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
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000, 2006 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
10 #include <linux/cache.h>
11 #include <linux/compat.h>
12 #include <linux/sched.h>
14 #include <linux/smp.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/syscalls.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/ptrace.h>
21 #include <linux/suspend.h>
22 #include <linux/compiler.h>
23 #include <linux/uaccess.h>
27 #include <asm/compat-signal.h>
28 #include <linux/bitops.h>
29 #include <asm/cacheflush.h>
31 #include <asm/ucontext.h>
32 #include <asm/system.h>
37 #include "signal-common.h"
39 static int (*save_fp_context32
)(struct sigcontext32 __user
*sc
);
40 static int (*restore_fp_context32
)(struct sigcontext32 __user
*sc
);
42 extern asmlinkage
int _save_fp_context32(struct sigcontext32 __user
*sc
);
43 extern asmlinkage
int _restore_fp_context32(struct sigcontext32 __user
*sc
);
45 extern asmlinkage
int fpu_emulator_save_context32(struct sigcontext32 __user
*sc
);
46 extern asmlinkage
int fpu_emulator_restore_context32(struct sigcontext32 __user
*sc
);
49 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
51 #define __NR_O32_restart_syscall 4253
53 /* 32-bit compatibility types */
55 typedef unsigned int __sighandler32_t
;
56 typedef void (*vfptr_t
)(void);
59 unsigned int sa_flags
;
60 __sighandler32_t sa_handler
;
61 compat_sigset_t sa_mask
;
64 /* IRIX compatible stack_t */
65 typedef struct sigaltstack32
{
67 compat_size_t ss_size
;
75 struct sigcontext32 uc_mcontext
;
76 compat_sigset_t uc_sigmask
; /* mask last for extensibility */
80 u32 sf_ass
[4]; /* argument save space for o32 */
81 u32 sf_pad
[2]; /* Was: signal trampoline */
82 struct sigcontext32 sf_sc
;
83 compat_sigset_t sf_mask
;
86 struct rt_sigframe32
{
87 u32 rs_ass
[4]; /* argument save space for o32 */
88 u32 rs_pad
[2]; /* Was: signal trampoline */
89 compat_siginfo_t rs_info
;
90 struct ucontext32 rs_uc
;
96 static int protected_save_fp_context32(struct sigcontext32 __user
*sc
)
102 err
= save_fp_context32(sc
); /* this might fail */
106 /* touch the sigcontext and try again */
107 err
= __put_user(0, &sc
->sc_fpregs
[0]) |
108 __put_user(0, &sc
->sc_fpregs
[31]) |
109 __put_user(0, &sc
->sc_fpc_csr
);
111 break; /* really bad sigcontext */
116 static int protected_restore_fp_context32(struct sigcontext32 __user
*sc
)
118 int err
, tmp __maybe_unused
;
122 err
= restore_fp_context32(sc
); /* this might fail */
126 /* touch the sigcontext and try again */
127 err
= __get_user(tmp
, &sc
->sc_fpregs
[0]) |
128 __get_user(tmp
, &sc
->sc_fpregs
[31]) |
129 __get_user(tmp
, &sc
->sc_fpc_csr
);
131 break; /* really bad sigcontext */
136 static int setup_sigcontext32(struct pt_regs
*regs
,
137 struct sigcontext32 __user
*sc
)
143 err
|= __put_user(regs
->cp0_epc
, &sc
->sc_pc
);
145 err
|= __put_user(0, &sc
->sc_regs
[0]);
146 for (i
= 1; i
< 32; i
++)
147 err
|= __put_user(regs
->regs
[i
], &sc
->sc_regs
[i
]);
149 err
|= __put_user(regs
->hi
, &sc
->sc_mdhi
);
150 err
|= __put_user(regs
->lo
, &sc
->sc_mdlo
);
152 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
153 err
|= __put_user(mfhi1(), &sc
->sc_hi1
);
154 err
|= __put_user(mflo1(), &sc
->sc_lo1
);
155 err
|= __put_user(mfhi2(), &sc
->sc_hi2
);
156 err
|= __put_user(mflo2(), &sc
->sc_lo2
);
157 err
|= __put_user(mfhi3(), &sc
->sc_hi3
);
158 err
|= __put_user(mflo3(), &sc
->sc_lo3
);
161 used_math
= !!used_math();
162 err
|= __put_user(used_math
, &sc
->sc_used_math
);
166 * Save FPU state to signal context. Signal handler
167 * will "inherit" current FPU state.
169 err
|= protected_save_fp_context32(sc
);
175 check_and_restore_fp_context32(struct sigcontext32 __user
*sc
)
179 err
= sig
= fpcsr_pending(&sc
->sc_fpc_csr
);
182 err
|= protected_restore_fp_context32(sc
);
186 static int restore_sigcontext32(struct pt_regs
*regs
,
187 struct sigcontext32 __user
*sc
)
194 /* Always make any pending restarted system calls return -EINTR */
195 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
197 err
|= __get_user(regs
->cp0_epc
, &sc
->sc_pc
);
198 err
|= __get_user(regs
->hi
, &sc
->sc_mdhi
);
199 err
|= __get_user(regs
->lo
, &sc
->sc_mdlo
);
201 err
|= __get_user(treg
, &sc
->sc_hi1
); mthi1(treg
);
202 err
|= __get_user(treg
, &sc
->sc_lo1
); mtlo1(treg
);
203 err
|= __get_user(treg
, &sc
->sc_hi2
); mthi2(treg
);
204 err
|= __get_user(treg
, &sc
->sc_lo2
); mtlo2(treg
);
205 err
|= __get_user(treg
, &sc
->sc_hi3
); mthi3(treg
);
206 err
|= __get_user(treg
, &sc
->sc_lo3
); mtlo3(treg
);
207 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
210 for (i
= 1; i
< 32; i
++)
211 err
|= __get_user(regs
->regs
[i
], &sc
->sc_regs
[i
]);
213 err
|= __get_user(used_math
, &sc
->sc_used_math
);
214 conditional_used_math(used_math
);
217 /* restore fpu context if we have used it before */
219 err
= check_and_restore_fp_context32(sc
);
221 /* signal handler may have used FPU. Give it up. */
231 extern void __put_sigset_unknown_nsig(void);
232 extern void __get_sigset_unknown_nsig(void);
234 static inline int put_sigset(const sigset_t
*kbuf
, compat_sigset_t __user
*ubuf
)
238 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(*ubuf
)))
241 switch (_NSIG_WORDS
) {
243 __put_sigset_unknown_nsig();
245 err
|= __put_user(kbuf
->sig
[1] >> 32, &ubuf
->sig
[3]);
246 err
|= __put_user(kbuf
->sig
[1] & 0xffffffff, &ubuf
->sig
[2]);
248 err
|= __put_user(kbuf
->sig
[0] >> 32, &ubuf
->sig
[1]);
249 err
|= __put_user(kbuf
->sig
[0] & 0xffffffff, &ubuf
->sig
[0]);
255 static inline int get_sigset(sigset_t
*kbuf
, const compat_sigset_t __user
*ubuf
)
258 unsigned long sig
[4];
260 if (!access_ok(VERIFY_READ
, ubuf
, sizeof(*ubuf
)))
263 switch (_NSIG_WORDS
) {
265 __get_sigset_unknown_nsig();
267 err
|= __get_user(sig
[3], &ubuf
->sig
[3]);
268 err
|= __get_user(sig
[2], &ubuf
->sig
[2]);
269 kbuf
->sig
[1] = sig
[2] | (sig
[3] << 32);
271 err
|= __get_user(sig
[1], &ubuf
->sig
[1]);
272 err
|= __get_user(sig
[0], &ubuf
->sig
[0]);
273 kbuf
->sig
[0] = sig
[0] | (sig
[1] << 32);
280 * Atomically swap in the new signal mask, and wait for a signal.
283 asmlinkage
int sys32_sigsuspend(nabi_no_regargs
struct pt_regs regs
)
285 compat_sigset_t __user
*uset
;
288 uset
= (compat_sigset_t __user
*) regs
.regs
[4];
289 if (get_sigset(&newset
, uset
))
291 sigdelsetmask(&newset
, ~_BLOCKABLE
);
293 spin_lock_irq(¤t
->sighand
->siglock
);
294 current
->saved_sigmask
= current
->blocked
;
295 current
->blocked
= newset
;
297 spin_unlock_irq(¤t
->sighand
->siglock
);
299 current
->state
= TASK_INTERRUPTIBLE
;
301 set_thread_flag(TIF_RESTORE_SIGMASK
);
302 return -ERESTARTNOHAND
;
305 asmlinkage
int sys32_rt_sigsuspend(nabi_no_regargs
struct pt_regs regs
)
307 compat_sigset_t __user
*uset
;
311 sigsetsize
= regs
.regs
[5];
312 if (sigsetsize
!= sizeof(compat_sigset_t
))
315 uset
= (compat_sigset_t __user
*) regs
.regs
[4];
316 if (get_sigset(&newset
, uset
))
318 sigdelsetmask(&newset
, ~_BLOCKABLE
);
320 spin_lock_irq(¤t
->sighand
->siglock
);
321 current
->saved_sigmask
= current
->blocked
;
322 current
->blocked
= newset
;
324 spin_unlock_irq(¤t
->sighand
->siglock
);
326 current
->state
= TASK_INTERRUPTIBLE
;
328 set_thread_flag(TIF_RESTORE_SIGMASK
);
329 return -ERESTARTNOHAND
;
332 SYSCALL_DEFINE3(32_sigaction
, long, sig
, const struct sigaction32 __user
*, act
,
333 struct sigaction32 __user
*, oact
)
335 struct k_sigaction new_ka
, old_ka
;
343 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)))
345 err
|= __get_user(handler
, &act
->sa_handler
);
346 new_ka
.sa
.sa_handler
= (void __user
*)(s64
)handler
;
347 err
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
348 err
|= __get_user(mask
, &act
->sa_mask
.sig
[0]);
352 siginitset(&new_ka
.sa
.sa_mask
, mask
);
355 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
358 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)))
360 err
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
361 err
|= __put_user((u32
)(u64
)old_ka
.sa
.sa_handler
,
363 err
|= __put_user(old_ka
.sa
.sa_mask
.sig
[0], oact
->sa_mask
.sig
);
364 err
|= __put_user(0, &oact
->sa_mask
.sig
[1]);
365 err
|= __put_user(0, &oact
->sa_mask
.sig
[2]);
366 err
|= __put_user(0, &oact
->sa_mask
.sig
[3]);
374 asmlinkage
int sys32_sigaltstack(nabi_no_regargs
struct pt_regs regs
)
376 const stack32_t __user
*uss
= (const stack32_t __user
*) regs
.regs
[4];
377 stack32_t __user
*uoss
= (stack32_t __user
*) regs
.regs
[5];
378 unsigned long usp
= regs
.regs
[29];
381 mm_segment_t old_fs
= get_fs();
385 if (!access_ok(VERIFY_READ
, uss
, sizeof(*uss
)))
387 err
|= __get_user(sp
, &uss
->ss_sp
);
388 kss
.ss_sp
= (void __user
*) (long) sp
;
389 err
|= __get_user(kss
.ss_size
, &uss
->ss_size
);
390 err
|= __get_user(kss
.ss_flags
, &uss
->ss_flags
);
396 ret
= do_sigaltstack(uss
? (stack_t __user
*)&kss
: NULL
,
397 uoss
? (stack_t __user
*)&koss
: NULL
, usp
);
401 if (!access_ok(VERIFY_WRITE
, uoss
, sizeof(*uoss
)))
403 sp
= (int) (unsigned long) koss
.ss_sp
;
404 err
|= __put_user(sp
, &uoss
->ss_sp
);
405 err
|= __put_user(koss
.ss_size
, &uoss
->ss_size
);
406 err
|= __put_user(koss
.ss_flags
, &uoss
->ss_flags
);
413 int copy_siginfo_to_user32(compat_siginfo_t __user
*to
, siginfo_t
*from
)
417 if (!access_ok (VERIFY_WRITE
, to
, sizeof(compat_siginfo_t
)))
420 /* If you change siginfo_t structure, please be sure
421 this code is fixed accordingly.
422 It should never copy any pad contained in the structure
423 to avoid security leaks, but must copy the generic
424 3 ints plus the relevant union member.
425 This routine must convert siginfo from 64bit to 32bit as well
427 err
= __put_user(from
->si_signo
, &to
->si_signo
);
428 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
429 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
430 if (from
->si_code
< 0)
431 err
|= __copy_to_user(&to
->_sifields
._pad
, &from
->_sifields
._pad
, SI_PAD_SIZE
);
433 switch (from
->si_code
>> 16) {
434 case __SI_TIMER
>> 16:
435 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
436 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
437 err
|= __put_user(from
->si_int
, &to
->si_int
);
439 case __SI_CHLD
>> 16:
440 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
441 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
442 err
|= __put_user(from
->si_status
, &to
->si_status
);
444 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
445 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
447 case __SI_FAULT
>> 16:
448 err
|= __put_user((unsigned long)from
->si_addr
, &to
->si_addr
);
450 case __SI_POLL
>> 16:
451 err
|= __put_user(from
->si_band
, &to
->si_band
);
452 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
454 case __SI_RT
>> 16: /* This is not generated by the kernel as of now. */
455 case __SI_MESGQ
>> 16:
456 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
457 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
458 err
|= __put_user(from
->si_int
, &to
->si_int
);
465 int copy_siginfo_from_user32(siginfo_t
*to
, compat_siginfo_t __user
*from
)
467 memset(to
, 0, sizeof *to
);
469 if (copy_from_user(to
, from
, 3*sizeof(int)) ||
470 copy_from_user(to
->_sifields
._pad
,
471 from
->_sifields
._pad
, SI_PAD_SIZE32
))
477 asmlinkage
void sys32_sigreturn(nabi_no_regargs
struct pt_regs regs
)
479 struct sigframe32 __user
*frame
;
483 frame
= (struct sigframe32 __user
*) regs
.regs
[29];
484 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
486 if (__copy_conv_sigset_from_user(&blocked
, &frame
->sf_mask
))
489 sigdelsetmask(&blocked
, ~_BLOCKABLE
);
490 spin_lock_irq(¤t
->sighand
->siglock
);
491 current
->blocked
= blocked
;
493 spin_unlock_irq(¤t
->sighand
->siglock
);
495 sig
= restore_sigcontext32(®s
, &frame
->sf_sc
);
499 force_sig(sig
, current
);
502 * Don't let your children do this ...
504 __asm__
__volatile__(
512 force_sig(SIGSEGV
, current
);
515 asmlinkage
void sys32_rt_sigreturn(nabi_no_regargs
struct pt_regs regs
)
517 struct rt_sigframe32 __user
*frame
;
524 frame
= (struct rt_sigframe32 __user
*) regs
.regs
[29];
525 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
527 if (__copy_conv_sigset_from_user(&set
, &frame
->rs_uc
.uc_sigmask
))
530 sigdelsetmask(&set
, ~_BLOCKABLE
);
531 spin_lock_irq(¤t
->sighand
->siglock
);
532 current
->blocked
= set
;
534 spin_unlock_irq(¤t
->sighand
->siglock
);
536 sig
= restore_sigcontext32(®s
, &frame
->rs_uc
.uc_mcontext
);
540 force_sig(sig
, current
);
542 /* The ucontext contains a stack32_t, so we must convert! */
543 if (__get_user(sp
, &frame
->rs_uc
.uc_stack
.ss_sp
))
545 st
.ss_sp
= (void __user
*)(long) sp
;
546 if (__get_user(st
.ss_size
, &frame
->rs_uc
.uc_stack
.ss_size
))
548 if (__get_user(st
.ss_flags
, &frame
->rs_uc
.uc_stack
.ss_flags
))
551 /* It is more difficult to avoid calling this function than to
552 call it and ignore errors. */
555 do_sigaltstack((stack_t __user
*)&st
, NULL
, regs
.regs
[29]);
559 * Don't let your children do this ...
561 __asm__
__volatile__(
569 force_sig(SIGSEGV
, current
);
572 static int setup_frame_32(void *sig_return
, struct k_sigaction
*ka
,
573 struct pt_regs
*regs
, int signr
, sigset_t
*set
)
575 struct sigframe32 __user
*frame
;
578 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
579 if (!access_ok(VERIFY_WRITE
, frame
, sizeof (*frame
)))
582 err
|= setup_sigcontext32(regs
, &frame
->sf_sc
);
583 err
|= __copy_conv_sigset_to_user(&frame
->sf_mask
, set
);
589 * Arguments to signal handler:
592 * a1 = 0 (should be cause)
593 * a2 = pointer to struct sigcontext
595 * $25 and c0_epc point to the signal handler, $29 points to the
598 regs
->regs
[ 4] = signr
;
600 regs
->regs
[ 6] = (unsigned long) &frame
->sf_sc
;
601 regs
->regs
[29] = (unsigned long) frame
;
602 regs
->regs
[31] = (unsigned long) sig_return
;
603 regs
->cp0_epc
= regs
->regs
[25] = (unsigned long) ka
->sa
.sa_handler
;
605 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
606 current
->comm
, current
->pid
,
607 frame
, regs
->cp0_epc
, regs
->regs
[31]);
612 force_sigsegv(signr
, current
);
616 static int setup_rt_frame_32(void *sig_return
, struct k_sigaction
*ka
,
617 struct pt_regs
*regs
, int signr
, sigset_t
*set
,
620 struct rt_sigframe32 __user
*frame
;
624 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
625 if (!access_ok(VERIFY_WRITE
, frame
, sizeof (*frame
)))
628 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
629 err
|= copy_siginfo_to_user32(&frame
->rs_info
, info
);
631 /* Create the ucontext. */
632 err
|= __put_user(0, &frame
->rs_uc
.uc_flags
);
633 err
|= __put_user(0, &frame
->rs_uc
.uc_link
);
634 sp
= (int) (long) current
->sas_ss_sp
;
635 err
|= __put_user(sp
,
636 &frame
->rs_uc
.uc_stack
.ss_sp
);
637 err
|= __put_user(sas_ss_flags(regs
->regs
[29]),
638 &frame
->rs_uc
.uc_stack
.ss_flags
);
639 err
|= __put_user(current
->sas_ss_size
,
640 &frame
->rs_uc
.uc_stack
.ss_size
);
641 err
|= setup_sigcontext32(regs
, &frame
->rs_uc
.uc_mcontext
);
642 err
|= __copy_conv_sigset_to_user(&frame
->rs_uc
.uc_sigmask
, set
);
648 * Arguments to signal handler:
651 * a1 = 0 (should be cause)
652 * a2 = pointer to ucontext
654 * $25 and c0_epc point to the signal handler, $29 points to
655 * the struct rt_sigframe32.
657 regs
->regs
[ 4] = signr
;
658 regs
->regs
[ 5] = (unsigned long) &frame
->rs_info
;
659 regs
->regs
[ 6] = (unsigned long) &frame
->rs_uc
;
660 regs
->regs
[29] = (unsigned long) frame
;
661 regs
->regs
[31] = (unsigned long) sig_return
;
662 regs
->cp0_epc
= regs
->regs
[25] = (unsigned long) ka
->sa
.sa_handler
;
664 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
665 current
->comm
, current
->pid
,
666 frame
, regs
->cp0_epc
, regs
->regs
[31]);
671 force_sigsegv(signr
, current
);
676 * o32 compatibility on 64-bit kernels, without DSP ASE
678 struct mips_abi mips_abi_32
= {
679 .setup_frame
= setup_frame_32
,
680 .signal_return_offset
=
681 offsetof(struct mips_vdso
, o32_signal_trampoline
),
682 .setup_rt_frame
= setup_rt_frame_32
,
683 .rt_signal_return_offset
=
684 offsetof(struct mips_vdso
, o32_rt_signal_trampoline
),
685 .restart
= __NR_O32_restart_syscall
688 SYSCALL_DEFINE4(32_rt_sigaction
, int, sig
,
689 const struct sigaction32 __user
*, act
,
690 struct sigaction32 __user
*, oact
, unsigned int, sigsetsize
)
692 struct k_sigaction new_sa
, old_sa
;
695 if (sigsetsize
!= sizeof(sigset_t
))
702 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)))
704 err
|= __get_user(handler
, &act
->sa_handler
);
705 new_sa
.sa
.sa_handler
= (void __user
*)(s64
)handler
;
706 err
|= __get_user(new_sa
.sa
.sa_flags
, &act
->sa_flags
);
707 err
|= get_sigset(&new_sa
.sa
.sa_mask
, &act
->sa_mask
);
712 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
717 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)))
720 err
|= __put_user((u32
)(u64
)old_sa
.sa
.sa_handler
,
722 err
|= __put_user(old_sa
.sa
.sa_flags
, &oact
->sa_flags
);
723 err
|= put_sigset(&old_sa
.sa
.sa_mask
, &oact
->sa_mask
);
731 SYSCALL_DEFINE4(32_rt_sigprocmask
, int, how
, compat_sigset_t __user
*, set
,
732 compat_sigset_t __user
*, oset
, unsigned int, sigsetsize
)
734 sigset_t old_set
, new_set
;
736 mm_segment_t old_fs
= get_fs();
738 if (set
&& get_sigset(&new_set
, set
))
742 ret
= sys_rt_sigprocmask(how
, set
? (sigset_t __user
*)&new_set
: NULL
,
743 oset
? (sigset_t __user
*)&old_set
: NULL
,
747 if (!ret
&& oset
&& put_sigset(&old_set
, oset
))
753 SYSCALL_DEFINE2(32_rt_sigpending
, compat_sigset_t __user
*, uset
,
754 unsigned int, sigsetsize
)
758 mm_segment_t old_fs
= get_fs();
761 ret
= sys_rt_sigpending((sigset_t __user
*)&set
, sigsetsize
);
764 if (!ret
&& put_sigset(&set
, uset
))
770 SYSCALL_DEFINE3(32_rt_sigqueueinfo
, int, pid
, int, sig
,
771 compat_siginfo_t __user
*, uinfo
)
775 mm_segment_t old_fs
= get_fs();
777 if (copy_from_user(&info
, uinfo
, 3*sizeof(int)) ||
778 copy_from_user(info
._sifields
._pad
, uinfo
->_sifields
._pad
, SI_PAD_SIZE
))
781 ret
= sys_rt_sigqueueinfo(pid
, sig
, (siginfo_t __user
*)&info
);
786 SYSCALL_DEFINE5(32_waitid
, int, which
, compat_pid_t
, pid
,
787 compat_siginfo_t __user
*, uinfo
, int, options
,
788 struct compat_rusage __user
*, uru
)
793 mm_segment_t old_fs
= get_fs();
797 ret
= sys_waitid(which
, pid
, (siginfo_t __user
*) &info
, options
,
798 uru
? (struct rusage __user
*) &ru
: NULL
);
801 if (ret
< 0 || info
.si_signo
== 0)
804 if (uru
&& (ret
= put_compat_rusage(&ru
, uru
)))
807 BUG_ON(info
.si_code
& __SI_MASK
);
808 info
.si_code
|= __SI_CHLD
;
809 return copy_siginfo_to_user32(uinfo
, &info
);
812 static int signal32_init(void)
815 save_fp_context32
= _save_fp_context32
;
816 restore_fp_context32
= _restore_fp_context32
;
818 save_fp_context32
= fpu_emulator_save_context32
;
819 restore_fp_context32
= fpu_emulator_restore_context32
;
825 arch_initcall(signal32_init
);