xtensa process.c must #include <linux/fs.h>
[linux-2.6] / arch / xtensa / kernel / signal.c
1 /*
2  * arch/xtensa/kernel/signal.c
3  *
4  * Default platform functions.
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file "COPYING" in the main directory of this archive
8  * for more details.
9  *
10  * Copyright (C) 2005, 2006 Tensilica Inc.
11  * Copyright (C) 1991, 1992  Linus Torvalds
12  * 1997-11-28  Modified for POSIX.1b signals by Richard Henderson
13  *
14  * Chris Zankel <chris@zankel.net>
15  * Joe Taylor <joe@tensilica.com>
16  */
17
18 #include <linux/signal.h>
19 #include <linux/errno.h>
20 #include <linux/ptrace.h>
21 #include <linux/personality.h>
22 #include <linux/freezer.h>
23
24 #include <asm/ucontext.h>
25 #include <asm/uaccess.h>
26 #include <asm/cacheflush.h>
27 #include <asm/coprocessor.h>
28 #include <asm/unistd.h>
29
30 #define DEBUG_SIG  0
31
32 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
33
34 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
35
36 extern struct task_struct *coproc_owners[];
37
38 extern void release_all_cp (struct task_struct *);
39
40 struct rt_sigframe
41 {
42         struct siginfo info;
43         struct ucontext uc;
44         cp_state_t cpstate;
45         unsigned char retcode[6];
46         unsigned int window[4];
47 };
48
49 /* 
50  * Flush register windows stored in pt_regs to stack.
51  * Returns 1 for errors.
52  *
53  * Note that windowbase, windowstart, and wmask are not updated!
54  */
55
56 int
57 flush_window_regs_user(struct pt_regs *regs)
58 {
59         const unsigned long ws = regs->windowstart;
60         const unsigned long wb = regs->windowbase;
61         unsigned long sp = 0;
62         unsigned long wm;
63         int err = 1;
64         int base;
65
66         /* Return if no other frames. */
67
68         if (regs->wmask == 1)
69                 return 0;
70
71         /* Rotate windowmask and skip empty frames. */
72
73         wm = (ws >> wb) | (ws << (XCHAL_NUM_AREGS / 4 - wb));
74         base = (XCHAL_NUM_AREGS / 4) - (regs->wmask >> 4);
75                 
76         /* For call8 or call12 frames, we need the previous stack pointer. */
77
78         if ((regs->wmask & 2) == 0)
79                 if (__get_user(sp, (int*)(regs->areg[base * 4 + 1] - 12)))
80                         goto errout;
81
82         /* Spill frames to stack. */
83
84         while (base < XCHAL_NUM_AREGS / 4) {
85
86                 int m = (wm >> base);
87                 int inc = 0;
88
89                 /* Save registers a4..a7 (call8) or a4...a11 (call12) */
90
91                 if (m & 2) {                    /* call4 */
92                         inc = 1;
93
94                 } else if (m & 4) {             /* call8 */
95                         if (copy_to_user((void*)(sp - 32),
96                                            &regs->areg[(base + 1) * 4], 16))
97                                 goto errout;
98                         inc = 2;
99
100                 } else if (m & 8) {     /* call12 */
101                         if (copy_to_user((void*)(sp - 48),
102                                            &regs->areg[(base + 1) * 4], 32))
103                                 goto errout;
104                         inc = 3;
105                 }
106
107                 /* Save current frame a0..a3 under next SP */
108
109                 sp = regs->areg[((base + inc) * 4 + 1) % XCHAL_NUM_AREGS];
110                 if (copy_to_user((void*)(sp - 16), &regs->areg[base * 4], 16))
111                         goto errout;
112
113                 /* Get current stack pointer for next loop iteration. */
114
115                 sp = regs->areg[base * 4 + 1];
116                 base += inc;
117         }
118
119         return 0;
120
121 errout:
122         return err;
123 }
124
125 /*
126  * Note: We don't copy double exception 'regs', we have to finish double exc. 
127  * first before we return to signal handler! This dbl.exc.handler might cause 
128  * another double exception, but I think we are fine as the situation is the 
129  * same as if we had returned to the signal handerl and got an interrupt 
130  * immediately...
131  */
132
133 static int
134 setup_sigcontext(struct sigcontext __user *sc, cp_state_t *cpstate,
135                  struct pt_regs *regs, unsigned long mask)
136 {
137         int err = 0;
138
139 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
140         COPY(pc);
141         COPY(ps);
142         COPY(lbeg);
143         COPY(lend);
144         COPY(lcount);
145         COPY(sar);
146 #undef COPY
147
148         err |= flush_window_regs_user(regs);
149         err |= __copy_to_user (sc->sc_a, regs->areg, 16 * 4);
150
151         // err |= __copy_to_user (sc->sc_a, regs->areg, XCHAL_NUM_AREGS * 4)
152
153 #if XCHAL_HAVE_CP
154 # error Coprocessors unsupported
155         err |= save_cpextra(cpstate);
156         err |= __put_user(err ? NULL : cpstate, &sc->sc_cpstate);
157 #endif
158         /* non-iBCS2 extensions.. */
159         err |= __put_user(mask, &sc->oldmask);
160
161         return err;
162 }
163
164 static int
165 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
166 {
167         unsigned int err = 0;
168         unsigned long ps;
169
170 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
171         COPY(pc);
172         COPY(lbeg);
173         COPY(lend);
174         COPY(lcount);
175         COPY(sar);
176 #undef COPY
177
178         /* All registers were flushed to stack. Start with a prestine frame. */
179
180         regs->wmask = 1;
181         regs->windowbase = 0;
182         regs->windowstart = 1;
183
184         /* For PS, restore only PS.CALLINC.
185          * Assume that all other bits are either the same as for the signal
186          * handler, or the user mode value doesn't matter (e.g. PS.OWB).
187          */
188         err |= __get_user(ps, &sc->sc_ps);
189         regs->ps = (regs->ps & ~PS_CALLINC_MASK) | (ps & PS_CALLINC_MASK);
190
191         /* Additional corruption checks */
192
193         if ((regs->lcount > 0)
194             && ((regs->lbeg > TASK_SIZE) || (regs->lend > TASK_SIZE)) )
195                 err = 1;
196
197         err |= __copy_from_user(regs->areg, sc->sc_a, 16 * 4);
198
199 #if XCHAL_HAVE_CP
200 # error Coprocessors unsupported
201         /* The signal handler may have used coprocessors in which
202          * case they are still enabled.  We disable them to force a
203          * reloading of the original task's CP state by the lazy
204          * context-switching mechanisms of CP exception handling.
205          * Also, we essentially discard any coprocessor state that the
206          * signal handler created. */
207
208         if (!err) {
209           struct task_struct *tsk = current;
210           release_all_cp(tsk);
211           err |= __copy_from_user(tsk->thread.cpextra, sc->sc_cpstate, 
212                                   XTENSA_CP_EXTRA_SIZE);
213         }
214 #endif
215
216         regs->syscall = -1;             /* disable syscall checks */
217         return err;
218 }
219
220
221
222 /*
223  * Do a signal return; undo the signal stack.
224  */
225
226 asmlinkage long xtensa_rt_sigreturn(long a0, long a1, long a2, long a3,
227                                     long a4, long a5, struct pt_regs *regs)
228 {
229         struct rt_sigframe __user *frame;
230         sigset_t set;
231         int ret;
232
233         if (regs->depc > 64)
234                 panic("rt_sigreturn in double exception!\n");
235
236         frame = (struct rt_sigframe __user *) regs->areg[1];
237
238         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
239                 goto badframe;
240
241         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
242                 goto badframe;
243
244         sigdelsetmask(&set, ~_BLOCKABLE);
245         spin_lock_irq(&current->sighand->siglock);
246         current->blocked = set;
247         recalc_sigpending();
248         spin_unlock_irq(&current->sighand->siglock);
249
250         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
251                 goto badframe;
252
253         ret = regs->areg[2];
254
255         if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->areg[1]) == -EFAULT)
256                 goto badframe;
257
258         return ret;
259
260 badframe:
261         force_sig(SIGSEGV, current);
262         return 0;
263 }
264
265
266
267 /*
268  * Set up a signal frame.
269  */
270
271 static int
272 gen_return_code(unsigned char *codemem)
273 {
274         int err = 0;
275
276         /*
277          * The 12-bit immediate is really split up within the 24-bit MOVI
278          * instruction.  As long as the above system call numbers fit within
279          * 8-bits, the following code works fine. See the Xtensa ISA for
280          * details.
281          */
282
283 #if __NR_rt_sigreturn > 255
284 # error Generating the MOVI instruction below breaks!
285 #endif
286
287 #ifdef __XTENSA_EB__   /* Big Endian version */
288         /* Generate instruction:  MOVI a2, __NR_rt_sigreturn */
289         err |= __put_user(0x22, &codemem[0]);
290         err |= __put_user(0x0a, &codemem[1]);
291         err |= __put_user(__NR_rt_sigreturn, &codemem[2]);
292         /* Generate instruction:  SYSCALL */
293         err |= __put_user(0x00, &codemem[3]);
294         err |= __put_user(0x05, &codemem[4]);
295         err |= __put_user(0x00, &codemem[5]);
296
297 #elif defined __XTENSA_EL__   /* Little Endian version */
298         /* Generate instruction:  MOVI a2, __NR_rt_sigreturn */
299         err |= __put_user(0x22, &codemem[0]);
300         err |= __put_user(0xa0, &codemem[1]);
301         err |= __put_user(__NR_rt_sigreturn, &codemem[2]);
302         /* Generate instruction:  SYSCALL */
303         err |= __put_user(0x00, &codemem[3]);
304         err |= __put_user(0x50, &codemem[4]);
305         err |= __put_user(0x00, &codemem[5]);
306 #else
307 # error Must use compiler for Xtensa processors.
308 #endif
309
310         /* Flush generated code out of the data cache */
311
312         if (err == 0) {
313                 __invalidate_icache_range((unsigned long)codemem, 6UL);
314                 __flush_invalidate_dcache_range((unsigned long)codemem, 6UL);
315         }
316
317         return err;
318 }
319
320
321 static void setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
322                         sigset_t *set, struct pt_regs *regs)
323 {
324         struct rt_sigframe *frame;
325         int err = 0;
326         int signal;
327         unsigned long sp, ra;
328
329         sp = regs->areg[1];
330
331         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp)) {
332                 sp = current->sas_ss_sp + current->sas_ss_size;
333         }
334
335         frame = (void *)((sp - sizeof(*frame)) & -16ul);
336
337         if (regs->depc > 64)
338                 panic ("Double exception sys_sigreturn\n");
339
340         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
341                 goto give_sigsegv;
342         }
343
344         signal = current_thread_info()->exec_domain
345                 && current_thread_info()->exec_domain->signal_invmap
346                 && sig < 32
347                 ? current_thread_info()->exec_domain->signal_invmap[sig]
348                 : sig;
349
350         if (ka->sa.sa_flags & SA_SIGINFO) {
351                 err |= copy_siginfo_to_user(&frame->info, info);
352         }
353
354         /* Create the user context.  */
355
356         err |= __put_user(0, &frame->uc.uc_flags);
357         err |= __put_user(0, &frame->uc.uc_link);
358         err |= __put_user((void *)current->sas_ss_sp,
359                           &frame->uc.uc_stack.ss_sp);
360         err |= __put_user(sas_ss_flags(regs->areg[1]),
361                           &frame->uc.uc_stack.ss_flags);
362         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
363         err |= setup_sigcontext(&frame->uc.uc_mcontext, &frame->cpstate,
364                                 regs, set->sig[0]);
365         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
366
367         /* Create sys_rt_sigreturn syscall in stack frame */
368
369         err |= gen_return_code(frame->retcode);
370
371         if (err) {
372                 goto give_sigsegv;
373         }
374                 
375
376         /* 
377          * Create signal handler execution context.
378          * Return context not modified until this point.
379          */
380
381         /* Set up registers for signal handler */
382         start_thread(regs, (unsigned long) ka->sa.sa_handler, 
383                      (unsigned long) frame);
384
385         /* Set up a stack frame for a call4
386          * Note: PS.CALLINC is set to one by start_thread
387          */
388         ra = (unsigned long) frame->retcode;
389         regs->areg[4] = (((unsigned long) ra) & 0x3fffffff) | 0x40000000;
390         regs->areg[6] = (unsigned long) signal;
391         regs->areg[7] = (unsigned long) &frame->info;
392         regs->areg[8] = (unsigned long) &frame->uc;
393
394         /* Set access mode to USER_DS.  Nomenclature is outdated, but
395          * functionality is used in uaccess.h
396          */
397         set_fs(USER_DS);
398
399 #if DEBUG_SIG
400         printk("SIG rt deliver (%s:%d): signal=%d sp=%p pc=%08x\n",
401                 current->comm, current->pid, signal, frame, regs->pc);
402 #endif
403
404         return;
405
406 give_sigsegv:
407         if (sig == SIGSEGV)
408                 ka->sa.sa_handler = SIG_DFL;
409         force_sig(SIGSEGV, current);
410 }
411
412 /*
413  * Atomically swap in the new signal mask, and wait for a signal.
414  */
415
416 asmlinkage long xtensa_rt_sigsuspend(sigset_t __user *unewset, 
417                                      size_t sigsetsize,
418                                      long a2, long a3, long a4, long a5, 
419                                      struct pt_regs *regs)
420 {
421         sigset_t saveset, newset;
422
423         /* XXX: Don't preclude handling different sized sigset_t's.  */
424         if (sigsetsize != sizeof(sigset_t))
425                 return -EINVAL;
426
427         if (copy_from_user(&newset, unewset, sizeof(newset)))
428                 return -EFAULT;
429
430         sigdelsetmask(&newset, ~_BLOCKABLE);
431         spin_lock_irq(&current->sighand->siglock);
432         saveset = current->blocked;
433         current->blocked = newset;
434         recalc_sigpending();
435         spin_unlock_irq(&current->sighand->siglock);
436
437         regs->areg[2] = -EINTR;
438         while (1) {
439                 current->state = TASK_INTERRUPTIBLE;
440                 schedule();
441                 if (do_signal(regs, &saveset))
442                         return -EINTR;
443         }
444 }
445
446 asmlinkage long xtensa_sigaltstack(const stack_t __user *uss, 
447                                    stack_t __user *uoss,
448                                    long a2, long a3, long a4, long a5,
449                                    struct pt_regs *regs)
450 {
451         return do_sigaltstack(uss, uoss, regs->areg[1]);
452 }
453
454
455
456 /*
457  * Note that 'init' is a special process: it doesn't get signals it doesn't
458  * want to handle. Thus you cannot kill init even with a SIGKILL even by
459  * mistake.
460  *
461  * Note that we go through the signals twice: once to check the signals that
462  * the kernel can handle, and then we build all the user-level signal handling
463  * stack-frames in one go after that.
464  */
465 int do_signal(struct pt_regs *regs, sigset_t *oldset)
466 {
467         siginfo_t info;
468         int signr;
469         struct k_sigaction ka;
470
471         if (!user_mode(regs))
472                 return 0;
473
474         if (try_to_freeze())
475                 goto no_signal;
476
477         if (!oldset)
478                 oldset = &current->blocked;
479
480         task_pt_regs(current)->icountlevel = 0;
481
482         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
483
484         if (signr > 0) {
485
486                 /* Are we from a system call? */
487
488                 if ((signed)regs->syscall >= 0) {
489
490                         /* If so, check system call restarting.. */
491
492                         switch (regs->areg[2]) {
493                                 case -ERESTARTNOHAND:
494                                 case -ERESTART_RESTARTBLOCK:
495                                         regs->areg[2] = -EINTR;
496                                         break;
497
498                                 case -ERESTARTSYS:
499                                         if (!(ka.sa.sa_flags & SA_RESTART)) {
500                                                 regs->areg[2] = -EINTR;
501                                                 break;
502                                         }
503                                         /* fallthrough */
504                                 case -ERESTARTNOINTR:
505                                         regs->areg[2] = regs->syscall;
506                                         regs->pc -= 3;
507                                         break;
508
509                                 default:
510                                         /* nothing to do */
511                                         if (regs->areg[2] != 0)
512                                         break;
513                         }
514                 }
515
516                 /* Whee!  Actually deliver the signal.  */
517                 /* Set up the stack frame */
518                 setup_frame(signr, &ka, &info, oldset, regs);
519
520                 if (ka.sa.sa_flags & SA_ONESHOT)
521                         ka.sa.sa_handler = SIG_DFL;
522
523                 spin_lock_irq(&current->sighand->siglock);
524                 sigorsets(&current->blocked, &current->blocked, &ka.sa.sa_mask);
525                 if (!(ka.sa.sa_flags & SA_NODEFER))
526                         sigaddset(&current->blocked, signr);
527                 recalc_sigpending();
528                 spin_unlock_irq(&current->sighand->siglock);
529                 if (current->ptrace & PT_SINGLESTEP)
530                         task_pt_regs(current)->icountlevel = 1;
531
532                 return 1;
533         }
534
535 no_signal:
536         /* Did we come from a system call? */
537         if ((signed) regs->syscall >= 0) {
538                 /* Restart the system call - no handlers present */
539                 switch (regs->areg[2]) {
540                 case -ERESTARTNOHAND:
541                 case -ERESTARTSYS:
542                 case -ERESTARTNOINTR:
543                         regs->areg[2] = regs->syscall;
544                         regs->pc -= 3;
545                         break;
546                 case -ERESTART_RESTARTBLOCK:
547                         regs->areg[2] = __NR_restart_syscall;
548                         regs->pc -= 3;
549                         break;
550                 }
551         }
552         if (current->ptrace & PT_SINGLESTEP)
553                 task_pt_regs(current)->icountlevel = 1;
554         return 0;
555 }
556