Subversion Repositories or1k

/*

 * linux/arch/parisc/kernel/sys_hpux.c

 *

 * implements HPUX syscalls.

 */

#include <linux/mm.h>

#include <linux/sched.h>

#include <linux/file.h>

#include <linux/smp_lock.h>

#include <linux/slab.h>

#include <asm/errno.h>

#include <asm/uaccess.h>

int hpux_execve(struct pt_regs *regs)

{

        int error;

        char *filename;

        filename = getname((char *) regs->gr[26]);

        error = PTR_ERR(filename);

        if (IS_ERR(filename))

                goto out;

        error = do_execve(filename, (char **) regs->gr[25],

                (char **)regs->gr[24], regs);

        if (error == 0)

                current->ptrace &= ~PT_DTRACE;

        putname(filename);

out:

        return error;

}

struct hpux_dirent {

        long    d_off_pad; /* we only have a 32-bit off_t */

        long    d_off;

        ino_t   d_ino;

        short   d_reclen;

        short   d_namlen;

        char    d_name[1];

};

struct getdents_callback {

        struct hpux_dirent *current_dir;

        struct hpux_dirent *previous;

        int count;

        int error;

};

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

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

static int filldir(void * __buf, const char * name, int namlen, loff_t offset,

                ino_t ino, unsigned int d_type)

{

        struct hpux_dirent * dirent;

        struct getdents_callback * buf = (struct getdents_callback *) __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);

        put_user(namlen, &dirent->d_namlen);

        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;

}

#undef NAME_OFFSET

#undef ROUND_UP

int hpux_getdents(unsigned int fd, struct hpux_dirent *dirent, unsigned int count)

{

        struct file * file;

        struct hpux_dirent * lastdirent;

        struct getdents_callback buf;

        int error;

        error = -EBADF;

        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, &buf);

        if (error < 0)

                goto out_putf;

        error = buf.error;

        lastdirent = buf.previous;

        if (lastdirent) {

                put_user(file->f_pos, &lastdirent->d_off);

                error = count - buf.count;

        }

out_putf:

        fput(file);

out:

        return error;

}

int hpux_mount(const char *fs, const char *path, int mflag,

                const char *fstype, const char *dataptr, int datalen)

{

        return -ENOSYS;

}

static int cp_hpux_stat(struct inode * inode, struct hpux_stat64 * statbuf)

{

        struct hpux_stat64 tmp;

        unsigned int blocks, indirect;

        memset(&tmp, 0, sizeof(tmp));

        tmp.st_dev = kdev_t_to_nr(inode->i_dev);

        tmp.st_ino = inode->i_ino;

        tmp.st_mode = inode->i_mode;

        tmp.st_nlink = inode->i_nlink;

        tmp.st_uid = inode->i_uid;

        tmp.st_gid = inode->i_gid;

        tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);

        tmp.st_size = inode->i_size;

        tmp.st_atime = inode->i_atime;

        tmp.st_mtime = inode->i_mtime;

        tmp.st_ctime = inode->i_ctime;

#define D_B   7

#define I_B   (BLOCK_SIZE / sizeof(unsigned short))

        if (!inode->i_blksize) {

                blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE;

                if (blocks > D_B) {

                        indirect = (blocks - D_B + I_B - 1) / I_B;

                        blocks += indirect;

                        if (indirect > 1) {

                                indirect = (indirect - 1 + I_B - 1) / I_B;

                                blocks += indirect;

                                if (indirect > 1)

                                        blocks++;

                        }

                }

                tmp.st_blocks = (BLOCK_SIZE / 512) * blocks;

                tmp.st_blksize = BLOCK_SIZE;

        } else {

                tmp.st_blocks = inode->i_blocks;

                tmp.st_blksize = inode->i_blksize;

        }

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

}

/*

 * Revalidate the inode. This is required for proper NFS attribute caching.

 * Blatently copied wholesale from fs/stat.c

 */

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;

}

long hpux_stat64(const char *path, struct hpux_stat64 *buf)

{

        struct nameidata nd;

        int error;

        lock_kernel();

        error = user_path_walk(path, &nd);

        if (!error) {

                error = do_revalidate(nd.dentry);

                if (!error)

                        error = cp_hpux_stat(nd.dentry->d_inode, buf);

                path_release(&nd);

        }

        unlock_kernel();

        return error;

}

long hpux_fstat64(unsigned int fd, struct hpux_stat64 *statbuf)

{

        struct file * f;

        int err = -EBADF;

        lock_kernel();

        f = fget(fd);

        if (f) {

                struct dentry * dentry = f->f_dentry;

                err = do_revalidate(dentry);

                if (!err)

                        err = cp_hpux_stat(dentry->d_inode, statbuf);

                fput(f);

        }

        unlock_kernel();

        return err;

}

long hpux_lstat64(char *filename, struct hpux_stat64 *statbuf)

{

        struct nameidata nd;

        int error;

        lock_kernel();

        error = user_path_walk_link(filename, &nd);

        if (!error) {

                error = do_revalidate(nd.dentry);

                if (!error)

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

                path_release(&nd);

        }

        unlock_kernel();

        return error;

}