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