Home | History | Annotate | Line # | Download | only in lfs
lfs_vnops.c revision 1.6 
      1 /*	$NetBSD: lfs_vnops.c,v 1.6 1994/12/14 13:03:50 mycroft Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1986, 1989, 1991, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  *
     35  *	@(#)lfs_vnops.c	8.8 (Berkeley) 8/10/94
     36  */
     37 
     38 #include <sys/param.h>
     39 #include <sys/systm.h>
     40 #include <sys/namei.h>
     41 #include <sys/resourcevar.h>
     42 #include <sys/kernel.h>
     43 #include <sys/file.h>
     44 #include <sys/stat.h>
     45 #include <sys/buf.h>
     46 #include <sys/proc.h>
     47 #include <sys/conf.h>
     48 #include <sys/mount.h>
     49 #include <sys/vnode.h>
     50 #include <sys/malloc.h>
     51 
     52 #include <vm/vm.h>
     53 
     54 #include <miscfs/specfs/specdev.h>
     55 #include <miscfs/fifofs/fifo.h>
     56 
     57 #include <ufs/ufs/quota.h>
     58 #include <ufs/ufs/inode.h>
     59 #include <ufs/ufs/dir.h>
     60 #include <ufs/ufs/ufsmount.h>
     61 #include <ufs/ufs/ufs_extern.h>
     62 
     63 #include <ufs/lfs/lfs.h>
     64 #include <ufs/lfs/lfs_extern.h>
     65 
     66 /* Global vfs data structures for lfs. */
     67 int (**lfs_vnodeop_p)();
     68 struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
     69 	{ &vop_default_desc, vn_default_error },
     70 	{ &vop_lookup_desc, ufs_lookup },		/* lookup */
     71 	{ &vop_create_desc, ufs_create },		/* create */
     72 	{ &vop_whiteout_desc, ufs_whiteout },		/* whiteout */
     73 	{ &vop_mknod_desc, ufs_mknod },			/* mknod */
     74 	{ &vop_open_desc, ufs_open },			/* open */
     75 	{ &vop_close_desc, lfs_close },			/* close */
     76 	{ &vop_access_desc, ufs_access },		/* access */
     77 	{ &vop_getattr_desc, lfs_getattr },		/* getattr */
     78 	{ &vop_setattr_desc, ufs_setattr },		/* setattr */
     79 	{ &vop_read_desc, lfs_read },			/* read */
     80 	{ &vop_write_desc, lfs_write },			/* write */
     81 	{ &vop_lease_desc, ufs_lease_check },		/* lease */
     82 	{ &vop_ioctl_desc, ufs_ioctl },			/* ioctl */
     83 	{ &vop_select_desc, ufs_select },		/* select */
     84 	{ &vop_mmap_desc, ufs_mmap },			/* mmap */
     85 	{ &vop_fsync_desc, lfs_fsync },			/* fsync */
     86 	{ &vop_seek_desc, ufs_seek },			/* seek */
     87 	{ &vop_remove_desc, ufs_remove },		/* remove */
     88 	{ &vop_link_desc, ufs_link },			/* link */
     89 	{ &vop_rename_desc, ufs_rename },		/* rename */
     90 	{ &vop_mkdir_desc, ufs_mkdir },			/* mkdir */
     91 	{ &vop_rmdir_desc, ufs_rmdir },			/* rmdir */
     92 	{ &vop_symlink_desc, ufs_symlink },		/* symlink */
     93 	{ &vop_readdir_desc, ufs_readdir },		/* readdir */
     94 	{ &vop_readlink_desc, ufs_readlink },		/* readlink */
     95 	{ &vop_abortop_desc, ufs_abortop },		/* abortop */
     96 	{ &vop_inactive_desc, lfs_inactive },		/* inactive */
     97 	{ &vop_reclaim_desc, lfs_reclaim },		/* reclaim */
     98 	{ &vop_lock_desc, ufs_lock },			/* lock */
     99 	{ &vop_unlock_desc, ufs_unlock },		/* unlock */
    100 	{ &vop_bmap_desc, ufs_bmap },			/* bmap */
    101 	{ &vop_strategy_desc, ufs_strategy },		/* strategy */
    102 	{ &vop_print_desc, ufs_print },			/* print */
    103 	{ &vop_islocked_desc, ufs_islocked },		/* islocked */
    104 	{ &vop_pathconf_desc, ufs_pathconf },		/* pathconf */
    105 	{ &vop_advlock_desc, ufs_advlock },		/* advlock */
    106 	{ &vop_blkatoff_desc, lfs_blkatoff },		/* blkatoff */
    107 	{ &vop_valloc_desc, lfs_valloc },		/* valloc */
    108 	{ &vop_vfree_desc, lfs_vfree },			/* vfree */
    109 	{ &vop_truncate_desc, lfs_truncate },		/* truncate */
    110 	{ &vop_update_desc, lfs_update },		/* update */
    111 	{ &vop_bwrite_desc, lfs_bwrite },		/* bwrite */
    112 	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
    113 };
    114 struct vnodeopv_desc lfs_vnodeop_opv_desc =
    115 	{ &lfs_vnodeop_p, lfs_vnodeop_entries };
    116 
    117 int (**lfs_specop_p)();
    118 struct vnodeopv_entry_desc lfs_specop_entries[] = {
    119 	{ &vop_default_desc, vn_default_error },
    120 	{ &vop_lookup_desc, spec_lookup },		/* lookup */
    121 	{ &vop_create_desc, spec_create },		/* create */
    122 	{ &vop_mknod_desc, spec_mknod },		/* mknod */
    123 	{ &vop_open_desc, spec_open },			/* open */
    124 	{ &vop_close_desc, ufsspec_close },		/* close */
    125 	{ &vop_access_desc, ufs_access },		/* access */
    126 	{ &vop_getattr_desc, lfs_getattr },		/* getattr */
    127 	{ &vop_setattr_desc, ufs_setattr },		/* setattr */
    128 	{ &vop_read_desc, ufsspec_read },		/* read */
    129 	{ &vop_write_desc, ufsspec_write },		/* write */
    130 	{ &vop_lease_desc, spec_lease_check },		/* lease */
    131 	{ &vop_ioctl_desc, spec_ioctl },		/* ioctl */
    132 	{ &vop_select_desc, spec_select },		/* select */
    133 	{ &vop_mmap_desc, spec_mmap },			/* mmap */
    134 	{ &vop_fsync_desc, spec_fsync },		/* fsync */
    135 	{ &vop_seek_desc, spec_seek },			/* seek */
    136 	{ &vop_remove_desc, spec_remove },		/* remove */
    137 	{ &vop_link_desc, spec_link },			/* link */
    138 	{ &vop_rename_desc, spec_rename },		/* rename */
    139 	{ &vop_mkdir_desc, spec_mkdir },		/* mkdir */
    140 	{ &vop_rmdir_desc, spec_rmdir },		/* rmdir */
    141 	{ &vop_symlink_desc, spec_symlink },		/* symlink */
    142 	{ &vop_readdir_desc, spec_readdir },		/* readdir */
    143 	{ &vop_readlink_desc, spec_readlink },		/* readlink */
    144 	{ &vop_abortop_desc, spec_abortop },		/* abortop */
    145 	{ &vop_inactive_desc, lfs_inactive },		/* inactive */
    146 	{ &vop_reclaim_desc, lfs_reclaim },		/* reclaim */
    147 	{ &vop_lock_desc, ufs_lock },			/* lock */
    148 	{ &vop_unlock_desc, ufs_unlock },		/* unlock */
    149 	{ &vop_bmap_desc, spec_bmap },			/* bmap */
    150 	{ &vop_strategy_desc, spec_strategy },		/* strategy */
    151 	{ &vop_print_desc, ufs_print },			/* print */
    152 	{ &vop_islocked_desc, ufs_islocked },		/* islocked */
    153 	{ &vop_pathconf_desc, spec_pathconf },		/* pathconf */
    154 	{ &vop_advlock_desc, spec_advlock },		/* advlock */
    155 	{ &vop_blkatoff_desc, spec_blkatoff },		/* blkatoff */
    156 	{ &vop_valloc_desc, spec_valloc },		/* valloc */
    157 	{ &vop_vfree_desc, lfs_vfree },			/* vfree */
    158 	{ &vop_truncate_desc, spec_truncate },		/* truncate */
    159 	{ &vop_update_desc, lfs_update },		/* update */
    160 	{ &vop_bwrite_desc, lfs_bwrite },		/* bwrite */
    161 	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
    162 };
    163 struct vnodeopv_desc lfs_specop_opv_desc =
    164 	{ &lfs_specop_p, lfs_specop_entries };
    165 
    166 #ifdef FIFO
    167 int (**lfs_fifoop_p)();
    168 struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
    169 	{ &vop_default_desc, vn_default_error },
    170 	{ &vop_lookup_desc, fifo_lookup },		/* lookup */
    171 	{ &vop_create_desc, fifo_create },		/* create */
    172 	{ &vop_mknod_desc, fifo_mknod },		/* mknod */
    173 	{ &vop_open_desc, fifo_open },			/* open */
    174 	{ &vop_close_desc, ufsfifo_close },		/* close */
    175 	{ &vop_access_desc, ufs_access },		/* access */
    176 	{ &vop_getattr_desc, lfs_getattr },		/* getattr */
    177 	{ &vop_setattr_desc, ufs_setattr },		/* setattr */
    178 	{ &vop_read_desc, ufsfifo_read },		/* read */
    179 	{ &vop_write_desc, ufsfifo_write },		/* write */
    180 	{ &vop_lease_desc, fifo_lease_check },		/* lease */
    181 	{ &vop_ioctl_desc, fifo_ioctl },		/* ioctl */
    182 	{ &vop_select_desc, fifo_select },		/* select */
    183 	{ &vop_mmap_desc, fifo_mmap },			/* mmap */
    184 	{ &vop_fsync_desc, fifo_fsync },		/* fsync */
    185 	{ &vop_seek_desc, fifo_seek },			/* seek */
    186 	{ &vop_remove_desc, fifo_remove },		/* remove */
    187 	{ &vop_link_desc, fifo_link },			/* link */
    188 	{ &vop_rename_desc, fifo_rename },		/* rename */
    189 	{ &vop_mkdir_desc, fifo_mkdir },		/* mkdir */
    190 	{ &vop_rmdir_desc, fifo_rmdir },		/* rmdir */
    191 	{ &vop_symlink_desc, fifo_symlink },		/* symlink */
    192 	{ &vop_readdir_desc, fifo_readdir },		/* readdir */
    193 	{ &vop_readlink_desc, fifo_readlink },		/* readlink */
    194 	{ &vop_abortop_desc, fifo_abortop },		/* abortop */
    195 	{ &vop_inactive_desc, lfs_inactive },		/* inactive */
    196 	{ &vop_reclaim_desc, lfs_reclaim },		/* reclaim */
    197 	{ &vop_lock_desc, ufs_lock },			/* lock */
    198 	{ &vop_unlock_desc, ufs_unlock },		/* unlock */
    199 	{ &vop_bmap_desc, fifo_bmap },			/* bmap */
    200 	{ &vop_strategy_desc, fifo_strategy },		/* strategy */
    201 	{ &vop_print_desc, ufs_print },			/* print */
    202 	{ &vop_islocked_desc, ufs_islocked },		/* islocked */
    203 	{ &vop_pathconf_desc, fifo_pathconf },		/* pathconf */
    204 	{ &vop_advlock_desc, fifo_advlock },		/* advlock */
    205 	{ &vop_blkatoff_desc, fifo_blkatoff },		/* blkatoff */
    206 	{ &vop_valloc_desc, fifo_valloc },		/* valloc */
    207 	{ &vop_vfree_desc, lfs_vfree },			/* vfree */
    208 	{ &vop_truncate_desc, fifo_truncate },		/* truncate */
    209 	{ &vop_update_desc, lfs_update },		/* update */
    210 	{ &vop_bwrite_desc, lfs_bwrite },		/* bwrite */
    211 	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
    212 };
    213 struct vnodeopv_desc lfs_fifoop_opv_desc =
    214 	{ &lfs_fifoop_p, lfs_fifoop_entries };
    215 #endif /* FIFO */
    216 
    217 #define	LFS_READWRITE
    218 #include <ufs/ufs/ufs_readwrite.c>
    219 #undef	LFS_READWRITE
    220 
    221 /*
    222  * Synch an open file.
    223  */
    224 /* ARGSUSED */
    225 lfs_fsync(ap)
    226 	struct vop_fsync_args /* {
    227 		struct vnode *a_vp;
    228 		struct ucred *a_cred;
    229 		int a_waitfor;
    230 		struct proc *a_p;
    231 	} */ *ap;
    232 {
    233 	struct timeval tv;
    234 
    235 	tv = time;
    236 	return (VOP_UPDATE(ap->a_vp, &tv, &tv,
    237 	    ap->a_waitfor == MNT_WAIT ? LFS_SYNC : 0));
    238 }
    239 
    240 /*
    241  * These macros are used to bracket UFS directory ops, so that we can
    242  * identify all the pages touched during directory ops which need to
    243  * be ordered and flushed atomically, so that they may be recovered.
    244  */
    245 #define	SET_DIROP(fs) {							\
    246 	if ((fs)->lfs_writer)						\
    247 		tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0);	\
    248 	++(fs)->lfs_dirops;						\
    249 	(fs)->lfs_doifile = 1;						\
    250 }
    251 
    252 #define	SET_ENDOP(fs) {							\
    253 	--(fs)->lfs_dirops;						\
    254 	if (!(fs)->lfs_dirops)						\
    255 		wakeup(&(fs)->lfs_writer);				\
    256 }
    257 
    258 #define	MARK_VNODE(dvp)	(dvp)->v_flag |= VDIROP
    259 
    260 int
    261 lfs_symlink(ap)
    262 	struct vop_symlink_args /* {
    263 		struct vnode *a_dvp;
    264 		struct vnode **a_vpp;
    265 		struct componentname *a_cnp;
    266 		struct vattr *a_vap;
    267 		char *a_target;
    268 	} */ *ap;
    269 {
    270 	int ret;
    271 
    272 	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
    273 	MARK_VNODE(ap->a_dvp);
    274 	ret = ufs_symlink(ap);
    275 	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
    276 	return (ret);
    277 }
    278 
    279 int
    280 lfs_mknod(ap)
    281 	struct vop_mknod_args /* {
    282 		struct vnode *a_dvp;
    283 		struct vnode **a_vpp;
    284 		struct componentname *a_cnp;
    285 		struct vattr *a_vap;
    286 	} */ *ap;
    287 {
    288 	int ret;
    289 
    290 	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
    291 	MARK_VNODE(ap->a_dvp);
    292 	ret = ufs_mknod(ap);
    293 	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
    294 	return (ret);
    295 }
    296 
    297 int
    298 lfs_create(ap)
    299 	struct vop_create_args /* {
    300 		struct vnode *a_dvp;
    301 		struct vnode **a_vpp;
    302 		struct componentname *a_cnp;
    303 		struct vattr *a_vap;
    304 	} */ *ap;
    305 {
    306 	int ret;
    307 
    308 	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
    309 	MARK_VNODE(ap->a_dvp);
    310 	ret = ufs_create(ap);
    311 	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
    312 	return (ret);
    313 }
    314 
    315 int
    316 lfs_mkdir(ap)
    317 	struct vop_mkdir_args /* {
    318 		struct vnode *a_dvp;
    319 		struct vnode **a_vpp;
    320 		struct componentname *a_cnp;
    321 		struct vattr *a_vap;
    322 	} */ *ap;
    323 {
    324 	int ret;
    325 
    326 	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
    327 	MARK_VNODE(ap->a_dvp);
    328 	ret = ufs_mkdir(ap);
    329 	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
    330 	return (ret);
    331 }
    332 
    333 int
    334 lfs_remove(ap)
    335 	struct vop_remove_args /* {
    336 		struct vnode *a_dvp;
    337 		struct vnode *a_vp;
    338 		struct componentname *a_cnp;
    339 	} */ *ap;
    340 {
    341 	int ret;
    342 
    343 	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
    344 	MARK_VNODE(ap->a_dvp);
    345 	MARK_VNODE(ap->a_vp);
    346 	ret = ufs_remove(ap);
    347 	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
    348 	return (ret);
    349 }
    350 
    351 int
    352 lfs_rmdir(ap)
    353 	struct vop_rmdir_args /* {
    354 		struct vnodeop_desc *a_desc;
    355 		struct vnode *a_dvp;
    356 		struct vnode *a_vp;
    357 		struct componentname *a_cnp;
    358 	} */ *ap;
    359 {
    360 	int ret;
    361 
    362 	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
    363 	MARK_VNODE(ap->a_dvp);
    364 	MARK_VNODE(ap->a_vp);
    365 	ret = ufs_rmdir(ap);
    366 	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
    367 	return (ret);
    368 }
    369 
    370 int
    371 lfs_link(ap)
    372 	struct vop_link_args /* {
    373 		struct vnode *a_vp;
    374 		struct vnode *a_tdvp;
    375 		struct componentname *a_cnp;
    376 	} */ *ap;
    377 {
    378 	int ret;
    379 
    380 	SET_DIROP(VTOI(ap->a_vp)->i_lfs);
    381 	MARK_VNODE(ap->a_vp);
    382 	ret = ufs_link(ap);
    383 	SET_ENDOP(VTOI(ap->a_vp)->i_lfs);
    384 	return (ret);
    385 }
    386 
    387 int
    388 lfs_rename(ap)
    389 	struct vop_rename_args  /* {
    390 		struct vnode *a_fdvp;
    391 		struct vnode *a_fvp;
    392 		struct componentname *a_fcnp;
    393 		struct vnode *a_tdvp;
    394 		struct vnode *a_tvp;
    395 		struct componentname *a_tcnp;
    396 	} */ *ap;
    397 {
    398 	int ret;
    399 
    400 	SET_DIROP(VTOI(ap->a_fdvp)->i_lfs);
    401 	MARK_VNODE(ap->a_fdvp);
    402 	MARK_VNODE(ap->a_tdvp);
    403 	ret = ufs_rename(ap);
    404 	SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
    405 	return (ret);
    406 }
    407 /* XXX hack to avoid calling ITIMES in getattr */
    408 int
    409 lfs_getattr(ap)
    410 	struct vop_getattr_args /* {
    411 		struct vnode *a_vp;
    412 		struct vattr *a_vap;
    413 		struct ucred *a_cred;
    414 		struct proc *a_p;
    415 	} */ *ap;
    416 {
    417 	register struct vnode *vp = ap->a_vp;
    418 	register struct inode *ip = VTOI(vp);
    419 	register struct vattr *vap = ap->a_vap;
    420 	/*
    421 	 * Copy from inode table
    422 	 */
    423 	vap->va_fsid = ip->i_dev;
    424 	vap->va_fileid = ip->i_number;
    425 	vap->va_mode = ip->i_mode & ~IFMT;
    426 	vap->va_nlink = ip->i_nlink;
    427 	vap->va_uid = ip->i_uid;
    428 	vap->va_gid = ip->i_gid;
    429 	vap->va_rdev = (dev_t)ip->i_rdev;
    430 	vap->va_size = ip->i_din.di_size;
    431 	vap->va_atime = ip->i_atime;
    432 	vap->va_mtime = ip->i_mtime;
    433 	vap->va_ctime = ip->i_ctime;
    434 	vap->va_flags = ip->i_flags;
    435 	vap->va_gen = ip->i_gen;
    436 	/* this doesn't belong here */
    437 	if (vp->v_type == VBLK)
    438 		vap->va_blocksize = BLKDEV_IOSIZE;
    439 	else if (vp->v_type == VCHR)
    440 		vap->va_blocksize = MAXBSIZE;
    441 	else
    442 		vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
    443 	vap->va_bytes = dbtob(ip->i_blocks);
    444 	vap->va_type = vp->v_type;
    445 	vap->va_filerev = ip->i_modrev;
    446 	return (0);
    447 }
    448 /*
    449  * Close called
    450  *
    451  * XXX -- we were using ufs_close, but since it updates the
    452  * times on the inode, we might need to bump the uinodes
    453  * count.
    454  */
    455 /* ARGSUSED */
    456 int
    457 lfs_close(ap)
    458 	struct vop_close_args /* {
    459 		struct vnode *a_vp;
    460 		int  a_fflag;
    461 		struct ucred *a_cred;
    462 		struct proc *a_p;
    463 	} */ *ap;
    464 {
    465 	register struct vnode *vp = ap->a_vp;
    466 	register struct inode *ip = VTOI(vp);
    467 	int mod;
    468 
    469 	if (vp->v_usecount > 1 && !(ip->i_flag & IN_LOCKED)) {
    470 		mod = ip->i_flag & IN_MODIFIED;
    471 		ITIMES(ip, &time, &time);
    472 		if (!mod && ip->i_flag & IN_MODIFIED)
    473 			ip->i_lfs->lfs_uinodes++;
    474 	}
    475 	return (0);
    476 }
    477 
    478 /*
    479  * Stub inactive routine that avoid calling ufs_inactive in some cases.
    480  */
    481 int lfs_no_inactive = 0;
    482 
    483 int
    484 lfs_inactive(ap)
    485 	struct vop_inactive_args /* {
    486 		struct vnode *a_vp;
    487 	} */ *ap;
    488 {
    489 
    490 	if (lfs_no_inactive)
    491 		return (0);
    492 	return (ufs_inactive(ap));
    493 }
    494 
    495 /*
    496  * Reclaim an inode so that it can be used for other purposes.
    497  */
    498 int
    499 lfs_reclaim(ap)
    500 	struct vop_reclaim_args /* {
    501 		struct vnode *a_vp;
    502 	} */ *ap;
    503 {
    504 	register struct vnode *vp = ap->a_vp;
    505 	int error;
    506 
    507 	if (error = ufs_reclaim(vp))
    508 		return (error);
    509 	FREE(vp->v_data, M_LFSNODE);
    510 	vp->v_data = NULL;
    511 	return (0);
    512 }
    513