Attachment #235200 for bug #260011

Lines 315-321 void nfsrc_trimcache(uint64_t, uint32_t, int); Link Here

(-)sys/fs/nfs/nfs_var.h (-5 / +6 lines)
315		315
316	/* nfs_commonsubs.c */	316	/* nfs_commonsubs.c */
317	void nfscl_reqstart(struct nfsrv_descript , int, struct nfsmount ,	317	void nfscl_reqstart(struct nfsrv_descript , int, struct nfsmount ,
318	u_int8_t , int, u_int32_t , struct nfsclsession , int, int);	318	u_int8_t , int, u_int32_t , struct nfsclsession , int, int,
		319	struct ucred *);
319	void nfsm_stateidtom(struct nfsrv_descript , nfsv4stateid_t , int);	320	void nfsm_stateidtom(struct nfsrv_descript , nfsv4stateid_t , int);
320	void nfscl_fillsattr(struct nfsrv_descript , struct vattr ,	321	void nfscl_fillsattr(struct nfsrv_descript , struct vattr ,
321	vnode_t, int, u_int32_t);	322	vnode_t, int, u_int32_t);
Lines 355-368 int nfsv4_seqsession(uint32_t, uint32_t, uint32_t, str Link Here
355	struct mbuf **, uint16_t);	356	struct mbuf **, uint16_t);
356	void nfsv4_seqsess_cacherep(uint32_t, struct nfsslot , int, struct mbuf *);	357	void nfsv4_seqsess_cacherep(uint32_t, struct nfsslot , int, struct mbuf *);
357	void nfsv4_setsequence(struct nfsmount , struct nfsrv_descript ,	358	void nfsv4_setsequence(struct nfsmount , struct nfsrv_descript ,
358	struct nfsclsession *, int);	359	struct nfsclsession , int, struct ucred );
359	int nfsv4_sequencelookup(struct nfsmount , struct nfsclsession , int *,	360	int nfsv4_sequencelookup(struct nfsmount , struct nfsclsession , int *,
360	int , uint32_t , uint8_t *);	361	int , uint32_t , uint8_t *, bool);
361	void nfsv4_freeslot(struct nfsclsession *, int, bool);	362	void nfsv4_freeslot(struct nfsclsession *, int, bool);
362	struct ucred nfsrv_getgrpscred(struct ucred );	363	struct ucred nfsrv_getgrpscred(struct ucred );
363	struct nfsdevice nfsv4_findmirror(struct nfsmount );	364	struct nfsdevice nfsv4_findmirror(struct nfsmount );
364	void nfsm_set(struct nfsrv_descript *, u_int);	365	void nfsm_set(struct nfsrv_descript *, u_int);
365	struct mbuf nfsm_add_ext_pgs(struct mbuf , int, int *);	366	struct mbuf nfsm_add_ext_pgs(struct mbuf , int, int *);
		367	int nfsrpc_destroysession(struct nfsmount , struct nfsclsession ,
		368	struct ucred , NFSPROC_T );
366		369
367	/* nfs_clcomsubs.c */	370	/* nfs_clcomsubs.c */
368	void nfsm_uiombuf(struct nfsrv_descript , struct uio , int);	371	void nfsm_uiombuf(struct nfsrv_descript , struct uio , int);
Lines 529-536 int nfsrpc_exchangeid(struct nfsmount *, struct nfsclc Link Here
529	int nfsrpc_createsession(struct nfsmount , struct nfsclsession ,	532	int nfsrpc_createsession(struct nfsmount , struct nfsclsession ,
530	struct nfssockreq , struct nfsclds , uint32_t, int, struct ucred *,	533	struct nfssockreq , struct nfsclds , uint32_t, int, struct ucred *,
531	NFSPROC_T *);	534	NFSPROC_T *);
532	int nfsrpc_destroysession(struct nfsmount , struct nfsclclient ,
533	struct ucred , NFSPROC_T );
534	int nfsrpc_destroyclient(struct nfsmount , struct nfsclclient ,	535	int nfsrpc_destroyclient(struct nfsmount , struct nfsclclient ,
535	struct ucred , NFSPROC_T );	536	struct ucred , NFSPROC_T );
536	int nfsrpc_getdeviceinfo(struct nfsmount , uint8_t , int, uint32_t *,	537	int nfsrpc_getdeviceinfo(struct nfsmount , uint8_t , int, uint32_t *,




	} else if (stat == RPC_TIMEDOUT) {
		NFSINCRGLOBAL(nfsstatsv1.rpctimeouts);
		error = ETIMEDOUT;
printf("Etimedout!\n");
	} else if (stat == RPC_VERSMISMATCH) {
		NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
		error = EOPNOTSUPP;
	} else if (stat == RPC_PROGVERSMISMATCH) {
		NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
		error = EPROTONOSUPPORT;
	} else if (stat == RPC_INTR) {
		error = EINTR;
	} else if (stat == RPC_CANTSEND || stat == RPC_CANTRECV ||
	     stat == RPC_SYSTEMERROR || stat == RPC_INTR) {
		/* Check for a session slot that needs to be free'd. */
		if ((nd->nd_flag & (ND_NFSV41 | ND_HASSLOTID)) ==
		    (ND_NFSV41 | ND_HASSLOTID) && nmp != NULL &&

			 * this slot will result in an NFSERR_SEQMISORDERED
			 * error and not a bogus cached RPC reply.
			 */
printf("Disable slot=%d\n", nd->nd_slotid);
			mtx_lock(&sep->nfsess_mtx);
			sep->nfsess_slotseq[nd->nd_slotid] += 10;
			sep->nfsess_badslots |= (0x1ULL << nd->nd_slotid);
			mtx_unlock(&sep->nfsess_mtx);
			/* And free the slot. */
			nfsv4_freeslot(sep, nd->nd_slotid, false);
		}
		if (stat == RPC_INTR)
			error = EINTR;
		else {
			NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
			error = ENXIO;
		}
	} else {
		NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
		error = EACCES;

			 * If the first op is Sequence, free up the slot.
			 */
			if ((nmp != NULL && i == NFSV4OP_SEQUENCE && j != 0) ||
			   (clp != NULL && i == NFSV4OP_CBSEQUENCE && j != 0)) {
				NFSCL_DEBUG(1, "failed seq=%d\n", j);
				if (sep != NULL && i == NFSV4OP_SEQUENCE &&
				    j == NFSERR_SEQMISORDERED) {
					mtx_lock(&sep->nfsess_mtx);
					sep->nfsess_badslots |=
					    (0x1ULL << nd->nd_slotid);
					mtx_unlock(&sep->nfsess_mtx);
				}
			}
			if (((nmp != NULL && i == NFSV4OP_SEQUENCE && j == 0) ||
			    (clp != NULL && i == NFSV4OP_CBSEQUENCE &&
			    j == 0)) && sep != NULL) {

					retseq = fxdr_unsigned(uint32_t, *tl++);
					slot = fxdr_unsigned(int, *tl++);
					if ((nd->nd_flag & ND_HASSLOTID) != 0) {
						if (slot >= NFSV4_SLOTS ||
						    (i == NFSV4OP_CBSEQUENCE &&
						     slot >= NFSV4_CBSLOTS)) {
							printf("newnfs_request:"
							    " Bogus slot\n");
							    "slot=%d\n", slot);
							slot = nd->nd_slotid;
						} else if (slot !=
						    nd->nd_slotid) {
						    printf("newnfs_request:"
							" Wrong session "
							"srvslot=%d "
							"slot=%d\n", slot,
							nd->nd_slotid);
						    if (i == NFSV4OP_SEQUENCE) {
							/*
							 * Mark both slots as
							 * bad, because we do
							 * not know if the
							 * server has advanced
							 * the sequence# for
							 * either of them.
							 */
							sep->nfsess_badslots |=
							    (0x1ULL << slot);
							sep->nfsess_badslots |=
							    (0x1ULL <<
							     nd->nd_slotid);
						    }
						    slot = nd->nd_slotid;
						}
					} else if (slot != 0) {
						printf("newnfs_request: Bad "

				sep = NFSMNT_MDSSESSION(nmp);
				if (bcmp(sep->nfsess_sessionid, nd->nd_sequence,
				    NFSX_V4SESSIONID) == 0) {
printf("nfs_commonkrpc: initiate recovery\n");
					/* Initiate recovery. */
					sep->nfsess_defunct = 1;
					NFSCL_DEBUG(1, "Marked defunct\n");

				if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {
					reterr = nfsv4_sequencelookup(nmp, sep,
					    &slotpos, &maxslot, &slotseq,
					    sessionid, true);
					if (reterr == 0) {
						/* Fill in new session info. */
						NFSCL_DEBUG(1,

Lines 49-58 struct nfsv4node { Link Here

(-)sys/fs/nfs/nfscl.h (-2 / +2 lines)
49	/*	49	/*
50	* Just a macro to convert the nfscl_reqstart arguments.	50	* Just a macro to convert the nfscl_reqstart arguments.
51	*/	51	*/
52	#define NFSCL_REQSTART(n, p, v) \	52	#define NFSCL_REQSTART(n, p, v, c) \
53	nfscl_reqstart((n), (p), VFSTONFS((v)->v_mount), \	53	nfscl_reqstart((n), (p), VFSTONFS((v)->v_mount), \
54	VTONFS(v)->n_fhp->nfh_fh, VTONFS(v)->n_fhp->nfh_len, NULL, \	54	VTONFS(v)->n_fhp->nfh_fh, VTONFS(v)->n_fhp->nfh_len, NULL, \
55	NULL, 0, 0)	55	NULL, 0, 0, (c))
56		56
57	/*	57	/*
58	* These two macros convert between a lease duration and renew interval.	58	* These two macros convert between a lease duration and renew interval.

Lines 323-329 static int nfs_bigrequest[NFSV42_NPROCS] = { Link Here

(-)sys/fs/nfs/nfs_commonsubs.c (-16 / +84 lines)
323	void	323	void
324	nfscl_reqstart(struct nfsrv_descript nd, int procnum, struct nfsmount nmp,	324	nfscl_reqstart(struct nfsrv_descript nd, int procnum, struct nfsmount nmp,
325	u_int8_t nfhp, int fhlen, u_int32_t opcntpp, struct nfsclsession sep,	325	u_int8_t nfhp, int fhlen, u_int32_t opcntpp, struct nfsclsession sep,
326	int vers, int minorvers)	326	int vers, int minorvers, struct ucred *cred)
327	{	327	{
328	struct mbuf *mb;	328	struct mbuf *mb;
329	u_int32_t *tl;	329	u_int32_t *tl;
Lines 416-426 nfscl_reqstart(struct nfsrv_descript *nd, int procnum, Link Here
416	*tl = txdr_unsigned(NFSV4OP_SEQUENCE);	416	*tl = txdr_unsigned(NFSV4OP_SEQUENCE);
417	if (sep == NULL) {	417	if (sep == NULL) {
418	sep = nfsmnt_mdssession(nmp);	418	sep = nfsmnt_mdssession(nmp);
		419	/*
		420	* For MDS mount sessions, check for bad
		421	* slots. If the caller does not want this
		422	* check to be done, the "cred" argument can
		423	* be passed in as NULL.
		424	*/
419	nfsv4_setsequence(nmp, nd, sep,	425	nfsv4_setsequence(nmp, nd, sep,
420	nfs_bigreply[procnum]);	426	nfs_bigreply[procnum], cred);
421	} else	427	} else
422	nfsv4_setsequence(nmp, nd, sep,	428	nfsv4_setsequence(nmp, nd, sep,
423	nfs_bigreply[procnum]);	429	nfs_bigreply[procnum], NULL);
424	}	430	}
425	if (nfsv4_opflag[nfsv4_opmap[procnum].op].needscfh > 0) {	431	if (nfsv4_opflag[nfsv4_opmap[procnum].op].needscfh > 0) {
426	NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);	432	NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
Lines 4773-4786 nfsv4_seqsess_cacherep(uint32_t slotid, struct nfsslot Link Here
4773	*/	4779	*/
4774	void	4780	void
4775	nfsv4_setsequence(struct nfsmount nmp, struct nfsrv_descript nd,	4781	nfsv4_setsequence(struct nfsmount nmp, struct nfsrv_descript nd,
4776	struct nfsclsession *sep, int dont_replycache)	4782	struct nfsclsession sep, int dont_replycache, struct ucred cred)
4777	{	4783	{
4778	uint32_t *tl, slotseq = 0;	4784	uint32_t *tl, slotseq = 0;
4779	int error, maxslot, slotpos;	4785	int error, maxslot, slotpos;
4780	uint8_t sessionid[NFSX_V4SESSIONID];	4786	uint8_t sessionid[NFSX_V4SESSIONID];
4781		4787
4782	error = nfsv4_sequencelookup(nmp, sep, &slotpos, &maxslot, &slotseq,	4788	if (cred != NULL) {
4783	sessionid);	4789	error = nfsv4_sequencelookup(nmp, sep, &slotpos, &maxslot,
		4790	&slotseq, sessionid, false);
		4791	if (error == NFSERR_SEQMISORDERED) {
		4792	/* If all slots are bad, Destroy the session. */
		4793	nfsrpc_destroysession(nmp, sep, cred, curthread);
		4794	error = 0;
		4795	}
		4796	} else
		4797	error = nfsv4_sequencelookup(nmp, sep, &slotpos, &maxslot,
		4798	&slotseq, sessionid, true);
4784	nd->nd_maxreq = sep->nfsess_maxreq;	4799	nd->nd_maxreq = sep->nfsess_maxreq;
4785	nd->nd_maxresp = sep->nfsess_maxresp;	4800	nd->nd_maxresp = sep->nfsess_maxresp;
4786		4801
Lines 4817-4833 nfsv4_setsequence(struct nfsmount *nmp, struct nfsrv_d Link Here
4817	nd->nd_flag \|= ND_HASSEQUENCE;	4832	nd->nd_flag \|= ND_HASSEQUENCE;
4818	}	4833	}
4819		4834
		4835	/*
		4836	* If fnd_init is true, ignore the badslots.
		4837	* If fnd_init is false, return NFSERR_SEQMISORDERED of all slots are bad.
		4838	*/
4820	int	4839	int
4821	nfsv4_sequencelookup(struct nfsmount nmp, struct nfsclsession sep,	4840	nfsv4_sequencelookup(struct nfsmount nmp, struct nfsclsession sep,
4822	int slotposp, int maxslotp, uint32_t slotseqp, uint8_t sessionid)	4841	int slotposp, int maxslotp, uint32_t slotseqp, uint8_t sessionid,
		4842	bool fnd_init)
4823	{	4843	{
4824	int i, maxslot, slotpos;	4844	int i, maxslot, slotpos;
4825	uint64_t bitval;	4845	uint64_t bitval;
		4846	bool fnd_ok;
4826		4847
4827	/* Find an unused slot. */	4848	/* Find an unused slot. */
4828	slotpos = -1;	4849	slotpos = -1;
4829	maxslot = -1;	4850	maxslot = -1;
4830	mtx_lock(&sep->nfsess_mtx);	4851	mtx_lock(&sep->nfsess_mtx);
		4852	if (sep->nfsess_badslots != 0) printf("bad slots=0x%lx\n", sep->nfsess_badslots);
4831	do {	4853	do {
4832	if (nmp != NULL && sep->nfsess_defunct != 0) {	4854	if (nmp != NULL && sep->nfsess_defunct != 0) {
4833	/* Just return the bad session. */	4855	/* Just return the bad session. */
Lines 4836-4849 nfsv4_sequencelookup(struct nfsmount *nmp, struct nfsc Link Here
4836	mtx_unlock(&sep->nfsess_mtx);	4858	mtx_unlock(&sep->nfsess_mtx);
4837	return (NFSERR_BADSESSION);	4859	return (NFSERR_BADSESSION);
4838	}	4860	}
		4861	fnd_ok = fnd_init;
4839	bitval = 1;	4862	bitval = 1;
4840	for (i = 0; i < sep->nfsess_foreslots; i++) {	4863	for (i = 0; i < sep->nfsess_foreslots; i++) {
4841	if ((bitval & sep->nfsess_slots) == 0) {	4864	if ((bitval & sep->nfsess_badslots) == 0 \|\| fnd_init) {
4842	slotpos = i;	4865	fnd_ok = true;
4843	sep->nfsess_slots \|= bitval;	4866	if ((bitval & sep->nfsess_slots) == 0) {
4844	sep->nfsess_slotseq[i]++;	4867	slotpos = i;
4845	*slotseqp = sep->nfsess_slotseq[i];	4868	sep->nfsess_slots \|= bitval;
4846	break;	4869	sep->nfsess_slotseq[i]++;
		4870	*slotseqp = sep->nfsess_slotseq[i];
		4871	break;
		4872	}
4847	}	4873	}
4848	bitval <<= 1;	4874	bitval <<= 1;
4849	}	4875	}
Lines 4858-4867 nfsv4_sequencelookup(struct nfsmount *nmp, struct nfsc Link Here
4858	return (ESTALE);	4884	return (ESTALE);
4859	}	4885	}
4860	/* Wake up once/sec, to check for a forced dismount. */	4886	/* Wake up once/sec, to check for a forced dismount. */
4861	(void)mtx_sleep(&sep->nfsess_slots, &sep->nfsess_mtx,	4887	if (fnd_ok)
4862	PZERO, "nfsclseq", hz);	4888	mtx_sleep(&sep->nfsess_slots, &sep->nfsess_mtx,
		4889	PZERO, "nfsclseq", hz);
4863	}	4890	}
4864	} while (slotpos == -1);	4891	} while (slotpos == -1 && fnd_ok);
		4892	/*
		4893	* If all slots are bad, just return slot 0 and NFSERR_SEQMISORDERED.
		4894	* The caller will do a DestroySession, so that the session's use
		4895	* will get a NFSERR_BADSESSION reply from the server.
		4896	*/
		4897	if (!fnd_ok)
		4898	slotpos = 0;
		4899
4865	/* Now, find the highest slot in use. (nfsc_slots is 64bits) */	4900	/* Now, find the highest slot in use. (nfsc_slots is 64bits) */
4866	bitval = 1;	4901	bitval = 1;
4867	for (i = 0; i < 64; i++) {	4902	for (i = 0; i < 64; i++) {
Lines 4873-4878 nfsv4_sequencelookup(struct nfsmount *nmp, struct nfsc Link Here
4873	mtx_unlock(&sep->nfsess_mtx);	4908	mtx_unlock(&sep->nfsess_mtx);
4874	*slotposp = slotpos;	4909	*slotposp = slotpos;
4875	*maxslotp = maxslot;	4910	*maxslotp = maxslot;
		4911
		4912	if (!fnd_ok)
		4913	{ printf("ret seqmis\n");
		4914	return (NFSERR_SEQMISORDERED);
		4915	}
4876	return (0);	4916	return (0);
4877	}	4917	}
4878		4918
Lines 4988-4991 nfsm_add_ext_pgs(struct mbuf m, int maxextsiz, int b Link Here
4988	mp = m;	5028	mp = m;
4989	}	5029	}
4990	return (mp);	5030	return (mp);
		5031	}
		5032
		5033	/*
		5034	* Do the NFSv4.1 Destroy Session.
		5035	*/
		5036	int
		5037	nfsrpc_destroysession(struct nfsmount nmp, struct nfsclsession tsep,
		5038	struct ucred cred, NFSPROC_T p)
		5039	{
		5040	uint32_t *tl;
		5041	struct nfsrv_descript nfsd;
		5042	struct nfsrv_descript *nd = &nfsd;
		5043	int error;
		5044
		5045	nfscl_reqstart(nd, NFSPROC_DESTROYSESSION, nmp, NULL, 0, NULL, NULL, 0,
		5046	0, NULL);
		5047	NFSM_BUILD(tl, uint32_t *, NFSX_V4SESSIONID);
		5048	if (tsep == NULL)
		5049	tsep = nfsmnt_mdssession(nmp);
		5050	bcopy(tsep->nfsess_sessionid, tl, NFSX_V4SESSIONID);
		5051	nd->nd_flag \|= ND_USEGSSNAME;
		5052	error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
		5053	NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
		5054	if (error != 0)
		5055	return (error);
		5056	error = nd->nd_repstat;
		5057	m_freem(nd->nd_mrep);
		5058	return (error);
4991	}	5059	}

Lines 67-72 struct nfsclsession { Link Here

(-)sys/fs/nfs/nfsclstate.h (+1 lines)
67	SVCXPRT nfsess_xprt; / For backchannel callback */	67	SVCXPRT nfsess_xprt; / For backchannel callback */
68	uint32_t nfsess_slotseq[64]; /* Max for 64bit nm_slots */	68	uint32_t nfsess_slotseq[64]; /* Max for 64bit nm_slots */
69	uint64_t nfsess_slots;	69	uint64_t nfsess_slots;
		70	uint64_t nfsess_badslots; /* Slots possibly broken */
70	uint32_t nfsess_sequenceid;	71	uint32_t nfsess_sequenceid;
71	uint32_t nfsess_maxcache; /* Max size for cached reply. */	72	uint32_t nfsess_maxcache; /* Max size for cached reply. */
72	uint32_t nfsess_maxreq; /* Max request size. */	73	uint32_t nfsess_maxreq; /* Max request size. */




	int error;
	struct nfsrv_descript nfsd, *nd = &nfsd;

	NFSCL_REQSTART(nd, NFSPROC_NULL, vp, NULL);
	error = nfscl_request(nd, vp, p, cred, NULL);
	if (nd->nd_repstat && !error)
		error = nd->nd_repstat;


	*attrflagp = 0;
	supported = mode;
	NFSCL_REQSTART(nd, NFSPROC_ACCESS, vp, cred);
	NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
	*tl = txdr_unsigned(mode);
	if (nd->nd_flag & ND_NFSV4) {


	dp = *dpp;
	*dpp = NULL;
	nfscl_reqstart(nd, NFSPROC_OPEN, nmp, nfhp, fhlen, NULL, NULL, 0, 0,
	    cred);
	NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
	*tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
	*tl++ = txdr_unsigned(mode & NFSV4OPEN_ACCESSBOTH);

	struct nfsrv_descript nfsd, *nd = &nfsd;
	int error;

	NFSCL_REQSTART(nd, NFSPROC_OPENDOWNGRADE, vp, cred);
	NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 3 * NFSX_UNSIGNED);
	if (NFSHASNFSV4N(VFSTONFS(vp->v_mount)))
		*tl++ = 0;

	int error;

	nfscl_reqstart(nd, NFSPROC_CLOSE, nmp, op->nfso_fh,
	    op->nfso_fhlen, NULL, NULL, 0, 0, cred);
	NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
	if (NFSHASNFSV4N(nmp)) {
		*tl++ = 0;

	if (NFSHASNFSV4N(nmp))
		return (0);		/* No confirmation for NFSv4.1. */
	nfscl_reqstart(nd, NFSPROC_OPENCONFIRM, nmp, nfhp, fhlen, NULL, NULL,
	    0, 0, NULL);
	NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
	*tl++ = op->nfso_stateid.seqid;
	*tl++ = op->nfso_stateid.other[0];

			dsp->nfsclds_sess.nfsess_clientid =
			    odsp->nfsclds_sess.nfsess_clientid;
			dsp->nfsclds_sess.nfsess_sequenceid =
			    odsp->nfsclds_sess.nfsess_sequenceid + 1;
			dsp->nfsclds_flags = odsp->nfsclds_flags;
			if (dsp->nfsclds_servownlen > 0)
				memcpy(dsp->nfsclds_serverown,

			 */
			tsep = NULL;
			if (TAILQ_FIRST(&nmp->nm_sess) != NULL) {
				/*
				 * Mark the old session defunct.  Needed
				 * when called from nfscl_hasexpired().
				 */
				tsep = NFSMNT_MDSSESSION(nmp);
				tsep->nfsess_defunct = 1;
					printf("nfsrpc_setclient: "
					    "nfsess_defunct not set\n");
			}
			TAILQ_INSERT_HEAD(&nmp->nm_sess, dsp,
			    nfsclds_list);

	tsep = NFSMNT_MDSSESSION(nmp);
	NFSUNLOCKMNT(nmp);

	nfscl_reqstart(nd, NFSPROC_SETCLIENTID, nmp, NULL, 0, NULL, NULL, 0, 0,
	    NULL);
	NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
	*tl++ = txdr_unsigned(nfsboottime.tv_sec);
	*tl = txdr_unsigned(clp->nfsc_rev);

	     * and confirm it.
	     */
	    nfscl_reqstart(nd, NFSPROC_SETCLIENTIDCFRM, nmp, NULL, 0, NULL,
		NULL, 0, 0, NULL);
	    NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
	    *tl++ = tsep->nfsess_clientid.lval[0];
	    *tl++ = tsep->nfsess_clientid.lval[1];

	int error;
	nfsattrbit_t attrbits;

	NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		NFSGETATTR_ATTRBIT(&attrbits);
		(void) nfsrv_putattrbit(nd, &attrbits);

	int error, vers = NFS_VER2;
	nfsattrbit_t attrbits;

	nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, fhp, fhlen, NULL, NULL, 0, 0,
	    cred);
	if (nd->nd_flag & ND_NFSV4) {
		vers = NFS_VER4;
		NFSGETATTR_ATTRBIT(&attrbits);

		    error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
			(void) nfs_catnap(PZERO, error, "nfs_setattr");
		} else if ((error == NFSERR_EXPIRED ||
		    ((!NFSHASINT(nmp) || !NFSHASNFSV4N(nmp)) &&
		    error == NFSERR_BADSTATEID)) && clidrev != 0) {
			expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
		} else if (error == NFSERR_BADSTATEID && NFSHASINT(nmp) &&
		    NFSHASNFSV4N(nmp)) {
			error = EIO;
		}
		retrycnt++;
	} while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||

	nfsattrbit_t attrbits;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_SETATTR, vp, cred);
	if (nd->nd_flag & ND_NFSV4)
		nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
	vap->va_type = vnode_vtype(vp);

	if (NFSHASNFSV4(nmp) && len == 2 &&
		name[0] == '.' && name[1] == '.') {
		lookupp = 1;
		NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, dvp, cred);
	} else {
		NFSCL_REQSTART(nd, NFSPROC_LOOKUP, dvp, cred);
		(void) nfsm_strtom(nd, name, len);
	}
	if (nd->nd_flag & ND_NFSV4) {

	int error, len, cangetattr = 1;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_READLINK, vp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		/*
		 * And do a Getattr op.

		    error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
			(void) nfs_catnap(PZERO, error, "nfs_read");
		} else if ((error == NFSERR_EXPIRED ||
		    ((!NFSHASINT(nmp) || !NFSHASNFSV4N(nmp)) &&
		    error == NFSERR_BADSTATEID)) && clidrev != 0) {
			expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
		} else if (error == NFSERR_BADSTATEID && NFSHASINT(nmp) &&
		    NFSHASNFSV4N(nmp)) {
			error = EIO;
		}
		retrycnt++;
	} while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||

	while (tsiz > 0) {
		*attrflagp = 0;
		len = (tsiz > rsize) ? rsize : tsiz;
		NFSCL_REQSTART(nd, NFSPROC_READ, vp, cred);
		if (nd->nd_flag & ND_NFSV4)
			nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
		NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED * 3);

		    error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
			(void) nfs_catnap(PZERO, error, "nfs_write");
		} else if ((error == NFSERR_EXPIRED ||
		    ((!NFSHASINT(nmp) || !NFSHASNFSV4N(nmp)) &&
		    error == NFSERR_BADSTATEID)) && clidrev != 0) {
			expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
		} else if (error == NFSERR_BADSTATEID && NFSHASINT(nmp) &&
		    NFSHASNFSV4N(nmp)) {
			error = EIO;
		}
		retrycnt++;
	} while (error == NFSERR_GRACE || error == NFSERR_DELAY ||

		*attrflagp = 0;
		len = (tsiz > wsize) ? wsize : tsiz;
		if (do_append)
			NFSCL_REQSTART(nd, NFSPROC_APPENDWRITE, vp, cred);
		else
			NFSCL_REQSTART(nd, NFSPROC_WRITE, vp, cred);
		if (nd->nd_flag & ND_NFSV4) {
			if (do_append) {
				NFSZERO_ATTRBIT(&attrbits);

	*dattrflagp = 0;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_MKNOD, dvp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		if (vtyp == VBLK || vtyp == VCHR) {
			NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);

	*dattrflagp = 0;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_CREATE, dvp, cred);
	(void) nfsm_strtom(nd, name, namelen);
	if (nd->nd_flag & ND_NFSV3) {
		NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);

	*dattrflagp = 0;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_CREATE, dvp, cred);
	/*
	 * For V4, this is actually an Open op.
	 */

	if (NFSHASNFSV4(nmp) && ret == 0) {
		ret = nfscl_removedeleg(vp, p, &dstateid);
		if (ret == 1) {
			NFSCL_REQSTART(nd, NFSPROC_RETDELEGREMOVE, vp, cred);
			NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID +
			    NFSX_UNSIGNED);
			if (NFSHASNFSV4N(nmp))

		ret = 0;
	}
	if (ret == 0)
		NFSCL_REQSTART(nd, NFSPROC_REMOVE, dvp, cred);
	(void) nfsm_strtom(nd, name, namelen);
	error = nfscl_request(nd, dvp, p, cred, dstuff);
	if (error)

		ret = nfscl_renamedeleg(fvp, &fdstateid, &gotfd, tvp,
		    &tdstateid, &gottd, p);
		if (gotfd && gottd) {
			NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME2, fvp, cred);
		} else if (gotfd) {
			NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME1, fvp, cred);
		} else if (gottd) {
			NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME1, tvp, cred);
		}
		if (gotfd) {
			NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);

		ret = 0;
	}
	if (ret == 0)
		NFSCL_REQSTART(nd, NFSPROC_RENAME, fdvp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
		*tl = txdr_unsigned(NFSV4OP_GETATTR);

	*dattrflagp = 0;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_LINK, vp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
		*tl = txdr_unsigned(NFSV4OP_PUTFH);

	slen = strlen(target);
	if (slen > NFS_MAXPATHLEN || namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_SYMLINK, dvp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
		*tl = txdr_unsigned(NFLNK);

	fhp = VTONFS(dvp)->n_fhp;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_MKDIR, dvp, cred);
	if (nd->nd_flag & ND_NFSV4) {
		NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
		*tl = txdr_unsigned(NFDIR);

	*dattrflagp = 0;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_RMDIR, dvp, cred);
	(void) nfsm_strtom(nd, name, namelen);
	error = nfscl_request(nd, dvp, p, cred, dstuff);
	if (error)

		 * Joy, oh joy. For V4 we get to hand craft '.' and '..'.
		 */
		if (uiop->uio_offset == 0) {
			NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, vp, cred);
			NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
			*tl++ = txdr_unsigned(NFSV4OP_GETFH);
			*tl = txdr_unsigned(NFSV4OP_GETATTR);

	 */
	while (more_dirs && bigenough) {
		*attrflagp = 0;
		NFSCL_REQSTART(nd, NFSPROC_READDIR, vp, cred);
		if (nd->nd_flag & ND_NFSV2) {
			NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
			*tl++ = cookie.lval[1];

		 * Joy, oh joy. For V4 we get to hand craft '.' and '..'.
		 */
		if (uiop->uio_offset == 0) {
			NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, vp, cred);
			NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
			*tl++ = txdr_unsigned(NFSV4OP_GETFH);
			*tl = txdr_unsigned(NFSV4OP_GETATTR);

	 */
	while (more_dirs && bigenough) {
		*attrflagp = 0;
		NFSCL_REQSTART(nd, NFSPROC_READDIRPLUS, vp, cred);
 		NFSM_BUILD(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
		*tl++ = cookie.lval[0];
		*tl++ = cookie.lval[1];

	struct nfsmount *nmp = VFSTONFS(vp->v_mount);

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_COMMIT, vp, cred);
	NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
	txdr_hyper(offset, tl);
	tl += 2;

	struct nfsclsession *tsep;

	nmp = VFSTONFS(vp->v_mount);
	NFSCL_REQSTART(nd, NFSPROC_LOCKT, vp, cred);
	NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
	if (fl->l_type == F_RDLCK)
		*tl++ = txdr_unsigned(NFSV4LOCKT_READ);

	int error;

	nfscl_reqstart(nd, NFSPROC_LOCKU, nmp, lp->nfsl_open->nfso_fh,
	    lp->nfsl_open->nfso_fhlen, NULL, NULL, 0, 0, cred);
	NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 6 * NFSX_UNSIGNED);
	*tl++ = txdr_unsigned(type);
	*tl = txdr_unsigned(lp->nfsl_seqid);

	uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
	struct nfsclsession *tsep;

	nfscl_reqstart(nd, NFSPROC_LOCK, nmp, nfhp, fhlen, NULL, NULL, 0, 0,
	    cred);
	NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
	if (type == F_RDLCK)
		*tl++ = txdr_unsigned(NFSV4LOCKT_READ);

		/*
		 * For V4, you actually do a getattr.
		 */
		NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp, cred);
		NFSSTATFS_GETATTRBIT(&attrbits);
		(void) nfsrv_putattrbit(nd, &attrbits);
		nd->nd_flag |= ND_USEGSSNAME;

		if (error)
			goto nfsmout;
	} else {
		NFSCL_REQSTART(nd, NFSPROC_FSSTAT, vp, NULL);
		error = nfscl_request(nd, vp, p, cred, stuff);
		if (error)
			return (error);

		/*
		 * For V4, you actually do a getattr.
		 */
		NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp, cred);
		NFSPATHCONF_GETATTRBIT(&attrbits);
		(void) nfsrv_putattrbit(nd, &attrbits);
		nd->nd_flag |= ND_USEGSSNAME;

			error = nd->nd_repstat;
		}
	} else {
		NFSCL_REQSTART(nd, NFSPROC_PATHCONF, vp, NULL);
		error = nfscl_request(nd, vp, p, cred, stuff);
		if (error)
			return (error);

	int error;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_FSINFO, vp, NULL);
	error = nfscl_request(nd, vp, p, cred, stuff);
	if (error)
		return (error);

		return (0);
	if (dsp == NULL)
		nfscl_reqstart(nd, NFSPROC_RENEW, nmp, NULL, 0, NULL, NULL, 0,
		    0, cred);
	else
		nfscl_reqstart(nd, NFSPROC_RENEW, nmp, NULL, 0, NULL,
		    &dsp->nfsclds_sess, 0, 0, NULL);
	if (!NFSHASNFSV4N(nmp)) {
		/* NFSv4.1 just uses a Sequence Op and not a Renew. */
		NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);

	if (NFSHASNFSV4N(nmp)) {
		/* For NFSv4.1, do a FreeStateID. */
		nfscl_reqstart(nd, NFSPROC_FREESTATEID, nmp, NULL, 0, NULL,
		    NULL, 0, 0, cred);
		nfsm_stateidtom(nd, &lp->nfsl_stateid, NFSSTATEID_PUTSTATEID);
	} else {
		nfscl_reqstart(nd, NFSPROC_RELEASELCKOWN, nmp, NULL, 0, NULL,
		    NULL, 0, 0, NULL);
		NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
		tsep = nfsmnt_mdssession(nmp);
		*tl++ = tsep->nfsess_clientid.lval[0];

	u_int32_t *opcntp;

	nfscl_reqstart(nd, NFSPROC_PUTROOTFH, nmp, NULL, 0, &opcntp, NULL, 0,
	    0, NULL);
	cp = dirpath;
	cnt = 0;
	do {

	int error;

	nfscl_reqstart(nd, NFSPROC_DELEGRETURN, nmp, dp->nfsdl_fh,
	    dp->nfsdl_fhlen, NULL, NULL, 0, 0, cred);
	NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
	if (NFSHASNFSV4N(nmp))
		*tl++ = 0;


	if (nfsrv_useacl == 0 || !NFSHASNFSV4(nmp))
		return (EOPNOTSUPP);
	NFSCL_REQSTART(nd, NFSPROC_GETACL, vp, cred);
	NFSZERO_ATTRBIT(&attrbits);
	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
	(void) nfsrv_putattrbit(nd, &attrbits);


	if (!NFSHASNFSV4(nmp))
		return (EOPNOTSUPP);
	NFSCL_REQSTART(nd, NFSPROC_SETACL, vp, cred);
	nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
	NFSZERO_ATTRBIT(&attrbits);
	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);

	if (minorvers == 0)
		minorvers = nmp->nm_minorvers;
	nfscl_reqstart(nd, NFSPROC_EXCHANGEID, nmp, NULL, 0, NULL, NULL,
	    NFS_VER4, minorvers, NULL);
	NFSM_BUILD(tl, uint32_t *, 2 * NFSX_UNSIGNED);
	*tl++ = txdr_unsigned(nfsboottime.tv_sec);	/* Client owner */
	*tl = txdr_unsigned(clp->nfsc_rev);

	else
		minorvers = NFSV41_MINORVERSION;
	nfscl_reqstart(nd, NFSPROC_CREATESESSION, nmp, NULL, 0, NULL, NULL,
	    NFS_VER4, minorvers, NULL);
	NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
	*tl++ = sep->nfsess_clientid.lval[0];
	*tl++ = sep->nfsess_clientid.lval[1];

}

/*
 * Do the NFSv4.1 Destroy Session.
 */
int
nfsrpc_destroysession(struct nfsmount *nmp, struct nfsclclient *clp,
    struct ucred *cred, NFSPROC_T *p)
{
	uint32_t *tl;
	struct nfsrv_descript nfsd;
	struct nfsrv_descript *nd = &nfsd;
	int error;
	struct nfsclsession *tsep;

	nfscl_reqstart(nd, NFSPROC_DESTROYSESSION, nmp, NULL, 0, NULL, NULL, 0,
	    0);
	NFSM_BUILD(tl, uint32_t *, NFSX_V4SESSIONID);
	tsep = nfsmnt_mdssession(nmp);
	bcopy(tsep->nfsess_sessionid, tl, NFSX_V4SESSIONID);
	nd->nd_flag |= ND_USEGSSNAME;
	error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
	    NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
	if (error != 0)
		return (error);
	error = nd->nd_repstat;
	m_freem(nd->nd_mrep);
	return (error);
}

/*
 * Do the NFSv4.1 Destroy Client.
 */
int

	struct nfsclsession *tsep;

	nfscl_reqstart(nd, NFSPROC_DESTROYCLIENT, nmp, NULL, 0, NULL, NULL, 0,
	    0, NULL);
	NFSM_BUILD(tl, uint32_t *, 2 * NFSX_UNSIGNED);
	tsep = nfsmnt_mdssession(nmp);
	*tl++ = tsep->nfsess_clientid.lval[0];

	int error;

	nfscl_reqstart(nd, NFSPROC_LAYOUTGET, nmp, fhp, fhlen, NULL, NULL, 0,
	    0, cred);
	nfsrv_setuplayoutget(nd, iomode, offset, len, minlen, stateidp,
	    layouttype, layoutlen, 0);
	nd->nd_flag |= ND_USEGSSNAME;

	ndi = NULL;
	gotdspp = NULL;
	nfscl_reqstart(nd, NFSPROC_GETDEVICEINFO, nmp, NULL, 0, NULL, NULL, 0,
	    0, cred);
	NFSM_BUILD(tl, uint32_t *, NFSX_V4DEVICEID + 3 * NFSX_UNSIGNED);
	NFSBCOPY(deviceid, tl, NFSX_V4DEVICEID);
	tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);

	int error;

	nfscl_reqstart(nd, NFSPROC_LAYOUTCOMMIT, nmp, fh, fhlen, NULL, NULL,
	    0, 0, cred);
	NFSM_BUILD(tl, uint32_t *, 5 * NFSX_UNSIGNED + 3 * NFSX_HYPER +
	    NFSX_STATEID);
	txdr_hyper(off, tl);

	int error;

	nfscl_reqstart(nd, NFSPROC_LAYOUTRETURN, nmp, fh, fhlen, NULL, NULL,
	    0, 0, cred);
	NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
	if (reclaim != 0)
		*tl++ = newnfs_true;

	int error;

	nfscl_reqstart(nd, NFSPROC_LAYOUTERROR, nmp, fh, fhlen, NULL, NULL,
	    0, 0, cred);
	NFSM_BUILD(tl, uint32_t *, 2 * NFSX_HYPER + NFSX_STATEID +
	    NFSX_V4DEVICEID + 3 * NFSX_UNSIGNED);
	txdr_hyper(offset, tl); tl += 2;

	int error;

	nfscl_reqstart(nd, NFSPROC_RECLAIMCOMPL, nmp, NULL, 0, NULL, NULL, 0,
	    0, cred);
	NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
	*tl = newnfs_false;
	nd->nd_flag |= ND_USEGSSNAME;

	for (i = 0; i < 64; i++)
		sep->nfsess_slotseq[i] = 0;
	sep->nfsess_slots = 0;
	sep->nfsess_badslots = 0;
}

/*

	nd->nd_mrep = NULL;
	if (vers == 0 || vers == NFS_VER4) {
		nfscl_reqstart(nd, NFSPROC_READDS, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		vers = NFS_VER4;
		NFSCL_DEBUG(4, "nfsrpc_readds: vers4 minvers=%d\n", minorvers);
		if (flex != 0)

			nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSEQIDZERO);
	} else {
		nfscl_reqstart(nd, NFSPROC_READ, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		NFSDECRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_READ]);
		NFSINCRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_READDS]);
		NFSCL_DEBUG(4, "nfsrpc_readds: vers3\n");

	nd->nd_mrep = NULL;
	if (vers == 0 || vers == NFS_VER4) {
		nfscl_reqstart(nd, NFSPROC_WRITEDS, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		NFSCL_DEBUG(4, "nfsrpc_writeds: vers4 minvers=%d\n", minorvers);
		vers = NFS_VER4;
		if (flex != 0)

		NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
	} else {
		nfscl_reqstart(nd, NFSPROC_WRITE, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		NFSDECRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_WRITE]);
		NFSINCRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_WRITEDS]);
		NFSCL_DEBUG(4, "nfsrpc_writeds: vers3\n");

	nd->nd_mrep = NULL;
	if (vers == 0 || vers == NFS_VER4) {
		nfscl_reqstart(nd, NFSPROC_WRITEDS, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		vers = NFS_VER4;
		NFSCL_DEBUG(4, "nfsrpc_writedsmir: vers4 minvers=%d\n",
		    minorvers);

		NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
	} else {
		nfscl_reqstart(nd, NFSPROC_WRITE, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		NFSDECRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_WRITE]);
		NFSINCRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_WRITEDS]);
		NFSCL_DEBUG(4, "nfsrpc_writedsmir: vers3\n");

	nd->nd_mrep = NULL;
	if (vers == 0 || vers == NFS_VER4) {
		nfscl_reqstart(nd, NFSPROC_COMMITDS, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		vers = NFS_VER4;
	} else {
		nfscl_reqstart(nd, NFSPROC_COMMIT, nmp, fhp->nfh_fh,
		    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers,
		    NULL);
		NFSDECRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_COMMIT]);
		NFSINCRGLOBAL(nfsstatsv1.rpccnt[NFSPROC_COMMITDS]);
	}

		NFSSETBIT_ATTRBIT(&hints, NFSV4IOHINT_DONTNEED);
	else
		return (0);
	NFSCL_REQSTART(nd, NFSPROC_IOADVISE, vp, cred);
	nfsm_stateidtom(nd, NULL, NFSSTATEID_PUTALLZERO);
	NFSM_BUILD(tl, uint32_t *, 2 * NFSX_HYPER);
	txdr_hyper(offset, tl);

		return (0);
	nd->nd_mrep = NULL;
	nfscl_reqstart(nd, NFSPROC_IOADVISEDS, nmp, fhp->nfh_fh,
	    fhp->nfh_len, NULL, &dsp->nfsclds_sess, vers, minorvers, NULL);
	vers = NFS_VER4;
	NFSCL_DEBUG(4, "nfsrpc_adviseds: vers=%d minvers=%d\n", vers,
	    minorvers);

		    error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
		    error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
			(void) nfs_catnap(PZERO, error, "nfs_allocate");
		} else if ((error == NFSERR_EXPIRED || (!NFSHASINT(nmp) &&
		    error == NFSERR_BADSTATEID)) && clidrev != 0) {
			expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
		} else if (error == NFSERR_BADSTATEID && NFSHASINT(nmp)) {
			error = EIO;
		}
		retrycnt++;
	} while (error == NFSERR_GRACE || error == NFSERR_DELAY ||

	nfsattrbit_t attrbits;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_ALLOCATE, vp, cred);
	nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
	NFSM_BUILD(tl, uint32_t *, 2 * NFSX_HYPER + NFSX_UNSIGNED);
	txdr_hyper(off, tl); tl += 2;

	*dpp = NULL;
	*laystatp = ENXIO;
	nfscl_reqstart(nd, NFSPROC_OPENLAYGET, nmp, nfhp, fhlen, NULL, NULL,
	    0, 0, cred);
	NFSM_BUILD(tl, uint32_t *, 5 * NFSX_UNSIGNED);
	*tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
	*tl++ = txdr_unsigned(mode & NFSV4OPEN_ACCESSBOTH);

	*dattrflagp = 0;
	if (namelen > NFS_MAXNAMLEN)
		return (ENAMETOOLONG);
	NFSCL_REQSTART(nd, NFSPROC_CREATELAYGET, dvp, cred);
	/*
	 * For V4, this is actually an Open op.
	 */

		    error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
		    error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
			(void) nfs_catnap(PZERO, error, "nfs_cfr");
		} else if ((error == NFSERR_EXPIRED || (!NFSHASINT(nmp) &&
		    error == NFSERR_BADSTATEID)) && clidrev != 0) {
			expireret = nfscl_hasexpired(nmp->nm_clp, clidrev,
			    curthread);
		} else if (error == NFSERR_BADSTATEID && NFSHASINT(nmp)) {
			error = EIO;
		}
		retrycnt++;
	} while (error == NFSERR_GRACE || error == NFSERR_DELAY ||

	*lenp = 0;
	if (len > nfs_maxcopyrange)
		len = nfs_maxcopyrange;
	NFSCL_REQSTART(nd, NFSPROC_COPY, invp, cred);
	NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
	*tl = txdr_unsigned(NFSV4OP_GETATTR);
	NFSGETATTR_ATTRBIT(&attrbits);

		    error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
		    error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
			(void) nfs_catnap(PZERO, error, "nfs_seek");
		} else if ((error == NFSERR_EXPIRED || (!NFSHASINT(nmp) &&
		    error == NFSERR_BADSTATEID)) && clidrev != 0) {
			expireret = nfscl_hasexpired(nmp->nm_clp, clidrev,
			    curthread);
		} else if (error == NFSERR_BADSTATEID && NFSHASINT(nmp)) {
			error = EIO;
		}
		retrycnt++;
	} while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||

	nfsattrbit_t attrbits;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_SEEK, vp, cred);
	nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
	txdr_hyper(*offp, tl); tl += 2;

	uint32_t len, len2;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_GETEXTATTR, vp, cred);
	nfsm_strtom(nd, name, strlen(name));
	NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
	*tl = txdr_unsigned(NFSV4OP_GETATTR);

	nfsattrbit_t attrbits;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_SETEXTATTR, vp, cred);
	if (uiop->uio_resid > nd->nd_maxreq) {
		/* nd_maxreq is set by NFSCL_REQSTART(). */
		m_freem(nd->nd_mreq);

	nfsattrbit_t attrbits;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_RMEXTATTR, vp, cred);
	nfsm_strtom(nd, name, strlen(name));
	NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
	*tl = txdr_unsigned(NFSV4OP_GETATTR);

	u_char c;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_LISTEXTATTR, vp, cred);
	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
	txdr_hyper(*cookiep, tl); tl += 2;
	*tl++ = txdr_unsigned(*lenp);

	int error;

	nfscl_reqstart(nd, NFSPROC_BINDCONNTOSESS, NULL, NULL, 0, NULL, NULL,
	    NFS_VER4, rcp->minorvers, NULL);
	NFSM_BUILD(tl, uint32_t *, NFSX_V4SESSIONID + 2 * NFSX_UNSIGNED);
	memcpy(tl, rcp->sessionid, NFSX_V4SESSIONID);
	tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;

Lines 2089-2095 nfscl_umount(struct nfsmount nmp, NFSPROC_T p, struc Link Here

(-)sys/fs/nfsclient/nfs_clstate.c (-1 / +1 lines)
2089	nfscl_delegreturnall(clp, p, dhp);	2089	nfscl_delegreturnall(clp, p, dhp);
2090	cred = newnfs_getcred();	2090	cred = newnfs_getcred();
2091	if (NFSHASNFSV4N(nmp)) {	2091	if (NFSHASNFSV4N(nmp)) {
2092	(void)nfsrpc_destroysession(nmp, clp, cred, p);	2092	(void)nfsrpc_destroysession(nmp, NULL, cred, p);
2093	(void)nfsrpc_destroyclient(nmp, clp, cred, p);	2093	(void)nfsrpc_destroyclient(nmp, clp, cred, p);
2094	} else	2094	} else
2095	(void)nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);	2095	(void)nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);

Lines 6638-6644 nfsv4_setcbsequence(struct nfsrv_descript *nd, struct Link Here

(-)sys/fs/nfsserver/nfs_nfsdstate.c (-1 / +1 lines)
6638	return (error);	6638	return (error);
6639	sep = *sepp;	6639	sep = *sepp;
6640	(void)nfsv4_sequencelookup(NULL, &sep->sess_cbsess, slotposp, &maxslot,	6640	(void)nfsv4_sequencelookup(NULL, &sep->sess_cbsess, slotposp, &maxslot,
6641	&slotseq, sessionid);	6641	&slotseq, sessionid, true);
6642	KASSERT(maxslot >= 0, ("nfsv4_setcbsequence neg maxslot"));	6642	KASSERT(maxslot >= 0, ("nfsv4_setcbsequence neg maxslot"));
6643		6643
6644	/* Build the Sequence arguments. */	6644	/* Build the Sequence arguments. */




	st.other[2] = 0x55555555;
	st.seqid = 0xffffffff;
	nfscl_reqstart(nd, NFSPROC_READDS, nmp, (u_int8_t *)fhp, sizeof(*fhp),
	    NULL, NULL, 0, 0, cred);
	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
	NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED * 3);
	txdr_hyper(off, tl);


	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
	nfscl_reqstart(nd, NFSPROC_WRITE, nmp, (u_int8_t *)fhp,
	    sizeof(fhandle_t), NULL, NULL, 0, 0, cred);

	/*
	 * Use a stateid where other is an alternating 01010 pattern and


	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
	nfscl_reqstart(nd, NFSPROC_ALLOCATE, nmp, (u_int8_t *)fhp,
	    sizeof(fhandle_t), NULL, NULL, 0, 0, cred);

	/*
	 * Use a stateid where other is an alternating 01010 pattern and

	st.other[2] = 0x55555555;
	st.seqid = 0xffffffff;
	nfscl_reqstart(nd, NFSPROC_SETATTR, nmp, (u_int8_t *)fhp, sizeof(*fhp),
	    NULL, NULL, 0, 0, cred);
	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
	nfscl_fillsattr(nd, &nap->na_vattr, vp, NFSSATTR_FULL, 0);


	st.other[2] = 0x55555555;
	st.seqid = 0xffffffff;
	nfscl_reqstart(nd, NFSPROC_SETACL, nmp, (u_int8_t *)fhp, sizeof(*fhp),
	    NULL, NULL, 0, 0, cred);
	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
	NFSZERO_ATTRBIT(&attrbits);
	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);

	NFSD_DEBUG(4, "in nfsrv_getattrdsrpc\n");
	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
	nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, (u_int8_t *)fhp,
	    sizeof(fhandle_t), NULL, NULL, 0, 0, cred);
	NFSZERO_ATTRBIT(&attrbits);
	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);
	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);

	st.seqid = 0xffffffff;
	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
	nfscl_reqstart(nd, NFSPROC_SEEKDS, nmp, (u_int8_t *)fhp,
	    sizeof(fhandle_t), NULL, NULL, 0, 0, cred);
	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);
	txdr_hyper(*offp, tl); tl += 2;

Return to bug 260011

Lines 919-934 tryagain: Link Here

(-)sys/fs/nfs/nfs_commonkrpc.c (-10 / +48 lines)
919	} else if (stat == RPC_TIMEDOUT) {	919	} else if (stat == RPC_TIMEDOUT) {
920	NFSINCRGLOBAL(nfsstatsv1.rpctimeouts);	920	NFSINCRGLOBAL(nfsstatsv1.rpctimeouts);
921	error = ETIMEDOUT;	921	error = ETIMEDOUT;
		922	printf("Etimedout!\n");
922	} else if (stat == RPC_VERSMISMATCH) {	923	} else if (stat == RPC_VERSMISMATCH) {
923	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);	924	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
924	error = EOPNOTSUPP;	925	error = EOPNOTSUPP;
925	} else if (stat == RPC_PROGVERSMISMATCH) {	926	} else if (stat == RPC_PROGVERSMISMATCH) {
926	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);	927	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
927	error = EPROTONOSUPPORT;	928	error = EPROTONOSUPPORT;
928	} else if (stat == RPC_INTR) {
929	error = EINTR;
930	} else if (stat == RPC_CANTSEND \|\| stat == RPC_CANTRECV \|\|	929	} else if (stat == RPC_CANTSEND \|\| stat == RPC_CANTRECV \|\|
931	stat == RPC_SYSTEMERROR) {	930	stat == RPC_SYSTEMERROR \|\| stat == RPC_INTR) {
932	/* Check for a session slot that needs to be free'd. */	931	/* Check for a session slot that needs to be free'd. */
933	if ((nd->nd_flag & (ND_NFSV41 \| ND_HASSLOTID)) ==	932	if ((nd->nd_flag & (ND_NFSV41 \| ND_HASSLOTID)) ==
934	(ND_NFSV41 \| ND_HASSLOTID) && nmp != NULL &&	933	(ND_NFSV41 \| ND_HASSLOTID) && nmp != NULL &&
Lines 949-962 tryagain: Link Here
949	* this slot will result in an NFSERR_SEQMISORDERED	948	* this slot will result in an NFSERR_SEQMISORDERED
950	* error and not a bogus cached RPC reply.	949	* error and not a bogus cached RPC reply.
951	*/	950	*/
		951	printf("Disable slot=%d\n", nd->nd_slotid);
952	mtx_lock(&sep->nfsess_mtx);	952	mtx_lock(&sep->nfsess_mtx);
953	sep->nfsess_slotseq[nd->nd_slotid] += 10;	953	sep->nfsess_slotseq[nd->nd_slotid] += 10;
		954	sep->nfsess_badslots \|= (0x1ULL << nd->nd_slotid);
954	mtx_unlock(&sep->nfsess_mtx);	955	mtx_unlock(&sep->nfsess_mtx);
955	/* And free the slot. */	956	/* And free the slot. */
956	nfsv4_freeslot(sep, nd->nd_slotid, false);	957	nfsv4_freeslot(sep, nd->nd_slotid, false);
957	}	958	}
958	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);	959	if (stat == RPC_INTR)
959	error = ENXIO;	960	error = EINTR;
		961	else {
		962	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
		963	error = ENXIO;
		964	}
960	} else {	965	} else {
961	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);	966	NFSINCRGLOBAL(nfsstatsv1.rpcinvalid);
962	error = EACCES;	967	error = EACCES;
Lines 1019-1026 tryagain: Link Here
1019	* If the first op is Sequence, free up the slot.	1024	* If the first op is Sequence, free up the slot.
1020	*/	1025	*/
1021	if ((nmp != NULL && i == NFSV4OP_SEQUENCE && j != 0) \|\|	1026	if ((nmp != NULL && i == NFSV4OP_SEQUENCE && j != 0) \|\|
1022	(clp != NULL && i == NFSV4OP_CBSEQUENCE && j != 0))	1027	(clp != NULL && i == NFSV4OP_CBSEQUENCE && j != 0)) {
1023	NFSCL_DEBUG(1, "failed seq=%d\n", j);	1028	NFSCL_DEBUG(1, "failed seq=%d\n", j);
		1029	if (sep != NULL && i == NFSV4OP_SEQUENCE &&
		1030	j == NFSERR_SEQMISORDERED) {
		1031	mtx_lock(&sep->nfsess_mtx);
		1032	sep->nfsess_badslots \|=
		1033	(0x1ULL << nd->nd_slotid);
		1034	mtx_unlock(&sep->nfsess_mtx);
		1035	}
		1036	}
1024	if (((nmp != NULL && i == NFSV4OP_SEQUENCE && j == 0) \|\|	1037	if (((nmp != NULL && i == NFSV4OP_SEQUENCE && j == 0) \|\|
1025	(clp != NULL && i == NFSV4OP_CBSEQUENCE &&	1038	(clp != NULL && i == NFSV4OP_CBSEQUENCE &&
1026	j == 0)) && sep != NULL) {	1039	j == 0)) && sep != NULL) {
Lines 1039-1049 tryagain: Link Here
1039	retseq = fxdr_unsigned(uint32_t, *tl++);	1052	retseq = fxdr_unsigned(uint32_t, *tl++);
1040	slot = fxdr_unsigned(int, *tl++);	1053	slot = fxdr_unsigned(int, *tl++);
1041	if ((nd->nd_flag & ND_HASSLOTID) != 0) {	1054	if ((nd->nd_flag & ND_HASSLOTID) != 0) {
1042	if (slot != nd->nd_slotid) {	1055	if (slot >= NFSV4_SLOTS \|\|
		1056	(i == NFSV4OP_CBSEQUENCE &&
		1057	slot >= NFSV4_CBSLOTS)) {
1043	printf("newnfs_request:"	1058	printf("newnfs_request:"
1044	" Wrong session "	1059	" Bogus slot\n");
1045	"slot=%d\n", slot);
1046	slot = nd->nd_slotid;	1060	slot = nd->nd_slotid;
		1061	} else if (slot !=
		1062	nd->nd_slotid) {
		1063	printf("newnfs_request:"
		1064	" Wrong session "
		1065	"srvslot=%d "
		1066	"slot=%d\n", slot,
		1067	nd->nd_slotid);
		1068	if (i == NFSV4OP_SEQUENCE) {
		1069	/*
		1070	* Mark both slots as
		1071	* bad, because we do
		1072	* not know if the
		1073	* server has advanced
		1074	* the sequence# for
		1075	* either of them.
		1076	*/
		1077	sep->nfsess_badslots \|=
		1078	(0x1ULL << slot);
		1079	sep->nfsess_badslots \|=
		1080	(0x1ULL <<
		1081	nd->nd_slotid);
		1082	}
		1083	slot = nd->nd_slotid;
1047	}	1084	}
1048	} else if (slot != 0) {	1085	} else if (slot != 0) {
1049	printf("newnfs_request: Bad "	1086	printf("newnfs_request: Bad "
Lines 1096-1101 tryagain: Link Here
1096	sep = NFSMNT_MDSSESSION(nmp);	1133	sep = NFSMNT_MDSSESSION(nmp);
1097	if (bcmp(sep->nfsess_sessionid, nd->nd_sequence,	1134	if (bcmp(sep->nfsess_sessionid, nd->nd_sequence,
1098	NFSX_V4SESSIONID) == 0) {	1135	NFSX_V4SESSIONID) == 0) {
		1136	printf("nfs_commonkrpc: initiate recovery\n");
1099	/* Initiate recovery. */	1137	/* Initiate recovery. */
1100	sep->nfsess_defunct = 1;	1138	sep->nfsess_defunct = 1;
1101	NFSCL_DEBUG(1, "Marked defunct\n");	1139	NFSCL_DEBUG(1, "Marked defunct\n");
Lines 1121-1127 tryagain: Link Here
1121	if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {	1159	if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {
1122	reterr = nfsv4_sequencelookup(nmp, sep,	1160	reterr = nfsv4_sequencelookup(nmp, sep,
1123	&slotpos, &maxslot, &slotseq,	1161	&slotpos, &maxslot, &slotseq,
1124	sessionid);	1162	sessionid, true);
1125	if (reterr == 0) {	1163	if (reterr == 0) {
1126	/* Fill in new session info. */	1164	/* Fill in new session info. */
1127	NFSCL_DEBUG(1,	1165	NFSCL_DEBUG(1,

Lines 5235-5241 nfsrv_readdsrpc(fhandle_t *fhp, off_t off, int len, st Link Here

(-)sys/fs/nfsserver/nfs_nfsdport.c (-7 / +7 lines)
5235	st.other[2] = 0x55555555;	5235	st.other[2] = 0x55555555;
5236	st.seqid = 0xffffffff;	5236	st.seqid = 0xffffffff;
5237	nfscl_reqstart(nd, NFSPROC_READDS, nmp, (u_int8_t )fhp, sizeof(fhp),	5237	nfscl_reqstart(nd, NFSPROC_READDS, nmp, (u_int8_t )fhp, sizeof(fhp),
5238	NULL, NULL, 0, 0);	5238	NULL, NULL, 0, 0, cred);
5239	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	5239	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5240	NFSM_BUILD(tl, uint32_t , NFSX_UNSIGNED 3);	5240	NFSM_BUILD(tl, uint32_t , NFSX_UNSIGNED 3);
5241	txdr_hyper(off, tl);	5241	txdr_hyper(off, tl);
Lines 5343-5349 nfsrv_writedsdorpc(struct nfsmount nmp, fhandle_t fh Link Here
5343		5343
5344	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	5344	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
5345	nfscl_reqstart(nd, NFSPROC_WRITE, nmp, (u_int8_t *)fhp,	5345	nfscl_reqstart(nd, NFSPROC_WRITE, nmp, (u_int8_t *)fhp,
5346	sizeof(fhandle_t), NULL, NULL, 0, 0);	5346	sizeof(fhandle_t), NULL, NULL, 0, 0, cred);
5347		5347
5348	/*	5348	/*
5349	* Use a stateid where other is an alternating 01010 pattern and	5349	* Use a stateid where other is an alternating 01010 pattern and
Lines 5565-5571 nfsrv_allocatedsdorpc(struct nfsmount *nmp, fhandle_t Link Here
5565		5565
5566	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	5566	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
5567	nfscl_reqstart(nd, NFSPROC_ALLOCATE, nmp, (u_int8_t *)fhp,	5567	nfscl_reqstart(nd, NFSPROC_ALLOCATE, nmp, (u_int8_t *)fhp,
5568	sizeof(fhandle_t), NULL, NULL, 0, 0);	5568	sizeof(fhandle_t), NULL, NULL, 0, 0, cred);
5569		5569
5570	/*	5570	/*
5571	* Use a stateid where other is an alternating 01010 pattern and	5571	* Use a stateid where other is an alternating 01010 pattern and
Lines 5719-5725 nfsrv_setattrdsdorpc(fhandle_t fhp, struct ucred cre Link Here
5719	st.other[2] = 0x55555555;	5719	st.other[2] = 0x55555555;
5720	st.seqid = 0xffffffff;	5720	st.seqid = 0xffffffff;
5721	nfscl_reqstart(nd, NFSPROC_SETATTR, nmp, (u_int8_t )fhp, sizeof(fhp),	5721	nfscl_reqstart(nd, NFSPROC_SETATTR, nmp, (u_int8_t )fhp, sizeof(fhp),
5722	NULL, NULL, 0, 0);	5722	NULL, NULL, 0, 0, cred);
5723	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	5723	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5724	nfscl_fillsattr(nd, &nap->na_vattr, vp, NFSSATTR_FULL, 0);	5724	nfscl_fillsattr(nd, &nap->na_vattr, vp, NFSSATTR_FULL, 0);
5725		5725
Lines 5904-5910 nfsrv_setacldsdorpc(fhandle_t fhp, struct ucred cred Link Here
5904	st.other[2] = 0x55555555;	5904	st.other[2] = 0x55555555;
5905	st.seqid = 0xffffffff;	5905	st.seqid = 0xffffffff;
5906	nfscl_reqstart(nd, NFSPROC_SETACL, nmp, (u_int8_t )fhp, sizeof(fhp),	5906	nfscl_reqstart(nd, NFSPROC_SETACL, nmp, (u_int8_t )fhp, sizeof(fhp),
5907	NULL, NULL, 0, 0);	5907	NULL, NULL, 0, 0, cred);
5908	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	5908	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5909	NFSZERO_ATTRBIT(&attrbits);	5909	NFSZERO_ATTRBIT(&attrbits);
5910	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);	5910	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
Lines 6039-6045 nfsrv_getattrdsrpc(fhandle_t fhp, struct ucred cred, Link Here
6039	NFSD_DEBUG(4, "in nfsrv_getattrdsrpc\n");	6039	NFSD_DEBUG(4, "in nfsrv_getattrdsrpc\n");
6040	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	6040	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
6041	nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, (u_int8_t *)fhp,	6041	nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, (u_int8_t *)fhp,
6042	sizeof(fhandle_t), NULL, NULL, 0, 0);	6042	sizeof(fhandle_t), NULL, NULL, 0, 0, cred);
6043	NFSZERO_ATTRBIT(&attrbits);	6043	NFSZERO_ATTRBIT(&attrbits);
6044	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);	6044	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);
6045	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);	6045	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
Lines 6107-6113 nfsrv_seekdsrpc(fhandle_t fhp, off_t offp, int conte Link Here
6107	st.seqid = 0xffffffff;	6107	st.seqid = 0xffffffff;
6108	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	6108	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
6109	nfscl_reqstart(nd, NFSPROC_SEEKDS, nmp, (u_int8_t *)fhp,	6109	nfscl_reqstart(nd, NFSPROC_SEEKDS, nmp, (u_int8_t *)fhp,
6110	sizeof(fhandle_t), NULL, NULL, 0, 0);	6110	sizeof(fhandle_t), NULL, NULL, 0, 0, cred);
6111	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	6111	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
6112	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);	6112	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);
6113	txdr_hyper(*offp, tl); tl += 2;	6113	txdr_hyper(*offp, tl); tl += 2;