?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-3.18-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tj...
[linux/fpc-iii.git] / arch / s390 / kernel / signal.c
blob0c1a0ff0a558bda9a389091f86628fb8b0f825bc
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_fp_ctl(&current->thread.fp_regs.fpc);
109 #ifdef CONFIG_64BIT
110 if (current->thread.vxrs) {
111 int i;
112
113 save_vx_regs(current->thread.vxrs);
114 for (i = 0; i < __NUM_FPRS; i++)
115 current->thread.fp_regs.fprs[i] =
116 *(freg_t *)(current->thread.vxrs + i);
117 } else
118 #endif
119 save_fp_regs(current->thread.fp_regs.fprs);
120 }
121
122 /* Load registers after signal return */
123 static void load_sigregs(void)
124 {
125 restore_access_regs(current->thread.acrs);
126 /* restore_fp_ctl is done in restore_sigregs */
127 #ifdef CONFIG_64BIT
128 if (current->thread.vxrs) {
129 int i;
130
131 for (i = 0; i < __NUM_FPRS; i++)
132 *(freg_t *)(current->thread.vxrs + i) =
133 current->thread.fp_regs.fprs[i];
134 restore_vx_regs(current->thread.vxrs);
135 } else
136 #endif
137 restore_fp_regs(current->thread.fp_regs.fprs);
138 }
139
140 /* Returns non-zero on fault. */
141 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
142 {
143 _sigregs user_sregs;
144
145 /* Copy a 'clean' PSW mask to the user to avoid leaking
146 information about whether PER is currently on. */
147 user_sregs.regs.psw.mask = PSW_USER_BITS |
148 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
149 user_sregs.regs.psw.addr = regs->psw.addr;
150 memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
151 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
152 sizeof(user_sregs.regs.acrs));
153 memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
154 sizeof(user_sregs.fpregs));
155 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
156 return -EFAULT;
157 return 0;
158 }
159
160 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
161 {
162 _sigregs user_sregs;
163
164 /* Alwys make any pending restarted system call return -EINTR */
165 current_thread_info()->restart_block.fn = do_no_restart_syscall;
166
167 if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
168 return -EFAULT;
169
170 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
171 return -EINVAL;
172
173 /* Loading the floating-point-control word can fail. Do that first. */
174 if (restore_fp_ctl(&user_sregs.fpregs.fpc))
175 return -EINVAL;
176
177 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
178 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
179 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
180 /* Check for invalid user address space control. */
181 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
182 regs->psw.mask = PSW_ASC_PRIMARY |
183 (regs->psw.mask & ~PSW_MASK_ASC);
184 /* Check for invalid amode */
185 if (regs->psw.mask & PSW_MASK_EA)
186 regs->psw.mask |= PSW_MASK_BA;
187 regs->psw.addr = user_sregs.regs.psw.addr;
188 memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
189 memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
190 sizeof(current->thread.acrs));
191
192 memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
193 sizeof(current->thread.fp_regs));
194
195 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
196 return 0;
197 }
198
199 /* Returns non-zero on fault. */
200 static int save_sigregs_ext(struct pt_regs *regs,
201 _sigregs_ext __user *sregs_ext)
202 {
203 #ifdef CONFIG_64BIT
204 __u64 vxrs[__NUM_VXRS_LOW];
205 int i;
206
207 /* Save vector registers to signal stack */
208 if (current->thread.vxrs) {
209 for (i = 0; i < __NUM_VXRS_LOW; i++)
210 vxrs[i] = *((__u64 *)(current->thread.vxrs + i) + 1);
211 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
212 sizeof(sregs_ext->vxrs_low)) ||
213 __copy_to_user(&sregs_ext->vxrs_high,
214 current->thread.vxrs + __NUM_VXRS_LOW,
215 sizeof(sregs_ext->vxrs_high)))
216 return -EFAULT;
217 }
218 #endif
219 return 0;
220 }
221
222 static int restore_sigregs_ext(struct pt_regs *regs,
223 _sigregs_ext __user *sregs_ext)
224 {
225 #ifdef CONFIG_64BIT
226 __u64 vxrs[__NUM_VXRS_LOW];
227 int i;
228
229 /* Restore vector registers from signal stack */
230 if (current->thread.vxrs) {
231 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
232 sizeof(sregs_ext->vxrs_low)) ||
233 __copy_from_user(current->thread.vxrs + __NUM_VXRS_LOW,
234 &sregs_ext->vxrs_high,
235 sizeof(sregs_ext->vxrs_high)))
236 return -EFAULT;
237 for (i = 0; i < __NUM_VXRS_LOW; i++)
238 *((__u64 *)(current->thread.vxrs + i) + 1) = vxrs[i];
239 }
240 #endif
241 return 0;
242 }
243
244 SYSCALL_DEFINE0(sigreturn)
245 {
246 struct pt_regs *regs = task_pt_regs(current);
247 struct sigframe __user *frame =
248 (struct sigframe __user *) regs->gprs[15];
249 sigset_t set;
250
251 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
252 goto badframe;
253 set_current_blocked(&set);
254 if (restore_sigregs(regs, &frame->sregs))
255 goto badframe;
256 if (restore_sigregs_ext(regs, &frame->sregs_ext))
257 goto badframe;
258 load_sigregs();
259 return regs->gprs[2];
260 badframe:
261 force_sig(SIGSEGV, current);
262 return 0;
263 }
264
265 SYSCALL_DEFINE0(rt_sigreturn)
266 {
267 struct pt_regs *regs = task_pt_regs(current);
268 struct rt_sigframe __user *frame =
269 (struct rt_sigframe __user *)regs->gprs[15];
270 sigset_t set;
271
272 if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
273 goto badframe;
274 set_current_blocked(&set);
275 if (restore_altstack(&frame->uc.uc_stack))
276 goto badframe;
277 if (restore_sigregs(regs, &frame->uc.uc_mcontext))
278 goto badframe;
279 if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
280 goto badframe;
281 load_sigregs();
282 return regs->gprs[2];
283 badframe:
284 force_sig(SIGSEGV, current);
285 return 0;
286 }
287
288 /*
289 * Determine which stack to use..
290 */
291 static inline void __user *
292 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
293 {
294 unsigned long sp;
295
296 /* Default to using normal stack */
297 sp = regs->gprs[15];
298
299 /* Overflow on alternate signal stack gives SIGSEGV. */
300 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
301 return (void __user *) -1UL;
302
303 /* This is the X/Open sanctioned signal stack switching. */
304 if (ka->sa.sa_flags & SA_ONSTACK) {
305 if (! sas_ss_flags(sp))
306 sp = current->sas_ss_sp + current->sas_ss_size;
307 }
308
309 return (void __user *)((sp - frame_size) & -8ul);
310 }
311
312 static inline int map_signal(int sig)
313 {
314 if (current_thread_info()->exec_domain
315 && current_thread_info()->exec_domain->signal_invmap
316 && sig < 32)
317 return current_thread_info()->exec_domain->signal_invmap[sig];
318 else
319 return sig;
320 }
321
322 static int setup_frame(int sig, struct k_sigaction *ka,
323 sigset_t *set, struct pt_regs * regs)
324 {
325 struct sigframe __user *frame;
326 struct sigcontext sc;
327 unsigned long restorer;
328 size_t frame_size;
329
330 /*
331 * gprs_high are only present for a 31-bit task running on
332 * a 64-bit kernel (see compat_signal.c) but the space for
333 * gprs_high need to be allocated if vector registers are
334 * included in the signal frame on a 31-bit system.
335 */
336 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
337 if (MACHINE_HAS_VX)
338 frame_size += sizeof(frame->sregs_ext);
339 frame = get_sigframe(ka, regs, frame_size);
340 if (frame == (void __user *) -1UL)
341 return -EFAULT;
342
343 /* Set up backchain. */
344 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
345 return -EFAULT;
346
347 /* Create struct sigcontext on the signal stack */
348 memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
349 sc.sregs = (_sigregs __user __force *) &frame->sregs;
350 if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
351 return -EFAULT;
352
353 /* Store registers needed to create the signal frame */
354 store_sigregs();
355
356 /* Create _sigregs on the signal stack */
357 if (save_sigregs(regs, &frame->sregs))
358 return -EFAULT;
359
360 /* Place signal number on stack to allow backtrace from handler. */
361 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
362 return -EFAULT;
363
364 /* Create _sigregs_ext on the signal stack */
365 if (save_sigregs_ext(regs, &frame->sregs_ext))
366 return -EFAULT;
367
368 /* Set up to return from userspace. If provided, use a stub
369 already in userspace. */
370 if (ka->sa.sa_flags & SA_RESTORER) {
371 restorer = (unsigned long) ka->sa.sa_restorer | PSW_ADDR_AMODE;
372 } else {
373 /* Signal frame without vector registers are short ! */
374 __u16 __user *svc = (void *) frame + frame_size - 2;
375 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
376 return -EFAULT;
377 restorer = (unsigned long) svc | PSW_ADDR_AMODE;
378 }
379
380 /* Set up registers for signal handler */
381 regs->gprs[14] = restorer;
382 regs->gprs[15] = (unsigned long) frame;
383 /* Force default amode and default user address space control. */
384 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
385 (PSW_USER_BITS & PSW_MASK_ASC) |
386 (regs->psw.mask & ~PSW_MASK_ASC);
387 regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
388
389 regs->gprs[2] = map_signal(sig);
390 regs->gprs[3] = (unsigned long) &frame->sc;
391
392 /* We forgot to include these in the sigcontext.
393 To avoid breaking binary compatibility, they are passed as args. */
394 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
395 sig == SIGTRAP || sig == SIGFPE) {
396 /* set extra registers only for synchronous signals */
397 regs->gprs[4] = regs->int_code & 127;
398 regs->gprs[5] = regs->int_parm_long;
399 regs->gprs[6] = task_thread_info(current)->last_break;
400 }
401 return 0;
402 }
403
404 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
405 struct pt_regs *regs)
406 {
407 struct rt_sigframe __user *frame;
408 unsigned long uc_flags, restorer;
409 size_t frame_size;
410
411 frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
412 /*
413 * gprs_high are only present for a 31-bit task running on
414 * a 64-bit kernel (see compat_signal.c) but the space for
415 * gprs_high need to be allocated if vector registers are
416 * included in the signal frame on a 31-bit system.
417 */
418 uc_flags = 0;
419 #ifdef CONFIG_64BIT
420 if (MACHINE_HAS_VX) {
421 frame_size += sizeof(_sigregs_ext);
422 if (current->thread.vxrs)
423 uc_flags |= UC_VXRS;
424 }
425 #endif
426 frame = get_sigframe(&ksig->ka, regs, frame_size);
427 if (frame == (void __user *) -1UL)
428 return -EFAULT;
429
430 /* Set up backchain. */
431 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
432 return -EFAULT;
433
434 /* Set up to return from userspace. If provided, use a stub
435 already in userspace. */
436 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
437 restorer = (unsigned long)
438 ksig->ka.sa.sa_restorer | PSW_ADDR_AMODE;
439 } else {
440 __u16 __user *svc = &frame->svc_insn;
441 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
442 return -EFAULT;
443 restorer = (unsigned long) svc | PSW_ADDR_AMODE;
444 }
445
446 /* Create siginfo on the signal stack */
447 if (copy_siginfo_to_user(&frame->info, &ksig->info))
448 return -EFAULT;
449
450 /* Store registers needed to create the signal frame */
451 store_sigregs();
452
453 /* Create ucontext on the signal stack. */
454 if (__put_user(uc_flags, &frame->uc.uc_flags) ||
455 __put_user(NULL, &frame->uc.uc_link) ||
456 __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
457 save_sigregs(regs, &frame->uc.uc_mcontext) ||
458 __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
459 save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
460 return -EFAULT;
461
462 /* Set up registers for signal handler */
463 regs->gprs[14] = restorer;
464 regs->gprs[15] = (unsigned long) frame;
465 /* Force default amode and default user address space control. */
466 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
467 (PSW_USER_BITS & PSW_MASK_ASC) |
468 (regs->psw.mask & ~PSW_MASK_ASC);
469 regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler | PSW_ADDR_AMODE;
470
471 regs->gprs[2] = map_signal(ksig->sig);
472 regs->gprs[3] = (unsigned long) &frame->info;
473 regs->gprs[4] = (unsigned long) &frame->uc;
474 regs->gprs[5] = task_thread_info(current)->last_break;
475 return 0;
476 }
477
478 static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
479 struct pt_regs *regs)
480 {
481 int ret;
482
483 /* Set up the stack frame */
484 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
485 ret = setup_rt_frame(ksig, oldset, regs);
486 else
487 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
488
489 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
490 }
491
492 /*
493 * Note that 'init' is a special process: it doesn't get signals it doesn't
494 * want to handle. Thus you cannot kill init even with a SIGKILL even by
495 * mistake.
496 *
497 * Note that we go through the signals twice: once to check the signals that
498 * the kernel can handle, and then we build all the user-level signal handling
499 * stack-frames in one go after that.
500 */
501 void do_signal(struct pt_regs *regs)
502 {
503 struct ksignal ksig;
504 sigset_t *oldset = sigmask_to_save();
505
506 /*
507 * Get signal to deliver. When running under ptrace, at this point
508 * the debugger may change all our registers, including the system
509 * call information.
510 */
511 current_thread_info()->system_call =
512 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
513
514 if (get_signal(&ksig)) {
515 /* Whee! Actually deliver the signal. */
516 if (current_thread_info()->system_call) {
517 regs->int_code = current_thread_info()->system_call;
518 /* Check for system call restarting. */
519 switch (regs->gprs[2]) {
520 case -ERESTART_RESTARTBLOCK:
521 case -ERESTARTNOHAND:
522 regs->gprs[2] = -EINTR;
523 break;
524 case -ERESTARTSYS:
525 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
526 regs->gprs[2] = -EINTR;
527 break;
528 }
529 /* fallthrough */
530 case -ERESTARTNOINTR:
531 regs->gprs[2] = regs->orig_gpr2;
532 regs->psw.addr =
533 __rewind_psw(regs->psw,
534 regs->int_code >> 16);
535 break;
536 }
537 }
538 /* No longer in a system call */
539 clear_pt_regs_flag(regs, PIF_SYSCALL);
540
541 if (is_compat_task())
542 handle_signal32(&ksig, oldset, regs);
543 else
544 handle_signal(&ksig, oldset, regs);
545 return;
546 }
547
548 /* No handlers present - check for system call restart */
549 clear_pt_regs_flag(regs, PIF_SYSCALL);
550 if (current_thread_info()->system_call) {
551 regs->int_code = current_thread_info()->system_call;
552 switch (regs->gprs[2]) {
553 case -ERESTART_RESTARTBLOCK:
554 /* Restart with sys_restart_syscall */
555 regs->int_code = __NR_restart_syscall;
556 /* fallthrough */
557 case -ERESTARTNOHAND:
558 case -ERESTARTSYS:
559 case -ERESTARTNOINTR:
560 /* Restart system call with magic TIF bit. */
561 regs->gprs[2] = regs->orig_gpr2;
562 set_pt_regs_flag(regs, PIF_SYSCALL);
563 if (test_thread_flag(TIF_SINGLE_STEP))
564 clear_pt_regs_flag(regs, PIF_PER_TRAP);
565 break;
566 }
567 }
568
569 /*
570 * If there's no signal to deliver, we just put the saved sigmask back.
571 */
572 restore_saved_sigmask();
573 }
574
575 void do_notify_resume(struct pt_regs *regs)
576 {
577 clear_thread_flag(TIF_NOTIFY_RESUME);
578 tracehook_notify_resume(regs);
579 }
Linux with added FPC-III support