/*      $NetBSD: v7fs_vnops.c,v 1.38 2022/07/31 13:08:19 mlelstv Exp $  */

/*-
* Copyright (c) 2004, 2011 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by UCHIYAMA Yasushi.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: v7fs_vnops.c,v 1.38 2022/07/31 13:08:19 mlelstv Exp $");
#if defined _KERNEL_OPT
#include "opt_v7fs.h"
#endif

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/resource.h>
#include <sys/vnode.h>
#include <sys/namei.h>
#include <sys/dirent.h>
#include <sys/kmem.h>
#include <sys/lockf.h>
#include <sys/unistd.h>
#include <sys/fcntl.h>
#include <sys/kauth.h>
#include <sys/buf.h>
#include <sys/stat.h>   /*APPEND */
#include <miscfs/genfs/genfs.h>

#include <fs/v7fs/v7fs.h>
#include <fs/v7fs/v7fs_impl.h>
#include <fs/v7fs/v7fs_inode.h>
#include <fs/v7fs/v7fs_dirent.h>
#include <fs/v7fs/v7fs_file.h>
#include <fs/v7fs/v7fs_datablock.h>
#include <fs/v7fs/v7fs_extern.h>

#ifdef V7FS_VNOPS_DEBUG
#define DPRINTF(fmt, args...)   printf("%s: " fmt, __func__, ##args)
#else
#define DPRINTF(arg...)         ((void)0)
#endif

static v7fs_mode_t vtype_to_v7fs_mode(enum vtype);
static uint8_t v7fs_mode_to_d_type(v7fs_mode_t);

static v7fs_mode_t
vtype_to_v7fs_mode(enum vtype type)
{
       /* Convert Vnode types to V7FS types (sys/vnode.h)*/
       v7fs_mode_t table[] = { 0, V7FS_IFREG, V7FS_IFDIR, V7FS_IFBLK,
                               V7FS_IFCHR, V7FSBSD_IFLNK, V7FSBSD_IFSOCK,
                               V7FSBSD_IFFIFO };
       return table[type];
}

static uint8_t
v7fs_mode_to_d_type(v7fs_mode_t mode)
{
       /* Convert V7FS types to dirent d_type (sys/dirent.h)*/

       return (mode & V7FS_IFMT) >> 12;
}

int
v7fs_lookup(void *v)
{
       struct vop_lookup_v2_args /* {
                                 struct vnode *a_dvp;
                                 struct vnode **a_vpp;
                                 struct componentname *a_cnp;
                                 } */ *a = v;
       struct vnode *dvp = a->a_dvp;
       struct v7fs_node *parent_node = dvp->v_data;
       struct v7fs_inode *parent = &parent_node->inode;
       struct v7fs_self *fs = parent_node->v7fsmount->core;/* my filesystem */
       struct vnode *vpp;
       struct componentname *cnp = a->a_cnp;
       int nameiop = cnp->cn_nameiop;
       const char *name = cnp->cn_nameptr;
       int namelen = cnp->cn_namelen;
       int flags = cnp->cn_flags;
       bool isdotdot = flags & ISDOTDOT;
       bool islastcn = flags & ISLASTCN;
       v7fs_ino_t ino;
       int error;
#ifdef V7FS_VNOPS_DEBUG
       const char *opname[] = { "LOOKUP", "CREATE", "DELETE", "RENAME" };
#endif
       DPRINTF("'%.*s' op=%s flags=%d parent=%d %o %dbyte\n", namelen, name,
           opname[nameiop], cnp->cn_flags, parent->inode_number, parent->mode,
           parent->filesize);

       *a->a_vpp = 0;

       /* Check directory permission for search */
       if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred))) {
               DPRINTF("***perm.\n");
               return error;
       }

       /* Deny last component write operation on a read-only mount */
       if (islastcn && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
           (nameiop == DELETE || nameiop == RENAME)) {
               DPRINTF("***ROFS.\n");
               return EROFS;
       }

       /* No lookup on removed directory */
       if (v7fs_inode_nlink(parent) == 0)
               return ENOENT;

       /* "." */
       if (namelen == 1 && name[0] == '.') {
               if ((nameiop == RENAME) && islastcn) {
                       return EISDIR; /* t_vnops rename_dir(3) */
               }
               vref(dvp); /* usecount++ */
               *a->a_vpp = dvp;
               DPRINTF("done.(.)\n");
               return 0;
       }

       /* ".." and regular file. */
       if ((error = v7fs_file_lookup_by_name(fs, parent, name, namelen,
           &ino))) {
               /* Not found. Tell this entry be able to allocate. */
               if (((nameiop == CREATE) || (nameiop == RENAME)) && islastcn) {
                       /* Check directory permission to allocate. */
                       if ((error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred))) {
                               DPRINTF("access denied. (%.*s)\n",
                                   namelen, name);
                               return error;
                       }
                       DPRINTF("EJUSTRETURN op=%d (%.*s)\n", nameiop, namelen,
                           name);
                       return EJUSTRETURN;
               }
               DPRINTF("lastcn=%d\n", flags & ISLASTCN);
               return error;
       }

       if ((nameiop == DELETE) && islastcn) {
               if ((error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred))) {
                       DPRINTF("access denied. (%.*s)\n", namelen, name);
                       return error;
               }
       }

       /* Entry found. Allocate v-node */
       // Check permissions?
       vpp = 0;
       if (isdotdot) {
               VOP_UNLOCK(dvp); /* preserve reference count. (not vput) */
       }
       DPRINTF("enter vget\n");
       error = v7fs_vget(dvp->v_mount, ino, LK_EXCLUSIVE, &vpp);
       if (error != 0) {
               DPRINTF("***can't get vnode.\n");
               return error;
       }
       DPRINTF("exit vget\n");
       if (isdotdot) {
               vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
       }
       if (vpp != dvp)
               VOP_UNLOCK(vpp);
       *a->a_vpp = vpp;
       DPRINTF("done.(%.*s)\n", namelen, name);

       return 0;
}

int
v7fs_create(void *v)
{
       struct vop_create_v3_args /* {
                                 struct vnode *a_dvp;
                                 struct vnode **a_vpp;
                                 struct componentname *a_cnp;
                                 struct vattr *a_vap;
                                 } */ *a = v;
       struct v7fs_node *parent_node = a->a_dvp->v_data;
       struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
       struct v7fs_self *fs = v7fsmount->core;
       struct mount *mp = v7fsmount->mountp;
       struct v7fs_fileattr attr;
       struct vattr *va = a->a_vap;
       kauth_cred_t cr = a->a_cnp->cn_cred;
       v7fs_ino_t ino;
       int error = 0;

       DPRINTF("%.*s parent#%d\n", (int)a->a_cnp->cn_namelen,
           a->a_cnp->cn_nameptr, parent_node->inode.inode_number);
       KDASSERT((va->va_type == VREG) || (va->va_type == VSOCK));

       memset(&attr, 0, sizeof(attr));
       attr.uid = kauth_cred_geteuid(cr);
       attr.gid = kauth_cred_getegid(cr);
       attr.mode = va->va_mode | vtype_to_v7fs_mode (va->va_type);
       attr.device = 0;

       /* Allocate disk entry. and register its entry to parent directory. */
       if ((error = v7fs_file_allocate(fs, &parent_node->inode,
                   a->a_cnp->cn_nameptr, a->a_cnp->cn_namelen, &attr, &ino))) {
               DPRINTF("v7fs_file_allocate failed.\n");
               return error;
       }
       /* Sync dirent size change. */
       uvm_vnp_setsize(a->a_dvp, v7fs_inode_filesize(&parent_node->inode));

       /* Get myself vnode. */
       *a->a_vpp = 0;
       error = v7fs_vget(mp, ino, LK_EXCLUSIVE, a->a_vpp);
       if (error != 0) {
               DPRINTF("v7fs_vget failed.\n");
               return error;
       }

       /* Scheduling update time. real update by v7fs_update */
       struct v7fs_node *newnode = (*a->a_vpp)->v_data;
       newnode->update_ctime = true;
       newnode->update_mtime = true;
       newnode->update_atime = true;
       DPRINTF("allocated %s->#%d\n", a->a_cnp->cn_nameptr, ino);

       if (error == 0)
               VOP_UNLOCK(*a->a_vpp);

       return error;
}

int
v7fs_mknod(void *v)
{
       struct vop_mknod_v3_args /* {
                                struct vnode           *a_dvp;
                                struct vnode           **a_vpp;
                                struct componentname   *a_cnp;
                                struct vattr           *a_vap;
                                } */ *a = v;
       struct componentname *cnp = a->a_cnp;
       kauth_cred_t cr = cnp->cn_cred;
       struct vnode *dvp = a->a_dvp;
       struct vattr *va = a->a_vap;
       struct v7fs_node *parent_node = dvp->v_data;
       struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
       struct v7fs_self *fs = v7fsmount->core;
       struct mount *mp = v7fsmount->mountp;
       struct v7fs_fileattr attr;

       v7fs_ino_t ino;
       int error = 0;

       DPRINTF("%.*s %06o %lx %d\n", (int)cnp->cn_namelen, cnp->cn_nameptr,
           va->va_mode, (long)va->va_rdev, va->va_type);
       memset(&attr, 0, sizeof(attr));
       attr.uid = kauth_cred_geteuid(cr);
       attr.gid = kauth_cred_getegid(cr);
       attr.mode = va->va_mode | vtype_to_v7fs_mode(va->va_type);
       attr.device = va->va_rdev;

       if ((error = v7fs_file_allocate(fs, &parent_node->inode,
           cnp->cn_nameptr, cnp->cn_namelen, &attr, &ino)))
               return error;
       /* Sync dirent size change. */
       uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));

       error = v7fs_vget(mp, ino, LK_EXCLUSIVE, a->a_vpp);
       if (error != 0) {
               DPRINTF("can't get vnode.\n");
               return error;
       }
       struct v7fs_node *newnode = (*a->a_vpp)->v_data;
       newnode->update_ctime = true;
       newnode->update_mtime = true;
       newnode->update_atime = true;

       if (error == 0)
               VOP_UNLOCK(*a->a_vpp);

       return error;
}

int
v7fs_open(void *v)
{
       struct vop_open_args /* {
                               struct vnode *a_vp;
                               int  a_mode;
                               kauth_cred_t a_cred;
                               } */ *a = v;

       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;

       DPRINTF("inode %d\n", inode->inode_number);
       /* Append mode file pointer is managed by kernel. */
       if (inode->append_mode &&
           ((a->a_mode & (FWRITE | O_APPEND)) == FWRITE)) {
               DPRINTF("file is already opened by append mode.\n");
               return EPERM;
       }

       return 0;
}

int
v7fs_close(void *v)
{
       struct vop_close_args /* {
                                struct vnodeop_desc *a_desc;
                                struct vnode *a_vp;
                                int  a_fflag;
                                kauth_cred_t a_cred;
                                } */ *a = v;
       struct vnode *vp = a->a_vp;
#ifdef V7FS_VNOPS_DEBUG
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
#endif
       DPRINTF("#%d (i)%dbyte (v)%zubyte\n", inode->inode_number,
           v7fs_inode_filesize(inode), vp->v_size);

       /* Update timestamp */
       v7fs_update(vp, 0, 0, UPDATE_WAIT);

       return 0;
}

static int
v7fs_check_possible(struct vnode *vp, struct v7fs_node *v7node,
   mode_t mode)
{

       if (!(mode & VWRITE))
         return 0;

       switch (vp->v_type) {
       default:
               /*  special file is always writable. */
               return 0;
       case VDIR:
       case VLNK:
       case VREG:
               break;
       }

       return vp->v_mount->mnt_flag & MNT_RDONLY ? EROFS : 0;
}

static int
v7fs_check_permitted(struct vnode *vp, struct v7fs_node *v7node,
   accmode_t accmode, kauth_cred_t cred)
{

       struct v7fs_inode *inode = &v7node->inode;

       return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode,
           vp->v_type, inode->mode), vp, NULL, genfs_can_access(vp, cred,
           inode->uid, inode->gid, inode->mode, NULL, accmode));
}

int
v7fs_access(void *v)
{
       struct vop_access_args /* {
               struct vnode    *a_vp;
               accmode_t       a_accmode;
               kauth_cred_t    a_cred;
       } */ *ap = v;
       struct vnode *vp = ap->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       int error;

       error = v7fs_check_possible(vp, v7node, ap->a_accmode);
       if (error)
               return error;

       error = v7fs_check_permitted(vp, v7node, ap->a_accmode, ap->a_cred);

       return error;
}

int
v7fs_getattr(void *v)
{
       struct vop_getattr_args /* {
                                  struct vnode *a_vp;
                                  struct vattr *a_vap;
                                  kauth_cred_t a_cred;
                                  } */ *ap = v;
       struct vnode *vp = ap->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
       struct v7fs_mount *v7fsmount = v7node->v7fsmount;
       struct vattr *vap = ap->a_vap;

       DPRINTF("\n");
       vap->va_type = vp->v_type;
       vap->va_mode = inode->mode;
       vap->va_nlink = inode->nlink;
       vap->va_uid = inode->uid;
       vap->va_gid = inode->gid;
       vap->va_fsid = v7fsmount->devvp->v_rdev;
       vap->va_fileid = inode->inode_number;
       vap->va_size = vp->v_size;
       if (vp->v_type == VLNK) {
               /* Adjust for trailing NUL. */
               KASSERT(vap->va_size > 0);
               vap->va_size -= 1;
       }
       vap->va_atime.tv_sec = inode->atime;
       vap->va_mtime.tv_sec = inode->mtime;
       vap->va_ctime.tv_sec = inode->ctime;
       vap->va_birthtime.tv_sec = 0;
       vap->va_gen = 1;
       vap->va_flags = inode->append_mode ? SF_APPEND : 0;
       vap->va_rdev = inode->device;
       vap->va_bytes = vap->va_size; /* No sparse support. */
       vap->va_filerev = 0;
       vap->va_vaflags = 0;
       /* PAGE_SIZE is larger than sizeof(struct dirent). OK.
          getcwd_scandir()@vfs_getcwd.c */
       vap->va_blocksize = PAGE_SIZE;

       return 0;
}

int
v7fs_setattr(void *v)
{
       struct vop_setattr_args /* {
                                  struct vnode *a_vp;
                                  struct vattr *a_vap;
                                  kauth_cred_t a_cred;
                                  struct proc *p;
                                  } */ *ap = v;
       struct vnode *vp = ap->a_vp;
       struct vattr *vap = ap->a_vap;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       struct v7fs_inode *inode = &v7node->inode;
       kauth_cred_t cred = ap->a_cred;
       struct timespec *acc, *mod;
       int error = 0;
       acc = mod = NULL;

       DPRINTF("\n");

       if (vp->v_mount->mnt_flag & MNT_RDONLY) {
               switch (vp->v_type) {
               default:
                       /*  special file is always writable. */
                       break;
               case VDIR:
               case VLNK:
               case VREG:
                       DPRINTF("read-only mount\n");
                       return EROFS;
               }
       }

       if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
           (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
           (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
           ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
               DPRINTF("invalid request\n");
               return EINVAL;
       }
       /* File pointer mode. */
       if (vap->va_flags != VNOVAL) {
               error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_FLAGS,
                   vp, NULL, genfs_can_chflags(vp, cred, inode->uid,
                   false));
               if (error)
                       return error;
               inode->append_mode = vap->va_flags & SF_APPEND;
       }

       /* File size change. */
       if ((vap->va_size != VNOVAL) && (vp->v_type == VREG)) {
               error = v7fs_datablock_size_change(fs, vap->va_size, inode);
               if (error == 0) {
                       uvm_vnp_setsize(vp, vap->va_size);
                       v7node->update_mtime = true;
                       v7node->update_ctime = true;
               }
       }
       uid_t uid = inode->uid;
       gid_t gid = inode->gid;

       if (vap->va_uid != (uid_t)VNOVAL) {
               uid = vap->va_uid;
               error = kauth_authorize_vnode(cred,
                   KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
                   genfs_can_chown(vp, cred, inode->uid, inode->gid, uid,
                   gid));
               if (error)
                       return error;
               inode->uid = uid;
       }
       if (vap->va_gid != (uid_t)VNOVAL) {
               gid = vap->va_gid;
               error = kauth_authorize_vnode(cred,
                   KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
                   genfs_can_chown(vp, cred, inode->uid, inode->gid, uid,
                   gid));
               if (error)
                       return error;
               inode->gid = gid;
       }
       if (vap->va_mode != (mode_t)VNOVAL) {
               mode_t mode = vap->va_mode;
               error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY,
                   vp, NULL, genfs_can_chmod(vp, cred, inode->uid, inode->gid,
                   mode));
               if (error) {
                       return error;
               }
               v7fs_inode_chmod(inode, mode);
       }
       if ((vap->va_atime.tv_sec != VNOVAL) ||
           (vap->va_mtime.tv_sec != VNOVAL) ||
           (vap->va_ctime.tv_sec != VNOVAL)) {
               error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
                   NULL, genfs_can_chtimes(vp, cred, inode->uid,
                   vap->va_vaflags));
               if (error)
                       return error;

               if (vap->va_atime.tv_sec != VNOVAL) {
                       acc = &vap->va_atime;
               }
               if (vap->va_mtime.tv_sec != VNOVAL) {
                       mod = &vap->va_mtime;
                       v7node->update_mtime = true;
               }
               if (vap->va_ctime.tv_sec != VNOVAL) {
                       v7node->update_ctime = true;
               }
       }

       v7node->update_atime = true;
       v7fs_update(vp, acc, mod, 0);

       return error;
}

int
v7fs_read(void *v)
{
       struct vop_read_args /* {
                               struct vnode *a_vp;
                               struct uio *a_uio;
                               int a_ioflag;
                               kauth_cred_t a_cred;
                               } */ *a = v;
       struct vnode *vp = a->a_vp;
       struct uio *uio = a->a_uio;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
       vsize_t sz, filesz = v7fs_inode_filesize(inode);
       const int advice = IO_ADV_DECODE(a->a_ioflag);
       int error = 0;

       DPRINTF("type=%d inode=%d\n", vp->v_type, v7node->inode.inode_number);

       while (uio->uio_resid > 0) {
               if ((sz = MIN(filesz - uio->uio_offset, uio->uio_resid)) == 0)
                       break;

               error = ubc_uiomove(&vp->v_uobj, uio, sz, advice, UBC_READ |
                   UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
               if (error) {
                       break;
               }
               DPRINTF("read %zubyte\n", sz);
       }
       v7node->update_atime = true;

       return error;
}

int
v7fs_write(void *v)
{
       struct vop_write_args /* {
                                struct vnode *a_vp;
                                struct uio *a_uio;
                                int  a_ioflag;
                                kauth_cred_t a_cred;
                                } */ *a = v;
       struct vnode *vp = a->a_vp;
       struct uio *uio = a->a_uio;
       int advice = IO_ADV_DECODE(a->a_ioflag);
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       vsize_t sz;
       int error = 0;

       if (uio->uio_resid == 0)
               return 0;

       sz = v7fs_inode_filesize(inode);
       DPRINTF("(i)%ld (v)%zu ofs=%zu + res=%zu = %zu\n", sz, vp->v_size,
           uio->uio_offset, uio->uio_resid, uio->uio_offset + uio->uio_resid);

       /* Append mode file offset is managed by kernel. */
       if (a->a_ioflag & IO_APPEND)
               uio->uio_offset = sz;

       /* If write region is over filesize, expand. */
       size_t newsize= uio->uio_offset + uio->uio_resid;
       ssize_t expand = newsize - sz;
       if (expand > 0) {
               if ((error = v7fs_datablock_expand(fs, inode, expand)))
                       return error;
               uvm_vnp_setsize(vp, newsize);
       }

       while (uio->uio_resid > 0) {
               sz = uio->uio_resid;
               if ((error = ubc_uiomove(&vp->v_uobj, uio, sz, advice,
                           UBC_WRITE | UBC_VNODE_FLAGS(vp))))
                       break;
               DPRINTF("write %zubyte\n", sz);
       }
       v7node->update_mtime = true;

       return error;
}

int
v7fs_fsync(void *v)
{
       struct vop_fsync_args /* {
                                struct vnode *a_vp;
                                kauth_cred_t a_cred;
                                int a_flags;
                                off_t offlo;
                                off_t offhi;
                                } */ *a = v;
       struct vnode *vp = a->a_vp;
       int error, wait;

       DPRINTF("%p\n", a->a_vp);
       if (a->a_flags & FSYNC_CACHE) {
               return EOPNOTSUPP;
       }

       wait = (a->a_flags & FSYNC_WAIT);
       error = vflushbuf(vp, a->a_flags);

       if (error == 0 && (a->a_flags & FSYNC_DATAONLY) == 0)
               error = v7fs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);

       return error;
}

int
v7fs_remove(void *v)
{
       struct vop_remove_v3_args /* {
                                 struct vnodeop_desc *a_desc;
                                 struct vnode * a_dvp;
                                 struct vnode * a_vp;
                                 struct componentname * a_cnp;
                                 nlink_t ctx_vp_new_nlink;
                                 } */ *a = v;
       struct v7fs_node *parent_node = a->a_dvp->v_data;
       struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
       struct vnode *vp = a->a_vp;
       struct vnode *dvp = a->a_dvp;
       struct v7fs_inode *inode = &((struct v7fs_node *)vp->v_data)->inode;
       struct v7fs_self *fs = v7fsmount->core;
       int error = 0;

       DPRINTF("delete %.*s\n", (int)a->a_cnp->cn_namelen,
           a->a_cnp->cn_nameptr);

       if (vp->v_type == VDIR) {
               error = EPERM;
               goto out;
       }

       if ((error = v7fs_file_deallocate(fs, &parent_node->inode,
                   a->a_cnp->cn_nameptr, a->a_cnp->cn_namelen))) {
               DPRINTF("v7fs_file_delete failed.\n");
               goto out;
       }
       error = v7fs_inode_load(fs, inode, inode->inode_number);
       if (error)
               goto out;
       /* Sync dirent size change. */
       uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));

out:
       if (dvp == vp)
               vrele(vp); /* usecount-- of unlocked vp */
       else
               vput(vp); /* unlock vp and then usecount-- */

       return error;
}

int
v7fs_link(void *v)
{
       struct vop_link_v2_args /* {
                               struct vnode *a_dvp;
                               struct vnode *a_vp;
                               struct componentname *a_cnp;
                               } */ *a = v;
       struct vnode *dvp = a->a_dvp;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *parent_node = dvp->v_data;
       struct v7fs_node *node = vp->v_data;
       struct v7fs_inode *parent = &parent_node->inode;
       struct v7fs_inode *p = &node->inode;
       struct v7fs_self *fs = node->v7fsmount->core;
       struct componentname *cnp = a->a_cnp;
       int error, abrt = 1;

       DPRINTF("%p\n", vp);
       /* Lock source file */
       if ((error = vn_lock(vp, LK_EXCLUSIVE))) {
               DPRINTF("lock failed. %p\n", vp);
               goto unlock;
       }
       error = kauth_authorize_vnode(cnp->cn_cred, KAUTH_VNODE_ADD_LINK, vp,
           dvp, 0);
       if (error)
               goto unlock;
       abrt = 0;
       error = v7fs_file_link(fs, parent, p, cnp->cn_nameptr, cnp->cn_namelen);
       /* Sync dirent size change. */
       uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));

unlock:
       VOP_UNLOCK(vp);
       if (abrt)
               VOP_ABORTOP(dvp, cnp);
       return error;
}

int
v7fs_rename(void *v)
{
       struct vop_rename_args /* {
                                 struct vnode *a_fdvp; from parent-directory
                                 struct vnode *a_fvp;  from file
                                 struct componentname *a_fcnp;
                                 struct vnode *a_tdvp; to parent-directory
                                 struct vnode *a_tvp;  to file
                                 struct componentname *a_tcnp;
                                 } */ *a = v;
       struct vnode *fvp = a->a_fvp;
       struct vnode *tvp = a->a_tvp;
       struct vnode *fdvp = a->a_fdvp;
       struct vnode *tdvp = a->a_tdvp;
       struct v7fs_node *parent_from = fdvp->v_data;
       struct v7fs_node *parent_to = tdvp->v_data;
       struct v7fs_node *v7node = fvp->v_data;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       const char *from_name = a->a_fcnp->cn_nameptr;
       const char *to_name = a->a_tcnp->cn_nameptr;
       size_t from_len = a->a_fcnp->cn_namelen;
       size_t to_len = a->a_tcnp->cn_namelen;
       int error;

       DPRINTF("%.*s->%.*s %p %p\n", (int)from_len, from_name, (int)to_len,
           to_name, fvp, tvp);

       if ((fvp->v_mount != tdvp->v_mount) ||
           (tvp && (fvp->v_mount != tvp->v_mount))) {
               error = EXDEV;
               DPRINTF("cross-device link\n");
               goto out;
       }
       // XXXsource file lock?
       error = v7fs_file_rename(fs, &parent_from->inode, from_name, from_len,
           &parent_to->inode, to_name, to_len);
       /* 'to file' inode may be changed. (hard-linked and it is cached.)
          t_vnops rename_reg_nodir */
       if (error == 0 && tvp) {
               struct v7fs_inode *inode =
                   &((struct v7fs_node *)tvp->v_data)->inode;

               error = v7fs_inode_load(fs, inode, inode->inode_number);
               uvm_vnp_setsize(tvp, v7fs_inode_filesize(inode));
       }
       /* Sync dirent size change. */
       uvm_vnp_setsize(tdvp, v7fs_inode_filesize(&parent_to->inode));
       uvm_vnp_setsize(fdvp, v7fs_inode_filesize(&parent_from->inode));
out:
       if (tvp)
               vput(tvp);  /* locked on entry */
       if (tdvp == tvp)
               vrele(tdvp);
       else
               vput(tdvp);
       vrele(fdvp);
       vrele(fvp);

       return error;
}

int
v7fs_mkdir(void *v)
{
       struct vop_mkdir_v3_args /* {
                                struct vnode           *a_dvp;
                                struct vnode           **a_vpp;
                                struct componentname   *a_cnp;
                                struct vattr           *a_vap;
                                } */ *a = v;
       struct componentname *cnp = a->a_cnp;
       kauth_cred_t cr = cnp->cn_cred;
       struct vnode *dvp = a->a_dvp;
       struct vattr *va = a->a_vap;
       struct v7fs_node *parent_node = dvp->v_data;
       struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
       struct v7fs_self *fs = v7fsmount->core;
       struct v7fs_fileattr attr;
       struct mount *mp = v7fsmount->mountp;
       v7fs_ino_t ino;
       int error = 0;

       DPRINTF("\n");
       memset(&attr, 0, sizeof(attr));
       attr.uid = kauth_cred_geteuid(cr);
       attr.gid = kauth_cred_getegid(cr);
       attr.mode = va->va_mode | vtype_to_v7fs_mode(va->va_type);

       if ((error = v7fs_file_allocate(fs, &parent_node->inode,
           cnp->cn_nameptr, cnp->cn_namelen, &attr, &ino)))
               return error;
       /* Sync dirent size change. */
       uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));

       error = v7fs_vget(mp, ino, LK_EXCLUSIVE, a->a_vpp);
       if (error != 0) {
               DPRINTF("can't get vnode.\n");
       }
       struct v7fs_node *newnode = (*a->a_vpp)->v_data;
       newnode->update_ctime = true;
       newnode->update_mtime = true;
       newnode->update_atime = true;

       if (error == 0)
               VOP_UNLOCK(*a->a_vpp);

       return error;
}

int
v7fs_rmdir(void *v)
{
       struct vop_rmdir_v2_args /* {
                                struct vnode           *a_dvp;
                                struct vnode           *a_vp;
                                struct componentname   *a_cnp;
                                } */ *a = v;
       struct vnode *vp = a->a_vp;
       struct vnode *dvp = a->a_dvp;
       struct v7fs_node *parent_node = dvp->v_data;
       struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
       struct v7fs_inode *inode = &((struct v7fs_node *)vp->v_data)->inode;
       struct v7fs_self *fs = v7fsmount->core;
       int error = 0;

       DPRINTF("delete %.*s\n", (int)a->a_cnp->cn_namelen,
           a->a_cnp->cn_nameptr);

       KDASSERT(vp->v_type == VDIR);

       if ((error = v7fs_file_deallocate(fs, &parent_node->inode,
           a->a_cnp->cn_nameptr, a->a_cnp->cn_namelen))) {
               DPRINTF("v7fs_directory_deallocate failed.\n");
               goto out;
       }
       error = v7fs_inode_load(fs, inode, inode->inode_number);
       if (error)
               goto out;
       uvm_vnp_setsize(vp, v7fs_inode_filesize(inode));
       /* Sync dirent size change. */
       uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));
out:
       vput(vp);

       return error;
}

struct v7fs_readdir_arg {
       struct dirent *dp;
       struct uio *uio;
       int start;
       int end;
       int cnt;
};
static int readdir_subr(struct v7fs_self *, void *, v7fs_daddr_t, size_t);

int
readdir_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)
{
       struct v7fs_readdir_arg *p = (struct v7fs_readdir_arg *)ctx;
       struct v7fs_dirent *dir;
       struct dirent *dp = p->dp;
       struct v7fs_inode inode;
       char filename[V7FS_NAME_MAX + 1];
       int i, n;
       int error = 0;
       void *buf;

       if (!(buf = scratch_read(fs, blk)))
               return EIO;
       dir = (struct v7fs_dirent *)buf;

       n = sz / sizeof(*dir);

       for (i = 0; (i < n) && (p->cnt < p->end); i++, dir++, p->cnt++) {
               if (p->cnt < p->start)
                       continue;

               if ((error = v7fs_inode_load(fs, &inode, dir->inode_number)))
                       break;

               v7fs_dirent_filename(filename, dir->name, strlen(dir->name));

               DPRINTF("inode=%d name=%s %s\n", dir->inode_number, filename,
                   v7fs_inode_isdir(&inode) ? "DIR" : "FILE");
               memset(dp, 0, sizeof(*dp));
               dp->d_fileno = dir->inode_number;
               dp->d_type = v7fs_mode_to_d_type(inode.mode);
               dp->d_namlen = strlen(filename);
               strcpy(dp->d_name, filename);
               dp->d_reclen = sizeof(*dp);
               if ((error = uiomove(dp, dp->d_reclen, p->uio))) {
                       DPRINTF("uiomove failed.\n");
                       break;
               }
       }
       scratch_free(fs, buf);

       if (p->cnt == p->end)
               return V7FS_ITERATOR_BREAK;

       return error;
}

int
v7fs_readdir(void *v)
{
       struct vop_readdir_args /* {
                                  struct vnode *a_vp;
                                  struct uio *a_uio;
                                  kauth_cred_t a_cred;
                                  int *a_eofflag;
                                  off_t **a_cookies;
                                  int *a_ncookies;
                                  } */ *a = v;
       struct uio *uio = a->a_uio;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       struct dirent *dp;
       int error;

       DPRINTF("offset=%zu residue=%zu\n", uio->uio_offset, uio->uio_resid);

       KDASSERT(vp->v_type == VDIR);
       KDASSERT(v7fs_inode_isdir(inode));

       if (uio->uio_offset  < 0)
               return EINVAL;

       struct v7fs_readdir_arg arg;
       arg.start = uio->uio_offset / sizeof(*dp);
       arg.end = arg.start +  uio->uio_resid / sizeof(*dp);
       if (arg.start == arg.end) {/* user buffer has not enuf space. */
               DPRINTF("uio buffer too small\n");
               return ENOMEM;
       }
       dp = kmem_zalloc(sizeof(*dp), KM_SLEEP);
       arg.cnt = 0;
       arg.dp = dp;
       arg.uio = uio;

       *a->a_eofflag = false;
       error = v7fs_datablock_foreach(fs, inode, readdir_subr, &arg);
       if (error == V7FS_ITERATOR_END) {
               *a->a_eofflag = true;
       }
       if (error < 0)
               error = 0;

       kmem_free(dp, sizeof(*dp));

       return error;
}

int
v7fs_inactive(void *v)
{
       struct vop_inactive_v2_args /* {
                                   struct vnode *a_vp;
                                   bool *a_recycle;
                                   } */ *a = v;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;

       DPRINTF("%p #%d\n", vp, inode->inode_number);
       if (v7fs_inode_nlink(inode) > 0) {
               v7fs_update(vp, 0, 0, UPDATE_WAIT);
               *a->a_recycle = false;
       } else {
               *a->a_recycle = true;
       }

       return 0;
}

int
v7fs_reclaim(void *v)
{
       /*This vnode is no longer referenced by kernel. */
       extern struct pool v7fs_node_pool;
       struct vop_reclaim_v2_args /* {
                                  struct vnode *a_vp;
                                  } */ *a = v;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       struct v7fs_inode *inode = &v7node->inode;

       VOP_UNLOCK(vp);

       DPRINTF("%p #%d\n", vp, inode->inode_number);
       if (v7fs_inode_nlink(inode) == 0) {
               v7fs_datablock_size_change(fs, 0, inode);
               DPRINTF("remove datablock\n");
               v7fs_inode_deallocate(fs, inode->inode_number);
               DPRINTF("remove inode\n");
       }
       genfs_node_destroy(vp);
       pool_put(&v7fs_node_pool, v7node);
       mutex_enter(vp->v_interlock);
       vp->v_data = NULL;
       mutex_exit(vp->v_interlock);

       return 0;
}

int
v7fs_bmap(void *v)
{
       struct vop_bmap_args /* {
                               struct vnode *a_vp;
                               daddr_t  a_bn;
                               struct vnode **a_vpp;
                               daddr_t *a_bnp;
                               int *a_runp;
                               } */ *a = v;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_mount *v7fsmount = v7node->v7fsmount;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       struct v7fs_inode *inode = &v7node->inode;
       int error = 0;

       DPRINTF("inode=%d offset=%zu %p\n", inode->inode_number, a->a_bn, vp);
       DPRINTF("filesize: %d\n", inode->filesize);
       if (!a->a_bnp)
               return 0;

       v7fs_daddr_t blk;
       if (!(blk = v7fs_datablock_last(fs, inode,
           (a->a_bn + 1) << V7FS_BSHIFT))) {
               /* +1 converts block # to file offset. */
               return ENOSPC;
       }

       *a->a_bnp = blk;

       if (a->a_vpp)
               *a->a_vpp = v7fsmount->devvp;
       if (a->a_runp)
               *a->a_runp = 0; /*XXX TODO */

       DPRINTF("%d  %zu->%zu status=%d\n", inode->inode_number, a->a_bn,
           *a->a_bnp, error);

       return error;
}

int
v7fs_strategy(void *v)
{
       struct vop_strategy_args /* {
                                   struct vnode *a_vp;
                                   struct buf *a_bp;
                                   } */ *a = v;
       struct buf *b = a->a_bp;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_mount *v7fsmount = v7node->v7fsmount;
       int error;

       DPRINTF("%p\n", vp);
       KDASSERT(vp->v_type == VREG);
       if (b->b_blkno == b->b_lblkno) {
               error = VOP_BMAP(vp, b->b_lblkno, NULL, &b->b_blkno, NULL);
               if (error) {
                       b->b_error = error;
                       biodone(b);
                       return error;
               }
               if ((long)b->b_blkno == -1)
                       clrbuf(b);
       }
       if ((long)b->b_blkno == -1) {
               biodone(b);
               return 0;
       }

       return VOP_STRATEGY(v7fsmount->devvp, b);
}

int
v7fs_print(void *v)
{
       struct vop_print_args /* {
                                struct vnode *a_vp;
                                } */ *a = v;
       struct v7fs_node *v7node = a->a_vp->v_data;

       v7fs_inode_dump(&v7node->inode);

       return 0;
}

int
v7fs_advlock(void *v)
{
       struct vop_advlock_args /* {
                                  struct vnode *a_vp;
                                  void *a_id;
                                  int a_op;
                                  struct flock *a_fl;
                                  int a_flags;
                                  } */ *a = v;
       struct v7fs_node *v7node = a->a_vp->v_data;

       DPRINTF("op=%d\n", a->a_op);

       return lf_advlock(a, &v7node->lockf,
           v7fs_inode_filesize(&v7node->inode));
}

int
v7fs_pathconf(void *v)
{
       struct vop_pathconf_args /* {
               struct vnode *a_vp;
               int a_name;
               register_t *a_retval;
       } */ *ap = v;
       DPRINTF("%p\n", ap->a_vp);

       switch (ap->a_name) {
       case _PC_LINK_MAX:
               *ap->a_retval = V7FS_LINK_MAX;
               return 0;
       case _PC_NAME_MAX:
               *ap->a_retval = V7FS_NAME_MAX;
               return 0;
       case _PC_PATH_MAX:
               *ap->a_retval = V7FS_PATH_MAX;
               return 0;
       case _PC_CHOWN_RESTRICTED:
               *ap->a_retval = 1;
               return 0;
       case _PC_NO_TRUNC:
               *ap->a_retval = 0;
               return 0;
       case _PC_SYNC_IO:
               *ap->a_retval = 1;
               return 0;
       case _PC_FILESIZEBITS:
               *ap->a_retval = 30; /* ~1G */
               return 0;
       case _PC_SYMLINK_MAX:
               *ap->a_retval = V7FSBSD_MAXSYMLINKLEN;
               return 0;
       case _PC_2_SYMLINKS:
               *ap->a_retval = 1;
               return 0;
       default:
               return genfs_pathconf(ap);
       }
}

int
v7fs_update(struct vnode *vp, const struct timespec *acc,
   const struct timespec *mod, int flags)
{
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       bool update = false;

       DPRINTF("%p %zu %d\n", vp, vp->v_size, v7fs_inode_filesize(inode));
       KDASSERT(vp->v_size == v7fs_inode_filesize(inode));

       if (v7node->update_atime) {
               inode->atime = acc ? acc->tv_sec : time_second;
               v7node->update_atime = false;
               update = true;
       }
       if (v7node->update_ctime) {
               inode->ctime = time_second;
               v7node->update_ctime = false;
               update = true;
       }
       if (v7node->update_mtime) {
               inode->mtime = mod ? mod->tv_sec : time_second;
               v7node->update_mtime = false;
               update = true;
       }

       if (update)
               v7fs_inode_writeback(fs, inode);

       return 0;
}

int
v7fs_symlink(void *v)
{
       struct vop_symlink_v3_args /* {
                                  struct vnode         *a_dvp;
                                  struct vnode         **a_vpp;
                                  struct componentname *a_cnp;
                                  struct vattr         *a_vap;
                                  char                 *a_target;
                                  } */ *a = v;
       struct v7fs_node *parent_node = a->a_dvp->v_data;
       struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
       struct v7fs_self *fs = v7fsmount->core;
       struct vattr *va = a->a_vap;
       kauth_cred_t cr = a->a_cnp->cn_cred;
       struct componentname *cnp = a->a_cnp;
       struct v7fs_fileattr attr;
       v7fs_ino_t ino;
       const char *from = a->a_target;
       const char *to = cnp->cn_nameptr;
       size_t len = strlen(from) + 1;
       size_t tolen = cnp->cn_namelen;
       int error = 0;

       if (len > V7FS_BSIZE) { /* limited to 512byte pathname */
               DPRINTF("too long pathname.");
               return ENAMETOOLONG;
       }

       memset(&attr, 0, sizeof(attr));
       attr.uid = kauth_cred_geteuid(cr);
       attr.gid = kauth_cred_getegid(cr);
       attr.mode = va->va_mode | vtype_to_v7fs_mode(va->va_type);

       if ((error = v7fs_file_allocate
               (fs, &parent_node->inode, to, tolen, &attr, &ino))) {
               return error;
       }
       /* Sync dirent size change. */
       uvm_vnp_setsize(a->a_dvp, v7fs_inode_filesize(&parent_node->inode));

       /* Get myself vnode. */
       error = v7fs_vget(v7fsmount->mountp, ino, LK_EXCLUSIVE, a->a_vpp);
       if (error != 0) {
               DPRINTF("can't get vnode.\n");
       }

       struct v7fs_node *newnode = (*a->a_vpp)->v_data;
       struct v7fs_inode *p = &newnode->inode;
       v7fs_file_symlink(fs, p, from);
       uvm_vnp_setsize(*a->a_vpp, v7fs_inode_filesize(p));

       newnode->update_ctime = true;
       newnode->update_mtime = true;
       newnode->update_atime = true;

       if (error == 0)
               VOP_UNLOCK(*a->a_vpp);

       return error;
}

int
v7fs_readlink(void *v)
{
       struct vop_readlink_args /* {
                                   struct vnode        *a_vp;
                                   struct uio          *a_uio;
                                   kauth_cred_t        a_cred;
                                   } */ *a = v;
       struct uio *uio = a->a_uio;
       struct vnode *vp = a->a_vp;
       struct v7fs_node *v7node = vp->v_data;
       struct v7fs_inode *inode = &v7node->inode;
       struct v7fs_self *fs = v7node->v7fsmount->core;
       int error = 0;

       KDASSERT(vp->v_type == VLNK);
       KDASSERT(uio->uio_offset >= 0);
       KDASSERT(v7fs_inode_islnk(inode));

       v7fs_daddr_t blk = inode->addr[0];
       void *buf;
       if (!(buf = scratch_read(fs, blk))) {
               error = EIO;
               goto error_exit;
       }

       if ((error = uiomove(buf, strlen(buf), uio))) {
               DPRINTF("uiomove failed.\n");
       }
       scratch_free(fs, buf);

error_exit:
       return error;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.