[apple/xnu.git] / bsd / vfs / vfs_vnops.c

/*
 * Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*
 * Copyright (c) 1982, 1986, 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * All or some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
 * the permission of UNIX System Laboratories, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)vfs_vnops.c	8.14 (Berkeley) 6/15/95
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/ubc.h>

struct 	fileops vnops =
	{ vn_read, vn_write, vn_ioctl, vn_select, vn_closefile };

/*
 * Common code for vnode open operations.
 * Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
 */
vn_open(ndp, fmode, cmode)
	register struct nameidata *ndp;
	int fmode, cmode;
{
	register struct vnode *vp;
	register struct proc *p = ndp->ni_cnd.cn_proc;
	register struct ucred *cred = p->p_ucred;
	struct vattr vat;
	struct vattr *vap = &vat;
	int error;

	if (fmode & O_CREAT) {
		ndp->ni_cnd.cn_nameiop = CREATE;
		ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
		if ((fmode & O_EXCL) == 0)
			ndp->ni_cnd.cn_flags |= FOLLOW;
		if (error = namei(ndp))
			return (error);
		if (ndp->ni_vp == NULL) {
			VATTR_NULL(vap);
			vap->va_type = VREG;
			vap->va_mode = cmode;
			if (fmode & O_EXCL)
				vap->va_vaflags |= VA_EXCLUSIVE;
			VOP_LEASE(ndp->ni_dvp, p, cred, LEASE_WRITE);
			if (error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
			    &ndp->ni_cnd, vap))
				return (error);
			fmode &= ~O_TRUNC;
			vp = ndp->ni_vp;
		} else {
			VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
			if (ndp->ni_dvp == ndp->ni_vp)
				vrele(ndp->ni_dvp);
			else
				vput(ndp->ni_dvp);
			ndp->ni_dvp = NULL;
			vp = ndp->ni_vp;
			if (fmode & O_EXCL) {
				error = EEXIST;
				goto bad;
			}
			fmode &= ~O_CREAT;
		}
	} else {
		ndp->ni_cnd.cn_nameiop = LOOKUP;
		ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF;
		if (error = namei(ndp))
			return (error);
		vp = ndp->ni_vp;
	}
	if (vp->v_type == VSOCK) {
		error = EOPNOTSUPP;
		goto bad;
	}
	if ((fmode & O_CREAT) == 0) {
		if (fmode & FREAD && fmode & (FWRITE | O_TRUNC)) {
			int err = 0;
			if (vp->v_type == VDIR)
				err = EISDIR;
			else
				err = vn_writechk(vp);
			if (err && !(error = VOP_ACCESS(vp, VREAD, cred, p)))
				error = err;
			if (error || (error = VOP_ACCESS(vp, VREAD|VWRITE,
							 cred, p)))
				goto bad;
		} else if (fmode & FREAD) {
			if ((error = VOP_ACCESS(vp, VREAD, cred, p)))
				goto bad;
		} else if (fmode & (FWRITE | O_TRUNC)) {
			if (vp->v_type == VDIR) {
				error = EISDIR;
				goto bad;
			}
			if ((error = vn_writechk(vp)) ||
			    (error = VOP_ACCESS(vp, VWRITE, cred, p)))
				goto bad;
		}
	}
	if (fmode & O_TRUNC) {
		VOP_UNLOCK(vp, 0, p);				/* XXX */
		VOP_LEASE(vp, p, cred, LEASE_WRITE);
		(void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);	/* XXX */
		VATTR_NULL(vap);
		vap->va_size = 0;
		if (error = VOP_SETATTR(vp, vap, cred, p))
			goto bad;
	}

#if DIAGNOSTIC
	if (UBCINFOMISSING(vp))
		panic("vn_open: ubc_info_init");
#endif /* DIAGNOSTIC */

	if (UBCINFOEXISTS(vp) && !ubc_hold(vp)) {
		error = ENOENT;
		goto bad;
	}

	if (error = VOP_OPEN(vp, fmode, cred, p)) {
		ubc_rele(vp);
		goto bad;
	}

	if (fmode & FWRITE)
		if (++vp->v_writecount <= 0)
			panic("vn_open: v_writecount");
	return (0);
bad:
	vput(vp);
	return (error);
}

/*
 * Check for write permissions on the specified vnode.
 * Prototype text segments cannot be written.
 */
vn_writechk(vp)
	register struct vnode *vp;
{

	/*
	 * If there's shared text associated with
	 * the vnode, try to free it up once.  If
	 * we fail, we can't allow writing.
	 */
#if 0
	/* XXXXX Not sure we need this */
	if (vp->v_flag & VTEXT)
		return (ETXTBSY);
#endif /* 0 */
	return (0);
}

/*
 * Vnode close call
 */
vn_close(vp, flags, cred, p)
	register struct vnode *vp;
	int flags;
	struct ucred *cred;
	struct proc *p;
{
	int error;

	if (flags & FWRITE)
		vp->v_writecount--;
	error = VOP_CLOSE(vp, flags, cred, p);
	ubc_rele(vp);
	vrele(vp);
	return (error);
}

/*
 * Package up an I/O request on a vnode into a uio and do it.
 */
vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p)
	enum uio_rw rw;
	struct vnode *vp;
	caddr_t base;
	int len;
	off_t offset;
	enum uio_seg segflg;
	int ioflg;
	struct ucred *cred;
	int *aresid;
	struct proc *p;
{
	struct uio auio;
	struct iovec aiov;
	int error=0;

	 /* FIXME XXX */
	if ((ioflg & IO_NODELOCKED) == 0)
		(void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	aiov.iov_base = base;
	aiov.iov_len = len;
	auio.uio_resid = len;
	auio.uio_offset = offset;
	auio.uio_segflg = segflg;
	auio.uio_rw = rw;
	auio.uio_procp = p;

	if (rw == UIO_READ)
		error = VOP_READ(vp, &auio, ioflg, cred);
	 else 
		error = VOP_WRITE(vp, &auio, ioflg, cred);

	if (aresid)
		*aresid = auio.uio_resid;
	else
		if (auio.uio_resid && error == 0)
			error = EIO;
	if ((ioflg & IO_NODELOCKED) == 0)
		VOP_UNLOCK(vp, 0, p);
	return (error);
}

/*
 * File table vnode read routine.
 */
vn_read(fp, uio, cred)
	struct file *fp;
	struct uio *uio;
	struct ucred *cred;
{
	struct vnode *vp = (struct vnode *)fp->f_data;
	struct proc *p = uio->uio_procp;
	int error;
	off_t count;

	VOP_LEASE(vp, p, cred, LEASE_READ);
	(void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
	uio->uio_offset = fp->f_offset;
	count = uio->uio_resid;

	error = VOP_READ(vp, uio, (fp->f_flag & FNONBLOCK) ? IO_NDELAY : 0, cred);

	fp->f_offset += count - uio->uio_resid;
	VOP_UNLOCK(vp, 0, p);
	return (error);
}


/*
 * File table vnode write routine.
 */
vn_write(fp, uio, cred)
	struct file *fp;
	struct uio *uio;
	struct ucred *cred;
{
	struct vnode *vp = (struct vnode *)fp->f_data;
	struct proc *p = uio->uio_procp;
	int error, ioflag = IO_UNIT;
	off_t count;

	if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
		ioflag |= IO_APPEND;
	if (fp->f_flag & FNONBLOCK)
		ioflag |= IO_NDELAY;
	if ((fp->f_flag & O_FSYNC) ||
		(vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
		ioflag |= IO_SYNC;
	VOP_LEASE(vp, p, cred, LEASE_WRITE);
	(void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
	uio->uio_offset = fp->f_offset;
	count = uio->uio_resid;

	error = VOP_WRITE(vp, uio, ioflag, cred);

	if (ioflag & IO_APPEND)
		fp->f_offset = uio->uio_offset;
	else
		fp->f_offset += count - uio->uio_resid;
	/*
	 * Set the credentials on successful writes
	 */
	if ((error == 0) && (vp->v_tag == VT_NFS) && (UBCINFOEXISTS(vp))) {
		ubc_setcred(vp, p);
	}

	VOP_UNLOCK(vp, 0, p);
	return (error);
}

/*
 * File table vnode stat routine.
 */
vn_stat(vp, sb, p)
	struct vnode *vp;
	register struct stat *sb;
	struct proc *p;
{
	struct vattr vattr;
	register struct vattr *vap;
	int error;
	u_short mode;

	vap = &vattr;
	error = VOP_GETATTR(vp, vap, p->p_ucred, p);
	if (error)
		return (error);
	/*
	 * Copy from vattr table
	 */
	sb->st_dev = vap->va_fsid;
	sb->st_ino = vap->va_fileid;
	mode = vap->va_mode;
	switch (vp->v_type) {
	case VREG:
		mode |= S_IFREG;
		break;
	case VDIR:
		mode |= S_IFDIR;
		break;
	case VBLK:
		mode |= S_IFBLK;
		break;
	case VCHR:
		mode |= S_IFCHR;
		break;
	case VLNK:
		mode |= S_IFLNK;
		break;
	case VSOCK:
		mode |= S_IFSOCK;
		break;
	case VFIFO:
		mode |= S_IFIFO;
		break;
	default:
		return (EBADF);
	};
	sb->st_mode = mode;
	sb->st_nlink = vap->va_nlink;
	sb->st_uid = vap->va_uid;
	sb->st_gid = vap->va_gid;
	sb->st_rdev = vap->va_rdev;
	sb->st_size = vap->va_size;
	sb->st_atimespec = vap->va_atime;
	sb->st_mtimespec = vap->va_mtime;
	sb->st_ctimespec = vap->va_ctime;
	sb->st_blksize = vap->va_blocksize;
	sb->st_flags = vap->va_flags;
	/* Do not give the generation number out to unpriviledged users */
	if (suser(p->p_ucred, &p->p_acflag))
		sb->st_gen = 0; 
	else
		sb->st_gen = vap->va_gen;
	sb->st_blocks = vap->va_bytes / S_BLKSIZE;
	return (0);
}

/*
 * File table vnode ioctl routine.
 */
vn_ioctl(fp, com, data, p)
	struct file *fp;
	u_long com;
	caddr_t data;
	struct proc *p;
{
	register struct vnode *vp = ((struct vnode *)fp->f_data);
	struct vattr vattr;
	int error;
	struct vnode *ttyvp;

	switch (vp->v_type) {

	case VREG:
	case VDIR:
		if (com == FIONREAD) {
			if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
				return (error);
			*(int *)data = vattr.va_size - fp->f_offset;
			return (0);
		}
		if (com == FIONBIO || com == FIOASYNC)	/* XXX */
			return (0);			/* XXX */
		/* fall into ... */

	default:
		return (ENOTTY);

	case VFIFO:
	case VCHR:
	case VBLK:
		error = VOP_IOCTL(vp, com, data, fp->f_flag, p->p_ucred, p);
		if (error == 0 && com == TIOCSCTTY) {
			VREF(vp);
			ttyvp = p->p_session->s_ttyvp;
			p->p_session->s_ttyvp = vp;
			if (ttyvp)
				vrele(ttyvp);
		}
		return (error);
	}
}

/*
 * File table vnode select routine.
 */
vn_select(fp, which, wql, p)
	struct file *fp;
	int which;
	void * wql;
	struct proc *p;
{

	return(VOP_SELECT(((struct vnode *)fp->f_data), which, fp->f_flag,
		fp->f_cred, wql, p));
}

/*
 * Check that the vnode is still valid, and if so
 * acquire requested lock.
 */
int
vn_lock(vp, flags, p)
	struct vnode *vp;
	int flags;
	struct proc *p;
{
	int error;
	
	do {
		if ((flags & LK_INTERLOCK) == 0)
			simple_lock(&vp->v_interlock);
		if (vp->v_flag & VXLOCK) {
			while (vp->v_flag & VXLOCK) {
				vp->v_flag |= VXWANT;
				simple_unlock(&vp->v_interlock);
				(void)tsleep((caddr_t)vp, PINOD, "vn_lock", 0);
			}
			error = ENOENT;
		} else {
			error = VOP_LOCK(vp, flags | LK_INTERLOCK, p);
			if (error == 0)
				return (error);
		}
		flags &= ~LK_INTERLOCK;
	} while (flags & LK_RETRY);
	return (error);
}

/*
 * File table vnode close routine.
 */
vn_closefile(fp, p)
	struct file *fp;
	struct proc *p;
{

	return (vn_close(((struct vnode *)fp->f_data), fp->f_flag,
		fp->f_cred, p));
}
Commit	Line	Data
1c79356b	1	/*
0b4e3aa0	2	* Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	23	/*
	24	* Copyright (c) 1982, 1986, 1989, 1993
	25	* The Regents of the University of California. All rights reserved.
	26	* (c) UNIX System Laboratories, Inc.
	27	* All or some portions of this file are derived from material licensed
	28	* to the University of California by American Telephone and Telegraph
	29	* Co. or Unix System Laboratories, Inc. and are reproduced herein with
	30	* the permission of UNIX System Laboratories, Inc.
	31	*
	32	* Redistribution and use in source and binary forms, with or without
	33	* modification, are permitted provided that the following conditions
	34	* are met:
	35	* 1. Redistributions of source code must retain the above copyright
	36	* notice, this list of conditions and the following disclaimer.
	37	* 2. Redistributions in binary form must reproduce the above copyright
	38	* notice, this list of conditions and the following disclaimer in the
	39	* documentation and/or other materials provided with the distribution.
	40	* 3. All advertising materials mentioning features or use of this software
	41	* must display the following acknowledgement:
	42	* This product includes software developed by the University of
	43	* California, Berkeley and its contributors.
	44	* 4. Neither the name of the University nor the names of its contributors
	45	* may be used to endorse or promote products derived from this software
	46	* without specific prior written permission.
	47	*
	48	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	49	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	50	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	51	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	52	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	53	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	54	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	55	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	56	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	57	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	58	* SUCH DAMAGE.
	59	*
	60	* @(#)vfs_vnops.c 8.14 (Berkeley) 6/15/95
	61	*
1c79356b A	62	*/
	63
	64	#include <sys/param.h>
	65	#include <sys/systm.h>
	66	#include <sys/kernel.h>
	67	#include <sys/file.h>
	68	#include <sys/stat.h>
	69	#include <sys/buf.h>
	70	#include <sys/proc.h>
	71	#include <sys/mount.h>
	72	#include <sys/namei.h>
	73	#include <sys/vnode.h>
	74	#include <sys/ioctl.h>
	75	#include <sys/tty.h>
	76	#include <sys/ubc.h>
1c79356b A	77
	78	struct fileops vnops =
	79	{ vn_read, vn_write, vn_ioctl, vn_select, vn_closefile };
	80
	81	/*
	82	* Common code for vnode open operations.
	83	* Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
	84	*/
	85	vn_open(ndp, fmode, cmode)
	86	register struct nameidata *ndp;
	87	int fmode, cmode;
	88	{
	89	register struct vnode *vp;
	90	register struct proc *p = ndp->ni_cnd.cn_proc;
	91	register struct ucred *cred = p->p_ucred;
	92	struct vattr vat;
	93	struct vattr *vap = &vat;
	94	int error;
	95
	96	if (fmode & O_CREAT) {
	97	ndp->ni_cnd.cn_nameiop = CREATE;
	98	ndp->ni_cnd.cn_flags = LOCKPARENT \| LOCKLEAF;
	99	if ((fmode & O_EXCL) == 0)
	100	ndp->ni_cnd.cn_flags \|= FOLLOW;
	101	if (error = namei(ndp))
	102	return (error);
	103	if (ndp->ni_vp == NULL) {
	104	VATTR_NULL(vap);
	105	vap->va_type = VREG;
	106	vap->va_mode = cmode;
	107	if (fmode & O_EXCL)
	108	vap->va_vaflags \|= VA_EXCLUSIVE;
	109	VOP_LEASE(ndp->ni_dvp, p, cred, LEASE_WRITE);
	110	if (error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
	111	&ndp->ni_cnd, vap))
	112	return (error);
	113	fmode &= ~O_TRUNC;
	114	vp = ndp->ni_vp;
	115	} else {
	116	VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
	117	if (ndp->ni_dvp == ndp->ni_vp)
	118	vrele(ndp->ni_dvp);
	119	else
	120	vput(ndp->ni_dvp);
	121	ndp->ni_dvp = NULL;
	122	vp = ndp->ni_vp;
	123	if (fmode & O_EXCL) {
	124	error = EEXIST;
	125	goto bad;
	126	}
	127	fmode &= ~O_CREAT;
	128	}
	129	} else {
	130	ndp->ni_cnd.cn_nameiop = LOOKUP;
	131	ndp->ni_cnd.cn_flags = FOLLOW \| LOCKLEAF;
	132	if (error = namei(ndp))
	133	return (error);
	134	vp = ndp->ni_vp;
	135	}
	136	if (vp->v_type == VSOCK) {
	137	error = EOPNOTSUPP;
	138	goto bad;
	139	}
	140	if ((fmode & O_CREAT) == 0) {
141	if (fmode & FREAD && fmode & (FWRITE \| O_TRUNC)) {
142	int err = 0;
143	if (vp->v_type == VDIR)
144	err = EISDIR;
145	else
146	err = vn_writechk(vp);
147	if (err && !(error = VOP_ACCESS(vp, VREAD, cred, p)))
148	error = err;
149	if (error \|\| (error = VOP_ACCESS(vp, VREAD\|VWRITE,
150	cred, p)))
151	goto bad;
152	} else if (fmode & FREAD) {
153	if ((error = VOP_ACCESS(vp, VREAD, cred, p)))
154	goto bad;
155	} else if (fmode & (FWRITE \| O_TRUNC)) {
156	if (vp->v_type == VDIR) {
157	error = EISDIR;
158	goto bad;
159	}
160	if ((error = vn_writechk(vp)) \|\|
161	(error = VOP_ACCESS(vp, VWRITE, cred, p)))
162	goto bad;
163	}
164	}
165	if (fmode & O_TRUNC) {
166	VOP_UNLOCK(vp, 0, p); /* XXX */
167	VOP_LEASE(vp, p, cred, LEASE_WRITE);
0b4e3aa0	168	(void)vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, p); /* XXX */
1c79356b A	169	VATTR_NULL(vap);
	170	vap->va_size = 0;
	171	if (error = VOP_SETATTR(vp, vap, cred, p))
	172	goto bad;
	173	}
0b4e3aa0 A	174
0b4e3aa0 A	175	#if DIAGNOSTIC
1c79356b	176	if (UBCINFOMISSING(vp))
0b4e3aa0 A	177	panic("vn_open: ubc_info_init");
	178	#endif /* DIAGNOSTIC */
	179
	180	if (UBCINFOEXISTS(vp) && !ubc_hold(vp)) {
	181	error = ENOENT;
	182	goto bad;
	183	}
	184
	185	if (error = VOP_OPEN(vp, fmode, cred, p)) {
	186	ubc_rele(vp);
	187	goto bad;
	188	}
	189
1c79356b A	190	if (fmode & FWRITE)
	191	if (++vp->v_writecount <= 0)
	192	panic("vn_open: v_writecount");
	193	return (0);
	194	bad:
	195	vput(vp);
	196	return (error);
	197	}
	198
	199	/*
	200	* Check for write permissions on the specified vnode.
	201	* Prototype text segments cannot be written.
	202	*/
	203	vn_writechk(vp)
	204	register struct vnode *vp;
	205	{
	206
	207	/*
	208	* If there's shared text associated with
	209	* the vnode, try to free it up once. If
	210	* we fail, we can't allow writing.
	211	*/
	212	#if 0
	213	/* XXXXX Not sure we need this */
	214	if (vp->v_flag & VTEXT)
	215	return (ETXTBSY);
	216	#endif /* 0 */
	217	return (0);
	218	}
	219
	220	/*
	221	* Vnode close call
	222	*/
	223	vn_close(vp, flags, cred, p)
	224	register struct vnode *vp;
	225	int flags;
	226	struct ucred *cred;
	227	struct proc *p;
	228	{
	229	int error;
1c79356b A	230
	231	if (flags & FWRITE)
	232	vp->v_writecount--;
	233	error = VOP_CLOSE(vp, flags, cred, p);
	234	ubc_rele(vp);
	235	vrele(vp);
	236	return (error);
	237	}
	238
	239	/*
	240	* Package up an I/O request on a vnode into a uio and do it.
	241	*/
	242	vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p)
	243	enum uio_rw rw;
	244	struct vnode *vp;
	245	caddr_t base;
	246	int len;
	247	off_t offset;
	248	enum uio_seg segflg;
	249	int ioflg;
	250	struct ucred *cred;
	251	int *aresid;
	252	struct proc *p;
	253	{
	254	struct uio auio;
	255	struct iovec aiov;
	256	int error=0;
	257
	258	/* FIXME XXX */
	259	if ((ioflg & IO_NODELOCKED) == 0)
0b4e3aa0	260	(void)vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, p);
1c79356b A	261	auio.uio_iov = &aiov;
	262	auio.uio_iovcnt = 1;
	263	aiov.iov_base = base;
	264	aiov.iov_len = len;
	265	auio.uio_resid = len;
	266	auio.uio_offset = offset;
	267	auio.uio_segflg = segflg;
	268	auio.uio_rw = rw;
	269	auio.uio_procp = p;
	270
	271	if (rw == UIO_READ)
	272	error = VOP_READ(vp, &auio, ioflg, cred);
	273	else
	274	error = VOP_WRITE(vp, &auio, ioflg, cred);
	275
	276	if (aresid)
	277	*aresid = auio.uio_resid;
	278	else
	279	if (auio.uio_resid && error == 0)
	280	error = EIO;
	281	if ((ioflg & IO_NODELOCKED) == 0)
	282	VOP_UNLOCK(vp, 0, p);
	283	return (error);
	284	}
	285
	286	/*
	287	* File table vnode read routine.
	288	*/
	289	vn_read(fp, uio, cred)
	290	struct file *fp;
	291	struct uio *uio;
	292	struct ucred *cred;
	293	{
	294	struct vnode vp = (struct vnode )fp->f_data;
	295	struct proc *p = uio->uio_procp;
	296	int error;
	297	off_t count;
	298
	299	VOP_LEASE(vp, p, cred, LEASE_READ);
0b4e3aa0	300	(void)vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, p);
1c79356b A	301	uio->uio_offset = fp->f_offset;
	302	count = uio->uio_resid;
	303
	304	error = VOP_READ(vp, uio, (fp->f_flag & FNONBLOCK) ? IO_NDELAY : 0, cred);
	305
	306	fp->f_offset += count - uio->uio_resid;
	307	VOP_UNLOCK(vp, 0, p);
	308	return (error);
	309	}
	310
	311
	312	/*
	313	* File table vnode write routine.
	314	*/
	315	vn_write(fp, uio, cred)
	316	struct file *fp;
	317	struct uio *uio;
	318	struct ucred *cred;
	319	{
	320	struct vnode vp = (struct vnode )fp->f_data;
	321	struct proc *p = uio->uio_procp;
	322	int error, ioflag = IO_UNIT;
	323	off_t count;
	324
	325	if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
	326	ioflag \|= IO_APPEND;
	327	if (fp->f_flag & FNONBLOCK)
	328	ioflag \|= IO_NDELAY;
	329	if ((fp->f_flag & O_FSYNC) \|\|
	330	(vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
	331	ioflag \|= IO_SYNC;
	332	VOP_LEASE(vp, p, cred, LEASE_WRITE);
0b4e3aa0	333	(void)vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, p);
1c79356b A	334	uio->uio_offset = fp->f_offset;
	335	count = uio->uio_resid;
	336
	337	error = VOP_WRITE(vp, uio, ioflag, cred);
	338
	339	if (ioflag & IO_APPEND)
	340	fp->f_offset = uio->uio_offset;
	341	else
	342	fp->f_offset += count - uio->uio_resid;
	343	/*
	344	* Set the credentials on successful writes
	345	*/
	346	if ((error == 0) && (vp->v_tag == VT_NFS) && (UBCINFOEXISTS(vp))) {
	347	ubc_setcred(vp, p);
	348	}
	349
	350	VOP_UNLOCK(vp, 0, p);
	351	return (error);
	352	}
	353
	354	/*
	355	* File table vnode stat routine.
	356	*/
	357	vn_stat(vp, sb, p)
	358	struct vnode *vp;
	359	register struct stat *sb;
	360	struct proc *p;
	361	{
	362	struct vattr vattr;
	363	register struct vattr *vap;
	364	int error;
	365	u_short mode;
	366
	367	vap = &vattr;
	368	error = VOP_GETATTR(vp, vap, p->p_ucred, p);
	369	if (error)
	370	return (error);
	371	/*
	372	* Copy from vattr table
	373	*/
	374	sb->st_dev = vap->va_fsid;
	375	sb->st_ino = vap->va_fileid;
	376	mode = vap->va_mode;
	377	switch (vp->v_type) {
	378	case VREG:
	379	mode \|= S_IFREG;
	380	break;
	381	case VDIR:
	382	mode \|= S_IFDIR;
	383	break;
	384	case VBLK:
	385	mode \|= S_IFBLK;
	386	break;
	387	case VCHR:
	388	mode \|= S_IFCHR;
	389	break;
	390	case VLNK:
	391	mode \|= S_IFLNK;
	392	break;
	393	case VSOCK:
	394	mode \|= S_IFSOCK;
	395	break;
	396	case VFIFO:
	397	mode \|= S_IFIFO;
398	break;
399	default:
400	return (EBADF);
401	};
402	sb->st_mode = mode;
403	sb->st_nlink = vap->va_nlink;
404	sb->st_uid = vap->va_uid;
405	sb->st_gid = vap->va_gid;
406	sb->st_rdev = vap->va_rdev;
407	sb->st_size = vap->va_size;
408	sb->st_atimespec = vap->va_atime;
409	sb->st_mtimespec = vap->va_mtime;
410	sb->st_ctimespec = vap->va_ctime;
411	sb->st_blksize = vap->va_blocksize;
412	sb->st_flags = vap->va_flags;
413	/* Do not give the generation number out to unpriviledged users */
414	if (suser(p->p_ucred, &p->p_acflag))
415	sb->st_gen = 0;
416	else
417	sb->st_gen = vap->va_gen;
418	sb->st_blocks = vap->va_bytes / S_BLKSIZE;
419	return (0);
420	}
421
422	/*
423	* File table vnode ioctl routine.
424	*/
425	vn_ioctl(fp, com, data, p)
426	struct file *fp;
427	u_long com;
428	caddr_t data;
429	struct proc *p;
430	{
431	register struct vnode vp = ((struct vnode )fp->f_data);
432	struct vattr vattr;
433	int error;
fa4905b1	434	struct vnode *ttyvp;
1c79356b A	435
	436	switch (vp->v_type) {
	437
	438	case VREG:
	439	case VDIR:
	440	if (com == FIONREAD) {
	441	if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))
	442	return (error);
	443	(int )data = vattr.va_size - fp->f_offset;
	444	return (0);
	445	}
	446	if (com == FIONBIO \|\| com == FIOASYNC) /* XXX */
	447	return (0); /* XXX */
	448	/* fall into ... */
	449
	450	default:
	451	return (ENOTTY);
	452
	453	case VFIFO:
	454	case VCHR:
	455	case VBLK:
	456	error = VOP_IOCTL(vp, com, data, fp->f_flag, p->p_ucred, p);
	457	if (error == 0 && com == TIOCSCTTY) {
1c79356b	458	VREF(vp);
fa4905b1 A	459	ttyvp = p->p_session->s_ttyvp;
	460	p->p_session->s_ttyvp = vp;
	461	if (ttyvp)
	462	vrele(ttyvp);
1c79356b A	463	}
	464	return (error);
	465	}
	466	}
	467
	468	/*
	469	* File table vnode select routine.
	470	*/
0b4e3aa0	471	vn_select(fp, which, wql, p)
1c79356b A	472	struct file *fp;
1c79356b A	473	int which;
0b4e3aa0	474	void * wql;
1c79356b A	475	struct proc *p;
	476	{
	477
0b4e3aa0 A	478	return(VOP_SELECT(((struct vnode *)fp->f_data), which, fp->f_flag,
0b4e3aa0 A	479	fp->f_cred, wql, p));
1c79356b A	480	}
	481
	482	/*
	483	* Check that the vnode is still valid, and if so
	484	* acquire requested lock.
	485	*/
	486	int
	487	vn_lock(vp, flags, p)
	488	struct vnode *vp;
	489	int flags;
	490	struct proc *p;
	491	{
	492	int error;
	493
	494	do {
	495	if ((flags & LK_INTERLOCK) == 0)
	496	simple_lock(&vp->v_interlock);
	497	if (vp->v_flag & VXLOCK) {
	498	while (vp->v_flag & VXLOCK) {
	499	vp->v_flag \|= VXWANT;
	500	simple_unlock(&vp->v_interlock);
0b4e3aa0	501	(void)tsleep((caddr_t)vp, PINOD, "vn_lock", 0);
1c79356b A	502	}
	503	error = ENOENT;
	504	} else {
	505	error = VOP_LOCK(vp, flags \| LK_INTERLOCK, p);
	506	if (error == 0)
	507	return (error);
	508	}
	509	flags &= ~LK_INTERLOCK;
	510	} while (flags & LK_RETRY);
	511	return (error);
	512	}
	513
	514	/*
	515	* File table vnode close routine.
	516	*/
	517	vn_closefile(fp, p)
	518	struct file *fp;
	519	struct proc *p;
	520	{
	521
	522	return (vn_close(((struct vnode *)fp->f_data), fp->f_flag,
	523	fp->f_cred, p));
	524	}