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

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

嵌入式Linux

开发平台：

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. sigset_t set;
  415. stack_t st;
  416. int err;
  418. synchronize_user_stack ();
  419. sf = (struct rt_signal_frame *)
  420. (regs->u_regs [UREG_FP] + STACK_BIAS);
  422. /* 1. Make sure we are not getting garbage from the user */
  423. if (((unsigned long) sf) & 3)
  424. goto segv;
  426. err = get_user(tpc, &sf->regs.tpc);
  427. err |= __get_user(tnpc, &sf->regs.tnpc);
  428. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  429. tpc &= 0xffffffff;
  430. tnpc &= 0xffffffff;
  431. }
  432. err |= ((tpc | tnpc) & 3);
  434. /* 2. Restore the state */
  435. err |= __get_user(regs->y, &sf->regs.y);
  436. err |= __get_user(tstate, &sf->regs.tstate);
  437. err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));
  439. /* User can only change condition codes in %tstate. */
  440. regs->tstate &= ~(TSTATE_ICC);
  441. regs->tstate |= (tstate & TSTATE_ICC);
  443. err |= __get_user(fpu_save, &sf->fpu_save);
  444. if (fpu_save)
  445. err |= restore_fpu_state(regs, &sf->fpu_state);
  447. err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
  448. err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
  450. if (err)
  451. goto segv;
  453. regs->tpc = tpc;
  454. regs->tnpc = tnpc;
  456. /* It is more difficult to avoid calling this function than to
  457.    call it and ignore errors.  */
  458. do_sigaltstack(&st, NULL, (unsigned long)sf);
  460. sigdelsetmask(&set, ~_BLOCKABLE);
  461. spin_lock_irq(&current->sigmask_lock);
  462. current->blocked = set;
  463. recalc_sigpending(current);
  464. spin_unlock_irq(&current->sigmask_lock);
  465. return;
  466. segv:
  467. send_sig(SIGSEGV, current, 1);
  468. }
  470. /* Checks if the fp is valid */
  471. static int invalid_frame_pointer(void *fp, int fplen)
  472. {
  473. if (((unsigned long) fp) & 7)
  474. return 1;
  475. return 0;
  476. }
  478. static inline int
  479. save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
  480. {
  481. unsigned long *fpregs = (unsigned long *)(regs+1);
  482. unsigned long fprs;
  483. int err = 0;
  485. fprs = current->thread.fpsaved[0];
  486. if (fprs & FPRS_DL)
  487. err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
  488.     (sizeof(unsigned int) * 32));
  489. if (fprs & FPRS_DU)
  490. err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
  491.     (sizeof(unsigned int) * 32));
  492. err |= __put_user(current->thread.xfsr[0], &fpu->si_fsr);
  493. err |= __put_user(current->thread.gsr[0], &fpu->si_gsr);
  494. err |= __put_user(fprs, &fpu->si_fprs);
  496. return err;
  497. }
  499. static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
  500. {
  501. unsigned long sp;
  503. sp = regs->u_regs[UREG_FP] + STACK_BIAS;
  505. /* This is the X/Open sanctioned signal stack switching.  */
  506. if (ka->sa.sa_flags & SA_ONSTACK) {
  507. if (!on_sig_stack(sp) &&
  508.     !((current->sas_ss_sp + current->sas_ss_size) & 7))
  509. sp = current->sas_ss_sp + current->sas_ss_size;
  510. }
  511. return (void *)(sp - framesize);
  512. }
  514. static inline void
  515. setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
  516.        int signo, sigset_t *oldset, siginfo_t *info)
  517. {
  518. struct rt_signal_frame *sf;
  519. int sigframe_size, err;
  521. /* 1. Make sure everything is clean */
  522. synchronize_user_stack();
  523. save_and_clear_fpu();
  525. sigframe_size = RT_ALIGNEDSZ;
  526. if (!(current->thread.fpsaved[0] & FPRS_FEF))
  527. sigframe_size -= sizeof(__siginfo_fpu_t);
  529. sf = (struct rt_signal_frame *)get_sigframe(ka, regs, sigframe_size);
  531. if (invalid_frame_pointer (sf, sigframe_size))
  532. goto sigill;
  534. if (current->thread.w_saved != 0) {
  535. #ifdef DEBUG_SIGNALS
  536. printk ("%s[%d]: Invalid user stack frame for "
  537. "signal delivery.n", current->comm, current->pid);
  538. #endif
  539. goto sigill;
  540. }
  542. /* 2. Save the current process state */
  543. err = copy_to_user(&sf->regs, regs, sizeof (*regs));
  545. if (current->thread.fpsaved[0] & FPRS_FEF) {
  546. err |= save_fpu_state(regs, &sf->fpu_state);
  547. err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
  548. } else {
  549. err |= __put_user(0, &sf->fpu_save);
  550. }
  552. /* Setup sigaltstack */
  553. err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
  554. err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
  555. err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
  557. err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
  559. err |= copy_in_user((u64 *)sf,
  560.     (u64 *)(regs->u_regs[UREG_FP]+STACK_BIAS),
  561.     sizeof(struct reg_window));
  563. if (info)
  564. err |= copy_siginfo_to_user(&sf->info, info);
  565. else {
  566. err |= __put_user(signo, &sf->info.si_signo);
  567. err |= __put_user(SI_NOINFO, &sf->info.si_code);
  568. }
  569. if (err)
  570. goto sigsegv;
  572. /* 3. signal handler back-trampoline and parameters */
  573. regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
  574. regs->u_regs[UREG_I0] = signo;
  575. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  577. /* 5. signal handler */
  578. regs->tpc = (unsigned long) ka->sa.sa_handler;
  579. regs->tnpc = (regs->tpc + 4);
  580. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  581. regs->tpc &= 0xffffffff;
  582. regs->tnpc &= 0xffffffff;
  583. }
  584. /* 4. return to kernel instructions */
  585. regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  586. return;
  588. sigill:
  589. do_exit(SIGILL);
  590. sigsegv:
  591. do_exit(SIGSEGV);
  592. }
  594. static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
  595.  siginfo_t *info,
  596.  sigset_t *oldset, struct pt_regs *regs)
  597. {
  598. setup_rt_frame(ka, regs, signr, oldset, (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL);
  599. if(ka->sa.sa_flags & SA_ONESHOT)
  600. ka->sa.sa_handler = SIG_DFL;
  601. if(!(ka->sa.sa_flags & SA_NOMASK)) {
  602. spin_lock_irq(&current->sigmask_lock);
  603. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  604. sigaddset(&current->blocked,signr);
  605. recalc_sigpending(current);
  606. spin_unlock_irq(&current->sigmask_lock);
  607. }
  608. }
  610. static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
  611.      struct sigaction *sa)
  612. {
  613. switch(regs->u_regs[UREG_I0]) {
  614. case ERESTARTNOHAND:
  615. no_system_call_restart:
  616. regs->u_regs[UREG_I0] = EINTR;
  617. regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
  618. break;
  619. case ERESTARTSYS:
  620. if(!(sa->sa_flags & SA_RESTART))
  621. goto no_system_call_restart;
  622. /* fallthrough */
  623. case ERESTARTNOINTR:
  624. regs->u_regs[UREG_I0] = orig_i0;
  625. regs->tpc -= 4;
  626. regs->tnpc -= 4;
  627. }
  628. }
  630. #ifdef DEBUG_SIGNALS_MAPS
  632. #define MAPS_LINE_FORMAT   "%016lx-%016lx %s %016lx %s %lu "
  634. static inline void read_maps (void)
  635. {
  636. struct vm_area_struct * map, * next;
  637. char * buffer;
  638. ssize_t i;
  640. buffer = (char*)__get_free_page(GFP_KERNEL);
  641. if (!buffer)
  642. return;
  644. for (map = current->mm->mmap ; map ; map = next ) {
  645. /* produce the next line */
  646. char *line;
  647. char str[5], *cp = str;
  648. int flags;
  649. kdev_t dev;
  650. unsigned long ino;
  652. /*
  653.  * Get the next vma now (but it won't be used if we sleep).
  654.  */
  655. next = map->vm_next;
  656. flags = map->vm_flags;
  658. *cp++ = flags & VM_READ ? 'r' : '-';
  659. *cp++ = flags & VM_WRITE ? 'w' : '-';
  660. *cp++ = flags & VM_EXEC ? 'x' : '-';
  661. *cp++ = flags & VM_MAYSHARE ? 's' : 'p';
  662. *cp++ = 0;
  664. dev = 0;
  665. ino = 0;
  666. if (map->vm_file != NULL) {
  667. dev = map->vm_file->f_dentry->d_inode->i_dev;
  668. ino = map->vm_file->f_dentry->d_inode->i_ino;
  669. line = d_path(map->vm_file->f_dentry,
  670.       map->vm_file->f_vfsmnt,
  671.       buffer, PAGE_SIZE);
  672. }
  673. printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT,
  674.       kdevname(dev), ino);
  675. if (map->vm_file != NULL)
  676. printk("%sn", line);
  677. else
  678. printk("n");
  679. }
  680. free_page((unsigned long)buffer);
  681. return;
  682. }
  684. #endif
  686. /* Note that 'init' is a special process: it doesn't get signals it doesn't
  687.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  688.  * mistake.
  689.  */
  690. asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
  691.  unsigned long orig_i0, int restart_syscall)
  692. {
  693. unsigned long signr;
  694. siginfo_t info;
  695. struct k_sigaction *ka;
  697. if (!oldset)
  698. oldset = &current->blocked;
  700. #ifdef CONFIG_SPARC32_COMPAT
  701. if (current->thread.flags & SPARC_FLAG_32BIT) {
  702. extern asmlinkage int do_signal32(sigset_t *, struct pt_regs *,
  703.   unsigned long, int);
  704. return do_signal32(oldset, regs, orig_i0, restart_syscall);
  705. }
  706. #endif
  707. for (;;) {
  708. spin_lock_irq(&current->sigmask_lock);
  709. signr = dequeue_signal(&current->blocked, &info);
  710. spin_unlock_irq(&current->sigmask_lock);
  712. if (!signr) break;
  714. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  715. current->exit_code = signr;
  716. current->state = TASK_STOPPED;
  717. notify_parent(current, SIGCHLD);
  718. schedule();
  719. if (!(signr = current->exit_code))
  720. continue;
  721. current->exit_code = 0;
  722. if (signr == SIGSTOP)
  723. continue;
  725. /* Update the siginfo structure.  Is this good?  */
  726. if (signr != info.si_signo) {
  727. info.si_signo = signr;
  728. info.si_errno = 0;
  729. info.si_code = SI_USER;
  730. info.si_pid = current->p_pptr->pid;
  731. info.si_uid = current->p_pptr->uid;
  732. }
  734. /* If the (new) signal is now blocked, requeue it.  */
  735. if (sigismember(&current->blocked, signr)) {
  736. send_sig_info(signr, &info, current);
  737. continue;
  738. }
  739. }
  741. ka = &current->sig->action[signr-1];
  743. if(ka->sa.sa_handler == SIG_IGN) {
  744. if(signr != SIGCHLD)
  745. continue;
  747.                         /* sys_wait4() grabs the master kernel lock, so
  748.                          * we need not do so, that sucker should be
  749.                          * threaded and would not be that difficult to
  750.                          * do anyways.
  751.                          */
  752.                         while(sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  753.                                 ;
  754. continue;
  755. }
  756. if(ka->sa.sa_handler == SIG_DFL) {
  757. unsigned long exit_code = signr;
  759. if(current->pid == 1)
  760. continue;
  761. switch(signr) {
  762. case SIGCONT: case SIGCHLD: case SIGWINCH:
  763. continue;
  765. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  766. if (is_orphaned_pgrp(current->pgrp))
  767. continue;
  769. case SIGSTOP:
  770. if (current->ptrace & PT_PTRACED)
  771. continue;
  772. current->state = TASK_STOPPED;
  773. current->exit_code = signr;
  774. if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
  775.      SA_NOCLDSTOP))
  776. notify_parent(current, SIGCHLD);
  777. schedule();
  778. continue;
  780. case SIGQUIT: case SIGILL: case SIGTRAP:
  781. case SIGABRT: case SIGFPE: case SIGSEGV:
  782. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  783. if (do_coredump(signr, regs))
  784. exit_code |= 0x80;
  785. #ifdef DEBUG_SIGNALS
  786. /* Very useful to debug the dynamic linker */
  787. printk ("Sig %d going...n", (int)signr);
  788. show_regs (regs);
  789. #ifdef DEBUG_SIGNALS_TRACE
  790. {
  791. struct reg_window *rw = (struct reg_window *)(regs->u_regs[UREG_FP] + STACK_BIAS);
  792. unsigned long ins[8];
  793.                                                 
  794. while(rw &&
  795.       !(((unsigned long) rw) & 0x3)) {
  796.         copy_from_user(ins, &rw->ins[0], sizeof(ins));
  797. printk("Caller[%016lx](%016lx,%016lx,%016lx,%016lx,%016lx,%016lx)n", ins[7], ins[0], ins[1], ins[2], ins[3], ins[4], ins[5]);
  798. rw = (struct reg_window *)(unsigned long)(ins[6] + STACK_BIAS);
  799. }
  800. }
  801. #endif
  802. #ifdef DEBUG_SIGNALS_MAPS
  803. printk("Maps:n");
  804. read_maps();
  805. #endif
  806. #endif
  807. /* fall through */
  808. default:
  809. sigaddset(&current->pending.signal, signr);
  810. recalc_sigpending(current);
  811. current->flags |= PF_SIGNALED;
  812. do_exit(exit_code);
  813. /* NOT REACHED */
  814. }
  815. }
  816. if(restart_syscall)
  817. syscall_restart(orig_i0, regs, &ka->sa);
  818. handle_signal(signr, ka, &info, oldset, regs);
  819. return 1;
  820. }
  821. if(restart_syscall &&
  822.    (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
  823.     regs->u_regs[UREG_I0] == ERESTARTSYS ||
  824.     regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
  825. /* replay the system call when we are done */
  826. regs->u_regs[UREG_I0] = orig_i0;
  827. regs->tpc -= 4;
  828. regs->tnpc -= 4;
  829. }
  830. return 0;
  831. }