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