2 * linux/arch/arm/kernel/signal.c
4 * Copyright (C) 1995-2009 Russell King
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 #include <linux/errno.h>
11 #include <linux/random.h>
12 #include <linux/signal.h>
13 #include <linux/personality.h>
14 #include <linux/uaccess.h>
15 #include <linux/tracehook.h>
16 #include <linux/uprobes.h>
17 #include <linux/syscalls.h>
20 #include <asm/cacheflush.h>
21 #include <asm/traps.h>
22 #include <asm/unistd.h>
27 extern const unsigned long sigreturn_codes[17];
29 static unsigned long signal_return_offset;
32 static int preserve_crunch_context(struct crunch_sigframe __user *frame)
34 char kbuf[sizeof(*frame) + 8];
35 struct crunch_sigframe *kframe;
37 /* the crunch context must be 64 bit aligned */
38 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
39 kframe->magic = CRUNCH_MAGIC;
40 kframe->size = CRUNCH_STORAGE_SIZE;
41 crunch_task_copy(current_thread_info(), &kframe->storage);
42 return __copy_to_user(frame, kframe, sizeof(*frame));
45 static int restore_crunch_context(char __user **auxp)
47 struct crunch_sigframe __user *frame =
48 (struct crunch_sigframe __user *)*auxp;
49 char kbuf[sizeof(*frame) + 8];
50 struct crunch_sigframe *kframe;
52 /* the crunch context must be 64 bit aligned */
53 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
54 if (__copy_from_user(kframe, frame, sizeof(*frame)))
56 if (kframe->magic != CRUNCH_MAGIC ||
57 kframe->size != CRUNCH_STORAGE_SIZE)
59 *auxp += CRUNCH_STORAGE_SIZE;
60 crunch_task_restore(current_thread_info(), &kframe->storage);
67 static int preserve_iwmmxt_context(struct iwmmxt_sigframe __user *frame)
69 char kbuf[sizeof(*frame) + 8];
70 struct iwmmxt_sigframe *kframe;
73 /* the iWMMXt context must be 64 bit aligned */
74 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
76 if (test_thread_flag(TIF_USING_IWMMXT)) {
77 kframe->magic = IWMMXT_MAGIC;
78 kframe->size = IWMMXT_STORAGE_SIZE;
79 iwmmxt_task_copy(current_thread_info(), &kframe->storage);
81 err = __copy_to_user(frame, kframe, sizeof(*frame));
84 * For bug-compatibility with older kernels, some space
85 * has to be reserved for iWMMXt even if it's not used.
86 * Set the magic and size appropriately so that properly
87 * written userspace can skip it reliably:
89 __put_user_error(DUMMY_MAGIC, &frame->magic, err);
90 __put_user_error(IWMMXT_STORAGE_SIZE, &frame->size, err);
96 static int restore_iwmmxt_context(char __user **auxp)
98 struct iwmmxt_sigframe __user *frame =
99 (struct iwmmxt_sigframe __user *)*auxp;
100 char kbuf[sizeof(*frame) + 8];
101 struct iwmmxt_sigframe *kframe;
103 /* the iWMMXt context must be 64 bit aligned */
104 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
105 if (__copy_from_user(kframe, frame, sizeof(*frame)))
109 * For non-iWMMXt threads: a single iwmmxt_sigframe-sized dummy
110 * block is discarded for compatibility with setup_sigframe() if
111 * present, but we don't mandate its presence. If some other
112 * magic is here, it's not for us:
114 if (!test_thread_flag(TIF_USING_IWMMXT) &&
115 kframe->magic != DUMMY_MAGIC)
118 if (kframe->size != IWMMXT_STORAGE_SIZE)
121 if (test_thread_flag(TIF_USING_IWMMXT)) {
122 if (kframe->magic != IWMMXT_MAGIC)
125 iwmmxt_task_restore(current_thread_info(), &kframe->storage);
128 *auxp += IWMMXT_STORAGE_SIZE;
136 static int preserve_vfp_context(struct vfp_sigframe __user *frame)
138 const unsigned long magic = VFP_MAGIC;
139 const unsigned long size = VFP_STORAGE_SIZE;
142 __put_user_error(magic, &frame->magic, err);
143 __put_user_error(size, &frame->size, err);
148 return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
151 static int restore_vfp_context(char __user **auxp)
153 struct vfp_sigframe frame;
156 err = __copy_from_user(&frame, *auxp, sizeof(frame));
160 if (frame.magic != VFP_MAGIC || frame.size != VFP_STORAGE_SIZE)
163 *auxp += sizeof(frame);
164 return vfp_restore_user_hwstate(&frame.ufp, &frame.ufp_exc);
170 * Do a signal return; undo the signal stack. These are aligned to 64-bit.
173 static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
175 struct sigcontext context;
180 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
182 set_current_blocked(&set);
184 err |= __copy_from_user(&context, &sf->uc.uc_mcontext, sizeof(context));
186 regs->ARM_r0 = context.arm_r0;
187 regs->ARM_r1 = context.arm_r1;
188 regs->ARM_r2 = context.arm_r2;
189 regs->ARM_r3 = context.arm_r3;
190 regs->ARM_r4 = context.arm_r4;
191 regs->ARM_r5 = context.arm_r5;
192 regs->ARM_r6 = context.arm_r6;
193 regs->ARM_r7 = context.arm_r7;
194 regs->ARM_r8 = context.arm_r8;
195 regs->ARM_r9 = context.arm_r9;
196 regs->ARM_r10 = context.arm_r10;
197 regs->ARM_fp = context.arm_fp;
198 regs->ARM_ip = context.arm_ip;
199 regs->ARM_sp = context.arm_sp;
200 regs->ARM_lr = context.arm_lr;
201 regs->ARM_pc = context.arm_pc;
202 regs->ARM_cpsr = context.arm_cpsr;
205 err |= !valid_user_regs(regs);
207 aux = (char __user *) sf->uc.uc_regspace;
210 err |= restore_crunch_context(&aux);
214 err |= restore_iwmmxt_context(&aux);
218 err |= restore_vfp_context(&aux);
224 asmlinkage int sys_sigreturn(struct pt_regs *regs)
226 struct sigframe __user *frame;
228 /* Always make any pending restarted system calls return -EINTR */
229 current->restart_block.fn = do_no_restart_syscall;
232 * Since we stacked the signal on a 64-bit boundary,
233 * then 'sp' should be word aligned here. If it's
234 * not, then the user is trying to mess with us.
236 if (regs->ARM_sp & 7)
239 frame = (struct sigframe __user *)regs->ARM_sp;
241 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
244 if (restore_sigframe(regs, frame))
250 force_sig(SIGSEGV, current);
254 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
256 struct rt_sigframe __user *frame;
258 /* Always make any pending restarted system calls return -EINTR */
259 current->restart_block.fn = do_no_restart_syscall;
262 * Since we stacked the signal on a 64-bit boundary,
263 * then 'sp' should be word aligned here. If it's
264 * not, then the user is trying to mess with us.
266 if (regs->ARM_sp & 7)
269 frame = (struct rt_sigframe __user *)regs->ARM_sp;
271 if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
274 if (restore_sigframe(regs, &frame->sig))
277 if (restore_altstack(&frame->sig.uc.uc_stack))
283 force_sig(SIGSEGV, current);
288 setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
290 struct aux_sigframe __user *aux;
293 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
294 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
295 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
296 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
297 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
298 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
299 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
300 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
301 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
302 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
303 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
304 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
305 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
306 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
307 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
308 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
309 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
311 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
312 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
313 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
314 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
316 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
318 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
321 err |= preserve_crunch_context(&aux->crunch);
325 err |= preserve_iwmmxt_context(&aux->iwmmxt);
329 err |= preserve_vfp_context(&aux->vfp);
331 __put_user_error(0, &aux->end_magic, err);
336 static inline void __user *
337 get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
339 unsigned long sp = sigsp(regs->ARM_sp, ksig);
343 * ATPCS B01 mandates 8-byte alignment
345 frame = (void __user *)((sp - framesize) & ~7);
348 * Check that we can actually write to the signal frame.
350 if (!access_ok(VERIFY_WRITE, frame, framesize))
357 setup_return(struct pt_regs *regs, struct ksignal *ksig,
358 unsigned long __user *rc, void __user *frame)
360 unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
361 unsigned long handler_fdpic_GOT = 0;
362 unsigned long retcode;
363 unsigned int idx, thumb = 0;
364 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
365 bool fdpic = IS_ENABLED(CONFIG_BINFMT_ELF_FDPIC) &&
366 (current->personality & FDPIC_FUNCPTRS);
369 unsigned long __user *fdpic_func_desc =
370 (unsigned long __user *)handler;
371 if (__get_user(handler, &fdpic_func_desc[0]) ||
372 __get_user(handler_fdpic_GOT, &fdpic_func_desc[1]))
376 cpsr |= PSR_ENDSTATE;
379 * Maybe we need to deliver a 32-bit signal to a 26-bit task.
381 if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
382 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
384 #ifdef CONFIG_ARM_THUMB
385 if (elf_hwcap & HWCAP_THUMB) {
387 * The LSB of the handler determines if we're going to
388 * be using THUMB or ARM mode for this signal handler.
393 * Clear the If-Then Thumb-2 execution state. ARM spec
394 * requires this to be all 000s in ARM mode. Snapdragon
395 * S4/Krait misbehaves on a Thumb=>ARM signal transition
398 * We must do this whenever we are running on a Thumb-2
399 * capable CPU, which includes ARMv6T2. However, we elect
400 * to always do this to simplify the code; this field is
401 * marked UNK/SBZP for older architectures.
403 cpsr &= ~PSR_IT_MASK;
412 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
413 retcode = (unsigned long)ksig->ka.sa.sa_restorer;
416 * We need code to load the function descriptor.
417 * That code follows the standard sigreturn code
418 * (6 words), and is made of 3 + 2 words for each
419 * variant. The 4th copied word is the actual FD
420 * address that the assembly code expects.
423 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
425 if (__put_user(sigreturn_codes[idx], rc ) ||
426 __put_user(sigreturn_codes[idx+1], rc+1) ||
427 __put_user(sigreturn_codes[idx+2], rc+2) ||
428 __put_user(retcode, rc+3))
434 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
438 * Put the sigreturn code on the stack no matter which return
439 * mechanism we use in order to remain ABI compliant
441 if (__put_user(sigreturn_codes[idx], rc) ||
442 __put_user(sigreturn_codes[idx+1], rc+1))
447 if (cpsr & MODE32_BIT) {
448 struct mm_struct *mm = current->mm;
451 * 32-bit code can use the signal return page
452 * except when the MPU has protected the vectors
455 retcode = mm->context.sigpage + signal_return_offset +
461 * Ensure that the instruction cache sees
462 * the return code written onto the stack.
464 flush_icache_range((unsigned long)rc,
465 (unsigned long)(rc + 3));
467 retcode = ((unsigned long)rc) + thumb;
471 regs->ARM_r0 = ksig->sig;
472 regs->ARM_sp = (unsigned long)frame;
473 regs->ARM_lr = retcode;
474 regs->ARM_pc = handler;
476 regs->ARM_r9 = handler_fdpic_GOT;
477 regs->ARM_cpsr = cpsr;
483 setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
485 struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
492 * Set uc.uc_flags to a value which sc.trap_no would never have.
494 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
496 err |= setup_sigframe(frame, regs, set);
498 err = setup_return(regs, ksig, frame->retcode, frame);
504 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
506 struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
512 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
514 __put_user_error(0, &frame->sig.uc.uc_flags, err);
515 __put_user_error(NULL, &frame->sig.uc.uc_link, err);
517 err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
518 err |= setup_sigframe(&frame->sig, regs, set);
520 err = setup_return(regs, ksig, frame->sig.retcode, frame);
524 * For realtime signals we must also set the second and third
525 * arguments for the signal handler.
526 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
528 regs->ARM_r1 = (unsigned long)&frame->info;
529 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
536 * OK, we're invoking a handler
538 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
540 sigset_t *oldset = sigmask_to_save();
544 * Increment event counter and perform fixup for the pre-signal
547 rseq_signal_deliver(ksig, regs);
550 * Set up the stack frame
552 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
553 ret = setup_rt_frame(ksig, oldset, regs);
555 ret = setup_frame(ksig, oldset, regs);
558 * Check that the resulting registers are actually sane.
560 ret |= !valid_user_regs(regs);
562 signal_setup_done(ret, ksig, 0);
566 * Note that 'init' is a special process: it doesn't get signals it doesn't
567 * want to handle. Thus you cannot kill init even with a SIGKILL even by
570 * Note that we go through the signals twice: once to check the signals that
571 * the kernel can handle, and then we build all the user-level signal handling
572 * stack-frames in one go after that.
574 static int do_signal(struct pt_regs *regs, int syscall)
576 unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
581 * If we were from a system call, check for system call restarting...
584 continue_addr = regs->ARM_pc;
585 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
586 retval = regs->ARM_r0;
589 * Prepare for system call restart. We do this here so that a
590 * debugger will see the already changed PSW.
593 case -ERESTART_RESTARTBLOCK:
595 case -ERESTARTNOHAND:
597 case -ERESTARTNOINTR:
599 regs->ARM_r0 = regs->ARM_ORIG_r0;
600 regs->ARM_pc = restart_addr;
606 * Get the signal to deliver. When running under ptrace, at this
607 * point the debugger may change all our registers ...
610 * Depending on the signal settings we may need to revert the
611 * decision to restart the system call. But skip this if a
612 * debugger has chosen to restart at a different PC.
614 if (get_signal(&ksig)) {
616 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
617 if (retval == -ERESTARTNOHAND ||
618 retval == -ERESTART_RESTARTBLOCK
619 || (retval == -ERESTARTSYS
620 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
621 regs->ARM_r0 = -EINTR;
622 regs->ARM_pc = continue_addr;
625 handle_signal(&ksig, regs);
628 restore_saved_sigmask();
629 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
630 regs->ARM_pc = continue_addr;
638 do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
641 * The assembly code enters us with IRQs off, but it hasn't
642 * informed the tracing code of that for efficiency reasons.
643 * Update the trace code with the current status.
645 trace_hardirqs_off();
647 if (likely(thread_flags & _TIF_NEED_RESCHED)) {
650 if (unlikely(!user_mode(regs)))
653 if (thread_flags & _TIF_SIGPENDING) {
654 int restart = do_signal(regs, syscall);
655 if (unlikely(restart)) {
657 * Restart without handlers.
658 * Deal with it without leaving
664 } else if (thread_flags & _TIF_UPROBE) {
665 uprobe_notify_resume(regs);
667 clear_thread_flag(TIF_NOTIFY_RESUME);
668 tracehook_notify_resume(regs);
669 rseq_handle_notify_resume(NULL, regs);
673 thread_flags = current_thread_info()->flags;
674 } while (thread_flags & _TIF_WORK_MASK);
678 struct page *get_signal_page(void)
685 page = alloc_pages(GFP_KERNEL, 0);
690 addr = page_address(page);
692 /* Give the signal return code some randomness */
693 offset = 0x200 + (get_random_int() & 0x7fc);
694 signal_return_offset = offset;
697 * Copy signal return handlers into the vector page, and
698 * set sigreturn to be a pointer to these.
700 memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
702 ptr = (unsigned long)addr + offset;
703 flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
708 /* Defer to generic check */
709 asmlinkage void addr_limit_check_failed(void)
711 addr_limit_user_check();
714 #ifdef CONFIG_DEBUG_RSEQ
715 asmlinkage void do_rseq_syscall(struct pt_regs *regs)