Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/ufs/lfs/lfs_vnops.c

640 lines
20 KiB
C
Raw Blame History

/* $NetBSD: lfs_vnops.c,v 1.25 1999/03/29 21:54:26 perseant Exp $ */
/*-
* Copyright (c) 1999 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Konrad E. Schroder <perseant@hhhh.org>.
*
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* 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.
*/
/*
* Copyright (c) 1986, 1989, 1991, 1993, 1995
* The Regents of the University of California. 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/namei.h>
#include <sys/resourcevar.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/pool.h>
#include <sys/signalvar.h>
#include <vm/vm.h>
#include <miscfs/fifofs/fifo.h>
#include <miscfs/genfs/genfs.h>
#include <miscfs/specfs/specdev.h>
#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/dir.h>
#include <ufs/ufs/ufsmount.h>
#include <ufs/ufs/ufs_extern.h>
#include <ufs/lfs/lfs.h>
#include <ufs/lfs/lfs_extern.h>
/* Global vfs data structures for lfs. */
int (**lfs_vnodeop_p) __P((void *));
struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
{ &vop_default_desc, vn_default_error },
{ &vop_lookup_desc, ufs_lookup }, /* lookup */
{ &vop_create_desc, lfs_create }, /* create */
{ &vop_whiteout_desc, lfs_whiteout }, /* whiteout */
{ &vop_mknod_desc, lfs_mknod }, /* mknod */
{ &vop_open_desc, ufs_open }, /* open */
{ &vop_close_desc, lfs_close }, /* close */
{ &vop_access_desc, ufs_access }, /* access */
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
{ &vop_setattr_desc, ufs_setattr }, /* setattr */
{ &vop_read_desc, lfs_read }, /* read */
{ &vop_write_desc, lfs_write }, /* write */
{ &vop_lease_desc, ufs_lease_check }, /* lease */
{ &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
{ &vop_poll_desc, ufs_poll }, /* poll */
{ &vop_revoke_desc, ufs_revoke }, /* revoke */
{ &vop_mmap_desc, ufs_mmap }, /* mmap */
{ &vop_fsync_desc, lfs_fsync }, /* fsync */
{ &vop_seek_desc, ufs_seek }, /* seek */
{ &vop_remove_desc, lfs_remove }, /* remove */
{ &vop_link_desc, lfs_link }, /* link */
{ &vop_rename_desc, lfs_rename }, /* rename */
{ &vop_mkdir_desc, lfs_mkdir }, /* mkdir */
{ &vop_rmdir_desc, lfs_rmdir }, /* rmdir */
{ &vop_symlink_desc, lfs_symlink }, /* symlink */
{ &vop_readdir_desc, ufs_readdir }, /* readdir */
{ &vop_readlink_desc, ufs_readlink }, /* readlink */
{ &vop_abortop_desc, ufs_abortop }, /* abortop */
{ &vop_inactive_desc, ufs_inactive }, /* inactive */
{ &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
{ &vop_lock_desc, ufs_lock }, /* lock */
{ &vop_unlock_desc, ufs_unlock }, /* unlock */
{ &vop_bmap_desc, ufs_bmap }, /* bmap */
{ &vop_strategy_desc, ufs_strategy }, /* strategy */
{ &vop_print_desc, ufs_print }, /* print */
{ &vop_islocked_desc, ufs_islocked }, /* islocked */
{ &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
{ &vop_advlock_desc, ufs_advlock }, /* advlock */
{ &vop_blkatoff_desc, lfs_blkatoff }, /* blkatoff */
{ &vop_valloc_desc, lfs_valloc }, /* valloc */
{ &vop_vfree_desc, lfs_vfree }, /* vfree */
{ &vop_truncate_desc, lfs_truncate }, /* truncate */
{ &vop_update_desc, lfs_update }, /* update */
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
};
struct vnodeopv_desc lfs_vnodeop_opv_desc =
{ &lfs_vnodeop_p, lfs_vnodeop_entries };
int (**lfs_specop_p) __P((void *));
struct vnodeopv_entry_desc lfs_specop_entries[] = {
{ &vop_default_desc, vn_default_error },
{ &vop_lookup_desc, spec_lookup }, /* lookup */
{ &vop_create_desc, spec_create }, /* create */
{ &vop_mknod_desc, spec_mknod }, /* mknod */
{ &vop_open_desc, spec_open }, /* open */
{ &vop_close_desc, ufsspec_close }, /* close */
{ &vop_access_desc, ufs_access }, /* access */
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
{ &vop_setattr_desc, ufs_setattr }, /* setattr */
{ &vop_read_desc, ufsspec_read }, /* read */
{ &vop_write_desc, ufsspec_write }, /* write */
{ &vop_lease_desc, spec_lease_check }, /* lease */
{ &vop_ioctl_desc, spec_ioctl }, /* ioctl */
{ &vop_poll_desc, spec_poll }, /* poll */
{ &vop_revoke_desc, spec_revoke }, /* revoke */
{ &vop_mmap_desc, spec_mmap }, /* mmap */
{ &vop_fsync_desc, spec_fsync }, /* fsync */
{ &vop_seek_desc, spec_seek }, /* seek */
{ &vop_remove_desc, spec_remove }, /* remove */
{ &vop_link_desc, spec_link }, /* link */
{ &vop_rename_desc, spec_rename }, /* rename */
{ &vop_mkdir_desc, spec_mkdir }, /* mkdir */
{ &vop_rmdir_desc, spec_rmdir }, /* rmdir */
{ &vop_symlink_desc, spec_symlink }, /* symlink */
{ &vop_readdir_desc, spec_readdir }, /* readdir */
{ &vop_readlink_desc, spec_readlink }, /* readlink */
{ &vop_abortop_desc, spec_abortop }, /* abortop */
{ &vop_inactive_desc, ufs_inactive }, /* inactive */
{ &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
{ &vop_lock_desc, ufs_lock }, /* lock */
{ &vop_unlock_desc, ufs_unlock }, /* unlock */
{ &vop_bmap_desc, spec_bmap }, /* bmap */
{ &vop_strategy_desc, spec_strategy }, /* strategy */
{ &vop_print_desc, ufs_print }, /* print */
{ &vop_islocked_desc, ufs_islocked }, /* islocked */
{ &vop_pathconf_desc, spec_pathconf }, /* pathconf */
{ &vop_advlock_desc, spec_advlock }, /* advlock */
{ &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
{ &vop_valloc_desc, spec_valloc }, /* valloc */
{ &vop_vfree_desc, lfs_vfree }, /* vfree */
{ &vop_truncate_desc, spec_truncate }, /* truncate */
{ &vop_update_desc, lfs_update }, /* update */
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
};
struct vnodeopv_desc lfs_specop_opv_desc =
{ &lfs_specop_p, lfs_specop_entries };
int (**lfs_fifoop_p) __P((void *));
struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
{ &vop_default_desc, vn_default_error },
{ &vop_lookup_desc, fifo_lookup }, /* lookup */
{ &vop_create_desc, fifo_create }, /* create */
{ &vop_mknod_desc, fifo_mknod }, /* mknod */
{ &vop_open_desc, fifo_open }, /* open */
{ &vop_close_desc, ufsfifo_close }, /* close */
{ &vop_access_desc, ufs_access }, /* access */
{ &vop_getattr_desc, lfs_getattr }, /* getattr */
{ &vop_setattr_desc, ufs_setattr }, /* setattr */
{ &vop_read_desc, ufsfifo_read }, /* read */
{ &vop_write_desc, ufsfifo_write }, /* write */
{ &vop_lease_desc, fifo_lease_check }, /* lease */
{ &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
{ &vop_poll_desc, fifo_poll }, /* poll */
{ &vop_revoke_desc, fifo_revoke }, /* revoke */
{ &vop_mmap_desc, fifo_mmap }, /* mmap */
{ &vop_fsync_desc, fifo_fsync }, /* fsync */
{ &vop_seek_desc, fifo_seek }, /* seek */
{ &vop_remove_desc, fifo_remove }, /* remove */
{ &vop_link_desc, fifo_link }, /* link */
{ &vop_rename_desc, fifo_rename }, /* rename */
{ &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
{ &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
{ &vop_symlink_desc, fifo_symlink }, /* symlink */
{ &vop_readdir_desc, fifo_readdir }, /* readdir */
{ &vop_readlink_desc, fifo_readlink }, /* readlink */
{ &vop_abortop_desc, fifo_abortop }, /* abortop */
{ &vop_inactive_desc, ufs_inactive }, /* inactive */
{ &vop_reclaim_desc, lfs_reclaim }, /* reclaim */
{ &vop_lock_desc, ufs_lock }, /* lock */
{ &vop_unlock_desc, ufs_unlock }, /* unlock */
{ &vop_bmap_desc, fifo_bmap }, /* bmap */
{ &vop_strategy_desc, fifo_strategy }, /* strategy */
{ &vop_print_desc, ufs_print }, /* print */
{ &vop_islocked_desc, ufs_islocked }, /* islocked */
{ &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
{ &vop_advlock_desc, fifo_advlock }, /* advlock */
{ &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */
{ &vop_valloc_desc, fifo_valloc }, /* valloc */
{ &vop_vfree_desc, lfs_vfree }, /* vfree */
{ &vop_truncate_desc, fifo_truncate }, /* truncate */
{ &vop_update_desc, lfs_update }, /* update */
{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
};
struct vnodeopv_desc lfs_fifoop_opv_desc =
{ &lfs_fifoop_p, lfs_fifoop_entries };
#define LFS_READWRITE
#include <ufs/ufs/ufs_readwrite.c>
#undef LFS_READWRITE
/*
* Synch an open file.
*/
/* ARGSUSED */
int
lfs_fsync(v)
void *v;
{
struct vop_fsync_args /* {
struct vnode *a_vp;
struct ucred *a_cred;
int a_flags;
struct proc *a_p;
} */ *ap = v;
return (VOP_UPDATE(ap->a_vp, NULL, NULL,
(ap->a_flags & FSYNC_WAIT) != 0 ? LFS_SYNC : 0)); /* XXX */
}
/*
* These macros are used to bracket UFS directory ops, so that we can
* identify all the pages touched during directory ops which need to
* be ordered and flushed atomically, so that they may be recovered.
*/
/*
* XXX KS - Because we have to mark nodes VDIROP in order to prevent
* the cache from reclaiming them while a dirop is in progress, we must
* also manage the number of nodes so marked (otherwise we can run out).
* We do this by setting lfs_dirvcount to the number of marked vnodes; it
* is decremented during segment write, when VDIROP is taken off.
*/
#define SET_DIROP(fs) lfs_set_dirop(fs)
static int lfs_set_dirop __P((struct lfs *));
static int lfs_set_dirop(fs)
struct lfs *fs;
{
int error;
while (fs->lfs_writer || fs->lfs_dirvcount>LFS_MAXDIROP) {
if(fs->lfs_writer)
tsleep(&fs->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0);
if(fs->lfs_dirvcount > LFS_MAXDIROP) {
#ifdef DEBUG_LFS
printf("(dirvcount=%d)\n",fs->lfs_dirvcount);
#endif
if((error=tsleep(&fs->lfs_dirvcount, PCATCH|PUSER, "lfs_maxdirop", 0))!=0)
return error;
}
}
++fs->lfs_dirops;
fs->lfs_doifile = 1;
return 0;
}
#define SET_ENDOP(fs,str) { \
--(fs)->lfs_dirops; \
if (!(fs)->lfs_dirops) { \
wakeup(&(fs)->lfs_writer); \
if ((fs)->lfs_dirvcount > LFS_MAXDIROP) { \
++(fs)->lfs_writer; \
lfs_flush((fs),0); \
if(--(fs)->lfs_writer==0) \
wakeup(&(fs)->lfs_dirops); \
} \
} \
}
#define MARK_VNODE(dvp) do { \
if(!((dvp)->v_flag & VDIROP)) { \
lfs_vref(dvp); \
++VTOI((dvp))->i_lfs->lfs_dirvcount; \
} \
(dvp)->v_flag |= VDIROP; \
} while(0)
#define MAYBE_INACTIVE(fs,vp) do { \
if((vp) && ((vp)->v_flag & VDIROP) && (vp)->v_usecount == 1 \
&& VTOI(vp) && VTOI(vp)->i_ffs_nlink == 0) \
{ \
if (VOP_LOCK((vp), LK_EXCLUSIVE) == 0) { \
VOP_INACTIVE((vp),curproc); \
} \
} \
} while(0)
int
lfs_symlink(v)
void *v;
{
struct vop_symlink_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
char *a_target;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
ret = ufs_symlink(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"symilnk");
return (ret);
}
int
lfs_mknod(v)
void *v;
{
struct vop_mknod_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
ret = ufs_mknod(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"mknod");
return (ret);
}
int
lfs_create(v)
void *v;
{
struct vop_create_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
ret = ufs_create(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"create");
return (ret);
}
int
lfs_whiteout(v)
void *v;
{
struct vop_whiteout_args /* {
struct vnode *a_dvp;
struct componentname *a_cnp;
int a_flags;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
ret = ufs_whiteout(ap);
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"whiteout");
return (ret);
}
int
lfs_mkdir(v)
void *v;
{
struct vop_mkdir_args /* {
struct vnode *a_dvp;
struct vnode **a_vpp;
struct componentname *a_cnp;
struct vattr *a_vap;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
ret = ufs_mkdir(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,*(ap->a_vpp)); /* XXX KS */
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"mkdir");
return (ret);
}
int
lfs_remove(v)
void *v;
{
struct vop_remove_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
MARK_VNODE(ap->a_vp);
ret = ufs_remove(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_vp);
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"remove");
return (ret);
}
int
lfs_rmdir(v)
void *v;
{
struct vop_rmdir_args /* {
struct vnodeop_desc *a_desc;
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
MARK_VNODE(ap->a_vp);
ret = ufs_rmdir(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_vp);
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"rmdir");
return (ret);
}
int
lfs_link(v)
void *v;
{
struct vop_link_args /* {
struct vnode *a_dvp;
struct vnode *a_vp;
struct componentname *a_cnp;
} */ *ap = v;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_dvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_dvp);
ret = ufs_link(ap);
SET_ENDOP(VTOI(ap->a_dvp)->i_lfs,"link");
return (ret);
}
int
lfs_rename(v)
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;
int ret;
if((ret=SET_DIROP(VTOI(ap->a_fdvp)->i_lfs))!=0)
return ret;
MARK_VNODE(ap->a_fdvp);
MARK_VNODE(ap->a_tdvp);
ret = ufs_rename(ap);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_fvp);
MAYBE_INACTIVE(VTOI(ap->a_dvp)->i_lfs,ap->a_tvp);
SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs,"rename");
return (ret);
}
/* XXX hack to avoid calling ITIMES in getattr */
int
lfs_getattr(v)
void *v;
{
struct vop_getattr_args /* {
struct vnode *a_vp;
struct vattr *a_vap;
struct ucred *a_cred;
struct proc *a_p;
} */ *ap = v;
register struct vnode *vp = ap->a_vp;
register struct inode *ip = VTOI(vp);
register struct vattr *vap = ap->a_vap;
/*
* Copy from inode table
*/
vap->va_fsid = ip->i_dev;
vap->va_fileid = ip->i_number;
vap->va_mode = ip->i_ffs_mode & ~IFMT;
vap->va_nlink = ip->i_ffs_nlink;
vap->va_uid = ip->i_ffs_uid;
vap->va_gid = ip->i_ffs_gid;
vap->va_rdev = (dev_t)ip->i_ffs_rdev;
vap->va_size = ip->i_ffs_size;
vap->va_atime.tv_sec = ip->i_ffs_atime;
vap->va_atime.tv_nsec = ip->i_ffs_atimensec;
vap->va_mtime.tv_sec = ip->i_ffs_mtime;
vap->va_mtime.tv_nsec = ip->i_ffs_mtimensec;
vap->va_ctime.tv_sec = ip->i_ffs_ctime;
vap->va_ctime.tv_nsec = ip->i_ffs_ctimensec;
vap->va_flags = ip->i_ffs_flags;
vap->va_gen = ip->i_ffs_gen;
/* this doesn't belong here */
if (vp->v_type == VBLK)
vap->va_blocksize = BLKDEV_IOSIZE;
else if (vp->v_type == VCHR)
vap->va_blocksize = MAXBSIZE;
else
vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
vap->va_bytes = dbtob((u_quad_t)ip->i_ffs_blocks);
vap->va_type = vp->v_type;
vap->va_filerev = ip->i_modrev;
return (0);
}
/*
* Close called
*
* XXX -- we were using ufs_close, but since it updates the
* times on the inode, we might need to bump the uinodes
* count.
*/
/* ARGSUSED */
int
lfs_close(v)
void *v;
{
struct vop_close_args /* {
struct vnode *a_vp;
int a_fflag;
struct ucred *a_cred;
struct proc *a_p;
} */ *ap = v;
register struct vnode *vp = ap->a_vp;
register struct inode *ip = VTOI(vp);
int mod;
struct timespec ts;
simple_lock(&vp->v_interlock);
if (vp->v_usecount > 1) {
mod = ip->i_flag & IN_MODIFIED;
TIMEVAL_TO_TIMESPEC(&time, &ts);
LFS_ITIMES(ip, &ts, &ts, &ts);
if (!mod && ip->i_flag & IN_MODIFIED)
ip->i_lfs->lfs_uinodes++;
}
simple_unlock(&vp->v_interlock);
return (0);
}
/*
* Reclaim an inode so that it can be used for other purposes.
*/
int lfs_no_inactive = 0;
int
lfs_reclaim(v)
void *v;
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
struct proc *a_p;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
int error;
if ((error = ufs_reclaim(vp, ap->a_p)))
return (error);
pool_put(&lfs_inode_pool, vp->v_data);
vp->v_data = NULL;
return (0);
}
Reference in New Issue View Git Blame Copy Permalink