Home | History | Annotate | Line # | Download | only in nfs
nfs_serv.c revision 1.181
      1 /*	$NetBSD: nfs_serv.c,v 1.181 2020/09/05 16:30:12 riastradh Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1989, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This code is derived from software contributed to Berkeley by
      8  * Rick Macklem at The University of Guelph.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  *
     34  *	@(#)nfs_serv.c	8.8 (Berkeley) 7/31/95
     35  */
     36 
     37 /*
     38  * nfs version 2 and 3 server calls to vnode ops
     39  * - these routines generally have 3 phases
     40  *   1 - break down and validate rpc request in mbuf list
     41  *   2 - do the vnode ops for the request
     42  *       (surprisingly ?? many are very similar to syscalls in vfs_syscalls.c)
     43  *   3 - build the rpc reply in an mbuf list
     44  *   nb:
     45  *	- do not mix the phases, since the nfsm_?? macros can return failures
     46  *	  on a bad rpc or similar and do not do any vrele() or vput()'s
     47  *
     48  *      - the nfsm_reply() macro generates an nfs rpc reply with the nfs
     49  *	error number iff error != 0 whereas
     50  *	returning an error from the server function implies a fatal error
     51  *	such as a badly constructed rpc request that should be dropped without
     52  *	a reply.
     53  *	For Version 3, nfsm_reply() does not return for the error case, since
     54  *	most version 3 rpcs return more than the status for error cases.
     55  */
     56 
     57 #include <sys/cdefs.h>
     58 __KERNEL_RCSID(0, "$NetBSD: nfs_serv.c,v 1.181 2020/09/05 16:30:12 riastradh Exp $");
     59 
     60 #include <sys/param.h>
     61 #include <sys/systm.h>
     62 #include <sys/proc.h>
     63 #include <sys/file.h>
     64 #include <sys/namei.h>
     65 #include <sys/vnode.h>
     66 #include <sys/mount.h>
     67 #include <sys/fstrans.h>
     68 #include <sys/socket.h>
     69 #include <sys/socketvar.h>
     70 #include <sys/mbuf.h>
     71 #include <sys/dirent.h>
     72 #include <sys/stat.h>
     73 #include <sys/kernel.h>
     74 #include <sys/hash.h>
     75 #include <sys/kauth.h>
     76 #include <sys/module.h>
     77 #include <sys/syscall.h>
     78 #include <sys/syscallargs.h>
     79 #include <sys/syscallvar.h>
     80 
     81 #include <uvm/uvm_extern.h>
     82 #include <uvm/uvm_loan.h>
     83 #include <uvm/uvm_page.h>
     84 
     85 #include <nfs/nfsproto.h>
     86 #include <nfs/rpcv2.h>
     87 #include <nfs/nfs.h>
     88 #include <nfs/xdr_subs.h>
     89 #include <nfs/nfsm_subs.h>
     90 #include <nfs/nfs_var.h>
     91 
     92 MODULE(MODULE_CLASS_MISC, nfsserver, "nfs");
     93 
     94 /* Global vars */
     95 extern u_int32_t nfs_xdrneg1;
     96 extern u_int32_t nfs_false, nfs_true;
     97 extern const enum vtype nv3tov_type[8];
     98 extern struct nfsstats nfsstats;
     99 extern const nfstype nfsv2_type[9];
    100 extern const nfstype nfsv3_type[9];
    101 int nfsrvw_procrastinate = NFS_GATHERDELAY * 1000;
    102 bool nfsd_use_loan = true;	/* use page-loan for READ OP */
    103 
    104 #define	nqsrv_getl(vp, rw)	/* nothing */
    105 
    106 static const struct syscall_package nfsserver_syscalls[] = {
    107 	{ SYS_nfssvc, 0, (sy_call_t *)sys_nfssvc },
    108 	{ 0, 0, NULL },
    109 };
    110 
    111 static int
    112 nfsserver_modcmd(modcmd_t cmd, void *arg)
    113 {
    114 	extern struct vfs_hooks nfs_export_hooks;	/* XXX */
    115 	int error;
    116 
    117 	switch (cmd) {
    118 	case MODULE_CMD_INIT:
    119 		error = syscall_establish(NULL, nfsserver_syscalls);
    120 		if (error != 0) {
    121 			return error;
    122 		}
    123 		nfs_init();	/* XXX for monolithic kernel */
    124 		netexport_init();
    125 		nfsrv_initcache();	/* Init the server request cache */
    126 		nfsrv_init(0);		/* Init server data structures */
    127 		vfs_hooks_attach(&nfs_export_hooks);
    128 		nfs_timer_srvinit(nfsrv_timer);
    129 		return 0;
    130 	case MODULE_CMD_FINI:
    131 		error = syscall_disestablish(NULL, nfsserver_syscalls);
    132 		if (error != 0) {
    133 			return error;
    134 		}
    135 		/*
    136 		 * Kill export list before detaching VFS hooks, so we
    137 		 * we don't leak state due to a concurrent umount().
    138 		 */
    139 		netexport_fini();
    140 		vfs_hooks_detach(&nfs_export_hooks);
    141 
    142 		/* Kill timer before server goes away. */
    143 		nfs_timer_srvfini();
    144 		nfsrv_fini();
    145 
    146 		/* Server uses server cache, so kill cache last. */
    147 		nfsrv_finicache();
    148 		nfs_fini();
    149 		return 0;
    150 	case MODULE_CMD_AUTOUNLOAD:
    151 		if (netexport_hasexports())
    152 			return EBUSY;
    153 		/*FALLTHROUGH*/
    154 	default:
    155 		return ENOTTY;
    156 	}
    157 }
    158 
    159 /*
    160  * nfs v3 access service
    161  */
    162 int
    163 nfsrv3_access(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    164 {
    165 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    166 	struct mbuf *nam = nfsd->nd_nam;
    167 	char *dpos = nfsd->nd_dpos;
    168 	kauth_cred_t cred = nfsd->nd_cr;
    169 	struct vnode *vp;
    170 	nfsrvfh_t nsfh;
    171 	u_int32_t *tl;
    172 	int32_t t1;
    173 	char *bpos;
    174 	int error = 0, rdonly, cache = 0, getret;
    175 	char *cp2;
    176 	struct mbuf *mb, *mreq __unused;
    177 	struct vattr va;
    178 	u_long inmode, testmode, outmode;
    179 	u_quad_t frev;
    180 
    181 	nfsm_srvmtofh(&nsfh);
    182 	nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
    183 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam, &rdonly,
    184 	    (nfsd->nd_flag & ND_KERBAUTH), false);
    185 	if (error) {
    186 		nfsm_reply(NFSX_UNSIGNED);
    187 		nfsm_srvpostop_attr(1, (struct vattr *)0);
    188 		return (0);
    189 	}
    190 	inmode = fxdr_unsigned(u_int32_t, *tl);
    191 	outmode = 0;
    192 	if ((inmode & NFSV3ACCESS_READ) &&
    193 	    nfsrv_access(vp, VREAD, cred, rdonly, lwp, 0) == 0)
    194 		outmode |= NFSV3ACCESS_READ;
    195 	if (vp->v_type != VDIR) {
    196 		testmode = inmode & (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
    197 		if (testmode &&
    198 		    nfsrv_access(vp, VWRITE, cred, rdonly, lwp, 0) == 0)
    199 			outmode |= testmode;
    200 		if ((inmode & NFSV3ACCESS_EXECUTE) &&
    201 		    nfsrv_access(vp, VEXEC, cred, rdonly, lwp, 0) == 0)
    202 			outmode |= NFSV3ACCESS_EXECUTE;
    203 	} else {
    204 		testmode = inmode & (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
    205 		    NFSV3ACCESS_DELETE);
    206 		if (testmode &&
    207 		    nfsrv_access(vp, VWRITE, cred, rdonly, lwp, 0) == 0)
    208 			outmode |= testmode;
    209 		if ((inmode & NFSV3ACCESS_LOOKUP) &&
    210 		    nfsrv_access(vp, VEXEC, cred, rdonly, lwp, 0) == 0)
    211 			outmode |= NFSV3ACCESS_LOOKUP;
    212 	}
    213 	getret = VOP_GETATTR(vp, &va, cred);
    214 	vput(vp);
    215 	nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED);
    216 	nfsm_srvpostop_attr(getret, &va);
    217 	nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
    218 	*tl = txdr_unsigned(outmode);
    219 	nfsm_srvdone;
    220 }
    221 
    222 /*
    223  * nfs getattr service
    224  */
    225 int
    226 nfsrv_getattr(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    227 {
    228 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    229 	struct mbuf *nam = nfsd->nd_nam;
    230 	char *dpos = nfsd->nd_dpos;
    231 	kauth_cred_t cred = nfsd->nd_cr;
    232 	struct nfs_fattr *fp;
    233 	struct vattr va;
    234 	struct vnode *vp;
    235 	nfsrvfh_t nsfh;
    236 	u_int32_t *tl;
    237 	int32_t t1;
    238 	char *bpos;
    239 	int error = 0, rdonly, cache = 0;
    240 	char *cp2;
    241 	struct mbuf *mb, *mreq __unused;
    242 	u_quad_t frev;
    243 
    244 	nfsm_srvmtofh(&nsfh);
    245 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam, &rdonly,
    246 	    (nfsd->nd_flag & ND_KERBAUTH), false);
    247 	if (error) {
    248 		nfsm_reply(0);
    249 		return (0);
    250 	}
    251 	nqsrv_getl(vp, ND_READ);
    252 	error = VOP_GETATTR(vp, &va, cred);
    253 	vput(vp);
    254 	nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
    255 	if (error)
    256 		return (0);
    257 	nfsm_build(fp, struct nfs_fattr *, NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
    258 	nfsm_srvfillattr(&va, fp);
    259 	nfsm_srvdone;
    260 }
    261 
    262 /*
    263  * nfs setattr service
    264  */
    265 int
    266 nfsrv_setattr(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    267 {
    268 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    269 	struct mbuf *nam = nfsd->nd_nam;
    270 	char *dpos = nfsd->nd_dpos;
    271 	kauth_cred_t cred = nfsd->nd_cr;
    272 	struct vattr va, preat;
    273 	struct nfsv2_sattr *sp;
    274 	struct nfs_fattr *fp;
    275 	struct vnode *vp;
    276 	nfsrvfh_t nsfh;
    277 	u_int32_t *tl;
    278 	int32_t t1;
    279 	char *bpos;
    280 	int error = 0, rdonly, cache = 0, preat_ret = 1, postat_ret = 1;
    281 	int v3 = (nfsd->nd_flag & ND_NFSV3), gcheck = 0;
    282 	char *cp2;
    283 	struct mbuf *mb, *mreq __unused;
    284 	u_quad_t frev;
    285 	struct timespec guard;
    286 
    287 	memset(&guard, 0, sizeof guard);	/* XXX gcc */
    288 
    289 	nfsm_srvmtofh(&nsfh);
    290 	vattr_null(&va);
    291 	if (v3) {
    292 		nfsm_srvsattr(&va);
    293 		nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
    294 		gcheck = fxdr_unsigned(int, *tl);
    295 		if (gcheck) {
    296 			nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
    297 			fxdr_nfsv3time(tl, &guard);
    298 		}
    299 	} else {
    300 		nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
    301 		/*
    302 		 * Nah nah nah nah na nah
    303 		 * There is a bug in the Sun client that puts 0xffff in the mode
    304 		 * field of sattr when it should put in 0xffffffff. The u_short
    305 		 * doesn't sign extend.
    306 		 * --> check the low order 2 bytes for 0xffff
    307 		 */
    308 		if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
    309 			va.va_mode = nfstov_mode(sp->sa_mode);
    310 		if (sp->sa_uid != nfs_xdrneg1)
    311 			va.va_uid = fxdr_unsigned(uid_t, sp->sa_uid);
    312 		if (sp->sa_gid != nfs_xdrneg1)
    313 			va.va_gid = fxdr_unsigned(gid_t, sp->sa_gid);
    314 		if (sp->sa_size != nfs_xdrneg1)
    315 			va.va_size = fxdr_unsigned(u_quad_t, sp->sa_size);
    316 		if (sp->sa_atime.nfsv2_sec != nfs_xdrneg1) {
    317 #ifdef notyet
    318 			fxdr_nfsv2time(&sp->sa_atime, &va.va_atime);
    319 #else
    320 			va.va_atime.tv_sec =
    321 				fxdr_unsigned(u_int32_t,sp->sa_atime.nfsv2_sec);
    322 			va.va_atime.tv_nsec = 0;
    323 #endif
    324 		}
    325 		if (sp->sa_mtime.nfsv2_sec != nfs_xdrneg1)
    326 			fxdr_nfsv2time(&sp->sa_mtime, &va.va_mtime);
    327 
    328 	}
    329 
    330 	/*
    331 	 * Now that we have all the fields, lets do it.
    332 	 */
    333 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam, &rdonly,
    334 	    (nfsd->nd_flag & ND_KERBAUTH), false);
    335 	if (error) {
    336 		nfsm_reply(2 * NFSX_UNSIGNED);
    337 		nfsm_srvwcc_data(preat_ret, &preat, postat_ret, &va);
    338 		return (0);
    339 	}
    340 	nqsrv_getl(vp, ND_WRITE);
    341 	if (v3) {
    342 		error = preat_ret = VOP_GETATTR(vp, &preat, cred);
    343 		if (!error && gcheck &&
    344 			(preat.va_ctime.tv_sec != guard.tv_sec ||
    345 			 preat.va_ctime.tv_nsec != guard.tv_nsec))
    346 			error = NFSERR_NOT_SYNC;
    347 		if (error) {
    348 			vput(vp);
    349 			nfsm_reply(NFSX_WCCDATA(v3));
    350 			nfsm_srvwcc_data(preat_ret, &preat, postat_ret, &va);
    351 			return (0);
    352 		}
    353 	}
    354 
    355 	/*
    356 	 * If the size is being changed write acces is required, otherwise
    357 	 * just check for a read only file system.
    358 	 */
    359 	if (va.va_size == ((u_quad_t)((quad_t) -1))) {
    360 		if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
    361 			error = EROFS;
    362 			goto out;
    363 		}
    364 	} else {
    365 		if (vp->v_type == VDIR) {
    366 			error = EISDIR;
    367 			goto out;
    368 		} else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly,
    369 			lwp, 0)) != 0)
    370 			goto out;
    371 	}
    372 	error = VOP_SETATTR(vp, &va, cred);
    373 	postat_ret = VOP_GETATTR(vp, &va, cred);
    374 	if (!error)
    375 		error = postat_ret;
    376 out:
    377 	vput(vp);
    378 	nfsm_reply(NFSX_WCCORFATTR(v3));
    379 	if (v3) {
    380 		nfsm_srvwcc_data(preat_ret, &preat, postat_ret, &va);
    381 		return (0);
    382 	} else {
    383 		nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
    384 		nfsm_srvfillattr(&va, fp);
    385 	}
    386 	nfsm_srvdone;
    387 }
    388 
    389 /*
    390  * nfs lookup rpc
    391  */
    392 int
    393 nfsrv_lookup(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    394 {
    395 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    396 	struct mbuf *nam = nfsd->nd_nam;
    397 	char *dpos = nfsd->nd_dpos;
    398 	kauth_cred_t cred = nfsd->nd_cr;
    399 	struct nfs_fattr *fp;
    400 	struct nameidata nd, ind, *ndp = &nd;
    401 	struct pathbuf *ipb = NULL;
    402 	struct vnode *vp, *dirp;
    403 	nfsrvfh_t nsfh;
    404 	char *cp;
    405 	u_int32_t *tl;
    406 	int32_t t1;
    407 	char *bpos;
    408 	int error = 0, cache = 0, dirattr_ret = 1;
    409 	uint32_t len;
    410 	int v3 = (nfsd->nd_flag & ND_NFSV3), pubflag;
    411 	char *cp2;
    412 	struct mbuf *mb, *mreq __unused;
    413 	struct vattr va, dirattr;
    414 	u_quad_t frev;
    415 
    416 	nfsm_srvmtofh(&nsfh);
    417 	nfsm_srvnamesiz(len);
    418 
    419 	pubflag = nfs_ispublicfh(&nsfh);
    420 
    421 	nd.ni_cnd.cn_cred = cred;
    422 	nd.ni_cnd.cn_nameiop = LOOKUP;
    423 	nd.ni_cnd.cn_flags = LOCKLEAF;
    424 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
    425 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), pubflag);
    426 
    427 	if (!error && pubflag) {
    428 		if (nd.ni_vp->v_type == VDIR && nfs_pub.np_index != NULL &&
    429 		    (ipb = pathbuf_create(nfs_pub.np_index)) != NULL) {
    430 			/*
    431 			 * Setup call to lookup() to see if we can find
    432 			 * the index file. Arguably, this doesn't belong
    433 			 * in a kernel.. Ugh.
    434 			 */
    435 			ind = nd;
    436 			VOP_UNLOCK(nd.ni_vp);
    437 			ind.ni_pathbuf = ipb;
    438 
    439 			error = lookup_for_nfsd_index(&ind, nd.ni_vp);
    440 			if (!error) {
    441 				/*
    442 				 * Found an index file. Get rid of
    443 				 * the old references.
    444 				 */
    445 				if (dirp)
    446 					vrele(dirp);
    447 				dirp = nd.ni_vp;
    448 				ndp = &ind;
    449 			} else
    450 				error = 0;
    451 		}
    452 		/*
    453 		 * If the public filehandle was used, check that this lookup
    454 		 * didn't result in a filehandle outside the publicly exported
    455 		 * filesystem.
    456 		 */
    457 
    458 		if (!error && ndp->ni_vp->v_mount != nfs_pub.np_mount) {
    459 			vput(nd.ni_vp);
    460 			error = EPERM;
    461 		}
    462 	}
    463 
    464 	if (error) {
    465 		if (nd.ni_pathbuf != NULL) {
    466 			pathbuf_destroy(nd.ni_pathbuf);
    467 		}
    468 		if (ipb != NULL) {
    469 			pathbuf_destroy(ipb);
    470 		}
    471 		if (dirp) {
    472 			if (v3) {
    473 				vn_lock(dirp, LK_SHARED | LK_RETRY);
    474 				dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred);
    475 				vput(dirp);
    476 			} else
    477 				vrele(dirp);
    478 		}
    479 		nfsm_reply(NFSX_POSTOPATTR(v3));
    480 		nfsm_srvpostop_attr(dirattr_ret, &dirattr);
    481 		return (0);
    482 	}
    483 
    484 	nqsrv_getl(ndp->ni_startdir, ND_READ);
    485 	pathbuf_destroy(nd.ni_pathbuf);
    486 	if (ipb != NULL) {
    487 		pathbuf_destroy(ipb);
    488 	}
    489 	vp = ndp->ni_vp;
    490 	error = nfsrv_composefh(vp, &nsfh, v3);
    491 	if (!error)
    492 		error = VOP_GETATTR(vp, &va, cred);
    493 	vput(vp);
    494 	if (dirp) {
    495 		if (v3) {
    496 			vn_lock(dirp, LK_SHARED | LK_RETRY);
    497 			dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred);
    498 			vput(dirp);
    499 		} else
    500 			vrele(dirp);
    501 	}
    502 	nfsm_reply(NFSX_SRVFH(&nsfh, v3) + NFSX_POSTOPORFATTR(v3) +
    503 	    NFSX_POSTOPATTR(v3));
    504 	if (error) {
    505 		nfsm_srvpostop_attr(dirattr_ret, &dirattr);
    506 		return (0);
    507 	}
    508 	nfsm_srvfhtom(&nsfh, v3);
    509 	if (v3) {
    510 		nfsm_srvpostop_attr(0, &va);
    511 		nfsm_srvpostop_attr(dirattr_ret, &dirattr);
    512 	} else {
    513 		nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
    514 		nfsm_srvfillattr(&va, fp);
    515 	}
    516 	nfsm_srvdone;
    517 }
    518 
    519 /*
    520  * nfs readlink service
    521  */
    522 int
    523 nfsrv_readlink(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    524 {
    525 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    526 	struct mbuf *nam = nfsd->nd_nam;
    527 	char *dpos = nfsd->nd_dpos;
    528 	kauth_cred_t cred = nfsd->nd_cr;
    529 	struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
    530 	struct iovec *ivp = iv;
    531 	struct mbuf *mp;
    532 	u_int32_t *tl;
    533 	int32_t t1;
    534 	char *bpos;
    535 	int error = 0, rdonly, cache = 0, i, padlen, getret;
    536 	uint32_t len;
    537 	int v3 = (nfsd->nd_flag & ND_NFSV3);
    538 	char *cp2;
    539 	struct mbuf *mb, *mp2 = NULL, *mp3 = NULL, *mreq __unused;
    540 	struct vnode *vp;
    541 	struct vattr attr;
    542 	nfsrvfh_t nsfh;
    543 	struct uio io, *uiop = &io;
    544 	u_quad_t frev;
    545 
    546 	nfsm_srvmtofh(&nsfh);
    547 	len = 0;
    548 	i = 0;
    549 	while (len < NFS_MAXPATHLEN) {
    550 		mp = m_get(M_WAIT, MT_DATA);
    551 		MCLAIM(mp, &nfs_mowner);
    552 		m_clget(mp, M_WAIT);
    553 		mp->m_len = NFSMSIZ(mp);
    554 		if (len == 0)
    555 			mp3 = mp2 = mp;
    556 		else {
    557 			mp2->m_next = mp;
    558 			mp2 = mp;
    559 		}
    560 		if ((len+mp->m_len) > NFS_MAXPATHLEN) {
    561 			mp->m_len = NFS_MAXPATHLEN-len;
    562 			len = NFS_MAXPATHLEN;
    563 		} else
    564 			len += mp->m_len;
    565 		ivp->iov_base = mtod(mp, void *);
    566 		ivp->iov_len = mp->m_len;
    567 		i++;
    568 		ivp++;
    569 	}
    570 	uiop->uio_iov = iv;
    571 	uiop->uio_iovcnt = i;
    572 	uiop->uio_offset = 0;
    573 	uiop->uio_resid = len;
    574 	uiop->uio_rw = UIO_READ;
    575 	UIO_SETUP_SYSSPACE(uiop);
    576 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
    577 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
    578 	if (error) {
    579 		m_freem(mp3);
    580 		nfsm_reply(2 * NFSX_UNSIGNED);
    581 		nfsm_srvpostop_attr(1, (struct vattr *)0);
    582 		return (0);
    583 	}
    584 	if (vp->v_type != VLNK) {
    585 		if (v3)
    586 			error = EINVAL;
    587 		else
    588 			error = ENXIO;
    589 		goto out;
    590 	}
    591 	nqsrv_getl(vp, ND_READ);
    592 	error = VOP_READLINK(vp, uiop, cred);
    593 out:
    594 	getret = VOP_GETATTR(vp, &attr, cred);
    595 	vput(vp);
    596 	if (error)
    597 		m_freem(mp3);
    598 	nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED);
    599 	if (v3) {
    600 		nfsm_srvpostop_attr(getret, &attr);
    601 		if (error)
    602 			return (0);
    603 	}
    604 	len -= uiop->uio_resid;
    605 	padlen = nfsm_padlen(len);
    606 	if (len == 0) {
    607 		m_freem(mp3);
    608 		mp3 = NULL;
    609 	} else if (uiop->uio_resid || padlen)
    610 		nfs_zeropad(mp3, uiop->uio_resid, padlen);
    611 	nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
    612 	*tl = txdr_unsigned(len);
    613 	mb->m_next = mp3;
    614 	nfsm_srvdone;
    615 }
    616 
    617 /*
    618  * nfs read service
    619  */
    620 int
    621 nfsrv_read(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    622 {
    623 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    624 	struct mbuf *nam = nfsd->nd_nam;
    625 	char *dpos = nfsd->nd_dpos;
    626 	kauth_cred_t cred = nfsd->nd_cr;
    627 	struct mbuf *m;
    628 	struct nfs_fattr *fp;
    629 	u_int32_t *tl;
    630 	int32_t t1;
    631 	int i;
    632 	char *bpos;
    633 	int error = 0, rdonly, cache = 0, getret;
    634 	int v3 = (nfsd->nd_flag & ND_NFSV3);
    635 	uint32_t reqlen, len, cnt, left;
    636 	int padlen;
    637 	char *cp2;
    638 	struct mbuf *mb, *mreq;
    639 	struct vnode *vp;
    640 	nfsrvfh_t nsfh;
    641 	struct uio io, *uiop = &io;
    642 	struct vattr va;
    643 	off_t off;
    644 	u_quad_t frev;
    645 
    646 	nfsm_srvmtofh(&nsfh);
    647 	if (v3) {
    648 		nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
    649 		off = fxdr_hyper(tl);
    650 	} else {
    651 		nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
    652 		off = (off_t)fxdr_unsigned(u_int32_t, *tl);
    653 	}
    654 	nfsm_dissect(tl, uint32_t *, NFSX_UNSIGNED);
    655 	reqlen = fxdr_unsigned(uint32_t, *tl);
    656 	reqlen = MIN(reqlen, NFS_SRVMAXDATA(nfsd));
    657 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
    658 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
    659 	if (error) {
    660 		nfsm_reply(2 * NFSX_UNSIGNED);
    661 		nfsm_srvpostop_attr(1, (struct vattr *)0);
    662 		return (0);
    663 	}
    664 	if (vp->v_type != VREG) {
    665 		if (v3)
    666 			error = EINVAL;
    667 		else
    668 			error = (vp->v_type == VDIR) ? EISDIR : EACCES;
    669 	}
    670 	if (!error) {
    671 	    nqsrv_getl(vp, ND_READ);
    672 	    if ((error = nfsrv_access(vp, VREAD, cred, rdonly, lwp, 1)) != 0)
    673 		error = nfsrv_access(vp, VEXEC, cred, rdonly, lwp, 1);
    674 	}
    675 	getret = VOP_GETATTR(vp, &va, cred);
    676 	if (!error)
    677 		error = getret;
    678 	if (error) {
    679 		vput(vp);
    680 		nfsm_reply(NFSX_POSTOPATTR(v3));
    681 		nfsm_srvpostop_attr(getret, &va);
    682 		return (0);
    683 	}
    684 	if (off >= va.va_size)
    685 		cnt = 0;
    686 	else if ((off + reqlen) > va.va_size)
    687 		cnt = va.va_size - off;
    688 	else
    689 		cnt = reqlen;
    690 	nfsm_reply(NFSX_POSTOPORFATTR(v3) + 3 * NFSX_UNSIGNED+nfsm_rndup(cnt));
    691 	if (v3) {
    692 		nfsm_build(tl, u_int32_t *, NFSX_V3FATTR + 4 * NFSX_UNSIGNED);
    693 		*tl++ = nfs_true;
    694 		fp = (struct nfs_fattr *)tl;
    695 		tl += (NFSX_V3FATTR / sizeof (u_int32_t));
    696 	} else {
    697 		nfsm_build(tl, u_int32_t *, NFSX_V2FATTR + NFSX_UNSIGNED);
    698 		fp = (struct nfs_fattr *)tl;
    699 		tl += (NFSX_V2FATTR / sizeof (u_int32_t));
    700 	}
    701 	len = left = cnt;
    702 	if (cnt > 0) {
    703 		if (nfsd_use_loan) {
    704 			struct vm_page **pgpp;
    705 			voff_t pgoff = trunc_page(off);
    706 			int npages;
    707 			vaddr_t lva;
    708 
    709 			npages = (round_page(off + cnt) - pgoff) >> PAGE_SHIFT;
    710 			KASSERT(npages <= M_EXT_MAXPAGES); /* XXX */
    711 
    712 			/* allocate kva for mbuf data */
    713 			lva = sokvaalloc(pgoff, npages << PAGE_SHIFT,
    714 			    slp->ns_so);
    715 			if (lva == 0) {
    716 				/* fall back to VOP_READ */
    717 				goto loan_fail;
    718 			}
    719 
    720 			/* allocate mbuf */
    721 			m = m_get(M_WAIT, MT_DATA);
    722 			MCLAIM(m, &nfs_mowner);
    723 			pgpp = m->m_ext.ext_pgs;
    724 
    725 			/* loan pages */
    726 			error = uvm_loanuobjpages(&vp->v_uobj, pgoff, npages,
    727 			    pgpp);
    728 			if (error) {
    729 				sokvafree(lva, npages << PAGE_SHIFT);
    730 				m_free(m);
    731 				if (error == EBUSY)
    732 					goto loan_fail;
    733 				goto read_error;
    734 			}
    735 
    736 			/* associate kva to mbuf */
    737 			MEXTADD(m, (void *)(lva + ((vaddr_t)off & PAGE_MASK)),
    738 			    cnt, M_MBUF, soloanfree, slp->ns_so);
    739 			m->m_flags |= M_EXT_PAGES | M_EXT_ROMAP;
    740 			m->m_len = cnt;
    741 
    742 			/* map pages */
    743 			for (i = 0; i < npages; i++) {
    744 				pmap_kenter_pa(lva, VM_PAGE_TO_PHYS(pgpp[i]),
    745 				    VM_PROT_READ, 0);
    746 				lva += PAGE_SIZE;
    747 			}
    748 
    749 			pmap_update(pmap_kernel());
    750 
    751 			mb->m_next = m;
    752 			mb = m;
    753 			error = 0;
    754 			uiop->uio_resid = 0;
    755 		} else {
    756 			struct iovec *iv;
    757 			struct iovec *iv2;
    758 			struct mbuf *m2;
    759 			int siz;
    760 loan_fail:
    761 			/*
    762 			 * Generate the mbuf list with the uio_iov ref. to it.
    763 			 */
    764 			i = 0;
    765 			m = m2 = mb;
    766 			while (left > 0) {
    767 				siz = uimin(M_TRAILINGSPACE(m), left);
    768 				if (siz > 0) {
    769 					left -= siz;
    770 					i++;
    771 				}
    772 				if (left > 0) {
    773 					m = m_get(M_WAIT, MT_DATA);
    774 					MCLAIM(m, &nfs_mowner);
    775 					m_clget(m, M_WAIT);
    776 					m->m_len = 0;
    777 					m2->m_next = m;
    778 					m2 = m;
    779 				}
    780 			}
    781 			iv = malloc(i * sizeof(struct iovec), M_TEMP, M_WAITOK);
    782 			uiop->uio_iov = iv2 = iv;
    783 			m = mb;
    784 			left = cnt;
    785 			i = 0;
    786 			while (left > 0) {
    787 				if (m == NULL)
    788 					panic("nfsrv_read iov");
    789 				siz = uimin(M_TRAILINGSPACE(m), left);
    790 				if (siz > 0) {
    791 					iv->iov_base = mtod(m, char *) +
    792 					    m->m_len;
    793 					iv->iov_len = siz;
    794 					m->m_len += siz;
    795 					left -= siz;
    796 					iv++;
    797 					i++;
    798 				}
    799 				m = m->m_next;
    800 			}
    801 			uiop->uio_iovcnt = i;
    802 			uiop->uio_offset = off;
    803 			uiop->uio_resid = cnt;
    804 			uiop->uio_rw = UIO_READ;
    805 			UIO_SETUP_SYSSPACE(uiop);
    806 			error = VOP_READ(vp, uiop, IO_NODELOCKED, cred);
    807 			free((void *)iv2, M_TEMP);
    808 		}
    809 read_error:
    810 		if (error || (getret = VOP_GETATTR(vp, &va, cred)) != 0){
    811 			if (!error)
    812 				error = getret;
    813 			m_freem(mreq);
    814 			vput(vp);
    815 			nfsm_reply(NFSX_POSTOPATTR(v3));
    816 			nfsm_srvpostop_attr(getret, &va);
    817 			return (0);
    818 		}
    819 	} else {
    820 		uiop->uio_resid = 0;
    821 	}
    822 	vput(vp);
    823 	nfsm_srvfillattr(&va, fp);
    824 	len -= uiop->uio_resid;
    825 	padlen = nfsm_padlen(len);
    826 	if (uiop->uio_resid || padlen)
    827 		nfs_zeropad(mb, uiop->uio_resid, padlen);
    828 	if (v3) {
    829 		/* count */
    830 		*tl++ = txdr_unsigned(len);
    831 		/* eof */
    832 		if (off + len >= va.va_size)
    833 			*tl++ = nfs_true;
    834 		else
    835 			*tl++ = nfs_false;
    836 	}
    837 	*tl = txdr_unsigned(len);
    838 	nfsm_srvdone;
    839 }
    840 
    841 /*
    842  * nfs write service
    843  */
    844 int
    845 nfsrv_write(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
    846 {
    847 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
    848 	struct mbuf *nam = nfsd->nd_nam;
    849 	char *dpos = nfsd->nd_dpos;
    850 	kauth_cred_t cred = nfsd->nd_cr;
    851 	struct iovec *ivp;
    852 	int i, cnt;
    853 	struct mbuf *mp;
    854 	struct nfs_fattr *fp;
    855 	struct iovec *iv;
    856 	struct vattr va, forat;
    857 	u_int32_t *tl;
    858 	int32_t t1;
    859 	char *bpos;
    860 	int error = 0, rdonly, cache = 0, len, forat_ret = 1;
    861 	int ioflags, aftat_ret = 1, retlen, zeroing, adjust;
    862 	int stable = NFSV3WRITE_FILESYNC;
    863 	int v3 = (nfsd->nd_flag & ND_NFSV3);
    864 	char *cp2;
    865 	struct mbuf *mb, *mreq __unused;
    866 	struct vnode *vp;
    867 	nfsrvfh_t nsfh;
    868 	struct uio io, *uiop = &io;
    869 	off_t off;
    870 	u_quad_t frev;
    871 
    872 	if (mrep == NULL) {
    873 		*mrq = NULL;
    874 		return (0);
    875 	}
    876 	nfsm_srvmtofh(&nsfh);
    877 	if (v3) {
    878 		nfsm_dissect(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
    879 		off = fxdr_hyper(tl);
    880 		tl += 3;
    881 		stable = fxdr_unsigned(int, *tl++);
    882 	} else {
    883 		nfsm_dissect(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
    884 		off = (off_t)fxdr_unsigned(u_int32_t, *++tl);
    885 		tl += 2;
    886 	}
    887 	retlen = len = fxdr_unsigned(int32_t, *tl);
    888 	cnt = i = 0;
    889 
    890 	/*
    891 	 * For NFS Version 2, it is not obvious what a write of zero length
    892 	 * should do, but I might as well be consistent with Version 3,
    893 	 * which is to return ok so long as there are no permission problems.
    894 	 */
    895 	if (len > 0) {
    896 		zeroing = 1;
    897 		mp = mrep;
    898 		while (mp) {
    899 			if (mp == md) {
    900 				zeroing = 0;
    901 				adjust = dpos - mtod(mp, char *);
    902 				mp->m_len -= adjust;
    903 				if (mp->m_len > 0 && adjust > 0)
    904 					NFSMADV(mp, adjust);
    905 			}
    906 			if (zeroing)
    907 				mp->m_len = 0;
    908 			else if (mp->m_len > 0) {
    909 				i += mp->m_len;
    910 				if (i > len) {
    911 					mp->m_len -= (i - len);
    912 					zeroing	= 1;
    913 				}
    914 				if (mp->m_len > 0)
    915 					cnt++;
    916 			}
    917 			mp = mp->m_next;
    918 		}
    919 	}
    920 	if (len > NFS_MAXDATA || len < 0 || i < len) {
    921 		error = EIO;
    922 		nfsm_reply(2 * NFSX_UNSIGNED);
    923 		nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
    924 		return (0);
    925 	}
    926 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
    927 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
    928 	if (error) {
    929 		nfsm_reply(2 * NFSX_UNSIGNED);
    930 		nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
    931 		return (0);
    932 	}
    933 	if (v3)
    934 		forat_ret = VOP_GETATTR(vp, &forat, cred);
    935 	if (vp->v_type != VREG) {
    936 		if (v3)
    937 			error = EINVAL;
    938 		else
    939 			error = (vp->v_type == VDIR) ? EISDIR : EACCES;
    940 	}
    941 	if (!error) {
    942 		nqsrv_getl(vp, ND_WRITE);
    943 		error = nfsrv_access(vp, VWRITE, cred, rdonly, lwp, 1);
    944 	}
    945 	if (error) {
    946 		vput(vp);
    947 		nfsm_reply(NFSX_WCCDATA(v3));
    948 		nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
    949 		return (0);
    950 	}
    951 
    952 	if (len > 0) {
    953 		ivp = malloc(cnt * sizeof (struct iovec), M_TEMP, M_WAITOK);
    954 		uiop->uio_iov = iv = ivp;
    955 		uiop->uio_iovcnt = cnt;
    956 		mp = mrep;
    957 		while (mp) {
    958 			if (mp->m_len > 0) {
    959 				ivp->iov_base = mtod(mp, void *);
    960 				ivp->iov_len = mp->m_len;
    961 				ivp++;
    962 			}
    963 			mp = mp->m_next;
    964 		}
    965 
    966 		/*
    967 		 * XXX
    968 		 * The IO_METASYNC flag indicates that all metadata (and not
    969 		 * just enough to ensure data integrity) must be written to
    970 		 * stable storage synchronously.
    971 		 * (IO_METASYNC is not yet implemented in 4.4BSD-Lite.)
    972 		 */
    973 		if (stable == NFSV3WRITE_UNSTABLE)
    974 			ioflags = IO_NODELOCKED;
    975 		else if (stable == NFSV3WRITE_DATASYNC)
    976 			ioflags = (IO_SYNC | IO_NODELOCKED);
    977 		else
    978 			ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
    979 		uiop->uio_resid = len;
    980 		uiop->uio_rw = UIO_WRITE;
    981 		uiop->uio_offset = off;
    982 		UIO_SETUP_SYSSPACE(uiop);
    983 		error = VOP_WRITE(vp, uiop, ioflags, cred);
    984 		nfsstats.srvvop_writes++;
    985 		free(iv, M_TEMP);
    986 	}
    987 	aftat_ret = VOP_GETATTR(vp, &va, cred);
    988 	vput(vp);
    989 	if (!error)
    990 		error = aftat_ret;
    991 	nfsm_reply(NFSX_PREOPATTR(v3) + NFSX_POSTOPORFATTR(v3) +
    992 		2 * NFSX_UNSIGNED + NFSX_WRITEVERF(v3));
    993 	if (v3) {
    994 		nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
    995 		if (error)
    996 			return (0);
    997 		nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
    998 		*tl++ = txdr_unsigned(retlen);
    999 		if (stable == NFSV3WRITE_UNSTABLE)
   1000 			*tl++ = txdr_unsigned(stable);
   1001 		else
   1002 			*tl++ = txdr_unsigned(NFSV3WRITE_FILESYNC);
   1003 		/*
   1004 		 * Actually, there is no need to txdr these fields,
   1005 		 * but it may make the values more human readable,
   1006 		 * for debugging purposes.
   1007 		 */
   1008 		struct timeval btv;
   1009 		getmicroboottime(&btv);
   1010 		*tl++ = txdr_unsigned(btv.tv_sec);
   1011 		*tl = txdr_unsigned(btv.tv_usec);
   1012 	} else {
   1013 		nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
   1014 		nfsm_srvfillattr(&va, fp);
   1015 	}
   1016 	nfsm_srvdone;
   1017 }
   1018 
   1019 /*
   1020  * XXX elad: the original NFSW_SAMECRED() macro also made sure the
   1021  *	     two nd_flag fields of the descriptors contained
   1022  *	     ND_KERBAUTH.
   1023  */
   1024 static int
   1025 nfsrv_samecred(kauth_cred_t cred1, kauth_cred_t cred2)
   1026 {
   1027 	int i, do_ngroups;
   1028 
   1029 	if (kauth_cred_geteuid(cred1) != kauth_cred_geteuid(cred2))
   1030 		return (0);
   1031 	if (kauth_cred_ngroups(cred1) != kauth_cred_ngroups(cred2))
   1032 		return (0);
   1033 	do_ngroups = kauth_cred_ngroups(cred1);
   1034 	for (i = 0; i < do_ngroups; i++)
   1035 		if (kauth_cred_group(cred1, i) !=
   1036 		    kauth_cred_group(cred2, i))
   1037 			return (0);
   1038 
   1039 	return (1);
   1040 }
   1041 
   1042 static struct nfsrvw_delayhash *
   1043 nfsrv_nwdelayhash(struct nfssvc_sock *slp, const nfsrvfh_t *nsfh)
   1044 {
   1045 	uint32_t hash;
   1046 
   1047 	hash = hash32_buf(NFSRVFH_DATA(nsfh), NFSRVFH_SIZE(nsfh),
   1048 	    HASH32_BUF_INIT);
   1049 	return &slp->ns_wdelayhashtbl[hash % NFS_WDELAYHASHSIZ];
   1050 }
   1051 
   1052 /*
   1053  * NFS write service with write gathering support. Called when
   1054  * nfsrvw_procrastinate > 0.
   1055  * See: Chet Juszczak, "Improving the Write Performance of an NFS Server",
   1056  * in Proc. of the Winter 1994 Usenix Conference, pg. 247-259, San Franscisco,
   1057  * Jan. 1994.
   1058  */
   1059 int
   1060 nfsrv_writegather(struct nfsrv_descript **ndp, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   1061 {
   1062 	struct timeval now;
   1063 	struct iovec *ivp;
   1064 	struct mbuf *mp;
   1065 	struct nfsrv_descript *wp, *nfsd, *owp, *swp;
   1066 	struct nfs_fattr *fp;
   1067 	int i = 0;
   1068 	struct iovec *iov;
   1069 	struct nfsrvw_delayhash *wpp;
   1070 	kauth_cred_t cred;
   1071 	struct vattr va, forat;
   1072 	u_int32_t *tl;
   1073 	int32_t t1;
   1074 	char *bpos, *dpos;
   1075 	int error = 0, rdonly, cache = 0, len = 0, forat_ret = 1;
   1076 	int ioflags, aftat_ret = 1, adjust, v3, zeroing;
   1077 	char *cp2;
   1078 	struct mbuf *mb, *mreq, *mrep, *md;
   1079 	struct vnode *vp;
   1080 	struct uio io, *uiop = &io;
   1081 	u_quad_t frev, cur_usec;
   1082 
   1083 	*mrq = NULL;
   1084 	if (*ndp) {
   1085 	    nfsd = *ndp;
   1086 	    *ndp = NULL;
   1087 	    mrep = nfsd->nd_mrep;
   1088 	    md = nfsd->nd_md;
   1089 	    dpos = nfsd->nd_dpos;
   1090 	    cred = nfsd->nd_cr;
   1091 	    v3 = (nfsd->nd_flag & ND_NFSV3);
   1092 	    LIST_INIT(&nfsd->nd_coalesce);
   1093 	    nfsd->nd_mreq = NULL;
   1094 	    nfsd->nd_stable = NFSV3WRITE_FILESYNC;
   1095 	    getmicrotime(&now);
   1096 	    cur_usec = (u_quad_t)now.tv_sec * 1000000 + (u_quad_t)now.tv_usec;
   1097 	    nfsd->nd_time = cur_usec + nfsrvw_procrastinate;
   1098 
   1099 	    /*
   1100 	     * Now, get the write header..
   1101 	     */
   1102 	    nfsm_srvmtofh(&nfsd->nd_fh);
   1103 	    if (v3) {
   1104 		nfsm_dissect(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
   1105 		nfsd->nd_off = fxdr_hyper(tl);
   1106 		tl += 3;
   1107 		nfsd->nd_stable = fxdr_unsigned(int, *tl++);
   1108 	    } else {
   1109 		nfsm_dissect(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
   1110 		nfsd->nd_off = (off_t)fxdr_unsigned(u_int32_t, *++tl);
   1111 		tl += 2;
   1112 	    }
   1113 	    len = fxdr_unsigned(int32_t, *tl);
   1114 	    nfsd->nd_len = len;
   1115 	    nfsd->nd_eoff = nfsd->nd_off + len;
   1116 
   1117 	    /*
   1118 	     * Trim the header out of the mbuf list and trim off any trailing
   1119 	     * junk so that the mbuf list has only the write data.
   1120 	     */
   1121 	    zeroing = 1;
   1122 	    i = 0;
   1123 	    mp = mrep;
   1124 	    while (mp) {
   1125 		if (mp == md) {
   1126 		    zeroing = 0;
   1127 		    adjust = dpos - mtod(mp, char *);
   1128 		    mp->m_len -= adjust;
   1129 		    if (mp->m_len > 0 && adjust > 0)
   1130 			NFSMADV(mp, adjust);
   1131 		}
   1132 		if (zeroing)
   1133 		    mp->m_len = 0;
   1134 		else {
   1135 		    i += mp->m_len;
   1136 		    if (i > len) {
   1137 			mp->m_len -= (i - len);
   1138 			zeroing = 1;
   1139 		    }
   1140 		}
   1141 		mp = mp->m_next;
   1142 	    }
   1143 	    if (len > NFS_MAXDATA || len < 0  || i < len) {
   1144 nfsmout:
   1145 		m_freem(mrep);
   1146 		error = EIO;
   1147 		nfsm_writereply(2 * NFSX_UNSIGNED, v3);
   1148 		if (v3)
   1149 		    nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
   1150 		nfsd->nd_mreq = mreq;
   1151 		nfsd->nd_mrep = NULL;
   1152 		nfsd->nd_time = 0;
   1153 	    }
   1154 
   1155 	    /*
   1156 	     * Add this entry to the hash and time queues.
   1157 	     */
   1158 	    owp = NULL;
   1159 	    mutex_enter(&nfsd_lock);
   1160 	    wp = LIST_FIRST(&slp->ns_tq);
   1161 	    while (wp && wp->nd_time < nfsd->nd_time) {
   1162 		owp = wp;
   1163 		wp = LIST_NEXT(wp, nd_tq);
   1164 	    }
   1165 	    if (owp) {
   1166 		LIST_INSERT_AFTER(owp, nfsd, nd_tq);
   1167 	    } else {
   1168 		LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
   1169 	    }
   1170 	    if (nfsd->nd_mrep) {
   1171 		wpp = nfsrv_nwdelayhash(slp, &nfsd->nd_fh);
   1172 		owp = NULL;
   1173 		wp = LIST_FIRST(wpp);
   1174 		while (wp && nfsrv_comparefh(&nfsd->nd_fh, &wp->nd_fh)) {
   1175 		    owp = wp;
   1176 		    wp = LIST_NEXT(wp, nd_hash);
   1177 		}
   1178 		while (wp && wp->nd_off < nfsd->nd_off &&
   1179 		    !nfsrv_comparefh(&nfsd->nd_fh, &wp->nd_fh)) {
   1180 		    owp = wp;
   1181 		    wp = LIST_NEXT(wp, nd_hash);
   1182 		}
   1183 		if (owp) {
   1184 		    LIST_INSERT_AFTER(owp, nfsd, nd_hash);
   1185 
   1186 		    /*
   1187 		     * Search the hash list for overlapping entries and
   1188 		     * coalesce.
   1189 		     */
   1190 		    for(; nfsd && NFSW_CONTIG(owp, nfsd); nfsd = wp) {
   1191 			wp = LIST_NEXT(nfsd, nd_hash);
   1192 			if (nfsrv_samecred(owp->nd_cr, nfsd->nd_cr))
   1193 			    nfsrvw_coalesce(owp, nfsd);
   1194 		    }
   1195 		} else {
   1196 		    LIST_INSERT_HEAD(wpp, nfsd, nd_hash);
   1197 		}
   1198 	    }
   1199 	    mutex_exit(&nfsd_lock);
   1200 	}
   1201 
   1202 	/*
   1203 	 * Now, do VOP_WRITE()s for any one(s) that need to be done now
   1204 	 * and generate the associated reply mbuf list(s).
   1205 	 */
   1206 loop1:
   1207 	getmicrotime(&now);
   1208 	cur_usec = (u_quad_t)now.tv_sec * 1000000 + (u_quad_t)now.tv_usec;
   1209 	mutex_enter(&nfsd_lock);
   1210 	for (nfsd = LIST_FIRST(&slp->ns_tq); nfsd; nfsd = owp) {
   1211 		owp = LIST_NEXT(nfsd, nd_tq);
   1212 		if (nfsd->nd_time > cur_usec)
   1213 		    break;
   1214 		if (nfsd->nd_mreq)
   1215 		    continue;
   1216 		LIST_REMOVE(nfsd, nd_tq);
   1217 		LIST_REMOVE(nfsd, nd_hash);
   1218 		mutex_exit(&nfsd_lock);
   1219 
   1220 		mrep = nfsd->nd_mrep;
   1221 		nfsd->nd_mrep = NULL;
   1222 		cred = nfsd->nd_cr;
   1223 		v3 = (nfsd->nd_flag & ND_NFSV3);
   1224 		forat_ret = aftat_ret = 1;
   1225 		error = nfsrv_fhtovp(&nfsd->nd_fh, 1, &vp, cred, slp,
   1226 		    nfsd->nd_nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH),
   1227 		    false);
   1228 		if (!error) {
   1229 		    if (v3)
   1230 			forat_ret = VOP_GETATTR(vp, &forat, cred);
   1231 		    if (vp->v_type != VREG) {
   1232 			if (v3)
   1233 			    error = EINVAL;
   1234 			else
   1235 			    error = (vp->v_type == VDIR) ? EISDIR : EACCES;
   1236 		    }
   1237 		} else
   1238 		    vp = NULL;
   1239 		if (!error) {
   1240 		    nqsrv_getl(vp, ND_WRITE);
   1241 		    error = nfsrv_access(vp, VWRITE, cred, rdonly, lwp, 1);
   1242 		}
   1243 
   1244 		if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE)
   1245 		    ioflags = IO_NODELOCKED;
   1246 		else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC)
   1247 		    ioflags = (IO_SYNC | IO_NODELOCKED);
   1248 		else
   1249 		    ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
   1250 		uiop->uio_rw = UIO_WRITE;
   1251 		uiop->uio_offset = nfsd->nd_off;
   1252 		uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
   1253 		UIO_SETUP_SYSSPACE(uiop);
   1254 		if (uiop->uio_resid > 0) {
   1255 		    mp = mrep;
   1256 		    i = 0;
   1257 		    while (mp) {
   1258 			if (mp->m_len > 0)
   1259 			    i++;
   1260 			mp = mp->m_next;
   1261 		    }
   1262 		    uiop->uio_iovcnt = i;
   1263 		    iov = malloc(i * sizeof (struct iovec), M_TEMP, M_WAITOK);
   1264 		    uiop->uio_iov = ivp = iov;
   1265 		    mp = mrep;
   1266 		    while (mp) {
   1267 			if (mp->m_len > 0) {
   1268 			    ivp->iov_base = mtod(mp, void *);
   1269 			    ivp->iov_len = mp->m_len;
   1270 			    ivp++;
   1271 			}
   1272 			mp = mp->m_next;
   1273 		    }
   1274 		    if (!error) {
   1275 			error = VOP_WRITE(vp, uiop, ioflags, cred);
   1276 			nfsstats.srvvop_writes++;
   1277 		    }
   1278 		    free((void *)iov, M_TEMP);
   1279 		}
   1280 		m_freem(mrep);
   1281 		if (vp) {
   1282 		    aftat_ret = VOP_GETATTR(vp, &va, cred);
   1283 		    vput(vp);
   1284 		}
   1285 
   1286 		/*
   1287 		 * Loop around generating replies for all write rpcs that have
   1288 		 * now been completed.
   1289 		 */
   1290 		swp = nfsd;
   1291 		do {
   1292 		    if (error) {
   1293 			nfsm_writereply(NFSX_WCCDATA(v3), v3);
   1294 			if (v3) {
   1295 			    nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
   1296 			}
   1297 		    } else {
   1298 			nfsm_writereply(NFSX_PREOPATTR(v3) +
   1299 			    NFSX_POSTOPORFATTR(v3) + 2 * NFSX_UNSIGNED +
   1300 			    NFSX_WRITEVERF(v3), v3);
   1301 			if (v3) {
   1302 			    nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
   1303 			    nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
   1304 			    *tl++ = txdr_unsigned(nfsd->nd_len);
   1305 			    *tl++ = txdr_unsigned(swp->nd_stable);
   1306 			    /*
   1307 			     * Actually, there is no need to txdr these fields,
   1308 			     * but it may make the values more human readable,
   1309 			     * for debugging purposes.
   1310 			     */
   1311 			    struct timeval btv;
   1312 			    getmicroboottime(&btv);
   1313 			    *tl++ = txdr_unsigned(btv.tv_sec);
   1314 			    *tl = txdr_unsigned(btv.tv_usec);
   1315 			} else {
   1316 			    nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
   1317 			    nfsm_srvfillattr(&va, fp);
   1318 			}
   1319 		    }
   1320 		    nfsd->nd_mreq = mreq;
   1321 		    if (nfsd->nd_mrep)
   1322 			panic("nfsrv_write: nd_mrep not free");
   1323 
   1324 		    /*
   1325 		     * Done. Put it at the head of the timer queue so that
   1326 		     * the final phase can return the reply.
   1327 		     */
   1328 		    mutex_enter(&nfsd_lock);
   1329 		    if (nfsd != swp) {
   1330 			nfsd->nd_time = 0;
   1331 			LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
   1332 		    }
   1333 		    nfsd = LIST_FIRST(&swp->nd_coalesce);
   1334 		    if (nfsd) {
   1335 			LIST_REMOVE(nfsd, nd_tq);
   1336 		    }
   1337 		    mutex_exit(&nfsd_lock);
   1338 		} while (nfsd);
   1339 		swp->nd_time = 0;
   1340 
   1341 		mutex_enter(&nfsd_lock);
   1342 		LIST_INSERT_HEAD(&slp->ns_tq, swp, nd_tq);
   1343 		mutex_exit(&nfsd_lock);
   1344 		goto loop1;
   1345 	}
   1346 	mutex_exit(&nfsd_lock);
   1347 	nfs_timer_start();
   1348 
   1349 	/*
   1350 	 * Search for a reply to return.
   1351 	 */
   1352 	mutex_enter(&nfsd_lock);
   1353 	LIST_FOREACH(nfsd, &slp->ns_tq, nd_tq) {
   1354 		if (nfsd->nd_mreq) {
   1355 		    LIST_REMOVE(nfsd, nd_tq);
   1356 		    *mrq = nfsd->nd_mreq;
   1357 		    *ndp = nfsd;
   1358 		    break;
   1359 		}
   1360 	}
   1361 	mutex_exit(&nfsd_lock);
   1362 	return (0);
   1363 }
   1364 
   1365 /*
   1366  * Coalesce the write request nfsd into owp. To do this we must:
   1367  * - remove nfsd from the queues
   1368  * - merge nfsd->nd_mrep into owp->nd_mrep
   1369  * - update the nd_eoff and nd_stable for owp
   1370  * - put nfsd on owp's nd_coalesce list
   1371  * NB: Must be called at splsoftclock().
   1372  */
   1373 void
   1374 nfsrvw_coalesce(struct nfsrv_descript *owp, struct nfsrv_descript *nfsd)
   1375 {
   1376         int overlap;
   1377         struct mbuf *mp;
   1378 	struct nfsrv_descript *m;
   1379 
   1380 	KASSERT(mutex_owned(&nfsd_lock));
   1381 
   1382         LIST_REMOVE(nfsd, nd_hash);
   1383         LIST_REMOVE(nfsd, nd_tq);
   1384         if (owp->nd_eoff < nfsd->nd_eoff) {
   1385             overlap = owp->nd_eoff - nfsd->nd_off;
   1386             if (overlap < 0)
   1387                 panic("nfsrv_coalesce: bad off");
   1388             if (overlap > 0)
   1389                 m_adj(nfsd->nd_mrep, overlap);
   1390             mp = owp->nd_mrep;
   1391             while (mp->m_next)
   1392                 mp = mp->m_next;
   1393             mp->m_next = nfsd->nd_mrep;
   1394             owp->nd_eoff = nfsd->nd_eoff;
   1395         } else
   1396             m_freem(nfsd->nd_mrep);
   1397         nfsd->nd_mrep = NULL;
   1398         if (nfsd->nd_stable == NFSV3WRITE_FILESYNC)
   1399             owp->nd_stable = NFSV3WRITE_FILESYNC;
   1400         else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC &&
   1401             owp->nd_stable == NFSV3WRITE_UNSTABLE)
   1402             owp->nd_stable = NFSV3WRITE_DATASYNC;
   1403         LIST_INSERT_HEAD(&owp->nd_coalesce, nfsd, nd_tq);
   1404  	/*
   1405  	 * nfsd might hold coalesce elements! Move them to owp.
   1406  	 * Otherwise, requests may be lost and clients will be stuck.
   1407  	 */
   1408 	while ((m = LIST_FIRST(&nfsd->nd_coalesce)) != NULL) {
   1409 		LIST_REMOVE(m, nd_tq);
   1410 		LIST_INSERT_HEAD(&owp->nd_coalesce, m, nd_tq);
   1411 	}
   1412 }
   1413 
   1414 /*
   1415  * nfs create service
   1416  * now does a truncate to 0 length via. setattr if it already exists
   1417  */
   1418 int
   1419 nfsrv_create(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   1420 {
   1421 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   1422 	struct mbuf *nam = nfsd->nd_nam;
   1423 	char *dpos = nfsd->nd_dpos;
   1424 	kauth_cred_t cred = nfsd->nd_cr;
   1425 	struct nfs_fattr *fp;
   1426 	struct vattr va, dirfor, diraft;
   1427 	struct nfsv2_sattr *sp;
   1428 	u_int32_t *tl;
   1429 	struct nameidata nd;
   1430 	char *cp;
   1431 	int32_t t1;
   1432 	char *bpos;
   1433 	int error = 0, cache = 0, len, tsize, dirfor_ret = 1, diraft_ret = 1;
   1434 	int rdev = 0, abort = 0;
   1435 	int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
   1436 	char *cp2;
   1437 	struct mbuf *mb, *mreq __unused;
   1438 	struct vnode *vp = NULL, *dirp = NULL;
   1439 	nfsrvfh_t nsfh;
   1440 	u_quad_t frev, tempsize;
   1441 	u_char cverf[NFSX_V3CREATEVERF];
   1442 
   1443 	nd.ni_cnd.cn_nameiop = 0;
   1444 	nfsm_srvmtofh(&nsfh);
   1445 	nfsm_srvnamesiz(len);
   1446 	nd.ni_cnd.cn_cred = cred;
   1447 	nd.ni_cnd.cn_nameiop = CREATE;
   1448 	nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
   1449 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
   1450 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   1451 	if (dirp && v3) {
   1452 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   1453 	}
   1454 	if (error) {
   1455 		nfsm_reply(NFSX_WCCDATA(v3));
   1456 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   1457 		if (dirp)
   1458 			vrele(dirp);
   1459 		if (nd.ni_pathbuf != NULL) {
   1460 			pathbuf_destroy(nd.ni_pathbuf);
   1461 			nd.ni_pathbuf = NULL;
   1462 		}
   1463 		return (0);
   1464 	}
   1465 	abort = 1;
   1466 	vattr_null(&va);
   1467 	if (v3) {
   1468 		va.va_mode = 0;
   1469 		nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   1470 		how = fxdr_unsigned(int, *tl);
   1471 		switch (how) {
   1472 		case NFSV3CREATE_GUARDED:
   1473 			if (nd.ni_vp) {
   1474 				error = EEXIST;
   1475 				break;
   1476 			}
   1477 			/* FALLTHROUGH */
   1478 		case NFSV3CREATE_UNCHECKED:
   1479 			nfsm_srvsattr(&va);
   1480 			break;
   1481 		case NFSV3CREATE_EXCLUSIVE:
   1482 			nfsm_dissect(cp, void *, NFSX_V3CREATEVERF);
   1483 			memcpy(cverf, cp, NFSX_V3CREATEVERF);
   1484 			exclusive_flag = 1;
   1485 			break;
   1486 		};
   1487 		va.va_type = VREG;
   1488 	} else {
   1489 		nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
   1490 		va.va_type = IFTOVT(fxdr_unsigned(u_int32_t, sp->sa_mode));
   1491 		if (va.va_type == VNON)
   1492 			va.va_type = VREG;
   1493 		va.va_mode = nfstov_mode(sp->sa_mode);
   1494 		switch (va.va_type) {
   1495 		case VREG:
   1496 			tsize = fxdr_unsigned(int32_t, sp->sa_size);
   1497 			if (tsize != -1)
   1498 				va.va_size = (u_quad_t)tsize;
   1499 			break;
   1500 		case VCHR:
   1501 		case VBLK:
   1502 		case VFIFO:
   1503 			rdev = fxdr_unsigned(int32_t, sp->sa_size);
   1504 			break;
   1505 		default:
   1506 			break;
   1507 		};
   1508 	}
   1509 
   1510 	/*
   1511 	 * Iff doesn't exist, create it
   1512 	 * otherwise just truncate to 0 length
   1513 	 *   should I set the mode too ??
   1514 	 */
   1515 	if (nd.ni_vp == NULL) {
   1516 		if (va.va_type == VREG || va.va_type == VSOCK) {
   1517 			nqsrv_getl(nd.ni_dvp, ND_WRITE);
   1518 			error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &va);
   1519 			if (!error) {
   1520 				vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY);
   1521 				if (exclusive_flag) {
   1522 					exclusive_flag = 0;
   1523 					vattr_null(&va);
   1524 					/*
   1525 					 * XXX
   1526 					 * assuming NFSX_V3CREATEVERF
   1527 					 * == sizeof(nfstime3)
   1528 					 */
   1529 					fxdr_nfsv3time(cverf, &va.va_atime);
   1530 					error = VOP_SETATTR(nd.ni_vp, &va,
   1531 						cred);
   1532 				}
   1533 			}
   1534 		} else if (va.va_type == VCHR || va.va_type == VBLK ||
   1535 			va.va_type == VFIFO) {
   1536 			if (va.va_type == VCHR && rdev == 0xffffffff)
   1537 				va.va_type = VFIFO;
   1538 			if (va.va_type != VFIFO &&
   1539 			    (error = kauth_authorize_system(cred,
   1540 			    KAUTH_SYSTEM_MKNOD, 0, NULL, NULL, NULL))) {
   1541 				VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1542 				vput(nd.ni_dvp);
   1543 				abort = 0;
   1544 				nfsm_reply(0);
   1545 				if (nd.ni_pathbuf != NULL) {
   1546 					pathbuf_destroy(nd.ni_pathbuf);
   1547 					nd.ni_pathbuf = NULL;
   1548 				}
   1549 				return (error);
   1550 			} else
   1551 				va.va_rdev = (dev_t)rdev;
   1552 			nqsrv_getl(nd.ni_dvp, ND_WRITE);
   1553 			error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd,
   1554 			    &va);
   1555 			if (!error) {
   1556 				vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY);
   1557 			} else {
   1558 				nfsm_reply(0);
   1559 			}
   1560 		} else {
   1561 			VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1562 			if (nd.ni_pathbuf != NULL) {
   1563 				pathbuf_destroy(nd.ni_pathbuf);
   1564 				nd.ni_pathbuf = NULL;
   1565 			}
   1566 			error = ENXIO;
   1567 			abort = 0;
   1568 		}
   1569 		vp = nd.ni_vp;
   1570 	} else {
   1571 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1572 		if (nd.ni_pathbuf != NULL) {
   1573 			pathbuf_destroy(nd.ni_pathbuf);
   1574 			nd.ni_pathbuf = NULL;
   1575 		}
   1576 		vp = nd.ni_vp;
   1577 		abort = 0;
   1578 		if (!error && va.va_size != -1) {
   1579 			error = nfsrv_access(vp, VWRITE, cred,
   1580 			    (nd.ni_cnd.cn_flags & RDONLY), lwp, 0);
   1581 			if (!error) {
   1582 				nqsrv_getl(vp, ND_WRITE);
   1583 				tempsize = va.va_size;
   1584 				vattr_null(&va);
   1585 				va.va_size = tempsize;
   1586 				error = VOP_SETATTR(vp, &va, cred);
   1587 			}
   1588 		}
   1589 		if (error)
   1590 			vput(vp);
   1591 	}
   1592 	if (!error) {
   1593 		error = nfsrv_composefh(vp, &nsfh, v3);
   1594 		if (!error)
   1595 			error = VOP_GETATTR(vp, &va, cred);
   1596 		vput(vp);
   1597 	}
   1598 	if (nd.ni_dvp == vp)
   1599 		vrele(nd.ni_dvp);
   1600 	else
   1601 		vput(nd.ni_dvp);
   1602 	if (v3) {
   1603 		if (exclusive_flag && !error) {
   1604 			/*
   1605 			 * XXX assuming NFSX_V3CREATEVERF == sizeof(nfstime3)
   1606 			 */
   1607 			char oldverf[NFSX_V3CREATEVERF];
   1608 
   1609 			txdr_nfsv3time(&va.va_atime, oldverf);
   1610 			if (memcmp(cverf, oldverf, NFSX_V3CREATEVERF))
   1611 				error = EEXIST;
   1612 		}
   1613 		if (dirp) {
   1614 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   1615 			diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   1616 			VOP_UNLOCK(dirp);
   1617 		}
   1618 	}
   1619 	if (dirp) {
   1620 		vrele(dirp);
   1621 		dirp = NULL;
   1622 	}
   1623 	if (nd.ni_pathbuf != NULL) {
   1624 		pathbuf_destroy(nd.ni_pathbuf);
   1625 		nd.ni_pathbuf = NULL;
   1626 	}
   1627 	abort = 0;
   1628 	nfsm_reply(NFSX_SRVFH(&nsfh, v3) + NFSX_FATTR(v3) + NFSX_WCCDATA(v3));
   1629 	if (v3) {
   1630 		if (!error) {
   1631 			nfsm_srvpostop_fh(&nsfh);
   1632 			nfsm_srvpostop_attr(0, &va);
   1633 		}
   1634 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   1635 	} else {
   1636 		nfsm_srvfhtom(&nsfh, v3);
   1637 		nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
   1638 		nfsm_srvfillattr(&va, fp);
   1639 	}
   1640 	return (0);
   1641 nfsmout:
   1642 	if (dirp)
   1643 		vrele(dirp);
   1644 	if (abort) {
   1645 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1646 		if (nd.ni_dvp == nd.ni_vp)
   1647 			vrele(nd.ni_dvp);
   1648 		else
   1649 			vput(nd.ni_dvp);
   1650 		if (nd.ni_vp)
   1651 			vput(nd.ni_vp);
   1652 	}
   1653 	if (nd.ni_pathbuf != NULL) {
   1654 		pathbuf_destroy(nd.ni_pathbuf);
   1655 		nd.ni_pathbuf = NULL;
   1656 	}
   1657 	return (error);
   1658 }
   1659 
   1660 /*
   1661  * nfs v3 mknod service
   1662  */
   1663 int
   1664 nfsrv_mknod(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   1665 {
   1666 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   1667 	struct mbuf *nam = nfsd->nd_nam;
   1668 	char *dpos = nfsd->nd_dpos;
   1669 	kauth_cred_t cred = nfsd->nd_cr;
   1670 	struct vattr va, dirfor, diraft;
   1671 	u_int32_t *tl;
   1672 	struct nameidata nd;
   1673 	int32_t t1;
   1674 	char *bpos;
   1675 	int error = 0, cache = 0, len, dirfor_ret = 1, diraft_ret = 1;
   1676 	int abort = 0;
   1677 	u_int32_t major, minor;
   1678 	enum vtype vtyp;
   1679 	char *cp2;
   1680 	struct mbuf *mb, *mreq __unused;
   1681 	struct vnode *vp, *dirp = (struct vnode *)0;
   1682 	nfsrvfh_t nsfh;
   1683 	u_quad_t frev;
   1684 
   1685 	nd.ni_cnd.cn_nameiop = 0;
   1686 	nfsm_srvmtofh(&nsfh);
   1687 	nfsm_srvnamesiz(len);
   1688 	nd.ni_cnd.cn_cred = cred;
   1689 	nd.ni_cnd.cn_nameiop = CREATE;
   1690 	nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
   1691 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
   1692 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   1693 	if (dirp)
   1694 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   1695 	if (error) {
   1696 		nfsm_reply(NFSX_WCCDATA(1));
   1697 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   1698 		if (dirp)
   1699 			vrele(dirp);
   1700 		if (nd.ni_pathbuf != NULL) {
   1701 			pathbuf_destroy(nd.ni_pathbuf);
   1702 			nd.ni_pathbuf = NULL;
   1703 		}
   1704 		return (0);
   1705 	}
   1706 	abort = 1;
   1707 	nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   1708 	vtyp = nfsv3tov_type(*tl);
   1709 	if (vtyp != VCHR && vtyp != VBLK && vtyp != VSOCK && vtyp != VFIFO) {
   1710 		error = NFSERR_BADTYPE;
   1711 		goto abort;
   1712 	}
   1713 	vattr_null(&va);
   1714 	va.va_mode = 0;
   1715 	nfsm_srvsattr(&va);
   1716 	if (vtyp == VCHR || vtyp == VBLK) {
   1717 		dev_t rdev;
   1718 
   1719 		nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   1720 		major = fxdr_unsigned(u_int32_t, *tl++);
   1721 		minor = fxdr_unsigned(u_int32_t, *tl);
   1722 		rdev = makedev(major, minor);
   1723 		if (major(rdev) != major || minor(rdev) != minor) {
   1724 			error = EINVAL;
   1725 			goto abort;
   1726 		}
   1727 		va.va_rdev = rdev;
   1728 	}
   1729 
   1730 	/*
   1731 	 * Iff doesn't exist, create it.
   1732 	 */
   1733 	if (nd.ni_vp) {
   1734 		error = EEXIST;
   1735 abort:
   1736 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1737 		if (nd.ni_vp)
   1738 			vput(nd.ni_vp);
   1739 		if (nd.ni_pathbuf != NULL) {
   1740 			pathbuf_destroy(nd.ni_pathbuf);
   1741 			nd.ni_pathbuf = NULL;
   1742 		}
   1743 		goto out;
   1744 	}
   1745 	va.va_type = vtyp;
   1746 	if (vtyp == VSOCK) {
   1747 		nqsrv_getl(nd.ni_dvp, ND_WRITE);
   1748 		error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &va);
   1749 	} else {
   1750 		if (va.va_type != VFIFO &&
   1751 		    (error = kauth_authorize_system(cred,
   1752 		    KAUTH_SYSTEM_MKNOD, 0, NULL, NULL, NULL))) {
   1753 			VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1754 			vput(nd.ni_dvp);
   1755 			goto out;
   1756 		}
   1757 		nqsrv_getl(nd.ni_dvp, ND_WRITE);
   1758 		error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &va);
   1759 		if (error)
   1760 			goto out;
   1761 	}
   1762 	if (!error) {
   1763 		vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY);
   1764 	}
   1765 out:
   1766 	vp = nd.ni_vp;
   1767 	if (!error) {
   1768 		error = nfsrv_composefh(vp, &nsfh, true);
   1769 		if (!error)
   1770 			error = VOP_GETATTR(vp, &va, cred);
   1771 		vput(vp);
   1772 	}
   1773 	if (nd.ni_dvp == nd.ni_vp)
   1774 		vrele(nd.ni_dvp);
   1775 	else
   1776 		vput(nd.ni_dvp);
   1777 	if (dirp) {
   1778 		vn_lock(dirp, LK_SHARED | LK_RETRY);
   1779 		diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   1780 		VOP_UNLOCK(dirp);
   1781 		vrele(dirp);
   1782 		dirp = NULL;
   1783 	}
   1784 	if (nd.ni_pathbuf != NULL) {
   1785 		pathbuf_destroy(nd.ni_pathbuf);
   1786 		nd.ni_pathbuf = NULL;
   1787 	}
   1788 	abort = 0;
   1789 	nfsm_reply(NFSX_SRVFH(&nsfh, true) + NFSX_POSTOPATTR(1) +
   1790 	    NFSX_WCCDATA(1));
   1791 	if (!error) {
   1792 		nfsm_srvpostop_fh(&nsfh);
   1793 		nfsm_srvpostop_attr(0, &va);
   1794 	}
   1795 	nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   1796 	return (0);
   1797 nfsmout:
   1798 	if (abort) {
   1799 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1800 		if (nd.ni_dvp == nd.ni_vp)
   1801 			vrele(nd.ni_dvp);
   1802 		else
   1803 			vput(nd.ni_dvp);
   1804 		if (nd.ni_vp)
   1805 			vput(nd.ni_vp);
   1806 	}
   1807 	if (nd.ni_pathbuf != NULL) {
   1808 		pathbuf_destroy(nd.ni_pathbuf);
   1809 		nd.ni_pathbuf = NULL;
   1810 	}
   1811 	if (dirp)
   1812 		vrele(dirp);
   1813 	return (error);
   1814 }
   1815 
   1816 /*
   1817  * nfs remove service
   1818  */
   1819 int
   1820 nfsrv_remove(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   1821 {
   1822 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   1823 	struct mbuf *nam = nfsd->nd_nam;
   1824 	char *dpos = nfsd->nd_dpos;
   1825 	kauth_cred_t cred = nfsd->nd_cr;
   1826 	struct nameidata nd;
   1827 	u_int32_t *tl;
   1828 	int32_t t1;
   1829 	char *bpos;
   1830 	int error = 0, cache = 0, len, dirfor_ret = 1, diraft_ret = 1;
   1831 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   1832 	char *cp2;
   1833 	struct mbuf *mb, *mreq __unused;
   1834 	struct vnode *vp, *dirp;
   1835 	struct vattr dirfor, diraft;
   1836 	nfsrvfh_t nsfh;
   1837 	u_quad_t frev;
   1838 
   1839 #ifndef nolint
   1840 	vp = (struct vnode *)0;
   1841 #endif
   1842 	nfsm_srvmtofh(&nsfh);
   1843 	nfsm_srvnamesiz(len);
   1844 	nd.ni_cnd.cn_cred = cred;
   1845 	nd.ni_cnd.cn_nameiop = DELETE;
   1846 	nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
   1847 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
   1848 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   1849 	if (error == 0 && dirp && v3) {
   1850 		if (nd.ni_dvp == nd.ni_vp)
   1851 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   1852 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   1853 		if (nd.ni_dvp == nd.ni_vp)
   1854 			VOP_UNLOCK(dirp);
   1855 	}
   1856 	if (!error) {
   1857 		vp = nd.ni_vp;
   1858 		if (vp->v_type == VDIR) {
   1859 			error = EPERM;
   1860 			goto out;
   1861 		}
   1862 		/*
   1863 		 * The root of a mounted filesystem cannot be deleted.
   1864 		 */
   1865 		if (vp->v_vflag & VV_ROOT) {
   1866 			error = EBUSY;
   1867 		}
   1868 out:
   1869 		if (!error) {
   1870 			nqsrv_getl(nd.ni_dvp, ND_WRITE);
   1871 			nqsrv_getl(vp, ND_WRITE);
   1872 			error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
   1873 			vput(nd.ni_dvp);
   1874 		} else {
   1875 			VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   1876 			if (nd.ni_dvp == vp)
   1877 				vrele(nd.ni_dvp);
   1878 			else
   1879 				vput(nd.ni_dvp);
   1880 			vput(vp);
   1881 		}
   1882 	}
   1883 	if (nd.ni_pathbuf != NULL) {
   1884 		pathbuf_destroy(nd.ni_pathbuf);
   1885 		nd.ni_pathbuf = NULL;
   1886 	}
   1887 	if (dirp) {
   1888 		if (v3) {
   1889 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   1890 			diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   1891 			VOP_UNLOCK(dirp);
   1892 		}
   1893 		vrele(dirp);
   1894 	}
   1895 	nfsm_reply(NFSX_WCCDATA(v3));
   1896 	if (v3) {
   1897 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   1898 		return (0);
   1899 	}
   1900 	nfsm_srvdone;
   1901 }
   1902 
   1903 /*
   1904  * nfs rename service
   1905  */
   1906 int
   1907 nfsrv_rename(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   1908 {
   1909 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   1910 	struct mbuf *nam = nfsd->nd_nam;
   1911 	char *dpos = nfsd->nd_dpos;
   1912 	kauth_cred_t cred = nfsd->nd_cr;
   1913 	u_int32_t *tl;
   1914 	int32_t t1;
   1915 	char *bpos;
   1916 	int error = 0, cache = 0, fdirfor_ret = 1, fdiraft_ret = 1;
   1917 	uint32_t len, len2;
   1918 	int tdirfor_ret = 1, tdiraft_ret = 1;
   1919 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   1920 	char *cp2;
   1921 	struct mbuf *mb, *mreq __unused;
   1922 	struct nameidata fromnd, tond;
   1923 	struct vnode *fvp, *tvp, *tdvp;
   1924 	struct vnode *fdirp = NULL, *tdirp = NULL;
   1925 	struct mount *localfs = NULL;
   1926 	struct vattr fdirfor, fdiraft, tdirfor, tdiraft;
   1927 	nfsrvfh_t fnsfh, tnsfh;
   1928 	u_quad_t frev;
   1929 	uid_t saved_uid;
   1930 
   1931 #ifndef nolint
   1932 	fvp = (struct vnode *)0;
   1933 #endif
   1934 	fromnd.ni_cnd.cn_nameiop = 0;
   1935 	tond.ni_cnd.cn_nameiop = 0;
   1936 	nfsm_srvmtofh(&fnsfh);
   1937 	nfsm_srvnamesiz(len);
   1938 	/*
   1939 	 * Remember our original uid so that we can reset cr_uid before
   1940 	 * the second nfs_namei() call, in case it is remapped.
   1941 	 */
   1942 	saved_uid = kauth_cred_geteuid(cred);
   1943 	fromnd.ni_cnd.cn_cred = cred;
   1944 	fromnd.ni_cnd.cn_nameiop = DELETE;
   1945 	fromnd.ni_cnd.cn_flags = LOCKPARENT;
   1946 	error = nfs_namei(&fromnd, &fnsfh, len, slp, nam, &md,
   1947 		&dpos, &fdirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   1948 	if (error == 0 && fdirp && v3) {
   1949 		if (fromnd.ni_dvp == fromnd.ni_vp)
   1950 			vn_lock(fdirp, LK_SHARED | LK_RETRY);
   1951 		fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred);
   1952 		if (fromnd.ni_dvp == fromnd.ni_vp)
   1953 			VOP_UNLOCK(fdirp);
   1954 	}
   1955 	if (error) {
   1956 		fromnd.ni_cnd.cn_nameiop = 0;
   1957 		nfsm_reply(2 * NFSX_WCCDATA(v3));
   1958 		nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
   1959 		nfsm_srvwcc_data(tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
   1960 		if (fdirp)
   1961 			vrele(fdirp);
   1962 		if (fromnd.ni_pathbuf != NULL) {
   1963 			pathbuf_destroy(fromnd.ni_pathbuf);
   1964 		}
   1965 		return (0);
   1966 	}
   1967 	localfs = fromnd.ni_dvp->v_mount;
   1968 	fstrans_start(localfs);
   1969 	if (fromnd.ni_dvp != fromnd.ni_vp) {
   1970 		VOP_UNLOCK(fromnd.ni_dvp);
   1971 	}
   1972 	fvp = fromnd.ni_vp;
   1973 
   1974 	error = VFS_RENAMELOCK_ENTER(localfs);
   1975 	if (error) {
   1976 		VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
   1977 		vrele(fromnd.ni_dvp);
   1978 		vrele(fvp);
   1979 		goto out1;
   1980 	}
   1981 
   1982 	/* Copied, regrettably, from vfs_syscalls.c (q.v.) */
   1983 	vrele(fvp);
   1984 	if ((fromnd.ni_cnd.cn_namelen == 1 &&
   1985 	     fromnd.ni_cnd.cn_nameptr[0] == '.') ||
   1986 	    (fromnd.ni_cnd.cn_namelen == 2 &&
   1987 	     fromnd.ni_cnd.cn_nameptr[0] == '.' &&
   1988 	     fromnd.ni_cnd.cn_nameptr[1] == '.')) {
   1989 		error = EINVAL;
   1990 		VFS_RENAMELOCK_EXIT(localfs);
   1991 		VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
   1992 		vrele(fromnd.ni_dvp);
   1993 		goto out1;
   1994 	}
   1995 	vn_lock(fromnd.ni_dvp, LK_EXCLUSIVE | LK_RETRY);
   1996 	error = relookup(fromnd.ni_dvp, &fromnd.ni_vp, &fromnd.ni_cnd, 0);
   1997 	if (error) {
   1998 		VOP_UNLOCK(fromnd.ni_dvp);
   1999 		VFS_RENAMELOCK_EXIT(localfs);
   2000 		VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
   2001 		vrele(fromnd.ni_dvp);
   2002 		goto out1;
   2003 	}
   2004 	VOP_UNLOCK(fromnd.ni_vp);
   2005 	if (fromnd.ni_dvp != fromnd.ni_vp)
   2006 		VOP_UNLOCK(fromnd.ni_dvp);
   2007 	fvp = fromnd.ni_vp;
   2008 
   2009 	nfsm_srvmtofh(&tnsfh);
   2010 	if (v3) {
   2011 		nfsm_dissect(tl, uint32_t *, NFSX_UNSIGNED);
   2012 		len2 = fxdr_unsigned(uint32_t, *tl);
   2013 		/* len2 will be checked by nfs_namei */
   2014 	}
   2015 	else {
   2016 		/* NFSv2 */
   2017 		nfsm_strsiz(len2, NFS_MAXNAMLEN);
   2018 	}
   2019 	kauth_cred_seteuid(cred, saved_uid);
   2020 	tond.ni_cnd.cn_cred = cred;
   2021 	tond.ni_cnd.cn_nameiop = RENAME;
   2022 	tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE;
   2023 	error = nfs_namei(&tond, &tnsfh, len2, slp, nam, &md,
   2024 		&dpos, &tdirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   2025 	if (tdirp && v3) {
   2026 		tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred);
   2027 	}
   2028 	if (error) {
   2029 		VFS_RENAMELOCK_EXIT(localfs);
   2030 		VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
   2031 		vrele(fromnd.ni_dvp);
   2032 		vrele(fvp);
   2033 		goto out1;
   2034 	}
   2035 	tdvp = tond.ni_dvp;
   2036 	tvp = tond.ni_vp;
   2037 	if (tvp != NULL) {
   2038 		if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
   2039 			if (v3)
   2040 				error = EEXIST;
   2041 			else
   2042 				error = EISDIR;
   2043 			goto out;
   2044 		} else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
   2045 			if (v3)
   2046 				error = EEXIST;
   2047 			else
   2048 				error = ENOTDIR;
   2049 			goto out;
   2050 		}
   2051 		if (tvp->v_type == VDIR && tvp->v_mountedhere) {
   2052 			if (v3)
   2053 				error = EXDEV;
   2054 			else
   2055 				error = ENOTEMPTY;
   2056 			goto out;
   2057 		}
   2058 	}
   2059 	if (fvp->v_type == VDIR && fvp->v_mountedhere) {
   2060 		if (v3)
   2061 			error = EXDEV;
   2062 		else
   2063 			error = ENOTEMPTY;
   2064 		goto out;
   2065 	}
   2066 	if (fvp->v_mount != tdvp->v_mount) {
   2067 		if (v3)
   2068 			error = EXDEV;
   2069 		else
   2070 			error = ENOTEMPTY;
   2071 		goto out;
   2072 	}
   2073 	if (fvp == tdvp) {
   2074 		if (v3)
   2075 			error = EINVAL;
   2076 		else
   2077 			error = ENOTEMPTY;
   2078 	}
   2079 	/*
   2080 	 * If source is the same as the destination (that is the
   2081 	 * same vnode with the same name in the same directory),
   2082 	 * then there is nothing to do.
   2083 	 */
   2084 	if (fvp == tvp && fromnd.ni_dvp == tdvp &&
   2085 	    fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen &&
   2086 	    !memcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr,
   2087 	      fromnd.ni_cnd.cn_namelen))
   2088 		error = -1;
   2089 out:
   2090 	if (!error) {
   2091 		nqsrv_getl(fromnd.ni_dvp, ND_WRITE);
   2092 		nqsrv_getl(tdvp, ND_WRITE);
   2093 		if (tvp) {
   2094 			nqsrv_getl(tvp, ND_WRITE);
   2095 		}
   2096 		error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
   2097 				   tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
   2098 		VFS_RENAMELOCK_EXIT(localfs);
   2099 	} else {
   2100 		VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd);
   2101 		if (tdvp == tvp)
   2102 			vrele(tdvp);
   2103 		else
   2104 			vput(tdvp);
   2105 		if (tvp)
   2106 			vput(tvp);
   2107 		VFS_RENAMELOCK_EXIT(localfs);
   2108 		VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
   2109 		vrele(fromnd.ni_dvp);
   2110 		vrele(fvp);
   2111 		if (error == -1)
   2112 			error = 0;
   2113 	}
   2114 	if (tond.ni_pathbuf != NULL) {
   2115 		pathbuf_destroy(tond.ni_pathbuf);
   2116 		tond.ni_pathbuf = NULL;
   2117 	}
   2118 	tond.ni_cnd.cn_nameiop = 0;
   2119 out1:
   2120 	if (fdirp) {
   2121 		if (v3) {
   2122 			vn_lock(fdirp, LK_SHARED | LK_RETRY);
   2123 			fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred);
   2124 			VOP_UNLOCK(fdirp);
   2125 		}
   2126 		vrele(fdirp);
   2127 		fdirp = NULL;
   2128 	}
   2129 	if (tdirp) {
   2130 		if (v3) {
   2131 			vn_lock(tdirp, LK_SHARED | LK_RETRY);
   2132 			tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred);
   2133 			VOP_UNLOCK(tdirp);
   2134 		}
   2135 		vrele(tdirp);
   2136 		tdirp = NULL;
   2137 	}
   2138 	pathbuf_destroy(fromnd.ni_pathbuf);
   2139 	fromnd.ni_pathbuf = NULL;
   2140 	fromnd.ni_cnd.cn_nameiop = 0;
   2141 	fstrans_done(localfs);
   2142 	localfs = NULL;
   2143 	nfsm_reply(2 * NFSX_WCCDATA(v3));
   2144 	if (v3) {
   2145 		nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
   2146 		nfsm_srvwcc_data(tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
   2147 	}
   2148 	return (0);
   2149 
   2150 nfsmout:
   2151 	if (fdirp)
   2152 		vrele(fdirp);
   2153 #ifdef notdef
   2154 	if (tdirp)
   2155 		vrele(tdirp);
   2156 #endif
   2157 	if (tond.ni_cnd.cn_nameiop) {
   2158 		if (tond.ni_pathbuf != NULL) {
   2159 			pathbuf_destroy(tond.ni_pathbuf);
   2160 			tond.ni_pathbuf = NULL;
   2161 		}
   2162 	}
   2163 	if (localfs) {
   2164 		VFS_RENAMELOCK_EXIT(localfs);
   2165 		fstrans_done(localfs);
   2166 	}
   2167 	if (fromnd.ni_cnd.cn_nameiop) {
   2168 		VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd);
   2169 		if (fromnd.ni_pathbuf != NULL) {
   2170 			pathbuf_destroy(fromnd.ni_pathbuf);
   2171 			fromnd.ni_pathbuf = NULL;
   2172 		}
   2173 		vrele(fromnd.ni_dvp);
   2174 		vrele(fvp);
   2175 	}
   2176 	return (error);
   2177 }
   2178 
   2179 /*
   2180  * nfs link service
   2181  */
   2182 int
   2183 nfsrv_link(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   2184 {
   2185 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   2186 	struct mbuf *nam = nfsd->nd_nam;
   2187 	char *dpos = nfsd->nd_dpos;
   2188 	kauth_cred_t cred = nfsd->nd_cr;
   2189 	struct nameidata nd;
   2190 	u_int32_t *tl;
   2191 	int32_t t1;
   2192 	char *bpos;
   2193 	int error = 0, rdonly, cache = 0, len, dirfor_ret = 1, diraft_ret = 1;
   2194 	int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);
   2195 	char *cp2;
   2196 	struct mbuf *mb, *mreq __unused;
   2197 	struct vnode *vp, *xp, *dirp = (struct vnode *)0;
   2198 	struct vattr dirfor, diraft, at;
   2199 	nfsrvfh_t nsfh, dnsfh;
   2200 	u_quad_t frev;
   2201 
   2202 	nfsm_srvmtofh(&nsfh);
   2203 	nfsm_srvmtofh(&dnsfh);
   2204 	nfsm_srvnamesiz(len);
   2205 	error = nfsrv_fhtovp(&nsfh, false, &vp, cred, slp, nam,
   2206 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   2207 	if (error) {
   2208 		nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
   2209 		nfsm_srvpostop_attr(getret, &at);
   2210 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2211 		return (0);
   2212 	}
   2213 	if (vp->v_type == VDIR) {
   2214 		error = EPERM;
   2215 		goto out1;
   2216 	}
   2217 	nd.ni_cnd.cn_cred = cred;
   2218 	nd.ni_cnd.cn_nameiop = CREATE;
   2219 	nd.ni_cnd.cn_flags = LOCKPARENT;
   2220 	error = nfs_namei(&nd, &dnsfh, len, slp, nam, &md, &dpos,
   2221 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   2222 	if (dirp && v3) {
   2223 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   2224 	}
   2225 	if (error)
   2226 		goto out1;
   2227 	xp = nd.ni_vp;
   2228 	if (xp != NULL) {
   2229 		error = EEXIST;
   2230 		goto out;
   2231 	}
   2232 	xp = nd.ni_dvp;
   2233 	if (vp->v_mount != xp->v_mount)
   2234 		error = EXDEV;
   2235 out:
   2236 	if (!error) {
   2237 		nqsrv_getl(vp, ND_WRITE);
   2238 		nqsrv_getl(xp, ND_WRITE);
   2239 		error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
   2240 		if (nd.ni_dvp != nd.ni_vp)
   2241 			VOP_UNLOCK(nd.ni_dvp);
   2242 		vrele(nd.ni_dvp);
   2243 	} else {
   2244 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   2245 		if (nd.ni_dvp == nd.ni_vp)
   2246 			vrele(nd.ni_dvp);
   2247 		else
   2248 			vput(nd.ni_dvp);
   2249 		if (nd.ni_vp)
   2250 			vrele(nd.ni_vp);
   2251 	}
   2252 out1:
   2253 	if (v3) {
   2254 		vn_lock(vp, LK_SHARED | LK_RETRY);
   2255 		getret = VOP_GETATTR(vp, &at, cred);
   2256 		VOP_UNLOCK(vp);
   2257 	}
   2258 	if (dirp) {
   2259 		if (v3) {
   2260 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   2261 			diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   2262 			VOP_UNLOCK(dirp);
   2263 		}
   2264 		vrele(dirp);
   2265 	}
   2266 	vrele(vp);
   2267 	if (nd.ni_pathbuf != NULL) {
   2268 		pathbuf_destroy(nd.ni_pathbuf);
   2269 		nd.ni_pathbuf = NULL;
   2270 	}
   2271 	nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
   2272 	if (v3) {
   2273 		nfsm_srvpostop_attr(getret, &at);
   2274 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2275 		return (0);
   2276 	}
   2277 	nfsm_srvdone;
   2278 }
   2279 
   2280 /*
   2281  * nfs symbolic link service
   2282  */
   2283 int
   2284 nfsrv_symlink(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   2285 {
   2286 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   2287 	struct mbuf *nam = nfsd->nd_nam;
   2288 	char *dpos = nfsd->nd_dpos;
   2289 	kauth_cred_t cred = nfsd->nd_cr;
   2290 	struct vattr va, dirfor, diraft;
   2291 	struct nameidata nd;
   2292 	u_int32_t *tl;
   2293 	int32_t t1;
   2294 	struct nfsv2_sattr *sp;
   2295 	char *bpos, *pathcp = NULL, *cp2;
   2296 	struct uio io;
   2297 	struct iovec iv;
   2298 	int error = 0, cache = 0, dirfor_ret = 1, diraft_ret = 1, abort = 0;
   2299 	uint32_t len, len2;
   2300 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   2301 	struct mbuf *mb, *mreq __unused;
   2302 	struct vnode *dirp = (struct vnode *)0;
   2303 	nfsrvfh_t nsfh;
   2304 	u_quad_t frev;
   2305 
   2306 	nd.ni_cnd.cn_nameiop = 0;
   2307 	nfsm_srvmtofh(&nsfh);
   2308 	nfsm_srvnamesiz(len);
   2309 	nd.ni_cnd.cn_cred = cred;
   2310 	nd.ni_cnd.cn_nameiop = CREATE;
   2311 	nd.ni_cnd.cn_flags = LOCKPARENT;
   2312 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
   2313 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   2314 	if (dirp && v3) {
   2315 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   2316 	}
   2317 	if (error)
   2318 		goto out;
   2319 	abort = 1;
   2320 	vattr_null(&va);
   2321 	va.va_type = VLNK;
   2322 	if (v3) {
   2323 		va.va_mode = 0;
   2324 		nfsm_srvsattr(&va);
   2325 		nfsm_dissect(tl, uint32_t *, NFSX_UNSIGNED);
   2326 		len2 = fxdr_unsigned(uint32_t, *tl);
   2327 		if (len2 > PATH_MAX) {
   2328 			/* XXX should check _PC_NO_TRUNC */
   2329 			error = ENAMETOOLONG;
   2330 			goto abortop;
   2331 		}
   2332 	}
   2333 	else {
   2334 		/* NFSv2 */
   2335 		nfsm_strsiz(len2, NFS_MAXPATHLEN);
   2336 	}
   2337 	pathcp = malloc(len2 + 1, M_TEMP, M_WAITOK);
   2338 	iv.iov_base = pathcp;
   2339 	iv.iov_len = len2;
   2340 	io.uio_resid = len2;
   2341 	io.uio_offset = 0;
   2342 	io.uio_iov = &iv;
   2343 	io.uio_iovcnt = 1;
   2344 	io.uio_rw = UIO_READ;
   2345 	UIO_SETUP_SYSSPACE(&io);
   2346 	nfsm_mtouio(&io, len2);
   2347 	if (!v3) {
   2348 		nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
   2349 		va.va_mode = fxdr_unsigned(u_int16_t, sp->sa_mode);
   2350 	}
   2351 	*(pathcp + len2) = '\0';
   2352 	if (nd.ni_vp) {
   2353 		error = EEXIST;
   2354 abortop:
   2355 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   2356 		if (nd.ni_dvp == nd.ni_vp)
   2357 			vrele(nd.ni_dvp);
   2358 		else
   2359 			vput(nd.ni_dvp);
   2360 		if (nd.ni_vp)
   2361 			vrele(nd.ni_vp);
   2362 		goto out;
   2363 	}
   2364 	nqsrv_getl(nd.ni_dvp, ND_WRITE);
   2365 	error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &va, pathcp);
   2366 	if (!error) {
   2367 	    if (v3) {
   2368 		vn_lock(nd.ni_vp, LK_SHARED | LK_RETRY);
   2369 		error = nfsrv_composefh(nd.ni_vp, &nsfh, v3);
   2370 		if (!error)
   2371 		    error = VOP_GETATTR(nd.ni_vp, &va, cred);
   2372 		vput(nd.ni_vp);
   2373 	    } else {
   2374 		vrele(nd.ni_vp);
   2375 	    }
   2376 	}
   2377 	vput(nd.ni_dvp);
   2378 out:
   2379 	if (pathcp)
   2380 		free(pathcp, M_TEMP);
   2381 	if (dirp) {
   2382 		if (v3) {
   2383 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   2384 			diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   2385 			VOP_UNLOCK(dirp);
   2386 		}
   2387 		vrele(dirp);
   2388 		dirp = NULL;
   2389 	}
   2390 	if (nd.ni_pathbuf != NULL) {
   2391 		pathbuf_destroy(nd.ni_pathbuf);
   2392 		nd.ni_pathbuf = NULL;
   2393 	}
   2394 	abort = 0;
   2395 	nfsm_reply(NFSX_SRVFH(&nsfh, v3) + NFSX_POSTOPATTR(v3) +
   2396 	    NFSX_WCCDATA(v3));
   2397 	if (v3) {
   2398 		if (!error) {
   2399 			nfsm_srvpostop_fh(&nsfh);
   2400 			nfsm_srvpostop_attr(0, &va);
   2401 		}
   2402 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2403 	}
   2404 	return (0);
   2405 nfsmout:
   2406 	if (abort) {
   2407 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   2408 		if (nd.ni_dvp == nd.ni_vp)
   2409 			vrele(nd.ni_dvp);
   2410 		else
   2411 			vput(nd.ni_dvp);
   2412 		if (nd.ni_vp)
   2413 			vrele(nd.ni_vp);
   2414 		if (nd.ni_pathbuf != NULL) {
   2415 			pathbuf_destroy(nd.ni_pathbuf);
   2416 			nd.ni_pathbuf = NULL;
   2417 		}
   2418 	}
   2419 	if (dirp)
   2420 		vrele(dirp);
   2421 	if (pathcp)
   2422 		free(pathcp, M_TEMP);
   2423 	return (error);
   2424 }
   2425 
   2426 /*
   2427  * nfs mkdir service
   2428  */
   2429 int
   2430 nfsrv_mkdir(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   2431 {
   2432 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   2433 	struct mbuf *nam = nfsd->nd_nam;
   2434 	char *dpos = nfsd->nd_dpos;
   2435 	kauth_cred_t cred = nfsd->nd_cr;
   2436 	struct vattr va, dirfor, diraft;
   2437 	struct nfs_fattr *fp;
   2438 	struct nameidata nd;
   2439 	char *cp;
   2440 	u_int32_t *tl;
   2441 	int32_t t1;
   2442 	char *bpos;
   2443 	int error = 0, cache = 0, len, dirfor_ret = 1, diraft_ret = 1;
   2444 	int abort = 0;
   2445 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   2446 	char *cp2;
   2447 	struct mbuf *mb, *mreq __unused;
   2448 	struct vnode *vp, *dirp = (struct vnode *)0;
   2449 	nfsrvfh_t nsfh;
   2450 	u_quad_t frev;
   2451 
   2452 	nfsm_srvmtofh(&nsfh);
   2453 	nfsm_srvnamesiz(len);
   2454 	nd.ni_cnd.cn_cred = cred;
   2455 	nd.ni_cnd.cn_nameiop = CREATE;
   2456 	nd.ni_cnd.cn_flags = LOCKPARENT;
   2457 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
   2458 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   2459 	if (dirp && v3) {
   2460 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   2461 	}
   2462 	if (error) {
   2463 		if (nd.ni_pathbuf != NULL) {
   2464 			pathbuf_destroy(nd.ni_pathbuf);
   2465 			nd.ni_pathbuf = NULL;
   2466 		}
   2467 		nfsm_reply(NFSX_WCCDATA(v3));
   2468 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2469 		if (dirp)
   2470 			vrele(dirp);
   2471 		return (0);
   2472 	}
   2473 	abort = 1;
   2474 	vattr_null(&va);
   2475 	if (v3) {
   2476 		va.va_mode = 0;
   2477 		nfsm_srvsattr(&va);
   2478 	} else {
   2479 		nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
   2480 		va.va_mode = nfstov_mode(*tl++);
   2481 	}
   2482 	va.va_type = VDIR;
   2483 	vp = nd.ni_vp;
   2484 	if (vp != NULL) {
   2485 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   2486 		if (nd.ni_dvp == vp)
   2487 			vrele(nd.ni_dvp);
   2488 		else
   2489 			vput(nd.ni_dvp);
   2490 		vrele(vp);
   2491 		error = EEXIST;
   2492 		goto out;
   2493 	}
   2494 	nqsrv_getl(nd.ni_dvp, ND_WRITE);
   2495 	error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &va);
   2496 	if (!error) {
   2497 		vp = nd.ni_vp;
   2498 		vn_lock(vp, LK_SHARED | LK_RETRY);
   2499 		error = nfsrv_composefh(vp, &nsfh, v3);
   2500 		if (!error)
   2501 			error = VOP_GETATTR(vp, &va, cred);
   2502 		vput(vp);
   2503 	}
   2504 	vput(nd.ni_dvp);
   2505 out:
   2506 	if (dirp) {
   2507 		if (v3) {
   2508 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   2509 			diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   2510 			VOP_UNLOCK(dirp);
   2511 		}
   2512 		vrele(dirp);
   2513 		dirp = NULL;
   2514 	}
   2515 	if (nd.ni_pathbuf != NULL) {
   2516 		pathbuf_destroy(nd.ni_pathbuf);
   2517 		nd.ni_pathbuf = NULL;
   2518 	}
   2519 	abort = 0;
   2520 	nfsm_reply(NFSX_SRVFH(&nsfh, v3) + NFSX_POSTOPATTR(v3) +
   2521 	    NFSX_WCCDATA(v3));
   2522 	if (v3) {
   2523 		if (!error) {
   2524 			nfsm_srvpostop_fh(&nsfh);
   2525 			nfsm_srvpostop_attr(0, &va);
   2526 		}
   2527 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2528 	} else {
   2529 		nfsm_srvfhtom(&nsfh, v3);
   2530 		nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
   2531 		nfsm_srvfillattr(&va, fp);
   2532 	}
   2533 	return (0);
   2534 nfsmout:
   2535 	if (abort) {
   2536 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   2537 		if (nd.ni_dvp == nd.ni_vp)
   2538 			vrele(nd.ni_dvp);
   2539 		else
   2540 			vput(nd.ni_dvp);
   2541 		if (nd.ni_vp)
   2542 			vrele(nd.ni_vp);
   2543 		if (nd.ni_pathbuf != NULL) {
   2544 			pathbuf_destroy(nd.ni_pathbuf);
   2545 			nd.ni_pathbuf = NULL;
   2546 		}
   2547 	}
   2548 	if (dirp)
   2549 		vrele(dirp);
   2550 	return (error);
   2551 }
   2552 
   2553 /*
   2554  * nfs rmdir service
   2555  */
   2556 int
   2557 nfsrv_rmdir(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   2558 {
   2559 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   2560 	struct mbuf *nam = nfsd->nd_nam;
   2561 	char *dpos = nfsd->nd_dpos;
   2562 	kauth_cred_t cred = nfsd->nd_cr;
   2563 	u_int32_t *tl;
   2564 	int32_t t1;
   2565 	char *bpos;
   2566 	int error = 0, cache = 0, len, dirfor_ret = 1, diraft_ret = 1;
   2567 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   2568 	char *cp2;
   2569 	struct mbuf *mb, *mreq __unused;
   2570 	struct vnode *vp, *dirp = (struct vnode *)0;
   2571 	struct vattr dirfor, diraft;
   2572 	nfsrvfh_t nsfh;
   2573 	struct nameidata nd;
   2574 	u_quad_t frev;
   2575 
   2576 	nfsm_srvmtofh(&nsfh);
   2577 	nfsm_srvnamesiz(len);
   2578 	nd.ni_cnd.cn_cred = cred;
   2579 	nd.ni_cnd.cn_nameiop = DELETE;
   2580 	nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
   2581 	error = nfs_namei(&nd, &nsfh, len, slp, nam, &md, &dpos,
   2582 		&dirp, lwp, (nfsd->nd_flag & ND_KERBAUTH), false);
   2583 	if (dirp && v3) {
   2584 		dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred);
   2585 	}
   2586 	if (error) {
   2587 		if (nd.ni_pathbuf != NULL) {
   2588 			pathbuf_destroy(nd.ni_pathbuf);
   2589 			nd.ni_pathbuf = NULL;
   2590 		}
   2591 		nfsm_reply(NFSX_WCCDATA(v3));
   2592 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2593 		if (dirp)
   2594 			vrele(dirp);
   2595 		return (0);
   2596 	}
   2597 	vp = nd.ni_vp;
   2598 	if (vp->v_type != VDIR) {
   2599 		error = ENOTDIR;
   2600 		goto out;
   2601 	}
   2602 	/*
   2603 	 * No rmdir "." please.
   2604 	 */
   2605 	if (nd.ni_dvp == vp) {
   2606 		error = EINVAL;
   2607 		goto out;
   2608 	}
   2609 	/*
   2610 	 * The root of a mounted filesystem cannot be deleted.
   2611 	 */
   2612 	if (vp->v_vflag & VV_ROOT)
   2613 		error = EBUSY;
   2614 out:
   2615 	if (!error) {
   2616 		nqsrv_getl(nd.ni_dvp, ND_WRITE);
   2617 		nqsrv_getl(vp, ND_WRITE);
   2618 		error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
   2619 		vput(nd.ni_dvp);
   2620 	} else {
   2621 		VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
   2622 		if (nd.ni_dvp == nd.ni_vp)
   2623 			vrele(nd.ni_dvp);
   2624 		else
   2625 			vput(nd.ni_dvp);
   2626 		vput(vp);
   2627 	}
   2628 	if (nd.ni_pathbuf != NULL) {
   2629 		pathbuf_destroy(nd.ni_pathbuf);
   2630 		nd.ni_pathbuf = NULL;
   2631 	}
   2632 	if (dirp) {
   2633 		if (v3) {
   2634 			vn_lock(dirp, LK_SHARED | LK_RETRY);
   2635 			diraft_ret = VOP_GETATTR(dirp, &diraft, cred);
   2636 			VOP_UNLOCK(dirp);
   2637 		}
   2638 		vrele(dirp);
   2639 	}
   2640 	nfsm_reply(NFSX_WCCDATA(v3));
   2641 	if (v3) {
   2642 		nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
   2643 		return (0);
   2644 	}
   2645 	nfsm_srvdone;
   2646 }
   2647 
   2648 /*
   2649  * nfs readdir service
   2650  * - mallocs what it thinks is enough to read
   2651  *	count rounded up to a multiple of NFS_SRVDIRBLKSIZ <= NFS_MAXREADDIR
   2652  * - calls VOP_READDIR()
   2653  * - loops around building the reply
   2654  *	if the output generated exceeds count break out of loop
   2655  *	The nfsm_clget macro is used here so that the reply will be packed
   2656  *	tightly in mbuf clusters.
   2657  * - it only knows that it has encountered eof when the VOP_READDIR()
   2658  *	reads nothing
   2659  * - as such one readdir rpc will return eof false although you are there
   2660  *	and then the next will return eof
   2661  * - it trims out records with d_fileno == 0
   2662  *	this doesn't matter for Unix clients, but they might confuse clients
   2663  *	for other os'.
   2664  * - it trims out records with d_type == DT_WHT
   2665  *	these cannot be seen through NFS (unless we extend the protocol)
   2666  * NB: It is tempting to set eof to true if the VOP_READDIR() reads less
   2667  *	than requested, but this may not apply to all filesystems. For
   2668  *	example, client NFS does not { although it is never remote mounted
   2669  *	anyhow }
   2670  *     The alternate call nfsrv_readdirplus() does lookups as well.
   2671  * PS: The NFS protocol spec. does not clarify what the "count" byte
   2672  *	argument is a count of.. just name strings and file id's or the
   2673  *	entire reply rpc or ...
   2674  *	I tried just file name and id sizes and it confused the Sun client,
   2675  *	so I am using the full rpc size now. The "paranoia.." comment refers
   2676  *	to including the status longwords that are not a part of the dir.
   2677  *	"entry" structures, but are in the rpc.
   2678  */
   2679 
   2680 #define	NFS_SRVDIRBLKSIZ	1024
   2681 
   2682 struct flrep {
   2683 	nfsuint64 fl_off;
   2684 	u_int32_t fl_postopok;
   2685 	struct nfs_fattr fl_fattr; /* XXX: must be of fattr3 size */
   2686 	u_int32_t fl_fhok;
   2687 	u_int32_t fl_fhsize;
   2688 	/* handle comes here, filled in dynamically */
   2689 };
   2690 
   2691 int
   2692 nfsrv_readdir(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   2693 {
   2694 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   2695 	struct mbuf *nam = nfsd->nd_nam;
   2696 	char *dpos = nfsd->nd_dpos;
   2697 	kauth_cred_t cred = nfsd->nd_cr;
   2698 	char *bp, *be;
   2699 	struct mbuf *mp;
   2700 	struct dirent *dp;
   2701 	char *cp;
   2702 	u_int32_t *tl;
   2703 	int32_t t1;
   2704 	char *bpos;
   2705 	struct mbuf *mb, *mreq __unused, *mp2;
   2706 	char *cpos, *cend, *cp2, *rbuf;
   2707 	struct vnode *vp;
   2708 	struct vattr at;
   2709 	nfsrvfh_t nsfh;
   2710 	struct uio io;
   2711 	struct iovec iv;
   2712 	int len, nlen, rem, xfer, tsiz, i, error = 0, getret = 1;
   2713 	int siz, cnt, fullsiz, eofflag, rdonly, cache = 0, ncookies;
   2714 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   2715 	u_quad_t frev, off, toff;
   2716 #ifdef NFS3_STRICTVERF
   2717 	u_quad_t verf;
   2718 #endif
   2719 	off_t *cookies = NULL, *cookiep;
   2720 	nfsuint64 jar;
   2721 
   2722 	nfsm_srvmtofh(&nsfh);
   2723 	if (v3) {
   2724 		nfsm_dissect(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
   2725 		toff = fxdr_hyper(tl);
   2726 		tl += 2;
   2727 #ifdef NFS3_STRICTVERF
   2728 		verf = fxdr_hyper(tl);
   2729 #endif
   2730 		tl += 2;
   2731 	} else {
   2732 		nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   2733 		toff = fxdr_unsigned(u_quad_t, *tl++);
   2734 	}
   2735 	off = toff;
   2736 	cnt = fxdr_unsigned(int, *tl);
   2737 	siz = ((cnt + NFS_SRVDIRBLKSIZ - 1) & ~(NFS_SRVDIRBLKSIZ - 1));
   2738 	xfer = NFS_SRVMAXDATA(nfsd);
   2739 	if (siz > xfer)
   2740 		siz = xfer;
   2741 	fullsiz = siz;
   2742 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
   2743 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   2744 	if (!error && vp->v_type != VDIR) {
   2745 		error = ENOTDIR;
   2746 		vput(vp);
   2747 	}
   2748 	if (error) {
   2749 		nfsm_reply(NFSX_UNSIGNED);
   2750 		nfsm_srvpostop_attr(getret, &at);
   2751 		return (0);
   2752 	}
   2753 	nqsrv_getl(vp, ND_READ);
   2754 	if (v3) {
   2755 		error = getret = VOP_GETATTR(vp, &at, cred);
   2756 #ifdef NFS3_STRICTVERF
   2757 		/*
   2758 		 * XXX This check is too strict for Solaris 2.5 clients.
   2759 		 */
   2760 		if (!error && toff && verf != at.va_filerev)
   2761 			error = NFSERR_BAD_COOKIE;
   2762 #endif
   2763 	}
   2764 	if (!error)
   2765 		error = nfsrv_access(vp, VEXEC, cred, rdonly, lwp, 0);
   2766 	if (error) {
   2767 		vput(vp);
   2768 		nfsm_reply(NFSX_POSTOPATTR(v3));
   2769 		nfsm_srvpostop_attr(getret, &at);
   2770 		return (0);
   2771 	}
   2772 	VOP_UNLOCK(vp);
   2773 	rbuf = malloc(siz, M_TEMP, M_WAITOK);
   2774 again:
   2775 	iv.iov_base = rbuf;
   2776 	iv.iov_len = fullsiz;
   2777 	io.uio_iov = &iv;
   2778 	io.uio_iovcnt = 1;
   2779 	io.uio_offset = (off_t)off;
   2780 	io.uio_resid = fullsiz;
   2781 	io.uio_rw = UIO_READ;
   2782 	UIO_SETUP_SYSSPACE(&io);
   2783 	eofflag = 0;
   2784 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   2785 
   2786 	error = VOP_READDIR(vp, &io, cred, &eofflag, &cookies, &ncookies);
   2787 
   2788 	off = (off_t)io.uio_offset;
   2789 	if (!cookies && !error)
   2790 		error = NFSERR_PERM;
   2791 	if (v3) {
   2792 		getret = VOP_GETATTR(vp, &at, cred);
   2793 		if (!error)
   2794 			error = getret;
   2795 	}
   2796 
   2797 	VOP_UNLOCK(vp);
   2798 	if (error) {
   2799 		vrele(vp);
   2800 		free((void *)rbuf, M_TEMP);
   2801 		if (cookies)
   2802 			free((void *)cookies, M_TEMP);
   2803 		nfsm_reply(NFSX_POSTOPATTR(v3));
   2804 		nfsm_srvpostop_attr(getret, &at);
   2805 		return (0);
   2806 	}
   2807 	if (io.uio_resid) {
   2808 		siz -= io.uio_resid;
   2809 
   2810 		/*
   2811 		 * If nothing read, return eof
   2812 		 * rpc reply
   2813 		 */
   2814 		if (siz == 0) {
   2815 			vrele(vp);
   2816 			nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_COOKIEVERF(v3) +
   2817 				2 * NFSX_UNSIGNED);
   2818 			if (v3) {
   2819 				nfsm_srvpostop_attr(getret, &at);
   2820 				nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
   2821 				txdr_hyper(at.va_filerev, tl);
   2822 				tl += 2;
   2823 			} else
   2824 				nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   2825 			*tl++ = nfs_false;
   2826 			*tl = nfs_true;
   2827 			free((void *)rbuf, M_TEMP);
   2828 			free((void *)cookies, M_TEMP);
   2829 			return (0);
   2830 		}
   2831 	}
   2832 
   2833 	/*
   2834 	 * Check for degenerate cases of nothing useful read.
   2835 	 * If so go try again
   2836 	 */
   2837 	cpos = rbuf;
   2838 	cend = rbuf + siz;
   2839 	dp = (struct dirent *)cpos;
   2840 	cookiep = cookies;
   2841 
   2842 	while (cpos < cend && ncookies > 0 &&
   2843 		(dp->d_fileno == 0 || dp->d_type == DT_WHT)) {
   2844 		cpos += dp->d_reclen;
   2845 		dp = (struct dirent *)cpos;
   2846 		cookiep++;
   2847 		ncookies--;
   2848 	}
   2849 	if (cpos >= cend || ncookies == 0) {
   2850 		toff = off;
   2851 		siz = fullsiz;
   2852 		free(cookies, M_TEMP);
   2853 		cookies = NULL;
   2854 		goto again;
   2855 	}
   2856 
   2857 	len = 3 * NFSX_UNSIGNED;	/* paranoia, probably can be 0 */
   2858 	nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_COOKIEVERF(v3) + siz);
   2859 	if (v3) {
   2860 		nfsm_srvpostop_attr(getret, &at);
   2861 		nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   2862 		txdr_hyper(at.va_filerev, tl);
   2863 	}
   2864 	mp = mp2 = mb;
   2865 	bp = bpos;
   2866 	be = bp + M_TRAILINGSPACE(mp);
   2867 
   2868 	/* Loop through the records and build reply */
   2869 	while (cpos < cend && ncookies > 0) {
   2870 		if (dp->d_fileno != 0 && dp->d_type != DT_WHT) {
   2871 			nlen = dp->d_namlen;
   2872 			rem = nfsm_rndup(nlen)-nlen;
   2873 			len += (4 * NFSX_UNSIGNED + nlen + rem);
   2874 			if (v3)
   2875 				len += 2 * NFSX_UNSIGNED;
   2876 			if (len > cnt) {
   2877 				eofflag = 0;
   2878 				break;
   2879 			}
   2880 			/*
   2881 			 * Build the directory record xdr from
   2882 			 * the dirent entry.
   2883 			 */
   2884 			nfsm_clget;
   2885 			*tl = nfs_true;
   2886 			bp += NFSX_UNSIGNED;
   2887 			if (v3) {
   2888 				nfsm_clget;
   2889 				*tl = txdr_unsigned(dp->d_fileno >> 32);
   2890 				bp += NFSX_UNSIGNED;
   2891 			}
   2892 			nfsm_clget;
   2893 			*tl = txdr_unsigned(dp->d_fileno);
   2894 			bp += NFSX_UNSIGNED;
   2895 			nfsm_clget;
   2896 			*tl = txdr_unsigned(nlen);
   2897 			bp += NFSX_UNSIGNED;
   2898 
   2899 			/* And loop around copying the name */
   2900 			xfer = nlen;
   2901 			cp = dp->d_name;
   2902 			while (xfer > 0) {
   2903 				nfsm_clget;
   2904 				if ((bp+xfer) > be)
   2905 					tsiz = be-bp;
   2906 				else
   2907 					tsiz = xfer;
   2908 				memcpy(bp, cp, tsiz);
   2909 				bp += tsiz;
   2910 				xfer -= tsiz;
   2911 				if (xfer > 0)
   2912 					cp += tsiz;
   2913 			}
   2914 			/* And null pad to an int32_t boundary */
   2915 			for (i = 0; i < rem; i++)
   2916 				*bp++ = '\0';
   2917 			nfsm_clget;
   2918 
   2919 			/* Finish off the record */
   2920 			txdr_hyper(*cookiep, &jar);
   2921 			if (v3) {
   2922 				*tl = jar.nfsuquad[0];
   2923 				bp += NFSX_UNSIGNED;
   2924 				nfsm_clget;
   2925 			}
   2926 			*tl = jar.nfsuquad[1];
   2927 			bp += NFSX_UNSIGNED;
   2928 		}
   2929 		cpos += dp->d_reclen;
   2930 		dp = (struct dirent *)cpos;
   2931 		cookiep++;
   2932 		ncookies--;
   2933 	}
   2934 	vrele(vp);
   2935 	nfsm_clget;
   2936 	*tl = nfs_false;
   2937 	bp += NFSX_UNSIGNED;
   2938 	nfsm_clget;
   2939 	if (eofflag)
   2940 		*tl = nfs_true;
   2941 	else
   2942 		*tl = nfs_false;
   2943 	bp += NFSX_UNSIGNED;
   2944 	if (mp != mb) {
   2945 		if (bp < be)
   2946 			mp->m_len = bp - mtod(mp, char *);
   2947 	} else
   2948 		mp->m_len += bp - bpos;
   2949 	free((void *)rbuf, M_TEMP);
   2950 	free((void *)cookies, M_TEMP);
   2951 	nfsm_srvdone;
   2952 }
   2953 
   2954 int
   2955 nfsrv_readdirplus(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   2956 {
   2957 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   2958 	struct mbuf *nam = nfsd->nd_nam;
   2959 	char *dpos = nfsd->nd_dpos;
   2960 	kauth_cred_t cred = nfsd->nd_cr;
   2961 	char *bp, *be;
   2962 	struct mbuf *mp;
   2963 	struct dirent *dp;
   2964 	char *cp;
   2965 	u_int32_t *tl;
   2966 	int32_t t1;
   2967 	char *bpos;
   2968 	struct mbuf *mb, *mreq __unused, *mp2;
   2969 	char *cpos, *cend, *cp2, *rbuf;
   2970 	struct vnode *vp, *nvp;
   2971 	struct flrep fl;
   2972 	nfsrvfh_t nsfh;
   2973 	struct uio io;
   2974 	struct iovec iv;
   2975 	struct vattr va, at, *vap = &va;
   2976 	struct nfs_fattr *fp;
   2977 	int len, nlen, rem, xfer, tsiz, i, error = 0, getret = 1;
   2978 	int siz, cnt, fullsiz, eofflag, rdonly, cache = 0, dirlen, ncookies;
   2979 	u_quad_t frev, off, toff;
   2980 #ifdef NFS3_STRICTVERF
   2981 	u_quad_t verf;
   2982 #endif
   2983 	off_t *cookies = NULL, *cookiep;
   2984 
   2985 	nfsm_srvmtofh(&nsfh);
   2986 	nfsm_dissect(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
   2987 	toff = fxdr_hyper(tl);
   2988 	tl += 2;
   2989 #ifdef NFS3_STRICTVERF
   2990 	verf = fxdr_hyper(tl);
   2991 #endif
   2992 	tl += 2;
   2993 	siz = fxdr_unsigned(int, *tl++);
   2994 	cnt = fxdr_unsigned(int, *tl);
   2995 	off = toff;
   2996 	siz = ((siz + NFS_SRVDIRBLKSIZ - 1) & ~(NFS_SRVDIRBLKSIZ - 1));
   2997 	xfer = NFS_SRVMAXDATA(nfsd);
   2998 	if (siz > xfer)
   2999 		siz = xfer;
   3000 	fullsiz = siz;
   3001 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
   3002 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   3003 	if (!error && vp->v_type != VDIR) {
   3004 		error = ENOTDIR;
   3005 		vput(vp);
   3006 	}
   3007 	if (error) {
   3008 		nfsm_reply(NFSX_UNSIGNED);
   3009 		nfsm_srvpostop_attr(getret, &at);
   3010 		return (0);
   3011 	}
   3012 	error = getret = VOP_GETATTR(vp, &at, cred);
   3013 #ifdef NFS3_STRICTVERF
   3014 	/*
   3015 	 * XXX This check is too strict for Solaris 2.5 clients.
   3016 	 */
   3017 	if (!error && toff && verf != at.va_filerev)
   3018 		error = NFSERR_BAD_COOKIE;
   3019 #endif
   3020 	if (!error) {
   3021 		nqsrv_getl(vp, ND_READ);
   3022 		error = nfsrv_access(vp, VEXEC, cred, rdonly, lwp, 0);
   3023 	}
   3024 	if (error) {
   3025 		vput(vp);
   3026 		nfsm_reply(NFSX_V3POSTOPATTR);
   3027 		nfsm_srvpostop_attr(getret, &at);
   3028 		return (0);
   3029 	}
   3030 	VOP_UNLOCK(vp);
   3031 
   3032 	rbuf = malloc(siz, M_TEMP, M_WAITOK);
   3033 again:
   3034 	iv.iov_base = rbuf;
   3035 	iv.iov_len = fullsiz;
   3036 	io.uio_iov = &iv;
   3037 	io.uio_iovcnt = 1;
   3038 	io.uio_offset = (off_t)off;
   3039 	io.uio_resid = fullsiz;
   3040 	io.uio_rw = UIO_READ;
   3041 	UIO_SETUP_SYSSPACE(&io);
   3042 	eofflag = 0;
   3043 
   3044 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
   3045 
   3046 	error = VOP_READDIR(vp, &io, cred, &eofflag, &cookies, &ncookies);
   3047 
   3048 	off = (u_quad_t)io.uio_offset;
   3049 	getret = VOP_GETATTR(vp, &at, cred);
   3050 
   3051 	VOP_UNLOCK(vp);
   3052 
   3053 	/*
   3054 	 * If the VGET operation doesn't work for this filesystem,
   3055 	 * we can't support readdirplus. Returning NOTSUPP should
   3056 	 * make clients fall back to plain readdir.
   3057 	 * There's no need to check for VPTOFH as well, we wouldn't
   3058 	 * even be here otherwise.
   3059 	 */
   3060 	if (!getret) {
   3061 		if ((getret = VFS_VGET(vp->v_mount, at.va_fileid,
   3062 		    LK_EXCLUSIVE, &nvp)))
   3063 			getret = (getret == EOPNOTSUPP) ?
   3064 				NFSERR_NOTSUPP : NFSERR_IO;
   3065 		else
   3066 			vput(nvp);
   3067 	}
   3068 
   3069 	if (!cookies && !error)
   3070 		error = NFSERR_PERM;
   3071 	if (!error)
   3072 		error = getret;
   3073 	if (error) {
   3074 		vrele(vp);
   3075 		if (cookies)
   3076 			free((void *)cookies, M_TEMP);
   3077 		free((void *)rbuf, M_TEMP);
   3078 		nfsm_reply(NFSX_V3POSTOPATTR);
   3079 		nfsm_srvpostop_attr(getret, &at);
   3080 		return (0);
   3081 	}
   3082 	if (io.uio_resid) {
   3083 		siz -= io.uio_resid;
   3084 
   3085 		/*
   3086 		 * If nothing read, return eof
   3087 		 * rpc reply
   3088 		 */
   3089 		if (siz == 0) {
   3090 			vrele(vp);
   3091 			nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3COOKIEVERF +
   3092 				2 * NFSX_UNSIGNED);
   3093 			nfsm_srvpostop_attr(getret, &at);
   3094 			nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
   3095 			txdr_hyper(at.va_filerev, tl);
   3096 			tl += 2;
   3097 			*tl++ = nfs_false;
   3098 			*tl = nfs_true;
   3099 			free((void *)cookies, M_TEMP);
   3100 			free((void *)rbuf, M_TEMP);
   3101 			return (0);
   3102 		}
   3103 	}
   3104 
   3105 	/*
   3106 	 * Check for degenerate cases of nothing useful read.
   3107 	 * If so go try again
   3108 	 */
   3109 	cpos = rbuf;
   3110 	cend = rbuf + siz;
   3111 	dp = (struct dirent *)cpos;
   3112 	cookiep = cookies;
   3113 
   3114 	while (cpos < cend && ncookies > 0 &&
   3115 		(dp->d_fileno == 0 || dp->d_type == DT_WHT)) {
   3116 		cpos += dp->d_reclen;
   3117 		dp = (struct dirent *)cpos;
   3118 		cookiep++;
   3119 		ncookies--;
   3120 	}
   3121 	if (cpos >= cend || ncookies == 0) {
   3122 		toff = off;
   3123 		siz = fullsiz;
   3124 		free(cookies, M_TEMP);
   3125 		cookies = NULL;
   3126 		goto again;
   3127 	}
   3128 
   3129 	dirlen = len = NFSX_V3POSTOPATTR + NFSX_V3COOKIEVERF + 2 * NFSX_UNSIGNED;
   3130 	nfsm_reply(cnt);
   3131 	nfsm_srvpostop_attr(getret, &at);
   3132 	nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
   3133 	txdr_hyper(at.va_filerev, tl);
   3134 	mp = mp2 = mb;
   3135 	bp = bpos;
   3136 	be = bp + M_TRAILINGSPACE(mp);
   3137 
   3138 	/* Loop through the records and build reply */
   3139 	while (cpos < cend && ncookies > 0) {
   3140 		if (dp->d_fileno != 0 && dp->d_type != DT_WHT) {
   3141 			nfsrvfh_t nnsfh;
   3142 
   3143 			nlen = dp->d_namlen;
   3144 			rem = nfsm_rndup(nlen)-nlen;
   3145 
   3146 			/*
   3147 			 * For readdir_and_lookup get the vnode using
   3148 			 * the file number.
   3149 			 */
   3150 			if (VFS_VGET(vp->v_mount, dp->d_fileno, LK_EXCLUSIVE,
   3151 			    &nvp))
   3152 				goto invalid;
   3153 			if (nfsrv_composefh(nvp, &nnsfh, true)) {
   3154 				vput(nvp);
   3155 				goto invalid;
   3156 			}
   3157 			if (VOP_GETATTR(nvp, vap, cred)) {
   3158 				vput(nvp);
   3159 				goto invalid;
   3160 			}
   3161 			vput(nvp);
   3162 
   3163 			/*
   3164 			 * If either the dircount or maxcount will be
   3165 			 * exceeded, get out now. Both of these lengths
   3166 			 * are calculated conservatively, including all
   3167 			 * XDR overheads.
   3168 			 */
   3169 			len += (8 * NFSX_UNSIGNED + nlen + rem + NFSX_V3FH +
   3170 				NFSX_V3POSTOPATTR);
   3171 			dirlen += (6 * NFSX_UNSIGNED + nlen + rem);
   3172 			if (len > cnt || dirlen > fullsiz) {
   3173 				eofflag = 0;
   3174 				break;
   3175 			}
   3176 
   3177 			/*
   3178 			 * Build the directory record xdr from
   3179 			 * the dirent entry.
   3180 			 */
   3181 			fp = (struct nfs_fattr *)&fl.fl_fattr;
   3182 			nfsm_srvfillattr(vap, fp);
   3183 			fl.fl_fhsize = txdr_unsigned(NFSX_V3FH);
   3184 			fl.fl_fhok = nfs_true;
   3185 			fl.fl_postopok = nfs_true;
   3186 			txdr_hyper(*cookiep, fl.fl_off.nfsuquad);
   3187 
   3188 			nfsm_clget;
   3189 			*tl = nfs_true;
   3190 			bp += NFSX_UNSIGNED;
   3191 			nfsm_clget;
   3192 			*tl = txdr_unsigned(dp->d_fileno >> 32);
   3193 			bp += NFSX_UNSIGNED;
   3194 			nfsm_clget;
   3195 			*tl = txdr_unsigned(dp->d_fileno);
   3196 			bp += NFSX_UNSIGNED;
   3197 			nfsm_clget;
   3198 			*tl = txdr_unsigned(nlen);
   3199 			bp += NFSX_UNSIGNED;
   3200 
   3201 			/* And loop around copying the name */
   3202 			xfer = nlen;
   3203 			cp = dp->d_name;
   3204 			while (xfer > 0) {
   3205 				nfsm_clget;
   3206 				if ((bp + xfer) > be)
   3207 					tsiz = be - bp;
   3208 				else
   3209 					tsiz = xfer;
   3210 				memcpy(bp, cp, tsiz);
   3211 				bp += tsiz;
   3212 				xfer -= tsiz;
   3213 				if (xfer > 0)
   3214 					cp += tsiz;
   3215 			}
   3216 			/* And null pad to an int32_t boundary */
   3217 			for (i = 0; i < rem; i++)
   3218 				*bp++ = '\0';
   3219 
   3220 			/*
   3221 			 * Now copy the flrep structure out.
   3222 			 */
   3223 			xfer = sizeof(struct flrep);
   3224 			cp = (void *)&fl;
   3225 			while (xfer > 0) {
   3226 				nfsm_clget;
   3227 				if ((bp + xfer) > be)
   3228 					tsiz = be - bp;
   3229 				else
   3230 					tsiz = xfer;
   3231 				memcpy(bp, cp, tsiz);
   3232 				bp += tsiz;
   3233 				xfer -= tsiz;
   3234 				if (xfer > 0)
   3235 					cp += tsiz;
   3236 			}
   3237 
   3238 			/*
   3239 			 * ... and filehandle.
   3240 			 */
   3241 			xfer = NFSRVFH_SIZE(&nnsfh);
   3242 			cp = NFSRVFH_DATA(&nnsfh);
   3243 			while (xfer > 0) {
   3244 				nfsm_clget;
   3245 				if ((bp + xfer) > be)
   3246 					tsiz = be - bp;
   3247 				else
   3248 					tsiz = xfer;
   3249 				memcpy(bp, cp, tsiz);
   3250 				bp += tsiz;
   3251 				xfer -= tsiz;
   3252 				if (xfer > 0)
   3253 					cp += tsiz;
   3254 			}
   3255 		}
   3256 invalid:
   3257 		cpos += dp->d_reclen;
   3258 		dp = (struct dirent *)cpos;
   3259 		cookiep++;
   3260 		ncookies--;
   3261 	}
   3262 	vrele(vp);
   3263 	nfsm_clget;
   3264 	*tl = nfs_false;
   3265 	bp += NFSX_UNSIGNED;
   3266 	nfsm_clget;
   3267 	if (eofflag)
   3268 		*tl = nfs_true;
   3269 	else
   3270 		*tl = nfs_false;
   3271 	bp += NFSX_UNSIGNED;
   3272 	if (mp != mb) {
   3273 		if (bp < be)
   3274 			mp->m_len = bp - mtod(mp, char *);
   3275 	} else
   3276 		mp->m_len += bp - bpos;
   3277 	free((void *)cookies, M_TEMP);
   3278 	free((void *)rbuf, M_TEMP);
   3279 	nfsm_srvdone;
   3280 }
   3281 
   3282 /*
   3283  * nfs commit service
   3284  */
   3285 int
   3286 nfsrv_commit(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   3287 {
   3288 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   3289 	struct mbuf *nam = nfsd->nd_nam;
   3290 	char *dpos = nfsd->nd_dpos;
   3291 	kauth_cred_t cred = nfsd->nd_cr;
   3292 	struct vattr bfor, aft;
   3293 	struct vnode *vp;
   3294 	nfsrvfh_t nsfh;
   3295 	u_int32_t *tl;
   3296 	int32_t t1;
   3297 	char *bpos;
   3298 	int error = 0, rdonly, for_ret = 1, aft_ret = 1, cache = 0;
   3299 	uint32_t cnt;
   3300 	char *cp2;
   3301 	struct mbuf *mb, *mreq __unused;
   3302 	u_quad_t frev, off, end;
   3303 
   3304 	nfsm_srvmtofh(&nsfh);
   3305 	nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
   3306 
   3307 	off = fxdr_hyper(tl);
   3308 	tl += 2;
   3309 	cnt = fxdr_unsigned(uint32_t, *tl);
   3310 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
   3311 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   3312 	if (error) {
   3313 		nfsm_reply(2 * NFSX_UNSIGNED);
   3314 		nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
   3315 		return (0);
   3316 	}
   3317 	for_ret = VOP_GETATTR(vp, &bfor, cred);
   3318 	end = (cnt > 0) ? off + cnt : vp->v_size;
   3319 	if (end < off || end > vp->v_size)
   3320 		end = vp->v_size;
   3321 	if (off < vp->v_size)
   3322 		error = VOP_FSYNC(vp, cred, FSYNC_WAIT, off, end);
   3323 	/* else error == 0, from nfsrv_fhtovp() */
   3324 	aft_ret = VOP_GETATTR(vp, &aft, cred);
   3325 	vput(vp);
   3326 	nfsm_reply(NFSX_V3WCCDATA + NFSX_V3WRITEVERF);
   3327 	nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
   3328 	if (!error) {
   3329 		nfsm_build(tl, u_int32_t *, NFSX_V3WRITEVERF);
   3330 		struct timeval btv;
   3331 		getmicroboottime(&btv);
   3332 		*tl++ = txdr_unsigned(btv.tv_sec);
   3333 		*tl = txdr_unsigned(btv.tv_usec);
   3334 	} else {
   3335 		return (0);
   3336 	}
   3337 	nfsm_srvdone;
   3338 }
   3339 
   3340 /*
   3341  * nfs statfs service
   3342  */
   3343 int
   3344 nfsrv_statfs(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   3345 {
   3346 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   3347 	struct mbuf *nam = nfsd->nd_nam;
   3348 	char *dpos = nfsd->nd_dpos;
   3349 	kauth_cred_t cred = nfsd->nd_cr;
   3350 	struct statvfs *sf = NULL;
   3351 	struct nfs_statfs *sfp;
   3352 	u_int32_t *tl;
   3353 	int32_t t1;
   3354 	char *bpos;
   3355 	int error = 0, rdonly, cache = 0, getret = 1;
   3356 	int v3 = (nfsd->nd_flag & ND_NFSV3);
   3357 	char *cp2;
   3358 	struct mbuf *mb, *mreq __unused;
   3359 	struct vnode *vp;
   3360 	struct vattr at;
   3361 	nfsrvfh_t nsfh;
   3362 	u_quad_t frev, tval;
   3363 
   3364 	nfsm_srvmtofh(&nsfh);
   3365 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
   3366 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   3367 	if (error) {
   3368 		nfsm_reply(NFSX_UNSIGNED);
   3369 		nfsm_srvpostop_attr(getret, &at);
   3370 		return (0);
   3371 	}
   3372 	sf = malloc(sizeof(*sf), M_TEMP, M_WAITOK);
   3373 	error = VFS_STATVFS(vp->v_mount, sf);
   3374 	getret = VOP_GETATTR(vp, &at, cred);
   3375 	vput(vp);
   3376 	nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3));
   3377 	if (v3)
   3378 		nfsm_srvpostop_attr(getret, &at);
   3379 	if (error) {
   3380 		free(sf, M_TEMP);
   3381 		return (0);
   3382 	}
   3383 	nfsm_build(sfp, struct nfs_statfs *, NFSX_STATFS(v3));
   3384 	if (v3) {
   3385 		tval = (u_quad_t)((quad_t)sf->f_blocks * (quad_t)sf->f_frsize);
   3386 		txdr_hyper(tval, &sfp->sf_tbytes);
   3387 		tval = (u_quad_t)((quad_t)sf->f_bfree * (quad_t)sf->f_frsize);
   3388 		txdr_hyper(tval, &sfp->sf_fbytes);
   3389 		tval = (u_quad_t)((quad_t)sf->f_bavail * (quad_t)sf->f_frsize);
   3390 		txdr_hyper(tval, &sfp->sf_abytes);
   3391 		tval = (u_quad_t)sf->f_files;
   3392 		txdr_hyper(tval, &sfp->sf_tfiles);
   3393 		tval = (u_quad_t)sf->f_ffree;
   3394 		txdr_hyper(tval, &sfp->sf_ffiles);
   3395 		txdr_hyper(tval, &sfp->sf_afiles);
   3396 		sfp->sf_invarsec = 0;
   3397 	} else {
   3398 		sfp->sf_tsize = txdr_unsigned(NFS_MAXDGRAMDATA);
   3399 		sfp->sf_bsize = txdr_unsigned(NFS_V2CLAMP16(sf->f_frsize));
   3400 		sfp->sf_blocks = txdr_unsigned(NFS_V2CLAMP32(sf->f_blocks));
   3401 		sfp->sf_bfree = txdr_unsigned(NFS_V2CLAMP32(sf->f_bfree));
   3402 		sfp->sf_bavail = txdr_unsigned(NFS_V2CLAMP32(sf->f_bavail));
   3403 	}
   3404 nfsmout:
   3405 	if (sf)
   3406 	    free(sf, M_TEMP);
   3407 	return error;
   3408 }
   3409 
   3410 /*
   3411  * nfs fsinfo service
   3412  */
   3413 int
   3414 nfsrv_fsinfo(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   3415 {
   3416 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   3417 	struct mbuf *nam = nfsd->nd_nam;
   3418 	char *dpos = nfsd->nd_dpos;
   3419 	kauth_cred_t cred = nfsd->nd_cr;
   3420 	u_int32_t *tl;
   3421 	struct nfsv3_fsinfo *sip;
   3422 	int32_t t1;
   3423 	char *bpos;
   3424 	int error = 0, rdonly, cache = 0, getret = 1;
   3425 	uint32_t maxdata;
   3426 	char *cp2;
   3427 	struct mbuf *mb, *mreq __unused;
   3428 	struct vnode *vp;
   3429 	struct vattr at;
   3430 	nfsrvfh_t nsfh;
   3431 	u_quad_t frev, maxfsize;
   3432 	struct statvfs *sb;
   3433 
   3434 	nfsm_srvmtofh(&nsfh);
   3435 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
   3436 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   3437 	if (error) {
   3438 		nfsm_reply(NFSX_UNSIGNED);
   3439 		nfsm_srvpostop_attr(getret, &at);
   3440 		return (0);
   3441 	}
   3442 
   3443 	/* XXX Try to make a guess on the max file size. */
   3444 	sb = malloc(sizeof(*sb), M_TEMP, M_WAITOK);
   3445 	VFS_STATVFS(vp->v_mount, sb);
   3446 	maxfsize = (u_quad_t)0x80000000 * sb->f_frsize - 1;
   3447 	free(sb, M_TEMP);
   3448 
   3449 	getret = VOP_GETATTR(vp, &at, cred);
   3450 	vput(vp);
   3451 	nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO);
   3452 	nfsm_srvpostop_attr(getret, &at);
   3453 	nfsm_build(sip, struct nfsv3_fsinfo *, NFSX_V3FSINFO);
   3454 
   3455 	/*
   3456 	 * XXX
   3457 	 * There should be file system VFS OP(s) to get this information.
   3458 	 * For now, assume ufs.
   3459 	 */
   3460 	if (slp->ns_so->so_type == SOCK_DGRAM)
   3461 		maxdata = NFS_MAXDGRAMDATA;
   3462 	else
   3463 		maxdata = NFS_MAXDATA;
   3464 	sip->fs_rtmax = txdr_unsigned(maxdata);
   3465 	sip->fs_rtpref = txdr_unsigned(maxdata);
   3466 	sip->fs_rtmult = txdr_unsigned(NFS_FABLKSIZE);
   3467 	sip->fs_wtmax = txdr_unsigned(maxdata);
   3468 	sip->fs_wtpref = txdr_unsigned(maxdata);
   3469 	sip->fs_wtmult = txdr_unsigned(NFS_FABLKSIZE);
   3470 	sip->fs_dtpref = txdr_unsigned(maxdata);
   3471 	txdr_hyper(maxfsize, &sip->fs_maxfilesize);
   3472 	sip->fs_timedelta.nfsv3_sec = 0;
   3473 	sip->fs_timedelta.nfsv3_nsec = txdr_unsigned(1);
   3474 	sip->fs_properties = txdr_unsigned(NFSV3FSINFO_LINK |
   3475 		NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
   3476 		NFSV3FSINFO_CANSETTIME);
   3477 	nfsm_srvdone;
   3478 }
   3479 
   3480 /*
   3481  * nfs pathconf service
   3482  */
   3483 int
   3484 nfsrv_pathconf(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp, struct lwp *lwp, struct mbuf **mrq)
   3485 {
   3486 	struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
   3487 	struct mbuf *nam = nfsd->nd_nam;
   3488 	char *dpos = nfsd->nd_dpos;
   3489 	kauth_cred_t cred = nfsd->nd_cr;
   3490 	u_int32_t *tl;
   3491 	struct nfsv3_pathconf *pc;
   3492 	int32_t t1;
   3493 	char *bpos;
   3494 	int error = 0, rdonly, cache = 0, getret = 1;
   3495 	register_t linkmax, namemax, chownres, notrunc;
   3496 	char *cp2;
   3497 	struct mbuf *mb, *mreq __unused;
   3498 	struct vnode *vp;
   3499 	struct vattr at;
   3500 	nfsrvfh_t nsfh;
   3501 	u_quad_t frev;
   3502 
   3503 	nfsm_srvmtofh(&nsfh);
   3504 	error = nfsrv_fhtovp(&nsfh, 1, &vp, cred, slp, nam,
   3505 		 &rdonly, (nfsd->nd_flag & ND_KERBAUTH), false);
   3506 	if (error) {
   3507 		nfsm_reply(NFSX_UNSIGNED);
   3508 		nfsm_srvpostop_attr(getret, &at);
   3509 		return (0);
   3510 	}
   3511 	error = VOP_PATHCONF(vp, _PC_LINK_MAX, &linkmax);
   3512 	if (!error)
   3513 		error = VOP_PATHCONF(vp, _PC_NAME_MAX, &namemax);
   3514 	if (!error)
   3515 		error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres);
   3516 	if (!error)
   3517 		error = VOP_PATHCONF(vp, _PC_NO_TRUNC, &notrunc);
   3518 	getret = VOP_GETATTR(vp, &at, cred);
   3519 	vput(vp);
   3520 	nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF);
   3521 	nfsm_srvpostop_attr(getret, &at);
   3522 	if (error)
   3523 		return (0);
   3524 	nfsm_build(pc, struct nfsv3_pathconf *, NFSX_V3PATHCONF);
   3525 
   3526 	pc->pc_linkmax = txdr_unsigned(linkmax);
   3527 	pc->pc_namemax = txdr_unsigned(namemax);
   3528 	pc->pc_notrunc = txdr_unsigned(notrunc);
   3529 	pc->pc_chownrestricted = txdr_unsigned(chownres);
   3530 
   3531 	/*
   3532 	 * These should probably be supported by VOP_PATHCONF(), but
   3533 	 * until msdosfs is exportable (why would you want to?), the
   3534 	 * Unix defaults should be ok.
   3535 	 */
   3536 	pc->pc_caseinsensitive = nfs_false;
   3537 	pc->pc_casepreserving = nfs_true;
   3538 	nfsm_srvdone;
   3539 }
   3540 
   3541 /*
   3542  * Null operation, used by clients to ping server
   3543  */
   3544 /* ARGSUSED */
   3545 int
   3546 nfsrv_null(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
   3547     struct lwp *lwp, struct mbuf **mrq)
   3548 {
   3549 	struct mbuf *mrep = nfsd->nd_mrep;
   3550 	char *bpos;
   3551 	int error = NFSERR_RETVOID, cache = 0;
   3552 	struct mbuf *mb, *mreq __unused;
   3553 	u_quad_t frev;
   3554 
   3555 	nfsm_reply(0);
   3556 nfsmout:
   3557 	return (0);
   3558 }
   3559 
   3560 /*
   3561  * No operation, used for obsolete procedures
   3562  */
   3563 /* ARGSUSED */
   3564 int
   3565 nfsrv_noop(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
   3566     struct lwp *lwp, struct mbuf **mrq)
   3567 {
   3568 	struct mbuf *mrep = nfsd->nd_mrep;
   3569 	char *bpos;
   3570 	int error, cache = 0;
   3571 	struct mbuf *mb, *mreq __unused;
   3572 	u_quad_t frev;
   3573 
   3574 	if (nfsd->nd_repstat)
   3575 		error = nfsd->nd_repstat;
   3576 	else
   3577 		error = EPROCUNAVAIL;
   3578 	nfsm_reply(0);
   3579 nfsmout:
   3580 	return (0);
   3581 }
   3582 
   3583 /*
   3584  * Perform access checking for vnodes obtained from file handles that would
   3585  * refer to files already opened by a Unix client. You cannot just use
   3586  * vn_writechk() and VOP_ACCESS() for two reasons.
   3587  * 1 - You must check for exported rdonly as well as MNT_RDONLY for the write case
   3588  * 2 - The owner is to be given access irrespective of mode bits for some
   3589  *     operations, so that processes that chmod after opening a file don't
   3590  *     break. I don't like this because it opens a security hole, but since
   3591  *     the nfs server opens a security hole the size of a barn door anyhow,
   3592  *     what the heck.
   3593  *
   3594  * The exception to rule 2 is EPERM. If a file is IMMUTABLE, VOP_ACCESS()
   3595  * will return EPERM instead of EACCES. EPERM is always an error.
   3596  */
   3597 int
   3598 nfsrv_access(struct vnode *vp, int flags, kauth_cred_t cred, int rdonly, struct lwp *lwp, int override)
   3599 {
   3600 	struct vattr vattr;
   3601 	int error;
   3602 	if (flags & VWRITE) {
   3603 		/* Just vn_writechk() changed to check rdonly */
   3604 		/*
   3605 		 * Disallow write attempts on read-only file systems;
   3606 		 * unless the file is a socket or a block or character
   3607 		 * device resident on the file system.
   3608 		 */
   3609 		if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
   3610 			switch (vp->v_type) {
   3611 			case VREG:
   3612 			case VDIR:
   3613 			case VLNK:
   3614 				return (EROFS);
   3615 			default:
   3616 				break;
   3617 			}
   3618 		}
   3619 
   3620 		/*
   3621 		 * If the vnode is in use as a process's text,
   3622 		 * we can't allow writing.
   3623 		 */
   3624 		if (vp->v_iflag & VI_TEXT)
   3625 			return (ETXTBSY);
   3626 	}
   3627 	error = VOP_GETATTR(vp, &vattr, cred);
   3628 	if (error)
   3629 		return (error);
   3630 	error = VOP_ACCESS(vp, flags, cred);
   3631 	/*
   3632 	 * Allow certain operations for the owner (reads and writes
   3633 	 * on files that are already open).
   3634 	 */
   3635 	if (override && error == EACCES && kauth_cred_geteuid(cred) == vattr.va_uid)
   3636 		error = 0;
   3637 	return error;
   3638 }
   3639