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

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

嵌入式Linux

开发平台：

Unix_Linux

signal32.c：源码内容
  1. /*  $Id: signal32.c,v 1.70 2001/04/24 01:09:12 davem Exp $
  2.  *  arch/sparc64/kernel/signal32.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/sched.h>
  12. #include <linux/kernel.h>
  13. #include <linux/signal.h>
  14. #include <linux/errno.h>
  15. #include <linux/wait.h>
  16. #include <linux/ptrace.h>
  17. #include <linux/unistd.h>
  18. #include <linux/mm.h>
  19. #include <linux/smp_lock.h>
  21. #include <asm/uaccess.h>
  22. #include <asm/bitops.h>
  23. #include <asm/ptrace.h>
  24. #include <asm/svr4.h>
  25. #include <asm/pgtable.h>
  26. #include <asm/psrcompat.h>
  27. #include <asm/fpumacro.h>
  28. #include <asm/visasm.h>
  30. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  32. asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs,
  33.  unsigned long orig_o0, int ret_from_syscall);
  35. /* This turned off for production... */
  36. /* #define DEBUG_SIGNALS 1 */
  37. /* #define DEBUG_SIGNALS_TRACE 1 */
  38. /* #define DEBUG_SIGNALS_MAPS 1 */
  39. /* #define DEBUG_SIGNALS_TLB 1 */
  41. /* Signal frames: the original one (compatible with SunOS):
  42.  *
  43.  * Set up a signal frame... Make the stack look the way SunOS
  44.  * expects it to look which is basically:
  45.  *
  46.  * ---------------------------------- <-- %sp at signal time
  47.  * Struct sigcontext
  48.  * Signal address
  49.  * Ptr to sigcontext area above
  50.  * Signal code
  51.  * The signal number itself
  52.  * One register window
  53.  * ---------------------------------- <-- New %sp
  54.  */
  55. struct signal_sframe32 {
  56. struct reg_window32 sig_window;
  57. int sig_num;
  58. int sig_code;
  59. /* struct sigcontext32 * */ u32 sig_scptr;
  60. int sig_address;
  61. struct sigcontext32 sig_context;
  62. unsigned extramask[_NSIG_WORDS32 - 1];
  63. };
  65. /* 
  66.  * And the new one, intended to be used for Linux applications only
  67.  * (we have enough in there to work with clone).
  68.  * All the interesting bits are in the info field.
  69.  */
  70. struct new_signal_frame32 {
  71. struct sparc_stackf32 ss;
  72. __siginfo32_t info;
  73. /* __siginfo_fpu32_t * */ u32 fpu_save;
  74. unsigned int insns [2];
  75. unsigned extramask[_NSIG_WORDS32 - 1];
  76. unsigned extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  77. /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  78. siginfo_extra_v8plus_t v8plus;
  79. __siginfo_fpu_t fpu_state;
  80. };
  82. struct rt_signal_frame32 {
  83. struct sparc_stackf32 ss;
  84. siginfo_t32 info;
  85. struct pt_regs32 regs;
  86. sigset_t32 mask;
  87. /* __siginfo_fpu32_t * */ u32 fpu_save;
  88. unsigned int insns [2];
  89. stack_t32 stack;
  90. unsigned extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  91. /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  92. siginfo_extra_v8plus_t v8plus;
  93. __siginfo_fpu_t fpu_state;
  94. };
  96. /* Align macros */
  97. #define SF_ALIGNEDSZ  (((sizeof(struct signal_sframe32) + 7) & (~7)))
  98. #define NF_ALIGNEDSZ  (((sizeof(struct new_signal_frame32) + 7) & (~7)))
  99. #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
  101. int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
  102. {
  103. int err;
  105. if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
  106. return -EFAULT;
  108. /* If you change siginfo_t structure, please be sure
  109.    this code is fixed accordingly.
  110.    It should never copy any pad contained in the structure
  111.    to avoid security leaks, but must copy the generic
  112.    3 ints plus the relevant union member.
  113.    This routine must convert siginfo from 64bit to 32bit as well
  114.    at the same time.  */
  115. err = __put_user(from->si_signo, &to->si_signo);
  116. err |= __put_user(from->si_errno, &to->si_errno);
  117. err |= __put_user((short)from->si_code, &to->si_code);
  118. if (from->si_code < 0)
  119. err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  120. else {
  121. switch (from->si_code >> 16) {
  122. case __SI_CHLD >> 16:
  123. err |= __put_user(from->si_utime, &to->si_utime);
  124. err |= __put_user(from->si_stime, &to->si_stime);
  125. err |= __put_user(from->si_status, &to->si_status);
  126. default:
  127. err |= __put_user(from->si_pid, &to->si_pid);
  128. err |= __put_user(from->si_uid, &to->si_uid);
  129. break;
  130. case __SI_FAULT >> 16:
  131. case __SI_POLL >> 16:
  132. err |= __put_user(from->si_trapno, &to->si_trapno);
  133. err |= __put_user((long)from->si_addr, &to->si_addr);
  134. break;
  135. /* case __SI_RT: This is not generated by the kernel as of now.  */
  136. }
  137. }
  138. return err;
  139. }
  141. /*
  142.  * atomically swap in the new signal mask, and wait for a signal.
  143.  * This is really tricky on the Sparc, watch out...
  144.  */
  145. asmlinkage void _sigpause32_common(old_sigset_t32 set, struct pt_regs *regs)
  146. {
  147. sigset_t saveset;
  149. set &= _BLOCKABLE;
  150. spin_lock_irq(&current->sigmask_lock);
  151. saveset = current->blocked;
  152. siginitset(&current->blocked, set);
  153. recalc_sigpending(current);
  154. spin_unlock_irq(&current->sigmask_lock);
  156. regs->tpc = regs->tnpc;
  157. regs->tnpc += 4;
  158. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  159. regs->tpc &= 0xffffffff;
  160. regs->tnpc &= 0xffffffff;
  161. }
  163. /* Condition codes and return value where set here for sigpause,
  164.  * and so got used by setup_frame, which again causes sigreturn()
  165.  * to return -EINTR.
  166.  */
  167. while (1) {
  168. current->state = TASK_INTERRUPTIBLE;
  169. schedule();
  170. /*
  171.  * Return -EINTR and set condition code here,
  172.  * so the interrupted system call actually returns
  173.  * these.
  174.  */
  175. regs->tstate |= TSTATE_ICARRY;
  176. regs->u_regs[UREG_I0] = EINTR;
  177. if (do_signal32(&saveset, regs, 0, 0))
  178. return;
  179. }
  180. }
  182. asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *regs)
  183. {
  184. sigset_t oldset, set;
  185. sigset_t32 set32;
  186.         
  187. /* XXX: Don't preclude handling different sized sigset_t's.  */
  188. if (((__kernel_size_t32)sigsetsize) != sizeof(sigset_t)) {
  189. regs->tstate |= TSTATE_ICARRY;
  190. regs->u_regs[UREG_I0] = EINVAL;
  191. return;
  192. }
  193. if (copy_from_user(&set32, (void *)(long)uset, sizeof(set32))) {
  194. regs->tstate |= TSTATE_ICARRY;
  195. regs->u_regs[UREG_I0] = EFAULT;
  196. return;
  197. }
  198. switch (_NSIG_WORDS) {
  199. case 4: set.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
  200. case 3: set.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
  201. case 2: set.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
  202. case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
  203. }
  204. sigdelsetmask(&set, ~_BLOCKABLE);
  205. spin_lock_irq(&current->sigmask_lock);
  206. oldset = current->blocked;
  207. current->blocked = set;
  208. recalc_sigpending(current);
  209. spin_unlock_irq(&current->sigmask_lock);
  211. regs->tpc = regs->tnpc;
  212. regs->tnpc += 4;
  213. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  214. regs->tpc &= 0xffffffff;
  215. regs->tnpc &= 0xffffffff;
  216. }
  218. /* Condition codes and return value where set here for sigpause,
  219.  * and so got used by setup_frame, which again causes sigreturn()
  220.  * to return -EINTR.
  221.  */
  222. while (1) {
  223. current->state = TASK_INTERRUPTIBLE;
  224. schedule();
  225. /*
  226.  * Return -EINTR and set condition code here,
  227.  * so the interrupted system call actually returns
  228.  * these.
  229.  */
  230. regs->tstate |= TSTATE_ICARRY;
  231. regs->u_regs[UREG_I0] = EINTR;
  232. if (do_signal32(&oldset, regs, 0, 0))
  233. return;
  234. }
  235. }
  237. static inline int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t *fpu)
  238. {
  239. unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  240. unsigned long fprs;
  241. int err;
  243. err = __get_user(fprs, &fpu->si_fprs);
  244. fprs_write(0);
  245. regs->tstate &= ~TSTATE_PEF;
  246. if (fprs & FPRS_DL)
  247. err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
  248. if (fprs & FPRS_DU)
  249. err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
  250. err |= __get_user(current->thread.xfsr[0], &fpu->si_fsr);
  251. err |= __get_user(current->thread.gsr[0], &fpu->si_gsr);
  252. current->thread.fpsaved[0] |= fprs;
  253. return err;
  254. }
  256. void do_new_sigreturn32(struct pt_regs *regs)
  257. {
  258. struct new_signal_frame32 *sf;
  259. unsigned int psr;
  260. unsigned pc, npc, fpu_save;
  261. sigset_t set;
  262. unsigned seta[_NSIG_WORDS32];
  263. int err, i;
  265. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  266. sf = (struct new_signal_frame32 *) regs->u_regs [UREG_FP];
  268. /* 1. Make sure we are not getting garbage from the user */
  269. if (verify_area (VERIFY_READ, sf, sizeof (*sf)) ||
  270.     (((unsigned long) sf) & 3))
  271. goto segv;
  273. get_user(pc, &sf->info.si_regs.pc);
  274. __get_user(npc, &sf->info.si_regs.npc);
  276. if ((pc | npc) & 3)
  277. goto segv;
  279. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  280. pc &= 0xffffffff;
  281. npc &= 0xffffffff;
  282. }
  283. regs->tpc = pc;
  284. regs->tnpc = npc;
  286. /* 2. Restore the state */
  287. err = __get_user(regs->y, &sf->info.si_regs.y);
  288. err |= __get_user(psr, &sf->info.si_regs.psr);
  290. for (i = UREG_G1; i <= UREG_I7; i++)
  291. err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
  292. if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
  293. err |= __get_user(i, &sf->v8plus.g_upper[0]);
  294. if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
  295. for (i = UREG_G1; i <= UREG_I7; i++)
  296. err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
  297. }
  298. }
  300. /* User can only change condition codes in %tstate. */
  301. regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
  302. regs->tstate |= psr_to_tstate_icc(psr);
  304. err |= __get_user(fpu_save, &sf->fpu_save);
  305. if (fpu_save)
  306. err |= restore_fpu_state32(regs, &sf->fpu_state);
  307. err |= __get_user(seta[0], &sf->info.si_mask);
  308. err |= copy_from_user(seta+1, &sf->extramask, (_NSIG_WORDS32 - 1) * sizeof(unsigned));
  309. if (err)
  310.      goto segv;
  311. switch (_NSIG_WORDS) {
  312. case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
  313. case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
  314. case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
  315. case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
  316. }
  317. sigdelsetmask(&set, ~_BLOCKABLE);
  318. spin_lock_irq(&current->sigmask_lock);
  319. current->blocked = set;
  320. recalc_sigpending(current);
  321. spin_unlock_irq(&current->sigmask_lock);
  322. return;
  324. segv:
  325. do_exit(SIGSEGV);
  326. }
  328. asmlinkage void do_sigreturn32(struct pt_regs *regs)
  329. {
  330. struct sigcontext32 *scptr;
  331. unsigned pc, npc, psr;
  332. sigset_t set;
  333. unsigned seta[_NSIG_WORDS32];
  334. int err;
  336. synchronize_user_stack();
  337. if (current->thread.flags & SPARC_FLAG_NEWSIGNALS)
  338. return do_new_sigreturn32(regs);
  340. scptr = (struct sigcontext32 *)
  341. (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
  342. /* Check sanity of the user arg. */
  343. if(verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
  344.    (((unsigned long) scptr) & 3))
  345. goto segv;
  347. err = __get_user(pc, &scptr->sigc_pc);
  348. err |= __get_user(npc, &scptr->sigc_npc);
  350. if((pc | npc) & 3)
  351. goto segv; /* Nice try. */
  353. err |= __get_user(seta[0], &scptr->sigc_mask);
  354. /* Note that scptr + 1 points to extramask */
  355. err |= copy_from_user(seta+1, scptr + 1, (_NSIG_WORDS32 - 1) * sizeof(unsigned));
  356. if (err)
  357.      goto segv;
  358. switch (_NSIG_WORDS) {
  359. case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
  360. case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
  361. case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
  362. case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
  363. }
  364. sigdelsetmask(&set, ~_BLOCKABLE);
  365. spin_lock_irq(&current->sigmask_lock);
  366. current->blocked = set;
  367. recalc_sigpending(current);
  368. spin_unlock_irq(&current->sigmask_lock);
  370. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  371. pc &= 0xffffffff;
  372. npc &= 0xffffffff;
  373. }
  374. regs->tpc = pc;
  375. regs->tnpc = npc;
  376. err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
  377. err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
  378. err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
  380. /* User can only change condition codes in %tstate. */
  381. err |= __get_user(psr, &scptr->sigc_psr);
  382. if (err)
  383. goto segv;
  384. regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
  385. regs->tstate |= psr_to_tstate_icc(psr);
  386. return;
  388. segv:
  389. do_exit(SIGSEGV);
  390. }
  392. asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
  393. {
  394. struct rt_signal_frame32 *sf;
  395. unsigned int psr;
  396. unsigned pc, npc, fpu_save;
  397. sigset_t set;
  398. sigset_t32 seta;
  399. stack_t st;
  400. int err, i;
  402. synchronize_user_stack();
  403. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  404. sf = (struct rt_signal_frame32 *) regs->u_regs [UREG_FP];
  406. /* 1. Make sure we are not getting garbage from the user */
  407. if (verify_area (VERIFY_READ, sf, sizeof (*sf)) ||
  408.     (((unsigned long) sf) & 3))
  409. goto segv;
  411. get_user(pc, &sf->regs.pc);
  412. __get_user(npc, &sf->regs.npc);
  414. if ((pc | npc) & 3)
  415. goto segv;
  417. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  418. pc &= 0xffffffff;
  419. npc &= 0xffffffff;
  420. }
  421. regs->tpc = pc;
  422. regs->tnpc = npc;
  424. /* 2. Restore the state */
  425. err = __get_user(regs->y, &sf->regs.y);
  426. err |= __get_user(psr, &sf->regs.psr);
  428. for (i = UREG_G1; i <= UREG_I7; i++)
  429. err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
  430. if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
  431. err |= __get_user(i, &sf->v8plus.g_upper[0]);
  432. if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
  433. for (i = UREG_G1; i <= UREG_I7; i++)
  434. err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
  435. }
  436. }
  438. /* User can only change condition codes in %tstate. */
  439. regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
  440. regs->tstate |= psr_to_tstate_icc(psr);
  442. err |= __get_user(fpu_save, &sf->fpu_save);
  443. if (fpu_save)
  444. err |= restore_fpu_state32(regs, &sf->fpu_state);
  445. err |= copy_from_user(&seta, &sf->mask, sizeof(sigset_t32));
  446. err |= __get_user((long)st.ss_sp, &sf->stack.ss_sp);
  447. err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
  448. err |= __get_user(st.ss_size, &sf->stack.ss_size);
  449. if (err)
  450. goto segv;
  452. /* It is more difficult to avoid calling this function than to
  453.    call it and ignore errors.  */
  454. do_sigaltstack(&st, NULL, (unsigned long)sf);
  456. switch (_NSIG_WORDS) {
  457. case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
  458. case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
  459. case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
  460. case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
  461. }
  462. sigdelsetmask(&set, ~_BLOCKABLE);
  463. spin_lock_irq(&current->sigmask_lock);
  464. current->blocked = set;
  465. recalc_sigpending(current);
  466. spin_unlock_irq(&current->sigmask_lock);
  467. return;
  468. segv:
  469. do_exit(SIGSEGV);
  470. }
  472. /* Checks if the fp is valid */
  473. static int invalid_frame_pointer(void *fp, int fplen)
  474. {
  475. if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
  476. return 1;
  477. return 0;
  478. }
  480. static inline void *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
  481. {
  482. unsigned long sp;
  484. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  485. sp = regs->u_regs[UREG_FP];
  487. /* This is the X/Open sanctioned signal stack switching.  */
  488. if (sa->sa_flags & SA_ONSTACK) {
  489. if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
  490. sp = current->sas_ss_sp + current->sas_ss_size;
  491. }
  492. return (void *)(sp - framesize);
  493. }
  495. static void
  496. setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
  497. {
  498. struct signal_sframe32 *sframep;
  499. struct sigcontext32 *sc;
  500. unsigned seta[_NSIG_WORDS32];
  501. int err = 0;
  502. void *sig_address;
  503. int sig_code;
  504. unsigned long pc = regs->tpc;
  505. unsigned long npc = regs->tnpc;
  507. #if 0
  508. int window = 0;
  509. #endif
  510. unsigned psr;
  512. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  513. pc &= 0xffffffff;
  514. npc &= 0xffffffff;
  515. }
  517. synchronize_user_stack();
  518. save_and_clear_fpu();
  520. sframep = (struct signal_sframe32 *)get_sigframe(sa, regs, SF_ALIGNEDSZ);
  521. if (invalid_frame_pointer (sframep, sizeof(*sframep))){
  522. #ifdef DEBUG_SIGNALS /* fills up the console logs during crashme runs, yuck... */
  523. printk("%s [%d]: User has trashed signal stackn",
  524.        current->comm, current->pid);
  525. printk("Sigstack ptr %p handler at pc<%016lx> for sig<%d>n",
  526.        sframep, pc, signr);
  527. #endif
  528. /* Don't change signal code and address, so that
  529.  * post mortem debuggers can have a look.
  530.  */
  531. do_exit(SIGILL);
  532. }
  534. sc = &sframep->sig_context;
  536. /* We've already made sure frame pointer isn't in kernel space... */
  537. err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
  538.  &sc->sigc_onstack);
  540. switch (_NSIG_WORDS) {
  541. case 4: seta[7] = (oldset->sig[3] >> 32);
  542.         seta[6] = oldset->sig[3];
  543. case 3: seta[5] = (oldset->sig[2] >> 32);
  544.         seta[4] = oldset->sig[2];
  545. case 2: seta[3] = (oldset->sig[1] >> 32);
  546.         seta[2] = oldset->sig[1];
  547. case 1: seta[1] = (oldset->sig[0] >> 32);
  548.         seta[0] = oldset->sig[0];
  549. }
  550. err |= __put_user(seta[0], &sc->sigc_mask);
  551. err |= __copy_to_user(sframep->extramask, seta + 1,
  552.       (_NSIG_WORDS32 - 1) * sizeof(unsigned));
  553. err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
  554. err |= __put_user(pc, &sc->sigc_pc);
  555. err |= __put_user(npc, &sc->sigc_npc);
  556. psr = tstate_to_psr (regs->tstate);
  557. if(current->thread.fpsaved[0] & FPRS_FEF)
  558. psr |= PSR_EF;
  559. err |= __put_user(psr, &sc->sigc_psr);
  560. err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
  561. err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
  562. err |= __put_user(current->thread.w_saved, &sc->sigc_oswins);
  563. #if 0
  564. /* w_saved is not currently used... */
  565. if(current->thread.w_saved)
  566. for(window = 0; window < current->thread.w_saved; window++) {
  567. sc->sigc_spbuf[window] =
  568. (char *)current->thread.rwbuf_stkptrs[window];
  569. err |= copy_to_user(&sc->sigc_wbuf[window],
  570.     &current->thread.reg_window[window],
  571.     sizeof(struct reg_window));
  572. }
  573. else
  574. #endif
  575. err |= copy_in_user((u32 *)sframep,
  576.     (u32 *)(regs->u_regs[UREG_FP]),
  577.     sizeof(struct reg_window32));
  578.        
  579. current->thread.w_saved = 0; /* So process is allowed to execute. */
  580. err |= __put_user(signr, &sframep->sig_num);
  581. sig_address = NULL;
  582. sig_code = 0;
  583. if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
  584. sig_address = info->si_addr;
  585. switch (signr) {
  586. case SIGSEGV:
  587. switch (info->si_code) {
  588. case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
  589. default: sig_code = SUBSIG_PROTECTION; break;
  590. }
  591. break;
  592. case SIGILL:
  593. switch (info->si_code) {
  594. case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
  595. case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
  596. case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP (info->si_trapno); break;
  597. default: sig_code = SUBSIG_STACK; break;
  598. }
  599. break;
  600. case SIGFPE:
  601. switch (info->si_code) {
  602. case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
  603. case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
  604. case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
  605. case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
  606. case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
  607. case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
  608. case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
  609. default: sig_code = SUBSIG_FPERROR; break;
  610. }
  611. break;
  612. case SIGBUS:
  613. switch (info->si_code) {
  614. case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
  615. case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
  616. default: sig_code = SUBSIG_BUSTIMEOUT; break;
  617. }
  618. break;
  619. case SIGEMT:
  620. switch (info->si_code) {
  621. case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
  622. }
  623. break;
  624. case SIGSYS:
  625. if (info->si_code == (__SI_FAULT|0x100)) {
  626. /* See sys_sunos32.c */
  627. sig_code = info->si_trapno;
  628. break;
  629. }
  630. default:
  631. sig_address = NULL;
  632. }
  633. }
  634. err |= __put_user((long)sig_address, &sframep->sig_address);
  635. err |= __put_user(sig_code, &sframep->sig_code);
  636. err |= __put_user((u64)sc, &sframep->sig_scptr);
  637. if (err)
  638. goto sigsegv;
  640. regs->u_regs[UREG_FP] = (unsigned long) sframep;
  641. regs->tpc = (unsigned long) sa->sa_handler;
  642. regs->tnpc = (regs->tpc + 4);
  643. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  644. regs->tpc &= 0xffffffff;
  645. regs->tnpc &= 0xffffffff;
  646. }
  647. return;
  649. sigsegv:
  650. do_exit(SIGSEGV);
  651. }
  654. static inline int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t *fpu)
  655. {
  656. unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  657. unsigned long fprs;
  658. int err = 0;
  660. fprs = current->thread.fpsaved[0];
  661. if (fprs & FPRS_DL)
  662. err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
  663.     (sizeof(unsigned int) * 32));
  664. if (fprs & FPRS_DU)
  665. err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
  666.     (sizeof(unsigned int) * 32));
  667. err |= __put_user(current->thread.xfsr[0], &fpu->si_fsr);
  668. err |= __put_user(current->thread.gsr[0], &fpu->si_gsr);
  669. err |= __put_user(fprs, &fpu->si_fprs);
  671. return err;
  672. }
  674. static inline void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
  675.      int signo, sigset_t *oldset)
  676. {
  677. struct new_signal_frame32 *sf;
  678. int sigframe_size;
  679. u32 psr;
  680. int i, err;
  681. unsigned seta[_NSIG_WORDS32];
  683. /* 1. Make sure everything is clean */
  684. synchronize_user_stack();
  685. save_and_clear_fpu();
  687. sigframe_size = NF_ALIGNEDSZ;
  688. if (!(current->thread.fpsaved[0] & FPRS_FEF))
  689. sigframe_size -= sizeof(__siginfo_fpu_t);
  691. sf = (struct new_signal_frame32 *)get_sigframe(&ka->sa, regs, sigframe_size);
  693. if (invalid_frame_pointer (sf, sigframe_size)) {
  694. #ifdef DEBUG_SIGNALS
  695. printk("new_setup_frame32(%s:%d): invalid_frame_pointer(%p, %d)n",
  696.        current->comm, current->pid, sf, sigframe_size);
  697. #endif
  698. goto sigill;
  699. }
  701. if (current->thread.w_saved != 0) {
  702. #ifdef DEBUG_SIGNALS
  703. printk ("%s[%d]: Invalid user stack frame for "
  704. "signal delivery.n", current->comm, current->pid);
  705. #endif
  706. goto sigill;
  707. }
  709. /* 2. Save the current process state */
  710. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  711. regs->tpc &= 0xffffffff;
  712. regs->tnpc &= 0xffffffff;
  713. }
  714. err  = put_user(regs->tpc, &sf->info.si_regs.pc);
  715. err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
  716. err |= __put_user(regs->y, &sf->info.si_regs.y);
  717. psr = tstate_to_psr (regs->tstate);
  718. if(current->thread.fpsaved[0] & FPRS_FEF)
  719. psr |= PSR_EF;
  720. err |= __put_user(psr, &sf->info.si_regs.psr);
  721. for (i = 0; i < 16; i++)
  722. err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
  723. err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
  724. err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
  725. for (i = 1; i < 16; i++)
  726. err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
  728. if (psr & PSR_EF) {
  729. err |= save_fpu_state32(regs, &sf->fpu_state);
  730. err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
  731. } else {
  732. err |= __put_user(0, &sf->fpu_save);
  733. }
  735. switch (_NSIG_WORDS) {
  736. case 4: seta[7] = (oldset->sig[3] >> 32);
  737.         seta[6] = oldset->sig[3];
  738. case 3: seta[5] = (oldset->sig[2] >> 32);
  739.         seta[4] = oldset->sig[2];
  740. case 2: seta[3] = (oldset->sig[1] >> 32);
  741.         seta[2] = oldset->sig[1];
  742. case 1: seta[1] = (oldset->sig[0] >> 32);
  743.         seta[0] = oldset->sig[0];
  744. }
  745. err |= __put_user(seta[0], &sf->info.si_mask);
  746. err |= __copy_to_user(sf->extramask, seta + 1,
  747.       (_NSIG_WORDS32 - 1) * sizeof(unsigned));
  749. err |= copy_in_user((u32 *)sf,
  750.     (u32 *)(regs->u_regs[UREG_FP]),
  751.     sizeof(struct reg_window32));
  753. if (err)
  754. goto sigsegv;
  756. /* 3. signal handler back-trampoline and parameters */
  757. regs->u_regs[UREG_FP] = (unsigned long) sf;
  758. regs->u_regs[UREG_I0] = signo;
  759. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  761. /* 4. signal handler */
  762. regs->tpc = (unsigned long) ka->sa.sa_handler;
  763. regs->tnpc = (regs->tpc + 4);
  764. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  765. regs->tpc &= 0xffffffff;
  766. regs->tnpc &= 0xffffffff;
  767. }
  769. /* 5. return to kernel instructions */
  770. if (ka->ka_restorer) {
  771. regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  772. } else {
  773. /* Flush instruction space. */
  774. unsigned long address = ((unsigned long)&(sf->insns[0]));
  775. pgd_t *pgdp = pgd_offset(current->mm, address);
  776. pmd_t *pmdp = pmd_offset(pgdp, address);
  777. pte_t *ptep = pte_offset(pmdp, address);
  779. regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
  781. err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
  782. err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
  783. if(err)
  784. goto sigsegv;
  786. if(pte_present(*ptep)) {
  787. unsigned long page = (unsigned long) page_address(pte_page(*ptep));
  789. __asm__ __volatile__(
  790. " membar #StoreStoren"
  791. " flush %0 + %1"
  792. : : "r" (page), "r" (address & (PAGE_SIZE - 1))
  793. : "memory");
  794. }
  795. }
  796. return;
  798. sigill:
  799. do_exit(SIGILL);
  800. sigsegv:
  801. do_exit(SIGSEGV);
  802. }
  804. /* Setup a Solaris stack frame */
  805. static inline void
  806. setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
  807.    struct pt_regs *regs, int signr, sigset_t *oldset)
  808. {
  809. svr4_signal_frame_t *sfp;
  810. svr4_gregset_t  *gr;
  811. svr4_siginfo_t  *si;
  812. svr4_mcontext_t *mc;
  813. svr4_gwindows_t *gw;
  814. svr4_ucontext_t *uc;
  815. svr4_sigset_t setv;
  816. #if 0
  817. int window = 0;
  818. #endif
  819. unsigned psr;
  820. int i, err;
  822. synchronize_user_stack();
  823. save_and_clear_fpu();
  825. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  826. sfp = (svr4_signal_frame_t *) get_sigframe(sa, regs, REGWIN_SZ + SVR4_SF_ALIGNED);
  828. if (invalid_frame_pointer (sfp, sizeof (*sfp))){
  829. #ifdef DEBUG_SIGNALS
  830. printk ("Invalid stack framen");
  831. #endif
  832. do_exit(SIGILL);
  833. }
  835. /* Start with a clean frame pointer and fill it */
  836. err = clear_user(sfp, sizeof (*sfp));
  838. /* Setup convenience variables */
  839. si = &sfp->si;
  840. uc = &sfp->uc;
  841. gw = &sfp->gw;
  842. mc = &uc->mcontext;
  843. gr = &mc->greg;
  845. /* FIXME: where am I supposed to put this?
  846.  * sc->sigc_onstack = old_status;
  847.  * anyways, it does not look like it is used for anything at all.
  848.  */
  849. setv.sigbits[0] = oldset->sig[0];
  850. setv.sigbits[1] = (oldset->sig[0] >> 32);
  851. if (_NSIG_WORDS >= 2) {
  852. setv.sigbits[2] = oldset->sig[1];
  853. setv.sigbits[3] = (oldset->sig[1] >> 32);
  854. err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
  855. } else
  856. err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
  858. /* Store registers */
  859. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  860. regs->tpc &= 0xffffffff;
  861. regs->tnpc &= 0xffffffff;
  862. }
  863. err |= __put_user(regs->tpc, &((*gr) [SVR4_PC]));
  864. err |= __put_user(regs->tnpc, &((*gr) [SVR4_NPC]));
  865. psr = tstate_to_psr (regs->tstate);
  866. if(current->thread.fpsaved[0] & FPRS_FEF)
  867. psr |= PSR_EF;
  868. err |= __put_user(psr, &((*gr) [SVR4_PSR]));
  869. err |= __put_user(regs->y, &((*gr) [SVR4_Y]));
  871. /* Copy g [1..7] and o [0..7] registers */
  872. for (i = 0; i < 7; i++)
  873. err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
  874. for (i = 0; i < 8; i++)
  875. err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
  877. /* Setup sigaltstack */
  878. err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
  879. err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
  880. err |= __put_user(current->sas_ss_size, &uc->stack.size);
  882. /* Save the currently window file: */
  884. /* 1. Link sfp->uc->gwins to our windows */
  885. err |= __put_user((u32)(long)gw, &mc->gwin);
  886.     
  887. /* 2. Number of windows to restore at setcontext (): */
  888. err |= __put_user(current->thread.w_saved, &gw->count);
  890. /* 3. Save each valid window
  891.  *    Currently, it makes a copy of the windows from the kernel copy.
  892.  *    David's code for SunOS, makes the copy but keeps the pointer to
  893.  *    the kernel.  My version makes the pointer point to a userland 
  894.  *    copy of those.  Mhm, I wonder if I shouldn't just ignore those
  895.  *    on setcontext and use those that are on the kernel, the signal
  896.  *    handler should not be modyfing those, mhm.
  897.  *
  898.  *    These windows are just used in case synchronize_user_stack failed
  899.  *    to flush the user windows.
  900.  */
  901. #if 0  
  902. for(window = 0; window < current->thread.w_saved; window++) {
  903. err |= __put_user((int *) &(gw->win [window]),
  904.   (int **)gw->winptr +window );
  905. err |= copy_to_user(&gw->win [window],
  906.     &current->thread.reg_window [window],
  907.     sizeof (svr4_rwindow_t));
  908. err |= __put_user(0, (int *)gw->winptr + window);
  909. }
  910. #endif
  912. /* 4. We just pay attention to the gw->count field on setcontext */
  913. current->thread.w_saved = 0; /* So process is allowed to execute. */
  915. /* Setup the signal information.  Solaris expects a bunch of
  916.  * information to be passed to the signal handler, we don't provide
  917.  * that much currently, should use siginfo.
  918.  */
  919. err |= __put_user(signr, &si->siginfo.signo);
  920. err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
  921. if (err)
  922. goto sigsegv;
  924. regs->u_regs[UREG_FP] = (unsigned long) sfp;
  925. regs->tpc = (unsigned long) sa->sa_handler;
  926. regs->tnpc = (regs->tpc + 4);
  927. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  928. regs->tpc &= 0xffffffff;
  929. regs->tnpc &= 0xffffffff;
  930. }
  932. #ifdef DEBUG_SIGNALS
  933. printk ("Solaris-frame: %x %xn", (int) regs->tpc, (int) regs->tnpc);
  934. #endif
  935. /* Arguments passed to signal handler */
  936. if (regs->u_regs [14]){
  937. struct reg_window32 *rw = (struct reg_window32 *)
  938. (regs->u_regs [14] & 0x00000000ffffffffUL);
  940. err |= __put_user(signr, &rw->ins [0]);
  941. err |= __put_user((u64)si, &rw->ins [1]);
  942. err |= __put_user((u64)uc, &rw->ins [2]);
  943. err |= __put_user((u64)sfp, &rw->ins [6]); /* frame pointer */
  944. if (err)
  945. goto sigsegv;
  947. regs->u_regs[UREG_I0] = signr;
  948. regs->u_regs[UREG_I1] = (u32)(u64) si;
  949. regs->u_regs[UREG_I2] = (u32)(u64) uc;
  950. }
  951. return;
  953. sigsegv:
  954. do_exit(SIGSEGV);
  955. }
  957. asmlinkage int
  958. svr4_getcontext(svr4_ucontext_t *uc, struct pt_regs *regs)
  959. {
  960. svr4_gregset_t  *gr;
  961. svr4_mcontext_t *mc;
  962. svr4_sigset_t setv;
  963. int i, err;
  965. synchronize_user_stack();
  966. save_and_clear_fpu();
  968. if (current->thread.w_saved){
  969. printk ("Uh oh, w_saved is not zero (%d)n", (int) current->thread.w_saved);
  970. do_exit (SIGSEGV);
  971. }
  972. err = clear_user(uc, sizeof (*uc));
  974. /* Setup convenience variables */
  975. mc = &uc->mcontext;
  976. gr = &mc->greg;
  978. setv.sigbits[0] = current->blocked.sig[0];
  979. setv.sigbits[1] = (current->blocked.sig[0] >> 32);
  980. if (_NSIG_WORDS >= 2) {
  981. setv.sigbits[2] = current->blocked.sig[1];
  982. setv.sigbits[3] = (current->blocked.sig[1] >> 32);
  983. err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
  984. } else
  985. err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
  987. /* Store registers */
  988. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  989. regs->tpc &= 0xffffffff;
  990. regs->tnpc &= 0xffffffff;
  991. }
  992. err |= __put_user(regs->tpc, &uc->mcontext.greg [SVR4_PC]);
  993. err |= __put_user(regs->tnpc, &uc->mcontext.greg [SVR4_NPC]);
  994. #if 1
  995. err |= __put_user(0, &uc->mcontext.greg [SVR4_PSR]);
  996. #else
  997. i = tstate_to_psr(regs->tstate) & ~PSR_EF;    
  998. if (current->thread.fpsaved[0] & FPRS_FEF)
  999. i |= PSR_EF;
  1000. err |= __put_user(i, &uc->mcontext.greg [SVR4_PSR]);
  1001. #endif
  1002. err |= __put_user(regs->y, &uc->mcontext.greg [SVR4_Y]);
  1004. /* Copy g [1..7] and o [0..7] registers */
  1005. for (i = 0; i < 7; i++)
  1006. err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
  1007. for (i = 0; i < 8; i++)
  1008. err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
  1010. /* Setup sigaltstack */
  1011. err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
  1012. err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
  1013. err |= __put_user(current->sas_ss_size, &uc->stack.size);
  1015. /* The register file is not saved
  1016.  * we have already stuffed all of it with sync_user_stack
  1017.  */
  1018. return (err ? -EFAULT : 0);
  1019. }
  1022. /* Set the context for a svr4 application, this is Solaris way to sigreturn */
  1023. asmlinkage int svr4_setcontext(svr4_ucontext_t *c, struct pt_regs *regs)
  1024. {
  1025. struct thread_struct *tp = &current->thread;
  1026. svr4_gregset_t  *gr;
  1027. u32 pc, npc, psr;
  1028. sigset_t set;
  1029. svr4_sigset_t setv;
  1030. int i, err;
  1031. stack_t st;
  1033. /* Fixme: restore windows, or is this already taken care of in
  1034.  * svr4_setup_frame when sync_user_windows is done?
  1035.  */
  1036. flush_user_windows();
  1038. if (tp->w_saved){
  1039. printk ("Uh oh, w_saved is: 0x%xn", tp->w_saved);
  1040. goto sigsegv;
  1041. }
  1042. if (((unsigned long) c) & 3){
  1043. printk ("Unaligned structure passedn");
  1044. goto sigsegv;
  1045. }
  1047. if(!__access_ok((unsigned long)c, sizeof(*c))) {
  1048. /* Miguel, add nice debugging msg _here_. ;-) */
  1049. goto sigsegv;
  1050. }
  1052. /* Check for valid PC and nPC */
  1053. gr = &c->mcontext.greg;
  1054. err = __get_user(pc, &((*gr)[SVR4_PC]));
  1055. err |= __get_user(npc, &((*gr)[SVR4_NPC]));
  1056. if((pc | npc) & 3) {
  1057. #ifdef DEBUG_SIGNALS
  1058.         printk ("setcontext, PC or nPC were bogusn");
  1059. #endif
  1060. goto sigsegv;
  1061. }
  1063. /* Retrieve information from passed ucontext */
  1064. /* note that nPC is ored a 1, this is used to inform entry.S */
  1065. /* that we don't want it to mess with our PC and nPC */
  1067. err |= copy_from_user (&setv, &c->sigmask, sizeof(svr4_sigset_t));
  1068. set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
  1069. if (_NSIG_WORDS >= 2)
  1070. set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
  1072. err |= __get_user((long)st.ss_sp, &c->stack.sp);
  1073. err |= __get_user(st.ss_flags, &c->stack.flags);
  1074. err |= __get_user(st.ss_size, &c->stack.size);
  1075. if (err)
  1076. goto sigsegv;
  1078. /* It is more difficult to avoid calling this function than to
  1079.    call it and ignore errors.  */
  1080. do_sigaltstack(&st, NULL, regs->u_regs[UREG_I6]);
  1082. sigdelsetmask(&set, ~_BLOCKABLE);
  1083. spin_lock_irq(&current->sigmask_lock);
  1084. current->blocked = set;
  1085. recalc_sigpending(current);
  1086. spin_unlock_irq(&current->sigmask_lock);
  1087. regs->tpc = pc;
  1088. regs->tnpc = npc | 1;
  1089. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  1090. regs->tpc &= 0xffffffff;
  1091. regs->tnpc &= 0xffffffff;
  1092. }
  1093. err |= __get_user(regs->y, &((*gr) [SVR4_Y]));
  1094. err |= __get_user(psr, &((*gr) [SVR4_PSR]));
  1095. regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
  1096. regs->tstate |= psr_to_tstate_icc(psr);
  1097. #if 0
  1098. if(psr & PSR_EF)
  1099. regs->tstate |= TSTATE_PEF;
  1100. #endif
  1101. /* Restore g[1..7] and o[0..7] registers */
  1102. for (i = 0; i < 7; i++)
  1103. err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
  1104. for (i = 0; i < 8; i++)
  1105. err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
  1106. if(err)
  1107. goto sigsegv;
  1109. return -EINTR;
  1110. sigsegv:
  1111. do_exit(SIGSEGV);
  1112. }
  1114. static inline void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
  1115.         unsigned long signr, sigset_t *oldset,
  1116.         siginfo_t *info)
  1117. {
  1118. struct rt_signal_frame32 *sf;
  1119. int sigframe_size;
  1120. u32 psr;
  1121. int i, err;
  1122. sigset_t32 seta;
  1124. /* 1. Make sure everything is clean */
  1125. synchronize_user_stack();
  1126. save_and_clear_fpu();
  1128. sigframe_size = RT_ALIGNEDSZ;
  1129. if (!(current->thread.fpsaved[0] & FPRS_FEF))
  1130. sigframe_size -= sizeof(__siginfo_fpu_t);
  1132. sf = (struct rt_signal_frame32 *)get_sigframe(&ka->sa, regs, sigframe_size);
  1134. if (invalid_frame_pointer (sf, sigframe_size)) {
  1135. #ifdef DEBUG_SIGNALS
  1136. printk("rt_setup_frame32(%s:%d): invalid_frame_pointer(%p, %d)n",
  1137.        current->comm, current->pid, sf, sigframe_size);
  1138. #endif
  1139. goto sigill;
  1140. }
  1142. if (current->thread.w_saved != 0) {
  1143. #ifdef DEBUG_SIGNALS
  1144. printk ("%s[%d]: Invalid user stack frame for "
  1145. "signal delivery.n", current->comm, current->pid);
  1146. #endif
  1147. goto sigill;
  1148. }
  1150. /* 2. Save the current process state */
  1151. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  1152. regs->tpc &= 0xffffffff;
  1153. regs->tnpc &= 0xffffffff;
  1154. }
  1155. err  = put_user(regs->tpc, &sf->regs.pc);
  1156. err |= __put_user(regs->tnpc, &sf->regs.npc);
  1157. err |= __put_user(regs->y, &sf->regs.y);
  1158. psr = tstate_to_psr (regs->tstate);
  1159. if(current->thread.fpsaved[0] & FPRS_FEF)
  1160. psr |= PSR_EF;
  1161. err |= __put_user(psr, &sf->regs.psr);
  1162. for (i = 0; i < 16; i++)
  1163. err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
  1164. err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
  1165. err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
  1166. for (i = 1; i < 16; i++)
  1167. err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
  1169. if (psr & PSR_EF) {
  1170. err |= save_fpu_state32(regs, &sf->fpu_state);
  1171. err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
  1172. } else {
  1173. err |= __put_user(0, &sf->fpu_save);
  1174. }
  1176. /* Update the siginfo structure.  */
  1177. err |= copy_siginfo_to_user32(&sf->info, info);
  1179. /* Setup sigaltstack */
  1180. err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
  1181. err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
  1182. err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
  1184. switch (_NSIG_WORDS) {
  1185. case 4: seta.sig[7] = (oldset->sig[3] >> 32);
  1186. seta.sig[6] = oldset->sig[3];
  1187. case 3: seta.sig[5] = (oldset->sig[2] >> 32);
  1188. seta.sig[4] = oldset->sig[2];
  1189. case 2: seta.sig[3] = (oldset->sig[1] >> 32);
  1190. seta.sig[2] = oldset->sig[1];
  1191. case 1: seta.sig[1] = (oldset->sig[0] >> 32);
  1192. seta.sig[0] = oldset->sig[0];
  1193. }
  1194. err |= __copy_to_user(&sf->mask, &seta, sizeof(sigset_t32));
  1196. err |= copy_in_user((u32 *)sf,
  1197.     (u32 *)(regs->u_regs[UREG_FP]),
  1198.     sizeof(struct reg_window32));
  1199. if (err)
  1200. goto sigsegv;
  1202. /* 3. signal handler back-trampoline and parameters */
  1203. regs->u_regs[UREG_FP] = (unsigned long) sf;
  1204. regs->u_regs[UREG_I0] = signr;
  1205. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  1207. /* 4. signal handler */
  1208. regs->tpc = (unsigned long) ka->sa.sa_handler;
  1209. regs->tnpc = (regs->tpc + 4);
  1210. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  1211. regs->tpc &= 0xffffffff;
  1212. regs->tnpc &= 0xffffffff;
  1213. }
  1215. /* 5. return to kernel instructions */
  1216. if (ka->ka_restorer)
  1217. regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  1218. else {
  1219. /* Flush instruction space. */
  1220. unsigned long address = ((unsigned long)&(sf->insns[0]));
  1221. pgd_t *pgdp = pgd_offset(current->mm, address);
  1222. pmd_t *pmdp = pmd_offset(pgdp, address);
  1223. pte_t *ptep = pte_offset(pmdp, address);
  1225. regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
  1227. /* mov __NR_rt_sigreturn, %g1 */
  1228. err |= __put_user(0x82102065, &sf->insns[0]);
  1230. /* t 0x10 */
  1231. err |= __put_user(0x91d02010, &sf->insns[1]);
  1232. if (err)
  1233. goto sigsegv;
  1235. if(pte_present(*ptep)) {
  1236. unsigned long page = (unsigned long) page_address(pte_page(*ptep));
  1238. __asm__ __volatile__(
  1239. " membar #StoreStoren"
  1240. " flush %0 + %1"
  1241. : : "r" (page), "r" (address & (PAGE_SIZE - 1))
  1242. : "memory");
  1243. }
  1244. }
  1245. return;
  1247. sigill:
  1248. do_exit(SIGILL);
  1249. sigsegv:
  1250. do_exit(SIGSEGV);
  1251. }
  1253. static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
  1254.    siginfo_t *info,
  1255.    sigset_t *oldset, struct pt_regs *regs,
  1256.    int svr4_signal)
  1257. {
  1258. if(svr4_signal)
  1259. setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc, regs, signr, oldset);
  1260. else {
  1261. if (ka->sa.sa_flags & SA_SIGINFO)
  1262. setup_rt_frame32(ka, regs, signr, oldset, info);
  1263. else if (current->thread.flags & SPARC_FLAG_NEWSIGNALS)
  1264. new_setup_frame32(ka, regs, signr, oldset);
  1265. else
  1266. setup_frame32(&ka->sa, regs, signr, oldset, info);
  1267. }
  1268. if(ka->sa.sa_flags & SA_ONESHOT)
  1269. ka->sa.sa_handler = SIG_DFL;
  1270. if(!(ka->sa.sa_flags & SA_NOMASK)) {
  1271. spin_lock_irq(&current->sigmask_lock);
  1272. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  1273. sigaddset(&current->blocked,signr);
  1274. recalc_sigpending(current);
  1275. spin_unlock_irq(&current->sigmask_lock);
  1276. }
  1277. }
  1279. static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
  1280.      struct sigaction *sa)
  1281. {
  1282. switch(regs->u_regs[UREG_I0]) {
  1283. case ERESTARTNOHAND:
  1284. no_system_call_restart:
  1285. regs->u_regs[UREG_I0] = EINTR;
  1286. regs->tstate |= TSTATE_ICARRY;
  1287. break;
  1288. case ERESTARTSYS:
  1289. if(!(sa->sa_flags & SA_RESTART))
  1290. goto no_system_call_restart;
  1291. /* fallthrough */
  1292. case ERESTARTNOINTR:
  1293. regs->u_regs[UREG_I0] = orig_i0;
  1294. regs->tpc -= 4;
  1295. regs->tnpc -= 4;
  1296. }
  1297. }
  1299. #ifdef DEBUG_SIGNALS_MAPS
  1301. #define MAPS_LINE_FORMAT   "%016lx-%016lx %s %016lx %s %lu "
  1303. static inline void read_maps (void)
  1304. {
  1305. struct vm_area_struct * map, * next;
  1306. char * buffer;
  1307. ssize_t i;
  1309. buffer = (char*)__get_free_page(GFP_KERNEL);
  1310. if (!buffer)
  1311. return;
  1313. for (map = current->mm->mmap ; map ; map = next ) {
  1314. /* produce the next line */
  1315. char *line;
  1316. char str[5], *cp = str;
  1317. int flags;
  1318. kdev_t dev;
  1319. unsigned long ino;
  1321. /*
  1322.  * Get the next vma now (but it won't be used if we sleep).
  1323.  */
  1324. next = map->vm_next;
  1325. flags = map->vm_flags;
  1327. *cp++ = flags & VM_READ ? 'r' : '-';
  1328. *cp++ = flags & VM_WRITE ? 'w' : '-';
  1329. *cp++ = flags & VM_EXEC ? 'x' : '-';
  1330. *cp++ = flags & VM_MAYSHARE ? 's' : 'p';
  1331. *cp++ = 0;
  1333. dev = 0;
  1334. ino = 0;
  1335. if (map->vm_file != NULL) {
  1336. dev = map->vm_file->f_dentry->d_inode->i_dev;
  1337. ino = map->vm_file->f_dentry->d_inode->i_ino;
  1338. line = d_path(map->vm_file->f_dentry,
  1339.       map->vm_file->f_vfsmnt,
  1340.       buffer, PAGE_SIZE);
  1341. }
  1342. printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT,
  1343.       kdevname(dev), ino);
  1344. if (map->vm_file != NULL)
  1345. printk("%sn", line);
  1346. else
  1347. printk("n");
  1348. }
  1349. free_page((unsigned long)buffer);
  1350. return;
  1351. }
  1353. #endif
  1355. /* Note that 'init' is a special process: it doesn't get signals it doesn't
  1356.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  1357.  * mistake.
  1358.  */
  1359. asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs * regs,
  1360.    unsigned long orig_i0, int restart_syscall)
  1361. {
  1362. unsigned long signr;
  1363. struct k_sigaction *ka;
  1364. siginfo_t info;
  1366. int svr4_signal = current->personality == PER_SVR4;
  1368. for (;;) {
  1369. spin_lock_irq(&current->sigmask_lock);
  1370. signr = dequeue_signal(&current->blocked, &info);
  1371. spin_unlock_irq(&current->sigmask_lock);
  1373. if (!signr) break;
  1375. if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  1376. current->exit_code = signr;
  1377. current->state = TASK_STOPPED;
  1378. notify_parent(current, SIGCHLD);
  1379. schedule();
  1380. if (!(signr = current->exit_code))
  1381. continue;
  1382. current->exit_code = 0;
  1383. if (signr == SIGSTOP)
  1384. continue;
  1386. /* Update the siginfo structure.  Is this good?  */
  1387. if (signr != info.si_signo) {
  1388. info.si_signo = signr;
  1389. info.si_errno = 0;
  1390. info.si_code = SI_USER;
  1391. info.si_pid = current->p_pptr->pid;
  1392. info.si_uid = current->p_pptr->uid;
  1393. }
  1395. /* If the (new) signal is now blocked, requeue it.  */
  1396. if (sigismember(&current->blocked, signr)) {
  1397. send_sig_info(signr, &info, current);
  1398. continue;
  1399. }
  1400. }
  1402. ka = &current->sig->action[signr-1];
  1404. if(ka->sa.sa_handler == SIG_IGN) {
  1405. if(signr != SIGCHLD)
  1406. continue;
  1408. /* sys_wait4() grabs the master kernel lock, so
  1409.  * we need not do so, that sucker should be
  1410.  * threaded and would not be that difficult to
  1411.  * do anyways.
  1412.  */
  1413. while(sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  1414. ;
  1415. continue;
  1416. }
  1417. if(ka->sa.sa_handler == SIG_DFL) {
  1418. unsigned long exit_code = signr;
  1420. if(current->pid == 1)
  1421. continue;
  1422. switch(signr) {
  1423. case SIGCONT: case SIGCHLD: case SIGWINCH:
  1424. continue;
  1426. case SIGTSTP: case SIGTTIN: case SIGTTOU:
  1427. if (is_orphaned_pgrp(current->pgrp))
  1428. continue;
  1430. case SIGSTOP:
  1431. if (current->ptrace & PT_PTRACED)
  1432. continue;
  1433. current->state = TASK_STOPPED;
  1434. current->exit_code = signr;
  1435. if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
  1436.      SA_NOCLDSTOP))
  1437. notify_parent(current, SIGCHLD);
  1438. schedule();
  1439. continue;
  1441. case SIGQUIT: case SIGILL: case SIGTRAP:
  1442. case SIGABRT: case SIGFPE: case SIGSEGV:
  1443. case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  1444. if (do_coredump(signr, regs))
  1445. exit_code |= 0x80;
  1446. #ifdef DEBUG_SIGNALS
  1447. /* Very useful to debug dynamic linker problems */
  1448. printk ("Sig %ld going for %s[%d]...n", signr, current->comm, current->pid);
  1449. /* On SMP we are only interested in the current
  1450.  * CPU's registers.
  1451.  */
  1452. __show_regs (regs);
  1453. #ifdef DEBUG_SIGNALS_TLB
  1454. do {
  1455. extern void sparc_ultra_dump_itlb(void);
  1456. extern void sparc_ultra_dump_dtlb(void);
  1457. sparc_ultra_dump_dtlb();
  1458. sparc_ultra_dump_itlb();
  1459. } while(0);
  1460. #endif
  1461. #ifdef DEBUG_SIGNALS_TRACE
  1462. {
  1463. struct reg_window32 *rw = (struct reg_window32 *)(regs->u_regs[UREG_FP] & 0xffffffff);
  1464. unsigned int ins[8];
  1466. while(rw &&
  1467.       !(((unsigned long) rw) & 0x3)) {
  1468. copy_from_user(ins, &rw->ins[0], sizeof(ins));
  1469. printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)n", ins[7], ins[0], ins[1], ins[2], ins[3], ins[4], ins[5]);
  1470. rw = (struct reg_window32 *)(unsigned long)ins[6];
  1471. }
  1472. }
  1473. #endif
  1474. #ifdef DEBUG_SIGNALS_MAPS
  1475. printk("Maps:n");
  1476. read_maps();
  1477. #endif
  1478. #endif
  1479. /* fall through */
  1480. default:
  1481. sigaddset(&current->pending.signal, signr);
  1482. recalc_sigpending(current);
  1483. current->flags |= PF_SIGNALED;
  1484. do_exit(exit_code);
  1485. /* NOT REACHED */
  1486. }
  1487. }
  1488. if(restart_syscall)
  1489. syscall_restart32(orig_i0, regs, &ka->sa);
  1490. handle_signal32(signr, ka, &info, oldset, regs, svr4_signal);
  1491. return 1;
  1492. }
  1493. if(restart_syscall &&
  1494.    (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
  1495.     regs->u_regs[UREG_I0] == ERESTARTSYS ||
  1496.     regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
  1497. /* replay the system call when we are done */
  1498. regs->u_regs[UREG_I0] = orig_i0;
  1499. regs->tpc -= 4;
  1500. regs->tnpc -= 4;
  1501. }
  1502. return 0;
  1503. }
  1505. struct sigstack32 {
  1506. u32 the_stack;
  1507. int cur_status;
  1508. };
  1510. asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
  1511. {
  1512. struct sigstack32 *ssptr = (struct sigstack32 *)((unsigned long)(u_ssptr));
  1513. struct sigstack32 *ossptr = (struct sigstack32 *)((unsigned long)(u_ossptr));
  1514. int ret = -EFAULT;
  1516. /* First see if old state is wanted. */
  1517. if (ossptr) {
  1518. if (put_user(current->sas_ss_sp + current->sas_ss_size, &ossptr->the_stack) ||
  1519.     __put_user(on_sig_stack(sp), &ossptr->cur_status))
  1520. goto out;
  1521. }
  1523. /* Now see if we want to update the new state. */
  1524. if (ssptr) {
  1525. void *ss_sp;
  1527. if (get_user((long)ss_sp, &ssptr->the_stack))
  1528. goto out;
  1529. /* If the current stack was set with sigaltstack, don't
  1530.    swap stacks while we are on it.  */
  1531. ret = -EPERM;
  1532. if (current->sas_ss_sp && on_sig_stack(sp))
  1533. goto out;
  1535. /* Since we don't know the extent of the stack, and we don't
  1536.    track onstack-ness, but rather calculate it, we must
  1537.    presume a size.  Ho hum this interface is lossy.  */
  1538. current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
  1539. current->sas_ss_size = SIGSTKSZ;
  1540. }
  1542. ret = 0;
  1543. out:
  1544. return ret;
  1545. }
  1547. asmlinkage int do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
  1548. {
  1549. stack_t uss, uoss;
  1550. int ret;
  1551. mm_segment_t old_fs;
  1553. if (ussa && (get_user((long)uss.ss_sp, &((stack_t32 *)(long)ussa)->ss_sp) ||
  1554.     __get_user(uss.ss_flags, &((stack_t32 *)(long)ussa)->ss_flags) ||
  1555.     __get_user(uss.ss_size, &((stack_t32 *)(long)ussa)->ss_size)))
  1556. return -EFAULT;
  1557. old_fs = get_fs();
  1558. set_fs(KERNEL_DS);
  1559. ret = do_sigaltstack(ussa ? &uss : NULL, uossa ? &uoss : NULL, sp);
  1560. set_fs(old_fs);
  1561. if (!ret && uossa && (put_user((long)uoss.ss_sp, &((stack_t32 *)(long)uossa)->ss_sp) ||
  1562.     __put_user(uoss.ss_flags, &((stack_t32 *)(long)uossa)->ss_flags) ||
  1563.     __put_user(uoss.ss_size, &((stack_t32 *)(long)uossa)->ss_size)))
  1564. return -EFAULT;
  1565. return ret;
  1566. }