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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
signal.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：21k
源码类别：

Linux/Unix编程

开发平台：

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/personality.h>
  17. #include <linux/signal.h>
  18. #include <linux/errno.h>
  19. #include <linux/wait.h>
  20. #include <linux/unistd.h>
  22. #include <asm/asm.h>
  23. #include <asm/bitops.h>
  24. #include <asm/cpu.h>
  25. #include <asm/offset.h>
  26. #include <asm/pgalloc.h>
  27. #include <asm/ptrace.h>
  28. #include <asm/uaccess.h>
  29. #include <asm/ucontext.h>
  31. #define DEBUG_SIG 0
  33. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  35. extern asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  37. extern asmlinkage int (*save_fp_context)(struct sigcontext *sc);
  38. extern asmlinkage int (*restore_fp_context)(struct sigcontext *sc);
  40. extern asmlinkage void syscall_trace(void);
  42. int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  43. {
  44. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  45. return -EFAULT;
  46. if (from->si_code < 0)
  47. return __copy_to_user(to, from, sizeof(siginfo_t));
  48. else {
  49. int err;
  51. /* If you change siginfo_t structure, please be sure
  52.    this code is fixed accordingly.
  53.    It should never copy any pad contained in the structure
  54.    to avoid security leaks, but must copy the generic
  55.    3 ints plus the relevant union member.  */
  56. err = __put_user(from->si_signo, &to->si_signo);
  57. err |= __put_user(from->si_errno, &to->si_errno);
  58. err |= __put_user((short)from->si_code, &to->si_code);
  59. /* First 32bits of unions are always present.  */
  60. err |= __put_user(from->si_pid, &to->si_pid);
  61. switch (from->si_code >> 16) {
  62. case __SI_FAULT >> 16:
  63. break;
  64. case __SI_CHLD >> 16:
  65. err |= __put_user(from->si_utime, &to->si_utime);
  66. err |= __put_user(from->si_stime, &to->si_stime);
  67. err |= __put_user(from->si_status, &to->si_status);
  68. default:
  69. err |= __put_user(from->si_uid, &to->si_uid);
  70. break;
  71. /* case __SI_RT: This is not generated by the kernel as of now.  */
  72. }
  73. return err;
  74. }
  75. }
  77. /*
  78.  * Atomically swap in the new signal mask, and wait for a signal.
  79.  */
  80. save_static_function(sys_sigsuspend);
  81. static_unused int _sys_sigsuspend(struct pt_regs regs)
  82. {
  83. sigset_t *uset, saveset, newset;
  85. uset = (sigset_t *) regs.regs[4];
  86. if (copy_from_user(&newset, uset, sizeof(sigset_t)))
  87. return -EFAULT;
  88. sigdelsetmask(&newset, ~_BLOCKABLE);
  90. spin_lock_irq(&current->sigmask_lock);
  91. saveset = current->blocked;
  92. current->blocked = newset;
  93. recalc_sigpending(current);
  94. spin_unlock_irq(&current->sigmask_lock);
  96. regs.regs[2] = EINTR;
  97. regs.regs[7] = 1;
  98. while (1) {
  99. current->state = TASK_INTERRUPTIBLE;
  100. schedule();
  101. if (do_signal(&saveset, &regs))
  102. return -EINTR;
  103. }
  104. }
  106. save_static_function(sys_rt_sigsuspend);
  107. static_unused int _sys_rt_sigsuspend(struct pt_regs regs)
  108. {
  109. sigset_t *unewset, saveset, newset;
  110.         size_t sigsetsize;
  112. /* XXX Don't preclude handling different sized sigset_t's.  */
  113. sigsetsize = regs.regs[5];
  114. if (sigsetsize != sizeof(sigset_t))
  115. return -EINVAL;
  117. unewset = (sigset_t *) regs.regs[4];
  118. if (copy_from_user(&newset, unewset, sizeof(newset)))
  119. return -EFAULT;
  120. sigdelsetmask(&newset, ~_BLOCKABLE);
  122. spin_lock_irq(&current->sigmask_lock);
  123. saveset = current->blocked;
  124. current->blocked = newset;
  125.         recalc_sigpending(current);
  126. spin_unlock_irq(&current->sigmask_lock);
  128. regs.regs[2] = EINTR;
  129. regs.regs[7] = 1;
  130. while (1) {
  131. current->state = TASK_INTERRUPTIBLE;
  132. schedule();
  133. if (do_signal(&saveset, &regs))
  134. return -EINTR;
  135. }
  136. }
  138. asmlinkage int sys_sigaction(int sig, const struct sigaction *act,
  139. struct sigaction *oact)
  140. {
  141. struct k_sigaction new_ka, old_ka;
  142. int ret;
  143. int err = 0;
  145. if (act) {
  146. old_sigset_t mask;
  148. if (!access_ok(VERIFY_READ, act, sizeof(*act)))
  149. return -EFAULT;
  150. err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
  151. err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  152. err |= __get_user(mask, &act->sa_mask.sig[0]);
  153. err |= __get_user(new_ka.sa.sa_restorer, &act->sa_restorer);
  154. if (err)
  155. return -EFAULT;
  157. siginitset(&new_ka.sa.sa_mask, mask);
  158. }
  160. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  162. if (!ret && oact) {
  163. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
  164.                         return -EFAULT;
  165. err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  166. err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
  167. err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
  168.                 err |= __put_user(0, &oact->sa_mask.sig[1]);
  169.                 err |= __put_user(0, &oact->sa_mask.sig[2]);
  170.                 err |= __put_user(0, &oact->sa_mask.sig[3]);
  171. err |= __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer);
  172.                 if (err)
  173. return -EFAULT;
  174. }
  176. return ret;
  177. }
  179. asmlinkage int sys_sigaltstack(struct pt_regs regs)
  180. {
  181. const stack_t *uss = (const stack_t *) regs.regs[4];
  182. stack_t *uoss = (stack_t *) regs.regs[5];
  183. unsigned long usp = regs.regs[29];
  185. return do_sigaltstack(uss, uoss, usp);
  186. }
  188. static inline int restore_thread_fp_context(struct sigcontext *sc)
  189. {
  190. u64 *pfreg = &current->thread.fpu.soft.regs[0];
  191. int err = 0;
  193. /*
  194.  * Copy all 32 64-bit values, for two reasons.  First, the R3000 and
  195.  * R4000/MIPS32 kernels use the thread FP register storage differently,
  196.  * such that a full copy is essentially necessary to support both.
  197.  */
  199. #define restore_fpr(i) 
  200. do { err |= __get_user(pfreg[i], &sc->sc_fpregs[i]); } while(0)
  202. restore_fpr( 0); restore_fpr( 1); restore_fpr( 2); restore_fpr( 3);
  203. restore_fpr( 4); restore_fpr( 5); restore_fpr( 6); restore_fpr( 7);
  204. restore_fpr( 8); restore_fpr( 9); restore_fpr(10); restore_fpr(11);
  205. restore_fpr(12); restore_fpr(13); restore_fpr(14); restore_fpr(15);
  206. restore_fpr(16); restore_fpr(17); restore_fpr(18); restore_fpr(19);
  207. restore_fpr(20); restore_fpr(21); restore_fpr(22); restore_fpr(23);
  208. restore_fpr(24); restore_fpr(25); restore_fpr(26); restore_fpr(27);
  209. restore_fpr(28); restore_fpr(29); restore_fpr(30); restore_fpr(31);
  211. err |= __get_user(current->thread.fpu.soft.sr, &sc->sc_fpc_csr);
  213. return err;
  214. }
  216. static inline int save_thread_fp_context(struct sigcontext *sc)
  217. {
  218. u64 *pfreg = &current->thread.fpu.soft.regs[0];
  219. int err = 0;
  221. #define save_fpr(i) 
  222. do { err |= __put_user(pfreg[i], &sc->sc_fpregs[i]); } while(0)
  224. save_fpr( 0); save_fpr( 1); save_fpr( 2); save_fpr( 3);
  225. save_fpr( 4); save_fpr( 5); save_fpr( 6); save_fpr( 7);
  226. save_fpr( 8); save_fpr( 9); save_fpr(10); save_fpr(11);
  227. save_fpr(12); save_fpr(13); save_fpr(14); save_fpr(15);
  228. save_fpr(16); save_fpr(17); save_fpr(18); save_fpr(19);
  229. save_fpr(20); save_fpr(21); save_fpr(22); save_fpr(23);
  230. save_fpr(24); save_fpr(25); save_fpr(26); save_fpr(27);
  231. save_fpr(28); save_fpr(29); save_fpr(30); save_fpr(31);
  233. err |= __put_user(current->thread.fpu.soft.sr, &sc->sc_fpc_csr);
  235. return err;
  236. }
  238. static int restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
  239. {
  240. int owned_fp;
  241. int err = 0;
  242. u64 reg;
  244. err |= __get_user(regs->cp0_epc, &sc->sc_pc);
  246. err |= __get_user(reg, &sc->sc_mdhi);
  247. regs->hi = (int) reg;
  248. err |= __get_user(reg, &sc->sc_mdlo);
  249. regs->lo = (int) reg;
  251. #define restore_gp_reg(i) do {
  252. err |= __get_user(reg, &sc->sc_regs[i]);
  253. regs->regs[i] = reg;
  254. } while(0)
  255. restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
  256. restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
  257. restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
  258. restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
  259. restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
  260. restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
  261. restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
  262. restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
  263. restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
  264. restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
  265. restore_gp_reg(31);
  266. #undef restore_gp_reg
  268. err |= __get_user(owned_fp, &sc->sc_ownedfp);
  269. err |= __get_user(current->used_math, &sc->sc_used_math);
  271. if (owned_fp) {
  272. err |= restore_fp_context(sc);
  273. goto out;
  274. }
  276. if (current == last_task_used_math) {
  277. /* Signal handler acquired FPU - give it back */
  278. last_task_used_math = NULL;
  279. regs->cp0_status &= ~ST0_CU1;
  280. }
  281. if (current->used_math) {
  282. /* Undo possible contamination of thread state */
  283. err |= restore_thread_fp_context(sc);
  284. }
  286. out:
  287. return err;
  288. }
  290. struct sigframe {
  291. u32 sf_ass[4]; /* argument save space for o32 */
  292. u32 sf_code[2]; /* signal trampoline */
  293. struct sigcontext sf_sc;
  294. sigset_t sf_mask;
  295. };
  297. struct rt_sigframe {
  298. u32 rs_ass[4]; /* argument save space for o32 */
  299. u32 rs_code[2]; /* signal trampoline */
  300. struct siginfo rs_info;
  301. struct ucontext rs_uc;
  302. };
  304. asmlinkage void sys_sigreturn(struct pt_regs regs)
  305. {
  306. struct sigframe *frame;
  307. sigset_t blocked;
  309. frame = (struct sigframe *) regs.regs[29];
  310. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  311. goto badframe;
  312. if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
  313. goto badframe;
  315. sigdelsetmask(&blocked, ~_BLOCKABLE);
  316. spin_lock_irq(&current->sigmask_lock);
  317. current->blocked = blocked;
  318. recalc_sigpending(current);
  319. spin_unlock_irq(&current->sigmask_lock);
  321. if (restore_sigcontext(&regs, &frame->sf_sc))
  322. goto badframe;
  324. /*
  325.  * Don't let your children do this ...
  326.  */
  327. if (current->ptrace & PT_TRACESYS)
  328. syscall_trace();
  329. __asm__ __volatile__(
  330. "movet$29, %0nt"
  331. "jtret_from_sys_call"
  332. :/* no outputs */
  333. :"r" (&regs));
  334. /* Unreached */
  336. badframe:
  337. force_sig(SIGSEGV, current);
  338. }
  340. asmlinkage void sys_rt_sigreturn(struct pt_regs regs)
  341. {
  342. struct rt_sigframe *frame;
  343. sigset_t set;
  344. stack_t st;
  346. frame = (struct rt_sigframe *) regs.regs[29];
  347. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  348. goto badframe;
  349. if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
  350. goto badframe;
  352. sigdelsetmask(&set, ~_BLOCKABLE);
  353. spin_lock_irq(&current->sigmask_lock);
  354. current->blocked = set;
  355. recalc_sigpending(current);
  356. spin_unlock_irq(&current->sigmask_lock);
  358. if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
  359. goto badframe;
  361. if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
  362. goto badframe;
  363. /* It is more difficult to avoid calling this function than to
  364.    call it and ignore errors.  */
  365. do_sigaltstack(&st, NULL, regs.regs[29]);
  367. /*
  368.  * Don't let your children do this ...
  369.  */
  370. __asm__ __volatile__(
  371. "movet$29, %0nt"
  372. "jtret_from_sys_call"
  373. :/* no outputs */
  374. :"r" (&regs));
  375. /* Unreached */
  377. badframe:
  378. force_sig(SIGSEGV, current);
  379. }
  381. static int inline setup_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
  382. {
  383. int owned_fp;
  384. int err = 0;
  385. u64 reg;
  387. reg = regs->cp0_epc; err |= __put_user(reg, &sc->sc_pc);
  388. err |= __put_user(regs->cp0_status, &sc->sc_status);
  390. #define save_gp_reg(i) {
  391. reg = regs->regs[i];
  392. err |= __put_user(reg, &sc->sc_regs[i]);
  393. } while(0)
  394. reg = 0; err |= __put_user(reg, &sc->sc_regs[0]);
  395. save_gp_reg(1); save_gp_reg(2);
  396. save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
  397. save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
  398. save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
  399. save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
  400. save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
  401. save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
  402. save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
  403. save_gp_reg(31);
  404. #undef save_gp_reg
  406. reg = regs->hi; err |= __put_user(reg, &sc->sc_mdhi);
  407. reg = regs->lo; err |= __put_user(reg, &sc->sc_mdlo);
  408. err |= __put_user(regs->cp0_cause, &sc->sc_cause);
  409. err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
  411. owned_fp = (current == last_task_used_math);
  412. err |= __put_user(owned_fp, &sc->sc_ownedfp);
  413. err |= __put_user(current->used_math, &sc->sc_used_math);
  415. if (!current->used_math)
  416. goto out;
  418. /* There exists FP thread state that may be trashed by signal */
  419. if (owned_fp) {
  420. /* fp is active.  Save context from FPU */
  421. err |= save_fp_context(sc);
  422. goto out;
  423. }
  425. /*
  426.  * Someone else has FPU.
  427.  * Copy Thread context into signal context
  428.  */
  429. err |= save_thread_fp_context(sc);
  431. out:
  432. return err;
  433. }
  435. /*
  436.  * Determine which stack to use..
  437.  */
  438. static inline void * get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
  439. size_t frame_size)
  440. {
  441. unsigned long sp;
  443. /* Default to using normal stack */
  444. sp = regs->regs[29];
  446. /*
  447.    * FPU emulator may have it's own trampoline active just
  448.    * above the user stack, 16-bytes before the next lowest
  449.    * 16 byte boundary.  Try to avoid trashing it.
  450.    */
  451.   sp -= 32;
  453. /* This is the X/Open sanctioned signal stack switching.  */
  454. if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
  455.                 sp = current->sas_ss_sp + current->sas_ss_size;
  457. return (void *)((sp - frame_size) & ALMASK);
  458. }
  460. static void inline setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
  461. int signr, sigset_t *set)
  462. {
  463. struct sigframe *frame;
  464. int err = 0;
  466. frame = get_sigframe(ka, regs, sizeof(*frame));
  467. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  468. goto give_sigsegv;
  470. /* Set up to return from userspace.  If provided, use a stub already
  471.    in userspace.  */
  472. if (ka->sa.sa_flags & SA_RESTORER)
  473. regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
  474. else {
  475. /*
  476.  * Set up the return code ...
  477.  *
  478.  *         li      v0, __NR_sigreturn
  479.  *         syscall
  480.  */
  481. err |= __put_user(0x24020000 + __NR_sigreturn,
  482.                   frame->sf_code + 0);
  483. err |= __put_user(0x0000000c                 ,
  484.                   frame->sf_code + 1);
  485. flush_cache_sigtramp((unsigned long) frame->sf_code);
  486. }
  488. err |= setup_sigcontext(regs, &frame->sf_sc);
  489. err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
  490. if (err)
  491. goto give_sigsegv;
  493. /*
  494.  * Arguments to signal handler:
  495.  *
  496.  *   a0 = signal number
  497.  *   a1 = 0 (should be cause)
  498.  *   a2 = pointer to struct sigcontext
  499.  *
  500.  * $25 and c0_epc point to the signal handler, $29 points to the
  501.  * struct sigframe.
  502.  */
  503. regs->regs[ 4] = signr;
  504. regs->regs[ 5] = 0;
  505. regs->regs[ 6] = (unsigned long) &frame->sf_sc;
  506. regs->regs[29] = (unsigned long) frame;
  507. regs->regs[31] = (unsigned long) frame->sf_code;
  508. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  510. #if DEBUG_SIG
  511. printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%pn",
  512.        current->comm, current->pid,
  513.        frame, regs->cp0_epc, frame->sf_code);
  514. #endif
  515.         return;
  517. give_sigsegv:
  518. if (signr == SIGSEGV)
  519. ka->sa.sa_handler = SIG_DFL;
  520. force_sig(SIGSEGV, current);
  521. }
  523. static void inline setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
  524. int signr, sigset_t *set, siginfo_t *info)
  525. {
  526. struct rt_sigframe *frame;
  527. int err = 0;
  529. frame = get_sigframe(ka, regs, sizeof(*frame));
  530. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  531. goto give_sigsegv;
  533. /* Set up to return from userspace.  If provided, use a stub already
  534.    in userspace.  */
  535. if (ka->sa.sa_flags & SA_RESTORER)
  536. regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
  537. else {
  538. /*
  539.  * Set up the return code ...
  540.  *
  541.  *         li      v0, __NR_rt_sigreturn
  542.  *         syscall
  543.  */
  544. err |= __put_user(0x24020000 + __NR_rt_sigreturn,
  545.                   frame->rs_code + 0);
  546. err |= __put_user(0x0000000c                 ,
  547.                   frame->rs_code + 1);
  548. flush_cache_sigtramp((unsigned long) frame->rs_code);
  549. }
  551. /* Create siginfo.  */
  552. err |= copy_siginfo_to_user(&frame->rs_info, info);
  554. /* Create the ucontext.  */
  555. err |= __put_user(0, &frame->rs_uc.uc_flags);
  556. err |= __put_user(0, &frame->rs_uc.uc_link);
  557. err |= __put_user((void *)current->sas_ss_sp,
  558.                   &frame->rs_uc.uc_stack.ss_sp);
  559. err |= __put_user(sas_ss_flags(regs->regs[29]),
  560.                   &frame->rs_uc.uc_stack.ss_flags);
  561. err |= __put_user(current->sas_ss_size,
  562.                   &frame->rs_uc.uc_stack.ss_size);
  563. err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
  564. err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
  566. if (err)
  567. goto give_sigsegv;
  569. /*
  570.  * Arguments to signal handler:
  571.  *
  572.  *   a0 = signal number
  573.  *   a1 = 0 (should be cause)
  574.  *   a2 = pointer to ucontext
  575.  *
  576.  * $25 and c0_epc point to the signal handler, $29 points to
  577.  * the struct rt_sigframe.
  578.  */
  579. regs->regs[ 4] = signr;
  580. regs->regs[ 5] = (unsigned long) &frame->rs_info;
  581. regs->regs[ 6] = (unsigned long) &frame->rs_uc;
  582. regs->regs[29] = (unsigned long) frame;
  583. regs->regs[31] = (unsigned long) frame->rs_code;
  584. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  586. #if DEBUG_SIG
  587. printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%pn",
  588.        current->comm, current->pid,
  589.        frame, regs->cp0_epc, frame->rs_code);
  590. #endif
  591. return;
  593. give_sigsegv:
  594. if (signr == SIGSEGV)
  595. ka->sa.sa_handler = SIG_DFL;
  596. force_sig(SIGSEGV, current);
  597. }
  599. static inline void handle_signal(unsigned long sig, struct k_sigaction *ka,
  600. siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  601. {
  602. if (ka->sa.sa_flags & SA_SIGINFO)
  603. setup_rt_frame(ka, regs, sig, oldset, info);
  604. else
  605. setup_frame(ka, regs, sig, oldset);
  607. if (ka->sa.sa_flags & SA_ONESHOT)
  608. ka->sa.sa_handler = SIG_DFL;
  609. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  610. spin_lock_irq(&current->sigmask_lock);
  611. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  612. sigaddset(&current->blocked,sig);
  613. recalc_sigpending(current);
  614. spin_unlock_irq(&current->sigmask_lock);
  615. }
  616. }
  618. static inline void syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
  619. {
  620. switch(regs->regs[0]) {
  621. case ERESTARTNOHAND:
  622. regs->regs[2] = EINTR;
  623. break;
  624. case ERESTARTSYS:
  625. if(!(ka->sa.sa_flags & SA_RESTART)) {
  626. regs->regs[2] = EINTR;
  627. break;
  628. }
  629. /* fallthrough */
  630. case ERESTARTNOINTR: /* Userland will reload $v0.  */
  631. regs->regs[7] = regs->regs[26];
  632. regs->cp0_epc -= 8;
  633. }
  635. regs->regs[0] = 0; /* Don't deal with this again.  */
  636. }
  638. extern int do_irix_signal(sigset_t *oldset, struct pt_regs *regs);
  640. asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
  641. {
  642. struct k_sigaction *ka;
  643. siginfo_t info;
  645. #ifdef CONFIG_BINFMT_IRIX
  646. if (current->personality != PER_LINUX)
  647. return do_irix_signal(oldset, regs);
  648. #endif
  650. if (!oldset)
  651. oldset = &current->blocked;
  653. for (;;) {
  654. unsigned long signr;
  656. spin_lock_irq(&current->sigmask_lock);
  657. signr = dequeue_signal(&current->blocked, &info);
  658. spin_unlock_irq(&current->sigmask_lock);
  660. if (!signr)
  661. break;
  663. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  664. /* Let the debugger run.  */
  665. current->exit_code = signr;
  666. current->state = TASK_STOPPED;
  667. notify_parent(current, SIGCHLD);
  668. schedule();
  670. /* We're back.  Did the debugger cancel the sig?  */
  671. if (!(signr = current->exit_code))
  672. continue;
  673. current->exit_code = 0;
  675. /* The debugger continued.  Ignore SIGSTOP.  */
  676. if (signr == SIGSTOP)
  677. continue;
  679. /* Update the siginfo structure.  Is this good?  */
  680. if (signr != info.si_signo) {
  681. info.si_signo = signr;
  682. info.si_errno = 0;
  683. info.si_code = SI_USER;
  684. info.si_pid = current->p_pptr->pid;
  685. info.si_uid = current->p_pptr->uid;
  686. }
  688. /* If the (new) signal is now blocked, requeue it.  */
  689. if (sigismember(&current->blocked, signr)) {
  690. send_sig_info(signr, &info, current);
  691. continue;
  692. }
  693. }
  695. ka = &current->sig->action[signr-1];
  696. if (ka->sa.sa_handler == SIG_IGN) {
  697. if (signr != SIGCHLD)
  698. continue;
  699. /* Check for SIGCHLD: it's special.  */
  700. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  701. /* nothing */;
  702. continue;
  703. }
  705. if (ka->sa.sa_handler == SIG_DFL) {
  706. int exit_code = signr;
  708. /* Init gets no signals it doesn't want.  */
  709. if (current->pid == 1)
  710. continue;
  712. switch (signr) {
  713. case SIGCONT: case SIGCHLD: case SIGWINCH: case SIGURG:
  714. continue;
  716. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  717. if (is_orphaned_pgrp(current->pgrp))
  718. continue;
  719. /* FALLTHRU */
  721. case SIGSTOP:
  722. current->state = TASK_STOPPED;
  723. current->exit_code = signr;
  724. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  725. notify_parent(current, SIGCHLD);
  726. schedule();
  727. continue;
  729. case SIGQUIT: case SIGILL: case SIGTRAP:
  730. case SIGABRT: case SIGFPE: case SIGSEGV:
  731. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  732. if (do_coredump(signr, regs))
  733. exit_code |= 0x80;
  734. /* FALLTHRU */
  736. default:
  737. sig_exit(signr, exit_code, &info);
  738. /* NOTREACHED */
  739. }
  740. }
  742. if (regs->regs[0])
  743. syscall_restart(regs, ka);
  744. /* Whee!  Actually deliver the signal.  */
  745. handle_signal(signr, ka, &info, oldset, regs);
  746. return 1;
  747. }
  749. /*
  750.  * Who's code doesn't conform to the restartable syscall convention
  751.  * dies here!!!  The li instruction, a single machine instruction,
  752.  * must directly be followed by the syscall instruction.
  753.  */
  754. if (regs->regs[0]) {
  755. if (regs->regs[2] == ERESTARTNOHAND ||
  756.     regs->regs[2] == ERESTARTSYS ||
  757.     regs->regs[2] == ERESTARTNOINTR) {
  758. regs->regs[7] = regs->regs[26];
  759. regs->cp0_epc -= 8;
  760. }
  761. }
  762. return 0;
  763. }