projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sparc: Fix debugger syscall restart interactions.
[deliverable/linux.git] / arch / sparc64 / kernel / signal32.c
1 /* arch/sparc64/kernel/signal32.c
2 *
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
6 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 */
9
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
12 #include <linux/signal.h>
13 #include <linux/errno.h>
14 #include <linux/wait.h>
15 #include <linux/ptrace.h>
16 #include <linux/unistd.h>
17 #include <linux/mm.h>
18 #include <linux/tty.h>
19 #include <linux/binfmts.h>
20 #include <linux/compat.h>
21 #include <linux/bitops.h>
22
23 #include <asm/uaccess.h>
24 #include <asm/ptrace.h>
25 #include <asm/pgtable.h>
26 #include <asm/psrcompat.h>
27 #include <asm/fpumacro.h>
28 #include <asm/visasm.h>
29 #include <asm/compat_signal.h>
30
31 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33 /* This magic should be in g_upper[0] for all upper parts
34 * to be valid.
35 */
36 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
37 typedef struct {
38 unsigned int g_upper[8];
39 unsigned int o_upper[8];
40 unsigned int asi;
41 } siginfo_extra_v8plus_t;
42
43 struct signal_frame32 {
44 struct sparc_stackf32 ss;
45 __siginfo32_t info;
46 /* __siginfo_fpu32_t * */ u32 fpu_save;
47 unsigned int insns[2];
48 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
49 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
50 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
51 siginfo_extra_v8plus_t v8plus;
52 __siginfo_fpu_t fpu_state;
53 };
54
55 typedef struct compat_siginfo{
56 int si_signo;
57 int si_errno;
58 int si_code;
59
60 union {
61 int _pad[SI_PAD_SIZE32];
62
63 /* kill() */
64 struct {
65 compat_pid_t _pid; /* sender's pid */
66 unsigned int _uid; /* sender's uid */
67 } _kill;
68
69 /* POSIX.1b timers */
70 struct {
71 compat_timer_t _tid; /* timer id */
72 int _overrun; /* overrun count */
73 compat_sigval_t _sigval; /* same as below */
74 int _sys_private; /* not to be passed to user */
75 } _timer;
76
77 /* POSIX.1b signals */
78 struct {
79 compat_pid_t _pid; /* sender's pid */
80 unsigned int _uid; /* sender's uid */
81 compat_sigval_t _sigval;
82 } _rt;
83
84 /* SIGCHLD */
85 struct {
86 compat_pid_t _pid; /* which child */
87 unsigned int _uid; /* sender's uid */
88 int _status; /* exit code */
89 compat_clock_t _utime;
90 compat_clock_t _stime;
91 } _sigchld;
92
93 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
94 struct {
95 u32 _addr; /* faulting insn/memory ref. */
96 int _trapno;
97 } _sigfault;
98
99 /* SIGPOLL */
100 struct {
101 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
102 int _fd;
103 } _sigpoll;
104 } _sifields;
105 }compat_siginfo_t;
106
107 struct rt_signal_frame32 {
108 struct sparc_stackf32 ss;
109 compat_siginfo_t info;
110 struct pt_regs32 regs;
111 compat_sigset_t mask;
112 /* __siginfo_fpu32_t * */ u32 fpu_save;
113 unsigned int insns[2];
114 stack_t32 stack;
115 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
116 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
117 siginfo_extra_v8plus_t v8plus;
118 __siginfo_fpu_t fpu_state;
119 };
120
121 /* Align macros */
122 #define SF_ALIGNEDSZ (((sizeof(struct signal_frame32) + 7) & (~7)))
123 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
124
125 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
126 {
127 int err;
128
129 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
130 return -EFAULT;
131
132 /* If you change siginfo_t structure, please be sure
133 this code is fixed accordingly.
134 It should never copy any pad contained in the structure
135 to avoid security leaks, but must copy the generic
136 3 ints plus the relevant union member.
137 This routine must convert siginfo from 64bit to 32bit as well
138 at the same time. */
139 err = __put_user(from->si_signo, &to->si_signo);
140 err |= __put_user(from->si_errno, &to->si_errno);
141 err |= __put_user((short)from->si_code, &to->si_code);
142 if (from->si_code < 0)
143 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
144 else {
145 switch (from->si_code >> 16) {
146 case __SI_TIMER >> 16:
147 err |= __put_user(from->si_tid, &to->si_tid);
148 err |= __put_user(from->si_overrun, &to->si_overrun);
149 err |= __put_user(from->si_int, &to->si_int);
150 break;
151 case __SI_CHLD >> 16:
152 err |= __put_user(from->si_utime, &to->si_utime);
153 err |= __put_user(from->si_stime, &to->si_stime);
154 err |= __put_user(from->si_status, &to->si_status);
155 default:
156 err |= __put_user(from->si_pid, &to->si_pid);
157 err |= __put_user(from->si_uid, &to->si_uid);
158 break;
159 case __SI_FAULT >> 16:
160 err |= __put_user(from->si_trapno, &to->si_trapno);
161 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
162 break;
163 case __SI_POLL >> 16:
164 err |= __put_user(from->si_band, &to->si_band);
165 err |= __put_user(from->si_fd, &to->si_fd);
166 break;
167 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
168 case __SI_MESGQ >> 16:
169 err |= __put_user(from->si_pid, &to->si_pid);
170 err |= __put_user(from->si_uid, &to->si_uid);
171 err |= __put_user(from->si_int, &to->si_int);
172 break;
173 }
174 }
175 return err;
176 }
177
178 /* CAUTION: This is just a very minimalist implementation for the
179 * sake of compat_sys_rt_sigqueueinfo()
180 */
181 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
182 {
183 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
184 return -EFAULT;
185
186 if (copy_from_user(to, from, 3*sizeof(int)) ||
187 copy_from_user(to->_sifields._pad, from->_sifields._pad,
188 SI_PAD_SIZE))
189 return -EFAULT;
190
191 return 0;
192 }
193
194 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
195 {
196 unsigned long *fpregs = current_thread_info()->fpregs;
197 unsigned long fprs;
198 int err;
199
200 err = __get_user(fprs, &fpu->si_fprs);
201 fprs_write(0);
202 regs->tstate &= ~TSTATE_PEF;
203 if (fprs & FPRS_DL)
204 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
205 if (fprs & FPRS_DU)
206 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
207 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
208 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
209 current_thread_info()->fpsaved[0] |= fprs;
210 return err;
211 }
212
213 void do_sigreturn32(struct pt_regs *regs)
214 {
215 struct signal_frame32 __user *sf;
216 unsigned int psr;
217 unsigned pc, npc, fpu_save;
218 sigset_t set;
219 unsigned seta[_COMPAT_NSIG_WORDS];
220 int err, i;
221
222 /* Always make any pending restarted system calls return -EINTR */
223 current_thread_info()->restart_block.fn = do_no_restart_syscall;
224
225 synchronize_user_stack();
226
227 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
228 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
229
230 /* 1. Make sure we are not getting garbage from the user */
231 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
232 (((unsigned long) sf) & 3))
233 goto segv;
234
235 get_user(pc, &sf->info.si_regs.pc);
236 __get_user(npc, &sf->info.si_regs.npc);
237
238 if ((pc | npc) & 3)
239 goto segv;
240
241 if (test_thread_flag(TIF_32BIT)) {
242 pc &= 0xffffffff;
243 npc &= 0xffffffff;
244 }
245 regs->tpc = pc;
246 regs->tnpc = npc;
247
248 /* 2. Restore the state */
249 err = __get_user(regs->y, &sf->info.si_regs.y);
250 err |= __get_user(psr, &sf->info.si_regs.psr);
251
252 for (i = UREG_G1; i <= UREG_I7; i++)
253 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
254 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
255 err |= __get_user(i, &sf->v8plus.g_upper[0]);
256 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
257 unsigned long asi;
258
259 for (i = UREG_G1; i <= UREG_I7; i++)
260 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
261 err |= __get_user(asi, &sf->v8plus.asi);
262 regs->tstate &= ~TSTATE_ASI;
263 regs->tstate |= ((asi & 0xffUL) << 24UL);
264 }
265 }
266
267 /* User can only change condition codes in %tstate. */
268 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
269 regs->tstate |= psr_to_tstate_icc(psr);
270
271 /* Prevent syscall restart. */
272 pt_regs_clear_syscall(regs);
273
274 err |= __get_user(fpu_save, &sf->fpu_save);
275 if (fpu_save)
276 err |= restore_fpu_state32(regs, &sf->fpu_state);
277 err |= __get_user(seta[0], &sf->info.si_mask);
278 err |= copy_from_user(seta+1, &sf->extramask,
279 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
280 if (err)
281 goto segv;
282 switch (_NSIG_WORDS) {
283 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
284 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
285 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
286 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
287 }
288 sigdelsetmask(&set, ~_BLOCKABLE);
289 spin_lock_irq(&current->sighand->siglock);
290 current->blocked = set;
291 recalc_sigpending();
292 spin_unlock_irq(&current->sighand->siglock);
293 return;
294
295 segv:
296 force_sig(SIGSEGV, current);
297 }
298
299 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
300 {
301 struct rt_signal_frame32 __user *sf;
302 unsigned int psr, pc, npc, fpu_save, u_ss_sp;
303 mm_segment_t old_fs;
304 sigset_t set;
305 compat_sigset_t seta;
306 stack_t st;
307 int err, i;
308
309 /* Always make any pending restarted system calls return -EINTR */
310 current_thread_info()->restart_block.fn = do_no_restart_syscall;
311
312 synchronize_user_stack();
313 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
314 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
315
316 /* 1. Make sure we are not getting garbage from the user */
317 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
318 (((unsigned long) sf) & 3))
319 goto segv;
320
321 get_user(pc, &sf->regs.pc);
322 __get_user(npc, &sf->regs.npc);
323
324 if ((pc | npc) & 3)
325 goto segv;
326
327 if (test_thread_flag(TIF_32BIT)) {
328 pc &= 0xffffffff;
329 npc &= 0xffffffff;
330 }
331 regs->tpc = pc;
332 regs->tnpc = npc;
333
334 /* 2. Restore the state */
335 err = __get_user(regs->y, &sf->regs.y);
336 err |= __get_user(psr, &sf->regs.psr);
337
338 for (i = UREG_G1; i <= UREG_I7; i++)
339 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
340 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
341 err |= __get_user(i, &sf->v8plus.g_upper[0]);
342 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
343 unsigned long asi;
344
345 for (i = UREG_G1; i <= UREG_I7; i++)
346 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
347 err |= __get_user(asi, &sf->v8plus.asi);
348 regs->tstate &= ~TSTATE_ASI;
349 regs->tstate |= ((asi & 0xffUL) << 24UL);
350 }
351 }
352
353 /* User can only change condition codes in %tstate. */
354 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
355 regs->tstate |= psr_to_tstate_icc(psr);
356
357 /* Prevent syscall restart. */
358 pt_regs_clear_syscall(regs);
359
360 err |= __get_user(fpu_save, &sf->fpu_save);
361 if (fpu_save)
362 err |= restore_fpu_state32(regs, &sf->fpu_state);
363 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
364 err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
365 st.ss_sp = compat_ptr(u_ss_sp);
366 err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
367 err |= __get_user(st.ss_size, &sf->stack.ss_size);
368 if (err)
369 goto segv;
370
371 /* It is more difficult to avoid calling this function than to
372 call it and ignore errors. */
373 old_fs = get_fs();
374 set_fs(KERNEL_DS);
375 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
376 set_fs(old_fs);
377
378 switch (_NSIG_WORDS) {
379 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
380 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
381 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
382 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
383 }
384 sigdelsetmask(&set, ~_BLOCKABLE);
385 spin_lock_irq(&current->sighand->siglock);
386 current->blocked = set;
387 recalc_sigpending();
388 spin_unlock_irq(&current->sighand->siglock);
389 return;
390 segv:
391 force_sig(SIGSEGV, current);
392 }
393
394 /* Checks if the fp is valid */
395 static int invalid_frame_pointer(void __user *fp, int fplen)
396 {
397 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
398 return 1;
399 return 0;
400 }
401
402 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
403 {
404 unsigned long sp;
405
406 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
407 sp = regs->u_regs[UREG_FP];
408
409 /*
410 * If we are on the alternate signal stack and would overflow it, don't.
411 * Return an always-bogus address instead so we will die with SIGSEGV.
412 */
413 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
414 return (void __user *) -1L;
415
416 /* This is the X/Open sanctioned signal stack switching. */
417 if (sa->sa_flags & SA_ONSTACK) {
418 if (sas_ss_flags(sp) == 0)
419 sp = current->sas_ss_sp + current->sas_ss_size;
420 }
421
422 /* Always align the stack frame. This handles two cases. First,
423 * sigaltstack need not be mindful of platform specific stack
424 * alignment. Second, if we took this signal because the stack
425 * is not aligned properly, we'd like to take the signal cleanly
426 * and report that.
427 */
428 sp &= ~7UL;
429
430 return (void __user *)(sp - framesize);
431 }
432
433 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
434 {
435 unsigned long *fpregs = current_thread_info()->fpregs;
436 unsigned long fprs;
437 int err = 0;
438
439 fprs = current_thread_info()->fpsaved[0];
440 if (fprs & FPRS_DL)
441 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
442 (sizeof(unsigned int) * 32));
443 if (fprs & FPRS_DU)
444 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
445 (sizeof(unsigned int) * 32));
446 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
447 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
448 err |= __put_user(fprs, &fpu->si_fprs);
449
450 return err;
451 }
452
453 static void setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
454 int signo, sigset_t *oldset)
455 {
456 struct signal_frame32 __user *sf;
457 int sigframe_size;
458 u32 psr;
459 int i, err;
460 unsigned int seta[_COMPAT_NSIG_WORDS];
461
462 /* 1. Make sure everything is clean */
463 synchronize_user_stack();
464 save_and_clear_fpu();
465
466 sigframe_size = SF_ALIGNEDSZ;
467 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
468 sigframe_size -= sizeof(__siginfo_fpu_t);
469
470 sf = (struct signal_frame32 __user *)
471 get_sigframe(&ka->sa, regs, sigframe_size);
472
473 if (invalid_frame_pointer(sf, sigframe_size))
474 goto sigill;
475
476 if (get_thread_wsaved() != 0)
477 goto sigill;
478
479 /* 2. Save the current process state */
480 if (test_thread_flag(TIF_32BIT)) {
481 regs->tpc &= 0xffffffff;
482 regs->tnpc &= 0xffffffff;
483 }
484 err = put_user(regs->tpc, &sf->info.si_regs.pc);
485 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
486 err |= __put_user(regs->y, &sf->info.si_regs.y);
487 psr = tstate_to_psr(regs->tstate);
488 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
489 psr |= PSR_EF;
490 err |= __put_user(psr, &sf->info.si_regs.psr);
491 for (i = 0; i < 16; i++)
492 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
493 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
494 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
495 for (i = 1; i < 16; i++)
496 err |= __put_user(((u32 *)regs->u_regs)[2*i],
497 &sf->v8plus.g_upper[i]);
498 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
499 &sf->v8plus.asi);
500
501 if (psr & PSR_EF) {
502 err |= save_fpu_state32(regs, &sf->fpu_state);
503 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
504 } else {
505 err |= __put_user(0, &sf->fpu_save);
506 }
507
508 switch (_NSIG_WORDS) {
509 case 4: seta[7] = (oldset->sig[3] >> 32);
510 seta[6] = oldset->sig[3];
511 case 3: seta[5] = (oldset->sig[2] >> 32);
512 seta[4] = oldset->sig[2];
513 case 2: seta[3] = (oldset->sig[1] >> 32);
514 seta[2] = oldset->sig[1];
515 case 1: seta[1] = (oldset->sig[0] >> 32);
516 seta[0] = oldset->sig[0];
517 }
518 err |= __put_user(seta[0], &sf->info.si_mask);
519 err |= __copy_to_user(sf->extramask, seta + 1,
520 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
521
522 err |= copy_in_user((u32 __user *)sf,
523 (u32 __user *)(regs->u_regs[UREG_FP]),
524 sizeof(struct reg_window32));
525
526 if (err)
527 goto sigsegv;
528
529 /* 3. signal handler back-trampoline and parameters */
530 regs->u_regs[UREG_FP] = (unsigned long) sf;
531 regs->u_regs[UREG_I0] = signo;
532 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
533 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
534
535 /* 4. signal handler */
536 regs->tpc = (unsigned long) ka->sa.sa_handler;
537 regs->tnpc = (regs->tpc + 4);
538 if (test_thread_flag(TIF_32BIT)) {
539 regs->tpc &= 0xffffffff;
540 regs->tnpc &= 0xffffffff;
541 }
542
543 /* 5. return to kernel instructions */
544 if (ka->ka_restorer) {
545 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
546 } else {
547 /* Flush instruction space. */
548 unsigned long address = ((unsigned long)&(sf->insns[0]));
549 pgd_t *pgdp = pgd_offset(current->mm, address);
550 pud_t *pudp = pud_offset(pgdp, address);
551 pmd_t *pmdp = pmd_offset(pudp, address);
552 pte_t *ptep;
553 pte_t pte;
554
555 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
556
557 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
558 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
559 if (err)
560 goto sigsegv;
561
562 preempt_disable();
563 ptep = pte_offset_map(pmdp, address);
564 pte = *ptep;
565 if (pte_present(pte)) {
566 unsigned long page = (unsigned long)
567 page_address(pte_page(pte));
568
569 wmb();
570 __asm__ __volatile__("flush %0 + %1"
571 : /* no outputs */
572 : "r" (page),
573 "r" (address & (PAGE_SIZE - 1))
574 : "memory");
575 }
576 pte_unmap(ptep);
577 preempt_enable();
578 }
579 return;
580
581 sigill:
582 do_exit(SIGILL);
583 sigsegv:
584 force_sigsegv(signo, current);
585 }
586
587 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
588 unsigned long signr, sigset_t *oldset,
589 siginfo_t *info)
590 {
591 struct rt_signal_frame32 __user *sf;
592 int sigframe_size;
593 u32 psr;
594 int i, err;
595 compat_sigset_t seta;
596
597 /* 1. Make sure everything is clean */
598 synchronize_user_stack();
599 save_and_clear_fpu();
600
601 sigframe_size = RT_ALIGNEDSZ;
602 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
603 sigframe_size -= sizeof(__siginfo_fpu_t);
604
605 sf = (struct rt_signal_frame32 __user *)
606 get_sigframe(&ka->sa, regs, sigframe_size);
607
608 if (invalid_frame_pointer(sf, sigframe_size))
609 goto sigill;
610
611 if (get_thread_wsaved() != 0)
612 goto sigill;
613
614 /* 2. Save the current process state */
615 if (test_thread_flag(TIF_32BIT)) {
616 regs->tpc &= 0xffffffff;
617 regs->tnpc &= 0xffffffff;
618 }
619 err = put_user(regs->tpc, &sf->regs.pc);
620 err |= __put_user(regs->tnpc, &sf->regs.npc);
621 err |= __put_user(regs->y, &sf->regs.y);
622 psr = tstate_to_psr(regs->tstate);
623 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
624 psr |= PSR_EF;
625 err |= __put_user(psr, &sf->regs.psr);
626 for (i = 0; i < 16; i++)
627 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
628 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
629 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
630 for (i = 1; i < 16; i++)
631 err |= __put_user(((u32 *)regs->u_regs)[2*i],
632 &sf->v8plus.g_upper[i]);
633 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
634 &sf->v8plus.asi);
635
636 if (psr & PSR_EF) {
637 err |= save_fpu_state32(regs, &sf->fpu_state);
638 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
639 } else {
640 err |= __put_user(0, &sf->fpu_save);
641 }
642
643 /* Update the siginfo structure. */
644 err |= copy_siginfo_to_user32(&sf->info, info);
645
646 /* Setup sigaltstack */
647 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
648 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
649 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
650
651 switch (_NSIG_WORDS) {
652 case 4: seta.sig[7] = (oldset->sig[3] >> 32);
653 seta.sig[6] = oldset->sig[3];
654 case 3: seta.sig[5] = (oldset->sig[2] >> 32);
655 seta.sig[4] = oldset->sig[2];
656 case 2: seta.sig[3] = (oldset->sig[1] >> 32);
657 seta.sig[2] = oldset->sig[1];
658 case 1: seta.sig[1] = (oldset->sig[0] >> 32);
659 seta.sig[0] = oldset->sig[0];
660 }
661 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
662
663 err |= copy_in_user((u32 __user *)sf,
664 (u32 __user *)(regs->u_regs[UREG_FP]),
665 sizeof(struct reg_window32));
666 if (err)
667 goto sigsegv;
668
669 /* 3. signal handler back-trampoline and parameters */
670 regs->u_regs[UREG_FP] = (unsigned long) sf;
671 regs->u_regs[UREG_I0] = signr;
672 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
673 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
674
675 /* 4. signal handler */
676 regs->tpc = (unsigned long) ka->sa.sa_handler;
677 regs->tnpc = (regs->tpc + 4);
678 if (test_thread_flag(TIF_32BIT)) {
679 regs->tpc &= 0xffffffff;
680 regs->tnpc &= 0xffffffff;
681 }
682
683 /* 5. return to kernel instructions */
684 if (ka->ka_restorer)
685 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
686 else {
687 /* Flush instruction space. */
688 unsigned long address = ((unsigned long)&(sf->insns[0]));
689 pgd_t *pgdp = pgd_offset(current->mm, address);
690 pud_t *pudp = pud_offset(pgdp, address);
691 pmd_t *pmdp = pmd_offset(pudp, address);
692 pte_t *ptep;
693
694 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
695
696 /* mov __NR_rt_sigreturn, %g1 */
697 err |= __put_user(0x82102065, &sf->insns[0]);
698
699 /* t 0x10 */
700 err |= __put_user(0x91d02010, &sf->insns[1]);
701 if (err)
702 goto sigsegv;
703
704 preempt_disable();
705 ptep = pte_offset_map(pmdp, address);
706 if (pte_present(*ptep)) {
707 unsigned long page = (unsigned long)
708 page_address(pte_page(*ptep));
709
710 wmb();
711 __asm__ __volatile__("flush %0 + %1"
712 : /* no outputs */
713 : "r" (page),
714 "r" (address & (PAGE_SIZE - 1))
715 : "memory");
716 }
717 pte_unmap(ptep);
718 preempt_enable();
719 }
720 return;
721
722 sigill:
723 do_exit(SIGILL);
724 sigsegv:
725 force_sigsegv(signr, current);
726 }
727
728 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
729 siginfo_t *info,
730 sigset_t *oldset, struct pt_regs *regs)
731 {
732 if (ka->sa.sa_flags & SA_SIGINFO)
733 setup_rt_frame32(ka, regs, signr, oldset, info);
734 else
735 setup_frame32(ka, regs, signr, oldset);
736
737 spin_lock_irq(&current->sighand->siglock);
738 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
739 if (!(ka->sa.sa_flags & SA_NOMASK))
740 sigaddset(&current->blocked,signr);
741 recalc_sigpending();
742 spin_unlock_irq(&current->sighand->siglock);
743 }
744
745 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
746 struct sigaction *sa)
747 {
748 switch (regs->u_regs[UREG_I0]) {
749 case ERESTART_RESTARTBLOCK:
750 case ERESTARTNOHAND:
751 no_system_call_restart:
752 regs->u_regs[UREG_I0] = EINTR;
753 regs->tstate |= TSTATE_ICARRY;
754 break;
755 case ERESTARTSYS:
756 if (!(sa->sa_flags & SA_RESTART))
757 goto no_system_call_restart;
758 /* fallthrough */
759 case ERESTARTNOINTR:
760 regs->u_regs[UREG_I0] = orig_i0;
761 regs->tpc -= 4;
762 regs->tnpc -= 4;
763 }
764 }
765
766 /* Note that 'init' is a special process: it doesn't get signals it doesn't
767 * want to handle. Thus you cannot kill init even with a SIGKILL even by
768 * mistake.
769 */
770 void do_signal32(sigset_t *oldset, struct pt_regs * regs,
771 int restart_syscall, unsigned long orig_i0)
772 {
773 struct k_sigaction ka;
774 siginfo_t info;
775 int signr;
776
777 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
778
779 /* If the debugger messes with the program counter, it clears
780 * the "in syscall" bit, directing us to not perform a syscall
781 * restart.
782 */
783 if (restart_syscall && !pt_regs_is_syscall(regs))
784 restart_syscall = 0;
785
786 if (signr > 0) {
787 if (restart_syscall)
788 syscall_restart32(orig_i0, regs, &ka.sa);
789 handle_signal32(signr, &ka, &info, oldset, regs);
790
791 /* a signal was successfully delivered; the saved
792 * sigmask will have been stored in the signal frame,
793 * and will be restored by sigreturn, so we can simply
794 * clear the TIF_RESTORE_SIGMASK flag.
795 */
796 if (test_thread_flag(TIF_RESTORE_SIGMASK))
797 clear_thread_flag(TIF_RESTORE_SIGMASK);
798 return;
799 }
800 if (restart_syscall &&
801 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
802 regs->u_regs[UREG_I0] == ERESTARTSYS ||
803 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
804 /* replay the system call when we are done */
805 regs->u_regs[UREG_I0] = orig_i0;
806 regs->tpc -= 4;
807 regs->tnpc -= 4;
808 }
809 if (restart_syscall &&
810 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
811 regs->u_regs[UREG_G1] = __NR_restart_syscall;
812 regs->tpc -= 4;
813 regs->tnpc -= 4;
814 }
815
816 /* if there's no signal to deliver, we just put the saved sigmask
817 * back
818 */
819 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
820 clear_thread_flag(TIF_RESTORE_SIGMASK);
821 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
822 }
823 }
824
825 struct sigstack32 {
826 u32 the_stack;
827 int cur_status;
828 };
829
830 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
831 {
832 struct sigstack32 __user *ssptr =
833 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
834 struct sigstack32 __user *ossptr =
835 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
836 int ret = -EFAULT;
837
838 /* First see if old state is wanted. */
839 if (ossptr) {
840 if (put_user(current->sas_ss_sp + current->sas_ss_size,
841 &ossptr->the_stack) ||
842 __put_user(on_sig_stack(sp), &ossptr->cur_status))
843 goto out;
844 }
845
846 /* Now see if we want to update the new state. */
847 if (ssptr) {
848 u32 ss_sp;
849
850 if (get_user(ss_sp, &ssptr->the_stack))
851 goto out;
852
853 /* If the current stack was set with sigaltstack, don't
854 * swap stacks while we are on it.
855 */
856 ret = -EPERM;
857 if (current->sas_ss_sp && on_sig_stack(sp))
858 goto out;
859
860 /* Since we don't know the extent of the stack, and we don't
861 * track onstack-ness, but rather calculate it, we must
862 * presume a size. Ho hum this interface is lossy.
863 */
864 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
865 current->sas_ss_size = SIGSTKSZ;
866 }
867
868 ret = 0;
869 out:
870 return ret;
871 }
872
873 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
874 {
875 stack_t uss, uoss;
876 u32 u_ss_sp = 0;
877 int ret;
878 mm_segment_t old_fs;
879 stack_t32 __user *uss32 = compat_ptr(ussa);
880 stack_t32 __user *uoss32 = compat_ptr(uossa);
881
882 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
883 __get_user(uss.ss_flags, &uss32->ss_flags) ||
884 __get_user(uss.ss_size, &uss32->ss_size)))
885 return -EFAULT;
886 uss.ss_sp = compat_ptr(u_ss_sp);
887 old_fs = get_fs();
888 set_fs(KERNEL_DS);
889 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
890 uossa ? (stack_t __user *) &uoss : NULL, sp);
891 set_fs(old_fs);
892 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
893 __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
894 __put_user(uoss.ss_size, &uoss32->ss_size)))
895 return -EFAULT;
896 return ret;
897 }
Linux kernel - Deliverables
This page took 0.067457 seconds and 5 git commands to generate.