sparc,sparc64: unify kernel/

o Move all files from sparc64/kernel/ to sparc/kernel
  - rename as appropriate
o Update sparc/Makefile to the changes
o Update sparc/kernel/Makefile to include the sparc64 files

NOTE: This commit changes link order on sparc64!

Link order had to change for either of sparc32 and sparc64.
And assuming sparc64 see more testing than sparc32 change link
order on sparc64 where issues will be caught faster.

Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 682 insertions, 0 deletions

diff --git a/arch/sparc/kernel/sys_sparc32.c b/arch/sparc/kernel/sys_sparc32.c
new file mode 100644
index 000000000000..e800503879e4
--- /dev/null
+++ b/arch/sparc/kernel/sys_sparc32.c
@@ -0,0 +1,682 @@
+/* sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
+ *
+ * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ * Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net)
+ *
+ * These routines maintain argument size conversion between 32bit and 64bit
+ * environment.
+ */
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/capability.h>
+#include <linux/fs.h> 
+#include <linux/mm.h> 
+#include <linux/file.h> 
+#include <linux/signal.h>
+#include <linux/resource.h>
+#include <linux/times.h>
+#include <linux/utsname.h>
+#include <linux/smp.h>
+#include <linux/smp_lock.h>
+#include <linux/sem.h>
+#include <linux/msg.h>
+#include <linux/shm.h>
+#include <linux/slab.h>
+#include <linux/uio.h>
+#include <linux/nfs_fs.h>
+#include <linux/quota.h>
+#include <linux/module.h>
+#include <linux/sunrpc/svc.h>
+#include <linux/nfsd/nfsd.h>
+#include <linux/nfsd/cache.h>
+#include <linux/nfsd/xdr.h>
+#include <linux/nfsd/syscall.h>
+#include <linux/poll.h>
+#include <linux/personality.h>
+#include <linux/stat.h>
+#include <linux/filter.h>
+#include <linux/highmem.h>
+#include <linux/highuid.h>
+#include <linux/mman.h>
+#include <linux/ipv6.h>
+#include <linux/in.h>
+#include <linux/icmpv6.h>
+#include <linux/syscalls.h>
+#include <linux/sysctl.h>
+#include <linux/binfmts.h>
+#include <linux/dnotify.h>
+#include <linux/security.h>
+#include <linux/compat.h>
+#include <linux/vfs.h>
+#include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/ptrace.h>
+
+#include <asm/types.h>
+#include <asm/uaccess.h>
+#include <asm/fpumacro.h>
+#include <asm/mmu_context.h>
+#include <asm/compat_signal.h>
+
+#ifdef CONFIG_SYSVIPC                                                        
+asmlinkage long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr, u32 fifth)
+{
+        int version;
+
+        version = call >> 16; /* hack for backward compatibility */
+        call &= 0xffff;
+
+        switch (call) {
+        case SEMTIMEDOP:
+                if (fifth)
+                        /* sign extend semid */
+                        return compat_sys_semtimedop((int)first,
+                                                     compat_ptr(ptr), second,
+                                                     compat_ptr(fifth));
+                /* else fall through for normal semop() */
+        case SEMOP:
+                /* struct sembuf is the same on 32 and 64bit :)) */
+                /* sign extend semid */
+                return sys_semtimedop((int)first, compat_ptr(ptr), second,
+                                      NULL);
+        case SEMGET:
+                /* sign extend key, nsems */
+                return sys_semget((int)first, (int)second, third);
+        case SEMCTL:
+                /* sign extend semid, semnum */
+                return compat_sys_semctl((int)first, (int)second, third,
+                                         compat_ptr(ptr));
+
+        case MSGSND:
+                /* sign extend msqid */
+                return compat_sys_msgsnd((int)first, (int)second, third,
+                                         compat_ptr(ptr));
+        case MSGRCV:
+                /* sign extend msqid, msgtyp */
+                return compat_sys_msgrcv((int)first, second, (int)fifth,
+                                         third, version, compat_ptr(ptr));
+        case MSGGET:
+                /* sign extend key */
+                return sys_msgget((int)first, second);
+        case MSGCTL:
+                /* sign extend msqid */
+                return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
+
+        case SHMAT:
+                /* sign extend shmid */
+                return compat_sys_shmat((int)first, second, third, version,
+                                        compat_ptr(ptr));
+        case SHMDT:
+                return sys_shmdt(compat_ptr(ptr));
+        case SHMGET:
+                /* sign extend key_t */
+                return sys_shmget((int)first, second, third);
+        case SHMCTL:
+                /* sign extend shmid */
+                return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
+
+        default:
+                return -ENOSYS;
+        };
+
+        return -ENOSYS;
+}
+#endif
+
+asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
+{
+        if ((int)high < 0)
+                return -EINVAL;
+        else
+                return sys_truncate(path, (high << 32) | low);
+}
+
+asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
+{
+        if ((int)high < 0)
+                return -EINVAL;
+        else
+                return sys_ftruncate(fd, (high << 32) | low);
+}
+
+static int cp_compat_stat64(struct kstat *stat,
+                            struct compat_stat64 __user *statbuf)
+{
+        int err;
+
+        err  = put_user(huge_encode_dev(stat->dev), &statbuf->st_dev);
+        err |= put_user(stat->ino, &statbuf->st_ino);
+        err |= put_user(stat->mode, &statbuf->st_mode);
+        err |= put_user(stat->nlink, &statbuf->st_nlink);
+        err |= put_user(stat->uid, &statbuf->st_uid);
+        err |= put_user(stat->gid, &statbuf->st_gid);
+        err |= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev);
+        err |= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]);
+        err |= put_user(stat->size, &statbuf->st_size);
+        err |= put_user(stat->blksize, &statbuf->st_blksize);
+        err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[0]);
+        err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[4]);
+        err |= put_user(stat->blocks, &statbuf->st_blocks);
+        err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
+        err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
+        err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
+        err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
+        err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
+        err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
+        err |= put_user(0, &statbuf->__unused4);
+        err |= put_user(0, &statbuf->__unused5);
+
+        return err;
+}
+
+asmlinkage long compat_sys_stat64(char __user * filename,
+                struct compat_stat64 __user *statbuf)
+{
+        struct kstat stat;
+        int error = vfs_stat(filename, &stat);
+
+        if (!error)
+                error = cp_compat_stat64(&stat, statbuf);
+        return error;
+}
+
+asmlinkage long compat_sys_lstat64(char __user * filename,
+                struct compat_stat64 __user *statbuf)
+{
+        struct kstat stat;
+        int error = vfs_lstat(filename, &stat);
+
+        if (!error)
+                error = cp_compat_stat64(&stat, statbuf);
+        return error;
+}
+
+asmlinkage long compat_sys_fstat64(unsigned int fd,
+                struct compat_stat64 __user * statbuf)
+{
+        struct kstat stat;
+        int error = vfs_fstat(fd, &stat);
+
+        if (!error)
+                error = cp_compat_stat64(&stat, statbuf);
+        return error;
+}
+
+asmlinkage long compat_sys_fstatat64(unsigned int dfd, char __user *filename,
+                struct compat_stat64 __user * statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
+
+        if (!error)
+                error = cp_compat_stat64(&stat, statbuf);
+
+out:
+        return error;
+}
+
+asmlinkage long compat_sys_sysfs(int option, u32 arg1, u32 arg2)
+{
+        return sys_sysfs(option, arg1, arg2);
+}
+
+asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid, struct compat_timespec __user *interval)
+{
+        struct timespec t;
+        int ret;
+        mm_segment_t old_fs = get_fs ();
+        
+        set_fs (KERNEL_DS);
+        ret = sys_sched_rr_get_interval(pid, (struct timespec __user *) &t);
+        set_fs (old_fs);
+        if (put_compat_timespec(&t, interval))
+                return -EFAULT;
+        return ret;
+}
+
+asmlinkage long compat_sys_rt_sigprocmask(int how,
+                                          compat_sigset_t __user *set,
+                                          compat_sigset_t __user *oset,
+                                          compat_size_t sigsetsize)
+{
+        sigset_t s;
+        compat_sigset_t s32;
+        int ret;
+        mm_segment_t old_fs = get_fs();
+        
+        if (set) {
+                if (copy_from_user (&s32, set, sizeof(compat_sigset_t)))
+                        return -EFAULT;
+                switch (_NSIG_WORDS) {
+                case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
+                case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
+                case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
+                case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
+                }
+        }
+        set_fs (KERNEL_DS);
+        ret = sys_rt_sigprocmask(how,
+                                 set ? (sigset_t __user *) &s : NULL,
+                                 oset ? (sigset_t __user *) &s : NULL,
+                                 sigsetsize);
+        set_fs (old_fs);
+        if (ret) return ret;
+        if (oset) {
+                switch (_NSIG_WORDS) {
+                case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
+                case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
+                case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
+                case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
+                }
+                if (copy_to_user (oset, &s32, sizeof(compat_sigset_t)))
+                        return -EFAULT;
+        }
+        return 0;
+}
+
+asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
+                                    compat_size_t sigsetsize)
+{
+        sigset_t s;
+        compat_sigset_t s32;
+        int ret;
+        mm_segment_t old_fs = get_fs();
+                
+        set_fs (KERNEL_DS);
+        ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
+        set_fs (old_fs);
+        if (!ret) {
+                switch (_NSIG_WORDS) {
+                case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
+                case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
+                case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
+                case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
+                }
+                if (copy_to_user (set, &s32, sizeof(compat_sigset_t)))
+                        return -EFAULT;
+        }
+        return ret;
+}
+
+asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig,
+                                           struct compat_siginfo __user *uinfo)
+{
+        siginfo_t info;
+        int ret;
+        mm_segment_t old_fs = get_fs();
+        
+        if (copy_siginfo_from_user32(&info, uinfo))
+                return -EFAULT;
+
+        set_fs (KERNEL_DS);
+        ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *) &info);
+        set_fs (old_fs);
+        return ret;
+}
+
+asmlinkage long compat_sys_sigaction(int sig, struct old_sigaction32 __user *act,
+                                     struct old_sigaction32 __user *oact)
+{
+        struct k_sigaction new_ka, old_ka;
+        int ret;
+
+        WARN_ON_ONCE(sig >= 0);
+        sig = -sig;
+
+        if (act) {
+                compat_old_sigset_t mask;
+                u32 u_handler, u_restorer;
+                
+                ret = get_user(u_handler, &act->sa_handler);
+                new_ka.sa.sa_handler =  compat_ptr(u_handler);
+                ret |= __get_user(u_restorer, &act->sa_restorer);
+                new_ka.sa.sa_restorer = compat_ptr(u_restorer);
+                ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
+                ret |= __get_user(mask, &act->sa_mask);
+                if (ret)
+                        return ret;
+                new_ka.ka_restorer = NULL;
+                siginitset(&new_ka.sa.sa_mask, mask);
+        }
+
+        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
+
+        if (!ret && oact) {
+                ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
+                ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
+                ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
+                ret |= __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
+        }
+
+        return ret;
+}
+
+asmlinkage long compat_sys_rt_sigaction(int sig,
+                                        struct sigaction32 __user *act,
+                                        struct sigaction32 __user *oact,
+                                        void __user *restorer,
+                                        compat_size_t sigsetsize)
+{
+        struct k_sigaction new_ka, old_ka;
+        int ret;
+        compat_sigset_t set32;
+
+        /* XXX: Don't preclude handling different sized sigset_t's.  */
+        if (sigsetsize != sizeof(compat_sigset_t))
+                return -EINVAL;
+
+        if (act) {
+                u32 u_handler, u_restorer;
+
+                new_ka.ka_restorer = restorer;
+                ret = get_user(u_handler, &act->sa_handler);
+                new_ka.sa.sa_handler =  compat_ptr(u_handler);
+                ret |= __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t));
+                switch (_NSIG_WORDS) {
+                case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] | (((long)set32.sig[7]) << 32);
+                case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] | (((long)set32.sig[5]) << 32);
+                case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] | (((long)set32.sig[3]) << 32);
+                case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] | (((long)set32.sig[1]) << 32);
+                }
+                ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
+                ret |= __get_user(u_restorer, &act->sa_restorer);
+                new_ka.sa.sa_restorer = compat_ptr(u_restorer);
+                if (ret)
+                        return -EFAULT;
+        }
+
+        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
+
+        if (!ret && oact) {
+                switch (_NSIG_WORDS) {
+                case 4: set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); set32.sig[6] = old_ka.sa.sa_mask.sig[3];
+                case 3: set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); set32.sig[4] = old_ka.sa.sa_mask.sig[2];
+                case 2: set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); set32.sig[2] = old_ka.sa.sa_mask.sig[1];
+                case 1: set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); set32.sig[0] = old_ka.sa.sa_mask.sig[0];
+                }
+                ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
+                ret |= __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t));
+                ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
+                ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
+                if (ret)
+                        ret = -EFAULT;
+        }
+
+        return ret;
+}
+
+/*
+ * sparc32_execve() executes a new program after the asm stub has set
+ * things up for us.  This should basically do what I want it to.
+ */
+asmlinkage long sparc32_execve(struct pt_regs *regs)
+{
+        int error, base = 0;
+        char *filename;
+
+        /* User register window flush is done by entry.S */
+
+        /* Check for indirect call. */
+        if ((u32)regs->u_regs[UREG_G1] == 0)
+                base = 1;
+
+        filename = getname(compat_ptr(regs->u_regs[base + UREG_I0]));
+        error = PTR_ERR(filename);
+        if (IS_ERR(filename))
+                goto out;
+
+        error = compat_do_execve(filename,
+                                 compat_ptr(regs->u_regs[base + UREG_I1]),
+                                 compat_ptr(regs->u_regs[base + UREG_I2]), regs);
+
+        putname(filename);
+
+        if (!error) {
+                fprs_write(0);
+                current_thread_info()->xfsr[0] = 0;
+                current_thread_info()->fpsaved[0] = 0;
+                regs->tstate &= ~TSTATE_PEF;
+        }
+out:
+        return error;
+}
+
+#ifdef CONFIG_MODULES
+
+asmlinkage long sys32_init_module(void __user *umod, u32 len,
+                                  const char __user *uargs)
+{
+        return sys_init_module(umod, len, uargs);
+}
+
+asmlinkage long sys32_delete_module(const char __user *name_user,
+                                    unsigned int flags)
+{
+        return sys_delete_module(name_user, flags);
+}
+
+#else /* CONFIG_MODULES */
+
+asmlinkage long sys32_init_module(const char __user *name_user,
+                                  struct module __user *mod_user)
+{
+        return -ENOSYS;
+}
+
+asmlinkage long sys32_delete_module(const char __user *name_user)
+{
+        return -ENOSYS;
+}
+
+#endif  /* CONFIG_MODULES */
+
+asmlinkage compat_ssize_t sys32_pread64(unsigned int fd,
+                                        char __user *ubuf,
+                                        compat_size_t count,
+                                        unsigned long poshi,
+                                        unsigned long poslo)
+{
+        return sys_pread64(fd, ubuf, count, (poshi << 32) | poslo);
+}
+
+asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd,
+                                         char __user *ubuf,
+                                         compat_size_t count,
+                                         unsigned long poshi,
+                                         unsigned long poslo)
+{
+        return sys_pwrite64(fd, ubuf, count, (poshi << 32) | poslo);
+}
+
+asmlinkage long compat_sys_readahead(int fd,
+                                     unsigned long offhi,
+                                     unsigned long offlo,
+                                     compat_size_t count)
+{
+        return sys_readahead(fd, (offhi << 32) | offlo, count);
+}
+
+long compat_sys_fadvise64(int fd,
+                          unsigned long offhi,
+                          unsigned long offlo,
+                          compat_size_t len, int advice)
+{
+        return sys_fadvise64_64(fd, (offhi << 32) | offlo, len, advice);
+}
+
+long compat_sys_fadvise64_64(int fd,
+                             unsigned long offhi, unsigned long offlo,
+                             unsigned long lenhi, unsigned long lenlo,
+                             int advice)
+{
+        return sys_fadvise64_64(fd,
+                                (offhi << 32) | offlo,
+                                (lenhi << 32) | lenlo,
+                                advice);
+}
+
+asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
+                                    compat_off_t __user *offset,
+                                    compat_size_t count)
+{
+        mm_segment_t old_fs = get_fs();
+        int ret;
+        off_t of;
+        
+        if (offset && get_user(of, offset))
+                return -EFAULT;
+                
+        set_fs(KERNEL_DS);
+        ret = sys_sendfile(out_fd, in_fd,
+                           offset ? (off_t __user *) &of : NULL,
+                           count);
+        set_fs(old_fs);
+        
+        if (offset && put_user(of, offset))
+                return -EFAULT;
+                
+        return ret;
+}
+
+asmlinkage long compat_sys_sendfile64(int out_fd, int in_fd,
+                                      compat_loff_t __user *offset,
+                                      compat_size_t count)
+{
+        mm_segment_t old_fs = get_fs();
+        int ret;
+        loff_t lof;
+        
+        if (offset && get_user(lof, offset))
+                return -EFAULT;
+                
+        set_fs(KERNEL_DS);
+        ret = sys_sendfile64(out_fd, in_fd,
+                             offset ? (loff_t __user *) &lof : NULL,
+                             count);
+        set_fs(old_fs);
+        
+        if (offset && put_user(lof, offset))
+                return -EFAULT;
+                
+        return ret;
+}
+
+/* This is just a version for 32-bit applications which does
+ * not force O_LARGEFILE on.
+ */
+
+asmlinkage long sparc32_open(const char __user *filename,
+                             int flags, int mode)
+{
+        return do_sys_open(AT_FDCWD, filename, flags, mode);
+}
+
+extern unsigned long do_mremap(unsigned long addr,
+        unsigned long old_len, unsigned long new_len,
+        unsigned long flags, unsigned long new_addr);
+                
+asmlinkage unsigned long sys32_mremap(unsigned long addr,
+        unsigned long old_len, unsigned long new_len,
+        unsigned long flags, u32 __new_addr)
+{
+        unsigned long ret = -EINVAL;
+        unsigned long new_addr = __new_addr;
+
+        if (unlikely(sparc_mmap_check(addr, old_len)))
+                goto out;
+        if (unlikely(sparc_mmap_check(new_addr, new_len)))
+                goto out;
+        down_write(&current->mm->mmap_sem);
+        ret = do_mremap(addr, old_len, new_len, flags, new_addr);
+        up_write(&current->mm->mmap_sem);
+out:
+        return ret;       
+}
+
+struct __sysctl_args32 {
+        u32 name;
+        int nlen;
+        u32 oldval;
+        u32 oldlenp;
+        u32 newval;
+        u32 newlen;
+        u32 __unused[4];
+};
+
+asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
+{
+#ifndef CONFIG_SYSCTL_SYSCALL
+        return -ENOSYS;
+#else
+        struct __sysctl_args32 tmp;
+        int error;
+        size_t oldlen, __user *oldlenp = NULL;
+        unsigned long addr = (((unsigned long)&args->__unused[0]) + 7UL) & ~7UL;
+
+        if (copy_from_user(&tmp, args, sizeof(tmp)))
+                return -EFAULT;
+
+        if (tmp.oldval && tmp.oldlenp) {
+                /* Duh, this is ugly and might not work if sysctl_args
+                   is in read-only memory, but do_sysctl does indirectly
+                   a lot of uaccess in both directions and we'd have to
+                   basically copy the whole sysctl.c here, and
+                   glibc's __sysctl uses rw memory for the structure
+                   anyway.  */
+                if (get_user(oldlen, (u32 __user *)(unsigned long)tmp.oldlenp) ||
+                    put_user(oldlen, (size_t __user *)addr))
+                        return -EFAULT;
+                oldlenp = (size_t __user *)addr;
+        }
+
+        lock_kernel();
+        error = do_sysctl((int __user *)(unsigned long) tmp.name,
+                          tmp.nlen,
+                          (void __user *)(unsigned long) tmp.oldval,
+                          oldlenp,
+                          (void __user *)(unsigned long) tmp.newval,
+                          tmp.newlen);
+        unlock_kernel();
+        if (oldlenp) {
+                if (!error) {
+                        if (get_user(oldlen, (size_t __user *)addr) ||
+                            put_user(oldlen, (u32 __user *)(unsigned long) tmp.oldlenp))
+                                error = -EFAULT;
+                }
+                if (copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused)))
+                        error = -EFAULT;
+        }
+        return error;
+#endif
+}
+
+long sys32_lookup_dcookie(unsigned long cookie_high,
+                          unsigned long cookie_low,
+                          char __user *buf, size_t len)
+{
+        return sys_lookup_dcookie((cookie_high << 32) | cookie_low,
+                                  buf, len);
+}
+
+long compat_sync_file_range(int fd, unsigned long off_high, unsigned long off_low, unsigned long nb_high, unsigned long nb_low, int flags)
+{
+        return sys_sync_file_range(fd,
+                                   (off_high << 32) | off_low,
+                                   (nb_high << 32) | nb_low,
+                                   flags);
+}
+
+asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo,
+                                     u32 lenhi, u32 lenlo)
+{
+        return sys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo,
+                             ((loff_t)lenhi << 32) | lenlo);
+}