/*
 * sys_ppc32.c: Conversion between 32bit and 64bit native syscalls.
 *
 * Copyright (C) 2001 IBM
 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
 *
 * These routines maintain argument size conversion between 32bit and 64bit
 * environment.
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#include <asm/ptrace.h>
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fs.h> 
#include <linux/mm.h> 
#include <linux/file.h> 
#include <linux/signal.h>
#include <linux/utime.h>
#include <linux/resource.h>
#include <linux/times.h>
#include <linux/utsname.h>
#include <linux/timex.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/smb_fs.h>
#include <linux/smb_mount.h>
#include <linux/ncp_fs.h>
#include <linux/quota.h>
#include <linux/quotacompat.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/sysctl.h>

#include <asm/types.h>
#include <asm/ipc.h>
#include <asm/uaccess.h>

#include <asm/semaphore.h>

#include <net/scm.h>
#include <linux/elf.h>
#include <asm/ppcdebug.h>
#include <asm/time.h>
#include <asm/ppc32.h>

extern unsigned long wall_jiffies;
#define USEC_PER_SEC (1000000)


extern asmlinkage long sys_utime(char * filename, struct utimbuf * times);

struct utimbuf32 {
        __kernel_time_t32 actime, modtime;
};

asmlinkage long sys32_utime(char * filename, struct utimbuf32 *times)
{
        struct utimbuf t;
        mm_segment_t old_fs;
        int ret;
        char *filenam;
        
        PPCDBG(PPCDBG_SYS32NI, "sys32_utime - running - filename=%s, times=%p - pid=%ld, comm=%s \n", filename, times, current->pid, current->comm);

        if (!times)
                return sys_utime(filename, NULL);
        if (get_user(t.actime, &times->actime) || __get_user(t.modtime, &times->modtime))
                return -EFAULT;
        filenam = getname(filename);

        ret = PTR_ERR(filenam);
        if (!IS_ERR(filenam)) {
                old_fs = get_fs();
                set_fs (KERNEL_DS); 
                ret = sys_utime(filenam, &t);
                set_fs (old_fs);
                putname (filenam);
        }

        return ret;
}

asmlinkage int sys32_ustat(__kernel_dev_t32 dev, struct ustat32 * ubuf)
{

        struct super_block *s;
        struct ustat32 tmp;
        struct statfs sbuf;
        int err = -EINVAL;

        s = get_super(to_kdev_t(dev));
        if (s == NULL)
                goto out;
        err = vfs_statfs(s, &sbuf);
        drop_super(s);
        if (err)
                goto out;

        memset(&tmp,0,sizeof(struct ustat));
        tmp.f_tfree = sbuf.f_bfree;
        tmp.f_tinode = sbuf.f_ffree;

        err = copy_to_user(ubuf, &tmp, sizeof(struct ustat32)) ? -EFAULT : 0;

out:
        return err;

}

struct iovec32 { u32 iov_base; __kernel_size_t32 iov_len; };

typedef ssize_t (*IO_fn_t)(struct file *, char *, size_t, loff_t *);
typedef __kernel_ssize_t32 ssize_t32;

static long do_readv_writev32(int type, struct file *file,
                              const struct iovec32 *vector, u32 count)
{
        unsigned long tot_len;
        struct iovec iovstack[UIO_FASTIOV];
        struct iovec *iov=iovstack, *ivp;
        struct inode *inode;
        long retval, i;
        IO_fn_t fn;

        /* First get the "struct iovec" from user memory and
         * verify all the pointers
         */
        if (!count)
                return 0;
        if (count > UIO_MAXIOV)
                return -EINVAL;
        if(verify_area(VERIFY_READ, vector, sizeof(struct iovec32)*count))
                return -EFAULT;
        if (count > UIO_FASTIOV) {
                iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
                if (!iov)
                        return -ENOMEM;
        }

        tot_len = 0;
        i = count;
        ivp = iov;
        while(i > 0) {
                u32 len;
                u32 buf;

                __get_user(len, &vector->iov_len);
                __get_user(buf, &vector->iov_base);
                tot_len += len;
                ivp->iov_base = (void *)A(buf);
                ivp->iov_len = (__kernel_size_t) len;
                vector++;
                ivp++;
                if ((len < 0) || (tot_len != (ssize_t32)tot_len)) {
                        if (iov != iovstack)
                                kfree(iov);
                        return -EINVAL;
                }
                i--;
        }

        inode = file->f_dentry->d_inode;
        /* VERIFY_WRITE actually means a read, as we write to user space */
        retval = locks_verify_area((type == VERIFY_WRITE
                                    ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE),
                                   inode, file, file->f_pos, tot_len);
        if (retval) {
                if (iov != iovstack)
                        kfree(iov);
                return retval;
        }

        /* Then do the actual IO.  Note that sockets need to be handled
         * specially as they have atomicity guarantees and can handle
         * iovec's natively
         */
        if (inode->i_sock) {
                int err;
                err = sock_readv_writev(type, inode, file, iov, count, tot_len);
                if (iov != iovstack)
                        kfree(iov);
                return err;
        }

        if (!file->f_op) {
                if (iov != iovstack)
                        kfree(iov);
                return -EINVAL;
        }
        /* VERIFY_WRITE actually means a read, as we write to user space */
        fn = file->f_op->read;
        if (type == VERIFY_READ)
                fn = (IO_fn_t) file->f_op->write;               
        ivp = iov;
        while (count > 0) {
                void * base;
                int len, nr;

                base = ivp->iov_base;
                len = ivp->iov_len;
                ivp++;
                count--;
                nr = fn(file, base, len, &file->f_pos);
                if (nr < 0) {
                        if (retval)
                                break;
                        retval = nr;
                        break;
                }
                retval += nr;
                if (nr != len)
                        break;
        }
        if (iov != iovstack)
                kfree(iov);
        return retval;
}

asmlinkage long sys32_readv(u32 fd, struct iovec32 *vector, u32 count)
{
        struct file *file;
        long ret = -EBADF;
        
        PPCDBG(PPCDBG_SYS32, "sys32_readv - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        file = fget(fd);
        if(!file)
                goto bad_file;

        if (file->f_op && (file->f_mode & FMODE_READ) &&
     (file->f_op->readv || file->f_op->read))
                ret = do_readv_writev32(VERIFY_WRITE, file, vector, count);
        fput(file);

bad_file:
        PPCDBG(PPCDBG_SYS32, "sys32_readv - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);
        return ret;
}

asmlinkage long sys32_writev(u32 fd, struct iovec32 *vector, u32 count)
{
        struct file *file;
        int ret = -EBADF;
        
        PPCDBG(PPCDBG_SYS32, "sys32_writev - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        file = fget(fd);
        if(!file)
                goto bad_file;
        if (file->f_op && (file->f_mode & FMODE_WRITE) &&
           (file->f_op->writev || file->f_op->write))
                ret = do_readv_writev32(VERIFY_READ, file, vector, count);
        fput(file);

bad_file:
        PPCDBG(PPCDBG_SYS32, "sys32_writev - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);
        return ret;
}



static inline int get_flock(struct flock *kfl, struct flock32 *ufl)
{
        int err;
        
        err = get_user(kfl->l_type, &ufl->l_type);
        err |= __get_user(kfl->l_whence, &ufl->l_whence);
        err |= __get_user(kfl->l_start, &ufl->l_start);
        err |= __get_user(kfl->l_len, &ufl->l_len);
        err |= __get_user(kfl->l_pid, &ufl->l_pid);
        return err;
}

static inline int put_flock(struct flock *kfl, struct flock32 *ufl)
{
        int err;
        
        err = __put_user(kfl->l_type, &ufl->l_type);
        err |= __put_user(kfl->l_whence, &ufl->l_whence);
        err |= __put_user(kfl->l_start, &ufl->l_start);
        err |= __put_user(kfl->l_len, &ufl->l_len);
        err |= __put_user(kfl->l_pid, &ufl->l_pid);
        return err;
}

extern asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
asmlinkage long sys32_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
{
        switch (cmd) {
        case F_GETLK:
        case F_SETLK:
        case F_SETLKW:
        {
                struct flock f;
                mm_segment_t old_fs;
                long ret;

                if(get_flock(&f, (struct flock32 *)arg))
                        return -EFAULT;
                old_fs = get_fs(); set_fs (KERNEL_DS);
                ret = sys_fcntl(fd, cmd, (unsigned long)&f);
                set_fs (old_fs);
                if(put_flock(&f, (struct flock32 *)arg))
                        return -EFAULT;
                return ret;
        }
        default:
                return sys_fcntl(fd, cmd, (unsigned long)arg);
        }
}

struct ncp_mount_data32 {
        int version;
        unsigned int ncp_fd;
        __kernel_uid_t32 mounted_uid;
        __kernel_pid_t32 wdog_pid;
        unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
        unsigned int time_out;
        unsigned int retry_count;
        unsigned int flags;
        __kernel_uid_t32 uid;
        __kernel_gid_t32 gid;
        __kernel_mode_t32 file_mode;
        __kernel_mode_t32 dir_mode;
};

static void *do_ncp_super_data_conv(void *raw_data)
{
        struct ncp_mount_data *n = (struct ncp_mount_data *)raw_data;
        struct ncp_mount_data32 *n32 = (struct ncp_mount_data32 *)raw_data;

        n->dir_mode = n32->dir_mode;
        n->file_mode = n32->file_mode;
        n->gid = n32->gid;
        n->uid = n32->uid;
        memmove (n->mounted_vol, n32->mounted_vol, (sizeof (n32->mounted_vol) + 3 * sizeof (unsigned int)));
        n->wdog_pid = n32->wdog_pid;
        n->mounted_uid = n32->mounted_uid;
        return raw_data;
}

struct smb_mount_data32 {
        int version;
        __kernel_uid_t32 mounted_uid;
        __kernel_uid_t32 uid;
        __kernel_gid_t32 gid;
        __kernel_mode_t32 file_mode;
        __kernel_mode_t32 dir_mode;
};

static void *do_smb_super_data_conv(void *raw_data)
{
        struct smb_mount_data *s = (struct smb_mount_data *)raw_data;
        struct smb_mount_data32 *s32 = (struct smb_mount_data32 *)raw_data;

        s->version = s32->version;
        s->mounted_uid = s32->mounted_uid;
        s->uid = s32->uid;
        s->gid = s32->gid;
        s->file_mode = s32->file_mode;
        s->dir_mode = s32->dir_mode;
        return raw_data;
}

static int copy_mount_stuff_to_kernel(const void *user, unsigned long *kernel)
{
        int i;
        unsigned long page;
        struct vm_area_struct *vma;

        *kernel = 0;
        if(!user)
                return 0;
        vma = find_vma(current->mm, (unsigned long)user);
        if(!vma || (unsigned long)user < vma->vm_start)
                return -EFAULT;
        if(!(vma->vm_flags & VM_READ))
                return -EFAULT;
        i = vma->vm_end - (unsigned long) user;
        if(PAGE_SIZE <= (unsigned long) i)
                i = PAGE_SIZE - 1;
        if(!(page = __get_free_page(GFP_KERNEL)))
                return -ENOMEM;
        if(copy_from_user((void *) page, user, i)) {
                free_page(page);
                return -EFAULT;
        }
        *kernel = page;
        return 0;
}

#define SMBFS_NAME      "smbfs"
#define NCPFS_NAME      "ncpfs"

asmlinkage long sys32_mount(char *dev_name, char *dir_name, char *type, unsigned long new_flags, u32 data)
{
        unsigned long type_page = 0;
        unsigned long data_page = 0;
        unsigned long dev_page = 0;
        unsigned long dir_page = 0;
        int err, is_smb, is_ncp;
        
        PPCDBG(PPCDBG_SYS32, "sys32_mount - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        is_smb = is_ncp = 0;

        err = copy_mount_stuff_to_kernel((const void *)type, &type_page);
        if (err)
                goto out;

        if (!type_page) {
                err = -EINVAL;
                goto out;
        }

        is_smb = !strcmp((char *)type_page, SMBFS_NAME);
        is_ncp = !strcmp((char *)type_page, NCPFS_NAME);

        err = copy_mount_stuff_to_kernel((const void *)AA(data), &data_page);
        if (err)
                goto type_out;

        err = copy_mount_stuff_to_kernel(dev_name, &dev_page);
        if (err)
                goto data_out;

        err = copy_mount_stuff_to_kernel(dir_name, &dir_page);
        if (err)
                goto dev_out;

        if (!is_smb && !is_ncp) {
                lock_kernel();
                err = do_mount((char*)dev_page, (char*)dir_page,
                                (char*)type_page, new_flags, (char*)data_page);
                unlock_kernel();
        } else {
                if (is_ncp)
                        do_ncp_super_data_conv((void *)data_page);
                else
                        do_smb_super_data_conv((void *)data_page);

                lock_kernel();
                err = do_mount((char*)dev_page, (char*)dir_page,
                                (char*)type_page, new_flags, (char*)data_page);
                unlock_kernel();
        }
        free_page(dir_page);

dev_out:
        free_page(dev_page);

data_out:
        free_page(data_page);

type_out:
        free_page(type_page);

out:
        
        PPCDBG(PPCDBG_SYS32, "sys32_mount - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        return err;
}

struct user_dqblk32 {
    __u32 dqb_bhardlimit;
    __u32 dqb_bsoftlimit;
    __u32 dqb_curblocks;
    __u32 dqb_ihardlimit;
    __u32 dqb_isoftlimit;
    __u32 dqb_curinodes;
    __kernel_time_t32 dqb_btime;
    __kernel_time_t32 dqb_itime;
};
                                

extern asmlinkage long sys_quotactl(unsigned int cmd, const char *special, qid_t id, caddr_t addr);

/* Note: it is necessary to treat cmd and id as unsigned ints, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_quotactl(u32 cmd_parm, const char *special, u32 id_parm, caddr_t addr)
{
        unsigned int cmd = cmd_parm;
        qid_t id  = (qid_t)id_parm;
        unsigned int cmds = cmd >> SUBCMDSHIFT;
        int err;
        struct v1c_mem_dqblk d;
        mm_segment_t old_fs;
        char *spec;
        
        PPCDBG(PPCDBG_SYS32, "sys32_quotactl - entered - pid=%ld current=%lx comm=%s \n",
                    current->pid, current, current->comm);

        switch (cmds) {
        case Q_V1_GETQUOTA:
                break;
        case Q_V1_SETQUOTA:
        case Q_V1_SETUSE:
        case Q_V1_SETQLIM:
                if (copy_from_user(&d, addr, sizeof(struct user_dqblk32)))
                        return -EFAULT;
                d.dqb_itime = ((struct user_dqblk32 *)&d)->dqb_itime;
                d.dqb_btime = ((struct user_dqblk32 *)&d)->dqb_btime;
                break;
        default:
                return sys_quotactl(cmd, special, id, addr);
        }
        spec = getname(special);
        err = PTR_ERR(spec);
        if (IS_ERR(spec))
                return err;
        old_fs = get_fs();
        set_fs (KERNEL_DS);
        err = sys_quotactl(cmd, (const char *)spec, id, (caddr_t)&d);
        set_fs (old_fs);
        putname (spec);
        if (cmds == Q_V1_GETQUOTA) {
                __kernel_time_t b = d.dqb_btime, i = d.dqb_itime;
                ((struct user_dqblk32 *)&d)->dqb_itime = i;
                ((struct user_dqblk32 *)&d)->dqb_btime = b;
                if (copy_to_user(addr, &d, sizeof(struct user_dqblk32)))
                        return -EFAULT;
        }
        
        PPCDBG(PPCDBG_SYS32, "sys32_quotactl - exited - pid=%ld current=%lx comm=%s \n",
                    current->pid, current, current->comm);

        return err;
}



/* readdir & getdents */
#define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
#define ROUND_UP(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))

struct old_linux_dirent32 {
        u32             d_ino;
        u32             d_offset;
        unsigned short  d_namlen;
        char            d_name[1];
};

struct readdir_callback32 {
        struct old_linux_dirent32 * dirent;
        int count;
};

static int fillonedir(void * __buf, const char * name, int namlen,
                                  off_t offset, ino_t ino, unsigned int d_type)
{
        struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
        struct old_linux_dirent32 * dirent;

        if (buf->count)
                return -EINVAL;
        buf->count++;
        dirent = buf->dirent;
        put_user(ino, &dirent->d_ino);
        put_user(offset, &dirent->d_offset);
        put_user(namlen, &dirent->d_namlen);
        copy_to_user(dirent->d_name, name, namlen);
        put_user(0, dirent->d_name + namlen);
        return 0;
}

asmlinkage int old32_readdir(unsigned int fd, struct old_linux_dirent32 *dirent, unsigned int count)
{
        int error = -EBADF;
        struct file * file;
        struct readdir_callback32 buf;

        file = fget(fd);
        if (!file)
                goto out;

        buf.count = 0;
        buf.dirent = dirent;

        error = vfs_readdir(file, (filldir_t)fillonedir, &buf);
        if (error < 0)
                goto out_putf;
        error = buf.count;

out_putf:
        fput(file);
out:
        return error;
}

#if 0
struct linux_dirent32 {
        u32             d_ino;
        u32             d_off;
        unsigned short  d_reclen;
        char            d_name[1];
};
#else
struct linux_dirent32 {
        u32             d_ino;
        u32             d_off;
        unsigned short  d_reclen;
  /* unsigned char      d_type; */
        char            d_name[256];
};
#endif

struct getdents_callback32 {
        struct linux_dirent32 * current_dir;
        struct linux_dirent32 * previous;
        int count;
        int error;
};

static int
filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino,
                               unsigned int d_type)
{
        struct linux_dirent32 * dirent;
        struct getdents_callback32 * buf = (struct getdents_callback32 *) __buf;
        int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);

        buf->error = -EINVAL;   /* only used if we fail.. */
        if (reclen > buf->count)
                return -EINVAL;
        dirent = buf->previous;
        if (dirent)
                put_user(offset, &dirent->d_off);
        dirent = buf->current_dir;
        buf->previous = dirent;
        put_user(ino, &dirent->d_ino);
        put_user(reclen, &dirent->d_reclen);
        copy_to_user(dirent->d_name, name, namlen);
        put_user(0, dirent->d_name + namlen);
        ((char *) dirent) += reclen;
        buf->current_dir = dirent;
        buf->count -= reclen;
        return 0;
}

asmlinkage long sys32_getdents(unsigned int fd, struct linux_dirent32 *dirent, unsigned int count)
{
        struct file * file;
        struct linux_dirent32 * lastdirent;
        struct getdents_callback32 buf;
        int error = -EBADF;

        PPCDBG(PPCDBG_SYS32NI, "sys32_getdents - running - fd=%x, pid=%ld, comm=%s \n", fd, current->pid, current->comm);

        file = fget(fd);
        if (!file)
                goto out;

        buf.current_dir = dirent;
        buf.previous = NULL;
        buf.count = count;
        buf.error = 0;

        error = vfs_readdir(file, (filldir_t)filldir, &buf);
        if (error < 0)
                goto out_putf;
        lastdirent = buf.previous;
        error = buf.error;
        if(lastdirent) {
                put_user(file->f_pos, &lastdirent->d_off);
                error = count - buf.count;
        }
 out_putf:
        fput(file);

 out:
        return error;
}
/* end of readdir & getdents */



/* 32-bit timeval and related flotsam.  */

struct timeval32
{
        int tv_sec, tv_usec;
};

struct itimerval32
{
        struct timeval32 it_interval;
        struct timeval32 it_value;
};




/*
 * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
 * 64-bit unsigned longs.
 */
static inline int
get_fd_set32(unsigned long n, unsigned long *fdset, u32 *ufdset)
{
        if (ufdset) {
                unsigned long odd;

                if (verify_area(VERIFY_WRITE, ufdset, n*sizeof(u32)))
                        return -EFAULT;

                odd = n & 1UL;
                n &= ~1UL;
                while (n) {
                        unsigned long h, l;
                        __get_user(l, ufdset);
                        __get_user(h, ufdset+1);
                        ufdset += 2;
                        *fdset++ = h << 32 | l;
                        n -= 2;
                }
                if (odd)
                        __get_user(*fdset, ufdset);
        } else {
                /* Tricky, must clear full unsigned long in the
                 * kernel fdset at the end, this makes sure that
                 * actually happens.
                 */
                memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
        }
        return 0;
}

static inline void
set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
{
        unsigned long odd;

        if (!ufdset)
                return;

        odd = n & 1UL;
        n &= ~1UL;
        while (n) {
                unsigned long h, l;
                l = *fdset++;
                h = l >> 32;
                __put_user(l, ufdset);
                __put_user(h, ufdset+1);
                ufdset += 2;
                n -= 2;
        }
        if (odd)
                __put_user(*fdset, ufdset);
}



#define MAX_SELECT_SECONDS ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)

asmlinkage long sys32_select(int n, u32 *inp, u32 *outp, u32 *exp, u32 tvp_x)
{
        fd_set_bits fds;
        struct timeval32 *tvp = (struct timeval32 *)AA(tvp_x);
        char *bits;
        unsigned long nn;
        long timeout;
        int ret, size;
        
  PPCDBG(PPCDBG_SYS32X, "sys32_select - entered - n=%x, inp=%p, outp=%p - pid=%ld comm=%s \n", n, inp, outp, current->pid, current->comm);

        timeout = MAX_SCHEDULE_TIMEOUT;
        if (tvp) {
                time_t sec, usec;
                if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
                    || (ret = __get_user(sec, &tvp->tv_sec))
                    || (ret = __get_user(usec, &tvp->tv_usec)))
                        goto out_nofds;

                ret = -EINVAL;
                if(sec < 0 || usec < 0)
                        goto out_nofds;

                if ((unsigned long) sec < MAX_SELECT_SECONDS) {
                        timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
                        timeout += sec * (unsigned long) HZ;
                }
        }

        ret = -EINVAL;
        if (n < 0)
                goto out_nofds;
        if (n > current->files->max_fdset)
                n = current->files->max_fdset;

        /*
         * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
         * since we used fdset we need to allocate memory in units of
         * long-words. 
         */
        ret = -ENOMEM;
        size = FDS_BYTES(n);
        bits = kmalloc(6 * size, GFP_KERNEL);
        if (!bits)
                goto out_nofds;
        fds.in      = (unsigned long *)  bits;
        fds.out     = (unsigned long *) (bits +   size);
        fds.ex      = (unsigned long *) (bits + 2*size);
        fds.res_in  = (unsigned long *) (bits + 3*size);
        fds.res_out = (unsigned long *) (bits + 4*size);
        fds.res_ex  = (unsigned long *) (bits + 5*size);

        nn = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
        if ((ret = get_fd_set32(nn, fds.in, inp)) ||
            (ret = get_fd_set32(nn, fds.out, outp)) ||
            (ret = get_fd_set32(nn, fds.ex, exp)))
                goto out;
        zero_fd_set(n, fds.res_in);
        zero_fd_set(n, fds.res_out);
        zero_fd_set(n, fds.res_ex);

        ret = do_select(n, &fds, &timeout);

        if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
                time_t sec = 0, usec = 0;
                if (timeout) {
                        sec = timeout / HZ;
                        usec = timeout % HZ;
                        usec *= (1000000/HZ);
                }
                put_user(sec, &tvp->tv_sec);
                put_user(usec, &tvp->tv_usec);
        }

        if (ret < 0)
                goto out;
        if (!ret) {
                ret = -ERESTARTNOHAND;
                if (signal_pending(current))
                        goto out;
                ret = 0;
        }

        set_fd_set32(nn, inp, fds.res_in);
        set_fd_set32(nn, outp, fds.res_out);
        set_fd_set32(nn, exp, fds.res_ex);
  
out:
        kfree(bits);

out_nofds:
        PPCDBG(PPCDBG_SYS32X, "sys32_select - exited - pid=%ld, comm=%s \n", current->pid, current->comm);
        return ret;
}

/* Note: it is necessary to treat n as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage int ppc32_select(u32 n, u32* inp, u32* outp, u32* exp, u32 tvp_x)
{
        return sys32_select((int)n, inp, outp, exp, tvp_x);
}

static int cp_new_stat32(struct inode *inode, struct stat32 *statbuf)
{
        unsigned long ino, blksize, blocks;
        kdev_t dev, rdev;
        umode_t mode;
        nlink_t nlink;
        uid_t uid;
        gid_t gid;
        off_t size;
        time_t atime, mtime, ctime;
        int err;

        /* Stream the loads of inode data into the load buffer,
         * then we push it all into the store buffer below.  This
         * should give optimal cache performance.
         */
        ino = inode->i_ino;
        dev = inode->i_dev;
        mode = inode->i_mode;
        nlink = inode->i_nlink;
        uid = inode->i_uid;
        gid = inode->i_gid;
        rdev = inode->i_rdev;
        size = inode->i_size;
        atime = inode->i_atime;
        mtime = inode->i_mtime;
        ctime = inode->i_ctime;
        blksize = inode->i_blksize;
        blocks = inode->i_blocks;

        err  = put_user(kdev_t_to_nr(dev), &statbuf->st_dev);
        err |= put_user(ino, &statbuf->st_ino);
        err |= put_user(mode, &statbuf->st_mode);
        err |= put_user(nlink, &statbuf->st_nlink);
        err |= put_user(uid, &statbuf->st_uid);
        err |= put_user(gid, &statbuf->st_gid);
        err |= put_user(kdev_t_to_nr(rdev), &statbuf->st_rdev);
        err |= put_user(size, &statbuf->st_size);
        err |= put_user(atime, &statbuf->st_atime);
        err |= put_user(0, &statbuf->__unused1);
        err |= put_user(mtime, &statbuf->st_mtime);
        err |= put_user(0, &statbuf->__unused2);
        err |= put_user(ctime, &statbuf->st_ctime);
        err |= put_user(0, &statbuf->__unused3);
        if (blksize) {
                err |= put_user(blksize, &statbuf->st_blksize);
                err |= put_user(blocks, &statbuf->st_blocks);
        } else {
                unsigned int tmp_blocks;

#define D_B   7
#define I_B   (BLOCK_SIZE / sizeof(unsigned short))
                tmp_blocks = (size + BLOCK_SIZE - 1) / BLOCK_SIZE;
                if (tmp_blocks > D_B) {
                        unsigned int indirect;

                        indirect = (tmp_blocks - D_B + I_B - 1) / I_B;
                        tmp_blocks += indirect;
                        if (indirect > 1) {
                                indirect = (indirect - 1 + I_B - 1) / I_B;
                                tmp_blocks += indirect;
                                if (indirect > 1)
                                        tmp_blocks++;
                        }
                }
                err |= put_user(BLOCK_SIZE, &statbuf->st_blksize);
                err |= put_user((BLOCK_SIZE / 512) * tmp_blocks, &statbuf->st_blocks);
#undef D_B
#undef I_B
        }
        err |= put_user(0, &statbuf->__unused4[0]);
        err |= put_user(0, &statbuf->__unused4[1]);

        return err;
}

static __inline__ int
do_revalidate(struct dentry *dentry)
{
        struct inode * inode = dentry->d_inode;
        if (inode->i_op && inode->i_op->revalidate)
                return inode->i_op->revalidate(dentry);
        return 0;
}

asmlinkage long sys32_newstat(char* filename, struct stat32* statbuf)
{
        struct nameidata nd;
        int error;
        
        PPCDBG(PPCDBG_SYS32X, "sys32_newstat - running - filename=%s, statbuf=%p, pid=%ld, comm=%s\n", filename, statbuf, current->pid, current->comm);

        error = user_path_walk(filename, &nd);
        if (!error) {
                error = do_revalidate(nd.dentry);
                if (!error)
                        error = cp_new_stat32(nd.dentry->d_inode, statbuf);
                path_release(&nd);
        }
        return error;
}

asmlinkage long sys32_newlstat(char * filename, struct stat32 *statbuf)
{
        struct nameidata nd;
        int error;
        
        PPCDBG(PPCDBG_SYS32X, "sys32_newlstat - running - fn=%s, pid=%ld, comm=%s\n", filename, current->pid, current->comm);

        error = user_path_walk_link(filename, &nd);
        if (!error) {
                error = do_revalidate(nd.dentry);
                if (!error)

                        error = cp_new_stat32(nd.dentry->d_inode, statbuf);

                path_release(&nd);
        }
        return error;
}

asmlinkage long sys32_newfstat(unsigned int fd, struct stat32 *statbuf)
{
        struct file *f;
        int err = -EBADF;
        
        PPCDBG(PPCDBG_SYS32X, "sys32_newfstat - running - fd=%x, pid=%ld, comm=%s\n", fd, current->pid, current->comm);

        f = fget(fd);
        if (f) {
                struct dentry * dentry = f->f_dentry;

                err = do_revalidate(dentry);
                if (!err)
                        err = cp_new_stat32(dentry->d_inode, statbuf);
                fput(f);
        }
        return err;
}

static inline int put_statfs (struct statfs32 *ubuf, struct statfs *kbuf)
{
        struct statfs32 tmp;
        memset(&tmp, 0, sizeof(tmp));

        tmp.f_type = kbuf->f_type;
        tmp.f_bsize = kbuf->f_bsize;
        tmp.f_blocks = kbuf->f_blocks;
        tmp.f_bfree = kbuf->f_bfree;
        tmp.f_bavail = kbuf->f_bavail;
        tmp.f_files = kbuf->f_files;
        tmp.f_ffree = kbuf->f_ffree;
        tmp.f_namelen = kbuf->f_namelen;
        tmp.f_fsid.val[0] = kbuf->f_fsid.val[0];
        tmp.f_fsid.val[1] = kbuf->f_fsid.val[1];

        return copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
}

extern asmlinkage int sys_statfs(const char * path, struct statfs * buf);

asmlinkage long sys32_statfs(const char * path, struct statfs32 *buf)
{
        int ret;
        struct statfs s;
        mm_segment_t old_fs = get_fs();
        char *pth;
        
        PPCDBG(PPCDBG_SYS32X, "sys32_statfs - entered - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);
        
        pth = getname (path);
        ret = PTR_ERR(pth);
        if (!IS_ERR(pth)) {
                set_fs (KERNEL_DS);
                ret = sys_statfs((const char *)pth, &s);
                set_fs (old_fs);
                putname (pth);
                if (put_statfs(buf, &s))
                        return -EFAULT;
        }
        
        PPCDBG(PPCDBG_SYS32X, "sys32_statfs - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        return ret;
}

extern asmlinkage long sys_fstatfs(unsigned int fd, struct statfs * buf);

asmlinkage long sys32_fstatfs(unsigned int fd, struct statfs32 *buf)
{
        int ret;
        struct statfs s;
        mm_segment_t old_fs = get_fs();
        
        PPCDBG(PPCDBG_SYS32X, "sys32_fstatfs - entered - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);
        
        set_fs (KERNEL_DS);
        ret = sys_fstatfs(fd, &s);
        set_fs (old_fs);
        if (put_statfs(buf, &s))
                return -EFAULT;
        
        PPCDBG(PPCDBG_SYS32X, "sys32_fstatfs - exited - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        return ret;
}



extern asmlinkage long sys_sysfs(int option, unsigned long arg1, unsigned long arg2);

/* Note: it is necessary to treat option as an unsigned int,
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_sysfs(u32 option, u32 arg1, u32 arg2)
{
        PPCDBG(PPCDBG_SYS32, "sys32_sysfs - running - pid=%ld, comm=%s\n", current->pid, current->comm);
        return sys_sysfs((int)option, arg1, arg2);
}




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 = AA(__new_addr);
        
        PPCDBG(PPCDBG_SYS32, "sys32_mremap - entered - pid=%ld current=%lx comm=%s\n",
                    current->pid, current, current->comm);


        if (old_len > 0xf0000000UL || new_len > 0xf0000000UL)
                goto out;
        if (addr > 0xf0000000UL - old_len)
                goto out;
        down_write(&current->mm->mmap_sem);
        if (flags & MREMAP_FIXED) {
                if (new_addr > 0xf0000000UL - new_len)
                        goto out_sem;
        } else if (addr > 0xf0000000UL - new_len) {
                ret = -ENOMEM;
                if (!(flags & MREMAP_MAYMOVE))
                        goto out_sem;
                new_addr = get_unmapped_area (NULL, addr, new_len, 0, 0);
                if (!new_addr)
                        goto out_sem;
                flags |= MREMAP_FIXED;
        }
        ret = do_mremap(addr, old_len, new_len, flags, new_addr);
out_sem:
        up_write(&current->mm->mmap_sem);
out:
        
        PPCDBG(PPCDBG_SYS32, "sys32_mremap - exited - pid=%ld current=%lx comm=%s\n",
                    current->pid, current, current->comm);

        return ret;       
}



/* Handle adjtimex compatability. */
struct timex32 {
        u32 modes;
        s32 offset, freq, maxerror, esterror;
        s32 status, constant, precision, tolerance;
        struct timeval32 time;
        s32 tick;
        s32 ppsfreq, jitter, shift, stabil;
        s32 jitcnt, calcnt, errcnt, stbcnt;
        s32  :32; s32  :32; s32  :32; s32  :32;
        s32  :32; s32  :32; s32  :32; s32  :32;
        s32  :32; s32  :32; s32  :32; s32  :32;
};

extern int do_adjtimex(struct timex *);
extern void ppc_adjtimex(void);

asmlinkage long sys32_adjtimex(struct timex32 *utp)
{
        struct timex txc;
        int ret;
        
        PPCDBG(PPCDBG_SYS32, "sys32_adjtimex - running - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        memset(&txc, 0, sizeof(struct timex));

        if(get_user(txc.modes, &utp->modes) ||
           __get_user(txc.offset, &utp->offset) ||
           __get_user(txc.freq, &utp->freq) ||
           __get_user(txc.maxerror, &utp->maxerror) ||
           __get_user(txc.esterror, &utp->esterror) ||
           __get_user(txc.status, &utp->status) ||
           __get_user(txc.constant, &utp->constant) ||
           __get_user(txc.precision, &utp->precision) ||
           __get_user(txc.tolerance, &utp->tolerance) ||
           __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
           __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
           __get_user(txc.tick, &utp->tick) ||
           __get_user(txc.ppsfreq, &utp->ppsfreq) ||
           __get_user(txc.jitter, &utp->jitter) ||
           __get_user(txc.shift, &utp->shift) ||
           __get_user(txc.stabil, &utp->stabil) ||
           __get_user(txc.jitcnt, &utp->jitcnt) ||
           __get_user(txc.calcnt, &utp->calcnt) ||
           __get_user(txc.errcnt, &utp->errcnt) ||
           __get_user(txc.stbcnt, &utp->stbcnt))
                return -EFAULT;

        ret = do_adjtimex(&txc);

        /* adjust the conversion of TB to time of day to track adjtimex */
        ppc_adjtimex();

        if(put_user(txc.modes, &utp->modes) ||
           __put_user(txc.offset, &utp->offset) ||
           __put_user(txc.freq, &utp->freq) ||
           __put_user(txc.maxerror, &utp->maxerror) ||
           __put_user(txc.esterror, &utp->esterror) ||
           __put_user(txc.status, &utp->status) ||
           __put_user(txc.constant, &utp->constant) ||
           __put_user(txc.precision, &utp->precision) ||
           __put_user(txc.tolerance, &utp->tolerance) ||
           __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
           __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
           __put_user(txc.tick, &utp->tick) ||
           __put_user(txc.ppsfreq, &utp->ppsfreq) ||
           __put_user(txc.jitter, &utp->jitter) ||
           __put_user(txc.shift, &utp->shift) ||
           __put_user(txc.stabil, &utp->stabil) ||
           __put_user(txc.jitcnt, &utp->jitcnt) ||
           __put_user(txc.calcnt, &utp->calcnt) ||
           __put_user(txc.errcnt, &utp->errcnt) ||
           __put_user(txc.stbcnt, &utp->stbcnt))
                ret = -EFAULT;

        return ret;
}



#ifdef CONFIG_MODULES

extern asmlinkage unsigned long sys_create_module(const char *name_user, size_t size);

asmlinkage unsigned long sys32_create_module(const char *name_user, __kernel_size_t32 size)
{
        
        PPCDBG(PPCDBG_SYS32M, "sys32_create_module - running - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        return sys_create_module(name_user, (size_t)size);
}



extern asmlinkage long sys_init_module(const char *name_user, struct module *mod_user);

asmlinkage long sys32_init_module(const char *name_user, struct module *mod_user)
{
        
        PPCDBG(PPCDBG_SYS32, "sys32_init_module - running - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        return sys_init_module(name_user, mod_user);
}



extern asmlinkage long sys_delete_module(const char *name_user);

asmlinkage long sys32_delete_module(const char *name_user)
{
        
        PPCDBG(PPCDBG_SYS32, "sys32_delete_module - running - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        return sys_delete_module(name_user);
}



struct module_info32 {
        u32 addr;
        u32 size;
        u32 flags;
        s32 usecount;
};

/* Query various bits about modules.  */

static inline long
get_mod_name(const char *user_name, char **buf)
{
        unsigned long page;
        long retval;

        if ((unsigned long)user_name >= TASK_SIZE
            && !segment_eq(get_fs (), KERNEL_DS))
                return -EFAULT;

        page = __get_free_page(GFP_KERNEL);
        if (!page)
                return -ENOMEM;

        retval = strncpy_from_user((char *)page, user_name, PAGE_SIZE);
        if (retval > 0) {
                if (retval < PAGE_SIZE) {
                        *buf = (char *)page;
                        return retval;
                }
                retval = -ENAMETOOLONG;
        } else if (!retval)
                retval = -EINVAL;

        free_page(page);
        return retval;
}

static inline void
put_mod_name(char *buf)
{
        free_page((unsigned long)buf);
}

static __inline__ struct module *find_module(const char *name)
{
        struct module *mod;

        for (mod = module_list; mod ; mod = mod->next) {
                if (mod->flags & MOD_DELETED)
                        continue;
                if (!strcmp(mod->name, name))
                        break;
        }

        return mod;
}

static int
qm_modules(char *buf, size_t bufsize, __kernel_size_t32 *ret)
{
        struct module *mod;
        size_t nmod, space, len;

        nmod = space = 0;

        for (mod = module_list; mod->next != NULL; mod = mod->next, ++nmod) {
                len = strlen(mod->name)+1;
                if (len > bufsize)
                        goto calc_space_needed;
                if (copy_to_user(buf, mod->name, len))
                        return -EFAULT;
                buf += len;
                bufsize -= len;
                space += len;
        }

        if (put_user(nmod, ret))
                return -EFAULT;
        else
                return 0;

calc_space_needed:
        space += len;
        while ((mod = mod->next)->next != NULL)
                space += strlen(mod->name)+1;

        if (put_user(space, ret))
                return -EFAULT;
        else
                return -ENOSPC;
}

static int
qm_deps(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
{
        size_t i, space, len;

        if (mod->next == NULL)
                return -EINVAL;
        if (!MOD_CAN_QUERY(mod))
                return put_user(0, ret);

        space = 0;
        for (i = 0; i < mod->ndeps; ++i) {
                const char *dep_name = mod->deps[i].dep->name;

                len = strlen(dep_name)+1;
                if (len > bufsize)
                        goto calc_space_needed;
                if (copy_to_user(buf, dep_name, len))
                        return -EFAULT;
                buf += len;
                bufsize -= len;
                space += len;
        }

        return put_user(i, ret);

calc_space_needed:
        space += len;
        while (++i < mod->ndeps)
                space += strlen(mod->deps[i].dep->name)+1;

        if (put_user(space, ret))
                return -EFAULT;
        else
                return -ENOSPC;
}

static int
qm_refs(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
{
        size_t nrefs, space, len;
        struct module_ref *ref;

        if (mod->next == NULL)
                return -EINVAL;
        if (!MOD_CAN_QUERY(mod))
                if (put_user(0, ret))
                        return -EFAULT;
                else
                        return 0;

        space = 0;
        for (nrefs = 0, ref = mod->refs; ref ; ++nrefs, ref = ref->next_ref) {
                const char *ref_name = ref->ref->name;

                len = strlen(ref_name)+1;
                if (len > bufsize)
                        goto calc_space_needed;
                if (copy_to_user(buf, ref_name, len))
                        return -EFAULT;
                buf += len;
                bufsize -= len;
                space += len;
        }

        if (put_user(nrefs, ret))
                return -EFAULT;
        else
                return 0;

calc_space_needed:
        space += len;
        while ((ref = ref->next_ref) != NULL)
                space += strlen(ref->ref->name)+1;

        if (put_user(space, ret))
                return -EFAULT;
        else
                return -ENOSPC;
}

static inline int
qm_symbols(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
{
        size_t i, space, len;
        struct module_symbol *s;
        char *strings;
        unsigned *vals;

        if (!MOD_CAN_QUERY(mod))
                if (put_user(0, ret))
                        return -EFAULT;
                else
                        return 0;

        space = mod->nsyms * 2*sizeof(u32);

        i = len = 0;
        s = mod->syms;

        if (space > bufsize)
                goto calc_space_needed;

        if (!access_ok(VERIFY_WRITE, buf, space))
                return -EFAULT;

        bufsize -= space;
        vals = (unsigned *)buf;
        strings = buf+space;

        for (; i < mod->nsyms ; ++i, ++s, vals += 2) {
                len = strlen(s->name)+1;
                if (len > bufsize)
                        goto calc_space_needed;

                if (copy_to_user(strings, s->name, len)
                    || __put_user(s->value, vals+0)
                    || __put_user(space, vals+1))
                        return -EFAULT;

                strings += len;
                bufsize -= len;
                space += len;
        }

        if (put_user(i, ret))
                return -EFAULT;
        else
                return 0;

calc_space_needed:
        for (; i < mod->nsyms; ++i, ++s)
                space += strlen(s->name)+1;

        if (put_user(space, ret))
                return -EFAULT;
        else
                return -ENOSPC;
}

static inline int
qm_info(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
{
        int error = 0;

        if (mod->next == NULL)
                return -EINVAL;

        if (sizeof(struct module_info32) <= bufsize) {
                struct module_info32 info;
                info.addr = (unsigned long)mod;
                info.size = mod->size;
                info.flags = mod->flags;
                info.usecount =
                        ((mod_member_present(mod, can_unload)
                          && mod->can_unload)
                         ? -1 : atomic_read(&mod->uc.usecount));

                if (copy_to_user(buf, &info, sizeof(struct module_info32)))
                        return -EFAULT;
        } else
                error = -ENOSPC;

        if (put_user(sizeof(struct module_info32), ret))
                return -EFAULT;

        return error;
}

/* Note: it is necessary to treat which as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_query_module(char *name_user, u32 which, char *buf, __kernel_size_t32 bufsize, u32 ret)
{
        struct module *mod;
        int err;
        
        PPCDBG(PPCDBG_SYS32M, "sys32_query_module - entered - pid=%ld current=%lx comm=%s\n",
                    current->pid, current, current->comm);

        lock_kernel();
        if (name_user == 0) {
                /* This finds "kernel_module" which is not exported. */
                for(mod = module_list; mod->next != NULL; mod = mod->next)
                        ;
        } else {
                long namelen;
                char *name;

                if ((namelen = get_mod_name(name_user, &name)) < 0) {
                        err = namelen;
                        goto out;
                }
                err = -ENOENT;
                if (namelen == 0) {
                        /* This finds "kernel_module" which is not exported. */
                        for(mod = module_list; mod->next != NULL; mod = mod->next)
                                ;
                } else if ((mod = find_module(name)) == NULL) {
                        put_mod_name(name);
                        goto out;
                }
                put_mod_name(name);
        }

        switch ((int)which)
        {
        case 0:
                err = 0;
                break;
        case QM_MODULES:
                err = qm_modules(buf, bufsize, (__kernel_size_t32 *)AA(ret));
                break;
        case QM_DEPS:
                err = qm_deps(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
                break;
        case QM_REFS:
                err = qm_refs(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
                break;
        case QM_SYMBOLS:
                err = qm_symbols(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
                break;
        case QM_INFO:
                err = qm_info(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
                break;
        default:
                err = -EINVAL;
                break;
        }
out:
        unlock_kernel();
        
        PPCDBG(PPCDBG_SYS32, "sys32_query_module - exited - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        return err;
}



struct kernel_sym32 {
        u32 value;
        char name[60];
};
                 
extern asmlinkage long sys_get_kernel_syms(struct kernel_sym *table);

asmlinkage long sys32_get_kernel_syms(struct kernel_sym32 *table)
{
        int len, i;
        struct kernel_sym *tbl;
        mm_segment_t old_fs;
        
        PPCDBG(PPCDBG_SYS32, "sys32_get_kernel_syms - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        
        len = sys_get_kernel_syms(NULL);
        if (!table) return len;
        tbl = kmalloc (len * sizeof (struct kernel_sym), GFP_KERNEL);
        if (!tbl) return -ENOMEM;
        old_fs = get_fs();
        set_fs (KERNEL_DS);
        sys_get_kernel_syms(tbl);
        set_fs (old_fs);
        for (i = 0; i < len; i++, table += sizeof (struct kernel_sym32)) {
                if (put_user (tbl[i].value, &table->value) ||
                    copy_to_user (table->name, tbl[i].name, 60))
                        break;
        }
        kfree (tbl);
        
        PPCDBG(PPCDBG_SYS32, "sys32_get_kernel_syms - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        return i;
}

#else /* CONFIG_MODULES */

asmlinkage unsigned long sys32_create_module(const char *name_user, size_t size)
{
        
        PPCDBG(PPCDBG_SYS32, "sys32_create_module - running - pid=%ld, comm=%s\n", current->pid, current->comm);

        return -ENOSYS;
}

asmlinkage long sys32_init_module(const char *name_user, struct module *mod_user)
{
        PPCDBG(PPCDBG_SYS32, "sys32_init_module - running - pid=%ld, comm=%s\n", current->pid, current->comm);

        return -ENOSYS;
}

asmlinkage long sys32_delete_module(const char *name_user)
{
        PPCDBG(PPCDBG_SYS32, "sys32_delete_module - running - pid=%ld, comm=%s\n", current->pid, current->comm);

        return -ENOSYS;
}

/* Note: it is necessary to treat which as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_query_module(const char *name_user, u32 which, char *buf, size_t bufsize, size_t *ret)
{
        PPCDBG(PPCDBG_SYS32, "sys32_query_module - entered - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        /* Let the program know about the new interface.  Not that it'll do them much good. */
        if ((int)which == 0)
                return 0;

        PPCDBG(PPCDBG_SYS32, "sys32_query_module - exited - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);
        return -ENOSYS;
}

asmlinkage long sys32_get_kernel_syms(struct kernel_sym *table)
{
        PPCDBG(PPCDBG_SYS32, "sys32_get_kernel_syms - running - pid=%ld, comm=%s\n", current->pid, current->comm);

        return -ENOSYS;
}

#endif  /* CONFIG_MODULES */



/* Stuff for NFS server syscalls... */
struct nfsctl_svc32 {
        u16                     svc32_port;
        s32                     svc32_nthreads;
};

struct nfsctl_client32 {
        s8                      cl32_ident[NFSCLNT_IDMAX+1];
        s32                     cl32_naddr;
        struct in_addr          cl32_addrlist[NFSCLNT_ADDRMAX];
        s32                     cl32_fhkeytype;
        s32                     cl32_fhkeylen;
        u8                      cl32_fhkey[NFSCLNT_KEYMAX];
};

struct nfsctl_export32 {
        s8                      ex32_client[NFSCLNT_IDMAX+1];
        s8                      ex32_path[NFS_MAXPATHLEN+1];
        __kernel_dev_t32        ex32_dev;
        __kernel_ino_t32        ex32_ino;
        s32                     ex32_flags;
        __kernel_uid_t32        ex32_anon_uid;
        __kernel_gid_t32        ex32_anon_gid;
};

struct nfsctl_uidmap32 {
        u32                     ug32_ident;   /* char * */
        __kernel_uid_t32        ug32_uidbase;
        s32                     ug32_uidlen;
        u32                     ug32_udimap;  /* uid_t * */
        __kernel_uid_t32        ug32_gidbase;
        s32                     ug32_gidlen;
        u32                     ug32_gdimap;  /* gid_t * */
};

struct nfsctl_fhparm32 {
        struct sockaddr         gf32_addr;
        __kernel_dev_t32        gf32_dev;
        __kernel_ino_t32        gf32_ino;
        s32                     gf32_version;
};

struct nfsctl_fdparm32 {
        struct sockaddr         gd32_addr;
        s8                      gd32_path[NFS_MAXPATHLEN+1];
        s32                     gd32_version;
};

struct nfsctl_fsparm32 {
        struct sockaddr         gd32_addr;
        s8                      gd32_path[NFS_MAXPATHLEN+1];
        s32                     gd32_maxlen;
};

struct nfsctl_arg32 {
        s32                     ca32_version;   /* safeguard */
        union {
                struct nfsctl_svc32     u32_svc;
                struct nfsctl_client32  u32_client;
                struct nfsctl_export32  u32_export;
                struct nfsctl_uidmap32  u32_umap;
                struct nfsctl_fhparm32  u32_getfh;
                struct nfsctl_fdparm32  u32_getfd;
                struct nfsctl_fsparm32  u32_getfs;
        } u;
#define ca32_svc        u.u32_svc
#define ca32_client     u.u32_client
#define ca32_export     u.u32_export
#define ca32_umap       u.u32_umap
#define ca32_getfh      u.u32_getfh
#define ca32_getfd      u.u32_getfd
#define ca32_getfs      u.u32_getfs
#define ca32_authd      u.u32_authd
};

union nfsctl_res32 {
        __u8                    cr32_getfh[NFS_FHSIZE];
        struct knfsd_fh         cr32_getfs;
};

static int nfs_svc32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        int err;
        
        err = __get_user(karg->ca_version, &arg32->ca32_version);
        err |= __get_user(karg->ca_svc.svc_port, &arg32->ca32_svc.svc32_port);
        err |= __get_user(karg->ca_svc.svc_nthreads, &arg32->ca32_svc.svc32_nthreads);
        return err;
}

static int nfs_clnt32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        int err;
        
        err = __get_user(karg->ca_version, &arg32->ca32_version);
        err |= copy_from_user(&karg->ca_client.cl_ident[0],
                          &arg32->ca32_client.cl32_ident[0],
                          NFSCLNT_IDMAX);
        err |= __get_user(karg->ca_client.cl_naddr, &arg32->ca32_client.cl32_naddr);
        err |= copy_from_user(&karg->ca_client.cl_addrlist[0],
                          &arg32->ca32_client.cl32_addrlist[0],
                          (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
        err |= __get_user(karg->ca_client.cl_fhkeytype,
                      &arg32->ca32_client.cl32_fhkeytype);
        err |= __get_user(karg->ca_client.cl_fhkeylen,
                      &arg32->ca32_client.cl32_fhkeylen);
        err |= copy_from_user(&karg->ca_client.cl_fhkey[0],
                          &arg32->ca32_client.cl32_fhkey[0],
                          NFSCLNT_KEYMAX);

        if(err) return -EFAULT;
        return 0;
}

static int nfs_exp32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        int err;
        
        err = __get_user(karg->ca_version, &arg32->ca32_version);
        err |= copy_from_user(&karg->ca_export.ex_client[0],
                          &arg32->ca32_export.ex32_client[0],
                          NFSCLNT_IDMAX);
        err |= copy_from_user(&karg->ca_export.ex_path[0],
                          &arg32->ca32_export.ex32_path[0],
                          NFS_MAXPATHLEN);
        err |= __get_user(karg->ca_export.ex_dev,
                      &arg32->ca32_export.ex32_dev);
        err |= __get_user(karg->ca_export.ex_ino,
                      &arg32->ca32_export.ex32_ino);
        err |= __get_user(karg->ca_export.ex_flags,
                      &arg32->ca32_export.ex32_flags);
        err |= __get_user(karg->ca_export.ex_anon_uid,
                      &arg32->ca32_export.ex32_anon_uid);
        err |= __get_user(karg->ca_export.ex_anon_gid,
                      &arg32->ca32_export.ex32_anon_gid);
        karg->ca_export.ex_anon_uid = karg->ca_export.ex_anon_uid;
        karg->ca_export.ex_anon_gid = karg->ca_export.ex_anon_gid;

        if(err) return -EFAULT;
        return 0;
}

static int nfs_uud32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        u32 uaddr;
        int i;
        int err;

        memset(karg, 0, sizeof(*karg));
        if(__get_user(karg->ca_version, &arg32->ca32_version))
                return -EFAULT;
        karg->ca_umap.ug_ident = (char *)get_free_page(GFP_USER);
        if(!karg->ca_umap.ug_ident)
                return -ENOMEM;
        err = __get_user(uaddr, &arg32->ca32_umap.ug32_ident);
        if(strncpy_from_user(karg->ca_umap.ug_ident,
                             (char *)A(uaddr), PAGE_SIZE) <= 0)
                return -EFAULT;
        err |= __get_user(karg->ca_umap.ug_uidbase,
                      &arg32->ca32_umap.ug32_uidbase);
        err |= __get_user(karg->ca_umap.ug_uidlen,
                      &arg32->ca32_umap.ug32_uidlen);
        err |= __get_user(uaddr, &arg32->ca32_umap.ug32_udimap);
        if (err)
                return -EFAULT;
        karg->ca_umap.ug_udimap = kmalloc((sizeof(uid_t) * karg->ca_umap.ug_uidlen),
                                          GFP_USER);
        if(!karg->ca_umap.ug_udimap)
                return -ENOMEM;
        for(i = 0; i < karg->ca_umap.ug_uidlen; i++)
                err |= __get_user(karg->ca_umap.ug_udimap[i],
                              &(((__kernel_uid_t32 *)A(uaddr))[i]));
        err |= __get_user(karg->ca_umap.ug_gidbase,
                      &arg32->ca32_umap.ug32_gidbase);
        err |= __get_user(karg->ca_umap.ug_uidlen,
                      &arg32->ca32_umap.ug32_gidlen);
        err |= __get_user(uaddr, &arg32->ca32_umap.ug32_gdimap);
        if (err)
                return -EFAULT;
        karg->ca_umap.ug_gdimap = kmalloc((sizeof(gid_t) * karg->ca_umap.ug_uidlen),
                                          GFP_USER);
        if(!karg->ca_umap.ug_gdimap)
                return -ENOMEM;
        for(i = 0; i < karg->ca_umap.ug_gidlen; i++)
                err |= __get_user(karg->ca_umap.ug_gdimap[i],
                              &(((__kernel_gid_t32 *)A(uaddr))[i]));

        return err;
}

static int nfs_getfh32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        int err;
        
        err = __get_user(karg->ca_version, &arg32->ca32_version);
        err |= copy_from_user(&karg->ca_getfh.gf_addr,
                          &arg32->ca32_getfh.gf32_addr,
                          (sizeof(struct sockaddr)));
        err |= __get_user(karg->ca_getfh.gf_dev,
                      &arg32->ca32_getfh.gf32_dev);
        err |= __get_user(karg->ca_getfh.gf_ino,
                      &arg32->ca32_getfh.gf32_ino);
        err |= __get_user(karg->ca_getfh.gf_version,
                      &arg32->ca32_getfh.gf32_version);

        if(err) return -EFAULT;
        return 0;
}

static int nfs_getfd32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        int err;
        
        err = __get_user(karg->ca_version, &arg32->ca32_version);
        err |= copy_from_user(&karg->ca_getfd.gd_addr,
                          &arg32->ca32_getfd.gd32_addr,
                          (sizeof(struct sockaddr)));
        err |= copy_from_user(&karg->ca_getfd.gd_path,
                          &arg32->ca32_getfd.gd32_path,
                          (NFS_MAXPATHLEN+1));
        err |= __get_user(karg->ca_getfd.gd_version,
                      &arg32->ca32_getfd.gd32_version);

        if(err) return -EFAULT;
        return 0;
}

static int nfs_getfs32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
{
        int err;
        
        err = __get_user(karg->ca_version, &arg32->ca32_version);
        err |= copy_from_user(&karg->ca_getfs.gd_addr,
                          &arg32->ca32_getfs.gd32_addr,
                          (sizeof(struct sockaddr)));
        err |= copy_from_user(&karg->ca_getfs.gd_path,
                          &arg32->ca32_getfs.gd32_path,
                          (NFS_MAXPATHLEN+1));
        err |= __get_user(karg->ca_getfs.gd_maxlen,
                      &arg32->ca32_getfs.gd32_maxlen);

        if(err) return -EFAULT;
        return 0;
}

/* This really doesn't need translations, we are only passing
 * back a union which contains opaque nfs file handle data.
 */
static int nfs_getfh32_res_trans(union nfsctl_res *kres, union nfsctl_res32 *res32)
{
        int err;

        err = copy_to_user(res32, kres, sizeof(*res32));

        if(err) return -EFAULT;
        return 0;
}

/* Note: it is necessary to treat cmd_parm as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
int asmlinkage sys32_nfsservctl(u32 cmd_parm, struct nfsctl_arg32 *arg32, union nfsctl_res32 *res32)
{
  int cmd = (int)cmd_parm;
        struct nfsctl_arg *karg = NULL;
        union nfsctl_res *kres = NULL;
        mm_segment_t oldfs;
        int err;

        karg = kmalloc(sizeof(*karg), GFP_USER);
        if(!karg)
                return -ENOMEM;
        if(res32) {
                kres = kmalloc(sizeof(*kres), GFP_USER);
                if(!kres) {
                        kfree(karg);
                        return -ENOMEM;
                }
        }
        switch(cmd) {
        case NFSCTL_SVC:
                err = nfs_svc32_trans(karg, arg32);
                break;
        case NFSCTL_ADDCLIENT:
                err = nfs_clnt32_trans(karg, arg32);
                break;
        case NFSCTL_DELCLIENT:
                err = nfs_clnt32_trans(karg, arg32);
                break;
        case NFSCTL_EXPORT:
        case NFSCTL_UNEXPORT:
                err = nfs_exp32_trans(karg, arg32);
                break;
        /* This one is unimplemented, be we're ready for it. */
        case NFSCTL_UGIDUPDATE:
                err = nfs_uud32_trans(karg, arg32);
                break;
        case NFSCTL_GETFH:
                err = nfs_getfh32_trans(karg, arg32);
                break;
        case NFSCTL_GETFD:
                err = nfs_getfd32_trans(karg, arg32);
                break;
        case NFSCTL_GETFS:

                err = nfs_getfs32_trans(karg, arg32);
                break;
        default:
                err = -EINVAL;
                break;
        }
        if(err)
                goto done;
        oldfs = get_fs();
        set_fs(KERNEL_DS);
        err = sys_nfsservctl(cmd, karg, kres);
        set_fs(oldfs);

        if (err)
                goto done;

        if((cmd == NFSCTL_GETFH) ||
           (cmd == NFSCTL_GETFD) ||
           (cmd == NFSCTL_GETFS))
                err = nfs_getfh32_res_trans(kres, res32);

done:
        if(karg) {
                if(cmd == NFSCTL_UGIDUPDATE) {
                        if(karg->ca_umap.ug_ident)
                                kfree(karg->ca_umap.ug_ident);
                        if(karg->ca_umap.ug_udimap)
                                kfree(karg->ca_umap.ug_udimap);
                        if(karg->ca_umap.ug_gdimap)
                                kfree(karg->ca_umap.ug_gdimap);
                }
                kfree(karg);
        }
        if(kres)
                kfree(kres);
        return err;
}



struct timespec32 {
        s32    tv_sec;
        s32    tv_nsec;
};

extern asmlinkage long sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp);

asmlinkage long sys32_nanosleep(struct timespec32 *rqtp, struct timespec32 *rmtp)
{
        struct timespec t;
        int ret;
        mm_segment_t old_fs = get_fs ();
        
        PPCDBG(PPCDBG_SYS32NI, "sys32_nanosleep - running - pid=%ld, comm=%s \n", current->pid, current->comm);
        
        if (get_user (t.tv_sec, &rqtp->tv_sec) ||
            __get_user (t.tv_nsec, &rqtp->tv_nsec))
                return -EFAULT;
        set_fs (KERNEL_DS);
        ret = sys_nanosleep(&t, rmtp ? &t : NULL);
        set_fs (old_fs);
        if (rmtp && ret == -EINTR) {
                if (__put_user (t.tv_sec, &rmtp->tv_sec) ||
                    __put_user (t.tv_nsec, &rmtp->tv_nsec))
                        return -EFAULT;
        }
        
        return ret;
}




/* These are here just in case some old sparc32 binary calls it. */
asmlinkage long sys32_pause(void)
{
        
        PPCDBG(PPCDBG_SYS32, "sys32_pause - running - pid=%ld, comm=%s \n", current->pid, current->comm);

        current->state = TASK_INTERRUPTIBLE;
        schedule();
        
        return -ERESTARTNOHAND;
}



static inline long get_it32(struct itimerval *o, struct itimerval32 *i)
{
        return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
                (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
                 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
                 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
                 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
}

static inline long put_it32(struct itimerval32 *o, struct itimerval *i)
{
        return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
                (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
                 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
                 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
                 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
}

static inline long get_tv32(struct timeval *o, struct timeval32 *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 timeval32 *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 int do_getitimer(int which, struct itimerval *value);

/* Note: it is necessary to treat which as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_getitimer(u32 which, struct itimerval32 *it)
{
        struct itimerval kit;
        int error;
        
        PPCDBG(PPCDBG_SYS32, "sys32_getitimer - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        error = do_getitimer((int)which, &kit);
        if (!error && put_it32(it, &kit))
                error = -EFAULT;

        
        PPCDBG(PPCDBG_SYS32, "sys32_getitimer - exited - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);
        return error;
}



extern int do_setitimer(int which, struct itimerval *, struct itimerval *);

/* Note: it is necessary to treat which as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_setitimer(u32 which, struct itimerval32 *in, struct itimerval32 *out)
{
        struct itimerval kin, kout;
        int error;
        
        PPCDBG(PPCDBG_SYS32, "sys32_setitimer - entered - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);

        if (in) {
                if (get_it32(&kin, in))
                        return -EFAULT;
        } else
                memset(&kin, 0, sizeof(kin));

        error = do_setitimer((int)which, &kin, out ? &kout : NULL);
        if (error || !out)
                return error;
        if (put_it32(out, &kout))
                return -EFAULT;

        
        PPCDBG(PPCDBG_SYS32, "sys32_setitimer - exited - pid=%ld current=%lx comm=%s\n", current->pid, current, current->comm);
        return 0;
}

#define RLIM_INFINITY32 0xffffffff
#define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)

struct rlimit32 {
        u32     rlim_cur;
        u32     rlim_max;
};

extern asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit *rlim);
asmlinkage long sys32_getrlimit(unsigned int resource, struct rlimit32 *rlim)
{
        struct rlimit r;
        int ret;
        mm_segment_t old_fs = get_fs();
        
        set_fs (KERNEL_DS);
        ret = sys_getrlimit(resource, &r);
        set_fs(old_fs);
        if (!ret) {
                ret = put_user(RESOURCE32(r.rlim_cur), &rlim->rlim_cur);
                ret |= __put_user(RESOURCE32(r.rlim_max), &rlim->rlim_max);
        }
        
        return ret;
}

/* Back compatibility for getrlimit. Needed for some apps. */
asmlinkage long sys32_old_getrlimit(unsigned int resource, struct rlimit32* rlim)
{
        struct rlimit   x;    // 64-bit version of the resource limits.
        struct rlimit32 x32;  // 32-bit version of the resource limits.
        long rc = 0;
        
        if (resource >= RLIM_NLIMITS) {
                PPCDBG(PPCDBG_SYS32, "sys32_old_getrlimit - specified resource is too large (%x) - pid=%ld, comm=%s\n", resource, current->pid, current->comm);
                return -EINVAL;
        }

        memcpy(&x, current->rlim+resource, sizeof(struct rlimit));

        if(x.rlim_cur > RLIM_INFINITY32)
                x32.rlim_cur = RLIM_INFINITY32;
        else
                x32.rlim_cur = x.rlim_cur;

        if(x.rlim_max > RLIM_INFINITY32)
                x32.rlim_max = RLIM_INFINITY32;
        else
                x32.rlim_max = x.rlim_max;

        rc = (copy_to_user(rlim, &x32, sizeof(x32))) ? (-EFAULT) : 0;
        if (rc == 0) {
                PPCDBG(PPCDBG_SYS32, "sys32_old_getrlimit - current=%x, maximum=%x - pid=%ld, comm=%s\n", x32.rlim_cur, x32.rlim_max, current->pid, current->comm);
        } else {
                PPCDBG(PPCDBG_SYS32, "sys32_old_getrlimit - unable to copy into user's storage - pid=%ld, comm=%s\n", current->pid, current->comm);
        }
        return rc;
}

extern asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit *rlim);
asmlinkage long sys32_setrlimit(unsigned int resource, struct rlimit32 *rlim)
{
        struct rlimit r;
        long ret;
        mm_segment_t old_fs = get_fs ();
        
        PPCDBG(PPCDBG_SYS32, "sys32_setrlimit - entered - resource=%x, rlim=%p - pid=%ld, comm=%s\n", resource, rlim, current->pid, current->comm);

        if (resource >= RLIM_NLIMITS) return -EINVAL;   
        if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
            __get_user (r.rlim_max, &rlim->rlim_max))
                return -EFAULT;
        if (r.rlim_cur >= RLIM_INFINITY32)
                r.rlim_cur = RLIM_INFINITY;
        if (r.rlim_max >= RLIM_INFINITY32)
                r.rlim_max = RLIM_INFINITY;
        set_fs (KERNEL_DS);
        ret = sys_setrlimit(resource, &r);
        set_fs (old_fs);
        
        PPCDBG(PPCDBG_SYS32, "sys32_setrlimit - exited w/ ret=%x - pid=%ld, comm=%s\n", ret, current->pid, current->comm);
        return ret;
}


struct rusage32 {
        struct timeval32 ru_utime;
        struct timeval32 ru_stime;
        s32    ru_maxrss;
        s32    ru_ixrss;
        s32    ru_idrss;
        s32    ru_isrss;
        s32    ru_minflt;
        s32    ru_majflt;
        s32    ru_nswap;
        s32    ru_inblock;
        s32    ru_oublock;
        s32    ru_msgsnd; 
        s32    ru_msgrcv; 
        s32    ru_nsignals;
        s32    ru_nvcsw;
        s32    ru_nivcsw;
};

static int put_rusage (struct rusage32 *ru, struct rusage *r)
{
        int err;
        
        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;
}


extern asmlinkage long sys_getrusage(int who, struct rusage *ru);

/* Note: it is necessary to treat who as an unsigned int, 
 * with the corresponding cast to a signed int to insure that the 
 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
 * and the register representation of a signed int (msr in 64-bit mode) is performed.
 */
asmlinkage long sys32_getrusage(u32 who, struct rusage32 *ru)
{
        struct rusage r;
        int ret;
        mm_segment_t old_fs = get_fs();
        
        PPCDBG(PPCDBG_SYS32X, "sys32_getrusage - running - pid=%ld, comm=%s\n", current->pid, current->comm);
                
        set_fs (KERNEL_DS);
        ret = sys_getrusage((int)who, &r);
        set_fs (old_fs);
        if (put_rusage (ru, &r)) 
                return -EFAULT;

        return ret;
}




struct sysinfo32 {
        s32 uptime;
        u32 loads[3];
        u32 totalram;
        u32 freeram;
        u32 sharedram;
        u32 bufferram;
        u32 totalswap;
        u32 freeswap;
        unsigned short procs;
        unsigned short pad;
        u32 totalhigh;
        u32 freehigh;
        u32 mem_unit;
        char _f[20-2*sizeof(u32)-sizeof(int)];
};

extern asmlinkage long sys_sysinfo(struct sysinfo *info);

asmlinkage long sys32_sysinfo(struct sysinfo32 *info)
{
        struct sysinfo s;
        int ret, err;
        int bitcount = 0;
        mm_segment_t old_fs = get_fs ();
        
        PPCDBG(PPCDBG_SYS32, "sys32_sysinfo - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);
        
        set_fs (KERNEL_DS);
        ret = sys_sysinfo(&s);
        set_fs (old_fs);
        /* Check to see if any memory value is too large for 32-bit and scale
         *  down if needed
         */
        if ((s.totalram >> 32) || (s.totalswap >> 32)) {
                while (s.mem_unit < PAGE_SIZE) {
                        s.mem_unit <<= 1;
                        bitcount++;
                }
                s.totalram >>= bitcount;
                s.freeram >>= bitcount;
                s.sharedram >>= bitcount;
                s.bufferram >>= bitcount;
                s.totalswap >>= bitcount;
                s.freeswap >>= bitcount;
                s.totalhigh >>= bitcount;
                s.freehigh >>= bitcount;
        }
        
        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;
        
        PPCDBG(PPCDBG_SYS32, "sys32_sysinfo - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        return ret;
}




/* Translations due to time_t size differences.  Which affects all
   sorts of things, like timeval and itimerval.  */
extern struct timezone sys_tz;
extern int do_sys_settimeofday(struct timeval *tv, struct timezone *tz);

asmlinkage long sys32_gettimeofday(struct timeval32 *tv, struct timezone *tz)
{
        
        PPCDBG(PPCDBG_SYS32X, "sys32_gettimeofday - running - pid=%ld, comm=%s\n", current->pid, current->comm);

        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;
}



asmlinkage long sys32_settimeofday(struct timeval32 *tv, struct timezone *tz)
{
        struct timeval ktv;
        struct timezone ktz;
        
        PPCDBG(PPCDBG_SYS32, "sys32_settimeofday - running - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        if (tv) {
                if (get_tv32(&ktv, tv))
                        return -EFAULT;
        }
        if (tz) {
                if (copy_from_user(&ktz, tz, sizeof(ktz)))
                        return -EFAULT;
        }

        return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL);
}




struct tms32 {
        __kernel_clock_t32 tms_utime;
        __kernel_clock_t32 tms_stime;
        __kernel_clock_t32 tms_cutime;
        __kernel_clock_t32 tms_cstime;
};
                                
extern asmlinkage long sys_times(struct tms * tbuf);

asmlinkage long sys32_times(struct tms32 *tbuf)
{
        struct tms t;
        long ret;
        mm_segment_t old_fs = get_fs ();
        int err;
        
        PPCDBG(PPCDBG_SYS32, "sys32_times - entered - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);
        
        set_fs (KERNEL_DS);
        ret = sys_times(tbuf ? &t : NULL);
        set_fs (old_fs);
        if (tbuf) {
                err = put_user (t.tms_utime, &tbuf->tms_utime);
                err |= __put_user (t.tms_stime, &tbuf->tms_stime);
                err |= __put_user (t.tms_cutime, &tbuf->tms_cutime);
                err |= __put_user (t.tms_cstime, &tbuf->tms_cstime);
                if (err)
                        ret = -EFAULT;
        }
        
        PPCDBG(PPCDBG_SYS32, "sys32_times - exited - pid=%ld current=%lx comm=%s \n", current->pid, current, current->comm);

        return ret;
}

struct msgbuf32 { s32 mtype; char mtext[1]; };

struct semid_ds32 {
        struct ipc_perm32 sem_perm;
        unsigned int _pad0;
        __kernel_time_t32 sem_otime;
        unsigned int _pad1;
        __kernel_time_t32 sem_ctime;
        u32 sem_base;
        u32 sem_pending;
        u32 sem_pending_last;
        u32 undo;
        unsigned short sem_nsems;
};

struct semid64_ds32 {
        struct ipc64_perm32 sem_perm;
        unsigned int __unused1;
        __kernel_time_t32 sem_otime;
        unsigned int __unused2;
        __kernel_time_t32 sem_ctime;
        u32 sem_nsems;
        u32 __unused3;
        u32 __unused4;
};

struct msqid_ds32
{
        struct ipc_perm32 msg_perm;
        u32 msg_first;
        u32 msg_last;
        __kernel_time_t32 msg_stime;
        __kernel_time_t32 msg_rtime;
        __kernel_time_t32 msg_ctime;
        u32 msg_lcbytes;
        u32 msg_lqbytes;
        unsigned short msg_cbytes;
        unsigned short msg_qnum;
        unsigned short msg_qbytes;
        __kernel_ipc_pid_t32 msg_lspid;
        __kernel_ipc_pid_t32 msg_lrpid;
};

struct msqid64_ds32 {
        struct ipc64_perm32 msg_perm;
        unsigned int __unused1;
        __kernel_time_t32 msg_stime;
        unsigned int __unused2;
        __kernel_time_t32 msg_rtime;
        unsigned int __unused3;
        __kernel_time_t32 msg_ctime;
        unsigned int msg_cbytes;
        unsigned int msg_qnum;
        unsigned int msg_qbytes;
        __kernel_pid_t32 msg_lspid;
        __kernel_pid_t32 msg_lrpid;
        unsigned int __unused4;
        unsigned int __unused5;
};

struct shmid_ds32 {
        struct ipc_perm32 shm_perm;
        int shm_segsz;
        __kernel_time_t32 shm_atime;
        __kernel_time_t32 shm_dtime;
        __kernel_time_t32 shm_ctime;
        __kernel_ipc_pid_t32 shm_cpid;
        __kernel_ipc_pid_t32 shm_lpid;
        unsigned short shm_nattch;
        unsigned short __unused;
        unsigned int __unused2;
        unsigned int __unused3;
};

struct shmid64_ds32 {
        struct ipc64_perm32 shm_perm;
        unsigned int __unused1;
        __kernel_time_t32 shm_atime;
        unsigned int __unused2;
        __kernel_time_t32 shm_dtime;
        unsigned int __unused3;
        __kernel_time_t32 shm_ctime;
        unsigned int __unused4;
        __kernel_size_t32 shm_segsz;
        __kernel_pid_t32 shm_cpid;
        __kernel_pid_t32 shm_lpid;
        unsigned int shm_nattch;
        unsigned int __unused5;
        unsigned int __unused6;
};

/*
 * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit
 * emulation..
 *
 * This is really horribly ugly.
 */
static long do_sys32_semctl(int first, int second, int third, void *uptr)
{
        union semun fourth;
        u32 pad;
        int err, err2;
        mm_segment_t old_fs;

        if (!uptr)
                return -EINVAL;
        err = -EFAULT;
        if (get_user(pad, (u32 *)uptr))
                return err;
        if ((third & (~IPC_64)) == SETVAL)
                fourth.val = (int)pad;
        else
                fourth.__pad = (void *)A(pad);
        switch (third & (~IPC_64)) {

        case IPC_INFO:
        case IPC_RMID:
        case SEM_INFO:
        case GETVAL:
        case GETPID:
        case GETNCNT:
        case GETZCNT:
        case GETALL:
        case SETALL:
        case SETVAL:
                err = sys_semctl(first, second, third, fourth);
                break;

        case IPC_STAT:
        case SEM_STAT:
                if (third & IPC_64) {
                        struct semid64_ds s64;
                        struct semid64_ds32 *usp;

                        usp = (struct semid64_ds32 *)A(pad);
                        fourth.__pad = &s64;
                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_semctl(first, second, third, fourth);
                        set_fs(old_fs);
                        err2 = copy_to_user(&usp->sem_perm, &s64.sem_perm,
                                            sizeof(struct ipc64_perm32));
                        err2 |= __put_user(s64.sem_otime, &usp->sem_otime);
                        err2 |= __put_user(s64.sem_ctime, &usp->sem_ctime);
                        err2 |= __put_user(s64.sem_nsems, &usp->sem_nsems);
                        if (err2)
                                err = -EFAULT;
                } else {
                        struct semid_ds s;
                        struct semid_ds32 *usp;

                        usp = (struct semid_ds32 *)A(pad);
                        fourth.__pad = &s;
                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_semctl(first, second, third, fourth);
                        set_fs(old_fs);
                        err2 = copy_to_user(&usp->sem_perm, &s.sem_perm,
                                            sizeof(struct ipc_perm32));
                        err2 |= __put_user(s.sem_otime, &usp->sem_otime);
                        err2 |= __put_user(s.sem_ctime, &usp->sem_ctime);
                        err2 |= __put_user(s.sem_nsems, &usp->sem_nsems);
                        if (err2)
                                err = -EFAULT;
                }
                break;
 
        case IPC_SET:
                if (third & IPC_64) {
                        struct semid64_ds s64;
                        struct semid64_ds32 *usp;

                        usp = (struct semid64_ds32 *)A(pad);

                        err = get_user(s64.sem_perm.uid, &usp->sem_perm.uid);
                        err |= __get_user(s64.sem_perm.gid,
                                          &usp->sem_perm.gid);
                        err |= __get_user(s64.sem_perm.mode,
                                          &usp->sem_perm.mode);
                        if (err)
                                goto out;
                        fourth.__pad = &s64;

                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_semctl(first, second, third, fourth);
                        set_fs(old_fs);

                } else {
                        struct semid_ds s;
                        struct semid_ds32 *usp;

                        usp = (struct semid_ds32 *)A(pad);

                        err = get_user(s.sem_perm.uid, &usp->sem_perm.uid);
                        err |= __get_user(s.sem_perm.gid,
                                          &usp->sem_perm.gid);
                        err |= __get_user(s.sem_perm.mode,
                                          &usp->sem_perm.mode);
                        if (err)
                                goto out;
                        fourth.__pad = &s;

                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_semctl(first, second, third, fourth);
                        set_fs(old_fs);
                }
                break;
        default:
                err = -EINVAL;
        }
out:
        return err;
}

#define MAXBUF (64*1024)

static int 
do_sys32_msgsnd(int first, int second, int third, void *uptr)
{
        struct msgbuf *p;
        struct msgbuf32 *up = (struct msgbuf32 *)uptr;
        mm_segment_t old_fs;
        int err;

        if (second < 0 || (second >= MAXBUF-sizeof(struct msgbuf)))
                return -EINVAL;

        p = kmalloc(second + sizeof(struct msgbuf), GFP_USER);
        if (!p)
                return -ENOMEM;
        err = get_user(p->mtype, &up->mtype);
        err |= copy_from_user(p->mtext, &up->mtext, second);
        if (err) {
                err = -EFAULT;
                goto out;
        }
        old_fs = get_fs();
        set_fs(KERNEL_DS);
        err = sys_msgsnd(first, p, second, third);
        set_fs(old_fs);
out:
        kfree(p);
        return err;
}

static int
do_sys32_msgrcv(int first, int second, int msgtyp, int third,
                int version, void *uptr)
{
        struct msgbuf32 *up;
        struct msgbuf *p;
        mm_segment_t old_fs;
        int err;

        if (second < 0 || (second >= MAXBUF-sizeof(struct msgbuf)))
                return -EINVAL;

        if (!version) {
                struct ipc_kludge_32 *uipck = (struct ipc_kludge_32 *)uptr;
                struct ipc_kludge_32 ipck;

                err = -EINVAL;
                if (!uptr)
                        goto out;
                err = -EFAULT;
                if (copy_from_user(&ipck, uipck, sizeof(struct ipc_kludge_32)))
                        goto out;
                uptr = (void *)A(ipck.msgp);
                msgtyp = ipck.msgtyp;
        }
        err = -ENOMEM;
        p = kmalloc(second + sizeof (struct msgbuf), GFP_USER);
        if (!p)
                goto out;
        old_fs = get_fs();
        set_fs(KERNEL_DS);
        err = sys_msgrcv(first, p, second, msgtyp, third);
        set_fs(old_fs);
        if (err < 0)
                goto free_then_out;
        up = (struct msgbuf32 *)uptr;
        if (put_user(p->mtype, &up->mtype) ||
            copy_to_user(&up->mtext, p->mtext, err))
                err = -EFAULT;
free_then_out:
        kfree(p);
out:
        return err;
}

static int
do_sys32_msgctl(int first, int second, void *uptr)
{
        int err = -EINVAL, err2;
        mm_segment_t old_fs;

        switch (second & (~IPC_64)) {

        case IPC_INFO:
        case IPC_RMID:
        case MSG_INFO:
                err = sys_msgctl(first, second, (struct msqid_ds *)uptr);
                break;

        case IPC_SET:
                if (second & IPC_64) {
                        struct msqid64_ds m64;
                        struct msqid64_ds32 *up = (struct msqid64_ds32 *)uptr;

                        err2 = copy_from_user(&m64.msg_perm, &up->msg_perm,
                                              sizeof(struct ipc64_perm32));
                        err2 |= __get_user(m64.msg_qbytes, &up->msg_qbytes);
                        if (err2) {
                                err = -EFAULT;
                                break;
                        }
                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_msgctl(first, second,
                                         (struct msqid_ds *)&m64);
                        set_fs(old_fs);
                } else {
                        struct msqid_ds m;
                        struct msqid_ds32 *up = (struct msqid_ds32 *)uptr;

                        err2 = copy_from_user(&m.msg_perm, &up->msg_perm,
                                              sizeof(struct ipc_perm32));
                        err2 |= __get_user(m.msg_qbytes, &up->msg_qbytes);
                        if (err2) {
                                err = -EFAULT;
                                break;
                        }
                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_msgctl(first, second, &m);
                        set_fs(old_fs);
                }
                break;

        case IPC_STAT:
        case MSG_STAT:
                if (second & IPC_64) {
                        struct msqid64_ds m64;
                        struct msqid64_ds32 *up = (struct msqid64_ds32 *)uptr;

                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_msgctl(first, second,
                                         (struct msqid_ds *)&m64);
                        set_fs(old_fs);

                        err2 = copy_to_user(&up->msg_perm, &m64.msg_perm,
                                            sizeof(struct ipc64_perm32));
                        err2 |= __put_user(m64.msg_stime, &up->msg_stime);
                        err2 |= __put_user(m64.msg_rtime, &up->msg_rtime);
                        err2 |= __put_user(m64.msg_ctime, &up->msg_ctime);
                        err2 |= __put_user(m64.msg_cbytes, &up->msg_cbytes);
                        err2 |= __put_user(m64.msg_qnum, &up->msg_qnum);
                        err2 |= __put_user(m64.msg_qbytes, &up->msg_qbytes);
                        err2 |= __put_user(m64.msg_lspid, &up->msg_lspid);
                        err2 |= __put_user(m64.msg_lrpid, &up->msg_lrpid);
                        if (err2)
                                err = -EFAULT;
                } else {
                        struct msqid64_ds m;
                        struct msqid_ds32 *up = (struct msqid_ds32 *)uptr;

                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_msgctl(first, second, (struct msqid_ds *)&m);
                        set_fs(old_fs);

                        err2 = copy_to_user(&up->msg_perm, &m.msg_perm,
                                            sizeof(struct ipc_perm32));
                        err2 |= __put_user(m.msg_stime, &up->msg_stime);
                        err2 |= __put_user(m.msg_rtime, &up->msg_rtime);
                        err2 |= __put_user(m.msg_ctime, &up->msg_ctime);
                        err2 |= __put_user(m.msg_cbytes, &up->msg_cbytes);
                        err2 |= __put_user(m.msg_qnum, &up->msg_qnum);
                        err2 |= __put_user(m.msg_qbytes, &up->msg_qbytes);
                        err2 |= __put_user(m.msg_lspid, &up->msg_lspid);
                        err2 |= __put_user(m.msg_lrpid, &up->msg_lrpid);
                        if (err2)
                                err = -EFAULT;
                }
                break;
        }
        return err;
}

static int
do_sys32_shmat(int first, int second, int third, int version, void *uptr)
{
        unsigned long raddr;
        u32 *uaddr = (u32 *)A((u32)third);
        int err = -EINVAL;

        if (version == 1)
                return err;
        err = sys_shmat(first, uptr, second, &raddr);
        if (err)
                return err;
        err = put_user(raddr, uaddr);
        return err;
}

static int
do_sys32_shmctl(int first, int second, void *uptr)
{
        int err = -EINVAL, err2;
        mm_segment_t old_fs;

        switch (second & (~IPC_64)) {

        case IPC_INFO:
        case IPC_RMID:
        case SHM_LOCK:
        case SHM_UNLOCK:
                err = sys_shmctl(first, second, (struct shmid_ds *)uptr);
                break;
        case IPC_SET:
                if (second & IPC_64) {
                        struct shmid64_ds32 *up = (struct shmid64_ds32 *)uptr;
                        struct shmid64_ds s64;

                        err = get_user(s64.shm_perm.uid, &up->shm_perm.uid);
                        err |= __get_user(s64.shm_perm.gid, &up->shm_perm.gid);
                        err |= __get_user(s64.shm_perm.mode,
                                          &up->shm_perm.mode);
                        if (err)
                                break;
                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_shmctl(first, second,
                                         (struct shmid_ds *)&s64);
                        set_fs(old_fs);
                } else {
                        struct shmid_ds32 *up = (struct shmid_ds32 *)uptr;
                        struct shmid_ds s;

                        err = get_user(s.shm_perm.uid, &up->shm_perm.uid);
                        err |= __get_user(s.shm_perm.gid, &up->shm_perm.gid);
                        err |= __get_user(s.shm_perm.mode, &up->shm_perm.mode);
                        if (err)
                                break;
                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_shmctl(first, second, &s);
                        set_fs(old_fs);
                }
                break;

        case IPC_STAT:
        case SHM_STAT:
                if (second & IPC_64) {
                        struct shmid64_ds32 *up = (struct shmid64_ds32 *)uptr;
                        struct shmid64_ds s64;

                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_shmctl(first, second,
                                         (struct shmid_ds *)&s64);
                        set_fs(old_fs);
                        if (err < 0)
                                break;

                        err2 = copy_to_user(&up->shm_perm, &s64.shm_perm,
                                            sizeof(struct ipc64_perm32));
                        err2 |= __put_user(s64.shm_atime, &up->shm_atime);
                        err2 |= __put_user(s64.shm_dtime, &up->shm_dtime);
                        err2 |= __put_user(s64.shm_ctime, &up->shm_ctime);
                        err2 |= __put_user(s64.shm_segsz, &up->shm_segsz);
                        err2 |= __put_user(s64.shm_nattch, &up->shm_nattch);
                        err2 |= __put_user(s64.shm_cpid, &up->shm_cpid);
                        err2 |= __put_user(s64.shm_lpid, &up->shm_lpid);
                        if (err2)
                                err = -EFAULT;
                } else {
                        struct shmid_ds32 *up = (struct shmid_ds32 *)uptr;
                        struct shmid_ds s;

                        old_fs = get_fs();
                        set_fs(KERNEL_DS);
                        err = sys_shmctl(first, second, &s);
                        set_fs(old_fs);
                        if (err < 0)
                                break;

                        err2 = copy_to_user(&up->shm_perm, &s.shm_perm,
                                            sizeof(struct ipc_perm32));
                        err2 |= __put_user (s.shm_atime, &up->shm_atime);
                        err2 |= __put_user (s.shm_dtime, &up->shm_dtime);
                        err2 |= __put_user (s.shm_ctime, &up->shm_ctime);
                        err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
                        err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
                        err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
                        err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
                        if (err2)
                                err = -EFAULT;
                }
                break;

        case SHM_INFO: {
                struct shm_info si;
                struct shm_info32 {