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

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

Linux/Unix编程

开发平台：

Unix_Linux

signal.c：源码内容
  1. /* $Id: signal.c,v 1.21 2000/03/11 14:06:21 gniibe Exp $
  2.  *
  3.  *  linux/arch/sh/kernel/signal.c
  4.  *
  5.  *  Copyright (C) 1991, 1992  Linus Torvalds
  6.  *
  7.  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  8.  *
  9.  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
  10.  *
  11.  */
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/smp.h>
  16. #include <linux/smp_lock.h>
  17. #include <linux/kernel.h>
  18. #include <linux/signal.h>
  19. #include <linux/errno.h>
  20. #include <linux/wait.h>
  21. #include <linux/ptrace.h>
  22. #include <linux/unistd.h>
  23. #include <linux/stddef.h>
  24. #include <linux/personality.h>
  25. #include <asm/ucontext.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/pgtable.h>
  29. #define DEBUG_SIG 0
  31. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  33. asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  35. int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  36. {
  37. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  38. return -EFAULT;
  39. if (from->si_code < 0)
  40. return __copy_to_user(to, from, sizeof(siginfo_t));
  41. else {
  42. int err;
  44. /* If you change siginfo_t structure, please be sure
  45.    this code is fixed accordingly.
  46.    It should never copy any pad contained in the structure
  47.    to avoid security leaks, but must copy the generic
  48.    3 ints plus the relevant union member.  */
  49. err = __put_user(from->si_signo, &to->si_signo);
  50. err |= __put_user(from->si_errno, &to->si_errno);
  51. err |= __put_user((short)from->si_code, &to->si_code);
  52. /* First 32bits of unions are always present.  */
  53. err |= __put_user(from->si_pid, &to->si_pid);
  54. switch (from->si_code >> 16) {
  55. case __SI_FAULT >> 16:
  56. break;
  57. case __SI_CHLD >> 16:
  58. err |= __put_user(from->si_utime, &to->si_utime);
  59. err |= __put_user(from->si_stime, &to->si_stime);
  60. err |= __put_user(from->si_status, &to->si_status);
  61. default:
  62. err |= __put_user(from->si_uid, &to->si_uid);
  63. break;
  64. /* case __SI_RT: This is not generated by the kernel as of now.  */
  65. }
  66. return err;
  67. }
  68. }
  70. /*
  71.  * Atomically swap in the new signal mask, and wait for a signal.
  72.  */
  73. asmlinkage int
  74. sys_sigsuspend(old_sigset_t mask,
  75.        unsigned long r5, unsigned long r6, unsigned long r7,
  76.        struct pt_regs regs)
  77. {
  78. sigset_t saveset;
  80. mask &= _BLOCKABLE;
  81. spin_lock_irq(&current->sigmask_lock);
  82. saveset = current->blocked;
  83. siginitset(&current->blocked, mask);
  84. recalc_sigpending(current);
  85. spin_unlock_irq(&current->sigmask_lock);
  87. regs.regs[0] = -EINTR;
  88. while (1) {
  89. current->state = TASK_INTERRUPTIBLE;
  90. schedule();
  91. if (do_signal(&regs, &saveset))
  92. return -EINTR;
  93. }
  94. }
  96. asmlinkage int
  97. sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
  98.   unsigned long r6, unsigned long r7,
  99.   struct pt_regs regs)
  100. {
  101. sigset_t saveset, newset;
  103. /* XXX: Don't preclude handling different sized sigset_t's.  */
  104. if (sigsetsize != sizeof(sigset_t))
  105. return -EINVAL;
  107. if (copy_from_user(&newset, unewset, sizeof(newset)))
  108. return -EFAULT;
  109. sigdelsetmask(&newset, ~_BLOCKABLE);
  110. spin_lock_irq(&current->sigmask_lock);
  111. saveset = current->blocked;
  112. current->blocked = newset;
  113. recalc_sigpending(current);
  114. spin_unlock_irq(&current->sigmask_lock);
  116. regs.regs[0] = -EINTR;
  117. while (1) {
  118. current->state = TASK_INTERRUPTIBLE;
  119. schedule();
  120. if (do_signal(&regs, &saveset))
  121. return -EINTR;
  122. }
  123. }
  125. asmlinkage int 
  126. sys_sigaction(int sig, const struct old_sigaction *act,
  127.       struct old_sigaction *oact)
  128. {
  129. struct k_sigaction new_ka, old_ka;
  130. int ret;
  132. if (act) {
  133. old_sigset_t mask;
  134. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  135.     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  136.     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
  137. return -EFAULT;
  138. __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  139. __get_user(mask, &act->sa_mask);
  140. siginitset(&new_ka.sa.sa_mask, mask);
  141. }
  143. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  145. if (!ret && oact) {
  146. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  147.     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  148.     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
  149. return -EFAULT;
  150. __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  151. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  152. }
  154. return ret;
  155. }
  157. asmlinkage int
  158. sys_sigaltstack(const stack_t *uss, stack_t *uoss,
  159. unsigned long r6, unsigned long r7,
  160. struct pt_regs regs)
  161. {
  162. return do_sigaltstack(uss, uoss, regs.regs[15]);
  163. }
  166. /*
  167.  * Do a signal return; undo the signal stack.
  168.  */
  170. struct sigframe
  171. {
  172. struct sigcontext sc;
  173. unsigned long extramask[_NSIG_WORDS-1];
  174. char retcode[4];
  175. };
  177. struct rt_sigframe
  178. {
  179. struct siginfo *pinfo;
  180. void *puc;
  181. struct siginfo info;
  182. struct ucontext uc;
  183. char retcode[4];
  184. };
  186. #if defined(__SH4__)
  187. static inline int restore_sigcontext_fpu(struct sigcontext *sc)
  188. {
  189. struct task_struct *tsk = current;
  191. tsk->used_math = 1;
  192. return __copy_from_user(&tsk->thread.fpu.hard, &sc->sc_fpregs[0],
  193. sizeof(long)*(16*2+2));
  194. }
  196. static inline int save_sigcontext_fpu(struct sigcontext *sc)
  197. {
  198. struct task_struct *tsk = current;
  199. unsigned long flags;
  200. int val;
  202. if (!tsk->used_math) {
  203.   val = 0;
  204. __copy_to_user(&sc->sc_ownedfp, &val, sizeof(int));
  205. return 0;
  206. }
  208. val = 1;
  209. __copy_to_user(&sc->sc_ownedfp, &val, sizeof(int));
  211. /* This will cause a "finit" to be triggered by the next
  212.    attempted FPU operation by the 'current' process.
  213.    */
  214. tsk->used_math = 0;
  216. save_and_cli(flags);
  217. unlazy_fpu(tsk);
  218. restore_flags(flags);
  220. return __copy_to_user(&sc->sc_fpregs[0], &tsk->thread.fpu.hard,
  221.       sizeof(long)*(16*2+2));
  222. }
  223. #endif
  225. static int
  226. restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc, int *r0_p)
  227. {
  228. unsigned int err = 0;
  230. #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
  231. COPY(regs[1]);
  232. COPY(regs[2]); COPY(regs[3]);
  233. COPY(regs[4]); COPY(regs[5]);
  234. COPY(regs[6]); COPY(regs[7]);
  235. COPY(regs[8]); COPY(regs[9]);
  236. COPY(regs[10]); COPY(regs[11]);
  237. COPY(regs[12]); COPY(regs[13]);
  238. COPY(regs[14]); COPY(regs[15]);
  239. COPY(gbr); COPY(mach);
  240. COPY(macl); COPY(pr);
  241. COPY(sr); COPY(pc);
  242. #undef COPY
  244. #if defined(__SH4__)
  245. {
  246. int owned_fp;
  247. struct task_struct *tsk = current;
  249. regs->sr |= SR_FD; /* Release FPU */
  250. clear_fpu(tsk);
  251. current->used_math = 0;
  252. __get_user (owned_fp, &sc->sc_ownedfp);
  253. if (owned_fp)
  254. err |= restore_sigcontext_fpu(sc);
  255. }
  256. #endif
  258. regs->syscall_nr = -1; /* disable syscall checks */
  259. err |= __get_user(*r0_p, &sc->sc_regs[0]);
  260. return err;
  261. }
  263. asmlinkage int sys_sigreturn(unsigned long r4, unsigned long r5,
  264.      unsigned long r6, unsigned long r7,
  265.      struct pt_regs regs)
  266. {
  267. struct sigframe *frame = (struct sigframe *)regs.regs[15];
  268. sigset_t set;
  269. int r0;
  271. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  272. goto badframe;
  274. if (__get_user(set.sig[0], &frame->sc.oldmask)
  275.     || (_NSIG_WORDS > 1
  276. && __copy_from_user(&set.sig[1], &frame->extramask,
  277.     sizeof(frame->extramask))))
  278. goto badframe;
  280. sigdelsetmask(&set, ~_BLOCKABLE);
  282. spin_lock_irq(&current->sigmask_lock);
  283. current->blocked = set;
  284. recalc_sigpending(current);
  285. spin_unlock_irq(&current->sigmask_lock);
  287. if (restore_sigcontext(&regs, &frame->sc, &r0))
  288. goto badframe;
  289. return r0;
  291. badframe:
  292. force_sig(SIGSEGV, current);
  293. return 0;
  294. }
  296. asmlinkage int sys_rt_sigreturn(unsigned long r4, unsigned long r5,
  297. unsigned long r6, unsigned long r7,
  298. struct pt_regs regs)
  299. {
  300. struct rt_sigframe *frame = (struct rt_sigframe *)regs.regs[15];
  301. sigset_t set;
  302. stack_t st;
  303. int r0;
  305. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  306. goto badframe;
  308. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  309. goto badframe;
  311. sigdelsetmask(&set, ~_BLOCKABLE);
  312. spin_lock_irq(&current->sigmask_lock);
  313. current->blocked = set;
  314. recalc_sigpending(current);
  315. spin_unlock_irq(&current->sigmask_lock);
  317. if (restore_sigcontext(&regs, &frame->uc.uc_mcontext, &r0))
  318. goto badframe;
  320. if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
  321. goto badframe;
  322. /* It is more difficult to avoid calling this function than to
  323.    call it and ignore errors.  */
  324. do_sigaltstack(&st, NULL, regs.regs[15]);
  326. return r0;
  328. badframe:
  329. force_sig(SIGSEGV, current);
  330. return 0;
  331. }
  333. /*
  334.  * Set up a signal frame.
  335.  */
  337. static int
  338. setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
  339.  unsigned long mask)
  340. {
  341. int err = 0;
  343. #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
  344. COPY(regs[0]); COPY(regs[1]);
  345. COPY(regs[2]); COPY(regs[3]);
  346. COPY(regs[4]); COPY(regs[5]);
  347. COPY(regs[6]); COPY(regs[7]);
  348. COPY(regs[8]); COPY(regs[9]);
  349. COPY(regs[10]); COPY(regs[11]);
  350. COPY(regs[12]); COPY(regs[13]);
  351. COPY(regs[14]); COPY(regs[15]);
  352. COPY(gbr); COPY(mach);
  353. COPY(macl); COPY(pr);
  354. COPY(sr); COPY(pc);
  355. #undef COPY
  357. #if defined(__SH4__)
  358. err |= save_sigcontext_fpu(sc);
  359. #endif
  361. /* non-iBCS2 extensions.. */
  362. err |= __put_user(mask, &sc->oldmask);
  364. return err;
  365. }
  367. /*
  368.  * Determine which stack to use..
  369.  */
  370. static inline void *
  371. get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
  372. {
  373. if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
  374. sp = current->sas_ss_sp + current->sas_ss_size;
  376. return (void *)((sp - frame_size) & -8ul);
  377. }
  379. static void setup_frame(int sig, struct k_sigaction *ka,
  380. sigset_t *set, struct pt_regs *regs)
  381. {
  382. struct sigframe *frame;
  383. int err = 0;
  384. int signal;
  386. frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
  388. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  389. goto give_sigsegv;
  391. signal = current->exec_domain
  392. && current->exec_domain->signal_invmap
  393. && sig < 32
  394. ? current->exec_domain->signal_invmap[sig]
  395. : sig;
  397. err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
  399. if (_NSIG_WORDS > 1) {
  400. err |= __copy_to_user(frame->extramask, &set->sig[1],
  401.       sizeof(frame->extramask));
  402. }
  404. /* Set up to return from userspace.  If provided, use a stub
  405.    already in userspace.  */
  406. if (ka->sa.sa_flags & SA_RESTORER) {
  407. regs->pr = (unsigned long) ka->sa.sa_restorer;
  408. } else {
  409. /* This is : mov  #__NR_sigreturn,r3 ; trapa #0x10 */
  410. #ifdef __LITTLE_ENDIAN__
  411. unsigned long code = 0xc310e300 | (__NR_sigreturn);
  412. #else
  413. unsigned long code = 0xe300c310 | (__NR_sigreturn << 16);
  414. #endif
  416. regs->pr = (unsigned long) frame->retcode;
  417. err |= __put_user(code, (long *)(frame->retcode+0));
  418. }
  420. if (err)
  421. goto give_sigsegv;
  423. /* Set up registers for signal handler */
  424. regs->regs[15] = (unsigned long) frame;
  425. regs->regs[4] = signal; /* Arg for signal handler */
  426. regs->pc = (unsigned long) ka->sa.sa_handler;
  428. set_fs(USER_DS);
  430. #if DEBUG_SIG
  431. printk("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lxn",
  432. current->comm, current->pid, frame, regs->pc, regs->pr);
  433. #endif
  435. flush_cache_sigtramp(regs->pr);
  436. return;
  438. give_sigsegv:
  439. if (sig == SIGSEGV)
  440. ka->sa.sa_handler = SIG_DFL;
  441. force_sig(SIGSEGV, current);
  442. }
  444. static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
  445.    sigset_t *set, struct pt_regs *regs)
  446. {
  447. struct rt_sigframe *frame;
  448. int err = 0;
  449. int signal;
  451. frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
  453. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  454. goto give_sigsegv;
  456. signal = current->exec_domain
  457. && current->exec_domain->signal_invmap
  458. && sig < 32
  459. ? current->exec_domain->signal_invmap[sig]
  460. : sig;
  462. err |= __put_user(&frame->info, &frame->pinfo);
  463. err |= __put_user(&frame->uc, &frame->puc);
  464. err |= copy_siginfo_to_user(&frame->info, info);
  466. /* Create the ucontext.  */
  467. err |= __put_user(0, &frame->uc.uc_flags);
  468. err |= __put_user(0, &frame->uc.uc_link);
  469. err |= __put_user((void *)current->sas_ss_sp,
  470.   &frame->uc.uc_stack.ss_sp);
  471. err |= __put_user(sas_ss_flags(regs->regs[15]),
  472.   &frame->uc.uc_stack.ss_flags);
  473. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  474. err |= setup_sigcontext(&frame->uc.uc_mcontext,
  475.         regs, set->sig[0]);
  476. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  478. /* Set up to return from userspace.  If provided, use a stub
  479.    already in userspace.  */
  480. if (ka->sa.sa_flags & SA_RESTORER) {
  481. regs->pr = (unsigned long) ka->sa.sa_restorer;
  482. } else {
  483. /* This is : mov  #__NR_rt_sigreturn,r3 ; trapa #0x10 */
  484. #ifdef __LITTLE_ENDIAN__
  485. unsigned long code = 0xc310e300 | (__NR_rt_sigreturn);
  486. #else
  487. unsigned long code = 0xe300c310 | (__NR_rt_sigreturn << 16);
  488. #endif
  490. regs->pr = (unsigned long) frame->retcode;
  491. err |= __put_user(code, (long *)(frame->retcode+0));
  492. }
  494. if (err)
  495. goto give_sigsegv;
  497. /* Set up registers for signal handler */
  498. regs->regs[15] = (unsigned long) frame;
  499. regs->regs[4] = signal; /* Arg for signal handler */
  500. regs->pc = (unsigned long) ka->sa.sa_handler;
  502. set_fs(USER_DS);
  504. #if DEBUG_SIG
  505. printk("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lxn",
  506. current->comm, current->pid, frame, regs->pc, regs->pr);
  507. #endif
  509. flush_cache_sigtramp(regs->pr);
  510. return;
  512. give_sigsegv:
  513. if (sig == SIGSEGV)
  514. ka->sa.sa_handler = SIG_DFL;
  515. force_sig(SIGSEGV, current);
  516. }
  518. /*
  519.  * OK, we're invoking a handler
  520.  */
  522. static void
  523. handle_signal(unsigned long sig, struct k_sigaction *ka,
  524.       siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  525. {
  526. /* Are we from a system call? */
  527. if (regs->syscall_nr >= 0) {
  528. /* If so, check system call restarting.. */
  529. switch (regs->regs[0]) {
  530. case -ERESTARTNOHAND:
  531. regs->regs[0] = -EINTR;
  532. break;
  534. case -ERESTARTSYS:
  535. if (!(ka->sa.sa_flags & SA_RESTART)) {
  536. regs->regs[0] = -EINTR;
  537. break;
  538. }
  539. /* fallthrough */
  540. case -ERESTARTNOINTR:
  541. regs->regs[0] = regs->syscall_nr;
  542. regs->pc -= 2;
  543. }
  544. }
  546. /* Set up the stack frame */
  547. if (ka->sa.sa_flags & SA_SIGINFO)
  548. setup_rt_frame(sig, ka, info, oldset, regs);
  549. else
  550. setup_frame(sig, ka, oldset, regs);
  552. if (ka->sa.sa_flags & SA_ONESHOT)
  553. ka->sa.sa_handler = SIG_DFL;
  555. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  556. spin_lock_irq(&current->sigmask_lock);
  557. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  558. sigaddset(&current->blocked,sig);
  559. recalc_sigpending(current);
  560. spin_unlock_irq(&current->sigmask_lock);
  561. }
  562. }
  564. /*
  565.  * Note that 'init' is a special process: it doesn't get signals it doesn't
  566.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  567.  * mistake.
  568.  *
  569.  * Note that we go through the signals twice: once to check the signals that
  570.  * the kernel can handle, and then we build all the user-level signal handling
  571.  * stack-frames in one go after that.
  572.  */
  573. int do_signal(struct pt_regs *regs, sigset_t *oldset)
  574. {
  575. siginfo_t info;
  576. struct k_sigaction *ka;
  578. /*
  579.  * We want the common case to go fast, which
  580.  * is why we may in certain cases get here from
  581.  * kernel mode. Just return without doing anything
  582.  * if so.
  583.  */
  584. if (!user_mode(regs))
  585. return 1;
  587. if (!oldset)
  588. oldset = &current->blocked;
  590. for (;;) {
  591. unsigned long signr;
  593. spin_lock_irq(&current->sigmask_lock);
  594. signr = dequeue_signal(&current->blocked, &info);
  595. spin_unlock_irq(&current->sigmask_lock);
  597. if (!signr)
  598. break;
  600. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  601. /* Let the debugger run.  */
  602. current->exit_code = signr;
  603. current->state = TASK_STOPPED;
  604. notify_parent(current, SIGCHLD);
  605. schedule();
  607. /* We're back.  Did the debugger cancel the sig?  */
  608. if (!(signr = current->exit_code))
  609. continue;
  610. current->exit_code = 0;
  612. /* The debugger continued.  Ignore SIGSTOP.  */
  613. if (signr == SIGSTOP)
  614. continue;
  616. /* Update the siginfo structure.  Is this good?  */
  617. if (signr != info.si_signo) {
  618. info.si_signo = signr;
  619. info.si_errno = 0;
  620. info.si_code = SI_USER;
  621. info.si_pid = current->p_pptr->pid;
  622. info.si_uid = current->p_pptr->uid;
  623. }
  625. /* If the (new) signal is now blocked, requeue it.  */
  626. if (sigismember(&current->blocked, signr)) {
  627. send_sig_info(signr, &info, current);
  628. continue;
  629. }
  630. }
  632. ka = &current->sig->action[signr-1];
  633. if (ka->sa.sa_handler == SIG_IGN) {
  634. if (signr != SIGCHLD)
  635. continue;
  636. /* Check for SIGCHLD: it's special.  */
  637. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  638. /* nothing */;
  639. continue;
  640. }
  642. if (ka->sa.sa_handler == SIG_DFL) {
  643. int exit_code = signr;
  645. /* Init gets no signals it doesn't want.  */
  646. if (current->pid == 1)
  647. continue;
  649. switch (signr) {
  650. case SIGCONT: case SIGCHLD: case SIGWINCH:
  651. continue;
  653. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  654. if (is_orphaned_pgrp(current->pgrp))
  655. continue;
  656. /* FALLTHRU */
  658. case SIGSTOP:
  659. current->state = TASK_STOPPED;
  660. current->exit_code = signr;
  661. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  662. notify_parent(current, SIGCHLD);
  663. schedule();
  664. continue;
  666. case SIGQUIT: case SIGILL: case SIGTRAP:
  667. case SIGABRT: case SIGFPE: case SIGSEGV:
  668. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  669. if (do_coredump(signr, regs))
  670. exit_code |= 0x80;
  671. /* FALLTHRU */
  673. default:
  674. sig_exit(signr, exit_code, &info);
  675. /* NOTREACHED */
  676. }
  677. }
  679. /* Whee!  Actually deliver the signal.  */
  680. handle_signal(signr, ka, &info, oldset, regs);
  681. return 1;
  682. }
  684. /* Did we come from a system call? */
  685. if (regs->syscall_nr >= 0) {
  686. /* Restart the system call - no handlers present */
  687. if (regs->regs[0] == -ERESTARTNOHAND ||
  688.     regs->regs[0] == -ERESTARTSYS ||
  689.     regs->regs[0] == -ERESTARTNOINTR) {
  690. regs->regs[0] = regs->syscall_nr;
  691. regs->pc -= 2;
  692. }
  693. }
  694. return 0;
  695. }