/* * 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/config.h>#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/timex.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 *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; 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 (!(flags & MAP_ANONYMOUS)) { error = -EBADF; file = fget(fd); if (!file) goto out; } flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); down_write(¤t->mm->mmap_sem); error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); up_write(¤t->mm->mmap_sem); if (file) fput(file); out: return error;} asmlinkage int sys_truncate64(const char *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]), ®s); putname(filename); out: return error;} struct dirent32 { unsigned int d_ino; unsigned int d_off; unsigned short d_reclen; char d_name[NAME_MAX + 1];}; static voidxlate_dirent(void *dirent64, void *dirent32, long n){ long off; struct dirent *dirp; struct dirent32 *dirp32; off = 0; while (off < n) { dirp = (struct dirent *)(dirent64 + off); dirp32 = (struct dirent32 *)(dirent32 + off); off += dirp->d_reclen; dirp32->d_ino = dirp->d_ino; dirp32->d_off = (unsigned int)dirp->d_off; dirp32->d_reclen = dirp->d_reclen; strncpy(dirp32->d_name, dirp->d_name, dirp->d_reclen - ((3 * 4) + 2)); } return;} asmlinkage longsys32_getdents(unsigned int fd, void * dirent32, unsigned int count){ long n; void *dirent64; dirent64 = (void *)((unsigned long)(dirent32 + (sizeof(long) - 1)) & ~(sizeof(long) - 1)); if ((n = sys_getdents(fd, dirent64, count - (dirent64 - dirent32))) < 0) return(n); xlate_dirent(dirent64, dirent32, n); return(n);} asmlinkage int old_readdir(unsigned int fd, void * dirent, unsigned int count); asmlinkage intsys32_readdir(unsigned int fd, void * dirent32, unsigned int count){ int n; struct dirent dirent64; if ((n = old_readdir(fd, &dirent64, count)) < 0) return(n); xlate_dirent(&dirent64, dirent32, dirent64.d_reclen); return(n);} struct rusage32 { struct compat_timeval ru_utime; struct compat_timeval ru_stime; int ru_maxrss; int ru_ixrss; int ru_idrss; int ru_isrss; int ru_minflt; int ru_majflt; int ru_nswap; int ru_inblock; int ru_oublock; int ru_msgsnd; int ru_msgrcv; int ru_nsignals; int ru_nvcsw; int ru_nivcsw;}; static intput_rusage (struct rusage32 *ru, struct rusage *r){ int err; if (!access_ok(VERIFY_WRITE, ru, sizeof *ru)) return -EFAULT; err = __put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec); err |= __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec); err |= __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec); err |= __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec); err |= __put_user (r->ru_maxrss, &ru->ru_maxrss); err |= __put_user (r->ru_ixrss, &ru->ru_ixrss); err |= __put_user (r->ru_idrss, &ru->ru_idrss); err |= __put_user (r->ru_isrss, &ru->ru_isrss); err |= __put_user (r->ru_minflt, &ru->ru_minflt); err |= __put_user (r->ru_majflt, &ru->ru_majflt); err |= __put_user (r->ru_nswap, &ru->ru_nswap); err |= __put_user (r->ru_inblock, &ru->ru_inblock); err |= __put_user (r->ru_oublock, &ru->ru_oublock); err |= __put_user (r->ru_msgsnd, &ru->ru_msgsnd); err |= __put_user (r->ru_msgrcv, &ru->ru_msgrcv); err |= __put_user (r->ru_nsignals, &ru->ru_nsignals); err |= __put_user (r->ru_nvcsw, &ru->ru_nvcsw); err |= __put_user (r->ru_nivcsw, &ru->ru_nivcsw); return err;} asmlinkage intsys32_wait4(compat_pid_t pid, unsigned int * stat_addr, int options, struct rusage32 * ru){ if (!ru) return sys_wait4(pid, stat_addr, options, NULL); else { struct rusage r; int ret; unsigned int status; mm_segment_t old_fs = get_fs(); set_fs(KERNEL_DS); ret = sys_wait4(pid, stat_addr ? &status : NULL, options, &r); set_fs(old_fs); if (put_rusage (ru, &r)) return -EFAULT; if (stat_addr && put_user (status, stat_addr)) return -EFAULT; return ret; }} asmlinkage intsys32_waitpid(compat_pid_t pid, unsigned int *stat_addr, int options){ return sys32_wait4(pid, stat_addr, options, NULL);} 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 *info){ struct sysinfo s; int ret, err; mm_segment_t old_fs = get_fs (); set_fs (KERNEL_DS); ret = sys_sysinfo(&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 * path, unsigned long __dummy, int length_hi, int length_lo)#endif#ifdef __MIPSEL__asmlinkage long sys32_truncate64(const char * 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 *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 *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 *tv, struct timezone *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 *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 *tv, struct timezone *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 * 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 * buf, size_t count, u32 unused, u64 a4, u64 a5){ ssize_t ret; struct file * file; ssize_t (*read)(struct file *, char *, size_t, loff_t *); loff_t pos; ret = -EBADF; file = fget(fd); if (!file) goto bad_file; if (!(file->f_mode & FMODE_READ)) goto out; pos = merge_64(a4, a5); ret = rw_verify_area(READ, file, &pos, count); if (ret) goto out; ret = -EINVAL; if (!file->f_op || !(read = file->f_op->read)) goto out; if (pos < 0) goto out; ret = -ESPIPE; if (!(file->f_mode & FMODE_PREAD)) goto out; ret = read(file, buf, count, &pos); if (ret > 0) dnotify_parent(file->f_dentry, DN_ACCESS);out: fput(file);bad_file: return ret;} asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char * buf, size_t count, u32 unused, u64 a4, u64 a5){ ssize_t ret; struct file * file; ssize_t (*write)(struct file *, const char *, size_t, loff_t *); loff_t pos; ret = -EBADF; file = fget(fd);Lines 1–500 of 1469. Load more
/* * 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/config.h> #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/timex.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 *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; 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 long sys32_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 (!(flags & MAP_ANONYMOUS)) { error = -EBADF; file = fget(fd); if (!file) goto out; } flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); down_write(¤t->mm->mmap_sem); error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); up_write(¤t->mm->mmap_sem); if (file) fput(file); out: return error; } asmlinkage int sys_truncate64(const char *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]), ®s); putname(filename); out: return error; } struct dirent32 { unsigned int d_ino; unsigned int d_off; unsigned short d_reclen; char d_name[NAME_MAX + 1]; }; static void xlate_dirent(void *dirent64, void *dirent32, long n) { long off; struct dirent *dirp; struct dirent32 *dirp32; off = 0; while (off < n) { dirp = (struct dirent *)(dirent64 + off); dirp32 = (struct dirent32 *)(dirent32 + off); off += dirp->d_reclen; dirp32->d_ino = dirp->d_ino; dirp32->d_off = (unsigned int)dirp->d_off; dirp32->d_reclen = dirp->d_reclen; strncpy(dirp32->d_name, dirp->d_name, dirp->d_reclen - ((3 * 4) + 2)); } return; } asmlinkage long sys32_getdents(unsigned int fd, void * dirent32, unsigned int count) { long n; void *dirent64; dirent64 = (void *)((unsigned long)(dirent32 + (sizeof(long) - 1)) & ~(sizeof(long) - 1)); if ((n = sys_getdents(fd, dirent64, count - (dirent64 - dirent32))) < 0) return(n); xlate_dirent(dirent64, dirent32, n); return(n); } asmlinkage int old_readdir(unsigned int fd, void * dirent, unsigned int count); asmlinkage int sys32_readdir(unsigned int fd, void * dirent32, unsigned int count) { int n; struct dirent dirent64; if ((n = old_readdir(fd, &dirent64, count)) < 0) return(n); xlate_dirent(&dirent64, dirent32, dirent64.d_reclen); return(n); } struct rusage32 { struct compat_timeval ru_utime; struct compat_timeval ru_stime; int ru_maxrss; int ru_ixrss; int ru_idrss; int ru_isrss; int ru_minflt; int ru_majflt; int ru_nswap; int ru_inblock; int ru_oublock; int ru_msgsnd; int ru_msgrcv; int ru_nsignals; int ru_nvcsw; int ru_nivcsw; }; static int put_rusage (struct rusage32 *ru, struct rusage *r) { int err; if (!access_ok(VERIFY_WRITE, ru, sizeof *ru)) return -EFAULT; err = __put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec); err |= __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec); err |= __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec); err |= __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec); err |= __put_user (r->ru_maxrss, &ru->ru_maxrss); err |= __put_user (r->ru_ixrss, &ru->ru_ixrss); err |= __put_user (r->ru_idrss, &ru->ru_idrss); err |= __put_user (r->ru_isrss, &ru->ru_isrss); err |= __put_user (r->ru_minflt, &ru->ru_minflt); err |= __put_user (r->ru_majflt, &ru->ru_majflt); err |= __put_user (r->ru_nswap, &ru->ru_nswap); err |= __put_user (r->ru_inblock, &ru->ru_inblock); err |= __put_user (r->ru_oublock, &ru->ru_oublock); err |= __put_user (r->ru_msgsnd, &ru->ru_msgsnd); err |= __put_user (r->ru_msgrcv, &ru->ru_msgrcv); err |= __put_user (r->ru_nsignals, &ru->ru_nsignals); err |= __put_user (r->ru_nvcsw, &ru->ru_nvcsw); err |= __put_user (r->ru_nivcsw, &ru->ru_nivcsw); return err; } asmlinkage int sys32_wait4(compat_pid_t pid, unsigned int * stat_addr, int options, struct rusage32 * ru) { if (!ru) return sys_wait4(pid, stat_addr, options, NULL); else { struct rusage r; int ret; unsigned int status; mm_segment_t old_fs = get_fs(); set_fs(KERNEL_DS); ret = sys_wait4(pid, stat_addr ? &status : NULL, options, &r); set_fs(old_fs); if (put_rusage (ru, &r)) return -EFAULT; if (stat_addr && put_user (status, stat_addr)) return -EFAULT; return ret; } } asmlinkage int sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr, int options) { return sys32_wait4(pid, stat_addr, options, NULL); } 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 *info) { struct sysinfo s; int ret, err; mm_segment_t old_fs = get_fs (); set_fs (KERNEL_DS); ret = sys_sysinfo(&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 * path, unsigned long __dummy, int length_hi, int length_lo) #endif #ifdef __MIPSEL__ asmlinkage long sys32_truncate64(const char * 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 long get_tv32(struct timeval *o, struct compat_timeval *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 long put_tv32(struct compat_timeval *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 int sys32_gettimeofday(struct compat_timeval *tv, struct timezone *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 *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 int sys32_settimeofday(struct compat_timeval *tv, struct timezone *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 * 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 * buf, size_t count, u32 unused, u64 a4, u64 a5) { ssize_t ret; struct file * file; ssize_t (*read)(struct file *, char *, size_t, loff_t *); loff_t pos; ret = -EBADF; file = fget(fd); if (!file) goto bad_file; if (!(file->f_mode & FMODE_READ)) goto out; pos = merge_64(a4, a5); ret = rw_verify_area(READ, file, &pos, count); if (ret) goto out; ret = -EINVAL; if (!file->f_op || !(read = file->f_op->read)) goto out; if (pos < 0) goto out; ret = -ESPIPE; if (!(file->f_mode & FMODE_PREAD)) goto out; ret = read(file, buf, count, &pos); if (ret > 0) dnotify_parent(file->f_dentry, DN_ACCESS); out: fput(file); bad_file: return ret; } asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char * buf, size_t count, u32 unused, u64 a4, u64 a5) { ssize_t ret; struct file * file; ssize_t (*write)(struct file *, const char *, size_t, loff_t *); loff_t pos; ret = -EBADF; file = fget(fd);