[unix-history] / 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.90 (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/malloc.h>

#include <vm/vm.h>

#include <miscfs/specfs/specdev.h>
#include <miscfs/fifofs/fifo.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 vnode *vp = ap->a_vp;
	register struct inode *ip = VTOI(vp);
	register struct uio *uio = ap->a_uio;
	register struct lfs *fs;
	struct buf *bp;
	daddr_t lbn, bn, rablock;
	off_t diff;
	int error = 0, size;
	long n, on;

#ifdef DIAGNOSTIC
	int type;
	if (uio->uio_rw != UIO_READ)
		panic("lfs_read mode");
	type = ip->i_mode & IFMT;
	if (type != IFDIR && type != IFREG && type != IFLNK)
		panic("lfs_read type");
	if (type == IFLNK && (int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
		panic("read short symlink");
#endif
	if (uio->uio_resid == 0)
		return (0);
	fs = ip->i_lfs;
	if (uio->uio_offset < 0 ||
	    (u_quad_t)uio->uio_offset + uio->uio_resid > fs->lfs_maxfilesize)
		return (EFBIG);
	ip->i_flag |= IACC;
	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);
		rablock = lbn + 1;
		if (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);
		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 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 */
	if (uio->uio_offset < 0 ||
	    (u_quad_t)uio->uio_offset + uio->uio_resid > fs->lfs_maxfilesize)
		return (EFBIG);
	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;

	tv = time;
	return (VOP_UPDATE(ap->a_vp, &tv, &tv,
	    ap->a_waitfor == MNT_WAIT ? LFS_SYNC : 0));
}

/*
 * 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;

	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) {							\
	if ((fs)->lfs_writer)						\
		tsleep(&(fs)->lfs_dirops, PRIBIO + 1, "lfs_dirop", 0);	\
	++(fs)->lfs_dirops;						\
	(fs)->lfs_doifile = 1;						\
}

#define	SET_ENDOP(fs) {							\
	--(fs)->lfs_dirops;						\
	if (!(fs)->lfs_dirops)						\
		wakeup(&(fs)->lfs_writer);				\
}

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