Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 751f409db6216ebd134a94f6dcd97779933a5106

Authored by Denys Vlasenko 2012-10-05 08:15:31 +0800

Committed by Linus Torvalds 2012-10-06 02:05:16 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

compat: move compat_siginfo_t definition to asm/compat.h

This is a preparatory patch for the introduction of NT_SIGINFO elf note.

Make the location of compat_siginfo_t uniform across eight architectures
which have it.  Now it can be pulled in by including asm/compat.h or
linux/compat.h.

Most of the copies are verbatim.  compat_uid[32]_t had to be replaced by
__compat_uid[32]_t.  compat_uptr_t had to be moved up before
compat_siginfo_t in asm/compat.h on a several architectures (tile already
had it moved up).  compat_sigval_t had to be relocated from linux/compat.h
to asm/compat.h.

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Amerigo Wang <amwang@redhat.com>
Cc: "Jonathan M. Foote" <jmfoote@cert.org>
Cc: Roland McGrath <roland@hack.frob.com>
Cc: Pedro Alves <palves@redhat.com>
Cc: Fengguang Wu <fengguang.wu@intel.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 19 changed files with 513 additions and 476 deletions Inline Diff

arch/arm64/include/asm/compat.h
arch/arm64/kernel/signal32.c
arch/mips/include/asm/compat-signal.h
arch/mips/include/asm/compat.h
arch/parisc/include/asm/compat.h
arch/parisc/kernel/signal32.h
arch/powerpc/include/asm/compat.h
arch/powerpc/include/asm/siginfo.h
arch/powerpc/kernel/ppc32.h
arch/s390/include/asm/compat.h
arch/s390/kernel/compat_linux.h
arch/sparc/include/asm/compat.h
arch/sparc/include/asm/siginfo.h
arch/sparc/kernel/signal32.c
arch/tile/include/asm/compat.h
arch/tile/kernel/compat_signal.c
arch/x86/include/asm/compat.h
arch/x86/include/asm/ia32.h
include/linux/compat.h

arch/arm64/include/asm/compat.h

Diff comments View file @ 751f409

 /*
  * Copyright (C) 2012 ARM Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #ifndef __ASM_COMPAT_H
 #define __ASM_COMPAT_H
 #ifdef __KERNEL__
 #ifdef CONFIG_COMPAT
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #include <linux/sched.h>
 #define COMPAT_USER_HZ		100
 #define COMPAT_UTS_MACHINE	"armv8l\0\0"
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef s32		compat_pid_t;
 typedef u32		__compat_uid_t;
 typedef u32		__compat_gid_t;
 typedef u32		__compat_uid32_t;
 typedef u32		__compat_gid32_t;
 typedef u32		compat_mode_t;
 typedef u32		compat_ino_t;
 typedef u32		compat_dev_t;
 typedef s32		compat_off_t;
 typedef s64		compat_loff_t;
 typedef s16		compat_nlink_t;
 typedef u16		compat_ipc_pid_t;
 typedef s32		compat_daddr_t;
 typedef u32		compat_caddr_t;
 typedef __kernel_fsid_t	compat_fsid_t;
 typedef s32		compat_key_t;
 typedef s32		compat_timer_t;
 typedef s32		compat_int_t;
 typedef s32		compat_long_t;
 typedef s64		compat_s64;
 typedef u32		compat_uint_t;
 typedef u32		compat_ulong_t;
 typedef u64		compat_u64;
+typedef u32		compat_uptr_t;
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 struct compat_stat {
 	compat_dev_t	st_dev;
 	compat_ino_t	st_ino;
 	compat_mode_t	st_mode;
 	compat_nlink_t	st_nlink;
 	__compat_uid32_t	st_uid;
 	__compat_gid32_t	st_gid;
 	compat_dev_t	st_rdev;
 	compat_off_t	st_size;
 	compat_off_t	st_blksize;
 	compat_off_t	st_blocks;
 	compat_time_t	st_atime;
 	u32		st_atime_nsec;
 	compat_time_t	st_mtime;
 	u32		st_mtime_nsec;
 	compat_time_t	st_ctime;
 	u32		st_ctime_nsec;
 	u32		__unused4[2];
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	compat_pid_t	l_pid;
 };
 #define F_GETLK64	12	/*  using 'struct flock64' */
 #define F_SETLK64	13
 #define F_SETLKW64	14
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 };
 struct compat_statfs {
 	int		f_type;
 	int		f_bsize;
 	int		f_blocks;
 	int		f_bfree;
 	int		f_bavail;
 	int		f_files;
 	int		f_ffree;
 	compat_fsid_t	f_fsid;
 	int		f_namelen;	/* SunOS ignores this field. */
 	int		f_frsize;
 	int		f_flags;
 	int		f_spare[4];
 };
 #define COMPAT_RLIM_INFINITY		0xffffffff
 typedef u32		compat_old_sigset_t;
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32		compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_errno;
+	int si_code;
+	union {
+		/* The padding is the same size as AArch64. */
+		int _pad[128/sizeof(int) - 3];
+		/* kill() */
+		struct {
+			compat_pid_t _pid;	/* sender's pid */
+			__compat_uid32_t _uid;	/* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;	/* timer id */
+			int _overrun;		/* overrun count */
+			compat_sigval_t _sigval;	/* same as below */
+			int _sys_private;       /* not to be passed to user */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			compat_pid_t _pid;	/* sender's pid */
+			__compat_uid32_t _uid;	/* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			compat_pid_t _pid;	/* which child */
+			__compat_uid32_t _uid;	/* sender's uid */
+			int _status;		/* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+		struct {
+			compat_uptr_t _addr; /* faulting insn/memory ref. */
+			short _addr_lsb; /* LSB of the reported address */
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			compat_long_t _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef	u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(unsigned long)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	struct pt_regs *regs = task_pt_regs(current);
 	return (void __user *)regs->compat_sp - len;
 }
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid32_t uid;
 	__compat_gid32_t gid;
 	__compat_uid32_t cuid;
 	__compat_gid32_t cgid;
 	unsigned short mode;
 	unsigned short __pad1;
 	unsigned short seq;
 	unsigned short __pad2;
 	compat_ulong_t unused1;
 	compat_ulong_t unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	compat_time_t  sem_otime;
 	compat_ulong_t __unused1;
 	compat_time_t  sem_ctime;
 	compat_ulong_t __unused2;
 	compat_ulong_t sem_nsems;
 	compat_ulong_t __unused3;
 	compat_ulong_t __unused4;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 	compat_time_t  msg_stime;
 	compat_ulong_t __unused1;
 	compat_time_t  msg_rtime;
 	compat_ulong_t __unused2;
 	compat_time_t  msg_ctime;
 	compat_ulong_t __unused3;
 	compat_ulong_t msg_cbytes;
 	compat_ulong_t msg_qnum;
 	compat_ulong_t msg_qbytes;
 	compat_pid_t   msg_lspid;
 	compat_pid_t   msg_lrpid;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	compat_size_t  shm_segsz;
 	compat_time_t  shm_atime;
 	compat_ulong_t __unused1;
 	compat_time_t  shm_dtime;
 	compat_ulong_t __unused2;
 	compat_time_t  shm_ctime;
 	compat_ulong_t __unused3;
 	compat_pid_t   shm_cpid;
 	compat_pid_t   shm_lpid;
 	compat_ulong_t shm_nattch;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 static inline int is_compat_task(void)
 {
 	return test_thread_flag(TIF_32BIT);
 }
 static inline int is_compat_thread(struct thread_info *thread)
 {
 	return test_ti_thread_flag(thread, TIF_32BIT);
 }
 #else /* !CONFIG_COMPAT */
 static inline int is_compat_task(void)
 {
 	return 0;
 }
 static inline int is_compat_thread(struct thread_info *thread)
 {
 	return 0;
 }
 #endif /* CONFIG_COMPAT */
 #endif /* __KERNEL__ */
 #endif /* __ASM_COMPAT_H */

arch/arm64/kernel/signal32.c

Diff comments View file @ 751f409

 /*
  * Based on arch/arm/kernel/signal.c
  *
  * Copyright (C) 1995-2009 Russell King
  * Copyright (C) 2012 ARM Ltd.
  * Modified by Will Deacon <will.deacon@arm.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #define __SYSCALL_COMPAT
 #include <linux/compat.h>
 #include <linux/signal.h>
 #include <linux/syscalls.h>
 #include <linux/ratelimit.h>
 #include <asm/fpsimd.h>
 #include <asm/signal32.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
-typedef struct compat_siginfo {
-	int si_signo;
-	int si_errno;
-	int si_code;
-	union {
-		/* The padding is the same size as AArch64. */
-		int _pad[SI_PAD_SIZE];
-		/* kill() */
-		struct {
-			compat_pid_t _pid;	/* sender's pid */
-			__compat_uid32_t _uid;	/* sender's uid */
-		} _kill;
-		/* POSIX.1b timers */
-		struct {
-			compat_timer_t _tid;	/* timer id */
-			int _overrun;		/* overrun count */
-			compat_sigval_t _sigval;	/* same as below */
-			int _sys_private;       /* not to be passed to user */
-		} _timer;
-		/* POSIX.1b signals */
-		struct {
-			compat_pid_t _pid;	/* sender's pid */
-			__compat_uid32_t _uid;	/* sender's uid */
-			compat_sigval_t _sigval;
-		} _rt;
-		/* SIGCHLD */
-		struct {
-			compat_pid_t _pid;	/* which child */
-			__compat_uid32_t _uid;	/* sender's uid */
-			int _status;		/* exit code */
-			compat_clock_t _utime;
-			compat_clock_t _stime;
-		} _sigchld;
-		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
-		struct {
-			compat_uptr_t _addr; /* faulting insn/memory ref. */
-			short _addr_lsb; /* LSB of the reported address */
-		} _sigfault;
-		/* SIGPOLL */
-		struct {
-			compat_long_t _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
-			int _fd;
-		} _sigpoll;
-	} _sifields;
-} compat_siginfo_t;
 struct compat_sigaction {
 	compat_uptr_t			sa_handler;
 	compat_ulong_t			sa_flags;
 	compat_uptr_t			sa_restorer;
 	compat_sigset_t			sa_mask;
 };
 struct compat_old_sigaction {
 	compat_uptr_t			sa_handler;
 	compat_old_sigset_t		sa_mask;
 	compat_ulong_t			sa_flags;
 	compat_uptr_t			sa_restorer;
 };
 typedef struct compat_sigaltstack {
 	compat_uptr_t			ss_sp;
 	int				ss_flags;
 	compat_size_t			ss_size;
 } compat_stack_t;
 struct compat_sigcontext {
 	/* We always set these two fields to 0 */
 	compat_ulong_t			trap_no;
 	compat_ulong_t			error_code;
 	compat_ulong_t			oldmask;
 	compat_ulong_t			arm_r0;
 	compat_ulong_t			arm_r1;
 	compat_ulong_t			arm_r2;
 	compat_ulong_t			arm_r3;
 	compat_ulong_t			arm_r4;
 	compat_ulong_t			arm_r5;
 	compat_ulong_t			arm_r6;
 	compat_ulong_t			arm_r7;
 	compat_ulong_t			arm_r8;
 	compat_ulong_t			arm_r9;
 	compat_ulong_t			arm_r10;
 	compat_ulong_t			arm_fp;
 	compat_ulong_t			arm_ip;
 	compat_ulong_t			arm_sp;
 	compat_ulong_t			arm_lr;
 	compat_ulong_t			arm_pc;
 	compat_ulong_t			arm_cpsr;
 	compat_ulong_t			fault_address;
 };
 struct compat_ucontext {
 	compat_ulong_t			uc_flags;
 	struct compat_ucontext		*uc_link;
 	compat_stack_t			uc_stack;
 	struct compat_sigcontext	uc_mcontext;
 	compat_sigset_t			uc_sigmask;
 	int		__unused[32 - (sizeof (compat_sigset_t) / sizeof (int))];
 	compat_ulong_t	uc_regspace[128] __attribute__((__aligned__(8)));
 };
 struct compat_vfp_sigframe {
 	compat_ulong_t	magic;
 	compat_ulong_t	size;
 	struct compat_user_vfp {
 		compat_u64	fpregs[32];
 		compat_ulong_t	fpscr;
 	} ufp;
 	struct compat_user_vfp_exc {
 		compat_ulong_t	fpexc;
 		compat_ulong_t	fpinst;
 		compat_ulong_t	fpinst2;
 	} ufp_exc;
 } __attribute__((__aligned__(8)));
 #define VFP_MAGIC		0x56465001
 #define VFP_STORAGE_SIZE	sizeof(struct compat_vfp_sigframe)
 struct compat_aux_sigframe {
 	struct compat_vfp_sigframe	vfp;
 	/* Something that isn't a valid magic number for any coprocessor.  */
 	unsigned long			end_magic;
 } __attribute__((__aligned__(8)));
 struct compat_sigframe {
 	struct compat_ucontext	uc;
 	compat_ulong_t		retcode[2];
 };
 struct compat_rt_sigframe {
 	struct compat_siginfo info;
 	struct compat_sigframe sig;
 };
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 /*
  * For ARM syscalls, the syscall number has to be loaded into r7.
  * We do not support an OABI userspace.
  */
 #define MOV_R7_NR_SIGRETURN	(0xe3a07000 | __NR_sigreturn)
 #define SVC_SYS_SIGRETURN	(0xef000000 | __NR_sigreturn)
 #define MOV_R7_NR_RT_SIGRETURN	(0xe3a07000 | __NR_rt_sigreturn)
 #define SVC_SYS_RT_SIGRETURN	(0xef000000 | __NR_rt_sigreturn)
 /*
  * For Thumb syscalls, we also pass the syscall number via r7. We therefore
  * need two 16-bit instructions.
  */
 #define SVC_THUMB_SIGRETURN	(((0xdf00 | __NR_sigreturn) << 16) | \
 				   0x2700 | __NR_sigreturn)
 #define SVC_THUMB_RT_SIGRETURN	(((0xdf00 | __NR_rt_sigreturn) << 16) | \
 				   0x2700 | __NR_rt_sigreturn)
 const compat_ulong_t aarch32_sigret_code[6] = {
 	/*
 	 * AArch32 sigreturn code.
 	 * We don't construct an OABI SWI - instead we just set the imm24 field
 	 * to the EABI syscall number so that we create a sane disassembly.
 	 */
 	MOV_R7_NR_SIGRETURN,    SVC_SYS_SIGRETURN,    SVC_THUMB_SIGRETURN,
 	MOV_R7_NR_RT_SIGRETURN, SVC_SYS_RT_SIGRETURN, SVC_THUMB_RT_SIGRETURN,
 };
 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
 {
 	compat_sigset_t	cset;
 	cset.sig[0] = set->sig[0] & 0xffffffffull;
 	cset.sig[1] = set->sig[0] >> 32;
 	return copy_to_user(uset, &cset, sizeof(*uset));
 }
 static inline int get_sigset_t(sigset_t *set,
 			       const compat_sigset_t __user *uset)
 {
 	compat_sigset_t s32;
 	if (copy_from_user(&s32, uset, sizeof(*uset)))
 		return -EFAULT;
 	set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
 	return 0;
 }
 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 {
 	int err;
 	if (!access_ok(VERIFY_WRITE, to, sizeof(*to)))
 		return -EFAULT;
 	/* If you change siginfo_t structure, please be sure
 	 * this code is fixed accordingly.
 	 * It should never copy any pad contained in the structure
 	 * to avoid security leaks, but must copy the generic
 	 * 3 ints plus the relevant union member.
 	 * This routine must convert siginfo from 64bit to 32bit as well
 	 * at the same time.
 	 */
 	err = __put_user(from->si_signo, &to->si_signo);
 	err |= __put_user(from->si_errno, &to->si_errno);
 	err |= __put_user((short)from->si_code, &to->si_code);
 	if (from->si_code < 0)
 		err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad,
 				      SI_PAD_SIZE);
 	else switch (from->si_code & __SI_MASK) {
 	case __SI_KILL:
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		break;
 	case __SI_TIMER:
 		 err |= __put_user(from->si_tid, &to->si_tid);
 		 err |= __put_user(from->si_overrun, &to->si_overrun);
 		 err |= __put_user((compat_uptr_t)(unsigned long)from->si_ptr,
 				   &to->si_ptr);
 		break;
 	case __SI_POLL:
 		err |= __put_user(from->si_band, &to->si_band);
 		err |= __put_user(from->si_fd, &to->si_fd);
 		break;
 	case __SI_FAULT:
 		err |= __put_user((compat_uptr_t)(unsigned long)from->si_addr,
 				  &to->si_addr);
 #ifdef BUS_MCEERR_AO
 		/*
 		 * Other callers might not initialize the si_lsb field,
 		 * so check explicitely for the right codes here.
 		 */
 		if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
 			err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
 #endif
 		break;
 	case __SI_CHLD:
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		err |= __put_user(from->si_status, &to->si_status);
 		err |= __put_user(from->si_utime, &to->si_utime);
 		err |= __put_user(from->si_stime, &to->si_stime);
 		break;
 	case __SI_RT: /* This is not generated by the kernel as of now. */
 	case __SI_MESGQ: /* But this is */
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		err |= __put_user((compat_uptr_t)(unsigned long)from->si_ptr, &to->si_ptr);
 		break;
 	default: /* this is just in case for now ... */
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		break;
 	}
 	return err;
 }
 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 {
 	memset(to, 0, sizeof *to);
 	if (copy_from_user(to, from, __ARCH_SI_PREAMBLE_SIZE) ||
 	    copy_from_user(to->_sifields._pad,
 			   from->_sifields._pad, SI_PAD_SIZE))
 		return -EFAULT;
 	return 0;
 }
 /*
  * VFP save/restore code.
  */
 static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame)
 {
 	struct fpsimd_state *fpsimd = &current->thread.fpsimd_state;
 	compat_ulong_t magic = VFP_MAGIC;
 	compat_ulong_t size = VFP_STORAGE_SIZE;
 	compat_ulong_t fpscr, fpexc;
 	int err = 0;
 	/*
 	 * Save the hardware registers to the fpsimd_state structure.
 	 * Note that this also saves V16-31, which aren't visible
 	 * in AArch32.
 	 */
 	fpsimd_save_state(fpsimd);
 	/* Place structure header on the stack */
 	__put_user_error(magic, &frame->magic, err);
 	__put_user_error(size, &frame->size, err);
 	/*
 	 * Now copy the FP registers. Since the registers are packed,
 	 * we can copy the prefix we want (V0-V15) as it is.
 	 * FIXME: Won't work if big endian.
 	 */
 	err |= __copy_to_user(&frame->ufp.fpregs, fpsimd->vregs,
 			      sizeof(frame->ufp.fpregs));
 	/* Create an AArch32 fpscr from the fpsr and the fpcr. */
 	fpscr = (fpsimd->fpsr & VFP_FPSCR_STAT_MASK) |
 		(fpsimd->fpcr & VFP_FPSCR_CTRL_MASK);
 	__put_user_error(fpscr, &frame->ufp.fpscr, err);
 	/*
 	 * The exception register aren't available so we fake up a
 	 * basic FPEXC and zero everything else.
 	 */
 	fpexc = (1 << 30);
 	__put_user_error(fpexc, &frame->ufp_exc.fpexc, err);
 	__put_user_error(0, &frame->ufp_exc.fpinst, err);
 	__put_user_error(0, &frame->ufp_exc.fpinst2, err);
 	return err ? -EFAULT : 0;
 }
 static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame)
 {
 	struct fpsimd_state fpsimd;
 	compat_ulong_t magic = VFP_MAGIC;
 	compat_ulong_t size = VFP_STORAGE_SIZE;
 	compat_ulong_t fpscr;
 	int err = 0;
 	__get_user_error(magic, &frame->magic, err);
 	__get_user_error(size, &frame->size, err);
 	if (err)
 		return -EFAULT;
 	if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
 		return -EINVAL;
 	/*
 	 * Copy the FP registers into the start of the fpsimd_state.
 	 * FIXME: Won't work if big endian.
 	 */
 	err |= __copy_from_user(fpsimd.vregs, frame->ufp.fpregs,
 				sizeof(frame->ufp.fpregs));
 	/* Extract the fpsr and the fpcr from the fpscr */
 	__get_user_error(fpscr, &frame->ufp.fpscr, err);
 	fpsimd.fpsr = fpscr & VFP_FPSCR_STAT_MASK;
 	fpsimd.fpcr = fpscr & VFP_FPSCR_CTRL_MASK;
 	/*
 	 * We don't need to touch the exception register, so
 	 * reload the hardware state.
 	 */
 	if (!err) {
 		preempt_disable();
 		fpsimd_load_state(&fpsimd);
 		preempt_enable();
 	}
 	return err ? -EFAULT : 0;
 }
 /*
  * atomically swap in the new signal mask, and wait for a signal.
  */
 asmlinkage int compat_sys_sigsuspend(int restart, compat_ulong_t oldmask,
 				     compat_old_sigset_t mask)
 {
 	sigset_t blocked;
 	siginitset(&current->blocked, mask);
 	return sigsuspend(&blocked);
 }
 asmlinkage int compat_sys_sigaction(int sig,
 				    const struct compat_old_sigaction __user *act,
 				    struct compat_old_sigaction __user *oact)
 {
 	struct k_sigaction new_ka, old_ka;
 	int ret;
 	compat_old_sigset_t mask;
 	compat_uptr_t handler, restorer;
 	if (act) {
 		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 		    __get_user(handler, &act->sa_handler) ||
 		    __get_user(restorer, &act->sa_restorer) ||
 		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
 		    __get_user(mask, &act->sa_mask))
 			return -EFAULT;
 		new_ka.sa.sa_handler = compat_ptr(handler);
 		new_ka.sa.sa_restorer = compat_ptr(restorer);
 		siginitset(&new_ka.sa.sa_mask, mask);
 	}
 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 	if (!ret && oact) {
 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 		    __put_user(ptr_to_compat(old_ka.sa.sa_handler),
 			       &oact->sa_handler) ||
 		    __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
 			       &oact->sa_restorer) ||
 		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
 		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
 			return -EFAULT;
 	}
 	return ret;
 }
 asmlinkage int compat_sys_rt_sigaction(int sig,
 				       const struct compat_sigaction __user *act,
 				       struct compat_sigaction __user *oact,
 				       compat_size_t sigsetsize)
 {
 	struct k_sigaction new_ka, old_ka;
 	int ret;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(compat_sigset_t))
 		return -EINVAL;
 	if (act) {
 		compat_uptr_t handler, restorer;
 		ret = get_user(handler, &act->sa_handler);
 		new_ka.sa.sa_handler = compat_ptr(handler);
 		ret |= get_user(restorer, &act->sa_restorer);
 		new_ka.sa.sa_restorer = compat_ptr(restorer);
 		ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
 		ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 		if (ret)
 			return -EFAULT;
 	}
 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 	if (!ret && oact) {
 		ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
 		ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
 		ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 	}
 	return ret;
 }
 int compat_do_sigaltstack(compat_uptr_t compat_uss, compat_uptr_t compat_uoss,
 			  compat_ulong_t sp)
 {
 	compat_stack_t __user *newstack = compat_ptr(compat_uss);
 	compat_stack_t __user *oldstack = compat_ptr(compat_uoss);
 	compat_uptr_t ss_sp;
 	int ret;
 	mm_segment_t old_fs;
 	stack_t uss, uoss;
 	/* Marshall the compat new stack into a stack_t */
 	if (newstack) {
 		if (get_user(ss_sp, &newstack->ss_sp) ||
 		    __get_user(uss.ss_flags, &newstack->ss_flags) ||
 		    __get_user(uss.ss_size, &newstack->ss_size))
 			return -EFAULT;
 		uss.ss_sp = compat_ptr(ss_sp);
 	}
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	/* The __user pointer casts are valid because of the set_fs() */
 	ret = do_sigaltstack(
 		newstack ? (stack_t __user *) &uss : NULL,
 		oldstack ? (stack_t __user *) &uoss : NULL,
 		(unsigned long)sp);
 	set_fs(old_fs);
 	/* Convert the old stack_t into a compat stack. */
 	if (!ret && oldstack &&
 		(put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
 		 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
 		 __put_user(uoss.ss_size, &oldstack->ss_size)))
 		return -EFAULT;
 	return ret;
 }
 static int compat_restore_sigframe(struct pt_regs *regs,
 				   struct compat_sigframe __user *sf)
 {
 	int err;
 	sigset_t set;
 	struct compat_aux_sigframe __user *aux;
 	err = get_sigset_t(&set, &sf->uc.uc_sigmask);
 	if (err == 0) {
 		sigdelsetmask(&set, ~_BLOCKABLE);
 		set_current_blocked(&set);
 	}
 	__get_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
 	__get_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
 	__get_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
 	__get_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
 	__get_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
 	__get_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
 	__get_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
 	__get_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
 	__get_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
 	__get_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
 	__get_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
 	__get_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
 	__get_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
 	__get_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
 	__get_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
 	__get_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
 	__get_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err);
 	/*
 	 * Avoid compat_sys_sigreturn() restarting.
 	 */
 	regs->syscallno = ~0UL;
 	err |= !valid_user_regs(&regs->user_regs);
 	aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
 	if (err == 0)
 		err |= compat_restore_vfp_context(&aux->vfp);
 	return err;
 }
 asmlinkage int compat_sys_sigreturn(struct pt_regs *regs)
 {
 	struct compat_sigframe __user *frame;
 	/* Always make any pending restarted system calls return -EINTR */
 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 	/*
 	 * Since we stacked the signal on a 64-bit boundary,
 	 * then 'sp' should be word aligned here.  If it's
 	 * not, then the user is trying to mess with us.
 	 */
 	if (regs->compat_sp & 7)
 		goto badframe;
 	frame = (struct compat_sigframe __user *)regs->compat_sp;
 	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
 		goto badframe;
 	if (compat_restore_sigframe(regs, frame))
 		goto badframe;
 	return regs->regs[0];
 badframe:
 	if (show_unhandled_signals)
 		pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
 				    current->comm, task_pid_nr(current), __func__,
 				    regs->pc, regs->sp);
 	force_sig(SIGSEGV, current);
 	return 0;
 }
 asmlinkage int compat_sys_rt_sigreturn(struct pt_regs *regs)
 {
 	struct compat_rt_sigframe __user *frame;
 	/* Always make any pending restarted system calls return -EINTR */
 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 	/*
 	 * Since we stacked the signal on a 64-bit boundary,
 	 * then 'sp' should be word aligned here.  If it's
 	 * not, then the user is trying to mess with us.
 	 */
 	if (regs->compat_sp & 7)
 		goto badframe;
 	frame = (struct compat_rt_sigframe __user *)regs->compat_sp;
 	if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
 		goto badframe;
 	if (compat_restore_sigframe(regs, &frame->sig))
 		goto badframe;
 	if (compat_do_sigaltstack(ptr_to_compat(&frame->sig.uc.uc_stack),
 				 ptr_to_compat((void __user *)NULL),
 				 regs->compat_sp) == -EFAULT)
 		goto badframe;
 	return regs->regs[0];
 badframe:
 	if (show_unhandled_signals)
 		pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
 				    current->comm, task_pid_nr(current), __func__,
 				    regs->pc, regs->sp);
 	force_sig(SIGSEGV, current);
 	return 0;
 }
 static inline void __user *compat_get_sigframe(struct k_sigaction *ka,
 					       struct pt_regs *regs,
 					       int framesize)
 {
 	compat_ulong_t sp = regs->compat_sp;
 	void __user *frame;
 	/*
 	 * This is the X/Open sanctioned signal stack switching.
 	 */
 	if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
 		sp = current->sas_ss_sp + current->sas_ss_size;
 	/*
 	 * ATPCS B01 mandates 8-byte alignment
 	 */
 	frame = compat_ptr((compat_uptr_t)((sp - framesize) & ~7));
 	/*
 	 * Check that we can actually write to the signal frame.
 	 */
 	if (!access_ok(VERIFY_WRITE, frame, framesize))
 		frame = NULL;
 	return frame;
 }
 static int compat_setup_return(struct pt_regs *regs, struct k_sigaction *ka,
 			       compat_ulong_t __user *rc, void __user *frame,
 			       int usig)
 {
 	compat_ulong_t handler = ptr_to_compat(ka->sa.sa_handler);
 	compat_ulong_t retcode;
 	compat_ulong_t spsr = regs->pstate & ~PSR_f;
 	int thumb;
 	/* Check if the handler is written for ARM or Thumb */
 	thumb = handler & 1;
 	if (thumb) {
 		spsr |= COMPAT_PSR_T_BIT;
 		spsr &= ~COMPAT_PSR_IT_MASK;
 	} else {
 		spsr &= ~COMPAT_PSR_T_BIT;
 	}
 	if (ka->sa.sa_flags & SA_RESTORER) {
 		retcode = ptr_to_compat(ka->sa.sa_restorer);
 	} else {
 		/* Set up sigreturn pointer */
 		unsigned int idx = thumb << 1;
 		if (ka->sa.sa_flags & SA_SIGINFO)
 			idx += 3;
 		retcode = AARCH32_VECTORS_BASE +
 			  AARCH32_KERN_SIGRET_CODE_OFFSET +
 			  (idx << 2) + thumb;
 	}
 	regs->regs[0]	= usig;
 	regs->compat_sp	= ptr_to_compat(frame);
 	regs->compat_lr	= retcode;
 	regs->pc	= handler;
 	regs->pstate	= spsr;
 	return 0;
 }
 static int compat_setup_sigframe(struct compat_sigframe __user *sf,
 				 struct pt_regs *regs, sigset_t *set)
 {
 	struct compat_aux_sigframe __user *aux;
 	int err = 0;
 	__put_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
 	__put_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
 	__put_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
 	__put_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
 	__put_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
 	__put_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
 	__put_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
 	__put_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
 	__put_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
 	__put_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
 	__put_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
 	__put_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
 	__put_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
 	__put_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
 	__put_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
 	__put_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
 	__put_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err);
 	__put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.trap_no, err);
 	__put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.error_code, err);
 	__put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
 	__put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
 	err |= put_sigset_t(&sf->uc.uc_sigmask, set);
 	aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
 	if (err == 0)
 		err |= compat_preserve_vfp_context(&aux->vfp);
 	__put_user_error(0, &aux->end_magic, err);
 	return err;
 }
 /*
  * 32-bit signal handling routines called from signal.c
  */
 int compat_setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
 			  sigset_t *set, struct pt_regs *regs)
 {
 	struct compat_rt_sigframe __user *frame;
 	compat_stack_t stack;
 	int err = 0;
 	frame = compat_get_sigframe(ka, regs, sizeof(*frame));
 	if (!frame)
 		return 1;
 	err |= copy_siginfo_to_user32(&frame->info, info);
 	__put_user_error(0, &frame->sig.uc.uc_flags, err);
 	__put_user_error(NULL, &frame->sig.uc.uc_link, err);
 	memset(&stack, 0, sizeof(stack));
 	stack.ss_sp = (compat_uptr_t)current->sas_ss_sp;
 	stack.ss_flags = sas_ss_flags(regs->compat_sp);
 	stack.ss_size = current->sas_ss_size;
 	err |= __copy_to_user(&frame->sig.uc.uc_stack, &stack, sizeof(stack));
 	err |= compat_setup_sigframe(&frame->sig, regs, set);
 	if (err == 0)
 		err = compat_setup_return(regs, ka, frame->sig.retcode, frame,
 					  usig);
 	if (err == 0) {
 		regs->regs[1] = (compat_ulong_t)(unsigned long)&frame->info;
 		regs->regs[2] = (compat_ulong_t)(unsigned long)&frame->sig.uc;
 	}
 	return err;
 }
 int compat_setup_frame(int usig, struct k_sigaction *ka, sigset_t *set,
 		       struct pt_regs *regs)
 {
 	struct compat_sigframe __user *frame;
 	int err = 0;
 	frame = compat_get_sigframe(ka, regs, sizeof(*frame));
 	if (!frame)
 		return 1;
 	__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
 	err |= compat_setup_sigframe(frame, regs, set);
 	if (err == 0)
 		err = compat_setup_return(regs, ka, frame->retcode, frame, usig);
 	return err;
 }
 /*
  * RT signals don't have generic compat wrappers.
  * See arch/powerpc/kernel/signal_32.c
  */
 asmlinkage int compat_sys_rt_sigprocmask(int how, compat_sigset_t __user *set,
 					 compat_sigset_t __user *oset,
 					 compat_size_t sigsetsize)
 {
 	sigset_t s;
 	sigset_t __user *up;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	if (set) {
 		if (get_sigset_t(&s, set))
 			return -EFAULT;
 	}
 	set_fs(KERNEL_DS);
 	/* This is valid because of the set_fs() */
 	up = (sigset_t __user *) &s;
 	ret = sys_rt_sigprocmask(how, set ? up : NULL, oset ? up : NULL,
 				 sigsetsize);
 	set_fs(old_fs);
 	if (ret)
 		return ret;
 	if (oset) {
 		if (put_sigset_t(oset, &s))
 			return -EFAULT;
 	}
 	return 0;
 }
 asmlinkage int compat_sys_rt_sigpending(compat_sigset_t __user *set,
 					compat_size_t sigsetsize)
 {
 	sigset_t s;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	/* The __user pointer cast is valid because of the set_fs() */
 	ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
 	set_fs(old_fs);
 	if (!ret) {
 		if (put_sigset_t(set, &s))
 			return -EFAULT;
 	}
 	return ret;
 }
 asmlinkage int compat_sys_rt_sigqueueinfo(int pid, int sig,
 					  compat_siginfo_t __user *uinfo)
 {
 	siginfo_t info;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	ret = copy_siginfo_from_user32(&info, uinfo);
 	if (unlikely(ret))
 		return ret;
 	set_fs (KERNEL_DS);
 	/* The __user pointer cast is valid because of the set_fs() */
 	ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *) &info);
 	set_fs (old_fs);
 	return ret;
 }
 void compat_setup_restart_syscall(struct pt_regs *regs)
 {
        regs->regs[7] = __NR_restart_syscall;
 }

arch/mips/include/asm/compat-signal.h

Diff comments View file @ 751f409

1	#ifndef __ASM_COMPAT_SIGNAL_H	1	#ifndef __ASM_COMPAT_SIGNAL_H
2	#define __ASM_COMPAT_SIGNAL_H	2	#define __ASM_COMPAT_SIGNAL_H
3		3
4	#include <linux/bug.h>	4	#include <linux/bug.h>
5	#include <linux/compat.h>	5	#include <linux/compat.h>
6	#include <linux/compiler.h>	6	#include <linux/compiler.h>
7		7
8	#include <asm/signal.h>	8	#include <asm/signal.h>
9	#include <asm/siginfo.h>	9	#include <asm/siginfo.h>
10		10
11	#include <asm/uaccess.h>	11	#include <asm/uaccess.h>
12		12
13	#define SI_PAD_SIZE32 ((SI_MAX_SIZE/sizeof(int)) - 3)
14
15	typedef struct compat_siginfo {
16	int si_signo;
17	int si_code;
18	int si_errno;
19
20	union {
21	int _pad[SI_PAD_SIZE32];
22
23	/* kill() */
24	struct {
25	compat_pid_t _pid; /* sender's pid */
26	compat_uid_t _uid; /* sender's uid */
27	} _kill;
28
29	/* SIGCHLD */
30	struct {
31	compat_pid_t _pid; /* which child */
32	compat_uid_t _uid; /* sender's uid */
33	int _status; /* exit code */
34	compat_clock_t _utime;
35	compat_clock_t _stime;
36	} _sigchld;
37
38	/* IRIX SIGCHLD */
39	struct {
40	compat_pid_t _pid; /* which child */
41	compat_clock_t _utime;
42	int _status; /* exit code */
43	compat_clock_t _stime;
44	} _irix_sigchld;
45
46	/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
47	struct {
48	s32 _addr; /* faulting insn/memory ref. */
49	} _sigfault;
50
51	/* SIGPOLL, SIGXFSZ (To do ...) */
52	struct {
53	int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
54	int _fd;
55	} _sigpoll;
56
57	/* POSIX.1b timers */
58	struct {
59	timer_t _tid; /* timer id */
60	int _overrun; /* overrun count */
61	compat_sigval_t _sigval;/* same as below */
62	int _sys_private; /* not to be passed to user */
63	} _timer;
64
65	/* POSIX.1b signals */
66	struct {
67	compat_pid_t _pid; /* sender's pid */
68	compat_uid_t _uid; /* sender's uid */
69	compat_sigval_t _sigval;
70	} _rt;
71
72	} _sifields;
73	} compat_siginfo_t;
74
75	static inline int __copy_conv_sigset_to_user(compat_sigset_t __user *d,	13	static inline int __copy_conv_sigset_to_user(compat_sigset_t __user *d,
76	const sigset_t *s)	14	const sigset_t *s)
77	{	15	{
78	int err;	16	int err;
79		17
80	BUG_ON(sizeof(d) != sizeof(s));	18	BUG_ON(sizeof(d) != sizeof(s));
81	BUG_ON(_NSIG_WORDS != 2);	19	BUG_ON(_NSIG_WORDS != 2);
82		20
83	err = __put_user(s->sig[0], &d->sig[0]);	21	err = __put_user(s->sig[0], &d->sig[0]);
84	err \|= __put_user(s->sig[0] >> 32, &d->sig[1]);	22	err \|= __put_user(s->sig[0] >> 32, &d->sig[1]);
85	err \|= __put_user(s->sig[1], &d->sig[2]);	23	err \|= __put_user(s->sig[1], &d->sig[2]);
86	err \|= __put_user(s->sig[1] >> 32, &d->sig[3]);	24	err \|= __put_user(s->sig[1] >> 32, &d->sig[3]);
87		25
88	return err;	26	return err;
89	}	27	}
90		28
91	static inline int __copy_conv_sigset_from_user(sigset_t *d,	29	static inline int __copy_conv_sigset_from_user(sigset_t *d,
92	const compat_sigset_t __user *s)	30	const compat_sigset_t __user *s)
93	{	31	{
94	int err;	32	int err;
95	union sigset_u {	33	union sigset_u {
96	sigset_t s;	34	sigset_t s;
97	compat_sigset_t c;	35	compat_sigset_t c;
98	} u = (union sigset_u ) d;	36	} u = (union sigset_u ) d;
99		37
100	BUG_ON(sizeof(d) != sizeof(s));	38	BUG_ON(sizeof(d) != sizeof(s));
101	BUG_ON(_NSIG_WORDS != 2);	39	BUG_ON(_NSIG_WORDS != 2);
102		40
103	#ifdef CONFIG_CPU_BIG_ENDIAN	41	#ifdef CONFIG_CPU_BIG_ENDIAN
104	err = __get_user(u->c.sig[1], &s->sig[0]);	42	err = __get_user(u->c.sig[1], &s->sig[0]);
105	err \|= __get_user(u->c.sig[0], &s->sig[1]);	43	err \|= __get_user(u->c.sig[0], &s->sig[1]);
106	err \|= __get_user(u->c.sig[3], &s->sig[2]);	44	err \|= __get_user(u->c.sig[3], &s->sig[2]);
107	err \|= __get_user(u->c.sig[2], &s->sig[3]);	45	err \|= __get_user(u->c.sig[2], &s->sig[3]);
108	#endif	46	#endif
109	#ifdef CONFIG_CPU_LITTLE_ENDIAN	47	#ifdef CONFIG_CPU_LITTLE_ENDIAN
110	err = __get_user(u->c.sig[0], &s->sig[0]);	48	err = __get_user(u->c.sig[0], &s->sig[0]);
111	err \|= __get_user(u->c.sig[1], &s->sig[1]);	49	err \|= __get_user(u->c.sig[1], &s->sig[1]);
112	err \|= __get_user(u->c.sig[2], &s->sig[2]);	50	err \|= __get_user(u->c.sig[2], &s->sig[2]);
113	err \|= __get_user(u->c.sig[3], &s->sig[3]);	51	err \|= __get_user(u->c.sig[3], &s->sig[3]);
114	#endif	52	#endif
115		53
116	return err;	54	return err;
117	}	55	}
118		56
119	#endif /* __ASM_COMPAT_SIGNAL_H */	57	#endif /* __ASM_COMPAT_SIGNAL_H */
120		58

arch/mips/include/asm/compat.h

Diff comments View file @ 751f409

 #ifndef _ASM_COMPAT_H
 #define _ASM_COMPAT_H
 /*
  * Architecture specific compatibility types
  */
 #include <linux/thread_info.h>
 #include <linux/types.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
 #define COMPAT_USER_HZ		100
 #define COMPAT_UTS_MACHINE	"mips\0\0\0"
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef s32		compat_suseconds_t;
 typedef s32		compat_pid_t;
 typedef s32		__compat_uid_t;
 typedef s32		__compat_gid_t;
 typedef __compat_uid_t	__compat_uid32_t;
 typedef __compat_gid_t	__compat_gid32_t;
 typedef u32		compat_mode_t;
 typedef u32		compat_ino_t;
 typedef u32		compat_dev_t;
 typedef s32		compat_off_t;
 typedef s64		compat_loff_t;
 typedef u32		compat_nlink_t;
 typedef s32		compat_ipc_pid_t;
 typedef s32		compat_daddr_t;
 typedef s32		compat_caddr_t;
 typedef struct {
 	s32	val[2];
 } compat_fsid_t;
 typedef s32		compat_timer_t;
 typedef s32		compat_key_t;
 typedef s32		compat_int_t;
 typedef s32		compat_long_t;
 typedef s64		compat_s64;
 typedef u32		compat_uint_t;
 typedef u32		compat_ulong_t;
 typedef u64		compat_u64;
+typedef u32		compat_uptr_t;
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 struct compat_stat {
 	compat_dev_t	st_dev;
 	s32		st_pad1[3];
 	compat_ino_t	st_ino;
 	compat_mode_t	st_mode;
 	compat_nlink_t	st_nlink;
 	__compat_uid_t	st_uid;
 	__compat_gid_t	st_gid;
 	compat_dev_t	st_rdev;
 	s32		st_pad2[2];
 	compat_off_t	st_size;
 	s32		st_pad3;
 	compat_time_t	st_atime;
 	s32		st_atime_nsec;
 	compat_time_t	st_mtime;
 	s32		st_mtime_nsec;
 	compat_time_t	st_ctime;
 	s32		st_ctime_nsec;
 	s32		st_blksize;
 	s32		st_blocks;
 	s32		st_pad4[14];
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	s32		l_sysid;
 	compat_pid_t	l_pid;
 	short		__unused;
 	s32		pad[4];
 };
 #define F_GETLK64	33
 #define F_SETLK64	34
 #define F_SETLKW64	35
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 };
 struct compat_statfs {
 	int		f_type;
 	int		f_bsize;
 	int		f_frsize;
 	int		f_blocks;
 	int		f_bfree;
 	int		f_files;
 	int		f_ffree;
 	int		f_bavail;
 	compat_fsid_t	f_fsid;
 	int		f_namelen;
 	int		f_flags;
 	int		f_spare[5];
 };
 #define COMPAT_RLIM_INFINITY	0x7fffffffUL
 typedef u32		compat_old_sigset_t;	/* at least 32 bits */
 #define _COMPAT_NSIG		128		/* Don't ask !$@#% ...  */
 #define _COMPAT_NSIG_BPW	32
 typedef u32		compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+#define SI_PAD_SIZE32	(128/sizeof(int) - 3)
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_code;
+	int si_errno;
+	union {
+		int _pad[SI_PAD_SIZE32];
+		/* kill() */
+		struct {
+			compat_pid_t _pid;	/* sender's pid */
+			__compat_uid_t _uid;	/* sender's uid */
+		} _kill;
+		/* SIGCHLD */
+		struct {
+			compat_pid_t _pid;	/* which child */
+			__compat_uid_t _uid;	/* sender's uid */
+			int _status;		/* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* IRIX SIGCHLD */
+		struct {
+			compat_pid_t _pid;	/* which child */
+			compat_clock_t _utime;
+			int _status;		/* exit code */
+			compat_clock_t _stime;
+		} _irix_sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+		struct {
+			s32 _addr; /* faulting insn/memory ref. */
+		} _sigfault;
+		/* SIGPOLL, SIGXFSZ (To do ...)  */
+		struct {
+			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+		/* POSIX.1b timers */
+		struct {
+			timer_t _tid;		/* timer id */
+			int _overrun;		/* overrun count */
+			compat_sigval_t _sigval;/* same as below */
+			int _sys_private;       /* not to be passed to user */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			compat_pid_t _pid;	/* sender's pid */
+			__compat_uid_t _uid;	/* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	/* cast to a __user pointer via "unsigned long" makes sparse happy */
 	return (void __user *)(unsigned long)(long)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	struct pt_regs *regs = (struct pt_regs *)
 		((unsigned long) current_thread_info() + THREAD_SIZE - 32) - 1;
 	return (void __user *) (regs->regs[29] - len);
 }
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid32_t uid;
 	__compat_gid32_t gid;
 	__compat_uid32_t cuid;
 	__compat_gid32_t cgid;
 	compat_mode_t mode;
 	unsigned short seq;
 	unsigned short __pad2;
 	compat_ulong_t __unused1;
 	compat_ulong_t __unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	compat_time_t	sem_otime;
 	compat_time_t	sem_ctime;
 	compat_ulong_t	sem_nsems;
 	compat_ulong_t	__unused1;
 	compat_ulong_t	__unused2;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 #ifndef CONFIG_CPU_LITTLE_ENDIAN
 	compat_ulong_t	__unused1;
 #endif
 	compat_time_t	msg_stime;
 #ifdef CONFIG_CPU_LITTLE_ENDIAN
 	compat_ulong_t	__unused1;
 #endif
 #ifndef CONFIG_CPU_LITTLE_ENDIAN
 	compat_ulong_t	__unused2;
 #endif
 	compat_time_t	msg_rtime;
 #ifdef CONFIG_CPU_LITTLE_ENDIAN
 	compat_ulong_t	__unused2;
 #endif
 #ifndef CONFIG_CPU_LITTLE_ENDIAN
 	compat_ulong_t	__unused3;
 #endif
 	compat_time_t	msg_ctime;
 #ifdef CONFIG_CPU_LITTLE_ENDIAN
 	compat_ulong_t	__unused3;
 #endif
 	compat_ulong_t	msg_cbytes;
 	compat_ulong_t	msg_qnum;
 	compat_ulong_t	msg_qbytes;
 	compat_pid_t	msg_lspid;
 	compat_pid_t	msg_lrpid;
 	compat_ulong_t	__unused4;
 	compat_ulong_t	__unused5;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	compat_size_t	shm_segsz;
 	compat_time_t	shm_atime;
 	compat_time_t	shm_dtime;
 	compat_time_t	shm_ctime;
 	compat_pid_t	shm_cpid;
 	compat_pid_t	shm_lpid;
 	compat_ulong_t	shm_nattch;
 	compat_ulong_t	__unused1;
 	compat_ulong_t	__unused2;
 };
 static inline int is_compat_task(void)
 {
 	return test_thread_flag(TIF_32BIT);
 }
 #endif /* _ASM_COMPAT_H */

arch/parisc/include/asm/compat.h

Diff comments View file @ 751f409

 #ifndef _ASM_PARISC_COMPAT_H
 #define _ASM_PARISC_COMPAT_H
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/thread_info.h>
 #define COMPAT_USER_HZ 		100
 #define COMPAT_UTS_MACHINE	"parisc\0\0"
 typedef u32	compat_size_t;
 typedef s32	compat_ssize_t;
 typedef s32	compat_time_t;
 typedef s32	compat_clock_t;
 typedef s32	compat_pid_t;
 typedef u32	__compat_uid_t;
 typedef u32	__compat_gid_t;
 typedef u32	__compat_uid32_t;
 typedef u32	__compat_gid32_t;
 typedef u16	compat_mode_t;
 typedef u32	compat_ino_t;
 typedef u32	compat_dev_t;
 typedef s32	compat_off_t;
 typedef s64	compat_loff_t;
 typedef u16	compat_nlink_t;
 typedef u16	compat_ipc_pid_t;
 typedef s32	compat_daddr_t;
 typedef u32	compat_caddr_t;
 typedef s32	compat_timer_t;
 typedef s32	compat_int_t;
 typedef s32	compat_long_t;
 typedef s64	compat_s64;
 typedef u32	compat_uint_t;
 typedef u32	compat_ulong_t;
 typedef u64	compat_u64;
+typedef u32	compat_uptr_t;
 struct compat_timespec {
 	compat_time_t		tv_sec;
 	s32			tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t		tv_sec;
 	s32			tv_usec;
 };
 struct compat_stat {
 	compat_dev_t		st_dev;	/* dev_t is 32 bits on parisc */
 	compat_ino_t		st_ino;	/* 32 bits */
 	compat_mode_t		st_mode;	/* 16 bits */
 	compat_nlink_t  	st_nlink;	/* 16 bits */
 	u16			st_reserved1;	/* old st_uid */
 	u16			st_reserved2;	/* old st_gid */
 	compat_dev_t		st_rdev;
 	compat_off_t		st_size;
 	compat_time_t		st_atime;
 	u32			st_atime_nsec;
 	compat_time_t		st_mtime;
 	u32			st_mtime_nsec;
 	compat_time_t		st_ctime;
 	u32			st_ctime_nsec;
 	s32			st_blksize;
 	s32			st_blocks;
 	u32			__unused1;	/* ACL stuff */
 	compat_dev_t		__unused2;	/* network */
 	compat_ino_t		__unused3;	/* network */
 	u32			__unused4;	/* cnodes */
 	u16			__unused5;	/* netsite */
 	short			st_fstype;
 	compat_dev_t		st_realdev;
 	u16			st_basemode;
 	u16			st_spareshort;
 	__compat_uid32_t	st_uid;
 	__compat_gid32_t	st_gid;
 	u32			st_spare4[3];
 };
 struct compat_flock {
 	short			l_type;
 	short			l_whence;
 	compat_off_t		l_start;
 	compat_off_t		l_len;
 	compat_pid_t		l_pid;
 };
 struct compat_flock64 {
 	short			l_type;
 	short			l_whence;
 	compat_loff_t		l_start;
 	compat_loff_t		l_len;
 	compat_pid_t		l_pid;
 };
 struct compat_statfs {
 	s32		f_type;
 	s32		f_bsize;
 	s32		f_blocks;
 	s32		f_bfree;
 	s32		f_bavail;
 	s32		f_files;
 	s32		f_ffree;
 	__kernel_fsid_t	f_fsid;
 	s32		f_namelen;
 	s32		f_frsize;
 	s32		f_flags;
 	s32		f_spare[4];
 };
 struct compat_sigcontext {
 	compat_int_t sc_flags;
 	compat_int_t sc_gr[32]; /* PSW in sc_gr[0] */
 	u64 sc_fr[32];
 	compat_int_t sc_iasq[2];
 	compat_int_t sc_iaoq[2];
 	compat_int_t sc_sar; /* cr11 */
 };
 #define COMPAT_RLIM_INFINITY 0xffffffff
 typedef u32		compat_old_sigset_t;	/* at least 32 bits */
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32		compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_errno;
+	int si_code;
+	union {
+		int _pad[128/sizeof(int) - 3];
+		/* kill() */
+		struct {
+			unsigned int _pid;      /* sender's pid */
+			unsigned int _uid;      /* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;            /* timer id */
+			int _overrun;           /* overrun count */
+			char _pad[sizeof(unsigned int) - sizeof(int)];
+			compat_sigval_t _sigval;        /* same as below */
+			int _sys_private;       /* not to be passed to user */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			unsigned int _pid;      /* sender's pid */
+			unsigned int _uid;      /* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			unsigned int _pid;      /* which child */
+			unsigned int _uid;      /* sender's uid */
+			int _status;            /* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+		struct {
+			unsigned int _addr;     /* faulting insn/memory ref. */
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef	u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(unsigned long)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 static __inline__ void __user *arch_compat_alloc_user_space(long len)
 {
 	struct pt_regs *regs = &current->thread.regs;
 	return (void __user *)regs->gr[30];
 }
 static inline int __is_compat_task(struct task_struct *t)
 {
 	return test_ti_thread_flag(task_thread_info(t), TIF_32BIT);
 }
 static inline int is_compat_task(void)
 {
 	return __is_compat_task(current);
 }
 #endif /* _ASM_PARISC_COMPAT_H */

arch/parisc/kernel/signal32.h

Diff comments View file @ 751f409

 /*
  *    Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org>
  *    Copyright (C) 2003 Carlos O'Donell <carlos at parisc-linux.org>
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 2 of the License, or
  *    (at your option) any later version.
  *
  *    This program is distributed in the hope that it will be useful,
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *    GNU General Public License for more details.
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #ifndef _PARISC64_KERNEL_SIGNAL32_H
 #define _PARISC64_KERNEL_SIGNAL32_H
 #include <linux/compat.h>
 typedef compat_uptr_t compat_sighandler_t;
 typedef struct compat_sigaltstack {
         compat_uptr_t ss_sp;
         compat_int_t ss_flags;
         compat_size_t ss_size;
 } compat_stack_t;
 /* Most things should be clean enough to redefine this at will, if care
    is taken to make libc match.  */
 struct compat_sigaction {
         compat_sighandler_t sa_handler;
         compat_uint_t sa_flags;
         compat_sigset_t sa_mask;               /* mask last for extensibility */
 };
 /* 32-bit ucontext as seen from an 64-bit kernel */
 struct compat_ucontext {
         compat_uint_t uc_flags;
         compat_uptr_t uc_link;
         compat_stack_t uc_stack;        /* struct compat_sigaltstack (12 bytes)*/
         /* FIXME: Pad out to get uc_mcontext to start at an 8-byte aligned boundary */
         compat_uint_t pad[1];
         struct compat_sigcontext uc_mcontext;
         compat_sigset_t uc_sigmask;     /* mask last for extensibility */
 };
 /* ELF32 signal handling */
 struct k_sigaction32 {
 	struct compat_sigaction sa;
 };
-typedef struct compat_siginfo {
-        int si_signo;
-        int si_errno;
-        int si_code;
-        union {
-                int _pad[((128/sizeof(int)) - 3)];
-                /* kill() */
-                struct {
-                        unsigned int _pid;      /* sender's pid */
-                        unsigned int _uid;      /* sender's uid */
-                } _kill;
-                /* POSIX.1b timers */
-                struct {
-                        compat_timer_t _tid;            /* timer id */
-                        int _overrun;           /* overrun count */
-                        char _pad[sizeof(unsigned int) - sizeof(int)];
-                        compat_sigval_t _sigval;        /* same as below */
-                        int _sys_private;       /* not to be passed to user */
-                } _timer;
-                /* POSIX.1b signals */
-                struct {
-                        unsigned int _pid;      /* sender's pid */
-                        unsigned int _uid;      /* sender's uid */
-                        compat_sigval_t _sigval;
-                } _rt;
-                /* SIGCHLD */
-                struct {
-                        unsigned int _pid;      /* which child */
-                        unsigned int _uid;      /* sender's uid */
-                        int _status;            /* exit code */
-                        compat_clock_t _utime;
-                        compat_clock_t _stime;
-                } _sigchld;
-                /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
-                struct {
-                        unsigned int _addr;     /* faulting insn/memory ref. */
-                } _sigfault;
-                /* SIGPOLL */
-                struct {
-                        int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
-                        int _fd;
-                } _sigpoll;
-        } _sifields;
-} compat_siginfo_t;
 int copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from);
 int copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from);
 /* In a deft move of uber-hackery, we decide to carry the top half of all
  * 64-bit registers in a non-portable, non-ABI, hidden structure.
  * Userspace can read the hidden structure if it *wants* but is never
  * guaranteed to be in the same place. In fact the uc_sigmask from the
  * ucontext_t structure may push the hidden register file downards
  */
 struct compat_regfile {
         /* Upper half of all the 64-bit registers that were truncated
            on a copy to a 32-bit userspace */
         compat_int_t rf_gr[32];
         compat_int_t rf_iasq[2];
         compat_int_t rf_iaoq[2];
         compat_int_t rf_sar;
 };
 #define COMPAT_SIGRETURN_TRAMP 4
 #define COMPAT_SIGRESTARTBLOCK_TRAMP 5
 #define COMPAT_TRAMP_SIZE (COMPAT_SIGRETURN_TRAMP + \
 				COMPAT_SIGRESTARTBLOCK_TRAMP)
 struct compat_rt_sigframe {
         /* XXX: Must match trampoline size in arch/parisc/kernel/signal.c
                 Secondary to that it must protect the ERESTART_RESTARTBLOCK
                 trampoline we left on the stack (we were bad and didn't
                 change sp so we could run really fast.) */
         compat_uint_t tramp[COMPAT_TRAMP_SIZE];
         compat_siginfo_t info;
         struct compat_ucontext uc;
         /* Hidden location of truncated registers, *must* be last. */
         struct compat_regfile regs;
 };
 /*
  * The 32-bit ABI wants at least 48 bytes for a function call frame:
  * 16 bytes for arg0-arg3, and 32 bytes for magic (the only part of
  * which Linux/parisc uses is sp-20 for the saved return pointer...)
  * Then, the stack pointer must be rounded to a cache line (64 bytes).
  */
 #define SIGFRAME32              64
 #define FUNCTIONCALLFRAME32     48
 #define PARISC_RT_SIGFRAME_SIZE32 (((sizeof(struct compat_rt_sigframe) + FUNCTIONCALLFRAME32) + SIGFRAME32) & -SIGFRAME32)
 void sigset_32to64(sigset_t *s64, compat_sigset_t *s32);
 void sigset_64to32(compat_sigset_t *s32, sigset_t *s64);
 int do_sigaltstack32 (const compat_stack_t __user *uss32,
 		compat_stack_t __user *uoss32, unsigned long sp);
 long restore_sigcontext32(struct compat_sigcontext __user *sc,
 		struct compat_regfile __user *rf,
 		struct pt_regs *regs);
 long setup_sigcontext32(struct compat_sigcontext __user *sc,
 		struct compat_regfile __user *rf,
 		struct pt_regs *regs, int in_syscall);
 #endif

arch/powerpc/include/asm/compat.h

Diff comments View file @ 751f409

 #ifndef _ASM_POWERPC_COMPAT_H
 #define _ASM_POWERPC_COMPAT_H
 #ifdef __KERNEL__
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #include <linux/sched.h>
 #define COMPAT_USER_HZ		100
 #define COMPAT_UTS_MACHINE	"ppc\0\0"
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef s32		compat_pid_t;
 typedef u32		__compat_uid_t;
 typedef u32		__compat_gid_t;
 typedef u32		__compat_uid32_t;
 typedef u32		__compat_gid32_t;
 typedef u32		compat_mode_t;
 typedef u32		compat_ino_t;
 typedef u32		compat_dev_t;
 typedef s32		compat_off_t;
 typedef s64		compat_loff_t;
 typedef s16		compat_nlink_t;
 typedef u16		compat_ipc_pid_t;
 typedef s32		compat_daddr_t;
 typedef u32		compat_caddr_t;
 typedef __kernel_fsid_t	compat_fsid_t;
 typedef s32		compat_key_t;
 typedef s32		compat_timer_t;
 typedef s32		compat_int_t;
 typedef s32		compat_long_t;
 typedef s64		compat_s64;
 typedef u32		compat_uint_t;
 typedef u32		compat_ulong_t;
 typedef u64		compat_u64;
+typedef u32		compat_uptr_t;
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 struct compat_stat {
 	compat_dev_t	st_dev;
 	compat_ino_t	st_ino;
 	compat_mode_t	st_mode;
 	compat_nlink_t	st_nlink;
 	__compat_uid32_t	st_uid;
 	__compat_gid32_t	st_gid;
 	compat_dev_t	st_rdev;
 	compat_off_t	st_size;
 	compat_off_t	st_blksize;
 	compat_off_t	st_blocks;
 	compat_time_t	st_atime;
 	u32		st_atime_nsec;
 	compat_time_t	st_mtime;
 	u32		st_mtime_nsec;
 	compat_time_t	st_ctime;
 	u32		st_ctime_nsec;
 	u32		__unused4[2];
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	compat_pid_t	l_pid;
 };
 #define F_GETLK64	12	/*  using 'struct flock64' */
 #define F_SETLK64	13
 #define F_SETLKW64	14
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 };
 struct compat_statfs {
 	int		f_type;
 	int		f_bsize;
 	int		f_blocks;
 	int		f_bfree;
 	int		f_bavail;
 	int		f_files;
 	int		f_ffree;
 	compat_fsid_t	f_fsid;
 	int		f_namelen;	/* SunOS ignores this field. */
 	int		f_frsize;
 	int		f_flags;
 	int		f_spare[4];
 };
 #define COMPAT_RLIM_OLD_INFINITY	0x7fffffff
 #define COMPAT_RLIM_INFINITY		0xffffffff
 typedef u32		compat_old_sigset_t;
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32		compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+#define SI_PAD_SIZE32	(128/sizeof(int) - 3)
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_errno;
+	int si_code;
+	union {
+		int _pad[SI_PAD_SIZE32];
+		/* kill() */
+		struct {
+			compat_pid_t _pid;		/* sender's pid */
+			__compat_uid_t _uid;		/* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;		/* timer id */
+			int _overrun;			/* overrun count */
+			compat_sigval_t _sigval;	/* same as below */
+			int _sys_private;	/* not to be passed to user */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			compat_pid_t _pid;		/* sender's pid */
+			__compat_uid_t _uid;		/* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			compat_pid_t _pid;		/* which child */
+			__compat_uid_t _uid;		/* sender's uid */
+			int _status;			/* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
+		struct {
+			unsigned int _addr; /* faulting insn/memory ref. */
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef	u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(unsigned long)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	struct pt_regs *regs = current->thread.regs;
 	unsigned long usp = regs->gpr[1];
 	/*
 	 * We can't access below the stack pointer in the 32bit ABI and
 	 * can access 288 bytes in the 64bit ABI
 	 */
 	if (!is_32bit_task())
 		usp -= 288;
 	return (void __user *) (usp - len);
 }
 /*
  * ipc64_perm is actually 32/64bit clean but since the compat layer refers to
  * it we may as well define it.
  */
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid_t uid;
 	__compat_gid_t gid;
 	__compat_uid_t cuid;
 	__compat_gid_t cgid;
 	compat_mode_t mode;
 	unsigned int seq;
 	unsigned int __pad2;
 	unsigned long __unused1;	/* yes they really are 64bit pads */
 	unsigned long __unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	unsigned int __unused1;
 	compat_time_t sem_otime;
 	unsigned int __unused2;
 	compat_time_t sem_ctime;
 	compat_ulong_t sem_nsems;
 	compat_ulong_t __unused3;
 	compat_ulong_t __unused4;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 	unsigned int __unused1;
 	compat_time_t msg_stime;
 	unsigned int __unused2;
 	compat_time_t msg_rtime;
 	unsigned int __unused3;
 	compat_time_t msg_ctime;
 	compat_ulong_t msg_cbytes;
 	compat_ulong_t msg_qnum;
 	compat_ulong_t msg_qbytes;
 	compat_pid_t msg_lspid;
 	compat_pid_t msg_lrpid;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	unsigned int __unused1;
 	compat_time_t shm_atime;
 	unsigned int __unused2;
 	compat_time_t shm_dtime;
 	unsigned int __unused3;
 	compat_time_t shm_ctime;
 	unsigned int __unused4;
 	compat_size_t shm_segsz;
 	compat_pid_t shm_cpid;
 	compat_pid_t shm_lpid;
 	compat_ulong_t shm_nattch;
 	compat_ulong_t __unused5;
 	compat_ulong_t __unused6;
 };
 static inline int is_compat_task(void)
 {
 	return is_32bit_task();
 }
 #endif /* __KERNEL__ */
 #endif /* _ASM_POWERPC_COMPAT_H */

arch/powerpc/include/asm/siginfo.h

Diff comments View file @ 751f409

 #ifndef _ASM_POWERPC_SIGINFO_H
 #define _ASM_POWERPC_SIGINFO_H
 /*
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 #ifdef __powerpc64__
 #    define __ARCH_SI_PREAMBLE_SIZE	(4 * sizeof(int))
-#    define SI_PAD_SIZE32		((SI_MAX_SIZE/sizeof(int)) - 3)
 #endif
 #include <asm-generic/siginfo.h>
 #undef NSIGTRAP
 #define NSIGTRAP	4
 #endif	/* _ASM_POWERPC_SIGINFO_H */

arch/powerpc/kernel/ppc32.h

Diff comments View file @ 751f409

 #ifndef _PPC64_PPC32_H
 #define _PPC64_PPC32_H
 #include <linux/compat.h>
 #include <asm/siginfo.h>
 #include <asm/signal.h>
 /*
  * Data types and macros for providing 32b PowerPC support.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */
 /* These are here to support 32-bit syscalls on a 64-bit kernel. */
-typedef struct compat_siginfo {
-	int si_signo;
-	int si_errno;
-	int si_code;
-	union {
-		int _pad[SI_PAD_SIZE32];
-		/* kill() */
-		struct {
-			compat_pid_t _pid;		/* sender's pid */
-			compat_uid_t _uid;		/* sender's uid */
-		} _kill;
-		/* POSIX.1b timers */
-		struct {
-			compat_timer_t _tid;			/* timer id */
-			int _overrun;			/* overrun count */
-			compat_sigval_t _sigval;		/* same as below */
-			int _sys_private;		/* not to be passed to user */
-		} _timer;
-		/* POSIX.1b signals */
-		struct {
-			compat_pid_t _pid;		/* sender's pid */
-			compat_uid_t _uid;		/* sender's uid */
-			compat_sigval_t _sigval;
-		} _rt;
-		/* SIGCHLD */
-		struct {
-			compat_pid_t _pid;		/* which child */
-			compat_uid_t _uid;		/* sender's uid */
-			int _status;			/* exit code */
-			compat_clock_t _utime;
-			compat_clock_t _stime;
-		} _sigchld;
-		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
-		struct {
-			unsigned int _addr; /* faulting insn/memory ref. */
-		} _sigfault;
-		/* SIGPOLL */
-		struct {
-			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
-			int _fd;
-		} _sigpoll;
-	} _sifields;
-} compat_siginfo_t;
 #define __old_sigaction32	old_sigaction32
 struct __old_sigaction32 {
 	compat_uptr_t		sa_handler;
 	compat_old_sigset_t  	sa_mask;
 	unsigned int    	sa_flags;
 	compat_uptr_t		sa_restorer;     /* not used by Linux/SPARC yet */
 };
 struct sigaction32 {
        compat_uptr_t  sa_handler;	/* Really a pointer, but need to deal with 32 bits */
        unsigned int sa_flags;
        compat_uptr_t sa_restorer;	/* Another 32 bit pointer */
        compat_sigset_t sa_mask;		/* A 32 bit mask */
 };
 typedef struct sigaltstack_32 {
 	unsigned int ss_sp;
 	int ss_flags;
 	compat_size_t ss_size;
 } stack_32_t;
 struct pt_regs32 {
 	unsigned int gpr[32];
 	unsigned int nip;
 	unsigned int msr;
 	unsigned int orig_gpr3;		/* Used for restarting system calls */
 	unsigned int ctr;
 	unsigned int link;
 	unsigned int xer;
 	unsigned int ccr;
 	unsigned int mq;		/* 601 only (not used at present) */
 	unsigned int trap;		/* Reason for being here */
 	unsigned int dar;		/* Fault registers */
 	unsigned int dsisr;
 	unsigned int result;		/* Result of a system call */
 };
 struct sigcontext32 {
 	unsigned int	_unused[4];
 	int		signal;
 	compat_uptr_t	handler;
 	unsigned int	oldmask;
 	compat_uptr_t	regs;  /* 4 byte pointer to the pt_regs32 structure. */
 };
 struct mcontext32 {
 	elf_gregset_t32		mc_gregs;
 	elf_fpregset_t		mc_fregs;
 	unsigned int		mc_pad[2];
 	elf_vrregset_t32	mc_vregs __attribute__((__aligned__(16)));
 	elf_vsrreghalf_t32      mc_vsregs __attribute__((__aligned__(16)));
 };
 struct ucontext32 {
 	unsigned int	  	uc_flags;
 	unsigned int 	  	uc_link;
 	stack_32_t	 	uc_stack;
 	int		 	uc_pad[7];
 	compat_uptr_t		uc_regs;	/* points to uc_mcontext field */
 	compat_sigset_t	 	uc_sigmask;	/* mask last for extensibility */
 	/* glibc has 1024-bit signal masks, ours are 64-bit */
 	int		 	uc_maskext[30];
 	int		 	uc_pad2[3];
 	struct mcontext32	uc_mcontext;
 };
 #endif  /* _PPC64_PPC32_H */

arch/s390/include/asm/compat.h

Diff comments View file @ 751f409

 #ifndef _ASM_S390X_COMPAT_H
 #define _ASM_S390X_COMPAT_H
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/thread_info.h>
 #define PSW32_MASK_PER		0x40000000UL
 #define PSW32_MASK_DAT		0x04000000UL
 #define PSW32_MASK_IO		0x02000000UL
 #define PSW32_MASK_EXT		0x01000000UL
 #define PSW32_MASK_KEY		0x00F00000UL
 #define PSW32_MASK_BASE		0x00080000UL	/* Always one */
 #define PSW32_MASK_MCHECK	0x00040000UL
 #define PSW32_MASK_WAIT		0x00020000UL
 #define PSW32_MASK_PSTATE	0x00010000UL
 #define PSW32_MASK_ASC		0x0000C000UL
 #define PSW32_MASK_CC		0x00003000UL
 #define PSW32_MASK_PM		0x00000f00UL
 #define PSW32_MASK_USER		0x00003F00UL
 #define PSW32_ADDR_AMODE	0x80000000UL
 #define PSW32_ADDR_INSN		0x7FFFFFFFUL
 #define PSW32_DEFAULT_KEY	(((u32) PAGE_DEFAULT_ACC) << 20)
 #define PSW32_ASC_PRIMARY	0x00000000UL
 #define PSW32_ASC_ACCREG	0x00004000UL
 #define PSW32_ASC_SECONDARY	0x00008000UL
 #define PSW32_ASC_HOME		0x0000C000UL
 extern u32 psw32_user_bits;
 #define COMPAT_USER_HZ		100
 #define COMPAT_UTS_MACHINE	"s390\0\0\0\0"
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef s32		compat_pid_t;
 typedef u16		__compat_uid_t;
 typedef u16		__compat_gid_t;
 typedef u32		__compat_uid32_t;
 typedef u32		__compat_gid32_t;
 typedef u16		compat_mode_t;
 typedef u32		compat_ino_t;
 typedef u16		compat_dev_t;
 typedef s32		compat_off_t;
 typedef s64		compat_loff_t;
 typedef u16		compat_nlink_t;
 typedef u16		compat_ipc_pid_t;
 typedef s32		compat_daddr_t;
 typedef u32		compat_caddr_t;
 typedef __kernel_fsid_t	compat_fsid_t;
 typedef s32		compat_key_t;
 typedef s32		compat_timer_t;
 typedef s32		compat_int_t;
 typedef s32		compat_long_t;
 typedef s64		compat_s64;
 typedef u32		compat_uint_t;
 typedef u32		compat_ulong_t;
 typedef u64		compat_u64;
+typedef u32		compat_uptr_t;
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 struct compat_stat {
 	compat_dev_t	st_dev;
 	u16		__pad1;
 	compat_ino_t	st_ino;
 	compat_mode_t	st_mode;
 	compat_nlink_t	st_nlink;
 	__compat_uid_t	st_uid;
 	__compat_gid_t	st_gid;
 	compat_dev_t	st_rdev;
 	u16		__pad2;
 	u32		st_size;
 	u32		st_blksize;
 	u32		st_blocks;
 	u32		st_atime;
 	u32		st_atime_nsec;
 	u32		st_mtime;
 	u32		st_mtime_nsec;
 	u32		st_ctime;
 	u32		st_ctime_nsec;
 	u32		__unused4;
 	u32		__unused5;
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	compat_pid_t	l_pid;
 };
 #define F_GETLK64       12
 #define F_SETLK64       13
 #define F_SETLKW64      14
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 };
 struct compat_statfs {
 	s32		f_type;
 	s32		f_bsize;
 	s32		f_blocks;
 	s32		f_bfree;
 	s32		f_bavail;
 	s32		f_files;
 	s32		f_ffree;
 	compat_fsid_t	f_fsid;
 	s32		f_namelen;
 	s32		f_frsize;
 	s32		f_flags;
 	s32		f_spare[5];
 };
 #define COMPAT_RLIM_OLD_INFINITY	0x7fffffff
 #define COMPAT_RLIM_INFINITY		0xffffffff
 typedef u32		compat_old_sigset_t;	/* at least 32 bits */
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32		compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+typedef struct compat_siginfo {
+	int	si_signo;
+	int	si_errno;
+	int	si_code;
+	union {
+		int _pad[128/sizeof(int) - 3];
+		/* kill() */
+		struct {
+			pid_t	_pid;	/* sender's pid */
+			uid_t	_uid;	/* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;		/* timer id */
+			int _overrun;			/* overrun count */
+			compat_sigval_t _sigval;	/* same as below */
+			int _sys_private;	/* not to be passed to user */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			pid_t			_pid;	/* sender's pid */
+			uid_t			_uid;	/* sender's uid */
+			compat_sigval_t		_sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			pid_t			_pid;	/* which child */
+			uid_t			_uid;	/* sender's uid */
+			int			_status;/* exit code */
+			compat_clock_t		_utime;
+			compat_clock_t		_stime;
+		} _sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+		struct {
+			__u32	_addr;	/* faulting insn/memory ref. - pointer */
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			int	_band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int	_fd;
+		} _sigpoll;
+	} _sifields;
+} compat_siginfo_t;
+/*
+ * How these fields are to be accessed.
+ */
+#define si_pid		_sifields._kill._pid
+#define si_uid		_sifields._kill._uid
+#define si_status	_sifields._sigchld._status
+#define si_utime	_sifields._sigchld._utime
+#define si_stime	_sifields._sigchld._stime
+#define si_value	_sifields._rt._sigval
+#define si_int		_sifields._rt._sigval.sival_int
+#define si_ptr		_sifields._rt._sigval.sival_ptr
+#define si_addr		_sifields._sigfault._addr
+#define si_band		_sifields._sigpoll._band
+#define si_fd		_sifields._sigpoll._fd
+#define si_tid		_sifields._timer._tid
+#define si_overrun	_sifields._timer._overrun
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef	u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(unsigned long)(uptr & 0x7fffffffUL);
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 #ifdef CONFIG_COMPAT
 static inline int is_compat_task(void)
 {
 	return is_32bit_task();
 }
 #endif
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	unsigned long stack;
 	stack = KSTK_ESP(current);
 	if (is_compat_task())
 		stack &= 0x7fffffffUL;
 	return (void __user *) (stack - len);
 }
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid32_t uid;
 	__compat_gid32_t gid;
 	__compat_uid32_t cuid;
 	__compat_gid32_t cgid;
 	compat_mode_t mode;
 	unsigned short __pad1;
 	unsigned short seq;
 	unsigned short __pad2;
 	unsigned int __unused1;
 	unsigned int __unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	compat_time_t  sem_otime;
 	compat_ulong_t __pad1;
 	compat_time_t  sem_ctime;
 	compat_ulong_t __pad2;
 	compat_ulong_t sem_nsems;
 	compat_ulong_t __unused1;
 	compat_ulong_t __unused2;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 	compat_time_t   msg_stime;
 	compat_ulong_t __pad1;
 	compat_time_t   msg_rtime;
 	compat_ulong_t __pad2;
 	compat_time_t   msg_ctime;
 	compat_ulong_t __pad3;
 	compat_ulong_t msg_cbytes;
 	compat_ulong_t msg_qnum;
 	compat_ulong_t msg_qbytes;
 	compat_pid_t   msg_lspid;
 	compat_pid_t   msg_lrpid;
 	compat_ulong_t __unused1;
 	compat_ulong_t __unused2;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	compat_size_t  shm_segsz;
 	compat_time_t  shm_atime;
 	compat_ulong_t __pad1;
 	compat_time_t  shm_dtime;
 	compat_ulong_t __pad2;
 	compat_time_t  shm_ctime;
 	compat_ulong_t __pad3;
 	compat_pid_t   shm_cpid;
 	compat_pid_t   shm_lpid;
 	compat_ulong_t shm_nattch;
 	compat_ulong_t __unused1;
 	compat_ulong_t __unused2;
 };
 #endif /* _ASM_S390X_COMPAT_H */

arch/s390/kernel/compat_linux.h

Diff comments View file @ 751f409

 #ifndef _ASM_S390X_S390_H
 #define _ASM_S390X_S390_H
 #include <linux/compat.h>
 #include <linux/socket.h>
 #include <linux/syscalls.h>
 /* Macro that masks the high order bit of an 32 bit pointer and converts it*/
 /*       to a 64 bit pointer */
 #define A(__x) ((unsigned long)((__x) & 0x7FFFFFFFUL))
 #define AA(__x)				\
 	((unsigned long)(__x))
 /* Now 32bit compatibility types */
 struct ipc_kludge_32 {
         __u32   msgp;                           /* pointer              */
         __s32   msgtyp;
 };
 struct old_sigaction32 {
        __u32			sa_handler;	/* Really a pointer, but need to deal with 32 bits */
        compat_old_sigset_t	sa_mask;	/* A 32 bit mask */
        __u32			sa_flags;
        __u32			sa_restorer;	/* Another 32 bit pointer */
 };
-typedef struct compat_siginfo {
-	int	si_signo;
-	int	si_errno;
-	int	si_code;
-	union {
-		int _pad[((128/sizeof(int)) - 3)];
-		/* kill() */
-		struct {
-			pid_t	_pid;	/* sender's pid */
-			uid_t	_uid;	/* sender's uid */
-		} _kill;
-		/* POSIX.1b timers */
-		struct {
-			compat_timer_t _tid;		/* timer id */
-			int _overrun;		/* overrun count */
-			compat_sigval_t _sigval;	/* same as below */
-			int _sys_private;       /* not to be passed to user */
-		} _timer;
-		/* POSIX.1b signals */
-		struct {
-			pid_t			_pid;	/* sender's pid */
-			uid_t			_uid;	/* sender's uid */
-			compat_sigval_t		_sigval;
-		} _rt;
-		/* SIGCHLD */
-		struct {
-			pid_t			_pid;	/* which child */
-			uid_t			_uid;	/* sender's uid */
-			int			_status;/* exit code */
-			compat_clock_t		_utime;
-			compat_clock_t		_stime;
-		} _sigchld;
-		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
-		struct {
-			__u32	_addr;	/* faulting insn/memory ref. - pointer */
-		} _sigfault;
-		/* SIGPOLL */
-		struct {
-			int	_band;	/* POLL_IN, POLL_OUT, POLL_MSG */
-			int	_fd;
-		} _sigpoll;
-	} _sifields;
-} compat_siginfo_t;
-/*
- * How these fields are to be accessed.
- */
-#define si_pid		_sifields._kill._pid
-#define si_uid		_sifields._kill._uid
-#define si_status	_sifields._sigchld._status
-#define si_utime	_sifields._sigchld._utime
-#define si_stime	_sifields._sigchld._stime
-#define si_value	_sifields._rt._sigval
-#define si_int		_sifields._rt._sigval.sival_int
-#define si_ptr		_sifields._rt._sigval.sival_ptr
-#define si_addr		_sifields._sigfault._addr
-#define si_band		_sifields._sigpoll._band
-#define si_fd		_sifields._sigpoll._fd
-#define si_tid		_sifields._timer._tid
-#define si_overrun	_sifields._timer._overrun
 /* asm/sigcontext.h */
 typedef union
 {
 	__u64   d;
 	__u32   f;
 } freg_t32;
 typedef struct
 {
 	unsigned int	fpc;
 	freg_t32	fprs[__NUM_FPRS];
 } _s390_fp_regs32;
 typedef struct
 {
         __u32   mask;
         __u32	addr;
 } _psw_t32 __attribute__ ((aligned(8)));
 typedef struct
 {
 	_psw_t32	psw;
 	__u32		gprs[__NUM_GPRS];
 	__u32		acrs[__NUM_ACRS];
 } _s390_regs_common32;
 typedef struct
 {
 	_s390_regs_common32 regs;
 	_s390_fp_regs32     fpregs;
 } _sigregs32;
 #define _SIGCONTEXT_NSIG32	64
 #define _SIGCONTEXT_NSIG_BPW32	32
 #define __SIGNAL_FRAMESIZE32	96
 #define _SIGMASK_COPY_SIZE32	(sizeof(u32)*2)
 struct sigcontext32
 {
 	__u32	oldmask[_COMPAT_NSIG_WORDS];
 	__u32	sregs;				/* pointer */
 };
 /* asm/signal.h */
 struct sigaction32 {
 	__u32		sa_handler;		/* pointer */
 	__u32		sa_flags;
         __u32		sa_restorer;		/* pointer */
 	compat_sigset_t	sa_mask;        /* mask last for extensibility */
 };
 typedef struct {
 	__u32			ss_sp;		/* pointer */
 	int			ss_flags;
 	compat_size_t		ss_size;
 } stack_t32;
 /* asm/ucontext.h */
 struct ucontext32 {
 	__u32			uc_flags;
 	__u32			uc_link;	/* pointer */
 	stack_t32		uc_stack;
 	_sigregs32		uc_mcontext;
 	compat_sigset_t		uc_sigmask;	/* mask last for extensibility */
 };
 struct stat64_emu31;
 struct mmap_arg_struct_emu31;
 struct fadvise64_64_args;
 struct old_sigaction32;
 struct old_sigaction32;
 long sys32_chown16(const char __user * filename, u16 user, u16 group);
 long sys32_lchown16(const char __user * filename, u16 user, u16 group);
 long sys32_fchown16(unsigned int fd, u16 user, u16 group);
 long sys32_setregid16(u16 rgid, u16 egid);
 long sys32_setgid16(u16 gid);
 long sys32_setreuid16(u16 ruid, u16 euid);
 long sys32_setuid16(u16 uid);
 long sys32_setresuid16(u16 ruid, u16 euid, u16 suid);
 long sys32_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid);
 long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid);
 long sys32_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid);
 long sys32_setfsuid16(u16 uid);
 long sys32_setfsgid16(u16 gid);
 long sys32_getgroups16(int gidsetsize, u16 __user *grouplist);
 long sys32_setgroups16(int gidsetsize, u16 __user *grouplist);
 long sys32_getuid16(void);
 long sys32_geteuid16(void);
 long sys32_getgid16(void);
 long sys32_getegid16(void);
 long sys32_ipc(u32 call, int first, int second, int third, u32 ptr);
 long sys32_truncate64(const char __user * path, unsigned long high,
 		      unsigned long low);
 long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low);
 long sys32_sched_rr_get_interval(compat_pid_t pid,
 				 struct compat_timespec __user *interval);
 long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
 			  compat_sigset_t __user *oset, size_t sigsetsize);
 long sys32_rt_sigpending(compat_sigset_t __user *set, size_t sigsetsize);
 long sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo);
 long sys32_execve(const char __user *name, compat_uptr_t __user *argv,
 		  compat_uptr_t __user *envp);
 long sys32_init_module(void __user *umod, unsigned long len,
 		       const char __user *uargs);
 long sys32_delete_module(const char __user *name_user, unsigned int flags);
 long sys32_pread64(unsigned int fd, char __user *ubuf, size_t count,
 		   u32 poshi, u32 poslo);
 long sys32_pwrite64(unsigned int fd, const char __user *ubuf,
 		    size_t count, u32 poshi, u32 poslo);
 compat_ssize_t sys32_readahead(int fd, u32 offhi, u32 offlo, s32 count);
 long sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset,
 		    size_t count);
 long sys32_sendfile64(int out_fd, int in_fd, compat_loff_t __user *offset,
 		      s32 count);
 long sys32_stat64(const char __user * filename, struct stat64_emu31 __user * statbuf);
 long sys32_lstat64(const char __user * filename,
 		   struct stat64_emu31 __user * statbuf);
 long sys32_fstat64(unsigned long fd, struct stat64_emu31 __user * statbuf);
 long sys32_fstatat64(unsigned int dfd, const char __user *filename,
 		     struct stat64_emu31 __user* statbuf, int flag);
 unsigned long old32_mmap(struct mmap_arg_struct_emu31 __user *arg);
 long sys32_mmap2(struct mmap_arg_struct_emu31 __user *arg);
 long sys32_read(unsigned int fd, char __user * buf, size_t count);
 long sys32_write(unsigned int fd, const char __user * buf, size_t count);
 long sys32_fadvise64(int fd, loff_t offset, size_t len, int advise);
 long sys32_fadvise64_64(struct fadvise64_64_args __user *args);
 long sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
 		     struct old_sigaction32 __user *oact);
 long sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
 			struct sigaction32 __user *oact, size_t sigsetsize);
 long sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss);
 #endif /* _ASM_S390X_S390_H */

arch/sparc/include/asm/compat.h

Diff comments View file @ 751f409

 #ifndef _ASM_SPARC64_COMPAT_H
 #define _ASM_SPARC64_COMPAT_H
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #define COMPAT_USER_HZ		100
 #define COMPAT_UTS_MACHINE	"sparc\0\0"
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef s32		compat_pid_t;
 typedef u16		__compat_uid_t;
 typedef u16		__compat_gid_t;
 typedef u32		__compat_uid32_t;
 typedef u32		__compat_gid32_t;
 typedef u16		compat_mode_t;
 typedef u32		compat_ino_t;
 typedef u16		compat_dev_t;
 typedef s32		compat_off_t;
 typedef s64		compat_loff_t;
 typedef s16		compat_nlink_t;
 typedef u16		compat_ipc_pid_t;
 typedef s32		compat_daddr_t;
 typedef u32		compat_caddr_t;
 typedef __kernel_fsid_t	compat_fsid_t;
 typedef s32		compat_key_t;
 typedef s32		compat_timer_t;
 typedef s32		compat_int_t;
 typedef s32		compat_long_t;
 typedef s64		compat_s64;
 typedef u32		compat_uint_t;
 typedef u32		compat_ulong_t;
 typedef u64		compat_u64;
+typedef u32		compat_uptr_t;
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 struct compat_stat {
 	compat_dev_t	st_dev;
 	compat_ino_t	st_ino;
 	compat_mode_t	st_mode;
 	compat_nlink_t	st_nlink;
 	__compat_uid_t	st_uid;
 	__compat_gid_t	st_gid;
 	compat_dev_t	st_rdev;
 	compat_off_t	st_size;
 	compat_time_t	st_atime;
 	compat_ulong_t	st_atime_nsec;
 	compat_time_t	st_mtime;
 	compat_ulong_t	st_mtime_nsec;
 	compat_time_t	st_ctime;
 	compat_ulong_t	st_ctime_nsec;
 	compat_off_t	st_blksize;
 	compat_off_t	st_blocks;
 	u32		__unused4[2];
 };
 struct compat_stat64 {
 	unsigned long long	st_dev;
 	unsigned long long	st_ino;
 	unsigned int	st_mode;
 	unsigned int	st_nlink;
 	unsigned int	st_uid;
 	unsigned int	st_gid;
 	unsigned long long	st_rdev;
 	unsigned char	__pad3[8];
 	long long	st_size;
 	unsigned int	st_blksize;
 	unsigned char	__pad4[8];
 	unsigned int	st_blocks;
 	unsigned int	st_atime;
 	unsigned int	st_atime_nsec;
 	unsigned int	st_mtime;
 	unsigned int	st_mtime_nsec;
 	unsigned int	st_ctime;
 	unsigned int	st_ctime_nsec;
 	unsigned int	__unused4;
 	unsigned int	__unused5;
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	compat_pid_t	l_pid;
 	short		__unused;
 };
 #define F_GETLK64	12
 #define F_SETLK64	13
 #define F_SETLKW64	14
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 	short		__unused;
 };
 struct compat_statfs {
 	int		f_type;
 	int		f_bsize;
 	int		f_blocks;
 	int		f_bfree;
 	int		f_bavail;
 	int		f_files;
 	int		f_ffree;
 	compat_fsid_t	f_fsid;
 	int		f_namelen;	/* SunOS ignores this field. */
 	int		f_frsize;
 	int		f_flags;
 	int		f_spare[4];
 };
 #define COMPAT_RLIM_INFINITY 0x7fffffff
 typedef u32		compat_old_sigset_t;
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32		compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+#define SI_PAD_SIZE32	(128/sizeof(int) - 3)
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_errno;
+	int si_code;
+	union {
+		int _pad[SI_PAD_SIZE32];
+		/* kill() */
+		struct {
+			compat_pid_t _pid;		/* sender's pid */
+			unsigned int _uid;		/* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;		/* timer id */
+			int _overrun;			/* overrun count */
+			compat_sigval_t _sigval;	/* same as below */
+			int _sys_private;	/* not to be passed to user */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			compat_pid_t _pid;		/* sender's pid */
+			unsigned int _uid;		/* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			compat_pid_t _pid;		/* which child */
+			unsigned int _uid;		/* sender's uid */
+			int _status;			/* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
+		struct {
+			u32 _addr; /* faulting insn/memory ref. */
+			int _trapno;
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef	u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(unsigned long)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	struct pt_regs *regs = current_thread_info()->kregs;
 	unsigned long usp = regs->u_regs[UREG_I6];
 	if (!(test_thread_flag(TIF_32BIT)))
 		usp += STACK_BIAS;
 	else
 		usp &= 0xffffffffUL;
 	usp -= len;
 	usp &= ~0x7UL;
 	return (void __user *) usp;
 }
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid32_t uid;
 	__compat_gid32_t gid;
 	__compat_uid32_t cuid;
 	__compat_gid32_t cgid;
 	unsigned short __pad1;
 	compat_mode_t mode;
 	unsigned short __pad2;
 	unsigned short seq;
 	unsigned long __unused1;	/* yes they really are 64bit pads */
 	unsigned long __unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	unsigned int	__pad1;
 	compat_time_t	sem_otime;
 	unsigned int	__pad2;
 	compat_time_t	sem_ctime;
 	u32		sem_nsems;
 	u32		__unused1;
 	u32		__unused2;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 	unsigned int	__pad1;
 	compat_time_t	msg_stime;
 	unsigned int	__pad2;
 	compat_time_t	msg_rtime;
 	unsigned int	__pad3;
 	compat_time_t	msg_ctime;
 	unsigned int	msg_cbytes;
 	unsigned int	msg_qnum;
 	unsigned int	msg_qbytes;
 	compat_pid_t	msg_lspid;
 	compat_pid_t	msg_lrpid;
 	unsigned int	__unused1;
 	unsigned int	__unused2;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	unsigned int	__pad1;
 	compat_time_t	shm_atime;
 	unsigned int	__pad2;
 	compat_time_t	shm_dtime;
 	unsigned int	__pad3;
 	compat_time_t	shm_ctime;
 	compat_size_t	shm_segsz;
 	compat_pid_t	shm_cpid;
 	compat_pid_t	shm_lpid;
 	unsigned int	shm_nattch;
 	unsigned int	__unused1;
 	unsigned int	__unused2;
 };
 static inline int is_compat_task(void)
 {
 	return test_thread_flag(TIF_32BIT);
 }
 #endif /* _ASM_SPARC64_COMPAT_H */

arch/sparc/include/asm/siginfo.h

Diff comments View file @ 751f409

 #ifndef __SPARC_SIGINFO_H
 #define __SPARC_SIGINFO_H
 #if defined(__sparc__) && defined(__arch64__)
-#define SI_PAD_SIZE32	((SI_MAX_SIZE/sizeof(int)) - 3)
 #define __ARCH_SI_PREAMBLE_SIZE	(4 * sizeof(int))
 #define __ARCH_SI_BAND_T int
 #endif /* defined(__sparc__) && defined(__arch64__) */
 #define __ARCH_SI_TRAPNO
 #include <asm-generic/siginfo.h>
 #ifdef __KERNEL__
 #ifdef CONFIG_COMPAT
 struct compat_siginfo;
 #endif /* CONFIG_COMPAT */
 #endif /* __KERNEL__ */
 #define SI_NOINFO	32767		/* no information in siginfo_t */
 /*
  * SIGEMT si_codes
  */
 #define EMT_TAGOVF	(__SI_FAULT|1)	/* tag overflow */
 #define NSIGEMT		1
 #endif /* !(__SPARC_SIGINFO_H) */

arch/sparc/kernel/signal32.c

Diff comments View file @ 751f409

 /*  arch/sparc64/kernel/signal32.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
  *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
  *  Copyright (C) 1997,1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
  */
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/signal.h>
 #include <linux/errno.h>
 #include <linux/wait.h>
 #include <linux/ptrace.h>
 #include <linux/unistd.h>
 #include <linux/mm.h>
 #include <linux/tty.h>
 #include <linux/binfmts.h>
 #include <linux/compat.h>
 #include <linux/bitops.h>
 #include <linux/tracehook.h>
 #include <asm/uaccess.h>
 #include <asm/ptrace.h>
 #include <asm/pgtable.h>
 #include <asm/psrcompat.h>
 #include <asm/fpumacro.h>
 #include <asm/visasm.h>
 #include <asm/compat_signal.h>
 #include <asm/switch_to.h>
 #include "sigutil.h"
 /* This magic should be in g_upper[0] for all upper parts
  * to be valid.
  */
 #define SIGINFO_EXTRA_V8PLUS_MAGIC	0x130e269
 typedef struct {
 	unsigned int g_upper[8];
 	unsigned int o_upper[8];
 	unsigned int asi;
 } siginfo_extra_v8plus_t;
 struct signal_frame32 {
 	struct sparc_stackf32	ss;
 	__siginfo32_t		info;
 	/* __siginfo_fpu_t * */ u32 fpu_save;
 	unsigned int		insns[2];
 	unsigned int		extramask[_COMPAT_NSIG_WORDS - 1];
 	unsigned int		extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
 	/* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
 	siginfo_extra_v8plus_t	v8plus;
 	/* __siginfo_rwin_t * */u32 rwin_save;
 } __attribute__((aligned(8)));
-typedef struct compat_siginfo{
-	int si_signo;
-	int si_errno;
-	int si_code;
-	union {
-		int _pad[SI_PAD_SIZE32];
-		/* kill() */
-		struct {
-			compat_pid_t _pid;		/* sender's pid */
-			unsigned int _uid;		/* sender's uid */
-		} _kill;
-		/* POSIX.1b timers */
-		struct {
-			compat_timer_t _tid;			/* timer id */
-			int _overrun;			/* overrun count */
-			compat_sigval_t _sigval;		/* same as below */
-			int _sys_private;		/* not to be passed to user */
-		} _timer;
-		/* POSIX.1b signals */
-		struct {
-			compat_pid_t _pid;		/* sender's pid */
-			unsigned int _uid;		/* sender's uid */
-			compat_sigval_t _sigval;
-		} _rt;
-		/* SIGCHLD */
-		struct {
-			compat_pid_t _pid;		/* which child */
-			unsigned int _uid;		/* sender's uid */
-			int _status;			/* exit code */
-			compat_clock_t _utime;
-			compat_clock_t _stime;
-		} _sigchld;
-		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
-		struct {
-			u32 _addr; /* faulting insn/memory ref. */
-			int _trapno;
-		} _sigfault;
-		/* SIGPOLL */
-		struct {
-			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
-			int _fd;
-		} _sigpoll;
-	} _sifields;
-}compat_siginfo_t;
 struct rt_signal_frame32 {
 	struct sparc_stackf32	ss;
 	compat_siginfo_t	info;
 	struct pt_regs32	regs;
 	compat_sigset_t		mask;
 	/* __siginfo_fpu_t * */ u32 fpu_save;
 	unsigned int		insns[2];
 	stack_t32		stack;
 	unsigned int		extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
 	/* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
 	siginfo_extra_v8plus_t	v8plus;
 	/* __siginfo_rwin_t * */u32 rwin_save;
 } __attribute__((aligned(8)));
 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 {
 	int err;
 	if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 		return -EFAULT;
 	/* If you change siginfo_t structure, please be sure
 	   this code is fixed accordingly.
 	   It should never copy any pad contained in the structure
 	   to avoid security leaks, but must copy the generic
 	   3 ints plus the relevant union member.
 	   This routine must convert siginfo from 64bit to 32bit as well
 	   at the same time.  */
 	err = __put_user(from->si_signo, &to->si_signo);
 	err |= __put_user(from->si_errno, &to->si_errno);
 	err |= __put_user((short)from->si_code, &to->si_code);
 	if (from->si_code < 0)
 		err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 	else {
 		switch (from->si_code >> 16) {
 		case __SI_TIMER >> 16:
 			err |= __put_user(from->si_tid, &to->si_tid);
 			err |= __put_user(from->si_overrun, &to->si_overrun);
 			err |= __put_user(from->si_int, &to->si_int);
 			break;
 		case __SI_CHLD >> 16:
 			err |= __put_user(from->si_utime, &to->si_utime);
 			err |= __put_user(from->si_stime, &to->si_stime);
 			err |= __put_user(from->si_status, &to->si_status);
 		default:
 			err |= __put_user(from->si_pid, &to->si_pid);
 			err |= __put_user(from->si_uid, &to->si_uid);
 			break;
 		case __SI_FAULT >> 16:
 			err |= __put_user(from->si_trapno, &to->si_trapno);
 			err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 			break;
 		case __SI_POLL >> 16:
 			err |= __put_user(from->si_band, &to->si_band);
 			err |= __put_user(from->si_fd, &to->si_fd);
 			break;
 		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 		case __SI_MESGQ >> 16:
 			err |= __put_user(from->si_pid, &to->si_pid);
 			err |= __put_user(from->si_uid, &to->si_uid);
 			err |= __put_user(from->si_int, &to->si_int);
 			break;
 		}
 	}
 	return err;
 }
 /* CAUTION: This is just a very minimalist implementation for the
  *          sake of compat_sys_rt_sigqueueinfo()
  */
 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 {
 	if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
 		return -EFAULT;
 	if (copy_from_user(to, from, 3*sizeof(int)) ||
 	    copy_from_user(to->_sifields._pad, from->_sifields._pad,
 			   SI_PAD_SIZE))
 		return -EFAULT;
 	return 0;
 }
 void do_sigreturn32(struct pt_regs *regs)
 {
 	struct signal_frame32 __user *sf;
 	compat_uptr_t fpu_save;
 	compat_uptr_t rwin_save;
 	unsigned int psr;
 	unsigned pc, npc;
 	sigset_t set;
 	unsigned seta[_COMPAT_NSIG_WORDS];
 	int err, i;
 	/* Always make any pending restarted system calls return -EINTR */
 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 	synchronize_user_stack();
 	regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 	sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
 	/* 1. Make sure we are not getting garbage from the user */
 	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
 	    (((unsigned long) sf) & 3))
 		goto segv;
 	if (get_user(pc, &sf->info.si_regs.pc) ||
 	    __get_user(npc, &sf->info.si_regs.npc))
 		goto segv;
 	if ((pc | npc) & 3)
 		goto segv;
 	if (test_thread_flag(TIF_32BIT)) {
 		pc &= 0xffffffff;
 		npc &= 0xffffffff;
 	}
 	regs->tpc = pc;
 	regs->tnpc = npc;
 	/* 2. Restore the state */
 	err = __get_user(regs->y, &sf->info.si_regs.y);
 	err |= __get_user(psr, &sf->info.si_regs.psr);
 	for (i = UREG_G1; i <= UREG_I7; i++)
 		err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 	if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 		err |= __get_user(i, &sf->v8plus.g_upper[0]);
 		if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 			unsigned long asi;
 			for (i = UREG_G1; i <= UREG_I7; i++)
 				err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 			err |= __get_user(asi, &sf->v8plus.asi);
 			regs->tstate &= ~TSTATE_ASI;
 			regs->tstate |= ((asi & 0xffUL) << 24UL);
 		}
 	}
 	/* User can only change condition codes in %tstate. */
 	regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 	regs->tstate |= psr_to_tstate_icc(psr);
 	/* Prevent syscall restart.  */
 	pt_regs_clear_syscall(regs);
 	err |= __get_user(fpu_save, &sf->fpu_save);
 	if (!err && fpu_save)
 		err |= restore_fpu_state(regs, compat_ptr(fpu_save));
 	err |= __get_user(rwin_save, &sf->rwin_save);
 	if (!err && rwin_save) {
 		if (restore_rwin_state(compat_ptr(rwin_save)))
 			goto segv;
 	}
 	err |= __get_user(seta[0], &sf->info.si_mask);
 	err |= copy_from_user(seta+1, &sf->extramask,
 			      (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 	if (err)
 	    	goto segv;
 	switch (_NSIG_WORDS) {
 		case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
 		case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
 		case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
 		case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
 	}
 	set_current_blocked(&set);
 	return;
 segv:
 	force_sig(SIGSEGV, current);
 }
 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
 {
 	struct rt_signal_frame32 __user *sf;
 	unsigned int psr, pc, npc, u_ss_sp;
 	compat_uptr_t fpu_save;
 	compat_uptr_t rwin_save;
 	mm_segment_t old_fs;
 	sigset_t set;
 	compat_sigset_t seta;
 	stack_t st;
 	int err, i;
 	/* Always make any pending restarted system calls return -EINTR */
 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 	synchronize_user_stack();
 	regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 	sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
 	/* 1. Make sure we are not getting garbage from the user */
 	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
 	    (((unsigned long) sf) & 3))
 		goto segv;
 	if (get_user(pc, &sf->regs.pc) ||
 	    __get_user(npc, &sf->regs.npc))
 		goto segv;
 	if ((pc | npc) & 3)
 		goto segv;
 	if (test_thread_flag(TIF_32BIT)) {
 		pc &= 0xffffffff;
 		npc &= 0xffffffff;
 	}
 	regs->tpc = pc;
 	regs->tnpc = npc;
 	/* 2. Restore the state */
 	err = __get_user(regs->y, &sf->regs.y);
 	err |= __get_user(psr, &sf->regs.psr);
 	for (i = UREG_G1; i <= UREG_I7; i++)
 		err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 	if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 		err |= __get_user(i, &sf->v8plus.g_upper[0]);
 		if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 			unsigned long asi;
 			for (i = UREG_G1; i <= UREG_I7; i++)
 				err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 			err |= __get_user(asi, &sf->v8plus.asi);
 			regs->tstate &= ~TSTATE_ASI;
 			regs->tstate |= ((asi & 0xffUL) << 24UL);
 		}
 	}
 	/* User can only change condition codes in %tstate. */
 	regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 	regs->tstate |= psr_to_tstate_icc(psr);
 	/* Prevent syscall restart.  */
 	pt_regs_clear_syscall(regs);
 	err |= __get_user(fpu_save, &sf->fpu_save);
 	if (!err && fpu_save)
 		err |= restore_fpu_state(regs, compat_ptr(fpu_save));
 	err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
 	err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
 	st.ss_sp = compat_ptr(u_ss_sp);
 	err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
 	err |= __get_user(st.ss_size, &sf->stack.ss_size);
 	if (err)
 		goto segv;
 	/* It is more difficult to avoid calling this function than to
 	   call it and ignore errors.  */
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
 	set_fs(old_fs);
 	err |= __get_user(rwin_save, &sf->rwin_save);
 	if (!err && rwin_save) {
 		if (restore_rwin_state(compat_ptr(rwin_save)))
 			goto segv;
 	}
 	switch (_NSIG_WORDS) {
 		case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
 		case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
 		case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
 		case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
 	}
 	set_current_blocked(&set);
 	return;
 segv:
 	force_sig(SIGSEGV, current);
 }
 /* Checks if the fp is valid */
 static int invalid_frame_pointer(void __user *fp, int fplen)
 {
 	if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
 		return 1;
 	return 0;
 }
 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
 {
 	unsigned long sp;
 	regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 	sp = regs->u_regs[UREG_FP];
 	/*
 	 * If we are on the alternate signal stack and would overflow it, don't.
 	 * Return an always-bogus address instead so we will die with SIGSEGV.
 	 */
 	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
 		return (void __user *) -1L;
 	/* This is the X/Open sanctioned signal stack switching.  */
 	if (sa->sa_flags & SA_ONSTACK) {
 		if (sas_ss_flags(sp) == 0)
 			sp = current->sas_ss_sp + current->sas_ss_size;
 	}
 	sp -= framesize;
 	/* Always align the stack frame.  This handles two cases.  First,
 	 * sigaltstack need not be mindful of platform specific stack
 	 * alignment.  Second, if we took this signal because the stack
 	 * is not aligned properly, we'd like to take the signal cleanly
 	 * and report that.
 	 */
 	sp &= ~15UL;
 	return (void __user *) sp;
 }
 /* The I-cache flush instruction only works in the primary ASI, which
  * right now is the nucleus, aka. kernel space.
  *
  * Therefore we have to kick the instructions out using the kernel
  * side linear mapping of the physical address backing the user
  * instructions.
  */
 static void flush_signal_insns(unsigned long address)
 {
 	unsigned long pstate, paddr;
 	pte_t *ptep, pte;
 	pgd_t *pgdp;
 	pud_t *pudp;
 	pmd_t *pmdp;
 	/* Commit all stores of the instructions we are about to flush.  */
 	wmb();
 	/* Disable cross-call reception.  In this way even a very wide
 	 * munmap() on another cpu can't tear down the page table
 	 * hierarchy from underneath us, since that can't complete
 	 * until the IPI tlb flush returns.
 	 */
 	__asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
 	__asm__ __volatile__("wrpr %0, %1, %%pstate"
 				: : "r" (pstate), "i" (PSTATE_IE));
 	pgdp = pgd_offset(current->mm, address);
 	if (pgd_none(*pgdp))
 		goto out_irqs_on;
 	pudp = pud_offset(pgdp, address);
 	if (pud_none(*pudp))
 		goto out_irqs_on;
 	pmdp = pmd_offset(pudp, address);
 	if (pmd_none(*pmdp))
 		goto out_irqs_on;
 	ptep = pte_offset_map(pmdp, address);
 	pte = *ptep;
 	if (!pte_present(pte))
 		goto out_unmap;
 	paddr = (unsigned long) page_address(pte_page(pte));
 	__asm__ __volatile__("flush	%0 + %1"
 			     : /* no outputs */
 			     : "r" (paddr),
 			       "r" (address & (PAGE_SIZE - 1))
 			     : "memory");
 out_unmap:
 	pte_unmap(ptep);
 out_irqs_on:
 	__asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
 }
 static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
 			 int signo, sigset_t *oldset)
 {
 	struct signal_frame32 __user *sf;
 	int i, err, wsaved;
 	void __user *tail;
 	int sigframe_size;
 	u32 psr;
 	unsigned int seta[_COMPAT_NSIG_WORDS];
 	/* 1. Make sure everything is clean */
 	synchronize_user_stack();
 	save_and_clear_fpu();
 	wsaved = get_thread_wsaved();
 	sigframe_size = sizeof(*sf);
 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 		sigframe_size += sizeof(__siginfo_fpu_t);
 	if (wsaved)
 		sigframe_size += sizeof(__siginfo_rwin_t);
 	sf = (struct signal_frame32 __user *)
 		get_sigframe(&ka->sa, regs, sigframe_size);
 	if (invalid_frame_pointer(sf, sigframe_size))
 		goto sigill;
 	tail = (sf + 1);
 	/* 2. Save the current process state */
 	if (test_thread_flag(TIF_32BIT)) {
 		regs->tpc &= 0xffffffff;
 		regs->tnpc &= 0xffffffff;
 	}
 	err  = put_user(regs->tpc, &sf->info.si_regs.pc);
 	err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
 	err |= __put_user(regs->y, &sf->info.si_regs.y);
 	psr = tstate_to_psr(regs->tstate);
 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 		psr |= PSR_EF;
 	err |= __put_user(psr, &sf->info.si_regs.psr);
 	for (i = 0; i < 16; i++)
 		err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 	err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 	err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 	for (i = 1; i < 16; i++)
 		err |= __put_user(((u32 *)regs->u_regs)[2*i],
 				  &sf->v8plus.g_upper[i]);
 	err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
 			  &sf->v8plus.asi);
 	if (psr & PSR_EF) {
 		__siginfo_fpu_t __user *fp = tail;
 		tail += sizeof(*fp);
 		err |= save_fpu_state(regs, fp);
 		err |= __put_user((u64)fp, &sf->fpu_save);
 	} else {
 		err |= __put_user(0, &sf->fpu_save);
 	}
 	if (wsaved) {
 		__siginfo_rwin_t __user *rwp = tail;
 		tail += sizeof(*rwp);
 		err |= save_rwin_state(wsaved, rwp);
 		err |= __put_user((u64)rwp, &sf->rwin_save);
 		set_thread_wsaved(0);
 	} else {
 		err |= __put_user(0, &sf->rwin_save);
 	}
 	switch (_NSIG_WORDS) {
 	case 4: seta[7] = (oldset->sig[3] >> 32);
 	        seta[6] = oldset->sig[3];
 	case 3: seta[5] = (oldset->sig[2] >> 32);
 	        seta[4] = oldset->sig[2];
 	case 2: seta[3] = (oldset->sig[1] >> 32);
 	        seta[2] = oldset->sig[1];
 	case 1: seta[1] = (oldset->sig[0] >> 32);
 	        seta[0] = oldset->sig[0];
 	}
 	err |= __put_user(seta[0], &sf->info.si_mask);
 	err |= __copy_to_user(sf->extramask, seta + 1,
 			      (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 	if (!wsaved) {
 		err |= copy_in_user((u32 __user *)sf,
 				    (u32 __user *)(regs->u_regs[UREG_FP]),
 				    sizeof(struct reg_window32));
 	} else {
 		struct reg_window *rp;
 		rp = &current_thread_info()->reg_window[wsaved - 1];
 		for (i = 0; i < 8; i++)
 			err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
 		for (i = 0; i < 6; i++)
 			err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
 		err |= __put_user(rp->ins[6], &sf->ss.fp);
 		err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
 	}
 	if (err)
 		goto sigsegv;
 	/* 3. signal handler back-trampoline and parameters */
 	regs->u_regs[UREG_FP] = (unsigned long) sf;
 	regs->u_regs[UREG_I0] = signo;
 	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
 	/* 4. signal handler */
 	regs->tpc = (unsigned long) ka->sa.sa_handler;
 	regs->tnpc = (regs->tpc + 4);
 	if (test_thread_flag(TIF_32BIT)) {
 		regs->tpc &= 0xffffffff;
 		regs->tnpc &= 0xffffffff;
 	}
 	/* 5. return to kernel instructions */
 	if (ka->ka_restorer) {
 		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 	} else {
 		unsigned long address = ((unsigned long)&(sf->insns[0]));
 		regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 		err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
 		err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
 		if (err)
 			goto sigsegv;
 		flush_signal_insns(address);
 	}
 	return 0;
 sigill:
 	do_exit(SIGILL);
 	return -EINVAL;
 sigsegv:
 	force_sigsegv(signo, current);
 	return -EFAULT;
 }
 static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
 			    unsigned long signr, sigset_t *oldset,
 			    siginfo_t *info)
 {
 	struct rt_signal_frame32 __user *sf;
 	int i, err, wsaved;
 	void __user *tail;
 	int sigframe_size;
 	u32 psr;
 	compat_sigset_t seta;
 	/* 1. Make sure everything is clean */
 	synchronize_user_stack();
 	save_and_clear_fpu();
 	wsaved = get_thread_wsaved();
 	sigframe_size = sizeof(*sf);
 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 		sigframe_size += sizeof(__siginfo_fpu_t);
 	if (wsaved)
 		sigframe_size += sizeof(__siginfo_rwin_t);
 	sf = (struct rt_signal_frame32 __user *)
 		get_sigframe(&ka->sa, regs, sigframe_size);
 	if (invalid_frame_pointer(sf, sigframe_size))
 		goto sigill;
 	tail = (sf + 1);
 	/* 2. Save the current process state */
 	if (test_thread_flag(TIF_32BIT)) {
 		regs->tpc &= 0xffffffff;
 		regs->tnpc &= 0xffffffff;
 	}
 	err  = put_user(regs->tpc, &sf->regs.pc);
 	err |= __put_user(regs->tnpc, &sf->regs.npc);
 	err |= __put_user(regs->y, &sf->regs.y);
 	psr = tstate_to_psr(regs->tstate);
 	if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 		psr |= PSR_EF;
 	err |= __put_user(psr, &sf->regs.psr);
 	for (i = 0; i < 16; i++)
 		err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 	err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 	err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 	for (i = 1; i < 16; i++)
 		err |= __put_user(((u32 *)regs->u_regs)[2*i],
 				  &sf->v8plus.g_upper[i]);
 	err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
 			  &sf->v8plus.asi);
 	if (psr & PSR_EF) {
 		__siginfo_fpu_t __user *fp = tail;
 		tail += sizeof(*fp);
 		err |= save_fpu_state(regs, fp);
 		err |= __put_user((u64)fp, &sf->fpu_save);
 	} else {
 		err |= __put_user(0, &sf->fpu_save);
 	}
 	if (wsaved) {
 		__siginfo_rwin_t __user *rwp = tail;
 		tail += sizeof(*rwp);
 		err |= save_rwin_state(wsaved, rwp);
 		err |= __put_user((u64)rwp, &sf->rwin_save);
 		set_thread_wsaved(0);
 	} else {
 		err |= __put_user(0, &sf->rwin_save);
 	}
 	/* Update the siginfo structure.  */
 	err |= copy_siginfo_to_user32(&sf->info, info);
 	/* Setup sigaltstack */
 	err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
 	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
 	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
 	switch (_NSIG_WORDS) {
 	case 4: seta.sig[7] = (oldset->sig[3] >> 32);
 		seta.sig[6] = oldset->sig[3];
 	case 3: seta.sig[5] = (oldset->sig[2] >> 32);
 		seta.sig[4] = oldset->sig[2];
 	case 2: seta.sig[3] = (oldset->sig[1] >> 32);
 		seta.sig[2] = oldset->sig[1];
 	case 1: seta.sig[1] = (oldset->sig[0] >> 32);
 		seta.sig[0] = oldset->sig[0];
 	}
 	err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
 	if (!wsaved) {
 		err |= copy_in_user((u32 __user *)sf,
 				    (u32 __user *)(regs->u_regs[UREG_FP]),
 				    sizeof(struct reg_window32));
 	} else {
 		struct reg_window *rp;
 		rp = &current_thread_info()->reg_window[wsaved - 1];
 		for (i = 0; i < 8; i++)
 			err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
 		for (i = 0; i < 6; i++)
 			err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
 		err |= __put_user(rp->ins[6], &sf->ss.fp);
 		err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
 	}
 	if (err)
 		goto sigsegv;
 	/* 3. signal handler back-trampoline and parameters */
 	regs->u_regs[UREG_FP] = (unsigned long) sf;
 	regs->u_regs[UREG_I0] = signr;
 	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
 	/* 4. signal handler */
 	regs->tpc = (unsigned long) ka->sa.sa_handler;
 	regs->tnpc = (regs->tpc + 4);
 	if (test_thread_flag(TIF_32BIT)) {
 		regs->tpc &= 0xffffffff;
 		regs->tnpc &= 0xffffffff;
 	}
 	/* 5. return to kernel instructions */
 	if (ka->ka_restorer)
 		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 	else {
 		unsigned long address = ((unsigned long)&(sf->insns[0]));
 		regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 		/* mov __NR_rt_sigreturn, %g1 */
 		err |= __put_user(0x82102065, &sf->insns[0]);
 		/* t 0x10 */
 		err |= __put_user(0x91d02010, &sf->insns[1]);
 		if (err)
 			goto sigsegv;
 		flush_signal_insns(address);
 	}
 	return 0;
 sigill:
 	do_exit(SIGILL);
 	return -EINVAL;
 sigsegv:
 	force_sigsegv(signr, current);
 	return -EFAULT;
 }
 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
 				  siginfo_t *info,
 				  sigset_t *oldset, struct pt_regs *regs)
 {
 	int err;
 	if (ka->sa.sa_flags & SA_SIGINFO)
 		err = setup_rt_frame32(ka, regs, signr, oldset, info);
 	else
 		err = setup_frame32(ka, regs, signr, oldset);
 	if (err)
 		return;
 	signal_delivered(signr, info, ka, regs, 0);
 }
 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
 				     struct sigaction *sa)
 {
 	switch (regs->u_regs[UREG_I0]) {
 	case ERESTART_RESTARTBLOCK:
 	case ERESTARTNOHAND:
 	no_system_call_restart:
 		regs->u_regs[UREG_I0] = EINTR;
 		regs->tstate |= TSTATE_ICARRY;
 		break;
 	case ERESTARTSYS:
 		if (!(sa->sa_flags & SA_RESTART))
 			goto no_system_call_restart;
 		/* fallthrough */
 	case ERESTARTNOINTR:
 		regs->u_regs[UREG_I0] = orig_i0;
 		regs->tpc -= 4;
 		regs->tnpc -= 4;
 	}
 }
 /* Note that 'init' is a special process: it doesn't get signals it doesn't
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  */
 void do_signal32(sigset_t *oldset, struct pt_regs * regs)
 {
 	struct k_sigaction ka;
 	unsigned long orig_i0;
 	int restart_syscall;
 	siginfo_t info;
 	int signr;
 	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 	restart_syscall = 0;
 	orig_i0 = 0;
 	if (pt_regs_is_syscall(regs) &&
 	    (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
 		restart_syscall = 1;
 		orig_i0 = regs->u_regs[UREG_G6];
 	}
 	if (signr > 0) {
 		if (restart_syscall)
 			syscall_restart32(orig_i0, regs, &ka.sa);
 		handle_signal32(signr, &ka, &info, oldset, regs);
 		return;
 	}
 	if (restart_syscall &&
 	    (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
 	     regs->u_regs[UREG_I0] == ERESTARTSYS ||
 	     regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
 		/* replay the system call when we are done */
 		regs->u_regs[UREG_I0] = orig_i0;
 		regs->tpc -= 4;
 		regs->tnpc -= 4;
 		pt_regs_clear_syscall(regs);
 	}
 	if (restart_syscall &&
 	    regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
 		regs->u_regs[UREG_G1] = __NR_restart_syscall;
 		regs->tpc -= 4;
 		regs->tnpc -= 4;
 		pt_regs_clear_syscall(regs);
 	}
 	/* If there's no signal to deliver, we just put the saved sigmask
 	 * back
 	 */
 	restore_saved_sigmask();
 }
 struct sigstack32 {
 	u32 the_stack;
 	int cur_status;
 };
 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
 {
 	struct sigstack32 __user *ssptr =
 		(struct sigstack32 __user *)((unsigned long)(u_ssptr));
 	struct sigstack32 __user *ossptr =
 		(struct sigstack32 __user *)((unsigned long)(u_ossptr));
 	int ret = -EFAULT;
 	/* First see if old state is wanted. */
 	if (ossptr) {
 		if (put_user(current->sas_ss_sp + current->sas_ss_size,
 			     &ossptr->the_stack) ||
 		    __put_user(on_sig_stack(sp), &ossptr->cur_status))
 			goto out;
 	}
 	/* Now see if we want to update the new state. */
 	if (ssptr) {
 		u32 ss_sp;
 		if (get_user(ss_sp, &ssptr->the_stack))
 			goto out;
 		/* If the current stack was set with sigaltstack, don't
 		 * swap stacks while we are on it.
 		 */
 		ret = -EPERM;
 		if (current->sas_ss_sp && on_sig_stack(sp))
 			goto out;
 		/* Since we don't know the extent of the stack, and we don't
 		 * track onstack-ness, but rather calculate it, we must
 		 * presume a size.  Ho hum this interface is lossy.
 		 */
 		current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
 		current->sas_ss_size = SIGSTKSZ;
 	}
 	ret = 0;
 out:
 	return ret;
 }
 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
 {
 	stack_t uss, uoss;
 	u32 u_ss_sp = 0;
 	int ret;
 	mm_segment_t old_fs;
 	stack_t32 __user *uss32 = compat_ptr(ussa);
 	stack_t32 __user *uoss32 = compat_ptr(uossa);
 	if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
 		    __get_user(uss.ss_flags, &uss32->ss_flags) ||
 		    __get_user(uss.ss_size, &uss32->ss_size)))
 		return -EFAULT;
 	uss.ss_sp = compat_ptr(u_ss_sp);
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
 			     uossa ? (stack_t __user *) &uoss : NULL, sp);
 	set_fs(old_fs);
 	if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
 		    __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
 		    __put_user(uoss.ss_size, &uoss32->ss_size)))
 		return -EFAULT;
 	return ret;
 }

arch/tile/include/asm/compat.h

Diff comments View file @ 751f409

 /*
  * Copyright 2010 Tilera Corporation. All Rights Reserved.
  *
  *   This program is free software; you can redistribute it and/or
  *   modify it under the terms of the GNU General Public License
  *   as published by the Free Software Foundation, version 2.
  *
  *   This program is distributed in the hope that it will be useful, but
  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  *   NON INFRINGEMENT.  See the GNU General Public License for
  *   more details.
  */
 #ifndef _ASM_TILE_COMPAT_H
 #define _ASM_TILE_COMPAT_H
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #include <linux/sched.h>
 #define COMPAT_USER_HZ	100
 /* "long" and pointer-based types are different. */
 typedef s32		compat_long_t;
 typedef u32		compat_ulong_t;
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_off_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef u32		compat_ino_t;
 typedef u32		compat_caddr_t;
 typedef	u32		compat_uptr_t;
 /* Many types are "int" or otherwise the same. */
 typedef __kernel_pid_t compat_pid_t;
 typedef __kernel_uid_t __compat_uid_t;
 typedef __kernel_gid_t __compat_gid_t;
 typedef __kernel_uid32_t __compat_uid32_t;
 typedef __kernel_uid32_t __compat_gid32_t;
 typedef __kernel_mode_t compat_mode_t;
 typedef __kernel_dev_t compat_dev_t;
 typedef __kernel_loff_t compat_loff_t;
 typedef __kernel_ipc_pid_t compat_ipc_pid_t;
 typedef __kernel_daddr_t compat_daddr_t;
 typedef __kernel_fsid_t	compat_fsid_t;
 typedef __kernel_timer_t compat_timer_t;
 typedef __kernel_key_t compat_key_t;
 typedef int compat_int_t;
 typedef s64 compat_s64;
 typedef uint compat_uint_t;
 typedef u64 compat_u64;
 /* We use the same register dump format in 32-bit images. */
 typedef unsigned long compat_elf_greg_t;
 #define COMPAT_ELF_NGREG (sizeof(struct pt_regs) / sizeof(compat_elf_greg_t))
 typedef compat_elf_greg_t compat_elf_gregset_t[COMPAT_ELF_NGREG];
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 #define compat_stat stat
 #define compat_statfs statfs
 struct compat_sysctl {
 	unsigned int	name;
 	int		nlen;
 	unsigned int	oldval;
 	unsigned int	oldlenp;
 	unsigned int	newval;
 	unsigned int	newlen;
 	unsigned int	__unused[4];
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	compat_pid_t	l_pid;
 };
 #define F_GETLK64	12	/*  using 'struct flock64' */
 #define F_SETLK64	13
 #define F_SETLKW64	14
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 };
 #define COMPAT_RLIM_INFINITY		0xffffffff
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32               compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+#define COMPAT_SI_PAD_SIZE	(128/sizeof(int) - 3)
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_errno;
+	int si_code;
+	union {
+		int _pad[COMPAT_SI_PAD_SIZE];
+		/* kill() */
+		struct {
+			unsigned int _pid;	/* sender's pid */
+			unsigned int _uid;	/* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;	/* timer id */
+			int _overrun;		/* overrun count */
+			compat_sigval_t _sigval;	/* same as below */
+			int _sys_private;	/* not to be passed to user */
+			int _overrun_incr;	/* amount to add to overrun */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			unsigned int _pid;	/* sender's pid */
+			unsigned int _uid;	/* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			unsigned int _pid;	/* which child */
+			unsigned int _uid;	/* sender's uid */
+			int _status;		/* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+		struct {
+			unsigned int _addr;	/* faulting insn/memory ref. */
+#ifdef __ARCH_SI_TRAPNO
+			int _trapno;	/* TRAP # which caused the signal */
+#endif
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid32_t uid;
 	__compat_gid32_t gid;
 	__compat_uid32_t cuid;
 	__compat_gid32_t cgid;
 	unsigned short mode;
 	unsigned short __pad1;
 	unsigned short seq;
 	unsigned short __pad2;
 	compat_ulong_t unused1;
 	compat_ulong_t unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	compat_time_t  sem_otime;
 	compat_ulong_t __unused1;
 	compat_time_t  sem_ctime;
 	compat_ulong_t __unused2;
 	compat_ulong_t sem_nsems;
 	compat_ulong_t __unused3;
 	compat_ulong_t __unused4;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 	compat_time_t  msg_stime;
 	compat_ulong_t __unused1;
 	compat_time_t  msg_rtime;
 	compat_ulong_t __unused2;
 	compat_time_t  msg_ctime;
 	compat_ulong_t __unused3;
 	compat_ulong_t msg_cbytes;
 	compat_ulong_t msg_qnum;
 	compat_ulong_t msg_qbytes;
 	compat_pid_t   msg_lspid;
 	compat_pid_t   msg_lrpid;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	compat_size_t  shm_segsz;
 	compat_time_t  shm_atime;
 	compat_ulong_t __unused1;
 	compat_time_t  shm_dtime;
 	compat_ulong_t __unused2;
 	compat_time_t  shm_ctime;
 	compat_ulong_t __unused3;
 	compat_pid_t   shm_cpid;
 	compat_pid_t   shm_lpid;
 	compat_ulong_t shm_nattch;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(long)(s32)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 /* Sign-extend when storing a kernel pointer to a user's ptregs. */
 static inline unsigned long ptr_to_compat_reg(void __user *uptr)
 {
 	return (long)(int)(long __force)uptr;
 }
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	struct pt_regs *regs = task_pt_regs(current);
 	return (void __user *)regs->sp - len;
 }
 static inline int is_compat_task(void)
 {
 	return current_thread_info()->status & TS_COMPAT;
 }
 extern int compat_setup_rt_frame(int sig, struct k_sigaction *ka,
 				 siginfo_t *info, sigset_t *set,
 				 struct pt_regs *regs);
 /* Compat syscalls. */
 struct compat_sigaction;
 struct compat_siginfo;
 struct compat_sigaltstack;
 long compat_sys_execve(const char __user *path,
 		       compat_uptr_t __user *argv,
 		       compat_uptr_t __user *envp, struct pt_regs *);
 long compat_sys_rt_sigaction(int sig, struct compat_sigaction __user *act,
 			     struct compat_sigaction __user *oact,
 			     size_t sigsetsize);
 long compat_sys_rt_sigqueueinfo(int pid, int sig,
 				struct compat_siginfo __user *uinfo);
 long compat_sys_rt_sigreturn(struct pt_regs *);
 long compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
 			    struct compat_sigaltstack __user *uoss_ptr,
 			    struct pt_regs *);
 long compat_sys_truncate64(char __user *filename, u32 dummy, u32 low, u32 high);
 long compat_sys_ftruncate64(unsigned int fd, u32 dummy, u32 low, u32 high);
 long compat_sys_pread64(unsigned int fd, char __user *ubuf, size_t count,
 			u32 dummy, u32 low, u32 high);
 long compat_sys_pwrite64(unsigned int fd, char __user *ubuf, size_t count,
 			 u32 dummy, u32 low, u32 high);
 long compat_sys_lookup_dcookie(u32 low, u32 high, char __user *buf, size_t len);
 long compat_sys_sync_file_range2(int fd, unsigned int flags,
 				 u32 offset_lo, u32 offset_hi,
 				 u32 nbytes_lo, u32 nbytes_hi);
 long compat_sys_fallocate(int fd, int mode,
 			  u32 offset_lo, u32 offset_hi,
 			  u32 len_lo, u32 len_hi);
 long compat_sys_sched_rr_get_interval(compat_pid_t pid,
 				      struct compat_timespec __user *interval);
 /* These are the intvec_64.S trampolines. */
 long _compat_sys_execve(const char __user *path,
 			const compat_uptr_t __user *argv,
 			const compat_uptr_t __user *envp);
 long _compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
 			    struct compat_sigaltstack __user *uoss_ptr);
 long _compat_sys_rt_sigreturn(void);
 #endif /* _ASM_TILE_COMPAT_H */

arch/tile/kernel/compat_signal.c

Diff comments View file @ 751f409

 /*
  * Copyright 2010 Tilera Corporation. All Rights Reserved.
  *
  *   This program is free software; you can redistribute it and/or
  *   modify it under the terms of the GNU General Public License
  *   as published by the Free Software Foundation, version 2.
  *
  *   This program is distributed in the hope that it will be useful, but
  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  *   NON INFRINGEMENT.  See the GNU General Public License for
  *   more details.
  */
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/kernel.h>
 #include <linux/signal.h>
 #include <linux/errno.h>
 #include <linux/wait.h>
 #include <linux/unistd.h>
 #include <linux/stddef.h>
 #include <linux/personality.h>
 #include <linux/suspend.h>
 #include <linux/ptrace.h>
 #include <linux/elf.h>
 #include <linux/compat.h>
 #include <linux/syscalls.h>
 #include <linux/uaccess.h>
 #include <asm/processor.h>
 #include <asm/ucontext.h>
 #include <asm/sigframe.h>
 #include <asm/syscalls.h>
 #include <arch/interrupts.h>
 struct compat_sigaction {
 	compat_uptr_t sa_handler;
 	compat_ulong_t sa_flags;
 	compat_uptr_t sa_restorer;
 	sigset_t sa_mask __packed;
 };
 struct compat_sigaltstack {
 	compat_uptr_t ss_sp;
 	int ss_flags;
 	compat_size_t ss_size;
 };
 struct compat_ucontext {
 	compat_ulong_t	  uc_flags;
 	compat_uptr_t     uc_link;
 	struct compat_sigaltstack	  uc_stack;
 	struct sigcontext uc_mcontext;
 	sigset_t	  uc_sigmask;	/* mask last for extensibility */
 };
-#define COMPAT_SI_PAD_SIZE	((SI_MAX_SIZE - 3 * sizeof(int)) / sizeof(int))
-struct compat_siginfo {
-	int si_signo;
-	int si_errno;
-	int si_code;
-	union {
-		int _pad[COMPAT_SI_PAD_SIZE];
-		/* kill() */
-		struct {
-			unsigned int _pid;	/* sender's pid */
-			unsigned int _uid;	/* sender's uid */
-		} _kill;
-		/* POSIX.1b timers */
-		struct {
-			compat_timer_t _tid;	/* timer id */
-			int _overrun;		/* overrun count */
-			compat_sigval_t _sigval;	/* same as below */
-			int _sys_private;	/* not to be passed to user */
-			int _overrun_incr;	/* amount to add to overrun */
-		} _timer;
-		/* POSIX.1b signals */
-		struct {
-			unsigned int _pid;	/* sender's pid */
-			unsigned int _uid;	/* sender's uid */
-			compat_sigval_t _sigval;
-		} _rt;
-		/* SIGCHLD */
-		struct {
-			unsigned int _pid;	/* which child */
-			unsigned int _uid;	/* sender's uid */
-			int _status;		/* exit code */
-			compat_clock_t _utime;
-			compat_clock_t _stime;
-		} _sigchld;
-		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
-		struct {
-			unsigned int _addr;	/* faulting insn/memory ref. */
-#ifdef __ARCH_SI_TRAPNO
-			int _trapno;	/* TRAP # which caused the signal */
-#endif
-		} _sigfault;
-		/* SIGPOLL */
-		struct {
-			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
-			int _fd;
-		} _sigpoll;
-	} _sifields;
-};
 struct compat_rt_sigframe {
 	unsigned char save_area[C_ABI_SAVE_AREA_SIZE]; /* caller save area */
 	struct compat_siginfo info;
 	struct compat_ucontext uc;
 };
 long compat_sys_rt_sigaction(int sig, struct compat_sigaction __user *act,
 			     struct compat_sigaction __user *oact,
 			     size_t sigsetsize)
 {
 	struct k_sigaction new_sa, old_sa;
 	int ret = -EINVAL;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		goto out;
 	if (act) {
 		compat_uptr_t handler, restorer;
 		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 		    __get_user(handler, &act->sa_handler) ||
 		    __get_user(new_sa.sa.sa_flags, &act->sa_flags) ||
 		    __get_user(restorer, &act->sa_restorer) ||
 		    __copy_from_user(&new_sa.sa.sa_mask, &act->sa_mask,
 				     sizeof(sigset_t)))
 			return -EFAULT;
 		new_sa.sa.sa_handler = compat_ptr(handler);
 		new_sa.sa.sa_restorer = compat_ptr(restorer);
 	}
 	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 	if (!ret && oact) {
 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 		    __put_user(ptr_to_compat(old_sa.sa.sa_handler),
 			       &oact->sa_handler) ||
 		    __put_user(ptr_to_compat(old_sa.sa.sa_restorer),
 			       &oact->sa_restorer) ||
 		    __put_user(old_sa.sa.sa_flags, &oact->sa_flags) ||
 		    __copy_to_user(&oact->sa_mask, &old_sa.sa.sa_mask,
 				   sizeof(sigset_t)))
 			return -EFAULT;
 	}
 out:
 	return ret;
 }
 long compat_sys_rt_sigqueueinfo(int pid, int sig,
 				struct compat_siginfo __user *uinfo)
 {
 	siginfo_t info;
 	int ret;
 	mm_segment_t old_fs = get_fs();
 	if (copy_siginfo_from_user32(&info, uinfo))
 		return -EFAULT;
 	set_fs(KERNEL_DS);
 	ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __force __user *)&info);
 	set_fs(old_fs);
 	return ret;
 }
 int copy_siginfo_to_user32(struct compat_siginfo __user *to, siginfo_t *from)
 {
 	int err;
 	if (!access_ok(VERIFY_WRITE, to, sizeof(struct compat_siginfo)))
 		return -EFAULT;
 	/* If you change siginfo_t structure, please make sure that
 	   this code is fixed accordingly.
 	   It should never copy any pad contained in the structure
 	   to avoid security leaks, but must copy the generic
 	   3 ints plus the relevant union member.  */
 	err = __put_user(from->si_signo, &to->si_signo);
 	err |= __put_user(from->si_errno, &to->si_errno);
 	err |= __put_user((short)from->si_code, &to->si_code);
 	if (from->si_code < 0) {
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
 	} else {
 		/*
 		 * First 32bits of unions are always present:
 		 * si_pid === si_band === si_tid === si_addr(LS half)
 		 */
 		err |= __put_user(from->_sifields._pad[0],
 				  &to->_sifields._pad[0]);
 		switch (from->si_code >> 16) {
 		case __SI_FAULT >> 16:
 			break;
 		case __SI_CHLD >> 16:
 			err |= __put_user(from->si_utime, &to->si_utime);
 			err |= __put_user(from->si_stime, &to->si_stime);
 			err |= __put_user(from->si_status, &to->si_status);
 			/* FALL THROUGH */
 		default:
 		case __SI_KILL >> 16:
 			err |= __put_user(from->si_uid, &to->si_uid);
 			break;
 		case __SI_POLL >> 16:
 			err |= __put_user(from->si_fd, &to->si_fd);
 			break;
 		case __SI_TIMER >> 16:
 			err |= __put_user(from->si_overrun, &to->si_overrun);
 			err |= __put_user(ptr_to_compat(from->si_ptr),
 					  &to->si_ptr);
 			break;
 			 /* This is not generated by the kernel as of now.  */
 		case __SI_RT >> 16:
 		case __SI_MESGQ >> 16:
 			err |= __put_user(from->si_uid, &to->si_uid);
 			err |= __put_user(from->si_int, &to->si_int);
 			break;
 		}
 	}
 	return err;
 }
 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 {
 	int err;
 	u32 ptr32;
 	if (!access_ok(VERIFY_READ, from, sizeof(struct compat_siginfo)))
 		return -EFAULT;
 	err = __get_user(to->si_signo, &from->si_signo);
 	err |= __get_user(to->si_errno, &from->si_errno);
 	err |= __get_user(to->si_code, &from->si_code);
 	err |= __get_user(to->si_pid, &from->si_pid);
 	err |= __get_user(to->si_uid, &from->si_uid);
 	err |= __get_user(ptr32, &from->si_ptr);
 	to->si_ptr = compat_ptr(ptr32);
 	return err;
 }
 long compat_sys_sigaltstack(const struct compat_sigaltstack __user *uss_ptr,
 			    struct compat_sigaltstack __user *uoss_ptr,
 			    struct pt_regs *regs)
 {
 	stack_t uss, uoss;
 	int ret;
 	mm_segment_t seg;
 	if (uss_ptr) {
 		u32 ptr;
 		memset(&uss, 0, sizeof(stack_t));
 		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(*uss_ptr)) ||
 			    __get_user(ptr, &uss_ptr->ss_sp) ||
 			    __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
 			    __get_user(uss.ss_size, &uss_ptr->ss_size))
 			return -EFAULT;
 		uss.ss_sp = compat_ptr(ptr);
 	}
 	seg = get_fs();
 	set_fs(KERNEL_DS);
 	ret = do_sigaltstack(uss_ptr ? (stack_t __user __force *)&uss : NULL,
 			     (stack_t __user __force *)&uoss,
 			     (unsigned long)compat_ptr(regs->sp));
 	set_fs(seg);
 	if (ret >= 0 && uoss_ptr)  {
 		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(*uoss_ptr)) ||
 		    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
 		    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
 		    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
 			ret = -EFAULT;
 	}
 	return ret;
 }
 /* The assembly shim for this function arranges to ignore the return value. */
 long compat_sys_rt_sigreturn(struct pt_regs *regs)
 {
 	struct compat_rt_sigframe __user *frame =
 		(struct compat_rt_sigframe __user *) compat_ptr(regs->sp);
 	sigset_t set;
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 		goto badframe;
 	set_current_blocked(&set);
 	if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 		goto badframe;
 	if (compat_sys_sigaltstack(&frame->uc.uc_stack, NULL, regs) != 0)
 		goto badframe;
 	return 0;
 badframe:
 	signal_fault("bad sigreturn frame", regs, frame, 0);
 	return 0;
 }
 /*
  * Determine which stack to use..
  */
 static inline void __user *compat_get_sigframe(struct k_sigaction *ka,
 					       struct pt_regs *regs,
 					       size_t frame_size)
 {
 	unsigned long sp;
 	/* Default to using normal stack */
 	sp = (unsigned long)compat_ptr(regs->sp);
 	/*
 	 * If we are on the alternate signal stack and would overflow
 	 * it, don't.  Return an always-bogus address instead so we
 	 * will die with SIGSEGV.
 	 */
 	if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
 		return (void __user __force *)-1UL;
 	/* This is the X/Open sanctioned signal stack switching.  */
 	if (ka->sa.sa_flags & SA_ONSTACK) {
 		if (sas_ss_flags(sp) == 0)
 			sp = current->sas_ss_sp + current->sas_ss_size;
 	}
 	sp -= frame_size;
 	/*
 	 * Align the stack pointer according to the TILE ABI,
 	 * i.e. so that on function entry (sp & 15) == 0.
 	 */
 	sp &= -16UL;
 	return (void __user *) sp;
 }
 int compat_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 			  sigset_t *set, struct pt_regs *regs)
 {
 	unsigned long restorer;
 	struct compat_rt_sigframe __user *frame;
 	int err = 0;
 	int usig;
 	frame = compat_get_sigframe(ka, regs, sizeof(*frame));
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		goto give_sigsegv;
 	usig = current_thread_info()->exec_domain
 		&& current_thread_info()->exec_domain->signal_invmap
 		&& sig < 32
 		? current_thread_info()->exec_domain->signal_invmap[sig]
 		: sig;
 	/* Always write at least the signal number for the stack backtracer. */
 	if (ka->sa.sa_flags & SA_SIGINFO) {
 		/* At sigreturn time, restore the callee-save registers too. */
 		err |= copy_siginfo_to_user32(&frame->info, info);
 		regs->flags |= PT_FLAGS_RESTORE_REGS;
 	} else {
 		err |= __put_user(info->si_signo, &frame->info.si_signo);
 	}
 	/* Create the ucontext.  */
 	err |= __clear_user(&frame->save_area, sizeof(frame->save_area));
 	err |= __put_user(0, &frame->uc.uc_flags);
 	err |= __put_user(0, &frame->uc.uc_link);
 	err |= __put_user(ptr_to_compat((void *)(current->sas_ss_sp)),
 			  &frame->uc.uc_stack.ss_sp);
 	err |= __put_user(sas_ss_flags(regs->sp),
 			  &frame->uc.uc_stack.ss_flags);
 	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 	err |= setup_sigcontext(&frame->uc.uc_mcontext, regs);
 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 	if (err)
 		goto give_sigsegv;
 	restorer = VDSO_BASE;
 	if (ka->sa.sa_flags & SA_RESTORER)
 		restorer = ptr_to_compat_reg(ka->sa.sa_restorer);
 	/*
 	 * Set up registers for signal handler.
 	 * Registers that we don't modify keep the value they had from
 	 * user-space at the time we took the signal.
 	 * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
 	 * since some things rely on this (e.g. glibc's debug/segfault.c).
 	 */
 	regs->pc = ptr_to_compat_reg(ka->sa.sa_handler);
 	regs->ex1 = PL_ICS_EX1(USER_PL, 1); /* set crit sec in handler */
 	regs->sp = ptr_to_compat_reg(frame);
 	regs->lr = restorer;
 	regs->regs[0] = (unsigned long) usig;
 	regs->regs[1] = ptr_to_compat_reg(&frame->info);
 	regs->regs[2] = ptr_to_compat_reg(&frame->uc);
 	regs->flags |= PT_FLAGS_CALLER_SAVES;
 	/*
 	 * Notify any tracer that was single-stepping it.
 	 * The tracer may want to single-step inside the
 	 * handler too.
 	 */
 	if (test_thread_flag(TIF_SINGLESTEP))
 		ptrace_notify(SIGTRAP);
 	return 0;
 give_sigsegv:
 	signal_fault("bad setup frame", regs, frame, sig);
 	return -EFAULT;
 }

arch/x86/include/asm/compat.h

Diff comments View file @ 751f409

 #ifndef _ASM_X86_COMPAT_H
 #define _ASM_X86_COMPAT_H
 /*
  * Architecture specific compatibility types
  */
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <asm/processor.h>
 #include <asm/user32.h>
 #include <asm/unistd.h>
 #define COMPAT_USER_HZ		100
 #define COMPAT_UTS_MACHINE	"i686\0\0"
 typedef u32		compat_size_t;
 typedef s32		compat_ssize_t;
 typedef s32		compat_time_t;
 typedef s32		compat_clock_t;
 typedef s32		compat_pid_t;
 typedef u16		__compat_uid_t;
 typedef u16		__compat_gid_t;
 typedef u32		__compat_uid32_t;
 typedef u32		__compat_gid32_t;
 typedef u16		compat_mode_t;
 typedef u32		compat_ino_t;
 typedef u16		compat_dev_t;
 typedef s32		compat_off_t;
 typedef s64		compat_loff_t;
 typedef u16		compat_nlink_t;
 typedef u16		compat_ipc_pid_t;
 typedef s32		compat_daddr_t;
 typedef u32		compat_caddr_t;
 typedef __kernel_fsid_t	compat_fsid_t;
 typedef s32		compat_timer_t;
 typedef s32		compat_key_t;
 typedef s32		compat_int_t;
 typedef s32		compat_long_t;
 typedef s64 __attribute__((aligned(4))) compat_s64;
 typedef u32		compat_uint_t;
 typedef u32		compat_ulong_t;
 typedef u64 __attribute__((aligned(4))) compat_u64;
+typedef u32		compat_uptr_t;
 struct compat_timespec {
 	compat_time_t	tv_sec;
 	s32		tv_nsec;
 };
 struct compat_timeval {
 	compat_time_t	tv_sec;
 	s32		tv_usec;
 };
 struct compat_stat {
 	compat_dev_t	st_dev;
 	u16		__pad1;
 	compat_ino_t	st_ino;
 	compat_mode_t	st_mode;
 	compat_nlink_t	st_nlink;
 	__compat_uid_t	st_uid;
 	__compat_gid_t	st_gid;
 	compat_dev_t	st_rdev;
 	u16		__pad2;
 	u32		st_size;
 	u32		st_blksize;
 	u32		st_blocks;
 	u32		st_atime;
 	u32		st_atime_nsec;
 	u32		st_mtime;
 	u32		st_mtime_nsec;
 	u32		st_ctime;
 	u32		st_ctime_nsec;
 	u32		__unused4;
 	u32		__unused5;
 };
 struct compat_flock {
 	short		l_type;
 	short		l_whence;
 	compat_off_t	l_start;
 	compat_off_t	l_len;
 	compat_pid_t	l_pid;
 };
 #define F_GETLK64	12	/*  using 'struct flock64' */
 #define F_SETLK64	13
 #define F_SETLKW64	14
 /*
  * IA32 uses 4 byte alignment for 64 bit quantities,
  * so we need to pack this structure.
  */
 struct compat_flock64 {
 	short		l_type;
 	short		l_whence;
 	compat_loff_t	l_start;
 	compat_loff_t	l_len;
 	compat_pid_t	l_pid;
 } __attribute__((packed));
 struct compat_statfs {
 	int		f_type;
 	int		f_bsize;
 	int		f_blocks;
 	int		f_bfree;
 	int		f_bavail;
 	int		f_files;
 	int		f_ffree;
 	compat_fsid_t	f_fsid;
 	int		f_namelen;	/* SunOS ignores this field. */
 	int		f_frsize;
 	int		f_flags;
 	int		f_spare[4];
 };
 #define COMPAT_RLIM_OLD_INFINITY	0x7fffffff
 #define COMPAT_RLIM_INFINITY		0xffffffff
 typedef u32		compat_old_sigset_t;	/* at least 32 bits */
 #define _COMPAT_NSIG		64
 #define _COMPAT_NSIG_BPW	32
 typedef u32               compat_sigset_word;
+typedef union compat_sigval {
+	compat_int_t	sival_int;
+	compat_uptr_t	sival_ptr;
+} compat_sigval_t;
+typedef struct compat_siginfo {
+	int si_signo;
+	int si_errno;
+	int si_code;
+	union {
+		int _pad[128/sizeof(int) - 3];
+		/* kill() */
+		struct {
+			unsigned int _pid;	/* sender's pid */
+			unsigned int _uid;	/* sender's uid */
+		} _kill;
+		/* POSIX.1b timers */
+		struct {
+			compat_timer_t _tid;	/* timer id */
+			int _overrun;		/* overrun count */
+			compat_sigval_t _sigval;	/* same as below */
+			int _sys_private;	/* not to be passed to user */
+			int _overrun_incr;	/* amount to add to overrun */
+		} _timer;
+		/* POSIX.1b signals */
+		struct {
+			unsigned int _pid;	/* sender's pid */
+			unsigned int _uid;	/* sender's uid */
+			compat_sigval_t _sigval;
+		} _rt;
+		/* SIGCHLD */
+		struct {
+			unsigned int _pid;	/* which child */
+			unsigned int _uid;	/* sender's uid */
+			int _status;		/* exit code */
+			compat_clock_t _utime;
+			compat_clock_t _stime;
+		} _sigchld;
+		/* SIGCHLD (x32 version) */
+		struct {
+			unsigned int _pid;	/* which child */
+			unsigned int _uid;	/* sender's uid */
+			int _status;		/* exit code */
+			compat_s64 _utime;
+			compat_s64 _stime;
+		} _sigchld_x32;
+		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+		struct {
+			unsigned int _addr;	/* faulting insn/memory ref. */
+		} _sigfault;
+		/* SIGPOLL */
+		struct {
+			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
+			int _fd;
+		} _sigpoll;
+		struct {
+			unsigned int _call_addr; /* calling insn */
+			int _syscall;	/* triggering system call number */
+			unsigned int _arch;	/* AUDIT_ARCH_* of syscall */
+		} _sigsys;
+	} _sifields;
+} compat_siginfo_t;
 #define COMPAT_OFF_T_MAX	0x7fffffff
 #define COMPAT_LOFF_T_MAX	0x7fffffffffffffffL
 struct compat_ipc64_perm {
 	compat_key_t key;
 	__compat_uid32_t uid;
 	__compat_gid32_t gid;
 	__compat_uid32_t cuid;
 	__compat_gid32_t cgid;
 	unsigned short mode;
 	unsigned short __pad1;
 	unsigned short seq;
 	unsigned short __pad2;
 	compat_ulong_t unused1;
 	compat_ulong_t unused2;
 };
 struct compat_semid64_ds {
 	struct compat_ipc64_perm sem_perm;
 	compat_time_t  sem_otime;
 	compat_ulong_t __unused1;
 	compat_time_t  sem_ctime;
 	compat_ulong_t __unused2;
 	compat_ulong_t sem_nsems;
 	compat_ulong_t __unused3;
 	compat_ulong_t __unused4;
 };
 struct compat_msqid64_ds {
 	struct compat_ipc64_perm msg_perm;
 	compat_time_t  msg_stime;
 	compat_ulong_t __unused1;
 	compat_time_t  msg_rtime;
 	compat_ulong_t __unused2;
 	compat_time_t  msg_ctime;
 	compat_ulong_t __unused3;
 	compat_ulong_t msg_cbytes;
 	compat_ulong_t msg_qnum;
 	compat_ulong_t msg_qbytes;
 	compat_pid_t   msg_lspid;
 	compat_pid_t   msg_lrpid;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 struct compat_shmid64_ds {
 	struct compat_ipc64_perm shm_perm;
 	compat_size_t  shm_segsz;
 	compat_time_t  shm_atime;
 	compat_ulong_t __unused1;
 	compat_time_t  shm_dtime;
 	compat_ulong_t __unused2;
 	compat_time_t  shm_ctime;
 	compat_ulong_t __unused3;
 	compat_pid_t   shm_cpid;
 	compat_pid_t   shm_lpid;
 	compat_ulong_t shm_nattch;
 	compat_ulong_t __unused4;
 	compat_ulong_t __unused5;
 };
 /*
  * The type of struct elf_prstatus.pr_reg in compatible core dumps.
  */
 #ifdef CONFIG_X86_X32_ABI
 typedef struct user_regs_struct compat_elf_gregset_t;
 #define PR_REG_SIZE(S) (test_thread_flag(TIF_IA32) ? 68 : 216)
 #define PRSTATUS_SIZE(S) (test_thread_flag(TIF_IA32) ? 144 : 296)
 #define SET_PR_FPVALID(S,V) \
   do { *(int *) (((void *) &((S)->pr_reg)) + PR_REG_SIZE(0)) = (V); } \
   while (0)
 #define COMPAT_USE_64BIT_TIME \
 	(!!(task_pt_regs(current)->orig_ax & __X32_SYSCALL_BIT))
 #else
 typedef struct user_regs_struct32 compat_elf_gregset_t;
 #endif
 /*
  * A pointer passed in from user mode. This should not
  * be used for syscall parameters, just declare them
  * as pointers because the syscall entry code will have
  * appropriately converted them already.
  */
-typedef	u32		compat_uptr_t;
 static inline void __user *compat_ptr(compat_uptr_t uptr)
 {
 	return (void __user *)(unsigned long)uptr;
 }
 static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 {
 	return (u32)(unsigned long)uptr;
 }
 static inline void __user *arch_compat_alloc_user_space(long len)
 {
 	compat_uptr_t sp;
 	if (test_thread_flag(TIF_IA32)) {
 		sp = task_pt_regs(current)->sp;
 	} else {
 		/* -128 for the x32 ABI redzone */
 		sp = this_cpu_read(old_rsp) - 128;
 	}
 	return (void __user *)round_down(sp - len, 16);
 }
 static inline bool is_x32_task(void)
 {
 #ifdef CONFIG_X86_X32_ABI
 	if (task_pt_regs(current)->orig_ax & __X32_SYSCALL_BIT)
 		return true;
 #endif
 	return false;
 }
 static inline bool is_compat_task(void)
 {
 	return is_ia32_task() || is_x32_task();
 }
 #endif /* _ASM_X86_COMPAT_H */

arch/x86/include/asm/ia32.h

Diff comments View file @ 751f409

 #ifndef _ASM_X86_IA32_H
 #define _ASM_X86_IA32_H
 #ifdef CONFIG_IA32_EMULATION
 #include <linux/compat.h>
 /*
  * 32 bit structures for IA32 support.
  */
 #include <asm/sigcontext32.h>
 /* signal.h */
 struct sigaction32 {
 	unsigned int  sa_handler;	/* Really a pointer, but need to deal
 					   with 32 bits */
 	unsigned int sa_flags;
 	unsigned int sa_restorer;	/* Another 32 bit pointer */
 	compat_sigset_t sa_mask;	/* A 32 bit mask */
 };
 struct old_sigaction32 {
 	unsigned int  sa_handler;	/* Really a pointer, but need to deal
 					   with 32 bits */
 	compat_old_sigset_t sa_mask;	/* A 32 bit mask */
 	unsigned int sa_flags;
 	unsigned int sa_restorer;	/* Another 32 bit pointer */
 };
 typedef struct sigaltstack_ia32 {
 	unsigned int	ss_sp;
 	int		ss_flags;
 	unsigned int	ss_size;
 } stack_ia32_t;
 struct ucontext_ia32 {
 	unsigned int	  uc_flags;
 	unsigned int 	  uc_link;
 	stack_ia32_t	  uc_stack;
 	struct sigcontext_ia32 uc_mcontext;
 	compat_sigset_t	  uc_sigmask;	/* mask last for extensibility */
 };
 struct ucontext_x32 {
 	unsigned int	  uc_flags;
 	unsigned int 	  uc_link;
 	stack_ia32_t	  uc_stack;
 	unsigned int	  uc__pad0;     /* needed for alignment */
 	struct sigcontext uc_mcontext;  /* the 64-bit sigcontext type */
 	compat_sigset_t	  uc_sigmask;	/* mask last for extensibility */
 };
 /* This matches struct stat64 in glibc2.2, hence the absolutely
  * insane amounts of padding around dev_t's.
  */
 struct stat64 {
 	unsigned long long	st_dev;
 	unsigned char		__pad0[4];
 #define STAT64_HAS_BROKEN_ST_INO	1
 	unsigned int		__st_ino;
 	unsigned int		st_mode;
 	unsigned int		st_nlink;
 	unsigned int		st_uid;
 	unsigned int		st_gid;
 	unsigned long long	st_rdev;
 	unsigned char		__pad3[4];
 	long long		st_size;
 	unsigned int		st_blksize;
 	long long		st_blocks;/* Number 512-byte blocks allocated */
 	unsigned 		st_atime;
 	unsigned 		st_atime_nsec;
 	unsigned 		st_mtime;
 	unsigned 		st_mtime_nsec;
 	unsigned 		st_ctime;
 	unsigned 		st_ctime_nsec;
 	unsigned long long	st_ino;
 } __attribute__((packed));
-typedef struct compat_siginfo {
-	int si_signo;
-	int si_errno;
-	int si_code;
-	union {
-		int _pad[((128 / sizeof(int)) - 3)];
-		/* kill() */
-		struct {
-			unsigned int _pid;	/* sender's pid */
-			unsigned int _uid;	/* sender's uid */
-		} _kill;
-		/* POSIX.1b timers */
-		struct {
-			compat_timer_t _tid;	/* timer id */
-			int _overrun;		/* overrun count */
-			compat_sigval_t _sigval;	/* same as below */
-			int _sys_private;	/* not to be passed to user */
-			int _overrun_incr;	/* amount to add to overrun */
-		} _timer;
-		/* POSIX.1b signals */
-		struct {
-			unsigned int _pid;	/* sender's pid */
-			unsigned int _uid;	/* sender's uid */
-			compat_sigval_t _sigval;
-		} _rt;
-		/* SIGCHLD */
-		struct {
-			unsigned int _pid;	/* which child */
-			unsigned int _uid;	/* sender's uid */
-			int _status;		/* exit code */
-			compat_clock_t _utime;
-			compat_clock_t _stime;
-		} _sigchld;
-		/* SIGCHLD (x32 version) */
-		struct {
-			unsigned int _pid;	/* which child */
-			unsigned int _uid;	/* sender's uid */
-			int _status;		/* exit code */
-			compat_s64 _utime;
-			compat_s64 _stime;
-		} _sigchld_x32;
-		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
-		struct {
-			unsigned int _addr;	/* faulting insn/memory ref. */
-		} _sigfault;
-		/* SIGPOLL */
-		struct {
-			int _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
-			int _fd;
-		} _sigpoll;
-		struct {
-			unsigned int _call_addr; /* calling insn */
-			int _syscall;	/* triggering system call number */
-			unsigned int _arch;	/* AUDIT_ARCH_* of syscall */
-		} _sigsys;
-	} _sifields;
-} compat_siginfo_t;
 #define IA32_STACK_TOP IA32_PAGE_OFFSET
 #ifdef __KERNEL__
 struct linux_binprm;
 extern int ia32_setup_arg_pages(struct linux_binprm *bprm,
 				unsigned long stack_top, int exec_stack);
 struct mm_struct;
 extern void ia32_pick_mmap_layout(struct mm_struct *mm);
 #endif
 #endif /* !CONFIG_IA32_SUPPORT */
 #endif /* _ASM_X86_IA32_H */

include/linux/compat.h

Diff comments View file @ 751f409

 #ifndef _LINUX_COMPAT_H
 #define _LINUX_COMPAT_H
 /*
  * These are the type definitions for the architecture specific
  * syscall compatibility layer.
  */
 #ifdef CONFIG_COMPAT
 #include <linux/stat.h>
 #include <linux/param.h>	/* for HZ */
 #include <linux/sem.h>
 #include <linux/socket.h>
 #include <linux/if.h>
 #include <linux/fs.h>
 #include <linux/aio_abi.h>	/* for aio_context_t */
 #include <asm/compat.h>
 #include <asm/siginfo.h>
 #include <asm/signal.h>
 #ifndef COMPAT_USE_64BIT_TIME
 #define COMPAT_USE_64BIT_TIME 0
 #endif
 #define compat_jiffies_to_clock_t(x)	\
 		(((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
 typedef __compat_uid32_t	compat_uid_t;
 typedef __compat_gid32_t	compat_gid_t;
 struct compat_sel_arg_struct;
 struct rusage;
 struct compat_itimerspec {
 	struct compat_timespec it_interval;
 	struct compat_timespec it_value;
 };
 struct compat_utimbuf {
 	compat_time_t		actime;
 	compat_time_t		modtime;
 };
 struct compat_itimerval {
 	struct compat_timeval	it_interval;
 	struct compat_timeval	it_value;
 };
 struct compat_tms {
 	compat_clock_t		tms_utime;
 	compat_clock_t		tms_stime;
 	compat_clock_t		tms_cutime;
 	compat_clock_t		tms_cstime;
 };
 struct compat_timex {
 	compat_uint_t modes;
 	compat_long_t offset;
 	compat_long_t freq;
 	compat_long_t maxerror;
 	compat_long_t esterror;
 	compat_int_t status;
 	compat_long_t constant;
 	compat_long_t precision;
 	compat_long_t tolerance;
 	struct compat_timeval time;
 	compat_long_t tick;
 	compat_long_t ppsfreq;
 	compat_long_t jitter;
 	compat_int_t shift;
 	compat_long_t stabil;
 	compat_long_t jitcnt;
 	compat_long_t calcnt;
 	compat_long_t errcnt;
 	compat_long_t stbcnt;
 	compat_int_t tai;
 	compat_int_t:32; compat_int_t:32; compat_int_t:32; compat_int_t:32;
 	compat_int_t:32; compat_int_t:32; compat_int_t:32; compat_int_t:32;
 	compat_int_t:32; compat_int_t:32; compat_int_t:32;
 };
 #define _COMPAT_NSIG_WORDS	(_COMPAT_NSIG / _COMPAT_NSIG_BPW)
 typedef struct {
 	compat_sigset_word	sig[_COMPAT_NSIG_WORDS];
 } compat_sigset_t;
 /*
  * These functions operate strictly on struct compat_time*
  */
 extern int get_compat_timespec(struct timespec *,
 			       const struct compat_timespec __user *);
 extern int put_compat_timespec(const struct timespec *,
 			       struct compat_timespec __user *);
 extern int get_compat_timeval(struct timeval *,
 			      const struct compat_timeval __user *);
 extern int put_compat_timeval(const struct timeval *,
 			      struct compat_timeval __user *);
 /*
  * These functions operate on 32- or 64-bit specs depending on
  * COMPAT_USE_64BIT_TIME, hence the void user pointer arguments and the
  * naming as compat_get/put_ rather than get/put_compat_.
  */
 extern int compat_get_timespec(struct timespec *, const void __user *);
 extern int compat_put_timespec(const struct timespec *, void __user *);
 extern int compat_get_timeval(struct timeval *, const void __user *);
 extern int compat_put_timeval(const struct timeval *, void __user *);
 struct compat_iovec {
 	compat_uptr_t	iov_base;
 	compat_size_t	iov_len;
 };
 struct compat_rlimit {
 	compat_ulong_t	rlim_cur;
 	compat_ulong_t	rlim_max;
 };
 struct compat_rusage {
 	struct compat_timeval ru_utime;
 	struct compat_timeval ru_stime;
 	compat_long_t	ru_maxrss;
 	compat_long_t	ru_ixrss;
 	compat_long_t	ru_idrss;
 	compat_long_t	ru_isrss;
 	compat_long_t	ru_minflt;
 	compat_long_t	ru_majflt;
 	compat_long_t	ru_nswap;
 	compat_long_t	ru_inblock;
 	compat_long_t	ru_oublock;
 	compat_long_t	ru_msgsnd;
 	compat_long_t	ru_msgrcv;
 	compat_long_t	ru_nsignals;
 	compat_long_t	ru_nvcsw;
 	compat_long_t	ru_nivcsw;
 };
 extern int put_compat_rusage(const struct rusage *,
 			     struct compat_rusage __user *);
 struct compat_siginfo;
 extern asmlinkage long compat_sys_waitid(int, compat_pid_t,
 		struct compat_siginfo __user *, int,
 		struct compat_rusage __user *);
 struct compat_dirent {
 	u32		d_ino;
 	compat_off_t	d_off;
 	u16		d_reclen;
 	char		d_name[256];
 };
 struct compat_ustat {
 	compat_daddr_t		f_tfree;
 	compat_ino_t		f_tinode;
 	char			f_fname[6];
 	char			f_fpack[6];
 };
-typedef union compat_sigval {
-	compat_int_t	sival_int;
-	compat_uptr_t	sival_ptr;
-} compat_sigval_t;
 #define COMPAT_SIGEV_PAD_SIZE	((SIGEV_MAX_SIZE/sizeof(int)) - 3)
 typedef struct compat_sigevent {
 	compat_sigval_t sigev_value;
 	compat_int_t sigev_signo;
 	compat_int_t sigev_notify;
 	union {
 		compat_int_t _pad[COMPAT_SIGEV_PAD_SIZE];
 		compat_int_t _tid;
 		struct {
 			compat_uptr_t _function;
 			compat_uptr_t _attribute;
 		} _sigev_thread;
 	} _sigev_un;
 } compat_sigevent_t;
 struct compat_ifmap {
 	compat_ulong_t mem_start;
 	compat_ulong_t mem_end;
 	unsigned short base_addr;
 	unsigned char irq;
 	unsigned char dma;
 	unsigned char port;
 };
 struct compat_if_settings {
 	unsigned int type;	/* Type of physical device or protocol */
 	unsigned int size;	/* Size of the data allocated by the caller */
 	compat_uptr_t ifs_ifsu;	/* union of pointers */
 };
 struct compat_ifreq {
 	union {
 		char	ifrn_name[IFNAMSIZ];    /* if name, e.g. "en0" */
 	} ifr_ifrn;
 	union {
 		struct	sockaddr ifru_addr;
 		struct	sockaddr ifru_dstaddr;
 		struct	sockaddr ifru_broadaddr;
 		struct	sockaddr ifru_netmask;
 		struct	sockaddr ifru_hwaddr;
 		short	ifru_flags;
 		compat_int_t	ifru_ivalue;
 		compat_int_t	ifru_mtu;
 		struct	compat_ifmap ifru_map;
 		char	ifru_slave[IFNAMSIZ];   /* Just fits the size */
 		char	ifru_newname[IFNAMSIZ];
 		compat_caddr_t	ifru_data;
 		struct	compat_if_settings ifru_settings;
 	} ifr_ifru;
 };
 struct compat_ifconf {
 	compat_int_t	ifc_len;                /* size of buffer */
 	compat_caddr_t  ifcbuf;
 };
 struct compat_robust_list {
 	compat_uptr_t			next;
 };
 struct compat_robust_list_head {
 	struct compat_robust_list	list;
 	compat_long_t			futex_offset;
 	compat_uptr_t			list_op_pending;
 };
 struct compat_statfs;
 struct compat_statfs64;
 struct compat_old_linux_dirent;
 struct compat_linux_dirent;
 struct linux_dirent64;
 struct compat_msghdr;
 struct compat_mmsghdr;
 struct compat_sysinfo;
 struct compat_sysctl_args;
 struct compat_kexec_segment;
 struct compat_mq_attr;
 struct compat_msgbuf;
 extern void compat_exit_robust_list(struct task_struct *curr);
 asmlinkage long
 compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
 			   compat_size_t len);
 asmlinkage long
 compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
 			   compat_size_t __user *len_ptr);
 #ifdef CONFIG_ARCH_WANT_OLD_COMPAT_IPC
 long compat_sys_semctl(int first, int second, int third, void __user *uptr);
 long compat_sys_msgsnd(int first, int second, int third, void __user *uptr);
 long compat_sys_msgrcv(int first, int second, int msgtyp, int third,
 		int version, void __user *uptr);
 long compat_sys_shmat(int first, int second, compat_uptr_t third, int version,
 		void __user *uptr);
 #else
 long compat_sys_semctl(int semid, int semnum, int cmd, int arg);
 long compat_sys_msgsnd(int msqid, struct compat_msgbuf __user *msgp,
 		compat_ssize_t msgsz, int msgflg);
 long compat_sys_msgrcv(int msqid, struct compat_msgbuf __user *msgp,
 		compat_ssize_t msgsz, long msgtyp, int msgflg);
 long compat_sys_shmat(int shmid, compat_uptr_t shmaddr, int shmflg);
 #endif
 long compat_sys_msgctl(int first, int second, void __user *uptr);
 long compat_sys_shmctl(int first, int second, void __user *uptr);
 long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
 		unsigned nsems, const struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_keyctl(u32 option,
 			      u32 arg2, u32 arg3, u32 arg4, u32 arg5);
 asmlinkage long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u32);
 asmlinkage ssize_t compat_sys_readv(unsigned long fd,
 		const struct compat_iovec __user *vec, unsigned long vlen);
 asmlinkage ssize_t compat_sys_writev(unsigned long fd,
 		const struct compat_iovec __user *vec, unsigned long vlen);
 asmlinkage ssize_t compat_sys_preadv(unsigned long fd,
 		const struct compat_iovec __user *vec,
 		unsigned long vlen, u32 pos_low, u32 pos_high);
 asmlinkage ssize_t compat_sys_pwritev(unsigned long fd,
 		const struct compat_iovec __user *vec,
 		unsigned long vlen, u32 pos_low, u32 pos_high);
 int compat_do_execve(char *filename, compat_uptr_t __user *argv,
 		     compat_uptr_t __user *envp, struct pt_regs *regs);
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
 		compat_ulong_t __user *outp, compat_ulong_t __user *exp,
 		struct compat_timeval __user *tvp);
 asmlinkage long compat_sys_old_select(struct compat_sel_arg_struct __user *arg);
 asmlinkage long compat_sys_wait4(compat_pid_t pid,
 				 compat_uint_t __user *stat_addr, int options,
 				 struct compat_rusage __user *ru);
 #define BITS_PER_COMPAT_LONG    (8*sizeof(compat_long_t))
 #define BITS_TO_COMPAT_LONGS(bits) \
 	(((bits)+BITS_PER_COMPAT_LONG-1)/BITS_PER_COMPAT_LONG)
 long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
 		       unsigned long bitmap_size);
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
 		       unsigned long bitmap_size);
 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from);
 int copy_siginfo_to_user32(struct compat_siginfo __user *to, siginfo_t *from);
 int get_compat_sigevent(struct sigevent *event,
 		const struct compat_sigevent __user *u_event);
 long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid, compat_pid_t pid, int sig,
 				  struct compat_siginfo __user *uinfo);
 static inline int compat_timeval_compare(struct compat_timeval *lhs,
 					struct compat_timeval *rhs)
 {
 	if (lhs->tv_sec < rhs->tv_sec)
 		return -1;
 	if (lhs->tv_sec > rhs->tv_sec)
 		return 1;
 	return lhs->tv_usec - rhs->tv_usec;
 }
 static inline int compat_timespec_compare(struct compat_timespec *lhs,
 					struct compat_timespec *rhs)
 {
 	if (lhs->tv_sec < rhs->tv_sec)
 		return -1;
 	if (lhs->tv_sec > rhs->tv_sec)
 		return 1;
 	return lhs->tv_nsec - rhs->tv_nsec;
 }
 extern int get_compat_itimerspec(struct itimerspec *dst,
 				 const struct compat_itimerspec __user *src);
 extern int put_compat_itimerspec(struct compat_itimerspec __user *dst,
 				 const struct itimerspec *src);
 asmlinkage long compat_sys_gettimeofday(struct compat_timeval __user *tv,
 		struct timezone __user *tz);
 asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
 		struct timezone __user *tz);
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 extern int compat_printk(const char *fmt, ...);
 extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
 asmlinkage long compat_sys_migrate_pages(compat_pid_t pid,
 		compat_ulong_t maxnode, const compat_ulong_t __user *old_nodes,
 		const compat_ulong_t __user *new_nodes);
 extern int compat_ptrace_request(struct task_struct *child,
 				 compat_long_t request,
 				 compat_ulong_t addr, compat_ulong_t data);
 extern long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
 			       compat_ulong_t addr, compat_ulong_t data);
 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
 				  compat_long_t addr, compat_long_t data);
 /*
  * epoll (fs/eventpoll.c) compat bits follow ...
  */
 struct epoll_event;
 #define compat_epoll_event	epoll_event
 asmlinkage long compat_sys_epoll_pwait(int epfd,
 			struct compat_epoll_event __user *events,
 			int maxevents, int timeout,
 			const compat_sigset_t __user *sigmask,
 			compat_size_t sigsetsize);
 asmlinkage long compat_sys_utime(const char __user *filename,
 				 struct compat_utimbuf __user *t);
 asmlinkage long compat_sys_utimensat(unsigned int dfd,
 				     const char __user *filename,
 				     struct compat_timespec __user *t,
 				     int flags);
 asmlinkage long compat_sys_time(compat_time_t __user *tloc);
 asmlinkage long compat_sys_stime(compat_time_t __user *tptr);
 asmlinkage long compat_sys_signalfd(int ufd,
 				    const compat_sigset_t __user *sigmask,
 				    compat_size_t sigsetsize);
 asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
 				   const struct compat_itimerspec __user *utmr,
 				   struct compat_itimerspec __user *otmr);
 asmlinkage long compat_sys_timerfd_gettime(int ufd,
 				   struct compat_itimerspec __user *otmr);
 asmlinkage long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
 				      __u32 __user *pages,
 				      const int __user *nodes,
 				      int __user *status,
 				      int flags);
 asmlinkage long compat_sys_futimesat(unsigned int dfd,
 				     const char __user *filename,
 				     struct compat_timeval __user *t);
 asmlinkage long compat_sys_utimes(const char __user *filename,
 				  struct compat_timeval __user *t);
 asmlinkage long compat_sys_newstat(const char __user *filename,
 				   struct compat_stat __user *statbuf);
 asmlinkage long compat_sys_newlstat(const char __user *filename,
 				    struct compat_stat __user *statbuf);
 asmlinkage long compat_sys_newfstatat(unsigned int dfd,
 				      const char __user *filename,
 				      struct compat_stat __user *statbuf,
 				      int flag);
 asmlinkage long compat_sys_newfstat(unsigned int fd,
 				    struct compat_stat __user *statbuf);
 asmlinkage long compat_sys_statfs(const char __user *pathname,
 				  struct compat_statfs __user *buf);
 asmlinkage long compat_sys_fstatfs(unsigned int fd,
 				   struct compat_statfs __user *buf);
 asmlinkage long compat_sys_statfs64(const char __user *pathname,
 				    compat_size_t sz,
 				    struct compat_statfs64 __user *buf);
 asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
 				     struct compat_statfs64 __user *buf);
 asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
 				   unsigned long arg);
 asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
 				 unsigned long arg);
 asmlinkage long compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p);
 asmlinkage long compat_sys_io_getevents(aio_context_t ctx_id,
 					unsigned long min_nr,
 					unsigned long nr,
 					struct io_event __user *events,
 					struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_io_submit(aio_context_t ctx_id, int nr,
 				     u32 __user *iocb);
 asmlinkage long compat_sys_mount(const char __user *dev_name,
 				 const char __user *dir_name,
 				 const char __user *type, unsigned long flags,
 				 const void __user *data);
 asmlinkage long compat_sys_old_readdir(unsigned int fd,
 				       struct compat_old_linux_dirent __user *,
 				       unsigned int count);
 asmlinkage long compat_sys_getdents(unsigned int fd,
 				    struct compat_linux_dirent __user *dirent,
 				    unsigned int count);
 asmlinkage long compat_sys_getdents64(unsigned int fd,
 				      struct linux_dirent64 __user *dirent,
 				      unsigned int count);
 asmlinkage long compat_sys_vmsplice(int fd, const struct compat_iovec __user *,
 				    unsigned int nr_segs, unsigned int flags);
 asmlinkage long compat_sys_open(const char __user *filename, int flags,
 				umode_t mode);
 asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
 				  int flags, umode_t mode);
 asmlinkage long compat_sys_open_by_handle_at(int mountdirfd,
 					     struct file_handle __user *handle,
 					     int flags);
 asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
 				    compat_ulong_t __user *outp,
 				    compat_ulong_t __user *exp,
 				    struct compat_timespec __user *tsp,
 				    void __user *sig);
 asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
 				 unsigned int nfds,
 				 struct compat_timespec __user *tsp,
 				 const compat_sigset_t __user *sigmask,
 				 compat_size_t sigsetsize);
 asmlinkage long compat_sys_signalfd4(int ufd,
 				     const compat_sigset_t __user *sigmask,
 				     compat_size_t sigsetsize, int flags);
 asmlinkage long compat_sys_get_mempolicy(int __user *policy,
 					 compat_ulong_t __user *nmask,
 					 compat_ulong_t maxnode,
 					 compat_ulong_t addr,
 					 compat_ulong_t flags);
 asmlinkage long compat_sys_set_mempolicy(int mode, compat_ulong_t __user *nmask,
 					 compat_ulong_t maxnode);
 asmlinkage long compat_sys_mbind(compat_ulong_t start, compat_ulong_t len,
 				 compat_ulong_t mode,
 				 compat_ulong_t __user *nmask,
 				 compat_ulong_t maxnode, compat_ulong_t flags);
 asmlinkage long compat_sys_setsockopt(int fd, int level, int optname,
 				      char __user *optval, unsigned int optlen);
 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg,
 				   unsigned flags);
 asmlinkage long compat_sys_sendmmsg(int fd, struct compat_mmsghdr __user *mmsg,
 				    unsigned vlen, unsigned int flags);
 asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg,
 				   unsigned int flags);
 asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len,
 				unsigned flags);
 asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, size_t len,
 			    unsigned flags, struct sockaddr __user *addr,
 			    int __user *addrlen);
 asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
 				    unsigned vlen, unsigned int flags,
 				    struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
 				     struct compat_timespec __user *rmtp);
 asmlinkage long compat_sys_getitimer(int which,
 				     struct compat_itimerval __user *it);
 asmlinkage long compat_sys_setitimer(int which,
 				     struct compat_itimerval __user *in,
 				     struct compat_itimerval __user *out);
 asmlinkage long compat_sys_times(struct compat_tms __user *tbuf);
 asmlinkage long compat_sys_setrlimit(unsigned int resource,
 				     struct compat_rlimit __user *rlim);
 asmlinkage long compat_sys_getrlimit(unsigned int resource,
 				     struct compat_rlimit __user *rlim);
 asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru);
 asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
 				     unsigned int len,
 				     compat_ulong_t __user *user_mask_ptr);
 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid,
 				     unsigned int len,
 				     compat_ulong_t __user *user_mask_ptr);
 asmlinkage long compat_sys_timer_create(clockid_t which_clock,
 			struct compat_sigevent __user *timer_event_spec,
 			timer_t __user *created_timer_id);
 asmlinkage long compat_sys_timer_settime(timer_t timer_id, int flags,
 					 struct compat_itimerspec __user *new,
 					 struct compat_itimerspec __user *old);
 asmlinkage long compat_sys_timer_gettime(timer_t timer_id,
 				 struct compat_itimerspec __user *setting);
 asmlinkage long compat_sys_clock_settime(clockid_t which_clock,
 					 struct compat_timespec __user *tp);
 asmlinkage long compat_sys_clock_gettime(clockid_t which_clock,
 					 struct compat_timespec __user *tp);
 asmlinkage long compat_sys_clock_adjtime(clockid_t which_clock,
 					 struct compat_timex __user *tp);
 asmlinkage long compat_sys_clock_getres(clockid_t which_clock,
 					struct compat_timespec __user *tp);
 asmlinkage long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
 					   struct compat_timespec __user *rqtp,
 					   struct compat_timespec __user *rmtp);
 asmlinkage long compat_sys_rt_sigtimedwait(compat_sigset_t __user *uthese,
 		struct compat_siginfo __user *uinfo,
 		struct compat_timespec __user *uts, compat_size_t sigsetsize);
 asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset,
 					 compat_size_t sigsetsize);
 asmlinkage long compat_sys_sysinfo(struct compat_sysinfo __user *info);
 asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
 				 unsigned long arg);
 asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val,
 		struct compat_timespec __user *utime, u32 __user *uaddr2,
 		u32 val3);
 asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,
 				      char __user *optval, int __user *optlen);
 asmlinkage long compat_sys_kexec_load(unsigned long entry,
 				      unsigned long nr_segments,
 				      struct compat_kexec_segment __user *,
 				      unsigned long flags);
 asmlinkage long compat_sys_mq_getsetattr(mqd_t mqdes,
 			const struct compat_mq_attr __user *u_mqstat,
 			struct compat_mq_attr __user *u_omqstat);
 asmlinkage long compat_sys_mq_notify(mqd_t mqdes,
 			const struct compat_sigevent __user *u_notification);
 asmlinkage long compat_sys_mq_open(const char __user *u_name,
 			int oflag, compat_mode_t mode,
 			struct compat_mq_attr __user *u_attr);
 asmlinkage long compat_sys_mq_timedsend(mqd_t mqdes,
 			const char __user *u_msg_ptr,
 			size_t msg_len, unsigned int msg_prio,
 			const struct compat_timespec __user *u_abs_timeout);
 asmlinkage ssize_t compat_sys_mq_timedreceive(mqd_t mqdes,
 			char __user *u_msg_ptr,
 			size_t msg_len, unsigned int __user *u_msg_prio,
 			const struct compat_timespec __user *u_abs_timeout);
 asmlinkage long compat_sys_socketcall(int call, u32 __user *args);
 asmlinkage long compat_sys_sysctl(struct compat_sysctl_args __user *args);
 extern ssize_t compat_rw_copy_check_uvector(int type,
 		const struct compat_iovec __user *uvector,
 		unsigned long nr_segs,
 		unsigned long fast_segs, struct iovec *fast_pointer,
 		struct iovec **ret_pointer);
 extern void __user *compat_alloc_user_space(unsigned long len);
 asmlinkage ssize_t compat_sys_process_vm_readv(compat_pid_t pid,
 		const struct compat_iovec __user *lvec,
 		unsigned long liovcnt, const struct compat_iovec __user *rvec,
 		unsigned long riovcnt, unsigned long flags);
 asmlinkage ssize_t compat_sys_process_vm_writev(compat_pid_t pid,
 		const struct compat_iovec __user *lvec,
 		unsigned long liovcnt, const struct compat_iovec __user *rvec,
 		unsigned long riovcnt, unsigned long flags);
 asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
 				    compat_off_t __user *offset, compat_size_t count);
 #else
 #define is_compat_task() (0)
 #endif /* CONFIG_COMPAT */
 #endif /* _LINUX_COMPAT_H */