1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 24 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 25 */ 26 27 /* 28 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T. 29 * All Rights Reserved 30 */ 31 32 #include <sys/param.h> 33 #include <sys/types.h> 34 #include <sys/systm.h> 35 #include <sys/cred.h> 36 #include <sys/vfs.h> 37 #include <sys/vfs_opreg.h> 38 #include <sys/vnode.h> 39 #include <sys/pathname.h> 40 #include <sys/sysmacros.h> 41 #include <sys/kmem.h> 42 #include <sys/mkdev.h> 43 #include <sys/mount.h> 44 #include <sys/statvfs.h> 45 #include <sys/errno.h> 46 #include <sys/debug.h> 47 #include <sys/cmn_err.h> 48 #include <sys/utsname.h> 49 #include <sys/bootconf.h> 50 #include <sys/modctl.h> 51 #include <sys/acl.h> 52 #include <sys/flock.h> 53 #include <sys/time.h> 54 #include <sys/disp.h> 55 #include <sys/policy.h> 56 #include <sys/socket.h> 57 #include <sys/netconfig.h> 58 #include <sys/dnlc.h> 59 #include <sys/list.h> 60 #include <sys/mntent.h> 61 #include <sys/tsol/label.h> 62 63 #include <rpc/types.h> 64 #include <rpc/auth.h> 65 #include <rpc/rpcsec_gss.h> 66 #include <rpc/clnt.h> 67 68 #include <nfs/nfs.h> 69 #include <nfs/nfs_clnt.h> 70 #include <nfs/mount.h> 71 #include <nfs/nfs_acl.h> 72 73 #include <fs/fs_subr.h> 74 75 #include <nfs/nfs4.h> 76 #include <nfs/rnode4.h> 77 #include <nfs/nfs4_clnt.h> 78 #include <sys/fs/autofs.h> 79 80 #include <sys/sdt.h> 81 82 83 /* 84 * Arguments passed to thread to free data structures from forced unmount. 85 */ 86 87 typedef struct { 88 vfs_t *fm_vfsp; 89 int fm_flag; 90 cred_t *fm_cr; 91 } freemountargs_t; 92 93 static void async_free_mount(vfs_t *, int, cred_t *); 94 static void nfs4_free_mount(vfs_t *, int, cred_t *); 95 static void nfs4_free_mount_thread(freemountargs_t *); 96 static int nfs4_chkdup_servinfo4(servinfo4_t *, servinfo4_t *); 97 98 /* 99 * From rpcsec module (common/rpcsec). 100 */ 101 extern int sec_clnt_loadinfo(struct sec_data *, struct sec_data **, model_t); 102 extern void sec_clnt_freeinfo(struct sec_data *); 103 104 /* 105 * The order and contents of this structure must be kept in sync with that of 106 * rfsreqcnt_v4_tmpl in nfs_stats.c 107 */ 108 static char *rfsnames_v4[] = { 109 "null", "compound", "reserved", "access", "close", "commit", "create", 110 "delegpurge", "delegreturn", "getattr", "getfh", "link", "lock", 111 "lockt", "locku", "lookup", "lookupp", "nverify", "open", "openattr", 112 "open_confirm", "open_downgrade", "putfh", "putpubfh", "putrootfh", 113 "read", "readdir", "readlink", "remove", "rename", "renew", 114 "restorefh", "savefh", "secinfo", "setattr", "setclientid", 115 "setclientid_confirm", "verify", "write" 116 }; 117 118 /* 119 * nfs4_max_mount_retry is the number of times the client will redrive 120 * a mount compound before giving up and returning failure. The intent 121 * is to redrive mount compounds which fail NFS4ERR_STALE so that 122 * if a component of the server path being mounted goes stale, it can 123 * "recover" by redriving the mount compund (LOOKUP ops). This recovery 124 * code is needed outside of the recovery framework because mount is a 125 * special case. The client doesn't create vnodes/rnodes for components 126 * of the server path being mounted. The recovery code recovers real 127 * client objects, not STALE FHs which map to components of the server 128 * path being mounted. 129 * 130 * We could just fail the mount on the first time, but that would 131 * instantly trigger failover (from nfs4_mount), and the client should 132 * try to re-lookup the STALE FH before doing failover. The easiest 133 * way to "re-lookup" is to simply redrive the mount compound. 134 */ 135 static int nfs4_max_mount_retry = 2; 136 137 /* 138 * nfs4 vfs operations. 139 */ 140 int nfs4_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *); 141 static int nfs4_unmount(vfs_t *, int, cred_t *); 142 static int nfs4_root(vfs_t *, vnode_t **); 143 static int nfs4_statvfs(vfs_t *, struct statvfs64 *); 144 static int nfs4_sync(vfs_t *, short, cred_t *); 145 static int nfs4_vget(vfs_t *, vnode_t **, fid_t *); 146 static int nfs4_mountroot(vfs_t *, whymountroot_t); 147 static void nfs4_freevfs(vfs_t *); 148 149 static int nfs4rootvp(vnode_t **, vfs_t *, struct servinfo4 *, 150 int, cred_t *, zone_t *); 151 152 vfsops_t *nfs4_vfsops; 153 154 int nfs4_vfsinit(void); 155 void nfs4_vfsfini(void); 156 static void nfs4setclientid_init(void); 157 static void nfs4setclientid_fini(void); 158 static void nfs4setclientid_otw(mntinfo4_t *, servinfo4_t *, cred_t *, 159 struct nfs4_server *, nfs4_error_t *, int *); 160 static void destroy_nfs4_server(nfs4_server_t *); 161 static void remove_mi(nfs4_server_t *, mntinfo4_t *); 162 163 extern void nfs4_ephemeral_init(void); 164 extern void nfs4_ephemeral_fini(void); 165 166 /* referral related routines */ 167 static servinfo4_t *copy_svp(servinfo4_t *); 168 static void free_knconf_contents(struct knetconfig *k); 169 static char *extract_referral_point(const char *, int); 170 static void setup_newsvpath(servinfo4_t *, int); 171 static void update_servinfo4(servinfo4_t *, fs_location4 *, 172 struct nfs_fsl_info *, char *, int); 173 174 /* 175 * Initialize the vfs structure 176 */ 177 178 static int nfs4fstyp; 179 180 181 /* 182 * Debug variable to check for rdma based 183 * transport startup and cleanup. Controlled 184 * through /etc/system. Off by default. 185 */ 186 extern int rdma_debug; 187 188 int 189 nfs4init(int fstyp, char *name) 190 { 191 static const fs_operation_def_t nfs4_vfsops_template[] = { 192 VFSNAME_MOUNT, { .vfs_mount = nfs4_mount }, 193 VFSNAME_UNMOUNT, { .vfs_unmount = nfs4_unmount }, 194 VFSNAME_ROOT, { .vfs_root = nfs4_root }, 195 VFSNAME_STATVFS, { .vfs_statvfs = nfs4_statvfs }, 196 VFSNAME_SYNC, { .vfs_sync = nfs4_sync }, 197 VFSNAME_VGET, { .vfs_vget = nfs4_vget }, 198 VFSNAME_MOUNTROOT, { .vfs_mountroot = nfs4_mountroot }, 199 VFSNAME_FREEVFS, { .vfs_freevfs = nfs4_freevfs }, 200 NULL, NULL 201 }; 202 int error; 203 204 nfs4_vfsops = NULL; 205 nfs4_vnodeops = NULL; 206 nfs4_trigger_vnodeops = NULL; 207 208 error = vfs_setfsops(fstyp, nfs4_vfsops_template, &nfs4_vfsops); 209 if (error != 0) { 210 zcmn_err(GLOBAL_ZONEID, CE_WARN, 211 "nfs4init: bad vfs ops template"); 212 goto out; 213 } 214 215 error = vn_make_ops(name, nfs4_vnodeops_template, &nfs4_vnodeops); 216 if (error != 0) { 217 zcmn_err(GLOBAL_ZONEID, CE_WARN, 218 "nfs4init: bad vnode ops template"); 219 goto out; 220 } 221 222 error = vn_make_ops("nfs4_trigger", nfs4_trigger_vnodeops_template, 223 &nfs4_trigger_vnodeops); 224 if (error != 0) { 225 zcmn_err(GLOBAL_ZONEID, CE_WARN, 226 "nfs4init: bad trigger vnode ops template"); 227 goto out; 228 } 229 230 nfs4fstyp = fstyp; 231 (void) nfs4_vfsinit(); 232 (void) nfs4_init_dot_entries(); 233 234 out: 235 if (error) { 236 if (nfs4_trigger_vnodeops != NULL) 237 vn_freevnodeops(nfs4_trigger_vnodeops); 238 239 if (nfs4_vnodeops != NULL) 240 vn_freevnodeops(nfs4_vnodeops); 241 242 (void) vfs_freevfsops_by_type(fstyp); 243 } 244 245 return (error); 246 } 247 248 void 249 nfs4fini(void) 250 { 251 (void) nfs4_destroy_dot_entries(); 252 nfs4_vfsfini(); 253 } 254 255 /* 256 * Create a new sec_data structure to store AUTH_DH related data: 257 * netname, syncaddr, knetconfig. There is no AUTH_F_RPCTIMESYNC 258 * flag set for NFS V4 since we are avoiding to contact the rpcbind 259 * daemon and is using the IP time service (IPPORT_TIMESERVER). 260 * 261 * sec_data can be freed by sec_clnt_freeinfo(). 262 */ 263 static struct sec_data * 264 create_authdh_data(char *netname, int nlen, struct netbuf *syncaddr, 265 struct knetconfig *knconf) 266 { 267 struct sec_data *secdata; 268 dh_k4_clntdata_t *data; 269 char *pf, *p; 270 271 if (syncaddr == NULL || syncaddr->buf == NULL || nlen == 0) 272 return (NULL); 273 274 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 275 secdata->flags = 0; 276 277 data = kmem_alloc(sizeof (*data), KM_SLEEP); 278 279 data->syncaddr.maxlen = syncaddr->maxlen; 280 data->syncaddr.len = syncaddr->len; 281 data->syncaddr.buf = (char *)kmem_alloc(syncaddr->len, KM_SLEEP); 282 bcopy(syncaddr->buf, data->syncaddr.buf, syncaddr->len); 283 284 /* 285 * duplicate the knconf information for the 286 * new opaque data. 287 */ 288 data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP); 289 *data->knconf = *knconf; 290 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 291 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 292 bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE); 293 bcopy(knconf->knc_proto, p, KNC_STRSIZE); 294 data->knconf->knc_protofmly = pf; 295 data->knconf->knc_proto = p; 296 297 /* move server netname to the sec_data structure */ 298 data->netname = kmem_alloc(nlen, KM_SLEEP); 299 bcopy(netname, data->netname, nlen); 300 data->netnamelen = (int)nlen; 301 302 secdata->secmod = AUTH_DH; 303 secdata->rpcflavor = AUTH_DH; 304 secdata->data = (caddr_t)data; 305 306 return (secdata); 307 } 308 309 /* 310 * Returns (deep) copy of sec_data_t. Allocates all memory required; caller 311 * is responsible for freeing. 312 */ 313 sec_data_t * 314 copy_sec_data(sec_data_t *fsecdata) 315 { 316 sec_data_t *tsecdata; 317 318 if (fsecdata == NULL) 319 return (NULL); 320 321 if (fsecdata->rpcflavor == AUTH_DH) { 322 dh_k4_clntdata_t *fdata = (dh_k4_clntdata_t *)fsecdata->data; 323 324 if (fdata == NULL) 325 return (NULL); 326 327 tsecdata = (sec_data_t *)create_authdh_data(fdata->netname, 328 fdata->netnamelen, &fdata->syncaddr, fdata->knconf); 329 330 return (tsecdata); 331 } 332 333 tsecdata = kmem_zalloc(sizeof (sec_data_t), KM_SLEEP); 334 335 tsecdata->secmod = fsecdata->secmod; 336 tsecdata->rpcflavor = fsecdata->rpcflavor; 337 tsecdata->flags = fsecdata->flags; 338 tsecdata->uid = fsecdata->uid; 339 340 if (fsecdata->rpcflavor == RPCSEC_GSS) { 341 gss_clntdata_t *gcd = (gss_clntdata_t *)fsecdata->data; 342 343 tsecdata->data = (caddr_t)copy_sec_data_gss(gcd); 344 } else { 345 tsecdata->data = NULL; 346 } 347 348 return (tsecdata); 349 } 350 351 gss_clntdata_t * 352 copy_sec_data_gss(gss_clntdata_t *fdata) 353 { 354 gss_clntdata_t *tdata; 355 356 if (fdata == NULL) 357 return (NULL); 358 359 tdata = kmem_zalloc(sizeof (gss_clntdata_t), KM_SLEEP); 360 361 tdata->mechanism.length = fdata->mechanism.length; 362 tdata->mechanism.elements = kmem_zalloc(fdata->mechanism.length, 363 KM_SLEEP); 364 bcopy(fdata->mechanism.elements, tdata->mechanism.elements, 365 fdata->mechanism.length); 366 367 tdata->service = fdata->service; 368 369 (void) strcpy(tdata->uname, fdata->uname); 370 (void) strcpy(tdata->inst, fdata->inst); 371 (void) strcpy(tdata->realm, fdata->realm); 372 373 tdata->qop = fdata->qop; 374 375 return (tdata); 376 } 377 378 static int 379 nfs4_chkdup_servinfo4(servinfo4_t *svp_head, servinfo4_t *svp) 380 { 381 servinfo4_t *si; 382 383 /* 384 * Iterate over the servinfo4 list to make sure 385 * we do not have a duplicate. Skip any servinfo4 386 * that has been marked "NOT IN USE" 387 */ 388 for (si = svp_head; si; si = si->sv_next) { 389 (void) nfs_rw_enter_sig(&si->sv_lock, RW_READER, 0); 390 if (si->sv_flags & SV4_NOTINUSE) { 391 nfs_rw_exit(&si->sv_lock); 392 continue; 393 } 394 nfs_rw_exit(&si->sv_lock); 395 if (si == svp) 396 continue; 397 if (si->sv_addr.len == svp->sv_addr.len && 398 strcmp(si->sv_knconf->knc_protofmly, 399 svp->sv_knconf->knc_protofmly) == 0 && 400 bcmp(si->sv_addr.buf, svp->sv_addr.buf, 401 si->sv_addr.len) == 0) { 402 /* it's a duplicate */ 403 return (1); 404 } 405 } 406 /* it's not a duplicate */ 407 return (0); 408 } 409 410 void 411 nfs4_free_args(struct nfs_args *nargs) 412 { 413 if (nargs->knconf) { 414 if (nargs->knconf->knc_protofmly) 415 kmem_free(nargs->knconf->knc_protofmly, 416 KNC_STRSIZE); 417 if (nargs->knconf->knc_proto) 418 kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE); 419 kmem_free(nargs->knconf, sizeof (*nargs->knconf)); 420 nargs->knconf = NULL; 421 } 422 423 if (nargs->fh) { 424 kmem_free(nargs->fh, strlen(nargs->fh) + 1); 425 nargs->fh = NULL; 426 } 427 428 if (nargs->hostname) { 429 kmem_free(nargs->hostname, strlen(nargs->hostname) + 1); 430 nargs->hostname = NULL; 431 } 432 433 if (nargs->addr) { 434 if (nargs->addr->buf) { 435 ASSERT(nargs->addr->len); 436 kmem_free(nargs->addr->buf, nargs->addr->len); 437 } 438 kmem_free(nargs->addr, sizeof (struct netbuf)); 439 nargs->addr = NULL; 440 } 441 442 if (nargs->syncaddr) { 443 ASSERT(nargs->syncaddr->len); 444 if (nargs->syncaddr->buf) { 445 ASSERT(nargs->syncaddr->len); 446 kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len); 447 } 448 kmem_free(nargs->syncaddr, sizeof (struct netbuf)); 449 nargs->syncaddr = NULL; 450 } 451 452 if (nargs->netname) { 453 kmem_free(nargs->netname, strlen(nargs->netname) + 1); 454 nargs->netname = NULL; 455 } 456 457 if (nargs->nfs_ext_u.nfs_extA.secdata) { 458 sec_clnt_freeinfo( 459 nargs->nfs_ext_u.nfs_extA.secdata); 460 nargs->nfs_ext_u.nfs_extA.secdata = NULL; 461 } 462 } 463 464 465 int 466 nfs4_copyin(char *data, int datalen, struct nfs_args *nargs) 467 { 468 469 int error; 470 size_t hlen; /* length of hostname */ 471 size_t nlen; /* length of netname */ 472 char netname[MAXNETNAMELEN+1]; /* server's netname */ 473 struct netbuf addr; /* server's address */ 474 struct netbuf syncaddr; /* AUTH_DES time sync addr */ 475 struct knetconfig *knconf; /* transport structure */ 476 struct sec_data *secdata = NULL; /* security data */ 477 STRUCT_DECL(nfs_args, args); /* nfs mount arguments */ 478 STRUCT_DECL(knetconfig, knconf_tmp); 479 STRUCT_DECL(netbuf, addr_tmp); 480 int flags; 481 char *p, *pf; 482 struct pathname pn; 483 char *userbufptr; 484 485 486 bzero(nargs, sizeof (*nargs)); 487 488 STRUCT_INIT(args, get_udatamodel()); 489 bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE)); 490 if (copyin(data, STRUCT_BUF(args), MIN(datalen, 491 STRUCT_SIZE(args)))) 492 return (EFAULT); 493 494 nargs->wsize = STRUCT_FGET(args, wsize); 495 nargs->rsize = STRUCT_FGET(args, rsize); 496 nargs->timeo = STRUCT_FGET(args, timeo); 497 nargs->retrans = STRUCT_FGET(args, retrans); 498 nargs->acregmin = STRUCT_FGET(args, acregmin); 499 nargs->acregmax = STRUCT_FGET(args, acregmax); 500 nargs->acdirmin = STRUCT_FGET(args, acdirmin); 501 nargs->acdirmax = STRUCT_FGET(args, acdirmax); 502 503 flags = STRUCT_FGET(args, flags); 504 nargs->flags = flags; 505 506 addr.buf = NULL; 507 syncaddr.buf = NULL; 508 509 510 /* 511 * Allocate space for a knetconfig structure and 512 * its strings and copy in from user-land. 513 */ 514 knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP); 515 STRUCT_INIT(knconf_tmp, get_udatamodel()); 516 if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp), 517 STRUCT_SIZE(knconf_tmp))) { 518 kmem_free(knconf, sizeof (*knconf)); 519 return (EFAULT); 520 } 521 522 knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics); 523 knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly); 524 knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto); 525 if (get_udatamodel() != DATAMODEL_LP64) { 526 knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev)); 527 } else { 528 knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev); 529 } 530 531 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 532 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 533 error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL); 534 if (error) { 535 kmem_free(pf, KNC_STRSIZE); 536 kmem_free(p, KNC_STRSIZE); 537 kmem_free(knconf, sizeof (*knconf)); 538 return (error); 539 } 540 541 error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL); 542 if (error) { 543 kmem_free(pf, KNC_STRSIZE); 544 kmem_free(p, KNC_STRSIZE); 545 kmem_free(knconf, sizeof (*knconf)); 546 return (error); 547 } 548 549 550 knconf->knc_protofmly = pf; 551 knconf->knc_proto = p; 552 553 nargs->knconf = knconf; 554 555 /* 556 * Get server address 557 */ 558 STRUCT_INIT(addr_tmp, get_udatamodel()); 559 if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp), 560 STRUCT_SIZE(addr_tmp))) { 561 error = EFAULT; 562 goto errout; 563 } 564 565 nargs->addr = kmem_zalloc(sizeof (struct netbuf), KM_SLEEP); 566 userbufptr = STRUCT_FGETP(addr_tmp, buf); 567 addr.len = STRUCT_FGET(addr_tmp, len); 568 addr.buf = kmem_alloc(addr.len, KM_SLEEP); 569 addr.maxlen = addr.len; 570 if (copyin(userbufptr, addr.buf, addr.len)) { 571 kmem_free(addr.buf, addr.len); 572 error = EFAULT; 573 goto errout; 574 } 575 bcopy(&addr, nargs->addr, sizeof (struct netbuf)); 576 577 /* 578 * Get the root fhandle 579 */ 580 error = pn_get(STRUCT_FGETP(args, fh), UIO_USERSPACE, &pn); 581 if (error) 582 goto errout; 583 584 /* Volatile fh: keep server paths, so use actual-size strings */ 585 nargs->fh = kmem_alloc(pn.pn_pathlen + 1, KM_SLEEP); 586 bcopy(pn.pn_path, nargs->fh, pn.pn_pathlen); 587 nargs->fh[pn.pn_pathlen] = '\0'; 588 pn_free(&pn); 589 590 591 /* 592 * Get server's hostname 593 */ 594 if (flags & NFSMNT_HOSTNAME) { 595 error = copyinstr(STRUCT_FGETP(args, hostname), 596 netname, sizeof (netname), &hlen); 597 if (error) 598 goto errout; 599 nargs->hostname = kmem_zalloc(hlen, KM_SLEEP); 600 (void) strcpy(nargs->hostname, netname); 601 602 } else { 603 nargs->hostname = NULL; 604 } 605 606 607 /* 608 * If there are syncaddr and netname data, load them in. This is 609 * to support data needed for NFSV4 when AUTH_DH is the negotiated 610 * flavor via SECINFO. (instead of using MOUNT protocol in V3). 611 */ 612 netname[0] = '\0'; 613 if (flags & NFSMNT_SECURE) { 614 615 /* get syncaddr */ 616 STRUCT_INIT(addr_tmp, get_udatamodel()); 617 if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp), 618 STRUCT_SIZE(addr_tmp))) { 619 error = EINVAL; 620 goto errout; 621 } 622 userbufptr = STRUCT_FGETP(addr_tmp, buf); 623 syncaddr.len = STRUCT_FGET(addr_tmp, len); 624 syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP); 625 syncaddr.maxlen = syncaddr.len; 626 if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) { 627 kmem_free(syncaddr.buf, syncaddr.len); 628 error = EFAULT; 629 goto errout; 630 } 631 632 nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP); 633 bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf)); 634 635 /* get server's netname */ 636 if (copyinstr(STRUCT_FGETP(args, netname), netname, 637 sizeof (netname), &nlen)) { 638 error = EFAULT; 639 goto errout; 640 } 641 642 netname[nlen] = '\0'; 643 nargs->netname = kmem_zalloc(nlen, KM_SLEEP); 644 (void) strcpy(nargs->netname, netname); 645 } 646 647 /* 648 * Get the extention data which has the security data structure. 649 * This includes data for AUTH_SYS as well. 650 */ 651 if (flags & NFSMNT_NEWARGS) { 652 nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext); 653 if (nargs->nfs_args_ext == NFS_ARGS_EXTA || 654 nargs->nfs_args_ext == NFS_ARGS_EXTB) { 655 /* 656 * Indicating the application is using the new 657 * sec_data structure to pass in the security 658 * data. 659 */ 660 if (STRUCT_FGETP(args, 661 nfs_ext_u.nfs_extA.secdata) != NULL) { 662 error = sec_clnt_loadinfo( 663 (struct sec_data *)STRUCT_FGETP(args, 664 nfs_ext_u.nfs_extA.secdata), 665 &secdata, get_udatamodel()); 666 } 667 nargs->nfs_ext_u.nfs_extA.secdata = secdata; 668 } 669 } 670 671 if (error) 672 goto errout; 673 674 /* 675 * Failover support: 676 * 677 * We may have a linked list of nfs_args structures, 678 * which means the user is looking for failover. If 679 * the mount is either not "read-only" or "soft", 680 * we want to bail out with EINVAL. 681 */ 682 if (nargs->nfs_args_ext == NFS_ARGS_EXTB) 683 nargs->nfs_ext_u.nfs_extB.next = 684 STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next); 685 686 errout: 687 if (error) 688 nfs4_free_args(nargs); 689 690 return (error); 691 } 692 693 694 /* 695 * nfs mount vfsop 696 * Set up mount info record and attach it to vfs struct. 697 */ 698 int 699 nfs4_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 700 { 701 char *data = uap->dataptr; 702 int error; 703 vnode_t *rtvp; /* the server's root */ 704 mntinfo4_t *mi; /* mount info, pointed at by vfs */ 705 struct knetconfig *rdma_knconf; /* rdma transport structure */ 706 rnode4_t *rp; 707 struct servinfo4 *svp; /* nfs server info */ 708 struct servinfo4 *svp_tail = NULL; /* previous nfs server info */ 709 struct servinfo4 *svp_head; /* first nfs server info */ 710 struct servinfo4 *svp_2ndlast; /* 2nd last in server info list */ 711 struct sec_data *secdata; /* security data */ 712 struct nfs_args *args = NULL; 713 int flags, addr_type, removed; 714 zone_t *zone = nfs_zone(); 715 nfs4_error_t n4e; 716 zone_t *mntzone = NULL; 717 718 if (secpolicy_fs_mount(cr, mvp, vfsp) != 0) 719 return (EPERM); 720 if (mvp->v_type != VDIR) 721 return (ENOTDIR); 722 723 /* 724 * get arguments 725 * 726 * nfs_args is now versioned and is extensible, so 727 * uap->datalen might be different from sizeof (args) 728 * in a compatible situation. 729 */ 730 more: 731 if (!(uap->flags & MS_SYSSPACE)) { 732 if (args == NULL) 733 args = kmem_zalloc(sizeof (struct nfs_args), KM_SLEEP); 734 else 735 nfs4_free_args(args); 736 error = nfs4_copyin(data, uap->datalen, args); 737 if (error) { 738 if (args) { 739 kmem_free(args, sizeof (*args)); 740 } 741 return (error); 742 } 743 } else { 744 args = (struct nfs_args *)data; 745 } 746 747 flags = args->flags; 748 749 /* 750 * If the request changes the locking type, disallow the remount, 751 * because it's questionable whether we can transfer the 752 * locking state correctly. 753 */ 754 if (uap->flags & MS_REMOUNT) { 755 if (!(uap->flags & MS_SYSSPACE)) { 756 nfs4_free_args(args); 757 kmem_free(args, sizeof (*args)); 758 } 759 if ((mi = VFTOMI4(vfsp)) != NULL) { 760 uint_t new_mi_llock; 761 uint_t old_mi_llock; 762 new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0; 763 old_mi_llock = (mi->mi_flags & MI4_LLOCK) ? 1 : 0; 764 if (old_mi_llock != new_mi_llock) 765 return (EBUSY); 766 } 767 return (0); 768 } 769 770 /* 771 * For ephemeral mount trigger stub vnodes, we have two problems 772 * to solve: racing threads will likely fail the v_count check, and 773 * we want only one to proceed with the mount. 774 * 775 * For stubs, if the mount has already occurred (via a racing thread), 776 * just return success. If not, skip the v_count check and proceed. 777 * Note that we are already serialised at this point. 778 */ 779 mutex_enter(&mvp->v_lock); 780 if (vn_matchops(mvp, nfs4_trigger_vnodeops)) { 781 /* mntpt is a v4 stub vnode */ 782 ASSERT(RP_ISSTUB(VTOR4(mvp))); 783 ASSERT(!(uap->flags & MS_OVERLAY)); 784 ASSERT(!(mvp->v_flag & VROOT)); 785 if (vn_mountedvfs(mvp) != NULL) { 786 /* ephemeral mount has already occurred */ 787 ASSERT(uap->flags & MS_SYSSPACE); 788 mutex_exit(&mvp->v_lock); 789 return (0); 790 } 791 } else { 792 /* mntpt is a non-v4 or v4 non-stub vnode */ 793 if (!(uap->flags & MS_OVERLAY) && 794 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 795 mutex_exit(&mvp->v_lock); 796 if (!(uap->flags & MS_SYSSPACE)) { 797 nfs4_free_args(args); 798 kmem_free(args, sizeof (*args)); 799 } 800 return (EBUSY); 801 } 802 } 803 mutex_exit(&mvp->v_lock); 804 805 /* make sure things are zeroed for errout: */ 806 rtvp = NULL; 807 mi = NULL; 808 secdata = NULL; 809 810 /* 811 * A valid knetconfig structure is required. 812 */ 813 if (!(flags & NFSMNT_KNCONF) || 814 args->knconf == NULL || args->knconf->knc_protofmly == NULL || 815 args->knconf->knc_proto == NULL || 816 (strcmp(args->knconf->knc_proto, NC_UDP) == 0)) { 817 if (!(uap->flags & MS_SYSSPACE)) { 818 nfs4_free_args(args); 819 kmem_free(args, sizeof (*args)); 820 } 821 return (EINVAL); 822 } 823 824 if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) || 825 (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) { 826 if (!(uap->flags & MS_SYSSPACE)) { 827 nfs4_free_args(args); 828 kmem_free(args, sizeof (*args)); 829 } 830 return (EINVAL); 831 } 832 833 /* 834 * Allocate a servinfo4 struct. 835 */ 836 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP); 837 nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL); 838 if (svp_tail) { 839 svp_2ndlast = svp_tail; 840 svp_tail->sv_next = svp; 841 } else { 842 svp_head = svp; 843 svp_2ndlast = svp; 844 } 845 846 svp_tail = svp; 847 svp->sv_knconf = args->knconf; 848 args->knconf = NULL; 849 850 /* 851 * Get server address 852 */ 853 if (args->addr == NULL || args->addr->buf == NULL) { 854 error = EINVAL; 855 goto errout; 856 } 857 858 svp->sv_addr.maxlen = args->addr->maxlen; 859 svp->sv_addr.len = args->addr->len; 860 svp->sv_addr.buf = args->addr->buf; 861 args->addr->buf = NULL; 862 863 /* 864 * Get the root fhandle 865 */ 866 if (args->fh == NULL || (strlen(args->fh) >= MAXPATHLEN)) { 867 error = EINVAL; 868 goto errout; 869 } 870 871 svp->sv_path = args->fh; 872 svp->sv_pathlen = strlen(args->fh) + 1; 873 args->fh = NULL; 874 875 /* 876 * Get server's hostname 877 */ 878 if (flags & NFSMNT_HOSTNAME) { 879 if (args->hostname == NULL || (strlen(args->hostname) > 880 MAXNETNAMELEN)) { 881 error = EINVAL; 882 goto errout; 883 } 884 svp->sv_hostnamelen = strlen(args->hostname) + 1; 885 svp->sv_hostname = args->hostname; 886 args->hostname = NULL; 887 } else { 888 char *p = "unknown-host"; 889 svp->sv_hostnamelen = strlen(p) + 1; 890 svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP); 891 (void) strcpy(svp->sv_hostname, p); 892 } 893 894 /* 895 * RDMA MOUNT SUPPORT FOR NFS v4. 896 * Establish, is it possible to use RDMA, if so overload the 897 * knconf with rdma specific knconf and free the orignal knconf. 898 */ 899 if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) { 900 /* 901 * Determine the addr type for RDMA, IPv4 or v6. 902 */ 903 if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0) 904 addr_type = AF_INET; 905 else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0) 906 addr_type = AF_INET6; 907 908 if (rdma_reachable(addr_type, &svp->sv_addr, 909 &rdma_knconf) == 0) { 910 /* 911 * If successful, hijack the orignal knconf and 912 * replace with the new one, depending on the flags. 913 */ 914 svp->sv_origknconf = svp->sv_knconf; 915 svp->sv_knconf = rdma_knconf; 916 } else { 917 if (flags & NFSMNT_TRYRDMA) { 918 #ifdef DEBUG 919 if (rdma_debug) 920 zcmn_err(getzoneid(), CE_WARN, 921 "no RDMA onboard, revert\n"); 922 #endif 923 } 924 925 if (flags & NFSMNT_DORDMA) { 926 /* 927 * If proto=rdma is specified and no RDMA 928 * path to this server is avialable then 929 * ditch this server. 930 * This is not included in the mountable 931 * server list or the replica list. 932 * Check if more servers are specified; 933 * Failover case, otherwise bail out of mount. 934 */ 935 if (args->nfs_args_ext == NFS_ARGS_EXTB && 936 args->nfs_ext_u.nfs_extB.next != NULL) { 937 data = (char *) 938 args->nfs_ext_u.nfs_extB.next; 939 if (uap->flags & MS_RDONLY && 940 !(flags & NFSMNT_SOFT)) { 941 if (svp_head->sv_next == NULL) { 942 svp_tail = NULL; 943 svp_2ndlast = NULL; 944 sv4_free(svp_head); 945 goto more; 946 } else { 947 svp_tail = svp_2ndlast; 948 svp_2ndlast->sv_next = 949 NULL; 950 sv4_free(svp); 951 goto more; 952 } 953 } 954 } else { 955 /* 956 * This is the last server specified 957 * in the nfs_args list passed down 958 * and its not rdma capable. 959 */ 960 if (svp_head->sv_next == NULL) { 961 /* 962 * Is this the only one 963 */ 964 error = EINVAL; 965 #ifdef DEBUG 966 if (rdma_debug) 967 zcmn_err(getzoneid(), 968 CE_WARN, 969 "No RDMA srv"); 970 #endif 971 goto errout; 972 } else { 973 /* 974 * There is list, since some 975 * servers specified before 976 * this passed all requirements 977 */ 978 svp_tail = svp_2ndlast; 979 svp_2ndlast->sv_next = NULL; 980 sv4_free(svp); 981 goto proceed; 982 } 983 } 984 } 985 } 986 } 987 988 /* 989 * If there are syncaddr and netname data, load them in. This is 990 * to support data needed for NFSV4 when AUTH_DH is the negotiated 991 * flavor via SECINFO. (instead of using MOUNT protocol in V3). 992 */ 993 if (args->flags & NFSMNT_SECURE) { 994 svp->sv_dhsec = create_authdh_data(args->netname, 995 strlen(args->netname), 996 args->syncaddr, svp->sv_knconf); 997 } 998 999 /* 1000 * Get the extention data which has the security data structure. 1001 * This includes data for AUTH_SYS as well. 1002 */ 1003 if (flags & NFSMNT_NEWARGS) { 1004 switch (args->nfs_args_ext) { 1005 case NFS_ARGS_EXTA: 1006 case NFS_ARGS_EXTB: 1007 /* 1008 * Indicating the application is using the new 1009 * sec_data structure to pass in the security 1010 * data. 1011 */ 1012 secdata = args->nfs_ext_u.nfs_extA.secdata; 1013 if (secdata == NULL) { 1014 error = EINVAL; 1015 } else if (uap->flags & MS_SYSSPACE) { 1016 /* 1017 * Need to validate the flavor here if 1018 * sysspace, userspace was already 1019 * validate from the nfs_copyin function. 1020 */ 1021 switch (secdata->rpcflavor) { 1022 case AUTH_NONE: 1023 case AUTH_UNIX: 1024 case AUTH_LOOPBACK: 1025 case AUTH_DES: 1026 case RPCSEC_GSS: 1027 break; 1028 default: 1029 error = EINVAL; 1030 goto errout; 1031 } 1032 } 1033 args->nfs_ext_u.nfs_extA.secdata = NULL; 1034 break; 1035 1036 default: 1037 error = EINVAL; 1038 break; 1039 } 1040 1041 } else if (flags & NFSMNT_SECURE) { 1042 /* 1043 * NFSMNT_SECURE is deprecated but we keep it 1044 * to support the rogue user-generated application 1045 * that may use this undocumented interface to do 1046 * AUTH_DH security, e.g. our own rexd. 1047 * 1048 * Also note that NFSMNT_SECURE is used for passing 1049 * AUTH_DH info to be used in negotiation. 1050 */ 1051 secdata = create_authdh_data(args->netname, 1052 strlen(args->netname), args->syncaddr, svp->sv_knconf); 1053 1054 } else { 1055 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 1056 secdata->secmod = secdata->rpcflavor = AUTH_SYS; 1057 secdata->data = NULL; 1058 } 1059 1060 svp->sv_secdata = secdata; 1061 1062 /* 1063 * User does not explictly specify a flavor, and a user 1064 * defined default flavor is passed down. 1065 */ 1066 if (flags & NFSMNT_SECDEFAULT) { 1067 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1068 svp->sv_flags |= SV4_TRYSECDEFAULT; 1069 nfs_rw_exit(&svp->sv_lock); 1070 } 1071 1072 /* 1073 * Failover support: 1074 * 1075 * We may have a linked list of nfs_args structures, 1076 * which means the user is looking for failover. If 1077 * the mount is either not "read-only" or "soft", 1078 * we want to bail out with EINVAL. 1079 */ 1080 if (args->nfs_args_ext == NFS_ARGS_EXTB && 1081 args->nfs_ext_u.nfs_extB.next != NULL) { 1082 if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) { 1083 data = (char *)args->nfs_ext_u.nfs_extB.next; 1084 goto more; 1085 } 1086 error = EINVAL; 1087 goto errout; 1088 } 1089 1090 /* 1091 * Determine the zone we're being mounted into. 1092 */ 1093 zone_hold(mntzone = zone); /* start with this assumption */ 1094 if (getzoneid() == GLOBAL_ZONEID) { 1095 zone_rele(mntzone); 1096 mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 1097 ASSERT(mntzone != NULL); 1098 if (mntzone != zone) { 1099 error = EBUSY; 1100 goto errout; 1101 } 1102 } 1103 1104 if (is_system_labeled()) { 1105 error = nfs_mount_label_policy(vfsp, &svp->sv_addr, 1106 svp->sv_knconf, cr); 1107 1108 if (error > 0) 1109 goto errout; 1110 1111 if (error == -1) { 1112 /* change mount to read-only to prevent write-down */ 1113 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 1114 } 1115 } 1116 1117 /* 1118 * Stop the mount from going any further if the zone is going away. 1119 */ 1120 if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) { 1121 error = EBUSY; 1122 goto errout; 1123 } 1124 1125 /* 1126 * Get root vnode. 1127 */ 1128 proceed: 1129 error = nfs4rootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone); 1130 if (error) { 1131 /* if nfs4rootvp failed, it will free svp_head */ 1132 svp_head = NULL; 1133 goto errout; 1134 } 1135 1136 mi = VTOMI4(rtvp); 1137 1138 /* 1139 * Send client id to the server, if necessary 1140 */ 1141 nfs4_error_zinit(&n4e); 1142 nfs4setclientid(mi, cr, FALSE, &n4e); 1143 1144 error = n4e.error; 1145 1146 if (error) 1147 goto errout; 1148 1149 /* 1150 * Set option fields in the mount info record 1151 */ 1152 1153 if (svp_head->sv_next) { 1154 mutex_enter(&mi->mi_lock); 1155 mi->mi_flags |= MI4_LLOCK; 1156 mutex_exit(&mi->mi_lock); 1157 } 1158 error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, args); 1159 if (error) 1160 goto errout; 1161 1162 /* 1163 * Time to tie in the mirror mount info at last! 1164 */ 1165 if (flags & NFSMNT_EPHEMERAL) 1166 error = nfs4_record_ephemeral_mount(mi, mvp); 1167 1168 errout: 1169 if (error) { 1170 if (rtvp != NULL) { 1171 rp = VTOR4(rtvp); 1172 if (rp->r_flags & R4HASHED) 1173 rp4_rmhash(rp); 1174 } 1175 if (mi != NULL) { 1176 nfs4_async_stop(vfsp); 1177 nfs4_async_manager_stop(vfsp); 1178 nfs4_remove_mi_from_server(mi, NULL); 1179 if (rtvp != NULL) 1180 VN_RELE(rtvp); 1181 if (mntzone != NULL) 1182 zone_rele(mntzone); 1183 /* need to remove it from the zone */ 1184 removed = nfs4_mi_zonelist_remove(mi); 1185 if (removed) 1186 zone_rele_ref(&mi->mi_zone_ref, 1187 ZONE_REF_NFSV4); 1188 MI4_RELE(mi); 1189 if (!(uap->flags & MS_SYSSPACE) && args) { 1190 nfs4_free_args(args); 1191 kmem_free(args, sizeof (*args)); 1192 } 1193 return (error); 1194 } 1195 if (svp_head) 1196 sv4_free(svp_head); 1197 } 1198 1199 if (!(uap->flags & MS_SYSSPACE) && args) { 1200 nfs4_free_args(args); 1201 kmem_free(args, sizeof (*args)); 1202 } 1203 if (rtvp != NULL) 1204 VN_RELE(rtvp); 1205 1206 if (mntzone != NULL) 1207 zone_rele(mntzone); 1208 1209 return (error); 1210 } 1211 1212 #ifdef DEBUG 1213 #define VERS_MSG "NFS4 server " 1214 #else 1215 #define VERS_MSG "NFS server " 1216 #endif 1217 1218 #define READ_MSG \ 1219 VERS_MSG "%s returned 0 for read transfer size" 1220 #define WRITE_MSG \ 1221 VERS_MSG "%s returned 0 for write transfer size" 1222 #define SIZE_MSG \ 1223 VERS_MSG "%s returned 0 for maximum file size" 1224 1225 /* 1226 * Get the symbolic link text from the server for a given filehandle 1227 * of that symlink. 1228 * 1229 * (get symlink text) PUTFH READLINK 1230 */ 1231 static int 1232 getlinktext_otw(mntinfo4_t *mi, nfs_fh4 *fh, char **linktextp, cred_t *cr, 1233 int flags) 1234 { 1235 COMPOUND4args_clnt args; 1236 COMPOUND4res_clnt res; 1237 int doqueue; 1238 nfs_argop4 argop[2]; 1239 nfs_resop4 *resop; 1240 READLINK4res *lr_res; 1241 uint_t len; 1242 bool_t needrecov = FALSE; 1243 nfs4_recov_state_t recov_state; 1244 nfs4_sharedfh_t *sfh; 1245 nfs4_error_t e; 1246 int num_retry = nfs4_max_mount_retry; 1247 int recovery = !(flags & NFS4_GETFH_NEEDSOP); 1248 1249 sfh = sfh4_get(fh, mi); 1250 recov_state.rs_flags = 0; 1251 recov_state.rs_num_retry_despite_err = 0; 1252 1253 recov_retry: 1254 nfs4_error_zinit(&e); 1255 1256 args.array_len = 2; 1257 args.array = argop; 1258 args.ctag = TAG_GET_SYMLINK; 1259 1260 if (! recovery) { 1261 e.error = nfs4_start_op(mi, NULL, NULL, &recov_state); 1262 if (e.error) { 1263 sfh4_rele(&sfh); 1264 return (e.error); 1265 } 1266 } 1267 1268 /* 0. putfh symlink fh */ 1269 argop[0].argop = OP_CPUTFH; 1270 argop[0].nfs_argop4_u.opcputfh.sfh = sfh; 1271 1272 /* 1. readlink */ 1273 argop[1].argop = OP_READLINK; 1274 1275 doqueue = 1; 1276 1277 rfs4call(mi, &args, &res, cr, &doqueue, 0, &e); 1278 1279 needrecov = nfs4_needs_recovery(&e, FALSE, mi->mi_vfsp); 1280 1281 if (needrecov && !recovery && num_retry-- > 0) { 1282 1283 NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, 1284 "getlinktext_otw: initiating recovery\n")); 1285 1286 if (nfs4_start_recovery(&e, mi, NULL, NULL, NULL, NULL, 1287 OP_READLINK, NULL, NULL, NULL) == FALSE) { 1288 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1289 if (!e.error) 1290 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1291 goto recov_retry; 1292 } 1293 } 1294 1295 /* 1296 * If non-NFS4 pcol error and/or we weren't able to recover. 1297 */ 1298 if (e.error != 0) { 1299 if (! recovery) 1300 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1301 sfh4_rele(&sfh); 1302 return (e.error); 1303 } 1304 1305 if (res.status) { 1306 e.error = geterrno4(res.status); 1307 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1308 if (! recovery) 1309 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1310 sfh4_rele(&sfh); 1311 return (e.error); 1312 } 1313 1314 /* res.status == NFS4_OK */ 1315 ASSERT(res.status == NFS4_OK); 1316 1317 resop = &res.array[1]; /* readlink res */ 1318 lr_res = &resop->nfs_resop4_u.opreadlink; 1319 1320 /* treat symlink name as data */ 1321 *linktextp = utf8_to_str((utf8string *)&lr_res->link, &len, NULL); 1322 1323 if (! recovery) 1324 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1325 sfh4_rele(&sfh); 1326 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1327 return (0); 1328 } 1329 1330 /* 1331 * Skip over consecutive slashes and "/./" in a pathname. 1332 */ 1333 void 1334 pathname_skipslashdot(struct pathname *pnp) 1335 { 1336 char *c1, *c2; 1337 1338 while (pnp->pn_pathlen > 0 && *pnp->pn_path == '/') { 1339 1340 c1 = pnp->pn_path + 1; 1341 c2 = pnp->pn_path + 2; 1342 1343 if (*c1 == '.' && (*c2 == '/' || *c2 == '\0')) { 1344 pnp->pn_path = pnp->pn_path + 2; /* skip "/." */ 1345 pnp->pn_pathlen = pnp->pn_pathlen - 2; 1346 } else { 1347 pnp->pn_path++; 1348 pnp->pn_pathlen--; 1349 } 1350 } 1351 } 1352 1353 /* 1354 * Resolve a symbolic link path. The symlink is in the nth component of 1355 * svp->sv_path and has an nfs4 file handle "fh". 1356 * Upon return, the sv_path will point to the new path that has the nth 1357 * component resolved to its symlink text. 1358 */ 1359 int 1360 resolve_sympath(mntinfo4_t *mi, servinfo4_t *svp, int nth, nfs_fh4 *fh, 1361 cred_t *cr, int flags) 1362 { 1363 char *oldpath; 1364 char *symlink, *newpath; 1365 struct pathname oldpn, newpn; 1366 char component[MAXNAMELEN]; 1367 int i, addlen, error = 0; 1368 int oldpathlen; 1369 1370 /* Get the symbolic link text over the wire. */ 1371 error = getlinktext_otw(mi, fh, &symlink, cr, flags); 1372 1373 if (error || symlink == NULL || strlen(symlink) == 0) 1374 return (error); 1375 1376 /* 1377 * Compose the new pathname. 1378 * Note: 1379 * - only the nth component is resolved for the pathname. 1380 * - pathname.pn_pathlen does not count the ending null byte. 1381 */ 1382 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 1383 oldpath = svp->sv_path; 1384 oldpathlen = svp->sv_pathlen; 1385 if (error = pn_get(oldpath, UIO_SYSSPACE, &oldpn)) { 1386 nfs_rw_exit(&svp->sv_lock); 1387 kmem_free(symlink, strlen(symlink) + 1); 1388 return (error); 1389 } 1390 nfs_rw_exit(&svp->sv_lock); 1391 pn_alloc(&newpn); 1392 1393 /* 1394 * Skip over previous components from the oldpath so that the 1395 * oldpn.pn_path will point to the symlink component. Skip 1396 * leading slashes and "/./" (no OP_LOOKUP on ".") so that 1397 * pn_getcompnent can get the component. 1398 */ 1399 for (i = 1; i < nth; i++) { 1400 pathname_skipslashdot(&oldpn); 1401 error = pn_getcomponent(&oldpn, component); 1402 if (error) 1403 goto out; 1404 } 1405 1406 /* 1407 * Copy the old path upto the component right before the symlink 1408 * if the symlink is not an absolute path. 1409 */ 1410 if (symlink[0] != '/') { 1411 addlen = oldpn.pn_path - oldpn.pn_buf; 1412 bcopy(oldpn.pn_buf, newpn.pn_path, addlen); 1413 newpn.pn_pathlen += addlen; 1414 newpn.pn_path += addlen; 1415 newpn.pn_buf[newpn.pn_pathlen] = '/'; 1416 newpn.pn_pathlen++; 1417 newpn.pn_path++; 1418 } 1419 1420 /* copy the resolved symbolic link text */ 1421 addlen = strlen(symlink); 1422 if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) { 1423 error = ENAMETOOLONG; 1424 goto out; 1425 } 1426 bcopy(symlink, newpn.pn_path, addlen); 1427 newpn.pn_pathlen += addlen; 1428 newpn.pn_path += addlen; 1429 1430 /* 1431 * Check if there is any remaining path after the symlink component. 1432 * First, skip the symlink component. 1433 */ 1434 pathname_skipslashdot(&oldpn); 1435 if (error = pn_getcomponent(&oldpn, component)) 1436 goto out; 1437 1438 addlen = pn_pathleft(&oldpn); /* includes counting the slash */ 1439 1440 /* 1441 * Copy the remaining path to the new pathname if there is any. 1442 */ 1443 if (addlen > 0) { 1444 if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) { 1445 error = ENAMETOOLONG; 1446 goto out; 1447 } 1448 bcopy(oldpn.pn_path, newpn.pn_path, addlen); 1449 newpn.pn_pathlen += addlen; 1450 } 1451 newpn.pn_buf[newpn.pn_pathlen] = '\0'; 1452 1453 /* get the newpath and store it in the servinfo4_t */ 1454 newpath = kmem_alloc(newpn.pn_pathlen + 1, KM_SLEEP); 1455 bcopy(newpn.pn_buf, newpath, newpn.pn_pathlen); 1456 newpath[newpn.pn_pathlen] = '\0'; 1457 1458 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1459 svp->sv_path = newpath; 1460 svp->sv_pathlen = strlen(newpath) + 1; 1461 nfs_rw_exit(&svp->sv_lock); 1462 1463 kmem_free(oldpath, oldpathlen); 1464 out: 1465 kmem_free(symlink, strlen(symlink) + 1); 1466 pn_free(&newpn); 1467 pn_free(&oldpn); 1468 1469 return (error); 1470 } 1471 1472 /* 1473 * This routine updates servinfo4 structure with the new referred server 1474 * info. 1475 * nfsfsloc has the location related information 1476 * fsp has the hostname and pathname info. 1477 * new path = pathname from referral + part of orig pathname(based on nth). 1478 */ 1479 static void 1480 update_servinfo4(servinfo4_t *svp, fs_location4 *fsp, 1481 struct nfs_fsl_info *nfsfsloc, char *orig_path, int nth) 1482 { 1483 struct knetconfig *knconf, *svknconf; 1484 struct netbuf *saddr; 1485 sec_data_t *secdata; 1486 utf8string *host; 1487 int i = 0, num_slashes = 0; 1488 char *p, *spath, *op, *new_path; 1489 1490 /* Update knconf */ 1491 knconf = svp->sv_knconf; 1492 free_knconf_contents(knconf); 1493 bzero(knconf, sizeof (struct knetconfig)); 1494 svknconf = nfsfsloc->knconf; 1495 knconf->knc_semantics = svknconf->knc_semantics; 1496 knconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 1497 knconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 1498 knconf->knc_rdev = svknconf->knc_rdev; 1499 bcopy(svknconf->knc_protofmly, knconf->knc_protofmly, KNC_STRSIZE); 1500 bcopy(svknconf->knc_proto, knconf->knc_proto, KNC_STRSIZE); 1501 1502 /* Update server address */ 1503 saddr = &svp->sv_addr; 1504 if (saddr->buf != NULL) 1505 kmem_free(saddr->buf, saddr->maxlen); 1506 saddr->buf = kmem_alloc(nfsfsloc->addr->maxlen, KM_SLEEP); 1507 saddr->len = nfsfsloc->addr->len; 1508 saddr->maxlen = nfsfsloc->addr->maxlen; 1509 bcopy(nfsfsloc->addr->buf, saddr->buf, nfsfsloc->addr->len); 1510 1511 /* Update server name */ 1512 host = fsp->server_val; 1513 kmem_free(svp->sv_hostname, svp->sv_hostnamelen); 1514 svp->sv_hostname = kmem_zalloc(host->utf8string_len + 1, KM_SLEEP); 1515 bcopy(host->utf8string_val, svp->sv_hostname, host->utf8string_len); 1516 svp->sv_hostname[host->utf8string_len] = '\0'; 1517 svp->sv_hostnamelen = host->utf8string_len + 1; 1518 1519 /* 1520 * Update server path. 1521 * We need to setup proper path here. 1522 * For ex., If we got a path name serv1:/rp/aaa/bbb 1523 * where aaa is a referral and points to serv2:/rpool/aa 1524 * we need to set the path to serv2:/rpool/aa/bbb 1525 * The first part of this below code generates /rpool/aa 1526 * and the second part appends /bbb to the server path. 1527 */ 1528 spath = p = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1529 *p++ = '/'; 1530 for (i = 0; i < fsp->rootpath.pathname4_len; i++) { 1531 component4 *comp; 1532 1533 comp = &fsp->rootpath.pathname4_val[i]; 1534 /* If no space, null the string and bail */ 1535 if ((p - spath) + comp->utf8string_len + 1 > MAXPATHLEN) { 1536 p = spath + MAXPATHLEN - 1; 1537 spath[0] = '\0'; 1538 break; 1539 } 1540 bcopy(comp->utf8string_val, p, comp->utf8string_len); 1541 p += comp->utf8string_len; 1542 *p++ = '/'; 1543 } 1544 if (fsp->rootpath.pathname4_len != 0) 1545 *(p - 1) = '\0'; 1546 else 1547 *p = '\0'; 1548 p = spath; 1549 1550 new_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1551 (void) strlcpy(new_path, p, MAXPATHLEN); 1552 kmem_free(p, MAXPATHLEN); 1553 i = strlen(new_path); 1554 1555 for (op = orig_path; *op; op++) { 1556 if (*op == '/') 1557 num_slashes++; 1558 if (num_slashes == nth + 2) { 1559 while (*op != '\0') { 1560 new_path[i] = *op; 1561 i++; 1562 op++; 1563 } 1564 break; 1565 } 1566 } 1567 new_path[i] = '\0'; 1568 1569 kmem_free(svp->sv_path, svp->sv_pathlen); 1570 svp->sv_pathlen = strlen(new_path) + 1; 1571 svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP); 1572 bcopy(new_path, svp->sv_path, svp->sv_pathlen); 1573 kmem_free(new_path, MAXPATHLEN); 1574 1575 /* 1576 * All the security data is specific to old server. 1577 * Clean it up except secdata which deals with mount options. 1578 * We need to inherit that data. Copy secdata into our new servinfo4. 1579 */ 1580 if (svp->sv_dhsec) { 1581 sec_clnt_freeinfo(svp->sv_dhsec); 1582 svp->sv_dhsec = NULL; 1583 } 1584 if (svp->sv_save_secinfo && 1585 svp->sv_save_secinfo != svp->sv_secinfo) { 1586 secinfo_free(svp->sv_save_secinfo); 1587 svp->sv_save_secinfo = NULL; 1588 } 1589 if (svp->sv_secinfo) { 1590 secinfo_free(svp->sv_secinfo); 1591 svp->sv_secinfo = NULL; 1592 } 1593 svp->sv_currsec = NULL; 1594 1595 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 1596 *secdata = *svp->sv_secdata; 1597 secdata->data = NULL; 1598 if (svp->sv_secdata) { 1599 sec_clnt_freeinfo(svp->sv_secdata); 1600 svp->sv_secdata = NULL; 1601 } 1602 svp->sv_secdata = secdata; 1603 } 1604 1605 /* 1606 * Resolve a referral. The referral is in the n+1th component of 1607 * svp->sv_path and has a parent nfs4 file handle "fh". 1608 * Upon return, the sv_path will point to the new path that has referral 1609 * component resolved to its referred path and part of original path. 1610 * Hostname and other address information is also updated. 1611 */ 1612 int 1613 resolve_referral(mntinfo4_t *mi, servinfo4_t *svp, cred_t *cr, int nth, 1614 nfs_fh4 *fh) 1615 { 1616 nfs4_sharedfh_t *sfh; 1617 struct nfs_fsl_info nfsfsloc; 1618 nfs4_ga_res_t garp; 1619 COMPOUND4res_clnt callres; 1620 fs_location4 *fsp; 1621 char *nm, *orig_path; 1622 int orig_pathlen = 0, ret = -1, index; 1623 1624 if (svp->sv_pathlen <= 0) 1625 return (ret); 1626 1627 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1628 orig_pathlen = svp->sv_pathlen; 1629 orig_path = kmem_alloc(orig_pathlen, KM_SLEEP); 1630 bcopy(svp->sv_path, orig_path, orig_pathlen); 1631 nm = extract_referral_point(svp->sv_path, nth); 1632 setup_newsvpath(svp, nth); 1633 nfs_rw_exit(&svp->sv_lock); 1634 1635 sfh = sfh4_get(fh, mi); 1636 index = nfs4_process_referral(mi, sfh, nm, cr, 1637 &garp, &callres, &nfsfsloc); 1638 sfh4_rele(&sfh); 1639 kmem_free(nm, MAXPATHLEN); 1640 if (index < 0) { 1641 kmem_free(orig_path, orig_pathlen); 1642 return (index); 1643 } 1644 1645 fsp = &garp.n4g_ext_res->n4g_fslocations.locations_val[index]; 1646 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1647 update_servinfo4(svp, fsp, &nfsfsloc, orig_path, nth); 1648 nfs_rw_exit(&svp->sv_lock); 1649 1650 mutex_enter(&mi->mi_lock); 1651 mi->mi_vfs_referral_loop_cnt++; 1652 mutex_exit(&mi->mi_lock); 1653 1654 ret = 0; 1655 bad: 1656 /* Free up XDR memory allocated in nfs4_process_referral() */ 1657 xdr_free(xdr_nfs_fsl_info, (char *)&nfsfsloc); 1658 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&callres); 1659 kmem_free(orig_path, orig_pathlen); 1660 1661 return (ret); 1662 } 1663 1664 /* 1665 * Get the root filehandle for the given filesystem and server, and update 1666 * svp. 1667 * 1668 * If NFS4_GETFH_NEEDSOP is set, then use nfs4_start_fop and nfs4_end_fop 1669 * to coordinate with recovery. Otherwise, the caller is assumed to be 1670 * the recovery thread or have already done a start_fop. 1671 * 1672 * Errors are returned by the nfs4_error_t parameter. 1673 */ 1674 static void 1675 nfs4getfh_otw(struct mntinfo4 *mi, servinfo4_t *svp, vtype_t *vtp, 1676 int flags, cred_t *cr, nfs4_error_t *ep) 1677 { 1678 COMPOUND4args_clnt args; 1679 COMPOUND4res_clnt res; 1680 int doqueue = 1; 1681 nfs_argop4 *argop; 1682 nfs_resop4 *resop; 1683 nfs4_ga_res_t *garp; 1684 int num_argops; 1685 lookup4_param_t lookuparg; 1686 nfs_fh4 *tmpfhp; 1687 nfs_fh4 *resfhp; 1688 bool_t needrecov = FALSE; 1689 nfs4_recov_state_t recov_state; 1690 int llndx; 1691 int nthcomp; 1692 int recovery = !(flags & NFS4_GETFH_NEEDSOP); 1693 1694 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 1695 ASSERT(svp->sv_path != NULL); 1696 if (svp->sv_path[0] == '\0') { 1697 nfs_rw_exit(&svp->sv_lock); 1698 nfs4_error_init(ep, EINVAL); 1699 return; 1700 } 1701 nfs_rw_exit(&svp->sv_lock); 1702 1703 recov_state.rs_flags = 0; 1704 recov_state.rs_num_retry_despite_err = 0; 1705 1706 recov_retry: 1707 if (mi->mi_vfs_referral_loop_cnt >= NFS4_REFERRAL_LOOP_MAX) { 1708 DTRACE_PROBE3(nfs4clnt__debug__referral__loop, mntinfo4 *, 1709 mi, servinfo4_t *, svp, char *, "nfs4getfh_otw"); 1710 nfs4_error_init(ep, EINVAL); 1711 return; 1712 } 1713 nfs4_error_zinit(ep); 1714 1715 if (!recovery) { 1716 ep->error = nfs4_start_fop(mi, NULL, NULL, OH_MOUNT, 1717 &recov_state, NULL); 1718 1719 /* 1720 * If recovery has been started and this request as 1721 * initiated by a mount, then we must wait for recovery 1722 * to finish before proceeding, otherwise, the error 1723 * cleanup would remove data structures needed by the 1724 * recovery thread. 1725 */ 1726 if (ep->error) { 1727 mutex_enter(&mi->mi_lock); 1728 if (mi->mi_flags & MI4_MOUNTING) { 1729 mi->mi_flags |= MI4_RECOV_FAIL; 1730 mi->mi_error = EIO; 1731 1732 NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, 1733 "nfs4getfh_otw: waiting 4 recovery\n")); 1734 1735 while (mi->mi_flags & MI4_RECOV_ACTIV) 1736 cv_wait(&mi->mi_failover_cv, 1737 &mi->mi_lock); 1738 } 1739 mutex_exit(&mi->mi_lock); 1740 return; 1741 } 1742 1743 /* 1744 * If the client does not specify a specific flavor to use 1745 * and has not gotten a secinfo list from the server yet, 1746 * retrieve the secinfo list from the server and use a 1747 * flavor from the list to mount. 1748 * 1749 * If fail to get the secinfo list from the server, then 1750 * try the default flavor. 1751 */ 1752 if ((svp->sv_flags & SV4_TRYSECDEFAULT) && 1753 svp->sv_secinfo == NULL) { 1754 (void) nfs4_secinfo_path(mi, cr, FALSE); 1755 } 1756 } 1757 1758 if (recovery) 1759 args.ctag = TAG_REMAP_MOUNT; 1760 else 1761 args.ctag = TAG_MOUNT; 1762 1763 lookuparg.l4_getattrs = LKP4_ALL_ATTRIBUTES; 1764 lookuparg.argsp = &args; 1765 lookuparg.resp = &res; 1766 lookuparg.header_len = 2; /* Putrootfh, getfh */ 1767 lookuparg.trailer_len = 0; 1768 lookuparg.ga_bits = FATTR4_FSINFO_MASK; 1769 lookuparg.mi = mi; 1770 1771 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 1772 ASSERT(svp->sv_path != NULL); 1773 llndx = nfs4lookup_setup(svp->sv_path, &lookuparg, 0); 1774 nfs_rw_exit(&svp->sv_lock); 1775 1776 argop = args.array; 1777 num_argops = args.array_len; 1778 1779 /* choose public or root filehandle */ 1780 if (flags & NFS4_GETFH_PUBLIC) 1781 argop[0].argop = OP_PUTPUBFH; 1782 else 1783 argop[0].argop = OP_PUTROOTFH; 1784 1785 /* get fh */ 1786 argop[1].argop = OP_GETFH; 1787 1788 NFS4_DEBUG(nfs4_client_call_debug, (CE_NOTE, 1789 "nfs4getfh_otw: %s call, mi 0x%p", 1790 needrecov ? "recov" : "first", (void *)mi)); 1791 1792 rfs4call(mi, &args, &res, cr, &doqueue, RFSCALL_SOFT, ep); 1793 1794 needrecov = nfs4_needs_recovery(ep, FALSE, mi->mi_vfsp); 1795 1796 if (needrecov) { 1797 bool_t abort; 1798 1799 if (recovery) { 1800 nfs4args_lookup_free(argop, num_argops); 1801 kmem_free(argop, 1802 lookuparg.arglen * sizeof (nfs_argop4)); 1803 if (!ep->error) 1804 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1805 return; 1806 } 1807 1808 NFS4_DEBUG(nfs4_client_recov_debug, 1809 (CE_NOTE, "nfs4getfh_otw: initiating recovery\n")); 1810 1811 abort = nfs4_start_recovery(ep, mi, NULL, 1812 NULL, NULL, NULL, OP_GETFH, NULL, NULL, NULL); 1813 if (!ep->error) { 1814 ep->error = geterrno4(res.status); 1815 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1816 } 1817 nfs4args_lookup_free(argop, num_argops); 1818 kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4)); 1819 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov); 1820 /* have another go? */ 1821 if (abort == FALSE) 1822 goto recov_retry; 1823 return; 1824 } 1825 1826 /* 1827 * No recovery, but check if error is set. 1828 */ 1829 if (ep->error) { 1830 nfs4args_lookup_free(argop, num_argops); 1831 kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4)); 1832 if (!recovery) 1833 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, 1834 needrecov); 1835 return; 1836 } 1837 1838 is_link_err: 1839 1840 /* for non-recovery errors */ 1841 if (res.status && res.status != NFS4ERR_SYMLINK && 1842 res.status != NFS4ERR_MOVED) { 1843 if (!recovery) { 1844 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, 1845 needrecov); 1846 } 1847 nfs4args_lookup_free(argop, num_argops); 1848 kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4)); 1849 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1850 return; 1851 } 1852 1853 /* 1854 * If any intermediate component in the path is a symbolic link, 1855 * resolve the symlink, then try mount again using the new path. 1856 */ 1857 if (res.status == NFS4ERR_SYMLINK || res.status == NFS4ERR_MOVED) { 1858 int where; 1859 1860 /* 1861 * Need to call nfs4_end_op before resolve_sympath to avoid 1862 * potential nfs4_start_op deadlock. 1863 */ 1864 if (!recovery) 1865 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, 1866 needrecov); 1867 1868 /* 1869 * This must be from OP_LOOKUP failure. The (cfh) for this 1870 * OP_LOOKUP is a symlink node. Found out where the 1871 * OP_GETFH is for the (cfh) that is a symlink node. 1872 * 1873 * Example: 1874 * (mount) PUTROOTFH, GETFH, LOOKUP comp1, GETFH, GETATTR, 1875 * LOOKUP comp2, GETFH, GETATTR, LOOKUP comp3, GETFH, GETATTR 1876 * 1877 * LOOKUP comp3 fails with SYMLINK because comp2 is a symlink. 1878 * In this case, where = 7, nthcomp = 2. 1879 */ 1880 where = res.array_len - 2; 1881 ASSERT(where > 0); 1882 1883 if (res.status == NFS4ERR_SYMLINK) { 1884 1885 resop = &res.array[where - 1]; 1886 ASSERT(resop->resop == OP_GETFH); 1887 tmpfhp = &resop->nfs_resop4_u.opgetfh.object; 1888 nthcomp = res.array_len/3 - 1; 1889 ep->error = resolve_sympath(mi, svp, nthcomp, 1890 tmpfhp, cr, flags); 1891 1892 } else if (res.status == NFS4ERR_MOVED) { 1893 1894 resop = &res.array[where - 2]; 1895 ASSERT(resop->resop == OP_GETFH); 1896 tmpfhp = &resop->nfs_resop4_u.opgetfh.object; 1897 nthcomp = res.array_len/3 - 1; 1898 ep->error = resolve_referral(mi, svp, cr, nthcomp, 1899 tmpfhp); 1900 } 1901 1902 nfs4args_lookup_free(argop, num_argops); 1903 kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4)); 1904 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1905 1906 if (ep->error) 1907 return; 1908 1909 goto recov_retry; 1910 } 1911 1912 /* getfh */ 1913 resop = &res.array[res.array_len - 2]; 1914 ASSERT(resop->resop == OP_GETFH); 1915 resfhp = &resop->nfs_resop4_u.opgetfh.object; 1916 1917 /* getattr fsinfo res */ 1918 resop++; 1919 garp = &resop->nfs_resop4_u.opgetattr.ga_res; 1920 1921 *vtp = garp->n4g_va.va_type; 1922 1923 mi->mi_fh_expire_type = garp->n4g_ext_res->n4g_fet; 1924 1925 mutex_enter(&mi->mi_lock); 1926 if (garp->n4g_ext_res->n4g_pc4.pc4_link_support) 1927 mi->mi_flags |= MI4_LINK; 1928 if (garp->n4g_ext_res->n4g_pc4.pc4_symlink_support) 1929 mi->mi_flags |= MI4_SYMLINK; 1930 if (garp->n4g_ext_res->n4g_suppattrs & FATTR4_ACL_MASK) 1931 mi->mi_flags |= MI4_ACL; 1932 mutex_exit(&mi->mi_lock); 1933 1934 if (garp->n4g_ext_res->n4g_maxread == 0) 1935 mi->mi_tsize = 1936 MIN(MAXBSIZE, mi->mi_tsize); 1937 else 1938 mi->mi_tsize = 1939 MIN(garp->n4g_ext_res->n4g_maxread, 1940 mi->mi_tsize); 1941 1942 if (garp->n4g_ext_res->n4g_maxwrite == 0) 1943 mi->mi_stsize = 1944 MIN(MAXBSIZE, mi->mi_stsize); 1945 else 1946 mi->mi_stsize = 1947 MIN(garp->n4g_ext_res->n4g_maxwrite, 1948 mi->mi_stsize); 1949 1950 if (garp->n4g_ext_res->n4g_maxfilesize != 0) 1951 mi->mi_maxfilesize = 1952 MIN(garp->n4g_ext_res->n4g_maxfilesize, 1953 mi->mi_maxfilesize); 1954 1955 /* 1956 * If the final component is a a symbolic link, resolve the symlink, 1957 * then try mount again using the new path. 1958 * 1959 * Assume no symbolic link for root filesysm "/". 1960 */ 1961 if (*vtp == VLNK) { 1962 /* 1963 * nthcomp is the total result length minus 1964 * the 1st 2 OPs (PUTROOTFH, GETFH), 1965 * then divided by 3 (LOOKUP,GETFH,GETATTR) 1966 * 1967 * e.g. PUTROOTFH GETFH LOOKUP 1st-comp GETFH GETATTR 1968 * LOOKUP 2nd-comp GETFH GETATTR 1969 * 1970 * (8 - 2)/3 = 2 1971 */ 1972 nthcomp = (res.array_len - 2)/3; 1973 1974 /* 1975 * Need to call nfs4_end_op before resolve_sympath to avoid 1976 * potential nfs4_start_op deadlock. See RFE 4777612. 1977 */ 1978 if (!recovery) 1979 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, 1980 needrecov); 1981 1982 ep->error = resolve_sympath(mi, svp, nthcomp, resfhp, cr, 1983 flags); 1984 1985 nfs4args_lookup_free(argop, num_argops); 1986 kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4)); 1987 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1988 1989 if (ep->error) 1990 return; 1991 1992 goto recov_retry; 1993 } 1994 1995 /* 1996 * We need to figure out where in the compound the getfh 1997 * for the parent directory is. If the object to be mounted is 1998 * the root, then there is no lookup at all: 1999 * PUTROOTFH, GETFH. 2000 * If the object to be mounted is in the root, then the compound is: 2001 * PUTROOTFH, GETFH, LOOKUP, GETFH, GETATTR. 2002 * In either of these cases, the index of the GETFH is 1. 2003 * If it is not at the root, then it's something like: 2004 * PUTROOTFH, GETFH, LOOKUP, GETFH, GETATTR, 2005 * LOOKUP, GETFH, GETATTR 2006 * In this case, the index is llndx (last lookup index) - 2. 2007 */ 2008 if (llndx == -1 || llndx == 2) 2009 resop = &res.array[1]; 2010 else { 2011 ASSERT(llndx > 2); 2012 resop = &res.array[llndx-2]; 2013 } 2014 2015 ASSERT(resop->resop == OP_GETFH); 2016 tmpfhp = &resop->nfs_resop4_u.opgetfh.object; 2017 2018 /* save the filehandles for the replica */ 2019 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2020 ASSERT(tmpfhp->nfs_fh4_len <= NFS4_FHSIZE); 2021 svp->sv_pfhandle.fh_len = tmpfhp->nfs_fh4_len; 2022 bcopy(tmpfhp->nfs_fh4_val, svp->sv_pfhandle.fh_buf, 2023 tmpfhp->nfs_fh4_len); 2024 ASSERT(resfhp->nfs_fh4_len <= NFS4_FHSIZE); 2025 svp->sv_fhandle.fh_len = resfhp->nfs_fh4_len; 2026 bcopy(resfhp->nfs_fh4_val, svp->sv_fhandle.fh_buf, resfhp->nfs_fh4_len); 2027 2028 /* initialize fsid and supp_attrs for server fs */ 2029 svp->sv_fsid = garp->n4g_fsid; 2030 svp->sv_supp_attrs = 2031 garp->n4g_ext_res->n4g_suppattrs | FATTR4_MANDATTR_MASK; 2032 2033 nfs_rw_exit(&svp->sv_lock); 2034 nfs4args_lookup_free(argop, num_argops); 2035 kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4)); 2036 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 2037 if (!recovery) 2038 nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov); 2039 } 2040 2041 /* 2042 * Save a copy of Servinfo4_t structure. 2043 * We might need when there is a failure in getting file handle 2044 * in case of a referral to replace servinfo4 struct and try again. 2045 */ 2046 static struct servinfo4 * 2047 copy_svp(servinfo4_t *nsvp) 2048 { 2049 servinfo4_t *svp = NULL; 2050 struct knetconfig *sknconf, *tknconf; 2051 struct netbuf *saddr, *taddr; 2052 2053 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP); 2054 nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL); 2055 svp->sv_flags = nsvp->sv_flags; 2056 svp->sv_fsid = nsvp->sv_fsid; 2057 svp->sv_hostnamelen = nsvp->sv_hostnamelen; 2058 svp->sv_pathlen = nsvp->sv_pathlen; 2059 svp->sv_supp_attrs = nsvp->sv_supp_attrs; 2060 2061 svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP); 2062 svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP); 2063 bcopy(nsvp->sv_hostname, svp->sv_hostname, svp->sv_hostnamelen); 2064 bcopy(nsvp->sv_path, svp->sv_path, svp->sv_pathlen); 2065 2066 saddr = &nsvp->sv_addr; 2067 taddr = &svp->sv_addr; 2068 taddr->maxlen = saddr->maxlen; 2069 taddr->len = saddr->len; 2070 if (saddr->len > 0) { 2071 taddr->buf = kmem_zalloc(saddr->maxlen, KM_SLEEP); 2072 bcopy(saddr->buf, taddr->buf, saddr->len); 2073 } 2074 2075 svp->sv_knconf = kmem_zalloc(sizeof (struct knetconfig), KM_SLEEP); 2076 sknconf = nsvp->sv_knconf; 2077 tknconf = svp->sv_knconf; 2078 tknconf->knc_semantics = sknconf->knc_semantics; 2079 tknconf->knc_rdev = sknconf->knc_rdev; 2080 if (sknconf->knc_proto != NULL) { 2081 tknconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 2082 bcopy(sknconf->knc_proto, (char *)tknconf->knc_proto, 2083 KNC_STRSIZE); 2084 } 2085 if (sknconf->knc_protofmly != NULL) { 2086 tknconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 2087 bcopy(sknconf->knc_protofmly, (char *)tknconf->knc_protofmly, 2088 KNC_STRSIZE); 2089 } 2090 2091 if (nsvp->sv_origknconf != NULL) { 2092 svp->sv_origknconf = kmem_zalloc(sizeof (struct knetconfig), 2093 KM_SLEEP); 2094 sknconf = nsvp->sv_origknconf; 2095 tknconf = svp->sv_origknconf; 2096 tknconf->knc_semantics = sknconf->knc_semantics; 2097 tknconf->knc_rdev = sknconf->knc_rdev; 2098 if (sknconf->knc_proto != NULL) { 2099 tknconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 2100 bcopy(sknconf->knc_proto, (char *)tknconf->knc_proto, 2101 KNC_STRSIZE); 2102 } 2103 if (sknconf->knc_protofmly != NULL) { 2104 tknconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, 2105 KM_SLEEP); 2106 bcopy(sknconf->knc_protofmly, 2107 (char *)tknconf->knc_protofmly, KNC_STRSIZE); 2108 } 2109 } 2110 2111 svp->sv_secdata = copy_sec_data(nsvp->sv_secdata); 2112 svp->sv_dhsec = copy_sec_data(svp->sv_dhsec); 2113 /* 2114 * Rest of the security information is not copied as they are built 2115 * with the information available from secdata and dhsec. 2116 */ 2117 svp->sv_next = NULL; 2118 2119 return (svp); 2120 } 2121 2122 servinfo4_t * 2123 restore_svp(mntinfo4_t *mi, servinfo4_t *svp, servinfo4_t *origsvp) 2124 { 2125 servinfo4_t *srvnext, *tmpsrv; 2126 2127 if (strcmp(svp->sv_hostname, origsvp->sv_hostname) != 0) { 2128 /* 2129 * Since the hostname changed, we must be dealing 2130 * with a referral, and the lookup failed. We will 2131 * restore the whole servinfo4_t to what it was before. 2132 */ 2133 srvnext = svp->sv_next; 2134 svp->sv_next = NULL; 2135 tmpsrv = copy_svp(origsvp); 2136 sv4_free(svp); 2137 svp = tmpsrv; 2138 svp->sv_next = srvnext; 2139 mutex_enter(&mi->mi_lock); 2140 mi->mi_servers = svp; 2141 mi->mi_curr_serv = svp; 2142 mutex_exit(&mi->mi_lock); 2143 2144 } else if (origsvp->sv_pathlen != svp->sv_pathlen) { 2145 2146 /* 2147 * For symlink case: restore original path because 2148 * it might have contained symlinks that were 2149 * expanded by nfsgetfh_otw before the failure occurred. 2150 */ 2151 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 2152 kmem_free(svp->sv_path, svp->sv_pathlen); 2153 svp->sv_path = 2154 kmem_alloc(origsvp->sv_pathlen, KM_SLEEP); 2155 svp->sv_pathlen = origsvp->sv_pathlen; 2156 bcopy(origsvp->sv_path, svp->sv_path, 2157 origsvp->sv_pathlen); 2158 nfs_rw_exit(&svp->sv_lock); 2159 } 2160 return (svp); 2161 } 2162 2163 static ushort_t nfs4_max_threads = 8; /* max number of active async threads */ 2164 uint_t nfs4_bsize = 32 * 1024; /* client `block' size */ 2165 static uint_t nfs4_async_clusters = 1; /* # of reqs from each async queue */ 2166 static uint_t nfs4_cots_timeo = NFS_COTS_TIMEO; 2167 2168 /* 2169 * Remap the root filehandle for the given filesystem. 2170 * 2171 * results returned via the nfs4_error_t parameter. 2172 */ 2173 void 2174 nfs4_remap_root(mntinfo4_t *mi, nfs4_error_t *ep, int flags) 2175 { 2176 struct servinfo4 *svp, *origsvp; 2177 vtype_t vtype; 2178 nfs_fh4 rootfh; 2179 int getfh_flags; 2180 int num_retry; 2181 2182 mutex_enter(&mi->mi_lock); 2183 2184 remap_retry: 2185 svp = mi->mi_curr_serv; 2186 getfh_flags = 2187 (flags & NFS4_REMAP_NEEDSOP) ? NFS4_GETFH_NEEDSOP : 0; 2188 getfh_flags |= 2189 (mi->mi_flags & MI4_PUBLIC) ? NFS4_GETFH_PUBLIC : 0; 2190 mutex_exit(&mi->mi_lock); 2191 2192 /* 2193 * Just in case server path being mounted contains 2194 * symlinks and fails w/STALE, save the initial sv_path 2195 * so we can redrive the initial mount compound with the 2196 * initial sv_path -- not a symlink-expanded version. 2197 * 2198 * This could only happen if a symlink was expanded 2199 * and the expanded mount compound failed stale. Because 2200 * it could be the case that the symlink was removed at 2201 * the server (and replaced with another symlink/dir, 2202 * we need to use the initial sv_path when attempting 2203 * to re-lookup everything and recover. 2204 */ 2205 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 2206 origsvp = copy_svp(svp); 2207 nfs_rw_exit(&svp->sv_lock); 2208 2209 num_retry = nfs4_max_mount_retry; 2210 2211 do { 2212 /* 2213 * Get the root fh from the server. Retry nfs4_max_mount_retry 2214 * (2) times if it fails with STALE since the recovery 2215 * infrastructure doesn't do STALE recovery for components 2216 * of the server path to the object being mounted. 2217 */ 2218 nfs4getfh_otw(mi, svp, &vtype, getfh_flags, CRED(), ep); 2219 2220 if (ep->error == 0 && ep->stat == NFS4_OK) 2221 break; 2222 2223 /* 2224 * For some reason, the mount compound failed. Before 2225 * retrying, we need to restore original conditions. 2226 */ 2227 svp = restore_svp(mi, svp, origsvp); 2228 2229 } while (num_retry-- > 0); 2230 2231 sv4_free(origsvp); 2232 2233 if (ep->error != 0 || ep->stat != 0) { 2234 return; 2235 } 2236 2237 if (vtype != VNON && vtype != mi->mi_type) { 2238 /* shouldn't happen */ 2239 zcmn_err(mi->mi_zone->zone_id, CE_WARN, 2240 "nfs4_remap_root: server root vnode type (%d) doesn't " 2241 "match mount info (%d)", vtype, mi->mi_type); 2242 } 2243 2244 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 2245 rootfh.nfs_fh4_val = svp->sv_fhandle.fh_buf; 2246 rootfh.nfs_fh4_len = svp->sv_fhandle.fh_len; 2247 nfs_rw_exit(&svp->sv_lock); 2248 sfh4_update(mi->mi_rootfh, &rootfh); 2249 2250 /* 2251 * It's possible that recovery took place on the filesystem 2252 * and the server has been updated between the time we did 2253 * the nfs4getfh_otw and now. Re-drive the otw operation 2254 * to make sure we have a good fh. 2255 */ 2256 mutex_enter(&mi->mi_lock); 2257 if (mi->mi_curr_serv != svp) 2258 goto remap_retry; 2259 2260 mutex_exit(&mi->mi_lock); 2261 } 2262 2263 static int 2264 nfs4rootvp(vnode_t **rtvpp, vfs_t *vfsp, struct servinfo4 *svp_head, 2265 int flags, cred_t *cr, zone_t *zone) 2266 { 2267 vnode_t *rtvp = NULL; 2268 mntinfo4_t *mi; 2269 dev_t nfs_dev; 2270 int error = 0; 2271 rnode4_t *rp; 2272 int i, len; 2273 struct vattr va; 2274 vtype_t vtype = VNON; 2275 vtype_t tmp_vtype = VNON; 2276 struct servinfo4 *firstsvp = NULL, *svp = svp_head; 2277 nfs4_oo_hash_bucket_t *bucketp; 2278 nfs_fh4 fh; 2279 char *droptext = ""; 2280 struct nfs_stats *nfsstatsp; 2281 nfs4_fname_t *mfname; 2282 nfs4_error_t e; 2283 int num_retry, removed; 2284 cred_t *lcr = NULL, *tcr = cr; 2285 struct servinfo4 *origsvp; 2286 char *resource; 2287 2288 nfsstatsp = zone_getspecific(nfsstat_zone_key, nfs_zone()); 2289 ASSERT(nfsstatsp != NULL); 2290 2291 ASSERT(nfs_zone() == zone); 2292 ASSERT(crgetref(cr)); 2293 2294 /* 2295 * Create a mount record and link it to the vfs struct. 2296 */ 2297 mi = kmem_zalloc(sizeof (*mi), KM_SLEEP); 2298 mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL); 2299 nfs_rw_init(&mi->mi_recovlock, NULL, RW_DEFAULT, NULL); 2300 nfs_rw_init(&mi->mi_rename_lock, NULL, RW_DEFAULT, NULL); 2301 nfs_rw_init(&mi->mi_fh_lock, NULL, RW_DEFAULT, NULL); 2302 2303 if (!(flags & NFSMNT_SOFT)) 2304 mi->mi_flags |= MI4_HARD; 2305 if ((flags & NFSMNT_NOPRINT)) 2306 mi->mi_flags |= MI4_NOPRINT; 2307 if (flags & NFSMNT_INT) 2308 mi->mi_flags |= MI4_INT; 2309 if (flags & NFSMNT_PUBLIC) 2310 mi->mi_flags |= MI4_PUBLIC; 2311 if (flags & NFSMNT_MIRRORMOUNT) 2312 mi->mi_flags |= MI4_MIRRORMOUNT; 2313 if (flags & NFSMNT_REFERRAL) 2314 mi->mi_flags |= MI4_REFERRAL; 2315 mi->mi_retrans = NFS_RETRIES; 2316 if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD || 2317 svp->sv_knconf->knc_semantics == NC_TPI_COTS) 2318 mi->mi_timeo = nfs4_cots_timeo; 2319 else 2320 mi->mi_timeo = NFS_TIMEO; 2321 mi->mi_prog = NFS_PROGRAM; 2322 mi->mi_vers = NFS_V4; 2323 mi->mi_rfsnames = rfsnames_v4; 2324 mi->mi_reqs = nfsstatsp->nfs_stats_v4.rfsreqcnt_ptr; 2325 cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL); 2326 mi->mi_servers = svp; 2327 mi->mi_curr_serv = svp; 2328 mi->mi_acregmin = SEC2HR(ACREGMIN); 2329 mi->mi_acregmax = SEC2HR(ACREGMAX); 2330 mi->mi_acdirmin = SEC2HR(ACDIRMIN); 2331 mi->mi_acdirmax = SEC2HR(ACDIRMAX); 2332 mi->mi_fh_expire_type = FH4_PERSISTENT; 2333 mi->mi_clientid_next = NULL; 2334 mi->mi_clientid_prev = NULL; 2335 mi->mi_srv = NULL; 2336 mi->mi_grace_wait = 0; 2337 mi->mi_error = 0; 2338 mi->mi_srvsettime = 0; 2339 mi->mi_srvset_cnt = 0; 2340 2341 mi->mi_count = 1; 2342 2343 mi->mi_tsize = nfs4_tsize(svp->sv_knconf); 2344 mi->mi_stsize = mi->mi_tsize; 2345 2346 if (flags & NFSMNT_DIRECTIO) 2347 mi->mi_flags |= MI4_DIRECTIO; 2348 2349 mi->mi_flags |= MI4_MOUNTING; 2350 2351 /* 2352 * Make a vfs struct for nfs. We do this here instead of below 2353 * because rtvp needs a vfs before we can do a getattr on it. 2354 * 2355 * Assign a unique device id to the mount 2356 */ 2357 mutex_enter(&nfs_minor_lock); 2358 do { 2359 nfs_minor = (nfs_minor + 1) & MAXMIN32; 2360 nfs_dev = makedevice(nfs_major, nfs_minor); 2361 } while (vfs_devismounted(nfs_dev)); 2362 mutex_exit(&nfs_minor_lock); 2363 2364 vfsp->vfs_dev = nfs_dev; 2365 vfs_make_fsid(&vfsp->vfs_fsid, nfs_dev, nfs4fstyp); 2366 vfsp->vfs_data = (caddr_t)mi; 2367 vfsp->vfs_fstype = nfsfstyp; 2368 vfsp->vfs_bsize = nfs4_bsize; 2369 2370 /* 2371 * Initialize fields used to support async putpage operations. 2372 */ 2373 for (i = 0; i < NFS4_ASYNC_TYPES; i++) 2374 mi->mi_async_clusters[i] = nfs4_async_clusters; 2375 mi->mi_async_init_clusters = nfs4_async_clusters; 2376 mi->mi_async_curr[NFS4_ASYNC_QUEUE] = 2377 mi->mi_async_curr[NFS4_ASYNC_PGOPS_QUEUE] = &mi->mi_async_reqs[0]; 2378 mi->mi_max_threads = nfs4_max_threads; 2379 mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL); 2380 cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL); 2381 cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_QUEUE], NULL, CV_DEFAULT, 2382 NULL); 2383 cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_PGOPS_QUEUE], NULL, 2384 CV_DEFAULT, NULL); 2385 cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL); 2386 cv_init(&mi->mi_inact_req_cv, NULL, CV_DEFAULT, NULL); 2387 2388 mi->mi_vfsp = vfsp; 2389 mi->mi_zone = zone; 2390 zone_init_ref(&mi->mi_zone_ref); 2391 zone_hold_ref(zone, &mi->mi_zone_ref, ZONE_REF_NFSV4); 2392 nfs4_mi_zonelist_add(mi); 2393 2394 /* 2395 * Initialize the <open owner/cred> hash table. 2396 */ 2397 for (i = 0; i < NFS4_NUM_OO_BUCKETS; i++) { 2398 bucketp = &(mi->mi_oo_list[i]); 2399 mutex_init(&bucketp->b_lock, NULL, MUTEX_DEFAULT, NULL); 2400 list_create(&bucketp->b_oo_hash_list, 2401 sizeof (nfs4_open_owner_t), 2402 offsetof(nfs4_open_owner_t, oo_hash_node)); 2403 } 2404 2405 /* 2406 * Initialize the freed open owner list. 2407 */ 2408 mi->mi_foo_num = 0; 2409 mi->mi_foo_max = NFS4_NUM_FREED_OPEN_OWNERS; 2410 list_create(&mi->mi_foo_list, sizeof (nfs4_open_owner_t), 2411 offsetof(nfs4_open_owner_t, oo_foo_node)); 2412 2413 list_create(&mi->mi_lost_state, sizeof (nfs4_lost_rqst_t), 2414 offsetof(nfs4_lost_rqst_t, lr_node)); 2415 2416 list_create(&mi->mi_bseqid_list, sizeof (nfs4_bseqid_entry_t), 2417 offsetof(nfs4_bseqid_entry_t, bs_node)); 2418 2419 /* 2420 * Initialize the msg buffer. 2421 */ 2422 list_create(&mi->mi_msg_list, sizeof (nfs4_debug_msg_t), 2423 offsetof(nfs4_debug_msg_t, msg_node)); 2424 mi->mi_msg_count = 0; 2425 mutex_init(&mi->mi_msg_list_lock, NULL, MUTEX_DEFAULT, NULL); 2426 2427 /* 2428 * Initialize kstats 2429 */ 2430 nfs4_mnt_kstat_init(vfsp); 2431 2432 /* 2433 * Initialize the shared filehandle pool. 2434 */ 2435 sfh4_createtab(&mi->mi_filehandles); 2436 2437 /* 2438 * Save server path we're attempting to mount. 2439 */ 2440 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2441 origsvp = copy_svp(svp); 2442 nfs_rw_exit(&svp->sv_lock); 2443 2444 /* 2445 * Make the GETFH call to get root fh for each replica. 2446 */ 2447 if (svp_head->sv_next) 2448 droptext = ", dropping replica"; 2449 2450 /* 2451 * If the uid is set then set the creds for secure mounts 2452 * by proxy processes such as automountd. 2453 */ 2454 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 2455 if (svp->sv_secdata->uid != 0 && 2456 svp->sv_secdata->rpcflavor == RPCSEC_GSS) { 2457 lcr = crdup(cr); 2458 (void) crsetugid(lcr, svp->sv_secdata->uid, crgetgid(cr)); 2459 tcr = lcr; 2460 } 2461 nfs_rw_exit(&svp->sv_lock); 2462 for (svp = svp_head; svp; svp = svp->sv_next) { 2463 if (nfs4_chkdup_servinfo4(svp_head, svp)) { 2464 nfs_cmn_err(error, CE_WARN, 2465 VERS_MSG "Host %s is a duplicate%s", 2466 svp->sv_hostname, droptext); 2467 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2468 svp->sv_flags |= SV4_NOTINUSE; 2469 nfs_rw_exit(&svp->sv_lock); 2470 continue; 2471 } 2472 mi->mi_curr_serv = svp; 2473 2474 /* 2475 * Just in case server path being mounted contains 2476 * symlinks and fails w/STALE, save the initial sv_path 2477 * so we can redrive the initial mount compound with the 2478 * initial sv_path -- not a symlink-expanded version. 2479 * 2480 * This could only happen if a symlink was expanded 2481 * and the expanded mount compound failed stale. Because 2482 * it could be the case that the symlink was removed at 2483 * the server (and replaced with another symlink/dir, 2484 * we need to use the initial sv_path when attempting 2485 * to re-lookup everything and recover. 2486 * 2487 * Other mount errors should evenutally be handled here also 2488 * (NFS4ERR_DELAY, NFS4ERR_RESOURCE). For now, all mount 2489 * failures will result in mount being redriven a few times. 2490 */ 2491 num_retry = nfs4_max_mount_retry; 2492 do { 2493 nfs4getfh_otw(mi, svp, &tmp_vtype, 2494 ((flags & NFSMNT_PUBLIC) ? NFS4_GETFH_PUBLIC : 0) | 2495 NFS4_GETFH_NEEDSOP, tcr, &e); 2496 2497 if (e.error == 0 && e.stat == NFS4_OK) 2498 break; 2499 2500 /* 2501 * For some reason, the mount compound failed. Before 2502 * retrying, we need to restore original conditions. 2503 */ 2504 svp = restore_svp(mi, svp, origsvp); 2505 svp_head = svp; 2506 2507 } while (num_retry-- > 0); 2508 error = e.error ? e.error : geterrno4(e.stat); 2509 if (error) { 2510 nfs_cmn_err(error, CE_WARN, 2511 VERS_MSG "initial call to %s failed%s: %m", 2512 svp->sv_hostname, droptext); 2513 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2514 svp->sv_flags |= SV4_NOTINUSE; 2515 nfs_rw_exit(&svp->sv_lock); 2516 mi->mi_flags &= ~MI4_RECOV_FAIL; 2517 mi->mi_error = 0; 2518 continue; 2519 } 2520 2521 if (tmp_vtype == VBAD) { 2522 zcmn_err(mi->mi_zone->zone_id, CE_WARN, 2523 VERS_MSG "%s returned a bad file type for " 2524 "root%s", svp->sv_hostname, droptext); 2525 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2526 svp->sv_flags |= SV4_NOTINUSE; 2527 nfs_rw_exit(&svp->sv_lock); 2528 continue; 2529 } 2530 2531 if (vtype == VNON) { 2532 vtype = tmp_vtype; 2533 } else if (vtype != tmp_vtype) { 2534 zcmn_err(mi->mi_zone->zone_id, CE_WARN, 2535 VERS_MSG "%s returned a different file type " 2536 "for root%s", svp->sv_hostname, droptext); 2537 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2538 svp->sv_flags |= SV4_NOTINUSE; 2539 nfs_rw_exit(&svp->sv_lock); 2540 continue; 2541 } 2542 if (firstsvp == NULL) 2543 firstsvp = svp; 2544 } 2545 2546 if (firstsvp == NULL) { 2547 if (error == 0) 2548 error = ENOENT; 2549 goto bad; 2550 } 2551 2552 mi->mi_curr_serv = svp = firstsvp; 2553 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 2554 ASSERT((mi->mi_curr_serv->sv_flags & SV4_NOTINUSE) == 0); 2555 fh.nfs_fh4_len = svp->sv_fhandle.fh_len; 2556 fh.nfs_fh4_val = svp->sv_fhandle.fh_buf; 2557 mi->mi_rootfh = sfh4_get(&fh, mi); 2558 fh.nfs_fh4_len = svp->sv_pfhandle.fh_len; 2559 fh.nfs_fh4_val = svp->sv_pfhandle.fh_buf; 2560 mi->mi_srvparentfh = sfh4_get(&fh, mi); 2561 nfs_rw_exit(&svp->sv_lock); 2562 2563 /* 2564 * Get the fname for filesystem root. 2565 */ 2566 mi->mi_fname = fn_get(NULL, ".", mi->mi_rootfh); 2567 mfname = mi->mi_fname; 2568 fn_hold(mfname); 2569 2570 /* 2571 * Make the root vnode without attributes. 2572 */ 2573 rtvp = makenfs4node_by_fh(mi->mi_rootfh, NULL, 2574 &mfname, NULL, mi, cr, gethrtime()); 2575 rtvp->v_type = vtype; 2576 2577 mi->mi_curread = mi->mi_tsize; 2578 mi->mi_curwrite = mi->mi_stsize; 2579 2580 /* 2581 * Start the manager thread responsible for handling async worker 2582 * threads. 2583 */ 2584 MI4_HOLD(mi); 2585 VFS_HOLD(vfsp); /* add reference for thread */ 2586 mi->mi_manager_thread = zthread_create(NULL, 0, nfs4_async_manager, 2587 vfsp, 0, minclsyspri); 2588 ASSERT(mi->mi_manager_thread != NULL); 2589 2590 /* 2591 * Create the thread that handles over-the-wire calls for 2592 * VOP_INACTIVE. 2593 * This needs to happen after the manager thread is created. 2594 */ 2595 MI4_HOLD(mi); 2596 mi->mi_inactive_thread = zthread_create(NULL, 0, nfs4_inactive_thread, 2597 mi, 0, minclsyspri); 2598 ASSERT(mi->mi_inactive_thread != NULL); 2599 2600 /* If we didn't get a type, get one now */ 2601 if (rtvp->v_type == VNON) { 2602 va.va_mask = AT_TYPE; 2603 error = nfs4getattr(rtvp, &va, tcr); 2604 if (error) 2605 goto bad; 2606 rtvp->v_type = va.va_type; 2607 } 2608 2609 mi->mi_type = rtvp->v_type; 2610 2611 mutex_enter(&mi->mi_lock); 2612 mi->mi_flags &= ~MI4_MOUNTING; 2613 mutex_exit(&mi->mi_lock); 2614 2615 /* Update VFS with new server and path info */ 2616 if ((strcmp(svp->sv_hostname, origsvp->sv_hostname) != 0) || 2617 (strcmp(svp->sv_path, origsvp->sv_path) != 0)) { 2618 len = svp->sv_hostnamelen + svp->sv_pathlen; 2619 resource = kmem_zalloc(len, KM_SLEEP); 2620 (void) strcat(resource, svp->sv_hostname); 2621 (void) strcat(resource, ":"); 2622 (void) strcat(resource, svp->sv_path); 2623 vfs_setresource(vfsp, resource, 0); 2624 kmem_free(resource, len); 2625 } 2626 2627 sv4_free(origsvp); 2628 *rtvpp = rtvp; 2629 if (lcr != NULL) 2630 crfree(lcr); 2631 2632 return (0); 2633 bad: 2634 /* 2635 * An error occurred somewhere, need to clean up... 2636 */ 2637 if (lcr != NULL) 2638 crfree(lcr); 2639 2640 if (rtvp != NULL) { 2641 /* 2642 * We need to release our reference to the root vnode and 2643 * destroy the mntinfo4 struct that we just created. 2644 */ 2645 rp = VTOR4(rtvp); 2646 if (rp->r_flags & R4HASHED) 2647 rp4_rmhash(rp); 2648 VN_RELE(rtvp); 2649 } 2650 nfs4_async_stop(vfsp); 2651 nfs4_async_manager_stop(vfsp); 2652 removed = nfs4_mi_zonelist_remove(mi); 2653 if (removed) 2654 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4); 2655 2656 /* 2657 * This releases the initial "hold" of the mi since it will never 2658 * be referenced by the vfsp. Also, when mount returns to vfs.c 2659 * with an error, the vfsp will be destroyed, not rele'd. 2660 */ 2661 MI4_RELE(mi); 2662 2663 if (origsvp != NULL) 2664 sv4_free(origsvp); 2665 2666 *rtvpp = NULL; 2667 return (error); 2668 } 2669 2670 /* 2671 * vfs operations 2672 */ 2673 static int 2674 nfs4_unmount(vfs_t *vfsp, int flag, cred_t *cr) 2675 { 2676 mntinfo4_t *mi; 2677 ushort_t omax; 2678 int removed; 2679 2680 bool_t must_unlock; 2681 2682 nfs4_ephemeral_tree_t *eph_tree; 2683 2684 if (secpolicy_fs_unmount(cr, vfsp) != 0) 2685 return (EPERM); 2686 2687 mi = VFTOMI4(vfsp); 2688 2689 if (flag & MS_FORCE) { 2690 vfsp->vfs_flag |= VFS_UNMOUNTED; 2691 if (nfs_zone() != mi->mi_zone) { 2692 /* 2693 * If the request is coming from the wrong zone, 2694 * we don't want to create any new threads, and 2695 * performance is not a concern. Do everything 2696 * inline. 2697 */ 2698 NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE, 2699 "nfs4_unmount x-zone forced unmount of vfs %p\n", 2700 (void *)vfsp)); 2701 nfs4_free_mount(vfsp, flag, cr); 2702 } else { 2703 /* 2704 * Free data structures asynchronously, to avoid 2705 * blocking the current thread (for performance 2706 * reasons only). 2707 */ 2708 async_free_mount(vfsp, flag, cr); 2709 } 2710 2711 return (0); 2712 } 2713 2714 /* 2715 * Wait until all asynchronous putpage operations on 2716 * this file system are complete before flushing rnodes 2717 * from the cache. 2718 */ 2719 omax = mi->mi_max_threads; 2720 if (nfs4_async_stop_sig(vfsp)) 2721 return (EINTR); 2722 2723 r4flush(vfsp, cr); 2724 2725 /* 2726 * About the only reason that this would fail would be 2727 * that the harvester is already busy tearing down this 2728 * node. So we fail back to the caller and let them try 2729 * again when needed. 2730 */ 2731 if (nfs4_ephemeral_umount(mi, flag, cr, 2732 &must_unlock, &eph_tree)) { 2733 ASSERT(must_unlock == FALSE); 2734 mutex_enter(&mi->mi_async_lock); 2735 mi->mi_max_threads = omax; 2736 mutex_exit(&mi->mi_async_lock); 2737 2738 return (EBUSY); 2739 } 2740 2741 /* 2742 * If there are any active vnodes on this file system, 2743 * then the file system is busy and can't be unmounted. 2744 */ 2745 if (check_rtable4(vfsp)) { 2746 nfs4_ephemeral_umount_unlock(&must_unlock, &eph_tree); 2747 2748 mutex_enter(&mi->mi_async_lock); 2749 mi->mi_max_threads = omax; 2750 mutex_exit(&mi->mi_async_lock); 2751 2752 return (EBUSY); 2753 } 2754 2755 /* 2756 * The unmount can't fail from now on, so record any 2757 * ephemeral changes. 2758 */ 2759 nfs4_ephemeral_umount_activate(mi, &must_unlock, &eph_tree); 2760 2761 /* 2762 * There are no active files that could require over-the-wire 2763 * calls to the server, so stop the async manager and the 2764 * inactive thread. 2765 */ 2766 nfs4_async_manager_stop(vfsp); 2767 2768 /* 2769 * Destroy all rnodes belonging to this file system from the 2770 * rnode hash queues and purge any resources allocated to 2771 * them. 2772 */ 2773 destroy_rtable4(vfsp, cr); 2774 vfsp->vfs_flag |= VFS_UNMOUNTED; 2775 2776 nfs4_remove_mi_from_server(mi, NULL); 2777 removed = nfs4_mi_zonelist_remove(mi); 2778 if (removed) 2779 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4); 2780 2781 return (0); 2782 } 2783 2784 /* 2785 * find root of nfs 2786 */ 2787 static int 2788 nfs4_root(vfs_t *vfsp, vnode_t **vpp) 2789 { 2790 mntinfo4_t *mi; 2791 vnode_t *vp; 2792 nfs4_fname_t *mfname; 2793 servinfo4_t *svp; 2794 2795 mi = VFTOMI4(vfsp); 2796 2797 if (nfs_zone() != mi->mi_zone) 2798 return (EPERM); 2799 2800 svp = mi->mi_curr_serv; 2801 if (svp) { 2802 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 2803 if (svp->sv_flags & SV4_ROOT_STALE) { 2804 nfs_rw_exit(&svp->sv_lock); 2805 2806 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 2807 if (svp->sv_flags & SV4_ROOT_STALE) { 2808 svp->sv_flags &= ~SV4_ROOT_STALE; 2809 nfs_rw_exit(&svp->sv_lock); 2810 return (ENOENT); 2811 } 2812 nfs_rw_exit(&svp->sv_lock); 2813 } else 2814 nfs_rw_exit(&svp->sv_lock); 2815 } 2816 2817 mfname = mi->mi_fname; 2818 fn_hold(mfname); 2819 vp = makenfs4node_by_fh(mi->mi_rootfh, NULL, &mfname, NULL, 2820 VFTOMI4(vfsp), CRED(), gethrtime()); 2821 2822 if (VTOR4(vp)->r_flags & R4STALE) { 2823 VN_RELE(vp); 2824 return (ENOENT); 2825 } 2826 2827 ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type); 2828 2829 vp->v_type = mi->mi_type; 2830 2831 *vpp = vp; 2832 2833 return (0); 2834 } 2835 2836 static int 2837 nfs4_statfs_otw(vnode_t *vp, struct statvfs64 *sbp, cred_t *cr) 2838 { 2839 int error; 2840 nfs4_ga_res_t gar; 2841 nfs4_ga_ext_res_t ger; 2842 2843 gar.n4g_ext_res = &ger; 2844 2845 if (error = nfs4_attr_otw(vp, TAG_FSINFO, &gar, 2846 NFS4_STATFS_ATTR_MASK, cr)) 2847 return (error); 2848 2849 *sbp = gar.n4g_ext_res->n4g_sb; 2850 2851 return (0); 2852 } 2853 2854 /* 2855 * Get file system statistics. 2856 */ 2857 static int 2858 nfs4_statvfs(vfs_t *vfsp, struct statvfs64 *sbp) 2859 { 2860 int error; 2861 vnode_t *vp; 2862 cred_t *cr; 2863 2864 error = nfs4_root(vfsp, &vp); 2865 if (error) 2866 return (error); 2867 2868 cr = CRED(); 2869 2870 error = nfs4_statfs_otw(vp, sbp, cr); 2871 if (!error) { 2872 (void) strncpy(sbp->f_basetype, 2873 vfssw[vfsp->vfs_fstype].vsw_name, FSTYPSZ); 2874 sbp->f_flag = vf_to_stf(vfsp->vfs_flag); 2875 } else { 2876 nfs4_purge_stale_fh(error, vp, cr); 2877 } 2878 2879 VN_RELE(vp); 2880 2881 return (error); 2882 } 2883 2884 static kmutex_t nfs4_syncbusy; 2885 2886 /* 2887 * Flush dirty nfs files for file system vfsp. 2888 * If vfsp == NULL, all nfs files are flushed. 2889 * 2890 * SYNC_CLOSE in flag is passed to us to 2891 * indicate that we are shutting down and or 2892 * rebooting. 2893 */ 2894 static int 2895 nfs4_sync(vfs_t *vfsp, short flag, cred_t *cr) 2896 { 2897 /* 2898 * Cross-zone calls are OK here, since this translates to a 2899 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone. 2900 */ 2901 if (!(flag & SYNC_ATTR) && mutex_tryenter(&nfs4_syncbusy) != 0) { 2902 r4flush(vfsp, cr); 2903 mutex_exit(&nfs4_syncbusy); 2904 } 2905 2906 /* 2907 * if SYNC_CLOSE is set then we know that 2908 * the system is rebooting, mark the mntinfo 2909 * for later examination. 2910 */ 2911 if (vfsp && (flag & SYNC_CLOSE)) { 2912 mntinfo4_t *mi; 2913 2914 mi = VFTOMI4(vfsp); 2915 if (!(mi->mi_flags & MI4_SHUTDOWN)) { 2916 mutex_enter(&mi->mi_lock); 2917 mi->mi_flags |= MI4_SHUTDOWN; 2918 mutex_exit(&mi->mi_lock); 2919 } 2920 } 2921 return (0); 2922 } 2923 2924 /* 2925 * vget is difficult, if not impossible, to support in v4 because we don't 2926 * know the parent directory or name, which makes it impossible to create a 2927 * useful shadow vnode. And we need the shadow vnode for things like 2928 * OPEN. 2929 */ 2930 2931 /* ARGSUSED */ 2932 /* 2933 * XXX Check nfs4_vget_pseudo() for dependency. 2934 */ 2935 static int 2936 nfs4_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 2937 { 2938 return (EREMOTE); 2939 } 2940 2941 /* 2942 * nfs4_mountroot get called in the case where we are diskless booting. All 2943 * we need from here is the ability to get the server info and from there we 2944 * can simply call nfs4_rootvp. 2945 */ 2946 /* ARGSUSED */ 2947 static int 2948 nfs4_mountroot(vfs_t *vfsp, whymountroot_t why) 2949 { 2950 vnode_t *rtvp; 2951 char root_hostname[SYS_NMLN+1]; 2952 struct servinfo4 *svp; 2953 int error; 2954 int vfsflags; 2955 size_t size; 2956 char *root_path; 2957 struct pathname pn; 2958 char *name; 2959 cred_t *cr; 2960 mntinfo4_t *mi; 2961 struct nfs_args args; /* nfs mount arguments */ 2962 static char token[10]; 2963 nfs4_error_t n4e; 2964 2965 bzero(&args, sizeof (args)); 2966 2967 /* do this BEFORE getfile which causes xid stamps to be initialized */ 2968 clkset(-1L); /* hack for now - until we get time svc? */ 2969 2970 if (why == ROOT_REMOUNT) { 2971 /* 2972 * Shouldn't happen. 2973 */ 2974 panic("nfs4_mountroot: why == ROOT_REMOUNT"); 2975 } 2976 2977 if (why == ROOT_UNMOUNT) { 2978 /* 2979 * Nothing to do for NFS. 2980 */ 2981 return (0); 2982 } 2983 2984 /* 2985 * why == ROOT_INIT 2986 */ 2987 2988 name = token; 2989 *name = 0; 2990 (void) getfsname("root", name, sizeof (token)); 2991 2992 pn_alloc(&pn); 2993 root_path = pn.pn_path; 2994 2995 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP); 2996 nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL); 2997 svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP); 2998 svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 2999 svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 3000 3001 /* 3002 * Get server address 3003 * Get the root path 3004 * Get server's transport 3005 * Get server's hostname 3006 * Get options 3007 */ 3008 args.addr = &svp->sv_addr; 3009 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 3010 args.fh = (char *)&svp->sv_fhandle; 3011 args.knconf = svp->sv_knconf; 3012 args.hostname = root_hostname; 3013 vfsflags = 0; 3014 if (error = mount_root(*name ? name : "root", root_path, NFS_V4, 3015 &args, &vfsflags)) { 3016 if (error == EPROTONOSUPPORT) 3017 nfs_cmn_err(error, CE_WARN, "nfs4_mountroot: " 3018 "mount_root failed: server doesn't support NFS V4"); 3019 else 3020 nfs_cmn_err(error, CE_WARN, 3021 "nfs4_mountroot: mount_root failed: %m"); 3022 nfs_rw_exit(&svp->sv_lock); 3023 sv4_free(svp); 3024 pn_free(&pn); 3025 return (error); 3026 } 3027 nfs_rw_exit(&svp->sv_lock); 3028 svp->sv_hostnamelen = (int)(strlen(root_hostname) + 1); 3029 svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP); 3030 (void) strcpy(svp->sv_hostname, root_hostname); 3031 3032 svp->sv_pathlen = (int)(strlen(root_path) + 1); 3033 svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP); 3034 (void) strcpy(svp->sv_path, root_path); 3035 3036 /* 3037 * Force root partition to always be mounted with AUTH_UNIX for now 3038 */ 3039 svp->sv_secdata = kmem_alloc(sizeof (*svp->sv_secdata), KM_SLEEP); 3040 svp->sv_secdata->secmod = AUTH_UNIX; 3041 svp->sv_secdata->rpcflavor = AUTH_UNIX; 3042 svp->sv_secdata->data = NULL; 3043 3044 cr = crgetcred(); 3045 rtvp = NULL; 3046 3047 error = nfs4rootvp(&rtvp, vfsp, svp, args.flags, cr, global_zone); 3048 3049 if (error) { 3050 crfree(cr); 3051 pn_free(&pn); 3052 sv4_free(svp); 3053 return (error); 3054 } 3055 3056 mi = VTOMI4(rtvp); 3057 3058 /* 3059 * Send client id to the server, if necessary 3060 */ 3061 nfs4_error_zinit(&n4e); 3062 nfs4setclientid(mi, cr, FALSE, &n4e); 3063 error = n4e.error; 3064 3065 crfree(cr); 3066 3067 if (error) { 3068 pn_free(&pn); 3069 goto errout; 3070 } 3071 3072 error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, &args); 3073 if (error) { 3074 nfs_cmn_err(error, CE_WARN, 3075 "nfs4_mountroot: invalid root mount options"); 3076 pn_free(&pn); 3077 goto errout; 3078 } 3079 3080 (void) vfs_lock_wait(vfsp); 3081 vfs_add(NULL, vfsp, vfsflags); 3082 vfs_unlock(vfsp); 3083 3084 size = strlen(svp->sv_hostname); 3085 (void) strcpy(rootfs.bo_name, svp->sv_hostname); 3086 rootfs.bo_name[size] = ':'; 3087 (void) strcpy(&rootfs.bo_name[size + 1], root_path); 3088 3089 pn_free(&pn); 3090 3091 errout: 3092 if (error) { 3093 sv4_free(svp); 3094 nfs4_async_stop(vfsp); 3095 nfs4_async_manager_stop(vfsp); 3096 } 3097 3098 if (rtvp != NULL) 3099 VN_RELE(rtvp); 3100 3101 return (error); 3102 } 3103 3104 /* 3105 * Initialization routine for VFS routines. Should only be called once 3106 */ 3107 int 3108 nfs4_vfsinit(void) 3109 { 3110 mutex_init(&nfs4_syncbusy, NULL, MUTEX_DEFAULT, NULL); 3111 nfs4setclientid_init(); 3112 nfs4_ephemeral_init(); 3113 return (0); 3114 } 3115 3116 void 3117 nfs4_vfsfini(void) 3118 { 3119 nfs4_ephemeral_fini(); 3120 nfs4setclientid_fini(); 3121 mutex_destroy(&nfs4_syncbusy); 3122 } 3123 3124 void 3125 nfs4_freevfs(vfs_t *vfsp) 3126 { 3127 mntinfo4_t *mi; 3128 3129 /* need to release the initial hold */ 3130 mi = VFTOMI4(vfsp); 3131 3132 /* 3133 * At this point, we can no longer reference the vfs 3134 * and need to inform other holders of the reference 3135 * to the mntinfo4_t. 3136 */ 3137 mi->mi_vfsp = NULL; 3138 3139 MI4_RELE(mi); 3140 } 3141 3142 /* 3143 * Client side SETCLIENTID and SETCLIENTID_CONFIRM 3144 */ 3145 struct nfs4_server nfs4_server_lst = 3146 { &nfs4_server_lst, &nfs4_server_lst }; 3147 3148 kmutex_t nfs4_server_lst_lock; 3149 3150 static void 3151 nfs4setclientid_init(void) 3152 { 3153 mutex_init(&nfs4_server_lst_lock, NULL, MUTEX_DEFAULT, NULL); 3154 } 3155 3156 static void 3157 nfs4setclientid_fini(void) 3158 { 3159 mutex_destroy(&nfs4_server_lst_lock); 3160 } 3161 3162 int nfs4_retry_sclid_delay = NFS4_RETRY_SCLID_DELAY; 3163 int nfs4_num_sclid_retries = NFS4_NUM_SCLID_RETRIES; 3164 3165 /* 3166 * Set the clientid for the server for "mi". No-op if the clientid is 3167 * already set. 3168 * 3169 * The recovery boolean should be set to TRUE if this function was called 3170 * by the recovery code, and FALSE otherwise. This is used to determine 3171 * if we need to call nfs4_start/end_op as well as grab the mi_recovlock 3172 * for adding a mntinfo4_t to a nfs4_server_t. 3173 * 3174 * Error is returned via 'n4ep'. If there was a 'n4ep->stat' error, then 3175 * 'n4ep->error' is set to geterrno4(n4ep->stat). 3176 */ 3177 void 3178 nfs4setclientid(mntinfo4_t *mi, cred_t *cr, bool_t recovery, nfs4_error_t *n4ep) 3179 { 3180 struct nfs4_server *np; 3181 struct servinfo4 *svp = mi->mi_curr_serv; 3182 nfs4_recov_state_t recov_state; 3183 int num_retries = 0; 3184 bool_t retry; 3185 cred_t *lcr = NULL; 3186 int retry_inuse = 1; /* only retry once on NFS4ERR_CLID_INUSE */ 3187 time_t lease_time = 0; 3188 3189 recov_state.rs_flags = 0; 3190 recov_state.rs_num_retry_despite_err = 0; 3191 ASSERT(n4ep != NULL); 3192 3193 recov_retry: 3194 retry = FALSE; 3195 nfs4_error_zinit(n4ep); 3196 if (!recovery) 3197 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 0); 3198 3199 mutex_enter(&nfs4_server_lst_lock); 3200 np = servinfo4_to_nfs4_server(svp); /* This locks np if it is found */ 3201 mutex_exit(&nfs4_server_lst_lock); 3202 if (!np) { 3203 struct nfs4_server *tnp; 3204 np = new_nfs4_server(svp, cr); 3205 mutex_enter(&np->s_lock); 3206 3207 mutex_enter(&nfs4_server_lst_lock); 3208 tnp = servinfo4_to_nfs4_server(svp); 3209 if (tnp) { 3210 /* 3211 * another thread snuck in and put server on list. 3212 * since we aren't adding it to the nfs4_server_list 3213 * we need to set the ref count to 0 and destroy it. 3214 */ 3215 np->s_refcnt = 0; 3216 destroy_nfs4_server(np); 3217 np = tnp; 3218 } else { 3219 /* 3220 * do not give list a reference until everything 3221 * succeeds 3222 */ 3223 insque(np, &nfs4_server_lst); 3224 } 3225 mutex_exit(&nfs4_server_lst_lock); 3226 } 3227 ASSERT(MUTEX_HELD(&np->s_lock)); 3228 /* 3229 * If we find the server already has N4S_CLIENTID_SET, then 3230 * just return, we've already done SETCLIENTID to that server 3231 */ 3232 if (np->s_flags & N4S_CLIENTID_SET) { 3233 /* add mi to np's mntinfo4_list */ 3234 nfs4_add_mi_to_server(np, mi); 3235 if (!recovery) 3236 nfs_rw_exit(&mi->mi_recovlock); 3237 mutex_exit(&np->s_lock); 3238 nfs4_server_rele(np); 3239 return; 3240 } 3241 mutex_exit(&np->s_lock); 3242 3243 3244 /* 3245 * Drop the mi_recovlock since nfs4_start_op will 3246 * acquire it again for us. 3247 */ 3248 if (!recovery) { 3249 nfs_rw_exit(&mi->mi_recovlock); 3250 3251 n4ep->error = nfs4_start_op(mi, NULL, NULL, &recov_state); 3252 if (n4ep->error) { 3253 nfs4_server_rele(np); 3254 return; 3255 } 3256 } 3257 3258 mutex_enter(&np->s_lock); 3259 while (np->s_flags & N4S_CLIENTID_PEND) { 3260 if (!cv_wait_sig(&np->s_clientid_pend, &np->s_lock)) { 3261 mutex_exit(&np->s_lock); 3262 nfs4_server_rele(np); 3263 if (!recovery) 3264 nfs4_end_op(mi, NULL, NULL, &recov_state, 3265 recovery); 3266 n4ep->error = EINTR; 3267 return; 3268 } 3269 } 3270 3271 if (np->s_flags & N4S_CLIENTID_SET) { 3272 /* XXX copied/pasted from above */ 3273 /* add mi to np's mntinfo4_list */ 3274 nfs4_add_mi_to_server(np, mi); 3275 mutex_exit(&np->s_lock); 3276 nfs4_server_rele(np); 3277 if (!recovery) 3278 nfs4_end_op(mi, NULL, NULL, &recov_state, recovery); 3279 return; 3280 } 3281 3282 /* 3283 * Reset the N4S_CB_PINGED flag. This is used to 3284 * indicate if we have received a CB_NULL from the 3285 * server. Also we reset the waiter flag. 3286 */ 3287 np->s_flags &= ~(N4S_CB_PINGED | N4S_CB_WAITER); 3288 /* any failure must now clear this flag */ 3289 np->s_flags |= N4S_CLIENTID_PEND; 3290 mutex_exit(&np->s_lock); 3291 nfs4setclientid_otw(mi, svp, cr, np, n4ep, &retry_inuse); 3292 3293 if (n4ep->error == EACCES) { 3294 /* 3295 * If the uid is set then set the creds for secure mounts 3296 * by proxy processes such as automountd. 3297 */ 3298 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 3299 if (svp->sv_secdata->uid != 0) { 3300 lcr = crdup(cr); 3301 (void) crsetugid(lcr, svp->sv_secdata->uid, 3302 crgetgid(cr)); 3303 } 3304 nfs_rw_exit(&svp->sv_lock); 3305 3306 if (lcr != NULL) { 3307 mutex_enter(&np->s_lock); 3308 crfree(np->s_cred); 3309 np->s_cred = lcr; 3310 mutex_exit(&np->s_lock); 3311 nfs4setclientid_otw(mi, svp, lcr, np, n4ep, 3312 &retry_inuse); 3313 } 3314 } 3315 mutex_enter(&np->s_lock); 3316 lease_time = np->s_lease_time; 3317 np->s_flags &= ~N4S_CLIENTID_PEND; 3318 mutex_exit(&np->s_lock); 3319 3320 if (n4ep->error != 0 || n4ep->stat != NFS4_OK) { 3321 /* 3322 * Start recovery if failover is a possibility. If 3323 * invoked by the recovery thread itself, then just 3324 * return and let it handle the failover first. NB: 3325 * recovery is not allowed if the mount is in progress 3326 * since the infrastructure is not sufficiently setup 3327 * to allow it. Just return the error (after suitable 3328 * retries). 3329 */ 3330 if (FAILOVER_MOUNT4(mi) && nfs4_try_failover(n4ep)) { 3331 (void) nfs4_start_recovery(n4ep, mi, NULL, 3332 NULL, NULL, NULL, OP_SETCLIENTID, NULL, NULL, NULL); 3333 /* 3334 * Don't retry here, just return and let 3335 * recovery take over. 3336 */ 3337 if (recovery) 3338 retry = FALSE; 3339 } else if (nfs4_rpc_retry_error(n4ep->error) || 3340 n4ep->stat == NFS4ERR_RESOURCE || 3341 n4ep->stat == NFS4ERR_STALE_CLIENTID) { 3342 3343 retry = TRUE; 3344 /* 3345 * Always retry if in recovery or once had 3346 * contact with the server (but now it's 3347 * overloaded). 3348 */ 3349 if (recovery == TRUE || 3350 n4ep->error == ETIMEDOUT || 3351 n4ep->error == ECONNRESET) 3352 num_retries = 0; 3353 } else if (retry_inuse && n4ep->error == 0 && 3354 n4ep->stat == NFS4ERR_CLID_INUSE) { 3355 retry = TRUE; 3356 num_retries = 0; 3357 } 3358 } else { 3359 /* 3360 * Since everything succeeded give the list a reference count if 3361 * it hasn't been given one by add_new_nfs4_server() or if this 3362 * is not a recovery situation in which case it is already on 3363 * the list. 3364 */ 3365 mutex_enter(&np->s_lock); 3366 if ((np->s_flags & N4S_INSERTED) == 0) { 3367 np->s_refcnt++; 3368 np->s_flags |= N4S_INSERTED; 3369 } 3370 mutex_exit(&np->s_lock); 3371 } 3372 3373 if (!recovery) 3374 nfs4_end_op(mi, NULL, NULL, &recov_state, recovery); 3375 3376 3377 if (retry && num_retries++ < nfs4_num_sclid_retries) { 3378 if (retry_inuse) { 3379 delay(SEC_TO_TICK(lease_time + nfs4_retry_sclid_delay)); 3380 retry_inuse = 0; 3381 } else 3382 delay(SEC_TO_TICK(nfs4_retry_sclid_delay)); 3383 3384 nfs4_server_rele(np); 3385 goto recov_retry; 3386 } 3387 3388 3389 if (n4ep->error == 0) 3390 n4ep->error = geterrno4(n4ep->stat); 3391 3392 /* broadcast before release in case no other threads are waiting */ 3393 cv_broadcast(&np->s_clientid_pend); 3394 nfs4_server_rele(np); 3395 } 3396 3397 int nfs4setclientid_otw_debug = 0; 3398 3399 /* 3400 * This function handles the recovery of STALE_CLIENTID for SETCLIENTID_CONFRIM, 3401 * but nothing else; the calling function must be designed to handle those 3402 * other errors. 3403 */ 3404 static void 3405 nfs4setclientid_otw(mntinfo4_t *mi, struct servinfo4 *svp, cred_t *cr, 3406 struct nfs4_server *np, nfs4_error_t *ep, int *retry_inusep) 3407 { 3408 COMPOUND4args_clnt args; 3409 COMPOUND4res_clnt res; 3410 nfs_argop4 argop[3]; 3411 SETCLIENTID4args *s_args; 3412 SETCLIENTID4resok *s_resok; 3413 int doqueue = 1; 3414 nfs4_ga_res_t *garp = NULL; 3415 timespec_t prop_time, after_time; 3416 verifier4 verf; 3417 clientid4 tmp_clientid; 3418 3419 ASSERT(!MUTEX_HELD(&np->s_lock)); 3420 3421 args.ctag = TAG_SETCLIENTID; 3422 3423 args.array = argop; 3424 args.array_len = 3; 3425 3426 /* PUTROOTFH */ 3427 argop[0].argop = OP_PUTROOTFH; 3428 3429 /* GETATTR */ 3430 argop[1].argop = OP_GETATTR; 3431 argop[1].nfs_argop4_u.opgetattr.attr_request = FATTR4_LEASE_TIME_MASK; 3432 argop[1].nfs_argop4_u.opgetattr.mi = mi; 3433 3434 /* SETCLIENTID */ 3435 argop[2].argop = OP_SETCLIENTID; 3436 3437 s_args = &argop[2].nfs_argop4_u.opsetclientid; 3438 3439 mutex_enter(&np->s_lock); 3440 3441 s_args->client.verifier = np->clidtosend.verifier; 3442 s_args->client.id_len = np->clidtosend.id_len; 3443 ASSERT(s_args->client.id_len <= NFS4_OPAQUE_LIMIT); 3444 s_args->client.id_val = np->clidtosend.id_val; 3445 3446 /* 3447 * Callback needs to happen on non-RDMA transport 3448 * Check if we have saved the original knetconfig 3449 * if so, use that instead. 3450 */ 3451 if (svp->sv_origknconf != NULL) 3452 nfs4_cb_args(np, svp->sv_origknconf, s_args); 3453 else 3454 nfs4_cb_args(np, svp->sv_knconf, s_args); 3455 3456 mutex_exit(&np->s_lock); 3457 3458 rfs4call(mi, &args, &res, cr, &doqueue, 0, ep); 3459 3460 if (ep->error) 3461 return; 3462 3463 /* getattr lease_time res */ 3464 if ((res.array_len >= 2) && 3465 (res.array[1].nfs_resop4_u.opgetattr.status == NFS4_OK)) { 3466 garp = &res.array[1].nfs_resop4_u.opgetattr.ga_res; 3467 3468 #ifndef _LP64 3469 /* 3470 * The 32 bit client cannot handle a lease time greater than 3471 * (INT32_MAX/1000000). This is due to the use of the 3472 * lease_time in calls to drv_usectohz() in 3473 * nfs4_renew_lease_thread(). The problem is that 3474 * drv_usectohz() takes a time_t (which is just a long = 4 3475 * bytes) as its parameter. The lease_time is multiplied by 3476 * 1000000 to convert seconds to usecs for the parameter. If 3477 * a number bigger than (INT32_MAX/1000000) is used then we 3478 * overflow on the 32bit client. 3479 */ 3480 if (garp->n4g_ext_res->n4g_leasetime > (INT32_MAX/1000000)) { 3481 garp->n4g_ext_res->n4g_leasetime = INT32_MAX/1000000; 3482 } 3483 #endif 3484 3485 mutex_enter(&np->s_lock); 3486 np->s_lease_time = garp->n4g_ext_res->n4g_leasetime; 3487 3488 /* 3489 * Keep track of the lease period for the mi's 3490 * mi_msg_list. We need an appropiate time 3491 * bound to associate past facts with a current 3492 * event. The lease period is perfect for this. 3493 */ 3494 mutex_enter(&mi->mi_msg_list_lock); 3495 mi->mi_lease_period = np->s_lease_time; 3496 mutex_exit(&mi->mi_msg_list_lock); 3497 mutex_exit(&np->s_lock); 3498 } 3499 3500 3501 if (res.status == NFS4ERR_CLID_INUSE) { 3502 clientaddr4 *clid_inuse; 3503 3504 if (!(*retry_inusep)) { 3505 clid_inuse = &res.array->nfs_resop4_u. 3506 opsetclientid.SETCLIENTID4res_u.client_using; 3507 3508 zcmn_err(mi->mi_zone->zone_id, CE_NOTE, 3509 "NFS4 mount (SETCLIENTID failed)." 3510 " nfs4_client_id.id is in" 3511 "use already by: r_netid<%s> r_addr<%s>", 3512 clid_inuse->r_netid, clid_inuse->r_addr); 3513 } 3514 3515 /* 3516 * XXX - The client should be more robust in its 3517 * handling of clientid in use errors (regen another 3518 * clientid and try again?) 3519 */ 3520 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3521 return; 3522 } 3523 3524 if (res.status) { 3525 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3526 return; 3527 } 3528 3529 s_resok = &res.array[2].nfs_resop4_u. 3530 opsetclientid.SETCLIENTID4res_u.resok4; 3531 3532 tmp_clientid = s_resok->clientid; 3533 3534 verf = s_resok->setclientid_confirm; 3535 3536 #ifdef DEBUG 3537 if (nfs4setclientid_otw_debug) { 3538 union { 3539 clientid4 clientid; 3540 int foo[2]; 3541 } cid; 3542 3543 cid.clientid = s_resok->clientid; 3544 3545 zcmn_err(mi->mi_zone->zone_id, CE_NOTE, 3546 "nfs4setclientid_otw: OK, clientid = %x,%x, " 3547 "verifier = %" PRIx64 "\n", cid.foo[0], cid.foo[1], verf); 3548 } 3549 #endif 3550 3551 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3552 3553 /* Confirm the client id and get the lease_time attribute */ 3554 3555 args.ctag = TAG_SETCLIENTID_CF; 3556 3557 args.array = argop; 3558 args.array_len = 1; 3559 3560 argop[0].argop = OP_SETCLIENTID_CONFIRM; 3561 3562 argop[0].nfs_argop4_u.opsetclientid_confirm.clientid = tmp_clientid; 3563 argop[0].nfs_argop4_u.opsetclientid_confirm.setclientid_confirm = verf; 3564 3565 /* used to figure out RTT for np */ 3566 gethrestime(&prop_time); 3567 3568 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4setlientid_otw: " 3569 "start time: %ld sec %ld nsec", prop_time.tv_sec, 3570 prop_time.tv_nsec)); 3571 3572 rfs4call(mi, &args, &res, cr, &doqueue, 0, ep); 3573 3574 gethrestime(&after_time); 3575 mutex_enter(&np->s_lock); 3576 np->propagation_delay.tv_sec = 3577 MAX(1, after_time.tv_sec - prop_time.tv_sec); 3578 mutex_exit(&np->s_lock); 3579 3580 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4setlcientid_otw: " 3581 "finish time: %ld sec ", after_time.tv_sec)); 3582 3583 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4setclientid_otw: " 3584 "propagation delay set to %ld sec", 3585 np->propagation_delay.tv_sec)); 3586 3587 if (ep->error) 3588 return; 3589 3590 if (res.status == NFS4ERR_CLID_INUSE) { 3591 clientaddr4 *clid_inuse; 3592 3593 if (!(*retry_inusep)) { 3594 clid_inuse = &res.array->nfs_resop4_u. 3595 opsetclientid.SETCLIENTID4res_u.client_using; 3596 3597 zcmn_err(mi->mi_zone->zone_id, CE_NOTE, 3598 "SETCLIENTID_CONFIRM failed. " 3599 "nfs4_client_id.id is in use already by: " 3600 "r_netid<%s> r_addr<%s>", 3601 clid_inuse->r_netid, clid_inuse->r_addr); 3602 } 3603 3604 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3605 return; 3606 } 3607 3608 if (res.status) { 3609 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3610 return; 3611 } 3612 3613 mutex_enter(&np->s_lock); 3614 np->clientid = tmp_clientid; 3615 np->s_flags |= N4S_CLIENTID_SET; 3616 3617 /* Add mi to np's mntinfo4 list */ 3618 nfs4_add_mi_to_server(np, mi); 3619 3620 if (np->lease_valid == NFS4_LEASE_NOT_STARTED) { 3621 /* 3622 * Start lease management thread. 3623 * Keep trying until we succeed. 3624 */ 3625 3626 np->s_refcnt++; /* pass reference to thread */ 3627 (void) zthread_create(NULL, 0, nfs4_renew_lease_thread, np, 0, 3628 minclsyspri); 3629 } 3630 mutex_exit(&np->s_lock); 3631 3632 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3633 } 3634 3635 /* 3636 * Add mi to sp's mntinfo4_list if it isn't already in the list. Makes 3637 * mi's clientid the same as sp's. 3638 * Assumes sp is locked down. 3639 */ 3640 void 3641 nfs4_add_mi_to_server(nfs4_server_t *sp, mntinfo4_t *mi) 3642 { 3643 mntinfo4_t *tmi; 3644 int in_list = 0; 3645 3646 ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) || 3647 nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER)); 3648 ASSERT(sp != &nfs4_server_lst); 3649 ASSERT(MUTEX_HELD(&sp->s_lock)); 3650 3651 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3652 "nfs4_add_mi_to_server: add mi %p to sp %p", 3653 (void*)mi, (void*)sp)); 3654 3655 for (tmi = sp->mntinfo4_list; 3656 tmi != NULL; 3657 tmi = tmi->mi_clientid_next) { 3658 if (tmi == mi) { 3659 NFS4_DEBUG(nfs4_client_lease_debug, 3660 (CE_NOTE, 3661 "nfs4_add_mi_to_server: mi in list")); 3662 in_list = 1; 3663 } 3664 } 3665 3666 /* 3667 * First put a hold on the mntinfo4's vfsp so that references via 3668 * mntinfo4_list will be valid. 3669 */ 3670 if (!in_list) 3671 VFS_HOLD(mi->mi_vfsp); 3672 3673 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4_add_mi_to_server: " 3674 "hold vfs %p for mi: %p", (void*)mi->mi_vfsp, (void*)mi)); 3675 3676 if (!in_list) { 3677 if (sp->mntinfo4_list) 3678 sp->mntinfo4_list->mi_clientid_prev = mi; 3679 mi->mi_clientid_next = sp->mntinfo4_list; 3680 mi->mi_srv = sp; 3681 sp->mntinfo4_list = mi; 3682 mi->mi_srvsettime = gethrestime_sec(); 3683 mi->mi_srvset_cnt++; 3684 } 3685 3686 /* set mi's clientid to that of sp's for later matching */ 3687 mi->mi_clientid = sp->clientid; 3688 3689 /* 3690 * Update the clientid for any other mi's belonging to sp. This 3691 * must be done here while we hold sp->s_lock, so that 3692 * find_nfs4_server() continues to work. 3693 */ 3694 3695 for (tmi = sp->mntinfo4_list; 3696 tmi != NULL; 3697 tmi = tmi->mi_clientid_next) { 3698 if (tmi != mi) { 3699 tmi->mi_clientid = sp->clientid; 3700 } 3701 } 3702 } 3703 3704 /* 3705 * Remove the mi from sp's mntinfo4_list and release its reference. 3706 * Exception: if mi still has open files, flag it for later removal (when 3707 * all the files are closed). 3708 * 3709 * If this is the last mntinfo4 in sp's list then tell the lease renewal 3710 * thread to exit. 3711 */ 3712 static void 3713 nfs4_remove_mi_from_server_nolock(mntinfo4_t *mi, nfs4_server_t *sp) 3714 { 3715 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3716 "nfs4_remove_mi_from_server_nolock: remove mi %p from sp %p", 3717 (void*)mi, (void*)sp)); 3718 3719 ASSERT(sp != NULL); 3720 ASSERT(MUTEX_HELD(&sp->s_lock)); 3721 ASSERT(mi->mi_open_files >= 0); 3722 3723 /* 3724 * First make sure this mntinfo4 can be taken off of the list, 3725 * ie: it doesn't have any open files remaining. 3726 */ 3727 if (mi->mi_open_files > 0) { 3728 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3729 "nfs4_remove_mi_from_server_nolock: don't " 3730 "remove mi since it still has files open")); 3731 3732 mutex_enter(&mi->mi_lock); 3733 mi->mi_flags |= MI4_REMOVE_ON_LAST_CLOSE; 3734 mutex_exit(&mi->mi_lock); 3735 return; 3736 } 3737 3738 VFS_HOLD(mi->mi_vfsp); 3739 remove_mi(sp, mi); 3740 VFS_RELE(mi->mi_vfsp); 3741 3742 if (sp->mntinfo4_list == NULL) { 3743 /* last fs unmounted, kill the thread */ 3744 NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, 3745 "remove_mi_from_nfs4_server_nolock: kill the thread")); 3746 nfs4_mark_srv_dead(sp); 3747 } 3748 } 3749 3750 /* 3751 * Remove mi from sp's mntinfo4_list and release the vfs reference. 3752 */ 3753 static void 3754 remove_mi(nfs4_server_t *sp, mntinfo4_t *mi) 3755 { 3756 ASSERT(MUTEX_HELD(&sp->s_lock)); 3757 3758 /* 3759 * We release a reference, and the caller must still have a 3760 * reference. 3761 */ 3762 ASSERT(mi->mi_vfsp->vfs_count >= 2); 3763 3764 if (mi->mi_clientid_prev) { 3765 mi->mi_clientid_prev->mi_clientid_next = mi->mi_clientid_next; 3766 } else { 3767 /* This is the first mi in sp's mntinfo4_list */ 3768 /* 3769 * Make sure the first mntinfo4 in the list is the actual 3770 * mntinfo4 passed in. 3771 */ 3772 ASSERT(sp->mntinfo4_list == mi); 3773 3774 sp->mntinfo4_list = mi->mi_clientid_next; 3775 } 3776 if (mi->mi_clientid_next) 3777 mi->mi_clientid_next->mi_clientid_prev = mi->mi_clientid_prev; 3778 3779 /* Now mark the mntinfo4's links as being removed */ 3780 mi->mi_clientid_prev = mi->mi_clientid_next = NULL; 3781 mi->mi_srv = NULL; 3782 mi->mi_srvset_cnt++; 3783 3784 VFS_RELE(mi->mi_vfsp); 3785 } 3786 3787 /* 3788 * Free all the entries in sp's mntinfo4_list. 3789 */ 3790 static void 3791 remove_all_mi(nfs4_server_t *sp) 3792 { 3793 mntinfo4_t *mi; 3794 3795 ASSERT(MUTEX_HELD(&sp->s_lock)); 3796 3797 while (sp->mntinfo4_list != NULL) { 3798 mi = sp->mntinfo4_list; 3799 /* 3800 * Grab a reference in case there is only one left (which 3801 * remove_mi() frees). 3802 */ 3803 VFS_HOLD(mi->mi_vfsp); 3804 remove_mi(sp, mi); 3805 VFS_RELE(mi->mi_vfsp); 3806 } 3807 } 3808 3809 /* 3810 * Remove the mi from sp's mntinfo4_list as above, and rele the vfs. 3811 * 3812 * This version can be called with a null nfs4_server_t arg, 3813 * and will either find the right one and handle locking, or 3814 * do nothing because the mi wasn't added to an sp's mntinfo4_list. 3815 */ 3816 void 3817 nfs4_remove_mi_from_server(mntinfo4_t *mi, nfs4_server_t *esp) 3818 { 3819 nfs4_server_t *sp; 3820 3821 if (esp) { 3822 nfs4_remove_mi_from_server_nolock(mi, esp); 3823 return; 3824 } 3825 3826 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 0); 3827 if (sp = find_nfs4_server_all(mi, 1)) { 3828 nfs4_remove_mi_from_server_nolock(mi, sp); 3829 mutex_exit(&sp->s_lock); 3830 nfs4_server_rele(sp); 3831 } 3832 nfs_rw_exit(&mi->mi_recovlock); 3833 } 3834 3835 /* 3836 * Return TRUE if the given server has any non-unmounted filesystems. 3837 */ 3838 3839 bool_t 3840 nfs4_fs_active(nfs4_server_t *sp) 3841 { 3842 mntinfo4_t *mi; 3843 3844 ASSERT(MUTEX_HELD(&sp->s_lock)); 3845 3846 for (mi = sp->mntinfo4_list; mi != NULL; mi = mi->mi_clientid_next) { 3847 if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED)) 3848 return (TRUE); 3849 } 3850 3851 return (FALSE); 3852 } 3853 3854 /* 3855 * Mark sp as finished and notify any waiters. 3856 */ 3857 3858 void 3859 nfs4_mark_srv_dead(nfs4_server_t *sp) 3860 { 3861 ASSERT(MUTEX_HELD(&sp->s_lock)); 3862 3863 sp->s_thread_exit = NFS4_THREAD_EXIT; 3864 cv_broadcast(&sp->cv_thread_exit); 3865 } 3866 3867 /* 3868 * Create a new nfs4_server_t structure. 3869 * Returns new node unlocked and not in list, but with a reference count of 3870 * 1. 3871 */ 3872 struct nfs4_server * 3873 new_nfs4_server(struct servinfo4 *svp, cred_t *cr) 3874 { 3875 struct nfs4_server *np; 3876 timespec_t tt; 3877 union { 3878 struct { 3879 uint32_t sec; 3880 uint32_t subsec; 3881 } un_curtime; 3882 verifier4 un_verifier; 3883 } nfs4clientid_verifier; 3884 /* 3885 * We change this ID string carefully and with the Solaris 3886 * NFS server behaviour in mind. "+referrals" indicates 3887 * a client that can handle an NFSv4 referral. 3888 */ 3889 char id_val[] = "Solaris: %s, NFSv4 kernel client +referrals"; 3890 int len; 3891 3892 np = kmem_zalloc(sizeof (struct nfs4_server), KM_SLEEP); 3893 np->saddr.len = svp->sv_addr.len; 3894 np->saddr.maxlen = svp->sv_addr.maxlen; 3895 np->saddr.buf = kmem_alloc(svp->sv_addr.maxlen, KM_SLEEP); 3896 bcopy(svp->sv_addr.buf, np->saddr.buf, svp->sv_addr.len); 3897 np->s_refcnt = 1; 3898 3899 /* 3900 * Build the nfs_client_id4 for this server mount. Ensure 3901 * the verifier is useful and that the identification is 3902 * somehow based on the server's address for the case of 3903 * multi-homed servers. 3904 */ 3905 nfs4clientid_verifier.un_verifier = 0; 3906 gethrestime(&tt); 3907 nfs4clientid_verifier.un_curtime.sec = (uint32_t)tt.tv_sec; 3908 nfs4clientid_verifier.un_curtime.subsec = (uint32_t)tt.tv_nsec; 3909 np->clidtosend.verifier = nfs4clientid_verifier.un_verifier; 3910 3911 /* 3912 * calculate the length of the opaque identifier. Subtract 2 3913 * for the "%s" and add the traditional +1 for null 3914 * termination. 3915 */ 3916 len = strlen(id_val) - 2 + strlen(uts_nodename()) + 1; 3917 np->clidtosend.id_len = len + np->saddr.maxlen; 3918 3919 np->clidtosend.id_val = kmem_alloc(np->clidtosend.id_len, KM_SLEEP); 3920 (void) sprintf(np->clidtosend.id_val, id_val, uts_nodename()); 3921 bcopy(np->saddr.buf, &np->clidtosend.id_val[len], np->saddr.len); 3922 3923 np->s_flags = 0; 3924 np->mntinfo4_list = NULL; 3925 /* save cred for issuing rfs4calls inside the renew thread */ 3926 crhold(cr); 3927 np->s_cred = cr; 3928 cv_init(&np->cv_thread_exit, NULL, CV_DEFAULT, NULL); 3929 mutex_init(&np->s_lock, NULL, MUTEX_DEFAULT, NULL); 3930 nfs_rw_init(&np->s_recovlock, NULL, RW_DEFAULT, NULL); 3931 list_create(&np->s_deleg_list, sizeof (rnode4_t), 3932 offsetof(rnode4_t, r_deleg_link)); 3933 np->s_thread_exit = 0; 3934 np->state_ref_count = 0; 3935 np->lease_valid = NFS4_LEASE_NOT_STARTED; 3936 cv_init(&np->s_cv_otw_count, NULL, CV_DEFAULT, NULL); 3937 cv_init(&np->s_clientid_pend, NULL, CV_DEFAULT, NULL); 3938 np->s_otw_call_count = 0; 3939 cv_init(&np->wait_cb_null, NULL, CV_DEFAULT, NULL); 3940 np->zoneid = getzoneid(); 3941 np->zone_globals = nfs4_get_callback_globals(); 3942 ASSERT(np->zone_globals != NULL); 3943 return (np); 3944 } 3945 3946 /* 3947 * Create a new nfs4_server_t structure and add it to the list. 3948 * Returns new node locked; reference must eventually be freed. 3949 */ 3950 static struct nfs4_server * 3951 add_new_nfs4_server(struct servinfo4 *svp, cred_t *cr) 3952 { 3953 nfs4_server_t *sp; 3954 3955 ASSERT(MUTEX_HELD(&nfs4_server_lst_lock)); 3956 sp = new_nfs4_server(svp, cr); 3957 mutex_enter(&sp->s_lock); 3958 insque(sp, &nfs4_server_lst); 3959 sp->s_refcnt++; /* list gets a reference */ 3960 sp->s_flags |= N4S_INSERTED; 3961 sp->clientid = 0; 3962 return (sp); 3963 } 3964 3965 int nfs4_server_t_debug = 0; 3966 3967 #ifdef lint 3968 extern void 3969 dumpnfs4slist(char *, mntinfo4_t *, clientid4, servinfo4_t *); 3970 #endif 3971 3972 #ifndef lint 3973 #ifdef DEBUG 3974 void 3975 dumpnfs4slist(char *txt, mntinfo4_t *mi, clientid4 clientid, servinfo4_t *srv_p) 3976 { 3977 int hash16(void *p, int len); 3978 nfs4_server_t *np; 3979 3980 NFS4_DEBUG(nfs4_server_t_debug, (CE_NOTE, 3981 "dumping nfs4_server_t list in %s", txt)); 3982 NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT, 3983 "mi 0x%p, want clientid %llx, addr %d/%04X", 3984 mi, (longlong_t)clientid, srv_p->sv_addr.len, 3985 hash16((void *)srv_p->sv_addr.buf, srv_p->sv_addr.len))); 3986 for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; 3987 np = np->forw) { 3988 NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT, 3989 "node 0x%p, clientid %llx, addr %d/%04X, cnt %d", 3990 np, (longlong_t)np->clientid, np->saddr.len, 3991 hash16((void *)np->saddr.buf, np->saddr.len), 3992 np->state_ref_count)); 3993 if (np->saddr.len == srv_p->sv_addr.len && 3994 bcmp(np->saddr.buf, srv_p->sv_addr.buf, 3995 np->saddr.len) == 0) 3996 NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT, 3997 " - address matches")); 3998 if (np->clientid == clientid || np->clientid == 0) 3999 NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT, 4000 " - clientid matches")); 4001 if (np->s_thread_exit != NFS4_THREAD_EXIT) 4002 NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT, 4003 " - thread not exiting")); 4004 } 4005 delay(hz); 4006 } 4007 #endif 4008 #endif 4009 4010 4011 /* 4012 * Move a mntinfo4_t from one server list to another. 4013 * Locking of the two nfs4_server_t nodes will be done in list order. 4014 * 4015 * Returns NULL if the current nfs4_server_t for the filesystem could not 4016 * be found (e.g., due to forced unmount). Otherwise returns a reference 4017 * to the new nfs4_server_t, which must eventually be freed. 4018 */ 4019 nfs4_server_t * 4020 nfs4_move_mi(mntinfo4_t *mi, servinfo4_t *old, servinfo4_t *new) 4021 { 4022 nfs4_server_t *p, *op = NULL, *np = NULL; 4023 int num_open; 4024 zoneid_t zoneid = nfs_zoneid(); 4025 4026 ASSERT(nfs_zone() == mi->mi_zone); 4027 4028 mutex_enter(&nfs4_server_lst_lock); 4029 #ifdef DEBUG 4030 if (nfs4_server_t_debug) 4031 dumpnfs4slist("nfs4_move_mi", mi, (clientid4)0, new); 4032 #endif 4033 for (p = nfs4_server_lst.forw; p != &nfs4_server_lst; p = p->forw) { 4034 if (p->zoneid != zoneid) 4035 continue; 4036 if (p->saddr.len == old->sv_addr.len && 4037 bcmp(p->saddr.buf, old->sv_addr.buf, p->saddr.len) == 0 && 4038 p->s_thread_exit != NFS4_THREAD_EXIT) { 4039 op = p; 4040 mutex_enter(&op->s_lock); 4041 op->s_refcnt++; 4042 } 4043 if (p->saddr.len == new->sv_addr.len && 4044 bcmp(p->saddr.buf, new->sv_addr.buf, p->saddr.len) == 0 && 4045 p->s_thread_exit != NFS4_THREAD_EXIT) { 4046 np = p; 4047 mutex_enter(&np->s_lock); 4048 } 4049 if (op != NULL && np != NULL) 4050 break; 4051 } 4052 if (op == NULL) { 4053 /* 4054 * Filesystem has been forcibly unmounted. Bail out. 4055 */ 4056 if (np != NULL) 4057 mutex_exit(&np->s_lock); 4058 mutex_exit(&nfs4_server_lst_lock); 4059 return (NULL); 4060 } 4061 if (np != NULL) { 4062 np->s_refcnt++; 4063 } else { 4064 #ifdef DEBUG 4065 NFS4_DEBUG(nfs4_client_failover_debug, (CE_NOTE, 4066 "nfs4_move_mi: no target nfs4_server, will create.")); 4067 #endif 4068 np = add_new_nfs4_server(new, kcred); 4069 } 4070 mutex_exit(&nfs4_server_lst_lock); 4071 4072 NFS4_DEBUG(nfs4_client_failover_debug, (CE_NOTE, 4073 "nfs4_move_mi: for mi 0x%p, " 4074 "old servinfo4 0x%p, new servinfo4 0x%p, " 4075 "old nfs4_server 0x%p, new nfs4_server 0x%p, ", 4076 (void*)mi, (void*)old, (void*)new, 4077 (void*)op, (void*)np)); 4078 ASSERT(op != NULL && np != NULL); 4079 4080 /* discard any delegations */ 4081 nfs4_deleg_discard(mi, op); 4082 4083 num_open = mi->mi_open_files; 4084 mi->mi_open_files = 0; 4085 op->state_ref_count -= num_open; 4086 ASSERT(op->state_ref_count >= 0); 4087 np->state_ref_count += num_open; 4088 nfs4_remove_mi_from_server_nolock(mi, op); 4089 mi->mi_open_files = num_open; 4090 NFS4_DEBUG(nfs4_client_failover_debug, (CE_NOTE, 4091 "nfs4_move_mi: mi_open_files %d, op->cnt %d, np->cnt %d", 4092 mi->mi_open_files, op->state_ref_count, np->state_ref_count)); 4093 4094 nfs4_add_mi_to_server(np, mi); 4095 4096 mutex_exit(&op->s_lock); 4097 mutex_exit(&np->s_lock); 4098 nfs4_server_rele(op); 4099 4100 return (np); 4101 } 4102 4103 /* 4104 * Need to have the nfs4_server_lst_lock. 4105 * Search the nfs4_server list to find a match on this servinfo4 4106 * based on its address. 4107 * 4108 * Returns NULL if no match is found. Otherwise returns a reference (which 4109 * must eventually be freed) to a locked nfs4_server. 4110 */ 4111 nfs4_server_t * 4112 servinfo4_to_nfs4_server(servinfo4_t *srv_p) 4113 { 4114 nfs4_server_t *np; 4115 zoneid_t zoneid = nfs_zoneid(); 4116 4117 ASSERT(MUTEX_HELD(&nfs4_server_lst_lock)); 4118 for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; np = np->forw) { 4119 if (np->zoneid == zoneid && 4120 np->saddr.len == srv_p->sv_addr.len && 4121 bcmp(np->saddr.buf, srv_p->sv_addr.buf, 4122 np->saddr.len) == 0 && 4123 np->s_thread_exit != NFS4_THREAD_EXIT) { 4124 mutex_enter(&np->s_lock); 4125 np->s_refcnt++; 4126 return (np); 4127 } 4128 } 4129 return (NULL); 4130 } 4131 4132 /* 4133 * Locks the nfs4_server down if it is found and returns a reference that 4134 * must eventually be freed. 4135 */ 4136 static nfs4_server_t * 4137 lookup_nfs4_server(nfs4_server_t *sp, int any_state) 4138 { 4139 nfs4_server_t *np; 4140 4141 mutex_enter(&nfs4_server_lst_lock); 4142 for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; np = np->forw) { 4143 mutex_enter(&np->s_lock); 4144 if (np == sp && np->s_refcnt > 0 && 4145 (np->s_thread_exit != NFS4_THREAD_EXIT || any_state)) { 4146 mutex_exit(&nfs4_server_lst_lock); 4147 np->s_refcnt++; 4148 return (np); 4149 } 4150 mutex_exit(&np->s_lock); 4151 } 4152 mutex_exit(&nfs4_server_lst_lock); 4153 4154 return (NULL); 4155 } 4156 4157 /* 4158 * The caller should be holding mi->mi_recovlock, and it should continue to 4159 * hold the lock until done with the returned nfs4_server_t. Once 4160 * mi->mi_recovlock is released, there is no guarantee that the returned 4161 * mi->nfs4_server_t will continue to correspond to mi. 4162 */ 4163 nfs4_server_t * 4164 find_nfs4_server(mntinfo4_t *mi) 4165 { 4166 ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) || 4167 nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER)); 4168 4169 return (lookup_nfs4_server(mi->mi_srv, 0)); 4170 } 4171 4172 /* 4173 * Same as above, but takes an "any_state" parameter which can be 4174 * set to 1 if the caller wishes to find nfs4_server_t's which 4175 * have been marked for termination by the exit of the renew 4176 * thread. This should only be used by operations which are 4177 * cleaning up and will not cause an OTW op. 4178 */ 4179 nfs4_server_t * 4180 find_nfs4_server_all(mntinfo4_t *mi, int any_state) 4181 { 4182 ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) || 4183 nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER)); 4184 4185 return (lookup_nfs4_server(mi->mi_srv, any_state)); 4186 } 4187 4188 /* 4189 * Lock sp, but only if it's still active (in the list and hasn't been 4190 * flagged as exiting) or 'any_state' is non-zero. 4191 * Returns TRUE if sp got locked and adds a reference to sp. 4192 */ 4193 bool_t 4194 nfs4_server_vlock(nfs4_server_t *sp, int any_state) 4195 { 4196 return (lookup_nfs4_server(sp, any_state) != NULL); 4197 } 4198 4199 /* 4200 * Release the reference to sp and destroy it if that's the last one. 4201 */ 4202 4203 void 4204 nfs4_server_rele(nfs4_server_t *sp) 4205 { 4206 mutex_enter(&sp->s_lock); 4207 ASSERT(sp->s_refcnt > 0); 4208 sp->s_refcnt--; 4209 if (sp->s_refcnt > 0) { 4210 mutex_exit(&sp->s_lock); 4211 return; 4212 } 4213 mutex_exit(&sp->s_lock); 4214 4215 mutex_enter(&nfs4_server_lst_lock); 4216 mutex_enter(&sp->s_lock); 4217 if (sp->s_refcnt > 0) { 4218 mutex_exit(&sp->s_lock); 4219 mutex_exit(&nfs4_server_lst_lock); 4220 return; 4221 } 4222 remque(sp); 4223 sp->forw = sp->back = NULL; 4224 mutex_exit(&nfs4_server_lst_lock); 4225 destroy_nfs4_server(sp); 4226 } 4227 4228 static void 4229 destroy_nfs4_server(nfs4_server_t *sp) 4230 { 4231 ASSERT(MUTEX_HELD(&sp->s_lock)); 4232 ASSERT(sp->s_refcnt == 0); 4233 ASSERT(sp->s_otw_call_count == 0); 4234 4235 remove_all_mi(sp); 4236 4237 crfree(sp->s_cred); 4238 kmem_free(sp->saddr.buf, sp->saddr.maxlen); 4239 kmem_free(sp->clidtosend.id_val, sp->clidtosend.id_len); 4240 mutex_exit(&sp->s_lock); 4241 4242 /* destroy the nfs4_server */ 4243 nfs4callback_destroy(sp); 4244 list_destroy(&sp->s_deleg_list); 4245 mutex_destroy(&sp->s_lock); 4246 cv_destroy(&sp->cv_thread_exit); 4247 cv_destroy(&sp->s_cv_otw_count); 4248 cv_destroy(&sp->s_clientid_pend); 4249 cv_destroy(&sp->wait_cb_null); 4250 nfs_rw_destroy(&sp->s_recovlock); 4251 kmem_free(sp, sizeof (*sp)); 4252 } 4253 4254 /* 4255 * Fork off a thread to free the data structures for a mount. 4256 */ 4257 4258 static void 4259 async_free_mount(vfs_t *vfsp, int flag, cred_t *cr) 4260 { 4261 freemountargs_t *args; 4262 args = kmem_alloc(sizeof (freemountargs_t), KM_SLEEP); 4263 args->fm_vfsp = vfsp; 4264 VFS_HOLD(vfsp); 4265 MI4_HOLD(VFTOMI4(vfsp)); 4266 args->fm_flag = flag; 4267 args->fm_cr = cr; 4268 crhold(cr); 4269 (void) zthread_create(NULL, 0, nfs4_free_mount_thread, args, 0, 4270 minclsyspri); 4271 } 4272 4273 static void 4274 nfs4_free_mount_thread(freemountargs_t *args) 4275 { 4276 mntinfo4_t *mi; 4277 nfs4_free_mount(args->fm_vfsp, args->fm_flag, args->fm_cr); 4278 mi = VFTOMI4(args->fm_vfsp); 4279 crfree(args->fm_cr); 4280 VFS_RELE(args->fm_vfsp); 4281 MI4_RELE(mi); 4282 kmem_free(args, sizeof (freemountargs_t)); 4283 zthread_exit(); 4284 /* NOTREACHED */ 4285 } 4286 4287 /* 4288 * Thread to free the data structures for a given filesystem. 4289 */ 4290 static void 4291 nfs4_free_mount(vfs_t *vfsp, int flag, cred_t *cr) 4292 { 4293 mntinfo4_t *mi = VFTOMI4(vfsp); 4294 nfs4_server_t *sp; 4295 callb_cpr_t cpr_info; 4296 kmutex_t cpr_lock; 4297 boolean_t async_thread; 4298 int removed; 4299 4300 bool_t must_unlock; 4301 nfs4_ephemeral_tree_t *eph_tree; 4302 4303 /* 4304 * We need to participate in the CPR framework if this is a kernel 4305 * thread. 4306 */ 4307 async_thread = (curproc == nfs_zone()->zone_zsched); 4308 if (async_thread) { 4309 mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL); 4310 CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr, 4311 "nfsv4AsyncUnmount"); 4312 } 4313 4314 /* 4315 * We need to wait for all outstanding OTW calls 4316 * and recovery to finish before we remove the mi 4317 * from the nfs4_server_t, as current pending 4318 * calls might still need this linkage (in order 4319 * to find a nfs4_server_t from a mntinfo4_t). 4320 */ 4321 (void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, FALSE); 4322 sp = find_nfs4_server(mi); 4323 nfs_rw_exit(&mi->mi_recovlock); 4324 4325 if (sp) { 4326 while (sp->s_otw_call_count != 0) { 4327 if (async_thread) { 4328 mutex_enter(&cpr_lock); 4329 CALLB_CPR_SAFE_BEGIN(&cpr_info); 4330 mutex_exit(&cpr_lock); 4331 } 4332 cv_wait(&sp->s_cv_otw_count, &sp->s_lock); 4333 if (async_thread) { 4334 mutex_enter(&cpr_lock); 4335 CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock); 4336 mutex_exit(&cpr_lock); 4337 } 4338 } 4339 mutex_exit(&sp->s_lock); 4340 nfs4_server_rele(sp); 4341 sp = NULL; 4342 } 4343 4344 mutex_enter(&mi->mi_lock); 4345 while (mi->mi_in_recovery != 0) { 4346 if (async_thread) { 4347 mutex_enter(&cpr_lock); 4348 CALLB_CPR_SAFE_BEGIN(&cpr_info); 4349 mutex_exit(&cpr_lock); 4350 } 4351 cv_wait(&mi->mi_cv_in_recov, &mi->mi_lock); 4352 if (async_thread) { 4353 mutex_enter(&cpr_lock); 4354 CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock); 4355 mutex_exit(&cpr_lock); 4356 } 4357 } 4358 mutex_exit(&mi->mi_lock); 4359 4360 /* 4361 * If we got an error, then do not nuke the 4362 * tree. Either the harvester is busy reclaiming 4363 * this node or we ran into some busy condition. 4364 * 4365 * The harvester will eventually come along and cleanup. 4366 * The only problem would be the root mount point. 4367 * 4368 * Since the busy node can occur for a variety 4369 * of reasons and can result in an entry staying 4370 * in df output but no longer accessible from the 4371 * directory tree, we are okay. 4372 */ 4373 if (!nfs4_ephemeral_umount(mi, flag, cr, 4374 &must_unlock, &eph_tree)) 4375 nfs4_ephemeral_umount_activate(mi, &must_unlock, 4376 &eph_tree); 4377 4378 /* 4379 * The original purge of the dnlc via 'dounmount' 4380 * doesn't guarantee that another dnlc entry was not 4381 * added while we waitied for all outstanding OTW 4382 * and recovery calls to finish. So re-purge the 4383 * dnlc now. 4384 */ 4385 (void) dnlc_purge_vfsp(vfsp, 0); 4386 4387 /* 4388 * We need to explicitly stop the manager thread; the asyc worker 4389 * threads can timeout and exit on their own. 4390 */ 4391 mutex_enter(&mi->mi_async_lock); 4392 mi->mi_max_threads = 0; 4393 NFS4_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv); 4394 mutex_exit(&mi->mi_async_lock); 4395 if (mi->mi_manager_thread) 4396 nfs4_async_manager_stop(vfsp); 4397 4398 destroy_rtable4(vfsp, cr); 4399 4400 nfs4_remove_mi_from_server(mi, NULL); 4401 4402 if (async_thread) { 4403 mutex_enter(&cpr_lock); 4404 CALLB_CPR_EXIT(&cpr_info); /* drops cpr_lock */ 4405 mutex_destroy(&cpr_lock); 4406 } 4407 4408 removed = nfs4_mi_zonelist_remove(mi); 4409 if (removed) 4410 zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4); 4411 } 4412 4413 /* Referral related sub-routines */ 4414 4415 /* Freeup knetconfig */ 4416 static void 4417 free_knconf_contents(struct knetconfig *k) 4418 { 4419 if (k == NULL) 4420 return; 4421 if (k->knc_protofmly) 4422 kmem_free(k->knc_protofmly, KNC_STRSIZE); 4423 if (k->knc_proto) 4424 kmem_free(k->knc_proto, KNC_STRSIZE); 4425 } 4426 4427 /* 4428 * This updates newpath variable with exact name component from the 4429 * path which gave us a NFS4ERR_MOVED error. 4430 * If the path is /rp/aaa/bbb and nth value is 1, aaa is returned. 4431 */ 4432 static char * 4433 extract_referral_point(const char *svp, int nth) 4434 { 4435 int num_slashes = 0; 4436 const char *p; 4437 char *newpath = NULL; 4438 int i = 0; 4439 4440 newpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 4441 for (p = svp; *p; p++) { 4442 if (*p == '/') 4443 num_slashes++; 4444 if (num_slashes == nth + 1) { 4445 p++; 4446 while (*p != '/') { 4447 if (*p == '\0') 4448 break; 4449 newpath[i] = *p; 4450 i++; 4451 p++; 4452 } 4453 newpath[i++] = '\0'; 4454 break; 4455 } 4456 } 4457 return (newpath); 4458 } 4459 4460 /* 4461 * This sets up a new path in sv_path to do a lookup of the referral point. 4462 * If the path is /rp/aaa/bbb and the referral point is aaa, 4463 * this updates /rp/aaa. This path will be used to get referral 4464 * location. 4465 */ 4466 static void 4467 setup_newsvpath(servinfo4_t *svp, int nth) 4468 { 4469 int num_slashes = 0, pathlen, i = 0; 4470 char *newpath, *p; 4471 4472 newpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 4473 for (p = svp->sv_path; *p; p++) { 4474 newpath[i] = *p; 4475 if (*p == '/') 4476 num_slashes++; 4477 if (num_slashes == nth + 1) { 4478 newpath[i] = '\0'; 4479 pathlen = strlen(newpath) + 1; 4480 kmem_free(svp->sv_path, svp->sv_pathlen); 4481 svp->sv_path = kmem_alloc(pathlen, KM_SLEEP); 4482 svp->sv_pathlen = pathlen; 4483 bcopy(newpath, svp->sv_path, pathlen); 4484 break; 4485 } 4486 i++; 4487 } 4488 kmem_free(newpath, MAXPATHLEN); 4489 } 4490