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);
121 if (from->si_code < 0)
122 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
124 switch (from->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;
224 compat_old_sigset_t mask;
225 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
226 __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||
227 __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))
229 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
230 __get_user(mask, &act->sa_mask);
231 siginitset(&new_ka.sa.sa_mask, mask);
234 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
237 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
238 __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||
239 __put_user((unsigned long)old_ka.sa.sa_restorer, &oact->sa_restorer))
241 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
242 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
249 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
252 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
253 struct sigaction32 __user *oact, size_t sigsetsize)
255 struct k_sigaction new_ka, old_ka;
257 compat_sigset_t set32;
259 /* XXX: Don't preclude handling different sized sigset_t's. */
260 if (sigsetsize != sizeof(compat_sigset_t))
264 ret = get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler);
265 ret |= __copy_from_user(&set32, &act->sa_mask,
266 sizeof(compat_sigset_t));
267 switch (_NSIG_WORDS) {
268 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
269 | (((long)set32.sig[7]) << 32);
270 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
271 | (((long)set32.sig[5]) << 32);
272 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
273 | (((long)set32.sig[3]) << 32);
274 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
275 | (((long)set32.sig[1]) << 32);
277 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
283 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
286 switch (_NSIG_WORDS) {
288 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
289 set32.sig[6] = old_ka.sa.sa_mask.sig[3];
291 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
292 set32.sig[4] = old_ka.sa.sa_mask.sig[2];
294 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
295 set32.sig[2] = old_ka.sa.sa_mask.sig[1];
297 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
298 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
300 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
301 ret |= __copy_to_user(&oact->sa_mask, &set32,
302 sizeof(compat_sigset_t));
303 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
310 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
311 struct pt_regs *regs)
315 mm_segment_t old_fs = get_fs();
318 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
320 err |= __get_user((unsigned long) kss.ss_sp, &uss->ss_sp);
321 err |= __get_user(kss.ss_size, &uss->ss_size);
322 err |= __get_user(kss.ss_flags, &uss->ss_flags);
328 ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
329 (stack_t __user *) (uoss ? &koss : NULL),
334 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
336 err |= __put_user((unsigned long) koss.ss_sp, &uoss->ss_sp);
337 err |= __put_user(koss.ss_size, &uoss->ss_size);
338 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
345 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
347 _s390_regs_common32 regs32;
350 regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
351 (__u32)(regs->psw.mask >> 32));
352 regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
353 for (i = 0; i < NUM_GPRS; i++)
354 regs32.gprs[i] = (__u32) regs->gprs[i];
355 save_access_regs(current->thread.acrs);
356 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
357 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32));
360 save_fp_regs(¤t->thread.fp_regs);
361 /* s390_fp_regs and _s390_fp_regs32 are the same ! */
362 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
363 sizeof(_s390_fp_regs32));
366 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
368 _s390_regs_common32 regs32;
371 /* Alwys make any pending restarted system call return -EINTR */
372 current_thread_info()->restart_block.fn = do_no_restart_syscall;
374 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32));
377 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
378 (__u64)regs32.psw.mask << 32);
379 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
380 for (i = 0; i < NUM_GPRS; i++)
381 regs->gprs[i] = (__u64) regs32.gprs[i];
382 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
383 restore_access_regs(current->thread.acrs);
385 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
386 sizeof(_s390_fp_regs32));
387 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
391 restore_fp_regs(¤t->thread.fp_regs);
392 regs->trap = -1; /* disable syscall checks */
396 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
398 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
401 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
403 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
406 sigdelsetmask(&set, ~_BLOCKABLE);
407 spin_lock_irq(¤t->sighand->siglock);
408 current->blocked = set;
410 spin_unlock_irq(¤t->sighand->siglock);
412 if (restore_sigregs32(regs, &frame->sregs))
415 return regs->gprs[2];
418 force_sig(SIGSEGV, current);
422 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
424 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
429 mm_segment_t old_fs = get_fs();
431 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
433 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
436 sigdelsetmask(&set, ~_BLOCKABLE);
437 spin_lock_irq(¤t->sighand->siglock);
438 current->blocked = set;
440 spin_unlock_irq(¤t->sighand->siglock);
442 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
445 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
446 st.ss_sp = (void *) A((unsigned long)ss_sp);
447 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
448 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
452 /* It is more difficult to avoid calling this function than to
453 call it and ignore errors. */
455 do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]);
458 return regs->gprs[2];
461 force_sig(SIGSEGV, current);
466 * Set up a signal frame.
471 * Determine which stack to use..
473 static inline void __user *
474 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
478 /* Default to using normal stack */
479 sp = (unsigned long) A(regs->gprs[15]);
481 /* This is the X/Open sanctioned signal stack switching. */
482 if (ka->sa.sa_flags & SA_ONSTACK) {
483 if (! on_sig_stack(sp))
484 sp = current->sas_ss_sp + current->sas_ss_size;
487 /* This is the legacy signal stack switching. */
488 else if (!user_mode(regs) &&
489 !(ka->sa.sa_flags & SA_RESTORER) &&
490 ka->sa.sa_restorer) {
491 sp = (unsigned long) ka->sa.sa_restorer;
494 return (void __user *)((sp - frame_size) & -8ul);
497 static inline int map_signal(int sig)
499 if (current_thread_info()->exec_domain
500 && current_thread_info()->exec_domain->signal_invmap
502 return current_thread_info()->exec_domain->signal_invmap[sig];
507 static void setup_frame32(int sig, struct k_sigaction *ka,
508 sigset_t *set, struct pt_regs * regs)
510 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
511 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
514 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
517 if (save_sigregs32(regs, &frame->sregs))
519 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
522 /* Set up to return from userspace. If provided, use a stub
523 already in userspace. */
524 if (ka->sa.sa_flags & SA_RESTORER) {
525 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
527 regs->gprs[14] = (__u64) frame->retcode;
528 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
529 (u16 __user *)(frame->retcode)))
533 /* Set up backchain. */
534 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
537 /* Set up registers for signal handler */
538 regs->gprs[15] = (__u64) frame;
539 regs->psw.addr = (__u64) ka->sa.sa_handler;
541 regs->gprs[2] = map_signal(sig);
542 regs->gprs[3] = (__u64) &frame->sc;
544 /* We forgot to include these in the sigcontext.
545 To avoid breaking binary compatibility, they are passed as args. */
546 regs->gprs[4] = current->thread.trap_no;
547 regs->gprs[5] = current->thread.prot_addr;
549 /* Place signal number on stack to allow backtrace from handler. */
550 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
556 ka->sa.sa_handler = SIG_DFL;
557 force_sig(SIGSEGV, current);
560 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
561 sigset_t *set, struct pt_regs * regs)
564 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
565 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
568 if (copy_siginfo_to_user32(&frame->info, info))
571 /* Create the ucontext. */
572 err |= __put_user(0, &frame->uc.uc_flags);
573 err |= __put_user(0, &frame->uc.uc_link);
574 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
575 err |= __put_user(sas_ss_flags(regs->gprs[15]),
576 &frame->uc.uc_stack.ss_flags);
577 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
578 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
579 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
583 /* Set up to return from userspace. If provided, use a stub
584 already in userspace. */
585 if (ka->sa.sa_flags & SA_RESTORER) {
586 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
588 regs->gprs[14] = (__u64) frame->retcode;
589 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
590 (u16 __user *)(frame->retcode));
593 /* Set up backchain. */
594 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
597 /* Set up registers for signal handler */
598 regs->gprs[15] = (__u64) frame;
599 regs->psw.addr = (__u64) ka->sa.sa_handler;
601 regs->gprs[2] = map_signal(sig);
602 regs->gprs[3] = (__u64) &frame->info;
603 regs->gprs[4] = (__u64) &frame->uc;
608 ka->sa.sa_handler = SIG_DFL;
609 force_sig(SIGSEGV, current);
613 * OK, we're invoking a handler
617 handle_signal32(unsigned long sig, siginfo_t *info, sigset_t *oldset,
618 struct pt_regs * regs)
620 struct k_sigaction *ka = ¤t->sighand->action[sig-1];
622 /* Set up the stack frame */
623 if (ka->sa.sa_flags & SA_SIGINFO)
624 setup_rt_frame32(sig, ka, info, oldset, regs);
626 setup_frame32(sig, ka, oldset, regs);
628 if (ka->sa.sa_flags & SA_ONESHOT)
629 ka->sa.sa_handler = SIG_DFL;
631 if (!(ka->sa.sa_flags & SA_NODEFER)) {
632 spin_lock_irq(¤t->sighand->siglock);
633 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
634 sigaddset(¤t->blocked,sig);
636 spin_unlock_irq(¤t->sighand->siglock);