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