signal_32.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* linux/arch/sparc/kernel/signal.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. */
  9. #include <linux/sched.h>
  10. #include <linux/kernel.h>
  11. #include <linux/signal.h>
  12. #include <linux/errno.h>
  13. #include <linux/wait.h>
  14. #include <linux/ptrace.h>
  15. #include <linux/unistd.h>
  16. #include <linux/mm.h>
  17. #include <linux/tty.h>
  18. #include <linux/smp.h>
  19. #include <linux/binfmts.h> /* do_coredum */
  20. #include <linux/bitops.h>
  21. #include <linux/tracehook.h>
  22. #include <linux/uaccess.h>
  23. #include <asm/ptrace.h>
  24. #include <asm/cacheflush.h> /* flush_sig_insns */
  25. #include <asm/switch_to.h>
  26. #include "sigutil.h"
  27. #include "kernel.h"
  28. extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
  29. void *fpqueue, unsigned long *fpqdepth);
  30. extern void fpload(unsigned long *fpregs, unsigned long *fsr);
  31. struct signal_frame {
  32. struct sparc_stackf ss;
  33. __siginfo32_t info;
  34. __siginfo_fpu_t __user *fpu_save;
  35. unsigned long insns[2] __attribute__ ((aligned (8)));
  36. unsigned int extramask[_NSIG_WORDS - 1];
  37. unsigned int extra_size; /* Should be 0 */
  38. __siginfo_rwin_t __user *rwin_save;
  39. } __attribute__((aligned(8)));
  40. struct rt_signal_frame {
  41. struct sparc_stackf ss;
  42. siginfo_t info;
  43. struct pt_regs regs;
  44. sigset_t mask;
  45. __siginfo_fpu_t __user *fpu_save;
  46. unsigned int insns[2];
  47. stack_t stack;
  48. unsigned int extra_size; /* Should be 0 */
  49. __siginfo_rwin_t __user *rwin_save;
  50. } __attribute__((aligned(8)));
  51. /* Align macros */
  52. #define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7)))
  53. #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
  54. /* Checks if the fp is valid. We always build signal frames which are
  55. * 16-byte aligned, therefore we can always enforce that the restore
  56. * frame has that property as well.
  57. */
  58. static inline bool invalid_frame_pointer(void __user *fp, int fplen)
  59. {
  60. if ((((unsigned long) fp) & 15) || !access_ok(fp, fplen))
  61. return true;
  62. return false;
  63. }
  64. asmlinkage void do_sigreturn(struct pt_regs *regs)
  65. {
  66. unsigned long up_psr, pc, npc, ufp;
  67. struct signal_frame __user *sf;
  68. sigset_t set;
  69. __siginfo_fpu_t __user *fpu_save;
  70. __siginfo_rwin_t __user *rwin_save;
  71. int err;
  72. /* Always make any pending restarted system calls return -EINTR */
  73. current->restart_block.fn = do_no_restart_syscall;
  74. synchronize_user_stack();
  75. sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];
  76. /* 1. Make sure we are not getting garbage from the user */
  77. if (invalid_frame_pointer(sf, sizeof(*sf)))
  78. goto segv_and_exit;
  79. if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP]))
  80. goto segv_and_exit;
  81. if (ufp & 0x7)
  82. goto segv_and_exit;
  83. err = __get_user(pc, &sf->info.si_regs.pc);
  84. err |= __get_user(npc, &sf->info.si_regs.npc);
  85. if ((pc | npc) & 3)
  86. goto segv_and_exit;
  87. /* 2. Restore the state */
  88. up_psr = regs->psr;
  89. err |= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs));
  90. /* User can only change condition codes and FPU enabling in %psr. */
  91. regs->psr = (up_psr & ~(PSR_ICC | PSR_EF))
  92. | (regs->psr & (PSR_ICC | PSR_EF));
  93. /* Prevent syscall restart. */
  94. pt_regs_clear_syscall(regs);
  95. err |= __get_user(fpu_save, &sf->fpu_save);
  96. if (fpu_save)
  97. err |= restore_fpu_state(regs, fpu_save);
  98. err |= __get_user(rwin_save, &sf->rwin_save);
  99. if (rwin_save)
  100. err |= restore_rwin_state(rwin_save);
  101. /* This is pretty much atomic, no amount locking would prevent
  102. * the races which exist anyways.
  103. */
  104. err |= __get_user(set.sig[0], &sf->info.si_mask);
  105. err |= __copy_from_user(&set.sig[1], &sf->extramask,
  106. (_NSIG_WORDS-1) * sizeof(unsigned int));
  107. if (err)
  108. goto segv_and_exit;
  109. set_current_blocked(&set);
  110. return;
  111. segv_and_exit:
  112. force_sig(SIGSEGV);
  113. }
  114. asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
  115. {
  116. struct rt_signal_frame __user *sf;
  117. unsigned int psr, pc, npc, ufp;
  118. __siginfo_fpu_t __user *fpu_save;
  119. __siginfo_rwin_t __user *rwin_save;
  120. sigset_t set;
  121. int err;
  122. synchronize_user_stack();
  123. sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];
  124. if (invalid_frame_pointer(sf, sizeof(*sf)))
  125. goto segv;
  126. if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))
  127. goto segv;
  128. if (ufp & 0x7)
  129. goto segv;
  130. err = __get_user(pc, &sf->regs.pc);
  131. err |= __get_user(npc, &sf->regs.npc);
  132. err |= ((pc | npc) & 0x03);
  133. err |= __get_user(regs->y, &sf->regs.y);
  134. err |= __get_user(psr, &sf->regs.psr);
  135. err |= __copy_from_user(&regs->u_regs[UREG_G1],
  136. &sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));
  137. regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);
  138. /* Prevent syscall restart. */
  139. pt_regs_clear_syscall(regs);
  140. err |= __get_user(fpu_save, &sf->fpu_save);
  141. if (!err && fpu_save)
  142. err |= restore_fpu_state(regs, fpu_save);
  143. err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
  144. err |= restore_altstack(&sf->stack);
  145. if (err)
  146. goto segv;
  147. regs->pc = pc;
  148. regs->npc = npc;
  149. err |= __get_user(rwin_save, &sf->rwin_save);
  150. if (!err && rwin_save) {
  151. if (restore_rwin_state(rwin_save))
  152. goto segv;
  153. }
  154. set_current_blocked(&set);
  155. return;
  156. segv:
  157. force_sig(SIGSEGV);
  158. }
  159. static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
  160. {
  161. unsigned long sp = regs->u_regs[UREG_FP];
  162. /*
  163. * If we are on the alternate signal stack and would overflow it, don't.
  164. * Return an always-bogus address instead so we will die with SIGSEGV.
  165. */
  166. if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
  167. return (void __user *) -1L;
  168. /* This is the X/Open sanctioned signal stack switching. */
  169. sp = sigsp(sp, ksig) - framesize;
  170. /* Always align the stack frame. This handles two cases. First,
  171. * sigaltstack need not be mindful of platform specific stack
  172. * alignment. Second, if we took this signal because the stack
  173. * is not aligned properly, we'd like to take the signal cleanly
  174. * and report that.
  175. */
  176. sp &= ~15UL;
  177. return (void __user *) sp;
  178. }
  179. static int setup_frame(struct ksignal *ksig, struct pt_regs *regs,
  180. sigset_t *oldset)
  181. {
  182. struct signal_frame __user *sf;
  183. int sigframe_size, err, wsaved;
  184. void __user *tail;
  185. /* 1. Make sure everything is clean */
  186. synchronize_user_stack();
  187. wsaved = current_thread_info()->w_saved;
  188. sigframe_size = sizeof(*sf);
  189. if (used_math())
  190. sigframe_size += sizeof(__siginfo_fpu_t);
  191. if (wsaved)
  192. sigframe_size += sizeof(__siginfo_rwin_t);
  193. sf = (struct signal_frame __user *)
  194. get_sigframe(ksig, regs, sigframe_size);
  195. if (invalid_frame_pointer(sf, sigframe_size)) {
  196. do_exit(SIGILL);
  197. return -EINVAL;
  198. }
  199. tail = sf + 1;
  200. /* 2. Save the current process state */
  201. err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));
  202. err |= __put_user(0, &sf->extra_size);
  203. if (used_math()) {
  204. __siginfo_fpu_t __user *fp = tail;
  205. tail += sizeof(*fp);
  206. err |= save_fpu_state(regs, fp);
  207. err |= __put_user(fp, &sf->fpu_save);
  208. } else {
  209. err |= __put_user(0, &sf->fpu_save);
  210. }
  211. if (wsaved) {
  212. __siginfo_rwin_t __user *rwp = tail;
  213. tail += sizeof(*rwp);
  214. err |= save_rwin_state(wsaved, rwp);
  215. err |= __put_user(rwp, &sf->rwin_save);
  216. } else {
  217. err |= __put_user(0, &sf->rwin_save);
  218. }
  219. err |= __put_user(oldset->sig[0], &sf->info.si_mask);
  220. err |= __copy_to_user(sf->extramask, &oldset->sig[1],
  221. (_NSIG_WORDS - 1) * sizeof(unsigned int));
  222. if (!wsaved) {
  223. err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
  224. sizeof(struct reg_window32));
  225. } else {
  226. struct reg_window32 *rp;
  227. rp = &current_thread_info()->reg_window[wsaved - 1];
  228. err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));
  229. }
  230. if (err)
  231. return err;
  232. /* 3. signal handler back-trampoline and parameters */
  233. regs->u_regs[UREG_FP] = (unsigned long) sf;
  234. regs->u_regs[UREG_I0] = ksig->sig;
  235. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  236. regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
  237. /* 4. signal handler */
  238. regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
  239. regs->npc = (regs->pc + 4);
  240. /* 5. return to kernel instructions */
  241. if (ksig->ka.ka_restorer)
  242. regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
  243. else {
  244. regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
  245. /* mov __NR_sigreturn, %g1 */
  246. err |= __put_user(0x821020d8, &sf->insns[0]);
  247. /* t 0x10 */
  248. err |= __put_user(0x91d02010, &sf->insns[1]);
  249. if (err)
  250. return err;
  251. /* Flush instruction space. */
  252. flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
  253. }
  254. return 0;
  255. }
  256. static int setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs,
  257. sigset_t *oldset)
  258. {
  259. struct rt_signal_frame __user *sf;
  260. int sigframe_size, wsaved;
  261. void __user *tail;
  262. unsigned int psr;
  263. int err;
  264. synchronize_user_stack();
  265. wsaved = current_thread_info()->w_saved;
  266. sigframe_size = sizeof(*sf);
  267. if (used_math())
  268. sigframe_size += sizeof(__siginfo_fpu_t);
  269. if (wsaved)
  270. sigframe_size += sizeof(__siginfo_rwin_t);
  271. sf = (struct rt_signal_frame __user *)
  272. get_sigframe(ksig, regs, sigframe_size);
  273. if (invalid_frame_pointer(sf, sigframe_size)) {
  274. do_exit(SIGILL);
  275. return -EINVAL;
  276. }
  277. tail = sf + 1;
  278. err = __put_user(regs->pc, &sf->regs.pc);
  279. err |= __put_user(regs->npc, &sf->regs.npc);
  280. err |= __put_user(regs->y, &sf->regs.y);
  281. psr = regs->psr;
  282. if (used_math())
  283. psr |= PSR_EF;
  284. err |= __put_user(psr, &sf->regs.psr);
  285. err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
  286. err |= __put_user(0, &sf->extra_size);
  287. if (psr & PSR_EF) {
  288. __siginfo_fpu_t __user *fp = tail;
  289. tail += sizeof(*fp);
  290. err |= save_fpu_state(regs, fp);
  291. err |= __put_user(fp, &sf->fpu_save);
  292. } else {
  293. err |= __put_user(0, &sf->fpu_save);
  294. }
  295. if (wsaved) {
  296. __siginfo_rwin_t __user *rwp = tail;
  297. tail += sizeof(*rwp);
  298. err |= save_rwin_state(wsaved, rwp);
  299. err |= __put_user(rwp, &sf->rwin_save);
  300. } else {
  301. err |= __put_user(0, &sf->rwin_save);
  302. }
  303. err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
  304. /* Setup sigaltstack */
  305. err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
  306. if (!wsaved) {
  307. err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],
  308. sizeof(struct reg_window32));
  309. } else {
  310. struct reg_window32 *rp;
  311. rp = &current_thread_info()->reg_window[wsaved - 1];
  312. err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));
  313. }
  314. err |= copy_siginfo_to_user(&sf->info, &ksig->info);
  315. if (err)
  316. return err;
  317. regs->u_regs[UREG_FP] = (unsigned long) sf;
  318. regs->u_regs[UREG_I0] = ksig->sig;
  319. regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
  320. regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
  321. regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
  322. regs->npc = (regs->pc + 4);
  323. if (ksig->ka.ka_restorer)
  324. regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
  325. else {
  326. regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
  327. /* mov __NR_sigreturn, %g1 */
  328. err |= __put_user(0x821020d8, &sf->insns[0]);
  329. /* t 0x10 */
  330. err |= __put_user(0x91d02010, &sf->insns[1]);
  331. if (err)
  332. return err;
  333. /* Flush instruction space. */
  334. flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
  335. }
  336. return 0;
  337. }
  338. static inline void
  339. handle_signal(struct ksignal *ksig, struct pt_regs *regs)
  340. {
  341. sigset_t *oldset = sigmask_to_save();
  342. int err;
  343. if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  344. err = setup_rt_frame(ksig, regs, oldset);
  345. else
  346. err = setup_frame(ksig, regs, oldset);
  347. signal_setup_done(err, ksig, 0);
  348. }
  349. static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
  350. struct sigaction *sa)
  351. {
  352. switch(regs->u_regs[UREG_I0]) {
  353. case ERESTART_RESTARTBLOCK:
  354. case ERESTARTNOHAND:
  355. no_system_call_restart:
  356. regs->u_regs[UREG_I0] = EINTR;
  357. regs->psr |= PSR_C;
  358. break;
  359. case ERESTARTSYS:
  360. if (!(sa->sa_flags & SA_RESTART))
  361. goto no_system_call_restart;
  362. fallthrough;
  363. case ERESTARTNOINTR:
  364. regs->u_regs[UREG_I0] = orig_i0;
  365. regs->pc -= 4;
  366. regs->npc -= 4;
  367. }
  368. }
  369. /* Note that 'init' is a special process: it doesn't get signals it doesn't
  370. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  371. * mistake.
  372. */
  373. static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
  374. {
  375. struct ksignal ksig;
  376. int restart_syscall;
  377. bool has_handler;
  378. /* It's a lot of work and synchronization to add a new ptrace
  379. * register for GDB to save and restore in order to get
  380. * orig_i0 correct for syscall restarts when debugging.
  381. *
  382. * Although it should be the case that most of the global
  383. * registers are volatile across a system call, glibc already
  384. * depends upon that fact that we preserve them. So we can't
  385. * just use any global register to save away the orig_i0 value.
  386. *
  387. * In particular %g2, %g3, %g4, and %g5 are all assumed to be
  388. * preserved across a system call trap by various pieces of
  389. * code in glibc.
  390. *
  391. * %g7 is used as the "thread register". %g6 is not used in
  392. * any fixed manner. %g6 is used as a scratch register and
  393. * a compiler temporary, but it's value is never used across
  394. * a system call. Therefore %g6 is usable for orig_i0 storage.
  395. */
  396. if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
  397. regs->u_regs[UREG_G6] = orig_i0;
  398. has_handler = get_signal(&ksig);
  399. /* If the debugger messes with the program counter, it clears
  400. * the software "in syscall" bit, directing us to not perform
  401. * a syscall restart.
  402. */
  403. restart_syscall = 0;
  404. if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C)) {
  405. restart_syscall = 1;
  406. orig_i0 = regs->u_regs[UREG_G6];
  407. }
  408. if (has_handler) {
  409. if (restart_syscall)
  410. syscall_restart(orig_i0, regs, &ksig.ka.sa);
  411. handle_signal(&ksig, regs);
  412. } else {
  413. if (restart_syscall) {
  414. switch (regs->u_regs[UREG_I0]) {
  415. case ERESTARTNOHAND:
  416. case ERESTARTSYS:
  417. case ERESTARTNOINTR:
  418. /* replay the system call when we are done */
  419. regs->u_regs[UREG_I0] = orig_i0;
  420. regs->pc -= 4;
  421. regs->npc -= 4;
  422. pt_regs_clear_syscall(regs);
  423. fallthrough;
  424. case ERESTART_RESTARTBLOCK:
  425. regs->u_regs[UREG_G1] = __NR_restart_syscall;
  426. regs->pc -= 4;
  427. regs->npc -= 4;
  428. pt_regs_clear_syscall(regs);
  429. }
  430. }
  431. restore_saved_sigmask();
  432. }
  433. }
  434. void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
  435. unsigned long thread_info_flags)
  436. {
  437. if (thread_info_flags & _TIF_SIGPENDING)
  438. do_signal(regs, orig_i0);
  439. if (thread_info_flags & _TIF_NOTIFY_RESUME)
  440. tracehook_notify_resume(regs);
  441. }
  442. asmlinkage int do_sys_sigstack(struct sigstack __user *ssptr,
  443. struct sigstack __user *ossptr,
  444. unsigned long sp)
  445. {
  446. int ret = -EFAULT;
  447. /* First see if old state is wanted. */
  448. if (ossptr) {
  449. if (put_user(current->sas_ss_sp + current->sas_ss_size,
  450. &ossptr->the_stack) ||
  451. __put_user(on_sig_stack(sp), &ossptr->cur_status))
  452. goto out;
  453. }
  454. /* Now see if we want to update the new state. */
  455. if (ssptr) {
  456. char *ss_sp;
  457. if (get_user(ss_sp, &ssptr->the_stack))
  458. goto out;
  459. /* If the current stack was set with sigaltstack, don't
  460. swap stacks while we are on it. */
  461. ret = -EPERM;
  462. if (current->sas_ss_sp && on_sig_stack(sp))
  463. goto out;
  464. /* Since we don't know the extent of the stack, and we don't
  465. track onstack-ness, but rather calculate it, we must
  466. presume a size. Ho hum this interface is lossy. */
  467. current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
  468. current->sas_ss_size = SIGSTKSZ;
  469. }
  470. ret = 0;
  471. out:
  472. return ret;
  473. }