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