File: /usr/src/linux/arch/sparc64/kernel/signal32.c
1 /* $Id: signal32.c,v 1.70 2001/04/24 01:09:12 davem Exp $
2 * arch/sparc64/kernel/signal32.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
7 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
9 */
10
11 #include <linux/sched.h>
12 #include <linux/kernel.h>
13 #include <linux/signal.h>
14 #include <linux/errno.h>
15 #include <linux/wait.h>
16 #include <linux/ptrace.h>
17 #include <linux/unistd.h>
18 #include <linux/mm.h>
19 #include <linux/smp_lock.h>
20
21 #include <asm/uaccess.h>
22 #include <asm/bitops.h>
23 #include <asm/ptrace.h>
24 #include <asm/svr4.h>
25 #include <asm/pgtable.h>
26 #include <asm/psrcompat.h>
27 #include <asm/fpumacro.h>
28 #include <asm/visasm.h>
29
30 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
31
32 asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs,
33 unsigned long orig_o0, int ret_from_syscall);
34
35 /* This turned off for production... */
36 /* #define DEBUG_SIGNALS 1 */
37 /* #define DEBUG_SIGNALS_TRACE 1 */
38 /* #define DEBUG_SIGNALS_MAPS 1 */
39 /* #define DEBUG_SIGNALS_TLB 1 */
40
41 /* Signal frames: the original one (compatible with SunOS):
42 *
43 * Set up a signal frame... Make the stack look the way SunOS
44 * expects it to look which is basically:
45 *
46 * ---------------------------------- <-- %sp at signal time
47 * Struct sigcontext
48 * Signal address
49 * Ptr to sigcontext area above
50 * Signal code
51 * The signal number itself
52 * One register window
53 * ---------------------------------- <-- New %sp
54 */
55 struct signal_sframe32 {
56 struct reg_window32 sig_window;
57 int sig_num;
58 int sig_code;
59 /* struct sigcontext32 * */ u32 sig_scptr;
60 int sig_address;
61 struct sigcontext32 sig_context;
62 unsigned extramask[_NSIG_WORDS32 - 1];
63 };
64
65 /*
66 * And the new one, intended to be used for Linux applications only
67 * (we have enough in there to work with clone).
68 * All the interesting bits are in the info field.
69 */
70 struct new_signal_frame32 {
71 struct sparc_stackf32 ss;
72 __siginfo32_t info;
73 /* __siginfo_fpu32_t * */ u32 fpu_save;
74 unsigned int insns [2];
75 unsigned extramask[_NSIG_WORDS32 - 1];
76 unsigned extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
77 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
78 siginfo_extra_v8plus_t v8plus;
79 __siginfo_fpu_t fpu_state;
80 };
81
82 struct rt_signal_frame32 {
83 struct sparc_stackf32 ss;
84 siginfo_t32 info;
85 struct pt_regs32 regs;
86 sigset_t32 mask;
87 /* __siginfo_fpu32_t * */ u32 fpu_save;
88 unsigned int insns [2];
89 stack_t32 stack;
90 unsigned extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
91 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
92 siginfo_extra_v8plus_t v8plus;
93 __siginfo_fpu_t fpu_state;
94 };
95
96 /* Align macros */
97 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7)))
98 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7)))
99 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
100
101 int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
102 {
103 int err;
104
105 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
106 return -EFAULT;
107
108 /* If you change siginfo_t structure, please be sure
109 this code is fixed accordingly.
110 It should never copy any pad contained in the structure
111 to avoid security leaks, but must copy the generic
112 3 ints plus the relevant union member.
113 This routine must convert siginfo from 64bit to 32bit as well
114 at the same time. */
115 err = __put_user(from->si_signo, &to->si_signo);
116 err |= __put_user(from->si_errno, &to->si_errno);
117 err |= __put_user((short)from->si_code, &to->si_code);
118 if (from->si_code < 0)
119 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
120 else {
121 switch (from->si_code >> 16) {
122 case __SI_CHLD >> 16:
123 err |= __put_user(from->si_utime, &to->si_utime);
124 err |= __put_user(from->si_stime, &to->si_stime);
125 err |= __put_user(from->si_status, &to->si_status);
126 default:
127 err |= __put_user(from->si_pid, &to->si_pid);
128 err |= __put_user(from->si_uid, &to->si_uid);
129 break;
130 case __SI_FAULT >> 16:
131 case __SI_POLL >> 16:
132 err |= __put_user(from->si_trapno, &to->si_trapno);
133 err |= __put_user((long)from->si_addr, &to->si_addr);
134 break;
135 /* case __SI_RT: This is not generated by the kernel as of now. */
136 }
137 }
138 return err;
139 }
140
141 /*
142 * atomically swap in the new signal mask, and wait for a signal.
143 * This is really tricky on the Sparc, watch out...
144 */
145 asmlinkage void _sigpause32_common(old_sigset_t32 set, struct pt_regs *regs)
146 {
147 sigset_t saveset;
148
149 set &= _BLOCKABLE;
150 spin_lock_irq(¤t->sigmask_lock);
151 saveset = current->blocked;
152 siginitset(¤t->blocked, set);
153 recalc_sigpending(current);
154 spin_unlock_irq(¤t->sigmask_lock);
155
156 regs->tpc = regs->tnpc;
157 regs->tnpc += 4;
158 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
159 regs->tpc &= 0xffffffff;
160 regs->tnpc &= 0xffffffff;
161 }
162
163 /* Condition codes and return value where set here for sigpause,
164 * and so got used by setup_frame, which again causes sigreturn()
165 * to return -EINTR.
166 */
167 while (1) {
168 current->state = TASK_INTERRUPTIBLE;
169 schedule();
170 /*
171 * Return -EINTR and set condition code here,
172 * so the interrupted system call actually returns
173 * these.
174 */
175 regs->tstate |= TSTATE_ICARRY;
176 regs->u_regs[UREG_I0] = EINTR;
177 if (do_signal32(&saveset, regs, 0, 0))
178 return;
179 }
180 }
181
182 asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *regs)
183 {
184 sigset_t oldset, set;
185 sigset_t32 set32;
186
187 /* XXX: Don't preclude handling different sized sigset_t's. */
188 if (((__kernel_size_t32)sigsetsize) != sizeof(sigset_t)) {
189 regs->tstate |= TSTATE_ICARRY;
190 regs->u_regs[UREG_I0] = EINVAL;
191 return;
192 }
193 if (copy_from_user(&set32, (void *)(long)uset, sizeof(set32))) {
194 regs->tstate |= TSTATE_ICARRY;
195 regs->u_regs[UREG_I0] = EFAULT;
196 return;
197 }
198 switch (_NSIG_WORDS) {
199 case 4: set.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
200 case 3: set.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
201 case 2: set.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
202 case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
203 }
204 sigdelsetmask(&set, ~_BLOCKABLE);
205 spin_lock_irq(¤t->sigmask_lock);
206 oldset = current->blocked;
207 current->blocked = set;
208 recalc_sigpending(current);
209 spin_unlock_irq(¤t->sigmask_lock);
210
211 regs->tpc = regs->tnpc;
212 regs->tnpc += 4;
213 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
214 regs->tpc &= 0xffffffff;
215 regs->tnpc &= 0xffffffff;
216 }
217
218 /* Condition codes and return value where set here for sigpause,
219 * and so got used by setup_frame, which again causes sigreturn()
220 * to return -EINTR.
221 */
222 while (1) {
223 current->state = TASK_INTERRUPTIBLE;
224 schedule();
225 /*
226 * Return -EINTR and set condition code here,
227 * so the interrupted system call actually returns
228 * these.
229 */
230 regs->tstate |= TSTATE_ICARRY;
231 regs->u_regs[UREG_I0] = EINTR;
232 if (do_signal32(&oldset, regs, 0, 0))
233 return;
234 }
235 }
236
237 static inline int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t *fpu)
238 {
239 unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
240 unsigned long fprs;
241 int err;
242
243 err = __get_user(fprs, &fpu->si_fprs);
244 fprs_write(0);
245 regs->tstate &= ~TSTATE_PEF;
246 if (fprs & FPRS_DL)
247 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
248 if (fprs & FPRS_DU)
249 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
250 err |= __get_user(current->thread.xfsr[0], &fpu->si_fsr);
251 err |= __get_user(current->thread.gsr[0], &fpu->si_gsr);
252 current->thread.fpsaved[0] |= fprs;
253 return err;
254 }
255
256 void do_new_sigreturn32(struct pt_regs *regs)
257 {
258 struct new_signal_frame32 *sf;
259 unsigned int psr;
260 unsigned pc, npc, fpu_save;
261 sigset_t set;
262 unsigned seta[_NSIG_WORDS32];
263 int err, i;
264
265 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
266 sf = (struct new_signal_frame32 *) regs->u_regs [UREG_FP];
267
268 /* 1. Make sure we are not getting garbage from the user */
269 if (verify_area (VERIFY_READ, sf, sizeof (*sf)) ||
270 (((unsigned long) sf) & 3))
271 goto segv;
272
273 get_user(pc, &sf->info.si_regs.pc);
274 __get_user(npc, &sf->info.si_regs.npc);
275
276 if ((pc | npc) & 3)
277 goto segv;
278
279 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
280 pc &= 0xffffffff;
281 npc &= 0xffffffff;
282 }
283 regs->tpc = pc;
284 regs->tnpc = npc;
285
286 /* 2. Restore the state */
287 err = __get_user(regs->y, &sf->info.si_regs.y);
288 err |= __get_user(psr, &sf->info.si_regs.psr);
289
290 for (i = UREG_G1; i <= UREG_I7; i++)
291 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
292 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
293 err |= __get_user(i, &sf->v8plus.g_upper[0]);
294 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
295 for (i = UREG_G1; i <= UREG_I7; i++)
296 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
297 }
298 }
299
300 /* User can only change condition codes in %tstate. */
301 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
302 regs->tstate |= psr_to_tstate_icc(psr);
303
304 err |= __get_user(fpu_save, &sf->fpu_save);
305 if (fpu_save)
306 err |= restore_fpu_state32(regs, &sf->fpu_state);
307 err |= __get_user(seta[0], &sf->info.si_mask);
308 err |= copy_from_user(seta+1, &sf->extramask, (_NSIG_WORDS32 - 1) * sizeof(unsigned));
309 if (err)
310 goto segv;
311 switch (_NSIG_WORDS) {
312 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
313 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
314 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
315 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
316 }
317 sigdelsetmask(&set, ~_BLOCKABLE);
318 spin_lock_irq(¤t->sigmask_lock);
319 current->blocked = set;
320 recalc_sigpending(current);
321 spin_unlock_irq(¤t->sigmask_lock);
322 return;
323
324 segv:
325 do_exit(SIGSEGV);
326 }
327
328 asmlinkage void do_sigreturn32(struct pt_regs *regs)
329 {
330 struct sigcontext32 *scptr;
331 unsigned pc, npc, psr;
332 sigset_t set;
333 unsigned seta[_NSIG_WORDS32];
334 int err;
335
336 synchronize_user_stack();
337 if (current->thread.flags & SPARC_FLAG_NEWSIGNALS)
338 return do_new_sigreturn32(regs);
339
340 scptr = (struct sigcontext32 *)
341 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
342 /* Check sanity of the user arg. */
343 if(verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
344 (((unsigned long) scptr) & 3))
345 goto segv;
346
347 err = __get_user(pc, &scptr->sigc_pc);
348 err |= __get_user(npc, &scptr->sigc_npc);
349
350 if((pc | npc) & 3)
351 goto segv; /* Nice try. */
352
353 err |= __get_user(seta[0], &scptr->sigc_mask);
354 /* Note that scptr + 1 points to extramask */
355 err |= copy_from_user(seta+1, scptr + 1, (_NSIG_WORDS32 - 1) * sizeof(unsigned));
356 if (err)
357 goto segv;
358 switch (_NSIG_WORDS) {
359 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
360 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
361 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
362 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
363 }
364 sigdelsetmask(&set, ~_BLOCKABLE);
365 spin_lock_irq(¤t->sigmask_lock);
366 current->blocked = set;
367 recalc_sigpending(current);
368 spin_unlock_irq(¤t->sigmask_lock);
369
370 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
371 pc &= 0xffffffff;
372 npc &= 0xffffffff;
373 }
374 regs->tpc = pc;
375 regs->tnpc = npc;
376 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
377 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
378 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
379
380 /* User can only change condition codes in %tstate. */
381 err |= __get_user(psr, &scptr->sigc_psr);
382 if (err)
383 goto segv;
384 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
385 regs->tstate |= psr_to_tstate_icc(psr);
386 return;
387
388 segv:
389 do_exit(SIGSEGV);
390 }
391
392 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
393 {
394 struct rt_signal_frame32 *sf;
395 unsigned int psr;
396 unsigned pc, npc, fpu_save;
397 sigset_t set;
398 sigset_t32 seta;
399 stack_t st;
400 int err, i;
401
402 synchronize_user_stack();
403 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
404 sf = (struct rt_signal_frame32 *) regs->u_regs [UREG_FP];
405
406 /* 1. Make sure we are not getting garbage from the user */
407 if (verify_area (VERIFY_READ, sf, sizeof (*sf)) ||
408 (((unsigned long) sf) & 3))
409 goto segv;
410
411 get_user(pc, &sf->regs.pc);
412 __get_user(npc, &sf->regs.npc);
413
414 if ((pc | npc) & 3)
415 goto segv;
416
417 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
418 pc &= 0xffffffff;
419 npc &= 0xffffffff;
420 }
421 regs->tpc = pc;
422 regs->tnpc = npc;
423
424 /* 2. Restore the state */
425 err = __get_user(regs->y, &sf->regs.y);
426 err |= __get_user(psr, &sf->regs.psr);
427
428 for (i = UREG_G1; i <= UREG_I7; i++)
429 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
430 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
431 err |= __get_user(i, &sf->v8plus.g_upper[0]);
432 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
433 for (i = UREG_G1; i <= UREG_I7; i++)
434 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
435 }
436 }
437
438 /* User can only change condition codes in %tstate. */
439 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
440 regs->tstate |= psr_to_tstate_icc(psr);
441
442 err |= __get_user(fpu_save, &sf->fpu_save);
443 if (fpu_save)
444 err |= restore_fpu_state32(regs, &sf->fpu_state);
445 err |= copy_from_user(&seta, &sf->mask, sizeof(sigset_t32));
446 err |= __get_user((long)st.ss_sp, &sf->stack.ss_sp);
447 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
448 err |= __get_user(st.ss_size, &sf->stack.ss_size);
449 if (err)
450 goto segv;
451
452 /* It is more difficult to avoid calling this function than to
453 call it and ignore errors. */
454 do_sigaltstack(&st, NULL, (unsigned long)sf);
455
456 switch (_NSIG_WORDS) {
457 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
458 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
459 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
460 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
461 }
462 sigdelsetmask(&set, ~_BLOCKABLE);
463 spin_lock_irq(¤t->sigmask_lock);
464 current->blocked = set;
465 recalc_sigpending(current);
466 spin_unlock_irq(¤t->sigmask_lock);
467 return;
468 segv:
469 do_exit(SIGSEGV);
470 }
471
472 /* Checks if the fp is valid */
473 static int invalid_frame_pointer(void *fp, int fplen)
474 {
475 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
476 return 1;
477 return 0;
478 }
479
480 static inline void *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
481 {
482 unsigned long sp;
483
484 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
485 sp = regs->u_regs[UREG_FP];
486
487 /* This is the X/Open sanctioned signal stack switching. */
488 if (sa->sa_flags & SA_ONSTACK) {
489 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
490 sp = current->sas_ss_sp + current->sas_ss_size;
491 }
492 return (void *)(sp - framesize);
493 }
494
495 static void
496 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
497 {
498 struct signal_sframe32 *sframep;
499 struct sigcontext32 *sc;
500 unsigned seta[_NSIG_WORDS32];
501 int err = 0;
502 void *sig_address;
503 int sig_code;
504 unsigned long pc = regs->tpc;
505 unsigned long npc = regs->tnpc;
506
507 #if 0
508 int window = 0;
509 #endif
510 unsigned psr;
511
512 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
513 pc &= 0xffffffff;
514 npc &= 0xffffffff;
515 }
516
517 synchronize_user_stack();
518 save_and_clear_fpu();
519
520 sframep = (struct signal_sframe32 *)get_sigframe(sa, regs, SF_ALIGNEDSZ);
521 if (invalid_frame_pointer (sframep, sizeof(*sframep))){
522 #ifdef DEBUG_SIGNALS /* fills up the console logs during crashme runs, yuck... */
523 printk("%s [%d]: User has trashed signal stack\n",
524 current->comm, current->pid);
525 printk("Sigstack ptr %p handler at pc<%016lx> for sig<%d>\n",
526 sframep, pc, signr);
527 #endif
528 /* Don't change signal code and address, so that
529 * post mortem debuggers can have a look.
530 */
531 do_exit(SIGILL);
532 }
533
534 sc = &sframep->sig_context;
535
536 /* We've already made sure frame pointer isn't in kernel space... */
537 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
538 &sc->sigc_onstack);
539
540 switch (_NSIG_WORDS) {
541 case 4: seta[7] = (oldset->sig[3] >> 32);
542 seta[6] = oldset->sig[3];
543 case 3: seta[5] = (oldset->sig[2] >> 32);
544 seta[4] = oldset->sig[2];
545 case 2: seta[3] = (oldset->sig[1] >> 32);
546 seta[2] = oldset->sig[1];
547 case 1: seta[1] = (oldset->sig[0] >> 32);
548 seta[0] = oldset->sig[0];
549 }
550 err |= __put_user(seta[0], &sc->sigc_mask);
551 err |= __copy_to_user(sframep->extramask, seta + 1,
552 (_NSIG_WORDS32 - 1) * sizeof(unsigned));
553 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
554 err |= __put_user(pc, &sc->sigc_pc);
555 err |= __put_user(npc, &sc->sigc_npc);
556 psr = tstate_to_psr (regs->tstate);
557 if(current->thread.fpsaved[0] & FPRS_FEF)
558 psr |= PSR_EF;
559 err |= __put_user(psr, &sc->sigc_psr);
560 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
561 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
562 err |= __put_user(current->thread.w_saved, &sc->sigc_oswins);
563 #if 0
564 /* w_saved is not currently used... */
565 if(current->thread.w_saved)
566 for(window = 0; window < current->thread.w_saved; window++) {
567 sc->sigc_spbuf[window] =
568 (char *)current->thread.rwbuf_stkptrs[window];
569 err |= copy_to_user(&sc->sigc_wbuf[window],
570 ¤t->thread.reg_window[window],
571 sizeof(struct reg_window));
572 }
573 else
574 #endif
575 err |= copy_in_user((u32 *)sframep,
576 (u32 *)(regs->u_regs[UREG_FP]),
577 sizeof(struct reg_window32));
578
579 current->thread.w_saved = 0; /* So process is allowed to execute. */
580 err |= __put_user(signr, &sframep->sig_num);
581 sig_address = NULL;
582 sig_code = 0;
583 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
584 sig_address = info->si_addr;
585 switch (signr) {
586 case SIGSEGV:
587 switch (info->si_code) {
588 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
589 default: sig_code = SUBSIG_PROTECTION; break;
590 }
591 break;
592 case SIGILL:
593 switch (info->si_code) {
594 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
595 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
596 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP (info->si_trapno); break;
597 default: sig_code = SUBSIG_STACK; break;
598 }
599 break;
600 case SIGFPE:
601 switch (info->si_code) {
602 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
603 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
604 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
605 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
606 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
607 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
608 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
609 default: sig_code = SUBSIG_FPERROR; break;
610 }
611 break;
612 case SIGBUS:
613 switch (info->si_code) {
614 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
615 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
616 default: sig_code = SUBSIG_BUSTIMEOUT; break;
617 }
618 break;
619 case SIGEMT:
620 switch (info->si_code) {
621 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
622 }
623 break;
624 case SIGSYS:
625 if (info->si_code == (__SI_FAULT|0x100)) {
626 /* See sys_sunos32.c */
627 sig_code = info->si_trapno;
628 break;
629 }
630 default:
631 sig_address = NULL;
632 }
633 }
634 err |= __put_user((long)sig_address, &sframep->sig_address);
635 err |= __put_user(sig_code, &sframep->sig_code);
636 err |= __put_user((u64)sc, &sframep->sig_scptr);
637 if (err)
638 goto sigsegv;
639
640 regs->u_regs[UREG_FP] = (unsigned long) sframep;
641 regs->tpc = (unsigned long) sa->sa_handler;
642 regs->tnpc = (regs->tpc + 4);
643 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
644 regs->tpc &= 0xffffffff;
645 regs->tnpc &= 0xffffffff;
646 }
647 return;
648
649 sigsegv:
650 do_exit(SIGSEGV);
651 }
652
653
654 static inline int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t *fpu)
655 {
656 unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
657 unsigned long fprs;
658 int err = 0;
659
660 fprs = current->thread.fpsaved[0];
661 if (fprs & FPRS_DL)
662 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
663 (sizeof(unsigned int) * 32));
664 if (fprs & FPRS_DU)
665 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
666 (sizeof(unsigned int) * 32));
667 err |= __put_user(current->thread.xfsr[0], &fpu->si_fsr);
668 err |= __put_user(current->thread.gsr[0], &fpu->si_gsr);
669 err |= __put_user(fprs, &fpu->si_fprs);
670
671 return err;
672 }
673
674 static inline void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
675 int signo, sigset_t *oldset)
676 {
677 struct new_signal_frame32 *sf;
678 int sigframe_size;
679 u32 psr;
680 int i, err;
681 unsigned seta[_NSIG_WORDS32];
682
683 /* 1. Make sure everything is clean */
684 synchronize_user_stack();
685 save_and_clear_fpu();
686
687 sigframe_size = NF_ALIGNEDSZ;
688 if (!(current->thread.fpsaved[0] & FPRS_FEF))
689 sigframe_size -= sizeof(__siginfo_fpu_t);
690
691 sf = (struct new_signal_frame32 *)get_sigframe(&ka->sa, regs, sigframe_size);
692
693 if (invalid_frame_pointer (sf, sigframe_size)) {
694 #ifdef DEBUG_SIGNALS
695 printk("new_setup_frame32(%s:%d): invalid_frame_pointer(%p, %d)\n",
696 current->comm, current->pid, sf, sigframe_size);
697 #endif
698 goto sigill;
699 }
700
701 if (current->thread.w_saved != 0) {
702 #ifdef DEBUG_SIGNALS
703 printk ("%s[%d]: Invalid user stack frame for "
704 "signal delivery.\n", current->comm, current->pid);
705 #endif
706 goto sigill;
707 }
708
709 /* 2. Save the current process state */
710 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
711 regs->tpc &= 0xffffffff;
712 regs->tnpc &= 0xffffffff;
713 }
714 err = put_user(regs->tpc, &sf->info.si_regs.pc);
715 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
716 err |= __put_user(regs->y, &sf->info.si_regs.y);
717 psr = tstate_to_psr (regs->tstate);
718 if(current->thread.fpsaved[0] & FPRS_FEF)
719 psr |= PSR_EF;
720 err |= __put_user(psr, &sf->info.si_regs.psr);
721 for (i = 0; i < 16; i++)
722 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
723 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
724 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
725 for (i = 1; i < 16; i++)
726 err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
727
728 if (psr & PSR_EF) {
729 err |= save_fpu_state32(regs, &sf->fpu_state);
730 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
731 } else {
732 err |= __put_user(0, &sf->fpu_save);
733 }
734
735 switch (_NSIG_WORDS) {
736 case 4: seta[7] = (oldset->sig[3] >> 32);
737 seta[6] = oldset->sig[3];
738 case 3: seta[5] = (oldset->sig[2] >> 32);
739 seta[4] = oldset->sig[2];
740 case 2: seta[3] = (oldset->sig[1] >> 32);
741 seta[2] = oldset->sig[1];
742 case 1: seta[1] = (oldset->sig[0] >> 32);
743 seta[0] = oldset->sig[0];
744 }
745 err |= __put_user(seta[0], &sf->info.si_mask);
746 err |= __copy_to_user(sf->extramask, seta + 1,
747 (_NSIG_WORDS32 - 1) * sizeof(unsigned));
748
749 err |= copy_in_user((u32 *)sf,
750 (u32 *)(regs->u_regs[UREG_FP]),
751 sizeof(struct reg_window32));
752
753 if (err)
754 goto sigsegv;
755
756 /* 3. signal handler back-trampoline and parameters */
757 regs->u_regs[UREG_FP] = (unsigned long) sf;
758 regs->u_regs[UREG_I0] = signo;
759 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
760
761 /* 4. signal handler */
762 regs->tpc = (unsigned long) ka->sa.sa_handler;
763 regs->tnpc = (regs->tpc + 4);
764 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
765 regs->tpc &= 0xffffffff;
766 regs->tnpc &= 0xffffffff;
767 }
768
769 /* 5. return to kernel instructions */
770 if (ka->ka_restorer) {
771 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
772 } else {
773 /* Flush instruction space. */
774 unsigned long address = ((unsigned long)&(sf->insns[0]));
775 pgd_t *pgdp = pgd_offset(current->mm, address);
776 pmd_t *pmdp = pmd_offset(pgdp, address);
777 pte_t *ptep = pte_offset(pmdp, address);
778
779 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
780
781 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
782 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
783 if(err)
784 goto sigsegv;
785
786 if(pte_present(*ptep)) {
787 unsigned long page = (unsigned long) page_address(pte_page(*ptep));
788
789 __asm__ __volatile__(
790 " membar #StoreStore\n"
791 " flush %0 + %1"
792 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
793 : "memory");
794 }
795 }
796 return;
797
798 sigill:
799 do_exit(SIGILL);
800 sigsegv:
801 do_exit(SIGSEGV);
802 }
803
804 /* Setup a Solaris stack frame */
805 static inline void
806 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
807 struct pt_regs *regs, int signr, sigset_t *oldset)
808 {
809 svr4_signal_frame_t *sfp;
810 svr4_gregset_t *gr;
811 svr4_siginfo_t *si;
812 svr4_mcontext_t *mc;
813 svr4_gwindows_t *gw;
814 svr4_ucontext_t *uc;
815 svr4_sigset_t setv;
816 #if 0
817 int window = 0;
818 #endif
819 unsigned psr;
820 int i, err;
821
822 synchronize_user_stack();
823 save_and_clear_fpu();
824
825 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
826 sfp = (svr4_signal_frame_t *) get_sigframe(sa, regs, REGWIN_SZ + SVR4_SF_ALIGNED);
827
828 if (invalid_frame_pointer (sfp, sizeof (*sfp))){
829 #ifdef DEBUG_SIGNALS
830 printk ("Invalid stack frame\n");
831 #endif
832 do_exit(SIGILL);
833 }
834
835 /* Start with a clean frame pointer and fill it */
836 err = clear_user(sfp, sizeof (*sfp));
837
838 /* Setup convenience variables */
839 si = &sfp->si;
840 uc = &sfp->uc;
841 gw = &sfp->gw;
842 mc = &uc->mcontext;
843 gr = &mc->greg;
844
845 /* FIXME: where am I supposed to put this?
846 * sc->sigc_onstack = old_status;
847 * anyways, it does not look like it is used for anything at all.
848 */
849 setv.sigbits[0] = oldset->sig[0];
850 setv.sigbits[1] = (oldset->sig[0] >> 32);
851 if (_NSIG_WORDS >= 2) {
852 setv.sigbits[2] = oldset->sig[1];
853 setv.sigbits[3] = (oldset->sig[1] >> 32);
854 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
855 } else
856 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
857
858 /* Store registers */
859 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
860 regs->tpc &= 0xffffffff;
861 regs->tnpc &= 0xffffffff;
862 }
863 err |= __put_user(regs->tpc, &((*gr) [SVR4_PC]));
864 err |= __put_user(regs->tnpc, &((*gr) [SVR4_NPC]));
865 psr = tstate_to_psr (regs->tstate);
866 if(current->thread.fpsaved[0] & FPRS_FEF)
867 psr |= PSR_EF;
868 err |= __put_user(psr, &((*gr) [SVR4_PSR]));
869 err |= __put_user(regs->y, &((*gr) [SVR4_Y]));
870
871 /* Copy g [1..7] and o [0..7] registers */
872 for (i = 0; i < 7; i++)
873 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
874 for (i = 0; i < 8; i++)
875 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
876
877 /* Setup sigaltstack */
878 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
879 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
880 err |= __put_user(current->sas_ss_size, &uc->stack.size);
881
882 /* Save the currently window file: */
883
884 /* 1. Link sfp->uc->gwins to our windows */
885 err |= __put_user((u32)(long)gw, &mc->gwin);
886
887 /* 2. Number of windows to restore at setcontext (): */
888 err |= __put_user(current->thread.w_saved, &gw->count);
889
890 /* 3. Save each valid window
891 * Currently, it makes a copy of the windows from the kernel copy.
892 * David's code for SunOS, makes the copy but keeps the pointer to
893 * the kernel. My version makes the pointer point to a userland
894 * copy of those. Mhm, I wonder if I shouldn't just ignore those
895 * on setcontext and use those that are on the kernel, the signal
896 * handler should not be modyfing those, mhm.
897 *
898 * These windows are just used in case synchronize_user_stack failed
899 * to flush the user windows.
900 */
901 #if 0
902 for(window = 0; window < current->thread.w_saved; window++) {
903 err |= __put_user((int *) &(gw->win [window]),
904 (int **)gw->winptr +window );
905 err |= copy_to_user(&gw->win [window],
906 ¤t->thread.reg_window [window],
907 sizeof (svr4_rwindow_t));
908 err |= __put_user(0, (int *)gw->winptr + window);
909 }
910 #endif
911
912 /* 4. We just pay attention to the gw->count field on setcontext */
913 current->thread.w_saved = 0; /* So process is allowed to execute. */
914
915 /* Setup the signal information. Solaris expects a bunch of
916 * information to be passed to the signal handler, we don't provide
917 * that much currently, should use siginfo.
918 */
919 err |= __put_user(signr, &si->siginfo.signo);
920 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
921 if (err)
922 goto sigsegv;
923
924 regs->u_regs[UREG_FP] = (unsigned long) sfp;
925 regs->tpc = (unsigned long) sa->sa_handler;
926 regs->tnpc = (regs->tpc + 4);
927 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
928 regs->tpc &= 0xffffffff;
929 regs->tnpc &= 0xffffffff;
930 }
931
932 #ifdef DEBUG_SIGNALS
933 printk ("Solaris-frame: %x %x\n", (int) regs->tpc, (int) regs->tnpc);
934 #endif
935 /* Arguments passed to signal handler */
936 if (regs->u_regs [14]){
937 struct reg_window32 *rw = (struct reg_window32 *)
938 (regs->u_regs [14] & 0x00000000ffffffffUL);
939
940 err |= __put_user(signr, &rw->ins [0]);
941 err |= __put_user((u64)si, &rw->ins [1]);
942 err |= __put_user((u64)uc, &rw->ins [2]);
943 err |= __put_user((u64)sfp, &rw->ins [6]); /* frame pointer */
944 if (err)
945 goto sigsegv;
946
947 regs->u_regs[UREG_I0] = signr;
948 regs->u_regs[UREG_I1] = (u32)(u64) si;
949 regs->u_regs[UREG_I2] = (u32)(u64) uc;
950 }
951 return;
952
953 sigsegv:
954 do_exit(SIGSEGV);
955 }
956
957 asmlinkage int
958 svr4_getcontext(svr4_ucontext_t *uc, struct pt_regs *regs)
959 {
960 svr4_gregset_t *gr;
961 svr4_mcontext_t *mc;
962 svr4_sigset_t setv;
963 int i, err;
964
965 synchronize_user_stack();
966 save_and_clear_fpu();
967
968 if (current->thread.w_saved){
969 printk ("Uh oh, w_saved is not zero (%d)\n", (int) current->thread.w_saved);
970 do_exit (SIGSEGV);
971 }
972 err = clear_user(uc, sizeof (*uc));
973
974 /* Setup convenience variables */
975 mc = &uc->mcontext;
976 gr = &mc->greg;
977
978 setv.sigbits[0] = current->blocked.sig[0];
979 setv.sigbits[1] = (current->blocked.sig[0] >> 32);
980 if (_NSIG_WORDS >= 2) {
981 setv.sigbits[2] = current->blocked.sig[1];
982 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
983 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
984 } else
985 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
986
987 /* Store registers */
988 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
989 regs->tpc &= 0xffffffff;
990 regs->tnpc &= 0xffffffff;
991 }
992 err |= __put_user(regs->tpc, &uc->mcontext.greg [SVR4_PC]);
993 err |= __put_user(regs->tnpc, &uc->mcontext.greg [SVR4_NPC]);
994 #if 1
995 err |= __put_user(0, &uc->mcontext.greg [SVR4_PSR]);
996 #else
997 i = tstate_to_psr(regs->tstate) & ~PSR_EF;
998 if (current->thread.fpsaved[0] & FPRS_FEF)
999 i |= PSR_EF;
1000 err |= __put_user(i, &uc->mcontext.greg [SVR4_PSR]);
1001 #endif
1002 err |= __put_user(regs->y, &uc->mcontext.greg [SVR4_Y]);
1003
1004 /* Copy g [1..7] and o [0..7] registers */
1005 for (i = 0; i < 7; i++)
1006 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1007 for (i = 0; i < 8; i++)
1008 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1009
1010 /* Setup sigaltstack */
1011 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
1012 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
1013 err |= __put_user(current->sas_ss_size, &uc->stack.size);
1014
1015 /* The register file is not saved
1016 * we have already stuffed all of it with sync_user_stack
1017 */
1018 return (err ? -EFAULT : 0);
1019 }
1020
1021
1022 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
1023 asmlinkage int svr4_setcontext(svr4_ucontext_t *c, struct pt_regs *regs)
1024 {
1025 struct thread_struct *tp = ¤t->thread;
1026 svr4_gregset_t *gr;
1027 u32 pc, npc, psr;
1028 sigset_t set;
1029 svr4_sigset_t setv;
1030 int i, err;
1031 stack_t st;
1032
1033 /* Fixme: restore windows, or is this already taken care of in
1034 * svr4_setup_frame when sync_user_windows is done?
1035 */
1036 flush_user_windows();
1037
1038 if (tp->w_saved){
1039 printk ("Uh oh, w_saved is: 0x%x\n", tp->w_saved);
1040 goto sigsegv;
1041 }
1042 if (((unsigned long) c) & 3){
1043 printk ("Unaligned structure passed\n");
1044 goto sigsegv;
1045 }
1046
1047 if(!__access_ok((unsigned long)c, sizeof(*c))) {
1048 /* Miguel, add nice debugging msg _here_. ;-) */
1049 goto sigsegv;
1050 }
1051
1052 /* Check for valid PC and nPC */
1053 gr = &c->mcontext.greg;
1054 err = __get_user(pc, &((*gr)[SVR4_PC]));
1055 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1056 if((pc | npc) & 3) {
1057 #ifdef DEBUG_SIGNALS
1058 printk ("setcontext, PC or nPC were bogus\n");
1059 #endif
1060 goto sigsegv;
1061 }
1062
1063 /* Retrieve information from passed ucontext */
1064 /* note that nPC is ored a 1, this is used to inform entry.S */
1065 /* that we don't want it to mess with our PC and nPC */
1066
1067 err |= copy_from_user (&setv, &c->sigmask, sizeof(svr4_sigset_t));
1068 set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1069 if (_NSIG_WORDS >= 2)
1070 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1071
1072 err |= __get_user((long)st.ss_sp, &c->stack.sp);
1073 err |= __get_user(st.ss_flags, &c->stack.flags);
1074 err |= __get_user(st.ss_size, &c->stack.size);
1075 if (err)
1076 goto sigsegv;
1077
1078 /* It is more difficult to avoid calling this function than to
1079 call it and ignore errors. */
1080 do_sigaltstack(&st, NULL, regs->u_regs[UREG_I6]);
1081
1082 sigdelsetmask(&set, ~_BLOCKABLE);
1083 spin_lock_irq(¤t->sigmask_lock);
1084 current->blocked = set;
1085 recalc_sigpending(current);
1086 spin_unlock_irq(¤t->sigmask_lock);
1087 regs->tpc = pc;
1088 regs->tnpc = npc | 1;
1089 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
1090 regs->tpc &= 0xffffffff;
1091 regs->tnpc &= 0xffffffff;
1092 }
1093 err |= __get_user(regs->y, &((*gr) [SVR4_Y]));
1094 err |= __get_user(psr, &((*gr) [SVR4_PSR]));
1095 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1096 regs->tstate |= psr_to_tstate_icc(psr);
1097 #if 0
1098 if(psr & PSR_EF)
1099 regs->tstate |= TSTATE_PEF;
1100 #endif
1101 /* Restore g[1..7] and o[0..7] registers */
1102 for (i = 0; i < 7; i++)
1103 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1104 for (i = 0; i < 8; i++)
1105 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1106 if(err)
1107 goto sigsegv;
1108
1109 return -EINTR;
1110 sigsegv:
1111 do_exit(SIGSEGV);
1112 }
1113
1114 static inline void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1115 unsigned long signr, sigset_t *oldset,
1116 siginfo_t *info)
1117 {
1118 struct rt_signal_frame32 *sf;
1119 int sigframe_size;
1120 u32 psr;
1121 int i, err;
1122 sigset_t32 seta;
1123
1124 /* 1. Make sure everything is clean */
1125 synchronize_user_stack();
1126 save_and_clear_fpu();
1127
1128 sigframe_size = RT_ALIGNEDSZ;
1129 if (!(current->thread.fpsaved[0] & FPRS_FEF))
1130 sigframe_size -= sizeof(__siginfo_fpu_t);
1131
1132 sf = (struct rt_signal_frame32 *)get_sigframe(&ka->sa, regs, sigframe_size);
1133
1134 if (invalid_frame_pointer (sf, sigframe_size)) {
1135 #ifdef DEBUG_SIGNALS
1136 printk("rt_setup_frame32(%s:%d): invalid_frame_pointer(%p, %d)\n",
1137 current->comm, current->pid, sf, sigframe_size);
1138 #endif
1139 goto sigill;
1140 }
1141
1142 if (current->thread.w_saved != 0) {
1143 #ifdef DEBUG_SIGNALS
1144 printk ("%s[%d]: Invalid user stack frame for "
1145 "signal delivery.\n", current->comm, current->pid);
1146 #endif
1147 goto sigill;
1148 }
1149
1150 /* 2. Save the current process state */
1151 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
1152 regs->tpc &= 0xffffffff;
1153 regs->tnpc &= 0xffffffff;
1154 }
1155 err = put_user(regs->tpc, &sf->regs.pc);
1156 err |= __put_user(regs->tnpc, &sf->regs.npc);
1157 err |= __put_user(regs->y, &sf->regs.y);
1158 psr = tstate_to_psr (regs->tstate);
1159 if(current->thread.fpsaved[0] & FPRS_FEF)
1160 psr |= PSR_EF;
1161 err |= __put_user(psr, &sf->regs.psr);
1162 for (i = 0; i < 16; i++)
1163 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1164 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1165 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1166 for (i = 1; i < 16; i++)
1167 err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
1168
1169 if (psr & PSR_EF) {
1170 err |= save_fpu_state32(regs, &sf->fpu_state);
1171 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1172 } else {
1173 err |= __put_user(0, &sf->fpu_save);
1174 }
1175
1176 /* Update the siginfo structure. */
1177 err |= copy_siginfo_to_user32(&sf->info, info);
1178
1179 /* Setup sigaltstack */
1180 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1181 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1182 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1183
1184 switch (_NSIG_WORDS) {
1185 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1186 seta.sig[6] = oldset->sig[3];
1187 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1188 seta.sig[4] = oldset->sig[2];
1189 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1190 seta.sig[2] = oldset->sig[1];
1191 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1192 seta.sig[0] = oldset->sig[0];
1193 }
1194 err |= __copy_to_user(&sf->mask, &seta, sizeof(sigset_t32));
1195
1196 err |= copy_in_user((u32 *)sf,
1197 (u32 *)(regs->u_regs[UREG_FP]),
1198 sizeof(struct reg_window32));
1199 if (err)
1200 goto sigsegv;
1201
1202 /* 3. signal handler back-trampoline and parameters */
1203 regs->u_regs[UREG_FP] = (unsigned long) sf;
1204 regs->u_regs[UREG_I0] = signr;
1205 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1206
1207 /* 4. signal handler */
1208 regs->tpc = (unsigned long) ka->sa.sa_handler;
1209 regs->tnpc = (regs->tpc + 4);
1210 if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
1211 regs->tpc &= 0xffffffff;
1212 regs->tnpc &= 0xffffffff;
1213 }
1214
1215 /* 5. return to kernel instructions */
1216 if (ka->ka_restorer)
1217 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1218 else {
1219 /* Flush instruction space. */
1220 unsigned long address = ((unsigned long)&(sf->insns[0]));
1221 pgd_t *pgdp = pgd_offset(current->mm, address);
1222 pmd_t *pmdp = pmd_offset(pgdp, address);
1223 pte_t *ptep = pte_offset(pmdp, address);
1224
1225 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1226
1227 /* mov __NR_rt_sigreturn, %g1 */
1228 err |= __put_user(0x82102065, &sf->insns[0]);
1229
1230 /* t 0x10 */
1231 err |= __put_user(0x91d02010, &sf->insns[1]);
1232 if (err)
1233 goto sigsegv;
1234
1235 if(pte_present(*ptep)) {
1236 unsigned long page = (unsigned long) page_address(pte_page(*ptep));
1237
1238 __asm__ __volatile__(
1239 " membar #StoreStore\n"
1240 " flush %0 + %1"
1241 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
1242 : "memory");
1243 }
1244 }
1245 return;
1246
1247 sigill:
1248 do_exit(SIGILL);
1249 sigsegv:
1250 do_exit(SIGSEGV);
1251 }
1252
1253 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1254 siginfo_t *info,
1255 sigset_t *oldset, struct pt_regs *regs,
1256 int svr4_signal)
1257 {
1258 if(svr4_signal)
1259 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc, regs, signr, oldset);
1260 else {
1261 if (ka->sa.sa_flags & SA_SIGINFO)
1262 setup_rt_frame32(ka, regs, signr, oldset, info);
1263 else if (current->thread.flags & SPARC_FLAG_NEWSIGNALS)
1264 new_setup_frame32(ka, regs, signr, oldset);
1265 else
1266 setup_frame32(&ka->sa, regs, signr, oldset, info);
1267 }
1268 if(ka->sa.sa_flags & SA_ONESHOT)
1269 ka->sa.sa_handler = SIG_DFL;
1270 if(!(ka->sa.sa_flags & SA_NOMASK)) {
1271 spin_lock_irq(¤t->sigmask_lock);
1272 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
1273 sigaddset(¤t->blocked,signr);
1274 recalc_sigpending(current);
1275 spin_unlock_irq(¤t->sigmask_lock);
1276 }
1277 }
1278
1279 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1280 struct sigaction *sa)
1281 {
1282 switch(regs->u_regs[UREG_I0]) {
1283 case ERESTARTNOHAND:
1284 no_system_call_restart:
1285 regs->u_regs[UREG_I0] = EINTR;
1286 regs->tstate |= TSTATE_ICARRY;
1287 break;
1288 case ERESTARTSYS:
1289 if(!(sa->sa_flags & SA_RESTART))
1290 goto no_system_call_restart;
1291 /* fallthrough */
1292 case ERESTARTNOINTR:
1293 regs->u_regs[UREG_I0] = orig_i0;
1294 regs->tpc -= 4;
1295 regs->tnpc -= 4;
1296 }
1297 }
1298
1299 #ifdef DEBUG_SIGNALS_MAPS
1300
1301 #define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %s %lu "
1302
1303 static inline void read_maps (void)
1304 {
1305 struct vm_area_struct * map, * next;
1306 char * buffer;
1307 ssize_t i;
1308
1309 buffer = (char*)__get_free_page(GFP_KERNEL);
1310 if (!buffer)
1311 return;
1312
1313 for (map = current->mm->mmap ; map ; map = next ) {
1314 /* produce the next line */
1315 char *line;
1316 char str[5], *cp = str;
1317 int flags;
1318 kdev_t dev;
1319 unsigned long ino;
1320
1321 /*
1322 * Get the next vma now (but it won't be used if we sleep).
1323 */
1324 next = map->vm_next;
1325 flags = map->vm_flags;
1326
1327 *cp++ = flags & VM_READ ? 'r' : '-';
1328 *cp++ = flags & VM_WRITE ? 'w' : '-';
1329 *cp++ = flags & VM_EXEC ? 'x' : '-';
1330 *cp++ = flags & VM_MAYSHARE ? 's' : 'p';
1331 *cp++ = 0;
1332
1333 dev = 0;
1334 ino = 0;
1335 if (map->vm_file != NULL) {
1336 dev = map->vm_file->f_dentry->d_inode->i_dev;
1337 ino = map->vm_file->f_dentry->d_inode->i_ino;
1338 line = d_path(map->vm_file->f_dentry,
1339 map->vm_file->f_vfsmnt,
1340 buffer, PAGE_SIZE);
1341 }
1342 printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT,
1343 kdevname(dev), ino);
1344 if (map->vm_file != NULL)
1345 printk("%s\n", line);
1346 else
1347 printk("\n");
1348 }
1349 free_page((unsigned long)buffer);
1350 return;
1351 }
1352
1353 #endif
1354
1355 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1356 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1357 * mistake.
1358 */
1359 asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs * regs,
1360 unsigned long orig_i0, int restart_syscall)
1361 {
1362 unsigned long signr;
1363 struct k_sigaction *ka;
1364 siginfo_t info;
1365
1366 int svr4_signal = current->personality == PER_SVR4;
1367
1368 for (;;) {
1369 spin_lock_irq(¤t->sigmask_lock);
1370 signr = dequeue_signal(¤t->blocked, &info);
1371 spin_unlock_irq(¤t->sigmask_lock);
1372
1373 if (!signr) break;
1374
1375 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1376 current->exit_code = signr;
1377 current->state = TASK_STOPPED;
1378 notify_parent(current, SIGCHLD);
1379 schedule();
1380 if (!(signr = current->exit_code))
1381 continue;
1382 current->exit_code = 0;
1383 if (signr == SIGSTOP)
1384 continue;
1385
1386 /* Update the siginfo structure. Is this good? */
1387 if (signr != info.si_signo) {
1388 info.si_signo = signr;
1389 info.si_errno = 0;
1390 info.si_code = SI_USER;
1391 info.si_pid = current->p_pptr->pid;
1392 info.si_uid = current->p_pptr->uid;
1393 }
1394
1395 /* If the (new) signal is now blocked, requeue it. */
1396 if (sigismember(¤t->blocked, signr)) {
1397 send_sig_info(signr, &info, current);
1398 continue;
1399 }
1400 }
1401
1402 ka = ¤t->sig->action[signr-1];
1403
1404 if(ka->sa.sa_handler == SIG_IGN) {
1405 if(signr != SIGCHLD)
1406 continue;
1407
1408 /* sys_wait4() grabs the master kernel lock, so
1409 * we need not do so, that sucker should be
1410 * threaded and would not be that difficult to
1411 * do anyways.
1412 */
1413 while(sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
1414 ;
1415 continue;
1416 }
1417 if(ka->sa.sa_handler == SIG_DFL) {
1418 unsigned long exit_code = signr;
1419
1420 if(current->pid == 1)
1421 continue;
1422 switch(signr) {
1423 case SIGCONT: case SIGCHLD: case SIGWINCH:
1424 continue;
1425
1426 case SIGTSTP: case SIGTTIN: case SIGTTOU:
1427 if (is_orphaned_pgrp(current->pgrp))
1428 continue;
1429
1430 case SIGSTOP:
1431 if (current->ptrace & PT_PTRACED)
1432 continue;
1433 current->state = TASK_STOPPED;
1434 current->exit_code = signr;
1435 if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
1436 SA_NOCLDSTOP))
1437 notify_parent(current, SIGCHLD);
1438 schedule();
1439 continue;
1440
1441 case SIGQUIT: case SIGILL: case SIGTRAP:
1442 case SIGABRT: case SIGFPE: case SIGSEGV:
1443 case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
1444 if (do_coredump(signr, regs))
1445 exit_code |= 0x80;
1446 #ifdef DEBUG_SIGNALS
1447 /* Very useful to debug dynamic linker problems */
1448 printk ("Sig %ld going for %s[%d]...\n", signr, current->comm, current->pid);
1449 /* On SMP we are only interested in the current
1450 * CPU's registers.
1451 */
1452 __show_regs (regs);
1453 #ifdef DEBUG_SIGNALS_TLB
1454 do {
1455 extern void sparc_ultra_dump_itlb(void);
1456 extern void sparc_ultra_dump_dtlb(void);
1457 sparc_ultra_dump_dtlb();
1458 sparc_ultra_dump_itlb();
1459 } while(0);
1460 #endif
1461 #ifdef DEBUG_SIGNALS_TRACE
1462 {
1463 struct reg_window32 *rw = (struct reg_window32 *)(regs->u_regs[UREG_FP] & 0xffffffff);
1464 unsigned int ins[8];
1465
1466 while(rw &&
1467 !(((unsigned long) rw) & 0x3)) {
1468 copy_from_user(ins, &rw->ins[0], sizeof(ins));
1469 printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)\n", ins[7], ins[0], ins[1], ins[2], ins[3], ins[4], ins[5]);
1470 rw = (struct reg_window32 *)(unsigned long)ins[6];
1471 }
1472 }
1473 #endif
1474 #ifdef DEBUG_SIGNALS_MAPS
1475 printk("Maps:\n");
1476 read_maps();
1477 #endif
1478 #endif
1479 /* fall through */
1480 default:
1481 sigaddset(¤t->pending.signal, signr);
1482 recalc_sigpending(current);
1483 current->flags |= PF_SIGNALED;
1484 do_exit(exit_code);
1485 /* NOT REACHED */
1486 }
1487 }
1488 if(restart_syscall)
1489 syscall_restart32(orig_i0, regs, &ka->sa);
1490 handle_signal32(signr, ka, &info, oldset, regs, svr4_signal);
1491 return 1;
1492 }
1493 if(restart_syscall &&
1494 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1495 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1496 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1497 /* replay the system call when we are done */
1498 regs->u_regs[UREG_I0] = orig_i0;
1499 regs->tpc -= 4;
1500 regs->tnpc -= 4;
1501 }
1502 return 0;
1503 }
1504
1505 struct sigstack32 {
1506 u32 the_stack;
1507 int cur_status;
1508 };
1509
1510 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1511 {
1512 struct sigstack32 *ssptr = (struct sigstack32 *)((unsigned long)(u_ssptr));
1513 struct sigstack32 *ossptr = (struct sigstack32 *)((unsigned long)(u_ossptr));
1514 int ret = -EFAULT;
1515
1516 /* First see if old state is wanted. */
1517 if (ossptr) {
1518 if (put_user(current->sas_ss_sp + current->sas_ss_size, &ossptr->the_stack) ||
1519 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1520 goto out;
1521 }
1522
1523 /* Now see if we want to update the new state. */
1524 if (ssptr) {
1525 void *ss_sp;
1526
1527 if (get_user((long)ss_sp, &ssptr->the_stack))
1528 goto out;
1529 /* If the current stack was set with sigaltstack, don't
1530 swap stacks while we are on it. */
1531 ret = -EPERM;
1532 if (current->sas_ss_sp && on_sig_stack(sp))
1533 goto out;
1534
1535 /* Since we don't know the extent of the stack, and we don't
1536 track onstack-ness, but rather calculate it, we must
1537 presume a size. Ho hum this interface is lossy. */
1538 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1539 current->sas_ss_size = SIGSTKSZ;
1540 }
1541
1542 ret = 0;
1543 out:
1544 return ret;
1545 }
1546
1547 asmlinkage int do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1548 {
1549 stack_t uss, uoss;
1550 int ret;
1551 mm_segment_t old_fs;
1552
1553 if (ussa && (get_user((long)uss.ss_sp, &((stack_t32 *)(long)ussa)->ss_sp) ||
1554 __get_user(uss.ss_flags, &((stack_t32 *)(long)ussa)->ss_flags) ||
1555 __get_user(uss.ss_size, &((stack_t32 *)(long)ussa)->ss_size)))
1556 return -EFAULT;
1557 old_fs = get_fs();
1558 set_fs(KERNEL_DS);
1559 ret = do_sigaltstack(ussa ? &uss : NULL, uossa ? &uoss : NULL, sp);
1560 set_fs(old_fs);
1561 if (!ret && uossa && (put_user((long)uoss.ss_sp, &((stack_t32 *)(long)uossa)->ss_sp) ||
1562 __put_user(uoss.ss_flags, &((stack_t32 *)(long)uossa)->ss_flags) ||
1563 __put_user(uoss.ss_size, &((stack_t32 *)(long)uossa)->ss_size)))
1564 return -EFAULT;
1565 return ret;
1566 }
1567