xref: /openbmc/linux/arch/mips/kernel/linux32.c (revision 05e4396651ca1cac51d8da9ff4992741c9dc1e39)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * Conversion between 32-bit and 64-bit native system calls.
31da177e4SLinus Torvalds  *
41da177e4SLinus Torvalds  * Copyright (C) 2000 Silicon Graphics, Inc.
51da177e4SLinus Torvalds  * Written by Ulf Carlsson (ulfc@engr.sgi.com)
61da177e4SLinus Torvalds  * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com)
71da177e4SLinus Torvalds  */
81da177e4SLinus Torvalds #include <linux/compiler.h>
91da177e4SLinus Torvalds #include <linux/mm.h>
101da177e4SLinus Torvalds #include <linux/errno.h>
111da177e4SLinus Torvalds #include <linux/file.h>
121da177e4SLinus Torvalds #include <linux/smp_lock.h>
131da177e4SLinus Torvalds #include <linux/highuid.h>
141da177e4SLinus Torvalds #include <linux/dirent.h>
151da177e4SLinus Torvalds #include <linux/resource.h>
161da177e4SLinus Torvalds #include <linux/highmem.h>
171da177e4SLinus Torvalds #include <linux/time.h>
181da177e4SLinus Torvalds #include <linux/times.h>
191da177e4SLinus Torvalds #include <linux/poll.h>
201da177e4SLinus Torvalds #include <linux/slab.h>
211da177e4SLinus Torvalds #include <linux/skbuff.h>
221da177e4SLinus Torvalds #include <linux/filter.h>
231da177e4SLinus Torvalds #include <linux/shm.h>
241da177e4SLinus Torvalds #include <linux/sem.h>
251da177e4SLinus Torvalds #include <linux/msg.h>
261da177e4SLinus Torvalds #include <linux/icmpv6.h>
271da177e4SLinus Torvalds #include <linux/syscalls.h>
281da177e4SLinus Torvalds #include <linux/sysctl.h>
291da177e4SLinus Torvalds #include <linux/utime.h>
301da177e4SLinus Torvalds #include <linux/utsname.h>
311da177e4SLinus Torvalds #include <linux/personality.h>
321da177e4SLinus Torvalds #include <linux/dnotify.h>
331da177e4SLinus Torvalds #include <linux/module.h>
341da177e4SLinus Torvalds #include <linux/binfmts.h>
351da177e4SLinus Torvalds #include <linux/security.h>
361da177e4SLinus Torvalds #include <linux/compat.h>
371da177e4SLinus Torvalds #include <linux/vfs.h>
381da177e4SLinus Torvalds 
391da177e4SLinus Torvalds #include <net/sock.h>
401da177e4SLinus Torvalds #include <net/scm.h>
411da177e4SLinus Torvalds 
421da177e4SLinus Torvalds #include <asm/ipc.h>
431da177e4SLinus Torvalds #include <asm/sim.h>
441da177e4SLinus Torvalds #include <asm/uaccess.h>
451da177e4SLinus Torvalds #include <asm/mmu_context.h>
461da177e4SLinus Torvalds #include <asm/mman.h>
471da177e4SLinus Torvalds 
481da177e4SLinus Torvalds /* Use this to get at 32-bit user passed pointers. */
491da177e4SLinus Torvalds /* A() macro should be used for places where you e.g.
501da177e4SLinus Torvalds    have some internal variable u32 and just want to get
511da177e4SLinus Torvalds    rid of a compiler warning. AA() has to be used in
521da177e4SLinus Torvalds    places where you want to convert a function argument
531da177e4SLinus Torvalds    to 32bit pointer or when you e.g. access pt_regs
541da177e4SLinus Torvalds    structure and want to consider 32bit registers only.
551da177e4SLinus Torvalds  */
561da177e4SLinus Torvalds #define A(__x) ((unsigned long)(__x))
571da177e4SLinus Torvalds #define AA(__x) ((unsigned long)((int)__x))
581da177e4SLinus Torvalds 
591da177e4SLinus Torvalds #ifdef __MIPSEB__
601da177e4SLinus Torvalds #define merge_64(r1,r2)	((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL))
611da177e4SLinus Torvalds #endif
621da177e4SLinus Torvalds #ifdef __MIPSEL__
631da177e4SLinus Torvalds #define merge_64(r1,r2)	((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL))
641da177e4SLinus Torvalds #endif
651da177e4SLinus Torvalds 
661da177e4SLinus Torvalds /*
671da177e4SLinus Torvalds  * Revalidate the inode. This is required for proper NFS attribute caching.
681da177e4SLinus Torvalds  */
691da177e4SLinus Torvalds 
70219ac73aSAtsushi Nemoto int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
711da177e4SLinus Torvalds {
721da177e4SLinus Torvalds 	struct compat_stat tmp;
731da177e4SLinus Torvalds 
741da177e4SLinus Torvalds 	if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
751da177e4SLinus Torvalds 		return -EOVERFLOW;
761da177e4SLinus Torvalds 
771da177e4SLinus Torvalds 	memset(&tmp, 0, sizeof(tmp));
781da177e4SLinus Torvalds 	tmp.st_dev = new_encode_dev(stat->dev);
791da177e4SLinus Torvalds 	tmp.st_ino = stat->ino;
80afefdbb2SDavid Howells 	if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
81afefdbb2SDavid Howells 		return -EOVERFLOW;
821da177e4SLinus Torvalds 	tmp.st_mode = stat->mode;
831da177e4SLinus Torvalds 	tmp.st_nlink = stat->nlink;
841da177e4SLinus Torvalds 	SET_UID(tmp.st_uid, stat->uid);
851da177e4SLinus Torvalds 	SET_GID(tmp.st_gid, stat->gid);
861da177e4SLinus Torvalds 	tmp.st_rdev = new_encode_dev(stat->rdev);
871da177e4SLinus Torvalds 	tmp.st_size = stat->size;
881da177e4SLinus Torvalds 	tmp.st_atime = stat->atime.tv_sec;
891da177e4SLinus Torvalds 	tmp.st_mtime = stat->mtime.tv_sec;
901da177e4SLinus Torvalds 	tmp.st_ctime = stat->ctime.tv_sec;
911da177e4SLinus Torvalds #ifdef STAT_HAVE_NSEC
921da177e4SLinus Torvalds 	tmp.st_atime_nsec = stat->atime.tv_nsec;
931da177e4SLinus Torvalds 	tmp.st_mtime_nsec = stat->mtime.tv_nsec;
941da177e4SLinus Torvalds 	tmp.st_ctime_nsec = stat->ctime.tv_nsec;
951da177e4SLinus Torvalds #endif
961da177e4SLinus Torvalds 	tmp.st_blocks = stat->blocks;
971da177e4SLinus Torvalds 	tmp.st_blksize = stat->blksize;
981da177e4SLinus Torvalds 	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
991da177e4SLinus Torvalds }
1001da177e4SLinus Torvalds 
1011da177e4SLinus Torvalds asmlinkage unsigned long
1021da177e4SLinus Torvalds sys32_mmap2(unsigned long addr, unsigned long len, unsigned long prot,
1031da177e4SLinus Torvalds          unsigned long flags, unsigned long fd, unsigned long pgoff)
1041da177e4SLinus Torvalds {
1051da177e4SLinus Torvalds 	struct file * file = NULL;
1061da177e4SLinus Torvalds 	unsigned long error;
1071da177e4SLinus Torvalds 
1081da177e4SLinus Torvalds 	error = -EINVAL;
109947df17cSH. Peter Anvin 	if (pgoff & (~PAGE_MASK >> 12))
110947df17cSH. Peter Anvin 		goto out;
111947df17cSH. Peter Anvin 	pgoff >>= PAGE_SHIFT-12;
112947df17cSH. Peter Anvin 
1131da177e4SLinus Torvalds 	if (!(flags & MAP_ANONYMOUS)) {
1141da177e4SLinus Torvalds 		error = -EBADF;
1151da177e4SLinus Torvalds 		file = fget(fd);
1161da177e4SLinus Torvalds 		if (!file)
1171da177e4SLinus Torvalds 			goto out;
1181da177e4SLinus Torvalds 	}
1191da177e4SLinus Torvalds 	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
1201da177e4SLinus Torvalds 
1211da177e4SLinus Torvalds 	down_write(&current->mm->mmap_sem);
1221da177e4SLinus Torvalds 	error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
1231da177e4SLinus Torvalds 	up_write(&current->mm->mmap_sem);
1241da177e4SLinus Torvalds 	if (file)
1251da177e4SLinus Torvalds 		fput(file);
1261da177e4SLinus Torvalds 
1271da177e4SLinus Torvalds out:
1281da177e4SLinus Torvalds 	return error;
1291da177e4SLinus Torvalds }
1301da177e4SLinus Torvalds 
1311da177e4SLinus Torvalds 
132219ac73aSAtsushi Nemoto asmlinkage int sys_truncate64(const char __user *path, unsigned int high,
1331da177e4SLinus Torvalds 			      unsigned int low)
1341da177e4SLinus Torvalds {
1351da177e4SLinus Torvalds 	if ((int)high < 0)
1361da177e4SLinus Torvalds 		return -EINVAL;
1371da177e4SLinus Torvalds 	return sys_truncate(path, ((long) high << 32) | low);
1381da177e4SLinus Torvalds }
1391da177e4SLinus Torvalds 
1401da177e4SLinus Torvalds asmlinkage int sys_ftruncate64(unsigned int fd, unsigned int high,
1411da177e4SLinus Torvalds 			       unsigned int low)
1421da177e4SLinus Torvalds {
1431da177e4SLinus Torvalds 	if ((int)high < 0)
1441da177e4SLinus Torvalds 		return -EINVAL;
1451da177e4SLinus Torvalds 	return sys_ftruncate(fd, ((long) high << 32) | low);
1461da177e4SLinus Torvalds }
1471da177e4SLinus Torvalds 
1481da177e4SLinus Torvalds /*
1491da177e4SLinus Torvalds  * sys_execve() executes a new program.
1501da177e4SLinus Torvalds  */
1511da177e4SLinus Torvalds asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs)
1521da177e4SLinus Torvalds {
1531da177e4SLinus Torvalds 	int error;
1541da177e4SLinus Torvalds 	char * filename;
1551da177e4SLinus Torvalds 
1561da177e4SLinus Torvalds 	filename = getname(compat_ptr(regs.regs[4]));
1571da177e4SLinus Torvalds 	error = PTR_ERR(filename);
1581da177e4SLinus Torvalds 	if (IS_ERR(filename))
1591da177e4SLinus Torvalds 		goto out;
1601da177e4SLinus Torvalds 	error = compat_do_execve(filename, compat_ptr(regs.regs[5]),
1611da177e4SLinus Torvalds 				 compat_ptr(regs.regs[6]), &regs);
1621da177e4SLinus Torvalds 	putname(filename);
1631da177e4SLinus Torvalds 
1641da177e4SLinus Torvalds out:
1651da177e4SLinus Torvalds 	return error;
1661da177e4SLinus Torvalds }
1671da177e4SLinus Torvalds 
16854f2da75SRalf Baechle asmlinkage long
16954f2da75SRalf Baechle sysn32_waitid(int which, compat_pid_t pid,
17054f2da75SRalf Baechle 	      siginfo_t __user *uinfo, int options,
17154f2da75SRalf Baechle 	      struct compat_rusage __user *uru)
17254f2da75SRalf Baechle {
17354f2da75SRalf Baechle 	struct rusage ru;
17454f2da75SRalf Baechle 	long ret;
17554f2da75SRalf Baechle 	mm_segment_t old_fs = get_fs();
176219ac73aSAtsushi Nemoto 	int si_signo;
17754f2da75SRalf Baechle 
178f3468e0cSRalf Baechle 	if (!access_ok(VERIFY_WRITE, uinfo, sizeof(*uinfo)))
179f3468e0cSRalf Baechle 		return -EFAULT;
180f3468e0cSRalf Baechle 
18154f2da75SRalf Baechle 	set_fs (KERNEL_DS);
18254f2da75SRalf Baechle 	ret = sys_waitid(which, pid, uinfo, options,
18354f2da75SRalf Baechle 			 uru ? (struct rusage __user *) &ru : NULL);
18454f2da75SRalf Baechle 	set_fs (old_fs);
18554f2da75SRalf Baechle 
186219ac73aSAtsushi Nemoto 	if (__get_user(si_signo, &uinfo->si_signo))
187219ac73aSAtsushi Nemoto 		return -EFAULT;
188219ac73aSAtsushi Nemoto 	if (ret < 0 || si_signo == 0)
18954f2da75SRalf Baechle 		return ret;
19054f2da75SRalf Baechle 
19154f2da75SRalf Baechle 	if (uru)
19254f2da75SRalf Baechle 		ret = put_compat_rusage(&ru, uru);
19354f2da75SRalf Baechle 	return ret;
19454f2da75SRalf Baechle }
19554f2da75SRalf Baechle 
1961da177e4SLinus Torvalds struct sysinfo32 {
1971da177e4SLinus Torvalds         s32 uptime;
1981da177e4SLinus Torvalds         u32 loads[3];
1991da177e4SLinus Torvalds         u32 totalram;
2001da177e4SLinus Torvalds         u32 freeram;
2011da177e4SLinus Torvalds         u32 sharedram;
2021da177e4SLinus Torvalds         u32 bufferram;
2031da177e4SLinus Torvalds         u32 totalswap;
2041da177e4SLinus Torvalds         u32 freeswap;
2051da177e4SLinus Torvalds         u16 procs;
2061da177e4SLinus Torvalds 	u32 totalhigh;
2071da177e4SLinus Torvalds 	u32 freehigh;
2081da177e4SLinus Torvalds 	u32 mem_unit;
2091da177e4SLinus Torvalds 	char _f[8];
2101da177e4SLinus Torvalds };
2111da177e4SLinus Torvalds 
212219ac73aSAtsushi Nemoto asmlinkage int sys32_sysinfo(struct sysinfo32 __user *info)
2131da177e4SLinus Torvalds {
2141da177e4SLinus Torvalds 	struct sysinfo s;
2151da177e4SLinus Torvalds 	int ret, err;
2161da177e4SLinus Torvalds 	mm_segment_t old_fs = get_fs ();
2171da177e4SLinus Torvalds 
2181da177e4SLinus Torvalds 	set_fs (KERNEL_DS);
219219ac73aSAtsushi Nemoto 	ret = sys_sysinfo((struct sysinfo __user *)&s);
2201da177e4SLinus Torvalds 	set_fs (old_fs);
2211da177e4SLinus Torvalds 	err = put_user (s.uptime, &info->uptime);
2221da177e4SLinus Torvalds 	err |= __put_user (s.loads[0], &info->loads[0]);
2231da177e4SLinus Torvalds 	err |= __put_user (s.loads[1], &info->loads[1]);
2241da177e4SLinus Torvalds 	err |= __put_user (s.loads[2], &info->loads[2]);
2251da177e4SLinus Torvalds 	err |= __put_user (s.totalram, &info->totalram);
2261da177e4SLinus Torvalds 	err |= __put_user (s.freeram, &info->freeram);
2271da177e4SLinus Torvalds 	err |= __put_user (s.sharedram, &info->sharedram);
2281da177e4SLinus Torvalds 	err |= __put_user (s.bufferram, &info->bufferram);
2291da177e4SLinus Torvalds 	err |= __put_user (s.totalswap, &info->totalswap);
2301da177e4SLinus Torvalds 	err |= __put_user (s.freeswap, &info->freeswap);
2311da177e4SLinus Torvalds 	err |= __put_user (s.procs, &info->procs);
2321da177e4SLinus Torvalds 	err |= __put_user (s.totalhigh, &info->totalhigh);
2331da177e4SLinus Torvalds 	err |= __put_user (s.freehigh, &info->freehigh);
2341da177e4SLinus Torvalds 	err |= __put_user (s.mem_unit, &info->mem_unit);
2351da177e4SLinus Torvalds 	if (err)
2361da177e4SLinus Torvalds 		return -EFAULT;
2371da177e4SLinus Torvalds 	return ret;
2381da177e4SLinus Torvalds }
2391da177e4SLinus Torvalds 
2401da177e4SLinus Torvalds #define RLIM_INFINITY32	0x7fffffff
2411da177e4SLinus Torvalds #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
2421da177e4SLinus Torvalds 
2431da177e4SLinus Torvalds struct rlimit32 {
2441da177e4SLinus Torvalds 	int	rlim_cur;
2451da177e4SLinus Torvalds 	int	rlim_max;
2461da177e4SLinus Torvalds };
2471da177e4SLinus Torvalds 
2481da177e4SLinus Torvalds #ifdef __MIPSEB__
249219ac73aSAtsushi Nemoto asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy,
2501da177e4SLinus Torvalds 	int length_hi, int length_lo)
2511da177e4SLinus Torvalds #endif
2521da177e4SLinus Torvalds #ifdef __MIPSEL__
253219ac73aSAtsushi Nemoto asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy,
2541da177e4SLinus Torvalds 	int length_lo, int length_hi)
2551da177e4SLinus Torvalds #endif
2561da177e4SLinus Torvalds {
2571da177e4SLinus Torvalds 	loff_t length;
2581da177e4SLinus Torvalds 
2591da177e4SLinus Torvalds 	length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo;
2601da177e4SLinus Torvalds 
2611da177e4SLinus Torvalds 	return sys_truncate(path, length);
2621da177e4SLinus Torvalds }
2631da177e4SLinus Torvalds 
2641da177e4SLinus Torvalds #ifdef __MIPSEB__
2651da177e4SLinus Torvalds asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy,
2661da177e4SLinus Torvalds 	int length_hi, int length_lo)
2671da177e4SLinus Torvalds #endif
2681da177e4SLinus Torvalds #ifdef __MIPSEL__
2691da177e4SLinus Torvalds asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy,
2701da177e4SLinus Torvalds 	int length_lo, int length_hi)
2711da177e4SLinus Torvalds #endif
2721da177e4SLinus Torvalds {
2731da177e4SLinus Torvalds 	loff_t length;
2741da177e4SLinus Torvalds 
2751da177e4SLinus Torvalds 	length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo;
2761da177e4SLinus Torvalds 
2771da177e4SLinus Torvalds 	return sys_ftruncate(fd, length);
2781da177e4SLinus Torvalds }
2791da177e4SLinus Torvalds 
2801da177e4SLinus Torvalds static inline long
281219ac73aSAtsushi Nemoto get_tv32(struct timeval *o, struct compat_timeval __user *i)
2821da177e4SLinus Torvalds {
2831da177e4SLinus Torvalds 	return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
2841da177e4SLinus Torvalds 		(__get_user(o->tv_sec, &i->tv_sec) |
2851da177e4SLinus Torvalds 		 __get_user(o->tv_usec, &i->tv_usec)));
2861da177e4SLinus Torvalds }
2871da177e4SLinus Torvalds 
2881da177e4SLinus Torvalds static inline long
289219ac73aSAtsushi Nemoto put_tv32(struct compat_timeval __user *o, struct timeval *i)
2901da177e4SLinus Torvalds {
2911da177e4SLinus Torvalds 	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
2921da177e4SLinus Torvalds 		(__put_user(i->tv_sec, &o->tv_sec) |
2931da177e4SLinus Torvalds 		 __put_user(i->tv_usec, &o->tv_usec)));
2941da177e4SLinus Torvalds }
2951da177e4SLinus Torvalds 
2961da177e4SLinus Torvalds extern struct timezone sys_tz;
2971da177e4SLinus Torvalds 
2981da177e4SLinus Torvalds asmlinkage int
299219ac73aSAtsushi Nemoto sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
3001da177e4SLinus Torvalds {
3011da177e4SLinus Torvalds 	if (tv) {
3021da177e4SLinus Torvalds 		struct timeval ktv;
3031da177e4SLinus Torvalds 		do_gettimeofday(&ktv);
3041da177e4SLinus Torvalds 		if (put_tv32(tv, &ktv))
3051da177e4SLinus Torvalds 			return -EFAULT;
3061da177e4SLinus Torvalds 	}
3071da177e4SLinus Torvalds 	if (tz) {
3081da177e4SLinus Torvalds 		if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
3091da177e4SLinus Torvalds 			return -EFAULT;
3101da177e4SLinus Torvalds 	}
3111da177e4SLinus Torvalds 	return 0;
3121da177e4SLinus Torvalds }
3131da177e4SLinus Torvalds 
314219ac73aSAtsushi Nemoto static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
3151da177e4SLinus Torvalds {
3161da177e4SLinus Torvalds 	long usec;
3171da177e4SLinus Torvalds 
3181da177e4SLinus Torvalds 	if (!access_ok(VERIFY_READ, i, sizeof(*i)))
3191da177e4SLinus Torvalds 		return -EFAULT;
3201da177e4SLinus Torvalds 	if (__get_user(o->tv_sec, &i->tv_sec))
3211da177e4SLinus Torvalds 		return -EFAULT;
3221da177e4SLinus Torvalds 	if (__get_user(usec, &i->tv_usec))
3231da177e4SLinus Torvalds 		return -EFAULT;
3241da177e4SLinus Torvalds 	o->tv_nsec = usec * 1000;
3251da177e4SLinus Torvalds 		return 0;
3261da177e4SLinus Torvalds }
3271da177e4SLinus Torvalds 
3281da177e4SLinus Torvalds asmlinkage int
329219ac73aSAtsushi Nemoto sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
3301da177e4SLinus Torvalds {
3311da177e4SLinus Torvalds 	struct timespec kts;
3321da177e4SLinus Torvalds 	struct timezone ktz;
3331da177e4SLinus Torvalds 
3341da177e4SLinus Torvalds  	if (tv) {
3351da177e4SLinus Torvalds 		if (get_ts32(&kts, tv))
3361da177e4SLinus Torvalds 			return -EFAULT;
3371da177e4SLinus Torvalds 	}
3381da177e4SLinus Torvalds 	if (tz) {
3391da177e4SLinus Torvalds 		if (copy_from_user(&ktz, tz, sizeof(ktz)))
3401da177e4SLinus Torvalds 			return -EFAULT;
3411da177e4SLinus Torvalds 	}
3421da177e4SLinus Torvalds 
3431da177e4SLinus Torvalds 	return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
3441da177e4SLinus Torvalds }
3451da177e4SLinus Torvalds 
3461da177e4SLinus Torvalds asmlinkage int sys32_llseek(unsigned int fd, unsigned int offset_high,
347219ac73aSAtsushi Nemoto 			    unsigned int offset_low, loff_t __user * result,
3481da177e4SLinus Torvalds 			    unsigned int origin)
3491da177e4SLinus Torvalds {
3501da177e4SLinus Torvalds 	return sys_llseek(fd, offset_high, offset_low, result, origin);
3511da177e4SLinus Torvalds }
3521da177e4SLinus Torvalds 
3531da177e4SLinus Torvalds /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +
3541da177e4SLinus Torvalds    lseek back to original location.  They fail just like lseek does on
3551da177e4SLinus Torvalds    non-seekable files.  */
3561da177e4SLinus Torvalds 
357219ac73aSAtsushi Nemoto asmlinkage ssize_t sys32_pread(unsigned int fd, char __user * buf,
3581da177e4SLinus Torvalds 			       size_t count, u32 unused, u64 a4, u64 a5)
3591da177e4SLinus Torvalds {
3606ad0013bSAl Viro 	return sys_pread64(fd, buf, count, merge_64(a4, a5));
3611da177e4SLinus Torvalds }
3621da177e4SLinus Torvalds 
363219ac73aSAtsushi Nemoto asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char __user * buf,
3641da177e4SLinus Torvalds 			        size_t count, u32 unused, u64 a4, u64 a5)
3651da177e4SLinus Torvalds {
3666ad0013bSAl Viro 	return sys_pwrite64(fd, buf, count, merge_64(a4, a5));
3671da177e4SLinus Torvalds }
3681da177e4SLinus Torvalds 
3691da177e4SLinus Torvalds asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid,
370219ac73aSAtsushi Nemoto 	struct compat_timespec __user *interval)
3711da177e4SLinus Torvalds {
3721da177e4SLinus Torvalds 	struct timespec t;
3731da177e4SLinus Torvalds 	int ret;
3741da177e4SLinus Torvalds 	mm_segment_t old_fs = get_fs ();
3751da177e4SLinus Torvalds 
3761da177e4SLinus Torvalds 	set_fs (KERNEL_DS);
377219ac73aSAtsushi Nemoto 	ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
3781da177e4SLinus Torvalds 	set_fs (old_fs);
3791da177e4SLinus Torvalds 	if (put_user (t.tv_sec, &interval->tv_sec) ||
3801da177e4SLinus Torvalds 	    __put_user (t.tv_nsec, &interval->tv_nsec))
3811da177e4SLinus Torvalds 		return -EFAULT;
3821da177e4SLinus Torvalds 	return ret;
3831da177e4SLinus Torvalds }
3841da177e4SLinus Torvalds 
3851da177e4SLinus Torvalds asmlinkage long
3861da177e4SLinus Torvalds sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth)
3871da177e4SLinus Torvalds {
3881da177e4SLinus Torvalds 	int version, err;
3891da177e4SLinus Torvalds 
3901da177e4SLinus Torvalds 	version = call >> 16; /* hack for backward compatibility */
3911da177e4SLinus Torvalds 	call &= 0xffff;
3921da177e4SLinus Torvalds 
3931da177e4SLinus Torvalds 	switch (call) {
3941da177e4SLinus Torvalds 	case SEMOP:
3951da177e4SLinus Torvalds 		/* struct sembuf is the same on 32 and 64bit :)) */
396*05e43966SAtsushi Nemoto 		err = sys_semtimedop(first, compat_ptr(ptr), second, NULL);
3971da177e4SLinus Torvalds 		break;
3981da177e4SLinus Torvalds 	case SEMTIMEDOP:
399*05e43966SAtsushi Nemoto 		err = compat_sys_semtimedop(first, compat_ptr(ptr), second,
400*05e43966SAtsushi Nemoto 					    compat_ptr(fifth));
4011da177e4SLinus Torvalds 		break;
4021da177e4SLinus Torvalds 	case SEMGET:
4031da177e4SLinus Torvalds 		err = sys_semget(first, second, third);
4041da177e4SLinus Torvalds 		break;
4051da177e4SLinus Torvalds 	case SEMCTL:
406*05e43966SAtsushi Nemoto 		err = compat_sys_semctl(first, second, third, compat_ptr(ptr));
4071da177e4SLinus Torvalds 		break;
4081da177e4SLinus Torvalds 	case MSGSND:
409*05e43966SAtsushi Nemoto 		err = compat_sys_msgsnd(first, second, third, compat_ptr(ptr));
4101da177e4SLinus Torvalds 		break;
4111da177e4SLinus Torvalds 	case MSGRCV:
412*05e43966SAtsushi Nemoto 		err = compat_sys_msgrcv(first, second, fifth, third,
413*05e43966SAtsushi Nemoto 					version, compat_ptr(ptr));
4141da177e4SLinus Torvalds 		break;
4151da177e4SLinus Torvalds 	case MSGGET:
4161da177e4SLinus Torvalds 		err = sys_msgget((key_t) first, second);
4171da177e4SLinus Torvalds 		break;
4181da177e4SLinus Torvalds 	case MSGCTL:
419*05e43966SAtsushi Nemoto 		err = compat_sys_msgctl(first, second, compat_ptr(ptr));
4201da177e4SLinus Torvalds 		break;
4211da177e4SLinus Torvalds 	case SHMAT:
422*05e43966SAtsushi Nemoto 		err = compat_sys_shmat(first, second, third, version,
423*05e43966SAtsushi Nemoto 				       compat_ptr(ptr));
4241da177e4SLinus Torvalds 		break;
4251da177e4SLinus Torvalds 	case SHMDT:
426*05e43966SAtsushi Nemoto 		err = sys_shmdt(compat_ptr(ptr));
4271da177e4SLinus Torvalds 		break;
4281da177e4SLinus Torvalds 	case SHMGET:
4291da177e4SLinus Torvalds 		err = sys_shmget(first, (unsigned)second, third);
4301da177e4SLinus Torvalds 		break;
4311da177e4SLinus Torvalds 	case SHMCTL:
432*05e43966SAtsushi Nemoto 		err = compat_sys_shmctl(first, second, compat_ptr(ptr));
4331da177e4SLinus Torvalds 		break;
4341da177e4SLinus Torvalds 	default:
4351da177e4SLinus Torvalds 		err = -EINVAL;
4361da177e4SLinus Torvalds 		break;
4371da177e4SLinus Torvalds 	}
4381da177e4SLinus Torvalds 
4391da177e4SLinus Torvalds 	return err;
4401da177e4SLinus Torvalds }
4411da177e4SLinus Torvalds 
442*05e43966SAtsushi Nemoto #ifdef CONFIG_MIPS32_N32
443*05e43966SAtsushi Nemoto asmlinkage long sysn32_semctl(int semid, int semnum, int cmd, union semun arg)
4441da177e4SLinus Torvalds {
445*05e43966SAtsushi Nemoto 	/* compat_sys_semctl expects a pointer to union semun */
446*05e43966SAtsushi Nemoto 	u32 __user *uptr = compat_alloc_user_space(sizeof(u32));
447*05e43966SAtsushi Nemoto 	if (put_user(ptr_to_compat(arg.__pad), uptr))
448*05e43966SAtsushi Nemoto 		return -EFAULT;
449*05e43966SAtsushi Nemoto 	return compat_sys_semctl(semid, semnum, cmd, uptr);
4501da177e4SLinus Torvalds }
451*05e43966SAtsushi Nemoto #endif
4521da177e4SLinus Torvalds 
4531da177e4SLinus Torvalds struct sysctl_args32
4541da177e4SLinus Torvalds {
4551da177e4SLinus Torvalds 	compat_caddr_t name;
4561da177e4SLinus Torvalds 	int nlen;
4571da177e4SLinus Torvalds 	compat_caddr_t oldval;
4581da177e4SLinus Torvalds 	compat_caddr_t oldlenp;
4591da177e4SLinus Torvalds 	compat_caddr_t newval;
4601da177e4SLinus Torvalds 	compat_size_t newlen;
4611da177e4SLinus Torvalds 	unsigned int __unused[4];
4621da177e4SLinus Torvalds };
4631da177e4SLinus Torvalds 
464b89a8171SEric W. Biederman #ifdef CONFIG_SYSCTL_SYSCALL
4651da177e4SLinus Torvalds 
466219ac73aSAtsushi Nemoto asmlinkage long sys32_sysctl(struct sysctl_args32 __user *args)
4671da177e4SLinus Torvalds {
4681da177e4SLinus Torvalds 	struct sysctl_args32 tmp;
4691da177e4SLinus Torvalds 	int error;
470219ac73aSAtsushi Nemoto 	size_t oldlen;
471219ac73aSAtsushi Nemoto 	size_t __user *oldlenp = NULL;
472219ac73aSAtsushi Nemoto 	unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7;
4731da177e4SLinus Torvalds 
4741da177e4SLinus Torvalds 	if (copy_from_user(&tmp, args, sizeof(tmp)))
4751da177e4SLinus Torvalds 		return -EFAULT;
4761da177e4SLinus Torvalds 
4771da177e4SLinus Torvalds 	if (tmp.oldval && tmp.oldlenp) {
4781da177e4SLinus Torvalds 		/* Duh, this is ugly and might not work if sysctl_args
4791da177e4SLinus Torvalds 		   is in read-only memory, but do_sysctl does indirectly
4801da177e4SLinus Torvalds 		   a lot of uaccess in both directions and we'd have to
4811da177e4SLinus Torvalds 		   basically copy the whole sysctl.c here, and
4821da177e4SLinus Torvalds 		   glibc's __sysctl uses rw memory for the structure
4831da177e4SLinus Torvalds 		   anyway.  */
484219ac73aSAtsushi Nemoto 		if (get_user(oldlen, (u32 __user *)A(tmp.oldlenp)) ||
485219ac73aSAtsushi Nemoto 		    put_user(oldlen, (size_t __user *)addr))
4861da177e4SLinus Torvalds 			return -EFAULT;
487219ac73aSAtsushi Nemoto 		oldlenp = (size_t __user *)addr;
4881da177e4SLinus Torvalds 	}
4891da177e4SLinus Torvalds 
4901da177e4SLinus Torvalds 	lock_kernel();
491219ac73aSAtsushi Nemoto 	error = do_sysctl((int __user *)A(tmp.name), tmp.nlen, (void __user *)A(tmp.oldval),
492219ac73aSAtsushi Nemoto 			  oldlenp, (void __user *)A(tmp.newval), tmp.newlen);
4931da177e4SLinus Torvalds 	unlock_kernel();
4941da177e4SLinus Torvalds 	if (oldlenp) {
4951da177e4SLinus Torvalds 		if (!error) {
496219ac73aSAtsushi Nemoto 			if (get_user(oldlen, (size_t __user *)addr) ||
497219ac73aSAtsushi Nemoto 			    put_user(oldlen, (u32 __user *)A(tmp.oldlenp)))
4981da177e4SLinus Torvalds 				error = -EFAULT;
4991da177e4SLinus Torvalds 		}
5001da177e4SLinus Torvalds 		copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
5011da177e4SLinus Torvalds 	}
5021da177e4SLinus Torvalds 	return error;
5031da177e4SLinus Torvalds }
5041da177e4SLinus Torvalds 
505b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL_SYSCALL */
5061da177e4SLinus Torvalds 
507219ac73aSAtsushi Nemoto asmlinkage long sys32_newuname(struct new_utsname __user * name)
5081da177e4SLinus Torvalds {
5091da177e4SLinus Torvalds 	int ret = 0;
5101da177e4SLinus Torvalds 
5111da177e4SLinus Torvalds 	down_read(&uts_sem);
512e9ff3990SSerge E. Hallyn 	if (copy_to_user(name, utsname(), sizeof *name))
5131da177e4SLinus Torvalds 		ret = -EFAULT;
5141da177e4SLinus Torvalds 	up_read(&uts_sem);
5151da177e4SLinus Torvalds 
5161da177e4SLinus Torvalds 	if (current->personality == PER_LINUX32 && !ret)
5171da177e4SLinus Torvalds 		if (copy_to_user(name->machine, "mips\0\0\0", 8))
5181da177e4SLinus Torvalds 			ret = -EFAULT;
5191da177e4SLinus Torvalds 
5201da177e4SLinus Torvalds 	return ret;
5211da177e4SLinus Torvalds }
5221da177e4SLinus Torvalds 
5231da177e4SLinus Torvalds asmlinkage int sys32_personality(unsigned long personality)
5241da177e4SLinus Torvalds {
5251da177e4SLinus Torvalds 	int ret;
52653571ce4SThiemo Seufer 	personality &= 0xffffffff;
52753571ce4SThiemo Seufer 	if (personality(current->personality) == PER_LINUX32 &&
52853571ce4SThiemo Seufer 	    personality == PER_LINUX)
5291da177e4SLinus Torvalds 		personality = PER_LINUX32;
5301da177e4SLinus Torvalds 	ret = sys_personality(personality);
5311da177e4SLinus Torvalds 	if (ret == PER_LINUX32)
5321da177e4SLinus Torvalds 		ret = PER_LINUX;
5331da177e4SLinus Torvalds 	return ret;
5341da177e4SLinus Torvalds }
5351da177e4SLinus Torvalds 
5361da177e4SLinus Torvalds /* ustat compatibility */
5371da177e4SLinus Torvalds struct ustat32 {
5381da177e4SLinus Torvalds 	compat_daddr_t	f_tfree;
5391da177e4SLinus Torvalds 	compat_ino_t	f_tinode;
5401da177e4SLinus Torvalds 	char		f_fname[6];
5411da177e4SLinus Torvalds 	char		f_fpack[6];
5421da177e4SLinus Torvalds };
5431da177e4SLinus Torvalds 
544219ac73aSAtsushi Nemoto extern asmlinkage long sys_ustat(dev_t dev, struct ustat __user * ubuf);
5451da177e4SLinus Torvalds 
546219ac73aSAtsushi Nemoto asmlinkage int sys32_ustat(dev_t dev, struct ustat32 __user * ubuf32)
5471da177e4SLinus Torvalds {
5481da177e4SLinus Torvalds 	int err;
5491da177e4SLinus Torvalds         struct ustat tmp;
5501da177e4SLinus Torvalds 	struct ustat32 tmp32;
5511da177e4SLinus Torvalds 	mm_segment_t old_fs = get_fs();
5521da177e4SLinus Torvalds 
5531da177e4SLinus Torvalds 	set_fs(KERNEL_DS);
554219ac73aSAtsushi Nemoto 	err = sys_ustat(dev, (struct ustat __user *)&tmp);
5551da177e4SLinus Torvalds 	set_fs (old_fs);
5561da177e4SLinus Torvalds 
5571da177e4SLinus Torvalds 	if (err)
5581da177e4SLinus Torvalds 		goto out;
5591da177e4SLinus Torvalds 
5601da177e4SLinus Torvalds         memset(&tmp32,0,sizeof(struct ustat32));
5611da177e4SLinus Torvalds         tmp32.f_tfree = tmp.f_tfree;
5621da177e4SLinus Torvalds         tmp32.f_tinode = tmp.f_tinode;
5631da177e4SLinus Torvalds 
5641da177e4SLinus Torvalds         err = copy_to_user(ubuf32,&tmp32,sizeof(struct ustat32)) ? -EFAULT : 0;
5651da177e4SLinus Torvalds 
5661da177e4SLinus Torvalds out:
5671da177e4SLinus Torvalds 	return err;
5681da177e4SLinus Torvalds }
5691da177e4SLinus Torvalds 
570219ac73aSAtsushi Nemoto asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset,
5711da177e4SLinus Torvalds 	s32 count)
5721da177e4SLinus Torvalds {
5731da177e4SLinus Torvalds 	mm_segment_t old_fs = get_fs();
5741da177e4SLinus Torvalds 	int ret;
5751da177e4SLinus Torvalds 	off_t of;
5761da177e4SLinus Torvalds 
5771da177e4SLinus Torvalds 	if (offset && get_user(of, offset))
5781da177e4SLinus Torvalds 		return -EFAULT;
5791da177e4SLinus Torvalds 
5801da177e4SLinus Torvalds 	set_fs(KERNEL_DS);
581219ac73aSAtsushi Nemoto 	ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count);
5821da177e4SLinus Torvalds 	set_fs(old_fs);
5831da177e4SLinus Torvalds 
5841da177e4SLinus Torvalds 	if (offset && put_user(of, offset))
5851da177e4SLinus Torvalds 		return -EFAULT;
5861da177e4SLinus Torvalds 
5871da177e4SLinus Torvalds 	return ret;
5881da177e4SLinus Torvalds }
5891da177e4SLinus Torvalds 
5901da177e4SLinus Torvalds asmlinkage ssize_t sys32_readahead(int fd, u32 pad0, u64 a2, u64 a3,
5911da177e4SLinus Torvalds                                    size_t count)
5921da177e4SLinus Torvalds {
5931da177e4SLinus Torvalds 	return sys_readahead(fd, merge_64(a2, a3), count);
5941da177e4SLinus Torvalds }
5951da177e4SLinus Torvalds 
596a8d587a7SRalf Baechle asmlinkage long sys32_sync_file_range(int fd, int __pad,
597a8d587a7SRalf Baechle 	unsigned long a2, unsigned long a3,
598a8d587a7SRalf Baechle 	unsigned long a4, unsigned long a5,
599a8d587a7SRalf Baechle 	int flags)
600a8d587a7SRalf Baechle {
601a8d587a7SRalf Baechle 	return sys_sync_file_range(fd,
602a8d587a7SRalf Baechle 			merge_64(a2, a3), merge_64(a4, a5),
603a8d587a7SRalf Baechle 			flags);
604a8d587a7SRalf Baechle }
605a8d587a7SRalf Baechle 
6061da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */
6071da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned int))
6081da177e4SLinus Torvalds static unsigned char socketcall_nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
6091da177e4SLinus Torvalds 				AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
6101da177e4SLinus Torvalds 				AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
6111da177e4SLinus Torvalds #undef AL
6121da177e4SLinus Torvalds 
6131da177e4SLinus Torvalds /*
6141da177e4SLinus Torvalds  *	System call vectors.
6151da177e4SLinus Torvalds  *
6161da177e4SLinus Torvalds  *	Argument checking cleaned up. Saved 20% in size.
6171da177e4SLinus Torvalds  *  This function doesn't need to set the kernel lock because
6181da177e4SLinus Torvalds  *  it is set by the callees.
6191da177e4SLinus Torvalds  */
6201da177e4SLinus Torvalds 
621219ac73aSAtsushi Nemoto asmlinkage long sys32_socketcall(int call, unsigned int __user *args32)
6221da177e4SLinus Torvalds {
6231da177e4SLinus Torvalds 	unsigned int a[6];
6241da177e4SLinus Torvalds 	unsigned int a0,a1;
6251da177e4SLinus Torvalds 	int err;
6261da177e4SLinus Torvalds 
6271da177e4SLinus Torvalds 	extern asmlinkage long sys_socket(int family, int type, int protocol);
6281da177e4SLinus Torvalds 	extern asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen);
6291da177e4SLinus Torvalds 	extern asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen);
6301da177e4SLinus Torvalds 	extern asmlinkage long sys_listen(int fd, int backlog);
6311da177e4SLinus Torvalds 	extern asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, int __user *upeer_addrlen);
6321da177e4SLinus Torvalds 	extern asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len);
6331da177e4SLinus Torvalds 	extern asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len);
6341da177e4SLinus Torvalds 	extern asmlinkage long sys_socketpair(int family, int type, int protocol, int __user *usockvec);
6351da177e4SLinus Torvalds 	extern asmlinkage long sys_send(int fd, void __user * buff, size_t len, unsigned flags);
6361da177e4SLinus Torvalds 	extern asmlinkage long sys_sendto(int fd, void __user * buff, size_t len, unsigned flags,
6371da177e4SLinus Torvalds 					  struct sockaddr __user *addr, int addr_len);
6381da177e4SLinus Torvalds 	extern asmlinkage long sys_recv(int fd, void __user * ubuf, size_t size, unsigned flags);
6391da177e4SLinus Torvalds 	extern asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags,
6401da177e4SLinus Torvalds 					    struct sockaddr __user *addr, int __user *addr_len);
6411da177e4SLinus Torvalds 	extern asmlinkage long sys_shutdown(int fd, int how);
6421da177e4SLinus Torvalds 	extern asmlinkage long sys_setsockopt(int fd, int level, int optname, char __user *optval, int optlen);
643219ac73aSAtsushi Nemoto 	extern asmlinkage long sys_getsockopt(int fd, int level, int optname, char __user *optval, int __user *optlen);
6441da177e4SLinus Torvalds 	extern asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
6451da177e4SLinus Torvalds 	extern asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, unsigned int flags);
6461da177e4SLinus Torvalds 
6471da177e4SLinus Torvalds 
6481da177e4SLinus Torvalds 	if(call<1||call>SYS_RECVMSG)
6491da177e4SLinus Torvalds 		return -EINVAL;
6501da177e4SLinus Torvalds 
6511da177e4SLinus Torvalds 	/* copy_from_user should be SMP safe. */
6521da177e4SLinus Torvalds 	if (copy_from_user(a, args32, socketcall_nargs[call]))
6531da177e4SLinus Torvalds 		return -EFAULT;
6541da177e4SLinus Torvalds 
6551da177e4SLinus Torvalds 	a0=a[0];
6561da177e4SLinus Torvalds 	a1=a[1];
6571da177e4SLinus Torvalds 
6581da177e4SLinus Torvalds 	switch(call)
6591da177e4SLinus Torvalds 	{
6601da177e4SLinus Torvalds 		case SYS_SOCKET:
6611da177e4SLinus Torvalds 			err = sys_socket(a0,a1,a[2]);
6621da177e4SLinus Torvalds 			break;
6631da177e4SLinus Torvalds 		case SYS_BIND:
6641da177e4SLinus Torvalds 			err = sys_bind(a0,(struct sockaddr __user *)A(a1), a[2]);
6651da177e4SLinus Torvalds 			break;
6661da177e4SLinus Torvalds 		case SYS_CONNECT:
6671da177e4SLinus Torvalds 			err = sys_connect(a0, (struct sockaddr __user *)A(a1), a[2]);
6681da177e4SLinus Torvalds 			break;
6691da177e4SLinus Torvalds 		case SYS_LISTEN:
6701da177e4SLinus Torvalds 			err = sys_listen(a0,a1);
6711da177e4SLinus Torvalds 			break;
6721da177e4SLinus Torvalds 		case SYS_ACCEPT:
6731da177e4SLinus Torvalds 			err = sys_accept(a0,(struct sockaddr __user *)A(a1), (int __user *)A(a[2]));
6741da177e4SLinus Torvalds 			break;
6751da177e4SLinus Torvalds 		case SYS_GETSOCKNAME:
6761da177e4SLinus Torvalds 			err = sys_getsockname(a0,(struct sockaddr __user *)A(a1), (int __user *)A(a[2]));
6771da177e4SLinus Torvalds 			break;
6781da177e4SLinus Torvalds 		case SYS_GETPEERNAME:
6791da177e4SLinus Torvalds 			err = sys_getpeername(a0, (struct sockaddr __user *)A(a1), (int __user *)A(a[2]));
6801da177e4SLinus Torvalds 			break;
6811da177e4SLinus Torvalds 		case SYS_SOCKETPAIR:
6821da177e4SLinus Torvalds 			err = sys_socketpair(a0,a1, a[2], (int __user *)A(a[3]));
6831da177e4SLinus Torvalds 			break;
6841da177e4SLinus Torvalds 		case SYS_SEND:
6851da177e4SLinus Torvalds 			err = sys_send(a0, (void __user *)A(a1), a[2], a[3]);
6861da177e4SLinus Torvalds 			break;
6871da177e4SLinus Torvalds 		case SYS_SENDTO:
6881da177e4SLinus Torvalds 			err = sys_sendto(a0,(void __user *)A(a1), a[2], a[3],
6891da177e4SLinus Torvalds 					 (struct sockaddr __user *)A(a[4]), a[5]);
6901da177e4SLinus Torvalds 			break;
6911da177e4SLinus Torvalds 		case SYS_RECV:
6921da177e4SLinus Torvalds 			err = sys_recv(a0, (void __user *)A(a1), a[2], a[3]);
6931da177e4SLinus Torvalds 			break;
6941da177e4SLinus Torvalds 		case SYS_RECVFROM:
6951da177e4SLinus Torvalds 			err = sys_recvfrom(a0, (void __user *)A(a1), a[2], a[3],
6961da177e4SLinus Torvalds 					   (struct sockaddr __user *)A(a[4]), (int __user *)A(a[5]));
6971da177e4SLinus Torvalds 			break;
6981da177e4SLinus Torvalds 		case SYS_SHUTDOWN:
6991da177e4SLinus Torvalds 			err = sys_shutdown(a0,a1);
7001da177e4SLinus Torvalds 			break;
7011da177e4SLinus Torvalds 		case SYS_SETSOCKOPT:
7021da177e4SLinus Torvalds 			err = sys_setsockopt(a0, a1, a[2], (char __user *)A(a[3]), a[4]);
7031da177e4SLinus Torvalds 			break;
7041da177e4SLinus Torvalds 		case SYS_GETSOCKOPT:
7051da177e4SLinus Torvalds 			err = sys_getsockopt(a0, a1, a[2], (char __user *)A(a[3]), (int __user *)A(a[4]));
7061da177e4SLinus Torvalds 			break;
7071da177e4SLinus Torvalds 		case SYS_SENDMSG:
7081da177e4SLinus Torvalds 			err = sys_sendmsg(a0, (struct msghdr __user *) A(a1), a[2]);
7091da177e4SLinus Torvalds 			break;
7101da177e4SLinus Torvalds 		case SYS_RECVMSG:
7111da177e4SLinus Torvalds 			err = sys_recvmsg(a0, (struct msghdr __user *) A(a1), a[2]);
7121da177e4SLinus Torvalds 			break;
7131da177e4SLinus Torvalds 		default:
7141da177e4SLinus Torvalds 			err = -EINVAL;
7151da177e4SLinus Torvalds 			break;
7161da177e4SLinus Torvalds 	}
7171da177e4SLinus Torvalds 	return err;
7181da177e4SLinus Torvalds }
719d1abb6a2SRalf Baechle 
720d1abb6a2SRalf Baechle struct sigevent32 {
721d1abb6a2SRalf Baechle 	u32 sigev_value;
722d1abb6a2SRalf Baechle 	u32 sigev_signo;
723d1abb6a2SRalf Baechle 	u32 sigev_notify;
724d1abb6a2SRalf Baechle 	u32 payload[(64 / 4) - 3];
725d1abb6a2SRalf Baechle };
726d1abb6a2SRalf Baechle 
727d1abb6a2SRalf Baechle extern asmlinkage long
728d1abb6a2SRalf Baechle sys_timer_create(clockid_t which_clock,
729d1abb6a2SRalf Baechle 		 struct sigevent __user *timer_event_spec,
730d1abb6a2SRalf Baechle 		 timer_t __user * created_timer_id);
731d1abb6a2SRalf Baechle 
732d1abb6a2SRalf Baechle long
733d1abb6a2SRalf Baechle sys32_timer_create(u32 clock, struct sigevent32 __user *se32, timer_t __user *timer_id)
734d1abb6a2SRalf Baechle {
735d1abb6a2SRalf Baechle 	struct sigevent __user *p = NULL;
736d1abb6a2SRalf Baechle 	if (se32) {
737d1abb6a2SRalf Baechle 		struct sigevent se;
738d1abb6a2SRalf Baechle 		p = compat_alloc_user_space(sizeof(struct sigevent));
739d1abb6a2SRalf Baechle 		memset(&se, 0, sizeof(struct sigevent));
740d1abb6a2SRalf Baechle 		if (get_user(se.sigev_value.sival_int,  &se32->sigev_value) ||
741d1abb6a2SRalf Baechle 		    __get_user(se.sigev_signo, &se32->sigev_signo) ||
742d1abb6a2SRalf Baechle 		    __get_user(se.sigev_notify, &se32->sigev_notify) ||
743d1abb6a2SRalf Baechle 		    __copy_from_user(&se._sigev_un._pad, &se32->payload,
744d1abb6a2SRalf Baechle 				     sizeof(se32->payload)) ||
745d1abb6a2SRalf Baechle 		    copy_to_user(p, &se, sizeof(se)))
746d1abb6a2SRalf Baechle 			return -EFAULT;
747d1abb6a2SRalf Baechle 	}
748d1abb6a2SRalf Baechle 	return sys_timer_create(clock, p, timer_id);
749d1abb6a2SRalf Baechle }
750d1abb6a2SRalf Baechle 
7513c37026dSRalf Baechle save_static_function(sys32_clone);
7523c37026dSRalf Baechle __attribute_used__ noinline static int
7533c37026dSRalf Baechle _sys32_clone(nabi_no_regargs struct pt_regs regs)
7543c37026dSRalf Baechle {
7553c37026dSRalf Baechle 	unsigned long clone_flags;
7563c37026dSRalf Baechle 	unsigned long newsp;
7573c37026dSRalf Baechle 	int __user *parent_tidptr, *child_tidptr;
7583c37026dSRalf Baechle 
7593c37026dSRalf Baechle 	clone_flags = regs.regs[4];
7603c37026dSRalf Baechle 	newsp = regs.regs[5];
7613c37026dSRalf Baechle 	if (!newsp)
7623c37026dSRalf Baechle 		newsp = regs.regs[29];
763219ac73aSAtsushi Nemoto 	parent_tidptr = (int __user *) regs.regs[6];
7643c37026dSRalf Baechle 
7653c37026dSRalf Baechle 	/* Use __dummy4 instead of getting it off the stack, so that
7663c37026dSRalf Baechle 	   syscall() works.  */
7673c37026dSRalf Baechle 	child_tidptr = (int __user *) __dummy4;
7683c37026dSRalf Baechle 	return do_fork(clone_flags, newsp, &regs, 0,
7693c37026dSRalf Baechle 	               parent_tidptr, child_tidptr);
7703c37026dSRalf Baechle }
771