sys/fs/nfsclient/nfs_clrpcops.c

   1 /*-
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Rick Macklem at The University of Guelph.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 4. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 /*
  38  * Rpc op calls, generally called from the vnode op calls or through the
  39  * buffer cache, for NFS v2, 3 and 4.
  40  * These do not normally make any changes to vnode arguments or use
  41  * structures that might change between the VFS variants. The returned
  42  * arguments are all at the end, after the NFSPROC_T *p one.
  43  */
  44
  45 #ifndef APPLEKEXT
  46 #include "opt_inet6.h"
  47
  48 #include <fs/nfs/nfsport.h>
  49
  50 /*
  51  * Global variables
  52  */
  53 extern int nfs_numnfscbd;
  54 extern struct timeval nfsboottime;
  55 extern u_int32_t newnfs_false, newnfs_true;
  56 extern nfstype nfsv34_type[9];
  57 extern int nfsrv_useacl;
  58 extern char nfsv4_callbackaddr[INET6_ADDRSTRLEN];
  59 extern int nfscl_debuglevel;
  60 NFSCLSTATEMUTEX;
  61 int nfstest_outofseq = 0;
  62 int nfscl_assumeposixlocks = 1;
  63 int nfscl_enablecallb = 0;
  64 short nfsv4_cbport = NFSV4_CBPORT;
  65 int nfstest_openallsetattr = 0;
  66 #endif  /* !APPLEKEXT */
  67
  68 #define DIRHDSIZ        (sizeof (struct dirent) - (MAXNAMLEN + 1))
  69
  70 /*
  71  * nfscl_getsameserver() can return one of three values:
  72  * NFSDSP_USETHISSESSION - Use this session for the DS.
  73  * NFSDSP_SEQTHISSESSION - Use the nfsclds_sequence field of this dsp for new
  74  *     session.
  75  * NFSDSP_NOTFOUND - No matching server was found.
  76  */
  77 enum nfsclds_state {
  78         NFSDSP_USETHISSESSION = 0,
  79         NFSDSP_SEQTHISSESSION = 1,
  80         NFSDSP_NOTFOUND = 2,
  81 };
  82
  83 static int nfsrpc_setattrrpc(vnode_t , struct vattr *, nfsv4stateid_t *,
  84     struct ucred *, NFSPROC_T *, struct nfsvattr *, int *, void *);
  85 static int nfsrpc_readrpc(vnode_t , struct uio *, struct ucred *,
  86     nfsv4stateid_t *, NFSPROC_T *, struct nfsvattr *, int *, void *);
  87 static int nfsrpc_writerpc(vnode_t , struct uio *, int *, int *,
  88     struct ucred *, nfsv4stateid_t *, NFSPROC_T *, struct nfsvattr *, int *,
  89     void *);
  90 static int nfsrpc_createv23(vnode_t , char *, int, struct vattr *,
  91     nfsquad_t, int, struct ucred *, NFSPROC_T *, struct nfsvattr *,
  92     struct nfsvattr *, struct nfsfh **, int *, int *, void *);
  93 static int nfsrpc_createv4(vnode_t , char *, int, struct vattr *,
  94     nfsquad_t, int, struct nfsclowner *, struct nfscldeleg **, struct ucred *,
  95     NFSPROC_T *, struct nfsvattr *, struct nfsvattr *, struct nfsfh **, int *,
  96     int *, void *, int *);
  97 static int nfsrpc_locku(struct nfsrv_descript *, struct nfsmount *,
  98     struct nfscllockowner *, u_int64_t, u_int64_t,
  99     u_int32_t, struct ucred *, NFSPROC_T *, int);
 100 static int nfsrpc_setaclrpc(vnode_t, struct ucred *, NFSPROC_T *,
 101     struct acl *, nfsv4stateid_t *, void *);
 102 static int nfsrpc_getlayout(struct nfsmount *, vnode_t, struct nfsfh *, int,
 103     uint32_t *, nfsv4stateid_t *, uint64_t, struct nfscllayout **,
 104     struct ucred *, NFSPROC_T *);
 105 static int nfsrpc_fillsa(struct nfsmount *, struct sockaddr_storage *,
 106     struct nfsclds **, NFSPROC_T *);
 107 static void nfscl_initsessionslots(struct nfsclsession *);
 108 static int nfscl_doflayoutio(vnode_t, struct uio *, int *, int *, int *,
 109     nfsv4stateid_t *, int, struct nfscldevinfo *, struct nfscllayout *,
 110     struct nfsclflayout *, uint64_t, uint64_t, struct ucred *, NFSPROC_T *);
 111 static int nfsrpc_readds(vnode_t, struct uio *, nfsv4stateid_t *, int *,
 112     struct nfsclds *, uint64_t, int, struct nfsfh *, struct ucred *,
 113     NFSPROC_T *);
 114 static int nfsrpc_writeds(vnode_t, struct uio *, int *, int *,
 115     nfsv4stateid_t *, struct nfsclds *, uint64_t, int,
 116     struct nfsfh *, int, struct ucred *, NFSPROC_T *);
 117 static enum nfsclds_state nfscl_getsameserver(struct nfsmount *,
 118     struct nfsclds *, struct nfsclds **);
 119 #ifdef notyet
 120 static int nfsrpc_commitds(vnode_t, uint64_t, int, struct nfsclds *,
 121     struct nfsfh *, struct ucred *, NFSPROC_T *, void *);
 122 #endif
 123
 124 /*
 125  * nfs null call from vfs.
 126  */
 127 APPLESTATIC int
 128 nfsrpc_null(vnode_t vp, struct ucred *cred, NFSPROC_T *p)
 129 {
 130         int error;
 131         struct nfsrv_descript nfsd, *nd = &nfsd;
 132
 133         NFSCL_REQSTART(nd, NFSPROC_NULL, vp);
 134         error = nfscl_request(nd, vp, p, cred, NULL);
 135         if (nd->nd_repstat && !error)
 136                 error = nd->nd_repstat;
 137         mbuf_freem(nd->nd_mrep);
 138         return (error);
 139 }
 140
 141 /*
 142  * nfs access rpc op.
 143  * For nfs version 3 and 4, use the access rpc to check accessibility. If file
 144  * modes are changed on the server, accesses might still fail later.
 145  */
 146 APPLESTATIC int
 147 nfsrpc_access(vnode_t vp, int acmode, struct ucred *cred,
 148     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp)
 149 {
 150         int error;
 151         u_int32_t mode, rmode;
 152
 153         if (acmode & VREAD)
 154                 mode = NFSACCESS_READ;
 155         else
 156                 mode = 0;
 157         if (vnode_vtype(vp) == VDIR) {
 158                 if (acmode & VWRITE)
 159                         mode |= (NFSACCESS_MODIFY | NFSACCESS_EXTEND |
 160                                  NFSACCESS_DELETE);
 161                 if (acmode & VEXEC)
 162                         mode |= NFSACCESS_LOOKUP;
 163         } else {
 164                 if (acmode & VWRITE)
 165                         mode |= (NFSACCESS_MODIFY | NFSACCESS_EXTEND);
 166                 if (acmode & VEXEC)
 167                         mode |= NFSACCESS_EXECUTE;
 168         }
 169
 170         /*
 171          * Now, just call nfsrpc_accessrpc() to do the actual RPC.
 172          */
 173         error = nfsrpc_accessrpc(vp, mode, cred, p, nap, attrflagp, &rmode,
 174             NULL);
 175
 176         /*
 177          * The NFS V3 spec does not clarify whether or not
 178          * the returned access bits can be a superset of
 179          * the ones requested, so...
 180          */
 181         if (!error && (rmode & mode) != mode)
 182                 error = EACCES;
 183         return (error);
 184 }
 185
 186 /*
 187  * The actual rpc, separated out for Darwin.
 188  */
 189 APPLESTATIC int
 190 nfsrpc_accessrpc(vnode_t vp, u_int32_t mode, struct ucred *cred,
 191     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, u_int32_t *rmodep,
 192     void *stuff)
 193 {
 194         u_int32_t *tl;
 195         u_int32_t supported, rmode;
 196         int error;
 197         struct nfsrv_descript nfsd, *nd = &nfsd;
 198         nfsattrbit_t attrbits;
 199
 200         *attrflagp = 0;
 201         supported = mode;
 202         NFSCL_REQSTART(nd, NFSPROC_ACCESS, vp);
 203         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
 204         *tl = txdr_unsigned(mode);
 205         if (nd->nd_flag & ND_NFSV4) {
 206                 /*
 207                  * And do a Getattr op.
 208                  */
 209                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
 210                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
 211                 NFSGETATTR_ATTRBIT(&attrbits);
 212                 (void) nfsrv_putattrbit(nd, &attrbits);
 213         }
 214         error = nfscl_request(nd, vp, p, cred, stuff);
 215         if (error)
 216                 return (error);
 217         if (nd->nd_flag & ND_NFSV3) {
 218                 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
 219                 if (error)
 220                         goto nfsmout;
 221         }
 222         if (!nd->nd_repstat) {
 223                 if (nd->nd_flag & ND_NFSV4) {
 224                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 225                         supported = fxdr_unsigned(u_int32_t, *tl++);
 226                 } else {
 227                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
 228                 }
 229                 rmode = fxdr_unsigned(u_int32_t, *tl);
 230                 if (nd->nd_flag & ND_NFSV4)
 231                         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
 232
 233                 /*
 234                  * It's not obvious what should be done about
 235                  * unsupported access modes. For now, be paranoid
 236                  * and clear the unsupported ones.
 237                  */
 238                 rmode &= supported;
 239                 *rmodep = rmode;
 240         } else
 241                 error = nd->nd_repstat;
 242 nfsmout:
 243         mbuf_freem(nd->nd_mrep);
 244         return (error);
 245 }
 246
 247 /*
 248  * nfs open rpc
 249  */
 250 APPLESTATIC int
 251 nfsrpc_open(vnode_t vp, int amode, struct ucred *cred, NFSPROC_T *p)
 252 {
 253         struct nfsclopen *op;
 254         struct nfscldeleg *dp;
 255         struct nfsfh *nfhp;
 256         struct nfsnode *np = VTONFS(vp);
 257         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
 258         u_int32_t mode, clidrev;
 259         int ret, newone, error, expireret = 0, retrycnt;
 260
 261         /*
 262          * For NFSv4, Open Ops are only done on Regular Files.
 263          */
 264         if (vnode_vtype(vp) != VREG)
 265                 return (0);
 266         mode = 0;
 267         if (amode & FREAD)
 268                 mode |= NFSV4OPEN_ACCESSREAD;
 269         if (amode & FWRITE)
 270                 mode |= NFSV4OPEN_ACCESSWRITE;
 271         nfhp = np->n_fhp;
 272
 273         retrycnt = 0;
 274 #ifdef notdef
 275 { char name[100]; int namel;
 276 namel = (np->n_v4->n4_namelen < 100) ? np->n_v4->n4_namelen : 99;
 277 bcopy(NFS4NODENAME(np->n_v4), name, namel);
 278 name[namel] = '\0';
 279 printf("rpcopen p=0x%x name=%s",p->p_pid,name);
 280 if (nfhp->nfh_len > 0) printf(" fh=0x%x\n",nfhp->nfh_fh[12]);
 281 else printf(" fhl=0\n");
 282 }
 283 #endif
 284         do {
 285             dp = NULL;
 286             error = nfscl_open(vp, nfhp->nfh_fh, nfhp->nfh_len, mode, 1,
 287                 cred, p, NULL, &op, &newone, &ret, 1);
 288             if (error) {
 289                 return (error);
 290             }
 291             if (nmp->nm_clp != NULL)
 292                 clidrev = nmp->nm_clp->nfsc_clientidrev;
 293             else
 294                 clidrev = 0;
 295             if (ret == NFSCLOPEN_DOOPEN) {
 296                 if (np->n_v4 != NULL) {
 297                         error = nfsrpc_openrpc(nmp, vp, np->n_v4->n4_data,
 298                            np->n_v4->n4_fhlen, np->n_fhp->nfh_fh,
 299                            np->n_fhp->nfh_len, mode, op,
 300                            NFS4NODENAME(np->n_v4), np->n_v4->n4_namelen, &dp,
 301                            0, 0x0, cred, p, 0, 0);
 302                         if (dp != NULL) {
 303 #ifdef APPLE
 304                                 OSBitAndAtomic((int32_t)~NDELEGMOD, (UInt32 *)&np->n_flag);
 305 #else
 306                                 NFSLOCKNODE(np);
 307                                 np->n_flag &= ~NDELEGMOD;
 308                                 /*
 309                                  * Invalidate the attribute cache, so that
 310                                  * attributes that pre-date the issue of a
 311                                  * delegation are not cached, since the
 312                                  * cached attributes will remain valid while
 313                                  * the delegation is held.
 314                                  */
 315                                 NFSINVALATTRCACHE(np);
 316                                 NFSUNLOCKNODE(np);
 317 #endif
 318                                 (void) nfscl_deleg(nmp->nm_mountp,
 319                                     op->nfso_own->nfsow_clp,
 320                                     nfhp->nfh_fh, nfhp->nfh_len, cred, p, &dp);
 321                         }
 322                 } else {
 323                         error = EIO;
 324                 }
 325                 newnfs_copyincred(cred, &op->nfso_cred);
 326             } else if (ret == NFSCLOPEN_SETCRED)
 327                 /*
 328                  * This is a new local open on a delegation. It needs
 329                  * to have credentials so that an open can be done
 330                  * against the server during recovery.
 331                  */
 332                 newnfs_copyincred(cred, &op->nfso_cred);
 333
 334             /*
 335              * nfso_opencnt is the count of how many VOP_OPEN()s have
 336              * been done on this Open successfully and a VOP_CLOSE()
 337              * is expected for each of these.
 338              * If error is non-zero, don't increment it, since the Open
 339              * hasn't succeeded yet.
 340              */
 341             if (!error)
 342                 op->nfso_opencnt++;
 343             nfscl_openrelease(op, error, newone);
 344             if (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
 345                 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
 346                 error == NFSERR_BADSESSION) {
 347                 (void) nfs_catnap(PZERO, error, "nfs_open");
 348             } else if ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID)
 349                 && clidrev != 0) {
 350                 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
 351                 retrycnt++;
 352             }
 353         } while (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
 354             error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
 355             error == NFSERR_BADSESSION ||
 356             ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
 357              expireret == 0 && clidrev != 0 && retrycnt < 4));
 358         if (error && retrycnt >= 4)
 359                 error = EIO;
 360         return (error);
 361 }
 362
 363 /*
 364  * the actual open rpc
 365  */
 366 APPLESTATIC int
 367 nfsrpc_openrpc(struct nfsmount *nmp, vnode_t vp, u_int8_t *nfhp, int fhlen,
 368     u_int8_t *newfhp, int newfhlen, u_int32_t mode, struct nfsclopen *op,
 369     u_int8_t *name, int namelen, struct nfscldeleg **dpp,
 370     int reclaim, u_int32_t delegtype, struct ucred *cred, NFSPROC_T *p,
 371     int syscred, int recursed)
 372 {
 373         u_int32_t *tl;
 374         struct nfsrv_descript nfsd, *nd = &nfsd;
 375         struct nfscldeleg *dp, *ndp = NULL;
 376         struct nfsvattr nfsva;
 377         u_int32_t rflags, deleg;
 378         nfsattrbit_t attrbits;
 379         int error, ret, acesize, limitby;
 380
 381         dp = *dpp;
 382         *dpp = NULL;
 383         nfscl_reqstart(nd, NFSPROC_OPEN, nmp, nfhp, fhlen, NULL, NULL);
 384         NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
 385         *tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
 386         *tl++ = txdr_unsigned(mode & NFSV4OPEN_ACCESSBOTH);
 387         *tl++ = txdr_unsigned((mode >> NFSLCK_SHIFT) & NFSV4OPEN_DENYBOTH);
 388         *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
 389         *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
 390         (void) nfsm_strtom(nd, op->nfso_own->nfsow_owner, NFSV4CL_LOCKNAMELEN);
 391         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 392         *tl++ = txdr_unsigned(NFSV4OPEN_NOCREATE);
 393         if (reclaim) {
 394                 *tl = txdr_unsigned(NFSV4OPEN_CLAIMPREVIOUS);
 395                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
 396                 *tl = txdr_unsigned(delegtype);
 397         } else {
 398                 if (dp != NULL) {
 399                         *tl = txdr_unsigned(NFSV4OPEN_CLAIMDELEGATECUR);
 400                         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
 401                         if (NFSHASNFSV4N(nmp))
 402                                 *tl++ = 0;
 403                         else
 404                                 *tl++ = dp->nfsdl_stateid.seqid;
 405                         *tl++ = dp->nfsdl_stateid.other[0];
 406                         *tl++ = dp->nfsdl_stateid.other[1];
 407                         *tl = dp->nfsdl_stateid.other[2];
 408                 } else {
 409                         *tl = txdr_unsigned(NFSV4OPEN_CLAIMNULL);
 410                 }
 411                 (void) nfsm_strtom(nd, name, namelen);
 412         }
 413         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
 414         *tl = txdr_unsigned(NFSV4OP_GETATTR);
 415         NFSZERO_ATTRBIT(&attrbits);
 416         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
 417         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFY);
 418         (void) nfsrv_putattrbit(nd, &attrbits);
 419         if (syscred)
 420                 nd->nd_flag |= ND_USEGSSNAME;
 421         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, vp, p, cred,
 422             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
 423         if (error)
 424                 return (error);
 425         NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
 426         if (!nd->nd_repstat) {
 427                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
 428                     6 * NFSX_UNSIGNED);
 429                 op->nfso_stateid.seqid = *tl++;
 430                 op->nfso_stateid.other[0] = *tl++;
 431                 op->nfso_stateid.other[1] = *tl++;
 432                 op->nfso_stateid.other[2] = *tl;
 433                 rflags = fxdr_unsigned(u_int32_t, *(tl + 6));
 434                 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
 435                 if (error)
 436                         goto nfsmout;
 437                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
 438                 deleg = fxdr_unsigned(u_int32_t, *tl);
 439                 if (deleg == NFSV4OPEN_DELEGATEREAD ||
 440                     deleg == NFSV4OPEN_DELEGATEWRITE) {
 441                         if (!(op->nfso_own->nfsow_clp->nfsc_flags &
 442                               NFSCLFLAGS_FIRSTDELEG))
 443                                 op->nfso_own->nfsow_clp->nfsc_flags |=
 444                                   (NFSCLFLAGS_FIRSTDELEG | NFSCLFLAGS_GOTDELEG);
 445                         MALLOC(ndp, struct nfscldeleg *,
 446                             sizeof (struct nfscldeleg) + newfhlen,
 447                             M_NFSCLDELEG, M_WAITOK);
 448                         LIST_INIT(&ndp->nfsdl_owner);
 449                         LIST_INIT(&ndp->nfsdl_lock);
 450                         ndp->nfsdl_clp = op->nfso_own->nfsow_clp;
 451                         ndp->nfsdl_fhlen = newfhlen;
 452                         NFSBCOPY(newfhp, ndp->nfsdl_fh, newfhlen);
 453                         newnfs_copyincred(cred, &ndp->nfsdl_cred);
 454                         nfscl_lockinit(&ndp->nfsdl_rwlock);
 455                         NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
 456                             NFSX_UNSIGNED);
 457                         ndp->nfsdl_stateid.seqid = *tl++;
 458                         ndp->nfsdl_stateid.other[0] = *tl++;
 459                         ndp->nfsdl_stateid.other[1] = *tl++;
 460                         ndp->nfsdl_stateid.other[2] = *tl++;
 461                         ret = fxdr_unsigned(int, *tl);
 462                         if (deleg == NFSV4OPEN_DELEGATEWRITE) {
 463                                 ndp->nfsdl_flags = NFSCLDL_WRITE;
 464                                 /*
 465                                  * Indicates how much the file can grow.
 466                                  */
 467                                 NFSM_DISSECT(tl, u_int32_t *,
 468                                     3 * NFSX_UNSIGNED);
 469                                 limitby = fxdr_unsigned(int, *tl++);
 470                                 switch (limitby) {
 471                                 case NFSV4OPEN_LIMITSIZE:
 472                                         ndp->nfsdl_sizelimit = fxdr_hyper(tl);
 473                                         break;
 474                                 case NFSV4OPEN_LIMITBLOCKS:
 475                                         ndp->nfsdl_sizelimit =
 476                                             fxdr_unsigned(u_int64_t, *tl++);
 477                                         ndp->nfsdl_sizelimit *=
 478                                             fxdr_unsigned(u_int64_t, *tl);
 479                                         break;
 480                                 default:
 481                                         error = NFSERR_BADXDR;
 482                                         goto nfsmout;
 483                                 };
 484                         } else {
 485                                 ndp->nfsdl_flags = NFSCLDL_READ;
 486                         }
 487                         if (ret)
 488                                 ndp->nfsdl_flags |= NFSCLDL_RECALL;
 489                         error = nfsrv_dissectace(nd, &ndp->nfsdl_ace, &ret,
 490                             &acesize, p);
 491                         if (error)
 492                                 goto nfsmout;
 493                 } else if (deleg != NFSV4OPEN_DELEGATENONE) {
 494                         error = NFSERR_BADXDR;
 495                         goto nfsmout;
 496                 }
 497                 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 498                 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
 499                     NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
 500                     NULL, NULL, NULL, p, cred);
 501                 if (error)
 502                         goto nfsmout;
 503                 if (ndp != NULL) {
 504                         ndp->nfsdl_change = nfsva.na_filerev;
 505                         ndp->nfsdl_modtime = nfsva.na_mtime;
 506                         ndp->nfsdl_flags |= NFSCLDL_MODTIMESET;
 507                 }
 508                 if (!reclaim && (rflags & NFSV4OPEN_RESULTCONFIRM)) {
 509                     do {
 510                         ret = nfsrpc_openconfirm(vp, newfhp, newfhlen, op,
 511                             cred, p);
 512                         if (ret == NFSERR_DELAY)
 513                             (void) nfs_catnap(PZERO, ret, "nfs_open");
 514                     } while (ret == NFSERR_DELAY);
 515                     error = ret;
 516                 }
 517                 if ((rflags & NFSV4OPEN_LOCKTYPEPOSIX) ||
 518                     nfscl_assumeposixlocks)
 519                     op->nfso_posixlock = 1;
 520                 else
 521                     op->nfso_posixlock = 0;
 522
 523                 /*
 524                  * If the server is handing out delegations, but we didn't
 525                  * get one because an OpenConfirm was required, try the
 526                  * Open again, to get a delegation. This is a harmless no-op,
 527                  * from a server's point of view.
 528                  */
 529                 if (!reclaim && (rflags & NFSV4OPEN_RESULTCONFIRM) &&
 530                     (op->nfso_own->nfsow_clp->nfsc_flags & NFSCLFLAGS_GOTDELEG)
 531                     && !error && dp == NULL && ndp == NULL && !recursed) {
 532                     do {
 533                         ret = nfsrpc_openrpc(nmp, vp, nfhp, fhlen, newfhp,
 534                             newfhlen, mode, op, name, namelen, &ndp, 0, 0x0,
 535                             cred, p, syscred, 1);
 536                         if (ret == NFSERR_DELAY)
 537                             (void) nfs_catnap(PZERO, ret, "nfs_open2");
 538                     } while (ret == NFSERR_DELAY);
 539                     if (ret) {
 540                         if (ndp != NULL)
 541                                 FREE((caddr_t)ndp, M_NFSCLDELEG);
 542                         if (ret == NFSERR_STALECLIENTID ||
 543                             ret == NFSERR_STALEDONTRECOVER ||
 544                             ret == NFSERR_BADSESSION)
 545                                 error = ret;
 546                     }
 547                 }
 548         }
 549         if (nd->nd_repstat != 0 && error == 0)
 550                 error = nd->nd_repstat;
 551         if (error == NFSERR_STALECLIENTID || error == NFSERR_BADSESSION)
 552                 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
 553 nfsmout:
 554         if (!error)
 555                 *dpp = ndp;
 556         else if (ndp != NULL)
 557                 FREE((caddr_t)ndp, M_NFSCLDELEG);
 558         mbuf_freem(nd->nd_mrep);
 559         return (error);
 560 }
 561
 562 /*
 563  * open downgrade rpc
 564  */
 565 APPLESTATIC int
 566 nfsrpc_opendowngrade(vnode_t vp, u_int32_t mode, struct nfsclopen *op,
 567     struct ucred *cred, NFSPROC_T *p)
 568 {
 569         u_int32_t *tl;
 570         struct nfsrv_descript nfsd, *nd = &nfsd;
 571         int error;
 572
 573         NFSCL_REQSTART(nd, NFSPROC_OPENDOWNGRADE, vp);
 574         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 3 * NFSX_UNSIGNED);
 575         if (NFSHASNFSV4N(VFSTONFS(vnode_mount(vp))))
 576                 *tl++ = 0;
 577         else
 578                 *tl++ = op->nfso_stateid.seqid;
 579         *tl++ = op->nfso_stateid.other[0];
 580         *tl++ = op->nfso_stateid.other[1];
 581         *tl++ = op->nfso_stateid.other[2];
 582         *tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
 583         *tl++ = txdr_unsigned(mode & NFSV4OPEN_ACCESSBOTH);
 584         *tl = txdr_unsigned((mode >> NFSLCK_SHIFT) & NFSV4OPEN_DENYBOTH);
 585         error = nfscl_request(nd, vp, p, cred, NULL);
 586         if (error)
 587                 return (error);
 588         NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
 589         if (!nd->nd_repstat) {
 590                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
 591                 op->nfso_stateid.seqid = *tl++;
 592                 op->nfso_stateid.other[0] = *tl++;
 593                 op->nfso_stateid.other[1] = *tl++;
 594                 op->nfso_stateid.other[2] = *tl;
 595         }
 596         if (nd->nd_repstat && error == 0)
 597                 error = nd->nd_repstat;
 598         if (error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION)
 599                 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
 600 nfsmout:
 601         mbuf_freem(nd->nd_mrep);
 602         return (error);
 603 }
 604
 605 /*
 606  * V4 Close operation.
 607  */
 608 APPLESTATIC int
 609 nfsrpc_close(vnode_t vp, int doclose, NFSPROC_T *p)
 610 {
 611         struct nfsclclient *clp;
 612         int error;
 613
 614         if (vnode_vtype(vp) != VREG)
 615                 return (0);
 616         if (doclose)
 617                 error = nfscl_doclose(vp, &clp, p);
 618         else
 619                 error = nfscl_getclose(vp, &clp);
 620         if (error)
 621                 return (error);
 622
 623         nfscl_clientrelease(clp);
 624         return (0);
 625 }
 626
 627 /*
 628  * Close the open.
 629  */
 630 APPLESTATIC void
 631 nfsrpc_doclose(struct nfsmount *nmp, struct nfsclopen *op, NFSPROC_T *p)
 632 {
 633         struct nfsrv_descript nfsd, *nd = &nfsd;
 634         struct nfscllockowner *lp, *nlp;
 635         struct nfscllock *lop, *nlop;
 636         struct ucred *tcred;
 637         u_int64_t off = 0, len = 0;
 638         u_int32_t type = NFSV4LOCKT_READ;
 639         int error, do_unlock, trycnt;
 640
 641         tcred = newnfs_getcred();
 642         newnfs_copycred(&op->nfso_cred, tcred);
 643         /*
 644          * (Theoretically this could be done in the same
 645          *  compound as the close, but having multiple
 646          *  sequenced Ops in the same compound might be
 647          *  too scary for some servers.)
 648          */
 649         if (op->nfso_posixlock) {
 650                 off = 0;
 651                 len = NFS64BITSSET;
 652                 type = NFSV4LOCKT_READ;
 653         }
 654
 655         /*
 656          * Since this function is only called from VOP_INACTIVE(), no
 657          * other thread will be manipulating this Open. As such, the
 658          * lock lists are not being changed by other threads, so it should
 659          * be safe to do this without locking.
 660          */
 661         LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
 662                 do_unlock = 1;
 663                 LIST_FOREACH_SAFE(lop, &lp->nfsl_lock, nfslo_list, nlop) {
 664                         if (op->nfso_posixlock == 0) {
 665                                 off = lop->nfslo_first;
 666                                 len = lop->nfslo_end - lop->nfslo_first;
 667                                 if (lop->nfslo_type == F_WRLCK)
 668                                         type = NFSV4LOCKT_WRITE;
 669                                 else
 670                                         type = NFSV4LOCKT_READ;
 671                         }
 672                         if (do_unlock) {
 673                                 trycnt = 0;
 674                                 do {
 675                                         error = nfsrpc_locku(nd, nmp, lp, off,
 676                                             len, type, tcred, p, 0);
 677                                         if ((nd->nd_repstat == NFSERR_GRACE ||
 678                                             nd->nd_repstat == NFSERR_DELAY) &&
 679                                             error == 0)
 680                                                 (void) nfs_catnap(PZERO,
 681                                                     (int)nd->nd_repstat,
 682                                                     "nfs_close");
 683                                 } while ((nd->nd_repstat == NFSERR_GRACE ||
 684                                     nd->nd_repstat == NFSERR_DELAY) &&
 685                                     error == 0 && trycnt++ < 5);
 686                                 if (op->nfso_posixlock)
 687                                         do_unlock = 0;
 688                         }
 689                         nfscl_freelock(lop, 0);
 690                 }
 691                 /*
 692                  * Do a ReleaseLockOwner.
 693                  * The lock owner name nfsl_owner may be used by other opens for
 694                  * other files but the lock_owner4 name that nfsrpc_rellockown()
 695                  * puts on the wire has the file handle for this file appended
 696                  * to it, so it can be done now.
 697                  */
 698                 (void)nfsrpc_rellockown(nmp, lp, lp->nfsl_open->nfso_fh,
 699                     lp->nfsl_open->nfso_fhlen, tcred, p);
 700         }
 701
 702         /*
 703          * There could be other Opens for different files on the same
 704          * OpenOwner, so locking is required.
 705          */
 706         NFSLOCKCLSTATE();
 707         nfscl_lockexcl(&op->nfso_own->nfsow_rwlock, NFSCLSTATEMUTEXPTR);
 708         NFSUNLOCKCLSTATE();
 709         do {
 710                 error = nfscl_tryclose(op, tcred, nmp, p);
 711                 if (error == NFSERR_GRACE)
 712                         (void) nfs_catnap(PZERO, error, "nfs_close");
 713         } while (error == NFSERR_GRACE);
 714         NFSLOCKCLSTATE();
 715         nfscl_lockunlock(&op->nfso_own->nfsow_rwlock);
 716
 717         LIST_FOREACH_SAFE(lp, &op->nfso_lock, nfsl_list, nlp)
 718                 nfscl_freelockowner(lp, 0);
 719         nfscl_freeopen(op, 0);
 720         NFSUNLOCKCLSTATE();
 721         NFSFREECRED(tcred);
 722 }
 723
 724 /*
 725  * The actual Close RPC.
 726  */
 727 APPLESTATIC int
 728 nfsrpc_closerpc(struct nfsrv_descript *nd, struct nfsmount *nmp,
 729     struct nfsclopen *op, struct ucred *cred, NFSPROC_T *p,
 730     int syscred)
 731 {
 732         u_int32_t *tl;
 733         int error;
 734
 735         nfscl_reqstart(nd, NFSPROC_CLOSE, nmp, op->nfso_fh,
 736             op->nfso_fhlen, NULL, NULL);
 737         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
 738         *tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
 739         if (NFSHASNFSV4N(nmp))
 740                 *tl++ = 0;
 741         else
 742                 *tl++ = op->nfso_stateid.seqid;
 743         *tl++ = op->nfso_stateid.other[0];
 744         *tl++ = op->nfso_stateid.other[1];
 745         *tl = op->nfso_stateid.other[2];
 746         if (syscred)
 747                 nd->nd_flag |= ND_USEGSSNAME;
 748         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
 749             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
 750         if (error)
 751                 return (error);
 752         NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
 753         if (nd->nd_repstat == 0)
 754                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
 755         error = nd->nd_repstat;
 756         if (error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION)
 757                 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
 758 nfsmout:
 759         mbuf_freem(nd->nd_mrep);
 760         return (error);
 761 }
 762
 763 /*
 764  * V4 Open Confirm RPC.
 765  */
 766 APPLESTATIC int
 767 nfsrpc_openconfirm(vnode_t vp, u_int8_t *nfhp, int fhlen,
 768     struct nfsclopen *op, struct ucred *cred, NFSPROC_T *p)
 769 {
 770         u_int32_t *tl;
 771         struct nfsrv_descript nfsd, *nd = &nfsd;
 772         struct nfsmount *nmp;
 773         int error;
 774
 775         nmp = VFSTONFS(vnode_mount(vp));
 776         if (NFSHASNFSV4N(nmp))
 777                 return (0);             /* No confirmation for NFSv4.1. */
 778         nfscl_reqstart(nd, NFSPROC_OPENCONFIRM, nmp, nfhp, fhlen, NULL, NULL);
 779         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
 780         *tl++ = op->nfso_stateid.seqid;
 781         *tl++ = op->nfso_stateid.other[0];
 782         *tl++ = op->nfso_stateid.other[1];
 783         *tl++ = op->nfso_stateid.other[2];
 784         *tl = txdr_unsigned(op->nfso_own->nfsow_seqid);
 785         error = nfscl_request(nd, vp, p, cred, NULL);
 786         if (error)
 787                 return (error);
 788         NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
 789         if (!nd->nd_repstat) {
 790                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
 791                 op->nfso_stateid.seqid = *tl++;
 792                 op->nfso_stateid.other[0] = *tl++;
 793                 op->nfso_stateid.other[1] = *tl++;
 794                 op->nfso_stateid.other[2] = *tl;
 795         }
 796         error = nd->nd_repstat;
 797         if (error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION)
 798                 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
 799 nfsmout:
 800         mbuf_freem(nd->nd_mrep);
 801         return (error);
 802 }
 803
 804 /*
 805  * Do the setclientid and setclientid confirm RPCs. Called from nfs_statfs()
 806  * when a mount has just occurred and when the server replies NFSERR_EXPIRED.
 807  */
 808 APPLESTATIC int
 809 nfsrpc_setclient(struct nfsmount *nmp, struct nfsclclient *clp, int reclaim,
 810     struct ucred *cred, NFSPROC_T *p)
 811 {
 812         u_int32_t *tl;
 813         struct nfsrv_descript nfsd;
 814         struct nfsrv_descript *nd = &nfsd;
 815         nfsattrbit_t attrbits;
 816         u_int8_t *cp = NULL, *cp2, addr[INET6_ADDRSTRLEN + 9];
 817         u_short port;
 818         int error, isinet6 = 0, callblen;
 819         nfsquad_t confirm;
 820         u_int32_t lease;
 821         static u_int32_t rev = 0;
 822         struct nfsclds *dsp, *ndsp, *tdsp;
 823
 824         if (nfsboottime.tv_sec == 0)
 825                 NFSSETBOOTTIME(nfsboottime);
 826         clp->nfsc_rev = rev++;
 827         if (NFSHASNFSV4N(nmp)) {
 828                 error = nfsrpc_exchangeid(nmp, clp, &nmp->nm_sockreq,
 829                     NFSV4EXCH_USEPNFSMDS | NFSV4EXCH_USENONPNFS, &dsp, cred, p);
 830                 NFSCL_DEBUG(1, "aft exch=%d\n", error);
 831                 if (error == 0) {
 832                         error = nfsrpc_createsession(nmp, &dsp->nfsclds_sess,
 833                             &nmp->nm_sockreq,
 834                             dsp->nfsclds_sess.nfsess_sequenceid, 1, cred, p);
 835                         if (error == 0) {
 836                                 NFSLOCKMNT(nmp);
 837                                 TAILQ_FOREACH_SAFE(tdsp, &nmp->nm_sess,
 838                                     nfsclds_list, ndsp)
 839                                         nfscl_freenfsclds(tdsp);
 840                                 TAILQ_INIT(&nmp->nm_sess);
 841                                 TAILQ_INSERT_HEAD(&nmp->nm_sess, dsp,
 842                                     nfsclds_list);
 843                                 NFSUNLOCKMNT(nmp);
 844                         } else
 845                                 nfscl_freenfsclds(dsp);
 846                         NFSCL_DEBUG(1, "aft createsess=%d\n", error);
 847                 }
 848                 if (error == 0 && reclaim == 0) {
 849                         error = nfsrpc_reclaimcomplete(nmp, cred, p);
 850                         NFSCL_DEBUG(1, "aft reclaimcomp=%d\n", error);
 851                         if (error == NFSERR_COMPLETEALREADY ||
 852                             error == NFSERR_NOTSUPP)
 853                                 /* Ignore this error. */
 854                                 error = 0;
 855                 }
 856                 return (error);
 857         }
 858
 859         /*
 860          * Allocate a single session structure for NFSv4.0, because some of
 861          * the fields are used by NFSv4.0 although it doesn't do a session.
 862          */
 863         dsp = malloc(sizeof(struct nfsclds), M_NFSCLDS, M_WAITOK | M_ZERO);
 864         mtx_init(&dsp->nfsclds_mtx, "nfsds", NULL, MTX_DEF);
 865         mtx_init(&dsp->nfsclds_sess.nfsess_mtx, "nfssession", NULL, MTX_DEF);
 866         NFSLOCKMNT(nmp);
 867         TAILQ_INSERT_HEAD(&nmp->nm_sess, dsp, nfsclds_list);
 868         NFSUNLOCKMNT(nmp);
 869
 870         nfscl_reqstart(nd, NFSPROC_SETCLIENTID, nmp, NULL, 0, NULL, NULL);
 871         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 872         *tl++ = txdr_unsigned(nfsboottime.tv_sec);
 873         *tl = txdr_unsigned(clp->nfsc_rev);
 874         (void) nfsm_strtom(nd, clp->nfsc_id, clp->nfsc_idlen);
 875
 876         /*
 877          * set up the callback address
 878          */
 879         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
 880         *tl = txdr_unsigned(NFS_CALLBCKPROG);
 881         callblen = strlen(nfsv4_callbackaddr);
 882         if (callblen == 0)
 883                 cp = nfscl_getmyip(nmp, &isinet6);
 884         if (nfscl_enablecallb && nfs_numnfscbd > 0 &&
 885             (callblen > 0 || cp != NULL)) {
 886                 port = htons(nfsv4_cbport);
 887                 cp2 = (u_int8_t *)&port;
 888 #ifdef INET6
 889                 if ((callblen > 0 &&
 890                      strchr(nfsv4_callbackaddr, ':')) || isinet6) {
 891                         char ip6buf[INET6_ADDRSTRLEN], *ip6add;
 892
 893                         (void) nfsm_strtom(nd, "tcp6", 4);
 894                         if (callblen == 0) {
 895                                 ip6_sprintf(ip6buf, (struct in6_addr *)cp);
 896                                 ip6add = ip6buf;
 897                         } else {
 898                                 ip6add = nfsv4_callbackaddr;
 899                         }
 900                         snprintf(addr, INET6_ADDRSTRLEN + 9, "%s.%d.%d",
 901                             ip6add, cp2[0], cp2[1]);
 902                 } else
 903 #endif
 904                 {
 905                         (void) nfsm_strtom(nd, "tcp", 3);
 906                         if (callblen == 0)
 907                                 snprintf(addr, INET6_ADDRSTRLEN + 9,
 908                                     "%d.%d.%d.%d.%d.%d", cp[0], cp[1],
 909                                     cp[2], cp[3], cp2[0], cp2[1]);
 910                         else
 911                                 snprintf(addr, INET6_ADDRSTRLEN + 9,
 912                                     "%s.%d.%d", nfsv4_callbackaddr,
 913                                     cp2[0], cp2[1]);
 914                 }
 915                 (void) nfsm_strtom(nd, addr, strlen(addr));
 916         } else {
 917                 (void) nfsm_strtom(nd, "tcp", 3);
 918                 (void) nfsm_strtom(nd, "0.0.0.0.0.0", 11);
 919         }
 920         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
 921         *tl = txdr_unsigned(clp->nfsc_cbident);
 922         nd->nd_flag |= ND_USEGSSNAME;
 923         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
 924                 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
 925         if (error)
 926                 return (error);
 927         if (nd->nd_repstat == 0) {
 928             NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
 929             NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0] = *tl++;
 930             NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1] = *tl++;
 931             confirm.lval[0] = *tl++;
 932             confirm.lval[1] = *tl;
 933             mbuf_freem(nd->nd_mrep);
 934             nd->nd_mrep = NULL;
 935
 936             /*
 937              * and confirm it.
 938              */
 939             nfscl_reqstart(nd, NFSPROC_SETCLIENTIDCFRM, nmp, NULL, 0, NULL,
 940                 NULL);
 941             NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
 942             *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
 943             *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
 944             *tl++ = confirm.lval[0];
 945             *tl = confirm.lval[1];
 946             nd->nd_flag |= ND_USEGSSNAME;
 947             error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p,
 948                 cred, NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
 949             if (error)
 950                 return (error);
 951             mbuf_freem(nd->nd_mrep);
 952             nd->nd_mrep = NULL;
 953             if (nd->nd_repstat == 0) {
 954                 nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, nmp->nm_fh,
 955                     nmp->nm_fhsize, NULL, NULL);
 956                 NFSZERO_ATTRBIT(&attrbits);
 957                 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_LEASETIME);
 958                 (void) nfsrv_putattrbit(nd, &attrbits);
 959                 nd->nd_flag |= ND_USEGSSNAME;
 960                 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p,
 961                     cred, NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
 962                 if (error)
 963                     return (error);
 964                 if (nd->nd_repstat == 0) {
 965                     error = nfsv4_loadattr(nd, NULL, NULL, NULL, NULL, 0, NULL,
 966                         NULL, NULL, NULL, NULL, 0, NULL, &lease, NULL, p, cred);
 967                     if (error)
 968                         goto nfsmout;
 969                     clp->nfsc_renew = NFSCL_RENEW(lease);
 970                     clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
 971                     clp->nfsc_clientidrev++;
 972                     if (clp->nfsc_clientidrev == 0)
 973                         clp->nfsc_clientidrev++;
 974                 }
 975             }
 976         }
 977         error = nd->nd_repstat;
 978 nfsmout:
 979         mbuf_freem(nd->nd_mrep);
 980         return (error);
 981 }
 982
 983 /*
 984  * nfs getattr call.
 985  */
 986 APPLESTATIC int
 987 nfsrpc_getattr(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
 988     struct nfsvattr *nap, void *stuff)
 989 {
 990         struct nfsrv_descript nfsd, *nd = &nfsd;
 991         int error;
 992         nfsattrbit_t attrbits;
 993
 994         NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp);
 995         if (nd->nd_flag & ND_NFSV4) {
 996                 NFSGETATTR_ATTRBIT(&attrbits);
 997                 (void) nfsrv_putattrbit(nd, &attrbits);
 998         }
 999         error = nfscl_request(nd, vp, p, cred, stuff);
1000         if (error)
1001                 return (error);
1002         if (!nd->nd_repstat)
1003                 error = nfsm_loadattr(nd, nap);
1004         else
1005                 error = nd->nd_repstat;
1006         mbuf_freem(nd->nd_mrep);
1007         return (error);
1008 }
1009
1010 /*
1011  * nfs getattr call with non-vnode arguemnts.
1012  */
1013 APPLESTATIC int
1014 nfsrpc_getattrnovp(struct nfsmount *nmp, u_int8_t *fhp, int fhlen, int syscred,
1015     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, u_int64_t *xidp,
1016     uint32_t *leasep)
1017 {
1018         struct nfsrv_descript nfsd, *nd = &nfsd;
1019         int error, vers = NFS_VER2;
1020         nfsattrbit_t attrbits;
1021
1022         nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, fhp, fhlen, NULL, NULL);
1023         if (nd->nd_flag & ND_NFSV4) {
1024                 vers = NFS_VER4;
1025                 NFSGETATTR_ATTRBIT(&attrbits);
1026                 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_LEASETIME);
1027                 (void) nfsrv_putattrbit(nd, &attrbits);
1028         } else if (nd->nd_flag & ND_NFSV3) {
1029                 vers = NFS_VER3;
1030         }
1031         if (syscred)
1032                 nd->nd_flag |= ND_USEGSSNAME;
1033         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
1034             NFS_PROG, vers, NULL, 1, xidp, NULL);
1035         if (error)
1036                 return (error);
1037         if (nd->nd_repstat == 0) {
1038                 if ((nd->nd_flag & ND_NFSV4) != 0)
1039                         error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
1040                             NULL, NULL, NULL, NULL, NULL, 0, NULL, leasep, NULL,
1041                             NULL, NULL);
1042                 else
1043                         error = nfsm_loadattr(nd, nap);
1044         } else
1045                 error = nd->nd_repstat;
1046         mbuf_freem(nd->nd_mrep);
1047         return (error);
1048 }
1049
1050 /*
1051  * Do an nfs setattr operation.
1052  */
1053 APPLESTATIC int
1054 nfsrpc_setattr(vnode_t vp, struct vattr *vap, NFSACL_T *aclp,
1055     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *rnap, int *attrflagp,
1056     void *stuff)
1057 {
1058         int error, expireret = 0, openerr, retrycnt;
1059         u_int32_t clidrev = 0, mode;
1060         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1061         struct nfsfh *nfhp;
1062         nfsv4stateid_t stateid;
1063         void *lckp;
1064
1065         if (nmp->nm_clp != NULL)
1066                 clidrev = nmp->nm_clp->nfsc_clientidrev;
1067         if (vap != NULL && NFSATTRISSET(u_quad_t, vap, va_size))
1068                 mode = NFSV4OPEN_ACCESSWRITE;
1069         else
1070                 mode = NFSV4OPEN_ACCESSREAD;
1071         retrycnt = 0;
1072         do {
1073                 lckp = NULL;
1074                 openerr = 1;
1075                 if (NFSHASNFSV4(nmp)) {
1076                         nfhp = VTONFS(vp)->n_fhp;
1077                         error = nfscl_getstateid(vp, nfhp->nfh_fh,
1078                             nfhp->nfh_len, mode, 0, cred, p, &stateid, &lckp);
1079                         if (error && vnode_vtype(vp) == VREG &&
1080                             (mode == NFSV4OPEN_ACCESSWRITE ||
1081                              nfstest_openallsetattr)) {
1082                                 /*
1083                                  * No Open stateid, so try and open the file
1084                                  * now.
1085                                  */
1086                                 if (mode == NFSV4OPEN_ACCESSWRITE)
1087                                         openerr = nfsrpc_open(vp, FWRITE, cred,
1088                                             p);
1089                                 else
1090                                         openerr = nfsrpc_open(vp, FREAD, cred,
1091                                             p);
1092                                 if (!openerr)
1093                                         (void) nfscl_getstateid(vp,
1094                                             nfhp->nfh_fh, nfhp->nfh_len,
1095                                             mode, 0, cred, p, &stateid, &lckp);
1096                         }
1097                 }
1098                 if (vap != NULL)
1099                         error = nfsrpc_setattrrpc(vp, vap, &stateid, cred, p,
1100                             rnap, attrflagp, stuff);
1101                 else
1102                         error = nfsrpc_setaclrpc(vp, cred, p, aclp, &stateid,
1103                             stuff);
1104                 if (error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION)
1105                         nfscl_initiate_recovery(nmp->nm_clp);
1106                 if (lckp != NULL)
1107                         nfscl_lockderef(lckp);
1108                 if (!openerr)
1109                         (void) nfsrpc_close(vp, 0, p);
1110                 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1111                     error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1112                     error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
1113                         (void) nfs_catnap(PZERO, error, "nfs_setattr");
1114                 } else if ((error == NFSERR_EXPIRED ||
1115                     error == NFSERR_BADSTATEID) && clidrev != 0) {
1116                         expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1117                 }
1118                 retrycnt++;
1119         } while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1120             error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1121             error == NFSERR_BADSESSION ||
1122             (error == NFSERR_OLDSTATEID && retrycnt < 20) ||
1123             ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1124              expireret == 0 && clidrev != 0 && retrycnt < 4));
1125         if (error && retrycnt >= 4)
1126                 error = EIO;
1127         return (error);
1128 }
1129
1130 static int
1131 nfsrpc_setattrrpc(vnode_t vp, struct vattr *vap,
1132     nfsv4stateid_t *stateidp, struct ucred *cred, NFSPROC_T *p,
1133     struct nfsvattr *rnap, int *attrflagp, void *stuff)
1134 {
1135         u_int32_t *tl;
1136         struct nfsrv_descript nfsd, *nd = &nfsd;
1137         int error;
1138         nfsattrbit_t attrbits;
1139
1140         *attrflagp = 0;
1141         NFSCL_REQSTART(nd, NFSPROC_SETATTR, vp);
1142         if (nd->nd_flag & ND_NFSV4)
1143                 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
1144         vap->va_type = vnode_vtype(vp);
1145         nfscl_fillsattr(nd, vap, vp, NFSSATTR_FULL, 0);
1146         if (nd->nd_flag & ND_NFSV3) {
1147                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1148                 *tl = newnfs_false;
1149         } else if (nd->nd_flag & ND_NFSV4) {
1150                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1151                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1152                 NFSGETATTR_ATTRBIT(&attrbits);
1153                 (void) nfsrv_putattrbit(nd, &attrbits);
1154         }
1155         error = nfscl_request(nd, vp, p, cred, stuff);
1156         if (error)
1157                 return (error);
1158         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
1159                 error = nfscl_wcc_data(nd, vp, rnap, attrflagp, NULL, stuff);
1160         if ((nd->nd_flag & ND_NFSV4) && !error)
1161                 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
1162         if (!(nd->nd_flag & ND_NFSV3) && !nd->nd_repstat && !error)
1163                 error = nfscl_postop_attr(nd, rnap, attrflagp, stuff);
1164         mbuf_freem(nd->nd_mrep);
1165         if (nd->nd_repstat && !error)
1166                 error = nd->nd_repstat;
1167         return (error);
1168 }
1169
1170 /*
1171  * nfs lookup rpc
1172  */
1173 APPLESTATIC int
1174 nfsrpc_lookup(vnode_t dvp, char *name, int len, struct ucred *cred,
1175     NFSPROC_T *p, struct nfsvattr *dnap, struct nfsvattr *nap,
1176     struct nfsfh **nfhpp, int *attrflagp, int *dattrflagp, void *stuff)
1177 {
1178         u_int32_t *tl;
1179         struct nfsrv_descript nfsd, *nd = &nfsd;
1180         struct nfsmount *nmp;
1181         struct nfsnode *np;
1182         struct nfsfh *nfhp;
1183         nfsattrbit_t attrbits;
1184         int error = 0, lookupp = 0;
1185
1186         *attrflagp = 0;
1187         *dattrflagp = 0;
1188         if (vnode_vtype(dvp) != VDIR)
1189                 return (ENOTDIR);
1190         nmp = VFSTONFS(vnode_mount(dvp));
1191         if (len > NFS_MAXNAMLEN)
1192                 return (ENAMETOOLONG);
1193         if (NFSHASNFSV4(nmp) && len == 1 &&
1194                 name[0] == '.') {
1195                 /*
1196                  * Just return the current dir's fh.
1197                  */
1198                 np = VTONFS(dvp);
1199                 MALLOC(nfhp, struct nfsfh *, sizeof (struct nfsfh) +
1200                         np->n_fhp->nfh_len, M_NFSFH, M_WAITOK);
1201                 nfhp->nfh_len = np->n_fhp->nfh_len;
1202                 NFSBCOPY(np->n_fhp->nfh_fh, nfhp->nfh_fh, nfhp->nfh_len);
1203                 *nfhpp = nfhp;
1204                 return (0);
1205         }
1206         if (NFSHASNFSV4(nmp) && len == 2 &&
1207                 name[0] == '.' && name[1] == '.') {
1208                 lookupp = 1;
1209                 NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, dvp);
1210         } else {
1211                 NFSCL_REQSTART(nd, NFSPROC_LOOKUP, dvp);
1212                 (void) nfsm_strtom(nd, name, len);
1213         }
1214         if (nd->nd_flag & ND_NFSV4) {
1215                 NFSGETATTR_ATTRBIT(&attrbits);
1216                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1217                 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
1218                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1219                 (void) nfsrv_putattrbit(nd, &attrbits);
1220         }
1221         error = nfscl_request(nd, dvp, p, cred, stuff);
1222         if (error)
1223                 return (error);
1224         if (nd->nd_repstat) {
1225                 /*
1226                  * When an NFSv4 Lookupp returns ENOENT, it means that
1227                  * the lookup is at the root of an fs, so return this dir.
1228                  */
1229                 if (nd->nd_repstat == NFSERR_NOENT && lookupp) {
1230                     np = VTONFS(dvp);
1231                     MALLOC(nfhp, struct nfsfh *, sizeof (struct nfsfh) +
1232                         np->n_fhp->nfh_len, M_NFSFH, M_WAITOK);
1233                     nfhp->nfh_len = np->n_fhp->nfh_len;
1234                     NFSBCOPY(np->n_fhp->nfh_fh, nfhp->nfh_fh, nfhp->nfh_len);
1235                     *nfhpp = nfhp;
1236                     mbuf_freem(nd->nd_mrep);
1237                     return (0);
1238                 }
1239                 if (nd->nd_flag & ND_NFSV3)
1240                     error = nfscl_postop_attr(nd, dnap, dattrflagp, stuff);
1241                 else if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) ==
1242                     ND_NFSV4) {
1243                         /* Load the directory attributes. */
1244                         error = nfsm_loadattr(nd, dnap);
1245                         if (error == 0)
1246                                 *dattrflagp = 1;
1247                 }
1248                 goto nfsmout;
1249         }
1250         if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4) {
1251                 /* Load the directory attributes. */
1252                 error = nfsm_loadattr(nd, dnap);
1253                 if (error != 0)
1254                         goto nfsmout;
1255                 *dattrflagp = 1;
1256                 /* Skip over the Lookup and GetFH operation status values. */
1257                 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
1258         }
1259         error = nfsm_getfh(nd, nfhpp);
1260         if (error)
1261                 goto nfsmout;
1262
1263         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1264         if ((nd->nd_flag & ND_NFSV3) && !error)
1265                 error = nfscl_postop_attr(nd, dnap, dattrflagp, stuff);
1266 nfsmout:
1267         mbuf_freem(nd->nd_mrep);
1268         if (!error && nd->nd_repstat)
1269                 error = nd->nd_repstat;
1270         return (error);
1271 }
1272
1273 /*
1274  * Do a readlink rpc.
1275  */
1276 APPLESTATIC int
1277 nfsrpc_readlink(vnode_t vp, struct uio *uiop, struct ucred *cred,
1278     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
1279 {
1280         u_int32_t *tl;
1281         struct nfsrv_descript nfsd, *nd = &nfsd;
1282         struct nfsnode *np = VTONFS(vp);
1283         nfsattrbit_t attrbits;
1284         int error, len, cangetattr = 1;
1285
1286         *attrflagp = 0;
1287         NFSCL_REQSTART(nd, NFSPROC_READLINK, vp);
1288         if (nd->nd_flag & ND_NFSV4) {
1289                 /*
1290                  * And do a Getattr op.
1291                  */
1292                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1293                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1294                 NFSGETATTR_ATTRBIT(&attrbits);
1295                 (void) nfsrv_putattrbit(nd, &attrbits);
1296         }
1297         error = nfscl_request(nd, vp, p, cred, stuff);
1298         if (error)
1299                 return (error);
1300         if (nd->nd_flag & ND_NFSV3)
1301                 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1302         if (!nd->nd_repstat && !error) {
1303                 NFSM_STRSIZ(len, NFS_MAXPATHLEN);
1304                 /*
1305                  * This seems weird to me, but must have been added to
1306                  * FreeBSD for some reason. The only thing I can think of
1307                  * is that there was/is some server that replies with
1308                  * more link data than it should?
1309                  */
1310                 if (len == NFS_MAXPATHLEN) {
1311                         NFSLOCKNODE(np);
1312                         if (np->n_size > 0 && np->n_size < NFS_MAXPATHLEN) {
1313                                 len = np->n_size;
1314                                 cangetattr = 0;
1315                         }
1316                         NFSUNLOCKNODE(np);
1317                 }
1318                 error = nfsm_mbufuio(nd, uiop, len);
1319                 if ((nd->nd_flag & ND_NFSV4) && !error && cangetattr)
1320                         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1321         }
1322         if (nd->nd_repstat && !error)
1323                 error = nd->nd_repstat;
1324 nfsmout:
1325         mbuf_freem(nd->nd_mrep);
1326         return (error);
1327 }
1328
1329 /*
1330  * Read operation.
1331  */
1332 APPLESTATIC int
1333 nfsrpc_read(vnode_t vp, struct uio *uiop, struct ucred *cred,
1334     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
1335 {
1336         int error, expireret = 0, retrycnt;
1337         u_int32_t clidrev = 0;
1338         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1339         struct nfsnode *np = VTONFS(vp);
1340         struct ucred *newcred;
1341         struct nfsfh *nfhp = NULL;
1342         nfsv4stateid_t stateid;
1343         void *lckp;
1344
1345         if (nmp->nm_clp != NULL)
1346                 clidrev = nmp->nm_clp->nfsc_clientidrev;
1347         newcred = cred;
1348         if (NFSHASNFSV4(nmp)) {
1349                 nfhp = np->n_fhp;
1350                 newcred = NFSNEWCRED(cred);
1351         }
1352         retrycnt = 0;
1353         do {
1354                 lckp = NULL;
1355                 if (NFSHASNFSV4(nmp))
1356                         (void)nfscl_getstateid(vp, nfhp->nfh_fh, nfhp->nfh_len,
1357                             NFSV4OPEN_ACCESSREAD, 0, newcred, p, &stateid,
1358                             &lckp);
1359                 error = nfsrpc_readrpc(vp, uiop, newcred, &stateid, p, nap,
1360                     attrflagp, stuff);
1361                 if (error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION)
1362                         nfscl_initiate_recovery(nmp->nm_clp);
1363                 if (lckp != NULL)
1364                         nfscl_lockderef(lckp);
1365                 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1366                     error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1367                     error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
1368                         (void) nfs_catnap(PZERO, error, "nfs_read");
1369                 } else if ((error == NFSERR_EXPIRED ||
1370                     error == NFSERR_BADSTATEID) && clidrev != 0) {
1371                         expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1372                 }
1373                 retrycnt++;
1374         } while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1375             error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1376             error == NFSERR_BADSESSION ||
1377             (error == NFSERR_OLDSTATEID && retrycnt < 20) ||
1378             ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1379              expireret == 0 && clidrev != 0 && retrycnt < 4));
1380         if (error && retrycnt >= 4)
1381                 error = EIO;
1382         if (NFSHASNFSV4(nmp))
1383                 NFSFREECRED(newcred);
1384         return (error);
1385 }
1386
1387 /*
1388  * The actual read RPC.
1389  */
1390 static int
1391 nfsrpc_readrpc(vnode_t vp, struct uio *uiop, struct ucred *cred,
1392     nfsv4stateid_t *stateidp, NFSPROC_T *p, struct nfsvattr *nap,
1393     int *attrflagp, void *stuff)
1394 {
1395         u_int32_t *tl;
1396         int error = 0, len, retlen, tsiz, eof = 0;
1397         struct nfsrv_descript nfsd;
1398         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1399         struct nfsrv_descript *nd = &nfsd;
1400         int rsize;
1401         off_t tmp_off;
1402
1403         *attrflagp = 0;
1404         tsiz = uio_uio_resid(uiop);
1405         tmp_off = uiop->uio_offset + tsiz;
1406         NFSLOCKMNT(nmp);
1407         if (tmp_off > nmp->nm_maxfilesize || tmp_off < uiop->uio_offset) {
1408                 NFSUNLOCKMNT(nmp);
1409                 return (EFBIG);
1410         }
1411         rsize = nmp->nm_rsize;
1412         NFSUNLOCKMNT(nmp);
1413         nd->nd_mrep = NULL;
1414         while (tsiz > 0) {
1415                 *attrflagp = 0;
1416                 len = (tsiz > rsize) ? rsize : tsiz;
1417                 NFSCL_REQSTART(nd, NFSPROC_READ, vp);
1418                 if (nd->nd_flag & ND_NFSV4)
1419                         nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
1420                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED * 3);
1421                 if (nd->nd_flag & ND_NFSV2) {
1422                         *tl++ = txdr_unsigned(uiop->uio_offset);
1423                         *tl++ = txdr_unsigned(len);
1424                         *tl = 0;
1425                 } else {
1426                         txdr_hyper(uiop->uio_offset, tl);
1427                         *(tl + 2) = txdr_unsigned(len);
1428                 }
1429                 /*
1430                  * Since I can't do a Getattr for NFSv4 for Write, there
1431                  * doesn't seem any point in doing one here, either.
1432                  * (See the comment in nfsrpc_writerpc() for more info.)
1433                  */
1434                 error = nfscl_request(nd, vp, p, cred, stuff);
1435                 if (error)
1436                         return (error);
1437                 if (nd->nd_flag & ND_NFSV3) {
1438                         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1439                 } else if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV2)) {
1440                         error = nfsm_loadattr(nd, nap);
1441                         if (!error)
1442                                 *attrflagp = 1;
1443                 }
1444                 if (nd->nd_repstat || error) {
1445                         if (!error)
1446                                 error = nd->nd_repstat;
1447                         goto nfsmout;
1448                 }
1449                 if (nd->nd_flag & ND_NFSV3) {
1450                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1451                         eof = fxdr_unsigned(int, *(tl + 1));
1452                 } else if (nd->nd_flag & ND_NFSV4) {
1453                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1454                         eof = fxdr_unsigned(int, *tl);
1455                 }
1456                 NFSM_STRSIZ(retlen, len);
1457                 error = nfsm_mbufuio(nd, uiop, retlen);
1458                 if (error)
1459                         goto nfsmout;
1460                 mbuf_freem(nd->nd_mrep);
1461                 nd->nd_mrep = NULL;
1462                 tsiz -= retlen;
1463                 if (!(nd->nd_flag & ND_NFSV2)) {
1464                         if (eof || retlen == 0)
1465                                 tsiz = 0;
1466                 } else if (retlen < len)
1467                         tsiz = 0;
1468         }
1469         return (0);
1470 nfsmout:
1471         if (nd->nd_mrep != NULL)
1472                 mbuf_freem(nd->nd_mrep);
1473         return (error);
1474 }
1475
1476 /*
1477  * nfs write operation
1478  * When called_from_strategy != 0, it should return EIO for an error that
1479  * indicates recovery is in progress, so that the buffer will be left
1480  * dirty and be written back to the server later. If it loops around,
1481  * the recovery thread could get stuck waiting for the buffer and recovery
1482  * will then deadlock.
1483  */
1484 APPLESTATIC int
1485 nfsrpc_write(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
1486     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
1487     void *stuff, int called_from_strategy)
1488 {
1489         int error, expireret = 0, retrycnt, nostateid;
1490         u_int32_t clidrev = 0;
1491         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1492         struct nfsnode *np = VTONFS(vp);
1493         struct ucred *newcred;
1494         struct nfsfh *nfhp = NULL;
1495         nfsv4stateid_t stateid;
1496         void *lckp;
1497
1498         *must_commit = 0;
1499         if (nmp->nm_clp != NULL)
1500                 clidrev = nmp->nm_clp->nfsc_clientidrev;
1501         newcred = cred;
1502         if (NFSHASNFSV4(nmp)) {
1503                 newcred = NFSNEWCRED(cred);
1504                 nfhp = np->n_fhp;
1505         }
1506         retrycnt = 0;
1507         do {
1508                 lckp = NULL;
1509                 nostateid = 0;
1510                 if (NFSHASNFSV4(nmp)) {
1511                         (void)nfscl_getstateid(vp, nfhp->nfh_fh, nfhp->nfh_len,
1512                             NFSV4OPEN_ACCESSWRITE, 0, newcred, p, &stateid,
1513                             &lckp);
1514                         if (stateid.other[0] == 0 && stateid.other[1] == 0 &&
1515                             stateid.other[2] == 0) {
1516                                 nostateid = 1;
1517                                 NFSCL_DEBUG(1, "stateid0 in write\n");
1518                         }
1519                 }
1520
1521                 /*
1522                  * If there is no stateid for NFSv4, it means this is an
1523                  * extraneous write after close. Basically a poorly
1524                  * implemented buffer cache. Just don't do the write.
1525                  */
1526                 if (nostateid)
1527                         error = 0;
1528                 else
1529                         error = nfsrpc_writerpc(vp, uiop, iomode, must_commit,
1530                             newcred, &stateid, p, nap, attrflagp, stuff);
1531                 if (error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION)
1532                         nfscl_initiate_recovery(nmp->nm_clp);
1533                 if (lckp != NULL)
1534                         nfscl_lockderef(lckp);
1535                 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1536                     error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1537                     error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
1538                         (void) nfs_catnap(PZERO, error, "nfs_write");
1539                 } else if ((error == NFSERR_EXPIRED ||
1540                     error == NFSERR_BADSTATEID) && clidrev != 0) {
1541                         expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1542                 }
1543                 retrycnt++;
1544         } while (error == NFSERR_GRACE || error == NFSERR_DELAY ||
1545             ((error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION ||
1546               error == NFSERR_STALEDONTRECOVER) && called_from_strategy == 0) ||
1547             (error == NFSERR_OLDSTATEID && retrycnt < 20) ||
1548             ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1549              expireret == 0 && clidrev != 0 && retrycnt < 4));
1550         if (error != 0 && (retrycnt >= 4 ||
1551             ((error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION ||
1552               error == NFSERR_STALEDONTRECOVER) && called_from_strategy != 0)))
1553                 error = EIO;
1554         if (NFSHASNFSV4(nmp))
1555                 NFSFREECRED(newcred);
1556         return (error);
1557 }
1558
1559 /*
1560  * The actual write RPC.
1561  */
1562 static int
1563 nfsrpc_writerpc(vnode_t vp, struct uio *uiop, int *iomode,
1564     int *must_commit, struct ucred *cred, nfsv4stateid_t *stateidp,
1565     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
1566 {
1567         u_int32_t *tl;
1568         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1569         struct nfsnode *np = VTONFS(vp);
1570         int error = 0, len, tsiz, rlen, commit, committed = NFSWRITE_FILESYNC;
1571         int wccflag = 0, wsize;
1572         int32_t backup;
1573         struct nfsrv_descript nfsd;
1574         struct nfsrv_descript *nd = &nfsd;
1575         nfsattrbit_t attrbits;
1576         off_t tmp_off;
1577
1578         KASSERT(uiop->uio_iovcnt == 1, ("nfs: writerpc iovcnt > 1"));
1579         *attrflagp = 0;
1580         tsiz = uio_uio_resid(uiop);
1581         tmp_off = uiop->uio_offset + tsiz;
1582         NFSLOCKMNT(nmp);
1583         if (tmp_off > nmp->nm_maxfilesize || tmp_off < uiop->uio_offset) {
1584                 NFSUNLOCKMNT(nmp);
1585                 return (EFBIG);
1586         }
1587         wsize = nmp->nm_wsize;
1588         NFSUNLOCKMNT(nmp);
1589         nd->nd_mrep = NULL;     /* NFSv2 sometimes does a write with */
1590         nd->nd_repstat = 0;     /* uio_resid == 0, so the while is not done */
1591         while (tsiz > 0) {
1592                 *attrflagp = 0;
1593                 len = (tsiz > wsize) ? wsize : tsiz;
1594                 NFSCL_REQSTART(nd, NFSPROC_WRITE, vp);
1595                 if (nd->nd_flag & ND_NFSV4) {
1596                         nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
1597                         NFSM_BUILD(tl, u_int32_t *, NFSX_HYPER+2*NFSX_UNSIGNED);
1598                         txdr_hyper(uiop->uio_offset, tl);
1599                         tl += 2;
1600                         *tl++ = txdr_unsigned(*iomode);
1601                         *tl = txdr_unsigned(len);
1602                 } else if (nd->nd_flag & ND_NFSV3) {
1603                         NFSM_BUILD(tl, u_int32_t *, NFSX_HYPER+3*NFSX_UNSIGNED);
1604                         txdr_hyper(uiop->uio_offset, tl);
1605                         tl += 2;
1606                         *tl++ = txdr_unsigned(len);
1607                         *tl++ = txdr_unsigned(*iomode);
1608                         *tl = txdr_unsigned(len);
1609                 } else {
1610                         u_int32_t x;
1611
1612                         NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
1613                         /*
1614                          * Not sure why someone changed this, since the
1615                          * RFC clearly states that "beginoffset" and
1616                          * "totalcount" are ignored, but it wouldn't
1617                          * surprise me if there's a busted server out there.
1618                          */
1619                         /* Set both "begin" and "current" to non-garbage. */
1620                         x = txdr_unsigned((u_int32_t)uiop->uio_offset);
1621                         *tl++ = x;      /* "begin offset" */
1622                         *tl++ = x;      /* "current offset" */
1623                         x = txdr_unsigned(len);
1624                         *tl++ = x;      /* total to this offset */
1625                         *tl = x;        /* size of this write */
1626
1627                 }
1628                 nfsm_uiombuf(nd, uiop, len);
1629                 /*
1630                  * Although it is tempting to do a normal Getattr Op in the
1631                  * NFSv4 compound, the result can be a nearly hung client
1632                  * system if the Getattr asks for Owner and/or OwnerGroup.
1633                  * It occurs when the client can't map either the Owner or
1634                  * Owner_group name in the Getattr reply to a uid/gid. When
1635                  * there is a cache miss, the kernel does an upcall to the
1636                  * nfsuserd. Then, it can try and read the local /etc/passwd
1637                  * or /etc/group file. It can then block in getnewbuf(),
1638                  * waiting for dirty writes to be pushed to the NFS server.
1639                  * The only reason this doesn't result in a complete
1640                  * deadlock, is that the upcall times out and allows
1641                  * the write to complete. However, progress is so slow
1642                  * that it might just as well be deadlocked.
1643                  * As such, we get the rest of the attributes, but not
1644                  * Owner or Owner_group.
1645                  * nb: nfscl_loadattrcache() needs to be told that these
1646                  *     partial attributes from a write rpc are being
1647                  *     passed in, via a argument flag.
1648                  */
1649                 if (nd->nd_flag & ND_NFSV4) {
1650                         NFSWRITEGETATTR_ATTRBIT(&attrbits);
1651                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1652                         *tl = txdr_unsigned(NFSV4OP_GETATTR);
1653                         (void) nfsrv_putattrbit(nd, &attrbits);
1654                 }
1655                 error = nfscl_request(nd, vp, p, cred, stuff);
1656                 if (error)
1657                         return (error);
1658                 if (nd->nd_repstat) {
1659                         /*
1660                          * In case the rpc gets retried, roll
1661                          * the uio fileds changed by nfsm_uiombuf()
1662                          * back.
1663                          */
1664                         uiop->uio_offset -= len;
1665                         uio_uio_resid_add(uiop, len);
1666                         uio_iov_base_add(uiop, -len);
1667                         uio_iov_len_add(uiop, len);
1668                 }
1669                 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
1670                         error = nfscl_wcc_data(nd, vp, nap, attrflagp,
1671                             &wccflag, stuff);
1672                         if (error)
1673                                 goto nfsmout;
1674                 }
1675                 if (!nd->nd_repstat) {
1676                         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
1677                                 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED
1678                                         + NFSX_VERF);
1679                                 rlen = fxdr_unsigned(int, *tl++);
1680                                 if (rlen == 0) {
1681                                         error = NFSERR_IO;
1682                                         goto nfsmout;
1683                                 } else if (rlen < len) {
1684                                         backup = len - rlen;
1685                                         uio_iov_base_add(uiop, -(backup));
1686                                         uio_iov_len_add(uiop, backup);
1687                                         uiop->uio_offset -= backup;
1688                                         uio_uio_resid_add(uiop, backup);
1689                                         len = rlen;
1690                                 }
1691                                 commit = fxdr_unsigned(int, *tl++);
1692
1693                                 /*
1694                                  * Return the lowest committment level
1695                                  * obtained by any of the RPCs.
1696                                  */
1697                                 if (committed == NFSWRITE_FILESYNC)
1698                                         committed = commit;
1699                                 else if (committed == NFSWRITE_DATASYNC &&
1700                                         commit == NFSWRITE_UNSTABLE)
1701                                         committed = commit;
1702                                 NFSLOCKMNT(nmp);
1703                                 if (!NFSHASWRITEVERF(nmp)) {
1704                                         NFSBCOPY((caddr_t)tl,
1705                                             (caddr_t)&nmp->nm_verf[0],
1706                                             NFSX_VERF);
1707                                         NFSSETWRITEVERF(nmp);
1708                                 } else if (NFSBCMP(tl, nmp->nm_verf,
1709                                     NFSX_VERF)) {
1710                                         *must_commit = 1;
1711                                         NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
1712                                 }
1713                                 NFSUNLOCKMNT(nmp);
1714                         }
1715                         if (nd->nd_flag & ND_NFSV4)
1716                                 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1717                         if (nd->nd_flag & (ND_NFSV2 | ND_NFSV4)) {
1718                                 error = nfsm_loadattr(nd, nap);
1719                                 if (!error)
1720                                         *attrflagp = NFS_LATTR_NOSHRINK;
1721                         }
1722                 } else {
1723                         error = nd->nd_repstat;
1724                 }
1725                 if (error)
1726                         goto nfsmout;
1727                 NFSWRITERPC_SETTIME(wccflag, np, (nd->nd_flag & ND_NFSV4));
1728                 mbuf_freem(nd->nd_mrep);
1729                 nd->nd_mrep = NULL;
1730                 tsiz -= len;
1731         }
1732 nfsmout:
1733         if (nd->nd_mrep != NULL)
1734                 mbuf_freem(nd->nd_mrep);
1735         *iomode = committed;
1736         if (nd->nd_repstat && !error)
1737                 error = nd->nd_repstat;
1738         return (error);
1739 }
1740
1741 /*
1742  * nfs mknod rpc
1743  * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
1744  * mode set to specify the file type and the size field for rdev.
1745  */
1746 APPLESTATIC int
1747 nfsrpc_mknod(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1748     u_int32_t rdev, enum vtype vtyp, struct ucred *cred, NFSPROC_T *p,
1749     struct nfsvattr *dnap, struct nfsvattr *nnap, struct nfsfh **nfhpp,
1750     int *attrflagp, int *dattrflagp, void *dstuff)
1751 {
1752         u_int32_t *tl;
1753         int error = 0;
1754         struct nfsrv_descript nfsd, *nd = &nfsd;
1755         nfsattrbit_t attrbits;
1756
1757         *nfhpp = NULL;
1758         *attrflagp = 0;
1759         *dattrflagp = 0;
1760         if (namelen > NFS_MAXNAMLEN)
1761                 return (ENAMETOOLONG);
1762         NFSCL_REQSTART(nd, NFSPROC_MKNOD, dvp);
1763         if (nd->nd_flag & ND_NFSV4) {
1764                 if (vtyp == VBLK || vtyp == VCHR) {
1765                         NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
1766                         *tl++ = vtonfsv34_type(vtyp);
1767                         *tl++ = txdr_unsigned(NFSMAJOR(rdev));
1768                         *tl = txdr_unsigned(NFSMINOR(rdev));
1769                 } else {
1770                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1771                         *tl = vtonfsv34_type(vtyp);
1772                 }
1773         }
1774         (void) nfsm_strtom(nd, name, namelen);
1775         if (nd->nd_flag & ND_NFSV3) {
1776                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1777                 *tl = vtonfsv34_type(vtyp);
1778         }
1779         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
1780                 nfscl_fillsattr(nd, vap, dvp, 0, 0);
1781         if ((nd->nd_flag & ND_NFSV3) &&
1782             (vtyp == VCHR || vtyp == VBLK)) {
1783                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1784                 *tl++ = txdr_unsigned(NFSMAJOR(rdev));
1785                 *tl = txdr_unsigned(NFSMINOR(rdev));
1786         }
1787         if (nd->nd_flag & ND_NFSV4) {
1788                 NFSGETATTR_ATTRBIT(&attrbits);
1789                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1790                 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
1791                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1792                 (void) nfsrv_putattrbit(nd, &attrbits);
1793         }
1794         if (nd->nd_flag & ND_NFSV2)
1795                 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZERDEV, rdev);
1796         error = nfscl_request(nd, dvp, p, cred, dstuff);
1797         if (error)
1798                 return (error);
1799         if (nd->nd_flag & ND_NFSV4)
1800                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
1801         if (!nd->nd_repstat) {
1802                 if (nd->nd_flag & ND_NFSV4) {
1803                         NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1804                         error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
1805                         if (error)
1806                                 goto nfsmout;
1807                 }
1808                 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
1809                 if (error)
1810                         goto nfsmout;
1811         }
1812         if (nd->nd_flag & ND_NFSV3)
1813                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
1814         if (!error && nd->nd_repstat)
1815                 error = nd->nd_repstat;
1816 nfsmout:
1817         mbuf_freem(nd->nd_mrep);
1818         return (error);
1819 }
1820
1821 /*
1822  * nfs file create call
1823  * Mostly just call the approriate routine. (I separated out v4, so that
1824  * error recovery wouldn't be as difficult.)
1825  */
1826 APPLESTATIC int
1827 nfsrpc_create(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1828     nfsquad_t cverf, int fmode, struct ucred *cred, NFSPROC_T *p,
1829     struct nfsvattr *dnap, struct nfsvattr *nnap, struct nfsfh **nfhpp,
1830     int *attrflagp, int *dattrflagp, void *dstuff)
1831 {
1832         int error = 0, newone, expireret = 0, retrycnt, unlocked;
1833         struct nfsclowner *owp;
1834         struct nfscldeleg *dp;
1835         struct nfsmount *nmp = VFSTONFS(vnode_mount(dvp));
1836         u_int32_t clidrev;
1837
1838         if (NFSHASNFSV4(nmp)) {
1839             retrycnt = 0;
1840             do {
1841                 dp = NULL;
1842                 error = nfscl_open(dvp, NULL, 0, (NFSV4OPEN_ACCESSWRITE |
1843                     NFSV4OPEN_ACCESSREAD), 0, cred, p, &owp, NULL, &newone,
1844                     NULL, 1);
1845                 if (error)
1846                         return (error);
1847                 if (nmp->nm_clp != NULL)
1848                         clidrev = nmp->nm_clp->nfsc_clientidrev;
1849                 else
1850                         clidrev = 0;
1851                 error = nfsrpc_createv4(dvp, name, namelen, vap, cverf, fmode,
1852                   owp, &dp, cred, p, dnap, nnap, nfhpp, attrflagp, dattrflagp,
1853                   dstuff, &unlocked);
1854                 /*
1855                  * There is no need to invalidate cached attributes here,
1856                  * since new post-delegation issue attributes are always
1857                  * returned by nfsrpc_createv4() and these will update the
1858                  * attribute cache.
1859                  */
1860                 if (dp != NULL)
1861                         (void) nfscl_deleg(nmp->nm_mountp, owp->nfsow_clp,
1862                             (*nfhpp)->nfh_fh, (*nfhpp)->nfh_len, cred, p, &dp);
1863                 nfscl_ownerrelease(owp, error, newone, unlocked);
1864                 if (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
1865                     error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1866                     error == NFSERR_BADSESSION) {
1867                         (void) nfs_catnap(PZERO, error, "nfs_open");
1868                 } else if ((error == NFSERR_EXPIRED ||
1869                     error == NFSERR_BADSTATEID) && clidrev != 0) {
1870                         expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1871                         retrycnt++;
1872                 }
1873             } while (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
1874                 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1875                 error == NFSERR_BADSESSION ||
1876                 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1877                  expireret == 0 && clidrev != 0 && retrycnt < 4));
1878             if (error && retrycnt >= 4)
1879                     error = EIO;
1880         } else {
1881                 error = nfsrpc_createv23(dvp, name, namelen, vap, cverf,
1882                     fmode, cred, p, dnap, nnap, nfhpp, attrflagp, dattrflagp,
1883                     dstuff);
1884         }
1885         return (error);
1886 }
1887
1888 /*
1889  * The create rpc for v2 and 3.
1890  */
1891 static int
1892 nfsrpc_createv23(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1893     nfsquad_t cverf, int fmode, struct ucred *cred, NFSPROC_T *p,
1894     struct nfsvattr *dnap, struct nfsvattr *nnap, struct nfsfh **nfhpp,
1895     int *attrflagp, int *dattrflagp, void *dstuff)
1896 {
1897         u_int32_t *tl;
1898         int error = 0;
1899         struct nfsrv_descript nfsd, *nd = &nfsd;
1900
1901         *nfhpp = NULL;
1902         *attrflagp = 0;
1903         *dattrflagp = 0;
1904         if (namelen > NFS_MAXNAMLEN)
1905                 return (ENAMETOOLONG);
1906         NFSCL_REQSTART(nd, NFSPROC_CREATE, dvp);
1907         (void) nfsm_strtom(nd, name, namelen);
1908         if (nd->nd_flag & ND_NFSV3) {
1909                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1910                 if (fmode & O_EXCL) {
1911                         *tl = txdr_unsigned(NFSCREATE_EXCLUSIVE);
1912                         NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
1913                         *tl++ = cverf.lval[0];
1914                         *tl = cverf.lval[1];
1915                 } else {
1916                         *tl = txdr_unsigned(NFSCREATE_UNCHECKED);
1917                         nfscl_fillsattr(nd, vap, dvp, 0, 0);
1918                 }
1919         } else {
1920                 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZE0, 0);
1921         }
1922         error = nfscl_request(nd, dvp, p, cred, dstuff);
1923         if (error)
1924                 return (error);
1925         if (nd->nd_repstat == 0) {
1926                 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
1927                 if (error)
1928                         goto nfsmout;
1929         }
1930         if (nd->nd_flag & ND_NFSV3)
1931                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
1932         if (nd->nd_repstat != 0 && error == 0)
1933                 error = nd->nd_repstat;
1934 nfsmout:
1935         mbuf_freem(nd->nd_mrep);
1936         return (error);
1937 }
1938
1939 static int
1940 nfsrpc_createv4(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1941     nfsquad_t cverf, int fmode, struct nfsclowner *owp, struct nfscldeleg **dpp,
1942     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
1943     struct nfsvattr *nnap, struct nfsfh **nfhpp, int *attrflagp,
1944     int *dattrflagp, void *dstuff, int *unlockedp)
1945 {
1946         u_int32_t *tl;
1947         int error = 0, deleg, newone, ret, acesize, limitby;
1948         struct nfsrv_descript nfsd, *nd = &nfsd;
1949         struct nfsclopen *op;
1950         struct nfscldeleg *dp = NULL;
1951         struct nfsnode *np;
1952         struct nfsfh *nfhp;
1953         nfsattrbit_t attrbits;
1954         nfsv4stateid_t stateid;
1955         u_int32_t rflags;
1956         struct nfsmount *nmp;
1957
1958         nmp = VFSTONFS(dvp->v_mount);
1959         np = VTONFS(dvp);
1960         *unlockedp = 0;
1961         *nfhpp = NULL;
1962         *dpp = NULL;
1963         *attrflagp = 0;
1964         *dattrflagp = 0;
1965         if (namelen > NFS_MAXNAMLEN)
1966                 return (ENAMETOOLONG);
1967         NFSCL_REQSTART(nd, NFSPROC_CREATE, dvp);
1968         /*
1969          * For V4, this is actually an Open op.
1970          */
1971         NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1972         *tl++ = txdr_unsigned(owp->nfsow_seqid);
1973         *tl++ = txdr_unsigned(NFSV4OPEN_ACCESSWRITE |
1974             NFSV4OPEN_ACCESSREAD);
1975         *tl++ = txdr_unsigned(NFSV4OPEN_DENYNONE);
1976         *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
1977         *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
1978         (void) nfsm_strtom(nd, owp->nfsow_owner, NFSV4CL_LOCKNAMELEN);
1979         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1980         *tl++ = txdr_unsigned(NFSV4OPEN_CREATE);
1981         if (fmode & O_EXCL) {
1982                 if (NFSHASNFSV4N(nmp)) {
1983                         if (NFSHASSESSPERSIST(nmp)) {
1984                                 /* Use GUARDED for persistent sessions. */
1985                                 *tl = txdr_unsigned(NFSCREATE_GUARDED);
1986                                 nfscl_fillsattr(nd, vap, dvp, 0, 0);
1987                         } else {
1988                                 /* Otherwise, use EXCLUSIVE4_1. */
1989                                 *tl = txdr_unsigned(NFSCREATE_EXCLUSIVE41);
1990                                 NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
1991                                 *tl++ = cverf.lval[0];
1992                                 *tl = cverf.lval[1];
1993                                 nfscl_fillsattr(nd, vap, dvp, 0, 0);
1994                         }
1995                 } else {
1996                         /* NFSv4.0 */
1997                         *tl = txdr_unsigned(NFSCREATE_EXCLUSIVE);
1998                         NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
1999                         *tl++ = cverf.lval[0];
2000                         *tl = cverf.lval[1];
2001                 }
2002         } else {
2003                 *tl = txdr_unsigned(NFSCREATE_UNCHECKED);
2004                 nfscl_fillsattr(nd, vap, dvp, 0, 0);
2005         }
2006         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2007         *tl = txdr_unsigned(NFSV4OPEN_CLAIMNULL);
2008         (void) nfsm_strtom(nd, name, namelen);
2009         /* Get the new file's handle and attributes. */
2010         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2011         *tl++ = txdr_unsigned(NFSV4OP_GETFH);
2012         *tl = txdr_unsigned(NFSV4OP_GETATTR);
2013         NFSGETATTR_ATTRBIT(&attrbits);
2014         (void) nfsrv_putattrbit(nd, &attrbits);
2015         /* Get the directory's post-op attributes. */
2016         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2017         *tl = txdr_unsigned(NFSV4OP_PUTFH);
2018         (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh, np->n_fhp->nfh_len, 0);
2019         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2020         *tl = txdr_unsigned(NFSV4OP_GETATTR);
2021         (void) nfsrv_putattrbit(nd, &attrbits);
2022         error = nfscl_request(nd, dvp, p, cred, dstuff);
2023         if (error)
2024                 return (error);
2025         NFSCL_INCRSEQID(owp->nfsow_seqid, nd);
2026         if (nd->nd_repstat == 0) {
2027                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
2028                     6 * NFSX_UNSIGNED);
2029                 stateid.seqid = *tl++;
2030                 stateid.other[0] = *tl++;
2031                 stateid.other[1] = *tl++;
2032                 stateid.other[2] = *tl;
2033                 rflags = fxdr_unsigned(u_int32_t, *(tl + 6));
2034                 (void) nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
2035                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2036                 deleg = fxdr_unsigned(int, *tl);
2037                 if (deleg == NFSV4OPEN_DELEGATEREAD ||
2038                     deleg == NFSV4OPEN_DELEGATEWRITE) {
2039                         if (!(owp->nfsow_clp->nfsc_flags &
2040                               NFSCLFLAGS_FIRSTDELEG))
2041                                 owp->nfsow_clp->nfsc_flags |=
2042                                   (NFSCLFLAGS_FIRSTDELEG | NFSCLFLAGS_GOTDELEG);
2043                         MALLOC(dp, struct nfscldeleg *,
2044                             sizeof (struct nfscldeleg) + NFSX_V4FHMAX,
2045                             M_NFSCLDELEG, M_WAITOK);
2046                         LIST_INIT(&dp->nfsdl_owner);
2047                         LIST_INIT(&dp->nfsdl_lock);
2048                         dp->nfsdl_clp = owp->nfsow_clp;
2049                         newnfs_copyincred(cred, &dp->nfsdl_cred);
2050                         nfscl_lockinit(&dp->nfsdl_rwlock);
2051                         NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
2052                             NFSX_UNSIGNED);
2053                         dp->nfsdl_stateid.seqid = *tl++;
2054                         dp->nfsdl_stateid.other[0] = *tl++;
2055                         dp->nfsdl_stateid.other[1] = *tl++;
2056                         dp->nfsdl_stateid.other[2] = *tl++;
2057                         ret = fxdr_unsigned(int, *tl);
2058                         if (deleg == NFSV4OPEN_DELEGATEWRITE) {
2059                                 dp->nfsdl_flags = NFSCLDL_WRITE;
2060                                 /*
2061                                  * Indicates how much the file can grow.
2062                                  */
2063                                 NFSM_DISSECT(tl, u_int32_t *,
2064                                     3 * NFSX_UNSIGNED);
2065                                 limitby = fxdr_unsigned(int, *tl++);
2066                                 switch (limitby) {
2067                                 case NFSV4OPEN_LIMITSIZE:
2068                                         dp->nfsdl_sizelimit = fxdr_hyper(tl);
2069                                         break;
2070                                 case NFSV4OPEN_LIMITBLOCKS:
2071                                         dp->nfsdl_sizelimit =
2072                                             fxdr_unsigned(u_int64_t, *tl++);
2073                                         dp->nfsdl_sizelimit *=
2074                                             fxdr_unsigned(u_int64_t, *tl);
2075                                         break;
2076                                 default:
2077                                         error = NFSERR_BADXDR;
2078                                         goto nfsmout;
2079                                 };
2080                         } else {
2081                                 dp->nfsdl_flags = NFSCLDL_READ;
2082                         }
2083                         if (ret)
2084                                 dp->nfsdl_flags |= NFSCLDL_RECALL;
2085                         error = nfsrv_dissectace(nd, &dp->nfsdl_ace, &ret,
2086                             &acesize, p);
2087                         if (error)
2088                                 goto nfsmout;
2089                 } else if (deleg != NFSV4OPEN_DELEGATENONE) {
2090                         error = NFSERR_BADXDR;
2091                         goto nfsmout;
2092                 }
2093                 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
2094                 if (error)
2095                         goto nfsmout;
2096                 /* Get rid of the PutFH and Getattr status values. */
2097                 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
2098                 /* Load the directory attributes. */
2099                 error = nfsm_loadattr(nd, dnap);
2100                 if (error)
2101                         goto nfsmout;
2102                 *dattrflagp = 1;
2103                 if (dp != NULL && *attrflagp) {
2104                         dp->nfsdl_change = nnap->na_filerev;
2105                         dp->nfsdl_modtime = nnap->na_mtime;
2106                         dp->nfsdl_flags |= NFSCLDL_MODTIMESET;
2107                 }
2108                 /*
2109                  * We can now complete the Open state.
2110                  */
2111                 nfhp = *nfhpp;
2112                 if (dp != NULL) {
2113                         dp->nfsdl_fhlen = nfhp->nfh_len;
2114                         NFSBCOPY(nfhp->nfh_fh, dp->nfsdl_fh, nfhp->nfh_len);
2115                 }
2116                 /*
2117                  * Get an Open structure that will be
2118                  * attached to the OpenOwner, acquired already.
2119                  */
2120                 error = nfscl_open(dvp, nfhp->nfh_fh, nfhp->nfh_len,
2121                     (NFSV4OPEN_ACCESSWRITE | NFSV4OPEN_ACCESSREAD), 0,
2122                     cred, p, NULL, &op, &newone, NULL, 0);
2123                 if (error)
2124                         goto nfsmout;
2125                 op->nfso_stateid = stateid;
2126                 newnfs_copyincred(cred, &op->nfso_cred);
2127                 if ((rflags & NFSV4OPEN_RESULTCONFIRM)) {
2128                     do {
2129                         ret = nfsrpc_openconfirm(dvp, nfhp->nfh_fh,
2130                             nfhp->nfh_len, op, cred, p);
2131                         if (ret == NFSERR_DELAY)
2132                             (void) nfs_catnap(PZERO, ret, "nfs_create");
2133                     } while (ret == NFSERR_DELAY);
2134                     error = ret;
2135                 }
2136
2137                 /*
2138                  * If the server is handing out delegations, but we didn't
2139                  * get one because an OpenConfirm was required, try the
2140                  * Open again, to get a delegation. This is a harmless no-op,
2141                  * from a server's point of view.
2142                  */
2143                 if ((rflags & NFSV4OPEN_RESULTCONFIRM) &&
2144                     (owp->nfsow_clp->nfsc_flags & NFSCLFLAGS_GOTDELEG) &&
2145                     !error && dp == NULL) {
2146                     do {
2147                         ret = nfsrpc_openrpc(VFSTONFS(vnode_mount(dvp)), dvp,
2148                             np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
2149                             nfhp->nfh_fh, nfhp->nfh_len,
2150                             (NFSV4OPEN_ACCESSWRITE | NFSV4OPEN_ACCESSREAD), op,
2151                             name, namelen, &dp, 0, 0x0, cred, p, 0, 1);
2152                         if (ret == NFSERR_DELAY)
2153                             (void) nfs_catnap(PZERO, ret, "nfs_crt2");
2154                     } while (ret == NFSERR_DELAY);
2155                     if (ret) {
2156                         if (dp != NULL) {
2157                                 FREE((caddr_t)dp, M_NFSCLDELEG);
2158                                 dp = NULL;
2159                         }
2160                         if (ret == NFSERR_STALECLIENTID ||
2161                             ret == NFSERR_STALEDONTRECOVER ||
2162                             ret == NFSERR_BADSESSION)
2163                                 error = ret;
2164                     }
2165                 }
2166                 nfscl_openrelease(op, error, newone);
2167                 *unlockedp = 1;
2168         }
2169         if (nd->nd_repstat != 0 && error == 0)
2170                 error = nd->nd_repstat;
2171         if (error == NFSERR_STALECLIENTID || error == NFSERR_BADSESSION)
2172                 nfscl_initiate_recovery(owp->nfsow_clp);
2173 nfsmout:
2174         if (!error)
2175                 *dpp = dp;
2176         else if (dp != NULL)
2177                 FREE((caddr_t)dp, M_NFSCLDELEG);
2178         mbuf_freem(nd->nd_mrep);
2179         return (error);
2180 }
2181
2182 /*
2183  * Nfs remove rpc
2184  */
2185 APPLESTATIC int
2186 nfsrpc_remove(vnode_t dvp, char *name, int namelen, vnode_t vp,
2187     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap, int *dattrflagp,
2188     void *dstuff)
2189 {
2190         u_int32_t *tl;
2191         struct nfsrv_descript nfsd, *nd = &nfsd;
2192         struct nfsnode *np;
2193         struct nfsmount *nmp;
2194         nfsv4stateid_t dstateid;
2195         int error, ret = 0, i;
2196
2197         *dattrflagp = 0;
2198         if (namelen > NFS_MAXNAMLEN)
2199                 return (ENAMETOOLONG);
2200         nmp = VFSTONFS(vnode_mount(dvp));
2201 tryagain:
2202         if (NFSHASNFSV4(nmp) && ret == 0) {
2203                 ret = nfscl_removedeleg(vp, p, &dstateid);
2204                 if (ret == 1) {
2205                         NFSCL_REQSTART(nd, NFSPROC_RETDELEGREMOVE, vp);
2206                         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID +
2207                             NFSX_UNSIGNED);
2208                         if (NFSHASNFSV4N(nmp))
2209                                 *tl++ = 0;
2210                         else
2211                                 *tl++ = dstateid.seqid;
2212                         *tl++ = dstateid.other[0];
2213                         *tl++ = dstateid.other[1];
2214                         *tl++ = dstateid.other[2];
2215                         *tl = txdr_unsigned(NFSV4OP_PUTFH);
2216                         np = VTONFS(dvp);
2217                         (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh,
2218                             np->n_fhp->nfh_len, 0);
2219                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2220                         *tl = txdr_unsigned(NFSV4OP_REMOVE);
2221                 }
2222         } else {
2223                 ret = 0;
2224         }
2225         if (ret == 0)
2226                 NFSCL_REQSTART(nd, NFSPROC_REMOVE, dvp);
2227         (void) nfsm_strtom(nd, name, namelen);
2228         error = nfscl_request(nd, dvp, p, cred, dstuff);
2229         if (error)
2230                 return (error);
2231         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
2232                 /* For NFSv4, parse out any Delereturn replies. */
2233                 if (ret > 0 && nd->nd_repstat != 0 &&
2234                     (nd->nd_flag & ND_NOMOREDATA)) {
2235                         /*
2236                          * If the Delegreturn failed, try again without
2237                          * it. The server will Recall, as required.
2238                          */
2239                         mbuf_freem(nd->nd_mrep);
2240                         goto tryagain;
2241                 }
2242                 for (i = 0; i < (ret * 2); i++) {
2243                         if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) ==
2244                             ND_NFSV4) {
2245                             NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2246                             if (*(tl + 1))
2247                                 nd->nd_flag |= ND_NOMOREDATA;
2248                         }
2249                 }
2250                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2251         }
2252         if (nd->nd_repstat && !error)
2253                 error = nd->nd_repstat;
2254 nfsmout:
2255         mbuf_freem(nd->nd_mrep);
2256         return (error);
2257 }
2258
2259 /*
2260  * Do an nfs rename rpc.
2261  */
2262 APPLESTATIC int
2263 nfsrpc_rename(vnode_t fdvp, vnode_t fvp, char *fnameptr, int fnamelen,
2264     vnode_t tdvp, vnode_t tvp, char *tnameptr, int tnamelen, struct ucred *cred,
2265     NFSPROC_T *p, struct nfsvattr *fnap, struct nfsvattr *tnap,
2266     int *fattrflagp, int *tattrflagp, void *fstuff, void *tstuff)
2267 {
2268         u_int32_t *tl;
2269         struct nfsrv_descript nfsd, *nd = &nfsd;
2270         struct nfsmount *nmp;
2271         struct nfsnode *np;
2272         nfsattrbit_t attrbits;
2273         nfsv4stateid_t fdstateid, tdstateid;
2274         int error = 0, ret = 0, gottd = 0, gotfd = 0, i;
2275
2276         *fattrflagp = 0;
2277         *tattrflagp = 0;
2278         nmp = VFSTONFS(vnode_mount(fdvp));
2279         if (fnamelen > NFS_MAXNAMLEN || tnamelen > NFS_MAXNAMLEN)
2280                 return (ENAMETOOLONG);
2281 tryagain:
2282         if (NFSHASNFSV4(nmp) && ret == 0) {
2283                 ret = nfscl_renamedeleg(fvp, &fdstateid, &gotfd, tvp,
2284                     &tdstateid, &gottd, p);
2285                 if (gotfd && gottd) {
2286                         NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME2, fvp);
2287                 } else if (gotfd) {
2288                         NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME1, fvp);
2289                 } else if (gottd) {
2290                         NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME1, tvp);
2291                 }
2292                 if (gotfd) {
2293                         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2294                         if (NFSHASNFSV4N(nmp))
2295                                 *tl++ = 0;
2296                         else
2297                                 *tl++ = fdstateid.seqid;
2298                         *tl++ = fdstateid.other[0];
2299                         *tl++ = fdstateid.other[1];
2300                         *tl = fdstateid.other[2];
2301                         if (gottd) {
2302                                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2303                                 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2304                                 np = VTONFS(tvp);
2305                                 (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh,
2306                                     np->n_fhp->nfh_len, 0);
2307                                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2308                                 *tl = txdr_unsigned(NFSV4OP_DELEGRETURN);
2309                         }
2310                 }
2311                 if (gottd) {
2312                         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2313                         if (NFSHASNFSV4N(nmp))
2314                                 *tl++ = 0;
2315                         else
2316                                 *tl++ = tdstateid.seqid;
2317                         *tl++ = tdstateid.other[0];
2318                         *tl++ = tdstateid.other[1];
2319                         *tl = tdstateid.other[2];
2320                 }
2321                 if (ret > 0) {
2322                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2323                         *tl = txdr_unsigned(NFSV4OP_PUTFH);
2324                         np = VTONFS(fdvp);
2325                         (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh,
2326                             np->n_fhp->nfh_len, 0);
2327                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2328                         *tl = txdr_unsigned(NFSV4OP_SAVEFH);
2329                 }
2330         } else {
2331                 ret = 0;
2332         }
2333         if (ret == 0)
2334                 NFSCL_REQSTART(nd, NFSPROC_RENAME, fdvp);
2335         if (nd->nd_flag & ND_NFSV4) {
2336                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2337                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2338                 NFSWCCATTR_ATTRBIT(&attrbits);
2339                 (void) nfsrv_putattrbit(nd, &attrbits);
2340                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2341                 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2342                 (void) nfsm_fhtom(nd, VTONFS(tdvp)->n_fhp->nfh_fh,
2343                     VTONFS(tdvp)->n_fhp->nfh_len, 0);
2344                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2345                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2346                 (void) nfsrv_putattrbit(nd, &attrbits);
2347                 nd->nd_flag |= ND_V4WCCATTR;
2348                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2349                 *tl = txdr_unsigned(NFSV4OP_RENAME);
2350         }
2351         (void) nfsm_strtom(nd, fnameptr, fnamelen);
2352         if (!(nd->nd_flag & ND_NFSV4))
2353                 (void) nfsm_fhtom(nd, VTONFS(tdvp)->n_fhp->nfh_fh,
2354                         VTONFS(tdvp)->n_fhp->nfh_len, 0);
2355         (void) nfsm_strtom(nd, tnameptr, tnamelen);
2356         error = nfscl_request(nd, fdvp, p, cred, fstuff);
2357         if (error)
2358                 return (error);
2359         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
2360                 /* For NFSv4, parse out any Delereturn replies. */
2361                 if (ret > 0 && nd->nd_repstat != 0 &&
2362                     (nd->nd_flag & ND_NOMOREDATA)) {
2363                         /*
2364                          * If the Delegreturn failed, try again without
2365                          * it. The server will Recall, as required.
2366                          */
2367                         mbuf_freem(nd->nd_mrep);
2368                         goto tryagain;
2369                 }
2370                 for (i = 0; i < (ret * 2); i++) {
2371                         if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) ==
2372                             ND_NFSV4) {
2373                             NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2374                             if (*(tl + 1)) {
2375                                 if (i == 0 && ret > 1) {
2376                                     /*
2377                                      * If the Delegreturn failed, try again
2378                                      * without it. The server will Recall, as
2379                                      * required.
2380                                      * If ret > 1, the first iteration of this
2381                                      * loop is the second DelegReturn result.
2382                                      */
2383                                     mbuf_freem(nd->nd_mrep);
2384                                     goto tryagain;
2385                                 } else {
2386                                     nd->nd_flag |= ND_NOMOREDATA;
2387                                 }
2388                             }
2389                         }
2390                 }
2391                 /* Now, the first wcc attribute reply. */
2392                 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4) {
2393                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2394                         if (*(tl + 1))
2395                                 nd->nd_flag |= ND_NOMOREDATA;
2396                 }
2397                 error = nfscl_wcc_data(nd, fdvp, fnap, fattrflagp, NULL,
2398                     fstuff);
2399                 /* and the second wcc attribute reply. */
2400                 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4 &&
2401                     !error) {
2402                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2403                         if (*(tl + 1))
2404                                 nd->nd_flag |= ND_NOMOREDATA;
2405                 }
2406                 if (!error)
2407                         error = nfscl_wcc_data(nd, tdvp, tnap, tattrflagp,
2408                             NULL, tstuff);
2409         }
2410         if (nd->nd_repstat && !error)
2411                 error = nd->nd_repstat;
2412 nfsmout:
2413         mbuf_freem(nd->nd_mrep);
2414         return (error);
2415 }
2416
2417 /*
2418  * nfs hard link create rpc
2419  */
2420 APPLESTATIC int
2421 nfsrpc_link(vnode_t dvp, vnode_t vp, char *name, int namelen,
2422     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
2423     struct nfsvattr *nap, int *attrflagp, int *dattrflagp, void *dstuff)
2424 {
2425         u_int32_t *tl;
2426         struct nfsrv_descript nfsd, *nd = &nfsd;
2427         nfsattrbit_t attrbits;
2428         int error = 0;
2429
2430         *attrflagp = 0;
2431         *dattrflagp = 0;
2432         if (namelen > NFS_MAXNAMLEN)
2433                 return (ENAMETOOLONG);
2434         NFSCL_REQSTART(nd, NFSPROC_LINK, vp);
2435         if (nd->nd_flag & ND_NFSV4) {
2436                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2437                 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2438         }
2439         (void) nfsm_fhtom(nd, VTONFS(dvp)->n_fhp->nfh_fh,
2440                 VTONFS(dvp)->n_fhp->nfh_len, 0);
2441         if (nd->nd_flag & ND_NFSV4) {
2442                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2443                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2444                 NFSWCCATTR_ATTRBIT(&attrbits);
2445                 (void) nfsrv_putattrbit(nd, &attrbits);
2446                 nd->nd_flag |= ND_V4WCCATTR;
2447                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2448                 *tl = txdr_unsigned(NFSV4OP_LINK);
2449         }
2450         (void) nfsm_strtom(nd, name, namelen);
2451         error = nfscl_request(nd, vp, p, cred, dstuff);
2452         if (error)
2453                 return (error);
2454         if (nd->nd_flag & ND_NFSV3) {
2455                 error = nfscl_postop_attr(nd, nap, attrflagp, dstuff);
2456                 if (!error)
2457                         error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp,
2458                             NULL, dstuff);
2459         } else if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4) {
2460                 /*
2461                  * First, parse out the PutFH and Getattr result.
2462                  */
2463                 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2464                 if (!(*(tl + 1)))
2465                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2466                 if (*(tl + 1))
2467                         nd->nd_flag |= ND_NOMOREDATA;
2468                 /*
2469                  * Get the pre-op attributes.
2470                  */
2471                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2472         }
2473         if (nd->nd_repstat && !error)
2474                 error = nd->nd_repstat;
2475 nfsmout:
2476         mbuf_freem(nd->nd_mrep);
2477         return (error);
2478 }
2479
2480 /*
2481  * nfs symbolic link create rpc
2482  */
2483 APPLESTATIC int
2484 nfsrpc_symlink(vnode_t dvp, char *name, int namelen, char *target,
2485     struct vattr *vap, struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
2486     struct nfsvattr *nnap, struct nfsfh **nfhpp, int *attrflagp,
2487     int *dattrflagp, void *dstuff)
2488 {
2489         u_int32_t *tl;
2490         struct nfsrv_descript nfsd, *nd = &nfsd;
2491         struct nfsmount *nmp;
2492         int slen, error = 0;
2493
2494         *nfhpp = NULL;
2495         *attrflagp = 0;
2496         *dattrflagp = 0;
2497         nmp = VFSTONFS(vnode_mount(dvp));
2498         slen = strlen(target);
2499         if (slen > NFS_MAXPATHLEN || namelen > NFS_MAXNAMLEN)
2500                 return (ENAMETOOLONG);
2501         NFSCL_REQSTART(nd, NFSPROC_SYMLINK, dvp);
2502         if (nd->nd_flag & ND_NFSV4) {
2503                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2504                 *tl = txdr_unsigned(NFLNK);
2505                 (void) nfsm_strtom(nd, target, slen);
2506         }
2507         (void) nfsm_strtom(nd, name, namelen);
2508         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
2509                 nfscl_fillsattr(nd, vap, dvp, 0, 0);
2510         if (!(nd->nd_flag & ND_NFSV4))
2511                 (void) nfsm_strtom(nd, target, slen);
2512         if (nd->nd_flag & ND_NFSV2)
2513                 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZENEG1, 0);
2514         error = nfscl_request(nd, dvp, p, cred, dstuff);
2515         if (error)
2516                 return (error);
2517         if (nd->nd_flag & ND_NFSV4)
2518                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2519         if ((nd->nd_flag & ND_NFSV3) && !error) {
2520                 if (!nd->nd_repstat)
2521                         error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
2522                 if (!error)
2523                         error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp,
2524                             NULL, dstuff);
2525         }
2526         if (nd->nd_repstat && !error)
2527                 error = nd->nd_repstat;
2528         mbuf_freem(nd->nd_mrep);
2529         /*
2530          * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
2531          */
2532         if (error == EEXIST)
2533                 error = 0;
2534         return (error);
2535 }
2536
2537 /*
2538  * nfs make dir rpc
2539  */
2540 APPLESTATIC int
2541 nfsrpc_mkdir(vnode_t dvp, char *name, int namelen, struct vattr *vap,
2542     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
2543     struct nfsvattr *nnap, struct nfsfh **nfhpp, int *attrflagp,
2544     int *dattrflagp, void *dstuff)
2545 {
2546         u_int32_t *tl;
2547         struct nfsrv_descript nfsd, *nd = &nfsd;
2548         nfsattrbit_t attrbits;
2549         int error = 0;
2550         struct nfsfh *fhp;
2551
2552         *nfhpp = NULL;
2553         *attrflagp = 0;
2554         *dattrflagp = 0;
2555         fhp = VTONFS(dvp)->n_fhp;
2556         if (namelen > NFS_MAXNAMLEN)
2557                 return (ENAMETOOLONG);
2558         NFSCL_REQSTART(nd, NFSPROC_MKDIR, dvp);
2559         if (nd->nd_flag & ND_NFSV4) {
2560                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2561                 *tl = txdr_unsigned(NFDIR);
2562         }
2563         (void) nfsm_strtom(nd, name, namelen);
2564         nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZENEG1, 0);
2565         if (nd->nd_flag & ND_NFSV4) {
2566                 NFSGETATTR_ATTRBIT(&attrbits);
2567                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2568                 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
2569                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2570                 (void) nfsrv_putattrbit(nd, &attrbits);
2571                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2572                 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2573                 (void) nfsm_fhtom(nd, fhp->nfh_fh, fhp->nfh_len, 0);
2574                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2575                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2576                 (void) nfsrv_putattrbit(nd, &attrbits);
2577         }
2578         error = nfscl_request(nd, dvp, p, cred, dstuff);
2579         if (error)
2580                 return (error);
2581         if (nd->nd_flag & ND_NFSV4)
2582                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2583         if (!nd->nd_repstat && !error) {
2584                 if (nd->nd_flag & ND_NFSV4) {
2585                         NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
2586                         error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
2587                 }
2588                 if (!error)
2589                         error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
2590                 if (error == 0 && (nd->nd_flag & ND_NFSV4) != 0) {
2591                         /* Get rid of the PutFH and Getattr status values. */
2592                         NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
2593                         /* Load the directory attributes. */
2594                         error = nfsm_loadattr(nd, dnap);
2595                         if (error == 0)
2596                                 *dattrflagp = 1;
2597                 }
2598         }
2599         if ((nd->nd_flag & ND_NFSV3) && !error)
2600                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2601         if (nd->nd_repstat && !error)
2602                 error = nd->nd_repstat;
2603 nfsmout:
2604         mbuf_freem(nd->nd_mrep);
2605         /*
2606          * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry.
2607          */
2608         if (error == EEXIST)
2609                 error = 0;
2610         return (error);
2611 }
2612
2613 /*
2614  * nfs remove directory call
2615  */
2616 APPLESTATIC int
2617 nfsrpc_rmdir(vnode_t dvp, char *name, int namelen, struct ucred *cred,
2618     NFSPROC_T *p, struct nfsvattr *dnap, int *dattrflagp, void *dstuff)
2619 {
2620         struct nfsrv_descript nfsd, *nd = &nfsd;
2621         int error = 0;
2622
2623         *dattrflagp = 0;
2624         if (namelen > NFS_MAXNAMLEN)
2625                 return (ENAMETOOLONG);
2626         NFSCL_REQSTART(nd, NFSPROC_RMDIR, dvp);
2627         (void) nfsm_strtom(nd, name, namelen);
2628         error = nfscl_request(nd, dvp, p, cred, dstuff);
2629         if (error)
2630                 return (error);
2631         if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
2632                 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2633         if (nd->nd_repstat && !error)
2634                 error = nd->nd_repstat;
2635         mbuf_freem(nd->nd_mrep);
2636         /*
2637          * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
2638          */
2639         if (error == ENOENT)
2640                 error = 0;
2641         return (error);
2642 }
2643
2644 /*
2645  * Readdir rpc.
2646  * Always returns with either uio_resid unchanged, if you are at the
2647  * end of the directory, or uio_resid == 0, with all DIRBLKSIZ chunks
2648  * filled in.
2649  * I felt this would allow caching of directory blocks more easily
2650  * than returning a pertially filled block.
2651  * Directory offset cookies:
2652  * Oh my, what to do with them...
2653  * I can think of three ways to deal with them:
2654  * 1 - have the layer above these RPCs maintain a map between logical
2655  *     directory byte offsets and the NFS directory offset cookies
2656  * 2 - pass the opaque directory offset cookies up into userland
2657  *     and let the libc functions deal with them, via the system call
2658  * 3 - return them to userland in the "struct dirent", so future versions
2659  *     of libc can use them and do whatever is necessary to amke things work
2660  *     above these rpc calls, in the meantime
2661  * For now, I do #3 by "hiding" the directory offset cookies after the
2662  * d_name field in struct dirent. This is space inside d_reclen that
2663  * will be ignored by anything that doesn't know about them.
2664  * The directory offset cookies are filled in as the last 8 bytes of
2665  * each directory entry, after d_name. Someday, the userland libc
2666  * functions may be able to use these. In the meantime, it satisfies
2667  * OpenBSD's requirements for cookies being returned.
2668  * If expects the directory offset cookie for the read to be in uio_offset
2669  * and returns the one for the next entry after this directory block in
2670  * there, as well.
2671  */
2672 APPLESTATIC int
2673 nfsrpc_readdir(vnode_t vp, struct uio *uiop, nfsuint64 *cookiep,
2674     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
2675     int *eofp, void *stuff)
2676 {
2677         int len, left;
2678         struct dirent *dp = NULL;
2679         u_int32_t *tl;
2680         nfsquad_t cookie, ncookie;
2681         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
2682         struct nfsnode *dnp = VTONFS(vp);
2683         struct nfsvattr nfsva;
2684         struct nfsrv_descript nfsd, *nd = &nfsd;
2685         int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
2686         int reqsize, tryformoredirs = 1, readsize, eof = 0, gotmnton = 0;
2687         long dotfileid, dotdotfileid = 0;
2688         u_int32_t fakefileno = 0xffffffff, rderr;
2689         char *cp;
2690         nfsattrbit_t attrbits, dattrbits;
2691         u_int32_t *tl2 = NULL;
2692         size_t tresid;
2693
2694         KASSERT(uiop->uio_iovcnt == 1 &&
2695             (uio_uio_resid(uiop) & (DIRBLKSIZ - 1)) == 0,
2696             ("nfs readdirrpc bad uio"));
2697
2698         /*
2699          * There is no point in reading a lot more than uio_resid, however
2700          * adding one additional DIRBLKSIZ makes sense. Since uio_resid
2701          * and nm_readdirsize are both exact multiples of DIRBLKSIZ, this
2702          * will never make readsize > nm_readdirsize.
2703          */
2704         readsize = nmp->nm_readdirsize;
2705         if (readsize > uio_uio_resid(uiop))
2706                 readsize = uio_uio_resid(uiop) + DIRBLKSIZ;
2707
2708         *attrflagp = 0;
2709         if (eofp)
2710                 *eofp = 0;
2711         tresid = uio_uio_resid(uiop);
2712         cookie.lval[0] = cookiep->nfsuquad[0];
2713         cookie.lval[1] = cookiep->nfsuquad[1];
2714         nd->nd_mrep = NULL;
2715
2716         /*
2717          * For NFSv4, first create the "." and ".." entries.
2718          */
2719         if (NFSHASNFSV4(nmp)) {
2720                 reqsize = 6 * NFSX_UNSIGNED;
2721                 NFSGETATTR_ATTRBIT(&dattrbits);
2722                 NFSZERO_ATTRBIT(&attrbits);
2723                 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FILEID);
2724                 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TYPE);
2725                 if (NFSISSET_ATTRBIT(&dnp->n_vattr.na_suppattr,
2726                     NFSATTRBIT_MOUNTEDONFILEID)) {
2727                         NFSSETBIT_ATTRBIT(&attrbits,
2728                             NFSATTRBIT_MOUNTEDONFILEID);
2729                         gotmnton = 1;
2730                 } else {
2731                         /*
2732                          * Must fake it. Use the fileno, except when the
2733                          * fsid is != to that of the directory. For that
2734                          * case, generate a fake fileno that is not the same.
2735                          */
2736                         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FSID);
2737                         gotmnton = 0;
2738                 }
2739
2740                 /*
2741                  * Joy, oh joy. For V4 we get to hand craft '.' and '..'.
2742                  */
2743                 if (uiop->uio_offset == 0) {
2744                         NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, vp);
2745                         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2746                         *tl++ = txdr_unsigned(NFSV4OP_GETFH);
2747                         *tl = txdr_unsigned(NFSV4OP_GETATTR);
2748                         (void) nfsrv_putattrbit(nd, &attrbits);
2749                         error = nfscl_request(nd, vp, p, cred, stuff);
2750                         if (error)
2751                             return (error);
2752                         dotfileid = 0;  /* Fake out the compiler. */
2753                         if ((nd->nd_flag & ND_NOMOREDATA) == 0) {
2754                             error = nfsm_loadattr(nd, &nfsva);
2755                             if (error != 0)
2756                                 goto nfsmout;
2757                             dotfileid = nfsva.na_fileid;
2758                         }
2759                         if (nd->nd_repstat == 0) {
2760                             NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
2761                             len = fxdr_unsigned(int, *(tl + 4));
2762                             if (len > 0 && len <= NFSX_V4FHMAX)
2763                                 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
2764                             else
2765                                 error = EPERM;
2766                             if (!error) {
2767                                 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
2768                                 nfsva.na_mntonfileno = 0xffffffff;
2769                                 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
2770                                     NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
2771                                     NULL, NULL, NULL, p, cred);
2772                                 if (error) {
2773                                     dotdotfileid = dotfileid;
2774                                 } else if (gotmnton) {
2775                                     if (nfsva.na_mntonfileno != 0xffffffff)
2776                                         dotdotfileid = nfsva.na_mntonfileno;
2777                                     else
2778                                         dotdotfileid = nfsva.na_fileid;
2779                                 } else if (nfsva.na_filesid[0] ==
2780                                     dnp->n_vattr.na_filesid[0] &&
2781                                     nfsva.na_filesid[1] ==
2782                                     dnp->n_vattr.na_filesid[1]) {
2783                                     dotdotfileid = nfsva.na_fileid;
2784                                 } else {
2785                                     do {
2786                                         fakefileno--;
2787                                     } while (fakefileno ==
2788                                         nfsva.na_fileid);
2789                                     dotdotfileid = fakefileno;
2790                                 }
2791                             }
2792                         } else if (nd->nd_repstat == NFSERR_NOENT) {
2793                             /*
2794                              * Lookupp returns NFSERR_NOENT when we are
2795                              * at the root, so just use the current dir.
2796                              */
2797                             nd->nd_repstat = 0;
2798                             dotdotfileid = dotfileid;
2799                         } else {
2800                             error = nd->nd_repstat;
2801                         }
2802                         mbuf_freem(nd->nd_mrep);
2803                         if (error)
2804                             return (error);
2805                         nd->nd_mrep = NULL;
2806                         dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
2807                         dp->d_type = DT_DIR;
2808                         dp->d_fileno = dotfileid;
2809                         dp->d_namlen = 1;
2810                         dp->d_name[0] = '.';
2811                         dp->d_name[1] = '\0';
2812                         dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
2813                         /*
2814                          * Just make these offset cookie 0.
2815                          */
2816                         tl = (u_int32_t *)&dp->d_name[4];
2817                         *tl++ = 0;
2818                         *tl = 0;
2819                         blksiz += dp->d_reclen;
2820                         uio_uio_resid_add(uiop, -(dp->d_reclen));
2821                         uiop->uio_offset += dp->d_reclen;
2822                         uio_iov_base_add(uiop, dp->d_reclen);
2823                         uio_iov_len_add(uiop, -(dp->d_reclen));
2824                         dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
2825                         dp->d_type = DT_DIR;
2826                         dp->d_fileno = dotdotfileid;
2827                         dp->d_namlen = 2;
2828                         dp->d_name[0] = '.';
2829                         dp->d_name[1] = '.';
2830                         dp->d_name[2] = '\0';
2831                         dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
2832                         /*
2833                          * Just make these offset cookie 0.
2834                          */
2835                         tl = (u_int32_t *)&dp->d_name[4];
2836                         *tl++ = 0;
2837                         *tl = 0;
2838                         blksiz += dp->d_reclen;
2839                         uio_uio_resid_add(uiop, -(dp->d_reclen));
2840                         uiop->uio_offset += dp->d_reclen;
2841                         uio_iov_base_add(uiop, dp->d_reclen);
2842                         uio_iov_len_add(uiop, -(dp->d_reclen));
2843                 }
2844                 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_RDATTRERROR);
2845         } else {
2846                 reqsize = 5 * NFSX_UNSIGNED;
2847         }
2848
2849
2850         /*
2851          * Loop around doing readdir rpc's of size readsize.
2852          * The stopping criteria is EOF or buffer full.
2853          */
2854         while (more_dirs && bigenough) {
2855                 *attrflagp = 0;
2856                 NFSCL_REQSTART(nd, NFSPROC_READDIR, vp);
2857                 if (nd->nd_flag & ND_NFSV2) {
2858                         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2859                         *tl++ = cookie.lval[1];
2860                         *tl = txdr_unsigned(readsize);
2861                 } else {
2862                         NFSM_BUILD(tl, u_int32_t *, reqsize);
2863                         *tl++ = cookie.lval[0];
2864                         *tl++ = cookie.lval[1];
2865                         if (cookie.qval == 0) {
2866                                 *tl++ = 0;
2867                                 *tl++ = 0;
2868                         } else {
2869                                 NFSLOCKNODE(dnp);
2870                                 *tl++ = dnp->n_cookieverf.nfsuquad[0];
2871                                 *tl++ = dnp->n_cookieverf.nfsuquad[1];
2872                                 NFSUNLOCKNODE(dnp);
2873                         }
2874                         if (nd->nd_flag & ND_NFSV4) {
2875                                 *tl++ = txdr_unsigned(readsize);
2876                                 *tl = txdr_unsigned(readsize);
2877                                 (void) nfsrv_putattrbit(nd, &attrbits);
2878                                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2879                                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2880                                 (void) nfsrv_putattrbit(nd, &dattrbits);
2881                         } else {
2882                                 *tl = txdr_unsigned(readsize);
2883                         }
2884                 }
2885                 error = nfscl_request(nd, vp, p, cred, stuff);
2886                 if (error)
2887                         return (error);
2888                 if (!(nd->nd_flag & ND_NFSV2)) {
2889                         if (nd->nd_flag & ND_NFSV3)
2890                                 error = nfscl_postop_attr(nd, nap, attrflagp,
2891                                     stuff);
2892                         if (!nd->nd_repstat && !error) {
2893                                 NFSM_DISSECT(tl, u_int32_t *, NFSX_HYPER);
2894                                 NFSLOCKNODE(dnp);
2895                                 dnp->n_cookieverf.nfsuquad[0] = *tl++;
2896                                 dnp->n_cookieverf.nfsuquad[1] = *tl;
2897                                 NFSUNLOCKNODE(dnp);
2898                         }
2899                 }
2900                 if (nd->nd_repstat || error) {
2901                         if (!error)
2902                                 error = nd->nd_repstat;
2903                         goto nfsmout;
2904                 }
2905                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2906                 more_dirs = fxdr_unsigned(int, *tl);
2907                 if (!more_dirs)
2908                         tryformoredirs = 0;
2909
2910                 /* loop thru the dir entries, doctoring them to 4bsd form */
2911                 while (more_dirs && bigenough) {
2912                         if (nd->nd_flag & ND_NFSV4) {
2913                                 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
2914                                 ncookie.lval[0] = *tl++;
2915                                 ncookie.lval[1] = *tl++;
2916                                 len = fxdr_unsigned(int, *tl);
2917                         } else if (nd->nd_flag & ND_NFSV3) {
2918                                 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
2919                                 nfsva.na_fileid = fxdr_hyper(tl);
2920                                 tl += 2;
2921                                 len = fxdr_unsigned(int, *tl);
2922                         } else {
2923                                 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
2924                                 nfsva.na_fileid =
2925                                     fxdr_unsigned(long, *tl++);
2926                                 len = fxdr_unsigned(int, *tl);
2927                         }
2928                         if (len <= 0 || len > NFS_MAXNAMLEN) {
2929                                 error = EBADRPC;
2930                                 goto nfsmout;
2931                         }
2932                         tlen = NFSM_RNDUP(len);
2933                         if (tlen == len)
2934                                 tlen += 4;  /* To ensure null termination */
2935                         left = DIRBLKSIZ - blksiz;
2936                         if ((int)(tlen + DIRHDSIZ + NFSX_HYPER) > left) {
2937                                 dp->d_reclen += left;
2938                                 uio_iov_base_add(uiop, left);
2939                                 uio_iov_len_add(uiop, -(left));
2940                                 uio_uio_resid_add(uiop, -(left));
2941                                 uiop->uio_offset += left;
2942                                 blksiz = 0;
2943                         }
2944                         if ((int)(tlen + DIRHDSIZ + NFSX_HYPER) > uio_uio_resid(uiop))
2945                                 bigenough = 0;
2946                         if (bigenough) {
2947                                 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
2948                                 dp->d_namlen = len;
2949                                 dp->d_reclen = tlen + DIRHDSIZ + NFSX_HYPER;
2950                                 dp->d_type = DT_UNKNOWN;
2951                                 blksiz += dp->d_reclen;
2952                                 if (blksiz == DIRBLKSIZ)
2953                                         blksiz = 0;
2954                                 uio_uio_resid_add(uiop, -(DIRHDSIZ));
2955                                 uiop->uio_offset += DIRHDSIZ;
2956                                 uio_iov_base_add(uiop, DIRHDSIZ);
2957                                 uio_iov_len_add(uiop, -(DIRHDSIZ));
2958                                 error = nfsm_mbufuio(nd, uiop, len);
2959                                 if (error)
2960                                         goto nfsmout;
2961                                 cp = CAST_DOWN(caddr_t, uio_iov_base(uiop));
2962                                 tlen -= len;
2963                                 *cp = '\0';     /* null terminate */
2964                                 cp += tlen;     /* points to cookie storage */
2965                                 tl2 = (u_int32_t *)cp;
2966                                 uio_iov_base_add(uiop, (tlen + NFSX_HYPER));
2967                                 uio_iov_len_add(uiop, -(tlen + NFSX_HYPER));
2968                                 uio_uio_resid_add(uiop, -(tlen + NFSX_HYPER));
2969                                 uiop->uio_offset += (tlen + NFSX_HYPER);
2970                         } else {
2971                                 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
2972                                 if (error)
2973                                         goto nfsmout;
2974                         }
2975                         if (nd->nd_flag & ND_NFSV4) {
2976                                 rderr = 0;
2977                                 nfsva.na_mntonfileno = 0xffffffff;
2978                                 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
2979                                     NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
2980                                     NULL, NULL, &rderr, p, cred);
2981                                 if (error)
2982                                         goto nfsmout;
2983                                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2984                         } else if (nd->nd_flag & ND_NFSV3) {
2985                                 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
2986                                 ncookie.lval[0] = *tl++;
2987                                 ncookie.lval[1] = *tl++;
2988                         } else {
2989                                 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
2990                                 ncookie.lval[0] = 0;
2991                                 ncookie.lval[1] = *tl++;
2992                         }
2993                         if (bigenough) {
2994                             if (nd->nd_flag & ND_NFSV4) {
2995                                 if (rderr) {
2996                                     dp->d_fileno = 0;
2997                                 } else {
2998                                     if (gotmnton) {
2999                                         if (nfsva.na_mntonfileno != 0xffffffff)
3000                                             dp->d_fileno = nfsva.na_mntonfileno;
3001                                         else
3002                                             dp->d_fileno = nfsva.na_fileid;
3003                                     } else if (nfsva.na_filesid[0] ==
3004                                         dnp->n_vattr.na_filesid[0] &&
3005                                         nfsva.na_filesid[1] ==
3006                                         dnp->n_vattr.na_filesid[1]) {
3007                                         dp->d_fileno = nfsva.na_fileid;
3008                                     } else {
3009                                         do {
3010                                             fakefileno--;
3011                                         } while (fakefileno ==
3012                                             nfsva.na_fileid);
3013                                         dp->d_fileno = fakefileno;
3014                                     }
3015                                     dp->d_type = vtonfs_dtype(nfsva.na_type);
3016                                 }
3017                             } else {
3018                                 dp->d_fileno = nfsva.na_fileid;
3019                             }
3020                             *tl2++ = cookiep->nfsuquad[0] = cookie.lval[0] =
3021                                 ncookie.lval[0];
3022                             *tl2 = cookiep->nfsuquad[1] = cookie.lval[1] =
3023                                 ncookie.lval[1];
3024                         }
3025                         more_dirs = fxdr_unsigned(int, *tl);
3026                 }
3027                 /*
3028                  * If at end of rpc data, get the eof boolean
3029                  */
3030                 if (!more_dirs) {
3031                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3032                         eof = fxdr_unsigned(int, *tl);
3033                         if (tryformoredirs)
3034                                 more_dirs = !eof;
3035                         if (nd->nd_flag & ND_NFSV4) {
3036                                 error = nfscl_postop_attr(nd, nap, attrflagp,
3037                                     stuff);
3038                                 if (error)
3039                                         goto nfsmout;
3040                         }
3041                 }
3042                 mbuf_freem(nd->nd_mrep);
3043                 nd->nd_mrep = NULL;
3044         }
3045         /*
3046          * Fill last record, iff any, out to a multiple of DIRBLKSIZ
3047          * by increasing d_reclen for the last record.
3048          */
3049         if (blksiz > 0) {
3050                 left = DIRBLKSIZ - blksiz;
3051                 dp->d_reclen += left;
3052                 uio_iov_base_add(uiop, left);
3053                 uio_iov_len_add(uiop, -(left));
3054                 uio_uio_resid_add(uiop, -(left));
3055                 uiop->uio_offset += left;
3056         }
3057
3058         /*
3059          * If returning no data, assume end of file.
3060          * If not bigenough, return not end of file, since you aren't
3061          *    returning all the data
3062          * Otherwise, return the eof flag from the server.
3063          */
3064         if (eofp) {
3065                 if (tresid == ((size_t)(uio_uio_resid(uiop))))
3066                         *eofp = 1;
3067                 else if (!bigenough)
3068                         *eofp = 0;
3069                 else
3070                         *eofp = eof;
3071         }
3072
3073         /*
3074          * Add extra empty records to any remaining DIRBLKSIZ chunks.
3075          */
3076         while (uio_uio_resid(uiop) > 0 && ((size_t)(uio_uio_resid(uiop))) != tresid) {
3077                 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
3078                 dp->d_type = DT_UNKNOWN;
3079                 dp->d_fileno = 0;
3080                 dp->d_namlen = 0;
3081                 dp->d_name[0] = '\0';
3082                 tl = (u_int32_t *)&dp->d_name[4];
3083                 *tl++ = cookie.lval[0];
3084                 *tl = cookie.lval[1];
3085                 dp->d_reclen = DIRBLKSIZ;
3086                 uio_iov_base_add(uiop, DIRBLKSIZ);
3087                 uio_iov_len_add(uiop, -(DIRBLKSIZ));
3088                 uio_uio_resid_add(uiop, -(DIRBLKSIZ));
3089                 uiop->uio_offset += DIRBLKSIZ;
3090         }
3091
3092 nfsmout:
3093         if (nd->nd_mrep != NULL)
3094                 mbuf_freem(nd->nd_mrep);
3095         return (error);
3096 }
3097
3098 #ifndef APPLE
3099 /*
3100  * NFS V3 readdir plus RPC. Used in place of nfsrpc_readdir().
3101  * (Also used for NFS V4 when mount flag set.)
3102  * (ditto above w.r.t. multiple of DIRBLKSIZ, etc.)
3103  */
3104 APPLESTATIC int
3105 nfsrpc_readdirplus(vnode_t vp, struct uio *uiop, nfsuint64 *cookiep,
3106     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
3107     int *eofp, void *stuff)
3108 {
3109         int len, left;
3110         struct dirent *dp = NULL;
3111         u_int32_t *tl;
3112         vnode_t newvp = NULLVP;
3113         struct nfsrv_descript nfsd, *nd = &nfsd;
3114         struct nameidata nami, *ndp = &nami;
3115         struct componentname *cnp = &ndp->ni_cnd;
3116         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3117         struct nfsnode *dnp = VTONFS(vp), *np;
3118         struct nfsvattr nfsva;
3119         struct nfsfh *nfhp;
3120         nfsquad_t cookie, ncookie;
3121         int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
3122         int attrflag, tryformoredirs = 1, eof = 0, gotmnton = 0;
3123         int isdotdot = 0, unlocknewvp = 0;
3124         long dotfileid, dotdotfileid = 0, fileno = 0;
3125         char *cp;
3126         nfsattrbit_t attrbits, dattrbits;
3127         size_t tresid;
3128         u_int32_t *tl2 = NULL, fakefileno = 0xffffffff, rderr;
3129         struct timespec dctime;
3130
3131         KASSERT(uiop->uio_iovcnt == 1 &&
3132             (uio_uio_resid(uiop) & (DIRBLKSIZ - 1)) == 0,
3133             ("nfs readdirplusrpc bad uio"));
3134         timespecclear(&dctime);
3135         *attrflagp = 0;
3136         if (eofp != NULL)
3137                 *eofp = 0;
3138         ndp->ni_dvp = vp;
3139         nd->nd_mrep = NULL;
3140         cookie.lval[0] = cookiep->nfsuquad[0];
3141         cookie.lval[1] = cookiep->nfsuquad[1];
3142         tresid = uio_uio_resid(uiop);
3143
3144         /*
3145          * For NFSv4, first create the "." and ".." entries.
3146          */
3147         if (NFSHASNFSV4(nmp)) {
3148                 NFSGETATTR_ATTRBIT(&dattrbits);
3149                 NFSZERO_ATTRBIT(&attrbits);
3150                 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FILEID);
3151                 if (NFSISSET_ATTRBIT(&dnp->n_vattr.na_suppattr,
3152                     NFSATTRBIT_MOUNTEDONFILEID)) {
3153                         NFSSETBIT_ATTRBIT(&attrbits,
3154                             NFSATTRBIT_MOUNTEDONFILEID);
3155                         gotmnton = 1;
3156                 } else {
3157                         /*
3158                          * Must fake it. Use the fileno, except when the
3159                          * fsid is != to that of the directory. For that
3160                          * case, generate a fake fileno that is not the same.
3161                          */
3162                         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FSID);
3163                         gotmnton = 0;
3164                 }
3165
3166                 /*
3167                  * Joy, oh joy. For V4 we get to hand craft '.' and '..'.
3168                  */
3169                 if (uiop->uio_offset == 0) {
3170                         NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, vp);
3171                         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
3172                         *tl++ = txdr_unsigned(NFSV4OP_GETFH);
3173                         *tl = txdr_unsigned(NFSV4OP_GETATTR);
3174                         (void) nfsrv_putattrbit(nd, &attrbits);
3175                         error = nfscl_request(nd, vp, p, cred, stuff);
3176                         if (error)
3177                             return (error);
3178                         dotfileid = 0;  /* Fake out the compiler. */
3179                         if ((nd->nd_flag & ND_NOMOREDATA) == 0) {
3180                             error = nfsm_loadattr(nd, &nfsva);
3181                             if (error != 0)
3182                                 goto nfsmout;
3183                             dctime = nfsva.na_ctime;
3184                             dotfileid = nfsva.na_fileid;
3185                         }
3186                         if (nd->nd_repstat == 0) {
3187                             NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
3188                             len = fxdr_unsigned(int, *(tl + 4));
3189                             if (len > 0 && len <= NFSX_V4FHMAX)
3190                                 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
3191                             else
3192                                 error = EPERM;
3193                             if (!error) {
3194                                 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
3195                                 nfsva.na_mntonfileno = 0xffffffff;
3196                                 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
3197                                     NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
3198                                     NULL, NULL, NULL, p, cred);
3199                                 if (error) {
3200                                     dotdotfileid = dotfileid;
3201                                 } else if (gotmnton) {
3202                                     if (nfsva.na_mntonfileno != 0xffffffff)
3203                                         dotdotfileid = nfsva.na_mntonfileno;
3204                                     else
3205                                         dotdotfileid = nfsva.na_fileid;
3206                                 } else if (nfsva.na_filesid[0] ==
3207                                     dnp->n_vattr.na_filesid[0] &&
3208                                     nfsva.na_filesid[1] ==
3209                                     dnp->n_vattr.na_filesid[1]) {
3210                                     dotdotfileid = nfsva.na_fileid;
3211                                 } else {
3212                                     do {
3213                                         fakefileno--;
3214                                     } while (fakefileno ==
3215                                         nfsva.na_fileid);
3216                                     dotdotfileid = fakefileno;
3217                                 }
3218                             }
3219                         } else if (nd->nd_repstat == NFSERR_NOENT) {
3220                             /*
3221                              * Lookupp returns NFSERR_NOENT when we are
3222                              * at the root, so just use the current dir.
3223                              */
3224                             nd->nd_repstat = 0;
3225                             dotdotfileid = dotfileid;
3226                         } else {
3227                             error = nd->nd_repstat;
3228                         }
3229                         mbuf_freem(nd->nd_mrep);
3230                         if (error)
3231                             return (error);
3232                         nd->nd_mrep = NULL;
3233                         dp = (struct dirent *)uio_iov_base(uiop);
3234                         dp->d_type = DT_DIR;
3235                         dp->d_fileno = dotfileid;
3236                         dp->d_namlen = 1;
3237                         dp->d_name[0] = '.';
3238                         dp->d_name[1] = '\0';
3239                         dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
3240                         /*
3241                          * Just make these offset cookie 0.
3242                          */
3243                         tl = (u_int32_t *)&dp->d_name[4];
3244                         *tl++ = 0;
3245                         *tl = 0;
3246                         blksiz += dp->d_reclen;
3247                         uio_uio_resid_add(uiop, -(dp->d_reclen));
3248                         uiop->uio_offset += dp->d_reclen;
3249                         uio_iov_base_add(uiop, dp->d_reclen);
3250                         uio_iov_len_add(uiop, -(dp->d_reclen));
3251                         dp = (struct dirent *)uio_iov_base(uiop);
3252                         dp->d_type = DT_DIR;
3253                         dp->d_fileno = dotdotfileid;
3254                         dp->d_namlen = 2;
3255                         dp->d_name[0] = '.';
3256                         dp->d_name[1] = '.';
3257                         dp->d_name[2] = '\0';
3258                         dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
3259                         /*
3260                          * Just make these offset cookie 0.
3261                          */
3262                         tl = (u_int32_t *)&dp->d_name[4];
3263                         *tl++ = 0;
3264                         *tl = 0;
3265                         blksiz += dp->d_reclen;
3266                         uio_uio_resid_add(uiop, -(dp->d_reclen));
3267                         uiop->uio_offset += dp->d_reclen;
3268                         uio_iov_base_add(uiop, dp->d_reclen);
3269                         uio_iov_len_add(uiop, -(dp->d_reclen));
3270                 }
3271                 NFSREADDIRPLUS_ATTRBIT(&attrbits);
3272                 if (gotmnton)
3273                         NFSSETBIT_ATTRBIT(&attrbits,
3274                             NFSATTRBIT_MOUNTEDONFILEID);
3275         }
3276
3277         /*
3278          * Loop around doing readdir rpc's of size nm_readdirsize.
3279          * The stopping criteria is EOF or buffer full.
3280          */
3281         while (more_dirs && bigenough) {
3282                 *attrflagp = 0;
3283                 NFSCL_REQSTART(nd, NFSPROC_READDIRPLUS, vp);
3284                 NFSM_BUILD(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
3285                 *tl++ = cookie.lval[0];
3286                 *tl++ = cookie.lval[1];
3287                 if (cookie.qval == 0) {
3288                         *tl++ = 0;
3289                         *tl++ = 0;
3290                 } else {
3291                         NFSLOCKNODE(dnp);
3292                         *tl++ = dnp->n_cookieverf.nfsuquad[0];
3293                         *tl++ = dnp->n_cookieverf.nfsuquad[1];
3294                         NFSUNLOCKNODE(dnp);
3295                 }
3296                 *tl++ = txdr_unsigned(nmp->nm_readdirsize);
3297                 *tl = txdr_unsigned(nmp->nm_readdirsize);
3298                 if (nd->nd_flag & ND_NFSV4) {
3299                         (void) nfsrv_putattrbit(nd, &attrbits);
3300                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3301                         *tl = txdr_unsigned(NFSV4OP_GETATTR);
3302                         (void) nfsrv_putattrbit(nd, &dattrbits);
3303                 }
3304                 error = nfscl_request(nd, vp, p, cred, stuff);
3305                 if (error)
3306                         return (error);
3307                 if (nd->nd_flag & ND_NFSV3)
3308                         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
3309                 if (nd->nd_repstat || error) {
3310                         if (!error)
3311                                 error = nd->nd_repstat;
3312                         goto nfsmout;
3313                 }
3314                 if ((nd->nd_flag & ND_NFSV3) != 0 && *attrflagp != 0)
3315                         dctime = nap->na_ctime;
3316                 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3317                 NFSLOCKNODE(dnp);
3318                 dnp->n_cookieverf.nfsuquad[0] = *tl++;
3319                 dnp->n_cookieverf.nfsuquad[1] = *tl++;
3320                 NFSUNLOCKNODE(dnp);
3321                 more_dirs = fxdr_unsigned(int, *tl);
3322                 if (!more_dirs)
3323                         tryformoredirs = 0;
3324
3325                 /* loop thru the dir entries, doctoring them to 4bsd form */
3326                 while (more_dirs && bigenough) {
3327                         NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3328                         if (nd->nd_flag & ND_NFSV4) {
3329                                 ncookie.lval[0] = *tl++;
3330                                 ncookie.lval[1] = *tl++;
3331                         } else {
3332                                 fileno = fxdr_unsigned(long, *++tl);
3333                                 tl++;
3334                         }
3335                         len = fxdr_unsigned(int, *tl);
3336                         if (len <= 0 || len > NFS_MAXNAMLEN) {
3337                                 error = EBADRPC;
3338                                 goto nfsmout;
3339                         }
3340                         tlen = NFSM_RNDUP(len);
3341                         if (tlen == len)
3342                                 tlen += 4;  /* To ensure null termination */
3343                         left = DIRBLKSIZ - blksiz;
3344                         if ((tlen + DIRHDSIZ + NFSX_HYPER) > left) {
3345                                 dp->d_reclen += left;
3346                                 uio_iov_base_add(uiop, left);
3347                                 uio_iov_len_add(uiop, -(left));
3348                                 uio_uio_resid_add(uiop, -(left));
3349                                 uiop->uio_offset += left;
3350                                 blksiz = 0;
3351                         }
3352                         if ((tlen + DIRHDSIZ + NFSX_HYPER) > uio_uio_resid(uiop))
3353                                 bigenough = 0;
3354                         if (bigenough) {
3355                                 dp = (struct dirent *)uio_iov_base(uiop);
3356                                 dp->d_namlen = len;
3357                                 dp->d_reclen = tlen + DIRHDSIZ + NFSX_HYPER;
3358                                 dp->d_type = DT_UNKNOWN;
3359                                 blksiz += dp->d_reclen;
3360                                 if (blksiz == DIRBLKSIZ)
3361                                         blksiz = 0;
3362                                 uio_uio_resid_add(uiop, -(DIRHDSIZ));
3363                                 uiop->uio_offset += DIRHDSIZ;
3364                                 uio_iov_base_add(uiop, DIRHDSIZ);
3365                                 uio_iov_len_add(uiop, -(DIRHDSIZ));
3366                                 cnp->cn_nameptr = uio_iov_base(uiop);
3367                                 cnp->cn_namelen = len;
3368                                 NFSCNHASHZERO(cnp);
3369                                 error = nfsm_mbufuio(nd, uiop, len);
3370                                 if (error)
3371                                         goto nfsmout;
3372                                 cp = uio_iov_base(uiop);
3373                                 tlen -= len;
3374                                 *cp = '\0';
3375                                 cp += tlen;     /* points to cookie storage */
3376                                 tl2 = (u_int32_t *)cp;
3377                                 if (len == 2 && cnp->cn_nameptr[0] == '.' &&
3378                                     cnp->cn_nameptr[1] == '.')
3379                                         isdotdot = 1;
3380                                 else
3381                                         isdotdot = 0;
3382                                 uio_iov_base_add(uiop, (tlen + NFSX_HYPER));
3383                                 uio_iov_len_add(uiop, -(tlen + NFSX_HYPER));
3384                                 uio_uio_resid_add(uiop, -(tlen + NFSX_HYPER));
3385                                 uiop->uio_offset += (tlen + NFSX_HYPER);
3386                         } else {
3387                                 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
3388                                 if (error)
3389                                         goto nfsmout;
3390                         }
3391                         nfhp = NULL;
3392                         if (nd->nd_flag & ND_NFSV3) {
3393                                 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
3394                                 ncookie.lval[0] = *tl++;
3395                                 ncookie.lval[1] = *tl++;
3396                                 attrflag = fxdr_unsigned(int, *tl);
3397                                 if (attrflag) {
3398                                   error = nfsm_loadattr(nd, &nfsva);
3399                                   if (error)
3400                                         goto nfsmout;
3401                                 }
3402                                 NFSM_DISSECT(tl,u_int32_t *,NFSX_UNSIGNED);
3403                                 if (*tl) {
3404                                         error = nfsm_getfh(nd, &nfhp);
3405                                         if (error)
3406                                             goto nfsmout;
3407                                 }
3408                                 if (!attrflag && nfhp != NULL) {
3409                                         FREE((caddr_t)nfhp, M_NFSFH);
3410                                         nfhp = NULL;
3411                                 }
3412                         } else {
3413                                 rderr = 0;
3414                                 nfsva.na_mntonfileno = 0xffffffff;
3415                                 error = nfsv4_loadattr(nd, NULL, &nfsva, &nfhp,
3416                                     NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
3417                                     NULL, NULL, &rderr, p, cred);
3418                                 if (error)
3419                                         goto nfsmout;
3420                         }
3421
3422                         if (bigenough) {
3423                             if (nd->nd_flag & ND_NFSV4) {
3424                                 if (rderr) {
3425                                     dp->d_fileno = 0;
3426                                 } else if (gotmnton) {
3427                                     if (nfsva.na_mntonfileno != 0xffffffff)
3428                                         dp->d_fileno = nfsva.na_mntonfileno;
3429                                     else
3430                                         dp->d_fileno = nfsva.na_fileid;
3431                                 } else if (nfsva.na_filesid[0] ==
3432                                     dnp->n_vattr.na_filesid[0] &&
3433                                     nfsva.na_filesid[1] ==
3434                                     dnp->n_vattr.na_filesid[1]) {
3435                                     dp->d_fileno = nfsva.na_fileid;
3436                                 } else {
3437                                     do {
3438                                         fakefileno--;
3439                                     } while (fakefileno ==
3440                                         nfsva.na_fileid);
3441                                     dp->d_fileno = fakefileno;
3442                                 }
3443                             } else {
3444                                 dp->d_fileno = fileno;
3445                             }
3446                             *tl2++ = cookiep->nfsuquad[0] = cookie.lval[0] =
3447                                 ncookie.lval[0];
3448                             *tl2 = cookiep->nfsuquad[1] = cookie.lval[1] =
3449                                 ncookie.lval[1];
3450
3451                             if (nfhp != NULL) {
3452                                 if (NFSRV_CMPFH(nfhp->nfh_fh, nfhp->nfh_len,
3453                                     dnp->n_fhp->nfh_fh, dnp->n_fhp->nfh_len)) {
3454                                     VREF(vp);
3455                                     newvp = vp;
3456                                     unlocknewvp = 0;
3457                                     FREE((caddr_t)nfhp, M_NFSFH);
3458                                     np = dnp;
3459                                 } else if (isdotdot != 0) {
3460                                     /*
3461                                      * Skip doing a nfscl_nget() call for "..".
3462                                      * There's a race between acquiring the nfs
3463                                      * node here and lookups that look for the
3464                                      * directory being read (in the parent).
3465                                      * It would try to get a lock on ".." here,
3466                                      * owning the lock on the directory being
3467                                      * read. Lookup will hold the lock on ".."
3468                                      * and try to acquire the lock on the
3469                                      * directory being read.
3470                                      * If the directory is unlocked/relocked,
3471                                      * then there is a LOR with the buflock
3472                                      * vp is relocked.
3473                                      */
3474                                     free(nfhp, M_NFSFH);
3475                                 } else {
3476                                     error = nfscl_nget(vnode_mount(vp), vp,
3477                                       nfhp, cnp, p, &np, NULL, LK_EXCLUSIVE);
3478                                     if (!error) {
3479                                         newvp = NFSTOV(np);
3480                                         unlocknewvp = 1;
3481                                     }
3482                                 }
3483                                 nfhp = NULL;
3484                                 if (newvp != NULLVP) {
3485                                     error = nfscl_loadattrcache(&newvp,
3486                                         &nfsva, NULL, NULL, 0, 0);
3487                                     if (error) {
3488                                         if (unlocknewvp)
3489                                             vput(newvp);
3490                                         else
3491                                             vrele(newvp);
3492                                         goto nfsmout;
3493                                     }
3494                                     dp->d_type =
3495                                         vtonfs_dtype(np->n_vattr.na_type);
3496                                     ndp->ni_vp = newvp;
3497                                     NFSCNHASH(cnp, HASHINIT);
3498                                     if (cnp->cn_namelen <= NCHNAMLEN &&
3499                                         (newvp->v_type != VDIR ||
3500                                          dctime.tv_sec != 0)) {
3501                                         cache_enter_time(ndp->ni_dvp,
3502                                             ndp->ni_vp, cnp,
3503                                             &nfsva.na_ctime,
3504                                             newvp->v_type != VDIR ? NULL :
3505                                             &dctime);
3506                                     }
3507                                     if (unlocknewvp)
3508                                         vput(newvp);
3509                                     else
3510                                         vrele(newvp);
3511                                     newvp = NULLVP;
3512                                 }
3513                             }
3514                         } else if (nfhp != NULL) {
3515                             FREE((caddr_t)nfhp, M_NFSFH);
3516                         }
3517                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3518                         more_dirs = fxdr_unsigned(int, *tl);
3519                 }
3520                 /*
3521                  * If at end of rpc data, get the eof boolean
3522                  */
3523                 if (!more_dirs) {
3524                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3525                         eof = fxdr_unsigned(int, *tl);
3526                         if (tryformoredirs)
3527                                 more_dirs = !eof;
3528                         if (nd->nd_flag & ND_NFSV4) {
3529                                 error = nfscl_postop_attr(nd, nap, attrflagp,
3530                                     stuff);
3531                                 if (error)
3532                                         goto nfsmout;
3533                         }
3534                 }
3535                 mbuf_freem(nd->nd_mrep);
3536                 nd->nd_mrep = NULL;
3537         }
3538         /*
3539          * Fill last record, iff any, out to a multiple of DIRBLKSIZ
3540          * by increasing d_reclen for the last record.
3541          */
3542         if (blksiz > 0) {
3543                 left = DIRBLKSIZ - blksiz;
3544                 dp->d_reclen += left;
3545                 uio_iov_base_add(uiop, left);
3546                 uio_iov_len_add(uiop, -(left));
3547                 uio_uio_resid_add(uiop, -(left));
3548                 uiop->uio_offset += left;
3549         }
3550
3551         /*
3552          * If returning no data, assume end of file.
3553          * If not bigenough, return not end of file, since you aren't
3554          *    returning all the data
3555          * Otherwise, return the eof flag from the server.
3556          */
3557         if (eofp != NULL) {
3558                 if (tresid == uio_uio_resid(uiop))
3559                         *eofp = 1;
3560                 else if (!bigenough)
3561                         *eofp = 0;
3562                 else
3563                         *eofp = eof;
3564         }
3565
3566         /*
3567          * Add extra empty records to any remaining DIRBLKSIZ chunks.
3568          */
3569         while (uio_uio_resid(uiop) > 0 && uio_uio_resid(uiop) != tresid) {
3570                 dp = (struct dirent *)uio_iov_base(uiop);
3571                 dp->d_type = DT_UNKNOWN;
3572                 dp->d_fileno = 0;
3573                 dp->d_namlen = 0;
3574                 dp->d_name[0] = '\0';
3575                 tl = (u_int32_t *)&dp->d_name[4];
3576                 *tl++ = cookie.lval[0];
3577                 *tl = cookie.lval[1];
3578                 dp->d_reclen = DIRBLKSIZ;
3579                 uio_iov_base_add(uiop, DIRBLKSIZ);
3580                 uio_iov_len_add(uiop, -(DIRBLKSIZ));
3581                 uio_uio_resid_add(uiop, -(DIRBLKSIZ));
3582                 uiop->uio_offset += DIRBLKSIZ;
3583         }
3584
3585 nfsmout:
3586         if (nd->nd_mrep != NULL)
3587                 mbuf_freem(nd->nd_mrep);
3588         return (error);
3589 }
3590 #endif  /* !APPLE */
3591
3592 /*
3593  * Nfs commit rpc
3594  */
3595 APPLESTATIC int
3596 nfsrpc_commit(vnode_t vp, u_quad_t offset, int cnt, struct ucred *cred,
3597     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
3598 {
3599         u_int32_t *tl;
3600         struct nfsrv_descript nfsd, *nd = &nfsd;
3601         nfsattrbit_t attrbits;
3602         int error;
3603         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3604
3605         *attrflagp = 0;
3606         NFSCL_REQSTART(nd, NFSPROC_COMMIT, vp);
3607         NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3608         txdr_hyper(offset, tl);
3609         tl += 2;
3610         *tl = txdr_unsigned(cnt);
3611         if (nd->nd_flag & ND_NFSV4) {
3612                 /*
3613                  * And do a Getattr op.
3614                  */
3615                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3616                 *tl = txdr_unsigned(NFSV4OP_GETATTR);
3617                 NFSGETATTR_ATTRBIT(&attrbits);
3618                 (void) nfsrv_putattrbit(nd, &attrbits);
3619         }
3620         error = nfscl_request(nd, vp, p, cred, stuff);
3621         if (error)
3622                 return (error);
3623         error = nfscl_wcc_data(nd, vp, nap, attrflagp, NULL, stuff);
3624         if (!error && !nd->nd_repstat) {
3625                 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF);
3626                 NFSLOCKMNT(nmp);
3627                 if (NFSBCMP(nmp->nm_verf, tl, NFSX_VERF)) {
3628                         NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
3629                         nd->nd_repstat = NFSERR_STALEWRITEVERF;
3630                 }
3631                 NFSUNLOCKMNT(nmp);
3632                 if (nd->nd_flag & ND_NFSV4)
3633                         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
3634         }
3635 nfsmout:
3636         if (!error && nd->nd_repstat)
3637                 error = nd->nd_repstat;
3638         mbuf_freem(nd->nd_mrep);
3639         return (error);
3640 }
3641
3642 /*
3643  * NFS byte range lock rpc.
3644  * (Mostly just calls one of the three lower level RPC routines.)
3645  */
3646 APPLESTATIC int
3647 nfsrpc_advlock(vnode_t vp, off_t size, int op, struct flock *fl,
3648     int reclaim, struct ucred *cred, NFSPROC_T *p, void *id, int flags)
3649 {
3650         struct nfscllockowner *lp;
3651         struct nfsclclient *clp;
3652         struct nfsfh *nfhp;
3653         struct nfsrv_descript nfsd, *nd = &nfsd;
3654         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3655         u_int64_t off, len;
3656         off_t start, end;
3657         u_int32_t clidrev = 0;
3658         int error = 0, newone = 0, expireret = 0, retrycnt, donelocally;
3659         int callcnt, dorpc;
3660
3661         /*
3662          * Convert the flock structure into a start and end and do POSIX
3663          * bounds checking.
3664          */
3665         switch (fl->l_whence) {
3666         case SEEK_SET:
3667         case SEEK_CUR:
3668                 /*
3669                  * Caller is responsible for adding any necessary offset
3670                  * when SEEK_CUR is used.
3671                  */
3672                 start = fl->l_start;
3673                 off = fl->l_start;
3674                 break;
3675         case SEEK_END:
3676                 start = size + fl->l_start;
3677                 off = size + fl->l_start;
3678                 break;
3679         default:
3680                 return (EINVAL);
3681         };
3682         if (start < 0)
3683                 return (EINVAL);
3684         if (fl->l_len != 0) {
3685                 end = start + fl->l_len - 1;
3686                 if (end < start)
3687                         return (EINVAL);
3688         }
3689
3690         len = fl->l_len;
3691         if (len == 0)
3692                 len = NFS64BITSSET;
3693         retrycnt = 0;
3694         do {
3695             nd->nd_repstat = 0;
3696             if (op == F_GETLK) {
3697                 error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
3698                 if (error)
3699                         return (error);
3700                 error = nfscl_lockt(vp, clp, off, len, fl, p, id, flags);
3701                 if (!error) {
3702                         clidrev = clp->nfsc_clientidrev;
3703                         error = nfsrpc_lockt(nd, vp, clp, off, len, fl, cred,
3704                             p, id, flags);
3705                 } else if (error == -1) {
3706                         error = 0;
3707                 }
3708                 nfscl_clientrelease(clp);
3709             } else if (op == F_UNLCK && fl->l_type == F_UNLCK) {
3710                 /*
3711                  * We must loop around for all lockowner cases.
3712                  */
3713                 callcnt = 0;
3714                 error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
3715                 if (error)
3716                         return (error);
3717                 do {
3718                     error = nfscl_relbytelock(vp, off, len, cred, p, callcnt,
3719                         clp, id, flags, &lp, &dorpc);
3720                     /*
3721                      * If it returns a NULL lp, we're done.
3722                      */
3723                     if (lp == NULL) {
3724                         if (callcnt == 0)
3725                             nfscl_clientrelease(clp);
3726                         else
3727                             nfscl_releasealllocks(clp, vp, p, id, flags);
3728                         return (error);
3729                     }
3730                     if (nmp->nm_clp != NULL)
3731                         clidrev = nmp->nm_clp->nfsc_clientidrev;
3732                     else
3733                         clidrev = 0;
3734                     /*
3735                      * If the server doesn't support Posix lock semantics,
3736                      * only allow locks on the entire file, since it won't
3737                      * handle overlapping byte ranges.
3738                      * There might still be a problem when a lock
3739                      * upgrade/downgrade (read<->write) occurs, since the
3740                      * server "might" expect an unlock first?
3741                      */
3742                     if (dorpc && (lp->nfsl_open->nfso_posixlock ||
3743                         (off == 0 && len == NFS64BITSSET))) {
3744                         /*
3745                          * Since the lock records will go away, we must
3746                          * wait for grace and delay here.
3747                          */
3748                         do {
3749                             error = nfsrpc_locku(nd, nmp, lp, off, len,
3750                                 NFSV4LOCKT_READ, cred, p, 0);
3751                             if ((nd->nd_repstat == NFSERR_GRACE ||
3752                                  nd->nd_repstat == NFSERR_DELAY) &&
3753                                 error == 0)
3754                                 (void) nfs_catnap(PZERO, (int)nd->nd_repstat,
3755                                     "nfs_advlock");
3756                         } while ((nd->nd_repstat == NFSERR_GRACE ||
3757                             nd->nd_repstat == NFSERR_DELAY) && error == 0);
3758                     }
3759                     callcnt++;
3760                 } while (error == 0 && nd->nd_repstat == 0);
3761                 nfscl_releasealllocks(clp, vp, p, id, flags);
3762             } else if (op == F_SETLK) {
3763                 error = nfscl_getbytelock(vp, off, len, fl->l_type, cred, p,
3764                     NULL, 0, id, flags, NULL, NULL, &lp, &newone, &donelocally);
3765                 if (error || donelocally) {
3766                         return (error);
3767                 }
3768                 if (nmp->nm_clp != NULL)
3769                         clidrev = nmp->nm_clp->nfsc_clientidrev;
3770                 else
3771                         clidrev = 0;
3772                 nfhp = VTONFS(vp)->n_fhp;
3773                 if (!lp->nfsl_open->nfso_posixlock &&
3774                     (off != 0 || len != NFS64BITSSET)) {
3775                         error = EINVAL;
3776                 } else {
3777                         error = nfsrpc_lock(nd, nmp, vp, nfhp->nfh_fh,
3778                             nfhp->nfh_len, lp, newone, reclaim, off,
3779                             len, fl->l_type, cred, p, 0);
3780                 }
3781                 if (!error)
3782                         error = nd->nd_repstat;
3783                 nfscl_lockrelease(lp, error, newone);
3784             } else {
3785                 error = EINVAL;
3786             }
3787             if (!error)
3788                 error = nd->nd_repstat;
3789             if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
3790                 error == NFSERR_STALEDONTRECOVER ||
3791                 error == NFSERR_STALECLIENTID || error == NFSERR_DELAY ||
3792                 error == NFSERR_BADSESSION) {
3793                 (void) nfs_catnap(PZERO, error, "nfs_advlock");
3794             } else if ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID)
3795                 && clidrev != 0) {
3796                 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
3797                 retrycnt++;
3798             }
3799         } while (error == NFSERR_GRACE ||
3800             error == NFSERR_STALECLIENTID || error == NFSERR_DELAY ||
3801             error == NFSERR_STALEDONTRECOVER || error == NFSERR_STALESTATEID ||
3802             error == NFSERR_BADSESSION ||
3803             ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
3804              expireret == 0 && clidrev != 0 && retrycnt < 4));
3805         if (error && retrycnt >= 4)
3806                 error = EIO;
3807         return (error);
3808 }
3809
3810 /*
3811  * The lower level routine for the LockT case.
3812  */
3813 APPLESTATIC int
3814 nfsrpc_lockt(struct nfsrv_descript *nd, vnode_t vp,
3815     struct nfsclclient *clp, u_int64_t off, u_int64_t len, struct flock *fl,
3816     struct ucred *cred, NFSPROC_T *p, void *id, int flags)
3817 {
3818         u_int32_t *tl;
3819         int error, type, size;
3820         uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
3821         struct nfsnode *np;
3822         struct nfsmount *nmp;
3823
3824         nmp = VFSTONFS(vp->v_mount);
3825         NFSCL_REQSTART(nd, NFSPROC_LOCKT, vp);
3826         NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
3827         if (fl->l_type == F_RDLCK)
3828                 *tl++ = txdr_unsigned(NFSV4LOCKT_READ);
3829         else
3830                 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE);
3831         txdr_hyper(off, tl);
3832         tl += 2;
3833         txdr_hyper(len, tl);
3834         tl += 2;
3835         *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
3836         *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
3837         nfscl_filllockowner(id, own, flags);
3838         np = VTONFS(vp);
3839         NFSBCOPY(np->n_fhp->nfh_fh, &own[NFSV4CL_LOCKNAMELEN],
3840             np->n_fhp->nfh_len);
3841         (void)nfsm_strtom(nd, own, NFSV4CL_LOCKNAMELEN + np->n_fhp->nfh_len);
3842         error = nfscl_request(nd, vp, p, cred, NULL);
3843         if (error)
3844                 return (error);
3845         if (nd->nd_repstat == 0) {
3846                 fl->l_type = F_UNLCK;
3847         } else if (nd->nd_repstat == NFSERR_DENIED) {
3848                 nd->nd_repstat = 0;
3849                 fl->l_whence = SEEK_SET;
3850                 NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
3851                 fl->l_start = fxdr_hyper(tl);
3852                 tl += 2;
3853                 len = fxdr_hyper(tl);
3854                 tl += 2;
3855                 if (len == NFS64BITSSET)
3856                         fl->l_len = 0;
3857                 else
3858                         fl->l_len = len;
3859                 type = fxdr_unsigned(int, *tl++);
3860                 if (type == NFSV4LOCKT_WRITE)
3861                         fl->l_type = F_WRLCK;
3862                 else
3863                         fl->l_type = F_RDLCK;
3864                 /*
3865                  * XXX For now, I have no idea what to do with the
3866                  * conflicting lock_owner, so I'll just set the pid == 0
3867                  * and skip over the lock_owner.
3868                  */
3869                 fl->l_pid = (pid_t)0;
3870                 tl += 2;
3871                 size = fxdr_unsigned(int, *tl);
3872                 if (size < 0 || size > NFSV4_OPAQUELIMIT)
3873                         error = EBADRPC;
3874                 if (!error)
3875                         error = nfsm_advance(nd, NFSM_RNDUP(size), -1);
3876         } else if (nd->nd_repstat == NFSERR_STALECLIENTID ||
3877             nd->nd_repstat == NFSERR_BADSESSION)
3878                 nfscl_initiate_recovery(clp);
3879 nfsmout:
3880         mbuf_freem(nd->nd_mrep);
3881         return (error);
3882 }
3883
3884 /*
3885  * Lower level function that performs the LockU RPC.
3886  */
3887 static int
3888 nfsrpc_locku(struct nfsrv_descript *nd, struct nfsmount *nmp,
3889     struct nfscllockowner *lp, u_int64_t off, u_int64_t len,
3890     u_int32_t type, struct ucred *cred, NFSPROC_T *p, int syscred)
3891 {
3892         u_int32_t *tl;
3893         int error;
3894
3895         nfscl_reqstart(nd, NFSPROC_LOCKU, nmp, lp->nfsl_open->nfso_fh,
3896             lp->nfsl_open->nfso_fhlen, NULL, NULL);
3897         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 6 * NFSX_UNSIGNED);
3898         *tl++ = txdr_unsigned(type);
3899         *tl = txdr_unsigned(lp->nfsl_seqid);
3900         if (nfstest_outofseq &&
3901             (arc4random() % nfstest_outofseq) == 0)
3902                 *tl = txdr_unsigned(lp->nfsl_seqid + 1);
3903         tl++;
3904         if (NFSHASNFSV4N(nmp))
3905                 *tl++ = 0;
3906         else
3907                 *tl++ = lp->nfsl_stateid.seqid;
3908         *tl++ = lp->nfsl_stateid.other[0];
3909         *tl++ = lp->nfsl_stateid.other[1];
3910         *tl++ = lp->nfsl_stateid.other[2];
3911         txdr_hyper(off, tl);
3912         tl += 2;
3913         txdr_hyper(len, tl);
3914         if (syscred)
3915                 nd->nd_flag |= ND_USEGSSNAME;
3916         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
3917             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
3918         NFSCL_INCRSEQID(lp->nfsl_seqid, nd);
3919         if (error)
3920                 return (error);
3921         if (nd->nd_repstat == 0) {
3922                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
3923                 lp->nfsl_stateid.seqid = *tl++;
3924                 lp->nfsl_stateid.other[0] = *tl++;
3925                 lp->nfsl_stateid.other[1] = *tl++;
3926                 lp->nfsl_stateid.other[2] = *tl;
3927         } else if (nd->nd_repstat == NFSERR_STALESTATEID ||
3928             nd->nd_repstat == NFSERR_BADSESSION)
3929                 nfscl_initiate_recovery(lp->nfsl_open->nfso_own->nfsow_clp);
3930 nfsmout:
3931         mbuf_freem(nd->nd_mrep);
3932         return (error);
3933 }
3934
3935 /*
3936  * The actual Lock RPC.
3937  */
3938 APPLESTATIC int
3939 nfsrpc_lock(struct nfsrv_descript *nd, struct nfsmount *nmp, vnode_t vp,
3940     u_int8_t *nfhp, int fhlen, struct nfscllockowner *lp, int newone,
3941     int reclaim, u_int64_t off, u_int64_t len, short type, struct ucred *cred,
3942     NFSPROC_T *p, int syscred)
3943 {
3944         u_int32_t *tl;
3945         int error, size;
3946         uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
3947
3948         nfscl_reqstart(nd, NFSPROC_LOCK, nmp, nfhp, fhlen, NULL, NULL);
3949         NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
3950         if (type == F_RDLCK)
3951                 *tl++ = txdr_unsigned(NFSV4LOCKT_READ);
3952         else
3953                 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE);
3954         *tl++ = txdr_unsigned(reclaim);
3955         txdr_hyper(off, tl);
3956         tl += 2;
3957         txdr_hyper(len, tl);
3958         tl += 2;
3959         if (newone) {
3960             *tl = newnfs_true;
3961             NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID +
3962                 2 * NFSX_UNSIGNED + NFSX_HYPER);
3963             *tl++ = txdr_unsigned(lp->nfsl_open->nfso_own->nfsow_seqid);
3964             if (NFSHASNFSV4N(nmp))
3965                 *tl++ = 0;
3966             else
3967                 *tl++ = lp->nfsl_open->nfso_stateid.seqid;
3968             *tl++ = lp->nfsl_open->nfso_stateid.other[0];
3969             *tl++ = lp->nfsl_open->nfso_stateid.other[1];
3970             *tl++ = lp->nfsl_open->nfso_stateid.other[2];
3971             *tl++ = txdr_unsigned(lp->nfsl_seqid);
3972             *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
3973             *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
3974             NFSBCOPY(lp->nfsl_owner, own, NFSV4CL_LOCKNAMELEN);
3975             NFSBCOPY(nfhp, &own[NFSV4CL_LOCKNAMELEN], fhlen);
3976             (void)nfsm_strtom(nd, own, NFSV4CL_LOCKNAMELEN + fhlen);
3977         } else {
3978             *tl = newnfs_false;
3979             NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + NFSX_UNSIGNED);
3980             if (NFSHASNFSV4N(nmp))
3981                 *tl++ = 0;
3982             else
3983                 *tl++ = lp->nfsl_stateid.seqid;
3984             *tl++ = lp->nfsl_stateid.other[0];
3985             *tl++ = lp->nfsl_stateid.other[1];
3986             *tl++ = lp->nfsl_stateid.other[2];
3987             *tl = txdr_unsigned(lp->nfsl_seqid);
3988             if (nfstest_outofseq &&
3989                 (arc4random() % nfstest_outofseq) == 0)
3990                     *tl = txdr_unsigned(lp->nfsl_seqid + 1);
3991         }
3992         if (syscred)
3993                 nd->nd_flag |= ND_USEGSSNAME;
3994         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, vp, p, cred,
3995             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
3996         if (error)
3997                 return (error);
3998         if (newone)
3999             NFSCL_INCRSEQID(lp->nfsl_open->nfso_own->nfsow_seqid, nd);
4000         NFSCL_INCRSEQID(lp->nfsl_seqid, nd);
4001         if (nd->nd_repstat == 0) {
4002                 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
4003                 lp->nfsl_stateid.seqid = *tl++;
4004                 lp->nfsl_stateid.other[0] = *tl++;
4005                 lp->nfsl_stateid.other[1] = *tl++;
4006                 lp->nfsl_stateid.other[2] = *tl;
4007         } else if (nd->nd_repstat == NFSERR_DENIED) {
4008                 NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
4009                 size = fxdr_unsigned(int, *(tl + 7));
4010                 if (size < 0 || size > NFSV4_OPAQUELIMIT)
4011                         error = EBADRPC;
4012                 if (!error)
4013                         error = nfsm_advance(nd, NFSM_RNDUP(size), -1);
4014         } else if (nd->nd_repstat == NFSERR_STALESTATEID ||
4015             nd->nd_repstat == NFSERR_BADSESSION)
4016                 nfscl_initiate_recovery(lp->nfsl_open->nfso_own->nfsow_clp);
4017 nfsmout:
4018         mbuf_freem(nd->nd_mrep);
4019         return (error);
4020 }
4021
4022 /*
4023  * nfs statfs rpc
4024  * (always called with the vp for the mount point)
4025  */
4026 APPLESTATIC int
4027 nfsrpc_statfs(vnode_t vp, struct nfsstatfs *sbp, struct nfsfsinfo *fsp,
4028     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
4029     void *stuff)
4030 {
4031         u_int32_t *tl = NULL;
4032         struct nfsrv_descript nfsd, *nd = &nfsd;
4033         struct nfsmount *nmp;
4034         nfsattrbit_t attrbits;
4035         int error;
4036
4037         *attrflagp = 0;
4038         nmp = VFSTONFS(vnode_mount(vp));
4039         if (NFSHASNFSV4(nmp)) {
4040                 /*
4041                  * For V4, you actually do a getattr.
4042                  */
4043                 NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp);
4044                 NFSSTATFS_GETATTRBIT(&attrbits);
4045                 (void) nfsrv_putattrbit(nd, &attrbits);
4046                 nd->nd_flag |= ND_USEGSSNAME;
4047                 error = nfscl_request(nd, vp, p, cred, stuff);
4048                 if (error)
4049                         return (error);
4050                 if (nd->nd_repstat == 0) {
4051                         error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
4052                             NULL, NULL, sbp, fsp, NULL, 0, NULL, NULL, NULL, p,
4053                             cred);
4054                         if (!error) {
4055                                 nmp->nm_fsid[0] = nap->na_filesid[0];
4056                                 nmp->nm_fsid[1] = nap->na_filesid[1];
4057                                 NFSSETHASSETFSID(nmp);
4058                                 *attrflagp = 1;
4059                         }
4060                 } else {
4061                         error = nd->nd_repstat;
4062                 }
4063                 if (error)
4064                         goto nfsmout;
4065         } else {
4066                 NFSCL_REQSTART(nd, NFSPROC_FSSTAT, vp);
4067                 error = nfscl_request(nd, vp, p, cred, stuff);
4068                 if (error)
4069                         return (error);
4070                 if (nd->nd_flag & ND_NFSV3) {
4071                         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
4072                         if (error)
4073                                 goto nfsmout;
4074                 }
4075                 if (nd->nd_repstat) {
4076                         error = nd->nd_repstat;
4077                         goto nfsmout;
4078                 }
4079                 NFSM_DISSECT(tl, u_int32_t *,
4080                     NFSX_STATFS(nd->nd_flag & ND_NFSV3));
4081         }
4082         if (NFSHASNFSV3(nmp)) {
4083                 sbp->sf_tbytes = fxdr_hyper(tl); tl += 2;
4084                 sbp->sf_fbytes = fxdr_hyper(tl); tl += 2;
4085                 sbp->sf_abytes = fxdr_hyper(tl); tl += 2;
4086                 sbp->sf_tfiles = fxdr_hyper(tl); tl += 2;
4087                 sbp->sf_ffiles = fxdr_hyper(tl); tl += 2;
4088                 sbp->sf_afiles = fxdr_hyper(tl); tl += 2;
4089                 sbp->sf_invarsec = fxdr_unsigned(u_int32_t, *tl);
4090         } else if (NFSHASNFSV4(nmp) == 0) {
4091                 sbp->sf_tsize = fxdr_unsigned(u_int32_t, *tl++);
4092                 sbp->sf_bsize = fxdr_unsigned(u_int32_t, *tl++);
4093                 sbp->sf_blocks = fxdr_unsigned(u_int32_t, *tl++);
4094                 sbp->sf_bfree = fxdr_unsigned(u_int32_t, *tl++);
4095                 sbp->sf_bavail = fxdr_unsigned(u_int32_t, *tl);
4096         }
4097 nfsmout:
4098         mbuf_freem(nd->nd_mrep);
4099         return (error);
4100 }
4101
4102 /*
4103  * nfs pathconf rpc
4104  */
4105 APPLESTATIC int
4106 nfsrpc_pathconf(vnode_t vp, struct nfsv3_pathconf *pc,
4107     struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
4108     void *stuff)
4109 {
4110         struct nfsrv_descript nfsd, *nd = &nfsd;
4111         struct nfsmount *nmp;
4112         u_int32_t *tl;
4113         nfsattrbit_t attrbits;
4114         int error;
4115
4116         *attrflagp = 0;
4117         nmp = VFSTONFS(vnode_mount(vp));
4118         if (NFSHASNFSV4(nmp)) {
4119                 /*
4120                  * For V4, you actually do a getattr.
4121                  */
4122                 NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp);
4123                 NFSPATHCONF_GETATTRBIT(&attrbits);
4124                 (void) nfsrv_putattrbit(nd, &attrbits);
4125                 nd->nd_flag |= ND_USEGSSNAME;
4126                 error = nfscl_request(nd, vp, p, cred, stuff);
4127                 if (error)
4128                         return (error);
4129                 if (nd->nd_repstat == 0) {
4130                         error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
4131                             pc, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL, p,
4132                             cred);
4133                         if (!error)
4134                                 *attrflagp = 1;
4135                 } else {
4136                         error = nd->nd_repstat;
4137                 }
4138         } else {
4139                 NFSCL_REQSTART(nd, NFSPROC_PATHCONF, vp);
4140                 error = nfscl_request(nd, vp, p, cred, stuff);
4141                 if (error)
4142                         return (error);
4143                 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
4144                 if (nd->nd_repstat && !error)
4145                         error = nd->nd_repstat;
4146                 if (!error) {
4147                         NFSM_DISSECT(tl, u_int32_t *, NFSX_V3PATHCONF);
4148                         pc->pc_linkmax = fxdr_unsigned(u_int32_t, *tl++);
4149                         pc->pc_namemax = fxdr_unsigned(u_int32_t, *tl++);
4150                         pc->pc_notrunc = fxdr_unsigned(u_int32_t, *tl++);
4151                         pc->pc_chownrestricted =
4152                             fxdr_unsigned(u_int32_t, *tl++);
4153                         pc->pc_caseinsensitive =
4154                             fxdr_unsigned(u_int32_t, *tl++);
4155                         pc->pc_casepreserving = fxdr_unsigned(u_int32_t, *tl);
4156                 }
4157         }
4158 nfsmout:
4159         mbuf_freem(nd->nd_mrep);
4160         return (error);
4161 }
4162
4163 /*
4164  * nfs version 3 fsinfo rpc call
4165  */
4166 APPLESTATIC int
4167 nfsrpc_fsinfo(vnode_t vp, struct nfsfsinfo *fsp, struct ucred *cred,
4168     NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
4169 {
4170         u_int32_t *tl;
4171         struct nfsrv_descript nfsd, *nd = &nfsd;
4172         int error;
4173
4174         *attrflagp = 0;
4175         NFSCL_REQSTART(nd, NFSPROC_FSINFO, vp);
4176         error = nfscl_request(nd, vp, p, cred, stuff);
4177         if (error)
4178                 return (error);
4179         error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
4180         if (nd->nd_repstat && !error)
4181                 error = nd->nd_repstat;
4182         if (!error) {
4183                 NFSM_DISSECT(tl, u_int32_t *, NFSX_V3FSINFO);
4184                 fsp->fs_rtmax = fxdr_unsigned(u_int32_t, *tl++);
4185                 fsp->fs_rtpref = fxdr_unsigned(u_int32_t, *tl++);
4186                 fsp->fs_rtmult = fxdr_unsigned(u_int32_t, *tl++);
4187                 fsp->fs_wtmax = fxdr_unsigned(u_int32_t, *tl++);
4188                 fsp->fs_wtpref = fxdr_unsigned(u_int32_t, *tl++);
4189                 fsp->fs_wtmult = fxdr_unsigned(u_int32_t, *tl++);
4190                 fsp->fs_dtpref = fxdr_unsigned(u_int32_t, *tl++);
4191                 fsp->fs_maxfilesize = fxdr_hyper(tl);
4192                 tl += 2;
4193                 fxdr_nfsv3time(tl, &fsp->fs_timedelta);
4194                 tl += 2;
4195                 fsp->fs_properties = fxdr_unsigned(u_int32_t, *tl);
4196         }
4197 nfsmout:
4198         mbuf_freem(nd->nd_mrep);
4199         return (error);
4200 }
4201
4202 /*
4203  * This function performs the Renew RPC.
4204  */
4205 APPLESTATIC int
4206 nfsrpc_renew(struct nfsclclient *clp, struct nfsclds *dsp, struct ucred *cred,
4207     NFSPROC_T *p)
4208 {
4209         u_int32_t *tl;
4210         struct nfsrv_descript nfsd;
4211         struct nfsrv_descript *nd = &nfsd;
4212         struct nfsmount *nmp;
4213         int error;
4214         struct nfssockreq *nrp;
4215
4216         nmp = clp->nfsc_nmp;
4217         if (nmp == NULL)
4218                 return (0);
4219         nfscl_reqstart(nd, NFSPROC_RENEW, nmp, NULL, 0, NULL,
4220             &dsp->nfsclds_sess);
4221         if (!NFSHASNFSV4N(nmp)) {
4222                 /* NFSv4.1 just uses a Sequence Op and not a Renew. */
4223                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
4224                 *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
4225                 *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
4226         }
4227         nrp = dsp->nfsclds_sockp;
4228         if (nrp == NULL)
4229                 /* If NULL, use the MDS socket. */
4230                 nrp = &nmp->nm_sockreq;
4231         nd->nd_flag |= ND_USEGSSNAME;
4232         error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred,
4233             NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
4234         if (error)
4235                 return (error);
4236         error = nd->nd_repstat;
4237         mbuf_freem(nd->nd_mrep);
4238         return (error);
4239 }
4240
4241 /*
4242  * This function performs the Releaselockowner RPC.
4243  */
4244 APPLESTATIC int
4245 nfsrpc_rellockown(struct nfsmount *nmp, struct nfscllockowner *lp,
4246     uint8_t *fh, int fhlen, struct ucred *cred, NFSPROC_T *p)
4247 {
4248         struct nfsrv_descript nfsd, *nd = &nfsd;
4249         u_int32_t *tl;
4250         int error;
4251         uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
4252
4253         if (NFSHASNFSV4N(nmp)) {
4254                 /* For NFSv4.1, do a FreeStateID. */
4255                 nfscl_reqstart(nd, NFSPROC_FREESTATEID, nmp, NULL, 0, NULL,
4256                     NULL);
4257                 nfsm_stateidtom(nd, &lp->nfsl_stateid, NFSSTATEID_PUTSTATEID);
4258         } else {
4259                 nfscl_reqstart(nd, NFSPROC_RELEASELCKOWN, nmp, NULL, 0, NULL,
4260                     NULL);
4261                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
4262                 *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
4263                 *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
4264                 NFSBCOPY(lp->nfsl_owner, own, NFSV4CL_LOCKNAMELEN);
4265                 NFSBCOPY(fh, &own[NFSV4CL_LOCKNAMELEN], fhlen);
4266                 (void)nfsm_strtom(nd, own, NFSV4CL_LOCKNAMELEN + fhlen);
4267         }
4268         nd->nd_flag |= ND_USEGSSNAME;
4269         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4270             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4271         if (error)
4272                 return (error);
4273         error = nd->nd_repstat;
4274         mbuf_freem(nd->nd_mrep);
4275         return (error);
4276 }
4277
4278 /*
4279  * This function performs the Compound to get the mount pt FH.
4280  */
4281 APPLESTATIC int
4282 nfsrpc_getdirpath(struct nfsmount *nmp, u_char *dirpath, struct ucred *cred,
4283     NFSPROC_T *p)
4284 {
4285         u_int32_t *tl;
4286         struct nfsrv_descript nfsd;
4287         struct nfsrv_descript *nd = &nfsd;
4288         u_char *cp, *cp2;
4289         int error, cnt, len, setnil;
4290         u_int32_t *opcntp;
4291
4292         nfscl_reqstart(nd, NFSPROC_PUTROOTFH, nmp, NULL, 0, &opcntp, NULL);
4293         cp = dirpath;
4294         cnt = 0;
4295         do {
4296                 setnil = 0;
4297                 while (*cp == '/')
4298                         cp++;
4299                 cp2 = cp;
4300                 while (*cp2 != '\0' && *cp2 != '/')
4301                         cp2++;
4302                 if (*cp2 == '/') {
4303                         setnil = 1;
4304                         *cp2 = '\0';
4305                 }
4306                 if (cp2 != cp) {
4307                         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
4308                         *tl = txdr_unsigned(NFSV4OP_LOOKUP);
4309                         nfsm_strtom(nd, cp, strlen(cp));
4310                         cnt++;
4311                 }
4312                 if (setnil)
4313                         *cp2++ = '/';
4314                 cp = cp2;
4315         } while (*cp != '\0');
4316         if (NFSHASNFSV4N(nmp))
4317                 /* Has a Sequence Op done by nfscl_reqstart(). */
4318                 *opcntp = txdr_unsigned(3 + cnt);
4319         else
4320                 *opcntp = txdr_unsigned(2 + cnt);
4321         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
4322         *tl = txdr_unsigned(NFSV4OP_GETFH);
4323         nd->nd_flag |= ND_USEGSSNAME;
4324         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4325                 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4326         if (error)
4327                 return (error);
4328         if (nd->nd_repstat == 0) {
4329                 NFSM_DISSECT(tl, u_int32_t *, (3 + 2 * cnt) * NFSX_UNSIGNED);
4330                 tl += (2 + 2 * cnt);
4331                 if ((len = fxdr_unsigned(int, *tl)) <= 0 ||
4332                         len > NFSX_FHMAX) {
4333                         nd->nd_repstat = NFSERR_BADXDR;
4334                 } else {
4335                         nd->nd_repstat = nfsrv_mtostr(nd, nmp->nm_fh, len);
4336                         if (nd->nd_repstat == 0)
4337                                 nmp->nm_fhsize = len;
4338                 }
4339         }
4340         error = nd->nd_repstat;
4341 nfsmout:
4342         mbuf_freem(nd->nd_mrep);
4343         return (error);
4344 }
4345
4346 /*
4347  * This function performs the Delegreturn RPC.
4348  */
4349 APPLESTATIC int
4350 nfsrpc_delegreturn(struct nfscldeleg *dp, struct ucred *cred,
4351     struct nfsmount *nmp, NFSPROC_T *p, int syscred)
4352 {
4353         u_int32_t *tl;
4354         struct nfsrv_descript nfsd;
4355         struct nfsrv_descript *nd = &nfsd;
4356         int error;
4357
4358         nfscl_reqstart(nd, NFSPROC_DELEGRETURN, nmp, dp->nfsdl_fh,
4359             dp->nfsdl_fhlen, NULL, NULL);
4360         NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
4361         if (NFSHASNFSV4N(nmp))
4362                 *tl++ = 0;
4363         else
4364                 *tl++ = dp->nfsdl_stateid.seqid;
4365         *tl++ = dp->nfsdl_stateid.other[0];
4366         *tl++ = dp->nfsdl_stateid.other[1];
4367         *tl = dp->nfsdl_stateid.other[2];
4368         if (syscred)
4369                 nd->nd_flag |= ND_USEGSSNAME;
4370         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4371             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4372         if (error)
4373                 return (error);
4374         error = nd->nd_repstat;
4375         mbuf_freem(nd->nd_mrep);
4376         return (error);
4377 }
4378
4379 /*
4380  * nfs getacl call.
4381  */
4382 APPLESTATIC int
4383 nfsrpc_getacl(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
4384     struct acl *aclp, void *stuff)
4385 {
4386         struct nfsrv_descript nfsd, *nd = &nfsd;
4387         int error;
4388         nfsattrbit_t attrbits;
4389         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4390
4391         if (nfsrv_useacl == 0 || !NFSHASNFSV4(nmp))
4392                 return (EOPNOTSUPP);
4393         NFSCL_REQSTART(nd, NFSPROC_GETACL, vp);
4394         NFSZERO_ATTRBIT(&attrbits);
4395         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
4396         (void) nfsrv_putattrbit(nd, &attrbits);
4397         error = nfscl_request(nd, vp, p, cred, stuff);
4398         if (error)
4399                 return (error);
4400         if (!nd->nd_repstat)
4401                 error = nfsv4_loadattr(nd, vp, NULL, NULL, NULL, 0, NULL,
4402                     NULL, NULL, NULL, aclp, 0, NULL, NULL, NULL, p, cred);
4403         else
4404                 error = nd->nd_repstat;
4405         mbuf_freem(nd->nd_mrep);
4406         return (error);
4407 }
4408
4409 /*
4410  * nfs setacl call.
4411  */
4412 APPLESTATIC int
4413 nfsrpc_setacl(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
4414     struct acl *aclp, void *stuff)
4415 {
4416         int error;
4417         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4418
4419         if (nfsrv_useacl == 0 || !NFSHASNFSV4(nmp))
4420                 return (EOPNOTSUPP);
4421         error = nfsrpc_setattr(vp, NULL, aclp, cred, p, NULL, NULL, stuff);
4422         return (error);
4423 }
4424
4425 /*
4426  * nfs setacl call.
4427  */
4428 static int
4429 nfsrpc_setaclrpc(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
4430     struct acl *aclp, nfsv4stateid_t *stateidp, void *stuff)
4431 {
4432         struct nfsrv_descript nfsd, *nd = &nfsd;
4433         int error;
4434         nfsattrbit_t attrbits;
4435         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4436
4437         if (!NFSHASNFSV4(nmp))
4438                 return (EOPNOTSUPP);
4439         NFSCL_REQSTART(nd, NFSPROC_SETACL, vp);
4440         nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
4441         NFSZERO_ATTRBIT(&attrbits);
4442         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
4443         (void) nfsv4_fillattr(nd, vnode_mount(vp), vp, aclp, NULL, NULL, 0,
4444             &attrbits, NULL, NULL, 0, 0, 0, 0, (uint64_t)0);
4445         error = nfscl_request(nd, vp, p, cred, stuff);
4446         if (error)
4447                 return (error);
4448         /* Don't care about the pre/postop attributes */
4449         mbuf_freem(nd->nd_mrep);
4450         return (nd->nd_repstat);
4451 }
4452
4453 /*
4454  * Do the NFSv4.1 Exchange ID.
4455  */
4456 int
4457 nfsrpc_exchangeid(struct nfsmount *nmp, struct nfsclclient *clp,
4458     struct nfssockreq *nrp, uint32_t exchflags, struct nfsclds **dspp,
4459     struct ucred *cred, NFSPROC_T *p)
4460 {
4461         uint32_t *tl, v41flags;
4462         struct nfsrv_descript nfsd;
4463         struct nfsrv_descript *nd = &nfsd;
4464         struct nfsclds *dsp;
4465         struct timespec verstime;
4466         int error, len;
4467
4468         *dspp = NULL;
4469         nfscl_reqstart(nd, NFSPROC_EXCHANGEID, nmp, NULL, 0, NULL, NULL);
4470         NFSM_BUILD(tl, uint32_t *, 2 * NFSX_UNSIGNED);
4471         *tl++ = txdr_unsigned(nfsboottime.tv_sec);      /* Client owner */
4472         *tl = txdr_unsigned(clp->nfsc_rev);
4473         (void) nfsm_strtom(nd, clp->nfsc_id, clp->nfsc_idlen);
4474
4475         NFSM_BUILD(tl, uint32_t *, 3 * NFSX_UNSIGNED);
4476         *tl++ = txdr_unsigned(exchflags);
4477         *tl++ = txdr_unsigned(NFSV4EXCH_SP4NONE);
4478
4479         /* Set the implementation id4 */
4480         *tl = txdr_unsigned(1);
4481         (void) nfsm_strtom(nd, "freebsd.org", strlen("freebsd.org"));
4482         (void) nfsm_strtom(nd, version, strlen(version));
4483         NFSM_BUILD(tl, uint32_t *, NFSX_V4TIME);
4484         verstime.tv_sec = 1293840000;           /* Jan 1, 2011 */
4485         verstime.tv_nsec = 0;
4486         txdr_nfsv4time(&verstime, tl);
4487         nd->nd_flag |= ND_USEGSSNAME;
4488         error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred,
4489             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4490         NFSCL_DEBUG(1, "exchangeid err=%d reps=%d\n", error,
4491             (int)nd->nd_repstat);
4492         if (error != 0)
4493                 return (error);
4494         if (nd->nd_repstat == 0) {
4495                 NFSM_DISSECT(tl, uint32_t *, 6 * NFSX_UNSIGNED + NFSX_HYPER);
4496                 len = fxdr_unsigned(int, *(tl + 7));
4497                 if (len < 0 || len > NFSV4_OPAQUELIMIT) {
4498                         error = NFSERR_BADXDR;
4499                         goto nfsmout;
4500                 }
4501                 dsp = malloc(sizeof(struct nfsclds) + len, M_NFSCLDS,
4502                     M_WAITOK | M_ZERO);
4503                 dsp->nfsclds_expire = NFSD_MONOSEC + clp->nfsc_renew;
4504                 dsp->nfsclds_servownlen = len;
4505                 dsp->nfsclds_sess.nfsess_clientid.lval[0] = *tl++;
4506                 dsp->nfsclds_sess.nfsess_clientid.lval[1] = *tl++;
4507                 dsp->nfsclds_sess.nfsess_sequenceid =
4508                     fxdr_unsigned(uint32_t, *tl++);
4509                 v41flags = fxdr_unsigned(uint32_t, *tl);
4510                 if ((v41flags & NFSV4EXCH_USEPNFSMDS) != 0 &&
4511                     NFSHASPNFSOPT(nmp)) {
4512                         NFSCL_DEBUG(1, "set PNFS\n");
4513                         NFSLOCKMNT(nmp);
4514                         nmp->nm_state |= NFSSTA_PNFS;
4515                         NFSUNLOCKMNT(nmp);
4516                         dsp->nfsclds_flags |= NFSCLDS_MDS;
4517                 }
4518                 if ((v41flags & NFSV4EXCH_USEPNFSDS) != 0)
4519                         dsp->nfsclds_flags |= NFSCLDS_DS;
4520                 if (len > 0)
4521                         nd->nd_repstat = nfsrv_mtostr(nd,
4522                             dsp->nfsclds_serverown, len);
4523                 if (nd->nd_repstat == 0) {
4524                         mtx_init(&dsp->nfsclds_mtx, "nfsds", NULL, MTX_DEF);
4525                         mtx_init(&dsp->nfsclds_sess.nfsess_mtx, "nfssession",
4526                             NULL, MTX_DEF);
4527                         nfscl_initsessionslots(&dsp->nfsclds_sess);
4528                         *dspp = dsp;
4529                 } else
4530                         free(dsp, M_NFSCLDS);
4531         }
4532         error = nd->nd_repstat;
4533 nfsmout:
4534         mbuf_freem(nd->nd_mrep);
4535         return (error);
4536 }
4537
4538 /*
4539  * Do the NFSv4.1 Create Session.
4540  */
4541 int
4542 nfsrpc_createsession(struct nfsmount *nmp, struct nfsclsession *sep,
4543     struct nfssockreq *nrp, uint32_t sequenceid, int mds, struct ucred *cred,
4544     NFSPROC_T *p)
4545 {
4546         uint32_t crflags, *tl;
4547         struct nfsrv_descript nfsd;
4548         struct nfsrv_descript *nd = &nfsd;
4549         int error, irdcnt;
4550
4551         nfscl_reqstart(nd, NFSPROC_CREATESESSION, nmp, NULL, 0, NULL, NULL);
4552         NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
4553         *tl++ = sep->nfsess_clientid.lval[0];
4554         *tl++ = sep->nfsess_clientid.lval[1];
4555         *tl++ = txdr_unsigned(sequenceid);
4556         crflags = (NFSMNT_RDONLY(nmp->nm_mountp) ? 0 : NFSV4CRSESS_PERSIST);
4557         if (nfscl_enablecallb != 0 && nfs_numnfscbd > 0)
4558                 crflags |= NFSV4CRSESS_CONNBACKCHAN;
4559         *tl = txdr_unsigned(crflags);
4560
4561         /* Fill in fore channel attributes. */
4562         NFSM_BUILD(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4563         *tl++ = 0;                              /* Header pad size */
4564         *tl++ = txdr_unsigned(100000);          /* Max request size */
4565         *tl++ = txdr_unsigned(100000);          /* Max response size */
4566         *tl++ = txdr_unsigned(4096);            /* Max response size cached */
4567         *tl++ = txdr_unsigned(20);              /* Max operations */
4568         *tl++ = txdr_unsigned(64);              /* Max slots */
4569         *tl = 0;                                /* No rdma ird */
4570
4571         /* Fill in back channel attributes. */
4572         NFSM_BUILD(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4573         *tl++ = 0;                              /* Header pad size */
4574         *tl++ = txdr_unsigned(10000);           /* Max request size */
4575         *tl++ = txdr_unsigned(10000);           /* Max response size */
4576         *tl++ = txdr_unsigned(4096);            /* Max response size cached */
4577         *tl++ = txdr_unsigned(4);               /* Max operations */
4578         *tl++ = txdr_unsigned(NFSV4_CBSLOTS);   /* Max slots */
4579         *tl = 0;                                /* No rdma ird */
4580
4581         NFSM_BUILD(tl, uint32_t *, 8 * NFSX_UNSIGNED);
4582         *tl++ = txdr_unsigned(NFS_CALLBCKPROG); /* Call back prog # */
4583
4584         /* Allow AUTH_SYS callbacks as uid, gid == 0. */
4585         *tl++ = txdr_unsigned(1);               /* Auth_sys only */
4586         *tl++ = txdr_unsigned(AUTH_SYS);        /* AUTH_SYS type */
4587         *tl++ = txdr_unsigned(nfsboottime.tv_sec); /* time stamp */
4588         *tl++ = 0;                              /* Null machine name */
4589         *tl++ = 0;                              /* Uid == 0 */
4590         *tl++ = 0;                              /* Gid == 0 */
4591         *tl = 0;                                /* No additional gids */
4592         nd->nd_flag |= ND_USEGSSNAME;
4593         error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred, NFS_PROG,
4594             NFS_VER4, NULL, 1, NULL, NULL);
4595         if (error != 0)
4596                 return (error);
4597         if (nd->nd_repstat == 0) {
4598                 NFSM_DISSECT(tl, uint32_t *, NFSX_V4SESSIONID +
4599                     2 * NFSX_UNSIGNED);
4600                 bcopy(tl, sep->nfsess_sessionid, NFSX_V4SESSIONID);
4601                 tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;
4602                 sep->nfsess_sequenceid = fxdr_unsigned(uint32_t, *tl++);
4603                 crflags = fxdr_unsigned(uint32_t, *tl);
4604                 if ((crflags & NFSV4CRSESS_PERSIST) != 0 && mds != 0) {
4605                         NFSLOCKMNT(nmp);
4606                         nmp->nm_state |= NFSSTA_SESSPERSIST;
4607                         NFSUNLOCKMNT(nmp);
4608                 }
4609
4610                 /* Get the fore channel slot count. */
4611                 NFSM_DISSECT(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4612                 tl += 3;                /* Skip the other counts. */
4613                 sep->nfsess_maxcache = fxdr_unsigned(int, *tl++);
4614                 tl++;
4615                 sep->nfsess_foreslots = fxdr_unsigned(uint16_t, *tl++);
4616                 NFSCL_DEBUG(4, "fore slots=%d\n", (int)sep->nfsess_foreslots);
4617                 irdcnt = fxdr_unsigned(int, *tl);
4618                 if (irdcnt > 0)
4619                         NFSM_DISSECT(tl, uint32_t *, irdcnt * NFSX_UNSIGNED);
4620
4621                 /* and the back channel slot count. */
4622                 NFSM_DISSECT(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4623                 tl += 5;
4624                 sep->nfsess_backslots = fxdr_unsigned(uint16_t, *tl);
4625                 NFSCL_DEBUG(4, "back slots=%d\n", (int)sep->nfsess_backslots);
4626         }
4627         error = nd->nd_repstat;
4628 nfsmout:
4629         mbuf_freem(nd->nd_mrep);
4630         return (error);
4631 }
4632
4633 /*
4634  * Do the NFSv4.1 Destroy Session.
4635  */
4636 int
4637 nfsrpc_destroysession(struct nfsmount *nmp, struct nfsclclient *clp,
4638     struct ucred *cred, NFSPROC_T *p)
4639 {
4640         uint32_t *tl;
4641         struct nfsrv_descript nfsd;
4642         struct nfsrv_descript *nd = &nfsd;
4643         int error;
4644
4645         nfscl_reqstart(nd, NFSPROC_DESTROYSESSION, nmp, NULL, 0, NULL, NULL);
4646         NFSM_BUILD(tl, uint32_t *, NFSX_V4SESSIONID);
4647         bcopy(NFSMNT_MDSSESSION(nmp)->nfsess_sessionid, tl, NFSX_V4SESSIONID);
4648         nd->nd_flag |= ND_USEGSSNAME;
4649         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4650             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4651         if (error != 0)
4652                 return (error);
4653         error = nd->nd_repstat;
4654         mbuf_freem(nd->nd_mrep);
4655         return (error);
4656 }
4657
4658 /*
4659  * Do the NFSv4.1 Destroy Client.
4660  */
4661 int
4662 nfsrpc_destroyclient(struct nfsmount *nmp, struct nfsclclient *clp,
4663     struct ucred *cred, NFSPROC_T *p)
4664 {
4665         uint32_t *tl;
4666         struct nfsrv_descript nfsd;
4667         struct nfsrv_descript *nd = &nfsd;
4668         int error;
4669
4670         nfscl_reqstart(nd, NFSPROC_DESTROYCLIENT, nmp, NULL, 0, NULL, NULL);
4671         NFSM_BUILD(tl, uint32_t *, 2 * NFSX_UNSIGNED);
4672         *tl++ = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[0];
4673         *tl = NFSMNT_MDSSESSION(nmp)->nfsess_clientid.lval[1];
4674         nd->nd_flag |= ND_USEGSSNAME;
4675         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4676             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4677         if (error != 0)
4678                 return (error);
4679         error = nd->nd_repstat;
4680         mbuf_freem(nd->nd_mrep);
4681         return (error);
4682 }
4683
4684 /*
4685  * Do the NFSv4.1 LayoutGet.
4686  */
4687 int
4688 nfsrpc_layoutget(struct nfsmount *nmp, uint8_t *fhp, int fhlen, int iomode,
4689     uint64_t offset, uint64_t len, uint64_t minlen, int layoutlen,
4690     nfsv4stateid_t *stateidp, int *retonclosep, struct nfsclflayouthead *flhp,
4691     struct ucred *cred, NFSPROC_T *p, void *stuff)
4692 {
4693         uint32_t *tl;
4694         struct nfsrv_descript nfsd, *nd = &nfsd;
4695         struct nfsfh *nfhp;
4696         struct nfsclflayout *flp, *prevflp, *tflp;
4697         int cnt, error, gotiomode, fhcnt, nfhlen, i, j;
4698         uint8_t *cp;
4699         uint64_t retlen;
4700
4701         flp = NULL;
4702         gotiomode = -1;
4703         nfscl_reqstart(nd, NFSPROC_LAYOUTGET, nmp, fhp, fhlen, NULL, NULL);
4704         NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED + 3 * NFSX_HYPER +
4705             NFSX_STATEID);
4706         *tl++ = newnfs_false;           /* Don't signal availability. */
4707         *tl++ = txdr_unsigned(NFSLAYOUT_NFSV4_1_FILES);
4708         *tl++ = txdr_unsigned(iomode);
4709         txdr_hyper(offset, tl);
4710         tl += 2;
4711         txdr_hyper(len, tl);
4712         tl += 2;
4713         txdr_hyper(minlen, tl);
4714         tl += 2;
4715         *tl++ = txdr_unsigned(stateidp->seqid);
4716         NFSCL_DEBUG(4, "layget seq=%d\n", (int)stateidp->seqid);
4717         *tl++ = stateidp->other[0];
4718         *tl++ = stateidp->other[1];
4719         *tl++ = stateidp->other[2];
4720         *tl = txdr_unsigned(layoutlen);
4721         nd->nd_flag |= ND_USEGSSNAME;
4722         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4723             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4724         if (error != 0)
4725                 return (error);
4726         if (nd->nd_repstat == 0) {
4727                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED + NFSX_STATEID);
4728                 if (*tl++ != 0)
4729                         *retonclosep = 1;
4730                 else
4731                         *retonclosep = 0;
4732                 stateidp->seqid = fxdr_unsigned(uint32_t, *tl++);
4733                 NFSCL_DEBUG(4, "retoncls=%d stseq=%d\n", *retonclosep,
4734                     (int)stateidp->seqid);
4735                 stateidp->other[0] = *tl++;
4736                 stateidp->other[1] = *tl++;
4737                 stateidp->other[2] = *tl++;
4738                 cnt = fxdr_unsigned(int, *tl);
4739                 NFSCL_DEBUG(4, "layg cnt=%d\n", cnt);
4740                 if (cnt <= 0 || cnt > 10000) {
4741                         /* Don't accept more than 10000 layouts in reply. */
4742                         error = NFSERR_BADXDR;
4743                         goto nfsmout;
4744                 }
4745                 for (i = 0; i < cnt; i++) {
4746                         /* Dissect all the way to the file handle cnt. */
4747                         NFSM_DISSECT(tl, uint32_t *, 3 * NFSX_HYPER +
4748                             6 * NFSX_UNSIGNED + NFSX_V4DEVICEID);
4749                         fhcnt = fxdr_unsigned(int, *(tl + 11 +
4750                             NFSX_V4DEVICEID / NFSX_UNSIGNED));
4751                         NFSCL_DEBUG(4, "fhcnt=%d\n", fhcnt);
4752                         if (fhcnt < 0 || fhcnt > 100) {
4753                                 /* Don't accept more than 100 file handles. */
4754                                 error = NFSERR_BADXDR;
4755                                 goto nfsmout;
4756                         }
4757                         if (fhcnt > 1)
4758                                 flp = malloc(sizeof(*flp) + (fhcnt - 1) *
4759                                     sizeof(struct nfsfh *),
4760                                     M_NFSFLAYOUT, M_WAITOK);
4761                         else
4762                                 flp = malloc(sizeof(*flp),
4763                                     M_NFSFLAYOUT, M_WAITOK);
4764                         flp->nfsfl_flags = 0;
4765                         flp->nfsfl_fhcnt = 0;
4766                         flp->nfsfl_devp = NULL;
4767                         flp->nfsfl_off = fxdr_hyper(tl); tl += 2;
4768                         retlen = fxdr_hyper(tl); tl += 2;
4769                         if (flp->nfsfl_off + retlen < flp->nfsfl_off)
4770                                 flp->nfsfl_end = UINT64_MAX - flp->nfsfl_off;
4771                         else
4772                                 flp->nfsfl_end = flp->nfsfl_off + retlen;
4773                         flp->nfsfl_iomode = fxdr_unsigned(int, *tl++);
4774                         if (gotiomode == -1)
4775                                 gotiomode = flp->nfsfl_iomode;
4776                         NFSCL_DEBUG(4, "layg reqiom=%d retiom=%d\n", iomode,
4777                             (int)flp->nfsfl_iomode);
4778                         if (fxdr_unsigned(int, *tl++) !=
4779                             NFSLAYOUT_NFSV4_1_FILES) {
4780                                 printf("NFSv4.1: got non-files layout\n");
4781                                 error = NFSERR_BADXDR;
4782                                 goto nfsmout;
4783                         }
4784                         NFSBCOPY(++tl, flp->nfsfl_dev, NFSX_V4DEVICEID);
4785                         tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
4786                         flp->nfsfl_util = fxdr_unsigned(uint32_t, *tl++);
4787                         NFSCL_DEBUG(4, "flutil=0x%x\n", flp->nfsfl_util);
4788                         flp->nfsfl_stripe1 = fxdr_unsigned(uint32_t, *tl++);
4789                         flp->nfsfl_patoff = fxdr_hyper(tl); tl += 2;
4790                         if (fxdr_unsigned(int, *tl) != fhcnt) {
4791                                 printf("EEK! bad fhcnt\n");
4792                                 error = NFSERR_BADXDR;
4793                                 goto nfsmout;
4794                         }
4795                         for (j = 0; j < fhcnt; j++) {
4796                                 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
4797                                 nfhlen = fxdr_unsigned(int, *tl);
4798                                 if (nfhlen <= 0 || nfhlen > NFSX_V4FHMAX) {
4799                                         error = NFSERR_BADXDR;
4800                                         goto nfsmout;
4801                                 }
4802                                 nfhp = malloc(sizeof(*nfhp) + nfhlen - 1,
4803                                     M_NFSFH, M_WAITOK);
4804                                 flp->nfsfl_fh[j] = nfhp;
4805                                 flp->nfsfl_fhcnt++;
4806                                 nfhp->nfh_len = nfhlen;
4807                                 NFSM_DISSECT(cp, uint8_t *, NFSM_RNDUP(nfhlen));
4808                                 NFSBCOPY(cp, nfhp->nfh_fh, nfhlen);
4809                         }
4810                         if (flp->nfsfl_iomode == gotiomode) {
4811                                 /* Keep the list in increasing offset order. */
4812                                 tflp = LIST_FIRST(flhp);
4813                                 prevflp = NULL;
4814                                 while (tflp != NULL &&
4815                                     tflp->nfsfl_off < flp->nfsfl_off) {
4816                                         prevflp = tflp;
4817                                         tflp = LIST_NEXT(tflp, nfsfl_list);
4818                                 }
4819                                 if (prevflp == NULL)
4820                                         LIST_INSERT_HEAD(flhp, flp, nfsfl_list);
4821                                 else
4822                                         LIST_INSERT_AFTER(prevflp, flp,
4823                                             nfsfl_list);
4824                         } else {
4825                                 printf("nfscl_layoutget(): got wrong iomode\n");
4826                                 nfscl_freeflayout(flp);
4827                         }
4828                         flp = NULL;
4829                 }
4830         }
4831         if (nd->nd_repstat != 0 && error == 0)
4832                 error = nd->nd_repstat;
4833 nfsmout:
4834         if (error != 0 && flp != NULL)
4835                 nfscl_freeflayout(flp);
4836         mbuf_freem(nd->nd_mrep);
4837         return (error);
4838 }
4839
4840 /*
4841  * Do the NFSv4.1 Get Device Info.
4842  */
4843 int
4844 nfsrpc_getdeviceinfo(struct nfsmount *nmp, uint8_t *deviceid, int layouttype,
4845     uint32_t *notifybitsp, struct nfscldevinfo **ndip, struct ucred *cred,
4846     NFSPROC_T *p)
4847 {
4848         uint32_t cnt, *tl;
4849         struct nfsrv_descript nfsd;
4850         struct nfsrv_descript *nd = &nfsd;
4851         struct sockaddr_storage ss;
4852         struct nfsclds *dsp = NULL, **dspp;
4853         struct nfscldevinfo *ndi;
4854         int addrcnt, bitcnt, error, i, isudp, j, pos, safilled, stripecnt;
4855         uint8_t stripeindex;
4856
4857         *ndip = NULL;
4858         ndi = NULL;
4859         nfscl_reqstart(nd, NFSPROC_GETDEVICEINFO, nmp, NULL, 0, NULL, NULL);
4860         NFSM_BUILD(tl, uint32_t *, NFSX_V4DEVICEID + 3 * NFSX_UNSIGNED);
4861         NFSBCOPY(deviceid, tl, NFSX_V4DEVICEID);
4862         tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
4863         *tl++ = txdr_unsigned(layouttype);
4864         *tl++ = txdr_unsigned(100000);
4865         if (notifybitsp != NULL && *notifybitsp != 0) {
4866                 *tl = txdr_unsigned(1);         /* One word of bits. */
4867                 NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
4868                 *tl = txdr_unsigned(*notifybitsp);
4869         } else
4870                 *tl = txdr_unsigned(0);
4871         nd->nd_flag |= ND_USEGSSNAME;
4872         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4873             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4874         if (error != 0)
4875                 return (error);
4876         if (nd->nd_repstat == 0) {
4877                 NFSM_DISSECT(tl, uint32_t *, 3 * NFSX_UNSIGNED);
4878                 if (layouttype != fxdr_unsigned(int, *tl++))
4879                         printf("EEK! devinfo layout type not same!\n");
4880                 stripecnt = fxdr_unsigned(int, *++tl);
4881                 NFSCL_DEBUG(4, "stripecnt=%d\n", stripecnt);
4882                 if (stripecnt < 1 || stripecnt > 4096) {
4883                         printf("NFS devinfo stripecnt %d: out of range\n",
4884                             stripecnt);
4885                         error = NFSERR_BADXDR;
4886                         goto nfsmout;
4887                 }
4888                 NFSM_DISSECT(tl, uint32_t *, (stripecnt + 1) * NFSX_UNSIGNED);
4889                 addrcnt = fxdr_unsigned(int, *(tl + stripecnt));
4890                 NFSCL_DEBUG(4, "addrcnt=%d\n", addrcnt);
4891                 if (addrcnt < 1 || addrcnt > 128) {
4892                         printf("NFS devinfo addrcnt %d: out of range\n",
4893                             addrcnt);
4894                         error = NFSERR_BADXDR;
4895                         goto nfsmout;
4896                 }
4897
4898                 /*
4899                  * Now we know how many stripe indices and addresses, so
4900                  * we can allocate the structure the correct size.
4901                  */
4902                 i = (stripecnt * sizeof(uint8_t)) / sizeof(struct nfsclds *)
4903                     + 1;
4904                 NFSCL_DEBUG(4, "stripeindices=%d\n", i);
4905                 ndi = malloc(sizeof(*ndi) + (addrcnt + i) *
4906                     sizeof(struct nfsclds *), M_NFSDEVINFO, M_WAITOK | M_ZERO);
4907                 NFSBCOPY(deviceid, ndi->nfsdi_deviceid, NFSX_V4DEVICEID);
4908                 ndi->nfsdi_refcnt = 0;
4909                 ndi->nfsdi_stripecnt = stripecnt;
4910                 ndi->nfsdi_addrcnt = addrcnt;
4911                 /* Fill in the stripe indices. */
4912                 for (i = 0; i < stripecnt; i++) {
4913                         stripeindex = fxdr_unsigned(uint8_t, *tl++);
4914                         NFSCL_DEBUG(4, "stripeind=%d\n", stripeindex);
4915                         if (stripeindex >= addrcnt) {
4916                                 printf("NFS devinfo stripeindex %d: too big\n",
4917                                     (int)stripeindex);
4918                                 error = NFSERR_BADXDR;
4919                                 goto nfsmout;
4920                         }
4921                         nfsfldi_setstripeindex(ndi, i, stripeindex);
4922                 }
4923
4924                 /* Now, dissect the server address(es). */
4925                 safilled = 0;
4926                 for (i = 0; i < addrcnt; i++) {
4927                         NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
4928                         cnt = fxdr_unsigned(uint32_t, *tl);
4929                         if (cnt == 0) {
4930                                 printf("NFS devinfo 0 len addrlist\n");
4931                                 error = NFSERR_BADXDR;
4932                                 goto nfsmout;
4933                         }
4934                         dspp = nfsfldi_addr(ndi, i);
4935                         pos = arc4random() % cnt;       /* Choose one. */
4936                         safilled = 0;
4937                         for (j = 0; j < cnt; j++) {
4938                                 error = nfsv4_getipaddr(nd, &ss, &isudp);
4939                                 if (error != 0 && error != EPERM) {
4940                                         error = NFSERR_BADXDR;
4941                                         goto nfsmout;
4942                                 }
4943                                 if (error == 0 && isudp == 0) {
4944                                         /*
4945                                          * The algorithm is:
4946                                          * - use "pos" entry if it is of the
4947                                          *   same af_family or none of them
4948                                          *   is of the same af_family
4949                                          * else
4950                                          * - use the first one of the same
4951                                          *   af_family.
4952                                          */
4953                                         if ((safilled == 0 && ss.ss_family ==
4954                                              nmp->nm_nam->sa_family) ||
4955                                             (j == pos &&
4956                                              (safilled == 0 || ss.ss_family ==
4957                                               nmp->nm_nam->sa_family)) ||
4958                                             (safilled == 1 && ss.ss_family ==
4959                                              nmp->nm_nam->sa_family)) {
4960                                                 error = nfsrpc_fillsa(nmp, &ss,
4961                                                     &dsp, p);
4962                                                 if (error == 0) {
4963                                                         *dspp = dsp;
4964                                                         if (ss.ss_family ==
4965                                                          nmp->nm_nam->sa_family)
4966                                                                 safilled = 2;
4967                                                         else
4968                                                                 safilled = 1;
4969                                                 }
4970                                         }
4971                                 }
4972                         }
4973                         if (safilled == 0)
4974                                 break;
4975                 }
4976
4977                 /* And the notify bits. */
4978                 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
4979                 if (safilled != 0) {
4980                         bitcnt = fxdr_unsigned(int, *tl);
4981                         if (bitcnt > 0) {
4982                                 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
4983                                 if (notifybitsp != NULL)
4984                                         *notifybitsp =
4985                                             fxdr_unsigned(uint32_t, *tl);
4986                         }
4987                         *ndip = ndi;
4988                 } else
4989                         error = EPERM;
4990         }
4991         if (nd->nd_repstat != 0)
4992                 error = nd->nd_repstat;
4993 nfsmout:
4994         if (error != 0 && ndi != NULL)
4995                 nfscl_freedevinfo(ndi);
4996         mbuf_freem(nd->nd_mrep);
4997         return (error);
4998 }
4999
5000 /*
5001  * Do the NFSv4.1 LayoutCommit.
5002  */
5003 int
5004 nfsrpc_layoutcommit(struct nfsmount *nmp, uint8_t *fh, int fhlen, int reclaim,
5005     uint64_t off, uint64_t len, uint64_t lastbyte, nfsv4stateid_t *stateidp,
5006     int layouttype, int layoutupdatecnt, uint8_t *layp, struct ucred *cred,
5007     NFSPROC_T *p, void *stuff)
5008 {
5009         uint32_t *tl;
5010         struct nfsrv_descript nfsd, *nd = &nfsd;
5011         int error, outcnt, i;
5012         uint8_t *cp;
5013
5014         nfscl_reqstart(nd, NFSPROC_LAYOUTCOMMIT, nmp, fh, fhlen, NULL, NULL);
5015         NFSM_BUILD(tl, uint32_t *, 5 * NFSX_UNSIGNED + 3 * NFSX_HYPER +
5016             NFSX_STATEID);
5017         txdr_hyper(off, tl);
5018         tl += 2;
5019         txdr_hyper(len, tl);
5020         tl += 2;
5021         if (reclaim != 0)
5022                 *tl++ = newnfs_true;
5023         else
5024                 *tl++ = newnfs_false;
5025         *tl++ = txdr_unsigned(stateidp->seqid);
5026         *tl++ = stateidp->other[0];
5027         *tl++ = stateidp->other[1];
5028         *tl++ = stateidp->other[2];
5029         *tl++ = newnfs_true;
5030         if (lastbyte < off)
5031                 lastbyte = off;
5032         else if (lastbyte >= (off + len))
5033                 lastbyte = off + len - 1;
5034         txdr_hyper(lastbyte, tl);
5035         tl += 2;
5036         *tl++ = newnfs_false;
5037         *tl++ = txdr_unsigned(layouttype);
5038         *tl = txdr_unsigned(layoutupdatecnt);
5039         if (layoutupdatecnt > 0) {
5040                 KASSERT(layouttype != NFSLAYOUT_NFSV4_1_FILES,
5041                     ("Must be nil for Files Layout"));
5042                 outcnt = NFSM_RNDUP(layoutupdatecnt);
5043                 NFSM_BUILD(cp, uint8_t *, outcnt);
5044                 NFSBCOPY(layp, cp, layoutupdatecnt);
5045                 cp += layoutupdatecnt;
5046                 for (i = 0; i < (outcnt - layoutupdatecnt); i++)
5047                         *cp++ = 0x0;
5048         }
5049         nd->nd_flag |= ND_USEGSSNAME;
5050         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5051             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5052         if (error != 0)
5053                 return (error);
5054         error = nd->nd_repstat;
5055         mbuf_freem(nd->nd_mrep);
5056         return (error);
5057 }
5058
5059 /*
5060  * Do the NFSv4.1 LayoutReturn.
5061  */
5062 int
5063 nfsrpc_layoutreturn(struct nfsmount *nmp, uint8_t *fh, int fhlen, int reclaim,
5064     int layouttype, uint32_t iomode, int layoutreturn, uint64_t offset,
5065     uint64_t len, nfsv4stateid_t *stateidp, int layoutcnt, uint32_t *layp,
5066     struct ucred *cred, NFSPROC_T *p, void *stuff)
5067 {
5068         uint32_t *tl;
5069         struct nfsrv_descript nfsd, *nd = &nfsd;
5070         int error, outcnt, i;
5071         uint8_t *cp;
5072
5073         nfscl_reqstart(nd, NFSPROC_LAYOUTRETURN, nmp, fh, fhlen, NULL, NULL);
5074         NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
5075         if (reclaim != 0)
5076                 *tl++ = newnfs_true;
5077         else
5078                 *tl++ = newnfs_false;
5079         *tl++ = txdr_unsigned(layouttype);
5080         *tl++ = txdr_unsigned(iomode);
5081         *tl = txdr_unsigned(layoutreturn);
5082         if (layoutreturn == NFSLAYOUTRETURN_FILE) {
5083                 NFSM_BUILD(tl, uint32_t *, 2 * NFSX_HYPER + NFSX_STATEID +
5084                     NFSX_UNSIGNED);
5085                 txdr_hyper(offset, tl);
5086                 tl += 2;
5087                 txdr_hyper(len, tl);
5088                 tl += 2;
5089                 NFSCL_DEBUG(4, "layoutret stseq=%d\n", (int)stateidp->seqid);
5090                 *tl++ = txdr_unsigned(stateidp->seqid);
5091                 *tl++ = stateidp->other[0];
5092                 *tl++ = stateidp->other[1];
5093                 *tl++ = stateidp->other[2];
5094                 *tl = txdr_unsigned(layoutcnt);
5095                 if (layoutcnt > 0) {
5096                         outcnt = NFSM_RNDUP(layoutcnt);
5097                         NFSM_BUILD(cp, uint8_t *, outcnt);
5098                         NFSBCOPY(layp, cp, layoutcnt);
5099                         cp += layoutcnt;
5100                         for (i = 0; i < (outcnt - layoutcnt); i++)
5101                                 *cp++ = 0x0;
5102                 }
5103         }
5104         nd->nd_flag |= ND_USEGSSNAME;
5105         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5106             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5107         if (error != 0)
5108                 return (error);
5109         if (nd->nd_repstat == 0) {
5110                 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5111                 if (*tl != 0) {
5112                         NFSM_DISSECT(tl, uint32_t *, NFSX_STATEID);
5113                         stateidp->seqid = fxdr_unsigned(uint32_t, *tl++);
5114                         stateidp->other[0] = *tl++;
5115                         stateidp->other[1] = *tl++;
5116                         stateidp->other[2] = *tl;
5117                 }
5118         } else
5119                 error = nd->nd_repstat;
5120 nfsmout:
5121         mbuf_freem(nd->nd_mrep);
5122         return (error);
5123 }
5124
5125 /*
5126  * Acquire a layout and devinfo, if possible. The caller must have acquired
5127  * a reference count on the nfsclclient structure before calling this.
5128  * Return the layout in lypp with a reference count on it, if successful.
5129  */
5130 static int
5131 nfsrpc_getlayout(struct nfsmount *nmp, vnode_t vp, struct nfsfh *nfhp,
5132     int iomode, uint32_t *notifybitsp, nfsv4stateid_t *stateidp, uint64_t off,
5133     struct nfscllayout **lypp, struct ucred *cred, NFSPROC_T *p)
5134 {
5135         struct nfscllayout *lyp;
5136         struct nfsclflayout *flp, *tflp;
5137         struct nfscldevinfo *dip;
5138         struct nfsclflayouthead flh;
5139         int error = 0, islocked, layoutlen, recalled, retonclose;
5140         nfsv4stateid_t stateid;
5141
5142         *lypp = NULL;
5143         /*
5144          * If lyp is returned non-NULL, there will be a refcnt (shared lock)
5145          * on it, iff flp != NULL or a lock (exclusive lock) on it iff
5146          * flp == NULL.
5147          */
5148         lyp = nfscl_getlayout(nmp->nm_clp, nfhp->nfh_fh, nfhp->nfh_len,
5149             off, &flp, &recalled);
5150         islocked = 0;
5151         if (lyp == NULL || flp == NULL) {
5152                 if (recalled != 0)
5153                         return (EIO);
5154                 LIST_INIT(&flh);
5155                 layoutlen = NFSMNT_MDSSESSION(nmp)->nfsess_maxcache -
5156                     (NFSX_STATEID + 3 * NFSX_UNSIGNED);
5157                 if (lyp == NULL) {
5158                         stateid.seqid = 0;
5159                         stateid.other[0] = stateidp->other[0];
5160                         stateid.other[1] = stateidp->other[1];
5161                         stateid.other[2] = stateidp->other[2];
5162                         error = nfsrpc_layoutget(nmp, nfhp->nfh_fh,
5163                             nfhp->nfh_len, iomode, (uint64_t)0, INT64_MAX,
5164                             (uint64_t)0, layoutlen, &stateid, &retonclose,
5165                             &flh, cred, p, NULL);
5166                 } else {
5167                         islocked = 1;
5168                         stateid.seqid = lyp->nfsly_stateid.seqid;
5169                         stateid.other[0] = lyp->nfsly_stateid.other[0];
5170                         stateid.other[1] = lyp->nfsly_stateid.other[1];
5171                         stateid.other[2] = lyp->nfsly_stateid.other[2];
5172                         error = nfsrpc_layoutget(nmp, nfhp->nfh_fh,
5173                             nfhp->nfh_len, iomode, off, INT64_MAX,
5174                             (uint64_t)0, layoutlen, &stateid, &retonclose,
5175                             &flh, cred, p, NULL);
5176                 }
5177                 if (error == 0)
5178                         LIST_FOREACH(tflp, &flh, nfsfl_list) {
5179                                 error = nfscl_adddevinfo(nmp, NULL, tflp);
5180                                 if (error != 0) {
5181                                         error = nfsrpc_getdeviceinfo(nmp,
5182                                             tflp->nfsfl_dev,
5183                                             NFSLAYOUT_NFSV4_1_FILES,
5184                                             notifybitsp, &dip, cred, p);
5185                                         if (error != 0)
5186                                                 break;
5187                                         error = nfscl_adddevinfo(nmp, dip,
5188                                             tflp);
5189                                         if (error != 0)
5190                                                 printf(
5191                                                     "getlayout: cannot add\n");
5192                                 }
5193                         }
5194                 if (error == 0) {
5195                         /*
5196                          * nfscl_layout() always returns with the nfsly_lock
5197                          * set to a refcnt (shared lock).
5198                          */
5199                         error = nfscl_layout(nmp, vp, nfhp->nfh_fh,
5200                             nfhp->nfh_len, &stateid, retonclose, &flh, &lyp,
5201                             cred, p);
5202                         if (error == 0)
5203                                 *lypp = lyp;
5204                 } else if (islocked != 0)
5205                         nfsv4_unlock(&lyp->nfsly_lock, 0);
5206         } else
5207                 *lypp = lyp;
5208         return (error);
5209 }
5210
5211 /*
5212  * Do a TCP connection plus exchange id and create session.
5213  * If successful, a "struct nfsclds" is linked into the list for the
5214  * mount point and a pointer to it is returned.
5215  */
5216 static int
5217 nfsrpc_fillsa(struct nfsmount *nmp, struct sockaddr_storage *ssp,
5218     struct nfsclds **dspp, NFSPROC_T *p)
5219 {
5220         struct sockaddr_in *msad, *sad, *ssd;
5221         struct sockaddr_in6 *msad6, *sad6, *ssd6;
5222         struct nfsclclient *clp;
5223         struct nfssockreq *nrp;
5224         struct nfsclds *dsp, *tdsp;
5225         int error;
5226         enum nfsclds_state retv;
5227         uint32_t sequenceid;
5228
5229         KASSERT(nmp->nm_sockreq.nr_cred != NULL,
5230             ("nfsrpc_fillsa: NULL nr_cred"));
5231         NFSLOCKCLSTATE();
5232         clp = nmp->nm_clp;
5233         NFSUNLOCKCLSTATE();
5234         if (clp == NULL)
5235                 return (EPERM);
5236         if (ssp->ss_family == AF_INET) {
5237                 ssd = (struct sockaddr_in *)ssp;
5238                 NFSLOCKMNT(nmp);
5239
5240                 /*
5241                  * Check to see if we already have a session for this
5242                  * address that is usable for a DS.
5243                  * Note that the MDS's address is in a different place
5244                  * than the sessions already acquired for DS's.
5245                  */
5246                 msad = (struct sockaddr_in *)nmp->nm_sockreq.nr_nam;
5247                 tdsp = TAILQ_FIRST(&nmp->nm_sess);
5248                 while (tdsp != NULL) {
5249                         if (msad != NULL && msad->sin_family == AF_INET &&
5250                             ssd->sin_addr.s_addr == msad->sin_addr.s_addr &&
5251                             ssd->sin_port == msad->sin_port &&
5252                             (tdsp->nfsclds_flags & NFSCLDS_DS) != 0) {
5253                                 *dspp = tdsp;
5254                                 NFSUNLOCKMNT(nmp);
5255                                 NFSCL_DEBUG(4, "fnd same addr\n");
5256                                 return (0);
5257                         }
5258                         tdsp = TAILQ_NEXT(tdsp, nfsclds_list);
5259                         if (tdsp != NULL && tdsp->nfsclds_sockp != NULL)
5260                                 msad = (struct sockaddr_in *)
5261                                     tdsp->nfsclds_sockp->nr_nam;
5262                         else
5263                                 msad = NULL;
5264                 }
5265                 NFSUNLOCKMNT(nmp);
5266
5267                 /* No IP address match, so look for new/trunked one. */
5268                 sad = malloc(sizeof(*sad), M_SONAME, M_WAITOK | M_ZERO);
5269                 sad->sin_len = sizeof(*sad);
5270                 sad->sin_family = AF_INET;
5271                 sad->sin_port = ssd->sin_port;
5272                 sad->sin_addr.s_addr = ssd->sin_addr.s_addr;
5273                 nrp = malloc(sizeof(*nrp), M_NFSSOCKREQ, M_WAITOK | M_ZERO);
5274                 nrp->nr_nam = (struct sockaddr *)sad;
5275         } else if (ssp->ss_family == AF_INET6) {
5276                 ssd6 = (struct sockaddr_in6 *)ssp;
5277                 NFSLOCKMNT(nmp);
5278
5279                 /*
5280                  * Check to see if we already have a session for this
5281                  * address that is usable for a DS.
5282                  * Note that the MDS's address is in a different place
5283                  * than the sessions already acquired for DS's.
5284                  */
5285                 msad6 = (struct sockaddr_in6 *)nmp->nm_sockreq.nr_nam;
5286                 tdsp = TAILQ_FIRST(&nmp->nm_sess);
5287                 while (tdsp != NULL) {
5288                         if (msad6 != NULL && msad6->sin6_family == AF_INET6 &&
5289                             IN6_ARE_ADDR_EQUAL(&ssd6->sin6_addr,
5290                             &msad6->sin6_addr) &&
5291                             ssd6->sin6_port == msad6->sin6_port &&
5292                             (tdsp->nfsclds_flags & NFSCLDS_DS) != 0) {
5293                                 *dspp = tdsp;
5294                                 NFSUNLOCKMNT(nmp);
5295                                 return (0);
5296                         }
5297                         tdsp = TAILQ_NEXT(tdsp, nfsclds_list);
5298                         if (tdsp != NULL && tdsp->nfsclds_sockp != NULL)
5299                                 msad6 = (struct sockaddr_in6 *)
5300                                     tdsp->nfsclds_sockp->nr_nam;
5301                         else
5302                                 msad6 = NULL;
5303                 }
5304                 NFSUNLOCKMNT(nmp);
5305
5306                 /* No IP address match, so look for new/trunked one. */
5307                 sad6 = malloc(sizeof(*sad6), M_SONAME, M_WAITOK | M_ZERO);
5308                 sad6->sin6_len = sizeof(*sad6);
5309                 sad6->sin6_family = AF_INET6;
5310                 sad6->sin6_port = ssd6->sin6_port;
5311                 NFSBCOPY(&ssd6->sin6_addr, &sad6->sin6_addr,
5312                     sizeof(struct in6_addr));
5313                 nrp = malloc(sizeof(*nrp), M_NFSSOCKREQ, M_WAITOK | M_ZERO);
5314                 nrp->nr_nam = (struct sockaddr *)sad6;
5315         } else
5316                 return (EPERM);
5317
5318         nrp->nr_sotype = SOCK_STREAM;
5319         mtx_init(&nrp->nr_mtx, "nfssock", NULL, MTX_DEF);
5320         nrp->nr_prog = NFS_PROG;
5321         nrp->nr_vers = NFS_VER4;
5322
5323         /*
5324          * Use the credentials that were used for the mount, which are
5325          * in nmp->nm_sockreq.nr_cred for newnfs_connect() etc.
5326          * Ref. counting the credentials with crhold() is probably not
5327          * necessary, since nm_sockreq.nr_cred won't be crfree()'d until
5328          * unmount, but I did it anyhow.
5329          */
5330         nrp->nr_cred = crhold(nmp->nm_sockreq.nr_cred);
5331         error = newnfs_connect(nmp, nrp, NULL, p, 0);
5332         NFSCL_DEBUG(3, "DS connect=%d\n", error);
5333
5334         /* Now, do the exchangeid and create session. */
5335         if (error == 0)
5336                 error = nfsrpc_exchangeid(nmp, clp, nrp, NFSV4EXCH_USEPNFSDS,
5337                     &dsp, nrp->nr_cred, p);
5338         NFSCL_DEBUG(3, "DS exchangeid=%d\n", error);
5339         if (error == 0) {
5340                 dsp->nfsclds_sockp = nrp;
5341                 NFSLOCKMNT(nmp);
5342                 retv = nfscl_getsameserver(nmp, dsp, &tdsp);
5343                 NFSCL_DEBUG(3, "getsame ret=%d\n", retv);
5344                 if (retv == NFSDSP_USETHISSESSION) {
5345                         NFSUNLOCKMNT(nmp);
5346                         /*
5347                          * If there is already a session for this server,
5348                          * use it.
5349                          */
5350                         (void)newnfs_disconnect(nrp);
5351                         nfscl_freenfsclds(dsp);
5352                         *dspp = tdsp;
5353                         return (0);
5354                 }
5355                 if (retv == NFSDSP_SEQTHISSESSION)
5356                         sequenceid = tdsp->nfsclds_sess.nfsess_sequenceid;
5357                 else
5358                         sequenceid = dsp->nfsclds_sess.nfsess_sequenceid;
5359                 NFSUNLOCKMNT(nmp);
5360                 error = nfsrpc_createsession(nmp, &dsp->nfsclds_sess,
5361                     nrp, sequenceid, 0, nrp->nr_cred, p);
5362                 NFSCL_DEBUG(3, "DS createsess=%d\n", error);
5363         } else {
5364                 NFSFREECRED(nrp->nr_cred);
5365                 NFSFREEMUTEX(&nrp->nr_mtx);
5366                 free(nrp->nr_nam, M_SONAME);
5367                 free(nrp, M_NFSSOCKREQ);
5368         }
5369         if (error == 0) {
5370                 NFSCL_DEBUG(3, "add DS session\n");
5371                 /*
5372                  * Put it at the end of the list. That way the list
5373                  * is ordered by when the entry was added. This matters
5374                  * since the one done first is the one that should be
5375                  * used for sequencid'ing any subsequent create sessions.
5376                  */
5377                 NFSLOCKMNT(nmp);
5378                 TAILQ_INSERT_TAIL(&nmp->nm_sess, dsp, nfsclds_list);
5379                 NFSUNLOCKMNT(nmp);
5380                 *dspp = dsp;
5381         } else if (dsp != NULL)
5382                 nfscl_freenfsclds(dsp);
5383         return (error);
5384 }
5385
5386 /*
5387  * Do the NFSv4.1 Reclaim Complete.
5388  */
5389 int
5390 nfsrpc_reclaimcomplete(struct nfsmount *nmp, struct ucred *cred, NFSPROC_T *p)
5391 {
5392         uint32_t *tl;
5393         struct nfsrv_descript nfsd;
5394         struct nfsrv_descript *nd = &nfsd;
5395         int error;
5396
5397         nfscl_reqstart(nd, NFSPROC_RECLAIMCOMPL, nmp, NULL, 0, NULL, NULL);
5398         NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
5399         *tl = newnfs_false;
5400         nd->nd_flag |= ND_USEGSSNAME;
5401         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5402             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5403         if (error != 0)
5404                 return (error);
5405         error = nd->nd_repstat;
5406         mbuf_freem(nd->nd_mrep);
5407         return (error);
5408 }
5409
5410 /*
5411  * Initialize the slot tables for a session.
5412  */
5413 static void
5414 nfscl_initsessionslots(struct nfsclsession *sep)
5415 {
5416         int i;
5417
5418         for (i = 0; i < NFSV4_CBSLOTS; i++) {
5419                 if (sep->nfsess_cbslots[i].nfssl_reply != NULL)
5420                         m_freem(sep->nfsess_cbslots[i].nfssl_reply);
5421                 NFSBZERO(&sep->nfsess_cbslots[i], sizeof(struct nfsslot));
5422         }
5423         for (i = 0; i < 64; i++)
5424                 sep->nfsess_slotseq[i] = 0;
5425         sep->nfsess_slots = 0;
5426 }
5427
5428 /*
5429  * Called to try and do an I/O operation via an NFSv4.1 Data Server (DS).
5430  */
5431 int
5432 nfscl_doiods(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
5433     uint32_t rwaccess, struct ucred *cred, NFSPROC_T *p)
5434 {
5435         struct nfsnode *np = VTONFS(vp);
5436         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5437         struct nfscllayout *layp;
5438         struct nfscldevinfo *dip;
5439         struct nfsclflayout *rflp;
5440         nfsv4stateid_t stateid;
5441         struct ucred *newcred;
5442         uint64_t lastbyte, len, off, oresid, xfer;
5443         int eof, error, iolaymode, recalled;
5444         void *lckp;
5445
5446         if (!NFSHASPNFS(nmp) || nfscl_enablecallb == 0 || nfs_numnfscbd == 0 ||
5447             (np->n_flag & NNOLAYOUT) != 0)
5448                 return (EIO);
5449         /* Now, get a reference cnt on the clientid for this mount. */
5450         if (nfscl_getref(nmp) == 0)
5451                 return (EIO);
5452
5453         /* Find an appropriate stateid. */
5454         newcred = NFSNEWCRED(cred);
5455         error = nfscl_getstateid(vp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
5456             rwaccess, 1, newcred, p, &stateid, &lckp);
5457         if (error != 0) {
5458                 NFSFREECRED(newcred);
5459                 nfscl_relref(nmp);
5460                 return (error);
5461         }
5462         /* Search for a layout for this file. */
5463         off = uiop->uio_offset;
5464         layp = nfscl_getlayout(nmp->nm_clp, np->n_fhp->nfh_fh,
5465             np->n_fhp->nfh_len, off, &rflp, &recalled);
5466         if (layp == NULL || rflp == NULL) {
5467                 if (recalled != 0) {
5468                         NFSFREECRED(newcred);
5469                         nfscl_relref(nmp);
5470                         return (EIO);
5471                 }
5472                 if (layp != NULL) {
5473                         nfscl_rellayout(layp, (rflp == NULL) ? 1 : 0);
5474                         layp = NULL;
5475                 }
5476                 /* Try and get a Layout, if it is supported. */
5477                 if (rwaccess == NFSV4OPEN_ACCESSWRITE ||
5478                     (np->n_flag & NWRITEOPENED) != 0)
5479                         iolaymode = NFSLAYOUTIOMODE_RW;
5480                 else
5481                         iolaymode = NFSLAYOUTIOMODE_READ;
5482                 error = nfsrpc_getlayout(nmp, vp, np->n_fhp, iolaymode,
5483                     NULL, &stateid, off, &layp, newcred, p);
5484                 if (error != 0) {
5485                         NFSLOCKNODE(np);
5486                         np->n_flag |= NNOLAYOUT;
5487                         NFSUNLOCKNODE(np);
5488                         if (lckp != NULL)
5489                                 nfscl_lockderef(lckp);
5490                         NFSFREECRED(newcred);
5491                         if (layp != NULL)
5492                                 nfscl_rellayout(layp, 0);
5493                         nfscl_relref(nmp);
5494                         return (error);
5495                 }
5496         }
5497
5498         /*
5499          * Loop around finding a layout that works for the first part of
5500          * this I/O operation, and then call the function that actually
5501          * does the RPC.
5502          */
5503         eof = 0;
5504         len = (uint64_t)uiop->uio_resid;
5505         while (len > 0 && error == 0 && eof == 0) {
5506                 off = uiop->uio_offset;
5507                 error = nfscl_findlayoutforio(layp, off, rwaccess, &rflp);
5508                 if (error == 0) {
5509                         oresid = xfer = (uint64_t)uiop->uio_resid;
5510                         if (xfer > (rflp->nfsfl_end - rflp->nfsfl_off))
5511                                 xfer = rflp->nfsfl_end - rflp->nfsfl_off;
5512                         dip = nfscl_getdevinfo(nmp->nm_clp, rflp->nfsfl_dev,
5513                             rflp->nfsfl_devp);
5514                         if (dip != NULL) {
5515                                 error = nfscl_doflayoutio(vp, uiop, iomode,
5516                                     must_commit, &eof, &stateid, rwaccess, dip,
5517                                     layp, rflp, off, xfer, newcred, p);
5518                                 nfscl_reldevinfo(dip);
5519                                 lastbyte = off + xfer - 1;
5520                                 if (error == 0) {
5521                                         NFSLOCKCLSTATE();
5522                                         if (lastbyte > layp->nfsly_lastbyte)
5523                                                 layp->nfsly_lastbyte = lastbyte;
5524                                         NFSUNLOCKCLSTATE();
5525                                 }
5526                         } else
5527                                 error = EIO;
5528                         if (error == 0)
5529                                 len -= (oresid - (uint64_t)uiop->uio_resid);
5530                 }
5531         }
5532         if (lckp != NULL)
5533                 nfscl_lockderef(lckp);
5534         NFSFREECRED(newcred);
5535         nfscl_rellayout(layp, 0);
5536         nfscl_relref(nmp);
5537         return (error);
5538 }
5539
5540 /*
5541  * Find a file layout that will handle the first bytes of the requested
5542  * range and return the information from it needed to to the I/O operation.
5543  */
5544 int
5545 nfscl_findlayoutforio(struct nfscllayout *lyp, uint64_t off, uint32_t rwaccess,
5546     struct nfsclflayout **retflpp)
5547 {
5548         struct nfsclflayout *flp, *nflp, *rflp;
5549         uint32_t rw;
5550
5551         rflp = NULL;
5552         rw = rwaccess;
5553         /* For reading, do the Read list first and then the Write list. */
5554         do {
5555                 if (rw == NFSV4OPEN_ACCESSREAD)
5556                         flp = LIST_FIRST(&lyp->nfsly_flayread);
5557                 else
5558                         flp = LIST_FIRST(&lyp->nfsly_flayrw);
5559                 while (flp != NULL) {
5560                         nflp = LIST_NEXT(flp, nfsfl_list);
5561                         if (flp->nfsfl_off > off)
5562                                 break;
5563                         if (flp->nfsfl_end > off &&
5564                             (rflp == NULL || rflp->nfsfl_end < flp->nfsfl_end))
5565                                 rflp = flp;
5566                         flp = nflp;
5567                 }
5568                 if (rw == NFSV4OPEN_ACCESSREAD)
5569                         rw = NFSV4OPEN_ACCESSWRITE;
5570                 else
5571                         rw = 0;
5572         } while (rw != 0);
5573         if (rflp != NULL) {
5574                 /* This one covers the most bytes starting at off. */
5575                 *retflpp = rflp;
5576                 return (0);
5577         }
5578         return (EIO);
5579 }
5580
5581 /*
5582  * Do I/O using an NFSv4.1 file layout.
5583  */
5584 static int
5585 nfscl_doflayoutio(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
5586     int *eofp, nfsv4stateid_t *stateidp, int rwflag, struct nfscldevinfo *dp,
5587     struct nfscllayout *lyp, struct nfsclflayout *flp, uint64_t off,
5588     uint64_t len, struct ucred *cred, NFSPROC_T *p)
5589 {
5590         uint64_t io_off, rel_off, stripe_unit_size, transfer, xfer;
5591         int commit_thru_mds, error = 0, stripe_index, stripe_pos;
5592         struct nfsnode *np;
5593         struct nfsfh *fhp;
5594         struct nfsclds **dspp;
5595
5596         np = VTONFS(vp);
5597         rel_off = off - flp->nfsfl_patoff;
5598         stripe_unit_size = (flp->nfsfl_util >> 6) & 0x3ffffff;
5599         stripe_pos = (rel_off / stripe_unit_size + flp->nfsfl_stripe1) %
5600             dp->nfsdi_stripecnt;
5601         transfer = stripe_unit_size - (rel_off % stripe_unit_size);
5602
5603         /* Loop around, doing I/O for each stripe unit. */
5604         while (len > 0 && error == 0) {
5605                 stripe_index = nfsfldi_stripeindex(dp, stripe_pos);
5606                 dspp = nfsfldi_addr(dp, stripe_index);
5607                 if (len > transfer)
5608                         xfer = transfer;
5609                 else
5610                         xfer = len;
5611                 if ((flp->nfsfl_util & NFSFLAYUTIL_DENSE) != 0) {
5612                         /* Dense layout. */
5613                         if (stripe_pos >= flp->nfsfl_fhcnt)
5614                                 return (EIO);
5615                         fhp = flp->nfsfl_fh[stripe_pos];
5616                         io_off = (rel_off / (stripe_unit_size *
5617                             dp->nfsdi_stripecnt)) * stripe_unit_size +
5618                             rel_off % stripe_unit_size;
5619                 } else {
5620                         /* Sparse layout. */
5621                         if (flp->nfsfl_fhcnt > 1) {
5622                                 if (stripe_index >= flp->nfsfl_fhcnt)
5623                                         return (EIO);
5624                                 fhp = flp->nfsfl_fh[stripe_index];
5625                         } else if (flp->nfsfl_fhcnt == 1)
5626                                 fhp = flp->nfsfl_fh[0];
5627                         else
5628                                 fhp = np->n_fhp;
5629                         io_off = off;
5630                 }
5631                 if ((flp->nfsfl_util & NFSFLAYUTIL_COMMIT_THRU_MDS) != 0)
5632                         commit_thru_mds = 1;
5633                 else
5634                         commit_thru_mds = 0;
5635                 if (rwflag == FREAD)
5636                         error = nfsrpc_readds(vp, uiop, stateidp, eofp, *dspp,
5637                             io_off, xfer, fhp, cred, p);
5638                 else {
5639                         error = nfsrpc_writeds(vp, uiop, iomode, must_commit,
5640                             stateidp, *dspp, io_off, xfer, fhp, commit_thru_mds,
5641                             cred, p);
5642                         if (error == 0) {
5643                                 NFSLOCKCLSTATE();
5644                                 lyp->nfsly_flags |= NFSLY_WRITTEN;
5645                                 NFSUNLOCKCLSTATE();
5646                         }
5647                 }
5648                 if (error == 0) {
5649                         transfer = stripe_unit_size;
5650                         stripe_pos = (stripe_pos + 1) % dp->nfsdi_stripecnt;
5651                         len -= xfer;
5652                         off += xfer;
5653                 }
5654         }
5655         return (error);
5656 }
5657
5658 /*
5659  * The actual read RPC done to a DS.
5660  */
5661 static int
5662 nfsrpc_readds(vnode_t vp, struct uio *uiop, nfsv4stateid_t *stateidp, int *eofp,
5663     struct nfsclds *dsp, uint64_t io_off, int len, struct nfsfh *fhp,
5664     struct ucred *cred, NFSPROC_T *p)
5665 {
5666         uint32_t *tl;
5667         int error, retlen;
5668         struct nfsrv_descript nfsd;
5669         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5670         struct nfsrv_descript *nd = &nfsd;
5671         struct nfssockreq *nrp;
5672
5673         nd->nd_mrep = NULL;
5674         nfscl_reqstart(nd, NFSPROC_READDS, nmp, fhp->nfh_fh, fhp->nfh_len,
5675             NULL, &dsp->nfsclds_sess);
5676         nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSEQIDZERO);
5677         NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED * 3);
5678         txdr_hyper(io_off, tl);
5679         *(tl + 2) = txdr_unsigned(len);
5680         nrp = dsp->nfsclds_sockp;
5681         if (nrp == NULL)
5682                 /* If NULL, use the MDS socket. */
5683                 nrp = &nmp->nm_sockreq;
5684         error = newnfs_request(nd, nmp, NULL, nrp, vp, p, cred,
5685             NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
5686         if (error != 0)
5687                 return (error);
5688         if (nd->nd_repstat != 0) {
5689                 error = nd->nd_repstat;
5690                 goto nfsmout;
5691         }
5692         NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5693         *eofp = fxdr_unsigned(int, *tl);
5694         NFSM_STRSIZ(retlen, len);
5695         error = nfsm_mbufuio(nd, uiop, retlen);
5696 nfsmout:
5697         if (nd->nd_mrep != NULL)
5698                 mbuf_freem(nd->nd_mrep);
5699         return (error);
5700 }
5701
5702 /*
5703  * The actual write RPC done to a DS.
5704  */
5705 static int
5706 nfsrpc_writeds(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
5707     nfsv4stateid_t *stateidp, struct nfsclds *dsp, uint64_t io_off, int len,
5708     struct nfsfh *fhp, int commit_thru_mds, struct ucred *cred, NFSPROC_T *p)
5709 {
5710         uint32_t *tl;
5711         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5712         int error, rlen, commit, committed = NFSWRITE_FILESYNC;
5713         int32_t backup;
5714         struct nfsrv_descript nfsd;
5715         struct nfsrv_descript *nd = &nfsd;
5716         struct nfssockreq *nrp;
5717
5718         KASSERT(uiop->uio_iovcnt == 1, ("nfs: writerpc iovcnt > 1"));
5719         nd->nd_mrep = NULL;
5720         nfscl_reqstart(nd, NFSPROC_WRITEDS, nmp, fhp->nfh_fh, fhp->nfh_len,
5721             NULL, &dsp->nfsclds_sess);
5722         nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSEQIDZERO);
5723         NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
5724         txdr_hyper(io_off, tl);
5725         tl += 2;
5726         *tl++ = txdr_unsigned(*iomode);
5727         *tl = txdr_unsigned(len);
5728         nfsm_uiombuf(nd, uiop, len);
5729         nrp = dsp->nfsclds_sockp;
5730         if (nrp == NULL)
5731                 /* If NULL, use the MDS socket. */
5732                 nrp = &nmp->nm_sockreq;
5733         error = newnfs_request(nd, nmp, NULL, nrp, vp, p, cred,
5734             NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
5735         if (error != 0)
5736                 return (error);
5737         if (nd->nd_repstat != 0) {
5738                 /*
5739                  * In case the rpc gets retried, roll
5740                  * the uio fileds changed by nfsm_uiombuf()
5741                  * back.
5742                  */
5743                 uiop->uio_offset -= len;
5744                 uio_uio_resid_add(uiop, len);
5745                 uio_iov_base_add(uiop, -len);
5746                 uio_iov_len_add(uiop, len);
5747                 error = nd->nd_repstat;
5748         } else {
5749                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED + NFSX_VERF);
5750                 rlen = fxdr_unsigned(int, *tl++);
5751                 if (rlen == 0) {
5752                         error = NFSERR_IO;
5753                         goto nfsmout;
5754                 } else if (rlen < len) {
5755                         backup = len - rlen;
5756                         uio_iov_base_add(uiop, -(backup));
5757                         uio_iov_len_add(uiop, backup);
5758                         uiop->uio_offset -= backup;
5759                         uio_uio_resid_add(uiop, backup);
5760                         len = rlen;
5761                 }
5762                 commit = fxdr_unsigned(int, *tl++);
5763
5764                 /*
5765                  * Return the lowest committment level
5766                  * obtained by any of the RPCs.
5767                  */
5768                 if (committed == NFSWRITE_FILESYNC)
5769                         committed = commit;
5770                 else if (committed == NFSWRITE_DATASYNC &&
5771                     commit == NFSWRITE_UNSTABLE)
5772                         committed = commit;
5773                 if (commit_thru_mds != 0) {
5774                         NFSLOCKMNT(nmp);
5775                         if (!NFSHASWRITEVERF(nmp)) {
5776                                 NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
5777                                 NFSSETWRITEVERF(nmp);
5778                         } else if (NFSBCMP(tl, nmp->nm_verf, NFSX_VERF)) {
5779                                 *must_commit = 1;
5780                                 NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
5781                         }
5782                         NFSUNLOCKMNT(nmp);
5783                 } else {
5784                         NFSLOCKDS(dsp);
5785                         if ((dsp->nfsclds_flags & NFSCLDS_HASWRITEVERF) == 0) {
5786                                 NFSBCOPY(tl, dsp->nfsclds_verf, NFSX_VERF);
5787                                 dsp->nfsclds_flags |= NFSCLDS_HASWRITEVERF;
5788                         } else if (NFSBCMP(tl, dsp->nfsclds_verf, NFSX_VERF)) {
5789                                 *must_commit = 1;
5790                                 NFSBCOPY(tl, dsp->nfsclds_verf, NFSX_VERF);
5791                         }
5792                         NFSUNLOCKDS(dsp);
5793                 }
5794         }
5795 nfsmout:
5796         if (nd->nd_mrep != NULL)
5797                 mbuf_freem(nd->nd_mrep);
5798         *iomode = committed;
5799         if (nd->nd_repstat != 0 && error == 0)
5800                 error = nd->nd_repstat;
5801         return (error);
5802 }
5803
5804 /*
5805  * Free up the nfsclds structure.
5806  */
5807 void
5808 nfscl_freenfsclds(struct nfsclds *dsp)
5809 {
5810         int i;
5811
5812         if (dsp == NULL)
5813                 return;
5814         if (dsp->nfsclds_sockp != NULL) {
5815                 NFSFREECRED(dsp->nfsclds_sockp->nr_cred);
5816                 NFSFREEMUTEX(&dsp->nfsclds_sockp->nr_mtx);
5817                 free(dsp->nfsclds_sockp->nr_nam, M_SONAME);
5818                 free(dsp->nfsclds_sockp, M_NFSSOCKREQ);
5819         }
5820         NFSFREEMUTEX(&dsp->nfsclds_mtx);
5821         NFSFREEMUTEX(&dsp->nfsclds_sess.nfsess_mtx);
5822         for (i = 0; i < NFSV4_CBSLOTS; i++) {
5823                 if (dsp->nfsclds_sess.nfsess_cbslots[i].nfssl_reply != NULL)
5824                         m_freem(
5825                             dsp->nfsclds_sess.nfsess_cbslots[i].nfssl_reply);
5826         }
5827         free(dsp, M_NFSCLDS);
5828 }
5829
5830 static enum nfsclds_state
5831 nfscl_getsameserver(struct nfsmount *nmp, struct nfsclds *newdsp,
5832     struct nfsclds **retdspp)
5833 {
5834         struct nfsclds *dsp, *cur_dsp;
5835
5836         /*
5837          * Search the list of nfsclds structures for one with the same
5838          * server.
5839          */
5840         cur_dsp = NULL;
5841         TAILQ_FOREACH(dsp, &nmp->nm_sess, nfsclds_list) {
5842                 if (dsp->nfsclds_servownlen == newdsp->nfsclds_servownlen &&
5843                     dsp->nfsclds_servownlen != 0 &&
5844                     !NFSBCMP(dsp->nfsclds_serverown, newdsp->nfsclds_serverown,
5845                     dsp->nfsclds_servownlen)) {
5846                         NFSCL_DEBUG(4, "fnd same fdsp=%p dsp=%p flg=0x%x\n",
5847                             TAILQ_FIRST(&nmp->nm_sess), dsp,
5848                             dsp->nfsclds_flags);
5849                         /* Server major id matches. */
5850                         if ((dsp->nfsclds_flags & NFSCLDS_DS) != 0) {
5851                                 *retdspp = dsp;
5852                                 return (NFSDSP_USETHISSESSION);
5853                         }
5854
5855                         /*
5856                          * Note the first match, so it can be used for
5857                          * sequence'ing new sessions.
5858                          */
5859                         if (cur_dsp == NULL)
5860                                 cur_dsp = dsp;
5861                 }
5862         }
5863         if (cur_dsp != NULL) {
5864                 *retdspp = cur_dsp;
5865                 return (NFSDSP_SEQTHISSESSION);
5866         }
5867         return (NFSDSP_NOTFOUND);
5868 }
5869
5870 #ifdef notyet
5871 /*
5872  * NFS commit rpc to a DS.
5873  */
5874 static int
5875 nfsrpc_commitds(vnode_t vp, uint64_t offset, int cnt, struct nfsclds *dsp,
5876     struct nfsfh *fhp, struct ucred *cred, NFSPROC_T *p, void *stuff)
5877 {
5878         uint32_t *tl;
5879         struct nfsrv_descript nfsd, *nd = &nfsd;
5880         struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5881         struct nfssockreq *nrp;
5882         int error;
5883
5884         nfscl_reqstart(nd, NFSPROC_COMMITDS, nmp, fhp->nfh_fh, fhp->nfh_len,
5885             NULL, &dsp->nfsclds_sess);
5886         NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);
5887         txdr_hyper(offset, tl);
5888         tl += 2;
5889         *tl = txdr_unsigned(cnt);
5890         nrp = dsp->nfsclds_sockp;
5891         if (nrp == NULL)
5892                 /* If NULL, use the MDS socket. */
5893                 nrp = &nmp->nm_sockreq;
5894         error = newnfs_request(nd, nmp, NULL, nrp, vp, p, cred,
5895             NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
5896         if (error)
5897                 return (error);
5898         if (nd->nd_repstat == 0) {
5899                 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF);
5900                 NFSLOCKDS(dsp);
5901                 if (NFSBCMP(tl, dsp->nfsclds_verf, NFSX_VERF)) {
5902                         NFSBCOPY(tl, dsp->nfsclds_verf, NFSX_VERF);
5903                         error = NFSERR_STALEWRITEVERF;
5904                 }
5905                 NFSUNLOCKDS(dsp);
5906         }
5907 nfsmout:
5908         if (error == 0 && nd->nd_repstat != 0)
5909                 error = nd->nd_repstat;
5910         mbuf_freem(nd->nd_mrep);
5911         return (error);
5912 }
5913 #endif
5914