/* * Conversion between 32-bit and 64-bit native system calls. * * Copyright (C) 2000 Silicon Graphics, Inc. * Written by Ulf Carlsson (ulfc@engr.sgi.com) * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com) */#include <linux/compiler.h>#include <linux/mm.h>#include <linux/errno.h>#include <linux/file.h>#include <linux/smp_lock.h>#include <linux/highuid.h>#include <linux/dirent.h>#include <linux/resource.h>#include <linux/highmem.h>#include <linux/time.h>#include <linux/times.h>#include <linux/poll.h>#include <linux/slab.h>#include <linux/skbuff.h>#include <linux/filter.h>#include <linux/shm.h>#include <linux/sem.h>#include <linux/msg.h>#include <linux/icmpv6.h>#include <linux/syscalls.h>#include <linux/sysctl.h>#include <linux/utime.h>#include <linux/utsname.h>#include <linux/personality.h>#include <linux/dnotify.h>#include <linux/module.h>#include <linux/binfmts.h>#include <linux/security.h>#include <linux/compat.h>#include <linux/vfs.h> #include <net/sock.h>#include <net/scm.h> #include <asm/ipc.h>#include <asm/sim.h>#include <asm/uaccess.h>#include <asm/mmu_context.h>#include <asm/mman.h> /* Use this to get at 32-bit user passed pointers. *//* A() macro should be used for places where you e.g.   have some internal variable u32 and just want to get   rid of a compiler warning. AA() has to be used in   places where you want to convert a function argument   to 32bit pointer or when you e.g. access pt_regs   structure and want to consider 32bit registers only. */#define A(__x) ((unsigned long)(__x))#define AA(__x) ((unsigned long)((int)__x)) #ifdef __MIPSEB__#define merge_64(r1,r2)	((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL))#endif#ifdef __MIPSEL__#define merge_64(r1,r2)	((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL))#endif /* * Revalidate the inode. This is required for proper NFS attribute caching. */ int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf){	struct compat_stat tmp; 	if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))		return -EOVERFLOW; 	memset(&tmp, 0, sizeof(tmp));	tmp.st_dev = new_encode_dev(stat->dev);	tmp.st_ino = stat->ino;	if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)		return -EOVERFLOW;	tmp.st_mode = stat->mode;	tmp.st_nlink = stat->nlink;	SET_UID(tmp.st_uid, stat->uid);	SET_GID(tmp.st_gid, stat->gid);	tmp.st_rdev = new_encode_dev(stat->rdev);	tmp.st_size = stat->size;	tmp.st_atime = stat->atime.tv_sec;	tmp.st_mtime = stat->mtime.tv_sec;	tmp.st_ctime = stat->ctime.tv_sec;#ifdef STAT_HAVE_NSEC	tmp.st_atime_nsec = stat->atime.tv_nsec;	tmp.st_mtime_nsec = stat->mtime.tv_nsec;	tmp.st_ctime_nsec = stat->ctime.tv_nsec;#endif	tmp.st_blocks = stat->blocks;	tmp.st_blksize = stat->blksize;	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;} asmlinkage unsigned longsys32_mmap2(unsigned long addr, unsigned long len, unsigned long prot,         unsigned long flags, unsigned long fd, unsigned long pgoff){	struct file * file = NULL;	unsigned long error; 	error = -EINVAL;	if (pgoff & (~PAGE_MASK >> 12))		goto out;	pgoff >>= PAGE_SHIFT-12; 	if (!(flags & MAP_ANONYMOUS)) {		error = -EBADF;		file = fget(fd);		if (!file)			goto out;	}	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); 	down_write(&current->mm->mmap_sem);	error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);	up_write(&current->mm->mmap_sem);	if (file)		fput(file); out:	return error;}  asmlinkage int sys_truncate64(const char __user *path, unsigned int high,			      unsigned int low){	if ((int)high < 0)		return -EINVAL;	return sys_truncate(path, ((long) high << 32) | low);} asmlinkage int sys_ftruncate64(unsigned int fd, unsigned int high,			       unsigned int low){	if ((int)high < 0)		return -EINVAL;	return sys_ftruncate(fd, ((long) high << 32) | low);} /* * sys_execve() executes a new program. */asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs){	int error;	char * filename; 	filename = getname(compat_ptr(regs.regs[4]));	error = PTR_ERR(filename);	if (IS_ERR(filename))		goto out;	error = compat_do_execve(filename, compat_ptr(regs.regs[5]),				 compat_ptr(regs.regs[6]), &regs);	putname(filename); out:	return error;} asmlinkage longsysn32_waitid(int which, compat_pid_t pid,	      siginfo_t __user *uinfo, int options,	      struct compat_rusage __user *uru){	struct rusage ru;	long ret;	mm_segment_t old_fs = get_fs();	int si_signo; 	if (!access_ok(VERIFY_WRITE, uinfo, sizeof(*uinfo)))		return -EFAULT; 	set_fs (KERNEL_DS);	ret = sys_waitid(which, pid, uinfo, options,			 uru ? (struct rusage __user *) &ru : NULL);	set_fs (old_fs); 	if (__get_user(si_signo, &uinfo->si_signo))		return -EFAULT;	if (ret < 0 || si_signo == 0)		return ret; 	if (uru)		ret = put_compat_rusage(&ru, uru);	return ret;} struct sysinfo32 {        s32 uptime;        u32 loads[3];        u32 totalram;        u32 freeram;        u32 sharedram;        u32 bufferram;        u32 totalswap;        u32 freeswap;        u16 procs;	u32 totalhigh;	u32 freehigh;	u32 mem_unit;	char _f[8];}; asmlinkage int sys32_sysinfo(struct sysinfo32 __user *info){	struct sysinfo s;	int ret, err;	mm_segment_t old_fs = get_fs (); 	set_fs (KERNEL_DS);	ret = sys_sysinfo((struct sysinfo __user *)&s);	set_fs (old_fs);	err = put_user (s.uptime, &info->uptime);	err |= __put_user (s.loads[0], &info->loads[0]);	err |= __put_user (s.loads[1], &info->loads[1]);	err |= __put_user (s.loads[2], &info->loads[2]);	err |= __put_user (s.totalram, &info->totalram);	err |= __put_user (s.freeram, &info->freeram);	err |= __put_user (s.sharedram, &info->sharedram);	err |= __put_user (s.bufferram, &info->bufferram);	err |= __put_user (s.totalswap, &info->totalswap);	err |= __put_user (s.freeswap, &info->freeswap);	err |= __put_user (s.procs, &info->procs);	err |= __put_user (s.totalhigh, &info->totalhigh);	err |= __put_user (s.freehigh, &info->freehigh);	err |= __put_user (s.mem_unit, &info->mem_unit);	if (err)		return -EFAULT;	return ret;} #define RLIM_INFINITY32	0x7fffffff#define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x) struct rlimit32 {	int	rlim_cur;	int	rlim_max;}; #ifdef __MIPSEB__asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy,	int length_hi, int length_lo)#endif#ifdef __MIPSEL__asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy,	int length_lo, int length_hi)#endif{	loff_t length; 	length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo; 	return sys_truncate(path, length);} #ifdef __MIPSEB__asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy,	int length_hi, int length_lo)#endif#ifdef __MIPSEL__asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy,	int length_lo, int length_hi)#endif{	loff_t length; 	length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo; 	return sys_ftruncate(fd, length);} static inline longget_tv32(struct timeval *o, struct compat_timeval __user *i){	return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||		(__get_user(o->tv_sec, &i->tv_sec) |		 __get_user(o->tv_usec, &i->tv_usec)));} static inline longput_tv32(struct compat_timeval __user *o, struct timeval *i){	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||		(__put_user(i->tv_sec, &o->tv_sec) |		 __put_user(i->tv_usec, &o->tv_usec)));} extern struct timezone sys_tz; asmlinkage intsys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz){	if (tv) {		struct timeval ktv;		do_gettimeofday(&ktv);		if (put_tv32(tv, &ktv))			return -EFAULT;	}	if (tz) {		if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))			return -EFAULT;	}	return 0;} static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i){	long usec; 	if (!access_ok(VERIFY_READ, i, sizeof(*i)))		return -EFAULT;	if (__get_user(o->tv_sec, &i->tv_sec))		return -EFAULT;	if (__get_user(usec, &i->tv_usec))		return -EFAULT;	o->tv_nsec = usec * 1000;		return 0;} asmlinkage intsys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz){	struct timespec kts;	struct timezone ktz;  	if (tv) {		if (get_ts32(&kts, tv))			return -EFAULT;	}	if (tz) {		if (copy_from_user(&ktz, tz, sizeof(ktz)))			return -EFAULT;	} 	return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);} asmlinkage int sys32_llseek(unsigned int fd, unsigned int offset_high,			    unsigned int offset_low, loff_t __user * result,			    unsigned int origin){	return sys_llseek(fd, offset_high, offset_low, result, origin);} /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +   lseek back to original location.  They fail just like lseek does on   non-seekable files.  */ asmlinkage ssize_t sys32_pread(unsigned int fd, char __user * buf,			       size_t count, u32 unused, u64 a4, u64 a5){	return sys_pread64(fd, buf, count, merge_64(a4, a5));} asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char __user * buf,			        size_t count, u32 unused, u64 a4, u64 a5){	return sys_pwrite64(fd, buf, count, merge_64(a4, a5));} asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid,	struct compat_timespec __user *interval){	struct timespec t;	int ret;	mm_segment_t old_fs = get_fs (); 	set_fs (KERNEL_DS);	ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);	set_fs (old_fs);	if (put_user (t.tv_sec, &interval->tv_sec) ||	    __put_user (t.tv_nsec, &interval->tv_nsec))		return -EFAULT;	return ret;} asmlinkage longsys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth){	int version, err; 	version = call >> 16; /* hack for backward compatibility */	call &= 0xffff; 	switch (call) {	case SEMOP:		/* struct sembuf is the same on 32 and 64bit :)) */		err = sys_semtimedop(first, compat_ptr(ptr), second, NULL);		break;	case SEMTIMEDOP:		err = compat_sys_semtimedop(first, compat_ptr(ptr), second,					    compat_ptr(fifth));		break;	case SEMGET:		err = sys_semget(first, second, third);		break;	case SEMCTL:		err = compat_sys_semctl(first, second, third, compat_ptr(ptr));		break;	case MSGSND:		err = compat_sys_msgsnd(first, second, third, compat_ptr(ptr));		break;	case MSGRCV:		err = compat_sys_msgrcv(first, second, fifth, third,					version, compat_ptr(ptr));		break;	case MSGGET:		err = sys_msgget((key_t) first, second);		break;	case MSGCTL:		err = compat_sys_msgctl(first, second, compat_ptr(ptr));		break;	case SHMAT:		err = compat_sys_shmat(first, second, third, version,				       compat_ptr(ptr));		break;	case SHMDT:		err = sys_shmdt(compat_ptr(ptr));		break;	case SHMGET:		err = sys_shmget(first, (unsigned)second, third);		break;	case SHMCTL:		err = compat_sys_shmctl(first, second, compat_ptr(ptr));		break;	default:		err = -EINVAL;		break;	} 	return err;} #ifdef CONFIG_MIPS32_N32asmlinkage long sysn32_semctl(int semid, int semnum, int cmd, u32 arg){	/* compat_sys_semctl expects a pointer to union semun */	u32 __user *uptr = compat_alloc_user_space(sizeof(u32));	if (put_user(arg, uptr))		return -EFAULT;	return compat_sys_semctl(semid, semnum, cmd, uptr);} asmlinkage long sysn32_msgsnd(int msqid, u32 msgp, unsigned msgsz, int msgflg){	return compat_sys_msgsnd(msqid, msgsz, msgflg, compat_ptr(msgp));} asmlinkage long sysn32_msgrcv(int msqid, u32 msgp, size_t msgsz, int msgtyp,			      int msgflg){	return compat_sys_msgrcv(msqid, msgsz, msgtyp, msgflg, IPC_64,				 compat_ptr(msgp));}#endif struct sysctl_args32{	compat_caddr_t name;	int nlen;	compat_caddr_t oldval;	compat_caddr_t oldlenp;	compat_caddr_t newval;	compat_size_t newlen;	unsigned int __unused[4];}; #ifdef CONFIG_SYSCTL_SYSCALL asmlinkage long sys32_sysctl(struct sysctl_args32 __user *args){	struct sysctl_args32 tmp;	int error;	size_t oldlen;	size_t __user *oldlenp = NULL;	unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7; 	if (copy_from_user(&tmp, args, sizeof(tmp)))		return -EFAULT; 	if (tmp.oldval && tmp.oldlenp) {		/* Duh, this is ugly and might not work if sysctl_args		   is in read-only memory, but do_sysctl does indirectly		   a lot of uaccess in both directions and we'd have to		   basically copy the whole sysctl.c here, and		   glibc's __sysctl uses rw memory for the structure		   anyway.  */		if (get_user(oldlen, (u32 __user *)A(tmp.oldlenp)) ||		    put_user(oldlen, (size_t __user *)addr))			return -EFAULT;		oldlenp = (size_t __user *)addr;	}

Lines 1–500 of 782. Load more