/*
 *  linux/fs/open.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/vfs.h>
#include <linux/types.h>
#include <linux/utime.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/tty.h>
#include <linux/time.h>
#include <linux/mm.h>

#include <asm/segment.h>

asmlinkage int sys_statfs(const char * path, struct statfs * buf)
{
        struct inode * inode;
        int error;

        error = verify_area(VERIFY_WRITE, buf, sizeof(struct statfs));
        if (error)
                return error;
        error = namei(path,&inode);
        if (error)
                return error;
        if (!inode->i_sb->s_op->statfs) {
                iput(inode);
                return -ENOSYS;
        }
        inode->i_sb->s_op->statfs(inode->i_sb, buf, sizeof(struct statfs));
        iput(inode);
        return 0;
}

asmlinkage int sys_fstatfs(unsigned int fd, struct statfs * buf)
{
        struct inode * inode;
        struct file * file;
        int error;

        error = verify_area(VERIFY_WRITE, buf, sizeof(struct statfs));
        if (error)
                return error;
        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (!inode->i_sb->s_op->statfs)
                return -ENOSYS;
        inode->i_sb->s_op->statfs(inode->i_sb, buf, sizeof(struct statfs));
        return 0;
}

int do_truncate(struct inode *inode, unsigned long length)
{
        int error;
        struct iattr newattrs;

        down(&inode->i_sem);
        newattrs.ia_size = length;
        newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
        error = notify_change(inode, &newattrs);
        if (!error) {
                /* truncate virtual mappings of this file */
                vmtruncate(inode, length);
                if (inode->i_op && inode->i_op->truncate)
                        inode->i_op->truncate(inode);
        }
        up(&inode->i_sem);
        return error;
}

asmlinkage int sys_truncate(const char * path, unsigned long length)
{
        struct inode * inode;
        int error;

        error = namei(path,&inode);
        if (error)
                return error;

        error = -EACCES;
        if (S_ISDIR(inode->i_mode))
                goto out;

        error = permission(inode,MAY_WRITE);
        if (error)
                goto out;

        error = -EROFS;
        if (IS_RDONLY(inode))
                goto out;

        error = -EPERM;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                goto out;

        error = get_write_access(inode);
        if (error)
                goto out;

        error = locks_verify_area(FLOCK_VERIFY_WRITE, inode, NULL,
                                  length < inode->i_size ? length : inode->i_size,
                                  abs(inode->i_size - length));
        if (!error) {
                if (inode->i_sb && inode->i_sb->dq_op)
                        inode->i_sb->dq_op->initialize(inode, -1);
                error = do_truncate(inode, length);
        }
        put_write_access(inode);
out:
        iput(inode);
        return error;
}

asmlinkage int sys_ftruncate(unsigned int fd, unsigned long length)
{
        struct inode * inode;
        struct file * file;
        int error;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (S_ISDIR(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
                return -EACCES;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
        error = locks_verify_area(FLOCK_VERIFY_WRITE, inode, file,
                                  length < inode->i_size ? length : inode->i_size,
                                  abs(inode->i_size - length));
        if (!error)
                error = do_truncate(inode, length);
        return error;
}

#ifndef __alpha__

/*
 * sys_utime() can be implemented in user-level using sys_utimes().
 * Is this for backwards compatibility?  If so, why not move it
 * into the appropriate arch directory (for those architectures that
 * need it).
 */

/* If times==NULL, set access and modification to current time,
 * must be owner or have write permission.
 * Else, update from *times, must be owner or super user.
 */
asmlinkage int sys_utime(char * filename, struct utimbuf * times)
{
        int error;
        struct inode * inode;
        struct iattr newattrs;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        /* Don't worry, the checks are done in inode_change_ok() */
        newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
        if (times) {
                error = verify_area(VERIFY_READ, times, sizeof(*times));
                if (error) {
                        iput(inode);
                        return error;
                }
                newattrs.ia_atime = get_user(&times->actime);
                newattrs.ia_mtime = get_user(&times->modtime);
                newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
        } else {
                if ((error = permission(inode,MAY_WRITE)) != 0) {
                        iput(inode);
                        return error;
                }
        }
        error = notify_change(inode, &newattrs);
        iput(inode);
        return error;
}

#endif

/* If times==NULL, set access and modification to current time,
 * must be owner or have write permission.
 * Else, update from *times, must be owner or super user.
 */
asmlinkage int sys_utimes(char * filename, struct timeval * utimes)
{
        int error;
        struct inode * inode;
        struct iattr newattrs;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        /* Don't worry, the checks are done in inode_change_ok() */
        newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
        if (utimes) {
                struct timeval times[2];
                error = verify_area(VERIFY_READ, utimes, sizeof(times));
                if (error) {
                        iput(inode);
                        return error;
                }
                memcpy_fromfs(&times, utimes, sizeof(times));
                newattrs.ia_atime = times[0].tv_sec;
                newattrs.ia_mtime = times[1].tv_sec;
                newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
        } else {
                if ((error = permission(inode,MAY_WRITE)) != 0) {
                        iput(inode);
                        return error;
                }
        }
        error = notify_change(inode, &newattrs);
        iput(inode);
        return error;
}

/*
 * access() needs to use the real uid/gid, not the effective uid/gid.
 * We do this by temporarily setting fsuid/fsgid to the wanted values
 */
asmlinkage int sys_access(const char * filename, int mode)
{
        struct inode * inode;
        int old_fsuid, old_fsgid;
        int res;

        if (mode != (mode & S_IRWXO))   /* where's F_OK, X_OK, W_OK, R_OK? */
                return -EINVAL;
        old_fsuid = current->fsuid;
        old_fsgid = current->fsgid;
        current->fsuid = current->uid;
        current->fsgid = current->gid;
        res = namei(filename,&inode);
        if (!res) {
                res = permission(inode, mode);
                iput(inode);
        }
        current->fsuid = old_fsuid;
        current->fsgid = old_fsgid;
        return res;
}

asmlinkage int sys_chdir(const char * filename)
{
        struct inode * inode;
        int error;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (!S_ISDIR(inode->i_mode)) {
                iput(inode);
                return -ENOTDIR;
        }
        if ((error = permission(inode,MAY_EXEC)) != 0) {
                iput(inode);
                return error;
        }
        iput(current->fs->pwd);
        current->fs->pwd = inode;
        return (0);
}

asmlinkage int sys_fchdir(unsigned int fd)
{
        struct inode * inode;
        struct file * file;
        int error;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (!S_ISDIR(inode->i_mode))
                return -ENOTDIR;
        if ((error = permission(inode,MAY_EXEC)) != 0)
                return error;
        iput(current->fs->pwd);
        current->fs->pwd = inode;
        inode->i_count++;
        return (0);
}

asmlinkage int sys_chroot(const char * filename)
{
        struct inode * inode;
        int error;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (!S_ISDIR(inode->i_mode)) {
                iput(inode);
                return -ENOTDIR;
        }
        if (!fsuser()) {
                iput(inode);
                return -EPERM;
        }
        iput(current->fs->root);
        current->fs->root = inode;
        return (0);
}

asmlinkage int sys_fchmod(unsigned int fd, mode_t mode)
{
        struct inode * inode;
        struct file * file;
        struct iattr newattrs;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (IS_RDONLY(inode))
                return -EROFS;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
        if (mode == (mode_t) -1)
                mode = inode->i_mode;
        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
        inode->i_dirt = 1;
        return notify_change(inode, &newattrs);
}

asmlinkage int sys_chmod(const char * filename, mode_t mode)
{
        struct inode * inode;
        int error;
        struct iattr newattrs;

        error = namei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
                iput(inode);
                return -EPERM;
        }
        if (mode == (mode_t) -1)
                mode = inode->i_mode;
        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
        inode->i_dirt = 1;
        error = notify_change(inode, &newattrs);
        iput(inode);
        return error;
}

asmlinkage int sys_fchown(unsigned int fd, uid_t user, gid_t group)
{
        struct inode * inode;
        struct file * file;
        struct iattr newattrs;
        int error;

        if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
                return -EBADF;
        if (!(inode = file->f_inode))
                return -ENOENT;
        if (IS_RDONLY(inode))
                return -EROFS;
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                return -EPERM;
        if (user == (uid_t) -1)
                user = inode->i_uid;
        if (group == (gid_t) -1)
                group = inode->i_gid;
        newattrs.ia_mode = inode->i_mode;
        newattrs.ia_uid = user;
        newattrs.ia_gid = group;
        newattrs.ia_valid =  ATTR_UID | ATTR_GID | ATTR_CTIME;
        /*
         * If the owner has been changed, remove the setuid bit
         */
        if (user != inode->i_uid && (inode->i_mode & S_ISUID)) {
                newattrs.ia_mode &= ~S_ISUID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        /*
         * If the group has been changed, remove the setgid bit
         *
         * Don't remove the setgid bit if no group execute bit.
         * This is a file marked for mandatory locking.
         */
        if (group != inode->i_gid &&
            ((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))) {
                newattrs.ia_mode &= ~S_ISGID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        inode->i_dirt = 1;
        if (inode->i_sb && inode->i_sb->dq_op) {
                inode->i_sb->dq_op->initialize(inode, -1);
                if (inode->i_sb->dq_op->transfer(inode, &newattrs, 0))
                        return -EDQUOT;
                error = notify_change(inode, &newattrs);
                if (error)
                        inode->i_sb->dq_op->transfer(inode, &newattrs, 1);
        } else
                error = notify_change(inode, &newattrs);
        return error;
}

asmlinkage int sys_chown(const char * filename, uid_t user, gid_t group)
{
        struct inode * inode;
        int error;
        struct iattr newattrs;

        error = lnamei(filename,&inode);
        if (error)
                return error;
        if (IS_RDONLY(inode)) {
                iput(inode);
                return -EROFS;
        }
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
                iput(inode);
                return -EPERM;
        }
        if (user == (uid_t) -1)
                user = inode->i_uid;
        if (group == (gid_t) -1)
                group = inode->i_gid;
        newattrs.ia_mode = inode->i_mode;
        newattrs.ia_uid = user;
        newattrs.ia_gid = group;
        newattrs.ia_valid =  ATTR_UID | ATTR_GID | ATTR_CTIME;
        /*
         * If the owner has been changed, remove the setuid bit
         */
        if (user != inode->i_uid && (inode->i_mode & S_ISUID)) {
                newattrs.ia_mode &= ~S_ISUID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        /*
         * If the group has been changed, remove the setgid bit
         *
         * Don't remove the setgid bit if no group execute bit.
         * This is a file marked for mandatory locking.
         */
        if (group != inode->i_gid &&
            ((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))) {
                newattrs.ia_mode &= ~S_ISGID;
                newattrs.ia_valid |= ATTR_MODE;
        }
        inode->i_dirt = 1;
        if (inode->i_sb->dq_op) {
                inode->i_sb->dq_op->initialize(inode, -1);
                if (inode->i_sb->dq_op->transfer(inode, &newattrs, 0))
                        return -EDQUOT;
                error = notify_change(inode, &newattrs);
                if (error)
                        inode->i_sb->dq_op->transfer(inode, &newattrs, 1);
        } else
                error = notify_change(inode, &newattrs);
        iput(inode);
        return(error);
}

/*
 * Note that while the flag value (low two bits) for sys_open means:
 *      00 - read-only
 *      01 - write-only
 *      10 - read-write
 *      11 - special
 * it is changed into
 *      00 - no permissions needed
 *      01 - read-permission
 *      10 - write-permission
 *      11 - read-write
 * for the internal routines (ie open_namei()/follow_link() etc). 00 is
 * used by symlinks.
 */
int do_open(const char * filename,int flags,int mode)
{
        struct inode * inode;
        struct file * f;
        int flag,error,fd;

        f = get_empty_filp();
        if (!f)
                return -ENFILE;
        f->f_flags = flag = flags;
        f->f_mode = (flag+1) & O_ACCMODE;
        if (f->f_mode)
                flag++;
        if (flag & (O_TRUNC | O_CREAT))
                flag |= 2;
        error = open_namei(filename,flag,mode,&inode,NULL);
        if (error)
                goto cleanup_file;
        if (f->f_mode & FMODE_WRITE) {
                error = get_write_access(inode);
                if (error)
                        goto cleanup_inode;
        }

        f->f_inode = inode;
        f->f_pos = 0;
        f->f_reada = 0;
        f->f_op = NULL;
        if (inode->i_op)
                f->f_op = inode->i_op->default_file_ops;
        if (f->f_op && f->f_op->open) {
                error = f->f_op->open(inode,f);
                if (error)
                        goto cleanup_all;
        }
        f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);

        /*
         * We have to do this last, because we mustn't export
         * an incomplete fd to other processes which may share
         * the same file table with us.
         */
        for(fd = 0; fd < NR_OPEN && fd < current->rlim[RLIMIT_NOFILE].rlim_cur; fd++) {
                if (!current->files->fd[fd]) {
                        current->files->fd[fd] = f;
                        FD_CLR(fd,&current->files->close_on_exec);
                        return fd;
                }
        }
        error = -EMFILE;
        if (f->f_op && f->f_op->release)
                f->f_op->release(inode,f);
cleanup_all:
        if (f->f_mode & FMODE_WRITE)
                put_write_access(inode);
cleanup_inode:
        iput(inode);
cleanup_file:
        f->f_count--;
        return error;
}

asmlinkage int sys_open(const char * filename,int flags,int mode)
{
        char * tmp;
        int error;

        error = getname(filename, &tmp);
        if (error)
                return error;
        error = do_open(tmp,flags,mode);
        putname(tmp);
        return error;
}

#ifndef __alpha__

/*
 * For backward compatibility?  Maybe this should be moved
 * into arch/i386 instead?
 */
asmlinkage int sys_creat(const char * pathname, int mode)
{
        return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
}

#endif

int close_fp(struct file *filp)
{
        struct inode *inode;

        if (filp->f_count == 0) {
                printk("VFS: Close: file count is 0\n");
                return 0;
        }
        inode = filp->f_inode;
        if (inode)
                locks_remove_locks(current, filp);
        if (filp->f_count > 1) {
                filp->f_count--;
                return 0;
        }
        if (filp->f_op && filp->f_op->release)
                filp->f_op->release(inode,filp);
        filp->f_count--;
        filp->f_inode = NULL;
        if (filp->f_mode & FMODE_WRITE)
                put_write_access(inode);
        iput(inode);
        return 0;
}

asmlinkage int sys_close(unsigned int fd)
{      
        struct file * filp;

        if (fd >= NR_OPEN)
                return -EBADF;
        FD_CLR(fd, &current->files->close_on_exec);
        if (!(filp = current->files->fd[fd]))
                return -EBADF;
        current->files->fd[fd] = NULL;
        return (close_fp (filp));
}

/*
 * This routine simulates a hangup on the tty, to arrange that users
 * are given clean terminals at login time.
 */
asmlinkage int sys_vhangup(void)
{
        if (!suser())
                return -EPERM;
        /* If there is a controlling tty, hang it up */
        if (current->tty)
                tty_vhangup(current->tty);
        return 0;
}