signal.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Based on arch/arm/kernel/signal.c
  4. *
  5. * Copyright (C) 1995-2009 Russell King
  6. * Copyright (C) 2012 ARM Ltd.
  7. */
  8. #include <linux/cache.h>
  9. #include <linux/compat.h>
  10. #include <linux/errno.h>
  11. #include <linux/kernel.h>
  12. #include <linux/signal.h>
  13. #include <linux/personality.h>
  14. #include <linux/freezer.h>
  15. #include <linux/stddef.h>
  16. #include <linux/uaccess.h>
  17. #include <linux/sizes.h>
  18. #include <linux/string.h>
  19. #include <linux/tracehook.h>
  20. #include <linux/ratelimit.h>
  21. #include <linux/syscalls.h>
  22. #include <asm/daifflags.h>
  23. #include <asm/debug-monitors.h>
  24. #include <asm/elf.h>
  25. #include <asm/cacheflush.h>
  26. #include <asm/ucontext.h>
  27. #include <asm/unistd.h>
  28. #include <asm/fpsimd.h>
  29. #include <asm/ptrace.h>
  30. #include <asm/syscall.h>
  31. #include <asm/signal32.h>
  32. #include <asm/traps.h>
  33. #include <asm/vdso.h>
  34. /*
  35. * Do a signal return; undo the signal stack. These are aligned to 128-bit.
  36. */
  37. struct rt_sigframe {
  38. struct siginfo info;
  39. struct ucontext uc;
  40. };
  41. struct frame_record {
  42. u64 fp;
  43. u64 lr;
  44. };
  45. struct rt_sigframe_user_layout {
  46. struct rt_sigframe __user *sigframe;
  47. struct frame_record __user *next_frame;
  48. unsigned long size; /* size of allocated sigframe data */
  49. unsigned long limit; /* largest allowed size */
  50. unsigned long fpsimd_offset;
  51. unsigned long esr_offset;
  52. unsigned long sve_offset;
  53. unsigned long extra_offset;
  54. unsigned long end_offset;
  55. };
  56. #define BASE_SIGFRAME_SIZE round_up(sizeof(struct rt_sigframe), 16)
  57. #define TERMINATOR_SIZE round_up(sizeof(struct _aarch64_ctx), 16)
  58. #define EXTRA_CONTEXT_SIZE round_up(sizeof(struct extra_context), 16)
  59. static void init_user_layout(struct rt_sigframe_user_layout *user)
  60. {
  61. const size_t reserved_size =
  62. sizeof(user->sigframe->uc.uc_mcontext.__reserved);
  63. memset(user, 0, sizeof(*user));
  64. user->size = offsetof(struct rt_sigframe, uc.uc_mcontext.__reserved);
  65. user->limit = user->size + reserved_size;
  66. user->limit -= TERMINATOR_SIZE;
  67. user->limit -= EXTRA_CONTEXT_SIZE;
  68. /* Reserve space for extension and terminator ^ */
  69. }
  70. static size_t sigframe_size(struct rt_sigframe_user_layout const *user)
  71. {
  72. return round_up(max(user->size, sizeof(struct rt_sigframe)), 16);
  73. }
  74. /*
  75. * Sanity limit on the approximate maximum size of signal frame we'll
  76. * try to generate. Stack alignment padding and the frame record are
  77. * not taken into account. This limit is not a guarantee and is
  78. * NOT ABI.
  79. */
  80. #define SIGFRAME_MAXSZ SZ_64K
  81. static int __sigframe_alloc(struct rt_sigframe_user_layout *user,
  82. unsigned long *offset, size_t size, bool extend)
  83. {
  84. size_t padded_size = round_up(size, 16);
  85. if (padded_size > user->limit - user->size &&
  86. !user->extra_offset &&
  87. extend) {
  88. int ret;
  89. user->limit += EXTRA_CONTEXT_SIZE;
  90. ret = __sigframe_alloc(user, &user->extra_offset,
  91. sizeof(struct extra_context), false);
  92. if (ret) {
  93. user->limit -= EXTRA_CONTEXT_SIZE;
  94. return ret;
  95. }
  96. /* Reserve space for the __reserved[] terminator */
  97. user->size += TERMINATOR_SIZE;
  98. /*
  99. * Allow expansion up to SIGFRAME_MAXSZ, ensuring space for
  100. * the terminator:
  101. */
  102. user->limit = SIGFRAME_MAXSZ - TERMINATOR_SIZE;
  103. }
  104. /* Still not enough space? Bad luck! */
  105. if (padded_size > user->limit - user->size)
  106. return -ENOMEM;
  107. *offset = user->size;
  108. user->size += padded_size;
  109. return 0;
  110. }
  111. /*
  112. * Allocate space for an optional record of <size> bytes in the user
  113. * signal frame. The offset from the signal frame base address to the
  114. * allocated block is assigned to *offset.
  115. */
  116. static int sigframe_alloc(struct rt_sigframe_user_layout *user,
  117. unsigned long *offset, size_t size)
  118. {
  119. return __sigframe_alloc(user, offset, size, true);
  120. }
  121. /* Allocate the null terminator record and prevent further allocations */
  122. static int sigframe_alloc_end(struct rt_sigframe_user_layout *user)
  123. {
  124. int ret;
  125. /* Un-reserve the space reserved for the terminator: */
  126. user->limit += TERMINATOR_SIZE;
  127. ret = sigframe_alloc(user, &user->end_offset,
  128. sizeof(struct _aarch64_ctx));
  129. if (ret)
  130. return ret;
  131. /* Prevent further allocation: */
  132. user->limit = user->size;
  133. return 0;
  134. }
  135. static void __user *apply_user_offset(
  136. struct rt_sigframe_user_layout const *user, unsigned long offset)
  137. {
  138. char __user *base = (char __user *)user->sigframe;
  139. return base + offset;
  140. }
  141. static int preserve_fpsimd_context(struct fpsimd_context __user *ctx)
  142. {
  143. struct user_fpsimd_state const *fpsimd =
  144. &current->thread.uw.fpsimd_state;
  145. int err;
  146. /* copy the FP and status/control registers */
  147. err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs));
  148. __put_user_error(fpsimd->fpsr, &ctx->fpsr, err);
  149. __put_user_error(fpsimd->fpcr, &ctx->fpcr, err);
  150. /* copy the magic/size information */
  151. __put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err);
  152. __put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err);
  153. return err ? -EFAULT : 0;
  154. }
  155. static int restore_fpsimd_context(struct fpsimd_context __user *ctx)
  156. {
  157. struct user_fpsimd_state fpsimd;
  158. __u32 magic, size;
  159. int err = 0;
  160. /* check the magic/size information */
  161. __get_user_error(magic, &ctx->head.magic, err);
  162. __get_user_error(size, &ctx->head.size, err);
  163. if (err)
  164. return -EFAULT;
  165. if (magic != FPSIMD_MAGIC || size != sizeof(struct fpsimd_context))
  166. return -EINVAL;
  167. /* copy the FP and status/control registers */
  168. err = __copy_from_user(fpsimd.vregs, ctx->vregs,
  169. sizeof(fpsimd.vregs));
  170. __get_user_error(fpsimd.fpsr, &ctx->fpsr, err);
  171. __get_user_error(fpsimd.fpcr, &ctx->fpcr, err);
  172. clear_thread_flag(TIF_SVE);
  173. /* load the hardware registers from the fpsimd_state structure */
  174. if (!err)
  175. fpsimd_update_current_state(&fpsimd);
  176. return err ? -EFAULT : 0;
  177. }
  178. struct user_ctxs {
  179. struct fpsimd_context __user *fpsimd;
  180. struct sve_context __user *sve;
  181. };
  182. #ifdef CONFIG_ARM64_SVE
  183. static int preserve_sve_context(struct sve_context __user *ctx)
  184. {
  185. int err = 0;
  186. u16 reserved[ARRAY_SIZE(ctx->__reserved)];
  187. unsigned int vl = current->thread.sve_vl;
  188. unsigned int vq = 0;
  189. if (test_thread_flag(TIF_SVE))
  190. vq = sve_vq_from_vl(vl);
  191. memset(reserved, 0, sizeof(reserved));
  192. __put_user_error(SVE_MAGIC, &ctx->head.magic, err);
  193. __put_user_error(round_up(SVE_SIG_CONTEXT_SIZE(vq), 16),
  194. &ctx->head.size, err);
  195. __put_user_error(vl, &ctx->vl, err);
  196. BUILD_BUG_ON(sizeof(ctx->__reserved) != sizeof(reserved));
  197. err |= __copy_to_user(&ctx->__reserved, reserved, sizeof(reserved));
  198. if (vq) {
  199. /*
  200. * This assumes that the SVE state has already been saved to
  201. * the task struct by calling the function
  202. * fpsimd_signal_preserve_current_state().
  203. */
  204. err |= __copy_to_user((char __user *)ctx + SVE_SIG_REGS_OFFSET,
  205. current->thread.sve_state,
  206. SVE_SIG_REGS_SIZE(vq));
  207. }
  208. return err ? -EFAULT : 0;
  209. }
  210. static int restore_sve_fpsimd_context(struct user_ctxs *user)
  211. {
  212. int err;
  213. unsigned int vq;
  214. struct user_fpsimd_state fpsimd;
  215. struct sve_context sve;
  216. if (__copy_from_user(&sve, user->sve, sizeof(sve)))
  217. return -EFAULT;
  218. if (sve.vl != current->thread.sve_vl)
  219. return -EINVAL;
  220. if (sve.head.size <= sizeof(*user->sve)) {
  221. clear_thread_flag(TIF_SVE);
  222. goto fpsimd_only;
  223. }
  224. vq = sve_vq_from_vl(sve.vl);
  225. if (sve.head.size < SVE_SIG_CONTEXT_SIZE(vq))
  226. return -EINVAL;
  227. /*
  228. * Careful: we are about __copy_from_user() directly into
  229. * thread.sve_state with preemption enabled, so protection is
  230. * needed to prevent a racing context switch from writing stale
  231. * registers back over the new data.
  232. */
  233. fpsimd_flush_task_state(current);
  234. /* From now, fpsimd_thread_switch() won't touch thread.sve_state */
  235. sve_alloc(current);
  236. err = __copy_from_user(current->thread.sve_state,
  237. (char __user const *)user->sve +
  238. SVE_SIG_REGS_OFFSET,
  239. SVE_SIG_REGS_SIZE(vq));
  240. if (err)
  241. return -EFAULT;
  242. set_thread_flag(TIF_SVE);
  243. fpsimd_only:
  244. /* copy the FP and status/control registers */
  245. /* restore_sigframe() already checked that user->fpsimd != NULL. */
  246. err = __copy_from_user(fpsimd.vregs, user->fpsimd->vregs,
  247. sizeof(fpsimd.vregs));
  248. __get_user_error(fpsimd.fpsr, &user->fpsimd->fpsr, err);
  249. __get_user_error(fpsimd.fpcr, &user->fpsimd->fpcr, err);
  250. /* load the hardware registers from the fpsimd_state structure */
  251. if (!err)
  252. fpsimd_update_current_state(&fpsimd);
  253. return err ? -EFAULT : 0;
  254. }
  255. #else /* ! CONFIG_ARM64_SVE */
  256. /* Turn any non-optimised out attempts to use these into a link error: */
  257. extern int preserve_sve_context(void __user *ctx);
  258. extern int restore_sve_fpsimd_context(struct user_ctxs *user);
  259. #endif /* ! CONFIG_ARM64_SVE */
  260. static int parse_user_sigframe(struct user_ctxs *user,
  261. struct rt_sigframe __user *sf)
  262. {
  263. struct sigcontext __user *const sc = &sf->uc.uc_mcontext;
  264. struct _aarch64_ctx __user *head;
  265. char __user *base = (char __user *)&sc->__reserved;
  266. size_t offset = 0;
  267. size_t limit = sizeof(sc->__reserved);
  268. bool have_extra_context = false;
  269. char const __user *const sfp = (char const __user *)sf;
  270. user->fpsimd = NULL;
  271. user->sve = NULL;
  272. if (!IS_ALIGNED((unsigned long)base, 16))
  273. goto invalid;
  274. while (1) {
  275. int err = 0;
  276. u32 magic, size;
  277. char const __user *userp;
  278. struct extra_context const __user *extra;
  279. u64 extra_datap;
  280. u32 extra_size;
  281. struct _aarch64_ctx const __user *end;
  282. u32 end_magic, end_size;
  283. if (limit - offset < sizeof(*head))
  284. goto invalid;
  285. if (!IS_ALIGNED(offset, 16))
  286. goto invalid;
  287. head = (struct _aarch64_ctx __user *)(base + offset);
  288. __get_user_error(magic, &head->magic, err);
  289. __get_user_error(size, &head->size, err);
  290. if (err)
  291. return err;
  292. if (limit - offset < size)
  293. goto invalid;
  294. switch (magic) {
  295. case 0:
  296. if (size)
  297. goto invalid;
  298. goto done;
  299. case FPSIMD_MAGIC:
  300. if (!system_supports_fpsimd())
  301. goto invalid;
  302. if (user->fpsimd)
  303. goto invalid;
  304. if (size < sizeof(*user->fpsimd))
  305. goto invalid;
  306. user->fpsimd = (struct fpsimd_context __user *)head;
  307. break;
  308. case ESR_MAGIC:
  309. /* ignore */
  310. break;
  311. case SVE_MAGIC:
  312. if (!system_supports_sve())
  313. goto invalid;
  314. if (user->sve)
  315. goto invalid;
  316. if (size < sizeof(*user->sve))
  317. goto invalid;
  318. user->sve = (struct sve_context __user *)head;
  319. break;
  320. case EXTRA_MAGIC:
  321. if (have_extra_context)
  322. goto invalid;
  323. if (size < sizeof(*extra))
  324. goto invalid;
  325. userp = (char const __user *)head;
  326. extra = (struct extra_context const __user *)userp;
  327. userp += size;
  328. __get_user_error(extra_datap, &extra->datap, err);
  329. __get_user_error(extra_size, &extra->size, err);
  330. if (err)
  331. return err;
  332. /* Check for the dummy terminator in __reserved[]: */
  333. if (limit - offset - size < TERMINATOR_SIZE)
  334. goto invalid;
  335. end = (struct _aarch64_ctx const __user *)userp;
  336. userp += TERMINATOR_SIZE;
  337. __get_user_error(end_magic, &end->magic, err);
  338. __get_user_error(end_size, &end->size, err);
  339. if (err)
  340. return err;
  341. if (end_magic || end_size)
  342. goto invalid;
  343. /* Prevent looping/repeated parsing of extra_context */
  344. have_extra_context = true;
  345. base = (__force void __user *)extra_datap;
  346. if (!IS_ALIGNED((unsigned long)base, 16))
  347. goto invalid;
  348. if (!IS_ALIGNED(extra_size, 16))
  349. goto invalid;
  350. if (base != userp)
  351. goto invalid;
  352. /* Reject "unreasonably large" frames: */
  353. if (extra_size > sfp + SIGFRAME_MAXSZ - userp)
  354. goto invalid;
  355. /*
  356. * Ignore trailing terminator in __reserved[]
  357. * and start parsing extra data:
  358. */
  359. offset = 0;
  360. limit = extra_size;
  361. if (!access_ok(base, limit))
  362. goto invalid;
  363. continue;
  364. default:
  365. goto invalid;
  366. }
  367. if (size < sizeof(*head))
  368. goto invalid;
  369. if (limit - offset < size)
  370. goto invalid;
  371. offset += size;
  372. }
  373. done:
  374. return 0;
  375. invalid:
  376. return -EINVAL;
  377. }
  378. static int restore_sigframe(struct pt_regs *regs,
  379. struct rt_sigframe __user *sf)
  380. {
  381. sigset_t set;
  382. int i, err;
  383. struct user_ctxs user;
  384. err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
  385. if (err == 0)
  386. set_current_blocked(&set);
  387. for (i = 0; i < 31; i++)
  388. __get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
  389. err);
  390. __get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
  391. __get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
  392. __get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
  393. /*
  394. * Avoid sys_rt_sigreturn() restarting.
  395. */
  396. forget_syscall(regs);
  397. err |= !valid_user_regs(&regs->user_regs, current);
  398. if (err == 0)
  399. err = parse_user_sigframe(&user, sf);
  400. if (err == 0 && system_supports_fpsimd()) {
  401. if (!user.fpsimd)
  402. return -EINVAL;
  403. if (user.sve) {
  404. if (!system_supports_sve())
  405. return -EINVAL;
  406. err = restore_sve_fpsimd_context(&user);
  407. } else {
  408. err = restore_fpsimd_context(user.fpsimd);
  409. }
  410. }
  411. return err;
  412. }
  413. SYSCALL_DEFINE0(rt_sigreturn)
  414. {
  415. struct pt_regs *regs = current_pt_regs();
  416. struct rt_sigframe __user *frame;
  417. /* Always make any pending restarted system calls return -EINTR */
  418. current->restart_block.fn = do_no_restart_syscall;
  419. /*
  420. * Since we stacked the signal on a 128-bit boundary, then 'sp' should
  421. * be word aligned here.
  422. */
  423. if (regs->sp & 15)
  424. goto badframe;
  425. frame = (struct rt_sigframe __user *)regs->sp;
  426. if (!access_ok(frame, sizeof (*frame)))
  427. goto badframe;
  428. if (restore_sigframe(regs, frame))
  429. goto badframe;
  430. if (restore_altstack(&frame->uc.uc_stack))
  431. goto badframe;
  432. return regs->regs[0];
  433. badframe:
  434. arm64_notify_segfault(regs->sp);
  435. return 0;
  436. }
  437. /*
  438. * Determine the layout of optional records in the signal frame
  439. *
  440. * add_all: if true, lays out the biggest possible signal frame for
  441. * this task; otherwise, generates a layout for the current state
  442. * of the task.
  443. */
  444. static int setup_sigframe_layout(struct rt_sigframe_user_layout *user,
  445. bool add_all)
  446. {
  447. int err;
  448. if (system_supports_fpsimd()) {
  449. err = sigframe_alloc(user, &user->fpsimd_offset,
  450. sizeof(struct fpsimd_context));
  451. if (err)
  452. return err;
  453. }
  454. /* fault information, if valid */
  455. if (add_all || current->thread.fault_code) {
  456. err = sigframe_alloc(user, &user->esr_offset,
  457. sizeof(struct esr_context));
  458. if (err)
  459. return err;
  460. }
  461. if (system_supports_sve()) {
  462. unsigned int vq = 0;
  463. if (add_all || test_thread_flag(TIF_SVE)) {
  464. int vl = sve_max_vl;
  465. if (!add_all)
  466. vl = current->thread.sve_vl;
  467. vq = sve_vq_from_vl(vl);
  468. }
  469. err = sigframe_alloc(user, &user->sve_offset,
  470. SVE_SIG_CONTEXT_SIZE(vq));
  471. if (err)
  472. return err;
  473. }
  474. return sigframe_alloc_end(user);
  475. }
  476. static int setup_sigframe(struct rt_sigframe_user_layout *user,
  477. struct pt_regs *regs, sigset_t *set)
  478. {
  479. int i, err = 0;
  480. struct rt_sigframe __user *sf = user->sigframe;
  481. /* set up the stack frame for unwinding */
  482. __put_user_error(regs->regs[29], &user->next_frame->fp, err);
  483. __put_user_error(regs->regs[30], &user->next_frame->lr, err);
  484. for (i = 0; i < 31; i++)
  485. __put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
  486. err);
  487. __put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
  488. __put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
  489. __put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
  490. __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
  491. err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
  492. if (err == 0 && system_supports_fpsimd()) {
  493. struct fpsimd_context __user *fpsimd_ctx =
  494. apply_user_offset(user, user->fpsimd_offset);
  495. err |= preserve_fpsimd_context(fpsimd_ctx);
  496. }
  497. /* fault information, if valid */
  498. if (err == 0 && user->esr_offset) {
  499. struct esr_context __user *esr_ctx =
  500. apply_user_offset(user, user->esr_offset);
  501. __put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err);
  502. __put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err);
  503. __put_user_error(current->thread.fault_code, &esr_ctx->esr, err);
  504. }
  505. /* Scalable Vector Extension state, if present */
  506. if (system_supports_sve() && err == 0 && user->sve_offset) {
  507. struct sve_context __user *sve_ctx =
  508. apply_user_offset(user, user->sve_offset);
  509. err |= preserve_sve_context(sve_ctx);
  510. }
  511. if (err == 0 && user->extra_offset) {
  512. char __user *sfp = (char __user *)user->sigframe;
  513. char __user *userp =
  514. apply_user_offset(user, user->extra_offset);
  515. struct extra_context __user *extra;
  516. struct _aarch64_ctx __user *end;
  517. u64 extra_datap;
  518. u32 extra_size;
  519. extra = (struct extra_context __user *)userp;
  520. userp += EXTRA_CONTEXT_SIZE;
  521. end = (struct _aarch64_ctx __user *)userp;
  522. userp += TERMINATOR_SIZE;
  523. /*
  524. * extra_datap is just written to the signal frame.
  525. * The value gets cast back to a void __user *
  526. * during sigreturn.
  527. */
  528. extra_datap = (__force u64)userp;
  529. extra_size = sfp + round_up(user->size, 16) - userp;
  530. __put_user_error(EXTRA_MAGIC, &extra->head.magic, err);
  531. __put_user_error(EXTRA_CONTEXT_SIZE, &extra->head.size, err);
  532. __put_user_error(extra_datap, &extra->datap, err);
  533. __put_user_error(extra_size, &extra->size, err);
  534. /* Add the terminator */
  535. __put_user_error(0, &end->magic, err);
  536. __put_user_error(0, &end->size, err);
  537. }
  538. /* set the "end" magic */
  539. if (err == 0) {
  540. struct _aarch64_ctx __user *end =
  541. apply_user_offset(user, user->end_offset);
  542. __put_user_error(0, &end->magic, err);
  543. __put_user_error(0, &end->size, err);
  544. }
  545. return err;
  546. }
  547. static int get_sigframe(struct rt_sigframe_user_layout *user,
  548. struct ksignal *ksig, struct pt_regs *regs)
  549. {
  550. unsigned long sp, sp_top;
  551. int err;
  552. init_user_layout(user);
  553. err = setup_sigframe_layout(user, false);
  554. if (err)
  555. return err;
  556. sp = sp_top = sigsp(regs->sp, ksig);
  557. sp = round_down(sp - sizeof(struct frame_record), 16);
  558. user->next_frame = (struct frame_record __user *)sp;
  559. sp = round_down(sp, 16) - sigframe_size(user);
  560. user->sigframe = (struct rt_sigframe __user *)sp;
  561. /*
  562. * Check that we can actually write to the signal frame.
  563. */
  564. if (!access_ok(user->sigframe, sp_top - sp))
  565. return -EFAULT;
  566. return 0;
  567. }
  568. static void setup_return(struct pt_regs *regs, struct k_sigaction *ka,
  569. struct rt_sigframe_user_layout *user, int usig)
  570. {
  571. __sigrestore_t sigtramp;
  572. regs->regs[0] = usig;
  573. regs->sp = (unsigned long)user->sigframe;
  574. regs->regs[29] = (unsigned long)&user->next_frame->fp;
  575. regs->pc = (unsigned long)ka->sa.sa_handler;
  576. /*
  577. * Signal delivery is a (wacky) indirect function call in
  578. * userspace, so simulate the same setting of BTYPE as a BLR
  579. * <register containing the signal handler entry point>.
  580. * Signal delivery to a location in a PROT_BTI guarded page
  581. * that is not a function entry point will now trigger a
  582. * SIGILL in userspace.
  583. *
  584. * If the signal handler entry point is not in a PROT_BTI
  585. * guarded page, this is harmless.
  586. */
  587. if (system_supports_bti()) {
  588. regs->pstate &= ~PSR_BTYPE_MASK;
  589. regs->pstate |= PSR_BTYPE_C;
  590. }
  591. /* TCO (Tag Check Override) always cleared for signal handlers */
  592. regs->pstate &= ~PSR_TCO_BIT;
  593. if (ka->sa.sa_flags & SA_RESTORER)
  594. sigtramp = ka->sa.sa_restorer;
  595. else
  596. sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp);
  597. regs->regs[30] = (unsigned long)sigtramp;
  598. }
  599. static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
  600. struct pt_regs *regs)
  601. {
  602. struct rt_sigframe_user_layout user;
  603. struct rt_sigframe __user *frame;
  604. int err = 0;
  605. fpsimd_signal_preserve_current_state();
  606. if (get_sigframe(&user, ksig, regs))
  607. return 1;
  608. frame = user.sigframe;
  609. __put_user_error(0, &frame->uc.uc_flags, err);
  610. __put_user_error(NULL, &frame->uc.uc_link, err);
  611. err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
  612. err |= setup_sigframe(&user, regs, set);
  613. if (err == 0) {
  614. setup_return(regs, &ksig->ka, &user, usig);
  615. if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
  616. err |= copy_siginfo_to_user(&frame->info, &ksig->info);
  617. regs->regs[1] = (unsigned long)&frame->info;
  618. regs->regs[2] = (unsigned long)&frame->uc;
  619. }
  620. }
  621. return err;
  622. }
  623. static void setup_restart_syscall(struct pt_regs *regs)
  624. {
  625. if (is_compat_task())
  626. compat_setup_restart_syscall(regs);
  627. else
  628. regs->regs[8] = __NR_restart_syscall;
  629. }
  630. /*
  631. * OK, we're invoking a handler
  632. */
  633. static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
  634. {
  635. sigset_t *oldset = sigmask_to_save();
  636. int usig = ksig->sig;
  637. int ret;
  638. rseq_signal_deliver(ksig, regs);
  639. /*
  640. * Set up the stack frame
  641. */
  642. if (is_compat_task()) {
  643. if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  644. ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
  645. else
  646. ret = compat_setup_frame(usig, ksig, oldset, regs);
  647. } else {
  648. ret = setup_rt_frame(usig, ksig, oldset, regs);
  649. }
  650. /*
  651. * Check that the resulting registers are actually sane.
  652. */
  653. ret |= !valid_user_regs(&regs->user_regs, current);
  654. /* Step into the signal handler if we are stepping */
  655. signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
  656. }
  657. /*
  658. * Note that 'init' is a special process: it doesn't get signals it doesn't
  659. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  660. * mistake.
  661. *
  662. * Note that we go through the signals twice: once to check the signals that
  663. * the kernel can handle, and then we build all the user-level signal handling
  664. * stack-frames in one go after that.
  665. */
  666. static void do_signal(struct pt_regs *regs)
  667. {
  668. unsigned long continue_addr = 0, restart_addr = 0;
  669. int retval = 0;
  670. struct ksignal ksig;
  671. bool syscall = in_syscall(regs);
  672. /*
  673. * If we were from a system call, check for system call restarting...
  674. */
  675. if (syscall) {
  676. continue_addr = regs->pc;
  677. restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4);
  678. retval = regs->regs[0];
  679. /*
  680. * Avoid additional syscall restarting via ret_to_user.
  681. */
  682. forget_syscall(regs);
  683. /*
  684. * Prepare for system call restart. We do this here so that a
  685. * debugger will see the already changed PC.
  686. */
  687. switch (retval) {
  688. case -ERESTARTNOHAND:
  689. case -ERESTARTSYS:
  690. case -ERESTARTNOINTR:
  691. case -ERESTART_RESTARTBLOCK:
  692. regs->regs[0] = regs->orig_x0;
  693. regs->pc = restart_addr;
  694. break;
  695. }
  696. }
  697. /*
  698. * Get the signal to deliver. When running under ptrace, at this point
  699. * the debugger may change all of our registers.
  700. */
  701. if (get_signal(&ksig)) {
  702. /*
  703. * Depending on the signal settings, we may need to revert the
  704. * decision to restart the system call, but skip this if a
  705. * debugger has chosen to restart at a different PC.
  706. */
  707. if (regs->pc == restart_addr &&
  708. (retval == -ERESTARTNOHAND ||
  709. retval == -ERESTART_RESTARTBLOCK ||
  710. (retval == -ERESTARTSYS &&
  711. !(ksig.ka.sa.sa_flags & SA_RESTART)))) {
  712. syscall_set_return_value(current, regs, -EINTR, 0);
  713. regs->pc = continue_addr;
  714. }
  715. handle_signal(&ksig, regs);
  716. return;
  717. }
  718. /*
  719. * Handle restarting a different system call. As above, if a debugger
  720. * has chosen to restart at a different PC, ignore the restart.
  721. */
  722. if (syscall && regs->pc == restart_addr) {
  723. if (retval == -ERESTART_RESTARTBLOCK)
  724. setup_restart_syscall(regs);
  725. user_rewind_single_step(current);
  726. }
  727. restore_saved_sigmask();
  728. }
  729. asmlinkage void do_notify_resume(struct pt_regs *regs,
  730. unsigned long thread_flags)
  731. {
  732. do {
  733. /* Check valid user FS if needed */
  734. addr_limit_user_check();
  735. if (thread_flags & _TIF_NEED_RESCHED) {
  736. /* Unmask Debug and SError for the next task */
  737. local_daif_restore(DAIF_PROCCTX_NOIRQ);
  738. schedule();
  739. } else {
  740. local_daif_restore(DAIF_PROCCTX);
  741. if (thread_flags & _TIF_UPROBE)
  742. uprobe_notify_resume(regs);
  743. if (thread_flags & _TIF_MTE_ASYNC_FAULT) {
  744. clear_thread_flag(TIF_MTE_ASYNC_FAULT);
  745. send_sig_fault(SIGSEGV, SEGV_MTEAERR,
  746. (void __user *)NULL, current);
  747. }
  748. if (thread_flags & _TIF_SIGPENDING)
  749. do_signal(regs);
  750. if (thread_flags & _TIF_NOTIFY_RESUME) {
  751. tracehook_notify_resume(regs);
  752. rseq_handle_notify_resume(NULL, regs);
  753. }
  754. if (thread_flags & _TIF_FOREIGN_FPSTATE)
  755. fpsimd_restore_current_state();
  756. }
  757. local_daif_mask();
  758. thread_flags = READ_ONCE(current_thread_info()->flags);
  759. } while (thread_flags & _TIF_WORK_MASK);
  760. }
  761. unsigned long __ro_after_init signal_minsigstksz;
  762. /*
  763. * Determine the stack space required for guaranteed signal devliery.
  764. * This function is used to populate AT_MINSIGSTKSZ at process startup.
  765. * cpufeatures setup is assumed to be complete.
  766. */
  767. void __init minsigstksz_setup(void)
  768. {
  769. struct rt_sigframe_user_layout user;
  770. init_user_layout(&user);
  771. /*
  772. * If this fails, SIGFRAME_MAXSZ needs to be enlarged. It won't
  773. * be big enough, but it's our best guess:
  774. */
  775. if (WARN_ON(setup_sigframe_layout(&user, true)))
  776. return;
  777. signal_minsigstksz = sigframe_size(&user) +
  778. round_up(sizeof(struct frame_record), 16) +
  779. 16; /* max alignment padding */
  780. }