Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * linux/arch/alpha/kernel/signal.c
4 *
5 * Copyright (C) 1995 Linus Torvalds
6 *
7 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 */
9
10#include <linux/sched/signal.h>
11#include <linux/sched/task_stack.h>
12#include <linux/kernel.h>
13#include <linux/signal.h>
14#include <linux/errno.h>
15#include <linux/wait.h>
16#include <linux/ptrace.h>
17#include <linux/unistd.h>
18#include <linux/mm.h>
19#include <linux/smp.h>
20#include <linux/stddef.h>
21#include <linux/tty.h>
22#include <linux/binfmts.h>
23#include <linux/bitops.h>
24#include <linux/syscalls.h>
25#include <linux/resume_user_mode.h>
26
27#include <linux/uaccess.h>
28#include <asm/sigcontext.h>
29#include <asm/ucontext.h>
30
31#include "proto.h"
32
33
34#define DEBUG_SIG 0
35
36#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
37
38asmlinkage void ret_from_sys_call(void);
39
40/*
41 * The OSF/1 sigprocmask calling sequence is different from the
42 * C sigprocmask() sequence..
43 */
44SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
45{
46 sigset_t oldmask;
47 sigset_t mask;
48 unsigned long res;
49
50 siginitset(&mask, newmask & _BLOCKABLE);
51 res = sigprocmask(how, &mask, &oldmask);
52 if (!res) {
53 force_successful_syscall_return();
54 res = oldmask.sig[0];
55 }
56 return res;
57}
58
59SYSCALL_DEFINE3(osf_sigaction, int, sig,
60 const struct osf_sigaction __user *, act,
61 struct osf_sigaction __user *, oact)
62{
63 struct k_sigaction new_ka, old_ka;
64 int ret;
65
66 if (act) {
67 old_sigset_t mask;
68 if (!access_ok(act, sizeof(*act)) ||
69 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
70 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
71 __get_user(mask, &act->sa_mask))
72 return -EFAULT;
73 siginitset(&new_ka.sa.sa_mask, mask);
74 new_ka.ka_restorer = NULL;
75 }
76
77 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
78
79 if (!ret && oact) {
80 if (!access_ok(oact, sizeof(*oact)) ||
81 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
82 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
83 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
84 return -EFAULT;
85 }
86
87 return ret;
88}
89
90SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
91 struct sigaction __user *, oact,
92 size_t, sigsetsize, void __user *, restorer)
93{
94 struct k_sigaction new_ka, old_ka;
95 int ret;
96
97 /* XXX: Don't preclude handling different sized sigset_t's. */
98 if (sigsetsize != sizeof(sigset_t))
99 return -EINVAL;
100
101 if (act) {
102 new_ka.ka_restorer = restorer;
103 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
104 return -EFAULT;
105 }
106
107 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
108
109 if (!ret && oact) {
110 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
111 return -EFAULT;
112 }
113
114 return ret;
115}
116
117/*
118 * Do a signal return; undo the signal stack.
119 */
120
121#if _NSIG_WORDS > 1
122# error "Non SA_SIGINFO frame needs rearranging"
123#endif
124
125struct sigframe
126{
127 struct sigcontext sc;
128 unsigned int retcode[3];
129};
130
131struct rt_sigframe
132{
133 struct siginfo info;
134 struct ucontext uc;
135 unsigned int retcode[3];
136};
137
138/* If this changes, userland unwinders that Know Things about our signal
139 frame will break. Do not undertake lightly. It also implies an ABI
140 change wrt the size of siginfo_t, which may cause some pain. */
141extern char compile_time_assert
142 [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
143
144#define INSN_MOV_R30_R16 0x47fe0410
145#define INSN_LDI_R0 0x201f0000
146#define INSN_CALLSYS 0x00000083
147
148static long
149restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
150{
151 unsigned long usp;
152 struct switch_stack *sw = (struct switch_stack *)regs - 1;
153 long err = __get_user(regs->pc, &sc->sc_pc);
154
155 current->restart_block.fn = do_no_restart_syscall;
156 current_thread_info()->status |= TS_SAVED_FP | TS_RESTORE_FP;
157
158 sw->r26 = (unsigned long) ret_from_sys_call;
159
160 err |= __get_user(regs->r0, sc->sc_regs+0);
161 err |= __get_user(regs->r1, sc->sc_regs+1);
162 err |= __get_user(regs->r2, sc->sc_regs+2);
163 err |= __get_user(regs->r3, sc->sc_regs+3);
164 err |= __get_user(regs->r4, sc->sc_regs+4);
165 err |= __get_user(regs->r5, sc->sc_regs+5);
166 err |= __get_user(regs->r6, sc->sc_regs+6);
167 err |= __get_user(regs->r7, sc->sc_regs+7);
168 err |= __get_user(regs->r8, sc->sc_regs+8);
169 err |= __get_user(sw->r9, sc->sc_regs+9);
170 err |= __get_user(sw->r10, sc->sc_regs+10);
171 err |= __get_user(sw->r11, sc->sc_regs+11);
172 err |= __get_user(sw->r12, sc->sc_regs+12);
173 err |= __get_user(sw->r13, sc->sc_regs+13);
174 err |= __get_user(sw->r14, sc->sc_regs+14);
175 err |= __get_user(sw->r15, sc->sc_regs+15);
176 err |= __get_user(regs->r16, sc->sc_regs+16);
177 err |= __get_user(regs->r17, sc->sc_regs+17);
178 err |= __get_user(regs->r18, sc->sc_regs+18);
179 err |= __get_user(regs->r19, sc->sc_regs+19);
180 err |= __get_user(regs->r20, sc->sc_regs+20);
181 err |= __get_user(regs->r21, sc->sc_regs+21);
182 err |= __get_user(regs->r22, sc->sc_regs+22);
183 err |= __get_user(regs->r23, sc->sc_regs+23);
184 err |= __get_user(regs->r24, sc->sc_regs+24);
185 err |= __get_user(regs->r25, sc->sc_regs+25);
186 err |= __get_user(regs->r26, sc->sc_regs+26);
187 err |= __get_user(regs->r27, sc->sc_regs+27);
188 err |= __get_user(regs->r28, sc->sc_regs+28);
189 err |= __get_user(regs->gp, sc->sc_regs+29);
190 err |= __get_user(usp, sc->sc_regs+30);
191 wrusp(usp);
192
193 err |= __copy_from_user(current_thread_info()->fp,
194 sc->sc_fpregs, 31 * 8);
195 err |= __get_user(current_thread_info()->fp[31], &sc->sc_fpcr);
196
197 return err;
198}
199
200/* Note that this syscall is also used by setcontext(3) to install
201 a given sigcontext. This because it's impossible to set *all*
202 registers and transfer control from userland. */
203
204asmlinkage void
205do_sigreturn(struct sigcontext __user *sc)
206{
207 struct pt_regs *regs = current_pt_regs();
208 sigset_t set;
209
210 /* Verify that it's a good sigcontext before using it */
211 if (!access_ok(sc, sizeof(*sc)))
212 goto give_sigsegv;
213 if (__get_user(set.sig[0], &sc->sc_mask))
214 goto give_sigsegv;
215
216 set_current_blocked(&set);
217
218 if (restore_sigcontext(sc, regs))
219 goto give_sigsegv;
220
221 /* Send SIGTRAP if we're single-stepping: */
222 if (ptrace_cancel_bpt (current)) {
223 send_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *) regs->pc,
224 current);
225 }
226 return;
227
228give_sigsegv:
229 force_sig(SIGSEGV);
230}
231
232asmlinkage void
233do_rt_sigreturn(struct rt_sigframe __user *frame)
234{
235 struct pt_regs *regs = current_pt_regs();
236 sigset_t set;
237
238 /* Verify that it's a good ucontext_t before using it */
239 if (!access_ok(&frame->uc, sizeof(frame->uc)))
240 goto give_sigsegv;
241 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
242 goto give_sigsegv;
243
244 set_current_blocked(&set);
245
246 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
247 goto give_sigsegv;
248
249 /* Send SIGTRAP if we're single-stepping: */
250 if (ptrace_cancel_bpt (current)) {
251 send_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *) regs->pc,
252 current);
253 }
254 return;
255
256give_sigsegv:
257 force_sig(SIGSEGV);
258}
259
260
261/*
262 * Set up a signal frame.
263 */
264
265static inline void __user *
266get_sigframe(struct ksignal *ksig, unsigned long sp, size_t frame_size)
267{
268 return (void __user *)((sigsp(sp, ksig) - frame_size) & -32ul);
269}
270
271static long
272setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
273 unsigned long mask, unsigned long sp)
274{
275 struct switch_stack *sw = (struct switch_stack *)regs - 1;
276 long err = 0;
277
278 err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
279 err |= __put_user(mask, &sc->sc_mask);
280 err |= __put_user(regs->pc, &sc->sc_pc);
281 err |= __put_user(8, &sc->sc_ps);
282
283 err |= __put_user(regs->r0 , sc->sc_regs+0);
284 err |= __put_user(regs->r1 , sc->sc_regs+1);
285 err |= __put_user(regs->r2 , sc->sc_regs+2);
286 err |= __put_user(regs->r3 , sc->sc_regs+3);
287 err |= __put_user(regs->r4 , sc->sc_regs+4);
288 err |= __put_user(regs->r5 , sc->sc_regs+5);
289 err |= __put_user(regs->r6 , sc->sc_regs+6);
290 err |= __put_user(regs->r7 , sc->sc_regs+7);
291 err |= __put_user(regs->r8 , sc->sc_regs+8);
292 err |= __put_user(sw->r9 , sc->sc_regs+9);
293 err |= __put_user(sw->r10 , sc->sc_regs+10);
294 err |= __put_user(sw->r11 , sc->sc_regs+11);
295 err |= __put_user(sw->r12 , sc->sc_regs+12);
296 err |= __put_user(sw->r13 , sc->sc_regs+13);
297 err |= __put_user(sw->r14 , sc->sc_regs+14);
298 err |= __put_user(sw->r15 , sc->sc_regs+15);
299 err |= __put_user(regs->r16, sc->sc_regs+16);
300 err |= __put_user(regs->r17, sc->sc_regs+17);
301 err |= __put_user(regs->r18, sc->sc_regs+18);
302 err |= __put_user(regs->r19, sc->sc_regs+19);
303 err |= __put_user(regs->r20, sc->sc_regs+20);
304 err |= __put_user(regs->r21, sc->sc_regs+21);
305 err |= __put_user(regs->r22, sc->sc_regs+22);
306 err |= __put_user(regs->r23, sc->sc_regs+23);
307 err |= __put_user(regs->r24, sc->sc_regs+24);
308 err |= __put_user(regs->r25, sc->sc_regs+25);
309 err |= __put_user(regs->r26, sc->sc_regs+26);
310 err |= __put_user(regs->r27, sc->sc_regs+27);
311 err |= __put_user(regs->r28, sc->sc_regs+28);
312 err |= __put_user(regs->gp , sc->sc_regs+29);
313 err |= __put_user(sp, sc->sc_regs+30);
314 err |= __put_user(0, sc->sc_regs+31);
315
316 err |= __copy_to_user(sc->sc_fpregs,
317 current_thread_info()->fp, 31 * 8);
318 err |= __put_user(0, sc->sc_fpregs+31);
319 err |= __put_user(current_thread_info()->fp[31], &sc->sc_fpcr);
320
321 err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
322 err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
323 err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
324
325 return err;
326}
327
328static int
329setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
330{
331 unsigned long oldsp, r26, err = 0;
332 struct sigframe __user *frame;
333
334 oldsp = rdusp();
335 frame = get_sigframe(ksig, oldsp, sizeof(*frame));
336 if (!access_ok(frame, sizeof(*frame)))
337 return -EFAULT;
338
339 err |= setup_sigcontext(&frame->sc, regs, set->sig[0], oldsp);
340 if (err)
341 return -EFAULT;
342
343 /* Set up to return from userspace. If provided, use a stub
344 already in userspace. */
345 r26 = (unsigned long) ksig->ka.ka_restorer;
346 if (!r26) {
347 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
348 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
349 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
350 imb();
351 r26 = (unsigned long) frame->retcode;
352 }
353
354 /* Check that everything was written properly. */
355 if (err)
356 return err;
357
358 /* "Return" to the handler */
359 regs->r26 = r26;
360 regs->r27 = regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
361 regs->r16 = ksig->sig; /* a0: signal number */
362 regs->r17 = 0; /* a1: exception code */
363 regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
364 wrusp((unsigned long) frame);
365
366#if DEBUG_SIG
367 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
368 current->comm, current->pid, frame, regs->pc, regs->r26);
369#endif
370 return 0;
371}
372
373static int
374setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
375{
376 unsigned long oldsp, r26, err = 0;
377 struct rt_sigframe __user *frame;
378
379 oldsp = rdusp();
380 frame = get_sigframe(ksig, oldsp, sizeof(*frame));
381 if (!access_ok(frame, sizeof(*frame)))
382 return -EFAULT;
383
384 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
385
386 /* Create the ucontext. */
387 err |= __put_user(0, &frame->uc.uc_flags);
388 err |= __put_user(0, &frame->uc.uc_link);
389 err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
390 err |= __save_altstack(&frame->uc.uc_stack, oldsp);
391 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs,
392 set->sig[0], oldsp);
393 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
394 if (err)
395 return -EFAULT;
396
397 /* Set up to return from userspace. If provided, use a stub
398 already in userspace. */
399 r26 = (unsigned long) ksig->ka.ka_restorer;
400 if (!r26) {
401 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
402 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
403 frame->retcode+1);
404 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
405 imb();
406 r26 = (unsigned long) frame->retcode;
407 }
408
409 if (err)
410 return -EFAULT;
411
412 /* "Return" to the handler */
413 regs->r26 = r26;
414 regs->r27 = regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
415 regs->r16 = ksig->sig; /* a0: signal number */
416 regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
417 regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */
418 wrusp((unsigned long) frame);
419
420#if DEBUG_SIG
421 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
422 current->comm, current->pid, frame, regs->pc, regs->r26);
423#endif
424
425 return 0;
426}
427
428
429/*
430 * OK, we're invoking a handler.
431 */
432static inline void
433handle_signal(struct ksignal *ksig, struct pt_regs *regs)
434{
435 sigset_t *oldset = sigmask_to_save();
436 int ret;
437
438 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
439 ret = setup_rt_frame(ksig, oldset, regs);
440 else
441 ret = setup_frame(ksig, oldset, regs);
442
443 signal_setup_done(ret, ksig, 0);
444}
445
446static inline void
447syscall_restart(unsigned long r0, unsigned long r19,
448 struct pt_regs *regs, struct k_sigaction *ka)
449{
450 switch (regs->r0) {
451 case ERESTARTSYS:
452 if (!(ka->sa.sa_flags & SA_RESTART)) {
453 case ERESTARTNOHAND:
454 regs->r0 = EINTR;
455 break;
456 }
457 fallthrough;
458 case ERESTARTNOINTR:
459 regs->r0 = r0; /* reset v0 and a3 and replay syscall */
460 regs->r19 = r19;
461 regs->pc -= 4;
462 break;
463 case ERESTART_RESTARTBLOCK:
464 regs->r0 = EINTR;
465 break;
466 }
467}
468
469
470/*
471 * Note that 'init' is a special process: it doesn't get signals it doesn't
472 * want to handle. Thus you cannot kill init even with a SIGKILL even by
473 * mistake.
474 *
475 * Note that we go through the signals twice: once to check the signals that
476 * the kernel can handle, and then we build all the user-level signal handling
477 * stack-frames in one go after that.
478 *
479 * "r0" and "r19" are the registers we need to restore for system call
480 * restart. "r0" is also used as an indicator whether we can restart at
481 * all (if we get here from anything but a syscall return, it will be 0)
482 */
483static void
484do_signal(struct pt_regs *regs, unsigned long r0, unsigned long r19)
485{
486 unsigned long single_stepping = ptrace_cancel_bpt(current);
487 struct ksignal ksig;
488
489 /* This lets the debugger run, ... */
490 if (get_signal(&ksig)) {
491 /* ... so re-check the single stepping. */
492 single_stepping |= ptrace_cancel_bpt(current);
493 /* Whee! Actually deliver the signal. */
494 if (r0)
495 syscall_restart(r0, r19, regs, &ksig.ka);
496 handle_signal(&ksig, regs);
497 } else {
498 single_stepping |= ptrace_cancel_bpt(current);
499 if (r0) {
500 switch (regs->r0) {
501 case ERESTARTNOHAND:
502 case ERESTARTSYS:
503 case ERESTARTNOINTR:
504 /* Reset v0 and a3 and replay syscall. */
505 regs->r0 = r0;
506 regs->r19 = r19;
507 regs->pc -= 4;
508 break;
509 case ERESTART_RESTARTBLOCK:
510 /* Set v0 to the restart_syscall and replay */
511 regs->r0 = __NR_restart_syscall;
512 regs->pc -= 4;
513 break;
514 }
515 }
516 restore_saved_sigmask();
517 }
518 if (single_stepping)
519 ptrace_set_bpt(current); /* re-set breakpoint */
520}
521
522void
523do_work_pending(struct pt_regs *regs, unsigned long thread_flags,
524 unsigned long r0, unsigned long r19)
525{
526 do {
527 if (thread_flags & _TIF_NEED_RESCHED) {
528 schedule();
529 } else {
530 local_irq_enable();
531 if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) {
532 preempt_disable();
533 save_fpu();
534 preempt_enable();
535 do_signal(regs, r0, r19);
536 r0 = 0;
537 } else {
538 resume_user_mode_work(regs);
539 }
540 }
541 local_irq_disable();
542 thread_flags = read_thread_flags();
543 } while (thread_flags & _TIF_WORK_MASK);
544}
1/*
2 * linux/arch/alpha/kernel/signal.c
3 *
4 * Copyright (C) 1995 Linus Torvalds
5 *
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
7 */
8
9#include <linux/sched.h>
10#include <linux/kernel.h>
11#include <linux/signal.h>
12#include <linux/errno.h>
13#include <linux/wait.h>
14#include <linux/ptrace.h>
15#include <linux/unistd.h>
16#include <linux/mm.h>
17#include <linux/smp.h>
18#include <linux/stddef.h>
19#include <linux/tty.h>
20#include <linux/binfmts.h>
21#include <linux/bitops.h>
22#include <linux/syscalls.h>
23#include <linux/tracehook.h>
24
25#include <asm/uaccess.h>
26#include <asm/sigcontext.h>
27#include <asm/ucontext.h>
28
29#include "proto.h"
30
31
32#define DEBUG_SIG 0
33
34#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
35
36asmlinkage void ret_from_sys_call(void);
37static void do_signal(struct pt_regs *, struct switch_stack *,
38 unsigned long, unsigned long);
39
40
41/*
42 * The OSF/1 sigprocmask calling sequence is different from the
43 * C sigprocmask() sequence..
44 */
45SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
46{
47 sigset_t oldmask;
48 sigset_t mask;
49 unsigned long res;
50
51 siginitset(&mask, newmask & _BLOCKABLE);
52 res = sigprocmask(how, &mask, &oldmask);
53 if (!res) {
54 force_successful_syscall_return();
55 res = oldmask.sig[0];
56 }
57 return res;
58}
59
60SYSCALL_DEFINE3(osf_sigaction, int, sig,
61 const struct osf_sigaction __user *, act,
62 struct osf_sigaction __user *, oact)
63{
64 struct k_sigaction new_ka, old_ka;
65 int ret;
66
67 if (act) {
68 old_sigset_t mask;
69 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
70 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
71 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
72 __get_user(mask, &act->sa_mask))
73 return -EFAULT;
74 siginitset(&new_ka.sa.sa_mask, mask);
75 new_ka.ka_restorer = NULL;
76 }
77
78 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
79
80 if (!ret && oact) {
81 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
82 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
83 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
84 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
85 return -EFAULT;
86 }
87
88 return ret;
89}
90
91SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
92 struct sigaction __user *, oact,
93 size_t, sigsetsize, void __user *, restorer)
94{
95 struct k_sigaction new_ka, old_ka;
96 int ret;
97
98 /* XXX: Don't preclude handling different sized sigset_t's. */
99 if (sigsetsize != sizeof(sigset_t))
100 return -EINVAL;
101
102 if (act) {
103 new_ka.ka_restorer = restorer;
104 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
105 return -EFAULT;
106 }
107
108 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
109
110 if (!ret && oact) {
111 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
112 return -EFAULT;
113 }
114
115 return ret;
116}
117
118/*
119 * Atomically swap in the new signal mask, and wait for a signal.
120 */
121SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
122{
123 mask &= _BLOCKABLE;
124 spin_lock_irq(¤t->sighand->siglock);
125 current->saved_sigmask = current->blocked;
126 siginitset(¤t->blocked, mask);
127 recalc_sigpending();
128 spin_unlock_irq(¤t->sighand->siglock);
129
130 current->state = TASK_INTERRUPTIBLE;
131 schedule();
132 set_thread_flag(TIF_RESTORE_SIGMASK);
133 return -ERESTARTNOHAND;
134}
135
136asmlinkage int
137sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
138{
139 return do_sigaltstack(uss, uoss, rdusp());
140}
141
142/*
143 * Do a signal return; undo the signal stack.
144 */
145
146#if _NSIG_WORDS > 1
147# error "Non SA_SIGINFO frame needs rearranging"
148#endif
149
150struct sigframe
151{
152 struct sigcontext sc;
153 unsigned int retcode[3];
154};
155
156struct rt_sigframe
157{
158 struct siginfo info;
159 struct ucontext uc;
160 unsigned int retcode[3];
161};
162
163/* If this changes, userland unwinders that Know Things about our signal
164 frame will break. Do not undertake lightly. It also implies an ABI
165 change wrt the size of siginfo_t, which may cause some pain. */
166extern char compile_time_assert
167 [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
168
169#define INSN_MOV_R30_R16 0x47fe0410
170#define INSN_LDI_R0 0x201f0000
171#define INSN_CALLSYS 0x00000083
172
173static long
174restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
175 struct switch_stack *sw)
176{
177 unsigned long usp;
178 long i, err = __get_user(regs->pc, &sc->sc_pc);
179
180 current_thread_info()->restart_block.fn = do_no_restart_syscall;
181
182 sw->r26 = (unsigned long) ret_from_sys_call;
183
184 err |= __get_user(regs->r0, sc->sc_regs+0);
185 err |= __get_user(regs->r1, sc->sc_regs+1);
186 err |= __get_user(regs->r2, sc->sc_regs+2);
187 err |= __get_user(regs->r3, sc->sc_regs+3);
188 err |= __get_user(regs->r4, sc->sc_regs+4);
189 err |= __get_user(regs->r5, sc->sc_regs+5);
190 err |= __get_user(regs->r6, sc->sc_regs+6);
191 err |= __get_user(regs->r7, sc->sc_regs+7);
192 err |= __get_user(regs->r8, sc->sc_regs+8);
193 err |= __get_user(sw->r9, sc->sc_regs+9);
194 err |= __get_user(sw->r10, sc->sc_regs+10);
195 err |= __get_user(sw->r11, sc->sc_regs+11);
196 err |= __get_user(sw->r12, sc->sc_regs+12);
197 err |= __get_user(sw->r13, sc->sc_regs+13);
198 err |= __get_user(sw->r14, sc->sc_regs+14);
199 err |= __get_user(sw->r15, sc->sc_regs+15);
200 err |= __get_user(regs->r16, sc->sc_regs+16);
201 err |= __get_user(regs->r17, sc->sc_regs+17);
202 err |= __get_user(regs->r18, sc->sc_regs+18);
203 err |= __get_user(regs->r19, sc->sc_regs+19);
204 err |= __get_user(regs->r20, sc->sc_regs+20);
205 err |= __get_user(regs->r21, sc->sc_regs+21);
206 err |= __get_user(regs->r22, sc->sc_regs+22);
207 err |= __get_user(regs->r23, sc->sc_regs+23);
208 err |= __get_user(regs->r24, sc->sc_regs+24);
209 err |= __get_user(regs->r25, sc->sc_regs+25);
210 err |= __get_user(regs->r26, sc->sc_regs+26);
211 err |= __get_user(regs->r27, sc->sc_regs+27);
212 err |= __get_user(regs->r28, sc->sc_regs+28);
213 err |= __get_user(regs->gp, sc->sc_regs+29);
214 err |= __get_user(usp, sc->sc_regs+30);
215 wrusp(usp);
216
217 for (i = 0; i < 31; i++)
218 err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
219 err |= __get_user(sw->fp[31], &sc->sc_fpcr);
220
221 return err;
222}
223
224/* Note that this syscall is also used by setcontext(3) to install
225 a given sigcontext. This because it's impossible to set *all*
226 registers and transfer control from userland. */
227
228asmlinkage void
229do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
230 struct switch_stack *sw)
231{
232 sigset_t set;
233
234 /* Verify that it's a good sigcontext before using it */
235 if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
236 goto give_sigsegv;
237 if (__get_user(set.sig[0], &sc->sc_mask))
238 goto give_sigsegv;
239
240 sigdelsetmask(&set, ~_BLOCKABLE);
241 spin_lock_irq(¤t->sighand->siglock);
242 current->blocked = set;
243 recalc_sigpending();
244 spin_unlock_irq(¤t->sighand->siglock);
245
246 if (restore_sigcontext(sc, regs, sw))
247 goto give_sigsegv;
248
249 /* Send SIGTRAP if we're single-stepping: */
250 if (ptrace_cancel_bpt (current)) {
251 siginfo_t info;
252
253 info.si_signo = SIGTRAP;
254 info.si_errno = 0;
255 info.si_code = TRAP_BRKPT;
256 info.si_addr = (void __user *) regs->pc;
257 info.si_trapno = 0;
258 send_sig_info(SIGTRAP, &info, current);
259 }
260 return;
261
262give_sigsegv:
263 force_sig(SIGSEGV, current);
264}
265
266asmlinkage void
267do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
268 struct switch_stack *sw)
269{
270 sigset_t set;
271
272 /* Verify that it's a good ucontext_t before using it */
273 if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
274 goto give_sigsegv;
275 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
276 goto give_sigsegv;
277
278 sigdelsetmask(&set, ~_BLOCKABLE);
279 spin_lock_irq(¤t->sighand->siglock);
280 current->blocked = set;
281 recalc_sigpending();
282 spin_unlock_irq(¤t->sighand->siglock);
283
284 if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
285 goto give_sigsegv;
286
287 /* Send SIGTRAP if we're single-stepping: */
288 if (ptrace_cancel_bpt (current)) {
289 siginfo_t info;
290
291 info.si_signo = SIGTRAP;
292 info.si_errno = 0;
293 info.si_code = TRAP_BRKPT;
294 info.si_addr = (void __user *) regs->pc;
295 info.si_trapno = 0;
296 send_sig_info(SIGTRAP, &info, current);
297 }
298 return;
299
300give_sigsegv:
301 force_sig(SIGSEGV, current);
302}
303
304
305/*
306 * Set up a signal frame.
307 */
308
309static inline void __user *
310get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
311{
312 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
313 sp = current->sas_ss_sp + current->sas_ss_size;
314
315 return (void __user *)((sp - frame_size) & -32ul);
316}
317
318static long
319setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
320 struct switch_stack *sw, unsigned long mask, unsigned long sp)
321{
322 long i, err = 0;
323
324 err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
325 err |= __put_user(mask, &sc->sc_mask);
326 err |= __put_user(regs->pc, &sc->sc_pc);
327 err |= __put_user(8, &sc->sc_ps);
328
329 err |= __put_user(regs->r0 , sc->sc_regs+0);
330 err |= __put_user(regs->r1 , sc->sc_regs+1);
331 err |= __put_user(regs->r2 , sc->sc_regs+2);
332 err |= __put_user(regs->r3 , sc->sc_regs+3);
333 err |= __put_user(regs->r4 , sc->sc_regs+4);
334 err |= __put_user(regs->r5 , sc->sc_regs+5);
335 err |= __put_user(regs->r6 , sc->sc_regs+6);
336 err |= __put_user(regs->r7 , sc->sc_regs+7);
337 err |= __put_user(regs->r8 , sc->sc_regs+8);
338 err |= __put_user(sw->r9 , sc->sc_regs+9);
339 err |= __put_user(sw->r10 , sc->sc_regs+10);
340 err |= __put_user(sw->r11 , sc->sc_regs+11);
341 err |= __put_user(sw->r12 , sc->sc_regs+12);
342 err |= __put_user(sw->r13 , sc->sc_regs+13);
343 err |= __put_user(sw->r14 , sc->sc_regs+14);
344 err |= __put_user(sw->r15 , sc->sc_regs+15);
345 err |= __put_user(regs->r16, sc->sc_regs+16);
346 err |= __put_user(regs->r17, sc->sc_regs+17);
347 err |= __put_user(regs->r18, sc->sc_regs+18);
348 err |= __put_user(regs->r19, sc->sc_regs+19);
349 err |= __put_user(regs->r20, sc->sc_regs+20);
350 err |= __put_user(regs->r21, sc->sc_regs+21);
351 err |= __put_user(regs->r22, sc->sc_regs+22);
352 err |= __put_user(regs->r23, sc->sc_regs+23);
353 err |= __put_user(regs->r24, sc->sc_regs+24);
354 err |= __put_user(regs->r25, sc->sc_regs+25);
355 err |= __put_user(regs->r26, sc->sc_regs+26);
356 err |= __put_user(regs->r27, sc->sc_regs+27);
357 err |= __put_user(regs->r28, sc->sc_regs+28);
358 err |= __put_user(regs->gp , sc->sc_regs+29);
359 err |= __put_user(sp, sc->sc_regs+30);
360 err |= __put_user(0, sc->sc_regs+31);
361
362 for (i = 0; i < 31; i++)
363 err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
364 err |= __put_user(0, sc->sc_fpregs+31);
365 err |= __put_user(sw->fp[31], &sc->sc_fpcr);
366
367 err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
368 err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
369 err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
370
371 return err;
372}
373
374static int
375setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
376 struct pt_regs *regs, struct switch_stack * sw)
377{
378 unsigned long oldsp, r26, err = 0;
379 struct sigframe __user *frame;
380
381 oldsp = rdusp();
382 frame = get_sigframe(ka, oldsp, sizeof(*frame));
383 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
384 goto give_sigsegv;
385
386 err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
387 if (err)
388 goto give_sigsegv;
389
390 /* Set up to return from userspace. If provided, use a stub
391 already in userspace. */
392 if (ka->ka_restorer) {
393 r26 = (unsigned long) ka->ka_restorer;
394 } else {
395 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
396 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
397 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
398 imb();
399 r26 = (unsigned long) frame->retcode;
400 }
401
402 /* Check that everything was written properly. */
403 if (err)
404 goto give_sigsegv;
405
406 /* "Return" to the handler */
407 regs->r26 = r26;
408 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
409 regs->r16 = sig; /* a0: signal number */
410 regs->r17 = 0; /* a1: exception code */
411 regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
412 wrusp((unsigned long) frame);
413
414#if DEBUG_SIG
415 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
416 current->comm, current->pid, frame, regs->pc, regs->r26);
417#endif
418
419 return 0;
420
421give_sigsegv:
422 force_sigsegv(sig, current);
423 return -EFAULT;
424}
425
426static int
427setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
428 sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
429{
430 unsigned long oldsp, r26, err = 0;
431 struct rt_sigframe __user *frame;
432
433 oldsp = rdusp();
434 frame = get_sigframe(ka, oldsp, sizeof(*frame));
435 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
436 goto give_sigsegv;
437
438 err |= copy_siginfo_to_user(&frame->info, info);
439
440 /* Create the ucontext. */
441 err |= __put_user(0, &frame->uc.uc_flags);
442 err |= __put_user(0, &frame->uc.uc_link);
443 err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
444 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
445 err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
446 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
447 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
448 set->sig[0], oldsp);
449 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
450 if (err)
451 goto give_sigsegv;
452
453 /* Set up to return from userspace. If provided, use a stub
454 already in userspace. */
455 if (ka->ka_restorer) {
456 r26 = (unsigned long) ka->ka_restorer;
457 } else {
458 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
459 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
460 frame->retcode+1);
461 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
462 imb();
463 r26 = (unsigned long) frame->retcode;
464 }
465
466 if (err)
467 goto give_sigsegv;
468
469 /* "Return" to the handler */
470 regs->r26 = r26;
471 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
472 regs->r16 = sig; /* a0: signal number */
473 regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
474 regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */
475 wrusp((unsigned long) frame);
476
477#if DEBUG_SIG
478 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
479 current->comm, current->pid, frame, regs->pc, regs->r26);
480#endif
481
482 return 0;
483
484give_sigsegv:
485 force_sigsegv(sig, current);
486 return -EFAULT;
487}
488
489
490/*
491 * OK, we're invoking a handler.
492 */
493static inline int
494handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
495 sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw)
496{
497 int ret;
498
499 if (ka->sa.sa_flags & SA_SIGINFO)
500 ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
501 else
502 ret = setup_frame(sig, ka, oldset, regs, sw);
503
504 if (ret == 0) {
505 spin_lock_irq(¤t->sighand->siglock);
506 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
507 if (!(ka->sa.sa_flags & SA_NODEFER))
508 sigaddset(¤t->blocked,sig);
509 recalc_sigpending();
510 spin_unlock_irq(¤t->sighand->siglock);
511 }
512
513 return ret;
514}
515
516static inline void
517syscall_restart(unsigned long r0, unsigned long r19,
518 struct pt_regs *regs, struct k_sigaction *ka)
519{
520 switch (regs->r0) {
521 case ERESTARTSYS:
522 if (!(ka->sa.sa_flags & SA_RESTART)) {
523 case ERESTARTNOHAND:
524 regs->r0 = EINTR;
525 break;
526 }
527 /* fallthrough */
528 case ERESTARTNOINTR:
529 regs->r0 = r0; /* reset v0 and a3 and replay syscall */
530 regs->r19 = r19;
531 regs->pc -= 4;
532 break;
533 case ERESTART_RESTARTBLOCK:
534 regs->r0 = EINTR;
535 break;
536 }
537}
538
539
540/*
541 * Note that 'init' is a special process: it doesn't get signals it doesn't
542 * want to handle. Thus you cannot kill init even with a SIGKILL even by
543 * mistake.
544 *
545 * Note that we go through the signals twice: once to check the signals that
546 * the kernel can handle, and then we build all the user-level signal handling
547 * stack-frames in one go after that.
548 *
549 * "r0" and "r19" are the registers we need to restore for system call
550 * restart. "r0" is also used as an indicator whether we can restart at
551 * all (if we get here from anything but a syscall return, it will be 0)
552 */
553static void
554do_signal(struct pt_regs * regs, struct switch_stack * sw,
555 unsigned long r0, unsigned long r19)
556{
557 siginfo_t info;
558 int signr;
559 unsigned long single_stepping = ptrace_cancel_bpt(current);
560 struct k_sigaction ka;
561 sigset_t *oldset;
562
563 if (test_thread_flag(TIF_RESTORE_SIGMASK))
564 oldset = ¤t->saved_sigmask;
565 else
566 oldset = ¤t->blocked;
567
568 /* This lets the debugger run, ... */
569 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
570
571 /* ... so re-check the single stepping. */
572 single_stepping |= ptrace_cancel_bpt(current);
573
574 if (signr > 0) {
575 /* Whee! Actually deliver the signal. */
576 if (r0)
577 syscall_restart(r0, r19, regs, &ka);
578 if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
579 /* A signal was successfully delivered, and the
580 saved sigmask was stored on the signal frame,
581 and will be restored by sigreturn. So we can
582 simply clear the restore sigmask flag. */
583 if (test_thread_flag(TIF_RESTORE_SIGMASK))
584 clear_thread_flag(TIF_RESTORE_SIGMASK);
585 }
586 if (single_stepping)
587 ptrace_set_bpt(current); /* re-set bpt */
588 return;
589 }
590
591 if (r0) {
592 switch (regs->r0) {
593 case ERESTARTNOHAND:
594 case ERESTARTSYS:
595 case ERESTARTNOINTR:
596 /* Reset v0 and a3 and replay syscall. */
597 regs->r0 = r0;
598 regs->r19 = r19;
599 regs->pc -= 4;
600 break;
601 case ERESTART_RESTARTBLOCK:
602 /* Force v0 to the restart syscall and reply. */
603 regs->r0 = __NR_restart_syscall;
604 regs->pc -= 4;
605 break;
606 }
607 }
608
609 /* If there's no signal to deliver, we just restore the saved mask. */
610 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
611 clear_thread_flag(TIF_RESTORE_SIGMASK);
612 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
613 }
614
615 if (single_stepping)
616 ptrace_set_bpt(current); /* re-set breakpoint */
617}
618
619void
620do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
621 unsigned long thread_info_flags,
622 unsigned long r0, unsigned long r19)
623{
624 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
625 do_signal(regs, sw, r0, r19);
626
627 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
628 clear_thread_flag(TIF_NOTIFY_RESUME);
629 tracehook_notify_resume(regs);
630 if (current->replacement_session_keyring)
631 key_replace_session_keyring();
632 }
633}