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