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