signal.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968
  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. * Copyright (C) 2014, Imagination Technologies Ltd.
  10. */
  11. #include <linux/cache.h>
  12. #include <linux/context_tracking.h>
  13. #include <linux/irqflags.h>
  14. #include <linux/sched.h>
  15. #include <linux/mm.h>
  16. #include <linux/personality.h>
  17. #include <linux/smp.h>
  18. #include <linux/kernel.h>
  19. #include <linux/signal.h>
  20. #include <linux/errno.h>
  21. #include <linux/wait.h>
  22. #include <linux/ptrace.h>
  23. #include <linux/unistd.h>
  24. #include <linux/uprobes.h>
  25. #include <linux/compiler.h>
  26. #include <linux/syscalls.h>
  27. #include <linux/uaccess.h>
  28. #include <linux/resume_user_mode.h>
  29. #include <asm/abi.h>
  30. #include <asm/asm.h>
  31. #include <linux/bitops.h>
  32. #include <asm/cacheflush.h>
  33. #include <asm/fpu.h>
  34. #include <asm/sim.h>
  35. #include <asm/ucontext.h>
  36. #include <asm/cpu-features.h>
  37. #include <asm/dsp.h>
  38. #include <asm/inst.h>
  39. #include <asm/msa.h>
  40. #include "signal-common.h"
  41. static int (*save_fp_context)(void __user *sc);
  42. static int (*restore_fp_context)(void __user *sc);
  43. struct sigframe {
  44. u32 sf_ass[4]; /* argument save space for o32 */
  45. u32 sf_pad[2]; /* Was: signal trampoline */
  46. /* Matches struct ucontext from its uc_mcontext field onwards */
  47. struct sigcontext sf_sc;
  48. sigset_t sf_mask;
  49. unsigned long long sf_extcontext[];
  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. #ifdef CONFIG_MIPS_FP_SUPPORT
  58. /*
  59. * Thread saved context copy to/from a signal context presumed to be on the
  60. * user stack, and therefore accessed with appropriate macros from uaccess.h.
  61. */
  62. static int copy_fp_to_sigcontext(void __user *sc)
  63. {
  64. struct mips_abi *abi = current->thread.abi;
  65. uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
  66. uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
  67. int i;
  68. int err = 0;
  69. int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
  70. for (i = 0; i < NUM_FPU_REGS; i += inc) {
  71. err |=
  72. __put_user(get_fpr64(&current->thread.fpu.fpr[i], 0),
  73. &fpregs[i]);
  74. }
  75. err |= __put_user(current->thread.fpu.fcr31, csr);
  76. return err;
  77. }
  78. static int copy_fp_from_sigcontext(void __user *sc)
  79. {
  80. struct mips_abi *abi = current->thread.abi;
  81. uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
  82. uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
  83. int i;
  84. int err = 0;
  85. int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
  86. u64 fpr_val;
  87. for (i = 0; i < NUM_FPU_REGS; i += inc) {
  88. err |= __get_user(fpr_val, &fpregs[i]);
  89. set_fpr64(&current->thread.fpu.fpr[i], 0, fpr_val);
  90. }
  91. err |= __get_user(current->thread.fpu.fcr31, csr);
  92. return err;
  93. }
  94. #else /* !CONFIG_MIPS_FP_SUPPORT */
  95. static int copy_fp_to_sigcontext(void __user *sc)
  96. {
  97. return 0;
  98. }
  99. static int copy_fp_from_sigcontext(void __user *sc)
  100. {
  101. return 0;
  102. }
  103. #endif /* !CONFIG_MIPS_FP_SUPPORT */
  104. /*
  105. * Wrappers for the assembly _{save,restore}_fp_context functions.
  106. */
  107. static int save_hw_fp_context(void __user *sc)
  108. {
  109. struct mips_abi *abi = current->thread.abi;
  110. uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
  111. uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
  112. return _save_fp_context(fpregs, csr);
  113. }
  114. static int restore_hw_fp_context(void __user *sc)
  115. {
  116. struct mips_abi *abi = current->thread.abi;
  117. uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
  118. uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
  119. return _restore_fp_context(fpregs, csr);
  120. }
  121. /*
  122. * Extended context handling.
  123. */
  124. static inline void __user *sc_to_extcontext(void __user *sc)
  125. {
  126. struct ucontext __user *uc;
  127. /*
  128. * We can just pretend the sigcontext is always embedded in a struct
  129. * ucontext here, because the offset from sigcontext to extended
  130. * context is the same in the struct sigframe case.
  131. */
  132. uc = container_of(sc, struct ucontext, uc_mcontext);
  133. return &uc->uc_extcontext;
  134. }
  135. #ifdef CONFIG_CPU_HAS_MSA
  136. static int save_msa_extcontext(void __user *buf)
  137. {
  138. struct msa_extcontext __user *msa = buf;
  139. uint64_t val;
  140. int i, err;
  141. if (!thread_msa_context_live())
  142. return 0;
  143. /*
  144. * Ensure that we can't lose the live MSA context between checking
  145. * for it & writing it to memory.
  146. */
  147. preempt_disable();
  148. if (is_msa_enabled()) {
  149. /*
  150. * There are no EVA versions of the vector register load/store
  151. * instructions, so MSA context has to be saved to kernel memory
  152. * and then copied to user memory. The save to kernel memory
  153. * should already have been done when handling scalar FP
  154. * context.
  155. */
  156. BUG_ON(IS_ENABLED(CONFIG_EVA));
  157. err = __put_user(read_msa_csr(), &msa->csr);
  158. err |= _save_msa_all_upper(&msa->wr);
  159. preempt_enable();
  160. } else {
  161. preempt_enable();
  162. err = __put_user(current->thread.fpu.msacsr, &msa->csr);
  163. for (i = 0; i < NUM_FPU_REGS; i++) {
  164. val = get_fpr64(&current->thread.fpu.fpr[i], 1);
  165. err |= __put_user(val, &msa->wr[i]);
  166. }
  167. }
  168. err |= __put_user(MSA_EXTCONTEXT_MAGIC, &msa->ext.magic);
  169. err |= __put_user(sizeof(*msa), &msa->ext.size);
  170. return err ? -EFAULT : sizeof(*msa);
  171. }
  172. static int restore_msa_extcontext(void __user *buf, unsigned int size)
  173. {
  174. struct msa_extcontext __user *msa = buf;
  175. unsigned long long val;
  176. unsigned int csr;
  177. int i, err;
  178. if (size != sizeof(*msa))
  179. return -EINVAL;
  180. err = get_user(csr, &msa->csr);
  181. if (err)
  182. return err;
  183. preempt_disable();
  184. if (is_msa_enabled()) {
  185. /*
  186. * There are no EVA versions of the vector register load/store
  187. * instructions, so MSA context has to be copied to kernel
  188. * memory and later loaded to registers. The same is true of
  189. * scalar FP context, so FPU & MSA should have already been
  190. * disabled whilst handling scalar FP context.
  191. */
  192. BUG_ON(IS_ENABLED(CONFIG_EVA));
  193. write_msa_csr(csr);
  194. err |= _restore_msa_all_upper(&msa->wr);
  195. preempt_enable();
  196. } else {
  197. preempt_enable();
  198. current->thread.fpu.msacsr = csr;
  199. for (i = 0; i < NUM_FPU_REGS; i++) {
  200. err |= __get_user(val, &msa->wr[i]);
  201. set_fpr64(&current->thread.fpu.fpr[i], 1, val);
  202. }
  203. }
  204. return err;
  205. }
  206. #else /* !CONFIG_CPU_HAS_MSA */
  207. static int save_msa_extcontext(void __user *buf)
  208. {
  209. return 0;
  210. }
  211. static int restore_msa_extcontext(void __user *buf, unsigned int size)
  212. {
  213. return SIGSYS;
  214. }
  215. #endif /* !CONFIG_CPU_HAS_MSA */
  216. static int save_extcontext(void __user *buf)
  217. {
  218. int sz;
  219. sz = save_msa_extcontext(buf);
  220. if (sz < 0)
  221. return sz;
  222. buf += sz;
  223. /* If no context was saved then trivially return */
  224. if (!sz)
  225. return 0;
  226. /* Write the end marker */
  227. if (__put_user(END_EXTCONTEXT_MAGIC, (u32 *)buf))
  228. return -EFAULT;
  229. sz += sizeof(((struct extcontext *)NULL)->magic);
  230. return sz;
  231. }
  232. static int restore_extcontext(void __user *buf)
  233. {
  234. struct extcontext ext;
  235. int err;
  236. while (1) {
  237. err = __get_user(ext.magic, (unsigned int *)buf);
  238. if (err)
  239. return err;
  240. if (ext.magic == END_EXTCONTEXT_MAGIC)
  241. return 0;
  242. err = __get_user(ext.size, (unsigned int *)(buf
  243. + offsetof(struct extcontext, size)));
  244. if (err)
  245. return err;
  246. switch (ext.magic) {
  247. case MSA_EXTCONTEXT_MAGIC:
  248. err = restore_msa_extcontext(buf, ext.size);
  249. break;
  250. default:
  251. err = -EINVAL;
  252. break;
  253. }
  254. if (err)
  255. return err;
  256. buf += ext.size;
  257. }
  258. }
  259. /*
  260. * Helper routines
  261. */
  262. int protected_save_fp_context(void __user *sc)
  263. {
  264. struct mips_abi *abi = current->thread.abi;
  265. uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
  266. uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
  267. uint32_t __user *used_math = sc + abi->off_sc_used_math;
  268. unsigned int used, ext_sz;
  269. int err;
  270. used = used_math() ? USED_FP : 0;
  271. if (!used)
  272. goto fp_done;
  273. if (!test_thread_flag(TIF_32BIT_FPREGS))
  274. used |= USED_FR1;
  275. if (test_thread_flag(TIF_HYBRID_FPREGS))
  276. used |= USED_HYBRID_FPRS;
  277. /*
  278. * EVA does not have userland equivalents of ldc1 or sdc1, so
  279. * save to the kernel FP context & copy that to userland below.
  280. */
  281. if (IS_ENABLED(CONFIG_EVA))
  282. lose_fpu(1);
  283. while (1) {
  284. lock_fpu_owner();
  285. if (is_fpu_owner()) {
  286. err = save_fp_context(sc);
  287. unlock_fpu_owner();
  288. } else {
  289. unlock_fpu_owner();
  290. err = copy_fp_to_sigcontext(sc);
  291. }
  292. if (likely(!err))
  293. break;
  294. /* touch the sigcontext and try again */
  295. err = __put_user(0, &fpregs[0]) |
  296. __put_user(0, &fpregs[31]) |
  297. __put_user(0, csr);
  298. if (err)
  299. return err; /* really bad sigcontext */
  300. }
  301. fp_done:
  302. ext_sz = err = save_extcontext(sc_to_extcontext(sc));
  303. if (err < 0)
  304. return err;
  305. used |= ext_sz ? USED_EXTCONTEXT : 0;
  306. return __put_user(used, used_math);
  307. }
  308. int protected_restore_fp_context(void __user *sc)
  309. {
  310. struct mips_abi *abi = current->thread.abi;
  311. uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
  312. uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
  313. uint32_t __user *used_math = sc + abi->off_sc_used_math;
  314. unsigned int used;
  315. int err, sig = 0, tmp __maybe_unused;
  316. err = __get_user(used, used_math);
  317. conditional_used_math(used & USED_FP);
  318. /*
  319. * The signal handler may have used FPU; give it up if the program
  320. * doesn't want it following sigreturn.
  321. */
  322. if (err || !(used & USED_FP))
  323. lose_fpu(0);
  324. if (err)
  325. return err;
  326. if (!(used & USED_FP))
  327. goto fp_done;
  328. err = sig = fpcsr_pending(csr);
  329. if (err < 0)
  330. return err;
  331. /*
  332. * EVA does not have userland equivalents of ldc1 or sdc1, so we
  333. * disable the FPU here such that the code below simply copies to
  334. * the kernel FP context.
  335. */
  336. if (IS_ENABLED(CONFIG_EVA))
  337. lose_fpu(0);
  338. while (1) {
  339. lock_fpu_owner();
  340. if (is_fpu_owner()) {
  341. err = restore_fp_context(sc);
  342. unlock_fpu_owner();
  343. } else {
  344. unlock_fpu_owner();
  345. err = copy_fp_from_sigcontext(sc);
  346. }
  347. if (likely(!err))
  348. break;
  349. /* touch the sigcontext and try again */
  350. err = __get_user(tmp, &fpregs[0]) |
  351. __get_user(tmp, &fpregs[31]) |
  352. __get_user(tmp, csr);
  353. if (err)
  354. break; /* really bad sigcontext */
  355. }
  356. fp_done:
  357. if (!err && (used & USED_EXTCONTEXT))
  358. err = restore_extcontext(sc_to_extcontext(sc));
  359. return err ?: sig;
  360. }
  361. int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
  362. {
  363. int err = 0;
  364. int i;
  365. err |= __put_user(regs->cp0_epc, &sc->sc_pc);
  366. err |= __put_user(0, &sc->sc_regs[0]);
  367. for (i = 1; i < 32; i++)
  368. err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
  369. #ifdef CONFIG_CPU_HAS_SMARTMIPS
  370. err |= __put_user(regs->acx, &sc->sc_acx);
  371. #endif
  372. err |= __put_user(regs->hi, &sc->sc_mdhi);
  373. err |= __put_user(regs->lo, &sc->sc_mdlo);
  374. if (cpu_has_dsp) {
  375. err |= __put_user(mfhi1(), &sc->sc_hi1);
  376. err |= __put_user(mflo1(), &sc->sc_lo1);
  377. err |= __put_user(mfhi2(), &sc->sc_hi2);
  378. err |= __put_user(mflo2(), &sc->sc_lo2);
  379. err |= __put_user(mfhi3(), &sc->sc_hi3);
  380. err |= __put_user(mflo3(), &sc->sc_lo3);
  381. err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
  382. }
  383. /*
  384. * Save FPU state to signal context. Signal handler
  385. * will "inherit" current FPU state.
  386. */
  387. err |= protected_save_fp_context(sc);
  388. return err;
  389. }
  390. static size_t extcontext_max_size(void)
  391. {
  392. size_t sz = 0;
  393. /*
  394. * The assumption here is that between this point & the point at which
  395. * the extended context is saved the size of the context should only
  396. * ever be able to shrink (if the task is preempted), but never grow.
  397. * That is, what this function returns is an upper bound on the size of
  398. * the extended context for the current task at the current time.
  399. */
  400. if (thread_msa_context_live())
  401. sz += sizeof(struct msa_extcontext);
  402. /* If any context is saved then we'll append the end marker */
  403. if (sz)
  404. sz += sizeof(((struct extcontext *)NULL)->magic);
  405. return sz;
  406. }
  407. int fpcsr_pending(unsigned int __user *fpcsr)
  408. {
  409. int err, sig = 0;
  410. unsigned int csr, enabled;
  411. err = __get_user(csr, fpcsr);
  412. enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
  413. /*
  414. * If the signal handler set some FPU exceptions, clear it and
  415. * send SIGFPE.
  416. */
  417. if (csr & enabled) {
  418. csr &= ~enabled;
  419. err |= __put_user(csr, fpcsr);
  420. sig = SIGFPE;
  421. }
  422. return err ?: sig;
  423. }
  424. int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
  425. {
  426. unsigned long treg;
  427. int err = 0;
  428. int i;
  429. /* Always make any pending restarted system calls return -EINTR */
  430. current->restart_block.fn = do_no_restart_syscall;
  431. err |= __get_user(regs->cp0_epc, &sc->sc_pc);
  432. #ifdef CONFIG_CPU_HAS_SMARTMIPS
  433. err |= __get_user(regs->acx, &sc->sc_acx);
  434. #endif
  435. err |= __get_user(regs->hi, &sc->sc_mdhi);
  436. err |= __get_user(regs->lo, &sc->sc_mdlo);
  437. if (cpu_has_dsp) {
  438. err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
  439. err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
  440. err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
  441. err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
  442. err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
  443. err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
  444. err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
  445. }
  446. for (i = 1; i < 32; i++)
  447. err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
  448. return err ?: protected_restore_fp_context(sc);
  449. }
  450. #ifdef CONFIG_WAR_ICACHE_REFILLS
  451. #define SIGMASK ~(cpu_icache_line_size()-1)
  452. #else
  453. #define SIGMASK ALMASK
  454. #endif
  455. void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
  456. size_t frame_size)
  457. {
  458. unsigned long sp;
  459. /* Leave space for potential extended context */
  460. frame_size += extcontext_max_size();
  461. /* Default to using normal stack */
  462. sp = regs->regs[29];
  463. /*
  464. * If we are on the alternate signal stack and would overflow it, don't.
  465. * Return an always-bogus address instead so we will die with SIGSEGV.
  466. */
  467. if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
  468. return (void __user __force *)(-1UL);
  469. /*
  470. * FPU emulator may have it's own trampoline active just
  471. * above the user stack, 16-bytes before the next lowest
  472. * 16 byte boundary. Try to avoid trashing it.
  473. */
  474. sp -= 32;
  475. sp = sigsp(sp, ksig);
  476. return (void __user *)((sp - frame_size) & SIGMASK);
  477. }
  478. /*
  479. * Atomically swap in the new signal mask, and wait for a signal.
  480. */
  481. #ifdef CONFIG_TRAD_SIGNALS
  482. SYSCALL_DEFINE1(sigsuspend, sigset_t __user *, uset)
  483. {
  484. return sys_rt_sigsuspend(uset, sizeof(sigset_t));
  485. }
  486. #endif
  487. #ifdef CONFIG_TRAD_SIGNALS
  488. SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
  489. struct sigaction __user *, oact)
  490. {
  491. struct k_sigaction new_ka, old_ka;
  492. int ret;
  493. int err = 0;
  494. if (act) {
  495. old_sigset_t mask;
  496. if (!access_ok(act, sizeof(*act)))
  497. return -EFAULT;
  498. err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
  499. err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  500. err |= __get_user(mask, &act->sa_mask.sig[0]);
  501. if (err)
  502. return -EFAULT;
  503. siginitset(&new_ka.sa.sa_mask, mask);
  504. }
  505. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  506. if (!ret && oact) {
  507. if (!access_ok(oact, sizeof(*oact)))
  508. return -EFAULT;
  509. err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  510. err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
  511. err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
  512. err |= __put_user(0, &oact->sa_mask.sig[1]);
  513. err |= __put_user(0, &oact->sa_mask.sig[2]);
  514. err |= __put_user(0, &oact->sa_mask.sig[3]);
  515. if (err)
  516. return -EFAULT;
  517. }
  518. return ret;
  519. }
  520. #endif
  521. #ifdef CONFIG_TRAD_SIGNALS
  522. asmlinkage void sys_sigreturn(void)
  523. {
  524. struct sigframe __user *frame;
  525. struct pt_regs *regs;
  526. sigset_t blocked;
  527. int sig;
  528. regs = current_pt_regs();
  529. frame = (struct sigframe __user *)regs->regs[29];
  530. if (!access_ok(frame, sizeof(*frame)))
  531. goto badframe;
  532. if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
  533. goto badframe;
  534. set_current_blocked(&blocked);
  535. sig = restore_sigcontext(regs, &frame->sf_sc);
  536. if (sig < 0)
  537. goto badframe;
  538. else if (sig)
  539. force_sig(sig);
  540. /*
  541. * Don't let your children do this ...
  542. */
  543. __asm__ __volatile__(
  544. "move\t$29, %0\n\t"
  545. "j\tsyscall_exit"
  546. : /* no outputs */
  547. : "r" (regs));
  548. /* Unreached */
  549. badframe:
  550. force_sig(SIGSEGV);
  551. }
  552. #endif /* CONFIG_TRAD_SIGNALS */
  553. asmlinkage void sys_rt_sigreturn(void)
  554. {
  555. struct rt_sigframe __user *frame;
  556. struct pt_regs *regs;
  557. sigset_t set;
  558. int sig;
  559. regs = current_pt_regs();
  560. frame = (struct rt_sigframe __user *)regs->regs[29];
  561. if (!access_ok(frame, sizeof(*frame)))
  562. goto badframe;
  563. if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
  564. goto badframe;
  565. set_current_blocked(&set);
  566. sig = restore_sigcontext(regs, &frame->rs_uc.uc_mcontext);
  567. if (sig < 0)
  568. goto badframe;
  569. else if (sig)
  570. force_sig(sig);
  571. if (restore_altstack(&frame->rs_uc.uc_stack))
  572. goto badframe;
  573. /*
  574. * Don't let your children do this ...
  575. */
  576. __asm__ __volatile__(
  577. "move\t$29, %0\n\t"
  578. "j\tsyscall_exit"
  579. : /* no outputs */
  580. : "r" (regs));
  581. /* Unreached */
  582. badframe:
  583. force_sig(SIGSEGV);
  584. }
  585. #ifdef CONFIG_TRAD_SIGNALS
  586. static int setup_frame(void *sig_return, struct ksignal *ksig,
  587. struct pt_regs *regs, sigset_t *set)
  588. {
  589. struct sigframe __user *frame;
  590. int err = 0;
  591. frame = get_sigframe(ksig, regs, sizeof(*frame));
  592. if (!access_ok(frame, sizeof (*frame)))
  593. return -EFAULT;
  594. err |= setup_sigcontext(regs, &frame->sf_sc);
  595. err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
  596. if (err)
  597. return -EFAULT;
  598. /*
  599. * Arguments to signal handler:
  600. *
  601. * a0 = signal number
  602. * a1 = 0 (should be cause)
  603. * a2 = pointer to struct sigcontext
  604. *
  605. * $25 and c0_epc point to the signal handler, $29 points to the
  606. * struct sigframe.
  607. */
  608. regs->regs[ 4] = ksig->sig;
  609. regs->regs[ 5] = 0;
  610. regs->regs[ 6] = (unsigned long) &frame->sf_sc;
  611. regs->regs[29] = (unsigned long) frame;
  612. regs->regs[31] = (unsigned long) sig_return;
  613. regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
  614. DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
  615. current->comm, current->pid,
  616. frame, regs->cp0_epc, regs->regs[31]);
  617. return 0;
  618. }
  619. #endif
  620. static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
  621. struct pt_regs *regs, sigset_t *set)
  622. {
  623. struct rt_sigframe __user *frame;
  624. frame = get_sigframe(ksig, regs, sizeof(*frame));
  625. if (!access_ok(frame, sizeof (*frame)))
  626. return -EFAULT;
  627. /* Create siginfo. */
  628. if (copy_siginfo_to_user(&frame->rs_info, &ksig->info))
  629. return -EFAULT;
  630. /* Create the ucontext. */
  631. if (__put_user(0, &frame->rs_uc.uc_flags))
  632. return -EFAULT;
  633. if (__put_user(NULL, &frame->rs_uc.uc_link))
  634. return -EFAULT;
  635. if (__save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]))
  636. return -EFAULT;
  637. if (setup_sigcontext(regs, &frame->rs_uc.uc_mcontext))
  638. return -EFAULT;
  639. if (__copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set)))
  640. return -EFAULT;
  641. /*
  642. * Arguments to signal handler:
  643. *
  644. * a0 = signal number
  645. * a1 = 0 (should be cause)
  646. * a2 = pointer to ucontext
  647. *
  648. * $25 and c0_epc point to the signal handler, $29 points to
  649. * the struct rt_sigframe.
  650. */
  651. regs->regs[ 4] = ksig->sig;
  652. regs->regs[ 5] = (unsigned long) &frame->rs_info;
  653. regs->regs[ 6] = (unsigned long) &frame->rs_uc;
  654. regs->regs[29] = (unsigned long) frame;
  655. regs->regs[31] = (unsigned long) sig_return;
  656. regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
  657. DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
  658. current->comm, current->pid,
  659. frame, regs->cp0_epc, regs->regs[31]);
  660. return 0;
  661. }
  662. struct mips_abi mips_abi = {
  663. #ifdef CONFIG_TRAD_SIGNALS
  664. .setup_frame = setup_frame,
  665. #endif
  666. .setup_rt_frame = setup_rt_frame,
  667. .restart = __NR_restart_syscall,
  668. .off_sc_fpregs = offsetof(struct sigcontext, sc_fpregs),
  669. .off_sc_fpc_csr = offsetof(struct sigcontext, sc_fpc_csr),
  670. .off_sc_used_math = offsetof(struct sigcontext, sc_used_math),
  671. .vdso = &vdso_image,
  672. };
  673. static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
  674. {
  675. sigset_t *oldset = sigmask_to_save();
  676. int ret;
  677. struct mips_abi *abi = current->thread.abi;
  678. void *vdso = current->mm->context.vdso;
  679. /*
  680. * If we were emulating a delay slot instruction, exit that frame such
  681. * that addresses in the sigframe are as expected for userland and we
  682. * don't have a problem if we reuse the thread's frame for an
  683. * instruction within the signal handler.
  684. */
  685. dsemul_thread_rollback(regs);
  686. if (regs->regs[0]) {
  687. switch(regs->regs[2]) {
  688. case ERESTART_RESTARTBLOCK:
  689. case ERESTARTNOHAND:
  690. regs->regs[2] = EINTR;
  691. break;
  692. case ERESTARTSYS:
  693. if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
  694. regs->regs[2] = EINTR;
  695. break;
  696. }
  697. fallthrough;
  698. case ERESTARTNOINTR:
  699. regs->regs[7] = regs->regs[26];
  700. regs->regs[2] = regs->regs[0];
  701. regs->cp0_epc -= 4;
  702. }
  703. regs->regs[0] = 0; /* Don't deal with this again. */
  704. }
  705. rseq_signal_deliver(ksig, regs);
  706. if (sig_uses_siginfo(&ksig->ka, abi))
  707. ret = abi->setup_rt_frame(vdso + abi->vdso->off_rt_sigreturn,
  708. ksig, regs, oldset);
  709. else
  710. ret = abi->setup_frame(vdso + abi->vdso->off_sigreturn,
  711. ksig, regs, oldset);
  712. signal_setup_done(ret, ksig, 0);
  713. }
  714. static void do_signal(struct pt_regs *regs)
  715. {
  716. struct ksignal ksig;
  717. if (get_signal(&ksig)) {
  718. /* Whee! Actually deliver the signal. */
  719. handle_signal(&ksig, regs);
  720. return;
  721. }
  722. if (regs->regs[0]) {
  723. switch (regs->regs[2]) {
  724. case ERESTARTNOHAND:
  725. case ERESTARTSYS:
  726. case ERESTARTNOINTR:
  727. regs->regs[2] = regs->regs[0];
  728. regs->regs[7] = regs->regs[26];
  729. regs->cp0_epc -= 4;
  730. break;
  731. case ERESTART_RESTARTBLOCK:
  732. regs->regs[2] = current->thread.abi->restart;
  733. regs->regs[7] = regs->regs[26];
  734. regs->cp0_epc -= 4;
  735. break;
  736. }
  737. regs->regs[0] = 0; /* Don't deal with this again. */
  738. }
  739. /*
  740. * If there's no signal to deliver, we just put the saved sigmask
  741. * back
  742. */
  743. restore_saved_sigmask();
  744. }
  745. /*
  746. * notification of userspace execution resumption
  747. * - triggered by the TIF_WORK_MASK flags
  748. */
  749. asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
  750. __u32 thread_info_flags)
  751. {
  752. local_irq_enable();
  753. user_exit();
  754. if (thread_info_flags & _TIF_UPROBE)
  755. uprobe_notify_resume(regs);
  756. /* deal with pending signal delivery */
  757. if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))
  758. do_signal(regs);
  759. if (thread_info_flags & _TIF_NOTIFY_RESUME)
  760. resume_user_mode_work(regs);
  761. user_enter();
  762. }
  763. #if defined(CONFIG_SMP) && defined(CONFIG_MIPS_FP_SUPPORT)
  764. static int smp_save_fp_context(void __user *sc)
  765. {
  766. return raw_cpu_has_fpu
  767. ? save_hw_fp_context(sc)
  768. : copy_fp_to_sigcontext(sc);
  769. }
  770. static int smp_restore_fp_context(void __user *sc)
  771. {
  772. return raw_cpu_has_fpu
  773. ? restore_hw_fp_context(sc)
  774. : copy_fp_from_sigcontext(sc);
  775. }
  776. #endif
  777. static int signal_setup(void)
  778. {
  779. /*
  780. * The offset from sigcontext to extended context should be the same
  781. * regardless of the type of signal, such that userland can always know
  782. * where to look if it wishes to find the extended context structures.
  783. */
  784. BUILD_BUG_ON((offsetof(struct sigframe, sf_extcontext) -
  785. offsetof(struct sigframe, sf_sc)) !=
  786. (offsetof(struct rt_sigframe, rs_uc.uc_extcontext) -
  787. offsetof(struct rt_sigframe, rs_uc.uc_mcontext)));
  788. #if defined(CONFIG_SMP) && defined(CONFIG_MIPS_FP_SUPPORT)
  789. /* For now just do the cpu_has_fpu check when the functions are invoked */
  790. save_fp_context = smp_save_fp_context;
  791. restore_fp_context = smp_restore_fp_context;
  792. #else
  793. if (cpu_has_fpu) {
  794. save_fp_context = save_hw_fp_context;
  795. restore_fp_context = restore_hw_fp_context;
  796. } else {
  797. save_fp_context = copy_fp_to_sigcontext;
  798. restore_fp_context = copy_fp_from_sigcontext;
  799. }
  800. #endif /* CONFIG_SMP */
  801. return 0;
  802. }
  803. arch_initcall(signal_setup);