2 * Based on arch/arm/kernel/signal.c
4 * Copyright (C) 1995-2009 Russell King
5 * Copyright (C) 2012 ARM Ltd.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #include <linux/compat.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/signal.h>
24 #include <linux/personality.h>
25 #include <linux/freezer.h>
26 #include <linux/stddef.h>
27 #include <linux/uaccess.h>
28 #include <linux/sizes.h>
29 #include <linux/string.h>
30 #include <linux/tracehook.h>
31 #include <linux/ratelimit.h>
32 #include <linux/syscalls.h>
34 #include <asm/debug-monitors.h>
36 #include <asm/cacheflush.h>
37 #include <asm/ucontext.h>
38 #include <asm/unistd.h>
39 #include <asm/fpsimd.h>
40 #include <asm/ptrace.h>
41 #include <asm/signal32.h>
45 * Do a signal return; undo the signal stack. These are aligned to 128-bit.
57 struct rt_sigframe_user_layout {
58 struct rt_sigframe __user *sigframe;
59 struct frame_record __user *next_frame;
61 unsigned long size; /* size of allocated sigframe data */
62 unsigned long limit; /* largest allowed size */
64 unsigned long fpsimd_offset;
65 unsigned long esr_offset;
66 unsigned long extra_offset;
67 unsigned long end_offset;
70 #define BASE_SIGFRAME_SIZE round_up(sizeof(struct rt_sigframe), 16)
71 #define TERMINATOR_SIZE round_up(sizeof(struct _aarch64_ctx), 16)
72 #define EXTRA_CONTEXT_SIZE round_up(sizeof(struct extra_context), 16)
74 static void init_user_layout(struct rt_sigframe_user_layout *user)
76 const size_t reserved_size =
77 sizeof(user->sigframe->uc.uc_mcontext.__reserved);
79 memset(user, 0, sizeof(*user));
80 user->size = offsetof(struct rt_sigframe, uc.uc_mcontext.__reserved);
82 user->limit = user->size + reserved_size;
84 user->limit -= TERMINATOR_SIZE;
85 user->limit -= EXTRA_CONTEXT_SIZE;
86 /* Reserve space for extension and terminator ^ */
89 static size_t sigframe_size(struct rt_sigframe_user_layout const *user)
91 return round_up(max(user->size, sizeof(struct rt_sigframe)), 16);
95 * Sanity limit on the approximate maximum size of signal frame we'll
96 * try to generate. Stack alignment padding and the frame record are
97 * not taken into account. This limit is not a guarantee and is
100 #define SIGFRAME_MAXSZ SZ_64K
102 static int __sigframe_alloc(struct rt_sigframe_user_layout *user,
103 unsigned long *offset, size_t size, bool extend)
105 size_t padded_size = round_up(size, 16);
107 if (padded_size > user->limit - user->size &&
108 !user->extra_offset &&
112 user->limit += EXTRA_CONTEXT_SIZE;
113 ret = __sigframe_alloc(user, &user->extra_offset,
114 sizeof(struct extra_context), false);
116 user->limit -= EXTRA_CONTEXT_SIZE;
120 /* Reserve space for the __reserved[] terminator */
121 user->size += TERMINATOR_SIZE;
124 * Allow expansion up to SIGFRAME_MAXSZ, ensuring space for
127 user->limit = SIGFRAME_MAXSZ - TERMINATOR_SIZE;
130 /* Still not enough space? Bad luck! */
131 if (padded_size > user->limit - user->size)
134 *offset = user->size;
135 user->size += padded_size;
141 * Allocate space for an optional record of <size> bytes in the user
142 * signal frame. The offset from the signal frame base address to the
143 * allocated block is assigned to *offset.
145 static int sigframe_alloc(struct rt_sigframe_user_layout *user,
146 unsigned long *offset, size_t size)
148 return __sigframe_alloc(user, offset, size, true);
151 /* Allocate the null terminator record and prevent further allocations */
152 static int sigframe_alloc_end(struct rt_sigframe_user_layout *user)
156 /* Un-reserve the space reserved for the terminator: */
157 user->limit += TERMINATOR_SIZE;
159 ret = sigframe_alloc(user, &user->end_offset,
160 sizeof(struct _aarch64_ctx));
164 /* Prevent further allocation: */
165 user->limit = user->size;
169 static void __user *apply_user_offset(
170 struct rt_sigframe_user_layout const *user, unsigned long offset)
172 char __user *base = (char __user *)user->sigframe;
174 return base + offset;
177 static int preserve_fpsimd_context(struct fpsimd_context __user *ctx)
179 struct fpsimd_state *fpsimd = ¤t->thread.fpsimd_state;
182 /* dump the hardware registers to the fpsimd_state structure */
183 fpsimd_preserve_current_state();
185 /* copy the FP and status/control registers */
186 err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs));
187 __put_user_error(fpsimd->fpsr, &ctx->fpsr, err);
188 __put_user_error(fpsimd->fpcr, &ctx->fpcr, err);
190 /* copy the magic/size information */
191 __put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err);
192 __put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err);
194 return err ? -EFAULT : 0;
197 static int restore_fpsimd_context(struct fpsimd_context __user *ctx)
199 struct fpsimd_state fpsimd;
203 /* check the magic/size information */
204 __get_user_error(magic, &ctx->head.magic, err);
205 __get_user_error(size, &ctx->head.size, err);
208 if (magic != FPSIMD_MAGIC || size != sizeof(struct fpsimd_context))
211 /* copy the FP and status/control registers */
212 err = __copy_from_user(fpsimd.vregs, ctx->vregs,
213 sizeof(fpsimd.vregs));
214 __get_user_error(fpsimd.fpsr, &ctx->fpsr, err);
215 __get_user_error(fpsimd.fpcr, &ctx->fpcr, err);
217 /* load the hardware registers from the fpsimd_state structure */
219 fpsimd_update_current_state(&fpsimd);
221 return err ? -EFAULT : 0;
225 struct fpsimd_context __user *fpsimd;
228 static int parse_user_sigframe(struct user_ctxs *user,
229 struct rt_sigframe __user *sf)
231 struct sigcontext __user *const sc = &sf->uc.uc_mcontext;
232 struct _aarch64_ctx __user *head;
233 char __user *base = (char __user *)&sc->__reserved;
235 size_t limit = sizeof(sc->__reserved);
236 bool have_extra_context = false;
237 char const __user *const sfp = (char const __user *)sf;
241 if (!IS_ALIGNED((unsigned long)base, 16))
247 char const __user *userp;
248 struct extra_context const __user *extra;
251 struct _aarch64_ctx const __user *end;
252 u32 end_magic, end_size;
254 if (limit - offset < sizeof(*head))
257 if (!IS_ALIGNED(offset, 16))
260 head = (struct _aarch64_ctx __user *)(base + offset);
261 __get_user_error(magic, &head->magic, err);
262 __get_user_error(size, &head->size, err);
266 if (limit - offset < size)
280 if (size < sizeof(*user->fpsimd))
283 user->fpsimd = (struct fpsimd_context __user *)head;
291 if (have_extra_context)
294 if (size < sizeof(*extra))
297 userp = (char const __user *)head;
299 extra = (struct extra_context const __user *)userp;
302 __get_user_error(extra_datap, &extra->datap, err);
303 __get_user_error(extra_size, &extra->size, err);
307 /* Check for the dummy terminator in __reserved[]: */
309 if (limit - offset - size < TERMINATOR_SIZE)
312 end = (struct _aarch64_ctx const __user *)userp;
313 userp += TERMINATOR_SIZE;
315 __get_user_error(end_magic, &end->magic, err);
316 __get_user_error(end_size, &end->size, err);
320 if (end_magic || end_size)
323 /* Prevent looping/repeated parsing of extra_context */
324 have_extra_context = true;
326 base = (__force void __user *)extra_datap;
327 if (!IS_ALIGNED((unsigned long)base, 16))
330 if (!IS_ALIGNED(extra_size, 16))
336 /* Reject "unreasonably large" frames: */
337 if (extra_size > sfp + SIGFRAME_MAXSZ - userp)
341 * Ignore trailing terminator in __reserved[]
342 * and start parsing extra data:
352 if (size < sizeof(*head))
355 if (limit - offset < size)
371 static int restore_sigframe(struct pt_regs *regs,
372 struct rt_sigframe __user *sf)
376 struct user_ctxs user;
378 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
380 set_current_blocked(&set);
382 for (i = 0; i < 31; i++)
383 __get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
385 __get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
386 __get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
387 __get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
390 * Avoid sys_rt_sigreturn() restarting.
392 forget_syscall(regs);
394 err |= !valid_user_regs(®s->user_regs, current);
396 err = parse_user_sigframe(&user, sf);
399 err = restore_fpsimd_context(user.fpsimd);
404 asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
406 struct rt_sigframe __user *frame;
408 /* Always make any pending restarted system calls return -EINTR */
409 current->restart_block.fn = do_no_restart_syscall;
412 * Since we stacked the signal on a 128-bit boundary, then 'sp' should
413 * be word aligned here.
418 frame = (struct rt_sigframe __user *)regs->sp;
420 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
423 if (restore_sigframe(regs, frame))
426 if (restore_altstack(&frame->uc.uc_stack))
429 return regs->regs[0];
432 if (show_unhandled_signals)
433 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
434 current->comm, task_pid_nr(current), __func__,
436 force_sig(SIGSEGV, current);
440 /* Determine the layout of optional records in the signal frame */
441 static int setup_sigframe_layout(struct rt_sigframe_user_layout *user)
445 err = sigframe_alloc(user, &user->fpsimd_offset,
446 sizeof(struct fpsimd_context));
450 /* fault information, if valid */
451 if (current->thread.fault_code) {
452 err = sigframe_alloc(user, &user->esr_offset,
453 sizeof(struct esr_context));
458 return sigframe_alloc_end(user);
462 static int setup_sigframe(struct rt_sigframe_user_layout *user,
463 struct pt_regs *regs, sigset_t *set)
466 struct rt_sigframe __user *sf = user->sigframe;
468 /* set up the stack frame for unwinding */
469 __put_user_error(regs->regs[29], &user->next_frame->fp, err);
470 __put_user_error(regs->regs[30], &user->next_frame->lr, err);
472 for (i = 0; i < 31; i++)
473 __put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
475 __put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
476 __put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
477 __put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
479 __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
481 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
484 struct fpsimd_context __user *fpsimd_ctx =
485 apply_user_offset(user, user->fpsimd_offset);
486 err |= preserve_fpsimd_context(fpsimd_ctx);
489 /* fault information, if valid */
490 if (err == 0 && user->esr_offset) {
491 struct esr_context __user *esr_ctx =
492 apply_user_offset(user, user->esr_offset);
494 __put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err);
495 __put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err);
496 __put_user_error(current->thread.fault_code, &esr_ctx->esr, err);
499 if (err == 0 && user->extra_offset) {
500 char __user *sfp = (char __user *)user->sigframe;
502 apply_user_offset(user, user->extra_offset);
504 struct extra_context __user *extra;
505 struct _aarch64_ctx __user *end;
509 extra = (struct extra_context __user *)userp;
510 userp += EXTRA_CONTEXT_SIZE;
512 end = (struct _aarch64_ctx __user *)userp;
513 userp += TERMINATOR_SIZE;
516 * extra_datap is just written to the signal frame.
517 * The value gets cast back to a void __user *
520 extra_datap = (__force u64)userp;
521 extra_size = sfp + round_up(user->size, 16) - userp;
523 __put_user_error(EXTRA_MAGIC, &extra->head.magic, err);
524 __put_user_error(EXTRA_CONTEXT_SIZE, &extra->head.size, err);
525 __put_user_error(extra_datap, &extra->datap, err);
526 __put_user_error(extra_size, &extra->size, err);
528 /* Add the terminator */
529 __put_user_error(0, &end->magic, err);
530 __put_user_error(0, &end->size, err);
533 /* set the "end" magic */
535 struct _aarch64_ctx __user *end =
536 apply_user_offset(user, user->end_offset);
538 __put_user_error(0, &end->magic, err);
539 __put_user_error(0, &end->size, err);
545 static int get_sigframe(struct rt_sigframe_user_layout *user,
546 struct ksignal *ksig, struct pt_regs *regs)
548 unsigned long sp, sp_top;
551 init_user_layout(user);
552 err = setup_sigframe_layout(user);
556 sp = sp_top = sigsp(regs->sp, ksig);
558 sp = round_down(sp - sizeof(struct frame_record), 16);
559 user->next_frame = (struct frame_record __user *)sp;
561 sp = round_down(sp, 16) - sigframe_size(user);
562 user->sigframe = (struct rt_sigframe __user *)sp;
565 * Check that we can actually write to the signal frame.
567 if (!access_ok(VERIFY_WRITE, user->sigframe, sp_top - sp))
573 static void setup_return(struct pt_regs *regs, struct k_sigaction *ka,
574 struct rt_sigframe_user_layout *user, int usig)
576 __sigrestore_t sigtramp;
578 regs->regs[0] = usig;
579 regs->sp = (unsigned long)user->sigframe;
580 regs->regs[29] = (unsigned long)&user->next_frame->fp;
581 regs->pc = (unsigned long)ka->sa.sa_handler;
583 if (ka->sa.sa_flags & SA_RESTORER)
584 sigtramp = ka->sa.sa_restorer;
586 sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp);
588 regs->regs[30] = (unsigned long)sigtramp;
591 static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
592 struct pt_regs *regs)
594 struct rt_sigframe_user_layout user;
595 struct rt_sigframe __user *frame;
598 if (get_sigframe(&user, ksig, regs))
601 frame = user.sigframe;
603 __put_user_error(0, &frame->uc.uc_flags, err);
604 __put_user_error(NULL, &frame->uc.uc_link, err);
606 err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
607 err |= setup_sigframe(&user, regs, set);
609 setup_return(regs, &ksig->ka, &user, usig);
610 if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
611 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
612 regs->regs[1] = (unsigned long)&frame->info;
613 regs->regs[2] = (unsigned long)&frame->uc;
620 static void setup_restart_syscall(struct pt_regs *regs)
622 if (is_compat_task())
623 compat_setup_restart_syscall(regs);
625 regs->regs[8] = __NR_restart_syscall;
629 * OK, we're invoking a handler
631 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
633 struct task_struct *tsk = current;
634 sigset_t *oldset = sigmask_to_save();
635 int usig = ksig->sig;
639 * Set up the stack frame
641 if (is_compat_task()) {
642 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
643 ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
645 ret = compat_setup_frame(usig, ksig, oldset, regs);
647 ret = setup_rt_frame(usig, ksig, oldset, regs);
651 * Check that the resulting registers are actually sane.
653 ret |= !valid_user_regs(®s->user_regs, current);
656 * Fast forward the stepping logic so we step into the signal
660 user_fastforward_single_step(tsk);
662 signal_setup_done(ret, ksig, 0);
666 * Note that 'init' is a special process: it doesn't get signals it doesn't
667 * want to handle. Thus you cannot kill init even with a SIGKILL even by
670 * Note that we go through the signals twice: once to check the signals that
671 * the kernel can handle, and then we build all the user-level signal handling
672 * stack-frames in one go after that.
674 static void do_signal(struct pt_regs *regs)
676 unsigned long continue_addr = 0, restart_addr = 0;
679 bool syscall = in_syscall(regs);
682 * If we were from a system call, check for system call restarting...
685 continue_addr = regs->pc;
686 restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4);
687 retval = regs->regs[0];
690 * Avoid additional syscall restarting via ret_to_user.
692 forget_syscall(regs);
695 * Prepare for system call restart. We do this here so that a
696 * debugger will see the already changed PC.
699 case -ERESTARTNOHAND:
701 case -ERESTARTNOINTR:
702 case -ERESTART_RESTARTBLOCK:
703 regs->regs[0] = regs->orig_x0;
704 regs->pc = restart_addr;
710 * Get the signal to deliver. When running under ptrace, at this point
711 * the debugger may change all of our registers.
713 if (get_signal(&ksig)) {
715 * Depending on the signal settings, we may need to revert the
716 * decision to restart the system call, but skip this if a
717 * debugger has chosen to restart at a different PC.
719 if (regs->pc == restart_addr &&
720 (retval == -ERESTARTNOHAND ||
721 retval == -ERESTART_RESTARTBLOCK ||
722 (retval == -ERESTARTSYS &&
723 !(ksig.ka.sa.sa_flags & SA_RESTART)))) {
724 regs->regs[0] = -EINTR;
725 regs->pc = continue_addr;
728 handle_signal(&ksig, regs);
733 * Handle restarting a different system call. As above, if a debugger
734 * has chosen to restart at a different PC, ignore the restart.
736 if (syscall && regs->pc == restart_addr) {
737 if (retval == -ERESTART_RESTARTBLOCK)
738 setup_restart_syscall(regs);
739 user_rewind_single_step(current);
742 restore_saved_sigmask();
745 asmlinkage void do_notify_resume(struct pt_regs *regs,
746 unsigned int thread_flags)
749 * The assembly code enters us with IRQs off, but it hasn't
750 * informed the tracing code of that for efficiency reasons.
751 * Update the trace code with the current status.
753 trace_hardirqs_off();
756 /* Check valid user FS if needed */
757 addr_limit_user_check();
759 if (thread_flags & _TIF_NEED_RESCHED) {
764 if (thread_flags & _TIF_UPROBE)
765 uprobe_notify_resume(regs);
767 if (thread_flags & _TIF_SIGPENDING)
770 if (thread_flags & _TIF_NOTIFY_RESUME) {
771 clear_thread_flag(TIF_NOTIFY_RESUME);
772 tracehook_notify_resume(regs);
775 if (thread_flags & _TIF_FOREIGN_FPSTATE)
776 fpsimd_restore_current_state();
780 thread_flags = READ_ONCE(current_thread_info()->flags);
781 } while (thread_flags & _TIF_WORK_MASK);