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;
43 __u8 retcode[S390_SYSCALL_SIZE];
48 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
49 __u8 retcode[S390_SYSCALL_SIZE];
50 struct siginfo32 info;
54 asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
56 int copy_siginfo_to_user32(siginfo_t32 __user *to, siginfo_t *from)
60 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
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 case __SI_TIMER >> 16:
98 err |= __put_user(from->si_band, &to->si_band);
99 err |= __put_user(from->si_fd, &to->si_fd);
109 * Atomically swap in the new signal mask, and wait for a signal.
112 sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
117 spin_lock_irq(¤t->sighand->siglock);
118 saveset = current->blocked;
119 siginitset(¤t->blocked, mask);
121 spin_unlock_irq(¤t->sighand->siglock);
122 regs->gprs[2] = -EINTR;
125 set_current_state(TASK_INTERRUPTIBLE);
127 if (do_signal(regs, &saveset))
133 sys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset,
136 sigset_t saveset, newset;
137 compat_sigset_t set32;
139 /* XXX: Don't preclude handling different sized sigset_t's. */
140 if (sigsetsize != sizeof(sigset_t))
143 if (copy_from_user(&set32, unewset, sizeof(set32)))
145 switch (_NSIG_WORDS) {
146 case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
147 case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
148 case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
149 case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
151 sigdelsetmask(&newset, ~_BLOCKABLE);
153 spin_lock_irq(¤t->sighand->siglock);
154 saveset = current->blocked;
155 current->blocked = newset;
157 spin_unlock_irq(¤t->sighand->siglock);
158 regs->gprs[2] = -EINTR;
161 set_current_state(TASK_INTERRUPTIBLE);
163 if (do_signal(regs, &saveset))
169 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
170 struct old_sigaction32 __user *oact)
172 struct k_sigaction new_ka, old_ka;
176 compat_old_sigset_t mask;
177 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
178 __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||
179 __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))
181 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
182 __get_user(mask, &act->sa_mask);
183 siginitset(&new_ka.sa.sa_mask, mask);
186 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
189 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
190 __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||
191 __put_user((unsigned long)old_ka.sa.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);
201 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
204 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
205 struct sigaction32 __user *oact, size_t sigsetsize)
207 struct k_sigaction new_ka, old_ka;
209 compat_sigset_t set32;
211 /* XXX: Don't preclude handling different sized sigset_t's. */
212 if (sigsetsize != sizeof(compat_sigset_t))
216 ret = get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler);
217 ret |= __copy_from_user(&set32, &act->sa_mask,
218 sizeof(compat_sigset_t));
219 switch (_NSIG_WORDS) {
220 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
221 | (((long)set32.sig[7]) << 32);
222 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
223 | (((long)set32.sig[5]) << 32);
224 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
225 | (((long)set32.sig[3]) << 32);
226 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
227 | (((long)set32.sig[1]) << 32);
229 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
235 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
238 switch (_NSIG_WORDS) {
240 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
241 set32.sig[6] = old_ka.sa.sa_mask.sig[3];
243 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
244 set32.sig[4] = old_ka.sa.sa_mask.sig[2];
246 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
247 set32.sig[2] = old_ka.sa.sa_mask.sig[1];
249 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
250 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
252 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
253 ret |= __copy_to_user(&oact->sa_mask, &set32,
254 sizeof(compat_sigset_t));
255 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
262 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
263 struct pt_regs *regs)
267 mm_segment_t old_fs = get_fs();
270 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
272 err |= __get_user((unsigned long) kss.ss_sp, &uss->ss_sp);
273 err |= __get_user(kss.ss_size, &uss->ss_size);
274 err |= __get_user(kss.ss_flags, &uss->ss_flags);
280 ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
281 (stack_t __user *) (uoss ? &koss : NULL),
286 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
288 err |= __put_user((unsigned long) koss.ss_sp, &uoss->ss_sp);
289 err |= __put_user(koss.ss_size, &uoss->ss_size);
290 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
297 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
299 _s390_regs_common32 regs32;
302 regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
303 (__u32)(regs->psw.mask >> 32));
304 regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
305 for (i = 0; i < NUM_GPRS; i++)
306 regs32.gprs[i] = (__u32) regs->gprs[i];
307 save_access_regs(current->thread.acrs);
308 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
309 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32));
312 save_fp_regs(¤t->thread.fp_regs);
313 /* s390_fp_regs and _s390_fp_regs32 are the same ! */
314 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
315 sizeof(_s390_fp_regs32));
318 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
320 _s390_regs_common32 regs32;
323 /* Alwys make any pending restarted system call return -EINTR */
324 current_thread_info()->restart_block.fn = do_no_restart_syscall;
326 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32));
329 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
330 (__u64)regs32.psw.mask << 32);
331 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
332 for (i = 0; i < NUM_GPRS; i++)
333 regs->gprs[i] = (__u64) regs32.gprs[i];
334 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
335 restore_access_regs(current->thread.acrs);
337 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
338 sizeof(_s390_fp_regs32));
339 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
343 restore_fp_regs(¤t->thread.fp_regs);
344 regs->trap = -1; /* disable syscall checks */
348 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
350 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
353 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
355 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
358 sigdelsetmask(&set, ~_BLOCKABLE);
359 spin_lock_irq(¤t->sighand->siglock);
360 current->blocked = set;
362 spin_unlock_irq(¤t->sighand->siglock);
364 if (restore_sigregs32(regs, &frame->sregs))
367 return regs->gprs[2];
370 force_sig(SIGSEGV, current);
374 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
376 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
381 mm_segment_t old_fs = get_fs();
383 if (verify_area(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 = (void *) A((unsigned long)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);
404 /* It is more difficult to avoid calling this function than to
405 call it and ignore errors. */
407 do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]);
410 return regs->gprs[2];
413 force_sig(SIGSEGV, current);
418 * Set up a signal frame.
423 * Determine which stack to use..
425 static inline void __user *
426 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
430 /* Default to using normal stack */
431 sp = (unsigned long) A(regs->gprs[15]);
433 /* This is the X/Open sanctioned signal stack switching. */
434 if (ka->sa.sa_flags & SA_ONSTACK) {
435 if (! on_sig_stack(sp))
436 sp = current->sas_ss_sp + current->sas_ss_size;
439 /* This is the legacy signal stack switching. */
440 else if (!user_mode(regs) &&
441 !(ka->sa.sa_flags & SA_RESTORER) &&
442 ka->sa.sa_restorer) {
443 sp = (unsigned long) ka->sa.sa_restorer;
446 return (void __user *)((sp - frame_size) & -8ul);
449 static inline int map_signal(int sig)
451 if (current_thread_info()->exec_domain
452 && current_thread_info()->exec_domain->signal_invmap
454 return current_thread_info()->exec_domain->signal_invmap[sig];
459 static void setup_frame32(int sig, struct k_sigaction *ka,
460 sigset_t *set, struct pt_regs * regs)
462 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
463 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
466 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
469 if (save_sigregs32(regs, &frame->sregs))
471 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
474 /* Set up to return from userspace. If provided, use a stub
475 already in userspace. */
476 if (ka->sa.sa_flags & SA_RESTORER) {
477 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
479 regs->gprs[14] = (__u64) frame->retcode;
480 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
481 (u16 __user *)(frame->retcode)))
485 /* Set up backchain. */
486 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
489 /* Set up registers for signal handler */
490 regs->gprs[15] = (__u64) frame;
491 regs->psw.addr = (__u64) ka->sa.sa_handler;
493 regs->gprs[2] = map_signal(sig);
494 regs->gprs[3] = (__u64) &frame->sc;
496 /* We forgot to include these in the sigcontext.
497 To avoid breaking binary compatibility, they are passed as args. */
498 regs->gprs[4] = current->thread.trap_no;
499 regs->gprs[5] = current->thread.prot_addr;
504 ka->sa.sa_handler = SIG_DFL;
505 force_sig(SIGSEGV, current);
508 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
509 sigset_t *set, struct pt_regs * regs)
512 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
513 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
516 if (copy_siginfo_to_user32(&frame->info, info))
519 /* Create the ucontext. */
520 err |= __put_user(0, &frame->uc.uc_flags);
521 err |= __put_user(0, &frame->uc.uc_link);
522 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
523 err |= __put_user(sas_ss_flags(regs->gprs[15]),
524 &frame->uc.uc_stack.ss_flags);
525 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
526 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
527 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
531 /* Set up to return from userspace. If provided, use a stub
532 already in userspace. */
533 if (ka->sa.sa_flags & SA_RESTORER) {
534 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
536 regs->gprs[14] = (__u64) frame->retcode;
537 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
538 (u16 __user *)(frame->retcode));
541 /* Set up backchain. */
542 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
545 /* Set up registers for signal handler */
546 regs->gprs[15] = (__u64) frame;
547 regs->psw.addr = (__u64) ka->sa.sa_handler;
549 regs->gprs[2] = map_signal(sig);
550 regs->gprs[3] = (__u64) &frame->info;
551 regs->gprs[4] = (__u64) &frame->uc;
556 ka->sa.sa_handler = SIG_DFL;
557 force_sig(SIGSEGV, current);
561 * OK, we're invoking a handler
565 handle_signal32(unsigned long sig, siginfo_t *info, sigset_t *oldset,
566 struct pt_regs * regs)
568 struct k_sigaction *ka = ¤t->sighand->action[sig-1];
570 /* Set up the stack frame */
571 if (ka->sa.sa_flags & SA_SIGINFO)
572 setup_rt_frame32(sig, ka, info, oldset, regs);
574 setup_frame32(sig, ka, oldset, regs);
576 if (ka->sa.sa_flags & SA_ONESHOT)
577 ka->sa.sa_handler = SIG_DFL;
579 if (!(ka->sa.sa_flags & SA_NODEFER)) {
580 spin_lock_irq(¤t->sighand->siglock);
581 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
582 sigaddset(¤t->blocked,sig);
584 spin_unlock_irq(¤t->sighand->siglock);