Merge branch 'devel' of master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6] / arch / mips / 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  * Copyright (C) 1991, 1992  Linus Torvalds
7  * Copyright (C) 1994 - 2000  Ralf Baechle
8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9  */
10 #include <linux/cache.h>
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/personality.h>
14 #include <linux/smp.h>
15 #include <linux/smp_lock.h>
16 #include <linux/kernel.h>
17 #include <linux/signal.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/ptrace.h>
21 #include <linux/unistd.h>
22 #include <linux/compiler.h>
23
24 #include <asm/abi.h>
25 #include <asm/asm.h>
26 #include <linux/bitops.h>
27 #include <asm/cacheflush.h>
28 #include <asm/fpu.h>
29 #include <asm/sim.h>
30 #include <asm/uaccess.h>
31 #include <asm/ucontext.h>
32 #include <asm/cpu-features.h>
33 #include <asm/war.h>
34
35 #include "signal-common.h"
36
37 #define DEBUG_SIG 0
38
39 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
40
41 /*
42  * Atomically swap in the new signal mask, and wait for a signal.
43  */
44
45 #ifdef CONFIG_TRAD_SIGNALS
46 save_static_function(sys_sigsuspend);
47 __attribute_used__ noinline static int
48 _sys_sigsuspend(nabi_no_regargs struct pt_regs regs)
49 {
50         sigset_t newset;
51         sigset_t __user *uset;
52
53         uset = (sigset_t __user *) regs.regs[4];
54         if (copy_from_user(&newset, uset, sizeof(sigset_t)))
55                 return -EFAULT;
56         sigdelsetmask(&newset, ~_BLOCKABLE);
57
58         spin_lock_irq(&current->sighand->siglock);
59         current->saved_sigmask = current->blocked;
60         current->blocked = newset;
61         recalc_sigpending();
62         spin_unlock_irq(&current->sighand->siglock);
63
64         current->state = TASK_INTERRUPTIBLE;
65         schedule();
66         set_thread_flag(TIF_RESTORE_SIGMASK);
67         return -ERESTARTNOHAND;
68 }
69 #endif
70
71 save_static_function(sys_rt_sigsuspend);
72 __attribute_used__ noinline static int
73 _sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
74 {
75         sigset_t newset;
76         sigset_t __user *unewset;
77         size_t sigsetsize;
78
79         /* XXX Don't preclude handling different sized sigset_t's.  */
80         sigsetsize = regs.regs[5];
81         if (sigsetsize != sizeof(sigset_t))
82                 return -EINVAL;
83
84         unewset = (sigset_t __user *) regs.regs[4];
85         if (copy_from_user(&newset, unewset, sizeof(newset)))
86                 return -EFAULT;
87         sigdelsetmask(&newset, ~_BLOCKABLE);
88
89         spin_lock_irq(&current->sighand->siglock);
90         current->saved_sigmask = current->blocked;
91         current->blocked = newset;
92         recalc_sigpending();
93         spin_unlock_irq(&current->sighand->siglock);
94
95         current->state = TASK_INTERRUPTIBLE;
96         schedule();
97         set_thread_flag(TIF_RESTORE_SIGMASK);
98         return -ERESTARTNOHAND;
99 }
100
101 #ifdef CONFIG_TRAD_SIGNALS
102 asmlinkage int sys_sigaction(int sig, const struct sigaction __user *act,
103         struct sigaction __user *oact)
104 {
105         struct k_sigaction new_ka, old_ka;
106         int ret;
107         int err = 0;
108
109         if (act) {
110                 old_sigset_t mask;
111
112                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
113                         return -EFAULT;
114                 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
115                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
116                 err |= __get_user(mask, &act->sa_mask.sig[0]);
117                 if (err)
118                         return -EFAULT;
119
120                 siginitset(&new_ka.sa.sa_mask, mask);
121         }
122
123         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
124
125         if (!ret && oact) {
126                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
127                         return -EFAULT;
128                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
129                 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
130                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
131                 err |= __put_user(0, &oact->sa_mask.sig[1]);
132                 err |= __put_user(0, &oact->sa_mask.sig[2]);
133                 err |= __put_user(0, &oact->sa_mask.sig[3]);
134                 if (err)
135                         return -EFAULT;
136         }
137
138         return ret;
139 }
140 #endif
141
142 asmlinkage int sys_sigaltstack(nabi_no_regargs struct pt_regs regs)
143 {
144         const stack_t __user *uss = (const stack_t __user *) regs.regs[4];
145         stack_t __user *uoss = (stack_t __user *) regs.regs[5];
146         unsigned long usp = regs.regs[29];
147
148         return do_sigaltstack(uss, uoss, usp);
149 }
150
151 /*
152  * Horribly complicated - with the bloody RM9000 workarounds enabled
153  * the signal trampolines is moving to the end of the structure so we can
154  * increase the alignment without breaking software compatibility.
155  */
156 #ifdef CONFIG_TRAD_SIGNALS
157 struct sigframe {
158         u32 sf_ass[4];                  /* argument save space for o32 */
159 #if ICACHE_REFILLS_WORKAROUND_WAR
160         u32 sf_pad[2];
161 #else
162         u32 sf_code[2];                 /* signal trampoline */
163 #endif
164         struct sigcontext sf_sc;
165         sigset_t sf_mask;
166 #if ICACHE_REFILLS_WORKAROUND_WAR
167         u32 sf_code[8] ____cacheline_aligned;   /* signal trampoline */
168 #endif
169 };
170 #endif
171
172 struct rt_sigframe {
173         u32 rs_ass[4];                  /* argument save space for o32 */
174 #if ICACHE_REFILLS_WORKAROUND_WAR
175         u32 rs_pad[2];
176 #else
177         u32 rs_code[2];                 /* signal trampoline */
178 #endif
179         struct siginfo rs_info;
180         struct ucontext rs_uc;
181 #if ICACHE_REFILLS_WORKAROUND_WAR
182         u32 rs_code[8] ____cacheline_aligned;   /* signal trampoline */
183 #endif
184 };
185
186 #ifdef CONFIG_TRAD_SIGNALS
187 save_static_function(sys_sigreturn);
188 __attribute_used__ noinline static void
189 _sys_sigreturn(nabi_no_regargs struct pt_regs regs)
190 {
191         struct sigframe __user *frame;
192         sigset_t blocked;
193
194         frame = (struct sigframe __user *) regs.regs[29];
195         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
196                 goto badframe;
197         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
198                 goto badframe;
199
200         sigdelsetmask(&blocked, ~_BLOCKABLE);
201         spin_lock_irq(&current->sighand->siglock);
202         current->blocked = blocked;
203         recalc_sigpending();
204         spin_unlock_irq(&current->sighand->siglock);
205
206         if (restore_sigcontext(&regs, &frame->sf_sc))
207                 goto badframe;
208
209         /*
210          * Don't let your children do this ...
211          */
212         __asm__ __volatile__(
213                 "move\t$29, %0\n\t"
214                 "j\tsyscall_exit"
215                 :/* no outputs */
216                 :"r" (&regs));
217         /* Unreached */
218
219 badframe:
220         force_sig(SIGSEGV, current);
221 }
222 #endif /* CONFIG_TRAD_SIGNALS */
223
224 save_static_function(sys_rt_sigreturn);
225 __attribute_used__ noinline static void
226 _sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
227 {
228         struct rt_sigframe __user *frame;
229         sigset_t set;
230         stack_t st;
231
232         frame = (struct rt_sigframe __user *) regs.regs[29];
233         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
234                 goto badframe;
235         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
236                 goto badframe;
237
238         sigdelsetmask(&set, ~_BLOCKABLE);
239         spin_lock_irq(&current->sighand->siglock);
240         current->blocked = set;
241         recalc_sigpending();
242         spin_unlock_irq(&current->sighand->siglock);
243
244         if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
245                 goto badframe;
246
247         if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
248                 goto badframe;
249         /* It is more difficult to avoid calling this function than to
250            call it and ignore errors.  */
251         do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
252
253         /*
254          * Don't let your children do this ...
255          */
256         __asm__ __volatile__(
257                 "move\t$29, %0\n\t"
258                 "j\tsyscall_exit"
259                 :/* no outputs */
260                 :"r" (&regs));
261         /* Unreached */
262
263 badframe:
264         force_sig(SIGSEGV, current);
265 }
266
267 #ifdef CONFIG_TRAD_SIGNALS
268 int setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
269         int signr, sigset_t *set)
270 {
271         struct sigframe __user *frame;
272         int err = 0;
273
274         frame = get_sigframe(ka, regs, sizeof(*frame));
275         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
276                 goto give_sigsegv;
277
278         install_sigtramp(frame->sf_code, __NR_sigreturn);
279
280         err |= setup_sigcontext(regs, &frame->sf_sc);
281         err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
282         if (err)
283                 goto give_sigsegv;
284
285         /*
286          * Arguments to signal handler:
287          *
288          *   a0 = signal number
289          *   a1 = 0 (should be cause)
290          *   a2 = pointer to struct sigcontext
291          *
292          * $25 and c0_epc point to the signal handler, $29 points to the
293          * struct sigframe.
294          */
295         regs->regs[ 4] = signr;
296         regs->regs[ 5] = 0;
297         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
298         regs->regs[29] = (unsigned long) frame;
299         regs->regs[31] = (unsigned long) frame->sf_code;
300         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
301
302 #if DEBUG_SIG
303         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
304                current->comm, current->pid,
305                frame, regs->cp0_epc, frame->regs[31]);
306 #endif
307         return 0;
308
309 give_sigsegv:
310         force_sigsegv(signr, current);
311         return -EFAULT;
312 }
313 #endif
314
315 int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
316         int signr, sigset_t *set, siginfo_t *info)
317 {
318         struct rt_sigframe __user *frame;
319         int err = 0;
320
321         frame = get_sigframe(ka, regs, sizeof(*frame));
322         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
323                 goto give_sigsegv;
324
325         install_sigtramp(frame->rs_code, __NR_rt_sigreturn);
326
327         /* Create siginfo.  */
328         err |= copy_siginfo_to_user(&frame->rs_info, info);
329
330         /* Create the ucontext.  */
331         err |= __put_user(0, &frame->rs_uc.uc_flags);
332         err |= __put_user(NULL, &frame->rs_uc.uc_link);
333         err |= __put_user((void __user *)current->sas_ss_sp,
334                           &frame->rs_uc.uc_stack.ss_sp);
335         err |= __put_user(sas_ss_flags(regs->regs[29]),
336                           &frame->rs_uc.uc_stack.ss_flags);
337         err |= __put_user(current->sas_ss_size,
338                           &frame->rs_uc.uc_stack.ss_size);
339         err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
340         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
341
342         if (err)
343                 goto give_sigsegv;
344
345         /*
346          * Arguments to signal handler:
347          *
348          *   a0 = signal number
349          *   a1 = 0 (should be cause)
350          *   a2 = pointer to ucontext
351          *
352          * $25 and c0_epc point to the signal handler, $29 points to
353          * the struct rt_sigframe.
354          */
355         regs->regs[ 4] = signr;
356         regs->regs[ 5] = (unsigned long) &frame->rs_info;
357         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
358         regs->regs[29] = (unsigned long) frame;
359         regs->regs[31] = (unsigned long) frame->rs_code;
360         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
361
362 #if DEBUG_SIG
363         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
364                current->comm, current->pid,
365                frame, regs->cp0_epc, regs->regs[31]);
366 #endif
367         return 0;
368
369 give_sigsegv:
370         force_sigsegv(signr, current);
371         return -EFAULT;
372 }
373
374 static inline int handle_signal(unsigned long sig, siginfo_t *info,
375         struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs)
376 {
377         int ret;
378
379         switch(regs->regs[0]) {
380         case ERESTART_RESTARTBLOCK:
381         case ERESTARTNOHAND:
382                 regs->regs[2] = EINTR;
383                 break;
384         case ERESTARTSYS:
385                 if (!(ka->sa.sa_flags & SA_RESTART)) {
386                         regs->regs[2] = EINTR;
387                         break;
388                 }
389         /* fallthrough */
390         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
391                 regs->regs[7] = regs->regs[26];
392                 regs->cp0_epc -= 8;
393         }
394
395         regs->regs[0] = 0;              /* Don't deal with this again.  */
396
397         if (sig_uses_siginfo(ka))
398                 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info);
399         else
400                 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset);
401
402         spin_lock_irq(&current->sighand->siglock);
403         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
404         if (!(ka->sa.sa_flags & SA_NODEFER))
405                 sigaddset(&current->blocked,sig);
406         recalc_sigpending();
407         spin_unlock_irq(&current->sighand->siglock);
408
409         return ret;
410 }
411
412 void do_signal(struct pt_regs *regs)
413 {
414         struct k_sigaction ka;
415         sigset_t *oldset;
416         siginfo_t info;
417         int signr;
418
419         /*
420          * We want the common case to go fast, which is why we may in certain
421          * cases get here from kernel mode. Just return without doing anything
422          * if so.
423          */
424         if (!user_mode(regs))
425                 return;
426
427         if (try_to_freeze())
428                 goto no_signal;
429
430         if (test_thread_flag(TIF_RESTORE_SIGMASK))
431                 oldset = &current->saved_sigmask;
432         else
433                 oldset = &current->blocked;
434
435
436         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
437         if (signr > 0) {
438                 /* Whee!  Actually deliver the signal.  */
439                 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
440                         /*
441                          * A signal was successfully delivered; the saved
442                          * sigmask will have been stored in the signal frame,
443                          * and will be restored by sigreturn, so we can simply
444                          * clear the TIF_RESTORE_SIGMASK flag.
445                          */
446                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
447                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
448                 }
449         }
450
451 no_signal:
452         /*
453          * Who's code doesn't conform to the restartable syscall convention
454          * dies here!!!  The li instruction, a single machine instruction,
455          * must directly be followed by the syscall instruction.
456          */
457         if (regs->regs[0]) {
458                 if (regs->regs[2] == ERESTARTNOHAND ||
459                     regs->regs[2] == ERESTARTSYS ||
460                     regs->regs[2] == ERESTARTNOINTR) {
461                         regs->regs[7] = regs->regs[26];
462                         regs->cp0_epc -= 8;
463                 }
464                 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
465                         regs->regs[2] = __NR_restart_syscall;
466                         regs->regs[7] = regs->regs[26];
467                         regs->cp0_epc -= 4;
468                 }
469         }
470
471         /*
472          * If there's no signal to deliver, we just put the saved sigmask
473          * back
474          */
475         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
476                 clear_thread_flag(TIF_RESTORE_SIGMASK);
477                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
478         }
479 }
480
481 /*
482  * notification of userspace execution resumption
483  * - triggered by the TIF_WORK_MASK flags
484  */
485 asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
486         __u32 thread_info_flags)
487 {
488         /* deal with pending signal delivery */
489         if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
490                 current->thread.abi->do_signal(regs);
491 }