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

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

Linux/Unix编程

开发平台：

Unix_Linux

signal32.c：源码内容
  1. /*
  2.  *  arch/s390/kernel/signal32.c
  3.  *
  4.  *  S390 version
  5.  *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6.  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  7.  *               Gerhard Tonn (ton@de.ibm.com)                  
  8.  *
  9.  *  Copyright (C) 1991, 1992  Linus Torvalds
  10.  *
  11.  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  12.  */
  14. #include <linux/config.h>
  15. #include <linux/sched.h>
  16. #include <linux/mm.h>
  17. #include <linux/smp.h>
  18. #include <linux/smp_lock.h>
  19. #include <linux/kernel.h>
  20. #include <linux/signal.h>
  21. #include <linux/errno.h>
  22. #include <linux/wait.h>
  23. #include <linux/ptrace.h>
  24. #include <linux/unistd.h>
  25. #include <linux/stddef.h>
  26. #include <linux/personality.h>
  27. #include <asm/ucontext.h>
  28. #include <asm/uaccess.h>
  29. #include "linux32.h"
  31. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  33. #define _USER_PSW_MASK32 0x0705C00080000000
  35. typedef struct 
  36. {
  37. __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  38. struct sigcontext32 sc;
  39. _sigregs32 sregs;
  40. __u8 retcode[S390_SYSCALL_SIZE];
  41. } sigframe32;
  43. typedef struct 
  44. {
  45. __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  46. __u8 retcode[S390_SYSCALL_SIZE];
  47. struct siginfo32 info;
  48. struct ucontext32 uc;
  49. } rt_sigframe32;
  51. asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
  53. int do_signal32(struct pt_regs *regs, sigset_t *oldset);
  55. int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
  56. {
  57. int err;
  59. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
  60. return -EFAULT;
  62. /* If you change siginfo_t structure, please be sure
  63.    this code is fixed accordingly.
  64.    It should never copy any pad contained in the structure
  65.    to avoid security leaks, but must copy the generic
  66.    3 ints plus the relevant union member.  
  67.    This routine must convert siginfo from 64bit to 32bit as well
  68.    at the same time.  */
  69. err = __put_user(from->si_signo, &to->si_signo);
  70. err |= __put_user(from->si_errno, &to->si_errno);
  71. err |= __put_user((short)from->si_code, &to->si_code);
  72. if (from->si_code < 0)
  73. err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  74. else {
  75. switch (from->si_code >> 16) {
  76. case __SI_KILL >> 16:
  77. err |= __put_user(from->si_pid, &to->si_pid);
  78. err |= __put_user(from->si_uid, &to->si_uid);
  79. break;
  80. case __SI_CHLD >> 16:
  81. err |= __put_user(from->si_pid, &to->si_pid);
  82. err |= __put_user(from->si_uid, &to->si_uid);
  83. err |= __put_user(from->si_utime, &to->si_utime);
  84. err |= __put_user(from->si_stime, &to->si_stime);
  85. err |= __put_user(from->si_status, &to->si_status);
  86. break;
  87. case __SI_FAULT >> 16:
  88. err |= __put_user(from->si_addr, &to->si_addr);
  89. break;
  90. case __SI_POLL >> 16:
  91. case __SI_TIMER >> 16:
  92. err |= __put_user(from->si_band, &to->si_band);
  93. err |= __put_user(from->si_fd, &to->si_fd);
  94. break;
  95. default:
  96. break;
  97. /* case __SI_RT: This is not generated by the kernel as of now.  */
  98. }
  99. }
  100. return err;
  101. }
  103. /*
  104.  * Atomically swap in the new signal mask, and wait for a signal.
  105.  */
  106. asmlinkage int
  107. sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
  108. {
  109. sigset_t saveset;
  111. mask &= _BLOCKABLE;
  112. spin_lock_irq(&current->sigmask_lock);
  113. saveset = current->blocked;
  114. siginitset(&current->blocked, mask);
  115. recalc_sigpending(current);
  116. spin_unlock_irq(&current->sigmask_lock);
  117. regs->gprs[2] = -EINTR;
  119. while (1) {
  120. set_current_state(TASK_INTERRUPTIBLE);
  121. schedule();
  122. if (do_signal32(regs, &saveset))
  123. return -EINTR;
  124. }
  125. }
  127. asmlinkage int
  128. sys32_rt_sigsuspend(struct pt_regs * regs,sigset_t32 *unewset, size_t sigsetsize)
  129. {
  130. sigset_t saveset, newset;
  131. sigset_t32 set32;
  133. /* XXX: Don't preclude handling different sized sigset_t's.  */
  134. if (sigsetsize != sizeof(sigset_t))
  135. return -EINVAL;
  137. if (copy_from_user(&set32, unewset, sizeof(set32)))
  138. return -EFAULT;
  139. switch (_NSIG_WORDS) {
  140. case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
  141. case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
  142. case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
  143. case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
  144. }
  145.         sigdelsetmask(&newset, ~_BLOCKABLE);
  147.         spin_lock_irq(&current->sigmask_lock);
  148.         saveset = current->blocked;
  149.         current->blocked = newset;
  150.         recalc_sigpending(current);
  151.         spin_unlock_irq(&current->sigmask_lock);
  152.         regs->gprs[2] = -EINTR;
  154.         while (1) {
  155.                 set_current_state(TASK_INTERRUPTIBLE);
  156.                 schedule();
  157.                 if (do_signal32(regs, &saveset))
  158.                         return -EINTR;
  159.         }
  160. }                                                         
  162. asmlinkage int
  163. sys32_sigaction(int sig, const struct old_sigaction32 *act,
  164.  struct old_sigaction32 *oact)
  165. {
  166.         struct k_sigaction new_ka, old_ka;
  167.         int ret;
  169.         if (act) {
  170. old_sigset_t32 mask;
  171. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  172.     __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||
  173.     __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))
  174. return -EFAULT;
  175. __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  176. __get_user(mask, &act->sa_mask);
  177. siginitset(&new_ka.sa.sa_mask, mask);
  178.         }
  180.         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  182. if (!ret && oact) {
  183. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  184.     __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||
  185.     __put_user((unsigned long)old_ka.sa.sa_restorer, &oact->sa_restorer))
  186. return -EFAULT;
  187. __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  188. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  189.         }
  191. return ret;
  192. }
  194. int
  195. do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
  197. asmlinkage long 
  198. sys32_rt_sigaction(int sig, const struct sigaction32 *act,
  199.    struct sigaction32 *oact,  size_t sigsetsize)
  200. {
  201. struct k_sigaction new_ka, old_ka;
  202. int ret;
  203. sigset_t32 set32;
  205. /* XXX: Don't preclude handling different sized sigset_t's.  */
  206. if (sigsetsize != sizeof(sigset_t32))
  207. return -EINVAL;
  209. if (act) {
  210. ret = get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler);
  211. ret |= __copy_from_user(&set32, &act->sa_mask,
  212. sizeof(sigset_t32));
  213. switch (_NSIG_WORDS) {
  214. case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
  215. | (((long)set32.sig[7]) << 32);
  216. case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
  217. | (((long)set32.sig[5]) << 32);
  218. case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
  219. | (((long)set32.sig[3]) << 32);
  220. case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
  221. | (((long)set32.sig[1]) << 32);
  222. }
  223. ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  225. if (ret)
  226. return -EFAULT;
  227. }
  229. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  231. if (!ret && oact) {
  232. switch (_NSIG_WORDS) {
  233. case 4:
  234. set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
  235. set32.sig[6] = old_ka.sa.sa_mask.sig[3];
  236. case 3:
  237. set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
  238. set32.sig[4] = old_ka.sa.sa_mask.sig[2];
  239. case 2:
  240. set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
  241. set32.sig[2] = old_ka.sa.sa_mask.sig[1];
  242. case 1:
  243. set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
  244. set32.sig[0] = old_ka.sa.sa_mask.sig[0];
  245. }
  246. ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
  247. ret |= __copy_to_user(&oact->sa_mask, &set32,
  248.       sizeof(sigset_t32));
  249. ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  250. }
  252. return ret;
  253. }
  255. asmlinkage int
  256. sys32_sigaltstack(const stack_t32 *uss, stack_t32 *uoss, struct pt_regs *regs)
  257. {
  258. stack_t kss, koss;
  259. int ret, err = 0;
  260. mm_segment_t old_fs = get_fs();
  262. if (uss) {
  263. if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
  264. return -EFAULT;
  265. err |= __get_user(kss.ss_sp, &uss->ss_sp);
  266. err |= __get_user(kss.ss_size, &uss->ss_size);
  267. err |= __get_user(kss.ss_flags, &uss->ss_flags);
  268. if (err)
  269. return -EFAULT;
  270. }
  272. set_fs (KERNEL_DS);
  273. ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, regs->gprs[15]);
  274. set_fs (old_fs);
  276. if (!ret && uoss) {
  277. if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
  278. return -EFAULT;
  279. err |= __put_user(koss.ss_sp, &uoss->ss_sp);
  280. err |= __put_user(koss.ss_size, &uoss->ss_size);
  281. err |= __put_user(koss.ss_flags, &uoss->ss_flags);
  282. if (err)
  283. return -EFAULT;
  284. }
  285. return ret;
  286. }
  288. static int save_sigregs32(struct pt_regs *regs,_sigregs32 *sregs)
  289. {
  290. int err = 0;
  291. s390_fp_regs fpregs;
  292. int i;
  294. for(i=0; i<NUM_GPRS; i++) 
  295. err |= __put_user(regs->gprs[i], &sregs->regs.gprs[i]);  
  296. for(i=0; i<NUM_ACRS; i++)
  297. err |= __put_user(regs->acrs[i], &sregs->regs.acrs[i]);  
  298. err |= __copy_to_user(&sregs->regs.psw.mask, &regs->psw.mask, 4);
  299. err |= __copy_to_user(&sregs->regs.psw.addr, ((char*)&regs->psw.addr)+4, 4);
  300. if(!err)
  301. {
  302. save_fp_regs(&fpregs);
  303. __put_user(fpregs.fpc, &sregs->fpregs.fpc);
  304. for(i=0; i<NUM_FPRS; i++)
  305. err |= __put_user(fpregs.fprs[i].d, &sregs->fpregs.fprs[i].d);  
  306. }
  307. return(err);
  309. }
  311. static int restore_sigregs32(struct pt_regs *regs,_sigregs32 *sregs)
  312. {
  313. int err = 0;
  314. s390_fp_regs fpregs;
  315. psw_t saved_psw=regs->psw;
  316. int i;
  318. for(i=0; i<NUM_GPRS; i++)
  319. err |= __get_user(regs->gprs[i], &sregs->regs.gprs[i]);  
  320. for(i=0; i<NUM_ACRS; i++)
  321. err |= __get_user(regs->acrs[i], &sregs->regs.acrs[i]);  
  322. err |= __copy_from_user(&regs->psw.mask, &sregs->regs.psw.mask, 4);
  323. err |= __copy_from_user(((char*)&regs->psw.addr)+4, &sregs->regs.psw.addr, 4);
  325. if(!err)
  326. {
  327. regs->trap = -1; /* disable syscall checks */
  328. regs->psw.mask=(saved_psw.mask&~PSW_MASK_DEBUGCHANGE)|
  329. (regs->psw.mask&PSW_MASK_DEBUGCHANGE);
  330. regs->psw.addr=(saved_psw.addr&~PSW_ADDR_DEBUGCHANGE)|
  331. (regs->psw.addr&PSW_ADDR_DEBUGCHANGE);
  332. __get_user(fpregs.fpc, &sregs->fpregs.fpc);
  333.                 for(i=0; i<NUM_FPRS; i++)
  334.                         err |= __get_user(fpregs.fprs[i].d, &sregs->fpregs.fprs[i].d);              
  335. if(!err)
  336. restore_fp_regs(&fpregs);
  337. }
  338. return(err);
  339. }
  341. asmlinkage long sys32_sigreturn(struct pt_regs *regs)
  342. {
  343. sigframe32 *frame = (sigframe32 *)regs->gprs[15];
  344. sigset_t set;
  346. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  347. goto badframe;
  348. if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
  349. goto badframe;
  351. sigdelsetmask(&set, ~_BLOCKABLE);
  352. spin_lock_irq(&current->sigmask_lock);
  353. current->blocked = set;
  354. recalc_sigpending(current);
  355. spin_unlock_irq(&current->sigmask_lock);
  357. if (restore_sigregs32(regs, &frame->sregs))
  358. goto badframe;
  360. return regs->gprs[2];
  362. badframe:
  363. force_sig(SIGSEGV, current);
  364. return 0;
  365. }
  367. asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
  368. {
  369. rt_sigframe32 *frame = (rt_sigframe32 *)regs->gprs[15];
  370. sigset_t set;
  371. stack_t st;
  372. int err;
  373. mm_segment_t old_fs = get_fs();
  375. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  376. goto badframe;
  377. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  378. goto badframe;
  380. sigdelsetmask(&set, ~_BLOCKABLE);
  381. spin_lock_irq(&current->sigmask_lock);
  382. current->blocked = set;
  383. recalc_sigpending(current);
  384. spin_unlock_irq(&current->sigmask_lock);
  386. if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
  387. goto badframe;
  389. err = __get_user(st.ss_sp, &frame->uc.uc_stack.ss_sp);
  390. st.ss_sp = (void *) A((unsigned long)st.ss_sp);
  391. err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
  392. err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
  393. if (err)
  394. goto badframe; 
  396. /* It is more difficult to avoid calling this function than to
  397.    call it and ignore errors.  */
  398. set_fs (KERNEL_DS);   
  399. do_sigaltstack(&st, NULL, regs->gprs[15]);
  400. set_fs (old_fs);
  402. return regs->gprs[2];
  404. badframe:
  405.         force_sig(SIGSEGV, current);
  406.         return 0;
  407. }
  409. /*
  410.  * Set up a signal frame.
  411.  */
  414. /*
  415.  * Determine which stack to use..
  416.  */
  417. static inline void *
  418. get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
  419. {
  420. unsigned long sp;
  422. /* Default to using normal stack */
  423. sp = (unsigned long) A(regs->gprs[15]);
  425. /* This is the X/Open sanctioned signal stack switching.  */
  426. if (ka->sa.sa_flags & SA_ONSTACK) {
  427. if (! on_sig_stack(sp))
  428. sp = current->sas_ss_sp + current->sas_ss_size;
  429. }
  431. /* This is the legacy signal stack switching. */
  432. else if (!user_mode(regs) &&
  433.  !(ka->sa.sa_flags & SA_RESTORER) &&
  434.  ka->sa.sa_restorer) {
  435. sp = (unsigned long) ka->sa.sa_restorer;
  436. }
  438. return (void *)((sp - frame_size) & -8ul);
  439. }
  441. static inline int map_signal(int sig)
  442. {
  443. if (current->exec_domain
  444.     && current->exec_domain->signal_invmap
  445.     && sig < 32)
  446. return current->exec_domain->signal_invmap[sig];
  447.         else
  448. return sig;
  449. }
  451. static void setup_frame32(int sig, struct k_sigaction *ka,
  452. sigset_t *set, struct pt_regs * regs)
  453. {
  454. sigframe32 *frame = get_sigframe(ka, regs, sizeof(sigframe32));
  455. if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
  456. goto give_sigsegv;
  458. if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
  459. goto give_sigsegv;
  461. if (save_sigregs32(regs, &frame->sregs))
  462. goto give_sigsegv;
  463. if (__put_user(&frame->sregs, &frame->sc.sregs))
  464. goto give_sigsegv;
  466. /* Set up to return from userspace.  If provided, use a stub
  467.    already in userspace.  */
  468. if (ka->sa.sa_flags & SA_RESTORER) {
  469. regs->gprs[14] = FIX_PSW(ka->sa.sa_restorer);
  470. } else {
  471. regs->gprs[14] = FIX_PSW(frame->retcode);
  472. if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
  473.                (u16 *)(frame->retcode)))
  474. goto give_sigsegv;
  475.         }
  477. /* Set up registers for signal handler */
  478. regs->gprs[15] = (addr_t)frame;
  479. regs->psw.addr = FIX_PSW(ka->sa.sa_handler);
  480. regs->psw.mask = _USER_PSW_MASK32;
  482. regs->gprs[2] = map_signal(sig);
  483. regs->gprs[3] = (addr_t)&frame->sc;
  485. /* We forgot to include these in the sigcontext.
  486.    To avoid breaking binary compatibility, they are passed as args. */
  487. regs->gprs[4] = current->thread.trap_no;
  488. regs->gprs[5] = current->thread.prot_addr;
  489. return;
  491. give_sigsegv:
  492. if (sig == SIGSEGV)
  493. ka->sa.sa_handler = SIG_DFL;
  494. force_sig(SIGSEGV, current);
  495. }
  497. static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
  498.    sigset_t *set, struct pt_regs * regs)
  499. {
  500. int err = 0;
  501. rt_sigframe32 *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
  502. if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
  503. goto give_sigsegv;
  505. if (copy_siginfo_to_user32(&frame->info, info))
  506. goto give_sigsegv;
  508. /* Create the ucontext.  */
  509. err |= __put_user(0, &frame->uc.uc_flags);
  510. err |= __put_user(0, &frame->uc.uc_link);
  511. err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
  512. err |= __put_user(sas_ss_flags(regs->gprs[15]),
  513.                   &frame->uc.uc_stack.ss_flags);
  514. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  515. err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
  516. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  517. if (err)
  518. goto give_sigsegv;
  520. /* Set up to return from userspace.  If provided, use a stub
  521.    already in userspace.  */
  522. if (ka->sa.sa_flags & SA_RESTORER) {
  523. regs->gprs[14] = FIX_PSW(ka->sa.sa_restorer);
  524. } else {
  525. regs->gprs[14] = FIX_PSW(frame->retcode);
  526. err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
  527.                   (u16 *)(frame->retcode));
  528. }
  530. /* Set up registers for signal handler */
  531. regs->gprs[15] = (addr_t)frame;
  532. regs->psw.addr = FIX_PSW(ka->sa.sa_handler);
  533. regs->psw.mask = _USER_PSW_MASK32;
  535. regs->gprs[2] = map_signal(sig);
  536. regs->gprs[3] = (addr_t)&frame->info;
  537. regs->gprs[4] = (addr_t)&frame->uc;
  538. return;
  540. give_sigsegv:
  541. if (sig == SIGSEGV)
  542. ka->sa.sa_handler = SIG_DFL;
  543. force_sig(SIGSEGV, current);
  544. }
  546. /*
  547.  * OK, we're invoking a handler
  548.  */
  550. static void
  551. handle_signal32(unsigned long sig, struct k_sigaction *ka,
  552.       siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  553. {
  554. /* Are we from a system call? */
  555. if (regs->trap == __LC_SVC_OLD_PSW) {
  556. /* If so, check system call restarting.. */
  557. switch (regs->gprs[2]) {
  558. case -ERESTARTNOHAND:
  559. regs->gprs[2] = -EINTR;
  560. break;
  562. case -ERESTARTSYS:
  563. if (!(ka->sa.sa_flags & SA_RESTART)) {
  564. regs->gprs[2] = -EINTR;
  565. break;
  566. }
  567. /* fallthrough */
  568. case -ERESTARTNOINTR:
  569. regs->gprs[2] = regs->orig_gpr2;
  570. regs->psw.addr -= 2;
  571. }
  572. }
  574. /* Set up the stack frame */
  575. if (ka->sa.sa_flags & SA_SIGINFO)
  576. setup_rt_frame32(sig, ka, info, oldset, regs);
  577. else
  578. setup_frame32(sig, ka, oldset, regs);
  580. if (ka->sa.sa_flags & SA_ONESHOT)
  581. ka->sa.sa_handler = SIG_DFL;
  583. if (!(ka->sa.sa_flags & SA_NODEFER)) {
  584. spin_lock_irq(&current->sigmask_lock);
  585. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  586. sigaddset(&current->blocked,sig);
  587. recalc_sigpending(current);
  588. spin_unlock_irq(&current->sigmask_lock);
  589. }
  590. }
  592. /*
  593.  * Note that 'init' is a special process: it doesn't get signals it doesn't
  594.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  595.  * mistake.
  596.  *
  597.  * Note that we go through the signals twice: once to check the signals that
  598.  * the kernel can handle, and then we build all the user-level signal handling
  599.  * stack-frames in one go after that.
  600.  */
  601. int do_signal32(struct pt_regs *regs, sigset_t *oldset)
  602. {
  603. siginfo_t info;
  604. struct k_sigaction *ka;
  606. /*
  607.  * We want the common case to go fast, which
  608.  * is why we may in certain cases get here from
  609.  * kernel mode. Just return without doing anything
  610.  * if so.
  611.  */
  612. if (!user_mode(regs))
  613. return 1;
  615. if (!oldset)
  616. oldset = &current->blocked;
  618. for (;;) {
  619. unsigned long signr;
  621. spin_lock_irq(&current->sigmask_lock);
  622. signr = dequeue_signal(&current->blocked, &info);
  623. spin_unlock_irq(&current->sigmask_lock);
  625. if (!signr)
  626. break;
  628. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  629. /* Let the debugger run.  */
  630. current->exit_code = signr;
  631. set_current_state(TASK_STOPPED);
  632. notify_parent(current, SIGCHLD);
  633. schedule();
  635. /* We're back.  Did the debugger cancel the sig?  */
  636. if (!(signr = current->exit_code))
  637. continue;
  638. current->exit_code = 0;
  640. /* The debugger continued.  Ignore SIGSTOP.  */
  641. if (signr == SIGSTOP)
  642. continue;
  644. /* Update the siginfo structure.  Is this good?  */
  645. if (signr != info.si_signo) {
  646. info.si_signo = signr;
  647. info.si_errno = 0;
  648. info.si_code = SI_USER;
  649. info.si_pid = current->p_pptr->pid;
  650. info.si_uid = current->p_pptr->uid;
  651. }
  653. /* If the (new) signal is now blocked, requeue it.  */
  654. if (sigismember(&current->blocked, signr)) {
  655. send_sig_info(signr, &info, current);
  656. continue;
  657. }
  658. }
  660. ka = &current->sig->action[signr-1];
  661. if (ka->sa.sa_handler == SIG_IGN) {
  662. if (signr != SIGCHLD)
  663. continue;
  664. /* Check for SIGCHLD: it's special.  */
  665. while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  666. /* nothing */;
  667. continue;
  668. }
  670. if (ka->sa.sa_handler == SIG_DFL) {
  671. int exit_code = signr;
  673. /* Init gets no signals it doesn't want.  */
  674. if (current->pid == 1)
  675. continue;
  677. switch (signr) {
  678. case SIGCONT: case SIGCHLD: case SIGWINCH:
  679. continue;
  681. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  682. if (is_orphaned_pgrp(current->pgrp))
  683. continue;
  684. /* FALLTHRU */
  686. case SIGSTOP:
  687. set_current_state(TASK_STOPPED);
  688. current->exit_code = signr;
  689. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  690. notify_parent(current, SIGCHLD);
  691. schedule();
  692. continue;
  694. case SIGQUIT: case SIGILL: case SIGTRAP:
  695. case SIGABRT: case SIGFPE: case SIGSEGV:
  696. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  697.                                 if (do_coredump(signr, regs))
  698.                                         exit_code |= 0x80;
  699.                                 /* FALLTHRU */
  701. default:
  702. sig_exit(signr, exit_code, &info);
  703. /* NOTREACHED */
  704. }
  705. }
  707. /* Whee!  Actually deliver the signal.  */
  708. handle_signal32(signr, ka, &info, oldset, regs);
  709. return 1;
  710. }
  712. /* Did we come from a system call? */
  713. if ( regs->trap == __LC_SVC_OLD_PSW /* System Call! */ ) {
  714. /* Restart the system call - no handlers present */
  715. if (regs->gprs[2] == -ERESTARTNOHAND ||
  716.     regs->gprs[2] == -ERESTARTSYS ||
  717.     regs->gprs[2] == -ERESTARTNOINTR) {
  718. regs->gprs[2] = regs->orig_gpr2;
  719. regs->psw.addr -= 2;
  720. }
  721. }
  722. return 0;
  723. }