header cleaning: don't include smp_lock.h when not used
[linux-3.10.git] / arch / s390 / kernel / signal.c
1 /*
2  *  arch/s390/kernel/signal.c
3  *
4  *    Copyright (C) IBM Corp. 1999,2006
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
14 #include <linux/sched.h>
15 #include <linux/mm.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
31 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33
34 typedef 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
43 typedef 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
51 /*
52  * Atomically swap in the new signal mask, and wait for a signal.
53  */
54 asmlinkage int
55 sys_sigsuspend(int history0, int history1, old_sigset_t mask)
56 {
57         mask &= _BLOCKABLE;
58         spin_lock_irq(&current->sighand->siglock);
59         current->saved_sigmask = current->blocked;
60         siginitset(&current->blocked, mask);
61         recalc_sigpending();
62         spin_unlock_irq(&current->sighand->siglock);
63
64         current->state = TASK_INTERRUPTIBLE;
65         schedule();
66         set_thread_flag(TIF_RESTORE_SIGMASK);
67
68         return -ERESTARTNOHAND;
69 }
70
71 asmlinkage long
72 sys_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) ||
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))
85                         return -EFAULT;
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) ||
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))
97                         return -EFAULT;
98         }
99
100         return ret;
101 }
102
103 asmlinkage long
104 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
105 {
106         struct pt_regs *regs = task_pt_regs(current);
107         return do_sigaltstack(uss, uoss, regs->gprs[15]);
108 }
109
110
111
112 /* Returns non-zero on fault. */
113 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
114 {
115         _sigregs user_sregs;
116
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.  */
121         user_sregs.regs.psw.mask = PSW_MASK_MERGE(psw_user_bits, regs->psw.mask);
122         user_sregs.regs.psw.addr = regs->psw.addr;
123         memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
124         memcpy(&user_sregs.regs.acrs, current->thread.acrs,
125                sizeof(sregs->regs.acrs));
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);
131         memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
132                sizeof(s390_fp_regs));
133         return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
134 }
135
136 /* Returns positive number on error */
137 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
138 {
139         int err;
140         _sigregs user_sregs;
141
142         /* Alwys make any pending restarted system call return -EINTR */
143         current_thread_info()->restart_block.fn = do_no_restart_syscall;
144
145         err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
146         if (err)
147                 return err;
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));
152         memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
153                sizeof(sregs->regs.acrs));
154         restore_access_regs(current->thread.acrs);
155
156         memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
157                sizeof(s390_fp_regs));
158         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
159
160         restore_fp_regs(&current->thread.fp_regs);
161         regs->trap = -1;        /* disable syscall checks */
162         return 0;
163 }
164
165 asmlinkage long sys_sigreturn(void)
166 {
167         struct pt_regs *regs = task_pt_regs(current);
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
187 badframe:
188         force_sig(SIGSEGV, current);
189         return 0;
190 }
191
192 asmlinkage long sys_rt_sigreturn(void)
193 {
194         struct pt_regs *regs = task_pt_regs(current);
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
212         if (do_sigaltstack(&frame->uc.uc_stack, NULL,
213                            regs->gprs[15]) == -EFAULT)
214                 goto badframe;
215         return regs->gprs[2];
216
217 badframe:
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  */
230 static inline void __user *
231 get_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
238         /* This is the X/Open sanctioned signal stack switching.  */
239         if (ka->sa.sa_flags & SA_ONSTACK) {
240                 if (! sas_ss_flags(sp))
241                         sp = current->sas_ss_sp + current->sas_ss_size;
242         }
243
244         /* This is the legacy signal stack switching. */
245         else if (!user_mode(regs) &&
246                  !(ka->sa.sa_flags & SA_RESTORER) &&
247                  ka->sa.sa_restorer) {
248                 sp = (unsigned long) ka->sa.sa_restorer;
249         }
250
251         return (void __user *)((sp - frame_size) & -8ul);
252 }
253
254 static inline int map_signal(int sig)
255 {
256         if (current_thread_info()->exec_domain
257             && current_thread_info()->exec_domain->signal_invmap
258             && sig < 32)
259                 return current_thread_info()->exec_domain->signal_invmap[sig];
260         else
261                 return sig;
262 }
263
264 static int setup_frame(int sig, struct k_sigaction *ka,
265                        sigset_t *set, struct pt_regs * regs)
266 {
267         sigframe __user *frame;
268
269         frame = get_sigframe(ka, regs, sizeof(sigframe));
270         if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
271                 goto give_sigsegv;
272
273         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
274                 goto give_sigsegv;
275
276         if (save_sigregs(regs, &frame->sregs))
277                 goto give_sigsegv;
278         if (__put_user(&frame->sregs, &frame->sc.sregs))
279                 goto give_sigsegv;
280
281         /* Set up to return from userspace.  If provided, use a stub
282            already in userspace.  */
283         if (ka->sa.sa_flags & SA_RESTORER) {
284                 regs->gprs[14] = (unsigned long)
285                         ka->sa.sa_restorer | PSW_ADDR_AMODE;
286         } else {
287                 regs->gprs[14] = (unsigned long)
288                         frame->retcode | PSW_ADDR_AMODE;
289                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
290                                (u16 __user *)(frame->retcode)))
291                         goto give_sigsegv;
292         }
293
294         /* Set up backchain. */
295         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
296                 goto give_sigsegv;
297
298         /* Set up registers for signal handler */
299         regs->gprs[15] = (unsigned long) frame;
300         regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
301
302         regs->gprs[2] = map_signal(sig);
303         regs->gprs[3] = (unsigned long) &frame->sc;
304
305         /* We forgot to include these in the sigcontext.
306            To avoid breaking binary compatibility, they are passed as args. */
307         regs->gprs[4] = current->thread.trap_no;
308         regs->gprs[5] = current->thread.prot_addr;
309
310         /* Place signal number on stack to allow backtrace from handler.  */
311         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
312                 goto give_sigsegv;
313         return 0;
314
315 give_sigsegv:
316         force_sigsegv(sig, current);
317         return -EFAULT;
318 }
319
320 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
321                            sigset_t *set, struct pt_regs * regs)
322 {
323         int err = 0;
324         rt_sigframe __user *frame;
325
326         frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
327         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
328                 goto give_sigsegv;
329
330         if (copy_siginfo_to_user(&frame->info, info))
331                 goto give_sigsegv;
332
333         /* Create the ucontext.  */
334         err |= __put_user(0, &frame->uc.uc_flags);
335         err |= __put_user(NULL, &frame->uc.uc_link);
336         err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
337         err |= __put_user(sas_ss_flags(regs->gprs[15]),
338                           &frame->uc.uc_stack.ss_flags);
339         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
340         err |= save_sigregs(regs, &frame->uc.uc_mcontext);
341         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
342         if (err)
343                 goto give_sigsegv;
344
345         /* Set up to return from userspace.  If provided, use a stub
346            already in userspace.  */
347         if (ka->sa.sa_flags & SA_RESTORER) {
348                 regs->gprs[14] = (unsigned long)
349                         ka->sa.sa_restorer | PSW_ADDR_AMODE;
350         } else {
351                 regs->gprs[14] = (unsigned long)
352                         frame->retcode | PSW_ADDR_AMODE;
353                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
354                                (u16 __user *)(frame->retcode)))
355                         goto give_sigsegv;
356         }
357
358         /* Set up backchain. */
359         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
360                 goto give_sigsegv;
361
362         /* Set up registers for signal handler */
363         regs->gprs[15] = (unsigned long) frame;
364         regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
365
366         regs->gprs[2] = map_signal(sig);
367         regs->gprs[3] = (unsigned long) &frame->info;
368         regs->gprs[4] = (unsigned long) &frame->uc;
369         return 0;
370
371 give_sigsegv:
372         force_sigsegv(sig, current);
373         return -EFAULT;
374 }
375
376 /*
377  * OK, we're invoking a handler
378  */     
379
380 static int
381 handle_signal(unsigned long sig, struct k_sigaction *ka,
382               siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
383 {
384         int ret;
385
386         /* Set up the stack frame */
387         if (ka->sa.sa_flags & SA_SIGINFO)
388                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
389         else
390                 ret = setup_frame(sig, ka, oldset, regs);
391
392         if (ret == 0) {
393                 spin_lock_irq(&current->sighand->siglock);
394                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
395                 if (!(ka->sa.sa_flags & SA_NODEFER))
396                         sigaddset(&current->blocked,sig);
397                 recalc_sigpending();
398                 spin_unlock_irq(&current->sighand->siglock);
399         }
400
401         return ret;
402 }
403
404 /*
405  * Note that 'init' is a special process: it doesn't get signals it doesn't
406  * want to handle. Thus you cannot kill init even with a SIGKILL even by
407  * mistake.
408  *
409  * Note that we go through the signals twice: once to check the signals that
410  * the kernel can handle, and then we build all the user-level signal handling
411  * stack-frames in one go after that.
412  */
413 void do_signal(struct pt_regs *regs)
414 {
415         unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
416         siginfo_t info;
417         int signr;
418         struct k_sigaction ka;
419         sigset_t *oldset;
420
421         /*
422          * We want the common case to go fast, which
423          * is why we may in certain cases get here from
424          * kernel mode. Just return without doing anything
425          * if so.
426          */
427         if (!user_mode(regs))
428                 return;
429
430         if (test_thread_flag(TIF_RESTORE_SIGMASK))
431                 oldset = &current->saved_sigmask;
432         else
433                 oldset = &current->blocked;
434
435         /* Are we from a system call? */
436         if (regs->trap == __LC_SVC_OLD_PSW) {
437                 continue_addr = regs->psw.addr;
438                 restart_addr = continue_addr - regs->ilc;
439                 retval = regs->gprs[2];
440
441                 /* Prepare for system call restart.  We do this here so that a
442                    debugger will see the already changed PSW. */
443                 switch (retval) {
444                 case -ERESTARTNOHAND:
445                 case -ERESTARTSYS:
446                 case -ERESTARTNOINTR:
447                         regs->gprs[2] = regs->orig_gpr2;
448                         regs->psw.addr = restart_addr;
449                         break;
450                 case -ERESTART_RESTARTBLOCK:
451                         regs->gprs[2] = -EINTR;
452                 }
453                 regs->trap = -1;        /* Don't deal with this again. */
454         }
455
456         /* Get signal to deliver.  When running under ptrace, at this point
457            the debugger may change all our registers ... */
458         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
459
460         /* Depending on the signal settings we may need to revert the
461            decision to restart the system call. */
462         if (signr > 0 && regs->psw.addr == restart_addr) {
463                 if (retval == -ERESTARTNOHAND
464                     || (retval == -ERESTARTSYS
465                          && !(current->sighand->action[signr-1].sa.sa_flags
466                               & SA_RESTART))) {
467                         regs->gprs[2] = -EINTR;
468                         regs->psw.addr = continue_addr;
469                 }
470         }
471
472         if (signr > 0) {
473                 /* Whee!  Actually deliver the signal.  */
474 #ifdef CONFIG_COMPAT
475                 if (test_thread_flag(TIF_31BIT)) {
476                         extern int handle_signal32(unsigned long sig,
477                                                    struct k_sigaction *ka,
478                                                    siginfo_t *info,
479                                                    sigset_t *oldset,
480                                                    struct pt_regs *regs);
481                         if (handle_signal32(
482                                     signr, &ka, &info, oldset, regs) == 0) {
483                                 if (test_thread_flag(TIF_RESTORE_SIGMASK))
484                                         clear_thread_flag(TIF_RESTORE_SIGMASK);
485                         }
486                         return;
487                 }
488 #endif
489                 if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
490                         /*
491                          * A signal was successfully delivered; the saved
492                          * sigmask will have been stored in the signal frame,
493                          * and will be restored by sigreturn, so we can simply
494                          * clear the TIF_RESTORE_SIGMASK flag.
495                          */
496                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
497                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
498                 }
499                 return;
500         }
501
502         /*
503          * If there's no signal to deliver, we just put the saved sigmask back.
504          */
505         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
506                 clear_thread_flag(TIF_RESTORE_SIGMASK);
507                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
508         }
509
510         /* Restart a different system call. */
511         if (retval == -ERESTART_RESTARTBLOCK
512             && regs->psw.addr == continue_addr) {
513                 regs->gprs[2] = __NR_restart_syscall;
514                 set_thread_flag(TIF_RESTART_SVC);
515         }
516 }