/*      $NetBSD: sysvbfs_vnops.c,v 1.69 2022/07/31 13:08:18 mlelstv Exp $       */

/*-
* Copyright (c) 2004 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: sysvbfs_vnops.c,v 1.69 2022/07/31 13:08:18 mlelstv Exp $");

#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/malloc.h>
#include <sys/lockf.h>
#include <sys/unistd.h>
#include <sys/fcntl.h>
#include <sys/kauth.h>
#include <sys/buf.h>

#include <miscfs/genfs/genfs.h>

#include <fs/sysvbfs/sysvbfs.h>
#include <fs/sysvbfs/bfs.h>

#ifdef SYSVBFS_VNOPS_DEBUG
#define DPRINTF(fmt, args...)   printf(fmt, ##args)
#else
#define DPRINTF(arg...)         ((void)0)
#endif
#define ROUND_SECTOR(x)         (((x) + 511) & ~511)

MALLOC_JUSTDEFINE(M_SYSVBFS_VNODE, "sysvbfs vnode", "sysvbfs vnode structures");
MALLOC_DECLARE(M_BFS);

static void sysvbfs_file_setsize(struct vnode *, size_t);

int
sysvbfs_lookup(void *arg)
{
       struct vop_lookup_v2_args /* {
               struct vnode *a_dvp;
               struct vnode **a_vpp;
               struct componentname *a_cnp;
       } */ *a = arg;
       struct vnode *v = a->a_dvp;
       struct sysvbfs_node *bnode = v->v_data;
       struct bfs *bfs = bnode->bmp->bfs;      /* my filesystem */
       struct vnode *vpp = NULL;
       struct bfs_dirent *dirent = NULL;
       struct componentname *cnp = a->a_cnp;
       int nameiop = cnp->cn_nameiop;
       const char *name = cnp->cn_nameptr;
       int namelen = cnp->cn_namelen;
       int error;

       DPRINTF("%s: %s op=%d %d\n", __func__, name, nameiop,
           cnp->cn_flags);

       *a->a_vpp = NULL;

       KASSERT((cnp->cn_flags & ISDOTDOT) == 0);

       if ((error = VOP_ACCESS(a->a_dvp, VEXEC, cnp->cn_cred)) != 0) {
               return error;   /* directory permission. */
       }

       /* Deny last component write operation on a read-only mount */
       if ((cnp->cn_flags & ISLASTCN) && (v->v_mount->mnt_flag & MNT_RDONLY) &&
           (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
               return EROFS;

       if (namelen == 1 && name[0] == '.') {   /* "." */
               vref(v);
               *a->a_vpp = v;
       } else {                                /* Regular file */
               if (!bfs_dirent_lookup_by_name(bfs, cnp->cn_nameptr,
                   &dirent)) {
                       if (nameiop != CREATE && nameiop != RENAME) {
                               DPRINTF("%s: no such a file. (1)\n",
                                   __func__);
                               return ENOENT;
                       }
                       if ((error = VOP_ACCESS(v, VWRITE, cnp->cn_cred)) != 0)
                               return error;
                       return EJUSTRETURN;
               }

               /* Allocate v-node */
               error = sysvbfs_vget(v->v_mount, dirent->inode,
                   LK_EXCLUSIVE, &vpp);
               if (error != 0) {
                       DPRINTF("%s: can't get vnode.\n", __func__);
                       return error;
               }
               VOP_UNLOCK(vpp);
               *a->a_vpp = vpp;
       }

       return 0;
}

int
sysvbfs_create(void *arg)
{
       struct vop_create_v3_args /* {
               struct vnode *a_dvp;
               struct vnode **a_vpp;
               struct componentname *a_cnp;
               struct vattr *a_vap;
       } */ *a = arg;
       struct sysvbfs_node *bnode = a->a_dvp->v_data;
       struct sysvbfs_mount *bmp = bnode->bmp;
       struct bfs *bfs = bmp->bfs;
       struct mount *mp = bmp->mountp;
       struct bfs_dirent *dirent;
       struct bfs_fileattr attr;
       struct vattr *va = a->a_vap;
       kauth_cred_t cr = a->a_cnp->cn_cred;
       int err = 0;

       DPRINTF("%s: %s\n", __func__, a->a_cnp->cn_nameptr);
       KDASSERT(a->a_vap->va_type == VREG);
       attr.uid = kauth_cred_geteuid(cr);
       attr.gid = kauth_cred_getegid(cr);
       attr.mode = va->va_mode;

       if ((err = bfs_file_create(bfs, a->a_cnp->cn_nameptr, 0, 0, &attr))
           != 0) {
               DPRINTF("%s: bfs_file_create failed.\n", __func__);
               return err;
       }

       if (!bfs_dirent_lookup_by_name(bfs, a->a_cnp->cn_nameptr, &dirent))
               panic("no dirent for created file.");

       err = sysvbfs_vget(mp, dirent->inode, LK_EXCLUSIVE, a->a_vpp);
       if (err != 0) {
               DPRINTF("%s: sysvbfs_vget failed.\n", __func__);
               return err;
       }
       bnode = (*a->a_vpp)->v_data;
       bnode->update_ctime = true;
       bnode->update_mtime = true;
       bnode->update_atime = true;
       VOP_UNLOCK(*a->a_vpp);

       return err;
}

int
sysvbfs_open(void *arg)
{
       struct vop_open_args /* {
               struct vnode *a_vp;
               int  a_mode;
               kauth_cred_t a_cred;
       } */ *a = arg;
       struct vnode *v = a->a_vp;
       struct sysvbfs_node *bnode = v->v_data;
       struct bfs_inode *inode = bnode->inode;

       DPRINTF("%s:\n", __func__);
       KDASSERT(v->v_type == VREG || v->v_type == VDIR);

       bnode->update_atime = true;
       if ((a->a_mode & FWRITE) && !(a->a_mode & O_APPEND)) {
               bnode->size = 0;
       } else {
               bnode->size = bfs_file_size(inode);
       }
       bnode->data_block = inode->start_sector;

       return 0;
}

int
sysvbfs_close(void *arg)
{
       struct vop_close_args /* {
               struct vnodeop_desc *a_desc;
               struct vnode *a_vp;
               int  a_fflag;
               kauth_cred_t a_cred;
       } */ *a = arg;
       struct vnode *v = a->a_vp;
       struct sysvbfs_node *bnode = v->v_data;
       struct bfs_fileattr attr;

       DPRINTF("%s:\n", __func__);

       if (v->v_mount->mnt_flag & MNT_RDONLY)
               goto out;

       uvm_vnp_setsize(v, bnode->size);

       memset(&attr, 0xff, sizeof attr);       /* Set VNOVAL all */
       if (bnode->update_atime)
               attr.atime = time_second;
       if (bnode->update_ctime)
               attr.ctime = time_second;
       if (bnode->update_mtime)
               attr.mtime = time_second;
       bfs_inode_set_attr(bnode->bmp->bfs, bnode->inode, &attr);

       VOP_FSYNC(a->a_vp, a->a_cred, FSYNC_WAIT, 0, 0);

out:
       return 0;
}

static int
sysvbfs_check_possible(struct vnode *vp, struct sysvbfs_node *bnode,
   mode_t mode)
{

       if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
               return EROFS;

       return 0;
}

static int
sysvbfs_check_permitted(struct vnode *vp, struct sysvbfs_node *bnode,
   accmode_t accmode, kauth_cred_t cred)
{
       struct bfs_fileattr *attr = &bnode->inode->attr;

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

int
sysvbfs_access(void *arg)
{
       struct vop_access_args /* {
               struct vnode    *a_vp;
               accmode_t       a_accmode;
               kauth_cred_t    a_cred;
       } */ *ap = arg;
       struct vnode *vp = ap->a_vp;
       struct sysvbfs_node *bnode = vp->v_data;
       int error;

       DPRINTF("%s:\n", __func__);

       error = sysvbfs_check_possible(vp, bnode, ap->a_accmode);
       if (error)
               return error;

       error = sysvbfs_check_permitted(vp, bnode, ap->a_accmode, ap->a_cred);

       return error;
}

int
sysvbfs_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 sysvbfs_node *bnode = vp->v_data;
       struct bfs_inode *inode = bnode->inode;
       struct bfs_fileattr *attr = &inode->attr;
       struct sysvbfs_mount *bmp = bnode->bmp;
       struct vattr *vap = ap->a_vap;

       DPRINTF("%s:\n", __func__);

       vap->va_type = vp->v_type;
       vap->va_mode = attr->mode;
       vap->va_nlink = attr->nlink;
       vap->va_uid = attr->uid;
       vap->va_gid = attr->gid;
       vap->va_fsid = bmp->devvp->v_rdev;
       vap->va_fileid = inode->number;
       vap->va_size = bfs_file_size(inode);
       vap->va_blocksize = BFS_BSIZE;
       vap->va_atime.tv_sec = attr->atime;
       vap->va_mtime.tv_sec = attr->mtime;
       vap->va_ctime.tv_sec = attr->ctime;
       vap->va_birthtime.tv_sec = 0;
       vap->va_gen = 1;
       vap->va_flags = 0;
       vap->va_rdev = 0;       /* No device file */
       vap->va_bytes = vap->va_size;
       vap->va_filerev = 0;
       vap->va_vaflags = 0;

       return 0;
}

int
sysvbfs_setattr(void *arg)
{
       struct vop_setattr_args /* {
               struct vnode *a_vp;
               struct vattr *a_vap;
               kauth_cred_t a_cred;
               struct proc *p;
       } */ *ap = arg;
       struct vnode *vp = ap->a_vp;
       struct vattr *vap = ap->a_vap;
       struct sysvbfs_node *bnode = vp->v_data;
       struct bfs_inode *inode = bnode->inode;
       struct bfs_fileattr *attr = &inode->attr;
       struct bfs *bfs = bnode->bmp->bfs;
       kauth_cred_t cred = ap->a_cred;
       int error;

       DPRINTF("%s:\n", __func__);
       if (vp->v_mount->mnt_flag & MNT_RDONLY)
               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))
               return EINVAL;

       if (vap->va_flags != VNOVAL)
               return EOPNOTSUPP;

       if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
               uid_t uid =
                   (vap->va_uid != (uid_t)VNOVAL) ? vap->va_uid : attr->uid;
               gid_t gid =
                   (vap->va_gid != (gid_t)VNOVAL) ? vap->va_gid : attr->gid;
               error = kauth_authorize_vnode(cred,
                   KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
                   genfs_can_chown(vp, cred, attr->uid, attr->gid, uid, gid));
               if (error)
                       return error;
               attr->uid = uid;
               attr->gid = gid;
       }

       if (vap->va_size != VNOVAL)
               switch (vp->v_type) {
               case VDIR:
                       return EISDIR;
               case VCHR:
               case VBLK:
               case VFIFO:
                       break;
               case VREG:
                       if (vp->v_mount->mnt_flag & MNT_RDONLY)
                               return EROFS;
                       sysvbfs_file_setsize(vp, vap->va_size);
                       break;
               default:
                       return EOPNOTSUPP;
               }

       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, attr->uid,
                   attr->gid, mode));
               if (error)
                       return error;
               attr->mode = 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, attr->uid,
                       vap->va_vaflags));
               if (error)
                       return error;

               if (vap->va_atime.tv_sec != VNOVAL)
                       attr->atime = vap->va_atime.tv_sec;
               if (vap->va_mtime.tv_sec != VNOVAL)
                       attr->mtime = vap->va_mtime.tv_sec;
               if (vap->va_ctime.tv_sec != VNOVAL)
                       attr->ctime = vap->va_ctime.tv_sec;
       }

       bfs_inode_set_attr(bfs, inode, attr);

       return 0;
}

int
sysvbfs_read(void *arg)
{
       struct vop_read_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int a_ioflag;
               kauth_cred_t a_cred;
       } */ *a = arg;
       struct vnode *v = a->a_vp;
       struct uio *uio = a->a_uio;
       struct sysvbfs_node *bnode = v->v_data;
       struct bfs_inode *inode = bnode->inode;
       vsize_t sz, filesz = bfs_file_size(inode);
       int err, uerr;
       const int advice = IO_ADV_DECODE(a->a_ioflag);

       DPRINTF("%s: type=%d\n", __func__, v->v_type);
       switch (v->v_type) {
       case VREG:
               break;
       case VDIR:
               return EISDIR;
       default:
               return EINVAL;
       }

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

               err = ubc_uiomove(&v->v_uobj, uio, sz, advice,
                   UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(v));
               if (err)
                       break;
               DPRINTF("%s: read %ldbyte\n", __func__, sz);
       }

       uerr = sysvbfs_update(v, NULL, NULL, UPDATE_WAIT);
       if (err == 0)
               err = uerr;

       return err;
}

int
sysvbfs_write(void *arg)
{
       struct vop_write_args /* {
               struct vnode *a_vp;
               struct uio *a_uio;
               int  a_ioflag;
               kauth_cred_t a_cred;
       } */ *a = arg;
       struct vnode *v = a->a_vp;
       struct uio *uio = a->a_uio;
       int advice = IO_ADV_DECODE(a->a_ioflag);
       struct sysvbfs_node *bnode = v->v_data;
       vsize_t sz;
       int err = 0;

       if (a->a_vp->v_type != VREG)
               return EISDIR;

       if (a->a_ioflag & IO_APPEND)
               uio->uio_offset = bnode->size;

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

       if (bnode->size < uio->uio_offset + uio->uio_resid) {
               sysvbfs_file_setsize(v, uio->uio_offset + uio->uio_resid);
       }

       while (uio->uio_resid > 0) {
               sz = uio->uio_resid;
               err = ubc_uiomove(&v->v_uobj, uio, sz, advice,
                   UBC_WRITE | UBC_VNODE_FLAGS(v));
               if (err)
                       break;
               DPRINTF("%s: write %ldbyte\n", __func__, sz);
       }
       if (err)
               sysvbfs_file_setsize(v, bnode->size - uio->uio_resid);

       return err;
}

int
sysvbfs_remove(void *arg)
{
       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;
       } */ *ap = arg;
       struct vnode *vp = ap->a_vp;
       struct vnode *dvp = ap->a_dvp;
       struct sysvbfs_node *bnode = vp->v_data;
       struct sysvbfs_mount *bmp = bnode->bmp;
       struct bfs *bfs = bmp->bfs;
       int err;

       DPRINTF("%s: delete %s\n", __func__, ap->a_cnp->cn_nameptr);

       if (vp->v_type == VDIR) {
               vrele(vp);
               return EPERM;
       }

       if ((err = bfs_file_delete(bfs, ap->a_cnp->cn_nameptr, true)) != 0)
               DPRINTF("%s: bfs_file_delete failed.\n", __func__);

       if (dvp == vp)
               vrele(vp);
       else
               vput(vp);

       if (err == 0) {
               bnode->removed = 1;
       }

       return err;
}

int
sysvbfs_rename(void *arg)
{
       struct vop_rename_args /* {
               struct vnode *a_fdvp;   from parent-directory v-node
               struct vnode *a_fvp;    from file v-node
               struct componentname *a_fcnp;
               struct vnode *a_tdvp;   to parent-directory
               struct vnode *a_tvp;    to file v-node
               struct componentname *a_tcnp;
       } */ *ap = arg;
       struct vnode *fvp = ap->a_fvp;
       struct vnode *fdvp = ap->a_fdvp;
       struct vnode *tvp = ap->a_tvp;
       struct vnode *tdvp = ap->a_tdvp;
       struct sysvbfs_node *bnode = fvp->v_data;
       struct bfs *bfs = bnode->bmp->bfs;
       const char *from_name = ap->a_fcnp->cn_nameptr;
       const char *to_name = ap->a_tcnp->cn_nameptr;
       int error;

       DPRINTF("%s: %s->%s\n", __func__, from_name, to_name);
       if ((fvp->v_mount != tdvp->v_mount) ||
           (tvp && (fvp->v_mount != tvp->v_mount))) {
               error = EXDEV;
               printf("cross-device link\n");
               goto out;
       }

       KDASSERT(fvp->v_type == VREG);
       KDASSERT(tvp == NULL ? true : tvp->v_type == VREG);
       KASSERT(tdvp == fdvp);

       /*
        * Make sure the source hasn't been removed between lookup
        * and target directory lock.
        */
       if (bnode->removed) {
               error = ENOENT;
               goto out;
       }

       /*
        * Remove the target if it exists.
        */
       if (tvp != NULL) {
               error = bfs_file_delete(bfs, to_name, true);
               if (error)
                       goto out;
       }
       error = bfs_file_rename(bfs, from_name, to_name);
out:
       /* tdvp == tvp probably can't happen with this fs, but safety first */
       if (tdvp == tvp)
               vrele(tdvp);
       else
               vput(tdvp);
       if (tvp)
               vput(tvp);

       vrele(fdvp);
       vrele(fvp);

       return 0;
}

int
sysvbfs_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;
       } */ *ap = v;
       struct uio *uio = ap->a_uio;
       struct vnode *vp = ap->a_vp;
       struct sysvbfs_node *bnode = vp->v_data;
       struct bfs *bfs = bnode->bmp->bfs;
       struct dirent *dp;
       struct bfs_dirent *file;
       int i, n, error;

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

       KDASSERT(vp->v_type == VDIR);

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

       dp = malloc(sizeof(struct dirent), M_BFS, M_WAITOK | M_ZERO);

       i = uio->uio_offset / sizeof(struct dirent);
       n = uio->uio_resid / sizeof(struct dirent);
       if ((i + n) > bfs->n_dirent)
               n = bfs->n_dirent - i;

       DPRINTF("%s 1: %d %d %d\n", __func__, i, n, bfs->n_dirent);
       for (file = &bfs->dirent[i]; n > 0; file++, i++) {
               if (i == bfs->max_dirent) {
                       DPRINTF("%s: file system inconsistent.\n",
                           __func__);
                       break;
               }
               if (file->inode == 0)
                       continue;

               /* ok, we have a live one here */
               n--;
               memset(dp, 0, sizeof(struct dirent));
               dp->d_fileno = file->inode;
               dp->d_type = file->inode == BFS_ROOT_INODE ? DT_DIR : DT_REG;
               dp->d_namlen = strlen(file->name);
               strncpy(dp->d_name, file->name, BFS_FILENAME_MAXLEN);
               dp->d_reclen = sizeof(struct dirent);
               if ((error = uiomove(dp, dp->d_reclen, uio)) != 0) {
                       DPRINTF("%s: uiomove failed.\n", __func__);
                       free(dp, M_BFS);
                       return error;
               }
       }
       DPRINTF("%s 2: %d %d %d\n", __func__, i, n, bfs->n_dirent);
       *ap->a_eofflag = (i == bfs->n_dirent);

       free(dp, M_BFS);
       return 0;
}

int
sysvbfs_inactive(void *arg)
{
       struct vop_inactive_v2_args /* {
               struct vnode *a_vp;
               bool *a_recycle;
       } */ *a = arg;
       struct vnode *v = a->a_vp;
       struct sysvbfs_node *bnode = v->v_data;

       DPRINTF("%s:\n", __func__);
       if (bnode->removed)
               *a->a_recycle = true;
       else
               *a->a_recycle = false;

       return 0;
}

int
sysvbfs_reclaim(void *v)
{
       extern struct pool sysvbfs_node_pool;
       struct vop_reclaim_v2_args /* {
               struct vnode *a_vp;
       } */ *ap = v;
       struct vnode *vp = ap->a_vp;
       struct sysvbfs_node *bnode = vp->v_data;
       struct bfs *bfs = bnode->bmp->bfs;

       VOP_UNLOCK(vp);

       DPRINTF("%s:\n", __func__);

       if (bnode->removed) {
               if (bfs_inode_delete(bfs, bnode->inode->number) != 0)
                       DPRINTF("%s: delete inode failed\n", __func__);
       }
       genfs_node_destroy(vp);
       pool_put(&sysvbfs_node_pool, bnode);
       vp->v_data = NULL;

       return 0;
}

int
sysvbfs_bmap(void *arg)
{
       struct vop_bmap_args /* {
               struct vnode *a_vp;
               daddr_t  a_bn;
               struct vnode **a_vpp;
               daddr_t *a_bnp;
               int *a_runp;
       } */ *a = arg;
       struct vnode *v = a->a_vp;
       struct sysvbfs_node *bnode = v->v_data;
       struct sysvbfs_mount *bmp = bnode->bmp;
       struct bfs_inode *inode = bnode->inode;
       daddr_t blk;

       DPRINTF("%s:\n", __func__);
       /* BFS algorithm is contiguous allocation */
       blk = inode->start_sector + a->a_bn;

       if (blk * BFS_BSIZE > bmp->bfs->data_end)
               return ENOSPC;

       *a->a_vpp = bmp->devvp;
       *a->a_runp = 0;
       DPRINTF("%s: %d + %" PRId64 "\n", __func__, inode->start_sector,
           a->a_bn);

       *a->a_bnp = blk;


       return 0;
}

int
sysvbfs_strategy(void *arg)
{
       struct vop_strategy_args /* {
               struct vnode *a_vp;
               struct buf *a_bp;
       } */ *a = arg;
       struct buf *b = a->a_bp;
       struct vnode *v = a->a_vp;
       struct sysvbfs_node *bnode = v->v_data;
       struct sysvbfs_mount *bmp = bnode->bmp;
       int error;

       DPRINTF("%s:\n", __func__);
       KDASSERT(v->v_type == VREG);
       if (b->b_blkno == b->b_lblkno) {
               error = VOP_BMAP(v, 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(bmp->devvp, b);
}

int
sysvbfs_print(void *v)
{
       struct vop_print_args /* {
               struct vnode *a_vp;
       } */ *ap = v;
       struct sysvbfs_node *bnode = ap->a_vp->v_data;

       DPRINTF("%s:\n", __func__);
       bfs_dump(bnode->bmp->bfs);

       return 0;
}

int
sysvbfs_advlock(void *v)
{
       struct vop_advlock_args /* {
               struct vnode *a_vp;
               void *a_id;
               int a_op;
               struct flock *a_fl;
               int a_flags;
       } */ *ap = v;
       struct sysvbfs_node *bnode = ap->a_vp->v_data;

       DPRINTF("%s: op=%d\n", __func__, ap->a_op);

       return lf_advlock(ap, &bnode->lockf, bfs_file_size(bnode->inode));
}

int
sysvbfs_pathconf(void *v)
{
       struct vop_pathconf_args /* {
               struct vnode *a_vp;
               int a_name;
               register_t *a_retval;
       } */ *ap = v;

       DPRINTF("%s:\n", __func__);

       switch (ap->a_name) {
       case _PC_LINK_MAX:
               *ap->a_retval = 1;
               return 0;
       case _PC_NAME_MAX:
               *ap->a_retval = BFS_FILENAME_MAXLEN;
               return 0;
       case _PC_PATH_MAX:
               *ap->a_retval = BFS_FILENAME_MAXLEN;
               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 = 32;
               return 0;
       default:
               return genfs_pathconf(ap);
       }
}

int
sysvbfs_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;
       } */ *ap = v;
       struct vnode *vp = ap->a_vp;
       int error, wait;

       if (ap->a_flags & FSYNC_CACHE) {
               return EOPNOTSUPP;
       }

       wait = (ap->a_flags & FSYNC_WAIT) != 0;
       error = vflushbuf(vp, ap->a_flags);
       if (error == 0 && (ap->a_flags & FSYNC_DATAONLY) == 0)
               error = sysvbfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);

       return error;
}

int
sysvbfs_update(struct vnode *vp, const struct timespec *acc,
   const struct timespec *mod, int flags)
{
       struct sysvbfs_node *bnode = vp->v_data;
       struct bfs_fileattr attr;

       if (vp->v_mount->mnt_flag & MNT_RDONLY)
               return 0;

       DPRINTF("%s:\n", __func__);
       memset(&attr, 0xff, sizeof attr);       /* Set VNOVAL all */
       if (bnode->update_atime) {
               attr.atime = acc ? acc->tv_sec : time_second;
               bnode->update_atime = false;
       }
       if (bnode->update_ctime) {
               attr.ctime = time_second;
               bnode->update_ctime = false;
       }
       if (bnode->update_mtime) {
               attr.mtime = mod ? mod->tv_sec : time_second;
               bnode->update_mtime = false;
       }
       bfs_inode_set_attr(bnode->bmp->bfs, bnode->inode, &attr);

       return 0;
}

static void
sysvbfs_file_setsize(struct vnode *v, size_t size)
{
       struct sysvbfs_node *bnode = v->v_data;
       struct bfs_inode *inode = bnode->inode;

       bnode->size = size;
       uvm_vnp_setsize(v, bnode->size);
       inode->end_sector = bnode->data_block +
           (ROUND_SECTOR(bnode->size) >> DEV_BSHIFT) - 1;
       inode->eof_offset_byte = bnode->data_block * DEV_BSIZE +
           bnode->size - 1;
       bnode->update_mtime = true;
}

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.