/* $NetBSD: nilfs_vnops.c,v 1.48 2022/10/07 22:33:42 andvar Exp $ */

/* $NetBSD: nilfs_vnops.c,v 1.48 2022/10/07 22:33:42 andvar Exp $ */

/*
* Copyright (c) 2008, 2009 Reinoud Zandijk
* All rights reserved.
*
* 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 AUTHOR ``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 AUTHOR 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>
#ifndef lint
__KERNEL_RCSID(0, "$NetBSD: nilfs_vnops.c,v 1.48 2022/10/07 22:33:42 andvar Exp $");
#endif /* not lint */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/namei.h>
#include <sys/resourcevar.h> /* defines plimit structure in proc struct */
#include <sys/kernel.h>
#include <sys/file.h> /* define FWRITE ... */
#include <sys/stat.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/signalvar.h>
#include <sys/malloc.h>
#include <sys/dirent.h>
#include <sys/lockf.h>
#include <sys/kauth.h>

#include <miscfs/genfs/genfs.h>
#include <uvm/uvm_extern.h>

#include <fs/nilfs/nilfs_mount.h>
#include "nilfs.h"
#include "nilfs_subr.h"
#include "nilfs_bswap.h"

#define VTOI(vnode) ((struct nilfs_node *) (vnode)->v_data)

/* implementations of vnode functions; table follows at end */
/* --------------------------------------------------------------------- */

int
nilfs_inactive(void *v)
{
struct vop_inactive_v2_args /* {
struct vnode *a_vp;
bool *a_recycle;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct nilfs_node *nilfs_node = VTOI(vp);

DPRINTF(NODE, ("nilfs_inactive called for nilfs_node %p\n", VTOI(vp)));

if (nilfs_node == NULL) {
DPRINTF(NODE, ("nilfs_inactive: inactive NULL NILFS node\n"));
VOP_UNLOCK(vp);
return 0;
}

/*
* Optionally flush metadata to disc. If the file has not been
* referenced anymore in a directory we ought to free up the resources
* on disc if applicable.
*/

return 0;
}

/* --------------------------------------------------------------------- */

int
nilfs_reclaim(void *v)
{
struct vop_reclaim_v2_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct nilfs_node *nilfs_node = VTOI(vp);

VOP_UNLOCK(vp);

DPRINTF(NODE, ("nilfs_reclaim called for node %p\n", nilfs_node));

if (nilfs_node == NULL) {
DPRINTF(NODE, ("nilfs_reclaim(): null nilfsnode\n"));
return 0;
}

/* update note for closure */
nilfs_update(vp, NULL, NULL, NULL, UPDATE_CLOSE);

/* dispose all node knowledge */
genfs_node_destroy(vp);
nilfs_dispose_node(&nilfs_node);

vp->v_data = NULL;

return 0;
}

/* --------------------------------------------------------------------- */

int
nilfs_read(void *v)
{
struct vop_read_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
int ioflag = ap->a_ioflag;
int advice = IO_ADV_DECODE(ap->a_ioflag);
struct uvm_object *uobj;
struct nilfs_node *nilfs_node = VTOI(vp);
uint64_t file_size;
vsize_t len;
int error;

DPRINTF(READ, ("nilfs_read called\n"));

/* can this happen? some filingsystems have this check */
if (uio->uio_offset < 0)
return EINVAL;
if (uio->uio_resid == 0)
return 0;

/* protect against rogue programs reading raw directories and links */
if ((ioflag & IO_ALTSEMANTICS) == 0) {
if (vp->v_type == VDIR)
return EISDIR;
/* all but regular files just give EINVAL */
if (vp->v_type != VREG)
return EINVAL;
}

assert(nilfs_node);
file_size = nilfs_rw64(nilfs_node->inode.i_size);

/* read contents using buffercache */
uobj = &vp->v_uobj;
error = 0;
while (uio->uio_resid > 0) {
/* reached end? */
if (file_size <= uio->uio_offset)
break;

/* maximise length to file extremity */
len = MIN(file_size - uio->uio_offset, uio->uio_resid);
if (len == 0)
break;

/* ubc, here we come, prepare to trap */
error = ubc_uiomove(uobj, uio, len, advice,
UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
if (error)
break;
}

/* note access time unless not requested */
if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) {
nilfs_node->i_flags |= IN_ACCESS;
if ((ioflag & IO_SYNC) == IO_SYNC)
error = nilfs_update(vp, NULL, NULL, NULL, UPDATE_WAIT);
}

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_write(void *v)
{
struct vop_write_args /* {
struct vnode *a_vp;
struct uio *a_uio;
int a_ioflag;
kauth_cred_t a_cred;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
int ioflag = ap->a_ioflag;
int advice = IO_ADV_DECODE(ap->a_ioflag);
struct uvm_object *uobj;
struct nilfs_node *nilfs_node = VTOI(vp);
uint64_t file_size;
vsize_t len;
int error, resid;

DPRINTF(WRITE, ("nilfs_write called\n"));

/* can this happen? some filingsystems have this check */
if (uio->uio_offset < 0)
return EINVAL;
if (uio->uio_resid == 0)
return 0;

/* protect against rogue programs writing raw directories or links */
if ((ioflag & IO_ALTSEMANTICS) == 0) {
if (vp->v_type == VDIR)
return EISDIR;
/* all but regular files just give EINVAL for now */
if (vp->v_type != VREG)
return EINVAL;
}

assert(nilfs_node);
panic("nilfs_write() called\n");

/* remember old file size */
assert(nilfs_node);
file_size = nilfs_rw64(nilfs_node->inode.i_size);

/* if explicitly asked to append, uio_offset can be wrong? */
if (ioflag & IO_APPEND)
uio->uio_offset = file_size;

#if 0
extended = (uio->uio_offset + uio->uio_resid > file_size);
if (extended) {
DPRINTF(WRITE, ("extending file from %"PRIu64" to %"PRIu64"\n",
file_size, uio->uio_offset + uio->uio_resid));
error = nilfs_grow_node(nilfs_node, uio->uio_offset + uio->uio_resid);
if (error)
return error;
file_size = uio->uio_offset + uio->uio_resid;
}
#endif

/* write contents using buffercache */
uobj = &vp->v_uobj;
resid = uio->uio_resid;
error = 0;

uvm_vnp_setwritesize(vp, file_size);
while (uio->uio_resid > 0) {
/* maximise length to file extremity */
len = MIN(file_size - uio->uio_offset, uio->uio_resid);
if (len == 0)
break;

/* ubc, here we come, prepare to trap */
error = ubc_uiomove(uobj, uio, len, advice,
UBC_WRITE | UBC_VNODE_FLAGS(vp));
if (error)
break;
}
uvm_vnp_setsize(vp, file_size);

/* mark node changed and request update */
nilfs_node->i_flags |= IN_CHANGE | IN_UPDATE;
if (vp->v_mount->mnt_flag & MNT_RELATIME)
nilfs_node->i_flags |= IN_ACCESS;

/*
* XXX TODO FFS has code here to reset setuid & setgid when we're not
* the superuser as a precaution against tampering.
*/

if (error) {
/* bring back file size to its former size */
/* take notice of its errors? */
// (void) nilfs_chsize(vp, (u_quad_t) old_size, NOCRED);

/* roll back uio */
uio->uio_offset -= resid - uio->uio_resid;
uio->uio_resid = resid;
} else {
/* if we write and we're synchronous, update node */
if ((resid > uio->uio_resid) && ((ioflag & IO_SYNC) == IO_SYNC))
error = nilfs_update(vp, NULL, NULL, NULL, UPDATE_WAIT);
}

return error;
}

/* --------------------------------------------------------------------- */

/*
* bmap functionality that translates logical block numbers to the virtual
* block numbers to be stored on the vnode itself.
*
* Important alert!
*
* If runp is not NULL, the number of contiguous blocks __starting from the
* next block after the queried block__ will be returned in runp.
*/

int
nilfs_trivial_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;
} */ *ap = v;
struct vnode *vp = ap->a_vp; /* our node */
struct vnode **vpp = ap->a_vpp; /* return node */
daddr_t *bnp = ap->a_bnp; /* translated */
daddr_t bn = ap->a_bn; /* original */
int *runp = ap->a_runp;
struct nilfs_node *node = VTOI(vp);
uint64_t *l2vmap;
uint32_t blocksize;
int blks, run, error;

DPRINTF(TRANSLATE, ("nilfs_bmap() called\n"));
/* XXX could return `-1' to indicate holes/zero's */

blocksize = node->nilfsdev->blocksize;
blks = MAXPHYS / blocksize;

/* get mapping memory */
l2vmap = malloc(sizeof(uint64_t) * blks, M_TEMP, M_WAITOK);

/* get virtual block numbers for the vnode's buffer span */
error = nilfs_btree_nlookup(node, bn, blks, l2vmap);
if (error) {
free(l2vmap, M_TEMP);
return error;
}

/* store virtual blocks on our own vp */
if (vpp)
*vpp = vp;

/* start at virt[0] */
*bnp = l2vmap[0];

/* get runlength */
run = 1;
while ((run < blks) && (l2vmap[run] == *bnp + run))
run++;
run--; /* see comment at start of function */

/* set runlength */
if (runp)
*runp = run;

DPRINTF(TRANSLATE, ("\tstart %"PRIu64" -> %"PRIu64" run %d\n",
bn, *bnp, run));

/* mark not translated on virtual block number 0 */
if (*bnp == 0)
*bnp = -1;

/* return success */
free(l2vmap, M_TEMP);
return 0;
}

/* --------------------------------------------------------------------- */

static void
nilfs_read_filebuf(struct nilfs_node *node, struct buf *bp)
{
struct nilfs_device *nilfsdev = node->nilfsdev;
struct buf *nbp;
uint64_t *l2vmap, *v2pmap;
uint64_t from, blks;
uint32_t blocksize, buf_offset;
uint8_t *buf_pos;
int blk2dev = nilfsdev->blocksize / DEV_BSIZE;
int i, error;

/*
* Translate all the block sectors into a series of buffers to read
* asynchronously from the nilfs device. Note that this lookup may
* induce readin's too.
*/

blocksize = nilfsdev->blocksize;

from = bp->b_blkno;
blks = bp->b_bcount / blocksize;

DPRINTF(READ, ("\tread in from inode %"PRIu64" blkno %"PRIu64" "
"+ %"PRIu64" blocks\n", node->ino, from, blks));

DPRINTF(READ, ("\t\tblkno %"PRIu64" "
"+ %d bytes\n", bp->b_blkno, bp->b_bcount));

/* get mapping memory */
l2vmap = malloc(sizeof(uint64_t) * blks, M_TEMP, M_WAITOK);
v2pmap = malloc(sizeof(uint64_t) * blks, M_TEMP, M_WAITOK);

/* get virtual block numbers for the vnode's buffer span */
for (i = 0; i < blks; i++)
l2vmap[i] = from + i;

/* translate virtual block numbers to physical block numbers */
error = nilfs_nvtop(node, blks, l2vmap, v2pmap);
if (error)
goto out;

/* issue translated blocks */
bp->b_resid = bp->b_bcount;
for (i = 0; i < blks; i++) {
DPRINTF(READ, ("read_filebuf : ino %"PRIu64" blk %d -> "
"%"PRIu64" -> %"PRIu64"\n",
node->ino, i, l2vmap[i], v2pmap[i]));

buf_offset = i * blocksize;
buf_pos = (uint8_t *) bp->b_data + buf_offset;

/* note virtual block 0 marks not mapped */
if (l2vmap[i] == 0) {
memset(buf_pos, 0, blocksize);
nestiobuf_done(bp, blocksize, 0);
continue;
}

/* nest iobuf */
nbp = getiobuf(NULL, true);
nestiobuf_setup(bp, nbp, buf_offset, blocksize);
KASSERT(nbp->b_vp == node->vnode);
/* nbp is B_ASYNC */

nbp->b_lblkno = i;
nbp->b_blkno = v2pmap[i] * blk2dev; /* in DEV_BSIZE */
nbp->b_rawblkno = nbp->b_blkno;

VOP_STRATEGY(nilfsdev->devvp, nbp);
}

if ((bp->b_flags & B_ASYNC) == 0)
biowait(bp);

out:
free(l2vmap, M_TEMP);
free(v2pmap, M_TEMP);
if (error) {
bp->b_error = EIO;
biodone(bp);
}
}

static void
nilfs_write_filebuf(struct nilfs_node *node, struct buf *bp)
{
/* TODO pass on to segment collector */
panic("nilfs_strategy writing called\n");
}

int
nilfs_vfsstrategy(void *v)
{
struct vop_strategy_args /* {
struct vnode *a_vp;
struct buf *a_bp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct buf *bp = ap->a_bp;
struct nilfs_node *node = VTOI(vp);

DPRINTF(STRATEGY, ("nilfs_strategy called\n"));

/* check if we ought to be here */
if (vp->v_type == VBLK || vp->v_type == VCHR)
panic("nilfs_strategy: spec");

/* translate if needed and pass on */
if (bp->b_flags & B_READ) {
nilfs_read_filebuf(node, bp);
return bp->b_error;
}

/* send to segment collector */
nilfs_write_filebuf(node, bp);
return bp->b_error;
}

/* --------------------------------------------------------------------- */

int
nilfs_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 nilfs_node *node = VTOI(vp);
struct nilfs_dir_entry *ndirent;
struct dirent dirent;
struct buf *bp;
uint64_t file_size, diroffset, transoffset, blkoff;
uint64_t blocknr;
uint32_t blocksize = node->nilfsdev->blocksize;
uint8_t *pos, name_len;
int error;

DPRINTF(READDIR, ("nilfs_readdir called\n"));

if (vp->v_type != VDIR)
return ENOTDIR;

file_size = nilfs_rw64(node->inode.i_size);

/* we are called just as long as we keep on pushing data in */
error = 0;
if ((uio->uio_offset < file_size) &&
(uio->uio_resid >= sizeof(struct dirent))) {
diroffset = uio->uio_offset;
transoffset = diroffset;

blocknr = diroffset / blocksize;
blkoff = diroffset % blocksize;
error = nilfs_bread(node, blocknr, 0, &bp);
if (error)
return EIO;
while (diroffset < file_size) {
DPRINTF(READDIR, ("readdir : offset = %"PRIu64"\n",
diroffset));
if (blkoff >= blocksize) {
blkoff = 0; blocknr++;
brelse(bp, BC_AGE);
error = nilfs_bread(node, blocknr, 0, &bp);
if (error)
return EIO;
}

/* read in one dirent */
pos = (uint8_t *) bp->b_data + blkoff;
ndirent = (struct nilfs_dir_entry *) pos;

name_len = ndirent->name_len;
memset(&dirent, 0, sizeof(struct dirent));
dirent.d_fileno = nilfs_rw64(ndirent->inode);
dirent.d_type = ndirent->file_type; /* 1:1 ? */
dirent.d_namlen = name_len;
strncpy(dirent.d_name, ndirent->name, name_len);
dirent.d_reclen = _DIRENT_SIZE(&dirent);
DPRINTF(READDIR, ("copying `%*.*s`\n", name_len,
name_len, dirent.d_name));

/*
* If there isn't enough space in the uio to return a
* whole dirent, break off read
*/
if (uio->uio_resid < _DIRENT_SIZE(&dirent))
break;

/* transfer */
if (name_len)
uiomove(&dirent, _DIRENT_SIZE(&dirent), uio);

/* advance */
diroffset += nilfs_rw16(ndirent->rec_len);
blkoff += nilfs_rw16(ndirent->rec_len);

/* remember the last entry we transferred */
transoffset = diroffset;
}
brelse(bp, BC_AGE);

/* pass on last transferred offset */
uio->uio_offset = transoffset;
}

if (ap->a_eofflag)
*ap->a_eofflag = (uio->uio_offset >= file_size);

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_lookup(void *v)
{
struct vop_lookup_v2_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct mount *mp = dvp->v_mount;
uint64_t ino;
const char *name;
int namelen, nameiop, islastcn, mounted_ro;
int vnodetp;
int error, found;

*vpp = NULL;

DPRINTF(LOOKUP, ("nilfs_lookup called\n"));

/* simplify/clarification flags */
nameiop = cnp->cn_nameiop;
islastcn = cnp->cn_flags & ISLASTCN;
mounted_ro = mp->mnt_flag & MNT_RDONLY;

/* check exec/dirread permissions first */
error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
if (error)
return error;

DPRINTF(LOOKUP, ("\taccess ok\n"));

/*
* If requesting a modify on the last path element on a read-only
* filingsystem, reject lookup; XXX why is this repeated in every FS ?
*/
if (islastcn && mounted_ro && (nameiop == DELETE || nameiop == RENAME))
return EROFS;

DPRINTF(LOOKUP, ("\tlooking up cnp->cn_nameptr '%s'\n",
cnp->cn_nameptr));
/* look in the namecache */
if (cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
cnp->cn_nameiop, cnp->cn_flags, NULL, vpp)) {
return *vpp == NULLVP ? ENOENT : 0;
}

DPRINTF(LOOKUP, ("\tNOT found in cache\n"));

/*
* Obviously, the file is not (anymore) in the namecache, we have to
* search for it. There are three basic cases: '.', '..' and others.
*
* Following the guidelines of VOP_LOOKUP manpage and tmpfs.
*/
error = 0;
if ((cnp->cn_namelen == 1) && (cnp->cn_nameptr[0] == '.')) {
DPRINTF(LOOKUP, ("\tlookup '.'\n"));
/* special case 1 '.' */
vref(dvp);
*vpp = dvp;
/* done */
} else if (cnp->cn_flags & ISDOTDOT) {
/* special case 2 '..' */
DPRINTF(LOOKUP, ("\tlookup '..'\n"));

/* get our node */
name = "..";
namelen = 2;
error = nilfs_lookup_name_in_dir(dvp, name, namelen,
&ino, &found);
if (error)
goto out;
if (!found)
error = ENOENT;

if (error == 0) {
DPRINTF(LOOKUP, ("\tfound '..'\n"));
/* try to create/reuse the node */
error = vcache_get(mp, &ino, sizeof(ino), vpp);

if (!error) {
DPRINTF(LOOKUP,
("\tnode retrieved/created OK\n"));
}
}
} else {
DPRINTF(LOOKUP, ("\tlookup file\n"));
/* all other files */
/* lookup filename in the directory returning its inode */
name = cnp->cn_nameptr;
namelen = cnp->cn_namelen;
error = nilfs_lookup_name_in_dir(dvp, name, namelen,
&ino, &found);
if (error)
goto out;
if (!found) {
DPRINTF(LOOKUP, ("\tNOT found\n"));
/*
* UGH, didn't find name. If we're creating or
* renaming on the last name this is OK and we ought
* to return EJUSTRETURN if its allowed to be created.
*/
error = ENOENT;
if (islastcn &&
(nameiop == CREATE || nameiop == RENAME))
error = 0;
if (!error) {
error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
if (!error) {
error = EJUSTRETURN;
}
}
/* done */
} else {
/* try to create/reuse the node */
error = vcache_get(mp, &ino, sizeof(ino), vpp);
if (!error) {
/*
* If we are not at the last path component
* and found a non-directory or non-link entry
* (which may itself be pointing to a
* directory), raise an error.
*/
vnodetp = (*vpp)->v_type;
if ((vnodetp != VDIR) && (vnodetp != VLNK)) {
if (!islastcn) {
vrele(*vpp);
*vpp = NULL;
error = ENOTDIR;
}
}

}
}
}

out:
/*
* Store result in the cache if requested. If we are creating a file,
* the file might not be found and thus putting it into the namecache
* might be seen as negative caching.
*/
if (error == 0 && nameiop != CREATE)
cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen,
cnp->cn_flags);

DPRINTFIF(LOOKUP, error, ("nilfs_lookup returning error %d\n", error));

if (error)
return error;
return 0;
}

/* --------------------------------------------------------------------- */

static void
nilfs_ctime_to_timespec(struct timespec *ts, uint64_t ctime)
{
ts->tv_sec = ctime;
ts->tv_nsec = 0;
}

int
nilfs_getattr(void *v)
{
struct vop_getattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
kauth_cred_t a_cred;
struct lwp *a_l;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct vattr *vap = ap->a_vap;
struct nilfs_node *node = VTOI(vp);
struct nilfs_inode *inode = &node->inode;

DPRINTF(VFSCALL, ("nilfs_getattr called\n"));

/* basic info */
vattr_null(vap);
vap->va_type = vp->v_type;
vap->va_mode = nilfs_rw16(inode->i_mode) & ALLPERMS;
vap->va_nlink = nilfs_rw16(inode->i_links_count);
vap->va_uid = nilfs_rw32(inode->i_uid);
vap->va_gid = nilfs_rw32(inode->i_gid);
vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
vap->va_fileid = node->ino;
vap->va_size = nilfs_rw64(inode->i_size);
vap->va_blocksize = node->nilfsdev->blocksize;

/* times */
nilfs_ctime_to_timespec(&vap->va_atime, nilfs_rw64(inode->i_mtime));
nilfs_ctime_to_timespec(&vap->va_mtime, nilfs_rw64(inode->i_mtime));
nilfs_ctime_to_timespec(&vap->va_ctime, nilfs_rw64(inode->i_ctime));
nilfs_ctime_to_timespec(&vap->va_birthtime, nilfs_rw64(inode->i_ctime));

vap->va_gen = nilfs_rw32(inode->i_generation);
vap->va_flags = 0; /* vattr flags */
vap->va_bytes = nilfs_rw64(inode->i_blocks) * vap->va_blocksize;
vap->va_filerev = vap->va_gen; /* XXX file revision? same as gen? */
vap->va_vaflags = 0; /* XXX chflags flags */

return 0;
}

/* --------------------------------------------------------------------- */

#if 0
static int
nilfs_chown(struct vnode *vp, uid_t new_uid, gid_t new_gid,
kauth_cred_t cred)
{
return EINVAL;
}

static int
nilfs_chmod(struct vnode *vp, mode_t mode, kauth_cred_t cred)
{

return EINVAL;
}

/* exported */
int
nilfs_chsize(struct vnode *vp, u_quad_t newsize, kauth_cred_t cred)
{
return EINVAL;
}

static int
nilfs_chflags(struct vnode *vp, mode_t mode, kauth_cred_t cred)
{
return EINVAL;
}

static int
nilfs_chtimes(struct vnode *vp,
struct timespec *atime, struct timespec *mtime,
struct timespec *birthtime, int setattrflags,
kauth_cred_t cred)
{
return EINVAL;
}
#endif

int
nilfs_setattr(void *v)
{
struct vop_setattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
kauth_cred_t a_cred;
struct lwp *a_l;
} */ *ap = v;
struct vnode *vp = ap->a_vp;

vp = vp;
DPRINTF(VFSCALL, ("nilfs_setattr called\n"));
return EINVAL;
}

/* --------------------------------------------------------------------- */

/*
* Return POSIX pathconf information for NILFS file systems.
*/
int
nilfs_pathconf(void *v)
{
struct vop_pathconf_args /* {
struct vnode *a_vp;
int a_name;
register_t *a_retval;
} */ *ap = v;
uint32_t bits;

DPRINTF(VFSCALL, ("nilfs_pathconf called\n"));

switch (ap->a_name) {
case _PC_LINK_MAX:
*ap->a_retval = (1<<16)-1; /* 16 bits */
return 0;
case _PC_NAME_MAX:
*ap->a_retval = NILFS_MAXNAMLEN;
return 0;
case _PC_PATH_MAX:
*ap->a_retval = PATH_MAX;
return 0;
case _PC_PIPE_BUF:
*ap->a_retval = PIPE_BUF;
return 0;
case _PC_CHOWN_RESTRICTED:
*ap->a_retval = 1;
return 0;
case _PC_NO_TRUNC:
*ap->a_retval = 1;
return 0;
case _PC_SYNC_IO:
*ap->a_retval = 0; /* synchronised is off for performance */
return 0;
case _PC_FILESIZEBITS:
/* 64 bit file offsets -> 2+floor(2log(2^64-1)) = 2 + 63 = 65 */
bits = 64; /* XXX ought to deliver 65 */
#if 0
if (nilfs_node)
bits = 64 * vp->v_mount->mnt_dev_bshift;
#endif
*ap->a_retval = bits;
return 0;
default:
return genfs_pathconf(ap);
}
}

/* --------------------------------------------------------------------- */

int
nilfs_open(void *v)
{
struct vop_open_args /* {
struct vnode *a_vp;
int a_mode;
kauth_cred_t a_cred;
struct proc *a_p;
} */ *ap = v;
int flags;

DPRINTF(VFSCALL, ("nilfs_open called\n"));

/*
* Files marked append-only must be opened for appending.
*/
flags = 0;
if ((flags & APPEND) && (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
return (EPERM);

return 0;
}

/* --------------------------------------------------------------------- */

int
nilfs_close(void *v)
{
struct vop_close_args /* {
struct vnode *a_vp;
int a_fflag;
kauth_cred_t a_cred;
struct proc *a_p;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct nilfs_node *nilfs_node = VTOI(vp);

DPRINTF(VFSCALL, ("nilfs_close called\n"));
nilfs_node = nilfs_node; /* shut up gcc */

mutex_enter(vp->v_interlock);
if (vrefcnt(vp) > 1)
nilfs_itimes(nilfs_node, NULL, NULL, NULL);
mutex_exit(vp->v_interlock);

return 0;
}

/* --------------------------------------------------------------------- */

static int
nilfs_check_possible(struct vnode *vp, struct vattr *vap, accmode_t accmode)
{
int flags;

/* check if we are allowed to write */
switch (vap->va_type) {
case VDIR:
case VLNK:
case VREG:
/*
* normal nodes: check if we're on a read-only mounted
* filingsystem and bomb out if we're trying to write.
*/
if ((accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
return EROFS;
break;
case VBLK:
case VCHR:
case VSOCK:
case VFIFO:
/*
* special nodes: even on read-only mounted filingsystems
* these are allowed to be written to if permissions allow.
*/
break;
default:
/* no idea what this is */
return EINVAL;
}

/* noone may write immutable files */
/* TODO: get chflags(2) flags */
flags = 0;
if ((accmode & VWRITE) && (flags & IMMUTABLE))
return EPERM;

return 0;
}

static int
nilfs_check_permitted(struct vnode *vp, struct vattr *vap, accmode_t accmode,
kauth_cred_t cred)
{

/* ask the generic genfs_can_access to advice on security */
return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode,
vp->v_type, vap->va_mode), vp, NULL, genfs_can_access(vp, cred,
vap->va_uid, vap->va_gid, vap->va_mode, NULL, accmode));
}

int
nilfs_access(void *v)
{
struct vop_access_args /* {
struct vnode *a_vp;
accmode_t a_accmode;
kauth_cred_t a_cred;
struct proc *a_p;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
accmode_t accmode = ap->a_accmode;
kauth_cred_t cred = ap->a_cred;
/* struct nilfs_node *nilfs_node = VTOI(vp); */
struct vattr vap;
int error;

DPRINTF(VFSCALL, ("nilfs_access called\n"));

error = VOP_GETATTR(vp, &vap, NULL);
if (error)
return error;

error = nilfs_check_possible(vp, &vap, accmode);
if (error)
return error;

error = nilfs_check_permitted(vp, &vap, accmode, cred);

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_create(void *v)
{
struct vop_create_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct vattr *vap = ap->a_vap;
struct componentname *cnp = ap->a_cnp;
int error;

DPRINTF(VFSCALL, ("nilfs_create called\n"));
error = nilfs_create_node(dvp, vpp, vap, cnp);

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_mknod(void *v)
{
struct vop_mknod_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct vattr *vap = ap->a_vap;
struct componentname *cnp = ap->a_cnp;
int error;

DPRINTF(VFSCALL, ("nilfs_mknod called\n"));
error = nilfs_create_node(dvp, vpp, vap, cnp);

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_mkdir(void *v)
{
struct vop_mkdir_v3_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct vattr *vap = ap->a_vap;
struct componentname *cnp = ap->a_cnp;
int error;

DPRINTF(VFSCALL, ("nilfs_mkdir called\n"));
error = nilfs_create_node(dvp, vpp, vap, cnp);

return error;
}

/* --------------------------------------------------------------------- */

static int
nilfs_do_link(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
{
struct nilfs_node *nilfs_node, *dir_node;
struct vattr vap;
int error;

DPRINTF(VFSCALL, ("nilfs_link called\n"));
KASSERT(dvp != vp);
KASSERT(vp->v_type != VDIR);
KASSERT(dvp->v_mount == vp->v_mount);

/* lock node */
error = vn_lock(vp, LK_EXCLUSIVE);
if (error)
return error;

/* get attributes */
dir_node = VTOI(dvp);
nilfs_node = VTOI(vp);

error = VOP_GETATTR(vp, &vap, FSCRED);
if (error) {
VOP_UNLOCK(vp);
return error;
}

/* check link count overflow */
if (vap.va_nlink >= (1<<16)-1) { /* uint16_t */
VOP_UNLOCK(vp);
return EMLINK;
}

error = nilfs_dir_attach(dir_node->ump, dir_node, nilfs_node,
&vap, cnp);
if (error)
VOP_UNLOCK(vp);
return error;
}

int
nilfs_link(void *v)
{
struct vop_link_v2_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct componentname *cnp = ap->a_cnp;
int error;

error = nilfs_do_link(dvp, vp, cnp);
if (error)
VOP_ABORTOP(dvp, cnp);

return error;
}

/* --------------------------------------------------------------------- */

static int
nilfs_do_symlink(struct nilfs_node *nilfs_node, char *target)
{
return EROFS;
}

int
nilfs_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;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct vattr *vap = ap->a_vap;
struct componentname *cnp = ap->a_cnp;
struct nilfs_node *dir_node;
struct nilfs_node *nilfs_node;
int error;

DPRINTF(VFSCALL, ("nilfs_symlink called\n"));
DPRINTF(VFSCALL, ("\tlinking to `%s`\n", ap->a_target));
error = nilfs_create_node(dvp, vpp, vap, cnp);
KASSERT(((error == 0) && (*vpp != NULL)) || ((error && (*vpp == NULL))));
if (!error) {
dir_node = VTOI(dvp);
nilfs_node = VTOI(*vpp);
KASSERT(nilfs_node);
error = nilfs_do_symlink(nilfs_node, ap->a_target);
if (error) {
/* remove node */
nilfs_shrink_node(nilfs_node, 0);
nilfs_dir_detach(nilfs_node->ump, dir_node, nilfs_node, cnp);
}
}
return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_readlink(void *v)
{
struct vop_readlink_args /* {
struct vnode *a_vp;
struct uio *a_uio;
kauth_cred_t a_cred;
} */ *ap = v;
#if 0
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
kauth_cred_t cred = ap->a_cred;
struct nilfs_node *nilfs_node;
struct pathcomp pathcomp;
struct vattr vattr;
uint8_t *pathbuf, *targetbuf, *tmpname;
uint8_t *pathpos, *targetpos;
char *mntonname;
int pathlen, targetlen, namelen, mntonnamelen, len, l_ci;
int first, error;
#endif
ap = ap;

DPRINTF(VFSCALL, ("nilfs_readlink called\n"));

return EROFS;
}

/* --------------------------------------------------------------------- */

/* note: i tried to follow the logic of the tmpfs rename code */
int
nilfs_rename(void *v)
{
struct vop_rename_args /* {
struct vnode *a_fdvp;
struct vnode *a_fvp;
struct componentname *a_fcnp;
struct vnode *a_tdvp;
struct vnode *a_tvp;
struct componentname *a_tcnp;
} */ *ap = v;
struct vnode *tvp = ap->a_tvp;
struct vnode *tdvp = ap->a_tdvp;
struct vnode *fvp = ap->a_fvp;
struct vnode *fdvp = ap->a_fdvp;
struct componentname *tcnp = ap->a_tcnp;
struct componentname *fcnp = ap->a_fcnp;
struct nilfs_node *fnode, *fdnode, *tnode, *tdnode;
struct vattr fvap, tvap;
int error;

DPRINTF(VFSCALL, ("nilfs_rename called\n"));

/* disallow cross-device renames */
if (fvp->v_mount != tdvp->v_mount ||
(tvp != NULL && fvp->v_mount != tvp->v_mount)) {
error = EXDEV;
goto out_unlocked;
}

fnode = VTOI(fvp);
fdnode = VTOI(fdvp);
tnode = (tvp == NULL) ? NULL : VTOI(tvp);
tdnode = VTOI(tdvp);

/* lock our source dir */
if (fdnode != tdnode) {
error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
if (error != 0)
goto out_unlocked;
}

/* get info about the node to be moved */
vn_lock(fvp, LK_SHARED | LK_RETRY);
error = VOP_GETATTR(fvp, &fvap, FSCRED);
VOP_UNLOCK(fvp);
KASSERT(error == 0);

/* check when to delete the old already existing entry */
if (tvp) {
/* get info about the node to be moved to */
error = VOP_GETATTR(tvp, &tvap, FSCRED);
KASSERT(error == 0);

/* if both dirs, make sure the destination is empty */
if (fvp->v_type == VDIR && tvp->v_type == VDIR) {
if (tvap.va_nlink > 2) {
error = ENOTEMPTY;
goto out;
}
}
/* if moving dir, make sure destination is dir too */
if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
error = ENOTDIR;
goto out;
}
/* if we're moving a non-directory, make sure dest is no dir */
if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
error = EISDIR;
goto out;
}
}

/* don't allow renaming directories across directory for now */
if (fdnode != tdnode) {
if (fvp->v_type == VDIR) {
error = EINVAL;
goto out;
}
}

/* remove existing entry if present */
if (tvp)
nilfs_dir_detach(tdnode->ump, tdnode, tnode, tcnp);

/* create new directory entry for the node */
error = nilfs_dir_attach(tdnode->ump, tdnode, fnode, &fvap, tcnp);
if (error)
goto out;

/* unlink old directory entry for the node, if failing, unattach new */
error = nilfs_dir_detach(tdnode->ump, fdnode, fnode, fcnp);
if (error)
nilfs_dir_detach(tdnode->ump, tdnode, fnode, tcnp);

out:
if (fdnode != tdnode)
VOP_UNLOCK(fdvp);

out_unlocked:
VOP_ABORTOP(tdvp, tcnp);
if (tdvp == tvp)
vrele(tdvp);
else
vput(tdvp);
if (tvp)
vput(tvp);
VOP_ABORTOP(fdvp, fcnp);

/* release source nodes. */
vrele(fdvp);
vrele(fvp);

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_remove(void *v)
{
struct vop_remove_v3_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
nlink_t ctx_vp_new_nlink;
} */ *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode *vp = ap->a_vp;
struct componentname *cnp = ap->a_cnp;
struct nilfs_node *dir_node = VTOI(dvp);
struct nilfs_node *nilfs_node = VTOI(vp);
struct nilfs_mount *ump = dir_node->ump;
int error;

DPRINTF(VFSCALL, ("nilfs_remove called\n"));
if (vp->v_type != VDIR) {
error = nilfs_dir_detach(ump, dir_node, nilfs_node, cnp);
DPRINTFIF(NODE, error, ("\tgot error removing file\n"));
} else {
DPRINTF(NODE, ("\tis a directory: perm. denied\n"));
error = EPERM;
}

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

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_rmdir(void *v)
{
struct vop_rmdir_v2_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_dvp;
struct componentname *cnp = ap->a_cnp;
struct nilfs_node *dir_node = VTOI(dvp);
struct nilfs_node *nilfs_node = VTOI(vp);
struct nilfs_mount *ump = dir_node->ump;
int refcnt, error;

DPRINTF(NOTIMPL, ("nilfs_rmdir called\n"));

/* don't allow '.' to be deleted */
if (dir_node == nilfs_node) {
vrele(vp);
return EINVAL;
}

/* check to see if the directory is empty */
error = 0;
refcnt = 2; /* XXX */
if (refcnt > 1) {
/* NOT empty */
vput(vp);
return ENOTEMPTY;
}

/* detach the node from the directory */
error = nilfs_dir_detach(ump, dir_node, nilfs_node, cnp);
if (error == 0) {
cache_purge(vp);
// cache_purge(dvp); /* XXX from msdosfs, why? */
}
DPRINTFIF(NODE, error, ("\tgot error removing file\n"));

/* put the node and exit */
vput(vp);

return error;
}

/* --------------------------------------------------------------------- */

int
nilfs_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;
struct proc *a_p;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
// struct nilfs_node *nilfs_node = VTOI(vp);
// int error, flags, wait;

DPRINTF(STRATEGY, ("nilfs_fsync called : %s, %s\n",
(ap->a_flags & FSYNC_WAIT) ? "wait":"no wait",
(ap->a_flags & FSYNC_DATAONLY) ? "data_only":"complete"));

vp = vp;
return 0;
}

/* --------------------------------------------------------------------- */

int
nilfs_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 vnode *vp = ap->a_vp;
struct nilfs_node *nilfs_node = VTOI(vp);
uint64_t file_size;

DPRINTF(LOCKING, ("nilfs_advlock called\n"));

assert(nilfs_node);
file_size = nilfs_rw64(nilfs_node->inode.i_size);

return lf_advlock(ap, &nilfs_node->lockf, file_size);
}

/* --------------------------------------------------------------------- */

/* Global vfs vnode data structures for nilfss */
int (**nilfs_vnodeop_p) __P((void *));

const struct vnodeopv_entry_desc nilfs_vnodeop_entries[] = {
{ &vop_default_desc, vn_default_error },
{ &vop_parsepath_desc, genfs_parsepath }, /* parsepath */
{ &vop_lookup_desc, nilfs_lookup }, /* lookup */
{ &vop_create_desc, nilfs_create }, /* create */
{ &vop_mknod_desc, nilfs_mknod }, /* mknod */ /* TODO */
{ &vop_open_desc, nilfs_open }, /* open */
{ &vop_close_desc, nilfs_close }, /* close */
{ &vop_access_desc, nilfs_access }, /* access */
{ &vop_accessx_desc, genfs_accessx }, /* accessx */
{ &vop_getattr_desc, nilfs_getattr }, /* getattr */
{ &vop_setattr_desc, nilfs_setattr }, /* setattr */ /* TODO chflags */
{ &vop_read_desc, nilfs_read }, /* read */
{ &vop_write_desc, nilfs_write }, /* write */ /* WRITE */
{ &vop_fallocate_desc, genfs_eopnotsupp }, /* fallocate */
{ &vop_fdiscard_desc, genfs_eopnotsupp }, /* fdiscard */
{ &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ /* TODO? */
{ &vop_ioctl_desc, genfs_enoioctl }, /* ioctl */ /* TODO? */
{ &vop_poll_desc, genfs_poll }, /* poll */ /* TODO/OK? */
{ &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */ /* ? */
{ &vop_revoke_desc, genfs_revoke }, /* revoke */ /* TODO? */
{ &vop_mmap_desc, genfs_mmap }, /* mmap */ /* OK? */
{ &vop_fsync_desc, nilfs_fsync }, /* fsync */
{ &vop_seek_desc, genfs_seek }, /* seek */
{ &vop_remove_desc, nilfs_remove }, /* remove */
{ &vop_link_desc, nilfs_link }, /* link */ /* TODO */
{ &vop_rename_desc, nilfs_rename }, /* rename */ /* TODO */
{ &vop_mkdir_desc, nilfs_mkdir }, /* mkdir */
{ &vop_rmdir_desc, nilfs_rmdir }, /* rmdir */
{ &vop_symlink_desc, nilfs_symlink }, /* symlink */ /* TODO */
{ &vop_readdir_desc, nilfs_readdir }, /* readdir */
{ &vop_readlink_desc, nilfs_readlink }, /* readlink */ /* TEST ME */
{ &vop_abortop_desc, genfs_abortop }, /* abortop */ /* TODO/OK? */
{ &vop_inactive_desc, nilfs_inactive }, /* inactive */
{ &vop_reclaim_desc, nilfs_reclaim }, /* reclaim */
{ &vop_lock_desc, genfs_lock }, /* lock */
{ &vop_unlock_desc, genfs_unlock }, /* unlock */
{ &vop_bmap_desc, nilfs_trivial_bmap }, /* bmap */ /* 1:1 bmap */
{ &vop_strategy_desc, nilfs_vfsstrategy },/* strategy */
/* { &vop_print_desc, nilfs_print }, */ /* print */
{ &vop_islocked_desc, genfs_islocked }, /* islocked */
{ &vop_pathconf_desc, nilfs_pathconf }, /* pathconf */
{ &vop_advlock_desc, nilfs_advlock }, /* advlock */ /* TEST ME */
{ &vop_bwrite_desc, vn_bwrite }, /* bwrite */ /* ->strategy */
{ &vop_getpages_desc, genfs_getpages }, /* getpages */
{ &vop_putpages_desc, genfs_putpages }, /* putpages */
{ NULL, NULL }
};

const struct vnodeopv_desc nilfs_vnodeop_opv_desc = {
&nilfs_vnodeop_p, nilfs_vnodeop_entries
};