signal.c 15 KB

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