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 "compat_linux.h"
31 #include "compat_ptrace.h"
33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
37 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
38 struct sigcontext32 sc;
41 __u8 retcode[S390_SYSCALL_SIZE];
46 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
47 __u8 retcode[S390_SYSCALL_SIZE];
48 compat_siginfo_t info;
52 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
56 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
59 /* If you change siginfo_t structure, please be sure
60 this code is fixed accordingly.
61 It should never copy any pad contained in the structure
62 to avoid security leaks, but must copy the generic
63 3 ints plus the relevant union member.
64 This routine must convert siginfo from 64bit to 32bit as well
66 err = __put_user(from->si_signo, &to->si_signo);
67 err |= __put_user(from->si_errno, &to->si_errno);
68 err |= __put_user((short)from->si_code, &to->si_code);
69 if (from->si_code < 0)
70 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
72 switch (from->si_code >> 16) {
73 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
74 case __SI_MESGQ >> 16:
75 err |= __put_user(from->si_int, &to->si_int);
78 err |= __put_user(from->si_pid, &to->si_pid);
79 err |= __put_user(from->si_uid, &to->si_uid);
82 err |= __put_user(from->si_pid, &to->si_pid);
83 err |= __put_user(from->si_uid, &to->si_uid);
84 err |= __put_user(from->si_utime, &to->si_utime);
85 err |= __put_user(from->si_stime, &to->si_stime);
86 err |= __put_user(from->si_status, &to->si_status);
88 case __SI_FAULT >> 16:
89 err |= __put_user((unsigned long) from->si_addr,
93 err |= __put_user(from->si_band, &to->si_band);
94 err |= __put_user(from->si_fd, &to->si_fd);
96 case __SI_TIMER >> 16:
97 err |= __put_user(from->si_tid, &to->si_tid);
98 err |= __put_user(from->si_overrun, &to->si_overrun);
99 err |= __put_user(from->si_int, &to->si_int);
108 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
113 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
116 err = __get_user(to->si_signo, &from->si_signo);
117 err |= __get_user(to->si_errno, &from->si_errno);
118 err |= __get_user(to->si_code, &from->si_code);
121 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
123 switch (to->si_code >> 16) {
124 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
125 case __SI_MESGQ >> 16:
126 err |= __get_user(to->si_int, &from->si_int);
128 case __SI_KILL >> 16:
129 err |= __get_user(to->si_pid, &from->si_pid);
130 err |= __get_user(to->si_uid, &from->si_uid);
132 case __SI_CHLD >> 16:
133 err |= __get_user(to->si_pid, &from->si_pid);
134 err |= __get_user(to->si_uid, &from->si_uid);
135 err |= __get_user(to->si_utime, &from->si_utime);
136 err |= __get_user(to->si_stime, &from->si_stime);
137 err |= __get_user(to->si_status, &from->si_status);
139 case __SI_FAULT >> 16:
140 err |= __get_user(tmp, &from->si_addr);
141 to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN);
143 case __SI_POLL >> 16:
144 err |= __get_user(to->si_band, &from->si_band);
145 err |= __get_user(to->si_fd, &from->si_fd);
147 case __SI_TIMER >> 16:
148 err |= __get_user(to->si_tid, &from->si_tid);
149 err |= __get_user(to->si_overrun, &from->si_overrun);
150 err |= __get_user(to->si_int, &from->si_int);
160 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
161 struct old_sigaction32 __user *oact)
163 struct k_sigaction new_ka, old_ka;
164 unsigned long sa_handler, sa_restorer;
168 compat_old_sigset_t mask;
169 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
170 __get_user(sa_handler, &act->sa_handler) ||
171 __get_user(sa_restorer, &act->sa_restorer) ||
172 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
173 __get_user(mask, &act->sa_mask))
175 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
176 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
177 siginitset(&new_ka.sa.sa_mask, mask);
180 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
183 sa_handler = (unsigned long) old_ka.sa.sa_handler;
184 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
185 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
186 __put_user(sa_handler, &oact->sa_handler) ||
187 __put_user(sa_restorer, &oact->sa_restorer) ||
188 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
189 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
197 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
198 struct sigaction32 __user *oact, size_t sigsetsize)
200 struct k_sigaction new_ka, old_ka;
201 unsigned long sa_handler;
203 compat_sigset_t set32;
205 /* XXX: Don't preclude handling different sized sigset_t's. */
206 if (sigsetsize != sizeof(compat_sigset_t))
210 ret = get_user(sa_handler, &act->sa_handler);
211 ret |= __copy_from_user(&set32, &act->sa_mask,
212 sizeof(compat_sigset_t));
213 switch (_NSIG_WORDS) {
214 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
215 | (((long)set32.sig[7]) << 32);
216 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
217 | (((long)set32.sig[5]) << 32);
218 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
219 | (((long)set32.sig[3]) << 32);
220 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
221 | (((long)set32.sig[1]) << 32);
223 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
227 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
230 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
233 switch (_NSIG_WORDS) {
235 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
236 set32.sig[6] = old_ka.sa.sa_mask.sig[3];
238 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
239 set32.sig[4] = old_ka.sa.sa_mask.sig[2];
241 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
242 set32.sig[2] = old_ka.sa.sa_mask.sig[1];
244 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
245 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
247 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
248 ret |= __copy_to_user(&oact->sa_mask, &set32,
249 sizeof(compat_sigset_t));
250 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
257 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
259 struct pt_regs *regs = task_pt_regs(current);
263 mm_segment_t old_fs = get_fs();
266 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
268 err |= __get_user(ss_sp, &uss->ss_sp);
269 err |= __get_user(kss.ss_size, &uss->ss_size);
270 err |= __get_user(kss.ss_flags, &uss->ss_flags);
273 kss.ss_sp = (void __user *) ss_sp;
277 ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
278 (stack_t __force __user *) (uoss ? &koss : NULL),
283 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
285 ss_sp = (unsigned long) koss.ss_sp;
286 err |= __put_user(ss_sp, &uoss->ss_sp);
287 err |= __put_user(koss.ss_size, &uoss->ss_size);
288 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
295 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
297 _s390_regs_common32 regs32;
300 regs32.psw.mask = PSW32_MASK_MERGE(psw32_user_bits,
301 (__u32)(regs->psw.mask >> 32));
302 regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
303 for (i = 0; i < NUM_GPRS; i++)
304 regs32.gprs[i] = (__u32) regs->gprs[i];
305 save_access_regs(current->thread.acrs);
306 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
307 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32));
310 save_fp_regs(¤t->thread.fp_regs);
311 /* s390_fp_regs and _s390_fp_regs32 are the same ! */
312 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
313 sizeof(_s390_fp_regs32));
316 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
318 _s390_regs_common32 regs32;
321 /* Alwys make any pending restarted system call return -EINTR */
322 current_thread_info()->restart_block.fn = do_no_restart_syscall;
324 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32));
327 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
328 (__u64)regs32.psw.mask << 32);
329 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
330 for (i = 0; i < NUM_GPRS; i++)
331 regs->gprs[i] = (__u64) regs32.gprs[i];
332 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
333 restore_access_regs(current->thread.acrs);
335 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
336 sizeof(_s390_fp_regs32));
337 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
341 restore_fp_regs(¤t->thread.fp_regs);
342 regs->trap = -1; /* disable syscall checks */
346 asmlinkage long sys32_sigreturn(void)
348 struct pt_regs *regs = task_pt_regs(current);
349 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
352 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
354 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
357 sigdelsetmask(&set, ~_BLOCKABLE);
358 spin_lock_irq(¤t->sighand->siglock);
359 current->blocked = set;
361 spin_unlock_irq(¤t->sighand->siglock);
363 if (restore_sigregs32(regs, &frame->sregs))
366 return regs->gprs[2];
369 force_sig(SIGSEGV, current);
373 asmlinkage long sys32_rt_sigreturn(void)
375 struct pt_regs *regs = task_pt_regs(current);
376 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
381 mm_segment_t old_fs = get_fs();
383 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
385 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
388 sigdelsetmask(&set, ~_BLOCKABLE);
389 spin_lock_irq(¤t->sighand->siglock);
390 current->blocked = set;
392 spin_unlock_irq(¤t->sighand->siglock);
394 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
397 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
398 st.ss_sp = compat_ptr(ss_sp);
399 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
400 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
405 do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
408 return regs->gprs[2];
411 force_sig(SIGSEGV, current);
416 * Set up a signal frame.
421 * Determine which stack to use..
423 static inline void __user *
424 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
428 /* Default to using normal stack */
429 sp = (unsigned long) A(regs->gprs[15]);
431 /* Overflow on alternate signal stack gives SIGSEGV. */
432 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
433 return (void __user *) -1UL;
435 /* This is the X/Open sanctioned signal stack switching. */
436 if (ka->sa.sa_flags & SA_ONSTACK) {
437 if (! sas_ss_flags(sp))
438 sp = current->sas_ss_sp + current->sas_ss_size;
441 /* This is the legacy signal stack switching. */
442 else if (!user_mode(regs) &&
443 !(ka->sa.sa_flags & SA_RESTORER) &&
444 ka->sa.sa_restorer) {
445 sp = (unsigned long) ka->sa.sa_restorer;
448 return (void __user *)((sp - frame_size) & -8ul);
451 static inline int map_signal(int sig)
453 if (current_thread_info()->exec_domain
454 && current_thread_info()->exec_domain->signal_invmap
456 return current_thread_info()->exec_domain->signal_invmap[sig];
461 static int setup_frame32(int sig, struct k_sigaction *ka,
462 sigset_t *set, struct pt_regs * regs)
464 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
465 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
468 if (frame == (void __user *) -1UL)
471 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
474 if (save_sigregs32(regs, &frame->sregs))
476 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
479 /* Set up to return from userspace. If provided, use a stub
480 already in userspace. */
481 if (ka->sa.sa_flags & SA_RESTORER) {
482 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
484 regs->gprs[14] = (__u64) frame->retcode;
485 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
486 (u16 __user *)(frame->retcode)))
490 /* Set up backchain. */
491 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
494 /* Set up registers for signal handler */
495 regs->gprs[15] = (__u64) frame;
496 regs->psw.addr = (__u64) ka->sa.sa_handler;
498 regs->gprs[2] = map_signal(sig);
499 regs->gprs[3] = (__u64) &frame->sc;
501 /* We forgot to include these in the sigcontext.
502 To avoid breaking binary compatibility, they are passed as args. */
503 regs->gprs[4] = current->thread.trap_no;
504 regs->gprs[5] = current->thread.prot_addr;
506 /* Place signal number on stack to allow backtrace from handler. */
507 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
512 force_sigsegv(sig, current);
516 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
517 sigset_t *set, struct pt_regs * regs)
520 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
521 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
524 if (frame == (void __user *) -1UL)
527 if (copy_siginfo_to_user32(&frame->info, info))
530 /* Create the ucontext. */
531 err |= __put_user(0, &frame->uc.uc_flags);
532 err |= __put_user(0, &frame->uc.uc_link);
533 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
534 err |= __put_user(sas_ss_flags(regs->gprs[15]),
535 &frame->uc.uc_stack.ss_flags);
536 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
537 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
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;
547 regs->gprs[14] = (__u64) frame->retcode;
548 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
549 (u16 __user *)(frame->retcode));
552 /* Set up backchain. */
553 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
556 /* Set up registers for signal handler */
557 regs->gprs[15] = (__u64) frame;
558 regs->psw.addr = (__u64) ka->sa.sa_handler;
560 regs->gprs[2] = map_signal(sig);
561 regs->gprs[3] = (__u64) &frame->info;
562 regs->gprs[4] = (__u64) &frame->uc;
566 force_sigsegv(sig, current);
571 * OK, we're invoking a handler
575 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 spin_lock_irq(¤t->sighand->siglock);
588 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
589 if (!(ka->sa.sa_flags & SA_NODEFER))
590 sigaddset(¤t->blocked,sig);
592 spin_unlock_irq(¤t->sighand->siglock);