Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/* $Id: sys_sunos32.c,v 1.64 2002/02/09 19:49:31 davem Exp $

 * sys_sunos32.c: SunOS binary compatibility layer on sparc64.

 *

 * Copyright (C) 1995, 1996, 1997 David S. Miller (davem@caip.rutgers.edu)

 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)

 *

 * Based upon preliminary work which is:

 *

 * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu)

 */

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/types.h>

#include <linux/capability.h>

#include <linux/compat.h>

#include <linux/mman.h>

#include <linux/mm.h>

#include <linux/swap.h>

#include <linux/fs.h>

#include <linux/file.h>

#include <linux/resource.h>

#include <linux/ipc.h>

#include <linux/shm.h>

#include <linux/msg.h>

#include <linux/sem.h>

#include <linux/signal.h>

#include <linux/uio.h>

#include <linux/utsname.h>

#include <linux/major.h>

#include <linux/stat.h>

#include <linux/slab.h>

#include <linux/pagemap.h>

#include <linux/errno.h>

#include <linux/smp.h>

#include <linux/smp_lock.h>

#include <linux/syscalls.h>

#include <asm/uaccess.h>

#include <asm/page.h>

#include <asm/pgtable.h>

#include <asm/pconf.h>

#include <asm/idprom.h> /* for gethostid() */

#include <asm/unistd.h>

#include <asm/system.h>

#include <asm/compat_signal.h>

/* For the nfs mount emulation */

#include <linux/socket.h>

#include <linux/in.h>

#include <linux/nfs.h>

#include <linux/nfs2.h>

#include <linux/nfs_mount.h>

/* for sunos_select */

#include <linux/time.h>

#include <linux/personality.h>

/* For SOCKET_I */

#include <net/sock.h>

#include <net/compat.h>

#define SUNOS_NR_OPEN   256

asmlinkage u32 sunos_mmap(u32 addr, u32 len, u32 prot, u32 flags, u32 fd, u32 off)

{

        struct file *file = NULL;

        unsigned long retval, ret_type;

        if (flags & MAP_NORESERVE) {

                static int cnt;

                if (cnt++ < 10)

                        printk("%s:  unimplemented SunOS MAP_NORESERVE mmap() flag\n",

                               current->comm);

                flags &= ~MAP_NORESERVE;

        }

        retval = -EBADF;

        if (!(flags & MAP_ANONYMOUS)) {

                struct inode * inode;

                if (fd >= SUNOS_NR_OPEN)

                        goto out;

                file = fget(fd);

                if (!file)

                        goto out;

                inode = file->f_path.dentry->d_inode;

                if (imajor(inode) == MEM_MAJOR && iminor(inode) == 5) {

                        flags |= MAP_ANONYMOUS;

                        fput(file);

                        file = NULL;

                }

        }

        retval = -EINVAL;

        if (!(flags & MAP_FIXED))

                addr = 0;

        else if (len > 0xf0000000 || addr > 0xf0000000 - len)

                goto out_putf;

        ret_type = flags & _MAP_NEW;

        flags &= ~_MAP_NEW;

        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);

        down_write(&current->mm->mmap_sem);

        retval = do_mmap(file,

                         (unsigned long) addr, (unsigned long) len,

                         (unsigned long) prot, (unsigned long) flags,

                         (unsigned long) off);

        up_write(&current->mm->mmap_sem);

        if (!ret_type)

                retval = ((retval < 0xf0000000) ? 0 : retval);

out_putf:

        if (file)

                fput(file);

out:

        return (u32) retval;

}

asmlinkage int sunos_mctl(u32 addr, u32 len, int function, u32 arg)

{

        return 0;

}

asmlinkage int sunos_brk(u32 baddr)

{

        int freepages, retval = -ENOMEM;

        unsigned long rlim;

        unsigned long newbrk, oldbrk, brk = (unsigned long) baddr;

        down_write(&current->mm->mmap_sem);

        if (brk < current->mm->end_code)

                goto out;

        newbrk = PAGE_ALIGN(brk);

        oldbrk = PAGE_ALIGN(current->mm->brk);

        retval = 0;

        if (oldbrk == newbrk) {

                current->mm->brk = brk;

                goto out;

        }

        /* Always allow shrinking brk. */

        if (brk <= current->mm->brk) {

                current->mm->brk = brk;

                do_munmap(current->mm, newbrk, oldbrk-newbrk);

                goto out;

        }

        /* Check against rlimit and stack.. */

        retval = -ENOMEM;

        rlim = current->signal->rlim[RLIMIT_DATA].rlim_cur;

        if (rlim >= RLIM_INFINITY)

                rlim = ~0;

        if (brk - current->mm->end_code > rlim)

                goto out;

        /* Check against existing mmap mappings. */

        if (find_vma_intersection(current->mm, oldbrk, newbrk+PAGE_SIZE))

                goto out;

        /* stupid algorithm to decide if we have enough memory: while

         * simple, it hopefully works in most obvious cases.. Easy to

         * fool it, but this should catch most mistakes.

         */

        freepages = global_page_state(NR_FILE_PAGES);

        freepages >>= 1;

        freepages += nr_free_pages();

        freepages += nr_swap_pages;

        freepages -= num_physpages >> 4;

        freepages -= (newbrk-oldbrk) >> PAGE_SHIFT;

        if (freepages < 0)

                goto out;

        /* Ok, we have probably got enough memory - let it rip. */

        current->mm->brk = brk;

        do_brk(oldbrk, newbrk-oldbrk);

        retval = 0;

out:

        up_write(&current->mm->mmap_sem);

        return retval;

}

asmlinkage u32 sunos_sbrk(int increment)

{

        int error, oldbrk;

        /* This should do it hopefully... */

        oldbrk = (int)current->mm->brk;

        error = sunos_brk(((int) current->mm->brk) + increment);

        if (!error)

                error = oldbrk;

        return error;

}

asmlinkage u32 sunos_sstk(int increment)

{

        printk("%s: Call to sunos_sstk(increment<%d>) is unsupported\n",

               current->comm, increment);

        return (u32)-1;

}

/* Give hints to the kernel as to what paging strategy to use...

 * Completely bogus, don't remind me.

 */

#define VA_NORMAL     0 /* Normal vm usage expected */

#define VA_ABNORMAL   1 /* Abnormal/random vm usage probable */

#define VA_SEQUENTIAL 2 /* Accesses will be of a sequential nature */

#define VA_INVALIDATE 3 /* Page table entries should be flushed ??? */

static char *vstrings[] = {

        "VA_NORMAL",

        "VA_ABNORMAL",

        "VA_SEQUENTIAL",

        "VA_INVALIDATE",

};

asmlinkage void sunos_vadvise(u32 strategy)

{

        static int count;

        /* I wanna see who uses this... */

        if (count++ < 5)

                printk("%s: Advises us to use %s paging strategy\n",

                       current->comm,

                       strategy <= 3 ? vstrings[strategy] : "BOGUS");

}

/* This just wants the soft limit (ie. rlim_cur element) of the RLIMIT_NOFILE

 * resource limit and is for backwards compatibility with older sunos

 * revs.

 */

asmlinkage int sunos_getdtablesize(void)

{

        return SUNOS_NR_OPEN;

}

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

asmlinkage u32 sunos_sigblock(u32 blk_mask)

{

        u32 old;

        spin_lock_irq(&current->sighand->siglock);

        old = (u32) current->blocked.sig[0];

        current->blocked.sig[0] |= (blk_mask & _BLOCKABLE);

        recalc_sigpending();

        spin_unlock_irq(&current->sighand->siglock);

        return old;

}

asmlinkage u32 sunos_sigsetmask(u32 newmask)

{

        u32 retval;

        spin_lock_irq(&current->sighand->siglock);

        retval = (u32) current->blocked.sig[0];

        current->blocked.sig[0] = (newmask & _BLOCKABLE);

        recalc_sigpending();

        spin_unlock_irq(&current->sighand->siglock);

        return retval;

}

/* SunOS getdents is very similar to the newer Linux (iBCS2 compliant)    */

/* getdents system call, the format of the structure just has a different */

/* layout (d_off+d_ino instead of d_ino+d_off) */

struct sunos_dirent {

    s32         d_off;

    u32         d_ino;

    u16         d_reclen;

    u16         d_namlen;

    char        d_name[1];

};

struct sunos_dirent_callback {

    struct sunos_dirent __user *curr;

    struct sunos_dirent __user *previous;

    int count;

    int error;

};

#define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))

#define ROUND_UP(x) (((x)+sizeof(s32)-1) & ~(sizeof(s32)-1))

static int sunos_filldir(void * __buf, const char * name, int namlen,

                         loff_t offset, ino_t ino, unsigned int d_type)

{

        struct sunos_dirent __user *dirent;

        struct sunos_dirent_callback * buf = (struct sunos_dirent_callback *) __buf;

        int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);

        u32 d_ino;

        buf->error = -EINVAL;   /* only used if we fail.. */

        if (reclen > buf->count)

                return -EINVAL;

        d_ino = ino;

        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)

                return -EOVERFLOW;

        dirent = buf->previous;

        if (dirent)

                put_user(offset, &dirent->d_off);

        dirent = buf->curr;

        buf->previous = dirent;

        put_user(d_ino, &dirent->d_ino);

        put_user(namlen, &dirent->d_namlen);

        put_user(reclen, &dirent->d_reclen);

        if (copy_to_user(dirent->d_name, name, namlen))

                return -EFAULT;

        put_user(0, dirent->d_name + namlen);

        dirent = (void __user *) dirent + reclen;

        buf->curr = dirent;

        buf->count -= reclen;

        return 0;

}

asmlinkage int sunos_getdents(unsigned int fd, void __user *dirent, int cnt)

{

        struct file * file;

        struct sunos_dirent __user *lastdirent;

        struct sunos_dirent_callback buf;

        int error = -EBADF;

        if (fd >= SUNOS_NR_OPEN)

                goto out;

        file = fget(fd);

        if (!file)

                goto out;

        error = -EINVAL;

        if (cnt < (sizeof(struct sunos_dirent) + 255))

                goto out_putf;

        buf.curr = (struct sunos_dirent __user *) dirent;

        buf.previous = NULL;

        buf.count = cnt;

        buf.error = 0;

        error = vfs_readdir(file, sunos_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 = cnt - buf.count;

        }

out_putf:

        fput(file);

out:

        return error;

}

/* Old sunos getdirentries, severely broken compatibility stuff here. */

struct sunos_direntry {

    u32         d_ino;

    u16         d_reclen;

    u16         d_namlen;

    char        d_name[1];

};

struct sunos_direntry_callback {

    struct sunos_direntry __user *curr;

    struct sunos_direntry __user *previous;

    int count;

    int error;

};

static int sunos_filldirentry(void * __buf, const char * name, int namlen,

                              loff_t offset, ino_t ino, unsigned int d_type)

{

        struct sunos_direntry __user *dirent;

        struct sunos_direntry_callback * buf =

                (struct sunos_direntry_callback *) __buf;

        int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);

        u32 d_ino;

        buf->error = -EINVAL;   /* only used if we fail.. */

        if (reclen > buf->count)

                return -EINVAL;

        d_ino = ino;

        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)

                return -EOVERFLOW;

        dirent = buf->previous;

        dirent = buf->curr;

        buf->previous = dirent;

        put_user(d_ino, &dirent->d_ino);

        put_user(namlen, &dirent->d_namlen);

        put_user(reclen, &dirent->d_reclen);

        if (copy_to_user(dirent->d_name, name, namlen))

                return -EFAULT;

        put_user(0, dirent->d_name + namlen);

        dirent = (void __user *) dirent + reclen;

        buf->curr = dirent;

        buf->count -= reclen;

        return 0;

}

asmlinkage int sunos_getdirentries(unsigned int fd,

                                   void __user *dirent,

                                   int cnt,

                                   unsigned int __user *basep)

{

        struct file * file;

        struct sunos_direntry __user *lastdirent;

        int error = -EBADF;

        struct sunos_direntry_callback buf;

        if (fd >= SUNOS_NR_OPEN)

                goto out;

        file = fget(fd);

        if (!file)

                goto out;

        error = -EINVAL;

        if (cnt < (sizeof(struct sunos_direntry) + 255))

                goto out_putf;

        buf.curr = (struct sunos_direntry __user *) dirent;

        buf.previous = NULL;

        buf.count = cnt;

        buf.error = 0;

        error = vfs_readdir(file, sunos_filldirentry, &buf);

        if (error < 0)

                goto out_putf;

        lastdirent = buf.previous;

        error = buf.error;

        if (lastdirent) {

                put_user(file->f_pos, basep);

                error = cnt - buf.count;

        }

out_putf:

        fput(file);

out:

        return error;

}

struct sunos_utsname {

        char sname[9];

        char nname[9];

        char nnext[56];

        char rel[9];

        char ver[9];

        char mach[9];

};

asmlinkage int sunos_uname(struct sunos_utsname __user *name)

{

        int ret;

        down_read(&uts_sem);

        ret = copy_to_user(&name->sname[0], &utsname()->sysname[0],

                           sizeof(name->sname) - 1);

        ret |= copy_to_user(&name->nname[0], &utsname()->nodename[0],

                            sizeof(name->nname) - 1);

        ret |= put_user('\0', &name->nname[8]);

        ret |= copy_to_user(&name->rel[0], &utsname()->release[0],

                            sizeof(name->rel) - 1);

        ret |= copy_to_user(&name->ver[0], &utsname()->version[0],

                            sizeof(name->ver) - 1);

        ret |= copy_to_user(&name->mach[0], &utsname()->machine[0],

                            sizeof(name->mach) - 1);

        up_read(&uts_sem);

        return (ret ? -EFAULT : 0);

}

asmlinkage int sunos_nosys(void)

{

        struct pt_regs *regs;

        siginfo_t info;

        static int cnt;

        regs = current_thread_info()->kregs;

        if (test_thread_flag(TIF_32BIT)) {

                regs->tpc &= 0xffffffff;

                regs->tnpc &= 0xffffffff;

        }

        info.si_signo = SIGSYS;

        info.si_errno = 0;

        info.si_code = __SI_FAULT|0x100;

        info.si_addr = (void __user *)regs->tpc;

        info.si_trapno = regs->u_regs[UREG_G1];

        send_sig_info(SIGSYS, &info, current);

        if (cnt++ < 4) {

                printk("Process makes ni_syscall number %d, register dump:\n",

                       (int) regs->u_regs[UREG_G1]);

                show_regs(regs);

        }

        return -ENOSYS;

}

/* This is not a real and complete implementation yet, just to keep

 * the easy SunOS binaries happy.

 */

asmlinkage int sunos_fpathconf(int fd, int name)

{

        int ret;

        switch(name) {

        case _PCONF_LINK:

                ret = LINK_MAX;

                break;

        case _PCONF_CANON:

                ret = MAX_CANON;

                break;

        case _PCONF_INPUT:

                ret = MAX_INPUT;

                break;

        case _PCONF_NAME:

                ret = NAME_MAX;

                break;

        case _PCONF_PATH:

                ret = PATH_MAX;

                break;

        case _PCONF_PIPE:

                ret = PIPE_BUF;

                break;

        case _PCONF_CHRESTRICT:         /* XXX Investigate XXX */

                ret = 1;

                break;

        case _PCONF_NOTRUNC:            /* XXX Investigate XXX */

        case _PCONF_VDISABLE:

                ret = 0;

                break;

        default:

                ret = -EINVAL;

                break;

        }

        return ret;

}

asmlinkage int sunos_pathconf(u32 u_path, int name)

{

        int ret;

        ret = sunos_fpathconf(0, name); /* XXX cheese XXX */

        return ret;

}

asmlinkage int sunos_select(int width, u32 inp, u32 outp, u32 exp, u32 tvp_x)

{

        int ret;

        /* SunOS binaries expect that select won't change the tvp contents */

        ret = compat_sys_select(width, compat_ptr(inp), compat_ptr(outp),

                                compat_ptr(exp), compat_ptr(tvp_x));

        if (ret == -EINTR && tvp_x) {

                struct compat_timeval __user *tvp = compat_ptr(tvp_x);

                time_t sec, usec;

                __get_user(sec, &tvp->tv_sec);

                __get_user(usec, &tvp->tv_usec);

                if (sec == 0 && usec == 0)

                        ret = 0;

        }

        return ret;

}

asmlinkage void sunos_nop(void)

{

        return;

}

#if 0 /* This code doesn't translate user pointers correctly,

       * disable for now. -DaveM

       */

/* XXXXXXXXXX SunOS mount/umount. XXXXXXXXXXX */

#define SMNT_RDONLY       1

#define SMNT_NOSUID       2

#define SMNT_NEWTYPE      4

#define SMNT_GRPID        8

#define SMNT_REMOUNT      16

#define SMNT_NOSUB        32

#define SMNT_MULTI        64

#define SMNT_SYS5         128

struct sunos_fh_t {

        char fh_data [NFS_FHSIZE];

};

struct sunos_nfs_mount_args {

        struct sockaddr_in  *addr; /* file server address */

        struct nfs_fh *fh;     /* File handle to be mounted */

        int        flags;      /* flags */

        int        wsize;      /* write size in bytes */

        int        rsize;      /* read size in bytes */

        int        timeo;      /* initial timeout in .1 secs */

        int        retrans;    /* times to retry send */

        char       *hostname;  /* server's hostname */

        int        acregmin;   /* attr cache file min secs */

        int        acregmax;   /* attr cache file max secs */

        int        acdirmin;   /* attr cache dir min secs */

        int        acdirmax;   /* attr cache dir max secs */

        char       *netname;   /* server's netname */

};

/* Bind the socket on a local reserved port and connect it to the

 * remote server.  This on Linux/i386 is done by the mount program,

 * not by the kernel.

 */

/* XXXXXXXXXXXXXXXXXXXX */

static int

sunos_nfs_get_server_fd (int fd, struct sockaddr_in *addr)

{

        struct sockaddr_in local;

        struct sockaddr_in server;

        int    try_port;

        int    ret;

        struct socket *socket;

        struct inode  *inode;

        struct file   *file;

        file = fget(fd);

        if (!file)

                return 0;

        inode = file->f_path.dentry->d_inode;

        socket = SOCKET_I(inode);

        local.sin_family = AF_INET;

        local.sin_addr.s_addr = INADDR_ANY;

        /* IPPORT_RESERVED = 1024, can't find the definition in the kernel */

        try_port = 1024;

        do {

                local.sin_port = htons (--try_port);

                ret = socket->ops->bind(socket, (struct sockaddr*)&local,

                                        sizeof(local));

        } while (ret && try_port > (1024 / 2));

        if (ret) {

                fput(file);

                return 0;

        }

        server.sin_family = AF_INET;

        server.sin_addr = addr->sin_addr;

        server.sin_port = NFS_PORT;

        /* Call sys_connect */

        ret = socket->ops->connect (socket, (struct sockaddr *) &server,

                                    sizeof (server), file->f_flags);

        fput(file);

        if (ret < 0)

                return 0;

        return 1;

}

/* XXXXXXXXXXXXXXXXXXXX */

static int get_default (int value, int def_value)

{

    if (value)

        return value;

    else

        return def_value;

}

/* XXXXXXXXXXXXXXXXXXXX */

static int sunos_nfs_mount(char *dir_name, int linux_flags, void __user *data)

{

        int  server_fd, err;

        char *the_name, *mount_page;

        struct nfs_mount_data linux_nfs_mount;

        struct sunos_nfs_mount_args sunos_mount;