[unix-history] / usr / src / sys / ufs / ffs / ffs_vnops.c

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

#include <sys/param.h>
#include <sys/systm.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/lockf.h>
#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/dir.h>
#include <ufs/ufs/ufs_extern.h>

#include <ufs/ffs/fs.h>
#include <ufs/ffs/ffs_extern.h>

/* Global vfs data structures for ufs. */
int (**ffs_vnodeop_p)();
struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
	{ &vop_default_desc, vn_default_error },
	{ &vop_lookup_desc, ufs_lookup },		/* lookup */
	{ &vop_create_desc, ufs_create },		/* create */
	{ &vop_mknod_desc, ufs_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, ffs_read },		/* read */
	{ &vop_write_desc, ffs_write },		/* write */
	{ &vop_ioctl_desc, ufs_ioctl },		/* ioctl */
	{ &vop_select_desc, ufs_select },		/* select */
	{ &vop_mmap_desc, ufs_mmap },		/* mmap */
	{ &vop_fsync_desc, ffs_fsync },		/* fsync */
	{ &vop_seek_desc, ufs_seek },		/* seek */
	{ &vop_remove_desc, ufs_remove },		/* remove */
	{ &vop_link_desc, ufs_link },		/* link */
	{ &vop_rename_desc, ufs_rename },		/* rename */
	{ &vop_mkdir_desc, ufs_mkdir },		/* mkdir */
	{ &vop_rmdir_desc, ufs_rmdir },		/* rmdir */
	{ &vop_symlink_desc, ufs_symlink },		/* symlink */
	{ &vop_readdir_desc, ufs_readdir },		/* readdir */
	{ &vop_readlink_desc, ufs_readlink },		/* readlink */
	{ &vop_abortop_desc, ufs_abortop },		/* abortop */
	{ &vop_inactive_desc, ffs_inactive },		/* inactive */
	{ &vop_reclaim_desc, ufs_reclaim },		/* reclaim */
	{ &vop_lock_desc, ufs_lock },		/* lock */
	{ &vop_unlock_desc, ufs_unlock },		/* unlock */
	{ &vop_bmap_desc, ffs_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, ffs_blkatoff },		/* blkatoff */
	{ &vop_vget_desc, ffs_vget },		/* vget */
	{ &vop_valloc_desc, ffs_valloc },		/* valloc */
	{ &vop_vfree_desc, ffs_vfree },		/* vfree */
	{ &vop_truncate_desc, ffs_truncate },		/* truncate */
	{ &vop_update_desc, ffs_update },		/* update */
	{ &vop_bwrite_desc, bwrite },
	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
};
struct vnodeopv_desc ffs_vnodeop_opv_desc =
	{ &ffs_vnodeop_p, ffs_vnodeop_entries };

int (**ffs_specop_p)();
struct vnodeopv_entry_desc ffs_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, ffs_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_vget_desc, spec_vget },		/* vget */
	{ &vop_valloc_desc, spec_valloc },		/* valloc */
	{ &vop_vfree_desc, spec_vfree },		/* vfree */
	{ &vop_truncate_desc, spec_truncate },		/* truncate */
	{ &vop_update_desc, ffs_update },		/* update */
	{ &vop_bwrite_desc, bwrite },
	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
};
struct vnodeopv_desc ffs_specop_opv_desc =
	{ &ffs_specop_p, ffs_specop_entries };

#ifdef FIFO
int (**ffs_fifoop_p)();
struct vnodeopv_entry_desc ffs_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, ffs_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_vget_desc, fifo_vget },		/* vget */
	{ &vop_valloc_desc, fifo_valloc },		/* valloc */
	{ &vop_vfree_desc, fifo_vfree },		/* vfree */
	{ &vop_truncate_desc, fifo_truncate },		/* truncate */
	{ &vop_update_desc, ffs_update },		/* update */
	{ &vop_bwrite_desc, bwrite },
	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
};
struct vnodeopv_desc ffs_fifoop_opv_desc =
	{ &ffs_fifoop_p, ffs_fifoop_entries };
#endif /* FIFO */


/*
 * Vnode op for reading.
 */
/* ARGSUSED */
ffs_read (ap)
	struct vop_read_args *ap;
#define vp (ap->a_vp)
#define uio (ap->a_uio)
#define ioflag (ap->a_ioflag)
#define cred (ap->a_cred)
{
	register struct inode *ip = VTOI(vp);
	register struct fs *fs;
	struct buf *bp;
	daddr_t lbn, bn, rablock;
	off_t diff;
	int rasize, error = 0;
	long size, n, on;

#ifdef DIAGNOSTIC
	int type;
	if (uio->uio_rw != UIO_READ)
		panic("ffs_read mode");
	type = ip->i_mode & IFMT;
	if (type != IFDIR && type != IFREG && type != IFLNK)
		panic("ffs_read type");
#endif
	if (uio->uio_resid == 0)
		return (0);
	if (uio->uio_offset < 0)
		return (EINVAL);
	ip->i_flag |= IACC;
	fs = ip->i_fs;
	do {
		lbn = lblkno(fs, uio->uio_offset);
		on = blkoff(fs, uio->uio_offset);
		n = MIN((unsigned)(fs->fs_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, ip, lbn);
		rablock = lbn + 1;
		if (vp->v_lastr + 1 == lbn &&
		    lblktosize(fs, rablock) < ip->i_size) {
			rasize = blksize(fs, ip, rablock);
			error = breadn(vp, lbn, size, &rablock,
				&rasize, 1, NOCRED, &bp);
		} else
			error = bread(vp, 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->fs_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);
}
#undef vp
#undef uio
#undef ioflag
#undef cred

/*
 * Vnode op for writing.
 */
ffs_write (ap)
	struct vop_write_args *ap;
#define vp (ap->a_vp)
#define uio (ap->a_uio)
#define ioflag (ap->a_ioflag)
#define cred (ap->a_cred)
{
	USES_VOP_TRUNCATE;
	USES_VOP_UPDATE;
	struct proc *p = uio->uio_procp;
	register struct inode *ip = VTOI(vp);
	register struct fs *fs;
	struct buf *bp;
	daddr_t lbn, bn;
	off_t osize;
	int n, on, flags;
	int size, resid, error = 0;

#ifdef DIAGNOSTIC
	if (uio->uio_rw != UIO_WRITE)
		panic("ffs_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:
		if ((ioflag & IO_SYNC) == 0)
			panic("ffs_write nonsync dir write");
		break;

	default:
		panic("ffs_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_fs;
	flags = 0;
	if (ioflag & IO_SYNC)
		flags = B_SYNC;
	do {
		lbn = lblkno(fs, uio->uio_offset);
		on = blkoff(fs, uio->uio_offset);
		n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
		if (n < fs->fs_bsize)
			flags |= B_CLRBUF;
		else
			flags &= ~B_CLRBUF;
		if (error = ffs_balloc(ip, lbn, on + n, cred, &bp, flags))
			break;
		bn = bp->b_blkno;
		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, ip, lbn);
		(void) vnode_pager_uncache(vp);
		n = MIN(n, size - bp->b_resid);
		error = uiomove(bp->b_un.b_addr + on, n, uio);
		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;
		if (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, cred);
		uio->uio_offset -= resid - uio->uio_resid;
		uio->uio_resid = resid;
	}
	if (!error && (ioflag & IO_SYNC))
		error = VOP_UPDATE(vp, &time, &time, 1);
	return (error);
}
#undef vp
#undef uio
#undef ioflag
#undef cred

/*
 * Synch an open file.
 */
/* ARGSUSED */
int
ffs_fsync (ap)
	struct vop_fsync_args *ap;
#define vp (ap->a_vp)
#define fflags (ap->a_fflags)
#define cred (ap->a_cred)
#define waitfor (ap->a_waitfor)
#define p (ap->a_p)
{
	USES_VOP_UPDATE;
	struct inode *ip = VTOI(vp);

	if (fflags & FWRITE)
		ip->i_flag |= ICHG;
	vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0);
	return (VOP_UPDATE(vp, &time, &time, waitfor == MNT_WAIT));
}
#undef vp
#undef fflags
#undef cred
#undef waitfor
#undef p

/*
 * Last reference to an inode, write the inode out and if necessary,
 * truncate and deallocate the file.
 */
int
ffs_inactive (ap)
	struct vop_inactive_args *ap;
#define vp (ap->a_vp)
#define p (ap->a_p)
{
	USES_VOP_TRUNCATE;
	USES_VOP_UPDATE;
	USES_VOP_VFREE;
	register struct inode *ip;
	int mode, error;
	extern int prtactive;

	if (prtactive && vp->v_usecount != 0)
		vprint("ffs_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);
		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))
		VOP_UPDATE(vp, &time, &time, 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);
}
#undef vp
#undef p
Commit	Line	Data
da7c5cc6	1	/*
7188ac27 KM	2	* Copyright (c) 1982, 1986, 1989 Regents of the University of California.
7188ac27 KM	3	* All rights reserved.
da7c5cc6	4	*
b702c21d	5	* %sccs.include.redist.c%
7188ac27	6	*
ea67b335	7	* @(#)ffs_vnops.c 7.76 (Berkeley) %G%
a6673c09 KB	8	*/
	9
	10	#include <sys/param.h>
	11	#include <sys/systm.h>
a6673c09 KB	12	#include <sys/resourcevar.h>
	13	#include <sys/kernel.h>
	14	#include <sys/file.h>
	15	#include <sys/stat.h>
	16	#include <sys/buf.h>
	17	#include <sys/proc.h>
	18	#include <sys/conf.h>
	19	#include <sys/mount.h>
	20	#include <sys/vnode.h>
	21	#include <sys/specdev.h>
	22	#include <sys/fifo.h>
	23	#include <sys/malloc.h>
	24
80e9de4e KM	25	#include <vm/vm.h>
80e9de4e KM	26
a6673c09 KB	27	#include <ufs/ufs/lockf.h>
	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/ffs/fs.h>
	34	#include <ufs/ffs/ffs_extern.h>
	35
	36	/* Global vfs data structures for ufs. */
9342689a JH	37	int (**ffs_vnodeop_p)();
	38	struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
	39	{ &vop_default_desc, vn_default_error },
	40	{ &vop_lookup_desc, ufs_lookup }, /* lookup */
	41	{ &vop_create_desc, ufs_create }, /* create */
	42	{ &vop_mknod_desc, ufs_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, ffs_read }, /* read */
	49	{ &vop_write_desc, ffs_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, ffs_fsync }, /* fsync */
	54	{ &vop_seek_desc, ufs_seek }, /* seek */
	55	{ &vop_remove_desc, ufs_remove }, /* remove */
	56	{ &vop_link_desc, ufs_link }, /* link */
	57	{ &vop_rename_desc, ufs_rename }, /* rename */
	58	{ &vop_mkdir_desc, ufs_mkdir }, /* mkdir */
	59	{ &vop_rmdir_desc, ufs_rmdir }, /* rmdir */
	60	{ &vop_symlink_desc, ufs_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, ffs_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, ffs_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, ffs_blkatoff }, /* blkatoff */
	74	{ &vop_vget_desc, ffs_vget }, /* vget */
	75	{ &vop_valloc_desc, ffs_valloc }, /* valloc */
	76	{ &vop_vfree_desc, ffs_vfree }, /* vfree */
	77	{ &vop_truncate_desc, ffs_truncate }, /* truncate */
	78	{ &vop_update_desc, ffs_update }, /* update */
	79	{ &vop_bwrite_desc, bwrite },
	80	{ (struct vnodeop_desc)NULL, (int()())NULL }
a6673c09	81	};
9342689a JH	82	struct vnodeopv_desc ffs_vnodeop_opv_desc =
9342689a JH	83	{ &ffs_vnodeop_p, ffs_vnodeop_entries };
528f664c	84
9342689a JH	85	int (**ffs_specop_p)();
	86	struct vnodeopv_entry_desc ffs_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 */
	91	{ &vop_open_desc, spec_open }, /* open */
	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 */
	100	{ &vop_mmap_desc, spec_mmap }, /* mmap */
	101	{ &vop_fsync_desc, spec_fsync }, /* fsync */
	102	{ &vop_seek_desc, spec_seek }, /* seek */
	103	{ &vop_remove_desc, spec_remove }, /* remove */
	104	{ &vop_link_desc, spec_link }, /* link */
	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, ffs_inactive }, /* inactive */
	113	{ &vop_reclaim_desc, ufs_reclaim }, /* reclaim */
	114	{ &vop_lock_desc, ufs_lock }, /* lock */
	115	{ &vop_unlock_desc, ufs_unlock }, /* unlock */
	116	{ &vop_bmap_desc, spec_bmap }, /* bmap */
	117	{ &vop_strategy_desc, spec_strategy }, /* strategy */
	118	{ &vop_print_desc, ufs_print }, /* print */
	119	{ &vop_islocked_desc, ufs_islocked }, /* islocked */
	120	{ &vop_advlock_desc, spec_advlock }, /* advlock */
	121	{ &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
	122	{ &vop_vget_desc, spec_vget }, /* vget */
	123	{ &vop_valloc_desc, spec_valloc }, /* valloc */
	124	{ &vop_vfree_desc, spec_vfree }, /* vfree */
	125	{ &vop_truncate_desc, spec_truncate }, /* truncate */
	126	{ &vop_update_desc, ffs_update }, /* update */
	127	{ &vop_bwrite_desc, bwrite },
	128	{ (struct vnodeop_desc)NULL, (int()())NULL }
9d5097aa	129	};
9342689a JH	130	struct vnodeopv_desc ffs_specop_opv_desc =
9342689a JH	131	{ &ffs_specop_p, ffs_specop_entries };
9d5097aa KM	132
9d5097aa KM	133	#ifdef FIFO
9342689a JH	134	int (**ffs_fifoop_p)();
	135	struct vnodeopv_entry_desc ffs_fifoop_entries[] = {
	136	{ &vop_default_desc, vn_default_error },
	137	{ &vop_lookup_desc, fifo_lookup }, /* lookup */
	138	{ &vop_create_desc, fifo_create }, /* create */
	139	{ &vop_mknod_desc, fifo_mknod }, /* mknod */
	140	{ &vop_open_desc, fifo_open }, /* open */
	141	{ &vop_close_desc, ufsfifo_close }, /* close */
	142	{ &vop_access_desc, ufs_access }, /* access */
	143	{ &vop_getattr_desc, ufs_getattr }, /* getattr */
	144	{ &vop_setattr_desc, ufs_setattr }, /* setattr */
	145	{ &vop_read_desc, ufsfifo_read }, /* read */
	146	{ &vop_write_desc, ufsfifo_write }, /* write */
	147	{ &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
	148	{ &vop_select_desc, fifo_select }, /* select */
	149	{ &vop_mmap_desc, fifo_mmap }, /* mmap */
	150	{ &vop_fsync_desc, fifo_fsync }, /* fsync */
	151	{ &vop_seek_desc, fifo_seek }, /* seek */
	152	{ &vop_remove_desc, fifo_remove }, /* remove */
	153	{ &vop_link_desc, fifo_link }, /* link */
	154	{ &vop_rename_desc, fifo_rename }, /* rename */
	155	{ &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
	156	{ &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
	157	{ &vop_symlink_desc, fifo_symlink }, /* symlink */
	158	{ &vop_readdir_desc, fifo_readdir }, /* readdir */
	159	{ &vop_readlink_desc, fifo_readlink }, /* readlink */
	160	{ &vop_abortop_desc, fifo_abortop }, /* abortop */
	161	{ &vop_inactive_desc, ffs_inactive }, /* inactive */
	162	{ &vop_reclaim_desc, ufs_reclaim }, /* reclaim */
	163	{ &vop_lock_desc, ufs_lock }, /* lock */
	164	{ &vop_unlock_desc, ufs_unlock }, /* unlock */
	165	{ &vop_bmap_desc, fifo_bmap }, /* bmap */
	166	{ &vop_strategy_desc, fifo_strategy }, /* strategy */
	167	{ &vop_print_desc, ufs_print }, /* print */
	168	{ &vop_islocked_desc, ufs_islocked }, /* islocked */
	169	{ &vop_advlock_desc, fifo_advlock }, /* advlock */
	170	{ &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */
	171	{ &vop_vget_desc, fifo_vget }, /* vget */
	172	{ &vop_valloc_desc, fifo_valloc }, /* valloc */
	173	{ &vop_vfree_desc, fifo_vfree }, /* vfree */
	174	{ &vop_truncate_desc, fifo_truncate }, /* truncate */
	175	{ &vop_update_desc, ffs_update }, /* update */
	176	{ &vop_bwrite_desc, bwrite },
	177	{ (struct vnodeop_desc)NULL, (int()())NULL }
9d5097aa	178	};
9342689a JH	179	struct vnodeopv_desc ffs_fifoop_opv_desc =
9342689a JH	180	{ &ffs_fifoop_p, ffs_fifoop_entries };
9d5097aa KM	181	#endif /* FIFO */
9d5097aa KM	182
d67a03eb	183
b373e060 KM	184	/*
	185	* Vnode op for reading.
	186	*/
	187	/* ARGSUSED */
9342689a JH	188	ffs_read (ap)
	189	struct vop_read_args *ap;
	190	#define vp (ap->a_vp)
	191	#define uio (ap->a_uio)
	192	#define ioflag (ap->a_ioflag)
	193	#define cred (ap->a_cred)
b373e060 KM	194	{
	195	register struct inode *ip = VTOI(vp);
	196	register struct fs *fs;
	197	struct buf *bp;
	198	daddr_t lbn, bn, rablock;
b7077901	199	off_t diff;
1ca49178 KM	200	int rasize, error = 0;
1ca49178 KM	201	long size, n, on;
b373e060	202
5b169cb7	203	#ifdef DIAGNOSTIC
b7077901	204	int type;
b373e060	205	if (uio->uio_rw != UIO_READ)
a6673c09	206	panic("ffs_read mode");
b373e060 KM	207	type = ip->i_mode & IFMT;
b373e060 KM	208	if (type != IFDIR && type != IFREG && type != IFLNK)
a6673c09	209	panic("ffs_read type");
5b169cb7	210	#endif
b373e060 KM	211	if (uio->uio_resid == 0)
	212	return (0);
	213	if (uio->uio_offset < 0)
	214	return (EINVAL);
	215	ip->i_flag \|= IACC;
	216	fs = ip->i_fs;
	217	do {
	218	lbn = lblkno(fs, uio->uio_offset);
	219	on = blkoff(fs, uio->uio_offset);
	220	n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
	221	diff = ip->i_size - uio->uio_offset;
	222	if (diff <= 0)
	223	return (0);
	224	if (diff < n)
	225	n = diff;
b373e060	226	size = blksize(fs, ip, lbn);
e16fa59e	227	rablock = lbn + 1;
20aa076b	228	if (vp->v_lastr + 1 == lbn &&
38f21582 KM	229	lblktosize(fs, rablock) < ip->i_size) {
38f21582 KM	230	rasize = blksize(fs, ip, rablock);
995d2177	231	error = breadn(vp, lbn, size, &rablock,
38f21582 KM	232	&rasize, 1, NOCRED, &bp);
38f21582 KM	233	} else
995d2177	234	error = bread(vp, lbn, size, NOCRED, &bp);
de67eefc	235	vp->v_lastr = lbn;
b373e060 KM	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->fs_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	}
9342689a JH	248	#undef vp
	249	#undef uio
	250	#undef ioflag
	251	#undef cred
b373e060 KM	252
	253	/*
	254	* Vnode op for writing.
	255	*/
9342689a JH	256	ffs_write (ap)
	257	struct vop_write_args *ap;
	258	#define vp (ap->a_vp)
	259	#define uio (ap->a_uio)
	260	#define ioflag (ap->a_ioflag)
	261	#define cred (ap->a_cred)
b373e060	262	{
9342689a JH	263	USES_VOP_TRUNCATE;
9342689a JH	264	USES_VOP_UPDATE;
5b169cb7	265	struct proc *p = uio->uio_procp;
b373e060 KM	266	register struct inode *ip = VTOI(vp);
	267	register struct fs *fs;
	268	struct buf *bp;
	269	daddr_t lbn, bn;
0308fc84	270	off_t osize;
8986c97c KM	271	int n, on, flags;
8986c97c KM	272	int size, resid, error = 0;
b373e060	273
5b169cb7	274	#ifdef DIAGNOSTIC
b373e060	275	if (uio->uio_rw != UIO_WRITE)
a6673c09	276	panic("ffs_write mode");
5b169cb7	277	#endif
b373e060 KM	278	switch (vp->v_type) {
	279	case VREG:
	280	if (ioflag & IO_APPEND)
	281	uio->uio_offset = ip->i_size;
	282	/* fall through */
	283	case VLNK:
	284	break;
	285
	286	case VDIR:
	287	if ((ioflag & IO_SYNC) == 0)
a6673c09	288	panic("ffs_write nonsync dir write");
b373e060 KM	289	break;
	290
	291	default:
a6673c09	292	panic("ffs_write type");
b373e060 KM	293	}
	294	if (uio->uio_offset < 0)
	295	return (EINVAL);
	296	if (uio->uio_resid == 0)
	297	return (0);
	298	/*
	299	* Maybe this should be above the vnode op call, but so long as
	300	* file servers have no limits, i don't think it matters
	301	*/
b326e282	302	if (vp->v_type == VREG && p &&
b373e060	303	uio->uio_offset + uio->uio_resid >
c6f5111d MK	304	p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
c6f5111d MK	305	psignal(p, SIGXFSZ);
b373e060 KM	306	return (EFBIG);
	307	}
	308	resid = uio->uio_resid;
	309	osize = ip->i_size;
	310	fs = ip->i_fs;
e16fa59e KM	311	flags = 0;
	312	if (ioflag & IO_SYNC)
	313	flags = B_SYNC;
b373e060 KM	314	do {
	315	lbn = lblkno(fs, uio->uio_offset);
	316	on = blkoff(fs, uio->uio_offset);
	317	n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid);
	318	if (n < fs->fs_bsize)
e16fa59e	319	flags \|= B_CLRBUF;
b373e060	320	else
e16fa59e	321	flags &= ~B_CLRBUF;
9438887a	322	if (error = ffs_balloc(ip, lbn, on + n, cred, &bp, flags))
b373e060	323	break;
e16fa59e	324	bn = bp->b_blkno;
8986c97c	325	if (uio->uio_offset + n > ip->i_size) {
b373e060	326	ip->i_size = uio->uio_offset + n;
8cfec5fd	327	vnode_pager_setsize(vp, (u_long)ip->i_size);
8986c97c	328	}
b373e060	329	size = blksize(fs, ip, lbn);
8986c97c	330	(void) vnode_pager_uncache(vp);
b373e060	331	n = MIN(n, size - bp->b_resid);
b373e060 KM	332	error = uiomove(bp->b_un.b_addr + on, n, uio);
	333	if (ioflag & IO_SYNC)
	334	(void) bwrite(bp);
	335	else if (n + on == fs->fs_bsize) {
	336	bp->b_flags \|= B_AGE;
	337	bawrite(bp);
	338	} else
	339	bdwrite(bp);
	340	ip->i_flag \|= IUPD\|ICHG;
	341	if (cred->cr_uid != 0)
	342	ip->i_mode &= ~(ISUID\|ISGID);
	343	} while (error == 0 && uio->uio_resid > 0 && n != 0);
	344	if (error && (ioflag & IO_UNIT)) {
9342689a	345	(void)VOP_TRUNCATE(vp, osize, ioflag & IO_SYNC, cred);
b373e060 KM	346	uio->uio_offset -= resid - uio->uio_resid;
	347	uio->uio_resid = resid;
	348	}
1c05ecaf	349	if (!error && (ioflag & IO_SYNC))
9342689a	350	error = VOP_UPDATE(vp, &time, &time, 1);
b373e060 KM	351	return (error);
b373e060 KM	352	}
9342689a JH	353	#undef vp
	354	#undef uio
	355	#undef ioflag
	356	#undef cred
b373e060	357
4f083fd7	358	/*
7188ac27	359	* Synch an open file.
4f083fd7	360	*/
7188ac27	361	/* ARGSUSED */
a6673c09	362	int
9342689a JH	363	ffs_fsync (ap)
	364	struct vop_fsync_args *ap;
	365	#define vp (ap->a_vp)
	366	#define fflags (ap->a_fflags)
	367	#define cred (ap->a_cred)
	368	#define waitfor (ap->a_waitfor)
	369	#define p (ap->a_p)
528f664c	370	{
9342689a	371	USES_VOP_UPDATE;
86cdabf6	372	struct inode *ip = VTOI(vp);
7188ac27	373
5b169cb7	374	if (fflags & FWRITE)
7188ac27	375	ip->i_flag \|= ICHG;
e16fa59e	376	vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0);
9342689a	377	return (VOP_UPDATE(vp, &time, &time, waitfor == MNT_WAIT));
9d5097aa	378	}
9342689a JH	379	#undef vp
	380	#undef fflags
	381	#undef cred
	382	#undef waitfor
	383	#undef p
9d5097aa KM	384
	385	/*
	386	* Last reference to an inode, write the inode out and if necessary,
	387	* truncate and deallocate the file.
	388	*/
	389	int
9342689a JH	390	ffs_inactive (ap)
	391	struct vop_inactive_args *ap;
	392	#define vp (ap->a_vp)
	393	#define p (ap->a_p)
9d5097aa	394	{
9342689a JH	395	USES_VOP_TRUNCATE;
	396	USES_VOP_UPDATE;
	397	USES_VOP_VFREE;
9d5097aa KM	398	register struct inode *ip;
	399	int mode, error;
	400	extern int prtactive;
	401
	402	if (prtactive && vp->v_usecount != 0)
	403	vprint("ffs_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
9342689a	420	error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED);
9d5097aa KM	421	mode = ip->i_mode;
	422	ip->i_mode = 0;
	423	ip->i_rdev = 0;
	424	ip->i_flag \|= IUPD\|ICHG;
9342689a	425	VOP_VFREE(vp, ip->i_number, mode);
9d5097aa KM	426	}
9d5097aa KM	427	if (ip->i_flag&(IUPD\|IACC\|ICHG\|IMOD))
9342689a	428	VOP_UPDATE(vp, &time, &time, 0);
9d5097aa KM	429	IUNLOCK(ip);
	430	ip->i_flag = 0;
	431	/*
	432	* If we are done with the inode, reclaim it
	433	* so that it can be reused immediately.
	434	*/
	435	if (vp->v_usecount == 0 && ip->i_mode == 0)
	436	vgone(vp);
	437	return (error);
4f083fd7	438	}
9342689a JH	439	#undef vp
9342689a JH	440	#undef p