2 * arch/s390/kernel/signal32.c
5 * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
7 * Gerhard Tonn (ton@de.ibm.com)
9 * Copyright (C) 1991, 1992 Linus Torvalds
11 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
14 #include <linux/config.h>
15 #include <linux/compat.h>
16 #include <linux/sched.h>
18 #include <linux/smp.h>
19 #include <linux/smp_lock.h>
20 #include <linux/kernel.h>
21 #include <linux/signal.h>
22 #include <linux/errno.h>
23 #include <linux/wait.h>
24 #include <linux/ptrace.h>
25 #include <linux/unistd.h>
26 #include <linux/stddef.h>
27 #include <linux/tty.h>
28 #include <linux/personality.h>
29 #include <linux/binfmts.h>
30 #include <asm/ucontext.h>
31 #include <asm/uaccess.h>
32 #include <asm/lowcore.h>
33 #include "compat_linux.h"
34 #include "compat_ptrace.h"
36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
40 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
41 struct sigcontext32 sc;
44 __u8 retcode[S390_SYSCALL_SIZE];
49 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
50 __u8 retcode[S390_SYSCALL_SIZE];
51 struct siginfo32 info;
55 asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
57 int copy_siginfo_to_user32(siginfo_t32 __user *to, siginfo_t *from)
61 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
64 /* If you change siginfo_t structure, please be sure
65 this code is fixed accordingly.
66 It should never copy any pad contained in the structure
67 to avoid security leaks, but must copy the generic
68 3 ints plus the relevant union member.
69 This routine must convert siginfo from 64bit to 32bit as well
71 err = __put_user(from->si_signo, &to->si_signo);
72 err |= __put_user(from->si_errno, &to->si_errno);
73 err |= __put_user((short)from->si_code, &to->si_code);
74 if (from->si_code < 0)
75 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
77 switch (from->si_code >> 16) {
78 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
79 case __SI_MESGQ >> 16:
80 err |= __put_user(from->si_int, &to->si_int);
83 err |= __put_user(from->si_pid, &to->si_pid);
84 err |= __put_user(from->si_uid, &to->si_uid);
87 err |= __put_user(from->si_pid, &to->si_pid);
88 err |= __put_user(from->si_uid, &to->si_uid);
89 err |= __put_user(from->si_utime, &to->si_utime);
90 err |= __put_user(from->si_stime, &to->si_stime);
91 err |= __put_user(from->si_status, &to->si_status);
93 case __SI_FAULT >> 16:
94 err |= __put_user((unsigned long) from->si_addr,
98 case __SI_TIMER >> 16:
99 err |= __put_user(from->si_band, &to->si_band);
100 err |= __put_user(from->si_fd, &to->si_fd);
109 int copy_siginfo_from_user32(siginfo_t *to, siginfo_t32 __user *from)
114 if (!access_ok (VERIFY_READ, from, sizeof(siginfo_t32)))
117 err = __get_user(to->si_signo, &from->si_signo);
118 err |= __get_user(to->si_errno, &from->si_errno);
119 err |= __get_user(to->si_code, &from->si_code);
122 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
124 switch (to->si_code >> 16) {
125 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
126 case __SI_MESGQ >> 16:
127 err |= __get_user(to->si_int, &from->si_int);
129 case __SI_KILL >> 16:
130 err |= __get_user(to->si_pid, &from->si_pid);
131 err |= __get_user(to->si_uid, &from->si_uid);
133 case __SI_CHLD >> 16:
134 err |= __get_user(to->si_pid, &from->si_pid);
135 err |= __get_user(to->si_uid, &from->si_uid);
136 err |= __get_user(to->si_utime, &from->si_utime);
137 err |= __get_user(to->si_stime, &from->si_stime);
138 err |= __get_user(to->si_status, &from->si_status);
140 case __SI_FAULT >> 16:
141 err |= __get_user(tmp, &from->si_addr);
142 to->si_addr = (void *)(u64) (tmp & PSW32_ADDR_INSN);
144 case __SI_POLL >> 16:
145 case __SI_TIMER >> 16:
146 err |= __get_user(to->si_band, &from->si_band);
147 err |= __get_user(to->si_fd, &from->si_fd);
157 * Atomically swap in the new signal mask, and wait for a signal.
160 sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
165 spin_lock_irq(¤t->sighand->siglock);
166 saveset = current->blocked;
167 siginitset(¤t->blocked, mask);
169 spin_unlock_irq(¤t->sighand->siglock);
170 regs->gprs[2] = -EINTR;
173 set_current_state(TASK_INTERRUPTIBLE);
175 if (do_signal(regs, &saveset))
181 sys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset,
184 sigset_t saveset, newset;
185 compat_sigset_t set32;
187 /* XXX: Don't preclude handling different sized sigset_t's. */
188 if (sigsetsize != sizeof(sigset_t))
191 if (copy_from_user(&set32, unewset, sizeof(set32)))
193 switch (_NSIG_WORDS) {
194 case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
195 case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
196 case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
197 case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
199 sigdelsetmask(&newset, ~_BLOCKABLE);
201 spin_lock_irq(¤t->sighand->siglock);
202 saveset = current->blocked;
203 current->blocked = newset;
205 spin_unlock_irq(¤t->sighand->siglock);
206 regs->gprs[2] = -EINTR;
209 set_current_state(TASK_INTERRUPTIBLE);
211 if (do_signal(regs, &saveset))
217 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
218 struct old_sigaction32 __user *oact)
220 struct k_sigaction new_ka, old_ka;
221 unsigned long sa_handler, sa_restorer;
225 compat_old_sigset_t mask;
226 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
227 __get_user(sa_handler, &act->sa_handler) ||
228 __get_user(sa_restorer, &act->sa_restorer))
230 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
231 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
232 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
233 __get_user(mask, &act->sa_mask);
234 siginitset(&new_ka.sa.sa_mask, mask);
237 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
240 sa_handler = (unsigned long) old_ka.sa.sa_handler;
241 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
242 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
243 __put_user(sa_handler, &oact->sa_handler) ||
244 __put_user(sa_restorer, &oact->sa_restorer))
246 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
247 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
254 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
257 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
258 struct sigaction32 __user *oact, size_t sigsetsize)
260 struct k_sigaction new_ka, old_ka;
261 unsigned long sa_handler;
263 compat_sigset_t set32;
265 /* XXX: Don't preclude handling different sized sigset_t's. */
266 if (sigsetsize != sizeof(compat_sigset_t))
270 ret = get_user(sa_handler, &act->sa_handler);
271 ret |= __copy_from_user(&set32, &act->sa_mask,
272 sizeof(compat_sigset_t));
273 switch (_NSIG_WORDS) {
274 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
275 | (((long)set32.sig[7]) << 32);
276 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
277 | (((long)set32.sig[5]) << 32);
278 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
279 | (((long)set32.sig[3]) << 32);
280 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
281 | (((long)set32.sig[1]) << 32);
283 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
287 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
290 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
293 switch (_NSIG_WORDS) {
295 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
296 set32.sig[6] = old_ka.sa.sa_mask.sig[3];
298 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
299 set32.sig[4] = old_ka.sa.sa_mask.sig[2];
301 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
302 set32.sig[2] = old_ka.sa.sa_mask.sig[1];
304 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
305 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
307 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
308 ret |= __copy_to_user(&oact->sa_mask, &set32,
309 sizeof(compat_sigset_t));
310 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
317 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
318 struct pt_regs *regs)
323 mm_segment_t old_fs = get_fs();
326 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
328 err |= __get_user(ss_sp, &uss->ss_sp);
329 err |= __get_user(kss.ss_size, &uss->ss_size);
330 err |= __get_user(kss.ss_flags, &uss->ss_flags);
333 kss.ss_sp = (void *) ss_sp;
337 ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
338 (stack_t __user *) (uoss ? &koss : NULL),
343 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
345 ss_sp = (unsigned long) koss.ss_sp;
346 err |= __put_user(ss_sp, &uoss->ss_sp);
347 err |= __put_user(koss.ss_size, &uoss->ss_size);
348 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
355 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
357 _s390_regs_common32 regs32;
360 regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
361 (__u32)(regs->psw.mask >> 32));
362 regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
363 for (i = 0; i < NUM_GPRS; i++)
364 regs32.gprs[i] = (__u32) regs->gprs[i];
365 save_access_regs(current->thread.acrs);
366 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
367 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32));
370 save_fp_regs(¤t->thread.fp_regs);
371 /* s390_fp_regs and _s390_fp_regs32 are the same ! */
372 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
373 sizeof(_s390_fp_regs32));
376 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
378 _s390_regs_common32 regs32;
381 /* Alwys make any pending restarted system call return -EINTR */
382 current_thread_info()->restart_block.fn = do_no_restart_syscall;
384 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32));
387 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
388 (__u64)regs32.psw.mask << 32);
389 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
390 for (i = 0; i < NUM_GPRS; i++)
391 regs->gprs[i] = (__u64) regs32.gprs[i];
392 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
393 restore_access_regs(current->thread.acrs);
395 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
396 sizeof(_s390_fp_regs32));
397 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
401 restore_fp_regs(¤t->thread.fp_regs);
402 regs->trap = -1; /* disable syscall checks */
406 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
408 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
411 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
413 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
416 sigdelsetmask(&set, ~_BLOCKABLE);
417 spin_lock_irq(¤t->sighand->siglock);
418 current->blocked = set;
420 spin_unlock_irq(¤t->sighand->siglock);
422 if (restore_sigregs32(regs, &frame->sregs))
425 return regs->gprs[2];
428 force_sig(SIGSEGV, current);
432 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
434 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
439 mm_segment_t old_fs = get_fs();
441 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
443 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
446 sigdelsetmask(&set, ~_BLOCKABLE);
447 spin_lock_irq(¤t->sighand->siglock);
448 current->blocked = set;
450 spin_unlock_irq(¤t->sighand->siglock);
452 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
455 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
456 st.ss_sp = (void *) A((unsigned long)ss_sp);
457 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
458 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
462 /* It is more difficult to avoid calling this function than to
463 call it and ignore errors. */
465 do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]);
468 return regs->gprs[2];
471 force_sig(SIGSEGV, current);
476 * Set up a signal frame.
481 * Determine which stack to use..
483 static inline void __user *
484 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
488 /* Default to using normal stack */
489 sp = (unsigned long) A(regs->gprs[15]);
491 /* This is the X/Open sanctioned signal stack switching. */
492 if (ka->sa.sa_flags & SA_ONSTACK) {
493 if (! on_sig_stack(sp))
494 sp = current->sas_ss_sp + current->sas_ss_size;
497 /* This is the legacy signal stack switching. */
498 else if (!user_mode(regs) &&
499 !(ka->sa.sa_flags & SA_RESTORER) &&
500 ka->sa.sa_restorer) {
501 sp = (unsigned long) ka->sa.sa_restorer;
504 return (void __user *)((sp - frame_size) & -8ul);
507 static inline int map_signal(int sig)
509 if (current_thread_info()->exec_domain
510 && current_thread_info()->exec_domain->signal_invmap
512 return current_thread_info()->exec_domain->signal_invmap[sig];
517 static void setup_frame32(int sig, struct k_sigaction *ka,
518 sigset_t *set, struct pt_regs * regs)
520 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
521 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
524 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
527 if (save_sigregs32(regs, &frame->sregs))
529 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
532 /* Set up to return from userspace. If provided, use a stub
533 already in userspace. */
534 if (ka->sa.sa_flags & SA_RESTORER) {
535 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
537 regs->gprs[14] = (__u64) frame->retcode;
538 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
539 (u16 __user *)(frame->retcode)))
543 /* Set up backchain. */
544 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
547 /* Set up registers for signal handler */
548 regs->gprs[15] = (__u64) frame;
549 regs->psw.addr = (__u64) ka->sa.sa_handler;
551 regs->gprs[2] = map_signal(sig);
552 regs->gprs[3] = (__u64) &frame->sc;
554 /* We forgot to include these in the sigcontext.
555 To avoid breaking binary compatibility, they are passed as args. */
556 regs->gprs[4] = current->thread.trap_no;
557 regs->gprs[5] = current->thread.prot_addr;
559 /* Place signal number on stack to allow backtrace from handler. */
560 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
565 force_sigsegv(sig, current);
568 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
569 sigset_t *set, struct pt_regs * regs)
572 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
573 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
576 if (copy_siginfo_to_user32(&frame->info, info))
579 /* Create the ucontext. */
580 err |= __put_user(0, &frame->uc.uc_flags);
581 err |= __put_user(0, &frame->uc.uc_link);
582 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
583 err |= __put_user(sas_ss_flags(regs->gprs[15]),
584 &frame->uc.uc_stack.ss_flags);
585 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
586 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
587 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
591 /* Set up to return from userspace. If provided, use a stub
592 already in userspace. */
593 if (ka->sa.sa_flags & SA_RESTORER) {
594 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
596 regs->gprs[14] = (__u64) frame->retcode;
597 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
598 (u16 __user *)(frame->retcode));
601 /* Set up backchain. */
602 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
605 /* Set up registers for signal handler */
606 regs->gprs[15] = (__u64) frame;
607 regs->psw.addr = (__u64) ka->sa.sa_handler;
609 regs->gprs[2] = map_signal(sig);
610 regs->gprs[3] = (__u64) &frame->info;
611 regs->gprs[4] = (__u64) &frame->uc;
615 force_sigsegv(sig, current);
619 * OK, we're invoking a handler
623 handle_signal32(unsigned long sig, struct k_sigaction *ka,
624 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
626 /* Set up the stack frame */
627 if (ka->sa.sa_flags & SA_SIGINFO)
628 setup_rt_frame32(sig, ka, info, oldset, regs);
630 setup_frame32(sig, ka, oldset, regs);
632 if (!(ka->sa.sa_flags & SA_NODEFER)) {
633 spin_lock_irq(¤t->sighand->siglock);
634 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
635 sigaddset(¤t->blocked,sig);
637 spin_unlock_irq(¤t->sighand->siglock);