signal32.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* arch/sparc64/kernel/signal32.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  6. * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
  7. * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
  8. * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  9. */
  10. #include <linux/sched.h>
  11. #include <linux/kernel.h>
  12. #include <linux/signal.h>
  13. #include <linux/errno.h>
  14. #include <linux/wait.h>
  15. #include <linux/ptrace.h>
  16. #include <linux/unistd.h>
  17. #include <linux/mm.h>
  18. #include <linux/tty.h>
  19. #include <linux/binfmts.h>
  20. #include <linux/compat.h>
  21. #include <linux/bitops.h>
  22. #include <linux/tracehook.h>
  23. #include <linux/uaccess.h>
  24. #include <asm/ptrace.h>
  25. #include <asm/psrcompat.h>
  26. #include <asm/fpumacro.h>
  27. #include <asm/visasm.h>
  28. #include <asm/compat_signal.h>
  29. #include <asm/switch_to.h>
  30. #include "sigutil.h"
  31. #include "kernel.h"
  32. /* This magic should be in g_upper[0] for all upper parts
  33. * to be valid.
  34. */
  35. #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
  36. typedef struct {
  37. unsigned int g_upper[8];
  38. unsigned int o_upper[8];
  39. unsigned int asi;
  40. } siginfo_extra_v8plus_t;
  41. struct signal_frame32 {
  42. struct sparc_stackf32 ss;
  43. __siginfo32_t info;
  44. /* __siginfo_fpu_t * */ u32 fpu_save;
  45. unsigned int insns[2];
  46. unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
  47. unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  48. /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  49. siginfo_extra_v8plus_t v8plus;
  50. /* __siginfo_rwin_t * */u32 rwin_save;
  51. } __attribute__((aligned(8)));
  52. struct rt_signal_frame32 {
  53. struct sparc_stackf32 ss;
  54. compat_siginfo_t info;
  55. struct pt_regs32 regs;
  56. compat_sigset_t mask;
  57. /* __siginfo_fpu_t * */ u32 fpu_save;
  58. unsigned int insns[2];
  59. compat_stack_t stack;
  60. unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  61. /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  62. siginfo_extra_v8plus_t v8plus;
  63. /* __siginfo_rwin_t * */u32 rwin_save;
  64. } __attribute__((aligned(8)));
  65. /* Checks if the fp is valid. We always build signal frames which are
  66. * 16-byte aligned, therefore we can always enforce that the restore
  67. * frame has that property as well.
  68. */
  69. static bool invalid_frame_pointer(void __user *fp, int fplen)
  70. {
  71. if ((((unsigned long) fp) & 15) ||
  72. ((unsigned long)fp) > 0x100000000ULL - fplen)
  73. return true;
  74. return false;
  75. }
  76. void do_sigreturn32(struct pt_regs *regs)
  77. {
  78. struct signal_frame32 __user *sf;
  79. compat_uptr_t fpu_save;
  80. compat_uptr_t rwin_save;
  81. unsigned int psr, ufp;
  82. unsigned int pc, npc;
  83. sigset_t set;
  84. compat_sigset_t seta;
  85. int err, i;
  86. /* Always make any pending restarted system calls return -EINTR */
  87. current->restart_block.fn = do_no_restart_syscall;
  88. synchronize_user_stack();
  89. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  90. sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
  91. /* 1. Make sure we are not getting garbage from the user */
  92. if (invalid_frame_pointer(sf, sizeof(*sf)))
  93. goto segv;
  94. if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP]))
  95. goto segv;
  96. if (ufp & 0x7)
  97. goto segv;
  98. if (__get_user(pc, &sf->info.si_regs.pc) ||
  99. __get_user(npc, &sf->info.si_regs.npc))
  100. goto segv;
  101. if ((pc | npc) & 3)
  102. goto segv;
  103. if (test_thread_flag(TIF_32BIT)) {
  104. pc &= 0xffffffff;
  105. npc &= 0xffffffff;
  106. }
  107. regs->tpc = pc;
  108. regs->tnpc = npc;
  109. /* 2. Restore the state */
  110. err = __get_user(regs->y, &sf->info.si_regs.y);
  111. err |= __get_user(psr, &sf->info.si_regs.psr);
  112. for (i = UREG_G1; i <= UREG_I7; i++)
  113. err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
  114. if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
  115. err |= __get_user(i, &sf->v8plus.g_upper[0]);
  116. if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
  117. unsigned long asi;
  118. for (i = UREG_G1; i <= UREG_I7; i++)
  119. err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
  120. err |= __get_user(asi, &sf->v8plus.asi);
  121. regs->tstate &= ~TSTATE_ASI;
  122. regs->tstate |= ((asi & 0xffUL) << 24UL);
  123. }
  124. }
  125. /* User can only change condition codes in %tstate. */
  126. regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
  127. regs->tstate |= psr_to_tstate_icc(psr);
  128. /* Prevent syscall restart. */
  129. pt_regs_clear_syscall(regs);
  130. err |= __get_user(fpu_save, &sf->fpu_save);
  131. if (!err && fpu_save)
  132. err |= restore_fpu_state(regs, compat_ptr(fpu_save));
  133. err |= __get_user(rwin_save, &sf->rwin_save);
  134. if (!err && rwin_save) {
  135. if (restore_rwin_state(compat_ptr(rwin_save)))
  136. goto segv;
  137. }
  138. err |= __get_user(seta.sig[0], &sf->info.si_mask);
  139. err |= copy_from_user(&seta.sig[1], &sf->extramask,
  140. (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
  141. if (err)
  142. goto segv;
  143. set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
  144. set_current_blocked(&set);
  145. return;
  146. segv:
  147. force_sig(SIGSEGV);
  148. }
  149. asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
  150. {
  151. struct rt_signal_frame32 __user *sf;
  152. unsigned int psr, pc, npc, ufp;
  153. compat_uptr_t fpu_save;
  154. compat_uptr_t rwin_save;
  155. sigset_t set;
  156. int err, i;
  157. /* Always make any pending restarted system calls return -EINTR */
  158. current->restart_block.fn = do_no_restart_syscall;
  159. synchronize_user_stack();
  160. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  161. sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
  162. /* 1. Make sure we are not getting garbage from the user */
  163. if (invalid_frame_pointer(sf, sizeof(*sf)))
  164. goto segv;
  165. if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))
  166. goto segv;
  167. if (ufp & 0x7)
  168. goto segv;
  169. if (__get_user(pc, &sf->regs.pc) ||
  170. __get_user(npc, &sf->regs.npc))
  171. goto segv;
  172. if ((pc | npc) & 3)
  173. goto segv;
  174. if (test_thread_flag(TIF_32BIT)) {
  175. pc &= 0xffffffff;
  176. npc &= 0xffffffff;
  177. }
  178. regs->tpc = pc;
  179. regs->tnpc = npc;
  180. /* 2. Restore the state */
  181. err = __get_user(regs->y, &sf->regs.y);
  182. err |= __get_user(psr, &sf->regs.psr);
  183. for (i = UREG_G1; i <= UREG_I7; i++)
  184. err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
  185. if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
  186. err |= __get_user(i, &sf->v8plus.g_upper[0]);
  187. if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
  188. unsigned long asi;
  189. for (i = UREG_G1; i <= UREG_I7; i++)
  190. err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
  191. err |= __get_user(asi, &sf->v8plus.asi);
  192. regs->tstate &= ~TSTATE_ASI;
  193. regs->tstate |= ((asi & 0xffUL) << 24UL);
  194. }
  195. }
  196. /* User can only change condition codes in %tstate. */
  197. regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
  198. regs->tstate |= psr_to_tstate_icc(psr);
  199. /* Prevent syscall restart. */
  200. pt_regs_clear_syscall(regs);
  201. err |= __get_user(fpu_save, &sf->fpu_save);
  202. if (!err && fpu_save)
  203. err |= restore_fpu_state(regs, compat_ptr(fpu_save));
  204. err |= get_compat_sigset(&set, &sf->mask);
  205. err |= compat_restore_altstack(&sf->stack);
  206. if (err)
  207. goto segv;
  208. err |= __get_user(rwin_save, &sf->rwin_save);
  209. if (!err && rwin_save) {
  210. if (restore_rwin_state(compat_ptr(rwin_save)))
  211. goto segv;
  212. }
  213. set_current_blocked(&set);
  214. return;
  215. segv:
  216. force_sig(SIGSEGV);
  217. }
  218. static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
  219. {
  220. unsigned long sp;
  221. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  222. sp = regs->u_regs[UREG_FP];
  223. /*
  224. * If we are on the alternate signal stack and would overflow it, don't.
  225. * Return an always-bogus address instead so we will die with SIGSEGV.
  226. */
  227. if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
  228. return (void __user *) -1L;
  229. /* This is the X/Open sanctioned signal stack switching. */
  230. sp = sigsp(sp, ksig) - framesize;
  231. /* Always align the stack frame. This handles two cases. First,
  232. * sigaltstack need not be mindful of platform specific stack
  233. * alignment. Second, if we took this signal because the stack
  234. * is not aligned properly, we'd like to take the signal cleanly
  235. * and report that.
  236. */
  237. sp &= ~15UL;
  238. return (void __user *) sp;
  239. }
  240. /* The I-cache flush instruction only works in the primary ASI, which
  241. * right now is the nucleus, aka. kernel space.
  242. *
  243. * Therefore we have to kick the instructions out using the kernel
  244. * side linear mapping of the physical address backing the user
  245. * instructions.
  246. */
  247. static void flush_signal_insns(unsigned long address)
  248. {
  249. unsigned long pstate, paddr;
  250. pte_t *ptep, pte;
  251. pgd_t *pgdp;
  252. p4d_t *p4dp;
  253. pud_t *pudp;
  254. pmd_t *pmdp;
  255. /* Commit all stores of the instructions we are about to flush. */
  256. wmb();
  257. /* Disable cross-call reception. In this way even a very wide
  258. * munmap() on another cpu can't tear down the page table
  259. * hierarchy from underneath us, since that can't complete
  260. * until the IPI tlb flush returns.
  261. */
  262. __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
  263. __asm__ __volatile__("wrpr %0, %1, %%pstate"
  264. : : "r" (pstate), "i" (PSTATE_IE));
  265. pgdp = pgd_offset(current->mm, address);
  266. if (pgd_none(*pgdp))
  267. goto out_irqs_on;
  268. p4dp = p4d_offset(pgdp, address);
  269. if (p4d_none(*p4dp))
  270. goto out_irqs_on;
  271. pudp = pud_offset(p4dp, address);
  272. if (pud_none(*pudp))
  273. goto out_irqs_on;
  274. pmdp = pmd_offset(pudp, address);
  275. if (pmd_none(*pmdp))
  276. goto out_irqs_on;
  277. ptep = pte_offset_map(pmdp, address);
  278. pte = *ptep;
  279. if (!pte_present(pte))
  280. goto out_unmap;
  281. paddr = (unsigned long) page_address(pte_page(pte));
  282. __asm__ __volatile__("flush %0 + %1"
  283. : /* no outputs */
  284. : "r" (paddr),
  285. "r" (address & (PAGE_SIZE - 1))
  286. : "memory");
  287. out_unmap:
  288. pte_unmap(ptep);
  289. out_irqs_on:
  290. __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
  291. }
  292. static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
  293. sigset_t *oldset)
  294. {
  295. struct signal_frame32 __user *sf;
  296. int i, err, wsaved;
  297. void __user *tail;
  298. int sigframe_size;
  299. u32 psr;
  300. compat_sigset_t seta;
  301. /* 1. Make sure everything is clean */
  302. synchronize_user_stack();
  303. save_and_clear_fpu();
  304. wsaved = get_thread_wsaved();
  305. sigframe_size = sizeof(*sf);
  306. if (current_thread_info()->fpsaved[0] & FPRS_FEF)
  307. sigframe_size += sizeof(__siginfo_fpu_t);
  308. if (wsaved)
  309. sigframe_size += sizeof(__siginfo_rwin_t);
  310. sf = (struct signal_frame32 __user *)
  311. get_sigframe(ksig, regs, sigframe_size);
  312. if (invalid_frame_pointer(sf, sigframe_size)) {
  313. if (show_unhandled_signals)
  314. pr_info("%s[%d] bad frame in setup_frame32: %08lx TPC %08lx O7 %08lx\n",
  315. current->comm, current->pid, (unsigned long)sf,
  316. regs->tpc, regs->u_regs[UREG_I7]);
  317. force_sigsegv(ksig->sig);
  318. return -EINVAL;
  319. }
  320. tail = (sf + 1);
  321. /* 2. Save the current process state */
  322. if (test_thread_flag(TIF_32BIT)) {
  323. regs->tpc &= 0xffffffff;
  324. regs->tnpc &= 0xffffffff;
  325. }
  326. err = put_user(regs->tpc, &sf->info.si_regs.pc);
  327. err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
  328. err |= __put_user(regs->y, &sf->info.si_regs.y);
  329. psr = tstate_to_psr(regs->tstate);
  330. if (current_thread_info()->fpsaved[0] & FPRS_FEF)
  331. psr |= PSR_EF;
  332. err |= __put_user(psr, &sf->info.si_regs.psr);
  333. for (i = 0; i < 16; i++)
  334. err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
  335. err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
  336. err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
  337. for (i = 1; i < 16; i++)
  338. err |= __put_user(((u32 *)regs->u_regs)[2*i],
  339. &sf->v8plus.g_upper[i]);
  340. err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
  341. &sf->v8plus.asi);
  342. if (psr & PSR_EF) {
  343. __siginfo_fpu_t __user *fp = tail;
  344. tail += sizeof(*fp);
  345. err |= save_fpu_state(regs, fp);
  346. err |= __put_user((u64)fp, &sf->fpu_save);
  347. } else {
  348. err |= __put_user(0, &sf->fpu_save);
  349. }
  350. if (wsaved) {
  351. __siginfo_rwin_t __user *rwp = tail;
  352. tail += sizeof(*rwp);
  353. err |= save_rwin_state(wsaved, rwp);
  354. err |= __put_user((u64)rwp, &sf->rwin_save);
  355. set_thread_wsaved(0);
  356. } else {
  357. err |= __put_user(0, &sf->rwin_save);
  358. }
  359. /* If these change we need to know - assignments to seta relies on these sizes */
  360. BUILD_BUG_ON(_NSIG_WORDS != 1);
  361. BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
  362. seta.sig[1] = (oldset->sig[0] >> 32);
  363. seta.sig[0] = oldset->sig[0];
  364. err |= __put_user(seta.sig[0], &sf->info.si_mask);
  365. err |= __copy_to_user(sf->extramask, &seta.sig[1],
  366. (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
  367. if (!wsaved) {
  368. err |= copy_in_user((u32 __user *)sf,
  369. (u32 __user *)(regs->u_regs[UREG_FP]),
  370. sizeof(struct reg_window32));
  371. } else {
  372. struct reg_window *rp;
  373. rp = &current_thread_info()->reg_window[wsaved - 1];
  374. for (i = 0; i < 8; i++)
  375. err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
  376. for (i = 0; i < 6; i++)
  377. err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
  378. err |= __put_user(rp->ins[6], &sf->ss.fp);
  379. err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
  380. }
  381. if (err)
  382. return err;
  383. /* 3. signal handler back-trampoline and parameters */
  384. regs->u_regs[UREG_FP] = (unsigned long) sf;
  385. regs->u_regs[UREG_I0] = ksig->sig;
  386. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  387. regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
  388. /* 4. signal handler */
  389. regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
  390. regs->tnpc = (regs->tpc + 4);
  391. if (test_thread_flag(TIF_32BIT)) {
  392. regs->tpc &= 0xffffffff;
  393. regs->tnpc &= 0xffffffff;
  394. }
  395. /* 5. return to kernel instructions */
  396. if (ksig->ka.ka_restorer) {
  397. regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
  398. } else {
  399. unsigned long address = ((unsigned long)&(sf->insns[0]));
  400. regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
  401. err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
  402. err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
  403. if (err)
  404. return err;
  405. flush_signal_insns(address);
  406. }
  407. return 0;
  408. }
  409. static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
  410. sigset_t *oldset)
  411. {
  412. struct rt_signal_frame32 __user *sf;
  413. int i, err, wsaved;
  414. void __user *tail;
  415. int sigframe_size;
  416. u32 psr;
  417. /* 1. Make sure everything is clean */
  418. synchronize_user_stack();
  419. save_and_clear_fpu();
  420. wsaved = get_thread_wsaved();
  421. sigframe_size = sizeof(*sf);
  422. if (current_thread_info()->fpsaved[0] & FPRS_FEF)
  423. sigframe_size += sizeof(__siginfo_fpu_t);
  424. if (wsaved)
  425. sigframe_size += sizeof(__siginfo_rwin_t);
  426. sf = (struct rt_signal_frame32 __user *)
  427. get_sigframe(ksig, regs, sigframe_size);
  428. if (invalid_frame_pointer(sf, sigframe_size)) {
  429. if (show_unhandled_signals)
  430. pr_info("%s[%d] bad frame in setup_rt_frame32: %08lx TPC %08lx O7 %08lx\n",
  431. current->comm, current->pid, (unsigned long)sf,
  432. regs->tpc, regs->u_regs[UREG_I7]);
  433. force_sigsegv(ksig->sig);
  434. return -EINVAL;
  435. }
  436. tail = (sf + 1);
  437. /* 2. Save the current process state */
  438. if (test_thread_flag(TIF_32BIT)) {
  439. regs->tpc &= 0xffffffff;
  440. regs->tnpc &= 0xffffffff;
  441. }
  442. err = put_user(regs->tpc, &sf->regs.pc);
  443. err |= __put_user(regs->tnpc, &sf->regs.npc);
  444. err |= __put_user(regs->y, &sf->regs.y);
  445. psr = tstate_to_psr(regs->tstate);
  446. if (current_thread_info()->fpsaved[0] & FPRS_FEF)
  447. psr |= PSR_EF;
  448. err |= __put_user(psr, &sf->regs.psr);
  449. for (i = 0; i < 16; i++)
  450. err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
  451. err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
  452. err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
  453. for (i = 1; i < 16; i++)
  454. err |= __put_user(((u32 *)regs->u_regs)[2*i],
  455. &sf->v8plus.g_upper[i]);
  456. err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
  457. &sf->v8plus.asi);
  458. if (psr & PSR_EF) {
  459. __siginfo_fpu_t __user *fp = tail;
  460. tail += sizeof(*fp);
  461. err |= save_fpu_state(regs, fp);
  462. err |= __put_user((u64)fp, &sf->fpu_save);
  463. } else {
  464. err |= __put_user(0, &sf->fpu_save);
  465. }
  466. if (wsaved) {
  467. __siginfo_rwin_t __user *rwp = tail;
  468. tail += sizeof(*rwp);
  469. err |= save_rwin_state(wsaved, rwp);
  470. err |= __put_user((u64)rwp, &sf->rwin_save);
  471. set_thread_wsaved(0);
  472. } else {
  473. err |= __put_user(0, &sf->rwin_save);
  474. }
  475. /* Update the siginfo structure. */
  476. err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
  477. /* Setup sigaltstack */
  478. err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
  479. err |= put_compat_sigset(&sf->mask, oldset, sizeof(compat_sigset_t));
  480. if (!wsaved) {
  481. err |= copy_in_user((u32 __user *)sf,
  482. (u32 __user *)(regs->u_regs[UREG_FP]),
  483. sizeof(struct reg_window32));
  484. } else {
  485. struct reg_window *rp;
  486. rp = &current_thread_info()->reg_window[wsaved - 1];
  487. for (i = 0; i < 8; i++)
  488. err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
  489. for (i = 0; i < 6; i++)
  490. err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
  491. err |= __put_user(rp->ins[6], &sf->ss.fp);
  492. err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
  493. }
  494. if (err)
  495. return err;
  496. /* 3. signal handler back-trampoline and parameters */
  497. regs->u_regs[UREG_FP] = (unsigned long) sf;
  498. regs->u_regs[UREG_I0] = ksig->sig;
  499. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  500. regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
  501. /* 4. signal handler */
  502. regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
  503. regs->tnpc = (regs->tpc + 4);
  504. if (test_thread_flag(TIF_32BIT)) {
  505. regs->tpc &= 0xffffffff;
  506. regs->tnpc &= 0xffffffff;
  507. }
  508. /* 5. return to kernel instructions */
  509. if (ksig->ka.ka_restorer)
  510. regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
  511. else {
  512. unsigned long address = ((unsigned long)&(sf->insns[0]));
  513. regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
  514. /* mov __NR_rt_sigreturn, %g1 */
  515. err |= __put_user(0x82102065, &sf->insns[0]);
  516. /* t 0x10 */
  517. err |= __put_user(0x91d02010, &sf->insns[1]);
  518. if (err)
  519. return err;
  520. flush_signal_insns(address);
  521. }
  522. return 0;
  523. }
  524. static inline void handle_signal32(struct ksignal *ksig,
  525. struct pt_regs *regs)
  526. {
  527. sigset_t *oldset = sigmask_to_save();
  528. int err;
  529. if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  530. err = setup_rt_frame32(ksig, regs, oldset);
  531. else
  532. err = setup_frame32(ksig, regs, oldset);
  533. signal_setup_done(err, ksig, 0);
  534. }
  535. static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
  536. struct sigaction *sa)
  537. {
  538. switch (regs->u_regs[UREG_I0]) {
  539. case ERESTART_RESTARTBLOCK:
  540. case ERESTARTNOHAND:
  541. no_system_call_restart:
  542. regs->u_regs[UREG_I0] = EINTR;
  543. regs->tstate |= TSTATE_ICARRY;
  544. break;
  545. case ERESTARTSYS:
  546. if (!(sa->sa_flags & SA_RESTART))
  547. goto no_system_call_restart;
  548. fallthrough;
  549. case ERESTARTNOINTR:
  550. regs->u_regs[UREG_I0] = orig_i0;
  551. regs->tpc -= 4;
  552. regs->tnpc -= 4;
  553. }
  554. }
  555. /* Note that 'init' is a special process: it doesn't get signals it doesn't
  556. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  557. * mistake.
  558. */
  559. void do_signal32(struct pt_regs * regs)
  560. {
  561. struct ksignal ksig;
  562. unsigned long orig_i0 = 0;
  563. int restart_syscall = 0;
  564. bool has_handler = get_signal(&ksig);
  565. if (pt_regs_is_syscall(regs) &&
  566. (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
  567. restart_syscall = 1;
  568. orig_i0 = regs->u_regs[UREG_G6];
  569. }
  570. if (has_handler) {
  571. if (restart_syscall)
  572. syscall_restart32(orig_i0, regs, &ksig.ka.sa);
  573. handle_signal32(&ksig, regs);
  574. } else {
  575. if (restart_syscall) {
  576. switch (regs->u_regs[UREG_I0]) {
  577. case ERESTARTNOHAND:
  578. case ERESTARTSYS:
  579. case ERESTARTNOINTR:
  580. /* replay the system call when we are done */
  581. regs->u_regs[UREG_I0] = orig_i0;
  582. regs->tpc -= 4;
  583. regs->tnpc -= 4;
  584. pt_regs_clear_syscall(regs);
  585. fallthrough;
  586. case ERESTART_RESTARTBLOCK:
  587. regs->u_regs[UREG_G1] = __NR_restart_syscall;
  588. regs->tpc -= 4;
  589. regs->tnpc -= 4;
  590. pt_regs_clear_syscall(regs);
  591. }
  592. }
  593. restore_saved_sigmask();
  594. }
  595. }
  596. struct sigstack32 {
  597. u32 the_stack;
  598. int cur_status;
  599. };
  600. asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
  601. {
  602. struct sigstack32 __user *ssptr =
  603. (struct sigstack32 __user *)((unsigned long)(u_ssptr));
  604. struct sigstack32 __user *ossptr =
  605. (struct sigstack32 __user *)((unsigned long)(u_ossptr));
  606. int ret = -EFAULT;
  607. /* First see if old state is wanted. */
  608. if (ossptr) {
  609. if (put_user(current->sas_ss_sp + current->sas_ss_size,
  610. &ossptr->the_stack) ||
  611. __put_user(on_sig_stack(sp), &ossptr->cur_status))
  612. goto out;
  613. }
  614. /* Now see if we want to update the new state. */
  615. if (ssptr) {
  616. u32 ss_sp;
  617. if (get_user(ss_sp, &ssptr->the_stack))
  618. goto out;
  619. /* If the current stack was set with sigaltstack, don't
  620. * swap stacks while we are on it.
  621. */
  622. ret = -EPERM;
  623. if (current->sas_ss_sp && on_sig_stack(sp))
  624. goto out;
  625. /* Since we don't know the extent of the stack, and we don't
  626. * track onstack-ness, but rather calculate it, we must
  627. * presume a size. Ho hum this interface is lossy.
  628. */
  629. current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
  630. current->sas_ss_size = SIGSTKSZ;
  631. }
  632. ret = 0;
  633. out:
  634. return ret;
  635. }