signal.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626
  1. /*
  2. * This file is subject to the terms and conditions of the GNU General Public
  3. * License. See the file "COPYING" in the main directory of this archive
  4. * for more details.
  5. *
  6. * Copyright (C) 1991, 1992 Linus Torvalds
  7. * Copyright (C) 1994 - 2000 Ralf Baechle
  8. * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  9. */
  10. #include <linux/cache.h>
  11. #include <linux/context_tracking.h>
  12. #include <linux/irqflags.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/personality.h>
  16. #include <linux/smp.h>
  17. #include <linux/kernel.h>
  18. #include <linux/signal.h>
  19. #include <linux/errno.h>
  20. #include <linux/wait.h>
  21. #include <linux/ptrace.h>
  22. #include <linux/unistd.h>
  23. #include <linux/compiler.h>
  24. #include <linux/syscalls.h>
  25. #include <linux/uaccess.h>
  26. #include <linux/tracehook.h>
  27. #include <asm/abi.h>
  28. #include <asm/asm.h>
  29. #include <linux/bitops.h>
  30. #include <asm/cacheflush.h>
  31. #include <asm/fpu.h>
  32. #include <asm/sim.h>
  33. #include <asm/ucontext.h>
  34. #include <asm/cpu-features.h>
  35. #include <asm/war.h>
  36. #include <asm/vdso.h>
  37. #include <asm/dsp.h>
  38. #include <asm/inst.h>
  39. #include "signal-common.h"
  40. static int (*save_fp_context)(struct sigcontext __user *sc);
  41. static int (*restore_fp_context)(struct sigcontext __user *sc);
  42. extern asmlinkage int _save_fp_context(struct sigcontext __user *sc);
  43. extern asmlinkage int _restore_fp_context(struct sigcontext __user *sc);
  44. extern asmlinkage int fpu_emulator_save_context(struct sigcontext __user *sc);
  45. extern asmlinkage int fpu_emulator_restore_context(struct sigcontext __user *sc);
  46. struct sigframe {
  47. u32 sf_ass[4]; /* argument save space for o32 */
  48. u32 sf_pad[2]; /* Was: signal trampoline */
  49. struct sigcontext sf_sc;
  50. sigset_t sf_mask;
  51. };
  52. struct rt_sigframe {
  53. u32 rs_ass[4]; /* argument save space for o32 */
  54. u32 rs_pad[2]; /* Was: signal trampoline */
  55. struct siginfo rs_info;
  56. struct ucontext rs_uc;
  57. };
  58. /*
  59. * Helper routines
  60. */
  61. static int protected_save_fp_context(struct sigcontext __user *sc)
  62. {
  63. int err;
  64. while (1) {
  65. lock_fpu_owner();
  66. own_fpu_inatomic(1);
  67. err = save_fp_context(sc); /* this might fail */
  68. unlock_fpu_owner();
  69. if (likely(!err))
  70. break;
  71. /* touch the sigcontext and try again */
  72. err = __put_user(0, &sc->sc_fpregs[0]) |
  73. __put_user(0, &sc->sc_fpregs[31]) |
  74. __put_user(0, &sc->sc_fpc_csr);
  75. if (err)
  76. break; /* really bad sigcontext */
  77. }
  78. return err;
  79. }
  80. static int protected_restore_fp_context(struct sigcontext __user *sc)
  81. {
  82. int err, tmp __maybe_unused;
  83. while (1) {
  84. lock_fpu_owner();
  85. own_fpu_inatomic(0);
  86. err = restore_fp_context(sc); /* this might fail */
  87. unlock_fpu_owner();
  88. if (likely(!err))
  89. break;
  90. /* touch the sigcontext and try again */
  91. err = __get_user(tmp, &sc->sc_fpregs[0]) |
  92. __get_user(tmp, &sc->sc_fpregs[31]) |
  93. __get_user(tmp, &sc->sc_fpc_csr);
  94. if (err)
  95. break; /* really bad sigcontext */
  96. }
  97. return err;
  98. }
  99. int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
  100. {
  101. int err = 0;
  102. int i;
  103. unsigned int used_math;
  104. err |= __put_user(regs->cp0_epc, &sc->sc_pc);
  105. err |= __put_user(0, &sc->sc_regs[0]);
  106. for (i = 1; i < 32; i++)
  107. err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
  108. #ifdef CONFIG_CPU_HAS_SMARTMIPS
  109. err |= __put_user(regs->acx, &sc->sc_acx);
  110. #endif
  111. err |= __put_user(regs->hi, &sc->sc_mdhi);
  112. err |= __put_user(regs->lo, &sc->sc_mdlo);
  113. if (cpu_has_dsp) {
  114. err |= __put_user(mfhi1(), &sc->sc_hi1);
  115. err |= __put_user(mflo1(), &sc->sc_lo1);
  116. err |= __put_user(mfhi2(), &sc->sc_hi2);
  117. err |= __put_user(mflo2(), &sc->sc_lo2);
  118. err |= __put_user(mfhi3(), &sc->sc_hi3);
  119. err |= __put_user(mflo3(), &sc->sc_lo3);
  120. err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
  121. }
  122. used_math = !!used_math();
  123. err |= __put_user(used_math, &sc->sc_used_math);
  124. if (used_math) {
  125. /*
  126. * Save FPU state to signal context. Signal handler
  127. * will "inherit" current FPU state.
  128. */
  129. err |= protected_save_fp_context(sc);
  130. }
  131. return err;
  132. }
  133. int fpcsr_pending(unsigned int __user *fpcsr)
  134. {
  135. int err, sig = 0;
  136. unsigned int csr, enabled;
  137. err = __get_user(csr, fpcsr);
  138. enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
  139. /*
  140. * If the signal handler set some FPU exceptions, clear it and
  141. * send SIGFPE.
  142. */
  143. if (csr & enabled) {
  144. csr &= ~enabled;
  145. err |= __put_user(csr, fpcsr);
  146. sig = SIGFPE;
  147. }
  148. return err ?: sig;
  149. }
  150. static int
  151. check_and_restore_fp_context(struct sigcontext __user *sc)
  152. {
  153. int err, sig;
  154. err = sig = fpcsr_pending(&sc->sc_fpc_csr);
  155. if (err > 0)
  156. err = 0;
  157. err |= protected_restore_fp_context(sc);
  158. return err ?: sig;
  159. }
  160. int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
  161. {
  162. unsigned int used_math;
  163. unsigned long treg;
  164. int err = 0;
  165. int i;
  166. /* Always make any pending restarted system calls return -EINTR */
  167. current_thread_info()->restart_block.fn = do_no_restart_syscall;
  168. err |= __get_user(regs->cp0_epc, &sc->sc_pc);
  169. #ifdef CONFIG_CPU_HAS_SMARTMIPS
  170. err |= __get_user(regs->acx, &sc->sc_acx);
  171. #endif
  172. err |= __get_user(regs->hi, &sc->sc_mdhi);
  173. err |= __get_user(regs->lo, &sc->sc_mdlo);
  174. if (cpu_has_dsp) {
  175. err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
  176. err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
  177. err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
  178. err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
  179. err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
  180. err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
  181. err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
  182. }
  183. for (i = 1; i < 32; i++)
  184. err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
  185. err |= __get_user(used_math, &sc->sc_used_math);
  186. conditional_used_math(used_math);
  187. if (used_math) {
  188. /* restore fpu context if we have used it before */
  189. if (!err)
  190. err = check_and_restore_fp_context(sc);
  191. } else {
  192. /* signal handler may have used FPU. Give it up. */
  193. lose_fpu(0);
  194. }
  195. return err;
  196. }
  197. void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
  198. size_t frame_size)
  199. {
  200. unsigned long sp;
  201. /* Default to using normal stack */
  202. sp = regs->regs[29];
  203. /*
  204. * FPU emulator may have it's own trampoline active just
  205. * above the user stack, 16-bytes before the next lowest
  206. * 16 byte boundary. Try to avoid trashing it.
  207. */
  208. sp -= 32;
  209. /* This is the X/Open sanctioned signal stack switching. */
  210. if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
  211. sp = current->sas_ss_sp + current->sas_ss_size;
  212. return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? ~(cpu_icache_line_size()-1) : ALMASK));
  213. }
  214. /*
  215. * Atomically swap in the new signal mask, and wait for a signal.
  216. */
  217. #ifdef CONFIG_TRAD_SIGNALS
  218. SYSCALL_DEFINE1(sigsuspend, sigset_t __user *, uset)
  219. {
  220. return sys_rt_sigsuspend(uset, sizeof(sigset_t));
  221. }
  222. #endif
  223. #ifdef CONFIG_TRAD_SIGNALS
  224. SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
  225. struct sigaction __user *, oact)
  226. {
  227. struct k_sigaction new_ka, old_ka;
  228. int ret;
  229. int err = 0;
  230. if (act) {
  231. old_sigset_t mask;
  232. if (!access_ok(VERIFY_READ, act, sizeof(*act)))
  233. return -EFAULT;
  234. err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
  235. err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  236. err |= __get_user(mask, &act->sa_mask.sig[0]);
  237. if (err)
  238. return -EFAULT;
  239. siginitset(&new_ka.sa.sa_mask, mask);
  240. }
  241. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  242. if (!ret && oact) {
  243. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
  244. return -EFAULT;
  245. err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  246. err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
  247. err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
  248. err |= __put_user(0, &oact->sa_mask.sig[1]);
  249. err |= __put_user(0, &oact->sa_mask.sig[2]);
  250. err |= __put_user(0, &oact->sa_mask.sig[3]);
  251. if (err)
  252. return -EFAULT;
  253. }
  254. return ret;
  255. }
  256. #endif
  257. #ifdef CONFIG_TRAD_SIGNALS
  258. asmlinkage void sys_sigreturn(nabi_no_regargs struct pt_regs regs)
  259. {
  260. struct sigframe __user *frame;
  261. sigset_t blocked;
  262. int sig;
  263. frame = (struct sigframe __user *) regs.regs[29];
  264. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  265. goto badframe;
  266. if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
  267. goto badframe;
  268. set_current_blocked(&blocked);
  269. sig = restore_sigcontext(&regs, &frame->sf_sc);
  270. if (sig < 0)
  271. goto badframe;
  272. else if (sig)
  273. force_sig(sig, current);
  274. /*
  275. * Don't let your children do this ...
  276. */
  277. __asm__ __volatile__(
  278. "move\t$29, %0\n\t"
  279. "j\tsyscall_exit"
  280. :/* no outputs */
  281. :"r" (&regs));
  282. /* Unreached */
  283. badframe:
  284. force_sig(SIGSEGV, current);
  285. }
  286. #endif /* CONFIG_TRAD_SIGNALS */
  287. asmlinkage void sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
  288. {
  289. struct rt_sigframe __user *frame;
  290. sigset_t set;
  291. int sig;
  292. frame = (struct rt_sigframe __user *) regs.regs[29];
  293. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  294. goto badframe;
  295. if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
  296. goto badframe;
  297. set_current_blocked(&set);
  298. sig = restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext);
  299. if (sig < 0)
  300. goto badframe;
  301. else if (sig)
  302. force_sig(sig, current);
  303. if (restore_altstack(&frame->rs_uc.uc_stack))
  304. goto badframe;
  305. /*
  306. * Don't let your children do this ...
  307. */
  308. __asm__ __volatile__(
  309. "move\t$29, %0\n\t"
  310. "j\tsyscall_exit"
  311. :/* no outputs */
  312. :"r" (&regs));
  313. /* Unreached */
  314. badframe:
  315. force_sig(SIGSEGV, current);
  316. }
  317. #ifdef CONFIG_TRAD_SIGNALS
  318. static int setup_frame(void *sig_return, struct k_sigaction *ka,
  319. struct pt_regs *regs, int signr, sigset_t *set)
  320. {
  321. struct sigframe __user *frame;
  322. int err = 0;
  323. frame = get_sigframe(ka, regs, sizeof(*frame));
  324. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  325. goto give_sigsegv;
  326. err |= setup_sigcontext(regs, &frame->sf_sc);
  327. err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
  328. if (err)
  329. goto give_sigsegv;
  330. /*
  331. * Arguments to signal handler:
  332. *
  333. * a0 = signal number
  334. * a1 = 0 (should be cause)
  335. * a2 = pointer to struct sigcontext
  336. *
  337. * $25 and c0_epc point to the signal handler, $29 points to the
  338. * struct sigframe.
  339. */
  340. regs->regs[ 4] = signr;
  341. regs->regs[ 5] = 0;
  342. regs->regs[ 6] = (unsigned long) &frame->sf_sc;
  343. regs->regs[29] = (unsigned long) frame;
  344. regs->regs[31] = (unsigned long) sig_return;
  345. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  346. DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
  347. current->comm, current->pid,
  348. frame, regs->cp0_epc, regs->regs[31]);
  349. return 0;
  350. give_sigsegv:
  351. force_sigsegv(signr, current);
  352. return -EFAULT;
  353. }
  354. #endif
  355. static int setup_rt_frame(void *sig_return, struct k_sigaction *ka,
  356. struct pt_regs *regs, int signr, sigset_t *set,
  357. siginfo_t *info)
  358. {
  359. struct rt_sigframe __user *frame;
  360. int err = 0;
  361. frame = get_sigframe(ka, regs, sizeof(*frame));
  362. if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
  363. goto give_sigsegv;
  364. /* Create siginfo. */
  365. err |= copy_siginfo_to_user(&frame->rs_info, info);
  366. /* Create the ucontext. */
  367. err |= __put_user(0, &frame->rs_uc.uc_flags);
  368. err |= __put_user(NULL, &frame->rs_uc.uc_link);
  369. err |= __save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
  370. err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
  371. err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
  372. if (err)
  373. goto give_sigsegv;
  374. /*
  375. * Arguments to signal handler:
  376. *
  377. * a0 = signal number
  378. * a1 = 0 (should be cause)
  379. * a2 = pointer to ucontext
  380. *
  381. * $25 and c0_epc point to the signal handler, $29 points to
  382. * the struct rt_sigframe.
  383. */
  384. regs->regs[ 4] = signr;
  385. regs->regs[ 5] = (unsigned long) &frame->rs_info;
  386. regs->regs[ 6] = (unsigned long) &frame->rs_uc;
  387. regs->regs[29] = (unsigned long) frame;
  388. regs->regs[31] = (unsigned long) sig_return;
  389. regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
  390. DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
  391. current->comm, current->pid,
  392. frame, regs->cp0_epc, regs->regs[31]);
  393. return 0;
  394. give_sigsegv:
  395. force_sigsegv(signr, current);
  396. return -EFAULT;
  397. }
  398. struct mips_abi mips_abi = {
  399. #ifdef CONFIG_TRAD_SIGNALS
  400. .setup_frame = setup_frame,
  401. .signal_return_offset = offsetof(struct mips_vdso, signal_trampoline),
  402. #endif
  403. .setup_rt_frame = setup_rt_frame,
  404. .rt_signal_return_offset =
  405. offsetof(struct mips_vdso, rt_signal_trampoline),
  406. .restart = __NR_restart_syscall
  407. };
  408. static void handle_signal(unsigned long sig, siginfo_t *info,
  409. struct k_sigaction *ka, struct pt_regs *regs)
  410. {
  411. sigset_t *oldset = sigmask_to_save();
  412. int ret;
  413. struct mips_abi *abi = current->thread.abi;
  414. #ifdef CONFIG_CPU_MICROMIPS
  415. void *vdso;
  416. unsigned int tmp = (unsigned int)current->mm->context.vdso;
  417. set_isa16_mode(tmp);
  418. vdso = (void *)tmp;
  419. #else
  420. void *vdso = current->mm->context.vdso;
  421. #endif
  422. if (regs->regs[0]) {
  423. switch(regs->regs[2]) {
  424. case ERESTART_RESTARTBLOCK:
  425. case ERESTARTNOHAND:
  426. regs->regs[2] = EINTR;
  427. break;
  428. case ERESTARTSYS:
  429. if (!(ka->sa.sa_flags & SA_RESTART)) {
  430. regs->regs[2] = EINTR;
  431. break;
  432. }
  433. /* fallthrough */
  434. case ERESTARTNOINTR:
  435. regs->regs[7] = regs->regs[26];
  436. regs->regs[2] = regs->regs[0];
  437. regs->cp0_epc -= 4;
  438. }
  439. regs->regs[0] = 0; /* Don't deal with this again. */
  440. }
  441. if (sig_uses_siginfo(ka))
  442. ret = abi->setup_rt_frame(vdso + abi->rt_signal_return_offset,
  443. ka, regs, sig, oldset, info);
  444. else
  445. ret = abi->setup_frame(vdso + abi->signal_return_offset,
  446. ka, regs, sig, oldset);
  447. if (ret)
  448. return;
  449. signal_delivered(sig, info, ka, regs, 0);
  450. }
  451. static void do_signal(struct pt_regs *regs)
  452. {
  453. struct k_sigaction ka;
  454. siginfo_t info;
  455. int signr;
  456. signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  457. if (signr > 0) {
  458. /* Whee! Actually deliver the signal. */
  459. handle_signal(signr, &info, &ka, regs);
  460. return;
  461. }
  462. if (regs->regs[0]) {
  463. switch (regs->regs[2]) {
  464. case ERESTARTNOHAND:
  465. case ERESTARTSYS:
  466. case ERESTARTNOINTR:
  467. regs->regs[2] = regs->regs[0];
  468. regs->regs[7] = regs->regs[26];
  469. regs->cp0_epc -= 4;
  470. break;
  471. case ERESTART_RESTARTBLOCK:
  472. regs->regs[2] = current->thread.abi->restart;
  473. regs->regs[7] = regs->regs[26];
  474. regs->cp0_epc -= 4;
  475. break;
  476. }
  477. regs->regs[0] = 0; /* Don't deal with this again. */
  478. }
  479. /*
  480. * If there's no signal to deliver, we just put the saved sigmask
  481. * back
  482. */
  483. restore_saved_sigmask();
  484. }
  485. /*
  486. * notification of userspace execution resumption
  487. * - triggered by the TIF_WORK_MASK flags
  488. */
  489. asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
  490. __u32 thread_info_flags)
  491. {
  492. local_irq_enable();
  493. user_exit();
  494. /* deal with pending signal delivery */
  495. if (thread_info_flags & _TIF_SIGPENDING)
  496. do_signal(regs);
  497. if (thread_info_flags & _TIF_NOTIFY_RESUME) {
  498. clear_thread_flag(TIF_NOTIFY_RESUME);
  499. tracehook_notify_resume(regs);
  500. }
  501. user_enter();
  502. }
  503. #ifdef CONFIG_SMP
  504. static int smp_save_fp_context(struct sigcontext __user *sc)
  505. {
  506. return raw_cpu_has_fpu
  507. ? _save_fp_context(sc)
  508. : fpu_emulator_save_context(sc);
  509. }
  510. static int smp_restore_fp_context(struct sigcontext __user *sc)
  511. {
  512. return raw_cpu_has_fpu
  513. ? _restore_fp_context(sc)
  514. : fpu_emulator_restore_context(sc);
  515. }
  516. #endif
  517. static int signal_setup(void)
  518. {
  519. #ifdef CONFIG_SMP
  520. /* For now just do the cpu_has_fpu check when the functions are invoked */
  521. save_fp_context = smp_save_fp_context;
  522. restore_fp_context = smp_restore_fp_context;
  523. #else
  524. if (cpu_has_fpu) {
  525. save_fp_context = _save_fp_context;
  526. restore_fp_context = _restore_fp_context;
  527. } else {
  528. save_fp_context = fpu_emulator_save_context;
  529. restore_fp_context = fpu_emulator_restore_context;
  530. }
  531. #endif
  532. return 0;
  533. }
  534. arch_initcall(signal_setup);