Home | History | Annotate | Line # | Download | only in nfs
nfs_vnops.c revision 1.319
      1  1.319  dholland /*	$NetBSD: nfs_vnops.c,v 1.319 2021/07/18 23:56:14 dholland Exp $	*/
      2   1.34       cgd 
      3    1.1       cgd /*
      4   1.32   mycroft  * Copyright (c) 1989, 1993
      5   1.32   mycroft  *	The Regents of the University of California.  All rights reserved.
      6    1.1       cgd  *
      7    1.1       cgd  * This code is derived from software contributed to Berkeley by
      8    1.1       cgd  * Rick Macklem at The University of Guelph.
      9    1.1       cgd  *
     10    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     11    1.1       cgd  * modification, are permitted provided that the following conditions
     12    1.1       cgd  * are met:
     13    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     14    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     15    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     16    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     17    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     18  1.177       agc  * 3. Neither the name of the University nor the names of its contributors
     19    1.1       cgd  *    may be used to endorse or promote products derived from this software
     20    1.1       cgd  *    without specific prior written permission.
     21    1.1       cgd  *
     22    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32    1.1       cgd  * SUCH DAMAGE.
     33    1.1       cgd  *
     34   1.89      fvdl  *	@(#)nfs_vnops.c	8.19 (Berkeley) 7/31/95
     35    1.1       cgd  */
     36    1.1       cgd 
     37    1.1       cgd /*
     38   1.59      fvdl  * vnode op calls for Sun NFS version 2 and 3
     39    1.1       cgd  */
     40  1.143     lukem 
     41  1.143     lukem #include <sys/cdefs.h>
     42  1.319  dholland __KERNEL_RCSID(0, "$NetBSD: nfs_vnops.c,v 1.319 2021/07/18 23:56:14 dholland Exp $");
     43    1.1       cgd 
     44  1.268        ad #ifdef _KERNEL_OPT
     45  1.119     bjh21 #include "opt_nfs.h"
     46  1.124       chs #include "opt_uvmhist.h"
     47  1.268        ad #endif
     48  1.119     bjh21 
     49   1.16   mycroft #include <sys/param.h>
     50   1.16   mycroft #include <sys/proc.h>
     51   1.16   mycroft #include <sys/kernel.h>
     52   1.16   mycroft #include <sys/systm.h>
     53   1.59      fvdl #include <sys/resourcevar.h>
     54   1.16   mycroft #include <sys/mount.h>
     55   1.16   mycroft #include <sys/buf.h>
     56  1.253      yamt #include <sys/condvar.h>
     57  1.232     blymn #include <sys/disk.h>
     58   1.16   mycroft #include <sys/malloc.h>
     59  1.264      yamt #include <sys/kmem.h>
     60   1.16   mycroft #include <sys/mbuf.h>
     61  1.253      yamt #include <sys/mutex.h>
     62   1.16   mycroft #include <sys/namei.h>
     63   1.16   mycroft #include <sys/vnode.h>
     64   1.32   mycroft #include <sys/dirent.h>
     65   1.59      fvdl #include <sys/fcntl.h>
     66  1.147     lukem #include <sys/hash.h>
     67   1.32   mycroft #include <sys/lockf.h>
     68   1.75   mycroft #include <sys/stat.h>
     69   1.95    kleink #include <sys/unistd.h>
     70  1.236      elad #include <sys/kauth.h>
     71  1.293       tls #include <sys/cprng.h>
     72   1.31       cgd 
     73  1.317  riastrad #ifdef UVMHIST
     74  1.317  riastrad #include <uvm/uvm.h>
     75  1.317  riastrad #endif
     76   1.87       mrg #include <uvm/uvm_extern.h>
     77  1.317  riastrad #include <uvm/uvm_stat.h>
     78   1.87       mrg 
     79   1.64   mycroft #include <miscfs/fifofs/fifo.h>
     80   1.64   mycroft #include <miscfs/genfs/genfs.h>
     81  1.244      yamt #include <miscfs/genfs/genfs_node.h>
     82   1.32   mycroft #include <miscfs/specfs/specdev.h>
     83   1.32   mycroft 
     84   1.32   mycroft #include <nfs/rpcv2.h>
     85   1.59      fvdl #include <nfs/nfsproto.h>
     86   1.16   mycroft #include <nfs/nfs.h>
     87   1.16   mycroft #include <nfs/nfsnode.h>
     88   1.16   mycroft #include <nfs/nfsmount.h>
     89   1.16   mycroft #include <nfs/xdr_subs.h>
     90   1.16   mycroft #include <nfs/nfsm_subs.h>
     91   1.58  christos #include <nfs/nfs_var.h>
     92   1.27        pk 
     93   1.59      fvdl #include <net/if.h>
     94   1.59      fvdl #include <netinet/in.h>
     95   1.59      fvdl #include <netinet/in_var.h>
     96    1.1       cgd 
     97    1.1       cgd /*
     98    1.1       cgd  * Global vfs data structures for nfs
     99    1.1       cgd  */
    100  1.271       dsl int (**nfsv2_vnodeop_p)(void *);
    101  1.127  jdolecek const struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
    102   1.32   mycroft 	{ &vop_default_desc, vn_default_error },
    103  1.318  dholland 	{ &vop_parsepath_desc, genfs_parsepath },	/* parsepath */
    104   1.64   mycroft 	{ &vop_lookup_desc, nfs_lookup },		/* lookup */
    105   1.64   mycroft 	{ &vop_create_desc, nfs_create },		/* create */
    106   1.64   mycroft 	{ &vop_mknod_desc, nfs_mknod },			/* mknod */
    107   1.64   mycroft 	{ &vop_open_desc, nfs_open },			/* open */
    108   1.64   mycroft 	{ &vop_close_desc, nfs_close },			/* close */
    109   1.64   mycroft 	{ &vop_access_desc, nfs_access },		/* access */
    110  1.315  christos 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
    111   1.64   mycroft 	{ &vop_getattr_desc, nfs_getattr },		/* getattr */
    112   1.64   mycroft 	{ &vop_setattr_desc, nfs_setattr },		/* setattr */
    113   1.64   mycroft 	{ &vop_read_desc, nfs_read },			/* read */
    114   1.64   mycroft 	{ &vop_write_desc, nfs_write },			/* write */
    115  1.306  dholland 	{ &vop_fallocate_desc, genfs_eopnotsupp },	/* fallocate */
    116  1.306  dholland 	{ &vop_fdiscard_desc, genfs_eopnotsupp },	/* fdiscard */
    117  1.105  wrstuden 	{ &vop_fcntl_desc, genfs_fcntl },		/* fcntl */
    118   1.64   mycroft 	{ &vop_ioctl_desc, nfs_ioctl },			/* ioctl */
    119   1.65   mycroft 	{ &vop_poll_desc, nfs_poll },			/* poll */
    120  1.156  jdolecek 	{ &vop_kqfilter_desc, nfs_kqfilter },		/* kqfilter */
    121   1.64   mycroft 	{ &vop_revoke_desc, nfs_revoke },		/* revoke */
    122   1.64   mycroft 	{ &vop_mmap_desc, nfs_mmap },			/* mmap */
    123   1.64   mycroft 	{ &vop_fsync_desc, nfs_fsync },			/* fsync */
    124   1.64   mycroft 	{ &vop_seek_desc, nfs_seek },			/* seek */
    125   1.64   mycroft 	{ &vop_remove_desc, nfs_remove },		/* remove */
    126   1.64   mycroft 	{ &vop_link_desc, nfs_link },			/* link */
    127   1.64   mycroft 	{ &vop_rename_desc, nfs_rename },		/* rename */
    128   1.64   mycroft 	{ &vop_mkdir_desc, nfs_mkdir },			/* mkdir */
    129   1.64   mycroft 	{ &vop_rmdir_desc, nfs_rmdir },			/* rmdir */
    130   1.64   mycroft 	{ &vop_symlink_desc, nfs_symlink },		/* symlink */
    131   1.64   mycroft 	{ &vop_readdir_desc, nfs_readdir },		/* readdir */
    132   1.64   mycroft 	{ &vop_readlink_desc, nfs_readlink },		/* readlink */
    133   1.64   mycroft 	{ &vop_abortop_desc, nfs_abortop },		/* abortop */
    134   1.64   mycroft 	{ &vop_inactive_desc, nfs_inactive },		/* inactive */
    135   1.64   mycroft 	{ &vop_reclaim_desc, nfs_reclaim },		/* reclaim */
    136   1.64   mycroft 	{ &vop_lock_desc, nfs_lock },			/* lock */
    137   1.64   mycroft 	{ &vop_unlock_desc, nfs_unlock },		/* unlock */
    138   1.64   mycroft 	{ &vop_bmap_desc, nfs_bmap },			/* bmap */
    139   1.64   mycroft 	{ &vop_strategy_desc, nfs_strategy },		/* strategy */
    140   1.64   mycroft 	{ &vop_print_desc, nfs_print },			/* print */
    141   1.64   mycroft 	{ &vop_islocked_desc, nfs_islocked },		/* islocked */
    142   1.64   mycroft 	{ &vop_pathconf_desc, nfs_pathconf },		/* pathconf */
    143   1.64   mycroft 	{ &vop_advlock_desc, nfs_advlock },		/* advlock */
    144  1.213      yamt 	{ &vop_bwrite_desc, genfs_badop },		/* bwrite */
    145  1.124       chs 	{ &vop_getpages_desc, nfs_getpages },		/* getpages */
    146  1.138       chs 	{ &vop_putpages_desc, genfs_putpages },		/* putpages */
    147  1.124       chs 	{ NULL, NULL }
    148    1.1       cgd };
    149  1.127  jdolecek const struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
    150   1.32   mycroft 	{ &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
    151    1.1       cgd 
    152    1.1       cgd /*
    153    1.1       cgd  * Special device vnode ops
    154    1.1       cgd  */
    155  1.271       dsl int (**spec_nfsv2nodeop_p)(void *);
    156  1.127  jdolecek const struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
    157   1.32   mycroft 	{ &vop_default_desc, vn_default_error },
    158  1.319  dholland 	GENFS_SPECOP_ENTRIES,
    159   1.64   mycroft 	{ &vop_close_desc, nfsspec_close },		/* close */
    160   1.64   mycroft 	{ &vop_access_desc, nfsspec_access },		/* access */
    161  1.315  christos 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
    162   1.64   mycroft 	{ &vop_getattr_desc, nfs_getattr },		/* getattr */
    163   1.64   mycroft 	{ &vop_setattr_desc, nfs_setattr },		/* setattr */
    164   1.64   mycroft 	{ &vop_read_desc, nfsspec_read },		/* read */
    165   1.64   mycroft 	{ &vop_write_desc, nfsspec_write },		/* write */
    166  1.105  wrstuden 	{ &vop_fcntl_desc, genfs_fcntl },		/* fcntl */
    167  1.124       chs 	{ &vop_fsync_desc, spec_fsync },		/* fsync */
    168   1.64   mycroft 	{ &vop_inactive_desc, nfs_inactive },		/* inactive */
    169   1.64   mycroft 	{ &vop_reclaim_desc, nfs_reclaim },		/* reclaim */
    170   1.64   mycroft 	{ &vop_lock_desc, nfs_lock },			/* lock */
    171   1.64   mycroft 	{ &vop_unlock_desc, nfs_unlock },		/* unlock */
    172   1.64   mycroft 	{ &vop_print_desc, nfs_print },			/* print */
    173   1.64   mycroft 	{ &vop_islocked_desc, nfs_islocked },		/* islocked */
    174  1.214      yamt 	{ &vop_bwrite_desc, spec_bwrite },		/* bwrite */
    175  1.124       chs 	{ NULL, NULL }
    176    1.1       cgd };
    177  1.127  jdolecek const struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
    178   1.32   mycroft 	{ &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
    179    1.1       cgd 
    180  1.271       dsl int (**fifo_nfsv2nodeop_p)(void *);
    181  1.127  jdolecek const struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
    182   1.32   mycroft 	{ &vop_default_desc, vn_default_error },
    183  1.319  dholland 	GENFS_FIFOOP_ENTRIES,
    184   1.64   mycroft 	{ &vop_close_desc, nfsfifo_close },		/* close */
    185   1.64   mycroft 	{ &vop_access_desc, nfsspec_access },		/* access */
    186  1.315  christos 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
    187   1.64   mycroft 	{ &vop_getattr_desc, nfs_getattr },		/* getattr */
    188   1.64   mycroft 	{ &vop_setattr_desc, nfs_setattr },		/* setattr */
    189   1.64   mycroft 	{ &vop_read_desc, nfsfifo_read },		/* read */
    190   1.64   mycroft 	{ &vop_write_desc, nfsfifo_write },		/* write */
    191  1.105  wrstuden 	{ &vop_fcntl_desc, genfs_fcntl },		/* fcntl */
    192   1.64   mycroft 	{ &vop_fsync_desc, nfs_fsync },			/* fsync */
    193   1.64   mycroft 	{ &vop_inactive_desc, nfs_inactive },		/* inactive */
    194   1.64   mycroft 	{ &vop_reclaim_desc, nfs_reclaim },		/* reclaim */
    195   1.64   mycroft 	{ &vop_lock_desc, nfs_lock },			/* lock */
    196   1.64   mycroft 	{ &vop_unlock_desc, nfs_unlock },		/* unlock */
    197  1.319  dholland 	{ &vop_strategy_desc, vn_fifo_bypass },		/* strategy */
    198   1.64   mycroft 	{ &vop_print_desc, nfs_print },			/* print */
    199   1.64   mycroft 	{ &vop_islocked_desc, nfs_islocked },		/* islocked */
    200  1.213      yamt 	{ &vop_bwrite_desc, genfs_badop },		/* bwrite */
    201  1.124       chs 	{ NULL, NULL }
    202    1.1       cgd };
    203  1.127  jdolecek const struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
    204   1.32   mycroft 	{ &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
    205    1.1       cgd 
    206  1.239      yamt static int nfs_linkrpc(struct vnode *, struct vnode *, const char *,
    207  1.239      yamt     size_t, kauth_cred_t, struct lwp *);
    208  1.252  christos static void nfs_writerpc_extfree(struct mbuf *, void *, size_t, void *);
    209  1.167      yamt 
    210    1.1       cgd /*
    211   1.32   mycroft  * Global variables
    212    1.1       cgd  */
    213   1.59      fvdl extern u_int32_t nfs_true, nfs_false;
    214   1.55   mycroft extern u_int32_t nfs_xdrneg1;
    215  1.157      matt extern const nfstype nfsv3_type[9];
    216  1.150      matt 
    217    1.1       cgd int nfs_numasync = 0;
    218  1.225  christos #define	DIRHDSIZ	_DIRENT_NAMEOFF(dp)
    219  1.225  christos #define UIO_ADVANCE(uio, siz) \
    220  1.225  christos     (void)((uio)->uio_resid -= (siz), \
    221  1.225  christos     (uio)->uio_iov->iov_base = (char *)(uio)->uio_iov->iov_base + (siz), \
    222  1.225  christos     (uio)->uio_iov->iov_len -= (siz))
    223    1.1       cgd 
    224  1.188      yamt static void nfs_cache_enter(struct vnode *, struct vnode *,
    225  1.188      yamt     struct componentname *);
    226  1.188      yamt 
    227  1.188      yamt static void
    228  1.188      yamt nfs_cache_enter(struct vnode *dvp, struct vnode *vp,
    229  1.188      yamt     struct componentname *cnp)
    230  1.188      yamt {
    231  1.215      yamt 	struct nfsnode *dnp = VTONFS(dvp);
    232  1.188      yamt 
    233  1.295     rmind 	if ((cnp->cn_flags & MAKEENTRY) == 0) {
    234  1.295     rmind 		return;
    235  1.295     rmind 	}
    236  1.188      yamt 	if (vp != NULL) {
    237  1.188      yamt 		struct nfsnode *np = VTONFS(vp);
    238  1.188      yamt 
    239  1.188      yamt 		np->n_ctime = np->n_vattr->va_ctime.tv_sec;
    240  1.215      yamt 	}
    241  1.188      yamt 
    242  1.215      yamt 	if (!timespecisset(&dnp->n_nctime))
    243  1.215      yamt 		dnp->n_nctime = dnp->n_vattr->va_mtime;
    244  1.188      yamt 
    245  1.297  dholland 	cache_enter(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags);
    246  1.188      yamt }
    247  1.188      yamt 
    248    1.1       cgd /*
    249    1.1       cgd  * nfs null call from vfs.
    250    1.1       cgd  */
    251   1.32   mycroft int
    252  1.272       dsl nfs_null(struct vnode *vp, kauth_cred_t cred, struct lwp *l)
    253    1.1       cgd {
    254  1.252  christos 	char *bpos, *dpos;
    255    1.1       cgd 	int error = 0;
    256  1.300    martin 	struct mbuf *mreq, *mrep, *md, *mb __unused;
    257  1.165  drochner 	struct nfsnode *np = VTONFS(vp);
    258  1.220     perry 
    259  1.165  drochner 	nfsm_reqhead(np, NFSPROC_NULL, 0);
    260  1.230  christos 	nfsm_request(np, NFSPROC_NULL, l, cred);
    261    1.1       cgd 	nfsm_reqdone;
    262    1.1       cgd 	return (error);
    263    1.1       cgd }
    264    1.1       cgd 
    265    1.1       cgd /*
    266    1.1       cgd  * nfs access vnode op.
    267   1.59      fvdl  * For nfs version 2, just return ok. File accesses may fail later.
    268   1.59      fvdl  * For nfs version 3, use the access rpc to check accessibility. If file modes
    269   1.59      fvdl  * are changed on the server, accesses might still fail later.
    270    1.1       cgd  */
    271   1.32   mycroft int
    272  1.272       dsl nfs_access(void *v)
    273   1.58  christos {
    274   1.32   mycroft 	struct vop_access_args /* {
    275   1.32   mycroft 		struct vnode *a_vp;
    276  1.315  christos 		accmode_t  a_accmode;
    277  1.236      elad 		kauth_cred_t a_cred;
    278   1.58  christos 	} */ *ap = v;
    279  1.110  augustss 	struct vnode *vp = ap->a_vp;
    280  1.200  christos #ifndef NFS_V2_ONLY
    281  1.110  augustss 	u_int32_t *tl;
    282  1.252  christos 	char *cp;
    283  1.110  augustss 	int32_t t1, t2;
    284  1.252  christos 	char *bpos, *dpos, *cp2;
    285  1.200  christos 	int error = 0, attrflag;
    286  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
    287   1.59      fvdl 	u_int32_t mode, rmode;
    288  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
    289  1.200  christos #endif
    290  1.200  christos 	int cachevalid;
    291  1.108      fvdl 	struct nfsnode *np = VTONFS(vp);
    292  1.227  christos 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
    293  1.108      fvdl 
    294  1.108      fvdl 	cachevalid = (np->n_accstamp != -1 &&
    295  1.257      yamt 	    (time_uptime - np->n_accstamp) < nfs_attrtimeo(nmp, np) &&
    296  1.236      elad 	    np->n_accuid == kauth_cred_geteuid(ap->a_cred));
    297  1.108      fvdl 
    298  1.108      fvdl 	/*
    299  1.108      fvdl 	 * Check access cache first. If this request has been made for this
    300  1.108      fvdl 	 * uid shortly before, use the cached result.
    301  1.108      fvdl 	 */
    302  1.118      fvdl 	if (cachevalid) {
    303  1.118      fvdl 		if (!np->n_accerror) {
    304  1.315  christos 			if  ((np->n_accmode & ap->a_accmode) == ap->a_accmode)
    305  1.118      fvdl 				return np->n_accerror;
    306  1.315  christos 		} else if ((np->n_accmode & ap->a_accmode) == np->n_accmode)
    307  1.118      fvdl 			return np->n_accerror;
    308  1.118      fvdl 	}
    309    1.1       cgd 
    310  1.200  christos #ifndef NFS_V2_ONLY
    311    1.1       cgd 	/*
    312   1.59      fvdl 	 * For nfs v3, do an access rpc, otherwise you are stuck emulating
    313   1.32   mycroft 	 * ufs_access() locally using the vattr. This may not be correct,
    314   1.32   mycroft 	 * since the server may apply other access criteria such as
    315   1.32   mycroft 	 * client uid-->server uid mapping that we do not know about, but
    316   1.32   mycroft 	 * this is better than just returning anything that is lying about
    317   1.32   mycroft 	 * in the cache.
    318   1.32   mycroft 	 */
    319   1.59      fvdl 	if (v3) {
    320   1.59      fvdl 		nfsstats.rpccnt[NFSPROC_ACCESS]++;
    321  1.165  drochner 		nfsm_reqhead(np, NFSPROC_ACCESS, NFSX_FH(v3) + NFSX_UNSIGNED);
    322  1.165  drochner 		nfsm_fhtom(np, v3);
    323   1.59      fvdl 		nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
    324  1.315  christos 		if (ap->a_accmode & VREAD)
    325   1.59      fvdl 			mode = NFSV3ACCESS_READ;
    326   1.32   mycroft 		else
    327   1.59      fvdl 			mode = 0;
    328   1.74   mycroft 		if (vp->v_type != VDIR) {
    329  1.315  christos 			if (ap->a_accmode & VWRITE)
    330   1.74   mycroft 				mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
    331  1.315  christos 			if (ap->a_accmode & VEXEC)
    332   1.74   mycroft 				mode |= NFSV3ACCESS_EXECUTE;
    333   1.74   mycroft 		} else {
    334  1.315  christos 			if (ap->a_accmode & VWRITE)
    335   1.59      fvdl 				mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
    336   1.59      fvdl 					 NFSV3ACCESS_DELETE);
    337  1.315  christos 			if (ap->a_accmode & VEXEC)
    338   1.59      fvdl 				mode |= NFSV3ACCESS_LOOKUP;
    339   1.59      fvdl 		}
    340   1.59      fvdl 		*tl = txdr_unsigned(mode);
    341  1.260     pooka 		nfsm_request(np, NFSPROC_ACCESS, curlwp, ap->a_cred);
    342  1.153      yamt 		nfsm_postop_attr(vp, attrflag, 0);
    343   1.59      fvdl 		if (!error) {
    344   1.59      fvdl 			nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
    345   1.59      fvdl 			rmode = fxdr_unsigned(u_int32_t, *tl);
    346   1.59      fvdl 			/*
    347   1.59      fvdl 			 * The NFS V3 spec does not clarify whether or not
    348   1.59      fvdl 			 * the returned access bits can be a superset of
    349   1.59      fvdl 			 * the ones requested, so...
    350   1.59      fvdl 			 */
    351   1.59      fvdl 			if ((rmode & mode) != mode)
    352   1.59      fvdl 				error = EACCES;
    353   1.59      fvdl 		}
    354   1.32   mycroft 		nfsm_reqdone;
    355   1.32   mycroft 	} else
    356  1.200  christos #endif
    357   1.32   mycroft 		return (nfsspec_access(ap));
    358  1.200  christos #ifndef NFS_V2_ONLY
    359   1.71      fvdl 	/*
    360   1.71      fvdl 	 * Disallow write attempts on filesystems mounted read-only;
    361   1.71      fvdl 	 * unless the file is a socket, fifo, or a block or character
    362   1.71      fvdl 	 * device resident on the filesystem.
    363   1.71      fvdl 	 */
    364  1.315  christos 	if (!error && (ap->a_accmode & VWRITE) &&
    365  1.108      fvdl 	    (vp->v_mount->mnt_flag & MNT_RDONLY)) {
    366   1.71      fvdl 		switch (vp->v_type) {
    367   1.71      fvdl 		case VREG:
    368   1.71      fvdl 		case VDIR:
    369   1.71      fvdl 		case VLNK:
    370  1.108      fvdl 			error = EROFS;
    371   1.71      fvdl 		default:
    372   1.71      fvdl 			break;
    373   1.71      fvdl 		}
    374   1.71      fvdl 	}
    375  1.108      fvdl 
    376  1.108      fvdl 	if (!error || error == EACCES) {
    377  1.108      fvdl 		/*
    378  1.108      fvdl 		 * If we got the same result as for a previous,
    379  1.108      fvdl 		 * different request, OR it in. Don't update
    380  1.108      fvdl 		 * the timestamp in that case.
    381  1.108      fvdl 		 */
    382  1.149      fvdl 		if (cachevalid && np->n_accstamp != -1 &&
    383  1.149      fvdl 		    error == np->n_accerror) {
    384  1.118      fvdl 			if (!error)
    385  1.315  christos 				np->n_accmode |= ap->a_accmode;
    386  1.315  christos 			else if ((np->n_accmode & ap->a_accmode) == ap->a_accmode)
    387  1.315  christos 				np->n_accmode = ap->a_accmode;
    388  1.118      fvdl 		} else {
    389  1.237    kardel 			np->n_accstamp = time_uptime;
    390  1.236      elad 			np->n_accuid = kauth_cred_geteuid(ap->a_cred);
    391  1.315  christos 			np->n_accmode = ap->a_accmode;
    392  1.108      fvdl 			np->n_accerror = error;
    393  1.108      fvdl 		}
    394  1.108      fvdl 	}
    395  1.108      fvdl 
    396  1.108      fvdl 	return (error);
    397  1.200  christos #endif
    398    1.1       cgd }
    399    1.1       cgd 
    400    1.1       cgd /*
    401    1.1       cgd  * nfs open vnode op
    402   1.32   mycroft  * Check to see if the type is ok
    403   1.32   mycroft  * and that deletion is not in progress.
    404   1.32   mycroft  * For paged in text files, you will need to flush the page cache
    405   1.32   mycroft  * if consistency is lost.
    406    1.1       cgd  */
    407    1.1       cgd /* ARGSUSED */
    408   1.32   mycroft int
    409  1.272       dsl nfs_open(void *v)
    410   1.58  christos {
    411   1.32   mycroft 	struct vop_open_args /* {
    412   1.32   mycroft 		struct vnode *a_vp;
    413   1.32   mycroft 		int  a_mode;
    414  1.236      elad 		kauth_cred_t a_cred;
    415   1.58  christos 	} */ *ap = v;
    416  1.110  augustss 	struct vnode *vp = ap->a_vp;
    417   1.32   mycroft 	struct nfsnode *np = VTONFS(vp);
    418   1.32   mycroft 	int error;
    419    1.1       cgd 
    420   1.59      fvdl 	if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) {
    421    1.1       cgd 		return (EACCES);
    422   1.59      fvdl 	}
    423  1.124       chs 
    424  1.126       chs 	if (ap->a_mode & FREAD) {
    425  1.184      fvdl 		if (np->n_rcred != NULL)
    426  1.236      elad 			kauth_cred_free(np->n_rcred);
    427  1.126       chs 		np->n_rcred = ap->a_cred;
    428  1.236      elad 		kauth_cred_hold(np->n_rcred);
    429  1.126       chs 	}
    430  1.125       chs 	if (ap->a_mode & FWRITE) {
    431  1.184      fvdl 		if (np->n_wcred != NULL)
    432  1.236      elad 			kauth_cred_free(np->n_wcred);
    433  1.125       chs 		np->n_wcred = ap->a_cred;
    434  1.236      elad 		kauth_cred_hold(np->n_wcred);
    435  1.125       chs 	}
    436  1.125       chs 
    437  1.260     pooka 	error = nfs_flushstalebuf(vp, ap->a_cred, curlwp, 0);
    438  1.247      yamt 	if (error)
    439  1.247      yamt 		return error;
    440  1.247      yamt 
    441  1.247      yamt 	NFS_INVALIDATE_ATTRCACHE(np); /* For Open/Close consistency */
    442  1.247      yamt 
    443   1.32   mycroft 	return (0);
    444    1.1       cgd }
    445    1.1       cgd 
    446    1.1       cgd /*
    447    1.1       cgd  * nfs close vnode op
    448   1.59      fvdl  * What an NFS client should do upon close after writing is a debatable issue.
    449   1.59      fvdl  * Most NFS clients push delayed writes to the server upon close, basically for
    450   1.59      fvdl  * two reasons:
    451   1.59      fvdl  * 1 - So that any write errors may be reported back to the client process
    452   1.59      fvdl  *     doing the close system call. By far the two most likely errors are
    453   1.59      fvdl  *     NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
    454   1.59      fvdl  * 2 - To put a worst case upper bound on cache inconsistency between
    455   1.59      fvdl  *     multiple clients for the file.
    456   1.59      fvdl  * There is also a consistency problem for Version 2 of the protocol w.r.t.
    457   1.59      fvdl  * not being able to tell if other clients are writing a file concurrently,
    458   1.59      fvdl  * since there is no way of knowing if the changed modify time in the reply
    459   1.59      fvdl  * is only due to the write for this client.
    460   1.59      fvdl  * (NFS Version 3 provides weak cache consistency data in the reply that
    461   1.59      fvdl  *  should be sufficient to detect and handle this case.)
    462   1.59      fvdl  *
    463   1.59      fvdl  * The current code does the following:
    464   1.59      fvdl  * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
    465   1.59      fvdl  * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
    466   1.59      fvdl  *                     or commit them (this satisfies 1 and 2 except for the
    467   1.59      fvdl  *                     case where the server crashes after this close but
    468   1.59      fvdl  *                     before the commit RPC, which is felt to be "good
    469   1.59      fvdl  *                     enough". Changing the last argument to nfs_flush() to
    470   1.59      fvdl  *                     a 1 would force a commit operation, if it is felt a
    471   1.59      fvdl  *                     commit is necessary now.
    472    1.1       cgd  */
    473    1.1       cgd /* ARGSUSED */
    474   1.32   mycroft int
    475  1.272       dsl nfs_close(void *v)
    476   1.58  christos {
    477   1.32   mycroft 	struct vop_close_args /* {
    478   1.32   mycroft 		struct vnodeop_desc *a_desc;
    479   1.32   mycroft 		struct vnode *a_vp;
    480   1.32   mycroft 		int  a_fflag;
    481  1.236      elad 		kauth_cred_t a_cred;
    482   1.58  christos 	} */ *ap = v;
    483  1.110  augustss 	struct vnode *vp = ap->a_vp;
    484  1.110  augustss 	struct nfsnode *np = VTONFS(vp);
    485    1.1       cgd 	int error = 0;
    486  1.124       chs 	UVMHIST_FUNC("nfs_close"); UVMHIST_CALLED(ubchist);
    487    1.1       cgd 
    488   1.32   mycroft 	if (vp->v_type == VREG) {
    489  1.248      yamt 	    if (np->n_flag & NMODIFIED) {
    490  1.200  christos #ifndef NFS_V2_ONLY
    491   1.59      fvdl 		if (NFS_ISV3(vp)) {
    492  1.260     pooka 		    error = nfs_flush(vp, ap->a_cred, MNT_WAIT, curlwp, 0);
    493   1.59      fvdl 		    np->n_flag &= ~NMODIFIED;
    494   1.59      fvdl 		} else
    495  1.200  christos #endif
    496  1.260     pooka 		    error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, curlwp, 1);
    497  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(np);
    498   1.32   mycroft 	    }
    499   1.32   mycroft 	    if (np->n_flag & NWRITEERR) {
    500   1.32   mycroft 		np->n_flag &= ~NWRITEERR;
    501   1.32   mycroft 		error = np->n_error;
    502   1.32   mycroft 	    }
    503    1.1       cgd 	}
    504  1.124       chs 	UVMHIST_LOG(ubchist, "returning %d", error,0,0,0);
    505    1.1       cgd 	return (error);
    506    1.1       cgd }
    507    1.1       cgd 
    508    1.1       cgd /*
    509    1.1       cgd  * nfs getattr call from vfs.
    510    1.1       cgd  */
    511   1.32   mycroft int
    512  1.272       dsl nfs_getattr(void *v)
    513   1.58  christos {
    514   1.32   mycroft 	struct vop_getattr_args /* {
    515   1.32   mycroft 		struct vnode *a_vp;
    516   1.32   mycroft 		struct vattr *a_vap;
    517  1.236      elad 		kauth_cred_t a_cred;
    518   1.58  christos 	} */ *ap = v;
    519  1.110  augustss 	struct vnode *vp = ap->a_vp;
    520  1.110  augustss 	struct nfsnode *np = VTONFS(vp);
    521  1.252  christos 	char *cp;
    522  1.110  augustss 	u_int32_t *tl;
    523  1.110  augustss 	int32_t t1, t2;
    524  1.252  christos 	char *bpos, *dpos;
    525    1.1       cgd 	int error = 0;
    526  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
    527  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
    528  1.220     perry 
    529   1.32   mycroft 	/*
    530   1.32   mycroft 	 * Update local times for special files.
    531   1.32   mycroft 	 */
    532   1.32   mycroft 	if (np->n_flag & (NACC | NUPD))
    533   1.32   mycroft 		np->n_flag |= NCHG;
    534  1.181      yamt 
    535  1.181      yamt 	/*
    536  1.181      yamt 	 * if we have delayed truncation, do it now.
    537  1.181      yamt 	 */
    538  1.181      yamt 	nfs_delayedtruncate(vp);
    539  1.181      yamt 
    540   1.32   mycroft 	/*
    541   1.32   mycroft 	 * First look in the cache.
    542   1.32   mycroft 	 */
    543   1.32   mycroft 	if (nfs_getattrcache(vp, ap->a_vap) == 0)
    544    1.1       cgd 		return (0);
    545    1.1       cgd 	nfsstats.rpccnt[NFSPROC_GETATTR]++;
    546  1.165  drochner 	nfsm_reqhead(np, NFSPROC_GETATTR, NFSX_FH(v3));
    547  1.165  drochner 	nfsm_fhtom(np, v3);
    548  1.260     pooka 	nfsm_request(np, NFSPROC_GETATTR, curlwp, ap->a_cred);
    549   1.81      fvdl 	if (!error) {
    550  1.153      yamt 		nfsm_loadattr(vp, ap->a_vap, 0);
    551   1.81      fvdl 		if (vp->v_type == VDIR &&
    552   1.81      fvdl 		    ap->a_vap->va_blocksize < NFS_DIRFRAGSIZ)
    553   1.81      fvdl 			ap->a_vap->va_blocksize = NFS_DIRFRAGSIZ;
    554   1.81      fvdl 	}
    555    1.1       cgd 	nfsm_reqdone;
    556    1.1       cgd 	return (error);
    557    1.1       cgd }
    558    1.1       cgd 
    559    1.1       cgd /*
    560    1.1       cgd  * nfs setattr call.
    561    1.1       cgd  */
    562   1.32   mycroft int
    563  1.272       dsl nfs_setattr(void *v)
    564   1.58  christos {
    565   1.32   mycroft 	struct vop_setattr_args /* {
    566   1.32   mycroft 		struct vnodeop_desc *a_desc;
    567   1.32   mycroft 		struct vnode *a_vp;
    568   1.32   mycroft 		struct vattr *a_vap;
    569  1.236      elad 		kauth_cred_t a_cred;
    570   1.58  christos 	} */ *ap = v;
    571  1.110  augustss 	struct vnode *vp = ap->a_vp;
    572  1.110  augustss 	struct nfsnode *np = VTONFS(vp);
    573  1.110  augustss 	struct vattr *vap = ap->a_vap;
    574   1.59      fvdl 	int error = 0;
    575   1.59      fvdl 	u_quad_t tsize = 0;
    576    1.1       cgd 
    577   1.59      fvdl 	/*
    578   1.71      fvdl 	 * Setting of flags is not supported.
    579   1.71      fvdl 	 */
    580   1.71      fvdl 	if (vap->va_flags != VNOVAL)
    581   1.71      fvdl 		return (EOPNOTSUPP);
    582   1.71      fvdl 
    583   1.71      fvdl 	/*
    584   1.59      fvdl 	 * Disallow write attempts if the filesystem is mounted read-only.
    585   1.59      fvdl 	 */
    586   1.71      fvdl   	if ((vap->va_uid != (uid_t)VNOVAL ||
    587   1.59      fvdl 	    vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
    588   1.59      fvdl 	    vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
    589   1.59      fvdl 	    (vp->v_mount->mnt_flag & MNT_RDONLY))
    590   1.59      fvdl 		return (EROFS);
    591   1.35   mycroft 	if (vap->va_size != VNOVAL) {
    592  1.266      yamt 		if (vap->va_size > VFSTONFS(vp->v_mount)->nm_maxfilesize) {
    593  1.266      yamt 			return EFBIG;
    594  1.266      yamt 		}
    595   1.59      fvdl  		switch (vp->v_type) {
    596   1.59      fvdl  		case VDIR:
    597   1.59      fvdl  			return (EISDIR);
    598   1.59      fvdl  		case VCHR:
    599   1.59      fvdl  		case VBLK:
    600   1.59      fvdl  		case VSOCK:
    601   1.59      fvdl  		case VFIFO:
    602   1.56       jtc 			if (vap->va_mtime.tv_sec == VNOVAL &&
    603   1.56       jtc 			    vap->va_atime.tv_sec == VNOVAL &&
    604   1.84  christos 			    vap->va_mode == (mode_t)VNOVAL &&
    605   1.59      fvdl 			    vap->va_uid == (uid_t)VNOVAL &&
    606   1.59      fvdl 			    vap->va_gid == (gid_t)VNOVAL)
    607   1.35   mycroft 				return (0);
    608   1.59      fvdl  			vap->va_size = VNOVAL;
    609   1.59      fvdl  			break;
    610   1.59      fvdl  		default:
    611   1.59      fvdl 			/*
    612   1.59      fvdl 			 * Disallow write attempts if the filesystem is
    613   1.59      fvdl 			 * mounted read-only.
    614   1.59      fvdl 			 */
    615   1.59      fvdl 			if (vp->v_mount->mnt_flag & MNT_RDONLY)
    616   1.59      fvdl 				return (EROFS);
    617  1.244      yamt 			genfs_node_wrlock(vp);
    618   1.87       mrg  			uvm_vnp_setsize(vp, vap->va_size);
    619  1.148      fvdl  			tsize = np->n_size;
    620  1.148      fvdl 			np->n_size = vap->va_size;
    621   1.59      fvdl  			if (vap->va_size == 0)
    622   1.59      fvdl  				error = nfs_vinvalbuf(vp, 0,
    623  1.260     pooka  				     ap->a_cred, curlwp, 1);
    624   1.59      fvdl 			else
    625   1.59      fvdl 				error = nfs_vinvalbuf(vp, V_SAVE,
    626  1.260     pooka 				     ap->a_cred, curlwp, 1);
    627   1.71      fvdl 			if (error) {
    628  1.148      fvdl 				uvm_vnp_setsize(vp, tsize);
    629  1.244      yamt 				genfs_node_unlock(vp);
    630   1.59      fvdl 				return (error);
    631   1.71      fvdl 			}
    632  1.148      fvdl  			np->n_vattr->va_size = vap->va_size;
    633   1.71      fvdl   		}
    634  1.242  drochner   	} else {
    635  1.242  drochner 		/*
    636  1.242  drochner 		 * flush files before setattr because a later write of
    637  1.242  drochner 		 * cached data might change timestamps or reset sugid bits
    638  1.242  drochner 		 */
    639  1.242  drochner 		if ((vap->va_mtime.tv_sec != VNOVAL ||
    640  1.242  drochner 		     vap->va_atime.tv_sec != VNOVAL ||
    641  1.242  drochner 		     vap->va_mode != VNOVAL) &&
    642  1.242  drochner 		    vp->v_type == VREG &&
    643  1.242  drochner   		    (error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
    644  1.260     pooka 		 			   curlwp, 1)) == EINTR)
    645  1.242  drochner 			return (error);
    646  1.242  drochner 	}
    647  1.260     pooka 	error = nfs_setattrrpc(vp, vap, ap->a_cred, curlwp);
    648  1.244      yamt 	if (vap->va_size != VNOVAL) {
    649  1.244      yamt 		if (error) {
    650  1.244      yamt 			np->n_size = np->n_vattr->va_size = tsize;
    651  1.244      yamt 			uvm_vnp_setsize(vp, np->n_size);
    652  1.244      yamt 		}
    653  1.244      yamt 		genfs_node_unlock(vp);
    654   1.32   mycroft 	}
    655  1.156  jdolecek 	VN_KNOTE(vp, NOTE_ATTRIB);
    656   1.59      fvdl 	return (error);
    657   1.59      fvdl }
    658   1.59      fvdl 
    659   1.59      fvdl /*
    660   1.59      fvdl  * Do an nfs setattr rpc.
    661   1.59      fvdl  */
    662   1.59      fvdl int
    663  1.272       dsl nfs_setattrrpc(struct vnode *vp, struct vattr *vap, kauth_cred_t cred, struct lwp *l)
    664   1.59      fvdl {
    665  1.110  augustss 	struct nfsv2_sattr *sp;
    666  1.252  christos 	char *cp;
    667  1.110  augustss 	int32_t t1, t2;
    668  1.252  christos 	char *bpos, *dpos;
    669   1.59      fvdl 	u_int32_t *tl;
    670  1.200  christos 	int error = 0;
    671  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
    672  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
    673  1.165  drochner 	struct nfsnode *np = VTONFS(vp);
    674  1.200  christos #ifndef NFS_V2_ONLY
    675  1.200  christos 	int wccflag = NFSV3_WCCRATTR;
    676  1.252  christos 	char *cp2;
    677  1.200  christos #endif
    678   1.59      fvdl 
    679    1.1       cgd 	nfsstats.rpccnt[NFSPROC_SETATTR]++;
    680  1.165  drochner 	nfsm_reqhead(np, NFSPROC_SETATTR, NFSX_FH(v3) + NFSX_SATTR(v3));
    681  1.165  drochner 	nfsm_fhtom(np, v3);
    682  1.200  christos #ifndef NFS_V2_ONLY
    683   1.59      fvdl 	if (v3) {
    684  1.251   thorpej 		nfsm_v3attrbuild(vap, true);
    685   1.59      fvdl 		nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
    686   1.59      fvdl 		*tl = nfs_false;
    687   1.24   mycroft 	} else {
    688  1.200  christos #endif
    689   1.59      fvdl 		nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
    690   1.84  christos 		if (vap->va_mode == (mode_t)VNOVAL)
    691   1.59      fvdl 			sp->sa_mode = nfs_xdrneg1;
    692   1.59      fvdl 		else
    693   1.59      fvdl 			sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
    694   1.59      fvdl 		if (vap->va_uid == (uid_t)VNOVAL)
    695   1.59      fvdl 			sp->sa_uid = nfs_xdrneg1;
    696   1.59      fvdl 		else
    697   1.59      fvdl 			sp->sa_uid = txdr_unsigned(vap->va_uid);
    698   1.59      fvdl 		if (vap->va_gid == (gid_t)VNOVAL)
    699   1.59      fvdl 			sp->sa_gid = nfs_xdrneg1;
    700   1.59      fvdl 		else
    701   1.59      fvdl 			sp->sa_gid = txdr_unsigned(vap->va_gid);
    702   1.59      fvdl 		sp->sa_size = txdr_unsigned(vap->va_size);
    703   1.59      fvdl 		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
    704   1.59      fvdl 		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
    705  1.200  christos #ifndef NFS_V2_ONLY
    706   1.59      fvdl 	}
    707  1.200  christos #endif
    708  1.230  christos 	nfsm_request(np, NFSPROC_SETATTR, l, cred);
    709  1.200  christos #ifndef NFS_V2_ONLY
    710   1.59      fvdl 	if (v3) {
    711  1.251   thorpej 		nfsm_wcc_data(vp, wccflag, NAC_NOTRUNC, false);
    712   1.59      fvdl 	} else
    713  1.200  christos #endif
    714  1.244      yamt 		nfsm_loadattr(vp, (struct vattr *)0, NAC_NOTRUNC);
    715   1.32   mycroft 	nfsm_reqdone;
    716    1.1       cgd 	return (error);
    717    1.1       cgd }
    718    1.1       cgd 
    719    1.1       cgd /*
    720    1.1       cgd  * nfs lookup call, one step at a time...
    721    1.1       cgd  * First look in cache
    722  1.274      yamt  * If not found, do the rpc.
    723    1.1       cgd  */
    724   1.32   mycroft int
    725  1.272       dsl nfs_lookup(void *v)
    726   1.58  christos {
    727  1.304   hannken 	struct vop_lookup_v2_args /* {
    728   1.32   mycroft 		struct vnodeop_desc *a_desc;
    729   1.32   mycroft 		struct vnode *a_dvp;
    730   1.32   mycroft 		struct vnode **a_vpp;
    731   1.32   mycroft 		struct componentname *a_cnp;
    732   1.58  christos 	} */ *ap = v;
    733   1.89      fvdl 	struct componentname *cnp = ap->a_cnp;
    734   1.89      fvdl 	struct vnode *dvp = ap->a_dvp;
    735   1.89      fvdl 	struct vnode **vpp = ap->a_vpp;
    736  1.102  wrstuden 	int flags;
    737   1.89      fvdl 	struct vnode *newvp;
    738   1.89      fvdl 	u_int32_t *tl;
    739  1.252  christos 	char *cp;
    740   1.89      fvdl 	int32_t t1, t2;
    741  1.252  christos 	char *bpos, *dpos, *cp2;
    742  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
    743    1.1       cgd 	long len;
    744   1.59      fvdl 	nfsfh_t *fhp;
    745    1.1       cgd 	struct nfsnode *np;
    746  1.296  dholland 	int cachefound;
    747  1.246       chs 	int error = 0, attrflag, fhsize;
    748  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
    749  1.128      fvdl 
    750  1.102  wrstuden 	flags = cnp->cn_flags;
    751    1.1       cgd 
    752   1.60       jtk 	*vpp = NULLVP;
    753  1.128      fvdl 	newvp = NULLVP;
    754   1.59      fvdl 	if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
    755   1.59      fvdl 	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
    756   1.59      fvdl 		return (EROFS);
    757   1.32   mycroft 	if (dvp->v_type != VDIR)
    758    1.1       cgd 		return (ENOTDIR);
    759  1.108      fvdl 
    760  1.198      yamt 	/*
    761  1.198      yamt 	 * RFC1813(nfsv3) 3.2 says clients should handle "." by themselves.
    762  1.198      yamt 	 */
    763  1.198      yamt 	if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
    764  1.260     pooka 		error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
    765  1.198      yamt 		if (error)
    766  1.198      yamt 			return error;
    767  1.198      yamt 		if (cnp->cn_nameiop == RENAME && (flags & ISLASTCN))
    768  1.198      yamt 			return EISDIR;
    769  1.282     pooka 		vref(dvp);
    770  1.198      yamt 		*vpp = dvp;
    771  1.198      yamt 		return 0;
    772  1.198      yamt 	}
    773  1.198      yamt 
    774   1.32   mycroft 	np = VTONFS(dvp);
    775  1.106  jdolecek 
    776  1.106  jdolecek 	/*
    777  1.270      yamt 	 * Before performing an RPC, check the name cache to see if
    778  1.270      yamt 	 * the directory/name pair we are looking for is known already.
    779  1.106  jdolecek 	 * If the directory/name pair is found in the name cache,
    780  1.106  jdolecek 	 * we have to ensure the directory has not changed from
    781  1.106  jdolecek 	 * the time the cache entry has been created. If it has,
    782  1.220     perry 	 * the cache entry has to be ignored.
    783  1.106  jdolecek 	 */
    784  1.297  dholland 	cachefound = cache_lookup_raw(dvp, cnp->cn_nameptr, cnp->cn_namelen,
    785  1.297  dholland 				      cnp->cn_flags, NULL, vpp);
    786  1.203      yamt 	KASSERT(dvp != *vpp);
    787  1.275      yamt 	KASSERT((cnp->cn_flags & ISWHITEOUT) == 0);
    788  1.296  dholland 	if (cachefound) {
    789    1.1       cgd 		struct vattr vattr;
    790  1.108      fvdl 
    791  1.296  dholland 		error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
    792  1.296  dholland 		if (error != 0) {
    793  1.296  dholland 			if (*vpp != NULLVP)
    794  1.296  dholland 				vrele(*vpp);
    795  1.108      fvdl 			*vpp = NULLVP;
    796  1.128      fvdl 			return error;
    797  1.128      fvdl 		}
    798  1.128      fvdl 
    799  1.260     pooka 		if (VOP_GETATTR(dvp, &vattr, cnp->cn_cred)
    800  1.260     pooka 		    || timespeccmp(&vattr.va_mtime,
    801  1.215      yamt 		    &VTONFS(dvp)->n_nctime, !=)) {
    802  1.296  dholland 			if (*vpp != NULLVP) {
    803  1.215      yamt 				vrele(*vpp);
    804  1.215      yamt 				*vpp = NULLVP;
    805  1.203      yamt 			}
    806  1.297  dholland 			cache_purge1(dvp, NULL, 0, PURGE_CHILDREN);
    807  1.178      yamt 			timespecclear(&np->n_nctime);
    808   1.82      fvdl 			goto dorpc;
    809   1.82      fvdl 		}
    810   1.82      fvdl 
    811  1.296  dholland 		if (*vpp == NULLVP) {
    812  1.296  dholland 			/* namecache gave us a negative result */
    813  1.298  macallan 			error = ENOENT;
    814  1.215      yamt 			goto noentry;
    815  1.215      yamt 		}
    816  1.215      yamt 
    817  1.274      yamt 		/*
    818  1.274      yamt 		 * investigate the vnode returned by cache_lookup_raw.
    819  1.274      yamt 		 * if it isn't appropriate, do an rpc.
    820  1.274      yamt 		 */
    821   1.59      fvdl 		newvp = *vpp;
    822  1.278      yamt 		if ((flags & ISDOTDOT) != 0) {
    823  1.284   hannken 			VOP_UNLOCK(dvp);
    824  1.278      yamt 		}
    825  1.304   hannken 		error = vn_lock(newvp, LK_SHARED);
    826  1.278      yamt 		if ((flags & ISDOTDOT) != 0) {
    827  1.278      yamt 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
    828  1.278      yamt 		}
    829  1.278      yamt 		if (error != 0) {
    830  1.278      yamt 			/* newvp has been reclaimed. */
    831  1.278      yamt 			vrele(newvp);
    832  1.278      yamt 			*vpp = NULLVP;
    833  1.278      yamt 			goto dorpc;
    834  1.278      yamt 		}
    835  1.260     pooka 		if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred)
    836  1.203      yamt 		    && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) {
    837  1.106  jdolecek 			nfsstats.lookupcache_hits++;
    838  1.190      yamt 			KASSERT(newvp->v_type != VNON);
    839  1.304   hannken 			VOP_UNLOCK(newvp);
    840  1.106  jdolecek 			return (0);
    841    1.1       cgd 		}
    842  1.297  dholland 		cache_purge1(newvp, NULL, 0, PURGE_PARENTS);
    843  1.278      yamt 		vput(newvp);
    844   1.32   mycroft 		*vpp = NULLVP;
    845   1.32   mycroft 	}
    846   1.82      fvdl dorpc:
    847  1.199      yamt #if 0
    848  1.192      yamt 	/*
    849  1.192      yamt 	 * because nfsv3 has the same CREATE semantics as ours,
    850  1.192      yamt 	 * we don't have to perform LOOKUPs beforehand.
    851  1.192      yamt 	 *
    852  1.192      yamt 	 * XXX ideally we can do the same for nfsv2 in the case of !O_EXCL.
    853  1.192      yamt 	 * XXX although we have no way to know if O_EXCL is requested or not.
    854  1.192      yamt 	 */
    855  1.192      yamt 
    856  1.196      yamt 	if (v3 && cnp->cn_nameiop == CREATE &&
    857  1.196      yamt 	    (flags & (ISLASTCN|ISDOTDOT)) == ISLASTCN &&
    858  1.193      yamt 	    (dvp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
    859  1.192      yamt 		return (EJUSTRETURN);
    860  1.192      yamt 	}
    861  1.199      yamt #endif /* 0 */
    862  1.192      yamt 
    863    1.1       cgd 	error = 0;
    864   1.59      fvdl 	newvp = NULLVP;
    865    1.1       cgd 	nfsstats.lookupcache_misses++;
    866    1.1       cgd 	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
    867   1.32   mycroft 	len = cnp->cn_namelen;
    868  1.165  drochner 	nfsm_reqhead(np, NFSPROC_LOOKUP,
    869   1.59      fvdl 		NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
    870  1.165  drochner 	nfsm_fhtom(np, v3);
    871   1.32   mycroft 	nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
    872  1.261     pooka 	nfsm_request(np, NFSPROC_LOOKUP, curlwp, cnp->cn_cred);
    873    1.1       cgd 	if (error) {
    874  1.153      yamt 		nfsm_postop_attr(dvp, attrflag, 0);
    875   1.59      fvdl 		m_freem(mrep);
    876   1.59      fvdl 		goto nfsmout;
    877   1.32   mycroft 	}
    878   1.59      fvdl 	nfsm_getfh(fhp, fhsize, v3);
    879    1.1       cgd 
    880    1.1       cgd 	/*
    881   1.32   mycroft 	 * Handle RENAME case...
    882    1.1       cgd 	 */
    883  1.246       chs 	if (cnp->cn_nameiop == RENAME && (flags & ISLASTCN)) {
    884   1.59      fvdl 		if (NFS_CMPFH(np, fhp, fhsize)) {
    885    1.1       cgd 			m_freem(mrep);
    886    1.1       cgd 			return (EISDIR);
    887    1.1       cgd 		}
    888  1.175      fvdl 		error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
    889   1.59      fvdl 		if (error) {
    890    1.1       cgd 			m_freem(mrep);
    891  1.128      fvdl 			return error;
    892    1.1       cgd 		}
    893    1.1       cgd 		newvp = NFSTOV(np);
    894  1.200  christos #ifndef NFS_V2_ONLY
    895   1.59      fvdl 		if (v3) {
    896  1.153      yamt 			nfsm_postop_attr(newvp, attrflag, 0);
    897  1.153      yamt 			nfsm_postop_attr(dvp, attrflag, 0);
    898   1.59      fvdl 		} else
    899  1.200  christos #endif
    900  1.153      yamt 			nfsm_loadattr(newvp, (struct vattr *)0, 0);
    901   1.32   mycroft 		*vpp = newvp;
    902    1.1       cgd 		m_freem(mrep);
    903  1.190      yamt 		goto validate;
    904    1.1       cgd 	}
    905    1.1       cgd 
    906  1.128      fvdl 	/*
    907  1.128      fvdl 	 * The postop attr handling is duplicated for each if case,
    908  1.128      fvdl 	 * because it should be done while dvp is locked (unlocking
    909  1.128      fvdl 	 * dvp is different for each case).
    910  1.128      fvdl 	 */
    911  1.128      fvdl 
    912   1.59      fvdl 	if (NFS_CMPFH(np, fhp, fhsize)) {
    913  1.128      fvdl 		/*
    914  1.309   hannken 		 * As we handle "." lookup locally, this is
    915  1.274      yamt 		 * a broken server.
    916  1.128      fvdl 		 */
    917  1.309   hannken 		m_freem(mrep);
    918  1.309   hannken 		return EBADRPC;
    919  1.128      fvdl 	} else if (flags & ISDOTDOT) {
    920  1.128      fvdl 		/*
    921  1.128      fvdl 		 * ".." lookup
    922  1.128      fvdl 		 */
    923  1.284   hannken 		VOP_UNLOCK(dvp);
    924  1.175      fvdl 		error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
    925  1.246       chs 		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
    926  1.128      fvdl 		if (error) {
    927  1.128      fvdl 			m_freem(mrep);
    928  1.128      fvdl 			return error;
    929  1.128      fvdl 		}
    930  1.128      fvdl 		newvp = NFSTOV(np);
    931  1.128      fvdl 
    932  1.200  christos #ifndef NFS_V2_ONLY
    933  1.128      fvdl 		if (v3) {
    934  1.153      yamt 			nfsm_postop_attr(newvp, attrflag, 0);
    935  1.153      yamt 			nfsm_postop_attr(dvp, attrflag, 0);
    936  1.128      fvdl 		} else
    937  1.200  christos #endif
    938  1.153      yamt 			nfsm_loadattr(newvp, (struct vattr *)0, 0);
    939    1.1       cgd 	} else {
    940  1.128      fvdl 		/*
    941  1.128      fvdl 		 * Other lookups.
    942  1.128      fvdl 		 */
    943  1.175      fvdl 		error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
    944   1.59      fvdl 		if (error) {
    945    1.1       cgd 			m_freem(mrep);
    946  1.128      fvdl 			return error;
    947    1.1       cgd 		}
    948    1.1       cgd 		newvp = NFSTOV(np);
    949  1.200  christos #ifndef NFS_V2_ONLY
    950  1.128      fvdl 		if (v3) {
    951  1.153      yamt 			nfsm_postop_attr(newvp, attrflag, 0);
    952  1.153      yamt 			nfsm_postop_attr(dvp, attrflag, 0);
    953  1.128      fvdl 		} else
    954  1.200  christos #endif
    955  1.153      yamt 			nfsm_loadattr(newvp, (struct vattr *)0, 0);
    956    1.1       cgd 	}
    957  1.295     rmind 	if (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN)) {
    958  1.188      yamt 		nfs_cache_enter(dvp, newvp, cnp);
    959    1.1       cgd 	}
    960   1.59      fvdl 	*vpp = newvp;
    961   1.59      fvdl 	nfsm_reqdone;
    962   1.59      fvdl 	if (error) {
    963  1.128      fvdl 		/*
    964  1.128      fvdl 		 * We get here only because of errors returned by
    965  1.128      fvdl 		 * the RPC. Otherwise we'll have returned above
    966  1.128      fvdl 		 * (the nfsm_* macros will jump to nfsm_reqdone
    967  1.128      fvdl 		 * on error).
    968  1.128      fvdl 		 */
    969  1.295     rmind 		if (error == ENOENT && cnp->cn_nameiop != CREATE) {
    970  1.188      yamt 			nfs_cache_enter(dvp, NULL, cnp);
    971   1.82      fvdl 		}
    972  1.128      fvdl 		if (newvp != NULLVP) {
    973  1.246       chs 			if (newvp == dvp) {
    974  1.246       chs 				vrele(newvp);
    975  1.246       chs 			} else {
    976  1.246       chs 				vput(newvp);
    977  1.246       chs 			}
    978  1.128      fvdl 		}
    979  1.203      yamt noentry:
    980   1.59      fvdl 		if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
    981   1.59      fvdl 		    (flags & ISLASTCN) && error == ENOENT) {
    982  1.203      yamt 			if (dvp->v_mount->mnt_flag & MNT_RDONLY) {
    983   1.59      fvdl 				error = EROFS;
    984  1.203      yamt 			} else {
    985   1.59      fvdl 				error = EJUSTRETURN;
    986  1.203      yamt 			}
    987   1.59      fvdl 		}
    988  1.128      fvdl 		*vpp = NULL;
    989  1.190      yamt 		return error;
    990  1.190      yamt 	}
    991  1.190      yamt 
    992  1.190      yamt validate:
    993  1.190      yamt 	/*
    994  1.190      yamt 	 * make sure we have valid type and size.
    995  1.190      yamt 	 */
    996  1.190      yamt 
    997  1.190      yamt 	newvp = *vpp;
    998  1.190      yamt 	if (newvp->v_type == VNON) {
    999  1.190      yamt 		struct vattr vattr; /* dummy */
   1000  1.190      yamt 
   1001  1.190      yamt 		KASSERT(VTONFS(newvp)->n_attrstamp == 0);
   1002  1.260     pooka 		error = VOP_GETATTR(newvp, &vattr, cnp->cn_cred);
   1003  1.190      yamt 		if (error) {
   1004  1.190      yamt 			vput(newvp);
   1005  1.190      yamt 			*vpp = NULL;
   1006  1.190      yamt 		}
   1007   1.59      fvdl 	}
   1008  1.304   hannken 	if (error)
   1009  1.304   hannken 		return error;
   1010  1.304   hannken 	if (newvp != dvp)
   1011  1.304   hannken 		VOP_UNLOCK(newvp);
   1012  1.304   hannken 	return 0;
   1013    1.1       cgd }
   1014    1.1       cgd 
   1015    1.1       cgd /*
   1016    1.1       cgd  * nfs read call.
   1017    1.1       cgd  * Just call nfs_bioread() to do the work.
   1018    1.1       cgd  */
   1019   1.32   mycroft int
   1020  1.272       dsl nfs_read(void *v)
   1021   1.58  christos {
   1022   1.32   mycroft 	struct vop_read_args /* {
   1023   1.32   mycroft 		struct vnode *a_vp;
   1024   1.32   mycroft 		struct uio *a_uio;
   1025   1.32   mycroft 		int  a_ioflag;
   1026  1.236      elad 		kauth_cred_t a_cred;
   1027   1.58  christos 	} */ *ap = v;
   1028  1.110  augustss 	struct vnode *vp = ap->a_vp;
   1029   1.32   mycroft 
   1030    1.1       cgd 	if (vp->v_type != VREG)
   1031  1.229      yamt 		return EISDIR;
   1032   1.81      fvdl 	return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred, 0));
   1033    1.1       cgd }
   1034    1.1       cgd 
   1035    1.1       cgd /*
   1036    1.1       cgd  * nfs readlink call
   1037    1.1       cgd  */
   1038   1.32   mycroft int
   1039  1.272       dsl nfs_readlink(void *v)
   1040   1.58  christos {
   1041   1.32   mycroft 	struct vop_readlink_args /* {
   1042   1.32   mycroft 		struct vnode *a_vp;
   1043   1.32   mycroft 		struct uio *a_uio;
   1044  1.236      elad 		kauth_cred_t a_cred;
   1045   1.58  christos 	} */ *ap = v;
   1046  1.110  augustss 	struct vnode *vp = ap->a_vp;
   1047  1.224      yamt 	struct nfsnode *np = VTONFS(vp);
   1048   1.32   mycroft 
   1049    1.1       cgd 	if (vp->v_type != VLNK)
   1050    1.1       cgd 		return (EPERM);
   1051  1.224      yamt 
   1052  1.224      yamt 	if (np->n_rcred != NULL) {
   1053  1.236      elad 		kauth_cred_free(np->n_rcred);
   1054  1.224      yamt 	}
   1055  1.224      yamt 	np->n_rcred = ap->a_cred;
   1056  1.236      elad 	kauth_cred_hold(np->n_rcred);
   1057  1.224      yamt 
   1058   1.81      fvdl 	return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred, 0));
   1059    1.1       cgd }
   1060    1.1       cgd 
   1061    1.1       cgd /*
   1062    1.1       cgd  * Do a readlink rpc.
   1063    1.1       cgd  * Called by nfs_doio() from below the buffer cache.
   1064    1.1       cgd  */
   1065   1.32   mycroft int
   1066  1.272       dsl nfs_readlinkrpc(struct vnode *vp, struct uio *uiop, kauth_cred_t cred)
   1067    1.1       cgd {
   1068  1.110  augustss 	u_int32_t *tl;
   1069  1.252  christos 	char *cp;
   1070  1.110  augustss 	int32_t t1, t2;
   1071  1.252  christos 	char *bpos, *dpos, *cp2;
   1072  1.200  christos 	int error = 0;
   1073  1.169      yamt 	uint32_t len;
   1074  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1075  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
   1076  1.165  drochner 	struct nfsnode *np = VTONFS(vp);
   1077  1.200  christos #ifndef NFS_V2_ONLY
   1078  1.200  christos 	int attrflag;
   1079  1.200  christos #endif
   1080    1.1       cgd 
   1081    1.1       cgd 	nfsstats.rpccnt[NFSPROC_READLINK]++;
   1082  1.165  drochner 	nfsm_reqhead(np, NFSPROC_READLINK, NFSX_FH(v3));
   1083  1.165  drochner 	nfsm_fhtom(np, v3);
   1084  1.231      yamt 	nfsm_request(np, NFSPROC_READLINK, curlwp, cred);
   1085  1.200  christos #ifndef NFS_V2_ONLY
   1086   1.59      fvdl 	if (v3)
   1087  1.153      yamt 		nfsm_postop_attr(vp, attrflag, 0);
   1088  1.200  christos #endif
   1089   1.59      fvdl 	if (!error) {
   1090  1.200  christos #ifndef NFS_V2_ONLY
   1091  1.169      yamt 		if (v3) {
   1092  1.169      yamt 			nfsm_dissect(tl, uint32_t *, NFSX_UNSIGNED);
   1093  1.169      yamt 			len = fxdr_unsigned(uint32_t, *tl);
   1094  1.292  christos 			if (len > NFS_MAXPATHLEN) {
   1095  1.169      yamt 				/*
   1096  1.169      yamt 				 * this pathname is too long for us.
   1097  1.169      yamt 				 */
   1098  1.169      yamt 				m_freem(mrep);
   1099  1.169      yamt 				/* Solaris returns EINVAL. should we follow? */
   1100  1.169      yamt 				error = ENAMETOOLONG;
   1101  1.169      yamt 				goto nfsmout;
   1102  1.169      yamt 			}
   1103  1.200  christos 		} else
   1104  1.200  christos #endif
   1105  1.200  christos 		{
   1106  1.169      yamt 			nfsm_strsiz(len, NFS_MAXPATHLEN);
   1107  1.169      yamt 		}
   1108   1.59      fvdl 		nfsm_mtouio(uiop, len);
   1109   1.59      fvdl 	}
   1110    1.1       cgd 	nfsm_reqdone;
   1111    1.1       cgd 	return (error);
   1112    1.1       cgd }
   1113    1.1       cgd 
   1114    1.1       cgd /*
   1115    1.1       cgd  * nfs read rpc call
   1116    1.1       cgd  * Ditto above
   1117    1.1       cgd  */
   1118   1.32   mycroft int
   1119  1.272       dsl nfs_readrpc(struct vnode *vp, struct uio *uiop)
   1120    1.1       cgd {
   1121  1.110  augustss 	u_int32_t *tl;
   1122  1.252  christos 	char *cp;
   1123  1.110  augustss 	int32_t t1, t2;
   1124  1.252  christos 	char *bpos, *dpos, *cp2;
   1125  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1126    1.1       cgd 	struct nfsmount *nmp;
   1127  1.301  nisimura 	int error = 0, len, retlen, tsiz, eof __unused, byte_count;
   1128  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
   1129  1.165  drochner 	struct nfsnode *np = VTONFS(vp);
   1130  1.200  christos #ifndef NFS_V2_ONLY
   1131  1.200  christos 	int attrflag;
   1132  1.200  christos #endif
   1133    1.1       cgd 
   1134   1.59      fvdl #ifndef nolint
   1135   1.59      fvdl 	eof = 0;
   1136   1.59      fvdl #endif
   1137    1.1       cgd 	nmp = VFSTONFS(vp->v_mount);
   1138    1.1       cgd 	tsiz = uiop->uio_resid;
   1139   1.80      fvdl 	if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
   1140   1.32   mycroft 		return (EFBIG);
   1141  1.232     blymn 	iostat_busy(nmp->nm_stats);
   1142  1.232     blymn 	byte_count = 0; /* count bytes actually transferred */
   1143    1.1       cgd 	while (tsiz > 0) {
   1144    1.1       cgd 		nfsstats.rpccnt[NFSPROC_READ]++;
   1145    1.1       cgd 		len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
   1146  1.165  drochner 		nfsm_reqhead(np, NFSPROC_READ, NFSX_FH(v3) + NFSX_UNSIGNED * 3);
   1147  1.165  drochner 		nfsm_fhtom(np, v3);
   1148   1.59      fvdl 		nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED * 3);
   1149  1.200  christos #ifndef NFS_V2_ONLY
   1150   1.59      fvdl 		if (v3) {
   1151   1.98      fair 			txdr_hyper(uiop->uio_offset, tl);
   1152   1.32   mycroft 			*(tl + 2) = txdr_unsigned(len);
   1153  1.200  christos 		} else
   1154  1.200  christos #endif
   1155  1.200  christos 		{
   1156   1.32   mycroft 			*tl++ = txdr_unsigned(uiop->uio_offset);
   1157   1.32   mycroft 			*tl++ = txdr_unsigned(len);
   1158   1.32   mycroft 			*tl = 0;
   1159   1.32   mycroft 		}
   1160  1.231      yamt 		nfsm_request(np, NFSPROC_READ, curlwp, np->n_rcred);
   1161  1.200  christos #ifndef NFS_V2_ONLY
   1162   1.59      fvdl 		if (v3) {
   1163  1.153      yamt 			nfsm_postop_attr(vp, attrflag, NAC_NOTRUNC);
   1164   1.59      fvdl 			if (error) {
   1165   1.59      fvdl 				m_freem(mrep);
   1166   1.59      fvdl 				goto nfsmout;
   1167   1.59      fvdl 			}
   1168   1.59      fvdl 			nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   1169   1.59      fvdl 			eof = fxdr_unsigned(int, *(tl + 1));
   1170   1.59      fvdl 		} else
   1171  1.200  christos #endif
   1172  1.153      yamt 			nfsm_loadattr(vp, (struct vattr *)0, NAC_NOTRUNC);
   1173    1.1       cgd 		nfsm_strsiz(retlen, nmp->nm_rsize);
   1174    1.1       cgd 		nfsm_mtouio(uiop, retlen);
   1175    1.1       cgd 		m_freem(mrep);
   1176   1.59      fvdl 		tsiz -= retlen;
   1177  1.232     blymn 		byte_count += retlen;
   1178  1.200  christos #ifndef NFS_V2_ONLY
   1179   1.59      fvdl 		if (v3) {
   1180   1.59      fvdl 			if (eof || retlen == 0)
   1181   1.59      fvdl 				tsiz = 0;
   1182  1.200  christos 		} else
   1183  1.200  christos #endif
   1184  1.200  christos 		if (retlen < len)
   1185    1.1       cgd 			tsiz = 0;
   1186    1.1       cgd 	}
   1187    1.1       cgd nfsmout:
   1188  1.232     blymn 	iostat_unbusy(nmp->nm_stats, byte_count, 1);
   1189    1.1       cgd 	return (error);
   1190    1.1       cgd }
   1191    1.1       cgd 
   1192  1.171      yamt struct nfs_writerpc_context {
   1193  1.253      yamt 	kmutex_t nwc_lock;
   1194  1.253      yamt 	kcondvar_t nwc_cv;
   1195  1.253      yamt 	int nwc_mbufcount;
   1196  1.171      yamt };
   1197  1.171      yamt 
   1198    1.1       cgd /*
   1199  1.170      yamt  * free mbuf used to refer protected pages while write rpc call.
   1200  1.171      yamt  * called at splvm.
   1201  1.167      yamt  */
   1202  1.167      yamt static void
   1203  1.252  christos nfs_writerpc_extfree(struct mbuf *m, void *tbuf, size_t size, void *arg)
   1204  1.167      yamt {
   1205  1.171      yamt 	struct nfs_writerpc_context *ctx = arg;
   1206  1.170      yamt 
   1207  1.170      yamt 	KASSERT(m != NULL);
   1208  1.171      yamt 	KASSERT(ctx != NULL);
   1209  1.258        ad 	pool_cache_put(mb_cache, m);
   1210  1.253      yamt 	mutex_enter(&ctx->nwc_lock);
   1211  1.171      yamt 	if (--ctx->nwc_mbufcount == 0) {
   1212  1.253      yamt 		cv_signal(&ctx->nwc_cv);
   1213  1.171      yamt 	}
   1214  1.253      yamt 	mutex_exit(&ctx->nwc_lock);
   1215  1.167      yamt }
   1216  1.167      yamt 
   1217  1.167      yamt /*
   1218    1.1       cgd  * nfs write call
   1219    1.1       cgd  */
   1220   1.32   mycroft int
   1221  1.272       dsl nfs_writerpc(struct vnode *vp, struct uio *uiop, int *iomode, bool pageprotected, bool *stalewriteverfp)
   1222    1.1       cgd {
   1223  1.110  augustss 	u_int32_t *tl;
   1224  1.252  christos 	char *cp;
   1225  1.173      yamt 	int32_t t1, t2;
   1226  1.252  christos 	char *bpos, *dpos;
   1227  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1228   1.59      fvdl 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
   1229  1.200  christos 	int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR;
   1230  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
   1231  1.119     bjh21 	int committed = NFSV3WRITE_FILESYNC;
   1232  1.165  drochner 	struct nfsnode *np = VTONFS(vp);
   1233  1.171      yamt 	struct nfs_writerpc_context ctx;
   1234  1.253      yamt 	int byte_count;
   1235  1.173      yamt 	size_t origresid;
   1236  1.200  christos #ifndef NFS_V2_ONLY
   1237  1.252  christos 	char *cp2;
   1238  1.200  christos 	int rlen, commit;
   1239  1.200  christos #endif
   1240  1.171      yamt 
   1241  1.125       chs 	if (vp->v_mount->mnt_flag & MNT_RDONLY) {
   1242  1.125       chs 		panic("writerpc readonly vp %p", vp);
   1243  1.125       chs 	}
   1244    1.1       cgd 
   1245  1.142     bjh21 #ifdef DIAGNOSTIC
   1246   1.59      fvdl 	if (uiop->uio_iovcnt != 1)
   1247   1.59      fvdl 		panic("nfs: writerpc iovcnt > 1");
   1248   1.59      fvdl #endif
   1249    1.1       cgd 	tsiz = uiop->uio_resid;
   1250   1.80      fvdl 	if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
   1251  1.289    cegger 		return EFBIG;
   1252  1.289    cegger 
   1253  1.289    cegger 	mutex_init(&ctx.nwc_lock, MUTEX_DRIVER, IPL_VM);
   1254  1.289    cegger 	cv_init(&ctx.nwc_cv, "nfsmblk");
   1255  1.289    cegger 	ctx.nwc_mbufcount = 1;
   1256  1.289    cegger 
   1257  1.173      yamt retry:
   1258  1.173      yamt 	origresid = uiop->uio_resid;
   1259  1.173      yamt 	KASSERT(origresid == uiop->uio_iov->iov_len);
   1260  1.232     blymn 	iostat_busy(nmp->nm_stats);
   1261  1.232     blymn 	byte_count = 0; /* count of bytes actually written */
   1262    1.1       cgd 	while (tsiz > 0) {
   1263  1.173      yamt 		uint32_t datalen; /* data bytes need to be allocated in mbuf */
   1264  1.308       chs 		size_t backup;
   1265  1.251   thorpej 		bool stalewriteverf = false;
   1266  1.167      yamt 
   1267    1.1       cgd 		nfsstats.rpccnt[NFSPROC_WRITE]++;
   1268  1.311  riastrad 		len = uimin(tsiz, nmp->nm_wsize);
   1269  1.167      yamt 		datalen = pageprotected ? 0 : nfsm_rndup(len);
   1270  1.165  drochner 		nfsm_reqhead(np, NFSPROC_WRITE,
   1271  1.167      yamt 			NFSX_FH(v3) + 5 * NFSX_UNSIGNED + datalen);
   1272  1.165  drochner 		nfsm_fhtom(np, v3);
   1273  1.200  christos #ifndef NFS_V2_ONLY
   1274   1.59      fvdl 		if (v3) {
   1275   1.59      fvdl 			nfsm_build(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
   1276   1.98      fair 			txdr_hyper(uiop->uio_offset, tl);
   1277   1.32   mycroft 			tl += 2;
   1278   1.59      fvdl 			*tl++ = txdr_unsigned(len);
   1279   1.59      fvdl 			*tl++ = txdr_unsigned(*iomode);
   1280   1.50       gwr 			*tl = txdr_unsigned(len);
   1281  1.200  christos 		} else
   1282  1.200  christos #endif
   1283  1.200  christos 		{
   1284  1.110  augustss 			u_int32_t x;
   1285   1.59      fvdl 
   1286   1.59      fvdl 			nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
   1287   1.50       gwr 			/* Set both "begin" and "current" to non-garbage. */
   1288   1.50       gwr 			x = txdr_unsigned((u_int32_t)uiop->uio_offset);
   1289   1.59      fvdl 			*tl++ = x;      /* "begin offset" */
   1290   1.59      fvdl 			*tl++ = x;      /* "current offset" */
   1291   1.50       gwr 			x = txdr_unsigned(len);
   1292   1.59      fvdl 			*tl++ = x;      /* total to this offset */
   1293   1.59      fvdl 			*tl = x;        /* size of this write */
   1294   1.59      fvdl 
   1295   1.32   mycroft 		}
   1296  1.167      yamt 		if (pageprotected) {
   1297  1.167      yamt 			/*
   1298  1.167      yamt 			 * since we know pages can't be modified during i/o,
   1299  1.167      yamt 			 * no need to copy them for us.
   1300  1.167      yamt 			 */
   1301  1.167      yamt 			struct mbuf *m;
   1302  1.167      yamt 			struct iovec *iovp = uiop->uio_iov;
   1303  1.167      yamt 
   1304  1.167      yamt 			m = m_get(M_WAIT, MT_DATA);
   1305  1.170      yamt 			MCLAIM(m, &nfs_mowner);
   1306  1.170      yamt 			MEXTADD(m, iovp->iov_base, len, M_MBUF,
   1307  1.171      yamt 			    nfs_writerpc_extfree, &ctx);
   1308  1.167      yamt 			m->m_flags |= M_EXT_ROMAP;
   1309  1.167      yamt 			m->m_len = len;
   1310  1.167      yamt 			mb->m_next = m;
   1311  1.167      yamt 			/*
   1312  1.167      yamt 			 * no need to maintain mb and bpos here
   1313  1.167      yamt 			 * because no one care them later.
   1314  1.167      yamt 			 */
   1315  1.167      yamt #if 0
   1316  1.167      yamt 			mb = m;
   1317  1.252  christos 			bpos = mtod(void *, mb) + mb->m_len;
   1318  1.167      yamt #endif
   1319  1.225  christos 			UIO_ADVANCE(uiop, len);
   1320  1.167      yamt 			uiop->uio_offset += len;
   1321  1.253      yamt 			mutex_enter(&ctx.nwc_lock);
   1322  1.171      yamt 			ctx.nwc_mbufcount++;
   1323  1.253      yamt 			mutex_exit(&ctx.nwc_lock);
   1324  1.183      yamt 			nfs_zeropad(mb, 0, nfsm_padlen(len));
   1325  1.167      yamt 		} else {
   1326  1.167      yamt 			nfsm_uiotom(uiop, len);
   1327  1.167      yamt 		}
   1328  1.231      yamt 		nfsm_request(np, NFSPROC_WRITE, curlwp, np->n_wcred);
   1329  1.200  christos #ifndef NFS_V2_ONLY
   1330   1.59      fvdl 		if (v3) {
   1331   1.59      fvdl 			wccflag = NFSV3_WCCCHK;
   1332  1.216      yamt 			nfsm_wcc_data(vp, wccflag, NAC_NOTRUNC, !error);
   1333   1.59      fvdl 			if (!error) {
   1334   1.59      fvdl 				nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED
   1335   1.59      fvdl 					+ NFSX_V3WRITEVERF);
   1336   1.59      fvdl 				rlen = fxdr_unsigned(int, *tl++);
   1337   1.59      fvdl 				if (rlen == 0) {
   1338   1.59      fvdl 					error = NFSERR_IO;
   1339   1.80      fvdl 					m_freem(mrep);
   1340   1.59      fvdl 					break;
   1341   1.59      fvdl 				} else if (rlen < len) {
   1342   1.59      fvdl 					backup = len - rlen;
   1343  1.225  christos 					UIO_ADVANCE(uiop, -backup);
   1344   1.59      fvdl 					uiop->uio_offset -= backup;
   1345   1.59      fvdl 					len = rlen;
   1346   1.59      fvdl 				}
   1347   1.59      fvdl 				commit = fxdr_unsigned(int, *tl++);
   1348   1.59      fvdl 
   1349   1.59      fvdl 				/*
   1350   1.59      fvdl 				 * Return the lowest committment level
   1351   1.59      fvdl 				 * obtained by any of the RPCs.
   1352   1.59      fvdl 				 */
   1353   1.59      fvdl 				if (committed == NFSV3WRITE_FILESYNC)
   1354   1.59      fvdl 					committed = commit;
   1355   1.59      fvdl 				else if (committed == NFSV3WRITE_DATASYNC &&
   1356   1.59      fvdl 					commit == NFSV3WRITE_UNSTABLE)
   1357   1.59      fvdl 					committed = commit;
   1358  1.254      yamt 				mutex_enter(&nmp->nm_lock);
   1359   1.81      fvdl 				if ((nmp->nm_iflag & NFSMNT_HASWRITEVERF) == 0){
   1360  1.166      yamt 					memcpy(nmp->nm_writeverf, tl,
   1361  1.166      yamt 					    NFSX_V3WRITEVERF);
   1362  1.166      yamt 					nmp->nm_iflag |= NFSMNT_HASWRITEVERF;
   1363  1.166      yamt 				} else if ((nmp->nm_iflag &
   1364  1.166      yamt 				    NFSMNT_STALEWRITEVERF) ||
   1365  1.166      yamt 				    memcmp(tl, nmp->nm_writeverf,
   1366  1.166      yamt 				    NFSX_V3WRITEVERF)) {
   1367  1.166      yamt 					memcpy(nmp->nm_writeverf, tl,
   1368  1.166      yamt 					    NFSX_V3WRITEVERF);
   1369  1.173      yamt 					/*
   1370  1.173      yamt 					 * note NFSMNT_STALEWRITEVERF
   1371  1.220     perry 					 * if we're the first thread to
   1372  1.173      yamt 					 * notice it.
   1373  1.173      yamt 					 */
   1374  1.173      yamt 					if ((nmp->nm_iflag &
   1375  1.173      yamt 					    NFSMNT_STALEWRITEVERF) == 0) {
   1376  1.251   thorpej 						stalewriteverf = true;
   1377  1.173      yamt 						nmp->nm_iflag |=
   1378  1.173      yamt 						    NFSMNT_STALEWRITEVERF;
   1379  1.173      yamt 					}
   1380   1.59      fvdl 				}
   1381  1.254      yamt 				mutex_exit(&nmp->nm_lock);
   1382   1.59      fvdl 			}
   1383   1.59      fvdl 		} else
   1384  1.200  christos #endif
   1385  1.172      yamt 			nfsm_loadattr(vp, (struct vattr *)0, NAC_NOTRUNC);
   1386   1.59      fvdl 		if (wccflag)
   1387  1.180      yamt 			VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr->va_mtime;
   1388    1.1       cgd 		m_freem(mrep);
   1389   1.80      fvdl 		if (error)
   1390   1.80      fvdl 			break;
   1391    1.1       cgd 		tsiz -= len;
   1392  1.232     blymn 		byte_count += len;
   1393  1.173      yamt 		if (stalewriteverf) {
   1394  1.251   thorpej 			*stalewriteverfp = true;
   1395  1.251   thorpej 			stalewriteverf = false;
   1396  1.173      yamt 			if (committed == NFSV3WRITE_UNSTABLE &&
   1397  1.173      yamt 			    len != origresid) {
   1398  1.173      yamt 				/*
   1399  1.173      yamt 				 * if our write requests weren't atomic but
   1400  1.173      yamt 				 * unstable, datas in previous iterations
   1401  1.173      yamt 				 * might have already been lost now.
   1402  1.173      yamt 				 * then, we should resend them to nfsd.
   1403  1.173      yamt 				 */
   1404  1.173      yamt 				backup = origresid - tsiz;
   1405  1.225  christos 				UIO_ADVANCE(uiop, -backup);
   1406  1.173      yamt 				uiop->uio_offset -= backup;
   1407  1.173      yamt 				tsiz = origresid;
   1408  1.173      yamt 				goto retry;
   1409  1.173      yamt 			}
   1410  1.173      yamt 		}
   1411  1.171      yamt 	}
   1412  1.210      yamt nfsmout:
   1413  1.232     blymn 	iostat_unbusy(nmp->nm_stats, byte_count, 0);
   1414  1.171      yamt 	if (pageprotected) {
   1415  1.171      yamt 		/*
   1416  1.171      yamt 		 * wait until mbufs go away.
   1417  1.171      yamt 		 * retransmitted mbufs can survive longer than rpc requests
   1418  1.171      yamt 		 * themselves.
   1419  1.171      yamt 		 */
   1420  1.253      yamt 		mutex_enter(&ctx.nwc_lock);
   1421  1.171      yamt 		ctx.nwc_mbufcount--;
   1422  1.171      yamt 		while (ctx.nwc_mbufcount > 0) {
   1423  1.253      yamt 			cv_wait(&ctx.nwc_cv, &ctx.nwc_lock);
   1424  1.171      yamt 		}
   1425  1.253      yamt 		mutex_exit(&ctx.nwc_lock);
   1426    1.1       cgd 	}
   1427  1.255      yamt 	mutex_destroy(&ctx.nwc_lock);
   1428  1.255      yamt 	cv_destroy(&ctx.nwc_cv);
   1429   1.59      fvdl 	*iomode = committed;
   1430   1.32   mycroft 	if (error)
   1431   1.32   mycroft 		uiop->uio_resid = tsiz;
   1432    1.1       cgd 	return (error);
   1433    1.1       cgd }
   1434    1.1       cgd 
   1435    1.1       cgd /*
   1436   1.59      fvdl  * nfs mknod rpc
   1437   1.59      fvdl  * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
   1438   1.59      fvdl  * mode set to specify the file type and the size field for rdev.
   1439    1.1       cgd  */
   1440   1.32   mycroft int
   1441  1.272       dsl nfs_mknodrpc(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, struct vattr *vap)
   1442   1.58  christos {
   1443  1.110  augustss 	struct nfsv2_sattr *sp;
   1444  1.110  augustss 	u_int32_t *tl;
   1445  1.252  christos 	char *cp;
   1446  1.110  augustss 	int32_t t1, t2;
   1447   1.59      fvdl 	struct vnode *newvp = (struct vnode *)0;
   1448  1.165  drochner 	struct nfsnode *dnp, *np;
   1449   1.32   mycroft 	char *cp2;
   1450  1.252  christos 	char *bpos, *dpos;
   1451   1.59      fvdl 	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
   1452  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1453   1.53       cgd 	u_int32_t rdev;
   1454  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   1455    1.1       cgd 
   1456    1.1       cgd 	if (vap->va_type == VCHR || vap->va_type == VBLK)
   1457    1.1       cgd 		rdev = txdr_unsigned(vap->va_rdev);
   1458   1.59      fvdl 	else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
   1459   1.59      fvdl 		rdev = nfs_xdrneg1;
   1460    1.1       cgd 	else {
   1461   1.32   mycroft 		VOP_ABORTOP(dvp, cnp);
   1462    1.1       cgd 		return (EOPNOTSUPP);
   1463    1.1       cgd 	}
   1464   1.59      fvdl 	nfsstats.rpccnt[NFSPROC_MKNOD]++;
   1465  1.165  drochner 	dnp = VTONFS(dvp);
   1466  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_MKNOD, NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
   1467   1.59      fvdl 		+ nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
   1468  1.165  drochner 	nfsm_fhtom(dnp, v3);
   1469   1.32   mycroft 	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
   1470  1.200  christos #ifndef NFS_V2_ONLY
   1471   1.59      fvdl 	if (v3) {
   1472  1.101      fvdl 		nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
   1473   1.59      fvdl 		*tl++ = vtonfsv3_type(vap->va_type);
   1474  1.251   thorpej 		nfsm_v3attrbuild(vap, false);
   1475   1.59      fvdl 		if (vap->va_type == VCHR || vap->va_type == VBLK) {
   1476   1.59      fvdl 			nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   1477   1.59      fvdl 			*tl++ = txdr_unsigned(major(vap->va_rdev));
   1478   1.59      fvdl 			*tl = txdr_unsigned(minor(vap->va_rdev));
   1479   1.59      fvdl 		}
   1480  1.200  christos 	} else
   1481  1.200  christos #endif
   1482  1.200  christos 	{
   1483   1.59      fvdl 		nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
   1484   1.59      fvdl 		sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
   1485   1.59      fvdl 		sp->sa_uid = nfs_xdrneg1;
   1486   1.59      fvdl 		sp->sa_gid = nfs_xdrneg1;
   1487   1.59      fvdl 		sp->sa_size = rdev;
   1488   1.59      fvdl 		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
   1489   1.59      fvdl 		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
   1490   1.59      fvdl 	}
   1491  1.261     pooka 	nfsm_request(dnp, NFSPROC_MKNOD, curlwp, cnp->cn_cred);
   1492   1.59      fvdl 	if (!error) {
   1493  1.175      fvdl 		nfsm_mtofh(dvp, newvp, v3, gotvp);
   1494   1.59      fvdl 		if (!gotvp) {
   1495   1.59      fvdl 			error = nfs_lookitup(dvp, cnp->cn_nameptr,
   1496  1.261     pooka 			    cnp->cn_namelen, cnp->cn_cred, curlwp, &np);
   1497   1.59      fvdl 			if (!error)
   1498   1.59      fvdl 				newvp = NFSTOV(np);
   1499   1.59      fvdl 		}
   1500   1.32   mycroft 	}
   1501  1.200  christos #ifndef NFS_V2_ONLY
   1502   1.59      fvdl 	if (v3)
   1503  1.216      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   1504  1.200  christos #endif
   1505    1.1       cgd 	nfsm_reqdone;
   1506   1.59      fvdl 	if (error) {
   1507   1.59      fvdl 		if (newvp)
   1508  1.128      fvdl 			vput(newvp);
   1509   1.59      fvdl 	} else {
   1510  1.295     rmind 		nfs_cache_enter(dvp, newvp, cnp);
   1511   1.59      fvdl 		*vpp = newvp;
   1512  1.303   hannken 		VOP_UNLOCK(newvp);
   1513   1.59      fvdl 	}
   1514   1.32   mycroft 	VTONFS(dvp)->n_flag |= NMODIFIED;
   1515   1.59      fvdl 	if (!wccflag)
   1516  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   1517   1.59      fvdl 	return (error);
   1518   1.59      fvdl }
   1519   1.59      fvdl 
   1520   1.59      fvdl /*
   1521   1.59      fvdl  * nfs mknod vop
   1522   1.59      fvdl  * just call nfs_mknodrpc() to do the work.
   1523   1.59      fvdl  */
   1524   1.59      fvdl /* ARGSUSED */
   1525   1.59      fvdl int
   1526  1.272       dsl nfs_mknod(void *v)
   1527   1.59      fvdl {
   1528  1.303   hannken 	struct vop_mknod_v3_args /* {
   1529   1.59      fvdl 		struct vnode *a_dvp;
   1530   1.59      fvdl 		struct vnode **a_vpp;
   1531   1.59      fvdl 		struct componentname *a_cnp;
   1532   1.59      fvdl 		struct vattr *a_vap;
   1533   1.59      fvdl 	} */ *ap = v;
   1534  1.203      yamt 	struct vnode *dvp = ap->a_dvp;
   1535  1.203      yamt 	struct componentname *cnp = ap->a_cnp;
   1536   1.59      fvdl 	int error;
   1537   1.59      fvdl 
   1538  1.203      yamt 	error = nfs_mknodrpc(dvp, ap->a_vpp, cnp, ap->a_vap);
   1539  1.203      yamt 	VN_KNOTE(dvp, NOTE_WRITE);
   1540  1.203      yamt 	if (error == 0 || error == EEXIST)
   1541  1.297  dholland 		cache_purge1(dvp, cnp->cn_nameptr, cnp->cn_namelen, 0);
   1542    1.1       cgd 	return (error);
   1543    1.1       cgd }
   1544    1.1       cgd 
   1545    1.1       cgd /*
   1546    1.1       cgd  * nfs file create call
   1547    1.1       cgd  */
   1548   1.32   mycroft int
   1549  1.272       dsl nfs_create(void *v)
   1550   1.58  christos {
   1551  1.303   hannken 	struct vop_create_v3_args /* {
   1552   1.32   mycroft 		struct vnode *a_dvp;
   1553   1.32   mycroft 		struct vnode **a_vpp;
   1554   1.32   mycroft 		struct componentname *a_cnp;
   1555   1.32   mycroft 		struct vattr *a_vap;
   1556   1.58  christos 	} */ *ap = v;
   1557  1.110  augustss 	struct vnode *dvp = ap->a_dvp;
   1558  1.110  augustss 	struct vattr *vap = ap->a_vap;
   1559  1.110  augustss 	struct componentname *cnp = ap->a_cnp;
   1560  1.110  augustss 	struct nfsv2_sattr *sp;
   1561  1.110  augustss 	u_int32_t *tl;
   1562  1.252  christos 	char *cp;
   1563  1.110  augustss 	int32_t t1, t2;
   1564  1.165  drochner 	struct nfsnode *dnp, *np = (struct nfsnode *)0;
   1565   1.59      fvdl 	struct vnode *newvp = (struct vnode *)0;
   1566  1.252  christos 	char *bpos, *dpos, *cp2;
   1567  1.262      yamt 	int error, wccflag = NFSV3_WCCRATTR, gotvp = 0;
   1568  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1569  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   1570  1.262      yamt 	u_int32_t excl_mode = NFSV3CREATE_UNCHECKED;
   1571   1.59      fvdl 
   1572   1.59      fvdl 	/*
   1573   1.59      fvdl 	 * Oops, not for me..
   1574   1.59      fvdl 	 */
   1575   1.59      fvdl 	if (vap->va_type == VSOCK)
   1576   1.59      fvdl 		return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap));
   1577    1.1       cgd 
   1578  1.204      yamt 	KASSERT(vap->va_type == VREG);
   1579  1.204      yamt 
   1580   1.59      fvdl #ifdef VA_EXCLUSIVE
   1581  1.262      yamt 	if (vap->va_vaflags & VA_EXCLUSIVE) {
   1582  1.262      yamt 		excl_mode = NFSV3CREATE_EXCLUSIVE;
   1583  1.262      yamt 	}
   1584   1.59      fvdl #endif
   1585   1.59      fvdl again:
   1586  1.103   thorpej 	error = 0;
   1587    1.1       cgd 	nfsstats.rpccnt[NFSPROC_CREATE]++;
   1588  1.165  drochner 	dnp = VTONFS(dvp);
   1589  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_CREATE, NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
   1590   1.59      fvdl 		nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
   1591  1.165  drochner 	nfsm_fhtom(dnp, v3);
   1592   1.32   mycroft 	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
   1593  1.200  christos #ifndef NFS_V2_ONLY
   1594   1.59      fvdl 	if (v3) {
   1595   1.59      fvdl 		nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
   1596  1.262      yamt 		if (excl_mode == NFSV3CREATE_EXCLUSIVE) {
   1597  1.101      fvdl 			*tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
   1598  1.101      fvdl 			nfsm_build(tl, u_int32_t *, NFSX_V3CREATEVERF);
   1599  1.293       tls 			*tl++ = cprng_fast32();
   1600  1.293       tls 			*tl = cprng_fast32();
   1601   1.59      fvdl 		} else {
   1602  1.262      yamt 			*tl = txdr_unsigned(excl_mode);
   1603  1.251   thorpej 			nfsm_v3attrbuild(vap, false);
   1604   1.59      fvdl 		}
   1605  1.200  christos 	} else
   1606  1.200  christos #endif
   1607  1.200  christos 	{
   1608   1.59      fvdl 		nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
   1609   1.59      fvdl 		sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
   1610   1.59      fvdl 		sp->sa_uid = nfs_xdrneg1;
   1611   1.59      fvdl 		sp->sa_gid = nfs_xdrneg1;
   1612   1.59      fvdl 		sp->sa_size = 0;
   1613   1.59      fvdl 		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
   1614   1.59      fvdl 		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
   1615   1.32   mycroft 	}
   1616  1.261     pooka 	nfsm_request(dnp, NFSPROC_CREATE, curlwp, cnp->cn_cred);
   1617   1.59      fvdl 	if (!error) {
   1618  1.175      fvdl 		nfsm_mtofh(dvp, newvp, v3, gotvp);
   1619   1.59      fvdl 		if (!gotvp) {
   1620   1.59      fvdl 			error = nfs_lookitup(dvp, cnp->cn_nameptr,
   1621  1.261     pooka 			    cnp->cn_namelen, cnp->cn_cred, curlwp, &np);
   1622   1.59      fvdl 			if (!error)
   1623   1.59      fvdl 				newvp = NFSTOV(np);
   1624   1.59      fvdl 		}
   1625   1.59      fvdl 	}
   1626  1.200  christos #ifndef NFS_V2_ONLY
   1627   1.59      fvdl 	if (v3)
   1628  1.216      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   1629  1.200  christos #endif
   1630    1.1       cgd 	nfsm_reqdone;
   1631   1.59      fvdl 	if (error) {
   1632  1.238      yamt 		/*
   1633  1.238      yamt 		 * nfs_request maps NFSERR_NOTSUPP to ENOTSUP.
   1634  1.238      yamt 		 */
   1635  1.262      yamt 		if (v3 && error == ENOTSUP) {
   1636  1.262      yamt 			if (excl_mode == NFSV3CREATE_EXCLUSIVE) {
   1637  1.262      yamt 				excl_mode = NFSV3CREATE_GUARDED;
   1638  1.262      yamt 				goto again;
   1639  1.262      yamt 			} else if (excl_mode == NFSV3CREATE_GUARDED) {
   1640  1.262      yamt 				excl_mode = NFSV3CREATE_UNCHECKED;
   1641  1.262      yamt 				goto again;
   1642  1.262      yamt 			}
   1643   1.59      fvdl 		}
   1644  1.262      yamt 	} else if (v3 && (excl_mode == NFSV3CREATE_EXCLUSIVE)) {
   1645  1.237    kardel 		struct timespec ts;
   1646  1.237    kardel 
   1647  1.237    kardel 		getnanotime(&ts);
   1648  1.204      yamt 
   1649  1.204      yamt 		/*
   1650  1.204      yamt 		 * make sure that we'll update timestamps as
   1651  1.204      yamt 		 * most server implementations use them to store
   1652  1.204      yamt 		 * the create verifier.
   1653  1.204      yamt 		 *
   1654  1.204      yamt 		 * XXX it's better to use TOSERVER always.
   1655  1.204      yamt 		 */
   1656  1.204      yamt 
   1657  1.237    kardel 		if (vap->va_atime.tv_sec == VNOVAL)
   1658  1.237    kardel 			vap->va_atime = ts;
   1659  1.237    kardel 		if (vap->va_mtime.tv_sec == VNOVAL)
   1660  1.237    kardel 			vap->va_mtime = ts;
   1661  1.204      yamt 
   1662  1.261     pooka 		error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, curlwp);
   1663  1.204      yamt 	}
   1664  1.203      yamt 	if (error == 0) {
   1665   1.59      fvdl 		if (cnp->cn_flags & MAKEENTRY)
   1666  1.188      yamt 			nfs_cache_enter(dvp, newvp, cnp);
   1667  1.203      yamt 		else
   1668  1.297  dholland 			cache_purge1(dvp, cnp->cn_nameptr, cnp->cn_namelen, 0);
   1669   1.59      fvdl 		*ap->a_vpp = newvp;
   1670  1.303   hannken 		VOP_UNLOCK(newvp);
   1671  1.203      yamt 	} else {
   1672  1.203      yamt 		if (newvp)
   1673  1.203      yamt 			vput(newvp);
   1674  1.203      yamt 		if (error == EEXIST)
   1675  1.297  dholland 			cache_purge1(dvp, cnp->cn_nameptr, cnp->cn_namelen, 0);
   1676   1.59      fvdl 	}
   1677   1.32   mycroft 	VTONFS(dvp)->n_flag |= NMODIFIED;
   1678   1.59      fvdl 	if (!wccflag)
   1679  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   1680  1.156  jdolecek 	VN_KNOTE(ap->a_dvp, NOTE_WRITE);
   1681    1.1       cgd 	return (error);
   1682    1.1       cgd }
   1683    1.1       cgd 
   1684    1.1       cgd /*
   1685    1.1       cgd  * nfs file remove call
   1686    1.1       cgd  * To try and make nfs semantics closer to ufs semantics, a file that has
   1687    1.1       cgd  * other processes using the vnode is renamed instead of removed and then
   1688    1.1       cgd  * removed later on the last close.
   1689  1.314        ad  * - If vrefcnt(vp) > 1
   1690    1.1       cgd  *	  If a rename is not already in the works
   1691    1.1       cgd  *	     call nfs_sillyrename() to set it up
   1692    1.1       cgd  *     else
   1693    1.1       cgd  *	  do the remove rpc
   1694    1.1       cgd  */
   1695   1.32   mycroft int
   1696  1.272       dsl nfs_remove(void *v)
   1697   1.58  christos {
   1698  1.310  riastrad 	struct vop_remove_v2_args /* {
   1699   1.32   mycroft 		struct vnodeop_desc *a_desc;
   1700   1.32   mycroft 		struct vnode * a_dvp;
   1701   1.32   mycroft 		struct vnode * a_vp;
   1702   1.32   mycroft 		struct componentname * a_cnp;
   1703   1.58  christos 	} */ *ap = v;
   1704  1.110  augustss 	struct vnode *vp = ap->a_vp;
   1705  1.110  augustss 	struct vnode *dvp = ap->a_dvp;
   1706  1.110  augustss 	struct componentname *cnp = ap->a_cnp;
   1707  1.110  augustss 	struct nfsnode *np = VTONFS(vp);
   1708    1.1       cgd 	int error = 0;
   1709   1.38        pk 	struct vattr vattr;
   1710    1.1       cgd 
   1711   1.59      fvdl #ifndef DIAGNOSTIC
   1712  1.314        ad 	if (vrefcnt(vp) < 1)
   1713  1.314        ad 		panic("nfs_remove: bad vrefcnt(vp)");
   1714   1.59      fvdl #endif
   1715   1.77      fvdl 	if (vp->v_type == VDIR)
   1716   1.77      fvdl 		error = EPERM;
   1717  1.314        ad 	else if (vrefcnt(vp) == 1 || (np->n_sillyrename &&
   1718  1.260     pooka 	    VOP_GETATTR(vp, &vattr, cnp->cn_cred) == 0 &&
   1719   1.59      fvdl 	    vattr.va_nlink > 1)) {
   1720   1.32   mycroft 		/*
   1721   1.32   mycroft 		 * Purge the name cache so that the chance of a lookup for
   1722   1.32   mycroft 		 * the name succeeding while the remove is in progress is
   1723   1.32   mycroft 		 * minimized. Without node locking it can still happen, such
   1724   1.32   mycroft 		 * that an I/O op returns ESTALE, but since you get this if
   1725   1.32   mycroft 		 * another host removes the file..
   1726   1.32   mycroft 		 */
   1727   1.32   mycroft 		cache_purge(vp);
   1728   1.32   mycroft 		/*
   1729   1.59      fvdl 		 * throw away biocache buffers, mainly to avoid
   1730   1.59      fvdl 		 * unnecessary delayed writes later.
   1731   1.32   mycroft 		 */
   1732  1.261     pooka 		error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, curlwp, 1);
   1733   1.32   mycroft 		/* Do the rpc */
   1734   1.59      fvdl 		if (error != EINTR)
   1735   1.59      fvdl 			error = nfs_removerpc(dvp, cnp->cn_nameptr,
   1736  1.261     pooka 				cnp->cn_namelen, cnp->cn_cred, curlwp);
   1737   1.59      fvdl 	} else if (!np->n_sillyrename)
   1738  1.251   thorpej 		error = nfs_sillyrename(dvp, vp, cnp, false);
   1739  1.176      yamt 	if (!error && nfs_getattrcache(vp, &vattr) == 0 &&
   1740  1.176      yamt 	    vattr.va_nlink == 1) {
   1741  1.176      yamt 		np->n_flag |= NREMOVED;
   1742  1.176      yamt 	}
   1743  1.185      yamt 	NFS_INVALIDATE_ATTRCACHE(np);
   1744  1.156  jdolecek 	VN_KNOTE(vp, NOTE_DELETE);
   1745  1.156  jdolecek 	VN_KNOTE(dvp, NOTE_WRITE);
   1746  1.152   thorpej 	if (dvp == vp)
   1747  1.152   thorpej 		vrele(vp);
   1748  1.152   thorpej 	else
   1749  1.152   thorpej 		vput(vp);
   1750    1.1       cgd 	return (error);
   1751    1.1       cgd }
   1752    1.1       cgd 
   1753    1.1       cgd /*
   1754    1.1       cgd  * nfs file remove rpc called from nfs_inactive
   1755    1.1       cgd  */
   1756   1.32   mycroft int
   1757  1.272       dsl nfs_removeit(struct sillyrename *sp)
   1758    1.1       cgd {
   1759   1.59      fvdl 
   1760   1.59      fvdl 	return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
   1761  1.230  christos 		(struct lwp *)0));
   1762   1.59      fvdl }
   1763   1.59      fvdl 
   1764   1.59      fvdl /*
   1765   1.59      fvdl  * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
   1766   1.59      fvdl  */
   1767   1.59      fvdl int
   1768  1.272       dsl nfs_removerpc(struct vnode *dvp, const char *name, int namelen, kauth_cred_t cred, struct lwp *l)
   1769   1.59      fvdl {
   1770  1.110  augustss 	u_int32_t *tl;
   1771  1.252  christos 	char *cp;
   1772  1.200  christos #ifndef NFS_V2_ONLY
   1773  1.200  christos 	int32_t t1;
   1774  1.252  christos 	char *cp2;
   1775  1.200  christos #endif
   1776  1.200  christos 	int32_t t2;
   1777  1.252  christos 	char *bpos, *dpos;
   1778   1.59      fvdl 	int error = 0, wccflag = NFSV3_WCCRATTR;
   1779  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1780  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   1781  1.234  christos 	int rexmit = 0;
   1782  1.165  drochner 	struct nfsnode *dnp = VTONFS(dvp);
   1783    1.1       cgd 
   1784    1.1       cgd 	nfsstats.rpccnt[NFSPROC_REMOVE]++;
   1785  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_REMOVE,
   1786   1.59      fvdl 		NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen));
   1787  1.165  drochner 	nfsm_fhtom(dnp, v3);
   1788   1.59      fvdl 	nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
   1789  1.230  christos 	nfsm_request1(dnp, NFSPROC_REMOVE, l, cred, &rexmit);
   1790  1.200  christos #ifndef NFS_V2_ONLY
   1791   1.59      fvdl 	if (v3)
   1792  1.216      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   1793  1.200  christos #endif
   1794    1.1       cgd 	nfsm_reqdone;
   1795   1.59      fvdl 	VTONFS(dvp)->n_flag |= NMODIFIED;
   1796   1.59      fvdl 	if (!wccflag)
   1797  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   1798  1.197      yamt 	/*
   1799  1.197      yamt 	 * Kludge City: If the first reply to the remove rpc is lost..
   1800  1.197      yamt 	 *   the reply to the retransmitted request will be ENOENT
   1801  1.197      yamt 	 *   since the file was in fact removed
   1802  1.197      yamt 	 *   Therefore, we cheat and return success.
   1803  1.197      yamt 	 */
   1804  1.197      yamt 	if (rexmit && error == ENOENT)
   1805  1.197      yamt 		error = 0;
   1806    1.1       cgd 	return (error);
   1807    1.1       cgd }
   1808    1.1       cgd 
   1809    1.1       cgd /*
   1810    1.1       cgd  * nfs file rename call
   1811    1.1       cgd  */
   1812   1.32   mycroft int
   1813  1.272       dsl nfs_rename(void *v)
   1814   1.58  christos {
   1815   1.32   mycroft 	struct vop_rename_args  /* {
   1816   1.32   mycroft 		struct vnode *a_fdvp;
   1817   1.32   mycroft 		struct vnode *a_fvp;
   1818   1.32   mycroft 		struct componentname *a_fcnp;
   1819   1.32   mycroft 		struct vnode *a_tdvp;
   1820   1.32   mycroft 		struct vnode *a_tvp;
   1821   1.32   mycroft 		struct componentname *a_tcnp;
   1822   1.58  christos 	} */ *ap = v;
   1823  1.111  augustss 	struct vnode *fvp = ap->a_fvp;
   1824  1.111  augustss 	struct vnode *tvp = ap->a_tvp;
   1825  1.111  augustss 	struct vnode *fdvp = ap->a_fdvp;
   1826  1.111  augustss 	struct vnode *tdvp = ap->a_tdvp;
   1827  1.111  augustss 	struct componentname *tcnp = ap->a_tcnp;
   1828  1.111  augustss 	struct componentname *fcnp = ap->a_fcnp;
   1829   1.59      fvdl 	int error;
   1830   1.17       cgd 
   1831   1.17       cgd 	/* Check for cross-device rename */
   1832   1.17       cgd 	if ((fvp->v_mount != tdvp->v_mount) ||
   1833   1.17       cgd 	    (tvp && (fvp->v_mount != tvp->v_mount))) {
   1834   1.17       cgd 		error = EXDEV;
   1835   1.17       cgd 		goto out;
   1836   1.17       cgd 	}
   1837    1.1       cgd 
   1838   1.59      fvdl 	/*
   1839   1.59      fvdl 	 * If the tvp exists and is in use, sillyrename it before doing the
   1840   1.59      fvdl 	 * rename of the new file over it.
   1841  1.240      yamt 	 *
   1842  1.240      yamt 	 * Have sillyrename use link instead of rename if possible,
   1843  1.240      yamt 	 * so that we don't lose the file if the rename fails, and so
   1844  1.240      yamt 	 * that there's no window when the "to" file doesn't exist.
   1845   1.59      fvdl 	 */
   1846  1.314        ad 	if (tvp && vrefcnt(tvp) > 1 && !VTONFS(tvp)->n_sillyrename &&
   1847  1.251   thorpej 	    tvp->v_type != VDIR && !nfs_sillyrename(tdvp, tvp, tcnp, true)) {
   1848  1.156  jdolecek 		VN_KNOTE(tvp, NOTE_DELETE);
   1849  1.130     enami 		vput(tvp);
   1850   1.59      fvdl 		tvp = NULL;
   1851   1.59      fvdl 	}
   1852   1.59      fvdl 
   1853   1.59      fvdl 	error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
   1854   1.59      fvdl 		tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
   1855  1.261     pooka 		curlwp);
   1856   1.32   mycroft 
   1857  1.156  jdolecek 	VN_KNOTE(fdvp, NOTE_WRITE);
   1858  1.156  jdolecek 	VN_KNOTE(tdvp, NOTE_WRITE);
   1859  1.203      yamt 	if (error == 0 || error == EEXIST) {
   1860  1.203      yamt 		if (fvp->v_type == VDIR)
   1861  1.203      yamt 			cache_purge(fvp);
   1862  1.203      yamt 		else
   1863  1.297  dholland 			cache_purge1(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
   1864  1.297  dholland 				     0);
   1865   1.32   mycroft 		if (tvp != NULL && tvp->v_type == VDIR)
   1866  1.203      yamt 			cache_purge(tvp);
   1867  1.203      yamt 		else
   1868  1.297  dholland 			cache_purge1(tdvp, tcnp->cn_nameptr, tcnp->cn_namelen,
   1869  1.297  dholland 				     0);
   1870    1.1       cgd 	}
   1871   1.17       cgd out:
   1872   1.32   mycroft 	if (tdvp == tvp)
   1873   1.32   mycroft 		vrele(tdvp);
   1874    1.1       cgd 	else
   1875   1.32   mycroft 		vput(tdvp);
   1876   1.32   mycroft 	if (tvp)
   1877   1.32   mycroft 		vput(tvp);
   1878   1.32   mycroft 	vrele(fdvp);
   1879   1.32   mycroft 	vrele(fvp);
   1880    1.1       cgd 	return (error);
   1881    1.1       cgd }
   1882    1.1       cgd 
   1883    1.1       cgd /*
   1884    1.1       cgd  * nfs file rename rpc called from nfs_remove() above
   1885    1.1       cgd  */
   1886   1.32   mycroft int
   1887  1.272       dsl nfs_renameit(struct vnode *sdvp, struct componentname *scnp, struct sillyrename *sp)
   1888    1.1       cgd {
   1889   1.59      fvdl 	return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen,
   1890  1.261     pooka 		sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, curlwp));
   1891   1.59      fvdl }
   1892   1.59      fvdl 
   1893   1.59      fvdl /*
   1894   1.59      fvdl  * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
   1895   1.59      fvdl  */
   1896   1.59      fvdl int
   1897  1.272       dsl nfs_renamerpc(struct vnode *fdvp, const char *fnameptr, int fnamelen, struct vnode *tdvp, const char *tnameptr, int tnamelen, kauth_cred_t cred, struct lwp *l)
   1898   1.59      fvdl {
   1899  1.111  augustss 	u_int32_t *tl;
   1900  1.252  christos 	char *cp;
   1901  1.200  christos #ifndef NFS_V2_ONLY
   1902  1.200  christos 	int32_t t1;
   1903  1.252  christos 	char *cp2;
   1904  1.200  christos #endif
   1905  1.200  christos 	int32_t t2;
   1906  1.252  christos 	char *bpos, *dpos;
   1907   1.59      fvdl 	int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
   1908  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   1909  1.119     bjh21 	const int v3 = NFS_ISV3(fdvp);
   1910  1.234  christos 	int rexmit = 0;
   1911  1.165  drochner 	struct nfsnode *fdnp = VTONFS(fdvp);
   1912    1.1       cgd 
   1913    1.1       cgd 	nfsstats.rpccnt[NFSPROC_RENAME]++;
   1914  1.165  drochner 	nfsm_reqhead(fdnp, NFSPROC_RENAME,
   1915   1.59      fvdl 		(NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
   1916   1.59      fvdl 		nfsm_rndup(tnamelen));
   1917  1.165  drochner 	nfsm_fhtom(fdnp, v3);
   1918   1.59      fvdl 	nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN);
   1919  1.165  drochner 	nfsm_fhtom(VTONFS(tdvp), v3);
   1920   1.59      fvdl 	nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN);
   1921  1.230  christos 	nfsm_request1(fdnp, NFSPROC_RENAME, l, cred, &rexmit);
   1922  1.200  christos #ifndef NFS_V2_ONLY
   1923   1.59      fvdl 	if (v3) {
   1924  1.216      yamt 		nfsm_wcc_data(fdvp, fwccflag, 0, !error);
   1925  1.216      yamt 		nfsm_wcc_data(tdvp, twccflag, 0, !error);
   1926   1.59      fvdl 	}
   1927  1.200  christos #endif
   1928    1.1       cgd 	nfsm_reqdone;
   1929   1.59      fvdl 	VTONFS(fdvp)->n_flag |= NMODIFIED;
   1930   1.59      fvdl 	VTONFS(tdvp)->n_flag |= NMODIFIED;
   1931   1.59      fvdl 	if (!fwccflag)
   1932  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(fdvp));
   1933   1.59      fvdl 	if (!twccflag)
   1934  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(tdvp));
   1935  1.197      yamt 	/*
   1936  1.197      yamt 	 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
   1937  1.197      yamt 	 */
   1938  1.197      yamt 	if (rexmit && error == ENOENT)
   1939  1.197      yamt 		error = 0;
   1940    1.1       cgd 	return (error);
   1941    1.1       cgd }
   1942    1.1       cgd 
   1943  1.240      yamt /*
   1944  1.240      yamt  * NFS link RPC, called from nfs_link.
   1945  1.240      yamt  * Assumes dvp and vp locked, and leaves them that way.
   1946  1.240      yamt  */
   1947  1.240      yamt 
   1948  1.239      yamt static int
   1949  1.239      yamt nfs_linkrpc(struct vnode *dvp, struct vnode *vp, const char *name,
   1950  1.239      yamt     size_t namelen, kauth_cred_t cred, struct lwp *l)
   1951  1.239      yamt {
   1952  1.239      yamt 	u_int32_t *tl;
   1953  1.252  christos 	char *cp;
   1954  1.239      yamt #ifndef NFS_V2_ONLY
   1955  1.239      yamt 	int32_t t1;
   1956  1.252  christos 	char *cp2;
   1957  1.239      yamt #endif
   1958  1.239      yamt 	int32_t t2;
   1959  1.252  christos 	char *bpos, *dpos;
   1960  1.239      yamt 	int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
   1961  1.239      yamt 	struct mbuf *mreq, *mrep, *md, *mb;
   1962  1.239      yamt 	const int v3 = NFS_ISV3(dvp);
   1963  1.239      yamt 	int rexmit = 0;
   1964  1.239      yamt 	struct nfsnode *np = VTONFS(vp);
   1965  1.239      yamt 
   1966  1.239      yamt 	nfsstats.rpccnt[NFSPROC_LINK]++;
   1967  1.239      yamt 	nfsm_reqhead(np, NFSPROC_LINK,
   1968  1.239      yamt 	    NFSX_FH(v3)*2 + NFSX_UNSIGNED + nfsm_rndup(namelen));
   1969  1.239      yamt 	nfsm_fhtom(np, v3);
   1970  1.239      yamt 	nfsm_fhtom(VTONFS(dvp), v3);
   1971  1.239      yamt 	nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
   1972  1.239      yamt 	nfsm_request1(np, NFSPROC_LINK, l, cred, &rexmit);
   1973  1.239      yamt #ifndef NFS_V2_ONLY
   1974  1.239      yamt 	if (v3) {
   1975  1.239      yamt 		nfsm_postop_attr(vp, attrflag, 0);
   1976  1.239      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   1977  1.239      yamt 	}
   1978  1.239      yamt #endif
   1979  1.239      yamt 	nfsm_reqdone;
   1980  1.239      yamt 
   1981  1.239      yamt 	VTONFS(dvp)->n_flag |= NMODIFIED;
   1982  1.239      yamt 	if (!attrflag)
   1983  1.239      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(vp));
   1984  1.239      yamt 	if (!wccflag)
   1985  1.239      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   1986  1.239      yamt 
   1987  1.239      yamt 	/*
   1988  1.239      yamt 	 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
   1989  1.239      yamt 	 */
   1990  1.239      yamt 	if (rexmit && error == EEXIST)
   1991  1.239      yamt 		error = 0;
   1992  1.239      yamt 
   1993  1.239      yamt 	return error;
   1994  1.239      yamt }
   1995  1.239      yamt 
   1996    1.1       cgd /*
   1997    1.1       cgd  * nfs hard link create call
   1998    1.1       cgd  */
   1999   1.32   mycroft int
   2000  1.272       dsl nfs_link(void *v)
   2001   1.58  christos {
   2002  1.307  riastrad 	struct vop_link_v2_args /* {
   2003   1.57   mycroft 		struct vnode *a_dvp;
   2004   1.32   mycroft 		struct vnode *a_vp;
   2005   1.32   mycroft 		struct componentname *a_cnp;
   2006   1.58  christos 	} */ *ap = v;
   2007  1.111  augustss 	struct vnode *vp = ap->a_vp;
   2008  1.111  augustss 	struct vnode *dvp = ap->a_dvp;
   2009  1.111  augustss 	struct componentname *cnp = ap->a_cnp;
   2010  1.239      yamt 	int error = 0;
   2011    1.1       cgd 
   2012  1.290     rmind 	error = vn_lock(vp, LK_EXCLUSIVE);
   2013  1.290     rmind 	if (error != 0) {
   2014  1.144  christos 		VOP_ABORTOP(dvp, cnp);
   2015  1.290     rmind 		return error;
   2016  1.132      fvdl 	}
   2017   1.32   mycroft 
   2018   1.36   mycroft 	/*
   2019   1.36   mycroft 	 * Push all writes to the server, so that the attribute cache
   2020   1.36   mycroft 	 * doesn't get "out of sync" with the server.
   2021   1.36   mycroft 	 * XXX There should be a better way!
   2022   1.36   mycroft 	 */
   2023  1.260     pooka 	VOP_FSYNC(vp, cnp->cn_cred, FSYNC_WAIT, 0, 0);
   2024   1.36   mycroft 
   2025  1.239      yamt 	error = nfs_linkrpc(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen,
   2026  1.261     pooka 	    cnp->cn_cred, curlwp);
   2027  1.239      yamt 
   2028  1.290     rmind 	if (error == 0) {
   2029  1.297  dholland 		cache_purge1(dvp, cnp->cn_nameptr, cnp->cn_namelen, 0);
   2030  1.290     rmind 	}
   2031  1.290     rmind 	VOP_UNLOCK(vp);
   2032  1.156  jdolecek 	VN_KNOTE(vp, NOTE_LINK);
   2033  1.156  jdolecek 	VN_KNOTE(dvp, NOTE_WRITE);
   2034    1.1       cgd 	return (error);
   2035    1.1       cgd }
   2036    1.1       cgd 
   2037    1.1       cgd /*
   2038    1.1       cgd  * nfs symbolic link create call
   2039    1.1       cgd  */
   2040   1.32   mycroft int
   2041  1.272       dsl nfs_symlink(void *v)
   2042   1.58  christos {
   2043  1.303   hannken 	struct vop_symlink_v3_args /* {
   2044   1.32   mycroft 		struct vnode *a_dvp;
   2045   1.32   mycroft 		struct vnode **a_vpp;
   2046   1.32   mycroft 		struct componentname *a_cnp;
   2047   1.32   mycroft 		struct vattr *a_vap;
   2048   1.32   mycroft 		char *a_target;
   2049   1.58  christos 	} */ *ap = v;
   2050  1.111  augustss 	struct vnode *dvp = ap->a_dvp;
   2051  1.111  augustss 	struct vattr *vap = ap->a_vap;
   2052  1.111  augustss 	struct componentname *cnp = ap->a_cnp;
   2053  1.111  augustss 	struct nfsv2_sattr *sp;
   2054  1.111  augustss 	u_int32_t *tl;
   2055  1.252  christos 	char *cp;
   2056  1.111  augustss 	int32_t t1, t2;
   2057  1.252  christos 	char *bpos, *dpos, *cp2;
   2058   1.59      fvdl 	int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
   2059  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2060   1.59      fvdl 	struct vnode *newvp = (struct vnode *)0;
   2061  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   2062  1.233  christos 	int rexmit = 0;
   2063  1.165  drochner 	struct nfsnode *dnp = VTONFS(dvp);
   2064    1.1       cgd 
   2065  1.135     assar 	*ap->a_vpp = NULL;
   2066    1.1       cgd 	nfsstats.rpccnt[NFSPROC_SYMLINK]++;
   2067   1.32   mycroft 	slen = strlen(ap->a_target);
   2068  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_SYMLINK, NFSX_FH(v3) + 2*NFSX_UNSIGNED +
   2069   1.59      fvdl 	    nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3));
   2070  1.165  drochner 	nfsm_fhtom(dnp, v3);
   2071   1.32   mycroft 	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
   2072  1.200  christos #ifndef NFS_V2_ONlY
   2073  1.101      fvdl 	if (v3)
   2074  1.251   thorpej 		nfsm_v3attrbuild(vap, false);
   2075  1.200  christos #endif
   2076   1.32   mycroft 	nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
   2077  1.200  christos #ifndef NFS_V2_ONlY
   2078   1.59      fvdl 	if (!v3) {
   2079   1.59      fvdl 		nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
   2080   1.59      fvdl 		sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
   2081   1.59      fvdl 		sp->sa_uid = nfs_xdrneg1;
   2082   1.59      fvdl 		sp->sa_gid = nfs_xdrneg1;
   2083   1.59      fvdl 		sp->sa_size = nfs_xdrneg1;
   2084   1.59      fvdl 		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
   2085   1.59      fvdl 		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
   2086   1.32   mycroft 	}
   2087  1.200  christos #endif
   2088  1.261     pooka 	nfsm_request1(dnp, NFSPROC_SYMLINK, curlwp, cnp->cn_cred,
   2089  1.197      yamt 	    &rexmit);
   2090  1.200  christos #ifndef NFS_V2_ONlY
   2091   1.59      fvdl 	if (v3) {
   2092   1.59      fvdl 		if (!error)
   2093  1.175      fvdl 			nfsm_mtofh(dvp, newvp, v3, gotvp);
   2094  1.216      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   2095   1.59      fvdl 	}
   2096  1.200  christos #endif
   2097    1.1       cgd 	nfsm_reqdone;
   2098  1.135     assar 	/*
   2099  1.135     assar 	 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
   2100  1.135     assar 	 */
   2101  1.197      yamt 	if (rexmit && error == EEXIST)
   2102  1.135     assar 		error = 0;
   2103  1.203      yamt 	if (error == 0 || error == EEXIST)
   2104  1.297  dholland 		cache_purge1(dvp, cnp->cn_nameptr, cnp->cn_namelen, 0);
   2105  1.135     assar 	if (error == 0 && newvp == NULL) {
   2106  1.135     assar 		struct nfsnode *np = NULL;
   2107  1.135     assar 
   2108  1.135     assar 		error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
   2109  1.261     pooka 		    cnp->cn_cred, curlwp, &np);
   2110  1.135     assar 		if (error == 0)
   2111  1.135     assar 			newvp = NFSTOV(np);
   2112  1.135     assar 	}
   2113  1.135     assar 	if (error) {
   2114  1.135     assar 		if (newvp != NULL)
   2115  1.135     assar 			vput(newvp);
   2116  1.135     assar 	} else {
   2117  1.135     assar 		*ap->a_vpp = newvp;
   2118  1.303   hannken 		VOP_UNLOCK(newvp);
   2119  1.135     assar 	}
   2120   1.32   mycroft 	VTONFS(dvp)->n_flag |= NMODIFIED;
   2121   1.59      fvdl 	if (!wccflag)
   2122  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   2123  1.156  jdolecek 	VN_KNOTE(dvp, NOTE_WRITE);
   2124    1.1       cgd 	return (error);
   2125    1.1       cgd }
   2126    1.1       cgd 
   2127    1.1       cgd /*
   2128    1.1       cgd  * nfs make dir call
   2129    1.1       cgd  */
   2130   1.32   mycroft int
   2131  1.272       dsl nfs_mkdir(void *v)
   2132   1.58  christos {
   2133  1.303   hannken 	struct vop_mkdir_v3_args /* {
   2134   1.32   mycroft 		struct vnode *a_dvp;
   2135   1.32   mycroft 		struct vnode **a_vpp;
   2136   1.32   mycroft 		struct componentname *a_cnp;
   2137   1.32   mycroft 		struct vattr *a_vap;
   2138   1.58  christos 	} */ *ap = v;
   2139  1.111  augustss 	struct vnode *dvp = ap->a_dvp;
   2140  1.111  augustss 	struct vattr *vap = ap->a_vap;
   2141  1.111  augustss 	struct componentname *cnp = ap->a_cnp;
   2142  1.111  augustss 	struct nfsv2_sattr *sp;
   2143  1.111  augustss 	u_int32_t *tl;
   2144  1.252  christos 	char *cp;
   2145  1.111  augustss 	int32_t t1, t2;
   2146  1.111  augustss 	int len;
   2147  1.165  drochner 	struct nfsnode *dnp = VTONFS(dvp), *np = (struct nfsnode *)0;
   2148   1.59      fvdl 	struct vnode *newvp = (struct vnode *)0;
   2149  1.252  christos 	char *bpos, *dpos, *cp2;
   2150   1.59      fvdl 	int error = 0, wccflag = NFSV3_WCCRATTR;
   2151   1.59      fvdl 	int gotvp = 0;
   2152  1.234  christos 	int rexmit = 0;
   2153  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2154  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   2155    1.1       cgd 
   2156   1.32   mycroft 	len = cnp->cn_namelen;
   2157    1.1       cgd 	nfsstats.rpccnt[NFSPROC_MKDIR]++;
   2158  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_MKDIR,
   2159   1.59      fvdl 	  NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) + NFSX_SATTR(v3));
   2160  1.165  drochner 	nfsm_fhtom(dnp, v3);
   2161   1.32   mycroft 	nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
   2162  1.200  christos #ifndef NFS_V2_ONLY
   2163   1.59      fvdl 	if (v3) {
   2164  1.251   thorpej 		nfsm_v3attrbuild(vap, false);
   2165  1.200  christos 	} else
   2166  1.200  christos #endif
   2167  1.200  christos 	{
   2168   1.59      fvdl 		nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
   2169   1.59      fvdl 		sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
   2170   1.59      fvdl 		sp->sa_uid = nfs_xdrneg1;
   2171   1.59      fvdl 		sp->sa_gid = nfs_xdrneg1;
   2172   1.59      fvdl 		sp->sa_size = nfs_xdrneg1;
   2173   1.59      fvdl 		txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
   2174   1.59      fvdl 		txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
   2175   1.32   mycroft 	}
   2176  1.261     pooka 	nfsm_request1(dnp, NFSPROC_MKDIR, curlwp, cnp->cn_cred, &rexmit);
   2177   1.59      fvdl 	if (!error)
   2178  1.175      fvdl 		nfsm_mtofh(dvp, newvp, v3, gotvp);
   2179   1.59      fvdl 	if (v3)
   2180  1.216      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   2181    1.1       cgd 	nfsm_reqdone;
   2182   1.32   mycroft 	VTONFS(dvp)->n_flag |= NMODIFIED;
   2183   1.59      fvdl 	if (!wccflag)
   2184  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   2185    1.1       cgd 	/*
   2186    1.1       cgd 	 * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
   2187    1.1       cgd 	 * if we can succeed in looking up the directory.
   2188    1.1       cgd 	 */
   2189  1.197      yamt 	if ((rexmit && error == EEXIST) || (!error && !gotvp)) {
   2190   1.59      fvdl 		if (newvp) {
   2191  1.128      fvdl 			vput(newvp);
   2192   1.59      fvdl 			newvp = (struct vnode *)0;
   2193   1.59      fvdl 		}
   2194   1.59      fvdl 		error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
   2195  1.261     pooka 			curlwp, &np);
   2196   1.59      fvdl 		if (!error) {
   2197   1.59      fvdl 			newvp = NFSTOV(np);
   2198  1.195      yamt 			if (newvp->v_type != VDIR || newvp == dvp)
   2199   1.59      fvdl 				error = EEXIST;
   2200    1.1       cgd 		}
   2201    1.1       cgd 	}
   2202   1.59      fvdl 	if (error) {
   2203  1.195      yamt 		if (newvp) {
   2204  1.195      yamt 			if (dvp != newvp)
   2205  1.195      yamt 				vput(newvp);
   2206  1.195      yamt 			else
   2207  1.195      yamt 				vrele(newvp);
   2208  1.195      yamt 		}
   2209   1.82      fvdl 	} else {
   2210  1.156  jdolecek 		VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
   2211  1.295     rmind 		nfs_cache_enter(dvp, newvp, cnp);
   2212   1.59      fvdl 		*ap->a_vpp = newvp;
   2213  1.303   hannken 		VOP_UNLOCK(newvp);
   2214   1.82      fvdl 	}
   2215    1.1       cgd 	return (error);
   2216    1.1       cgd }
   2217    1.1       cgd 
   2218    1.1       cgd /*
   2219    1.1       cgd  * nfs remove directory call
   2220    1.1       cgd  */
   2221   1.32   mycroft int
   2222  1.272       dsl nfs_rmdir(void *v)
   2223   1.58  christos {
   2224  1.310  riastrad 	struct vop_rmdir_v2_args /* {
   2225   1.32   mycroft 		struct vnode *a_dvp;
   2226   1.32   mycroft 		struct vnode *a_vp;
   2227   1.32   mycroft 		struct componentname *a_cnp;
   2228   1.58  christos 	} */ *ap = v;
   2229  1.111  augustss 	struct vnode *vp = ap->a_vp;
   2230  1.111  augustss 	struct vnode *dvp = ap->a_dvp;
   2231  1.111  augustss 	struct componentname *cnp = ap->a_cnp;
   2232  1.111  augustss 	u_int32_t *tl;
   2233  1.252  christos 	char *cp;
   2234  1.200  christos #ifndef NFS_V2_ONLY
   2235  1.200  christos 	int32_t t1;
   2236  1.252  christos 	char *cp2;
   2237  1.200  christos #endif
   2238  1.200  christos 	int32_t t2;
   2239  1.252  christos 	char *bpos, *dpos;
   2240   1.59      fvdl 	int error = 0, wccflag = NFSV3_WCCRATTR;
   2241  1.234  christos 	int rexmit = 0;
   2242  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2243  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   2244  1.165  drochner 	struct nfsnode *dnp;
   2245    1.1       cgd 
   2246   1.32   mycroft 	if (dvp == vp) {
   2247  1.310  riastrad 		vrele(vp);
   2248    1.1       cgd 		return (EINVAL);
   2249    1.1       cgd 	}
   2250    1.1       cgd 	nfsstats.rpccnt[NFSPROC_RMDIR]++;
   2251  1.165  drochner 	dnp = VTONFS(dvp);
   2252  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_RMDIR,
   2253   1.59      fvdl 		NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
   2254  1.165  drochner 	nfsm_fhtom(dnp, v3);
   2255   1.32   mycroft 	nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
   2256  1.261     pooka 	nfsm_request1(dnp, NFSPROC_RMDIR, curlwp, cnp->cn_cred, &rexmit);
   2257  1.200  christos #ifndef NFS_V2_ONLY
   2258   1.59      fvdl 	if (v3)
   2259  1.216      yamt 		nfsm_wcc_data(dvp, wccflag, 0, !error);
   2260  1.200  christos #endif
   2261    1.1       cgd 	nfsm_reqdone;
   2262   1.32   mycroft 	VTONFS(dvp)->n_flag |= NMODIFIED;
   2263   1.59      fvdl 	if (!wccflag)
   2264  1.185      yamt 		NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
   2265  1.156  jdolecek 	VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
   2266  1.156  jdolecek 	VN_KNOTE(vp, NOTE_DELETE);
   2267   1.32   mycroft 	cache_purge(vp);
   2268  1.129      fvdl 	vput(vp);
   2269    1.1       cgd 	/*
   2270    1.1       cgd 	 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
   2271    1.1       cgd 	 */
   2272  1.197      yamt 	if (rexmit && error == ENOENT)
   2273    1.1       cgd 		error = 0;
   2274    1.1       cgd 	return (error);
   2275    1.1       cgd }
   2276    1.1       cgd 
   2277    1.1       cgd /*
   2278    1.1       cgd  * nfs readdir call
   2279    1.1       cgd  */
   2280   1.32   mycroft int
   2281  1.272       dsl nfs_readdir(void *v)
   2282   1.58  christos {
   2283   1.32   mycroft 	struct vop_readdir_args /* {
   2284   1.32   mycroft 		struct vnode *a_vp;
   2285   1.32   mycroft 		struct uio *a_uio;
   2286  1.236      elad 		kauth_cred_t a_cred;
   2287   1.32   mycroft 		int *a_eofflag;
   2288   1.89      fvdl 		off_t **a_cookies;
   2289   1.89      fvdl 		int *a_ncookies;
   2290   1.58  christos 	} */ *ap = v;
   2291  1.111  augustss 	struct vnode *vp = ap->a_vp;
   2292  1.111  augustss 	struct uio *uio = ap->a_uio;
   2293   1.85      fvdl 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
   2294   1.52   ghudson 	char *base = uio->uio_iov->iov_base;
   2295    1.1       cgd 	int tresid, error;
   2296   1.81      fvdl 	size_t count, lost;
   2297   1.90      fvdl 	struct dirent *dp;
   2298   1.90      fvdl 	off_t *cookies = NULL;
   2299   1.90      fvdl 	int ncookies = 0, nc;
   2300   1.32   mycroft 
   2301    1.1       cgd 	if (vp->v_type != VDIR)
   2302    1.1       cgd 		return (EPERM);
   2303   1.81      fvdl 
   2304   1.81      fvdl 	lost = uio->uio_resid & (NFS_DIRFRAGSIZ - 1);
   2305   1.81      fvdl 	count = uio->uio_resid - lost;
   2306   1.81      fvdl 	if (count <= 0)
   2307   1.81      fvdl 		return (EINVAL);
   2308   1.81      fvdl 
   2309    1.1       cgd 	/*
   2310    1.1       cgd 	 * Call nfs_bioread() to do the real work.
   2311    1.1       cgd 	 */
   2312   1.81      fvdl 	tresid = uio->uio_resid = count;
   2313   1.81      fvdl 	error = nfs_bioread(vp, uio, 0, ap->a_cred,
   2314   1.81      fvdl 		    ap->a_cookies ? NFSBIO_CACHECOOKIES : 0);
   2315    1.1       cgd 
   2316   1.90      fvdl 	if (!error && ap->a_cookies) {
   2317   1.90      fvdl 		ncookies = count / 16;
   2318  1.116   thorpej 		cookies = malloc(sizeof (off_t) * ncookies, M_TEMP, M_WAITOK);
   2319   1.90      fvdl 		*ap->a_cookies = cookies;
   2320   1.90      fvdl 	}
   2321   1.90      fvdl 
   2322   1.59      fvdl 	if (!error && uio->uio_resid == tresid) {
   2323   1.81      fvdl 		uio->uio_resid += lost;
   2324    1.1       cgd 		nfsstats.direofcache_misses++;
   2325   1.90      fvdl 		if (ap->a_cookies)
   2326   1.90      fvdl 			*ap->a_ncookies = 0;
   2327   1.59      fvdl 		*ap->a_eofflag = 1;
   2328   1.59      fvdl 		return (0);
   2329   1.59      fvdl 	}
   2330   1.52   ghudson 
   2331   1.52   ghudson 	if (!error && ap->a_cookies) {
   2332   1.52   ghudson 		/*
   2333   1.52   ghudson 		 * Only the NFS server and emulations use cookies, and they
   2334   1.52   ghudson 		 * load the directory block into system space, so we can
   2335   1.52   ghudson 		 * just look at it directly.
   2336   1.52   ghudson 		 */
   2337  1.231      yamt 		if (!VMSPACE_IS_KERNEL_P(uio->uio_vmspace) ||
   2338  1.231      yamt 		    uio->uio_iovcnt != 1)
   2339   1.59      fvdl 			panic("nfs_readdir: lost in space");
   2340   1.91    kleink 		for (nc = 0; ncookies-- &&
   2341   1.91    kleink 		     base < (char *)uio->uio_iov->iov_base; nc++){
   2342   1.52   ghudson 			dp = (struct dirent *) base;
   2343   1.52   ghudson 			if (dp->d_reclen == 0)
   2344   1.52   ghudson 				break;
   2345   1.85      fvdl 			if (nmp->nm_flag & NFSMNT_XLATECOOKIE)
   2346   1.85      fvdl 				*(cookies++) = (off_t)NFS_GETCOOKIE32(dp);
   2347   1.85      fvdl 			else
   2348   1.85      fvdl 				*(cookies++) = NFS_GETCOOKIE(dp);
   2349   1.52   ghudson 			base += dp->d_reclen;
   2350   1.52   ghudson 		}
   2351   1.91    kleink 		uio->uio_resid +=
   2352  1.252  christos 		    ((char *)uio->uio_iov->iov_base - base);
   2353   1.91    kleink 		uio->uio_iov->iov_len +=
   2354  1.252  christos 		    ((char *)uio->uio_iov->iov_base - base);
   2355   1.52   ghudson 		uio->uio_iov->iov_base = base;
   2356   1.90      fvdl 		*ap->a_ncookies = nc;
   2357   1.52   ghudson 	}
   2358   1.52   ghudson 
   2359   1.81      fvdl 	uio->uio_resid += lost;
   2360   1.59      fvdl 	*ap->a_eofflag = 0;
   2361    1.1       cgd 	return (error);
   2362    1.1       cgd }
   2363    1.1       cgd 
   2364    1.1       cgd /*
   2365    1.1       cgd  * Readdir rpc call.
   2366    1.1       cgd  * Called from below the buffer cache by nfs_doio().
   2367    1.1       cgd  */
   2368   1.32   mycroft int
   2369  1.272       dsl nfs_readdirrpc(struct vnode *vp, struct uio *uiop, kauth_cred_t cred)
   2370    1.1       cgd {
   2371  1.111  augustss 	int len, left;
   2372  1.111  augustss 	struct dirent *dp = NULL;
   2373  1.111  augustss 	u_int32_t *tl;
   2374  1.252  christos 	char *cp;
   2375  1.111  augustss 	int32_t t1, t2;
   2376  1.252  christos 	char *bpos, *dpos, *cp2;
   2377  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2378   1.59      fvdl 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
   2379   1.59      fvdl 	struct nfsnode *dnp = VTONFS(vp);
   2380   1.59      fvdl 	u_quad_t fileno;
   2381  1.225  christos 	int error = 0, more_dirs = 1, blksiz = 0, bigenough = 1;
   2382  1.200  christos #ifndef NFS_V2_ONLY
   2383  1.200  christos 	int attrflag;
   2384  1.200  christos #endif
   2385  1.200  christos 	int nrpcs = 0, reclen;
   2386  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
   2387   1.59      fvdl 
   2388   1.81      fvdl #ifdef DIAGNOSTIC
   2389   1.81      fvdl 	/*
   2390   1.81      fvdl 	 * Should be called from buffer cache, so only amount of
   2391   1.81      fvdl 	 * NFS_DIRBLKSIZ will be requested.
   2392   1.81      fvdl 	 */
   2393  1.219      yamt 	if (uiop->uio_iovcnt != 1 || uiop->uio_resid != NFS_DIRBLKSIZ)
   2394   1.59      fvdl 		panic("nfs readdirrpc bad uio");
   2395   1.59      fvdl #endif
   2396    1.1       cgd 
   2397    1.1       cgd 	/*
   2398   1.59      fvdl 	 * Loop around doing readdir rpc's of size nm_readdirsize
   2399   1.81      fvdl 	 * truncated to a multiple of NFS_DIRFRAGSIZ.
   2400    1.1       cgd 	 * The stopping criteria is EOF or buffer full.
   2401    1.1       cgd 	 */
   2402   1.59      fvdl 	while (more_dirs && bigenough) {
   2403   1.85      fvdl 		/*
   2404   1.85      fvdl 		 * Heuristic: don't bother to do another RPC to further
   2405   1.85      fvdl 		 * fill up this block if there is not much room left. (< 50%
   2406   1.85      fvdl 		 * of the readdir RPC size). This wastes some buffer space
   2407   1.85      fvdl 		 * but can save up to 50% in RPC calls.
   2408   1.85      fvdl 		 */
   2409   1.85      fvdl 		if (nrpcs > 0 && uiop->uio_resid < (nmp->nm_readdirsize / 2)) {
   2410   1.85      fvdl 			bigenough = 0;
   2411   1.85      fvdl 			break;
   2412   1.85      fvdl 		}
   2413    1.1       cgd 		nfsstats.rpccnt[NFSPROC_READDIR]++;
   2414  1.165  drochner 		nfsm_reqhead(dnp, NFSPROC_READDIR, NFSX_FH(v3) +
   2415   1.59      fvdl 			NFSX_READDIR(v3));
   2416  1.165  drochner 		nfsm_fhtom(dnp, v3);
   2417  1.200  christos #ifndef NFS_V2_ONLY
   2418   1.59      fvdl 		if (v3) {
   2419   1.59      fvdl 			nfsm_build(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
   2420   1.81      fvdl 			if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE) {
   2421   1.81      fvdl 				txdr_swapcookie3(uiop->uio_offset, tl);
   2422   1.81      fvdl 			} else {
   2423   1.81      fvdl 				txdr_cookie3(uiop->uio_offset, tl);
   2424   1.81      fvdl 			}
   2425   1.81      fvdl 			tl += 2;
   2426   1.59      fvdl 			*tl++ = dnp->n_cookieverf.nfsuquad[0];
   2427   1.59      fvdl 			*tl++ = dnp->n_cookieverf.nfsuquad[1];
   2428  1.200  christos 		} else
   2429  1.200  christos #endif
   2430  1.200  christos 		{
   2431   1.59      fvdl 			nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   2432   1.81      fvdl 			*tl++ = txdr_unsigned(uiop->uio_offset);
   2433   1.59      fvdl 		}
   2434   1.59      fvdl 		*tl = txdr_unsigned(nmp->nm_readdirsize);
   2435  1.231      yamt 		nfsm_request(dnp, NFSPROC_READDIR, curlwp, cred);
   2436   1.85      fvdl 		nrpcs++;
   2437  1.200  christos #ifndef NFS_V2_ONLY
   2438   1.59      fvdl 		if (v3) {
   2439  1.153      yamt 			nfsm_postop_attr(vp, attrflag, 0);
   2440   1.59      fvdl 			if (!error) {
   2441   1.59      fvdl 				nfsm_dissect(tl, u_int32_t *,
   2442   1.59      fvdl 				    2 * NFSX_UNSIGNED);
   2443   1.59      fvdl 				dnp->n_cookieverf.nfsuquad[0] = *tl++;
   2444   1.59      fvdl 				dnp->n_cookieverf.nfsuquad[1] = *tl;
   2445   1.59      fvdl 			} else {
   2446   1.59      fvdl 				m_freem(mrep);
   2447   1.59      fvdl 				goto nfsmout;
   2448   1.59      fvdl 			}
   2449   1.59      fvdl 		}
   2450  1.200  christos #endif
   2451   1.53       cgd 		nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2452    1.1       cgd 		more_dirs = fxdr_unsigned(int, *tl);
   2453  1.220     perry 
   2454    1.1       cgd 		/* loop thru the dir entries, doctoring them to 4bsd form */
   2455   1.59      fvdl 		while (more_dirs && bigenough) {
   2456  1.200  christos #ifndef NFS_V2_ONLY
   2457   1.59      fvdl 			if (v3) {
   2458   1.59      fvdl 				nfsm_dissect(tl, u_int32_t *,
   2459   1.59      fvdl 				    3 * NFSX_UNSIGNED);
   2460   1.98      fair 				fileno = fxdr_hyper(tl);
   2461   1.59      fvdl 				len = fxdr_unsigned(int, *(tl + 2));
   2462  1.200  christos 			} else
   2463  1.200  christos #endif
   2464  1.200  christos 			{
   2465   1.59      fvdl 				nfsm_dissect(tl, u_int32_t *,
   2466   1.59      fvdl 				    2 * NFSX_UNSIGNED);
   2467   1.59      fvdl 				fileno = fxdr_unsigned(u_quad_t, *tl++);
   2468   1.59      fvdl 				len = fxdr_unsigned(int, *tl);
   2469   1.59      fvdl 			}
   2470    1.1       cgd 			if (len <= 0 || len > NFS_MAXNAMLEN) {
   2471    1.1       cgd 				error = EBADRPC;
   2472    1.1       cgd 				m_freem(mrep);
   2473    1.1       cgd 				goto nfsmout;
   2474    1.1       cgd 			}
   2475  1.225  christos 			/* for cookie stashing */
   2476  1.225  christos 			reclen = _DIRENT_RECLEN(dp, len) + 2 * sizeof(off_t);
   2477   1.81      fvdl 			left = NFS_DIRFRAGSIZ - blksiz;
   2478   1.86   thorpej 			if (reclen > left) {
   2479  1.211      yamt 				memset(uiop->uio_iov->iov_base, 0, left);
   2480   1.59      fvdl 				dp->d_reclen += left;
   2481  1.225  christos 				UIO_ADVANCE(uiop, left);
   2482   1.59      fvdl 				blksiz = 0;
   2483   1.81      fvdl 				NFS_STASHCOOKIE(dp, uiop->uio_offset);
   2484   1.59      fvdl 			}
   2485   1.86   thorpej 			if (reclen > uiop->uio_resid)
   2486   1.59      fvdl 				bigenough = 0;
   2487   1.59      fvdl 			if (bigenough) {
   2488  1.225  christos 				int tlen;
   2489  1.225  christos 
   2490   1.59      fvdl 				dp = (struct dirent *)uiop->uio_iov->iov_base;
   2491  1.225  christos 				dp->d_fileno = fileno;
   2492   1.59      fvdl 				dp->d_namlen = len;
   2493   1.86   thorpej 				dp->d_reclen = reclen;
   2494   1.59      fvdl 				dp->d_type = DT_UNKNOWN;
   2495  1.225  christos 				blksiz += reclen;
   2496   1.81      fvdl 				if (blksiz == NFS_DIRFRAGSIZ)
   2497   1.59      fvdl 					blksiz = 0;
   2498  1.225  christos 				UIO_ADVANCE(uiop, DIRHDSIZ);
   2499   1.59      fvdl 				nfsm_mtouio(uiop, len);
   2500  1.225  christos 				tlen = reclen - (DIRHDSIZ + len);
   2501  1.225  christos 				(void)memset(uiop->uio_iov->iov_base, 0, tlen);
   2502  1.225  christos 				UIO_ADVANCE(uiop, tlen);
   2503   1.59      fvdl 			} else
   2504   1.59      fvdl 				nfsm_adv(nfsm_rndup(len));
   2505  1.200  christos #ifndef NFS_V2_ONLY
   2506   1.59      fvdl 			if (v3) {
   2507   1.59      fvdl 				nfsm_dissect(tl, u_int32_t *,
   2508   1.59      fvdl 				    3 * NFSX_UNSIGNED);
   2509  1.220     perry 			} else
   2510  1.200  christos #endif
   2511  1.200  christos 			{
   2512   1.59      fvdl 				nfsm_dissect(tl, u_int32_t *,
   2513   1.59      fvdl 				    2 * NFSX_UNSIGNED);
   2514    1.1       cgd 			}
   2515   1.59      fvdl 			if (bigenough) {
   2516  1.200  christos #ifndef NFS_V2_ONLY
   2517   1.81      fvdl 				if (v3) {
   2518   1.81      fvdl 					if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE)
   2519   1.81      fvdl 						uiop->uio_offset =
   2520   1.81      fvdl 						    fxdr_swapcookie3(tl);
   2521   1.81      fvdl 					else
   2522  1.220     perry 						uiop->uio_offset =
   2523   1.81      fvdl 						    fxdr_cookie3(tl);
   2524   1.81      fvdl 				}
   2525  1.200  christos 				else
   2526  1.200  christos #endif
   2527  1.200  christos 				{
   2528   1.81      fvdl 					uiop->uio_offset =
   2529   1.81      fvdl 					    fxdr_unsigned(off_t, *tl);
   2530   1.81      fvdl 				}
   2531   1.81      fvdl 				NFS_STASHCOOKIE(dp, uiop->uio_offset);
   2532   1.81      fvdl 			}
   2533   1.81      fvdl 			if (v3)
   2534   1.59      fvdl 				tl += 2;
   2535   1.59      fvdl 			else
   2536   1.59      fvdl 				tl++;
   2537    1.1       cgd 			more_dirs = fxdr_unsigned(int, *tl);
   2538    1.1       cgd 		}
   2539    1.1       cgd 		/*
   2540    1.1       cgd 		 * If at end of rpc data, get the eof boolean
   2541    1.1       cgd 		 */
   2542    1.1       cgd 		if (!more_dirs) {
   2543   1.53       cgd 			nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2544    1.1       cgd 			more_dirs = (fxdr_unsigned(int, *tl) == 0);
   2545  1.219      yamt 
   2546  1.219      yamt 			/*
   2547  1.219      yamt 			 * kludge: if we got no entries, treat it as EOF.
   2548  1.219      yamt 			 * some server sometimes send a reply without any
   2549  1.219      yamt 			 * entries or EOF.
   2550  1.219      yamt 			 * although it might mean the server has very long name,
   2551  1.219      yamt 			 * we can't handle such entries anyway.
   2552  1.219      yamt 			 */
   2553  1.219      yamt 
   2554  1.219      yamt 			if (uiop->uio_resid >= NFS_DIRBLKSIZ)
   2555  1.219      yamt 				more_dirs = 0;
   2556    1.1       cgd 		}
   2557    1.1       cgd 		m_freem(mrep);
   2558    1.1       cgd 	}
   2559    1.1       cgd 	/*
   2560   1.81      fvdl 	 * Fill last record, iff any, out to a multiple of NFS_DIRFRAGSIZ
   2561    1.1       cgd 	 * by increasing d_reclen for the last record.
   2562    1.1       cgd 	 */
   2563   1.59      fvdl 	if (blksiz > 0) {
   2564   1.81      fvdl 		left = NFS_DIRFRAGSIZ - blksiz;
   2565  1.211      yamt 		memset(uiop->uio_iov->iov_base, 0, left);
   2566   1.59      fvdl 		dp->d_reclen += left;
   2567   1.81      fvdl 		NFS_STASHCOOKIE(dp, uiop->uio_offset);
   2568  1.225  christos 		UIO_ADVANCE(uiop, left);
   2569   1.59      fvdl 	}
   2570   1.59      fvdl 
   2571   1.59      fvdl 	/*
   2572   1.59      fvdl 	 * We are now either at the end of the directory or have filled the
   2573   1.59      fvdl 	 * block.
   2574   1.59      fvdl 	 */
   2575  1.218      yamt 	if (bigenough) {
   2576   1.59      fvdl 		dnp->n_direofoffset = uiop->uio_offset;
   2577  1.218      yamt 		dnp->n_flag |= NEOFVALID;
   2578  1.218      yamt 	}
   2579    1.1       cgd nfsmout:
   2580    1.1       cgd 	return (error);
   2581    1.1       cgd }
   2582    1.1       cgd 
   2583  1.200  christos #ifndef NFS_V2_ONLY
   2584   1.32   mycroft /*
   2585   1.59      fvdl  * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
   2586   1.32   mycroft  */
   2587   1.32   mycroft int
   2588  1.272       dsl nfs_readdirplusrpc(struct vnode *vp, struct uio *uiop, kauth_cred_t cred)
   2589   1.32   mycroft {
   2590  1.111  augustss 	int len, left;
   2591  1.111  augustss 	struct dirent *dp = NULL;
   2592  1.111  augustss 	u_int32_t *tl;
   2593  1.252  christos 	char *cp;
   2594  1.111  augustss 	int32_t t1, t2;
   2595   1.79      fvdl 	struct vnode *newvp;
   2596  1.252  christos 	char *bpos, *dpos, *cp2;
   2597  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2598   1.32   mycroft 	struct nameidata nami, *ndp = &nami;
   2599   1.32   mycroft 	struct componentname *cnp = &ndp->ni_cnd;
   2600   1.59      fvdl 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
   2601   1.59      fvdl 	struct nfsnode *dnp = VTONFS(vp), *np;
   2602   1.59      fvdl 	nfsfh_t *fhp;
   2603   1.59      fvdl 	u_quad_t fileno;
   2604  1.225  christos 	int error = 0, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
   2605   1.86   thorpej 	int attrflag, fhsize, nrpcs = 0, reclen;
   2606   1.79      fvdl 	struct nfs_fattr fattr, *fp;
   2607   1.59      fvdl 
   2608   1.81      fvdl #ifdef DIAGNOSTIC
   2609  1.219      yamt 	if (uiop->uio_iovcnt != 1 || uiop->uio_resid != NFS_DIRBLKSIZ)
   2610   1.59      fvdl 		panic("nfs readdirplusrpc bad uio");
   2611   1.59      fvdl #endif
   2612   1.32   mycroft 	ndp->ni_dvp = vp;
   2613   1.32   mycroft 	newvp = NULLVP;
   2614   1.59      fvdl 
   2615   1.59      fvdl 	/*
   2616   1.59      fvdl 	 * Loop around doing readdir rpc's of size nm_readdirsize
   2617   1.81      fvdl 	 * truncated to a multiple of NFS_DIRFRAGSIZ.
   2618   1.32   mycroft 	 * The stopping criteria is EOF or buffer full.
   2619   1.32   mycroft 	 */
   2620   1.59      fvdl 	while (more_dirs && bigenough) {
   2621   1.85      fvdl 		if (nrpcs > 0 && uiop->uio_resid < (nmp->nm_readdirsize / 2)) {
   2622   1.85      fvdl 			bigenough = 0;
   2623   1.85      fvdl 			break;
   2624   1.85      fvdl 		}
   2625   1.59      fvdl 		nfsstats.rpccnt[NFSPROC_READDIRPLUS]++;
   2626  1.165  drochner 		nfsm_reqhead(dnp, NFSPROC_READDIRPLUS,
   2627   1.59      fvdl 			NFSX_FH(1) + 6 * NFSX_UNSIGNED);
   2628  1.165  drochner 		nfsm_fhtom(dnp, 1);
   2629   1.59      fvdl  		nfsm_build(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
   2630   1.81      fvdl 		if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE) {
   2631   1.81      fvdl 			txdr_swapcookie3(uiop->uio_offset, tl);
   2632   1.81      fvdl 		} else {
   2633   1.81      fvdl 			txdr_cookie3(uiop->uio_offset, tl);
   2634   1.81      fvdl 		}
   2635   1.81      fvdl 		tl += 2;
   2636   1.59      fvdl 		*tl++ = dnp->n_cookieverf.nfsuquad[0];
   2637   1.59      fvdl 		*tl++ = dnp->n_cookieverf.nfsuquad[1];
   2638   1.59      fvdl 		*tl++ = txdr_unsigned(nmp->nm_readdirsize);
   2639   1.59      fvdl 		*tl = txdr_unsigned(nmp->nm_rsize);
   2640  1.231      yamt 		nfsm_request(dnp, NFSPROC_READDIRPLUS, curlwp, cred);
   2641  1.153      yamt 		nfsm_postop_attr(vp, attrflag, 0);
   2642   1.59      fvdl 		if (error) {
   2643   1.59      fvdl 			m_freem(mrep);
   2644   1.59      fvdl 			goto nfsmout;
   2645   1.59      fvdl 		}
   2646   1.85      fvdl 		nrpcs++;
   2647   1.59      fvdl 		nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
   2648   1.59      fvdl 		dnp->n_cookieverf.nfsuquad[0] = *tl++;
   2649   1.59      fvdl 		dnp->n_cookieverf.nfsuquad[1] = *tl++;
   2650   1.32   mycroft 		more_dirs = fxdr_unsigned(int, *tl);
   2651  1.220     perry 
   2652   1.32   mycroft 		/* loop thru the dir entries, doctoring them to 4bsd form */
   2653   1.32   mycroft 		while (more_dirs && bigenough) {
   2654   1.59      fvdl 			nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
   2655   1.98      fair 			fileno = fxdr_hyper(tl);
   2656   1.59      fvdl 			len = fxdr_unsigned(int, *(tl + 2));
   2657   1.32   mycroft 			if (len <= 0 || len > NFS_MAXNAMLEN) {
   2658   1.32   mycroft 				error = EBADRPC;
   2659   1.32   mycroft 				m_freem(mrep);
   2660   1.32   mycroft 				goto nfsmout;
   2661   1.32   mycroft 			}
   2662  1.225  christos 			/* for cookie stashing */
   2663  1.226      yamt 			reclen = _DIRENT_RECLEN(dp, len) + 2 * sizeof(off_t);
   2664   1.81      fvdl 			left = NFS_DIRFRAGSIZ - blksiz;
   2665   1.86   thorpej 			if (reclen > left) {
   2666   1.86   thorpej 				/*
   2667   1.86   thorpej 				 * DIRFRAGSIZ is aligned, no need to align
   2668   1.86   thorpej 				 * again here.
   2669   1.86   thorpej 				 */
   2670  1.211      yamt 				memset(uiop->uio_iov->iov_base, 0, left);
   2671   1.59      fvdl 				dp->d_reclen += left;
   2672  1.225  christos 				UIO_ADVANCE(uiop, left);
   2673   1.81      fvdl 				NFS_STASHCOOKIE(dp, uiop->uio_offset);
   2674   1.59      fvdl 				blksiz = 0;
   2675   1.59      fvdl 			}
   2676   1.86   thorpej 			if (reclen > uiop->uio_resid)
   2677   1.32   mycroft 				bigenough = 0;
   2678   1.59      fvdl 			if (bigenough) {
   2679  1.225  christos 				int tlen;
   2680  1.225  christos 
   2681   1.32   mycroft 				dp = (struct dirent *)uiop->uio_iov->iov_base;
   2682  1.225  christos 				dp->d_fileno = fileno;
   2683   1.32   mycroft 				dp->d_namlen = len;
   2684   1.86   thorpej 				dp->d_reclen = reclen;
   2685   1.59      fvdl 				dp->d_type = DT_UNKNOWN;
   2686  1.225  christos 				blksiz += reclen;
   2687   1.81      fvdl 				if (blksiz == NFS_DIRFRAGSIZ)
   2688   1.59      fvdl 					blksiz = 0;
   2689  1.225  christos 				UIO_ADVANCE(uiop, DIRHDSIZ);
   2690   1.32   mycroft 				nfsm_mtouio(uiop, len);
   2691  1.225  christos 				tlen = reclen - (DIRHDSIZ + len);
   2692  1.225  christos 				(void)memset(uiop->uio_iov->iov_base, 0, tlen);
   2693  1.225  christos 				UIO_ADVANCE(uiop, tlen);
   2694  1.225  christos 				cnp->cn_nameptr = dp->d_name;
   2695  1.225  christos 				cnp->cn_namelen = dp->d_namlen;
   2696   1.59      fvdl 			} else
   2697   1.59      fvdl 				nfsm_adv(nfsm_rndup(len));
   2698   1.59      fvdl 			nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
   2699   1.59      fvdl 			if (bigenough) {
   2700   1.81      fvdl 				if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE)
   2701   1.81      fvdl 					uiop->uio_offset =
   2702   1.81      fvdl 						fxdr_swapcookie3(tl);
   2703   1.81      fvdl 				else
   2704   1.81      fvdl 					uiop->uio_offset =
   2705   1.81      fvdl 						fxdr_cookie3(tl);
   2706   1.81      fvdl 				NFS_STASHCOOKIE(dp, uiop->uio_offset);
   2707   1.81      fvdl 			}
   2708   1.81      fvdl 			tl += 2;
   2709   1.59      fvdl 
   2710   1.59      fvdl 			/*
   2711   1.59      fvdl 			 * Since the attributes are before the file handle
   2712   1.59      fvdl 			 * (sigh), we must skip over the attributes and then
   2713   1.59      fvdl 			 * come back and get them.
   2714   1.59      fvdl 			 */
   2715   1.59      fvdl 			attrflag = fxdr_unsigned(int, *tl);
   2716   1.59      fvdl 			if (attrflag) {
   2717   1.79      fvdl 			    nfsm_dissect(fp, struct nfs_fattr *, NFSX_V3FATTR);
   2718   1.97     perry 			    memcpy(&fattr, fp, NFSX_V3FATTR);
   2719   1.59      fvdl 			    nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2720   1.59      fvdl 			    doit = fxdr_unsigned(int, *tl);
   2721   1.59      fvdl 			    if (doit) {
   2722   1.59      fvdl 				nfsm_getfh(fhp, fhsize, 1);
   2723   1.59      fvdl 				if (NFS_CMPFH(dnp, fhp, fhsize)) {
   2724  1.282     pooka 				    vref(vp);
   2725   1.59      fvdl 				    newvp = vp;
   2726   1.59      fvdl 				    np = dnp;
   2727   1.59      fvdl 				} else {
   2728  1.191      yamt 				    error = nfs_nget1(vp->v_mount, fhp,
   2729  1.191      yamt 					fhsize, &np, LK_NOWAIT);
   2730   1.79      fvdl 				    if (!error)
   2731   1.59      fvdl 					newvp = NFSTOV(np);
   2732   1.59      fvdl 				}
   2733   1.79      fvdl 				if (!error) {
   2734  1.153      yamt 				    nfs_loadattrcache(&newvp, &fattr, 0, 0);
   2735  1.208      yamt 				    if (bigenough) {
   2736  1.208      yamt 					dp->d_type =
   2737  1.208      yamt 					   IFTODT(VTTOIF(np->n_vattr->va_type));
   2738  1.312  christos 					ndp->ni_vp = newvp;
   2739  1.312  christos 					nfs_cache_enter(ndp->ni_dvp,
   2740  1.312  christos 					    ndp->ni_vp, cnp);
   2741  1.208      yamt 				    }
   2742   1.79      fvdl 				}
   2743  1.209      yamt 				error = 0;
   2744   1.79      fvdl 			   }
   2745   1.32   mycroft 			} else {
   2746   1.59      fvdl 			    /* Just skip over the file handle */
   2747   1.59      fvdl 			    nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2748   1.59      fvdl 			    i = fxdr_unsigned(int, *tl);
   2749   1.59      fvdl 			    nfsm_adv(nfsm_rndup(i));
   2750   1.32   mycroft 			}
   2751   1.32   mycroft 			if (newvp != NULLVP) {
   2752  1.220     perry 			    if (newvp == vp)
   2753  1.220     perry 				vrele(newvp);
   2754  1.220     perry 			    else
   2755  1.151       tls 				vput(newvp);
   2756   1.59      fvdl 			    newvp = NULLVP;
   2757   1.32   mycroft 			}
   2758   1.59      fvdl 			nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2759   1.32   mycroft 			more_dirs = fxdr_unsigned(int, *tl);
   2760   1.32   mycroft 		}
   2761   1.32   mycroft 		/*
   2762   1.32   mycroft 		 * If at end of rpc data, get the eof boolean
   2763   1.32   mycroft 		 */
   2764   1.32   mycroft 		if (!more_dirs) {
   2765   1.53       cgd 			nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2766   1.32   mycroft 			more_dirs = (fxdr_unsigned(int, *tl) == 0);
   2767  1.219      yamt 
   2768  1.219      yamt 			/*
   2769  1.219      yamt 			 * kludge: see a comment in nfs_readdirrpc.
   2770  1.219      yamt 			 */
   2771  1.219      yamt 
   2772  1.219      yamt 			if (uiop->uio_resid >= NFS_DIRBLKSIZ)
   2773  1.219      yamt 				more_dirs = 0;
   2774   1.32   mycroft 		}
   2775   1.32   mycroft 		m_freem(mrep);
   2776   1.32   mycroft 	}
   2777   1.32   mycroft 	/*
   2778   1.81      fvdl 	 * Fill last record, iff any, out to a multiple of NFS_DIRFRAGSIZ
   2779   1.32   mycroft 	 * by increasing d_reclen for the last record.
   2780   1.32   mycroft 	 */
   2781   1.59      fvdl 	if (blksiz > 0) {
   2782   1.81      fvdl 		left = NFS_DIRFRAGSIZ - blksiz;
   2783  1.211      yamt 		memset(uiop->uio_iov->iov_base, 0, left);
   2784   1.59      fvdl 		dp->d_reclen += left;
   2785   1.81      fvdl 		NFS_STASHCOOKIE(dp, uiop->uio_offset);
   2786  1.225  christos 		UIO_ADVANCE(uiop, left);
   2787   1.59      fvdl 	}
   2788   1.59      fvdl 
   2789   1.59      fvdl 	/*
   2790   1.59      fvdl 	 * We are now either at the end of the directory or have filled the
   2791   1.59      fvdl 	 * block.
   2792   1.59      fvdl 	 */
   2793  1.218      yamt 	if (bigenough) {
   2794   1.59      fvdl 		dnp->n_direofoffset = uiop->uio_offset;
   2795  1.218      yamt 		dnp->n_flag |= NEOFVALID;
   2796  1.218      yamt 	}
   2797   1.32   mycroft nfsmout:
   2798  1.128      fvdl 	if (newvp != NULLVP) {
   2799  1.151       tls 		if(newvp == vp)
   2800  1.151       tls 		    vrele(newvp);
   2801  1.151       tls 		else
   2802  1.151       tls 		    vput(newvp);
   2803  1.128      fvdl 	}
   2804   1.32   mycroft 	return (error);
   2805   1.32   mycroft }
   2806  1.200  christos #endif
   2807  1.200  christos 
   2808    1.1       cgd /*
   2809    1.1       cgd  * Silly rename. To make the NFS filesystem that is stateless look a little
   2810    1.1       cgd  * more like the "ufs" a remove of an active vnode is translated to a rename
   2811    1.1       cgd  * to a funny looking filename that is removed by nfs_inactive on the
   2812    1.1       cgd  * nfsnode. There is the potential for another process on a different client
   2813    1.1       cgd  * to create the same funny name between the nfs_lookitup() fails and the
   2814    1.1       cgd  * nfs_rename() completes, but...
   2815    1.1       cgd  */
   2816   1.32   mycroft int
   2817  1.273       dsl nfs_sillyrename(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, bool dolink)
   2818    1.1       cgd {
   2819  1.111  augustss 	struct sillyrename *sp;
   2820   1.59      fvdl 	struct nfsnode *np;
   2821    1.1       cgd 	int error;
   2822  1.280       apb 	pid_t pid;
   2823    1.1       cgd 
   2824   1.32   mycroft 	cache_purge(dvp);
   2825   1.32   mycroft 	np = VTONFS(vp);
   2826   1.59      fvdl #ifndef DIAGNOSTIC
   2827   1.59      fvdl 	if (vp->v_type == VDIR)
   2828   1.59      fvdl 		panic("nfs: sillyrename dir");
   2829   1.59      fvdl #endif
   2830  1.264      yamt 	sp = kmem_alloc(sizeof(*sp), KM_SLEEP);
   2831  1.236      elad 	sp->s_cred = kauth_cred_dup(cnp->cn_cred);
   2832   1.32   mycroft 	sp->s_dvp = dvp;
   2833  1.282     pooka 	vref(dvp);
   2834    1.1       cgd 
   2835    1.1       cgd 	/* Fudge together a funny name */
   2836  1.261     pooka 	pid = curlwp->l_proc->p_pid;
   2837   1.97     perry 	memcpy(sp->s_name, ".nfsAxxxx4.4", 13);
   2838    1.1       cgd 	sp->s_namlen = 12;
   2839  1.221  christos 	sp->s_name[8] = hexdigits[pid & 0xf];
   2840  1.221  christos 	sp->s_name[7] = hexdigits[(pid >> 4) & 0xf];
   2841  1.221  christos 	sp->s_name[6] = hexdigits[(pid >> 8) & 0xf];
   2842  1.221  christos 	sp->s_name[5] = hexdigits[(pid >> 12) & 0xf];
   2843    1.1       cgd 
   2844    1.1       cgd 	/* Try lookitups until we get one that isn't there */
   2845   1.59      fvdl 	while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
   2846  1.261     pooka 		curlwp, (struct nfsnode **)0) == 0) {
   2847    1.1       cgd 		sp->s_name[4]++;
   2848    1.1       cgd 		if (sp->s_name[4] > 'z') {
   2849    1.1       cgd 			error = EINVAL;
   2850    1.1       cgd 			goto bad;
   2851    1.1       cgd 		}
   2852    1.1       cgd 	}
   2853  1.239      yamt 	if (dolink) {
   2854  1.239      yamt 		error = nfs_linkrpc(dvp, vp, sp->s_name, sp->s_namlen,
   2855  1.261     pooka 		    sp->s_cred, curlwp);
   2856  1.239      yamt 		/*
   2857  1.239      yamt 		 * nfs_request maps NFSERR_NOTSUPP to ENOTSUP.
   2858  1.239      yamt 		 */
   2859  1.239      yamt 		if (error == ENOTSUP) {
   2860  1.239      yamt 			error = nfs_renameit(dvp, cnp, sp);
   2861  1.239      yamt 		}
   2862  1.239      yamt 	} else {
   2863  1.239      yamt 		error = nfs_renameit(dvp, cnp, sp);
   2864  1.239      yamt 	}
   2865   1.59      fvdl 	if (error)
   2866    1.1       cgd 		goto bad;
   2867   1.59      fvdl 	error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
   2868  1.261     pooka 		curlwp, &np);
   2869    1.1       cgd 	np->n_sillyrename = sp;
   2870    1.1       cgd 	return (0);
   2871    1.1       cgd bad:
   2872    1.1       cgd 	vrele(sp->s_dvp);
   2873  1.236      elad 	kauth_cred_free(sp->s_cred);
   2874  1.264      yamt 	kmem_free(sp, sizeof(*sp));
   2875    1.1       cgd 	return (error);
   2876    1.1       cgd }
   2877    1.1       cgd 
   2878    1.1       cgd /*
   2879   1.59      fvdl  * Look up a file name and optionally either update the file handle or
   2880   1.59      fvdl  * allocate an nfsnode, depending on the value of npp.
   2881   1.59      fvdl  * npp == NULL	--> just do the lookup
   2882   1.59      fvdl  * *npp == NULL --> allocate a new nfsnode and make sure attributes are
   2883   1.59      fvdl  *			handled too
   2884   1.59      fvdl  * *npp != NULL --> update the file handle in the vnode
   2885    1.1       cgd  */
   2886   1.32   mycroft int
   2887  1.272       dsl nfs_lookitup(struct vnode *dvp, const char *name, int len, kauth_cred_t cred, struct lwp *l, struct nfsnode **npp)
   2888    1.1       cgd {
   2889  1.111  augustss 	u_int32_t *tl;
   2890  1.252  christos 	char *cp;
   2891  1.111  augustss 	int32_t t1, t2;
   2892   1.59      fvdl 	struct vnode *newvp = (struct vnode *)0;
   2893   1.59      fvdl 	struct nfsnode *np, *dnp = VTONFS(dvp);
   2894  1.252  christos 	char *bpos, *dpos, *cp2;
   2895  1.305   hannken 	int error = 0, ofhlen, fhlen;
   2896  1.200  christos #ifndef NFS_V2_ONLY
   2897  1.200  christos 	int attrflag;
   2898  1.200  christos #endif
   2899  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2900  1.305   hannken 	nfsfh_t *ofhp, *nfhp;
   2901  1.119     bjh21 	const int v3 = NFS_ISV3(dvp);
   2902    1.1       cgd 
   2903    1.1       cgd 	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
   2904  1.165  drochner 	nfsm_reqhead(dnp, NFSPROC_LOOKUP,
   2905   1.59      fvdl 		NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
   2906  1.165  drochner 	nfsm_fhtom(dnp, v3);
   2907   1.59      fvdl 	nfsm_strtom(name, len, NFS_MAXNAMLEN);
   2908  1.230  christos 	nfsm_request(dnp, NFSPROC_LOOKUP, l, cred);
   2909   1.59      fvdl 	if (npp && !error) {
   2910   1.59      fvdl 		nfsm_getfh(nfhp, fhlen, v3);
   2911   1.59      fvdl 		if (*npp) {
   2912   1.59      fvdl 		    np = *npp;
   2913  1.305   hannken 		    newvp = NFSTOV(np);
   2914  1.305   hannken 		    ofhlen = np->n_fhsize;
   2915  1.305   hannken 		    ofhp = kmem_alloc(ofhlen, KM_SLEEP);
   2916  1.305   hannken 		    memcpy(ofhp, np->n_fhp, ofhlen);
   2917  1.305   hannken 		    error = vcache_rekey_enter(newvp->v_mount, newvp,
   2918  1.305   hannken 			ofhp, ofhlen, nfhp, fhlen);
   2919  1.305   hannken 		    if (error) {
   2920  1.305   hannken 			kmem_free(ofhp, ofhlen);
   2921  1.305   hannken 			m_freem(mrep);
   2922  1.305   hannken 			return error;
   2923  1.305   hannken 		    }
   2924   1.59      fvdl 		    if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
   2925  1.264      yamt 			kmem_free(np->n_fhp, np->n_fhsize);
   2926   1.59      fvdl 			np->n_fhp = &np->n_fh;
   2927  1.235  christos 		    }
   2928  1.235  christos #if NFS_SMALLFH < NFSX_V3FHMAX
   2929  1.264      yamt 		    else if (np->n_fhsize <= NFS_SMALLFH && fhlen > NFS_SMALLFH)
   2930  1.264      yamt 			np->n_fhp = kmem_alloc(fhlen, KM_SLEEP);
   2931  1.235  christos #endif
   2932  1.264      yamt 		    memcpy(np->n_fhp, nfhp, fhlen);
   2933   1.59      fvdl 		    np->n_fhsize = fhlen;
   2934  1.305   hannken 		    vcache_rekey_exit(newvp->v_mount, newvp,
   2935  1.305   hannken 			ofhp, ofhlen, np->n_fhp, fhlen);
   2936  1.305   hannken 		    kmem_free(ofhp, ofhlen);
   2937   1.59      fvdl 		} else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
   2938  1.282     pooka 		    vref(dvp);
   2939   1.59      fvdl 		    newvp = dvp;
   2940  1.194      yamt 		    np = dnp;
   2941   1.59      fvdl 		} else {
   2942  1.175      fvdl 		    error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np);
   2943   1.59      fvdl 		    if (error) {
   2944   1.59      fvdl 			m_freem(mrep);
   2945   1.59      fvdl 			return (error);
   2946   1.59      fvdl 		    }
   2947   1.59      fvdl 		    newvp = NFSTOV(np);
   2948   1.59      fvdl 		}
   2949  1.200  christos #ifndef NFS_V2_ONLY
   2950   1.59      fvdl 		if (v3) {
   2951  1.153      yamt 			nfsm_postop_attr(newvp, attrflag, 0);
   2952   1.59      fvdl 			if (!attrflag && *npp == NULL) {
   2953   1.59      fvdl 				m_freem(mrep);
   2954  1.128      fvdl 				vput(newvp);
   2955   1.59      fvdl 				return (ENOENT);
   2956   1.59      fvdl 			}
   2957   1.59      fvdl 		} else
   2958  1.200  christos #endif
   2959  1.153      yamt 			nfsm_loadattr(newvp, (struct vattr *)0, 0);
   2960   1.59      fvdl 	}
   2961   1.59      fvdl 	nfsm_reqdone;
   2962   1.59      fvdl 	if (npp && *npp == NULL) {
   2963   1.59      fvdl 		if (error) {
   2964   1.59      fvdl 			if (newvp)
   2965  1.128      fvdl 				vput(newvp);
   2966   1.59      fvdl 		} else
   2967   1.59      fvdl 			*npp = np;
   2968   1.32   mycroft 	}
   2969   1.59      fvdl 	return (error);
   2970   1.59      fvdl }
   2971   1.59      fvdl 
   2972  1.200  christos #ifndef NFS_V2_ONLY
   2973   1.59      fvdl /*
   2974   1.59      fvdl  * Nfs Version 3 commit rpc
   2975   1.59      fvdl  */
   2976   1.59      fvdl int
   2977  1.272       dsl nfs_commit(struct vnode *vp, off_t offset, uint32_t cnt, struct lwp *l)
   2978   1.59      fvdl {
   2979  1.252  christos 	char *cp;
   2980  1.111  augustss 	u_int32_t *tl;
   2981  1.111  augustss 	int32_t t1, t2;
   2982  1.111  augustss 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
   2983  1.252  christos 	char *bpos, *dpos, *cp2;
   2984   1.59      fvdl 	int error = 0, wccflag = NFSV3_WCCRATTR;
   2985  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   2986  1.165  drochner 	struct nfsnode *np;
   2987  1.120      fvdl 
   2988  1.166      yamt 	KASSERT(NFS_ISV3(vp));
   2989  1.166      yamt 
   2990  1.160      yamt #ifdef NFS_DEBUG_COMMIT
   2991  1.120      fvdl 	printf("commit %lu - %lu\n", (unsigned long)offset,
   2992  1.120      fvdl 	    (unsigned long)(offset + cnt));
   2993  1.120      fvdl #endif
   2994  1.220     perry 
   2995  1.254      yamt 	mutex_enter(&nmp->nm_lock);
   2996  1.166      yamt 	if ((nmp->nm_iflag & NFSMNT_HASWRITEVERF) == 0) {
   2997  1.254      yamt 		mutex_exit(&nmp->nm_lock);
   2998   1.59      fvdl 		return (0);
   2999  1.166      yamt 	}
   3000  1.254      yamt 	mutex_exit(&nmp->nm_lock);
   3001   1.59      fvdl 	nfsstats.rpccnt[NFSPROC_COMMIT]++;
   3002  1.165  drochner 	np = VTONFS(vp);
   3003  1.165  drochner 	nfsm_reqhead(np, NFSPROC_COMMIT, NFSX_FH(1));
   3004  1.165  drochner 	nfsm_fhtom(np, 1);
   3005   1.59      fvdl 	nfsm_build(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
   3006   1.98      fair 	txdr_hyper(offset, tl);
   3007   1.59      fvdl 	tl += 2;
   3008   1.59      fvdl 	*tl = txdr_unsigned(cnt);
   3009  1.230  christos 	nfsm_request(np, NFSPROC_COMMIT, l, np->n_wcred);
   3010  1.251   thorpej 	nfsm_wcc_data(vp, wccflag, NAC_NOTRUNC, false);
   3011   1.59      fvdl 	if (!error) {
   3012   1.59      fvdl 		nfsm_dissect(tl, u_int32_t *, NFSX_V3WRITEVERF);
   3013  1.254      yamt 		mutex_enter(&nmp->nm_lock);
   3014  1.166      yamt 		if ((nmp->nm_iflag & NFSMNT_STALEWRITEVERF) ||
   3015  1.166      yamt 		    memcmp(nmp->nm_writeverf, tl, NFSX_V3WRITEVERF)) {
   3016  1.166      yamt 			memcpy(nmp->nm_writeverf, tl, NFSX_V3WRITEVERF);
   3017   1.59      fvdl 			error = NFSERR_STALEWRITEVERF;
   3018  1.166      yamt 			nmp->nm_iflag |= NFSMNT_STALEWRITEVERF;
   3019   1.59      fvdl 		}
   3020  1.254      yamt 		mutex_exit(&nmp->nm_lock);
   3021    1.1       cgd 	}
   3022    1.1       cgd 	nfsm_reqdone;
   3023    1.1       cgd 	return (error);
   3024    1.1       cgd }
   3025  1.200  christos #endif
   3026    1.1       cgd 
   3027    1.1       cgd /*
   3028    1.1       cgd  * Kludge City..
   3029    1.1       cgd  * - make nfs_bmap() essentially a no-op that does no translation
   3030   1.59      fvdl  * - do nfs_strategy() by doing I/O with nfs_readrpc/nfs_writerpc
   3031    1.1       cgd  *   (Maybe I could use the process's page mapping, but I was concerned that
   3032    1.1       cgd  *    Kernel Write might not be enabled and also figured copyout() would do
   3033   1.97     perry  *    a lot more work than memcpy() and also it currently happens in the
   3034    1.1       cgd  *    context of the swapper process (2).
   3035    1.1       cgd  */
   3036   1.32   mycroft int
   3037  1.272       dsl nfs_bmap(void *v)
   3038   1.58  christos {
   3039   1.32   mycroft 	struct vop_bmap_args /* {
   3040   1.32   mycroft 		struct vnode *a_vp;
   3041   1.32   mycroft 		daddr_t  a_bn;
   3042   1.32   mycroft 		struct vnode **a_vpp;
   3043   1.32   mycroft 		daddr_t *a_bnp;
   3044   1.32   mycroft 		int *a_runp;
   3045   1.58  christos 	} */ *ap = v;
   3046  1.111  augustss 	struct vnode *vp = ap->a_vp;
   3047  1.139       chs 	int bshift = vp->v_mount->mnt_fs_bshift - vp->v_mount->mnt_dev_bshift;
   3048   1.32   mycroft 
   3049   1.32   mycroft 	if (ap->a_vpp != NULL)
   3050   1.32   mycroft 		*ap->a_vpp = vp;
   3051   1.32   mycroft 	if (ap->a_bnp != NULL)
   3052  1.139       chs 		*ap->a_bnp = ap->a_bn << bshift;
   3053  1.138       chs 	if (ap->a_runp != NULL)
   3054  1.138       chs 		*ap->a_runp = 1024 * 1024; /* XXX */
   3055    1.1       cgd 	return (0);
   3056    1.1       cgd }
   3057    1.1       cgd 
   3058    1.1       cgd /*
   3059   1.32   mycroft  * Strategy routine.
   3060   1.32   mycroft  * For async requests when nfsiod(s) are running, queue the request by
   3061   1.32   mycroft  * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
   3062   1.32   mycroft  * request.
   3063    1.1       cgd  */
   3064   1.32   mycroft int
   3065  1.272       dsl nfs_strategy(void *v)
   3066    1.1       cgd {
   3067   1.58  christos 	struct vop_strategy_args *ap = v;
   3068  1.111  augustss 	struct buf *bp = ap->a_bp;
   3069    1.1       cgd 	int error = 0;
   3070    1.1       cgd 
   3071   1.33        pk 	if ((bp->b_flags & (B_PHYS|B_ASYNC)) == (B_PHYS|B_ASYNC))
   3072   1.33        pk 		panic("nfs physio/async");
   3073  1.124       chs 
   3074    1.1       cgd 	/*
   3075    1.1       cgd 	 * If the op is asynchronous and an i/o daemon is waiting
   3076    1.1       cgd 	 * queue the request, wake it up and wait for completion
   3077    1.1       cgd 	 * otherwise just do it ourselves.
   3078    1.1       cgd 	 */
   3079  1.223  christos 	if ((bp->b_flags & B_ASYNC) == 0 || nfs_asyncio(bp))
   3080  1.223  christos 		error = nfs_doio(bp);
   3081    1.1       cgd 	return (error);
   3082    1.1       cgd }
   3083    1.1       cgd 
   3084    1.1       cgd /*
   3085   1.59      fvdl  * fsync vnode op. Just call nfs_flush() with commit == 1.
   3086    1.1       cgd  */
   3087    1.1       cgd /* ARGSUSED */
   3088   1.32   mycroft int
   3089  1.272       dsl nfs_fsync(void *v)
   3090   1.58  christos {
   3091   1.32   mycroft 	struct vop_fsync_args /* {
   3092   1.32   mycroft 		struct vnodeop_desc *a_desc;
   3093   1.32   mycroft 		struct vnode * a_vp;
   3094  1.236      elad 		kauth_cred_t  a_cred;
   3095   1.92    kleink 		int  a_flags;
   3096  1.120      fvdl 		off_t offlo;
   3097  1.120      fvdl 		off_t offhi;
   3098  1.230  christos 		struct lwp * a_l;
   3099   1.58  christos 	} */ *ap = v;
   3100   1.59      fvdl 
   3101  1.186      yamt 	struct vnode *vp = ap->a_vp;
   3102  1.186      yamt 
   3103  1.186      yamt 	if (vp->v_type != VREG)
   3104  1.186      yamt 		return 0;
   3105  1.186      yamt 
   3106  1.186      yamt 	return (nfs_flush(vp, ap->a_cred,
   3107  1.260     pooka 	    (ap->a_flags & FSYNC_WAIT) != 0 ? MNT_WAIT : 0, curlwp, 1));
   3108   1.59      fvdl }
   3109   1.59      fvdl 
   3110   1.59      fvdl /*
   3111  1.124       chs  * Flush all the data associated with a vnode.
   3112   1.59      fvdl  */
   3113   1.59      fvdl int
   3114  1.245      yamt nfs_flush(struct vnode *vp, kauth_cred_t cred, int waitfor, struct lwp *l,
   3115  1.245      yamt     int commit)
   3116   1.59      fvdl {
   3117  1.111  augustss 	struct nfsnode *np = VTONFS(vp);
   3118  1.124       chs 	int error;
   3119  1.124       chs 	int flushflags = PGO_ALLPAGES|PGO_CLEANIT|PGO_SYNCIO;
   3120  1.124       chs 	UVMHIST_FUNC("nfs_flush"); UVMHIST_CALLED(ubchist);
   3121    1.1       cgd 
   3122  1.313        ad 	rw_enter(vp->v_uobj.vmobjlock, RW_WRITER);
   3123  1.145       chs 	error = VOP_PUTPAGES(vp, 0, 0, flushflags);
   3124   1.32   mycroft 	if (np->n_flag & NWRITEERR) {
   3125    1.1       cgd 		error = np->n_error;
   3126   1.32   mycroft 		np->n_flag &= ~NWRITEERR;
   3127   1.32   mycroft 	}
   3128  1.124       chs 	UVMHIST_LOG(ubchist, "returning %d", error,0,0,0);
   3129    1.1       cgd 	return (error);
   3130    1.1       cgd }
   3131    1.1       cgd 
   3132    1.1       cgd /*
   3133   1.32   mycroft  * Return POSIX pathconf information applicable to nfs.
   3134   1.32   mycroft  *
   3135   1.95    kleink  * N.B. The NFS V2 protocol doesn't support this RPC.
   3136   1.32   mycroft  */
   3137   1.32   mycroft /* ARGSUSED */
   3138   1.58  christos int
   3139  1.272       dsl nfs_pathconf(void *v)
   3140   1.58  christos {
   3141   1.32   mycroft 	struct vop_pathconf_args /* {
   3142   1.32   mycroft 		struct vnode *a_vp;
   3143   1.32   mycroft 		int a_name;
   3144   1.41       cgd 		register_t *a_retval;
   3145   1.58  christos 	} */ *ap = v;
   3146   1.95    kleink 	struct nfsv3_pathconf *pcp;
   3147   1.95    kleink 	struct vnode *vp = ap->a_vp;
   3148  1.159      matt 	struct mbuf *mreq, *mrep, *md, *mb;
   3149   1.95    kleink 	int32_t t1, t2;
   3150   1.95    kleink 	u_int32_t *tl;
   3151  1.252  christos 	char *bpos, *dpos, *cp, *cp2;
   3152   1.95    kleink 	int error = 0, attrflag;
   3153  1.146  christos #ifndef NFS_V2_ONLY
   3154  1.146  christos 	struct nfsmount *nmp;
   3155   1.99    kleink 	unsigned int l;
   3156   1.99    kleink 	u_int64_t maxsize;
   3157  1.146  christos #endif
   3158  1.119     bjh21 	const int v3 = NFS_ISV3(vp);
   3159  1.165  drochner 	struct nfsnode *np = VTONFS(vp);
   3160   1.95    kleink 
   3161   1.95    kleink 	switch (ap->a_name) {
   3162   1.95    kleink 		/* Names that can be resolved locally. */
   3163   1.95    kleink 	case _PC_PIPE_BUF:
   3164   1.95    kleink 		*ap->a_retval = PIPE_BUF;
   3165   1.95    kleink 		break;
   3166   1.95    kleink 	case _PC_SYNC_IO:
   3167   1.95    kleink 		*ap->a_retval = 1;
   3168   1.95    kleink 		break;
   3169   1.95    kleink 	/* Names that cannot be resolved locally; do an RPC, if possible. */
   3170   1.95    kleink 	case _PC_LINK_MAX:
   3171   1.95    kleink 	case _PC_NAME_MAX:
   3172   1.95    kleink 	case _PC_CHOWN_RESTRICTED:
   3173   1.95    kleink 	case _PC_NO_TRUNC:
   3174   1.95    kleink 		if (!v3) {
   3175   1.96    kleink 			error = EINVAL;
   3176   1.95    kleink 			break;
   3177   1.95    kleink 		}
   3178   1.95    kleink 		nfsstats.rpccnt[NFSPROC_PATHCONF]++;
   3179  1.165  drochner 		nfsm_reqhead(np, NFSPROC_PATHCONF, NFSX_FH(1));
   3180  1.165  drochner 		nfsm_fhtom(np, 1);
   3181  1.165  drochner 		nfsm_request(np, NFSPROC_PATHCONF,
   3182  1.241        ad 		    curlwp, curlwp->l_cred);	/* XXX */
   3183  1.153      yamt 		nfsm_postop_attr(vp, attrflag, 0);
   3184   1.95    kleink 		if (!error) {
   3185   1.95    kleink 			nfsm_dissect(pcp, struct nfsv3_pathconf *,
   3186   1.95    kleink 			    NFSX_V3PATHCONF);
   3187   1.95    kleink 			switch (ap->a_name) {
   3188   1.95    kleink 			case _PC_LINK_MAX:
   3189   1.95    kleink 				*ap->a_retval =
   3190   1.95    kleink 				    fxdr_unsigned(register_t, pcp->pc_linkmax);
   3191   1.95    kleink 				break;
   3192   1.95    kleink 			case _PC_NAME_MAX:
   3193   1.95    kleink 				*ap->a_retval =
   3194   1.95    kleink 				    fxdr_unsigned(register_t, pcp->pc_namemax);
   3195   1.95    kleink 				break;
   3196   1.95    kleink 			case _PC_CHOWN_RESTRICTED:
   3197   1.95    kleink 				*ap->a_retval =
   3198   1.95    kleink 				    (pcp->pc_chownrestricted == nfs_true);
   3199   1.95    kleink 				break;
   3200   1.95    kleink 			case _PC_NO_TRUNC:
   3201   1.95    kleink 				*ap->a_retval =
   3202   1.95    kleink 				    (pcp->pc_notrunc == nfs_true);
   3203   1.95    kleink 				break;
   3204   1.95    kleink 			}
   3205   1.95    kleink 		}
   3206   1.95    kleink 		nfsm_reqdone;
   3207   1.99    kleink 		break;
   3208   1.99    kleink 	case _PC_FILESIZEBITS:
   3209  1.146  christos #ifndef NFS_V2_ONLY
   3210   1.99    kleink 		if (v3) {
   3211   1.99    kleink 			nmp = VFSTONFS(vp->v_mount);
   3212   1.99    kleink 			if ((nmp->nm_iflag & NFSMNT_GOTFSINFO) == 0)
   3213   1.99    kleink 				if ((error = nfs_fsinfo(nmp, vp,
   3214  1.241        ad 				    curlwp->l_cred, curlwp)) != 0) /* XXX */
   3215   1.99    kleink 					break;
   3216   1.99    kleink 			for (l = 0, maxsize = nmp->nm_maxfilesize;
   3217   1.99    kleink 			    (maxsize >> l) > 0; l++)
   3218   1.99    kleink 				;
   3219   1.99    kleink 			*ap->a_retval = l + 1;
   3220  1.146  christos 		} else
   3221  1.146  christos #endif
   3222  1.146  christos 		{
   3223   1.99    kleink 			*ap->a_retval = 32;	/* NFS V2 limitation */
   3224   1.99    kleink 		}
   3225   1.95    kleink 		break;
   3226   1.95    kleink 	default:
   3227  1.316  christos 		error = genfs_pathconf(ap);
   3228   1.95    kleink 		break;
   3229   1.95    kleink 	}
   3230   1.32   mycroft 
   3231   1.95    kleink 	return (error);
   3232   1.32   mycroft }
   3233   1.32   mycroft 
   3234   1.32   mycroft /*
   3235    1.1       cgd  * NFS advisory byte-level locks.
   3236    1.1       cgd  */
   3237   1.32   mycroft int
   3238  1.272       dsl nfs_advlock(void *v)
   3239   1.58  christos {
   3240   1.32   mycroft 	struct vop_advlock_args /* {
   3241   1.32   mycroft 		struct vnode *a_vp;
   3242  1.252  christos 		void *a_id;
   3243   1.32   mycroft 		int  a_op;
   3244   1.32   mycroft 		struct flock *a_fl;
   3245   1.32   mycroft 		int  a_flags;
   3246   1.58  christos 	} */ *ap = v;
   3247  1.111  augustss 	struct nfsnode *np = VTONFS(ap->a_vp);
   3248    1.1       cgd 
   3249  1.115  jdolecek 	return lf_advlock(ap, &np->n_lockf, np->n_size);
   3250    1.1       cgd }
   3251    1.1       cgd 
   3252    1.1       cgd /*
   3253    1.1       cgd  * Print out the contents of an nfsnode.
   3254    1.1       cgd  */
   3255   1.17       cgd int
   3256  1.272       dsl nfs_print(void *v)
   3257   1.58  christos {
   3258   1.32   mycroft 	struct vop_print_args /* {
   3259   1.32   mycroft 		struct vnode *a_vp;
   3260   1.58  christos 	} */ *ap = v;
   3261  1.111  augustss 	struct vnode *vp = ap->a_vp;
   3262  1.111  augustss 	struct nfsnode *np = VTONFS(vp);
   3263    1.1       cgd 
   3264  1.269  christos 	printf("tag VT_NFS, fileid %lld fsid 0x%llx",
   3265  1.269  christos 	    (unsigned long long)np->n_vattr->va_fileid,
   3266  1.269  christos 	    (unsigned long long)np->n_vattr->va_fsid);
   3267    1.1       cgd 	if (vp->v_type == VFIFO)
   3268  1.283     pooka 		VOCALL(fifo_vnodeop_p, VOFFSET(vop_print), v);
   3269   1.67  christos 	printf("\n");
   3270   1.59      fvdl 	return (0);
   3271   1.32   mycroft }
   3272   1.32   mycroft 
   3273   1.32   mycroft /*
   3274  1.153      yamt  * nfs unlock wrapper.
   3275  1.153      yamt  */
   3276  1.153      yamt int
   3277  1.153      yamt nfs_unlock(void *v)
   3278  1.153      yamt {
   3279  1.153      yamt 	struct vop_unlock_args /* {
   3280  1.153      yamt 		struct vnode *a_vp;
   3281  1.153      yamt 		int a_flags;
   3282  1.153      yamt 	} */ *ap = v;
   3283  1.153      yamt 	struct vnode *vp = ap->a_vp;
   3284  1.153      yamt 
   3285  1.155      yamt 	/*
   3286  1.155      yamt 	 * VOP_UNLOCK can be called by nfs_loadattrcache
   3287  1.155      yamt 	 * with v_data == 0.
   3288  1.155      yamt 	 */
   3289  1.155      yamt 	if (VTONFS(vp)) {
   3290  1.155      yamt 		nfs_delayedtruncate(vp);
   3291  1.155      yamt 	}
   3292  1.153      yamt 
   3293  1.153      yamt 	return genfs_unlock(v);
   3294   1.59      fvdl }
   3295   1.59      fvdl 
   3296   1.59      fvdl /*
   3297   1.32   mycroft  * nfs special file access vnode op.
   3298   1.32   mycroft  * Essentially just get vattr and then imitate iaccess() since the device is
   3299   1.32   mycroft  * local to the client.
   3300    1.3     glass  */
   3301   1.32   mycroft int
   3302  1.272       dsl nfsspec_access(void *v)
   3303   1.58  christos {
   3304   1.32   mycroft 	struct vop_access_args /* {
   3305   1.32   mycroft 		struct vnode *a_vp;
   3306  1.315  christos 		accmode_t  a_accmode;
   3307  1.236      elad 		kauth_cred_t a_cred;
   3308  1.230  christos 		struct lwp *a_l;
   3309   1.58  christos 	} */ *ap = v;
   3310   1.46   mycroft 	struct vattr va;
   3311   1.59      fvdl 	struct vnode *vp = ap->a_vp;
   3312   1.32   mycroft 	int error;
   3313    1.3     glass 
   3314  1.260     pooka 	error = VOP_GETATTR(vp, &va, ap->a_cred);
   3315   1.71      fvdl 	if (error)
   3316   1.71      fvdl 		return (error);
   3317   1.71      fvdl 
   3318   1.59      fvdl         /*
   3319   1.59      fvdl 	 * Disallow write attempts on filesystems mounted read-only;
   3320   1.59      fvdl 	 * unless the file is a socket, fifo, or a block or character
   3321   1.59      fvdl 	 * device resident on the filesystem.
   3322   1.59      fvdl 	 */
   3323  1.315  christos 	if ((ap->a_accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
   3324   1.59      fvdl 		switch (vp->v_type) {
   3325   1.59      fvdl 		case VREG:
   3326   1.59      fvdl 		case VDIR:
   3327   1.59      fvdl 		case VLNK:
   3328   1.59      fvdl 			return (EROFS);
   3329   1.59      fvdl 		default:
   3330   1.59      fvdl 			break;
   3331   1.59      fvdl 		}
   3332   1.59      fvdl 	}
   3333   1.46   mycroft 
   3334  1.315  christos 	return kauth_authorize_vnode(ap->a_cred, KAUTH_ACCESS_ACTION(
   3335  1.315  christos 	    ap->a_accmode, va.va_type, va.va_mode), vp, NULL, genfs_can_access(
   3336  1.315  christos 	    vp, ap->a_cred, va.va_uid, va.va_gid, va.va_mode, NULL,
   3337  1.315  christos 	    ap->a_accmode));
   3338    1.3     glass }
   3339   1.22        pk 
   3340   1.22        pk /*
   3341   1.22        pk  * Read wrapper for special devices.
   3342   1.22        pk  */
   3343   1.32   mycroft int
   3344  1.272       dsl nfsspec_read(void *v)
   3345   1.58  christos {
   3346   1.32   mycroft 	struct vop_read_args /* {
   3347   1.32   mycroft 		struct vnode *a_vp;
   3348   1.32   mycroft 		struct uio *a_uio;
   3349   1.32   mycroft 		int  a_ioflag;
   3350  1.236      elad 		kauth_cred_t a_cred;
   3351   1.58  christos 	} */ *ap = v;
   3352  1.111  augustss 	struct nfsnode *np = VTONFS(ap->a_vp);
   3353   1.32   mycroft 
   3354   1.32   mycroft 	/*
   3355   1.32   mycroft 	 * Set access flag.
   3356   1.32   mycroft 	 */
   3357   1.32   mycroft 	np->n_flag |= NACC;
   3358  1.237    kardel 	getnanotime(&np->n_atim);
   3359   1.32   mycroft 	return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
   3360   1.22        pk }
   3361   1.22        pk 
   3362   1.22        pk /*
   3363   1.22        pk  * Write wrapper for special devices.
   3364   1.22        pk  */
   3365   1.32   mycroft int
   3366  1.272       dsl nfsspec_write(void *v)
   3367   1.58  christos {
   3368   1.32   mycroft 	struct vop_write_args /* {
   3369   1.32   mycroft 		struct vnode *a_vp;
   3370   1.32   mycroft 		struct uio *a_uio;
   3371   1.32   mycroft 		int  a_ioflag;
   3372  1.236      elad 		kauth_cred_t a_cred;
   3373   1.58  christos 	} */ *ap = v;
   3374  1.111  augustss 	struct nfsnode *np = VTONFS(ap->a_vp);
   3375   1.32   mycroft 
   3376   1.32   mycroft 	/*
   3377   1.32   mycroft 	 * Set update flag.
   3378   1.32   mycroft 	 */
   3379   1.32   mycroft 	np->n_flag |= NUPD;
   3380  1.237    kardel 	getnanotime(&np->n_mtim);
   3381   1.32   mycroft 	return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
   3382   1.22        pk }
   3383   1.22        pk 
   3384   1.22        pk /*
   3385   1.22        pk  * Close wrapper for special devices.
   3386   1.22        pk  *
   3387   1.32   mycroft  * Update the times on the nfsnode then do device close.
   3388   1.22        pk  */
   3389   1.32   mycroft int
   3390  1.272       dsl nfsspec_close(void *v)
   3391   1.58  christos {
   3392   1.32   mycroft 	struct vop_close_args /* {
   3393   1.32   mycroft 		struct vnode *a_vp;
   3394   1.32   mycroft 		int  a_fflag;
   3395  1.236      elad 		kauth_cred_t a_cred;
   3396  1.230  christos 		struct lwp *a_l;
   3397   1.58  christos 	} */ *ap = v;
   3398  1.111  augustss 	struct vnode *vp = ap->a_vp;
   3399  1.111  augustss 	struct nfsnode *np = VTONFS(vp);
   3400   1.32   mycroft 	struct vattr vattr;
   3401   1.32   mycroft 
   3402   1.32   mycroft 	if (np->n_flag & (NACC | NUPD)) {
   3403   1.32   mycroft 		np->n_flag |= NCHG;
   3404  1.314        ad 		if (vrefcnt(vp) == 1 &&
   3405   1.32   mycroft 		    (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
   3406  1.282     pooka 			vattr_null(&vattr);
   3407   1.59      fvdl 			if (np->n_flag & NACC)
   3408   1.59      fvdl 				vattr.va_atime = np->n_atim;
   3409   1.59      fvdl 			if (np->n_flag & NUPD)
   3410   1.59      fvdl 				vattr.va_mtime = np->n_mtim;
   3411  1.260     pooka 			(void)VOP_SETATTR(vp, &vattr, ap->a_cred);
   3412   1.32   mycroft 		}
   3413   1.22        pk 	}
   3414   1.32   mycroft 	return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
   3415   1.22        pk }
   3416   1.22        pk 
   3417   1.22        pk /*
   3418   1.32   mycroft  * Read wrapper for fifos.
   3419   1.22        pk  */
   3420   1.32   mycroft int
   3421  1.272       dsl nfsfifo_read(void *v)
   3422   1.58  christos {
   3423   1.32   mycroft 	struct vop_read_args /* {
   3424   1.32   mycroft 		struct vnode *a_vp;
   3425   1.32   mycroft 		struct uio *a_uio;
   3426   1.32   mycroft 		int  a_ioflag;
   3427  1.236      elad 		kauth_cred_t a_cred;
   3428   1.58  christos 	} */ *ap = v;
   3429  1.111  augustss 	struct nfsnode *np = VTONFS(ap->a_vp);
   3430   1.32   mycroft 
   3431   1.22        pk 	/*
   3432   1.32   mycroft 	 * Set access flag.
   3433   1.22        pk 	 */
   3434   1.32   mycroft 	np->n_flag |= NACC;
   3435  1.237    kardel 	getnanotime(&np->n_atim);
   3436   1.32   mycroft 	return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
   3437   1.22        pk }
   3438   1.22        pk 
   3439   1.22        pk /*
   3440   1.32   mycroft  * Write wrapper for fifos.
   3441   1.22        pk  */
   3442   1.32   mycroft int
   3443  1.272       dsl nfsfifo_write(void *v)
   3444   1.58  christos {
   3445   1.32   mycroft 	struct vop_write_args /* {
   3446   1.32   mycroft 		struct vnode *a_vp;
   3447   1.32   mycroft 		struct uio *a_uio;
   3448   1.32   mycroft 		int  a_ioflag;
   3449  1.236      elad 		kauth_cred_t a_cred;
   3450   1.58  christos 	} */ *ap = v;
   3451  1.111  augustss 	struct nfsnode *np = VTONFS(ap->a_vp);
   3452   1.32   mycroft 
   3453   1.22        pk 	/*
   3454   1.32   mycroft 	 * Set update flag.
   3455   1.22        pk 	 */
   3456   1.32   mycroft 	np->n_flag |= NUPD;
   3457  1.237    kardel 	getnanotime(&np->n_mtim);
   3458   1.32   mycroft 	return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
   3459   1.22        pk }
   3460   1.22        pk 
   3461   1.22        pk /*
   3462   1.32   mycroft  * Close wrapper for fifos.
   3463   1.22        pk  *
   3464   1.32   mycroft  * Update the times on the nfsnode then do fifo close.
   3465   1.22        pk  */
   3466   1.32   mycroft int
   3467  1.272       dsl nfsfifo_close(void *v)
   3468   1.58  christos {
   3469   1.32   mycroft 	struct vop_close_args /* {
   3470   1.32   mycroft 		struct vnode *a_vp;
   3471   1.32   mycroft 		int  a_fflag;
   3472  1.236      elad 		kauth_cred_t a_cred;
   3473  1.230  christos 		struct lwp *a_l;
   3474   1.58  christos 	} */ *ap = v;
   3475  1.111  augustss 	struct vnode *vp = ap->a_vp;
   3476  1.111  augustss 	struct nfsnode *np = VTONFS(vp);
   3477   1.32   mycroft 	struct vattr vattr;
   3478   1.32   mycroft 
   3479   1.32   mycroft 	if (np->n_flag & (NACC | NUPD)) {
   3480  1.237    kardel 		struct timespec ts;
   3481  1.237    kardel 
   3482  1.237    kardel 		getnanotime(&ts);
   3483  1.237    kardel 		if (np->n_flag & NACC)
   3484  1.237    kardel 			np->n_atim = ts;
   3485  1.237    kardel 		if (np->n_flag & NUPD)
   3486  1.237    kardel 			np->n_mtim = ts;
   3487   1.32   mycroft 		np->n_flag |= NCHG;
   3488  1.314        ad 		if (vrefcnt(vp) == 1 &&
   3489   1.32   mycroft 		    (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
   3490  1.282     pooka 			vattr_null(&vattr);
   3491   1.59      fvdl 			if (np->n_flag & NACC)
   3492   1.59      fvdl 				vattr.va_atime = np->n_atim;
   3493   1.59      fvdl 			if (np->n_flag & NUPD)
   3494   1.59      fvdl 				vattr.va_mtime = np->n_mtim;
   3495  1.260     pooka 			(void)VOP_SETATTR(vp, &vattr, ap->a_cred);
   3496   1.32   mycroft 		}
   3497   1.22        pk 	}
   3498   1.32   mycroft 	return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
   3499   1.22        pk }
   3500