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 * Copyright (c) 1986, 2010, Oracle and/or its affiliates. All rights reserved. 23 * 24 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T. 25 * All rights reserved. 26 */ 27 28 #include <sys/param.h> 29 #include <sys/types.h> 30 #include <sys/systm.h> 31 #include <sys/cred.h> 32 #include <sys/vfs.h> 33 #include <sys/vfs_opreg.h> 34 #include <sys/vnode.h> 35 #include <sys/pathname.h> 36 #include <sys/sysmacros.h> 37 #include <sys/kmem.h> 38 #include <sys/mkdev.h> 39 #include <sys/mount.h> 40 #include <sys/mntent.h> 41 #include <sys/statvfs.h> 42 #include <sys/errno.h> 43 #include <sys/debug.h> 44 #include <sys/cmn_err.h> 45 #include <sys/utsname.h> 46 #include <sys/bootconf.h> 47 #include <sys/modctl.h> 48 #include <sys/acl.h> 49 #include <sys/flock.h> 50 #include <sys/policy.h> 51 #include <sys/zone.h> 52 #include <sys/class.h> 53 #include <sys/socket.h> 54 #include <sys/netconfig.h> 55 #include <sys/mntent.h> 56 #include <sys/tsol/label.h> 57 58 #include <rpc/types.h> 59 #include <rpc/auth.h> 60 #include <rpc/clnt.h> 61 62 #include <nfs/nfs.h> 63 #include <nfs/nfs_clnt.h> 64 #include <nfs/rnode.h> 65 #include <nfs/mount.h> 66 #include <nfs/nfs_acl.h> 67 68 #include <fs/fs_subr.h> 69 70 /* 71 * From rpcsec module (common/rpcsec). 72 */ 73 extern int sec_clnt_loadinfo(struct sec_data *, struct sec_data **, model_t); 74 extern void sec_clnt_freeinfo(struct sec_data *); 75 76 static int pathconf_copyin(struct nfs_args *, struct pathcnf *); 77 static int pathconf_get(struct mntinfo *, struct nfs_args *); 78 static void pathconf_rele(struct mntinfo *); 79 80 /* 81 * The order and contents of this structure must be kept in sync with that of 82 * rfsreqcnt_v2_tmpl in nfs_stats.c 83 */ 84 static char *rfsnames_v2[] = { 85 "null", "getattr", "setattr", "unused", "lookup", "readlink", "read", 86 "unused", "write", "create", "remove", "rename", "link", "symlink", 87 "mkdir", "rmdir", "readdir", "fsstat" 88 }; 89 90 /* 91 * This table maps from NFS protocol number into call type. 92 * Zero means a "Lookup" type call 93 * One means a "Read" type call 94 * Two means a "Write" type call 95 * This is used to select a default time-out. 96 */ 97 static uchar_t call_type_v2[] = { 98 0, 0, 1, 0, 0, 0, 1, 99 0, 2, 2, 2, 2, 2, 2, 100 2, 2, 1, 0 101 }; 102 103 /* 104 * Similar table, but to determine which timer to use 105 * (only real reads and writes!) 106 */ 107 static uchar_t timer_type_v2[] = { 108 0, 0, 0, 0, 0, 0, 1, 109 0, 2, 0, 0, 0, 0, 0, 110 0, 0, 1, 0 111 }; 112 113 /* 114 * This table maps from NFS protocol number into a call type 115 * for the semisoft mount option. 116 * Zero means do not repeat operation. 117 * One means repeat. 118 */ 119 static uchar_t ss_call_type_v2[] = { 120 0, 0, 1, 0, 0, 0, 0, 121 0, 1, 1, 1, 1, 1, 1, 122 1, 1, 0, 0 123 }; 124 125 /* 126 * nfs vfs operations. 127 */ 128 static int nfs_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *); 129 static int nfs_unmount(vfs_t *, int, cred_t *); 130 static int nfs_root(vfs_t *, vnode_t **); 131 static int nfs_statvfs(vfs_t *, struct statvfs64 *); 132 static int nfs_sync(vfs_t *, short, cred_t *); 133 static int nfs_vget(vfs_t *, vnode_t **, fid_t *); 134 static int nfs_mountroot(vfs_t *, whymountroot_t); 135 static void nfs_freevfs(vfs_t *); 136 137 static int nfsrootvp(vnode_t **, vfs_t *, struct servinfo *, 138 int, cred_t *, zone_t *); 139 140 /* 141 * Initialize the vfs structure 142 */ 143 144 int nfsfstyp; 145 vfsops_t *nfs_vfsops; 146 147 /* 148 * Debug variable to check for rdma based 149 * transport startup and cleanup. Controlled 150 * through /etc/system. Off by default. 151 */ 152 int rdma_debug = 0; 153 154 int 155 nfsinit(int fstyp, char *name) 156 { 157 static const fs_operation_def_t nfs_vfsops_template[] = { 158 VFSNAME_MOUNT, { .vfs_mount = nfs_mount }, 159 VFSNAME_UNMOUNT, { .vfs_unmount = nfs_unmount }, 160 VFSNAME_ROOT, { .vfs_root = nfs_root }, 161 VFSNAME_STATVFS, { .vfs_statvfs = nfs_statvfs }, 162 VFSNAME_SYNC, { .vfs_sync = nfs_sync }, 163 VFSNAME_VGET, { .vfs_vget = nfs_vget }, 164 VFSNAME_MOUNTROOT, { .vfs_mountroot = nfs_mountroot }, 165 VFSNAME_FREEVFS, { .vfs_freevfs = nfs_freevfs }, 166 NULL, NULL 167 }; 168 int error; 169 170 error = vfs_setfsops(fstyp, nfs_vfsops_template, &nfs_vfsops); 171 if (error != 0) { 172 zcmn_err(GLOBAL_ZONEID, CE_WARN, 173 "nfsinit: bad vfs ops template"); 174 return (error); 175 } 176 177 error = vn_make_ops(name, nfs_vnodeops_template, &nfs_vnodeops); 178 if (error != 0) { 179 (void) vfs_freevfsops_by_type(fstyp); 180 zcmn_err(GLOBAL_ZONEID, CE_WARN, 181 "nfsinit: bad vnode ops template"); 182 return (error); 183 } 184 185 186 nfsfstyp = fstyp; 187 188 return (0); 189 } 190 191 void 192 nfsfini(void) 193 { 194 } 195 196 static void 197 nfs_free_args(struct nfs_args *nargs, nfs_fhandle *fh) 198 { 199 200 if (fh) 201 kmem_free(fh, sizeof (*fh)); 202 203 if (nargs->pathconf) { 204 kmem_free(nargs->pathconf, sizeof (struct pathcnf)); 205 nargs->pathconf = NULL; 206 } 207 208 if (nargs->knconf) { 209 if (nargs->knconf->knc_protofmly) 210 kmem_free(nargs->knconf->knc_protofmly, KNC_STRSIZE); 211 if (nargs->knconf->knc_proto) 212 kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE); 213 kmem_free(nargs->knconf, sizeof (*nargs->knconf)); 214 nargs->knconf = NULL; 215 } 216 217 if (nargs->fh) { 218 kmem_free(nargs->fh, strlen(nargs->fh) + 1); 219 nargs->fh = NULL; 220 } 221 222 if (nargs->hostname) { 223 kmem_free(nargs->hostname, strlen(nargs->hostname) + 1); 224 nargs->hostname = NULL; 225 } 226 227 if (nargs->addr) { 228 if (nargs->addr->buf) { 229 ASSERT(nargs->addr->len); 230 kmem_free(nargs->addr->buf, nargs->addr->len); 231 } 232 kmem_free(nargs->addr, sizeof (struct netbuf)); 233 nargs->addr = NULL; 234 } 235 236 if (nargs->syncaddr) { 237 ASSERT(nargs->syncaddr->len); 238 if (nargs->syncaddr->buf) { 239 ASSERT(nargs->syncaddr->len); 240 kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len); 241 } 242 kmem_free(nargs->syncaddr, sizeof (struct netbuf)); 243 nargs->syncaddr = NULL; 244 } 245 246 if (nargs->netname) { 247 kmem_free(nargs->netname, strlen(nargs->netname) + 1); 248 nargs->netname = NULL; 249 } 250 251 if (nargs->nfs_ext_u.nfs_extA.secdata) { 252 sec_clnt_freeinfo(nargs->nfs_ext_u.nfs_extA.secdata); 253 nargs->nfs_ext_u.nfs_extA.secdata = NULL; 254 } 255 } 256 257 static int 258 nfs_copyin(char *data, int datalen, struct nfs_args *nargs, nfs_fhandle *fh) 259 { 260 261 int error; 262 size_t nlen; /* length of netname */ 263 size_t hlen; /* length of hostname */ 264 char netname[MAXNETNAMELEN+1]; /* server's netname */ 265 struct netbuf addr; /* server's address */ 266 struct netbuf syncaddr; /* AUTH_DES time sync addr */ 267 struct knetconfig *knconf; /* transport knetconfig structure */ 268 struct sec_data *secdata = NULL; /* security data */ 269 STRUCT_DECL(nfs_args, args); /* nfs mount arguments */ 270 STRUCT_DECL(knetconfig, knconf_tmp); 271 STRUCT_DECL(netbuf, addr_tmp); 272 int flags; 273 struct pathcnf *pc; /* Pathconf */ 274 char *p, *pf; 275 char *userbufptr; 276 277 278 bzero(nargs, sizeof (*nargs)); 279 280 STRUCT_INIT(args, get_udatamodel()); 281 bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE)); 282 if (copyin(data, STRUCT_BUF(args), MIN(datalen, STRUCT_SIZE(args)))) 283 return (EFAULT); 284 285 nargs->wsize = STRUCT_FGET(args, wsize); 286 nargs->rsize = STRUCT_FGET(args, rsize); 287 nargs->timeo = STRUCT_FGET(args, timeo); 288 nargs->retrans = STRUCT_FGET(args, retrans); 289 nargs->acregmin = STRUCT_FGET(args, acregmin); 290 nargs->acregmax = STRUCT_FGET(args, acregmax); 291 nargs->acdirmin = STRUCT_FGET(args, acdirmin); 292 nargs->acdirmax = STRUCT_FGET(args, acdirmax); 293 294 flags = STRUCT_FGET(args, flags); 295 nargs->flags = flags; 296 297 298 addr.buf = NULL; 299 syncaddr.buf = NULL; 300 301 /* 302 * Allocate space for a knetconfig structure and 303 * its strings and copy in from user-land. 304 */ 305 knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP); 306 STRUCT_INIT(knconf_tmp, get_udatamodel()); 307 if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp), 308 STRUCT_SIZE(knconf_tmp))) { 309 kmem_free(knconf, sizeof (*knconf)); 310 return (EFAULT); 311 } 312 313 knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics); 314 knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly); 315 knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto); 316 if (get_udatamodel() != DATAMODEL_LP64) { 317 knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev)); 318 } else { 319 knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev); 320 } 321 322 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 323 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 324 error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL); 325 if (error) { 326 kmem_free(pf, KNC_STRSIZE); 327 kmem_free(p, KNC_STRSIZE); 328 kmem_free(knconf, sizeof (*knconf)); 329 return (error); 330 } 331 332 error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL); 333 if (error) { 334 kmem_free(pf, KNC_STRSIZE); 335 kmem_free(p, KNC_STRSIZE); 336 kmem_free(knconf, sizeof (*knconf)); 337 return (error); 338 } 339 340 341 knconf->knc_protofmly = pf; 342 knconf->knc_proto = p; 343 344 nargs->knconf = knconf; 345 346 /* Copyin pathconf if there is one */ 347 if (STRUCT_FGETP(args, pathconf) != NULL) { 348 pc = kmem_alloc(sizeof (*pc), KM_SLEEP); 349 error = pathconf_copyin(STRUCT_BUF(args), pc); 350 nargs->pathconf = pc; 351 if (error) 352 goto errout; 353 } 354 355 /* 356 * Get server address 357 */ 358 STRUCT_INIT(addr_tmp, get_udatamodel()); 359 if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp), 360 STRUCT_SIZE(addr_tmp))) { 361 error = EFAULT; 362 goto errout; 363 } 364 nargs->addr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP); 365 userbufptr = STRUCT_FGETP(addr_tmp, buf); 366 addr.len = STRUCT_FGET(addr_tmp, len); 367 addr.buf = kmem_alloc(addr.len, KM_SLEEP); 368 addr.maxlen = addr.len; 369 if (copyin(userbufptr, addr.buf, addr.len)) { 370 kmem_free(addr.buf, addr.len); 371 error = EFAULT; 372 goto errout; 373 } 374 bcopy(&addr, nargs->addr, sizeof (struct netbuf)); 375 376 /* 377 * Get the root fhandle 378 */ 379 380 if (copyin(STRUCT_FGETP(args, fh), &fh->fh_buf, NFS_FHSIZE)) { 381 error = EFAULT; 382 goto errout; 383 } 384 fh->fh_len = NFS_FHSIZE; 385 386 /* 387 * Get server's hostname 388 */ 389 if (flags & NFSMNT_HOSTNAME) { 390 error = copyinstr(STRUCT_FGETP(args, hostname), netname, 391 sizeof (netname), &hlen); 392 if (error) 393 goto errout; 394 nargs->hostname = kmem_zalloc(hlen, KM_SLEEP); 395 (void) strcpy(nargs->hostname, netname); 396 397 } else { 398 nargs->hostname = NULL; 399 } 400 401 402 /* 403 * If there are syncaddr and netname data, load them in. This is 404 * to support data needed for NFSV4 when AUTH_DH is the negotiated 405 * flavor via SECINFO. (instead of using MOUNT protocol in V3). 406 */ 407 netname[0] = '\0'; 408 if (flags & NFSMNT_SECURE) { 409 if (STRUCT_FGETP(args, syncaddr) == NULL) { 410 error = EINVAL; 411 goto errout; 412 } 413 /* get syncaddr */ 414 STRUCT_INIT(addr_tmp, get_udatamodel()); 415 if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp), 416 STRUCT_SIZE(addr_tmp))) { 417 error = EINVAL; 418 goto errout; 419 } 420 userbufptr = STRUCT_FGETP(addr_tmp, buf); 421 syncaddr.len = STRUCT_FGET(addr_tmp, len); 422 syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP); 423 syncaddr.maxlen = syncaddr.len; 424 if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) { 425 kmem_free(syncaddr.buf, syncaddr.len); 426 error = EFAULT; 427 goto errout; 428 } 429 430 nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP); 431 bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf)); 432 433 ASSERT(STRUCT_FGETP(args, netname)); 434 if (copyinstr(STRUCT_FGETP(args, netname), netname, 435 sizeof (netname), &nlen)) { 436 error = EFAULT; 437 goto errout; 438 } 439 440 netname[nlen] = '\0'; 441 nargs->netname = kmem_zalloc(nlen, KM_SLEEP); 442 (void) strcpy(nargs->netname, netname); 443 } 444 445 /* 446 * Get the extention data which has the security data structure. 447 * This includes data for AUTH_SYS as well. 448 */ 449 if (flags & NFSMNT_NEWARGS) { 450 nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext); 451 if (nargs->nfs_args_ext == NFS_ARGS_EXTA || 452 nargs->nfs_args_ext == NFS_ARGS_EXTB) { 453 /* 454 * Indicating the application is using the new 455 * sec_data structure to pass in the security 456 * data. 457 */ 458 if (STRUCT_FGETP(args, 459 nfs_ext_u.nfs_extA.secdata) != NULL) { 460 error = sec_clnt_loadinfo( 461 (struct sec_data *)STRUCT_FGETP(args, 462 nfs_ext_u.nfs_extA.secdata), &secdata, 463 get_udatamodel()); 464 } 465 nargs->nfs_ext_u.nfs_extA.secdata = secdata; 466 } 467 } 468 469 if (error) 470 goto errout; 471 472 /* 473 * Failover support: 474 * 475 * We may have a linked list of nfs_args structures, 476 * which means the user is looking for failover. If 477 * the mount is either not "read-only" or "soft", 478 * we want to bail out with EINVAL. 479 */ 480 if (nargs->nfs_args_ext == NFS_ARGS_EXTB) 481 nargs->nfs_ext_u.nfs_extB.next = 482 STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next); 483 484 errout: 485 if (error) 486 nfs_free_args(nargs, fh); 487 488 return (error); 489 } 490 491 492 /* 493 * nfs mount vfsop 494 * Set up mount info record and attach it to vfs struct. 495 */ 496 static int 497 nfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 498 { 499 char *data = uap->dataptr; 500 int error; 501 vnode_t *rtvp; /* the server's root */ 502 mntinfo_t *mi; /* mount info, pointed at by vfs */ 503 size_t nlen; /* length of netname */ 504 struct knetconfig *knconf; /* transport knetconfig structure */ 505 struct knetconfig *rdma_knconf; /* rdma transport structure */ 506 rnode_t *rp; 507 struct servinfo *svp; /* nfs server info */ 508 struct servinfo *svp_tail = NULL; /* previous nfs server info */ 509 struct servinfo *svp_head; /* first nfs server info */ 510 struct servinfo *svp_2ndlast; /* 2nd last in the server info list */ 511 struct sec_data *secdata; /* security data */ 512 struct nfs_args *args = NULL; 513 int flags, addr_type; 514 zone_t *zone = nfs_zone(); 515 zone_t *mntzone = NULL; 516 nfs_fhandle *fhandle = NULL; 517 518 if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0) 519 return (error); 520 521 if (mvp->v_type != VDIR) 522 return (ENOTDIR); 523 524 /* 525 * get arguments 526 * 527 * nfs_args is now versioned and is extensible, so 528 * uap->datalen might be different from sizeof (args) 529 * in a compatible situation. 530 */ 531 more: 532 533 if (!(uap->flags & MS_SYSSPACE)) { 534 if (args == NULL) 535 args = kmem_alloc(sizeof (struct nfs_args), KM_SLEEP); 536 else { 537 nfs_free_args(args, fhandle); 538 fhandle = NULL; 539 } 540 if (fhandle == NULL) 541 fhandle = kmem_zalloc(sizeof (nfs_fhandle), KM_SLEEP); 542 error = nfs_copyin(data, uap->datalen, args, fhandle); 543 if (error) { 544 if (args) 545 kmem_free(args, sizeof (*args)); 546 return (error); 547 } 548 } else { 549 args = (struct nfs_args *)data; 550 fhandle = (nfs_fhandle *)args->fh; 551 } 552 553 554 flags = args->flags; 555 556 if (uap->flags & MS_REMOUNT) { 557 size_t n; 558 char name[FSTYPSZ]; 559 560 if (uap->flags & MS_SYSSPACE) 561 error = copystr(uap->fstype, name, FSTYPSZ, &n); 562 else 563 error = copyinstr(uap->fstype, name, FSTYPSZ, &n); 564 565 if (error) { 566 if (error == ENAMETOOLONG) 567 return (EINVAL); 568 return (error); 569 } 570 571 572 /* 573 * This check is to ensure that the request is a 574 * genuine nfs remount request. 575 */ 576 577 if (strncmp(name, "nfs", 3) != 0) 578 return (EINVAL); 579 580 /* 581 * If the request changes the locking type, disallow the 582 * remount, 583 * because it's questionable whether we can transfer the 584 * locking state correctly. 585 * 586 * Remounts need to save the pathconf information. 587 * Part of the infamous static kludge. 588 */ 589 590 if ((mi = VFTOMI(vfsp)) != NULL) { 591 uint_t new_mi_llock; 592 uint_t old_mi_llock; 593 594 new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0; 595 old_mi_llock = (mi->mi_flags & MI_LLOCK) ? 1 : 0; 596 if (old_mi_llock != new_mi_llock) 597 return (EBUSY); 598 } 599 error = pathconf_get((struct mntinfo *)vfsp->vfs_data, args); 600 601 if (!(uap->flags & MS_SYSSPACE)) { 602 nfs_free_args(args, fhandle); 603 kmem_free(args, sizeof (*args)); 604 } 605 606 return (error); 607 } 608 609 mutex_enter(&mvp->v_lock); 610 if (!(uap->flags & MS_OVERLAY) && 611 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 612 mutex_exit(&mvp->v_lock); 613 if (!(uap->flags & MS_SYSSPACE)) { 614 nfs_free_args(args, fhandle); 615 kmem_free(args, sizeof (*args)); 616 } 617 return (EBUSY); 618 } 619 mutex_exit(&mvp->v_lock); 620 621 /* make sure things are zeroed for errout: */ 622 rtvp = NULL; 623 mi = NULL; 624 secdata = NULL; 625 626 /* 627 * A valid knetconfig structure is required. 628 */ 629 if (!(flags & NFSMNT_KNCONF)) { 630 if (!(uap->flags & MS_SYSSPACE)) { 631 nfs_free_args(args, fhandle); 632 kmem_free(args, sizeof (*args)); 633 } 634 return (EINVAL); 635 } 636 637 if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) || 638 (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) { 639 if (!(uap->flags & MS_SYSSPACE)) { 640 nfs_free_args(args, fhandle); 641 kmem_free(args, sizeof (*args)); 642 } 643 return (EINVAL); 644 } 645 646 647 /* 648 * Allocate a servinfo struct. 649 */ 650 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP); 651 mutex_init(&svp->sv_lock, NULL, MUTEX_DEFAULT, NULL); 652 if (svp_tail) { 653 svp_2ndlast = svp_tail; 654 svp_tail->sv_next = svp; 655 } else { 656 svp_head = svp; 657 svp_2ndlast = svp; 658 } 659 660 svp_tail = svp; 661 662 /* 663 * Get knetconfig and server address 664 */ 665 svp->sv_knconf = args->knconf; 666 args->knconf = NULL; 667 668 if (args->addr == NULL || args->addr->buf == NULL) { 669 error = EINVAL; 670 goto errout; 671 } 672 673 svp->sv_addr.maxlen = args->addr->maxlen; 674 svp->sv_addr.len = args->addr->len; 675 svp->sv_addr.buf = args->addr->buf; 676 args->addr->buf = NULL; 677 678 /* 679 * Get the root fhandle 680 */ 681 ASSERT(fhandle); 682 683 bcopy(&fhandle->fh_buf, &svp->sv_fhandle.fh_buf, fhandle->fh_len); 684 svp->sv_fhandle.fh_len = fhandle->fh_len; 685 686 /* 687 * Get server's hostname 688 */ 689 if (flags & NFSMNT_HOSTNAME) { 690 if (args->hostname == NULL) { 691 error = EINVAL; 692 goto errout; 693 } 694 svp->sv_hostnamelen = strlen(args->hostname) + 1; 695 svp->sv_hostname = args->hostname; 696 args->hostname = NULL; 697 } else { 698 char *p = "unknown-host"; 699 svp->sv_hostnamelen = strlen(p) + 1; 700 svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP); 701 (void) strcpy(svp->sv_hostname, p); 702 } 703 704 705 /* 706 * RDMA MOUNT SUPPORT FOR NFS v2: 707 * Establish, is it possible to use RDMA, if so overload the 708 * knconf with rdma specific knconf and free the orignal. 709 */ 710 if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) { 711 /* 712 * Determine the addr type for RDMA, IPv4 or v6. 713 */ 714 if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0) 715 addr_type = AF_INET; 716 else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0) 717 addr_type = AF_INET6; 718 719 if (rdma_reachable(addr_type, &svp->sv_addr, 720 &rdma_knconf) == 0) { 721 /* 722 * If successful, hijack, the orignal knconf and 723 * replace with a new one, depending on the flags. 724 */ 725 svp->sv_origknconf = svp->sv_knconf; 726 svp->sv_knconf = rdma_knconf; 727 knconf = rdma_knconf; 728 } else { 729 if (flags & NFSMNT_TRYRDMA) { 730 #ifdef DEBUG 731 if (rdma_debug) 732 zcmn_err(getzoneid(), CE_WARN, 733 "no RDMA onboard, revert\n"); 734 #endif 735 } 736 737 if (flags & NFSMNT_DORDMA) { 738 /* 739 * If proto=rdma is specified and no RDMA 740 * path to this server is avialable then 741 * ditch this server. 742 * This is not included in the mountable 743 * server list or the replica list. 744 * Check if more servers are specified; 745 * Failover case, otherwise bail out of mount. 746 */ 747 if (args->nfs_args_ext == NFS_ARGS_EXTB && 748 args->nfs_ext_u.nfs_extB.next != NULL) { 749 data = (char *) 750 args->nfs_ext_u.nfs_extB.next; 751 if (uap->flags & MS_RDONLY && 752 !(flags & NFSMNT_SOFT)) { 753 if (svp_head->sv_next == NULL) { 754 svp_tail = NULL; 755 svp_2ndlast = NULL; 756 sv_free(svp_head); 757 goto more; 758 } else { 759 svp_tail = svp_2ndlast; 760 svp_2ndlast->sv_next = 761 NULL; 762 sv_free(svp); 763 goto more; 764 } 765 } 766 } else { 767 /* 768 * This is the last server specified 769 * in the nfs_args list passed down 770 * and its not rdma capable. 771 */ 772 if (svp_head->sv_next == NULL) { 773 /* 774 * Is this the only one 775 */ 776 error = EINVAL; 777 #ifdef DEBUG 778 if (rdma_debug) 779 zcmn_err(getzoneid(), 780 CE_WARN, 781 "No RDMA srv"); 782 #endif 783 goto errout; 784 } else { 785 /* 786 * There is list, since some 787 * servers specified before 788 * this passed all requirements 789 */ 790 svp_tail = svp_2ndlast; 791 svp_2ndlast->sv_next = NULL; 792 sv_free(svp); 793 goto proceed; 794 } 795 } 796 } 797 } 798 } 799 800 /* 801 * Get the extention data which has the new security data structure. 802 */ 803 if (flags & NFSMNT_NEWARGS) { 804 switch (args->nfs_args_ext) { 805 case NFS_ARGS_EXTA: 806 case NFS_ARGS_EXTB: 807 /* 808 * Indicating the application is using the new 809 * sec_data structure to pass in the security 810 * data. 811 */ 812 secdata = args->nfs_ext_u.nfs_extA.secdata; 813 if (secdata == NULL) { 814 error = EINVAL; 815 } else { 816 /* 817 * Need to validate the flavor here if 818 * sysspace, userspace was already 819 * validate from the nfs_copyin function. 820 */ 821 switch (secdata->rpcflavor) { 822 case AUTH_NONE: 823 case AUTH_UNIX: 824 case AUTH_LOOPBACK: 825 case AUTH_DES: 826 case RPCSEC_GSS: 827 break; 828 default: 829 error = EINVAL; 830 goto errout; 831 } 832 } 833 args->nfs_ext_u.nfs_extA.secdata = NULL; 834 break; 835 836 default: 837 error = EINVAL; 838 break; 839 } 840 } else if (flags & NFSMNT_SECURE) { 841 /* 842 * Keep this for backward compatibility to support 843 * NFSMNT_SECURE/NFSMNT_RPCTIMESYNC flags. 844 */ 845 if (args->syncaddr == NULL || args->syncaddr->buf == NULL) { 846 error = EINVAL; 847 goto errout; 848 } 849 850 /* 851 * get time sync address. 852 */ 853 if (args->syncaddr == NULL) { 854 error = EFAULT; 855 goto errout; 856 } 857 858 /* 859 * Move security related data to the sec_data structure. 860 */ 861 { 862 dh_k4_clntdata_t *data; 863 char *pf, *p; 864 865 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 866 if (flags & NFSMNT_RPCTIMESYNC) 867 secdata->flags |= AUTH_F_RPCTIMESYNC; 868 data = kmem_alloc(sizeof (*data), KM_SLEEP); 869 bcopy(args->syncaddr, &data->syncaddr, 870 sizeof (*args->syncaddr)); 871 872 873 /* 874 * duplicate the knconf information for the 875 * new opaque data. 876 */ 877 data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP); 878 *data->knconf = *knconf; 879 pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 880 p = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 881 bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE); 882 bcopy(knconf->knc_proto, pf, KNC_STRSIZE); 883 data->knconf->knc_protofmly = pf; 884 data->knconf->knc_proto = p; 885 886 /* move server netname to the sec_data structure */ 887 nlen = strlen(args->hostname) + 1; 888 if (nlen != 0) { 889 data->netname = kmem_alloc(nlen, KM_SLEEP); 890 bcopy(args->hostname, data->netname, nlen); 891 data->netnamelen = (int)nlen; 892 } 893 secdata->secmod = secdata->rpcflavor = AUTH_DES; 894 secdata->data = (caddr_t)data; 895 } 896 } else { 897 secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP); 898 secdata->secmod = secdata->rpcflavor = AUTH_UNIX; 899 secdata->data = NULL; 900 } 901 svp->sv_secdata = secdata; 902 903 /* 904 * See bug 1180236. 905 * If mount secure failed, we will fall back to AUTH_NONE 906 * and try again. nfs3rootvp() will turn this back off. 907 * 908 * The NFS Version 2 mount uses GETATTR and STATFS procedures. 909 * The server does not care if these procedures have the proper 910 * authentication flavor, so if mount retries using AUTH_NONE 911 * that does not require a credential setup for root then the 912 * automounter would work without requiring root to be 913 * keylogged into AUTH_DES. 914 */ 915 if (secdata->rpcflavor != AUTH_UNIX && 916 secdata->rpcflavor != AUTH_LOOPBACK) 917 secdata->flags |= AUTH_F_TRYNONE; 918 919 /* 920 * Failover support: 921 * 922 * We may have a linked list of nfs_args structures, 923 * which means the user is looking for failover. If 924 * the mount is either not "read-only" or "soft", 925 * we want to bail out with EINVAL. 926 */ 927 if (args->nfs_args_ext == NFS_ARGS_EXTB && 928 args->nfs_ext_u.nfs_extB.next != NULL) { 929 if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) { 930 data = (char *)args->nfs_ext_u.nfs_extB.next; 931 goto more; 932 } 933 error = EINVAL; 934 goto errout; 935 } 936 937 /* 938 * Determine the zone we're being mounted into. 939 */ 940 zone_hold(mntzone = zone); /* start with this assumption */ 941 if (getzoneid() == GLOBAL_ZONEID) { 942 zone_rele(mntzone); 943 mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 944 ASSERT(mntzone != NULL); 945 if (mntzone != zone) { 946 error = EBUSY; 947 goto errout; 948 } 949 } 950 951 if (is_system_labeled()) { 952 error = nfs_mount_label_policy(vfsp, &svp->sv_addr, 953 svp->sv_knconf, cr); 954 955 if (error > 0) 956 goto errout; 957 958 if (error == -1) { 959 /* change mount to read-only to prevent write-down */ 960 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 961 } 962 } 963 964 /* 965 * Stop the mount from going any further if the zone is going away. 966 */ 967 if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) { 968 error = EBUSY; 969 goto errout; 970 } 971 972 /* 973 * Get root vnode. 974 */ 975 proceed: 976 error = nfsrootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone); 977 978 if (error) 979 goto errout; 980 981 /* 982 * Set option fields in the mount info record 983 */ 984 mi = VTOMI(rtvp); 985 986 if (svp_head->sv_next) 987 mi->mi_flags |= MI_LLOCK; 988 989 error = nfs_setopts(rtvp, DATAMODEL_NATIVE, args); 990 if (!error) { 991 /* static pathconf kludge */ 992 error = pathconf_get(mi, args); 993 } 994 995 errout: 996 if (rtvp != NULL) { 997 if (error) { 998 rp = VTOR(rtvp); 999 if (rp->r_flags & RHASHED) 1000 rp_rmhash(rp); 1001 } 1002 VN_RELE(rtvp); 1003 } 1004 1005 if (error) { 1006 sv_free(svp_head); 1007 if (mi != NULL) { 1008 nfs_async_stop(vfsp); 1009 nfs_async_manager_stop(vfsp); 1010 if (mi->mi_io_kstats) { 1011 kstat_delete(mi->mi_io_kstats); 1012 mi->mi_io_kstats = NULL; 1013 } 1014 if (mi->mi_ro_kstats) { 1015 kstat_delete(mi->mi_ro_kstats); 1016 mi->mi_ro_kstats = NULL; 1017 } 1018 nfs_free_mi(mi); 1019 } 1020 } 1021 1022 if (!(uap->flags & MS_SYSSPACE)) { 1023 nfs_free_args(args, fhandle); 1024 kmem_free(args, sizeof (*args)); 1025 } 1026 1027 if (mntzone != NULL) 1028 zone_rele(mntzone); 1029 1030 return (error); 1031 } 1032 1033 /* 1034 * The pathconf information is kept on a linked list of kmem_alloc'ed 1035 * structs. We search the list & add a new struct iff there is no other 1036 * struct with the same information. 1037 * See sys/pathconf.h for ``the rest of the story.'' 1038 */ 1039 static struct pathcnf *allpc = NULL; 1040 1041 static int 1042 pathconf_copyin(struct nfs_args *args, struct pathcnf *pc) 1043 { 1044 STRUCT_DECL(pathcnf, pc_tmp); 1045 STRUCT_HANDLE(nfs_args, ap); 1046 int i; 1047 model_t model; 1048 1049 model = get_udatamodel(); 1050 STRUCT_INIT(pc_tmp, model); 1051 STRUCT_SET_HANDLE(ap, model, args); 1052 1053 if ((STRUCT_FGET(ap, flags) & NFSMNT_POSIX) && 1054 STRUCT_FGETP(ap, pathconf) != NULL) { 1055 if (copyin(STRUCT_FGETP(ap, pathconf), STRUCT_BUF(pc_tmp), 1056 STRUCT_SIZE(pc_tmp))) 1057 return (EFAULT); 1058 if (_PC_ISSET(_PC_ERROR, STRUCT_FGET(pc_tmp, pc_mask))) 1059 return (EINVAL); 1060 1061 pc->pc_link_max = STRUCT_FGET(pc_tmp, pc_link_max); 1062 pc->pc_max_canon = STRUCT_FGET(pc_tmp, pc_max_canon); 1063 pc->pc_max_input = STRUCT_FGET(pc_tmp, pc_max_input); 1064 pc->pc_name_max = STRUCT_FGET(pc_tmp, pc_name_max); 1065 pc->pc_path_max = STRUCT_FGET(pc_tmp, pc_path_max); 1066 pc->pc_pipe_buf = STRUCT_FGET(pc_tmp, pc_pipe_buf); 1067 pc->pc_vdisable = STRUCT_FGET(pc_tmp, pc_vdisable); 1068 pc->pc_xxx = STRUCT_FGET(pc_tmp, pc_xxx); 1069 for (i = 0; i < _PC_N; i++) 1070 pc->pc_mask[i] = STRUCT_FGET(pc_tmp, pc_mask[i]); 1071 } 1072 return (0); 1073 } 1074 1075 static int 1076 pathconf_get(struct mntinfo *mi, struct nfs_args *args) 1077 { 1078 struct pathcnf *p, *pc; 1079 1080 pc = args->pathconf; 1081 if (mi->mi_pathconf != NULL) { 1082 pathconf_rele(mi); 1083 mi->mi_pathconf = NULL; 1084 } 1085 1086 if (args->flags & NFSMNT_POSIX && args->pathconf != NULL) { 1087 if (_PC_ISSET(_PC_ERROR, pc->pc_mask)) 1088 return (EINVAL); 1089 1090 for (p = allpc; p != NULL; p = p->pc_next) { 1091 if (PCCMP(p, pc) == 0) 1092 break; 1093 } 1094 if (p != NULL) { 1095 mi->mi_pathconf = p; 1096 p->pc_refcnt++; 1097 } else { 1098 p = kmem_alloc(sizeof (*p), KM_SLEEP); 1099 bcopy(pc, p, sizeof (struct pathcnf)); 1100 p->pc_next = allpc; 1101 p->pc_refcnt = 1; 1102 allpc = mi->mi_pathconf = p; 1103 } 1104 } 1105 return (0); 1106 } 1107 1108 /* 1109 * release the static pathconf information 1110 */ 1111 static void 1112 pathconf_rele(struct mntinfo *mi) 1113 { 1114 if (mi->mi_pathconf != NULL) { 1115 if (--mi->mi_pathconf->pc_refcnt == 0) { 1116 struct pathcnf *p; 1117 struct pathcnf *p2; 1118 1119 p2 = p = allpc; 1120 while (p != NULL && p != mi->mi_pathconf) { 1121 p2 = p; 1122 p = p->pc_next; 1123 } 1124 if (p == NULL) { 1125 panic("mi->pathconf"); 1126 /*NOTREACHED*/ 1127 } 1128 if (p == allpc) 1129 allpc = p->pc_next; 1130 else 1131 p2->pc_next = p->pc_next; 1132 kmem_free(p, sizeof (*p)); 1133 mi->mi_pathconf = NULL; 1134 } 1135 } 1136 } 1137 1138 static int nfs_dynamic = 1; /* global variable to enable dynamic retrans. */ 1139 static ushort_t nfs_max_threads = 8; /* max number of active async threads */ 1140 static uint_t nfs_async_clusters = 1; /* # of reqs from each async queue */ 1141 static uint_t nfs_cots_timeo = NFS_COTS_TIMEO; 1142 1143 static int 1144 nfsrootvp(vnode_t **rtvpp, vfs_t *vfsp, struct servinfo *svp, 1145 int flags, cred_t *cr, zone_t *zone) 1146 { 1147 vnode_t *rtvp; 1148 mntinfo_t *mi; 1149 dev_t nfs_dev; 1150 struct vattr va; 1151 int error; 1152 rnode_t *rp; 1153 int i; 1154 struct nfs_stats *nfsstatsp; 1155 cred_t *lcr = NULL, *tcr = cr; 1156 1157 nfsstatsp = zone_getspecific(nfsstat_zone_key, nfs_zone()); 1158 ASSERT(nfsstatsp != NULL); 1159 1160 /* 1161 * Create a mount record and link it to the vfs struct. 1162 */ 1163 mi = kmem_zalloc(sizeof (*mi), KM_SLEEP); 1164 mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL); 1165 mutex_init(&mi->mi_remap_lock, NULL, MUTEX_DEFAULT, NULL); 1166 mi->mi_flags = MI_ACL | MI_EXTATTR; 1167 if (!(flags & NFSMNT_SOFT)) 1168 mi->mi_flags |= MI_HARD; 1169 if ((flags & NFSMNT_SEMISOFT)) 1170 mi->mi_flags |= MI_SEMISOFT; 1171 if ((flags & NFSMNT_NOPRINT)) 1172 mi->mi_flags |= MI_NOPRINT; 1173 if (flags & NFSMNT_INT) 1174 mi->mi_flags |= MI_INT; 1175 mi->mi_retrans = NFS_RETRIES; 1176 if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD || 1177 svp->sv_knconf->knc_semantics == NC_TPI_COTS) 1178 mi->mi_timeo = nfs_cots_timeo; 1179 else 1180 mi->mi_timeo = NFS_TIMEO; 1181 mi->mi_prog = NFS_PROGRAM; 1182 mi->mi_vers = NFS_VERSION; 1183 mi->mi_rfsnames = rfsnames_v2; 1184 mi->mi_reqs = nfsstatsp->nfs_stats_v2.rfsreqcnt_ptr; 1185 mi->mi_call_type = call_type_v2; 1186 mi->mi_ss_call_type = ss_call_type_v2; 1187 mi->mi_timer_type = timer_type_v2; 1188 mi->mi_aclnames = aclnames_v2; 1189 mi->mi_aclreqs = nfsstatsp->nfs_stats_v2.aclreqcnt_ptr; 1190 mi->mi_acl_call_type = acl_call_type_v2; 1191 mi->mi_acl_ss_call_type = acl_ss_call_type_v2; 1192 mi->mi_acl_timer_type = acl_timer_type_v2; 1193 cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL); 1194 mi->mi_servers = svp; 1195 mi->mi_curr_serv = svp; 1196 mi->mi_acregmin = SEC2HR(ACREGMIN); 1197 mi->mi_acregmax = SEC2HR(ACREGMAX); 1198 mi->mi_acdirmin = SEC2HR(ACDIRMIN); 1199 mi->mi_acdirmax = SEC2HR(ACDIRMAX); 1200 1201 if (nfs_dynamic) 1202 mi->mi_flags |= MI_DYNAMIC; 1203 1204 if (flags & NFSMNT_DIRECTIO) 1205 mi->mi_flags |= MI_DIRECTIO; 1206 1207 mutex_init(&mi->mi_rnodes_lock, NULL, MUTEX_DEFAULT, NULL); 1208 list_create(&mi->mi_rnodes, sizeof (rnode_t), 1209 offsetof(rnode_t, r_mi_link)); 1210 1211 /* 1212 * Make a vfs struct for nfs. We do this here instead of below 1213 * because rtvp needs a vfs before we can do a getattr on it. 1214 * 1215 * Assign a unique device id to the mount 1216 */ 1217 mutex_enter(&nfs_minor_lock); 1218 do { 1219 nfs_minor = (nfs_minor + 1) & MAXMIN32; 1220 nfs_dev = makedevice(nfs_major, nfs_minor); 1221 } while (vfs_devismounted(nfs_dev)); 1222 mutex_exit(&nfs_minor_lock); 1223 1224 vfsp->vfs_dev = nfs_dev; 1225 vfs_make_fsid(&vfsp->vfs_fsid, nfs_dev, nfsfstyp); 1226 vfsp->vfs_data = (caddr_t)mi; 1227 vfsp->vfs_fstype = nfsfstyp; 1228 vfsp->vfs_bsize = NFS_MAXDATA; 1229 1230 /* 1231 * Initialize fields used to support async putpage operations. 1232 */ 1233 for (i = 0; i < NFS_ASYNC_TYPES; i++) 1234 mi->mi_async_clusters[i] = nfs_async_clusters; 1235 mi->mi_async_init_clusters = nfs_async_clusters; 1236 mi->mi_async_curr[NFS_ASYNC_QUEUE] = 1237 mi->mi_async_curr[NFS_ASYNC_PGOPS_QUEUE] = &mi->mi_async_reqs[0]; 1238 mi->mi_max_threads = nfs_max_threads; 1239 mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL); 1240 cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL); 1241 cv_init(&mi->mi_async_work_cv[NFS_ASYNC_QUEUE], NULL, CV_DEFAULT, NULL); 1242 cv_init(&mi->mi_async_work_cv[NFS_ASYNC_PGOPS_QUEUE], NULL, 1243 CV_DEFAULT, NULL); 1244 cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL); 1245 1246 mi->mi_vfsp = vfsp; 1247 mi->mi_zone = zone; 1248 zone_init_ref(&mi->mi_zone_ref); 1249 zone_hold_ref(zone, &mi->mi_zone_ref, ZONE_REF_NFS); 1250 nfs_mi_zonelist_add(mi); 1251 1252 /* 1253 * Make the root vnode, use it to get attributes, 1254 * then remake it with the attributes. 1255 */ 1256 rtvp = makenfsnode((fhandle_t *)svp->sv_fhandle.fh_buf, 1257 NULL, vfsp, gethrtime(), cr, NULL, NULL); 1258 1259 va.va_mask = AT_ALL; 1260 1261 /* 1262 * If the uid is set then set the creds for secure mounts 1263 * by proxy processes such as automountd. 1264 */ 1265 if (svp->sv_secdata->uid != 0 && 1266 svp->sv_secdata->rpcflavor == RPCSEC_GSS) { 1267 lcr = crdup(cr); 1268 (void) crsetugid(lcr, svp->sv_secdata->uid, crgetgid(cr)); 1269 tcr = lcr; 1270 } 1271 1272 error = nfsgetattr(rtvp, &va, tcr); 1273 if (error) 1274 goto bad; 1275 rtvp->v_type = va.va_type; 1276 1277 /* 1278 * Poll every server to get the filesystem stats; we're 1279 * only interested in the server's transfer size, and we 1280 * want the minimum. 1281 * 1282 * While we're looping, we'll turn off AUTH_F_TRYNONE, 1283 * which is only for the mount operation. 1284 */ 1285 1286 mi->mi_tsize = MIN(NFS_MAXDATA, nfstsize()); 1287 mi->mi_stsize = MIN(NFS_MAXDATA, nfstsize()); 1288 1289 for (svp = mi->mi_servers; svp != NULL; svp = svp->sv_next) { 1290 struct nfsstatfs fs; 1291 int douprintf; 1292 1293 douprintf = 1; 1294 mi->mi_curr_serv = svp; 1295 1296 error = rfs2call(mi, RFS_STATFS, xdr_fhandle, 1297 (caddr_t)svp->sv_fhandle.fh_buf, xdr_statfs, (caddr_t)&fs, 1298 tcr, &douprintf, &fs.fs_status, 0, NULL); 1299 if (error) 1300 goto bad; 1301 mi->mi_stsize = MIN(mi->mi_stsize, fs.fs_tsize); 1302 svp->sv_secdata->flags &= ~AUTH_F_TRYNONE; 1303 } 1304 mi->mi_curr_serv = mi->mi_servers; 1305 mi->mi_curread = mi->mi_tsize; 1306 mi->mi_curwrite = mi->mi_stsize; 1307 1308 /* 1309 * Start the manager thread responsible for handling async worker 1310 * threads. 1311 */ 1312 VFS_HOLD(vfsp); /* add reference for thread */ 1313 mi->mi_manager_thread = zthread_create(NULL, 0, nfs_async_manager, 1314 vfsp, 0, minclsyspri); 1315 ASSERT(mi->mi_manager_thread != NULL); 1316 1317 /* 1318 * Initialize kstats 1319 */ 1320 nfs_mnt_kstat_init(vfsp); 1321 1322 mi->mi_type = rtvp->v_type; 1323 1324 *rtvpp = rtvp; 1325 if (lcr != NULL) 1326 crfree(lcr); 1327 1328 return (0); 1329 bad: 1330 /* 1331 * An error occurred somewhere, need to clean up... 1332 * We need to release our reference to the root vnode and 1333 * destroy the mntinfo struct that we just created. 1334 */ 1335 if (lcr != NULL) 1336 crfree(lcr); 1337 rp = VTOR(rtvp); 1338 if (rp->r_flags & RHASHED) 1339 rp_rmhash(rp); 1340 VN_RELE(rtvp); 1341 nfs_async_stop(vfsp); 1342 nfs_async_manager_stop(vfsp); 1343 if (mi->mi_io_kstats) { 1344 kstat_delete(mi->mi_io_kstats); 1345 mi->mi_io_kstats = NULL; 1346 } 1347 if (mi->mi_ro_kstats) { 1348 kstat_delete(mi->mi_ro_kstats); 1349 mi->mi_ro_kstats = NULL; 1350 } 1351 nfs_free_mi(mi); 1352 *rtvpp = NULL; 1353 return (error); 1354 } 1355 1356 /* 1357 * vfs operations 1358 */ 1359 static int 1360 nfs_unmount(vfs_t *vfsp, int flag, cred_t *cr) 1361 { 1362 mntinfo_t *mi; 1363 ushort_t omax; 1364 1365 if (secpolicy_fs_unmount(cr, vfsp) != 0) 1366 return (EPERM); 1367 1368 mi = VFTOMI(vfsp); 1369 if (flag & MS_FORCE) { 1370 1371 vfsp->vfs_flag |= VFS_UNMOUNTED; 1372 1373 /* 1374 * We are about to stop the async manager. 1375 * Let every one know not to schedule any 1376 * more async requests. 1377 */ 1378 mutex_enter(&mi->mi_async_lock); 1379 mi->mi_max_threads = 0; 1380 NFS_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv); 1381 mutex_exit(&mi->mi_async_lock); 1382 1383 /* 1384 * We need to stop the manager thread explicitly; the worker 1385 * threads can time out and exit on their own. 1386 */ 1387 nfs_async_manager_stop(vfsp); 1388 destroy_rtable(vfsp, cr); 1389 if (mi->mi_io_kstats) { 1390 kstat_delete(mi->mi_io_kstats); 1391 mi->mi_io_kstats = NULL; 1392 } 1393 if (mi->mi_ro_kstats) { 1394 kstat_delete(mi->mi_ro_kstats); 1395 mi->mi_ro_kstats = NULL; 1396 } 1397 return (0); 1398 } 1399 /* 1400 * Wait until all asynchronous putpage operations on 1401 * this file system are complete before flushing rnodes 1402 * from the cache. 1403 */ 1404 omax = mi->mi_max_threads; 1405 if (nfs_async_stop_sig(vfsp)) { 1406 return (EINTR); 1407 } 1408 rflush(vfsp, cr); 1409 /* 1410 * If there are any active vnodes on this file system, 1411 * then the file system is busy and can't be umounted. 1412 */ 1413 if (check_rtable(vfsp)) { 1414 mutex_enter(&mi->mi_async_lock); 1415 mi->mi_max_threads = omax; 1416 mutex_exit(&mi->mi_async_lock); 1417 return (EBUSY); 1418 } 1419 /* 1420 * The unmount can't fail from now on; stop the manager thread. 1421 */ 1422 nfs_async_manager_stop(vfsp); 1423 /* 1424 * Destroy all rnodes belonging to this file system from the 1425 * rnode hash queues and purge any resources allocated to 1426 * them. 1427 */ 1428 destroy_rtable(vfsp, cr); 1429 if (mi->mi_io_kstats) { 1430 kstat_delete(mi->mi_io_kstats); 1431 mi->mi_io_kstats = NULL; 1432 } 1433 if (mi->mi_ro_kstats) { 1434 kstat_delete(mi->mi_ro_kstats); 1435 mi->mi_ro_kstats = NULL; 1436 } 1437 return (0); 1438 } 1439 1440 /* 1441 * find root of nfs 1442 */ 1443 static int 1444 nfs_root(vfs_t *vfsp, vnode_t **vpp) 1445 { 1446 mntinfo_t *mi; 1447 vnode_t *vp; 1448 servinfo_t *svp; 1449 rnode_t *rp; 1450 int error = 0; 1451 1452 mi = VFTOMI(vfsp); 1453 1454 if (nfs_zone() != mi->mi_zone) 1455 return (EPERM); 1456 1457 svp = mi->mi_curr_serv; 1458 if (svp && (svp->sv_flags & SV_ROOT_STALE)) { 1459 mutex_enter(&svp->sv_lock); 1460 svp->sv_flags &= ~SV_ROOT_STALE; 1461 mutex_exit(&svp->sv_lock); 1462 error = ENOENT; 1463 } 1464 1465 vp = makenfsnode((fhandle_t *)mi->mi_curr_serv->sv_fhandle.fh_buf, 1466 NULL, vfsp, gethrtime(), CRED(), NULL, NULL); 1467 1468 /* 1469 * if the SV_ROOT_STALE flag was reset above, reset the 1470 * RSTALE flag if needed and return an error 1471 */ 1472 if (error == ENOENT) { 1473 rp = VTOR(vp); 1474 if (svp && rp->r_flags & RSTALE) { 1475 mutex_enter(&rp->r_statelock); 1476 rp->r_flags &= ~RSTALE; 1477 mutex_exit(&rp->r_statelock); 1478 } 1479 VN_RELE(vp); 1480 return (error); 1481 } 1482 1483 ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type); 1484 1485 vp->v_type = mi->mi_type; 1486 1487 *vpp = vp; 1488 1489 return (0); 1490 } 1491 1492 /* 1493 * Get file system statistics. 1494 */ 1495 static int 1496 nfs_statvfs(vfs_t *vfsp, struct statvfs64 *sbp) 1497 { 1498 int error; 1499 mntinfo_t *mi; 1500 struct nfsstatfs fs; 1501 int douprintf; 1502 failinfo_t fi; 1503 vnode_t *vp; 1504 1505 error = nfs_root(vfsp, &vp); 1506 if (error) 1507 return (error); 1508 1509 mi = VFTOMI(vfsp); 1510 douprintf = 1; 1511 fi.vp = vp; 1512 fi.fhp = NULL; /* no need to update, filehandle not copied */ 1513 fi.copyproc = nfscopyfh; 1514 fi.lookupproc = nfslookup; 1515 fi.xattrdirproc = acl_getxattrdir2; 1516 1517 error = rfs2call(mi, RFS_STATFS, xdr_fhandle, (caddr_t)VTOFH(vp), 1518 xdr_statfs, (caddr_t)&fs, CRED(), &douprintf, &fs.fs_status, 0, 1519 &fi); 1520 1521 if (!error) { 1522 error = geterrno(fs.fs_status); 1523 if (!error) { 1524 mutex_enter(&mi->mi_lock); 1525 if (mi->mi_stsize) { 1526 mi->mi_stsize = MIN(mi->mi_stsize, fs.fs_tsize); 1527 } else { 1528 mi->mi_stsize = fs.fs_tsize; 1529 mi->mi_curwrite = mi->mi_stsize; 1530 } 1531 mutex_exit(&mi->mi_lock); 1532 sbp->f_bsize = fs.fs_bsize; 1533 sbp->f_frsize = fs.fs_bsize; 1534 sbp->f_blocks = (fsblkcnt64_t)fs.fs_blocks; 1535 sbp->f_bfree = (fsblkcnt64_t)fs.fs_bfree; 1536 /* 1537 * Some servers may return negative available 1538 * block counts. They may do this because they 1539 * calculate the number of available blocks by 1540 * subtracting the number of used blocks from 1541 * the total number of blocks modified by the 1542 * minimum free value. For example, if the 1543 * minumum free percentage is 10 and the file 1544 * system is greater than 90 percent full, then 1545 * 90 percent of the total blocks minus the 1546 * actual number of used blocks may be a 1547 * negative number. 1548 * 1549 * In this case, we need to sign extend the 1550 * negative number through the assignment from 1551 * the 32 bit bavail count to the 64 bit bavail 1552 * count. 1553 * 1554 * We need to be able to discern between there 1555 * just being a lot of available blocks on the 1556 * file system and the case described above. 1557 * We are making the assumption that it does 1558 * not make sense to have more available blocks 1559 * than there are free blocks. So, if there 1560 * are, then we treat the number as if it were 1561 * a negative number and arrange to have it 1562 * sign extended when it is converted from 32 1563 * bits to 64 bits. 1564 */ 1565 if (fs.fs_bavail <= fs.fs_bfree) 1566 sbp->f_bavail = (fsblkcnt64_t)fs.fs_bavail; 1567 else { 1568 sbp->f_bavail = 1569 (fsblkcnt64_t)((long)fs.fs_bavail); 1570 } 1571 sbp->f_files = (fsfilcnt64_t)-1; 1572 sbp->f_ffree = (fsfilcnt64_t)-1; 1573 sbp->f_favail = (fsfilcnt64_t)-1; 1574 sbp->f_fsid = (unsigned long)vfsp->vfs_fsid.val[0]; 1575 (void) strncpy(sbp->f_basetype, 1576 vfssw[vfsp->vfs_fstype].vsw_name, FSTYPSZ); 1577 sbp->f_flag = vf_to_stf(vfsp->vfs_flag); 1578 sbp->f_namemax = (uint32_t)-1; 1579 } else { 1580 PURGE_STALE_FH(error, vp, CRED()); 1581 } 1582 } 1583 1584 VN_RELE(vp); 1585 1586 return (error); 1587 } 1588 1589 static kmutex_t nfs_syncbusy; 1590 1591 /* 1592 * Flush dirty nfs files for file system vfsp. 1593 * If vfsp == NULL, all nfs files are flushed. 1594 */ 1595 /* ARGSUSED */ 1596 static int 1597 nfs_sync(vfs_t *vfsp, short flag, cred_t *cr) 1598 { 1599 /* 1600 * Cross-zone calls are OK here, since this translates to a 1601 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone. 1602 */ 1603 if (!(flag & SYNC_ATTR) && mutex_tryenter(&nfs_syncbusy) != 0) { 1604 rflush(vfsp, cr); 1605 mutex_exit(&nfs_syncbusy); 1606 } 1607 return (0); 1608 } 1609 1610 /* ARGSUSED */ 1611 static int 1612 nfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 1613 { 1614 int error; 1615 vnode_t *vp; 1616 struct vattr va; 1617 struct nfs_fid *nfsfidp = (struct nfs_fid *)fidp; 1618 zoneid_t zoneid = VFTOMI(vfsp)->mi_zone->zone_id; 1619 1620 if (nfs_zone() != VFTOMI(vfsp)->mi_zone) 1621 return (EPERM); 1622 if (fidp->fid_len != (sizeof (*nfsfidp) - sizeof (short))) { 1623 #ifdef DEBUG 1624 zcmn_err(zoneid, CE_WARN, 1625 "nfs_vget: bad fid len, %d/%d", fidp->fid_len, 1626 (int)(sizeof (*nfsfidp) - sizeof (short))); 1627 #endif 1628 *vpp = NULL; 1629 return (ESTALE); 1630 } 1631 1632 vp = makenfsnode((fhandle_t *)(nfsfidp->nf_data), NULL, vfsp, 1633 gethrtime(), CRED(), NULL, NULL); 1634 1635 if (VTOR(vp)->r_flags & RSTALE) { 1636 VN_RELE(vp); 1637 *vpp = NULL; 1638 return (ENOENT); 1639 } 1640 1641 if (vp->v_type == VNON) { 1642 va.va_mask = AT_ALL; 1643 error = nfsgetattr(vp, &va, CRED()); 1644 if (error) { 1645 VN_RELE(vp); 1646 *vpp = NULL; 1647 return (error); 1648 } 1649 vp->v_type = va.va_type; 1650 } 1651 1652 *vpp = vp; 1653 1654 return (0); 1655 } 1656 1657 /* ARGSUSED */ 1658 static int 1659 nfs_mountroot(vfs_t *vfsp, whymountroot_t why) 1660 { 1661 vnode_t *rtvp; 1662 char root_hostname[SYS_NMLN+1]; 1663 struct servinfo *svp; 1664 int error; 1665 int vfsflags; 1666 size_t size; 1667 char *root_path; 1668 struct pathname pn; 1669 char *name; 1670 cred_t *cr; 1671 struct nfs_args args; /* nfs mount arguments */ 1672 static char token[10]; 1673 1674 bzero(&args, sizeof (args)); 1675 1676 /* do this BEFORE getfile which causes xid stamps to be initialized */ 1677 clkset(-1L); /* hack for now - until we get time svc? */ 1678 1679 if (why == ROOT_REMOUNT) { 1680 /* 1681 * Shouldn't happen. 1682 */ 1683 panic("nfs_mountroot: why == ROOT_REMOUNT"); 1684 } 1685 1686 if (why == ROOT_UNMOUNT) { 1687 /* 1688 * Nothing to do for NFS. 1689 */ 1690 return (0); 1691 } 1692 1693 /* 1694 * why == ROOT_INIT 1695 */ 1696 1697 name = token; 1698 *name = 0; 1699 getfsname("root", name, sizeof (token)); 1700 1701 pn_alloc(&pn); 1702 root_path = pn.pn_path; 1703 1704 svp = kmem_zalloc(sizeof (*svp), KM_SLEEP); 1705 svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP); 1706 svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 1707 svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP); 1708 1709 /* 1710 * Get server address 1711 * Get the root fhandle 1712 * Get server's transport 1713 * Get server's hostname 1714 * Get options 1715 */ 1716 args.addr = &svp->sv_addr; 1717 args.fh = (char *)&svp->sv_fhandle.fh_buf; 1718 args.knconf = svp->sv_knconf; 1719 args.hostname = root_hostname; 1720 vfsflags = 0; 1721 if (error = mount_root(*name ? name : "root", root_path, NFS_VERSION, 1722 &args, &vfsflags)) { 1723 nfs_cmn_err(error, CE_WARN, 1724 "nfs_mountroot: mount_root failed: %m"); 1725 sv_free(svp); 1726 pn_free(&pn); 1727 return (error); 1728 } 1729 svp->sv_fhandle.fh_len = NFS_FHSIZE; 1730 svp->sv_hostnamelen = (int)(strlen(root_hostname) + 1); 1731 svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP); 1732 (void) strcpy(svp->sv_hostname, root_hostname); 1733 1734 /* 1735 * Force root partition to always be mounted with AUTH_UNIX for now 1736 */ 1737 svp->sv_secdata = kmem_alloc(sizeof (*svp->sv_secdata), KM_SLEEP); 1738 svp->sv_secdata->secmod = AUTH_UNIX; 1739 svp->sv_secdata->rpcflavor = AUTH_UNIX; 1740 svp->sv_secdata->data = NULL; 1741 1742 cr = crgetcred(); 1743 rtvp = NULL; 1744 1745 error = nfsrootvp(&rtvp, vfsp, svp, args.flags, cr, global_zone); 1746 1747 crfree(cr); 1748 1749 if (error) { 1750 pn_free(&pn); 1751 sv_free(svp); 1752 return (error); 1753 } 1754 1755 error = nfs_setopts(rtvp, DATAMODEL_NATIVE, &args); 1756 if (error) { 1757 nfs_cmn_err(error, CE_WARN, 1758 "nfs_mountroot: invalid root mount options"); 1759 pn_free(&pn); 1760 goto errout; 1761 } 1762 1763 (void) vfs_lock_wait(vfsp); 1764 vfs_add(NULL, vfsp, vfsflags); 1765 vfs_unlock(vfsp); 1766 1767 size = strlen(svp->sv_hostname); 1768 (void) strcpy(rootfs.bo_name, svp->sv_hostname); 1769 rootfs.bo_name[size] = ':'; 1770 (void) strcpy(&rootfs.bo_name[size + 1], root_path); 1771 1772 pn_free(&pn); 1773 1774 errout: 1775 if (error) { 1776 sv_free(svp); 1777 nfs_async_stop(vfsp); 1778 nfs_async_manager_stop(vfsp); 1779 } 1780 1781 if (rtvp != NULL) 1782 VN_RELE(rtvp); 1783 1784 return (error); 1785 } 1786 1787 /* 1788 * Initialization routine for VFS routines. Should only be called once 1789 */ 1790 int 1791 nfs_vfsinit(void) 1792 { 1793 mutex_init(&nfs_syncbusy, NULL, MUTEX_DEFAULT, NULL); 1794 return (0); 1795 } 1796 1797 void 1798 nfs_vfsfini(void) 1799 { 1800 mutex_destroy(&nfs_syncbusy); 1801 } 1802 1803 void 1804 nfs_freevfs(vfs_t *vfsp) 1805 { 1806 mntinfo_t *mi; 1807 servinfo_t *svp; 1808 1809 /* free up the resources */ 1810 mi = VFTOMI(vfsp); 1811 pathconf_rele(mi); 1812 svp = mi->mi_servers; 1813 mi->mi_servers = mi->mi_curr_serv = NULL; 1814 sv_free(svp); 1815 1816 /* 1817 * By this time we should have already deleted the 1818 * mi kstats in the unmount code. If they are still around 1819 * somethings wrong 1820 */ 1821 ASSERT(mi->mi_io_kstats == NULL); 1822 nfs_free_mi(mi); 1823 } 1824