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