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