signal.c 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2009 Sunplus Core Technology Co., Ltd.
  4. * Chen Liqin <liqin.chen@sunplusct.com>
  5. * Lennox Wu <lennox.wu@sunplusct.com>
  6. * Copyright (C) 2012 Regents of the University of California
  7. */
  8. #include <linux/compat.h>
  9. #include <linux/signal.h>
  10. #include <linux/uaccess.h>
  11. #include <linux/syscalls.h>
  12. #include <linux/tracehook.h>
  13. #include <linux/linkage.h>
  14. #include <asm/ucontext.h>
  15. #include <asm/vdso.h>
  16. #include <asm/switch_to.h>
  17. #include <asm/csr.h>
  18. extern u32 __user_rt_sigreturn[2];
  19. #define DEBUG_SIG 0
  20. struct rt_sigframe {
  21. struct siginfo info;
  22. struct ucontext uc;
  23. #ifndef CONFIG_MMU
  24. u32 sigreturn_code[2];
  25. #endif
  26. };
  27. #ifdef CONFIG_FPU
  28. static long restore_fp_state(struct pt_regs *regs,
  29. union __riscv_fp_state __user *sc_fpregs)
  30. {
  31. long err;
  32. struct __riscv_d_ext_state __user *state = &sc_fpregs->d;
  33. size_t i;
  34. err = __copy_from_user(&current->thread.fstate, state, sizeof(*state));
  35. if (unlikely(err))
  36. return err;
  37. fstate_restore(current, regs);
  38. /* We support no other extension state at this time. */
  39. for (i = 0; i < ARRAY_SIZE(sc_fpregs->q.reserved); i++) {
  40. u32 value;
  41. err = __get_user(value, &sc_fpregs->q.reserved[i]);
  42. if (unlikely(err))
  43. break;
  44. if (value != 0)
  45. return -EINVAL;
  46. }
  47. return err;
  48. }
  49. static long save_fp_state(struct pt_regs *regs,
  50. union __riscv_fp_state __user *sc_fpregs)
  51. {
  52. long err;
  53. struct __riscv_d_ext_state __user *state = &sc_fpregs->d;
  54. size_t i;
  55. fstate_save(current, regs);
  56. err = __copy_to_user(state, &current->thread.fstate, sizeof(*state));
  57. if (unlikely(err))
  58. return err;
  59. /* We support no other extension state at this time. */
  60. for (i = 0; i < ARRAY_SIZE(sc_fpregs->q.reserved); i++) {
  61. err = __put_user(0, &sc_fpregs->q.reserved[i]);
  62. if (unlikely(err))
  63. break;
  64. }
  65. return err;
  66. }
  67. #else
  68. #define save_fp_state(task, regs) (0)
  69. #define restore_fp_state(task, regs) (0)
  70. #endif
  71. #ifdef CONFIG_VECTOR
  72. static long restore_v_state(struct pt_regs *regs,
  73. struct __riscv_v_state *sc_vregs)
  74. {
  75. long err;
  76. struct __riscv_v_state __user *state = sc_vregs;
  77. err = __copy_from_user(&current->thread.vstate, state, sizeof(*state));
  78. if (unlikely(err))
  79. return err;
  80. vstate_restore(current, regs);
  81. return err;
  82. }
  83. static long save_v_state(struct pt_regs *regs,
  84. struct __riscv_v_state *sc_vregs)
  85. {
  86. long err;
  87. struct __riscv_v_state __user *state = sc_vregs;
  88. vstate_save(current, regs);
  89. err = __copy_to_user(state, &current->thread.vstate, sizeof(*state));
  90. if (unlikely(err))
  91. return err;
  92. return err;
  93. }
  94. #else
  95. #define save_v_state(task, regs) (0)
  96. #define restore_v_state(task, regs) (0)
  97. #endif
  98. static long restore_sigcontext(struct pt_regs *regs,
  99. struct sigcontext __user *sc)
  100. {
  101. long err;
  102. /* sc_regs is structured the same as the start of pt_regs */
  103. err = __copy_from_user(regs, &sc->sc_regs, sizeof(sc->sc_regs));
  104. /* Restore the floating-point state. */
  105. if (has_fpu)
  106. err |= restore_fp_state(regs, &sc->sc_fpregs);
  107. /* Restore the vector state. */
  108. if (has_vector)
  109. err |= restore_v_state(regs, &sc->sc_vregs);
  110. return err;
  111. }
  112. SYSCALL_DEFINE0(rt_sigreturn)
  113. {
  114. struct pt_regs *regs = current_pt_regs();
  115. struct rt_sigframe __user *frame;
  116. struct task_struct *task;
  117. sigset_t set;
  118. /* Always make any pending restarted system calls return -EINTR */
  119. current->restart_block.fn = do_no_restart_syscall;
  120. frame = (struct rt_sigframe __user *)regs->sp;
  121. if (!access_ok(frame, sizeof(*frame)))
  122. goto badframe;
  123. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  124. goto badframe;
  125. set_current_blocked(&set);
  126. if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
  127. goto badframe;
  128. if (restore_altstack(&frame->uc.uc_stack))
  129. goto badframe;
  130. return regs->a0;
  131. badframe:
  132. task = current;
  133. if (show_unhandled_signals) {
  134. pr_info_ratelimited(
  135. "%s[%d]: bad frame in %s: frame=%p pc=%p sp=%p\n",
  136. task->comm, task_pid_nr(task), __func__,
  137. frame, (void *)regs->epc, (void *)regs->sp);
  138. }
  139. force_sig(SIGSEGV);
  140. return 0;
  141. }
  142. static long setup_sigcontext(struct rt_sigframe __user *frame,
  143. struct pt_regs *regs)
  144. {
  145. struct sigcontext __user *sc = &frame->uc.uc_mcontext;
  146. long err;
  147. /* sc_regs is structured the same as the start of pt_regs */
  148. err = __copy_to_user(&sc->sc_regs, regs, sizeof(sc->sc_regs));
  149. /* Save the floating-point state. */
  150. if (has_fpu)
  151. err |= save_fp_state(regs, &sc->sc_fpregs);
  152. /* Save the vector state. */
  153. if (has_vector)
  154. err |= save_v_state(regs, &sc->sc_vregs);
  155. return err;
  156. }
  157. static inline void __user *get_sigframe(struct ksignal *ksig,
  158. struct pt_regs *regs, size_t framesize)
  159. {
  160. unsigned long sp;
  161. /* Default to using normal stack */
  162. sp = regs->sp;
  163. /*
  164. * If we are on the alternate signal stack and would overflow it, don't.
  165. * Return an always-bogus address instead so we will die with SIGSEGV.
  166. */
  167. if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
  168. return (void __user __force *)(-1UL);
  169. /* This is the X/Open sanctioned signal stack switching. */
  170. sp = sigsp(sp, ksig) - framesize;
  171. /* Align the stack frame. */
  172. sp &= ~0xfUL;
  173. return (void __user *)sp;
  174. }
  175. static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
  176. struct pt_regs *regs)
  177. {
  178. struct rt_sigframe __user *frame;
  179. long err = 0;
  180. frame = get_sigframe(ksig, regs, sizeof(*frame));
  181. if (!access_ok(frame, sizeof(*frame)))
  182. return -EFAULT;
  183. err |= copy_siginfo_to_user(&frame->info, &ksig->info);
  184. /* Create the ucontext. */
  185. err |= __put_user(0, &frame->uc.uc_flags);
  186. err |= __put_user(NULL, &frame->uc.uc_link);
  187. err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
  188. err |= setup_sigcontext(frame, regs);
  189. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  190. if (err)
  191. return -EFAULT;
  192. /* Set up to return from userspace. */
  193. #ifdef CONFIG_MMU
  194. regs->ra = (unsigned long)VDSO_SYMBOL(
  195. current->mm->context.vdso, rt_sigreturn);
  196. #else
  197. /*
  198. * For the nommu case we don't have a VDSO. Instead we push two
  199. * instructions to call the rt_sigreturn syscall onto the user stack.
  200. */
  201. if (copy_to_user(&frame->sigreturn_code, __user_rt_sigreturn,
  202. sizeof(frame->sigreturn_code)))
  203. return -EFAULT;
  204. regs->ra = (unsigned long)&frame->sigreturn_code;
  205. #endif /* CONFIG_MMU */
  206. /*
  207. * Set up registers for signal handler.
  208. * Registers that we don't modify keep the value they had from
  209. * user-space at the time we took the signal.
  210. * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
  211. * since some things rely on this (e.g. glibc's debug/segfault.c).
  212. */
  213. regs->epc = (unsigned long)ksig->ka.sa.sa_handler;
  214. regs->sp = (unsigned long)frame;
  215. regs->a0 = ksig->sig; /* a0: signal number */
  216. regs->a1 = (unsigned long)(&frame->info); /* a1: siginfo pointer */
  217. regs->a2 = (unsigned long)(&frame->uc); /* a2: ucontext pointer */
  218. #if DEBUG_SIG
  219. pr_info("SIG deliver (%s:%d): sig=%d pc=%p ra=%p sp=%p\n",
  220. current->comm, task_pid_nr(current), ksig->sig,
  221. (void *)regs->epc, (void *)regs->ra, frame);
  222. #endif
  223. return 0;
  224. }
  225. #ifdef CONFIG_COMPAT
  226. extern int compat_setup_rt_frame(struct ksignal *ksig, sigset_t *set,
  227. struct pt_regs *regs);
  228. #endif
  229. static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
  230. {
  231. sigset_t *oldset = sigmask_to_save();
  232. int ret;
  233. /* Are we from a system call? */
  234. if (regs->cause == EXC_SYSCALL) {
  235. /* Avoid additional syscall restarting via ret_from_exception */
  236. regs->cause = -1UL;
  237. /* If so, check system call restarting.. */
  238. switch (regs->a0) {
  239. case -ERESTART_RESTARTBLOCK:
  240. case -ERESTARTNOHAND:
  241. regs->a0 = -EINTR;
  242. break;
  243. case -ERESTARTSYS:
  244. if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
  245. regs->a0 = -EINTR;
  246. break;
  247. }
  248. fallthrough;
  249. case -ERESTARTNOINTR:
  250. regs->a0 = regs->orig_a0;
  251. regs->epc -= 0x4;
  252. break;
  253. }
  254. }
  255. #ifdef CONFIG_COMPAT
  256. /* Set up the stack frame */
  257. if (is_compat_task())
  258. ret = compat_setup_rt_frame(ksig, oldset, regs);
  259. else
  260. #endif
  261. ret = setup_rt_frame(ksig, oldset, regs);
  262. signal_setup_done(ret, ksig, 0);
  263. }
  264. static void do_signal(struct pt_regs *regs)
  265. {
  266. struct ksignal ksig;
  267. if (get_signal(&ksig)) {
  268. /* Actually deliver the signal */
  269. handle_signal(&ksig, regs);
  270. return;
  271. }
  272. /* Did we come from a system call? */
  273. if (regs->cause == EXC_SYSCALL) {
  274. /* Avoid additional syscall restarting via ret_from_exception */
  275. regs->cause = -1UL;
  276. /* Restart the system call - no handlers present */
  277. switch (regs->a0) {
  278. case -ERESTARTNOHAND:
  279. case -ERESTARTSYS:
  280. case -ERESTARTNOINTR:
  281. regs->a0 = regs->orig_a0;
  282. regs->epc -= 0x4;
  283. break;
  284. case -ERESTART_RESTARTBLOCK:
  285. regs->a0 = regs->orig_a0;
  286. regs->a7 = __NR_restart_syscall;
  287. regs->epc -= 0x4;
  288. break;
  289. }
  290. }
  291. /*
  292. * If there is no signal to deliver, we just put the saved
  293. * sigmask back.
  294. */
  295. restore_saved_sigmask();
  296. }
  297. /*
  298. * notification of userspace execution resumption
  299. * - triggered by the _TIF_WORK_MASK flags
  300. */
  301. asmlinkage __visible void do_notify_resume(struct pt_regs *regs,
  302. unsigned long thread_info_flags)
  303. {
  304. if (thread_info_flags & _TIF_UPROBE)
  305. uprobe_notify_resume(regs);
  306. /* Handle pending signal delivery */
  307. if (thread_info_flags & _TIF_SIGPENDING)
  308. do_signal(regs);
  309. if (thread_info_flags & _TIF_NOTIFY_RESUME)
  310. tracehook_notify_resume(regs);
  311. }