1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/sched.h>
22#include <linux/mm.h>
23#include <linux/smp.h>
24#include <linux/kernel.h>
25#include <linux/signal.h>
26#include <linux/errno.h>
27#include <linux/wait.h>
28#include <linux/ptrace.h>
29#include <linux/unistd.h>
30#include <linux/stddef.h>
31#include <linux/personality.h>
32#include <linux/percpu.h>
33#include <linux/linkage.h>
34#include <asm/entry.h>
35#include <asm/ucontext.h>
36#include <linux/uaccess.h>
37#include <asm/pgtable.h>
38#include <asm/pgalloc.h>
39#include <linux/syscalls.h>
40#include <asm/cacheflush.h>
41#include <asm/syscalls.h>
42
43#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
44
45asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset, int in_sycall);
46
47
48asmlinkage long
49sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
50 struct pt_regs *regs)
51{
52 return do_sigaltstack(uss, uoss, regs->r1);
53}
54
55
56
57
58struct sigframe {
59 struct sigcontext sc;
60 unsigned long extramask[_NSIG_WORDS-1];
61 unsigned long tramp[2];
62};
63
64struct rt_sigframe {
65 struct siginfo info;
66 struct ucontext uc;
67 unsigned long tramp[2];
68};
69
70static int restore_sigcontext(struct pt_regs *regs,
71 struct sigcontext __user *sc, int *rval_p)
72{
73 unsigned int err = 0;
74
75#define COPY(x) {err |= __get_user(regs->x, &sc->regs.x); }
76 COPY(r0);
77 COPY(r1);
78 COPY(r2); COPY(r3); COPY(r4); COPY(r5);
79 COPY(r6); COPY(r7); COPY(r8); COPY(r9);
80 COPY(r10); COPY(r11); COPY(r12); COPY(r13);
81 COPY(r14); COPY(r15); COPY(r16); COPY(r17);
82 COPY(r18); COPY(r19); COPY(r20); COPY(r21);
83 COPY(r22); COPY(r23); COPY(r24); COPY(r25);
84 COPY(r26); COPY(r27); COPY(r28); COPY(r29);
85 COPY(r30); COPY(r31);
86 COPY(pc); COPY(ear); COPY(esr); COPY(fsr);
87#undef COPY
88
89 *rval_p = regs->r3;
90
91 return err;
92}
93
94asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
95{
96 struct rt_sigframe __user *frame =
97 (struct rt_sigframe __user *)(regs->r1 + STATE_SAVE_ARG_SPACE);
98
99 sigset_t set;
100 int rval;
101
102 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
103 goto badframe;
104
105 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
106 goto badframe;
107
108 sigdelsetmask(&set, ~_BLOCKABLE);
109 spin_lock_irq(¤t->sighand->siglock);
110 current->blocked = set;
111 recalc_sigpending();
112 spin_unlock_irq(¤t->sighand->siglock);
113
114 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &rval))
115 goto badframe;
116
117
118
119 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->r1))
120 goto badframe;
121
122 return rval;
123
124badframe:
125 force_sig(SIGSEGV, current);
126 return 0;
127}
128
129
130
131
132
133static int
134setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
135 unsigned long mask)
136{
137 int err = 0;
138
139#define COPY(x) {err |= __put_user(regs->x, &sc->regs.x); }
140 COPY(r0);
141 COPY(r1);
142 COPY(r2); COPY(r3); COPY(r4); COPY(r5);
143 COPY(r6); COPY(r7); COPY(r8); COPY(r9);
144 COPY(r10); COPY(r11); COPY(r12); COPY(r13);
145 COPY(r14); COPY(r15); COPY(r16); COPY(r17);
146 COPY(r18); COPY(r19); COPY(r20); COPY(r21);
147 COPY(r22); COPY(r23); COPY(r24); COPY(r25);
148 COPY(r26); COPY(r27); COPY(r28); COPY(r29);
149 COPY(r30); COPY(r31);
150 COPY(pc); COPY(ear); COPY(esr); COPY(fsr);
151#undef COPY
152
153 err |= __put_user(mask, &sc->oldmask);
154
155 return err;
156}
157
158
159
160
161static inline void __user *
162get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
163{
164
165 unsigned long sp = regs->r1;
166
167 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
168 sp = current->sas_ss_sp + current->sas_ss_size;
169
170 return (void __user *)((sp - frame_size) & -8UL);
171}
172
173static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
174 sigset_t *set, struct pt_regs *regs)
175{
176 struct rt_sigframe __user *frame;
177 int err = 0;
178 int signal;
179
180 frame = get_sigframe(ka, regs, sizeof(*frame));
181
182 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
183 goto give_sigsegv;
184
185 signal = current_thread_info()->exec_domain
186 && current_thread_info()->exec_domain->signal_invmap
187 && sig < 32
188 ? current_thread_info()->exec_domain->signal_invmap[sig]
189 : sig;
190
191 if (info)
192 err |= copy_siginfo_to_user(&frame->info, info);
193
194
195 err |= __put_user(0, &frame->uc.uc_flags);
196 err |= __put_user(0, &frame->uc.uc_link);
197 err |= __put_user((void *)current->sas_ss_sp,
198 &frame->uc.uc_stack.ss_sp);
199 err |= __put_user(sas_ss_flags(regs->r1),
200 &frame->uc.uc_stack.ss_flags);
201 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
202 err |= setup_sigcontext(&frame->uc.uc_mcontext,
203 regs, set->sig[0]);
204 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
205
206
207
208
209
210 err |= __put_user(0x31800000 | __NR_rt_sigreturn ,
211 frame->tramp + 0);
212
213 err |= __put_user(0xb9cc0008, frame->tramp + 1);
214
215
216
217 regs->r15 = ((unsigned long)frame->tramp)-8;
218
219 __invalidate_cache_sigtramp((unsigned long)frame->tramp);
220
221 if (err)
222 goto give_sigsegv;
223
224
225 regs->r1 = (unsigned long) frame - STATE_SAVE_ARG_SPACE;
226
227
228 regs->r5 = signal;
229 regs->r6 = (unsigned long) &frame->info;
230 regs->r7 = (unsigned long) &frame->uc;
231
232 regs->pc = (unsigned long)ka->sa.sa_handler;
233
234 set_fs(USER_DS);
235
236#ifdef DEBUG_SIG
237 printk(KERN_INFO "SIG deliver (%s:%d): sp=%p pc=%08lx\n",
238 current->comm, current->pid, frame, regs->pc);
239#endif
240
241 return;
242
243give_sigsegv:
244 if (sig == SIGSEGV)
245 ka->sa.sa_handler = SIG_DFL;
246 force_sig(SIGSEGV, current);
247}
248
249
250static inline void
251handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
252{
253 switch (regs->r3) {
254 case -ERESTART_RESTARTBLOCK:
255 case -ERESTARTNOHAND:
256 if (!has_handler)
257 goto do_restart;
258 regs->r3 = -EINTR;
259 break;
260 case -ERESTARTSYS:
261 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
262 regs->r3 = -EINTR;
263 break;
264 }
265
266 case -ERESTARTNOINTR:
267do_restart:
268
269#ifndef CONFIG_MMU
270 regs->pc -= 4;
271#else
272
273
274
275
276 regs->pc -= 8;
277#endif
278 break;
279 }
280}
281
282
283
284
285
286static int
287handle_signal(unsigned long sig, struct k_sigaction *ka,
288 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
289{
290
291 if (ka->sa.sa_flags & SA_SIGINFO)
292 setup_rt_frame(sig, ka, info, oldset, regs);
293 else
294 setup_rt_frame(sig, ka, NULL, oldset, regs);
295
296 if (ka->sa.sa_flags & SA_ONESHOT)
297 ka->sa.sa_handler = SIG_DFL;
298
299 if (!(ka->sa.sa_flags & SA_NODEFER)) {
300 spin_lock_irq(¤t->sighand->siglock);
301 sigorsets(¤t->blocked,
302 ¤t->blocked, &ka->sa.sa_mask);
303 sigaddset(¤t->blocked, sig);
304 recalc_sigpending();
305 spin_unlock_irq(¤t->sighand->siglock);
306 }
307 return 1;
308}
309
310
311
312
313
314
315
316
317
318
319int do_signal(struct pt_regs *regs, sigset_t *oldset, int in_syscall)
320{
321 siginfo_t info;
322 int signr;
323 struct k_sigaction ka;
324#ifdef DEBUG_SIG
325 printk(KERN_INFO "do signal: %p %p %d\n", regs, oldset, in_syscall);
326 printk(KERN_INFO "do signal2: %lx %lx %ld [%lx]\n", regs->pc, regs->r1,
327 regs->r12, current_thread_info()->flags);
328#endif
329
330
331
332
333
334
335 if (kernel_mode(regs))
336 return 1;
337
338 if (current_thread_info()->status & TS_RESTORE_SIGMASK)
339 oldset = ¤t->saved_sigmask;
340 else
341 oldset = ¤t->blocked;
342
343 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
344 if (signr > 0) {
345
346 if (in_syscall)
347 handle_restart(regs, &ka, 1);
348 if (handle_signal(signr, &ka, &info, oldset, regs)) {
349
350
351
352
353
354
355 current_thread_info()->status &=
356 ~TS_RESTORE_SIGMASK;
357 }
358 return 1;
359 }
360
361 if (in_syscall)
362 handle_restart(regs, NULL, 0);
363
364
365
366
367
368 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
369 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
370 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
371 }
372
373
374 return 0;
375}
376