projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Support the MIPS32 / MIPS64 DSP ASE.
[linux-2.6-block.git] / arch / mips / kernel / signal32.c
CommitLineData
1da177e4
LT		 1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9 */
10#include <linux/sched.h>
11#include <linux/mm.h>
12#include <linux/smp.h>
13#include <linux/smp_lock.h>
14#include <linux/kernel.h>
15#include <linux/signal.h>
16#include <linux/syscalls.h>
17#include <linux/errno.h>
18#include <linux/wait.h>
19#include <linux/ptrace.h>
20#include <linux/compat.h>
21#include <linux/suspend.h>
22#include <linux/compiler.h>
23
e50c0a8f 24#include <asm/abi.h>
1da177e4
LT		 25#include <asm/asm.h>
26#include <linux/bitops.h>
27#include <asm/cacheflush.h>
28#include <asm/sim.h>
29#include <asm/uaccess.h>
30#include <asm/ucontext.h>
31#include <asm/system.h>
32#include <asm/fpu.h>
33
34#define SI_PAD_SIZE32 ((SI_MAX_SIZE/sizeof(int)) - 3)
35
36typedef struct compat_siginfo {
37 int si_signo;
38 int si_code;
39 int si_errno;
40
41 union {
42 int _pad[SI_PAD_SIZE32];
43
44 /* kill() */
45 struct {
46 compat_pid_t _pid; /* sender's pid */
47 compat_uid_t _uid; /* sender's uid */
48 } _kill;
49
50 /* SIGCHLD */
51 struct {
52 compat_pid_t _pid; /* which child */
53 compat_uid_t _uid; /* sender's uid */
54 int _status; /* exit code */
55 compat_clock_t _utime;
56 compat_clock_t _stime;
57 } _sigchld;
58
59 /* IRIX SIGCHLD */
60 struct {
61 compat_pid_t _pid; /* which child */
62 compat_clock_t _utime;
63 int _status; /* exit code */
64 compat_clock_t _stime;
65 } _irix_sigchld;
66
67 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
68 struct {
69 s32 _addr; /* faulting insn/memory ref. */
70 } _sigfault;
71
72 /* SIGPOLL, SIGXFSZ (To do ...) */
73 struct {
74 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
75 int _fd;
76 } _sigpoll;
77
78 /* POSIX.1b timers */
79 struct {
a982099c
RB		 80 timer_t _tid; /* timer id */
81 int _overrun; /* overrun count */
209ac8dd 82 compat_sigval_t _sigval;/* same as below */
a982099c 83 int _sys_private; /* not to be passed to user */
1da177e4
LT		 84 } _timer;
85
86 /* POSIX.1b signals */
87 struct {
88 compat_pid_t _pid; /* sender's pid */
89 compat_uid_t _uid; /* sender's uid */
90 compat_sigval_t _sigval;
91 } _rt;
92
93 } _sifields;
94} compat_siginfo_t;
95
96/*
97 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
98 */
99#define __NR_O32_sigreturn 4119
100#define __NR_O32_rt_sigreturn 4193
101#define __NR_O32_restart_syscall 4253
102
103#define DEBUG_SIG 0
104
105#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
106
107extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
108
109/* 32-bit compatibility types */
110
111#define _NSIG_BPW32 32
112#define _NSIG_WORDS32 (_NSIG / _NSIG_BPW32)
113
114typedef struct {
115 unsigned int sig[_NSIG_WORDS32];
116} sigset_t32;
117
118typedef unsigned int __sighandler32_t;
119typedef void (*vfptr_t)(void);
120
121struct sigaction32 {
122 unsigned int sa_flags;
123 __sighandler32_t sa_handler;
124 compat_sigset_t sa_mask;
125};
126
127/* IRIX compatible stack_t */
128typedef struct sigaltstack32 {
129 s32 ss_sp;
130 compat_size_t ss_size;
131 int ss_flags;
132} stack32_t;
133
134struct ucontext32 {
135 u32 uc_flags;
136 s32 uc_link;
137 stack32_t uc_stack;
138 struct sigcontext32 uc_mcontext;
139 sigset_t32 uc_sigmask; /* mask last for extensibility */
140};
141
142extern void __put_sigset_unknown_nsig(void);
143extern void __get_sigset_unknown_nsig(void);
144
145static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t *ubuf)
146{
147 int err = 0;
148
149 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
150 return -EFAULT;
151
152 switch (_NSIG_WORDS) {
153 default:
154 __put_sigset_unknown_nsig();
155 case 2:
156 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
157 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
158 case 1:
159 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
160 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
161 }
162
163 return err;
164}
165
166static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t *ubuf)
167{
168 int err = 0;
169 unsigned long sig[4];
170
171 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
172 return -EFAULT;
173
174 switch (_NSIG_WORDS) {
175 default:
176 __get_sigset_unknown_nsig();
177 case 2:
178 err |= __get_user (sig[3], &ubuf->sig[3]);
179 err |= __get_user (sig[2], &ubuf->sig[2]);
180 kbuf->sig[1] = sig[2] | (sig[3] << 32);
181 case 1:
182 err |= __get_user (sig[1], &ubuf->sig[1]);
183 err |= __get_user (sig[0], &ubuf->sig[0]);
184 kbuf->sig[0] = sig[0] | (sig[1] << 32);
185 }
186
187 return err;
188}
189
190/*
191 * Atomically swap in the new signal mask, and wait for a signal.
192 */
193
194save_static_function(sys32_sigsuspend);
195__attribute_used__ noinline static int
196_sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
197{
198 compat_sigset_t *uset;
199 sigset_t newset, saveset;
200
201 uset = (compat_sigset_t *) regs.regs[4];
202 if (get_sigset(&newset, uset))
203 return -EFAULT;
204 sigdelsetmask(&newset, ~_BLOCKABLE);
205
206 spin_lock_irq(&current->sighand->siglock);
207 saveset = current->blocked;
208 current->blocked = newset;
209 recalc_sigpending();
210 spin_unlock_irq(&current->sighand->siglock);
211
212 regs.regs[2] = EINTR;
213 regs.regs[7] = 1;
214 while (1) {
215 current->state = TASK_INTERRUPTIBLE;
216 schedule();
217 if (do_signal32(&saveset, &regs))
218 return -EINTR;
219 }
220}
221
222save_static_function(sys32_rt_sigsuspend);
223__attribute_used__ noinline static int
224_sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
225{
226 compat_sigset_t *uset;
227 sigset_t newset, saveset;
228 size_t sigsetsize;
229
230 /* XXX Don't preclude handling different sized sigset_t's. */
231 sigsetsize = regs.regs[5];
232 if (sigsetsize != sizeof(compat_sigset_t))
233 return -EINVAL;
234
235 uset = (compat_sigset_t *) regs.regs[4];
236 if (get_sigset(&newset, uset))
237 return -EFAULT;
238 sigdelsetmask(&newset, ~_BLOCKABLE);
239
240 spin_lock_irq(&current->sighand->siglock);
241 saveset = current->blocked;
242 current->blocked = newset;
243 recalc_sigpending();
244 spin_unlock_irq(&current->sighand->siglock);
245
246 regs.regs[2] = EINTR;
247 regs.regs[7] = 1;
248 while (1) {
249 current->state = TASK_INTERRUPTIBLE;
250 schedule();
251 if (do_signal32(&saveset, &regs))
252 return -EINTR;
253 }
254}
255
256asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
257 struct sigaction32 *oact)
258{
259 struct k_sigaction new_ka, old_ka;
260 int ret;
261 int err = 0;
262
263 if (act) {
264 old_sigset_t mask;
77c728c2 265 s32 handler;
1da177e4
LT		 266
267 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
268 return -EFAULT;
77c728c2
RB		 269 err |= __get_user(handler, &act->sa_handler);
270 new_ka.sa.sa_handler = (void*)(s64)handler;
1da177e4
LT		 271 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
272 err |= __get_user(mask, &act->sa_mask.sig[0]);
273 if (err)
274 return -EFAULT;
275
276 siginitset(&new_ka.sa.sa_mask, mask);
277 }
278
279 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
280
281 if (!ret && oact) {
282 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
283 return -EFAULT;
284 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
285 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
286 &oact->sa_handler);
287 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
288 err |= __put_user(0, &oact->sa_mask.sig[1]);
289 err |= __put_user(0, &oact->sa_mask.sig[2]);
290 err |= __put_user(0, &oact->sa_mask.sig[3]);
291 if (err)
292 return -EFAULT;
293 }
294
295 return ret;
296}
297
298asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
299{
300 const stack32_t *uss = (const stack32_t *) regs.regs[4];
301 stack32_t *uoss = (stack32_t *) regs.regs[5];
302 unsigned long usp = regs.regs[29];
303 stack_t kss, koss;
304 int ret, err = 0;
305 mm_segment_t old_fs = get_fs();
306 s32 sp;
307
308 if (uss) {
309 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
310 return -EFAULT;
311 err |= __get_user(sp, &uss->ss_sp);
312 kss.ss_sp = (void *) (long) sp;
313 err |= __get_user(kss.ss_size, &uss->ss_size);
314 err |= __get_user(kss.ss_flags, &uss->ss_flags);
315 if (err)
316 return -EFAULT;
317 }
318
319 set_fs (KERNEL_DS);
320 ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, usp);
321 set_fs (old_fs);
322
323 if (!ret && uoss) {
324 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
325 return -EFAULT;
326 sp = (int) (long) koss.ss_sp;
327 err |= __put_user(sp, &uoss->ss_sp);
328 err |= __put_user(koss.ss_size, &uoss->ss_size);
329 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
330 if (err)
331 return -EFAULT;
332 }
333 return ret;
334}
335
336static int restore_sigcontext32(struct pt_regs *regs, struct sigcontext32 *sc)
337{
e50c0a8f 338 u32 used_math;
1da177e4 339 int err = 0;
e50c0a8f 340 s32 treg;
1da177e4
LT		 341
342 /* Always make any pending restarted system calls return -EINTR */
343 current_thread_info()->restart_block.fn = do_no_restart_syscall;
344
345 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
346 err |= __get_user(regs->hi, &sc->sc_mdhi);
347 err |= __get_user(regs->lo, &sc->sc_mdlo);
e50c0a8f
RB		 348 if (cpu_has_dsp) {
349 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
350 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
351 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
352 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
353 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
354 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
355 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
356 }
1da177e4
LT		 357
358#define restore_gp_reg(i) do { \
359 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); \
360} while(0)
361 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
362 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
363 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
364 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
365 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
366 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
367 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
368 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
369 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
370 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
371 restore_gp_reg(31);
372#undef restore_gp_reg
373
374 err |= __get_user(used_math, &sc->sc_used_math);
375 conditional_used_math(used_math);
376
377 preempt_disable();
378
379 if (used_math()) {
380 /* restore fpu context if we have used it before */
381 own_fpu();
382 err |= restore_fp_context32(sc);
383 } else {
384 /* signal handler may have used FPU. Give it up. */
385 lose_fpu();
386 }
387
388 preempt_enable();
389
390 return err;
391}
392
393struct sigframe {
394 u32 sf_ass[4]; /* argument save space for o32 */
395 u32 sf_code[2]; /* signal trampoline */
396 struct sigcontext32 sf_sc;
397 sigset_t sf_mask;
398};
399
400struct rt_sigframe32 {
401 u32 rs_ass[4]; /* argument save space for o32 */
402 u32 rs_code[2]; /* signal trampoline */
403 compat_siginfo_t rs_info;
404 struct ucontext32 rs_uc;
405};
406
407int copy_siginfo_to_user32(compat_siginfo_t *to, siginfo_t *from)
408{
409 int err;
410
411 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
412 return -EFAULT;
413
414 /* If you change siginfo_t structure, please be sure
415 this code is fixed accordingly.
416 It should never copy any pad contained in the structure
417 to avoid security leaks, but must copy the generic
418 3 ints plus the relevant union member.
419 This routine must convert siginfo from 64bit to 32bit as well
420 at the same time. */
421 err = __put_user(from->si_signo, &to->si_signo);
422 err |= __put_user(from->si_errno, &to->si_errno);
423 err |= __put_user((short)from->si_code, &to->si_code);
424 if (from->si_code < 0)
425 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
426 else {
427 switch (from->si_code >> 16) {
a982099c
RB		 428 case __SI_TIMER >> 16:
429 err |= __put_user(from->si_tid, &to->si_tid);
430 err |= __put_user(from->si_overrun, &to->si_overrun);
431 err |= __put_user(from->si_int, &to->si_int);
432 break;
1da177e4
LT		 433 case __SI_CHLD >> 16:
434 err |= __put_user(from->si_utime, &to->si_utime);
435 err |= __put_user(from->si_stime, &to->si_stime);
436 err |= __put_user(from->si_status, &to->si_status);
437 default:
438 err |= __put_user(from->si_pid, &to->si_pid);
439 err |= __put_user(from->si_uid, &to->si_uid);
440 break;
441 case __SI_FAULT >> 16:
442 err |= __put_user((long)from->si_addr, &to->si_addr);
443 break;
444 case __SI_POLL >> 16:
445 err |= __put_user(from->si_band, &to->si_band);
446 err |= __put_user(from->si_fd, &to->si_fd);
447 break;
448 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
449 case __SI_MESGQ >> 16:
450 err |= __put_user(from->si_pid, &to->si_pid);
451 err |= __put_user(from->si_uid, &to->si_uid);
452 err |= __put_user(from->si_int, &to->si_int);
453 break;
454 }
455 }
456 return err;
457}
458
459save_static_function(sys32_sigreturn);
460__attribute_used__ noinline static void
461_sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
462{
463 struct sigframe *frame;
464 sigset_t blocked;
465
466 frame = (struct sigframe *) regs.regs[29];
467 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
468 goto badframe;
469 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
470 goto badframe;
471
472 sigdelsetmask(&blocked, ~_BLOCKABLE);
473 spin_lock_irq(&current->sighand->siglock);
474 current->blocked = blocked;
475 recalc_sigpending();
476 spin_unlock_irq(&current->sighand->siglock);
477
478 if (restore_sigcontext32(&regs, &frame->sf_sc))
479 goto badframe;
480
481 /*
482 * Don't let your children do this ...
483 */
484 if (current_thread_info()->flags & TIF_SYSCALL_TRACE)
485 do_syscall_trace(&regs, 1);
486 __asm__ __volatile__(
487 "move\t$29, %0\n\t"
488 "j\tsyscall_exit"
489 :/* no outputs */
490 :"r" (&regs));
491 /* Unreached */
492
493badframe:
494 force_sig(SIGSEGV, current);
495}
496
497save_static_function(sys32_rt_sigreturn);
498__attribute_used__ noinline static void
499_sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
500{
501 struct rt_sigframe32 *frame;
1fcf1cc7 502 mm_segment_t old_fs;
1da177e4
LT		 503 sigset_t set;
504 stack_t st;
505 s32 sp;
506
507 frame = (struct rt_sigframe32 *) regs.regs[29];
508 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
509 goto badframe;
510 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
511 goto badframe;
512
513 sigdelsetmask(&set, ~_BLOCKABLE);
514 spin_lock_irq(&current->sighand->siglock);
515 current->blocked = set;
516 recalc_sigpending();
517 spin_unlock_irq(&current->sighand->siglock);
518
519 if (restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext))
520 goto badframe;
521
522 /* The ucontext contains a stack32_t, so we must convert! */
523 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
524 goto badframe;
525 st.ss_size = (long) sp;
526 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
527 goto badframe;
528 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
529 goto badframe;
530
531 /* It is more difficult to avoid calling this function than to
532 call it and ignore errors. */
1fcf1cc7
RB		 533 old_fs = get_fs();
534 set_fs (KERNEL_DS);
1da177e4 535 do_sigaltstack(&st, NULL, regs.regs[29]);
1fcf1cc7 536 set_fs (old_fs);
1da177e4
LT		 537
538 /*
539 * Don't let your children do this ...
540 */
541 __asm__ __volatile__(
542 "move\t$29, %0\n\t"
543 "j\tsyscall_exit"
544 :/* no outputs */
545 :"r" (&regs));
546 /* Unreached */
547
548badframe:
549 force_sig(SIGSEGV, current);
550}
551
552static inline int setup_sigcontext32(struct pt_regs *regs,
553 struct sigcontext32 *sc)
554{
555 int err = 0;
556
557 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
558 err |= __put_user(regs->cp0_status, &sc->sc_status);
559
560#define save_gp_reg(i) { \
561 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); \
562} while(0)
563 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
564 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
565 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
566 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
567 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
568 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
569 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
570 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
571 save_gp_reg(31);
572#undef save_gp_reg
573
574 err |= __put_user(regs->hi, &sc->sc_mdhi);
575 err |= __put_user(regs->lo, &sc->sc_mdlo);
e50c0a8f
RB		 576 if (cpu_has_dsp) {
577 err |= __put_user(rddsp(DSP_MASK), &sc->sc_hi1);
578 err |= __put_user(mfhi1(), &sc->sc_hi1);
579 err |= __put_user(mflo1(), &sc->sc_lo1);
580 err |= __put_user(mfhi2(), &sc->sc_hi2);
581 err |= __put_user(mflo2(), &sc->sc_lo2);
582 err |= __put_user(mfhi3(), &sc->sc_hi3);
583 err |= __put_user(mflo3(), &sc->sc_lo3);
584 }
1da177e4
LT		 585
586 err |= __put_user(!!used_math(), &sc->sc_used_math);
587
588 if (!used_math())
589 goto out;
590
42a3b4f2 591 /*
1da177e4
LT		 592 * Save FPU state to signal context. Signal handler will "inherit"
593 * current FPU state.
594 */
595 preempt_disable();
596
597 if (!is_fpu_owner()) {
598 own_fpu();
599 restore_fp(current);
600 }
601 err |= save_fp_context32(sc);
602
603 preempt_enable();
604
605out:
606 return err;
607}
608
609/*
610 * Determine which stack to use..
611 */
612static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
613 size_t frame_size)
614{
615 unsigned long sp;
616
617 /* Default to using normal stack */
618 sp = regs->regs[29];
619
620 /*
621 * FPU emulator may have it's own trampoline active just
622 * above the user stack, 16-bytes before the next lowest
623 * 16 byte boundary. Try to avoid trashing it.
624 */
625 sp -= 32;
626
627 /* This is the X/Open sanctioned signal stack switching. */
628 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
629 sp = current->sas_ss_sp + current->sas_ss_size;
630
631 return (void *)((sp - frame_size) & ALMASK);
632}
633
e50c0a8f 634void setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
1da177e4
LT		 635 int signr, sigset_t *set)
636{
637 struct sigframe *frame;
638 int err = 0;
639
640 frame = get_sigframe(ka, regs, sizeof(*frame));
641 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
642 goto give_sigsegv;
643
644 /*
645 * Set up the return code ...
646 *
647 * li v0, __NR_O32_sigreturn
648 * syscall
649 */
650 err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
651 err |= __put_user(0x0000000c , frame->sf_code + 1);
652 flush_cache_sigtramp((unsigned long) frame->sf_code);
653
654 err |= setup_sigcontext32(regs, &frame->sf_sc);
655 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
656 if (err)
657 goto give_sigsegv;
658
659 /*
660 * Arguments to signal handler:
661 *
662 * a0 = signal number
663 * a1 = 0 (should be cause)
664 * a2 = pointer to struct sigcontext
665 *
666 * $25 and c0_epc point to the signal handler, $29 points to the
667 * struct sigframe.
668 */
669 regs->regs[ 4] = signr;
670 regs->regs[ 5] = 0;
671 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
672 regs->regs[29] = (unsigned long) frame;
673 regs->regs[31] = (unsigned long) frame->sf_code;
674 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
675
676#if DEBUG_SIG
677 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
678 current->comm, current->pid,
679 frame, regs->cp0_epc, frame->sf_code);
680#endif
681 return;
682
683give_sigsegv:
684 force_sigsegv(signr, current);
685}
686
e50c0a8f 687void setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs, int signr, sigset_t *set, siginfo_t *info)
1da177e4
LT		 688{
689 struct rt_sigframe32 *frame;
690 int err = 0;
691 s32 sp;
692
693 frame = get_sigframe(ka, regs, sizeof(*frame));
694 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
695 goto give_sigsegv;
696
697 /* Set up to return from userspace. If provided, use a stub already
698 in userspace. */
699 /*
700 * Set up the return code ...
701 *
702 * li v0, __NR_O32_rt_sigreturn
703 * syscall
704 */
705 err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
706 err |= __put_user(0x0000000c , frame->rs_code + 1);
707 flush_cache_sigtramp((unsigned long) frame->rs_code);
708
709 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
710 err |= copy_siginfo_to_user32(&frame->rs_info, info);
711
712 /* Create the ucontext. */
713 err |= __put_user(0, &frame->rs_uc.uc_flags);
714 err |= __put_user(0, &frame->rs_uc.uc_link);
715 sp = (int) (long) current->sas_ss_sp;
716 err |= __put_user(sp,
717 &frame->rs_uc.uc_stack.ss_sp);
718 err |= __put_user(sas_ss_flags(regs->regs[29]),
719 &frame->rs_uc.uc_stack.ss_flags);
720 err |= __put_user(current->sas_ss_size,
721 &frame->rs_uc.uc_stack.ss_size);
722 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
723 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
724
725 if (err)
726 goto give_sigsegv;
727
728 /*
729 * Arguments to signal handler:
730 *
731 * a0 = signal number
732 * a1 = 0 (should be cause)
733 * a2 = pointer to ucontext
734 *
735 * $25 and c0_epc point to the signal handler, $29 points to
736 * the struct rt_sigframe32.
737 */
738 regs->regs[ 4] = signr;
739 regs->regs[ 5] = (unsigned long) &frame->rs_info;
740 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
741 regs->regs[29] = (unsigned long) frame;
742 regs->regs[31] = (unsigned long) frame->rs_code;
743 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
744
745#if DEBUG_SIG
746 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
747 current->comm, current->pid,
748 frame, regs->cp0_epc, frame->rs_code);
749#endif
750 return;
751
752give_sigsegv:
753 force_sigsegv(signr, current);
754}
755
756static inline void handle_signal(unsigned long sig, siginfo_t *info,
757 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
758{
759 switch (regs->regs[0]) {
760 case ERESTART_RESTARTBLOCK:
761 case ERESTARTNOHAND:
762 regs->regs[2] = EINTR;
763 break;
764 case ERESTARTSYS:
765 if(!(ka->sa.sa_flags & SA_RESTART)) {
766 regs->regs[2] = EINTR;
767 break;
768 }
769 /* fallthrough */
770 case ERESTARTNOINTR: /* Userland will reload $v0. */
771 regs->regs[7] = regs->regs[26];
772 regs->cp0_epc -= 8;
773 }
774
775 regs->regs[0] = 0; /* Don't deal with this again. */
776
777 if (ka->sa.sa_flags & SA_SIGINFO)
e50c0a8f 778 current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info);
1da177e4 779 else
e50c0a8f 780 current->thread.abi->setup_frame(ka, regs, sig, oldset);
1da177e4 781
69be8f18
SR		 782 spin_lock_irq(&current->sighand->siglock);
783 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
784 if (!(ka->sa.sa_flags & SA_NODEFER))
1da177e4 785 sigaddset(&current->blocked,sig);
69be8f18
SR		 786 recalc_sigpending();
787 spin_unlock_irq(&current->sighand->siglock);
1da177e4
LT		 788}
789
790int do_signal32(sigset_t *oldset, struct pt_regs *regs)
791{
792 struct k_sigaction ka;
793 siginfo_t info;
794 int signr;
795
796 /*
797 * We want the common case to go fast, which is why we may in certain
798 * cases get here from kernel mode. Just return without doing anything
799 * if so.
800 */
801 if (!user_mode(regs))
802 return 1;
803
0e6c1f5f 804 if (try_to_freeze())
1da177e4
LT		 805 goto no_signal;
806
807 if (!oldset)
808 oldset = &current->blocked;
809
810 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
811 if (signr > 0) {
812 handle_signal(signr, &info, &ka, oldset, regs);
813 return 1;
814 }
815
816no_signal:
817 /*
818 * Who's code doesn't conform to the restartable syscall convention
819 * dies here!!! The li instruction, a single machine instruction,
820 * must directly be followed by the syscall instruction.
821 */
822 if (regs->regs[0]) {
823 if (regs->regs[2] == ERESTARTNOHAND ||
824 regs->regs[2] == ERESTARTSYS ||
825 regs->regs[2] == ERESTARTNOINTR) {
826 regs->regs[7] = regs->regs[26];
827 regs->cp0_epc -= 8;
828 }
829 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
830 regs->regs[2] = __NR_O32_restart_syscall;
831 regs->regs[7] = regs->regs[26];
832 regs->cp0_epc -= 4;
833 }
834 }
835 return 0;
836}
837
838asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
839 struct sigaction32 *oact,
840 unsigned int sigsetsize)
841{
842 struct k_sigaction new_sa, old_sa;
843 int ret = -EINVAL;
844
845 /* XXX: Don't preclude handling different sized sigset_t's. */
846 if (sigsetsize != sizeof(sigset_t))
847 goto out;
848
849 if (act) {
77c728c2 850 s32 handler;
1da177e4
LT		 851 int err = 0;
852
853 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
854 return -EFAULT;
77c728c2
RB		 855 err |= __get_user(handler, &act->sa_handler);
856 new_sa.sa.sa_handler = (void*)(s64)handler;
1da177e4
LT		 857 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
858 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
859 if (err)
860 return -EFAULT;
861 }
862
863 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
864
865 if (!ret && oact) {
866 int err = 0;
867
868 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
869 return -EFAULT;
870
871 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
872 &oact->sa_handler);
873 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
874 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
875 if (err)
876 return -EFAULT;
877 }
878out:
879 return ret;
880}
881
882asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
883 compat_sigset_t *oset, unsigned int sigsetsize)
884{
885 sigset_t old_set, new_set;
886 int ret;
887 mm_segment_t old_fs = get_fs();
888
889 if (set && get_sigset(&new_set, set))
890 return -EFAULT;
891
892 set_fs (KERNEL_DS);
893 ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
894 oset ? &old_set : NULL, sigsetsize);
895 set_fs (old_fs);
896
897 if (!ret && oset && put_sigset(&old_set, oset))
898 return -EFAULT;
899
900 return ret;
901}
902
903asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
904 unsigned int sigsetsize)
905{
906 int ret;
907 sigset_t set;
908 mm_segment_t old_fs = get_fs();
909
910 set_fs (KERNEL_DS);
911 ret = sys_rt_sigpending(&set, sigsetsize);
912 set_fs (old_fs);
913
914 if (!ret && put_sigset(&set, uset))
915 return -EFAULT;
916
917 return ret;
918}
919
920asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t *uinfo)
921{
922 siginfo_t info;
923 int ret;
924 mm_segment_t old_fs = get_fs();
925
926 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
927 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
928 return -EFAULT;
929 set_fs (KERNEL_DS);
930 ret = sys_rt_sigqueueinfo(pid, sig, &info);
931 set_fs (old_fs);
932 return ret;
933}
54f2da75
RB		 934
935asmlinkage long
936sys32_waitid(int which, compat_pid_t pid,
937 compat_siginfo_t __user *uinfo, int options,
938 struct compat_rusage __user *uru)
939{
940 siginfo_t info;
941 struct rusage ru;
942 long ret;
943 mm_segment_t old_fs = get_fs();
944
945 info.si_signo = 0;
946 set_fs (KERNEL_DS);
947 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
948 uru ? (struct rusage __user *) &ru : NULL);
949 set_fs (old_fs);
950
951 if (ret < 0 || info.si_signo == 0)
952 return ret;
953
954 if (uru && (ret = put_compat_rusage(&ru, uru)))
955 return ret;
956
957 BUG_ON(info.si_code & __SI_MASK);
958 info.si_code |= __SI_CHLD;
959 return copy_siginfo_to_user32(uinfo, &info);
960}
Linux 6.x block layer and io_uring tree(s)