projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec
[deliverable/linux.git] / arch / sparc / kernel / signal32.c
CommitLineData
5526b7e4 1/* arch/sparc64/kernel/signal32.c
1da177e4
LT		 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>
1da177e4
LT		 19#include <linux/binfmts.h>
20#include <linux/compat.h>
21#include <linux/bitops.h>
95698466 22#include <linux/tracehook.h>
1da177e4
LT		 23
24#include <asm/uaccess.h>
25#include <asm/ptrace.h>
1da177e4
LT		 26#include <asm/pgtable.h>
27#include <asm/psrcompat.h>
28#include <asm/fpumacro.h>
29#include <asm/visasm.h>
14cc6aba 30#include <asm/compat_signal.h>
d550bbd4 31#include <asm/switch_to.h>
1da177e4 32
5598473a 33#include "sigutil.h"
abaff455 34#include "kernel.h"
5598473a 35
1da177e4
LT		 36/* This magic should be in g_upper[0] for all upper parts
37 * to be valid.
38 */
39#define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
40typedef struct {
41 unsigned int g_upper[8];
42 unsigned int o_upper[8];
43 unsigned int asi;
44} siginfo_extra_v8plus_t;
45
5526b7e4 46struct signal_frame32 {
1da177e4
LT		 47 struct sparc_stackf32 ss;
48 __siginfo32_t info;
5598473a 49 /* __siginfo_fpu_t * */ u32 fpu_save;
1da177e4
LT		 50 unsigned int insns[2];
51 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
52 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
53 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
54 siginfo_extra_v8plus_t v8plus;
5598473a
DM		 55 /* __siginfo_rwin_t * */u32 rwin_save;
56} __attribute__((aligned(8)));
1da177e4 57
1da177e4
LT		 58struct rt_signal_frame32 {
59 struct sparc_stackf32 ss;
60 compat_siginfo_t info;
61 struct pt_regs32 regs;
62 compat_sigset_t mask;
5598473a 63 /* __siginfo_fpu_t * */ u32 fpu_save;
1da177e4 64 unsigned int insns[2];
99b06feb 65 compat_stack_t stack;
1da177e4
LT		 66 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
67 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
68 siginfo_extra_v8plus_t v8plus;
5598473a
DM		 69 /* __siginfo_rwin_t * */u32 rwin_save;
70} __attribute__((aligned(8)));
1da177e4 71
ce395960 72int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
1da177e4
LT		 73{
74 int err;
75
76 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
77 return -EFAULT;
78
79 /* If you change siginfo_t structure, please be sure
80 this code is fixed accordingly.
81 It should never copy any pad contained in the structure
82 to avoid security leaks, but must copy the generic
83 3 ints plus the relevant union member.
84 This routine must convert siginfo from 64bit to 32bit as well
85 at the same time. */
86 err = __put_user(from->si_signo, &to->si_signo);
87 err |= __put_user(from->si_errno, &to->si_errno);
88 err |= __put_user((short)from->si_code, &to->si_code);
89 if (from->si_code < 0)
90 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
91 else {
92 switch (from->si_code >> 16) {
93 case __SI_TIMER >> 16:
94 err |= __put_user(from->si_tid, &to->si_tid);
95 err |= __put_user(from->si_overrun, &to->si_overrun);
96 err |= __put_user(from->si_int, &to->si_int);
97 break;
98 case __SI_CHLD >> 16:
99 err |= __put_user(from->si_utime, &to->si_utime);
100 err |= __put_user(from->si_stime, &to->si_stime);
101 err |= __put_user(from->si_status, &to->si_status);
102 default:
103 err |= __put_user(from->si_pid, &to->si_pid);
104 err |= __put_user(from->si_uid, &to->si_uid);
105 break;
106 case __SI_FAULT >> 16:
1da177e4
LT		 107 err |= __put_user(from->si_trapno, &to->si_trapno);
108 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
109 break;
9c7d3b3a
JS		 110 case __SI_POLL >> 16:
111 err |= __put_user(from->si_band, &to->si_band);
112 err |= __put_user(from->si_fd, &to->si_fd);
113 break;
1da177e4
LT		 114 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
115 case __SI_MESGQ >> 16:
116 err |= __put_user(from->si_pid, &to->si_pid);
117 err |= __put_user(from->si_uid, &to->si_uid);
118 err |= __put_user(from->si_int, &to->si_int);
119 break;
120 }
121 }
122 return err;
123}
124
125/* CAUTION: This is just a very minimalist implementation for the
126 * sake of compat_sys_rt_sigqueueinfo()
127 */
128int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
129{
130 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
131 return -EFAULT;
132
133 if (copy_from_user(to, from, 3*sizeof(int)) ||
134 copy_from_user(to->_sifields._pad, from->_sifields._pad,
135 SI_PAD_SIZE))
136 return -EFAULT;
137
138 return 0;
139}
140
5526b7e4 141void do_sigreturn32(struct pt_regs *regs)
1da177e4 142{
5526b7e4 143 struct signal_frame32 __user *sf;
5598473a
DM		 144 compat_uptr_t fpu_save;
145 compat_uptr_t rwin_save;
1da177e4 146 unsigned int psr;
5598473a 147 unsigned pc, npc;
1da177e4 148 sigset_t set;
c19ac326 149 compat_sigset_t seta;
1da177e4
LT		 150 int err, i;
151
5526b7e4
DM		 152 /* Always make any pending restarted system calls return -EINTR */
153 current_thread_info()->restart_block.fn = do_no_restart_syscall;
154
155 synchronize_user_stack();
156
1da177e4 157 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
5526b7e4 158 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
1da177e4
LT		 159
160 /* 1. Make sure we are not getting garbage from the user */
161 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
162 (((unsigned long) sf) & 3))
163 goto segv;
164
187cd44e
AV		 165 if (get_user(pc, &sf->info.si_regs.pc) ||
166 __get_user(npc, &sf->info.si_regs.npc))
167 goto segv;
1da177e4
LT		 168
169 if ((pc | npc) & 3)
170 goto segv;
171
172 if (test_thread_flag(TIF_32BIT)) {
173 pc &= 0xffffffff;
174 npc &= 0xffffffff;
175 }
176 regs->tpc = pc;
177 regs->tnpc = npc;
178
179 /* 2. Restore the state */
180 err = __get_user(regs->y, &sf->info.si_regs.y);
181 err |= __get_user(psr, &sf->info.si_regs.psr);
182
183 for (i = UREG_G1; i <= UREG_I7; i++)
184 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
185 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
186 err |= __get_user(i, &sf->v8plus.g_upper[0]);
187 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
188 unsigned long asi;
189
190 for (i = UREG_G1; i <= UREG_I7; i++)
191 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
192 err |= __get_user(asi, &sf->v8plus.asi);
193 regs->tstate &= ~TSTATE_ASI;
194 regs->tstate |= ((asi & 0xffUL) << 24UL);
195 }
196 }
197
198 /* User can only change condition codes in %tstate. */
199 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
200 regs->tstate |= psr_to_tstate_icc(psr);
201
2678fefe 202 /* Prevent syscall restart. */
28e61036 203 pt_regs_clear_syscall(regs);
2678fefe 204
1da177e4 205 err |= __get_user(fpu_save, &sf->fpu_save);
5598473a
DM		 206 if (!err && fpu_save)
207 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
208 err |= __get_user(rwin_save, &sf->rwin_save);
209 if (!err && rwin_save) {
210 if (restore_rwin_state(compat_ptr(rwin_save)))
211 goto segv;
212 }
c19ac326
SR		 213 err |= __get_user(seta.sig[0], &sf->info.si_mask);
214 err |= copy_from_user(&seta.sig[1], &sf->extramask,
1da177e4
LT		 215 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
216 if (err)
217 goto segv;
c19ac326
SR		 218
219 set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
faddf598 220 set_current_blocked(&set);
1da177e4
LT		 221 return;
222
223segv:
224 force_sig(SIGSEGV, current);
225}
226
1da177e4
LT		 227asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
228{
229 struct rt_signal_frame32 __user *sf;
99b06feb 230 unsigned int psr, pc, npc;
5598473a
DM		 231 compat_uptr_t fpu_save;
232 compat_uptr_t rwin_save;
1da177e4
LT		 233 sigset_t set;
234 compat_sigset_t seta;
1da177e4
LT		 235 int err, i;
236
237 /* Always make any pending restarted system calls return -EINTR */
238 current_thread_info()->restart_block.fn = do_no_restart_syscall;
239
240 synchronize_user_stack();
241 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
242 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
243
244 /* 1. Make sure we are not getting garbage from the user */
245 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
246 (((unsigned long) sf) & 3))
247 goto segv;
248
187cd44e
AV		 249 if (get_user(pc, &sf->regs.pc) ||
250 __get_user(npc, &sf->regs.npc))
251 goto segv;
1da177e4
LT		 252
253 if ((pc | npc) & 3)
254 goto segv;
255
256 if (test_thread_flag(TIF_32BIT)) {
257 pc &= 0xffffffff;
258 npc &= 0xffffffff;
259 }
260 regs->tpc = pc;
261 regs->tnpc = npc;
262
263 /* 2. Restore the state */
264 err = __get_user(regs->y, &sf->regs.y);
265 err |= __get_user(psr, &sf->regs.psr);
266
267 for (i = UREG_G1; i <= UREG_I7; i++)
268 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
269 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
270 err |= __get_user(i, &sf->v8plus.g_upper[0]);
271 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
272 unsigned long asi;
273
274 for (i = UREG_G1; i <= UREG_I7; i++)
275 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
276 err |= __get_user(asi, &sf->v8plus.asi);
277 regs->tstate &= ~TSTATE_ASI;
278 regs->tstate |= ((asi & 0xffUL) << 24UL);
279 }
280 }
281
282 /* User can only change condition codes in %tstate. */
283 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
284 regs->tstate |= psr_to_tstate_icc(psr);
285
2678fefe 286 /* Prevent syscall restart. */
28e61036 287 pt_regs_clear_syscall(regs);
2678fefe 288
1da177e4 289 err |= __get_user(fpu_save, &sf->fpu_save);
5598473a
DM		 290 if (!err && fpu_save)
291 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
1da177e4 292 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
99b06feb 293 err |= compat_restore_altstack(&sf->stack);
1da177e4
LT		 294 if (err)
295 goto segv;
296
5598473a
DM		 297 err |= __get_user(rwin_save, &sf->rwin_save);
298 if (!err && rwin_save) {
299 if (restore_rwin_state(compat_ptr(rwin_save)))
300 goto segv;
301 }
302
c19ac326 303 set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
faddf598 304 set_current_blocked(&set);
1da177e4
LT		 305 return;
306segv:
307 force_sig(SIGSEGV, current);
308}
309
310/* Checks if the fp is valid */
311static int invalid_frame_pointer(void __user *fp, int fplen)
312{
313 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
314 return 1;
315 return 0;
316}
317
08f73957 318static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
1da177e4
LT		 319{
320 unsigned long sp;
321
322 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
323 sp = regs->u_regs[UREG_FP];
324
dc5dc7e6
DM		 325 /*
326 * If we are on the alternate signal stack and would overflow it, don't.
327 * Return an always-bogus address instead so we will die with SIGSEGV.
328 */
329 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
330 return (void __user *) -1L;
331
1da177e4 332 /* This is the X/Open sanctioned signal stack switching. */
08f73957 333 sp = sigsp(sp, ksig) - framesize;
f036d9f3 334
dc5dc7e6
DM		 335 /* Always align the stack frame. This handles two cases. First,
336 * sigaltstack need not be mindful of platform specific stack
337 * alignment. Second, if we took this signal because the stack
338 * is not aligned properly, we'd like to take the signal cleanly
339 * and report that.
340 */
f036d9f3 341 sp &= ~15UL;
dc5dc7e6 342
f036d9f3 343 return (void __user *) sp;
1da177e4
LT		 344}
345
05c5e769
DM		 346/* The I-cache flush instruction only works in the primary ASI, which
347 * right now is the nucleus, aka. kernel space.
348 *
349 * Therefore we have to kick the instructions out using the kernel
350 * side linear mapping of the physical address backing the user
351 * instructions.
352 */
353static void flush_signal_insns(unsigned long address)
354{
355 unsigned long pstate, paddr;
356 pte_t *ptep, pte;
357 pgd_t *pgdp;
358 pud_t *pudp;
359 pmd_t *pmdp;
360
361 /* Commit all stores of the instructions we are about to flush. */
362 wmb();
363
364 /* Disable cross-call reception. In this way even a very wide
365 * munmap() on another cpu can't tear down the page table
366 * hierarchy from underneath us, since that can't complete
367 * until the IPI tlb flush returns.
368 */
369
370 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
371 __asm__ __volatile__("wrpr %0, %1, %%pstate"
372 : : "r" (pstate), "i" (PSTATE_IE));
373
374 pgdp = pgd_offset(current->mm, address);
375 if (pgd_none(*pgdp))
376 goto out_irqs_on;
377 pudp = pud_offset(pgdp, address);
378 if (pud_none(*pudp))
379 goto out_irqs_on;
380 pmdp = pmd_offset(pudp, address);
381 if (pmd_none(*pmdp))
382 goto out_irqs_on;
383
384 ptep = pte_offset_map(pmdp, address);
385 pte = *ptep;
386 if (!pte_present(pte))
387 goto out_unmap;
388
389 paddr = (unsigned long) page_address(pte_page(pte));
390
391 __asm__ __volatile__("flush %0 + %1"
392 : /* no outputs */
393 : "r" (paddr),
394 "r" (address & (PAGE_SIZE - 1))
395 : "memory");
396
397out_unmap:
398 pte_unmap(ptep);
399out_irqs_on:
400 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
401
402}
403
08f73957
AV		 404static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
405 sigset_t *oldset)
1da177e4 406{
5526b7e4 407 struct signal_frame32 __user *sf;
5598473a
DM		 408 int i, err, wsaved;
409 void __user *tail;
1da177e4
LT		 410 int sigframe_size;
411 u32 psr;
c19ac326 412 compat_sigset_t seta;
1da177e4
LT		 413
414 /* 1. Make sure everything is clean */
415 synchronize_user_stack();
416 save_and_clear_fpu();
417
5598473a
DM		 418 wsaved = get_thread_wsaved();
419
420 sigframe_size = sizeof(*sf);
421 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
422 sigframe_size += sizeof(__siginfo_fpu_t);
423 if (wsaved)
424 sigframe_size += sizeof(__siginfo_rwin_t);
1da177e4 425
5526b7e4 426 sf = (struct signal_frame32 __user *)
08f73957 427 get_sigframe(ksig, regs, sigframe_size);
1da177e4 428
08f73957
AV		 429 if (invalid_frame_pointer(sf, sigframe_size)) {
430 do_exit(SIGILL);
431 return -EINVAL;
432 }
1da177e4 433
5598473a 434 tail = (sf + 1);
1da177e4
LT		 435
436 /* 2. Save the current process state */
437 if (test_thread_flag(TIF_32BIT)) {
438 regs->tpc &= 0xffffffff;
439 regs->tnpc &= 0xffffffff;
440 }
441 err = put_user(regs->tpc, &sf->info.si_regs.pc);
442 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
443 err |= __put_user(regs->y, &sf->info.si_regs.y);
444 psr = tstate_to_psr(regs->tstate);
445 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
446 psr |= PSR_EF;
447 err |= __put_user(psr, &sf->info.si_regs.psr);
448 for (i = 0; i < 16; i++)
449 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
450 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
451 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
452 for (i = 1; i < 16; i++)
453 err |= __put_user(((u32 *)regs->u_regs)[2*i],
454 &sf->v8plus.g_upper[i]);
455 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
456 &sf->v8plus.asi);
457
458 if (psr & PSR_EF) {
5598473a
DM		 459 __siginfo_fpu_t __user *fp = tail;
460 tail += sizeof(*fp);
461 err |= save_fpu_state(regs, fp);
462 err |= __put_user((u64)fp, &sf->fpu_save);
1da177e4
LT		 463 } else {
464 err |= __put_user(0, &sf->fpu_save);
465 }
5598473a
DM		 466 if (wsaved) {
467 __siginfo_rwin_t __user *rwp = tail;
468 tail += sizeof(*rwp);
469 err |= save_rwin_state(wsaved, rwp);
470 err |= __put_user((u64)rwp, &sf->rwin_save);
471 set_thread_wsaved(0);
472 } else {
473 err |= __put_user(0, &sf->rwin_save);
474 }
1da177e4 475
c19ac326
SR		 476 /* If these change we need to know - assignments to seta relies on these sizes */
477 BUILD_BUG_ON(_NSIG_WORDS != 1);
478 BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
479 seta.sig[1] = (oldset->sig[0] >> 32);
480 seta.sig[0] = oldset->sig[0];
481
482 err |= __put_user(seta.sig[0], &sf->info.si_mask);
483 err |= __copy_to_user(sf->extramask, &seta.sig[1],
1da177e4
LT		 484 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
485
5598473a
DM		 486 if (!wsaved) {
487 err |= copy_in_user((u32 __user *)sf,
488 (u32 __user *)(regs->u_regs[UREG_FP]),
489 sizeof(struct reg_window32));
490 } else {
491 struct reg_window *rp;
492
493 rp = &current_thread_info()->reg_window[wsaved - 1];
494 for (i = 0; i < 8; i++)
495 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
496 for (i = 0; i < 6; i++)
497 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
498 err |= __put_user(rp->ins[6], &sf->ss.fp);
499 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
500 }
1da177e4 501 if (err)
08f73957 502 return err;
1da177e4
LT		 503
504 /* 3. signal handler back-trampoline and parameters */
505 regs->u_regs[UREG_FP] = (unsigned long) sf;
08f73957 506 regs->u_regs[UREG_I0] = ksig->sig;
1da177e4
LT		 507 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
508 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
509
510 /* 4. signal handler */
08f73957 511 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
1da177e4
LT		 512 regs->tnpc = (regs->tpc + 4);
513 if (test_thread_flag(TIF_32BIT)) {
514 regs->tpc &= 0xffffffff;
515 regs->tnpc &= 0xffffffff;
516 }
517
518 /* 5. return to kernel instructions */
08f73957
AV		 519 if (ksig->ka.ka_restorer) {
520 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
1da177e4 521 } else {
1da177e4 522 unsigned long address = ((unsigned long)&(sf->insns[0]));
1da177e4
LT		 523
524 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
525
526 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
527 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
528 if (err)
08f73957 529 return err;
05c5e769 530 flush_signal_insns(address);
1da177e4 531 }
c2785259 532 return 0;
1da177e4
LT		 533}
534
08f73957
AV		 535static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
536 sigset_t *oldset)
1da177e4
LT		 537{
538 struct rt_signal_frame32 __user *sf;
5598473a
DM		 539 int i, err, wsaved;
540 void __user *tail;
1da177e4
LT		 541 int sigframe_size;
542 u32 psr;
1da177e4
LT		 543 compat_sigset_t seta;
544
545 /* 1. Make sure everything is clean */
546 synchronize_user_stack();
547 save_and_clear_fpu();
548
5598473a
DM		 549 wsaved = get_thread_wsaved();
550
551 sigframe_size = sizeof(*sf);
552 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
553 sigframe_size += sizeof(__siginfo_fpu_t);
554 if (wsaved)
555 sigframe_size += sizeof(__siginfo_rwin_t);
1da177e4
LT		 556
557 sf = (struct rt_signal_frame32 __user *)
08f73957 558 get_sigframe(ksig, regs, sigframe_size);
1da177e4 559
08f73957
AV		 560 if (invalid_frame_pointer(sf, sigframe_size)) {
561 do_exit(SIGILL);
562 return -EINVAL;
563 }
1da177e4 564
5598473a 565 tail = (sf + 1);
1da177e4
LT		 566
567 /* 2. Save the current process state */
568 if (test_thread_flag(TIF_32BIT)) {
569 regs->tpc &= 0xffffffff;
570 regs->tnpc &= 0xffffffff;
571 }
572 err = put_user(regs->tpc, &sf->regs.pc);
573 err |= __put_user(regs->tnpc, &sf->regs.npc);
574 err |= __put_user(regs->y, &sf->regs.y);
575 psr = tstate_to_psr(regs->tstate);
576 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
577 psr |= PSR_EF;
578 err |= __put_user(psr, &sf->regs.psr);
579 for (i = 0; i < 16; i++)
580 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
581 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
582 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
583 for (i = 1; i < 16; i++)
584 err |= __put_user(((u32 *)regs->u_regs)[2*i],
585 &sf->v8plus.g_upper[i]);
586 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
587 &sf->v8plus.asi);
588
589 if (psr & PSR_EF) {
5598473a
DM		 590 __siginfo_fpu_t __user *fp = tail;
591 tail += sizeof(*fp);
592 err |= save_fpu_state(regs, fp);
593 err |= __put_user((u64)fp, &sf->fpu_save);
1da177e4
LT		 594 } else {
595 err |= __put_user(0, &sf->fpu_save);
596 }
5598473a
DM		 597 if (wsaved) {
598 __siginfo_rwin_t __user *rwp = tail;
599 tail += sizeof(*rwp);
600 err |= save_rwin_state(wsaved, rwp);
601 err |= __put_user((u64)rwp, &sf->rwin_save);
602 set_thread_wsaved(0);
603 } else {
604 err |= __put_user(0, &sf->rwin_save);
605 }
1da177e4
LT		 606
607 /* Update the siginfo structure. */
08f73957 608 err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
1da177e4
LT		 609
610 /* Setup sigaltstack */
99b06feb 611 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
1da177e4 612
c19ac326
SR		 613 seta.sig[1] = (oldset->sig[0] >> 32);
614 seta.sig[0] = oldset->sig[0];
1da177e4
LT		 615 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
616
5598473a
DM		 617 if (!wsaved) {
618 err |= copy_in_user((u32 __user *)sf,
619 (u32 __user *)(regs->u_regs[UREG_FP]),
620 sizeof(struct reg_window32));
621 } else {
622 struct reg_window *rp;
623
624 rp = &current_thread_info()->reg_window[wsaved - 1];
625 for (i = 0; i < 8; i++)
626 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
627 for (i = 0; i < 6; i++)
628 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
629 err |= __put_user(rp->ins[6], &sf->ss.fp);
630 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
631 }
1da177e4 632 if (err)
08f73957 633 return err;
1da177e4
LT		 634
635 /* 3. signal handler back-trampoline and parameters */
636 regs->u_regs[UREG_FP] = (unsigned long) sf;
08f73957 637 regs->u_regs[UREG_I0] = ksig->sig;
1da177e4
LT		 638 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
639 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
640
641 /* 4. signal handler */
08f73957 642 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
1da177e4
LT		 643 regs->tnpc = (regs->tpc + 4);
644 if (test_thread_flag(TIF_32BIT)) {
645 regs->tpc &= 0xffffffff;
646 regs->tnpc &= 0xffffffff;
647 }
648
649 /* 5. return to kernel instructions */
08f73957
AV		 650 if (ksig->ka.ka_restorer)
651 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
1da177e4 652 else {
1da177e4 653 unsigned long address = ((unsigned long)&(sf->insns[0]));
1da177e4
LT		 654
655 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
656
657 /* mov __NR_rt_sigreturn, %g1 */
658 err |= __put_user(0x82102065, &sf->insns[0]);
659
660 /* t 0x10 */
661 err |= __put_user(0x91d02010, &sf->insns[1]);
662 if (err)
08f73957 663 return err;
1da177e4 664
05c5e769 665 flush_signal_insns(address);
1da177e4 666 }
392c2180 667 return 0;
1da177e4
LT		 668}
669
08f73957
AV		 670static inline void handle_signal32(struct ksignal *ksig,
671 struct pt_regs *regs)
1da177e4 672{
08f73957 673 sigset_t *oldset = sigmask_to_save();
392c2180
DM		 674 int err;
675
08f73957
AV		 676 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
677 err = setup_rt_frame32(ksig, regs, oldset);
ec98c6b9 678 else
08f73957 679 err = setup_frame32(ksig, regs, oldset);
392c2180 680
08f73957 681 signal_setup_done(err, ksig, 0);
1da177e4
LT		 682}
683
684static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
685 struct sigaction *sa)
686{
687 switch (regs->u_regs[UREG_I0]) {
688 case ERESTART_RESTARTBLOCK:
689 case ERESTARTNOHAND:
690 no_system_call_restart:
691 regs->u_regs[UREG_I0] = EINTR;
692 regs->tstate |= TSTATE_ICARRY;
693 break;
694 case ERESTARTSYS:
695 if (!(sa->sa_flags & SA_RESTART))
696 goto no_system_call_restart;
697 /* fallthrough */
698 case ERESTARTNOINTR:
699 regs->u_regs[UREG_I0] = orig_i0;
700 regs->tpc -= 4;
701 regs->tnpc -= 4;
702 }
703}
704
705/* Note that 'init' is a special process: it doesn't get signals it doesn't
706 * want to handle. Thus you cannot kill init even with a SIGKILL even by
707 * mistake.
708 */
dfbb83d3 709void do_signal32(struct pt_regs * regs)
1da177e4 710{
08f73957
AV		 711 struct ksignal ksig;
712 unsigned long orig_i0 = 0;
713 int restart_syscall = 0;
714 bool has_handler = get_signal(&ksig);
28e61036 715
1d299bc7
DM		 716 if (pt_regs_is_syscall(regs) &&
717 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
718 restart_syscall = 1;
e88d2468 719 orig_i0 = regs->u_regs[UREG_G6];
1d299bc7 720 }
28e61036 721
08f73957 722 if (has_handler) {
28e61036 723 if (restart_syscall)
08f73957
AV		 724 syscall_restart32(orig_i0, regs, &ksig.ka.sa);
725 handle_signal32(&ksig, regs);
726 } else {
727 if (restart_syscall) {
728 switch (regs->u_regs[UREG_I0]) {
729 case ERESTARTNOHAND:
730 case ERESTARTSYS:
731 case ERESTARTNOINTR:
732 /* replay the system call when we are done */
733 regs->u_regs[UREG_I0] = orig_i0;
734 regs->tpc -= 4;
735 regs->tnpc -= 4;
736 pt_regs_clear_syscall(regs);
737 case ERESTART_RESTARTBLOCK:
738 regs->u_regs[UREG_G1] = __NR_restart_syscall;
739 regs->tpc -= 4;
740 regs->tnpc -= 4;
741 pt_regs_clear_syscall(regs);
742 }
743 }
744 restore_saved_sigmask();
1da177e4 745 }
1da177e4
LT		 746}
747
748struct sigstack32 {
749 u32 the_stack;
750 int cur_status;
751};
752
753asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
754{
755 struct sigstack32 __user *ssptr =
756 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
757 struct sigstack32 __user *ossptr =
758 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
759 int ret = -EFAULT;
760
761 /* First see if old state is wanted. */
762 if (ossptr) {
763 if (put_user(current->sas_ss_sp + current->sas_ss_size,
764 &ossptr->the_stack) ||
765 __put_user(on_sig_stack(sp), &ossptr->cur_status))
766 goto out;
767 }
768
769 /* Now see if we want to update the new state. */
770 if (ssptr) {
771 u32 ss_sp;
772
773 if (get_user(ss_sp, &ssptr->the_stack))
774 goto out;
775
776 /* If the current stack was set with sigaltstack, don't
777 * swap stacks while we are on it.
778 */
779 ret = -EPERM;
780 if (current->sas_ss_sp && on_sig_stack(sp))
781 goto out;
782
783 /* Since we don't know the extent of the stack, and we don't
784 * track onstack-ness, but rather calculate it, we must
785 * presume a size. Ho hum this interface is lossy.
786 */
787 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
788 current->sas_ss_size = SIGSTKSZ;
789 }
790
791 ret = 0;
792out:
793 return ret;
794}
Linux kernel - Deliverables
This page took 1.125957 seconds and 5 git commands to generate.