Attachment #234241 for bug #260011

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 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. */

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	}





/* nfs_commonsubs.c */
void nfscl_reqstart(struct nfsrv_descript *, int, struct nfsmount *,
    u_int8_t *, int, u_int32_t **, struct nfsclsession *, int, int,
    struct ucred *);
void nfsm_stateidtom(struct nfsrv_descript *, nfsv4stateid_t *, int);
void nfscl_fillsattr(struct nfsrv_descript *, struct vattr *,
      vnode_t, int, u_int32_t);

    struct mbuf **, uint16_t);
void nfsv4_seqsess_cacherep(uint32_t, struct nfsslot *, int, struct mbuf **);
void nfsv4_setsequence(struct nfsmount *, struct nfsrv_descript *,
    struct nfsclsession *, int, struct ucred *);
int nfsv4_sequencelookup(struct nfsmount *, struct nfsclsession *, int *,
    int *, uint32_t *, uint8_t *, bool);
void nfsv4_freeslot(struct nfsclsession *, int, bool);
struct ucred *nfsrv_getgrpscred(struct ucred *);
struct nfsdevice *nfsv4_findmirror(struct nfsmount *);

int nfsrpc_createsession(struct nfsmount *, struct nfsclsession *,
    struct nfssockreq *, struct nfsclds *, uint32_t, int, struct ucred *,
    NFSPROC_T *);
int nfsrpc_destroysession(struct nfsmount *, struct nfsclsession *,
    struct ucred *, NFSPROC_T *);
int nfsrpc_destroyclient(struct nfsmount *, struct nfsclclient *,
    struct ucred *, NFSPROC_T *);

Lines 951-956 tryagain: Link Here

(-)sys/fs/nfs/nfs_commonkrpc.c (-5 / +38 lines)
951	*/	951	*/
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);
Lines 1019-1026 tryagain: Link Here
1019	* If the first op is Sequence, free up the slot.	1020	* If the first op is Sequence, free up the slot.
1020	*/	1021	*/
1021	if ((nmp != NULL && i == NFSV4OP_SEQUENCE && j != 0) \|\|	1022	if ((nmp != NULL && i == NFSV4OP_SEQUENCE && j != 0) \|\|
1022	(clp != NULL && i == NFSV4OP_CBSEQUENCE && j != 0))	1023	(clp != NULL && i == NFSV4OP_CBSEQUENCE && j != 0)) {
1023	NFSCL_DEBUG(1, "failed seq=%d\n", j);	1024	NFSCL_DEBUG(1, "failed seq=%d\n", j);
		1025	if (sep != NULL && i == NFSV4OP_SEQUENCE &&
		1026	j == NFSERR_SEQMISORDERED) {
		1027	mtx_lock(&sep->nfsess_mtx);
		1028	sep->nfsess_badslots \|=
		1029	(0x1ULL << nd->nd_slotid);
		1030	mtx_unlock(&sep->nfsess_mtx);
		1031	}
		1032	}
1024	if (((nmp != NULL && i == NFSV4OP_SEQUENCE && j == 0) \|\|	1033	if (((nmp != NULL && i == NFSV4OP_SEQUENCE && j == 0) \|\|
1025	(clp != NULL && i == NFSV4OP_CBSEQUENCE &&	1034	(clp != NULL && i == NFSV4OP_CBSEQUENCE &&
1026	j == 0)) && sep != NULL) {	1035	j == 0)) && sep != NULL) {
Lines 1039-1049 tryagain: Link Here
1039	retseq = fxdr_unsigned(uint32_t, *tl++);	1048	retseq = fxdr_unsigned(uint32_t, *tl++);
1040	slot = fxdr_unsigned(int, *tl++);	1049	slot = fxdr_unsigned(int, *tl++);
1041	if ((nd->nd_flag & ND_HASSLOTID) != 0) {	1050	if ((nd->nd_flag & ND_HASSLOTID) != 0) {
1042	if (slot != nd->nd_slotid) {	1051	if (slot >= NFSV4_SLOTS \|\|
		1052	(i == NFSV4OP_CBSEQUENCE &&
		1053	slot >= NFSV4_CBSLOTS)) {
1043	printf("newnfs_request:"	1054	printf("newnfs_request:"
1044	" Wrong session "	1055	" Bogus slot\n");
1045	"slot=%d\n", slot);
1046	slot = nd->nd_slotid;	1056	slot = nd->nd_slotid;
		1057	} else if (slot !=
		1058	nd->nd_slotid) {
		1059	printf("newnfs_request:"
		1060	" Wrong session "
		1061	"srvslot=%d "
		1062	"slot=%d\n", slot,
		1063	nd->nd_slotid);
		1064	if (i == NFSV4OP_SEQUENCE) {
		1065	/*
		1066	* Mark both slots as
		1067	* bad, because we do
		1068	* not know if the
		1069	* server has advanced
		1070	* the sequence# for
		1071	* either of them.
		1072	*/
		1073	sep->nfsess_badslots \|=
		1074	(0x1ULL << slot);
		1075	sep->nfsess_badslots \|=
		1076	(0x1ULL <<
		1077	nd->nd_slotid);
		1078	}
		1079	slot = nd->nd_slotid;
1047	}	1080	}
1048	} else if (slot != 0) {	1081	} else if (slot != 0) {
1049	printf("newnfs_request: Bad "	1082	printf("newnfs_request: Bad "
Lines 1122-1128 printf("nfs_commonkrpc: initiate recovery\n"); Link Here
1122	if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {	1155	if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {
1123	reterr = nfsv4_sequencelookup(nmp, sep,	1156	reterr = nfsv4_sequencelookup(nmp, sep,
1124	&slotpos, &maxslot, &slotseq,	1157	&slotpos, &maxslot, &slotseq,
1125	sessionid);	1158	sessionid, true);
1126	if (reterr == 0) {	1159	if (reterr == 0) {
1127	/* Fill in new session info. */	1160	/* Fill in new session info. */
1128	NFSCL_DEBUG(1,	1161	NFSCL_DEBUG(1,




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

	NFSCL_REQSTART(nd, NFSPROC_NULL, vp, NULL);
	error = nfscl_request(nd, vp, p, cred);
	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];

			 * in-progress RPCs.
			 */
			tsep = NULL;
			if (TAILQ_FIRST(&nmp->nm_sess) != NULL) {
				tsep = NFSMNT_MDSSESSION(nmp);
				if (tsep->nfsess_defunct == 0)
					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);

	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);

		name[0] == '.' && name[1] == '.') {
		lookupp = 1;
		openmode = 0;
		NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, dvp, cred);
	} else if (openmode != 0) {
		NFSCL_REQSTART(nd, NFSPROC_LOOKUPOPEN, dvp, cred);
		nfsm_strtom(nd, name, len);
	} 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.

	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);

		*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);

	nfsattrbit_t attrbits;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_DEALLOCATE, vp, cred);
	nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
	NFSM_BUILD(tl, uint32_t *, 2 * NFSX_HYPER);
	txdr_hyper(offs, tl);

	*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);
	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);
	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, cred);
		error = nfscl_request(nd, vp, p, cred);
		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, cred);
		error = nfscl_request(nd, vp, p, cred);
		if (error)
			return (error);

	int error;

	*attrflagp = 0;
	NFSCL_REQSTART(nd, NFSPROC_FSINFO, vp, cred);
	error = nfscl_request(nd, vp, p, cred);
	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);

	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.
	 */

	}
	if (nd->nd_repstat != 0 && error == 0)
		error = nd->nd_repstat;
	if (error == NFSERR_STALECLIENTID)
		nfscl_initiate_recovery(owp->nfsow_clp);
nfsmout:
	NFSCL_DEBUG(4, "eo nfsrpc_createlayout err=%d\n", error);

	*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);

	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 2087-2093 nfscl_umount(struct nfsmount nmp, NFSPROC_T p, struc Link Here

(-)sys/fs/nfsclient/nfs_clstate.c (-3 / +2 lines)
2087	nfscl_delegreturnall(clp, p, dhp);	2087	nfscl_delegreturnall(clp, p, dhp);
2088	cred = newnfs_getcred();	2088	cred = newnfs_getcred();
2089	if (NFSHASNFSV4N(nmp)) {	2089	if (NFSHASNFSV4N(nmp)) {
2090	(void)nfsrpc_destroysession(nmp, clp, cred, p);	2090	(void)nfsrpc_destroysession(nmp, NULL, cred, p);
2091	(void)nfsrpc_destroyclient(nmp, clp, cred, p);	2091	(void)nfsrpc_destroyclient(nmp, clp, cred, p);
2092	} else	2092	} else
2093	(void)nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);	2093	(void)nfsrpc_setclient(nmp, clp, 0, NULL, cred, p);
Lines 2765-2772 nfscl_renewthread(struct nfsclclient clp, NFSPROC_T Link Here
2765	error = nfsrpc_renew(clp, NULL, cred, p);	2765	error = nfsrpc_renew(clp, NULL, cred, p);
2766	if (error == NFSERR_CBPATHDOWN)	2766	if (error == NFSERR_CBPATHDOWN)
2767	cbpathdown = 1;	2767	cbpathdown = 1;
2768	else if (error == NFSERR_STALECLIENTID \|\|	2768	else if (error == NFSERR_STALECLIENTID) {
2769	error == NFSERR_BADSESSION) {
2770	NFSLOCKCLSTATE();	2769	NFSLOCKCLSTATE();
2771	clp->nfsc_flags \|= NFSCLFLAGS_RECOVER;	2770	clp->nfsc_flags \|= NFSCLFLAGS_RECOVER;
2772	NFSUNLOCKCLSTATE();	2771	NFSUNLOCKCLSTATE();

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, NULL);
	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, NULL);

	/*
	 * 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, NULL);

	/*
	 * 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_DEALLOCATE, nmp, (u_int8_t *)fhp,
	    sizeof(fhandle_t), NULL, NULL, 0, 0, NULL);

	/*
	 * 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, NULL);
	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, NULL);
	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, NULL);
	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, NULL);
	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 317-323 void nfsrc_trimcache(uint64_t, uint32_t, int); Link Here

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

Lines 5234-5240 nfsrv_readdsrpc(fhandle_t *fhp, off_t off, int len, st Link Here

(-)sys/fs/nfsserver/nfs_nfsdport.c (-8 / +8 lines)
5234	st.other[2] = 0x55555555;	5234	st.other[2] = 0x55555555;
5235	st.seqid = 0xffffffff;	5235	st.seqid = 0xffffffff;
5236	nfscl_reqstart(nd, NFSPROC_READDS, nmp, (u_int8_t )fhp, sizeof(fhp),	5236	nfscl_reqstart(nd, NFSPROC_READDS, nmp, (u_int8_t )fhp, sizeof(fhp),
5237	NULL, NULL, 0, 0);	5237	NULL, NULL, 0, 0, NULL);
5238	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	5238	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5239	NFSM_BUILD(tl, uint32_t , NFSX_UNSIGNED 3);	5239	NFSM_BUILD(tl, uint32_t , NFSX_UNSIGNED 3);
5240	txdr_hyper(off, tl);	5240	txdr_hyper(off, tl);
Lines 5342-5348 nfsrv_writedsdorpc(struct nfsmount nmp, fhandle_t fh Link Here
5342		5342
5343	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	5343	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
5344	nfscl_reqstart(nd, NFSPROC_WRITE, nmp, (u_int8_t *)fhp,	5344	nfscl_reqstart(nd, NFSPROC_WRITE, nmp, (u_int8_t *)fhp,
5345	sizeof(fhandle_t), NULL, NULL, 0, 0);	5345	sizeof(fhandle_t), NULL, NULL, 0, 0, NULL);
5346		5346
5347	/*	5347	/*
5348	* Use a stateid where other is an alternating 01010 pattern and	5348	* Use a stateid where other is an alternating 01010 pattern and
Lines 5564-5570 nfsrv_allocatedsdorpc(struct nfsmount *nmp, fhandle_t Link Here
5564		5564
5565	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	5565	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
5566	nfscl_reqstart(nd, NFSPROC_ALLOCATE, nmp, (u_int8_t *)fhp,	5566	nfscl_reqstart(nd, NFSPROC_ALLOCATE, nmp, (u_int8_t *)fhp,
5567	sizeof(fhandle_t), NULL, NULL, 0, 0);	5567	sizeof(fhandle_t), NULL, NULL, 0, 0, NULL);
5568		5568
5569	/*	5569	/*
5570	* Use a stateid where other is an alternating 01010 pattern and	5570	* Use a stateid where other is an alternating 01010 pattern and
Lines 5724-5730 nfsrv_deallocatedsdorpc(struct nfsmount *nmp, fhandle_ Link Here
5724		5724
5725	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	5725	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
5726	nfscl_reqstart(nd, NFSPROC_DEALLOCATE, nmp, (u_int8_t *)fhp,	5726	nfscl_reqstart(nd, NFSPROC_DEALLOCATE, nmp, (u_int8_t *)fhp,
5727	sizeof(fhandle_t), NULL, NULL, 0, 0);	5727	sizeof(fhandle_t), NULL, NULL, 0, 0, NULL);
5728		5728
5729	/*	5729	/*
5730	* Use a stateid where other is an alternating 01010 pattern and	5730	* Use a stateid where other is an alternating 01010 pattern and
Lines 5899-5905 nfsrv_setattrdsdorpc(fhandle_t fhp, struct ucred cre Link Here
5899	st.other[2] = 0x55555555;	5899	st.other[2] = 0x55555555;
5900	st.seqid = 0xffffffff;	5900	st.seqid = 0xffffffff;
5901	nfscl_reqstart(nd, NFSPROC_SETATTR, nmp, (u_int8_t )fhp, sizeof(fhp),	5901	nfscl_reqstart(nd, NFSPROC_SETATTR, nmp, (u_int8_t )fhp, sizeof(fhp),
5902	NULL, NULL, 0, 0);	5902	NULL, NULL, 0, 0, NULL);
5903	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	5903	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5904	nfscl_fillsattr(nd, &nap->na_vattr, vp, NFSSATTR_FULL, 0);	5904	nfscl_fillsattr(nd, &nap->na_vattr, vp, NFSSATTR_FULL, 0);
5905		5905
Lines 6084-6090 nfsrv_setacldsdorpc(fhandle_t fhp, struct ucred cred Link Here
6084	st.other[2] = 0x55555555;	6084	st.other[2] = 0x55555555;
6085	st.seqid = 0xffffffff;	6085	st.seqid = 0xffffffff;
6086	nfscl_reqstart(nd, NFSPROC_SETACL, nmp, (u_int8_t )fhp, sizeof(fhp),	6086	nfscl_reqstart(nd, NFSPROC_SETACL, nmp, (u_int8_t )fhp, sizeof(fhp),
6087	NULL, NULL, 0, 0);	6087	NULL, NULL, 0, 0, NULL);
6088	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	6088	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
6089	NFSZERO_ATTRBIT(&attrbits);	6089	NFSZERO_ATTRBIT(&attrbits);
6090	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);	6090	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
Lines 6219-6225 nfsrv_getattrdsrpc(fhandle_t fhp, struct ucred cred, Link Here
6219	NFSD_DEBUG(4, "in nfsrv_getattrdsrpc\n");	6219	NFSD_DEBUG(4, "in nfsrv_getattrdsrpc\n");
6220	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	6220	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
6221	nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, (u_int8_t *)fhp,	6221	nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, (u_int8_t *)fhp,
6222	sizeof(fhandle_t), NULL, NULL, 0, 0);	6222	sizeof(fhandle_t), NULL, NULL, 0, 0, NULL);
6223	NFSZERO_ATTRBIT(&attrbits);	6223	NFSZERO_ATTRBIT(&attrbits);
6224	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);	6224	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);
6225	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);	6225	NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
Lines 6287-6293 nfsrv_seekdsrpc(fhandle_t fhp, off_t offp, int conte Link Here
6287	st.seqid = 0xffffffff;	6287	st.seqid = 0xffffffff;
6288	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);	6288	nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK \| M_ZERO);
6289	nfscl_reqstart(nd, NFSPROC_SEEKDS, nmp, (u_int8_t *)fhp,	6289	nfscl_reqstart(nd, NFSPROC_SEEKDS, nmp, (u_int8_t *)fhp,
6290	sizeof(fhandle_t), NULL, NULL, 0, 0);	6290	sizeof(fhandle_t), NULL, NULL, 0, 0, NULL);
6291	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);	6291	nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
6292	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);	6292	NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);
6293	txdr_hyper(*offp, tl); tl += 2;	6293	txdr_hyper(*offp, tl); tl += 2;