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 struct sec_data *secdata; 267 dh_k4_clntdata_t *data; 268 char *pf, *p; 269 270 if (syncaddr == NULL || syncaddr->buf == NULL || nlen == 0) 271 return (NULL); 272 273 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 274 secdata->flags = 0; 275 276 data = kmem_alloc(sizeof (*data), KM_SLEEP); 277 278 data->syncaddr.maxlen = syncaddr->maxlen; 279 data->syncaddr.len = syncaddr->len; 280 data->syncaddr.buf = (char *)kmem_alloc(syncaddr->len, KM_SLEEP); 281 bcopy(syncaddr->buf, data->syncaddr.buf, syncaddr->len); 282 283 /* 284 * duplicate the knconf information for the 285 * new opaque data. 286 */ 287 data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP); 288 *data->knconf = *knconf; 289 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 290 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 291 bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE); 292 bcopy(knconf->knc_proto, p, KNC_STRSIZE); 293 data->knconf->knc_protofmly = pf; 294 data->knconf->knc_proto = p; 295 296 /* move server netname to the sec_data structure */ 297 data->netname = kmem_alloc(nlen, KM_SLEEP); 298 bcopy(netname, data->netname, nlen); 299 data->netnamelen = (int)nlen; 300 301 secdata->secmod = AUTH_DH; 302 secdata->rpcflavor = AUTH_DH; 303 secdata->data = (caddr_t)data; 304 305 return (secdata); 306 } 307 308 /* 309 * Returns (deep) copy of sec_data_t. Allocates all memory required; caller 310 * is responsible for freeing. 311 */ 312 sec_data_t * 313 copy_sec_data(sec_data_t *fsecdata) { 314 sec_data_t *tsecdata; 315 316 if (fsecdata == NULL) 317 return (NULL); 318 319 if (fsecdata->rpcflavor == AUTH_DH) { 320 dh_k4_clntdata_t *fdata = (dh_k4_clntdata_t *)fsecdata->data; 321 322 if (fdata == NULL) 323 return (NULL); 324 325 tsecdata = (sec_data_t *)create_authdh_data(fdata->netname, 326 fdata->netnamelen, &fdata->syncaddr, fdata->knconf); 327 328 return (tsecdata); 329 } 330 331 tsecdata = kmem_zalloc(sizeof (sec_data_t), KM_SLEEP); 332 333 tsecdata->secmod = fsecdata->secmod; 334 tsecdata->rpcflavor = fsecdata->rpcflavor; 335 tsecdata->flags = fsecdata->flags; 336 tsecdata->uid = fsecdata->uid; 337 338 if (fsecdata->rpcflavor == RPCSEC_GSS) { 339 gss_clntdata_t *gcd = (gss_clntdata_t *)fsecdata->data; 340 341 tsecdata->data = (caddr_t)copy_sec_data_gss(gcd); 342 } else { 343 tsecdata->data = NULL; 344 } 345 346 return (tsecdata); 347 } 348 349 gss_clntdata_t * 350 copy_sec_data_gss(gss_clntdata_t *fdata) 351 { 352 gss_clntdata_t *tdata; 353 354 if (fdata == NULL) 355 return (NULL); 356 357 tdata = kmem_zalloc(sizeof (gss_clntdata_t), KM_SLEEP); 358 359 tdata->mechanism.length = fdata->mechanism.length; 360 tdata->mechanism.elements = kmem_zalloc(fdata->mechanism.length, 361 KM_SLEEP); 362 bcopy(fdata->mechanism.elements, tdata->mechanism.elements, 363 fdata->mechanism.length); 364 365 tdata->service = fdata->service; 366 367 (void) strcpy(tdata->uname, fdata->uname); 368 (void) strcpy(tdata->inst, fdata->inst); 369 (void) strcpy(tdata->realm, fdata->realm); 370 371 tdata->qop = fdata->qop; 372 373 return (tdata); 374 } 375 376 static int 377 nfs4_chkdup_servinfo4(servinfo4_t *svp_head, servinfo4_t *svp) 378 { 379 servinfo4_t *si; 380 381 /* 382 * Iterate over the servinfo4 list to make sure 383 * we do not have a duplicate. Skip any servinfo4 384 * that has been marked "NOT IN USE" 385 */ 386 for (si = svp_head; si; si = si->sv_next) { 387 (void) nfs_rw_enter_sig(&si->sv_lock, RW_READER, 0); 388 if (si->sv_flags & SV4_NOTINUSE) { 389 nfs_rw_exit(&si->sv_lock); 390 continue; 391 } 392 nfs_rw_exit(&si->sv_lock); 393 if (si == svp) 394 continue; 395 if (si->sv_addr.len == svp->sv_addr.len && 396 strcmp(si->sv_knconf->knc_protofmly, 397 svp->sv_knconf->knc_protofmly) == 0 && 398 bcmp(si->sv_addr.buf, svp->sv_addr.buf, 399 si->sv_addr.len) == 0) { 400 /* it's a duplicate */ 401 return (1); 402 } 403 } 404 /* it's not a duplicate */ 405 return (0); 406 } 407 408 void 409 nfs4_free_args(struct nfs_args *nargs) 410 { 411 if (nargs->knconf) { 412 if (nargs->knconf->knc_protofmly) 413 kmem_free(nargs->knconf->knc_protofmly, 414 KNC_STRSIZE); 415 if (nargs->knconf->knc_proto) 416 kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE); 417 kmem_free(nargs->knconf, sizeof (*nargs->knconf)); 418 nargs->knconf = NULL; 419 } 420 421 if (nargs->fh) { 422 kmem_free(nargs->fh, strlen(nargs->fh) + 1); 423 nargs->fh = NULL; 424 } 425 426 if (nargs->hostname) { 427 kmem_free(nargs->hostname, strlen(nargs->hostname) + 1); 428 nargs->hostname = NULL; 429 } 430 431 if (nargs->addr) { 432 if (nargs->addr->buf) { 433 ASSERT(nargs->addr->len); 434 kmem_free(nargs->addr->buf, nargs->addr->len); 435 } 436 kmem_free(nargs->addr, sizeof (struct netbuf)); 437 nargs->addr = NULL; 438 } 439 440 if (nargs->syncaddr) { 441 ASSERT(nargs->syncaddr->len); 442 if (nargs->syncaddr->buf) { 443 ASSERT(nargs->syncaddr->len); 444 kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len); 445 } 446 kmem_free(nargs->syncaddr, sizeof (struct netbuf)); 447 nargs->syncaddr = NULL; 448 } 449 450 if (nargs->netname) { 451 kmem_free(nargs->netname, strlen(nargs->netname) + 1); 452 nargs->netname = NULL; 453 } 454 455 if (nargs->nfs_ext_u.nfs_extA.secdata) { 456 sec_clnt_freeinfo( 457 nargs->nfs_ext_u.nfs_extA.secdata); 458 nargs->nfs_ext_u.nfs_extA.secdata = NULL; 459 } 460 } 461 462 463 int 464 nfs4_copyin(char *data, int datalen, struct nfs_args *nargs) 465 { 466 467 int error; 468 size_t hlen; /* length of hostname */ 469 size_t nlen; /* length of netname */ 470 char netname[MAXNETNAMELEN+1]; /* server's netname */ 471 struct netbuf addr; /* server's address */ 472 struct netbuf syncaddr; /* AUTH_DES time sync addr */ 473 struct knetconfig *knconf; /* transport structure */ 474 struct sec_data *secdata = NULL; /* security data */ 475 STRUCT_DECL(nfs_args, args); /* nfs mount arguments */ 476 STRUCT_DECL(knetconfig, knconf_tmp); 477 STRUCT_DECL(netbuf, addr_tmp); 478 int flags; 479 char *p, *pf; 480 struct pathname pn; 481 char *userbufptr; 482 483 484 bzero(nargs, sizeof (*nargs)); 485 486 STRUCT_INIT(args, get_udatamodel()); 487 bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE)); 488 if (copyin(data, STRUCT_BUF(args), MIN(datalen, 489 STRUCT_SIZE(args)))) 490 return (EFAULT); 491 492 nargs->wsize = STRUCT_FGET(args, wsize); 493 nargs->rsize = STRUCT_FGET(args, rsize); 494 nargs->timeo = STRUCT_FGET(args, timeo); 495 nargs->retrans = STRUCT_FGET(args, retrans); 496 nargs->acregmin = STRUCT_FGET(args, acregmin); 497 nargs->acregmax = STRUCT_FGET(args, acregmax); 498 nargs->acdirmin = STRUCT_FGET(args, acdirmin); 499 nargs->acdirmax = STRUCT_FGET(args, acdirmax); 500 501 flags = STRUCT_FGET(args, flags); 502 nargs->flags = flags; 503 504 addr.buf = NULL; 505 syncaddr.buf = NULL; 506 507 508 /* 509 * Allocate space for a knetconfig structure and 510 * its strings and copy in from user-land. 511 */ 512 knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP); 513 STRUCT_INIT(knconf_tmp, get_udatamodel()); 514 if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp), 515 STRUCT_SIZE(knconf_tmp))) { 516 kmem_free(knconf, sizeof (*knconf)); 517 return (EFAULT); 518 } 519 520 knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics); 521 knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly); 522 knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto); 523 if (get_udatamodel() != DATAMODEL_LP64) { 524 knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev)); 525 } else { 526 knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev); 527 } 528 529 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 530 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 531 error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL); 532 if (error) { 533 kmem_free(pf, KNC_STRSIZE); 534 kmem_free(p, KNC_STRSIZE); 535 kmem_free(knconf, sizeof (*knconf)); 536 return (error); 537 } 538 539 error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL); 540 if (error) { 541 kmem_free(pf, KNC_STRSIZE); 542 kmem_free(p, KNC_STRSIZE); 543 kmem_free(knconf, sizeof (*knconf)); 544 return (error); 545 } 546 547 548 knconf->knc_protofmly = pf; 549 knconf->knc_proto = p; 550 551 nargs->knconf = knconf; 552 553 /* 554 * Get server address 555 */ 556 STRUCT_INIT(addr_tmp, get_udatamodel()); 557 if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp), 558 STRUCT_SIZE(addr_tmp))) { 559 error = EFAULT; 560 goto errout; 561 } 562 563 nargs->addr = kmem_zalloc(sizeof (struct netbuf), KM_SLEEP); 564 userbufptr = STRUCT_FGETP(addr_tmp, buf); 565 addr.len = STRUCT_FGET(addr_tmp, len); 566 addr.buf = kmem_alloc(addr.len, KM_SLEEP); 567 addr.maxlen = addr.len; 568 if (copyin(userbufptr, addr.buf, addr.len)) { 569 kmem_free(addr.buf, addr.len); 570 error = EFAULT; 571 goto errout; 572 } 573 bcopy(&addr, nargs->addr, sizeof (struct netbuf)); 574 575 /* 576 * Get the root fhandle 577 */ 578 error = pn_get(STRUCT_FGETP(args, fh), UIO_USERSPACE, &pn); 579 if (error) 580 goto errout; 581 582 /* Volatile fh: keep server paths, so use actual-size strings */ 583 nargs->fh = kmem_alloc(pn.pn_pathlen + 1, KM_SLEEP); 584 bcopy(pn.pn_path, nargs->fh, pn.pn_pathlen); 585 nargs->fh[pn.pn_pathlen] = '\0'; 586 pn_free(&pn); 587 588 589 /* 590 * Get server's hostname 591 */ 592 if (flags & NFSMNT_HOSTNAME) { 593 error = copyinstr(STRUCT_FGETP(args, hostname), 594 netname, sizeof (netname), &hlen); 595 if (error) 596 goto errout; 597 nargs->hostname = kmem_zalloc(hlen, KM_SLEEP); 598 (void) strcpy(nargs->hostname, netname); 599 600 } else { 601 nargs->hostname = NULL; 602 } 603 604 605 /* 606 * If there are syncaddr and netname data, load them in. This is 607 * to support data needed for NFSV4 when AUTH_DH is the negotiated 608 * flavor via SECINFO. (instead of using MOUNT protocol in V3). 609 */ 610 netname[0] = '\0'; 611 if (flags & NFSMNT_SECURE) { 612 613 /* get syncaddr */ 614 STRUCT_INIT(addr_tmp, get_udatamodel()); 615 if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp), 616 STRUCT_SIZE(addr_tmp))) { 617 error = EINVAL; 618 goto errout; 619 } 620 userbufptr = STRUCT_FGETP(addr_tmp, buf); 621 syncaddr.len = STRUCT_FGET(addr_tmp, len); 622 syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP); 623 syncaddr.maxlen = syncaddr.len; 624 if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) { 625 kmem_free(syncaddr.buf, syncaddr.len); 626 error = EFAULT; 627 goto errout; 628 } 629 630 nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP); 631 bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf)); 632 633 /* get server's netname */ 634 if (copyinstr(STRUCT_FGETP(args, netname), netname, 635 sizeof (netname), &nlen)) { 636 error = EFAULT; 637 goto errout; 638 } 639 640 netname[nlen] = '\0'; 641 nargs->netname = kmem_zalloc(nlen, KM_SLEEP); 642 (void) strcpy(nargs->netname, netname); 643 } 644 645 /* 646 * Get the extention data which has the security data structure. 647 * This includes data for AUTH_SYS as well. 648 */ 649 if (flags & NFSMNT_NEWARGS) { 650 nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext); 651 if (nargs->nfs_args_ext == NFS_ARGS_EXTA || 652 nargs->nfs_args_ext == NFS_ARGS_EXTB) { 653 /* 654 * Indicating the application is using the new 655 * sec_data structure to pass in the security 656 * data. 657 */ 658 if (STRUCT_FGETP(args, 659 nfs_ext_u.nfs_extA.secdata) != NULL) { 660 error = sec_clnt_loadinfo( 661 (struct sec_data *)STRUCT_FGETP(args, 662 nfs_ext_u.nfs_extA.secdata), 663 &secdata, get_udatamodel()); 664 } 665 nargs->nfs_ext_u.nfs_extA.secdata = secdata; 666 } 667 } 668 669 if (error) 670 goto errout; 671 672 /* 673 * Failover support: 674 * 675 * We may have a linked list of nfs_args structures, 676 * which means the user is looking for failover. If 677 * the mount is either not "read-only" or "soft", 678 * we want to bail out with EINVAL. 679 */ 680 if (nargs->nfs_args_ext == NFS_ARGS_EXTB) 681 nargs->nfs_ext_u.nfs_extB.next = 682 STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next); 683 684 errout: 685 if (error) 686 nfs4_free_args(nargs); 687 688 return (error); 689 } 690 691 692 /* 693 * nfs mount vfsop 694 * Set up mount info record and attach it to vfs struct. 695 */ 696 int 697 nfs4_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 698 { 699 char *data = uap->dataptr; 700 int error; 701 vnode_t *rtvp; /* the server's root */ 702 mntinfo4_t *mi; /* mount info, pointed at by vfs */ 703 struct knetconfig *rdma_knconf; /* rdma transport structure */ 704 rnode4_t *rp; 705 struct servinfo4 *svp; /* nfs server info */ 706 struct servinfo4 *svp_tail = NULL; /* previous nfs server info */ 707 struct servinfo4 *svp_head; /* first nfs server info */ 708 struct servinfo4 *svp_2ndlast; /* 2nd last in server info list */ 709 struct sec_data *secdata; /* security data */ 710 struct nfs_args *args = NULL; 711 int flags, addr_type, removed; 712 zone_t *zone = nfs_zone(); 713 nfs4_error_t n4e; 714 zone_t *mntzone = NULL; 715 716 if (secpolicy_fs_mount(cr, mvp, vfsp) != 0) 717 return (EPERM); 718 if (mvp->v_type != VDIR) 719 return (ENOTDIR); 720 721 /* 722 * get arguments 723 * 724 * nfs_args is now versioned and is extensible, so 725 * uap->datalen might be different from sizeof (args) 726 * in a compatible situation. 727 */ 728 more: 729 if (!(uap->flags & MS_SYSSPACE)) { 730 if (args == NULL) 731 args = kmem_zalloc(sizeof (struct nfs_args), KM_SLEEP); 732 else 733 nfs4_free_args(args); 734 error = nfs4_copyin(data, uap->datalen, args); 735 if (error) { 736 if (args) { 737 kmem_free(args, sizeof (*args)); 738 } 739 return (error); 740 } 741 } else { 742 args = (struct nfs_args *)data; 743 } 744 745 flags = args->flags; 746 747 /* 748 * If the request changes the locking type, disallow the remount, 749 * because it's questionable whether we can transfer the 750 * locking state correctly. 751 */ 752 if (uap->flags & MS_REMOUNT) { 753 if (!(uap->flags & MS_SYSSPACE)) { 754 nfs4_free_args(args); 755 kmem_free(args, sizeof (*args)); 756 } 757 if ((mi = VFTOMI4(vfsp)) != NULL) { 758 uint_t new_mi_llock; 759 uint_t old_mi_llock; 760 new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0; 761 old_mi_llock = (mi->mi_flags & MI4_LLOCK) ? 1 : 0; 762 if (old_mi_llock != new_mi_llock) 763 return (EBUSY); 764 } 765 return (0); 766 } 767 768 /* 769 * For ephemeral mount trigger stub vnodes, we have two problems 770 * to solve: racing threads will likely fail the v_count check, and 771 * we want only one to proceed with the mount. 772 * 773 * For stubs, if the mount has already occurred (via a racing thread), 774 * just return success. If not, skip the v_count check and proceed. 775 * Note that we are already serialised at this point. 776 */ 777 mutex_enter(&mvp->v_lock); 778 if (vn_matchops(mvp, nfs4_trigger_vnodeops)) { 779 /* mntpt is a v4 stub vnode */ 780 ASSERT(RP_ISSTUB(VTOR4(mvp))); 781 ASSERT(!(uap->flags & MS_OVERLAY)); 782 ASSERT(!(mvp->v_flag & VROOT)); 783 if (vn_mountedvfs(mvp) != NULL) { 784 /* ephemeral mount has already occurred */ 785 ASSERT(uap->flags & MS_SYSSPACE); 786 mutex_exit(&mvp->v_lock); 787 return (0); 788 } 789 } else { 790 /* mntpt is a non-v4 or v4 non-stub vnode */ 791 if (!(uap->flags & MS_OVERLAY) && 792 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 793 mutex_exit(&mvp->v_lock); 794 if (!(uap->flags & MS_SYSSPACE)) { 795 nfs4_free_args(args); 796 kmem_free(args, sizeof (*args)); 797 } 798 return (EBUSY); 799 } 800 } 801 mutex_exit(&mvp->v_lock); 802 803 /* make sure things are zeroed for errout: */ 804 rtvp = NULL; 805 mi = NULL; 806 secdata = NULL; 807 808 /* 809 * A valid knetconfig structure is required. 810 */ 811 if (!(flags & NFSMNT_KNCONF) || 812 args->knconf == NULL || args->knconf->knc_protofmly == NULL || 813 args->knconf->knc_proto == NULL || 814 (strcmp(args->knconf->knc_proto, NC_UDP) == 0)) { 815 if (!(uap->flags & MS_SYSSPACE)) { 816 nfs4_free_args(args); 817 kmem_free(args, sizeof (*args)); 818 } 819 return (EINVAL); 820 } 821 822 if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) || 823 (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) { 824 if (!(uap->flags & MS_SYSSPACE)) { 825 nfs4_free_args(args); 826 kmem_free(args, sizeof (*args)); 827 } 828 return (EINVAL); 829 } 830 831 /* 832 * Allocate a servinfo4 struct. 833 */ 834 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP); 835 nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL); 836 if (svp_tail) { 837 svp_2ndlast = svp_tail; 838 svp_tail->sv_next = svp; 839 } else { 840 svp_head = svp; 841 svp_2ndlast = svp; 842 } 843 844 svp_tail = svp; 845 svp->sv_knconf = args->knconf; 846 args->knconf = NULL; 847 848 /* 849 * Get server address 850 */ 851 if (args->addr == NULL || args->addr->buf == NULL) { 852 error = EINVAL; 853 goto errout; 854 } 855 856 svp->sv_addr.maxlen = args->addr->maxlen; 857 svp->sv_addr.len = args->addr->len; 858 svp->sv_addr.buf = args->addr->buf; 859 args->addr->buf = NULL; 860 861 /* 862 * Get the root fhandle 863 */ 864 if (args->fh == NULL || (strlen(args->fh) >= MAXPATHLEN)) { 865 error = EINVAL; 866 goto errout; 867 } 868 869 svp->sv_path = args->fh; 870 svp->sv_pathlen = strlen(args->fh) + 1; 871 args->fh = NULL; 872 873 /* 874 * Get server's hostname 875 */ 876 if (flags & NFSMNT_HOSTNAME) { 877 if (args->hostname == NULL || (strlen(args->hostname) > 878 MAXNETNAMELEN)) { 879 error = EINVAL; 880 goto errout; 881 } 882 svp->sv_hostnamelen = strlen(args->hostname) + 1; 883 svp->sv_hostname = args->hostname; 884 args->hostname = NULL; 885 } else { 886 char *p = "unknown-host"; 887 svp->sv_hostnamelen = strlen(p) + 1; 888 svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP); 889 (void) strcpy(svp->sv_hostname, p); 890 } 891 892 /* 893 * RDMA MOUNT SUPPORT FOR NFS v4. 894 * Establish, is it possible to use RDMA, if so overload the 895 * knconf with rdma specific knconf and free the orignal knconf. 896 */ 897 if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) { 898 /* 899 * Determine the addr type for RDMA, IPv4 or v6. 900 */ 901 if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0) 902 addr_type = AF_INET; 903 else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0) 904 addr_type = AF_INET6; 905 906 if (rdma_reachable(addr_type, &svp->sv_addr, 907 &rdma_knconf) == 0) { 908 /* 909 * If successful, hijack the orignal knconf and 910 * replace with the new one, depending on the flags. 911 */ 912 svp->sv_origknconf = svp->sv_knconf; 913 svp->sv_knconf = rdma_knconf; 914 } else { 915 if (flags & NFSMNT_TRYRDMA) { 916 #ifdef DEBUG 917 if (rdma_debug) 918 zcmn_err(getzoneid(), CE_WARN, 919 "no RDMA onboard, revert\n"); 920 #endif 921 } 922 923 if (flags & NFSMNT_DORDMA) { 924 /* 925 * If proto=rdma is specified and no RDMA 926 * path to this server is avialable then 927 * ditch this server. 928 * This is not included in the mountable 929 * server list or the replica list. 930 * Check if more servers are specified; 931 * Failover case, otherwise bail out of mount. 932 */ 933 if (args->nfs_args_ext == NFS_ARGS_EXTB && 934 args->nfs_ext_u.nfs_extB.next != NULL) { 935 data = (char *) 936 args->nfs_ext_u.nfs_extB.next; 937 if (uap->flags & MS_RDONLY && 938 !(flags & NFSMNT_SOFT)) { 939 if (svp_head->sv_next == NULL) { 940 svp_tail = NULL; 941 svp_2ndlast = NULL; 942 sv4_free(svp_head); 943 goto more; 944 } else { 945 svp_tail = svp_2ndlast; 946 svp_2ndlast->sv_next = 947 NULL; 948 sv4_free(svp); 949 goto more; 950 } 951 } 952 } else { 953 /* 954 * This is the last server specified 955 * in the nfs_args list passed down 956 * and its not rdma capable. 957 */ 958 if (svp_head->sv_next == NULL) { 959 /* 960 * Is this the only one 961 */ 962 error = EINVAL; 963 #ifdef DEBUG 964 if (rdma_debug) 965 zcmn_err(getzoneid(), 966 CE_WARN, 967 "No RDMA srv"); 968 #endif 969 goto errout; 970 } else { 971 /* 972 * There is list, since some 973 * servers specified before 974 * this passed all requirements 975 */ 976 svp_tail = svp_2ndlast; 977 svp_2ndlast->sv_next = NULL; 978 sv4_free(svp); 979 goto proceed; 980 } 981 } 982 } 983 } 984 } 985 986 /* 987 * If there are syncaddr and netname data, load them in. This is 988 * to support data needed for NFSV4 when AUTH_DH is the negotiated 989 * flavor via SECINFO. (instead of using MOUNT protocol in V3). 990 */ 991 if (args->flags & NFSMNT_SECURE) { 992 svp->sv_dhsec = create_authdh_data(args->netname, 993 strlen(args->netname), 994 args->syncaddr, svp->sv_knconf); 995 } 996 997 /* 998 * Get the extention data which has the security data structure. 999 * This includes data for AUTH_SYS as well. 1000 */ 1001 if (flags & NFSMNT_NEWARGS) { 1002 switch (args->nfs_args_ext) { 1003 case NFS_ARGS_EXTA: 1004 case NFS_ARGS_EXTB: 1005 /* 1006 * Indicating the application is using the new 1007 * sec_data structure to pass in the security 1008 * data. 1009 */ 1010 secdata = args->nfs_ext_u.nfs_extA.secdata; 1011 if (secdata == NULL) { 1012 error = EINVAL; 1013 } else if (uap->flags & MS_SYSSPACE) { 1014 /* 1015 * Need to validate the flavor here if 1016 * sysspace, userspace was already 1017 * validate from the nfs_copyin function. 1018 */ 1019 switch (secdata->rpcflavor) { 1020 case AUTH_NONE: 1021 case AUTH_UNIX: 1022 case AUTH_LOOPBACK: 1023 case AUTH_DES: 1024 case RPCSEC_GSS: 1025 break; 1026 default: 1027 error = EINVAL; 1028 goto errout; 1029 } 1030 } 1031 args->nfs_ext_u.nfs_extA.secdata = NULL; 1032 break; 1033 1034 default: 1035 error = EINVAL; 1036 break; 1037 } 1038 1039 } else if (flags & NFSMNT_SECURE) { 1040 /* 1041 * NFSMNT_SECURE is deprecated but we keep it 1042 * to support the rogue user-generated application 1043 * that may use this undocumented interface to do 1044 * AUTH_DH security, e.g. our own rexd. 1045 * 1046 * Also note that NFSMNT_SECURE is used for passing 1047 * AUTH_DH info to be used in negotiation. 1048 */ 1049 secdata = create_authdh_data(args->netname, 1050 strlen(args->netname), args->syncaddr, svp->sv_knconf); 1051 1052 } else { 1053 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 1054 secdata->secmod = secdata->rpcflavor = AUTH_SYS; 1055 secdata->data = NULL; 1056 } 1057 1058 svp->sv_secdata = secdata; 1059 1060 /* 1061 * User does not explictly specify a flavor, and a user 1062 * defined default flavor is passed down. 1063 */ 1064 if (flags & NFSMNT_SECDEFAULT) { 1065 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1066 svp->sv_flags |= SV4_TRYSECDEFAULT; 1067 nfs_rw_exit(&svp->sv_lock); 1068 } 1069 1070 /* 1071 * Failover support: 1072 * 1073 * We may have a linked list of nfs_args structures, 1074 * which means the user is looking for failover. If 1075 * the mount is either not "read-only" or "soft", 1076 * we want to bail out with EINVAL. 1077 */ 1078 if (args->nfs_args_ext == NFS_ARGS_EXTB && 1079 args->nfs_ext_u.nfs_extB.next != NULL) { 1080 if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) { 1081 data = (char *)args->nfs_ext_u.nfs_extB.next; 1082 goto more; 1083 } 1084 error = EINVAL; 1085 goto errout; 1086 } 1087 1088 /* 1089 * Determine the zone we're being mounted into. 1090 */ 1091 zone_hold(mntzone = zone); /* start with this assumption */ 1092 if (getzoneid() == GLOBAL_ZONEID) { 1093 zone_rele(mntzone); 1094 mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 1095 ASSERT(mntzone != NULL); 1096 if (mntzone != zone) { 1097 error = EBUSY; 1098 goto errout; 1099 } 1100 } 1101 1102 if (is_system_labeled()) { 1103 error = nfs_mount_label_policy(vfsp, &svp->sv_addr, 1104 svp->sv_knconf, cr); 1105 1106 if (error > 0) 1107 goto errout; 1108 1109 if (error == -1) { 1110 /* change mount to read-only to prevent write-down */ 1111 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 1112 } 1113 } 1114 1115 /* 1116 * Stop the mount from going any further if the zone is going away. 1117 */ 1118 if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) { 1119 error = EBUSY; 1120 goto errout; 1121 } 1122 1123 /* 1124 * Get root vnode. 1125 */ 1126 proceed: 1127 error = nfs4rootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone); 1128 if (error) { 1129 /* if nfs4rootvp failed, it will free svp_head */ 1130 svp_head = NULL; 1131 goto errout; 1132 } 1133 1134 mi = VTOMI4(rtvp); 1135 1136 /* 1137 * Send client id to the server, if necessary 1138 */ 1139 nfs4_error_zinit(&n4e); 1140 nfs4setclientid(mi, cr, FALSE, &n4e); 1141 1142 error = n4e.error; 1143 1144 if (error) 1145 goto errout; 1146 1147 /* 1148 * Set option fields in the mount info record 1149 */ 1150 1151 if (svp_head->sv_next) { 1152 mutex_enter(&mi->mi_lock); 1153 mi->mi_flags |= MI4_LLOCK; 1154 mutex_exit(&mi->mi_lock); 1155 } 1156 error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, args); 1157 if (error) 1158 goto errout; 1159 1160 /* 1161 * Time to tie in the mirror mount info at last! 1162 */ 1163 if (flags & NFSMNT_EPHEMERAL) 1164 error = nfs4_record_ephemeral_mount(mi, mvp); 1165 1166 errout: 1167 if (error) { 1168 if (rtvp != NULL) { 1169 rp = VTOR4(rtvp); 1170 if (rp->r_flags & R4HASHED) 1171 rp4_rmhash(rp); 1172 } 1173 if (mi != NULL) { 1174 nfs4_async_stop(vfsp); 1175 nfs4_async_manager_stop(vfsp); 1176 nfs4_remove_mi_from_server(mi, NULL); 1177 if (rtvp != NULL) 1178 VN_RELE(rtvp); 1179 if (mntzone != NULL) 1180 zone_rele(mntzone); 1181 /* need to remove it from the zone */ 1182 removed = nfs4_mi_zonelist_remove(mi); 1183 if (removed) 1184 zone_rele_ref(&mi->mi_zone_ref, 1185 ZONE_REF_NFSV4); 1186 MI4_RELE(mi); 1187 if (!(uap->flags & MS_SYSSPACE) && args) { 1188 nfs4_free_args(args); 1189 kmem_free(args, sizeof (*args)); 1190 } 1191 return (error); 1192 } 1193 if (svp_head) 1194 sv4_free(svp_head); 1195 } 1196 1197 if (!(uap->flags & MS_SYSSPACE) && args) { 1198 nfs4_free_args(args); 1199 kmem_free(args, sizeof (*args)); 1200 } 1201 if (rtvp != NULL) 1202 VN_RELE(rtvp); 1203 1204 if (mntzone != NULL) 1205 zone_rele(mntzone); 1206 1207 return (error); 1208 } 1209 1210 #ifdef DEBUG 1211 #define VERS_MSG "NFS4 server " 1212 #else 1213 #define VERS_MSG "NFS server " 1214 #endif 1215 1216 #define READ_MSG \ 1217 VERS_MSG "%s returned 0 for read transfer size" 1218 #define WRITE_MSG \ 1219 VERS_MSG "%s returned 0 for write transfer size" 1220 #define SIZE_MSG \ 1221 VERS_MSG "%s returned 0 for maximum file size" 1222 1223 /* 1224 * Get the symbolic link text from the server for a given filehandle 1225 * of that symlink. 1226 * 1227 * (get symlink text) PUTFH READLINK 1228 */ 1229 static int 1230 getlinktext_otw(mntinfo4_t *mi, nfs_fh4 *fh, char **linktextp, cred_t *cr, 1231 int flags) 1232 { 1233 COMPOUND4args_clnt args; 1234 COMPOUND4res_clnt res; 1235 int doqueue; 1236 nfs_argop4 argop[2]; 1237 nfs_resop4 *resop; 1238 READLINK4res *lr_res; 1239 uint_t len; 1240 bool_t needrecov = FALSE; 1241 nfs4_recov_state_t recov_state; 1242 nfs4_sharedfh_t *sfh; 1243 nfs4_error_t e; 1244 int num_retry = nfs4_max_mount_retry; 1245 int recovery = !(flags & NFS4_GETFH_NEEDSOP); 1246 1247 sfh = sfh4_get(fh, mi); 1248 recov_state.rs_flags = 0; 1249 recov_state.rs_num_retry_despite_err = 0; 1250 1251 recov_retry: 1252 nfs4_error_zinit(&e); 1253 1254 args.array_len = 2; 1255 args.array = argop; 1256 args.ctag = TAG_GET_SYMLINK; 1257 1258 if (! recovery) { 1259 e.error = nfs4_start_op(mi, NULL, NULL, &recov_state); 1260 if (e.error) { 1261 sfh4_rele(&sfh); 1262 return (e.error); 1263 } 1264 } 1265 1266 /* 0. putfh symlink fh */ 1267 argop[0].argop = OP_CPUTFH; 1268 argop[0].nfs_argop4_u.opcputfh.sfh = sfh; 1269 1270 /* 1. readlink */ 1271 argop[1].argop = OP_READLINK; 1272 1273 doqueue = 1; 1274 1275 rfs4call(mi, &args, &res, cr, &doqueue, 0, &e); 1276 1277 needrecov = nfs4_needs_recovery(&e, FALSE, mi->mi_vfsp); 1278 1279 if (needrecov && !recovery && num_retry-- > 0) { 1280 1281 NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, 1282 "getlinktext_otw: initiating recovery\n")); 1283 1284 if (nfs4_start_recovery(&e, mi, NULL, NULL, NULL, NULL, 1285 OP_READLINK, NULL, NULL, NULL) == FALSE) { 1286 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1287 if (!e.error) 1288 (void) xdr_free(xdr_COMPOUND4res_clnt, 1289 (caddr_t)&res); 1290 goto recov_retry; 1291 } 1292 } 1293 1294 /* 1295 * If non-NFS4 pcol error and/or we weren't able to recover. 1296 */ 1297 if (e.error != 0) { 1298 if (! recovery) 1299 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1300 sfh4_rele(&sfh); 1301 return (e.error); 1302 } 1303 1304 if (res.status) { 1305 e.error = geterrno4(res.status); 1306 (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1307 if (! recovery) 1308 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1309 sfh4_rele(&sfh); 1310 return (e.error); 1311 } 1312 1313 /* res.status == NFS4_OK */ 1314 ASSERT(res.status == NFS4_OK); 1315 1316 resop = &res.array[1]; /* readlink res */ 1317 lr_res = &resop->nfs_resop4_u.opreadlink; 1318 1319 /* treat symlink name as data */ 1320 *linktextp = utf8_to_str((utf8string *)&lr_res->link, &len, NULL); 1321 1322 if (! recovery) 1323 nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov); 1324 sfh4_rele(&sfh); 1325 (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 1326 return (0); 1327 } 1328 1329 /* 1330 * Skip over consecutive slashes and "/./" in a pathname. 1331 */ 1332 void 1333 pathname_skipslashdot(struct pathname *pnp) 1334 { 1335 char *c1, *c2; 1336 1337 while (pnp->pn_pathlen > 0 && *pnp->pn_path == '/') { 1338 1339 c1 = pnp->pn_path + 1; 1340 c2 = pnp->pn_path + 2; 1341 1342 if (*c1 == '.' && (*c2 == '/' || *c2 == '\0')) { 1343 pnp->pn_path = pnp->pn_path + 2; /* skip "/." */ 1344 pnp->pn_pathlen = pnp->pn_pathlen - 2; 1345 } else { 1346 pnp->pn_path++; 1347 pnp->pn_pathlen--; 1348 } 1349 } 1350 } 1351 1352 /* 1353 * Resolve a symbolic link path. The symlink is in the nth component of 1354 * svp->sv_path and has an nfs4 file handle "fh". 1355 * Upon return, the sv_path will point to the new path that has the nth 1356 * component resolved to its symlink text. 1357 */ 1358 int 1359 resolve_sympath(mntinfo4_t *mi, servinfo4_t *svp, int nth, nfs_fh4 *fh, 1360 cred_t *cr, int flags) 1361 { 1362 char *oldpath; 1363 char *symlink, *newpath; 1364 struct pathname oldpn, newpn; 1365 char component[MAXNAMELEN]; 1366 int i, addlen, error = 0; 1367 int oldpathlen; 1368 1369 /* Get the symbolic link text over the wire. */ 1370 error = getlinktext_otw(mi, fh, &symlink, cr, flags); 1371 1372 if (error || symlink == NULL || strlen(symlink) == 0) 1373 return (error); 1374 1375 /* 1376 * Compose the new pathname. 1377 * Note: 1378 * - only the nth component is resolved for the pathname. 1379 * - pathname.pn_pathlen does not count the ending null byte. 1380 */ 1381 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 1382 oldpath = svp->sv_path; 1383 oldpathlen = svp->sv_pathlen; 1384 if (error = pn_get(oldpath, UIO_SYSSPACE, &oldpn)) { 1385 nfs_rw_exit(&svp->sv_lock); 1386 kmem_free(symlink, strlen(symlink) + 1); 1387 return (error); 1388 } 1389 nfs_rw_exit(&svp->sv_lock); 1390 pn_alloc(&newpn); 1391 1392 /* 1393 * Skip over previous components from the oldpath so that the 1394 * oldpn.pn_path will point to the symlink component. Skip 1395 * leading slashes and "/./" (no OP_LOOKUP on ".") so that 1396 * pn_getcompnent can get the component. 1397 */ 1398 for (i = 1; i < nth; i++) { 1399 pathname_skipslashdot(&oldpn); 1400 error = pn_getcomponent(&oldpn, component); 1401 if (error) 1402 goto out; 1403 } 1404 1405 /* 1406 * Copy the old path upto the component right before the symlink 1407 * if the symlink is not an absolute path. 1408 */ 1409 if (symlink[0] != '/') { 1410 addlen = oldpn.pn_path - oldpn.pn_buf; 1411 bcopy(oldpn.pn_buf, newpn.pn_path, addlen); 1412 newpn.pn_pathlen += addlen; 1413 newpn.pn_path += addlen; 1414 newpn.pn_buf[newpn.pn_pathlen] = '/'; 1415 newpn.pn_pathlen++; 1416 newpn.pn_path++; 1417 } 1418 1419 /* copy the resolved symbolic link text */ 1420 addlen = strlen(symlink); 1421 if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) { 1422 error = ENAMETOOLONG; 1423 goto out; 1424 } 1425 bcopy(symlink, newpn.pn_path, addlen); 1426 newpn.pn_pathlen += addlen; 1427 newpn.pn_path += addlen; 1428 1429 /* 1430 * Check if there is any remaining path after the symlink component. 1431 * First, skip the symlink component. 1432 */ 1433 pathname_skipslashdot(&oldpn); 1434 if (error = pn_getcomponent(&oldpn, component)) 1435 goto out; 1436 1437 addlen = pn_pathleft(&oldpn); /* includes counting the slash */ 1438 1439 /* 1440 * Copy the remaining path to the new pathname if there is any. 1441 */ 1442 if (addlen > 0) { 1443 if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) { 1444 error = ENAMETOOLONG; 1445 goto out; 1446 } 1447 bcopy(oldpn.pn_path, newpn.pn_path, addlen); 1448 newpn.pn_pathlen += addlen; 1449 } 1450 newpn.pn_buf[newpn.pn_pathlen] = '\0'; 1451 1452 /* get the newpath and store it in the servinfo4_t */ 1453 newpath = kmem_alloc(newpn.pn_pathlen + 1, KM_SLEEP); 1454 bcopy(newpn.pn_buf, newpath, newpn.pn_pathlen); 1455 newpath[newpn.pn_pathlen] = '\0'; 1456 1457 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1458 svp->sv_path = newpath; 1459 svp->sv_pathlen = strlen(newpath) + 1; 1460 nfs_rw_exit(&svp->sv_lock); 1461 1462 kmem_free(oldpath, oldpathlen); 1463 out: 1464 kmem_free(symlink, strlen(symlink) + 1); 1465 pn_free(&newpn); 1466 pn_free(&oldpn); 1467 1468 return (error); 1469 } 1470 1471 /* 1472 * This routine updates servinfo4 structure with the new referred server 1473 * info. 1474 * nfsfsloc has the location related information 1475 * fsp has the hostname and pathname info. 1476 * new path = pathname from referral + part of orig pathname(based on nth). 1477 */ 1478 static void 1479 update_servinfo4(servinfo4_t *svp, fs_location4 *fsp, 1480 struct nfs_fsl_info *nfsfsloc, char *orig_path, int nth) 1481 { 1482 struct knetconfig *knconf, *svknconf; 1483 struct netbuf *saddr; 1484 sec_data_t *secdata; 1485 utf8string *host; 1486 int i = 0, num_slashes = 0; 1487 char *p, *spath, *op, *new_path; 1488 1489 /* Update knconf */ 1490 knconf = svp->sv_knconf; 1491 free_knconf_contents(knconf); 1492 bzero(knconf, sizeof (struct knetconfig)); 1493 svknconf = nfsfsloc->knconf; 1494 knconf->knc_semantics = svknconf->knc_semantics; 1495 knconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 1496 knconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP); 1497 knconf->knc_rdev = svknconf->knc_rdev; 1498 bcopy(svknconf->knc_protofmly, knconf->knc_protofmly, KNC_STRSIZE); 1499 bcopy(svknconf->knc_proto, knconf->knc_proto, KNC_STRSIZE); 1500 1501 /* Update server address */ 1502 saddr = &svp->sv_addr; 1503 if (saddr->buf != NULL) 1504 kmem_free(saddr->buf, saddr->maxlen); 1505 saddr->buf = kmem_alloc(nfsfsloc->addr->maxlen, KM_SLEEP); 1506 saddr->len = nfsfsloc->addr->len; 1507 saddr->maxlen = nfsfsloc->addr->maxlen; 1508 bcopy(nfsfsloc->addr->buf, saddr->buf, nfsfsloc->addr->len); 1509 1510 /* Update server name */ 1511 host = fsp->server_val; 1512 kmem_free(svp->sv_hostname, svp->sv_hostnamelen); 1513 svp->sv_hostname = kmem_zalloc(host->utf8string_len + 1, KM_SLEEP); 1514 bcopy(host->utf8string_val, svp->sv_hostname, host->utf8string_len); 1515 svp->sv_hostname[host->utf8string_len] = '\0'; 1516 svp->sv_hostnamelen = host->utf8string_len + 1; 1517 1518 /* 1519 * Update server path. 1520 * We need to setup proper path here. 1521 * For ex., If we got a path name serv1:/rp/aaa/bbb 1522 * where aaa is a referral and points to serv2:/rpool/aa 1523 * we need to set the path to serv2:/rpool/aa/bbb 1524 * The first part of this below code generates /rpool/aa 1525 * and the second part appends /bbb to the server path. 1526 */ 1527 spath = p = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1528 *p++ = '/'; 1529 for (i = 0; i < fsp->rootpath.pathname4_len; i++) { 1530 component4 *comp; 1531 1532 comp = &fsp->rootpath.pathname4_val[i]; 1533 /* If no space, null the string and bail */ 1534 if ((p - spath) + comp->utf8string_len + 1 > MAXPATHLEN) { 1535 p = spath + MAXPATHLEN - 1; 1536 spath[0] = '\0'; 1537 break; 1538 } 1539 bcopy(comp->utf8string_val, p, comp->utf8string_len); 1540 p += comp->utf8string_len; 1541 *p++ = '/'; 1542 } 1543 if (fsp->rootpath.pathname4_len != 0) 1544 *(p - 1) = '\0'; 1545 else 1546 *p = '\0'; 1547 p = spath; 1548 1549 new_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1550 (void) strlcpy(new_path, p, MAXPATHLEN); 1551 kmem_free(p, MAXPATHLEN); 1552 i = strlen(new_path); 1553 1554 for (op = orig_path; *op; op++) { 1555 if (*op == '/') 1556 num_slashes++; 1557 if (num_slashes == nth + 2) { 1558 while (*op != '\0') { 1559 new_path[i] = *op; 1560 i++; 1561 op++; 1562 } 1563 break; 1564 } 1565 } 1566 new_path[i] = '\0'; 1567 1568 kmem_free(svp->sv_path, svp->sv_pathlen); 1569 svp->sv_pathlen = strlen(new_path) + 1; 1570 svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP); 1571 bcopy(new_path, svp->sv_path, svp->sv_pathlen); 1572 kmem_free(new_path, MAXPATHLEN); 1573 1574 /* 1575 * All the security data is specific to old server. 1576 * Clean it up except secdata which deals with mount options. 1577 * We need to inherit that data. Copy secdata into our new servinfo4. 1578 */ 1579 if (svp->sv_dhsec) { 1580 sec_clnt_freeinfo(svp->sv_dhsec); 1581 svp->sv_dhsec = NULL; 1582 } 1583 if (svp->sv_save_secinfo && 1584 svp->sv_save_secinfo != svp->sv_secinfo) { 1585 secinfo_free(svp->sv_save_secinfo); 1586 svp->sv_save_secinfo = NULL; 1587 } 1588 if (svp->sv_secinfo) { 1589 secinfo_free(svp->sv_secinfo); 1590 svp->sv_secinfo = NULL; 1591 } 1592 svp->sv_currsec = NULL; 1593 1594 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 1595 *secdata = *svp->sv_secdata; 1596 secdata->data = NULL; 1597 if (svp->sv_secdata) { 1598 sec_clnt_freeinfo(svp->sv_secdata); 1599 svp->sv_secdata = NULL; 1600 } 1601 svp->sv_secdata = secdata; 1602 } 1603 1604 /* 1605 * Resolve a referral. The referral is in the n+1th component of 1606 * svp->sv_path and has a parent nfs4 file handle "fh". 1607 * Upon return, the sv_path will point to the new path that has referral 1608 * component resolved to its referred path and part of original path. 1609 * Hostname and other address information is also updated. 1610 */ 1611 int 1612 resolve_referral(mntinfo4_t *mi, servinfo4_t *svp, cred_t *cr, int nth, 1613 nfs_fh4 *fh) 1614 { 1615 nfs4_sharedfh_t *sfh; 1616 struct nfs_fsl_info nfsfsloc; 1617 nfs4_ga_res_t garp; 1618 COMPOUND4res_clnt callres; 1619 fs_location4 *fsp; 1620 char *nm, *orig_path; 1621 int orig_pathlen = 0, ret = -1, index; 1622 1623 if (svp->sv_pathlen <= 0) 1624 return (ret); 1625 1626 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1627 orig_pathlen = svp->sv_pathlen; 1628 orig_path = kmem_alloc(orig_pathlen, KM_SLEEP); 1629 bcopy(svp->sv_path, orig_path, orig_pathlen); 1630 nm = extract_referral_point(svp->sv_path, nth); 1631 setup_newsvpath(svp, nth); 1632 nfs_rw_exit(&svp->sv_lock); 1633 1634 sfh = sfh4_get(fh, mi); 1635 index = nfs4_process_referral(mi, sfh, nm, cr, 1636 &garp, &callres, &nfsfsloc); 1637 sfh4_rele(&sfh); 1638 kmem_free(nm, MAXPATHLEN); 1639 if (index < 0) { 1640 kmem_free(orig_path, orig_pathlen); 1641 return (index); 1642 } 1643 1644 fsp = &garp.n4g_ext_res->n4g_fslocations.locations_val[index]; 1645 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0); 1646 update_servinfo4(svp, fsp, &nfsfsloc, orig_path, nth); 1647 nfs_rw_exit(&svp->sv_lock); 1648 1649 mutex_enter(&mi->mi_lock); 1650 mi->mi_vfs_referral_loop_cnt++; 1651 mutex_exit(&mi->mi_lock); 1652 1653 ret = 0; 1654 bad: 1655 /* Free up XDR memory allocated in nfs4_process_referral() */ 1656 xdr_free(xdr_nfs_fsl_info, (char *)&nfsfsloc); 1657 xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&callres); 1658 kmem_free(orig_path, orig_pathlen); 1659 1660 return (ret); 1661 } 1662 1663 /* 1664 * Get the root filehandle for the given filesystem and server, and update 1665 * svp. 1666 * 1667 * If NFS4_GETFH_NEEDSOP is set, then use nfs4_start_fop and nfs4_end_fop 1668 * to coordinate with recovery. Otherwise, the caller is assumed to be 1669 * the recovery thread or have already done a start_fop. 1670 * 1671 * Errors are returned by the nfs4_error_t parameter. 1672 */ 1673 static void 1674 nfs4getfh_otw(struct mntinfo4 *mi, servinfo4_t *svp, vtype_t *vtp, 1675 int flags, cred_t *cr, nfs4_error_t *ep) 1676 { 1677 COMPOUND4args_clnt args; 1678 COMPOUND4res_clnt res; 1679 int doqueue = 1; 1680 nfs_argop4 *argop; 1681 nfs_resop4 *resop; 1682 nfs4_ga_res_t *garp; 1683 int num_argops; 1684 lookup4_param_t lookuparg; 1685 nfs_fh4 *tmpfhp; 1686 nfs_fh4 *resfhp; 1687 bool_t needrecov = FALSE; 1688 nfs4_recov_state_t recov_state; 1689 int llndx; 1690 int nthcomp; 1691 int recovery = !(flags & NFS4_GETFH_NEEDSOP); 1692 1693 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 1694 ASSERT(svp->sv_path != NULL); 1695 if (svp->sv_path[0] == '\0') { 1696 nfs_rw_exit(&svp->sv_lock); 1697 nfs4_error_init(ep, EINVAL); 1698 return; 1699 } 1700 nfs_rw_exit(&svp->sv_lock); 1701 1702 recov_state.rs_flags = 0; 1703 recov_state.rs_num_retry_despite_err = 0; 1704 1705 recov_retry: 1706 if (mi->mi_vfs_referral_loop_cnt >= NFS4_REFERRAL_LOOP_MAX) { 1707 DTRACE_PROBE3(nfs4clnt__debug__referral__loop, mntinfo4 *, 1708 mi, servinfo4_t *, svp, char *, "nfs4getfh_otw"); 1709 nfs4_error_init(ep, EINVAL); 1710 return; 1711 } 1712 nfs4_error_zinit(ep); 1713 1714 if (!recovery) { 1715 ep->error = nfs4_start_fop(mi, NULL, NULL, OH_MOUNT, 1716 &recov_state, NULL); 1717 1718 /* 1719 * If recovery has been started and this request as 1720 * initiated by a mount, then we must wait for recovery 1721 * to finish before proceeding, otherwise, the error 1722 * cleanup would remove data structures needed by the 1723 * recovery thread. 1724 */ 1725 if (ep->error) { 1726 mutex_enter(&mi->mi_lock); 1727 if (mi->mi_flags & MI4_MOUNTING) { 1728 mi->mi_flags |= MI4_RECOV_FAIL; 1729 mi->mi_error = EIO; 1730 1731 NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE, 1732 "nfs4getfh_otw: waiting 4 recovery\n")); 1733 1734 while (mi->mi_flags & MI4_RECOV_ACTIV) 1735 cv_wait(&mi->mi_failover_cv, 1736 &mi->mi_lock); 1737 } 1738 mutex_exit(&mi->mi_lock); 1739 return; 1740 } 1741 1742 /* 1743 * If the client does not specify a specific flavor to use 1744 * and has not gotten a secinfo list from the server yet, 1745 * retrieve the secinfo list from the server and use a 1746 * flavor from the list to mount. 1747 * 1748 * If fail to get the secinfo list from the server, then 1749 * try the default flavor. 1750 */ 1751 if ((svp->sv_flags & SV4_TRYSECDEFAULT) && 1752 svp->sv_secinfo == NULL) { 1753 (void) nfs4_secinfo_path(mi, cr, FALSE); 1754 } 1755 } 1756 1757 if (recovery) 1758 args.ctag = TAG_REMAP_MOUNT; 1759 else 1760 args.ctag = TAG_MOUNT; 1761 1762 lookuparg.l4_getattrs = LKP4_ALL_ATTRIBUTES; 1763 lookuparg.argsp = &args; 1764 lookuparg.resp = &res; 1765 lookuparg.header_len = 2; /* Putrootfh, getfh */ 1766 lookuparg.trailer_len = 0; 1767 lookuparg.ga_bits = FATTR4_FSINFO_MASK; 1768 lookuparg.mi = mi; 1769 1770 (void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0); 1771 ASSERT(svp->sv_path != NULL); 1772 llndx = nfs4lookup_setup(svp->sv_path, &lookuparg, 0); 1773 nfs_rw_exit(&svp->sv_lock); 1774 1775 argop = args.array; 1776 num_argops = args.array_len; 1777 1778 /* choose public or root filehandle */ 1779 if (flags & NFS4_GETFH_PUBLIC) 1780 argop[0].argop = OP_PUTPUBFH; 1781 else 1782 argop[0].argop = OP_PUTROOTFH; 1783 1784 /* get fh */ 1785 argop[1].argop = OP_GETFH; 1786 1787 NFS4_DEBUG(nfs4_client_call_debug, (CE_NOTE, 1788 "nfs4getfh_otw: %s call, mi 0x%p", 1789 needrecov ? "recov" : "first", (void *)mi)); 1790 1791 rfs4call(mi, &args, &res, cr, &doqueue, RFSCALL_SOFT, ep); 1792 1793 needrecov = nfs4_needs_recovery(ep, FALSE, mi->mi_vfsp); 1794 1795 if (needrecov) { 1796 bool_t abort; 1797 1798 if (recovery) { 1799 nfs4args_lookup_free(argop, num_argops); 1800 kmem_free(argop, 1801 lookuparg.arglen * sizeof (nfs_argop4)); 1802 if (!ep->error) 1803 (void) xdr_free(xdr_COMPOUND4res_clnt, 1804 (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 (void) 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 (void) 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 (void) 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 (void) 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 (void) 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 (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3521 return; 3522 } 3523 3524 if (res.status) { 3525 (void) 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 (void) 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 (void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res); 3605 return; 3606 } 3607 3608 if (res.status) { 3609 (void) 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 (void) 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