sys/fs/nfsserver/nfs_nfsdport.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Rick Macklem at The University of Guelph.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/capsicum.h>
  40 #include <sys/extattr.h>
  41
  42 /*
  43  * Functions that perform the vfs operations required by the routines in
  44  * nfsd_serv.c. It is hoped that this change will make the server more
  45  * portable.
  46  */
  47
  48 #include <fs/nfs/nfsport.h>
  49 #include <sys/hash.h>
  50 #include <sys/sysctl.h>
  51 #include <nlm/nlm_prot.h>
  52 #include <nlm/nlm.h>
  53
  54 FEATURE(nfsd, "NFSv4 server");
  55
  56 extern u_int32_t newnfs_true, newnfs_false, newnfs_xdrneg1;
  57 extern int nfsrv_useacl;
  58 extern int newnfs_numnfsd;
  59 extern struct mount nfsv4root_mnt;
  60 extern struct nfsrv_stablefirst nfsrv_stablefirst;
  61 extern void (*nfsd_call_servertimer)(void);
  62 extern SVCPOOL  *nfsrvd_pool;
  63 extern struct nfsv4lock nfsd_suspend_lock;
  64 extern struct nfsclienthashhead *nfsclienthash;
  65 extern struct nfslockhashhead *nfslockhash;
  66 extern struct nfssessionhash *nfssessionhash;
  67 extern int nfsrv_sessionhashsize;
  68 extern struct nfsstatsv1 nfsstatsv1;
  69 extern struct nfslayouthash *nfslayouthash;
  70 extern int nfsrv_layouthashsize;
  71 extern struct mtx nfsrv_dslock_mtx;
  72 extern int nfs_pnfsiothreads;
  73 extern struct nfsdontlisthead nfsrv_dontlisthead;
  74 extern volatile int nfsrv_dontlistlen;
  75 extern volatile int nfsrv_devidcnt;
  76 extern int nfsrv_maxpnfsmirror;
  77 struct vfsoptlist nfsv4root_opt, nfsv4root_newopt;
  78 NFSDLOCKMUTEX;
  79 NFSSTATESPINLOCK;
  80 struct nfsrchash_bucket nfsrchash_table[NFSRVCACHE_HASHSIZE];
  81 struct nfsrchash_bucket nfsrcahash_table[NFSRVCACHE_HASHSIZE];
  82 struct mtx nfsrc_udpmtx;
  83 struct mtx nfs_v4root_mutex;
  84 struct mtx nfsrv_dontlistlock_mtx;
  85 struct mtx nfsrv_recalllock_mtx;
  86 struct nfsrvfh nfs_rootfh, nfs_pubfh;
  87 int nfs_pubfhset = 0, nfs_rootfhset = 0;
  88 struct proc *nfsd_master_proc = NULL;
  89 int nfsd_debuglevel = 0;
  90 static pid_t nfsd_master_pid = (pid_t)-1;
  91 static char nfsd_master_comm[MAXCOMLEN + 1];
  92 static struct timeval nfsd_master_start;
  93 static uint32_t nfsv4_sysid = 0;
  94 static fhandle_t zerofh;
  95
  96 static int nfssvc_srvcall(struct thread *, struct nfssvc_args *,
  97     struct ucred *);
  98
  99 int nfsrv_enable_crossmntpt = 1;
 100 static int nfs_commit_blks;
 101 static int nfs_commit_miss;
 102 extern int nfsrv_issuedelegs;
 103 extern int nfsrv_dolocallocks;
 104 extern int nfsd_enable_stringtouid;
 105 extern struct nfsdevicehead nfsrv_devidhead;
 106
 107 static void nfsrv_pnfscreate(struct vnode *, struct vattr *, struct ucred *,
 108     NFSPROC_T *);
 109 static void nfsrv_pnfsremovesetup(struct vnode *, NFSPROC_T *, struct vnode **,
 110     int *, char *, fhandle_t *);
 111 static void nfsrv_pnfsremove(struct vnode **, int, char *, fhandle_t *,
 112     NFSPROC_T *);
 113 static int nfsrv_proxyds(struct nfsrv_descript *, struct vnode *, off_t, int,
 114     struct ucred *, struct thread *, int, struct mbuf **, char *,
 115     struct mbuf **, struct nfsvattr *, struct acl *);
 116 static int nfsrv_setextattr(struct vnode *, struct nfsvattr *, NFSPROC_T *);
 117 static int nfsrv_readdsrpc(fhandle_t *, off_t, int, struct ucred *,
 118     NFSPROC_T *, struct nfsmount *, struct mbuf **, struct mbuf **);
 119 static int nfsrv_writedsrpc(fhandle_t *, off_t, int, struct ucred *,
 120     NFSPROC_T *, struct vnode *, struct nfsmount **, int, struct mbuf **,
 121     char *, int *);
 122 static int nfsrv_setacldsrpc(fhandle_t *, struct ucred *, NFSPROC_T *,
 123     struct vnode *, struct nfsmount **, int, struct acl *, int *);
 124 static int nfsrv_setattrdsrpc(fhandle_t *, struct ucred *, NFSPROC_T *,
 125     struct vnode *, struct nfsmount **, int, struct nfsvattr *, int *);
 126 static int nfsrv_getattrdsrpc(fhandle_t *, struct ucred *, NFSPROC_T *,
 127     struct vnode *, struct nfsmount *, struct nfsvattr *);
 128 static int nfsrv_putfhname(fhandle_t *, char *);
 129 static int nfsrv_pnfslookupds(struct vnode *, struct vnode *,
 130     struct pnfsdsfile *, struct vnode **, NFSPROC_T *);
 131 static void nfsrv_pnfssetfh(struct vnode *, struct pnfsdsfile *, char *, char *,
 132     struct vnode *, NFSPROC_T *);
 133 static int nfsrv_dsremove(struct vnode *, char *, struct ucred *, NFSPROC_T *);
 134 static int nfsrv_dssetacl(struct vnode *, struct acl *, struct ucred *,
 135     NFSPROC_T *);
 136 static int nfsrv_pnfsstatfs(struct statfs *, struct mount *);
 137
 138 int nfs_pnfsio(task_fn_t *, void *);
 139
 140 SYSCTL_NODE(_vfs, OID_AUTO, nfsd, CTLFLAG_RW, 0, "NFS server");
 141 SYSCTL_INT(_vfs_nfsd, OID_AUTO, mirrormnt, CTLFLAG_RW,
 142     &nfsrv_enable_crossmntpt, 0, "Enable nfsd to cross mount points");
 143 SYSCTL_INT(_vfs_nfsd, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks,
 144     0, "");
 145 SYSCTL_INT(_vfs_nfsd, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss,
 146     0, "");
 147 SYSCTL_INT(_vfs_nfsd, OID_AUTO, issue_delegations, CTLFLAG_RW,
 148     &nfsrv_issuedelegs, 0, "Enable nfsd to issue delegations");
 149 SYSCTL_INT(_vfs_nfsd, OID_AUTO, enable_locallocks, CTLFLAG_RW,
 150     &nfsrv_dolocallocks, 0, "Enable nfsd to acquire local locks on files");
 151 SYSCTL_INT(_vfs_nfsd, OID_AUTO, debuglevel, CTLFLAG_RW, &nfsd_debuglevel,
 152     0, "Debug level for NFS server");
 153 SYSCTL_INT(_vfs_nfsd, OID_AUTO, enable_stringtouid, CTLFLAG_RW,
 154     &nfsd_enable_stringtouid, 0, "Enable nfsd to accept numeric owner_names");
 155 static int nfsrv_pnfsgetdsattr = 1;
 156 SYSCTL_INT(_vfs_nfsd, OID_AUTO, pnfsgetdsattr, CTLFLAG_RW,
 157     &nfsrv_pnfsgetdsattr, 0, "When set getattr gets DS attributes via RPC");
 158
 159 /*
 160  * nfsrv_dsdirsize can only be increased and only when the nfsd threads are
 161  * not running.
 162  * The dsN subdirectories for the increased values must have been created
 163  * on all DS servers before this increase is done.
 164  */
 165 u_int   nfsrv_dsdirsize = 20;
 166 static int
 167 sysctl_dsdirsize(SYSCTL_HANDLER_ARGS)
 168 {
 169         int error, newdsdirsize;
 170
 171         newdsdirsize = nfsrv_dsdirsize;
 172         error = sysctl_handle_int(oidp, &newdsdirsize, 0, req);
 173         if (error != 0 || req->newptr == NULL)
 174                 return (error);
 175         if (newdsdirsize <= nfsrv_dsdirsize || newdsdirsize > 10000 ||
 176             newnfs_numnfsd != 0)
 177                 return (EINVAL);
 178         nfsrv_dsdirsize = newdsdirsize;
 179         return (0);
 180 }
 181 SYSCTL_PROC(_vfs_nfsd, OID_AUTO, dsdirsize, CTLTYPE_UINT | CTLFLAG_RW, 0,
 182     sizeof(nfsrv_dsdirsize), sysctl_dsdirsize, "IU",
 183     "Number of dsN subdirs on the DS servers");
 184
 185 #define MAX_REORDERED_RPC       16
 186 #define NUM_HEURISTIC           1031
 187 #define NHUSE_INIT              64
 188 #define NHUSE_INC               16
 189 #define NHUSE_MAX               2048
 190
 191 static struct nfsheur {
 192         struct vnode *nh_vp;    /* vp to match (unreferenced pointer) */
 193         off_t nh_nextoff;       /* next offset for sequential detection */
 194         int nh_use;             /* use count for selection */
 195         int nh_seqcount;        /* heuristic */
 196 } nfsheur[NUM_HEURISTIC];
 197
 198
 199 /*
 200  * Heuristic to detect sequential operation.
 201  */
 202 static struct nfsheur *
 203 nfsrv_sequential_heuristic(struct uio *uio, struct vnode *vp)
 204 {
 205         struct nfsheur *nh;
 206         int hi, try;
 207
 208         /* Locate best candidate. */
 209         try = 32;
 210         hi = ((int)(vm_offset_t)vp / sizeof(struct vnode)) % NUM_HEURISTIC;
 211         nh = &nfsheur[hi];
 212         while (try--) {
 213                 if (nfsheur[hi].nh_vp == vp) {
 214                         nh = &nfsheur[hi];
 215                         break;
 216                 }
 217                 if (nfsheur[hi].nh_use > 0)
 218                         --nfsheur[hi].nh_use;
 219                 hi = (hi + 1) % NUM_HEURISTIC;
 220                 if (nfsheur[hi].nh_use < nh->nh_use)
 221                         nh = &nfsheur[hi];
 222         }
 223
 224         /* Initialize hint if this is a new file. */
 225         if (nh->nh_vp != vp) {
 226                 nh->nh_vp = vp;
 227                 nh->nh_nextoff = uio->uio_offset;
 228                 nh->nh_use = NHUSE_INIT;
 229                 if (uio->uio_offset == 0)
 230                         nh->nh_seqcount = 4;
 231                 else
 232                         nh->nh_seqcount = 1;
 233         }
 234
 235         /* Calculate heuristic. */
 236         if ((uio->uio_offset == 0 && nh->nh_seqcount > 0) ||
 237             uio->uio_offset == nh->nh_nextoff) {
 238                 /* See comments in vfs_vnops.c:sequential_heuristic(). */
 239                 nh->nh_seqcount += howmany(uio->uio_resid, 16384);
 240                 if (nh->nh_seqcount > IO_SEQMAX)
 241                         nh->nh_seqcount = IO_SEQMAX;
 242         } else if (qabs(uio->uio_offset - nh->nh_nextoff) <= MAX_REORDERED_RPC *
 243             imax(vp->v_mount->mnt_stat.f_iosize, uio->uio_resid)) {
 244                 /* Probably a reordered RPC, leave seqcount alone. */
 245         } else if (nh->nh_seqcount > 1) {
 246                 nh->nh_seqcount /= 2;
 247         } else {
 248                 nh->nh_seqcount = 0;
 249         }
 250         nh->nh_use += NHUSE_INC;
 251         if (nh->nh_use > NHUSE_MAX)
 252                 nh->nh_use = NHUSE_MAX;
 253         return (nh);
 254 }
 255
 256 /*
 257  * Get attributes into nfsvattr structure.
 258  */
 259 int
 260 nfsvno_getattr(struct vnode *vp, struct nfsvattr *nvap,
 261     struct nfsrv_descript *nd, struct thread *p, int vpislocked,
 262     nfsattrbit_t *attrbitp)
 263 {
 264         int error, gotattr, lockedit = 0;
 265         struct nfsvattr na;
 266
 267         if (vpislocked == 0) {
 268                 /*
 269                  * When vpislocked == 0, the vnode is either exclusively
 270                  * locked by this thread or not locked by this thread.
 271                  * As such, shared lock it, if not exclusively locked.
 272                  */
 273                 if (NFSVOPISLOCKED(vp) != LK_EXCLUSIVE) {
 274                         lockedit = 1;
 275                         NFSVOPLOCK(vp, LK_SHARED | LK_RETRY);
 276                 }
 277         }
 278
 279         /*
 280          * Acquire the Change, Size and TimeModify attributes, as required.
 281          * This needs to be done for regular files if:
 282          * - non-NFSv4 RPCs or
 283          * - when attrbitp == NULL or
 284          * - an NFSv4 RPC with any of the above attributes in attrbitp.
 285          * A return of 0 for nfsrv_proxyds() indicates that it has acquired
 286          * these attributes.  nfsrv_proxyds() will return an error if the
 287          * server is not a pNFS one.
 288          */
 289         gotattr = 0;
 290         if (vp->v_type == VREG && nfsrv_devidcnt > 0 && (attrbitp == NULL ||
 291             (nd->nd_flag & ND_NFSV4) == 0 ||
 292             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_CHANGE) ||
 293             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_SIZE) ||
 294             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_TIMEACCESS) ||
 295             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_TIMEMODIFY))) {
 296                 error = nfsrv_proxyds(nd, vp, 0, 0, nd->nd_cred, p,
 297                     NFSPROC_GETATTR, NULL, NULL, NULL, &na, NULL);
 298                 if (error == 0)
 299                         gotattr = 1;
 300         }
 301
 302         error = VOP_GETATTR(vp, &nvap->na_vattr, nd->nd_cred);
 303         if (lockedit != 0)
 304                 NFSVOPUNLOCK(vp, 0);
 305
 306         /*
 307          * If we got the Change, Size and Modify Time from the DS,
 308          * replace them.
 309          */
 310         if (gotattr != 0) {
 311                 nvap->na_atime = na.na_atime;
 312                 nvap->na_mtime = na.na_mtime;
 313                 nvap->na_filerev = na.na_filerev;
 314                 nvap->na_size = na.na_size;
 315         }
 316         NFSD_DEBUG(4, "nfsvno_getattr: gotattr=%d err=%d chg=%ju\n", gotattr,
 317             error, (uintmax_t)na.na_filerev);
 318
 319         NFSEXITCODE(error);
 320         return (error);
 321 }
 322
 323 /*
 324  * Get a file handle for a vnode.
 325  */
 326 int
 327 nfsvno_getfh(struct vnode *vp, fhandle_t *fhp, struct thread *p)
 328 {
 329         int error;
 330
 331         NFSBZERO((caddr_t)fhp, sizeof(fhandle_t));
 332         fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
 333         error = VOP_VPTOFH(vp, &fhp->fh_fid);
 334
 335         NFSEXITCODE(error);
 336         return (error);
 337 }
 338
 339 /*
 340  * Perform access checking for vnodes obtained from file handles that would
 341  * refer to files already opened by a Unix client. You cannot just use
 342  * vn_writechk() and VOP_ACCESSX() for two reasons.
 343  * 1 - You must check for exported rdonly as well as MNT_RDONLY for the write
 344  *     case.
 345  * 2 - The owner is to be given access irrespective of mode bits for some
 346  *     operations, so that processes that chmod after opening a file don't
 347  *     break.
 348  */
 349 int
 350 nfsvno_accchk(struct vnode *vp, accmode_t accmode, struct ucred *cred,
 351     struct nfsexstuff *exp, struct thread *p, int override, int vpislocked,
 352     u_int32_t *supportedtypep)
 353 {
 354         struct vattr vattr;
 355         int error = 0, getret = 0;
 356
 357         if (vpislocked == 0) {
 358                 if (NFSVOPLOCK(vp, LK_SHARED) != 0) {
 359                         error = EPERM;
 360                         goto out;
 361                 }
 362         }
 363         if (accmode & VWRITE) {
 364                 /* Just vn_writechk() changed to check rdonly */
 365                 /*
 366                  * Disallow write attempts on read-only file systems;
 367                  * unless the file is a socket or a block or character
 368                  * device resident on the file system.
 369                  */
 370                 if (NFSVNO_EXRDONLY(exp) ||
 371                     (vp->v_mount->mnt_flag & MNT_RDONLY)) {
 372                         switch (vp->v_type) {
 373                         case VREG:
 374                         case VDIR:
 375                         case VLNK:
 376                                 error = EROFS;
 377                         default:
 378                                 break;
 379                         }
 380                 }
 381                 /*
 382                  * If there's shared text associated with
 383                  * the inode, try to free it up once.  If
 384                  * we fail, we can't allow writing.
 385                  */
 386                 if (VOP_IS_TEXT(vp) && error == 0)
 387                         error = ETXTBSY;
 388         }
 389         if (error != 0) {
 390                 if (vpislocked == 0)
 391                         NFSVOPUNLOCK(vp, 0);
 392                 goto out;
 393         }
 394
 395         /*
 396          * Should the override still be applied when ACLs are enabled?
 397          */
 398         error = VOP_ACCESSX(vp, accmode, cred, p);
 399         if (error != 0 && (accmode & (VDELETE | VDELETE_CHILD))) {
 400                 /*
 401                  * Try again with VEXPLICIT_DENY, to see if the test for
 402                  * deletion is supported.
 403                  */
 404                 error = VOP_ACCESSX(vp, accmode | VEXPLICIT_DENY, cred, p);
 405                 if (error == 0) {
 406                         if (vp->v_type == VDIR) {
 407                                 accmode &= ~(VDELETE | VDELETE_CHILD);
 408                                 accmode |= VWRITE;
 409                                 error = VOP_ACCESSX(vp, accmode, cred, p);
 410                         } else if (supportedtypep != NULL) {
 411                                 *supportedtypep &= ~NFSACCESS_DELETE;
 412                         }
 413                 }
 414         }
 415
 416         /*
 417          * Allow certain operations for the owner (reads and writes
 418          * on files that are already open).
 419          */
 420         if (override != NFSACCCHK_NOOVERRIDE &&
 421             (error == EPERM || error == EACCES)) {
 422                 if (cred->cr_uid == 0 && (override & NFSACCCHK_ALLOWROOT))
 423                         error = 0;
 424                 else if (override & NFSACCCHK_ALLOWOWNER) {
 425                         getret = VOP_GETATTR(vp, &vattr, cred);
 426                         if (getret == 0 && cred->cr_uid == vattr.va_uid)
 427                                 error = 0;
 428                 }
 429         }
 430         if (vpislocked == 0)
 431                 NFSVOPUNLOCK(vp, 0);
 432
 433 out:
 434         NFSEXITCODE(error);
 435         return (error);
 436 }
 437
 438 /*
 439  * Set attribute(s) vnop.
 440  */
 441 int
 442 nfsvno_setattr(struct vnode *vp, struct nfsvattr *nvap, struct ucred *cred,
 443     struct thread *p, struct nfsexstuff *exp)
 444 {
 445         u_quad_t savsize = 0;
 446         int error, savedit;
 447
 448         /*
 449          * If this is an exported file system and a pNFS service is running,
 450          * don't VOP_SETATTR() of size for the MDS file system.
 451          */
 452         savedit = 0;
 453         error = 0;
 454         if (vp->v_type == VREG && (vp->v_mount->mnt_flag & MNT_EXPORTED) != 0 &&
 455             nfsrv_devidcnt != 0 && nvap->na_vattr.va_size != VNOVAL &&
 456             nvap->na_vattr.va_size > 0) {
 457                 savsize = nvap->na_vattr.va_size;
 458                 nvap->na_vattr.va_size = VNOVAL;
 459                 if (nvap->na_vattr.va_uid != (uid_t)VNOVAL ||
 460                     nvap->na_vattr.va_gid != (gid_t)VNOVAL ||
 461                     nvap->na_vattr.va_mode != (mode_t)VNOVAL ||
 462                     nvap->na_vattr.va_atime.tv_sec != VNOVAL ||
 463                     nvap->na_vattr.va_mtime.tv_sec != VNOVAL)
 464                         savedit = 1;
 465                 else
 466                         savedit = 2;
 467         }
 468         if (savedit != 2)
 469                 error = VOP_SETATTR(vp, &nvap->na_vattr, cred);
 470         if (savedit != 0)
 471                 nvap->na_vattr.va_size = savsize;
 472         if (error == 0 && (nvap->na_vattr.va_uid != (uid_t)VNOVAL ||
 473             nvap->na_vattr.va_gid != (gid_t)VNOVAL ||
 474             nvap->na_vattr.va_size != VNOVAL ||
 475             nvap->na_vattr.va_mode != (mode_t)VNOVAL ||
 476             nvap->na_vattr.va_atime.tv_sec != VNOVAL ||
 477             nvap->na_vattr.va_mtime.tv_sec != VNOVAL)) {
 478                 /* For a pNFS server, set the attributes on the DS file. */
 479                 error = nfsrv_proxyds(NULL, vp, 0, 0, cred, p, NFSPROC_SETATTR,
 480                     NULL, NULL, NULL, nvap, NULL);
 481                 if (error == ENOENT)
 482                         error = 0;
 483         }
 484         NFSEXITCODE(error);
 485         return (error);
 486 }
 487
 488 /*
 489  * Set up nameidata for a lookup() call and do it.
 490  */
 491 int
 492 nfsvno_namei(struct nfsrv_descript *nd, struct nameidata *ndp,
 493     struct vnode *dp, int islocked, struct nfsexstuff *exp, struct thread *p,
 494     struct vnode **retdirp)
 495 {
 496         struct componentname *cnp = &ndp->ni_cnd;
 497         int i;
 498         struct iovec aiov;
 499         struct uio auio;
 500         int lockleaf = (cnp->cn_flags & LOCKLEAF) != 0, linklen;
 501         int error = 0;
 502         char *cp;
 503
 504         *retdirp = NULL;
 505         cnp->cn_nameptr = cnp->cn_pnbuf;
 506         ndp->ni_lcf = 0;
 507         /*
 508          * Extract and set starting directory.
 509          */
 510         if (dp->v_type != VDIR) {
 511                 if (islocked)
 512                         vput(dp);
 513                 else
 514                         vrele(dp);
 515                 nfsvno_relpathbuf(ndp);
 516                 error = ENOTDIR;
 517                 goto out1;
 518         }
 519         if (islocked)
 520                 NFSVOPUNLOCK(dp, 0);
 521         VREF(dp);
 522         *retdirp = dp;
 523         if (NFSVNO_EXRDONLY(exp))
 524                 cnp->cn_flags |= RDONLY;
 525         ndp->ni_segflg = UIO_SYSSPACE;
 526
 527         if (nd->nd_flag & ND_PUBLOOKUP) {
 528                 ndp->ni_loopcnt = 0;
 529                 if (cnp->cn_pnbuf[0] == '/') {
 530                         vrele(dp);
 531                         /*
 532                          * Check for degenerate pathnames here, since lookup()
 533                          * panics on them.
 534                          */
 535                         for (i = 1; i < ndp->ni_pathlen; i++)
 536                                 if (cnp->cn_pnbuf[i] != '/')
 537                                         break;
 538                         if (i == ndp->ni_pathlen) {
 539                                 error = NFSERR_ACCES;
 540                                 goto out;
 541                         }
 542                         dp = rootvnode;
 543                         VREF(dp);
 544                 }
 545         } else if ((nfsrv_enable_crossmntpt == 0 && NFSVNO_EXPORTED(exp)) ||
 546             (nd->nd_flag & ND_NFSV4) == 0) {
 547                 /*
 548                  * Only cross mount points for NFSv4 when doing a
 549                  * mount while traversing the file system above
 550                  * the mount point, unless nfsrv_enable_crossmntpt is set.
 551                  */
 552                 cnp->cn_flags |= NOCROSSMOUNT;
 553         }
 554
 555         /*
 556          * Initialize for scan, set ni_startdir and bump ref on dp again
 557          * because lookup() will dereference ni_startdir.
 558          */
 559
 560         cnp->cn_thread = p;
 561         ndp->ni_startdir = dp;
 562         ndp->ni_rootdir = rootvnode;
 563         ndp->ni_topdir = NULL;
 564
 565         if (!lockleaf)
 566                 cnp->cn_flags |= LOCKLEAF;
 567         for (;;) {
 568                 cnp->cn_nameptr = cnp->cn_pnbuf;
 569                 /*
 570                  * Call lookup() to do the real work.  If an error occurs,
 571                  * ndp->ni_vp and ni_dvp are left uninitialized or NULL and
 572                  * we do not have to dereference anything before returning.
 573                  * In either case ni_startdir will be dereferenced and NULLed
 574                  * out.
 575                  */
 576                 error = lookup(ndp);
 577                 if (error)
 578                         break;
 579
 580                 /*
 581                  * Check for encountering a symbolic link.  Trivial
 582                  * termination occurs if no symlink encountered.
 583                  */
 584                 if ((cnp->cn_flags & ISSYMLINK) == 0) {
 585                         if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0)
 586                                 nfsvno_relpathbuf(ndp);
 587                         if (ndp->ni_vp && !lockleaf)
 588                                 NFSVOPUNLOCK(ndp->ni_vp, 0);
 589                         break;
 590                 }
 591
 592                 /*
 593                  * Validate symlink
 594                  */
 595                 if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1)
 596                         NFSVOPUNLOCK(ndp->ni_dvp, 0);
 597                 if (!(nd->nd_flag & ND_PUBLOOKUP)) {
 598                         error = EINVAL;
 599                         goto badlink2;
 600                 }
 601
 602                 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
 603                         error = ELOOP;
 604                         goto badlink2;
 605                 }
 606                 if (ndp->ni_pathlen > 1)
 607                         cp = uma_zalloc(namei_zone, M_WAITOK);
 608                 else
 609                         cp = cnp->cn_pnbuf;
 610                 aiov.iov_base = cp;
 611                 aiov.iov_len = MAXPATHLEN;
 612                 auio.uio_iov = &aiov;
 613                 auio.uio_iovcnt = 1;
 614                 auio.uio_offset = 0;
 615                 auio.uio_rw = UIO_READ;
 616                 auio.uio_segflg = UIO_SYSSPACE;
 617                 auio.uio_td = NULL;
 618                 auio.uio_resid = MAXPATHLEN;
 619                 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
 620                 if (error) {
 621                 badlink1:
 622                         if (ndp->ni_pathlen > 1)
 623                                 uma_zfree(namei_zone, cp);
 624                 badlink2:
 625                         vrele(ndp->ni_dvp);
 626                         vput(ndp->ni_vp);
 627                         break;
 628                 }
 629                 linklen = MAXPATHLEN - auio.uio_resid;
 630                 if (linklen == 0) {
 631                         error = ENOENT;
 632                         goto badlink1;
 633                 }
 634                 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
 635                         error = ENAMETOOLONG;
 636                         goto badlink1;
 637                 }
 638
 639                 /*
 640                  * Adjust or replace path
 641                  */
 642                 if (ndp->ni_pathlen > 1) {
 643                         NFSBCOPY(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
 644                         uma_zfree(namei_zone, cnp->cn_pnbuf);
 645                         cnp->cn_pnbuf = cp;
 646                 } else
 647                         cnp->cn_pnbuf[linklen] = '\0';
 648                 ndp->ni_pathlen += linklen;
 649
 650                 /*
 651                  * Cleanup refs for next loop and check if root directory
 652                  * should replace current directory.  Normally ni_dvp
 653                  * becomes the new base directory and is cleaned up when
 654                  * we loop.  Explicitly null pointers after invalidation
 655                  * to clarify operation.
 656                  */
 657                 vput(ndp->ni_vp);
 658                 ndp->ni_vp = NULL;
 659
 660                 if (cnp->cn_pnbuf[0] == '/') {
 661                         vrele(ndp->ni_dvp);
 662                         ndp->ni_dvp = ndp->ni_rootdir;
 663                         VREF(ndp->ni_dvp);
 664                 }
 665                 ndp->ni_startdir = ndp->ni_dvp;
 666                 ndp->ni_dvp = NULL;
 667         }
 668         if (!lockleaf)
 669                 cnp->cn_flags &= ~LOCKLEAF;
 670
 671 out:
 672         if (error) {
 673                 nfsvno_relpathbuf(ndp);
 674                 ndp->ni_vp = NULL;
 675                 ndp->ni_dvp = NULL;
 676                 ndp->ni_startdir = NULL;
 677         } else if ((ndp->ni_cnd.cn_flags & (WANTPARENT|LOCKPARENT)) == 0) {
 678                 ndp->ni_dvp = NULL;
 679         }
 680
 681 out1:
 682         NFSEXITCODE2(error, nd);
 683         return (error);
 684 }
 685
 686 /*
 687  * Set up a pathname buffer and return a pointer to it and, optionally
 688  * set a hash pointer.
 689  */
 690 void
 691 nfsvno_setpathbuf(struct nameidata *ndp, char **bufpp, u_long **hashpp)
 692 {
 693         struct componentname *cnp = &ndp->ni_cnd;
 694
 695         cnp->cn_flags |= (NOMACCHECK | HASBUF);
 696         cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
 697         if (hashpp != NULL)
 698                 *hashpp = NULL;
 699         *bufpp = cnp->cn_pnbuf;
 700 }
 701
 702 /*
 703  * Release the above path buffer, if not released by nfsvno_namei().
 704  */
 705 void
 706 nfsvno_relpathbuf(struct nameidata *ndp)
 707 {
 708
 709         if ((ndp->ni_cnd.cn_flags & HASBUF) == 0)
 710                 panic("nfsrelpath");
 711         uma_zfree(namei_zone, ndp->ni_cnd.cn_pnbuf);
 712         ndp->ni_cnd.cn_flags &= ~HASBUF;
 713 }
 714
 715 /*
 716  * Readlink vnode op into an mbuf list.
 717  */
 718 int
 719 nfsvno_readlink(struct vnode *vp, struct ucred *cred, struct thread *p,
 720     struct mbuf **mpp, struct mbuf **mpendp, int *lenp)
 721 {
 722         struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
 723         struct iovec *ivp = iv;
 724         struct uio io, *uiop = &io;
 725         struct mbuf *mp, *mp2 = NULL, *mp3 = NULL;
 726         int i, len, tlen, error = 0;
 727
 728         len = 0;
 729         i = 0;
 730         while (len < NFS_MAXPATHLEN) {
 731                 NFSMGET(mp);
 732                 MCLGET(mp, M_WAITOK);
 733                 mp->m_len = M_SIZE(mp);
 734                 if (len == 0) {
 735                         mp3 = mp2 = mp;
 736                 } else {
 737                         mp2->m_next = mp;
 738                         mp2 = mp;
 739                 }
 740                 if ((len + mp->m_len) > NFS_MAXPATHLEN) {
 741                         mp->m_len = NFS_MAXPATHLEN - len;
 742                         len = NFS_MAXPATHLEN;
 743                 } else {
 744                         len += mp->m_len;
 745                 }
 746                 ivp->iov_base = mtod(mp, caddr_t);
 747                 ivp->iov_len = mp->m_len;
 748                 i++;
 749                 ivp++;
 750         }
 751         uiop->uio_iov = iv;
 752         uiop->uio_iovcnt = i;
 753         uiop->uio_offset = 0;
 754         uiop->uio_resid = len;
 755         uiop->uio_rw = UIO_READ;
 756         uiop->uio_segflg = UIO_SYSSPACE;
 757         uiop->uio_td = NULL;
 758         error = VOP_READLINK(vp, uiop, cred);
 759         if (error) {
 760                 m_freem(mp3);
 761                 *lenp = 0;
 762                 goto out;
 763         }
 764         if (uiop->uio_resid > 0) {
 765                 len -= uiop->uio_resid;
 766                 tlen = NFSM_RNDUP(len);
 767                 nfsrv_adj(mp3, NFS_MAXPATHLEN - tlen, tlen - len);
 768         }
 769         *lenp = len;
 770         *mpp = mp3;
 771         *mpendp = mp;
 772
 773 out:
 774         NFSEXITCODE(error);
 775         return (error);
 776 }
 777
 778 /*
 779  * Read vnode op call into mbuf list.
 780  */
 781 int
 782 nfsvno_read(struct vnode *vp, off_t off, int cnt, struct ucred *cred,
 783     struct thread *p, struct mbuf **mpp, struct mbuf **mpendp)
 784 {
 785         struct mbuf *m;
 786         int i;
 787         struct iovec *iv;
 788         struct iovec *iv2;
 789         int error = 0, len, left, siz, tlen, ioflag = 0;
 790         struct mbuf *m2 = NULL, *m3;
 791         struct uio io, *uiop = &io;
 792         struct nfsheur *nh;
 793
 794         /*
 795          * Attempt to read from a DS file. A return of ENOENT implies
 796          * there is no DS file to read.
 797          */
 798         error = nfsrv_proxyds(NULL, vp, off, cnt, cred, p, NFSPROC_READDS, mpp,
 799             NULL, mpendp, NULL, NULL);
 800         if (error != ENOENT)
 801                 return (error);
 802
 803         len = left = NFSM_RNDUP(cnt);
 804         m3 = NULL;
 805         /*
 806          * Generate the mbuf list with the uio_iov ref. to it.
 807          */
 808         i = 0;
 809         while (left > 0) {
 810                 NFSMGET(m);
 811                 MCLGET(m, M_WAITOK);
 812                 m->m_len = 0;
 813                 siz = min(M_TRAILINGSPACE(m), left);
 814                 left -= siz;
 815                 i++;
 816                 if (m3)
 817                         m2->m_next = m;
 818                 else
 819                         m3 = m;
 820                 m2 = m;
 821         }
 822         iv = malloc(i * sizeof (struct iovec),
 823             M_TEMP, M_WAITOK);
 824         uiop->uio_iov = iv2 = iv;
 825         m = m3;
 826         left = len;
 827         i = 0;
 828         while (left > 0) {
 829                 if (m == NULL)
 830                         panic("nfsvno_read iov");
 831                 siz = min(M_TRAILINGSPACE(m), left);
 832                 if (siz > 0) {
 833                         iv->iov_base = mtod(m, caddr_t) + m->m_len;
 834                         iv->iov_len = siz;
 835                         m->m_len += siz;
 836                         left -= siz;
 837                         iv++;
 838                         i++;
 839                 }
 840                 m = m->m_next;
 841         }
 842         uiop->uio_iovcnt = i;
 843         uiop->uio_offset = off;
 844         uiop->uio_resid = len;
 845         uiop->uio_rw = UIO_READ;
 846         uiop->uio_segflg = UIO_SYSSPACE;
 847         uiop->uio_td = NULL;
 848         nh = nfsrv_sequential_heuristic(uiop, vp);
 849         ioflag |= nh->nh_seqcount << IO_SEQSHIFT;
 850         /* XXX KDM make this more systematic? */
 851         nfsstatsv1.srvbytes[NFSV4OP_READ] += uiop->uio_resid;
 852         error = VOP_READ(vp, uiop, IO_NODELOCKED | ioflag, cred);
 853         free(iv2, M_TEMP);
 854         if (error) {
 855                 m_freem(m3);
 856                 *mpp = NULL;
 857                 goto out;
 858         }
 859         nh->nh_nextoff = uiop->uio_offset;
 860         tlen = len - uiop->uio_resid;
 861         cnt = cnt < tlen ? cnt : tlen;
 862         tlen = NFSM_RNDUP(cnt);
 863         if (tlen == 0) {
 864                 m_freem(m3);
 865                 m3 = NULL;
 866         } else if (len != tlen || tlen != cnt)
 867                 nfsrv_adj(m3, len - tlen, tlen - cnt);
 868         *mpp = m3;
 869         *mpendp = m2;
 870
 871 out:
 872         NFSEXITCODE(error);
 873         return (error);
 874 }
 875
 876 /*
 877  * Write vnode op from an mbuf list.
 878  */
 879 int
 880 nfsvno_write(struct vnode *vp, off_t off, int retlen, int cnt, int *stable,
 881     struct mbuf *mp, char *cp, struct ucred *cred, struct thread *p)
 882 {
 883         struct iovec *ivp;
 884         int i, len;
 885         struct iovec *iv;
 886         int ioflags, error;
 887         struct uio io, *uiop = &io;
 888         struct nfsheur *nh;
 889
 890         /*
 891          * Attempt to write to a DS file. A return of ENOENT implies
 892          * there is no DS file to write.
 893          */
 894         error = nfsrv_proxyds(NULL, vp, off, retlen, cred, p, NFSPROC_WRITEDS,
 895             &mp, cp, NULL, NULL, NULL);
 896         if (error != ENOENT) {
 897                 *stable = NFSWRITE_FILESYNC;
 898                 return (error);
 899         }
 900
 901         ivp = malloc(cnt * sizeof (struct iovec), M_TEMP,
 902             M_WAITOK);
 903         uiop->uio_iov = iv = ivp;
 904         uiop->uio_iovcnt = cnt;
 905         i = mtod(mp, caddr_t) + mp->m_len - cp;
 906         len = retlen;
 907         while (len > 0) {
 908                 if (mp == NULL)
 909                         panic("nfsvno_write");
 910                 if (i > 0) {
 911                         i = min(i, len);
 912                         ivp->iov_base = cp;
 913                         ivp->iov_len = i;
 914                         ivp++;
 915                         len -= i;
 916                 }
 917                 mp = mp->m_next;
 918                 if (mp) {
 919                         i = mp->m_len;
 920                         cp = mtod(mp, caddr_t);
 921                 }
 922         }
 923
 924         if (*stable == NFSWRITE_UNSTABLE)
 925                 ioflags = IO_NODELOCKED;
 926         else
 927                 ioflags = (IO_SYNC | IO_NODELOCKED);
 928         uiop->uio_resid = retlen;
 929         uiop->uio_rw = UIO_WRITE;
 930         uiop->uio_segflg = UIO_SYSSPACE;
 931         NFSUIOPROC(uiop, p);
 932         uiop->uio_offset = off;
 933         nh = nfsrv_sequential_heuristic(uiop, vp);
 934         ioflags |= nh->nh_seqcount << IO_SEQSHIFT;
 935         /* XXX KDM make this more systematic? */
 936         nfsstatsv1.srvbytes[NFSV4OP_WRITE] += uiop->uio_resid;
 937         error = VOP_WRITE(vp, uiop, ioflags, cred);
 938         if (error == 0)
 939                 nh->nh_nextoff = uiop->uio_offset;
 940         free(iv, M_TEMP);
 941
 942         NFSEXITCODE(error);
 943         return (error);
 944 }
 945
 946 /*
 947  * Common code for creating a regular file (plus special files for V2).
 948  */
 949 int
 950 nfsvno_createsub(struct nfsrv_descript *nd, struct nameidata *ndp,
 951     struct vnode **vpp, struct nfsvattr *nvap, int *exclusive_flagp,
 952     int32_t *cverf, NFSDEV_T rdev, struct nfsexstuff *exp)
 953 {
 954         u_quad_t tempsize;
 955         int error;
 956         struct thread *p = curthread;
 957
 958         error = nd->nd_repstat;
 959         if (!error && ndp->ni_vp == NULL) {
 960                 if (nvap->na_type == VREG || nvap->na_type == VSOCK) {
 961                         vrele(ndp->ni_startdir);
 962                         error = VOP_CREATE(ndp->ni_dvp,
 963                             &ndp->ni_vp, &ndp->ni_cnd, &nvap->na_vattr);
 964                         /* For a pNFS server, create the data file on a DS. */
 965                         if (error == 0 && nvap->na_type == VREG) {
 966                                 /*
 967                                  * Create a data file on a DS for a pNFS server.
 968                                  * This function just returns if not
 969                                  * running a pNFS DS or the creation fails.
 970                                  */
 971                                 nfsrv_pnfscreate(ndp->ni_vp, &nvap->na_vattr,
 972                                     nd->nd_cred, p);
 973                         }
 974                         vput(ndp->ni_dvp);
 975                         nfsvno_relpathbuf(ndp);
 976                         if (!error) {
 977                                 if (*exclusive_flagp) {
 978                                         *exclusive_flagp = 0;
 979                                         NFSVNO_ATTRINIT(nvap);
 980                                         nvap->na_atime.tv_sec = cverf[0];
 981                                         nvap->na_atime.tv_nsec = cverf[1];
 982                                         error = VOP_SETATTR(ndp->ni_vp,
 983                                             &nvap->na_vattr, nd->nd_cred);
 984                                         if (error != 0) {
 985                                                 vput(ndp->ni_vp);
 986                                                 ndp->ni_vp = NULL;
 987                                                 error = NFSERR_NOTSUPP;
 988                                         }
 989                                 }
 990                         }
 991                 /*
 992                  * NFS V2 Only. nfsrvd_mknod() does this for V3.
 993                  * (This implies, just get out on an error.)
 994                  */
 995                 } else if (nvap->na_type == VCHR || nvap->na_type == VBLK ||
 996                         nvap->na_type == VFIFO) {
 997                         if (nvap->na_type == VCHR && rdev == 0xffffffff)
 998                                 nvap->na_type = VFIFO;
 999                         if (nvap->na_type != VFIFO &&
1000                             (error = priv_check_cred(nd->nd_cred, PRIV_VFS_MKNOD_DEV))) {
1001                                 vrele(ndp->ni_startdir);
1002                                 nfsvno_relpathbuf(ndp);
1003                                 vput(ndp->ni_dvp);
1004                                 goto out;
1005                         }
1006                         nvap->na_rdev = rdev;
1007                         error = VOP_MKNOD(ndp->ni_dvp, &ndp->ni_vp,
1008                             &ndp->ni_cnd, &nvap->na_vattr);
1009                         vput(ndp->ni_dvp);
1010                         nfsvno_relpathbuf(ndp);
1011                         vrele(ndp->ni_startdir);
1012                         if (error)
1013                                 goto out;
1014                 } else {
1015                         vrele(ndp->ni_startdir);
1016                         nfsvno_relpathbuf(ndp);
1017                         vput(ndp->ni_dvp);
1018                         error = ENXIO;
1019                         goto out;
1020                 }
1021                 *vpp = ndp->ni_vp;
1022         } else {
1023                 /*
1024                  * Handle cases where error is already set and/or
1025                  * the file exists.
1026                  * 1 - clean up the lookup
1027                  * 2 - iff !error and na_size set, truncate it
1028                  */
1029                 vrele(ndp->ni_startdir);
1030                 nfsvno_relpathbuf(ndp);
1031                 *vpp = ndp->ni_vp;
1032                 if (ndp->ni_dvp == *vpp)
1033                         vrele(ndp->ni_dvp);
1034                 else
1035                         vput(ndp->ni_dvp);
1036                 if (!error && nvap->na_size != VNOVAL) {
1037                         error = nfsvno_accchk(*vpp, VWRITE,
1038                             nd->nd_cred, exp, p, NFSACCCHK_NOOVERRIDE,
1039                             NFSACCCHK_VPISLOCKED, NULL);
1040                         if (!error) {
1041                                 tempsize = nvap->na_size;
1042                                 NFSVNO_ATTRINIT(nvap);
1043                                 nvap->na_size = tempsize;
1044                                 error = VOP_SETATTR(*vpp,
1045                                     &nvap->na_vattr, nd->nd_cred);
1046                         }
1047                 }
1048                 if (error)
1049                         vput(*vpp);
1050         }
1051
1052 out:
1053         NFSEXITCODE(error);
1054         return (error);
1055 }
1056
1057 /*
1058  * Do a mknod vnode op.
1059  */
1060 int
1061 nfsvno_mknod(struct nameidata *ndp, struct nfsvattr *nvap, struct ucred *cred,
1062     struct thread *p)
1063 {
1064         int error = 0;
1065         enum vtype vtyp;
1066
1067         vtyp = nvap->na_type;
1068         /*
1069          * Iff doesn't exist, create it.
1070          */
1071         if (ndp->ni_vp) {
1072                 vrele(ndp->ni_startdir);
1073                 nfsvno_relpathbuf(ndp);
1074                 vput(ndp->ni_dvp);
1075                 vrele(ndp->ni_vp);
1076                 error = EEXIST;
1077                 goto out;
1078         }
1079         if (vtyp != VCHR && vtyp != VBLK && vtyp != VSOCK && vtyp != VFIFO) {
1080                 vrele(ndp->ni_startdir);
1081                 nfsvno_relpathbuf(ndp);
1082                 vput(ndp->ni_dvp);
1083                 error = NFSERR_BADTYPE;
1084                 goto out;
1085         }
1086         if (vtyp == VSOCK) {
1087                 vrele(ndp->ni_startdir);
1088                 error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
1089                     &ndp->ni_cnd, &nvap->na_vattr);
1090                 vput(ndp->ni_dvp);
1091                 nfsvno_relpathbuf(ndp);
1092         } else {
1093                 if (nvap->na_type != VFIFO &&
1094                     (error = priv_check_cred(cred, PRIV_VFS_MKNOD_DEV))) {
1095                         vrele(ndp->ni_startdir);
1096                         nfsvno_relpathbuf(ndp);
1097                         vput(ndp->ni_dvp);
1098                         goto out;
1099                 }
1100                 error = VOP_MKNOD(ndp->ni_dvp, &ndp->ni_vp,
1101                     &ndp->ni_cnd, &nvap->na_vattr);
1102                 vput(ndp->ni_dvp);
1103                 nfsvno_relpathbuf(ndp);
1104                 vrele(ndp->ni_startdir);
1105                 /*
1106                  * Since VOP_MKNOD returns the ni_vp, I can't
1107                  * see any reason to do the lookup.
1108                  */
1109         }
1110
1111 out:
1112         NFSEXITCODE(error);
1113         return (error);
1114 }
1115
1116 /*
1117  * Mkdir vnode op.
1118  */
1119 int
1120 nfsvno_mkdir(struct nameidata *ndp, struct nfsvattr *nvap, uid_t saved_uid,
1121     struct ucred *cred, struct thread *p, struct nfsexstuff *exp)
1122 {
1123         int error = 0;
1124
1125         if (ndp->ni_vp != NULL) {
1126                 if (ndp->ni_dvp == ndp->ni_vp)
1127                         vrele(ndp->ni_dvp);
1128                 else
1129                         vput(ndp->ni_dvp);
1130                 vrele(ndp->ni_vp);
1131                 nfsvno_relpathbuf(ndp);
1132                 error = EEXIST;
1133                 goto out;
1134         }
1135         error = VOP_MKDIR(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd,
1136             &nvap->na_vattr);
1137         vput(ndp->ni_dvp);
1138         nfsvno_relpathbuf(ndp);
1139
1140 out:
1141         NFSEXITCODE(error);
1142         return (error);
1143 }
1144
1145 /*
1146  * symlink vnode op.
1147  */
1148 int
1149 nfsvno_symlink(struct nameidata *ndp, struct nfsvattr *nvap, char *pathcp,
1150     int pathlen, int not_v2, uid_t saved_uid, struct ucred *cred, struct thread *p,
1151     struct nfsexstuff *exp)
1152 {
1153         int error = 0;
1154
1155         if (ndp->ni_vp) {
1156                 vrele(ndp->ni_startdir);
1157                 nfsvno_relpathbuf(ndp);
1158                 if (ndp->ni_dvp == ndp->ni_vp)
1159                         vrele(ndp->ni_dvp);
1160                 else
1161                         vput(ndp->ni_dvp);
1162                 vrele(ndp->ni_vp);
1163                 error = EEXIST;
1164                 goto out;
1165         }
1166
1167         error = VOP_SYMLINK(ndp->ni_dvp, &ndp->ni_vp, &ndp->ni_cnd,
1168             &nvap->na_vattr, pathcp);
1169         vput(ndp->ni_dvp);
1170         vrele(ndp->ni_startdir);
1171         nfsvno_relpathbuf(ndp);
1172         /*
1173          * Although FreeBSD still had the lookup code in
1174          * it for 7/current, there doesn't seem to be any
1175          * point, since VOP_SYMLINK() returns the ni_vp.
1176          * Just vput it for v2.
1177          */
1178         if (!not_v2 && !error)
1179                 vput(ndp->ni_vp);
1180
1181 out:
1182         NFSEXITCODE(error);
1183         return (error);
1184 }
1185
1186 /*
1187  * Parse symbolic link arguments.
1188  * This function has an ugly side effect. It will malloc() an area for
1189  * the symlink and set iov_base to point to it, only if it succeeds.
1190  * So, if it returns with uiop->uio_iov->iov_base != NULL, that must
1191  * be FREE'd later.
1192  */
1193 int
1194 nfsvno_getsymlink(struct nfsrv_descript *nd, struct nfsvattr *nvap,
1195     struct thread *p, char **pathcpp, int *lenp)
1196 {
1197         u_int32_t *tl;
1198         char *pathcp = NULL;
1199         int error = 0, len;
1200         struct nfsv2_sattr *sp;
1201
1202         *pathcpp = NULL;
1203         *lenp = 0;
1204         if ((nd->nd_flag & ND_NFSV3) &&
1205             (error = nfsrv_sattr(nd, NULL, nvap, NULL, NULL, p)))
1206                 goto nfsmout;
1207         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1208         len = fxdr_unsigned(int, *tl);
1209         if (len > NFS_MAXPATHLEN || len <= 0) {
1210                 error = EBADRPC;
1211                 goto nfsmout;
1212         }
1213         pathcp = malloc(len + 1, M_TEMP, M_WAITOK);
1214         error = nfsrv_mtostr(nd, pathcp, len);
1215         if (error)
1216                 goto nfsmout;
1217         if (nd->nd_flag & ND_NFSV2) {
1218                 NFSM_DISSECT(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1219                 nvap->na_mode = fxdr_unsigned(u_int16_t, sp->sa_mode);
1220         }
1221         *pathcpp = pathcp;
1222         *lenp = len;
1223         NFSEXITCODE2(0, nd);
1224         return (0);
1225 nfsmout:
1226         if (pathcp)
1227                 free(pathcp, M_TEMP);
1228         NFSEXITCODE2(error, nd);
1229         return (error);
1230 }
1231
1232 /*
1233  * Remove a non-directory object.
1234  */
1235 int
1236 nfsvno_removesub(struct nameidata *ndp, int is_v4, struct ucred *cred,
1237     struct thread *p, struct nfsexstuff *exp)
1238 {
1239         struct vnode *vp, *dsdvp[NFSDEV_MAXMIRRORS];
1240         int error = 0, mirrorcnt;
1241         char fname[PNFS_FILENAME_LEN + 1];
1242         fhandle_t fh;
1243
1244         vp = ndp->ni_vp;
1245         dsdvp[0] = NULL;
1246         if (vp->v_type == VDIR)
1247                 error = NFSERR_ISDIR;
1248         else if (is_v4)
1249                 error = nfsrv_checkremove(vp, 1, p);
1250         if (error == 0)
1251                 nfsrv_pnfsremovesetup(vp, p, dsdvp, &mirrorcnt, fname, &fh);
1252         if (!error)
1253                 error = VOP_REMOVE(ndp->ni_dvp, vp, &ndp->ni_cnd);
1254         if (error == 0 && dsdvp[0] != NULL)
1255                 nfsrv_pnfsremove(dsdvp, mirrorcnt, fname, &fh, p);
1256         if (ndp->ni_dvp == vp)
1257                 vrele(ndp->ni_dvp);
1258         else
1259                 vput(ndp->ni_dvp);
1260         vput(vp);
1261         if ((ndp->ni_cnd.cn_flags & SAVENAME) != 0)
1262                 nfsvno_relpathbuf(ndp);
1263         NFSEXITCODE(error);
1264         return (error);
1265 }
1266
1267 /*
1268  * Remove a directory.
1269  */
1270 int
1271 nfsvno_rmdirsub(struct nameidata *ndp, int is_v4, struct ucred *cred,
1272     struct thread *p, struct nfsexstuff *exp)
1273 {
1274         struct vnode *vp;
1275         int error = 0;
1276
1277         vp = ndp->ni_vp;
1278         if (vp->v_type != VDIR) {
1279                 error = ENOTDIR;
1280                 goto out;
1281         }
1282         /*
1283          * No rmdir "." please.
1284          */
1285         if (ndp->ni_dvp == vp) {
1286                 error = EINVAL;
1287                 goto out;
1288         }
1289         /*
1290          * The root of a mounted filesystem cannot be deleted.
1291          */
1292         if (vp->v_vflag & VV_ROOT)
1293                 error = EBUSY;
1294 out:
1295         if (!error)
1296                 error = VOP_RMDIR(ndp->ni_dvp, vp, &ndp->ni_cnd);
1297         if (ndp->ni_dvp == vp)
1298                 vrele(ndp->ni_dvp);
1299         else
1300                 vput(ndp->ni_dvp);
1301         vput(vp);
1302         if ((ndp->ni_cnd.cn_flags & SAVENAME) != 0)
1303                 nfsvno_relpathbuf(ndp);
1304         NFSEXITCODE(error);
1305         return (error);
1306 }
1307
1308 /*
1309  * Rename vnode op.
1310  */
1311 int
1312 nfsvno_rename(struct nameidata *fromndp, struct nameidata *tondp,
1313     u_int32_t ndstat, u_int32_t ndflag, struct ucred *cred, struct thread *p)
1314 {
1315         struct vnode *fvp, *tvp, *tdvp, *dsdvp[NFSDEV_MAXMIRRORS];
1316         int error = 0, mirrorcnt;
1317         char fname[PNFS_FILENAME_LEN + 1];
1318         fhandle_t fh;
1319
1320         dsdvp[0] = NULL;
1321         fvp = fromndp->ni_vp;
1322         if (ndstat) {
1323                 vrele(fromndp->ni_dvp);
1324                 vrele(fvp);
1325                 error = ndstat;
1326                 goto out1;
1327         }
1328         tdvp = tondp->ni_dvp;
1329         tvp = tondp->ni_vp;
1330         if (tvp != NULL) {
1331                 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
1332                         error = (ndflag & ND_NFSV2) ? EISDIR : EEXIST;
1333                         goto out;
1334                 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
1335                         error = (ndflag & ND_NFSV2) ? ENOTDIR : EEXIST;
1336                         goto out;
1337                 }
1338                 if (tvp->v_type == VDIR && tvp->v_mountedhere) {
1339                         error = (ndflag & ND_NFSV2) ? ENOTEMPTY : EXDEV;
1340                         goto out;
1341                 }
1342
1343                 /*
1344                  * A rename to '.' or '..' results in a prematurely
1345                  * unlocked vnode on FreeBSD5, so I'm just going to fail that
1346                  * here.
1347                  */
1348                 if ((tondp->ni_cnd.cn_namelen == 1 &&
1349                      tondp->ni_cnd.cn_nameptr[0] == '.') ||
1350                     (tondp->ni_cnd.cn_namelen == 2 &&
1351                      tondp->ni_cnd.cn_nameptr[0] == '.' &&
1352                      tondp->ni_cnd.cn_nameptr[1] == '.')) {
1353                         error = EINVAL;
1354                         goto out;
1355                 }
1356         }
1357         if (fvp->v_type == VDIR && fvp->v_mountedhere) {
1358                 error = (ndflag & ND_NFSV2) ? ENOTEMPTY : EXDEV;
1359                 goto out;
1360         }
1361         if (fvp->v_mount != tdvp->v_mount) {
1362                 error = (ndflag & ND_NFSV2) ? ENOTEMPTY : EXDEV;
1363                 goto out;
1364         }
1365         if (fvp == tdvp) {
1366                 error = (ndflag & ND_NFSV2) ? ENOTEMPTY : EINVAL;
1367                 goto out;
1368         }
1369         if (fvp == tvp) {
1370                 /*
1371                  * If source and destination are the same, there is nothing to
1372                  * do. Set error to -1 to indicate this.
1373                  */
1374                 error = -1;
1375                 goto out;
1376         }
1377         if (ndflag & ND_NFSV4) {
1378                 if (NFSVOPLOCK(fvp, LK_EXCLUSIVE) == 0) {
1379                         error = nfsrv_checkremove(fvp, 0, p);
1380                         NFSVOPUNLOCK(fvp, 0);
1381                 } else
1382                         error = EPERM;
1383                 if (tvp && !error)
1384                         error = nfsrv_checkremove(tvp, 1, p);
1385         } else {
1386                 /*
1387                  * For NFSv2 and NFSv3, try to get rid of the delegation, so
1388                  * that the NFSv4 client won't be confused by the rename.
1389                  * Since nfsd_recalldelegation() can only be called on an
1390                  * unlocked vnode at this point and fvp is the file that will
1391                  * still exist after the rename, just do fvp.
1392                  */
1393                 nfsd_recalldelegation(fvp, p);
1394         }
1395         if (error == 0 && tvp != NULL) {
1396                 nfsrv_pnfsremovesetup(tvp, p, dsdvp, &mirrorcnt, fname, &fh);
1397                 NFSD_DEBUG(4, "nfsvno_rename: pnfsremovesetup"
1398                     " dsdvp=%p\n", dsdvp[0]);
1399         }
1400 out:
1401         if (!error) {
1402                 error = VOP_RENAME(fromndp->ni_dvp, fromndp->ni_vp,
1403                     &fromndp->ni_cnd, tondp->ni_dvp, tondp->ni_vp,
1404                     &tondp->ni_cnd);
1405         } else {
1406                 if (tdvp == tvp)
1407                         vrele(tdvp);
1408                 else
1409                         vput(tdvp);
1410                 if (tvp)
1411                         vput(tvp);
1412                 vrele(fromndp->ni_dvp);
1413                 vrele(fvp);
1414                 if (error == -1)
1415                         error = 0;
1416         }
1417
1418         /*
1419          * If dsdvp[0] != NULL, it was set up by nfsrv_pnfsremovesetup() and
1420          * if the rename succeeded, the DS file for the tvp needs to be
1421          * removed.
1422          */
1423         if (error == 0 && dsdvp[0] != NULL) {
1424                 nfsrv_pnfsremove(dsdvp, mirrorcnt, fname, &fh, p);
1425                 NFSD_DEBUG(4, "nfsvno_rename: pnfsremove\n");
1426         }
1427
1428         vrele(tondp->ni_startdir);
1429         nfsvno_relpathbuf(tondp);
1430 out1:
1431         vrele(fromndp->ni_startdir);
1432         nfsvno_relpathbuf(fromndp);
1433         NFSEXITCODE(error);
1434         return (error);
1435 }
1436
1437 /*
1438  * Link vnode op.
1439  */
1440 int
1441 nfsvno_link(struct nameidata *ndp, struct vnode *vp, struct ucred *cred,
1442     struct thread *p, struct nfsexstuff *exp)
1443 {
1444         struct vnode *xp;
1445         int error = 0;
1446
1447         xp = ndp->ni_vp;
1448         if (xp != NULL) {
1449                 error = EEXIST;
1450         } else {
1451                 xp = ndp->ni_dvp;
1452                 if (vp->v_mount != xp->v_mount)
1453                         error = EXDEV;
1454         }
1455         if (!error) {
1456                 NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
1457                 if ((vp->v_iflag & VI_DOOMED) == 0)
1458                         error = VOP_LINK(ndp->ni_dvp, vp, &ndp->ni_cnd);
1459                 else
1460                         error = EPERM;
1461                 if (ndp->ni_dvp == vp)
1462                         vrele(ndp->ni_dvp);
1463                 else
1464                         vput(ndp->ni_dvp);
1465                 NFSVOPUNLOCK(vp, 0);
1466         } else {
1467                 if (ndp->ni_dvp == ndp->ni_vp)
1468                         vrele(ndp->ni_dvp);
1469                 else
1470                         vput(ndp->ni_dvp);
1471                 if (ndp->ni_vp)
1472                         vrele(ndp->ni_vp);
1473         }
1474         nfsvno_relpathbuf(ndp);
1475         NFSEXITCODE(error);
1476         return (error);
1477 }
1478
1479 /*
1480  * Do the fsync() appropriate for the commit.
1481  */
1482 int
1483 nfsvno_fsync(struct vnode *vp, u_int64_t off, int cnt, struct ucred *cred,
1484     struct thread *td)
1485 {
1486         int error = 0;
1487
1488         /*
1489          * RFC 1813 3.3.21: if count is 0, a flush from offset to the end of
1490          * file is done.  At this time VOP_FSYNC does not accept offset and
1491          * byte count parameters so call VOP_FSYNC the whole file for now.
1492          * The same is true for NFSv4: RFC 3530 Sec. 14.2.3.
1493          * File systems that do not use the buffer cache (as indicated
1494          * by MNTK_USES_BCACHE not being set) must use VOP_FSYNC().
1495          */
1496         if (cnt == 0 || cnt > MAX_COMMIT_COUNT ||
1497             (vp->v_mount->mnt_kern_flag & MNTK_USES_BCACHE) == 0) {
1498                 /*
1499                  * Give up and do the whole thing
1500                  */
1501                 if (vp->v_object &&
1502                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
1503                         VM_OBJECT_WLOCK(vp->v_object);
1504                         vm_object_page_clean(vp->v_object, 0, 0, OBJPC_SYNC);
1505                         VM_OBJECT_WUNLOCK(vp->v_object);
1506                 }
1507                 error = VOP_FSYNC(vp, MNT_WAIT, td);
1508         } else {
1509                 /*
1510                  * Locate and synchronously write any buffers that fall
1511                  * into the requested range.  Note:  we are assuming that
1512                  * f_iosize is a power of 2.
1513                  */
1514                 int iosize = vp->v_mount->mnt_stat.f_iosize;
1515                 int iomask = iosize - 1;
1516                 struct bufobj *bo;
1517                 daddr_t lblkno;
1518
1519                 /*
1520                  * Align to iosize boundary, super-align to page boundary.
1521                  */
1522                 if (off & iomask) {
1523                         cnt += off & iomask;
1524                         off &= ~(u_quad_t)iomask;
1525                 }
1526                 if (off & PAGE_MASK) {
1527                         cnt += off & PAGE_MASK;
1528                         off &= ~(u_quad_t)PAGE_MASK;
1529                 }
1530                 lblkno = off / iosize;
1531
1532                 if (vp->v_object &&
1533                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
1534                         VM_OBJECT_WLOCK(vp->v_object);
1535                         vm_object_page_clean(vp->v_object, off, off + cnt,
1536                             OBJPC_SYNC);
1537                         VM_OBJECT_WUNLOCK(vp->v_object);
1538                 }
1539
1540                 bo = &vp->v_bufobj;
1541                 BO_LOCK(bo);
1542                 while (cnt > 0) {
1543                         struct buf *bp;
1544
1545                         /*
1546                          * If we have a buffer and it is marked B_DELWRI we
1547                          * have to lock and write it.  Otherwise the prior
1548                          * write is assumed to have already been committed.
1549                          *
1550                          * gbincore() can return invalid buffers now so we
1551                          * have to check that bit as well (though B_DELWRI
1552                          * should not be set if B_INVAL is set there could be
1553                          * a race here since we haven't locked the buffer).
1554                          */
1555                         if ((bp = gbincore(&vp->v_bufobj, lblkno)) != NULL) {
1556                                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_SLEEPFAIL |
1557                                     LK_INTERLOCK, BO_LOCKPTR(bo)) == ENOLCK) {
1558                                         BO_LOCK(bo);
1559                                         continue; /* retry */
1560                                 }
1561                                 if ((bp->b_flags & (B_DELWRI|B_INVAL)) ==
1562                                     B_DELWRI) {
1563                                         bremfree(bp);
1564                                         bp->b_flags &= ~B_ASYNC;
1565                                         bwrite(bp);
1566                                         ++nfs_commit_miss;
1567                                 } else
1568                                         BUF_UNLOCK(bp);
1569                                 BO_LOCK(bo);
1570                         }
1571                         ++nfs_commit_blks;
1572                         if (cnt < iosize)
1573                                 break;
1574                         cnt -= iosize;
1575                         ++lblkno;
1576                 }
1577                 BO_UNLOCK(bo);
1578         }
1579         NFSEXITCODE(error);
1580         return (error);
1581 }
1582
1583 /*
1584  * Statfs vnode op.
1585  */
1586 int
1587 nfsvno_statfs(struct vnode *vp, struct statfs *sf)
1588 {
1589         struct statfs *tsf;
1590         int error;
1591
1592         tsf = NULL;
1593         if (nfsrv_devidcnt > 0) {
1594                 /* For a pNFS service, get the DS numbers. */
1595                 tsf = malloc(sizeof(*tsf), M_TEMP, M_WAITOK | M_ZERO);
1596                 error = nfsrv_pnfsstatfs(tsf, vp->v_mount);
1597                 if (error != 0) {
1598                         free(tsf, M_TEMP);
1599                         tsf = NULL;
1600                 }
1601         }
1602         error = VFS_STATFS(vp->v_mount, sf);
1603         if (error == 0) {
1604                 if (tsf != NULL) {
1605                         sf->f_blocks = tsf->f_blocks;
1606                         sf->f_bavail = tsf->f_bavail;
1607                         sf->f_bfree = tsf->f_bfree;
1608                         sf->f_bsize = tsf->f_bsize;
1609                 }
1610                 /*
1611                  * Since NFS handles these values as unsigned on the
1612                  * wire, there is no way to represent negative values,
1613                  * so set them to 0. Without this, they will appear
1614                  * to be very large positive values for clients like
1615                  * Solaris10.
1616                  */
1617                 if (sf->f_bavail < 0)
1618                         sf->f_bavail = 0;
1619                 if (sf->f_ffree < 0)
1620                         sf->f_ffree = 0;
1621         }
1622         free(tsf, M_TEMP);
1623         NFSEXITCODE(error);
1624         return (error);
1625 }
1626
1627 /*
1628  * Do the vnode op stuff for Open. Similar to nfsvno_createsub(), but
1629  * must handle nfsrv_opencheck() calls after any other access checks.
1630  */
1631 void
1632 nfsvno_open(struct nfsrv_descript *nd, struct nameidata *ndp,
1633     nfsquad_t clientid, nfsv4stateid_t *stateidp, struct nfsstate *stp,
1634     int *exclusive_flagp, struct nfsvattr *nvap, int32_t *cverf, int create,
1635     NFSACL_T *aclp, nfsattrbit_t *attrbitp, struct ucred *cred,
1636     struct nfsexstuff *exp, struct vnode **vpp)
1637 {
1638         struct vnode *vp = NULL;
1639         u_quad_t tempsize;
1640         struct nfsexstuff nes;
1641         struct thread *p = curthread;
1642
1643         if (ndp->ni_vp == NULL)
1644                 nd->nd_repstat = nfsrv_opencheck(clientid,
1645                     stateidp, stp, NULL, nd, p, nd->nd_repstat);
1646         if (!nd->nd_repstat) {
1647                 if (ndp->ni_vp == NULL) {
1648                         vrele(ndp->ni_startdir);
1649                         nd->nd_repstat = VOP_CREATE(ndp->ni_dvp,
1650                             &ndp->ni_vp, &ndp->ni_cnd, &nvap->na_vattr);
1651                         /* For a pNFS server, create the data file on a DS. */
1652                         if (nd->nd_repstat == 0) {
1653                                 /*
1654                                  * Create a data file on a DS for a pNFS server.
1655                                  * This function just returns if not
1656                                  * running a pNFS DS or the creation fails.
1657                                  */
1658                                 nfsrv_pnfscreate(ndp->ni_vp, &nvap->na_vattr,
1659                                     cred, p);
1660                         }
1661                         vput(ndp->ni_dvp);
1662                         nfsvno_relpathbuf(ndp);
1663                         if (!nd->nd_repstat) {
1664                                 if (*exclusive_flagp) {
1665                                         *exclusive_flagp = 0;
1666                                         NFSVNO_ATTRINIT(nvap);
1667                                         nvap->na_atime.tv_sec = cverf[0];
1668                                         nvap->na_atime.tv_nsec = cverf[1];
1669                                         nd->nd_repstat = VOP_SETATTR(ndp->ni_vp,
1670                                             &nvap->na_vattr, cred);
1671                                         if (nd->nd_repstat != 0) {
1672                                                 vput(ndp->ni_vp);
1673                                                 ndp->ni_vp = NULL;
1674                                                 nd->nd_repstat = NFSERR_NOTSUPP;
1675                                         } else
1676                                                 NFSSETBIT_ATTRBIT(attrbitp,
1677                                                     NFSATTRBIT_TIMEACCESS);
1678                                 } else {
1679                                         nfsrv_fixattr(nd, ndp->ni_vp, nvap,
1680                                             aclp, p, attrbitp, exp);
1681                                 }
1682                         }
1683                         vp = ndp->ni_vp;
1684                 } else {
1685                         if (ndp->ni_startdir)
1686                                 vrele(ndp->ni_startdir);
1687                         nfsvno_relpathbuf(ndp);
1688                         vp = ndp->ni_vp;
1689                         if (create == NFSV4OPEN_CREATE) {
1690                                 if (ndp->ni_dvp == vp)
1691                                         vrele(ndp->ni_dvp);
1692                                 else
1693                                         vput(ndp->ni_dvp);
1694                         }
1695                         if (NFSVNO_ISSETSIZE(nvap) && vp->v_type == VREG) {
1696                                 if (ndp->ni_cnd.cn_flags & RDONLY)
1697                                         NFSVNO_SETEXRDONLY(&nes);
1698                                 else
1699                                         NFSVNO_EXINIT(&nes);
1700                                 nd->nd_repstat = nfsvno_accchk(vp,
1701                                     VWRITE, cred, &nes, p,
1702                                     NFSACCCHK_NOOVERRIDE,
1703                                     NFSACCCHK_VPISLOCKED, NULL);
1704                                 nd->nd_repstat = nfsrv_opencheck(clientid,
1705                                     stateidp, stp, vp, nd, p, nd->nd_repstat);
1706                                 if (!nd->nd_repstat) {
1707                                         tempsize = nvap->na_size;
1708                                         NFSVNO_ATTRINIT(nvap);
1709                                         nvap->na_size = tempsize;
1710                                         nd->nd_repstat = VOP_SETATTR(vp,
1711                                             &nvap->na_vattr, cred);
1712                                 }
1713                         } else if (vp->v_type == VREG) {
1714                                 nd->nd_repstat = nfsrv_opencheck(clientid,
1715                                     stateidp, stp, vp, nd, p, nd->nd_repstat);
1716                         }
1717                 }
1718         } else {
1719                 if (ndp->ni_cnd.cn_flags & HASBUF)
1720                         nfsvno_relpathbuf(ndp);
1721                 if (ndp->ni_startdir && create == NFSV4OPEN_CREATE) {
1722                         vrele(ndp->ni_startdir);
1723                         if (ndp->ni_dvp == ndp->ni_vp)
1724                                 vrele(ndp->ni_dvp);
1725                         else
1726                                 vput(ndp->ni_dvp);
1727                         if (ndp->ni_vp)
1728                                 vput(ndp->ni_vp);
1729                 }
1730         }
1731         *vpp = vp;
1732
1733         NFSEXITCODE2(0, nd);
1734 }
1735
1736 /*
1737  * Updates the file rev and sets the mtime and ctime
1738  * to the current clock time, returning the va_filerev and va_Xtime
1739  * values.
1740  * Return ESTALE to indicate the vnode is VI_DOOMED.
1741  */
1742 int
1743 nfsvno_updfilerev(struct vnode *vp, struct nfsvattr *nvap,
1744     struct nfsrv_descript *nd, struct thread *p)
1745 {
1746         struct vattr va;
1747
1748         VATTR_NULL(&va);
1749         vfs_timestamp(&va.va_mtime);
1750         if (NFSVOPISLOCKED(vp) != LK_EXCLUSIVE) {
1751                 NFSVOPLOCK(vp, LK_UPGRADE | LK_RETRY);
1752                 if ((vp->v_iflag & VI_DOOMED) != 0)
1753                         return (ESTALE);
1754         }
1755         (void) VOP_SETATTR(vp, &va, nd->nd_cred);
1756         (void) nfsvno_getattr(vp, nvap, nd, p, 1, NULL);
1757         return (0);
1758 }
1759
1760 /*
1761  * Glue routine to nfsv4_fillattr().
1762  */
1763 int
1764 nfsvno_fillattr(struct nfsrv_descript *nd, struct mount *mp, struct vnode *vp,
1765     struct nfsvattr *nvap, fhandle_t *fhp, int rderror, nfsattrbit_t *attrbitp,
1766     struct ucred *cred, struct thread *p, int isdgram, int reterr,
1767     int supports_nfsv4acls, int at_root, uint64_t mounted_on_fileno)
1768 {
1769         struct statfs *sf;
1770         int error;
1771
1772         sf = NULL;
1773         if (nfsrv_devidcnt > 0 &&
1774             (NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_SPACEAVAIL) ||
1775              NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_SPACEFREE) ||
1776              NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_SPACETOTAL))) {
1777                 sf = malloc(sizeof(*sf), M_TEMP, M_WAITOK | M_ZERO);
1778                 error = nfsrv_pnfsstatfs(sf, mp);
1779                 if (error != 0) {
1780                         free(sf, M_TEMP);
1781                         sf = NULL;
1782                 }
1783         }
1784         error = nfsv4_fillattr(nd, mp, vp, NULL, &nvap->na_vattr, fhp, rderror,
1785             attrbitp, cred, p, isdgram, reterr, supports_nfsv4acls, at_root,
1786             mounted_on_fileno, sf);
1787         free(sf, M_TEMP);
1788         NFSEXITCODE2(0, nd);
1789         return (error);
1790 }
1791
1792 /* Since the Readdir vnode ops vary, put the entire functions in here. */
1793 /*
1794  * nfs readdir service
1795  * - mallocs what it thinks is enough to read
1796  *      count rounded up to a multiple of DIRBLKSIZ <= NFS_MAXREADDIR
1797  * - calls VOP_READDIR()
1798  * - loops around building the reply
1799  *      if the output generated exceeds count break out of loop
1800  *      The NFSM_CLGET macro is used here so that the reply will be packed
1801  *      tightly in mbuf clusters.
1802  * - it trims out records with d_fileno == 0
1803  *      this doesn't matter for Unix clients, but they might confuse clients
1804  *      for other os'.
1805  * - it trims out records with d_type == DT_WHT
1806  *      these cannot be seen through NFS (unless we extend the protocol)
1807  *     The alternate call nfsrvd_readdirplus() does lookups as well.
1808  * PS: The NFS protocol spec. does not clarify what the "count" byte
1809  *      argument is a count of.. just name strings and file id's or the
1810  *      entire reply rpc or ...
1811  *      I tried just file name and id sizes and it confused the Sun client,
1812  *      so I am using the full rpc size now. The "paranoia.." comment refers
1813  *      to including the status longwords that are not a part of the dir.
1814  *      "entry" structures, but are in the rpc.
1815  */
1816 int
1817 nfsrvd_readdir(struct nfsrv_descript *nd, int isdgram,
1818     struct vnode *vp, struct nfsexstuff *exp)
1819 {
1820         struct dirent *dp;
1821         u_int32_t *tl;
1822         int dirlen;
1823         char *cpos, *cend, *rbuf;
1824         struct nfsvattr at;
1825         int nlen, error = 0, getret = 1;
1826         int siz, cnt, fullsiz, eofflag, ncookies;
1827         u_int64_t off, toff, verf __unused;
1828         u_long *cookies = NULL, *cookiep;
1829         struct uio io;
1830         struct iovec iv;
1831         int is_ufs;
1832         struct thread *p = curthread;
1833
1834         if (nd->nd_repstat) {
1835                 nfsrv_postopattr(nd, getret, &at);
1836                 goto out;
1837         }
1838         if (nd->nd_flag & ND_NFSV2) {
1839                 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1840                 off = fxdr_unsigned(u_quad_t, *tl++);
1841         } else {
1842                 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1843                 off = fxdr_hyper(tl);
1844                 tl += 2;
1845                 verf = fxdr_hyper(tl);
1846                 tl += 2;
1847         }
1848         toff = off;
1849         cnt = fxdr_unsigned(int, *tl);
1850         if (cnt > NFS_SRVMAXDATA(nd) || cnt < 0)
1851                 cnt = NFS_SRVMAXDATA(nd);
1852         siz = ((cnt + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
1853         fullsiz = siz;
1854         if (nd->nd_flag & ND_NFSV3) {
1855                 nd->nd_repstat = getret = nfsvno_getattr(vp, &at, nd, p, 1,
1856                     NULL);
1857 #if 0
1858                 /*
1859                  * va_filerev is not sufficient as a cookie verifier,
1860                  * since it is not supposed to change when entries are
1861                  * removed/added unless that offset cookies returned to
1862                  * the client are no longer valid.
1863                  */
1864                 if (!nd->nd_repstat && toff && verf != at.na_filerev)
1865                         nd->nd_repstat = NFSERR_BAD_COOKIE;
1866 #endif
1867         }
1868         if (!nd->nd_repstat && vp->v_type != VDIR)
1869                 nd->nd_repstat = NFSERR_NOTDIR;
1870         if (nd->nd_repstat == 0 && cnt == 0) {
1871                 if (nd->nd_flag & ND_NFSV2)
1872                         /* NFSv2 does not have NFSERR_TOOSMALL */
1873                         nd->nd_repstat = EPERM;
1874                 else
1875                         nd->nd_repstat = NFSERR_TOOSMALL;
1876         }
1877         if (!nd->nd_repstat)
1878                 nd->nd_repstat = nfsvno_accchk(vp, VEXEC,
1879                     nd->nd_cred, exp, p, NFSACCCHK_NOOVERRIDE,
1880                     NFSACCCHK_VPISLOCKED, NULL);
1881         if (nd->nd_repstat) {
1882                 vput(vp);
1883                 if (nd->nd_flag & ND_NFSV3)
1884                         nfsrv_postopattr(nd, getret, &at);
1885                 goto out;
1886         }
1887         is_ufs = strcmp(vp->v_mount->mnt_vfc->vfc_name, "ufs") == 0;
1888         rbuf = malloc(siz, M_TEMP, M_WAITOK);
1889 again:
1890         eofflag = 0;
1891         if (cookies) {
1892                 free(cookies, M_TEMP);
1893                 cookies = NULL;
1894         }
1895
1896         iv.iov_base = rbuf;
1897         iv.iov_len = siz;
1898         io.uio_iov = &iv;
1899         io.uio_iovcnt = 1;
1900         io.uio_offset = (off_t)off;
1901         io.uio_resid = siz;
1902         io.uio_segflg = UIO_SYSSPACE;
1903         io.uio_rw = UIO_READ;
1904         io.uio_td = NULL;
1905         nd->nd_repstat = VOP_READDIR(vp, &io, nd->nd_cred, &eofflag, &ncookies,
1906             &cookies);
1907         off = (u_int64_t)io.uio_offset;
1908         if (io.uio_resid)
1909                 siz -= io.uio_resid;
1910
1911         if (!cookies && !nd->nd_repstat)
1912                 nd->nd_repstat = NFSERR_PERM;
1913         if (nd->nd_flag & ND_NFSV3) {
1914                 getret = nfsvno_getattr(vp, &at, nd, p, 1, NULL);
1915                 if (!nd->nd_repstat)
1916                         nd->nd_repstat = getret;
1917         }
1918
1919         /*
1920          * Handles the failed cases. nd->nd_repstat == 0 past here.
1921          */
1922         if (nd->nd_repstat) {
1923                 vput(vp);
1924                 free(rbuf, M_TEMP);
1925                 if (cookies)
1926                         free(cookies, M_TEMP);
1927                 if (nd->nd_flag & ND_NFSV3)
1928                         nfsrv_postopattr(nd, getret, &at);
1929                 goto out;
1930         }
1931         /*
1932          * If nothing read, return eof
1933          * rpc reply
1934          */
1935         if (siz == 0) {
1936                 vput(vp);
1937                 if (nd->nd_flag & ND_NFSV2) {
1938                         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1939                 } else {
1940                         nfsrv_postopattr(nd, getret, &at);
1941                         NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
1942                         txdr_hyper(at.na_filerev, tl);
1943                         tl += 2;
1944                 }
1945                 *tl++ = newnfs_false;
1946                 *tl = newnfs_true;
1947                 free(rbuf, M_TEMP);
1948                 free(cookies, M_TEMP);
1949                 goto out;
1950         }
1951
1952         /*
1953          * Check for degenerate cases of nothing useful read.
1954          * If so go try again
1955          */
1956         cpos = rbuf;
1957         cend = rbuf + siz;
1958         dp = (struct dirent *)cpos;
1959         cookiep = cookies;
1960
1961         /*
1962          * For some reason FreeBSD's ufs_readdir() chooses to back the
1963          * directory offset up to a block boundary, so it is necessary to
1964          * skip over the records that precede the requested offset. This
1965          * requires the assumption that file offset cookies monotonically
1966          * increase.
1967          */
1968         while (cpos < cend && ncookies > 0 &&
1969             (dp->d_fileno == 0 || dp->d_type == DT_WHT ||
1970              (is_ufs == 1 && ((u_quad_t)(*cookiep)) <= toff))) {
1971                 cpos += dp->d_reclen;
1972                 dp = (struct dirent *)cpos;
1973                 cookiep++;
1974                 ncookies--;
1975         }
1976         if (cpos >= cend || ncookies == 0) {
1977                 siz = fullsiz;
1978                 toff = off;
1979                 goto again;
1980         }
1981         vput(vp);
1982
1983         /*
1984          * dirlen is the size of the reply, including all XDR and must
1985          * not exceed cnt. For NFSv2, RFC1094 didn't clearly indicate
1986          * if the XDR should be included in "count", but to be safe, we do.
1987          * (Include the two booleans at the end of the reply in dirlen now.)
1988          */
1989         if (nd->nd_flag & ND_NFSV3) {
1990                 nfsrv_postopattr(nd, getret, &at);
1991                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1992                 txdr_hyper(at.na_filerev, tl);
1993                 dirlen = NFSX_V3POSTOPATTR + NFSX_VERF + 2 * NFSX_UNSIGNED;
1994         } else {
1995                 dirlen = 2 * NFSX_UNSIGNED;
1996         }
1997
1998         /* Loop through the records and build reply */
1999         while (cpos < cend && ncookies > 0) {
2000                 nlen = dp->d_namlen;
2001                 if (dp->d_fileno != 0 && dp->d_type != DT_WHT &&
2002                         nlen <= NFS_MAXNAMLEN) {
2003                         if (nd->nd_flag & ND_NFSV3)
2004                                 dirlen += (6*NFSX_UNSIGNED + NFSM_RNDUP(nlen));
2005                         else
2006                                 dirlen += (4*NFSX_UNSIGNED + NFSM_RNDUP(nlen));
2007                         if (dirlen > cnt) {
2008                                 eofflag = 0;
2009                                 break;
2010                         }
2011
2012                         /*
2013                          * Build the directory record xdr from
2014                          * the dirent entry.
2015                          */
2016                         if (nd->nd_flag & ND_NFSV3) {
2017                                 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2018                                 *tl++ = newnfs_true;
2019                                 *tl++ = 0;
2020                         } else {
2021                                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2022                                 *tl++ = newnfs_true;
2023                         }
2024                         *tl = txdr_unsigned(dp->d_fileno);
2025                         (void) nfsm_strtom(nd, dp->d_name, nlen);
2026                         if (nd->nd_flag & ND_NFSV3) {
2027                                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2028                                 *tl++ = 0;
2029                         } else
2030                                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2031                         *tl = txdr_unsigned(*cookiep);
2032                 }
2033                 cpos += dp->d_reclen;
2034                 dp = (struct dirent *)cpos;
2035                 cookiep++;
2036                 ncookies--;
2037         }
2038         if (cpos < cend)
2039                 eofflag = 0;
2040         NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2041         *tl++ = newnfs_false;
2042         if (eofflag)
2043                 *tl = newnfs_true;
2044         else
2045                 *tl = newnfs_false;
2046         free(rbuf, M_TEMP);
2047         free(cookies, M_TEMP);
2048
2049 out:
2050         NFSEXITCODE2(0, nd);
2051         return (0);
2052 nfsmout:
2053         vput(vp);
2054         NFSEXITCODE2(error, nd);
2055         return (error);
2056 }
2057
2058 /*
2059  * Readdirplus for V3 and Readdir for V4.
2060  */
2061 int
2062 nfsrvd_readdirplus(struct nfsrv_descript *nd, int isdgram,
2063     struct vnode *vp, struct nfsexstuff *exp)
2064 {
2065         struct dirent *dp;
2066         u_int32_t *tl;
2067         int dirlen;
2068         char *cpos, *cend, *rbuf;
2069         struct vnode *nvp;
2070         fhandle_t nfh;
2071         struct nfsvattr nva, at, *nvap = &nva;
2072         struct mbuf *mb0, *mb1;
2073         struct nfsreferral *refp;
2074         int nlen, r, error = 0, getret = 1, usevget = 1;
2075         int siz, cnt, fullsiz, eofflag, ncookies, entrycnt;
2076         caddr_t bpos0, bpos1;
2077         u_int64_t off, toff, verf;
2078         u_long *cookies = NULL, *cookiep;
2079         nfsattrbit_t attrbits, rderrbits, savbits;
2080         struct uio io;
2081         struct iovec iv;
2082         struct componentname cn;
2083         int at_root, is_ufs, is_zfs, needs_unbusy, supports_nfsv4acls;
2084         struct mount *mp, *new_mp;
2085         uint64_t mounted_on_fileno;
2086         struct thread *p = curthread;
2087
2088         if (nd->nd_repstat) {
2089                 nfsrv_postopattr(nd, getret, &at);
2090                 goto out;
2091         }
2092         NFSM_DISSECT(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
2093         off = fxdr_hyper(tl);
2094         toff = off;
2095         tl += 2;
2096         verf = fxdr_hyper(tl);
2097         tl += 2;
2098         siz = fxdr_unsigned(int, *tl++);
2099         cnt = fxdr_unsigned(int, *tl);
2100
2101         /*
2102          * Use the server's maximum data transfer size as the upper bound
2103          * on reply datalen.
2104          */
2105         if (cnt > NFS_SRVMAXDATA(nd) || cnt < 0)
2106                 cnt = NFS_SRVMAXDATA(nd);
2107
2108         /*
2109          * siz is a "hint" of how much directory information (name, fileid,
2110          * cookie) should be in the reply. At least one client "hints" 0,
2111          * so I set it to cnt for that case. I also round it up to the
2112          * next multiple of DIRBLKSIZ.
2113          * Since the size of a Readdirplus directory entry reply will always
2114          * be greater than a directory entry returned by VOP_READDIR(), it
2115          * does not make sense to read more than NFS_SRVMAXDATA() via
2116          * VOP_READDIR().
2117          */
2118         if (siz <= 0)
2119                 siz = cnt;
2120         else if (siz > NFS_SRVMAXDATA(nd))
2121                 siz = NFS_SRVMAXDATA(nd);
2122         siz = ((siz + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
2123
2124         if (nd->nd_flag & ND_NFSV4) {
2125                 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
2126                 if (error)
2127                         goto nfsmout;
2128                 NFSSET_ATTRBIT(&savbits, &attrbits);
2129                 NFSCLRNOTFILLABLE_ATTRBIT(&attrbits);
2130                 NFSZERO_ATTRBIT(&rderrbits);
2131                 NFSSETBIT_ATTRBIT(&rderrbits, NFSATTRBIT_RDATTRERROR);
2132         } else {
2133                 NFSZERO_ATTRBIT(&attrbits);
2134         }
2135         fullsiz = siz;
2136         nd->nd_repstat = getret = nfsvno_getattr(vp, &at, nd, p, 1, NULL);
2137 #if 0
2138         if (!nd->nd_repstat) {
2139             if (off && verf != at.na_filerev) {
2140                 /*
2141                  * va_filerev is not sufficient as a cookie verifier,
2142                  * since it is not supposed to change when entries are
2143                  * removed/added unless that offset cookies returned to
2144                  * the client are no longer valid.
2145                  */
2146                 if (nd->nd_flag & ND_NFSV4) {
2147                         nd->nd_repstat = NFSERR_NOTSAME;
2148                 } else {
2149                         nd->nd_repstat = NFSERR_BAD_COOKIE;
2150                 }
2151             }
2152         }
2153 #endif
2154         if (!nd->nd_repstat && vp->v_type != VDIR)
2155                 nd->nd_repstat = NFSERR_NOTDIR;
2156         if (!nd->nd_repstat && cnt == 0)
2157                 nd->nd_repstat = NFSERR_TOOSMALL;
2158         if (!nd->nd_repstat)
2159                 nd->nd_repstat = nfsvno_accchk(vp, VEXEC,
2160                     nd->nd_cred, exp, p, NFSACCCHK_NOOVERRIDE,
2161                     NFSACCCHK_VPISLOCKED, NULL);
2162         if (nd->nd_repstat) {
2163                 vput(vp);
2164                 if (nd->nd_flag & ND_NFSV3)
2165                         nfsrv_postopattr(nd, getret, &at);
2166                 goto out;
2167         }
2168         is_ufs = strcmp(vp->v_mount->mnt_vfc->vfc_name, "ufs") == 0;
2169         is_zfs = strcmp(vp->v_mount->mnt_vfc->vfc_name, "zfs") == 0;
2170
2171         rbuf = malloc(siz, M_TEMP, M_WAITOK);
2172 again:
2173         eofflag = 0;
2174         if (cookies) {
2175                 free(cookies, M_TEMP);
2176                 cookies = NULL;
2177         }
2178
2179         iv.iov_base = rbuf;
2180         iv.iov_len = siz;
2181         io.uio_iov = &iv;
2182         io.uio_iovcnt = 1;
2183         io.uio_offset = (off_t)off;
2184         io.uio_resid = siz;
2185         io.uio_segflg = UIO_SYSSPACE;
2186         io.uio_rw = UIO_READ;
2187         io.uio_td = NULL;
2188         nd->nd_repstat = VOP_READDIR(vp, &io, nd->nd_cred, &eofflag, &ncookies,
2189             &cookies);
2190         off = (u_int64_t)io.uio_offset;
2191         if (io.uio_resid)
2192                 siz -= io.uio_resid;
2193
2194         getret = nfsvno_getattr(vp, &at, nd, p, 1, NULL);
2195
2196         if (!cookies && !nd->nd_repstat)
2197                 nd->nd_repstat = NFSERR_PERM;
2198         if (!nd->nd_repstat)
2199                 nd->nd_repstat = getret;
2200         if (nd->nd_repstat) {
2201                 vput(vp);
2202                 if (cookies)
2203                         free(cookies, M_TEMP);
2204                 free(rbuf, M_TEMP);
2205                 if (nd->nd_flag & ND_NFSV3)
2206                         nfsrv_postopattr(nd, getret, &at);
2207                 goto out;
2208         }
2209         /*
2210          * If nothing read, return eof
2211          * rpc reply
2212          */
2213         if (siz == 0) {
2214                 vput(vp);
2215                 if (nd->nd_flag & ND_NFSV3)
2216                         nfsrv_postopattr(nd, getret, &at);
2217                 NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
2218                 txdr_hyper(at.na_filerev, tl);
2219                 tl += 2;
2220                 *tl++ = newnfs_false;
2221                 *tl = newnfs_true;
2222                 free(cookies, M_TEMP);
2223                 free(rbuf, M_TEMP);
2224                 goto out;
2225         }
2226
2227         /*
2228          * Check for degenerate cases of nothing useful read.
2229          * If so go try again
2230          */
2231         cpos = rbuf;
2232         cend = rbuf + siz;
2233         dp = (struct dirent *)cpos;
2234         cookiep = cookies;
2235
2236         /*
2237          * For some reason FreeBSD's ufs_readdir() chooses to back the
2238          * directory offset up to a block boundary, so it is necessary to
2239          * skip over the records that precede the requested offset. This
2240          * requires the assumption that file offset cookies monotonically
2241          * increase.
2242          */
2243         while (cpos < cend && ncookies > 0 &&
2244           (dp->d_fileno == 0 || dp->d_type == DT_WHT ||
2245            (is_ufs == 1 && ((u_quad_t)(*cookiep)) <= toff) ||
2246            ((nd->nd_flag & ND_NFSV4) &&
2247             ((dp->d_namlen == 1 && dp->d_name[0] == '.') ||
2248              (dp->d_namlen==2 && dp->d_name[0]=='.' && dp->d_name[1]=='.'))))) {
2249                 cpos += dp->d_reclen;
2250                 dp = (struct dirent *)cpos;
2251                 cookiep++;
2252                 ncookies--;
2253         }
2254         if (cpos >= cend || ncookies == 0) {
2255                 siz = fullsiz;
2256                 toff = off;
2257                 goto again;
2258         }
2259
2260         /*
2261          * Busy the file system so that the mount point won't go away
2262          * and, as such, VFS_VGET() can be used safely.
2263          */
2264         mp = vp->v_mount;
2265         vfs_ref(mp);
2266         NFSVOPUNLOCK(vp, 0);
2267         nd->nd_repstat = vfs_busy(mp, 0);
2268         vfs_rel(mp);
2269         if (nd->nd_repstat != 0) {
2270                 vrele(vp);
2271                 free(cookies, M_TEMP);
2272                 free(rbuf, M_TEMP);
2273                 if (nd->nd_flag & ND_NFSV3)
2274                         nfsrv_postopattr(nd, getret, &at);
2275                 goto out;
2276         }
2277
2278         /*
2279          * Check to see if entries in this directory can be safely acquired
2280          * via VFS_VGET() or if a switch to VOP_LOOKUP() is required.
2281          * ZFS snapshot directories need VOP_LOOKUP(), so that any
2282          * automount of the snapshot directory that is required will
2283          * be done.
2284          * This needs to be done here for NFSv4, since NFSv4 never does
2285          * a VFS_VGET() for "." or "..".
2286          */
2287         if (is_zfs == 1) {
2288                 r = VFS_VGET(mp, at.na_fileid, LK_SHARED, &nvp);
2289                 if (r == EOPNOTSUPP) {
2290                         usevget = 0;
2291                         cn.cn_nameiop = LOOKUP;
2292                         cn.cn_lkflags = LK_SHARED | LK_RETRY;
2293                         cn.cn_cred = nd->nd_cred;
2294                         cn.cn_thread = p;
2295                 } else if (r == 0)
2296                         vput(nvp);
2297         }
2298
2299         /*
2300          * Save this position, in case there is an error before one entry
2301          * is created.
2302          */
2303         mb0 = nd->nd_mb;
2304         bpos0 = nd->nd_bpos;
2305
2306         /*
2307          * Fill in the first part of the reply.
2308          * dirlen is the reply length in bytes and cannot exceed cnt.
2309          * (Include the two booleans at the end of the reply in dirlen now,
2310          *  so we recognize when we have exceeded cnt.)
2311          */
2312         if (nd->nd_flag & ND_NFSV3) {
2313                 dirlen = NFSX_V3POSTOPATTR + NFSX_VERF + 2 * NFSX_UNSIGNED;
2314                 nfsrv_postopattr(nd, getret, &at);
2315         } else {
2316                 dirlen = NFSX_VERF + 2 * NFSX_UNSIGNED;
2317         }
2318         NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
2319         txdr_hyper(at.na_filerev, tl);
2320
2321         /*
2322          * Save this position, in case there is an empty reply needed.
2323          */
2324         mb1 = nd->nd_mb;
2325         bpos1 = nd->nd_bpos;
2326
2327         /* Loop through the records and build reply */
2328         entrycnt = 0;
2329         while (cpos < cend && ncookies > 0 && dirlen < cnt) {
2330                 nlen = dp->d_namlen;
2331                 if (dp->d_fileno != 0 && dp->d_type != DT_WHT &&
2332                     nlen <= NFS_MAXNAMLEN &&
2333                     ((nd->nd_flag & ND_NFSV3) || nlen > 2 ||
2334                      (nlen==2 && (dp->d_name[0]!='.' || dp->d_name[1]!='.'))
2335                       || (nlen == 1 && dp->d_name[0] != '.'))) {
2336                         /*
2337                          * Save the current position in the reply, in case
2338                          * this entry exceeds cnt.
2339                          */
2340                         mb1 = nd->nd_mb;
2341                         bpos1 = nd->nd_bpos;
2342
2343                         /*
2344                          * For readdir_and_lookup get the vnode using
2345                          * the file number.
2346                          */
2347                         nvp = NULL;
2348                         refp = NULL;
2349                         r = 0;
2350                         at_root = 0;
2351                         needs_unbusy = 0;
2352                         new_mp = mp;
2353                         mounted_on_fileno = (uint64_t)dp->d_fileno;
2354                         if ((nd->nd_flag & ND_NFSV3) ||
2355                             NFSNONZERO_ATTRBIT(&savbits)) {
2356                                 if (nd->nd_flag & ND_NFSV4)
2357                                         refp = nfsv4root_getreferral(NULL,
2358                                             vp, dp->d_fileno);
2359                                 if (refp == NULL) {
2360                                         if (usevget)
2361                                                 r = VFS_VGET(mp, dp->d_fileno,
2362                                                     LK_SHARED, &nvp);
2363                                         else
2364                                                 r = EOPNOTSUPP;
2365                                         if (r == EOPNOTSUPP) {
2366                                                 if (usevget) {
2367                                                         usevget = 0;
2368                                                         cn.cn_nameiop = LOOKUP;
2369                                                         cn.cn_lkflags =
2370                                                             LK_SHARED |
2371                                                             LK_RETRY;
2372                                                         cn.cn_cred =
2373                                                             nd->nd_cred;
2374                                                         cn.cn_thread = p;
2375                                                 }
2376                                                 cn.cn_nameptr = dp->d_name;
2377                                                 cn.cn_namelen = nlen;
2378                                                 cn.cn_flags = ISLASTCN |
2379                                                     NOFOLLOW | LOCKLEAF;
2380                                                 if (nlen == 2 &&
2381                                                     dp->d_name[0] == '.' &&
2382                                                     dp->d_name[1] == '.')
2383                                                         cn.cn_flags |=
2384                                                             ISDOTDOT;
2385                                                 if (NFSVOPLOCK(vp, LK_SHARED)
2386                                                     != 0) {
2387                                                         nd->nd_repstat = EPERM;
2388                                                         break;
2389                                                 }
2390                                                 if ((vp->v_vflag & VV_ROOT) != 0
2391                                                     && (cn.cn_flags & ISDOTDOT)
2392                                                     != 0) {
2393                                                         vref(vp);
2394                                                         nvp = vp;
2395                                                         r = 0;
2396                                                 } else {
2397                                                         r = VOP_LOOKUP(vp, &nvp,
2398                                                             &cn);
2399                                                         if (vp != nvp)
2400                                                                 NFSVOPUNLOCK(vp,
2401                                                                     0);
2402                                                 }
2403                                         }
2404
2405                                         /*
2406                                          * For NFSv4, check to see if nvp is
2407                                          * a mount point and get the mount
2408                                          * point vnode, as required.
2409                                          */
2410                                         if (r == 0 &&
2411                                             nfsrv_enable_crossmntpt != 0 &&
2412                                             (nd->nd_flag & ND_NFSV4) != 0 &&
2413                                             nvp->v_type == VDIR &&
2414                                             nvp->v_mountedhere != NULL) {
2415                                                 new_mp = nvp->v_mountedhere;
2416                                                 r = vfs_busy(new_mp, 0);
2417                                                 vput(nvp);
2418                                                 nvp = NULL;
2419                                                 if (r == 0) {
2420                                                         r = VFS_ROOT(new_mp,
2421                                                             LK_SHARED, &nvp);
2422                                                         needs_unbusy = 1;
2423                                                         if (r == 0)
2424                                                                 at_root = 1;
2425                                                 }
2426                                         }
2427                                 }
2428
2429                                 /*
2430                                  * If we failed to look up the entry, then it
2431                                  * has become invalid, most likely removed.
2432                                  */
2433                                 if (r != 0) {
2434                                         if (needs_unbusy)
2435                                                 vfs_unbusy(new_mp);
2436                                         goto invalid;
2437                                 }
2438                                 KASSERT(refp != NULL || nvp != NULL,
2439                                     ("%s: undetected lookup error", __func__));
2440
2441                                 if (refp == NULL &&
2442                                     ((nd->nd_flag & ND_NFSV3) ||
2443                                      NFSNONZERO_ATTRBIT(&attrbits))) {
2444                                         r = nfsvno_getfh(nvp, &nfh, p);
2445                                         if (!r)
2446                                             r = nfsvno_getattr(nvp, nvap, nd, p,
2447                                                 1, &attrbits);
2448                                         if (r == 0 && is_zfs == 1 &&
2449                                             nfsrv_enable_crossmntpt != 0 &&
2450                                             (nd->nd_flag & ND_NFSV4) != 0 &&
2451                                             nvp->v_type == VDIR &&
2452                                             vp->v_mount != nvp->v_mount) {
2453                                             /*
2454                                              * For a ZFS snapshot, there is a
2455                                              * pseudo mount that does not set
2456                                              * v_mountedhere, so it needs to
2457                                              * be detected via a different
2458                                              * mount structure.
2459                                              */
2460                                             at_root = 1;
2461                                             if (new_mp == mp)
2462                                                 new_mp = nvp->v_mount;
2463                                         }
2464                                 }
2465
2466                                 /*
2467                                  * If we failed to get attributes of the entry,
2468                                  * then just skip it for NFSv3 (the traditional
2469                                  * behavior in the old NFS server).
2470                                  * For NFSv4 the behavior is controlled by
2471                                  * RDATTRERROR: we either ignore the error or
2472                                  * fail the request.
2473                                  * Note that RDATTRERROR is never set for NFSv3.
2474                                  */
2475                                 if (r != 0) {
2476                                         if (!NFSISSET_ATTRBIT(&attrbits,
2477                                             NFSATTRBIT_RDATTRERROR)) {
2478                                                 vput(nvp);
2479                                                 if (needs_unbusy != 0)
2480                                                         vfs_unbusy(new_mp);
2481                                                 if ((nd->nd_flag & ND_NFSV3))
2482                                                         goto invalid;
2483                                                 nd->nd_repstat = r;
2484                                                 break;
2485                                         }
2486                                 }
2487                         }
2488
2489                         /*
2490                          * Build the directory record xdr
2491                          */
2492                         if (nd->nd_flag & ND_NFSV3) {
2493                                 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2494                                 *tl++ = newnfs_true;
2495                                 *tl++ = 0;
2496                                 *tl = txdr_unsigned(dp->d_fileno);
2497                                 dirlen += nfsm_strtom(nd, dp->d_name, nlen);
2498                                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2499                                 *tl++ = 0;
2500                                 *tl = txdr_unsigned(*cookiep);
2501                                 nfsrv_postopattr(nd, 0, nvap);
2502                                 dirlen += nfsm_fhtom(nd,(u_int8_t *)&nfh,0,1);
2503                                 dirlen += (5*NFSX_UNSIGNED+NFSX_V3POSTOPATTR);
2504                                 if (nvp != NULL)
2505                                         vput(nvp);
2506                         } else {
2507                                 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2508                                 *tl++ = newnfs_true;
2509                                 *tl++ = 0;
2510                                 *tl = txdr_unsigned(*cookiep);
2511                                 dirlen += nfsm_strtom(nd, dp->d_name, nlen);
2512                                 if (nvp != NULL) {
2513                                         supports_nfsv4acls =
2514                                             nfs_supportsnfsv4acls(nvp);
2515                                         NFSVOPUNLOCK(nvp, 0);
2516                                 } else
2517                                         supports_nfsv4acls = 0;
2518                                 if (refp != NULL) {
2519                                         dirlen += nfsrv_putreferralattr(nd,
2520                                             &savbits, refp, 0,
2521                                             &nd->nd_repstat);
2522                                         if (nd->nd_repstat) {
2523                                                 if (nvp != NULL)
2524                                                         vrele(nvp);
2525                                                 if (needs_unbusy != 0)
2526                                                         vfs_unbusy(new_mp);
2527                                                 break;
2528                                         }
2529                                 } else if (r) {
2530                                         dirlen += nfsvno_fillattr(nd, new_mp,
2531                                             nvp, nvap, &nfh, r, &rderrbits,
2532                                             nd->nd_cred, p, isdgram, 0,
2533                                             supports_nfsv4acls, at_root,
2534                                             mounted_on_fileno);
2535                                 } else {
2536                                         dirlen += nfsvno_fillattr(nd, new_mp,
2537                                             nvp, nvap, &nfh, r, &attrbits,
2538                                             nd->nd_cred, p, isdgram, 0,
2539                                             supports_nfsv4acls, at_root,
2540                                             mounted_on_fileno);
2541                                 }
2542                                 if (nvp != NULL)
2543                                         vrele(nvp);
2544                                 dirlen += (3 * NFSX_UNSIGNED);
2545                         }
2546                         if (needs_unbusy != 0)
2547                                 vfs_unbusy(new_mp);
2548                         if (dirlen <= cnt)
2549                                 entrycnt++;
2550                 }
2551 invalid:
2552                 cpos += dp->d_reclen;
2553                 dp = (struct dirent *)cpos;
2554                 cookiep++;
2555                 ncookies--;
2556         }
2557         vrele(vp);
2558         vfs_unbusy(mp);
2559
2560         /*
2561          * If dirlen > cnt, we must strip off the last entry. If that
2562          * results in an empty reply, report NFSERR_TOOSMALL.
2563          */
2564         if (dirlen > cnt || nd->nd_repstat) {
2565                 if (!nd->nd_repstat && entrycnt == 0)
2566                         nd->nd_repstat = NFSERR_TOOSMALL;
2567                 if (nd->nd_repstat) {
2568                         newnfs_trimtrailing(nd, mb0, bpos0);
2569                         if (nd->nd_flag & ND_NFSV3)
2570                                 nfsrv_postopattr(nd, getret, &at);
2571                 } else
2572                         newnfs_trimtrailing(nd, mb1, bpos1);
2573                 eofflag = 0;
2574         } else if (cpos < cend)
2575                 eofflag = 0;
2576         if (!nd->nd_repstat) {
2577                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2578                 *tl++ = newnfs_false;
2579                 if (eofflag)
2580                         *tl = newnfs_true;
2581                 else
2582                         *tl = newnfs_false;
2583         }
2584         free(cookies, M_TEMP);
2585         free(rbuf, M_TEMP);
2586
2587 out:
2588         NFSEXITCODE2(0, nd);
2589         return (0);
2590 nfsmout:
2591         vput(vp);
2592         NFSEXITCODE2(error, nd);
2593         return (error);
2594 }
2595
2596 /*
2597  * Get the settable attributes out of the mbuf list.
2598  * (Return 0 or EBADRPC)
2599  */
2600 int
2601 nfsrv_sattr(struct nfsrv_descript *nd, vnode_t vp, struct nfsvattr *nvap,
2602     nfsattrbit_t *attrbitp, NFSACL_T *aclp, struct thread *p)
2603 {
2604         u_int32_t *tl;
2605         struct nfsv2_sattr *sp;
2606         int error = 0, toclient = 0;
2607
2608         switch (nd->nd_flag & (ND_NFSV2 | ND_NFSV3 | ND_NFSV4)) {
2609         case ND_NFSV2:
2610                 NFSM_DISSECT(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2611                 /*
2612                  * Some old clients didn't fill in the high order 16bits.
2613                  * --> check the low order 2 bytes for 0xffff
2614                  */
2615                 if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
2616                         nvap->na_mode = nfstov_mode(sp->sa_mode);
2617                 if (sp->sa_uid != newnfs_xdrneg1)
2618                         nvap->na_uid = fxdr_unsigned(uid_t, sp->sa_uid);
2619                 if (sp->sa_gid != newnfs_xdrneg1)
2620                         nvap->na_gid = fxdr_unsigned(gid_t, sp->sa_gid);
2621                 if (sp->sa_size != newnfs_xdrneg1)
2622                         nvap->na_size = fxdr_unsigned(u_quad_t, sp->sa_size);
2623                 if (sp->sa_atime.nfsv2_sec != newnfs_xdrneg1) {
2624 #ifdef notyet
2625                         fxdr_nfsv2time(&sp->sa_atime, &nvap->na_atime);
2626 #else
2627                         nvap->na_atime.tv_sec =
2628                                 fxdr_unsigned(u_int32_t,sp->sa_atime.nfsv2_sec);
2629                         nvap->na_atime.tv_nsec = 0;
2630 #endif
2631                 }
2632                 if (sp->sa_mtime.nfsv2_sec != newnfs_xdrneg1)
2633                         fxdr_nfsv2time(&sp->sa_mtime, &nvap->na_mtime);
2634                 break;
2635         case ND_NFSV3:
2636                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2637                 if (*tl == newnfs_true) {
2638                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2639                         nvap->na_mode = nfstov_mode(*tl);
2640                 }
2641                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2642                 if (*tl == newnfs_true) {
2643                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2644                         nvap->na_uid = fxdr_unsigned(uid_t, *tl);
2645                 }
2646                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2647                 if (*tl == newnfs_true) {
2648                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2649                         nvap->na_gid = fxdr_unsigned(gid_t, *tl);
2650                 }
2651                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2652                 if (*tl == newnfs_true) {
2653                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2654                         nvap->na_size = fxdr_hyper(tl);
2655                 }
2656                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2657                 switch (fxdr_unsigned(int, *tl)) {
2658                 case NFSV3SATTRTIME_TOCLIENT:
2659                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2660                         fxdr_nfsv3time(tl, &nvap->na_atime);
2661                         toclient = 1;
2662                         break;
2663                 case NFSV3SATTRTIME_TOSERVER:
2664                         vfs_timestamp(&nvap->na_atime);
2665                         nvap->na_vaflags |= VA_UTIMES_NULL;
2666                         break;
2667                 }
2668                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2669                 switch (fxdr_unsigned(int, *tl)) {
2670                 case NFSV3SATTRTIME_TOCLIENT:
2671                         NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2672                         fxdr_nfsv3time(tl, &nvap->na_mtime);
2673                         nvap->na_vaflags &= ~VA_UTIMES_NULL;
2674                         break;
2675                 case NFSV3SATTRTIME_TOSERVER:
2676                         vfs_timestamp(&nvap->na_mtime);
2677                         if (!toclient)
2678                                 nvap->na_vaflags |= VA_UTIMES_NULL;
2679                         break;
2680                 }
2681                 break;
2682         case ND_NFSV4:
2683                 error = nfsv4_sattr(nd, vp, nvap, attrbitp, aclp, p);
2684         }
2685 nfsmout:
2686         NFSEXITCODE2(error, nd);
2687         return (error);
2688 }
2689
2690 /*
2691  * Handle the setable attributes for V4.
2692  * Returns NFSERR_BADXDR if it can't be parsed, 0 otherwise.
2693  */
2694 int
2695 nfsv4_sattr(struct nfsrv_descript *nd, vnode_t vp, struct nfsvattr *nvap,
2696     nfsattrbit_t *attrbitp, NFSACL_T *aclp, struct thread *p)
2697 {
2698         u_int32_t *tl;
2699         int attrsum = 0;
2700         int i, j;
2701         int error, attrsize, bitpos, aclsize, aceerr, retnotsup = 0;
2702         int toclient = 0;
2703         u_char *cp, namestr[NFSV4_SMALLSTR + 1];
2704         uid_t uid;
2705         gid_t gid;
2706
2707         error = nfsrv_getattrbits(nd, attrbitp, NULL, &retnotsup);
2708         if (error)
2709                 goto nfsmout;
2710         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2711         attrsize = fxdr_unsigned(int, *tl);
2712
2713         /*
2714          * Loop around getting the setable attributes. If an unsupported
2715          * one is found, set nd_repstat == NFSERR_ATTRNOTSUPP and return.
2716          */
2717         if (retnotsup) {
2718                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2719                 bitpos = NFSATTRBIT_MAX;
2720         } else {
2721                 bitpos = 0;
2722         }
2723         for (; bitpos < NFSATTRBIT_MAX; bitpos++) {
2724             if (attrsum > attrsize) {
2725                 error = NFSERR_BADXDR;
2726                 goto nfsmout;
2727             }
2728             if (NFSISSET_ATTRBIT(attrbitp, bitpos))
2729                 switch (bitpos) {
2730                 case NFSATTRBIT_SIZE:
2731                         NFSM_DISSECT(tl, u_int32_t *, NFSX_HYPER);
2732                      if (vp != NULL && vp->v_type != VREG) {
2733                             error = (vp->v_type == VDIR) ? NFSERR_ISDIR :
2734                                 NFSERR_INVAL;
2735                             goto nfsmout;
2736                         }
2737                         nvap->na_size = fxdr_hyper(tl);
2738                         attrsum += NFSX_HYPER;
2739                         break;
2740                 case NFSATTRBIT_ACL:
2741                         error = nfsrv_dissectacl(nd, aclp, &aceerr, &aclsize,
2742                             p);
2743                         if (error)
2744                                 goto nfsmout;
2745                         if (aceerr && !nd->nd_repstat)
2746                                 nd->nd_repstat = aceerr;
2747                         attrsum += aclsize;
2748                         break;
2749                 case NFSATTRBIT_ARCHIVE:
2750                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2751                         if (!nd->nd_repstat)
2752                                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2753                         attrsum += NFSX_UNSIGNED;
2754                         break;
2755                 case NFSATTRBIT_HIDDEN:
2756                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2757                         if (!nd->nd_repstat)
2758                                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2759                         attrsum += NFSX_UNSIGNED;
2760                         break;
2761                 case NFSATTRBIT_MIMETYPE:
2762                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2763                         i = fxdr_unsigned(int, *tl);
2764                         error = nfsm_advance(nd, NFSM_RNDUP(i), -1);
2765                         if (error)
2766                                 goto nfsmout;
2767                         if (!nd->nd_repstat)
2768                                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2769                         attrsum += (NFSX_UNSIGNED + NFSM_RNDUP(i));
2770                         break;
2771                 case NFSATTRBIT_MODE:
2772                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2773                         nvap->na_mode = nfstov_mode(*tl);
2774                         attrsum += NFSX_UNSIGNED;
2775                         break;
2776                 case NFSATTRBIT_OWNER:
2777                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2778                         j = fxdr_unsigned(int, *tl);
2779                         if (j < 0) {
2780                                 error = NFSERR_BADXDR;
2781                                 goto nfsmout;
2782                         }
2783                         if (j > NFSV4_SMALLSTR)
2784                                 cp = malloc(j + 1, M_NFSSTRING, M_WAITOK);
2785                         else
2786                                 cp = namestr;
2787                         error = nfsrv_mtostr(nd, cp, j);
2788                         if (error) {
2789                                 if (j > NFSV4_SMALLSTR)
2790                                         free(cp, M_NFSSTRING);
2791                                 goto nfsmout;
2792                         }
2793                         if (!nd->nd_repstat) {
2794                                 nd->nd_repstat = nfsv4_strtouid(nd, cp, j,
2795                                     &uid);
2796                                 if (!nd->nd_repstat)
2797                                         nvap->na_uid = uid;
2798                         }
2799                         if (j > NFSV4_SMALLSTR)
2800                                 free(cp, M_NFSSTRING);
2801                         attrsum += (NFSX_UNSIGNED + NFSM_RNDUP(j));
2802                         break;
2803                 case NFSATTRBIT_OWNERGROUP:
2804                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2805                         j = fxdr_unsigned(int, *tl);
2806                         if (j < 0) {
2807                                 error = NFSERR_BADXDR;
2808                                 goto nfsmout;
2809                         }
2810                         if (j > NFSV4_SMALLSTR)
2811                                 cp = malloc(j + 1, M_NFSSTRING, M_WAITOK);
2812                         else
2813                                 cp = namestr;
2814                         error = nfsrv_mtostr(nd, cp, j);
2815                         if (error) {
2816                                 if (j > NFSV4_SMALLSTR)
2817                                         free(cp, M_NFSSTRING);
2818                                 goto nfsmout;
2819                         }
2820                         if (!nd->nd_repstat) {
2821                                 nd->nd_repstat = nfsv4_strtogid(nd, cp, j, &gid,
2822                                     p);
2823                                 if (!nd->nd_repstat)
2824                                         nvap->na_gid = gid;
2825                         }
2826                         if (j > NFSV4_SMALLSTR)
2827                                 free(cp, M_NFSSTRING);
2828                         attrsum += (NFSX_UNSIGNED + NFSM_RNDUP(j));
2829                         break;
2830                 case NFSATTRBIT_SYSTEM:
2831                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2832                         if (!nd->nd_repstat)
2833                                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2834                         attrsum += NFSX_UNSIGNED;
2835                         break;
2836                 case NFSATTRBIT_TIMEACCESSSET:
2837                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2838                         attrsum += NFSX_UNSIGNED;
2839                         if (fxdr_unsigned(int, *tl)==NFSV4SATTRTIME_TOCLIENT) {
2840                             NFSM_DISSECT(tl, u_int32_t *, NFSX_V4TIME);
2841                             fxdr_nfsv4time(tl, &nvap->na_atime);
2842                             toclient = 1;
2843                             attrsum += NFSX_V4TIME;
2844                         } else {
2845                             vfs_timestamp(&nvap->na_atime);
2846                             nvap->na_vaflags |= VA_UTIMES_NULL;
2847                         }
2848                         break;
2849                 case NFSATTRBIT_TIMEBACKUP:
2850                         NFSM_DISSECT(tl, u_int32_t *, NFSX_V4TIME);
2851                         if (!nd->nd_repstat)
2852                                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2853                         attrsum += NFSX_V4TIME;
2854                         break;
2855                 case NFSATTRBIT_TIMECREATE:
2856                         NFSM_DISSECT(tl, u_int32_t *, NFSX_V4TIME);
2857                         if (!nd->nd_repstat)
2858                                 nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2859                         attrsum += NFSX_V4TIME;
2860                         break;
2861                 case NFSATTRBIT_TIMEMODIFYSET:
2862                         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2863                         attrsum += NFSX_UNSIGNED;
2864                         if (fxdr_unsigned(int, *tl)==NFSV4SATTRTIME_TOCLIENT) {
2865                             NFSM_DISSECT(tl, u_int32_t *, NFSX_V4TIME);
2866                             fxdr_nfsv4time(tl, &nvap->na_mtime);
2867                             nvap->na_vaflags &= ~VA_UTIMES_NULL;
2868                             attrsum += NFSX_V4TIME;
2869                         } else {
2870                             vfs_timestamp(&nvap->na_mtime);
2871                             if (!toclient)
2872                                 nvap->na_vaflags |= VA_UTIMES_NULL;
2873                         }
2874                         break;
2875                 default:
2876                         nd->nd_repstat = NFSERR_ATTRNOTSUPP;
2877                         /*
2878                          * set bitpos so we drop out of the loop.
2879                          */
2880                         bitpos = NFSATTRBIT_MAX;
2881                         break;
2882                 }
2883         }
2884
2885         /*
2886          * some clients pad the attrlist, so we need to skip over the
2887          * padding.
2888          */
2889         if (attrsum > attrsize) {
2890                 error = NFSERR_BADXDR;
2891         } else {
2892                 attrsize = NFSM_RNDUP(attrsize);
2893                 if (attrsum < attrsize)
2894                         error = nfsm_advance(nd, attrsize - attrsum, -1);
2895         }
2896 nfsmout:
2897         NFSEXITCODE2(error, nd);
2898         return (error);
2899 }
2900
2901 /*
2902  * Check/setup export credentials.
2903  */
2904 int
2905 nfsd_excred(struct nfsrv_descript *nd, struct nfsexstuff *exp,
2906     struct ucred *credanon)
2907 {
2908         int error = 0;
2909
2910         /*
2911          * Check/setup credentials.
2912          */
2913         if (nd->nd_flag & ND_GSS)
2914                 exp->nes_exflag &= ~MNT_EXPORTANON;
2915
2916         /*
2917          * Check to see if the operation is allowed for this security flavor.
2918          * RFC2623 suggests that the NFSv3 Fsinfo RPC be allowed to
2919          * AUTH_NONE or AUTH_SYS for file systems requiring RPCSEC_GSS.
2920          * Also, allow Secinfo, so that it can acquire the correct flavor(s).
2921          */
2922         if (nfsvno_testexp(nd, exp) &&
2923             nd->nd_procnum != NFSV4OP_SECINFO &&
2924             nd->nd_procnum != NFSPROC_FSINFO) {
2925                 if (nd->nd_flag & ND_NFSV4)
2926                         error = NFSERR_WRONGSEC;
2927                 else
2928                         error = (NFSERR_AUTHERR | AUTH_TOOWEAK);
2929                 goto out;
2930         }
2931
2932         /*
2933          * Check to see if the file system is exported V4 only.
2934          */
2935         if (NFSVNO_EXV4ONLY(exp) && !(nd->nd_flag & ND_NFSV4)) {
2936                 error = NFSERR_PROGNOTV4;
2937                 goto out;
2938         }
2939
2940         /*
2941          * Now, map the user credentials.
2942          * (Note that ND_AUTHNONE will only be set for an NFSv3
2943          *  Fsinfo RPC. If set for anything else, this code might need
2944          *  to change.)
2945          */
2946         if (NFSVNO_EXPORTED(exp)) {
2947                 if (((nd->nd_flag & ND_GSS) == 0 && nd->nd_cred->cr_uid == 0) ||
2948                      NFSVNO_EXPORTANON(exp) ||
2949                      (nd->nd_flag & ND_AUTHNONE) != 0) {
2950                         nd->nd_cred->cr_uid = credanon->cr_uid;
2951                         nd->nd_cred->cr_gid = credanon->cr_gid;
2952                         crsetgroups(nd->nd_cred, credanon->cr_ngroups,
2953                             credanon->cr_groups);
2954                 } else if ((nd->nd_flag & ND_GSS) == 0) {
2955                         /*
2956                          * If using AUTH_SYS, call nfsrv_getgrpscred() to see
2957                          * if there is a replacement credential with a group
2958                          * list set up by "nfsuserd -manage-gids".
2959                          * If there is no replacement, nfsrv_getgrpscred()
2960                          * simply returns its argument.
2961                          */
2962                         nd->nd_cred = nfsrv_getgrpscred(nd->nd_cred);
2963                 }
2964         }
2965
2966 out:
2967         NFSEXITCODE2(error, nd);
2968         return (error);
2969 }
2970
2971 /*
2972  * Check exports.
2973  */
2974 int
2975 nfsvno_checkexp(struct mount *mp, struct sockaddr *nam, struct nfsexstuff *exp,
2976     struct ucred **credp)
2977 {
2978         int i, error, *secflavors;
2979
2980         error = VFS_CHECKEXP(mp, nam, &exp->nes_exflag, credp,
2981             &exp->nes_numsecflavor, &secflavors);
2982         if (error) {
2983                 if (nfs_rootfhset) {
2984                         exp->nes_exflag = 0;
2985                         exp->nes_numsecflavor = 0;
2986                         error = 0;
2987                 }
2988         } else {
2989                 /* Copy the security flavors. */
2990                 for (i = 0; i < exp->nes_numsecflavor; i++)
2991                         exp->nes_secflavors[i] = secflavors[i];
2992         }
2993         NFSEXITCODE(error);
2994         return (error);
2995 }
2996
2997 /*
2998  * Get a vnode for a file handle and export stuff.
2999  */
3000 int
3001 nfsvno_fhtovp(struct mount *mp, fhandle_t *fhp, struct sockaddr *nam,
3002     int lktype, struct vnode **vpp, struct nfsexstuff *exp,
3003     struct ucred **credp)
3004 {
3005         int i, error, *secflavors;
3006
3007         *credp = NULL;
3008         exp->nes_numsecflavor = 0;
3009         error = VFS_FHTOVP(mp, &fhp->fh_fid, lktype, vpp);
3010         if (error != 0)
3011                 /* Make sure the server replies ESTALE to the client. */
3012                 error = ESTALE;
3013         if (nam && !error) {
3014                 error = VFS_CHECKEXP(mp, nam, &exp->nes_exflag, credp,
3015                     &exp->nes_numsecflavor, &secflavors);
3016                 if (error) {
3017                         if (nfs_rootfhset) {
3018                                 exp->nes_exflag = 0;
3019                                 exp->nes_numsecflavor = 0;
3020                                 error = 0;
3021                         } else {
3022                                 vput(*vpp);
3023                         }
3024                 } else {
3025                         /* Copy the security flavors. */
3026                         for (i = 0; i < exp->nes_numsecflavor; i++)
3027                                 exp->nes_secflavors[i] = secflavors[i];
3028                 }
3029         }
3030         NFSEXITCODE(error);
3031         return (error);
3032 }
3033
3034 /*
3035  * nfsd_fhtovp() - convert a fh to a vnode ptr
3036  *      - look up fsid in mount list (if not found ret error)
3037  *      - get vp and export rights by calling nfsvno_fhtovp()
3038  *      - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon
3039  *        for AUTH_SYS
3040  *      - if mpp != NULL, return the mount point so that it can
3041  *        be used for vn_finished_write() by the caller
3042  */
3043 void
3044 nfsd_fhtovp(struct nfsrv_descript *nd, struct nfsrvfh *nfp, int lktype,
3045     struct vnode **vpp, struct nfsexstuff *exp,
3046     struct mount **mpp, int startwrite)
3047 {
3048         struct mount *mp;
3049         struct ucred *credanon;
3050         fhandle_t *fhp;
3051
3052         fhp = (fhandle_t *)nfp->nfsrvfh_data;
3053         /*
3054          * Check for the special case of the nfsv4root_fh.
3055          */
3056         mp = vfs_busyfs(&fhp->fh_fsid);
3057         if (mpp != NULL)
3058                 *mpp = mp;
3059         if (mp == NULL) {
3060                 *vpp = NULL;
3061                 nd->nd_repstat = ESTALE;
3062                 goto out;
3063         }
3064
3065         if (startwrite) {
3066                 vn_start_write(NULL, mpp, V_WAIT);
3067                 if (lktype == LK_SHARED && !(MNT_SHARED_WRITES(mp)))
3068                         lktype = LK_EXCLUSIVE;
3069         }
3070         nd->nd_repstat = nfsvno_fhtovp(mp, fhp, nd->nd_nam, lktype, vpp, exp,
3071             &credanon);
3072         vfs_unbusy(mp);
3073
3074         /*
3075          * For NFSv4 without a pseudo root fs, unexported file handles
3076          * can be returned, so that Lookup works everywhere.
3077          */
3078         if (!nd->nd_repstat && exp->nes_exflag == 0 &&
3079             !(nd->nd_flag & ND_NFSV4)) {
3080                 vput(*vpp);
3081                 nd->nd_repstat = EACCES;
3082         }
3083
3084         /*
3085          * Personally, I've never seen any point in requiring a
3086          * reserved port#, since only in the rare case where the
3087          * clients are all boxes with secure system privileges,
3088          * does it provide any enhanced security, but... some people
3089          * believe it to be useful and keep putting this code back in.
3090          * (There is also some "security checker" out there that
3091          *  complains if the nfs server doesn't enforce this.)
3092          * However, note the following:
3093          * RFC3530 (NFSv4) specifies that a reserved port# not be
3094          *      required.
3095          * RFC2623 recommends that, if a reserved port# is checked for,
3096          *      that there be a way to turn that off--> ifdef'd.
3097          */
3098 #ifdef NFS_REQRSVPORT
3099         if (!nd->nd_repstat) {
3100                 struct sockaddr_in *saddr;
3101                 struct sockaddr_in6 *saddr6;
3102
3103                 saddr = NFSSOCKADDR(nd->nd_nam, struct sockaddr_in *);
3104                 saddr6 = NFSSOCKADDR(nd->nd_nam, struct sockaddr_in6 *);
3105                 if (!(nd->nd_flag & ND_NFSV4) &&
3106                     ((saddr->sin_family == AF_INET &&
3107                       ntohs(saddr->sin_port) >= IPPORT_RESERVED) ||
3108                      (saddr6->sin6_family == AF_INET6 &&
3109                       ntohs(saddr6->sin6_port) >= IPPORT_RESERVED))) {
3110                         vput(*vpp);
3111                         nd->nd_repstat = (NFSERR_AUTHERR | AUTH_TOOWEAK);
3112                 }
3113         }
3114 #endif  /* NFS_REQRSVPORT */
3115
3116         /*
3117          * Check/setup credentials.
3118          */
3119         if (!nd->nd_repstat) {
3120                 nd->nd_saveduid = nd->nd_cred->cr_uid;
3121                 nd->nd_repstat = nfsd_excred(nd, exp, credanon);
3122                 if (nd->nd_repstat)
3123                         vput(*vpp);
3124         }
3125         if (credanon != NULL)
3126                 crfree(credanon);
3127         if (nd->nd_repstat) {
3128                 if (startwrite)
3129                         vn_finished_write(mp);
3130                 *vpp = NULL;
3131                 if (mpp != NULL)
3132                         *mpp = NULL;
3133         }
3134
3135 out:
3136         NFSEXITCODE2(0, nd);
3137 }
3138
3139 /*
3140  * glue for fp.
3141  */
3142 static int
3143 fp_getfvp(struct thread *p, int fd, struct file **fpp, struct vnode **vpp)
3144 {
3145         struct filedesc *fdp;
3146         struct file *fp;
3147         int error = 0;
3148
3149         fdp = p->td_proc->p_fd;
3150         if (fd < 0 || fd >= fdp->fd_nfiles ||
3151             (fp = fdp->fd_ofiles[fd].fde_file) == NULL) {
3152                 error = EBADF;
3153                 goto out;
3154         }
3155         *fpp = fp;
3156
3157 out:
3158         NFSEXITCODE(error);
3159         return (error);
3160 }
3161
3162 /*
3163  * Called from nfssvc() to update the exports list. Just call
3164  * vfs_export(). This has to be done, since the v4 root fake fs isn't
3165  * in the mount list.
3166  */
3167 int
3168 nfsrv_v4rootexport(void *argp, struct ucred *cred, struct thread *p)
3169 {
3170         struct nfsex_args *nfsexargp = (struct nfsex_args *)argp;
3171         int error = 0;
3172         struct nameidata nd;
3173         fhandle_t fh;
3174
3175         error = vfs_export(&nfsv4root_mnt, &nfsexargp->export);
3176         if ((nfsexargp->export.ex_flags & MNT_DELEXPORT) != 0)
3177                 nfs_rootfhset = 0;
3178         else if (error == 0) {
3179                 if (nfsexargp->fspec == NULL) {
3180                         error = EPERM;
3181                         goto out;
3182                 }
3183                 /*
3184                  * If fspec != NULL, this is the v4root path.
3185                  */
3186                 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE,
3187                     nfsexargp->fspec, p);
3188                 if ((error = namei(&nd)) != 0)
3189                         goto out;
3190                 error = nfsvno_getfh(nd.ni_vp, &fh, p);
3191                 vrele(nd.ni_vp);
3192                 if (!error) {
3193                         nfs_rootfh.nfsrvfh_len = NFSX_MYFH;
3194                         NFSBCOPY((caddr_t)&fh,
3195                             nfs_rootfh.nfsrvfh_data,
3196                             sizeof (fhandle_t));
3197                         nfs_rootfhset = 1;
3198                 }
3199         }
3200
3201 out:
3202         NFSEXITCODE(error);
3203         return (error);
3204 }
3205
3206 /*
3207  * This function needs to test to see if the system is near its limit
3208  * for memory allocation via malloc() or mget() and return True iff
3209  * either of these resources are near their limit.
3210  * XXX (For now, this is just a stub.)
3211  */
3212 int nfsrv_testmalloclimit = 0;
3213 int
3214 nfsrv_mallocmget_limit(void)
3215 {
3216         static int printmesg = 0;
3217         static int testval = 1;
3218
3219         if (nfsrv_testmalloclimit && (testval++ % 1000) == 0) {
3220                 if ((printmesg++ % 100) == 0)
3221                         printf("nfsd: malloc/mget near limit\n");
3222                 return (1);
3223         }
3224         return (0);
3225 }
3226
3227 /*
3228  * BSD specific initialization of a mount point.
3229  */
3230 void
3231 nfsd_mntinit(void)
3232 {
3233         static int inited = 0;
3234
3235         if (inited)
3236                 return;
3237         inited = 1;
3238         nfsv4root_mnt.mnt_flag = (MNT_RDONLY | MNT_EXPORTED);
3239         TAILQ_INIT(&nfsv4root_mnt.mnt_nvnodelist);
3240         TAILQ_INIT(&nfsv4root_mnt.mnt_activevnodelist);
3241         nfsv4root_mnt.mnt_export = NULL;
3242         TAILQ_INIT(&nfsv4root_opt);
3243         TAILQ_INIT(&nfsv4root_newopt);
3244         nfsv4root_mnt.mnt_opt = &nfsv4root_opt;
3245         nfsv4root_mnt.mnt_optnew = &nfsv4root_newopt;
3246         nfsv4root_mnt.mnt_nvnodelistsize = 0;
3247         nfsv4root_mnt.mnt_activevnodelistsize = 0;
3248 }
3249
3250 /*
3251  * Get a vnode for a file handle, without checking exports, etc.
3252  */
3253 struct vnode *
3254 nfsvno_getvp(fhandle_t *fhp)
3255 {
3256         struct mount *mp;
3257         struct vnode *vp;
3258         int error;
3259
3260         mp = vfs_busyfs(&fhp->fh_fsid);
3261         if (mp == NULL)
3262                 return (NULL);
3263         error = VFS_FHTOVP(mp, &fhp->fh_fid, LK_EXCLUSIVE, &vp);
3264         vfs_unbusy(mp);
3265         if (error)
3266                 return (NULL);
3267         return (vp);
3268 }
3269
3270 /*
3271  * Do a local VOP_ADVLOCK().
3272  */
3273 int
3274 nfsvno_advlock(struct vnode *vp, int ftype, u_int64_t first,
3275     u_int64_t end, struct thread *td)
3276 {
3277         int error = 0;
3278         struct flock fl;
3279         u_int64_t tlen;
3280
3281         if (nfsrv_dolocallocks == 0)
3282                 goto out;
3283         ASSERT_VOP_UNLOCKED(vp, "nfsvno_advlock: vp locked");
3284
3285         fl.l_whence = SEEK_SET;
3286         fl.l_type = ftype;
3287         fl.l_start = (off_t)first;
3288         if (end == NFS64BITSSET) {
3289                 fl.l_len = 0;
3290         } else {
3291                 tlen = end - first;
3292                 fl.l_len = (off_t)tlen;
3293         }
3294         /*
3295          * For FreeBSD8, the l_pid and l_sysid must be set to the same
3296          * values for all calls, so that all locks will be held by the
3297          * nfsd server. (The nfsd server handles conflicts between the
3298          * various clients.)
3299          * Since an NFSv4 lockowner is a ClientID plus an array of up to 1024
3300          * bytes, so it can't be put in l_sysid.
3301          */
3302         if (nfsv4_sysid == 0)
3303                 nfsv4_sysid = nlm_acquire_next_sysid();
3304         fl.l_pid = (pid_t)0;
3305         fl.l_sysid = (int)nfsv4_sysid;
3306
3307         if (ftype == F_UNLCK)
3308                 error = VOP_ADVLOCK(vp, (caddr_t)td->td_proc, F_UNLCK, &fl,
3309                     (F_POSIX | F_REMOTE));
3310         else
3311                 error = VOP_ADVLOCK(vp, (caddr_t)td->td_proc, F_SETLK, &fl,
3312                     (F_POSIX | F_REMOTE));
3313
3314 out:
3315         NFSEXITCODE(error);
3316         return (error);
3317 }
3318
3319 /*
3320  * Check the nfsv4 root exports.
3321  */
3322 int
3323 nfsvno_v4rootexport(struct nfsrv_descript *nd)
3324 {
3325         struct ucred *credanon;
3326         int exflags, error = 0, numsecflavor, *secflavors, i;
3327
3328         error = vfs_stdcheckexp(&nfsv4root_mnt, nd->nd_nam, &exflags,
3329             &credanon, &numsecflavor, &secflavors);
3330         if (error) {
3331                 error = NFSERR_PROGUNAVAIL;
3332                 goto out;
3333         }
3334         if (credanon != NULL)
3335                 crfree(credanon);
3336         for (i = 0; i < numsecflavor; i++) {
3337                 if (secflavors[i] == AUTH_SYS)
3338                         nd->nd_flag |= ND_EXAUTHSYS;
3339                 else if (secflavors[i] == RPCSEC_GSS_KRB5)
3340                         nd->nd_flag |= ND_EXGSS;
3341                 else if (secflavors[i] == RPCSEC_GSS_KRB5I)
3342                         nd->nd_flag |= ND_EXGSSINTEGRITY;
3343                 else if (secflavors[i] == RPCSEC_GSS_KRB5P)
3344                         nd->nd_flag |= ND_EXGSSPRIVACY;
3345         }
3346
3347 out:
3348         NFSEXITCODE(error);
3349         return (error);
3350 }
3351
3352 /*
3353  * Nfs server pseudo system call for the nfsd's
3354  */
3355 /*
3356  * MPSAFE
3357  */
3358 static int
3359 nfssvc_nfsd(struct thread *td, struct nfssvc_args *uap)
3360 {
3361         struct file *fp;
3362         struct nfsd_addsock_args sockarg;
3363         struct nfsd_nfsd_args nfsdarg;
3364         struct nfsd_nfsd_oargs onfsdarg;
3365         struct nfsd_pnfsd_args pnfsdarg;
3366         struct vnode *vp, *nvp, *curdvp;
3367         struct pnfsdsfile *pf;
3368         struct nfsdevice *ds, *fds;
3369         cap_rights_t rights;
3370         int buflen, error, ret;
3371         char *buf, *cp, *cp2, *cp3;
3372         char fname[PNFS_FILENAME_LEN + 1];
3373
3374         if (uap->flag & NFSSVC_NFSDADDSOCK) {
3375                 error = copyin(uap->argp, (caddr_t)&sockarg, sizeof (sockarg));
3376                 if (error)
3377                         goto out;
3378                 /*
3379                  * Since we don't know what rights might be required,
3380                  * pretend that we need them all. It is better to be too
3381                  * careful than too reckless.
3382                  */
3383                 error = fget(td, sockarg.sock,
3384                     cap_rights_init(&rights, CAP_SOCK_SERVER), &fp);
3385                 if (error != 0)
3386                         goto out;
3387                 if (fp->f_type != DTYPE_SOCKET) {
3388                         fdrop(fp, td);
3389                         error = EPERM;
3390                         goto out;
3391                 }
3392                 error = nfsrvd_addsock(fp);
3393                 fdrop(fp, td);
3394         } else if (uap->flag & NFSSVC_NFSDNFSD) {
3395                 if (uap->argp == NULL) {
3396                         error = EINVAL;
3397                         goto out;
3398                 }
3399                 if ((uap->flag & NFSSVC_NEWSTRUCT) == 0) {
3400                         error = copyin(uap->argp, &onfsdarg, sizeof(onfsdarg));
3401                         if (error == 0) {
3402                                 nfsdarg.principal = onfsdarg.principal;
3403                                 nfsdarg.minthreads = onfsdarg.minthreads;
3404                                 nfsdarg.maxthreads = onfsdarg.maxthreads;
3405                                 nfsdarg.version = 1;
3406                                 nfsdarg.addr = NULL;
3407                                 nfsdarg.addrlen = 0;
3408                                 nfsdarg.dnshost = NULL;
3409                                 nfsdarg.dnshostlen = 0;
3410                                 nfsdarg.dspath = NULL;
3411                                 nfsdarg.dspathlen = 0;
3412                                 nfsdarg.mdspath = NULL;
3413                                 nfsdarg.mdspathlen = 0;
3414                                 nfsdarg.mirrorcnt = 1;
3415                         }
3416                 } else
3417                         error = copyin(uap->argp, &nfsdarg, sizeof(nfsdarg));
3418                 if (error)
3419                         goto out;
3420                 if (nfsdarg.addrlen > 0 && nfsdarg.addrlen < 10000 &&
3421                     nfsdarg.dnshostlen > 0 && nfsdarg.dnshostlen < 10000 &&
3422                     nfsdarg.dspathlen > 0 && nfsdarg.dspathlen < 10000 &&
3423                     nfsdarg.mdspathlen > 0 && nfsdarg.mdspathlen < 10000 &&
3424                     nfsdarg.mirrorcnt >= 1 &&
3425                     nfsdarg.mirrorcnt <= NFSDEV_MAXMIRRORS &&
3426                     nfsdarg.addr != NULL && nfsdarg.dnshost != NULL &&
3427                     nfsdarg.dspath != NULL && nfsdarg.mdspath != NULL) {
3428                         NFSD_DEBUG(1, "addrlen=%d dspathlen=%d dnslen=%d"
3429                             " mdspathlen=%d mirrorcnt=%d\n", nfsdarg.addrlen,
3430                             nfsdarg.dspathlen, nfsdarg.dnshostlen,
3431                             nfsdarg.mdspathlen, nfsdarg.mirrorcnt);
3432                         cp = malloc(nfsdarg.addrlen + 1, M_TEMP, M_WAITOK);
3433                         error = copyin(nfsdarg.addr, cp, nfsdarg.addrlen);
3434                         if (error != 0) {
3435                                 free(cp, M_TEMP);
3436                                 goto out;
3437                         }
3438                         cp[nfsdarg.addrlen] = '\0';     /* Ensure nul term. */
3439                         nfsdarg.addr = cp;
3440                         cp = malloc(nfsdarg.dnshostlen + 1, M_TEMP, M_WAITOK);
3441                         error = copyin(nfsdarg.dnshost, cp, nfsdarg.dnshostlen);
3442                         if (error != 0) {
3443                                 free(nfsdarg.addr, M_TEMP);
3444                                 free(cp, M_TEMP);
3445                                 goto out;
3446                         }
3447                         cp[nfsdarg.dnshostlen] = '\0';  /* Ensure nul term. */
3448                         nfsdarg.dnshost = cp;
3449                         cp = malloc(nfsdarg.dspathlen + 1, M_TEMP, M_WAITOK);
3450                         error = copyin(nfsdarg.dspath, cp, nfsdarg.dspathlen);
3451                         if (error != 0) {
3452                                 free(nfsdarg.addr, M_TEMP);
3453                                 free(nfsdarg.dnshost, M_TEMP);
3454                                 free(cp, M_TEMP);
3455                                 goto out;
3456                         }
3457                         cp[nfsdarg.dspathlen] = '\0';   /* Ensure nul term. */
3458                         nfsdarg.dspath = cp;
3459                         cp = malloc(nfsdarg.mdspathlen + 1, M_TEMP, M_WAITOK);
3460                         error = copyin(nfsdarg.mdspath, cp, nfsdarg.mdspathlen);
3461                         if (error != 0) {
3462                                 free(nfsdarg.addr, M_TEMP);
3463                                 free(nfsdarg.dnshost, M_TEMP);
3464                                 free(nfsdarg.dspath, M_TEMP);
3465                                 free(cp, M_TEMP);
3466                                 goto out;
3467                         }
3468                         cp[nfsdarg.mdspathlen] = '\0';  /* Ensure nul term. */
3469                         nfsdarg.mdspath = cp;
3470                 } else {
3471                         nfsdarg.addr = NULL;
3472                         nfsdarg.addrlen = 0;
3473                         nfsdarg.dnshost = NULL;
3474                         nfsdarg.dnshostlen = 0;
3475                         nfsdarg.dspath = NULL;
3476                         nfsdarg.dspathlen = 0;
3477                         nfsdarg.mdspath = NULL;
3478                         nfsdarg.mdspathlen = 0;
3479                         nfsdarg.mirrorcnt = 1;
3480                 }
3481                 error = nfsrvd_nfsd(td, &nfsdarg);
3482                 free(nfsdarg.addr, M_TEMP);
3483                 free(nfsdarg.dnshost, M_TEMP);
3484                 free(nfsdarg.dspath, M_TEMP);
3485                 free(nfsdarg.mdspath, M_TEMP);
3486         } else if (uap->flag & NFSSVC_PNFSDS) {
3487                 error = copyin(uap->argp, &pnfsdarg, sizeof(pnfsdarg));
3488                 if (error == 0 && (pnfsdarg.op == PNFSDOP_DELDSSERVER ||
3489                     pnfsdarg.op == PNFSDOP_FORCEDELDS)) {
3490                         cp = malloc(PATH_MAX + 1, M_TEMP, M_WAITOK);
3491                         error = copyinstr(pnfsdarg.dspath, cp, PATH_MAX + 1,
3492                             NULL);
3493                         if (error == 0)
3494                                 error = nfsrv_deldsserver(pnfsdarg.op, cp, td);
3495                         free(cp, M_TEMP);
3496                 } else if (error == 0 && pnfsdarg.op == PNFSDOP_COPYMR) {
3497                         cp = malloc(PATH_MAX + 1, M_TEMP, M_WAITOK);
3498                         buflen = sizeof(*pf) * NFSDEV_MAXMIRRORS;
3499                         buf = malloc(buflen, M_TEMP, M_WAITOK);
3500                         error = copyinstr(pnfsdarg.mdspath, cp, PATH_MAX + 1,
3501                             NULL);
3502                         NFSD_DEBUG(4, "pnfsdcopymr cp mdspath=%d\n", error);
3503                         if (error == 0 && pnfsdarg.dspath != NULL) {
3504                                 cp2 = malloc(PATH_MAX + 1, M_TEMP, M_WAITOK);
3505                                 error = copyinstr(pnfsdarg.dspath, cp2,
3506                                     PATH_MAX + 1, NULL);
3507                                 NFSD_DEBUG(4, "pnfsdcopymr cp dspath=%d\n",
3508                                     error);
3509                         } else
3510                                 cp2 = NULL;
3511                         if (error == 0 && pnfsdarg.curdspath != NULL) {
3512                                 cp3 = malloc(PATH_MAX + 1, M_TEMP, M_WAITOK);
3513                                 error = copyinstr(pnfsdarg.curdspath, cp3,
3514                                     PATH_MAX + 1, NULL);
3515                                 NFSD_DEBUG(4, "pnfsdcopymr cp curdspath=%d\n",
3516                                     error);
3517                         } else
3518                                 cp3 = NULL;
3519                         curdvp = NULL;
3520                         fds = NULL;
3521                         if (error == 0)
3522                                 error = nfsrv_mdscopymr(cp, cp2, cp3, buf,
3523                                     &buflen, fname, td, &vp, &nvp, &pf, &ds,
3524                                     &fds);
3525                         NFSD_DEBUG(4, "nfsrv_mdscopymr=%d\n", error);
3526                         if (error == 0) {
3527                                 if (pf->dsf_dir >= nfsrv_dsdirsize) {
3528                                         printf("copymr: dsdir out of range\n");
3529                                         pf->dsf_dir = 0;
3530                                 }
3531                                 NFSD_DEBUG(4, "copymr: buflen=%d\n", buflen);
3532                                 error = nfsrv_copymr(vp, nvp,
3533                                     ds->nfsdev_dsdir[pf->dsf_dir], ds, pf,
3534                                     (struct pnfsdsfile *)buf,
3535                                     buflen / sizeof(*pf), td->td_ucred, td);
3536                                 vput(vp);
3537                                 vput(nvp);
3538                                 if (fds != NULL && error == 0) {
3539                                         curdvp = fds->nfsdev_dsdir[pf->dsf_dir];
3540                                         ret = vn_lock(curdvp, LK_EXCLUSIVE);
3541                                         if (ret == 0) {
3542                                                 nfsrv_dsremove(curdvp, fname,
3543                                                     td->td_ucred, td);
3544                                                 NFSVOPUNLOCK(curdvp, 0);
3545                                         }
3546                                 }
3547                                 NFSD_DEBUG(4, "nfsrv_copymr=%d\n", error);
3548                         }
3549                         free(cp, M_TEMP);
3550                         free(cp2, M_TEMP);
3551                         free(cp3, M_TEMP);
3552                         free(buf, M_TEMP);
3553                 }
3554         } else {
3555                 error = nfssvc_srvcall(td, uap, td->td_ucred);
3556         }
3557
3558 out:
3559         NFSEXITCODE(error);
3560         return (error);
3561 }
3562
3563 static int
3564 nfssvc_srvcall(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
3565 {
3566         struct nfsex_args export;
3567         struct file *fp = NULL;
3568         int stablefd, len;
3569         struct nfsd_clid adminrevoke;
3570         struct nfsd_dumplist dumplist;
3571         struct nfsd_dumpclients *dumpclients;
3572         struct nfsd_dumplocklist dumplocklist;
3573         struct nfsd_dumplocks *dumplocks;
3574         struct nameidata nd;
3575         vnode_t vp;
3576         int error = EINVAL, igotlock;
3577         struct proc *procp;
3578         static int suspend_nfsd = 0;
3579
3580         if (uap->flag & NFSSVC_PUBLICFH) {
3581                 NFSBZERO((caddr_t)&nfs_pubfh.nfsrvfh_data,
3582                     sizeof (fhandle_t));
3583                 error = copyin(uap->argp,
3584                     &nfs_pubfh.nfsrvfh_data, sizeof (fhandle_t));
3585                 if (!error)
3586                         nfs_pubfhset = 1;
3587         } else if (uap->flag & NFSSVC_V4ROOTEXPORT) {
3588                 error = copyin(uap->argp,(caddr_t)&export,
3589                     sizeof (struct nfsex_args));
3590                 if (!error)
3591                         error = nfsrv_v4rootexport(&export, cred, p);
3592         } else if (uap->flag & NFSSVC_NOPUBLICFH) {
3593                 nfs_pubfhset = 0;
3594                 error = 0;
3595         } else if (uap->flag & NFSSVC_STABLERESTART) {
3596                 error = copyin(uap->argp, (caddr_t)&stablefd,
3597                     sizeof (int));
3598                 if (!error)
3599                         error = fp_getfvp(p, stablefd, &fp, &vp);
3600                 if (!error && (NFSFPFLAG(fp) & (FREAD | FWRITE)) != (FREAD | FWRITE))
3601                         error = EBADF;
3602                 if (!error && newnfs_numnfsd != 0)
3603                         error = EPERM;
3604                 if (!error) {
3605                         nfsrv_stablefirst.nsf_fp = fp;
3606                         nfsrv_setupstable(p);
3607                 }
3608         } else if (uap->flag & NFSSVC_ADMINREVOKE) {
3609                 error = copyin(uap->argp, (caddr_t)&adminrevoke,
3610                     sizeof (struct nfsd_clid));
3611                 if (!error)
3612                         error = nfsrv_adminrevoke(&adminrevoke, p);
3613         } else if (uap->flag & NFSSVC_DUMPCLIENTS) {
3614                 error = copyin(uap->argp, (caddr_t)&dumplist,
3615                     sizeof (struct nfsd_dumplist));
3616                 if (!error && (dumplist.ndl_size < 1 ||
3617                         dumplist.ndl_size > NFSRV_MAXDUMPLIST))
3618                         error = EPERM;
3619                 if (!error) {
3620                     len = sizeof (struct nfsd_dumpclients) * dumplist.ndl_size;
3621                     dumpclients = malloc(len, M_TEMP, M_WAITOK | M_ZERO);
3622                     nfsrv_dumpclients(dumpclients, dumplist.ndl_size);
3623                     error = copyout(dumpclients,
3624                         CAST_USER_ADDR_T(dumplist.ndl_list), len);
3625                     free(dumpclients, M_TEMP);
3626                 }
3627         } else if (uap->flag & NFSSVC_DUMPLOCKS) {
3628                 error = copyin(uap->argp, (caddr_t)&dumplocklist,
3629                     sizeof (struct nfsd_dumplocklist));
3630                 if (!error && (dumplocklist.ndllck_size < 1 ||
3631                         dumplocklist.ndllck_size > NFSRV_MAXDUMPLIST))
3632                         error = EPERM;
3633                 if (!error)
3634                         error = nfsrv_lookupfilename(&nd,
3635                                 dumplocklist.ndllck_fname, p);
3636                 if (!error) {
3637                         len = sizeof (struct nfsd_dumplocks) *
3638                                 dumplocklist.ndllck_size;
3639                         dumplocks = malloc(len, M_TEMP, M_WAITOK | M_ZERO);
3640                         nfsrv_dumplocks(nd.ni_vp, dumplocks,
3641                             dumplocklist.ndllck_size, p);
3642                         vput(nd.ni_vp);
3643                         error = copyout(dumplocks,
3644                             CAST_USER_ADDR_T(dumplocklist.ndllck_list), len);
3645                         free(dumplocks, M_TEMP);
3646                 }
3647         } else if (uap->flag & NFSSVC_BACKUPSTABLE) {
3648                 procp = p->td_proc;
3649                 PROC_LOCK(procp);
3650                 nfsd_master_pid = procp->p_pid;
3651                 bcopy(procp->p_comm, nfsd_master_comm, MAXCOMLEN + 1);
3652                 nfsd_master_start = procp->p_stats->p_start;
3653                 nfsd_master_proc = procp;
3654                 PROC_UNLOCK(procp);
3655         } else if ((uap->flag & NFSSVC_SUSPENDNFSD) != 0) {
3656                 NFSLOCKV4ROOTMUTEX();
3657                 if (suspend_nfsd == 0) {
3658                         /* Lock out all nfsd threads */
3659                         do {
3660                                 igotlock = nfsv4_lock(&nfsd_suspend_lock, 1,
3661                                     NULL, NFSV4ROOTLOCKMUTEXPTR, NULL);
3662                         } while (igotlock == 0 && suspend_nfsd == 0);
3663                         suspend_nfsd = 1;
3664                 }
3665                 NFSUNLOCKV4ROOTMUTEX();
3666                 error = 0;
3667         } else if ((uap->flag & NFSSVC_RESUMENFSD) != 0) {
3668                 NFSLOCKV4ROOTMUTEX();
3669                 if (suspend_nfsd != 0) {
3670                         nfsv4_unlock(&nfsd_suspend_lock, 0);
3671                         suspend_nfsd = 0;
3672                 }
3673                 NFSUNLOCKV4ROOTMUTEX();
3674                 error = 0;
3675         }
3676
3677         NFSEXITCODE(error);
3678         return (error);
3679 }
3680
3681 /*
3682  * Check exports.
3683  * Returns 0 if ok, 1 otherwise.
3684  */
3685 int
3686 nfsvno_testexp(struct nfsrv_descript *nd, struct nfsexstuff *exp)
3687 {
3688         int i;
3689
3690         /*
3691          * This seems odd, but allow the case where the security flavor
3692          * list is empty. This happens when NFSv4 is traversing non-exported
3693          * file systems. Exported file systems should always have a non-empty
3694          * security flavor list.
3695          */
3696         if (exp->nes_numsecflavor == 0)
3697                 return (0);
3698
3699         for (i = 0; i < exp->nes_numsecflavor; i++) {
3700                 /*
3701                  * The tests for privacy and integrity must be first,
3702                  * since ND_GSS is set for everything but AUTH_SYS.
3703                  */
3704                 if (exp->nes_secflavors[i] == RPCSEC_GSS_KRB5P &&
3705                     (nd->nd_flag & ND_GSSPRIVACY))
3706                         return (0);
3707                 if (exp->nes_secflavors[i] == RPCSEC_GSS_KRB5I &&
3708                     (nd->nd_flag & ND_GSSINTEGRITY))
3709                         return (0);
3710                 if (exp->nes_secflavors[i] == RPCSEC_GSS_KRB5 &&
3711                     (nd->nd_flag & ND_GSS))
3712                         return (0);
3713                 if (exp->nes_secflavors[i] == AUTH_SYS &&
3714                     (nd->nd_flag & ND_GSS) == 0)
3715                         return (0);
3716         }
3717         return (1);
3718 }
3719
3720 /*
3721  * Calculate a hash value for the fid in a file handle.
3722  */
3723 uint32_t
3724 nfsrv_hashfh(fhandle_t *fhp)
3725 {
3726         uint32_t hashval;
3727
3728         hashval = hash32_buf(&fhp->fh_fid, sizeof(struct fid), 0);
3729         return (hashval);
3730 }
3731
3732 /*
3733  * Calculate a hash value for the sessionid.
3734  */
3735 uint32_t
3736 nfsrv_hashsessionid(uint8_t *sessionid)
3737 {
3738         uint32_t hashval;
3739
3740         hashval = hash32_buf(sessionid, NFSX_V4SESSIONID, 0);
3741         return (hashval);
3742 }
3743
3744 /*
3745  * Signal the userland master nfsd to backup the stable restart file.
3746  */
3747 void
3748 nfsrv_backupstable(void)
3749 {
3750         struct proc *procp;
3751
3752         if (nfsd_master_proc != NULL) {
3753                 procp = pfind(nfsd_master_pid);
3754                 /* Try to make sure it is the correct process. */
3755                 if (procp == nfsd_master_proc &&
3756                     procp->p_stats->p_start.tv_sec ==
3757                     nfsd_master_start.tv_sec &&
3758                     procp->p_stats->p_start.tv_usec ==
3759                     nfsd_master_start.tv_usec &&
3760                     strcmp(procp->p_comm, nfsd_master_comm) == 0)
3761                         kern_psignal(procp, SIGUSR2);
3762                 else
3763                         nfsd_master_proc = NULL;
3764
3765                 if (procp != NULL)
3766                         PROC_UNLOCK(procp);
3767         }
3768 }
3769
3770 /*
3771  * Create a DS data file for nfsrv_pnfscreate(). Called for each mirror.
3772  * The arguments are in a structure, so that they can be passed through
3773  * taskqueue for a kernel process to execute this function.
3774  */
3775 struct nfsrvdscreate {
3776         int                     done;
3777         int                     inprog;
3778         struct task             tsk;
3779         struct ucred            *tcred;
3780         struct vnode            *dvp;
3781         NFSPROC_T               *p;
3782         struct pnfsdsfile       *pf;
3783         int                     err;
3784         fhandle_t               fh;
3785         struct vattr            va;
3786         struct vattr            createva;
3787 };
3788
3789 int
3790 nfsrv_dscreate(struct vnode *dvp, struct vattr *vap, struct vattr *nvap,
3791     fhandle_t *fhp, struct pnfsdsfile *pf, struct pnfsdsattr *dsa,
3792     char *fnamep, struct ucred *tcred, NFSPROC_T *p, struct vnode **nvpp)
3793 {
3794         struct vnode *nvp;
3795         struct nameidata named;
3796         struct vattr va;
3797         char *bufp;
3798         u_long *hashp;
3799         struct nfsnode *np;
3800         struct nfsmount *nmp;
3801         int error;
3802
3803         NFSNAMEICNDSET(&named.ni_cnd, tcred, CREATE,
3804             LOCKPARENT | LOCKLEAF | SAVESTART | NOCACHE);
3805         nfsvno_setpathbuf(&named, &bufp, &hashp);
3806         named.ni_cnd.cn_lkflags = LK_EXCLUSIVE;
3807         named.ni_cnd.cn_thread = p;
3808         named.ni_cnd.cn_nameptr = bufp;
3809         if (fnamep != NULL) {
3810                 strlcpy(bufp, fnamep, PNFS_FILENAME_LEN + 1);
3811                 named.ni_cnd.cn_namelen = strlen(bufp);
3812         } else
3813                 named.ni_cnd.cn_namelen = nfsrv_putfhname(fhp, bufp);
3814         NFSD_DEBUG(4, "nfsrv_dscreate: dvp=%p fname=%s\n", dvp, bufp);
3815
3816         /* Create the date file in the DS mount. */
3817         error = NFSVOPLOCK(dvp, LK_EXCLUSIVE);
3818         if (error == 0) {
3819                 error = VOP_CREATE(dvp, &nvp, &named.ni_cnd, vap);
3820                 NFSVOPUNLOCK(dvp, 0);
3821                 if (error == 0) {
3822                         /* Set the ownership of the file. */
3823                         error = VOP_SETATTR(nvp, nvap, tcred);
3824                         NFSD_DEBUG(4, "nfsrv_dscreate:"
3825                             " setattr-uid=%d\n", error);
3826                         if (error != 0)
3827                                 vput(nvp);
3828                 }
3829                 if (error != 0)
3830                         printf("pNFS: pnfscreate failed=%d\n", error);
3831         } else
3832                 printf("pNFS: pnfscreate vnlock=%d\n", error);
3833         if (error == 0) {
3834                 np = VTONFS(nvp);
3835                 nmp = VFSTONFS(nvp->v_mount);
3836                 if (strcmp(nvp->v_mount->mnt_vfc->vfc_name, "nfs")
3837                     != 0 || nmp->nm_nam->sa_len > sizeof(
3838                     struct sockaddr_in6) ||
3839                     np->n_fhp->nfh_len != NFSX_MYFH) {
3840                         printf("Bad DS file: fstype=%s salen=%d"
3841                             " fhlen=%d\n",
3842                             nvp->v_mount->mnt_vfc->vfc_name,
3843                             nmp->nm_nam->sa_len, np->n_fhp->nfh_len);
3844                         error = ENOENT;
3845                 }
3846
3847                 /* Set extattrs for the DS on the MDS file. */
3848                 if (error == 0) {
3849                         if (dsa != NULL) {
3850                                 error = VOP_GETATTR(nvp, &va, tcred);
3851                                 if (error == 0) {
3852                                         dsa->dsa_filerev = va.va_filerev;
3853                                         dsa->dsa_size = va.va_size;
3854                                         dsa->dsa_atime = va.va_atime;
3855                                         dsa->dsa_mtime = va.va_mtime;
3856                                 }
3857                         }
3858                         if (error == 0) {
3859                                 NFSBCOPY(np->n_fhp->nfh_fh, &pf->dsf_fh,
3860                                     NFSX_MYFH);
3861                                 NFSBCOPY(nmp->nm_nam, &pf->dsf_sin,
3862                                     nmp->nm_nam->sa_len);
3863                                 NFSBCOPY(named.ni_cnd.cn_nameptr,
3864                                     pf->dsf_filename,
3865                                     sizeof(pf->dsf_filename));
3866                         }
3867                 } else
3868                         printf("pNFS: pnfscreate can't get DS"
3869                             " attr=%d\n", error);
3870                 if (nvpp != NULL && error == 0)
3871                         *nvpp = nvp;
3872                 else
3873                         vput(nvp);
3874         }
3875         nfsvno_relpathbuf(&named);
3876         return (error);
3877 }
3878
3879 /*
3880  * Start up the thread that will execute nfsrv_dscreate().
3881  */
3882 static void
3883 start_dscreate(void *arg, int pending)
3884 {
3885         struct nfsrvdscreate *dsc;
3886
3887         dsc = (struct nfsrvdscreate *)arg;
3888         dsc->err = nfsrv_dscreate(dsc->dvp, &dsc->createva, &dsc->va, &dsc->fh,
3889             dsc->pf, NULL, NULL, dsc->tcred, dsc->p, NULL);
3890         dsc->done = 1;
3891         NFSD_DEBUG(4, "start_dscreate: err=%d\n", dsc->err);
3892 }
3893
3894 /*
3895  * Create a pNFS data file on the Data Server(s).
3896  */
3897 static void
3898 nfsrv_pnfscreate(struct vnode *vp, struct vattr *vap, struct ucred *cred,
3899     NFSPROC_T *p)
3900 {
3901         struct nfsrvdscreate *dsc, *tdsc;
3902         struct nfsdevice *ds, *tds, *fds;
3903         struct mount *mp;
3904         struct pnfsdsfile *pf, *tpf;
3905         struct pnfsdsattr dsattr;
3906         struct vattr va;
3907         struct vnode *dvp[NFSDEV_MAXMIRRORS];
3908         struct nfsmount *nmp;
3909         fhandle_t fh;
3910         uid_t vauid;
3911         gid_t vagid;
3912         u_short vamode;
3913         struct ucred *tcred;
3914         int dsdir[NFSDEV_MAXMIRRORS], error, i, mirrorcnt, ret;
3915         int failpos, timo;
3916
3917         /* Get a DS server directory in a round-robin order. */
3918         mirrorcnt = 1;
3919         mp = vp->v_mount;
3920         ds = fds = NULL;
3921         NFSDDSLOCK();
3922         /*
3923          * Search for the first entry that handles this MDS fs, but use the
3924          * first entry for all MDS fs's otherwise.
3925          */
3926         TAILQ_FOREACH(tds, &nfsrv_devidhead, nfsdev_list) {
3927                 if (tds->nfsdev_nmp != NULL) {
3928                         if (tds->nfsdev_mdsisset == 0 && ds == NULL)
3929                                 ds = tds;
3930                         else if (tds->nfsdev_mdsisset != 0 &&
3931                             mp->mnt_stat.f_fsid.val[0] ==
3932                             tds->nfsdev_mdsfsid.val[0] &&
3933                             mp->mnt_stat.f_fsid.val[1] ==
3934                             tds->nfsdev_mdsfsid.val[1]) {
3935                                 ds = fds = tds;
3936                                 break;
3937                         }
3938                 }
3939         }
3940         if (ds == NULL) {
3941                 NFSDDSUNLOCK();
3942                 NFSD_DEBUG(4, "nfsrv_pnfscreate: no srv\n");
3943                 return;
3944         }
3945         i = dsdir[0] = ds->nfsdev_nextdir;
3946         ds->nfsdev_nextdir = (ds->nfsdev_nextdir + 1) % nfsrv_dsdirsize;
3947         dvp[0] = ds->nfsdev_dsdir[i];
3948         tds = TAILQ_NEXT(ds, nfsdev_list);
3949         if (nfsrv_maxpnfsmirror > 1 && tds != NULL) {
3950                 TAILQ_FOREACH_FROM(tds, &nfsrv_devidhead, nfsdev_list) {
3951                         if (tds->nfsdev_nmp != NULL &&
3952                             ((tds->nfsdev_mdsisset == 0 && fds == NULL) ||
3953                              (tds->nfsdev_mdsisset != 0 && fds != NULL &&
3954                               mp->mnt_stat.f_fsid.val[0] ==
3955                               tds->nfsdev_mdsfsid.val[0] &&
3956                               mp->mnt_stat.f_fsid.val[1] ==
3957                               tds->nfsdev_mdsfsid.val[1]))) {
3958                                 dsdir[mirrorcnt] = i;
3959                                 dvp[mirrorcnt] = tds->nfsdev_dsdir[i];
3960                                 mirrorcnt++;
3961                                 if (mirrorcnt >= nfsrv_maxpnfsmirror)
3962                                         break;
3963                         }
3964                 }
3965         }
3966         /* Put at end of list to implement round-robin usage. */
3967         TAILQ_REMOVE(&nfsrv_devidhead, ds, nfsdev_list);
3968         TAILQ_INSERT_TAIL(&nfsrv_devidhead, ds, nfsdev_list);
3969         NFSDDSUNLOCK();
3970         dsc = NULL;
3971         if (mirrorcnt > 1)
3972                 tdsc = dsc = malloc(sizeof(*dsc) * (mirrorcnt - 1), M_TEMP,
3973                     M_WAITOK | M_ZERO);
3974         tpf = pf = malloc(sizeof(*pf) * nfsrv_maxpnfsmirror, M_TEMP, M_WAITOK |
3975             M_ZERO);
3976
3977         error = nfsvno_getfh(vp, &fh, p);
3978         if (error == 0)
3979                 error = VOP_GETATTR(vp, &va, cred);
3980         if (error == 0) {
3981                 /* Set the attributes for "vp" to Setattr the DS vp. */
3982                 vauid = va.va_uid;
3983                 vagid = va.va_gid;
3984                 vamode = va.va_mode;
3985                 VATTR_NULL(&va);
3986                 va.va_uid = vauid;
3987                 va.va_gid = vagid;
3988                 va.va_mode = vamode;
3989                 va.va_size = 0;
3990         } else
3991                 printf("pNFS: pnfscreate getfh+attr=%d\n", error);
3992
3993         NFSD_DEBUG(4, "nfsrv_pnfscreate: cruid=%d crgid=%d\n", cred->cr_uid,
3994             cred->cr_gid);
3995         /* Make data file name based on FH. */
3996         tcred = newnfs_getcred();
3997
3998         /*
3999          * Create the file on each DS mirror, using kernel process(es) for the
4000          * additional mirrors.
4001          */
4002         failpos = -1;
4003         for (i = 0; i < mirrorcnt - 1 && error == 0; i++, tpf++, tdsc++) {
4004                 tpf->dsf_dir = dsdir[i];
4005                 tdsc->tcred = tcred;
4006                 tdsc->p = p;
4007                 tdsc->pf = tpf;
4008                 tdsc->createva = *vap;
4009                 NFSBCOPY(&fh, &tdsc->fh, sizeof(fh));
4010                 tdsc->va = va;
4011                 tdsc->dvp = dvp[i];
4012                 tdsc->done = 0;
4013                 tdsc->inprog = 0;
4014                 tdsc->err = 0;
4015                 ret = EIO;
4016                 if (nfs_pnfsiothreads != 0) {
4017                         ret = nfs_pnfsio(start_dscreate, tdsc);
4018                         NFSD_DEBUG(4, "nfsrv_pnfscreate: nfs_pnfsio=%d\n", ret);
4019                 }
4020                 if (ret != 0) {
4021                         ret = nfsrv_dscreate(dvp[i], vap, &va, &fh, tpf, NULL,
4022                             NULL, tcred, p, NULL);
4023                         if (ret != 0) {
4024                                 KASSERT(error == 0, ("nfsrv_dscreate err=%d",
4025                                     error));
4026                                 if (failpos == -1 && nfsds_failerr(ret))
4027                                         failpos = i;
4028                                 else
4029                                         error = ret;
4030                         }
4031                 }
4032         }
4033         if (error == 0) {
4034                 tpf->dsf_dir = dsdir[mirrorcnt - 1];
4035                 error = nfsrv_dscreate(dvp[mirrorcnt - 1], vap, &va, &fh, tpf,
4036                     &dsattr, NULL, tcred, p, NULL);
4037                 if (failpos == -1 && mirrorcnt > 1 && nfsds_failerr(error)) {
4038                         failpos = mirrorcnt - 1;
4039                         error = 0;
4040                 }
4041         }
4042         timo = hz / 50;         /* Wait for 20msec. */
4043         if (timo < 1)
4044                 timo = 1;
4045         /* Wait for kernel task(s) to complete. */
4046         for (tdsc = dsc, i = 0; i < mirrorcnt - 1; i++, tdsc++) {
4047                 while (tdsc->inprog != 0 && tdsc->done == 0)
4048                         tsleep(&tdsc->tsk, PVFS, "srvdcr", timo);
4049                 if (tdsc->err != 0) {
4050                         if (failpos == -1 && nfsds_failerr(tdsc->err))
4051                                 failpos = i;
4052                         else if (error == 0)
4053                                 error = tdsc->err;
4054                 }
4055         }
4056
4057         /*
4058          * If failpos has been set, that mirror has failed, so it needs
4059          * to be disabled.
4060          */
4061         if (failpos >= 0) {
4062                 nmp = VFSTONFS(dvp[failpos]->v_mount);
4063                 NFSLOCKMNT(nmp);
4064                 if ((nmp->nm_privflag & (NFSMNTP_FORCEDISM |
4065                      NFSMNTP_CANCELRPCS)) == 0) {
4066                         nmp->nm_privflag |= NFSMNTP_CANCELRPCS;
4067                         NFSUNLOCKMNT(nmp);
4068                         ds = nfsrv_deldsnmp(PNFSDOP_DELDSSERVER, nmp, p);
4069                         NFSD_DEBUG(4, "dscreatfail fail=%d ds=%p\n", failpos,
4070                             ds);
4071                         if (ds != NULL)
4072                                 nfsrv_killrpcs(nmp);
4073                         NFSLOCKMNT(nmp);
4074                         nmp->nm_privflag &= ~NFSMNTP_CANCELRPCS;
4075                         wakeup(nmp);
4076                 }
4077                 NFSUNLOCKMNT(nmp);
4078         }
4079
4080         NFSFREECRED(tcred);
4081         if (error == 0) {
4082                 ASSERT_VOP_ELOCKED(vp, "nfsrv_pnfscreate vp");
4083
4084                 NFSD_DEBUG(4, "nfsrv_pnfscreate: mirrorcnt=%d maxmirror=%d\n",
4085                     mirrorcnt, nfsrv_maxpnfsmirror);
4086                 /*
4087                  * For all mirrors that couldn't be created, fill in the
4088                  * *pf structure, but with an IP address == 0.0.0.0.
4089                  */
4090                 tpf = pf + mirrorcnt;
4091                 for (i = mirrorcnt; i < nfsrv_maxpnfsmirror; i++, tpf++) {
4092                         *tpf = *pf;
4093                         tpf->dsf_sin.sin_family = AF_INET;
4094                         tpf->dsf_sin.sin_len = sizeof(struct sockaddr_in);
4095                         tpf->dsf_sin.sin_addr.s_addr = 0;
4096                         tpf->dsf_sin.sin_port = 0;
4097                 }
4098
4099                 error = vn_extattr_set(vp, IO_NODELOCKED,
4100                     EXTATTR_NAMESPACE_SYSTEM, "pnfsd.dsfile",
4101                     sizeof(*pf) * nfsrv_maxpnfsmirror, (char *)pf, p);
4102                 if (error == 0)
4103                         error = vn_extattr_set(vp, IO_NODELOCKED,
4104                             EXTATTR_NAMESPACE_SYSTEM, "pnfsd.dsattr",
4105                             sizeof(dsattr), (char *)&dsattr, p);
4106                 if (error != 0)
4107                         printf("pNFS: pnfscreate setextattr=%d\n",
4108                             error);
4109         } else
4110                 printf("pNFS: pnfscreate=%d\n", error);
4111         free(pf, M_TEMP);
4112         free(dsc, M_TEMP);
4113 }
4114
4115 /*
4116  * Get the information needed to remove the pNFS Data Server file from the
4117  * Metadata file.  Upon success, ddvp is set non-NULL to the locked
4118  * DS directory vnode.  The caller must unlock *ddvp when done with it.
4119  */
4120 static void
4121 nfsrv_pnfsremovesetup(struct vnode *vp, NFSPROC_T *p, struct vnode **dvpp,
4122     int *mirrorcntp, char *fname, fhandle_t *fhp)
4123 {
4124         struct vattr va;
4125         struct ucred *tcred;
4126         char *buf;
4127         int buflen, error;
4128
4129         dvpp[0] = NULL;
4130         /* If not an exported regular file or not a pNFS server, just return. */
4131         if (vp->v_type != VREG || (vp->v_mount->mnt_flag & MNT_EXPORTED) == 0 ||
4132             nfsrv_devidcnt == 0)
4133                 return;
4134
4135         /* Check to see if this is the last hard link. */
4136         tcred = newnfs_getcred();
4137         error = VOP_GETATTR(vp, &va, tcred);
4138         NFSFREECRED(tcred);
4139         if (error != 0) {
4140                 printf("pNFS: nfsrv_pnfsremovesetup getattr=%d\n", error);
4141                 return;
4142         }
4143         if (va.va_nlink > 1)
4144                 return;
4145
4146         error = nfsvno_getfh(vp, fhp, p);
4147         if (error != 0) {
4148                 printf("pNFS: nfsrv_pnfsremovesetup getfh=%d\n", error);
4149                 return;
4150         }
4151
4152         buflen = 1024;
4153         buf = malloc(buflen, M_TEMP, M_WAITOK);
4154         /* Get the directory vnode for the DS mount and the file handle. */
4155         error = nfsrv_dsgetsockmnt(vp, 0, buf, &buflen, mirrorcntp, p, dvpp,
4156             NULL, NULL, fname, NULL, NULL, NULL, NULL, NULL);
4157         free(buf, M_TEMP);
4158         if (error != 0)
4159                 printf("pNFS: nfsrv_pnfsremovesetup getsockmnt=%d\n", error);
4160 }
4161
4162 /*
4163  * Remove a DS data file for nfsrv_pnfsremove(). Called for each mirror.
4164  * The arguments are in a structure, so that they can be passed through
4165  * taskqueue for a kernel process to execute this function.
4166  */
4167 struct nfsrvdsremove {
4168         int                     done;
4169         int                     inprog;
4170         struct task             tsk;
4171         struct ucred            *tcred;
4172         struct vnode            *dvp;
4173         NFSPROC_T               *p;
4174         int                     err;
4175         char                    fname[PNFS_FILENAME_LEN + 1];
4176 };
4177
4178 static int
4179 nfsrv_dsremove(struct vnode *dvp, char *fname, struct ucred *tcred,
4180     NFSPROC_T *p)
4181 {
4182         struct nameidata named;
4183         struct vnode *nvp;
4184         char *bufp;
4185         u_long *hashp;
4186         int error;
4187
4188         error = NFSVOPLOCK(dvp, LK_EXCLUSIVE);
4189         if (error != 0)
4190                 return (error);
4191         named.ni_cnd.cn_nameiop = DELETE;
4192         named.ni_cnd.cn_lkflags = LK_EXCLUSIVE | LK_RETRY;
4193         named.ni_cnd.cn_cred = tcred;
4194         named.ni_cnd.cn_thread = p;
4195         named.ni_cnd.cn_flags = ISLASTCN | LOCKPARENT | LOCKLEAF | SAVENAME;
4196         nfsvno_setpathbuf(&named, &bufp, &hashp);
4197         named.ni_cnd.cn_nameptr = bufp;
4198         named.ni_cnd.cn_namelen = strlen(fname);
4199         strlcpy(bufp, fname, NAME_MAX);
4200         NFSD_DEBUG(4, "nfsrv_pnfsremove: filename=%s\n", bufp);
4201         error = VOP_LOOKUP(dvp, &nvp, &named.ni_cnd);
4202         NFSD_DEBUG(4, "nfsrv_pnfsremove: aft LOOKUP=%d\n", error);
4203         if (error == 0) {
4204                 error = VOP_REMOVE(dvp, nvp, &named.ni_cnd);
4205                 vput(nvp);
4206         }
4207         NFSVOPUNLOCK(dvp, 0);
4208         nfsvno_relpathbuf(&named);
4209         if (error != 0)
4210                 printf("pNFS: nfsrv_pnfsremove failed=%d\n", error);
4211         return (error);
4212 }
4213
4214 /*
4215  * Start up the thread that will execute nfsrv_dsremove().
4216  */
4217 static void
4218 start_dsremove(void *arg, int pending)
4219 {
4220         struct nfsrvdsremove *dsrm;
4221
4222         dsrm = (struct nfsrvdsremove *)arg;
4223         dsrm->err = nfsrv_dsremove(dsrm->dvp, dsrm->fname, dsrm->tcred,
4224             dsrm->p);
4225         dsrm->done = 1;
4226         NFSD_DEBUG(4, "start_dsremove: err=%d\n", dsrm->err);
4227 }
4228
4229 /*
4230  * Remove a pNFS data file from a Data Server.
4231  * nfsrv_pnfsremovesetup() must have been called before the MDS file was
4232  * removed to set up the dvp and fill in the FH.
4233  */
4234 static void
4235 nfsrv_pnfsremove(struct vnode **dvp, int mirrorcnt, char *fname, fhandle_t *fhp,
4236     NFSPROC_T *p)
4237 {
4238         struct ucred *tcred;
4239         struct nfsrvdsremove *dsrm, *tdsrm;
4240         struct nfsdevice *ds;
4241         struct nfsmount *nmp;
4242         int failpos, i, ret, timo;
4243
4244         tcred = newnfs_getcred();
4245         dsrm = NULL;
4246         if (mirrorcnt > 1)
4247                 dsrm = malloc(sizeof(*dsrm) * mirrorcnt - 1, M_TEMP, M_WAITOK);
4248         /*
4249          * Remove the file on each DS mirror, using kernel process(es) for the
4250          * additional mirrors.
4251          */
4252         failpos = -1;
4253         for (tdsrm = dsrm, i = 0; i < mirrorcnt - 1; i++, tdsrm++) {
4254                 tdsrm->tcred = tcred;
4255                 tdsrm->p = p;
4256                 tdsrm->dvp = dvp[i];
4257                 strlcpy(tdsrm->fname, fname, PNFS_FILENAME_LEN + 1);
4258                 tdsrm->inprog = 0;
4259                 tdsrm->done = 0;
4260                 tdsrm->err = 0;
4261                 ret = EIO;
4262                 if (nfs_pnfsiothreads != 0) {
4263                         ret = nfs_pnfsio(start_dsremove, tdsrm);
4264                         NFSD_DEBUG(4, "nfsrv_pnfsremove: nfs_pnfsio=%d\n", ret);
4265                 }
4266                 if (ret != 0) {
4267                         ret = nfsrv_dsremove(dvp[i], fname, tcred, p);
4268                         if (failpos == -1 && nfsds_failerr(ret))
4269                                 failpos = i;
4270                 }
4271         }
4272         ret = nfsrv_dsremove(dvp[mirrorcnt - 1], fname, tcred, p);
4273         if (failpos == -1 && mirrorcnt > 1 && nfsds_failerr(ret))
4274                 failpos = mirrorcnt - 1;
4275         timo = hz / 50;         /* Wait for 20msec. */
4276         if (timo < 1)
4277                 timo = 1;
4278         /* Wait for kernel task(s) to complete. */
4279         for (tdsrm = dsrm, i = 0; i < mirrorcnt - 1; i++, tdsrm++) {
4280                 while (tdsrm->inprog != 0 && tdsrm->done == 0)
4281                         tsleep(&tdsrm->tsk, PVFS, "srvdsrm", timo);
4282                 if (failpos == -1 && nfsds_failerr(tdsrm->err))
4283                         failpos = i;
4284         }
4285
4286         /*
4287          * If failpos has been set, that mirror has failed, so it needs
4288          * to be disabled.
4289          */
4290         if (failpos >= 0) {
4291                 nmp = VFSTONFS(dvp[failpos]->v_mount);
4292                 NFSLOCKMNT(nmp);
4293                 if ((nmp->nm_privflag & (NFSMNTP_FORCEDISM |
4294                      NFSMNTP_CANCELRPCS)) == 0) {
4295                         nmp->nm_privflag |= NFSMNTP_CANCELRPCS;
4296                         NFSUNLOCKMNT(nmp);
4297                         ds = nfsrv_deldsnmp(PNFSDOP_DELDSSERVER, nmp, p);
4298                         NFSD_DEBUG(4, "dsremovefail fail=%d ds=%p\n", failpos,
4299                             ds);
4300                         if (ds != NULL)
4301                                 nfsrv_killrpcs(nmp);
4302                         NFSLOCKMNT(nmp);
4303                         nmp->nm_privflag &= ~NFSMNTP_CANCELRPCS;
4304                         wakeup(nmp);
4305                 }
4306                 NFSUNLOCKMNT(nmp);
4307         }
4308
4309         /* Get rid all layouts for the file. */
4310         nfsrv_freefilelayouts(fhp);
4311
4312         NFSFREECRED(tcred);
4313         free(dsrm, M_TEMP);
4314 }
4315
4316 /*
4317  * Generate a file name based on the file handle and put it in *bufp.
4318  * Return the number of bytes generated.
4319  */
4320 static int
4321 nfsrv_putfhname(fhandle_t *fhp, char *bufp)
4322 {
4323         int i;
4324         uint8_t *cp;
4325         const uint8_t *hexdigits = "0123456789abcdef";
4326
4327         cp = (uint8_t *)fhp;
4328         for (i = 0; i < sizeof(*fhp); i++) {
4329                 bufp[2 * i] = hexdigits[(*cp >> 4) & 0xf];
4330                 bufp[2 * i + 1] = hexdigits[*cp++ & 0xf];
4331         }
4332         bufp[2 * i] = '\0';
4333         return (2 * i);
4334 }
4335
4336 /*
4337  * Update the Metadata file's attributes from the DS file when a Read/Write
4338  * layout is returned.
4339  * Basically just call nfsrv_proxyds() with procedure == NFSPROC_LAYOUTRETURN
4340  * so that it does a nfsrv_getattrdsrpc() and nfsrv_setextattr() on the DS file.
4341  */
4342 int
4343 nfsrv_updatemdsattr(struct vnode *vp, struct nfsvattr *nap, NFSPROC_T *p)
4344 {
4345         struct ucred *tcred;
4346         int error;
4347
4348         /* Do this as root so that it won't fail with EACCES. */
4349         tcred = newnfs_getcred();
4350         error = nfsrv_proxyds(NULL, vp, 0, 0, tcred, p, NFSPROC_LAYOUTRETURN,
4351             NULL, NULL, NULL, nap, NULL);
4352         NFSFREECRED(tcred);
4353         return (error);
4354 }
4355
4356 /*
4357  * Set the NFSv4 ACL on the DS file to the same ACL as the MDS file.
4358  */
4359 static int
4360 nfsrv_dssetacl(struct vnode *vp, struct acl *aclp, struct ucred *cred,
4361     NFSPROC_T *p)
4362 {
4363         int error;
4364
4365         error = nfsrv_proxyds(NULL, vp, 0, 0, cred, p, NFSPROC_SETACL,
4366             NULL, NULL, NULL, NULL, aclp);
4367         return (error);
4368 }
4369
4370 static int
4371 nfsrv_proxyds(struct nfsrv_descript *nd, struct vnode *vp, off_t off, int cnt,
4372     struct ucred *cred, struct thread *p, int ioproc, struct mbuf **mpp,
4373     char *cp, struct mbuf **mpp2, struct nfsvattr *nap, struct acl *aclp)
4374 {
4375         struct nfsmount *nmp[NFSDEV_MAXMIRRORS], *failnmp;
4376         fhandle_t fh[NFSDEV_MAXMIRRORS];
4377         struct vnode *dvp[NFSDEV_MAXMIRRORS];
4378         struct nfsdevice *ds;
4379         struct pnfsdsattr dsattr;
4380         char *buf;
4381         int buflen, error, failpos, i, mirrorcnt, origmircnt, trycnt;
4382
4383         NFSD_DEBUG(4, "in nfsrv_proxyds\n");
4384         /*
4385          * If not a regular file, not exported or not a pNFS server,
4386          * just return ENOENT.
4387          */
4388         if (vp->v_type != VREG || (vp->v_mount->mnt_flag & MNT_EXPORTED) == 0 ||
4389             nfsrv_devidcnt == 0)
4390                 return (ENOENT);
4391
4392         buflen = 1024;
4393         buf = malloc(buflen, M_TEMP, M_WAITOK);
4394         error = 0;
4395
4396         /*
4397          * For Getattr, get the Change attribute (va_filerev) and size (va_size)
4398          * from the MetaData file's extended attribute.
4399          */
4400         if (ioproc == NFSPROC_GETATTR) {
4401                 error = vn_extattr_get(vp, IO_NODELOCKED,
4402                     EXTATTR_NAMESPACE_SYSTEM, "pnfsd.dsattr", &buflen, buf,
4403                     p);
4404                 if (error == 0 && buflen != sizeof(dsattr))
4405                         error = ENXIO;
4406                 if (error == 0) {
4407                         NFSBCOPY(buf, &dsattr, buflen);
4408                         nap->na_filerev = dsattr.dsa_filerev;
4409                         nap->na_size = dsattr.dsa_size;
4410                         nap->na_atime = dsattr.dsa_atime;
4411                         nap->na_mtime = dsattr.dsa_mtime;
4412
4413                         /*
4414                          * If nfsrv_pnfsgetdsattr is 0 or nfsrv_checkdsattr()
4415                          * returns 0, just return now.  nfsrv_checkdsattr()
4416                          * returns 0 if there is no Read/Write layout
4417                          * plus either an Open/Write_access or Write
4418                          * delegation issued to a client for the file.
4419                          */
4420                         if (nfsrv_pnfsgetdsattr == 0 ||
4421                             nfsrv_checkdsattr(nd, vp, p) == 0) {
4422                                 free(buf, M_TEMP);
4423                                 return (error);
4424                         }
4425                 }
4426
4427                 /*
4428                  * Clear ENOATTR so the code below will attempt to do a
4429                  * nfsrv_getattrdsrpc() to get the attributes and (re)create
4430                  * the extended attribute.
4431                  */
4432                 if (error == ENOATTR)
4433                         error = 0;
4434         }
4435
4436         origmircnt = -1;
4437         trycnt = 0;
4438 tryagain:
4439         if (error == 0) {
4440                 buflen = 1024;
4441                 if (ioproc == NFSPROC_READDS && NFSVOPISLOCKED(vp) ==
4442                     LK_EXCLUSIVE)
4443                         printf("nfsrv_proxyds: Readds vp exclusively locked\n");
4444                 error = nfsrv_dsgetsockmnt(vp, LK_SHARED, buf, &buflen,
4445                     &mirrorcnt, p, dvp, fh, NULL, NULL, NULL, NULL, NULL,
4446                     NULL, NULL);
4447                 if (error == 0) {
4448                         for (i = 0; i < mirrorcnt; i++)
4449                                 nmp[i] = VFSTONFS(dvp[i]->v_mount);
4450                 } else
4451                         printf("pNFS: proxy getextattr sockaddr=%d\n", error);
4452         } else
4453                 printf("pNFS: nfsrv_dsgetsockmnt=%d\n", error);
4454         if (error == 0) {
4455                 failpos = -1;
4456                 if (origmircnt == -1)
4457                         origmircnt = mirrorcnt;
4458                 /*
4459                  * If failpos is set to a mirror#, then that mirror has
4460                  * failed and will be disabled. For Read and Getattr, the
4461                  * function only tries one mirror, so if that mirror has
4462                  * failed, it will need to be retried. As such, increment
4463                  * tryitagain for these cases.
4464                  * For Write, Setattr and Setacl, the function tries all
4465                  * mirrors and will not return an error for the case where
4466                  * one mirror has failed. For these cases, the functioning
4467                  * mirror(s) will have been modified, so a retry isn't
4468                  * necessary. These functions will set failpos for the
4469                  * failed mirror#.
4470                  */
4471                 if (ioproc == NFSPROC_READDS) {
4472                         error = nfsrv_readdsrpc(fh, off, cnt, cred, p, nmp[0],
4473                             mpp, mpp2);
4474                         if (nfsds_failerr(error) && mirrorcnt > 1) {
4475                                 /*
4476                                  * Setting failpos will cause the mirror
4477                                  * to be disabled and then a retry of this
4478                                  * read is required.
4479                                  */
4480                                 failpos = 0;
4481                                 error = 0;
4482                                 trycnt++;
4483                         }
4484                 } else if (ioproc == NFSPROC_WRITEDS)
4485                         error = nfsrv_writedsrpc(fh, off, cnt, cred, p, vp,
4486                             &nmp[0], mirrorcnt, mpp, cp, &failpos);
4487                 else if (ioproc == NFSPROC_SETATTR)
4488                         error = nfsrv_setattrdsrpc(fh, cred, p, vp, &nmp[0],
4489                             mirrorcnt, nap, &failpos);
4490                 else if (ioproc == NFSPROC_SETACL)
4491                         error = nfsrv_setacldsrpc(fh, cred, p, vp, &nmp[0],
4492                             mirrorcnt, aclp, &failpos);
4493                 else {
4494                         error = nfsrv_getattrdsrpc(&fh[mirrorcnt - 1], cred, p,
4495                             vp, nmp[mirrorcnt - 1], nap);
4496                         if (nfsds_failerr(error) && mirrorcnt > 1) {
4497                                 /*
4498                                  * Setting failpos will cause the mirror
4499                                  * to be disabled and then a retry of this
4500                                  * getattr is required.
4501                                  */
4502                                 failpos = mirrorcnt - 1;
4503                                 error = 0;
4504                                 trycnt++;
4505                         }
4506                 }
4507                 ds = NULL;
4508                 if (failpos >= 0) {
4509                         failnmp = nmp[failpos];
4510                         NFSLOCKMNT(failnmp);
4511                         if ((failnmp->nm_privflag & (NFSMNTP_FORCEDISM |
4512                              NFSMNTP_CANCELRPCS)) == 0) {
4513                                 failnmp->nm_privflag |= NFSMNTP_CANCELRPCS;
4514                                 NFSUNLOCKMNT(failnmp);
4515                                 ds = nfsrv_deldsnmp(PNFSDOP_DELDSSERVER,
4516                                     failnmp, p);
4517                                 NFSD_DEBUG(4, "dsldsnmp fail=%d ds=%p\n",
4518                                     failpos, ds);
4519                                 if (ds != NULL)
4520                                         nfsrv_killrpcs(failnmp);
4521                                 NFSLOCKMNT(failnmp);
4522                                 failnmp->nm_privflag &= ~NFSMNTP_CANCELRPCS;
4523                                 wakeup(failnmp);
4524                         }
4525                         NFSUNLOCKMNT(failnmp);
4526                 }
4527                 for (i = 0; i < mirrorcnt; i++)
4528                         NFSVOPUNLOCK(dvp[i], 0);
4529                 NFSD_DEBUG(4, "nfsrv_proxyds: aft RPC=%d trya=%d\n", error,
4530                     trycnt);
4531                 /* Try the Read/Getattr again if a mirror was deleted. */
4532                 if (ds != NULL && trycnt > 0 && trycnt < origmircnt)
4533                         goto tryagain;
4534         } else {
4535                 /* Return ENOENT for any Extended Attribute error. */
4536                 error = ENOENT;
4537         }
4538         free(buf, M_TEMP);
4539         NFSD_DEBUG(4, "nfsrv_proxyds: error=%d\n", error);
4540         return (error);
4541 }
4542
4543 /*
4544  * Get the DS mount point, fh and directory from the "pnfsd.dsfile" extended
4545  * attribute.
4546  * newnmpp - If it points to a non-NULL nmp, that is the destination and needs
4547  *           to be checked.  If it points to a NULL nmp, then it returns
4548  *           a suitable destination.
4549  * curnmp - If non-NULL, it is the source mount for the copy.
4550  */
4551 int
4552 nfsrv_dsgetsockmnt(struct vnode *vp, int lktype, char *buf, int *buflenp,
4553     int *mirrorcntp, NFSPROC_T *p, struct vnode **dvpp, fhandle_t *fhp,
4554     char *devid, char *fnamep, struct vnode **nvpp, struct nfsmount **newnmpp,
4555     struct nfsmount *curnmp, int *ippos, int *dsdirp)
4556 {
4557         struct vnode *dvp, *nvp, **tdvpp;
4558         struct mount *mp;
4559         struct nfsmount *nmp, *newnmp;
4560         struct sockaddr *sad;
4561         struct sockaddr_in *sin;
4562         struct nfsdevice *ds, *tds, *fndds;
4563         struct pnfsdsfile *pf;
4564         uint32_t dsdir;
4565         int error, fhiszero, fnd, gotone, i, mirrorcnt;
4566
4567         ASSERT_VOP_LOCKED(vp, "nfsrv_dsgetsockmnt vp");
4568         *mirrorcntp = 1;
4569         tdvpp = dvpp;
4570         if (nvpp != NULL)
4571                 *nvpp = NULL;
4572         if (dvpp != NULL)
4573                 *dvpp = NULL;
4574         if (ippos != NULL)
4575                 *ippos = -1;
4576         if (newnmpp != NULL)
4577                 newnmp = *newnmpp;
4578         else
4579                 newnmp = NULL;
4580         mp = vp->v_mount;
4581         error = vn_extattr_get(vp, IO_NODELOCKED, EXTATTR_NAMESPACE_SYSTEM,
4582             "pnfsd.dsfile", buflenp, buf, p);
4583         mirrorcnt = *buflenp / sizeof(*pf);
4584         if (error == 0 && (mirrorcnt < 1 || mirrorcnt > NFSDEV_MAXMIRRORS ||
4585             *buflenp != sizeof(*pf) * mirrorcnt))
4586                 error = ENOATTR;
4587
4588         pf = (struct pnfsdsfile *)buf;
4589         /* If curnmp != NULL, check for a match in the mirror list. */
4590         if (curnmp != NULL && error == 0) {
4591                 fnd = 0;
4592                 for (i = 0; i < mirrorcnt; i++, pf++) {
4593                         sad = (struct sockaddr *)&pf->dsf_sin;
4594                         if (nfsaddr2_match(sad, curnmp->nm_nam)) {
4595                                 if (ippos != NULL)
4596                                         *ippos = i;
4597                                 fnd = 1;
4598                                 break;
4599                         }
4600                 }
4601                 if (fnd == 0)
4602                         error = ENXIO;
4603         }
4604
4605         gotone = 0;
4606         pf = (struct pnfsdsfile *)buf;
4607         NFSD_DEBUG(4, "nfsrv_dsgetsockmnt: mirrorcnt=%d err=%d\n", mirrorcnt,
4608             error);
4609         for (i = 0; i < mirrorcnt && error == 0; i++, pf++) {
4610                 fhiszero = 0;
4611                 sad = (struct sockaddr *)&pf->dsf_sin;
4612                 sin = &pf->dsf_sin;
4613                 dsdir = pf->dsf_dir;
4614                 if (dsdir >= nfsrv_dsdirsize) {
4615                         printf("nfsrv_dsgetsockmnt: dsdir=%d\n", dsdir);
4616                         error = ENOATTR;
4617                 } else if (nvpp != NULL && newnmp != NULL &&
4618                     nfsaddr2_match(sad, newnmp->nm_nam))
4619                         error = EEXIST;
4620                 if (error == 0) {
4621                         if (ippos != NULL && curnmp == NULL &&
4622                             sad->sa_family == AF_INET &&
4623                             sin->sin_addr.s_addr == 0)
4624                                 *ippos = i;
4625                         if (NFSBCMP(&zerofh, &pf->dsf_fh, sizeof(zerofh)) == 0)
4626                                 fhiszero = 1;
4627                         /* Use the socket address to find the mount point. */
4628                         fndds = NULL;
4629                         NFSDDSLOCK();
4630                         /* Find a match for the IP address. */
4631                         TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
4632                                 if (ds->nfsdev_nmp != NULL) {
4633                                         dvp = ds->nfsdev_dvp;
4634                                         nmp = VFSTONFS(dvp->v_mount);
4635                                         if (nmp != ds->nfsdev_nmp)
4636                                                 printf("different2 nmp %p %p\n",
4637                                                     nmp, ds->nfsdev_nmp);
4638                                         if (nfsaddr2_match(sad, nmp->nm_nam)) {
4639                                                 fndds = ds;
4640                                                 break;
4641                                         }
4642                                 }
4643                         }
4644                         if (fndds != NULL && newnmpp != NULL &&
4645                             newnmp == NULL) {
4646                                 /* Search for a place to make a mirror copy. */
4647                                 TAILQ_FOREACH(tds, &nfsrv_devidhead,
4648                                     nfsdev_list) {
4649                                         if (tds->nfsdev_nmp != NULL &&
4650                                             fndds != tds &&
4651                                             ((tds->nfsdev_mdsisset == 0 &&
4652                                               fndds->nfsdev_mdsisset == 0) ||
4653                                              (tds->nfsdev_mdsisset != 0 &&
4654                                               fndds->nfsdev_mdsisset != 0 &&
4655                                               tds->nfsdev_mdsfsid.val[0] ==
4656                                               mp->mnt_stat.f_fsid.val[0] &&
4657                                               tds->nfsdev_mdsfsid.val[1] ==
4658                                               mp->mnt_stat.f_fsid.val[1]))) {
4659                                                 *newnmpp = tds->nfsdev_nmp;
4660                                                 break;
4661                                         }
4662                                 }
4663                                 if (tds != NULL) {
4664                                         /*
4665                                          * Move this entry to the end of the
4666                                          * list, so it won't be selected as
4667                                          * easily the next time.
4668                                          */
4669                                         TAILQ_REMOVE(&nfsrv_devidhead, tds,
4670                                             nfsdev_list);
4671                                         TAILQ_INSERT_TAIL(&nfsrv_devidhead, tds,
4672                                             nfsdev_list);
4673                                 }
4674                         }
4675                         NFSDDSUNLOCK();
4676                         if (fndds != NULL) {
4677                                 dvp = fndds->nfsdev_dsdir[dsdir];
4678                                 if (lktype != 0 || fhiszero != 0 ||
4679                                     (nvpp != NULL && *nvpp == NULL)) {
4680                                         if (fhiszero != 0)
4681                                                 error = vn_lock(dvp,
4682                                                     LK_EXCLUSIVE);
4683                                         else if (lktype != 0)
4684                                                 error = vn_lock(dvp, lktype);
4685                                         else
4686                                                 error = vn_lock(dvp, LK_SHARED);
4687                                         /*
4688                                          * If the file handle is all 0's, try to
4689                                          * do a Lookup against the DS to acquire
4690                                          * it.
4691                                          * If dvpp == NULL or the Lookup fails,
4692                                          * unlock dvp after the call.
4693                                          */
4694                                         if (error == 0 && (fhiszero != 0 ||
4695                                             (nvpp != NULL && *nvpp == NULL))) {
4696                                                 error = nfsrv_pnfslookupds(vp,
4697                                                     dvp, pf, &nvp, p);
4698                                                 if (error == 0) {
4699                                                         if (fhiszero != 0)
4700                                                                 nfsrv_pnfssetfh(
4701                                                                     vp, pf,
4702                                                                     devid,
4703                                                                     fnamep,
4704                                                                     nvp, p);
4705                                                         if (nvpp != NULL &&
4706                                                             *nvpp == NULL) {
4707                                                                 *nvpp = nvp;
4708                                                                 *dsdirp = dsdir;
4709                                                         } else
4710                                                                 vput(nvp);
4711                                                 }
4712                                                 if (error != 0 || lktype == 0)
4713                                                         NFSVOPUNLOCK(dvp, 0);
4714                                         }
4715                                 }
4716                                 if (error == 0) {
4717                                         gotone++;
4718                                         NFSD_DEBUG(4, "gotone=%d\n", gotone);
4719                                         if (devid != NULL) {
4720                                                 NFSBCOPY(fndds->nfsdev_deviceid,
4721                                                     devid, NFSX_V4DEVICEID);
4722                                                 devid += NFSX_V4DEVICEID;
4723                                         }
4724                                         if (dvpp != NULL)
4725                                                 *tdvpp++ = dvp;
4726                                         if (fhp != NULL)
4727                                                 NFSBCOPY(&pf->dsf_fh, fhp++,
4728                                                     NFSX_MYFH);
4729                                         if (fnamep != NULL && gotone == 1)
4730                                                 strlcpy(fnamep,
4731                                                     pf->dsf_filename,
4732                                                     sizeof(pf->dsf_filename));
4733                                 } else
4734                                         NFSD_DEBUG(4, "nfsrv_dsgetsockmnt "
4735                                             "err=%d\n", error);
4736                         }
4737                 }
4738         }
4739         if (error == 0 && gotone == 0)
4740                 error = ENOENT;
4741
4742         NFSD_DEBUG(4, "eo nfsrv_dsgetsockmnt: gotone=%d err=%d\n", gotone,
4743             error);
4744         if (error == 0)
4745                 *mirrorcntp = gotone;
4746         else {
4747                 if (gotone > 0 && dvpp != NULL) {
4748                         /*
4749                          * If the error didn't occur on the first one and
4750                          * dvpp != NULL, the one(s) prior to the failure will
4751                          * have locked dvp's that need to be unlocked.
4752                          */
4753                         for (i = 0; i < gotone; i++) {
4754                                 NFSVOPUNLOCK(*dvpp, 0);
4755                                 *dvpp++ = NULL;
4756                         }
4757                 }
4758                 /*
4759                  * If it found the vnode to be copied from before a failure,
4760                  * it needs to be vput()'d.
4761                  */
4762                 if (nvpp != NULL && *nvpp != NULL) {
4763                         vput(*nvpp);
4764                         *nvpp = NULL;
4765                 }
4766         }
4767         return (error);
4768 }
4769
4770 /*
4771  * Set the extended attribute for the Change attribute.
4772  */
4773 static int
4774 nfsrv_setextattr(struct vnode *vp, struct nfsvattr *nap, NFSPROC_T *p)
4775 {
4776         struct pnfsdsattr dsattr;
4777         int error;
4778
4779         ASSERT_VOP_ELOCKED(vp, "nfsrv_setextattr vp");
4780         dsattr.dsa_filerev = nap->na_filerev;
4781         dsattr.dsa_size = nap->na_size;
4782         dsattr.dsa_atime = nap->na_atime;
4783         dsattr.dsa_mtime = nap->na_mtime;
4784         error = vn_extattr_set(vp, IO_NODELOCKED, EXTATTR_NAMESPACE_SYSTEM,
4785             "pnfsd.dsattr", sizeof(dsattr), (char *)&dsattr, p);
4786         if (error != 0)
4787                 printf("pNFS: setextattr=%d\n", error);
4788         return (error);
4789 }
4790
4791 static int
4792 nfsrv_readdsrpc(fhandle_t *fhp, off_t off, int len, struct ucred *cred,
4793     NFSPROC_T *p, struct nfsmount *nmp, struct mbuf **mpp, struct mbuf **mpendp)
4794 {
4795         uint32_t *tl;
4796         struct nfsrv_descript *nd;
4797         nfsv4stateid_t st;
4798         struct mbuf *m, *m2;
4799         int error = 0, retlen, tlen, trimlen;
4800
4801         NFSD_DEBUG(4, "in nfsrv_readdsrpc\n");
4802         nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
4803         *mpp = NULL;
4804         /*
4805          * Use a stateid where other is an alternating 01010 pattern and
4806          * seqid is 0xffffffff.  This value is not defined as special by
4807          * the RFC and is used by the FreeBSD NFS server to indicate an
4808          * MDS->DS proxy operation.
4809          */
4810         st.other[0] = 0x55555555;
4811         st.other[1] = 0x55555555;
4812         st.other[2] = 0x55555555;
4813         st.seqid = 0xffffffff;
4814         nfscl_reqstart(nd, NFSPROC_READDS, nmp, (u_int8_t *)fhp, sizeof(*fhp),
4815             NULL, NULL, 0, 0);
4816         nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
4817         NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED * 3);
4818         txdr_hyper(off, tl);
4819         *(tl + 2) = txdr_unsigned(len);
4820         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4821             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4822         if (error != 0) {
4823                 free(nd, M_TEMP);
4824                 return (error);
4825         }
4826         if (nd->nd_repstat == 0) {
4827                 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
4828                 NFSM_STRSIZ(retlen, len);
4829                 if (retlen > 0) {
4830                         /* Trim off the pre-data XDR from the mbuf chain. */
4831                         m = nd->nd_mrep;
4832                         while (m != NULL && m != nd->nd_md) {
4833                                 if (m->m_next == nd->nd_md) {
4834                                         m->m_next = NULL;
4835                                         m_freem(nd->nd_mrep);
4836                                         nd->nd_mrep = m = nd->nd_md;
4837                                 } else
4838                                         m = m->m_next;
4839                         }
4840                         if (m == NULL) {
4841                                 printf("nfsrv_readdsrpc: busted mbuf list\n");
4842                                 error = ENOENT;
4843                                 goto nfsmout;
4844                         }
4845
4846                         /*
4847                          * Now, adjust first mbuf so that any XDR before the
4848                          * read data is skipped over.
4849                          */
4850                         trimlen = nd->nd_dpos - mtod(m, char *);
4851                         if (trimlen > 0) {
4852                                 m->m_len -= trimlen;
4853                                 NFSM_DATAP(m, trimlen);
4854                         }
4855
4856                         /*
4857                          * Truncate the mbuf chain at retlen bytes of data,
4858                          * plus XDR padding that brings the length up to a
4859                          * multiple of 4.
4860                          */
4861                         tlen = NFSM_RNDUP(retlen);
4862                         do {
4863                                 if (m->m_len >= tlen) {
4864                                         m->m_len = tlen;
4865                                         tlen = 0;
4866                                         m2 = m->m_next;
4867                                         m->m_next = NULL;
4868                                         m_freem(m2);
4869                                         break;
4870                                 }
4871                                 tlen -= m->m_len;
4872                                 m = m->m_next;
4873                         } while (m != NULL);
4874                         if (tlen > 0) {
4875                                 printf("nfsrv_readdsrpc: busted mbuf list\n");
4876                                 error = ENOENT;
4877                                 goto nfsmout;
4878                         }
4879                         *mpp = nd->nd_mrep;
4880                         *mpendp = m;
4881                         nd->nd_mrep = NULL;
4882                 }
4883         } else
4884                 error = nd->nd_repstat;
4885 nfsmout:
4886         /* If nd->nd_mrep is already NULL, this is a no-op. */
4887         m_freem(nd->nd_mrep);
4888         free(nd, M_TEMP);
4889         NFSD_DEBUG(4, "nfsrv_readdsrpc error=%d\n", error);
4890         return (error);
4891 }
4892
4893 /*
4894  * Do a write RPC on a DS data file, using this structure for the arguments,
4895  * so that this function can be executed by a separate kernel process.
4896  */
4897 struct nfsrvwritedsdorpc {
4898         int                     done;
4899         int                     inprog;
4900         struct task             tsk;
4901         fhandle_t               fh;
4902         off_t                   off;
4903         int                     len;
4904         struct nfsmount         *nmp;
4905         struct ucred            *cred;
4906         NFSPROC_T               *p;
4907         struct mbuf             *m;
4908         int                     err;
4909 };
4910
4911 static int
4912 nfsrv_writedsdorpc(struct nfsmount *nmp, fhandle_t *fhp, off_t off, int len,
4913     struct nfsvattr *nap, struct mbuf *m, struct ucred *cred, NFSPROC_T *p)
4914 {
4915         uint32_t *tl;
4916         struct nfsrv_descript *nd;
4917         nfsattrbit_t attrbits;
4918         nfsv4stateid_t st;
4919         int commit, error, retlen;
4920
4921         nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
4922         nfscl_reqstart(nd, NFSPROC_WRITE, nmp, (u_int8_t *)fhp,
4923             sizeof(fhandle_t), NULL, NULL, 0, 0);
4924
4925         /*
4926          * Use a stateid where other is an alternating 01010 pattern and
4927          * seqid is 0xffffffff.  This value is not defined as special by
4928          * the RFC and is used by the FreeBSD NFS server to indicate an
4929          * MDS->DS proxy operation.
4930          */
4931         st.other[0] = 0x55555555;
4932         st.other[1] = 0x55555555;
4933         st.other[2] = 0x55555555;
4934         st.seqid = 0xffffffff;
4935         nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
4936         NFSM_BUILD(tl, u_int32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
4937         txdr_hyper(off, tl);
4938         tl += 2;
4939         /*
4940          * Do all writes FileSync, since the server doesn't hold onto dirty
4941          * buffers.  Since clients should be accessing the DS servers directly
4942          * using the pNFS layouts, this just needs to work correctly as a
4943          * fallback.
4944          */
4945         *tl++ = txdr_unsigned(NFSWRITE_FILESYNC);
4946         *tl = txdr_unsigned(len);
4947         NFSD_DEBUG(4, "nfsrv_writedsdorpc: len=%d\n", len);
4948
4949         /* Put data in mbuf chain. */
4950         nd->nd_mb->m_next = m;
4951
4952         /* Set nd_mb and nd_bpos to end of data. */
4953         while (m->m_next != NULL)
4954                 m = m->m_next;
4955         nd->nd_mb = m;
4956         nd->nd_bpos = mtod(m, char *) + m->m_len;
4957         NFSD_DEBUG(4, "nfsrv_writedsdorpc: lastmb len=%d\n", m->m_len);
4958
4959         /* Do a Getattr for Size, Change and Modify Time. */
4960         NFSZERO_ATTRBIT(&attrbits);
4961         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);
4962         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
4963         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESS);
4964         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFY);
4965         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
4966         *tl = txdr_unsigned(NFSV4OP_GETATTR);
4967         (void) nfsrv_putattrbit(nd, &attrbits);
4968         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p,
4969             cred, NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4970         if (error != 0) {
4971                 free(nd, M_TEMP);
4972                 return (error);
4973         }
4974         NFSD_DEBUG(4, "nfsrv_writedsdorpc: aft writerpc=%d\n", nd->nd_repstat);
4975         /* Get rid of weak cache consistency data for now. */
4976         if ((nd->nd_flag & (ND_NOMOREDATA | ND_NFSV4 | ND_V4WCCATTR)) ==
4977             (ND_NFSV4 | ND_V4WCCATTR)) {
4978                 error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0, NULL, NULL,
4979                     NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL);
4980                 NFSD_DEBUG(4, "nfsrv_writedsdorpc: wcc attr=%d\n", error);
4981                 if (error != 0)
4982                         goto nfsmout;
4983                 /*
4984                  * Get rid of Op# and status for next op.
4985                  */
4986                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED);
4987                 if (*++tl != 0)
4988                         nd->nd_flag |= ND_NOMOREDATA;
4989         }
4990         if (nd->nd_repstat == 0) {
4991                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED + NFSX_VERF);
4992                 retlen = fxdr_unsigned(int, *tl++);
4993                 commit = fxdr_unsigned(int, *tl);
4994                 if (commit != NFSWRITE_FILESYNC)
4995                         error = NFSERR_IO;
4996                 NFSD_DEBUG(4, "nfsrv_writedsdorpc:retlen=%d commit=%d err=%d\n",
4997                     retlen, commit, error);
4998         } else
4999                 error = nd->nd_repstat;
5000         /* We have no use for the Write Verifier since we use FileSync. */
5001
5002         /*
5003          * Get the Change, Size, Access Time and Modify Time attributes and set
5004          * on the Metadata file, so its attributes will be what the file's
5005          * would be if it had been written.
5006          */
5007         if (error == 0) {
5008                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED);
5009                 error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0, NULL, NULL,
5010                     NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL);
5011         }
5012         NFSD_DEBUG(4, "nfsrv_writedsdorpc: aft loadattr=%d\n", error);
5013 nfsmout:
5014         m_freem(nd->nd_mrep);
5015         free(nd, M_TEMP);
5016         NFSD_DEBUG(4, "nfsrv_writedsdorpc error=%d\n", error);
5017         return (error);
5018 }
5019
5020 /*
5021  * Start up the thread that will execute nfsrv_writedsdorpc().
5022  */
5023 static void
5024 start_writedsdorpc(void *arg, int pending)
5025 {
5026         struct nfsrvwritedsdorpc *drpc;
5027
5028         drpc = (struct nfsrvwritedsdorpc *)arg;
5029         drpc->err = nfsrv_writedsdorpc(drpc->nmp, &drpc->fh, drpc->off,
5030             drpc->len, NULL, drpc->m, drpc->cred, drpc->p);
5031         drpc->done = 1;
5032         NFSD_DEBUG(4, "start_writedsdorpc: err=%d\n", drpc->err);
5033 }
5034
5035 static int
5036 nfsrv_writedsrpc(fhandle_t *fhp, off_t off, int len, struct ucred *cred,
5037     NFSPROC_T *p, struct vnode *vp, struct nfsmount **nmpp, int mirrorcnt,
5038     struct mbuf **mpp, char *cp, int *failposp)
5039 {
5040         struct nfsrvwritedsdorpc *drpc, *tdrpc;
5041         struct nfsvattr na;
5042         struct mbuf *m;
5043         int error, i, offs, ret, timo;
5044
5045         NFSD_DEBUG(4, "in nfsrv_writedsrpc\n");
5046         KASSERT(*mpp != NULL, ("nfsrv_writedsrpc: NULL mbuf chain"));
5047         drpc = NULL;
5048         if (mirrorcnt > 1)
5049                 tdrpc = drpc = malloc(sizeof(*drpc) * (mirrorcnt - 1), M_TEMP,
5050                     M_WAITOK);
5051
5052         /* Calculate offset in mbuf chain that data starts. */
5053         offs = cp - mtod(*mpp, char *);
5054         NFSD_DEBUG(4, "nfsrv_writedsrpc: mcopy offs=%d len=%d\n", offs, len);
5055
5056         /*
5057          * Do the write RPC for every DS, using a separate kernel process
5058          * for every DS except the last one.
5059          */
5060         error = 0;
5061         for (i = 0; i < mirrorcnt - 1; i++, tdrpc++) {
5062                 tdrpc->done = 0;
5063                 NFSBCOPY(fhp, &tdrpc->fh, sizeof(*fhp));
5064                 tdrpc->off = off;
5065                 tdrpc->len = len;
5066                 tdrpc->nmp = *nmpp;
5067                 tdrpc->cred = cred;
5068                 tdrpc->p = p;
5069                 tdrpc->inprog = 0;
5070                 tdrpc->err = 0;
5071                 tdrpc->m = m_copym(*mpp, offs, NFSM_RNDUP(len), M_WAITOK);
5072                 ret = EIO;
5073                 if (nfs_pnfsiothreads != 0) {
5074                         ret = nfs_pnfsio(start_writedsdorpc, tdrpc);
5075                         NFSD_DEBUG(4, "nfsrv_writedsrpc: nfs_pnfsio=%d\n",
5076                             ret);
5077                 }
5078                 if (ret != 0) {
5079                         ret = nfsrv_writedsdorpc(*nmpp, fhp, off, len, NULL,
5080                             tdrpc->m, cred, p);
5081                         if (nfsds_failerr(ret) && *failposp == -1)
5082                                 *failposp = i;
5083                         else if (error == 0 && ret != 0)
5084                                 error = ret;
5085                 }
5086                 nmpp++;
5087                 fhp++;
5088         }
5089         m = m_copym(*mpp, offs, NFSM_RNDUP(len), M_WAITOK);
5090         ret = nfsrv_writedsdorpc(*nmpp, fhp, off, len, &na, m, cred, p);
5091         if (nfsds_failerr(ret) && *failposp == -1 && mirrorcnt > 1)
5092                 *failposp = mirrorcnt - 1;
5093         else if (error == 0 && ret != 0)
5094                 error = ret;
5095         if (error == 0)
5096                 error = nfsrv_setextattr(vp, &na, p);
5097         NFSD_DEBUG(4, "nfsrv_writedsrpc: aft setextat=%d\n", error);
5098         tdrpc = drpc;
5099         timo = hz / 50;         /* Wait for 20msec. */
5100         if (timo < 1)
5101                 timo = 1;
5102         for (i = 0; i < mirrorcnt - 1; i++, tdrpc++) {
5103                 /* Wait for RPCs on separate threads to complete. */
5104                 while (tdrpc->inprog != 0 && tdrpc->done == 0)
5105                         tsleep(&tdrpc->tsk, PVFS, "srvwrds", timo);
5106                 if (nfsds_failerr(tdrpc->err) && *failposp == -1)
5107                         *failposp = i;
5108                 else if (error == 0 && tdrpc->err != 0)
5109                         error = tdrpc->err;
5110         }
5111         free(drpc, M_TEMP);
5112         return (error);
5113 }
5114
5115 static int
5116 nfsrv_setattrdsdorpc(fhandle_t *fhp, struct ucred *cred, NFSPROC_T *p,
5117     struct vnode *vp, struct nfsmount *nmp, struct nfsvattr *nap,
5118     struct nfsvattr *dsnap)
5119 {
5120         uint32_t *tl;
5121         struct nfsrv_descript *nd;
5122         nfsv4stateid_t st;
5123         nfsattrbit_t attrbits;
5124         int error;
5125
5126         NFSD_DEBUG(4, "in nfsrv_setattrdsdorpc\n");
5127         nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
5128         /*
5129          * Use a stateid where other is an alternating 01010 pattern and
5130          * seqid is 0xffffffff.  This value is not defined as special by
5131          * the RFC and is used by the FreeBSD NFS server to indicate an
5132          * MDS->DS proxy operation.
5133          */
5134         st.other[0] = 0x55555555;
5135         st.other[1] = 0x55555555;
5136         st.other[2] = 0x55555555;
5137         st.seqid = 0xffffffff;
5138         nfscl_reqstart(nd, NFSPROC_SETATTR, nmp, (u_int8_t *)fhp, sizeof(*fhp),
5139             NULL, NULL, 0, 0);
5140         nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5141         nfscl_fillsattr(nd, &nap->na_vattr, vp, NFSSATTR_FULL, 0);
5142
5143         /* Do a Getattr for Size, Change, Access Time and Modify Time. */
5144         NFSZERO_ATTRBIT(&attrbits);
5145         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);
5146         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
5147         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESS);
5148         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFY);
5149         NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
5150         *tl = txdr_unsigned(NFSV4OP_GETATTR);
5151         (void) nfsrv_putattrbit(nd, &attrbits);
5152         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5153             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5154         if (error != 0) {
5155                 free(nd, M_TEMP);
5156                 return (error);
5157         }
5158         NFSD_DEBUG(4, "nfsrv_setattrdsdorpc: aft setattrrpc=%d\n",
5159             nd->nd_repstat);
5160         /* Get rid of weak cache consistency data for now. */
5161         if ((nd->nd_flag & (ND_NOMOREDATA | ND_NFSV4 | ND_V4WCCATTR)) ==
5162             (ND_NFSV4 | ND_V4WCCATTR)) {
5163                 error = nfsv4_loadattr(nd, NULL, dsnap, NULL, NULL, 0, NULL,
5164                     NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL);
5165                 NFSD_DEBUG(4, "nfsrv_setattrdsdorpc: wcc attr=%d\n", error);
5166                 if (error != 0)
5167                         goto nfsmout;
5168                 /*
5169                  * Get rid of Op# and status for next op.
5170                  */
5171                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED);
5172                 if (*++tl != 0)
5173                         nd->nd_flag |= ND_NOMOREDATA;
5174         }
5175         error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
5176         if (error != 0)
5177                 goto nfsmout;
5178         if (nd->nd_repstat != 0)
5179                 error = nd->nd_repstat;
5180         /*
5181          * Get the Change, Size, Access Time and Modify Time attributes and set
5182          * on the Metadata file, so its attributes will be what the file's
5183          * would be if it had been written.
5184          */
5185         if (error == 0) {
5186                 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED);
5187                 error = nfsv4_loadattr(nd, NULL, dsnap, NULL, NULL, 0, NULL,
5188                     NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL);
5189         }
5190         NFSD_DEBUG(4, "nfsrv_setattrdsdorpc: aft setattr loadattr=%d\n", error);
5191 nfsmout:
5192         m_freem(nd->nd_mrep);
5193         free(nd, M_TEMP);
5194         NFSD_DEBUG(4, "nfsrv_setattrdsdorpc error=%d\n", error);
5195         return (error);
5196 }
5197
5198 struct nfsrvsetattrdsdorpc {
5199         int                     done;
5200         int                     inprog;
5201         struct task             tsk;
5202         fhandle_t               fh;
5203         struct nfsmount         *nmp;
5204         struct vnode            *vp;
5205         struct ucred            *cred;
5206         NFSPROC_T               *p;
5207         struct nfsvattr         na;
5208         struct nfsvattr         dsna;
5209         int                     err;
5210 };
5211
5212 /*
5213  * Start up the thread that will execute nfsrv_setattrdsdorpc().
5214  */
5215 static void
5216 start_setattrdsdorpc(void *arg, int pending)
5217 {
5218         struct nfsrvsetattrdsdorpc *drpc;
5219
5220         drpc = (struct nfsrvsetattrdsdorpc *)arg;
5221         drpc->err = nfsrv_setattrdsdorpc(&drpc->fh, drpc->cred, drpc->p,
5222             drpc->vp, drpc->nmp, &drpc->na, &drpc->dsna);
5223         drpc->done = 1;
5224 }
5225
5226 static int
5227 nfsrv_setattrdsrpc(fhandle_t *fhp, struct ucred *cred, NFSPROC_T *p,
5228     struct vnode *vp, struct nfsmount **nmpp, int mirrorcnt,
5229     struct nfsvattr *nap, int *failposp)
5230 {
5231         struct nfsrvsetattrdsdorpc *drpc, *tdrpc;
5232         struct nfsvattr na;
5233         int error, i, ret, timo;
5234
5235         NFSD_DEBUG(4, "in nfsrv_setattrdsrpc\n");
5236         drpc = NULL;
5237         if (mirrorcnt > 1)
5238                 tdrpc = drpc = malloc(sizeof(*drpc) * (mirrorcnt - 1), M_TEMP,
5239                     M_WAITOK);
5240
5241         /*
5242          * Do the setattr RPC for every DS, using a separate kernel process
5243          * for every DS except the last one.
5244          */
5245         error = 0;
5246         for (i = 0; i < mirrorcnt - 1; i++, tdrpc++) {
5247                 tdrpc->done = 0;
5248                 tdrpc->inprog = 0;
5249                 NFSBCOPY(fhp, &tdrpc->fh, sizeof(*fhp));
5250                 tdrpc->nmp = *nmpp;
5251                 tdrpc->vp = vp;
5252                 tdrpc->cred = cred;
5253                 tdrpc->p = p;
5254                 tdrpc->na = *nap;
5255                 tdrpc->err = 0;
5256                 ret = EIO;
5257                 if (nfs_pnfsiothreads != 0) {
5258                         ret = nfs_pnfsio(start_setattrdsdorpc, tdrpc);
5259                         NFSD_DEBUG(4, "nfsrv_setattrdsrpc: nfs_pnfsio=%d\n",
5260                             ret);
5261                 }
5262                 if (ret != 0) {
5263                         ret = nfsrv_setattrdsdorpc(fhp, cred, p, vp, *nmpp, nap,
5264                             &na);
5265                         if (nfsds_failerr(ret) && *failposp == -1)
5266                                 *failposp = i;
5267                         else if (error == 0 && ret != 0)
5268                                 error = ret;
5269                 }
5270                 nmpp++;
5271                 fhp++;
5272         }
5273         ret = nfsrv_setattrdsdorpc(fhp, cred, p, vp, *nmpp, nap, &na);
5274         if (nfsds_failerr(ret) && *failposp == -1 && mirrorcnt > 1)
5275                 *failposp = mirrorcnt - 1;
5276         else if (error == 0 && ret != 0)
5277                 error = ret;
5278         if (error == 0)
5279                 error = nfsrv_setextattr(vp, &na, p);
5280         NFSD_DEBUG(4, "nfsrv_setattrdsrpc: aft setextat=%d\n", error);
5281         tdrpc = drpc;
5282         timo = hz / 50;         /* Wait for 20msec. */
5283         if (timo < 1)
5284                 timo = 1;
5285         for (i = 0; i < mirrorcnt - 1; i++, tdrpc++) {
5286                 /* Wait for RPCs on separate threads to complete. */
5287                 while (tdrpc->inprog != 0 && tdrpc->done == 0)
5288                         tsleep(&tdrpc->tsk, PVFS, "srvsads", timo);
5289                 if (nfsds_failerr(tdrpc->err) && *failposp == -1)
5290                         *failposp = i;
5291                 else if (error == 0 && tdrpc->err != 0)
5292                         error = tdrpc->err;
5293         }
5294         free(drpc, M_TEMP);
5295         return (error);
5296 }
5297
5298 /*
5299  * Do a Setattr of an NFSv4 ACL on the DS file.
5300  */
5301 static int
5302 nfsrv_setacldsdorpc(fhandle_t *fhp, struct ucred *cred, NFSPROC_T *p,
5303     struct vnode *vp, struct nfsmount *nmp, struct acl *aclp)
5304 {
5305         struct nfsrv_descript *nd;
5306         nfsv4stateid_t st;
5307         nfsattrbit_t attrbits;
5308         int error;
5309
5310         NFSD_DEBUG(4, "in nfsrv_setacldsdorpc\n");
5311         nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
5312         /*
5313          * Use a stateid where other is an alternating 01010 pattern and
5314          * seqid is 0xffffffff.  This value is not defined as special by
5315          * the RFC and is used by the FreeBSD NFS server to indicate an
5316          * MDS->DS proxy operation.
5317          */
5318         st.other[0] = 0x55555555;
5319         st.other[1] = 0x55555555;
5320         st.other[2] = 0x55555555;
5321         st.seqid = 0xffffffff;
5322         nfscl_reqstart(nd, NFSPROC_SETACL, nmp, (u_int8_t *)fhp, sizeof(*fhp),
5323             NULL, NULL, 0, 0);
5324         nfsm_stateidtom(nd, &st, NFSSTATEID_PUTSTATEID);
5325         NFSZERO_ATTRBIT(&attrbits);
5326         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
5327         /*
5328          * The "vp" argument to nfsv4_fillattr() is only used for vnode_type(),
5329          * so passing in the metadata "vp" will be ok, since it is of
5330          * the same type (VREG).
5331          */
5332         nfsv4_fillattr(nd, NULL, vp, aclp, NULL, NULL, 0, &attrbits, NULL,
5333             NULL, 0, 0, 0, 0, 0, NULL);
5334         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5335             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5336         if (error != 0) {
5337                 free(nd, M_TEMP);
5338                 return (error);
5339         }
5340         NFSD_DEBUG(4, "nfsrv_setacldsdorpc: aft setaclrpc=%d\n",
5341             nd->nd_repstat);
5342         error = nd->nd_repstat;
5343         m_freem(nd->nd_mrep);
5344         free(nd, M_TEMP);
5345         return (error);
5346 }
5347
5348 struct nfsrvsetacldsdorpc {
5349         int                     done;
5350         int                     inprog;
5351         struct task             tsk;
5352         fhandle_t               fh;
5353         struct nfsmount         *nmp;
5354         struct vnode            *vp;
5355         struct ucred            *cred;
5356         NFSPROC_T               *p;
5357         struct acl              *aclp;
5358         int                     err;
5359 };
5360
5361 /*
5362  * Start up the thread that will execute nfsrv_setacldsdorpc().
5363  */
5364 static void
5365 start_setacldsdorpc(void *arg, int pending)
5366 {
5367         struct nfsrvsetacldsdorpc *drpc;
5368
5369         drpc = (struct nfsrvsetacldsdorpc *)arg;
5370         drpc->err = nfsrv_setacldsdorpc(&drpc->fh, drpc->cred, drpc->p,
5371             drpc->vp, drpc->nmp, drpc->aclp);
5372         drpc->done = 1;
5373 }
5374
5375 static int
5376 nfsrv_setacldsrpc(fhandle_t *fhp, struct ucred *cred, NFSPROC_T *p,
5377     struct vnode *vp, struct nfsmount **nmpp, int mirrorcnt, struct acl *aclp,
5378     int *failposp)
5379 {
5380         struct nfsrvsetacldsdorpc *drpc, *tdrpc;
5381         int error, i, ret, timo;
5382
5383         NFSD_DEBUG(4, "in nfsrv_setacldsrpc\n");
5384         drpc = NULL;
5385         if (mirrorcnt > 1)
5386                 tdrpc = drpc = malloc(sizeof(*drpc) * (mirrorcnt - 1), M_TEMP,
5387                     M_WAITOK);
5388
5389         /*
5390          * Do the setattr RPC for every DS, using a separate kernel process
5391          * for every DS except the last one.
5392          */
5393         error = 0;
5394         for (i = 0; i < mirrorcnt - 1; i++, tdrpc++) {
5395                 tdrpc->done = 0;
5396                 tdrpc->inprog = 0;
5397                 NFSBCOPY(fhp, &tdrpc->fh, sizeof(*fhp));
5398                 tdrpc->nmp = *nmpp;
5399                 tdrpc->vp = vp;
5400                 tdrpc->cred = cred;
5401                 tdrpc->p = p;
5402                 tdrpc->aclp = aclp;
5403                 tdrpc->err = 0;
5404                 ret = EIO;
5405                 if (nfs_pnfsiothreads != 0) {
5406                         ret = nfs_pnfsio(start_setacldsdorpc, tdrpc);
5407                         NFSD_DEBUG(4, "nfsrv_setacldsrpc: nfs_pnfsio=%d\n",
5408                             ret);
5409                 }
5410                 if (ret != 0) {
5411                         ret = nfsrv_setacldsdorpc(fhp, cred, p, vp, *nmpp,
5412                             aclp);
5413                         if (nfsds_failerr(ret) && *failposp == -1)
5414                                 *failposp = i;
5415                         else if (error == 0 && ret != 0)
5416                                 error = ret;
5417                 }
5418                 nmpp++;
5419                 fhp++;
5420         }
5421         ret = nfsrv_setacldsdorpc(fhp, cred, p, vp, *nmpp, aclp);
5422         if (nfsds_failerr(ret) && *failposp == -1 && mirrorcnt > 1)
5423                 *failposp = mirrorcnt - 1;
5424         else if (error == 0 && ret != 0)
5425                 error = ret;
5426         NFSD_DEBUG(4, "nfsrv_setacldsrpc: aft setextat=%d\n", error);
5427         tdrpc = drpc;
5428         timo = hz / 50;         /* Wait for 20msec. */
5429         if (timo < 1)
5430                 timo = 1;
5431         for (i = 0; i < mirrorcnt - 1; i++, tdrpc++) {
5432                 /* Wait for RPCs on separate threads to complete. */
5433                 while (tdrpc->inprog != 0 && tdrpc->done == 0)
5434                         tsleep(&tdrpc->tsk, PVFS, "srvacds", timo);
5435                 if (nfsds_failerr(tdrpc->err) && *failposp == -1)
5436                         *failposp = i;
5437                 else if (error == 0 && tdrpc->err != 0)
5438                         error = tdrpc->err;
5439         }
5440         free(drpc, M_TEMP);
5441         return (error);
5442 }
5443
5444 /*
5445  * Getattr call to the DS for the Modify, Size and Change attributes.
5446  */
5447 static int
5448 nfsrv_getattrdsrpc(fhandle_t *fhp, struct ucred *cred, NFSPROC_T *p,
5449     struct vnode *vp, struct nfsmount *nmp, struct nfsvattr *nap)
5450 {
5451         struct nfsrv_descript *nd;
5452         int error;
5453         nfsattrbit_t attrbits;
5454
5455         NFSD_DEBUG(4, "in nfsrv_getattrdsrpc\n");
5456         nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
5457         nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, (u_int8_t *)fhp,
5458             sizeof(fhandle_t), NULL, NULL, 0, 0);
5459         NFSZERO_ATTRBIT(&attrbits);
5460         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_SIZE);
5461         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
5462         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEACCESS);
5463         NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFY);
5464         (void) nfsrv_putattrbit(nd, &attrbits);
5465         error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5466             NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5467         if (error != 0) {
5468                 free(nd, M_TEMP);
5469                 return (error);
5470         }
5471         NFSD_DEBUG(4, "nfsrv_getattrdsrpc: aft getattrrpc=%d\n",
5472             nd->nd_repstat);
5473         if (nd->nd_repstat == 0) {
5474                 error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
5475                     NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL,
5476                     NULL, NULL);
5477                 /*
5478                  * We can only save the updated values in the extended
5479                  * attribute if the vp is exclusively locked.
5480                  * This should happen when any of the following operations
5481                  * occur on the vnode:
5482                  *    Close, Delegreturn, LayoutCommit, LayoutReturn
5483                  * As such, the updated extended attribute should get saved
5484                  * before nfsrv_checkdsattr() returns 0 and allows the cached
5485                  * attributes to be returned without calling this function.
5486                  */
5487                 if (error == 0 && VOP_ISLOCKED(vp) == LK_EXCLUSIVE) {
5488                         error = nfsrv_setextattr(vp, nap, p);
5489                         NFSD_DEBUG(4, "nfsrv_getattrdsrpc: aft setextat=%d\n",
5490                             error);
5491                 }
5492         } else
5493                 error = nd->nd_repstat;
5494         m_freem(nd->nd_mrep);
5495         free(nd, M_TEMP);
5496         NFSD_DEBUG(4, "nfsrv_getattrdsrpc error=%d\n", error);
5497         return (error);
5498 }
5499
5500 /*
5501  * Get the device id and file handle for a DS file.
5502  */
5503 int
5504 nfsrv_dsgetdevandfh(struct vnode *vp, NFSPROC_T *p, int *mirrorcntp,
5505     fhandle_t *fhp, char *devid)
5506 {
5507         int buflen, error;
5508         char *buf;
5509
5510         buflen = 1024;
5511         buf = malloc(buflen, M_TEMP, M_WAITOK);
5512         error = nfsrv_dsgetsockmnt(vp, 0, buf, &buflen, mirrorcntp, p, NULL,
5513             fhp, devid, NULL, NULL, NULL, NULL, NULL, NULL);
5514         free(buf, M_TEMP);
5515         return (error);
5516 }
5517
5518 /*
5519  * Do a Lookup against the DS for the filename.
5520  */
5521 static int
5522 nfsrv_pnfslookupds(struct vnode *vp, struct vnode *dvp, struct pnfsdsfile *pf,
5523     struct vnode **nvpp, NFSPROC_T *p)
5524 {
5525         struct nameidata named;
5526         struct ucred *tcred;
5527         char *bufp;
5528         u_long *hashp;
5529         struct vnode *nvp;
5530         int error;
5531
5532         tcred = newnfs_getcred();
5533         named.ni_cnd.cn_nameiop = LOOKUP;
5534         named.ni_cnd.cn_lkflags = LK_SHARED | LK_RETRY;
5535         named.ni_cnd.cn_cred = tcred;
5536         named.ni_cnd.cn_thread = p;
5537         named.ni_cnd.cn_flags = ISLASTCN | LOCKPARENT | LOCKLEAF | SAVENAME;
5538         nfsvno_setpathbuf(&named, &bufp, &hashp);
5539         named.ni_cnd.cn_nameptr = bufp;
5540         named.ni_cnd.cn_namelen = strlen(pf->dsf_filename);
5541         strlcpy(bufp, pf->dsf_filename, NAME_MAX);
5542         NFSD_DEBUG(4, "nfsrv_pnfslookupds: filename=%s\n", bufp);
5543         error = VOP_LOOKUP(dvp, &nvp, &named.ni_cnd);
5544         NFSD_DEBUG(4, "nfsrv_pnfslookupds: aft LOOKUP=%d\n", error);
5545         NFSFREECRED(tcred);
5546         nfsvno_relpathbuf(&named);
5547         if (error == 0)
5548                 *nvpp = nvp;
5549         NFSD_DEBUG(4, "eo nfsrv_pnfslookupds=%d\n", error);
5550         return (error);
5551 }
5552
5553 /*
5554  * Set the file handle to the correct one.
5555  */
5556 static void
5557 nfsrv_pnfssetfh(struct vnode *vp, struct pnfsdsfile *pf, char *devid,
5558     char *fnamep, struct vnode *nvp, NFSPROC_T *p)
5559 {
5560         struct nfsnode *np;
5561         int ret;
5562
5563         np = VTONFS(nvp);
5564         NFSBCOPY(np->n_fhp->nfh_fh, &pf->dsf_fh, NFSX_MYFH);
5565         /*
5566          * We can only do a vn_set_extattr() if the vnode is exclusively
5567          * locked and vn_start_write() has been done.  If devid != NULL or
5568          * fnamep != NULL or the vnode is shared locked, vn_start_write()
5569          * may not have been done.
5570          * If not done now, it will be done on a future call.
5571          */
5572         if (devid == NULL && fnamep == NULL && NFSVOPISLOCKED(vp) ==
5573             LK_EXCLUSIVE)
5574                 ret = vn_extattr_set(vp, IO_NODELOCKED,
5575                     EXTATTR_NAMESPACE_SYSTEM, "pnfsd.dsfile", sizeof(*pf),
5576                     (char *)pf, p);
5577         NFSD_DEBUG(4, "eo nfsrv_pnfssetfh=%d\n", ret);
5578 }
5579
5580 /*
5581  * Cause RPCs waiting on "nmp" to fail.  This is called for a DS mount point
5582  * when the DS has failed.
5583  */
5584 void
5585 nfsrv_killrpcs(struct nfsmount *nmp)
5586 {
5587
5588         /*
5589          * Call newnfs_nmcancelreqs() to cause
5590          * any RPCs in progress on the mount point to
5591          * fail.
5592          * This will cause any process waiting for an
5593          * RPC to complete while holding a vnode lock
5594          * on the mounted-on vnode (such as "df" or
5595          * a non-forced "umount") to fail.
5596          * This will unlock the mounted-on vnode so
5597          * a forced dismount can succeed.
5598          * The NFSMNTP_CANCELRPCS flag should be set when this function is
5599          * called.
5600          */
5601         newnfs_nmcancelreqs(nmp);
5602 }
5603
5604 /*
5605  * Sum up the statfs info for each of the DSs, so that the client will
5606  * receive the total for all DSs.
5607  */
5608 static int
5609 nfsrv_pnfsstatfs(struct statfs *sf, struct mount *mp)
5610 {
5611         struct statfs *tsf;
5612         struct nfsdevice *ds;
5613         struct vnode **dvpp, **tdvpp, *dvp;
5614         uint64_t tot;
5615         int cnt, error = 0, i;
5616
5617         if (nfsrv_devidcnt <= 0)
5618                 return (ENXIO);
5619         dvpp = mallocarray(nfsrv_devidcnt, sizeof(*dvpp), M_TEMP, M_WAITOK);
5620         tsf = malloc(sizeof(*tsf), M_TEMP, M_WAITOK);
5621
5622         /* Get an array of the dvps for the DSs. */
5623         tdvpp = dvpp;
5624         i = 0;
5625         NFSDDSLOCK();
5626         /* First, search for matches for same file system. */
5627         TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
5628                 if (ds->nfsdev_nmp != NULL && ds->nfsdev_mdsisset != 0 &&
5629                     ds->nfsdev_mdsfsid.val[0] == mp->mnt_stat.f_fsid.val[0] &&
5630                     ds->nfsdev_mdsfsid.val[1] == mp->mnt_stat.f_fsid.val[1]) {
5631                         if (++i > nfsrv_devidcnt)
5632                                 break;
5633                         *tdvpp++ = ds->nfsdev_dvp;
5634                 }
5635         }
5636         /*
5637          * If no matches for same file system, total all servers not assigned
5638          * to a file system.
5639          */
5640         if (i == 0) {
5641                 TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
5642                         if (ds->nfsdev_nmp != NULL &&
5643                             ds->nfsdev_mdsisset == 0) {
5644                                 if (++i > nfsrv_devidcnt)
5645                                         break;
5646                                 *tdvpp++ = ds->nfsdev_dvp;
5647                         }
5648                 }
5649         }
5650         NFSDDSUNLOCK();
5651         cnt = i;
5652
5653         /* Do a VFS_STATFS() for each of the DSs and sum them up. */
5654         tdvpp = dvpp;
5655         for (i = 0; i < cnt && error == 0; i++) {
5656                 dvp = *tdvpp++;
5657                 error = VFS_STATFS(dvp->v_mount, tsf);
5658                 if (error == 0) {
5659                         if (sf->f_bsize == 0) {
5660                                 if (tsf->f_bsize > 0)
5661                                         sf->f_bsize = tsf->f_bsize;
5662                                 else
5663                                         sf->f_bsize = 8192;
5664                         }
5665                         if (tsf->f_blocks > 0) {
5666                                 if (sf->f_bsize != tsf->f_bsize) {
5667                                         tot = tsf->f_blocks * tsf->f_bsize;
5668                                         sf->f_blocks += (tot / sf->f_bsize);
5669                                 } else
5670                                         sf->f_blocks += tsf->f_blocks;
5671                         }
5672                         if (tsf->f_bfree > 0) {
5673                                 if (sf->f_bsize != tsf->f_bsize) {
5674                                         tot = tsf->f_bfree * tsf->f_bsize;
5675                                         sf->f_bfree += (tot / sf->f_bsize);
5676                                 } else
5677                                         sf->f_bfree += tsf->f_bfree;
5678                         }
5679                         if (tsf->f_bavail > 0) {
5680                                 if (sf->f_bsize != tsf->f_bsize) {
5681                                         tot = tsf->f_bavail * tsf->f_bsize;
5682                                         sf->f_bavail += (tot / sf->f_bsize);
5683                                 } else
5684                                         sf->f_bavail += tsf->f_bavail;
5685                         }
5686                 }
5687         }
5688         free(tsf, M_TEMP);
5689         free(dvpp, M_TEMP);
5690         return (error);
5691 }
5692
5693 /*
5694  * Set an NFSv4 acl.
5695  */
5696 int
5697 nfsrv_setacl(struct vnode *vp, NFSACL_T *aclp, struct ucred *cred, NFSPROC_T *p)
5698 {
5699         int error;
5700
5701         if (nfsrv_useacl == 0 || nfs_supportsnfsv4acls(vp) == 0) {
5702                 error = NFSERR_ATTRNOTSUPP;
5703                 goto out;
5704         }
5705         /*
5706          * With NFSv4 ACLs, chmod(2) may need to add additional entries.
5707          * Make sure it has enough room for that - splitting every entry
5708          * into two and appending "canonical six" entries at the end.
5709          * Cribbed out of kern/vfs_acl.c - Rick M.
5710          */
5711         if (aclp->acl_cnt > (ACL_MAX_ENTRIES - 6) / 2) {
5712                 error = NFSERR_ATTRNOTSUPP;
5713                 goto out;
5714         }
5715         error = VOP_SETACL(vp, ACL_TYPE_NFS4, aclp, cred, p);
5716         if (error == 0) {
5717                 error = nfsrv_dssetacl(vp, aclp, cred, p);
5718                 if (error == ENOENT)
5719                         error = 0;
5720         }
5721
5722 out:
5723         NFSEXITCODE(error);
5724         return (error);
5725 }
5726
5727 extern int (*nfsd_call_nfsd)(struct thread *, struct nfssvc_args *);
5728
5729 /*
5730  * Called once to initialize data structures...
5731  */
5732 static int
5733 nfsd_modevent(module_t mod, int type, void *data)
5734 {
5735         int error = 0, i;
5736         static int loaded = 0;
5737
5738         switch (type) {
5739         case MOD_LOAD:
5740                 if (loaded)
5741                         goto out;
5742                 newnfs_portinit();
5743                 for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
5744                         mtx_init(&nfsrchash_table[i].mtx, "nfsrtc", NULL,
5745                             MTX_DEF);
5746                         mtx_init(&nfsrcahash_table[i].mtx, "nfsrtca", NULL,
5747                             MTX_DEF);
5748                 }
5749                 mtx_init(&nfsrc_udpmtx, "nfsuc", NULL, MTX_DEF);
5750                 mtx_init(&nfs_v4root_mutex, "nfs4rt", NULL, MTX_DEF);
5751                 mtx_init(&nfsv4root_mnt.mnt_mtx, "nfs4mnt", NULL, MTX_DEF);
5752                 mtx_init(&nfsrv_dontlistlock_mtx, "nfs4dnl", NULL, MTX_DEF);
5753                 mtx_init(&nfsrv_recalllock_mtx, "nfs4rec", NULL, MTX_DEF);
5754                 lockinit(&nfsv4root_mnt.mnt_explock, PVFS, "explock", 0, 0);
5755                 nfsrvd_initcache();
5756                 nfsd_init();
5757                 NFSD_LOCK();
5758                 nfsrvd_init(0);
5759                 NFSD_UNLOCK();
5760                 nfsd_mntinit();
5761 #ifdef VV_DISABLEDELEG
5762                 vn_deleg_ops.vndeleg_recall = nfsd_recalldelegation;
5763                 vn_deleg_ops.vndeleg_disable = nfsd_disabledelegation;
5764 #endif
5765                 nfsd_call_servertimer = nfsrv_servertimer;
5766                 nfsd_call_nfsd = nfssvc_nfsd;
5767                 loaded = 1;
5768                 break;
5769
5770         case MOD_UNLOAD:
5771                 if (newnfs_numnfsd != 0) {
5772                         error = EBUSY;
5773                         break;
5774                 }
5775
5776 #ifdef VV_DISABLEDELEG
5777                 vn_deleg_ops.vndeleg_recall = NULL;
5778                 vn_deleg_ops.vndeleg_disable = NULL;
5779 #endif
5780                 nfsd_call_servertimer = NULL;
5781                 nfsd_call_nfsd = NULL;
5782
5783                 /* Clean out all NFSv4 state. */
5784                 nfsrv_throwawayallstate(curthread);
5785
5786                 /* Clean the NFS server reply cache */
5787                 nfsrvd_cleancache();
5788
5789                 /* Free up the krpc server pool. */
5790                 if (nfsrvd_pool != NULL)
5791                         svcpool_destroy(nfsrvd_pool);
5792
5793                 /* and get rid of the locks */
5794                 for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
5795                         mtx_destroy(&nfsrchash_table[i].mtx);
5796                         mtx_destroy(&nfsrcahash_table[i].mtx);
5797                 }
5798                 mtx_destroy(&nfsrc_udpmtx);
5799                 mtx_destroy(&nfs_v4root_mutex);
5800                 mtx_destroy(&nfsv4root_mnt.mnt_mtx);
5801                 mtx_destroy(&nfsrv_dontlistlock_mtx);
5802                 mtx_destroy(&nfsrv_recalllock_mtx);
5803                 for (i = 0; i < nfsrv_sessionhashsize; i++)
5804                         mtx_destroy(&nfssessionhash[i].mtx);
5805                 if (nfslayouthash != NULL) {
5806                         for (i = 0; i < nfsrv_layouthashsize; i++)
5807                                 mtx_destroy(&nfslayouthash[i].mtx);
5808                         free(nfslayouthash, M_NFSDSESSION);
5809                 }
5810                 lockdestroy(&nfsv4root_mnt.mnt_explock);
5811                 free(nfsclienthash, M_NFSDCLIENT);
5812                 free(nfslockhash, M_NFSDLOCKFILE);
5813                 free(nfssessionhash, M_NFSDSESSION);
5814                 loaded = 0;
5815                 break;
5816         default:
5817                 error = EOPNOTSUPP;
5818                 break;
5819         }
5820
5821 out:
5822         NFSEXITCODE(error);
5823         return (error);
5824 }
5825 static moduledata_t nfsd_mod = {
5826         "nfsd",
5827         nfsd_modevent,
5828         NULL,
5829 };
5830 DECLARE_MODULE(nfsd, nfsd_mod, SI_SUB_VFS, SI_ORDER_ANY);
5831
5832 /* So that loader and kldload(2) can find us, wherever we are.. */
5833 MODULE_VERSION(nfsd, 1);
5834 MODULE_DEPEND(nfsd, nfscommon, 1, 1, 1);
5835 MODULE_DEPEND(nfsd, nfslock, 1, 1, 1);
5836 MODULE_DEPEND(nfsd, nfslockd, 1, 1, 1);
5837 MODULE_DEPEND(nfsd, krpc, 1, 1, 1);
5838 MODULE_DEPEND(nfsd, nfssvc, 1, 1, 1);
5839