signal_32.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590
  1. /* linux/arch/sparc/kernel/signal.c
  2. *
  3. * Copyright (C) 1991, 1992 Linus Torvalds
  4. * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  5. * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
  6. * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
  7. */
  8. #include <linux/sched.h>
  9. #include <linux/kernel.h>
  10. #include <linux/signal.h>
  11. #include <linux/errno.h>
  12. #include <linux/wait.h>
  13. #include <linux/ptrace.h>
  14. #include <linux/unistd.h>
  15. #include <linux/mm.h>
  16. #include <linux/tty.h>
  17. #include <linux/smp.h>
  18. #include <linux/binfmts.h> /* do_coredum */
  19. #include <linux/bitops.h>
  20. #include <linux/tracehook.h>
  21. #include <asm/uaccess.h>
  22. #include <asm/ptrace.h>
  23. #include <asm/pgalloc.h>
  24. #include <asm/pgtable.h>
  25. #include <asm/cacheflush.h> /* flush_sig_insns */
  26. #include <asm/switch_to.h>
  27. #include "sigutil.h"
  28. extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
  29. void *fpqueue, unsigned long *fpqdepth);
  30. extern void fpload(unsigned long *fpregs, unsigned long *fsr);
  31. struct signal_frame {
  32. struct sparc_stackf ss;
  33. __siginfo32_t info;
  34. __siginfo_fpu_t __user *fpu_save;
  35. unsigned long insns[2] __attribute__ ((aligned (8)));
  36. unsigned int extramask[_NSIG_WORDS - 1];
  37. unsigned int extra_size; /* Should be 0 */
  38. __siginfo_rwin_t __user *rwin_save;
  39. } __attribute__((aligned(8)));
  40. struct rt_signal_frame {
  41. struct sparc_stackf ss;
  42. siginfo_t info;
  43. struct pt_regs regs;
  44. sigset_t mask;
  45. __siginfo_fpu_t __user *fpu_save;
  46. unsigned int insns[2];
  47. stack_t stack;
  48. unsigned int extra_size; /* Should be 0 */
  49. __siginfo_rwin_t __user *rwin_save;
  50. } __attribute__((aligned(8)));
  51. /* Align macros */
  52. #define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7)))
  53. #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
  54. asmlinkage int sys_sigsuspend(old_sigset_t set)
  55. {
  56. sigset_t blocked;
  57. siginitset(&blocked, set);
  58. return sigsuspend(&blocked);
  59. }
  60. asmlinkage void do_sigreturn(struct pt_regs *regs)
  61. {
  62. struct signal_frame __user *sf;
  63. unsigned long up_psr, pc, npc;
  64. sigset_t set;
  65. __siginfo_fpu_t __user *fpu_save;
  66. __siginfo_rwin_t __user *rwin_save;
  67. int err;
  68. /* Always make any pending restarted system calls return -EINTR */
  69. current_thread_info()->restart_block.fn = do_no_restart_syscall;
  70. synchronize_user_stack();
  71. sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];
  72. /* 1. Make sure we are not getting garbage from the user */
  73. if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
  74. goto segv_and_exit;
  75. if (((unsigned long) sf) & 3)
  76. goto segv_and_exit;
  77. err = __get_user(pc, &sf->info.si_regs.pc);
  78. err |= __get_user(npc, &sf->info.si_regs.npc);
  79. if ((pc | npc) & 3)
  80. goto segv_and_exit;
  81. /* 2. Restore the state */
  82. up_psr = regs->psr;
  83. err |= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs));
  84. /* User can only change condition codes and FPU enabling in %psr. */
  85. regs->psr = (up_psr & ~(PSR_ICC | PSR_EF))
  86. | (regs->psr & (PSR_ICC | PSR_EF));
  87. /* Prevent syscall restart. */
  88. pt_regs_clear_syscall(regs);
  89. err |= __get_user(fpu_save, &sf->fpu_save);
  90. if (fpu_save)
  91. err |= restore_fpu_state(regs, fpu_save);
  92. err |= __get_user(rwin_save, &sf->rwin_save);
  93. if (rwin_save)
  94. err |= restore_rwin_state(rwin_save);
  95. /* This is pretty much atomic, no amount locking would prevent
  96. * the races which exist anyways.
  97. */
  98. err |= __get_user(set.sig[0], &sf->info.si_mask);
  99. err |= __copy_from_user(&set.sig[1], &sf->extramask,
  100. (_NSIG_WORDS-1) * sizeof(unsigned int));
  101. if (err)
  102. goto segv_and_exit;
  103. set_current_blocked(&set);
  104. return;
  105. segv_and_exit:
  106. force_sig(SIGSEGV, current);
  107. }
  108. asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
  109. {
  110. struct rt_signal_frame __user *sf;
  111. unsigned int psr, pc, npc;
  112. __siginfo_fpu_t __user *fpu_save;
  113. __siginfo_rwin_t __user *rwin_save;
  114. sigset_t set;
  115. int err;
  116. synchronize_user_stack();
  117. sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];
  118. if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
  119. (((unsigned long) sf) & 0x03))
  120. goto segv;
  121. err = __get_user(pc, &sf->regs.pc);
  122. err |= __get_user(npc, &sf->regs.npc);
  123. err |= ((pc | npc) & 0x03);
  124. err |= __get_user(regs->y, &sf->regs.y);
  125. err |= __get_user(psr, &sf->regs.psr);
  126. err |= __copy_from_user(&regs->u_regs[UREG_G1],
  127. &sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));
  128. regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);
  129. /* Prevent syscall restart. */
  130. pt_regs_clear_syscall(regs);
  131. err |= __get_user(fpu_save, &sf->fpu_save);
  132. if (!err && fpu_save)
  133. err |= restore_fpu_state(regs, fpu_save);
  134. err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
  135. err |= restore_altstack(&sf->stack);
  136. if (err)
  137. goto segv;
  138. regs->pc = pc;
  139. regs->npc = npc;
  140. err |= __get_user(rwin_save, &sf->rwin_save);
  141. if (!err && rwin_save) {
  142. if (restore_rwin_state(rwin_save))
  143. goto segv;
  144. }
  145. set_current_blocked(&set);
  146. return;
  147. segv:
  148. force_sig(SIGSEGV, current);
  149. }
  150. /* Checks if the fp is valid */
  151. static inline int invalid_frame_pointer(void __user *fp, int fplen)
  152. {
  153. if ((((unsigned long) fp) & 7) || !__access_ok((unsigned long)fp, fplen))
  154. return 1;
  155. return 0;
  156. }
  157. static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
  158. {
  159. unsigned long sp = regs->u_regs[UREG_FP];
  160. /*
  161. * If we are on the alternate signal stack and would overflow it, don't.
  162. * Return an always-bogus address instead so we will die with SIGSEGV.
  163. */
  164. if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
  165. return (void __user *) -1L;
  166. /* This is the X/Open sanctioned signal stack switching. */
  167. if (sa->sa_flags & SA_ONSTACK) {
  168. if (sas_ss_flags(sp) == 0)
  169. sp = current->sas_ss_sp + current->sas_ss_size;
  170. }
  171. sp -= framesize;
  172. /* Always align the stack frame. This handles two cases. First,
  173. * sigaltstack need not be mindful of platform specific stack
  174. * alignment. Second, if we took this signal because the stack
  175. * is not aligned properly, we'd like to take the signal cleanly
  176. * and report that.
  177. */
  178. sp &= ~15UL;
  179. return (void __user *) sp;
  180. }
  181. static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
  182. int signo, sigset_t *oldset)
  183. {
  184. struct signal_frame __user *sf;
  185. int sigframe_size, err, wsaved;
  186. void __user *tail;
  187. /* 1. Make sure everything is clean */
  188. synchronize_user_stack();
  189. wsaved = current_thread_info()->w_saved;
  190. sigframe_size = sizeof(*sf);
  191. if (used_math())
  192. sigframe_size += sizeof(__siginfo_fpu_t);
  193. if (wsaved)
  194. sigframe_size += sizeof(__siginfo_rwin_t);
  195. sf = (struct signal_frame __user *)
  196. get_sigframe(&ka->sa, regs, sigframe_size);
  197. if (invalid_frame_pointer(sf, sigframe_size))
  198. goto sigill_and_return;
  199. tail = sf + 1;
  200. /* 2. Save the current process state */
  201. err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));
  202. err |= __put_user(0, &sf->extra_size);
  203. if (used_math()) {
  204. __siginfo_fpu_t __user *fp = tail;
  205. tail += sizeof(*fp);
  206. err |= save_fpu_state(regs, fp);
  207. err |= __put_user(fp, &sf->fpu_save);
  208. } else {
  209. err |= __put_user(0, &sf->fpu_save);
  210. }
  211. if (wsaved) {
  212. __siginfo_rwin_t __user *rwp = tail;
  213. tail += sizeof(*rwp);
  214. err |= save_rwin_state(wsaved, rwp);
  215. err |= __put_user(rwp, &sf->rwin_save);
  216. } else {
  217. err |= __put_user(0, &sf->rwin_save);
  218. }
  219. err |= __put_user(oldset->sig[0], &sf->info.si_mask);
  220. err |= __copy_to_user(sf->extramask, &oldset->sig[1],
  221. (_NSIG_WORDS - 1) * sizeof(unsigned int));
  222. if (!wsaved) {
  223. err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
  224. sizeof(struct reg_window32));
  225. } else {
  226. struct reg_window32 *rp;
  227. rp = &current_thread_info()->reg_window[wsaved - 1];
  228. err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));
  229. }
  230. if (err)
  231. goto sigsegv;
  232. /* 3. signal handler back-trampoline and parameters */
  233. regs->u_regs[UREG_FP] = (unsigned long) sf;
  234. regs->u_regs[UREG_I0] = signo;
  235. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  236. regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
  237. /* 4. signal handler */
  238. regs->pc = (unsigned long) ka->sa.sa_handler;
  239. regs->npc = (regs->pc + 4);
  240. /* 5. return to kernel instructions */
  241. if (ka->ka_restorer)
  242. regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  243. else {
  244. regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
  245. /* mov __NR_sigreturn, %g1 */
  246. err |= __put_user(0x821020d8, &sf->insns[0]);
  247. /* t 0x10 */
  248. err |= __put_user(0x91d02010, &sf->insns[1]);
  249. if (err)
  250. goto sigsegv;
  251. /* Flush instruction space. */
  252. flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
  253. }
  254. return 0;
  255. sigill_and_return:
  256. do_exit(SIGILL);
  257. return -EINVAL;
  258. sigsegv:
  259. force_sigsegv(signo, current);
  260. return -EFAULT;
  261. }
  262. static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
  263. int signo, sigset_t *oldset, siginfo_t *info)
  264. {
  265. struct rt_signal_frame __user *sf;
  266. int sigframe_size, wsaved;
  267. void __user *tail;
  268. unsigned int psr;
  269. int err;
  270. synchronize_user_stack();
  271. wsaved = current_thread_info()->w_saved;
  272. sigframe_size = sizeof(*sf);
  273. if (used_math())
  274. sigframe_size += sizeof(__siginfo_fpu_t);
  275. if (wsaved)
  276. sigframe_size += sizeof(__siginfo_rwin_t);
  277. sf = (struct rt_signal_frame __user *)
  278. get_sigframe(&ka->sa, regs, sigframe_size);
  279. if (invalid_frame_pointer(sf, sigframe_size))
  280. goto sigill;
  281. tail = sf + 1;
  282. err = __put_user(regs->pc, &sf->regs.pc);
  283. err |= __put_user(regs->npc, &sf->regs.npc);
  284. err |= __put_user(regs->y, &sf->regs.y);
  285. psr = regs->psr;
  286. if (used_math())
  287. psr |= PSR_EF;
  288. err |= __put_user(psr, &sf->regs.psr);
  289. err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
  290. err |= __put_user(0, &sf->extra_size);
  291. if (psr & PSR_EF) {
  292. __siginfo_fpu_t *fp = tail;
  293. tail += sizeof(*fp);
  294. err |= save_fpu_state(regs, fp);
  295. err |= __put_user(fp, &sf->fpu_save);
  296. } else {
  297. err |= __put_user(0, &sf->fpu_save);
  298. }
  299. if (wsaved) {
  300. __siginfo_rwin_t *rwp = tail;
  301. tail += sizeof(*rwp);
  302. err |= save_rwin_state(wsaved, rwp);
  303. err |= __put_user(rwp, &sf->rwin_save);
  304. } else {
  305. err |= __put_user(0, &sf->rwin_save);
  306. }
  307. err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
  308. /* Setup sigaltstack */
  309. err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
  310. if (!wsaved) {
  311. err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
  312. sizeof(struct reg_window32));
  313. } else {
  314. struct reg_window32 *rp;
  315. rp = &current_thread_info()->reg_window[wsaved - 1];
  316. err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));
  317. }
  318. err |= copy_siginfo_to_user(&sf->info, info);
  319. if (err)
  320. goto sigsegv;
  321. regs->u_regs[UREG_FP] = (unsigned long) sf;
  322. regs->u_regs[UREG_I0] = signo;
  323. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  324. regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
  325. regs->pc = (unsigned long) ka->sa.sa_handler;
  326. regs->npc = (regs->pc + 4);
  327. if (ka->ka_restorer)
  328. regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  329. else {
  330. regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
  331. /* mov __NR_sigreturn, %g1 */
  332. err |= __put_user(0x821020d8, &sf->insns[0]);
  333. /* t 0x10 */
  334. err |= __put_user(0x91d02010, &sf->insns[1]);
  335. if (err)
  336. goto sigsegv;
  337. /* Flush instruction space. */
  338. flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
  339. }
  340. return 0;
  341. sigill:
  342. do_exit(SIGILL);
  343. return -EINVAL;
  344. sigsegv:
  345. force_sigsegv(signo, current);
  346. return -EFAULT;
  347. }
  348. static inline void
  349. handle_signal(unsigned long signr, struct k_sigaction *ka,
  350. siginfo_t *info, struct pt_regs *regs)
  351. {
  352. sigset_t *oldset = sigmask_to_save();
  353. int err;
  354. if (ka->sa.sa_flags & SA_SIGINFO)
  355. err = setup_rt_frame(ka, regs, signr, oldset, info);
  356. else
  357. err = setup_frame(ka, regs, signr, oldset);
  358. if (err)
  359. return;
  360. signal_delivered(signr, info, ka, regs, 0);
  361. }
  362. static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
  363. struct sigaction *sa)
  364. {
  365. switch(regs->u_regs[UREG_I0]) {
  366. case ERESTART_RESTARTBLOCK:
  367. case ERESTARTNOHAND:
  368. no_system_call_restart:
  369. regs->u_regs[UREG_I0] = EINTR;
  370. regs->psr |= PSR_C;
  371. break;
  372. case ERESTARTSYS:
  373. if (!(sa->sa_flags & SA_RESTART))
  374. goto no_system_call_restart;
  375. /* fallthrough */
  376. case ERESTARTNOINTR:
  377. regs->u_regs[UREG_I0] = orig_i0;
  378. regs->pc -= 4;
  379. regs->npc -= 4;
  380. }
  381. }
  382. /* Note that 'init' is a special process: it doesn't get signals it doesn't
  383. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  384. * mistake.
  385. */
  386. static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
  387. {
  388. struct k_sigaction ka;
  389. int restart_syscall;
  390. siginfo_t info;
  391. int signr;
  392. /* It's a lot of work and synchronization to add a new ptrace
  393. * register for GDB to save and restore in order to get
  394. * orig_i0 correct for syscall restarts when debugging.
  395. *
  396. * Although it should be the case that most of the global
  397. * registers are volatile across a system call, glibc already
  398. * depends upon that fact that we preserve them. So we can't
  399. * just use any global register to save away the orig_i0 value.
  400. *
  401. * In particular %g2, %g3, %g4, and %g5 are all assumed to be
  402. * preserved across a system call trap by various pieces of
  403. * code in glibc.
  404. *
  405. * %g7 is used as the "thread register". %g6 is not used in
  406. * any fixed manner. %g6 is used as a scratch register and
  407. * a compiler temporary, but it's value is never used across
  408. * a system call. Therefore %g6 is usable for orig_i0 storage.
  409. */
  410. if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
  411. regs->u_regs[UREG_G6] = orig_i0;
  412. signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  413. /* If the debugger messes with the program counter, it clears
  414. * the software "in syscall" bit, directing us to not perform
  415. * a syscall restart.
  416. */
  417. restart_syscall = 0;
  418. if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C)) {
  419. restart_syscall = 1;
  420. orig_i0 = regs->u_regs[UREG_G6];
  421. }
  422. if (signr > 0) {
  423. if (restart_syscall)
  424. syscall_restart(orig_i0, regs, &ka.sa);
  425. handle_signal(signr, &ka, &info, regs);
  426. return;
  427. }
  428. if (restart_syscall &&
  429. (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
  430. regs->u_regs[UREG_I0] == ERESTARTSYS ||
  431. regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
  432. /* replay the system call when we are done */
  433. regs->u_regs[UREG_I0] = orig_i0;
  434. regs->pc -= 4;
  435. regs->npc -= 4;
  436. pt_regs_clear_syscall(regs);
  437. }
  438. if (restart_syscall &&
  439. regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
  440. regs->u_regs[UREG_G1] = __NR_restart_syscall;
  441. regs->pc -= 4;
  442. regs->npc -= 4;
  443. pt_regs_clear_syscall(regs);
  444. }
  445. /* if there's no signal to deliver, we just put the saved sigmask
  446. * back
  447. */
  448. restore_saved_sigmask();
  449. }
  450. void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
  451. unsigned long thread_info_flags)
  452. {
  453. if (thread_info_flags & _TIF_SIGPENDING)
  454. do_signal(regs, orig_i0);
  455. if (thread_info_flags & _TIF_NOTIFY_RESUME) {
  456. clear_thread_flag(TIF_NOTIFY_RESUME);
  457. tracehook_notify_resume(regs);
  458. }
  459. }
  460. asmlinkage int
  461. do_sys_sigstack(struct sigstack __user *ssptr, struct sigstack __user *ossptr,
  462. unsigned long sp)
  463. {
  464. int ret = -EFAULT;
  465. /* First see if old state is wanted. */
  466. if (ossptr) {
  467. if (put_user(current->sas_ss_sp + current->sas_ss_size,
  468. &ossptr->the_stack) ||
  469. __put_user(on_sig_stack(sp), &ossptr->cur_status))
  470. goto out;
  471. }
  472. /* Now see if we want to update the new state. */
  473. if (ssptr) {
  474. char *ss_sp;
  475. if (get_user(ss_sp, &ssptr->the_stack))
  476. goto out;
  477. /* If the current stack was set with sigaltstack, don't
  478. swap stacks while we are on it. */
  479. ret = -EPERM;
  480. if (current->sas_ss_sp && on_sig_stack(sp))
  481. goto out;
  482. /* Since we don't know the extent of the stack, and we don't
  483. track onstack-ness, but rather calculate it, we must
  484. presume a size. Ho hum this interface is lossy. */
  485. current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
  486. current->sas_ss_size = SIGSTKSZ;
  487. }
  488. ret = 0;
  489. out:
  490. return ret;
  491. }