sys/fs/nfsserver/nfs_nfsdstate.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2009 Rick Macklem, University of Guelph
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include "opt_inet.h"
  34 #include "opt_inet6.h"
  35 #include <sys/extattr.h>
  36 #include <fs/nfs/nfsport.h>
  37
  38 struct nfsrv_stablefirst nfsrv_stablefirst;
  39 int nfsrv_issuedelegs = 0;
  40 int nfsrv_dolocallocks = 0;
  41 struct nfsv4lock nfsv4rootfs_lock;
  42 time_t nfsdev_time = 0;
  43 int nfsrv_layouthashsize;
  44 volatile int nfsrv_layoutcnt = 0;
  45
  46 extern int newnfs_numnfsd;
  47 extern struct nfsstatsv1 nfsstatsv1;
  48 extern int nfsrv_lease;
  49 extern struct timeval nfsboottime;
  50 extern u_int32_t newnfs_true, newnfs_false;
  51 extern struct mtx nfsrv_dslock_mtx;
  52 extern struct mtx nfsrv_recalllock_mtx;
  53 extern struct mtx nfsrv_dontlistlock_mtx;
  54 extern int nfsd_debuglevel;
  55 extern u_int nfsrv_dsdirsize;
  56 extern struct nfsdevicehead nfsrv_devidhead;
  57 extern int nfsrv_doflexfile;
  58 extern int nfsrv_maxpnfsmirror;
  59 NFSV4ROOTLOCKMUTEX;
  60 NFSSTATESPINLOCK;
  61 extern struct nfsdontlisthead nfsrv_dontlisthead;
  62 extern volatile int nfsrv_devidcnt;
  63 extern struct nfslayouthead nfsrv_recalllisthead;
  64 extern char *nfsrv_zeropnfsdat;
  65
  66 SYSCTL_DECL(_vfs_nfsd);
  67 int     nfsrv_statehashsize = NFSSTATEHASHSIZE;
  68 SYSCTL_INT(_vfs_nfsd, OID_AUTO, statehashsize, CTLFLAG_RDTUN,
  69     &nfsrv_statehashsize, 0,
  70     "Size of state hash table set via loader.conf");
  71
  72 int     nfsrv_clienthashsize = NFSCLIENTHASHSIZE;
  73 SYSCTL_INT(_vfs_nfsd, OID_AUTO, clienthashsize, CTLFLAG_RDTUN,
  74     &nfsrv_clienthashsize, 0,
  75     "Size of client hash table set via loader.conf");
  76
  77 int     nfsrv_lockhashsize = NFSLOCKHASHSIZE;
  78 SYSCTL_INT(_vfs_nfsd, OID_AUTO, fhhashsize, CTLFLAG_RDTUN,
  79     &nfsrv_lockhashsize, 0,
  80     "Size of file handle hash table set via loader.conf");
  81
  82 int     nfsrv_sessionhashsize = NFSSESSIONHASHSIZE;
  83 SYSCTL_INT(_vfs_nfsd, OID_AUTO, sessionhashsize, CTLFLAG_RDTUN,
  84     &nfsrv_sessionhashsize, 0,
  85     "Size of session hash table set via loader.conf");
  86
  87 int     nfsrv_layouthighwater = NFSLAYOUTHIGHWATER;
  88 SYSCTL_INT(_vfs_nfsd, OID_AUTO, layouthighwater, CTLFLAG_RDTUN,
  89     &nfsrv_layouthighwater, 0,
  90     "High water mark for number of layouts set via loader.conf");
  91
  92 static int      nfsrv_v4statelimit = NFSRV_V4STATELIMIT;
  93 SYSCTL_INT(_vfs_nfsd, OID_AUTO, v4statelimit, CTLFLAG_RWTUN,
  94     &nfsrv_v4statelimit, 0,
  95     "High water limit for NFSv4 opens+locks+delegations");
  96
  97 static int      nfsrv_writedelegifpos = 0;
  98 SYSCTL_INT(_vfs_nfsd, OID_AUTO, writedelegifpos, CTLFLAG_RW,
  99     &nfsrv_writedelegifpos, 0,
 100     "Issue a write delegation for read opens if possible");
 101
 102 static int      nfsrv_allowreadforwriteopen = 1;
 103 SYSCTL_INT(_vfs_nfsd, OID_AUTO, allowreadforwriteopen, CTLFLAG_RW,
 104     &nfsrv_allowreadforwriteopen, 0,
 105     "Allow Reads to be done with Write Access StateIDs");
 106
 107 int     nfsrv_pnfsatime = 0;
 108 SYSCTL_INT(_vfs_nfsd, OID_AUTO, pnfsstrictatime, CTLFLAG_RW,
 109     &nfsrv_pnfsatime, 0,
 110     "For pNFS service, do Getattr ops to keep atime up-to-date");
 111
 112 int     nfsrv_flexlinuxhack = 0;
 113 SYSCTL_INT(_vfs_nfsd, OID_AUTO, flexlinuxhack, CTLFLAG_RW,
 114     &nfsrv_flexlinuxhack, 0,
 115     "For Linux clients, hack around Flex File Layout bug");
 116
 117 /*
 118  * Hash lists for nfs V4.
 119  */
 120 struct nfsclienthashhead        *nfsclienthash;
 121 struct nfslockhashhead          *nfslockhash;
 122 struct nfssessionhash           *nfssessionhash;
 123 struct nfslayouthash            *nfslayouthash;
 124 volatile int nfsrv_dontlistlen = 0;
 125
 126 static u_int32_t nfsrv_openpluslock = 0, nfsrv_delegatecnt = 0;
 127 static time_t nfsrvboottime;
 128 static int nfsrv_returnoldstateid = 0, nfsrv_clients = 0;
 129 static int nfsrv_clienthighwater = NFSRV_CLIENTHIGHWATER;
 130 static int nfsrv_nogsscallback = 0;
 131 static volatile int nfsrv_writedelegcnt = 0;
 132 static int nfsrv_faildscnt;
 133
 134 /* local functions */
 135 static void nfsrv_dumpaclient(struct nfsclient *clp,
 136     struct nfsd_dumpclients *dumpp);
 137 static void nfsrv_freeopenowner(struct nfsstate *stp, int cansleep,
 138     NFSPROC_T *p);
 139 static int nfsrv_freeopen(struct nfsstate *stp, vnode_t vp, int cansleep,
 140     NFSPROC_T *p);
 141 static void nfsrv_freelockowner(struct nfsstate *stp, vnode_t vp, int cansleep,
 142     NFSPROC_T *p);
 143 static void nfsrv_freeallnfslocks(struct nfsstate *stp, vnode_t vp,
 144     int cansleep, NFSPROC_T *p);
 145 static void nfsrv_freenfslock(struct nfslock *lop);
 146 static void nfsrv_freenfslockfile(struct nfslockfile *lfp);
 147 static void nfsrv_freedeleg(struct nfsstate *);
 148 static int nfsrv_getstate(struct nfsclient *clp, nfsv4stateid_t *stateidp,
 149     u_int32_t flags, struct nfsstate **stpp);
 150 static void nfsrv_getowner(struct nfsstatehead *hp, struct nfsstate *new_stp,
 151     struct nfsstate **stpp);
 152 static int nfsrv_getlockfh(vnode_t vp, u_short flags,
 153     struct nfslockfile *new_lfp, fhandle_t *nfhp, NFSPROC_T *p);
 154 static int nfsrv_getlockfile(u_short flags, struct nfslockfile **new_lfpp,
 155     struct nfslockfile **lfpp, fhandle_t *nfhp, int lockit);
 156 static void nfsrv_insertlock(struct nfslock *new_lop,
 157     struct nfslock *insert_lop, struct nfsstate *stp, struct nfslockfile *lfp);
 158 static void nfsrv_updatelock(struct nfsstate *stp, struct nfslock **new_lopp,
 159     struct nfslock **other_lopp, struct nfslockfile *lfp);
 160 static int nfsrv_getipnumber(u_char *cp);
 161 static int nfsrv_checkrestart(nfsquad_t clientid, u_int32_t flags,
 162     nfsv4stateid_t *stateidp, int specialid);
 163 static int nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
 164     u_int32_t flags);
 165 static int nfsrv_docallback(struct nfsclient *clp, int procnum,
 166     nfsv4stateid_t *stateidp, int trunc, fhandle_t *fhp,
 167     struct nfsvattr *nap, nfsattrbit_t *attrbitp, int laytype, NFSPROC_T *p);
 168 static int nfsrv_cbcallargs(struct nfsrv_descript *nd, struct nfsclient *clp,
 169     uint32_t callback, int op, const char *optag, struct nfsdsession **sepp);
 170 static u_int32_t nfsrv_nextclientindex(void);
 171 static u_int32_t nfsrv_nextstateindex(struct nfsclient *clp);
 172 static void nfsrv_markstable(struct nfsclient *clp);
 173 static void nfsrv_markreclaim(struct nfsclient *clp);
 174 static int nfsrv_checkstable(struct nfsclient *clp);
 175 static int nfsrv_clientconflict(struct nfsclient *clp, int *haslockp, struct
 176     vnode *vp, NFSPROC_T *p);
 177 static int nfsrv_delegconflict(struct nfsstate *stp, int *haslockp,
 178     NFSPROC_T *p, vnode_t vp);
 179 static int nfsrv_cleandeleg(vnode_t vp, struct nfslockfile *lfp,
 180     struct nfsclient *clp, int *haslockp, NFSPROC_T *p);
 181 static int nfsrv_notsamecredname(struct nfsrv_descript *nd,
 182     struct nfsclient *clp);
 183 static time_t nfsrv_leaseexpiry(void);
 184 static void nfsrv_delaydelegtimeout(struct nfsstate *stp);
 185 static int nfsrv_checkseqid(struct nfsrv_descript *nd, u_int32_t seqid,
 186     struct nfsstate *stp, struct nfsrvcache *op);
 187 static int nfsrv_nootherstate(struct nfsstate *stp);
 188 static int nfsrv_locallock(vnode_t vp, struct nfslockfile *lfp, int flags,
 189     uint64_t first, uint64_t end, struct nfslockconflict *cfp, NFSPROC_T *p);
 190 static void nfsrv_localunlock(vnode_t vp, struct nfslockfile *lfp,
 191     uint64_t init_first, uint64_t init_end, NFSPROC_T *p);
 192 static int nfsrv_dolocal(vnode_t vp, struct nfslockfile *lfp, int flags,
 193     int oldflags, uint64_t first, uint64_t end, struct nfslockconflict *cfp,
 194     NFSPROC_T *p);
 195 static void nfsrv_locallock_rollback(vnode_t vp, struct nfslockfile *lfp,
 196     NFSPROC_T *p);
 197 static void nfsrv_locallock_commit(struct nfslockfile *lfp, int flags,
 198     uint64_t first, uint64_t end);
 199 static void nfsrv_locklf(struct nfslockfile *lfp);
 200 static void nfsrv_unlocklf(struct nfslockfile *lfp);
 201 static struct nfsdsession *nfsrv_findsession(uint8_t *sessionid);
 202 static int nfsrv_freesession(struct nfsdsession *sep, uint8_t *sessionid);
 203 static int nfsv4_setcbsequence(struct nfsrv_descript *nd, struct nfsclient *clp,
 204     int dont_replycache, struct nfsdsession **sepp);
 205 static int nfsv4_getcbsession(struct nfsclient *clp, struct nfsdsession **sepp);
 206 static int nfsrv_addlayout(struct nfsrv_descript *nd, struct nfslayout **lypp,
 207     nfsv4stateid_t *stateidp, char *layp, int *layoutlenp, NFSPROC_T *p);
 208 static void nfsrv_freelayout(struct nfslayouthead *lhp, struct nfslayout *lyp);
 209 static void nfsrv_freelayoutlist(nfsquad_t clientid);
 210 static void nfsrv_freelayouts(nfsquad_t *clid, fsid_t *fs, int laytype,
 211     int iomode);
 212 static void nfsrv_freealllayouts(void);
 213 static void nfsrv_freedevid(struct nfsdevice *ds);
 214 static int nfsrv_setdsserver(char *dspathp, char *mdspathp, NFSPROC_T *p,
 215     struct nfsdevice **dsp);
 216 static void nfsrv_deleteds(struct nfsdevice *fndds);
 217 static void nfsrv_allocdevid(struct nfsdevice *ds, char *addr, char *dnshost);
 218 static void nfsrv_freealldevids(void);
 219 static void nfsrv_flexlayouterr(struct nfsrv_descript *nd, uint32_t *layp,
 220     int maxcnt, NFSPROC_T *p);
 221 static int nfsrv_recalllayout(nfsquad_t clid, nfsv4stateid_t *stateidp,
 222     fhandle_t *fhp, struct nfslayout *lyp, int changed, int laytype,
 223     NFSPROC_T *p);
 224 static int nfsrv_findlayout(nfsquad_t *clientidp, fhandle_t *fhp, int laytype,
 225     NFSPROC_T *, struct nfslayout **lypp);
 226 static int nfsrv_fndclid(nfsquad_t *clidvec, nfsquad_t clid, int clidcnt);
 227 static struct nfslayout *nfsrv_filelayout(struct nfsrv_descript *nd, int iomode,
 228     fhandle_t *fhp, fhandle_t *dsfhp, char *devid, fsid_t fs);
 229 static struct nfslayout *nfsrv_flexlayout(struct nfsrv_descript *nd, int iomode,
 230     int mirrorcnt, fhandle_t *fhp, fhandle_t *dsfhp, char *devid, fsid_t fs);
 231 static int nfsrv_dontlayout(fhandle_t *fhp);
 232 static int nfsrv_createdsfile(vnode_t vp, fhandle_t *fhp, struct pnfsdsfile *pf,
 233     vnode_t dvp, struct nfsdevice *ds, struct ucred *cred, NFSPROC_T *p,
 234     vnode_t *tvpp);
 235 static struct nfsdevice *nfsrv_findmirroredds(struct nfsmount *nmp);
 236
 237 /*
 238  * Scan the client list for a match and either return the current one,
 239  * create a new entry or return an error.
 240  * If returning a non-error, the clp structure must either be linked into
 241  * the client list or free'd.
 242  */
 243 int
 244 nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
 245     nfsquad_t *clientidp, nfsquad_t *confirmp, NFSPROC_T *p)
 246 {
 247         struct nfsclient *clp = NULL, *new_clp = *new_clpp;
 248         int i, error = 0, ret;
 249         struct nfsstate *stp, *tstp;
 250 #ifdef INET
 251         struct sockaddr_in *sin, *rin;
 252 #endif
 253 #ifdef INET6
 254         struct sockaddr_in6 *sin6, *rin6;
 255 #endif
 256         struct nfsdsession *sep, *nsep;
 257         int zapit = 0, gotit, hasstate = 0, igotlock;
 258         static u_int64_t confirm_index = 0;
 259
 260         /*
 261          * Check for state resource limit exceeded.
 262          */
 263         if (nfsrv_openpluslock > nfsrv_v4statelimit) {
 264                 error = NFSERR_RESOURCE;
 265                 goto out;
 266         }
 267
 268         if (nfsrv_issuedelegs == 0 ||
 269             ((nd->nd_flag & ND_GSS) != 0 && nfsrv_nogsscallback != 0))
 270                 /*
 271                  * Don't do callbacks when delegations are disabled or
 272                  * for AUTH_GSS unless enabled via nfsrv_nogsscallback.
 273                  * If establishing a callback connection is attempted
 274                  * when a firewall is blocking the callback path, the
 275                  * server may wait too long for the connect attempt to
 276                  * succeed during the Open. Some clients, such as Linux,
 277                  * may timeout and give up on the Open before the server
 278                  * replies. Also, since AUTH_GSS callbacks are not
 279                  * yet interoperability tested, they might cause the
 280                  * server to crap out, if they get past the Init call to
 281                  * the client.
 282                  */
 283                 new_clp->lc_program = 0;
 284
 285         /* Lock out other nfsd threads */
 286         NFSLOCKV4ROOTMUTEX();
 287         nfsv4_relref(&nfsv4rootfs_lock);
 288         do {
 289                 igotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
 290                     NFSV4ROOTLOCKMUTEXPTR, NULL);
 291         } while (!igotlock);
 292         NFSUNLOCKV4ROOTMUTEX();
 293
 294         /*
 295          * Search for a match in the client list.
 296          */
 297         gotit = i = 0;
 298         while (i < nfsrv_clienthashsize && !gotit) {
 299             LIST_FOREACH(clp, &nfsclienthash[i], lc_hash) {
 300                 if (new_clp->lc_idlen == clp->lc_idlen &&
 301                     !NFSBCMP(new_clp->lc_id, clp->lc_id, clp->lc_idlen)) {
 302                         gotit = 1;
 303                         break;
 304                 }
 305             }
 306             if (gotit == 0)
 307                 i++;
 308         }
 309         if (!gotit ||
 310             (clp->lc_flags & (LCL_NEEDSCONFIRM | LCL_ADMINREVOKED))) {
 311                 if ((nd->nd_flag & ND_NFSV41) != 0 && confirmp->lval[1] != 0) {
 312                         /*
 313                          * For NFSv4.1, if confirmp->lval[1] is non-zero, the
 314                          * client is trying to update a confirmed clientid.
 315                          */
 316                         NFSLOCKV4ROOTMUTEX();
 317                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
 318                         NFSUNLOCKV4ROOTMUTEX();
 319                         confirmp->lval[1] = 0;
 320                         error = NFSERR_NOENT;
 321                         goto out;
 322                 }
 323                 /*
 324                  * Get rid of the old one.
 325                  */
 326                 if (i != nfsrv_clienthashsize) {
 327                         LIST_REMOVE(clp, lc_hash);
 328                         nfsrv_cleanclient(clp, p);
 329                         nfsrv_freedeleglist(&clp->lc_deleg);
 330                         nfsrv_freedeleglist(&clp->lc_olddeleg);
 331                         zapit = 1;
 332                 }
 333                 /*
 334                  * Add it after assigning a client id to it.
 335                  */
 336                 new_clp->lc_flags |= LCL_NEEDSCONFIRM;
 337                 if ((nd->nd_flag & ND_NFSV41) != 0)
 338                         new_clp->lc_confirm.lval[0] = confirmp->lval[0] =
 339                             ++confirm_index;
 340                 else
 341                         confirmp->qval = new_clp->lc_confirm.qval =
 342                             ++confirm_index;
 343                 clientidp->lval[0] = new_clp->lc_clientid.lval[0] =
 344                     (u_int32_t)nfsrvboottime;
 345                 clientidp->lval[1] = new_clp->lc_clientid.lval[1] =
 346                     nfsrv_nextclientindex();
 347                 new_clp->lc_stateindex = 0;
 348                 new_clp->lc_statemaxindex = 0;
 349                 new_clp->lc_cbref = 0;
 350                 new_clp->lc_expiry = nfsrv_leaseexpiry();
 351                 LIST_INIT(&new_clp->lc_open);
 352                 LIST_INIT(&new_clp->lc_deleg);
 353                 LIST_INIT(&new_clp->lc_olddeleg);
 354                 LIST_INIT(&new_clp->lc_session);
 355                 for (i = 0; i < nfsrv_statehashsize; i++)
 356                         LIST_INIT(&new_clp->lc_stateid[i]);
 357                 LIST_INSERT_HEAD(NFSCLIENTHASH(new_clp->lc_clientid), new_clp,
 358                     lc_hash);
 359                 nfsstatsv1.srvclients++;
 360                 nfsrv_openpluslock++;
 361                 nfsrv_clients++;
 362                 NFSLOCKV4ROOTMUTEX();
 363                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
 364                 NFSUNLOCKV4ROOTMUTEX();
 365                 if (zapit)
 366                         nfsrv_zapclient(clp, p);
 367                 *new_clpp = NULL;
 368                 goto out;
 369         }
 370
 371         /*
 372          * Now, handle the cases where the id is already issued.
 373          */
 374         if (nfsrv_notsamecredname(nd, clp)) {
 375             /*
 376              * Check to see if there is expired state that should go away.
 377              */
 378             if (clp->lc_expiry < NFSD_MONOSEC &&
 379                 (!LIST_EMPTY(&clp->lc_open) || !LIST_EMPTY(&clp->lc_deleg))) {
 380                 nfsrv_cleanclient(clp, p);
 381                 nfsrv_freedeleglist(&clp->lc_deleg);
 382             }
 383
 384             /*
 385              * If there is outstanding state, then reply NFSERR_CLIDINUSE per
 386              * RFC3530 Sec. 8.1.2 last para.
 387              */
 388             if (!LIST_EMPTY(&clp->lc_deleg)) {
 389                 hasstate = 1;
 390             } else if (LIST_EMPTY(&clp->lc_open)) {
 391                 hasstate = 0;
 392             } else {
 393                 hasstate = 0;
 394                 /* Look for an Open on the OpenOwner */
 395                 LIST_FOREACH(stp, &clp->lc_open, ls_list) {
 396                     if (!LIST_EMPTY(&stp->ls_open)) {
 397                         hasstate = 1;
 398                         break;
 399                     }
 400                 }
 401             }
 402             if (hasstate) {
 403                 /*
 404                  * If the uid doesn't match, return NFSERR_CLIDINUSE after
 405                  * filling out the correct ipaddr and portnum.
 406                  */
 407                 switch (clp->lc_req.nr_nam->sa_family) {
 408 #ifdef INET
 409                 case AF_INET:
 410                         sin = (struct sockaddr_in *)new_clp->lc_req.nr_nam;
 411                         rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
 412                         sin->sin_addr.s_addr = rin->sin_addr.s_addr;
 413                         sin->sin_port = rin->sin_port;
 414                         break;
 415 #endif
 416 #ifdef INET6
 417                 case AF_INET6:
 418                         sin6 = (struct sockaddr_in6 *)new_clp->lc_req.nr_nam;
 419                         rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
 420                         sin6->sin6_addr = rin6->sin6_addr;
 421                         sin6->sin6_port = rin6->sin6_port;
 422                         break;
 423 #endif
 424                 }
 425                 NFSLOCKV4ROOTMUTEX();
 426                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
 427                 NFSUNLOCKV4ROOTMUTEX();
 428                 error = NFSERR_CLIDINUSE;
 429                 goto out;
 430             }
 431         }
 432
 433         if (NFSBCMP(new_clp->lc_verf, clp->lc_verf, NFSX_VERF)) {
 434                 /*
 435                  * If the verifier has changed, the client has rebooted
 436                  * and a new client id is issued. The old state info
 437                  * can be thrown away once the SETCLIENTID_CONFIRM occurs.
 438                  */
 439                 LIST_REMOVE(clp, lc_hash);
 440
 441                 /* Get rid of all sessions on this clientid. */
 442                 LIST_FOREACH_SAFE(sep, &clp->lc_session, sess_list, nsep) {
 443                         ret = nfsrv_freesession(sep, NULL);
 444                         if (ret != 0)
 445                                 printf("nfsrv_setclient: verifier changed free"
 446                                     " session failed=%d\n", ret);
 447                 }
 448
 449                 new_clp->lc_flags |= LCL_NEEDSCONFIRM;
 450                 if ((nd->nd_flag & ND_NFSV41) != 0)
 451                         new_clp->lc_confirm.lval[0] = confirmp->lval[0] =
 452                             ++confirm_index;
 453                 else
 454                         confirmp->qval = new_clp->lc_confirm.qval =
 455                             ++confirm_index;
 456                 clientidp->lval[0] = new_clp->lc_clientid.lval[0] =
 457                     nfsrvboottime;
 458                 clientidp->lval[1] = new_clp->lc_clientid.lval[1] =
 459                     nfsrv_nextclientindex();
 460                 new_clp->lc_stateindex = 0;
 461                 new_clp->lc_statemaxindex = 0;
 462                 new_clp->lc_cbref = 0;
 463                 new_clp->lc_expiry = nfsrv_leaseexpiry();
 464
 465                 /*
 466                  * Save the state until confirmed.
 467                  */
 468                 LIST_NEWHEAD(&new_clp->lc_open, &clp->lc_open, ls_list);
 469                 LIST_FOREACH(tstp, &new_clp->lc_open, ls_list)
 470                         tstp->ls_clp = new_clp;
 471                 LIST_NEWHEAD(&new_clp->lc_deleg, &clp->lc_deleg, ls_list);
 472                 LIST_FOREACH(tstp, &new_clp->lc_deleg, ls_list)
 473                         tstp->ls_clp = new_clp;
 474                 LIST_NEWHEAD(&new_clp->lc_olddeleg, &clp->lc_olddeleg,
 475                     ls_list);
 476                 LIST_FOREACH(tstp, &new_clp->lc_olddeleg, ls_list)
 477                         tstp->ls_clp = new_clp;
 478                 for (i = 0; i < nfsrv_statehashsize; i++) {
 479                         LIST_NEWHEAD(&new_clp->lc_stateid[i],
 480                             &clp->lc_stateid[i], ls_hash);
 481                         LIST_FOREACH(tstp, &new_clp->lc_stateid[i], ls_hash)
 482                                 tstp->ls_clp = new_clp;
 483                 }
 484                 LIST_INIT(&new_clp->lc_session);
 485                 LIST_INSERT_HEAD(NFSCLIENTHASH(new_clp->lc_clientid), new_clp,
 486                     lc_hash);
 487                 nfsstatsv1.srvclients++;
 488                 nfsrv_openpluslock++;
 489                 nfsrv_clients++;
 490                 NFSLOCKV4ROOTMUTEX();
 491                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
 492                 NFSUNLOCKV4ROOTMUTEX();
 493
 494                 /*
 495                  * Must wait until any outstanding callback on the old clp
 496                  * completes.
 497                  */
 498                 NFSLOCKSTATE();
 499                 while (clp->lc_cbref) {
 500                         clp->lc_flags |= LCL_WAKEUPWANTED;
 501                         (void)mtx_sleep(clp, NFSSTATEMUTEXPTR, PZERO - 1,
 502                             "nfsd clp", 10 * hz);
 503                 }
 504                 NFSUNLOCKSTATE();
 505                 nfsrv_zapclient(clp, p);
 506                 *new_clpp = NULL;
 507                 goto out;
 508         }
 509
 510         /* For NFSv4.1, mark that we found a confirmed clientid. */
 511         if ((nd->nd_flag & ND_NFSV41) != 0) {
 512                 clientidp->lval[0] = clp->lc_clientid.lval[0];
 513                 clientidp->lval[1] = clp->lc_clientid.lval[1];
 514                 confirmp->lval[0] = 0;  /* Ignored by client */
 515                 confirmp->lval[1] = 1;
 516         } else {
 517                 /*
 518                  * id and verifier match, so update the net address info
 519                  * and get rid of any existing callback authentication
 520                  * handle, so a new one will be acquired.
 521                  */
 522                 LIST_REMOVE(clp, lc_hash);
 523                 new_clp->lc_flags |= (LCL_NEEDSCONFIRM | LCL_DONTCLEAN);
 524                 new_clp->lc_expiry = nfsrv_leaseexpiry();
 525                 confirmp->qval = new_clp->lc_confirm.qval = ++confirm_index;
 526                 clientidp->lval[0] = new_clp->lc_clientid.lval[0] =
 527                     clp->lc_clientid.lval[0];
 528                 clientidp->lval[1] = new_clp->lc_clientid.lval[1] =
 529                     clp->lc_clientid.lval[1];
 530                 new_clp->lc_delegtime = clp->lc_delegtime;
 531                 new_clp->lc_stateindex = clp->lc_stateindex;
 532                 new_clp->lc_statemaxindex = clp->lc_statemaxindex;
 533                 new_clp->lc_cbref = 0;
 534                 LIST_NEWHEAD(&new_clp->lc_open, &clp->lc_open, ls_list);
 535                 LIST_FOREACH(tstp, &new_clp->lc_open, ls_list)
 536                         tstp->ls_clp = new_clp;
 537                 LIST_NEWHEAD(&new_clp->lc_deleg, &clp->lc_deleg, ls_list);
 538                 LIST_FOREACH(tstp, &new_clp->lc_deleg, ls_list)
 539                         tstp->ls_clp = new_clp;
 540                 LIST_NEWHEAD(&new_clp->lc_olddeleg, &clp->lc_olddeleg, ls_list);
 541                 LIST_FOREACH(tstp, &new_clp->lc_olddeleg, ls_list)
 542                         tstp->ls_clp = new_clp;
 543                 for (i = 0; i < nfsrv_statehashsize; i++) {
 544                         LIST_NEWHEAD(&new_clp->lc_stateid[i],
 545                             &clp->lc_stateid[i], ls_hash);
 546                         LIST_FOREACH(tstp, &new_clp->lc_stateid[i], ls_hash)
 547                                 tstp->ls_clp = new_clp;
 548                 }
 549                 LIST_INIT(&new_clp->lc_session);
 550                 LIST_INSERT_HEAD(NFSCLIENTHASH(new_clp->lc_clientid), new_clp,
 551                     lc_hash);
 552                 nfsstatsv1.srvclients++;
 553                 nfsrv_openpluslock++;
 554                 nfsrv_clients++;
 555         }
 556         NFSLOCKV4ROOTMUTEX();
 557         nfsv4_unlock(&nfsv4rootfs_lock, 1);
 558         NFSUNLOCKV4ROOTMUTEX();
 559
 560         if ((nd->nd_flag & ND_NFSV41) == 0) {
 561                 /*
 562                  * Must wait until any outstanding callback on the old clp
 563                  * completes.
 564                  */
 565                 NFSLOCKSTATE();
 566                 while (clp->lc_cbref) {
 567                         clp->lc_flags |= LCL_WAKEUPWANTED;
 568                         (void)mtx_sleep(clp, NFSSTATEMUTEXPTR, PZERO - 1,
 569                             "nfsdclp", 10 * hz);
 570                 }
 571                 NFSUNLOCKSTATE();
 572                 nfsrv_zapclient(clp, p);
 573                 *new_clpp = NULL;
 574         }
 575
 576 out:
 577         NFSEXITCODE2(error, nd);
 578         return (error);
 579 }
 580
 581 /*
 582  * Check to see if the client id exists and optionally confirm it.
 583  */
 584 int
 585 nfsrv_getclient(nfsquad_t clientid, int opflags, struct nfsclient **clpp,
 586     struct nfsdsession *nsep, nfsquad_t confirm, uint32_t cbprogram,
 587     struct nfsrv_descript *nd, NFSPROC_T *p)
 588 {
 589         struct nfsclient *clp;
 590         struct nfsstate *stp;
 591         int i;
 592         struct nfsclienthashhead *hp;
 593         int error = 0, igotlock, doneok;
 594         struct nfssessionhash *shp;
 595         struct nfsdsession *sep;
 596         uint64_t sessid[2];
 597         static uint64_t next_sess = 0;
 598
 599         if (clpp)
 600                 *clpp = NULL;
 601         if ((nd == NULL || (nd->nd_flag & ND_NFSV41) == 0 ||
 602             opflags != CLOPS_RENEW) && nfsrvboottime != clientid.lval[0]) {
 603                 error = NFSERR_STALECLIENTID;
 604                 goto out;
 605         }
 606
 607         /*
 608          * If called with opflags == CLOPS_RENEW, the State Lock is
 609          * already held. Otherwise, we need to get either that or,
 610          * for the case of Confirm, lock out the nfsd threads.
 611          */
 612         if (opflags & CLOPS_CONFIRM) {
 613                 NFSLOCKV4ROOTMUTEX();
 614                 nfsv4_relref(&nfsv4rootfs_lock);
 615                 do {
 616                         igotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
 617                             NFSV4ROOTLOCKMUTEXPTR, NULL);
 618                 } while (!igotlock);
 619                 /*
 620                  * Create a new sessionid here, since we need to do it where
 621                  * there is a mutex held to serialize update of next_sess.
 622                  */
 623                 if ((nd->nd_flag & ND_NFSV41) != 0) {
 624                         sessid[0] = ++next_sess;
 625                         sessid[1] = clientid.qval;
 626                 }
 627                 NFSUNLOCKV4ROOTMUTEX();
 628         } else if (opflags != CLOPS_RENEW) {
 629                 NFSLOCKSTATE();
 630         }
 631
 632         /* For NFSv4.1, the clp is acquired from the associated session. */
 633         if (nd != NULL && (nd->nd_flag & ND_NFSV41) != 0 &&
 634             opflags == CLOPS_RENEW) {
 635                 clp = NULL;
 636                 if ((nd->nd_flag & ND_HASSEQUENCE) != 0) {
 637                         shp = NFSSESSIONHASH(nd->nd_sessionid);
 638                         NFSLOCKSESSION(shp);
 639                         sep = nfsrv_findsession(nd->nd_sessionid);
 640                         if (sep != NULL)
 641                                 clp = sep->sess_clp;
 642                         NFSUNLOCKSESSION(shp);
 643                 }
 644         } else {
 645                 hp = NFSCLIENTHASH(clientid);
 646                 LIST_FOREACH(clp, hp, lc_hash) {
 647                         if (clp->lc_clientid.lval[1] == clientid.lval[1])
 648                                 break;
 649                 }
 650         }
 651         if (clp == NULL) {
 652                 if (opflags & CLOPS_CONFIRM)
 653                         error = NFSERR_STALECLIENTID;
 654                 else
 655                         error = NFSERR_EXPIRED;
 656         } else if (clp->lc_flags & LCL_ADMINREVOKED) {
 657                 /*
 658                  * If marked admin revoked, just return the error.
 659                  */
 660                 error = NFSERR_ADMINREVOKED;
 661         }
 662         if (error) {
 663                 if (opflags & CLOPS_CONFIRM) {
 664                         NFSLOCKV4ROOTMUTEX();
 665                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
 666                         NFSUNLOCKV4ROOTMUTEX();
 667                 } else if (opflags != CLOPS_RENEW) {
 668                         NFSUNLOCKSTATE();
 669                 }
 670                 goto out;
 671         }
 672
 673         /*
 674          * Perform any operations specified by the opflags.
 675          */
 676         if (opflags & CLOPS_CONFIRM) {
 677                 if (((nd->nd_flag & ND_NFSV41) != 0 &&
 678                      clp->lc_confirm.lval[0] != confirm.lval[0]) ||
 679                     ((nd->nd_flag & ND_NFSV41) == 0 &&
 680                      clp->lc_confirm.qval != confirm.qval))
 681                         error = NFSERR_STALECLIENTID;
 682                 else if (nfsrv_notsamecredname(nd, clp))
 683                         error = NFSERR_CLIDINUSE;
 684
 685                 if (!error) {
 686                     if ((clp->lc_flags & (LCL_NEEDSCONFIRM | LCL_DONTCLEAN)) ==
 687                         LCL_NEEDSCONFIRM) {
 688                         /*
 689                          * Hang onto the delegations (as old delegations)
 690                          * for an Open with CLAIM_DELEGATE_PREV unless in
 691                          * grace, but get rid of the rest of the state.
 692                          */
 693                         nfsrv_cleanclient(clp, p);
 694                         nfsrv_freedeleglist(&clp->lc_olddeleg);
 695                         if (nfsrv_checkgrace(nd, clp, 0)) {
 696                             /* In grace, so just delete delegations */
 697                             nfsrv_freedeleglist(&clp->lc_deleg);
 698                         } else {
 699                             LIST_FOREACH(stp, &clp->lc_deleg, ls_list)
 700                                 stp->ls_flags |= NFSLCK_OLDDELEG;
 701                             clp->lc_delegtime = NFSD_MONOSEC +
 702                                 nfsrv_lease + NFSRV_LEASEDELTA;
 703                             LIST_NEWHEAD(&clp->lc_olddeleg, &clp->lc_deleg,
 704                                 ls_list);
 705                         }
 706                         if ((nd->nd_flag & ND_NFSV41) != 0)
 707                             clp->lc_program = cbprogram;
 708                     }
 709                     clp->lc_flags &= ~(LCL_NEEDSCONFIRM | LCL_DONTCLEAN);
 710                     if (clp->lc_program)
 711                         clp->lc_flags |= LCL_NEEDSCBNULL;
 712                     /* For NFSv4.1, link the session onto the client. */
 713                     if (nsep != NULL) {
 714                         /* Hold a reference on the xprt for a backchannel. */
 715                         if ((nsep->sess_crflags & NFSV4CRSESS_CONNBACKCHAN)
 716                             != 0) {
 717                             if (clp->lc_req.nr_client == NULL)
 718                                 clp->lc_req.nr_client = (struct __rpc_client *)
 719                                     clnt_bck_create(nd->nd_xprt->xp_socket,
 720                                     cbprogram, NFSV4_CBVERS);
 721                             if (clp->lc_req.nr_client != NULL) {
 722                                 SVC_ACQUIRE(nd->nd_xprt);
 723                                 nd->nd_xprt->xp_p2 =
 724                                     clp->lc_req.nr_client->cl_private;
 725                                 /* Disable idle timeout. */
 726                                 nd->nd_xprt->xp_idletimeout = 0;
 727                                 nsep->sess_cbsess.nfsess_xprt = nd->nd_xprt;
 728                             } else
 729                                 nsep->sess_crflags &= ~NFSV4CRSESS_CONNBACKCHAN;
 730                         }
 731                         NFSBCOPY(sessid, nsep->sess_sessionid,
 732                             NFSX_V4SESSIONID);
 733                         NFSBCOPY(sessid, nsep->sess_cbsess.nfsess_sessionid,
 734                             NFSX_V4SESSIONID);
 735                         shp = NFSSESSIONHASH(nsep->sess_sessionid);
 736                         NFSLOCKSTATE();
 737                         NFSLOCKSESSION(shp);
 738                         LIST_INSERT_HEAD(&shp->list, nsep, sess_hash);
 739                         LIST_INSERT_HEAD(&clp->lc_session, nsep, sess_list);
 740                         nsep->sess_clp = clp;
 741                         NFSUNLOCKSESSION(shp);
 742                         NFSUNLOCKSTATE();
 743                     }
 744                 }
 745         } else if (clp->lc_flags & LCL_NEEDSCONFIRM) {
 746                 error = NFSERR_EXPIRED;
 747         }
 748
 749         /*
 750          * If called by the Renew Op, we must check the principal.
 751          */
 752         if (!error && (opflags & CLOPS_RENEWOP)) {
 753             if (nfsrv_notsamecredname(nd, clp)) {
 754                 doneok = 0;
 755                 for (i = 0; i < nfsrv_statehashsize && doneok == 0; i++) {
 756                     LIST_FOREACH(stp, &clp->lc_stateid[i], ls_hash) {
 757                         if ((stp->ls_flags & NFSLCK_OPEN) &&
 758                             stp->ls_uid == nd->nd_cred->cr_uid) {
 759                                 doneok = 1;
 760                                 break;
 761                         }
 762                     }
 763                 }
 764                 if (!doneok)
 765                         error = NFSERR_ACCES;
 766             }
 767             if (!error && (clp->lc_flags & LCL_CBDOWN))
 768                 error = NFSERR_CBPATHDOWN;
 769         }
 770         if ((!error || error == NFSERR_CBPATHDOWN) &&
 771              (opflags & CLOPS_RENEW)) {
 772                 clp->lc_expiry = nfsrv_leaseexpiry();
 773         }
 774         if (opflags & CLOPS_CONFIRM) {
 775                 NFSLOCKV4ROOTMUTEX();
 776                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
 777                 NFSUNLOCKV4ROOTMUTEX();
 778         } else if (opflags != CLOPS_RENEW) {
 779                 NFSUNLOCKSTATE();
 780         }
 781         if (clpp)
 782                 *clpp = clp;
 783
 784 out:
 785         NFSEXITCODE2(error, nd);
 786         return (error);
 787 }
 788
 789 /*
 790  * Perform the NFSv4.1 destroy clientid.
 791  */
 792 int
 793 nfsrv_destroyclient(nfsquad_t clientid, NFSPROC_T *p)
 794 {
 795         struct nfsclient *clp;
 796         struct nfsclienthashhead *hp;
 797         int error = 0, i, igotlock;
 798
 799         if (nfsrvboottime != clientid.lval[0]) {
 800                 error = NFSERR_STALECLIENTID;
 801                 goto out;
 802         }
 803
 804         /* Lock out other nfsd threads */
 805         NFSLOCKV4ROOTMUTEX();
 806         nfsv4_relref(&nfsv4rootfs_lock);
 807         do {
 808                 igotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
 809                     NFSV4ROOTLOCKMUTEXPTR, NULL);
 810         } while (igotlock == 0);
 811         NFSUNLOCKV4ROOTMUTEX();
 812
 813         hp = NFSCLIENTHASH(clientid);
 814         LIST_FOREACH(clp, hp, lc_hash) {
 815                 if (clp->lc_clientid.lval[1] == clientid.lval[1])
 816                         break;
 817         }
 818         if (clp == NULL) {
 819                 NFSLOCKV4ROOTMUTEX();
 820                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
 821                 NFSUNLOCKV4ROOTMUTEX();
 822                 /* Just return ok, since it is gone. */
 823                 goto out;
 824         }
 825
 826         /*
 827          * Free up all layouts on the clientid.  Should the client return the
 828          * layouts?
 829          */
 830         nfsrv_freelayoutlist(clientid);
 831
 832         /* Scan for state on the clientid. */
 833         for (i = 0; i < nfsrv_statehashsize; i++)
 834                 if (!LIST_EMPTY(&clp->lc_stateid[i])) {
 835                         NFSLOCKV4ROOTMUTEX();
 836                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
 837                         NFSUNLOCKV4ROOTMUTEX();
 838                         error = NFSERR_CLIENTIDBUSY;
 839                         goto out;
 840                 }
 841         if (!LIST_EMPTY(&clp->lc_session) || !LIST_EMPTY(&clp->lc_deleg)) {
 842                 NFSLOCKV4ROOTMUTEX();
 843                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
 844                 NFSUNLOCKV4ROOTMUTEX();
 845                 error = NFSERR_CLIENTIDBUSY;
 846                 goto out;
 847         }
 848
 849         /* Destroy the clientid and return ok. */
 850         nfsrv_cleanclient(clp, p);
 851         nfsrv_freedeleglist(&clp->lc_deleg);
 852         nfsrv_freedeleglist(&clp->lc_olddeleg);
 853         LIST_REMOVE(clp, lc_hash);
 854         NFSLOCKV4ROOTMUTEX();
 855         nfsv4_unlock(&nfsv4rootfs_lock, 1);
 856         NFSUNLOCKV4ROOTMUTEX();
 857         nfsrv_zapclient(clp, p);
 858 out:
 859         NFSEXITCODE2(error, nd);
 860         return (error);
 861 }
 862
 863 /*
 864  * Called from the new nfssvc syscall to admin revoke a clientid.
 865  * Returns 0 for success, error otherwise.
 866  */
 867 int
 868 nfsrv_adminrevoke(struct nfsd_clid *revokep, NFSPROC_T *p)
 869 {
 870         struct nfsclient *clp = NULL;
 871         int i, error = 0;
 872         int gotit, igotlock;
 873
 874         /*
 875          * First, lock out the nfsd so that state won't change while the
 876          * revocation record is being written to the stable storage restart
 877          * file.
 878          */
 879         NFSLOCKV4ROOTMUTEX();
 880         do {
 881                 igotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
 882                     NFSV4ROOTLOCKMUTEXPTR, NULL);
 883         } while (!igotlock);
 884         NFSUNLOCKV4ROOTMUTEX();
 885
 886         /*
 887          * Search for a match in the client list.
 888          */
 889         gotit = i = 0;
 890         while (i < nfsrv_clienthashsize && !gotit) {
 891             LIST_FOREACH(clp, &nfsclienthash[i], lc_hash) {
 892                 if (revokep->nclid_idlen == clp->lc_idlen &&
 893                     !NFSBCMP(revokep->nclid_id, clp->lc_id, clp->lc_idlen)) {
 894                         gotit = 1;
 895                         break;
 896                 }
 897             }
 898             i++;
 899         }
 900         if (!gotit) {
 901                 NFSLOCKV4ROOTMUTEX();
 902                 nfsv4_unlock(&nfsv4rootfs_lock, 0);
 903                 NFSUNLOCKV4ROOTMUTEX();
 904                 error = EPERM;
 905                 goto out;
 906         }
 907
 908         /*
 909          * Now, write out the revocation record
 910          */
 911         nfsrv_writestable(clp->lc_id, clp->lc_idlen, NFSNST_REVOKE, p);
 912         nfsrv_backupstable();
 913
 914         /*
 915          * and clear out the state, marking the clientid revoked.
 916          */
 917         clp->lc_flags &= ~LCL_CALLBACKSON;
 918         clp->lc_flags |= LCL_ADMINREVOKED;
 919         nfsrv_cleanclient(clp, p);
 920         nfsrv_freedeleglist(&clp->lc_deleg);
 921         nfsrv_freedeleglist(&clp->lc_olddeleg);
 922         NFSLOCKV4ROOTMUTEX();
 923         nfsv4_unlock(&nfsv4rootfs_lock, 0);
 924         NFSUNLOCKV4ROOTMUTEX();
 925
 926 out:
 927         NFSEXITCODE(error);
 928         return (error);
 929 }
 930
 931 /*
 932  * Dump out stats for all clients. Called from nfssvc(2), that is used
 933  * nfsstatsv1.
 934  */
 935 void
 936 nfsrv_dumpclients(struct nfsd_dumpclients *dumpp, int maxcnt)
 937 {
 938         struct nfsclient *clp;
 939         int i = 0, cnt = 0;
 940
 941         /*
 942          * First, get a reference on the nfsv4rootfs_lock so that an
 943          * exclusive lock cannot be acquired while dumping the clients.
 944          */
 945         NFSLOCKV4ROOTMUTEX();
 946         nfsv4_getref(&nfsv4rootfs_lock, NULL, NFSV4ROOTLOCKMUTEXPTR, NULL);
 947         NFSUNLOCKV4ROOTMUTEX();
 948         NFSLOCKSTATE();
 949         /*
 950          * Rattle through the client lists until done.
 951          */
 952         while (i < nfsrv_clienthashsize && cnt < maxcnt) {
 953             clp = LIST_FIRST(&nfsclienthash[i]);
 954             while (clp != LIST_END(&nfsclienthash[i]) && cnt < maxcnt) {
 955                 nfsrv_dumpaclient(clp, &dumpp[cnt]);
 956                 cnt++;
 957                 clp = LIST_NEXT(clp, lc_hash);
 958             }
 959             i++;
 960         }
 961         if (cnt < maxcnt)
 962             dumpp[cnt].ndcl_clid.nclid_idlen = 0;
 963         NFSUNLOCKSTATE();
 964         NFSLOCKV4ROOTMUTEX();
 965         nfsv4_relref(&nfsv4rootfs_lock);
 966         NFSUNLOCKV4ROOTMUTEX();
 967 }
 968
 969 /*
 970  * Dump stats for a client. Must be called with the NFSSTATELOCK and spl'd.
 971  */
 972 static void
 973 nfsrv_dumpaclient(struct nfsclient *clp, struct nfsd_dumpclients *dumpp)
 974 {
 975         struct nfsstate *stp, *openstp, *lckownstp;
 976         struct nfslock *lop;
 977         sa_family_t af;
 978 #ifdef INET
 979         struct sockaddr_in *rin;
 980 #endif
 981 #ifdef INET6
 982         struct sockaddr_in6 *rin6;
 983 #endif
 984
 985         dumpp->ndcl_nopenowners = dumpp->ndcl_nlockowners = 0;
 986         dumpp->ndcl_nopens = dumpp->ndcl_nlocks = 0;
 987         dumpp->ndcl_ndelegs = dumpp->ndcl_nolddelegs = 0;
 988         dumpp->ndcl_flags = clp->lc_flags;
 989         dumpp->ndcl_clid.nclid_idlen = clp->lc_idlen;
 990         NFSBCOPY(clp->lc_id, dumpp->ndcl_clid.nclid_id, clp->lc_idlen);
 991         af = clp->lc_req.nr_nam->sa_family;
 992         dumpp->ndcl_addrfam = af;
 993         switch (af) {
 994 #ifdef INET
 995         case AF_INET:
 996                 rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
 997                 dumpp->ndcl_cbaddr.sin_addr = rin->sin_addr;
 998                 break;
 999 #endif
1000 #ifdef INET6
1001         case AF_INET6:
1002                 rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
1003                 dumpp->ndcl_cbaddr.sin6_addr = rin6->sin6_addr;
1004                 break;
1005 #endif
1006         }
1007
1008         /*
1009          * Now, scan the state lists and total up the opens and locks.
1010          */
1011         LIST_FOREACH(stp, &clp->lc_open, ls_list) {
1012             dumpp->ndcl_nopenowners++;
1013             LIST_FOREACH(openstp, &stp->ls_open, ls_list) {
1014                 dumpp->ndcl_nopens++;
1015                 LIST_FOREACH(lckownstp, &openstp->ls_open, ls_list) {
1016                     dumpp->ndcl_nlockowners++;
1017                     LIST_FOREACH(lop, &lckownstp->ls_lock, lo_lckowner) {
1018                         dumpp->ndcl_nlocks++;
1019                     }
1020                 }
1021             }
1022         }
1023
1024         /*
1025          * and the delegation lists.
1026          */
1027         LIST_FOREACH(stp, &clp->lc_deleg, ls_list) {
1028             dumpp->ndcl_ndelegs++;
1029         }
1030         LIST_FOREACH(stp, &clp->lc_olddeleg, ls_list) {
1031             dumpp->ndcl_nolddelegs++;
1032         }
1033 }
1034
1035 /*
1036  * Dump out lock stats for a file.
1037  */
1038 void
1039 nfsrv_dumplocks(vnode_t vp, struct nfsd_dumplocks *ldumpp, int maxcnt,
1040     NFSPROC_T *p)
1041 {
1042         struct nfsstate *stp;
1043         struct nfslock *lop;
1044         int cnt = 0;
1045         struct nfslockfile *lfp;
1046         sa_family_t af;
1047 #ifdef INET
1048         struct sockaddr_in *rin;
1049 #endif
1050 #ifdef INET6
1051         struct sockaddr_in6 *rin6;
1052 #endif
1053         int ret;
1054         fhandle_t nfh;
1055
1056         ret = nfsrv_getlockfh(vp, 0, NULL, &nfh, p);
1057         /*
1058          * First, get a reference on the nfsv4rootfs_lock so that an
1059          * exclusive lock on it cannot be acquired while dumping the locks.
1060          */
1061         NFSLOCKV4ROOTMUTEX();
1062         nfsv4_getref(&nfsv4rootfs_lock, NULL, NFSV4ROOTLOCKMUTEXPTR, NULL);
1063         NFSUNLOCKV4ROOTMUTEX();
1064         NFSLOCKSTATE();
1065         if (!ret)
1066                 ret = nfsrv_getlockfile(0, NULL, &lfp, &nfh, 0);
1067         if (ret) {
1068                 ldumpp[0].ndlck_clid.nclid_idlen = 0;
1069                 NFSUNLOCKSTATE();
1070                 NFSLOCKV4ROOTMUTEX();
1071                 nfsv4_relref(&nfsv4rootfs_lock);
1072                 NFSUNLOCKV4ROOTMUTEX();
1073                 return;
1074         }
1075
1076         /*
1077          * For each open share on file, dump it out.
1078          */
1079         stp = LIST_FIRST(&lfp->lf_open);
1080         while (stp != LIST_END(&lfp->lf_open) && cnt < maxcnt) {
1081                 ldumpp[cnt].ndlck_flags = stp->ls_flags;
1082                 ldumpp[cnt].ndlck_stateid.seqid = stp->ls_stateid.seqid;
1083                 ldumpp[cnt].ndlck_stateid.other[0] = stp->ls_stateid.other[0];
1084                 ldumpp[cnt].ndlck_stateid.other[1] = stp->ls_stateid.other[1];
1085                 ldumpp[cnt].ndlck_stateid.other[2] = stp->ls_stateid.other[2];
1086                 ldumpp[cnt].ndlck_owner.nclid_idlen =
1087                     stp->ls_openowner->ls_ownerlen;
1088                 NFSBCOPY(stp->ls_openowner->ls_owner,
1089                     ldumpp[cnt].ndlck_owner.nclid_id,
1090                     stp->ls_openowner->ls_ownerlen);
1091                 ldumpp[cnt].ndlck_clid.nclid_idlen = stp->ls_clp->lc_idlen;
1092                 NFSBCOPY(stp->ls_clp->lc_id, ldumpp[cnt].ndlck_clid.nclid_id,
1093                     stp->ls_clp->lc_idlen);
1094                 af = stp->ls_clp->lc_req.nr_nam->sa_family;
1095                 ldumpp[cnt].ndlck_addrfam = af;
1096                 switch (af) {
1097 #ifdef INET
1098                 case AF_INET:
1099                         rin = (struct sockaddr_in *)stp->ls_clp->lc_req.nr_nam;
1100                         ldumpp[cnt].ndlck_cbaddr.sin_addr = rin->sin_addr;
1101                         break;
1102 #endif
1103 #ifdef INET6
1104                 case AF_INET6:
1105                         rin6 = (struct sockaddr_in6 *)
1106                             stp->ls_clp->lc_req.nr_nam;
1107                         ldumpp[cnt].ndlck_cbaddr.sin6_addr = rin6->sin6_addr;
1108                         break;
1109 #endif
1110                 }
1111                 stp = LIST_NEXT(stp, ls_file);
1112                 cnt++;
1113         }
1114
1115         /*
1116          * and all locks.
1117          */
1118         lop = LIST_FIRST(&lfp->lf_lock);
1119         while (lop != LIST_END(&lfp->lf_lock) && cnt < maxcnt) {
1120                 stp = lop->lo_stp;
1121                 ldumpp[cnt].ndlck_flags = lop->lo_flags;
1122                 ldumpp[cnt].ndlck_first = lop->lo_first;
1123                 ldumpp[cnt].ndlck_end = lop->lo_end;
1124                 ldumpp[cnt].ndlck_stateid.seqid = stp->ls_stateid.seqid;
1125                 ldumpp[cnt].ndlck_stateid.other[0] = stp->ls_stateid.other[0];
1126                 ldumpp[cnt].ndlck_stateid.other[1] = stp->ls_stateid.other[1];
1127                 ldumpp[cnt].ndlck_stateid.other[2] = stp->ls_stateid.other[2];
1128                 ldumpp[cnt].ndlck_owner.nclid_idlen = stp->ls_ownerlen;
1129                 NFSBCOPY(stp->ls_owner, ldumpp[cnt].ndlck_owner.nclid_id,
1130                     stp->ls_ownerlen);
1131                 ldumpp[cnt].ndlck_clid.nclid_idlen = stp->ls_clp->lc_idlen;
1132                 NFSBCOPY(stp->ls_clp->lc_id, ldumpp[cnt].ndlck_clid.nclid_id,
1133                     stp->ls_clp->lc_idlen);
1134                 af = stp->ls_clp->lc_req.nr_nam->sa_family;
1135                 ldumpp[cnt].ndlck_addrfam = af;
1136                 switch (af) {
1137 #ifdef INET
1138                 case AF_INET:
1139                         rin = (struct sockaddr_in *)stp->ls_clp->lc_req.nr_nam;
1140                         ldumpp[cnt].ndlck_cbaddr.sin_addr = rin->sin_addr;
1141                         break;
1142 #endif
1143 #ifdef INET6
1144                 case AF_INET6:
1145                         rin6 = (struct sockaddr_in6 *)
1146                             stp->ls_clp->lc_req.nr_nam;
1147                         ldumpp[cnt].ndlck_cbaddr.sin6_addr = rin6->sin6_addr;
1148                         break;
1149 #endif
1150                 }
1151                 lop = LIST_NEXT(lop, lo_lckfile);
1152                 cnt++;
1153         }
1154
1155         /*
1156          * and the delegations.
1157          */
1158         stp = LIST_FIRST(&lfp->lf_deleg);
1159         while (stp != LIST_END(&lfp->lf_deleg) && cnt < maxcnt) {
1160                 ldumpp[cnt].ndlck_flags = stp->ls_flags;
1161                 ldumpp[cnt].ndlck_stateid.seqid = stp->ls_stateid.seqid;
1162                 ldumpp[cnt].ndlck_stateid.other[0] = stp->ls_stateid.other[0];
1163                 ldumpp[cnt].ndlck_stateid.other[1] = stp->ls_stateid.other[1];
1164                 ldumpp[cnt].ndlck_stateid.other[2] = stp->ls_stateid.other[2];
1165                 ldumpp[cnt].ndlck_owner.nclid_idlen = 0;
1166                 ldumpp[cnt].ndlck_clid.nclid_idlen = stp->ls_clp->lc_idlen;
1167                 NFSBCOPY(stp->ls_clp->lc_id, ldumpp[cnt].ndlck_clid.nclid_id,
1168                     stp->ls_clp->lc_idlen);
1169                 af = stp->ls_clp->lc_req.nr_nam->sa_family;
1170                 ldumpp[cnt].ndlck_addrfam = af;
1171                 switch (af) {
1172 #ifdef INET
1173                 case AF_INET:
1174                         rin = (struct sockaddr_in *)stp->ls_clp->lc_req.nr_nam;
1175                         ldumpp[cnt].ndlck_cbaddr.sin_addr = rin->sin_addr;
1176                         break;
1177 #endif
1178 #ifdef INET6
1179                 case AF_INET6:
1180                         rin6 = (struct sockaddr_in6 *)
1181                             stp->ls_clp->lc_req.nr_nam;
1182                         ldumpp[cnt].ndlck_cbaddr.sin6_addr = rin6->sin6_addr;
1183                         break;
1184 #endif
1185                 }
1186                 stp = LIST_NEXT(stp, ls_file);
1187                 cnt++;
1188         }
1189
1190         /*
1191          * If list isn't full, mark end of list by setting the client name
1192          * to zero length.
1193          */
1194         if (cnt < maxcnt)
1195                 ldumpp[cnt].ndlck_clid.nclid_idlen = 0;
1196         NFSUNLOCKSTATE();
1197         NFSLOCKV4ROOTMUTEX();
1198         nfsv4_relref(&nfsv4rootfs_lock);
1199         NFSUNLOCKV4ROOTMUTEX();
1200 }
1201
1202 /*
1203  * Server timer routine. It can scan any linked list, so long
1204  * as it holds the spin/mutex lock and there is no exclusive lock on
1205  * nfsv4rootfs_lock.
1206  * (For OpenBSD, a kthread is ok. For FreeBSD, I think it is ok
1207  *  to do this from a callout, since the spin locks work. For
1208  *  Darwin, I'm not sure what will work correctly yet.)
1209  * Should be called once per second.
1210  */
1211 void
1212 nfsrv_servertimer(void)
1213 {
1214         struct nfsclient *clp, *nclp;
1215         struct nfsstate *stp, *nstp;
1216         int got_ref, i;
1217
1218         /*
1219          * Make sure nfsboottime is set. This is used by V3 as well
1220          * as V4. Note that nfsboottime is not nfsrvboottime, which is
1221          * only used by the V4 server for leases.
1222          */
1223         if (nfsboottime.tv_sec == 0)
1224                 NFSSETBOOTTIME(nfsboottime);
1225
1226         /*
1227          * If server hasn't started yet, just return.
1228          */
1229         NFSLOCKSTATE();
1230         if (nfsrv_stablefirst.nsf_eograce == 0) {
1231                 NFSUNLOCKSTATE();
1232                 return;
1233         }
1234         if (!(nfsrv_stablefirst.nsf_flags & NFSNSF_UPDATEDONE)) {
1235                 if (!(nfsrv_stablefirst.nsf_flags & NFSNSF_GRACEOVER) &&
1236                     NFSD_MONOSEC > nfsrv_stablefirst.nsf_eograce)
1237                         nfsrv_stablefirst.nsf_flags |=
1238                             (NFSNSF_GRACEOVER | NFSNSF_NEEDLOCK);
1239                 NFSUNLOCKSTATE();
1240                 return;
1241         }
1242
1243         /*
1244          * Try and get a reference count on the nfsv4rootfs_lock so that
1245          * no nfsd thread can acquire an exclusive lock on it before this
1246          * call is done. If it is already exclusively locked, just return.
1247          */
1248         NFSLOCKV4ROOTMUTEX();
1249         got_ref = nfsv4_getref_nonblock(&nfsv4rootfs_lock);
1250         NFSUNLOCKV4ROOTMUTEX();
1251         if (got_ref == 0) {
1252                 NFSUNLOCKSTATE();
1253                 return;
1254         }
1255
1256         /*
1257          * For each client...
1258          */
1259         for (i = 0; i < nfsrv_clienthashsize; i++) {
1260             clp = LIST_FIRST(&nfsclienthash[i]);
1261             while (clp != LIST_END(&nfsclienthash[i])) {
1262                 nclp = LIST_NEXT(clp, lc_hash);
1263                 if (!(clp->lc_flags & LCL_EXPIREIT)) {
1264                     if (((clp->lc_expiry + NFSRV_STALELEASE) < NFSD_MONOSEC
1265                          && ((LIST_EMPTY(&clp->lc_deleg)
1266                               && LIST_EMPTY(&clp->lc_open)) ||
1267                              nfsrv_clients > nfsrv_clienthighwater)) ||
1268                         (clp->lc_expiry + NFSRV_MOULDYLEASE) < NFSD_MONOSEC ||
1269                         (clp->lc_expiry < NFSD_MONOSEC &&
1270                          (nfsrv_openpluslock * 10 / 9) > nfsrv_v4statelimit)) {
1271                         /*
1272                          * Lease has expired several nfsrv_lease times ago:
1273                          * PLUS
1274                          *    - no state is associated with it
1275                          *    OR
1276                          *    - above high water mark for number of clients
1277                          *      (nfsrv_clienthighwater should be large enough
1278                          *       that this only occurs when clients fail to
1279                          *       use the same nfs_client_id4.id. Maybe somewhat
1280                          *       higher that the maximum number of clients that
1281                          *       will mount this server?)
1282                          * OR
1283                          * Lease has expired a very long time ago
1284                          * OR
1285                          * Lease has expired PLUS the number of opens + locks
1286                          * has exceeded 90% of capacity
1287                          *
1288                          * --> Mark for expiry. The actual expiry will be done
1289                          *     by an nfsd sometime soon.
1290                          */
1291                         clp->lc_flags |= LCL_EXPIREIT;
1292                         nfsrv_stablefirst.nsf_flags |=
1293                             (NFSNSF_NEEDLOCK | NFSNSF_EXPIREDCLIENT);
1294                     } else {
1295                         /*
1296                          * If there are no opens, increment no open tick cnt
1297                          * If time exceeds NFSNOOPEN, mark it to be thrown away
1298                          * otherwise, if there is an open, reset no open time
1299                          * Hopefully, this will avoid excessive re-creation
1300                          * of open owners and subsequent open confirms.
1301                          */
1302                         stp = LIST_FIRST(&clp->lc_open);
1303                         while (stp != LIST_END(&clp->lc_open)) {
1304                                 nstp = LIST_NEXT(stp, ls_list);
1305                                 if (LIST_EMPTY(&stp->ls_open)) {
1306                                         stp->ls_noopens++;
1307                                         if (stp->ls_noopens > NFSNOOPEN ||
1308                                             (nfsrv_openpluslock * 2) >
1309                                             nfsrv_v4statelimit)
1310                                                 nfsrv_stablefirst.nsf_flags |=
1311                                                         NFSNSF_NOOPENS;
1312                                 } else {
1313                                         stp->ls_noopens = 0;
1314                                 }
1315                                 stp = nstp;
1316                         }
1317                     }
1318                 }
1319                 clp = nclp;
1320             }
1321         }
1322         NFSUNLOCKSTATE();
1323         NFSLOCKV4ROOTMUTEX();
1324         nfsv4_relref(&nfsv4rootfs_lock);
1325         NFSUNLOCKV4ROOTMUTEX();
1326 }
1327
1328 /*
1329  * The following set of functions free up the various data structures.
1330  */
1331 /*
1332  * Clear out all open/lock state related to this nfsclient.
1333  * Caller must hold an exclusive lock on nfsv4rootfs_lock, so that
1334  * there are no other active nfsd threads.
1335  */
1336 void
1337 nfsrv_cleanclient(struct nfsclient *clp, NFSPROC_T *p)
1338 {
1339         struct nfsstate *stp, *nstp;
1340         struct nfsdsession *sep, *nsep;
1341
1342         LIST_FOREACH_SAFE(stp, &clp->lc_open, ls_list, nstp)
1343                 nfsrv_freeopenowner(stp, 1, p);
1344         if ((clp->lc_flags & LCL_ADMINREVOKED) == 0)
1345                 LIST_FOREACH_SAFE(sep, &clp->lc_session, sess_list, nsep)
1346                         (void)nfsrv_freesession(sep, NULL);
1347 }
1348
1349 /*
1350  * Free a client that has been cleaned. It should also already have been
1351  * removed from the lists.
1352  * (Just to be safe w.r.t. newnfs_disconnect(), call this function when
1353  *  softclock interrupts are enabled.)
1354  */
1355 void
1356 nfsrv_zapclient(struct nfsclient *clp, NFSPROC_T *p)
1357 {
1358
1359 #ifdef notyet
1360         if ((clp->lc_flags & (LCL_GSS | LCL_CALLBACKSON)) ==
1361              (LCL_GSS | LCL_CALLBACKSON) &&
1362             (clp->lc_hand.nfsh_flag & NFSG_COMPLETE) &&
1363             clp->lc_handlelen > 0) {
1364                 clp->lc_hand.nfsh_flag &= ~NFSG_COMPLETE;
1365                 clp->lc_hand.nfsh_flag |= NFSG_DESTROYED;
1366                 (void) nfsrv_docallback(clp, NFSV4PROC_CBNULL,
1367                         NULL, 0, NULL, NULL, NULL, 0, p);
1368         }
1369 #endif
1370         newnfs_disconnect(&clp->lc_req);
1371         free(clp->lc_req.nr_nam, M_SONAME);
1372         NFSFREEMUTEX(&clp->lc_req.nr_mtx);
1373         free(clp->lc_stateid, M_NFSDCLIENT);
1374         free(clp, M_NFSDCLIENT);
1375         NFSLOCKSTATE();
1376         nfsstatsv1.srvclients--;
1377         nfsrv_openpluslock--;
1378         nfsrv_clients--;
1379         NFSUNLOCKSTATE();
1380 }
1381
1382 /*
1383  * Free a list of delegation state structures.
1384  * (This function will also free all nfslockfile structures that no
1385  *  longer have associated state.)
1386  */
1387 void
1388 nfsrv_freedeleglist(struct nfsstatehead *sthp)
1389 {
1390         struct nfsstate *stp, *nstp;
1391
1392         LIST_FOREACH_SAFE(stp, sthp, ls_list, nstp) {
1393                 nfsrv_freedeleg(stp);
1394         }
1395         LIST_INIT(sthp);
1396 }
1397
1398 /*
1399  * Free up a delegation.
1400  */
1401 static void
1402 nfsrv_freedeleg(struct nfsstate *stp)
1403 {
1404         struct nfslockfile *lfp;
1405
1406         LIST_REMOVE(stp, ls_hash);
1407         LIST_REMOVE(stp, ls_list);
1408         LIST_REMOVE(stp, ls_file);
1409         if ((stp->ls_flags & NFSLCK_DELEGWRITE) != 0)
1410                 nfsrv_writedelegcnt--;
1411         lfp = stp->ls_lfp;
1412         if (LIST_EMPTY(&lfp->lf_open) &&
1413             LIST_EMPTY(&lfp->lf_lock) && LIST_EMPTY(&lfp->lf_deleg) &&
1414             LIST_EMPTY(&lfp->lf_locallock) && LIST_EMPTY(&lfp->lf_rollback) &&
1415             lfp->lf_usecount == 0 &&
1416             nfsv4_testlock(&lfp->lf_locallock_lck) == 0)
1417                 nfsrv_freenfslockfile(lfp);
1418         free(stp, M_NFSDSTATE);
1419         nfsstatsv1.srvdelegates--;
1420         nfsrv_openpluslock--;
1421         nfsrv_delegatecnt--;
1422 }
1423
1424 /*
1425  * This function frees an open owner and all associated opens.
1426  */
1427 static void
1428 nfsrv_freeopenowner(struct nfsstate *stp, int cansleep, NFSPROC_T *p)
1429 {
1430         struct nfsstate *nstp, *tstp;
1431
1432         LIST_REMOVE(stp, ls_list);
1433         /*
1434          * Now, free all associated opens.
1435          */
1436         nstp = LIST_FIRST(&stp->ls_open);
1437         while (nstp != LIST_END(&stp->ls_open)) {
1438                 tstp = nstp;
1439                 nstp = LIST_NEXT(nstp, ls_list);
1440                 (void) nfsrv_freeopen(tstp, NULL, cansleep, p);
1441         }
1442         if (stp->ls_op)
1443                 nfsrvd_derefcache(stp->ls_op);
1444         free(stp, M_NFSDSTATE);
1445         nfsstatsv1.srvopenowners--;
1446         nfsrv_openpluslock--;
1447 }
1448
1449 /*
1450  * This function frees an open (nfsstate open structure) with all associated
1451  * lock_owners and locks. It also frees the nfslockfile structure iff there
1452  * are no other opens on the file.
1453  * Returns 1 if it free'd the nfslockfile, 0 otherwise.
1454  */
1455 static int
1456 nfsrv_freeopen(struct nfsstate *stp, vnode_t vp, int cansleep, NFSPROC_T *p)
1457 {
1458         struct nfsstate *nstp, *tstp;
1459         struct nfslockfile *lfp;
1460         int ret;
1461
1462         LIST_REMOVE(stp, ls_hash);
1463         LIST_REMOVE(stp, ls_list);
1464         LIST_REMOVE(stp, ls_file);
1465
1466         lfp = stp->ls_lfp;
1467         /*
1468          * Now, free all lockowners associated with this open.
1469          */
1470         LIST_FOREACH_SAFE(tstp, &stp->ls_open, ls_list, nstp)
1471                 nfsrv_freelockowner(tstp, vp, cansleep, p);
1472
1473         /*
1474          * The nfslockfile is freed here if there are no locks
1475          * associated with the open.
1476          * If there are locks associated with the open, the
1477          * nfslockfile structure can be freed via nfsrv_freelockowner().
1478          * Acquire the state mutex to avoid races with calls to
1479          * nfsrv_getlockfile().
1480          */
1481         if (cansleep != 0)
1482                 NFSLOCKSTATE();
1483         if (lfp != NULL && LIST_EMPTY(&lfp->lf_open) &&
1484             LIST_EMPTY(&lfp->lf_deleg) && LIST_EMPTY(&lfp->lf_lock) &&
1485             LIST_EMPTY(&lfp->lf_locallock) && LIST_EMPTY(&lfp->lf_rollback) &&
1486             lfp->lf_usecount == 0 &&
1487             (cansleep != 0 || nfsv4_testlock(&lfp->lf_locallock_lck) == 0)) {
1488                 nfsrv_freenfslockfile(lfp);
1489                 ret = 1;
1490         } else
1491                 ret = 0;
1492         if (cansleep != 0)
1493                 NFSUNLOCKSTATE();
1494         free(stp, M_NFSDSTATE);
1495         nfsstatsv1.srvopens--;
1496         nfsrv_openpluslock--;
1497         return (ret);
1498 }
1499
1500 /*
1501  * Frees a lockowner and all associated locks.
1502  */
1503 static void
1504 nfsrv_freelockowner(struct nfsstate *stp, vnode_t vp, int cansleep,
1505     NFSPROC_T *p)
1506 {
1507
1508         LIST_REMOVE(stp, ls_hash);
1509         LIST_REMOVE(stp, ls_list);
1510         nfsrv_freeallnfslocks(stp, vp, cansleep, p);
1511         if (stp->ls_op)
1512                 nfsrvd_derefcache(stp->ls_op);
1513         free(stp, M_NFSDSTATE);
1514         nfsstatsv1.srvlockowners--;
1515         nfsrv_openpluslock--;
1516 }
1517
1518 /*
1519  * Free all the nfs locks on a lockowner.
1520  */
1521 static void
1522 nfsrv_freeallnfslocks(struct nfsstate *stp, vnode_t vp, int cansleep,
1523     NFSPROC_T *p)
1524 {
1525         struct nfslock *lop, *nlop;
1526         struct nfsrollback *rlp, *nrlp;
1527         struct nfslockfile *lfp = NULL;
1528         int gottvp = 0;
1529         vnode_t tvp = NULL;
1530         uint64_t first, end;
1531
1532         if (vp != NULL)
1533                 ASSERT_VOP_UNLOCKED(vp, "nfsrv_freeallnfslocks: vnode locked");
1534         lop = LIST_FIRST(&stp->ls_lock);
1535         while (lop != LIST_END(&stp->ls_lock)) {
1536                 nlop = LIST_NEXT(lop, lo_lckowner);
1537                 /*
1538                  * Since all locks should be for the same file, lfp should
1539                  * not change.
1540                  */
1541                 if (lfp == NULL)
1542                         lfp = lop->lo_lfp;
1543                 else if (lfp != lop->lo_lfp)
1544                         panic("allnfslocks");
1545                 /*
1546                  * If vp is NULL and cansleep != 0, a vnode must be acquired
1547                  * from the file handle. This only occurs when called from
1548                  * nfsrv_cleanclient().
1549                  */
1550                 if (gottvp == 0) {
1551                         if (nfsrv_dolocallocks == 0)
1552                                 tvp = NULL;
1553                         else if (vp == NULL && cansleep != 0) {
1554                                 tvp = nfsvno_getvp(&lfp->lf_fh);
1555                                 if (tvp != NULL)
1556                                         NFSVOPUNLOCK(tvp);
1557                         } else
1558                                 tvp = vp;
1559                         gottvp = 1;
1560                 }
1561
1562                 if (tvp != NULL) {
1563                         if (cansleep == 0)
1564                                 panic("allnfs2");
1565                         first = lop->lo_first;
1566                         end = lop->lo_end;
1567                         nfsrv_freenfslock(lop);
1568                         nfsrv_localunlock(tvp, lfp, first, end, p);
1569                         LIST_FOREACH_SAFE(rlp, &lfp->lf_rollback, rlck_list,
1570                             nrlp)
1571                                 free(rlp, M_NFSDROLLBACK);
1572                         LIST_INIT(&lfp->lf_rollback);
1573                 } else
1574                         nfsrv_freenfslock(lop);
1575                 lop = nlop;
1576         }
1577         if (vp == NULL && tvp != NULL)
1578                 vrele(tvp);
1579 }
1580
1581 /*
1582  * Free an nfslock structure.
1583  */
1584 static void
1585 nfsrv_freenfslock(struct nfslock *lop)
1586 {
1587
1588         if (lop->lo_lckfile.le_prev != NULL) {
1589                 LIST_REMOVE(lop, lo_lckfile);
1590                 nfsstatsv1.srvlocks--;
1591                 nfsrv_openpluslock--;
1592         }
1593         LIST_REMOVE(lop, lo_lckowner);
1594         free(lop, M_NFSDLOCK);
1595 }
1596
1597 /*
1598  * This function frees an nfslockfile structure.
1599  */
1600 static void
1601 nfsrv_freenfslockfile(struct nfslockfile *lfp)
1602 {
1603
1604         LIST_REMOVE(lfp, lf_hash);
1605         free(lfp, M_NFSDLOCKFILE);
1606 }
1607
1608 /*
1609  * This function looks up an nfsstate structure via stateid.
1610  */
1611 static int
1612 nfsrv_getstate(struct nfsclient *clp, nfsv4stateid_t *stateidp, __unused u_int32_t flags,
1613     struct nfsstate **stpp)
1614 {
1615         struct nfsstate *stp;
1616         struct nfsstatehead *hp;
1617         int error = 0;
1618
1619         *stpp = NULL;
1620         hp = NFSSTATEHASH(clp, *stateidp);
1621         LIST_FOREACH(stp, hp, ls_hash) {
1622                 if (!NFSBCMP(stp->ls_stateid.other, stateidp->other,
1623                         NFSX_STATEIDOTHER))
1624                         break;
1625         }
1626
1627         /*
1628          * If no state id in list, return NFSERR_BADSTATEID.
1629          */
1630         if (stp == LIST_END(hp)) {
1631                 error = NFSERR_BADSTATEID;
1632                 goto out;
1633         }
1634         *stpp = stp;
1635
1636 out:
1637         NFSEXITCODE(error);
1638         return (error);
1639 }
1640
1641 /*
1642  * This function gets an nfsstate structure via owner string.
1643  */
1644 static void
1645 nfsrv_getowner(struct nfsstatehead *hp, struct nfsstate *new_stp,
1646     struct nfsstate **stpp)
1647 {
1648         struct nfsstate *stp;
1649
1650         *stpp = NULL;
1651         LIST_FOREACH(stp, hp, ls_list) {
1652                 if (new_stp->ls_ownerlen == stp->ls_ownerlen &&
1653                   !NFSBCMP(new_stp->ls_owner,stp->ls_owner,stp->ls_ownerlen)) {
1654                         *stpp = stp;
1655                         return;
1656                 }
1657         }
1658 }
1659
1660 /*
1661  * Lock control function called to update lock status.
1662  * Returns 0 upon success, -1 if there is no lock and the flags indicate
1663  * that one isn't to be created and an NFSERR_xxx for other errors.
1664  * The structures new_stp and new_lop are passed in as pointers that should
1665  * be set to NULL if the structure is used and shouldn't be free'd.
1666  * For the NFSLCK_TEST and NFSLCK_CHECK cases, the structures are
1667  * never used and can safely be allocated on the stack. For all other
1668  * cases, *new_stpp and *new_lopp should be malloc'd before the call,
1669  * in case they are used.
1670  */
1671 int
1672 nfsrv_lockctrl(vnode_t vp, struct nfsstate **new_stpp,
1673     struct nfslock **new_lopp, struct nfslockconflict *cfp,
1674     nfsquad_t clientid, nfsv4stateid_t *stateidp,
1675     __unused struct nfsexstuff *exp,
1676     struct nfsrv_descript *nd, NFSPROC_T *p)
1677 {
1678         struct nfslock *lop;
1679         struct nfsstate *new_stp = *new_stpp;
1680         struct nfslock *new_lop = *new_lopp;
1681         struct nfsstate *tstp, *mystp, *nstp;
1682         int specialid = 0;
1683         struct nfslockfile *lfp;
1684         struct nfslock *other_lop = NULL;
1685         struct nfsstate *stp, *lckstp = NULL;
1686         struct nfsclient *clp = NULL;
1687         u_int32_t bits;
1688         int error = 0, haslock = 0, ret, reterr;
1689         int getlckret, delegation = 0, filestruct_locked, vnode_unlocked = 0;
1690         fhandle_t nfh;
1691         uint64_t first, end;
1692         uint32_t lock_flags;
1693
1694         if (new_stp->ls_flags & (NFSLCK_CHECK | NFSLCK_SETATTR)) {
1695                 /*
1696                  * Note the special cases of "all 1s" or "all 0s" stateids and
1697                  * let reads with all 1s go ahead.
1698                  */
1699                 if (new_stp->ls_stateid.seqid == 0x0 &&
1700                     new_stp->ls_stateid.other[0] == 0x0 &&
1701                     new_stp->ls_stateid.other[1] == 0x0 &&
1702                     new_stp->ls_stateid.other[2] == 0x0)
1703                         specialid = 1;
1704                 else if (new_stp->ls_stateid.seqid == 0xffffffff &&
1705                     new_stp->ls_stateid.other[0] == 0xffffffff &&
1706                     new_stp->ls_stateid.other[1] == 0xffffffff &&
1707                     new_stp->ls_stateid.other[2] == 0xffffffff)
1708                         specialid = 2;
1709         }
1710
1711         /*
1712          * Check for restart conditions (client and server).
1713          */
1714         error = nfsrv_checkrestart(clientid, new_stp->ls_flags,
1715             &new_stp->ls_stateid, specialid);
1716         if (error)
1717                 goto out;
1718
1719         /*
1720          * Check for state resource limit exceeded.
1721          */
1722         if ((new_stp->ls_flags & NFSLCK_LOCK) &&
1723             nfsrv_openpluslock > nfsrv_v4statelimit) {
1724                 error = NFSERR_RESOURCE;
1725                 goto out;
1726         }
1727
1728         /*
1729          * For the lock case, get another nfslock structure,
1730          * just in case we need it.
1731          * Malloc now, before we start sifting through the linked lists,
1732          * in case we have to wait for memory.
1733          */
1734 tryagain:
1735         if (new_stp->ls_flags & NFSLCK_LOCK)
1736                 other_lop = malloc(sizeof (struct nfslock),
1737                     M_NFSDLOCK, M_WAITOK);
1738         filestruct_locked = 0;
1739         reterr = 0;
1740         lfp = NULL;
1741
1742         /*
1743          * Get the lockfile structure for CFH now, so we can do a sanity
1744          * check against the stateid, before incrementing the seqid#, since
1745          * we want to return NFSERR_BADSTATEID on failure and the seqid#
1746          * shouldn't be incremented for this case.
1747          * If nfsrv_getlockfile() returns -1, it means "not found", which
1748          * will be handled later.
1749          * If we are doing Lock/LockU and local locking is enabled, sleep
1750          * lock the nfslockfile structure.
1751          */
1752         getlckret = nfsrv_getlockfh(vp, new_stp->ls_flags, NULL, &nfh, p);
1753         NFSLOCKSTATE();
1754         if (getlckret == 0) {
1755                 if ((new_stp->ls_flags & (NFSLCK_LOCK | NFSLCK_UNLOCK)) != 0 &&
1756                     nfsrv_dolocallocks != 0 && nd->nd_repstat == 0) {
1757                         getlckret = nfsrv_getlockfile(new_stp->ls_flags, NULL,
1758                             &lfp, &nfh, 1);
1759                         if (getlckret == 0)
1760                                 filestruct_locked = 1;
1761                 } else
1762                         getlckret = nfsrv_getlockfile(new_stp->ls_flags, NULL,
1763                             &lfp, &nfh, 0);
1764         }
1765         if (getlckret != 0 && getlckret != -1)
1766                 reterr = getlckret;
1767
1768         if (filestruct_locked != 0) {
1769                 LIST_INIT(&lfp->lf_rollback);
1770                 if ((new_stp->ls_flags & NFSLCK_LOCK)) {
1771                         /*
1772                          * For local locking, do the advisory locking now, so
1773                          * that any conflict can be detected. A failure later
1774                          * can be rolled back locally. If an error is returned,
1775                          * struct nfslockfile has been unlocked and any local
1776                          * locking rolled back.
1777                          */
1778                         NFSUNLOCKSTATE();
1779                         if (vnode_unlocked == 0) {
1780                                 ASSERT_VOP_ELOCKED(vp, "nfsrv_lockctrl1");
1781                                 vnode_unlocked = 1;
1782                                 NFSVOPUNLOCK(vp);
1783                         }
1784                         reterr = nfsrv_locallock(vp, lfp,
1785                             (new_lop->lo_flags & (NFSLCK_READ | NFSLCK_WRITE)),
1786                             new_lop->lo_first, new_lop->lo_end, cfp, p);
1787                         NFSLOCKSTATE();
1788                 }
1789         }
1790
1791         if (specialid == 0) {
1792             if (new_stp->ls_flags & NFSLCK_TEST) {
1793                 /*
1794                  * RFC 3530 does not list LockT as an op that renews a
1795                  * lease, but the consensus seems to be that it is ok
1796                  * for a server to do so.
1797                  */
1798                 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
1799                     (nfsquad_t)((u_quad_t)0), 0, nd, p);
1800
1801                 /*
1802                  * Since NFSERR_EXPIRED, NFSERR_ADMINREVOKED are not valid
1803                  * error returns for LockT, just go ahead and test for a lock,
1804                  * since there are no locks for this client, but other locks
1805                  * can conflict. (ie. same client will always be false)
1806                  */
1807                 if (error == NFSERR_EXPIRED || error == NFSERR_ADMINREVOKED)
1808                     error = 0;
1809                 lckstp = new_stp;
1810             } else {
1811               error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
1812                 (nfsquad_t)((u_quad_t)0), 0, nd, p);
1813               if (error == 0)
1814                 /*
1815                  * Look up the stateid
1816                  */
1817                 error = nfsrv_getstate(clp, &new_stp->ls_stateid,
1818                   new_stp->ls_flags, &stp);
1819               /*
1820                * do some sanity checks for an unconfirmed open or a
1821                * stateid that refers to the wrong file, for an open stateid
1822                */
1823               if (error == 0 && (stp->ls_flags & NFSLCK_OPEN) &&
1824                   ((stp->ls_openowner->ls_flags & NFSLCK_NEEDSCONFIRM) ||
1825                    (getlckret == 0 && stp->ls_lfp != lfp))){
1826                       /*
1827                        * NFSLCK_SETATTR should return OK rather than NFSERR_BADSTATEID
1828                        * The only exception is using SETATTR with SIZE.
1829                        * */
1830                     if ((new_stp->ls_flags &
1831                          (NFSLCK_SETATTR | NFSLCK_CHECK)) != NFSLCK_SETATTR)
1832                              error = NFSERR_BADSTATEID;
1833               }
1834
1835                 if (error == 0 &&
1836                   (stp->ls_flags & (NFSLCK_DELEGREAD | NFSLCK_DELEGWRITE)) &&
1837                   getlckret == 0 && stp->ls_lfp != lfp)
1838                         error = NFSERR_BADSTATEID;
1839
1840               /*
1841                * If the lockowner stateid doesn't refer to the same file,
1842                * I believe that is considered ok, since some clients will
1843                * only create a single lockowner and use that for all locks
1844                * on all files.
1845                * For now, log it as a diagnostic, instead of considering it
1846                * a BadStateid.
1847                */
1848               if (error == 0 && (stp->ls_flags &
1849                   (NFSLCK_OPEN | NFSLCK_DELEGREAD | NFSLCK_DELEGWRITE)) == 0 &&
1850                   getlckret == 0 && stp->ls_lfp != lfp) {
1851 #ifdef DIAGNOSTIC
1852                   printf("Got a lock statid for different file open\n");
1853 #endif
1854                   /*
1855                   error = NFSERR_BADSTATEID;
1856                   */
1857               }
1858
1859               if (error == 0) {
1860                     if (new_stp->ls_flags & NFSLCK_OPENTOLOCK) {
1861                         /*
1862                          * If haslock set, we've already checked the seqid.
1863                          */
1864                         if (!haslock) {
1865                             if (stp->ls_flags & NFSLCK_OPEN)
1866                                 error = nfsrv_checkseqid(nd, new_stp->ls_seq,
1867                                     stp->ls_openowner, new_stp->ls_op);
1868                             else
1869                                 error = NFSERR_BADSTATEID;
1870                         }
1871                         if (!error)
1872                             nfsrv_getowner(&stp->ls_open, new_stp, &lckstp);
1873                         if (lckstp)
1874                             /*
1875                              * I believe this should be an error, but it
1876                              * isn't obvious what NFSERR_xxx would be
1877                              * appropriate, so I'll use NFSERR_INVAL for now.
1878                              */
1879                             error = NFSERR_INVAL;
1880                         else
1881                             lckstp = new_stp;
1882                     } else if (new_stp->ls_flags&(NFSLCK_LOCK|NFSLCK_UNLOCK)) {
1883                         /*
1884                          * If haslock set, ditto above.
1885                          */
1886                         if (!haslock) {
1887                             if (stp->ls_flags & NFSLCK_OPEN)
1888                                 error = NFSERR_BADSTATEID;
1889                             else
1890                                 error = nfsrv_checkseqid(nd, new_stp->ls_seq,
1891                                     stp, new_stp->ls_op);
1892                         }
1893                         lckstp = stp;
1894                     } else {
1895                         lckstp = stp;
1896                     }
1897               }
1898               /*
1899                * If the seqid part of the stateid isn't the same, return
1900                * NFSERR_OLDSTATEID for cases other than I/O Ops.
1901                * For I/O Ops, only return NFSERR_OLDSTATEID if
1902                * nfsrv_returnoldstateid is set. (The consensus on the email
1903                * list was that most clients would prefer to not receive
1904                * NFSERR_OLDSTATEID for I/O Ops, but the RFC suggests that that
1905                * is what will happen, so I use the nfsrv_returnoldstateid to
1906                * allow for either server configuration.)
1907                */
1908               if (!error && stp->ls_stateid.seqid!=new_stp->ls_stateid.seqid &&
1909                   (((nd->nd_flag & ND_NFSV41) == 0 &&
1910                    (!(new_stp->ls_flags & NFSLCK_CHECK) ||
1911                     nfsrv_returnoldstateid)) ||
1912                    ((nd->nd_flag & ND_NFSV41) != 0 &&
1913                     new_stp->ls_stateid.seqid != 0)))
1914                     error = NFSERR_OLDSTATEID;
1915             }
1916         }
1917
1918         /*
1919          * Now we can check for grace.
1920          */
1921         if (!error)
1922                 error = nfsrv_checkgrace(nd, clp, new_stp->ls_flags);
1923         if ((new_stp->ls_flags & NFSLCK_RECLAIM) && !error &&
1924                 nfsrv_checkstable(clp))
1925                 error = NFSERR_NOGRACE;
1926         /*
1927          * If we successfully Reclaimed state, note that.
1928          */
1929         if ((new_stp->ls_flags & NFSLCK_RECLAIM) && !error)
1930                 nfsrv_markstable(clp);
1931
1932         /*
1933          * At this point, either error == NFSERR_BADSTATEID or the
1934          * seqid# has been updated, so we can return any error.
1935          * If error == 0, there may be an error in:
1936          *    nd_repstat - Set by the calling function.
1937          *    reterr - Set above, if getting the nfslockfile structure
1938          *       or acquiring the local lock failed.
1939          *    (If both of these are set, nd_repstat should probably be
1940          *     returned, since that error was detected before this
1941          *     function call.)
1942          */
1943         if (error != 0 || nd->nd_repstat != 0 || reterr != 0) {
1944                 if (error == 0) {
1945                         if (nd->nd_repstat != 0)
1946                                 error = nd->nd_repstat;
1947                         else
1948                                 error = reterr;
1949                 }
1950                 if (filestruct_locked != 0) {
1951                         /* Roll back local locks. */
1952                         NFSUNLOCKSTATE();
1953                         if (vnode_unlocked == 0) {
1954                                 ASSERT_VOP_ELOCKED(vp, "nfsrv_lockctrl2");
1955                                 vnode_unlocked = 1;
1956                                 NFSVOPUNLOCK(vp);
1957                         }
1958                         nfsrv_locallock_rollback(vp, lfp, p);
1959                         NFSLOCKSTATE();
1960                         nfsrv_unlocklf(lfp);
1961                 }
1962                 NFSUNLOCKSTATE();
1963                 goto out;
1964         }
1965
1966         /*
1967          * Check the nfsrv_getlockfile return.
1968          * Returned -1 if no structure found.
1969          */
1970         if (getlckret == -1) {
1971                 error = NFSERR_EXPIRED;
1972                 /*
1973                  * Called from lockt, so no lock is OK.
1974                  */
1975                 if (new_stp->ls_flags & NFSLCK_TEST) {
1976                         error = 0;
1977                 } else if (new_stp->ls_flags &
1978                     (NFSLCK_CHECK | NFSLCK_SETATTR)) {
1979                         /*
1980                          * Called to check for a lock, OK if the stateid is all
1981                          * 1s or all 0s, but there should be an nfsstate
1982                          * otherwise.
1983                          * (ie. If there is no open, I'll assume no share
1984                          *  deny bits.)
1985                          */
1986                         if (specialid)
1987                                 error = 0;
1988                         else
1989                                 error = NFSERR_BADSTATEID;
1990                 }
1991                 NFSUNLOCKSTATE();
1992                 goto out;
1993         }
1994
1995         /*
1996          * For NFSLCK_CHECK and NFSLCK_LOCK, test for a share conflict.
1997          * For NFSLCK_CHECK, allow a read if write access is granted,
1998          * but check for a deny. For NFSLCK_LOCK, require correct access,
1999          * which implies a conflicting deny can't exist.
2000          */
2001         if (new_stp->ls_flags & (NFSLCK_CHECK | NFSLCK_LOCK)) {
2002             /*
2003              * Four kinds of state id:
2004              * - specialid (all 0s or all 1s), only for NFSLCK_CHECK
2005              * - stateid for an open
2006              * - stateid for a delegation
2007              * - stateid for a lock owner
2008              */
2009             if (!specialid) {
2010                 if (stp->ls_flags & (NFSLCK_DELEGREAD | NFSLCK_DELEGWRITE)) {
2011                     delegation = 1;
2012                     mystp = stp;
2013                     nfsrv_delaydelegtimeout(stp);
2014                 } else if (stp->ls_flags & NFSLCK_OPEN) {
2015                     mystp = stp;
2016                 } else {
2017                     mystp = stp->ls_openstp;
2018                 }
2019                 /*
2020                  * If locking or checking, require correct access
2021                  * bit set.
2022                  */
2023                 if (((new_stp->ls_flags & NFSLCK_LOCK) &&
2024                      !((new_lop->lo_flags >> NFSLCK_LOCKSHIFT) &
2025                        mystp->ls_flags & NFSLCK_ACCESSBITS)) ||
2026                     ((new_stp->ls_flags & (NFSLCK_CHECK|NFSLCK_READACCESS)) ==
2027                       (NFSLCK_CHECK | NFSLCK_READACCESS) &&
2028                      !(mystp->ls_flags & NFSLCK_READACCESS) &&
2029                      nfsrv_allowreadforwriteopen == 0) ||
2030                     ((new_stp->ls_flags & (NFSLCK_CHECK|NFSLCK_WRITEACCESS)) ==
2031                       (NFSLCK_CHECK | NFSLCK_WRITEACCESS) &&
2032                      !(mystp->ls_flags & NFSLCK_WRITEACCESS))) {
2033                         if (filestruct_locked != 0) {
2034                                 /* Roll back local locks. */
2035                                 NFSUNLOCKSTATE();
2036                                 if (vnode_unlocked == 0) {
2037                                         ASSERT_VOP_ELOCKED(vp,
2038                                             "nfsrv_lockctrl3");
2039                                         vnode_unlocked = 1;
2040                                         NFSVOPUNLOCK(vp);
2041                                 }
2042                                 nfsrv_locallock_rollback(vp, lfp, p);
2043                                 NFSLOCKSTATE();
2044                                 nfsrv_unlocklf(lfp);
2045                         }
2046                         NFSUNLOCKSTATE();
2047                         error = NFSERR_OPENMODE;
2048                         goto out;
2049                 }
2050             } else
2051                 mystp = NULL;
2052             if ((new_stp->ls_flags & NFSLCK_CHECK) && !delegation) {
2053                 /*
2054                  * Check for a conflicting deny bit.
2055                  */
2056                 LIST_FOREACH(tstp, &lfp->lf_open, ls_file) {
2057                     if (tstp != mystp) {
2058                         bits = tstp->ls_flags;
2059                         bits >>= NFSLCK_SHIFT;
2060                         if (new_stp->ls_flags & bits & NFSLCK_ACCESSBITS) {
2061                             KASSERT(vnode_unlocked == 0,
2062                                 ("nfsrv_lockctrl: vnode unlocked1"));
2063                             ret = nfsrv_clientconflict(tstp->ls_clp, &haslock,
2064                                 vp, p);
2065                             if (ret == 1) {
2066                                 /*
2067                                 * nfsrv_clientconflict unlocks state
2068                                  * when it returns non-zero.
2069                                  */
2070                                 lckstp = NULL;
2071                                 goto tryagain;
2072                             }
2073                             if (ret == 0)
2074                                 NFSUNLOCKSTATE();
2075                             if (ret == 2)
2076                                 error = NFSERR_PERM;
2077                             else
2078                                 error = NFSERR_OPENMODE;
2079                             goto out;
2080                         }
2081                     }
2082                 }
2083
2084                 /* We're outta here */
2085                 NFSUNLOCKSTATE();
2086                 goto out;
2087             }
2088         }
2089
2090         /*
2091          * For setattr, just get rid of all the Delegations for other clients.
2092          */
2093         if (new_stp->ls_flags & NFSLCK_SETATTR) {
2094                 KASSERT(vnode_unlocked == 0,
2095                     ("nfsrv_lockctrl: vnode unlocked2"));
2096                 ret = nfsrv_cleandeleg(vp, lfp, clp, &haslock, p);
2097                 if (ret) {
2098                         /*
2099                          * nfsrv_cleandeleg() unlocks state when it
2100                          * returns non-zero.
2101                          */
2102                         if (ret == -1) {
2103                                 lckstp = NULL;
2104                                 goto tryagain;
2105                         }
2106                         error = ret;
2107                         goto out;
2108                 }
2109                 if (!(new_stp->ls_flags & NFSLCK_CHECK) ||
2110                     (LIST_EMPTY(&lfp->lf_open) && LIST_EMPTY(&lfp->lf_lock) &&
2111                      LIST_EMPTY(&lfp->lf_deleg))) {
2112                         NFSUNLOCKSTATE();
2113                         goto out;
2114                 }
2115         }
2116
2117         /*
2118          * Check for a conflicting delegation. If one is found, call
2119          * nfsrv_delegconflict() to handle it. If the v4root lock hasn't
2120          * been set yet, it will get the lock. Otherwise, it will recall
2121          * the delegation. Then, we try try again...
2122          * I currently believe the conflict algorithm to be:
2123          * For Lock Ops (Lock/LockT/LockU)
2124          * - there is a conflict iff a different client has a write delegation
2125          * For Reading (Read Op)
2126          * - there is a conflict iff a different client has a write delegation
2127          *   (the specialids are always a different client)
2128          * For Writing (Write/Setattr of size)
2129          * - there is a conflict if a different client has any delegation
2130          * - there is a conflict if the same client has a read delegation
2131          *   (I don't understand why this isn't allowed, but that seems to be
2132          *    the current consensus?)
2133          */
2134         tstp = LIST_FIRST(&lfp->lf_deleg);
2135         while (tstp != LIST_END(&lfp->lf_deleg)) {
2136             nstp = LIST_NEXT(tstp, ls_file);
2137             if ((((new_stp->ls_flags&(NFSLCK_LOCK|NFSLCK_UNLOCK|NFSLCK_TEST))||
2138                  ((new_stp->ls_flags & NFSLCK_CHECK) &&
2139                   (new_lop->lo_flags & NFSLCK_READ))) &&
2140                   clp != tstp->ls_clp &&
2141                  (tstp->ls_flags & NFSLCK_DELEGWRITE)) ||
2142                  ((new_stp->ls_flags & NFSLCK_CHECK) &&
2143                    (new_lop->lo_flags & NFSLCK_WRITE) &&
2144                   (clp != tstp->ls_clp ||
2145                    (tstp->ls_flags & NFSLCK_DELEGREAD)))) {
2146                 ret = 0;
2147                 if (filestruct_locked != 0) {
2148                         /* Roll back local locks. */
2149                         NFSUNLOCKSTATE();
2150                         if (vnode_unlocked == 0) {
2151                                 ASSERT_VOP_ELOCKED(vp, "nfsrv_lockctrl4");
2152                                 NFSVOPUNLOCK(vp);
2153                         }
2154                         nfsrv_locallock_rollback(vp, lfp, p);
2155                         NFSLOCKSTATE();
2156                         nfsrv_unlocklf(lfp);
2157                         NFSUNLOCKSTATE();
2158                         NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
2159                         vnode_unlocked = 0;
2160                         if (VN_IS_DOOMED(vp))
2161                                 ret = NFSERR_SERVERFAULT;
2162                         NFSLOCKSTATE();
2163                 }
2164                 if (ret == 0)
2165                         ret = nfsrv_delegconflict(tstp, &haslock, p, vp);
2166                 if (ret) {
2167                     /*
2168                      * nfsrv_delegconflict unlocks state when it
2169                      * returns non-zero, which it always does.
2170                      */
2171                     if (other_lop) {
2172                         free(other_lop, M_NFSDLOCK);
2173                         other_lop = NULL;
2174                     }
2175                     if (ret == -1) {
2176                         lckstp = NULL;
2177                         goto tryagain;
2178                     }
2179                     error = ret;
2180                     goto out;
2181                 }
2182                 /* Never gets here. */
2183             }
2184             tstp = nstp;
2185         }
2186
2187         /*
2188          * Handle the unlock case by calling nfsrv_updatelock().
2189          * (Should I have done some access checking above for unlock? For now,
2190          *  just let it happen.)
2191          */
2192         if (new_stp->ls_flags & NFSLCK_UNLOCK) {
2193                 first = new_lop->lo_first;
2194                 end = new_lop->lo_end;
2195                 nfsrv_updatelock(stp, new_lopp, &other_lop, lfp);
2196                 stateidp->seqid = ++(stp->ls_stateid.seqid);
2197                 if ((nd->nd_flag & ND_NFSV41) != 0 && stateidp->seqid == 0)
2198                         stateidp->seqid = stp->ls_stateid.seqid = 1;
2199                 stateidp->other[0] = stp->ls_stateid.other[0];
2200                 stateidp->other[1] = stp->ls_stateid.other[1];
2201                 stateidp->other[2] = stp->ls_stateid.other[2];
2202                 if (filestruct_locked != 0) {
2203                         NFSUNLOCKSTATE();
2204                         if (vnode_unlocked == 0) {
2205                                 ASSERT_VOP_ELOCKED(vp, "nfsrv_lockctrl5");
2206                                 vnode_unlocked = 1;
2207                                 NFSVOPUNLOCK(vp);
2208                         }
2209                         /* Update the local locks. */
2210                         nfsrv_localunlock(vp, lfp, first, end, p);
2211                         NFSLOCKSTATE();
2212                         nfsrv_unlocklf(lfp);
2213                 }
2214                 NFSUNLOCKSTATE();
2215                 goto out;
2216         }
2217
2218         /*
2219          * Search for a conflicting lock. A lock conflicts if:
2220          * - the lock range overlaps and
2221          * - at least one lock is a write lock and
2222          * - it is not owned by the same lock owner
2223          */
2224         if (!delegation) {
2225           LIST_FOREACH(lop, &lfp->lf_lock, lo_lckfile) {
2226             if (new_lop->lo_end > lop->lo_first &&
2227                 new_lop->lo_first < lop->lo_end &&
2228                 (new_lop->lo_flags == NFSLCK_WRITE ||
2229                  lop->lo_flags == NFSLCK_WRITE) &&
2230                 lckstp != lop->lo_stp &&
2231                 (clp != lop->lo_stp->ls_clp ||
2232                  lckstp->ls_ownerlen != lop->lo_stp->ls_ownerlen ||
2233                  NFSBCMP(lckstp->ls_owner, lop->lo_stp->ls_owner,
2234                     lckstp->ls_ownerlen))) {
2235                 if (other_lop) {
2236                     free(other_lop, M_NFSDLOCK);
2237                     other_lop = NULL;
2238                 }
2239                 if (vnode_unlocked != 0)
2240                     ret = nfsrv_clientconflict(lop->lo_stp->ls_clp, &haslock,
2241                         NULL, p);
2242                 else
2243                     ret = nfsrv_clientconflict(lop->lo_stp->ls_clp, &haslock,
2244                         vp, p);
2245                 if (ret == 1) {
2246                     if (filestruct_locked != 0) {
2247                         if (vnode_unlocked == 0) {
2248                                 ASSERT_VOP_ELOCKED(vp, "nfsrv_lockctrl6");
2249                                 NFSVOPUNLOCK(vp);
2250                         }
2251                         /* Roll back local locks. */
2252                         nfsrv_locallock_rollback(vp, lfp, p);
2253                         NFSLOCKSTATE();
2254                         nfsrv_unlocklf(lfp);
2255                         NFSUNLOCKSTATE();
2256                         NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
2257                         vnode_unlocked = 0;
2258                         if (VN_IS_DOOMED(vp)) {
2259                                 error = NFSERR_SERVERFAULT;
2260                                 goto out;
2261                         }
2262                     }
2263                     /*
2264                      * nfsrv_clientconflict() unlocks state when it
2265                      * returns non-zero.
2266                      */
2267                     lckstp = NULL;
2268                     goto tryagain;
2269                 }
2270                 /*
2271                  * Found a conflicting lock, so record the conflict and
2272                  * return the error.
2273                  */
2274                 if (cfp != NULL && ret == 0) {
2275                     cfp->cl_clientid.lval[0]=lop->lo_stp->ls_stateid.other[0];
2276                     cfp->cl_clientid.lval[1]=lop->lo_stp->ls_stateid.other[1];
2277                     cfp->cl_first = lop->lo_first;
2278                     cfp->cl_end = lop->lo_end;
2279                     cfp->cl_flags = lop->lo_flags;
2280                     cfp->cl_ownerlen = lop->lo_stp->ls_ownerlen;
2281                     NFSBCOPY(lop->lo_stp->ls_owner, cfp->cl_owner,
2282                         cfp->cl_ownerlen);
2283                 }
2284                 if (ret == 2)
2285                     error = NFSERR_PERM;
2286                 else if (new_stp->ls_flags & NFSLCK_RECLAIM)
2287                     error = NFSERR_RECLAIMCONFLICT;
2288                 else if (new_stp->ls_flags & NFSLCK_CHECK)
2289                     error = NFSERR_LOCKED;
2290                 else
2291                     error = NFSERR_DENIED;
2292                 if (filestruct_locked != 0 && ret == 0) {
2293                         /* Roll back local locks. */
2294                         NFSUNLOCKSTATE();
2295                         if (vnode_unlocked == 0) {
2296                                 ASSERT_VOP_ELOCKED(vp, "nfsrv_lockctrl7");
2297                                 vnode_unlocked = 1;
2298                                 NFSVOPUNLOCK(vp);
2299                         }
2300                         nfsrv_locallock_rollback(vp, lfp, p);
2301                         NFSLOCKSTATE();
2302                         nfsrv_unlocklf(lfp);
2303                 }
2304                 if (ret == 0)
2305                         NFSUNLOCKSTATE();
2306                 goto out;
2307             }
2308           }
2309         }
2310
2311         /*
2312          * We only get here if there was no lock that conflicted.
2313          */
2314         if (new_stp->ls_flags & (NFSLCK_TEST | NFSLCK_CHECK)) {
2315                 NFSUNLOCKSTATE();
2316                 goto out;
2317         }
2318
2319         /*
2320          * We only get here when we are creating or modifying a lock.
2321          * There are two variants:
2322          * - exist_lock_owner where lock_owner exists
2323          * - open_to_lock_owner with new lock_owner
2324          */
2325         first = new_lop->lo_first;
2326         end = new_lop->lo_end;
2327         lock_flags = new_lop->lo_flags;
2328         if (!(new_stp->ls_flags & NFSLCK_OPENTOLOCK)) {
2329                 nfsrv_updatelock(lckstp, new_lopp, &other_lop, lfp);
2330                 stateidp->seqid = ++(lckstp->ls_stateid.seqid);
2331                 if ((nd->nd_flag & ND_NFSV41) != 0 && stateidp->seqid == 0)
2332                         stateidp->seqid = lckstp->ls_stateid.seqid = 1;
2333                 stateidp->other[0] = lckstp->ls_stateid.other[0];
2334                 stateidp->other[1] = lckstp->ls_stateid.other[1];
2335                 stateidp->other[2] = lckstp->ls_stateid.other[2];
2336         } else {
2337                 /*
2338                  * The new open_to_lock_owner case.
2339                  * Link the new nfsstate into the lists.
2340                  */
2341                 new_stp->ls_seq = new_stp->ls_opentolockseq;
2342                 nfsrvd_refcache(new_stp->ls_op);
2343                 stateidp->seqid = new_stp->ls_stateid.seqid = 1;
2344                 stateidp->other[0] = new_stp->ls_stateid.other[0] =
2345                     clp->lc_clientid.lval[0];
2346                 stateidp->other[1] = new_stp->ls_stateid.other[1] =
2347                     clp->lc_clientid.lval[1];
2348                 stateidp->other[2] = new_stp->ls_stateid.other[2] =
2349                     nfsrv_nextstateindex(clp);
2350                 new_stp->ls_clp = clp;
2351                 LIST_INIT(&new_stp->ls_lock);
2352                 new_stp->ls_openstp = stp;
2353                 new_stp->ls_lfp = lfp;
2354                 nfsrv_insertlock(new_lop, (struct nfslock *)new_stp, new_stp,
2355                     lfp);
2356                 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_stp->ls_stateid),
2357                     new_stp, ls_hash);
2358                 LIST_INSERT_HEAD(&stp->ls_open, new_stp, ls_list);
2359                 *new_lopp = NULL;
2360                 *new_stpp = NULL;
2361                 nfsstatsv1.srvlockowners++;
2362                 nfsrv_openpluslock++;
2363         }
2364         if (filestruct_locked != 0) {
2365                 NFSUNLOCKSTATE();
2366                 nfsrv_locallock_commit(lfp, lock_flags, first, end);
2367                 NFSLOCKSTATE();
2368                 nfsrv_unlocklf(lfp);
2369         }
2370         NFSUNLOCKSTATE();
2371
2372 out:
2373         if (haslock) {
2374                 NFSLOCKV4ROOTMUTEX();
2375                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
2376                 NFSUNLOCKV4ROOTMUTEX();
2377         }
2378         if (vnode_unlocked != 0) {
2379                 NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
2380                 if (error == 0 && VN_IS_DOOMED(vp))
2381                         error = NFSERR_SERVERFAULT;
2382         }
2383         if (other_lop)
2384                 free(other_lop, M_NFSDLOCK);
2385         NFSEXITCODE2(error, nd);
2386         return (error);
2387 }
2388
2389 /*
2390  * Check for state errors for Open.
2391  * repstat is passed back out as an error if more critical errors
2392  * are not detected.
2393  */
2394 int
2395 nfsrv_opencheck(nfsquad_t clientid, nfsv4stateid_t *stateidp,
2396     struct nfsstate *new_stp, vnode_t vp, struct nfsrv_descript *nd,
2397     NFSPROC_T *p, int repstat)
2398 {
2399         struct nfsstate *stp, *nstp;
2400         struct nfsclient *clp;
2401         struct nfsstate *ownerstp;
2402         struct nfslockfile *lfp, *new_lfp;
2403         int error = 0, haslock = 0, ret, readonly = 0, getfhret = 0;
2404
2405         if ((new_stp->ls_flags & NFSLCK_SHAREBITS) == NFSLCK_READACCESS)
2406                 readonly = 1;
2407         /*
2408          * Check for restart conditions (client and server).
2409          */
2410         error = nfsrv_checkrestart(clientid, new_stp->ls_flags,
2411                 &new_stp->ls_stateid, 0);
2412         if (error)
2413                 goto out;
2414
2415         /*
2416          * Check for state resource limit exceeded.
2417          * Technically this should be SMP protected, but the worst
2418          * case error is "out by one or two" on the count when it
2419          * returns NFSERR_RESOURCE and the limit is just a rather
2420          * arbitrary high water mark, so no harm is done.
2421          */
2422         if (nfsrv_openpluslock > nfsrv_v4statelimit) {
2423                 error = NFSERR_RESOURCE;
2424                 goto out;
2425         }
2426
2427 tryagain:
2428         new_lfp = malloc(sizeof (struct nfslockfile),
2429             M_NFSDLOCKFILE, M_WAITOK);
2430         if (vp)
2431                 getfhret = nfsrv_getlockfh(vp, new_stp->ls_flags, new_lfp,
2432                     NULL, p);
2433         NFSLOCKSTATE();
2434         /*
2435          * Get the nfsclient structure.
2436          */
2437         error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
2438             (nfsquad_t)((u_quad_t)0), 0, nd, p);
2439
2440         /*
2441          * Look up the open owner. See if it needs confirmation and
2442          * check the seq#, as required.
2443          */
2444         if (!error)
2445                 nfsrv_getowner(&clp->lc_open, new_stp, &ownerstp);
2446
2447         if (!error && ownerstp) {
2448                 error = nfsrv_checkseqid(nd, new_stp->ls_seq, ownerstp,
2449                     new_stp->ls_op);
2450                 /*
2451                  * If the OpenOwner hasn't been confirmed, assume the
2452                  * old one was a replay and this one is ok.
2453                  * See: RFC3530 Sec. 14.2.18.
2454                  */
2455                 if (error == NFSERR_BADSEQID &&
2456                     (ownerstp->ls_flags & NFSLCK_NEEDSCONFIRM))
2457                         error = 0;
2458         }
2459
2460         /*
2461          * Check for grace.
2462          */
2463         if (!error)
2464                 error = nfsrv_checkgrace(nd, clp, new_stp->ls_flags);
2465         if ((new_stp->ls_flags & NFSLCK_RECLAIM) && !error &&
2466                 nfsrv_checkstable(clp))
2467                 error = NFSERR_NOGRACE;
2468
2469         /*
2470          * If none of the above errors occurred, let repstat be
2471          * returned.
2472          */
2473         if (repstat && !error)
2474                 error = repstat;
2475         if (error) {
2476                 NFSUNLOCKSTATE();
2477                 if (haslock) {
2478                         NFSLOCKV4ROOTMUTEX();
2479                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
2480                         NFSUNLOCKV4ROOTMUTEX();
2481                 }
2482                 free(new_lfp, M_NFSDLOCKFILE);
2483                 goto out;
2484         }
2485
2486         /*
2487          * If vp == NULL, the file doesn't exist yet, so return ok.
2488          * (This always happens on the first pass, so haslock must be 0.)
2489          */
2490         if (vp == NULL) {
2491                 NFSUNLOCKSTATE();
2492                 free(new_lfp, M_NFSDLOCKFILE);
2493                 goto out;
2494         }
2495
2496         /*
2497          * Get the structure for the underlying file.
2498          */
2499         if (getfhret)
2500                 error = getfhret;
2501         else
2502                 error = nfsrv_getlockfile(new_stp->ls_flags, &new_lfp, &lfp,
2503                     NULL, 0);
2504         if (new_lfp)
2505                 free(new_lfp, M_NFSDLOCKFILE);
2506         if (error) {
2507                 NFSUNLOCKSTATE();
2508                 if (haslock) {
2509                         NFSLOCKV4ROOTMUTEX();
2510                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
2511                         NFSUNLOCKV4ROOTMUTEX();
2512                 }
2513                 goto out;
2514         }
2515
2516         /*
2517          * Search for a conflicting open/share.
2518          */
2519         if (new_stp->ls_flags & NFSLCK_DELEGCUR) {
2520             /*
2521              * For Delegate_Cur, search for the matching Delegation,
2522              * which indicates no conflict.
2523              * An old delegation should have been recovered by the
2524              * client doing a Claim_DELEGATE_Prev, so I won't let
2525              * it match and return NFSERR_EXPIRED. Should I let it
2526              * match?
2527              */
2528             LIST_FOREACH(stp, &lfp->lf_deleg, ls_file) {
2529                 if (!(stp->ls_flags & NFSLCK_OLDDELEG) &&
2530                     (((nd->nd_flag & ND_NFSV41) != 0 &&
2531                     stateidp->seqid == 0) ||
2532                     stateidp->seqid == stp->ls_stateid.seqid) &&
2533                     !NFSBCMP(stateidp->other, stp->ls_stateid.other,
2534                           NFSX_STATEIDOTHER))
2535                         break;
2536             }
2537             if (stp == LIST_END(&lfp->lf_deleg) ||
2538                 ((new_stp->ls_flags & NFSLCK_WRITEACCESS) &&
2539                  (stp->ls_flags & NFSLCK_DELEGREAD))) {
2540                 NFSUNLOCKSTATE();
2541                 if (haslock) {
2542                         NFSLOCKV4ROOTMUTEX();
2543                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
2544                         NFSUNLOCKV4ROOTMUTEX();
2545                 }
2546                 error = NFSERR_EXPIRED;
2547                 goto out;
2548             }
2549         }
2550
2551         /*
2552          * Check for access/deny bit conflicts. I check for the same
2553          * owner as well, in case the client didn't bother.
2554          */
2555         LIST_FOREACH(stp, &lfp->lf_open, ls_file) {
2556                 if (!(new_stp->ls_flags & NFSLCK_DELEGCUR) &&
2557                     (((new_stp->ls_flags & NFSLCK_ACCESSBITS) &
2558                       ((stp->ls_flags>>NFSLCK_SHIFT) & NFSLCK_ACCESSBITS))||
2559                      ((stp->ls_flags & NFSLCK_ACCESSBITS) &
2560                       ((new_stp->ls_flags>>NFSLCK_SHIFT)&NFSLCK_ACCESSBITS)))){
2561                         ret = nfsrv_clientconflict(stp->ls_clp,&haslock,vp,p);
2562                         if (ret == 1) {
2563                                 /*
2564                                  * nfsrv_clientconflict() unlocks
2565                                  * state when it returns non-zero.
2566                                  */
2567                                 goto tryagain;
2568                         }
2569                         if (ret == 2)
2570                                 error = NFSERR_PERM;
2571                         else if (new_stp->ls_flags & NFSLCK_RECLAIM)
2572                                 error = NFSERR_RECLAIMCONFLICT;
2573                         else
2574                                 error = NFSERR_SHAREDENIED;
2575                         if (ret == 0)
2576                                 NFSUNLOCKSTATE();
2577                         if (haslock) {
2578                                 NFSLOCKV4ROOTMUTEX();
2579                                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
2580                                 NFSUNLOCKV4ROOTMUTEX();
2581                         }
2582                         goto out;
2583                 }
2584         }
2585
2586         /*
2587          * Check for a conflicting delegation. If one is found, call
2588          * nfsrv_delegconflict() to handle it. If the v4root lock hasn't
2589          * been set yet, it will get the lock. Otherwise, it will recall
2590          * the delegation. Then, we try try again...
2591          * (If NFSLCK_DELEGCUR is set, it has a delegation, so there
2592          *  isn't a conflict.)
2593          * I currently believe the conflict algorithm to be:
2594          * For Open with Read Access and Deny None
2595          * - there is a conflict iff a different client has a write delegation
2596          * For Open with other Write Access or any Deny except None
2597          * - there is a conflict if a different client has any delegation
2598          * - there is a conflict if the same client has a read delegation
2599          *   (The current consensus is that this last case should be
2600          *    considered a conflict since the client with a read delegation
2601          *    could have done an Open with ReadAccess and WriteDeny
2602          *    locally and then not have checked for the WriteDeny.)
2603          * Don't check for a Reclaim, since that will be dealt with
2604          * by nfsrv_openctrl().
2605          */
2606         if (!(new_stp->ls_flags &
2607                 (NFSLCK_DELEGPREV | NFSLCK_DELEGCUR | NFSLCK_RECLAIM))) {
2608             stp = LIST_FIRST(&lfp->lf_deleg);
2609             while (stp != LIST_END(&lfp->lf_deleg)) {
2610                 nstp = LIST_NEXT(stp, ls_file);
2611                 if ((readonly && stp->ls_clp != clp &&
2612                        (stp->ls_flags & NFSLCK_DELEGWRITE)) ||
2613                     (!readonly && (stp->ls_clp != clp ||
2614                          (stp->ls_flags & NFSLCK_DELEGREAD)))) {
2615                         ret = nfsrv_delegconflict(stp, &haslock, p, vp);
2616                         if (ret) {
2617                             /*
2618                              * nfsrv_delegconflict() unlocks state
2619                              * when it returns non-zero.
2620                              */
2621                             if (ret == -1)
2622                                 goto tryagain;
2623                             error = ret;
2624                             goto out;
2625                         }
2626                 }
2627                 stp = nstp;
2628             }
2629         }
2630         NFSUNLOCKSTATE();
2631         if (haslock) {
2632                 NFSLOCKV4ROOTMUTEX();
2633                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
2634                 NFSUNLOCKV4ROOTMUTEX();
2635         }
2636
2637 out:
2638         NFSEXITCODE2(error, nd);
2639         return (error);
2640 }
2641
2642 /*
2643  * Open control function to create/update open state for an open.
2644  */
2645 int
2646 nfsrv_openctrl(struct nfsrv_descript *nd, vnode_t vp,
2647     struct nfsstate **new_stpp, nfsquad_t clientid, nfsv4stateid_t *stateidp,
2648     nfsv4stateid_t *delegstateidp, u_int32_t *rflagsp, struct nfsexstuff *exp,
2649     NFSPROC_T *p, u_quad_t filerev)
2650 {
2651         struct nfsstate *new_stp = *new_stpp;
2652         struct nfsstate *stp, *nstp;
2653         struct nfsstate *openstp = NULL, *new_open, *ownerstp, *new_deleg;
2654         struct nfslockfile *lfp, *new_lfp;
2655         struct nfsclient *clp;
2656         int error = 0, haslock = 0, ret, delegate = 1, writedeleg = 1;
2657         int readonly = 0, cbret = 1, getfhret = 0;
2658         int gotstate = 0, len = 0;
2659         u_char *clidp = NULL;
2660
2661         if ((new_stp->ls_flags & NFSLCK_SHAREBITS) == NFSLCK_READACCESS)
2662                 readonly = 1;
2663         /*
2664          * Check for restart conditions (client and server).
2665          * (Paranoia, should have been detected by nfsrv_opencheck().)
2666          * If an error does show up, return NFSERR_EXPIRED, since the
2667          * the seqid# has already been incremented.
2668          */
2669         error = nfsrv_checkrestart(clientid, new_stp->ls_flags,
2670             &new_stp->ls_stateid, 0);
2671         if (error) {
2672                 printf("Nfsd: openctrl unexpected restart err=%d\n",
2673                     error);
2674                 error = NFSERR_EXPIRED;
2675                 goto out;
2676         }
2677
2678         clidp = malloc(NFSV4_OPAQUELIMIT, M_TEMP, M_WAITOK);
2679 tryagain:
2680         new_lfp = malloc(sizeof (struct nfslockfile),
2681             M_NFSDLOCKFILE, M_WAITOK);
2682         new_open = malloc(sizeof (struct nfsstate),
2683             M_NFSDSTATE, M_WAITOK);
2684         new_deleg = malloc(sizeof (struct nfsstate),
2685             M_NFSDSTATE, M_WAITOK);
2686         getfhret = nfsrv_getlockfh(vp, new_stp->ls_flags, new_lfp,
2687             NULL, p);
2688         NFSLOCKSTATE();
2689         /*
2690          * Get the client structure. Since the linked lists could be changed
2691          * by other nfsd processes if this process does a tsleep(), one of
2692          * two things must be done.
2693          * 1 - don't tsleep()
2694          * or
2695          * 2 - get the nfsv4_lock() { indicated by haslock == 1 }
2696          *     before using the lists, since this lock stops the other
2697          *     nfsd. This should only be used for rare cases, since it
2698          *     essentially single threads the nfsd.
2699          *     At this time, it is only done for cases where the stable
2700          *     storage file must be written prior to completion of state
2701          *     expiration.
2702          */
2703         error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
2704             (nfsquad_t)((u_quad_t)0), 0, nd, p);
2705         if (!error && (clp->lc_flags & LCL_NEEDSCBNULL) &&
2706             clp->lc_program) {
2707                 /*
2708                  * This happens on the first open for a client
2709                  * that supports callbacks.
2710                  */
2711                 NFSUNLOCKSTATE();
2712                 /*
2713                  * Although nfsrv_docallback() will sleep, clp won't
2714                  * go away, since they are only removed when the
2715                  * nfsv4_lock() has blocked the nfsd threads. The
2716                  * fields in clp can change, but having multiple
2717                  * threads do this Null callback RPC should be
2718                  * harmless.
2719                  */
2720                 cbret = nfsrv_docallback(clp, NFSV4PROC_CBNULL,
2721                     NULL, 0, NULL, NULL, NULL, 0, p);
2722                 NFSLOCKSTATE();
2723                 clp->lc_flags &= ~LCL_NEEDSCBNULL;
2724                 if (!cbret)
2725                         clp->lc_flags |= LCL_CALLBACKSON;
2726         }
2727
2728         /*
2729          * Look up the open owner. See if it needs confirmation and
2730          * check the seq#, as required.
2731          */
2732         if (!error)
2733                 nfsrv_getowner(&clp->lc_open, new_stp, &ownerstp);
2734
2735         if (error) {
2736                 NFSUNLOCKSTATE();
2737                 printf("Nfsd: openctrl unexpected state err=%d\n",
2738                         error);
2739                 free(new_lfp, M_NFSDLOCKFILE);
2740                 free(new_open, M_NFSDSTATE);
2741                 free(new_deleg, M_NFSDSTATE);
2742                 if (haslock) {
2743                         NFSLOCKV4ROOTMUTEX();
2744                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
2745                         NFSUNLOCKV4ROOTMUTEX();
2746                 }
2747                 error = NFSERR_EXPIRED;
2748                 goto out;
2749         }
2750
2751         if (new_stp->ls_flags & NFSLCK_RECLAIM)
2752                 nfsrv_markstable(clp);
2753
2754         /*
2755          * Get the structure for the underlying file.
2756          */
2757         if (getfhret)
2758                 error = getfhret;
2759         else
2760                 error = nfsrv_getlockfile(new_stp->ls_flags, &new_lfp, &lfp,
2761                     NULL, 0);
2762         if (new_lfp)
2763                 free(new_lfp, M_NFSDLOCKFILE);
2764         if (error) {
2765                 NFSUNLOCKSTATE();
2766                 printf("Nfsd openctrl unexpected getlockfile err=%d\n",
2767                     error);
2768                 free(new_open, M_NFSDSTATE);
2769                 free(new_deleg, M_NFSDSTATE);
2770                 if (haslock) {
2771                         NFSLOCKV4ROOTMUTEX();
2772                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
2773                         NFSUNLOCKV4ROOTMUTEX();
2774                 }
2775                 goto out;
2776         }
2777
2778         /*
2779          * Search for a conflicting open/share.
2780          */
2781         if (new_stp->ls_flags & NFSLCK_DELEGCUR) {
2782             /*
2783              * For Delegate_Cur, search for the matching Delegation,
2784              * which indicates no conflict.
2785              * An old delegation should have been recovered by the
2786              * client doing a Claim_DELEGATE_Prev, so I won't let
2787              * it match and return NFSERR_EXPIRED. Should I let it
2788              * match?
2789              */
2790             LIST_FOREACH(stp, &lfp->lf_deleg, ls_file) {
2791                 if (!(stp->ls_flags & NFSLCK_OLDDELEG) &&
2792                     (((nd->nd_flag & ND_NFSV41) != 0 &&
2793                     stateidp->seqid == 0) ||
2794                     stateidp->seqid == stp->ls_stateid.seqid) &&
2795                     !NFSBCMP(stateidp->other, stp->ls_stateid.other,
2796                         NFSX_STATEIDOTHER))
2797                         break;
2798             }
2799             if (stp == LIST_END(&lfp->lf_deleg) ||
2800                 ((new_stp->ls_flags & NFSLCK_WRITEACCESS) &&
2801                  (stp->ls_flags & NFSLCK_DELEGREAD))) {
2802                 NFSUNLOCKSTATE();
2803                 printf("Nfsd openctrl unexpected expiry\n");
2804                 free(new_open, M_NFSDSTATE);
2805                 free(new_deleg, M_NFSDSTATE);
2806                 if (haslock) {
2807                         NFSLOCKV4ROOTMUTEX();
2808                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
2809                         NFSUNLOCKV4ROOTMUTEX();
2810                 }
2811                 error = NFSERR_EXPIRED;
2812                 goto out;
2813             }
2814
2815             /*
2816              * Don't issue a Delegation, since one already exists and
2817              * delay delegation timeout, as required.
2818              */
2819             delegate = 0;
2820             nfsrv_delaydelegtimeout(stp);
2821         }
2822
2823         /*
2824          * Check for access/deny bit conflicts. I also check for the
2825          * same owner, since the client might not have bothered to check.
2826          * Also, note an open for the same file and owner, if found,
2827          * which is all we do here for Delegate_Cur, since conflict
2828          * checking is already done.
2829          */
2830         LIST_FOREACH(stp, &lfp->lf_open, ls_file) {
2831                 if (ownerstp && stp->ls_openowner == ownerstp)
2832                         openstp = stp;
2833                 if (!(new_stp->ls_flags & NFSLCK_DELEGCUR)) {
2834                     /*
2835                      * If another client has the file open, the only
2836                      * delegation that can be issued is a Read delegation
2837                      * and only if it is a Read open with Deny none.
2838                      */
2839                     if (clp != stp->ls_clp) {
2840                         if ((stp->ls_flags & NFSLCK_SHAREBITS) ==
2841                             NFSLCK_READACCESS)
2842                             writedeleg = 0;
2843                         else
2844                             delegate = 0;
2845                     }
2846                     if(((new_stp->ls_flags & NFSLCK_ACCESSBITS) &
2847                         ((stp->ls_flags>>NFSLCK_SHIFT) & NFSLCK_ACCESSBITS))||
2848                        ((stp->ls_flags & NFSLCK_ACCESSBITS) &
2849                         ((new_stp->ls_flags>>NFSLCK_SHIFT)&NFSLCK_ACCESSBITS))){
2850                         ret = nfsrv_clientconflict(stp->ls_clp,&haslock,vp,p);
2851                         if (ret == 1) {
2852                                 /*
2853                                  * nfsrv_clientconflict() unlocks state
2854                                  * when it returns non-zero.
2855                                  */
2856                                 free(new_open, M_NFSDSTATE);
2857                                 free(new_deleg, M_NFSDSTATE);
2858                                 openstp = NULL;
2859                                 goto tryagain;
2860                         }
2861                         if (ret == 2)
2862                                 error = NFSERR_PERM;
2863                         else if (new_stp->ls_flags & NFSLCK_RECLAIM)
2864                                 error = NFSERR_RECLAIMCONFLICT;
2865                         else
2866                                 error = NFSERR_SHAREDENIED;
2867                         if (ret == 0)
2868                                 NFSUNLOCKSTATE();
2869                         if (haslock) {
2870                                 NFSLOCKV4ROOTMUTEX();
2871                                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
2872                                 NFSUNLOCKV4ROOTMUTEX();
2873                         }
2874                         free(new_open, M_NFSDSTATE);
2875                         free(new_deleg, M_NFSDSTATE);
2876                         printf("nfsd openctrl unexpected client cnfl\n");
2877                         goto out;
2878                     }
2879                 }
2880         }
2881
2882         /*
2883          * Check for a conflicting delegation. If one is found, call
2884          * nfsrv_delegconflict() to handle it. If the v4root lock hasn't
2885          * been set yet, it will get the lock. Otherwise, it will recall
2886          * the delegation. Then, we try try again...
2887          * (If NFSLCK_DELEGCUR is set, it has a delegation, so there
2888          *  isn't a conflict.)
2889          * I currently believe the conflict algorithm to be:
2890          * For Open with Read Access and Deny None
2891          * - there is a conflict iff a different client has a write delegation
2892          * For Open with other Write Access or any Deny except None
2893          * - there is a conflict if a different client has any delegation
2894          * - there is a conflict if the same client has a read delegation
2895          *   (The current consensus is that this last case should be
2896          *    considered a conflict since the client with a read delegation
2897          *    could have done an Open with ReadAccess and WriteDeny
2898          *    locally and then not have checked for the WriteDeny.)
2899          */
2900         if (!(new_stp->ls_flags & (NFSLCK_DELEGPREV | NFSLCK_DELEGCUR))) {
2901             stp = LIST_FIRST(&lfp->lf_deleg);
2902             while (stp != LIST_END(&lfp->lf_deleg)) {
2903                 nstp = LIST_NEXT(stp, ls_file);
2904                 if (stp->ls_clp != clp && (stp->ls_flags & NFSLCK_DELEGREAD))
2905                         writedeleg = 0;
2906                 else
2907                         delegate = 0;
2908                 if ((readonly && stp->ls_clp != clp &&
2909                        (stp->ls_flags & NFSLCK_DELEGWRITE)) ||
2910                     (!readonly && (stp->ls_clp != clp ||
2911                          (stp->ls_flags & NFSLCK_DELEGREAD)))) {
2912                     if (new_stp->ls_flags & NFSLCK_RECLAIM) {
2913                         delegate = 2;
2914                     } else {
2915                         ret = nfsrv_delegconflict(stp, &haslock, p, vp);
2916                         if (ret) {
2917                             /*
2918                              * nfsrv_delegconflict() unlocks state
2919                              * when it returns non-zero.
2920                              */
2921                             printf("Nfsd openctrl unexpected deleg cnfl\n");
2922                             free(new_open, M_NFSDSTATE);
2923                             free(new_deleg, M_NFSDSTATE);
2924                             if (ret == -1) {
2925                                 openstp = NULL;
2926                                 goto tryagain;
2927                             }
2928                             error = ret;
2929                             goto out;
2930                         }
2931                     }
2932                 }
2933                 stp = nstp;
2934             }
2935         }
2936
2937         /*
2938          * We only get here if there was no open that conflicted.
2939          * If an open for the owner exists, or in the access/deny bits.
2940          * Otherwise it is a new open. If the open_owner hasn't been
2941          * confirmed, replace the open with the new one needing confirmation,
2942          * otherwise add the open.
2943          */
2944         if (new_stp->ls_flags & NFSLCK_DELEGPREV) {
2945             /*
2946              * Handle NFSLCK_DELEGPREV by searching the old delegations for
2947              * a match. If found, just move the old delegation to the current
2948              * delegation list and issue open. If not found, return
2949              * NFSERR_EXPIRED.
2950              */
2951             LIST_FOREACH(stp, &clp->lc_olddeleg, ls_list) {
2952                 if (stp->ls_lfp == lfp) {
2953                     /* Found it */
2954                     if (stp->ls_clp != clp)
2955                         panic("olddeleg clp");
2956                     LIST_REMOVE(stp, ls_list);
2957                     LIST_REMOVE(stp, ls_hash);
2958                     stp->ls_flags &= ~NFSLCK_OLDDELEG;
2959                     stp->ls_stateid.seqid = delegstateidp->seqid = 1;
2960                     stp->ls_stateid.other[0] = delegstateidp->other[0] =
2961                         clp->lc_clientid.lval[0];
2962                     stp->ls_stateid.other[1] = delegstateidp->other[1] =
2963                         clp->lc_clientid.lval[1];
2964                     stp->ls_stateid.other[2] = delegstateidp->other[2] =
2965                         nfsrv_nextstateindex(clp);
2966                     stp->ls_compref = nd->nd_compref;
2967                     LIST_INSERT_HEAD(&clp->lc_deleg, stp, ls_list);
2968                     LIST_INSERT_HEAD(NFSSTATEHASH(clp,
2969                         stp->ls_stateid), stp, ls_hash);
2970                     if (stp->ls_flags & NFSLCK_DELEGWRITE)
2971                         *rflagsp |= NFSV4OPEN_WRITEDELEGATE;
2972                     else
2973                         *rflagsp |= NFSV4OPEN_READDELEGATE;
2974                     clp->lc_delegtime = NFSD_MONOSEC +
2975                         nfsrv_lease + NFSRV_LEASEDELTA;
2976
2977                     /*
2978                      * Now, do the associated open.
2979                      */
2980                     new_open->ls_stateid.seqid = 1;
2981                     new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
2982                     new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
2983                     new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
2984                     new_open->ls_flags = (new_stp->ls_flags&NFSLCK_DENYBITS)|
2985                         NFSLCK_OPEN;
2986                     if (stp->ls_flags & NFSLCK_DELEGWRITE)
2987                         new_open->ls_flags |= (NFSLCK_READACCESS |
2988                             NFSLCK_WRITEACCESS);
2989                     else
2990                         new_open->ls_flags |= NFSLCK_READACCESS;
2991                     new_open->ls_uid = new_stp->ls_uid;
2992                     new_open->ls_lfp = lfp;
2993                     new_open->ls_clp = clp;
2994                     LIST_INIT(&new_open->ls_open);
2995                     LIST_INSERT_HEAD(&lfp->lf_open, new_open, ls_file);
2996                     LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
2997                         new_open, ls_hash);
2998                     /*
2999                      * and handle the open owner
3000                      */
3001                     if (ownerstp) {
3002                         new_open->ls_openowner = ownerstp;
3003                         LIST_INSERT_HEAD(&ownerstp->ls_open,new_open,ls_list);
3004                     } else {
3005                         new_open->ls_openowner = new_stp;
3006                         new_stp->ls_flags = 0;
3007                         nfsrvd_refcache(new_stp->ls_op);
3008                         new_stp->ls_noopens = 0;
3009                         LIST_INIT(&new_stp->ls_open);
3010                         LIST_INSERT_HEAD(&new_stp->ls_open, new_open, ls_list);
3011                         LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
3012                         *new_stpp = NULL;
3013                         nfsstatsv1.srvopenowners++;
3014                         nfsrv_openpluslock++;
3015                     }
3016                     openstp = new_open;
3017                     new_open = NULL;
3018                     nfsstatsv1.srvopens++;
3019                     nfsrv_openpluslock++;
3020                     break;
3021                 }
3022             }
3023             if (stp == LIST_END(&clp->lc_olddeleg))
3024                 error = NFSERR_EXPIRED;
3025         } else if (new_stp->ls_flags & (NFSLCK_DELEGREAD | NFSLCK_DELEGWRITE)) {
3026             /*
3027              * Scan to see that no delegation for this client and file
3028              * doesn't already exist.
3029              * There also shouldn't yet be an Open for this file and
3030              * openowner.
3031              */
3032             LIST_FOREACH(stp, &lfp->lf_deleg, ls_file) {
3033                 if (stp->ls_clp == clp)
3034                     break;
3035             }
3036             if (stp == LIST_END(&lfp->lf_deleg) && openstp == NULL) {
3037                 /*
3038                  * This is the Claim_Previous case with a delegation
3039                  * type != Delegate_None.
3040                  */
3041                 /*
3042                  * First, add the delegation. (Although we must issue the
3043                  * delegation, we can also ask for an immediate return.)
3044                  */
3045                 new_deleg->ls_stateid.seqid = delegstateidp->seqid = 1;
3046                 new_deleg->ls_stateid.other[0] = delegstateidp->other[0] =
3047                     clp->lc_clientid.lval[0];
3048                 new_deleg->ls_stateid.other[1] = delegstateidp->other[1] =
3049                     clp->lc_clientid.lval[1];
3050                 new_deleg->ls_stateid.other[2] = delegstateidp->other[2] =
3051                     nfsrv_nextstateindex(clp);
3052                 if (new_stp->ls_flags & NFSLCK_DELEGWRITE) {
3053                     new_deleg->ls_flags = (NFSLCK_DELEGWRITE |
3054                         NFSLCK_READACCESS | NFSLCK_WRITEACCESS);
3055                     *rflagsp |= NFSV4OPEN_WRITEDELEGATE;
3056                     nfsrv_writedelegcnt++;
3057                 } else {
3058                     new_deleg->ls_flags = (NFSLCK_DELEGREAD |
3059                         NFSLCK_READACCESS);
3060                     *rflagsp |= NFSV4OPEN_READDELEGATE;
3061                 }
3062                 new_deleg->ls_uid = new_stp->ls_uid;
3063                 new_deleg->ls_lfp = lfp;
3064                 new_deleg->ls_clp = clp;
3065                 new_deleg->ls_filerev = filerev;
3066                 new_deleg->ls_compref = nd->nd_compref;
3067                 LIST_INSERT_HEAD(&lfp->lf_deleg, new_deleg, ls_file);
3068                 LIST_INSERT_HEAD(NFSSTATEHASH(clp,
3069                     new_deleg->ls_stateid), new_deleg, ls_hash);
3070                 LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg, ls_list);
3071                 new_deleg = NULL;
3072                 if (delegate == 2 || nfsrv_issuedelegs == 0 ||
3073                     (clp->lc_flags & (LCL_CALLBACKSON | LCL_CBDOWN)) !=
3074                      LCL_CALLBACKSON ||
3075                     NFSRV_V4DELEGLIMIT(nfsrv_delegatecnt) ||
3076                     !NFSVNO_DELEGOK(vp))
3077                     *rflagsp |= NFSV4OPEN_RECALL;
3078                 nfsstatsv1.srvdelegates++;
3079                 nfsrv_openpluslock++;
3080                 nfsrv_delegatecnt++;
3081
3082                 /*
3083                  * Now, do the associated open.
3084                  */
3085                 new_open->ls_stateid.seqid = 1;
3086                 new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3087                 new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3088                 new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3089                 new_open->ls_flags = (new_stp->ls_flags & NFSLCK_DENYBITS) |
3090                     NFSLCK_OPEN;
3091                 if (new_stp->ls_flags & NFSLCK_DELEGWRITE)
3092                         new_open->ls_flags |= (NFSLCK_READACCESS |
3093                             NFSLCK_WRITEACCESS);
3094                 else
3095                         new_open->ls_flags |= NFSLCK_READACCESS;
3096                 new_open->ls_uid = new_stp->ls_uid;
3097                 new_open->ls_lfp = lfp;
3098                 new_open->ls_clp = clp;
3099                 LIST_INIT(&new_open->ls_open);
3100                 LIST_INSERT_HEAD(&lfp->lf_open, new_open, ls_file);
3101                 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3102                    new_open, ls_hash);
3103                 /*
3104                  * and handle the open owner
3105                  */
3106                 if (ownerstp) {
3107                     new_open->ls_openowner = ownerstp;
3108                     LIST_INSERT_HEAD(&ownerstp->ls_open, new_open, ls_list);
3109                 } else {
3110                     new_open->ls_openowner = new_stp;
3111                     new_stp->ls_flags = 0;
3112                     nfsrvd_refcache(new_stp->ls_op);
3113                     new_stp->ls_noopens = 0;
3114                     LIST_INIT(&new_stp->ls_open);
3115                     LIST_INSERT_HEAD(&new_stp->ls_open, new_open, ls_list);
3116                     LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
3117                     *new_stpp = NULL;
3118                     nfsstatsv1.srvopenowners++;
3119                     nfsrv_openpluslock++;
3120                 }
3121                 openstp = new_open;
3122                 new_open = NULL;
3123                 nfsstatsv1.srvopens++;
3124                 nfsrv_openpluslock++;
3125             } else {
3126                 error = NFSERR_RECLAIMCONFLICT;
3127             }
3128         } else if (ownerstp) {
3129                 if (ownerstp->ls_flags & NFSLCK_NEEDSCONFIRM) {
3130                     /* Replace the open */
3131                     if (ownerstp->ls_op)
3132                         nfsrvd_derefcache(ownerstp->ls_op);
3133                     ownerstp->ls_op = new_stp->ls_op;
3134                     nfsrvd_refcache(ownerstp->ls_op);
3135                     ownerstp->ls_seq = new_stp->ls_seq;
3136                     *rflagsp |= NFSV4OPEN_RESULTCONFIRM;
3137                     stp = LIST_FIRST(&ownerstp->ls_open);
3138                     stp->ls_flags = (new_stp->ls_flags & NFSLCK_SHAREBITS) |
3139                         NFSLCK_OPEN;
3140                     stp->ls_stateid.seqid = 1;
3141                     stp->ls_uid = new_stp->ls_uid;
3142                     if (lfp != stp->ls_lfp) {
3143                         LIST_REMOVE(stp, ls_file);
3144                         LIST_INSERT_HEAD(&lfp->lf_open, stp, ls_file);
3145                         stp->ls_lfp = lfp;
3146                     }
3147                     openstp = stp;
3148                 } else if (openstp) {
3149                     openstp->ls_flags |= (new_stp->ls_flags & NFSLCK_SHAREBITS);
3150                     openstp->ls_stateid.seqid++;
3151                     if ((nd->nd_flag & ND_NFSV41) != 0 &&
3152                         openstp->ls_stateid.seqid == 0)
3153                         openstp->ls_stateid.seqid = 1;
3154
3155                     /*
3156                      * This is where we can choose to issue a delegation.
3157                      */
3158                     if ((new_stp->ls_flags & NFSLCK_WANTNODELEG) != 0)
3159                         *rflagsp |= NFSV4OPEN_WDNOTWANTED;
3160                     else if (nfsrv_issuedelegs == 0)
3161                         *rflagsp |= NFSV4OPEN_WDSUPPFTYPE;
3162                     else if (NFSRV_V4DELEGLIMIT(nfsrv_delegatecnt))
3163                         *rflagsp |= NFSV4OPEN_WDRESOURCE;
3164                     else if (delegate == 0 || writedeleg == 0 ||
3165                         NFSVNO_EXRDONLY(exp) || (readonly != 0 &&
3166                         nfsrv_writedelegifpos == 0) ||
3167                         !NFSVNO_DELEGOK(vp) ||
3168                         (new_stp->ls_flags & NFSLCK_WANTRDELEG) != 0 ||
3169                         (clp->lc_flags & (LCL_CALLBACKSON | LCL_CBDOWN)) !=
3170                          LCL_CALLBACKSON)
3171                         *rflagsp |= NFSV4OPEN_WDCONTENTION;
3172                     else {
3173                         new_deleg->ls_stateid.seqid = delegstateidp->seqid = 1;
3174                         new_deleg->ls_stateid.other[0] = delegstateidp->other[0]
3175                             = clp->lc_clientid.lval[0];
3176                         new_deleg->ls_stateid.other[1] = delegstateidp->other[1]
3177                             = clp->lc_clientid.lval[1];
3178                         new_deleg->ls_stateid.other[2] = delegstateidp->other[2]
3179                             = nfsrv_nextstateindex(clp);
3180                         new_deleg->ls_flags = (NFSLCK_DELEGWRITE |
3181                             NFSLCK_READACCESS | NFSLCK_WRITEACCESS);
3182                         *rflagsp |= NFSV4OPEN_WRITEDELEGATE;
3183                         new_deleg->ls_uid = new_stp->ls_uid;
3184                         new_deleg->ls_lfp = lfp;
3185                         new_deleg->ls_clp = clp;
3186                         new_deleg->ls_filerev = filerev;
3187                         new_deleg->ls_compref = nd->nd_compref;
3188                         nfsrv_writedelegcnt++;
3189                         LIST_INSERT_HEAD(&lfp->lf_deleg, new_deleg, ls_file);
3190                         LIST_INSERT_HEAD(NFSSTATEHASH(clp,
3191                             new_deleg->ls_stateid), new_deleg, ls_hash);
3192                         LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg, ls_list);
3193                         new_deleg = NULL;
3194                         nfsstatsv1.srvdelegates++;
3195                         nfsrv_openpluslock++;
3196                         nfsrv_delegatecnt++;
3197                     }
3198                 } else {
3199                     new_open->ls_stateid.seqid = 1;
3200                     new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3201                     new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3202                     new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3203                     new_open->ls_flags = (new_stp->ls_flags & NFSLCK_SHAREBITS)|
3204                         NFSLCK_OPEN;
3205                     new_open->ls_uid = new_stp->ls_uid;
3206                     new_open->ls_openowner = ownerstp;
3207                     new_open->ls_lfp = lfp;
3208                     new_open->ls_clp = clp;
3209                     LIST_INIT(&new_open->ls_open);
3210                     LIST_INSERT_HEAD(&lfp->lf_open, new_open, ls_file);
3211                     LIST_INSERT_HEAD(&ownerstp->ls_open, new_open, ls_list);
3212                     LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3213                         new_open, ls_hash);
3214                     openstp = new_open;
3215                     new_open = NULL;
3216                     nfsstatsv1.srvopens++;
3217                     nfsrv_openpluslock++;
3218
3219                     /*
3220                      * This is where we can choose to issue a delegation.
3221                      */
3222                     if ((new_stp->ls_flags & NFSLCK_WANTNODELEG) != 0)
3223                         *rflagsp |= NFSV4OPEN_WDNOTWANTED;
3224                     else if (nfsrv_issuedelegs == 0)
3225                         *rflagsp |= NFSV4OPEN_WDSUPPFTYPE;
3226                     else if (NFSRV_V4DELEGLIMIT(nfsrv_delegatecnt))
3227                         *rflagsp |= NFSV4OPEN_WDRESOURCE;
3228                     else if (delegate == 0 || (writedeleg == 0 &&
3229                         readonly == 0) || !NFSVNO_DELEGOK(vp) ||
3230                         (clp->lc_flags & (LCL_CALLBACKSON | LCL_CBDOWN)) !=
3231                          LCL_CALLBACKSON)
3232                         *rflagsp |= NFSV4OPEN_WDCONTENTION;
3233                     else {
3234                         new_deleg->ls_stateid.seqid = delegstateidp->seqid = 1;
3235                         new_deleg->ls_stateid.other[0] = delegstateidp->other[0]
3236                             = clp->lc_clientid.lval[0];
3237                         new_deleg->ls_stateid.other[1] = delegstateidp->other[1]
3238                             = clp->lc_clientid.lval[1];
3239                         new_deleg->ls_stateid.other[2] = delegstateidp->other[2]
3240                             = nfsrv_nextstateindex(clp);
3241                         if (writedeleg && !NFSVNO_EXRDONLY(exp) &&
3242                             (nfsrv_writedelegifpos || !readonly) &&
3243                             (new_stp->ls_flags & NFSLCK_WANTRDELEG) == 0) {
3244                             new_deleg->ls_flags = (NFSLCK_DELEGWRITE |
3245                                 NFSLCK_READACCESS | NFSLCK_WRITEACCESS);
3246                             *rflagsp |= NFSV4OPEN_WRITEDELEGATE;
3247                             nfsrv_writedelegcnt++;
3248                         } else {
3249                             new_deleg->ls_flags = (NFSLCK_DELEGREAD |
3250                                 NFSLCK_READACCESS);
3251                             *rflagsp |= NFSV4OPEN_READDELEGATE;
3252                         }
3253                         new_deleg->ls_uid = new_stp->ls_uid;
3254                         new_deleg->ls_lfp = lfp;
3255                         new_deleg->ls_clp = clp;
3256                         new_deleg->ls_filerev = filerev;
3257                         new_deleg->ls_compref = nd->nd_compref;
3258                         LIST_INSERT_HEAD(&lfp->lf_deleg, new_deleg, ls_file);
3259                         LIST_INSERT_HEAD(NFSSTATEHASH(clp,
3260                             new_deleg->ls_stateid), new_deleg, ls_hash);
3261                         LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg, ls_list);
3262                         new_deleg = NULL;
3263                         nfsstatsv1.srvdelegates++;
3264                         nfsrv_openpluslock++;
3265                         nfsrv_delegatecnt++;
3266                     }
3267                 }
3268         } else {
3269                 /*
3270                  * New owner case. Start the open_owner sequence with a
3271                  * Needs confirmation (unless a reclaim) and hang the
3272                  * new open off it.
3273                  */
3274                 new_open->ls_stateid.seqid = 1;
3275                 new_open->ls_stateid.other[0] = clp->lc_clientid.lval[0];
3276                 new_open->ls_stateid.other[1] = clp->lc_clientid.lval[1];
3277                 new_open->ls_stateid.other[2] = nfsrv_nextstateindex(clp);
3278                 new_open->ls_flags = (new_stp->ls_flags & NFSLCK_SHAREBITS) |
3279                     NFSLCK_OPEN;
3280                 new_open->ls_uid = new_stp->ls_uid;
3281                 LIST_INIT(&new_open->ls_open);
3282                 new_open->ls_openowner = new_stp;
3283                 new_open->ls_lfp = lfp;
3284                 new_open->ls_clp = clp;
3285                 LIST_INSERT_HEAD(&lfp->lf_open, new_open, ls_file);
3286                 if (new_stp->ls_flags & NFSLCK_RECLAIM) {
3287                         new_stp->ls_flags = 0;
3288                 } else if ((nd->nd_flag & ND_NFSV41) != 0) {
3289                         /* NFSv4.1 never needs confirmation. */
3290                         new_stp->ls_flags = 0;
3291
3292                         /*
3293                          * This is where we can choose to issue a delegation.
3294                          */
3295                         if (delegate && nfsrv_issuedelegs &&
3296                             (writedeleg || readonly) &&
3297                             (clp->lc_flags & (LCL_CALLBACKSON | LCL_CBDOWN)) ==
3298                              LCL_CALLBACKSON &&
3299                             !NFSRV_V4DELEGLIMIT(nfsrv_delegatecnt) &&
3300                             NFSVNO_DELEGOK(vp) &&
3301                             ((nd->nd_flag & ND_NFSV41) == 0 ||
3302                              (new_stp->ls_flags & NFSLCK_WANTNODELEG) == 0)) {
3303                                 new_deleg->ls_stateid.seqid =
3304                                     delegstateidp->seqid = 1;
3305                                 new_deleg->ls_stateid.other[0] =
3306                                     delegstateidp->other[0]
3307                                     = clp->lc_clientid.lval[0];
3308                                 new_deleg->ls_stateid.other[1] =
3309                                     delegstateidp->other[1]
3310                                     = clp->lc_clientid.lval[1];
3311                                 new_deleg->ls_stateid.other[2] =
3312                                     delegstateidp->other[2]
3313                                     = nfsrv_nextstateindex(clp);
3314                                 if (writedeleg && !NFSVNO_EXRDONLY(exp) &&
3315                                     (nfsrv_writedelegifpos || !readonly) &&
3316                                     ((nd->nd_flag & ND_NFSV41) == 0 ||
3317                                      (new_stp->ls_flags & NFSLCK_WANTRDELEG) ==
3318                                      0)) {
3319                                         new_deleg->ls_flags =
3320                                             (NFSLCK_DELEGWRITE |
3321                                              NFSLCK_READACCESS |
3322                                              NFSLCK_WRITEACCESS);
3323                                         *rflagsp |= NFSV4OPEN_WRITEDELEGATE;
3324                                         nfsrv_writedelegcnt++;
3325                                 } else {
3326                                         new_deleg->ls_flags =
3327                                             (NFSLCK_DELEGREAD |
3328                                              NFSLCK_READACCESS);
3329                                         *rflagsp |= NFSV4OPEN_READDELEGATE;
3330                                 }
3331                                 new_deleg->ls_uid = new_stp->ls_uid;
3332                                 new_deleg->ls_lfp = lfp;
3333                                 new_deleg->ls_clp = clp;
3334                                 new_deleg->ls_filerev = filerev;
3335                                 new_deleg->ls_compref = nd->nd_compref;
3336                                 LIST_INSERT_HEAD(&lfp->lf_deleg, new_deleg,
3337                                     ls_file);
3338                                 LIST_INSERT_HEAD(NFSSTATEHASH(clp,
3339                                     new_deleg->ls_stateid), new_deleg, ls_hash);
3340                                 LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg,
3341                                     ls_list);
3342                                 new_deleg = NULL;
3343                                 nfsstatsv1.srvdelegates++;
3344                                 nfsrv_openpluslock++;
3345                                 nfsrv_delegatecnt++;
3346                         }
3347                         /*
3348                          * Since NFSv4.1 never does an OpenConfirm, the first
3349                          * open state will be acquired here.
3350                          */
3351                         if (!(clp->lc_flags & LCL_STAMPEDSTABLE)) {
3352                                 clp->lc_flags |= LCL_STAMPEDSTABLE;
3353                                 len = clp->lc_idlen;
3354                                 NFSBCOPY(clp->lc_id, clidp, len);
3355                                 gotstate = 1;
3356                         }
3357                 } else {
3358                         *rflagsp |= NFSV4OPEN_RESULTCONFIRM;
3359                         new_stp->ls_flags = NFSLCK_NEEDSCONFIRM;
3360                 }
3361                 nfsrvd_refcache(new_stp->ls_op);
3362                 new_stp->ls_noopens = 0;
3363                 LIST_INIT(&new_stp->ls_open);
3364                 LIST_INSERT_HEAD(&new_stp->ls_open, new_open, ls_list);
3365                 LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
3366                 LIST_INSERT_HEAD(NFSSTATEHASH(clp, new_open->ls_stateid),
3367                     new_open, ls_hash);
3368                 openstp = new_open;
3369                 new_open = NULL;
3370                 *new_stpp = NULL;
3371                 nfsstatsv1.srvopens++;
3372                 nfsrv_openpluslock++;
3373                 nfsstatsv1.srvopenowners++;
3374                 nfsrv_openpluslock++;
3375         }
3376         if (!error) {
3377                 stateidp->seqid = openstp->ls_stateid.seqid;
3378                 stateidp->other[0] = openstp->ls_stateid.other[0];
3379                 stateidp->other[1] = openstp->ls_stateid.other[1];
3380                 stateidp->other[2] = openstp->ls_stateid.other[2];
3381         }
3382         NFSUNLOCKSTATE();
3383         if (haslock) {
3384                 NFSLOCKV4ROOTMUTEX();
3385                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
3386                 NFSUNLOCKV4ROOTMUTEX();
3387         }
3388         if (new_open)
3389                 free(new_open, M_NFSDSTATE);
3390         if (new_deleg)
3391                 free(new_deleg, M_NFSDSTATE);
3392
3393         /*
3394          * If the NFSv4.1 client just acquired its first open, write a timestamp
3395          * to the stable storage file.
3396          */
3397         if (gotstate != 0) {
3398                 nfsrv_writestable(clidp, len, NFSNST_NEWSTATE, p);
3399                 nfsrv_backupstable();
3400         }
3401
3402 out:
3403         free(clidp, M_TEMP);
3404         NFSEXITCODE2(error, nd);
3405         return (error);
3406 }
3407
3408 /*
3409  * Open update. Does the confirm, downgrade and close.
3410  */
3411 int
3412 nfsrv_openupdate(vnode_t vp, struct nfsstate *new_stp, nfsquad_t clientid,
3413     nfsv4stateid_t *stateidp, struct nfsrv_descript *nd, NFSPROC_T *p,
3414     int *retwriteaccessp)
3415 {
3416         struct nfsstate *stp;
3417         struct nfsclient *clp;
3418         struct nfslockfile *lfp;
3419         u_int32_t bits;
3420         int error = 0, gotstate = 0, len = 0;
3421         u_char *clidp = NULL;
3422
3423         /*
3424          * Check for restart conditions (client and server).
3425          */
3426         error = nfsrv_checkrestart(clientid, new_stp->ls_flags,
3427             &new_stp->ls_stateid, 0);
3428         if (error)
3429                 goto out;
3430
3431         clidp = malloc(NFSV4_OPAQUELIMIT, M_TEMP, M_WAITOK);
3432         NFSLOCKSTATE();
3433         /*
3434          * Get the open structure via clientid and stateid.
3435          */
3436         error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
3437             (nfsquad_t)((u_quad_t)0), 0, nd, p);
3438         if (!error)
3439                 error = nfsrv_getstate(clp, &new_stp->ls_stateid,
3440                     new_stp->ls_flags, &stp);
3441
3442         /*
3443          * Sanity check the open.
3444          */
3445         if (!error && (!(stp->ls_flags & NFSLCK_OPEN) ||
3446                 (!(new_stp->ls_flags & NFSLCK_CONFIRM) &&
3447                  (stp->ls_openowner->ls_flags & NFSLCK_NEEDSCONFIRM)) ||
3448                 ((new_stp->ls_flags & NFSLCK_CONFIRM) &&
3449                  (!(stp->ls_openowner->ls_flags & NFSLCK_NEEDSCONFIRM)))))
3450                 error = NFSERR_BADSTATEID;
3451
3452         if (!error)
3453                 error = nfsrv_checkseqid(nd, new_stp->ls_seq,
3454                     stp->ls_openowner, new_stp->ls_op);
3455         if (!error && stp->ls_stateid.seqid != new_stp->ls_stateid.seqid &&
3456             (((nd->nd_flag & ND_NFSV41) == 0 &&
3457               !(new_stp->ls_flags & NFSLCK_CONFIRM)) ||
3458              ((nd->nd_flag & ND_NFSV41) != 0 &&
3459               new_stp->ls_stateid.seqid != 0)))
3460                 error = NFSERR_OLDSTATEID;
3461         if (!error && vnode_vtype(vp) != VREG) {
3462                 if (vnode_vtype(vp) == VDIR)
3463                         error = NFSERR_ISDIR;
3464                 else
3465                         error = NFSERR_INVAL;
3466         }
3467
3468         if (error) {
3469                 /*
3470                  * If a client tries to confirm an Open with a bad
3471                  * seqid# and there are no byte range locks or other Opens
3472                  * on the openowner, just throw it away, so the next use of the
3473                  * openowner will start a fresh seq#.
3474                  */
3475                 if (error == NFSERR_BADSEQID &&
3476                     (new_stp->ls_flags & NFSLCK_CONFIRM) &&
3477                     nfsrv_nootherstate(stp))
3478                         nfsrv_freeopenowner(stp->ls_openowner, 0, p);
3479                 NFSUNLOCKSTATE();
3480                 goto out;
3481         }
3482
3483         /*
3484          * Set the return stateid.
3485          */
3486         stateidp->seqid = stp->ls_stateid.seqid + 1;
3487         if ((nd->nd_flag & ND_NFSV41) != 0 && stateidp->seqid == 0)
3488                 stateidp->seqid = 1;
3489         stateidp->other[0] = stp->ls_stateid.other[0];
3490         stateidp->other[1] = stp->ls_stateid.other[1];
3491         stateidp->other[2] = stp->ls_stateid.other[2];
3492         /*
3493          * Now, handle the three cases.
3494          */
3495         if (new_stp->ls_flags & NFSLCK_CONFIRM) {
3496                 /*
3497                  * If the open doesn't need confirmation, it seems to me that
3498                  * there is a client error, but I'll just log it and keep going?
3499                  */
3500                 if (!(stp->ls_openowner->ls_flags & NFSLCK_NEEDSCONFIRM))
3501                         printf("Nfsv4d: stray open confirm\n");
3502                 stp->ls_openowner->ls_flags = 0;
3503                 stp->ls_stateid.seqid++;
3504                 if ((nd->nd_flag & ND_NFSV41) != 0 &&
3505                     stp->ls_stateid.seqid == 0)
3506                         stp->ls_stateid.seqid = 1;
3507                 if (!(clp->lc_flags & LCL_STAMPEDSTABLE)) {
3508                         clp->lc_flags |= LCL_STAMPEDSTABLE;
3509                         len = clp->lc_idlen;
3510                         NFSBCOPY(clp->lc_id, clidp, len);
3511                         gotstate = 1;
3512                 }
3513                 NFSUNLOCKSTATE();
3514         } else if (new_stp->ls_flags & NFSLCK_CLOSE) {
3515                 lfp = stp->ls_lfp;
3516                 if (retwriteaccessp != NULL) {
3517                         if ((stp->ls_flags & NFSLCK_WRITEACCESS) != 0)
3518                                 *retwriteaccessp = 1;
3519                         else
3520                                 *retwriteaccessp = 0;
3521                 }
3522                 if (nfsrv_dolocallocks != 0 && !LIST_EMPTY(&stp->ls_open)) {
3523                         /* Get the lf lock */
3524                         nfsrv_locklf(lfp);
3525                         NFSUNLOCKSTATE();
3526                         ASSERT_VOP_ELOCKED(vp, "nfsrv_openupdate");
3527                         NFSVOPUNLOCK(vp);
3528                         if (nfsrv_freeopen(stp, vp, 1, p) == 0) {
3529                                 NFSLOCKSTATE();
3530                                 nfsrv_unlocklf(lfp);
3531                                 NFSUNLOCKSTATE();
3532                         }
3533                         NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
3534                 } else {
3535                         (void) nfsrv_freeopen(stp, NULL, 0, p);
3536                         NFSUNLOCKSTATE();
3537                 }
3538         } else {
3539                 /*
3540                  * Update the share bits, making sure that the new set are a
3541                  * subset of the old ones.
3542                  */
3543                 bits = (new_stp->ls_flags & NFSLCK_SHAREBITS);
3544                 if (~(stp->ls_flags) & bits) {
3545                         NFSUNLOCKSTATE();
3546                         error = NFSERR_INVAL;
3547                         goto out;
3548                 }
3549                 stp->ls_flags = (bits | NFSLCK_OPEN);
3550                 stp->ls_stateid.seqid++;
3551                 if ((nd->nd_flag & ND_NFSV41) != 0 &&
3552                     stp->ls_stateid.seqid == 0)
3553                         stp->ls_stateid.seqid = 1;
3554                 NFSUNLOCKSTATE();
3555         }
3556
3557         /*
3558          * If the client just confirmed its first open, write a timestamp
3559          * to the stable storage file.
3560          */
3561         if (gotstate != 0) {
3562                 nfsrv_writestable(clidp, len, NFSNST_NEWSTATE, p);
3563                 nfsrv_backupstable();
3564         }
3565
3566 out:
3567         free(clidp, M_TEMP);
3568         NFSEXITCODE2(error, nd);
3569         return (error);
3570 }
3571
3572 /*
3573  * Delegation update. Does the purge and return.
3574  */
3575 int
3576 nfsrv_delegupdate(struct nfsrv_descript *nd, nfsquad_t clientid,
3577     nfsv4stateid_t *stateidp, vnode_t vp, int op, struct ucred *cred,
3578     NFSPROC_T *p, int *retwriteaccessp)
3579 {
3580         struct nfsstate *stp;
3581         struct nfsclient *clp;
3582         int error = 0;
3583         fhandle_t fh;
3584
3585         /*
3586          * Do a sanity check against the file handle for DelegReturn.
3587          */
3588         if (vp) {
3589                 error = nfsvno_getfh(vp, &fh, p);
3590                 if (error)
3591                         goto out;
3592         }
3593         /*
3594          * Check for restart conditions (client and server).
3595          */
3596         if (op == NFSV4OP_DELEGRETURN)
3597                 error = nfsrv_checkrestart(clientid, NFSLCK_DELEGRETURN,
3598                         stateidp, 0);
3599         else
3600                 error = nfsrv_checkrestart(clientid, NFSLCK_DELEGPURGE,
3601                         stateidp, 0);
3602
3603         NFSLOCKSTATE();
3604         /*
3605          * Get the open structure via clientid and stateid.
3606          */
3607         if (!error)
3608             error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
3609                 (nfsquad_t)((u_quad_t)0), 0, nd, p);
3610         if (error) {
3611                 if (error == NFSERR_CBPATHDOWN)
3612                         error = 0;
3613                 if (error == NFSERR_STALECLIENTID && op == NFSV4OP_DELEGRETURN)
3614                         error = NFSERR_STALESTATEID;
3615         }
3616         if (!error && op == NFSV4OP_DELEGRETURN) {
3617             error = nfsrv_getstate(clp, stateidp, NFSLCK_DELEGRETURN, &stp);
3618             if (!error && stp->ls_stateid.seqid != stateidp->seqid &&
3619                 ((nd->nd_flag & ND_NFSV41) == 0 || stateidp->seqid != 0))
3620                 error = NFSERR_OLDSTATEID;
3621         }
3622         /*
3623          * NFSERR_EXPIRED means that the state has gone away,
3624          * so Delegations have been purged. Just return ok.
3625          */
3626         if (error == NFSERR_EXPIRED && op == NFSV4OP_DELEGPURGE) {
3627                 NFSUNLOCKSTATE();
3628                 error = 0;
3629                 goto out;
3630         }
3631         if (error) {
3632                 NFSUNLOCKSTATE();
3633                 goto out;
3634         }
3635
3636         if (op == NFSV4OP_DELEGRETURN) {
3637                 if (NFSBCMP((caddr_t)&fh, (caddr_t)&stp->ls_lfp->lf_fh,
3638                     sizeof (fhandle_t))) {
3639                         NFSUNLOCKSTATE();
3640                         error = NFSERR_BADSTATEID;
3641                         goto out;
3642                 }
3643                 if (retwriteaccessp != NULL) {
3644                         if ((stp->ls_flags & NFSLCK_DELEGWRITE) != 0)
3645                                 *retwriteaccessp = 1;
3646                         else
3647                                 *retwriteaccessp = 0;
3648                 }
3649                 nfsrv_freedeleg(stp);
3650         } else {
3651                 nfsrv_freedeleglist(&clp->lc_olddeleg);
3652         }
3653         NFSUNLOCKSTATE();
3654         error = 0;
3655
3656 out:
3657         NFSEXITCODE(error);
3658         return (error);
3659 }
3660
3661 /*
3662  * Release lock owner.
3663  */
3664 int
3665 nfsrv_releaselckown(struct nfsstate *new_stp, nfsquad_t clientid,
3666     NFSPROC_T *p)
3667 {
3668         struct nfsstate *stp, *nstp, *openstp, *ownstp;
3669         struct nfsclient *clp;
3670         int error = 0;
3671
3672         /*
3673          * Check for restart conditions (client and server).
3674          */
3675         error = nfsrv_checkrestart(clientid, new_stp->ls_flags,
3676             &new_stp->ls_stateid, 0);
3677         if (error)
3678                 goto out;
3679
3680         NFSLOCKSTATE();
3681         /*
3682          * Get the lock owner by name.
3683          */
3684         error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
3685             (nfsquad_t)((u_quad_t)0), 0, NULL, p);
3686         if (error) {
3687                 NFSUNLOCKSTATE();
3688                 goto out;
3689         }
3690         LIST_FOREACH(ownstp, &clp->lc_open, ls_list) {
3691             LIST_FOREACH(openstp, &ownstp->ls_open, ls_list) {
3692                 stp = LIST_FIRST(&openstp->ls_open);
3693                 while (stp != LIST_END(&openstp->ls_open)) {
3694                     nstp = LIST_NEXT(stp, ls_list);
3695                     /*
3696                      * If the owner matches, check for locks and
3697                      * then free or return an error.
3698                      */
3699                     if (stp->ls_ownerlen == new_stp->ls_ownerlen &&
3700                         !NFSBCMP(stp->ls_owner, new_stp->ls_owner,
3701                          stp->ls_ownerlen)){
3702                         if (LIST_EMPTY(&stp->ls_lock)) {
3703                             nfsrv_freelockowner(stp, NULL, 0, p);
3704                         } else {
3705                             NFSUNLOCKSTATE();
3706                             error = NFSERR_LOCKSHELD;
3707                             goto out;
3708                         }
3709                     }
3710                     stp = nstp;
3711                 }
3712             }
3713         }
3714         NFSUNLOCKSTATE();
3715
3716 out:
3717         NFSEXITCODE(error);
3718         return (error);
3719 }
3720
3721 /*
3722  * Get the file handle for a lock structure.
3723  */
3724 static int
3725 nfsrv_getlockfh(vnode_t vp, u_short flags, struct nfslockfile *new_lfp,
3726     fhandle_t *nfhp, NFSPROC_T *p)
3727 {
3728         fhandle_t *fhp = NULL;
3729         int error;
3730
3731         /*
3732          * For lock, use the new nfslock structure, otherwise just
3733          * a fhandle_t on the stack.
3734          */
3735         if (flags & NFSLCK_OPEN) {
3736                 KASSERT(new_lfp != NULL, ("nfsrv_getlockfh: new_lfp NULL"));
3737                 fhp = &new_lfp->lf_fh;
3738         } else if (nfhp) {
3739                 fhp = nfhp;
3740         } else {
3741                 panic("nfsrv_getlockfh");
3742         }
3743         error = nfsvno_getfh(vp, fhp, p);
3744         NFSEXITCODE(error);
3745         return (error);
3746 }
3747
3748 /*
3749  * Get an nfs lock structure. Allocate one, as required, and return a
3750  * pointer to it.
3751  * Returns an NFSERR_xxx upon failure or -1 to indicate no current lock.
3752  */
3753 static int
3754 nfsrv_getlockfile(u_short flags, struct nfslockfile **new_lfpp,
3755     struct nfslockfile **lfpp, fhandle_t *nfhp, int lockit)
3756 {
3757         struct nfslockfile *lfp;
3758         fhandle_t *fhp = NULL, *tfhp;
3759         struct nfslockhashhead *hp;
3760         struct nfslockfile *new_lfp = NULL;
3761
3762         /*
3763          * For lock, use the new nfslock structure, otherwise just
3764          * a fhandle_t on the stack.
3765          */
3766         if (flags & NFSLCK_OPEN) {
3767                 new_lfp = *new_lfpp;
3768                 fhp = &new_lfp->lf_fh;
3769         } else if (nfhp) {
3770                 fhp = nfhp;
3771         } else {
3772                 panic("nfsrv_getlockfile");
3773         }
3774
3775         hp = NFSLOCKHASH(fhp);
3776         LIST_FOREACH(lfp, hp, lf_hash) {
3777                 tfhp = &lfp->lf_fh;
3778                 if (NFSVNO_CMPFH(fhp, tfhp)) {
3779                         if (lockit)
3780                                 nfsrv_locklf(lfp);
3781                         *lfpp = lfp;
3782                         return (0);
3783                 }
3784         }
3785         if (!(flags & NFSLCK_OPEN))
3786                 return (-1);
3787
3788         /*
3789          * No match, so chain the new one into the list.
3790          */
3791         LIST_INIT(&new_lfp->lf_open);
3792         LIST_INIT(&new_lfp->lf_lock);
3793         LIST_INIT(&new_lfp->lf_deleg);
3794         LIST_INIT(&new_lfp->lf_locallock);
3795         LIST_INIT(&new_lfp->lf_rollback);
3796         new_lfp->lf_locallock_lck.nfslock_usecnt = 0;
3797         new_lfp->lf_locallock_lck.nfslock_lock = 0;
3798         new_lfp->lf_usecount = 0;
3799         LIST_INSERT_HEAD(hp, new_lfp, lf_hash);
3800         *lfpp = new_lfp;
3801         *new_lfpp = NULL;
3802         return (0);
3803 }
3804
3805 /*
3806  * This function adds a nfslock lock structure to the list for the associated
3807  * nfsstate and nfslockfile structures. It will be inserted after the
3808  * entry pointed at by insert_lop.
3809  */
3810 static void
3811 nfsrv_insertlock(struct nfslock *new_lop, struct nfslock *insert_lop,
3812     struct nfsstate *stp, struct nfslockfile *lfp)
3813 {
3814         struct nfslock *lop, *nlop;
3815
3816         new_lop->lo_stp = stp;
3817         new_lop->lo_lfp = lfp;
3818
3819         if (stp != NULL) {
3820                 /* Insert in increasing lo_first order */
3821                 lop = LIST_FIRST(&lfp->lf_lock);
3822                 if (lop == LIST_END(&lfp->lf_lock) ||
3823                     new_lop->lo_first <= lop->lo_first) {
3824                         LIST_INSERT_HEAD(&lfp->lf_lock, new_lop, lo_lckfile);
3825                 } else {
3826                         nlop = LIST_NEXT(lop, lo_lckfile);
3827                         while (nlop != LIST_END(&lfp->lf_lock) &&
3828                                nlop->lo_first < new_lop->lo_first) {
3829                                 lop = nlop;
3830                                 nlop = LIST_NEXT(lop, lo_lckfile);
3831                         }
3832                         LIST_INSERT_AFTER(lop, new_lop, lo_lckfile);
3833                 }
3834         } else {
3835                 new_lop->lo_lckfile.le_prev = NULL;     /* list not used */
3836         }
3837
3838         /*
3839          * Insert after insert_lop, which is overloaded as stp or lfp for
3840          * an empty list.
3841          */
3842         if (stp == NULL && (struct nfslockfile *)insert_lop == lfp)
3843                 LIST_INSERT_HEAD(&lfp->lf_locallock, new_lop, lo_lckowner);
3844         else if ((struct nfsstate *)insert_lop == stp)
3845                 LIST_INSERT_HEAD(&stp->ls_lock, new_lop, lo_lckowner);
3846         else
3847                 LIST_INSERT_AFTER(insert_lop, new_lop, lo_lckowner);
3848         if (stp != NULL) {
3849                 nfsstatsv1.srvlocks++;
3850                 nfsrv_openpluslock++;
3851         }
3852 }
3853
3854 /*
3855  * This function updates the locking for a lock owner and given file. It
3856  * maintains a list of lock ranges ordered on increasing file offset that
3857  * are NFSLCK_READ or NFSLCK_WRITE and non-overlapping (aka POSIX style).
3858  * It always adds new_lop to the list and sometimes uses the one pointed
3859  * at by other_lopp.
3860  */
3861 static void
3862 nfsrv_updatelock(struct nfsstate *stp, struct nfslock **new_lopp,
3863     struct nfslock **other_lopp, struct nfslockfile *lfp)
3864 {
3865         struct nfslock *new_lop = *new_lopp;
3866         struct nfslock *lop, *tlop, *ilop;
3867         struct nfslock *other_lop = *other_lopp;
3868         int unlock = 0, myfile = 0;
3869         u_int64_t tmp;
3870
3871         /*
3872          * Work down the list until the lock is merged.
3873          */
3874         if (new_lop->lo_flags & NFSLCK_UNLOCK)
3875                 unlock = 1;
3876         if (stp != NULL) {
3877                 ilop = (struct nfslock *)stp;
3878                 lop = LIST_FIRST(&stp->ls_lock);
3879         } else {
3880                 ilop = (struct nfslock *)lfp;
3881                 lop = LIST_FIRST(&lfp->lf_locallock);
3882         }
3883         while (lop != NULL) {
3884             /*
3885              * Only check locks for this file that aren't before the start of
3886              * new lock's range.
3887              */
3888             if (lop->lo_lfp == lfp) {
3889               myfile = 1;
3890               if (lop->lo_end >= new_lop->lo_first) {
3891                 if (new_lop->lo_end < lop->lo_first) {
3892                         /*
3893                          * If the new lock ends before the start of the
3894                          * current lock's range, no merge, just insert
3895                          * the new lock.
3896                          */
3897                         break;
3898                 }
3899                 if (new_lop->lo_flags == lop->lo_flags ||
3900                     (new_lop->lo_first <= lop->lo_first &&
3901                      new_lop->lo_end >= lop->lo_end)) {
3902                         /*
3903                          * This lock can be absorbed by the new lock/unlock.
3904                          * This happens when it covers the entire range
3905                          * of the old lock or is contiguous
3906                          * with the old lock and is of the same type or an
3907                          * unlock.
3908                          */
3909                         if (lop->lo_first < new_lop->lo_first)
3910                                 new_lop->lo_first = lop->lo_first;
3911                         if (lop->lo_end > new_lop->lo_end)
3912                                 new_lop->lo_end = lop->lo_end;
3913                         tlop = lop;
3914                         lop = LIST_NEXT(lop, lo_lckowner);
3915                         nfsrv_freenfslock(tlop);
3916                         continue;
3917                 }
3918
3919                 /*
3920                  * All these cases are for contiguous locks that are not the
3921                  * same type, so they can't be merged.
3922                  */
3923                 if (new_lop->lo_first <= lop->lo_first) {
3924                         /*
3925                          * This case is where the new lock overlaps with the
3926                          * first part of the old lock. Move the start of the
3927                          * old lock to just past the end of the new lock. The
3928                          * new lock will be inserted in front of the old, since
3929                          * ilop hasn't been updated. (We are done now.)
3930                          */
3931                         lop->lo_first = new_lop->lo_end;
3932                         break;
3933                 }
3934                 if (new_lop->lo_end >= lop->lo_end) {
3935                         /*
3936                          * This case is where the new lock overlaps with the
3937                          * end of the old lock's range. Move the old lock's
3938                          * end to just before the new lock's first and insert
3939                          * the new lock after the old lock.
3940                          * Might not be done yet, since the new lock could
3941                          * overlap further locks with higher ranges.
3942                          */
3943                         lop->lo_end = new_lop->lo_first;
3944                         ilop = lop;
3945                         lop = LIST_NEXT(lop, lo_lckowner);
3946                         continue;
3947                 }
3948                 /*
3949                  * The final case is where the new lock's range is in the
3950                  * middle of the current lock's and splits the current lock
3951                  * up. Use *other_lopp to handle the second part of the
3952                  * split old lock range. (We are done now.)
3953                  * For unlock, we use new_lop as other_lop and tmp, since
3954                  * other_lop and new_lop are the same for this case.
3955                  * We noted the unlock case above, so we don't need
3956                  * new_lop->lo_flags any longer.
3957                  */
3958                 tmp = new_lop->lo_first;
3959                 if (other_lop == NULL) {
3960                         if (!unlock)
3961                                 panic("nfsd srv update unlock");
3962                         other_lop = new_lop;
3963                         *new_lopp = NULL;
3964                 }
3965                 other_lop->lo_first = new_lop->lo_end;
3966                 other_lop->lo_end = lop->lo_end;
3967                 other_lop->lo_flags = lop->lo_flags;
3968                 other_lop->lo_stp = stp;
3969                 other_lop->lo_lfp = lfp;
3970                 lop->lo_end = tmp;
3971                 nfsrv_insertlock(other_lop, lop, stp, lfp);
3972                 *other_lopp = NULL;
3973                 ilop = lop;
3974                 break;
3975               }
3976             }
3977             ilop = lop;
3978             lop = LIST_NEXT(lop, lo_lckowner);
3979             if (myfile && (lop == NULL || lop->lo_lfp != lfp))
3980                 break;
3981         }
3982
3983         /*
3984          * Insert the new lock in the list at the appropriate place.
3985          */
3986         if (!unlock) {
3987                 nfsrv_insertlock(new_lop, ilop, stp, lfp);
3988                 *new_lopp = NULL;
3989         }
3990 }
3991
3992 /*
3993  * This function handles sequencing of locks, etc.
3994  * It returns an error that indicates what the caller should do.
3995  */
3996 static int
3997 nfsrv_checkseqid(struct nfsrv_descript *nd, u_int32_t seqid,
3998     struct nfsstate *stp, struct nfsrvcache *op)
3999 {
4000         int error = 0;
4001
4002         if ((nd->nd_flag & ND_NFSV41) != 0)
4003                 /* NFSv4.1 ignores the open_seqid and lock_seqid. */
4004                 goto out;
4005         if (op != nd->nd_rp)
4006                 panic("nfsrvstate checkseqid");
4007         if (!(op->rc_flag & RC_INPROG))
4008                 panic("nfsrvstate not inprog");
4009         if (stp->ls_op && stp->ls_op->rc_refcnt <= 0) {
4010                 printf("refcnt=%d\n", stp->ls_op->rc_refcnt);
4011                 panic("nfsrvstate op refcnt");
4012         }
4013         if ((stp->ls_seq + 1) == seqid) {
4014                 if (stp->ls_op)
4015                         nfsrvd_derefcache(stp->ls_op);
4016                 stp->ls_op = op;
4017                 nfsrvd_refcache(op);
4018                 stp->ls_seq = seqid;
4019                 goto out;
4020         } else if (stp->ls_seq == seqid && stp->ls_op &&
4021                 op->rc_xid == stp->ls_op->rc_xid &&
4022                 op->rc_refcnt == 0 &&
4023                 op->rc_reqlen == stp->ls_op->rc_reqlen &&
4024                 op->rc_cksum == stp->ls_op->rc_cksum) {
4025                 if (stp->ls_op->rc_flag & RC_INPROG) {
4026                         error = NFSERR_DONTREPLY;
4027                         goto out;
4028                 }
4029                 nd->nd_rp = stp->ls_op;
4030                 nd->nd_rp->rc_flag |= RC_INPROG;
4031                 nfsrvd_delcache(op);
4032                 error = NFSERR_REPLYFROMCACHE;
4033                 goto out;
4034         }
4035         error = NFSERR_BADSEQID;
4036
4037 out:
4038         NFSEXITCODE2(error, nd);
4039         return (error);
4040 }
4041
4042 /*
4043  * Get the client ip address for callbacks. If the strings can't be parsed,
4044  * just set lc_program to 0 to indicate no callbacks are possible.
4045  * (For cases where the address can't be parsed or is 0.0.0.0.0.0, set
4046  *  the address to the client's transport address. This won't be used
4047  *  for callbacks, but can be printed out by nfsstats for info.)
4048  * Return error if the xdr can't be parsed, 0 otherwise.
4049  */
4050 int
4051 nfsrv_getclientipaddr(struct nfsrv_descript *nd, struct nfsclient *clp)
4052 {
4053         u_int32_t *tl;
4054         u_char *cp, *cp2;
4055         int i, j, maxalen = 0, minalen = 0;
4056         sa_family_t af;
4057 #ifdef INET
4058         struct sockaddr_in *rin = NULL, *sin;
4059 #endif
4060 #ifdef INET6
4061         struct sockaddr_in6 *rin6 = NULL, *sin6;
4062 #endif
4063         u_char *addr;
4064         int error = 0, cantparse = 0;
4065         union {
4066                 in_addr_t ival;
4067                 u_char cval[4];
4068         } ip;
4069         union {
4070                 in_port_t sval;
4071                 u_char cval[2];
4072         } port;
4073
4074         /* 8 is the maximum length of the port# string. */
4075         addr = malloc(INET6_ADDRSTRLEN + 8, M_TEMP, M_WAITOK);
4076         clp->lc_req.nr_client = NULL;
4077         clp->lc_req.nr_lock = 0;
4078         af = AF_UNSPEC;
4079         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
4080         i = fxdr_unsigned(int, *tl);
4081         if (i >= 3 && i <= 4) {
4082                 error = nfsrv_mtostr(nd, addr, i);
4083                 if (error)
4084                         goto nfsmout;
4085 #ifdef INET
4086                 if (!strcmp(addr, "tcp")) {
4087                         clp->lc_flags |= LCL_TCPCALLBACK;
4088                         clp->lc_req.nr_sotype = SOCK_STREAM;
4089                         clp->lc_req.nr_soproto = IPPROTO_TCP;
4090                         af = AF_INET;
4091                 } else if (!strcmp(addr, "udp")) {
4092                         clp->lc_req.nr_sotype = SOCK_DGRAM;
4093                         clp->lc_req.nr_soproto = IPPROTO_UDP;
4094                         af = AF_INET;
4095                 }
4096 #endif
4097 #ifdef INET6
4098                 if (af == AF_UNSPEC) {
4099                         if (!strcmp(addr, "tcp6")) {
4100                                 clp->lc_flags |= LCL_TCPCALLBACK;
4101                                 clp->lc_req.nr_sotype = SOCK_STREAM;
4102                                 clp->lc_req.nr_soproto = IPPROTO_TCP;
4103                                 af = AF_INET6;
4104                         } else if (!strcmp(addr, "udp6")) {
4105                                 clp->lc_req.nr_sotype = SOCK_DGRAM;
4106                                 clp->lc_req.nr_soproto = IPPROTO_UDP;
4107                                 af = AF_INET6;
4108                         }
4109                 }
4110 #endif
4111                 if (af == AF_UNSPEC) {
4112                         cantparse = 1;
4113                 }
4114         } else {
4115                 cantparse = 1;
4116                 if (i > 0) {
4117                         error = nfsm_advance(nd, NFSM_RNDUP(i), -1);
4118                         if (error)
4119                                 goto nfsmout;
4120                 }
4121         }
4122         /*
4123          * The caller has allocated clp->lc_req.nr_nam to be large enough
4124          * for either AF_INET or AF_INET6 and zeroed out the contents.
4125          * maxalen is set to the maximum length of the host IP address string
4126          * plus 8 for the maximum length of the port#.
4127          * minalen is set to the minimum length of the host IP address string
4128          * plus 4 for the minimum length of the port#.
4129          * These lengths do not include NULL termination,
4130          * so INET[6]_ADDRSTRLEN - 1 is used in the calculations.
4131          */
4132         switch (af) {
4133 #ifdef INET
4134         case AF_INET:
4135                 rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
4136                 rin->sin_family = AF_INET;
4137                 rin->sin_len = sizeof(struct sockaddr_in);
4138                 maxalen = INET_ADDRSTRLEN - 1 + 8;
4139                 minalen = 7 + 4;
4140                 break;
4141 #endif
4142 #ifdef INET6
4143         case AF_INET6:
4144                 rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
4145                 rin6->sin6_family = AF_INET6;
4146                 rin6->sin6_len = sizeof(struct sockaddr_in6);
4147                 maxalen = INET6_ADDRSTRLEN - 1 + 8;
4148                 minalen = 3 + 4;
4149                 break;
4150 #endif
4151         }
4152         NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
4153         i = fxdr_unsigned(int, *tl);
4154         if (i < 0) {
4155                 error = NFSERR_BADXDR;
4156                 goto nfsmout;
4157         } else if (i == 0) {
4158                 cantparse = 1;
4159         } else if (!cantparse && i <= maxalen && i >= minalen) {
4160                 error = nfsrv_mtostr(nd, addr, i);
4161                 if (error)
4162                         goto nfsmout;
4163
4164                 /*
4165                  * Parse out the address fields. We expect 6 decimal numbers
4166                  * separated by '.'s for AF_INET and two decimal numbers
4167                  * preceeded by '.'s for AF_INET6.
4168                  */
4169                 cp = NULL;
4170                 switch (af) {
4171 #ifdef INET6
4172                 /*
4173                  * For AF_INET6, first parse the host address.
4174                  */
4175                 case AF_INET6:
4176                         cp = strchr(addr, '.');
4177                         if (cp != NULL) {
4178                                 *cp++ = '\0';
4179                                 if (inet_pton(af, addr, &rin6->sin6_addr) == 1)
4180                                         i = 4;
4181                                 else {
4182                                         cp = NULL;
4183                                         cantparse = 1;
4184                                 }
4185                         }
4186                         break;
4187 #endif
4188 #ifdef INET
4189                 case AF_INET:
4190                         cp = addr;
4191                         i = 0;
4192                         break;
4193 #endif
4194                 }
4195                 while (cp != NULL && *cp && i < 6) {
4196                         cp2 = cp;
4197                         while (*cp2 && *cp2 != '.')
4198                                 cp2++;
4199                         if (*cp2)
4200                                 *cp2++ = '\0';
4201                         else if (i != 5) {
4202                                 cantparse = 1;
4203                                 break;
4204                         }
4205                         j = nfsrv_getipnumber(cp);
4206                         if (j >= 0) {
4207                                 if (i < 4)
4208                                         ip.cval[3 - i] = j;
4209                                 else
4210                                         port.cval[5 - i] = j;
4211                         } else {
4212                                 cantparse = 1;
4213                                 break;
4214                         }
4215                         cp = cp2;
4216                         i++;
4217                 }
4218                 if (!cantparse) {
4219                         /*
4220                          * The host address INADDR_ANY is (mis)used to indicate
4221                          * "there is no valid callback address".
4222                          */
4223                         switch (af) {
4224 #ifdef INET6
4225                         case AF_INET6:
4226                                 if (!IN6_ARE_ADDR_EQUAL(&rin6->sin6_addr,
4227                                     &in6addr_any))
4228                                         rin6->sin6_port = htons(port.sval);
4229                                 else
4230                                         cantparse = 1;
4231                                 break;
4232 #endif
4233 #ifdef INET
4234                         case AF_INET:
4235                                 if (ip.ival != INADDR_ANY) {
4236                                         rin->sin_addr.s_addr = htonl(ip.ival);
4237                                         rin->sin_port = htons(port.sval);
4238                                 } else {
4239                                         cantparse = 1;
4240                                 }
4241                                 break;
4242 #endif
4243                         }
4244                 }
4245         } else {
4246                 cantparse = 1;
4247                 if (i > 0) {
4248                         error = nfsm_advance(nd, NFSM_RNDUP(i), -1);
4249                         if (error)
4250                                 goto nfsmout;
4251                 }
4252         }
4253         if (cantparse) {
4254                 switch (nd->nd_nam->sa_family) {
4255 #ifdef INET
4256                 case AF_INET:
4257                         sin = (struct sockaddr_in *)nd->nd_nam;
4258                         rin = (struct sockaddr_in *)clp->lc_req.nr_nam;
4259                         rin->sin_family = AF_INET;
4260                         rin->sin_len = sizeof(struct sockaddr_in);
4261                         rin->sin_addr.s_addr = sin->sin_addr.s_addr;
4262                         rin->sin_port = 0x0;
4263                         break;
4264 #endif
4265 #ifdef INET6
4266                 case AF_INET6:
4267                         sin6 = (struct sockaddr_in6 *)nd->nd_nam;
4268                         rin6 = (struct sockaddr_in6 *)clp->lc_req.nr_nam;
4269                         rin6->sin6_family = AF_INET6;
4270                         rin6->sin6_len = sizeof(struct sockaddr_in6);
4271                         rin6->sin6_addr = sin6->sin6_addr;
4272                         rin6->sin6_port = 0x0;
4273                         break;
4274 #endif
4275                 }
4276                 clp->lc_program = 0;
4277         }
4278 nfsmout:
4279         free(addr, M_TEMP);
4280         NFSEXITCODE2(error, nd);
4281         return (error);
4282 }
4283
4284 /*
4285  * Turn a string of up to three decimal digits into a number. Return -1 upon
4286  * error.
4287  */
4288 static int
4289 nfsrv_getipnumber(u_char *cp)
4290 {
4291         int i = 0, j = 0;
4292
4293         while (*cp) {
4294                 if (j > 2 || *cp < '0' || *cp > '9')
4295                         return (-1);
4296                 i *= 10;
4297                 i += (*cp - '0');
4298                 cp++;
4299                 j++;
4300         }
4301         if (i < 256)
4302                 return (i);
4303         return (-1);
4304 }
4305
4306 /*
4307  * This function checks for restart conditions.
4308  */
4309 static int
4310 nfsrv_checkrestart(nfsquad_t clientid, u_int32_t flags,
4311     nfsv4stateid_t *stateidp, int specialid)
4312 {
4313         int ret = 0;
4314
4315         /*
4316          * First check for a server restart. Open, LockT, ReleaseLockOwner
4317          * and DelegPurge have a clientid, the rest a stateid.
4318          */
4319         if (flags &
4320             (NFSLCK_OPEN | NFSLCK_TEST | NFSLCK_RELEASE | NFSLCK_DELEGPURGE)) {
4321                 if (clientid.lval[0] != nfsrvboottime) {
4322                         ret = NFSERR_STALECLIENTID;
4323                         goto out;
4324                 }
4325         } else if (stateidp->other[0] != nfsrvboottime &&
4326                 specialid == 0) {
4327                 ret = NFSERR_STALESTATEID;
4328                 goto out;
4329         }
4330
4331         /*
4332          * Read, Write, Setattr and LockT can return NFSERR_GRACE and do
4333          * not use a lock/open owner seqid#, so the check can be done now.
4334          * (The others will be checked, as required, later.)
4335          */
4336         if (!(flags & (NFSLCK_CHECK | NFSLCK_TEST)))
4337                 goto out;
4338
4339         NFSLOCKSTATE();
4340         ret = nfsrv_checkgrace(NULL, NULL, flags);
4341         NFSUNLOCKSTATE();
4342
4343 out:
4344         NFSEXITCODE(ret);
4345         return (ret);
4346 }
4347
4348 /*
4349  * Check for grace.
4350  */
4351 static int
4352 nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
4353     u_int32_t flags)
4354 {
4355         int error = 0, notreclaimed;
4356         struct nfsrv_stable *sp;
4357
4358         if ((nfsrv_stablefirst.nsf_flags & (NFSNSF_UPDATEDONE |
4359              NFSNSF_GRACEOVER)) == 0) {
4360                 /*
4361                  * First, check to see if all of the clients have done a
4362                  * ReclaimComplete.  If so, grace can end now.
4363                  */
4364                 notreclaimed = 0;
4365                 LIST_FOREACH(sp, &nfsrv_stablefirst.nsf_head, nst_list) {
4366                         if ((sp->nst_flag & NFSNST_RECLAIMED) == 0) {
4367                                 notreclaimed = 1;
4368                                 break;
4369                         }
4370                 }
4371                 if (notreclaimed == 0)
4372                         nfsrv_stablefirst.nsf_flags |= (NFSNSF_GRACEOVER |
4373                             NFSNSF_NEEDLOCK);
4374         }
4375
4376         if ((nfsrv_stablefirst.nsf_flags & NFSNSF_GRACEOVER) != 0) {
4377                 if (flags & NFSLCK_RECLAIM) {
4378                         error = NFSERR_NOGRACE;
4379                         goto out;
4380                 }
4381         } else {
4382                 if (!(flags & NFSLCK_RECLAIM)) {
4383                         error = NFSERR_GRACE;
4384                         goto out;
4385                 }
4386                 if (nd != NULL && clp != NULL &&
4387                     (nd->nd_flag & ND_NFSV41) != 0 &&
4388                     (clp->lc_flags & LCL_RECLAIMCOMPLETE) != 0) {
4389                         error = NFSERR_NOGRACE;
4390                         goto out;
4391                 }
4392
4393                 /*
4394                  * If grace is almost over and we are still getting Reclaims,
4395                  * extend grace a bit.
4396                  */
4397                 if ((NFSD_MONOSEC + NFSRV_LEASEDELTA) >
4398                     nfsrv_stablefirst.nsf_eograce)
4399                         nfsrv_stablefirst.nsf_eograce = NFSD_MONOSEC +
4400                                 NFSRV_LEASEDELTA;
4401         }
4402
4403 out:
4404         NFSEXITCODE(error);
4405         return (error);
4406 }
4407
4408 /*
4409  * Do a server callback.
4410  * The "trunc" argument is slightly overloaded and refers to different
4411  * boolean arguments for CBRECALL and CBLAYOUTRECALL.
4412  */
4413 static int
4414 nfsrv_docallback(struct nfsclient *clp, int procnum, nfsv4stateid_t *stateidp,
4415     int trunc, fhandle_t *fhp, struct nfsvattr *nap, nfsattrbit_t *attrbitp,
4416     int laytype, NFSPROC_T *p)
4417 {
4418         struct mbuf *m;
4419         u_int32_t *tl;
4420         struct nfsrv_descript *nd;
4421         struct ucred *cred;
4422         int error = 0;
4423         u_int32_t callback;
4424         struct nfsdsession *sep = NULL;
4425         uint64_t tval;
4426         bool dotls;
4427
4428         nd = malloc(sizeof(*nd), M_TEMP, M_WAITOK | M_ZERO);
4429         cred = newnfs_getcred();
4430         NFSLOCKSTATE(); /* mostly for lc_cbref++ */
4431         if (clp->lc_flags & LCL_NEEDSCONFIRM) {
4432                 NFSUNLOCKSTATE();
4433                 panic("docallb");
4434         }
4435         clp->lc_cbref++;
4436
4437         /*
4438          * Fill the callback program# and version into the request
4439          * structure for newnfs_connect() to use.
4440          */
4441         clp->lc_req.nr_prog = clp->lc_program;
4442 #ifdef notnow
4443         if ((clp->lc_flags & LCL_NFSV41) != 0)
4444                 clp->lc_req.nr_vers = NFSV41_CBVERS;
4445         else
4446 #endif
4447                 clp->lc_req.nr_vers = NFSV4_CBVERS;
4448
4449         /*
4450          * First, fill in some of the fields of nd and cr.
4451          */
4452         nd->nd_flag = ND_NFSV4;
4453         if (clp->lc_flags & LCL_GSS)
4454                 nd->nd_flag |= ND_KERBV;
4455         if ((clp->lc_flags & LCL_NFSV41) != 0)
4456                 nd->nd_flag |= ND_NFSV41;
4457         if ((clp->lc_flags & LCL_NFSV42) != 0)
4458                 nd->nd_flag |= ND_NFSV42;
4459         nd->nd_repstat = 0;
4460         cred->cr_uid = clp->lc_uid;
4461         cred->cr_gid = clp->lc_gid;
4462         callback = clp->lc_callback;
4463         NFSUNLOCKSTATE();
4464         cred->cr_ngroups = 1;
4465
4466         /*
4467          * Get the first mbuf for the request.
4468          */
4469         MGET(m, M_WAITOK, MT_DATA);
4470         m->m_len = 0;
4471         nd->nd_mreq = nd->nd_mb = m;
4472         nd->nd_bpos = mtod(m, caddr_t);
4473
4474         /*
4475          * and build the callback request.
4476          */
4477         if (procnum == NFSV4OP_CBGETATTR) {
4478                 nd->nd_procnum = NFSV4PROC_CBCOMPOUND;
4479                 error = nfsrv_cbcallargs(nd, clp, callback, NFSV4OP_CBGETATTR,
4480                     "CB Getattr", &sep);
4481                 if (error != 0) {
4482                         m_freem(nd->nd_mreq);
4483                         goto errout;
4484                 }
4485                 (void)nfsm_fhtom(nd, (u_int8_t *)fhp, NFSX_MYFH, 0);
4486                 (void)nfsrv_putattrbit(nd, attrbitp);
4487         } else if (procnum == NFSV4OP_CBRECALL) {
4488                 nd->nd_procnum = NFSV4PROC_CBCOMPOUND;
4489                 error = nfsrv_cbcallargs(nd, clp, callback, NFSV4OP_CBRECALL,
4490                     "CB Recall", &sep);
4491                 if (error != 0) {
4492                         m_freem(nd->nd_mreq);
4493                         goto errout;
4494                 }
4495                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
4496                 *tl++ = txdr_unsigned(stateidp->seqid);
4497                 NFSBCOPY((caddr_t)stateidp->other, (caddr_t)tl,
4498                     NFSX_STATEIDOTHER);
4499                 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
4500                 if (trunc)
4501                         *tl = newnfs_true;
4502                 else
4503                         *tl = newnfs_false;
4504                 (void)nfsm_fhtom(nd, (u_int8_t *)fhp, NFSX_MYFH, 0);
4505         } else if (procnum == NFSV4OP_CBLAYOUTRECALL) {
4506                 NFSD_DEBUG(4, "docallback layout recall\n");
4507                 nd->nd_procnum = NFSV4PROC_CBCOMPOUND;
4508                 error = nfsrv_cbcallargs(nd, clp, callback,
4509                     NFSV4OP_CBLAYOUTRECALL, "CB Reclayout", &sep);
4510                 NFSD_DEBUG(4, "aft cbcallargs=%d\n", error);
4511                 if (error != 0) {
4512                         m_freem(nd->nd_mreq);
4513                         goto errout;
4514                 }
4515                 NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
4516                 *tl++ = txdr_unsigned(laytype);
4517                 *tl++ = txdr_unsigned(NFSLAYOUTIOMODE_ANY);
4518                 if (trunc)
4519                         *tl++ = newnfs_true;
4520                 else
4521                         *tl++ = newnfs_false;
4522                 *tl = txdr_unsigned(NFSV4LAYOUTRET_FILE);
4523                 nfsm_fhtom(nd, (uint8_t *)fhp, NFSX_MYFH, 0);
4524                 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_HYPER + NFSX_STATEID);
4525                 tval = 0;
4526                 txdr_hyper(tval, tl); tl += 2;
4527                 tval = UINT64_MAX;
4528                 txdr_hyper(tval, tl); tl += 2;
4529                 *tl++ = txdr_unsigned(stateidp->seqid);
4530                 NFSBCOPY(stateidp->other, tl, NFSX_STATEIDOTHER);
4531                 tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
4532                 NFSD_DEBUG(4, "aft args\n");
4533         } else if (procnum == NFSV4PROC_CBNULL) {
4534                 nd->nd_procnum = NFSV4PROC_CBNULL;
4535                 if ((clp->lc_flags & LCL_NFSV41) != 0) {
4536                         error = nfsv4_getcbsession(clp, &sep);
4537                         if (error != 0) {
4538                                 m_freem(nd->nd_mreq);
4539                                 goto errout;
4540                         }
4541                 }
4542         } else {
4543                 error = NFSERR_SERVERFAULT;
4544                 m_freem(nd->nd_mreq);
4545                 goto errout;
4546         }
4547
4548         /*
4549          * Call newnfs_connect(), as required, and then newnfs_request().
4550          */
4551         dotls = false;
4552         if ((clp->lc_flags & LCL_TLSCB) != 0)
4553                 dotls = true;
4554         (void) newnfs_sndlock(&clp->lc_req.nr_lock);
4555         if (clp->lc_req.nr_client == NULL) {
4556                 if ((clp->lc_flags & LCL_NFSV41) != 0) {
4557                         error = ECONNREFUSED;
4558                         nfsrv_freesession(sep, NULL);
4559                 } else if (nd->nd_procnum == NFSV4PROC_CBNULL)
4560                         error = newnfs_connect(NULL, &clp->lc_req, cred,
4561                             NULL, 1, dotls);
4562                 else
4563                         error = newnfs_connect(NULL, &clp->lc_req, cred,
4564                             NULL, 3, dotls);
4565         }
4566         newnfs_sndunlock(&clp->lc_req.nr_lock);
4567         NFSD_DEBUG(4, "aft sndunlock=%d\n", error);
4568         if (!error) {
4569                 if ((nd->nd_flag & ND_NFSV41) != 0) {
4570                         KASSERT(sep != NULL, ("sep NULL"));
4571                         if (sep->sess_cbsess.nfsess_xprt != NULL)
4572                                 error = newnfs_request(nd, NULL, clp,
4573                                     &clp->lc_req, NULL, NULL, cred,
4574                                     clp->lc_program, clp->lc_req.nr_vers, NULL,
4575                                     1, NULL, &sep->sess_cbsess);
4576                         else {
4577                                 /*
4578                                  * This should probably never occur, but if a
4579                                  * client somehow does an RPC without a
4580                                  * SequenceID Op that causes a callback just
4581                                  * after the nfsd threads have been terminated
4582                                  * and restared we could conceivably get here
4583                                  * without a backchannel xprt.
4584                                  */
4585                                 printf("nfsrv_docallback: no xprt\n");
4586                                 error = ECONNREFUSED;
4587                         }
4588                         NFSD_DEBUG(4, "aft newnfs_request=%d\n", error);
4589                         nfsrv_freesession(sep, NULL);
4590                 } else
4591                         error = newnfs_request(nd, NULL, clp, &clp->lc_req,
4592                             NULL, NULL, cred, clp->lc_program,
4593                             clp->lc_req.nr_vers, NULL, 1, NULL, NULL);
4594         }
4595 errout:
4596         NFSFREECRED(cred);
4597
4598         /*
4599          * If error is set here, the Callback path isn't working
4600          * properly, so twiddle the appropriate LCL_ flags.
4601          * (nd_repstat != 0 indicates the Callback path is working,
4602          *  but the callback failed on the client.)
4603          */
4604         if (error) {
4605                 /*
4606                  * Mark the callback pathway down, which disabled issuing
4607                  * of delegations and gets Renew to return NFSERR_CBPATHDOWN.
4608                  */
4609                 NFSLOCKSTATE();
4610                 clp->lc_flags |= LCL_CBDOWN;
4611                 NFSUNLOCKSTATE();
4612         } else {
4613                 /*
4614                  * Callback worked. If the callback path was down, disable
4615                  * callbacks, so no more delegations will be issued. (This
4616                  * is done on the assumption that the callback pathway is
4617                  * flakey.)
4618                  */
4619                 NFSLOCKSTATE();
4620                 if (clp->lc_flags & LCL_CBDOWN)
4621                         clp->lc_flags &= ~(LCL_CBDOWN | LCL_CALLBACKSON);
4622                 NFSUNLOCKSTATE();
4623                 if (nd->nd_repstat) {
4624                         error = nd->nd_repstat;
4625                         NFSD_DEBUG(1, "nfsrv_docallback op=%d err=%d\n",
4626                             procnum, error);
4627                 } else if (error == 0 && procnum == NFSV4OP_CBGETATTR)
4628                         error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
4629                             NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL,
4630                             p, NULL);
4631                 m_freem(nd->nd_mrep);
4632         }
4633         NFSLOCKSTATE();
4634         clp->lc_cbref--;
4635         if ((clp->lc_flags & LCL_WAKEUPWANTED) && clp->lc_cbref == 0) {
4636                 clp->lc_flags &= ~LCL_WAKEUPWANTED;
4637                 wakeup(clp);
4638         }
4639         NFSUNLOCKSTATE();
4640
4641         free(nd, M_TEMP);
4642         NFSEXITCODE(error);
4643         return (error);
4644 }
4645
4646 /*
4647  * Set up the compound RPC for the callback.
4648  */
4649 static int
4650 nfsrv_cbcallargs(struct nfsrv_descript *nd, struct nfsclient *clp,
4651     uint32_t callback, int op, const char *optag, struct nfsdsession **sepp)
4652 {
4653         uint32_t *tl;
4654         int error, len;
4655
4656         len = strlen(optag);
4657         (void)nfsm_strtom(nd, optag, len);
4658         NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
4659         if ((nd->nd_flag & ND_NFSV41) != 0) {
4660                 if ((nd->nd_flag & ND_NFSV42) != 0)
4661                         *tl++ = txdr_unsigned(NFSV42_MINORVERSION);
4662                 else
4663                         *tl++ = txdr_unsigned(NFSV41_MINORVERSION);
4664                 *tl++ = txdr_unsigned(callback);
4665                 *tl++ = txdr_unsigned(2);
4666                 *tl = txdr_unsigned(NFSV4OP_CBSEQUENCE);
4667                 error = nfsv4_setcbsequence(nd, clp, 1, sepp);
4668                 if (error != 0)
4669                         return (error);
4670                 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
4671                 *tl = txdr_unsigned(op);
4672         } else {
4673                 *tl++ = txdr_unsigned(NFSV4_MINORVERSION);
4674                 *tl++ = txdr_unsigned(callback);
4675                 *tl++ = txdr_unsigned(1);
4676                 *tl = txdr_unsigned(op);
4677         }
4678         return (0);
4679 }
4680
4681 /*
4682  * Return the next index# for a clientid. Mostly just increment and return
4683  * the next one, but... if the 32bit unsigned does actually wrap around,
4684  * it should be rebooted.
4685  * At an average rate of one new client per second, it will wrap around in
4686  * approximately 136 years. (I think the server will have been shut
4687  * down or rebooted before then.)
4688  */
4689 static u_int32_t
4690 nfsrv_nextclientindex(void)
4691 {
4692         static u_int32_t client_index = 0;
4693
4694         client_index++;
4695         if (client_index != 0)
4696                 return (client_index);
4697
4698         printf("%s: out of clientids\n", __func__);
4699         return (client_index);
4700 }
4701
4702 /*
4703  * Return the next index# for a stateid. Mostly just increment and return
4704  * the next one, but... if the 32bit unsigned does actually wrap around
4705  * (will a BSD server stay up that long?), find
4706  * new start and end values.
4707  */
4708 static u_int32_t
4709 nfsrv_nextstateindex(struct nfsclient *clp)
4710 {
4711         struct nfsstate *stp;
4712         int i;
4713         u_int32_t canuse, min_index, max_index;
4714
4715         if (!(clp->lc_flags & LCL_INDEXNOTOK)) {
4716                 clp->lc_stateindex++;
4717                 if (clp->lc_stateindex != clp->lc_statemaxindex)
4718                         return (clp->lc_stateindex);
4719         }
4720
4721         /*
4722          * Yuck, we've hit the end.
4723          * Look for a new min and max.
4724          */
4725         min_index = 0;
4726         max_index = 0xffffffff;
4727         for (i = 0; i < nfsrv_statehashsize; i++) {
4728             LIST_FOREACH(stp, &clp->lc_stateid[i], ls_hash) {
4729                 if (stp->ls_stateid.other[2] > 0x80000000) {
4730                     if (stp->ls_stateid.other[2] < max_index)
4731                         max_index = stp->ls_stateid.other[2];
4732                 } else {
4733                     if (stp->ls_stateid.other[2] > min_index)
4734                         min_index = stp->ls_stateid.other[2];
4735                 }
4736             }
4737         }
4738
4739         /*
4740          * Yikes, highly unlikely, but I'll handle it anyhow.
4741          */
4742         if (min_index == 0x80000000 && max_index == 0x80000001) {
4743             canuse = 0;
4744             /*
4745              * Loop around until we find an unused entry. Return that
4746              * and set LCL_INDEXNOTOK, so the search will continue next time.
4747              * (This is one of those rare cases where a goto is the
4748              *  cleanest way to code the loop.)
4749              */
4750 tryagain:
4751             for (i = 0; i < nfsrv_statehashsize; i++) {
4752                 LIST_FOREACH(stp, &clp->lc_stateid[i], ls_hash) {
4753                     if (stp->ls_stateid.other[2] == canuse) {
4754                         canuse++;
4755                         goto tryagain;
4756                     }
4757                 }
4758             }
4759             clp->lc_flags |= LCL_INDEXNOTOK;
4760             return (canuse);
4761         }
4762
4763         /*
4764          * Ok to start again from min + 1.
4765          */
4766         clp->lc_stateindex = min_index + 1;
4767         clp->lc_statemaxindex = max_index;
4768         clp->lc_flags &= ~LCL_INDEXNOTOK;
4769         return (clp->lc_stateindex);
4770 }
4771
4772 /*
4773  * The following functions handle the stable storage file that deals with
4774  * the edge conditions described in RFC3530 Sec. 8.6.3.
4775  * The file is as follows:
4776  * - a single record at the beginning that has the lease time of the
4777  *   previous server instance (before the last reboot) and the nfsrvboottime
4778  *   values for the previous server boots.
4779  *   These previous boot times are used to ensure that the current
4780  *   nfsrvboottime does not, somehow, get set to a previous one.
4781  *   (This is important so that Stale ClientIDs and StateIDs can
4782  *    be recognized.)
4783  *   The number of previous nfsvrboottime values precedes the list.
4784  * - followed by some number of appended records with:
4785  *   - client id string
4786  *   - flag that indicates it is a record revoking state via lease
4787  *     expiration or similar
4788  *     OR has successfully acquired state.
4789  * These structures vary in length, with the client string at the end, up
4790  * to NFSV4_OPAQUELIMIT in size.
4791  *
4792  * At the end of the grace period, the file is truncated, the first
4793  * record is rewritten with updated information and any acquired state
4794  * records for successful reclaims of state are written.
4795  *
4796  * Subsequent records are appended when the first state is issued to
4797  * a client and when state is revoked for a client.
4798  *
4799  * When reading the file in, state issued records that come later in
4800  * the file override older ones, since the append log is in cronological order.
4801  * If, for some reason, the file can't be read, the grace period is
4802  * immediately terminated and all reclaims get NFSERR_NOGRACE.
4803  */
4804
4805 /*
4806  * Read in the stable storage file. Called by nfssvc() before the nfsd
4807  * processes start servicing requests.
4808  */
4809 void
4810 nfsrv_setupstable(NFSPROC_T *p)
4811 {
4812         struct nfsrv_stablefirst *sf = &nfsrv_stablefirst;
4813         struct nfsrv_stable *sp, *nsp;
4814         struct nfst_rec *tsp;
4815         int error, i, tryagain;
4816         off_t off = 0;
4817         ssize_t aresid, len;
4818
4819         /*
4820          * If NFSNSF_UPDATEDONE is set, this is a restart of the nfsds without
4821          * a reboot, so state has not been lost.
4822          */
4823         if (sf->nsf_flags & NFSNSF_UPDATEDONE)
4824                 return;
4825         /*
4826          * Set Grace over just until the file reads successfully.
4827          */
4828         nfsrvboottime = time_second;
4829         LIST_INIT(&sf->nsf_head);
4830         sf->nsf_flags = (NFSNSF_GRACEOVER | NFSNSF_NEEDLOCK);
4831         sf->nsf_eograce = NFSD_MONOSEC + NFSRV_LEASEDELTA;
4832         if (sf->nsf_fp == NULL)
4833                 return;
4834         error = NFSD_RDWR(UIO_READ, NFSFPVNODE(sf->nsf_fp),
4835             (caddr_t)&sf->nsf_rec, sizeof (struct nfsf_rec), off, UIO_SYSSPACE,
4836             0, NFSFPCRED(sf->nsf_fp), &aresid, p);
4837         if (error || aresid || sf->nsf_numboots == 0 ||
4838                 sf->nsf_numboots > NFSNSF_MAXNUMBOOTS)
4839                 return;
4840
4841         /*
4842          * Now, read in the boottimes.
4843          */
4844         sf->nsf_bootvals = (time_t *)malloc((sf->nsf_numboots + 1) *
4845                 sizeof (time_t), M_TEMP, M_WAITOK);
4846         off = sizeof (struct nfsf_rec);
4847         error = NFSD_RDWR(UIO_READ, NFSFPVNODE(sf->nsf_fp),
4848             (caddr_t)sf->nsf_bootvals, sf->nsf_numboots * sizeof (time_t), off,
4849             UIO_SYSSPACE, 0, NFSFPCRED(sf->nsf_fp), &aresid, p);
4850         if (error || aresid) {
4851                 free(sf->nsf_bootvals, M_TEMP);
4852                 sf->nsf_bootvals = NULL;
4853                 return;
4854         }
4855
4856         /*
4857          * Make sure this nfsrvboottime is different from all recorded
4858          * previous ones.
4859          */
4860         do {
4861                 tryagain = 0;
4862                 for (i = 0; i < sf->nsf_numboots; i++) {
4863                         if (nfsrvboottime == sf->nsf_bootvals[i]) {
4864                                 nfsrvboottime++;
4865                                 tryagain = 1;
4866                                 break;
4867                         }
4868                 }
4869         } while (tryagain);
4870
4871         sf->nsf_flags |= NFSNSF_OK;
4872         off += (sf->nsf_numboots * sizeof (time_t));
4873
4874         /*
4875          * Read through the file, building a list of records for grace
4876          * checking.
4877          * Each record is between sizeof (struct nfst_rec) and
4878          * sizeof (struct nfst_rec) + NFSV4_OPAQUELIMIT - 1
4879          * and is actually sizeof (struct nfst_rec) + nst_len - 1.
4880          */
4881         tsp = (struct nfst_rec *)malloc(sizeof (struct nfst_rec) +
4882                 NFSV4_OPAQUELIMIT - 1, M_TEMP, M_WAITOK);
4883         do {
4884             error = NFSD_RDWR(UIO_READ, NFSFPVNODE(sf->nsf_fp),
4885                 (caddr_t)tsp, sizeof (struct nfst_rec) + NFSV4_OPAQUELIMIT - 1,
4886                 off, UIO_SYSSPACE, 0, NFSFPCRED(sf->nsf_fp), &aresid, p);
4887             len = (sizeof (struct nfst_rec) + NFSV4_OPAQUELIMIT - 1) - aresid;
4888             if (error || (len > 0 && (len < sizeof (struct nfst_rec) ||
4889                 len < (sizeof (struct nfst_rec) + tsp->len - 1)))) {
4890                 /*
4891                  * Yuck, the file has been corrupted, so just return
4892                  * after clearing out any restart state, so the grace period
4893                  * is over.
4894                  */
4895                 LIST_FOREACH_SAFE(sp, &sf->nsf_head, nst_list, nsp) {
4896                         LIST_REMOVE(sp, nst_list);
4897                         free(sp, M_TEMP);
4898                 }
4899                 free(tsp, M_TEMP);
4900                 sf->nsf_flags &= ~NFSNSF_OK;
4901                 free(sf->nsf_bootvals, M_TEMP);
4902                 sf->nsf_bootvals = NULL;
4903                 return;
4904             }
4905             if (len > 0) {
4906                 off += sizeof (struct nfst_rec) + tsp->len - 1;
4907                 /*
4908                  * Search the list for a matching client.
4909                  */
4910                 LIST_FOREACH(sp, &sf->nsf_head, nst_list) {
4911                         if (tsp->len == sp->nst_len &&
4912                             !NFSBCMP(tsp->client, sp->nst_client, tsp->len))
4913                                 break;
4914                 }
4915                 if (sp == LIST_END(&sf->nsf_head)) {
4916                         sp = (struct nfsrv_stable *)malloc(tsp->len +
4917                                 sizeof (struct nfsrv_stable) - 1, M_TEMP,
4918                                 M_WAITOK);
4919                         NFSBCOPY((caddr_t)tsp, (caddr_t)&sp->nst_rec,
4920                                 sizeof (struct nfst_rec) + tsp->len - 1);
4921                         LIST_INSERT_HEAD(&sf->nsf_head, sp, nst_list);
4922                 } else {
4923                         if (tsp->flag == NFSNST_REVOKE)
4924                                 sp->nst_flag |= NFSNST_REVOKE;
4925                         else
4926                                 /*
4927                                  * A subsequent timestamp indicates the client
4928                                  * did a setclientid/confirm and any previous
4929                                  * revoke is no longer relevant.
4930                                  */
4931                                 sp->nst_flag &= ~NFSNST_REVOKE;
4932                 }
4933             }
4934         } while (len > 0);
4935         free(tsp, M_TEMP);
4936         sf->nsf_flags = NFSNSF_OK;
4937         sf->nsf_eograce = NFSD_MONOSEC + sf->nsf_lease +
4938                 NFSRV_LEASEDELTA;
4939 }
4940
4941 /*
4942  * Update the stable storage file, now that the grace period is over.
4943  */
4944 void
4945 nfsrv_updatestable(NFSPROC_T *p)
4946 {
4947         struct nfsrv_stablefirst *sf = &nfsrv_stablefirst;
4948         struct nfsrv_stable *sp, *nsp;
4949         int i;
4950         struct nfsvattr nva;
4951         vnode_t vp;
4952 #if defined(__FreeBSD_version) && (__FreeBSD_version >= 500000)
4953         mount_t mp = NULL;
4954 #endif
4955         int error;
4956
4957         if (sf->nsf_fp == NULL || (sf->nsf_flags & NFSNSF_UPDATEDONE))
4958                 return;
4959         sf->nsf_flags |= NFSNSF_UPDATEDONE;
4960         /*
4961          * Ok, we need to rewrite the stable storage file.
4962          * - truncate to 0 length
4963          * - write the new first structure
4964          * - loop through the data structures, writing out any that
4965          *   have timestamps older than the old boot
4966          */
4967         if (sf->nsf_bootvals) {
4968                 sf->nsf_numboots++;
4969                 for (i = sf->nsf_numboots - 2; i >= 0; i--)
4970                         sf->nsf_bootvals[i + 1] = sf->nsf_bootvals[i];
4971         } else {
4972                 sf->nsf_numboots = 1;
4973                 sf->nsf_bootvals = (time_t *)malloc(sizeof (time_t),
4974                         M_TEMP, M_WAITOK);
4975         }
4976         sf->nsf_bootvals[0] = nfsrvboottime;
4977         sf->nsf_lease = nfsrv_lease;
4978         NFSVNO_ATTRINIT(&nva);
4979         NFSVNO_SETATTRVAL(&nva, size, 0);
4980         vp = NFSFPVNODE(sf->nsf_fp);
4981         vn_start_write(vp, &mp, V_WAIT);
4982         if (NFSVOPLOCK(vp, LK_EXCLUSIVE) == 0) {
4983                 error = nfsvno_setattr(vp, &nva, NFSFPCRED(sf->nsf_fp), p,
4984                     NULL);
4985                 NFSVOPUNLOCK(vp);
4986         } else
4987                 error = EPERM;
4988         vn_finished_write(mp);
4989         if (!error)
4990             error = NFSD_RDWR(UIO_WRITE, vp,
4991                 (caddr_t)&sf->nsf_rec, sizeof (struct nfsf_rec), (off_t)0,
4992                 UIO_SYSSPACE, IO_SYNC, NFSFPCRED(sf->nsf_fp), NULL, p);
4993         if (!error)
4994             error = NFSD_RDWR(UIO_WRITE, vp,
4995                 (caddr_t)sf->nsf_bootvals,
4996                 sf->nsf_numboots * sizeof (time_t),
4997                 (off_t)(sizeof (struct nfsf_rec)),
4998                 UIO_SYSSPACE, IO_SYNC, NFSFPCRED(sf->nsf_fp), NULL, p);
4999         free(sf->nsf_bootvals, M_TEMP);
5000         sf->nsf_bootvals = NULL;
5001         if (error) {
5002                 sf->nsf_flags &= ~NFSNSF_OK;
5003                 printf("EEK! Can't write NfsV4 stable storage file\n");
5004                 return;
5005         }
5006         sf->nsf_flags |= NFSNSF_OK;
5007
5008         /*
5009          * Loop through the list and write out timestamp records for
5010          * any clients that successfully reclaimed state.
5011          */
5012         LIST_FOREACH_SAFE(sp, &sf->nsf_head, nst_list, nsp) {
5013                 if (sp->nst_flag & NFSNST_GOTSTATE) {
5014                         nfsrv_writestable(sp->nst_client, sp->nst_len,
5015                                 NFSNST_NEWSTATE, p);
5016                         sp->nst_clp->lc_flags |= LCL_STAMPEDSTABLE;
5017                 }
5018                 LIST_REMOVE(sp, nst_list);
5019                 free(sp, M_TEMP);
5020         }
5021         nfsrv_backupstable();
5022 }
5023
5024 /*
5025  * Append a record to the stable storage file.
5026  */
5027 void
5028 nfsrv_writestable(u_char *client, int len, int flag, NFSPROC_T *p)
5029 {
5030         struct nfsrv_stablefirst *sf = &nfsrv_stablefirst;
5031         struct nfst_rec *sp;
5032         int error;
5033
5034         if (!(sf->nsf_flags & NFSNSF_OK) || sf->nsf_fp == NULL)
5035                 return;
5036         sp = (struct nfst_rec *)malloc(sizeof (struct nfst_rec) +
5037                 len - 1, M_TEMP, M_WAITOK);
5038         sp->len = len;
5039         NFSBCOPY(client, sp->client, len);
5040         sp->flag = flag;
5041         error = NFSD_RDWR(UIO_WRITE, NFSFPVNODE(sf->nsf_fp),
5042             (caddr_t)sp, sizeof (struct nfst_rec) + len - 1, (off_t)0,
5043             UIO_SYSSPACE, (IO_SYNC | IO_APPEND), NFSFPCRED(sf->nsf_fp), NULL, p);
5044         free(sp, M_TEMP);
5045         if (error) {
5046                 sf->nsf_flags &= ~NFSNSF_OK;
5047                 printf("EEK! Can't write NfsV4 stable storage file\n");
5048         }
5049 }
5050
5051 /*
5052  * This function is called during the grace period to mark a client
5053  * that successfully reclaimed state.
5054  */
5055 static void
5056 nfsrv_markstable(struct nfsclient *clp)
5057 {
5058         struct nfsrv_stable *sp;
5059
5060         /*
5061          * First find the client structure.
5062          */
5063         LIST_FOREACH(sp, &nfsrv_stablefirst.nsf_head, nst_list) {
5064                 if (sp->nst_len == clp->lc_idlen &&
5065                     !NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
5066                         break;
5067         }
5068         if (sp == LIST_END(&nfsrv_stablefirst.nsf_head))
5069                 return;
5070
5071         /*
5072          * Now, just mark it and set the nfsclient back pointer.
5073          */
5074         sp->nst_flag |= NFSNST_GOTSTATE;
5075         sp->nst_clp = clp;
5076 }
5077
5078 /*
5079  * This function is called when a NFSv4.1 client does a ReclaimComplete.
5080  * Very similar to nfsrv_markstable(), except for the flag being set.
5081  */
5082 static void
5083 nfsrv_markreclaim(struct nfsclient *clp)
5084 {
5085         struct nfsrv_stable *sp;
5086
5087         /*
5088          * First find the client structure.
5089          */
5090         LIST_FOREACH(sp, &nfsrv_stablefirst.nsf_head, nst_list) {
5091                 if (sp->nst_len == clp->lc_idlen &&
5092                     !NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
5093                         break;
5094         }
5095         if (sp == LIST_END(&nfsrv_stablefirst.nsf_head))
5096                 return;
5097
5098         /*
5099          * Now, just set the flag.
5100          */
5101         sp->nst_flag |= NFSNST_RECLAIMED;
5102 }
5103
5104 /*
5105  * This function is called for a reclaim, to see if it gets grace.
5106  * It returns 0 if a reclaim is allowed, 1 otherwise.
5107  */
5108 static int
5109 nfsrv_checkstable(struct nfsclient *clp)
5110 {
5111         struct nfsrv_stable *sp;
5112
5113         /*
5114          * First, find the entry for the client.
5115          */
5116         LIST_FOREACH(sp, &nfsrv_stablefirst.nsf_head, nst_list) {
5117                 if (sp->nst_len == clp->lc_idlen &&
5118                     !NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
5119                         break;
5120         }
5121
5122         /*
5123          * If not in the list, state was revoked or no state was issued
5124          * since the previous reboot, a reclaim is denied.
5125          */
5126         if (sp == LIST_END(&nfsrv_stablefirst.nsf_head) ||
5127             (sp->nst_flag & NFSNST_REVOKE) ||
5128             !(nfsrv_stablefirst.nsf_flags & NFSNSF_OK))
5129                 return (1);
5130         return (0);
5131 }
5132
5133 /*
5134  * Test for and try to clear out a conflicting client. This is called by
5135  * nfsrv_lockctrl() and nfsrv_openctrl() when conflicts with other clients
5136  * a found.
5137  * The trick here is that it can't revoke a conflicting client with an
5138  * expired lease unless it holds the v4root lock, so...
5139  * If no v4root lock, get the lock and return 1 to indicate "try again".
5140  * Return 0 to indicate the conflict can't be revoked and 1 to indicate
5141  * the revocation worked and the conflicting client is "bye, bye", so it
5142  * can be tried again.
5143  * Return 2 to indicate that the vnode is VIRF_DOOMED after NFSVOPLOCK().
5144  * Unlocks State before a non-zero value is returned.
5145  */
5146 static int
5147 nfsrv_clientconflict(struct nfsclient *clp, int *haslockp, vnode_t vp,
5148     NFSPROC_T *p)
5149 {
5150         int gotlock, lktype = 0;
5151
5152         /*
5153          * If lease hasn't expired, we can't fix it.
5154          */
5155         if (clp->lc_expiry >= NFSD_MONOSEC ||
5156             !(nfsrv_stablefirst.nsf_flags & NFSNSF_UPDATEDONE))
5157                 return (0);
5158         if (*haslockp == 0) {
5159                 NFSUNLOCKSTATE();
5160                 if (vp != NULL) {
5161                         lktype = NFSVOPISLOCKED(vp);
5162                         NFSVOPUNLOCK(vp);
5163                 }
5164                 NFSLOCKV4ROOTMUTEX();
5165                 nfsv4_relref(&nfsv4rootfs_lock);
5166                 do {
5167                         gotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
5168                             NFSV4ROOTLOCKMUTEXPTR, NULL);
5169                 } while (!gotlock);
5170                 NFSUNLOCKV4ROOTMUTEX();
5171                 *haslockp = 1;
5172                 if (vp != NULL) {
5173                         NFSVOPLOCK(vp, lktype | LK_RETRY);
5174                         if (VN_IS_DOOMED(vp))
5175                                 return (2);
5176                 }
5177                 return (1);
5178         }
5179         NFSUNLOCKSTATE();
5180
5181         /*
5182          * Ok, we can expire the conflicting client.
5183          */
5184         nfsrv_writestable(clp->lc_id, clp->lc_idlen, NFSNST_REVOKE, p);
5185         nfsrv_backupstable();
5186         nfsrv_cleanclient(clp, p);
5187         nfsrv_freedeleglist(&clp->lc_deleg);
5188         nfsrv_freedeleglist(&clp->lc_olddeleg);
5189         LIST_REMOVE(clp, lc_hash);
5190         nfsrv_zapclient(clp, p);
5191         return (1);
5192 }
5193
5194 /*
5195  * Resolve a delegation conflict.
5196  * Returns 0 to indicate the conflict was resolved without sleeping.
5197  * Return -1 to indicate that the caller should check for conflicts again.
5198  * Return > 0 for an error that should be returned, normally NFSERR_DELAY.
5199  *
5200  * Also, manipulate the nfsv4root_lock, as required. It isn't changed
5201  * for a return of 0, since there was no sleep and it could be required
5202  * later. It is released for a return of NFSERR_DELAY, since the caller
5203  * will return that error. It is released when a sleep was done waiting
5204  * for the delegation to be returned or expire (so that other nfsds can
5205  * handle ops). Then, it must be acquired for the write to stable storage.
5206  * (This function is somewhat similar to nfsrv_clientconflict(), but
5207  *  the semantics differ in a couple of subtle ways. The return of 0
5208  *  indicates the conflict was resolved without sleeping here, not
5209  *  that the conflict can't be resolved and the handling of nfsv4root_lock
5210  *  differs, as noted above.)
5211  * Unlocks State before returning a non-zero value.
5212  */
5213 static int
5214 nfsrv_delegconflict(struct nfsstate *stp, int *haslockp, NFSPROC_T *p,
5215     vnode_t vp)
5216 {
5217         struct nfsclient *clp = stp->ls_clp;
5218         int gotlock, error, lktype = 0, retrycnt, zapped_clp;
5219         nfsv4stateid_t tstateid;
5220         fhandle_t tfh;
5221
5222         /*
5223          * If the conflict is with an old delegation...
5224          */
5225         if (stp->ls_flags & NFSLCK_OLDDELEG) {
5226                 /*
5227                  * You can delete it, if it has expired.
5228                  */
5229                 if (clp->lc_delegtime < NFSD_MONOSEC) {
5230                         nfsrv_freedeleg(stp);
5231                         NFSUNLOCKSTATE();
5232                         error = -1;
5233                         goto out;
5234                 }
5235                 NFSUNLOCKSTATE();
5236                 /*
5237                  * During this delay, the old delegation could expire or it
5238                  * could be recovered by the client via an Open with
5239                  * CLAIM_DELEGATE_PREV.
5240                  * Release the nfsv4root_lock, if held.
5241                  */
5242                 if (*haslockp) {
5243                         *haslockp = 0;
5244                         NFSLOCKV4ROOTMUTEX();
5245                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
5246                         NFSUNLOCKV4ROOTMUTEX();
5247                 }
5248                 error = NFSERR_DELAY;
5249                 goto out;
5250         }
5251
5252         /*
5253          * It's a current delegation, so:
5254          * - check to see if the delegation has expired
5255          *   - if so, get the v4root lock and then expire it
5256          */
5257         if (!(stp->ls_flags & NFSLCK_DELEGRECALL)) {
5258                 /*
5259                  * - do a recall callback, since not yet done
5260                  * For now, never allow truncate to be set. To use
5261                  * truncate safely, it must be guaranteed that the
5262                  * Remove, Rename or Setattr with size of 0 will
5263                  * succeed and that would require major changes to
5264                  * the VFS/Vnode OPs.
5265                  * Set the expiry time large enough so that it won't expire
5266                  * until after the callback, then set it correctly, once
5267                  * the callback is done. (The delegation will now time
5268                  * out whether or not the Recall worked ok. The timeout
5269                  * will be extended when ops are done on the delegation
5270                  * stateid, up to the timelimit.)
5271                  */
5272                 stp->ls_delegtime = NFSD_MONOSEC + (2 * nfsrv_lease) +
5273                     NFSRV_LEASEDELTA;
5274                 stp->ls_delegtimelimit = NFSD_MONOSEC + (6 * nfsrv_lease) +
5275                     NFSRV_LEASEDELTA;
5276                 stp->ls_flags |= NFSLCK_DELEGRECALL;
5277
5278                 /*
5279                  * Loop NFSRV_CBRETRYCNT times while the CBRecall replies
5280                  * NFSERR_BADSTATEID or NFSERR_BADHANDLE. This is done
5281                  * in order to try and avoid a race that could happen
5282                  * when a CBRecall request passed the Open reply with
5283                  * the delegation in it when transitting the network.
5284                  * Since nfsrv_docallback will sleep, don't use stp after
5285                  * the call.
5286                  */
5287                 NFSBCOPY((caddr_t)&stp->ls_stateid, (caddr_t)&tstateid,
5288                     sizeof (tstateid));
5289                 NFSBCOPY((caddr_t)&stp->ls_lfp->lf_fh, (caddr_t)&tfh,
5290                     sizeof (tfh));
5291                 NFSUNLOCKSTATE();
5292                 if (*haslockp) {
5293                         *haslockp = 0;
5294                         NFSLOCKV4ROOTMUTEX();
5295                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
5296                         NFSUNLOCKV4ROOTMUTEX();
5297                 }
5298                 retrycnt = 0;
5299                 do {
5300                     error = nfsrv_docallback(clp, NFSV4OP_CBRECALL,
5301                         &tstateid, 0, &tfh, NULL, NULL, 0, p);
5302                     retrycnt++;
5303                 } while ((error == NFSERR_BADSTATEID ||
5304                     error == NFSERR_BADHANDLE) && retrycnt < NFSV4_CBRETRYCNT);
5305                 error = NFSERR_DELAY;
5306                 goto out;
5307         }
5308
5309         if (clp->lc_expiry >= NFSD_MONOSEC &&
5310             stp->ls_delegtime >= NFSD_MONOSEC) {
5311                 NFSUNLOCKSTATE();
5312                 /*
5313                  * A recall has been done, but it has not yet expired.
5314                  * So, RETURN_DELAY.
5315                  */
5316                 if (*haslockp) {
5317                         *haslockp = 0;
5318                         NFSLOCKV4ROOTMUTEX();
5319                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
5320                         NFSUNLOCKV4ROOTMUTEX();
5321                 }
5322                 error = NFSERR_DELAY;
5323                 goto out;
5324         }
5325
5326         /*
5327          * If we don't yet have the lock, just get it and then return,
5328          * since we need that before deleting expired state, such as
5329          * this delegation.
5330          * When getting the lock, unlock the vnode, so other nfsds that
5331          * are in progress, won't get stuck waiting for the vnode lock.
5332          */
5333         if (*haslockp == 0) {
5334                 NFSUNLOCKSTATE();
5335                 if (vp != NULL) {
5336                         lktype = NFSVOPISLOCKED(vp);
5337                         NFSVOPUNLOCK(vp);
5338                 }
5339                 NFSLOCKV4ROOTMUTEX();
5340                 nfsv4_relref(&nfsv4rootfs_lock);
5341                 do {
5342                         gotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
5343                             NFSV4ROOTLOCKMUTEXPTR, NULL);
5344                 } while (!gotlock);
5345                 NFSUNLOCKV4ROOTMUTEX();
5346                 *haslockp = 1;
5347                 if (vp != NULL) {
5348                         NFSVOPLOCK(vp, lktype | LK_RETRY);
5349                         if (VN_IS_DOOMED(vp)) {
5350                                 *haslockp = 0;
5351                                 NFSLOCKV4ROOTMUTEX();
5352                                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
5353                                 NFSUNLOCKV4ROOTMUTEX();
5354                                 error = NFSERR_PERM;
5355                                 goto out;
5356                         }
5357                 }
5358                 error = -1;
5359                 goto out;
5360         }
5361
5362         NFSUNLOCKSTATE();
5363         /*
5364          * Ok, we can delete the expired delegation.
5365          * First, write the Revoke record to stable storage and then
5366          * clear out the conflict.
5367          * Since all other nfsd threads are now blocked, we can safely
5368          * sleep without the state changing.
5369          */
5370         nfsrv_writestable(clp->lc_id, clp->lc_idlen, NFSNST_REVOKE, p);
5371         nfsrv_backupstable();
5372         if (clp->lc_expiry < NFSD_MONOSEC) {
5373                 nfsrv_cleanclient(clp, p);
5374                 nfsrv_freedeleglist(&clp->lc_deleg);
5375                 nfsrv_freedeleglist(&clp->lc_olddeleg);
5376                 LIST_REMOVE(clp, lc_hash);
5377                 zapped_clp = 1;
5378         } else {
5379                 nfsrv_freedeleg(stp);
5380                 zapped_clp = 0;
5381         }
5382         if (zapped_clp)
5383                 nfsrv_zapclient(clp, p);
5384         error = -1;
5385
5386 out:
5387         NFSEXITCODE(error);
5388         return (error);
5389 }
5390
5391 /*
5392  * Check for a remove allowed, if remove is set to 1 and get rid of
5393  * delegations.
5394  */
5395 int
5396 nfsrv_checkremove(vnode_t vp, int remove, struct nfsrv_descript *nd,
5397     nfsquad_t clientid, NFSPROC_T *p)
5398 {
5399         struct nfsclient *clp;
5400         struct nfsstate *stp;
5401         struct nfslockfile *lfp;
5402         int error, haslock = 0;
5403         fhandle_t nfh;
5404
5405         clp = NULL;
5406         /*
5407          * First, get the lock file structure.
5408          * (A return of -1 means no associated state, so remove ok.)
5409          */
5410         error = nfsrv_getlockfh(vp, NFSLCK_CHECK, NULL, &nfh, p);
5411 tryagain:
5412         NFSLOCKSTATE();
5413         if (error == 0 && clientid.qval != 0)
5414                 error = nfsrv_getclient(clientid, CLOPS_RENEW, &clp, NULL,
5415                     (nfsquad_t)((u_quad_t)0), 0, nd, p);
5416         if (!error)
5417                 error = nfsrv_getlockfile(NFSLCK_CHECK, NULL, &lfp, &nfh, 0);
5418         if (error) {
5419                 NFSUNLOCKSTATE();
5420                 if (haslock) {
5421                         NFSLOCKV4ROOTMUTEX();
5422                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
5423                         NFSUNLOCKV4ROOTMUTEX();
5424                 }
5425                 if (error == -1)
5426                         error = 0;
5427                 goto out;
5428         }
5429
5430         /*
5431          * Now, we must Recall any delegations.
5432          */
5433         error = nfsrv_cleandeleg(vp, lfp, clp, &haslock, p);
5434         if (error) {
5435                 /*
5436                  * nfsrv_cleandeleg() unlocks state for non-zero
5437                  * return.
5438                  */
5439                 if (error == -1)
5440                         goto tryagain;
5441                 if (haslock) {
5442                         NFSLOCKV4ROOTMUTEX();
5443                         nfsv4_unlock(&nfsv4rootfs_lock, 1);
5444                         NFSUNLOCKV4ROOTMUTEX();
5445                 }
5446                 goto out;
5447         }
5448
5449         /*
5450          * Now, look for a conflicting open share.
5451          */
5452         if (remove) {
5453                 /*
5454                  * If the entry in the directory was the last reference to the
5455                  * corresponding filesystem object, the object can be destroyed
5456                  * */
5457                 if(lfp->lf_usecount>1)
5458                         LIST_FOREACH(stp, &lfp->lf_open, ls_file) {
5459                                 if (stp->ls_flags & NFSLCK_WRITEDENY) {
5460                                         error = NFSERR_FILEOPEN;
5461                                         break;
5462                                 }
5463                         }
5464         }
5465
5466         NFSUNLOCKSTATE();
5467         if (haslock) {
5468                 NFSLOCKV4ROOTMUTEX();
5469                 nfsv4_unlock(&nfsv4rootfs_lock, 1);
5470                 NFSUNLOCKV4ROOTMUTEX();
5471         }
5472
5473 out:
5474         NFSEXITCODE(error);
5475         return (error);
5476 }
5477
5478 /*
5479  * Clear out all delegations for the file referred to by lfp.
5480  * May return NFSERR_DELAY, if there will be a delay waiting for
5481  * delegations to expire.
5482  * Returns -1 to indicate it slept while recalling a delegation.
5483  * This function has the side effect of deleting the nfslockfile structure,
5484  * if it no longer has associated state and didn't have to sleep.
5485  * Unlocks State before a non-zero value is returned.
5486  */
5487 static int
5488 nfsrv_cleandeleg(vnode_t vp, struct nfslockfile *lfp,
5489     struct nfsclient *clp, int *haslockp, NFSPROC_T *p)
5490 {
5491         struct nfsstate *stp, *nstp;
5492         int ret = 0;
5493
5494         stp = LIST_FIRST(&lfp->lf_deleg);
5495         while (stp != LIST_END(&lfp->lf_deleg)) {
5496                 nstp = LIST_NEXT(stp, ls_file);
5497                 if (stp->ls_clp != clp) {
5498                         ret = nfsrv_delegconflict(stp, haslockp, p, vp);
5499                         if (ret) {
5500                                 /*
5501                                  * nfsrv_delegconflict() unlocks state
5502                                  * when it returns non-zero.
5503                                  */
5504                                 goto out;
5505                         }
5506                 }
5507                 stp = nstp;
5508         }
5509 out:
5510         NFSEXITCODE(ret);
5511         return (ret);
5512 }
5513
5514 /*
5515  * There are certain operations that, when being done outside of NFSv4,
5516  * require that any NFSv4 delegation for the file be recalled.
5517  * This function is to be called for those cases:
5518  * VOP_RENAME() - When a delegation is being recalled for any reason,
5519  *      the client may have to do Opens against the server, using the file's
5520  *      final component name. If the file has been renamed on the server,
5521  *      that component name will be incorrect and the Open will fail.
5522  * VOP_REMOVE() - Theoretically, a client could Open a file after it has
5523  *      been removed on the server, if there is a delegation issued to
5524  *      that client for the file. I say "theoretically" since clients
5525  *      normally do an Access Op before the Open and that Access Op will
5526  *      fail with ESTALE. Note that NFSv2 and 3 don't even do Opens, so
5527  *      they will detect the file's removal in the same manner. (There is
5528  *      one case where RFC3530 allows a client to do an Open without first
5529  *      doing an Access Op, which is passage of a check against the ACE
5530  *      returned with a Write delegation, but current practice is to ignore
5531  *      the ACE and always do an Access Op.)
5532  *      Since the functions can only be called with an unlocked vnode, this
5533  *      can't be done at this time.
5534  * VOP_ADVLOCK() - When a client holds a delegation, it can issue byte range
5535  *      locks locally in the client, which are not visible to the server. To
5536  *      deal with this, issuing of delegations for a vnode must be disabled
5537  *      and all delegations for the vnode recalled. This is done via the
5538  *      second function, using the VV_DISABLEDELEG vflag on the vnode.
5539  */
5540 void
5541 nfsd_recalldelegation(vnode_t vp, NFSPROC_T *p)
5542 {
5543         time_t starttime;
5544         int error;
5545
5546         /*
5547          * First, check to see if the server is currently running and it has
5548          * been called for a regular file when issuing delegations.
5549          */
5550         if (newnfs_numnfsd == 0 || vp->v_type != VREG ||
5551             nfsrv_issuedelegs == 0)
5552                 return;
5553
5554         KASSERT((NFSVOPISLOCKED(vp) != LK_EXCLUSIVE), ("vp %p is locked", vp));
5555         /*
5556          * First, get a reference on the nfsv4rootfs_lock so that an
5557          * exclusive lock cannot be acquired by another thread.
5558          */
5559         NFSLOCKV4ROOTMUTEX();
5560         nfsv4_getref(&nfsv4rootfs_lock, NULL, NFSV4ROOTLOCKMUTEXPTR, NULL);
5561         NFSUNLOCKV4ROOTMUTEX();
5562
5563         /*
5564          * Now, call nfsrv_checkremove() in a loop while it returns
5565          * NFSERR_DELAY. Return upon any other error or when timed out.
5566          */
5567         starttime = NFSD_MONOSEC;
5568         do {
5569                 if (NFSVOPLOCK(vp, LK_EXCLUSIVE) == 0) {
5570                         error = nfsrv_checkremove(vp, 0, NULL,
5571                             (nfsquad_t)((u_quad_t)0), p);
5572                         NFSVOPUNLOCK(vp);
5573                 } else
5574                         error = EPERM;
5575                 if (error == NFSERR_DELAY) {
5576                         if (NFSD_MONOSEC - starttime > NFS_REMOVETIMEO)
5577                                 break;
5578                         /* Sleep for a short period of time */
5579                         (void) nfs_catnap(PZERO, 0, "nfsremove");
5580                 }
5581         } while (error == NFSERR_DELAY);
5582         NFSLOCKV4ROOTMUTEX();
5583         nfsv4_relref(&nfsv4rootfs_lock);
5584         NFSUNLOCKV4ROOTMUTEX();
5585 }
5586
5587 void
5588 nfsd_disabledelegation(vnode_t vp, NFSPROC_T *p)
5589 {
5590
5591 #ifdef VV_DISABLEDELEG
5592         /*
5593          * First, flag issuance of delegations disabled.
5594          */
5595         atomic_set_long(&vp->v_vflag, VV_DISABLEDELEG);
5596 #endif
5597
5598         /*
5599          * Then call nfsd_recalldelegation() to get rid of all extant
5600          * delegations.
5601          */
5602         nfsd_recalldelegation(vp, p);
5603 }
5604
5605 /*
5606  * Check for conflicting locks, etc. and then get rid of delegations.
5607  * (At one point I thought that I should get rid of delegations for any
5608  *  Setattr, since it could potentially disallow the I/O op (read or write)
5609  *  allowed by the delegation. However, Setattr Ops that aren't changing
5610  *  the size get a stateid of all 0s, so you can't tell if it is a delegation
5611  *  for the same client or a different one, so I decided to only get rid
5612  *  of delegations for other clients when the size is being changed.)
5613  * In general, a Setattr can disable NFS I/O Ops that are outstanding, such
5614  * as Write backs, even if there is no delegation, so it really isn't any
5615  * different?)
5616  */
5617 int
5618 nfsrv_checksetattr(vnode_t vp, struct nfsrv_descript *nd,
5619     nfsv4stateid_t *stateidp, struct nfsvattr *nvap, nfsattrbit_t *attrbitp,
5620     struct nfsexstuff *exp, NFSPROC_T *p)
5621 {
5622         struct nfsstate st, *stp = &st;
5623         struct nfslock lo, *lop = &lo;
5624         int error = 0;
5625         nfsquad_t clientid;
5626
5627         if (NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_SIZE)) {
5628                 stp->ls_flags = (NFSLCK_CHECK | NFSLCK_WRITEACCESS);
5629                 lop->lo_first = nvap->na_size;
5630         } else {
5631                 stp->ls_flags = 0;
5632                 lop->lo_first = 0;
5633         }
5634         if (NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_OWNER) ||
5635             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_OWNERGROUP) ||
5636             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_MODE) ||
5637             NFSISSET_ATTRBIT(attrbitp, NFSATTRBIT_ACL))
5638                 stp->ls_flags |= NFSLCK_SETATTR;
5639         if (stp->ls_flags == 0)
5640                 goto out;
5641         lop->lo_end = NFS64BITSSET;
5642         lop->lo_flags = NFSLCK_WRITE;
5643         stp->ls_ownerlen = 0;
5644         stp->ls_op = NULL;
5645         stp->ls_uid = nd->nd_cred->cr_uid;
5646         stp->ls_stateid.seqid = stateidp->seqid;
5647         clientid.lval[0] = stp->ls_stateid.other[0] = stateidp->other[0];
5648         clientid.lval[1] = stp->ls_stateid.other[1] = stateidp->other[1];
5649         stp->ls_stateid.other[2] = stateidp->other[2];
5650         error = nfsrv_lockctrl(vp, &stp, &lop, NULL, clientid,
5651             stateidp, exp, nd, p);
5652
5653 out:
5654         NFSEXITCODE2(error, nd);
5655         return (error);
5656 }
5657
5658 /*
5659  * Check for a write delegation and do a CBGETATTR if there is one, updating
5660  * the attributes, as required.
5661  * Should I return an error if I can't get the attributes? (For now, I'll
5662  * just return ok.
5663  */
5664 int
5665 nfsrv_checkgetattr(struct nfsrv_descript *nd, vnode_t vp,
5666     struct nfsvattr *nvap, nfsattrbit_t *attrbitp, NFSPROC_T *p)
5667 {
5668         struct nfsstate *stp;
5669         struct nfslockfile *lfp;
5670         struct nfsclient *clp;
5671         struct nfsvattr nva;
5672         fhandle_t nfh;
5673         int error = 0;
5674         nfsattrbit_t cbbits;
5675         u_quad_t delegfilerev;
5676
5677         NFSCBGETATTR_ATTRBIT(attrbitp, &cbbits);
5678         if (!NFSNONZERO_ATTRBIT(&cbbits))
5679                 goto out;
5680         if (nfsrv_writedelegcnt == 0)
5681                 goto out;
5682
5683         /*
5684          * Get the lock file structure.
5685          * (A return of -1 means no associated state, so return ok.)
5686          */
5687         error = nfsrv_getlockfh(vp, NFSLCK_CHECK, NULL, &nfh, p);
5688         NFSLOCKSTATE();
5689         if (!error)
5690                 error = nfsrv_getlockfile(NFSLCK_CHECK, NULL, &lfp, &nfh, 0);
5691         if (error) {
5692                 NFSUNLOCKSTATE();
5693                 if (error == -1)
5694                         error = 0;
5695                 goto out;
5696         }
5697
5698         /*
5699          * Now, look for a write delegation.
5700          */
5701         LIST_FOREACH(stp, &lfp->lf_deleg, ls_file) {
5702                 if (stp->ls_flags & NFSLCK_DELEGWRITE)
5703                         break;
5704         }
5705         if (stp == LIST_END(&lfp->lf_deleg)) {
5706                 NFSUNLOCKSTATE();
5707                 goto out;
5708         }
5709         clp = stp->ls_clp;
5710         delegfilerev = stp->ls_filerev;
5711
5712         /*
5713          * If the Write delegation was issued as a part of this Compound RPC
5714          * or if we have an Implied Clientid (used in a previous Op in this
5715          * compound) and it is the client the delegation was issued to,
5716          * just return ok.
5717          * I also assume that it is from the same client iff the network
5718          * host IP address is the same as the callback address. (Not
5719          * exactly correct by the RFC, but avoids a lot of Getattr
5720          * callbacks.)
5721          */
5722         if (nd->nd_compref == stp->ls_compref ||
5723             ((nd->nd_flag & ND_IMPLIEDCLID) &&
5724              clp->lc_clientid.qval == nd->nd_clientid.qval) ||
5725              nfsaddr2_match(clp->lc_req.nr_nam, nd->nd_nam)) {
5726                 NFSUNLOCKSTATE();
5727                 goto out;
5728         }
5729
5730         /*
5731          * We are now done with the delegation state structure,
5732          * so the statelock can be released and we can now tsleep().
5733          */
5734
5735         /*
5736          * Now, we must do the CB Getattr callback, to see if Change or Size
5737          * has changed.
5738          */
5739         if (clp->lc_expiry >= NFSD_MONOSEC) {
5740                 NFSUNLOCKSTATE();
5741                 NFSVNO_ATTRINIT(&nva);
5742                 nva.na_filerev = NFS64BITSSET;
5743                 error = nfsrv_docallback(clp, NFSV4OP_CBGETATTR, NULL,
5744                     0, &nfh, &nva, &cbbits, 0, p);
5745                 if (!error) {
5746                         if ((nva.na_filerev != NFS64BITSSET &&
5747                             nva.na_filerev > delegfilerev) ||
5748                             (NFSVNO_ISSETSIZE(&nva) &&
5749                              nva.na_size != nvap->na_size)) {
5750                                 error = nfsvno_updfilerev(vp, nvap, nd, p);
5751                                 if (NFSVNO_ISSETSIZE(&nva))
5752                                         nvap->na_size = nva.na_size;
5753                         }
5754                 } else
5755                         error = 0;      /* Ignore callback errors for now. */
5756         } else {
5757                 NFSUNLOCKSTATE();
5758         }
5759
5760 out:
5761         NFSEXITCODE2(error, nd);
5762         return (error);
5763 }
5764
5765 /*
5766  * This function looks for openowners that haven't had any opens for
5767  * a while and throws them away. Called by an nfsd when NFSNSF_NOOPENS
5768  * is set.
5769  */
5770 void
5771 nfsrv_throwawayopens(NFSPROC_T *p)
5772 {
5773         struct nfsclient *clp, *nclp;
5774         struct nfsstate *stp, *nstp;
5775         int i;
5776
5777         NFSLOCKSTATE();
5778         nfsrv_stablefirst.nsf_flags &= ~NFSNSF_NOOPENS;
5779         /*
5780          * For each client...
5781          */
5782         for (i = 0; i < nfsrv_clienthashsize; i++) {
5783             LIST_FOREACH_SAFE(clp, &nfsclienthash[i], lc_hash, nclp) {
5784                 LIST_FOREACH_SAFE(stp, &clp->lc_open, ls_list, nstp) {
5785                         if (LIST_EMPTY(&stp->ls_open) &&
5786                             (stp->ls_noopens > NFSNOOPEN ||
5787                              (nfsrv_openpluslock * 2) >
5788                              nfsrv_v4statelimit))
5789                                 nfsrv_freeopenowner(stp, 0, p);
5790                 }
5791             }
5792         }
5793         NFSUNLOCKSTATE();
5794 }
5795
5796 /*
5797  * This function checks to see if the credentials are the same.
5798  * Returns 1 for not same, 0 otherwise.
5799  */
5800 static int
5801 nfsrv_notsamecredname(struct nfsrv_descript *nd, struct nfsclient *clp)
5802 {
5803
5804         if (nd->nd_flag & ND_GSS) {
5805                 if (!(clp->lc_flags & LCL_GSS))
5806                         return (1);
5807                 if (clp->lc_flags & LCL_NAME) {
5808                         if (nd->nd_princlen != clp->lc_namelen ||
5809                             NFSBCMP(nd->nd_principal, clp->lc_name,
5810                                 clp->lc_namelen))
5811                                 return (1);
5812                         else
5813                                 return (0);
5814                 }
5815                 if (nd->nd_cred->cr_uid == clp->lc_uid)
5816                         return (0);
5817                 else
5818                         return (1);
5819         } else if (clp->lc_flags & LCL_GSS)
5820                 return (1);
5821         /*
5822          * For AUTH_SYS, allow the same uid or root. (This is underspecified
5823          * in RFC3530, which talks about principals, but doesn't say anything
5824          * about uids for AUTH_SYS.)
5825          */
5826         if (nd->nd_cred->cr_uid == clp->lc_uid || nd->nd_cred->cr_uid == 0)
5827                 return (0);
5828         else
5829                 return (1);
5830 }
5831
5832 /*
5833  * Calculate the lease expiry time.
5834  */
5835 static time_t
5836 nfsrv_leaseexpiry(void)
5837 {
5838
5839         if (nfsrv_stablefirst.nsf_eograce > NFSD_MONOSEC)
5840                 return (NFSD_MONOSEC + 2 * (nfsrv_lease + NFSRV_LEASEDELTA));
5841         return (NFSD_MONOSEC + nfsrv_lease + NFSRV_LEASEDELTA);
5842 }
5843
5844 /*
5845  * Delay the delegation timeout as far as ls_delegtimelimit, as required.
5846  */
5847 static void
5848 nfsrv_delaydelegtimeout(struct nfsstate *stp)
5849 {
5850
5851         if ((stp->ls_flags & NFSLCK_DELEGRECALL) == 0)
5852                 return;
5853
5854         if ((stp->ls_delegtime + 15) > NFSD_MONOSEC &&
5855             stp->ls_delegtime < stp->ls_delegtimelimit) {
5856                 stp->ls_delegtime += nfsrv_lease;
5857                 if (stp->ls_delegtime > stp->ls_delegtimelimit)
5858                         stp->ls_delegtime = stp->ls_delegtimelimit;
5859         }
5860 }
5861
5862 /*
5863  * This function checks to see if there is any other state associated
5864  * with the openowner for this Open.
5865  * It returns 1 if there is no other state, 0 otherwise.
5866  */
5867 static int
5868 nfsrv_nootherstate(struct nfsstate *stp)
5869 {
5870         struct nfsstate *tstp;
5871
5872         LIST_FOREACH(tstp, &stp->ls_openowner->ls_open, ls_list) {
5873                 if (tstp != stp || !LIST_EMPTY(&tstp->ls_lock))
5874                         return (0);
5875         }
5876         return (1);
5877 }
5878
5879 /*
5880  * Create a list of lock deltas (changes to local byte range locking
5881  * that can be rolled back using the list) and apply the changes via
5882  * nfsvno_advlock(). Optionally, lock the list. It is expected that either
5883  * the rollback or update function will be called after this.
5884  * It returns an error (and rolls back, as required), if any nfsvno_advlock()
5885  * call fails. If it returns an error, it will unlock the list.
5886  */
5887 static int
5888 nfsrv_locallock(vnode_t vp, struct nfslockfile *lfp, int flags,
5889     uint64_t first, uint64_t end, struct nfslockconflict *cfp, NFSPROC_T *p)
5890 {
5891         struct nfslock *lop, *nlop;
5892         int error = 0;
5893
5894         /* Loop through the list of locks. */
5895         lop = LIST_FIRST(&lfp->lf_locallock);
5896         while (first < end && lop != NULL) {
5897                 nlop = LIST_NEXT(lop, lo_lckowner);
5898                 if (first >= lop->lo_end) {
5899                         /* not there yet */
5900                         lop = nlop;
5901                 } else if (first < lop->lo_first) {
5902                         /* new one starts before entry in list */
5903                         if (end <= lop->lo_first) {
5904                                 /* no overlap between old and new */
5905                                 error = nfsrv_dolocal(vp, lfp, flags,
5906                                     NFSLCK_UNLOCK, first, end, cfp, p);
5907                                 if (error != 0)
5908                                         break;
5909                                 first = end;
5910                         } else {
5911                                 /* handle fragment overlapped with new one */
5912                                 error = nfsrv_dolocal(vp, lfp, flags,
5913                                     NFSLCK_UNLOCK, first, lop->lo_first, cfp,
5914                                     p);
5915                                 if (error != 0)
5916                                         break;
5917                                 first = lop->lo_first;
5918                         }
5919                 } else {
5920                         /* new one overlaps this entry in list */
5921                         if (end <= lop->lo_end) {
5922                                 /* overlaps all of new one */
5923                                 error = nfsrv_dolocal(vp, lfp, flags,
5924                                     lop->lo_flags, first, end, cfp, p);
5925                                 if (error != 0)
5926                                         break;
5927                                 first = end;
5928                         } else {
5929                                 /* handle fragment overlapped with new one */
5930                                 error = nfsrv_dolocal(vp, lfp, flags,
5931                                     lop->lo_flags, first, lop->lo_end, cfp, p);
5932                                 if (error != 0)
5933                                         break;
5934                                 first = lop->lo_end;
5935                                 lop = nlop;
5936                         }
5937                 }
5938         }
5939         if (first < end && error == 0)
5940                 /* handle fragment past end of list */
5941                 error = nfsrv_dolocal(vp, lfp, flags, NFSLCK_UNLOCK, first,
5942                     end, cfp, p);
5943
5944         NFSEXITCODE(error);
5945         return (error);
5946 }
5947
5948 /*
5949  * Local lock unlock. Unlock all byte ranges that are no longer locked
5950  * by NFSv4. To do this, unlock any subranges of first-->end that
5951  * do not overlap with the byte ranges of any lock in the lfp->lf_lock
5952  * list. This list has all locks for the file held by other
5953  * <clientid, lockowner> tuples. The list is ordered by increasing
5954  * lo_first value, but may have entries that overlap each other, for
5955  * the case of read locks.
5956  */
5957 static void
5958 nfsrv_localunlock(vnode_t vp, struct nfslockfile *lfp, uint64_t init_first,
5959     uint64_t init_end, NFSPROC_T *p)
5960 {
5961         struct nfslock *lop;
5962         uint64_t first, end, prevfirst __unused;
5963
5964         first = init_first;
5965         end = init_end;
5966         while (first < init_end) {
5967                 /* Loop through all nfs locks, adjusting first and end */
5968                 prevfirst = 0;
5969                 LIST_FOREACH(lop, &lfp->lf_lock, lo_lckfile) {
5970                         KASSERT(prevfirst <= lop->lo_first,
5971                             ("nfsv4 locks out of order"));
5972                         KASSERT(lop->lo_first < lop->lo_end,
5973                             ("nfsv4 bogus lock"));
5974                         prevfirst = lop->lo_first;
5975                         if (first >= lop->lo_first &&
5976                             first < lop->lo_end)
5977                                 /*
5978                                  * Overlaps with initial part, so trim
5979                                  * off that initial part by moving first past
5980                                  * it.
5981                                  */
5982                                 first = lop->lo_end;
5983                         else if (end > lop->lo_first &&
5984                             lop->lo_first > first) {
5985                                 /*
5986                                  * This lock defines the end of the
5987                                  * segment to unlock, so set end to the
5988                                  * start of it and break out of the loop.
5989                                  */
5990                                 end = lop->lo_first;
5991                                 break;
5992                         }
5993                         if (first >= end)
5994                                 /*
5995                                  * There is no segment left to do, so
5996                                  * break out of this loop and then exit
5997                                  * the outer while() since first will be set
5998                                  * to end, which must equal init_end here.
5999                                  */
6000                                 break;
6001                 }
6002                 if (first < end) {
6003                         /* Unlock this segment */
6004                         (void) nfsrv_dolocal(vp, lfp, NFSLCK_UNLOCK,
6005                             NFSLCK_READ, first, end, NULL, p);
6006                         nfsrv_locallock_commit(lfp, NFSLCK_UNLOCK,
6007                             first, end);
6008                 }
6009                 /*
6010                  * Now move past this segment and look for any further
6011                  * segment in the range, if there is one.
6012                  */
6013                 first = end;
6014                 end = init_end;
6015         }
6016 }
6017
6018 /*
6019  * Do the local lock operation and update the rollback list, as required.
6020  * Perform the rollback and return the error if nfsvno_advlock() fails.
6021  */
6022 static int
6023 nfsrv_dolocal(vnode_t vp, struct nfslockfile *lfp, int flags, int oldflags,
6024     uint64_t first, uint64_t end, struct nfslockconflict *cfp, NFSPROC_T *p)
6025 {
6026         struct nfsrollback *rlp;
6027         int error = 0, ltype, oldltype;
6028
6029         if (flags & NFSLCK_WRITE)
6030                 ltype = F_WRLCK;
6031         else if (flags & NFSLCK_READ)
6032                 ltype = F_RDLCK;
6033         else
6034                 ltype = F_UNLCK;
6035         if (oldflags & NFSLCK_WRITE)
6036                 oldltype = F_WRLCK;
6037         else if (oldflags & NFSLCK_READ)
6038                 oldltype = F_RDLCK;
6039         else
6040                 oldltype = F_UNLCK;
6041         if (ltype == oldltype || (oldltype == F_WRLCK && ltype == F_RDLCK))
6042                 /* nothing to do */
6043                 goto out;
6044         error = nfsvno_advlock(vp, ltype, first, end, p);
6045         if (error != 0) {
6046                 if (cfp != NULL) {
6047                         cfp->cl_clientid.lval[0] = 0;
6048                         cfp->cl_clientid.lval[1] = 0;
6049                         cfp->cl_first = 0;
6050                         cfp->cl_end = NFS64BITSSET;
6051                         cfp->cl_flags = NFSLCK_WRITE;
6052                         cfp->cl_ownerlen = 5;
6053                         NFSBCOPY("LOCAL", cfp->cl_owner, 5);
6054                 }
6055                 nfsrv_locallock_rollback(vp, lfp, p);
6056         } else if (ltype != F_UNLCK) {
6057                 rlp = malloc(sizeof (struct nfsrollback), M_NFSDROLLBACK,
6058                     M_WAITOK);
6059                 rlp->rlck_first = first;
6060                 rlp->rlck_end = end;
6061                 rlp->rlck_type = oldltype;
6062                 LIST_INSERT_HEAD(&lfp->lf_rollback, rlp, rlck_list);
6063         }
6064
6065 out:
6066         NFSEXITCODE(error);
6067         return (error);
6068 }
6069
6070 /*
6071  * Roll back local lock changes and free up the rollback list.
6072  */
6073 static void
6074 nfsrv_locallock_rollback(vnode_t vp, struct nfslockfile *lfp, NFSPROC_T *p)
6075 {
6076         struct nfsrollback *rlp, *nrlp;
6077
6078         LIST_FOREACH_SAFE(rlp, &lfp->lf_rollback, rlck_list, nrlp) {
6079                 (void) nfsvno_advlock(vp, rlp->rlck_type, rlp->rlck_first,
6080                     rlp->rlck_end, p);
6081                 free(rlp, M_NFSDROLLBACK);
6082         }
6083         LIST_INIT(&lfp->lf_rollback);
6084 }
6085
6086 /*
6087  * Update local lock list and delete rollback list (ie now committed to the
6088  * local locks). Most of the work is done by the internal function.
6089  */
6090 static void
6091 nfsrv_locallock_commit(struct nfslockfile *lfp, int flags, uint64_t first,
6092     uint64_t end)
6093 {
6094         struct nfsrollback *rlp, *nrlp;
6095         struct nfslock *new_lop, *other_lop;
6096
6097         new_lop = malloc(sizeof (struct nfslock), M_NFSDLOCK, M_WAITOK);
6098         if (flags & (NFSLCK_READ | NFSLCK_WRITE))
6099                 other_lop = malloc(sizeof (struct nfslock), M_NFSDLOCK,
6100                     M_WAITOK);
6101         else
6102                 other_lop = NULL;
6103         new_lop->lo_flags = flags;
6104         new_lop->lo_first = first;
6105         new_lop->lo_end = end;
6106         nfsrv_updatelock(NULL, &new_lop, &other_lop, lfp);
6107         if (new_lop != NULL)
6108                 free(new_lop, M_NFSDLOCK);
6109         if (other_lop != NULL)
6110                 free(other_lop, M_NFSDLOCK);
6111
6112         /* and get rid of the rollback list */
6113         LIST_FOREACH_SAFE(rlp, &lfp->lf_rollback, rlck_list, nrlp)
6114                 free(rlp, M_NFSDROLLBACK);
6115         LIST_INIT(&lfp->lf_rollback);
6116 }
6117
6118 /*
6119  * Lock the struct nfslockfile for local lock updating.
6120  */
6121 static void
6122 nfsrv_locklf(struct nfslockfile *lfp)
6123 {
6124         int gotlock;
6125
6126         /* lf_usecount ensures *lfp won't be free'd */
6127         lfp->lf_usecount++;
6128         do {
6129                 gotlock = nfsv4_lock(&lfp->lf_locallock_lck, 1, NULL,
6130                     NFSSTATEMUTEXPTR, NULL);
6131         } while (gotlock == 0);
6132         lfp->lf_usecount--;
6133 }
6134
6135 /*
6136  * Unlock the struct nfslockfile after local lock updating.
6137  */
6138 static void
6139 nfsrv_unlocklf(struct nfslockfile *lfp)
6140 {
6141
6142         nfsv4_unlock(&lfp->lf_locallock_lck, 0);
6143 }
6144
6145 /*
6146  * Clear out all state for the NFSv4 server.
6147  * Must be called by a thread that can sleep when no nfsds are running.
6148  */
6149 void
6150 nfsrv_throwawayallstate(NFSPROC_T *p)
6151 {
6152         struct nfsclient *clp, *nclp;
6153         struct nfslockfile *lfp, *nlfp;
6154         int i;
6155
6156         /*
6157          * For each client, clean out the state and then free the structure.
6158          */
6159         for (i = 0; i < nfsrv_clienthashsize; i++) {
6160                 LIST_FOREACH_SAFE(clp, &nfsclienthash[i], lc_hash, nclp) {
6161                         nfsrv_cleanclient(clp, p);
6162                         nfsrv_freedeleglist(&clp->lc_deleg);
6163                         nfsrv_freedeleglist(&clp->lc_olddeleg);
6164                         free(clp->lc_stateid, M_NFSDCLIENT);
6165                         free(clp, M_NFSDCLIENT);
6166                 }
6167         }
6168
6169         /*
6170          * Also, free up any remaining lock file structures.
6171          */
6172         for (i = 0; i < nfsrv_lockhashsize; i++) {
6173                 LIST_FOREACH_SAFE(lfp, &nfslockhash[i], lf_hash, nlfp) {
6174                         printf("nfsd unload: fnd a lock file struct\n");
6175                         nfsrv_freenfslockfile(lfp);
6176                 }
6177         }
6178
6179         /* And get rid of the deviceid structures and layouts. */
6180         nfsrv_freealllayoutsanddevids();
6181 }
6182
6183 /*
6184  * Check the sequence# for the session and slot provided as an argument.
6185  * Also, renew the lease if the session will return NFS_OK.
6186  */
6187 int
6188 nfsrv_checksequence(struct nfsrv_descript *nd, uint32_t sequenceid,
6189     uint32_t *highest_slotidp, uint32_t *target_highest_slotidp, int cache_this,
6190     uint32_t *sflagsp, NFSPROC_T *p)
6191 {
6192         struct nfsdsession *sep;
6193         struct nfssessionhash *shp;
6194         int error;
6195         SVCXPRT *savxprt;
6196
6197         shp = NFSSESSIONHASH(nd->nd_sessionid);
6198         NFSLOCKSESSION(shp);
6199         sep = nfsrv_findsession(nd->nd_sessionid);
6200         if (sep == NULL) {
6201                 NFSUNLOCKSESSION(shp);
6202                 return (NFSERR_BADSESSION);
6203         }
6204         error = nfsv4_seqsession(sequenceid, nd->nd_slotid, *highest_slotidp,
6205             sep->sess_slots, NULL, NFSV4_SLOTS - 1);
6206         if (error != 0) {
6207                 NFSUNLOCKSESSION(shp);
6208                 return (error);
6209         }
6210         if (cache_this != 0)
6211                 nd->nd_flag |= ND_SAVEREPLY;
6212         /* Renew the lease. */
6213         sep->sess_clp->lc_expiry = nfsrv_leaseexpiry();
6214         nd->nd_clientid.qval = sep->sess_clp->lc_clientid.qval;
6215         nd->nd_flag |= ND_IMPLIEDCLID;
6216
6217         /* Save maximum request and reply sizes. */
6218         nd->nd_maxreq = sep->sess_maxreq;
6219         nd->nd_maxresp = sep->sess_maxresp;
6220
6221         /*
6222          * If this session handles the backchannel, save the nd_xprt for this
6223          * RPC, since this is the one being used.
6224          * RFC-5661 specifies that the fore channel will be implicitly
6225          * bound by a Sequence operation.  However, since some NFSv4.1 clients
6226          * erroneously assumed that the back channel would be implicitly
6227          * bound as well, do the implicit binding unless a
6228          * BindConnectiontoSession has already been done on the session.
6229          */
6230         if (sep->sess_clp->lc_req.nr_client != NULL &&
6231             sep->sess_cbsess.nfsess_xprt != nd->nd_xprt &&
6232             (sep->sess_crflags & NFSV4CRSESS_CONNBACKCHAN) != 0 &&
6233             (sep->sess_clp->lc_flags & LCL_DONEBINDCONN) == 0) {
6234                 NFSD_DEBUG(2,
6235                     "nfsrv_checksequence: implicit back channel bind\n");
6236                 savxprt = sep->sess_cbsess.nfsess_xprt;
6237                 SVC_ACQUIRE(nd->nd_xprt);
6238                 nd->nd_xprt->xp_p2 =
6239                     sep->sess_clp->lc_req.nr_client->cl_private;
6240                 nd->nd_xprt->xp_idletimeout = 0;        /* Disable timeout. */
6241                 sep->sess_cbsess.nfsess_xprt = nd->nd_xprt;
6242                 if (savxprt != NULL)
6243                         SVC_RELEASE(savxprt);
6244         }
6245
6246         *sflagsp = 0;
6247         if (sep->sess_clp->lc_req.nr_client == NULL)
6248                 *sflagsp |= NFSV4SEQ_CBPATHDOWN;
6249         NFSUNLOCKSESSION(shp);
6250         if (error == NFSERR_EXPIRED) {
6251                 *sflagsp |= NFSV4SEQ_EXPIREDALLSTATEREVOKED;
6252                 error = 0;
6253         } else if (error == NFSERR_ADMINREVOKED) {
6254                 *sflagsp |= NFSV4SEQ_ADMINSTATEREVOKED;
6255                 error = 0;
6256         }
6257         *highest_slotidp = *target_highest_slotidp = NFSV4_SLOTS - 1;
6258         return (0);
6259 }
6260
6261 /*
6262  * Check/set reclaim complete for this session/clientid.
6263  */
6264 int
6265 nfsrv_checkreclaimcomplete(struct nfsrv_descript *nd, int onefs)
6266 {
6267         struct nfsdsession *sep;
6268         struct nfssessionhash *shp;
6269         int error = 0;
6270
6271         shp = NFSSESSIONHASH(nd->nd_sessionid);
6272         NFSLOCKSTATE();
6273         NFSLOCKSESSION(shp);
6274         sep = nfsrv_findsession(nd->nd_sessionid);
6275         if (sep == NULL) {
6276                 NFSUNLOCKSESSION(shp);
6277                 NFSUNLOCKSTATE();
6278                 return (NFSERR_BADSESSION);
6279         }
6280
6281         if (onefs != 0)
6282                 sep->sess_clp->lc_flags |= LCL_RECLAIMONEFS;
6283                 /* Check to see if reclaim complete has already happened. */
6284         else if ((sep->sess_clp->lc_flags & LCL_RECLAIMCOMPLETE) != 0)
6285                 error = NFSERR_COMPLETEALREADY;
6286         else {
6287                 sep->sess_clp->lc_flags |= LCL_RECLAIMCOMPLETE;
6288                 nfsrv_markreclaim(sep->sess_clp);
6289         }
6290         NFSUNLOCKSESSION(shp);
6291         NFSUNLOCKSTATE();
6292         return (error);
6293 }
6294
6295 /*
6296  * Cache the reply in a session slot.
6297  */
6298 void
6299 nfsrv_cache_session(struct nfsrv_descript *nd, struct mbuf **m)
6300 {
6301         struct nfsdsession *sep;
6302         struct nfssessionhash *shp;
6303         char *buf, *cp;
6304 #ifdef INET
6305         struct sockaddr_in *sin;
6306 #endif
6307 #ifdef INET6
6308         struct sockaddr_in6 *sin6;
6309 #endif
6310
6311         shp = NFSSESSIONHASH(nd->nd_sessionid);
6312         NFSLOCKSESSION(shp);
6313         sep = nfsrv_findsession(nd->nd_sessionid);
6314         if (sep == NULL) {
6315                 NFSUNLOCKSESSION(shp);
6316                 if ((nfsrv_stablefirst.nsf_flags & NFSNSF_GRACEOVER) != 0) {
6317                         buf = malloc(INET6_ADDRSTRLEN, M_TEMP, M_WAITOK);
6318                         switch (nd->nd_nam->sa_family) {
6319 #ifdef INET
6320                         case AF_INET:
6321                                 sin = (struct sockaddr_in *)nd->nd_nam;
6322                                 cp = inet_ntop(sin->sin_family,
6323                                     &sin->sin_addr.s_addr, buf,
6324                                     INET6_ADDRSTRLEN);
6325                                 break;
6326 #endif
6327 #ifdef INET6
6328                         case AF_INET6:
6329                                 sin6 = (struct sockaddr_in6 *)nd->nd_nam;
6330                                 cp = inet_ntop(sin6->sin6_family,
6331                                     &sin6->sin6_addr, buf, INET6_ADDRSTRLEN);
6332                                 break;
6333 #endif
6334                         default:
6335                                 cp = NULL;
6336                         }
6337                         if (cp != NULL)
6338                                 printf("nfsrv_cache_session: no session "
6339                                     "IPaddr=%s\n", cp);
6340                         else
6341                                 printf("nfsrv_cache_session: no session\n");
6342                         free(buf, M_TEMP);
6343                 }
6344                 m_freem(*m);
6345                 return;
6346         }
6347         nfsv4_seqsess_cacherep(nd->nd_slotid, sep->sess_slots, nd->nd_repstat,
6348             m);
6349         NFSUNLOCKSESSION(shp);
6350 }
6351
6352 /*
6353  * Search for a session that matches the sessionid.
6354  */
6355 static struct nfsdsession *
6356 nfsrv_findsession(uint8_t *sessionid)
6357 {
6358         struct nfsdsession *sep;
6359         struct nfssessionhash *shp;
6360
6361         shp = NFSSESSIONHASH(sessionid);
6362         LIST_FOREACH(sep, &shp->list, sess_hash) {
6363                 if (!NFSBCMP(sessionid, sep->sess_sessionid, NFSX_V4SESSIONID))
6364                         break;
6365         }
6366         return (sep);
6367 }
6368
6369 /*
6370  * Destroy a session.
6371  */
6372 int
6373 nfsrv_destroysession(struct nfsrv_descript *nd, uint8_t *sessionid)
6374 {
6375         int error, igotlock, samesess;
6376
6377         samesess = 0;
6378         if (!NFSBCMP(sessionid, nd->nd_sessionid, NFSX_V4SESSIONID) &&
6379             (nd->nd_flag & ND_HASSEQUENCE) != 0) {
6380                 samesess = 1;
6381                 if ((nd->nd_flag & ND_LASTOP) == 0)
6382                         return (NFSERR_BADSESSION);
6383         }
6384
6385         /* Lock out other nfsd threads */
6386         NFSLOCKV4ROOTMUTEX();
6387         nfsv4_relref(&nfsv4rootfs_lock);
6388         do {
6389                 igotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
6390                     NFSV4ROOTLOCKMUTEXPTR, NULL);
6391         } while (igotlock == 0);
6392         NFSUNLOCKV4ROOTMUTEX();
6393
6394         error = nfsrv_freesession(NULL, sessionid);
6395         if (error == 0 && samesess != 0)
6396                 nd->nd_flag &= ~ND_HASSEQUENCE;
6397
6398         NFSLOCKV4ROOTMUTEX();
6399         nfsv4_unlock(&nfsv4rootfs_lock, 1);
6400         NFSUNLOCKV4ROOTMUTEX();
6401         return (error);
6402 }
6403
6404 /*
6405  * Bind a connection to a session.
6406  * For now, only certain variants are supported, since the current session
6407  * structure can only handle a single backchannel entry, which will be
6408  * applied to all connections if it is set.
6409  */
6410 int
6411 nfsrv_bindconnsess(struct nfsrv_descript *nd, uint8_t *sessionid, int *foreaftp)
6412 {
6413         struct nfssessionhash *shp;
6414         struct nfsdsession *sep;
6415         struct nfsclient *clp;
6416         SVCXPRT *savxprt;
6417         int error;
6418
6419         error = 0;
6420         shp = NFSSESSIONHASH(sessionid);
6421         NFSLOCKSTATE();
6422         NFSLOCKSESSION(shp);
6423         sep = nfsrv_findsession(sessionid);
6424         if (sep != NULL) {
6425                 clp = sep->sess_clp;
6426                 if (*foreaftp == NFSCDFC4_BACK ||
6427                     *foreaftp == NFSCDFC4_BACK_OR_BOTH ||
6428                     *foreaftp == NFSCDFC4_FORE_OR_BOTH) {
6429                         /* Try to set up a backchannel. */
6430                         if (clp->lc_req.nr_client == NULL) {
6431                                 NFSD_DEBUG(2, "nfsrv_bindconnsess: acquire "
6432                                     "backchannel\n");
6433                                 clp->lc_req.nr_client = (struct __rpc_client *)
6434                                     clnt_bck_create(nd->nd_xprt->xp_socket,
6435                                     sep->sess_cbprogram, NFSV4_CBVERS);
6436                         }
6437                         if (clp->lc_req.nr_client != NULL) {
6438                                 NFSD_DEBUG(2, "nfsrv_bindconnsess: set up "
6439                                     "backchannel\n");
6440                                 savxprt = sep->sess_cbsess.nfsess_xprt;
6441                                 SVC_ACQUIRE(nd->nd_xprt);
6442                                 nd->nd_xprt->xp_p2 =
6443                                     clp->lc_req.nr_client->cl_private;
6444                                 /* Disable idle timeout. */
6445                                 nd->nd_xprt->xp_idletimeout = 0;
6446                                 sep->sess_cbsess.nfsess_xprt = nd->nd_xprt;
6447                                 if (savxprt != NULL)
6448                                         SVC_RELEASE(savxprt);
6449                                 sep->sess_crflags |= NFSV4CRSESS_CONNBACKCHAN;
6450                                 clp->lc_flags |= LCL_DONEBINDCONN;
6451                                 if (*foreaftp == NFSCDFS4_BACK)
6452                                         *foreaftp = NFSCDFS4_BACK;
6453                                 else
6454                                         *foreaftp = NFSCDFS4_BOTH;
6455                         } else if (*foreaftp != NFSCDFC4_BACK) {
6456                                 NFSD_DEBUG(2, "nfsrv_bindconnsess: can't set "
6457                                     "up backchannel\n");
6458                                 sep->sess_crflags &= ~NFSV4CRSESS_CONNBACKCHAN;
6459                                 clp->lc_flags |= LCL_DONEBINDCONN;
6460                                 *foreaftp = NFSCDFS4_FORE;
6461                         } else {
6462                                 error = NFSERR_NOTSUPP;
6463                                 printf("nfsrv_bindconnsess: Can't add "
6464                                     "backchannel\n");
6465                         }
6466                 } else {
6467                         NFSD_DEBUG(2, "nfsrv_bindconnsess: Set forechannel\n");
6468                         clp->lc_flags |= LCL_DONEBINDCONN;
6469                         *foreaftp = NFSCDFS4_FORE;
6470                 }
6471         } else
6472                 error = NFSERR_BADSESSION;
6473         NFSUNLOCKSESSION(shp);
6474         NFSUNLOCKSTATE();
6475         return (error);
6476 }
6477
6478 /*
6479  * Free up a session structure.
6480  */
6481 static int
6482 nfsrv_freesession(struct nfsdsession *sep, uint8_t *sessionid)
6483 {
6484         struct nfssessionhash *shp;
6485         int i;
6486
6487         NFSLOCKSTATE();
6488         if (sep == NULL) {
6489                 shp = NFSSESSIONHASH(sessionid);
6490                 NFSLOCKSESSION(shp);
6491                 sep = nfsrv_findsession(sessionid);
6492         } else {
6493                 shp = NFSSESSIONHASH(sep->sess_sessionid);
6494                 NFSLOCKSESSION(shp);
6495         }
6496         if (sep != NULL) {
6497                 sep->sess_refcnt--;
6498                 if (sep->sess_refcnt > 0) {
6499                         NFSUNLOCKSESSION(shp);
6500                         NFSUNLOCKSTATE();
6501                         return (NFSERR_BACKCHANBUSY);
6502                 }
6503                 LIST_REMOVE(sep, sess_hash);
6504                 LIST_REMOVE(sep, sess_list);
6505         }
6506         NFSUNLOCKSESSION(shp);
6507         NFSUNLOCKSTATE();
6508         if (sep == NULL)
6509                 return (NFSERR_BADSESSION);
6510         for (i = 0; i < NFSV4_SLOTS; i++)
6511                 if (sep->sess_slots[i].nfssl_reply != NULL)
6512                         m_freem(sep->sess_slots[i].nfssl_reply);
6513         if (sep->sess_cbsess.nfsess_xprt != NULL)
6514                 SVC_RELEASE(sep->sess_cbsess.nfsess_xprt);
6515         free(sep, M_NFSDSESSION);
6516         return (0);
6517 }
6518
6519 /*
6520  * Free a stateid.
6521  * RFC5661 says that it should fail when there are associated opens, locks
6522  * or delegations. Since stateids represent opens, I don't see how you can
6523  * free an open stateid (it will be free'd when closed), so this function
6524  * only works for lock stateids (freeing the lock_owner) or delegations.
6525  */
6526 int
6527 nfsrv_freestateid(struct nfsrv_descript *nd, nfsv4stateid_t *stateidp,
6528     NFSPROC_T *p)
6529 {
6530         struct nfsclient *clp;
6531         struct nfsstate *stp;
6532         int error;
6533
6534         NFSLOCKSTATE();
6535         /*
6536          * Look up the stateid
6537          */
6538         error = nfsrv_getclient((nfsquad_t)((u_quad_t)0), CLOPS_RENEW, &clp,
6539             NULL, (nfsquad_t)((u_quad_t)0), 0, nd, p);
6540         if (error == 0) {
6541                 /* First, check for a delegation. */
6542                 LIST_FOREACH(stp, &clp->lc_deleg, ls_list) {
6543                         if (!NFSBCMP(stp->ls_stateid.other, stateidp->other,
6544                             NFSX_STATEIDOTHER))
6545                                 break;
6546                 }
6547                 if (stp != NULL) {
6548                         nfsrv_freedeleg(stp);
6549                         NFSUNLOCKSTATE();
6550                         return (error);
6551                 }
6552         }
6553         /* Not a delegation, try for a lock_owner. */
6554         if (error == 0)
6555                 error = nfsrv_getstate(clp, stateidp, 0, &stp);
6556         if (error == 0 && ((stp->ls_flags & (NFSLCK_OPEN | NFSLCK_DELEGREAD |
6557             NFSLCK_DELEGWRITE)) != 0 || (stp->ls_flags & NFSLCK_LOCK) == 0))
6558                 /* Not a lock_owner stateid. */
6559                 error = NFSERR_LOCKSHELD;
6560         if (error == 0 && !LIST_EMPTY(&stp->ls_lock))
6561                 error = NFSERR_LOCKSHELD;
6562         if (error == 0)
6563                 nfsrv_freelockowner(stp, NULL, 0, p);
6564         NFSUNLOCKSTATE();
6565         return (error);
6566 }
6567
6568 /*
6569  * Test a stateid.
6570  */
6571 int
6572 nfsrv_teststateid(struct nfsrv_descript *nd, nfsv4stateid_t *stateidp,
6573     NFSPROC_T *p)
6574 {
6575         struct nfsclient *clp;
6576         struct nfsstate *stp;
6577         int error;
6578
6579         NFSLOCKSTATE();
6580         /*
6581          * Look up the stateid
6582          */
6583         error = nfsrv_getclient((nfsquad_t)((u_quad_t)0), CLOPS_RENEW, &clp,
6584             NULL, (nfsquad_t)((u_quad_t)0), 0, nd, p);
6585         if (error == 0)
6586                 error = nfsrv_getstate(clp, stateidp, 0, &stp);
6587         if (error == 0 && stateidp->seqid != 0 &&
6588             SEQ_LT(stateidp->seqid, stp->ls_stateid.seqid))
6589                 error = NFSERR_OLDSTATEID;
6590         NFSUNLOCKSTATE();
6591         return (error);
6592 }
6593
6594 /*
6595  * Generate the xdr for an NFSv4.1 CBSequence Operation.
6596  */
6597 static int
6598 nfsv4_setcbsequence(struct nfsrv_descript *nd, struct nfsclient *clp,
6599     int dont_replycache, struct nfsdsession **sepp)
6600 {
6601         struct nfsdsession *sep;
6602         uint32_t *tl, slotseq = 0;
6603         int maxslot, slotpos;
6604         uint8_t sessionid[NFSX_V4SESSIONID];
6605         int error;
6606
6607         error = nfsv4_getcbsession(clp, sepp);
6608         if (error != 0)
6609                 return (error);
6610         sep = *sepp;
6611         (void)nfsv4_sequencelookup(NULL, &sep->sess_cbsess, &slotpos, &maxslot,
6612             &slotseq, sessionid);
6613         KASSERT(maxslot >= 0, ("nfsv4_setcbsequence neg maxslot"));
6614
6615         /* Build the Sequence arguments. */
6616         NFSM_BUILD(tl, uint32_t *, NFSX_V4SESSIONID + 5 * NFSX_UNSIGNED);
6617         bcopy(sessionid, tl, NFSX_V4SESSIONID);
6618         tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;
6619         nd->nd_slotseq = tl;
6620         *tl++ = txdr_unsigned(slotseq);
6621         *tl++ = txdr_unsigned(slotpos);
6622         *tl++ = txdr_unsigned(maxslot);
6623         if (dont_replycache == 0)
6624                 *tl++ = newnfs_true;
6625         else
6626                 *tl++ = newnfs_false;
6627         *tl = 0;                        /* No referring call list, for now. */
6628         nd->nd_flag |= ND_HASSEQUENCE;
6629         return (0);
6630 }
6631
6632 /*
6633  * Get a session for the callback.
6634  */
6635 static int
6636 nfsv4_getcbsession(struct nfsclient *clp, struct nfsdsession **sepp)
6637 {
6638         struct nfsdsession *sep;
6639
6640         NFSLOCKSTATE();
6641         LIST_FOREACH(sep, &clp->lc_session, sess_list) {
6642                 if ((sep->sess_crflags & NFSV4CRSESS_CONNBACKCHAN) != 0)
6643                         break;
6644         }
6645         if (sep == NULL) {
6646                 NFSUNLOCKSTATE();
6647                 return (NFSERR_BADSESSION);
6648         }
6649         sep->sess_refcnt++;
6650         *sepp = sep;
6651         NFSUNLOCKSTATE();
6652         return (0);
6653 }
6654
6655 /*
6656  * Free up all backchannel xprts.  This needs to be done when the nfsd threads
6657  * exit, since those transports will all be going away.
6658  * This is only called after all the nfsd threads are done performing RPCs,
6659  * so locking shouldn't be an issue.
6660  */
6661 void
6662 nfsrv_freeallbackchannel_xprts(void)
6663 {
6664         struct nfsdsession *sep;
6665         struct nfsclient *clp;
6666         SVCXPRT *xprt;
6667         int i;
6668
6669         for (i = 0; i < nfsrv_clienthashsize; i++) {
6670                 LIST_FOREACH(clp, &nfsclienthash[i], lc_hash) {
6671                         LIST_FOREACH(sep, &clp->lc_session, sess_list) {
6672                                 xprt = sep->sess_cbsess.nfsess_xprt;
6673                                 sep->sess_cbsess.nfsess_xprt = NULL;
6674                                 if (xprt != NULL)
6675                                         SVC_RELEASE(xprt);
6676                         }
6677                 }
6678         }
6679 }
6680
6681 /*
6682  * Do a layout commit.  Actually just call nfsrv_updatemdsattr().
6683  * I have no idea if the rest of these arguments will ever be useful?
6684  */
6685 int
6686 nfsrv_layoutcommit(struct nfsrv_descript *nd, vnode_t vp, int layouttype,
6687     int hasnewoff, uint64_t newoff, uint64_t offset, uint64_t len,
6688     int hasnewmtime, struct timespec *newmtimep, int reclaim,
6689     nfsv4stateid_t *stateidp, int maxcnt, char *layp, int *hasnewsizep,
6690     uint64_t *newsizep, struct ucred *cred, NFSPROC_T *p)
6691 {
6692         struct nfsvattr na;
6693         int error;
6694
6695         error = nfsrv_updatemdsattr(vp, &na, p);
6696         if (error == 0) {
6697                 *hasnewsizep = 1;
6698                 *newsizep = na.na_size;
6699         }
6700         return (error);
6701 }
6702
6703 /*
6704  * Try and get a layout.
6705  */
6706 int
6707 nfsrv_layoutget(struct nfsrv_descript *nd, vnode_t vp, struct nfsexstuff *exp,
6708     int layouttype, int *iomode, uint64_t *offset, uint64_t *len,
6709     uint64_t minlen, nfsv4stateid_t *stateidp, int maxcnt, int *retonclose,
6710     int *layoutlenp, char *layp, struct ucred *cred, NFSPROC_T *p)
6711 {
6712         struct nfslayouthash *lhyp;
6713         struct nfslayout *lyp;
6714         char *devid;
6715         fhandle_t fh, *dsfhp;
6716         int error, mirrorcnt;
6717
6718         if (nfsrv_devidcnt == 0)
6719                 return (NFSERR_UNKNLAYOUTTYPE);
6720
6721         if (*offset != 0)
6722                 printf("nfsrv_layoutget: off=%ju len=%ju\n", (uintmax_t)*offset,
6723                     (uintmax_t)*len);
6724         error = nfsvno_getfh(vp, &fh, p);
6725         NFSD_DEBUG(4, "layoutget getfh=%d\n", error);
6726         if (error != 0)
6727                 return (error);
6728
6729         /*
6730          * For now, all layouts are for entire files.
6731          * Only issue Read/Write layouts if requested for a non-readonly fs.
6732          */
6733         if (NFSVNO_EXRDONLY(exp)) {
6734                 if (*iomode == NFSLAYOUTIOMODE_RW)
6735                         return (NFSERR_LAYOUTTRYLATER);
6736                 *iomode = NFSLAYOUTIOMODE_READ;
6737         }
6738         if (*iomode != NFSLAYOUTIOMODE_RW)
6739                 *iomode = NFSLAYOUTIOMODE_READ;
6740
6741         /*
6742          * Check to see if a write layout can be issued for this file.
6743          * This is used during mirror recovery to avoid RW layouts being
6744          * issued for a file while it is being copied to the recovered
6745          * mirror.
6746          */
6747         if (*iomode == NFSLAYOUTIOMODE_RW && nfsrv_dontlayout(&fh) != 0)
6748                 return (NFSERR_LAYOUTTRYLATER);
6749
6750         *retonclose = 0;
6751         *offset = 0;
6752         *len = UINT64_MAX;
6753
6754         /* First, see if a layout already exists and return if found. */
6755         lhyp = NFSLAYOUTHASH(&fh);
6756         NFSLOCKLAYOUT(lhyp);
6757         error = nfsrv_findlayout(&nd->nd_clientid, &fh, layouttype, p, &lyp);
6758         NFSD_DEBUG(4, "layoutget findlay=%d\n", error);
6759         /*
6760          * Not sure if the seqid must be the same, so I won't check it.
6761          */
6762         if (error == 0 && (stateidp->other[0] != lyp->lay_stateid.other[0] ||
6763             stateidp->other[1] != lyp->lay_stateid.other[1] ||
6764             stateidp->other[2] != lyp->lay_stateid.other[2])) {
6765                 if ((lyp->lay_flags & NFSLAY_CALLB) == 0) {
6766                         NFSUNLOCKLAYOUT(lhyp);
6767                         NFSD_DEBUG(1, "ret bad stateid\n");
6768                         return (NFSERR_BADSTATEID);
6769                 }
6770                 /*
6771                  * I believe we get here because there is a race between
6772                  * the client processing the CBLAYOUTRECALL and the layout
6773                  * being deleted here on the server.
6774                  * The client has now done a LayoutGet with a non-layout
6775                  * stateid, as it would when there is no layout.
6776                  * As such, free this layout and set error == NFSERR_BADSTATEID
6777                  * so the code below will create a new layout structure as
6778                  * would happen if no layout was found.
6779                  * "lyp" will be set before being used below, but set it NULL
6780                  * as a safety belt.
6781                  */
6782                 nfsrv_freelayout(&lhyp->list, lyp);
6783                 lyp = NULL;
6784                 error = NFSERR_BADSTATEID;
6785         }
6786         if (error == 0) {
6787                 if (lyp->lay_layoutlen > maxcnt) {
6788                         NFSUNLOCKLAYOUT(lhyp);
6789                         NFSD_DEBUG(1, "ret layout too small\n");
6790                         return (NFSERR_TOOSMALL);
6791                 }
6792                 if (*iomode == NFSLAYOUTIOMODE_RW)
6793                         lyp->lay_flags |= NFSLAY_RW;
6794                 else
6795                         lyp->lay_flags |= NFSLAY_READ;
6796                 NFSBCOPY(lyp->lay_xdr, layp, lyp->lay_layoutlen);
6797                 *layoutlenp = lyp->lay_layoutlen;
6798                 if (++lyp->lay_stateid.seqid == 0)
6799                         lyp->lay_stateid.seqid = 1;
6800                 stateidp->seqid = lyp->lay_stateid.seqid;
6801                 NFSUNLOCKLAYOUT(lhyp);
6802                 NFSD_DEBUG(4, "ret fnd layout\n");
6803                 return (0);
6804         }
6805         NFSUNLOCKLAYOUT(lhyp);
6806
6807         /* Find the device id and file handle. */
6808         dsfhp = malloc(sizeof(fhandle_t) * NFSDEV_MAXMIRRORS, M_TEMP, M_WAITOK);
6809         devid = malloc(NFSX_V4DEVICEID * NFSDEV_MAXMIRRORS, M_TEMP, M_WAITOK);
6810         error = nfsrv_dsgetdevandfh(vp, p, &mirrorcnt, dsfhp, devid);
6811         NFSD_DEBUG(4, "layoutget devandfh=%d\n", error);
6812         if (error == 0) {
6813                 if (layouttype == NFSLAYOUT_NFSV4_1_FILES) {
6814                         if (NFSX_V4FILELAYOUT > maxcnt)
6815                                 error = NFSERR_TOOSMALL;
6816                         else
6817                                 lyp = nfsrv_filelayout(nd, *iomode, &fh, dsfhp,
6818                                     devid, vp->v_mount->mnt_stat.f_fsid);
6819                 } else {
6820                         if (NFSX_V4FLEXLAYOUT(mirrorcnt) > maxcnt)
6821                                 error = NFSERR_TOOSMALL;
6822                         else
6823                                 lyp = nfsrv_flexlayout(nd, *iomode, mirrorcnt,
6824                                     &fh, dsfhp, devid,
6825                                     vp->v_mount->mnt_stat.f_fsid);
6826                 }
6827         }
6828         free(dsfhp, M_TEMP);
6829         free(devid, M_TEMP);
6830         if (error != 0)
6831                 return (error);
6832
6833         /*
6834          * Now, add this layout to the list.
6835          */
6836         error = nfsrv_addlayout(nd, &lyp, stateidp, layp, layoutlenp, p);
6837         NFSD_DEBUG(4, "layoutget addl=%d\n", error);
6838         /*
6839          * The lyp will be set to NULL by nfsrv_addlayout() if it
6840          * linked the new structure into the lists.
6841          */
6842         free(lyp, M_NFSDSTATE);
6843         return (error);
6844 }
6845
6846 /*
6847  * Generate a File Layout.
6848  */
6849 static struct nfslayout *
6850 nfsrv_filelayout(struct nfsrv_descript *nd, int iomode, fhandle_t *fhp,
6851     fhandle_t *dsfhp, char *devid, fsid_t fs)
6852 {
6853         uint32_t *tl;
6854         struct nfslayout *lyp;
6855         uint64_t pattern_offset;
6856
6857         lyp = malloc(sizeof(struct nfslayout) + NFSX_V4FILELAYOUT, M_NFSDSTATE,
6858             M_WAITOK | M_ZERO);
6859         lyp->lay_type = NFSLAYOUT_NFSV4_1_FILES;
6860         if (iomode == NFSLAYOUTIOMODE_RW)
6861                 lyp->lay_flags = NFSLAY_RW;
6862         else
6863                 lyp->lay_flags = NFSLAY_READ;
6864         NFSBCOPY(fhp, &lyp->lay_fh, sizeof(*fhp));
6865         lyp->lay_clientid.qval = nd->nd_clientid.qval;
6866         lyp->lay_fsid = fs;
6867
6868         /* Fill in the xdr for the files layout. */
6869         tl = (uint32_t *)lyp->lay_xdr;
6870         NFSBCOPY(devid, tl, NFSX_V4DEVICEID);           /* Device ID. */
6871         tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
6872
6873         /*
6874          * Make the stripe size as many 64K blocks as will fit in the stripe
6875          * mask. Since there is only one stripe, the stripe size doesn't really
6876          * matter, except that the Linux client will only handle an exact
6877          * multiple of their PAGE_SIZE (usually 4K).  I chose 64K as a value
6878          * that should cover most/all arches w.r.t. PAGE_SIZE.
6879          */
6880         *tl++ = txdr_unsigned(NFSFLAYUTIL_STRIPE_MASK & ~0xffff);
6881         *tl++ = 0;                                      /* 1st stripe index. */
6882         pattern_offset = 0;
6883         txdr_hyper(pattern_offset, tl); tl += 2;        /* Pattern offset. */
6884         *tl++ = txdr_unsigned(1);                       /* 1 file handle. */
6885         *tl++ = txdr_unsigned(NFSX_V4PNFSFH);
6886         NFSBCOPY(dsfhp, tl, sizeof(*dsfhp));
6887         lyp->lay_layoutlen = NFSX_V4FILELAYOUT;
6888         return (lyp);
6889 }
6890
6891 #define FLEX_OWNERID    "999"
6892 #define FLEX_UID0       "0"
6893 /*
6894  * Generate a Flex File Layout.
6895  * The FLEX_OWNERID can be any string of 3 decimal digits. Although this
6896  * string goes on the wire, it isn't supposed to be used by the client,
6897  * since this server uses tight coupling.
6898  * Although not recommended by the spec., if vfs.nfsd.flexlinuxhack=1 use
6899  * a string of "0". This works around the Linux Flex File Layout driver bug
6900  * which uses the synthetic uid/gid strings for the "tightly coupled" case.
6901  */
6902 static struct nfslayout *
6903 nfsrv_flexlayout(struct nfsrv_descript *nd, int iomode, int mirrorcnt,
6904     fhandle_t *fhp, fhandle_t *dsfhp, char *devid, fsid_t fs)
6905 {
6906         uint32_t *tl;
6907         struct nfslayout *lyp;
6908         uint64_t lenval;
6909         int i;
6910
6911         lyp = malloc(sizeof(struct nfslayout) + NFSX_V4FLEXLAYOUT(mirrorcnt),
6912             M_NFSDSTATE, M_WAITOK | M_ZERO);
6913         lyp->lay_type = NFSLAYOUT_FLEXFILE;
6914         if (iomode == NFSLAYOUTIOMODE_RW)
6915                 lyp->lay_flags = NFSLAY_RW;
6916         else
6917                 lyp->lay_flags = NFSLAY_READ;
6918         NFSBCOPY(fhp, &lyp->lay_fh, sizeof(*fhp));
6919         lyp->lay_clientid.qval = nd->nd_clientid.qval;
6920         lyp->lay_fsid = fs;
6921         lyp->lay_mirrorcnt = mirrorcnt;
6922
6923         /* Fill in the xdr for the files layout. */
6924         tl = (uint32_t *)lyp->lay_xdr;
6925         lenval = 0;
6926         txdr_hyper(lenval, tl); tl += 2;                /* Stripe unit. */
6927         *tl++ = txdr_unsigned(mirrorcnt);               /* # of mirrors. */
6928         for (i = 0; i < mirrorcnt; i++) {
6929                 *tl++ = txdr_unsigned(1);               /* One stripe. */
6930                 NFSBCOPY(devid, tl, NFSX_V4DEVICEID);   /* Device ID. */
6931                 tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
6932                 devid += NFSX_V4DEVICEID;
6933                 *tl++ = txdr_unsigned(1);               /* Efficiency. */
6934                 *tl++ = 0;                              /* Proxy Stateid. */
6935                 *tl++ = 0x55555555;
6936                 *tl++ = 0x55555555;
6937                 *tl++ = 0x55555555;
6938                 *tl++ = txdr_unsigned(1);               /* 1 file handle. */
6939                 *tl++ = txdr_unsigned(NFSX_V4PNFSFH);
6940                 NFSBCOPY(dsfhp, tl, sizeof(*dsfhp));
6941                 tl += (NFSM_RNDUP(NFSX_V4PNFSFH) / NFSX_UNSIGNED);
6942                 dsfhp++;
6943                 if (nfsrv_flexlinuxhack != 0) {
6944                         *tl++ = txdr_unsigned(strlen(FLEX_UID0));
6945                         *tl = 0;                /* 0 pad string. */
6946                         NFSBCOPY(FLEX_UID0, tl++, strlen(FLEX_UID0));
6947                         *tl++ = txdr_unsigned(strlen(FLEX_UID0));
6948                         *tl = 0;                /* 0 pad string. */
6949                         NFSBCOPY(FLEX_UID0, tl++, strlen(FLEX_UID0));
6950                 } else {
6951                         *tl++ = txdr_unsigned(strlen(FLEX_OWNERID));
6952                         NFSBCOPY(FLEX_OWNERID, tl++, NFSX_UNSIGNED);
6953                         *tl++ = txdr_unsigned(strlen(FLEX_OWNERID));
6954                         NFSBCOPY(FLEX_OWNERID, tl++, NFSX_UNSIGNED);
6955                 }
6956         }
6957         *tl++ = txdr_unsigned(0);               /* ff_flags. */
6958         *tl = txdr_unsigned(60);                /* Status interval hint. */
6959         lyp->lay_layoutlen = NFSX_V4FLEXLAYOUT(mirrorcnt);
6960         return (lyp);
6961 }
6962
6963 /*
6964  * Parse and process Flex File errors returned via LayoutReturn.
6965  */
6966 static void
6967 nfsrv_flexlayouterr(struct nfsrv_descript *nd, uint32_t *layp, int maxcnt,
6968     NFSPROC_T *p)
6969 {
6970         uint32_t *tl;
6971         int cnt, errcnt, i, j, opnum, stat;
6972         char devid[NFSX_V4DEVICEID];
6973
6974         tl = layp;
6975         cnt = fxdr_unsigned(int, *tl++);
6976         NFSD_DEBUG(4, "flexlayouterr cnt=%d\n", cnt);
6977         for (i = 0; i < cnt; i++) {
6978                 /* Skip offset, length and stateid for now. */
6979                 tl += (4 + NFSX_STATEID / NFSX_UNSIGNED);
6980                 errcnt = fxdr_unsigned(int, *tl++);
6981                 NFSD_DEBUG(4, "flexlayouterr errcnt=%d\n", errcnt);
6982                 for (j = 0; j < errcnt; j++) {
6983                         NFSBCOPY(tl, devid, NFSX_V4DEVICEID);
6984                         tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
6985                         stat = fxdr_unsigned(int, *tl++);
6986                         opnum = fxdr_unsigned(int, *tl++);
6987                         NFSD_DEBUG(4, "flexlayouterr op=%d stat=%d\n", opnum,
6988                             stat);
6989                         /*
6990                          * Except for NFSERR_ACCES and NFSERR_STALE errors,
6991                          * disable the mirror.
6992                          */
6993                         if (stat != NFSERR_ACCES && stat != NFSERR_STALE)
6994                                 nfsrv_delds(devid, p);
6995                 }
6996         }
6997 }
6998
6999 /*
7000  * This function removes all flex file layouts which has a mirror with
7001  * a device id that matches the argument.
7002  * Called when the DS represented by the device id has failed.
7003  */
7004 void
7005 nfsrv_flexmirrordel(char *devid, NFSPROC_T *p)
7006 {
7007         uint32_t *tl;
7008         struct nfslayout *lyp, *nlyp;
7009         struct nfslayouthash *lhyp;
7010         struct nfslayouthead loclyp;
7011         int i, j;
7012
7013         NFSD_DEBUG(4, "flexmirrordel\n");
7014         /* Move all layouts found onto a local list. */
7015         TAILQ_INIT(&loclyp);
7016         for (i = 0; i < nfsrv_layouthashsize; i++) {
7017                 lhyp = &nfslayouthash[i];
7018                 NFSLOCKLAYOUT(lhyp);
7019                 TAILQ_FOREACH_SAFE(lyp, &lhyp->list, lay_list, nlyp) {
7020                         if (lyp->lay_type == NFSLAYOUT_FLEXFILE &&
7021                             lyp->lay_mirrorcnt > 1) {
7022                                 NFSD_DEBUG(4, "possible match\n");
7023                                 tl = lyp->lay_xdr;
7024                                 tl += 3;
7025                                 for (j = 0; j < lyp->lay_mirrorcnt; j++) {
7026                                         tl++;
7027                                         if (NFSBCMP(devid, tl, NFSX_V4DEVICEID)
7028                                             == 0) {
7029                                                 /* Found one. */
7030                                                 NFSD_DEBUG(4, "fnd one\n");
7031                                                 TAILQ_REMOVE(&lhyp->list, lyp,
7032                                                     lay_list);
7033                                                 TAILQ_INSERT_HEAD(&loclyp, lyp,
7034                                                     lay_list);
7035                                                 break;
7036                                         }
7037                                         tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED +
7038                                             NFSM_RNDUP(NFSX_V4PNFSFH) /
7039                                             NFSX_UNSIGNED + 11 * NFSX_UNSIGNED);
7040                                 }
7041                         }
7042                 }
7043                 NFSUNLOCKLAYOUT(lhyp);
7044         }
7045
7046         /* Now, try to do a Layout recall for each one found. */
7047         TAILQ_FOREACH_SAFE(lyp, &loclyp, lay_list, nlyp) {
7048                 NFSD_DEBUG(4, "do layout recall\n");
7049                 /*
7050                  * The layout stateid.seqid needs to be incremented
7051                  * before doing a LAYOUT_RECALL callback.
7052                  */
7053                 if (++lyp->lay_stateid.seqid == 0)
7054                         lyp->lay_stateid.seqid = 1;
7055                 nfsrv_recalllayout(lyp->lay_clientid, &lyp->lay_stateid,
7056                     &lyp->lay_fh, lyp, 1, lyp->lay_type, p);
7057                 nfsrv_freelayout(&loclyp, lyp);
7058         }
7059 }
7060
7061 /*
7062  * Do a recall callback to the client for this layout.
7063  */
7064 static int
7065 nfsrv_recalllayout(nfsquad_t clid, nfsv4stateid_t *stateidp, fhandle_t *fhp,
7066     struct nfslayout *lyp, int changed, int laytype, NFSPROC_T *p)
7067 {
7068         struct nfsclient *clp;
7069         int error;
7070
7071         NFSD_DEBUG(4, "nfsrv_recalllayout\n");
7072         error = nfsrv_getclient(clid, 0, &clp, NULL, (nfsquad_t)((u_quad_t)0),
7073             0, NULL, p);
7074         NFSD_DEBUG(4, "aft nfsrv_getclient=%d\n", error);
7075         if (error != 0) {
7076                 printf("nfsrv_recalllayout: getclient err=%d\n", error);
7077                 return (error);
7078         }
7079         if ((clp->lc_flags & LCL_NFSV41) != 0) {
7080                 error = nfsrv_docallback(clp, NFSV4OP_CBLAYOUTRECALL,
7081                     stateidp, changed, fhp, NULL, NULL, laytype, p);
7082                 /* If lyp != NULL, handle an error return here. */
7083                 if (error != 0 && lyp != NULL) {
7084                         NFSDRECALLLOCK();
7085                         /*
7086                          * Mark it returned, since no layout recall
7087                          * has been done.
7088                          * All errors seem to be non-recoverable, although
7089                          * NFSERR_NOMATCHLAYOUT is a normal event.
7090                          */
7091                         if ((lyp->lay_flags & NFSLAY_RECALL) != 0) {
7092                                 lyp->lay_flags |= NFSLAY_RETURNED;
7093                                 wakeup(lyp);
7094                         }
7095                         NFSDRECALLUNLOCK();
7096                         if (error != NFSERR_NOMATCHLAYOUT)
7097                                 printf("nfsrv_recalllayout: err=%d\n", error);
7098                 }
7099         } else
7100                 printf("nfsrv_recalllayout: clp not NFSv4.1\n");
7101         return (error);
7102 }
7103
7104 /*
7105  * Find a layout to recall when we exceed our high water mark.
7106  */
7107 void
7108 nfsrv_recalloldlayout(NFSPROC_T *p)
7109 {
7110         struct nfslayouthash *lhyp;
7111         struct nfslayout *lyp;
7112         nfsquad_t clientid;
7113         nfsv4stateid_t stateid;
7114         fhandle_t fh;
7115         int error, laytype = 0, ret;
7116
7117         lhyp = &nfslayouthash[arc4random() % nfsrv_layouthashsize];
7118         NFSLOCKLAYOUT(lhyp);
7119         TAILQ_FOREACH_REVERSE(lyp, &lhyp->list, nfslayouthead, lay_list) {
7120                 if ((lyp->lay_flags & NFSLAY_CALLB) == 0) {
7121                         lyp->lay_flags |= NFSLAY_CALLB;
7122                         /*
7123                          * The layout stateid.seqid needs to be incremented
7124                          * before doing a LAYOUT_RECALL callback.
7125                          */
7126                         if (++lyp->lay_stateid.seqid == 0)
7127                                 lyp->lay_stateid.seqid = 1;
7128                         clientid = lyp->lay_clientid;
7129                         stateid = lyp->lay_stateid;
7130                         NFSBCOPY(&lyp->lay_fh, &fh, sizeof(fh));
7131                         laytype = lyp->lay_type;
7132                         break;
7133                 }
7134         }
7135         NFSUNLOCKLAYOUT(lhyp);
7136         if (lyp != NULL) {
7137                 error = nfsrv_recalllayout(clientid, &stateid, &fh, NULL, 0,
7138                     laytype, p);
7139                 if (error != 0 && error != NFSERR_NOMATCHLAYOUT)
7140                         NFSD_DEBUG(4, "recallold=%d\n", error);
7141                 if (error != 0) {
7142                         NFSLOCKLAYOUT(lhyp);
7143                         /*
7144                          * Since the hash list was unlocked, we need to
7145                          * find it again.
7146                          */
7147                         ret = nfsrv_findlayout(&clientid, &fh, laytype, p,
7148                             &lyp);
7149                         if (ret == 0 &&
7150                             (lyp->lay_flags & NFSLAY_CALLB) != 0 &&
7151                             lyp->lay_stateid.other[0] == stateid.other[0] &&
7152                             lyp->lay_stateid.other[1] == stateid.other[1] &&
7153                             lyp->lay_stateid.other[2] == stateid.other[2]) {
7154                                 /*
7155                                  * The client no longer knows this layout, so
7156                                  * it can be free'd now.
7157                                  */
7158                                 if (error == NFSERR_NOMATCHLAYOUT)
7159                                         nfsrv_freelayout(&lhyp->list, lyp);
7160                                 else {
7161                                         /*
7162                                          * Leave it to be tried later by
7163                                          * clearing NFSLAY_CALLB and moving
7164                                          * it to the head of the list, so it
7165                                          * won't be tried again for a while.
7166                                          */
7167                                         lyp->lay_flags &= ~NFSLAY_CALLB;
7168                                         TAILQ_REMOVE(&lhyp->list, lyp,
7169                                             lay_list);
7170                                         TAILQ_INSERT_HEAD(&lhyp->list, lyp,
7171                                             lay_list);
7172                                 }
7173                         }
7174                         NFSUNLOCKLAYOUT(lhyp);
7175                 }
7176         }
7177 }
7178
7179 /*
7180  * Try and return layout(s).
7181  */
7182 int
7183 nfsrv_layoutreturn(struct nfsrv_descript *nd, vnode_t vp,
7184     int layouttype, int iomode, uint64_t offset, uint64_t len, int reclaim,
7185     int kind, nfsv4stateid_t *stateidp, int maxcnt, uint32_t *layp, int *fndp,
7186     struct ucred *cred, NFSPROC_T *p)
7187 {
7188         struct nfsvattr na;
7189         struct nfslayouthash *lhyp;
7190         struct nfslayout *lyp;
7191         fhandle_t fh;
7192         int error = 0;
7193
7194         *fndp = 0;
7195         if (kind == NFSV4LAYOUTRET_FILE) {
7196                 error = nfsvno_getfh(vp, &fh, p);
7197                 if (error == 0) {
7198                         error = nfsrv_updatemdsattr(vp, &na, p);
7199                         if (error != 0)
7200                                 printf("nfsrv_layoutreturn: updatemdsattr"
7201                                     " failed=%d\n", error);
7202                 }
7203                 if (error == 0) {
7204                         if (reclaim == newnfs_true) {
7205                                 error = nfsrv_checkgrace(NULL, NULL,
7206                                     NFSLCK_RECLAIM);
7207                                 if (error != NFSERR_NOGRACE)
7208                                         error = 0;
7209                                 return (error);
7210                         }
7211                         lhyp = NFSLAYOUTHASH(&fh);
7212                         NFSDRECALLLOCK();
7213                         NFSLOCKLAYOUT(lhyp);
7214                         error = nfsrv_findlayout(&nd->nd_clientid, &fh,
7215                             layouttype, p, &lyp);
7216                         NFSD_DEBUG(4, "layoutret findlay=%d\n", error);
7217                         if (error == 0 &&
7218                             stateidp->other[0] == lyp->lay_stateid.other[0] &&
7219                             stateidp->other[1] == lyp->lay_stateid.other[1] &&
7220                             stateidp->other[2] == lyp->lay_stateid.other[2]) {
7221                                 NFSD_DEBUG(4, "nfsrv_layoutreturn: stateid %d"
7222                                     " %x %x %x laystateid %d %x %x %x"
7223                                     " off=%ju len=%ju flgs=0x%x\n",
7224                                     stateidp->seqid, stateidp->other[0],
7225                                     stateidp->other[1], stateidp->other[2],
7226                                     lyp->lay_stateid.seqid,
7227                                     lyp->lay_stateid.other[0],
7228                                     lyp->lay_stateid.other[1],
7229                                     lyp->lay_stateid.other[2],
7230                                     (uintmax_t)offset, (uintmax_t)len,
7231                                     lyp->lay_flags);
7232                                 if (++lyp->lay_stateid.seqid == 0)
7233                                         lyp->lay_stateid.seqid = 1;
7234                                 stateidp->seqid = lyp->lay_stateid.seqid;
7235                                 if (offset == 0 && len == UINT64_MAX) {
7236                                         if ((iomode & NFSLAYOUTIOMODE_READ) !=
7237                                             0)
7238                                                 lyp->lay_flags &= ~NFSLAY_READ;
7239                                         if ((iomode & NFSLAYOUTIOMODE_RW) != 0)
7240                                                 lyp->lay_flags &= ~NFSLAY_RW;
7241                                         if ((lyp->lay_flags & (NFSLAY_READ |
7242                                             NFSLAY_RW)) == 0)
7243                                                 nfsrv_freelayout(&lhyp->list,
7244                                                     lyp);
7245                                         else
7246                                                 *fndp = 1;
7247                                 } else
7248                                         *fndp = 1;
7249                         }
7250                         NFSUNLOCKLAYOUT(lhyp);
7251                         /* Search the nfsrv_recalllist for a match. */
7252                         TAILQ_FOREACH(lyp, &nfsrv_recalllisthead, lay_list) {
7253                                 if (NFSBCMP(&lyp->lay_fh, &fh,
7254                                     sizeof(fh)) == 0 &&
7255                                     lyp->lay_clientid.qval ==
7256                                     nd->nd_clientid.qval &&
7257                                     stateidp->other[0] ==
7258                                     lyp->lay_stateid.other[0] &&
7259                                     stateidp->other[1] ==
7260                                     lyp->lay_stateid.other[1] &&
7261                                     stateidp->other[2] ==
7262                                     lyp->lay_stateid.other[2]) {
7263                                         lyp->lay_flags |= NFSLAY_RETURNED;
7264                                         wakeup(lyp);
7265                                         error = 0;
7266                                 }
7267                         }
7268                         NFSDRECALLUNLOCK();
7269                 }
7270                 if (layouttype == NFSLAYOUT_FLEXFILE)
7271                         nfsrv_flexlayouterr(nd, layp, maxcnt, p);
7272         } else if (kind == NFSV4LAYOUTRET_FSID)
7273                 nfsrv_freelayouts(&nd->nd_clientid,
7274                     &vp->v_mount->mnt_stat.f_fsid, layouttype, iomode);
7275         else if (kind == NFSV4LAYOUTRET_ALL)
7276                 nfsrv_freelayouts(&nd->nd_clientid, NULL, layouttype, iomode);
7277         else
7278                 error = NFSERR_INVAL;
7279         if (error == -1)
7280                 error = 0;
7281         return (error);
7282 }
7283
7284 /*
7285  * Look for an existing layout.
7286  */
7287 static int
7288 nfsrv_findlayout(nfsquad_t *clientidp, fhandle_t *fhp, int laytype,
7289     NFSPROC_T *p, struct nfslayout **lypp)
7290 {
7291         struct nfslayouthash *lhyp;
7292         struct nfslayout *lyp;
7293         int ret;
7294
7295         *lypp = NULL;
7296         ret = 0;
7297         lhyp = NFSLAYOUTHASH(fhp);
7298         TAILQ_FOREACH(lyp, &lhyp->list, lay_list) {
7299                 if (NFSBCMP(&lyp->lay_fh, fhp, sizeof(*fhp)) == 0 &&
7300                     lyp->lay_clientid.qval == clientidp->qval &&
7301                     lyp->lay_type == laytype)
7302                         break;
7303         }
7304         if (lyp != NULL)
7305                 *lypp = lyp;
7306         else
7307                 ret = -1;
7308         return (ret);
7309 }
7310
7311 /*
7312  * Add the new layout, as required.
7313  */
7314 static int
7315 nfsrv_addlayout(struct nfsrv_descript *nd, struct nfslayout **lypp,
7316     nfsv4stateid_t *stateidp, char *layp, int *layoutlenp, NFSPROC_T *p)
7317 {
7318         struct nfsclient *clp;
7319         struct nfslayouthash *lhyp;
7320         struct nfslayout *lyp, *nlyp;
7321         fhandle_t *fhp;
7322         int error;
7323
7324         KASSERT((nd->nd_flag & ND_IMPLIEDCLID) != 0,
7325             ("nfsrv_layoutget: no nd_clientid\n"));
7326         lyp = *lypp;
7327         fhp = &lyp->lay_fh;
7328         NFSLOCKSTATE();
7329         error = nfsrv_getclient((nfsquad_t)((u_quad_t)0), CLOPS_RENEW, &clp,
7330             NULL, (nfsquad_t)((u_quad_t)0), 0, nd, p);
7331         if (error != 0) {
7332                 NFSUNLOCKSTATE();
7333                 return (error);
7334         }
7335         lyp->lay_stateid.seqid = stateidp->seqid = 1;
7336         lyp->lay_stateid.other[0] = stateidp->other[0] =
7337             clp->lc_clientid.lval[0];
7338         lyp->lay_stateid.other[1] = stateidp->other[1] =
7339             clp->lc_clientid.lval[1];
7340         lyp->lay_stateid.other[2] = stateidp->other[2] =
7341             nfsrv_nextstateindex(clp);
7342         NFSUNLOCKSTATE();
7343
7344         lhyp = NFSLAYOUTHASH(fhp);
7345         NFSLOCKLAYOUT(lhyp);
7346         TAILQ_FOREACH(nlyp, &lhyp->list, lay_list) {
7347                 if (NFSBCMP(&nlyp->lay_fh, fhp, sizeof(*fhp)) == 0 &&
7348                     nlyp->lay_clientid.qval == nd->nd_clientid.qval)
7349                         break;
7350         }
7351         if (nlyp != NULL) {
7352                 /* A layout already exists, so use it. */
7353                 nlyp->lay_flags |= (lyp->lay_flags & (NFSLAY_READ | NFSLAY_RW));
7354                 NFSBCOPY(nlyp->lay_xdr, layp, nlyp->lay_layoutlen);
7355                 *layoutlenp = nlyp->lay_layoutlen;
7356                 if (++nlyp->lay_stateid.seqid == 0)
7357                         nlyp->lay_stateid.seqid = 1;
7358                 stateidp->seqid = nlyp->lay_stateid.seqid;
7359                 stateidp->other[0] = nlyp->lay_stateid.other[0];
7360                 stateidp->other[1] = nlyp->lay_stateid.other[1];
7361                 stateidp->other[2] = nlyp->lay_stateid.other[2];
7362                 NFSUNLOCKLAYOUT(lhyp);
7363                 return (0);
7364         }
7365
7366         /* Insert the new layout in the lists. */
7367         *lypp = NULL;
7368         atomic_add_int(&nfsrv_layoutcnt, 1);
7369         NFSBCOPY(lyp->lay_xdr, layp, lyp->lay_layoutlen);
7370         *layoutlenp = lyp->lay_layoutlen;
7371         TAILQ_INSERT_HEAD(&lhyp->list, lyp, lay_list);
7372         NFSUNLOCKLAYOUT(lhyp);
7373         return (0);
7374 }
7375
7376 /*
7377  * Get the devinfo for a deviceid.
7378  */
7379 int
7380 nfsrv_getdevinfo(char *devid, int layouttype, uint32_t *maxcnt,
7381     uint32_t *notify, int *devaddrlen, char **devaddr)
7382 {
7383         struct nfsdevice *ds;
7384
7385         if ((layouttype != NFSLAYOUT_NFSV4_1_FILES && layouttype !=
7386              NFSLAYOUT_FLEXFILE) ||
7387             (nfsrv_maxpnfsmirror > 1 && layouttype == NFSLAYOUT_NFSV4_1_FILES))
7388                 return (NFSERR_UNKNLAYOUTTYPE);
7389
7390         /*
7391          * Now, search for the device id.  Note that the structures won't go
7392          * away, but the order changes in the list.  As such, the lock only
7393          * needs to be held during the search through the list.
7394          */
7395         NFSDDSLOCK();
7396         TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
7397                 if (NFSBCMP(devid, ds->nfsdev_deviceid, NFSX_V4DEVICEID) == 0 &&
7398                     ds->nfsdev_nmp != NULL)
7399                         break;
7400         }
7401         NFSDDSUNLOCK();
7402         if (ds == NULL)
7403                 return (NFSERR_NOENT);
7404
7405         /* If the correct nfsdev_XXXXaddrlen is > 0, we have the device info. */
7406         *devaddrlen = 0;
7407         if (layouttype == NFSLAYOUT_NFSV4_1_FILES) {
7408                 *devaddrlen = ds->nfsdev_fileaddrlen;
7409                 *devaddr = ds->nfsdev_fileaddr;
7410         } else if (layouttype == NFSLAYOUT_FLEXFILE) {
7411                 *devaddrlen = ds->nfsdev_flexaddrlen;
7412                 *devaddr = ds->nfsdev_flexaddr;
7413         }
7414         if (*devaddrlen == 0)
7415                 return (NFSERR_UNKNLAYOUTTYPE);
7416
7417         /*
7418          * The XDR overhead is 3 unsigned values: layout_type,
7419          * length_of_address and notify bitmap.
7420          * If the notify array is changed to not all zeros, the
7421          * count of unsigned values must be increased.
7422          */
7423         if (*maxcnt > 0 && *maxcnt < NFSM_RNDUP(*devaddrlen) +
7424             3 * NFSX_UNSIGNED) {
7425                 *maxcnt = NFSM_RNDUP(*devaddrlen) + 3 * NFSX_UNSIGNED;
7426                 return (NFSERR_TOOSMALL);
7427         }
7428         return (0);
7429 }
7430
7431 /*
7432  * Free a list of layout state structures.
7433  */
7434 static void
7435 nfsrv_freelayoutlist(nfsquad_t clientid)
7436 {
7437         struct nfslayouthash *lhyp;
7438         struct nfslayout *lyp, *nlyp;
7439         int i;
7440
7441         for (i = 0; i < nfsrv_layouthashsize; i++) {
7442                 lhyp = &nfslayouthash[i];
7443                 NFSLOCKLAYOUT(lhyp);
7444                 TAILQ_FOREACH_SAFE(lyp, &lhyp->list, lay_list, nlyp) {
7445                         if (lyp->lay_clientid.qval == clientid.qval)
7446                                 nfsrv_freelayout(&lhyp->list, lyp);
7447                 }
7448                 NFSUNLOCKLAYOUT(lhyp);
7449         }
7450 }
7451
7452 /*
7453  * Free up a layout.
7454  */
7455 static void
7456 nfsrv_freelayout(struct nfslayouthead *lhp, struct nfslayout *lyp)
7457 {
7458
7459         NFSD_DEBUG(4, "Freelayout=%p\n", lyp);
7460         atomic_add_int(&nfsrv_layoutcnt, -1);
7461         TAILQ_REMOVE(lhp, lyp, lay_list);
7462         free(lyp, M_NFSDSTATE);
7463 }
7464
7465 /*
7466  * Free up a device id.
7467  */
7468 void
7469 nfsrv_freeonedevid(struct nfsdevice *ds)
7470 {
7471         int i;
7472
7473         atomic_add_int(&nfsrv_devidcnt, -1);
7474         vrele(ds->nfsdev_dvp);
7475         for (i = 0; i < nfsrv_dsdirsize; i++)
7476                 if (ds->nfsdev_dsdir[i] != NULL)
7477                         vrele(ds->nfsdev_dsdir[i]);
7478         free(ds->nfsdev_fileaddr, M_NFSDSTATE);
7479         free(ds->nfsdev_flexaddr, M_NFSDSTATE);
7480         free(ds->nfsdev_host, M_NFSDSTATE);
7481         free(ds, M_NFSDSTATE);
7482 }
7483
7484 /*
7485  * Free up a device id and its mirrors.
7486  */
7487 static void
7488 nfsrv_freedevid(struct nfsdevice *ds)
7489 {
7490
7491         TAILQ_REMOVE(&nfsrv_devidhead, ds, nfsdev_list);
7492         nfsrv_freeonedevid(ds);
7493 }
7494
7495 /*
7496  * Free all layouts and device ids.
7497  * Done when the nfsd threads are shut down since there may be a new
7498  * modified device id list created when the nfsd is restarted.
7499  */
7500 void
7501 nfsrv_freealllayoutsanddevids(void)
7502 {
7503         struct nfsdontlist *mrp, *nmrp;
7504         struct nfslayout *lyp, *nlyp;
7505
7506         /* Get rid of the deviceid structures. */
7507         nfsrv_freealldevids();
7508         TAILQ_INIT(&nfsrv_devidhead);
7509         nfsrv_devidcnt = 0;
7510
7511         /* Get rid of all layouts. */
7512         nfsrv_freealllayouts();
7513
7514         /* Get rid of any nfsdontlist entries. */
7515         LIST_FOREACH_SAFE(mrp, &nfsrv_dontlisthead, nfsmr_list, nmrp)
7516                 free(mrp, M_NFSDSTATE);
7517         LIST_INIT(&nfsrv_dontlisthead);
7518         nfsrv_dontlistlen = 0;
7519
7520         /* Free layouts in the recall list. */
7521         TAILQ_FOREACH_SAFE(lyp, &nfsrv_recalllisthead, lay_list, nlyp)
7522                 nfsrv_freelayout(&nfsrv_recalllisthead, lyp);
7523         TAILQ_INIT(&nfsrv_recalllisthead);
7524 }
7525
7526 /*
7527  * Free layouts that match the arguments.
7528  */
7529 static void
7530 nfsrv_freelayouts(nfsquad_t *clid, fsid_t *fs, int laytype, int iomode)
7531 {
7532         struct nfslayouthash *lhyp;
7533         struct nfslayout *lyp, *nlyp;
7534         int i;
7535
7536         for (i = 0; i < nfsrv_layouthashsize; i++) {
7537                 lhyp = &nfslayouthash[i];
7538                 NFSLOCKLAYOUT(lhyp);
7539                 TAILQ_FOREACH_SAFE(lyp, &lhyp->list, lay_list, nlyp) {
7540                         if (clid->qval != lyp->lay_clientid.qval)
7541                                 continue;
7542                         if (fs != NULL && fsidcmp(fs, &lyp->lay_fsid) != 0)
7543                                 continue;
7544                         if (laytype != lyp->lay_type)
7545                                 continue;
7546                         if ((iomode & NFSLAYOUTIOMODE_READ) != 0)
7547                                 lyp->lay_flags &= ~NFSLAY_READ;
7548                         if ((iomode & NFSLAYOUTIOMODE_RW) != 0)
7549                                 lyp->lay_flags &= ~NFSLAY_RW;
7550                         if ((lyp->lay_flags & (NFSLAY_READ | NFSLAY_RW)) == 0)
7551                                 nfsrv_freelayout(&lhyp->list, lyp);
7552                 }
7553                 NFSUNLOCKLAYOUT(lhyp);
7554         }
7555 }
7556
7557 /*
7558  * Free all layouts for the argument file.
7559  */
7560 void
7561 nfsrv_freefilelayouts(fhandle_t *fhp)
7562 {
7563         struct nfslayouthash *lhyp;
7564         struct nfslayout *lyp, *nlyp;
7565
7566         lhyp = NFSLAYOUTHASH(fhp);
7567         NFSLOCKLAYOUT(lhyp);
7568         TAILQ_FOREACH_SAFE(lyp, &lhyp->list, lay_list, nlyp) {
7569                 if (NFSBCMP(&lyp->lay_fh, fhp, sizeof(*fhp)) == 0)
7570                         nfsrv_freelayout(&lhyp->list, lyp);
7571         }
7572         NFSUNLOCKLAYOUT(lhyp);
7573 }
7574
7575 /*
7576  * Free all layouts.
7577  */
7578 static void
7579 nfsrv_freealllayouts(void)
7580 {
7581         struct nfslayouthash *lhyp;
7582         struct nfslayout *lyp, *nlyp;
7583         int i;
7584
7585         for (i = 0; i < nfsrv_layouthashsize; i++) {
7586                 lhyp = &nfslayouthash[i];
7587                 NFSLOCKLAYOUT(lhyp);
7588                 TAILQ_FOREACH_SAFE(lyp, &lhyp->list, lay_list, nlyp)
7589                         nfsrv_freelayout(&lhyp->list, lyp);
7590                 NFSUNLOCKLAYOUT(lhyp);
7591         }
7592 }
7593
7594 /*
7595  * Look up the mount path for the DS server.
7596  */
7597 static int
7598 nfsrv_setdsserver(char *dspathp, char *mdspathp, NFSPROC_T *p,
7599     struct nfsdevice **dsp)
7600 {
7601         struct nameidata nd;
7602         struct nfsdevice *ds;
7603         struct mount *mp;
7604         int error, i;
7605         char *dsdirpath;
7606         size_t dsdirsize;
7607
7608         NFSD_DEBUG(4, "setdssrv path=%s\n", dspathp);
7609         *dsp = NULL;
7610         NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
7611             dspathp, p);
7612         error = namei(&nd);
7613         NFSD_DEBUG(4, "lookup=%d\n", error);
7614         if (error != 0)
7615                 return (error);
7616         if (nd.ni_vp->v_type != VDIR) {
7617                 vput(nd.ni_vp);
7618                 NFSD_DEBUG(4, "dspath not dir\n");
7619                 return (ENOTDIR);
7620         }
7621         if (strcmp(nd.ni_vp->v_mount->mnt_vfc->vfc_name, "nfs") != 0) {
7622                 vput(nd.ni_vp);
7623                 NFSD_DEBUG(4, "dspath not an NFS mount\n");
7624                 return (ENXIO);
7625         }
7626
7627         /*
7628          * Allocate a DS server structure with the NFS mounted directory
7629          * vnode reference counted, so that a non-forced dismount will
7630          * fail with EBUSY.
7631          * This structure is always linked into the list, even if an error
7632          * is being returned.  The caller will free the entire list upon
7633          * an error return.
7634          */
7635         *dsp = ds = malloc(sizeof(*ds) + nfsrv_dsdirsize * sizeof(vnode_t),
7636             M_NFSDSTATE, M_WAITOK | M_ZERO);
7637         ds->nfsdev_dvp = nd.ni_vp;
7638         ds->nfsdev_nmp = VFSTONFS(nd.ni_vp->v_mount);
7639         NFSVOPUNLOCK(nd.ni_vp);
7640
7641         dsdirsize = strlen(dspathp) + 16;
7642         dsdirpath = malloc(dsdirsize, M_TEMP, M_WAITOK);
7643         /* Now, create the DS directory structures. */
7644         for (i = 0; i < nfsrv_dsdirsize; i++) {
7645                 snprintf(dsdirpath, dsdirsize, "%s/ds%d", dspathp, i);
7646                 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF,
7647                     UIO_SYSSPACE, dsdirpath, p);
7648                 error = namei(&nd);
7649                 NFSD_DEBUG(4, "dsdirpath=%s lookup=%d\n", dsdirpath, error);
7650                 if (error != 0)
7651                         break;
7652                 if (nd.ni_vp->v_type != VDIR) {
7653                         vput(nd.ni_vp);
7654                         error = ENOTDIR;
7655                         NFSD_DEBUG(4, "dsdirpath not a VDIR\n");
7656                         break;
7657                 }
7658                 if (strcmp(nd.ni_vp->v_mount->mnt_vfc->vfc_name, "nfs") != 0) {
7659                         vput(nd.ni_vp);
7660                         error = ENXIO;
7661                         NFSD_DEBUG(4, "dsdirpath not an NFS mount\n");
7662                         break;
7663                 }
7664                 ds->nfsdev_dsdir[i] = nd.ni_vp;
7665                 NFSVOPUNLOCK(nd.ni_vp);
7666         }
7667         free(dsdirpath, M_TEMP);
7668
7669         if (strlen(mdspathp) > 0) {
7670                 /*
7671                  * This DS stores file for a specific MDS exported file
7672                  * system.
7673                  */
7674                 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF,
7675                     UIO_SYSSPACE, mdspathp, p);
7676                 error = namei(&nd);
7677                 NFSD_DEBUG(4, "mds lookup=%d\n", error);
7678                 if (error != 0)
7679                         goto out;
7680                 if (nd.ni_vp->v_type != VDIR) {
7681                         vput(nd.ni_vp);
7682                         error = ENOTDIR;
7683                         NFSD_DEBUG(4, "mdspath not dir\n");
7684                         goto out;
7685                 }
7686                 mp = nd.ni_vp->v_mount;
7687                 if ((mp->mnt_flag & MNT_EXPORTED) == 0) {
7688                         vput(nd.ni_vp);
7689                         error = ENXIO;
7690                         NFSD_DEBUG(4, "mdspath not an exported fs\n");
7691                         goto out;
7692                 }
7693                 ds->nfsdev_mdsfsid = mp->mnt_stat.f_fsid;
7694                 ds->nfsdev_mdsisset = 1;
7695                 vput(nd.ni_vp);
7696         }
7697
7698 out:
7699         TAILQ_INSERT_TAIL(&nfsrv_devidhead, ds, nfsdev_list);
7700         atomic_add_int(&nfsrv_devidcnt, 1);
7701         return (error);
7702 }
7703
7704 /*
7705  * Look up the mount path for the DS server and delete it.
7706  */
7707 int
7708 nfsrv_deldsserver(int op, char *dspathp, NFSPROC_T *p)
7709 {
7710         struct mount *mp;
7711         struct nfsmount *nmp;
7712         struct nfsdevice *ds;
7713         int error;
7714
7715         NFSD_DEBUG(4, "deldssrv path=%s\n", dspathp);
7716         /*
7717          * Search for the path in the mount list.  Avoid looking the path
7718          * up, since this mount point may be hung, with associated locked
7719          * vnodes, etc.
7720          * Set NFSMNTP_CANCELRPCS so that any forced dismount will be blocked
7721          * until this completes.
7722          * As noted in the man page, this should be done before any forced
7723          * dismount on the mount point, but at least the handshake on
7724          * NFSMNTP_CANCELRPCS should make it safe.
7725          */
7726         error = 0;
7727         ds = NULL;
7728         nmp = NULL;
7729         mtx_lock(&mountlist_mtx);
7730         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
7731                 if (strcmp(mp->mnt_stat.f_mntonname, dspathp) == 0 &&
7732                     strcmp(mp->mnt_stat.f_fstypename, "nfs") == 0 &&
7733                     mp->mnt_data != NULL) {
7734                         nmp = VFSTONFS(mp);
7735                         NFSLOCKMNT(nmp);
7736                         if ((nmp->nm_privflag & (NFSMNTP_FORCEDISM |
7737                              NFSMNTP_CANCELRPCS)) == 0) {
7738                                 nmp->nm_privflag |= NFSMNTP_CANCELRPCS;
7739                                 NFSUNLOCKMNT(nmp);
7740                         } else {
7741                                 NFSUNLOCKMNT(nmp);
7742                                 nmp = NULL;
7743                         }
7744                         break;
7745                 }
7746         }
7747         mtx_unlock(&mountlist_mtx);
7748
7749         if (nmp != NULL) {
7750                 ds = nfsrv_deldsnmp(op, nmp, p);
7751                 NFSD_DEBUG(4, "deldsnmp=%p\n", ds);
7752                 if (ds != NULL) {
7753                         nfsrv_killrpcs(nmp);
7754                         NFSD_DEBUG(4, "aft killrpcs\n");
7755                 } else
7756                         error = ENXIO;
7757                 NFSLOCKMNT(nmp);
7758                 nmp->nm_privflag &= ~NFSMNTP_CANCELRPCS;
7759                 wakeup(nmp);
7760                 NFSUNLOCKMNT(nmp);
7761         } else
7762                 error = EINVAL;
7763         return (error);
7764 }
7765
7766 /*
7767  * Search for and remove a DS entry which matches the "nmp" argument.
7768  * The nfsdevice structure pointer is returned so that the caller can
7769  * free it via nfsrv_freeonedevid().
7770  * For the forced case, do not try to do LayoutRecalls, since the server
7771  * must be shut down now anyhow.
7772  */
7773 struct nfsdevice *
7774 nfsrv_deldsnmp(int op, struct nfsmount *nmp, NFSPROC_T *p)
7775 {
7776         struct nfsdevice *fndds;
7777
7778         NFSD_DEBUG(4, "deldsdvp\n");
7779         NFSDDSLOCK();
7780         if (op == PNFSDOP_FORCEDELDS)
7781                 fndds = nfsv4_findmirror(nmp);
7782         else
7783                 fndds = nfsrv_findmirroredds(nmp);
7784         if (fndds != NULL)
7785                 nfsrv_deleteds(fndds);
7786         NFSDDSUNLOCK();
7787         if (fndds != NULL) {
7788                 if (op != PNFSDOP_FORCEDELDS)
7789                         nfsrv_flexmirrordel(fndds->nfsdev_deviceid, p);
7790                 printf("pNFS server: mirror %s failed\n", fndds->nfsdev_host);
7791         }
7792         return (fndds);
7793 }
7794
7795 /*
7796  * Similar to nfsrv_deldsnmp(), except that the DS is indicated by deviceid.
7797  * This function also calls nfsrv_killrpcs() to unblock RPCs on the mount
7798  * point.
7799  * Also, returns an error instead of the nfsdevice found.
7800  */
7801 int
7802 nfsrv_delds(char *devid, NFSPROC_T *p)
7803 {
7804         struct nfsdevice *ds, *fndds;
7805         struct nfsmount *nmp;
7806         int fndmirror;
7807
7808         NFSD_DEBUG(4, "delds\n");
7809         /*
7810          * Search the DS server list for a match with devid.
7811          * Remove the DS entry if found and there is a mirror.
7812          */
7813         fndds = NULL;
7814         nmp = NULL;
7815         fndmirror = 0;
7816         NFSDDSLOCK();
7817         TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
7818                 if (NFSBCMP(ds->nfsdev_deviceid, devid, NFSX_V4DEVICEID) == 0 &&
7819                     ds->nfsdev_nmp != NULL) {
7820                         NFSD_DEBUG(4, "fnd main ds\n");
7821                         fndds = ds;
7822                         break;
7823                 }
7824         }
7825         if (fndds == NULL) {
7826                 NFSDDSUNLOCK();
7827                 return (ENXIO);
7828         }
7829         if (fndds->nfsdev_mdsisset == 0 && nfsrv_faildscnt > 0)
7830                 fndmirror = 1;
7831         else if (fndds->nfsdev_mdsisset != 0) {
7832                 /* For the fsid is set case, search for a mirror. */
7833                 TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
7834                         if (ds != fndds && ds->nfsdev_nmp != NULL &&
7835                             ds->nfsdev_mdsisset != 0 &&
7836                             fsidcmp(&ds->nfsdev_mdsfsid,
7837                             &fndds->nfsdev_mdsfsid) == 0) {
7838                                 fndmirror = 1;
7839                                 break;
7840                         }
7841                 }
7842         }
7843         if (fndmirror != 0) {
7844                 nmp = fndds->nfsdev_nmp;
7845                 NFSLOCKMNT(nmp);
7846                 if ((nmp->nm_privflag & (NFSMNTP_FORCEDISM |
7847                      NFSMNTP_CANCELRPCS)) == 0) {
7848                         nmp->nm_privflag |= NFSMNTP_CANCELRPCS;
7849                         NFSUNLOCKMNT(nmp);
7850                         nfsrv_deleteds(fndds);
7851                 } else {
7852                         NFSUNLOCKMNT(nmp);
7853                         nmp = NULL;
7854                 }
7855         }
7856         NFSDDSUNLOCK();
7857         if (nmp != NULL) {
7858                 nfsrv_flexmirrordel(fndds->nfsdev_deviceid, p);
7859                 printf("pNFS server: mirror %s failed\n", fndds->nfsdev_host);
7860                 nfsrv_killrpcs(nmp);
7861                 NFSLOCKMNT(nmp);
7862                 nmp->nm_privflag &= ~NFSMNTP_CANCELRPCS;
7863                 wakeup(nmp);
7864                 NFSUNLOCKMNT(nmp);
7865                 return (0);
7866         }
7867         return (ENXIO);
7868 }
7869
7870 /*
7871  * Mark a DS as disabled by setting nfsdev_nmp = NULL.
7872  */
7873 static void
7874 nfsrv_deleteds(struct nfsdevice *fndds)
7875 {
7876
7877         NFSD_DEBUG(4, "deleteds: deleting a mirror\n");
7878         fndds->nfsdev_nmp = NULL;
7879         if (fndds->nfsdev_mdsisset == 0)
7880                 nfsrv_faildscnt--;
7881 }
7882
7883 /*
7884  * Fill in the addr structures for the File and Flex File layouts.
7885  */
7886 static void
7887 nfsrv_allocdevid(struct nfsdevice *ds, char *addr, char *dnshost)
7888 {
7889         uint32_t *tl;
7890         char *netprot;
7891         int addrlen;
7892         static uint64_t new_devid = 0;
7893
7894         if (strchr(addr, ':') != NULL)
7895                 netprot = "tcp6";
7896         else
7897                 netprot = "tcp";
7898
7899         /* Fill in the device id. */
7900         NFSBCOPY(&nfsdev_time, ds->nfsdev_deviceid, sizeof(nfsdev_time));
7901         new_devid++;
7902         NFSBCOPY(&new_devid, &ds->nfsdev_deviceid[sizeof(nfsdev_time)],
7903             sizeof(new_devid));
7904
7905         /*
7906          * Fill in the file addr (actually the nfsv4_file_layout_ds_addr4
7907          * as defined in RFC5661) in XDR.
7908          */
7909         addrlen = NFSM_RNDUP(strlen(addr)) + NFSM_RNDUP(strlen(netprot)) +
7910             6 * NFSX_UNSIGNED;
7911         NFSD_DEBUG(4, "hn=%s addr=%s netprot=%s\n", dnshost, addr, netprot);
7912         ds->nfsdev_fileaddrlen = addrlen;
7913         tl = malloc(addrlen, M_NFSDSTATE, M_WAITOK | M_ZERO);
7914         ds->nfsdev_fileaddr = (char *)tl;
7915         *tl++ = txdr_unsigned(1);               /* One stripe with index 0. */
7916         *tl++ = 0;
7917         *tl++ = txdr_unsigned(1);               /* One multipath list */
7918         *tl++ = txdr_unsigned(1);               /* with one entry in it. */
7919         /* The netaddr for this one entry. */
7920         *tl++ = txdr_unsigned(strlen(netprot));
7921         NFSBCOPY(netprot, tl, strlen(netprot));
7922         tl += (NFSM_RNDUP(strlen(netprot)) / NFSX_UNSIGNED);
7923         *tl++ = txdr_unsigned(strlen(addr));
7924         NFSBCOPY(addr, tl, strlen(addr));
7925
7926         /*
7927          * Fill in the flex file addr (actually the ff_device_addr4
7928          * as defined for Flexible File Layout) in XDR.
7929          */
7930         addrlen = NFSM_RNDUP(strlen(addr)) + NFSM_RNDUP(strlen(netprot)) +
7931             14 * NFSX_UNSIGNED;
7932         ds->nfsdev_flexaddrlen = addrlen;
7933         tl = malloc(addrlen, M_NFSDSTATE, M_WAITOK | M_ZERO);
7934         ds->nfsdev_flexaddr = (char *)tl;
7935         *tl++ = txdr_unsigned(1);               /* One multipath entry. */
7936         /* The netaddr for this one entry. */
7937         *tl++ = txdr_unsigned(strlen(netprot));
7938         NFSBCOPY(netprot, tl, strlen(netprot));
7939         tl += (NFSM_RNDUP(strlen(netprot)) / NFSX_UNSIGNED);
7940         *tl++ = txdr_unsigned(strlen(addr));
7941         NFSBCOPY(addr, tl, strlen(addr));
7942         tl += (NFSM_RNDUP(strlen(addr)) / NFSX_UNSIGNED);
7943         *tl++ = txdr_unsigned(2);               /* Two NFS Versions. */
7944         *tl++ = txdr_unsigned(NFS_VER4);        /* NFSv4. */
7945         *tl++ = txdr_unsigned(NFSV42_MINORVERSION); /* Minor version 2. */
7946         *tl++ = txdr_unsigned(NFS_SRVMAXIO);    /* DS max rsize. */
7947         *tl++ = txdr_unsigned(NFS_SRVMAXIO);    /* DS max wsize. */
7948         *tl++ = newnfs_true;                    /* Tightly coupled. */
7949         *tl++ = txdr_unsigned(NFS_VER4);        /* NFSv4. */
7950         *tl++ = txdr_unsigned(NFSV41_MINORVERSION); /* Minor version 1. */
7951         *tl++ = txdr_unsigned(NFS_SRVMAXIO);    /* DS max rsize. */
7952         *tl++ = txdr_unsigned(NFS_SRVMAXIO);    /* DS max wsize. */
7953         *tl = newnfs_true;                      /* Tightly coupled. */
7954
7955         ds->nfsdev_hostnamelen = strlen(dnshost);
7956         ds->nfsdev_host = malloc(ds->nfsdev_hostnamelen + 1, M_NFSDSTATE,
7957             M_WAITOK);
7958         NFSBCOPY(dnshost, ds->nfsdev_host, ds->nfsdev_hostnamelen + 1);
7959 }
7960
7961 /*
7962  * Create the device id list.
7963  * Return 0 if the nfsd threads are to run and ENXIO if the "-p" argument
7964  * is misconfigured.
7965  */
7966 int
7967 nfsrv_createdevids(struct nfsd_nfsd_args *args, NFSPROC_T *p)
7968 {
7969         struct nfsdevice *ds;
7970         char *addrp, *dnshostp, *dspathp, *mdspathp;
7971         int error, i;
7972
7973         addrp = args->addr;
7974         dnshostp = args->dnshost;
7975         dspathp = args->dspath;
7976         mdspathp = args->mdspath;
7977         nfsrv_maxpnfsmirror = args->mirrorcnt;
7978         if (addrp == NULL || dnshostp == NULL || dspathp == NULL ||
7979             mdspathp == NULL)
7980                 return (0);
7981
7982         /*
7983          * Loop around for each nul-terminated string in args->addr,
7984          * args->dnshost, args->dnspath and args->mdspath.
7985          */
7986         while (addrp < (args->addr + args->addrlen) &&
7987             dnshostp < (args->dnshost + args->dnshostlen) &&
7988             dspathp < (args->dspath + args->dspathlen) &&
7989             mdspathp < (args->mdspath + args->mdspathlen)) {
7990                 error = nfsrv_setdsserver(dspathp, mdspathp, p, &ds);
7991                 if (error != 0) {
7992                         /* Free all DS servers. */
7993                         nfsrv_freealldevids();
7994                         nfsrv_devidcnt = 0;
7995                         return (ENXIO);
7996                 }
7997                 nfsrv_allocdevid(ds, addrp, dnshostp);
7998                 addrp += (strlen(addrp) + 1);
7999                 dnshostp += (strlen(dnshostp) + 1);
8000                 dspathp += (strlen(dspathp) + 1);
8001                 mdspathp += (strlen(mdspathp) + 1);
8002         }
8003         if (nfsrv_devidcnt < nfsrv_maxpnfsmirror) {
8004                 /* Free all DS servers. */
8005                 nfsrv_freealldevids();
8006                 nfsrv_devidcnt = 0;
8007                 nfsrv_maxpnfsmirror = 1;
8008                 return (ENXIO);
8009         }
8010         /* We can fail at most one less DS than the mirror level. */
8011         nfsrv_faildscnt = nfsrv_maxpnfsmirror - 1;
8012
8013         /*
8014          * Allocate the nfslayout hash table now, since this is a pNFS server.
8015          * Make it 1% of the high water mark and at least 100.
8016          */
8017         if (nfslayouthash == NULL) {
8018                 nfsrv_layouthashsize = nfsrv_layouthighwater / 100;
8019                 if (nfsrv_layouthashsize < 100)
8020                         nfsrv_layouthashsize = 100;
8021                 nfslayouthash = mallocarray(nfsrv_layouthashsize,
8022                     sizeof(struct nfslayouthash), M_NFSDSESSION, M_WAITOK |
8023                     M_ZERO);
8024                 for (i = 0; i < nfsrv_layouthashsize; i++) {
8025                         mtx_init(&nfslayouthash[i].mtx, "nfslm", NULL, MTX_DEF);
8026                         TAILQ_INIT(&nfslayouthash[i].list);
8027                 }
8028         }
8029         return (0);
8030 }
8031
8032 /*
8033  * Free all device ids.
8034  */
8035 static void
8036 nfsrv_freealldevids(void)
8037 {
8038         struct nfsdevice *ds, *nds;
8039
8040         TAILQ_FOREACH_SAFE(ds, &nfsrv_devidhead, nfsdev_list, nds)
8041                 nfsrv_freedevid(ds);
8042 }
8043
8044 /*
8045  * Check to see if there is a Read/Write Layout plus either:
8046  * - A Write Delegation
8047  * or
8048  * - An Open with Write_access.
8049  * Return 1 if this is the case and 0 otherwise.
8050  * This function is used by nfsrv_proxyds() to decide if doing a Proxy
8051  * Getattr RPC to the Data Server (DS) is necessary.
8052  */
8053 #define NFSCLIDVECSIZE  6
8054 int
8055 nfsrv_checkdsattr(vnode_t vp, NFSPROC_T *p)
8056 {
8057         fhandle_t fh, *tfhp;
8058         struct nfsstate *stp;
8059         struct nfslayout *lyp;
8060         struct nfslayouthash *lhyp;
8061         struct nfslockhashhead *hp;
8062         struct nfslockfile *lfp;
8063         nfsquad_t clid[NFSCLIDVECSIZE];
8064         int clidcnt, ret;
8065
8066         ret = nfsvno_getfh(vp, &fh, p);
8067         if (ret != 0)
8068                 return (0);
8069
8070         /* First check for a Read/Write Layout. */
8071         clidcnt = 0;
8072         lhyp = NFSLAYOUTHASH(&fh);
8073         NFSLOCKLAYOUT(lhyp);
8074         TAILQ_FOREACH(lyp, &lhyp->list, lay_list) {
8075                 if (NFSBCMP(&lyp->lay_fh, &fh, sizeof(fh)) == 0 &&
8076                     ((lyp->lay_flags & NFSLAY_RW) != 0 ||
8077                      ((lyp->lay_flags & NFSLAY_READ) != 0 &&
8078                       nfsrv_pnfsatime != 0))) {
8079                         if (clidcnt < NFSCLIDVECSIZE)
8080                                 clid[clidcnt].qval = lyp->lay_clientid.qval;
8081                         clidcnt++;
8082                 }
8083         }
8084         NFSUNLOCKLAYOUT(lhyp);
8085         if (clidcnt == 0) {
8086                 /* None found, so return 0. */
8087                 return (0);
8088         }
8089
8090         /* Get the nfslockfile for this fh. */
8091         NFSLOCKSTATE();
8092         hp = NFSLOCKHASH(&fh);
8093         LIST_FOREACH(lfp, hp, lf_hash) {
8094                 tfhp = &lfp->lf_fh;
8095                 if (NFSVNO_CMPFH(&fh, tfhp))
8096                         break;
8097         }
8098         if (lfp == NULL) {
8099                 /* None found, so return 0. */
8100                 NFSUNLOCKSTATE();
8101                 return (0);
8102         }
8103
8104         /* Now, look for a Write delegation for this clientid. */
8105         LIST_FOREACH(stp, &lfp->lf_deleg, ls_file) {
8106                 if ((stp->ls_flags & NFSLCK_DELEGWRITE) != 0 &&
8107                     nfsrv_fndclid(clid, stp->ls_clp->lc_clientid, clidcnt) != 0)
8108                         break;
8109         }
8110         if (stp != NULL) {
8111                 /* Found one, so return 1. */
8112                 NFSUNLOCKSTATE();
8113                 return (1);
8114         }
8115
8116         /* No Write delegation, so look for an Open with Write_access. */
8117         LIST_FOREACH(stp, &lfp->lf_open, ls_file) {
8118                 KASSERT((stp->ls_flags & NFSLCK_OPEN) != 0,
8119                     ("nfsrv_checkdsattr: Non-open in Open list\n"));
8120                 if ((stp->ls_flags & NFSLCK_WRITEACCESS) != 0 &&
8121                     nfsrv_fndclid(clid, stp->ls_clp->lc_clientid, clidcnt) != 0)
8122                         break;
8123         }
8124         NFSUNLOCKSTATE();
8125         if (stp != NULL)
8126                 return (1);
8127         return (0);
8128 }
8129
8130 /*
8131  * Look for a matching clientid in the vector. Return 1 if one might match.
8132  */
8133 static int
8134 nfsrv_fndclid(nfsquad_t *clidvec, nfsquad_t clid, int clidcnt)
8135 {
8136         int i;
8137
8138         /* If too many for the vector, return 1 since there might be a match. */
8139         if (clidcnt > NFSCLIDVECSIZE)
8140                 return (1);
8141
8142         for (i = 0; i < clidcnt; i++)
8143                 if (clidvec[i].qval == clid.qval)
8144                         return (1);
8145         return (0);
8146 }
8147
8148 /*
8149  * Check the don't list for "vp" and see if issuing an rw layout is allowed.
8150  * Return 1 if issuing an rw layout isn't allowed, 0 otherwise.
8151  */
8152 static int
8153 nfsrv_dontlayout(fhandle_t *fhp)
8154 {
8155         struct nfsdontlist *mrp;
8156         int ret;
8157
8158         if (nfsrv_dontlistlen == 0)
8159                 return (0);
8160         ret = 0;
8161         NFSDDONTLISTLOCK();
8162         LIST_FOREACH(mrp, &nfsrv_dontlisthead, nfsmr_list) {
8163                 if (NFSBCMP(fhp, &mrp->nfsmr_fh, sizeof(*fhp)) == 0 &&
8164                     (mrp->nfsmr_flags & NFSMR_DONTLAYOUT) != 0) {
8165                         ret = 1;
8166                         break;
8167                 }
8168         }
8169         NFSDDONTLISTUNLOCK();
8170         return (ret);
8171 }
8172
8173 #define PNFSDS_COPYSIZ  65536
8174 /*
8175  * Create a new file on a DS and copy the contents of an extant DS file to it.
8176  * This can be used for recovery of a DS file onto a recovered DS.
8177  * The steps are:
8178  * - When called, the MDS file's vnode is locked, blocking LayoutGet operations.
8179  * - Disable issuing of read/write layouts for the file via the nfsdontlist,
8180  *   so that they will be disabled after the MDS file's vnode is unlocked.
8181  * - Set up the nfsrv_recalllist so that recall of read/write layouts can
8182  *   be done.
8183  * - Unlock the MDS file's vnode, so that the client(s) can perform proxied
8184  *   writes, LayoutCommits and LayoutReturns for the file when completing the
8185  *   LayoutReturn requested by the LayoutRecall callback.
8186  * - Issue a LayoutRecall callback for all read/write layouts and wait for
8187  *   them to be returned. (If the LayoutRecall callback replies
8188  *   NFSERR_NOMATCHLAYOUT, they are gone and no LayoutReturn is needed.)
8189  * - Exclusively lock the MDS file's vnode.  This ensures that no proxied
8190  *   writes are in progress or can occur during the DS file copy.
8191  *   It also blocks Setattr operations.
8192  * - Create the file on the recovered mirror.
8193  * - Copy the file from the operational DS.
8194  * - Copy any ACL from the MDS file to the new DS file.
8195  * - Set the modify time of the new DS file to that of the MDS file.
8196  * - Update the extended attribute for the MDS file.
8197  * - Enable issuing of rw layouts by deleting the nfsdontlist entry.
8198  * - The caller will unlock the MDS file's vnode allowing operations
8199  *   to continue normally, since it is now on the mirror again.
8200  */
8201 int
8202 nfsrv_copymr(vnode_t vp, vnode_t fvp, vnode_t dvp, struct nfsdevice *ds,
8203     struct pnfsdsfile *pf, struct pnfsdsfile *wpf, int mirrorcnt,
8204     struct ucred *cred, NFSPROC_T *p)
8205 {
8206         struct nfsdontlist *mrp, *nmrp;
8207         struct nfslayouthash *lhyp;
8208         struct nfslayout *lyp, *nlyp;
8209         struct nfslayouthead thl;
8210         struct mount *mp, *tvmp;
8211         struct acl *aclp;
8212         struct vattr va;
8213         struct timespec mtime;
8214         fhandle_t fh;
8215         vnode_t tvp;
8216         off_t rdpos, wrpos;
8217         ssize_t aresid;
8218         char *dat;
8219         int didprintf, ret, retacl, xfer;
8220
8221         ASSERT_VOP_LOCKED(fvp, "nfsrv_copymr fvp");
8222         ASSERT_VOP_LOCKED(vp, "nfsrv_copymr vp");
8223         /*
8224          * Allocate a nfsdontlist entry and set the NFSMR_DONTLAYOUT flag
8225          * so that no more RW layouts will get issued.
8226          */
8227         ret = nfsvno_getfh(vp, &fh, p);
8228         if (ret != 0) {
8229                 NFSD_DEBUG(4, "nfsrv_copymr: getfh=%d\n", ret);
8230                 return (ret);
8231         }
8232         nmrp = malloc(sizeof(*nmrp), M_NFSDSTATE, M_WAITOK);
8233         nmrp->nfsmr_flags = NFSMR_DONTLAYOUT;
8234         NFSBCOPY(&fh, &nmrp->nfsmr_fh, sizeof(fh));
8235         NFSDDONTLISTLOCK();
8236         LIST_FOREACH(mrp, &nfsrv_dontlisthead, nfsmr_list) {
8237                 if (NFSBCMP(&fh, &mrp->nfsmr_fh, sizeof(fh)) == 0)
8238                         break;
8239         }
8240         if (mrp == NULL) {
8241                 LIST_INSERT_HEAD(&nfsrv_dontlisthead, nmrp, nfsmr_list);
8242                 mrp = nmrp;
8243                 nmrp = NULL;
8244                 nfsrv_dontlistlen++;
8245                 NFSD_DEBUG(4, "nfsrv_copymr: in dontlist\n");
8246         } else {
8247                 NFSDDONTLISTUNLOCK();
8248                 free(nmrp, M_NFSDSTATE);
8249                 NFSD_DEBUG(4, "nfsrv_copymr: dup dontlist\n");
8250                 return (ENXIO);
8251         }
8252         NFSDDONTLISTUNLOCK();
8253
8254         /*
8255          * Search for all RW layouts for this file.  Move them to the
8256          * recall list, so they can be recalled and their return noted.
8257          */
8258         lhyp = NFSLAYOUTHASH(&fh);
8259         NFSDRECALLLOCK();
8260         NFSLOCKLAYOUT(lhyp);
8261         TAILQ_FOREACH_SAFE(lyp, &lhyp->list, lay_list, nlyp) {
8262                 if (NFSBCMP(&lyp->lay_fh, &fh, sizeof(fh)) == 0 &&
8263                     (lyp->lay_flags & NFSLAY_RW) != 0) {
8264                         TAILQ_REMOVE(&lhyp->list, lyp, lay_list);
8265                         TAILQ_INSERT_HEAD(&nfsrv_recalllisthead, lyp, lay_list);
8266                         lyp->lay_trycnt = 0;
8267                 }
8268         }
8269         NFSUNLOCKLAYOUT(lhyp);
8270         NFSDRECALLUNLOCK();
8271
8272         ret = 0;
8273         mp = tvmp = NULL;
8274         didprintf = 0;
8275         TAILQ_INIT(&thl);
8276         /* Unlock the MDS vp, so that a LayoutReturn can be done on it. */
8277         NFSVOPUNLOCK(vp);
8278         /* Now, do a recall for all layouts not yet recalled. */
8279 tryagain:
8280         NFSDRECALLLOCK();
8281         TAILQ_FOREACH(lyp, &nfsrv_recalllisthead, lay_list) {
8282                 if (NFSBCMP(&lyp->lay_fh, &fh, sizeof(fh)) == 0 &&
8283                     (lyp->lay_flags & NFSLAY_RECALL) == 0) {
8284                         lyp->lay_flags |= NFSLAY_RECALL;
8285                         /*
8286                          * The layout stateid.seqid needs to be incremented
8287                          * before doing a LAYOUT_RECALL callback.
8288                          */
8289                         if (++lyp->lay_stateid.seqid == 0)
8290                                 lyp->lay_stateid.seqid = 1;
8291                         NFSDRECALLUNLOCK();
8292                         nfsrv_recalllayout(lyp->lay_clientid, &lyp->lay_stateid,
8293                             &lyp->lay_fh, lyp, 0, lyp->lay_type, p);
8294                         NFSD_DEBUG(4, "nfsrv_copymr: recalled layout\n");
8295                         goto tryagain;
8296                 }
8297         }
8298
8299         /* Now wait for them to be returned. */
8300 tryagain2:
8301         TAILQ_FOREACH(lyp, &nfsrv_recalllisthead, lay_list) {
8302                 if (NFSBCMP(&lyp->lay_fh, &fh, sizeof(fh)) == 0) {
8303                         if ((lyp->lay_flags & NFSLAY_RETURNED) != 0) {
8304                                 TAILQ_REMOVE(&nfsrv_recalllisthead, lyp,
8305                                     lay_list);
8306                                 TAILQ_INSERT_HEAD(&thl, lyp, lay_list);
8307                                 NFSD_DEBUG(4,
8308                                     "nfsrv_copymr: layout returned\n");
8309                         } else {
8310                                 lyp->lay_trycnt++;
8311                                 ret = mtx_sleep(lyp, NFSDRECALLMUTEXPTR,
8312                                     PVFS | PCATCH, "nfsmrl", hz);
8313                                 NFSD_DEBUG(4, "nfsrv_copymr: aft sleep=%d\n",
8314                                     ret);
8315                                 if (ret == EINTR || ret == ERESTART)
8316                                         break;
8317                                 if ((lyp->lay_flags & NFSLAY_RETURNED) == 0) {
8318                                         /*
8319                                          * Give up after 60sec and return
8320                                          * ENXIO, failing the copymr.
8321                                          * This layout will remain on the
8322                                          * recalllist.  It can only be cleared
8323                                          * by restarting the nfsd.
8324                                          * This seems the safe way to handle
8325                                          * it, since it cannot be safely copied
8326                                          * with an outstanding RW layout.
8327                                          */
8328                                         if (lyp->lay_trycnt >= 60) {
8329                                                 ret = ENXIO;
8330                                                 break;
8331                                         }
8332                                         if (didprintf == 0) {
8333                                                 printf("nfsrv_copymr: layout "
8334                                                     "not returned\n");
8335                                                 didprintf = 1;
8336                                         }
8337                                 }
8338                         }
8339                         goto tryagain2;
8340                 }
8341         }
8342         NFSDRECALLUNLOCK();
8343         /* We can now get rid of the layouts that have been returned. */
8344         TAILQ_FOREACH_SAFE(lyp, &thl, lay_list, nlyp)
8345                 nfsrv_freelayout(&thl, lyp);
8346
8347         /*
8348          * Do the vn_start_write() calls here, before the MDS vnode is
8349          * locked and the tvp is created (locked) in the NFS file system
8350          * that dvp is in.
8351          * For tvmp, this probably isn't necessary, since it will be an
8352          * NFS mount and they are not suspendable at this time.
8353          */
8354         if (ret == 0)
8355                 ret = vn_start_write(vp, &mp, V_WAIT | PCATCH);
8356         if (ret == 0) {
8357                 tvmp = dvp->v_mount;
8358                 ret = vn_start_write(NULL, &tvmp, V_WAIT | PCATCH);
8359         }
8360
8361         /*
8362          * LK_EXCLUSIVE lock the MDS vnode, so that any
8363          * proxied writes through the MDS will be blocked until we have
8364          * completed the copy and update of the extended attributes.
8365          * This will also ensure that any attributes and ACL will not be
8366          * changed until the copy is complete.
8367          */
8368         NFSVOPLOCK(vp, LK_EXCLUSIVE | LK_RETRY);
8369         if (ret == 0 && VN_IS_DOOMED(vp)) {
8370                 NFSD_DEBUG(4, "nfsrv_copymr: lk_exclusive doomed\n");
8371                 ret = ESTALE;
8372         }
8373
8374         /* Create the data file on the recovered DS. */
8375         if (ret == 0)
8376                 ret = nfsrv_createdsfile(vp, &fh, pf, dvp, ds, cred, p, &tvp);
8377
8378         /* Copy the DS file, if created successfully. */
8379         if (ret == 0) {
8380                 /*
8381                  * Get any NFSv4 ACL on the MDS file, so that it can be set
8382                  * on the new DS file.
8383                  */
8384                 aclp = acl_alloc(M_WAITOK | M_ZERO);
8385                 retacl = VOP_GETACL(vp, ACL_TYPE_NFS4, aclp, cred, p);
8386                 if (retacl != 0 && retacl != ENOATTR)
8387                         NFSD_DEBUG(1, "nfsrv_copymr: vop_getacl=%d\n", retacl);
8388                 dat = malloc(PNFSDS_COPYSIZ, M_TEMP, M_WAITOK);
8389                 /* Malloc a block of 0s used to check for holes. */
8390                 if (nfsrv_zeropnfsdat == NULL)
8391                         nfsrv_zeropnfsdat = malloc(PNFSDS_COPYSIZ, M_TEMP,
8392                             M_WAITOK | M_ZERO);
8393                 rdpos = wrpos = 0;
8394                 ret = VOP_GETATTR(fvp, &va, cred);
8395                 aresid = 0;
8396                 while (ret == 0 && aresid == 0) {
8397                         ret = vn_rdwr(UIO_READ, fvp, dat, PNFSDS_COPYSIZ,
8398                             rdpos, UIO_SYSSPACE, IO_NODELOCKED, cred, NULL,
8399                             &aresid, p);
8400                         xfer = PNFSDS_COPYSIZ - aresid;
8401                         if (ret == 0 && xfer > 0) {
8402                                 rdpos += xfer;
8403                                 /*
8404                                  * Skip the write for holes, except for the
8405                                  * last block.
8406                                  */
8407                                 if (xfer < PNFSDS_COPYSIZ || rdpos ==
8408                                     va.va_size || NFSBCMP(dat,
8409                                     nfsrv_zeropnfsdat, PNFSDS_COPYSIZ) != 0)
8410                                         ret = vn_rdwr(UIO_WRITE, tvp, dat, xfer,
8411                                             wrpos, UIO_SYSSPACE, IO_NODELOCKED,
8412                                             cred, NULL, NULL, p);
8413                                 if (ret == 0)
8414                                         wrpos += xfer;
8415                         }
8416                 }
8417
8418                 /* If there is an ACL and the copy succeeded, set the ACL. */
8419                 if (ret == 0 && retacl == 0) {
8420                         ret = VOP_SETACL(tvp, ACL_TYPE_NFS4, aclp, cred, p);
8421                         /*
8422                          * Don't consider these as errors, since VOP_GETACL()
8423                          * can return an ACL when they are not actually
8424                          * supported.  For example, for UFS, VOP_GETACL()
8425                          * will return a trivial ACL based on the uid/gid/mode
8426                          * when there is no ACL on the file.
8427                          * This case should be recognized as a trivial ACL
8428                          * by UFS's VOP_SETACL() and succeed, but...
8429                          */
8430                         if (ret == ENOATTR || ret == EOPNOTSUPP || ret == EPERM)
8431                                 ret = 0;
8432                 }
8433
8434                 if (ret == 0)
8435                         ret = VOP_FSYNC(tvp, MNT_WAIT, p);
8436
8437                 /* Set the DS data file's modify time that of the MDS file. */
8438                 if (ret == 0)
8439                         ret = VOP_GETATTR(vp, &va, cred);
8440                 if (ret == 0) {
8441                         mtime = va.va_mtime;
8442                         VATTR_NULL(&va);
8443                         va.va_mtime = mtime;
8444                         ret = VOP_SETATTR(tvp, &va, cred);
8445                 }
8446
8447                 vput(tvp);
8448                 acl_free(aclp);
8449                 free(dat, M_TEMP);
8450         }
8451         if (tvmp != NULL)
8452                 vn_finished_write(tvmp);
8453
8454         /* Update the extended attributes for the newly created DS file. */
8455         if (ret == 0)
8456                 ret = vn_extattr_set(vp, IO_NODELOCKED,
8457                     EXTATTR_NAMESPACE_SYSTEM, "pnfsd.dsfile",
8458                     sizeof(*wpf) * mirrorcnt, (char *)wpf, p);
8459         if (mp != NULL)
8460                 vn_finished_write(mp);
8461
8462         /* Get rid of the dontlist entry, so that Layouts can be issued. */
8463         NFSDDONTLISTLOCK();
8464         LIST_REMOVE(mrp, nfsmr_list);
8465         NFSDDONTLISTUNLOCK();
8466         free(mrp, M_NFSDSTATE);
8467         return (ret);
8468 }
8469
8470 /*
8471  * Create a data storage file on the recovered DS.
8472  */
8473 static int
8474 nfsrv_createdsfile(vnode_t vp, fhandle_t *fhp, struct pnfsdsfile *pf,
8475     vnode_t dvp, struct nfsdevice *ds, struct ucred *cred, NFSPROC_T *p,
8476     vnode_t *tvpp)
8477 {
8478         struct vattr va, nva;
8479         int error;
8480
8481         /* Make data file name based on FH. */
8482         error = VOP_GETATTR(vp, &va, cred);
8483         if (error == 0) {
8484                 /* Set the attributes for "vp" to Setattr the DS vp. */
8485                 VATTR_NULL(&nva);
8486                 nva.va_uid = va.va_uid;
8487                 nva.va_gid = va.va_gid;
8488                 nva.va_mode = va.va_mode;
8489                 nva.va_size = 0;
8490                 VATTR_NULL(&va);
8491                 va.va_type = VREG;
8492                 va.va_mode = nva.va_mode;
8493                 NFSD_DEBUG(4, "nfsrv_dscreatefile: dvp=%p pf=%p\n", dvp, pf);
8494                 error = nfsrv_dscreate(dvp, &va, &nva, fhp, pf, NULL,
8495                     pf->dsf_filename, cred, p, tvpp);
8496         }
8497         return (error);
8498 }
8499
8500 /*
8501  * Look up the MDS file shared locked, and then get the extended attribute
8502  * to find the extant DS file to be copied to the new mirror.
8503  * If successful, *vpp is set to the MDS file's vp and *nvpp is
8504  * set to a DS data file for the MDS file, both exclusively locked.
8505  * The "buf" argument has the pnfsdsfile structure from the MDS file
8506  * in it and buflen is set to its length.
8507  */
8508 int
8509 nfsrv_mdscopymr(char *mdspathp, char *dspathp, char *curdspathp, char *buf,
8510     int *buflenp, char *fname, NFSPROC_T *p, struct vnode **vpp,
8511     struct vnode **nvpp, struct pnfsdsfile **pfp, struct nfsdevice **dsp,
8512     struct nfsdevice **fdsp)
8513 {
8514         struct nameidata nd;
8515         struct vnode *vp, *curvp;
8516         struct pnfsdsfile *pf;
8517         struct nfsmount *nmp, *curnmp;
8518         int dsdir, error, mirrorcnt, ippos;
8519
8520         vp = NULL;
8521         curvp = NULL;
8522         curnmp = NULL;
8523         *dsp = NULL;
8524         *fdsp = NULL;
8525         if (dspathp == NULL && curdspathp != NULL)
8526                 return (EPERM);
8527
8528         /*
8529          * Look up the MDS file shared locked.  The lock will be upgraded
8530          * to an exclusive lock after any rw layouts have been returned.
8531          */
8532         NFSD_DEBUG(4, "mdsopen path=%s\n", mdspathp);
8533         NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
8534             mdspathp, p);
8535         error = namei(&nd);
8536         NFSD_DEBUG(4, "lookup=%d\n", error);
8537         if (error != 0)
8538                 return (error);
8539         if (nd.ni_vp->v_type != VREG) {
8540                 vput(nd.ni_vp);
8541                 NFSD_DEBUG(4, "mdspath not reg\n");
8542                 return (EISDIR);
8543         }
8544         vp = nd.ni_vp;
8545
8546         if (curdspathp != NULL) {
8547                 /*
8548                  * Look up the current DS path and find the nfsdev structure for
8549                  * it.
8550                  */
8551                 NFSD_DEBUG(4, "curmdsdev path=%s\n", curdspathp);
8552                 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF,
8553                     UIO_SYSSPACE, curdspathp, p);
8554                 error = namei(&nd);
8555                 NFSD_DEBUG(4, "ds lookup=%d\n", error);
8556                 if (error != 0) {
8557                         vput(vp);
8558                         return (error);
8559                 }
8560                 if (nd.ni_vp->v_type != VDIR) {
8561                         vput(nd.ni_vp);
8562                         vput(vp);
8563                         NFSD_DEBUG(4, "curdspath not dir\n");
8564                         return (ENOTDIR);
8565                 }
8566                 if (strcmp(nd.ni_vp->v_mount->mnt_vfc->vfc_name, "nfs") != 0) {
8567                         vput(nd.ni_vp);
8568                         vput(vp);
8569                         NFSD_DEBUG(4, "curdspath not an NFS mount\n");
8570                         return (ENXIO);
8571                 }
8572                 curnmp = VFSTONFS(nd.ni_vp->v_mount);
8573
8574                 /* Search the nfsdev list for a match. */
8575                 NFSDDSLOCK();
8576                 *fdsp = nfsv4_findmirror(curnmp);
8577                 NFSDDSUNLOCK();
8578                 if (*fdsp == NULL)
8579                         curnmp = NULL;
8580                 if (curnmp == NULL) {
8581                         vput(nd.ni_vp);
8582                         vput(vp);
8583                         NFSD_DEBUG(4, "mdscopymr: no current ds\n");
8584                         return (ENXIO);
8585                 }
8586                 curvp = nd.ni_vp;
8587         }
8588
8589         if (dspathp != NULL) {
8590                 /* Look up the nfsdev path and find the nfsdev structure. */
8591                 NFSD_DEBUG(4, "mdsdev path=%s\n", dspathp);
8592                 NDINIT(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF,
8593                     UIO_SYSSPACE, dspathp, p);
8594                 error = namei(&nd);
8595                 NFSD_DEBUG(4, "ds lookup=%d\n", error);
8596                 if (error != 0) {
8597                         vput(vp);
8598                         if (curvp != NULL)
8599                                 vput(curvp);
8600                         return (error);
8601                 }
8602                 if (nd.ni_vp->v_type != VDIR || nd.ni_vp == curvp) {
8603                         vput(nd.ni_vp);
8604                         vput(vp);
8605                         if (curvp != NULL)
8606                                 vput(curvp);
8607                         NFSD_DEBUG(4, "dspath not dir\n");
8608                         if (nd.ni_vp == curvp)
8609                                 return (EPERM);
8610                         return (ENOTDIR);
8611                 }
8612                 if (strcmp(nd.ni_vp->v_mount->mnt_vfc->vfc_name, "nfs") != 0) {
8613                         vput(nd.ni_vp);
8614                         vput(vp);
8615                         if (curvp != NULL)
8616                                 vput(curvp);
8617                         NFSD_DEBUG(4, "dspath not an NFS mount\n");
8618                         return (ENXIO);
8619                 }
8620                 nmp = VFSTONFS(nd.ni_vp->v_mount);
8621
8622                 /*
8623                  * Search the nfsdevice list for a match.  If curnmp == NULL,
8624                  * this is a recovery and there must be a mirror.
8625                  */
8626                 NFSDDSLOCK();
8627                 if (curnmp == NULL)
8628                         *dsp = nfsrv_findmirroredds(nmp);
8629                 else
8630                         *dsp = nfsv4_findmirror(nmp);
8631                 NFSDDSUNLOCK();
8632                 if (*dsp == NULL) {
8633                         vput(nd.ni_vp);
8634                         vput(vp);
8635                         if (curvp != NULL)
8636                                 vput(curvp);
8637                         NFSD_DEBUG(4, "mdscopymr: no ds\n");
8638                         return (ENXIO);
8639                 }
8640         } else {
8641                 nd.ni_vp = NULL;
8642                 nmp = NULL;
8643         }
8644
8645         /*
8646          * Get a vp for an available DS data file using the extended
8647          * attribute on the MDS file.
8648          * If there is a valid entry for the new DS in the extended attribute
8649          * on the MDS file (as checked via the nmp argument),
8650          * nfsrv_dsgetsockmnt() returns EEXIST, so no copying will occur.
8651          */
8652         error = nfsrv_dsgetsockmnt(vp, 0, buf, buflenp, &mirrorcnt, p,
8653             NULL, NULL, NULL, fname, nvpp, &nmp, curnmp, &ippos, &dsdir);
8654         if (curvp != NULL)
8655                 vput(curvp);
8656         if (nd.ni_vp == NULL) {
8657                 if (error == 0 && nmp != NULL) {
8658                         /* Search the nfsdev list for a match. */
8659                         NFSDDSLOCK();
8660                         *dsp = nfsrv_findmirroredds(nmp);
8661                         NFSDDSUNLOCK();
8662                 }
8663                 if (error == 0 && (nmp == NULL || *dsp == NULL)) {
8664                         if (nvpp != NULL && *nvpp != NULL) {
8665                                 vput(*nvpp);
8666                                 *nvpp = NULL;
8667                         }
8668                         error = ENXIO;
8669                 }
8670         } else
8671                 vput(nd.ni_vp);
8672
8673         /*
8674          * When dspathp != NULL and curdspathp == NULL, this is a recovery
8675          * and is only allowed if there is a 0.0.0.0 IP address entry.
8676          * When curdspathp != NULL, the ippos will be set to that entry.
8677          */
8678         if (error == 0 && dspathp != NULL && ippos == -1) {
8679                 if (nvpp != NULL && *nvpp != NULL) {
8680                         vput(*nvpp);
8681                         *nvpp = NULL;
8682                 }
8683                 error = ENXIO;
8684         }
8685         if (error == 0) {
8686                 *vpp = vp;
8687
8688                 pf = (struct pnfsdsfile *)buf;
8689                 if (ippos == -1) {
8690                         /* If no zeroip pnfsdsfile, add one. */
8691                         ippos = *buflenp / sizeof(*pf);
8692                         *buflenp += sizeof(*pf);
8693                         pf += ippos;
8694                         pf->dsf_dir = dsdir;
8695                         strlcpy(pf->dsf_filename, fname,
8696                             sizeof(pf->dsf_filename));
8697                 } else
8698                         pf += ippos;
8699                 *pfp = pf;
8700         } else
8701                 vput(vp);
8702         return (error);
8703 }
8704
8705 /*
8706  * Search for a matching pnfsd mirror device structure, base on the nmp arg.
8707  * Return one if found, NULL otherwise.
8708  */
8709 static struct nfsdevice *
8710 nfsrv_findmirroredds(struct nfsmount *nmp)
8711 {
8712         struct nfsdevice *ds, *fndds;
8713         int fndmirror;
8714
8715         mtx_assert(NFSDDSMUTEXPTR, MA_OWNED);
8716         /*
8717          * Search the DS server list for a match with nmp.
8718          * Remove the DS entry if found and there is a mirror.
8719          */
8720         fndds = NULL;
8721         fndmirror = 0;
8722         if (nfsrv_devidcnt == 0)
8723                 return (fndds);
8724         TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
8725                 if (ds->nfsdev_nmp == nmp) {
8726                         NFSD_DEBUG(4, "nfsrv_findmirroredds: fnd main ds\n");
8727                         fndds = ds;
8728                         break;
8729                 }
8730         }
8731         if (fndds == NULL)
8732                 return (fndds);
8733         if (fndds->nfsdev_mdsisset == 0 && nfsrv_faildscnt > 0)
8734                 fndmirror = 1;
8735         else if (fndds->nfsdev_mdsisset != 0) {
8736                 /* For the fsid is set case, search for a mirror. */
8737                 TAILQ_FOREACH(ds, &nfsrv_devidhead, nfsdev_list) {
8738                         if (ds != fndds && ds->nfsdev_nmp != NULL &&
8739                             ds->nfsdev_mdsisset != 0 &&
8740                             fsidcmp(&ds->nfsdev_mdsfsid,
8741                             &fndds->nfsdev_mdsfsid) == 0) {
8742                                 fndmirror = 1;
8743                                 break;
8744                         }
8745                 }
8746         }
8747         if (fndmirror == 0) {
8748                 NFSD_DEBUG(4, "nfsrv_findmirroredds: no mirror for DS\n");
8749                 return (NULL);
8750         }
8751         return (fndds);
8752 }