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(¤t->mm->mmap_sem); 1221da177e4SLinus Torvalds error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); 1231da177e4SLinus Torvalds up_write(¤t->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]), ®s); 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, ®s, 0, 7693c37026dSRalf Baechle parent_tidptr, child_tidptr); 7703c37026dSRalf Baechle } 771