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