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