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