1
2
3
4
5
6
7
8
9
10
11
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 <linux/tracehook.h>
28#include <linux/syscalls.h>
29#include <linux/compat.h>
30#include <asm/ucontext.h>
31#include <asm/uaccess.h>
32#include <asm/lowcore.h>
33#include "entry.h"
34
35#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
36
37
38typedef struct
39{
40 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
41 struct sigcontext sc;
42 _sigregs sregs;
43 int signo;
44 __u8 retcode[S390_SYSCALL_SIZE];
45} sigframe;
46
47typedef struct
48{
49 __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
50 __u8 retcode[S390_SYSCALL_SIZE];
51 struct siginfo info;
52 struct ucontext uc;
53} rt_sigframe;
54
55
56
57
58SYSCALL_DEFINE3(sigsuspend, int, history0, int, history1, old_sigset_t, mask)
59{
60 mask &= _BLOCKABLE;
61 spin_lock_irq(¤t->sighand->siglock);
62 current->saved_sigmask = current->blocked;
63 siginitset(¤t->blocked, mask);
64 recalc_sigpending();
65 spin_unlock_irq(¤t->sighand->siglock);
66
67 current->state = TASK_INTERRUPTIBLE;
68 schedule();
69 set_thread_flag(TIF_RESTORE_SIGMASK);
70
71 return -ERESTARTNOHAND;
72}
73
74SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user *, act,
75 struct old_sigaction __user *, oact)
76{
77 struct k_sigaction new_ka, old_ka;
78 int ret;
79
80 if (act) {
81 old_sigset_t mask;
82 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
83 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
84 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
85 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
86 __get_user(mask, &act->sa_mask))
87 return -EFAULT;
88 siginitset(&new_ka.sa.sa_mask, mask);
89 }
90
91 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
92
93 if (!ret && oact) {
94 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
95 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
96 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
97 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
98 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
99 return -EFAULT;
100 }
101
102 return ret;
103}
104
105SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss,
106 stack_t __user *, uoss)
107{
108 struct pt_regs *regs = task_pt_regs(current);
109 return do_sigaltstack(uss, uoss, regs->gprs[15]);
110}
111
112
113static 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
120
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, ®s->gprs, sizeof(sregs->regs.gprs));
124 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
125 sizeof(sregs->regs.acrs));
126
127
128
129
130 save_fp_regs(¤t->thread.fp_regs);
131 memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs,
132 sizeof(s390_fp_regs));
133 return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
134}
135
136
137static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
138{
139 int err;
140 _sigregs user_sregs;
141
142
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(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
152 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
153 sizeof(sregs->regs.acrs));
154 restore_access_regs(current->thread.acrs);
155
156 memcpy(¤t->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(¤t->thread.fp_regs);
161 regs->svcnr = 0;
162 return 0;
163}
164
165SYSCALL_DEFINE0(sigreturn)
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(¤t->sighand->siglock);
178 current->blocked = set;
179 recalc_sigpending();
180 spin_unlock_irq(¤t->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
192SYSCALL_DEFINE0(rt_sigreturn)
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(¤t->sighand->siglock);
205 current->blocked = set;
206 recalc_sigpending();
207 spin_unlock_irq(¤t->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
217badframe:
218 force_sig(SIGSEGV, current);
219 return 0;
220}
221
222
223
224
225
226
227
228
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
236 sp = regs->gprs[15];
237
238
239 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
240 return (void __user *) -1UL;
241
242
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
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
268static int setup_frame(int sig, struct k_sigaction *ka,
269 sigset_t *set, struct pt_regs * regs)
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
277 if (frame == (void __user *) -1UL)
278 goto give_sigsegv;
279
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
289
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
302 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
303 goto give_sigsegv;
304
305
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
313
314 regs->gprs[4] = current->thread.trap_no;
315 regs->gprs[5] = current->thread.prot_addr;
316
317
318 if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
319 goto give_sigsegv;
320 return 0;
321
322give_sigsegv:
323 force_sigsegv(sig, current);
324 return -EFAULT;
325}
326
327static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
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
337 if (frame == (void __user *) -1UL)
338 goto give_sigsegv;
339
340 if (copy_siginfo_to_user(&frame->info, info))
341 goto give_sigsegv;
342
343
344 err |= __put_user(0, &frame->uc.uc_flags);
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);
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
356
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;
363 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
364 (u16 __user *)(frame->retcode)))
365 goto give_sigsegv;
366 }
367
368
369 if (__put_user(regs->gprs[15], (addr_t __user *) frame))
370 goto give_sigsegv;
371
372
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;
379 return 0;
380
381give_sigsegv:
382 force_sigsegv(sig, current);
383 return -EFAULT;
384}
385
386
387
388
389
390static int
391handle_signal(unsigned long sig, struct k_sigaction *ka,
392 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
393{
394 int ret;
395
396
397 if (ka->sa.sa_flags & SA_SIGINFO)
398 ret = setup_rt_frame(sig, ka, info, oldset, regs);
399 else
400 ret = setup_frame(sig, ka, oldset, regs);
401
402 if (ret == 0) {
403 spin_lock_irq(¤t->sighand->siglock);
404 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
405 if (!(ka->sa.sa_flags & SA_NODEFER))
406 sigaddset(¤t->blocked,sig);
407 recalc_sigpending();
408 spin_unlock_irq(¤t->sighand->siglock);
409 }
410
411 return ret;
412}
413
414
415
416
417
418
419
420
421
422
423void do_signal(struct pt_regs *regs)
424{
425 unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
426 siginfo_t info;
427 int signr;
428 struct k_sigaction ka;
429 sigset_t *oldset;
430
431
432
433
434
435
436
437 if (!user_mode(regs))
438 return;
439
440 if (test_thread_flag(TIF_RESTORE_SIGMASK))
441 oldset = ¤t->saved_sigmask;
442 else
443 oldset = ¤t->blocked;
444
445
446 if (regs->svcnr) {
447 continue_addr = regs->psw.addr;
448 restart_addr = continue_addr - regs->ilc;
449 retval = regs->gprs[2];
450
451
452
453 switch (retval) {
454 case -ERESTARTNOHAND:
455 case -ERESTARTSYS:
456 case -ERESTARTNOINTR:
457 regs->gprs[2] = regs->orig_gpr2;
458 regs->psw.addr = restart_addr;
459 break;
460 case -ERESTART_RESTARTBLOCK:
461 regs->gprs[2] = -EINTR;
462 }
463 regs->svcnr = 0;
464 }
465
466
467
468 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
469
470
471
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
484 int ret;
485#ifdef CONFIG_COMPAT
486 if (is_compat_task()) {
487 ret = handle_signal32(signr, &ka, &info, oldset, regs);
488 }
489 else
490#endif
491 ret = handle_signal(signr, &ka, &info, oldset, regs);
492 if (!ret) {
493
494
495
496
497
498
499 if (test_thread_flag(TIF_RESTORE_SIGMASK))
500 clear_thread_flag(TIF_RESTORE_SIGMASK);
501
502
503
504
505
506
507 if (current->thread.per_info.single_step)
508 set_thread_flag(TIF_SINGLE_STEP);
509
510
511
512
513 tracehook_signal_handler(signr, &info, &ka, regs,
514 test_thread_flag(TIF_SINGLE_STEP));
515 }
516 return;
517 }
518
519
520
521
522 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
523 clear_thread_flag(TIF_RESTORE_SIGMASK);
524 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
525 }
526
527
528 if (retval == -ERESTART_RESTARTBLOCK
529 && regs->psw.addr == continue_addr) {
530 regs->gprs[2] = __NR_restart_syscall;
531 set_thread_flag(TIF_RESTART_SVC);
532 }
533}
534
535void do_notify_resume(struct pt_regs *regs)
536{
537 clear_thread_flag(TIF_NOTIFY_RESUME);
538 tracehook_notify_resume(regs);
539 if (current->replacement_session_keyring)
540 key_replace_session_keyring();
541}
542