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