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

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

Linux/Unix编程

开发平台：

Unix_Linux

signal.c：源码内容
  1. /*  $Id: signal.c,v 1.56 2001/03/21 11:46:20 davem Exp $
  2.  *  arch/sparc64/kernel/signal.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  6.  *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
  7.  *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
  8.  *  Copyright (C) 1997,1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/sched.h>
  13. #include <linux/kernel.h>
  14. #include <linux/signal.h>
  15. #include <linux/errno.h>
  16. #include <linux/wait.h>
  17. #include <linux/ptrace.h>
  18. #include <linux/unistd.h>
  19. #include <linux/mm.h>
  20. #include <linux/smp_lock.h>
  22. #include <asm/uaccess.h>
  23. #include <asm/bitops.h>
  24. #include <asm/ptrace.h>
  25. #include <asm/svr4.h>
  26. #include <asm/pgtable.h>
  27. #include <asm/fpumacro.h>
  28. #include <asm/uctx.h>
  29. #include <asm/siginfo.h>
  30. #include <asm/visasm.h>
  32. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  34. asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
  35.  unsigned long orig_o0, int ret_from_syscall);
  37. /* This turned off for production... */
  38. /* #define DEBUG_SIGNALS 1 */
  39. /* #define DEBUG_SIGNALS_TRACE 1 */
  40. /* #define DEBUG_SIGNALS_MAPS 1 */
  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(*(long *)&from->si_signo, (long *)&to->si_signo);
  57. err |= __put_user((short)from->si_code, &to->si_code);
  58. switch (from->si_code >> 16) {
  59. case __SI_CHLD >> 16:
  60. err |= __put_user(from->si_utime, &to->si_utime);
  61. err |= __put_user(from->si_stime, &to->si_stime);
  62. case __SI_FAULT >> 16:
  63. case __SI_POLL >> 16:
  64. err |= __put_user(from->si_trapno, &to->si_trapno);
  65. default:
  66. err |= __put_user(from->si_addr, &to->si_addr);
  67. break;
  68. /* case __SI_RT: This is not generated by the kernel as of now.  */
  69. }
  70. return err;
  71. }
  72. }
  74. /* {set, get}context() needed for 64-bit SparcLinux userland. */
  75. asmlinkage void sparc64_set_context(struct pt_regs *regs)
  76. {
  77. struct ucontext *ucp = (struct ucontext *) regs->u_regs[UREG_I0];
  78. struct thread_struct *tp = &current->thread;
  79. mc_gregset_t *grp;
  80. unsigned long pc, npc, tstate;
  81. unsigned long fp, i7;
  82. unsigned char fenab;
  83. int err;
  85. flush_user_windows();
  86. if(tp->w_saved ||
  87.    (((unsigned long)ucp) & (sizeof(unsigned long)-1)) ||
  88.    (!__access_ok((unsigned long)ucp, sizeof(*ucp))))
  89. goto do_sigsegv;
  90. grp  = &ucp->uc_mcontext.mc_gregs;
  91. err  = __get_user(pc, &((*grp)[MC_PC]));
  92. err |= __get_user(npc, &((*grp)[MC_NPC]));
  93. if(err || ((pc | npc) & 3))
  94. goto do_sigsegv;
  95. if(regs->u_regs[UREG_I1]) {
  96. sigset_t set;
  98. if (_NSIG_WORDS == 1) {
  99. if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))
  100. goto do_sigsegv;
  101. } else {
  102. if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))
  103. goto do_sigsegv;
  104. }
  105. sigdelsetmask(&set, ~_BLOCKABLE);
  106. spin_lock_irq(&current->sigmask_lock);
  107. current->blocked = set;
  108. recalc_sigpending(current);
  109. spin_unlock_irq(&current->sigmask_lock);
  110. }
  111. if ((tp->flags & SPARC_FLAG_32BIT) != 0) {
  112. pc &= 0xffffffff;
  113. npc &= 0xffffffff;
  114. }
  115. regs->tpc = pc;
  116. regs->tnpc = npc;
  117. err |= __get_user(regs->y, &((*grp)[MC_Y]));
  118. err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
  119. regs->tstate &= ~(TSTATE_ICC | TSTATE_XCC);
  120. regs->tstate |= (tstate & (TSTATE_ICC | TSTATE_XCC));
  121. err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));
  122. err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));
  123. err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));
  124. err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));
  125. err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));
  126. err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));
  127. err |= __get_user(regs->u_regs[UREG_G7], (&(*grp)[MC_G7]));
  128. err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));
  129. err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));
  130. err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));
  131. err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));
  132. err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));
  133. err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));
  134. err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));
  135. err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));
  137. err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
  138. err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
  139. err |= __put_user(fp,
  140.       (&(((struct reg_window *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
  141. err |= __put_user(i7,
  142.       (&(((struct reg_window *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
  144. err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
  145. if(fenab) {
  146. unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  147. unsigned long fprs;
  149. fprs_write(0);
  150. err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
  151. if (fprs & FPRS_DL)
  152. err |= copy_from_user(fpregs,
  153.       &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),
  154.       (sizeof(unsigned int) * 32));
  155. if (fprs & FPRS_DU)
  156. err |= copy_from_user(fpregs+16,
  157.  ((unsigned long *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,
  158.  (sizeof(unsigned int) * 32));
  159. err |= __get_user(current->thread.xfsr[0],
  160.   &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
  161. err |= __get_user(current->thread.gsr[0],
  162.   &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
  163. regs->tstate &= ~TSTATE_PEF;
  164. }
  165. if (err)
  166. goto do_sigsegv;
  168. return;
  169. do_sigsegv:
  170. do_exit(SIGSEGV);
  171. }
  173. asmlinkage void sparc64_get_context(struct pt_regs *regs)
  174. {
  175. struct ucontext *ucp = (struct ucontext *) regs->u_regs[UREG_I0];
  176. struct thread_struct *tp = &current->thread;
  177. mc_gregset_t *grp;
  178. mcontext_t *mcp;
  179. unsigned long fp, i7;
  180. unsigned char fenab;
  181. int err;
  183. synchronize_user_stack();
  184. if(tp->w_saved || clear_user(ucp, sizeof(*ucp)))
  185. goto do_sigsegv;
  187. #if 1
  188. fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
  189. #else
  190. fenab = (current->thread.fpsaved[0] & FPRS_FEF);
  191. #endif
  193. mcp = &ucp->uc_mcontext;
  194. grp = &mcp->mc_gregs;
  196. /* Skip over the trap instruction, first. */
  197. if ((tp->flags & SPARC_FLAG_32BIT) != 0) {
  198. regs->tpc   = (regs->tnpc & 0xffffffff);
  199. regs->tnpc  = (regs->tnpc + 4) & 0xffffffff;
  200. } else {
  201. regs->tpc   = regs->tnpc;
  202. regs->tnpc += 4;
  203. }
  204. err = 0;
  205. if (_NSIG_WORDS == 1)
  206. err |= __put_user(current->blocked.sig[0],
  207.   (unsigned long *)&ucp->uc_sigmask);
  208. else
  209. err |= __copy_to_user(&ucp->uc_sigmask, &current->blocked,
  210.       sizeof(sigset_t));
  212. err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));
  213. err |= __put_user(regs->tpc, &((*grp)[MC_PC]));
  214. err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));
  215. err |= __put_user(regs->y, &((*grp)[MC_Y]));
  216. err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));
  217. err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));
  218. err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));
  219. err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));
  220. err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));
  221. err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));
  222. err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G7]));
  223. err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));
  224. err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));
  225. err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));
  226. err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));
  227. err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));
  228. err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));
  229. err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));
  230. err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));
  232. err |= __get_user(fp,
  233.  (&(((struct reg_window *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
  234. err |= __get_user(i7,
  235.  (&(((struct reg_window *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
  236. err |= __put_user(fp, &(mcp->mc_fp));
  237. err |= __put_user(i7, &(mcp->mc_i7));
  239. err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));
  240. if(fenab) {
  241. unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  242. unsigned long fprs;
  244. fprs = current->thread.fpsaved[0];
  245. if (fprs & FPRS_DL)
  246. err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,
  247.     (sizeof(unsigned int) * 32));
  248. if (fprs & FPRS_DU)
  249. err |= copy_to_user(
  250.                           ((unsigned long *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,
  251.   (sizeof(unsigned int) * 32));
  252. err |= __put_user(current->thread.xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));
  253. err |= __put_user(current->thread.gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));
  254. err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));
  255. }
  256. if (err)
  257. goto do_sigsegv;
  259. return;
  260. do_sigsegv:
  261. do_exit(SIGSEGV);
  262. }
  264. struct rt_signal_frame {
  265. struct sparc_stackf ss;
  266. siginfo_t info;
  267. struct pt_regs regs;
  268. __siginfo_fpu_t * fpu_save;
  269. stack_t stack;
  270. sigset_t mask;
  271. __siginfo_fpu_t fpu_state;
  272. };
  274. /* Align macros */
  275. #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame) + 7) & (~7)))
  277. /*
  278.  * atomically swap in the new signal mask, and wait for a signal.
  279.  * This is really tricky on the Sparc, watch out...
  280.  */
  281. asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
  282. {
  283. sigset_t saveset;
  285. #ifdef CONFIG_SPARC32_COMPAT
  286. if (current->thread.flags & SPARC_FLAG_32BIT) {
  287. extern asmlinkage void _sigpause32_common(old_sigset_t32,
  288.   struct pt_regs *);
  289. _sigpause32_common(set, regs);
  290. return;
  291. }
  292. #endif
  293. set &= _BLOCKABLE;
  294. spin_lock_irq(&current->sigmask_lock);
  295. saveset = current->blocked;
  296. siginitset(&current->blocked, set);
  297. recalc_sigpending(current);
  298. spin_unlock_irq(&current->sigmask_lock);
  300. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  301. regs->tpc = (regs->tnpc & 0xffffffff);
  302. regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
  303. } else {
  304. regs->tpc = regs->tnpc;
  305. regs->tnpc += 4;
  306. }
  308. /* Condition codes and return value where set here for sigpause,
  309.  * and so got used by setup_frame, which again causes sigreturn()
  310.  * to return -EINTR.
  311.  */
  312. while (1) {
  313. current->state = TASK_INTERRUPTIBLE;
  314. schedule();
  315. /*
  316.  * Return -EINTR and set condition code here,
  317.  * so the interrupted system call actually returns
  318.  * these.
  319.  */
  320. regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
  321. regs->u_regs[UREG_I0] = EINTR;
  322. if (do_signal(&saveset, regs, 0, 0))
  323. return;
  324. }
  325. }
  327. asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
  328. {
  329. _sigpause_common(set, regs);
  330. }
  332. asmlinkage void do_sigsuspend(struct pt_regs *regs)
  333. {
  334. _sigpause_common(regs->u_regs[UREG_I0], regs);
  335. }
  337. asmlinkage void do_rt_sigsuspend(sigset_t *uset, size_t sigsetsize, struct pt_regs *regs)
  338. {
  339. sigset_t oldset, set;
  340.         
  341. /* XXX: Don't preclude handling different sized sigset_t's.  */
  342. if (sigsetsize != sizeof(sigset_t)) {
  343. regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
  344. regs->u_regs[UREG_I0] = EINVAL;
  345. return;
  346. }
  347. if (copy_from_user(&set, uset, sizeof(set))) {
  348. regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
  349. regs->u_regs[UREG_I0] = EFAULT;
  350. return;
  351. }
  352.                                                                 
  353. sigdelsetmask(&set, ~_BLOCKABLE);
  354. spin_lock_irq(&current->sigmask_lock);
  355. oldset = current->blocked;
  356. current->blocked = set;
  357. recalc_sigpending(current);
  358. spin_unlock_irq(&current->sigmask_lock);
  360. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  361. regs->tpc = (regs->tnpc & 0xffffffff);
  362. regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
  363. } else {
  364. regs->tpc = regs->tnpc;
  365. regs->tnpc += 4;
  366. }
  368. /* Condition codes and return value where set here for sigpause,
  369.  * and so got used by setup_frame, which again causes sigreturn()
  370.  * to return -EINTR.
  371.  */
  372. while (1) {
  373. current->state = TASK_INTERRUPTIBLE;
  374. schedule();
  375. /*
  376.  * Return -EINTR and set condition code here,
  377.  * so the interrupted system call actually returns
  378.  * these.
  379.  */
  380. regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
  381. regs->u_regs[UREG_I0] = EINTR;
  382. if (do_signal(&oldset, regs, 0, 0))
  383. return;
  384. }
  385. }
  387. static inline int
  388. restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
  389. {
  390. unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  391. unsigned long fprs;
  392. int err;
  394. err = __get_user(fprs, &fpu->si_fprs);
  395. fprs_write(0);
  396. regs->tstate &= ~TSTATE_PEF;
  397. if (fprs & FPRS_DL)
  398. err |= copy_from_user(fpregs, &fpu->si_float_regs[0],
  399.                (sizeof(unsigned int) * 32));
  400. if (fprs & FPRS_DU)
  401. err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32],
  402.                (sizeof(unsigned int) * 32));
  403. err |= __get_user(current->thread.xfsr[0], &fpu->si_fsr);
  404. err |= __get_user(current->thread.gsr[0], &fpu->si_gsr);
  405. current->thread.fpsaved[0] |= fprs;
  406. return err;
  407. }
  409. void do_rt_sigreturn(struct pt_regs *regs)
  410. {
  411. struct rt_signal_frame *sf;
  412. unsigned long tpc, tnpc, tstate;
  413. __siginfo_fpu_t *fpu_save;
  414. mm_segment_t old_fs;
  415. sigset_t set;
  416. stack_t st;
  417. int err;
  419. synchronize_user_stack ();
  420. sf = (struct rt_signal_frame *)
  421. (regs->u_regs [UREG_FP] + STACK_BIAS);
  423. /* 1. Make sure we are not getting garbage from the user */
  424. if (((unsigned long) sf) & 3)
  425. goto segv;
  427. err = get_user(tpc, &sf->regs.tpc);
  428. err |= __get_user(tnpc, &sf->regs.tnpc);
  429. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  430. tpc &= 0xffffffff;
  431. tnpc &= 0xffffffff;
  432. }
  433. err |= ((tpc | tnpc) & 3);
  435. /* 2. Restore the state */
  436. err |= __get_user(regs->y, &sf->regs.y);
  437. err |= __get_user(tstate, &sf->regs.tstate);
  438. err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));
  440. /* User can only change condition codes in %tstate. */
  441. regs->tstate &= ~(TSTATE_ICC);
  442. regs->tstate |= (tstate & TSTATE_ICC);
  444. err |= __get_user(fpu_save, &sf->fpu_save);
  445. if (fpu_save)
  446. err |= restore_fpu_state(regs, &sf->fpu_state);
  448. err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
  449. err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
  451. if (err)
  452. goto segv;
  454. regs->tpc = tpc;
  455. regs->tnpc = tnpc;
  457. /* It is more difficult to avoid calling this function than to
  458.    call it and ignore errors.  */
  459. old_fs = get_fs();
  460. set_fs(KERNEL_DS);
  461. do_sigaltstack(&st, NULL, (unsigned long)sf);
  462. set_fs(old_fs);
  464. sigdelsetmask(&set, ~_BLOCKABLE);
  465. spin_lock_irq(&current->sigmask_lock);
  466. current->blocked = set;
  467. recalc_sigpending(current);
  468. spin_unlock_irq(&current->sigmask_lock);
  469. return;
  470. segv:
  471. send_sig(SIGSEGV, current, 1);
  472. }
  474. /* Checks if the fp is valid */
  475. static int invalid_frame_pointer(void *fp, int fplen)
  476. {
  477. if (((unsigned long) fp) & 7)
  478. return 1;
  479. return 0;
  480. }
  482. static inline int
  483. save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
  484. {
  485. unsigned long *fpregs = (unsigned long *)(regs+1);
  486. unsigned long fprs;
  487. int err = 0;
  489. fprs = current->thread.fpsaved[0];
  490. if (fprs & FPRS_DL)
  491. err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
  492.     (sizeof(unsigned int) * 32));
  493. if (fprs & FPRS_DU)
  494. err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
  495.     (sizeof(unsigned int) * 32));
  496. err |= __put_user(current->thread.xfsr[0], &fpu->si_fsr);
  497. err |= __put_user(current->thread.gsr[0], &fpu->si_gsr);
  498. err |= __put_user(fprs, &fpu->si_fprs);
  500. return err;
  501. }
  503. static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
  504. {
  505. unsigned long sp;
  507. sp = regs->u_regs[UREG_FP] + STACK_BIAS;
  509. /* This is the X/Open sanctioned signal stack switching.  */
  510. if (ka->sa.sa_flags & SA_ONSTACK) {
  511. if (!on_sig_stack(sp) &&
  512.     !((current->sas_ss_sp + current->sas_ss_size) & 7))
  513. sp = current->sas_ss_sp + current->sas_ss_size;
  514. }
  515. return (void *)(sp - framesize);
  516. }
  518. static inline void
  519. setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
  520.        int signo, sigset_t *oldset, siginfo_t *info)
  521. {
  522. struct rt_signal_frame *sf;
  523. int sigframe_size, err;
  525. /* 1. Make sure everything is clean */
  526. synchronize_user_stack();
  527. save_and_clear_fpu();
  529. sigframe_size = RT_ALIGNEDSZ;
  530. if (!(current->thread.fpsaved[0] & FPRS_FEF))
  531. sigframe_size -= sizeof(__siginfo_fpu_t);
  533. sf = (struct rt_signal_frame *)get_sigframe(ka, regs, sigframe_size);
  535. if (invalid_frame_pointer (sf, sigframe_size))
  536. goto sigill;
  538. if (current->thread.w_saved != 0) {
  539. #ifdef DEBUG_SIGNALS
  540. printk ("%s[%d]: Invalid user stack frame for "
  541. "signal delivery.n", current->comm, current->pid);
  542. #endif
  543. goto sigill;
  544. }
  546. /* 2. Save the current process state */
  547. err = copy_to_user(&sf->regs, regs, sizeof (*regs));
  549. if (current->thread.fpsaved[0] & FPRS_FEF) {
  550. err |= save_fpu_state(regs, &sf->fpu_state);
  551. err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
  552. } else {
  553. err |= __put_user(0, &sf->fpu_save);
  554. }
  556. /* Setup sigaltstack */
  557. err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
  558. err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
  559. err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
  561. err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
  563. err |= copy_in_user((u64 *)sf,
  564.     (u64 *)(regs->u_regs[UREG_FP]+STACK_BIAS),
  565.     sizeof(struct reg_window));
  567. if (info)
  568. err |= copy_siginfo_to_user(&sf->info, info);
  569. else {
  570. err |= __put_user(signo, &sf->info.si_signo);
  571. err |= __put_user(SI_NOINFO, &sf->info.si_code);
  572. }
  573. if (err)
  574. goto sigsegv;
  576. /* 3. signal handler back-trampoline and parameters */
  577. regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
  578. regs->u_regs[UREG_I0] = signo;
  579. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  581. /* The sigcontext is passed in this way because of how it
  582.  * is defined in GLIBC's /usr/include/bits/sigcontext.h
  583.  * for sparc64.  It includes the 128 bytes of siginfo_t.
  584.  */
  585. regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
  587. /* 5. signal handler */
  588. regs->tpc = (unsigned long) ka->sa.sa_handler;
  589. regs->tnpc = (regs->tpc + 4);
  590. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  591. regs->tpc &= 0xffffffff;
  592. regs->tnpc &= 0xffffffff;
  593. }
  594. /* 4. return to kernel instructions */
  595. regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  596. return;
  598. sigill:
  599. do_exit(SIGILL);
  600. sigsegv:
  601. do_exit(SIGSEGV);
  602. }
  604. static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
  605.  siginfo_t *info,
  606.  sigset_t *oldset, struct pt_regs *regs)
  607. {
  608. setup_rt_frame(ka, regs, signr, oldset, (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL);
  609. if(ka->sa.sa_flags & SA_ONESHOT)
  610. ka->sa.sa_handler = SIG_DFL;
  611. if(!(ka->sa.sa_flags & SA_NOMASK)) {
  612. spin_lock_irq(&current->sigmask_lock);
  613. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  614. sigaddset(&current->blocked,signr);
  615. recalc_sigpending(current);
  616. spin_unlock_irq(&current->sigmask_lock);
  617. }
  618. }
  620. static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
  621.      struct sigaction *sa)
  622. {
  623. switch(regs->u_regs[UREG_I0]) {
  624. case ERESTARTNOHAND:
  625. no_system_call_restart:
  626. regs->u_regs[UREG_I0] = EINTR;
  627. regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
  628. break;
  629. case ERESTARTSYS:
  630. if(!(sa->sa_flags & SA_RESTART))
  631. goto no_system_call_restart;
  632. /* fallthrough */
  633. case ERESTARTNOINTR:
  634. regs->u_regs[UREG_I0] = orig_i0;
  635. regs->tpc -= 4;
  636. regs->tnpc -= 4;
  637. }
  638. }
  640. #ifdef DEBUG_SIGNALS_MAPS
  642. #define MAPS_LINE_FORMAT   "%016lx-%016lx %s %016lx %s %lu "
  644. static inline void read_maps (void)
  645. {
  646. struct vm_area_struct * map, * next;
  647. char * buffer;
  648. ssize_t i;
  650. buffer = (char*)__get_free_page(GFP_KERNEL);
  651. if (!buffer)
  652. return;
  654. for (map = current->mm->mmap ; map ; map = next ) {
  655. /* produce the next line */
  656. char *line;
  657. char str[5], *cp = str;
  658. int flags;
  659. kdev_t dev;
  660. unsigned long ino;
  662. /*
  663.  * Get the next vma now (but it won't be used if we sleep).
  664.  */
  665. next = map->vm_next;
  666. flags = map->vm_flags;
  668. *cp++ = flags & VM_READ ? 'r' : '-';
  669. *cp++ = flags & VM_WRITE ? 'w' : '-';
  670. *cp++ = flags & VM_EXEC ? 'x' : '-';
  671. *cp++ = flags & VM_MAYSHARE ? 's' : 'p';
  672. *cp++ = 0;
  674. dev = 0;
  675. ino = 0;
  676. if (map->vm_file != NULL) {
  677. dev = map->vm_file->f_dentry->d_inode->i_dev;
  678. ino = map->vm_file->f_dentry->d_inode->i_ino;
  679. line = d_path(map->vm_file->f_dentry,
  680.       map->vm_file->f_vfsmnt,
  681.       buffer, PAGE_SIZE);
  682. }
  683. printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT,
  684.       kdevname(dev), ino);
  685. if (map->vm_file != NULL)
  686. printk("%sn", line);
  687. else
  688. printk("n");
  689. }
  690. free_page((unsigned long)buffer);
  691. return;
  692. }
  694. #endif
  696. /* Note that 'init' is a special process: it doesn't get signals it doesn't
  697.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  698.  * mistake.
  699.  */
  700. asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
  701.  unsigned long orig_i0, int restart_syscall)
  702. {
  703. unsigned long signr;
  704. siginfo_t info;
  705. struct k_sigaction *ka;
  707. if (!oldset)
  708. oldset = &current->blocked;
  710. #ifdef CONFIG_SPARC32_COMPAT
  711. if (current->thread.flags & SPARC_FLAG_32BIT) {
  712. extern asmlinkage int do_signal32(sigset_t *, struct pt_regs *,
  713.   unsigned long, int);
  714. return do_signal32(oldset, regs, orig_i0, restart_syscall);
  715. }
  716. #endif
  717. for (;;) {
  718. spin_lock_irq(&current->sigmask_lock);
  719. signr = dequeue_signal(&current->blocked, &info);
  720. spin_unlock_irq(&current->sigmask_lock);
  722. if (!signr)
  723. break;
  725. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  726. /* Do the syscall restart before we let the debugger
  727.  * look at the child registers.
  728.  */
  729. if (restart_syscall &&
  730.     (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
  731.      regs->u_regs[UREG_I0] == ERESTARTSYS ||
  732.      regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
  733. regs->u_regs[UREG_I0] = orig_i0;
  734. regs->tpc -= 4;
  735. regs->tnpc -= 4;
  736. restart_syscall = 0;
  737. }
  739. current->exit_code = signr;
  740. current->state = TASK_STOPPED;
  741. notify_parent(current, SIGCHLD);
  742. schedule();
  743. if (!(signr = current->exit_code))
  744. continue;
  745. current->exit_code = 0;
  746. if (signr == SIGSTOP)
  747. continue;
  749. /* Update the siginfo structure.  Is this good?  */
  750. if (signr != info.si_signo) {
  751. info.si_signo = signr;
  752. info.si_errno = 0;
  753. info.si_code = SI_USER;
  754. info.si_pid = current->p_pptr->pid;
  755. info.si_uid = current->p_pptr->uid;
  756. }
  758. /* If the (new) signal is now blocked, requeue it.  */
  759. if (sigismember(&current->blocked, signr)) {
  760. send_sig_info(signr, &info, current);
  761. continue;
  762. }
  763. }
  765. ka = &current->sig->action[signr-1];
  767. if (ka->sa.sa_handler == SIG_IGN) {
  768. if (signr != SIGCHLD)
  769. continue;
  771.                         /* sys_wait4() grabs the master kernel lock, so
  772.                          * we need not do so, that sucker should be
  773.                          * threaded and would not be that difficult to
  774.                          * do anyways.
  775.                          */
  776.                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  777.                                 ;
  778. continue;
  779. }
  780. if (ka->sa.sa_handler == SIG_DFL) {
  781. unsigned long exit_code = signr;
  783. if (current->pid == 1)
  784. continue;
  785. switch (signr) {
  786. case SIGCONT: case SIGCHLD: case SIGWINCH:
  787. continue;
  789. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  790. if (is_orphaned_pgrp(current->pgrp))
  791. continue;
  793. case SIGSTOP:
  794. if (current->ptrace & PT_PTRACED)
  795. continue;
  796. current->state = TASK_STOPPED;
  797. current->exit_code = signr;
  798. if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
  799.       SA_NOCLDSTOP))
  800. notify_parent(current, SIGCHLD);
  801. schedule();
  802. continue;
  804. case SIGQUIT: case SIGILL: case SIGTRAP:
  805. case SIGABRT: case SIGFPE: case SIGSEGV:
  806. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  807. if (do_coredump(signr, regs))
  808. exit_code |= 0x80;
  809. #ifdef DEBUG_SIGNALS
  810. /* Very useful to debug the dynamic linker */
  811. printk ("Sig %d going...n", (int)signr);
  812. show_regs (regs);
  813. #ifdef DEBUG_SIGNALS_TRACE
  814. {
  815. struct reg_window *rw = (struct reg_window *)(regs->u_regs[UREG_FP] + STACK_BIAS);
  816. unsigned long ins[8];
  817.                                                 
  818. while (rw &&
  819.        !(((unsigned long) rw) & 0x3)) {
  820.         copy_from_user(ins, &rw->ins[0], sizeof(ins));
  821. printk("Caller[%016lx](%016lx,%016lx,%016lx,%016lx,%016lx,%016lx)n", ins[7], ins[0], ins[1], ins[2], ins[3], ins[4], ins[5]);
  822. rw = (struct reg_window *)(unsigned long)(ins[6] + STACK_BIAS);
  823. }
  824. }
  825. #endif
  826. #ifdef DEBUG_SIGNALS_MAPS
  827. printk("Maps:n");
  828. read_maps();
  829. #endif
  830. #endif
  831. /* fall through */
  832. default:
  833. sig_exit(signr, exit_code, &info);
  834. /* NOT REACHED */
  835. }
  836. }
  837. if (restart_syscall)
  838. syscall_restart(orig_i0, regs, &ka->sa);
  839. handle_signal(signr, ka, &info, oldset, regs);
  840. return 1;
  841. }
  842. if (restart_syscall &&
  843.     (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
  844.      regs->u_regs[UREG_I0] == ERESTARTSYS ||
  845.      regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
  846. /* replay the system call when we are done */
  847. regs->u_regs[UREG_I0] = orig_i0;
  848. regs->tpc -= 4;
  849. regs->tnpc -= 4;
  850. }
  851. return 0;
  852. }