开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
signal.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：18k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

signal.c：源码内容
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1991, 1992  Linus Torvalds
  7.  * Copyright (C) 1994 - 1999  Ralf Baechle
  8.  * Copyright (C) 1999 Silicon Graphics, Inc.
  9.  */
  10. #include <linux/config.h>
  11. #include <linux/sched.h>
  12. #include <linux/mm.h>
  13. #include <linux/smp.h>
  14. #include <linux/smp_lock.h>
  15. #include <linux/kernel.h>
  16. #include <linux/signal.h>
  17. #include <linux/errno.h>
  18. #include <linux/wait.h>
  19. #include <linux/ptrace.h>
  20. #include <linux/unistd.h>
  22. #include <asm/asm.h>
  23. #include <asm/bitops.h>
  24. #include <asm/pgalloc.h>
  25. #include <asm/stackframe.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/ucontext.h>
  29. #define DEBUG_SIG 0
  31. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  33. extern asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  35. extern asmlinkage int (*save_fp_context)(struct sigcontext *sc);
  36. extern asmlinkage int (*restore_fp_context)(struct sigcontext *sc);
  38. extern asmlinkage void syscall_trace(void);
  40. int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  41. {
  42. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  43. return -EFAULT;
  44. if (from->si_code < 0)
  45. return __copy_to_user(to, from, sizeof(siginfo_t));
  46. else {
  47. int err;
  49. /* If you change siginfo_t structure, please be sure
  50.    this code is fixed accordingly.
  51.    It should never copy any pad contained in the structure
  52.    to avoid security leaks, but must copy the generic
  53.    3 ints plus the relevant union member.  */
  54. err = __put_user(from->si_signo, &to->si_signo);
  55. err |= __put_user(from->si_errno, &to->si_errno);
  56. err |= __put_user((short)from->si_code, &to->si_code);
  57. /* First 32bits of unions are always present.  */
  58. err |= __put_user(from->si_pid, &to->si_pid);
  59. switch (from->si_code >> 16) {
  60. case __SI_FAULT >> 16:
  61. break;
  62. case __SI_CHLD >> 16:
  63. err |= __put_user(from->si_utime, &to->si_utime);
  64. err |= __put_user(from->si_stime, &to->si_stime);
  65. err |= __put_user(from->si_status, &to->si_status);
  66. default:
  67. err |= __put_user(from->si_uid, &to->si_uid);
  68. break;
  69. /* case __SI_RT: This is not generated by the kernel as of now.  */
  70. }
  71. return err;
  72. }
  73. }
  75. /*
  76.  * Atomically swap in the new signal mask, and wait for a signal.
  77.  */
  78. save_static_function(sys_sigsuspend);
  79. static_unused int
  80. _sys_sigsuspend(struct pt_regs regs)
  81. {
  82. sigset_t *uset, saveset, newset;
  84. uset = (sigset_t *) regs.regs[4];
  85. if (copy_from_user(&newset, uset, sizeof(sigset_t)))
  86. return -EFAULT;
  87. sigdelsetmask(&newset, ~_BLOCKABLE);
  89. spin_lock_irq(&current->sigmask_lock);
  90. saveset = current->blocked;
  91. current->blocked = newset;
  92. recalc_sigpending(current);
  93. spin_unlock_irq(&current->sigmask_lock);
  95. regs.regs[2] = EINTR;
  96. regs.regs[7] = 1;
  97. while (1) {
  98. current->state = TASK_INTERRUPTIBLE;
  99. schedule();
  100. if (do_signal(&saveset, &regs))
  101. return -EINTR;
  102. }
  103. }
  106. save_static_function(sys_rt_sigsuspend);
  107. static_unused int
  108. _sys_rt_sigsuspend(struct pt_regs regs)
  109. {
  110. sigset_t *unewset, saveset, newset;
  111.         size_t sigsetsize;
  113. /* XXX Don't preclude handling different sized sigset_t's.  */
  114. sigsetsize = regs.regs[5];
  115. if (sigsetsize != sizeof(sigset_t))
  116. return -EINVAL;
  118. unewset = (sigset_t *) regs.regs[4];
  119. if (copy_from_user(&newset, unewset, sizeof(newset)))
  120. return -EFAULT;
  121. sigdelsetmask(&newset, ~_BLOCKABLE);
  123. spin_lock_irq(&current->sigmask_lock);
  124. saveset = current->blocked;
  125. current->blocked = newset;
  126.         recalc_sigpending(current);
  127. spin_unlock_irq(&current->sigmask_lock);
  129. regs.regs[2] = EINTR;
  130. regs.regs[7] = 1;
  131. while (1) {
  132. current->state = TASK_INTERRUPTIBLE;
  133. schedule();
  134. if (do_signal(&saveset, &regs))
  135. return -EINTR;
  136. }
  137. }
  139. asmlinkage int 
  140. sys_sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
  141. {
  142. struct k_sigaction new_ka, old_ka;
  143. int ret;
  144. int err = 0;
  146. if (act) {
  147. old_sigset_t mask;
  149. if (!access_ok(VERIFY_READ, act, sizeof(*act)))
  150. return -EFAULT;
  151. err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
  152. err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  153. err |= __get_user(mask, &act->sa_mask.sig[0]);
  154. err |= __get_user(new_ka.sa.sa_restorer, &act->sa_restorer);
  155. if (err)
  156. return -EFAULT;
  158. siginitset(&new_ka.sa.sa_mask, mask);
  159. }
  161. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  163. if (!ret && oact) {
  164. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
  165.                         return -EFAULT;
  166. err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  167. err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
  168. err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
  169.                 err |= __put_user(0, &oact->sa_mask.sig[1]);
  170.                 err |= __put_user(0, &oact->sa_mask.sig[2]);
  171.                 err |= __put_user(0, &oact->sa_mask.sig[3]);
  172. err |= __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer);
  173.                 if (err)
  174. return -EFAULT;
  175. }
  177. return ret;
  178. }
  180. asmlinkage int
  181. sys_sigaltstack(struct pt_regs regs)
  182. {
  183. const stack_t *uss = (const stack_t *) regs.regs[4];
  184. stack_t *uoss = (stack_t *) regs.regs[5];
  185. unsigned long usp = regs.regs[29];
  187. return do_sigaltstack(uss, uoss, usp);
  188. }
  190. asmlinkage int
  191. restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
  192. {
  193. int owned_fp;
  194. int err = 0;
  195. u64 reg;
  197. err |= __get_user(regs->cp0_epc, &sc->sc_pc);
  199. err |= __get_user(reg, &sc->sc_mdhi);
  200. regs->hi = (int) reg;
  201. err |= __get_user(reg, &sc->sc_mdlo);
  202. regs->lo = (int) reg;
  204. #define restore_gp_reg(i) do {
  205. err |= __get_user(reg, &sc->sc_regs[i]);
  206. regs->regs[i] = reg;
  207. } while(0);
  208. restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
  209. restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
  210. restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
  211. restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
  212. restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
  213. restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
  214. restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
  215. restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
  216. restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
  217. restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
  218. restore_gp_reg(31);
  219. #undef restore_gp_reg
  221. err |= __get_user(owned_fp, &sc->sc_ownedfp);
  222. if (owned_fp) {
  223. err |= restore_fp_context(sc);
  224. last_task_used_math = current;
  225. }
  227. return err;
  228. }
  230. struct sigframe {
  231. u32 sf_ass[4]; /* argument save space for o32 */
  232. u32 sf_code[2]; /* signal trampoline */
  233. struct sigcontext sf_sc;
  234. sigset_t sf_mask;
  235. };
  237. struct rt_sigframe {
  238. u32 rs_ass[4]; /* argument save space for o32 */
  239. u32 rs_code[2]; /* signal trampoline */
  240. struct siginfo rs_info;
  241. struct ucontext rs_uc;
  242. };
  244. asmlinkage void
  245. sys_sigreturn(struct pt_regs regs)
  246. {
  247. struct sigframe *frame;
  248. sigset_t blocked;
  250. frame = (struct sigframe *) regs.regs[29];
  251. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  252. goto badframe;
  253. if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
  254. goto badframe;
  256. sigdelsetmask(&blocked, ~_BLOCKABLE);
  257. spin_lock_irq(&current->sigmask_lock);
  258. current->blocked = blocked;
  259. recalc_sigpending(current);
  260. spin_unlock_irq(&current->sigmask_lock);
  262. if (restore_sigcontext(&regs, &frame->sf_sc))
  263. goto badframe;
  265. /*
  266.  * Don't let your children do this ...
  267.  */
  268. if (current->ptrace & PT_TRACESYS)
  269. syscall_trace();
  270. __asm__ __volatile__(
  271. "movet$29, %0nt"
  272. "jtret_from_sys_call"
  273. :/* no outputs */
  274. :"r" (&regs));
  275. /* Unreached */
  277. badframe:
  278. force_sig(SIGSEGV, current);
  279. }
  281. asmlinkage void
  282. sys_rt_sigreturn(struct pt_regs regs)
  283. {
  284. struct rt_sigframe *frame;
  285. sigset_t set;
  286. stack_t st;
  288. frame = (struct rt_sigframe *) regs.regs[29];
  289. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  290. goto badframe;
  291. if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
  292. goto badframe;
  294. sigdelsetmask(&set, ~_BLOCKABLE);
  295. spin_lock_irq(&current->sigmask_lock);
  296. current->blocked = set;
  297. recalc_sigpending(current);
  298. spin_unlock_irq(&current->sigmask_lock);
  300. if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
  301. goto badframe;
  303. if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
  304. goto badframe;
  305. /* It is more difficult to avoid calling this function than to
  306.    call it and ignore errors.  */
  307. do_sigaltstack(&st, NULL, regs.regs[29]);
  309. /*
  310.  * Don't let your children do this ...
  311.  */
  312. __asm__ __volatile__(
  313. "movet$29, %0nt"
  314. "jtret_from_sys_call"
  315. :/* no outputs */
  316. :"r" (&regs));
  317. /* Unreached */
  319. badframe:
  320. force_sig(SIGSEGV, current);
  321. }
  323. static int inline
  324. setup_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
  325. {
  326. int owned_fp;
  327. int err = 0;
  328. u64 reg;
  330. err |= __put_user(regs->cp0_epc, &sc->sc_pc);
  331. err |= __put_user(regs->cp0_status, &sc->sc_status);
  333. #define save_gp_reg(i) {
  334. reg = regs->regs[i];
  335. err |= __put_user(reg, &sc->sc_regs[i]);
  336. } while(0)
  337. __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
  338. save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
  339. save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
  340. save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
  341. save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
  342. save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
  343. save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
  344. save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
  345. save_gp_reg(31);
  346. #undef save_gp_reg
  348. err |= __put_user(regs->hi, &sc->sc_mdhi);
  349. err |= __put_user(regs->lo, &sc->sc_mdlo);
  350. err |= __put_user(regs->cp0_cause, &sc->sc_cause);
  351. err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
  353. owned_fp = (current == last_task_used_math);
  354. err |= __put_user(owned_fp, &sc->sc_ownedfp);
  356. if (current->used_math) { /* fp is active.  */
  357. set_cp0_status(ST0_CU1);
  358. err |= save_fp_context(sc);
  359. last_task_used_math = NULL;
  360. regs->cp0_status &= ~ST0_CU1;
  361. current->used_math = 0;
  362. }
  364. return err;
  365. }
  367. /*
  368.  * Determine which stack to use..
  369.  */
  370. static inline void *
  371. get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
  372. {
  373. unsigned long sp;
  375. /* Default to using normal stack */
  376. sp = regs->regs[29];
  378. /* This is the X/Open sanctioned signal stack switching.  */
  379. if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
  380.                 sp = current->sas_ss_sp + current->sas_ss_size;
  382. return (void *)((sp - frame_size) & ALMASK);
  383. }
  385. static void inline
  386. setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
  387.             int signr, sigset_t *set)
  388. {
  389. struct sigframe *frame;
  390. int err = 0;
  392. frame = get_sigframe(ka, regs, sizeof(*frame));
  393. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  394. goto give_sigsegv;
  396. /* Set up to return from userspace.  If provided, use a stub already
  397.    in userspace.  */
  398. if (ka->sa.sa_flags & SA_RESTORER)
  399. regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
  400. else {
  401. /*
  402.  * Set up the return code ...
  403.  *
  404.  *         li      v0, __NR_sigreturn
  405.  *         syscall
  406.  */
  407. err |= __put_user(0x24020000 + __NR_sigreturn,
  408.                   frame->sf_code + 0);
  409. err |= __put_user(0x0000000c                 ,
  410.                   frame->sf_code + 1);
  411. flush_cache_sigtramp((unsigned long) frame->sf_code);
  412. }
  414. err |= setup_sigcontext(regs, &frame->sf_sc);
  415. err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
  416. if (err)
  417. goto give_sigsegv;
  419. /*
  420.  * Arguments to signal handler:
  421.  *
  422.  *   a0 = signal number
  423.  *   a1 = 0 (should be cause)
  424.  *   a2 = pointer to struct sigcontext
  425.  *
  426.  * $25 and c0_epc point to the signal handler, $29 points to the
  427.  * struct sigframe.
  428.  */
  429. regs->regs[ 4] = signr;
  430. regs->regs[ 5] = 0;
  431. regs->regs[ 6] = (unsigned long) &frame->sf_sc;
  432. regs->regs[29] = (unsigned long) frame;
  433. regs->regs[31] = (unsigned long) frame->sf_code;
  434. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  436. #if DEBUG_SIG
  437. printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%pn",
  438.        current->comm, current->pid, frame, regs->cp0_epc, frame->code);
  439. #endif
  440.         return;
  442. give_sigsegv:
  443. if (signr == SIGSEGV)
  444. ka->sa.sa_handler = SIG_DFL;
  445. force_sig(SIGSEGV, current);
  446. }
  448. static void inline
  449. setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
  450.                int signr, sigset_t *set, siginfo_t *info)
  451. {
  452. struct rt_sigframe *frame;
  453. int err = 0;
  455. frame = get_sigframe(ka, regs, sizeof(*frame));
  456. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  457. goto give_sigsegv;
  459. /* Set up to return from userspace.  If provided, use a stub already
  460.    in userspace.  */
  461. if (ka->sa.sa_flags & SA_RESTORER)
  462. regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
  463. else {
  464. /*
  465.  * Set up the return code ...
  466.  *
  467.  *         li      v0, __NR_rt_sigreturn
  468.  *         syscall
  469.  */
  470. err |= __put_user(0x24020000 + __NR_rt_sigreturn,
  471.                   frame->rs_code + 0);
  472. err |= __put_user(0x0000000c                 ,
  473.                   frame->rs_code + 1);
  474. flush_cache_sigtramp((unsigned long) frame->rs_code);
  475. }
  477. /* Create siginfo.  */
  478. err |= copy_siginfo_to_user(&frame->rs_info, info);
  480. /* Create the ucontext.  */
  481. err |= __put_user(0, &frame->rs_uc.uc_flags);
  482. err |= __put_user(0, &frame->rs_uc.uc_link);
  483. err |= __put_user((void *)current->sas_ss_sp,
  484.                   &frame->rs_uc.uc_stack.ss_sp);
  485. err |= __put_user(sas_ss_flags(regs->regs[29]),
  486.                   &frame->rs_uc.uc_stack.ss_flags);
  487. err |= __put_user(current->sas_ss_size,
  488.                   &frame->rs_uc.uc_stack.ss_size);
  489. err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
  490. err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
  492. if (err)
  493. goto give_sigsegv;
  495. /*
  496.  * Arguments to signal handler:
  497.  *
  498.  *   a0 = signal number
  499.  *   a1 = 0 (should be cause)
  500.  *   a2 = pointer to ucontext
  501.  *
  502.  * $25 and c0_epc point to the signal handler, $29 points to
  503.  * the struct rt_sigframe.
  504.  */
  505. regs->regs[ 4] = signr;
  506. regs->regs[ 5] = (unsigned long) &frame->rs_info;
  507. regs->regs[ 6] = (unsigned long) &frame->rs_uc;
  508. regs->regs[29] = (unsigned long) frame;
  509. regs->regs[31] = (unsigned long) frame->rs_code;
  510. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  512. #if DEBUG_SIG
  513. printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%pn",
  514.        current->comm, current->pid, frame, regs->cp0_epc, frame->code);
  515. #endif
  516. return;
  518. give_sigsegv:
  519. if (signr == SIGSEGV)
  520. ka->sa.sa_handler = SIG_DFL;
  521. force_sig(SIGSEGV, current);
  522. }
  524. static inline void
  525. handle_signal(unsigned long sig, struct k_sigaction *ka,
  526. siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  527. {
  528. if (ka->sa.sa_flags & SA_SIGINFO)
  529. setup_rt_frame(ka, regs, sig, oldset, info);
  530. else
  531. setup_frame(ka, regs, sig, oldset);
  533. if (ka->sa.sa_flags & SA_ONESHOT)
  534. ka->sa.sa_handler = SIG_DFL;
  535. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  536. spin_lock_irq(&current->sigmask_lock);
  537. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  538. sigaddset(&current->blocked,sig);
  539. recalc_sigpending(current);
  540. spin_unlock_irq(&current->sigmask_lock);
  541. }
  542. }
  544. static inline void
  545. syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
  546. {
  547. switch(regs->regs[0]) {
  548. case ERESTARTNOHAND:
  549. regs->regs[2] = EINTR;
  550. break;
  551. case ERESTARTSYS:
  552. if(!(ka->sa.sa_flags & SA_RESTART)) {
  553. regs->regs[2] = EINTR;
  554. break;
  555. }
  556. /* fallthrough */
  557. case ERESTARTNOINTR: /* Userland will reload $v0.  */
  558. regs->regs[7] = regs->regs[26];
  559. regs->cp0_epc -= 8;
  560. }
  562. regs->regs[0] = 0; /* Don't deal with this again.  */
  563. }
  565. extern int do_irix_signal(sigset_t *oldset, struct pt_regs *regs);
  567. asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
  568. {
  569. struct k_sigaction *ka;
  570. siginfo_t info;
  572. #ifdef CONFIG_BINFMT_IRIX
  573. if (current->personality != PER_LINUX)
  574. return do_irix_signal(oldset, regs);
  575. #endif
  577. if (!oldset)
  578. oldset = &current->blocked;
  580. for (;;) {
  581. unsigned long signr;
  583. spin_lock_irq(&current->sigmask_lock);
  584. signr = dequeue_signal(&current->blocked, &info);
  585. spin_unlock_irq(&current->sigmask_lock);
  587. if (!signr)
  588. break;
  590. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  591. /* Let the debugger run.  */
  592. current->exit_code = signr;
  593. current->state = TASK_STOPPED;
  594. notify_parent(current, SIGCHLD);
  595. schedule();
  597. /* We're back.  Did the debugger cancel the sig?  */
  598. if (!(signr = current->exit_code))
  599. continue;
  600. current->exit_code = 0;
  602. /* The debugger continued.  Ignore SIGSTOP.  */
  603. if (signr == SIGSTOP)
  604. continue;
  606. /* Update the siginfo structure.  Is this good?  */
  607. if (signr != info.si_signo) {
  608. info.si_signo = signr;
  609. info.si_errno = 0;
  610. info.si_code = SI_USER;
  611. info.si_pid = current->p_pptr->pid;
  612. info.si_uid = current->p_pptr->uid;
  613. }
  615. /* If the (new) signal is now blocked, requeue it.  */
  616. if (sigismember(&current->blocked, signr)) {
  617. send_sig_info(signr, &info, current);
  618. continue;
  619. }
  620. }
  622. ka = &current->sig->action[signr-1];
  623. if (ka->sa.sa_handler == SIG_IGN) {
  624. if (signr != SIGCHLD)
  625. continue;
  626. /* Check for SIGCHLD: it's special.  */
  627. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  628. /* nothing */;
  629. continue;
  630. }
  632. if (ka->sa.sa_handler == SIG_DFL) {
  633. int exit_code = signr;
  635. /* Init gets no signals it doesn't want.  */
  636. if (current->pid == 1)
  637. continue;
  639. switch (signr) {
  640. case SIGCONT: case SIGCHLD: case SIGWINCH:
  641. continue;
  643. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  644. if (is_orphaned_pgrp(current->pgrp))
  645. continue;
  646. /* FALLTHRU */
  648. case SIGSTOP:
  649. current->state = TASK_STOPPED;
  650. current->exit_code = signr;
  651. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  652. notify_parent(current, SIGCHLD);
  653. schedule();
  654. continue;
  656. case SIGQUIT: case SIGILL: case SIGTRAP:
  657. case SIGABRT: case SIGFPE: case SIGSEGV:
  658. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  659. if (do_coredump(signr, regs))
  660. exit_code |= 0x80;
  661. /* FALLTHRU */
  663. default:
  664. sigaddset(&current->pending.signal, signr);
  665. recalc_sigpending(current);
  666. current->flags |= PF_SIGNALED;
  667. do_exit(exit_code);
  668. /* NOTREACHED */
  669. }
  670. }
  672. if (regs->regs[0])
  673. syscall_restart(regs, ka);
  674. /* Whee!  Actually deliver the signal.  */
  675. handle_signal(signr, ka, &info, oldset, regs);
  676. return 1;
  677. }
  679. /*
  680.  * Who's code doesn't conform to the restartable syscall convention
  681.  * dies here!!!  The li instruction, a single machine instruction,
  682.  * must directly be followed by the syscall instruction.
  683.  */
  684. if (regs->regs[0]) {
  685. if (regs->regs[2] == ERESTARTNOHAND ||
  686.     regs->regs[2] == ERESTARTSYS ||
  687.     regs->regs[2] == ERESTARTNOINTR) {
  688. regs->regs[7] = regs->regs[26];
  689. regs->cp0_epc -= 8;
  690. }
  691. }
  692. return 0;
  693. }