1
2
3
4
5
6
7
8
9
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61struct 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;
69};
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96struct 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
105static void store_sigregs(void)
106{
107 save_access_regs(current->thread.acrs);
108 save_fpu_regs();
109}
110
111
112static void load_sigregs(void)
113{
114 restore_access_regs(current->thread.acrs);
115}
116
117
118static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
119{
120 _sigregs user_sregs;
121
122
123
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, ®s->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, ¤t->thread.fpu);
131 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
132 return -EFAULT;
133 return 0;
134}
135
136static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
137{
138 _sigregs user_sregs;
139
140
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
150 if (test_fp_ctl(user_sregs.fpregs.fpc))
151 return -EINVAL;
152
153
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
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
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(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
165 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
166 sizeof(current->thread.acrs));
167
168 fpregs_load(&user_sregs.fpregs, ¤t->thread.fpu);
169
170 clear_pt_regs_flag(regs, PIF_SYSCALL);
171 return 0;
172}
173
174
175static 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
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
195static 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
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
215SYSCALL_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];
232badframe:
233 force_sig(SIGSEGV, current);
234 return 0;
235}
236
237SYSCALL_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];
256badframe:
257 force_sig(SIGSEGV, current);
258 return 0;
259}
260
261
262
263
264static inline void __user *
265get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
266{
267 unsigned long sp;
268
269
270 sp = regs->gprs[15];
271
272
273 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
274 return (void __user *) -1UL;
275
276
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
285static 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
295
296
297
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
307 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
308 return -EFAULT;
309
310
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
317 store_sigregs();
318
319
320 if (save_sigregs(regs, &frame->sregs))
321 return -EFAULT;
322
323
324 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
325 return -EFAULT;
326
327
328 if (save_sigregs_ext(regs, &frame->sregs_ext))
329 return -EFAULT;
330
331
332
333 if (ka->sa.sa_flags & SA_RESTORER) {
334 restorer = (unsigned long) ka->sa.sa_restorer;
335 } else {
336
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
344 regs->gprs[14] = restorer;
345 regs->gprs[15] = (unsigned long) frame;
346
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
356
357 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
358 sig == SIGTRAP || sig == SIGFPE) {
359
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
367static 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
377
378
379
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
391 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
392 return -EFAULT;
393
394
395
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
406 if (copy_siginfo_to_user(&frame->info, &ksig->info))
407 return -EFAULT;
408
409
410 store_sigregs();
411
412
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
422 regs->gprs[14] = restorer;
423 regs->gprs[15] = (unsigned long) frame;
424
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
437static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
438 struct pt_regs *regs)
439{
440 int ret;
441
442
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
453
454
455
456
457
458
459
460void do_signal(struct pt_regs *regs)
461{
462 struct ksignal ksig;
463 sigset_t *oldset = sigmask_to_save();
464
465
466
467
468
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
475 if (current_thread_info()->system_call) {
476 regs->int_code = current_thread_info()->system_call;
477
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
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
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
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
514 regs->int_code = __NR_restart_syscall;
515
516 case -ERESTARTNOHAND:
517 case -ERESTARTSYS:
518 case -ERESTARTNOINTR:
519
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
530
531 restore_saved_sigmask();
532}
533
534void do_notify_resume(struct pt_regs *regs)
535{
536 clear_thread_flag(TIF_NOTIFY_RESUME);
537 tracehook_notify_resume(regs);
538}
539