Attachment #234243 for bug #260011




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

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

	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.

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

	while (tsiz > 0) {
		*attrflagp = 0;
		len = (tsiz > wsize) ? wsize : tsiz;
		NFSCL_REQSTART(nd, NFSPROC_WRITE, vp, cred);
		if (nd->nd_flag & ND_NFSV4) {
			nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
			NFSM_BUILD(tl, u_int32_t *, NFSX_HYPER+2*NFSX_UNSIGNED);

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

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

(-)sys/fs/nfsclient/nfs_clstate.c (-3 / +2 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 2767-2774 nfscl_renewthread(struct nfsclclient clp, NFSPROC_T Link Here
2767	error = nfsrpc_renew(clp, NULL, cred, p);	2767	error = nfsrpc_renew(clp, NULL, cred, p);
2768	if (error == NFSERR_CBPATHDOWN)	2768	if (error == NFSERR_CBPATHDOWN)
2769	cbpathdown = 1;	2769	cbpathdown = 1;
2770	else if (error == NFSERR_STALECLIENTID \|\|	2770	else if (error == NFSERR_STALECLIENTID) {
2771	error == NFSERR_BADSESSION) {
2772	NFSLOCKCLSTATE();	2771	NFSLOCKCLSTATE();
2773	clp->nfsc_flags \|= NFSCLFLAGS_RECOVER;	2772	clp->nfsc_flags \|= NFSCLFLAGS_RECOVER;
2774	NFSUNLOCKCLSTATE();	2773	NFSUNLOCKCLSTATE();

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 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 1121-1127 tryagain: Link Here
1121	if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {	1154	if ((nd->nd_flag & ND_LOOPBADSESS) != 0) {
1122	reterr = nfsv4_sequencelookup(nmp, sep,	1155	reterr = nfsv4_sequencelookup(nmp, sep,
1123	&slotpos, &maxslot, &slotseq,	1156	&slotpos, &maxslot, &slotseq,
1124	sessionid);	1157	sessionid, true);
1125	if (reterr == 0) {	1158	if (reterr == 0) {
1126	/* Fill in new session info. */	1159	/* Fill in new session info. */
1127	NFSCL_DEBUG(1,	1160	NFSCL_DEBUG(1,

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 322-328 static int nfs_bigrequest[NFSV42_NPROCS] = { Link Here

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





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

	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 315-321 void nfsrc_trimcache(uint64_t, uint32_t, int); Link Here

(-)sys/fs/nfs/nfs_var.h (-4 / +5 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-363 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 );
Lines 529-535 int nfsrpc_exchangeid(struct nfsmount *, struct nfsclc Link Here
529	int nfsrpc_createsession(struct nfsmount , struct nfsclsession ,	530	int nfsrpc_createsession(struct nfsmount , struct nfsclsession ,
530	struct nfssockreq , struct nfsclds , uint32_t, int, struct ucred *,	531	struct nfssockreq , struct nfsclds , uint32_t, int, struct ucred *,
531	NFSPROC_T *);	532	NFSPROC_T *);
532	int nfsrpc_destroysession(struct nfsmount , struct nfsclclient ,	533	int nfsrpc_destroysession(struct nfsmount , struct nfsclsession ,
533	struct ucred , NFSPROC_T );	534	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 );

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