2 * Copyright 2004-2010 Analog Devices Inc.
4 * Licensed under the GPL-2 or later
7 #include <linux/signal.h>
8 #include <linux/syscalls.h>
9 #include <linux/ptrace.h>
10 #include <linux/tty.h>
11 #include <linux/personality.h>
12 #include <linux/binfmts.h>
13 #include <linux/freezer.h>
14 #include <linux/uaccess.h>
15 #include <linux/tracehook.h>
17 #include <asm/cacheflush.h>
18 #include <asm/ucontext.h>
19 #include <asm/fixed_code.h>
20 #include <asm/syscall.h>
22 /* Location of the trace bit in SYSCFG. */
23 #define TRACE_BITS 0x0001
25 struct fdpic_func_descriptor
{
32 struct siginfo
*pinfo
;
34 /* This is no longer needed by the kernel, but unfortunately userspace
35 * code expects it to be there. */
41 asmlinkage
int sys_sigaltstack(const stack_t __user
*uss
, stack_t __user
*uoss
)
43 return do_sigaltstack(uss
, uoss
, rdusp());
47 rt_restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
, int *pr0
)
49 unsigned long usp
= 0;
52 /* Always make any pending restarted system calls return -EINTR */
53 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
55 #define RESTORE(x) err |= __get_user(regs->x, &sc->sc_##x)
57 /* restore passed registers */
58 RESTORE(r0
); RESTORE(r1
); RESTORE(r2
); RESTORE(r3
);
59 RESTORE(r4
); RESTORE(r5
); RESTORE(r6
); RESTORE(r7
);
60 RESTORE(p0
); RESTORE(p1
); RESTORE(p2
); RESTORE(p3
);
61 RESTORE(p4
); RESTORE(p5
);
62 err
|= __get_user(usp
, &sc
->sc_usp
);
64 RESTORE(a0w
); RESTORE(a1w
);
65 RESTORE(a0x
); RESTORE(a1x
);
71 RESTORE(i0
); RESTORE(i1
); RESTORE(i2
); RESTORE(i3
);
72 RESTORE(m0
); RESTORE(m1
); RESTORE(m2
); RESTORE(m3
);
73 RESTORE(l0
); RESTORE(l1
); RESTORE(l2
); RESTORE(l3
);
74 RESTORE(b0
); RESTORE(b1
); RESTORE(b2
); RESTORE(b3
);
75 RESTORE(lc0
); RESTORE(lc1
);
76 RESTORE(lt0
); RESTORE(lt1
);
77 RESTORE(lb0
); RESTORE(lb1
);
80 regs
->orig_p0
= -1; /* disable syscall checks */
86 asmlinkage
int do_rt_sigreturn(unsigned long __unused
)
88 struct pt_regs
*regs
= (struct pt_regs
*)__unused
;
89 unsigned long usp
= rdusp();
90 struct rt_sigframe
*frame
= (struct rt_sigframe
*)(usp
);
94 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
96 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
99 set_current_blocked(&set
);
101 if (rt_restore_sigcontext(regs
, &frame
->uc
.uc_mcontext
, &r0
))
104 if (do_sigaltstack(&frame
->uc
.uc_stack
, NULL
, regs
->usp
) == -EFAULT
)
110 force_sig(SIGSEGV
, current
);
114 static inline int rt_setup_sigcontext(struct sigcontext
*sc
, struct pt_regs
*regs
)
118 #define SETUP(x) err |= __put_user(regs->x, &sc->sc_##x)
120 SETUP(r0
); SETUP(r1
); SETUP(r2
); SETUP(r3
);
121 SETUP(r4
); SETUP(r5
); SETUP(r6
); SETUP(r7
);
122 SETUP(p0
); SETUP(p1
); SETUP(p2
); SETUP(p3
);
123 SETUP(p4
); SETUP(p5
);
124 err
|= __put_user(rdusp(), &sc
->sc_usp
);
125 SETUP(a0w
); SETUP(a1w
);
126 SETUP(a0x
); SETUP(a1x
);
132 SETUP(i0
); SETUP(i1
); SETUP(i2
); SETUP(i3
);
133 SETUP(m0
); SETUP(m1
); SETUP(m2
); SETUP(m3
);
134 SETUP(l0
); SETUP(l1
); SETUP(l2
); SETUP(l3
);
135 SETUP(b0
); SETUP(b1
); SETUP(b2
); SETUP(b3
);
136 SETUP(lc0
); SETUP(lc1
);
137 SETUP(lt0
); SETUP(lt1
);
138 SETUP(lb0
); SETUP(lb1
);
144 static inline void *get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
,
149 /* Default to using normal stack. */
152 /* This is the X/Open sanctioned signal stack switching. */
153 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
154 if (!on_sig_stack(usp
))
155 usp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
157 return (void *)((usp
- frame_size
) & -8UL);
161 setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
* info
,
162 sigset_t
* set
, struct pt_regs
*regs
)
164 struct rt_sigframe
*frame
;
167 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
169 err
|= __put_user((current_thread_info()->exec_domain
170 && current_thread_info()->exec_domain
->signal_invmap
172 ? current_thread_info()->exec_domain
->
173 signal_invmap
[sig
] : sig
), &frame
->sig
);
175 err
|= __put_user(&frame
->info
, &frame
->pinfo
);
176 err
|= __put_user(&frame
->uc
, &frame
->puc
);
177 err
|= copy_siginfo_to_user(&frame
->info
, info
);
179 /* Create the ucontext. */
180 err
|= __put_user(0, &frame
->uc
.uc_flags
);
181 err
|= __put_user(0, &frame
->uc
.uc_link
);
183 __put_user((void *)current
->sas_ss_sp
, &frame
->uc
.uc_stack
.ss_sp
);
184 err
|= __put_user(sas_ss_flags(rdusp()), &frame
->uc
.uc_stack
.ss_flags
);
185 err
|= __put_user(current
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
186 err
|= rt_setup_sigcontext(&frame
->uc
.uc_mcontext
, regs
);
187 err
|= copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
192 /* Set up registers for signal handler */
193 wrusp((unsigned long)frame
);
194 if (current
->personality
& FDPIC_FUNCPTRS
) {
195 struct fdpic_func_descriptor __user
*funcptr
=
196 (struct fdpic_func_descriptor
*) ka
->sa
.sa_handler
;
197 __get_user(regs
->pc
, &funcptr
->text
);
198 __get_user(regs
->p3
, &funcptr
->GOT
);
200 regs
->pc
= (unsigned long)ka
->sa
.sa_handler
;
201 regs
->rets
= SIGRETURN_STUB
;
203 regs
->r0
= frame
->sig
;
204 regs
->r1
= (unsigned long)(&frame
->info
);
205 regs
->r2
= (unsigned long)(&frame
->uc
);
210 force_sigsegv(sig
, current
);
215 handle_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
, int has_handler
)
218 case -ERESTARTNOHAND
:
225 if (has_handler
&& !(ka
->sa
.sa_flags
& SA_RESTART
)) {
230 case -ERESTARTNOINTR
:
232 regs
->p0
= regs
->orig_p0
;
233 regs
->r0
= regs
->orig_r0
;
237 case -ERESTART_RESTARTBLOCK
:
238 regs
->p0
= __NR_restart_syscall
;
245 * OK, we're invoking a handler
248 handle_signal(int sig
, siginfo_t
*info
, struct k_sigaction
*ka
,
249 struct pt_regs
*regs
)
253 /* are we from a system call? to see pt_regs->orig_p0 */
254 if (regs
->orig_p0
>= 0)
255 /* If so, check system call restarting.. */
256 handle_restart(regs
, ka
, 1);
258 /* set up the stack frame */
259 ret
= setup_rt_frame(sig
, ka
, info
, sigmask_to_save(), regs
);
263 signal_delivered(sig
, info
, ka
, regs
,
264 test_thread_flag(TIF_SINGLESTEP
));
268 * Note that 'init' is a special process: it doesn't get signals it doesn't
269 * want to handle. Thus you cannot kill init even with a SIGKILL even by
272 * Note that we go through the signals twice: once to check the signals
273 * that the kernel can handle, and then we build all the user-level signal
274 * handling stack-frames in one go after that.
276 asmlinkage
void do_signal(struct pt_regs
*regs
)
280 struct k_sigaction ka
;
282 current
->thread
.esp0
= (unsigned long)regs
;
284 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
286 /* Whee! Actually deliver the signal. */
287 handle_signal(signr
, &info
, &ka
, regs
);
291 /* Did we come from a system call? */
292 if (regs
->orig_p0
>= 0)
293 /* Restart the system call - no handlers present */
294 handle_restart(regs
, NULL
, 0);
296 /* if there's no signal to deliver, we just put the saved sigmask
298 restore_saved_sigmask();
302 * notification of userspace execution resumption
304 asmlinkage
void do_notify_resume(struct pt_regs
*regs
)
306 if (test_thread_flag(TIF_SIGPENDING
))
309 if (test_thread_flag(TIF_NOTIFY_RESUME
)) {
310 clear_thread_flag(TIF_NOTIFY_RESUME
);
311 tracehook_notify_resume(regs
);