Loading...
1/*
2 * arch/sh/kernel/signal_64.c
3 *
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 - 2008 Paul Mundt
6 * Copyright (C) 2004 Richard Curnow
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12#include <linux/rwsem.h>
13#include <linux/sched.h>
14#include <linux/mm.h>
15#include <linux/smp.h>
16#include <linux/kernel.h>
17#include <linux/signal.h>
18#include <linux/errno.h>
19#include <linux/wait.h>
20#include <linux/personality.h>
21#include <linux/freezer.h>
22#include <linux/ptrace.h>
23#include <linux/unistd.h>
24#include <linux/stddef.h>
25#include <linux/tracehook.h>
26#include <asm/ucontext.h>
27#include <asm/uaccess.h>
28#include <asm/pgtable.h>
29#include <asm/cacheflush.h>
30#include <asm/fpu.h>
31
32#define REG_RET 9
33#define REG_ARG1 2
34#define REG_ARG2 3
35#define REG_ARG3 4
36#define REG_SP 15
37#define REG_PR 18
38#define REF_REG_RET regs->regs[REG_RET]
39#define REF_REG_SP regs->regs[REG_SP]
40#define DEREF_REG_PR regs->regs[REG_PR]
41
42#define DEBUG_SIG 0
43
44static void
45handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
46 struct pt_regs * regs);
47
48static inline void
49handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
50{
51 /* If we're not from a syscall, bail out */
52 if (regs->syscall_nr < 0)
53 return;
54
55 /* check for system call restart.. */
56 switch (regs->regs[REG_RET]) {
57 case -ERESTART_RESTARTBLOCK:
58 case -ERESTARTNOHAND:
59 no_system_call_restart:
60 regs->regs[REG_RET] = -EINTR;
61 break;
62
63 case -ERESTARTSYS:
64 if (!(sa->sa_flags & SA_RESTART))
65 goto no_system_call_restart;
66 /* fallthrough */
67 case -ERESTARTNOINTR:
68 /* Decode syscall # */
69 regs->regs[REG_RET] = regs->syscall_nr;
70 regs->pc -= 4;
71 break;
72 }
73}
74
75/*
76 * Note that 'init' is a special process: it doesn't get signals it doesn't
77 * want to handle. Thus you cannot kill init even with a SIGKILL even by
78 * mistake.
79 *
80 * Note that we go through the signals twice: once to check the signals that
81 * the kernel can handle, and then we build all the user-level signal handling
82 * stack-frames in one go after that.
83 */
84static void do_signal(struct pt_regs *regs)
85{
86 siginfo_t info;
87 int signr;
88 struct k_sigaction ka;
89
90 /*
91 * We want the common case to go fast, which
92 * is why we may in certain cases get here from
93 * kernel mode. Just return without doing anything
94 * if so.
95 */
96 if (!user_mode(regs))
97 return;
98
99 signr = get_signal_to_deliver(&info, &ka, regs, 0);
100 if (signr > 0) {
101 handle_syscall_restart(regs, &ka.sa);
102
103 /* Whee! Actually deliver the signal. */
104 handle_signal(signr, &info, &ka, regs);
105 return;
106 }
107
108 /* Did we come from a system call? */
109 if (regs->syscall_nr >= 0) {
110 /* Restart the system call - no handlers present */
111 switch (regs->regs[REG_RET]) {
112 case -ERESTARTNOHAND:
113 case -ERESTARTSYS:
114 case -ERESTARTNOINTR:
115 /* Decode Syscall # */
116 regs->regs[REG_RET] = regs->syscall_nr;
117 regs->pc -= 4;
118 break;
119
120 case -ERESTART_RESTARTBLOCK:
121 regs->regs[REG_RET] = __NR_restart_syscall;
122 regs->pc -= 4;
123 break;
124 }
125 }
126
127 /* No signal to deliver -- put the saved sigmask back */
128 restore_saved_sigmask();
129}
130
131/*
132 * Atomically swap in the new signal mask, and wait for a signal.
133 */
134asmlinkage int
135sys_sigsuspend(old_sigset_t mask)
136{
137 sigset_t blocked;
138 siginitset(&blocked, mask);
139 return sigsuspend(&blocked);
140}
141
142asmlinkage int
143sys_sigaction(int sig, const struct old_sigaction __user *act,
144 struct old_sigaction __user *oact)
145{
146 struct k_sigaction new_ka, old_ka;
147 int ret;
148
149 if (act) {
150 old_sigset_t mask;
151 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
152 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
153 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
154 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
155 __get_user(mask, &act->sa_mask))
156 return -EFAULT;
157 siginitset(&new_ka.sa.sa_mask, mask);
158 }
159
160 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
161
162 if (!ret && oact) {
163 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
164 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
165 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
166 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
167 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
168 return -EFAULT;
169 }
170
171 return ret;
172}
173
174asmlinkage int
175sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
176 unsigned long r4, unsigned long r5, unsigned long r6,
177 unsigned long r7,
178 struct pt_regs * regs)
179{
180 return do_sigaltstack(uss, uoss, REF_REG_SP);
181}
182
183/*
184 * Do a signal return; undo the signal stack.
185 */
186struct sigframe {
187 struct sigcontext sc;
188 unsigned long extramask[_NSIG_WORDS-1];
189 long long retcode[2];
190};
191
192struct rt_sigframe {
193 struct siginfo __user *pinfo;
194 void *puc;
195 struct siginfo info;
196 struct ucontext uc;
197 long long retcode[2];
198};
199
200#ifdef CONFIG_SH_FPU
201static inline int
202restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
203{
204 int err = 0;
205 int fpvalid;
206
207 err |= __get_user (fpvalid, &sc->sc_fpvalid);
208 conditional_used_math(fpvalid);
209 if (! fpvalid)
210 return err;
211
212 if (current == last_task_used_math) {
213 last_task_used_math = NULL;
214 regs->sr |= SR_FD;
215 }
216
217 err |= __copy_from_user(¤t->thread.xstate->hardfpu, &sc->sc_fpregs[0],
218 (sizeof(long long) * 32) + (sizeof(int) * 1));
219
220 return err;
221}
222
223static inline int
224setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
225{
226 int err = 0;
227 int fpvalid;
228
229 fpvalid = !!used_math();
230 err |= __put_user(fpvalid, &sc->sc_fpvalid);
231 if (! fpvalid)
232 return err;
233
234 if (current == last_task_used_math) {
235 enable_fpu();
236 save_fpu(current);
237 disable_fpu();
238 last_task_used_math = NULL;
239 regs->sr |= SR_FD;
240 }
241
242 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.xstate->hardfpu,
243 (sizeof(long long) * 32) + (sizeof(int) * 1));
244 clear_used_math();
245
246 return err;
247}
248#else
249static inline int
250restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
251{
252 return 0;
253}
254static inline int
255setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
256{
257 return 0;
258}
259#endif
260
261static int
262restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
263{
264 unsigned int err = 0;
265 unsigned long long current_sr, new_sr;
266#define SR_MASK 0xffff8cfd
267
268#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
269
270 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
271 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
272 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
273 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
274 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
275 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
276 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
277 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
278 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
279 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
280 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
281 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
282 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
283 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
284 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
285 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
286 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
287 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
288
289 /* Prevent the signal handler manipulating SR in a way that can
290 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
291 modified */
292 current_sr = regs->sr;
293 err |= __get_user(new_sr, &sc->sc_sr);
294 regs->sr &= SR_MASK;
295 regs->sr |= (new_sr & ~SR_MASK);
296
297 COPY(pc);
298
299#undef COPY
300
301 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
302 * has been restored above.) */
303 err |= restore_sigcontext_fpu(regs, sc);
304
305 regs->syscall_nr = -1; /* disable syscall checks */
306 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
307 return err;
308}
309
310asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
311 unsigned long r4, unsigned long r5,
312 unsigned long r6, unsigned long r7,
313 struct pt_regs * regs)
314{
315 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
316 sigset_t set;
317 long long ret;
318
319 /* Always make any pending restarted system calls return -EINTR */
320 current_thread_info()->restart_block.fn = do_no_restart_syscall;
321
322 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
323 goto badframe;
324
325 if (__get_user(set.sig[0], &frame->sc.oldmask)
326 || (_NSIG_WORDS > 1
327 && __copy_from_user(&set.sig[1], &frame->extramask,
328 sizeof(frame->extramask))))
329 goto badframe;
330
331 set_current_blocked(&set);
332
333 if (restore_sigcontext(regs, &frame->sc, &ret))
334 goto badframe;
335 regs->pc -= 4;
336
337 return (int) ret;
338
339badframe:
340 force_sig(SIGSEGV, current);
341 return 0;
342}
343
344asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
345 unsigned long r4, unsigned long r5,
346 unsigned long r6, unsigned long r7,
347 struct pt_regs * regs)
348{
349 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
350 sigset_t set;
351 stack_t __user st;
352 long long ret;
353
354 /* Always make any pending restarted system calls return -EINTR */
355 current_thread_info()->restart_block.fn = do_no_restart_syscall;
356
357 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
358 goto badframe;
359
360 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
361 goto badframe;
362
363 set_current_blocked(&set);
364
365 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
366 goto badframe;
367 regs->pc -= 4;
368
369 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
370 goto badframe;
371 /* It is more difficult to avoid calling this function than to
372 call it and ignore errors. */
373 do_sigaltstack(&st, NULL, REF_REG_SP);
374
375 return (int) ret;
376
377badframe:
378 force_sig(SIGSEGV, current);
379 return 0;
380}
381
382/*
383 * Set up a signal frame.
384 */
385static int
386setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
387 unsigned long mask)
388{
389 int err = 0;
390
391 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
392 err |= setup_sigcontext_fpu(regs, sc);
393
394#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
395
396 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
397 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
398 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
399 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
400 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
401 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
402 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
403 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
404 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
405 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
406 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
407 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
408 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
409 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
410 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
411 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
412 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
413 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
414 COPY(sr); COPY(pc);
415
416#undef COPY
417
418 err |= __put_user(mask, &sc->oldmask);
419
420 return err;
421}
422
423/*
424 * Determine which stack to use..
425 */
426static inline void __user *
427get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
428{
429 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
430 sp = current->sas_ss_sp + current->sas_ss_size;
431
432 return (void __user *)((sp - frame_size) & -8ul);
433}
434
435void sa_default_restorer(void); /* See comments below */
436void sa_default_rt_restorer(void); /* See comments below */
437
438static int setup_frame(int sig, struct k_sigaction *ka,
439 sigset_t *set, struct pt_regs *regs)
440{
441 struct sigframe __user *frame;
442 int err = 0;
443 int signal;
444
445 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
446
447 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
448 goto give_sigsegv;
449
450 signal = current_thread_info()->exec_domain
451 && current_thread_info()->exec_domain->signal_invmap
452 && sig < 32
453 ? current_thread_info()->exec_domain->signal_invmap[sig]
454 : sig;
455
456 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
457
458 /* Give up earlier as i386, in case */
459 if (err)
460 goto give_sigsegv;
461
462 if (_NSIG_WORDS > 1) {
463 err |= __copy_to_user(frame->extramask, &set->sig[1],
464 sizeof(frame->extramask)); }
465
466 /* Give up earlier as i386, in case */
467 if (err)
468 goto give_sigsegv;
469
470 /* Set up to return from userspace. If provided, use a stub
471 already in userspace. */
472 if (ka->sa.sa_flags & SA_RESTORER) {
473 /*
474 * On SH5 all edited pointers are subject to NEFF
475 */
476 DEREF_REG_PR = neff_sign_extend((unsigned long)
477 ka->sa.sa_restorer | 0x1);
478 } else {
479 /*
480 * Different approach on SH5.
481 * . Endianness independent asm code gets placed in entry.S .
482 * This is limited to four ASM instructions corresponding
483 * to two long longs in size.
484 * . err checking is done on the else branch only
485 * . flush_icache_range() is called upon __put_user() only
486 * . all edited pointers are subject to NEFF
487 * . being code, linker turns ShMedia bit on, always
488 * dereference index -1.
489 */
490 DEREF_REG_PR = neff_sign_extend((unsigned long)
491 frame->retcode | 0x01);
492
493 if (__copy_to_user(frame->retcode,
494 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
495 goto give_sigsegv;
496
497 /* Cohere the trampoline with the I-cache. */
498 flush_cache_sigtramp(DEREF_REG_PR-1);
499 }
500
501 /*
502 * Set up registers for signal handler.
503 * All edited pointers are subject to NEFF.
504 */
505 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
506 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
507
508 /* FIXME:
509 The glibc profiling support for SH-5 needs to be passed a sigcontext
510 so it can retrieve the PC. At some point during 2003 the glibc
511 support was changed to receive the sigcontext through the 2nd
512 argument, but there are still versions of libc.so in use that use
513 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
514 through both 2nd and 3rd arguments.
515 */
516
517 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
518 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
519
520 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
521
522 set_fs(USER_DS);
523
524 /* Broken %016Lx */
525 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
526 signal, current->comm, current->pid, frame,
527 regs->pc >> 32, regs->pc & 0xffffffff,
528 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
529
530 return 0;
531
532give_sigsegv:
533 force_sigsegv(sig, current);
534 return -EFAULT;
535}
536
537static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
538 sigset_t *set, struct pt_regs *regs)
539{
540 struct rt_sigframe __user *frame;
541 int err = 0;
542 int signal;
543
544 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
545
546 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
547 goto give_sigsegv;
548
549 signal = current_thread_info()->exec_domain
550 && current_thread_info()->exec_domain->signal_invmap
551 && sig < 32
552 ? current_thread_info()->exec_domain->signal_invmap[sig]
553 : sig;
554
555 err |= __put_user(&frame->info, &frame->pinfo);
556 err |= __put_user(&frame->uc, &frame->puc);
557 err |= copy_siginfo_to_user(&frame->info, info);
558
559 /* Give up earlier as i386, in case */
560 if (err)
561 goto give_sigsegv;
562
563 /* Create the ucontext. */
564 err |= __put_user(0, &frame->uc.uc_flags);
565 err |= __put_user(0, &frame->uc.uc_link);
566 err |= __put_user((void *)current->sas_ss_sp,
567 &frame->uc.uc_stack.ss_sp);
568 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
569 &frame->uc.uc_stack.ss_flags);
570 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
571 err |= setup_sigcontext(&frame->uc.uc_mcontext,
572 regs, set->sig[0]);
573 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
574
575 /* Give up earlier as i386, in case */
576 if (err)
577 goto give_sigsegv;
578
579 /* Set up to return from userspace. If provided, use a stub
580 already in userspace. */
581 if (ka->sa.sa_flags & SA_RESTORER) {
582 /*
583 * On SH5 all edited pointers are subject to NEFF
584 */
585 DEREF_REG_PR = neff_sign_extend((unsigned long)
586 ka->sa.sa_restorer | 0x1);
587 } else {
588 /*
589 * Different approach on SH5.
590 * . Endianness independent asm code gets placed in entry.S .
591 * This is limited to four ASM instructions corresponding
592 * to two long longs in size.
593 * . err checking is done on the else branch only
594 * . flush_icache_range() is called upon __put_user() only
595 * . all edited pointers are subject to NEFF
596 * . being code, linker turns ShMedia bit on, always
597 * dereference index -1.
598 */
599 DEREF_REG_PR = neff_sign_extend((unsigned long)
600 frame->retcode | 0x01);
601
602 if (__copy_to_user(frame->retcode,
603 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
604 goto give_sigsegv;
605
606 /* Cohere the trampoline with the I-cache. */
607 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
608 }
609
610 /*
611 * Set up registers for signal handler.
612 * All edited pointers are subject to NEFF.
613 */
614 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
615 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
616 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
617 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
618 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
619
620 set_fs(USER_DS);
621
622 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
623 signal, current->comm, current->pid, frame,
624 regs->pc >> 32, regs->pc & 0xffffffff,
625 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
626
627 return 0;
628
629give_sigsegv:
630 force_sigsegv(sig, current);
631 return -EFAULT;
632}
633
634/*
635 * OK, we're invoking a handler
636 */
637static void
638handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
639 struct pt_regs * regs)
640{
641 sigset_t *oldset = sigmask_to_save();
642 int ret;
643
644 /* Set up the stack frame */
645 if (ka->sa.sa_flags & SA_SIGINFO)
646 ret = setup_rt_frame(sig, ka, info, oldset, regs);
647 else
648 ret = setup_frame(sig, ka, oldset, regs);
649
650 if (ret)
651 return;
652
653 signal_delivered(sig, info, ka, regs,
654 test_thread_flag(TIF_SINGLESTEP));
655}
656
657asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
658{
659 if (thread_info_flags & _TIF_SIGPENDING)
660 do_signal(regs);
661
662 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
663 clear_thread_flag(TIF_NOTIFY_RESUME);
664 tracehook_notify_resume(regs);
665 }
666}
1/*
2 * arch/sh/kernel/signal_64.c
3 *
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 - 2008 Paul Mundt
6 * Copyright (C) 2004 Richard Curnow
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12#include <linux/rwsem.h>
13#include <linux/sched.h>
14#include <linux/mm.h>
15#include <linux/smp.h>
16#include <linux/kernel.h>
17#include <linux/signal.h>
18#include <linux/errno.h>
19#include <linux/wait.h>
20#include <linux/personality.h>
21#include <linux/ptrace.h>
22#include <linux/unistd.h>
23#include <linux/stddef.h>
24#include <linux/tracehook.h>
25#include <asm/ucontext.h>
26#include <linux/uaccess.h>
27#include <asm/pgtable.h>
28#include <asm/cacheflush.h>
29#include <asm/fpu.h>
30
31#define REG_RET 9
32#define REG_ARG1 2
33#define REG_ARG2 3
34#define REG_ARG3 4
35#define REG_SP 15
36#define REG_PR 18
37#define REF_REG_RET regs->regs[REG_RET]
38#define REF_REG_SP regs->regs[REG_SP]
39#define DEREF_REG_PR regs->regs[REG_PR]
40
41#define DEBUG_SIG 0
42
43static void
44handle_signal(struct ksignal *ksig, struct pt_regs *regs);
45
46static inline void
47handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
48{
49 /* If we're not from a syscall, bail out */
50 if (regs->syscall_nr < 0)
51 return;
52
53 /* check for system call restart.. */
54 switch (regs->regs[REG_RET]) {
55 case -ERESTART_RESTARTBLOCK:
56 case -ERESTARTNOHAND:
57 no_system_call_restart:
58 regs->regs[REG_RET] = -EINTR;
59 break;
60
61 case -ERESTARTSYS:
62 if (!(sa->sa_flags & SA_RESTART))
63 goto no_system_call_restart;
64 /* fallthrough */
65 case -ERESTARTNOINTR:
66 /* Decode syscall # */
67 regs->regs[REG_RET] = regs->syscall_nr;
68 regs->pc -= 4;
69 break;
70 }
71}
72
73/*
74 * Note that 'init' is a special process: it doesn't get signals it doesn't
75 * want to handle. Thus you cannot kill init even with a SIGKILL even by
76 * mistake.
77 *
78 * Note that we go through the signals twice: once to check the signals that
79 * the kernel can handle, and then we build all the user-level signal handling
80 * stack-frames in one go after that.
81 */
82static void do_signal(struct pt_regs *regs)
83{
84 struct ksignal ksig;
85
86 /*
87 * We want the common case to go fast, which
88 * is why we may in certain cases get here from
89 * kernel mode. Just return without doing anything
90 * if so.
91 */
92 if (!user_mode(regs))
93 return;
94
95 if (get_signal(&ksig)) {
96 handle_syscall_restart(regs, &ksig.ka.sa);
97
98 /* Whee! Actually deliver the signal. */
99 handle_signal(&ksig, regs);
100 return;
101 }
102
103 /* Did we come from a system call? */
104 if (regs->syscall_nr >= 0) {
105 /* Restart the system call - no handlers present */
106 switch (regs->regs[REG_RET]) {
107 case -ERESTARTNOHAND:
108 case -ERESTARTSYS:
109 case -ERESTARTNOINTR:
110 /* Decode Syscall # */
111 regs->regs[REG_RET] = regs->syscall_nr;
112 regs->pc -= 4;
113 break;
114
115 case -ERESTART_RESTARTBLOCK:
116 regs->regs[REG_RET] = __NR_restart_syscall;
117 regs->pc -= 4;
118 break;
119 }
120 }
121
122 /* No signal to deliver -- put the saved sigmask back */
123 restore_saved_sigmask();
124}
125
126/*
127 * Do a signal return; undo the signal stack.
128 */
129struct sigframe {
130 struct sigcontext sc;
131 unsigned long extramask[_NSIG_WORDS-1];
132 long long retcode[2];
133};
134
135struct rt_sigframe {
136 struct siginfo __user *pinfo;
137 void *puc;
138 struct siginfo info;
139 struct ucontext uc;
140 long long retcode[2];
141};
142
143#ifdef CONFIG_SH_FPU
144static inline int
145restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
146{
147 int err = 0;
148 int fpvalid;
149
150 err |= __get_user (fpvalid, &sc->sc_fpvalid);
151 conditional_used_math(fpvalid);
152 if (! fpvalid)
153 return err;
154
155 if (current == last_task_used_math) {
156 last_task_used_math = NULL;
157 regs->sr |= SR_FD;
158 }
159
160 err |= __copy_from_user(¤t->thread.xstate->hardfpu, &sc->sc_fpregs[0],
161 (sizeof(long long) * 32) + (sizeof(int) * 1));
162
163 return err;
164}
165
166static inline int
167setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
168{
169 int err = 0;
170 int fpvalid;
171
172 fpvalid = !!used_math();
173 err |= __put_user(fpvalid, &sc->sc_fpvalid);
174 if (! fpvalid)
175 return err;
176
177 if (current == last_task_used_math) {
178 enable_fpu();
179 save_fpu(current);
180 disable_fpu();
181 last_task_used_math = NULL;
182 regs->sr |= SR_FD;
183 }
184
185 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.xstate->hardfpu,
186 (sizeof(long long) * 32) + (sizeof(int) * 1));
187 clear_used_math();
188
189 return err;
190}
191#else
192static inline int
193restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
194{
195 return 0;
196}
197static inline int
198setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
199{
200 return 0;
201}
202#endif
203
204static int
205restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
206{
207 unsigned int err = 0;
208 unsigned long long current_sr, new_sr;
209#define SR_MASK 0xffff8cfd
210
211#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
212
213 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
214 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
215 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
216 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
217 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
218 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
219 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
220 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
221 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
222 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
223 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
224 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
225 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
226 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
227 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
228 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
229 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
230 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
231
232 /* Prevent the signal handler manipulating SR in a way that can
233 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
234 modified */
235 current_sr = regs->sr;
236 err |= __get_user(new_sr, &sc->sc_sr);
237 regs->sr &= SR_MASK;
238 regs->sr |= (new_sr & ~SR_MASK);
239
240 COPY(pc);
241
242#undef COPY
243
244 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
245 * has been restored above.) */
246 err |= restore_sigcontext_fpu(regs, sc);
247
248 regs->syscall_nr = -1; /* disable syscall checks */
249 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
250 return err;
251}
252
253asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
254 unsigned long r4, unsigned long r5,
255 unsigned long r6, unsigned long r7,
256 struct pt_regs * regs)
257{
258 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
259 sigset_t set;
260 long long ret;
261
262 /* Always make any pending restarted system calls return -EINTR */
263 current->restart_block.fn = do_no_restart_syscall;
264
265 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
266 goto badframe;
267
268 if (__get_user(set.sig[0], &frame->sc.oldmask)
269 || (_NSIG_WORDS > 1
270 && __copy_from_user(&set.sig[1], &frame->extramask,
271 sizeof(frame->extramask))))
272 goto badframe;
273
274 set_current_blocked(&set);
275
276 if (restore_sigcontext(regs, &frame->sc, &ret))
277 goto badframe;
278 regs->pc -= 4;
279
280 return (int) ret;
281
282badframe:
283 force_sig(SIGSEGV, current);
284 return 0;
285}
286
287asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
288 unsigned long r4, unsigned long r5,
289 unsigned long r6, unsigned long r7,
290 struct pt_regs * regs)
291{
292 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
293 sigset_t set;
294 long long ret;
295
296 /* Always make any pending restarted system calls return -EINTR */
297 current->restart_block.fn = do_no_restart_syscall;
298
299 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
300 goto badframe;
301
302 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
303 goto badframe;
304
305 set_current_blocked(&set);
306
307 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
308 goto badframe;
309 regs->pc -= 4;
310
311 if (restore_altstack(&frame->uc.uc_stack))
312 goto badframe;
313
314 return (int) ret;
315
316badframe:
317 force_sig(SIGSEGV, current);
318 return 0;
319}
320
321/*
322 * Set up a signal frame.
323 */
324static int
325setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
326 unsigned long mask)
327{
328 int err = 0;
329
330 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
331 err |= setup_sigcontext_fpu(regs, sc);
332
333#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
334
335 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
336 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
337 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
338 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
339 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
340 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
341 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
342 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
343 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
344 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
345 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
346 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
347 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
348 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
349 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
350 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
351 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
352 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
353 COPY(sr); COPY(pc);
354
355#undef COPY
356
357 err |= __put_user(mask, &sc->oldmask);
358
359 return err;
360}
361
362/*
363 * Determine which stack to use..
364 */
365static inline void __user *
366get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
367{
368 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
369 sp = current->sas_ss_sp + current->sas_ss_size;
370
371 return (void __user *)((sp - frame_size) & -8ul);
372}
373
374void sa_default_restorer(void); /* See comments below */
375void sa_default_rt_restorer(void); /* See comments below */
376
377static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
378{
379 struct sigframe __user *frame;
380 int err = 0, sig = ksig->sig;
381 int signal;
382
383 frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
384
385 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
386 return -EFAULT;
387
388 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
389
390 /* Give up earlier as i386, in case */
391 if (err)
392 return -EFAULT;
393
394 if (_NSIG_WORDS > 1) {
395 err |= __copy_to_user(frame->extramask, &set->sig[1],
396 sizeof(frame->extramask)); }
397
398 /* Give up earlier as i386, in case */
399 if (err)
400 return -EFAULT;
401
402 /* Set up to return from userspace. If provided, use a stub
403 already in userspace. */
404 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
405 /*
406 * On SH5 all edited pointers are subject to NEFF
407 */
408 DEREF_REG_PR = neff_sign_extend((unsigned long)
409 ksig->ka->sa.sa_restorer | 0x1);
410 } else {
411 /*
412 * Different approach on SH5.
413 * . Endianness independent asm code gets placed in entry.S .
414 * This is limited to four ASM instructions corresponding
415 * to two long longs in size.
416 * . err checking is done on the else branch only
417 * . flush_icache_range() is called upon __put_user() only
418 * . all edited pointers are subject to NEFF
419 * . being code, linker turns ShMedia bit on, always
420 * dereference index -1.
421 */
422 DEREF_REG_PR = neff_sign_extend((unsigned long)
423 frame->retcode | 0x01);
424
425 if (__copy_to_user(frame->retcode,
426 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
427 return -EFAULT;
428
429 /* Cohere the trampoline with the I-cache. */
430 flush_cache_sigtramp(DEREF_REG_PR-1);
431 }
432
433 /*
434 * Set up registers for signal handler.
435 * All edited pointers are subject to NEFF.
436 */
437 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
438 regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
439
440 /* FIXME:
441 The glibc profiling support for SH-5 needs to be passed a sigcontext
442 so it can retrieve the PC. At some point during 2003 the glibc
443 support was changed to receive the sigcontext through the 2nd
444 argument, but there are still versions of libc.so in use that use
445 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
446 through both 2nd and 3rd arguments.
447 */
448
449 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
450 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
451
452 regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
453
454 /* Broken %016Lx */
455 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
456 sig, current->comm, current->pid, frame,
457 regs->pc >> 32, regs->pc & 0xffffffff,
458 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
459
460 return 0;
461}
462
463static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
464 struct pt_regs *regs)
465{
466 struct rt_sigframe __user *frame;
467 int err = 0, sig = ksig->sig;
468
469 frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
470
471 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
472 return -EFAULT;
473
474 err |= __put_user(&frame->info, &frame->pinfo);
475 err |= __put_user(&frame->uc, &frame->puc);
476 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
477
478 /* Give up earlier as i386, in case */
479 if (err)
480 return -EFAULT;
481
482 /* Create the ucontext. */
483 err |= __put_user(0, &frame->uc.uc_flags);
484 err |= __put_user(0, &frame->uc.uc_link);
485 err |= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
486 err |= setup_sigcontext(&frame->uc.uc_mcontext,
487 regs, set->sig[0]);
488 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
489
490 /* Give up earlier as i386, in case */
491 if (err)
492 return -EFAULT;
493
494 /* Set up to return from userspace. If provided, use a stub
495 already in userspace. */
496 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
497 /*
498 * On SH5 all edited pointers are subject to NEFF
499 */
500 DEREF_REG_PR = neff_sign_extend((unsigned long)
501 ksig->ka.sa.sa_restorer | 0x1);
502 } else {
503 /*
504 * Different approach on SH5.
505 * . Endianness independent asm code gets placed in entry.S .
506 * This is limited to four ASM instructions corresponding
507 * to two long longs in size.
508 * . err checking is done on the else branch only
509 * . flush_icache_range() is called upon __put_user() only
510 * . all edited pointers are subject to NEFF
511 * . being code, linker turns ShMedia bit on, always
512 * dereference index -1.
513 */
514 DEREF_REG_PR = neff_sign_extend((unsigned long)
515 frame->retcode | 0x01);
516
517 if (__copy_to_user(frame->retcode,
518 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
519 return -EFAULT;
520
521 /* Cohere the trampoline with the I-cache. */
522 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
523 }
524
525 /*
526 * Set up registers for signal handler.
527 * All edited pointers are subject to NEFF.
528 */
529 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
530 regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
531 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
532 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
533 regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
534
535 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
536 sig, current->comm, current->pid, frame,
537 regs->pc >> 32, regs->pc & 0xffffffff,
538 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
539
540 return 0;
541}
542
543/*
544 * OK, we're invoking a handler
545 */
546static void
547handle_signal(struct ksignal *ksig, struct pt_regs *regs)
548{
549 sigset_t *oldset = sigmask_to_save();
550 int ret;
551
552 /* Set up the stack frame */
553 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
554 ret = setup_rt_frame(ksig, oldset, regs);
555 else
556 ret = setup_frame(ksig, oldset, regs);
557
558 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
559}
560
561asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
562{
563 if (thread_info_flags & _TIF_SIGPENDING)
564 do_signal(regs);
565
566 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
567 clear_thread_flag(TIF_NOTIFY_RESUME);
568 tracehook_notify_resume(regs);
569 }
570}