Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / arch / cris / arch-v10 / kernel / signal.c
1 /*
2  *  linux/arch/cris/kernel/signal.c
3  *
4  *  Based on arch/i386/kernel/signal.c by
5  *     Copyright (C) 1991, 1992  Linus Torvalds
6  *     1997-11-28  Modified for POSIX.1b signals by Richard Henderson *
7  *
8  *  Ideas also taken from arch/arm.
9  *
10  *  Copyright (C) 2000, 2001 Axis Communications AB
11  *
12  *  Authors:  Bjorn Wesen (bjornw@axis.com)
13  *
14  */
15
16 #include <linux/sched.h>
17 #include <linux/mm.h>
18 #include <linux/smp.h>
19 #include <linux/kernel.h>
20 #include <linux/signal.h>
21 #include <linux/errno.h>
22 #include <linux/wait.h>
23 #include <linux/ptrace.h>
24 #include <linux/unistd.h>
25 #include <linux/stddef.h>
26
27 #include <asm/processor.h>
28 #include <asm/ucontext.h>
29 #include <asm/uaccess.h>
30
31 #define DEBUG_SIG 0
32
33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
34
35 /* a syscall in Linux/CRIS is a break 13 instruction which is 2 bytes */
36 /* manipulate regs so that upon return, it will be re-executed */
37
38 /* We rely on that pc points to the instruction after "break 13", so the
39  * library must never do strange things like putting it in a delay slot.
40  */
41 #define RESTART_CRIS_SYS(regs) regs->r10 = regs->orig_r10; regs->irp -= 2;
42
43 int do_signal(int canrestart, sigset_t *oldset, struct pt_regs *regs);
44
45 /*
46  * Atomically swap in the new signal mask, and wait for a signal.  Define 
47  * dummy arguments to be able to reach the regs argument.  (Note that this
48  * arrangement relies on old_sigset_t occupying one register.)
49  */
50 int
51 sys_sigsuspend(old_sigset_t mask, long r11, long r12, long r13, long mof, 
52                long srp, struct pt_regs *regs)
53 {
54         sigset_t saveset;
55
56         mask &= _BLOCKABLE;
57         spin_lock_irq(&current->sighand->siglock);
58         saveset = current->blocked;
59         siginitset(&current->blocked, mask);
60         recalc_sigpending();
61         spin_unlock_irq(&current->sighand->siglock);
62
63         regs->r10 = -EINTR;
64         while (1) {
65                 current->state = TASK_INTERRUPTIBLE;
66                 schedule();
67                 if (do_signal(0, &saveset, regs))
68                         /* We will get here twice: once to call the signal
69                            handler, then again to return from the
70                            sigsuspend system call.  When calling the
71                            signal handler, R10 holds the signal number as
72                            set through do_signal.  The sigsuspend call
73                            will return with the restored value set above;
74                            always -EINTR.  */
75                         return regs->r10;
76         }
77 }
78
79 /* Define dummy arguments to be able to reach the regs argument.  (Note that
80  * this arrangement relies on size_t occupying one register.)
81  */
82 int
83 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, long r12, long r13, 
84                   long mof, long srp, struct pt_regs *regs)
85 {
86         sigset_t saveset, newset;
87
88         /* XXX: Don't preclude handling different sized sigset_t's.  */
89         if (sigsetsize != sizeof(sigset_t))
90                 return -EINVAL;
91
92         if (copy_from_user(&newset, unewset, sizeof(newset)))
93                 return -EFAULT;
94         sigdelsetmask(&newset, ~_BLOCKABLE);
95
96         spin_lock_irq(&current->sighand->siglock);
97         saveset = current->blocked;
98         current->blocked = newset;
99         recalc_sigpending();
100         spin_unlock_irq(&current->sighand->siglock);
101
102         regs->r10 = -EINTR;
103         while (1) {
104                 current->state = TASK_INTERRUPTIBLE;
105                 schedule();
106                 if (do_signal(0, &saveset, regs))
107                         /* We will get here twice: once to call the signal
108                            handler, then again to return from the
109                            sigsuspend system call.  When calling the
110                            signal handler, R10 holds the signal number as
111                            set through do_signal.  The sigsuspend call
112                            will return with the restored value set above;
113                            always -EINTR.  */
114                         return regs->r10;
115         }
116 }
117
118 int 
119 sys_sigaction(int sig, const struct old_sigaction __user *act,
120               struct old_sigaction *oact)
121 {
122         struct k_sigaction new_ka, old_ka;
123         int ret;
124
125         if (act) {
126                 old_sigset_t mask;
127                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
128                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
129                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
130                         return -EFAULT;
131                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
132                 __get_user(mask, &act->sa_mask);
133                 siginitset(&new_ka.sa.sa_mask, mask);
134         }
135
136         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
137
138         if (!ret && oact) {
139                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
140                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
141                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
142                         return -EFAULT;
143                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
144                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
145         }
146
147         return ret;
148 }
149
150 int
151 sys_sigaltstack(const stack_t *uss, stack_t __user *uoss)
152 {
153         return do_sigaltstack(uss, uoss, rdusp());
154 }
155
156
157 /*
158  * Do a signal return; undo the signal stack.
159  */
160
161 struct sigframe {
162         struct sigcontext sc;
163         unsigned long extramask[_NSIG_WORDS-1];
164         unsigned char retcode[8];  /* trampoline code */
165 };
166
167 struct rt_sigframe {
168         struct siginfo *pinfo;
169         void *puc;
170         struct siginfo info;
171         struct ucontext uc;
172         unsigned char retcode[8];  /* trampoline code */
173 };
174
175
176 static int
177 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
178 {
179         unsigned int err = 0;
180         unsigned long old_usp;
181
182         /* Always make any pending restarted system calls return -EINTR */
183         current_thread_info()->restart_block.fn = do_no_restart_syscall;
184
185         /* restore the regs from &sc->regs (same as sc, since regs is first)
186          * (sc is already checked for VERIFY_READ since the sigframe was
187          *  checked in sys_sigreturn previously)
188          */
189
190         if (__copy_from_user(regs, sc, sizeof(struct pt_regs)))
191                 goto badframe;
192
193         /* make sure the U-flag is set so user-mode cannot fool us */
194
195         regs->dccr |= 1 << 8;
196
197         /* restore the old USP as it was before we stacked the sc etc.
198          * (we cannot just pop the sigcontext since we aligned the sp and
199          *  stuff after pushing it)
200          */
201
202         err |= __get_user(old_usp, &sc->usp);
203
204         wrusp(old_usp);
205
206         /* TODO: the other ports use regs->orig_XX to disable syscall checks
207          * after this completes, but we don't use that mechanism. maybe we can
208          * use it now ? 
209          */
210
211         return err;
212
213 badframe:
214         return 1;
215 }
216
217 /* Define dummy arguments to be able to reach the regs argument.  */
218
219 asmlinkage int sys_sigreturn(long r10, long r11, long r12, long r13, long mof, 
220                              long srp, struct pt_regs *regs)
221 {
222         struct sigframe __user *frame = (struct sigframe *)rdusp();
223         sigset_t set;
224
225         /*
226          * Since we stacked the signal on a dword boundary,
227          * then frame should be dword aligned here.  If it's
228          * not, then the user is trying to mess with us.
229          */
230         if (((long)frame) & 3)
231                 goto badframe;
232
233         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
234                 goto badframe;
235         if (__get_user(set.sig[0], &frame->sc.oldmask)
236             || (_NSIG_WORDS > 1
237                 && __copy_from_user(&set.sig[1], frame->extramask,
238                                     sizeof(frame->extramask))))
239                 goto badframe;
240
241         sigdelsetmask(&set, ~_BLOCKABLE);
242         spin_lock_irq(&current->sighand->siglock);
243         current->blocked = set;
244         recalc_sigpending();
245         spin_unlock_irq(&current->sighand->siglock);
246         
247         if (restore_sigcontext(regs, &frame->sc))
248                 goto badframe;
249
250         /* TODO: SIGTRAP when single-stepping as in arm ? */
251
252         return regs->r10;
253
254 badframe:
255         force_sig(SIGSEGV, current);
256         return 0;
257 }       
258
259 /* Define dummy arguments to be able to reach the regs argument.  */
260
261 asmlinkage int sys_rt_sigreturn(long r10, long r11, long r12, long r13, 
262                                 long mof, long srp, struct pt_regs *regs)
263 {
264         struct rt_sigframe __user *frame = (struct rt_sigframe *)rdusp();
265         sigset_t set;
266
267         /*
268          * Since we stacked the signal on a dword boundary,
269          * then frame should be dword aligned here.  If it's
270          * not, then the user is trying to mess with us.
271          */
272         if (((long)frame) & 3)
273                 goto badframe;
274
275         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
276                 goto badframe;
277         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
278                 goto badframe;
279
280         sigdelsetmask(&set, ~_BLOCKABLE);
281         spin_lock_irq(&current->sighand->siglock);
282         current->blocked = set;
283         recalc_sigpending();
284         spin_unlock_irq(&current->sighand->siglock);
285         
286         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
287                 goto badframe;
288
289         if (do_sigaltstack(&frame->uc.uc_stack, NULL, rdusp()) == -EFAULT)
290                 goto badframe;
291
292         return regs->r10;
293
294 badframe:
295         force_sig(SIGSEGV, current);
296         return 0;
297 }       
298
299 /*
300  * Set up a signal frame.
301  */
302
303 static int
304 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask)
305 {
306         int err = 0;
307         unsigned long usp = rdusp();
308
309         /* copy the regs. they are first in sc so we can use sc directly */
310
311         err |= __copy_to_user(sc, regs, sizeof(struct pt_regs));
312
313         /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
314            the signal handler. The frametype will be restored to its previous
315            value in restore_sigcontext. */
316         regs->frametype = CRIS_FRAME_NORMAL;
317
318         /* then some other stuff */
319
320         err |= __put_user(mask, &sc->oldmask);
321
322         err |= __put_user(usp, &sc->usp);
323
324         return err;
325 }
326
327 /* figure out where we want to put the new signal frame - usually on the stack */
328
329 static inline void __user *
330 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
331 {
332         unsigned long sp = rdusp();
333
334         /* This is the X/Open sanctioned signal stack switching.  */
335         if (ka->sa.sa_flags & SA_ONSTACK) {
336                 if (! on_sig_stack(sp))
337                         sp = current->sas_ss_sp + current->sas_ss_size;
338         }
339
340         /* make sure the frame is dword-aligned */
341
342         sp &= ~3;
343
344         return (void __user*)(sp - frame_size);
345 }
346
347 /* grab and setup a signal frame.
348  * 
349  * basically we stack a lot of state info, and arrange for the
350  * user-mode program to return to the kernel using either a
351  * trampoline which performs the syscall sigreturn, or a provided
352  * user-mode trampoline.
353  */
354
355 static void setup_frame(int sig, struct k_sigaction *ka,
356                         sigset_t *set, struct pt_regs * regs)
357 {
358         struct sigframe __user *frame;
359         unsigned long return_ip;
360         int err = 0;
361
362         frame = get_sigframe(ka, regs, sizeof(*frame));
363
364         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
365                 goto give_sigsegv;
366
367         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
368         if (err)
369                 goto give_sigsegv;
370
371         if (_NSIG_WORDS > 1) {
372                 err |= __copy_to_user(frame->extramask, &set->sig[1],
373                                       sizeof(frame->extramask));
374         }
375         if (err)
376                 goto give_sigsegv;
377
378         /* Set up to return from userspace.  If provided, use a stub
379            already in userspace.  */
380         if (ka->sa.sa_flags & SA_RESTORER) {
381                 return_ip = (unsigned long)ka->sa.sa_restorer;
382         } else {
383                 /* trampoline - the desired return ip is the retcode itself */
384                 return_ip = (unsigned long)&frame->retcode;
385                 /* This is movu.w __NR_sigreturn, r9; break 13; */
386                 err |= __put_user(0x9c5f,         (short __user*)(frame->retcode+0));
387                 err |= __put_user(__NR_sigreturn, (short __user*)(frame->retcode+2));
388                 err |= __put_user(0xe93d,         (short __user*)(frame->retcode+4));
389         }
390
391         if (err)
392                 goto give_sigsegv;
393
394         /* Set up registers for signal handler */
395
396         regs->irp = (unsigned long) ka->sa.sa_handler;  /* what we enter NOW   */
397         regs->srp = return_ip;                          /* what we enter LATER */
398         regs->r10 = sig;                                /* first argument is signo */
399
400         /* actually move the usp to reflect the stacked frame */
401
402         wrusp((unsigned long)frame);
403
404         return;
405
406 give_sigsegv:
407         force_sigsegv(sig, current);
408 }
409
410 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
411                            sigset_t *set, struct pt_regs * regs)
412 {
413         struct rt_sigframe __user *frame;
414         unsigned long return_ip;
415         int err = 0;
416
417         frame = get_sigframe(ka, regs, sizeof(*frame));
418
419         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
420                 goto give_sigsegv;
421
422         err |= __put_user(&frame->info, &frame->pinfo);
423         err |= __put_user(&frame->uc, &frame->puc);
424         err |= copy_siginfo_to_user(&frame->info, info);
425         if (err)
426                 goto give_sigsegv;
427
428         /* Clear all the bits of the ucontext we don't use.  */
429         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
430
431         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
432
433         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
434
435         if (err)
436                 goto give_sigsegv;
437
438         /* Set up to return from userspace.  If provided, use a stub
439            already in userspace.  */
440         if (ka->sa.sa_flags & SA_RESTORER) {
441                 return_ip = (unsigned long)ka->sa.sa_restorer;
442         } else {
443                 /* trampoline - the desired return ip is the retcode itself */
444                 return_ip = (unsigned long)&frame->retcode;
445                 /* This is movu.w __NR_rt_sigreturn, r9; break 13; */
446                 err |= __put_user(0x9c5f,            (short __user*)(frame->retcode+0));
447                 err |= __put_user(__NR_rt_sigreturn, (short __user*)(frame->retcode+2));
448                 err |= __put_user(0xe93d,            (short __user*)(frame->retcode+4));
449         }
450
451         if (err)
452                 goto give_sigsegv;
453
454         /* TODO what is the current->exec_domain stuff and invmap ? */
455
456         /* Set up registers for signal handler */
457
458         regs->irp = (unsigned long) ka->sa.sa_handler;  /* what we enter NOW   */
459         regs->srp = return_ip;                          /* what we enter LATER */
460         regs->r10 = sig;                                /* first argument is signo */
461         regs->r11 = (unsigned long) &frame->info;       /* second argument is (siginfo_t *) */
462         regs->r12 = 0;                                  /* third argument is unused */
463
464         /* actually move the usp to reflect the stacked frame */
465
466         wrusp((unsigned long)frame);
467
468         return;
469
470 give_sigsegv:
471         force_sigsegv(sig, current);
472 }
473
474 /*
475  * OK, we're invoking a handler
476  */     
477
478 static inline void
479 handle_signal(int canrestart, unsigned long sig,
480               siginfo_t *info, struct k_sigaction *ka,
481               sigset_t *oldset, struct pt_regs * regs)
482 {
483         /* Are we from a system call? */
484         if (canrestart) {
485                 /* If so, check system call restarting.. */
486                 switch (regs->r10) {
487                         case -ERESTART_RESTARTBLOCK:
488                         case -ERESTARTNOHAND:
489                                 /* ERESTARTNOHAND means that the syscall should only be
490                                    restarted if there was no handler for the signal, and since
491                                    we only get here if there is a handler, we don't restart */
492                                 regs->r10 = -EINTR;
493                                 break;
494
495                         case -ERESTARTSYS:
496                                 /* ERESTARTSYS means to restart the syscall if there is no
497                                    handler or the handler was registered with SA_RESTART */
498                                 if (!(ka->sa.sa_flags & SA_RESTART)) {
499                                         regs->r10 = -EINTR;
500                                         break;
501                                 }
502                         /* fallthrough */
503                         case -ERESTARTNOINTR:
504                                 /* ERESTARTNOINTR means that the syscall should be called again
505                                    after the signal handler returns. */
506                                 RESTART_CRIS_SYS(regs);
507                 }
508         }
509
510         /* Set up the stack frame */
511         if (ka->sa.sa_flags & SA_SIGINFO)
512                 setup_rt_frame(sig, ka, info, oldset, regs);
513         else
514                 setup_frame(sig, ka, oldset, regs);
515
516         if (ka->sa.sa_flags & SA_ONESHOT)
517                 ka->sa.sa_handler = SIG_DFL;
518
519         spin_lock_irq(&current->sighand->siglock);
520         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
521         if (!(ka->sa.sa_flags & SA_NODEFER))
522                 sigaddset(&current->blocked,sig);
523         recalc_sigpending();
524         spin_unlock_irq(&current->sighand->siglock);
525 }
526
527 /*
528  * Note that 'init' is a special process: it doesn't get signals it doesn't
529  * want to handle. Thus you cannot kill init even with a SIGKILL even by
530  * mistake.
531  *
532  * Also note that the regs structure given here as an argument, is the latest
533  * pushed pt_regs. It may or may not be the same as the first pushed registers
534  * when the initial usermode->kernelmode transition took place. Therefore
535  * we can use user_mode(regs) to see if we came directly from kernel or user
536  * mode below.
537  */
538
539 int do_signal(int canrestart, sigset_t *oldset, struct pt_regs *regs)
540 {
541         siginfo_t info;
542         int signr;
543         struct k_sigaction ka;
544
545         /*
546          * We want the common case to go fast, which
547          * is why we may in certain cases get here from
548          * kernel mode. Just return without doing anything
549          * if so.
550          */
551         if (!user_mode(regs))
552                 return 1;
553
554         if (!oldset)
555                 oldset = &current->blocked;
556
557         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
558         if (signr > 0) {
559                 /* Whee!  Actually deliver the signal.  */
560                 handle_signal(canrestart, signr, &info, &ka, oldset, regs);
561                 return 1;
562         }
563
564         /* Did we come from a system call? */
565         if (canrestart) {
566                 /* Restart the system call - no handlers present */
567                 if (regs->r10 == -ERESTARTNOHAND ||
568                     regs->r10 == -ERESTARTSYS ||
569                     regs->r10 == -ERESTARTNOINTR) {
570                         RESTART_CRIS_SYS(regs);
571                 }
572                 if (regs->r10 == -ERESTART_RESTARTBLOCK){
573                         regs->r10 = __NR_restart_syscall;
574                         regs->irp -= 2;
575                 }
576         }
577         return 0;
578 }