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