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/errno.h>
21 #include <linux/signal.h>
22 #include <linux/personality.h>
23 #include <linux/freezer.h>
24 #include <linux/uaccess.h>
25 #include <linux/tracehook.h>
26 #include <linux/ratelimit.h>
28 #include <asm/compat.h>
29 #include <asm/debug-monitors.h>
31 #include <asm/cacheflush.h>
32 #include <asm/ucontext.h>
33 #include <asm/unistd.h>
34 #include <asm/fpsimd.h>
35 #include <asm/signal32.h>
39 * Do a signal return; undo the signal stack. These are aligned to 128-bit.
46 static int preserve_fpsimd_context(struct fpsimd_context __user
*ctx
)
48 struct fpsimd_state
*fpsimd
= ¤t
->thread
.fpsimd_state
;
51 /* dump the hardware registers to the fpsimd_state structure */
52 fpsimd_save_state(fpsimd
);
54 /* copy the FP and status/control registers */
55 err
= __copy_to_user(ctx
->vregs
, fpsimd
->vregs
, sizeof(fpsimd
->vregs
));
56 __put_user_error(fpsimd
->fpsr
, &ctx
->fpsr
, err
);
57 __put_user_error(fpsimd
->fpcr
, &ctx
->fpcr
, err
);
59 /* copy the magic/size information */
60 __put_user_error(FPSIMD_MAGIC
, &ctx
->head
.magic
, err
);
61 __put_user_error(sizeof(struct fpsimd_context
), &ctx
->head
.size
, err
);
63 return err
? -EFAULT
: 0;
66 static int restore_fpsimd_context(struct fpsimd_context __user
*ctx
)
68 struct fpsimd_state fpsimd
;
72 /* check the magic/size information */
73 __get_user_error(magic
, &ctx
->head
.magic
, err
);
74 __get_user_error(size
, &ctx
->head
.size
, err
);
77 if (magic
!= FPSIMD_MAGIC
|| size
!= sizeof(struct fpsimd_context
))
80 /* copy the FP and status/control registers */
81 err
= __copy_from_user(fpsimd
.vregs
, ctx
->vregs
,
82 sizeof(fpsimd
.vregs
));
83 __get_user_error(fpsimd
.fpsr
, &ctx
->fpsr
, err
);
84 __get_user_error(fpsimd
.fpcr
, &ctx
->fpcr
, err
);
86 /* load the hardware registers from the fpsimd_state structure */
89 fpsimd_load_state(&fpsimd
);
93 return err
? -EFAULT
: 0;
96 static int restore_sigframe(struct pt_regs
*regs
,
97 struct rt_sigframe __user
*sf
)
101 struct aux_context __user
*aux
=
102 (struct aux_context __user
*)sf
->uc
.uc_mcontext
.__reserved
;
104 err
= __copy_from_user(&set
, &sf
->uc
.uc_sigmask
, sizeof(set
));
106 set_current_blocked(&set
);
108 for (i
= 0; i
< 31; i
++)
109 __get_user_error(regs
->regs
[i
], &sf
->uc
.uc_mcontext
.regs
[i
],
111 __get_user_error(regs
->sp
, &sf
->uc
.uc_mcontext
.sp
, err
);
112 __get_user_error(regs
->pc
, &sf
->uc
.uc_mcontext
.pc
, err
);
113 __get_user_error(regs
->pstate
, &sf
->uc
.uc_mcontext
.pstate
, err
);
116 * Avoid sys_rt_sigreturn() restarting.
118 regs
->syscallno
= ~0UL;
120 err
|= !valid_user_regs(®s
->user_regs
);
123 err
|= restore_fpsimd_context(&aux
->fpsimd
);
128 asmlinkage
long sys_rt_sigreturn(struct pt_regs
*regs
)
130 struct rt_sigframe __user
*frame
;
132 /* Always make any pending restarted system calls return -EINTR */
133 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
136 * Since we stacked the signal on a 128-bit boundary, then 'sp' should
137 * be word aligned here.
142 frame
= (struct rt_sigframe __user
*)regs
->sp
;
144 if (!access_ok(VERIFY_READ
, frame
, sizeof (*frame
)))
147 if (restore_sigframe(regs
, frame
))
150 if (do_sigaltstack(&frame
->uc
.uc_stack
,
151 NULL
, regs
->sp
) == -EFAULT
)
154 return regs
->regs
[0];
157 if (show_unhandled_signals
)
158 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
159 current
->comm
, task_pid_nr(current
), __func__
,
161 force_sig(SIGSEGV
, current
);
165 asmlinkage
long sys_sigaltstack(const stack_t __user
*uss
, stack_t __user
*uoss
,
168 return do_sigaltstack(uss
, uoss
, sp
);
171 static int setup_sigframe(struct rt_sigframe __user
*sf
,
172 struct pt_regs
*regs
, sigset_t
*set
)
175 struct aux_context __user
*aux
=
176 (struct aux_context __user
*)sf
->uc
.uc_mcontext
.__reserved
;
178 for (i
= 0; i
< 31; i
++)
179 __put_user_error(regs
->regs
[i
], &sf
->uc
.uc_mcontext
.regs
[i
],
181 __put_user_error(regs
->sp
, &sf
->uc
.uc_mcontext
.sp
, err
);
182 __put_user_error(regs
->pc
, &sf
->uc
.uc_mcontext
.pc
, err
);
183 __put_user_error(regs
->pstate
, &sf
->uc
.uc_mcontext
.pstate
, err
);
185 __put_user_error(current
->thread
.fault_address
, &sf
->uc
.uc_mcontext
.fault_address
, err
);
187 err
|= __copy_to_user(&sf
->uc
.uc_sigmask
, set
, sizeof(*set
));
190 err
|= preserve_fpsimd_context(&aux
->fpsimd
);
192 /* set the "end" magic */
193 __put_user_error(0, &aux
->end
.magic
, err
);
194 __put_user_error(0, &aux
->end
.size
, err
);
199 static void __user
*get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
,
202 unsigned long sp
, sp_top
;
205 sp
= sp_top
= regs
->sp
;
208 * This is the X/Open sanctioned signal stack switching.
210 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && !sas_ss_flags(sp
))
211 sp
= sp_top
= current
->sas_ss_sp
+ current
->sas_ss_size
;
213 /* room for stack frame (FP, LR) */
216 sp
= (sp
- framesize
) & ~15;
217 frame
= (void __user
*)sp
;
220 * Check that we can actually write to the signal frame.
222 if (!access_ok(VERIFY_WRITE
, frame
, sp_top
- sp
))
228 static int setup_return(struct pt_regs
*regs
, struct k_sigaction
*ka
,
229 void __user
*frame
, int usig
)
232 __sigrestore_t sigtramp
;
233 unsigned long __user
*sp
= (unsigned long __user
*)regs
->sp
;
235 /* set up the stack frame */
236 __put_user_error(regs
->regs
[29], sp
- 2, err
);
237 __put_user_error(regs
->regs
[30], sp
- 1, err
);
239 regs
->regs
[0] = usig
;
240 regs
->regs
[29] = regs
->sp
- 16;
241 regs
->sp
= (unsigned long)frame
;
242 regs
->pc
= (unsigned long)ka
->sa
.sa_handler
;
244 if (ka
->sa
.sa_flags
& SA_RESTORER
)
245 sigtramp
= ka
->sa
.sa_restorer
;
247 sigtramp
= VDSO_SYMBOL(current
->mm
->context
.vdso
, sigtramp
);
249 regs
->regs
[30] = (unsigned long)sigtramp
;
254 static int setup_rt_frame(int usig
, struct k_sigaction
*ka
, siginfo_t
*info
,
255 sigset_t
*set
, struct pt_regs
*regs
)
257 struct rt_sigframe __user
*frame
;
261 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
265 __put_user_error(0, &frame
->uc
.uc_flags
, err
);
266 __put_user_error(NULL
, &frame
->uc
.uc_link
, err
);
268 memset(&stack
, 0, sizeof(stack
));
269 stack
.ss_sp
= (void __user
*)current
->sas_ss_sp
;
270 stack
.ss_flags
= sas_ss_flags(regs
->sp
);
271 stack
.ss_size
= current
->sas_ss_size
;
272 err
|= __copy_to_user(&frame
->uc
.uc_stack
, &stack
, sizeof(stack
));
274 err
|= setup_sigframe(frame
, regs
, set
);
276 err
= setup_return(regs
, ka
, frame
, usig
);
278 if (err
== 0 && ka
->sa
.sa_flags
& SA_SIGINFO
) {
279 err
|= copy_siginfo_to_user(&frame
->info
, info
);
280 regs
->regs
[1] = (unsigned long)&frame
->info
;
281 regs
->regs
[2] = (unsigned long)&frame
->uc
;
287 static void setup_restart_syscall(struct pt_regs
*regs
)
289 if (is_compat_task())
290 compat_setup_restart_syscall(regs
);
292 regs
->regs
[8] = __NR_restart_syscall
;
296 * OK, we're invoking a handler
298 static void handle_signal(unsigned long sig
, struct k_sigaction
*ka
,
299 siginfo_t
*info
, struct pt_regs
*regs
)
301 struct thread_info
*thread
= current_thread_info();
302 struct task_struct
*tsk
= current
;
303 sigset_t
*oldset
= sigmask_to_save();
308 * translate the signal
310 if (usig
< 32 && thread
->exec_domain
&& thread
->exec_domain
->signal_invmap
)
311 usig
= thread
->exec_domain
->signal_invmap
[usig
];
314 * Set up the stack frame
316 if (is_compat_task()) {
317 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
318 ret
= compat_setup_rt_frame(usig
, ka
, info
, oldset
,
321 ret
= compat_setup_frame(usig
, ka
, oldset
, regs
);
323 ret
= setup_rt_frame(usig
, ka
, info
, oldset
, regs
);
327 * Check that the resulting registers are actually sane.
329 ret
|= !valid_user_regs(®s
->user_regs
);
332 force_sigsegv(sig
, tsk
);
337 * Fast forward the stepping logic so we step into the signal
340 user_fastforward_single_step(tsk
);
342 signal_delivered(sig
, info
, ka
, regs
, 0);
346 * Note that 'init' is a special process: it doesn't get signals it doesn't
347 * want to handle. Thus you cannot kill init even with a SIGKILL even by
350 * Note that we go through the signals twice: once to check the signals that
351 * the kernel can handle, and then we build all the user-level signal handling
352 * stack-frames in one go after that.
354 static void do_signal(struct pt_regs
*regs
)
356 unsigned long continue_addr
= 0, restart_addr
= 0;
357 struct k_sigaction ka
;
359 int signr
, retval
= 0;
360 int syscall
= (int)regs
->syscallno
;
363 * If we were from a system call, check for system call restarting...
366 continue_addr
= regs
->pc
;
367 restart_addr
= continue_addr
- (compat_thumb_mode(regs
) ? 2 : 4);
368 retval
= regs
->regs
[0];
371 * Avoid additional syscall restarting via ret_to_user.
373 regs
->syscallno
= ~0UL;
376 * Prepare for system call restart. We do this here so that a
377 * debugger will see the already changed PC.
380 case -ERESTARTNOHAND
:
382 case -ERESTARTNOINTR
:
383 case -ERESTART_RESTARTBLOCK
:
384 regs
->regs
[0] = regs
->orig_x0
;
385 regs
->pc
= restart_addr
;
391 * Get the signal to deliver. When running under ptrace, at this point
392 * the debugger may change all of our registers.
394 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
397 * Depending on the signal settings, we may need to revert the
398 * decision to restart the system call, but skip this if a
399 * debugger has chosen to restart at a different PC.
401 if (regs
->pc
== restart_addr
&&
402 (retval
== -ERESTARTNOHAND
||
403 retval
== -ERESTART_RESTARTBLOCK
||
404 (retval
== -ERESTARTSYS
&&
405 !(ka
.sa
.sa_flags
& SA_RESTART
)))) {
406 regs
->regs
[0] = -EINTR
;
407 regs
->pc
= continue_addr
;
410 handle_signal(signr
, &ka
, &info
, regs
);
415 * Handle restarting a different system call. As above, if a debugger
416 * has chosen to restart at a different PC, ignore the restart.
418 if (syscall
>= 0 && regs
->pc
== restart_addr
) {
419 if (retval
== -ERESTART_RESTARTBLOCK
)
420 setup_restart_syscall(regs
);
421 user_rewind_single_step(current
);
424 restore_saved_sigmask();
427 asmlinkage
void do_notify_resume(struct pt_regs
*regs
,
428 unsigned int thread_flags
)
430 if (thread_flags
& _TIF_SIGPENDING
)
433 if (thread_flags
& _TIF_NOTIFY_RESUME
) {
434 clear_thread_flag(TIF_NOTIFY_RESUME
);
435 tracehook_notify_resume(regs
);