signal.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/arch/alpha/kernel/signal.c
  4. *
  5. * Copyright (C) 1995 Linus Torvalds
  6. *
  7. * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
  8. */
  9. #include <linux/sched/signal.h>
  10. #include <linux/sched/task_stack.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/smp.h>
  19. #include <linux/stddef.h>
  20. #include <linux/tty.h>
  21. #include <linux/binfmts.h>
  22. #include <linux/bitops.h>
  23. #include <linux/syscalls.h>
  24. #include <linux/resume_user_mode.h>
  25. #include <linux/uaccess.h>
  26. #include <asm/sigcontext.h>
  27. #include <asm/ucontext.h>
  28. #include "proto.h"
  29. #define DEBUG_SIG 0
  30. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  31. asmlinkage void ret_from_sys_call(void);
  32. /*
  33. * The OSF/1 sigprocmask calling sequence is different from the
  34. * C sigprocmask() sequence..
  35. */
  36. SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
  37. {
  38. sigset_t oldmask;
  39. sigset_t mask;
  40. unsigned long res;
  41. siginitset(&mask, newmask & _BLOCKABLE);
  42. res = sigprocmask(how, &mask, &oldmask);
  43. if (!res) {
  44. force_successful_syscall_return();
  45. res = oldmask.sig[0];
  46. }
  47. return res;
  48. }
  49. SYSCALL_DEFINE3(osf_sigaction, int, sig,
  50. const struct osf_sigaction __user *, act,
  51. struct osf_sigaction __user *, oact)
  52. {
  53. struct k_sigaction new_ka, old_ka;
  54. int ret;
  55. if (act) {
  56. old_sigset_t mask;
  57. if (!access_ok(act, sizeof(*act)) ||
  58. __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  59. __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
  60. __get_user(mask, &act->sa_mask))
  61. return -EFAULT;
  62. siginitset(&new_ka.sa.sa_mask, mask);
  63. new_ka.ka_restorer = NULL;
  64. }
  65. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  66. if (!ret && oact) {
  67. if (!access_ok(oact, sizeof(*oact)) ||
  68. __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  69. __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
  70. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
  71. return -EFAULT;
  72. }
  73. return ret;
  74. }
  75. SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
  76. struct sigaction __user *, oact,
  77. size_t, sigsetsize, void __user *, restorer)
  78. {
  79. struct k_sigaction new_ka, old_ka;
  80. int ret;
  81. /* XXX: Don't preclude handling different sized sigset_t's. */
  82. if (sigsetsize != sizeof(sigset_t))
  83. return -EINVAL;
  84. if (act) {
  85. new_ka.ka_restorer = restorer;
  86. if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
  87. return -EFAULT;
  88. }
  89. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  90. if (!ret && oact) {
  91. if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
  92. return -EFAULT;
  93. }
  94. return ret;
  95. }
  96. /*
  97. * Do a signal return; undo the signal stack.
  98. */
  99. #if _NSIG_WORDS > 1
  100. # error "Non SA_SIGINFO frame needs rearranging"
  101. #endif
  102. struct sigframe
  103. {
  104. struct sigcontext sc;
  105. unsigned int retcode[3];
  106. };
  107. struct rt_sigframe
  108. {
  109. struct siginfo info;
  110. struct ucontext uc;
  111. unsigned int retcode[3];
  112. };
  113. /* If this changes, userland unwinders that Know Things about our signal
  114. frame will break. Do not undertake lightly. It also implies an ABI
  115. change wrt the size of siginfo_t, which may cause some pain. */
  116. extern char compile_time_assert
  117. [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
  118. #define INSN_MOV_R30_R16 0x47fe0410
  119. #define INSN_LDI_R0 0x201f0000
  120. #define INSN_CALLSYS 0x00000083
  121. static long
  122. restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
  123. {
  124. unsigned long usp;
  125. struct switch_stack *sw = (struct switch_stack *)regs - 1;
  126. long i, err = __get_user(regs->pc, &sc->sc_pc);
  127. current->restart_block.fn = do_no_restart_syscall;
  128. sw->r26 = (unsigned long) ret_from_sys_call;
  129. err |= __get_user(regs->r0, sc->sc_regs+0);
  130. err |= __get_user(regs->r1, sc->sc_regs+1);
  131. err |= __get_user(regs->r2, sc->sc_regs+2);
  132. err |= __get_user(regs->r3, sc->sc_regs+3);
  133. err |= __get_user(regs->r4, sc->sc_regs+4);
  134. err |= __get_user(regs->r5, sc->sc_regs+5);
  135. err |= __get_user(regs->r6, sc->sc_regs+6);
  136. err |= __get_user(regs->r7, sc->sc_regs+7);
  137. err |= __get_user(regs->r8, sc->sc_regs+8);
  138. err |= __get_user(sw->r9, sc->sc_regs+9);
  139. err |= __get_user(sw->r10, sc->sc_regs+10);
  140. err |= __get_user(sw->r11, sc->sc_regs+11);
  141. err |= __get_user(sw->r12, sc->sc_regs+12);
  142. err |= __get_user(sw->r13, sc->sc_regs+13);
  143. err |= __get_user(sw->r14, sc->sc_regs+14);
  144. err |= __get_user(sw->r15, sc->sc_regs+15);
  145. err |= __get_user(regs->r16, sc->sc_regs+16);
  146. err |= __get_user(regs->r17, sc->sc_regs+17);
  147. err |= __get_user(regs->r18, sc->sc_regs+18);
  148. err |= __get_user(regs->r19, sc->sc_regs+19);
  149. err |= __get_user(regs->r20, sc->sc_regs+20);
  150. err |= __get_user(regs->r21, sc->sc_regs+21);
  151. err |= __get_user(regs->r22, sc->sc_regs+22);
  152. err |= __get_user(regs->r23, sc->sc_regs+23);
  153. err |= __get_user(regs->r24, sc->sc_regs+24);
  154. err |= __get_user(regs->r25, sc->sc_regs+25);
  155. err |= __get_user(regs->r26, sc->sc_regs+26);
  156. err |= __get_user(regs->r27, sc->sc_regs+27);
  157. err |= __get_user(regs->r28, sc->sc_regs+28);
  158. err |= __get_user(regs->gp, sc->sc_regs+29);
  159. err |= __get_user(usp, sc->sc_regs+30);
  160. wrusp(usp);
  161. for (i = 0; i < 31; i++)
  162. err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
  163. err |= __get_user(sw->fp[31], &sc->sc_fpcr);
  164. return err;
  165. }
  166. /* Note that this syscall is also used by setcontext(3) to install
  167. a given sigcontext. This because it's impossible to set *all*
  168. registers and transfer control from userland. */
  169. asmlinkage void
  170. do_sigreturn(struct sigcontext __user *sc)
  171. {
  172. struct pt_regs *regs = current_pt_regs();
  173. sigset_t set;
  174. /* Verify that it's a good sigcontext before using it */
  175. if (!access_ok(sc, sizeof(*sc)))
  176. goto give_sigsegv;
  177. if (__get_user(set.sig[0], &sc->sc_mask))
  178. goto give_sigsegv;
  179. set_current_blocked(&set);
  180. if (restore_sigcontext(sc, regs))
  181. goto give_sigsegv;
  182. /* Send SIGTRAP if we're single-stepping: */
  183. if (ptrace_cancel_bpt (current)) {
  184. send_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *) regs->pc,
  185. current);
  186. }
  187. return;
  188. give_sigsegv:
  189. force_sig(SIGSEGV);
  190. }
  191. asmlinkage void
  192. do_rt_sigreturn(struct rt_sigframe __user *frame)
  193. {
  194. struct pt_regs *regs = current_pt_regs();
  195. sigset_t set;
  196. /* Verify that it's a good ucontext_t before using it */
  197. if (!access_ok(&frame->uc, sizeof(frame->uc)))
  198. goto give_sigsegv;
  199. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  200. goto give_sigsegv;
  201. set_current_blocked(&set);
  202. if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
  203. goto give_sigsegv;
  204. /* Send SIGTRAP if we're single-stepping: */
  205. if (ptrace_cancel_bpt (current)) {
  206. send_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *) regs->pc,
  207. current);
  208. }
  209. return;
  210. give_sigsegv:
  211. force_sig(SIGSEGV);
  212. }
  213. /*
  214. * Set up a signal frame.
  215. */
  216. static inline void __user *
  217. get_sigframe(struct ksignal *ksig, unsigned long sp, size_t frame_size)
  218. {
  219. return (void __user *)((sigsp(sp, ksig) - frame_size) & -32ul);
  220. }
  221. static long
  222. setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
  223. unsigned long mask, unsigned long sp)
  224. {
  225. struct switch_stack *sw = (struct switch_stack *)regs - 1;
  226. long i, err = 0;
  227. err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
  228. err |= __put_user(mask, &sc->sc_mask);
  229. err |= __put_user(regs->pc, &sc->sc_pc);
  230. err |= __put_user(8, &sc->sc_ps);
  231. err |= __put_user(regs->r0 , sc->sc_regs+0);
  232. err |= __put_user(regs->r1 , sc->sc_regs+1);
  233. err |= __put_user(regs->r2 , sc->sc_regs+2);
  234. err |= __put_user(regs->r3 , sc->sc_regs+3);
  235. err |= __put_user(regs->r4 , sc->sc_regs+4);
  236. err |= __put_user(regs->r5 , sc->sc_regs+5);
  237. err |= __put_user(regs->r6 , sc->sc_regs+6);
  238. err |= __put_user(regs->r7 , sc->sc_regs+7);
  239. err |= __put_user(regs->r8 , sc->sc_regs+8);
  240. err |= __put_user(sw->r9 , sc->sc_regs+9);
  241. err |= __put_user(sw->r10 , sc->sc_regs+10);
  242. err |= __put_user(sw->r11 , sc->sc_regs+11);
  243. err |= __put_user(sw->r12 , sc->sc_regs+12);
  244. err |= __put_user(sw->r13 , sc->sc_regs+13);
  245. err |= __put_user(sw->r14 , sc->sc_regs+14);
  246. err |= __put_user(sw->r15 , sc->sc_regs+15);
  247. err |= __put_user(regs->r16, sc->sc_regs+16);
  248. err |= __put_user(regs->r17, sc->sc_regs+17);
  249. err |= __put_user(regs->r18, sc->sc_regs+18);
  250. err |= __put_user(regs->r19, sc->sc_regs+19);
  251. err |= __put_user(regs->r20, sc->sc_regs+20);
  252. err |= __put_user(regs->r21, sc->sc_regs+21);
  253. err |= __put_user(regs->r22, sc->sc_regs+22);
  254. err |= __put_user(regs->r23, sc->sc_regs+23);
  255. err |= __put_user(regs->r24, sc->sc_regs+24);
  256. err |= __put_user(regs->r25, sc->sc_regs+25);
  257. err |= __put_user(regs->r26, sc->sc_regs+26);
  258. err |= __put_user(regs->r27, sc->sc_regs+27);
  259. err |= __put_user(regs->r28, sc->sc_regs+28);
  260. err |= __put_user(regs->gp , sc->sc_regs+29);
  261. err |= __put_user(sp, sc->sc_regs+30);
  262. err |= __put_user(0, sc->sc_regs+31);
  263. for (i = 0; i < 31; i++)
  264. err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
  265. err |= __put_user(0, sc->sc_fpregs+31);
  266. err |= __put_user(sw->fp[31], &sc->sc_fpcr);
  267. err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
  268. err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
  269. err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
  270. return err;
  271. }
  272. static int
  273. setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
  274. {
  275. unsigned long oldsp, r26, err = 0;
  276. struct sigframe __user *frame;
  277. oldsp = rdusp();
  278. frame = get_sigframe(ksig, oldsp, sizeof(*frame));
  279. if (!access_ok(frame, sizeof(*frame)))
  280. return -EFAULT;
  281. err |= setup_sigcontext(&frame->sc, regs, set->sig[0], oldsp);
  282. if (err)
  283. return -EFAULT;
  284. /* Set up to return from userspace. If provided, use a stub
  285. already in userspace. */
  286. r26 = (unsigned long) ksig->ka.ka_restorer;
  287. if (!r26) {
  288. err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
  289. err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
  290. err |= __put_user(INSN_CALLSYS, frame->retcode+2);
  291. imb();
  292. r26 = (unsigned long) frame->retcode;
  293. }
  294. /* Check that everything was written properly. */
  295. if (err)
  296. return err;
  297. /* "Return" to the handler */
  298. regs->r26 = r26;
  299. regs->r27 = regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
  300. regs->r16 = ksig->sig; /* a0: signal number */
  301. regs->r17 = 0; /* a1: exception code */
  302. regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
  303. wrusp((unsigned long) frame);
  304. #if DEBUG_SIG
  305. printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
  306. current->comm, current->pid, frame, regs->pc, regs->r26);
  307. #endif
  308. return 0;
  309. }
  310. static int
  311. setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
  312. {
  313. unsigned long oldsp, r26, err = 0;
  314. struct rt_sigframe __user *frame;
  315. oldsp = rdusp();
  316. frame = get_sigframe(ksig, oldsp, sizeof(*frame));
  317. if (!access_ok(frame, sizeof(*frame)))
  318. return -EFAULT;
  319. err |= copy_siginfo_to_user(&frame->info, &ksig->info);
  320. /* Create the ucontext. */
  321. err |= __put_user(0, &frame->uc.uc_flags);
  322. err |= __put_user(0, &frame->uc.uc_link);
  323. err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
  324. err |= __save_altstack(&frame->uc.uc_stack, oldsp);
  325. err |= setup_sigcontext(&frame->uc.uc_mcontext, regs,
  326. set->sig[0], oldsp);
  327. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  328. if (err)
  329. return -EFAULT;
  330. /* Set up to return from userspace. If provided, use a stub
  331. already in userspace. */
  332. r26 = (unsigned long) ksig->ka.ka_restorer;
  333. if (!r26) {
  334. err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
  335. err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
  336. frame->retcode+1);
  337. err |= __put_user(INSN_CALLSYS, frame->retcode+2);
  338. imb();
  339. r26 = (unsigned long) frame->retcode;
  340. }
  341. if (err)
  342. return -EFAULT;
  343. /* "Return" to the handler */
  344. regs->r26 = r26;
  345. regs->r27 = regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
  346. regs->r16 = ksig->sig; /* a0: signal number */
  347. regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
  348. regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */
  349. wrusp((unsigned long) frame);
  350. #if DEBUG_SIG
  351. printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
  352. current->comm, current->pid, frame, regs->pc, regs->r26);
  353. #endif
  354. return 0;
  355. }
  356. /*
  357. * OK, we're invoking a handler.
  358. */
  359. static inline void
  360. handle_signal(struct ksignal *ksig, struct pt_regs *regs)
  361. {
  362. sigset_t *oldset = sigmask_to_save();
  363. int ret;
  364. if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  365. ret = setup_rt_frame(ksig, oldset, regs);
  366. else
  367. ret = setup_frame(ksig, oldset, regs);
  368. signal_setup_done(ret, ksig, 0);
  369. }
  370. static inline void
  371. syscall_restart(unsigned long r0, unsigned long r19,
  372. struct pt_regs *regs, struct k_sigaction *ka)
  373. {
  374. switch (regs->r0) {
  375. case ERESTARTSYS:
  376. if (!(ka->sa.sa_flags & SA_RESTART)) {
  377. case ERESTARTNOHAND:
  378. regs->r0 = EINTR;
  379. break;
  380. }
  381. fallthrough;
  382. case ERESTARTNOINTR:
  383. regs->r0 = r0; /* reset v0 and a3 and replay syscall */
  384. regs->r19 = r19;
  385. regs->pc -= 4;
  386. break;
  387. case ERESTART_RESTARTBLOCK:
  388. regs->r0 = EINTR;
  389. break;
  390. }
  391. }
  392. /*
  393. * Note that 'init' is a special process: it doesn't get signals it doesn't
  394. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  395. * mistake.
  396. *
  397. * Note that we go through the signals twice: once to check the signals that
  398. * the kernel can handle, and then we build all the user-level signal handling
  399. * stack-frames in one go after that.
  400. *
  401. * "r0" and "r19" are the registers we need to restore for system call
  402. * restart. "r0" is also used as an indicator whether we can restart at
  403. * all (if we get here from anything but a syscall return, it will be 0)
  404. */
  405. static void
  406. do_signal(struct pt_regs *regs, unsigned long r0, unsigned long r19)
  407. {
  408. unsigned long single_stepping = ptrace_cancel_bpt(current);
  409. struct ksignal ksig;
  410. /* This lets the debugger run, ... */
  411. if (get_signal(&ksig)) {
  412. /* ... so re-check the single stepping. */
  413. single_stepping |= ptrace_cancel_bpt(current);
  414. /* Whee! Actually deliver the signal. */
  415. if (r0)
  416. syscall_restart(r0, r19, regs, &ksig.ka);
  417. handle_signal(&ksig, regs);
  418. } else {
  419. single_stepping |= ptrace_cancel_bpt(current);
  420. if (r0) {
  421. switch (regs->r0) {
  422. case ERESTARTNOHAND:
  423. case ERESTARTSYS:
  424. case ERESTARTNOINTR:
  425. /* Reset v0 and a3 and replay syscall. */
  426. regs->r0 = r0;
  427. regs->r19 = r19;
  428. regs->pc -= 4;
  429. break;
  430. case ERESTART_RESTARTBLOCK:
  431. /* Set v0 to the restart_syscall and replay */
  432. regs->r0 = __NR_restart_syscall;
  433. regs->pc -= 4;
  434. break;
  435. }
  436. }
  437. restore_saved_sigmask();
  438. }
  439. if (single_stepping)
  440. ptrace_set_bpt(current); /* re-set breakpoint */
  441. }
  442. void
  443. do_work_pending(struct pt_regs *regs, unsigned long thread_flags,
  444. unsigned long r0, unsigned long r19)
  445. {
  446. do {
  447. if (thread_flags & _TIF_NEED_RESCHED) {
  448. schedule();
  449. } else {
  450. local_irq_enable();
  451. if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) {
  452. do_signal(regs, r0, r19);
  453. r0 = 0;
  454. } else {
  455. resume_user_mode_work(regs);
  456. }
  457. }
  458. local_irq_disable();
  459. thread_flags = read_thread_flags();
  460. } while (thread_flags & _TIF_WORK_MASK);
  461. }