2 * arch/s390/kernel/compat_signal.c
4 * Copyright (C) IBM Corp. 2000,2006
5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 * Gerhard Tonn (ton@de.ibm.com)
8 * Copyright (C) 1991, 1992 Linus Torvalds
10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
13 #include <linux/compat.h>
14 #include <linux/sched.h>
16 #include <linux/smp.h>
17 #include <linux/kernel.h>
18 #include <linux/signal.h>
19 #include <linux/errno.h>
20 #include <linux/wait.h>
21 #include <linux/ptrace.h>
22 #include <linux/unistd.h>
23 #include <linux/stddef.h>
24 #include <linux/tty.h>
25 #include <linux/personality.h>
26 #include <linux/binfmts.h>
27 #include <asm/ucontext.h>
28 #include <asm/uaccess.h>
29 #include <asm/lowcore.h>
30 #include <asm/switch_to.h>
31 #include "compat_linux.h"
32 #include "compat_ptrace.h"
35 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
39 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
40 struct sigcontext32 sc;
43 __u32 gprs_high[NUM_GPRS];
44 __u8 retcode[S390_SYSCALL_SIZE];
49 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
50 __u8 retcode[S390_SYSCALL_SIZE];
51 compat_siginfo_t info;
53 __u32 gprs_high[NUM_GPRS];
56 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
60 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
63 /* If you change siginfo_t structure, please be sure
64 this code is fixed accordingly.
65 It should never copy any pad contained in the structure
66 to avoid security leaks, but must copy the generic
67 3 ints plus the relevant union member.
68 This routine must convert siginfo from 64bit to 32bit as well
70 err = __put_user(from->si_signo, &to->si_signo);
71 err |= __put_user(from->si_errno, &to->si_errno);
72 err |= __put_user((short)from->si_code, &to->si_code);
73 if (from->si_code < 0)
74 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
76 switch (from->si_code >> 16) {
77 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
78 case __SI_MESGQ >> 16:
79 err |= __put_user(from->si_int, &to->si_int);
82 err |= __put_user(from->si_pid, &to->si_pid);
83 err |= __put_user(from->si_uid, &to->si_uid);
86 err |= __put_user(from->si_pid, &to->si_pid);
87 err |= __put_user(from->si_uid, &to->si_uid);
88 err |= __put_user(from->si_utime, &to->si_utime);
89 err |= __put_user(from->si_stime, &to->si_stime);
90 err |= __put_user(from->si_status, &to->si_status);
92 case __SI_FAULT >> 16:
93 err |= __put_user((unsigned long) from->si_addr,
97 err |= __put_user(from->si_band, &to->si_band);
98 err |= __put_user(from->si_fd, &to->si_fd);
100 case __SI_TIMER >> 16:
101 err |= __put_user(from->si_tid, &to->si_tid);
102 err |= __put_user(from->si_overrun, &to->si_overrun);
103 err |= __put_user(from->si_int, &to->si_int);
112 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
117 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
120 err = __get_user(to->si_signo, &from->si_signo);
121 err |= __get_user(to->si_errno, &from->si_errno);
122 err |= __get_user(to->si_code, &from->si_code);
125 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
127 switch (to->si_code >> 16) {
128 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
129 case __SI_MESGQ >> 16:
130 err |= __get_user(to->si_int, &from->si_int);
132 case __SI_KILL >> 16:
133 err |= __get_user(to->si_pid, &from->si_pid);
134 err |= __get_user(to->si_uid, &from->si_uid);
136 case __SI_CHLD >> 16:
137 err |= __get_user(to->si_pid, &from->si_pid);
138 err |= __get_user(to->si_uid, &from->si_uid);
139 err |= __get_user(to->si_utime, &from->si_utime);
140 err |= __get_user(to->si_stime, &from->si_stime);
141 err |= __get_user(to->si_status, &from->si_status);
143 case __SI_FAULT >> 16:
144 err |= __get_user(tmp, &from->si_addr);
145 to->si_addr = (void __force __user *)
146 (u64) (tmp & PSW32_ADDR_INSN);
148 case __SI_POLL >> 16:
149 err |= __get_user(to->si_band, &from->si_band);
150 err |= __get_user(to->si_fd, &from->si_fd);
152 case __SI_TIMER >> 16:
153 err |= __get_user(to->si_tid, &from->si_tid);
154 err |= __get_user(to->si_overrun, &from->si_overrun);
155 err |= __get_user(to->si_int, &from->si_int);
165 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
166 struct old_sigaction32 __user *oact)
168 struct k_sigaction new_ka, old_ka;
169 unsigned long sa_handler, sa_restorer;
173 compat_old_sigset_t mask;
174 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
175 __get_user(sa_handler, &act->sa_handler) ||
176 __get_user(sa_restorer, &act->sa_restorer) ||
177 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
178 __get_user(mask, &act->sa_mask))
180 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
181 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
182 siginitset(&new_ka.sa.sa_mask, mask);
185 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
188 sa_handler = (unsigned long) old_ka.sa.sa_handler;
189 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
190 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
191 __put_user(sa_handler, &oact->sa_handler) ||
192 __put_user(sa_restorer, &oact->sa_restorer) ||
193 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
194 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
202 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
203 struct sigaction32 __user *oact, size_t sigsetsize)
205 struct k_sigaction new_ka, old_ka;
206 unsigned long sa_handler;
208 compat_sigset_t set32;
210 /* XXX: Don't preclude handling different sized sigset_t's. */
211 if (sigsetsize != sizeof(compat_sigset_t))
215 ret = get_user(sa_handler, &act->sa_handler);
216 ret |= __copy_from_user(&set32, &act->sa_mask,
217 sizeof(compat_sigset_t));
218 new_ka.sa.sa_mask.sig[0] =
219 set32.sig[0] | (((long)set32.sig[1]) << 32);
220 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
224 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
227 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
230 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
231 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
232 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
233 ret |= __copy_to_user(&oact->sa_mask, &set32,
234 sizeof(compat_sigset_t));
235 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
242 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
244 struct pt_regs *regs = task_pt_regs(current);
248 mm_segment_t old_fs = get_fs();
251 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
253 err |= __get_user(ss_sp, &uss->ss_sp);
254 err |= __get_user(kss.ss_size, &uss->ss_size);
255 err |= __get_user(kss.ss_flags, &uss->ss_flags);
258 kss.ss_sp = (void __user *) ss_sp;
262 ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
263 (stack_t __force __user *) (uoss ? &koss : NULL),
268 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
270 ss_sp = (unsigned long) koss.ss_sp;
271 err |= __put_user(ss_sp, &uoss->ss_sp);
272 err |= __put_user(koss.ss_size, &uoss->ss_size);
273 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
280 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
282 _s390_regs_common32 regs32;
285 regs32.psw.mask = psw32_user_bits |
286 ((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER);
287 regs32.psw.addr = (__u32) regs->psw.addr |
288 (__u32)(regs->psw.mask & PSW_MASK_BA);
289 for (i = 0; i < NUM_GPRS; i++)
290 regs32.gprs[i] = (__u32) regs->gprs[i];
291 save_access_regs(current->thread.acrs);
292 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
293 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32));
296 save_fp_regs(¤t->thread.fp_regs);
297 /* s390_fp_regs and _s390_fp_regs32 are the same ! */
298 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
299 sizeof(_s390_fp_regs32));
302 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
304 _s390_regs_common32 regs32;
307 /* Alwys make any pending restarted system call return -EINTR */
308 current_thread_info()->restart_block.fn = do_no_restart_syscall;
310 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32));
313 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
314 (__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 |
315 (__u64)(regs32.psw.addr & PSW32_ADDR_AMODE);
316 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
317 for (i = 0; i < NUM_GPRS; i++)
318 regs->gprs[i] = (__u64) regs32.gprs[i];
319 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
320 restore_access_regs(current->thread.acrs);
322 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
323 sizeof(_s390_fp_regs32));
324 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
328 restore_fp_regs(¤t->thread.fp_regs);
329 clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
333 static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
335 __u32 gprs_high[NUM_GPRS];
338 for (i = 0; i < NUM_GPRS; i++)
339 gprs_high[i] = regs->gprs[i] >> 32;
341 return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high));
344 static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
346 __u32 gprs_high[NUM_GPRS];
349 err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high));
352 for (i = 0; i < NUM_GPRS; i++)
353 *(__u32 *)®s->gprs[i] = gprs_high[i];
357 asmlinkage long sys32_sigreturn(void)
359 struct pt_regs *regs = task_pt_regs(current);
360 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
363 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
365 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
367 sigdelsetmask(&set, ~_BLOCKABLE);
368 set_current_blocked(&set);
369 if (restore_sigregs32(regs, &frame->sregs))
371 if (restore_sigregs_gprs_high(regs, frame->gprs_high))
373 return regs->gprs[2];
375 force_sig(SIGSEGV, current);
379 asmlinkage long sys32_rt_sigreturn(void)
381 struct pt_regs *regs = task_pt_regs(current);
382 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
387 mm_segment_t old_fs = get_fs();
389 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
391 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
393 sigdelsetmask(&set, ~_BLOCKABLE);
394 set_current_blocked(&set);
395 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
397 if (restore_sigregs_gprs_high(regs, frame->gprs_high))
399 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
400 st.ss_sp = compat_ptr(ss_sp);
401 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
402 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
406 do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
408 return regs->gprs[2];
410 force_sig(SIGSEGV, current);
415 * Set up a signal frame.
420 * Determine which stack to use..
422 static inline void __user *
423 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
427 /* Default to using normal stack */
428 sp = (unsigned long) A(regs->gprs[15]);
430 /* Overflow on alternate signal stack gives SIGSEGV. */
431 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
432 return (void __user *) -1UL;
434 /* This is the X/Open sanctioned signal stack switching. */
435 if (ka->sa.sa_flags & SA_ONSTACK) {
436 if (! sas_ss_flags(sp))
437 sp = current->sas_ss_sp + current->sas_ss_size;
440 return (void __user *)((sp - frame_size) & -8ul);
443 static inline int map_signal(int sig)
445 if (current_thread_info()->exec_domain
446 && current_thread_info()->exec_domain->signal_invmap
448 return current_thread_info()->exec_domain->signal_invmap[sig];
453 static int setup_frame32(int sig, struct k_sigaction *ka,
454 sigset_t *set, struct pt_regs * regs)
456 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
457 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
460 if (frame == (void __user *) -1UL)
463 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
466 if (save_sigregs32(regs, &frame->sregs))
468 if (save_sigregs_gprs_high(regs, frame->gprs_high))
470 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
473 /* Set up to return from userspace. If provided, use a stub
474 already in userspace. */
475 if (ka->sa.sa_flags & SA_RESTORER) {
476 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
478 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
479 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
480 (u16 __force __user *)(frame->retcode)))
484 /* Set up backchain. */
485 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
488 /* Set up registers for signal handler */
489 regs->gprs[15] = (__force __u64) frame;
490 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */
491 regs->psw.addr = (__force __u64) ka->sa.sa_handler;
493 regs->gprs[2] = map_signal(sig);
494 regs->gprs[3] = (__force __u64) &frame->sc;
496 /* We forgot to include these in the sigcontext.
497 To avoid breaking binary compatibility, they are passed as args. */
498 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
499 sig == SIGTRAP || sig == SIGFPE) {
500 /* set extra registers only for synchronous signals */
501 regs->gprs[4] = regs->int_code & 127;
502 regs->gprs[5] = regs->int_parm_long;
505 /* Place signal number on stack to allow backtrace from handler. */
506 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
511 force_sigsegv(sig, current);
515 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
516 sigset_t *set, struct pt_regs * regs)
519 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
520 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
523 if (frame == (void __user *) -1UL)
526 if (copy_siginfo_to_user32(&frame->info, info))
529 /* Create the ucontext. */
530 err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
531 err |= __put_user(0, &frame->uc.uc_link);
532 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
533 err |= __put_user(sas_ss_flags(regs->gprs[15]),
534 &frame->uc.uc_stack.ss_flags);
535 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
536 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
537 err |= save_sigregs_gprs_high(regs, frame->gprs_high);
538 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
542 /* Set up to return from userspace. If provided, use a stub
543 already in userspace. */
544 if (ka->sa.sa_flags & SA_RESTORER) {
545 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
547 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
548 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
549 (u16 __force __user *)(frame->retcode));
552 /* Set up backchain. */
553 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
556 /* Set up registers for signal handler */
557 regs->gprs[15] = (__force __u64) frame;
558 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */
559 regs->psw.addr = (__u64) ka->sa.sa_handler;
561 regs->gprs[2] = map_signal(sig);
562 regs->gprs[3] = (__force __u64) &frame->info;
563 regs->gprs[4] = (__force __u64) &frame->uc;
567 force_sigsegv(sig, current);
572 * OK, we're invoking a handler
575 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
576 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
580 /* Set up the stack frame */
581 if (ka->sa.sa_flags & SA_SIGINFO)
582 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
584 ret = setup_frame32(sig, ka, oldset, regs);
587 block_sigmask(ka, sig);