[S390] Protect against sigaltstack wraparound.
[deliverable/linux.git] / arch / s390 / kernel / signal.c
CommitLineData
1da177e4
LT
1/*
2 * arch/s390/kernel/signal.c
3 *
54dfe5dd 4 * Copyright (C) IBM Corp. 1999,2006
1da177e4
LT
5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 *
7 * Based on Intel version
8 *
9 * Copyright (C) 1991, 1992 Linus Torvalds
10 *
11 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
12 */
13
1da177e4
LT
14#include <linux/sched.h>
15#include <linux/mm.h>
16#include <linux/smp.h>
1da177e4
LT
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
31#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33
34typedef struct
35{
36 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
37 struct sigcontext sc;
38 _sigregs sregs;
39 int signo;
40 __u8 retcode[S390_SYSCALL_SIZE];
41} sigframe;
42
43typedef struct
44{
45 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
46 __u8 retcode[S390_SYSCALL_SIZE];
47 struct siginfo info;
48 struct ucontext uc;
49} rt_sigframe;
50
1da177e4
LT
51/*
52 * Atomically swap in the new signal mask, and wait for a signal.
53 */
54asmlinkage int
54dfe5dd 55sys_sigsuspend(int history0, int history1, old_sigset_t mask)
1da177e4 56{
1da177e4
LT
57 mask &= _BLOCKABLE;
58 spin_lock_irq(&current->sighand->siglock);
54dfe5dd 59 current->saved_sigmask = current->blocked;
1da177e4
LT
60 siginitset(&current->blocked, mask);
61 recalc_sigpending();
62 spin_unlock_irq(&current->sighand->siglock);
1da177e4 63
54dfe5dd
HC
64 current->state = TASK_INTERRUPTIBLE;
65 schedule();
66 set_thread_flag(TIF_RESTORE_SIGMASK);
1da177e4 67
54dfe5dd 68 return -ERESTARTNOHAND;
1da177e4
LT
69}
70
71asmlinkage long
72sys_sigaction(int sig, const struct old_sigaction __user *act,
73 struct old_sigaction __user *oact)
74{
75 struct k_sigaction new_ka, old_ka;
76 int ret;
77
78 if (act) {
79 old_sigset_t mask;
80 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
81 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
12bae235
HC
82 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
83 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
84 __get_user(mask, &act->sa_mask))
1da177e4 85 return -EFAULT;
1da177e4
LT
86 siginitset(&new_ka.sa.sa_mask, mask);
87 }
88
89 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
90
91 if (!ret && oact) {
92 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
93 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
12bae235
HC
94 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
95 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
96 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
1da177e4 97 return -EFAULT;
1da177e4
LT
98 }
99
100 return ret;
101}
102
103asmlinkage long
03ff9a23 104sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
1da177e4 105{
03ff9a23 106 struct pt_regs *regs = task_pt_regs(current);
1da177e4
LT
107 return do_sigaltstack(uss, uoss, regs->gprs[15]);
108}
109
110
111
112/* Returns non-zero on fault. */
113static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
114{
6837a8c3
GS
115 _sigregs user_sregs;
116
1da177e4
LT
117 save_access_regs(current->thread.acrs);
118
119 /* Copy a 'clean' PSW mask to the user to avoid leaking
120 information about whether PER is currently on. */
c1821c2e 121 user_sregs.regs.psw.mask = PSW_MASK_MERGE(psw_user_bits, regs->psw.mask);
b05e3703
MS
122 user_sregs.regs.psw.addr = regs->psw.addr;
123 memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
6837a8c3
GS
124 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
125 sizeof(sregs->regs.acrs));
1da177e4
LT
126 /*
127 * We have to store the fp registers to current->thread.fp_regs
128 * to merge them with the emulated registers.
129 */
130 save_fp_regs(&current->thread.fp_regs);
6837a8c3
GS
131 memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
132 sizeof(s390_fp_regs));
133 return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
1da177e4
LT
134}
135
136/* Returns positive number on error */
137static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
138{
1da177e4 139 int err;
6837a8c3 140 _sigregs user_sregs;
1da177e4
LT
141
142 /* Alwys make any pending restarted system call return -EINTR */
143 current_thread_info()->restart_block.fn = do_no_restart_syscall;
144
6837a8c3 145 err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
1da177e4
LT
146 if (err)
147 return err;
b05e3703
MS
148 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
149 user_sregs.regs.psw.mask);
150 regs->psw.addr = PSW_ADDR_AMODE | user_sregs.regs.psw.addr;
151 memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
6837a8c3
GS
152 memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
153 sizeof(sregs->regs.acrs));
1da177e4
LT
154 restore_access_regs(current->thread.acrs);
155
6837a8c3
GS
156 memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
157 sizeof(s390_fp_regs));
1da177e4 158 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
1da177e4
LT
159
160 restore_fp_regs(&current->thread.fp_regs);
161 regs->trap = -1; /* disable syscall checks */
162 return 0;
163}
164
03ff9a23 165asmlinkage long sys_sigreturn(void)
1da177e4 166{
03ff9a23 167 struct pt_regs *regs = task_pt_regs(current);
1da177e4
LT
168 sigframe __user *frame = (sigframe __user *)regs->gprs[15];
169 sigset_t set;
170
171 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
172 goto badframe;
173 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
174 goto badframe;
175
176 sigdelsetmask(&set, ~_BLOCKABLE);
177 spin_lock_irq(&current->sighand->siglock);
178 current->blocked = set;
179 recalc_sigpending();
180 spin_unlock_irq(&current->sighand->siglock);
181
182 if (restore_sigregs(regs, &frame->sregs))
183 goto badframe;
184
185 return regs->gprs[2];
186
187badframe:
188 force_sig(SIGSEGV, current);
189 return 0;
190}
191
03ff9a23 192asmlinkage long sys_rt_sigreturn(void)
1da177e4 193{
03ff9a23 194 struct pt_regs *regs = task_pt_regs(current);
1da177e4
LT
195 rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
196 sigset_t set;
197
198 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
199 goto badframe;
200 if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
201 goto badframe;
202
203 sigdelsetmask(&set, ~_BLOCKABLE);
204 spin_lock_irq(&current->sighand->siglock);
205 current->blocked = set;
206 recalc_sigpending();
207 spin_unlock_irq(&current->sighand->siglock);
208
209 if (restore_sigregs(regs, &frame->uc.uc_mcontext))
210 goto badframe;
211
4e3df37e
CLG
212 if (do_sigaltstack(&frame->uc.uc_stack, NULL,
213 regs->gprs[15]) == -EFAULT)
214 goto badframe;
1da177e4
LT
215 return regs->gprs[2];
216
217badframe:
218 force_sig(SIGSEGV, current);
219 return 0;
220}
221
222/*
223 * Set up a signal frame.
224 */
225
226
227/*
228 * Determine which stack to use..
229 */
230static inline void __user *
231get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
232{
233 unsigned long sp;
234
235 /* Default to using normal stack */
236 sp = regs->gprs[15];
237
de553438
HC
238 /* Overflow on alternate signal stack gives SIGSEGV. */
239 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
240 return (void __user *) -1UL;
241
1da177e4
LT
242 /* This is the X/Open sanctioned signal stack switching. */
243 if (ka->sa.sa_flags & SA_ONSTACK) {
244 if (! sas_ss_flags(sp))
245 sp = current->sas_ss_sp + current->sas_ss_size;
246 }
247
248 /* This is the legacy signal stack switching. */
249 else if (!user_mode(regs) &&
250 !(ka->sa.sa_flags & SA_RESTORER) &&
251 ka->sa.sa_restorer) {
252 sp = (unsigned long) ka->sa.sa_restorer;
253 }
254
255 return (void __user *)((sp - frame_size) & -8ul);
256}
257
258static inline int map_signal(int sig)
259{
260 if (current_thread_info()->exec_domain
261 && current_thread_info()->exec_domain->signal_invmap
262 && sig < 32)
263 return current_thread_info()->exec_domain->signal_invmap[sig];
264 else
265 return sig;
266}
267
54dfe5dd
HC
268static int setup_frame(int sig, struct k_sigaction *ka,
269 sigset_t *set, struct pt_regs * regs)
1da177e4
LT
270{
271 sigframe __user *frame;
272
273 frame = get_sigframe(ka, regs, sizeof(sigframe));
274 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
275 goto give_sigsegv;
276
de553438
HC
277 if (frame == (void __user *) -1UL)
278 goto give_sigsegv;
279
1da177e4
LT
280 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
281 goto give_sigsegv;
282
283 if (save_sigregs(regs, &frame->sregs))
284 goto give_sigsegv;
285 if (__put_user(&frame->sregs, &frame->sc.sregs))
286 goto give_sigsegv;
287
288 /* Set up to return from userspace. If provided, use a stub
289 already in userspace. */
290 if (ka->sa.sa_flags & SA_RESTORER) {
291 regs->gprs[14] = (unsigned long)
292 ka->sa.sa_restorer | PSW_ADDR_AMODE;
293 } else {
294 regs->gprs[14] = (unsigned long)
295 frame->retcode | PSW_ADDR_AMODE;
296 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
297 (u16 __user *)(frame->retcode)))
298 goto give_sigsegv;
299 }
300
301 /* Set up backchain. */
302 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
303 goto give_sigsegv;
304
305 /* Set up registers for signal handler */
306 regs->gprs[15] = (unsigned long) frame;
307 regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
308
309 regs->gprs[2] = map_signal(sig);
310 regs->gprs[3] = (unsigned long) &frame->sc;
311
312 /* We forgot to include these in the sigcontext.
313 To avoid breaking binary compatibility, they are passed as args. */
314 regs->gprs[4] = current->thread.trap_no;
315 regs->gprs[5] = current->thread.prot_addr;
316
317 /* Place signal number on stack to allow backtrace from handler. */
318 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
319 goto give_sigsegv;
54dfe5dd 320 return 0;
1da177e4
LT
321
322give_sigsegv:
323 force_sigsegv(sig, current);
54dfe5dd 324 return -EFAULT;
1da177e4
LT
325}
326
54dfe5dd 327static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
1da177e4
LT
328 sigset_t *set, struct pt_regs * regs)
329{
330 int err = 0;
331 rt_sigframe __user *frame;
332
333 frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
334 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
335 goto give_sigsegv;
336
de553438
HC
337 if (frame == (void __user *) -1UL)
338 goto give_sigsegv;
339
1da177e4
LT
340 if (copy_siginfo_to_user(&frame->info, info))
341 goto give_sigsegv;
342
343 /* Create the ucontext. */
344 err |= __put_user(0, &frame->uc.uc_flags);
c2814476
AV
345 err |= __put_user(NULL, &frame->uc.uc_link);
346 err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
1da177e4
LT
347 err |= __put_user(sas_ss_flags(regs->gprs[15]),
348 &frame->uc.uc_stack.ss_flags);
349 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
350 err |= save_sigregs(regs, &frame->uc.uc_mcontext);
351 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
352 if (err)
353 goto give_sigsegv;
354
355 /* Set up to return from userspace. If provided, use a stub
356 already in userspace. */
357 if (ka->sa.sa_flags & SA_RESTORER) {
358 regs->gprs[14] = (unsigned long)
359 ka->sa.sa_restorer | PSW_ADDR_AMODE;
360 } else {
361 regs->gprs[14] = (unsigned long)
362 frame->retcode | PSW_ADDR_AMODE;
b44df334
HC
363 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
364 (u16 __user *)(frame->retcode)))
365 goto give_sigsegv;
1da177e4
LT
366 }
367
368 /* Set up backchain. */
369 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
370 goto give_sigsegv;
371
372 /* Set up registers for signal handler */
373 regs->gprs[15] = (unsigned long) frame;
374 regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
375
376 regs->gprs[2] = map_signal(sig);
377 regs->gprs[3] = (unsigned long) &frame->info;
378 regs->gprs[4] = (unsigned long) &frame->uc;
54dfe5dd 379 return 0;
1da177e4
LT
380
381give_sigsegv:
382 force_sigsegv(sig, current);
54dfe5dd 383 return -EFAULT;
1da177e4
LT
384}
385
386/*
387 * OK, we're invoking a handler
388 */
389
54dfe5dd 390static int
1da177e4
LT
391handle_signal(unsigned long sig, struct k_sigaction *ka,
392 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
393{
54dfe5dd
HC
394 int ret;
395
1da177e4
LT
396 /* Set up the stack frame */
397 if (ka->sa.sa_flags & SA_SIGINFO)
54dfe5dd 398 ret = setup_rt_frame(sig, ka, info, oldset, regs);
1da177e4 399 else
54dfe5dd
HC
400 ret = setup_frame(sig, ka, oldset, regs);
401
402 if (ret == 0) {
403 spin_lock_irq(&current->sighand->siglock);
404 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
405 if (!(ka->sa.sa_flags & SA_NODEFER))
406 sigaddset(&current->blocked,sig);
407 recalc_sigpending();
408 spin_unlock_irq(&current->sighand->siglock);
409 }
1da177e4 410
54dfe5dd 411 return ret;
1da177e4
LT
412}
413
414/*
415 * Note that 'init' is a special process: it doesn't get signals it doesn't
416 * want to handle. Thus you cannot kill init even with a SIGKILL even by
417 * mistake.
418 *
419 * Note that we go through the signals twice: once to check the signals that
420 * the kernel can handle, and then we build all the user-level signal handling
421 * stack-frames in one go after that.
422 */
54dfe5dd 423void do_signal(struct pt_regs *regs)
1da177e4
LT
424{
425 unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
426 siginfo_t info;
427 int signr;
428 struct k_sigaction ka;
54dfe5dd 429 sigset_t *oldset;
1da177e4
LT
430
431 /*
432 * We want the common case to go fast, which
433 * is why we may in certain cases get here from
434 * kernel mode. Just return without doing anything
435 * if so.
436 */
437 if (!user_mode(regs))
54dfe5dd 438 return;
1da177e4 439
54dfe5dd
HC
440 if (test_thread_flag(TIF_RESTORE_SIGMASK))
441 oldset = &current->saved_sigmask;
442 else
1da177e4
LT
443 oldset = &current->blocked;
444
445 /* Are we from a system call? */
446 if (regs->trap == __LC_SVC_OLD_PSW) {
447 continue_addr = regs->psw.addr;
448 restart_addr = continue_addr - regs->ilc;
449 retval = regs->gprs[2];
450
451 /* Prepare for system call restart. We do this here so that a
452 debugger will see the already changed PSW. */
54dfe5dd
HC
453 switch (retval) {
454 case -ERESTARTNOHAND:
455 case -ERESTARTSYS:
456 case -ERESTARTNOINTR:
1da177e4
LT
457 regs->gprs[2] = regs->orig_gpr2;
458 regs->psw.addr = restart_addr;
54dfe5dd
HC
459 break;
460 case -ERESTART_RESTARTBLOCK:
1da177e4
LT
461 regs->gprs[2] = -EINTR;
462 }
8427082a 463 regs->trap = -1; /* Don't deal with this again. */
1da177e4
LT
464 }
465
466 /* Get signal to deliver. When running under ptrace, at this point
467 the debugger may change all our registers ... */
468 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
469
470 /* Depending on the signal settings we may need to revert the
471 decision to restart the system call. */
472 if (signr > 0 && regs->psw.addr == restart_addr) {
473 if (retval == -ERESTARTNOHAND
474 || (retval == -ERESTARTSYS
475 && !(current->sighand->action[signr-1].sa.sa_flags
476 & SA_RESTART))) {
477 regs->gprs[2] = -EINTR;
478 regs->psw.addr = continue_addr;
479 }
480 }
481
482 if (signr > 0) {
483 /* Whee! Actually deliver the signal. */
0ac30be4 484 int ret;
347a8dc3 485#ifdef CONFIG_COMPAT
1da177e4 486 if (test_thread_flag(TIF_31BIT)) {
54dfe5dd
HC
487 extern int handle_signal32(unsigned long sig,
488 struct k_sigaction *ka,
489 siginfo_t *info,
490 sigset_t *oldset,
491 struct pt_regs *regs);
0ac30be4 492 ret = handle_signal32(signr, &ka, &info, oldset, regs);
1da177e4 493 }
0ac30be4 494 else
1da177e4 495#endif
0ac30be4
RM
496 ret = handle_signal(signr, &ka, &info, oldset, regs);
497 if (!ret) {
54dfe5dd
HC
498 /*
499 * A signal was successfully delivered; the saved
500 * sigmask will have been stored in the signal frame,
501 * and will be restored by sigreturn, so we can simply
502 * clear the TIF_RESTORE_SIGMASK flag.
503 */
504 if (test_thread_flag(TIF_RESTORE_SIGMASK))
505 clear_thread_flag(TIF_RESTORE_SIGMASK);
0ac30be4
RM
506
507 /*
508 * If we would have taken a single-step trap
509 * for a normal instruction, act like we took
510 * one for the handler setup.
511 */
512 if (current->thread.per_info.single_step)
513 set_thread_flag(TIF_SINGLE_STEP);
54dfe5dd
HC
514 }
515 return;
516 }
517
518 /*
519 * If there's no signal to deliver, we just put the saved sigmask back.
520 */
521 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
522 clear_thread_flag(TIF_RESTORE_SIGMASK);
523 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1da177e4
LT
524 }
525
526 /* Restart a different system call. */
527 if (retval == -ERESTART_RESTARTBLOCK
528 && regs->psw.addr == continue_addr) {
529 regs->gprs[2] = __NR_restart_syscall;
530 set_thread_flag(TIF_RESTART_SVC);
531 }
1da177e4 532}
This page took 0.309218 seconds and 5 git commands to generate.