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

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

嵌入式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 - 2000  Ralf Baechle
  8.  * Copyright (C) 1999, 2000 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>
  28. #include <asm/system.h>
  30. #define DEBUG_SIG 0
  32. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  34. 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. switch (from->si_code >> 16) {
  58. case __SI_FAULT >> 16:
  59. err |= __put_user((long)from->si_addr, &to->si_addr);
  60. break;
  61. case __SI_CHLD >> 16:
  62. err |= __put_user(from->si_utime, &to->si_utime);
  63. err |= __put_user(from->si_stime, &to->si_stime);
  64. err |= __put_user(from->si_status, &to->si_status);
  65. default:
  66. err |= __put_user(from->si_pid, &to->si_pid);
  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. static inline int store_fp_context(struct sigcontext *sc)
  76. {
  77. unsigned int fcr0;
  78. int err = 0;
  80. err |= __copy_to_user(&sc->sc_fpregs[0], 
  81. &current->thread.fpu.hard.fp_regs[0], NUM_FPU_REGS * 
  82. sizeof(unsigned long));
  83. err |= __copy_to_user(&sc->sc_fpc_csr, &current->thread.fpu.hard.control,
  84. sizeof(unsigned int));
  85. __asm__ __volatile__("cfc1 %0, $0nt" : "=r" (fcr0));
  86. err |= __copy_to_user(&sc->sc_fpc_eir, &fcr0, sizeof(unsigned int));
  88. return err;
  89. }
  91. static inline int refill_fp_context(struct sigcontext *sc)
  92. {
  93. int err = 0;
  95. if (verify_area(VERIFY_READ, sc, sizeof(*sc)))
  96. return -EFAULT;
  97. err |= __copy_from_user(&current->thread.fpu.hard.fp_regs[0], 
  98. &sc->sc_fpregs[0], NUM_FPU_REGS * sizeof(unsigned long));
  99. err |= __copy_from_user(&current->thread.fpu.hard.control, &sc->sc_fpc_csr,
  100. sizeof(unsigned int));
  101. return err;
  102. }
  104. /*
  105.  * Atomically swap in the new signal mask, and wait for a signal.
  106.  */
  107. asmlinkage inline int
  108. sys_sigsuspend(abi64_no_regargs, struct pt_regs regs)
  109. {
  110. sigset_t *uset, saveset, newset;
  112. save_static(&regs);
  113. uset = (sigset_t *) regs.regs[4];
  114. if (copy_from_user(&newset, uset, sizeof(sigset_t)))
  115. return -EFAULT;
  116. sigdelsetmask(&newset, ~_BLOCKABLE);
  118. spin_lock_irq(&current->sigmask_lock);
  119. saveset = current->blocked;
  120. current->blocked = newset;
  121. recalc_sigpending(current);
  122. spin_unlock_irq(&current->sigmask_lock);
  124. regs.regs[2] = EINTR;
  125. regs.regs[7] = 1;
  126. while (1) {
  127. current->state = TASK_INTERRUPTIBLE;
  128. schedule();
  129. if (do_signal(&saveset, &regs))
  130. return -EINTR;
  131. }
  132. }
  134. asmlinkage int
  135. sys_rt_sigsuspend(abi64_no_regargs, struct pt_regs regs)
  136. {
  137. sigset_t *unewset, saveset, newset;
  138.         size_t sigsetsize;
  140. save_static(&regs);
  142. /* XXX Don't preclude handling different sized sigset_t's.  */
  143. sigsetsize = regs.regs[5];
  144. if (sigsetsize != sizeof(sigset_t))
  145. return -EINVAL;
  147. unewset = (sigset_t *) regs.regs[4];
  148. if (copy_from_user(&newset, unewset, sizeof(newset)))
  149. return -EFAULT;
  150. sigdelsetmask(&newset, ~_BLOCKABLE);
  152. spin_lock_irq(&current->sigmask_lock);
  153. saveset = current->blocked;
  154. current->blocked = newset;
  155.         recalc_sigpending(current);
  156. spin_unlock_irq(&current->sigmask_lock);
  158. regs.regs[2] = EINTR;
  159. regs.regs[7] = 1;
  160. while (1) {
  161. current->state = TASK_INTERRUPTIBLE;
  162. schedule();
  163. if (do_signal(&saveset, &regs))
  164. return -EINTR;
  165. }
  166. }
  168. asmlinkage int 
  169. sys_sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
  170. {
  171. struct k_sigaction new_ka, old_ka;
  172. int ret;
  173. int err = 0;
  175. if (act) {
  176. old_sigset_t mask;
  178. if (!access_ok(VERIFY_READ, act, sizeof(*act)))
  179. return -EFAULT;
  180. err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
  181. err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  182. err |= __get_user(mask, &act->sa_mask.sig[0]);
  183. err |= __get_user(new_ka.sa.sa_restorer, &act->sa_restorer);
  184. if (err)
  185. return -EFAULT;
  187. siginitset(&new_ka.sa.sa_mask, mask);
  188. }
  190. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  192. if (!ret && oact) {
  193. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
  194.                         return -EFAULT;
  195. err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  196. err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
  197. err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
  198.                 err |= __put_user(0, &oact->sa_mask.sig[1]);
  199. err |= __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer);
  200.                 if (err)
  201. return -EFAULT;
  202. }
  204. return ret;
  205. }
  207. asmlinkage int
  208. sys_sigaltstack(abi64_no_regargs, struct pt_regs regs)
  209. {
  210. const stack_t *uss = (const stack_t *) regs.regs[4];
  211. stack_t *uoss = (stack_t *) regs.regs[5];
  212. unsigned long usp = regs.regs[29];
  214. return do_sigaltstack(uss, uoss, usp);
  215. }
  217. asmlinkage int
  218. restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
  219. {
  220. int owned_fp;
  221. int err = 0;
  223. err |= __get_user(regs->cp0_epc, &sc->sc_pc);
  224. err |= __get_user(regs->hi, &sc->sc_mdhi);
  225. err |= __get_user(regs->lo, &sc->sc_mdlo);
  227. #define restore_gp_reg(i) do {
  228. err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
  229. } while(0)
  230. restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
  231. restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
  232. restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
  233. restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
  234. restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
  235. restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
  236. restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
  237. restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
  238. restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
  239. restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
  240. restore_gp_reg(31);
  241. #undef restore_gp_reg
  243. err |= __get_user(owned_fp, &sc->sc_ownedfp);
  244. if (owned_fp) {
  245. if (IS_FPU_OWNER()) {
  246. CLEAR_FPU_OWNER();
  247. regs->cp0_status &= ~ST0_CU1;
  248. }
  249. current->used_math = 1;
  250. err |= refill_fp_context(sc);
  251. }
  253. return err;
  254. }
  256. struct sigframe {
  257. u32 sf_ass[4]; /* argument save space for o32 */
  258. u32 sf_code[2]; /* signal trampoline */
  259. struct sigcontext sf_sc;
  260. sigset_t sf_mask;
  261. };
  263. struct rt_sigframe {
  264. u32 rs_ass[4]; /* argument save space for o32 */
  265. u32 rs_code[2]; /* signal trampoline */
  266. struct siginfo rs_info;
  267. struct ucontext rs_uc;
  268. };
  270. asmlinkage void sys_sigreturn(abi64_no_regargs, struct pt_regs regs)
  271. {
  272. struct sigframe *frame;
  273. sigset_t blocked;
  275. frame = (struct sigframe *) regs.regs[29];
  276. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  277. goto badframe;
  278. if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
  279. goto badframe;
  281. sigdelsetmask(&blocked, ~_BLOCKABLE);
  282. spin_lock_irq(&current->sigmask_lock);
  283. current->blocked = blocked;
  284. recalc_sigpending(current);
  285. spin_unlock_irq(&current->sigmask_lock);
  287. if (restore_sigcontext(&regs, &frame->sf_sc))
  288. goto badframe;
  290. /*
  291.  * Don't let your children do this ...
  292.  */
  293. if (current->ptrace & PT_TRACESYS)
  294. syscall_trace();
  295. __asm__ __volatile__(
  296. "movet$29, %0nt"
  297. "jtret_from_sys_call"
  298. :/* no outputs */
  299. :"r" (&regs));
  300. /* Unreached */
  302. badframe:
  303. force_sig(SIGSEGV, current);
  304. }
  306. asmlinkage void sys_rt_sigreturn(abi64_no_regargs, struct pt_regs regs)
  307. {
  308. struct rt_sigframe *frame;
  309. sigset_t set;
  310. stack_t st;
  312. frame = (struct rt_sigframe *) regs.regs[29];
  313. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  314. goto badframe;
  315. if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
  316. goto badframe;
  318. sigdelsetmask(&set, ~_BLOCKABLE);
  319. spin_lock_irq(&current->sigmask_lock);
  320. current->blocked = set;
  321. recalc_sigpending(current);
  322. spin_unlock_irq(&current->sigmask_lock);
  324. if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
  325. goto badframe;
  327. if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
  328. goto badframe;
  329. /* It is more difficult to avoid calling this function than to
  330.    call it and ignore errors.  */
  331. do_sigaltstack(&st, NULL, regs.regs[29]);
  333. /*
  334.  * Don't let your children do this ...
  335.  */
  336. __asm__ __volatile__(
  337. "movet$29, %0nt"
  338. "jtret_from_sys_call"
  339. :/* no outputs */
  340. :"r" (&regs));
  341. /* Unreached */
  343. badframe:
  344. force_sig(SIGSEGV, current);
  345. }
  347. static int inline setup_sigcontext(struct pt_regs *regs,
  348.    struct sigcontext *sc)
  349. {
  350. int err = 0;
  352. err |= __put_user(regs->cp0_epc, &sc->sc_pc);
  354. #define save_gp_reg(i) do {
  355. err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
  356. } while(0)
  357. __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
  358. save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
  359. save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
  360. save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
  361. save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
  362. save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
  363. save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
  364. save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
  365. save_gp_reg(31);
  366. #undef save_gp_reg
  368. err |= __put_user(regs->hi, &sc->sc_mdhi);
  369. err |= __put_user(regs->lo, &sc->sc_mdlo);
  370. err |= __put_user(regs->cp0_cause, &sc->sc_cause);
  371. err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
  373. if (current->used_math) { /* fp is active.  */
  374. if (IS_FPU_OWNER()) {
  375. lazy_fpu_switch(current, 0);
  376. CLEAR_FPU_OWNER();
  377. regs->cp0_status &= ~ST0_CU1;
  378. }
  379. err |= __put_user(1, &sc->sc_ownedfp);
  380. err |= store_fp_context(sc);
  381. current->used_math = 0;
  382. } else {
  383. err |= __put_user(0, &sc->sc_ownedfp);
  384. }
  385. err |= __put_user(regs->cp0_status, &sc->sc_status);
  387. return err;
  388. }
  390. /*
  391.  * Determine which stack to use..
  392.  */
  393. static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
  394.  size_t frame_size)
  395. {
  396. unsigned long sp;
  398. /* Default to using normal stack */
  399. sp = regs->regs[29];
  401. /* This is the X/Open sanctioned signal stack switching.  */
  402. if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
  403. sp = current->sas_ss_sp + current->sas_ss_size;
  405. return (void *)((sp - frame_size) & ALMASK);
  406. }
  408. static void inline setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
  409.        int signr, sigset_t *set)
  410. {
  411. struct sigframe *frame;
  412. int err = 0;
  414. frame = get_sigframe(ka, regs, sizeof(*frame));
  415. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  416. goto give_sigsegv;
  418. /* Set up to return from userspace.  If provided, use a stub already
  419.    in userspace.  */
  420. if (ka->sa.sa_flags & SA_RESTORER)
  421. regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
  422. else {
  423. /*
  424.  * Set up the return code ...
  425.  *
  426.  *         li      v0, __NR_sigreturn
  427.  *         syscall
  428.  */
  429. err |= __put_user(0x24020000 + __NR_sigreturn,
  430.                   frame->sf_code + 0);
  431. err |= __put_user(0x0000000c                 ,
  432.                   frame->sf_code + 1);
  433. flush_cache_sigtramp((unsigned long) frame->sf_code);
  434. }
  436. err |= setup_sigcontext(regs, &frame->sf_sc);
  437. err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
  438. if (err)
  439. goto give_sigsegv;
  441. /*
  442.  * Arguments to signal handler:
  443.  *
  444.  *   a0 = signal number
  445.  *   a1 = 0 (should be cause)
  446.  *   a2 = pointer to struct sigcontext
  447.  *
  448.  * $25 and c0_epc point to the signal handler, $29 points to the
  449.  * struct sigframe.
  450.  */
  451. regs->regs[ 4] = signr;
  452. regs->regs[ 5] = 0;
  453. regs->regs[ 6] = (unsigned long) &frame->sf_sc;
  454. regs->regs[29] = (unsigned long) frame;
  455. regs->regs[31] = (unsigned long) frame->sf_code;
  456. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  458. #if DEBUG_SIG
  459. printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%pn",
  460.        current->comm, current->pid, frame, regs->cp0_epc, frame->code);
  461. #endif
  462.         return;
  464. give_sigsegv:
  465. if (signr == SIGSEGV)
  466. ka->sa.sa_handler = SIG_DFL;
  467. force_sig(SIGSEGV, current);
  468. }
  470. static void inline setup_rt_frame(struct k_sigaction * ka,
  471.   struct pt_regs *regs, int signr,
  472.   sigset_t *set, siginfo_t *info)
  473. {
  474. struct rt_sigframe *frame;
  475. int err = 0;
  477. frame = get_sigframe(ka, regs, sizeof(*frame));
  478. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  479. goto give_sigsegv;
  481. /* Set up to return from userspace.  If provided, use a stub already
  482.    in userspace.  */
  483. if (ka->sa.sa_flags & SA_RESTORER)
  484. regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
  485. else {
  486. /*
  487.  * Set up the return code ...
  488.  *
  489.  *         li      v0, __NR_rt_sigreturn
  490.  *         syscall
  491.  */
  492. err |= __put_user(0x24020000 + __NR_rt_sigreturn,
  493.                   frame->rs_code + 0);
  494. err |= __put_user(0x0000000c                 ,
  495.                   frame->rs_code + 1);
  496. flush_cache_sigtramp((unsigned long) frame->rs_code);
  497. }
  499. /* Create siginfo.  */
  500. err |= copy_siginfo_to_user(&frame->rs_info, info);
  502. /* Create the ucontext.  */
  503. err |= __put_user(0, &frame->rs_uc.uc_flags);
  504. err |= __put_user(0, &frame->rs_uc.uc_link);
  505. err |= __put_user((void *)current->sas_ss_sp,
  506.                   &frame->rs_uc.uc_stack.ss_sp);
  507. err |= __put_user(sas_ss_flags(regs->regs[29]),
  508.                   &frame->rs_uc.uc_stack.ss_flags);
  509. err |= __put_user(current->sas_ss_size,
  510.                   &frame->rs_uc.uc_stack.ss_size);
  511. err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
  512. err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
  514. if (err)
  515. goto give_sigsegv;
  517. /*
  518.  * Arguments to signal handler:
  519.  *
  520.  *   a0 = signal number
  521.  *   a1 = 0 (should be cause)
  522.  *   a2 = pointer to ucontext
  523.  *
  524.  * $25 and c0_epc point to the signal handler, $29 points to
  525.  * the struct rt_sigframe.
  526.  */
  527. regs->regs[ 4] = signr;
  528. regs->regs[ 5] = (unsigned long) &frame->rs_info;
  529. regs->regs[ 6] = (unsigned long) &frame->rs_uc;
  530. regs->regs[29] = (unsigned long) frame;
  531. regs->regs[31] = (unsigned long) frame->rs_code;
  532. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  534. #if DEBUG_SIG
  535. printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%pn",
  536.        current->comm, current->pid, frame, regs->cp0_epc, frame->code);
  537. #endif
  538. return;
  540. give_sigsegv:
  541. if (signr == SIGSEGV)
  542. ka->sa.sa_handler = SIG_DFL;
  543. force_sig(SIGSEGV, current);
  544. }
  546. static inline void handle_signal(unsigned long sig, struct k_sigaction *ka,
  547.  siginfo_t *info, sigset_t *oldset,
  548.  struct pt_regs *regs)
  549. {
  550. if (ka->sa.sa_flags & SA_SIGINFO)
  551. setup_rt_frame(ka, regs, sig, oldset, info);
  552. else
  553. setup_frame(ka, regs, sig, oldset);
  555. if (ka->sa.sa_flags & SA_ONESHOT)
  556. ka->sa.sa_handler = SIG_DFL;
  557. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  558. spin_lock_irq(&current->sigmask_lock);
  559. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  560. sigaddset(&current->blocked,sig);
  561. recalc_sigpending(current);
  562. spin_unlock_irq(&current->sigmask_lock);
  563. }
  564. }
  566. static inline void syscall_restart(struct pt_regs *regs,
  567.    struct k_sigaction *ka)
  568. {
  569. switch(regs->regs[0]) {
  570. case ERESTARTNOHAND:
  571. regs->regs[2] = EINTR;
  572. break;
  573. case ERESTARTSYS:
  574. if(!(ka->sa.sa_flags & SA_RESTART)) {
  575. regs->regs[2] = EINTR;
  576. break;
  577. }
  578. /* fallthrough */
  579. case ERESTARTNOINTR: /* Userland will reload $v0.  */
  580. regs->regs[7] = regs->regs[26];
  581. regs->cp0_epc -= 8;
  582. }
  584. regs->regs[0] = 0; /* Don't deal with this again.  */
  585. }
  587. extern int do_irix_signal(sigset_t *oldset, struct pt_regs *regs);
  588. extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
  590. asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
  591. {
  592. struct k_sigaction *ka;
  593. siginfo_t info;
  595. #ifdef CONFIG_BINFMT_ELF32
  596. if (current->thread.mflags & MF_32BIT) {
  597. return do_signal32(oldset, regs);
  598. }
  599. #endif
  601. if (!oldset)
  602. oldset = &current->blocked;
  604. for (;;) {
  605. unsigned long signr;
  607. spin_lock_irq(&current->sigmask_lock);
  608. signr = dequeue_signal(&current->blocked, &info);
  609. spin_unlock_irq(&current->sigmask_lock);
  611. if (!signr)
  612. break;
  614. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  615. /* Let the debugger run.  */
  616. current->exit_code = signr;
  617. current->state = TASK_STOPPED;
  618. notify_parent(current, SIGCHLD);
  619. schedule();
  621. /* We're back.  Did the debugger cancel the sig?  */
  622. if (!(signr = current->exit_code))
  623. continue;
  624. current->exit_code = 0;
  626. /* The debugger continued.  Ignore SIGSTOP.  */
  627. if (signr == SIGSTOP)
  628. continue;
  630. /* Update the siginfo structure.  Is this good?  */
  631. if (signr != info.si_signo) {
  632. info.si_signo = signr;
  633. info.si_errno = 0;
  634. info.si_code = SI_USER;
  635. info.si_pid = current->p_pptr->pid;
  636. info.si_uid = current->p_pptr->uid;
  637. }
  639. /* If the (new) signal is now blocked, requeue it.  */
  640. if (sigismember(&current->blocked, signr)) {
  641. send_sig_info(signr, &info, current);
  642. continue;
  643. }
  644. }
  646. ka = &current->sig->action[signr-1];
  647. if (ka->sa.sa_handler == SIG_IGN) {
  648. if (signr != SIGCHLD)
  649. continue;
  650. /* Check for SIGCHLD: it's special.  */
  651. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  652. /* nothing */;
  653. continue;
  654. }
  656. if (ka->sa.sa_handler == SIG_DFL) {
  657. int exit_code = signr;
  659. /* Init gets no signals it doesn't want.  */
  660. if (current->pid == 1)
  661. continue;
  663. switch (signr) {
  664. case SIGCONT: case SIGCHLD: case SIGWINCH:
  665. continue;
  667. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  668. if (is_orphaned_pgrp(current->pgrp))
  669. continue;
  670. /* FALLTHRU */
  672. case SIGSTOP:
  673. current->state = TASK_STOPPED;
  674. current->exit_code = signr;
  675. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  676. notify_parent(current, SIGCHLD);
  677. schedule();
  678. continue;
  680. case SIGQUIT: case SIGILL: case SIGTRAP:
  681. case SIGABRT: case SIGFPE: case SIGSEGV:
  682. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  683. if (do_coredump(signr, regs))
  684. exit_code |= 0x80;
  685. /* FALLTHRU */
  687. default:
  688. sigaddset(&current->pending.signal, signr);
  689. recalc_sigpending(current);
  690. current->flags |= PF_SIGNALED;
  691. do_exit(exit_code);
  692. /* NOTREACHED */
  693. }
  694. }
  696. if (regs->regs[0])
  697. syscall_restart(regs, ka);
  698. /* Whee!  Actually deliver the signal.  */
  699. handle_signal(signr, ka, &info, oldset, regs);
  700. return 1;
  701. }
  703. /*
  704.  * Who's code doesn't conform to the restartable syscall convention
  705.  * dies here!!!  The li instruction, a single machine instruction,
  706.  * must directly be followed by the syscall instruction.
  707.  */
  708. if (regs->regs[0]) {
  709. if (regs->regs[2] == ERESTARTNOHAND ||
  710.     regs->regs[2] == ERESTARTSYS ||
  711.     regs->regs[2] == ERESTARTNOINTR) {
  712. regs->regs[7] = regs->regs[26];
  713. regs->cp0_epc -= 8;
  714. }
  715. }
  716. return 0;
  717. }