GNU Linux-libre 4.9.288-gnu1
[releases.git] / arch / s390 / kernel / signal.c
1 /*
2  *    Copyright IBM Corp. 1999, 2006
3  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
4  *
5  *    Based on Intel version
6  * 
7  *  Copyright (C) 1991, 1992  Linus Torvalds
8  *
9  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
10  */
11
12 #include <linux/sched.h>
13 #include <linux/mm.h>
14 #include <linux/smp.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/unistd.h>
21 #include <linux/stddef.h>
22 #include <linux/tty.h>
23 #include <linux/personality.h>
24 #include <linux/binfmts.h>
25 #include <linux/tracehook.h>
26 #include <linux/syscalls.h>
27 #include <linux/compat.h>
28 #include <asm/ucontext.h>
29 #include <asm/uaccess.h>
30 #include <asm/lowcore.h>
31 #include <asm/switch_to.h>
32 #include "entry.h"
33
34 /*
35  * Layout of an old-style signal-frame:
36  *      -----------------------------------------
37  *      | save area (_SIGNAL_FRAMESIZE)         |
38  *      -----------------------------------------
39  *      | struct sigcontext                     |
40  *      |       oldmask                         |
41  *      |       _sigregs *                      |
42  *      -----------------------------------------
43  *      | _sigregs with                         |
44  *      |       _s390_regs_common               |
45  *      |       _s390_fp_regs                   |
46  *      -----------------------------------------
47  *      | int signo                             |
48  *      -----------------------------------------
49  *      | _sigregs_ext with                     |
50  *      |       gprs_high 64 byte (opt)         |
51  *      |       vxrs_low 128 byte (opt)         |
52  *      |       vxrs_high 256 byte (opt)        |
53  *      |       reserved 128 byte (opt)         |
54  *      -----------------------------------------
55  *      | __u16 svc_insn                        |
56  *      -----------------------------------------
57  * The svc_insn entry with the sigreturn system call opcode does not
58  * have a fixed position and moves if gprs_high or vxrs exist.
59  * Future extensions will be added to _sigregs_ext.
60  */
61 struct sigframe
62 {
63         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
64         struct sigcontext sc;
65         _sigregs sregs;
66         int signo;
67         _sigregs_ext sregs_ext;
68         __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
69 };
70
71 /*
72  * Layout of an rt signal-frame:
73  *      -----------------------------------------
74  *      | save area (_SIGNAL_FRAMESIZE)         |
75  *      -----------------------------------------
76  *      | svc __NR_rt_sigreturn 2 byte          |
77  *      -----------------------------------------
78  *      | struct siginfo                        |
79  *      -----------------------------------------
80  *      | struct ucontext_extended with         |
81  *      |       unsigned long uc_flags          |
82  *      |       struct ucontext *uc_link        |
83  *      |       stack_t uc_stack                |
84  *      |       _sigregs uc_mcontext with       |
85  *      |               _s390_regs_common       |
86  *      |               _s390_fp_regs           |
87  *      |       sigset_t uc_sigmask             |
88  *      |       _sigregs_ext uc_mcontext_ext    |
89  *      |               gprs_high 64 byte (opt) |
90  *      |               vxrs_low 128 byte (opt) |
91  *      |               vxrs_high 256 byte (opt)|
92  *      |               reserved 128 byte (opt) |
93  *      -----------------------------------------
94  * Future extensions will be added to _sigregs_ext.
95  */
96 struct rt_sigframe
97 {
98         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
99         __u16 svc_insn;
100         struct siginfo info;
101         struct ucontext_extended uc;
102 };
103
104 /* Store registers needed to create the signal frame */
105 static void store_sigregs(void)
106 {
107         save_access_regs(current->thread.acrs);
108         save_fpu_regs();
109 }
110
111 /* Load registers after signal return */
112 static void load_sigregs(void)
113 {
114         restore_access_regs(current->thread.acrs);
115 }
116
117 /* Returns non-zero on fault. */
118 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
119 {
120         _sigregs user_sregs;
121
122         /* Copy a 'clean' PSW mask to the user to avoid leaking
123            information about whether PER is currently on.  */
124         user_sregs.regs.psw.mask = PSW_USER_BITS |
125                 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
126         user_sregs.regs.psw.addr = regs->psw.addr;
127         memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
128         memcpy(&user_sregs.regs.acrs, current->thread.acrs,
129                sizeof(user_sregs.regs.acrs));
130         fpregs_store(&user_sregs.fpregs, &current->thread.fpu);
131         if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
132                 return -EFAULT;
133         return 0;
134 }
135
136 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
137 {
138         _sigregs user_sregs;
139
140         /* Alwys make any pending restarted system call return -EINTR */
141         current->restart_block.fn = do_no_restart_syscall;
142
143         if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
144                 return -EFAULT;
145
146         if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
147                 return -EINVAL;
148
149         /* Test the floating-point-control word. */
150         if (test_fp_ctl(user_sregs.fpregs.fpc))
151                 return -EINVAL;
152
153         /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
154         regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
155                 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
156         /* Check for invalid user address space control. */
157         if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
158                 regs->psw.mask = PSW_ASC_PRIMARY |
159                         (regs->psw.mask & ~PSW_MASK_ASC);
160         /* Check for invalid amode */
161         if (regs->psw.mask & PSW_MASK_EA)
162                 regs->psw.mask |= PSW_MASK_BA;
163         regs->psw.addr = user_sregs.regs.psw.addr;
164         memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
165         memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
166                sizeof(current->thread.acrs));
167
168         fpregs_load(&user_sregs.fpregs, &current->thread.fpu);
169
170         clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
171         return 0;
172 }
173
174 /* Returns non-zero on fault. */
175 static int save_sigregs_ext(struct pt_regs *regs,
176                             _sigregs_ext __user *sregs_ext)
177 {
178         __u64 vxrs[__NUM_VXRS_LOW];
179         int i;
180
181         /* Save vector registers to signal stack */
182         if (MACHINE_HAS_VX) {
183                 for (i = 0; i < __NUM_VXRS_LOW; i++)
184                         vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
185                 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
186                                    sizeof(sregs_ext->vxrs_low)) ||
187                     __copy_to_user(&sregs_ext->vxrs_high,
188                                    current->thread.fpu.vxrs + __NUM_VXRS_LOW,
189                                    sizeof(sregs_ext->vxrs_high)))
190                         return -EFAULT;
191         }
192         return 0;
193 }
194
195 static int restore_sigregs_ext(struct pt_regs *regs,
196                                _sigregs_ext __user *sregs_ext)
197 {
198         __u64 vxrs[__NUM_VXRS_LOW];
199         int i;
200
201         /* Restore vector registers from signal stack */
202         if (MACHINE_HAS_VX) {
203                 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
204                                      sizeof(sregs_ext->vxrs_low)) ||
205                     __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
206                                      &sregs_ext->vxrs_high,
207                                      sizeof(sregs_ext->vxrs_high)))
208                         return -EFAULT;
209                 for (i = 0; i < __NUM_VXRS_LOW; i++)
210                         *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
211         }
212         return 0;
213 }
214
215 SYSCALL_DEFINE0(sigreturn)
216 {
217         struct pt_regs *regs = task_pt_regs(current);
218         struct sigframe __user *frame =
219                 (struct sigframe __user *) regs->gprs[15];
220         sigset_t set;
221
222         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
223                 goto badframe;
224         set_current_blocked(&set);
225         save_fpu_regs();
226         if (restore_sigregs(regs, &frame->sregs))
227                 goto badframe;
228         if (restore_sigregs_ext(regs, &frame->sregs_ext))
229                 goto badframe;
230         load_sigregs();
231         return regs->gprs[2];
232 badframe:
233         force_sig(SIGSEGV, current);
234         return 0;
235 }
236
237 SYSCALL_DEFINE0(rt_sigreturn)
238 {
239         struct pt_regs *regs = task_pt_regs(current);
240         struct rt_sigframe __user *frame =
241                 (struct rt_sigframe __user *)regs->gprs[15];
242         sigset_t set;
243
244         if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
245                 goto badframe;
246         set_current_blocked(&set);
247         if (restore_altstack(&frame->uc.uc_stack))
248                 goto badframe;
249         save_fpu_regs();
250         if (restore_sigregs(regs, &frame->uc.uc_mcontext))
251                 goto badframe;
252         if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
253                 goto badframe;
254         load_sigregs();
255         return regs->gprs[2];
256 badframe:
257         force_sig(SIGSEGV, current);
258         return 0;
259 }
260
261 /*
262  * Determine which stack to use..
263  */
264 static inline void __user *
265 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
266 {
267         unsigned long sp;
268
269         /* Default to using normal stack */
270         sp = regs->gprs[15];
271
272         /* Overflow on alternate signal stack gives SIGSEGV. */
273         if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
274                 return (void __user *) -1UL;
275
276         /* This is the X/Open sanctioned signal stack switching.  */
277         if (ka->sa.sa_flags & SA_ONSTACK) {
278                 if (! sas_ss_flags(sp))
279                         sp = current->sas_ss_sp + current->sas_ss_size;
280         }
281
282         return (void __user *)((sp - frame_size) & -8ul);
283 }
284
285 static int setup_frame(int sig, struct k_sigaction *ka,
286                        sigset_t *set, struct pt_regs * regs)
287 {
288         struct sigframe __user *frame;
289         struct sigcontext sc;
290         unsigned long restorer;
291         size_t frame_size;
292
293         /*
294          * gprs_high are only present for a 31-bit task running on
295          * a 64-bit kernel (see compat_signal.c) but the space for
296          * gprs_high need to be allocated if vector registers are
297          * included in the signal frame on a 31-bit system.
298          */
299         frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
300         if (MACHINE_HAS_VX)
301                 frame_size += sizeof(frame->sregs_ext);
302         frame = get_sigframe(ka, regs, frame_size);
303         if (frame == (void __user *) -1UL)
304                 return -EFAULT;
305
306         /* Set up backchain. */
307         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
308                 return -EFAULT;
309
310         /* Create struct sigcontext on the signal stack */
311         memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
312         sc.sregs = (_sigregs __user __force *) &frame->sregs;
313         if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
314                 return -EFAULT;
315
316         /* Store registers needed to create the signal frame */
317         store_sigregs();
318
319         /* Create _sigregs on the signal stack */
320         if (save_sigregs(regs, &frame->sregs))
321                 return -EFAULT;
322
323         /* Place signal number on stack to allow backtrace from handler.  */
324         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
325                 return -EFAULT;
326
327         /* Create _sigregs_ext on the signal stack */
328         if (save_sigregs_ext(regs, &frame->sregs_ext))
329                 return -EFAULT;
330
331         /* Set up to return from userspace.  If provided, use a stub
332            already in userspace.  */
333         if (ka->sa.sa_flags & SA_RESTORER) {
334                 restorer = (unsigned long) ka->sa.sa_restorer;
335         } else {
336                 /* Signal frame without vector registers are short ! */
337                 __u16 __user *svc = (void __user *) frame + frame_size - 2;
338                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
339                         return -EFAULT;
340                 restorer = (unsigned long) svc;
341         }
342
343         /* Set up registers for signal handler */
344         regs->gprs[14] = restorer;
345         regs->gprs[15] = (unsigned long) frame;
346         /* Force default amode and default user address space control. */
347         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
348                 (PSW_USER_BITS & PSW_MASK_ASC) |
349                 (regs->psw.mask & ~PSW_MASK_ASC);
350         regs->psw.addr = (unsigned long) ka->sa.sa_handler;
351
352         regs->gprs[2] = sig;
353         regs->gprs[3] = (unsigned long) &frame->sc;
354
355         /* We forgot to include these in the sigcontext.
356            To avoid breaking binary compatibility, they are passed as args. */
357         if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
358             sig == SIGTRAP || sig == SIGFPE) {
359                 /* set extra registers only for synchronous signals */
360                 regs->gprs[4] = regs->int_code & 127;
361                 regs->gprs[5] = regs->int_parm_long;
362                 regs->gprs[6] = task_thread_info(current)->last_break;
363         }
364         return 0;
365 }
366
367 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
368                           struct pt_regs *regs)
369 {
370         struct rt_sigframe __user *frame;
371         unsigned long uc_flags, restorer;
372         size_t frame_size;
373
374         frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
375         /*
376          * gprs_high are only present for a 31-bit task running on
377          * a 64-bit kernel (see compat_signal.c) but the space for
378          * gprs_high need to be allocated if vector registers are
379          * included in the signal frame on a 31-bit system.
380          */
381         uc_flags = 0;
382         if (MACHINE_HAS_VX) {
383                 frame_size += sizeof(_sigregs_ext);
384                 uc_flags |= UC_VXRS;
385         }
386         frame = get_sigframe(&ksig->ka, regs, frame_size);
387         if (frame == (void __user *) -1UL)
388                 return -EFAULT;
389
390         /* Set up backchain. */
391         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
392                 return -EFAULT;
393
394         /* Set up to return from userspace.  If provided, use a stub
395            already in userspace.  */
396         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
397                 restorer = (unsigned long) ksig->ka.sa.sa_restorer;
398         } else {
399                 __u16 __user *svc = &frame->svc_insn;
400                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
401                         return -EFAULT;
402                 restorer = (unsigned long) svc;
403         }
404
405         /* Create siginfo on the signal stack */
406         if (copy_siginfo_to_user(&frame->info, &ksig->info))
407                 return -EFAULT;
408
409         /* Store registers needed to create the signal frame */
410         store_sigregs();
411
412         /* Create ucontext on the signal stack. */
413         if (__put_user(uc_flags, &frame->uc.uc_flags) ||
414             __put_user(NULL, &frame->uc.uc_link) ||
415             __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
416             save_sigregs(regs, &frame->uc.uc_mcontext) ||
417             __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
418             save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
419                 return -EFAULT;
420
421         /* Set up registers for signal handler */
422         regs->gprs[14] = restorer;
423         regs->gprs[15] = (unsigned long) frame;
424         /* Force default amode and default user address space control. */
425         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
426                 (PSW_USER_BITS & PSW_MASK_ASC) |
427                 (regs->psw.mask & ~PSW_MASK_ASC);
428         regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler;
429
430         regs->gprs[2] = ksig->sig;
431         regs->gprs[3] = (unsigned long) &frame->info;
432         regs->gprs[4] = (unsigned long) &frame->uc;
433         regs->gprs[5] = task_thread_info(current)->last_break;
434         return 0;
435 }
436
437 static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
438                           struct pt_regs *regs)
439 {
440         int ret;
441
442         /* Set up the stack frame */
443         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
444                 ret = setup_rt_frame(ksig, oldset, regs);
445         else
446                 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
447
448         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
449 }
450
451 /*
452  * Note that 'init' is a special process: it doesn't get signals it doesn't
453  * want to handle. Thus you cannot kill init even with a SIGKILL even by
454  * mistake.
455  *
456  * Note that we go through the signals twice: once to check the signals that
457  * the kernel can handle, and then we build all the user-level signal handling
458  * stack-frames in one go after that.
459  */
460 void do_signal(struct pt_regs *regs)
461 {
462         struct ksignal ksig;
463         sigset_t *oldset = sigmask_to_save();
464
465         /*
466          * Get signal to deliver. When running under ptrace, at this point
467          * the debugger may change all our registers, including the system
468          * call information.
469          */
470         current_thread_info()->system_call =
471                 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
472
473         if (get_signal(&ksig)) {
474                 /* Whee!  Actually deliver the signal.  */
475                 if (current_thread_info()->system_call) {
476                         regs->int_code = current_thread_info()->system_call;
477                         /* Check for system call restarting. */
478                         switch (regs->gprs[2]) {
479                         case -ERESTART_RESTARTBLOCK:
480                         case -ERESTARTNOHAND:
481                                 regs->gprs[2] = -EINTR;
482                                 break;
483                         case -ERESTARTSYS:
484                                 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
485                                         regs->gprs[2] = -EINTR;
486                                         break;
487                                 }
488                         /* fallthrough */
489                         case -ERESTARTNOINTR:
490                                 regs->gprs[2] = regs->orig_gpr2;
491                                 regs->psw.addr =
492                                         __rewind_psw(regs->psw,
493                                                      regs->int_code >> 16);
494                                 break;
495                         }
496                 }
497                 /* No longer in a system call */
498                 clear_pt_regs_flag(regs, PIF_SYSCALL);
499
500                 if (is_compat_task())
501                         handle_signal32(&ksig, oldset, regs);
502                 else
503                         handle_signal(&ksig, oldset, regs);
504                 return;
505         }
506
507         /* No handlers present - check for system call restart */
508         clear_pt_regs_flag(regs, PIF_SYSCALL);
509         if (current_thread_info()->system_call) {
510                 regs->int_code = current_thread_info()->system_call;
511                 switch (regs->gprs[2]) {
512                 case -ERESTART_RESTARTBLOCK:
513                         /* Restart with sys_restart_syscall */
514                         regs->int_code = __NR_restart_syscall;
515                 /* fallthrough */
516                 case -ERESTARTNOHAND:
517                 case -ERESTARTSYS:
518                 case -ERESTARTNOINTR:
519                         /* Restart system call with magic TIF bit. */
520                         regs->gprs[2] = regs->orig_gpr2;
521                         set_pt_regs_flag(regs, PIF_SYSCALL);
522                         if (test_thread_flag(TIF_SINGLE_STEP))
523                                 clear_pt_regs_flag(regs, PIF_PER_TRAP);
524                         break;
525                 }
526         }
527
528         /*
529          * If there's no signal to deliver, we just put the saved sigmask back.
530          */
531         restore_saved_sigmask();
532 }
533
534 void do_notify_resume(struct pt_regs *regs)
535 {
536         clear_thread_flag(TIF_NOTIFY_RESUME);
537         tracehook_notify_resume(regs);
538 }