signal.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright IBM Corp. 1999, 2006
  4. * Author(s): Denis Joseph Barrow ([email protected],[email protected])
  5. *
  6. * Based on Intel version
  7. *
  8. * Copyright (C) 1991, 1992 Linus Torvalds
  9. *
  10. * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
  11. */
  12. #include <linux/sched.h>
  13. #include <linux/sched/task_stack.h>
  14. #include <linux/mm.h>
  15. #include <linux/smp.h>
  16. #include <linux/kernel.h>
  17. #include <linux/signal.h>
  18. #include <linux/entry-common.h>
  19. #include <linux/errno.h>
  20. #include <linux/wait.h>
  21. #include <linux/ptrace.h>
  22. #include <linux/unistd.h>
  23. #include <linux/stddef.h>
  24. #include <linux/tty.h>
  25. #include <linux/personality.h>
  26. #include <linux/binfmts.h>
  27. #include <linux/syscalls.h>
  28. #include <linux/compat.h>
  29. #include <asm/ucontext.h>
  30. #include <linux/uaccess.h>
  31. #include <asm/lowcore.h>
  32. #include <asm/switch_to.h>
  33. #include <asm/vdso.h>
  34. #include "entry.h"
  35. /*
  36. * Layout of an old-style signal-frame:
  37. * -----------------------------------------
  38. * | save area (_SIGNAL_FRAMESIZE) |
  39. * -----------------------------------------
  40. * | struct sigcontext |
  41. * | oldmask |
  42. * | _sigregs * |
  43. * -----------------------------------------
  44. * | _sigregs with |
  45. * | _s390_regs_common |
  46. * | _s390_fp_regs |
  47. * -----------------------------------------
  48. * | int signo |
  49. * -----------------------------------------
  50. * | _sigregs_ext with |
  51. * | gprs_high 64 byte (opt) |
  52. * | vxrs_low 128 byte (opt) |
  53. * | vxrs_high 256 byte (opt) |
  54. * | reserved 128 byte (opt) |
  55. * -----------------------------------------
  56. * | __u16 svc_insn |
  57. * -----------------------------------------
  58. * The svc_insn entry with the sigreturn system call opcode does not
  59. * have a fixed position and moves if gprs_high or vxrs exist.
  60. * Future extensions will be added to _sigregs_ext.
  61. */
  62. struct sigframe
  63. {
  64. __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  65. struct sigcontext sc;
  66. _sigregs sregs;
  67. int signo;
  68. _sigregs_ext sregs_ext;
  69. __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */
  70. };
  71. /*
  72. * Layout of an rt signal-frame:
  73. * -----------------------------------------
  74. * | save area (_SIGNAL_FRAMESIZE) |
  75. * -----------------------------------------
  76. * | svc __NR_rt_sigreturn 2 byte |
  77. * -----------------------------------------
  78. * | struct siginfo |
  79. * -----------------------------------------
  80. * | struct ucontext_extended with |
  81. * | unsigned long uc_flags |
  82. * | struct ucontext *uc_link |
  83. * | stack_t uc_stack |
  84. * | _sigregs uc_mcontext with |
  85. * | _s390_regs_common |
  86. * | _s390_fp_regs |
  87. * | sigset_t uc_sigmask |
  88. * | _sigregs_ext uc_mcontext_ext |
  89. * | gprs_high 64 byte (opt) |
  90. * | vxrs_low 128 byte (opt) |
  91. * | vxrs_high 256 byte (opt)|
  92. * | reserved 128 byte (opt) |
  93. * -----------------------------------------
  94. * Future extensions will be added to _sigregs_ext.
  95. */
  96. struct rt_sigframe
  97. {
  98. __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  99. __u16 svc_insn;
  100. struct siginfo info;
  101. struct ucontext_extended uc;
  102. };
  103. /* Store registers needed to create the signal frame */
  104. static void store_sigregs(void)
  105. {
  106. save_access_regs(current->thread.acrs);
  107. save_fpu_regs();
  108. }
  109. /* Load registers after signal return */
  110. static void load_sigregs(void)
  111. {
  112. restore_access_regs(current->thread.acrs);
  113. }
  114. /* Returns non-zero on fault. */
  115. static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
  116. {
  117. _sigregs user_sregs;
  118. /* Copy a 'clean' PSW mask to the user to avoid leaking
  119. information about whether PER is currently on. */
  120. user_sregs.regs.psw.mask = PSW_USER_BITS |
  121. (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
  122. user_sregs.regs.psw.addr = regs->psw.addr;
  123. memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
  124. memcpy(&user_sregs.regs.acrs, current->thread.acrs,
  125. sizeof(user_sregs.regs.acrs));
  126. fpregs_store(&user_sregs.fpregs, &current->thread.fpu);
  127. if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
  128. return -EFAULT;
  129. return 0;
  130. }
  131. static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
  132. {
  133. _sigregs user_sregs;
  134. /* Always make any pending restarted system call return -EINTR */
  135. current->restart_block.fn = do_no_restart_syscall;
  136. if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
  137. return -EFAULT;
  138. if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
  139. return -EINVAL;
  140. /* Test the floating-point-control word. */
  141. if (test_fp_ctl(user_sregs.fpregs.fpc))
  142. return -EINVAL;
  143. /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
  144. regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
  145. (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
  146. /* Check for invalid user address space control. */
  147. if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
  148. regs->psw.mask = PSW_ASC_PRIMARY |
  149. (regs->psw.mask & ~PSW_MASK_ASC);
  150. /* Check for invalid amode */
  151. if (regs->psw.mask & PSW_MASK_EA)
  152. regs->psw.mask |= PSW_MASK_BA;
  153. regs->psw.addr = user_sregs.regs.psw.addr;
  154. memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
  155. memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
  156. sizeof(current->thread.acrs));
  157. fpregs_load(&user_sregs.fpregs, &current->thread.fpu);
  158. clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
  159. return 0;
  160. }
  161. /* Returns non-zero on fault. */
  162. static int save_sigregs_ext(struct pt_regs *regs,
  163. _sigregs_ext __user *sregs_ext)
  164. {
  165. __u64 vxrs[__NUM_VXRS_LOW];
  166. int i;
  167. /* Save vector registers to signal stack */
  168. if (MACHINE_HAS_VX) {
  169. for (i = 0; i < __NUM_VXRS_LOW; i++)
  170. vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
  171. if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
  172. sizeof(sregs_ext->vxrs_low)) ||
  173. __copy_to_user(&sregs_ext->vxrs_high,
  174. current->thread.fpu.vxrs + __NUM_VXRS_LOW,
  175. sizeof(sregs_ext->vxrs_high)))
  176. return -EFAULT;
  177. }
  178. return 0;
  179. }
  180. static int restore_sigregs_ext(struct pt_regs *regs,
  181. _sigregs_ext __user *sregs_ext)
  182. {
  183. __u64 vxrs[__NUM_VXRS_LOW];
  184. int i;
  185. /* Restore vector registers from signal stack */
  186. if (MACHINE_HAS_VX) {
  187. if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
  188. sizeof(sregs_ext->vxrs_low)) ||
  189. __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
  190. &sregs_ext->vxrs_high,
  191. sizeof(sregs_ext->vxrs_high)))
  192. return -EFAULT;
  193. for (i = 0; i < __NUM_VXRS_LOW; i++)
  194. *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
  195. }
  196. return 0;
  197. }
  198. SYSCALL_DEFINE0(sigreturn)
  199. {
  200. struct pt_regs *regs = task_pt_regs(current);
  201. struct sigframe __user *frame =
  202. (struct sigframe __user *) regs->gprs[15];
  203. sigset_t set;
  204. if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
  205. goto badframe;
  206. set_current_blocked(&set);
  207. save_fpu_regs();
  208. if (restore_sigregs(regs, &frame->sregs))
  209. goto badframe;
  210. if (restore_sigregs_ext(regs, &frame->sregs_ext))
  211. goto badframe;
  212. load_sigregs();
  213. return regs->gprs[2];
  214. badframe:
  215. force_sig(SIGSEGV);
  216. return 0;
  217. }
  218. SYSCALL_DEFINE0(rt_sigreturn)
  219. {
  220. struct pt_regs *regs = task_pt_regs(current);
  221. struct rt_sigframe __user *frame =
  222. (struct rt_sigframe __user *)regs->gprs[15];
  223. sigset_t set;
  224. if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
  225. goto badframe;
  226. set_current_blocked(&set);
  227. if (restore_altstack(&frame->uc.uc_stack))
  228. goto badframe;
  229. save_fpu_regs();
  230. if (restore_sigregs(regs, &frame->uc.uc_mcontext))
  231. goto badframe;
  232. if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
  233. goto badframe;
  234. load_sigregs();
  235. return regs->gprs[2];
  236. badframe:
  237. force_sig(SIGSEGV);
  238. return 0;
  239. }
  240. /*
  241. * Determine which stack to use..
  242. */
  243. static inline void __user *
  244. get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
  245. {
  246. unsigned long sp;
  247. /* Default to using normal stack */
  248. sp = regs->gprs[15];
  249. /* Overflow on alternate signal stack gives SIGSEGV. */
  250. if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
  251. return (void __user *) -1UL;
  252. /* This is the X/Open sanctioned signal stack switching. */
  253. if (ka->sa.sa_flags & SA_ONSTACK) {
  254. if (! sas_ss_flags(sp))
  255. sp = current->sas_ss_sp + current->sas_ss_size;
  256. }
  257. return (void __user *)((sp - frame_size) & -8ul);
  258. }
  259. static int setup_frame(int sig, struct k_sigaction *ka,
  260. sigset_t *set, struct pt_regs * regs)
  261. {
  262. struct sigframe __user *frame;
  263. struct sigcontext sc;
  264. unsigned long restorer;
  265. size_t frame_size;
  266. /*
  267. * gprs_high are only present for a 31-bit task running on
  268. * a 64-bit kernel (see compat_signal.c) but the space for
  269. * gprs_high need to be allocated if vector registers are
  270. * included in the signal frame on a 31-bit system.
  271. */
  272. frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
  273. if (MACHINE_HAS_VX)
  274. frame_size += sizeof(frame->sregs_ext);
  275. frame = get_sigframe(ka, regs, frame_size);
  276. if (frame == (void __user *) -1UL)
  277. return -EFAULT;
  278. /* Set up backchain. */
  279. if (__put_user(regs->gprs[15], (addr_t __user *) frame))
  280. return -EFAULT;
  281. /* Create struct sigcontext on the signal stack */
  282. memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
  283. sc.sregs = (_sigregs __user __force *) &frame->sregs;
  284. if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
  285. return -EFAULT;
  286. /* Store registers needed to create the signal frame */
  287. store_sigregs();
  288. /* Create _sigregs on the signal stack */
  289. if (save_sigregs(regs, &frame->sregs))
  290. return -EFAULT;
  291. /* Place signal number on stack to allow backtrace from handler. */
  292. if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
  293. return -EFAULT;
  294. /* Create _sigregs_ext on the signal stack */
  295. if (save_sigregs_ext(regs, &frame->sregs_ext))
  296. return -EFAULT;
  297. /* Set up to return from userspace. If provided, use a stub
  298. already in userspace. */
  299. if (ka->sa.sa_flags & SA_RESTORER)
  300. restorer = (unsigned long) ka->sa.sa_restorer;
  301. else
  302. restorer = VDSO64_SYMBOL(current, sigreturn);
  303. /* Set up registers for signal handler */
  304. regs->gprs[14] = restorer;
  305. regs->gprs[15] = (unsigned long) frame;
  306. /* Force default amode and default user address space control. */
  307. regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
  308. (PSW_USER_BITS & PSW_MASK_ASC) |
  309. (regs->psw.mask & ~PSW_MASK_ASC);
  310. regs->psw.addr = (unsigned long) ka->sa.sa_handler;
  311. regs->gprs[2] = sig;
  312. regs->gprs[3] = (unsigned long) &frame->sc;
  313. /* We forgot to include these in the sigcontext.
  314. To avoid breaking binary compatibility, they are passed as args. */
  315. if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
  316. sig == SIGTRAP || sig == SIGFPE) {
  317. /* set extra registers only for synchronous signals */
  318. regs->gprs[4] = regs->int_code & 127;
  319. regs->gprs[5] = regs->int_parm_long;
  320. regs->gprs[6] = current->thread.last_break;
  321. }
  322. return 0;
  323. }
  324. static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
  325. struct pt_regs *regs)
  326. {
  327. struct rt_sigframe __user *frame;
  328. unsigned long uc_flags, restorer;
  329. size_t frame_size;
  330. frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
  331. /*
  332. * gprs_high are only present for a 31-bit task running on
  333. * a 64-bit kernel (see compat_signal.c) but the space for
  334. * gprs_high need to be allocated if vector registers are
  335. * included in the signal frame on a 31-bit system.
  336. */
  337. uc_flags = 0;
  338. if (MACHINE_HAS_VX) {
  339. frame_size += sizeof(_sigregs_ext);
  340. uc_flags |= UC_VXRS;
  341. }
  342. frame = get_sigframe(&ksig->ka, regs, frame_size);
  343. if (frame == (void __user *) -1UL)
  344. return -EFAULT;
  345. /* Set up backchain. */
  346. if (__put_user(regs->gprs[15], (addr_t __user *) frame))
  347. return -EFAULT;
  348. /* Set up to return from userspace. If provided, use a stub
  349. already in userspace. */
  350. if (ksig->ka.sa.sa_flags & SA_RESTORER)
  351. restorer = (unsigned long) ksig->ka.sa.sa_restorer;
  352. else
  353. restorer = VDSO64_SYMBOL(current, rt_sigreturn);
  354. /* Create siginfo on the signal stack */
  355. if (copy_siginfo_to_user(&frame->info, &ksig->info))
  356. return -EFAULT;
  357. /* Store registers needed to create the signal frame */
  358. store_sigregs();
  359. /* Create ucontext on the signal stack. */
  360. if (__put_user(uc_flags, &frame->uc.uc_flags) ||
  361. __put_user(NULL, &frame->uc.uc_link) ||
  362. __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
  363. save_sigregs(regs, &frame->uc.uc_mcontext) ||
  364. __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
  365. save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
  366. return -EFAULT;
  367. /* Set up registers for signal handler */
  368. regs->gprs[14] = restorer;
  369. regs->gprs[15] = (unsigned long) frame;
  370. /* Force default amode and default user address space control. */
  371. regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
  372. (PSW_USER_BITS & PSW_MASK_ASC) |
  373. (regs->psw.mask & ~PSW_MASK_ASC);
  374. regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler;
  375. regs->gprs[2] = ksig->sig;
  376. regs->gprs[3] = (unsigned long) &frame->info;
  377. regs->gprs[4] = (unsigned long) &frame->uc;
  378. regs->gprs[5] = current->thread.last_break;
  379. return 0;
  380. }
  381. static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
  382. struct pt_regs *regs)
  383. {
  384. int ret;
  385. /* Set up the stack frame */
  386. if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  387. ret = setup_rt_frame(ksig, oldset, regs);
  388. else
  389. ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
  390. signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
  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. void arch_do_signal_or_restart(struct pt_regs *regs)
  402. {
  403. struct ksignal ksig;
  404. sigset_t *oldset = sigmask_to_save();
  405. /*
  406. * Get signal to deliver. When running under ptrace, at this point
  407. * the debugger may change all our registers, including the system
  408. * call information.
  409. */
  410. current->thread.system_call =
  411. test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
  412. if (get_signal(&ksig)) {
  413. /* Whee! Actually deliver the signal. */
  414. if (current->thread.system_call) {
  415. regs->int_code = current->thread.system_call;
  416. /* Check for system call restarting. */
  417. switch (regs->gprs[2]) {
  418. case -ERESTART_RESTARTBLOCK:
  419. case -ERESTARTNOHAND:
  420. regs->gprs[2] = -EINTR;
  421. break;
  422. case -ERESTARTSYS:
  423. if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
  424. regs->gprs[2] = -EINTR;
  425. break;
  426. }
  427. fallthrough;
  428. case -ERESTARTNOINTR:
  429. regs->gprs[2] = regs->orig_gpr2;
  430. regs->psw.addr =
  431. __rewind_psw(regs->psw,
  432. regs->int_code >> 16);
  433. break;
  434. }
  435. }
  436. /* No longer in a system call */
  437. clear_pt_regs_flag(regs, PIF_SYSCALL);
  438. rseq_signal_deliver(&ksig, regs);
  439. if (is_compat_task())
  440. handle_signal32(&ksig, oldset, regs);
  441. else
  442. handle_signal(&ksig, oldset, regs);
  443. return;
  444. }
  445. /* No handlers present - check for system call restart */
  446. clear_pt_regs_flag(regs, PIF_SYSCALL);
  447. if (current->thread.system_call) {
  448. regs->int_code = current->thread.system_call;
  449. switch (regs->gprs[2]) {
  450. case -ERESTART_RESTARTBLOCK:
  451. /* Restart with sys_restart_syscall */
  452. regs->gprs[2] = regs->orig_gpr2;
  453. current->restart_block.arch_data = regs->psw.addr;
  454. if (is_compat_task())
  455. regs->psw.addr = VDSO32_SYMBOL(current, restart_syscall);
  456. else
  457. regs->psw.addr = VDSO64_SYMBOL(current, restart_syscall);
  458. if (test_thread_flag(TIF_SINGLE_STEP))
  459. clear_thread_flag(TIF_PER_TRAP);
  460. break;
  461. case -ERESTARTNOHAND:
  462. case -ERESTARTSYS:
  463. case -ERESTARTNOINTR:
  464. regs->gprs[2] = regs->orig_gpr2;
  465. regs->psw.addr = __rewind_psw(regs->psw, regs->int_code >> 16);
  466. if (test_thread_flag(TIF_SINGLE_STEP))
  467. clear_thread_flag(TIF_PER_TRAP);
  468. break;
  469. }
  470. }
  471. /*
  472. * If there's no signal to deliver, we just put the saved sigmask back.
  473. */
  474. restore_saved_sigmask();
  475. }