2 * arch/xtensa/kernel/signal.c
4 * Default platform functions.
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
10 * Copyright (C) 2005, 2006 Tensilica Inc.
11 * Copyright (C) 1991, 1992 Linus Torvalds
12 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
14 * Chris Zankel <chris@zankel.net>
15 * Joe Taylor <joe@tensilica.com>
18 #include <linux/signal.h>
19 #include <linux/errno.h>
20 #include <linux/ptrace.h>
21 #include <linux/personality.h>
22 #include <linux/tracehook.h>
23 #include <linux/sched/task_stack.h>
25 #include <asm/ucontext.h>
26 #include <linux/uaccess.h>
27 #include <asm/cacheflush.h>
28 #include <asm/coprocessor.h>
29 #include <asm/unistd.h>
33 extern struct task_struct
*coproc_owners
[];
42 #if XTENSA_HAVE_COPROCESSORS
43 xtregs_coprocessor_t cp
;
46 unsigned char retcode
[6];
47 unsigned int window
[4];
51 * Flush register windows stored in pt_regs to stack.
52 * Returns 1 for errors.
56 flush_window_regs_user(struct pt_regs
*regs
)
58 const unsigned long ws
= regs
->windowstart
;
59 const unsigned long wb
= regs
->windowbase
;
65 /* Return if no other frames. */
70 /* Rotate windowmask and skip empty frames. */
72 wm
= (ws
>> wb
) | (ws
<< (XCHAL_NUM_AREGS
/ 4 - wb
));
73 base
= (XCHAL_NUM_AREGS
/ 4) - (regs
->wmask
>> 4);
75 /* For call8 or call12 frames, we need the previous stack pointer. */
77 if ((regs
->wmask
& 2) == 0)
78 if (__get_user(sp
, (int*)(regs
->areg
[base
* 4 + 1] - 12)))
81 /* Spill frames to stack. */
83 while (base
< XCHAL_NUM_AREGS
/ 4) {
88 /* Save registers a4..a7 (call8) or a4...a11 (call12) */
90 if (m
& 2) { /* call4 */
93 } else if (m
& 4) { /* call8 */
94 if (copy_to_user(&SPILL_SLOT_CALL8(sp
, 4),
95 ®s
->areg
[(base
+ 1) * 4], 16))
99 } else if (m
& 8) { /* call12 */
100 if (copy_to_user(&SPILL_SLOT_CALL12(sp
, 4),
101 ®s
->areg
[(base
+ 1) * 4], 32))
106 /* Save current frame a0..a3 under next SP */
108 sp
= regs
->areg
[((base
+ inc
) * 4 + 1) % XCHAL_NUM_AREGS
];
109 if (copy_to_user(&SPILL_SLOT(sp
, 0), ®s
->areg
[base
* 4], 16))
112 /* Get current stack pointer for next loop iteration. */
114 sp
= regs
->areg
[base
* 4 + 1];
119 regs
->windowstart
= 1 << wb
;
128 * Note: We don't copy double exception 'regs', we have to finish double exc.
129 * first before we return to signal handler! This dbl.exc.handler might cause
130 * another double exception, but I think we are fine as the situation is the
131 * same as if we had returned to the signal handerl and got an interrupt
136 setup_sigcontext(struct rt_sigframe __user
*frame
, struct pt_regs
*regs
)
138 struct sigcontext __user
*sc
= &frame
->uc
.uc_mcontext
;
139 struct thread_info
*ti
= current_thread_info();
142 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
151 err
|= flush_window_regs_user(regs
);
152 err
|= __copy_to_user (sc
->sc_a
, regs
->areg
, 16 * 4);
153 err
|= __put_user(0, &sc
->sc_xtregs
);
158 #if XTENSA_HAVE_COPROCESSORS
159 coprocessor_flush_all(ti
);
160 coprocessor_release_all(ti
);
161 err
|= __copy_to_user(&frame
->xtregs
.cp
, &ti
->xtregs_cp
,
162 sizeof (frame
->xtregs
.cp
));
164 err
|= __copy_to_user(&frame
->xtregs
.opt
, ®s
->xtregs_opt
,
165 sizeof (xtregs_opt_t
));
166 err
|= __copy_to_user(&frame
->xtregs
.user
, &ti
->xtregs_user
,
167 sizeof (xtregs_user_t
));
169 err
|= __put_user(err
? NULL
: &frame
->xtregs
, &sc
->sc_xtregs
);
175 restore_sigcontext(struct pt_regs
*regs
, struct rt_sigframe __user
*frame
)
177 struct sigcontext __user
*sc
= &frame
->uc
.uc_mcontext
;
178 struct thread_info
*ti
= current_thread_info();
179 unsigned int err
= 0;
182 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
190 /* All registers were flushed to stack. Start with a prestine frame. */
193 regs
->windowbase
= 0;
194 regs
->windowstart
= 1;
196 regs
->syscall
= -1; /* disable syscall checks */
198 /* For PS, restore only PS.CALLINC.
199 * Assume that all other bits are either the same as for the signal
200 * handler, or the user mode value doesn't matter (e.g. PS.OWB).
202 err
|= __get_user(ps
, &sc
->sc_ps
);
203 regs
->ps
= (regs
->ps
& ~PS_CALLINC_MASK
) | (ps
& PS_CALLINC_MASK
);
205 /* Additional corruption checks */
207 if ((regs
->lcount
> 0)
208 && ((regs
->lbeg
> TASK_SIZE
) || (regs
->lend
> TASK_SIZE
)) )
211 err
|= __copy_from_user(regs
->areg
, sc
->sc_a
, 16 * 4);
216 /* The signal handler may have used coprocessors in which
217 * case they are still enabled. We disable them to force a
218 * reloading of the original task's CP state by the lazy
219 * context-switching mechanisms of CP exception handling.
220 * Also, we essentially discard any coprocessor state that the
221 * signal handler created. */
223 #if XTENSA_HAVE_COPROCESSORS
224 coprocessor_release_all(ti
);
225 err
|= __copy_from_user(&ti
->xtregs_cp
, &frame
->xtregs
.cp
,
226 sizeof (frame
->xtregs
.cp
));
228 err
|= __copy_from_user(&ti
->xtregs_user
, &frame
->xtregs
.user
,
229 sizeof (xtregs_user_t
));
230 err
|= __copy_from_user(®s
->xtregs_opt
, &frame
->xtregs
.opt
,
231 sizeof (xtregs_opt_t
));
238 * Do a signal return; undo the signal stack.
241 asmlinkage
long xtensa_rt_sigreturn(long a0
, long a1
, long a2
, long a3
,
242 long a4
, long a5
, struct pt_regs
*regs
)
244 struct rt_sigframe __user
*frame
;
248 /* Always make any pending restarted system calls return -EINTR */
249 current
->restart_block
.fn
= do_no_restart_syscall
;
252 panic("rt_sigreturn in double exception!\n");
254 frame
= (struct rt_sigframe __user
*) regs
->areg
[1];
256 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
259 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
262 set_current_blocked(&set
);
264 if (restore_sigcontext(regs
, frame
))
269 if (restore_altstack(&frame
->uc
.uc_stack
))
275 force_sig(SIGSEGV
, current
);
282 * Set up a signal frame.
286 gen_return_code(unsigned char *codemem
)
291 * The 12-bit immediate is really split up within the 24-bit MOVI
292 * instruction. As long as the above system call numbers fit within
293 * 8-bits, the following code works fine. See the Xtensa ISA for
297 #if __NR_rt_sigreturn > 255
298 # error Generating the MOVI instruction below breaks!
301 #ifdef __XTENSA_EB__ /* Big Endian version */
302 /* Generate instruction: MOVI a2, __NR_rt_sigreturn */
303 err
|= __put_user(0x22, &codemem
[0]);
304 err
|= __put_user(0x0a, &codemem
[1]);
305 err
|= __put_user(__NR_rt_sigreturn
, &codemem
[2]);
306 /* Generate instruction: SYSCALL */
307 err
|= __put_user(0x00, &codemem
[3]);
308 err
|= __put_user(0x05, &codemem
[4]);
309 err
|= __put_user(0x00, &codemem
[5]);
311 #elif defined __XTENSA_EL__ /* Little Endian version */
312 /* Generate instruction: MOVI a2, __NR_rt_sigreturn */
313 err
|= __put_user(0x22, &codemem
[0]);
314 err
|= __put_user(0xa0, &codemem
[1]);
315 err
|= __put_user(__NR_rt_sigreturn
, &codemem
[2]);
316 /* Generate instruction: SYSCALL */
317 err
|= __put_user(0x00, &codemem
[3]);
318 err
|= __put_user(0x50, &codemem
[4]);
319 err
|= __put_user(0x00, &codemem
[5]);
321 # error Must use compiler for Xtensa processors.
324 /* Flush generated code out of the data cache */
327 __invalidate_icache_range((unsigned long)codemem
, 6UL);
328 __flush_invalidate_dcache_range((unsigned long)codemem
, 6UL);
335 static int setup_frame(struct ksignal
*ksig
, sigset_t
*set
,
336 struct pt_regs
*regs
)
338 struct rt_sigframe
*frame
;
339 int err
= 0, sig
= ksig
->sig
;
340 unsigned long sp
, ra
, tp
;
344 if ((ksig
->ka
.sa
.sa_flags
& SA_ONSTACK
) != 0 && sas_ss_flags(sp
) == 0) {
345 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
348 frame
= (void *)((sp
- sizeof(*frame
)) & -16ul);
351 panic ("Double exception sys_sigreturn\n");
353 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
))) {
357 if (ksig
->ka
.sa
.sa_flags
& SA_SIGINFO
) {
358 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
361 /* Create the user context. */
363 err
|= __put_user(0, &frame
->uc
.uc_flags
);
364 err
|= __put_user(0, &frame
->uc
.uc_link
);
365 err
|= __save_altstack(&frame
->uc
.uc_stack
, regs
->areg
[1]);
366 err
|= setup_sigcontext(frame
, regs
);
367 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
369 if (ksig
->ka
.sa
.sa_flags
& SA_RESTORER
) {
370 ra
= (unsigned long)ksig
->ka
.sa
.sa_restorer
;
373 /* Create sys_rt_sigreturn syscall in stack frame */
375 err
|= gen_return_code(frame
->retcode
);
380 ra
= (unsigned long) frame
->retcode
;
384 * Create signal handler execution context.
385 * Return context not modified until this point.
388 /* Set up registers for signal handler; preserve the threadptr */
389 tp
= regs
->threadptr
;
390 start_thread(regs
, (unsigned long) ksig
->ka
.sa
.sa_handler
,
391 (unsigned long) frame
);
393 /* Set up a stack frame for a call4
394 * Note: PS.CALLINC is set to one by start_thread
396 regs
->areg
[4] = (((unsigned long) ra
) & 0x3fffffff) | 0x40000000;
397 regs
->areg
[6] = (unsigned long) sig
;
398 regs
->areg
[7] = (unsigned long) &frame
->info
;
399 regs
->areg
[8] = (unsigned long) &frame
->uc
;
400 regs
->threadptr
= tp
;
403 printk("SIG rt deliver (%s:%d): signal=%d sp=%p pc=%08x\n",
404 current
->comm
, current
->pid
, sig
, frame
, regs
->pc
);
411 * Note that 'init' is a special process: it doesn't get signals it doesn't
412 * want to handle. Thus you cannot kill init even with a SIGKILL even by
415 * Note that we go through the signals twice: once to check the signals that
416 * the kernel can handle, and then we build all the user-level signal handling
417 * stack-frames in one go after that.
419 static void do_signal(struct pt_regs
*regs
)
423 task_pt_regs(current
)->icountlevel
= 0;
425 if (get_signal(&ksig
)) {
428 /* Are we from a system call? */
430 if ((signed)regs
->syscall
>= 0) {
432 /* If so, check system call restarting.. */
434 switch (regs
->areg
[2]) {
435 case -ERESTARTNOHAND
:
436 case -ERESTART_RESTARTBLOCK
:
437 regs
->areg
[2] = -EINTR
;
441 if (!(ksig
.ka
.sa
.sa_flags
& SA_RESTART
)) {
442 regs
->areg
[2] = -EINTR
;
446 case -ERESTARTNOINTR
:
447 regs
->areg
[2] = regs
->syscall
;
453 if (regs
->areg
[2] != 0)
458 /* Whee! Actually deliver the signal. */
459 /* Set up the stack frame */
460 ret
= setup_frame(&ksig
, sigmask_to_save(), regs
);
461 signal_setup_done(ret
, &ksig
, 0);
462 if (current
->ptrace
& PT_SINGLESTEP
)
463 task_pt_regs(current
)->icountlevel
= 1;
468 /* Did we come from a system call? */
469 if ((signed) regs
->syscall
>= 0) {
470 /* Restart the system call - no handlers present */
471 switch (regs
->areg
[2]) {
472 case -ERESTARTNOHAND
:
474 case -ERESTARTNOINTR
:
475 regs
->areg
[2] = regs
->syscall
;
478 case -ERESTART_RESTARTBLOCK
:
479 regs
->areg
[2] = __NR_restart_syscall
;
485 /* If there's no signal to deliver, we just restore the saved mask. */
486 restore_saved_sigmask();
488 if (current
->ptrace
& PT_SINGLESTEP
)
489 task_pt_regs(current
)->icountlevel
= 1;
493 void do_notify_resume(struct pt_regs
*regs
)
495 if (test_thread_flag(TIF_SIGPENDING
))
498 if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME
))
499 tracehook_notify_resume(regs
);