OMAP: DISPC: Fix to disable also interface clocks. 2nd.
[linux-ginger.git] / arch / sh / kernel / signal_64.c
blob552eb810cd85e6c9199b5558d567f292eacbad20
1 /*
2 * arch/sh/kernel/signal_64.c
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 Paul Mundt
6 * Copyright (C) 2004 Richard Curnow
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.
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 <asm/ucontext.h>
26 #include <asm/uaccess.h>
27 #include <asm/pgtable.h>
28 #include <asm/cacheflush.h>
29 #include <asm/fpu.h>
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]
41 #define DEBUG_SIG 0
43 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
45 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
48 * Atomically swap in the new signal mask, and wait for a signal.
51 asmlinkage int
52 sys_sigsuspend(old_sigset_t mask,
53 unsigned long r3, unsigned long r4, unsigned long r5,
54 unsigned long r6, unsigned long r7,
55 struct pt_regs * regs)
57 sigset_t saveset;
59 mask &= _BLOCKABLE;
60 spin_lock_irq(&current->sighand->siglock);
61 saveset = current->blocked;
62 siginitset(&current->blocked, mask);
63 recalc_sigpending();
64 spin_unlock_irq(&current->sighand->siglock);
66 REF_REG_RET = -EINTR;
67 while (1) {
68 current->state = TASK_INTERRUPTIBLE;
69 schedule();
70 regs->pc += 4; /* because sys_sigreturn decrements the pc */
71 if (do_signal(regs, &saveset)) {
72 /* pc now points at signal handler. Need to decrement
73 it because entry.S will increment it. */
74 regs->pc -= 4;
75 return -EINTR;
80 asmlinkage int
81 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
82 unsigned long r4, unsigned long r5, unsigned long r6,
83 unsigned long r7,
84 struct pt_regs * regs)
86 sigset_t saveset, newset;
88 /* XXX: Don't preclude handling different sized sigset_t's. */
89 if (sigsetsize != sizeof(sigset_t))
90 return -EINVAL;
92 if (copy_from_user(&newset, unewset, sizeof(newset)))
93 return -EFAULT;
94 sigdelsetmask(&newset, ~_BLOCKABLE);
95 spin_lock_irq(&current->sighand->siglock);
96 saveset = current->blocked;
97 current->blocked = newset;
98 recalc_sigpending();
99 spin_unlock_irq(&current->sighand->siglock);
101 REF_REG_RET = -EINTR;
102 while (1) {
103 current->state = TASK_INTERRUPTIBLE;
104 schedule();
105 regs->pc += 4; /* because sys_sigreturn decrements the pc */
106 if (do_signal(regs, &saveset)) {
107 /* pc now points at signal handler. Need to decrement
108 it because entry.S will increment it. */
109 regs->pc -= 4;
110 return -EINTR;
115 asmlinkage int
116 sys_sigaction(int sig, const struct old_sigaction __user *act,
117 struct old_sigaction __user *oact)
119 struct k_sigaction new_ka, old_ka;
120 int ret;
122 if (act) {
123 old_sigset_t mask;
124 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
125 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
126 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
127 return -EFAULT;
128 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
129 __get_user(mask, &act->sa_mask);
130 siginitset(&new_ka.sa.sa_mask, mask);
133 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
135 if (!ret && oact) {
136 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
137 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
138 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
139 return -EFAULT;
140 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
141 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
144 return ret;
147 asmlinkage int
148 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
149 unsigned long r4, unsigned long r5, unsigned long r6,
150 unsigned long r7,
151 struct pt_regs * regs)
153 return do_sigaltstack(uss, uoss, REF_REG_SP);
158 * Do a signal return; undo the signal stack.
161 struct sigframe
163 struct sigcontext sc;
164 unsigned long extramask[_NSIG_WORDS-1];
165 long long retcode[2];
168 struct rt_sigframe
170 struct siginfo __user *pinfo;
171 void *puc;
172 struct siginfo info;
173 struct ucontext uc;
174 long long retcode[2];
177 #ifdef CONFIG_SH_FPU
178 static inline int
179 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
181 int err = 0;
182 int fpvalid;
184 err |= __get_user (fpvalid, &sc->sc_fpvalid);
185 conditional_used_math(fpvalid);
186 if (! fpvalid)
187 return err;
189 if (current == last_task_used_math) {
190 last_task_used_math = NULL;
191 regs->sr |= SR_FD;
194 err |= __copy_from_user(&current->thread.fpu.hard, &sc->sc_fpregs[0],
195 (sizeof(long long) * 32) + (sizeof(int) * 1));
197 return err;
200 static inline int
201 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
203 int err = 0;
204 int fpvalid;
206 fpvalid = !!used_math();
207 err |= __put_user(fpvalid, &sc->sc_fpvalid);
208 if (! fpvalid)
209 return err;
211 if (current == last_task_used_math) {
212 enable_fpu();
213 save_fpu(current, regs);
214 disable_fpu();
215 last_task_used_math = NULL;
216 regs->sr |= SR_FD;
219 err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.fpu.hard,
220 (sizeof(long long) * 32) + (sizeof(int) * 1));
221 clear_used_math();
223 return err;
225 #else
226 static inline int
227 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
229 return 0;
231 static inline int
232 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
234 return 0;
236 #endif
238 static int
239 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
241 unsigned int err = 0;
242 unsigned long long current_sr, new_sr;
243 #define SR_MASK 0xffff8cfd
245 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
247 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
248 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
249 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
250 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
251 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
252 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
253 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
254 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
255 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
256 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
257 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
258 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
259 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
260 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
261 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
262 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
263 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
264 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
266 /* Prevent the signal handler manipulating SR in a way that can
267 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
268 modified */
269 current_sr = regs->sr;
270 err |= __get_user(new_sr, &sc->sc_sr);
271 regs->sr &= SR_MASK;
272 regs->sr |= (new_sr & ~SR_MASK);
274 COPY(pc);
276 #undef COPY
278 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
279 * has been restored above.) */
280 err |= restore_sigcontext_fpu(regs, sc);
282 regs->syscall_nr = -1; /* disable syscall checks */
283 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
284 return err;
287 asmlinkage int sys_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)
292 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
293 sigset_t set;
294 long long ret;
296 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
297 goto badframe;
299 if (__get_user(set.sig[0], &frame->sc.oldmask)
300 || (_NSIG_WORDS > 1
301 && __copy_from_user(&set.sig[1], &frame->extramask,
302 sizeof(frame->extramask))))
303 goto badframe;
305 sigdelsetmask(&set, ~_BLOCKABLE);
307 spin_lock_irq(&current->sighand->siglock);
308 current->blocked = set;
309 recalc_sigpending();
310 spin_unlock_irq(&current->sighand->siglock);
312 if (restore_sigcontext(regs, &frame->sc, &ret))
313 goto badframe;
314 regs->pc -= 4;
316 return (int) ret;
318 badframe:
319 force_sig(SIGSEGV, current);
320 return 0;
323 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
324 unsigned long r4, unsigned long r5,
325 unsigned long r6, unsigned long r7,
326 struct pt_regs * regs)
328 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
329 sigset_t set;
330 stack_t __user st;
331 long long ret;
333 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
334 goto badframe;
336 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
337 goto badframe;
339 sigdelsetmask(&set, ~_BLOCKABLE);
340 spin_lock_irq(&current->sighand->siglock);
341 current->blocked = set;
342 recalc_sigpending();
343 spin_unlock_irq(&current->sighand->siglock);
345 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
346 goto badframe;
347 regs->pc -= 4;
349 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
350 goto badframe;
351 /* It is more difficult to avoid calling this function than to
352 call it and ignore errors. */
353 do_sigaltstack(&st, NULL, REF_REG_SP);
355 return (int) ret;
357 badframe:
358 force_sig(SIGSEGV, current);
359 return 0;
363 * Set up a signal frame.
366 static int
367 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
368 unsigned long mask)
370 int err = 0;
372 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
373 err |= setup_sigcontext_fpu(regs, sc);
375 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
377 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
378 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
379 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
380 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
381 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
382 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
383 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
384 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
385 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
386 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
387 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
388 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
389 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
390 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
391 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
392 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
393 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
394 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
395 COPY(sr); COPY(pc);
397 #undef COPY
399 err |= __put_user(mask, &sc->oldmask);
401 return err;
405 * Determine which stack to use..
407 static inline void __user *
408 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
410 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
411 sp = current->sas_ss_sp + current->sas_ss_size;
413 return (void __user *)((sp - frame_size) & -8ul);
416 void sa_default_restorer(void); /* See comments below */
417 void sa_default_rt_restorer(void); /* See comments below */
419 static void setup_frame(int sig, struct k_sigaction *ka,
420 sigset_t *set, struct pt_regs *regs)
422 struct sigframe __user *frame;
423 int err = 0;
424 int signal;
426 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
428 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
429 goto give_sigsegv;
431 signal = current_thread_info()->exec_domain
432 && current_thread_info()->exec_domain->signal_invmap
433 && sig < 32
434 ? current_thread_info()->exec_domain->signal_invmap[sig]
435 : sig;
437 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
439 /* Give up earlier as i386, in case */
440 if (err)
441 goto give_sigsegv;
443 if (_NSIG_WORDS > 1) {
444 err |= __copy_to_user(frame->extramask, &set->sig[1],
445 sizeof(frame->extramask)); }
447 /* Give up earlier as i386, in case */
448 if (err)
449 goto give_sigsegv;
451 /* Set up to return from userspace. If provided, use a stub
452 already in userspace. */
453 if (ka->sa.sa_flags & SA_RESTORER) {
454 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
457 * On SH5 all edited pointers are subject to NEFF
459 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
460 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
461 } else {
463 * Different approach on SH5.
464 * . Endianness independent asm code gets placed in entry.S .
465 * This is limited to four ASM instructions corresponding
466 * to two long longs in size.
467 * . err checking is done on the else branch only
468 * . flush_icache_range() is called upon __put_user() only
469 * . all edited pointers are subject to NEFF
470 * . being code, linker turns ShMedia bit on, always
471 * dereference index -1.
473 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
474 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
475 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
477 if (__copy_to_user(frame->retcode,
478 (unsigned long long)sa_default_restorer & (~1), 16) != 0)
479 goto give_sigsegv;
481 /* Cohere the trampoline with the I-cache. */
482 flush_cache_sigtramp(DEREF_REG_PR-1);
486 * Set up registers for signal handler.
487 * All edited pointers are subject to NEFF.
489 regs->regs[REG_SP] = (unsigned long) frame;
490 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
491 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
492 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
494 /* FIXME:
495 The glibc profiling support for SH-5 needs to be passed a sigcontext
496 so it can retrieve the PC. At some point during 2003 the glibc
497 support was changed to receive the sigcontext through the 2nd
498 argument, but there are still versions of libc.so in use that use
499 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
500 through both 2nd and 3rd arguments.
503 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
504 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
506 regs->pc = (unsigned long) ka->sa.sa_handler;
507 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
509 set_fs(USER_DS);
511 #if DEBUG_SIG
512 /* Broken %016Lx */
513 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
514 signal,
515 current->comm, current->pid, frame,
516 regs->pc >> 32, regs->pc & 0xffffffff,
517 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
518 #endif
520 return;
522 give_sigsegv:
523 force_sigsegv(sig, current);
526 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
527 sigset_t *set, struct pt_regs *regs)
529 struct rt_sigframe __user *frame;
530 int err = 0;
531 int signal;
533 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
535 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
536 goto give_sigsegv;
538 signal = current_thread_info()->exec_domain
539 && current_thread_info()->exec_domain->signal_invmap
540 && sig < 32
541 ? current_thread_info()->exec_domain->signal_invmap[sig]
542 : sig;
544 err |= __put_user(&frame->info, &frame->pinfo);
545 err |= __put_user(&frame->uc, &frame->puc);
546 err |= copy_siginfo_to_user(&frame->info, info);
548 /* Give up earlier as i386, in case */
549 if (err)
550 goto give_sigsegv;
552 /* Create the ucontext. */
553 err |= __put_user(0, &frame->uc.uc_flags);
554 err |= __put_user(0, &frame->uc.uc_link);
555 err |= __put_user((void *)current->sas_ss_sp,
556 &frame->uc.uc_stack.ss_sp);
557 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
558 &frame->uc.uc_stack.ss_flags);
559 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
560 err |= setup_sigcontext(&frame->uc.uc_mcontext,
561 regs, set->sig[0]);
562 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
564 /* Give up earlier as i386, in case */
565 if (err)
566 goto give_sigsegv;
568 /* Set up to return from userspace. If provided, use a stub
569 already in userspace. */
570 if (ka->sa.sa_flags & SA_RESTORER) {
571 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
574 * On SH5 all edited pointers are subject to NEFF
576 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
577 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
578 } else {
580 * Different approach on SH5.
581 * . Endianness independent asm code gets placed in entry.S .
582 * This is limited to four ASM instructions corresponding
583 * to two long longs in size.
584 * . err checking is done on the else branch only
585 * . flush_icache_range() is called upon __put_user() only
586 * . all edited pointers are subject to NEFF
587 * . being code, linker turns ShMedia bit on, always
588 * dereference index -1.
591 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
592 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
593 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
595 if (__copy_to_user(frame->retcode,
596 (unsigned long long)sa_default_rt_restorer & (~1), 16) != 0)
597 goto give_sigsegv;
599 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
603 * Set up registers for signal handler.
604 * All edited pointers are subject to NEFF.
606 regs->regs[REG_SP] = (unsigned long) frame;
607 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
608 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
609 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
610 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
611 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
612 regs->pc = (unsigned long) ka->sa.sa_handler;
613 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
615 set_fs(USER_DS);
617 #if DEBUG_SIG
618 /* Broken %016Lx */
619 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
620 signal,
621 current->comm, current->pid, frame,
622 regs->pc >> 32, regs->pc & 0xffffffff,
623 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
624 #endif
626 return;
628 give_sigsegv:
629 force_sigsegv(sig, current);
633 * OK, we're invoking a handler
636 static void
637 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
638 sigset_t *oldset, struct pt_regs * regs)
640 /* Are we from a system call? */
641 if (regs->syscall_nr >= 0) {
642 /* If so, check system call restarting.. */
643 switch (regs->regs[REG_RET]) {
644 case -ERESTART_RESTARTBLOCK:
645 case -ERESTARTNOHAND:
646 regs->regs[REG_RET] = -EINTR;
647 break;
649 case -ERESTARTSYS:
650 if (!(ka->sa.sa_flags & SA_RESTART)) {
651 regs->regs[REG_RET] = -EINTR;
652 break;
654 /* fallthrough */
655 case -ERESTARTNOINTR:
656 /* Decode syscall # */
657 regs->regs[REG_RET] = regs->syscall_nr;
658 regs->pc -= 4;
662 /* Set up the stack frame */
663 if (ka->sa.sa_flags & SA_SIGINFO)
664 setup_rt_frame(sig, ka, info, oldset, regs);
665 else
666 setup_frame(sig, ka, oldset, regs);
668 spin_lock_irq(&current->sighand->siglock);
669 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
670 if (!(ka->sa.sa_flags & SA_NODEFER))
671 sigaddset(&current->blocked,sig);
672 recalc_sigpending();
673 spin_unlock_irq(&current->sighand->siglock);
677 * Note that 'init' is a special process: it doesn't get signals it doesn't
678 * want to handle. Thus you cannot kill init even with a SIGKILL even by
679 * mistake.
681 * Note that we go through the signals twice: once to check the signals that
682 * the kernel can handle, and then we build all the user-level signal handling
683 * stack-frames in one go after that.
685 int do_signal(struct pt_regs *regs, sigset_t *oldset)
687 siginfo_t info;
688 int signr;
689 struct k_sigaction ka;
692 * We want the common case to go fast, which
693 * is why we may in certain cases get here from
694 * kernel mode. Just return without doing anything
695 * if so.
697 if (!user_mode(regs))
698 return 1;
700 if (try_to_freeze())
701 goto no_signal;
703 if (test_thread_flag(TIF_RESTORE_SIGMASK))
704 oldset = &current->saved_sigmask;
705 else if (!oldset)
706 oldset = &current->blocked;
708 signr = get_signal_to_deliver(&info, &ka, regs, 0);
710 if (signr > 0) {
711 /* Whee! Actually deliver the signal. */
712 handle_signal(signr, &info, &ka, oldset, regs);
715 * If a signal was successfully delivered, the saved sigmask
716 * is in its frame, and we can clear the TIF_RESTORE_SIGMASK
717 * flag.
719 if (test_thread_flag(TIF_RESTORE_SIGMASK))
720 clear_thread_flag(TIF_RESTORE_SIGMASK);
722 return 1;
725 no_signal:
726 /* Did we come from a system call? */
727 if (regs->syscall_nr >= 0) {
728 /* Restart the system call - no handlers present */
729 switch (regs->regs[REG_RET]) {
730 case -ERESTARTNOHAND:
731 case -ERESTARTSYS:
732 case -ERESTARTNOINTR:
733 /* Decode Syscall # */
734 regs->regs[REG_RET] = regs->syscall_nr;
735 regs->pc -= 4;
736 break;
738 case -ERESTART_RESTARTBLOCK:
739 regs->regs[REG_RET] = __NR_restart_syscall;
740 regs->pc -= 4;
741 break;
745 /* No signal to deliver -- put the saved sigmask back */
746 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
747 clear_thread_flag(TIF_RESTORE_SIGMASK);
748 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
751 return 0;