?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / arch / sparc64 / kernel / signal32.c
blob9a375e975cffbdcc0d6e2403addf7e203459b2e5
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 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
867 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
868
869 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
870 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
871 if (err)
872 goto sigsegv;
873
874 preempt_disable();
875 ptep = pte_offset_map(pmdp, address);
876 if (pte_present(*ptep)) {
877 unsigned long page = (unsigned long)
878 page_address(pte_page(*ptep));
879
880 __asm__ __volatile__(
881 " membar #StoreStore\n"
882 " flush %0 + %1"
883 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
884 : "memory");
885 }
886 pte_unmap(ptep);
887 preempt_enable();
888 }
889 return;
890
891 sigill:
892 do_exit(SIGILL);
893 sigsegv:
894 force_sigsegv(signo, current);
895 }
896
897 /* Setup a Solaris stack frame */
898 static void
899 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
900 struct pt_regs *regs, int signr, sigset_t *oldset)
901 {
902 svr4_signal_frame_t __user *sfp;
903 svr4_gregset_t __user *gr;
904 svr4_siginfo_t __user *si;
905 svr4_mcontext_t __user *mc;
906 svr4_gwindows_t __user *gw;
907 svr4_ucontext_t __user *uc;
908 svr4_sigset_t setv;
909 unsigned int psr;
910 int i, err;
911
912 synchronize_user_stack();
913 save_and_clear_fpu();
914
915 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
916 sfp = (svr4_signal_frame_t __user *)
917 get_sigframe(sa, regs,
918 sizeof(struct reg_window32) + SVR4_SF_ALIGNED);
919
920 if (invalid_frame_pointer(sfp, sizeof(*sfp)))
921 do_exit(SIGILL);
922
923 /* Start with a clean frame pointer and fill it */
924 err = clear_user(sfp, sizeof(*sfp));
925
926 /* Setup convenience variables */
927 si = &sfp->si;
928 uc = &sfp->uc;
929 gw = &sfp->gw;
930 mc = &uc->mcontext;
931 gr = &mc->greg;
932
933 /* FIXME: where am I supposed to put this?
934 * sc->sigc_onstack = old_status;
935 * anyways, it does not look like it is used for anything at all.
936 */
937 setv.sigbits[0] = oldset->sig[0];
938 setv.sigbits[1] = (oldset->sig[0] >> 32);
939 if (_NSIG_WORDS >= 2) {
940 setv.sigbits[2] = oldset->sig[1];
941 setv.sigbits[3] = (oldset->sig[1] >> 32);
942 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
943 } else
944 err |= __copy_to_user(&uc->sigmask, &setv,
945 2 * sizeof(unsigned int));
946
947 /* Store registers */
948 if (test_thread_flag(TIF_32BIT)) {
949 regs->tpc &= 0xffffffff;
950 regs->tnpc &= 0xffffffff;
951 }
952 err |= __put_user(regs->tpc, &((*gr)[SVR4_PC]));
953 err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC]));
954 psr = tstate_to_psr(regs->tstate);
955 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
956 psr |= PSR_EF;
957 err |= __put_user(psr, &((*gr)[SVR4_PSR]));
958 err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
959
960 /* Copy g[1..7] and o[0..7] registers */
961 for (i = 0; i < 7; i++)
962 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
963 for (i = 0; i < 8; i++)
964 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
965
966 /* Setup sigaltstack */
967 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
968 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
969 err |= __put_user(current->sas_ss_size, &uc->stack.size);
970
971 /* Save the currently window file: */
972
973 /* 1. Link sfp->uc->gwins to our windows */
974 err |= __put_user(ptr_to_compat(gw), &mc->gwin);
975
976 /* 2. Number of windows to restore at setcontext (): */
977 err |= __put_user(get_thread_wsaved(), &gw->count);
978
979 /* 3. We just pay attention to the gw->count field on setcontext */
980 set_thread_wsaved(0); /* So process is allowed to execute. */
981
982 /* Setup the signal information. Solaris expects a bunch of
983 * information to be passed to the signal handler, we don't provide
984 * that much currently, should use siginfo.
985 */
986 err |= __put_user(signr, &si->siginfo.signo);
987 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
988 if (err)
989 goto sigsegv;
990
991 regs->u_regs[UREG_FP] = (unsigned long) sfp;
992 regs->tpc = (unsigned long) sa->sa_handler;
993 regs->tnpc = (regs->tpc + 4);
994 if (test_thread_flag(TIF_32BIT)) {
995 regs->tpc &= 0xffffffff;
996 regs->tnpc &= 0xffffffff;
997 }
998
999 /* Arguments passed to signal handler */
1000 if (regs->u_regs[14]){
1001 struct reg_window32 __user *rw = (struct reg_window32 __user *)
1002 (regs->u_regs[14] & 0x00000000ffffffffUL);
1003
1004 err |= __put_user(signr, &rw->ins[0]);
1005 err |= __put_user((u64)si, &rw->ins[1]);
1006 err |= __put_user((u64)uc, &rw->ins[2]);
1007 err |= __put_user((u64)sfp, &rw->ins[6]); /* frame pointer */
1008 if (err)
1009 goto sigsegv;
1010
1011 regs->u_regs[UREG_I0] = signr;
1012 regs->u_regs[UREG_I1] = (u32)(u64) si;
1013 regs->u_regs[UREG_I2] = (u32)(u64) uc;
1014 }
1015 return;
1016
1017 sigsegv:
1018 force_sigsegv(signr, current);
1019 }
1020
1021 asmlinkage int
1022 svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
1023 {
1024 svr4_gregset_t __user *gr;
1025 svr4_mcontext_t __user *mc;
1026 svr4_sigset_t setv;
1027 int i, err;
1028 u32 psr;
1029
1030 synchronize_user_stack();
1031 save_and_clear_fpu();
1032
1033 if (get_thread_wsaved())
1034 do_exit(SIGSEGV);
1035
1036 err = clear_user(uc, sizeof(*uc));
1037
1038 /* Setup convenience variables */
1039 mc = &uc->mcontext;
1040 gr = &mc->greg;
1041
1042 setv.sigbits[0] = current->blocked.sig[0];
1043 setv.sigbits[1] = (current->blocked.sig[0] >> 32);
1044 if (_NSIG_WORDS >= 2) {
1045 setv.sigbits[2] = current->blocked.sig[1];
1046 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
1047 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
1048 } else
1049 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
1050
1051 /* Store registers */
1052 if (test_thread_flag(TIF_32BIT)) {
1053 regs->tpc &= 0xffffffff;
1054 regs->tnpc &= 0xffffffff;
1055 }
1056 err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]);
1057 err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]);
1058
1059 psr = tstate_to_psr(regs->tstate) & ~PSR_EF;
1060 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1061 psr |= PSR_EF;
1062 err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]);
1063
1064 err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
1065
1066 /* Copy g[1..7] and o[0..7] registers */
1067 for (i = 0; i < 7; i++)
1068 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1069 for (i = 0; i < 8; i++)
1070 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1071
1072 /* Setup sigaltstack */
1073 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
1074 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
1075 err |= __put_user(current->sas_ss_size, &uc->stack.size);
1076
1077 /* The register file is not saved
1078 * we have already stuffed all of it with sync_user_stack
1079 */
1080 return (err ? -EFAULT : 0);
1081 }
1082
1083
1084 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
1085 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
1086 {
1087 svr4_gregset_t __user *gr;
1088 mm_segment_t old_fs;
1089 u32 pc, npc, psr, u_ss_sp;
1090 sigset_t set;
1091 svr4_sigset_t setv;
1092 int i, err;
1093 stack_t st;
1094
1095 /* Fixme: restore windows, or is this already taken care of in
1096 * svr4_setup_frame when sync_user_windows is done?
1097 */
1098 flush_user_windows();
1099
1100 if (get_thread_wsaved())
1101 goto sigsegv;
1102
1103 if (((unsigned long) c) & 3){
1104 printk("Unaligned structure passed\n");
1105 goto sigsegv;
1106 }
1107
1108 if (!__access_ok(c, sizeof(*c))) {
1109 /* Miguel, add nice debugging msg _here_. ;-) */
1110 goto sigsegv;
1111 }
1112
1113 /* Check for valid PC and nPC */
1114 gr = &c->mcontext.greg;
1115 err = __get_user(pc, &((*gr)[SVR4_PC]));
1116 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1117 if ((pc | npc) & 3)
1118 goto sigsegv;
1119
1120 /* Retrieve information from passed ucontext */
1121 /* note that nPC is ored a 1, this is used to inform entry.S */
1122 /* that we don't want it to mess with our PC and nPC */
1123
1124 err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1125 set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1126 if (_NSIG_WORDS >= 2)
1127 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1128
1129 err |= __get_user(u_ss_sp, &c->stack.sp);
1130 st.ss_sp = compat_ptr(u_ss_sp);
1131 err |= __get_user(st.ss_flags, &c->stack.flags);
1132 err |= __get_user(st.ss_size, &c->stack.size);
1133 if (err)
1134 goto sigsegv;
1135
1136 /* It is more difficult to avoid calling this function than to
1137 call it and ignore errors. */
1138 old_fs = get_fs();
1139 set_fs(KERNEL_DS);
1140 do_sigaltstack((stack_t __user *) &st, NULL, regs->u_regs[UREG_I6]);
1141 set_fs(old_fs);
1142
1143 sigdelsetmask(&set, ~_BLOCKABLE);
1144 spin_lock_irq(&current->sighand->siglock);
1145 current->blocked = set;
1146 recalc_sigpending();
1147 spin_unlock_irq(&current->sighand->siglock);
1148 regs->tpc = pc;
1149 regs->tnpc = npc | 1;
1150 if (test_thread_flag(TIF_32BIT)) {
1151 regs->tpc &= 0xffffffff;
1152 regs->tnpc &= 0xffffffff;
1153 }
1154 err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
1155 err |= __get_user(psr, &((*gr)[SVR4_PSR]));
1156 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1157 regs->tstate |= psr_to_tstate_icc(psr);
1158
1159 /* Restore g[1..7] and o[0..7] registers */
1160 for (i = 0; i < 7; i++)
1161 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1162 for (i = 0; i < 8; i++)
1163 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1164 if (err)
1165 goto sigsegv;
1166
1167 return -EINTR;
1168 sigsegv:
1169 return -EFAULT;
1170 }
1171
1172 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1173 unsigned long signr, sigset_t *oldset,
1174 siginfo_t *info)
1175 {
1176 struct rt_signal_frame32 __user *sf;
1177 int sigframe_size;
1178 u32 psr;
1179 int i, err;
1180 compat_sigset_t seta;
1181
1182 /* 1. Make sure everything is clean */
1183 synchronize_user_stack();
1184 save_and_clear_fpu();
1185
1186 sigframe_size = RT_ALIGNEDSZ;
1187 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
1188 sigframe_size -= sizeof(__siginfo_fpu_t);
1189
1190 sf = (struct rt_signal_frame32 __user *)
1191 get_sigframe(&ka->sa, regs, sigframe_size);
1192
1193 if (invalid_frame_pointer(sf, sigframe_size))
1194 goto sigill;
1195
1196 if (get_thread_wsaved() != 0)
1197 goto sigill;
1198
1199 /* 2. Save the current process state */
1200 if (test_thread_flag(TIF_32BIT)) {
1201 regs->tpc &= 0xffffffff;
1202 regs->tnpc &= 0xffffffff;
1203 }
1204 err = put_user(regs->tpc, &sf->regs.pc);
1205 err |= __put_user(regs->tnpc, &sf->regs.npc);
1206 err |= __put_user(regs->y, &sf->regs.y);
1207 psr = tstate_to_psr(regs->tstate);
1208 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1209 psr |= PSR_EF;
1210 err |= __put_user(psr, &sf->regs.psr);
1211 for (i = 0; i < 16; i++)
1212 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1213 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1214 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1215 for (i = 1; i < 16; i++)
1216 err |= __put_user(((u32 *)regs->u_regs)[2*i],
1217 &sf->v8plus.g_upper[i]);
1218 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
1219 &sf->v8plus.asi);
1220
1221 if (psr & PSR_EF) {
1222 err |= save_fpu_state32(regs, &sf->fpu_state);
1223 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1224 } else {
1225 err |= __put_user(0, &sf->fpu_save);
1226 }
1227
1228 /* Update the siginfo structure. */
1229 err |= copy_siginfo_to_user32(&sf->info, info);
1230
1231 /* Setup sigaltstack */
1232 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1233 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1234 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1235
1236 switch (_NSIG_WORDS) {
1237 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1238 seta.sig[6] = oldset->sig[3];
1239 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1240 seta.sig[4] = oldset->sig[2];
1241 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1242 seta.sig[2] = oldset->sig[1];
1243 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1244 seta.sig[0] = oldset->sig[0];
1245 }
1246 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
1247
1248 err |= copy_in_user((u32 __user *)sf,
1249 (u32 __user *)(regs->u_regs[UREG_FP]),
1250 sizeof(struct reg_window32));
1251 if (err)
1252 goto sigsegv;
1253
1254 /* 3. signal handler back-trampoline and parameters */
1255 regs->u_regs[UREG_FP] = (unsigned long) sf;
1256 regs->u_regs[UREG_I0] = signr;
1257 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1258 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
1259
1260 /* 4. signal handler */
1261 regs->tpc = (unsigned long) ka->sa.sa_handler;
1262 regs->tnpc = (regs->tpc + 4);
1263 if (test_thread_flag(TIF_32BIT)) {
1264 regs->tpc &= 0xffffffff;
1265 regs->tnpc &= 0xffffffff;
1266 }
1267
1268 /* 5. return to kernel instructions */
1269 if (ka->ka_restorer)
1270 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1271 else {
1272 /* Flush instruction space. */
1273 unsigned long address = ((unsigned long)&(sf->insns[0]));
1274 pgd_t *pgdp = pgd_offset(current->mm, address);
1275 pud_t *pudp = pud_offset(pgdp, address);
1276 pmd_t *pmdp = pmd_offset(pudp, address);
1277 pte_t *ptep;
1278
1279 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1280
1281 /* mov __NR_rt_sigreturn, %g1 */
1282 err |= __put_user(0x82102065, &sf->insns[0]);
1283
1284 /* t 0x10 */
1285 err |= __put_user(0x91d02010, &sf->insns[1]);
1286 if (err)
1287 goto sigsegv;
1288
1289 preempt_disable();
1290 ptep = pte_offset_map(pmdp, address);
1291 if (pte_present(*ptep)) {
1292 unsigned long page = (unsigned long)
1293 page_address(pte_page(*ptep));
1294
1295 __asm__ __volatile__(
1296 " membar #StoreStore\n"
1297 " flush %0 + %1"
1298 : : "r" (page), "r" (address & (PAGE_SIZE - 1))
1299 : "memory");
1300 }
1301 pte_unmap(ptep);
1302 preempt_enable();
1303 }
1304 return;
1305
1306 sigill:
1307 do_exit(SIGILL);
1308 sigsegv:
1309 force_sigsegv(signr, current);
1310 }
1311
1312 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1313 siginfo_t *info,
1314 sigset_t *oldset, struct pt_regs *regs,
1315 int svr4_signal)
1316 {
1317 if (svr4_signal)
1318 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc,
1319 regs, signr, oldset);
1320 else {
1321 if (ka->sa.sa_flags & SA_SIGINFO)
1322 setup_rt_frame32(ka, regs, signr, oldset, info);
1323 else if (test_thread_flag(TIF_NEWSIGNALS))
1324 new_setup_frame32(ka, regs, signr, oldset);
1325 else
1326 setup_frame32(&ka->sa, regs, signr, oldset, info);
1327 }
1328 if (!(ka->sa.sa_flags & SA_NOMASK)) {
1329 spin_lock_irq(&current->sighand->siglock);
1330 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
1331 sigaddset(&current->blocked,signr);
1332 recalc_sigpending();
1333 spin_unlock_irq(&current->sighand->siglock);
1334 }
1335 }
1336
1337 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1338 struct sigaction *sa)
1339 {
1340 switch (regs->u_regs[UREG_I0]) {
1341 case ERESTART_RESTARTBLOCK:
1342 case ERESTARTNOHAND:
1343 no_system_call_restart:
1344 regs->u_regs[UREG_I0] = EINTR;
1345 regs->tstate |= TSTATE_ICARRY;
1346 break;
1347 case ERESTARTSYS:
1348 if (!(sa->sa_flags & SA_RESTART))
1349 goto no_system_call_restart;
1350 /* fallthrough */
1351 case ERESTARTNOINTR:
1352 regs->u_regs[UREG_I0] = orig_i0;
1353 regs->tpc -= 4;
1354 regs->tnpc -= 4;
1355 }
1356 }
1357
1358 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1359 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1360 * mistake.
1361 */
1362 int do_signal32(sigset_t *oldset, struct pt_regs * regs,
1363 unsigned long orig_i0, int restart_syscall)
1364 {
1365 siginfo_t info;
1366 struct signal_deliver_cookie cookie;
1367 struct k_sigaction ka;
1368 int signr;
1369 int svr4_signal = current->personality == PER_SVR4;
1370
1371 cookie.restart_syscall = restart_syscall;
1372 cookie.orig_i0 = orig_i0;
1373
1374 signr = get_signal_to_deliver(&info, &ka, regs, &cookie);
1375 if (signr > 0) {
1376 if (cookie.restart_syscall)
1377 syscall_restart32(orig_i0, regs, &ka.sa);
1378 handle_signal32(signr, &ka, &info, oldset,
1379 regs, svr4_signal);
1380 return 1;
1381 }
1382 if (cookie.restart_syscall &&
1383 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1384 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1385 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1386 /* replay the system call when we are done */
1387 regs->u_regs[UREG_I0] = cookie.orig_i0;
1388 regs->tpc -= 4;
1389 regs->tnpc -= 4;
1390 }
1391 if (cookie.restart_syscall &&
1392 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1393 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1394 regs->tpc -= 4;
1395 regs->tnpc -= 4;
1396 }
1397 return 0;
1398 }
1399
1400 struct sigstack32 {
1401 u32 the_stack;
1402 int cur_status;
1403 };
1404
1405 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1406 {
1407 struct sigstack32 __user *ssptr =
1408 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1409 struct sigstack32 __user *ossptr =
1410 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1411 int ret = -EFAULT;
1412
1413 /* First see if old state is wanted. */
1414 if (ossptr) {
1415 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1416 &ossptr->the_stack) ||
1417 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1418 goto out;
1419 }
1420
1421 /* Now see if we want to update the new state. */
1422 if (ssptr) {
1423 u32 ss_sp;
1424
1425 if (get_user(ss_sp, &ssptr->the_stack))
1426 goto out;
1427
1428 /* If the current stack was set with sigaltstack, don't
1429 * swap stacks while we are on it.
1430 */
1431 ret = -EPERM;
1432 if (current->sas_ss_sp && on_sig_stack(sp))
1433 goto out;
1434
1435 /* Since we don't know the extent of the stack, and we don't
1436 * track onstack-ness, but rather calculate it, we must
1437 * presume a size. Ho hum this interface is lossy.
1438 */
1439 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1440 current->sas_ss_size = SIGSTKSZ;
1441 }
1442
1443 ret = 0;
1444 out:
1445 return ret;
1446 }
1447
1448 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1449 {
1450 stack_t uss, uoss;
1451 u32 u_ss_sp = 0;
1452 int ret;
1453 mm_segment_t old_fs;
1454 stack_t32 __user *uss32 = compat_ptr(ussa);
1455 stack_t32 __user *uoss32 = compat_ptr(uossa);
1456
1457 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
1458 __get_user(uss.ss_flags, &uss32->ss_flags) ||
1459 __get_user(uss.ss_size, &uss32->ss_size)))
1460 return -EFAULT;
1461 uss.ss_sp = compat_ptr(u_ss_sp);
1462 old_fs = get_fs();
1463 set_fs(KERNEL_DS);
1464 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
1465 uossa ? (stack_t __user *) &uoss : NULL, sp);
1466 set_fs(old_fs);
1467 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
1468 __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
1469 __put_user(uoss.ss_size, &uoss32->ss_size)))
1470 return -EFAULT;
1471 return ret;
1472 }
Verdex Pro support