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
9 #include <linux/cache.h>
10 #include <linux/compat.h>
11 #include <linux/errno.h>
12 #include <linux/kernel.h>
13 #include <linux/signal.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/ratelimit.h>
20 #include <linux/rseq.h>
21 #include <linux/syscalls.h>
22 #include <linux/pkeys.h>
23
24 #include <asm/daifflags.h>
25 #include <asm/debug-monitors.h>
26 #include <asm/elf.h>
27 #include <asm/exception.h>
28 #include <asm/cacheflush.h>
29 #include <asm/ucontext.h>
30 #include <asm/unistd.h>
31 #include <asm/fpsimd.h>
32 #include <asm/ptrace.h>
33 #include <asm/syscall.h>
34 #include <asm/signal32.h>
35 #include <asm/traps.h>
36 #include <asm/vdso.h>
37
38 /*
39 * Do a signal return; undo the signal stack. These are aligned to 128-bit.
40 */
41 struct rt_sigframe {
42 struct siginfo info;
43 struct ucontext uc;
44 };
45
46 struct frame_record {
47 u64 fp;
48 u64 lr;
49 };
50
51 struct rt_sigframe_user_layout {
52 struct rt_sigframe __user *sigframe;
53 struct frame_record __user *next_frame;
54
55 unsigned long size; /* size of allocated sigframe data */
56 unsigned long limit; /* largest allowed size */
57
58 unsigned long fpsimd_offset;
59 unsigned long esr_offset;
60 unsigned long sve_offset;
61 unsigned long tpidr2_offset;
62 unsigned long za_offset;
63 unsigned long zt_offset;
64 unsigned long fpmr_offset;
65 unsigned long poe_offset;
66 unsigned long extra_offset;
67 unsigned long end_offset;
68 };
69
70 /*
71 * Holds any EL0-controlled state that influences unprivileged memory accesses.
72 * This includes both accesses done in userspace and uaccess done in the kernel.
73 *
74 * This state needs to be carefully managed to ensure that it doesn't cause
75 * uaccess to fail when setting up the signal frame, and the signal handler
76 * itself also expects a well-defined state when entered.
77 */
78 struct user_access_state {
79 u64 por_el0;
80 };
81
82 #define BASE_SIGFRAME_SIZE round_up(sizeof(struct rt_sigframe), 16)
83 #define TERMINATOR_SIZE round_up(sizeof(struct _aarch64_ctx), 16)
84 #define EXTRA_CONTEXT_SIZE round_up(sizeof(struct extra_context), 16)
85
86 /*
87 * Save the user access state into ua_state and reset it to disable any
88 * restrictions.
89 */
save_reset_user_access_state(struct user_access_state * ua_state)90 static void save_reset_user_access_state(struct user_access_state *ua_state)
91 {
92 if (system_supports_poe()) {
93 u64 por_enable_all = 0;
94
95 for (int pkey = 0; pkey < arch_max_pkey(); pkey++)
96 por_enable_all |= POE_RXW << (pkey * POR_BITS_PER_PKEY);
97
98 ua_state->por_el0 = read_sysreg_s(SYS_POR_EL0);
99 write_sysreg_s(por_enable_all, SYS_POR_EL0);
100 /* Ensure that any subsequent uaccess observes the updated value */
101 isb();
102 }
103 }
104
105 /*
106 * Set the user access state for invoking the signal handler.
107 *
108 * No uaccess should be done after that function is called.
109 */
set_handler_user_access_state(void)110 static void set_handler_user_access_state(void)
111 {
112 if (system_supports_poe())
113 write_sysreg_s(POR_EL0_INIT, SYS_POR_EL0);
114 }
115
116 /*
117 * Restore the user access state to the values saved in ua_state.
118 *
119 * No uaccess should be done after that function is called.
120 */
restore_user_access_state(const struct user_access_state * ua_state)121 static void restore_user_access_state(const struct user_access_state *ua_state)
122 {
123 if (system_supports_poe())
124 write_sysreg_s(ua_state->por_el0, SYS_POR_EL0);
125 }
126
init_user_layout(struct rt_sigframe_user_layout * user)127 static void init_user_layout(struct rt_sigframe_user_layout *user)
128 {
129 const size_t reserved_size =
130 sizeof(user->sigframe->uc.uc_mcontext.__reserved);
131
132 memset(user, 0, sizeof(*user));
133 user->size = offsetof(struct rt_sigframe, uc.uc_mcontext.__reserved);
134
135 user->limit = user->size + reserved_size;
136
137 user->limit -= TERMINATOR_SIZE;
138 user->limit -= EXTRA_CONTEXT_SIZE;
139 /* Reserve space for extension and terminator ^ */
140 }
141
sigframe_size(struct rt_sigframe_user_layout const * user)142 static size_t sigframe_size(struct rt_sigframe_user_layout const *user)
143 {
144 return round_up(max(user->size, sizeof(struct rt_sigframe)), 16);
145 }
146
147 /*
148 * Sanity limit on the approximate maximum size of signal frame we'll
149 * try to generate. Stack alignment padding and the frame record are
150 * not taken into account. This limit is not a guarantee and is
151 * NOT ABI.
152 */
153 #define SIGFRAME_MAXSZ SZ_256K
154
__sigframe_alloc(struct rt_sigframe_user_layout * user,unsigned long * offset,size_t size,bool extend)155 static int __sigframe_alloc(struct rt_sigframe_user_layout *user,
156 unsigned long *offset, size_t size, bool extend)
157 {
158 size_t padded_size = round_up(size, 16);
159
160 if (padded_size > user->limit - user->size &&
161 !user->extra_offset &&
162 extend) {
163 int ret;
164
165 user->limit += EXTRA_CONTEXT_SIZE;
166 ret = __sigframe_alloc(user, &user->extra_offset,
167 sizeof(struct extra_context), false);
168 if (ret) {
169 user->limit -= EXTRA_CONTEXT_SIZE;
170 return ret;
171 }
172
173 /* Reserve space for the __reserved[] terminator */
174 user->size += TERMINATOR_SIZE;
175
176 /*
177 * Allow expansion up to SIGFRAME_MAXSZ, ensuring space for
178 * the terminator:
179 */
180 user->limit = SIGFRAME_MAXSZ - TERMINATOR_SIZE;
181 }
182
183 /* Still not enough space? Bad luck! */
184 if (padded_size > user->limit - user->size)
185 return -ENOMEM;
186
187 *offset = user->size;
188 user->size += padded_size;
189
190 return 0;
191 }
192
193 /*
194 * Allocate space for an optional record of <size> bytes in the user
195 * signal frame. The offset from the signal frame base address to the
196 * allocated block is assigned to *offset.
197 */
sigframe_alloc(struct rt_sigframe_user_layout * user,unsigned long * offset,size_t size)198 static int sigframe_alloc(struct rt_sigframe_user_layout *user,
199 unsigned long *offset, size_t size)
200 {
201 return __sigframe_alloc(user, offset, size, true);
202 }
203
204 /* Allocate the null terminator record and prevent further allocations */
sigframe_alloc_end(struct rt_sigframe_user_layout * user)205 static int sigframe_alloc_end(struct rt_sigframe_user_layout *user)
206 {
207 int ret;
208
209 /* Un-reserve the space reserved for the terminator: */
210 user->limit += TERMINATOR_SIZE;
211
212 ret = sigframe_alloc(user, &user->end_offset,
213 sizeof(struct _aarch64_ctx));
214 if (ret)
215 return ret;
216
217 /* Prevent further allocation: */
218 user->limit = user->size;
219 return 0;
220 }
221
apply_user_offset(struct rt_sigframe_user_layout const * user,unsigned long offset)222 static void __user *apply_user_offset(
223 struct rt_sigframe_user_layout const *user, unsigned long offset)
224 {
225 char __user *base = (char __user *)user->sigframe;
226
227 return base + offset;
228 }
229
230 struct user_ctxs {
231 struct fpsimd_context __user *fpsimd;
232 u32 fpsimd_size;
233 struct sve_context __user *sve;
234 u32 sve_size;
235 struct tpidr2_context __user *tpidr2;
236 u32 tpidr2_size;
237 struct za_context __user *za;
238 u32 za_size;
239 struct zt_context __user *zt;
240 u32 zt_size;
241 struct fpmr_context __user *fpmr;
242 u32 fpmr_size;
243 struct poe_context __user *poe;
244 u32 poe_size;
245 };
246
preserve_fpsimd_context(struct fpsimd_context __user * ctx)247 static int preserve_fpsimd_context(struct fpsimd_context __user *ctx)
248 {
249 struct user_fpsimd_state const *fpsimd =
250 ¤t->thread.uw.fpsimd_state;
251 int err;
252
253 fpsimd_sync_from_effective_state(current);
254
255 /* copy the FP and status/control registers */
256 err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs));
257 __put_user_error(fpsimd->fpsr, &ctx->fpsr, err);
258 __put_user_error(fpsimd->fpcr, &ctx->fpcr, err);
259
260 /* copy the magic/size information */
261 __put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err);
262 __put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err);
263
264 return err ? -EFAULT : 0;
265 }
266
read_fpsimd_context(struct user_fpsimd_state * fpsimd,struct user_ctxs * user)267 static int read_fpsimd_context(struct user_fpsimd_state *fpsimd,
268 struct user_ctxs *user)
269 {
270 int err;
271
272 /* check the size information */
273 if (user->fpsimd_size != sizeof(struct fpsimd_context))
274 return -EINVAL;
275
276 /* copy the FP and status/control registers */
277 err = __copy_from_user(fpsimd->vregs, &(user->fpsimd->vregs),
278 sizeof(fpsimd->vregs));
279 __get_user_error(fpsimd->fpsr, &(user->fpsimd->fpsr), err);
280 __get_user_error(fpsimd->fpcr, &(user->fpsimd->fpcr), err);
281
282 return err ? -EFAULT : 0;
283 }
284
restore_fpsimd_context(struct user_ctxs * user)285 static int restore_fpsimd_context(struct user_ctxs *user)
286 {
287 struct user_fpsimd_state fpsimd;
288 int err;
289
290 err = read_fpsimd_context(&fpsimd, user);
291 if (err)
292 return err;
293
294 clear_thread_flag(TIF_SVE);
295 current->thread.svcr &= ~SVCR_SM_MASK;
296 current->thread.fp_type = FP_STATE_FPSIMD;
297
298 /* load the hardware registers from the fpsimd_state structure */
299 fpsimd_update_current_state(&fpsimd);
300 return 0;
301 }
302
preserve_fpmr_context(struct fpmr_context __user * ctx)303 static int preserve_fpmr_context(struct fpmr_context __user *ctx)
304 {
305 int err = 0;
306
307 __put_user_error(FPMR_MAGIC, &ctx->head.magic, err);
308 __put_user_error(sizeof(*ctx), &ctx->head.size, err);
309 __put_user_error(current->thread.uw.fpmr, &ctx->fpmr, err);
310
311 return err;
312 }
313
restore_fpmr_context(struct user_ctxs * user)314 static int restore_fpmr_context(struct user_ctxs *user)
315 {
316 u64 fpmr;
317 int err = 0;
318
319 if (user->fpmr_size != sizeof(*user->fpmr))
320 return -EINVAL;
321
322 __get_user_error(fpmr, &user->fpmr->fpmr, err);
323 if (!err)
324 current->thread.uw.fpmr = fpmr;
325
326 return err;
327 }
328
preserve_poe_context(struct poe_context __user * ctx,const struct user_access_state * ua_state)329 static int preserve_poe_context(struct poe_context __user *ctx,
330 const struct user_access_state *ua_state)
331 {
332 int err = 0;
333
334 __put_user_error(POE_MAGIC, &ctx->head.magic, err);
335 __put_user_error(sizeof(*ctx), &ctx->head.size, err);
336 __put_user_error(ua_state->por_el0, &ctx->por_el0, err);
337
338 return err;
339 }
340
restore_poe_context(struct user_ctxs * user,struct user_access_state * ua_state)341 static int restore_poe_context(struct user_ctxs *user,
342 struct user_access_state *ua_state)
343 {
344 u64 por_el0;
345 int err = 0;
346
347 if (user->poe_size != sizeof(*user->poe))
348 return -EINVAL;
349
350 __get_user_error(por_el0, &(user->poe->por_el0), err);
351 if (!err)
352 ua_state->por_el0 = por_el0;
353
354 return err;
355 }
356
357 #ifdef CONFIG_ARM64_SVE
358
preserve_sve_context(struct sve_context __user * ctx)359 static int preserve_sve_context(struct sve_context __user *ctx)
360 {
361 int err = 0;
362 u16 reserved[ARRAY_SIZE(ctx->__reserved)];
363 u16 flags = 0;
364 unsigned int vl = task_get_sve_vl(current);
365 unsigned int vq = 0;
366
367 if (thread_sm_enabled(¤t->thread)) {
368 vl = task_get_sme_vl(current);
369 vq = sve_vq_from_vl(vl);
370 flags |= SVE_SIG_FLAG_SM;
371 } else if (current->thread.fp_type == FP_STATE_SVE) {
372 vq = sve_vq_from_vl(vl);
373 }
374
375 memset(reserved, 0, sizeof(reserved));
376
377 __put_user_error(SVE_MAGIC, &ctx->head.magic, err);
378 __put_user_error(round_up(SVE_SIG_CONTEXT_SIZE(vq), 16),
379 &ctx->head.size, err);
380 __put_user_error(vl, &ctx->vl, err);
381 __put_user_error(flags, &ctx->flags, err);
382 BUILD_BUG_ON(sizeof(ctx->__reserved) != sizeof(reserved));
383 err |= __copy_to_user(&ctx->__reserved, reserved, sizeof(reserved));
384
385 if (vq) {
386 err |= __copy_to_user((char __user *)ctx + SVE_SIG_REGS_OFFSET,
387 current->thread.sve_state,
388 SVE_SIG_REGS_SIZE(vq));
389 }
390
391 return err ? -EFAULT : 0;
392 }
393
restore_sve_fpsimd_context(struct user_ctxs * user)394 static int restore_sve_fpsimd_context(struct user_ctxs *user)
395 {
396 int err = 0;
397 unsigned int vl, vq;
398 struct user_fpsimd_state fpsimd;
399 u16 user_vl, flags;
400 bool sm;
401
402 if (user->sve_size < sizeof(*user->sve))
403 return -EINVAL;
404
405 __get_user_error(user_vl, &(user->sve->vl), err);
406 __get_user_error(flags, &(user->sve->flags), err);
407 if (err)
408 return err;
409
410 sm = flags & SVE_SIG_FLAG_SM;
411 if (sm) {
412 if (!system_supports_sme())
413 return -EINVAL;
414
415 vl = task_get_sme_vl(current);
416 } else {
417 /*
418 * A SME only system use SVE for streaming mode so can
419 * have a SVE formatted context with a zero VL and no
420 * payload data.
421 */
422 if (!system_supports_sve() && !system_supports_sme())
423 return -EINVAL;
424
425 vl = task_get_sve_vl(current);
426 }
427
428 if (user_vl != vl)
429 return -EINVAL;
430
431 /*
432 * Non-streaming SVE state may be preserved without an SVE payload, in
433 * which case the SVE context only has a header with VL==0, and all
434 * state can be restored from the FPSIMD context.
435 *
436 * Streaming SVE state is always preserved with an SVE payload. For
437 * consistency and robustness, reject restoring streaming SVE state
438 * without an SVE payload.
439 */
440 if (!sm && user->sve_size == sizeof(*user->sve))
441 return restore_fpsimd_context(user);
442
443 vq = sve_vq_from_vl(vl);
444
445 if (user->sve_size < SVE_SIG_CONTEXT_SIZE(vq))
446 return -EINVAL;
447
448 sve_alloc(current, true);
449 if (!current->thread.sve_state) {
450 clear_thread_flag(TIF_SVE);
451 return -ENOMEM;
452 }
453
454 err = __copy_from_user(current->thread.sve_state,
455 (char __user const *)user->sve +
456 SVE_SIG_REGS_OFFSET,
457 SVE_SIG_REGS_SIZE(vq));
458 if (err)
459 return -EFAULT;
460
461 if (flags & SVE_SIG_FLAG_SM)
462 current->thread.svcr |= SVCR_SM_MASK;
463 else
464 set_thread_flag(TIF_SVE);
465 current->thread.fp_type = FP_STATE_SVE;
466
467 err = read_fpsimd_context(&fpsimd, user);
468 if (err)
469 return err;
470
471 /* Merge the FPSIMD registers into the SVE state */
472 fpsimd_update_current_state(&fpsimd);
473
474 return 0;
475 }
476
477 #else /* ! CONFIG_ARM64_SVE */
478
restore_sve_fpsimd_context(struct user_ctxs * user)479 static int restore_sve_fpsimd_context(struct user_ctxs *user)
480 {
481 WARN_ON_ONCE(1);
482 return -EINVAL;
483 }
484
485 /* Turn any non-optimised out attempts to use this into a link error: */
486 extern int preserve_sve_context(void __user *ctx);
487
488 #endif /* ! CONFIG_ARM64_SVE */
489
490 #ifdef CONFIG_ARM64_SME
491
preserve_tpidr2_context(struct tpidr2_context __user * ctx)492 static int preserve_tpidr2_context(struct tpidr2_context __user *ctx)
493 {
494 u64 tpidr2_el0 = read_sysreg_s(SYS_TPIDR2_EL0);
495 int err = 0;
496
497 __put_user_error(TPIDR2_MAGIC, &ctx->head.magic, err);
498 __put_user_error(sizeof(*ctx), &ctx->head.size, err);
499 __put_user_error(tpidr2_el0, &ctx->tpidr2, err);
500
501 return err;
502 }
503
restore_tpidr2_context(struct user_ctxs * user)504 static int restore_tpidr2_context(struct user_ctxs *user)
505 {
506 u64 tpidr2_el0;
507 int err = 0;
508
509 if (user->tpidr2_size != sizeof(*user->tpidr2))
510 return -EINVAL;
511
512 __get_user_error(tpidr2_el0, &user->tpidr2->tpidr2, err);
513 if (!err)
514 write_sysreg_s(tpidr2_el0, SYS_TPIDR2_EL0);
515
516 return err;
517 }
518
preserve_za_context(struct za_context __user * ctx)519 static int preserve_za_context(struct za_context __user *ctx)
520 {
521 int err = 0;
522 u16 reserved[ARRAY_SIZE(ctx->__reserved)];
523 unsigned int vl = task_get_sme_vl(current);
524 unsigned int vq;
525
526 if (thread_za_enabled(¤t->thread))
527 vq = sve_vq_from_vl(vl);
528 else
529 vq = 0;
530
531 memset(reserved, 0, sizeof(reserved));
532
533 __put_user_error(ZA_MAGIC, &ctx->head.magic, err);
534 __put_user_error(round_up(ZA_SIG_CONTEXT_SIZE(vq), 16),
535 &ctx->head.size, err);
536 __put_user_error(vl, &ctx->vl, err);
537 BUILD_BUG_ON(sizeof(ctx->__reserved) != sizeof(reserved));
538 err |= __copy_to_user(&ctx->__reserved, reserved, sizeof(reserved));
539
540 if (vq) {
541 err |= __copy_to_user((char __user *)ctx + ZA_SIG_REGS_OFFSET,
542 current->thread.sme_state,
543 ZA_SIG_REGS_SIZE(vq));
544 }
545
546 return err ? -EFAULT : 0;
547 }
548
restore_za_context(struct user_ctxs * user)549 static int restore_za_context(struct user_ctxs *user)
550 {
551 int err = 0;
552 unsigned int vq;
553 u16 user_vl;
554
555 if (user->za_size < sizeof(*user->za))
556 return -EINVAL;
557
558 __get_user_error(user_vl, &(user->za->vl), err);
559 if (err)
560 return err;
561
562 if (user_vl != task_get_sme_vl(current))
563 return -EINVAL;
564
565 if (user->za_size == sizeof(*user->za)) {
566 current->thread.svcr &= ~SVCR_ZA_MASK;
567 return 0;
568 }
569
570 vq = sve_vq_from_vl(user_vl);
571
572 if (user->za_size < ZA_SIG_CONTEXT_SIZE(vq))
573 return -EINVAL;
574
575 sme_alloc(current, true);
576 if (!current->thread.sme_state) {
577 current->thread.svcr &= ~SVCR_ZA_MASK;
578 clear_thread_flag(TIF_SME);
579 return -ENOMEM;
580 }
581
582 err = __copy_from_user(current->thread.sme_state,
583 (char __user const *)user->za +
584 ZA_SIG_REGS_OFFSET,
585 ZA_SIG_REGS_SIZE(vq));
586 if (err)
587 return -EFAULT;
588
589 set_thread_flag(TIF_SME);
590 current->thread.svcr |= SVCR_ZA_MASK;
591
592 return 0;
593 }
594
preserve_zt_context(struct zt_context __user * ctx)595 static int preserve_zt_context(struct zt_context __user *ctx)
596 {
597 int err = 0;
598 u16 reserved[ARRAY_SIZE(ctx->__reserved)];
599
600 if (WARN_ON(!thread_za_enabled(¤t->thread)))
601 return -EINVAL;
602
603 memset(reserved, 0, sizeof(reserved));
604
605 __put_user_error(ZT_MAGIC, &ctx->head.magic, err);
606 __put_user_error(round_up(ZT_SIG_CONTEXT_SIZE(1), 16),
607 &ctx->head.size, err);
608 __put_user_error(1, &ctx->nregs, err);
609 BUILD_BUG_ON(sizeof(ctx->__reserved) != sizeof(reserved));
610 err |= __copy_to_user(&ctx->__reserved, reserved, sizeof(reserved));
611
612 err |= __copy_to_user((char __user *)ctx + ZT_SIG_REGS_OFFSET,
613 thread_zt_state(¤t->thread),
614 ZT_SIG_REGS_SIZE(1));
615
616 return err ? -EFAULT : 0;
617 }
618
restore_zt_context(struct user_ctxs * user)619 static int restore_zt_context(struct user_ctxs *user)
620 {
621 int err;
622 u16 nregs;
623
624 /* ZA must be restored first for this check to be valid */
625 if (!thread_za_enabled(¤t->thread))
626 return -EINVAL;
627
628 if (user->zt_size != ZT_SIG_CONTEXT_SIZE(1))
629 return -EINVAL;
630
631 if (__copy_from_user(&nregs, &(user->zt->nregs), sizeof(nregs)))
632 return -EFAULT;
633
634 if (nregs != 1)
635 return -EINVAL;
636
637 err = __copy_from_user(thread_zt_state(¤t->thread),
638 (char __user const *)user->zt +
639 ZT_SIG_REGS_OFFSET,
640 ZT_SIG_REGS_SIZE(1));
641 if (err)
642 return -EFAULT;
643
644 return 0;
645 }
646
647 #else /* ! CONFIG_ARM64_SME */
648
649 /* Turn any non-optimised out attempts to use these into a link error: */
650 extern int preserve_tpidr2_context(void __user *ctx);
651 extern int restore_tpidr2_context(struct user_ctxs *user);
652 extern int preserve_za_context(void __user *ctx);
653 extern int restore_za_context(struct user_ctxs *user);
654 extern int preserve_zt_context(void __user *ctx);
655 extern int restore_zt_context(struct user_ctxs *user);
656
657 #endif /* ! CONFIG_ARM64_SME */
658
parse_user_sigframe(struct user_ctxs * user,struct rt_sigframe __user * sf)659 static int parse_user_sigframe(struct user_ctxs *user,
660 struct rt_sigframe __user *sf)
661 {
662 struct sigcontext __user *const sc = &sf->uc.uc_mcontext;
663 struct _aarch64_ctx __user *head;
664 char __user *base = (char __user *)&sc->__reserved;
665 size_t offset = 0;
666 size_t limit = sizeof(sc->__reserved);
667 bool have_extra_context = false;
668 char const __user *const sfp = (char const __user *)sf;
669
670 user->fpsimd = NULL;
671 user->sve = NULL;
672 user->tpidr2 = NULL;
673 user->za = NULL;
674 user->zt = NULL;
675 user->fpmr = NULL;
676 user->poe = NULL;
677
678 if (!IS_ALIGNED((unsigned long)base, 16))
679 goto invalid;
680
681 while (1) {
682 int err = 0;
683 u32 magic, size;
684 char const __user *userp;
685 struct extra_context const __user *extra;
686 u64 extra_datap;
687 u32 extra_size;
688 struct _aarch64_ctx const __user *end;
689 u32 end_magic, end_size;
690
691 if (limit - offset < sizeof(*head))
692 goto invalid;
693
694 if (!IS_ALIGNED(offset, 16))
695 goto invalid;
696
697 head = (struct _aarch64_ctx __user *)(base + offset);
698 __get_user_error(magic, &head->magic, err);
699 __get_user_error(size, &head->size, err);
700 if (err)
701 return err;
702
703 if (limit - offset < size)
704 goto invalid;
705
706 switch (magic) {
707 case 0:
708 if (size)
709 goto invalid;
710
711 goto done;
712
713 case FPSIMD_MAGIC:
714 if (!system_supports_fpsimd())
715 goto invalid;
716 if (user->fpsimd)
717 goto invalid;
718
719 user->fpsimd = (struct fpsimd_context __user *)head;
720 user->fpsimd_size = size;
721 break;
722
723 case ESR_MAGIC:
724 /* ignore */
725 break;
726
727 case POE_MAGIC:
728 if (!system_supports_poe())
729 goto invalid;
730
731 if (user->poe)
732 goto invalid;
733
734 user->poe = (struct poe_context __user *)head;
735 user->poe_size = size;
736 break;
737
738 case SVE_MAGIC:
739 if (!system_supports_sve() && !system_supports_sme())
740 goto invalid;
741
742 if (user->sve)
743 goto invalid;
744
745 user->sve = (struct sve_context __user *)head;
746 user->sve_size = size;
747 break;
748
749 case TPIDR2_MAGIC:
750 if (!system_supports_tpidr2())
751 goto invalid;
752
753 if (user->tpidr2)
754 goto invalid;
755
756 user->tpidr2 = (struct tpidr2_context __user *)head;
757 user->tpidr2_size = size;
758 break;
759
760 case ZA_MAGIC:
761 if (!system_supports_sme())
762 goto invalid;
763
764 if (user->za)
765 goto invalid;
766
767 user->za = (struct za_context __user *)head;
768 user->za_size = size;
769 break;
770
771 case ZT_MAGIC:
772 if (!system_supports_sme2())
773 goto invalid;
774
775 if (user->zt)
776 goto invalid;
777
778 user->zt = (struct zt_context __user *)head;
779 user->zt_size = size;
780 break;
781
782 case FPMR_MAGIC:
783 if (!system_supports_fpmr())
784 goto invalid;
785
786 if (user->fpmr)
787 goto invalid;
788
789 user->fpmr = (struct fpmr_context __user *)head;
790 user->fpmr_size = size;
791 break;
792
793 case EXTRA_MAGIC:
794 if (have_extra_context)
795 goto invalid;
796
797 if (size < sizeof(*extra))
798 goto invalid;
799
800 userp = (char const __user *)head;
801
802 extra = (struct extra_context const __user *)userp;
803 userp += size;
804
805 __get_user_error(extra_datap, &extra->datap, err);
806 __get_user_error(extra_size, &extra->size, err);
807 if (err)
808 return err;
809
810 /* Check for the dummy terminator in __reserved[]: */
811
812 if (limit - offset - size < TERMINATOR_SIZE)
813 goto invalid;
814
815 end = (struct _aarch64_ctx const __user *)userp;
816 userp += TERMINATOR_SIZE;
817
818 __get_user_error(end_magic, &end->magic, err);
819 __get_user_error(end_size, &end->size, err);
820 if (err)
821 return err;
822
823 if (end_magic || end_size)
824 goto invalid;
825
826 /* Prevent looping/repeated parsing of extra_context */
827 have_extra_context = true;
828
829 base = (__force void __user *)extra_datap;
830 if (!IS_ALIGNED((unsigned long)base, 16))
831 goto invalid;
832
833 if (!IS_ALIGNED(extra_size, 16))
834 goto invalid;
835
836 if (base != userp)
837 goto invalid;
838
839 /* Reject "unreasonably large" frames: */
840 if (extra_size > sfp + SIGFRAME_MAXSZ - userp)
841 goto invalid;
842
843 /*
844 * Ignore trailing terminator in __reserved[]
845 * and start parsing extra data:
846 */
847 offset = 0;
848 limit = extra_size;
849
850 if (!access_ok(base, limit))
851 goto invalid;
852
853 continue;
854
855 default:
856 goto invalid;
857 }
858
859 if (size < sizeof(*head))
860 goto invalid;
861
862 if (limit - offset < size)
863 goto invalid;
864
865 offset += size;
866 }
867
868 done:
869 return 0;
870
871 invalid:
872 return -EINVAL;
873 }
874
restore_sigframe(struct pt_regs * regs,struct rt_sigframe __user * sf,struct user_access_state * ua_state)875 static int restore_sigframe(struct pt_regs *regs,
876 struct rt_sigframe __user *sf,
877 struct user_access_state *ua_state)
878 {
879 sigset_t set;
880 int i, err;
881 struct user_ctxs user;
882
883 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
884 if (err == 0)
885 set_current_blocked(&set);
886
887 for (i = 0; i < 31; i++)
888 __get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
889 err);
890 __get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
891 __get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
892 __get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
893
894 /*
895 * Avoid sys_rt_sigreturn() restarting.
896 */
897 forget_syscall(regs);
898
899 fpsimd_save_and_flush_current_state();
900
901 err |= !valid_user_regs(®s->user_regs, current);
902 if (err == 0)
903 err = parse_user_sigframe(&user, sf);
904
905 if (err == 0 && system_supports_fpsimd()) {
906 if (!user.fpsimd)
907 return -EINVAL;
908
909 if (user.sve)
910 err = restore_sve_fpsimd_context(&user);
911 else
912 err = restore_fpsimd_context(&user);
913 }
914
915 if (err == 0 && system_supports_tpidr2() && user.tpidr2)
916 err = restore_tpidr2_context(&user);
917
918 if (err == 0 && system_supports_fpmr() && user.fpmr)
919 err = restore_fpmr_context(&user);
920
921 if (err == 0 && system_supports_sme() && user.za)
922 err = restore_za_context(&user);
923
924 if (err == 0 && system_supports_sme2() && user.zt)
925 err = restore_zt_context(&user);
926
927 if (err == 0 && system_supports_poe() && user.poe)
928 err = restore_poe_context(&user, ua_state);
929
930 return err;
931 }
932
SYSCALL_DEFINE0(rt_sigreturn)933 SYSCALL_DEFINE0(rt_sigreturn)
934 {
935 struct pt_regs *regs = current_pt_regs();
936 struct rt_sigframe __user *frame;
937 struct user_access_state ua_state;
938
939 /* Always make any pending restarted system calls return -EINTR */
940 current->restart_block.fn = do_no_restart_syscall;
941
942 /*
943 * Since we stacked the signal on a 128-bit boundary, then 'sp' should
944 * be word aligned here.
945 */
946 if (regs->sp & 15)
947 goto badframe;
948
949 frame = (struct rt_sigframe __user *)regs->sp;
950
951 if (!access_ok(frame, sizeof (*frame)))
952 goto badframe;
953
954 if (restore_sigframe(regs, frame, &ua_state))
955 goto badframe;
956
957 if (restore_altstack(&frame->uc.uc_stack))
958 goto badframe;
959
960 restore_user_access_state(&ua_state);
961
962 return regs->regs[0];
963
964 badframe:
965 arm64_notify_segfault(regs->sp);
966 return 0;
967 }
968
969 /*
970 * Determine the layout of optional records in the signal frame
971 *
972 * add_all: if true, lays out the biggest possible signal frame for
973 * this task; otherwise, generates a layout for the current state
974 * of the task.
975 */
setup_sigframe_layout(struct rt_sigframe_user_layout * user,bool add_all)976 static int setup_sigframe_layout(struct rt_sigframe_user_layout *user,
977 bool add_all)
978 {
979 int err;
980
981 if (system_supports_fpsimd()) {
982 err = sigframe_alloc(user, &user->fpsimd_offset,
983 sizeof(struct fpsimd_context));
984 if (err)
985 return err;
986 }
987
988 /* fault information, if valid */
989 if (add_all || current->thread.fault_code) {
990 err = sigframe_alloc(user, &user->esr_offset,
991 sizeof(struct esr_context));
992 if (err)
993 return err;
994 }
995
996 if (system_supports_sve() || system_supports_sme()) {
997 unsigned int vq = 0;
998
999 if (add_all || current->thread.fp_type == FP_STATE_SVE ||
1000 thread_sm_enabled(¤t->thread)) {
1001 int vl = max(sve_max_vl(), sme_max_vl());
1002
1003 if (!add_all)
1004 vl = thread_get_cur_vl(¤t->thread);
1005
1006 vq = sve_vq_from_vl(vl);
1007 }
1008
1009 err = sigframe_alloc(user, &user->sve_offset,
1010 SVE_SIG_CONTEXT_SIZE(vq));
1011 if (err)
1012 return err;
1013 }
1014
1015 if (system_supports_tpidr2()) {
1016 err = sigframe_alloc(user, &user->tpidr2_offset,
1017 sizeof(struct tpidr2_context));
1018 if (err)
1019 return err;
1020 }
1021
1022 if (system_supports_sme()) {
1023 unsigned int vl;
1024 unsigned int vq = 0;
1025
1026 if (add_all)
1027 vl = sme_max_vl();
1028 else
1029 vl = task_get_sme_vl(current);
1030
1031 if (thread_za_enabled(¤t->thread))
1032 vq = sve_vq_from_vl(vl);
1033
1034 err = sigframe_alloc(user, &user->za_offset,
1035 ZA_SIG_CONTEXT_SIZE(vq));
1036 if (err)
1037 return err;
1038 }
1039
1040 if (system_supports_sme2()) {
1041 if (add_all || thread_za_enabled(¤t->thread)) {
1042 err = sigframe_alloc(user, &user->zt_offset,
1043 ZT_SIG_CONTEXT_SIZE(1));
1044 if (err)
1045 return err;
1046 }
1047 }
1048
1049 if (system_supports_fpmr()) {
1050 err = sigframe_alloc(user, &user->fpmr_offset,
1051 sizeof(struct fpmr_context));
1052 if (err)
1053 return err;
1054 }
1055
1056 if (system_supports_poe()) {
1057 err = sigframe_alloc(user, &user->poe_offset,
1058 sizeof(struct poe_context));
1059 if (err)
1060 return err;
1061 }
1062
1063 return sigframe_alloc_end(user);
1064 }
1065
setup_sigframe(struct rt_sigframe_user_layout * user,struct pt_regs * regs,sigset_t * set,const struct user_access_state * ua_state)1066 static int setup_sigframe(struct rt_sigframe_user_layout *user,
1067 struct pt_regs *regs, sigset_t *set,
1068 const struct user_access_state *ua_state)
1069 {
1070 int i, err = 0;
1071 struct rt_sigframe __user *sf = user->sigframe;
1072
1073 /* set up the stack frame for unwinding */
1074 __put_user_error(regs->regs[29], &user->next_frame->fp, err);
1075 __put_user_error(regs->regs[30], &user->next_frame->lr, err);
1076
1077 for (i = 0; i < 31; i++)
1078 __put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
1079 err);
1080 __put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
1081 __put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
1082 __put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
1083
1084 __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
1085
1086 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
1087
1088 if (err == 0 && system_supports_fpsimd()) {
1089 struct fpsimd_context __user *fpsimd_ctx =
1090 apply_user_offset(user, user->fpsimd_offset);
1091 err |= preserve_fpsimd_context(fpsimd_ctx);
1092 }
1093
1094 /* fault information, if valid */
1095 if (err == 0 && user->esr_offset) {
1096 struct esr_context __user *esr_ctx =
1097 apply_user_offset(user, user->esr_offset);
1098
1099 __put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err);
1100 __put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err);
1101 __put_user_error(current->thread.fault_code, &esr_ctx->esr, err);
1102 }
1103
1104 /* Scalable Vector Extension state (including streaming), if present */
1105 if ((system_supports_sve() || system_supports_sme()) &&
1106 err == 0 && user->sve_offset) {
1107 struct sve_context __user *sve_ctx =
1108 apply_user_offset(user, user->sve_offset);
1109 err |= preserve_sve_context(sve_ctx);
1110 }
1111
1112 /* TPIDR2 if supported */
1113 if (system_supports_tpidr2() && err == 0) {
1114 struct tpidr2_context __user *tpidr2_ctx =
1115 apply_user_offset(user, user->tpidr2_offset);
1116 err |= preserve_tpidr2_context(tpidr2_ctx);
1117 }
1118
1119 /* FPMR if supported */
1120 if (system_supports_fpmr() && err == 0) {
1121 struct fpmr_context __user *fpmr_ctx =
1122 apply_user_offset(user, user->fpmr_offset);
1123 err |= preserve_fpmr_context(fpmr_ctx);
1124 }
1125
1126 if (system_supports_poe() && err == 0 && user->poe_offset) {
1127 struct poe_context __user *poe_ctx =
1128 apply_user_offset(user, user->poe_offset);
1129
1130 err |= preserve_poe_context(poe_ctx, ua_state);
1131 }
1132
1133 /* ZA state if present */
1134 if (system_supports_sme() && err == 0 && user->za_offset) {
1135 struct za_context __user *za_ctx =
1136 apply_user_offset(user, user->za_offset);
1137 err |= preserve_za_context(za_ctx);
1138 }
1139
1140 /* ZT state if present */
1141 if (system_supports_sme2() && err == 0 && user->zt_offset) {
1142 struct zt_context __user *zt_ctx =
1143 apply_user_offset(user, user->zt_offset);
1144 err |= preserve_zt_context(zt_ctx);
1145 }
1146
1147 if (err == 0 && user->extra_offset) {
1148 char __user *sfp = (char __user *)user->sigframe;
1149 char __user *userp =
1150 apply_user_offset(user, user->extra_offset);
1151
1152 struct extra_context __user *extra;
1153 struct _aarch64_ctx __user *end;
1154 u64 extra_datap;
1155 u32 extra_size;
1156
1157 extra = (struct extra_context __user *)userp;
1158 userp += EXTRA_CONTEXT_SIZE;
1159
1160 end = (struct _aarch64_ctx __user *)userp;
1161 userp += TERMINATOR_SIZE;
1162
1163 /*
1164 * extra_datap is just written to the signal frame.
1165 * The value gets cast back to a void __user *
1166 * during sigreturn.
1167 */
1168 extra_datap = (__force u64)userp;
1169 extra_size = sfp + round_up(user->size, 16) - userp;
1170
1171 __put_user_error(EXTRA_MAGIC, &extra->head.magic, err);
1172 __put_user_error(EXTRA_CONTEXT_SIZE, &extra->head.size, err);
1173 __put_user_error(extra_datap, &extra->datap, err);
1174 __put_user_error(extra_size, &extra->size, err);
1175
1176 /* Add the terminator */
1177 __put_user_error(0, &end->magic, err);
1178 __put_user_error(0, &end->size, err);
1179 }
1180
1181 /* set the "end" magic */
1182 if (err == 0) {
1183 struct _aarch64_ctx __user *end =
1184 apply_user_offset(user, user->end_offset);
1185
1186 __put_user_error(0, &end->magic, err);
1187 __put_user_error(0, &end->size, err);
1188 }
1189
1190 return err;
1191 }
1192
get_sigframe(struct rt_sigframe_user_layout * user,struct ksignal * ksig,struct pt_regs * regs)1193 static int get_sigframe(struct rt_sigframe_user_layout *user,
1194 struct ksignal *ksig, struct pt_regs *regs)
1195 {
1196 unsigned long sp, sp_top;
1197 int err;
1198
1199 init_user_layout(user);
1200 err = setup_sigframe_layout(user, false);
1201 if (err)
1202 return err;
1203
1204 sp = sp_top = sigsp(regs->sp, ksig);
1205
1206 sp = round_down(sp - sizeof(struct frame_record), 16);
1207 user->next_frame = (struct frame_record __user *)sp;
1208
1209 sp = round_down(sp, 16) - sigframe_size(user);
1210 user->sigframe = (struct rt_sigframe __user *)sp;
1211
1212 /*
1213 * Check that we can actually write to the signal frame.
1214 */
1215 if (!access_ok(user->sigframe, sp_top - sp))
1216 return -EFAULT;
1217
1218 return 0;
1219 }
1220
setup_return(struct pt_regs * regs,struct k_sigaction * ka,struct rt_sigframe_user_layout * user,int usig)1221 static void setup_return(struct pt_regs *regs, struct k_sigaction *ka,
1222 struct rt_sigframe_user_layout *user, int usig)
1223 {
1224 __sigrestore_t sigtramp;
1225
1226 regs->regs[0] = usig;
1227 regs->sp = (unsigned long)user->sigframe;
1228 regs->regs[29] = (unsigned long)&user->next_frame->fp;
1229 regs->pc = (unsigned long)ka->sa.sa_handler;
1230
1231 /*
1232 * Signal delivery is a (wacky) indirect function call in
1233 * userspace, so simulate the same setting of BTYPE as a BLR
1234 * <register containing the signal handler entry point>.
1235 * Signal delivery to a location in a PROT_BTI guarded page
1236 * that is not a function entry point will now trigger a
1237 * SIGILL in userspace.
1238 *
1239 * If the signal handler entry point is not in a PROT_BTI
1240 * guarded page, this is harmless.
1241 */
1242 if (system_supports_bti()) {
1243 regs->pstate &= ~PSR_BTYPE_MASK;
1244 regs->pstate |= PSR_BTYPE_C;
1245 }
1246
1247 /* TCO (Tag Check Override) always cleared for signal handlers */
1248 regs->pstate &= ~PSR_TCO_BIT;
1249
1250 /* Signal handlers are invoked with ZA and streaming mode disabled */
1251 if (system_supports_sme()) {
1252 task_smstop_sm(current);
1253 current->thread.svcr &= ~SVCR_ZA_MASK;
1254 write_sysreg_s(0, SYS_TPIDR2_EL0);
1255 }
1256
1257 if (ka->sa.sa_flags & SA_RESTORER)
1258 sigtramp = ka->sa.sa_restorer;
1259 else
1260 sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp);
1261
1262 regs->regs[30] = (unsigned long)sigtramp;
1263 }
1264
setup_rt_frame(int usig,struct ksignal * ksig,sigset_t * set,struct pt_regs * regs)1265 static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
1266 struct pt_regs *regs)
1267 {
1268 struct rt_sigframe_user_layout user;
1269 struct rt_sigframe __user *frame;
1270 struct user_access_state ua_state;
1271 int err = 0;
1272
1273 fpsimd_save_and_flush_current_state();
1274
1275 if (get_sigframe(&user, ksig, regs))
1276 return 1;
1277
1278 save_reset_user_access_state(&ua_state);
1279 frame = user.sigframe;
1280
1281 __put_user_error(0, &frame->uc.uc_flags, err);
1282 __put_user_error(NULL, &frame->uc.uc_link, err);
1283
1284 err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
1285 err |= setup_sigframe(&user, regs, set, &ua_state);
1286 if (err == 0) {
1287 setup_return(regs, &ksig->ka, &user, usig);
1288 if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
1289 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
1290 regs->regs[1] = (unsigned long)&frame->info;
1291 regs->regs[2] = (unsigned long)&frame->uc;
1292 }
1293 }
1294
1295 if (err == 0)
1296 set_handler_user_access_state();
1297 else
1298 restore_user_access_state(&ua_state);
1299
1300 return err;
1301 }
1302
setup_restart_syscall(struct pt_regs * regs)1303 static void setup_restart_syscall(struct pt_regs *regs)
1304 {
1305 if (is_compat_task())
1306 compat_setup_restart_syscall(regs);
1307 else
1308 regs->regs[8] = __NR_restart_syscall;
1309 }
1310
1311 /*
1312 * OK, we're invoking a handler
1313 */
handle_signal(struct ksignal * ksig,struct pt_regs * regs)1314 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
1315 {
1316 sigset_t *oldset = sigmask_to_save();
1317 int usig = ksig->sig;
1318 int ret;
1319
1320 rseq_signal_deliver(ksig, regs);
1321
1322 /*
1323 * Set up the stack frame
1324 */
1325 if (is_compat_task()) {
1326 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
1327 ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
1328 else
1329 ret = compat_setup_frame(usig, ksig, oldset, regs);
1330 } else {
1331 ret = setup_rt_frame(usig, ksig, oldset, regs);
1332 }
1333
1334 /*
1335 * Check that the resulting registers are actually sane.
1336 */
1337 ret |= !valid_user_regs(®s->user_regs, current);
1338
1339 /* Step into the signal handler if we are stepping */
1340 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
1341 }
1342
1343 /*
1344 * Note that 'init' is a special process: it doesn't get signals it doesn't
1345 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1346 * mistake.
1347 *
1348 * Note that we go through the signals twice: once to check the signals that
1349 * the kernel can handle, and then we build all the user-level signal handling
1350 * stack-frames in one go after that.
1351 */
do_signal(struct pt_regs * regs)1352 void do_signal(struct pt_regs *regs)
1353 {
1354 unsigned long continue_addr = 0, restart_addr = 0;
1355 int retval = 0;
1356 struct ksignal ksig;
1357 bool syscall = in_syscall(regs);
1358
1359 /*
1360 * If we were from a system call, check for system call restarting...
1361 */
1362 if (syscall) {
1363 continue_addr = regs->pc;
1364 restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4);
1365 retval = regs->regs[0];
1366
1367 /*
1368 * Avoid additional syscall restarting via ret_to_user.
1369 */
1370 forget_syscall(regs);
1371
1372 /*
1373 * Prepare for system call restart. We do this here so that a
1374 * debugger will see the already changed PC.
1375 */
1376 switch (retval) {
1377 case -ERESTARTNOHAND:
1378 case -ERESTARTSYS:
1379 case -ERESTARTNOINTR:
1380 case -ERESTART_RESTARTBLOCK:
1381 regs->regs[0] = regs->orig_x0;
1382 regs->pc = restart_addr;
1383 break;
1384 }
1385 }
1386
1387 /*
1388 * Get the signal to deliver. When running under ptrace, at this point
1389 * the debugger may change all of our registers.
1390 */
1391 if (get_signal(&ksig)) {
1392 /*
1393 * Depending on the signal settings, we may need to revert the
1394 * decision to restart the system call, but skip this if a
1395 * debugger has chosen to restart at a different PC.
1396 */
1397 if (regs->pc == restart_addr &&
1398 (retval == -ERESTARTNOHAND ||
1399 retval == -ERESTART_RESTARTBLOCK ||
1400 (retval == -ERESTARTSYS &&
1401 !(ksig.ka.sa.sa_flags & SA_RESTART)))) {
1402 syscall_set_return_value(current, regs, -EINTR, 0);
1403 regs->pc = continue_addr;
1404 }
1405
1406 handle_signal(&ksig, regs);
1407 return;
1408 }
1409
1410 /*
1411 * Handle restarting a different system call. As above, if a debugger
1412 * has chosen to restart at a different PC, ignore the restart.
1413 */
1414 if (syscall && regs->pc == restart_addr) {
1415 if (retval == -ERESTART_RESTARTBLOCK)
1416 setup_restart_syscall(regs);
1417 user_rewind_single_step(current);
1418 }
1419
1420 restore_saved_sigmask();
1421 }
1422
1423 unsigned long __ro_after_init signal_minsigstksz;
1424
1425 /*
1426 * Determine the stack space required for guaranteed signal devliery.
1427 * This function is used to populate AT_MINSIGSTKSZ at process startup.
1428 * cpufeatures setup is assumed to be complete.
1429 */
minsigstksz_setup(void)1430 void __init minsigstksz_setup(void)
1431 {
1432 struct rt_sigframe_user_layout user;
1433
1434 init_user_layout(&user);
1435
1436 /*
1437 * If this fails, SIGFRAME_MAXSZ needs to be enlarged. It won't
1438 * be big enough, but it's our best guess:
1439 */
1440 if (WARN_ON(setup_sigframe_layout(&user, true)))
1441 return;
1442
1443 signal_minsigstksz = sigframe_size(&user) +
1444 round_up(sizeof(struct frame_record), 16) +
1445 16; /* max alignment padding */
1446 }
1447
1448 /*
1449 * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as
1450 * changes likely come with new fields that should be added below.
1451 */
1452 static_assert(NSIGILL == 11);
1453 static_assert(NSIGFPE == 15);
1454 static_assert(NSIGSEGV == 10);
1455 static_assert(NSIGBUS == 5);
1456 static_assert(NSIGTRAP == 6);
1457 static_assert(NSIGCHLD == 6);
1458 static_assert(NSIGSYS == 2);
1459 static_assert(sizeof(siginfo_t) == 128);
1460 static_assert(__alignof__(siginfo_t) == 8);
1461 static_assert(offsetof(siginfo_t, si_signo) == 0x00);
1462 static_assert(offsetof(siginfo_t, si_errno) == 0x04);
1463 static_assert(offsetof(siginfo_t, si_code) == 0x08);
1464 static_assert(offsetof(siginfo_t, si_pid) == 0x10);
1465 static_assert(offsetof(siginfo_t, si_uid) == 0x14);
1466 static_assert(offsetof(siginfo_t, si_tid) == 0x10);
1467 static_assert(offsetof(siginfo_t, si_overrun) == 0x14);
1468 static_assert(offsetof(siginfo_t, si_status) == 0x18);
1469 static_assert(offsetof(siginfo_t, si_utime) == 0x20);
1470 static_assert(offsetof(siginfo_t, si_stime) == 0x28);
1471 static_assert(offsetof(siginfo_t, si_value) == 0x18);
1472 static_assert(offsetof(siginfo_t, si_int) == 0x18);
1473 static_assert(offsetof(siginfo_t, si_ptr) == 0x18);
1474 static_assert(offsetof(siginfo_t, si_addr) == 0x10);
1475 static_assert(offsetof(siginfo_t, si_addr_lsb) == 0x18);
1476 static_assert(offsetof(siginfo_t, si_lower) == 0x20);
1477 static_assert(offsetof(siginfo_t, si_upper) == 0x28);
1478 static_assert(offsetof(siginfo_t, si_pkey) == 0x20);
1479 static_assert(offsetof(siginfo_t, si_perf_data) == 0x18);
1480 static_assert(offsetof(siginfo_t, si_perf_type) == 0x20);
1481 static_assert(offsetof(siginfo_t, si_perf_flags) == 0x24);
1482 static_assert(offsetof(siginfo_t, si_band) == 0x10);
1483 static_assert(offsetof(siginfo_t, si_fd) == 0x18);
1484 static_assert(offsetof(siginfo_t, si_call_addr) == 0x10);
1485 static_assert(offsetof(siginfo_t, si_syscall) == 0x18);
1486 static_assert(offsetof(siginfo_t, si_arch) == 0x1c);
1487