signal.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555
  1. /* MN10300 Signal handling
  2. *
  3. * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
  4. * Written by David Howells (dhowells@redhat.com)
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public Licence
  8. * as published by the Free Software Foundation; either version
  9. * 2 of the Licence, or (at your option) any later version.
  10. */
  11. #include <linux/sched.h>
  12. #include <linux/mm.h>
  13. #include <linux/smp.h>
  14. #include <linux/kernel.h>
  15. #include <linux/signal.h>
  16. #include <linux/errno.h>
  17. #include <linux/wait.h>
  18. #include <linux/ptrace.h>
  19. #include <linux/unistd.h>
  20. #include <linux/stddef.h>
  21. #include <linux/tty.h>
  22. #include <linux/personality.h>
  23. #include <linux/suspend.h>
  24. #include <linux/tracehook.h>
  25. #include <asm/cacheflush.h>
  26. #include <asm/ucontext.h>
  27. #include <asm/uaccess.h>
  28. #include <asm/fpu.h>
  29. #include "sigframe.h"
  30. #define DEBUG_SIG 0
  31. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  32. /*
  33. * atomically swap in the new signal mask, and wait for a signal.
  34. */
  35. asmlinkage long sys_sigsuspend(int history0, int history1, old_sigset_t mask)
  36. {
  37. sigset_t blocked;
  38. siginitset(&blocked, mask);
  39. return sigsuspend(&blocked);
  40. }
  41. /*
  42. * set signal action syscall
  43. */
  44. asmlinkage long sys_sigaction(int sig,
  45. const struct old_sigaction __user *act,
  46. struct old_sigaction __user *oact)
  47. {
  48. struct k_sigaction new_ka, old_ka;
  49. int ret;
  50. if (act) {
  51. old_sigset_t mask;
  52. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  53. __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  54. __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
  55. __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
  56. __get_user(mask, &act->sa_mask))
  57. return -EFAULT;
  58. siginitset(&new_ka.sa.sa_mask, mask);
  59. }
  60. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  61. if (!ret && oact) {
  62. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  63. __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  64. __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
  65. __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
  66. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
  67. return -EFAULT;
  68. }
  69. return ret;
  70. }
  71. /*
  72. * set alternate signal stack syscall
  73. */
  74. asmlinkage long sys_sigaltstack(const stack_t __user *uss, stack_t *uoss)
  75. {
  76. return do_sigaltstack(uss, uoss, current_frame()->sp);
  77. }
  78. /*
  79. * do a signal return; undo the signal stack.
  80. */
  81. static int restore_sigcontext(struct pt_regs *regs,
  82. struct sigcontext __user *sc, long *_d0)
  83. {
  84. unsigned int err = 0;
  85. /* Always make any pending restarted system calls return -EINTR */
  86. current_thread_info()->restart_block.fn = do_no_restart_syscall;
  87. if (is_using_fpu(current))
  88. fpu_kill_state(current);
  89. #define COPY(x) err |= __get_user(regs->x, &sc->x)
  90. COPY(d1); COPY(d2); COPY(d3);
  91. COPY(a0); COPY(a1); COPY(a2); COPY(a3);
  92. COPY(e0); COPY(e1); COPY(e2); COPY(e3);
  93. COPY(e4); COPY(e5); COPY(e6); COPY(e7);
  94. COPY(lar); COPY(lir);
  95. COPY(mdr); COPY(mdrq);
  96. COPY(mcvf); COPY(mcrl); COPY(mcrh);
  97. COPY(sp); COPY(pc);
  98. #undef COPY
  99. {
  100. unsigned int tmpflags;
  101. #ifndef CONFIG_MN10300_USING_JTAG
  102. #define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \
  103. EPSW_T | EPSW_nAR)
  104. #else
  105. #define USER_EPSW (EPSW_FLAG_Z | EPSW_FLAG_N | EPSW_FLAG_C | EPSW_FLAG_V | \
  106. EPSW_nAR)
  107. #endif
  108. err |= __get_user(tmpflags, &sc->epsw);
  109. regs->epsw = (regs->epsw & ~USER_EPSW) |
  110. (tmpflags & USER_EPSW);
  111. regs->orig_d0 = -1; /* disable syscall checks */
  112. }
  113. {
  114. struct fpucontext *buf;
  115. err |= __get_user(buf, &sc->fpucontext);
  116. if (buf) {
  117. if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
  118. goto badframe;
  119. err |= fpu_restore_sigcontext(buf);
  120. }
  121. }
  122. err |= __get_user(*_d0, &sc->d0);
  123. return err;
  124. badframe:
  125. return 1;
  126. }
  127. /*
  128. * standard signal return syscall
  129. */
  130. asmlinkage long sys_sigreturn(void)
  131. {
  132. struct sigframe __user *frame;
  133. sigset_t set;
  134. long d0;
  135. frame = (struct sigframe __user *) current_frame()->sp;
  136. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  137. goto badframe;
  138. if (__get_user(set.sig[0], &frame->sc.oldmask))
  139. goto badframe;
  140. if (_NSIG_WORDS > 1 &&
  141. __copy_from_user(&set.sig[1], &frame->extramask,
  142. sizeof(frame->extramask)))
  143. goto badframe;
  144. sigdelsetmask(&set, ~_BLOCKABLE);
  145. set_current_blocked(&set);
  146. if (restore_sigcontext(current_frame(), &frame->sc, &d0))
  147. goto badframe;
  148. return d0;
  149. badframe:
  150. force_sig(SIGSEGV, current);
  151. return 0;
  152. }
  153. /*
  154. * realtime signal return syscall
  155. */
  156. asmlinkage long sys_rt_sigreturn(void)
  157. {
  158. struct rt_sigframe __user *frame;
  159. sigset_t set;
  160. long d0;
  161. frame = (struct rt_sigframe __user *) current_frame()->sp;
  162. if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
  163. goto badframe;
  164. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  165. goto badframe;
  166. sigdelsetmask(&set, ~_BLOCKABLE);
  167. set_current_blocked(&set);
  168. if (restore_sigcontext(current_frame(), &frame->uc.uc_mcontext, &d0))
  169. goto badframe;
  170. if (do_sigaltstack(&frame->uc.uc_stack, NULL, current_frame()->sp) ==
  171. -EFAULT)
  172. goto badframe;
  173. return d0;
  174. badframe:
  175. force_sig(SIGSEGV, current);
  176. return 0;
  177. }
  178. /*
  179. * store the userspace context into a signal frame
  180. */
  181. static int setup_sigcontext(struct sigcontext __user *sc,
  182. struct fpucontext *fpuctx,
  183. struct pt_regs *regs,
  184. unsigned long mask)
  185. {
  186. int tmp, err = 0;
  187. #define COPY(x) err |= __put_user(regs->x, &sc->x)
  188. COPY(d0); COPY(d1); COPY(d2); COPY(d3);
  189. COPY(a0); COPY(a1); COPY(a2); COPY(a3);
  190. COPY(e0); COPY(e1); COPY(e2); COPY(e3);
  191. COPY(e4); COPY(e5); COPY(e6); COPY(e7);
  192. COPY(lar); COPY(lir);
  193. COPY(mdr); COPY(mdrq);
  194. COPY(mcvf); COPY(mcrl); COPY(mcrh);
  195. COPY(sp); COPY(epsw); COPY(pc);
  196. #undef COPY
  197. tmp = fpu_setup_sigcontext(fpuctx);
  198. if (tmp < 0)
  199. err = 1;
  200. else
  201. err |= __put_user(tmp ? fpuctx : NULL, &sc->fpucontext);
  202. /* non-iBCS2 extensions.. */
  203. err |= __put_user(mask, &sc->oldmask);
  204. return err;
  205. }
  206. /*
  207. * determine which stack to use..
  208. */
  209. static inline void __user *get_sigframe(struct k_sigaction *ka,
  210. struct pt_regs *regs,
  211. size_t frame_size)
  212. {
  213. unsigned long sp;
  214. /* default to using normal stack */
  215. sp = regs->sp;
  216. /* this is the X/Open sanctioned signal stack switching. */
  217. if (ka->sa.sa_flags & SA_ONSTACK) {
  218. if (sas_ss_flags(sp) == 0)
  219. sp = current->sas_ss_sp + current->sas_ss_size;
  220. }
  221. return (void __user *) ((sp - frame_size) & ~7UL);
  222. }
  223. /*
  224. * set up a normal signal frame
  225. */
  226. static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
  227. struct pt_regs *regs)
  228. {
  229. struct sigframe __user *frame;
  230. int rsig;
  231. frame = get_sigframe(ka, regs, sizeof(*frame));
  232. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  233. goto give_sigsegv;
  234. rsig = sig;
  235. if (sig < 32 &&
  236. current_thread_info()->exec_domain &&
  237. current_thread_info()->exec_domain->signal_invmap)
  238. rsig = current_thread_info()->exec_domain->signal_invmap[sig];
  239. if (__put_user(rsig, &frame->sig) < 0 ||
  240. __put_user(&frame->sc, &frame->psc) < 0)
  241. goto give_sigsegv;
  242. if (setup_sigcontext(&frame->sc, &frame->fpuctx, regs, set->sig[0]))
  243. goto give_sigsegv;
  244. if (_NSIG_WORDS > 1) {
  245. if (__copy_to_user(frame->extramask, &set->sig[1],
  246. sizeof(frame->extramask)))
  247. goto give_sigsegv;
  248. }
  249. /* set up to return from userspace. If provided, use a stub already in
  250. * userspace */
  251. if (ka->sa.sa_flags & SA_RESTORER) {
  252. if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
  253. goto give_sigsegv;
  254. } else {
  255. if (__put_user((void (*)(void))frame->retcode,
  256. &frame->pretcode))
  257. goto give_sigsegv;
  258. /* this is mov $,d0; syscall 0 */
  259. if (__put_user(0x2c, (char *)(frame->retcode + 0)) ||
  260. __put_user(__NR_sigreturn, (char *)(frame->retcode + 1)) ||
  261. __put_user(0x00, (char *)(frame->retcode + 2)) ||
  262. __put_user(0xf0, (char *)(frame->retcode + 3)) ||
  263. __put_user(0xe0, (char *)(frame->retcode + 4)))
  264. goto give_sigsegv;
  265. flush_icache_range((unsigned long) frame->retcode,
  266. (unsigned long) frame->retcode + 5);
  267. }
  268. /* set up registers for signal handler */
  269. regs->sp = (unsigned long) frame;
  270. regs->pc = (unsigned long) ka->sa.sa_handler;
  271. regs->d0 = sig;
  272. regs->d1 = (unsigned long) &frame->sc;
  273. /* the tracer may want to single-step inside the handler */
  274. if (test_thread_flag(TIF_SINGLESTEP))
  275. ptrace_notify(SIGTRAP);
  276. #if DEBUG_SIG
  277. printk(KERN_DEBUG "SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
  278. sig, current->comm, current->pid, frame, regs->pc,
  279. frame->pretcode);
  280. #endif
  281. return 0;
  282. give_sigsegv:
  283. force_sigsegv(sig, current);
  284. return -EFAULT;
  285. }
  286. /*
  287. * set up a realtime signal frame
  288. */
  289. static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
  290. sigset_t *set, struct pt_regs *regs)
  291. {
  292. struct rt_sigframe __user *frame;
  293. int rsig;
  294. frame = get_sigframe(ka, regs, sizeof(*frame));
  295. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  296. goto give_sigsegv;
  297. rsig = sig;
  298. if (sig < 32 &&
  299. current_thread_info()->exec_domain &&
  300. current_thread_info()->exec_domain->signal_invmap)
  301. rsig = current_thread_info()->exec_domain->signal_invmap[sig];
  302. if (__put_user(rsig, &frame->sig) ||
  303. __put_user(&frame->info, &frame->pinfo) ||
  304. __put_user(&frame->uc, &frame->puc) ||
  305. copy_siginfo_to_user(&frame->info, info))
  306. goto give_sigsegv;
  307. /* create the ucontext. */
  308. if (__put_user(0, &frame->uc.uc_flags) ||
  309. __put_user(0, &frame->uc.uc_link) ||
  310. __put_user((void *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp) ||
  311. __put_user(sas_ss_flags(regs->sp), &frame->uc.uc_stack.ss_flags) ||
  312. __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size) ||
  313. setup_sigcontext(&frame->uc.uc_mcontext,
  314. &frame->fpuctx, regs, set->sig[0]) ||
  315. __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))
  316. goto give_sigsegv;
  317. /* set up to return from userspace. If provided, use a stub already in
  318. * userspace */
  319. if (ka->sa.sa_flags & SA_RESTORER) {
  320. if (__put_user(ka->sa.sa_restorer, &frame->pretcode))
  321. goto give_sigsegv;
  322. } else {
  323. if (__put_user((void(*)(void))frame->retcode,
  324. &frame->pretcode) ||
  325. /* This is mov $,d0; syscall 0 */
  326. __put_user(0x2c, (char *)(frame->retcode + 0)) ||
  327. __put_user(__NR_rt_sigreturn,
  328. (char *)(frame->retcode + 1)) ||
  329. __put_user(0x00, (char *)(frame->retcode + 2)) ||
  330. __put_user(0xf0, (char *)(frame->retcode + 3)) ||
  331. __put_user(0xe0, (char *)(frame->retcode + 4)))
  332. goto give_sigsegv;
  333. flush_icache_range((u_long) frame->retcode,
  334. (u_long) frame->retcode + 5);
  335. }
  336. /* Set up registers for signal handler */
  337. regs->sp = (unsigned long) frame;
  338. regs->pc = (unsigned long) ka->sa.sa_handler;
  339. regs->d0 = sig;
  340. regs->d1 = (long) &frame->info;
  341. /* the tracer may want to single-step inside the handler */
  342. if (test_thread_flag(TIF_SINGLESTEP))
  343. ptrace_notify(SIGTRAP);
  344. #if DEBUG_SIG
  345. printk(KERN_DEBUG "SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
  346. sig, current->comm, current->pid, frame, regs->pc,
  347. frame->pretcode);
  348. #endif
  349. return 0;
  350. give_sigsegv:
  351. force_sigsegv(sig, current);
  352. return -EFAULT;
  353. }
  354. static inline void stepback(struct pt_regs *regs)
  355. {
  356. regs->pc -= 2;
  357. regs->orig_d0 = -1;
  358. }
  359. /*
  360. * handle the actual delivery of a signal to userspace
  361. */
  362. static int handle_signal(int sig,
  363. siginfo_t *info, struct k_sigaction *ka,
  364. sigset_t *oldset, struct pt_regs *regs)
  365. {
  366. int ret;
  367. /* Are we from a system call? */
  368. if (regs->orig_d0 >= 0) {
  369. /* If so, check system call restarting.. */
  370. switch (regs->d0) {
  371. case -ERESTART_RESTARTBLOCK:
  372. case -ERESTARTNOHAND:
  373. regs->d0 = -EINTR;
  374. break;
  375. case -ERESTARTSYS:
  376. if (!(ka->sa.sa_flags & SA_RESTART)) {
  377. regs->d0 = -EINTR;
  378. break;
  379. }
  380. /* fallthrough */
  381. case -ERESTARTNOINTR:
  382. regs->d0 = regs->orig_d0;
  383. stepback(regs);
  384. }
  385. }
  386. /* Set up the stack frame */
  387. if (ka->sa.sa_flags & SA_SIGINFO)
  388. ret = setup_rt_frame(sig, ka, info, oldset, regs);
  389. else
  390. ret = setup_frame(sig, ka, oldset, regs);
  391. if (ret == 0)
  392. block_sigmask(ka, sig);
  393. return ret;
  394. }
  395. /*
  396. * handle a potential signal
  397. */
  398. static void do_signal(struct pt_regs *regs)
  399. {
  400. struct k_sigaction ka;
  401. siginfo_t info;
  402. sigset_t *oldset;
  403. int signr;
  404. /* we want the common case to go fast, which is why we may in certain
  405. * cases get here from kernel mode */
  406. if (!user_mode(regs))
  407. return;
  408. if (test_thread_flag(TIF_RESTORE_SIGMASK))
  409. oldset = &current->saved_sigmask;
  410. else
  411. oldset = &current->blocked;
  412. signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  413. if (signr > 0) {
  414. if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
  415. /* a signal was successfully delivered; the saved
  416. * sigmask will have been stored in the signal frame,
  417. * and will be restored by sigreturn, so we can simply
  418. * clear the TIF_RESTORE_SIGMASK flag */
  419. if (test_thread_flag(TIF_RESTORE_SIGMASK))
  420. clear_thread_flag(TIF_RESTORE_SIGMASK);
  421. tracehook_signal_handler(signr, &info, &ka, regs,
  422. test_thread_flag(TIF_SINGLESTEP));
  423. }
  424. return;
  425. }
  426. /* did we come from a system call? */
  427. if (regs->orig_d0 >= 0) {
  428. /* restart the system call - no handlers present */
  429. switch (regs->d0) {
  430. case -ERESTARTNOHAND:
  431. case -ERESTARTSYS:
  432. case -ERESTARTNOINTR:
  433. regs->d0 = regs->orig_d0;
  434. stepback(regs);
  435. break;
  436. case -ERESTART_RESTARTBLOCK:
  437. regs->d0 = __NR_restart_syscall;
  438. stepback(regs);
  439. break;
  440. }
  441. }
  442. /* if there's no signal to deliver, we just put the saved sigmask
  443. * back */
  444. restore_saved_sigmask();
  445. }
  446. /*
  447. * notification of userspace execution resumption
  448. * - triggered by current->work.notify_resume
  449. */
  450. asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags)
  451. {
  452. /* Pending single-step? */
  453. if (thread_info_flags & _TIF_SINGLESTEP) {
  454. #ifndef CONFIG_MN10300_USING_JTAG
  455. regs->epsw |= EPSW_T;
  456. clear_thread_flag(TIF_SINGLESTEP);
  457. #else
  458. BUG(); /* no h/w single-step if using JTAG unit */
  459. #endif
  460. }
  461. /* deal with pending signal delivery */
  462. if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
  463. do_signal(regs);
  464. if (thread_info_flags & _TIF_NOTIFY_RESUME) {
  465. clear_thread_flag(TIF_NOTIFY_RESUME);
  466. tracehook_notify_resume(current_frame());
  467. }
  468. }