usr/src/sys/ufs/lfs/lfs_vnops.c

/*
 * Copyright (c) 1986, 1989, 1991 Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 *
 *	@(#)lfs_vnops.c	7.87 (Berkeley) %G%
 */

#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/specdev.h>
#include <sys/fifo.h>
#include <sys/malloc.h>

#include <vm/vm.h>

#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/dir.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)();
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_mknod_desc, lfs_mknod },			/* mknod */
	{ &vop_open_desc, ufs_open },			/* open */
	{ &vop_close_desc, ufs_close },			/* close */
	{ &vop_access_desc, ufs_access },		/* access */
	{ &vop_getattr_desc, ufs_getattr },		/* getattr */
	{ &vop_setattr_desc, ufs_setattr },		/* setattr */
	{ &vop_read_desc, lfs_read },			/* read */
	{ &vop_write_desc, lfs_write },			/* write */
	{ &vop_ioctl_desc, ufs_ioctl },			/* ioctl */
	{ &vop_select_desc, ufs_select },		/* select */
	{ &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, lfs_inactive },		/* inactive */
	{ &vop_reclaim_desc, ufs_reclaim },		/* reclaim */
	{ &vop_lock_desc, ufs_lock },			/* lock */
	{ &vop_unlock_desc, ufs_unlock },		/* unlock */
	{ &vop_bmap_desc, lfs_bmap },			/* bmap */
	{ &vop_strategy_desc, ufs_strategy },		/* strategy */
	{ &vop_print_desc, ufs_print },			/* print */
	{ &vop_islocked_desc, ufs_islocked },		/* islocked */
	{ &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(*)())NULL }
};
struct vnodeopv_desc lfs_vnodeop_opv_desc =
	{ &lfs_vnodeop_p, lfs_vnodeop_entries };

int (**lfs_specop_p)();
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, ufs_getattr },		/* getattr */
	{ &vop_setattr_desc, ufs_setattr },		/* setattr */
	{ &vop_read_desc, ufsspec_read },		/* read */
	{ &vop_write_desc, ufsspec_write },		/* write */
	{ &vop_ioctl_desc, spec_ioctl },		/* ioctl */
	{ &vop_select_desc, spec_select },		/* select */
	{ &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, lfs_inactive },		/* inactive */
	{ &vop_reclaim_desc, ufs_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_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(*)())NULL }
};
struct vnodeopv_desc lfs_specop_opv_desc =
	{ &lfs_specop_p, lfs_specop_entries };

#ifdef FIFO
int (**lfs_fifoop_p)();
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, ufs_getattr },		/* getattr */
	{ &vop_setattr_desc, ufs_setattr },		/* setattr */
	{ &vop_read_desc, ufsfifo_read },		/* read */
	{ &vop_write_desc, ufsfifo_write },		/* write */
	{ &vop_ioctl_desc, fifo_ioctl },		/* ioctl */
	{ &vop_select_desc, fifo_select },		/* select */
	{ &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, lfs_inactive },		/* inactive */
	{ &vop_reclaim_desc, ufs_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_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(*)())NULL }
};
struct vnodeopv_desc lfs_fifoop_opv_desc =
	{ &lfs_fifoop_p, lfs_fifoop_entries };
#endif /* FIFO */

/*
 * Vnode op for reading.
 */
/* ARGSUSED */
lfs_read(ap)
	struct vop_read_args /* {
		struct vnode *a_vp;
		struct uio *a_uio;
		int a_ioflag;
		struct ucred *a_cred;
	} */ *ap;
{
	register struct uio *uio = ap->a_uio;
	register struct inode *ip = VTOI(ap->a_vp);
	register struct lfs *fs;				/* LFS */
	struct buf *bp;
	daddr_t lbn, bn, rablock;
	int size, error = 0;
	long n, on, type;
	off_t diff;

#ifdef VERBOSE
	printf("lfs_read: ino %d\n", ip->i_number);
#endif
#ifdef DIAGNOSTIC
	if (uio->uio_rw != UIO_READ)
		panic("ufs_read mode");
	type = ip->i_mode & IFMT;
	if (type != IFDIR && type != IFREG && type != IFLNK)
		panic("ufs_read type");
#endif
	if (uio->uio_resid == 0)
		return (0);
	if (uio->uio_offset < 0)
		return (EINVAL);
	ip->i_flag |= IACC;

	fs = ip->i_lfs;						/* LFS */
	do {
		lbn = lblkno(fs, uio->uio_offset);
		on = blkoff(fs, uio->uio_offset);
		n = MIN((unsigned)(fs->lfs_bsize - on), uio->uio_resid);
		diff = ip->i_size - uio->uio_offset;
		if (diff <= 0)
			return (0);
		if (diff < n)
			n = diff;
		size = blksize(fs);				/* LFS */
		rablock = lbn + 1;
		if (ap->a_vp->v_lastr + 1 == lbn &&
		    lblktosize(fs, rablock) < ip->i_size)
			error = breadn(ITOV(ip), lbn, size, &rablock,
				&size, 1, NOCRED, &bp);
		else
			error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
		ap->a_vp->v_lastr = lbn;
		n = MIN(n, size - bp->b_resid);
		if (error) {
			brelse(bp);
			return (error);
		}
		error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
		if (n + on == fs->lfs_bsize || uio->uio_offset == ip->i_size)
			bp->b_flags |= B_AGE;
		brelse(bp);
	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	return (error);
}

/*
 * Vnode op for writing.
 */
lfs_write(ap)
	struct vop_write_args /* {
		struct vnode *a_vp;
		struct uio *a_uio;
		int a_ioflag;
		struct ucred *a_cred;
	} */ *ap;
{
	register struct vnode *vp = ap->a_vp;
	register struct uio *uio = ap->a_uio;
	struct proc *p = uio->uio_procp;
	register struct inode *ip = VTOI(vp);
	register struct lfs *fs;
	register ioflag = ap->a_ioflag;
	struct timeval tv;
	struct buf *bp;
	daddr_t lbn;
	off_t osize;
	int n, on, flags, newblock;
	int size, resid, error = 0;

#ifdef VERBOSE
	printf("lfs_write ino %d\n", ip->i_number);
#endif
#ifdef DIAGNOSTIC
	if (uio->uio_rw != UIO_WRITE)
		panic("lfs_write mode");
#endif
	switch (vp->v_type) {
	case VREG:
		if (ioflag & IO_APPEND)
			uio->uio_offset = ip->i_size;
		/* fall through */
	case VLNK:
		break;

	case VDIR:
		/* XXX This may not be correct for LFS. */
		if ((ioflag & IO_SYNC) == 0)
			panic("lfs_write nonsync dir write");
		break;

	default:
		panic("lfs_write type");
	}
	if (uio->uio_offset < 0)
		return (EINVAL);
	if (uio->uio_resid == 0)
		return (0);
	/*
	 * Maybe this should be above the vnode op call, but so long as
	 * file servers have no limits, i don't think it matters
	 */
	if (vp->v_type == VREG && p &&
	    uio->uio_offset + uio->uio_resid >
	      p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
		psignal(p, SIGXFSZ);
		return (EFBIG);
	}
	resid = uio->uio_resid;
	osize = ip->i_size;
	fs = ip->i_lfs;						/* LFS */
	flags = 0;
#ifdef NOTLFS
	if (ioflag & IO_SYNC)
		flags = B_SYNC;
#endif
	do {
		lbn = lblkno(fs, uio->uio_offset);
		on = blkoff(fs, uio->uio_offset);
		n = MIN((unsigned)(fs->lfs_bsize - on), uio->uio_resid);
		if (error = lfs_balloc(vp, n, lbn, &bp))
			break;
		if (uio->uio_offset + n > ip->i_size) {
			ip->i_size = uio->uio_offset + n;
			vnode_pager_setsize(vp, (u_long)ip->i_size);
		}
		size = blksize(fs);
		(void) vnode_pager_uncache(vp);
		n = MIN(n, size - bp->b_resid);
		error = uiomove(bp->b_un.b_addr + on, n, uio);
#ifdef NOTLFS							/* LFS */
		if (ioflag & IO_SYNC)
			(void) bwrite(bp);
		else if (n + on == fs->fs_bsize) {
			bp->b_flags |= B_AGE;
			bawrite(bp);
		} else
			bdwrite(bp);
		ip->i_flag |= IUPD|ICHG;
#else
		/* XXX This doesn't handle IO_SYNC. */
		LFS_UBWRITE(bp);
#endif
		if (ap->a_cred->cr_uid != 0)
			ip->i_mode &= ~(ISUID|ISGID);
	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	if (error && (ioflag & IO_UNIT)) {
		(void)VOP_TRUNCATE(vp, osize, ioflag & IO_SYNC, ap->a_cred,
		    uio->uio_procp);
		uio->uio_offset -= resid - uio->uio_resid;
		uio->uio_resid = resid;
	}
	if (!error && (ioflag & IO_SYNC)) {
		tv = time;
		error = VOP_UPDATE(vp, &tv, &tv, 1);
	}
	return (error);
}

/*
 * Synch an open file.
 */
/* ARGSUSED */
lfs_fsync(ap)
	struct vop_fsync_args /* {
		struct vnode *a_vp;
		struct ucred *a_cred;
		int a_waitfor;
		struct proc *a_p;
	} */ *ap;
{
	struct timeval tv;

#ifdef VERBOSE
	printf("lfs_fsync\n");
#endif
	tv = time;
	return (VOP_UPDATE(ap->a_vp, &tv, &tv, ap->a_waitfor == MNT_WAIT));
}

/*
 * Last reference to an inode, write the inode out and if necessary,
 * truncate and deallocate the file.
 */
int
lfs_inactive(ap)
	struct vop_inactive_args /* {
		struct vnode *a_vp;
	} */ *ap;
{
	extern int prtactive;
	register struct vnode *vp = ap->a_vp;
	register struct inode *ip;
	struct timeval tv;
	int mode, error;

#ifdef VERBOSE
	printf("lfs_inactive\n");
#endif
	if (prtactive && vp->v_usecount != 0)
		vprint("lfs_inactive: pushing active", vp);

	/* Get rid of inodes related to stale file handles. */
	ip = VTOI(vp);
	if (ip->i_mode == 0) {
		if ((vp->v_flag & VXLOCK) == 0)
			vgone(vp);
		return (0);
	}

	error = 0;
	ILOCK(ip);
	if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
#ifdef QUOTA
		if (!getinoquota(ip))
			(void)chkiq(ip, -1, NOCRED, 0);
#endif
		error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL);
		mode = ip->i_mode;
		ip->i_mode = 0;
		ip->i_rdev = 0;
		ip->i_flag |= IUPD|ICHG;
		VOP_VFREE(vp, ip->i_number, mode);
	}
	if (ip->i_flag&(IUPD|IACC|ICHG|IMOD)) {
		tv = time;
		VOP_UPDATE(vp, &tv, &tv, 0);
	}
	IUNLOCK(ip);
	ip->i_flag = 0;
	/*
	 * If we are done with the inode, reclaim it
	 * so that it can be reused immediately.
	 */
	if (vp->v_usecount == 0 && ip->i_mode == 0)
		vgone(vp);
	return (error);
}

/*
 * 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.
 */
#define	SET_DIROP(fs) {							\
	int __s;							\
	__s = splbio();							\
	if ((fs)->lfs_writer)						\
		tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs dirop", 0);	\
	++(fs)->lfs_dirops;						\
	(fs)->lfs_doifile = 1;						\
	splx(__s);							\
}

#define	SET_ENDOP(fs) {							\
	int __s;							\
	__s = splbio();							\
	--(fs)->lfs_dirops;						\
	if (!(fs)->lfs_dirops)						\
		wakeup(&(fs)->lfs_writer);				\
	splx(__s);							\
}

#define	MARK_VNODE(dvp)	(dvp)->v_flag |= VDIROP

int
lfs_symlink(ap)
	struct vop_symlink_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
		char *a_target;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	MARK_VNODE(ap->a_dvp);
	ret = ufs_symlink(ap);
	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	return (ret);
}

int
lfs_mknod(ap)
	struct vop_mknod_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	MARK_VNODE(ap->a_dvp);
	ret = ufs_mknod(ap);
	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	return (ret);
}

int
lfs_create(ap)
	struct vop_create_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	MARK_VNODE(ap->a_dvp);
	ret = ufs_create(ap);
	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	return (ret);
}

int
lfs_mkdir(ap)
	struct vop_mkdir_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	MARK_VNODE(ap->a_dvp);
	ret = ufs_mkdir(ap);
	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	return (ret);
}

int
lfs_remove(ap)
	struct vop_remove_args /* {
		struct vnode *a_dvp;
		struct vnode *a_vp;
		struct componentname *a_cnp;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	MARK_VNODE(ap->a_dvp);
	MARK_VNODE(ap->a_vp);
	ret = ufs_remove(ap);
	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	return (ret);
}

int
lfs_rmdir(ap)
	struct vop_rmdir_args /* {
		struct vnodeop_desc *a_desc;
		struct vnode *a_dvp;
		struct vnode *a_vp;
		struct componentname *a_cnp;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	MARK_VNODE(ap->a_dvp);
	MARK_VNODE(ap->a_vp);
	ret = ufs_rmdir(ap);
	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	return (ret);
}

int
lfs_link(ap)
	struct vop_link_args /* {
		struct vnode *a_vp;
		struct vnode *a_tdvp;
		struct componentname *a_cnp;
	} */ *ap;
{
	int ret;

	SET_DIROP(VTOI(ap->a_vp)->i_lfs);
	MARK_VNODE(ap->a_vp);
	ret = ufs_link(ap);
	SET_ENDOP(VTOI(ap->a_vp)->i_lfs);
	return (ret);
}

int
lfs_rename(ap)
	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;
{
	int ret;

	SET_DIROP(VTOI(ap->a_fdvp)->i_lfs);
	MARK_VNODE(ap->a_fdvp);
	MARK_VNODE(ap->a_tdvp);
	ret = ufs_rename(ap);
	SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
	return (ret);
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 1986, 1989, 1991 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* %sccs.include.redist.c%
	6	*
	7	* @(#)lfs_vnops.c 7.87 (Berkeley) %G%
	8	*/
	9
	10	#include <sys/param.h>
	11	#include <sys/systm.h>
	12	#include <sys/namei.h>
	13	#include <sys/resourcevar.h>
	14	#include <sys/kernel.h>
	15	#include <sys/file.h>
	16	#include <sys/stat.h>
	17	#include <sys/buf.h>
	18	#include <sys/proc.h>
	19	#include <sys/conf.h>
	20	#include <sys/mount.h>
	21	#include <sys/vnode.h>
	22	#include <sys/specdev.h>
	23	#include <sys/fifo.h>
	24	#include <sys/malloc.h>
	25
	26	#include <vm/vm.h>
	27
	28	#include <ufs/ufs/quota.h>
	29	#include <ufs/ufs/inode.h>
	30	#include <ufs/ufs/dir.h>
	31	#include <ufs/ufs/ufs_extern.h>
	32
	33	#include <ufs/lfs/lfs.h>
	34	#include <ufs/lfs/lfs_extern.h>
	35
	36	/* Global vfs data structures for lfs. */
	37	int (**lfs_vnodeop_p)();
	38	struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
	39	{ &vop_default_desc, vn_default_error },
	40	{ &vop_lookup_desc, ufs_lookup }, /* lookup */
	41	{ &vop_create_desc, lfs_create }, /* create */
	42	{ &vop_mknod_desc, lfs_mknod }, /* mknod */
	43	{ &vop_open_desc, ufs_open }, /* open */
	44	{ &vop_close_desc, ufs_close }, /* close */
	45	{ &vop_access_desc, ufs_access }, /* access */
	46	{ &vop_getattr_desc, ufs_getattr }, /* getattr */
	47	{ &vop_setattr_desc, ufs_setattr }, /* setattr */
	48	{ &vop_read_desc, lfs_read }, /* read */
	49	{ &vop_write_desc, lfs_write }, /* write */
	50	{ &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
	51	{ &vop_select_desc, ufs_select }, /* select */
	52	{ &vop_mmap_desc, ufs_mmap }, /* mmap */
	53	{ &vop_fsync_desc, lfs_fsync }, /* fsync */
	54	{ &vop_seek_desc, ufs_seek }, /* seek */
	55	{ &vop_remove_desc, lfs_remove }, /* remove */
	56	{ &vop_link_desc, lfs_link }, /* link */
	57	{ &vop_rename_desc, lfs_rename }, /* rename */
	58	{ &vop_mkdir_desc, lfs_mkdir }, /* mkdir */
	59	{ &vop_rmdir_desc, lfs_rmdir }, /* rmdir */
	60	{ &vop_symlink_desc, lfs_symlink }, /* symlink */
	61	{ &vop_readdir_desc, ufs_readdir }, /* readdir */
	62	{ &vop_readlink_desc, ufs_readlink }, /* readlink */
	63	{ &vop_abortop_desc, ufs_abortop }, /* abortop */
	64	{ &vop_inactive_desc, lfs_inactive }, /* inactive */
	65	{ &vop_reclaim_desc, ufs_reclaim }, /* reclaim */
	66	{ &vop_lock_desc, ufs_lock }, /* lock */
	67	{ &vop_unlock_desc, ufs_unlock }, /* unlock */
	68	{ &vop_bmap_desc, lfs_bmap }, /* bmap */
	69	{ &vop_strategy_desc, ufs_strategy }, /* strategy */
	70	{ &vop_print_desc, ufs_print }, /* print */
	71	{ &vop_islocked_desc, ufs_islocked }, /* islocked */
	72	{ &vop_advlock_desc, ufs_advlock }, /* advlock */
	73	{ &vop_blkatoff_desc, lfs_blkatoff }, /* blkatoff */
	74	{ &vop_valloc_desc, lfs_valloc }, /* valloc */
	75	{ &vop_vfree_desc, lfs_vfree }, /* vfree */
	76	{ &vop_truncate_desc, lfs_truncate }, /* truncate */
	77	{ &vop_update_desc, lfs_update }, /* update */
	78	{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
	79	{ (struct vnodeop_desc)NULL, (int()())NULL }
	80	};
	81	struct vnodeopv_desc lfs_vnodeop_opv_desc =
	82	{ &lfs_vnodeop_p, lfs_vnodeop_entries };
	83
	84	int (**lfs_specop_p)();
	85	struct vnodeopv_entry_desc lfs_specop_entries[] = {
	86	{ &vop_default_desc, vn_default_error },
	87	{ &vop_lookup_desc, spec_lookup }, /* lookup */
	88	{ &vop_create_desc, spec_create }, /* create */
	89	{ &vop_mknod_desc, spec_mknod }, /* mknod */
	90	{ &vop_open_desc, spec_open }, /* open */
	91	{ &vop_close_desc, ufsspec_close }, /* close */
	92	{ &vop_access_desc, ufs_access }, /* access */
	93	{ &vop_getattr_desc, ufs_getattr }, /* getattr */
	94	{ &vop_setattr_desc, ufs_setattr }, /* setattr */
	95	{ &vop_read_desc, ufsspec_read }, /* read */
	96	{ &vop_write_desc, ufsspec_write }, /* write */
	97	{ &vop_ioctl_desc, spec_ioctl }, /* ioctl */
	98	{ &vop_select_desc, spec_select }, /* select */
	99	{ &vop_mmap_desc, spec_mmap }, /* mmap */
	100	{ &vop_fsync_desc, spec_fsync }, /* fsync */
	101	{ &vop_seek_desc, spec_seek }, /* seek */
	102	{ &vop_remove_desc, spec_remove }, /* remove */
	103	{ &vop_link_desc, spec_link }, /* link */
	104	{ &vop_rename_desc, spec_rename }, /* rename */
	105	{ &vop_mkdir_desc, spec_mkdir }, /* mkdir */
	106	{ &vop_rmdir_desc, spec_rmdir }, /* rmdir */
	107	{ &vop_symlink_desc, spec_symlink }, /* symlink */
	108	{ &vop_readdir_desc, spec_readdir }, /* readdir */
	109	{ &vop_readlink_desc, spec_readlink }, /* readlink */
	110	{ &vop_abortop_desc, spec_abortop }, /* abortop */
	111	{ &vop_inactive_desc, lfs_inactive }, /* inactive */
	112	{ &vop_reclaim_desc, ufs_reclaim }, /* reclaim */
	113	{ &vop_lock_desc, ufs_lock }, /* lock */
	114	{ &vop_unlock_desc, ufs_unlock }, /* unlock */
	115	{ &vop_bmap_desc, spec_bmap }, /* bmap */
	116	{ &vop_strategy_desc, spec_strategy }, /* strategy */
	117	{ &vop_print_desc, ufs_print }, /* print */
	118	{ &vop_islocked_desc, ufs_islocked }, /* islocked */
	119	{ &vop_advlock_desc, spec_advlock }, /* advlock */
	120	{ &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
	121	{ &vop_valloc_desc, spec_valloc }, /* valloc */
	122	{ &vop_vfree_desc, lfs_vfree }, /* vfree */
	123	{ &vop_truncate_desc, spec_truncate }, /* truncate */
	124	{ &vop_update_desc, lfs_update }, /* update */
	125	{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
	126	{ (struct vnodeop_desc)NULL, (int()())NULL }
	127	};
	128	struct vnodeopv_desc lfs_specop_opv_desc =
	129	{ &lfs_specop_p, lfs_specop_entries };
	130
	131	#ifdef FIFO
	132	int (**lfs_fifoop_p)();
	133	struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
	134	{ &vop_default_desc, vn_default_error },
	135	{ &vop_lookup_desc, fifo_lookup }, /* lookup */
	136	{ &vop_create_desc, fifo_create }, /* create */
	137	{ &vop_mknod_desc, fifo_mknod }, /* mknod */
	138	{ &vop_open_desc, fifo_open }, /* open */
	139	{ &vop_close_desc, ufsfifo_close }, /* close */
	140	{ &vop_access_desc, ufs_access }, /* access */
	141	{ &vop_getattr_desc, ufs_getattr }, /* getattr */
	142	{ &vop_setattr_desc, ufs_setattr }, /* setattr */
	143	{ &vop_read_desc, ufsfifo_read }, /* read */
	144	{ &vop_write_desc, ufsfifo_write }, /* write */
	145	{ &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
	146	{ &vop_select_desc, fifo_select }, /* select */
	147	{ &vop_mmap_desc, fifo_mmap }, /* mmap */
	148	{ &vop_fsync_desc, fifo_fsync }, /* fsync */
	149	{ &vop_seek_desc, fifo_seek }, /* seek */
	150	{ &vop_remove_desc, fifo_remove }, /* remove */
	151	{ &vop_link_desc, fifo_link }, /* link */
	152	{ &vop_rename_desc, fifo_rename }, /* rename */
	153	{ &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
	154	{ &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
	155	{ &vop_symlink_desc, fifo_symlink }, /* symlink */
	156	{ &vop_readdir_desc, fifo_readdir }, /* readdir */
	157	{ &vop_readlink_desc, fifo_readlink }, /* readlink */
	158	{ &vop_abortop_desc, fifo_abortop }, /* abortop */
	159	{ &vop_inactive_desc, lfs_inactive }, /* inactive */
	160	{ &vop_reclaim_desc, ufs_reclaim }, /* reclaim */
	161	{ &vop_lock_desc, ufs_lock }, /* lock */
	162	{ &vop_unlock_desc, ufs_unlock }, /* unlock */
	163	{ &vop_bmap_desc, fifo_bmap }, /* bmap */
	164	{ &vop_strategy_desc, fifo_strategy }, /* strategy */
	165	{ &vop_print_desc, ufs_print }, /* print */
	166	{ &vop_islocked_desc, ufs_islocked }, /* islocked */
	167	{ &vop_advlock_desc, fifo_advlock }, /* advlock */
	168	{ &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */
	169	{ &vop_valloc_desc, fifo_valloc }, /* valloc */
	170	{ &vop_vfree_desc, lfs_vfree }, /* vfree */
	171	{ &vop_truncate_desc, fifo_truncate }, /* truncate */
	172	{ &vop_update_desc, lfs_update }, /* update */
	173	{ &vop_bwrite_desc, lfs_bwrite }, /* bwrite */
	174	{ (struct vnodeop_desc)NULL, (int()())NULL }
	175	};
	176	struct vnodeopv_desc lfs_fifoop_opv_desc =
	177	{ &lfs_fifoop_p, lfs_fifoop_entries };
	178	#endif /* FIFO */
	179
	180	/*
	181	* Vnode op for reading.
	182	*/
	183	/* ARGSUSED */
	184	lfs_read(ap)
	185	struct vop_read_args /* {
	186	struct vnode *a_vp;
	187	struct uio *a_uio;
	188	int a_ioflag;
	189	struct ucred *a_cred;
	190	} / ap;
	191	{
	192	register struct uio *uio = ap->a_uio;
	193	register struct inode *ip = VTOI(ap->a_vp);
	194	register struct lfs fs; / LFS */
	195	struct buf *bp;
	196	daddr_t lbn, bn, rablock;
	197	int size, error = 0;
	198	long n, on, type;
	199	off_t diff;
	200
	201	#ifdef VERBOSE
	202	printf("lfs_read: ino %d\n", ip->i_number);
	203	#endif
	204	#ifdef DIAGNOSTIC
	205	if (uio->uio_rw != UIO_READ)
	206	panic("ufs_read mode");
	207	type = ip->i_mode & IFMT;
	208	if (type != IFDIR && type != IFREG && type != IFLNK)
	209	panic("ufs_read type");
	210	#endif
	211	if (uio->uio_resid == 0)
	212	return (0);
	213	if (uio->uio_offset < 0)
	214	return (EINVAL);
	215	ip->i_flag \|= IACC;
	216
	217	fs = ip->i_lfs; /* LFS */
	218	do {
	219	lbn = lblkno(fs, uio->uio_offset);
	220	on = blkoff(fs, uio->uio_offset);
	221	n = MIN((unsigned)(fs->lfs_bsize - on), uio->uio_resid);
	222	diff = ip->i_size - uio->uio_offset;
	223	if (diff <= 0)
	224	return (0);
	225	if (diff < n)
	226	n = diff;
	227	size = blksize(fs); /* LFS */
	228	rablock = lbn + 1;
	229	if (ap->a_vp->v_lastr + 1 == lbn &&
	230	lblktosize(fs, rablock) < ip->i_size)
	231	error = breadn(ITOV(ip), lbn, size, &rablock,
	232	&size, 1, NOCRED, &bp);
	233	else
	234	error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
	235	ap->a_vp->v_lastr = lbn;
	236	n = MIN(n, size - bp->b_resid);
	237	if (error) {
	238	brelse(bp);
	239	return (error);
	240	}
	241	error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
	242	if (n + on == fs->lfs_bsize \|\| uio->uio_offset == ip->i_size)
	243	bp->b_flags \|= B_AGE;
	244	brelse(bp);
	245	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	246	return (error);
	247	}
	248
	249	/*
	250	* Vnode op for writing.
	251	*/
	252	lfs_write(ap)
	253	struct vop_write_args /* {
	254	struct vnode *a_vp;
	255	struct uio *a_uio;
	256	int a_ioflag;
	257	struct ucred *a_cred;
	258	} / ap;
	259	{
	260	register struct vnode *vp = ap->a_vp;
	261	register struct uio *uio = ap->a_uio;
	262	struct proc *p = uio->uio_procp;
	263	register struct inode *ip = VTOI(vp);
	264	register struct lfs *fs;
	265	register ioflag = ap->a_ioflag;
	266	struct timeval tv;
	267	struct buf *bp;
	268	daddr_t lbn;
	269	off_t osize;
	270	int n, on, flags, newblock;
	271	int size, resid, error = 0;
	272
	273	#ifdef VERBOSE
	274	printf("lfs_write ino %d\n", ip->i_number);
	275	#endif
	276	#ifdef DIAGNOSTIC
	277	if (uio->uio_rw != UIO_WRITE)
	278	panic("lfs_write mode");
	279	#endif
	280	switch (vp->v_type) {
	281	case VREG:
	282	if (ioflag & IO_APPEND)
	283	uio->uio_offset = ip->i_size;
	284	/* fall through */
	285	case VLNK:
	286	break;
	287
	288	case VDIR:
	289	/* XXX This may not be correct for LFS. */
	290	if ((ioflag & IO_SYNC) == 0)
	291	panic("lfs_write nonsync dir write");
	292	break;
	293
	294	default:
	295	panic("lfs_write type");
	296	}
	297	if (uio->uio_offset < 0)
	298	return (EINVAL);
	299	if (uio->uio_resid == 0)
	300	return (0);
	301	/*
	302	* Maybe this should be above the vnode op call, but so long as
	303	* file servers have no limits, i don't think it matters
	304	*/
	305	if (vp->v_type == VREG && p &&
	306	uio->uio_offset + uio->uio_resid >
	307	p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
	308	psignal(p, SIGXFSZ);
	309	return (EFBIG);
	310	}
	311	resid = uio->uio_resid;
	312	osize = ip->i_size;
	313	fs = ip->i_lfs; /* LFS */
	314	flags = 0;
	315	#ifdef NOTLFS
	316	if (ioflag & IO_SYNC)
	317	flags = B_SYNC;
	318	#endif
	319	do {
	320	lbn = lblkno(fs, uio->uio_offset);
	321	on = blkoff(fs, uio->uio_offset);
	322	n = MIN((unsigned)(fs->lfs_bsize - on), uio->uio_resid);
	323	if (error = lfs_balloc(vp, n, lbn, &bp))
	324	break;
	325	if (uio->uio_offset + n > ip->i_size) {
	326	ip->i_size = uio->uio_offset + n;
	327	vnode_pager_setsize(vp, (u_long)ip->i_size);
	328	}
	329	size = blksize(fs);
	330	(void) vnode_pager_uncache(vp);
	331	n = MIN(n, size - bp->b_resid);
	332	error = uiomove(bp->b_un.b_addr + on, n, uio);
	333	#ifdef NOTLFS /* LFS */
	334	if (ioflag & IO_SYNC)
	335	(void) bwrite(bp);
	336	else if (n + on == fs->fs_bsize) {
	337	bp->b_flags \|= B_AGE;
	338	bawrite(bp);
	339	} else
	340	bdwrite(bp);
	341	ip->i_flag \|= IUPD\|ICHG;
	342	#else
	343	/* XXX This doesn't handle IO_SYNC. */
	344	LFS_UBWRITE(bp);
	345	#endif
	346	if (ap->a_cred->cr_uid != 0)
	347	ip->i_mode &= ~(ISUID\|ISGID);
	348	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	349	if (error && (ioflag & IO_UNIT)) {
	350	(void)VOP_TRUNCATE(vp, osize, ioflag & IO_SYNC, ap->a_cred,
	351	uio->uio_procp);
	352	uio->uio_offset -= resid - uio->uio_resid;
	353	uio->uio_resid = resid;
	354	}
	355	if (!error && (ioflag & IO_SYNC)) {
	356	tv = time;
	357	error = VOP_UPDATE(vp, &tv, &tv, 1);
	358	}
	359	return (error);
	360	}
	361
	362	/*
	363	* Synch an open file.
	364	*/
	365	/* ARGSUSED */
	366	lfs_fsync(ap)
	367	struct vop_fsync_args /* {
	368	struct vnode *a_vp;
	369	struct ucred *a_cred;
	370	int a_waitfor;
	371	struct proc *a_p;
	372	} / ap;
	373	{
	374	struct timeval tv;
	375
	376	#ifdef VERBOSE
	377	printf("lfs_fsync\n");
	378	#endif
	379	tv = time;
	380	return (VOP_UPDATE(ap->a_vp, &tv, &tv, ap->a_waitfor == MNT_WAIT));
	381	}
	382
	383	/*
	384	* Last reference to an inode, write the inode out and if necessary,
	385	* truncate and deallocate the file.
	386	*/
	387	int
	388	lfs_inactive(ap)
	389	struct vop_inactive_args /* {
	390	struct vnode *a_vp;
	391	} / ap;
	392	{
	393	extern int prtactive;
	394	register struct vnode *vp = ap->a_vp;
	395	register struct inode *ip;
	396	struct timeval tv;
	397	int mode, error;
	398
	399	#ifdef VERBOSE
	400	printf("lfs_inactive\n");
	401	#endif
	402	if (prtactive && vp->v_usecount != 0)
	403	vprint("lfs_inactive: pushing active", vp);
	404
	405	/* Get rid of inodes related to stale file handles. */
	406	ip = VTOI(vp);
	407	if (ip->i_mode == 0) {
	408	if ((vp->v_flag & VXLOCK) == 0)
	409	vgone(vp);
	410	return (0);
	411	}
	412
	413	error = 0;
	414	ILOCK(ip);
	415	if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
	416	#ifdef QUOTA
	417	if (!getinoquota(ip))
	418	(void)chkiq(ip, -1, NOCRED, 0);
	419	#endif
	420	error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL);
	421	mode = ip->i_mode;
	422	ip->i_mode = 0;
	423	ip->i_rdev = 0;
	424	ip->i_flag \|= IUPD\|ICHG;
	425	VOP_VFREE(vp, ip->i_number, mode);
	426	}
	427	if (ip->i_flag&(IUPD\|IACC\|ICHG\|IMOD)) {
	428	tv = time;
	429	VOP_UPDATE(vp, &tv, &tv, 0);
	430	}
	431	IUNLOCK(ip);
	432	ip->i_flag = 0;
	433	/*
	434	* If we are done with the inode, reclaim it
	435	* so that it can be reused immediately.
	436	*/
	437	if (vp->v_usecount == 0 && ip->i_mode == 0)
	438	vgone(vp);
	439	return (error);
	440	}
	441
	442	/*
	443	* These macros are used to bracket UFS directory ops, so that we can
	444	* identify all the pages touched during directory ops which need to
	445	* be ordered and flushed atomically, so that they may be recovered.
	446	*/
	447	#define SET_DIROP(fs) { \
	448	int __s; \
	449	__s = splbio(); \
	450	if ((fs)->lfs_writer) \
	451	tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs dirop", 0); \
	452	++(fs)->lfs_dirops; \
	453	(fs)->lfs_doifile = 1; \
	454	splx(__s); \
	455	}
	456
	457	#define SET_ENDOP(fs) { \
	458	int __s; \
	459	__s = splbio(); \
	460	--(fs)->lfs_dirops; \
	461	if (!(fs)->lfs_dirops) \
	462	wakeup(&(fs)->lfs_writer); \
	463	splx(__s); \
	464	}
	465
	466	#define MARK_VNODE(dvp) (dvp)->v_flag \|= VDIROP
	467
	468	int
	469	lfs_symlink(ap)
	470	struct vop_symlink_args /* {
	471	struct vnode *a_dvp;
	472	struct vnode **a_vpp;
	473	struct componentname *a_cnp;
	474	struct vattr *a_vap;
	475	char *a_target;
	476	} / ap;
	477	{
	478	int ret;
	479
	480	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	481	MARK_VNODE(ap->a_dvp);
	482	ret = ufs_symlink(ap);
	483	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	484	return (ret);
	485	}
	486
	487	int
	488	lfs_mknod(ap)
	489	struct vop_mknod_args /* {
	490	struct vnode *a_dvp;
	491	struct vnode **a_vpp;
	492	struct componentname *a_cnp;
	493	struct vattr *a_vap;
	494	} / ap;
	495	{
	496	int ret;
	497
	498	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	499	MARK_VNODE(ap->a_dvp);
	500	ret = ufs_mknod(ap);
	501	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	502	return (ret);
	503	}
	504
	505	int
	506	lfs_create(ap)
	507	struct vop_create_args /* {
	508	struct vnode *a_dvp;
	509	struct vnode **a_vpp;
	510	struct componentname *a_cnp;
	511	struct vattr *a_vap;
	512	} / ap;
	513	{
	514	int ret;
	515
	516	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	517	MARK_VNODE(ap->a_dvp);
	518	ret = ufs_create(ap);
	519	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	520	return (ret);
	521	}
	522
	523	int
	524	lfs_mkdir(ap)
	525	struct vop_mkdir_args /* {
	526	struct vnode *a_dvp;
	527	struct vnode **a_vpp;
	528	struct componentname *a_cnp;
	529	struct vattr *a_vap;
	530	} / ap;
	531	{
	532	int ret;
	533
	534	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	535	MARK_VNODE(ap->a_dvp);
	536	ret = ufs_mkdir(ap);
	537	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	538	return (ret);
	539	}
	540
	541	int
	542	lfs_remove(ap)
	543	struct vop_remove_args /* {
	544	struct vnode *a_dvp;
	545	struct vnode *a_vp;
	546	struct componentname *a_cnp;
	547	} / ap;
	548	{
	549	int ret;
	550
	551	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	552	MARK_VNODE(ap->a_dvp);
	553	MARK_VNODE(ap->a_vp);
	554	ret = ufs_remove(ap);
	555	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	556	return (ret);
	557	}
	558
	559	int
	560	lfs_rmdir(ap)
	561	struct vop_rmdir_args /* {
	562	struct vnodeop_desc *a_desc;
	563	struct vnode *a_dvp;
	564	struct vnode *a_vp;
	565	struct componentname *a_cnp;
	566	} / ap;
	567	{
	568	int ret;
	569
	570	SET_DIROP(VTOI(ap->a_dvp)->i_lfs);
	571	MARK_VNODE(ap->a_dvp);
	572	MARK_VNODE(ap->a_vp);
	573	ret = ufs_rmdir(ap);
	574	SET_ENDOP(VTOI(ap->a_dvp)->i_lfs);
	575	return (ret);
	576	}
	577
	578	int
	579	lfs_link(ap)
	580	struct vop_link_args /* {
	581	struct vnode *a_vp;
	582	struct vnode *a_tdvp;
	583	struct componentname *a_cnp;
	584	} / ap;
	585	{
	586	int ret;
	587
	588	SET_DIROP(VTOI(ap->a_vp)->i_lfs);
	589	MARK_VNODE(ap->a_vp);
	590	ret = ufs_link(ap);
	591	SET_ENDOP(VTOI(ap->a_vp)->i_lfs);
	592	return (ret);
	593	}
	594
	595	int
	596	lfs_rename(ap)
	597	struct vop_rename_args /* {
	598	struct vnode *a_fdvp;
	599	struct vnode *a_fvp;
	600	struct componentname *a_fcnp;
	601	struct vnode *a_tdvp;
	602	struct vnode *a_tvp;
	603	struct componentname *a_tcnp;
	604	} / ap;
	605	{
	606	int ret;
	607
	608	SET_DIROP(VTOI(ap->a_fdvp)->i_lfs);
	609	MARK_VNODE(ap->a_fdvp);
	610	MARK_VNODE(ap->a_tdvp);
	611	ret = ufs_rename(ap);
	612	SET_ENDOP(VTOI(ap->a_fdvp)->i_lfs);
	613	return (ret);
	614	}