?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
I2C: TWL4030: Kconfig and Makefile changes
[linux-ginger.git] / arch / sh / kernel / signal_64.c
blob80bde19d445be5bc2f2628b75502915e6990cc23
1 /*
2 * arch/sh/kernel/signal_64.c
3 *
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 Paul Mundt
6 * Copyright (C) 2004 Richard Curnow
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12 #include <linux/rwsem.h>
13 #include <linux/sched.h>
14 #include <linux/mm.h>
15 #include <linux/smp.h>
16 #include <linux/kernel.h>
17 #include <linux/signal.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/personality.h>
21 #include <linux/freezer.h>
22 #include <linux/ptrace.h>
23 #include <linux/unistd.h>
24 #include <linux/stddef.h>
25 #include <asm/ucontext.h>
26 #include <asm/uaccess.h>
27 #include <asm/pgtable.h>
28 #include <asm/cacheflush.h>
29
30 #define REG_RET 9
31 #define REG_ARG1 2
32 #define REG_ARG2 3
33 #define REG_ARG3 4
34 #define REG_SP 15
35 #define REG_PR 18
36 #define REF_REG_RET regs->regs[REG_RET]
37 #define REF_REG_SP regs->regs[REG_SP]
38 #define DEREF_REG_PR regs->regs[REG_PR]
39
40 #define DEBUG_SIG 0
41
42 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
43
44 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
45
46 /*
47 * Atomically swap in the new signal mask, and wait for a signal.
48 */
49
50 asmlinkage int
51 sys_sigsuspend(old_sigset_t mask,
52 unsigned long r3, unsigned long r4, unsigned long r5,
53 unsigned long r6, unsigned long r7,
54 struct pt_regs * regs)
55 {
56 sigset_t saveset;
57
58 mask &= _BLOCKABLE;
59 spin_lock_irq(&current->sighand->siglock);
60 saveset = current->blocked;
61 siginitset(&current->blocked, mask);
62 recalc_sigpending();
63 spin_unlock_irq(&current->sighand->siglock);
64
65 REF_REG_RET = -EINTR;
66 while (1) {
67 current->state = TASK_INTERRUPTIBLE;
68 schedule();
69 regs->pc += 4; /* because sys_sigreturn decrements the pc */
70 if (do_signal(regs, &saveset)) {
71 /* pc now points at signal handler. Need to decrement
72 it because entry.S will increment it. */
73 regs->pc -= 4;
74 return -EINTR;
75 }
76 }
77 }
78
79 asmlinkage int
80 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
81 unsigned long r4, unsigned long r5, unsigned long r6,
82 unsigned long r7,
83 struct pt_regs * regs)
84 {
85 sigset_t saveset, newset;
86
87 /* XXX: Don't preclude handling different sized sigset_t's. */
88 if (sigsetsize != sizeof(sigset_t))
89 return -EINVAL;
90
91 if (copy_from_user(&newset, unewset, sizeof(newset)))
92 return -EFAULT;
93 sigdelsetmask(&newset, ~_BLOCKABLE);
94 spin_lock_irq(&current->sighand->siglock);
95 saveset = current->blocked;
96 current->blocked = newset;
97 recalc_sigpending();
98 spin_unlock_irq(&current->sighand->siglock);
99
100 REF_REG_RET = -EINTR;
101 while (1) {
102 current->state = TASK_INTERRUPTIBLE;
103 schedule();
104 regs->pc += 4; /* because sys_sigreturn decrements the pc */
105 if (do_signal(regs, &saveset)) {
106 /* pc now points at signal handler. Need to decrement
107 it because entry.S will increment it. */
108 regs->pc -= 4;
109 return -EINTR;
110 }
111 }
112 }
113
114 asmlinkage int
115 sys_sigaction(int sig, const struct old_sigaction __user *act,
116 struct old_sigaction __user *oact)
117 {
118 struct k_sigaction new_ka, old_ka;
119 int ret;
120
121 if (act) {
122 old_sigset_t mask;
123 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
124 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
125 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
126 return -EFAULT;
127 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
128 __get_user(mask, &act->sa_mask);
129 siginitset(&new_ka.sa.sa_mask, mask);
130 }
131
132 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
133
134 if (!ret && oact) {
135 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
136 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
137 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
138 return -EFAULT;
139 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
140 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
141 }
142
143 return ret;
144 }
145
146 asmlinkage int
147 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
148 unsigned long r4, unsigned long r5, unsigned long r6,
149 unsigned long r7,
150 struct pt_regs * regs)
151 {
152 return do_sigaltstack(uss, uoss, REF_REG_SP);
153 }
154
155
156 /*
157 * Do a signal return; undo the signal stack.
158 */
159
160 struct sigframe
161 {
162 struct sigcontext sc;
163 unsigned long extramask[_NSIG_WORDS-1];
164 long long retcode[2];
165 };
166
167 struct rt_sigframe
168 {
169 struct siginfo __user *pinfo;
170 void *puc;
171 struct siginfo info;
172 struct ucontext uc;
173 long long retcode[2];
174 };
175
176 #ifdef CONFIG_SH_FPU
177 static inline int
178 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
179 {
180 int err = 0;
181 int fpvalid;
182
183 err |= __get_user (fpvalid, &sc->sc_fpvalid);
184 conditional_used_math(fpvalid);
185 if (! fpvalid)
186 return err;
187
188 if (current == last_task_used_math) {
189 last_task_used_math = NULL;
190 regs->sr |= SR_FD;
191 }
192
193 err |= __copy_from_user(&current->thread.fpu.hard, &sc->sc_fpregs[0],
194 (sizeof(long long) * 32) + (sizeof(int) * 1));
195
196 return err;
197 }
198
199 static inline int
200 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
201 {
202 int err = 0;
203 int fpvalid;
204
205 fpvalid = !!used_math();
206 err |= __put_user(fpvalid, &sc->sc_fpvalid);
207 if (! fpvalid)
208 return err;
209
210 if (current == last_task_used_math) {
211 enable_fpu();
212 save_fpu(current, regs);
213 disable_fpu();
214 last_task_used_math = NULL;
215 regs->sr |= SR_FD;
216 }
217
218 err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.fpu.hard,
219 (sizeof(long long) * 32) + (sizeof(int) * 1));
220 clear_used_math();
221
222 return err;
223 }
224 #else
225 static inline int
226 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
227 {
228 return 0;
229 }
230 static inline int
231 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
232 {
233 return 0;
234 }
235 #endif
236
237 static int
238 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
239 {
240 unsigned int err = 0;
241 unsigned long long current_sr, new_sr;
242 #define SR_MASK 0xffff8cfd
243
244 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
245
246 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
247 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
248 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
249 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
250 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
251 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
252 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
253 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
254 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
255 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
256 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
257 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
258 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
259 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
260 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
261 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
262 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
263 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
264
265 /* Prevent the signal handler manipulating SR in a way that can
266 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
267 modified */
268 current_sr = regs->sr;
269 err |= __get_user(new_sr, &sc->sc_sr);
270 regs->sr &= SR_MASK;
271 regs->sr |= (new_sr & ~SR_MASK);
272
273 COPY(pc);
274
275 #undef COPY
276
277 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
278 * has been restored above.) */
279 err |= restore_sigcontext_fpu(regs, sc);
280
281 regs->syscall_nr = -1; /* disable syscall checks */
282 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
283 return err;
284 }
285
286 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
287 unsigned long r4, unsigned long r5,
288 unsigned long r6, unsigned long r7,
289 struct pt_regs * regs)
290 {
291 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
292 sigset_t set;
293 long long ret;
294
295 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
296 goto badframe;
297
298 if (__get_user(set.sig[0], &frame->sc.oldmask)
299 || (_NSIG_WORDS > 1
300 && __copy_from_user(&set.sig[1], &frame->extramask,
301 sizeof(frame->extramask))))
302 goto badframe;
303
304 sigdelsetmask(&set, ~_BLOCKABLE);
305
306 spin_lock_irq(&current->sighand->siglock);
307 current->blocked = set;
308 recalc_sigpending();
309 spin_unlock_irq(&current->sighand->siglock);
310
311 if (restore_sigcontext(regs, &frame->sc, &ret))
312 goto badframe;
313 regs->pc -= 4;
314
315 return (int) ret;
316
317 badframe:
318 force_sig(SIGSEGV, current);
319 return 0;
320 }
321
322 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
323 unsigned long r4, unsigned long r5,
324 unsigned long r6, unsigned long r7,
325 struct pt_regs * regs)
326 {
327 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
328 sigset_t set;
329 stack_t __user st;
330 long long ret;
331
332 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
333 goto badframe;
334
335 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
336 goto badframe;
337
338 sigdelsetmask(&set, ~_BLOCKABLE);
339 spin_lock_irq(&current->sighand->siglock);
340 current->blocked = set;
341 recalc_sigpending();
342 spin_unlock_irq(&current->sighand->siglock);
343
344 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
345 goto badframe;
346 regs->pc -= 4;
347
348 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
349 goto badframe;
350 /* It is more difficult to avoid calling this function than to
351 call it and ignore errors. */
352 do_sigaltstack(&st, NULL, REF_REG_SP);
353
354 return (int) ret;
355
356 badframe:
357 force_sig(SIGSEGV, current);
358 return 0;
359 }
360
361 /*
362 * Set up a signal frame.
363 */
364
365 static int
366 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
367 unsigned long mask)
368 {
369 int err = 0;
370
371 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
372 err |= setup_sigcontext_fpu(regs, sc);
373
374 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
375
376 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
377 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
378 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
379 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
380 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
381 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
382 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
383 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
384 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
385 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
386 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
387 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
388 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
389 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
390 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
391 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
392 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
393 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
394 COPY(sr); COPY(pc);
395
396 #undef COPY
397
398 err |= __put_user(mask, &sc->oldmask);
399
400 return err;
401 }
402
403 /*
404 * Determine which stack to use..
405 */
406 static inline void __user *
407 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
408 {
409 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
410 sp = current->sas_ss_sp + current->sas_ss_size;
411
412 return (void __user *)((sp - frame_size) & -8ul);
413 }
414
415 void sa_default_restorer(void); /* See comments below */
416 void sa_default_rt_restorer(void); /* See comments below */
417
418 static void setup_frame(int sig, struct k_sigaction *ka,
419 sigset_t *set, struct pt_regs *regs)
420 {
421 struct sigframe __user *frame;
422 int err = 0;
423 int signal;
424
425 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
426
427 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
428 goto give_sigsegv;
429
430 signal = current_thread_info()->exec_domain
431 && current_thread_info()->exec_domain->signal_invmap
432 && sig < 32
433 ? current_thread_info()->exec_domain->signal_invmap[sig]
434 : sig;
435
436 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
437
438 /* Give up earlier as i386, in case */
439 if (err)
440 goto give_sigsegv;
441
442 if (_NSIG_WORDS > 1) {
443 err |= __copy_to_user(frame->extramask, &set->sig[1],
444 sizeof(frame->extramask)); }
445
446 /* Give up earlier as i386, in case */
447 if (err)
448 goto give_sigsegv;
449
450 /* Set up to return from userspace. If provided, use a stub
451 already in userspace. */
452 if (ka->sa.sa_flags & SA_RESTORER) {
453 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
454
455 /*
456 * On SH5 all edited pointers are subject to NEFF
457 */
458 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
459 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
460 } else {
461 /*
462 * Different approach on SH5.
463 * . Endianness independent asm code gets placed in entry.S .
464 * This is limited to four ASM instructions corresponding
465 * to two long longs in size.
466 * . err checking is done on the else branch only
467 * . flush_icache_range() is called upon __put_user() only
468 * . all edited pointers are subject to NEFF
469 * . being code, linker turns ShMedia bit on, always
470 * dereference index -1.
471 */
472 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
473 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
474 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
475
476 if (__copy_to_user(frame->retcode,
477 (unsigned long long)sa_default_restorer & (~1), 16) != 0)
478 goto give_sigsegv;
479
480 /* Cohere the trampoline with the I-cache. */
481 flush_cache_sigtramp(DEREF_REG_PR-1);
482 }
483
484 /*
485 * Set up registers for signal handler.
486 * All edited pointers are subject to NEFF.
487 */
488 regs->regs[REG_SP] = (unsigned long) frame;
489 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
490 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
491 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
492
493 /* FIXME:
494 The glibc profiling support for SH-5 needs to be passed a sigcontext
495 so it can retrieve the PC. At some point during 2003 the glibc
496 support was changed to receive the sigcontext through the 2nd
497 argument, but there are still versions of libc.so in use that use
498 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
499 through both 2nd and 3rd arguments.
500 */
501
502 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
503 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
504
505 regs->pc = (unsigned long) ka->sa.sa_handler;
506 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
507
508 set_fs(USER_DS);
509
510 #if DEBUG_SIG
511 /* Broken %016Lx */
512 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
513 signal,
514 current->comm, current->pid, frame,
515 regs->pc >> 32, regs->pc & 0xffffffff,
516 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
517 #endif
518
519 return;
520
521 give_sigsegv:
522 force_sigsegv(sig, current);
523 }
524
525 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
526 sigset_t *set, struct pt_regs *regs)
527 {
528 struct rt_sigframe __user *frame;
529 int err = 0;
530 int signal;
531
532 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
533
534 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
535 goto give_sigsegv;
536
537 signal = current_thread_info()->exec_domain
538 && current_thread_info()->exec_domain->signal_invmap
539 && sig < 32
540 ? current_thread_info()->exec_domain->signal_invmap[sig]
541 : sig;
542
543 err |= __put_user(&frame->info, &frame->pinfo);
544 err |= __put_user(&frame->uc, &frame->puc);
545 err |= copy_siginfo_to_user(&frame->info, info);
546
547 /* Give up earlier as i386, in case */
548 if (err)
549 goto give_sigsegv;
550
551 /* Create the ucontext. */
552 err |= __put_user(0, &frame->uc.uc_flags);
553 err |= __put_user(0, &frame->uc.uc_link);
554 err |= __put_user((void *)current->sas_ss_sp,
555 &frame->uc.uc_stack.ss_sp);
556 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
557 &frame->uc.uc_stack.ss_flags);
558 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
559 err |= setup_sigcontext(&frame->uc.uc_mcontext,
560 regs, set->sig[0]);
561 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
562
563 /* Give up earlier as i386, in case */
564 if (err)
565 goto give_sigsegv;
566
567 /* Set up to return from userspace. If provided, use a stub
568 already in userspace. */
569 if (ka->sa.sa_flags & SA_RESTORER) {
570 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
571
572 /*
573 * On SH5 all edited pointers are subject to NEFF
574 */
575 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
576 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
577 } else {
578 /*
579 * Different approach on SH5.
580 * . Endianness independent asm code gets placed in entry.S .
581 * This is limited to four ASM instructions corresponding
582 * to two long longs in size.
583 * . err checking is done on the else branch only
584 * . flush_icache_range() is called upon __put_user() only
585 * . all edited pointers are subject to NEFF
586 * . being code, linker turns ShMedia bit on, always
587 * dereference index -1.
588 */
589
590 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
591 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
592 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
593
594 if (__copy_to_user(frame->retcode,
595 (unsigned long long)sa_default_rt_restorer & (~1), 16) != 0)
596 goto give_sigsegv;
597
598 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
599 }
600
601 /*
602 * Set up registers for signal handler.
603 * All edited pointers are subject to NEFF.
604 */
605 regs->regs[REG_SP] = (unsigned long) frame;
606 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
607 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
608 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
609 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
610 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
611 regs->pc = (unsigned long) ka->sa.sa_handler;
612 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
613
614 set_fs(USER_DS);
615
616 #if DEBUG_SIG
617 /* Broken %016Lx */
618 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
619 signal,
620 current->comm, current->pid, frame,
621 regs->pc >> 32, regs->pc & 0xffffffff,
622 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
623 #endif
624
625 return;
626
627 give_sigsegv:
628 force_sigsegv(sig, current);
629 }
630
631 /*
632 * OK, we're invoking a handler
633 */
634
635 static void
636 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
637 sigset_t *oldset, struct pt_regs * regs)
638 {
639 /* Are we from a system call? */
640 if (regs->syscall_nr >= 0) {
641 /* If so, check system call restarting.. */
642 switch (regs->regs[REG_RET]) {
643 case -ERESTART_RESTARTBLOCK:
644 case -ERESTARTNOHAND:
645 regs->regs[REG_RET] = -EINTR;
646 break;
647
648 case -ERESTARTSYS:
649 if (!(ka->sa.sa_flags & SA_RESTART)) {
650 regs->regs[REG_RET] = -EINTR;
651 break;
652 }
653 /* fallthrough */
654 case -ERESTARTNOINTR:
655 /* Decode syscall # */
656 regs->regs[REG_RET] = regs->syscall_nr;
657 regs->pc -= 4;
658 }
659 }
660
661 /* Set up the stack frame */
662 if (ka->sa.sa_flags & SA_SIGINFO)
663 setup_rt_frame(sig, ka, info, oldset, regs);
664 else
665 setup_frame(sig, ka, oldset, regs);
666
667 spin_lock_irq(&current->sighand->siglock);
668 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
669 if (!(ka->sa.sa_flags & SA_NODEFER))
670 sigaddset(&current->blocked,sig);
671 recalc_sigpending();
672 spin_unlock_irq(&current->sighand->siglock);
673 }
674
675 /*
676 * Note that 'init' is a special process: it doesn't get signals it doesn't
677 * want to handle. Thus you cannot kill init even with a SIGKILL even by
678 * mistake.
679 *
680 * Note that we go through the signals twice: once to check the signals that
681 * the kernel can handle, and then we build all the user-level signal handling
682 * stack-frames in one go after that.
683 */
684 int do_signal(struct pt_regs *regs, sigset_t *oldset)
685 {
686 siginfo_t info;
687 int signr;
688 struct k_sigaction ka;
689
690 /*
691 * We want the common case to go fast, which
692 * is why we may in certain cases get here from
693 * kernel mode. Just return without doing anything
694 * if so.
695 */
696 if (!user_mode(regs))
697 return 1;
698
699 if (try_to_freeze())
700 goto no_signal;
701
702 if (test_thread_flag(TIF_RESTORE_SIGMASK))
703 oldset = &current->saved_sigmask;
704 else if (!oldset)
705 oldset = &current->blocked;
706
707 signr = get_signal_to_deliver(&info, &ka, regs, 0);
708
709 if (signr > 0) {
710 /* Whee! Actually deliver the signal. */
711 handle_signal(signr, &info, &ka, oldset, regs);
712
713 /*
714 * If a signal was successfully delivered, the saved sigmask
715 * is in its frame, and we can clear the TIF_RESTORE_SIGMASK
716 * flag.
717 */
718 if (test_thread_flag(TIF_RESTORE_SIGMASK))
719 clear_thread_flag(TIF_RESTORE_SIGMASK);
720
721 return 1;
722 }
723
724 no_signal:
725 /* Did we come from a system call? */
726 if (regs->syscall_nr >= 0) {
727 /* Restart the system call - no handlers present */
728 switch (regs->regs[REG_RET]) {
729 case -ERESTARTNOHAND:
730 case -ERESTARTSYS:
731 case -ERESTARTNOINTR:
732 /* Decode Syscall # */
733 regs->regs[REG_RET] = regs->syscall_nr;
734 regs->pc -= 4;
735 break;
736
737 case -ERESTART_RESTARTBLOCK:
738 regs->regs[REG_RET] = __NR_restart_syscall;
739 regs->pc -= 4;
740 break;
741 }
742 }
743
744 /* No signal to deliver -- put the saved sigmask back */
745 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
746 clear_thread_flag(TIF_RESTORE_SIGMASK);
747 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
748 }
749
750 return 0;
751 }
Linux for Ginger Game Console