Home | History | Annotate | Line # | Download | only in kern
vfs_vnops.c revision 1.106.2.2
      1  1.106.2.2      yamt /*	$NetBSD: vfs_vnops.c,v 1.106.2.2 2006/04/01 12:07:42 yamt Exp $	*/
      2       1.12       cgd 
      3       1.10       cgd /*
      4       1.11   mycroft  * Copyright (c) 1982, 1986, 1989, 1993
      5       1.11   mycroft  *	The Regents of the University of California.  All rights reserved.
      6       1.10       cgd  * (c) UNIX System Laboratories, Inc.
      7       1.10       cgd  * All or some portions of this file are derived from material licensed
      8       1.10       cgd  * to the University of California by American Telephone and Telegraph
      9       1.10       cgd  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
     10       1.10       cgd  * the permission of UNIX System Laboratories, Inc.
     11       1.10       cgd  *
     12       1.10       cgd  * Redistribution and use in source and binary forms, with or without
     13       1.10       cgd  * modification, are permitted provided that the following conditions
     14       1.10       cgd  * are met:
     15       1.10       cgd  * 1. Redistributions of source code must retain the above copyright
     16       1.10       cgd  *    notice, this list of conditions and the following disclaimer.
     17       1.10       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     18       1.10       cgd  *    notice, this list of conditions and the following disclaimer in the
     19       1.10       cgd  *    documentation and/or other materials provided with the distribution.
     20       1.73       agc  * 3. Neither the name of the University nor the names of its contributors
     21       1.10       cgd  *    may be used to endorse or promote products derived from this software
     22       1.10       cgd  *    without specific prior written permission.
     23       1.10       cgd  *
     24       1.10       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     25       1.10       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26       1.10       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27       1.10       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     28       1.10       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     29       1.10       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     30       1.10       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     31       1.10       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     32       1.10       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     33       1.10       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     34       1.10       cgd  * SUCH DAMAGE.
     35       1.10       cgd  *
     36       1.28      fvdl  *	@(#)vfs_vnops.c	8.14 (Berkeley) 6/15/95
     37       1.10       cgd  */
     38       1.52     lukem 
     39       1.52     lukem #include <sys/cdefs.h>
     40  1.106.2.2      yamt __KERNEL_RCSID(0, "$NetBSD: vfs_vnops.c,v 1.106.2.2 2006/04/01 12:07:42 yamt Exp $");
     41       1.93  christos 
     42       1.93  christos #include "opt_verified_exec.h"
     43       1.26       mrg 
     44       1.27   thorpej #include "fs_union.h"
     45       1.10       cgd 
     46       1.10       cgd #include <sys/param.h>
     47       1.10       cgd #include <sys/systm.h>
     48       1.10       cgd #include <sys/kernel.h>
     49       1.10       cgd #include <sys/file.h>
     50       1.10       cgd #include <sys/stat.h>
     51       1.10       cgd #include <sys/buf.h>
     52       1.10       cgd #include <sys/proc.h>
     53       1.77   hannken #include <sys/malloc.h>
     54       1.10       cgd #include <sys/mount.h>
     55       1.10       cgd #include <sys/namei.h>
     56       1.10       cgd #include <sys/vnode.h>
     57       1.10       cgd #include <sys/ioctl.h>
     58       1.10       cgd #include <sys/tty.h>
     59       1.21   mycroft #include <sys/poll.h>
     60       1.11   mycroft 
     61       1.77   hannken #include <miscfs/specfs/specdev.h>
     62       1.77   hannken 
     63       1.25       mrg #include <uvm/uvm_extern.h>
     64      1.100      yamt #include <uvm/uvm_readahead.h>
     65       1.25       mrg 
     66       1.28      fvdl #ifdef UNION
     67       1.65  jdolecek #include <fs/union/union.h>
     68       1.28      fvdl #endif
     69       1.64  jdolecek 
     70       1.66  jdolecek #if defined(LKM) || defined(UNION)
     71      1.101  christos int (*vn_union_readdir_hook) (struct vnode **, struct file *, struct lwp *);
     72       1.66  jdolecek #endif
     73       1.66  jdolecek 
     74       1.64  jdolecek #ifdef VERIFIED_EXEC
     75       1.58     blymn #include <sys/verified_exec.h>
     76       1.64  jdolecek #endif
     77       1.28      fvdl 
     78       1.56  gmcgarry static int vn_read(struct file *fp, off_t *offset, struct uio *uio,
     79       1.56  gmcgarry 	    struct ucred *cred, int flags);
     80       1.56  gmcgarry static int vn_write(struct file *fp, off_t *offset, struct uio *uio,
     81       1.56  gmcgarry 	    struct ucred *cred, int flags);
     82      1.101  christos static int vn_closefile(struct file *fp, struct lwp *l);
     83      1.101  christos static int vn_poll(struct file *fp, int events, struct lwp *l);
     84      1.101  christos static int vn_fcntl(struct file *fp, u_int com, void *data, struct lwp *l);
     85      1.101  christos static int vn_statfile(struct file *fp, struct stat *sb, struct lwp *l);
     86      1.101  christos static int vn_ioctl(struct file *fp, u_long com, void *data, struct lwp *l);
     87       1.48  jdolecek 
     88       1.83  christos const struct fileops vnops = {
     89       1.48  jdolecek 	vn_read, vn_write, vn_ioctl, vn_fcntl, vn_poll,
     90       1.57  jdolecek 	vn_statfile, vn_closefile, vn_kqfilter
     91       1.48  jdolecek };
     92       1.10       cgd 
     93       1.10       cgd /*
     94       1.10       cgd  * Common code for vnode open operations.
     95       1.10       cgd  * Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
     96       1.10       cgd  */
     97       1.20  christos int
     98       1.89   thorpej vn_open(struct nameidata *ndp, int fmode, int cmode)
     99       1.10       cgd {
    100       1.94       erh 	struct vnode *vp;
    101       1.75   hannken 	struct mount *mp;
    102      1.101  christos 	struct lwp *l = ndp->ni_cnd.cn_lwp;
    103      1.101  christos 	struct ucred *cred = l->l_proc->p_ucred;
    104       1.19   mycroft 	struct vattr va;
    105       1.10       cgd 	int error;
    106       1.92      elad #ifdef VERIFIED_EXEC
    107       1.92      elad 	struct veriexec_hash_entry *vhe = NULL;
    108       1.96      elad 	char pathbuf[MAXPATHLEN];
    109       1.96      elad 	size_t pathlen;
    110       1.98      elad 	int (*copyfun)(const void *, void *, size_t, size_t *) =
    111       1.97  christos 	    ndp->ni_segflg == UIO_SYSSPACE ? copystr : copyinstr;
    112       1.96      elad #endif /* VERIFIED_EXEC */
    113       1.96      elad 
    114       1.96      elad #ifdef VERIFIED_EXEC
    115       1.97  christos 	error = (*copyfun)(ndp->ni_dirp, pathbuf, sizeof(pathbuf), &pathlen);
    116       1.96      elad 	if (error) {
    117       1.96      elad 		if (veriexec_verbose >= 1)
    118       1.96      elad 			printf("veriexec: Can't copy path. (error=%d)\n",
    119       1.97  christos 			    error);
    120       1.96      elad 
    121       1.96      elad 		return (error);
    122       1.96      elad 	}
    123       1.92      elad #endif /* VERIFIED_EXEC */
    124       1.75   hannken 
    125       1.75   hannken restart:
    126       1.10       cgd 	if (fmode & O_CREAT) {
    127       1.11   mycroft 		ndp->ni_cnd.cn_nameiop = CREATE;
    128       1.11   mycroft 		ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
    129       1.38    bouyer 		if ((fmode & O_EXCL) == 0 &&
    130       1.59  christos 		    ((fmode & O_NOFOLLOW) == 0))
    131       1.11   mycroft 			ndp->ni_cnd.cn_flags |= FOLLOW;
    132       1.20  christos 		if ((error = namei(ndp)) != 0)
    133       1.10       cgd 			return (error);
    134       1.10       cgd 		if (ndp->ni_vp == NULL) {
    135       1.91      elad #ifdef VERIFIED_EXEC
    136       1.91      elad 			/* Lockdown mode: Prevent creation of new files. */
    137       1.91      elad 			if (veriexec_strict >= 3) {
    138       1.91      elad 				VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
    139       1.91      elad 
    140       1.91      elad 				printf("Veriexec: vn_open: Preventing "
    141       1.91      elad 				       "new file creation in %s.\n",
    142       1.96      elad 				       pathbuf);
    143       1.91      elad 
    144       1.94       erh 				vp = ndp->ni_dvp;
    145       1.91      elad 				error = EPERM;
    146       1.91      elad 				goto bad;
    147       1.91      elad 			}
    148       1.91      elad #endif /* VERIFIED_EXEC */
    149       1.91      elad 
    150       1.19   mycroft 			VATTR_NULL(&va);
    151       1.19   mycroft 			va.va_type = VREG;
    152       1.19   mycroft 			va.va_mode = cmode;
    153       1.28      fvdl 			if (fmode & O_EXCL)
    154       1.28      fvdl 				 va.va_vaflags |= VA_EXCLUSIVE;
    155       1.75   hannken 			if (vn_start_write(ndp->ni_dvp, &mp, V_NOWAIT) != 0) {
    156       1.75   hannken 				VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
    157       1.75   hannken 				vput(ndp->ni_dvp);
    158       1.75   hannken 				if ((error = vn_start_write(NULL, &mp,
    159       1.75   hannken 				    V_WAIT | V_SLEEPONLY | V_PCATCH)) != 0)
    160       1.75   hannken 					return (error);
    161       1.75   hannken 				goto restart;
    162       1.75   hannken 			}
    163      1.101  christos 			VOP_LEASE(ndp->ni_dvp, l, cred, LEASE_WRITE);
    164       1.20  christos 			error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
    165       1.20  christos 					   &ndp->ni_cnd, &va);
    166       1.75   hannken 			vn_finished_write(mp, 0);
    167       1.20  christos 			if (error)
    168       1.10       cgd 				return (error);
    169       1.10       cgd 			fmode &= ~O_TRUNC;
    170       1.10       cgd 			vp = ndp->ni_vp;
    171       1.10       cgd 		} else {
    172       1.11   mycroft 			VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
    173       1.10       cgd 			if (ndp->ni_dvp == ndp->ni_vp)
    174       1.10       cgd 				vrele(ndp->ni_dvp);
    175       1.10       cgd 			else
    176       1.10       cgd 				vput(ndp->ni_dvp);
    177       1.10       cgd 			ndp->ni_dvp = NULL;
    178       1.10       cgd 			vp = ndp->ni_vp;
    179       1.10       cgd 			if (fmode & O_EXCL) {
    180       1.10       cgd 				error = EEXIST;
    181       1.38    bouyer 				goto bad;
    182       1.38    bouyer 			}
    183       1.10       cgd 			fmode &= ~O_CREAT;
    184       1.10       cgd 		}
    185       1.10       cgd 	} else {
    186       1.11   mycroft 		ndp->ni_cnd.cn_nameiop = LOOKUP;
    187       1.74        cb 		ndp->ni_cnd.cn_flags = LOCKLEAF;
    188       1.74        cb 		if ((fmode & O_NOFOLLOW) == 0)
    189       1.74        cb 			ndp->ni_cnd.cn_flags |= FOLLOW;
    190       1.20  christos 		if ((error = namei(ndp)) != 0)
    191       1.10       cgd 			return (error);
    192       1.10       cgd 		vp = ndp->ni_vp;
    193       1.10       cgd 	}
    194       1.10       cgd 	if (vp->v_type == VSOCK) {
    195       1.10       cgd 		error = EOPNOTSUPP;
    196       1.74        cb 		goto bad;
    197       1.74        cb 	}
    198       1.74        cb 	if (ndp->ni_vp->v_type == VLNK) {
    199       1.74        cb 		error = EFTYPE;
    200       1.10       cgd 		goto bad;
    201       1.10       cgd 	}
    202       1.58     blymn 
    203       1.58     blymn #ifdef VERIFIED_EXEC
    204      1.101  christos 	if ((error = VOP_GETATTR(vp, &va, cred, l)) != 0)
    205       1.58     blymn 		goto bad;
    206       1.58     blymn #endif
    207       1.58     blymn 
    208       1.10       cgd 	if ((fmode & O_CREAT) == 0) {
    209       1.58     blymn #ifdef VERIFIED_EXEC
    210      1.101  christos 		if ((error = veriexec_verify(l, vp, &va, pathbuf,
    211       1.92      elad 					     VERIEXEC_FILE, &vhe)) != 0)
    212       1.87     blymn 			goto bad;
    213       1.58     blymn #endif
    214       1.91      elad 
    215       1.10       cgd 		if (fmode & FREAD) {
    216      1.101  christos 			if ((error = VOP_ACCESS(vp, VREAD, cred, l)) != 0)
    217       1.10       cgd 				goto bad;
    218       1.10       cgd 		}
    219       1.87     blymn 
    220       1.10       cgd 		if (fmode & (FWRITE | O_TRUNC)) {
    221       1.10       cgd 			if (vp->v_type == VDIR) {
    222       1.10       cgd 				error = EISDIR;
    223       1.10       cgd 				goto bad;
    224       1.10       cgd 			}
    225       1.20  christos 			if ((error = vn_writechk(vp)) != 0 ||
    226      1.101  christos 			    (error = VOP_ACCESS(vp, VWRITE, cred, l)) != 0)
    227       1.10       cgd 				goto bad;
    228       1.58     blymn #ifdef VERIFIED_EXEC
    229       1.92      elad 			if (vhe != NULL) {
    230       1.90      elad 				veriexec_report("Write access request.",
    231      1.102      elad 						pathbuf, &va, l,
    232       1.90      elad 						REPORT_NOVERBOSE,
    233       1.90      elad 						REPORT_ALARM,
    234       1.90      elad 						REPORT_NOPANIC);
    235       1.90      elad 
    236       1.91      elad 				/* IPS mode: Deny writing to monitored files. */
    237       1.91      elad 				if (veriexec_strict >= 2) {
    238       1.58     blymn 					error = EPERM;
    239       1.58     blymn 					goto bad;
    240       1.58     blymn 				} else {
    241       1.92      elad 					vhe->status = FINGERPRINT_NOTEVAL;
    242       1.58     blymn 				}
    243       1.58     blymn 			}
    244       1.58     blymn #endif
    245       1.10       cgd 		}
    246       1.10       cgd 	}
    247       1.87     blymn 
    248       1.10       cgd 	if (fmode & O_TRUNC) {
    249       1.28      fvdl 		VOP_UNLOCK(vp, 0);			/* XXX */
    250       1.75   hannken 		if ((error = vn_start_write(vp, &mp, V_WAIT | V_PCATCH)) != 0) {
    251       1.99   hannken 			vrele(vp);
    252       1.75   hannken 			return (error);
    253       1.75   hannken 		}
    254      1.101  christos 		VOP_LEASE(vp, l, cred, LEASE_WRITE);
    255       1.28      fvdl 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);	/* XXX */
    256       1.19   mycroft 		VATTR_NULL(&va);
    257       1.19   mycroft 		va.va_size = 0;
    258      1.101  christos 		error = VOP_SETATTR(vp, &va, cred, l);
    259       1.75   hannken 		vn_finished_write(mp, 0);
    260       1.75   hannken 		if (error != 0)
    261       1.10       cgd 			goto bad;
    262       1.10       cgd 	}
    263      1.101  christos 	if ((error = VOP_OPEN(vp, fmode, cred, l)) != 0)
    264       1.10       cgd 		goto bad;
    265       1.45       chs 	if (vp->v_type == VREG &&
    266       1.45       chs 	    uvn_attach(vp, fmode & FWRITE ? VM_PROT_WRITE : 0) == NULL) {
    267       1.45       chs 		error = EIO;
    268       1.45       chs 		goto bad;
    269       1.45       chs 	}
    270       1.10       cgd 	if (fmode & FWRITE)
    271       1.10       cgd 		vp->v_writecount++;
    272       1.45       chs 
    273       1.10       cgd 	return (0);
    274       1.10       cgd bad:
    275       1.10       cgd 	vput(vp);
    276       1.10       cgd 	return (error);
    277       1.10       cgd }
    278       1.10       cgd 
    279       1.10       cgd /*
    280       1.10       cgd  * Check for write permissions on the specified vnode.
    281       1.28      fvdl  * Prototype text segments cannot be written.
    282       1.10       cgd  */
    283       1.20  christos int
    284       1.89   thorpej vn_writechk(struct vnode *vp)
    285       1.10       cgd {
    286       1.10       cgd 
    287       1.10       cgd 	/*
    288       1.45       chs 	 * If the vnode is in use as a process's text,
    289       1.45       chs 	 * we can't allow writing.
    290       1.10       cgd 	 */
    291       1.45       chs 	if (vp->v_flag & VTEXT)
    292       1.25       mrg 		return (ETXTBSY);
    293       1.10       cgd 	return (0);
    294       1.42       chs }
    295       1.42       chs 
    296       1.42       chs /*
    297       1.51   thorpej  * Mark a vnode as having executable mappings.
    298       1.42       chs  */
    299       1.42       chs void
    300       1.89   thorpej vn_markexec(struct vnode *vp)
    301       1.42       chs {
    302       1.51   thorpej 	if ((vp->v_flag & VEXECMAP) == 0) {
    303       1.53       chs 		uvmexp.filepages -= vp->v_uobj.uo_npages;
    304       1.53       chs 		uvmexp.execpages += vp->v_uobj.uo_npages;
    305       1.46       chs 	}
    306       1.51   thorpej 	vp->v_flag |= VEXECMAP;
    307       1.55       chs }
    308       1.55       chs 
    309       1.55       chs /*
    310       1.55       chs  * Mark a vnode as being the text of a process.
    311       1.55       chs  * Fail if the vnode is currently writable.
    312       1.55       chs  */
    313       1.55       chs int
    314       1.89   thorpej vn_marktext(struct vnode *vp)
    315       1.55       chs {
    316       1.55       chs 
    317       1.55       chs 	if (vp->v_writecount != 0) {
    318       1.55       chs 		KASSERT((vp->v_flag & VTEXT) == 0);
    319       1.55       chs 		return (ETXTBSY);
    320       1.55       chs 	}
    321       1.55       chs 	vp->v_flag |= VTEXT;
    322       1.55       chs 	vn_markexec(vp);
    323       1.55       chs 	return (0);
    324       1.10       cgd }
    325       1.10       cgd 
    326       1.10       cgd /*
    327       1.10       cgd  * Vnode close call
    328       1.32  wrstuden  *
    329       1.32  wrstuden  * Note: takes an unlocked vnode, while VOP_CLOSE takes a locked node.
    330       1.10       cgd  */
    331       1.20  christos int
    332      1.101  christos vn_close(struct vnode *vp, int flags, struct ucred *cred, struct lwp *l)
    333       1.10       cgd {
    334       1.10       cgd 	int error;
    335       1.10       cgd 
    336       1.10       cgd 	if (flags & FWRITE)
    337       1.10       cgd 		vp->v_writecount--;
    338       1.32  wrstuden 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    339      1.101  christos 	error = VOP_CLOSE(vp, flags, cred, l);
    340       1.32  wrstuden 	vput(vp);
    341       1.10       cgd 	return (error);
    342       1.10       cgd }
    343       1.10       cgd 
    344       1.10       cgd /*
    345       1.10       cgd  * Package up an I/O request on a vnode into a uio and do it.
    346       1.10       cgd  */
    347       1.20  christos int
    348       1.89   thorpej vn_rdwr(enum uio_rw rw, struct vnode *vp, caddr_t base, int len, off_t offset,
    349       1.89   thorpej     enum uio_seg segflg, int ioflg, struct ucred *cred, size_t *aresid,
    350      1.101  christos     struct lwp *l)
    351       1.10       cgd {
    352       1.10       cgd 	struct uio auio;
    353       1.10       cgd 	struct iovec aiov;
    354  1.106.2.2      yamt 	struct mount *mp = NULL;
    355       1.10       cgd 	int error;
    356       1.10       cgd 
    357       1.50       chs 	if ((ioflg & IO_NODELOCKED) == 0) {
    358       1.50       chs 		if (rw == UIO_READ) {
    359       1.50       chs 			vn_lock(vp, LK_SHARED | LK_RETRY);
    360       1.75   hannken 		} else /* UIO_WRITE */ {
    361       1.75   hannken 			if (vp->v_type != VCHR &&
    362       1.75   hannken 			    (error = vn_start_write(vp, &mp, V_WAIT | V_PCATCH))
    363       1.75   hannken 			    != 0)
    364       1.75   hannken 				return (error);
    365       1.50       chs 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    366       1.50       chs 		}
    367       1.50       chs 	}
    368       1.10       cgd 	auio.uio_iov = &aiov;
    369       1.10       cgd 	auio.uio_iovcnt = 1;
    370       1.10       cgd 	aiov.iov_base = base;
    371       1.10       cgd 	aiov.iov_len = len;
    372       1.10       cgd 	auio.uio_resid = len;
    373       1.10       cgd 	auio.uio_offset = offset;
    374       1.10       cgd 	auio.uio_rw = rw;
    375      1.106      yamt 	if (segflg == UIO_SYSSPACE) {
    376      1.106      yamt 		UIO_SETUP_SYSSPACE(&auio);
    377      1.106      yamt 	} else {
    378      1.106      yamt 		auio.uio_vmspace = l->l_proc->p_vmspace;
    379      1.106      yamt 	}
    380       1.11   mycroft 	if (rw == UIO_READ) {
    381       1.10       cgd 		error = VOP_READ(vp, &auio, ioflg, cred);
    382       1.11   mycroft 	} else {
    383       1.10       cgd 		error = VOP_WRITE(vp, &auio, ioflg, cred);
    384       1.11   mycroft 	}
    385       1.10       cgd 	if (aresid)
    386       1.10       cgd 		*aresid = auio.uio_resid;
    387       1.10       cgd 	else
    388       1.10       cgd 		if (auio.uio_resid && error == 0)
    389       1.10       cgd 			error = EIO;
    390       1.75   hannken 	if ((ioflg & IO_NODELOCKED) == 0) {
    391       1.75   hannken 		if (rw == UIO_WRITE)
    392       1.75   hannken 			vn_finished_write(mp, 0);
    393       1.28      fvdl 		VOP_UNLOCK(vp, 0);
    394       1.75   hannken 	}
    395       1.10       cgd 	return (error);
    396       1.23      fvdl }
    397       1.23      fvdl 
    398       1.23      fvdl int
    399       1.89   thorpej vn_readdir(struct file *fp, char *bf, int segflg, u_int count, int *done,
    400      1.101  christos     struct lwp *l, off_t **cookies, int *ncookies)
    401       1.23      fvdl {
    402       1.23      fvdl 	struct vnode *vp = (struct vnode *)fp->f_data;
    403       1.23      fvdl 	struct iovec aiov;
    404       1.23      fvdl 	struct uio auio;
    405       1.23      fvdl 	int error, eofflag;
    406       1.23      fvdl 
    407       1.23      fvdl unionread:
    408       1.23      fvdl 	if (vp->v_type != VDIR)
    409       1.23      fvdl 		return (EINVAL);
    410       1.88  christos 	aiov.iov_base = bf;
    411       1.23      fvdl 	aiov.iov_len = count;
    412       1.23      fvdl 	auio.uio_iov = &aiov;
    413       1.23      fvdl 	auio.uio_iovcnt = 1;
    414       1.23      fvdl 	auio.uio_rw = UIO_READ;
    415      1.106      yamt 	if (segflg == UIO_SYSSPACE) {
    416      1.106      yamt 		UIO_SETUP_SYSSPACE(&auio);
    417      1.106      yamt 	} else {
    418      1.106      yamt 		KASSERT(l == curlwp);
    419      1.106      yamt 		auio.uio_vmspace = l->l_proc->p_vmspace;
    420      1.106      yamt 	}
    421       1.23      fvdl 	auio.uio_resid = count;
    422       1.50       chs 	vn_lock(vp, LK_SHARED | LK_RETRY);
    423       1.23      fvdl 	auio.uio_offset = fp->f_offset;
    424       1.28      fvdl 	error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, cookies,
    425       1.23      fvdl 		    ncookies);
    426       1.23      fvdl 	fp->f_offset = auio.uio_offset;
    427       1.28      fvdl 	VOP_UNLOCK(vp, 0);
    428       1.23      fvdl 	if (error)
    429       1.23      fvdl 		return (error);
    430       1.23      fvdl 
    431       1.66  jdolecek #if defined(UNION) || defined(LKM)
    432       1.66  jdolecek 	if (count == auio.uio_resid && vn_union_readdir_hook) {
    433       1.66  jdolecek 		struct vnode *ovp = vp;
    434       1.23      fvdl 
    435      1.101  christos 		error = (*vn_union_readdir_hook)(&vp, fp, l);
    436       1.66  jdolecek 		if (error)
    437       1.66  jdolecek 			return (error);
    438       1.66  jdolecek 		if (vp != ovp)
    439       1.23      fvdl 			goto unionread;
    440       1.23      fvdl 	}
    441       1.66  jdolecek #endif /* UNION || LKM */
    442       1.23      fvdl 
    443       1.23      fvdl 	if (count == auio.uio_resid && (vp->v_flag & VROOT) &&
    444       1.23      fvdl 	    (vp->v_mount->mnt_flag & MNT_UNION)) {
    445       1.23      fvdl 		struct vnode *tvp = vp;
    446       1.23      fvdl 		vp = vp->v_mount->mnt_vnodecovered;
    447       1.23      fvdl 		VREF(vp);
    448       1.68       dsl 		fp->f_data = vp;
    449       1.23      fvdl 		fp->f_offset = 0;
    450       1.23      fvdl 		vrele(tvp);
    451       1.23      fvdl 		goto unionread;
    452       1.23      fvdl 	}
    453       1.23      fvdl 	*done = count - auio.uio_resid;
    454       1.23      fvdl 	return error;
    455       1.10       cgd }
    456       1.10       cgd 
    457       1.10       cgd /*
    458       1.10       cgd  * File table vnode read routine.
    459       1.10       cgd  */
    460       1.56  gmcgarry static int
    461       1.89   thorpej vn_read(struct file *fp, off_t *offset, struct uio *uio, struct ucred *cred,
    462       1.89   thorpej     int flags)
    463       1.10       cgd {
    464       1.28      fvdl 	struct vnode *vp = (struct vnode *)fp->f_data;
    465      1.100      yamt 	int count, error, ioflag;
    466      1.106      yamt 	struct lwp *l = curlwp;
    467       1.10       cgd 
    468      1.106      yamt 	VOP_LEASE(vp, l, cred, LEASE_READ);
    469      1.100      yamt 	ioflag = IO_ADV_ENCODE(fp->f_advice);
    470       1.31    kleink 	if (fp->f_flag & FNONBLOCK)
    471       1.31    kleink 		ioflag |= IO_NDELAY;
    472       1.31    kleink 	if ((fp->f_flag & (FFSYNC | FRSYNC)) == (FFSYNC | FRSYNC))
    473       1.31    kleink 		ioflag |= IO_SYNC;
    474       1.37  wrstuden 	if (fp->f_flag & FALTIO)
    475       1.37  wrstuden 		ioflag |= IO_ALTSEMANTICS;
    476       1.50       chs 	vn_lock(vp, LK_SHARED | LK_RETRY);
    477       1.29   thorpej 	uio->uio_offset = *offset;
    478       1.10       cgd 	count = uio->uio_resid;
    479       1.31    kleink 	error = VOP_READ(vp, uio, ioflag, cred);
    480       1.29   thorpej 	if (flags & FOF_UPDATE_OFFSET)
    481       1.29   thorpej 		*offset += count - uio->uio_resid;
    482       1.28      fvdl 	VOP_UNLOCK(vp, 0);
    483       1.10       cgd 	return (error);
    484       1.10       cgd }
    485       1.10       cgd 
    486       1.10       cgd /*
    487       1.10       cgd  * File table vnode write routine.
    488       1.10       cgd  */
    489       1.56  gmcgarry static int
    490       1.89   thorpej vn_write(struct file *fp, off_t *offset, struct uio *uio, struct ucred *cred,
    491       1.89   thorpej     int flags)
    492       1.10       cgd {
    493       1.28      fvdl 	struct vnode *vp = (struct vnode *)fp->f_data;
    494       1.75   hannken 	struct mount *mp;
    495       1.17   mycroft 	int count, error, ioflag = IO_UNIT;
    496      1.106      yamt 	struct lwp *l = curlwp;
    497       1.10       cgd 
    498       1.10       cgd 	if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
    499       1.10       cgd 		ioflag |= IO_APPEND;
    500       1.10       cgd 	if (fp->f_flag & FNONBLOCK)
    501       1.10       cgd 		ioflag |= IO_NDELAY;
    502       1.24   thorpej 	if (fp->f_flag & FFSYNC ||
    503       1.24   thorpej 	    (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
    504       1.24   thorpej 		ioflag |= IO_SYNC;
    505       1.31    kleink 	else if (fp->f_flag & FDSYNC)
    506       1.31    kleink 		ioflag |= IO_DSYNC;
    507       1.37  wrstuden 	if (fp->f_flag & FALTIO)
    508       1.37  wrstuden 		ioflag |= IO_ALTSEMANTICS;
    509       1.75   hannken 	mp = NULL;
    510       1.75   hannken 	if (vp->v_type != VCHR &&
    511       1.75   hannken 	    (error = vn_start_write(vp, &mp, V_WAIT | V_PCATCH)) != 0)
    512       1.75   hannken 		return (error);
    513      1.106      yamt 	VOP_LEASE(vp, l, cred, LEASE_WRITE);
    514       1.28      fvdl 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    515       1.29   thorpej 	uio->uio_offset = *offset;
    516       1.10       cgd 	count = uio->uio_resid;
    517       1.10       cgd 	error = VOP_WRITE(vp, uio, ioflag, cred);
    518       1.29   thorpej 	if (flags & FOF_UPDATE_OFFSET) {
    519       1.29   thorpej 		if (ioflag & IO_APPEND)
    520       1.29   thorpej 			*offset = uio->uio_offset;
    521       1.29   thorpej 		else
    522       1.29   thorpej 			*offset += count - uio->uio_resid;
    523       1.29   thorpej 	}
    524       1.28      fvdl 	VOP_UNLOCK(vp, 0);
    525       1.75   hannken 	vn_finished_write(mp, 0);
    526       1.10       cgd 	return (error);
    527       1.10       cgd }
    528       1.10       cgd 
    529       1.10       cgd /*
    530       1.10       cgd  * File table vnode stat routine.
    531       1.10       cgd  */
    532       1.48  jdolecek static int
    533      1.101  christos vn_statfile(struct file *fp, struct stat *sb, struct lwp *l)
    534       1.48  jdolecek {
    535       1.48  jdolecek 	struct vnode *vp = (struct vnode *)fp->f_data;
    536       1.48  jdolecek 
    537      1.101  christos 	return vn_stat(vp, sb, l);
    538       1.48  jdolecek }
    539       1.48  jdolecek 
    540       1.20  christos int
    541      1.101  christos vn_stat(struct vnode *vp, struct stat *sb, struct lwp *l)
    542       1.10       cgd {
    543       1.19   mycroft 	struct vattr va;
    544       1.10       cgd 	int error;
    545       1.35  wrstuden 	mode_t mode;
    546       1.10       cgd 
    547      1.101  christos 	error = VOP_GETATTR(vp, &va, l->l_proc->p_ucred, l);
    548       1.10       cgd 	if (error)
    549       1.10       cgd 		return (error);
    550       1.10       cgd 	/*
    551       1.10       cgd 	 * Copy from vattr table
    552       1.10       cgd 	 */
    553       1.19   mycroft 	sb->st_dev = va.va_fsid;
    554       1.19   mycroft 	sb->st_ino = va.va_fileid;
    555       1.19   mycroft 	mode = va.va_mode;
    556       1.10       cgd 	switch (vp->v_type) {
    557       1.10       cgd 	case VREG:
    558       1.10       cgd 		mode |= S_IFREG;
    559       1.10       cgd 		break;
    560       1.10       cgd 	case VDIR:
    561       1.10       cgd 		mode |= S_IFDIR;
    562       1.10       cgd 		break;
    563       1.10       cgd 	case VBLK:
    564       1.10       cgd 		mode |= S_IFBLK;
    565       1.10       cgd 		break;
    566       1.10       cgd 	case VCHR:
    567       1.10       cgd 		mode |= S_IFCHR;
    568       1.10       cgd 		break;
    569       1.10       cgd 	case VLNK:
    570       1.10       cgd 		mode |= S_IFLNK;
    571       1.10       cgd 		break;
    572       1.10       cgd 	case VSOCK:
    573       1.10       cgd 		mode |= S_IFSOCK;
    574       1.10       cgd 		break;
    575       1.10       cgd 	case VFIFO:
    576       1.10       cgd 		mode |= S_IFIFO;
    577       1.10       cgd 		break;
    578       1.10       cgd 	default:
    579       1.10       cgd 		return (EBADF);
    580       1.10       cgd 	};
    581       1.10       cgd 	sb->st_mode = mode;
    582       1.19   mycroft 	sb->st_nlink = va.va_nlink;
    583       1.19   mycroft 	sb->st_uid = va.va_uid;
    584       1.19   mycroft 	sb->st_gid = va.va_gid;
    585       1.19   mycroft 	sb->st_rdev = va.va_rdev;
    586       1.19   mycroft 	sb->st_size = va.va_size;
    587       1.19   mycroft 	sb->st_atimespec = va.va_atime;
    588       1.19   mycroft 	sb->st_mtimespec = va.va_mtime;
    589       1.19   mycroft 	sb->st_ctimespec = va.va_ctime;
    590       1.69      fvdl 	sb->st_birthtimespec = va.va_birthtime;
    591       1.19   mycroft 	sb->st_blksize = va.va_blocksize;
    592       1.19   mycroft 	sb->st_flags = va.va_flags;
    593       1.22   mycroft 	sb->st_gen = 0;
    594       1.19   mycroft 	sb->st_blocks = va.va_bytes / S_BLKSIZE;
    595       1.10       cgd 	return (0);
    596       1.37  wrstuden }
    597       1.37  wrstuden 
    598       1.37  wrstuden /*
    599       1.37  wrstuden  * File table vnode fcntl routine.
    600       1.37  wrstuden  */
    601       1.56  gmcgarry static int
    602      1.101  christos vn_fcntl(struct file *fp, u_int com, void *data, struct lwp *l)
    603       1.37  wrstuden {
    604       1.41  augustss 	struct vnode *vp = ((struct vnode *)fp->f_data);
    605       1.37  wrstuden 	int error;
    606       1.37  wrstuden 
    607       1.37  wrstuden 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    608      1.101  christos 	error = VOP_FCNTL(vp, com, data, fp->f_flag, l->l_proc->p_ucred, l);
    609       1.37  wrstuden 	VOP_UNLOCK(vp, 0);
    610       1.37  wrstuden 	return (error);
    611       1.10       cgd }
    612       1.10       cgd 
    613       1.10       cgd /*
    614       1.10       cgd  * File table vnode ioctl routine.
    615       1.10       cgd  */
    616       1.56  gmcgarry static int
    617      1.101  christos vn_ioctl(struct file *fp, u_long com, void *data, struct lwp *l)
    618       1.10       cgd {
    619       1.41  augustss 	struct vnode *vp = ((struct vnode *)fp->f_data);
    620      1.101  christos 	struct proc *p = l->l_proc;
    621       1.10       cgd 	struct vattr vattr;
    622       1.10       cgd 	int error;
    623       1.10       cgd 
    624       1.10       cgd 	switch (vp->v_type) {
    625       1.10       cgd 
    626       1.10       cgd 	case VREG:
    627       1.10       cgd 	case VDIR:
    628       1.10       cgd 		if (com == FIONREAD) {
    629      1.101  christos 			error = VOP_GETATTR(vp, &vattr, l->l_proc->p_ucred, l);
    630       1.20  christos 			if (error)
    631       1.10       cgd 				return (error);
    632       1.10       cgd 			*(int *)data = vattr.va_size - fp->f_offset;
    633       1.10       cgd 			return (0);
    634       1.60    atatat 		}
    635       1.82  christos 		if ((com == FIONWRITE) || (com == FIONSPACE)) {
    636       1.81  wrstuden 			/*
    637       1.81  wrstuden 			 * Files don't have send queues, so there never
    638       1.81  wrstuden 			 * are any bytes in them, nor is there any
    639       1.81  wrstuden 			 * open space in them.
    640       1.81  wrstuden 			 */
    641       1.81  wrstuden 			*(int *)data = 0;
    642       1.81  wrstuden 			return (0);
    643       1.81  wrstuden 		}
    644       1.60    atatat 		if (com == FIOGETBMAP) {
    645       1.60    atatat 			daddr_t *block;
    646       1.60    atatat 
    647       1.62    atatat 			if (*(daddr_t *)data < 0)
    648       1.62    atatat 				return (EINVAL);
    649       1.60    atatat 			block = (daddr_t *)data;
    650       1.60    atatat 			return (VOP_BMAP(vp, *block, NULL, block, NULL));
    651       1.61      fvdl 		}
    652       1.61      fvdl 		if (com == OFIOGETBMAP) {
    653       1.61      fvdl 			daddr_t ibn, obn;
    654       1.61      fvdl 
    655       1.62    atatat 			if (*(int32_t *)data < 0)
    656       1.62    atatat 				return (EINVAL);
    657       1.61      fvdl 			ibn = (daddr_t)*(int32_t *)data;
    658       1.61      fvdl 			error = VOP_BMAP(vp, ibn, NULL, &obn, NULL);
    659       1.61      fvdl 			*(int32_t *)data = (int32_t)obn;
    660       1.61      fvdl 			return error;
    661       1.10       cgd 		}
    662       1.10       cgd 		if (com == FIONBIO || com == FIOASYNC)	/* XXX */
    663       1.10       cgd 			return (0);			/* XXX */
    664       1.10       cgd 		/* fall into ... */
    665       1.10       cgd 	case VFIFO:
    666       1.10       cgd 	case VCHR:
    667       1.10       cgd 	case VBLK:
    668      1.101  christos 		error = VOP_IOCTL(vp, com, data, fp->f_flag,
    669      1.101  christos 		    l->l_proc->p_ucred, l);
    670       1.10       cgd 		if (error == 0 && com == TIOCSCTTY) {
    671       1.13       cgd 			if (p->p_session->s_ttyvp)
    672       1.13       cgd 				vrele(p->p_session->s_ttyvp);
    673       1.10       cgd 			p->p_session->s_ttyvp = vp;
    674       1.10       cgd 			VREF(vp);
    675       1.10       cgd 		}
    676       1.10       cgd 		return (error);
    677       1.63  perseant 
    678       1.63  perseant 	default:
    679       1.63  perseant 		return (EPASSTHROUGH);
    680       1.10       cgd 	}
    681       1.10       cgd }
    682       1.10       cgd 
    683       1.10       cgd /*
    684       1.21   mycroft  * File table vnode poll routine.
    685       1.10       cgd  */
    686       1.56  gmcgarry static int
    687      1.101  christos vn_poll(struct file *fp, int events, struct lwp *l)
    688       1.10       cgd {
    689       1.10       cgd 
    690      1.101  christos 	return (VOP_POLL(((struct vnode *)fp->f_data), events, l));
    691       1.57  jdolecek }
    692       1.57  jdolecek 
    693       1.57  jdolecek /*
    694       1.57  jdolecek  * File table vnode kqfilter routine.
    695       1.57  jdolecek  */
    696       1.57  jdolecek int
    697       1.89   thorpej vn_kqfilter(struct file *fp, struct knote *kn)
    698       1.57  jdolecek {
    699       1.57  jdolecek 
    700       1.57  jdolecek 	return (VOP_KQFILTER((struct vnode *)fp->f_data, kn));
    701       1.28      fvdl }
    702       1.28      fvdl 
    703       1.28      fvdl /*
    704       1.28      fvdl  * Check that the vnode is still valid, and if so
    705       1.28      fvdl  * acquire requested lock.
    706       1.28      fvdl  */
    707       1.28      fvdl int
    708       1.89   thorpej vn_lock(struct vnode *vp, int flags)
    709       1.28      fvdl {
    710       1.28      fvdl 	int error;
    711       1.34  sommerfe 
    712       1.84      yamt #if 0
    713       1.80      yamt 	KASSERT(vp->v_usecount > 0 || (flags & LK_INTERLOCK) != 0
    714       1.80      yamt 	    || (vp->v_flag & VONWORKLST) != 0);
    715       1.84      yamt #endif
    716      1.103      yamt 	KASSERT((flags &
    717      1.103      yamt 	    ~(LK_INTERLOCK|LK_SHARED|LK_EXCLUSIVE|LK_DRAIN|LK_NOWAIT|LK_RETRY|
    718      1.104      yamt 	    LK_SETRECURSE|LK_CANRECURSE))
    719      1.103      yamt 	    == 0);
    720       1.80      yamt 
    721       1.28      fvdl 	do {
    722       1.36   mycroft 		if ((flags & LK_INTERLOCK) == 0)
    723       1.28      fvdl 			simple_lock(&vp->v_interlock);
    724       1.28      fvdl 		if (vp->v_flag & VXLOCK) {
    725       1.49       chs 			if (flags & LK_NOWAIT) {
    726       1.49       chs 				simple_unlock(&vp->v_interlock);
    727       1.49       chs 				return EBUSY;
    728       1.49       chs 			}
    729       1.28      fvdl 			vp->v_flag |= VXWANT;
    730       1.49       chs 			ltsleep(vp, PINOD | PNORELOCK,
    731       1.44  sommerfe 			    "vn_lock", 0, &vp->v_interlock);
    732       1.28      fvdl 			error = ENOENT;
    733       1.28      fvdl 		} else {
    734       1.79      yamt 			error = VOP_LOCK(vp,
    735       1.79      yamt 			    (flags & ~LK_RETRY) | LK_INTERLOCK);
    736       1.49       chs 			if (error == 0 || error == EDEADLK || error == EBUSY)
    737       1.28      fvdl 				return (error);
    738       1.28      fvdl 		}
    739       1.28      fvdl 		flags &= ~LK_INTERLOCK;
    740       1.28      fvdl 	} while (flags & LK_RETRY);
    741       1.28      fvdl 	return (error);
    742       1.10       cgd }
    743       1.10       cgd 
    744       1.10       cgd /*
    745       1.10       cgd  * File table vnode close routine.
    746       1.10       cgd  */
    747       1.56  gmcgarry static int
    748      1.101  christos vn_closefile(struct file *fp, struct lwp *l)
    749       1.10       cgd {
    750       1.10       cgd 
    751       1.10       cgd 	return (vn_close(((struct vnode *)fp->f_data), fp->f_flag,
    752      1.101  christos 		fp->f_cred, l));
    753       1.39      fvdl }
    754       1.39      fvdl 
    755       1.39      fvdl /*
    756       1.39      fvdl  * Enable LK_CANRECURSE on lock. Return prior status.
    757       1.39      fvdl  */
    758       1.39      fvdl u_int
    759       1.89   thorpej vn_setrecurse(struct vnode *vp)
    760       1.39      fvdl {
    761       1.39      fvdl 	struct lock *lkp = &vp->v_lock;
    762       1.39      fvdl 	u_int retval = lkp->lk_flags & LK_CANRECURSE;
    763       1.39      fvdl 
    764       1.39      fvdl 	lkp->lk_flags |= LK_CANRECURSE;
    765       1.39      fvdl 	return retval;
    766       1.39      fvdl }
    767       1.39      fvdl 
    768       1.39      fvdl /*
    769       1.39      fvdl  * Called when done with locksetrecurse.
    770       1.39      fvdl  */
    771       1.39      fvdl void
    772       1.89   thorpej vn_restorerecurse(struct vnode *vp, u_int flags)
    773       1.39      fvdl {
    774       1.39      fvdl 	struct lock *lkp = &vp->v_lock;
    775       1.39      fvdl 
    776       1.39      fvdl 	lkp->lk_flags &= ~LK_CANRECURSE;
    777       1.39      fvdl 	lkp->lk_flags |= flags;
    778       1.75   hannken }
    779       1.77   hannken 
    780       1.77   hannken int
    781       1.77   hannken vn_cow_establish(struct vnode *vp,
    782       1.78   hannken     int (*func)(void *, struct buf *), void *cookie)
    783       1.77   hannken {
    784       1.77   hannken 	int s;
    785       1.77   hannken 	struct spec_cow_entry *e;
    786       1.77   hannken 
    787       1.77   hannken 	MALLOC(e, struct spec_cow_entry *, sizeof(struct spec_cow_entry),
    788       1.77   hannken 	    M_DEVBUF, M_WAITOK);
    789       1.77   hannken 	e->ce_func = func;
    790       1.77   hannken 	e->ce_cookie = cookie;
    791       1.77   hannken 
    792       1.77   hannken 	SPEC_COW_LOCK(vp->v_specinfo, s);
    793       1.77   hannken 	vp->v_spec_cow_req++;
    794       1.77   hannken 	while (vp->v_spec_cow_count > 0)
    795       1.77   hannken 		ltsleep(&vp->v_spec_cow_req, PRIBIO, "cowlist", 0,
    796       1.77   hannken 		    &vp->v_spec_cow_slock);
    797       1.77   hannken 
    798       1.77   hannken 	SLIST_INSERT_HEAD(&vp->v_spec_cow_head, e, ce_list);
    799       1.77   hannken 
    800       1.77   hannken 	vp->v_spec_cow_req--;
    801       1.77   hannken 	if (vp->v_spec_cow_req == 0)
    802       1.77   hannken 		wakeup(&vp->v_spec_cow_req);
    803       1.77   hannken 	SPEC_COW_UNLOCK(vp->v_specinfo, s);
    804       1.77   hannken 
    805       1.77   hannken 	return 0;
    806       1.77   hannken }
    807       1.77   hannken 
    808       1.77   hannken int
    809       1.77   hannken vn_cow_disestablish(struct vnode *vp,
    810       1.78   hannken     int (*func)(void *, struct buf *), void *cookie)
    811       1.77   hannken {
    812       1.77   hannken 	int s;
    813       1.77   hannken 	struct spec_cow_entry *e;
    814       1.77   hannken 
    815       1.77   hannken 	SPEC_COW_LOCK(vp->v_specinfo, s);
    816       1.77   hannken 	vp->v_spec_cow_req++;
    817       1.77   hannken 	while (vp->v_spec_cow_count > 0)
    818       1.77   hannken 		ltsleep(&vp->v_spec_cow_req, PRIBIO, "cowlist", 0,
    819       1.77   hannken 		    &vp->v_spec_cow_slock);
    820       1.77   hannken 
    821       1.77   hannken 	SLIST_FOREACH(e, &vp->v_spec_cow_head, ce_list)
    822       1.77   hannken 		if (e->ce_func == func && e->ce_cookie == cookie) {
    823       1.77   hannken 			SLIST_REMOVE(&vp->v_spec_cow_head, e,
    824       1.77   hannken 			    spec_cow_entry, ce_list);
    825       1.77   hannken 			FREE(e, M_DEVBUF);
    826       1.77   hannken 			break;
    827       1.77   hannken 		}
    828       1.77   hannken 
    829       1.77   hannken 	vp->v_spec_cow_req--;
    830       1.77   hannken 	if (vp->v_spec_cow_req == 0)
    831       1.77   hannken 		wakeup(&vp->v_spec_cow_req);
    832       1.77   hannken 	SPEC_COW_UNLOCK(vp->v_specinfo, s);
    833       1.77   hannken 
    834       1.77   hannken 	return e ? 0 : EINVAL;
    835       1.77   hannken }
    836       1.85   thorpej 
    837       1.85   thorpej /*
    838       1.85   thorpej  * Simplified in-kernel wrapper calls for extended attribute access.
    839       1.85   thorpej  * Both calls pass in a NULL credential, authorizing a "kernel" access.
    840       1.85   thorpej  * Set IO_NODELOCKED in ioflg if the vnode is already locked.
    841       1.85   thorpej  */
    842       1.85   thorpej int
    843       1.85   thorpej vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace,
    844      1.101  christos     const char *attrname, size_t *buflen, void *bf, struct lwp *l)
    845       1.85   thorpej {
    846       1.85   thorpej 	struct uio auio;
    847       1.85   thorpej 	struct iovec aiov;
    848       1.85   thorpej 	int error;
    849       1.85   thorpej 
    850       1.85   thorpej 	aiov.iov_len = *buflen;
    851       1.88  christos 	aiov.iov_base = bf;
    852       1.85   thorpej 
    853       1.85   thorpej 	auio.uio_iov = &aiov;
    854       1.85   thorpej 	auio.uio_iovcnt = 1;
    855       1.85   thorpej 	auio.uio_rw = UIO_READ;
    856       1.85   thorpej 	auio.uio_offset = 0;
    857       1.85   thorpej 	auio.uio_resid = *buflen;
    858      1.106      yamt 	UIO_SETUP_SYSSPACE(&auio);
    859       1.85   thorpej 
    860       1.85   thorpej 	if ((ioflg & IO_NODELOCKED) == 0)
    861       1.85   thorpej 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    862       1.86     perry 
    863       1.85   thorpej 	error = VOP_GETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, NULL,
    864      1.101  christos 	    l);
    865       1.86     perry 
    866       1.85   thorpej 	if ((ioflg & IO_NODELOCKED) == 0)
    867       1.85   thorpej 		VOP_UNLOCK(vp, 0);
    868       1.86     perry 
    869       1.85   thorpej 	if (error == 0)
    870       1.85   thorpej 		*buflen = *buflen - auio.uio_resid;
    871       1.86     perry 
    872       1.85   thorpej 	return (error);
    873       1.85   thorpej }
    874       1.85   thorpej 
    875       1.85   thorpej /*
    876       1.85   thorpej  * XXX Failure mode if partially written?
    877       1.85   thorpej  */
    878       1.85   thorpej int
    879       1.85   thorpej vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace,
    880      1.101  christos     const char *attrname, size_t buflen, const void *bf, struct lwp *l)
    881       1.85   thorpej {
    882       1.85   thorpej 	struct uio auio;
    883       1.85   thorpej 	struct iovec aiov;
    884       1.85   thorpej 	struct mount *mp;
    885       1.85   thorpej 	int error;
    886       1.85   thorpej 
    887       1.85   thorpej 	aiov.iov_len = buflen;
    888       1.88  christos 	aiov.iov_base = __UNCONST(bf);		/* XXXUNCONST kills const */
    889       1.85   thorpej 
    890       1.85   thorpej 	auio.uio_iov = &aiov;
    891       1.85   thorpej 	auio.uio_iovcnt = 1;
    892       1.85   thorpej 	auio.uio_rw = UIO_WRITE;
    893       1.85   thorpej 	auio.uio_offset = 0;
    894       1.85   thorpej 	auio.uio_resid = buflen;
    895      1.106      yamt 	UIO_SETUP_SYSSPACE(&auio);
    896       1.85   thorpej 
    897       1.85   thorpej 	if ((ioflg & IO_NODELOCKED) == 0) {
    898       1.85   thorpej 		if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
    899       1.85   thorpej 			return (error);
    900       1.85   thorpej 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    901       1.85   thorpej 	}
    902       1.85   thorpej 
    903      1.101  christos 	error = VOP_SETEXTATTR(vp, attrnamespace, attrname, &auio, NULL, l);
    904       1.85   thorpej 
    905       1.85   thorpej 	if ((ioflg & IO_NODELOCKED) == 0) {
    906       1.85   thorpej 		vn_finished_write(mp, 0);
    907       1.85   thorpej 		VOP_UNLOCK(vp, 0);
    908       1.85   thorpej 	}
    909       1.85   thorpej 
    910       1.85   thorpej 	return (error);
    911       1.85   thorpej }
    912       1.85   thorpej 
    913       1.85   thorpej int
    914       1.85   thorpej vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace,
    915      1.101  christos     const char *attrname, struct lwp *l)
    916       1.85   thorpej {
    917       1.85   thorpej 	struct mount *mp;
    918       1.85   thorpej 	int error;
    919       1.85   thorpej 
    920       1.85   thorpej 	if ((ioflg & IO_NODELOCKED) == 0) {
    921       1.85   thorpej 		if ((error = vn_start_write(vp, &mp, V_WAIT)) != 0)
    922       1.85   thorpej 			return (error);
    923       1.85   thorpej 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    924       1.85   thorpej 	}
    925       1.85   thorpej 
    926      1.101  christos 	error = VOP_DELETEEXTATTR(vp, attrnamespace, attrname, NULL, l);
    927       1.85   thorpej 	if (error == EOPNOTSUPP)
    928       1.85   thorpej 		error = VOP_SETEXTATTR(vp, attrnamespace, attrname, NULL,
    929      1.101  christos 		    NULL, l);
    930       1.86     perry 
    931       1.85   thorpej 	if ((ioflg & IO_NODELOCKED) == 0) {
    932       1.85   thorpej 		vn_finished_write(mp, 0);
    933       1.85   thorpej 		VOP_UNLOCK(vp, 0);
    934       1.85   thorpej 	}
    935       1.85   thorpej 
    936       1.85   thorpej 	return (error);
    937       1.85   thorpej }
    938       1.95      yamt 
    939       1.95      yamt /*
    940       1.95      yamt  * Preparing to start a filesystem write operation. If the operation is
    941       1.95      yamt  * permitted, then we bump the count of operations in progress and
    942       1.95      yamt  * proceed. If a suspend request is in progress, we wait until the
    943       1.95      yamt  * suspension is over, and then proceed.
    944       1.95      yamt  * V_PCATCH    adds PCATCH to the tsleep flags.
    945       1.95      yamt  * V_WAIT      waits until suspension is over. Otherwise returns EWOULDBLOCK.
    946       1.95      yamt  * V_SLEEPONLY wait, but do not bump the operations count.
    947       1.95      yamt  * V_LOWER     this is a lower level operation. No further vnodes should be
    948       1.95      yamt  *             locked. Otherwise it is a upper level operation. No vnodes
    949       1.95      yamt  *             should be locked.
    950       1.95      yamt  */
    951       1.95      yamt int
    952       1.95      yamt vn_start_write(struct vnode *vp, struct mount **mpp, int flags)
    953       1.95      yamt {
    954       1.95      yamt 	struct mount *mp;
    955       1.95      yamt 	int error, mask, prio;
    956       1.95      yamt 
    957       1.95      yamt 	/*
    958       1.95      yamt 	 * If a vnode is provided, get and return the mount point that
    959       1.95      yamt 	 * to which it will write.
    960       1.95      yamt 	 */
    961       1.95      yamt 	if (vp != NULL) {
    962       1.95      yamt 		*mpp = vp->v_mount;
    963       1.95      yamt 	}
    964       1.95      yamt 	if ((mp = *mpp) == NULL)
    965       1.95      yamt 		return (0);
    966       1.95      yamt 	mp = mp->mnt_leaf;
    967       1.95      yamt 	/*
    968       1.95      yamt 	 * Check on status of suspension.
    969       1.95      yamt 	 */
    970       1.95      yamt 	prio = PUSER - 1;
    971       1.95      yamt 	if (flags & V_PCATCH)
    972       1.95      yamt 		prio |= PCATCH;
    973       1.95      yamt 
    974       1.95      yamt 	if ((flags & V_LOWER) == 0)
    975       1.95      yamt 		mask = IMNT_SUSPEND;
    976       1.95      yamt 	else
    977       1.95      yamt 		mask = IMNT_SUSPENDLOW;
    978       1.95      yamt 
    979       1.95      yamt 	while ((mp->mnt_iflag & mask) != 0) {
    980       1.95      yamt 		if ((flags & V_WAIT) == 0)
    981       1.95      yamt 			return (EWOULDBLOCK);
    982       1.95      yamt 		error = tsleep(&mp->mnt_flag, prio, "suspfs", 0);
    983       1.95      yamt 		if (error)
    984       1.95      yamt 			return (error);
    985       1.95      yamt 	}
    986       1.95      yamt 	if (flags & V_SLEEPONLY)
    987       1.95      yamt 		return (0);
    988       1.95      yamt 	simple_lock(&mp->mnt_slock);
    989       1.95      yamt 	if ((flags & V_LOWER) == 0)
    990       1.95      yamt 		mp->mnt_writeopcountupper++;
    991       1.95      yamt 	else
    992       1.95      yamt 		mp->mnt_writeopcountlower++;
    993       1.95      yamt 	simple_unlock(&mp->mnt_slock);
    994       1.95      yamt 	return (0);
    995       1.95      yamt }
    996       1.95      yamt 
    997       1.95      yamt /*
    998       1.95      yamt  * Filesystem write operation has completed. If we are suspending and this
    999       1.95      yamt  * operation is the last one, notify the suspender that the suspension is
   1000       1.95      yamt  * now in effect.
   1001       1.95      yamt  */
   1002       1.95      yamt void
   1003       1.95      yamt vn_finished_write(struct mount *mp, int flags)
   1004       1.95      yamt {
   1005       1.95      yamt 	if (mp == NULL)
   1006       1.95      yamt 		return;
   1007       1.95      yamt 	mp = mp->mnt_leaf;
   1008       1.95      yamt 	simple_lock(&mp->mnt_slock);
   1009       1.95      yamt 	if ((flags & V_LOWER) == 0) {
   1010       1.95      yamt 		mp->mnt_writeopcountupper--;
   1011       1.95      yamt 		if (mp->mnt_writeopcountupper < 0)
   1012       1.95      yamt 			printf("vn_finished_write: neg cnt upper=%d\n",
   1013       1.95      yamt 			       mp->mnt_writeopcountupper);
   1014       1.95      yamt 		if ((mp->mnt_iflag & IMNT_SUSPEND) != 0 &&
   1015       1.95      yamt 		    mp->mnt_writeopcountupper <= 0)
   1016       1.95      yamt 			wakeup(&mp->mnt_writeopcountupper);
   1017       1.95      yamt 	} else {
   1018       1.95      yamt 		mp->mnt_writeopcountlower--;
   1019       1.95      yamt 		if (mp->mnt_writeopcountlower < 0)
   1020       1.95      yamt 			printf("vn_finished_write: neg cnt lower=%d\n",
   1021       1.95      yamt 			       mp->mnt_writeopcountlower);
   1022       1.95      yamt 		if ((mp->mnt_iflag & IMNT_SUSPENDLOW) != 0 &&
   1023       1.95      yamt 		    mp->mnt_writeopcountupper <= 0)
   1024       1.95      yamt 			wakeup(&mp->mnt_writeopcountlower);
   1025       1.95      yamt 	}
   1026       1.95      yamt 	simple_unlock(&mp->mnt_slock);
   1027       1.95      yamt }
   1028      1.100      yamt 
   1029      1.100      yamt void
   1030      1.100      yamt vn_ra_allocctx(struct vnode *vp)
   1031      1.100      yamt {
   1032      1.100      yamt 	struct uvm_ractx *ra = NULL;
   1033      1.100      yamt 
   1034      1.100      yamt 	if (vp->v_type != VREG) {
   1035      1.100      yamt 		return;
   1036      1.100      yamt 	}
   1037      1.100      yamt 	if (vp->v_ractx != NULL) {
   1038      1.100      yamt 		return;
   1039      1.100      yamt 	}
   1040      1.100      yamt 	simple_lock(&vp->v_interlock);
   1041      1.100      yamt 	if (vp->v_ractx == NULL) {
   1042      1.100      yamt 		simple_unlock(&vp->v_interlock);
   1043      1.100      yamt 		ra = uvm_ra_allocctx();
   1044      1.100      yamt 		simple_lock(&vp->v_interlock);
   1045      1.100      yamt 		if (ra != NULL && vp->v_ractx == NULL) {
   1046      1.100      yamt 			vp->v_ractx = ra;
   1047      1.100      yamt 			ra = NULL;
   1048      1.100      yamt 		}
   1049      1.100      yamt 	}
   1050      1.100      yamt 	simple_unlock(&vp->v_interlock);
   1051      1.100      yamt 	if (ra != NULL) {
   1052      1.100      yamt 		uvm_ra_freectx(ra);
   1053      1.100      yamt 	}
   1054      1.100      yamt }
   1055