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) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 26 /* All Rights Reserved */ 27 28 /* 29 * University Copyright- Copyright (c) 1982, 1986, 1988 30 * The Regents of the University of California 31 * All Rights Reserved 32 * 33 * University Acknowledgment- Portions of this document are derived from 34 * software developed by the University of California, Berkeley, and its 35 * contributors. 36 */ 37 38 #include <sys/types.h> 39 #include <sys/t_lock.h> 40 #include <sys/param.h> 41 #include <sys/errno.h> 42 #include <sys/user.h> 43 #include <sys/fstyp.h> 44 #include <sys/kmem.h> 45 #include <sys/systm.h> 46 #include <sys/proc.h> 47 #include <sys/mount.h> 48 #include <sys/vfs.h> 49 #include <sys/vfs_opreg.h> 50 #include <sys/fem.h> 51 #include <sys/mntent.h> 52 #include <sys/stat.h> 53 #include <sys/statvfs.h> 54 #include <sys/statfs.h> 55 #include <sys/cred.h> 56 #include <sys/vnode.h> 57 #include <sys/rwstlock.h> 58 #include <sys/dnlc.h> 59 #include <sys/file.h> 60 #include <sys/time.h> 61 #include <sys/atomic.h> 62 #include <sys/cmn_err.h> 63 #include <sys/buf.h> 64 #include <sys/swap.h> 65 #include <sys/debug.h> 66 #include <sys/vnode.h> 67 #include <sys/modctl.h> 68 #include <sys/ddi.h> 69 #include <sys/pathname.h> 70 #include <sys/bootconf.h> 71 #include <sys/dumphdr.h> 72 #include <sys/dc_ki.h> 73 #include <sys/poll.h> 74 #include <sys/sunddi.h> 75 #include <sys/sysmacros.h> 76 #include <sys/zone.h> 77 #include <sys/policy.h> 78 #include <sys/ctfs.h> 79 #include <sys/objfs.h> 80 #include <sys/console.h> 81 #include <sys/reboot.h> 82 #include <sys/attr.h> 83 #include <sys/zio.h> 84 #include <sys/spa.h> 85 #include <sys/lofi.h> 86 #include <sys/bootprops.h> 87 88 #include <vm/page.h> 89 90 #include <fs/fs_subr.h> 91 /* Private interfaces to create vopstats-related data structures */ 92 extern void initialize_vopstats(vopstats_t *); 93 extern vopstats_t *get_fstype_vopstats(struct vfs *, struct vfssw *); 94 extern vsk_anchor_t *get_vskstat_anchor(struct vfs *); 95 96 static void vfs_clearmntopt_nolock(mntopts_t *, const char *, int); 97 static void vfs_setmntopt_nolock(mntopts_t *, const char *, 98 const char *, int, int); 99 static int vfs_optionisset_nolock(const mntopts_t *, const char *, char **); 100 static void vfs_freemnttab(struct vfs *); 101 static void vfs_freeopt(mntopt_t *); 102 static void vfs_swapopttbl_nolock(mntopts_t *, mntopts_t *); 103 static void vfs_swapopttbl(mntopts_t *, mntopts_t *); 104 static void vfs_copyopttbl_extend(const mntopts_t *, mntopts_t *, int); 105 static void vfs_createopttbl_extend(mntopts_t *, const char *, 106 const mntopts_t *); 107 static char **vfs_copycancelopt_extend(char **const, int); 108 static void vfs_freecancelopt(char **); 109 static void getrootfs(char **, char **); 110 static int getmacpath(dev_info_t *, void *); 111 static void vfs_mnttabvp_setup(void); 112 113 struct ipmnt { 114 struct ipmnt *mip_next; 115 dev_t mip_dev; 116 struct vfs *mip_vfsp; 117 }; 118 119 static kmutex_t vfs_miplist_mutex; 120 static struct ipmnt *vfs_miplist = NULL; 121 static struct ipmnt *vfs_miplist_end = NULL; 122 123 static kmem_cache_t *vfs_cache; /* Pointer to VFS kmem cache */ 124 125 /* 126 * VFS global data. 127 */ 128 vnode_t *rootdir; /* pointer to root inode vnode. */ 129 vnode_t *devicesdir; /* pointer to inode of devices root */ 130 vnode_t *devdir; /* pointer to inode of dev root */ 131 132 char *server_rootpath; /* root path for diskless clients */ 133 char *server_hostname; /* hostname of diskless server */ 134 135 static struct vfs root; 136 static struct vfs devices; 137 static struct vfs dev; 138 struct vfs *rootvfs = &root; /* pointer to root vfs; head of VFS list. */ 139 rvfs_t *rvfs_list; /* array of vfs ptrs for vfs hash list */ 140 int vfshsz = 512; /* # of heads/locks in vfs hash arrays */ 141 /* must be power of 2! */ 142 timespec_t vfs_mnttab_ctime; /* mnttab created time */ 143 timespec_t vfs_mnttab_mtime; /* mnttab last modified time */ 144 char *vfs_dummyfstype = "\0"; 145 struct pollhead vfs_pollhd; /* for mnttab pollers */ 146 struct vnode *vfs_mntdummyvp; /* to fake mnttab read/write for file events */ 147 int mntfstype; /* will be set once mnt fs is mounted */ 148 149 /* 150 * Table for generic options recognized in the VFS layer and acted 151 * on at this level before parsing file system specific options. 152 * The nosuid option is stronger than any of the devices and setuid 153 * options, so those are canceled when nosuid is seen. 154 * 155 * All options which are added here need to be added to the 156 * list of standard options in usr/src/cmd/fs.d/fslib.c as well. 157 */ 158 /* 159 * VFS Mount options table 160 */ 161 static char *ro_cancel[] = { MNTOPT_RW, NULL }; 162 static char *rw_cancel[] = { MNTOPT_RO, NULL }; 163 static char *suid_cancel[] = { MNTOPT_NOSUID, NULL }; 164 static char *nosuid_cancel[] = { MNTOPT_SUID, MNTOPT_DEVICES, MNTOPT_NODEVICES, 165 MNTOPT_NOSETUID, MNTOPT_SETUID, NULL }; 166 static char *devices_cancel[] = { MNTOPT_NODEVICES, NULL }; 167 static char *nodevices_cancel[] = { MNTOPT_DEVICES, NULL }; 168 static char *setuid_cancel[] = { MNTOPT_NOSETUID, NULL }; 169 static char *nosetuid_cancel[] = { MNTOPT_SETUID, NULL }; 170 static char *nbmand_cancel[] = { MNTOPT_NONBMAND, NULL }; 171 static char *nonbmand_cancel[] = { MNTOPT_NBMAND, NULL }; 172 static char *exec_cancel[] = { MNTOPT_NOEXEC, NULL }; 173 static char *noexec_cancel[] = { MNTOPT_EXEC, NULL }; 174 175 static const mntopt_t mntopts[] = { 176 /* 177 * option name cancel options default arg flags 178 */ 179 { MNTOPT_REMOUNT, NULL, NULL, 180 MO_NODISPLAY, (void *)0 }, 181 { MNTOPT_RO, ro_cancel, NULL, 0, 182 (void *)0 }, 183 { MNTOPT_RW, rw_cancel, NULL, 0, 184 (void *)0 }, 185 { MNTOPT_SUID, suid_cancel, NULL, 0, 186 (void *)0 }, 187 { MNTOPT_NOSUID, nosuid_cancel, NULL, 0, 188 (void *)0 }, 189 { MNTOPT_DEVICES, devices_cancel, NULL, 0, 190 (void *)0 }, 191 { MNTOPT_NODEVICES, nodevices_cancel, NULL, 0, 192 (void *)0 }, 193 { MNTOPT_SETUID, setuid_cancel, NULL, 0, 194 (void *)0 }, 195 { MNTOPT_NOSETUID, nosetuid_cancel, NULL, 0, 196 (void *)0 }, 197 { MNTOPT_NBMAND, nbmand_cancel, NULL, 0, 198 (void *)0 }, 199 { MNTOPT_NONBMAND, nonbmand_cancel, NULL, 0, 200 (void *)0 }, 201 { MNTOPT_EXEC, exec_cancel, NULL, 0, 202 (void *)0 }, 203 { MNTOPT_NOEXEC, noexec_cancel, NULL, 0, 204 (void *)0 }, 205 }; 206 207 const mntopts_t vfs_mntopts = { 208 sizeof (mntopts) / sizeof (mntopt_t), 209 (mntopt_t *)&mntopts[0] 210 }; 211 212 /* 213 * File system operation dispatch functions. 214 */ 215 216 int 217 fsop_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 218 { 219 return (*(vfsp)->vfs_op->vfs_mount)(vfsp, mvp, uap, cr); 220 } 221 222 int 223 fsop_unmount(vfs_t *vfsp, int flag, cred_t *cr) 224 { 225 return (*(vfsp)->vfs_op->vfs_unmount)(vfsp, flag, cr); 226 } 227 228 int 229 fsop_root(vfs_t *vfsp, vnode_t **vpp) 230 { 231 refstr_t *mntpt; 232 int ret = (*(vfsp)->vfs_op->vfs_root)(vfsp, vpp); 233 /* 234 * Make sure this root has a path. With lofs, it is possible to have 235 * a NULL mountpoint. 236 */ 237 if (ret == 0 && vfsp->vfs_mntpt != NULL && (*vpp)->v_path == NULL) { 238 mntpt = vfs_getmntpoint(vfsp); 239 vn_setpath_str(*vpp, refstr_value(mntpt), 240 strlen(refstr_value(mntpt))); 241 refstr_rele(mntpt); 242 } 243 244 return (ret); 245 } 246 247 int 248 fsop_statfs(vfs_t *vfsp, statvfs64_t *sp) 249 { 250 return (*(vfsp)->vfs_op->vfs_statvfs)(vfsp, sp); 251 } 252 253 int 254 fsop_sync(vfs_t *vfsp, short flag, cred_t *cr) 255 { 256 return (*(vfsp)->vfs_op->vfs_sync)(vfsp, flag, cr); 257 } 258 259 int 260 fsop_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 261 { 262 /* 263 * In order to handle system attribute fids in a manner 264 * transparent to the underlying fs, we embed the fid for 265 * the sysattr parent object in the sysattr fid and tack on 266 * some extra bytes that only the sysattr layer knows about. 267 * 268 * This guarantees that sysattr fids are larger than other fids 269 * for this vfs. If the vfs supports the sysattr view interface 270 * (as indicated by VFSFT_SYSATTR_VIEWS), we cannot have a size 271 * collision with XATTR_FIDSZ. 272 */ 273 if (vfs_has_feature(vfsp, VFSFT_SYSATTR_VIEWS) && 274 fidp->fid_len == XATTR_FIDSZ) 275 return (xattr_dir_vget(vfsp, vpp, fidp)); 276 277 return (*(vfsp)->vfs_op->vfs_vget)(vfsp, vpp, fidp); 278 } 279 280 int 281 fsop_mountroot(vfs_t *vfsp, enum whymountroot reason) 282 { 283 return (*(vfsp)->vfs_op->vfs_mountroot)(vfsp, reason); 284 } 285 286 void 287 fsop_freefs(vfs_t *vfsp) 288 { 289 (*(vfsp)->vfs_op->vfs_freevfs)(vfsp); 290 } 291 292 int 293 fsop_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate) 294 { 295 return ((*(vfsp)->vfs_op->vfs_vnstate)(vfsp, vp, nstate)); 296 } 297 298 int 299 fsop_sync_by_kind(int fstype, short flag, cred_t *cr) 300 { 301 ASSERT((fstype >= 0) && (fstype < nfstype)); 302 303 if (ALLOCATED_VFSSW(&vfssw[fstype]) && VFS_INSTALLED(&vfssw[fstype])) 304 return (*vfssw[fstype].vsw_vfsops.vfs_sync) (NULL, flag, cr); 305 else 306 return (ENOTSUP); 307 } 308 309 /* 310 * File system initialization. vfs_setfsops() must be called from a file 311 * system's init routine. 312 */ 313 314 static int 315 fs_copyfsops(const fs_operation_def_t *template, vfsops_t *actual, 316 int *unused_ops) 317 { 318 static const fs_operation_trans_def_t vfs_ops_table[] = { 319 VFSNAME_MOUNT, offsetof(vfsops_t, vfs_mount), 320 fs_nosys, fs_nosys, 321 322 VFSNAME_UNMOUNT, offsetof(vfsops_t, vfs_unmount), 323 fs_nosys, fs_nosys, 324 325 VFSNAME_ROOT, offsetof(vfsops_t, vfs_root), 326 fs_nosys, fs_nosys, 327 328 VFSNAME_STATVFS, offsetof(vfsops_t, vfs_statvfs), 329 fs_nosys, fs_nosys, 330 331 VFSNAME_SYNC, offsetof(vfsops_t, vfs_sync), 332 (fs_generic_func_p) fs_sync, 333 (fs_generic_func_p) fs_sync, /* No errors allowed */ 334 335 VFSNAME_VGET, offsetof(vfsops_t, vfs_vget), 336 fs_nosys, fs_nosys, 337 338 VFSNAME_MOUNTROOT, offsetof(vfsops_t, vfs_mountroot), 339 fs_nosys, fs_nosys, 340 341 VFSNAME_FREEVFS, offsetof(vfsops_t, vfs_freevfs), 342 (fs_generic_func_p)fs_freevfs, 343 (fs_generic_func_p)fs_freevfs, /* Shouldn't fail */ 344 345 VFSNAME_VNSTATE, offsetof(vfsops_t, vfs_vnstate), 346 (fs_generic_func_p)fs_nosys, 347 (fs_generic_func_p)fs_nosys, 348 349 NULL, 0, NULL, NULL 350 }; 351 352 return (fs_build_vector(actual, unused_ops, vfs_ops_table, template)); 353 } 354 355 void 356 zfs_boot_init() { 357 358 if (strcmp(rootfs.bo_fstype, MNTTYPE_ZFS) == 0) 359 spa_boot_init(); 360 } 361 362 int 363 vfs_setfsops(int fstype, const fs_operation_def_t *template, vfsops_t **actual) 364 { 365 int error; 366 int unused_ops; 367 368 /* 369 * Verify that fstype refers to a valid fs. Note that 370 * 0 is valid since it's used to set "stray" ops. 371 */ 372 if ((fstype < 0) || (fstype >= nfstype)) 373 return (EINVAL); 374 375 if (!ALLOCATED_VFSSW(&vfssw[fstype])) 376 return (EINVAL); 377 378 /* Set up the operations vector. */ 379 380 error = fs_copyfsops(template, &vfssw[fstype].vsw_vfsops, &unused_ops); 381 382 if (error != 0) 383 return (error); 384 385 vfssw[fstype].vsw_flag |= VSW_INSTALLED; 386 387 if (actual != NULL) 388 *actual = &vfssw[fstype].vsw_vfsops; 389 390 #if DEBUG 391 if (unused_ops != 0) 392 cmn_err(CE_WARN, "vfs_setfsops: %s: %d operations supplied " 393 "but not used", vfssw[fstype].vsw_name, unused_ops); 394 #endif 395 396 return (0); 397 } 398 399 int 400 vfs_makefsops(const fs_operation_def_t *template, vfsops_t **actual) 401 { 402 int error; 403 int unused_ops; 404 405 *actual = (vfsops_t *)kmem_alloc(sizeof (vfsops_t), KM_SLEEP); 406 407 error = fs_copyfsops(template, *actual, &unused_ops); 408 if (error != 0) { 409 kmem_free(*actual, sizeof (vfsops_t)); 410 *actual = NULL; 411 return (error); 412 } 413 414 return (0); 415 } 416 417 /* 418 * Free a vfsops structure created as a result of vfs_makefsops(). 419 * NOTE: For a vfsops structure initialized by vfs_setfsops(), use 420 * vfs_freevfsops_by_type(). 421 */ 422 void 423 vfs_freevfsops(vfsops_t *vfsops) 424 { 425 kmem_free(vfsops, sizeof (vfsops_t)); 426 } 427 428 /* 429 * Since the vfsops structure is part of the vfssw table and wasn't 430 * really allocated, we're not really freeing anything. We keep 431 * the name for consistency with vfs_freevfsops(). We do, however, 432 * need to take care of a little bookkeeping. 433 * NOTE: For a vfsops structure created by vfs_setfsops(), use 434 * vfs_freevfsops_by_type(). 435 */ 436 int 437 vfs_freevfsops_by_type(int fstype) 438 { 439 440 /* Verify that fstype refers to a loaded fs (and not fsid 0). */ 441 if ((fstype <= 0) || (fstype >= nfstype)) 442 return (EINVAL); 443 444 WLOCK_VFSSW(); 445 if ((vfssw[fstype].vsw_flag & VSW_INSTALLED) == 0) { 446 WUNLOCK_VFSSW(); 447 return (EINVAL); 448 } 449 450 vfssw[fstype].vsw_flag &= ~VSW_INSTALLED; 451 WUNLOCK_VFSSW(); 452 453 return (0); 454 } 455 456 /* Support routines used to reference vfs_op */ 457 458 /* Set the operations vector for a vfs */ 459 void 460 vfs_setops(vfs_t *vfsp, vfsops_t *vfsops) 461 { 462 vfsops_t *op; 463 464 ASSERT(vfsp != NULL); 465 ASSERT(vfsops != NULL); 466 467 op = vfsp->vfs_op; 468 membar_consumer(); 469 if (vfsp->vfs_femhead == NULL && 470 casptr(&vfsp->vfs_op, op, vfsops) == op) { 471 return; 472 } 473 fsem_setvfsops(vfsp, vfsops); 474 } 475 476 /* Retrieve the operations vector for a vfs */ 477 vfsops_t * 478 vfs_getops(vfs_t *vfsp) 479 { 480 vfsops_t *op; 481 482 ASSERT(vfsp != NULL); 483 484 op = vfsp->vfs_op; 485 membar_consumer(); 486 if (vfsp->vfs_femhead == NULL && op == vfsp->vfs_op) { 487 return (op); 488 } else { 489 return (fsem_getvfsops(vfsp)); 490 } 491 } 492 493 /* 494 * Returns non-zero (1) if the vfsops matches that of the vfs. 495 * Returns zero (0) if not. 496 */ 497 int 498 vfs_matchops(vfs_t *vfsp, vfsops_t *vfsops) 499 { 500 return (vfs_getops(vfsp) == vfsops); 501 } 502 503 /* 504 * Returns non-zero (1) if the file system has installed a non-default, 505 * non-error vfs_sync routine. Returns zero (0) otherwise. 506 */ 507 int 508 vfs_can_sync(vfs_t *vfsp) 509 { 510 /* vfs_sync() routine is not the default/error function */ 511 return (vfs_getops(vfsp)->vfs_sync != fs_sync); 512 } 513 514 /* 515 * Initialize a vfs structure. 516 */ 517 void 518 vfs_init(vfs_t *vfsp, vfsops_t *op, void *data) 519 { 520 /* Other initialization has been moved to vfs_alloc() */ 521 vfsp->vfs_count = 0; 522 vfsp->vfs_next = vfsp; 523 vfsp->vfs_prev = vfsp; 524 vfsp->vfs_zone_next = vfsp; 525 vfsp->vfs_zone_prev = vfsp; 526 vfsp->vfs_lofi_minor = 0; 527 sema_init(&vfsp->vfs_reflock, 1, NULL, SEMA_DEFAULT, NULL); 528 vfsimpl_setup(vfsp); 529 vfsp->vfs_data = (data); 530 vfs_setops((vfsp), (op)); 531 } 532 533 /* 534 * Allocate and initialize the vfs implementation private data 535 * structure, vfs_impl_t. 536 */ 537 void 538 vfsimpl_setup(vfs_t *vfsp) 539 { 540 int i; 541 542 if (vfsp->vfs_implp != NULL) { 543 return; 544 } 545 546 vfsp->vfs_implp = kmem_alloc(sizeof (vfs_impl_t), KM_SLEEP); 547 /* Note that these are #define'd in vfs.h */ 548 vfsp->vfs_vskap = NULL; 549 vfsp->vfs_fstypevsp = NULL; 550 551 /* Set size of counted array, then zero the array */ 552 vfsp->vfs_featureset[0] = VFS_FEATURE_MAXSZ - 1; 553 for (i = 1; i < VFS_FEATURE_MAXSZ; i++) { 554 vfsp->vfs_featureset[i] = 0; 555 } 556 } 557 558 /* 559 * Release the vfs_impl_t structure, if it exists. Some unbundled 560 * filesystems may not use the newer version of vfs and thus 561 * would not contain this implementation private data structure. 562 */ 563 void 564 vfsimpl_teardown(vfs_t *vfsp) 565 { 566 vfs_impl_t *vip = vfsp->vfs_implp; 567 568 if (vip == NULL) 569 return; 570 571 kmem_free(vfsp->vfs_implp, sizeof (vfs_impl_t)); 572 vfsp->vfs_implp = NULL; 573 } 574 575 /* 576 * VFS system calls: mount, umount, syssync, statfs, fstatfs, statvfs, 577 * fstatvfs, and sysfs moved to common/syscall. 578 */ 579 580 /* 581 * Update every mounted file system. We call the vfs_sync operation of 582 * each file system type, passing it a NULL vfsp to indicate that all 583 * mounted file systems of that type should be updated. 584 */ 585 void 586 vfs_sync(int flag) 587 { 588 struct vfssw *vswp; 589 RLOCK_VFSSW(); 590 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 591 if (ALLOCATED_VFSSW(vswp) && VFS_INSTALLED(vswp)) { 592 vfs_refvfssw(vswp); 593 RUNLOCK_VFSSW(); 594 (void) (*vswp->vsw_vfsops.vfs_sync)(NULL, flag, 595 CRED()); 596 vfs_unrefvfssw(vswp); 597 RLOCK_VFSSW(); 598 } 599 } 600 RUNLOCK_VFSSW(); 601 } 602 603 void 604 sync(void) 605 { 606 vfs_sync(0); 607 } 608 609 /* 610 * External routines. 611 */ 612 613 krwlock_t vfssw_lock; /* lock accesses to vfssw */ 614 615 /* 616 * Lock for accessing the vfs linked list. Initialized in vfs_mountroot(), 617 * but otherwise should be accessed only via vfs_list_lock() and 618 * vfs_list_unlock(). Also used to protect the timestamp for mods to the list. 619 */ 620 static krwlock_t vfslist; 621 622 /* 623 * Mount devfs on /devices. This is done right after root is mounted 624 * to provide device access support for the system 625 */ 626 static void 627 vfs_mountdevices(void) 628 { 629 struct vfssw *vsw; 630 struct vnode *mvp; 631 struct mounta mounta = { /* fake mounta for devfs_mount() */ 632 NULL, 633 NULL, 634 MS_SYSSPACE, 635 NULL, 636 NULL, 637 0, 638 NULL, 639 0 640 }; 641 642 /* 643 * _init devfs module to fill in the vfssw 644 */ 645 if (modload("fs", "devfs") == -1) 646 panic("Cannot _init devfs module"); 647 648 /* 649 * Hold vfs 650 */ 651 RLOCK_VFSSW(); 652 vsw = vfs_getvfsswbyname("devfs"); 653 VFS_INIT(&devices, &vsw->vsw_vfsops, NULL); 654 VFS_HOLD(&devices); 655 656 /* 657 * Locate mount point 658 */ 659 if (lookupname("/devices", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) 660 panic("Cannot find /devices"); 661 662 /* 663 * Perform the mount of /devices 664 */ 665 if (VFS_MOUNT(&devices, mvp, &mounta, CRED())) 666 panic("Cannot mount /devices"); 667 668 RUNLOCK_VFSSW(); 669 670 /* 671 * Set appropriate members and add to vfs list for mnttab display 672 */ 673 vfs_setresource(&devices, "/devices"); 674 vfs_setmntpoint(&devices, "/devices"); 675 676 /* 677 * Hold the root of /devices so it won't go away 678 */ 679 if (VFS_ROOT(&devices, &devicesdir)) 680 panic("vfs_mountdevices: not devices root"); 681 682 if (vfs_lock(&devices) != 0) { 683 VN_RELE(devicesdir); 684 cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /devices"); 685 return; 686 } 687 688 if (vn_vfswlock(mvp) != 0) { 689 vfs_unlock(&devices); 690 VN_RELE(devicesdir); 691 cmn_err(CE_NOTE, "Cannot acquire vfswlock of /devices"); 692 return; 693 } 694 695 vfs_add(mvp, &devices, 0); 696 vn_vfsunlock(mvp); 697 vfs_unlock(&devices); 698 VN_RELE(devicesdir); 699 } 700 701 /* 702 * mount the first instance of /dev to root and remain mounted 703 */ 704 static void 705 vfs_mountdev1(void) 706 { 707 struct vfssw *vsw; 708 struct vnode *mvp; 709 struct mounta mounta = { /* fake mounta for sdev_mount() */ 710 NULL, 711 NULL, 712 MS_SYSSPACE | MS_OVERLAY, 713 NULL, 714 NULL, 715 0, 716 NULL, 717 0 718 }; 719 720 /* 721 * _init dev module to fill in the vfssw 722 */ 723 if (modload("fs", "dev") == -1) 724 cmn_err(CE_PANIC, "Cannot _init dev module\n"); 725 726 /* 727 * Hold vfs 728 */ 729 RLOCK_VFSSW(); 730 vsw = vfs_getvfsswbyname("dev"); 731 VFS_INIT(&dev, &vsw->vsw_vfsops, NULL); 732 VFS_HOLD(&dev); 733 734 /* 735 * Locate mount point 736 */ 737 if (lookupname("/dev", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) 738 cmn_err(CE_PANIC, "Cannot find /dev\n"); 739 740 /* 741 * Perform the mount of /dev 742 */ 743 if (VFS_MOUNT(&dev, mvp, &mounta, CRED())) 744 cmn_err(CE_PANIC, "Cannot mount /dev 1\n"); 745 746 RUNLOCK_VFSSW(); 747 748 /* 749 * Set appropriate members and add to vfs list for mnttab display 750 */ 751 vfs_setresource(&dev, "/dev"); 752 vfs_setmntpoint(&dev, "/dev"); 753 754 /* 755 * Hold the root of /dev so it won't go away 756 */ 757 if (VFS_ROOT(&dev, &devdir)) 758 cmn_err(CE_PANIC, "vfs_mountdev1: not dev root"); 759 760 if (vfs_lock(&dev) != 0) { 761 VN_RELE(devdir); 762 cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /dev"); 763 return; 764 } 765 766 if (vn_vfswlock(mvp) != 0) { 767 vfs_unlock(&dev); 768 VN_RELE(devdir); 769 cmn_err(CE_NOTE, "Cannot acquire vfswlock of /dev"); 770 return; 771 } 772 773 vfs_add(mvp, &dev, 0); 774 vn_vfsunlock(mvp); 775 vfs_unlock(&dev); 776 VN_RELE(devdir); 777 } 778 779 /* 780 * Mount required filesystem. This is done right after root is mounted. 781 */ 782 static void 783 vfs_mountfs(char *module, char *spec, char *path) 784 { 785 struct vnode *mvp; 786 struct mounta mounta; 787 vfs_t *vfsp; 788 789 mounta.flags = MS_SYSSPACE | MS_DATA; 790 mounta.fstype = module; 791 mounta.spec = spec; 792 mounta.dir = path; 793 if (lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) { 794 cmn_err(CE_WARN, "Cannot find %s", path); 795 return; 796 } 797 if (domount(NULL, &mounta, mvp, CRED(), &vfsp)) 798 cmn_err(CE_WARN, "Cannot mount %s", path); 799 else 800 VFS_RELE(vfsp); 801 VN_RELE(mvp); 802 } 803 804 /* 805 * vfs_mountroot is called by main() to mount the root filesystem. 806 */ 807 void 808 vfs_mountroot(void) 809 { 810 struct vnode *rvp = NULL; 811 char *path; 812 size_t plen; 813 struct vfssw *vswp; 814 proc_t *p; 815 816 rw_init(&vfssw_lock, NULL, RW_DEFAULT, NULL); 817 rw_init(&vfslist, NULL, RW_DEFAULT, NULL); 818 819 /* 820 * Alloc the vfs hash bucket array and locks 821 */ 822 rvfs_list = kmem_zalloc(vfshsz * sizeof (rvfs_t), KM_SLEEP); 823 824 /* 825 * Call machine-dependent routine "rootconf" to choose a root 826 * file system type. 827 */ 828 if (rootconf()) 829 panic("vfs_mountroot: cannot mount root"); 830 /* 831 * Get vnode for '/'. Set up rootdir, u.u_rdir and u.u_cdir 832 * to point to it. These are used by lookuppn() so that it 833 * knows where to start from ('/' or '.'). 834 */ 835 vfs_setmntpoint(rootvfs, "/"); 836 if (VFS_ROOT(rootvfs, &rootdir)) 837 panic("vfs_mountroot: no root vnode"); 838 839 /* 840 * At this point, the process tree consists of p0 and possibly some 841 * direct children of p0. (i.e. there are no grandchildren) 842 * 843 * Walk through them all, setting their current directory. 844 */ 845 mutex_enter(&pidlock); 846 for (p = practive; p != NULL; p = p->p_next) { 847 ASSERT(p == &p0 || p->p_parent == &p0); 848 849 PTOU(p)->u_cdir = rootdir; 850 VN_HOLD(PTOU(p)->u_cdir); 851 PTOU(p)->u_rdir = NULL; 852 } 853 mutex_exit(&pidlock); 854 855 /* 856 * Setup the global zone's rootvp, now that it exists. 857 */ 858 global_zone->zone_rootvp = rootdir; 859 VN_HOLD(global_zone->zone_rootvp); 860 861 /* 862 * Notify the module code that it can begin using the 863 * root filesystem instead of the boot program's services. 864 */ 865 modrootloaded = 1; 866 867 /* 868 * Special handling for a ZFS root file system. 869 */ 870 zfs_boot_init(); 871 872 /* 873 * Set up mnttab information for root 874 */ 875 vfs_setresource(rootvfs, rootfs.bo_name); 876 877 /* 878 * Notify cluster software that the root filesystem is available. 879 */ 880 clboot_mountroot(); 881 882 /* Now that we're all done with the root FS, set up its vopstats */ 883 if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) != NULL) { 884 /* Set flag for statistics collection */ 885 if (vswp->vsw_flag & VSW_STATS) { 886 initialize_vopstats(&rootvfs->vfs_vopstats); 887 rootvfs->vfs_flag |= VFS_STATS; 888 rootvfs->vfs_fstypevsp = 889 get_fstype_vopstats(rootvfs, vswp); 890 rootvfs->vfs_vskap = get_vskstat_anchor(rootvfs); 891 } 892 vfs_unrefvfssw(vswp); 893 } 894 895 /* 896 * Mount /devices, /dev instance 1, /system/contract, /etc/mnttab, 897 * /etc/svc/volatile, /etc/dfs/sharetab, /system/object, and /proc. 898 */ 899 vfs_mountdevices(); 900 vfs_mountdev1(); 901 902 vfs_mountfs("ctfs", "ctfs", CTFS_ROOT); 903 vfs_mountfs("proc", "/proc", "/proc"); 904 vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab"); 905 vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile"); 906 vfs_mountfs("objfs", "objfs", OBJFS_ROOT); 907 908 if (getzoneid() == GLOBAL_ZONEID) { 909 vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab"); 910 } 911 912 #ifdef __sparc 913 /* 914 * This bit of magic can go away when we convert sparc to 915 * the new boot architecture based on ramdisk. 916 * 917 * Booting off a mirrored root volume: 918 * At this point, we have booted and mounted root on a 919 * single component of the mirror. Complete the boot 920 * by configuring SVM and converting the root to the 921 * dev_t of the mirrored root device. This dev_t conversion 922 * only works because the underlying device doesn't change. 923 */ 924 if (root_is_svm) { 925 if (svm_rootconf()) { 926 panic("vfs_mountroot: cannot remount root"); 927 } 928 929 /* 930 * mnttab should reflect the new root device 931 */ 932 vfs_lock_wait(rootvfs); 933 vfs_setresource(rootvfs, rootfs.bo_name); 934 vfs_unlock(rootvfs); 935 } 936 #endif /* __sparc */ 937 938 /* 939 * Look up the root device via devfs so that a dv_node is 940 * created for it. The vnode is never VN_RELE()ed. 941 * We allocate more than MAXPATHLEN so that the 942 * buffer passed to i_ddi_prompath_to_devfspath() is 943 * exactly MAXPATHLEN (the function expects a buffer 944 * of that length). 945 */ 946 plen = strlen("/devices"); 947 path = kmem_alloc(plen + MAXPATHLEN, KM_SLEEP); 948 (void) strcpy(path, "/devices"); 949 950 if (i_ddi_prompath_to_devfspath(rootfs.bo_name, path + plen) 951 != DDI_SUCCESS || 952 lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &rvp)) { 953 954 /* NUL terminate in case "path" has garbage */ 955 path[plen + MAXPATHLEN - 1] = '\0'; 956 #ifdef DEBUG 957 cmn_err(CE_WARN, "!Cannot lookup root device: %s", path); 958 #endif 959 } 960 kmem_free(path, plen + MAXPATHLEN); 961 vfs_mnttabvp_setup(); 962 } 963 964 /* 965 * If remount failed and we're in a zone we need to check for the zone 966 * root path and strip it before the call to vfs_setpath(). 967 * 968 * If strpath doesn't begin with the zone_rootpath the original 969 * strpath is returned unchanged. 970 */ 971 static const char * 972 stripzonepath(const char *strpath) 973 { 974 char *str1, *str2; 975 int i; 976 zone_t *zonep = curproc->p_zone; 977 978 if (zonep->zone_rootpath == NULL || strpath == NULL) { 979 return (NULL); 980 } 981 982 /* 983 * we check for the end of the string at one past the 984 * current position because the zone_rootpath always 985 * ends with "/" but we don't want to strip that off. 986 */ 987 str1 = zonep->zone_rootpath; 988 str2 = (char *)strpath; 989 ASSERT(str1[0] != '\0'); 990 for (i = 0; str1[i + 1] != '\0'; i++) { 991 if (str1[i] != str2[i]) 992 return ((char *)strpath); 993 } 994 return (&str2[i]); 995 } 996 997 /* 998 * Check to see if our "block device" is actually a file. If so, 999 * automatically add a lofi device, and keep track of this fact. 1000 */ 1001 static int 1002 lofi_add(const char *fsname, struct vfs *vfsp, 1003 mntopts_t *mntopts, struct mounta *uap) 1004 { 1005 int fromspace = (uap->flags & MS_SYSSPACE) ? 1006 UIO_SYSSPACE : UIO_USERSPACE; 1007 struct lofi_ioctl *li = NULL; 1008 struct vnode *vp = NULL; 1009 struct pathname pn = { NULL }; 1010 ldi_ident_t ldi_id; 1011 ldi_handle_t ldi_hdl; 1012 vfssw_t *vfssw; 1013 int minor; 1014 int err = 0; 1015 1016 if ((vfssw = vfs_getvfssw(fsname)) == NULL) 1017 return (0); 1018 1019 if (!(vfssw->vsw_flag & VSW_CANLOFI)) { 1020 vfs_unrefvfssw(vfssw); 1021 return (0); 1022 } 1023 1024 vfs_unrefvfssw(vfssw); 1025 vfssw = NULL; 1026 1027 if (pn_get(uap->spec, fromspace, &pn) != 0) 1028 return (0); 1029 1030 if (lookupname(uap->spec, fromspace, FOLLOW, NULL, &vp) != 0) 1031 goto out; 1032 1033 if (vp->v_type != VREG) 1034 goto out; 1035 1036 /* OK, this is a lofi mount. */ 1037 1038 if ((uap->flags & (MS_REMOUNT|MS_GLOBAL)) || 1039 vfs_optionisset_nolock(mntopts, MNTOPT_SUID, NULL) || 1040 vfs_optionisset_nolock(mntopts, MNTOPT_SETUID, NULL) || 1041 vfs_optionisset_nolock(mntopts, MNTOPT_DEVICES, NULL)) { 1042 err = EINVAL; 1043 goto out; 1044 } 1045 1046 ldi_id = ldi_ident_from_anon(); 1047 li = kmem_zalloc(sizeof (*li), KM_SLEEP); 1048 (void) strlcpy(li->li_filename, pn.pn_path, MAXPATHLEN); 1049 1050 err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred, 1051 &ldi_hdl, ldi_id); 1052 1053 if (err) 1054 goto out2; 1055 1056 err = ldi_ioctl(ldi_hdl, LOFI_MAP_FILE, (intptr_t)li, 1057 FREAD | FWRITE | FKIOCTL, kcred, &minor); 1058 1059 (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred); 1060 1061 if (!err) 1062 vfsp->vfs_lofi_minor = minor; 1063 1064 out2: 1065 ldi_ident_release(ldi_id); 1066 out: 1067 if (li != NULL) 1068 kmem_free(li, sizeof (*li)); 1069 if (vp != NULL) 1070 VN_RELE(vp); 1071 pn_free(&pn); 1072 return (err); 1073 } 1074 1075 static void 1076 lofi_remove(struct vfs *vfsp) 1077 { 1078 struct lofi_ioctl *li = NULL; 1079 ldi_ident_t ldi_id; 1080 ldi_handle_t ldi_hdl; 1081 int err; 1082 1083 if (vfsp->vfs_lofi_minor == 0) 1084 return; 1085 1086 ldi_id = ldi_ident_from_anon(); 1087 1088 li = kmem_zalloc(sizeof (*li), KM_SLEEP); 1089 li->li_minor = vfsp->vfs_lofi_minor; 1090 li->li_cleanup = B_TRUE; 1091 1092 err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred, 1093 &ldi_hdl, ldi_id); 1094 1095 if (err) 1096 goto out; 1097 1098 err = ldi_ioctl(ldi_hdl, LOFI_UNMAP_FILE_MINOR, (intptr_t)li, 1099 FREAD | FWRITE | FKIOCTL, kcred, NULL); 1100 1101 (void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred); 1102 1103 if (!err) 1104 vfsp->vfs_lofi_minor = 0; 1105 1106 out: 1107 ldi_ident_release(ldi_id); 1108 if (li != NULL) 1109 kmem_free(li, sizeof (*li)); 1110 } 1111 1112 /* 1113 * Common mount code. Called from the system call entry point, from autofs, 1114 * nfsv4 trigger mounts, and from pxfs. 1115 * 1116 * Takes the effective file system type, mount arguments, the mount point 1117 * vnode, flags specifying whether the mount is a remount and whether it 1118 * should be entered into the vfs list, and credentials. Fills in its vfspp 1119 * parameter with the mounted file system instance's vfs. 1120 * 1121 * Note that the effective file system type is specified as a string. It may 1122 * be null, in which case it's determined from the mount arguments, and may 1123 * differ from the type specified in the mount arguments; this is a hook to 1124 * allow interposition when instantiating file system instances. 1125 * 1126 * The caller is responsible for releasing its own hold on the mount point 1127 * vp (this routine does its own hold when necessary). 1128 * Also note that for remounts, the mount point vp should be the vnode for 1129 * the root of the file system rather than the vnode that the file system 1130 * is mounted on top of. 1131 */ 1132 int 1133 domount(char *fsname, struct mounta *uap, vnode_t *vp, struct cred *credp, 1134 struct vfs **vfspp) 1135 { 1136 struct vfssw *vswp; 1137 vfsops_t *vfsops; 1138 struct vfs *vfsp; 1139 struct vnode *bvp; 1140 dev_t bdev = 0; 1141 mntopts_t mnt_mntopts; 1142 int error = 0; 1143 int copyout_error = 0; 1144 int ovflags; 1145 char *opts = uap->optptr; 1146 char *inargs = opts; 1147 int optlen = uap->optlen; 1148 int remount; 1149 int rdonly; 1150 int nbmand = 0; 1151 int delmip = 0; 1152 int addmip = 0; 1153 int splice = ((uap->flags & MS_NOSPLICE) == 0); 1154 int fromspace = (uap->flags & MS_SYSSPACE) ? 1155 UIO_SYSSPACE : UIO_USERSPACE; 1156 char *resource = NULL, *mountpt = NULL; 1157 refstr_t *oldresource, *oldmntpt; 1158 struct pathname pn, rpn; 1159 vsk_anchor_t *vskap; 1160 char fstname[FSTYPSZ]; 1161 1162 /* 1163 * The v_flag value for the mount point vp is permanently set 1164 * to VVFSLOCK so that no one bypasses the vn_vfs*locks routine 1165 * for mount point locking. 1166 */ 1167 mutex_enter(&vp->v_lock); 1168 vp->v_flag |= VVFSLOCK; 1169 mutex_exit(&vp->v_lock); 1170 1171 mnt_mntopts.mo_count = 0; 1172 /* 1173 * Find the ops vector to use to invoke the file system-specific mount 1174 * method. If the fsname argument is non-NULL, use it directly. 1175 * Otherwise, dig the file system type information out of the mount 1176 * arguments. 1177 * 1178 * A side effect is to hold the vfssw entry. 1179 * 1180 * Mount arguments can be specified in several ways, which are 1181 * distinguished by flag bit settings. The preferred way is to set 1182 * MS_OPTIONSTR, indicating an 8 argument mount with the file system 1183 * type supplied as a character string and the last two arguments 1184 * being a pointer to a character buffer and the size of the buffer. 1185 * On entry, the buffer holds a null terminated list of options; on 1186 * return, the string is the list of options the file system 1187 * recognized. If MS_DATA is set arguments five and six point to a 1188 * block of binary data which the file system interprets. 1189 * A further wrinkle is that some callers don't set MS_FSS and MS_DATA 1190 * consistently with these conventions. To handle them, we check to 1191 * see whether the pointer to the file system name has a numeric value 1192 * less than 256. If so, we treat it as an index. 1193 */ 1194 if (fsname != NULL) { 1195 if ((vswp = vfs_getvfssw(fsname)) == NULL) { 1196 return (EINVAL); 1197 } 1198 } else if (uap->flags & (MS_OPTIONSTR | MS_DATA | MS_FSS)) { 1199 size_t n; 1200 uint_t fstype; 1201 1202 fsname = fstname; 1203 1204 if ((fstype = (uintptr_t)uap->fstype) < 256) { 1205 RLOCK_VFSSW(); 1206 if (fstype == 0 || fstype >= nfstype || 1207 !ALLOCATED_VFSSW(&vfssw[fstype])) { 1208 RUNLOCK_VFSSW(); 1209 return (EINVAL); 1210 } 1211 (void) strcpy(fsname, vfssw[fstype].vsw_name); 1212 RUNLOCK_VFSSW(); 1213 if ((vswp = vfs_getvfssw(fsname)) == NULL) 1214 return (EINVAL); 1215 } else { 1216 /* 1217 * Handle either kernel or user address space. 1218 */ 1219 if (uap->flags & MS_SYSSPACE) { 1220 error = copystr(uap->fstype, fsname, 1221 FSTYPSZ, &n); 1222 } else { 1223 error = copyinstr(uap->fstype, fsname, 1224 FSTYPSZ, &n); 1225 } 1226 if (error) { 1227 if (error == ENAMETOOLONG) 1228 return (EINVAL); 1229 return (error); 1230 } 1231 if ((vswp = vfs_getvfssw(fsname)) == NULL) 1232 return (EINVAL); 1233 } 1234 } else { 1235 if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) == NULL) 1236 return (EINVAL); 1237 fsname = vswp->vsw_name; 1238 } 1239 if (!VFS_INSTALLED(vswp)) 1240 return (EINVAL); 1241 1242 if ((error = secpolicy_fs_allowed_mount(fsname)) != 0) { 1243 vfs_unrefvfssw(vswp); 1244 return (error); 1245 } 1246 1247 vfsops = &vswp->vsw_vfsops; 1248 1249 vfs_copyopttbl(&vswp->vsw_optproto, &mnt_mntopts); 1250 /* 1251 * Fetch mount options and parse them for generic vfs options 1252 */ 1253 if (uap->flags & MS_OPTIONSTR) { 1254 /* 1255 * Limit the buffer size 1256 */ 1257 if (optlen < 0 || optlen > MAX_MNTOPT_STR) { 1258 error = EINVAL; 1259 goto errout; 1260 } 1261 if ((uap->flags & MS_SYSSPACE) == 0) { 1262 inargs = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP); 1263 inargs[0] = '\0'; 1264 if (optlen) { 1265 error = copyinstr(opts, inargs, (size_t)optlen, 1266 NULL); 1267 if (error) { 1268 goto errout; 1269 } 1270 } 1271 } 1272 vfs_parsemntopts(&mnt_mntopts, inargs, 0); 1273 } 1274 /* 1275 * Flag bits override the options string. 1276 */ 1277 if (uap->flags & MS_REMOUNT) 1278 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_REMOUNT, NULL, 0, 0); 1279 if (uap->flags & MS_RDONLY) 1280 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_RO, NULL, 0, 0); 1281 if (uap->flags & MS_NOSUID) 1282 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0); 1283 1284 /* 1285 * Check if this is a remount; must be set in the option string and 1286 * the file system must support a remount option. 1287 */ 1288 if (remount = vfs_optionisset_nolock(&mnt_mntopts, 1289 MNTOPT_REMOUNT, NULL)) { 1290 if (!(vswp->vsw_flag & VSW_CANREMOUNT)) { 1291 error = ENOTSUP; 1292 goto errout; 1293 } 1294 uap->flags |= MS_REMOUNT; 1295 } 1296 1297 /* 1298 * uap->flags and vfs_optionisset() should agree. 1299 */ 1300 if (rdonly = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_RO, NULL)) { 1301 uap->flags |= MS_RDONLY; 1302 } 1303 if (vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL)) { 1304 uap->flags |= MS_NOSUID; 1305 } 1306 nbmand = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NBMAND, NULL); 1307 ASSERT(splice || !remount); 1308 /* 1309 * If we are splicing the fs into the namespace, 1310 * perform mount point checks. 1311 * 1312 * We want to resolve the path for the mount point to eliminate 1313 * '.' and ".." and symlinks in mount points; we can't do the 1314 * same for the resource string, since it would turn 1315 * "/dev/dsk/c0t0d0s0" into "/devices/pci@...". We need to do 1316 * this before grabbing vn_vfswlock(), because otherwise we 1317 * would deadlock with lookuppn(). 1318 */ 1319 if (splice) { 1320 ASSERT(vp->v_count > 0); 1321 1322 /* 1323 * Pick up mount point and device from appropriate space. 1324 */ 1325 if (pn_get(uap->spec, fromspace, &pn) == 0) { 1326 resource = kmem_alloc(pn.pn_pathlen + 1, 1327 KM_SLEEP); 1328 (void) strcpy(resource, pn.pn_path); 1329 pn_free(&pn); 1330 } 1331 /* 1332 * Do a lookupname prior to taking the 1333 * writelock. Mark this as completed if 1334 * successful for later cleanup and addition to 1335 * the mount in progress table. 1336 */ 1337 if ((uap->flags & MS_GLOBAL) == 0 && 1338 lookupname(uap->spec, fromspace, 1339 FOLLOW, NULL, &bvp) == 0) { 1340 addmip = 1; 1341 } 1342 1343 if ((error = pn_get(uap->dir, fromspace, &pn)) == 0) { 1344 pathname_t *pnp; 1345 1346 if (*pn.pn_path != '/') { 1347 error = EINVAL; 1348 pn_free(&pn); 1349 goto errout; 1350 } 1351 pn_alloc(&rpn); 1352 /* 1353 * Kludge to prevent autofs from deadlocking with 1354 * itself when it calls domount(). 1355 * 1356 * If autofs is calling, it is because it is doing 1357 * (autofs) mounts in the process of an NFS mount. A 1358 * lookuppn() here would cause us to block waiting for 1359 * said NFS mount to complete, which can't since this 1360 * is the thread that was supposed to doing it. 1361 */ 1362 if (fromspace == UIO_USERSPACE) { 1363 if ((error = lookuppn(&pn, &rpn, FOLLOW, NULL, 1364 NULL)) == 0) { 1365 pnp = &rpn; 1366 } else { 1367 /* 1368 * The file disappeared or otherwise 1369 * became inaccessible since we opened 1370 * it; might as well fail the mount 1371 * since the mount point is no longer 1372 * accessible. 1373 */ 1374 pn_free(&rpn); 1375 pn_free(&pn); 1376 goto errout; 1377 } 1378 } else { 1379 pnp = &pn; 1380 } 1381 mountpt = kmem_alloc(pnp->pn_pathlen + 1, KM_SLEEP); 1382 (void) strcpy(mountpt, pnp->pn_path); 1383 1384 /* 1385 * If the addition of the zone's rootpath 1386 * would push us over a total path length 1387 * of MAXPATHLEN, we fail the mount with 1388 * ENAMETOOLONG, which is what we would have 1389 * gotten if we were trying to perform the same 1390 * mount in the global zone. 1391 * 1392 * strlen() doesn't count the trailing 1393 * '\0', but zone_rootpathlen counts both a 1394 * trailing '/' and the terminating '\0'. 1395 */ 1396 if ((curproc->p_zone->zone_rootpathlen - 1 + 1397 strlen(mountpt)) > MAXPATHLEN || 1398 (resource != NULL && 1399 (curproc->p_zone->zone_rootpathlen - 1 + 1400 strlen(resource)) > MAXPATHLEN)) { 1401 error = ENAMETOOLONG; 1402 } 1403 1404 pn_free(&rpn); 1405 pn_free(&pn); 1406 } 1407 1408 if (error) 1409 goto errout; 1410 1411 /* 1412 * Prevent path name resolution from proceeding past 1413 * the mount point. 1414 */ 1415 if (vn_vfswlock(vp) != 0) { 1416 error = EBUSY; 1417 goto errout; 1418 } 1419 1420 /* 1421 * Verify that it's legitimate to establish a mount on 1422 * the prospective mount point. 1423 */ 1424 if (vn_mountedvfs(vp) != NULL) { 1425 /* 1426 * The mount point lock was obtained after some 1427 * other thread raced through and established a mount. 1428 */ 1429 vn_vfsunlock(vp); 1430 error = EBUSY; 1431 goto errout; 1432 } 1433 if (vp->v_flag & VNOMOUNT) { 1434 vn_vfsunlock(vp); 1435 error = EINVAL; 1436 goto errout; 1437 } 1438 } 1439 if ((uap->flags & (MS_DATA | MS_OPTIONSTR)) == 0) { 1440 uap->dataptr = NULL; 1441 uap->datalen = 0; 1442 } 1443 1444 /* 1445 * If this is a remount, we don't want to create a new VFS. 1446 * Instead, we pass the existing one with a remount flag. 1447 */ 1448 if (remount) { 1449 /* 1450 * Confirm that the mount point is the root vnode of the 1451 * file system that is being remounted. 1452 * This can happen if the user specifies a different 1453 * mount point directory pathname in the (re)mount command. 1454 * 1455 * Code below can only be reached if splice is true, so it's 1456 * safe to do vn_vfsunlock() here. 1457 */ 1458 if ((vp->v_flag & VROOT) == 0) { 1459 vn_vfsunlock(vp); 1460 error = ENOENT; 1461 goto errout; 1462 } 1463 /* 1464 * Disallow making file systems read-only unless file system 1465 * explicitly allows it in its vfssw. Ignore other flags. 1466 */ 1467 if (rdonly && vn_is_readonly(vp) == 0 && 1468 (vswp->vsw_flag & VSW_CANRWRO) == 0) { 1469 vn_vfsunlock(vp); 1470 error = EINVAL; 1471 goto errout; 1472 } 1473 /* 1474 * Disallow changing the NBMAND disposition of the file 1475 * system on remounts. 1476 */ 1477 if ((nbmand && ((vp->v_vfsp->vfs_flag & VFS_NBMAND) == 0)) || 1478 (!nbmand && (vp->v_vfsp->vfs_flag & VFS_NBMAND))) { 1479 vn_vfsunlock(vp); 1480 error = EINVAL; 1481 goto errout; 1482 } 1483 vfsp = vp->v_vfsp; 1484 ovflags = vfsp->vfs_flag; 1485 vfsp->vfs_flag |= VFS_REMOUNT; 1486 vfsp->vfs_flag &= ~VFS_RDONLY; 1487 } else { 1488 vfsp = vfs_alloc(KM_SLEEP); 1489 VFS_INIT(vfsp, vfsops, NULL); 1490 } 1491 1492 VFS_HOLD(vfsp); 1493 1494 if ((error = lofi_add(fsname, vfsp, &mnt_mntopts, uap)) != 0) { 1495 if (!remount) { 1496 if (splice) 1497 vn_vfsunlock(vp); 1498 vfs_free(vfsp); 1499 } else { 1500 vn_vfsunlock(vp); 1501 VFS_RELE(vfsp); 1502 } 1503 goto errout; 1504 } 1505 1506 /* 1507 * PRIV_SYS_MOUNT doesn't mean you can become root. 1508 */ 1509 if (vfsp->vfs_lofi_minor != 0) { 1510 uap->flags |= MS_NOSUID; 1511 vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0); 1512 } 1513 1514 /* 1515 * The vfs_reflock is not used anymore the code below explicitly 1516 * holds it preventing others accesing it directly. 1517 */ 1518 if ((sema_tryp(&vfsp->vfs_reflock) == 0) && 1519 !(vfsp->vfs_flag & VFS_REMOUNT)) 1520 cmn_err(CE_WARN, 1521 "mount type %s couldn't get vfs_reflock", vswp->vsw_name); 1522 1523 /* 1524 * Lock the vfs. If this is a remount we want to avoid spurious umount 1525 * failures that happen as a side-effect of fsflush() and other mount 1526 * and unmount operations that might be going on simultaneously and 1527 * may have locked the vfs currently. To not return EBUSY immediately 1528 * here we use vfs_lock_wait() instead vfs_lock() for the remount case. 1529 */ 1530 if (!remount) { 1531 if (error = vfs_lock(vfsp)) { 1532 vfsp->vfs_flag = ovflags; 1533 1534 lofi_remove(vfsp); 1535 1536 if (splice) 1537 vn_vfsunlock(vp); 1538 vfs_free(vfsp); 1539 goto errout; 1540 } 1541 } else { 1542 vfs_lock_wait(vfsp); 1543 } 1544 1545 /* 1546 * Add device to mount in progress table, global mounts require special 1547 * handling. It is possible that we have already done the lookupname 1548 * on a spliced, non-global fs. If so, we don't want to do it again 1549 * since we cannot do a lookupname after taking the 1550 * wlock above. This case is for a non-spliced, non-global filesystem. 1551 */ 1552 if (!addmip) { 1553 if ((uap->flags & MS_GLOBAL) == 0 && 1554 lookupname(uap->spec, fromspace, FOLLOW, NULL, &bvp) == 0) { 1555 addmip = 1; 1556 } 1557 } 1558 1559 if (addmip) { 1560 vnode_t *lvp = NULL; 1561 1562 error = vfs_get_lofi(vfsp, &lvp); 1563 if (error > 0) { 1564 lofi_remove(vfsp); 1565 1566 if (splice) 1567 vn_vfsunlock(vp); 1568 vfs_unlock(vfsp); 1569 1570 if (remount) { 1571 VFS_RELE(vfsp); 1572 } else { 1573 vfs_free(vfsp); 1574 } 1575 1576 goto errout; 1577 } else if (error == -1) { 1578 bdev = bvp->v_rdev; 1579 VN_RELE(bvp); 1580 } else { 1581 bdev = lvp->v_rdev; 1582 VN_RELE(lvp); 1583 VN_RELE(bvp); 1584 } 1585 1586 vfs_addmip(bdev, vfsp); 1587 addmip = 0; 1588 delmip = 1; 1589 } 1590 /* 1591 * Invalidate cached entry for the mount point. 1592 */ 1593 if (splice) 1594 dnlc_purge_vp(vp); 1595 1596 /* 1597 * If have an option string but the filesystem doesn't supply a 1598 * prototype options table, create a table with the global 1599 * options and sufficient room to accept all the options in the 1600 * string. Then parse the passed in option string 1601 * accepting all the options in the string. This gives us an 1602 * option table with all the proper cancel properties for the 1603 * global options. 1604 * 1605 * Filesystems that supply a prototype options table are handled 1606 * earlier in this function. 1607 */ 1608 if (uap->flags & MS_OPTIONSTR) { 1609 if (!(vswp->vsw_flag & VSW_HASPROTO)) { 1610 mntopts_t tmp_mntopts; 1611 1612 tmp_mntopts.mo_count = 0; 1613 vfs_createopttbl_extend(&tmp_mntopts, inargs, 1614 &mnt_mntopts); 1615 vfs_parsemntopts(&tmp_mntopts, inargs, 1); 1616 vfs_swapopttbl_nolock(&mnt_mntopts, &tmp_mntopts); 1617 vfs_freeopttbl(&tmp_mntopts); 1618 } 1619 } 1620 1621 /* 1622 * Serialize with zone creations. 1623 */ 1624 mount_in_progress(); 1625 /* 1626 * Instantiate (or reinstantiate) the file system. If appropriate, 1627 * splice it into the file system name space. 1628 * 1629 * We want VFS_MOUNT() to be able to override the vfs_resource 1630 * string if necessary (ie, mntfs), and also for a remount to 1631 * change the same (necessary when remounting '/' during boot). 1632 * So we set up vfs_mntpt and vfs_resource to what we think they 1633 * should be, then hand off control to VFS_MOUNT() which can 1634 * override this. 1635 * 1636 * For safety's sake, when changing vfs_resource or vfs_mntpt of 1637 * a vfs which is on the vfs list (i.e. during a remount), we must 1638 * never set those fields to NULL. Several bits of code make 1639 * assumptions that the fields are always valid. 1640 */ 1641 vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts); 1642 if (remount) { 1643 if ((oldresource = vfsp->vfs_resource) != NULL) 1644 refstr_hold(oldresource); 1645 if ((oldmntpt = vfsp->vfs_mntpt) != NULL) 1646 refstr_hold(oldmntpt); 1647 } 1648 vfs_setresource(vfsp, resource); 1649 vfs_setmntpoint(vfsp, mountpt); 1650 1651 /* 1652 * going to mount on this vnode, so notify. 1653 */ 1654 vnevent_mountedover(vp, NULL); 1655 error = VFS_MOUNT(vfsp, vp, uap, credp); 1656 1657 if (uap->flags & MS_RDONLY) 1658 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 1659 if (uap->flags & MS_NOSUID) 1660 vfs_setmntopt(vfsp, MNTOPT_NOSUID, NULL, 0); 1661 if (uap->flags & MS_GLOBAL) 1662 vfs_setmntopt(vfsp, MNTOPT_GLOBAL, NULL, 0); 1663 1664 if (error) { 1665 lofi_remove(vfsp); 1666 1667 if (remount) { 1668 /* put back pre-remount options */ 1669 vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts); 1670 vfs_setmntpoint(vfsp, (stripzonepath( 1671 refstr_value(oldmntpt)))); 1672 if (oldmntpt) 1673 refstr_rele(oldmntpt); 1674 vfs_setresource(vfsp, (stripzonepath( 1675 refstr_value(oldresource)))); 1676 if (oldresource) 1677 refstr_rele(oldresource); 1678 vfsp->vfs_flag = ovflags; 1679 vfs_unlock(vfsp); 1680 VFS_RELE(vfsp); 1681 } else { 1682 vfs_unlock(vfsp); 1683 vfs_freemnttab(vfsp); 1684 vfs_free(vfsp); 1685 } 1686 } else { 1687 /* 1688 * Set the mount time to now 1689 */ 1690 vfsp->vfs_mtime = ddi_get_time(); 1691 if (remount) { 1692 vfsp->vfs_flag &= ~VFS_REMOUNT; 1693 if (oldresource) 1694 refstr_rele(oldresource); 1695 if (oldmntpt) 1696 refstr_rele(oldmntpt); 1697 } else if (splice) { 1698 /* 1699 * Link vfsp into the name space at the mount 1700 * point. Vfs_add() is responsible for 1701 * holding the mount point which will be 1702 * released when vfs_remove() is called. 1703 */ 1704 vfs_add(vp, vfsp, uap->flags); 1705 } else { 1706 /* 1707 * Hold the reference to file system which is 1708 * not linked into the name space. 1709 */ 1710 vfsp->vfs_zone = NULL; 1711 VFS_HOLD(vfsp); 1712 vfsp->vfs_vnodecovered = NULL; 1713 } 1714 /* 1715 * Set flags for global options encountered 1716 */ 1717 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) 1718 vfsp->vfs_flag |= VFS_RDONLY; 1719 else 1720 vfsp->vfs_flag &= ~VFS_RDONLY; 1721 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) { 1722 vfsp->vfs_flag |= (VFS_NOSETUID|VFS_NODEVICES); 1723 } else { 1724 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) 1725 vfsp->vfs_flag |= VFS_NODEVICES; 1726 else 1727 vfsp->vfs_flag &= ~VFS_NODEVICES; 1728 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) 1729 vfsp->vfs_flag |= VFS_NOSETUID; 1730 else 1731 vfsp->vfs_flag &= ~VFS_NOSETUID; 1732 } 1733 if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) 1734 vfsp->vfs_flag |= VFS_NBMAND; 1735 else 1736 vfsp->vfs_flag &= ~VFS_NBMAND; 1737 1738 if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) 1739 vfsp->vfs_flag |= VFS_XATTR; 1740 else 1741 vfsp->vfs_flag &= ~VFS_XATTR; 1742 1743 if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) 1744 vfsp->vfs_flag |= VFS_NOEXEC; 1745 else 1746 vfsp->vfs_flag &= ~VFS_NOEXEC; 1747 1748 /* 1749 * Now construct the output option string of options 1750 * we recognized. 1751 */ 1752 if (uap->flags & MS_OPTIONSTR) { 1753 vfs_list_read_lock(); 1754 copyout_error = vfs_buildoptionstr( 1755 &vfsp->vfs_mntopts, inargs, optlen); 1756 vfs_list_unlock(); 1757 if (copyout_error == 0 && 1758 (uap->flags & MS_SYSSPACE) == 0) { 1759 copyout_error = copyoutstr(inargs, opts, 1760 optlen, NULL); 1761 } 1762 } 1763 1764 /* 1765 * If this isn't a remount, set up the vopstats before 1766 * anyone can touch this. We only allow spliced file 1767 * systems (file systems which are in the namespace) to 1768 * have the VFS_STATS flag set. 1769 * NOTE: PxFS mounts the underlying file system with 1770 * MS_NOSPLICE set and copies those vfs_flags to its private 1771 * vfs structure. As a result, PxFS should never have 1772 * the VFS_STATS flag or else we might access the vfs 1773 * statistics-related fields prior to them being 1774 * properly initialized. 1775 */ 1776 if (!remount && (vswp->vsw_flag & VSW_STATS) && splice) { 1777 initialize_vopstats(&vfsp->vfs_vopstats); 1778 /* 1779 * We need to set vfs_vskap to NULL because there's 1780 * a chance it won't be set below. This is checked 1781 * in teardown_vopstats() so we can't have garbage. 1782 */ 1783 vfsp->vfs_vskap = NULL; 1784 vfsp->vfs_flag |= VFS_STATS; 1785 vfsp->vfs_fstypevsp = get_fstype_vopstats(vfsp, vswp); 1786 } 1787 1788 if (vswp->vsw_flag & VSW_XID) 1789 vfsp->vfs_flag |= VFS_XID; 1790 1791 vfs_unlock(vfsp); 1792 } 1793 mount_completed(); 1794 if (splice) 1795 vn_vfsunlock(vp); 1796 1797 if ((error == 0) && (copyout_error == 0)) { 1798 if (!remount) { 1799 /* 1800 * Don't call get_vskstat_anchor() while holding 1801 * locks since it allocates memory and calls 1802 * VFS_STATVFS(). For NFS, the latter can generate 1803 * an over-the-wire call. 1804 */ 1805 vskap = get_vskstat_anchor(vfsp); 1806 /* Only take the lock if we have something to do */ 1807 if (vskap != NULL) { 1808 vfs_lock_wait(vfsp); 1809 if (vfsp->vfs_flag & VFS_STATS) { 1810 vfsp->vfs_vskap = vskap; 1811 } 1812 vfs_unlock(vfsp); 1813 } 1814 } 1815 /* Return vfsp to caller. */ 1816 *vfspp = vfsp; 1817 } 1818 errout: 1819 vfs_freeopttbl(&mnt_mntopts); 1820 if (resource != NULL) 1821 kmem_free(resource, strlen(resource) + 1); 1822 if (mountpt != NULL) 1823 kmem_free(mountpt, strlen(mountpt) + 1); 1824 /* 1825 * It is possible we errored prior to adding to mount in progress 1826 * table. Must free vnode we acquired with successful lookupname. 1827 */ 1828 if (addmip) 1829 VN_RELE(bvp); 1830 if (delmip) 1831 vfs_delmip(vfsp); 1832 ASSERT(vswp != NULL); 1833 vfs_unrefvfssw(vswp); 1834 if (inargs != opts) 1835 kmem_free(inargs, MAX_MNTOPT_STR); 1836 if (copyout_error) { 1837 lofi_remove(vfsp); 1838 VFS_RELE(vfsp); 1839 error = copyout_error; 1840 } 1841 return (error); 1842 } 1843 1844 static void 1845 vfs_setpath(struct vfs *vfsp, refstr_t **refp, const char *newpath) 1846 { 1847 size_t len; 1848 refstr_t *ref; 1849 zone_t *zone = curproc->p_zone; 1850 char *sp; 1851 int have_list_lock = 0; 1852 1853 ASSERT(!VFS_ON_LIST(vfsp) || vfs_lock_held(vfsp)); 1854 1855 /* 1856 * New path must be less than MAXPATHLEN because mntfs 1857 * will only display up to MAXPATHLEN bytes. This is currently 1858 * safe, because domount() uses pn_get(), and other callers 1859 * similarly cap the size to fewer than MAXPATHLEN bytes. 1860 */ 1861 1862 ASSERT(strlen(newpath) < MAXPATHLEN); 1863 1864 /* mntfs requires consistency while vfs list lock is held */ 1865 1866 if (VFS_ON_LIST(vfsp)) { 1867 have_list_lock = 1; 1868 vfs_list_lock(); 1869 } 1870 1871 if (*refp != NULL) 1872 refstr_rele(*refp); 1873 1874 /* Do we need to modify the path? */ 1875 1876 if (zone == global_zone || *newpath != '/') { 1877 ref = refstr_alloc(newpath); 1878 goto out; 1879 } 1880 1881 /* 1882 * Truncate the trailing '/' in the zoneroot, and merge 1883 * in the zone's rootpath with the "newpath" (resource 1884 * or mountpoint) passed in. 1885 * 1886 * The size of the required buffer is thus the size of 1887 * the buffer required for the passed-in newpath 1888 * (strlen(newpath) + 1), plus the size of the buffer 1889 * required to hold zone_rootpath (zone_rootpathlen) 1890 * minus one for one of the now-superfluous NUL 1891 * terminations, minus one for the trailing '/'. 1892 * 1893 * That gives us: 1894 * 1895 * (strlen(newpath) + 1) + zone_rootpathlen - 1 - 1 1896 * 1897 * Which is what we have below. 1898 */ 1899 1900 len = strlen(newpath) + zone->zone_rootpathlen - 1; 1901 sp = kmem_alloc(len, KM_SLEEP); 1902 1903 /* 1904 * Copy everything including the trailing slash, which 1905 * we then overwrite with the NUL character. 1906 */ 1907 1908 (void) strcpy(sp, zone->zone_rootpath); 1909 sp[zone->zone_rootpathlen - 2] = '\0'; 1910 (void) strcat(sp, newpath); 1911 1912 ref = refstr_alloc(sp); 1913 kmem_free(sp, len); 1914 out: 1915 *refp = ref; 1916 1917 if (have_list_lock) { 1918 vfs_mnttab_modtimeupd(); 1919 vfs_list_unlock(); 1920 } 1921 } 1922 1923 /* 1924 * Record a mounted resource name in a vfs structure. 1925 * If vfsp is already mounted, caller must hold the vfs lock. 1926 */ 1927 void 1928 vfs_setresource(struct vfs *vfsp, const char *resource) 1929 { 1930 if (resource == NULL || resource[0] == '\0') 1931 resource = VFS_NORESOURCE; 1932 vfs_setpath(vfsp, &vfsp->vfs_resource, resource); 1933 } 1934 1935 /* 1936 * Record a mount point name in a vfs structure. 1937 * If vfsp is already mounted, caller must hold the vfs lock. 1938 */ 1939 void 1940 vfs_setmntpoint(struct vfs *vfsp, const char *mntpt) 1941 { 1942 if (mntpt == NULL || mntpt[0] == '\0') 1943 mntpt = VFS_NOMNTPT; 1944 vfs_setpath(vfsp, &vfsp->vfs_mntpt, mntpt); 1945 } 1946 1947 /* Returns the vfs_resource. Caller must call refstr_rele() when finished. */ 1948 1949 refstr_t * 1950 vfs_getresource(const struct vfs *vfsp) 1951 { 1952 refstr_t *resource; 1953 1954 vfs_list_read_lock(); 1955 resource = vfsp->vfs_resource; 1956 refstr_hold(resource); 1957 vfs_list_unlock(); 1958 1959 return (resource); 1960 } 1961 1962 /* Returns the vfs_mntpt. Caller must call refstr_rele() when finished. */ 1963 1964 refstr_t * 1965 vfs_getmntpoint(const struct vfs *vfsp) 1966 { 1967 refstr_t *mntpt; 1968 1969 vfs_list_read_lock(); 1970 mntpt = vfsp->vfs_mntpt; 1971 refstr_hold(mntpt); 1972 vfs_list_unlock(); 1973 1974 return (mntpt); 1975 } 1976 1977 /* 1978 * Create an empty options table with enough empty slots to hold all 1979 * The options in the options string passed as an argument. 1980 * Potentially prepend another options table. 1981 * 1982 * Note: caller is responsible for locking the vfs list, if needed, 1983 * to protect mops. 1984 */ 1985 static void 1986 vfs_createopttbl_extend(mntopts_t *mops, const char *opts, 1987 const mntopts_t *mtmpl) 1988 { 1989 const char *s = opts; 1990 uint_t count; 1991 1992 if (opts == NULL || *opts == '\0') { 1993 count = 0; 1994 } else { 1995 count = 1; 1996 1997 /* 1998 * Count number of options in the string 1999 */ 2000 for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) { 2001 count++; 2002 s++; 2003 } 2004 } 2005 vfs_copyopttbl_extend(mtmpl, mops, count); 2006 } 2007 2008 /* 2009 * Create an empty options table with enough empty slots to hold all 2010 * The options in the options string passed as an argument. 2011 * 2012 * This function is *not* for general use by filesystems. 2013 * 2014 * Note: caller is responsible for locking the vfs list, if needed, 2015 * to protect mops. 2016 */ 2017 void 2018 vfs_createopttbl(mntopts_t *mops, const char *opts) 2019 { 2020 vfs_createopttbl_extend(mops, opts, NULL); 2021 } 2022 2023 2024 /* 2025 * Swap two mount options tables 2026 */ 2027 static void 2028 vfs_swapopttbl_nolock(mntopts_t *optbl1, mntopts_t *optbl2) 2029 { 2030 uint_t tmpcnt; 2031 mntopt_t *tmplist; 2032 2033 tmpcnt = optbl2->mo_count; 2034 tmplist = optbl2->mo_list; 2035 optbl2->mo_count = optbl1->mo_count; 2036 optbl2->mo_list = optbl1->mo_list; 2037 optbl1->mo_count = tmpcnt; 2038 optbl1->mo_list = tmplist; 2039 } 2040 2041 static void 2042 vfs_swapopttbl(mntopts_t *optbl1, mntopts_t *optbl2) 2043 { 2044 vfs_list_lock(); 2045 vfs_swapopttbl_nolock(optbl1, optbl2); 2046 vfs_mnttab_modtimeupd(); 2047 vfs_list_unlock(); 2048 } 2049 2050 static char ** 2051 vfs_copycancelopt_extend(char **const moc, int extend) 2052 { 2053 int i = 0; 2054 int j; 2055 char **result; 2056 2057 if (moc != NULL) { 2058 for (; moc[i] != NULL; i++) 2059 /* count number of options to cancel */; 2060 } 2061 2062 if (i + extend == 0) 2063 return (NULL); 2064 2065 result = kmem_alloc((i + extend + 1) * sizeof (char *), KM_SLEEP); 2066 2067 for (j = 0; j < i; j++) { 2068 result[j] = kmem_alloc(strlen(moc[j]) + 1, KM_SLEEP); 2069 (void) strcpy(result[j], moc[j]); 2070 } 2071 for (; j <= i + extend; j++) 2072 result[j] = NULL; 2073 2074 return (result); 2075 } 2076 2077 static void 2078 vfs_copyopt(const mntopt_t *s, mntopt_t *d) 2079 { 2080 char *sp, *dp; 2081 2082 d->mo_flags = s->mo_flags; 2083 d->mo_data = s->mo_data; 2084 sp = s->mo_name; 2085 if (sp != NULL) { 2086 dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP); 2087 (void) strcpy(dp, sp); 2088 d->mo_name = dp; 2089 } else { 2090 d->mo_name = NULL; /* should never happen */ 2091 } 2092 2093 d->mo_cancel = vfs_copycancelopt_extend(s->mo_cancel, 0); 2094 2095 sp = s->mo_arg; 2096 if (sp != NULL) { 2097 dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP); 2098 (void) strcpy(dp, sp); 2099 d->mo_arg = dp; 2100 } else { 2101 d->mo_arg = NULL; 2102 } 2103 } 2104 2105 /* 2106 * Copy a mount options table, possibly allocating some spare 2107 * slots at the end. It is permissible to copy_extend the NULL table. 2108 */ 2109 static void 2110 vfs_copyopttbl_extend(const mntopts_t *smo, mntopts_t *dmo, int extra) 2111 { 2112 uint_t i, count; 2113 mntopt_t *motbl; 2114 2115 /* 2116 * Clear out any existing stuff in the options table being initialized 2117 */ 2118 vfs_freeopttbl(dmo); 2119 count = (smo == NULL) ? 0 : smo->mo_count; 2120 if ((count + extra) == 0) /* nothing to do */ 2121 return; 2122 dmo->mo_count = count + extra; 2123 motbl = kmem_zalloc((count + extra) * sizeof (mntopt_t), KM_SLEEP); 2124 dmo->mo_list = motbl; 2125 for (i = 0; i < count; i++) { 2126 vfs_copyopt(&smo->mo_list[i], &motbl[i]); 2127 } 2128 for (i = count; i < count + extra; i++) { 2129 motbl[i].mo_flags = MO_EMPTY; 2130 } 2131 } 2132 2133 /* 2134 * Copy a mount options table. 2135 * 2136 * This function is *not* for general use by filesystems. 2137 * 2138 * Note: caller is responsible for locking the vfs list, if needed, 2139 * to protect smo and dmo. 2140 */ 2141 void 2142 vfs_copyopttbl(const mntopts_t *smo, mntopts_t *dmo) 2143 { 2144 vfs_copyopttbl_extend(smo, dmo, 0); 2145 } 2146 2147 static char ** 2148 vfs_mergecancelopts(const mntopt_t *mop1, const mntopt_t *mop2) 2149 { 2150 int c1 = 0; 2151 int c2 = 0; 2152 char **result; 2153 char **sp1, **sp2, **dp; 2154 2155 /* 2156 * First we count both lists of cancel options. 2157 * If either is NULL or has no elements, we return a copy of 2158 * the other. 2159 */ 2160 if (mop1->mo_cancel != NULL) { 2161 for (; mop1->mo_cancel[c1] != NULL; c1++) 2162 /* count cancel options in mop1 */; 2163 } 2164 2165 if (c1 == 0) 2166 return (vfs_copycancelopt_extend(mop2->mo_cancel, 0)); 2167 2168 if (mop2->mo_cancel != NULL) { 2169 for (; mop2->mo_cancel[c2] != NULL; c2++) 2170 /* count cancel options in mop2 */; 2171 } 2172 2173 result = vfs_copycancelopt_extend(mop1->mo_cancel, c2); 2174 2175 if (c2 == 0) 2176 return (result); 2177 2178 /* 2179 * When we get here, we've got two sets of cancel options; 2180 * we need to merge the two sets. We know that the result 2181 * array has "c1+c2+1" entries and in the end we might shrink 2182 * it. 2183 * Result now has a copy of the c1 entries from mop1; we'll 2184 * now lookup all the entries of mop2 in mop1 and copy it if 2185 * it is unique. 2186 * This operation is O(n^2) but it's only called once per 2187 * filesystem per duplicate option. This is a situation 2188 * which doesn't arise with the filesystems in ON and 2189 * n is generally 1. 2190 */ 2191 2192 dp = &result[c1]; 2193 for (sp2 = mop2->mo_cancel; *sp2 != NULL; sp2++) { 2194 for (sp1 = mop1->mo_cancel; *sp1 != NULL; sp1++) { 2195 if (strcmp(*sp1, *sp2) == 0) 2196 break; 2197 } 2198 if (*sp1 == NULL) { 2199 /* 2200 * Option *sp2 not found in mop1, so copy it. 2201 * The calls to vfs_copycancelopt_extend() 2202 * guarantee that there's enough room. 2203 */ 2204 *dp = kmem_alloc(strlen(*sp2) + 1, KM_SLEEP); 2205 (void) strcpy(*dp++, *sp2); 2206 } 2207 } 2208 if (dp != &result[c1+c2]) { 2209 size_t bytes = (dp - result + 1) * sizeof (char *); 2210 char **nres = kmem_alloc(bytes, KM_SLEEP); 2211 2212 bcopy(result, nres, bytes); 2213 kmem_free(result, (c1 + c2 + 1) * sizeof (char *)); 2214 result = nres; 2215 } 2216 return (result); 2217 } 2218 2219 /* 2220 * Merge two mount option tables (outer and inner) into one. This is very 2221 * similar to "merging" global variables and automatic variables in C. 2222 * 2223 * This isn't (and doesn't have to be) fast. 2224 * 2225 * This function is *not* for general use by filesystems. 2226 * 2227 * Note: caller is responsible for locking the vfs list, if needed, 2228 * to protect omo, imo & dmo. 2229 */ 2230 void 2231 vfs_mergeopttbl(const mntopts_t *omo, const mntopts_t *imo, mntopts_t *dmo) 2232 { 2233 uint_t i, count; 2234 mntopt_t *mop, *motbl; 2235 uint_t freeidx; 2236 2237 /* 2238 * First determine how much space we need to allocate. 2239 */ 2240 count = omo->mo_count; 2241 for (i = 0; i < imo->mo_count; i++) { 2242 if (imo->mo_list[i].mo_flags & MO_EMPTY) 2243 continue; 2244 if (vfs_hasopt(omo, imo->mo_list[i].mo_name) == NULL) 2245 count++; 2246 } 2247 ASSERT(count >= omo->mo_count && 2248 count <= omo->mo_count + imo->mo_count); 2249 motbl = kmem_alloc(count * sizeof (mntopt_t), KM_SLEEP); 2250 for (i = 0; i < omo->mo_count; i++) 2251 vfs_copyopt(&omo->mo_list[i], &motbl[i]); 2252 freeidx = omo->mo_count; 2253 for (i = 0; i < imo->mo_count; i++) { 2254 if (imo->mo_list[i].mo_flags & MO_EMPTY) 2255 continue; 2256 if ((mop = vfs_hasopt(omo, imo->mo_list[i].mo_name)) != NULL) { 2257 char **newcanp; 2258 uint_t index = mop - omo->mo_list; 2259 2260 newcanp = vfs_mergecancelopts(mop, &motbl[index]); 2261 2262 vfs_freeopt(&motbl[index]); 2263 vfs_copyopt(&imo->mo_list[i], &motbl[index]); 2264 2265 vfs_freecancelopt(motbl[index].mo_cancel); 2266 motbl[index].mo_cancel = newcanp; 2267 } else { 2268 /* 2269 * If it's a new option, just copy it over to the first 2270 * free location. 2271 */ 2272 vfs_copyopt(&imo->mo_list[i], &motbl[freeidx++]); 2273 } 2274 } 2275 dmo->mo_count = count; 2276 dmo->mo_list = motbl; 2277 } 2278 2279 /* 2280 * Functions to set and clear mount options in a mount options table. 2281 */ 2282 2283 /* 2284 * Clear a mount option, if it exists. 2285 * 2286 * The update_mnttab arg indicates whether mops is part of a vfs that is on 2287 * the vfs list. 2288 */ 2289 static void 2290 vfs_clearmntopt_nolock(mntopts_t *mops, const char *opt, int update_mnttab) 2291 { 2292 struct mntopt *mop; 2293 uint_t i, count; 2294 2295 ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist)); 2296 2297 count = mops->mo_count; 2298 for (i = 0; i < count; i++) { 2299 mop = &mops->mo_list[i]; 2300 2301 if (mop->mo_flags & MO_EMPTY) 2302 continue; 2303 if (strcmp(opt, mop->mo_name)) 2304 continue; 2305 mop->mo_flags &= ~MO_SET; 2306 if (mop->mo_arg != NULL) { 2307 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1); 2308 } 2309 mop->mo_arg = NULL; 2310 if (update_mnttab) 2311 vfs_mnttab_modtimeupd(); 2312 break; 2313 } 2314 } 2315 2316 void 2317 vfs_clearmntopt(struct vfs *vfsp, const char *opt) 2318 { 2319 int gotlock = 0; 2320 2321 if (VFS_ON_LIST(vfsp)) { 2322 gotlock = 1; 2323 vfs_list_lock(); 2324 } 2325 vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, opt, gotlock); 2326 if (gotlock) 2327 vfs_list_unlock(); 2328 } 2329 2330 2331 /* 2332 * Set a mount option on. If it's not found in the table, it's silently 2333 * ignored. If the option has MO_IGNORE set, it is still set unless the 2334 * VFS_NOFORCEOPT bit is set in the flags. Also, VFS_DISPLAY/VFS_NODISPLAY flag 2335 * bits can be used to toggle the MO_NODISPLAY bit for the option. 2336 * If the VFS_CREATEOPT flag bit is set then the first option slot with 2337 * MO_EMPTY set is created as the option passed in. 2338 * 2339 * The update_mnttab arg indicates whether mops is part of a vfs that is on 2340 * the vfs list. 2341 */ 2342 static void 2343 vfs_setmntopt_nolock(mntopts_t *mops, const char *opt, 2344 const char *arg, int flags, int update_mnttab) 2345 { 2346 mntopt_t *mop; 2347 uint_t i, count; 2348 char *sp; 2349 2350 ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist)); 2351 2352 if (flags & VFS_CREATEOPT) { 2353 if (vfs_hasopt(mops, opt) != NULL) { 2354 flags &= ~VFS_CREATEOPT; 2355 } 2356 } 2357 count = mops->mo_count; 2358 for (i = 0; i < count; i++) { 2359 mop = &mops->mo_list[i]; 2360 2361 if (mop->mo_flags & MO_EMPTY) { 2362 if ((flags & VFS_CREATEOPT) == 0) 2363 continue; 2364 sp = kmem_alloc(strlen(opt) + 1, KM_SLEEP); 2365 (void) strcpy(sp, opt); 2366 mop->mo_name = sp; 2367 if (arg != NULL) 2368 mop->mo_flags = MO_HASVALUE; 2369 else 2370 mop->mo_flags = 0; 2371 } else if (strcmp(opt, mop->mo_name)) { 2372 continue; 2373 } 2374 if ((mop->mo_flags & MO_IGNORE) && (flags & VFS_NOFORCEOPT)) 2375 break; 2376 if (arg != NULL && (mop->mo_flags & MO_HASVALUE) != 0) { 2377 sp = kmem_alloc(strlen(arg) + 1, KM_SLEEP); 2378 (void) strcpy(sp, arg); 2379 } else { 2380 sp = NULL; 2381 } 2382 if (mop->mo_arg != NULL) 2383 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1); 2384 mop->mo_arg = sp; 2385 if (flags & VFS_DISPLAY) 2386 mop->mo_flags &= ~MO_NODISPLAY; 2387 if (flags & VFS_NODISPLAY) 2388 mop->mo_flags |= MO_NODISPLAY; 2389 mop->mo_flags |= MO_SET; 2390 if (mop->mo_cancel != NULL) { 2391 char **cp; 2392 2393 for (cp = mop->mo_cancel; *cp != NULL; cp++) 2394 vfs_clearmntopt_nolock(mops, *cp, 0); 2395 } 2396 if (update_mnttab) 2397 vfs_mnttab_modtimeupd(); 2398 break; 2399 } 2400 } 2401 2402 void 2403 vfs_setmntopt(struct vfs *vfsp, const char *opt, const char *arg, int flags) 2404 { 2405 int gotlock = 0; 2406 2407 if (VFS_ON_LIST(vfsp)) { 2408 gotlock = 1; 2409 vfs_list_lock(); 2410 } 2411 vfs_setmntopt_nolock(&vfsp->vfs_mntopts, opt, arg, flags, gotlock); 2412 if (gotlock) 2413 vfs_list_unlock(); 2414 } 2415 2416 2417 /* 2418 * Add a "tag" option to a mounted file system's options list. 2419 * 2420 * Note: caller is responsible for locking the vfs list, if needed, 2421 * to protect mops. 2422 */ 2423 static mntopt_t * 2424 vfs_addtag(mntopts_t *mops, const char *tag) 2425 { 2426 uint_t count; 2427 mntopt_t *mop, *motbl; 2428 2429 count = mops->mo_count + 1; 2430 motbl = kmem_zalloc(count * sizeof (mntopt_t), KM_SLEEP); 2431 if (mops->mo_count) { 2432 size_t len = (count - 1) * sizeof (mntopt_t); 2433 2434 bcopy(mops->mo_list, motbl, len); 2435 kmem_free(mops->mo_list, len); 2436 } 2437 mops->mo_count = count; 2438 mops->mo_list = motbl; 2439 mop = &motbl[count - 1]; 2440 mop->mo_flags = MO_TAG; 2441 mop->mo_name = kmem_alloc(strlen(tag) + 1, KM_SLEEP); 2442 (void) strcpy(mop->mo_name, tag); 2443 return (mop); 2444 } 2445 2446 /* 2447 * Allow users to set arbitrary "tags" in a vfs's mount options. 2448 * Broader use within the kernel is discouraged. 2449 */ 2450 int 2451 vfs_settag(uint_t major, uint_t minor, const char *mntpt, const char *tag, 2452 cred_t *cr) 2453 { 2454 vfs_t *vfsp; 2455 mntopts_t *mops; 2456 mntopt_t *mop; 2457 int found = 0; 2458 dev_t dev = makedevice(major, minor); 2459 int err = 0; 2460 char *buf = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP); 2461 2462 /* 2463 * Find the desired mounted file system 2464 */ 2465 vfs_list_lock(); 2466 vfsp = rootvfs; 2467 do { 2468 if (vfsp->vfs_dev == dev && 2469 strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) { 2470 found = 1; 2471 break; 2472 } 2473 vfsp = vfsp->vfs_next; 2474 } while (vfsp != rootvfs); 2475 2476 if (!found) { 2477 err = EINVAL; 2478 goto out; 2479 } 2480 err = secpolicy_fs_config(cr, vfsp); 2481 if (err != 0) 2482 goto out; 2483 2484 mops = &vfsp->vfs_mntopts; 2485 /* 2486 * Add tag if it doesn't already exist 2487 */ 2488 if ((mop = vfs_hasopt(mops, tag)) == NULL) { 2489 int len; 2490 2491 (void) vfs_buildoptionstr(mops, buf, MAX_MNTOPT_STR); 2492 len = strlen(buf); 2493 if (len + strlen(tag) + 2 > MAX_MNTOPT_STR) { 2494 err = ENAMETOOLONG; 2495 goto out; 2496 } 2497 mop = vfs_addtag(mops, tag); 2498 } 2499 if ((mop->mo_flags & MO_TAG) == 0) { 2500 err = EINVAL; 2501 goto out; 2502 } 2503 vfs_setmntopt_nolock(mops, tag, NULL, 0, 1); 2504 out: 2505 vfs_list_unlock(); 2506 kmem_free(buf, MAX_MNTOPT_STR); 2507 return (err); 2508 } 2509 2510 /* 2511 * Allow users to remove arbitrary "tags" in a vfs's mount options. 2512 * Broader use within the kernel is discouraged. 2513 */ 2514 int 2515 vfs_clrtag(uint_t major, uint_t minor, const char *mntpt, const char *tag, 2516 cred_t *cr) 2517 { 2518 vfs_t *vfsp; 2519 mntopt_t *mop; 2520 int found = 0; 2521 dev_t dev = makedevice(major, minor); 2522 int err = 0; 2523 2524 /* 2525 * Find the desired mounted file system 2526 */ 2527 vfs_list_lock(); 2528 vfsp = rootvfs; 2529 do { 2530 if (vfsp->vfs_dev == dev && 2531 strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) { 2532 found = 1; 2533 break; 2534 } 2535 vfsp = vfsp->vfs_next; 2536 } while (vfsp != rootvfs); 2537 2538 if (!found) { 2539 err = EINVAL; 2540 goto out; 2541 } 2542 err = secpolicy_fs_config(cr, vfsp); 2543 if (err != 0) 2544 goto out; 2545 2546 if ((mop = vfs_hasopt(&vfsp->vfs_mntopts, tag)) == NULL) { 2547 err = EINVAL; 2548 goto out; 2549 } 2550 if ((mop->mo_flags & MO_TAG) == 0) { 2551 err = EINVAL; 2552 goto out; 2553 } 2554 vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, tag, 1); 2555 out: 2556 vfs_list_unlock(); 2557 return (err); 2558 } 2559 2560 /* 2561 * Function to parse an option string and fill in a mount options table. 2562 * Unknown options are silently ignored. The input option string is modified 2563 * by replacing separators with nulls. If the create flag is set, options 2564 * not found in the table are just added on the fly. The table must have 2565 * an option slot marked MO_EMPTY to add an option on the fly. 2566 * 2567 * This function is *not* for general use by filesystems. 2568 * 2569 * Note: caller is responsible for locking the vfs list, if needed, 2570 * to protect mops.. 2571 */ 2572 void 2573 vfs_parsemntopts(mntopts_t *mops, char *osp, int create) 2574 { 2575 char *s = osp, *p, *nextop, *valp, *cp, *ep; 2576 int setflg = VFS_NOFORCEOPT; 2577 2578 if (osp == NULL) 2579 return; 2580 while (*s != '\0') { 2581 p = strchr(s, ','); /* find next option */ 2582 if (p == NULL) { 2583 cp = NULL; 2584 p = s + strlen(s); 2585 } else { 2586 cp = p; /* save location of comma */ 2587 *p++ = '\0'; /* mark end and point to next option */ 2588 } 2589 nextop = p; 2590 p = strchr(s, '='); /* look for value */ 2591 if (p == NULL) { 2592 valp = NULL; /* no value supplied */ 2593 } else { 2594 ep = p; /* save location of equals */ 2595 *p++ = '\0'; /* end option and point to value */ 2596 valp = p; 2597 } 2598 /* 2599 * set option into options table 2600 */ 2601 if (create) 2602 setflg |= VFS_CREATEOPT; 2603 vfs_setmntopt_nolock(mops, s, valp, setflg, 0); 2604 if (cp != NULL) 2605 *cp = ','; /* restore the comma */ 2606 if (valp != NULL) 2607 *ep = '='; /* restore the equals */ 2608 s = nextop; 2609 } 2610 } 2611 2612 /* 2613 * Function to inquire if an option exists in a mount options table. 2614 * Returns a pointer to the option if it exists, else NULL. 2615 * 2616 * This function is *not* for general use by filesystems. 2617 * 2618 * Note: caller is responsible for locking the vfs list, if needed, 2619 * to protect mops. 2620 */ 2621 struct mntopt * 2622 vfs_hasopt(const mntopts_t *mops, const char *opt) 2623 { 2624 struct mntopt *mop; 2625 uint_t i, count; 2626 2627 count = mops->mo_count; 2628 for (i = 0; i < count; i++) { 2629 mop = &mops->mo_list[i]; 2630 2631 if (mop->mo_flags & MO_EMPTY) 2632 continue; 2633 if (strcmp(opt, mop->mo_name) == 0) 2634 return (mop); 2635 } 2636 return (NULL); 2637 } 2638 2639 /* 2640 * Function to inquire if an option is set in a mount options table. 2641 * Returns non-zero if set and fills in the arg pointer with a pointer to 2642 * the argument string or NULL if there is no argument string. 2643 */ 2644 static int 2645 vfs_optionisset_nolock(const mntopts_t *mops, const char *opt, char **argp) 2646 { 2647 struct mntopt *mop; 2648 uint_t i, count; 2649 2650 count = mops->mo_count; 2651 for (i = 0; i < count; i++) { 2652 mop = &mops->mo_list[i]; 2653 2654 if (mop->mo_flags & MO_EMPTY) 2655 continue; 2656 if (strcmp(opt, mop->mo_name)) 2657 continue; 2658 if ((mop->mo_flags & MO_SET) == 0) 2659 return (0); 2660 if (argp != NULL && (mop->mo_flags & MO_HASVALUE) != 0) 2661 *argp = mop->mo_arg; 2662 return (1); 2663 } 2664 return (0); 2665 } 2666 2667 2668 int 2669 vfs_optionisset(const struct vfs *vfsp, const char *opt, char **argp) 2670 { 2671 int ret; 2672 2673 vfs_list_read_lock(); 2674 ret = vfs_optionisset_nolock(&vfsp->vfs_mntopts, opt, argp); 2675 vfs_list_unlock(); 2676 return (ret); 2677 } 2678 2679 2680 /* 2681 * Construct a comma separated string of the options set in the given 2682 * mount table, return the string in the given buffer. Return non-zero if 2683 * the buffer would overflow. 2684 * 2685 * This function is *not* for general use by filesystems. 2686 * 2687 * Note: caller is responsible for locking the vfs list, if needed, 2688 * to protect mp. 2689 */ 2690 int 2691 vfs_buildoptionstr(const mntopts_t *mp, char *buf, int len) 2692 { 2693 char *cp; 2694 uint_t i; 2695 2696 buf[0] = '\0'; 2697 cp = buf; 2698 for (i = 0; i < mp->mo_count; i++) { 2699 struct mntopt *mop; 2700 2701 mop = &mp->mo_list[i]; 2702 if (mop->mo_flags & MO_SET) { 2703 int optlen, comma = 0; 2704 2705 if (buf[0] != '\0') 2706 comma = 1; 2707 optlen = strlen(mop->mo_name); 2708 if (strlen(buf) + comma + optlen + 1 > len) 2709 goto err; 2710 if (comma) 2711 *cp++ = ','; 2712 (void) strcpy(cp, mop->mo_name); 2713 cp += optlen; 2714 /* 2715 * Append option value if there is one 2716 */ 2717 if (mop->mo_arg != NULL) { 2718 int arglen; 2719 2720 arglen = strlen(mop->mo_arg); 2721 if (strlen(buf) + arglen + 2 > len) 2722 goto err; 2723 *cp++ = '='; 2724 (void) strcpy(cp, mop->mo_arg); 2725 cp += arglen; 2726 } 2727 } 2728 } 2729 return (0); 2730 err: 2731 return (EOVERFLOW); 2732 } 2733 2734 static void 2735 vfs_freecancelopt(char **moc) 2736 { 2737 if (moc != NULL) { 2738 int ccnt = 0; 2739 char **cp; 2740 2741 for (cp = moc; *cp != NULL; cp++) { 2742 kmem_free(*cp, strlen(*cp) + 1); 2743 ccnt++; 2744 } 2745 kmem_free(moc, (ccnt + 1) * sizeof (char *)); 2746 } 2747 } 2748 2749 static void 2750 vfs_freeopt(mntopt_t *mop) 2751 { 2752 if (mop->mo_name != NULL) 2753 kmem_free(mop->mo_name, strlen(mop->mo_name) + 1); 2754 2755 vfs_freecancelopt(mop->mo_cancel); 2756 2757 if (mop->mo_arg != NULL) 2758 kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1); 2759 } 2760 2761 /* 2762 * Free a mount options table 2763 * 2764 * This function is *not* for general use by filesystems. 2765 * 2766 * Note: caller is responsible for locking the vfs list, if needed, 2767 * to protect mp. 2768 */ 2769 void 2770 vfs_freeopttbl(mntopts_t *mp) 2771 { 2772 uint_t i, count; 2773 2774 count = mp->mo_count; 2775 for (i = 0; i < count; i++) { 2776 vfs_freeopt(&mp->mo_list[i]); 2777 } 2778 if (count) { 2779 kmem_free(mp->mo_list, sizeof (mntopt_t) * count); 2780 mp->mo_count = 0; 2781 mp->mo_list = NULL; 2782 } 2783 } 2784 2785 2786 /* ARGSUSED */ 2787 static int 2788 vfs_mntdummyread(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred, 2789 caller_context_t *ct) 2790 { 2791 return (0); 2792 } 2793 2794 /* ARGSUSED */ 2795 static int 2796 vfs_mntdummywrite(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred, 2797 caller_context_t *ct) 2798 { 2799 return (0); 2800 } 2801 2802 /* 2803 * The dummy vnode is currently used only by file events notification 2804 * module which is just interested in the timestamps. 2805 */ 2806 /* ARGSUSED */ 2807 static int 2808 vfs_mntdummygetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 2809 caller_context_t *ct) 2810 { 2811 bzero(vap, sizeof (vattr_t)); 2812 vap->va_type = VREG; 2813 vap->va_nlink = 1; 2814 vap->va_ctime = vfs_mnttab_ctime; 2815 /* 2816 * it is ok to just copy mtime as the time will be monotonically 2817 * increasing. 2818 */ 2819 vap->va_mtime = vfs_mnttab_mtime; 2820 vap->va_atime = vap->va_mtime; 2821 return (0); 2822 } 2823 2824 static void 2825 vfs_mnttabvp_setup(void) 2826 { 2827 vnode_t *tvp; 2828 vnodeops_t *vfs_mntdummyvnops; 2829 const fs_operation_def_t mnt_dummyvnodeops_template[] = { 2830 VOPNAME_READ, { .vop_read = vfs_mntdummyread }, 2831 VOPNAME_WRITE, { .vop_write = vfs_mntdummywrite }, 2832 VOPNAME_GETATTR, { .vop_getattr = vfs_mntdummygetattr }, 2833 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 2834 NULL, NULL 2835 }; 2836 2837 if (vn_make_ops("mnttab", mnt_dummyvnodeops_template, 2838 &vfs_mntdummyvnops) != 0) { 2839 cmn_err(CE_WARN, "vfs_mnttabvp_setup: vn_make_ops failed"); 2840 /* Shouldn't happen, but not bad enough to panic */ 2841 return; 2842 } 2843 2844 /* 2845 * A global dummy vnode is allocated to represent mntfs files. 2846 * The mntfs file (/etc/mnttab) can be monitored for file events 2847 * and receive an event when mnttab changes. Dummy VOP calls 2848 * will be made on this vnode. The file events notification module 2849 * intercepts this vnode and delivers relevant events. 2850 */ 2851 tvp = vn_alloc(KM_SLEEP); 2852 tvp->v_flag = VNOMOUNT|VNOMAP|VNOSWAP|VNOCACHE; 2853 vn_setops(tvp, vfs_mntdummyvnops); 2854 tvp->v_type = VREG; 2855 /* 2856 * The mnt dummy ops do not reference v_data. 2857 * No other module intercepting this vnode should either. 2858 * Just set it to point to itself. 2859 */ 2860 tvp->v_data = (caddr_t)tvp; 2861 tvp->v_vfsp = rootvfs; 2862 vfs_mntdummyvp = tvp; 2863 } 2864 2865 /* 2866 * performs fake read/write ops 2867 */ 2868 static void 2869 vfs_mnttab_rwop(int rw) 2870 { 2871 struct uio uio; 2872 struct iovec iov; 2873 char buf[1]; 2874 2875 if (vfs_mntdummyvp == NULL) 2876 return; 2877 2878 bzero(&uio, sizeof (uio)); 2879 bzero(&iov, sizeof (iov)); 2880 iov.iov_base = buf; 2881 iov.iov_len = 0; 2882 uio.uio_iov = &iov; 2883 uio.uio_iovcnt = 1; 2884 uio.uio_loffset = 0; 2885 uio.uio_segflg = UIO_SYSSPACE; 2886 uio.uio_resid = 0; 2887 if (rw) { 2888 (void) VOP_WRITE(vfs_mntdummyvp, &uio, 0, kcred, NULL); 2889 } else { 2890 (void) VOP_READ(vfs_mntdummyvp, &uio, 0, kcred, NULL); 2891 } 2892 } 2893 2894 /* 2895 * Generate a write operation. 2896 */ 2897 void 2898 vfs_mnttab_writeop(void) 2899 { 2900 vfs_mnttab_rwop(1); 2901 } 2902 2903 /* 2904 * Generate a read operation. 2905 */ 2906 void 2907 vfs_mnttab_readop(void) 2908 { 2909 vfs_mnttab_rwop(0); 2910 } 2911 2912 /* 2913 * Free any mnttab information recorded in the vfs struct. 2914 * The vfs must not be on the vfs list. 2915 */ 2916 static void 2917 vfs_freemnttab(struct vfs *vfsp) 2918 { 2919 ASSERT(!VFS_ON_LIST(vfsp)); 2920 2921 /* 2922 * Free device and mount point information 2923 */ 2924 if (vfsp->vfs_mntpt != NULL) { 2925 refstr_rele(vfsp->vfs_mntpt); 2926 vfsp->vfs_mntpt = NULL; 2927 } 2928 if (vfsp->vfs_resource != NULL) { 2929 refstr_rele(vfsp->vfs_resource); 2930 vfsp->vfs_resource = NULL; 2931 } 2932 /* 2933 * Now free mount options information 2934 */ 2935 vfs_freeopttbl(&vfsp->vfs_mntopts); 2936 } 2937 2938 /* 2939 * Return the last mnttab modification time 2940 */ 2941 void 2942 vfs_mnttab_modtime(timespec_t *ts) 2943 { 2944 ASSERT(RW_LOCK_HELD(&vfslist)); 2945 *ts = vfs_mnttab_mtime; 2946 } 2947 2948 /* 2949 * See if mnttab is changed 2950 */ 2951 void 2952 vfs_mnttab_poll(timespec_t *old, struct pollhead **phpp) 2953 { 2954 int changed; 2955 2956 *phpp = (struct pollhead *)NULL; 2957 2958 /* 2959 * Note: don't grab vfs list lock before accessing vfs_mnttab_mtime. 2960 * Can lead to deadlock against vfs_mnttab_modtimeupd(). It is safe 2961 * to not grab the vfs list lock because tv_sec is monotonically 2962 * increasing. 2963 */ 2964 2965 changed = (old->tv_nsec != vfs_mnttab_mtime.tv_nsec) || 2966 (old->tv_sec != vfs_mnttab_mtime.tv_sec); 2967 if (!changed) { 2968 *phpp = &vfs_pollhd; 2969 } 2970 } 2971 2972 /* Provide a unique and monotonically-increasing timestamp. */ 2973 void 2974 vfs_mono_time(timespec_t *ts) 2975 { 2976 static volatile hrtime_t hrt; /* The saved time. */ 2977 hrtime_t newhrt, oldhrt; /* For effecting the CAS. */ 2978 timespec_t newts; 2979 2980 /* 2981 * Try gethrestime() first, but be prepared to fabricate a sensible 2982 * answer at the first sign of any trouble. 2983 */ 2984 gethrestime(&newts); 2985 newhrt = ts2hrt(&newts); 2986 for (;;) { 2987 oldhrt = hrt; 2988 if (newhrt <= hrt) 2989 newhrt = hrt + 1; 2990 if (cas64((uint64_t *)&hrt, oldhrt, newhrt) == oldhrt) 2991 break; 2992 } 2993 hrt2ts(newhrt, ts); 2994 } 2995 2996 /* 2997 * Update the mnttab modification time and wake up any waiters for 2998 * mnttab changes 2999 */ 3000 void 3001 vfs_mnttab_modtimeupd() 3002 { 3003 hrtime_t oldhrt, newhrt; 3004 3005 ASSERT(RW_WRITE_HELD(&vfslist)); 3006 oldhrt = ts2hrt(&vfs_mnttab_mtime); 3007 gethrestime(&vfs_mnttab_mtime); 3008 newhrt = ts2hrt(&vfs_mnttab_mtime); 3009 if (oldhrt == (hrtime_t)0) 3010 vfs_mnttab_ctime = vfs_mnttab_mtime; 3011 /* 3012 * Attempt to provide unique mtime (like uniqtime but not). 3013 */ 3014 if (newhrt == oldhrt) { 3015 newhrt++; 3016 hrt2ts(newhrt, &vfs_mnttab_mtime); 3017 } 3018 pollwakeup(&vfs_pollhd, (short)POLLRDBAND); 3019 vfs_mnttab_writeop(); 3020 } 3021 3022 int 3023 dounmount(struct vfs *vfsp, int flag, cred_t *cr) 3024 { 3025 vnode_t *coveredvp; 3026 int error; 3027 extern void teardown_vopstats(vfs_t *); 3028 3029 /* 3030 * Get covered vnode. This will be NULL if the vfs is not linked 3031 * into the file system name space (i.e., domount() with MNT_NOSPICE). 3032 */ 3033 coveredvp = vfsp->vfs_vnodecovered; 3034 ASSERT(coveredvp == NULL || vn_vfswlock_held(coveredvp)); 3035 3036 /* 3037 * Purge all dnlc entries for this vfs. 3038 */ 3039 (void) dnlc_purge_vfsp(vfsp, 0); 3040 3041 /* For forcible umount, skip VFS_SYNC() since it may hang */ 3042 if ((flag & MS_FORCE) == 0) 3043 (void) VFS_SYNC(vfsp, 0, cr); 3044 3045 /* 3046 * Lock the vfs to maintain fs status quo during unmount. This 3047 * has to be done after the sync because ufs_update tries to acquire 3048 * the vfs_reflock. 3049 */ 3050 vfs_lock_wait(vfsp); 3051 3052 if (error = VFS_UNMOUNT(vfsp, flag, cr)) { 3053 vfs_unlock(vfsp); 3054 if (coveredvp != NULL) 3055 vn_vfsunlock(coveredvp); 3056 } else if (coveredvp != NULL) { 3057 teardown_vopstats(vfsp); 3058 /* 3059 * vfs_remove() will do a VN_RELE(vfsp->vfs_vnodecovered) 3060 * when it frees vfsp so we do a VN_HOLD() so we can 3061 * continue to use coveredvp afterwards. 3062 */ 3063 VN_HOLD(coveredvp); 3064 vfs_remove(vfsp); 3065 vn_vfsunlock(coveredvp); 3066 VN_RELE(coveredvp); 3067 } else { 3068 teardown_vopstats(vfsp); 3069 /* 3070 * Release the reference to vfs that is not linked 3071 * into the name space. 3072 */ 3073 vfs_unlock(vfsp); 3074 VFS_RELE(vfsp); 3075 } 3076 return (error); 3077 } 3078 3079 3080 /* 3081 * Vfs_unmountall() is called by uadmin() to unmount all 3082 * mounted file systems (except the root file system) during shutdown. 3083 * It follows the existing locking protocol when traversing the vfs list 3084 * to sync and unmount vfses. Even though there should be no 3085 * other thread running while the system is shutting down, it is prudent 3086 * to still follow the locking protocol. 3087 */ 3088 void 3089 vfs_unmountall(void) 3090 { 3091 struct vfs *vfsp; 3092 struct vfs *prev_vfsp = NULL; 3093 int error; 3094 3095 /* 3096 * Toss all dnlc entries now so that the per-vfs sync 3097 * and unmount operations don't have to slog through 3098 * a bunch of uninteresting vnodes over and over again. 3099 */ 3100 dnlc_purge(); 3101 3102 vfs_list_lock(); 3103 for (vfsp = rootvfs->vfs_prev; vfsp != rootvfs; vfsp = prev_vfsp) { 3104 prev_vfsp = vfsp->vfs_prev; 3105 3106 if (vfs_lock(vfsp) != 0) 3107 continue; 3108 error = vn_vfswlock(vfsp->vfs_vnodecovered); 3109 vfs_unlock(vfsp); 3110 if (error) 3111 continue; 3112 3113 vfs_list_unlock(); 3114 3115 (void) VFS_SYNC(vfsp, SYNC_CLOSE, CRED()); 3116 (void) dounmount(vfsp, 0, CRED()); 3117 3118 /* 3119 * Since we dropped the vfslist lock above we must 3120 * verify that next_vfsp still exists, else start over. 3121 */ 3122 vfs_list_lock(); 3123 for (vfsp = rootvfs->vfs_prev; 3124 vfsp != rootvfs; vfsp = vfsp->vfs_prev) 3125 if (vfsp == prev_vfsp) 3126 break; 3127 if (vfsp == rootvfs && prev_vfsp != rootvfs) 3128 prev_vfsp = rootvfs->vfs_prev; 3129 } 3130 vfs_list_unlock(); 3131 } 3132 3133 /* 3134 * Called to add an entry to the end of the vfs mount in progress list 3135 */ 3136 void 3137 vfs_addmip(dev_t dev, struct vfs *vfsp) 3138 { 3139 struct ipmnt *mipp; 3140 3141 mipp = (struct ipmnt *)kmem_alloc(sizeof (struct ipmnt), KM_SLEEP); 3142 mipp->mip_next = NULL; 3143 mipp->mip_dev = dev; 3144 mipp->mip_vfsp = vfsp; 3145 mutex_enter(&vfs_miplist_mutex); 3146 if (vfs_miplist_end != NULL) 3147 vfs_miplist_end->mip_next = mipp; 3148 else 3149 vfs_miplist = mipp; 3150 vfs_miplist_end = mipp; 3151 mutex_exit(&vfs_miplist_mutex); 3152 } 3153 3154 /* 3155 * Called to remove an entry from the mount in progress list 3156 * Either because the mount completed or it failed. 3157 */ 3158 void 3159 vfs_delmip(struct vfs *vfsp) 3160 { 3161 struct ipmnt *mipp, *mipprev; 3162 3163 mutex_enter(&vfs_miplist_mutex); 3164 mipprev = NULL; 3165 for (mipp = vfs_miplist; 3166 mipp && mipp->mip_vfsp != vfsp; mipp = mipp->mip_next) { 3167 mipprev = mipp; 3168 } 3169 if (mipp == NULL) 3170 return; /* shouldn't happen */ 3171 if (mipp == vfs_miplist_end) 3172 vfs_miplist_end = mipprev; 3173 if (mipprev == NULL) 3174 vfs_miplist = mipp->mip_next; 3175 else 3176 mipprev->mip_next = mipp->mip_next; 3177 mutex_exit(&vfs_miplist_mutex); 3178 kmem_free(mipp, sizeof (struct ipmnt)); 3179 } 3180 3181 /* 3182 * vfs_add is called by a specific filesystem's mount routine to add 3183 * the new vfs into the vfs list/hash and to cover the mounted-on vnode. 3184 * The vfs should already have been locked by the caller. 3185 * 3186 * coveredvp is NULL if this is the root. 3187 */ 3188 void 3189 vfs_add(vnode_t *coveredvp, struct vfs *vfsp, int mflag) 3190 { 3191 int newflag; 3192 3193 ASSERT(vfs_lock_held(vfsp)); 3194 VFS_HOLD(vfsp); 3195 newflag = vfsp->vfs_flag; 3196 if (mflag & MS_RDONLY) 3197 newflag |= VFS_RDONLY; 3198 else 3199 newflag &= ~VFS_RDONLY; 3200 if (mflag & MS_NOSUID) 3201 newflag |= (VFS_NOSETUID|VFS_NODEVICES); 3202 else 3203 newflag &= ~(VFS_NOSETUID|VFS_NODEVICES); 3204 if (mflag & MS_NOMNTTAB) 3205 newflag |= VFS_NOMNTTAB; 3206 else 3207 newflag &= ~VFS_NOMNTTAB; 3208 3209 if (coveredvp != NULL) { 3210 ASSERT(vn_vfswlock_held(coveredvp)); 3211 coveredvp->v_vfsmountedhere = vfsp; 3212 VN_HOLD(coveredvp); 3213 } 3214 vfsp->vfs_vnodecovered = coveredvp; 3215 vfsp->vfs_flag = newflag; 3216 3217 vfs_list_add(vfsp); 3218 } 3219 3220 /* 3221 * Remove a vfs from the vfs list, null out the pointer from the 3222 * covered vnode to the vfs (v_vfsmountedhere), and null out the pointer 3223 * from the vfs to the covered vnode (vfs_vnodecovered). Release the 3224 * reference to the vfs and to the covered vnode. 3225 * 3226 * Called from dounmount after it's confirmed with the file system 3227 * that the unmount is legal. 3228 */ 3229 void 3230 vfs_remove(struct vfs *vfsp) 3231 { 3232 vnode_t *vp; 3233 3234 ASSERT(vfs_lock_held(vfsp)); 3235 3236 /* 3237 * Can't unmount root. Should never happen because fs will 3238 * be busy. 3239 */ 3240 if (vfsp == rootvfs) 3241 panic("vfs_remove: unmounting root"); 3242 3243 vfs_list_remove(vfsp); 3244 3245 /* 3246 * Unhook from the file system name space. 3247 */ 3248 vp = vfsp->vfs_vnodecovered; 3249 ASSERT(vn_vfswlock_held(vp)); 3250 vp->v_vfsmountedhere = NULL; 3251 vfsp->vfs_vnodecovered = NULL; 3252 VN_RELE(vp); 3253 3254 /* 3255 * Release lock and wakeup anybody waiting. 3256 */ 3257 vfs_unlock(vfsp); 3258 VFS_RELE(vfsp); 3259 } 3260 3261 /* 3262 * Lock a filesystem to prevent access to it while mounting, 3263 * unmounting and syncing. Return EBUSY immediately if lock 3264 * can't be acquired. 3265 */ 3266 int 3267 vfs_lock(vfs_t *vfsp) 3268 { 3269 vn_vfslocks_entry_t *vpvfsentry; 3270 3271 vpvfsentry = vn_vfslocks_getlock(vfsp); 3272 if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER)) 3273 return (0); 3274 3275 vn_vfslocks_rele(vpvfsentry); 3276 return (EBUSY); 3277 } 3278 3279 int 3280 vfs_rlock(vfs_t *vfsp) 3281 { 3282 vn_vfslocks_entry_t *vpvfsentry; 3283 3284 vpvfsentry = vn_vfslocks_getlock(vfsp); 3285 3286 if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER)) 3287 return (0); 3288 3289 vn_vfslocks_rele(vpvfsentry); 3290 return (EBUSY); 3291 } 3292 3293 void 3294 vfs_lock_wait(vfs_t *vfsp) 3295 { 3296 vn_vfslocks_entry_t *vpvfsentry; 3297 3298 vpvfsentry = vn_vfslocks_getlock(vfsp); 3299 rwst_enter(&vpvfsentry->ve_lock, RW_WRITER); 3300 } 3301 3302 void 3303 vfs_rlock_wait(vfs_t *vfsp) 3304 { 3305 vn_vfslocks_entry_t *vpvfsentry; 3306 3307 vpvfsentry = vn_vfslocks_getlock(vfsp); 3308 rwst_enter(&vpvfsentry->ve_lock, RW_READER); 3309 } 3310 3311 /* 3312 * Unlock a locked filesystem. 3313 */ 3314 void 3315 vfs_unlock(vfs_t *vfsp) 3316 { 3317 vn_vfslocks_entry_t *vpvfsentry; 3318 3319 /* 3320 * vfs_unlock will mimic sema_v behaviour to fix 4748018. 3321 * And these changes should remain for the patch changes as it is. 3322 */ 3323 if (panicstr) 3324 return; 3325 3326 /* 3327 * ve_refcount needs to be dropped twice here. 3328 * 1. To release refernce after a call to vfs_locks_getlock() 3329 * 2. To release the reference from the locking routines like 3330 * vfs_rlock_wait/vfs_wlock_wait/vfs_wlock etc,. 3331 */ 3332 3333 vpvfsentry = vn_vfslocks_getlock(vfsp); 3334 vn_vfslocks_rele(vpvfsentry); 3335 3336 rwst_exit(&vpvfsentry->ve_lock); 3337 vn_vfslocks_rele(vpvfsentry); 3338 } 3339 3340 /* 3341 * Utility routine that allows a filesystem to construct its 3342 * fsid in "the usual way" - by munging some underlying dev_t and 3343 * the filesystem type number into the 64-bit fsid. Note that 3344 * this implicitly relies on dev_t persistence to make filesystem 3345 * id's persistent. 3346 * 3347 * There's nothing to prevent an individual fs from constructing its 3348 * fsid in a different way, and indeed they should. 3349 * 3350 * Since we want fsids to be 32-bit quantities (so that they can be 3351 * exported identically by either 32-bit or 64-bit APIs, as well as 3352 * the fact that fsid's are "known" to NFS), we compress the device 3353 * number given down to 32-bits, and panic if that isn't possible. 3354 */ 3355 void 3356 vfs_make_fsid(fsid_t *fsi, dev_t dev, int val) 3357 { 3358 if (!cmpldev((dev32_t *)&fsi->val[0], dev)) 3359 panic("device number too big for fsid!"); 3360 fsi->val[1] = val; 3361 } 3362 3363 int 3364 vfs_lock_held(vfs_t *vfsp) 3365 { 3366 int held; 3367 vn_vfslocks_entry_t *vpvfsentry; 3368 3369 /* 3370 * vfs_lock_held will mimic sema_held behaviour 3371 * if panicstr is set. And these changes should remain 3372 * for the patch changes as it is. 3373 */ 3374 if (panicstr) 3375 return (1); 3376 3377 vpvfsentry = vn_vfslocks_getlock(vfsp); 3378 held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER); 3379 3380 vn_vfslocks_rele(vpvfsentry); 3381 return (held); 3382 } 3383 3384 struct _kthread * 3385 vfs_lock_owner(vfs_t *vfsp) 3386 { 3387 struct _kthread *owner; 3388 vn_vfslocks_entry_t *vpvfsentry; 3389 3390 /* 3391 * vfs_wlock_held will mimic sema_held behaviour 3392 * if panicstr is set. And these changes should remain 3393 * for the patch changes as it is. 3394 */ 3395 if (panicstr) 3396 return (NULL); 3397 3398 vpvfsentry = vn_vfslocks_getlock(vfsp); 3399 owner = rwst_owner(&vpvfsentry->ve_lock); 3400 3401 vn_vfslocks_rele(vpvfsentry); 3402 return (owner); 3403 } 3404 3405 /* 3406 * vfs list locking. 3407 * 3408 * Rather than manipulate the vfslist lock directly, we abstract into lock 3409 * and unlock routines to allow the locking implementation to be changed for 3410 * clustering. 3411 * 3412 * Whenever the vfs list is modified through its hash links, the overall list 3413 * lock must be obtained before locking the relevant hash bucket. But to see 3414 * whether a given vfs is on the list, it suffices to obtain the lock for the 3415 * hash bucket without getting the overall list lock. (See getvfs() below.) 3416 */ 3417 3418 void 3419 vfs_list_lock() 3420 { 3421 rw_enter(&vfslist, RW_WRITER); 3422 } 3423 3424 void 3425 vfs_list_read_lock() 3426 { 3427 rw_enter(&vfslist, RW_READER); 3428 } 3429 3430 void 3431 vfs_list_unlock() 3432 { 3433 rw_exit(&vfslist); 3434 } 3435 3436 /* 3437 * Low level worker routines for adding entries to and removing entries from 3438 * the vfs list. 3439 */ 3440 3441 static void 3442 vfs_hash_add(struct vfs *vfsp, int insert_at_head) 3443 { 3444 int vhno; 3445 struct vfs **hp; 3446 dev_t dev; 3447 3448 ASSERT(RW_WRITE_HELD(&vfslist)); 3449 3450 dev = expldev(vfsp->vfs_fsid.val[0]); 3451 vhno = VFSHASH(getmajor(dev), getminor(dev)); 3452 3453 mutex_enter(&rvfs_list[vhno].rvfs_lock); 3454 3455 /* 3456 * Link into the hash table, inserting it at the end, so that LOFS 3457 * with the same fsid as UFS (or other) file systems will not hide the 3458 * UFS. 3459 */ 3460 if (insert_at_head) { 3461 vfsp->vfs_hash = rvfs_list[vhno].rvfs_head; 3462 rvfs_list[vhno].rvfs_head = vfsp; 3463 } else { 3464 for (hp = &rvfs_list[vhno].rvfs_head; *hp != NULL; 3465 hp = &(*hp)->vfs_hash) 3466 continue; 3467 /* 3468 * hp now contains the address of the pointer to update 3469 * to effect the insertion. 3470 */ 3471 vfsp->vfs_hash = NULL; 3472 *hp = vfsp; 3473 } 3474 3475 rvfs_list[vhno].rvfs_len++; 3476 mutex_exit(&rvfs_list[vhno].rvfs_lock); 3477 } 3478 3479 3480 static void 3481 vfs_hash_remove(struct vfs *vfsp) 3482 { 3483 int vhno; 3484 struct vfs *tvfsp; 3485 dev_t dev; 3486 3487 ASSERT(RW_WRITE_HELD(&vfslist)); 3488 3489 dev = expldev(vfsp->vfs_fsid.val[0]); 3490 vhno = VFSHASH(getmajor(dev), getminor(dev)); 3491 3492 mutex_enter(&rvfs_list[vhno].rvfs_lock); 3493 3494 /* 3495 * Remove from hash. 3496 */ 3497 if (rvfs_list[vhno].rvfs_head == vfsp) { 3498 rvfs_list[vhno].rvfs_head = vfsp->vfs_hash; 3499 rvfs_list[vhno].rvfs_len--; 3500 goto foundit; 3501 } 3502 for (tvfsp = rvfs_list[vhno].rvfs_head; tvfsp != NULL; 3503 tvfsp = tvfsp->vfs_hash) { 3504 if (tvfsp->vfs_hash == vfsp) { 3505 tvfsp->vfs_hash = vfsp->vfs_hash; 3506 rvfs_list[vhno].rvfs_len--; 3507 goto foundit; 3508 } 3509 } 3510 cmn_err(CE_WARN, "vfs_list_remove: vfs not found in hash"); 3511 3512 foundit: 3513 3514 mutex_exit(&rvfs_list[vhno].rvfs_lock); 3515 } 3516 3517 3518 void 3519 vfs_list_add(struct vfs *vfsp) 3520 { 3521 zone_t *zone; 3522 3523 /* 3524 * Typically, the vfs_t will have been created on behalf of the file 3525 * system in vfs_init, where it will have been provided with a 3526 * vfs_impl_t. This, however, might be lacking if the vfs_t was created 3527 * by an unbundled file system. We therefore check for such an example 3528 * before stamping the vfs_t with its creation time for the benefit of 3529 * mntfs. 3530 */ 3531 if (vfsp->vfs_implp == NULL) 3532 vfsimpl_setup(vfsp); 3533 vfs_mono_time(&vfsp->vfs_hrctime); 3534 3535 /* 3536 * The zone that owns the mount is the one that performed the mount. 3537 * Note that this isn't necessarily the same as the zone mounted into. 3538 * The corresponding zone_rele() will be done when the vfs_t is 3539 * being free'd. 3540 */ 3541 vfsp->vfs_zone = curproc->p_zone; 3542 zone_hold(vfsp->vfs_zone); 3543 3544 /* 3545 * Find the zone mounted into, and put this mount on its vfs list. 3546 */ 3547 zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 3548 ASSERT(zone != NULL); 3549 /* 3550 * Special casing for the root vfs. This structure is allocated 3551 * statically and hooked onto rootvfs at link time. During the 3552 * vfs_mountroot call at system startup time, the root file system's 3553 * VFS_MOUNTROOT routine will call vfs_add with this root vfs struct 3554 * as argument. The code below must detect and handle this special 3555 * case. The only apparent justification for this special casing is 3556 * to ensure that the root file system appears at the head of the 3557 * list. 3558 * 3559 * XXX: I'm assuming that it's ok to do normal list locking when 3560 * adding the entry for the root file system (this used to be 3561 * done with no locks held). 3562 */ 3563 vfs_list_lock(); 3564 /* 3565 * Link into the vfs list proper. 3566 */ 3567 if (vfsp == &root) { 3568 /* 3569 * Assert: This vfs is already on the list as its first entry. 3570 * Thus, there's nothing to do. 3571 */ 3572 ASSERT(rootvfs == vfsp); 3573 /* 3574 * Add it to the head of the global zone's vfslist. 3575 */ 3576 ASSERT(zone == global_zone); 3577 ASSERT(zone->zone_vfslist == NULL); 3578 zone->zone_vfslist = vfsp; 3579 } else { 3580 /* 3581 * Link to end of list using vfs_prev (as rootvfs is now a 3582 * doubly linked circular list) so list is in mount order for 3583 * mnttab use. 3584 */ 3585 rootvfs->vfs_prev->vfs_next = vfsp; 3586 vfsp->vfs_prev = rootvfs->vfs_prev; 3587 rootvfs->vfs_prev = vfsp; 3588 vfsp->vfs_next = rootvfs; 3589 3590 /* 3591 * Do it again for the zone-private list (which may be NULL). 3592 */ 3593 if (zone->zone_vfslist == NULL) { 3594 ASSERT(zone != global_zone); 3595 zone->zone_vfslist = vfsp; 3596 } else { 3597 zone->zone_vfslist->vfs_zone_prev->vfs_zone_next = vfsp; 3598 vfsp->vfs_zone_prev = zone->zone_vfslist->vfs_zone_prev; 3599 zone->zone_vfslist->vfs_zone_prev = vfsp; 3600 vfsp->vfs_zone_next = zone->zone_vfslist; 3601 } 3602 } 3603 3604 /* 3605 * Link into the hash table, inserting it at the end, so that LOFS 3606 * with the same fsid as UFS (or other) file systems will not hide 3607 * the UFS. 3608 */ 3609 vfs_hash_add(vfsp, 0); 3610 3611 /* 3612 * update the mnttab modification time 3613 */ 3614 vfs_mnttab_modtimeupd(); 3615 vfs_list_unlock(); 3616 zone_rele(zone); 3617 } 3618 3619 void 3620 vfs_list_remove(struct vfs *vfsp) 3621 { 3622 zone_t *zone; 3623 3624 zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt)); 3625 ASSERT(zone != NULL); 3626 /* 3627 * Callers are responsible for preventing attempts to unmount the 3628 * root. 3629 */ 3630 ASSERT(vfsp != rootvfs); 3631 3632 vfs_list_lock(); 3633 3634 /* 3635 * Remove from hash. 3636 */ 3637 vfs_hash_remove(vfsp); 3638 3639 /* 3640 * Remove from vfs list. 3641 */ 3642 vfsp->vfs_prev->vfs_next = vfsp->vfs_next; 3643 vfsp->vfs_next->vfs_prev = vfsp->vfs_prev; 3644 vfsp->vfs_next = vfsp->vfs_prev = NULL; 3645 3646 /* 3647 * Remove from zone-specific vfs list. 3648 */ 3649 if (zone->zone_vfslist == vfsp) 3650 zone->zone_vfslist = vfsp->vfs_zone_next; 3651 3652 if (vfsp->vfs_zone_next == vfsp) { 3653 ASSERT(vfsp->vfs_zone_prev == vfsp); 3654 ASSERT(zone->zone_vfslist == vfsp); 3655 zone->zone_vfslist = NULL; 3656 } 3657 3658 vfsp->vfs_zone_prev->vfs_zone_next = vfsp->vfs_zone_next; 3659 vfsp->vfs_zone_next->vfs_zone_prev = vfsp->vfs_zone_prev; 3660 vfsp->vfs_zone_next = vfsp->vfs_zone_prev = NULL; 3661 3662 /* 3663 * update the mnttab modification time 3664 */ 3665 vfs_mnttab_modtimeupd(); 3666 vfs_list_unlock(); 3667 zone_rele(zone); 3668 } 3669 3670 struct vfs * 3671 getvfs(fsid_t *fsid) 3672 { 3673 struct vfs *vfsp; 3674 int val0 = fsid->val[0]; 3675 int val1 = fsid->val[1]; 3676 dev_t dev = expldev(val0); 3677 int vhno = VFSHASH(getmajor(dev), getminor(dev)); 3678 kmutex_t *hmp = &rvfs_list[vhno].rvfs_lock; 3679 3680 mutex_enter(hmp); 3681 for (vfsp = rvfs_list[vhno].rvfs_head; vfsp; vfsp = vfsp->vfs_hash) { 3682 if (vfsp->vfs_fsid.val[0] == val0 && 3683 vfsp->vfs_fsid.val[1] == val1) { 3684 VFS_HOLD(vfsp); 3685 mutex_exit(hmp); 3686 return (vfsp); 3687 } 3688 } 3689 mutex_exit(hmp); 3690 return (NULL); 3691 } 3692 3693 /* 3694 * Search the vfs mount in progress list for a specified device/vfs entry. 3695 * Returns 0 if the first entry in the list that the device matches has the 3696 * given vfs pointer as well. If the device matches but a different vfs 3697 * pointer is encountered in the list before the given vfs pointer then 3698 * a 1 is returned. 3699 */ 3700 3701 int 3702 vfs_devmounting(dev_t dev, struct vfs *vfsp) 3703 { 3704 int retval = 0; 3705 struct ipmnt *mipp; 3706 3707 mutex_enter(&vfs_miplist_mutex); 3708 for (mipp = vfs_miplist; mipp != NULL; mipp = mipp->mip_next) { 3709 if (mipp->mip_dev == dev) { 3710 if (mipp->mip_vfsp != vfsp) 3711 retval = 1; 3712 break; 3713 } 3714 } 3715 mutex_exit(&vfs_miplist_mutex); 3716 return (retval); 3717 } 3718 3719 /* 3720 * Search the vfs list for a specified device. Returns 1, if entry is found 3721 * or 0 if no suitable entry is found. 3722 */ 3723 3724 int 3725 vfs_devismounted(dev_t dev) 3726 { 3727 struct vfs *vfsp; 3728 int found; 3729 3730 vfs_list_read_lock(); 3731 vfsp = rootvfs; 3732 found = 0; 3733 do { 3734 if (vfsp->vfs_dev == dev) { 3735 found = 1; 3736 break; 3737 } 3738 vfsp = vfsp->vfs_next; 3739 } while (vfsp != rootvfs); 3740 3741 vfs_list_unlock(); 3742 return (found); 3743 } 3744 3745 /* 3746 * Search the vfs list for a specified device. Returns a pointer to it 3747 * or NULL if no suitable entry is found. The caller of this routine 3748 * is responsible for releasing the returned vfs pointer. 3749 */ 3750 struct vfs * 3751 vfs_dev2vfsp(dev_t dev) 3752 { 3753 struct vfs *vfsp; 3754 int found; 3755 3756 vfs_list_read_lock(); 3757 vfsp = rootvfs; 3758 found = 0; 3759 do { 3760 /* 3761 * The following could be made more efficient by making 3762 * the entire loop use vfs_zone_next if the call is from 3763 * a zone. The only callers, however, ustat(2) and 3764 * umount2(2), don't seem to justify the added 3765 * complexity at present. 3766 */ 3767 if (vfsp->vfs_dev == dev && 3768 ZONE_PATH_VISIBLE(refstr_value(vfsp->vfs_mntpt), 3769 curproc->p_zone)) { 3770 VFS_HOLD(vfsp); 3771 found = 1; 3772 break; 3773 } 3774 vfsp = vfsp->vfs_next; 3775 } while (vfsp != rootvfs); 3776 vfs_list_unlock(); 3777 return (found ? vfsp: NULL); 3778 } 3779 3780 /* 3781 * Search the vfs list for a specified mntpoint. Returns a pointer to it 3782 * or NULL if no suitable entry is found. The caller of this routine 3783 * is responsible for releasing the returned vfs pointer. 3784 * 3785 * Note that if multiple mntpoints match, the last one matching is 3786 * returned in an attempt to return the "top" mount when overlay 3787 * mounts are covering the same mount point. This is accomplished by starting 3788 * at the end of the list and working our way backwards, stopping at the first 3789 * matching mount. 3790 */ 3791 struct vfs * 3792 vfs_mntpoint2vfsp(const char *mp) 3793 { 3794 struct vfs *vfsp; 3795 struct vfs *retvfsp = NULL; 3796 zone_t *zone = curproc->p_zone; 3797 struct vfs *list; 3798 3799 vfs_list_read_lock(); 3800 if (getzoneid() == GLOBAL_ZONEID) { 3801 /* 3802 * The global zone may see filesystems in any zone. 3803 */ 3804 vfsp = rootvfs->vfs_prev; 3805 do { 3806 if (strcmp(refstr_value(vfsp->vfs_mntpt), mp) == 0) { 3807 retvfsp = vfsp; 3808 break; 3809 } 3810 vfsp = vfsp->vfs_prev; 3811 } while (vfsp != rootvfs->vfs_prev); 3812 } else if ((list = zone->zone_vfslist) != NULL) { 3813 const char *mntpt; 3814 3815 vfsp = list->vfs_zone_prev; 3816 do { 3817 mntpt = refstr_value(vfsp->vfs_mntpt); 3818 mntpt = ZONE_PATH_TRANSLATE(mntpt, zone); 3819 if (strcmp(mntpt, mp) == 0) { 3820 retvfsp = vfsp; 3821 break; 3822 } 3823 vfsp = vfsp->vfs_zone_prev; 3824 } while (vfsp != list->vfs_zone_prev); 3825 } 3826 if (retvfsp) 3827 VFS_HOLD(retvfsp); 3828 vfs_list_unlock(); 3829 return (retvfsp); 3830 } 3831 3832 /* 3833 * Search the vfs list for a specified vfsops. 3834 * if vfs entry is found then return 1, else 0. 3835 */ 3836 int 3837 vfs_opsinuse(vfsops_t *ops) 3838 { 3839 struct vfs *vfsp; 3840 int found; 3841 3842 vfs_list_read_lock(); 3843 vfsp = rootvfs; 3844 found = 0; 3845 do { 3846 if (vfs_getops(vfsp) == ops) { 3847 found = 1; 3848 break; 3849 } 3850 vfsp = vfsp->vfs_next; 3851 } while (vfsp != rootvfs); 3852 vfs_list_unlock(); 3853 return (found); 3854 } 3855 3856 /* 3857 * Allocate an entry in vfssw for a file system type 3858 */ 3859 struct vfssw * 3860 allocate_vfssw(const char *type) 3861 { 3862 struct vfssw *vswp; 3863 3864 if (type[0] == '\0' || strlen(type) + 1 > _ST_FSTYPSZ) { 3865 /* 3866 * The vfssw table uses the empty string to identify an 3867 * available entry; we cannot add any type which has 3868 * a leading NUL. The string length is limited to 3869 * the size of the st_fstype array in struct stat. 3870 */ 3871 return (NULL); 3872 } 3873 3874 ASSERT(VFSSW_WRITE_LOCKED()); 3875 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) 3876 if (!ALLOCATED_VFSSW(vswp)) { 3877 vswp->vsw_name = kmem_alloc(strlen(type) + 1, KM_SLEEP); 3878 (void) strcpy(vswp->vsw_name, type); 3879 ASSERT(vswp->vsw_count == 0); 3880 vswp->vsw_count = 1; 3881 mutex_init(&vswp->vsw_lock, NULL, MUTEX_DEFAULT, NULL); 3882 return (vswp); 3883 } 3884 return (NULL); 3885 } 3886 3887 /* 3888 * Impose additional layer of translation between vfstype names 3889 * and module names in the filesystem. 3890 */ 3891 static const char * 3892 vfs_to_modname(const char *vfstype) 3893 { 3894 if (strcmp(vfstype, "proc") == 0) { 3895 vfstype = "procfs"; 3896 } else if (strcmp(vfstype, "fd") == 0) { 3897 vfstype = "fdfs"; 3898 } else if (strncmp(vfstype, "nfs", 3) == 0) { 3899 vfstype = "nfs"; 3900 } 3901 3902 return (vfstype); 3903 } 3904 3905 /* 3906 * Find a vfssw entry given a file system type name. 3907 * Try to autoload the filesystem if it's not found. 3908 * If it's installed, return the vfssw locked to prevent unloading. 3909 */ 3910 struct vfssw * 3911 vfs_getvfssw(const char *type) 3912 { 3913 struct vfssw *vswp; 3914 const char *modname; 3915 3916 RLOCK_VFSSW(); 3917 vswp = vfs_getvfsswbyname(type); 3918 modname = vfs_to_modname(type); 3919 3920 if (rootdir == NULL) { 3921 /* 3922 * If we haven't yet loaded the root file system, then our 3923 * _init won't be called until later. Allocate vfssw entry, 3924 * because mod_installfs won't be called. 3925 */ 3926 if (vswp == NULL) { 3927 RUNLOCK_VFSSW(); 3928 WLOCK_VFSSW(); 3929 if ((vswp = vfs_getvfsswbyname(type)) == NULL) { 3930 if ((vswp = allocate_vfssw(type)) == NULL) { 3931 WUNLOCK_VFSSW(); 3932 return (NULL); 3933 } 3934 } 3935 WUNLOCK_VFSSW(); 3936 RLOCK_VFSSW(); 3937 } 3938 if (!VFS_INSTALLED(vswp)) { 3939 RUNLOCK_VFSSW(); 3940 (void) modloadonly("fs", modname); 3941 } else 3942 RUNLOCK_VFSSW(); 3943 return (vswp); 3944 } 3945 3946 /* 3947 * Try to load the filesystem. Before calling modload(), we drop 3948 * our lock on the VFS switch table, and pick it up after the 3949 * module is loaded. However, there is a potential race: the 3950 * module could be unloaded after the call to modload() completes 3951 * but before we pick up the lock and drive on. Therefore, 3952 * we keep reloading the module until we've loaded the module 3953 * _and_ we have the lock on the VFS switch table. 3954 */ 3955 while (vswp == NULL || !VFS_INSTALLED(vswp)) { 3956 RUNLOCK_VFSSW(); 3957 if (modload("fs", modname) == -1) 3958 return (NULL); 3959 RLOCK_VFSSW(); 3960 if (vswp == NULL) 3961 if ((vswp = vfs_getvfsswbyname(type)) == NULL) 3962 break; 3963 } 3964 RUNLOCK_VFSSW(); 3965 3966 return (vswp); 3967 } 3968 3969 /* 3970 * Find a vfssw entry given a file system type name. 3971 */ 3972 struct vfssw * 3973 vfs_getvfsswbyname(const char *type) 3974 { 3975 struct vfssw *vswp; 3976 3977 ASSERT(VFSSW_LOCKED()); 3978 if (type == NULL || *type == '\0') 3979 return (NULL); 3980 3981 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 3982 if (strcmp(type, vswp->vsw_name) == 0) { 3983 vfs_refvfssw(vswp); 3984 return (vswp); 3985 } 3986 } 3987 3988 return (NULL); 3989 } 3990 3991 /* 3992 * Find a vfssw entry given a set of vfsops. 3993 */ 3994 struct vfssw * 3995 vfs_getvfsswbyvfsops(vfsops_t *vfsops) 3996 { 3997 struct vfssw *vswp; 3998 3999 RLOCK_VFSSW(); 4000 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 4001 if (ALLOCATED_VFSSW(vswp) && &vswp->vsw_vfsops == vfsops) { 4002 vfs_refvfssw(vswp); 4003 RUNLOCK_VFSSW(); 4004 return (vswp); 4005 } 4006 } 4007 RUNLOCK_VFSSW(); 4008 4009 return (NULL); 4010 } 4011 4012 /* 4013 * Reference a vfssw entry. 4014 */ 4015 void 4016 vfs_refvfssw(struct vfssw *vswp) 4017 { 4018 4019 mutex_enter(&vswp->vsw_lock); 4020 vswp->vsw_count++; 4021 mutex_exit(&vswp->vsw_lock); 4022 } 4023 4024 /* 4025 * Unreference a vfssw entry. 4026 */ 4027 void 4028 vfs_unrefvfssw(struct vfssw *vswp) 4029 { 4030 4031 mutex_enter(&vswp->vsw_lock); 4032 vswp->vsw_count--; 4033 mutex_exit(&vswp->vsw_lock); 4034 } 4035 4036 int sync_timeout = 30; /* timeout for syncing a page during panic */ 4037 int sync_timeleft; /* portion of sync_timeout remaining */ 4038 4039 static int sync_retries = 20; /* number of retries when not making progress */ 4040 static int sync_triesleft; /* portion of sync_retries remaining */ 4041 4042 static pgcnt_t old_pgcnt, new_pgcnt; 4043 static int new_bufcnt, old_bufcnt; 4044 4045 /* 4046 * Sync all of the mounted filesystems, and then wait for the actual i/o to 4047 * complete. We wait by counting the number of dirty pages and buffers, 4048 * pushing them out using bio_busy() and page_busy(), and then counting again. 4049 * This routine is used during both the uadmin A_SHUTDOWN code as well as 4050 * the SYNC phase of the panic code (see comments in panic.c). It should only 4051 * be used after some higher-level mechanism has quiesced the system so that 4052 * new writes are not being initiated while we are waiting for completion. 4053 * 4054 * To ensure finite running time, our algorithm uses two timeout mechanisms: 4055 * sync_timeleft (a timer implemented by the omnipresent deadman() cyclic), and 4056 * sync_triesleft (a progress counter used by the vfs_syncall() loop below). 4057 * Together these ensure that syncing completes if our i/o paths are stuck. 4058 * The counters are declared above so they can be found easily in the debugger. 4059 * 4060 * The sync_timeleft counter is reset by bio_busy() and page_busy() using the 4061 * vfs_syncprogress() subroutine whenever we make progress through the lists of 4062 * pages and buffers. It is decremented and expired by the deadman() cyclic. 4063 * When vfs_syncall() decides it is done, we disable the deadman() counter by 4064 * setting sync_timeleft to zero. This timer guards against vfs_syncall() 4065 * deadlocking or hanging inside of a broken filesystem or driver routine. 4066 * 4067 * The sync_triesleft counter is updated by vfs_syncall() itself. If we make 4068 * sync_retries consecutive calls to bio_busy() and page_busy() without 4069 * decreasing either the number of dirty buffers or dirty pages below the 4070 * lowest count we have seen so far, we give up and return from vfs_syncall(). 4071 * 4072 * Each loop iteration ends with a call to delay() one second to allow time for 4073 * i/o completion and to permit the user time to read our progress messages. 4074 */ 4075 void 4076 vfs_syncall(void) 4077 { 4078 if (rootdir == NULL && !modrootloaded) 4079 return; /* panic during boot - no filesystems yet */ 4080 4081 printf("syncing file systems..."); 4082 vfs_syncprogress(); 4083 sync(); 4084 4085 vfs_syncprogress(); 4086 sync_triesleft = sync_retries; 4087 4088 old_bufcnt = new_bufcnt = INT_MAX; 4089 old_pgcnt = new_pgcnt = ULONG_MAX; 4090 4091 while (sync_triesleft > 0) { 4092 old_bufcnt = MIN(old_bufcnt, new_bufcnt); 4093 old_pgcnt = MIN(old_pgcnt, new_pgcnt); 4094 4095 new_bufcnt = bio_busy(B_TRUE); 4096 new_pgcnt = page_busy(B_TRUE); 4097 vfs_syncprogress(); 4098 4099 if (new_bufcnt == 0 && new_pgcnt == 0) 4100 break; 4101 4102 if (new_bufcnt < old_bufcnt || new_pgcnt < old_pgcnt) 4103 sync_triesleft = sync_retries; 4104 else 4105 sync_triesleft--; 4106 4107 if (new_bufcnt) 4108 printf(" [%d]", new_bufcnt); 4109 if (new_pgcnt) 4110 printf(" %lu", new_pgcnt); 4111 4112 delay(hz); 4113 } 4114 4115 if (new_bufcnt != 0 || new_pgcnt != 0) 4116 printf(" done (not all i/o completed)\n"); 4117 else 4118 printf(" done\n"); 4119 4120 sync_timeleft = 0; 4121 delay(hz); 4122 } 4123 4124 /* 4125 * If we are in the middle of the sync phase of panic, reset sync_timeleft to 4126 * sync_timeout to indicate that we are making progress and the deadman() 4127 * omnipresent cyclic should not yet time us out. Note that it is safe to 4128 * store to sync_timeleft here since the deadman() is firing at high-level 4129 * on top of us. If we are racing with the deadman(), either the deadman() 4130 * will decrement the old value and then we will reset it, or we will 4131 * reset it and then the deadman() will immediately decrement it. In either 4132 * case, correct behavior results. 4133 */ 4134 void 4135 vfs_syncprogress(void) 4136 { 4137 if (panicstr) 4138 sync_timeleft = sync_timeout; 4139 } 4140 4141 /* 4142 * Map VFS flags to statvfs flags. These shouldn't really be separate 4143 * flags at all. 4144 */ 4145 uint_t 4146 vf_to_stf(uint_t vf) 4147 { 4148 uint_t stf = 0; 4149 4150 if (vf & VFS_RDONLY) 4151 stf |= ST_RDONLY; 4152 if (vf & VFS_NOSETUID) 4153 stf |= ST_NOSUID; 4154 if (vf & VFS_NOTRUNC) 4155 stf |= ST_NOTRUNC; 4156 4157 return (stf); 4158 } 4159 4160 /* 4161 * Entries for (illegal) fstype 0. 4162 */ 4163 /* ARGSUSED */ 4164 int 4165 vfsstray_sync(struct vfs *vfsp, short arg, struct cred *cr) 4166 { 4167 cmn_err(CE_PANIC, "stray vfs operation"); 4168 return (0); 4169 } 4170 4171 /* 4172 * Entries for (illegal) fstype 0. 4173 */ 4174 int 4175 vfsstray(void) 4176 { 4177 cmn_err(CE_PANIC, "stray vfs operation"); 4178 return (0); 4179 } 4180 4181 /* 4182 * Support for dealing with forced UFS unmount and its interaction with 4183 * LOFS. Could be used by any filesystem. 4184 * See bug 1203132. 4185 */ 4186 int 4187 vfs_EIO(void) 4188 { 4189 return (EIO); 4190 } 4191 4192 /* 4193 * We've gotta define the op for sync separately, since the compiler gets 4194 * confused if we mix and match ANSI and normal style prototypes when 4195 * a "short" argument is present and spits out a warning. 4196 */ 4197 /*ARGSUSED*/ 4198 int 4199 vfs_EIO_sync(struct vfs *vfsp, short arg, struct cred *cr) 4200 { 4201 return (EIO); 4202 } 4203 4204 vfs_t EIO_vfs; 4205 vfsops_t *EIO_vfsops; 4206 4207 /* 4208 * Called from startup() to initialize all loaded vfs's 4209 */ 4210 void 4211 vfsinit(void) 4212 { 4213 struct vfssw *vswp; 4214 int error; 4215 extern int vopstats_enabled; 4216 extern void vopstats_startup(); 4217 4218 static const fs_operation_def_t EIO_vfsops_template[] = { 4219 VFSNAME_MOUNT, { .error = vfs_EIO }, 4220 VFSNAME_UNMOUNT, { .error = vfs_EIO }, 4221 VFSNAME_ROOT, { .error = vfs_EIO }, 4222 VFSNAME_STATVFS, { .error = vfs_EIO }, 4223 VFSNAME_SYNC, { .vfs_sync = vfs_EIO_sync }, 4224 VFSNAME_VGET, { .error = vfs_EIO }, 4225 VFSNAME_MOUNTROOT, { .error = vfs_EIO }, 4226 VFSNAME_FREEVFS, { .error = vfs_EIO }, 4227 VFSNAME_VNSTATE, { .error = vfs_EIO }, 4228 NULL, NULL 4229 }; 4230 4231 static const fs_operation_def_t stray_vfsops_template[] = { 4232 VFSNAME_MOUNT, { .error = vfsstray }, 4233 VFSNAME_UNMOUNT, { .error = vfsstray }, 4234 VFSNAME_ROOT, { .error = vfsstray }, 4235 VFSNAME_STATVFS, { .error = vfsstray }, 4236 VFSNAME_SYNC, { .vfs_sync = vfsstray_sync }, 4237 VFSNAME_VGET, { .error = vfsstray }, 4238 VFSNAME_MOUNTROOT, { .error = vfsstray }, 4239 VFSNAME_FREEVFS, { .error = vfsstray }, 4240 VFSNAME_VNSTATE, { .error = vfsstray }, 4241 NULL, NULL 4242 }; 4243 4244 /* Create vfs cache */ 4245 vfs_cache = kmem_cache_create("vfs_cache", sizeof (struct vfs), 4246 sizeof (uintptr_t), NULL, NULL, NULL, NULL, NULL, 0); 4247 4248 /* Initialize the vnode cache (file systems may use it during init). */ 4249 vn_create_cache(); 4250 4251 /* Setup event monitor framework */ 4252 fem_init(); 4253 4254 /* Initialize the dummy stray file system type. */ 4255 error = vfs_setfsops(0, stray_vfsops_template, NULL); 4256 4257 /* Initialize the dummy EIO file system. */ 4258 error = vfs_makefsops(EIO_vfsops_template, &EIO_vfsops); 4259 if (error != 0) { 4260 cmn_err(CE_WARN, "vfsinit: bad EIO vfs ops template"); 4261 /* Shouldn't happen, but not bad enough to panic */ 4262 } 4263 4264 VFS_INIT(&EIO_vfs, EIO_vfsops, (caddr_t)NULL); 4265 4266 /* 4267 * Default EIO_vfs.vfs_flag to VFS_UNMOUNTED so a lookup 4268 * on this vfs can immediately notice it's invalid. 4269 */ 4270 EIO_vfs.vfs_flag |= VFS_UNMOUNTED; 4271 4272 /* 4273 * Call the init routines of non-loadable filesystems only. 4274 * Filesystems which are loaded as separate modules will be 4275 * initialized by the module loading code instead. 4276 */ 4277 4278 for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) { 4279 RLOCK_VFSSW(); 4280 if (vswp->vsw_init != NULL) 4281 (*vswp->vsw_init)(vswp - vfssw, vswp->vsw_name); 4282 RUNLOCK_VFSSW(); 4283 } 4284 4285 vopstats_startup(); 4286 4287 if (vopstats_enabled) { 4288 /* EIO_vfs can collect stats, but we don't retrieve them */ 4289 initialize_vopstats(&EIO_vfs.vfs_vopstats); 4290 EIO_vfs.vfs_fstypevsp = NULL; 4291 EIO_vfs.vfs_vskap = NULL; 4292 EIO_vfs.vfs_flag |= VFS_STATS; 4293 } 4294 4295 xattr_init(); 4296 4297 reparse_point_init(); 4298 } 4299 4300 vfs_t * 4301 vfs_alloc(int kmflag) 4302 { 4303 vfs_t *vfsp; 4304 4305 vfsp = kmem_cache_alloc(vfs_cache, kmflag); 4306 4307 /* 4308 * Do the simplest initialization here. 4309 * Everything else gets done in vfs_init() 4310 */ 4311 bzero(vfsp, sizeof (vfs_t)); 4312 return (vfsp); 4313 } 4314 4315 void 4316 vfs_free(vfs_t *vfsp) 4317 { 4318 /* 4319 * One would be tempted to assert that "vfsp->vfs_count == 0". 4320 * The problem is that this gets called out of domount() with 4321 * a partially initialized vfs and a vfs_count of 1. This is 4322 * also called from vfs_rele() with a vfs_count of 0. We can't 4323 * call VFS_RELE() from domount() if VFS_MOUNT() hasn't successfully 4324 * returned. This is because VFS_MOUNT() fully initializes the 4325 * vfs structure and its associated data. VFS_RELE() will call 4326 * VFS_FREEVFS() which may panic the system if the data structures 4327 * aren't fully initialized from a successful VFS_MOUNT()). 4328 */ 4329 4330 /* If FEM was in use, make sure everything gets cleaned up */ 4331 if (vfsp->vfs_femhead) { 4332 ASSERT(vfsp->vfs_femhead->femh_list == NULL); 4333 mutex_destroy(&vfsp->vfs_femhead->femh_lock); 4334 kmem_free(vfsp->vfs_femhead, sizeof (*(vfsp->vfs_femhead))); 4335 vfsp->vfs_femhead = NULL; 4336 } 4337 4338 if (vfsp->vfs_implp) 4339 vfsimpl_teardown(vfsp); 4340 sema_destroy(&vfsp->vfs_reflock); 4341 kmem_cache_free(vfs_cache, vfsp); 4342 } 4343 4344 /* 4345 * Increments the vfs reference count by one atomically. 4346 */ 4347 void 4348 vfs_hold(vfs_t *vfsp) 4349 { 4350 atomic_add_32(&vfsp->vfs_count, 1); 4351 ASSERT(vfsp->vfs_count != 0); 4352 } 4353 4354 /* 4355 * Decrements the vfs reference count by one atomically. When 4356 * vfs reference count becomes zero, it calls the file system 4357 * specific vfs_freevfs() to free up the resources. 4358 */ 4359 void 4360 vfs_rele(vfs_t *vfsp) 4361 { 4362 ASSERT(vfsp->vfs_count != 0); 4363 if (atomic_add_32_nv(&vfsp->vfs_count, -1) == 0) { 4364 VFS_FREEVFS(vfsp); 4365 lofi_remove(vfsp); 4366 if (vfsp->vfs_zone) 4367 zone_rele(vfsp->vfs_zone); 4368 vfs_freemnttab(vfsp); 4369 vfs_free(vfsp); 4370 } 4371 } 4372 4373 /* 4374 * Generic operations vector support. 4375 * 4376 * This is used to build operations vectors for both the vfs and vnode. 4377 * It's normally called only when a file system is loaded. 4378 * 4379 * There are many possible algorithms for this, including the following: 4380 * 4381 * (1) scan the list of known operations; for each, see if the file system 4382 * includes an entry for it, and fill it in as appropriate. 4383 * 4384 * (2) set up defaults for all known operations. scan the list of ops 4385 * supplied by the file system; for each which is both supplied and 4386 * known, fill it in. 4387 * 4388 * (3) sort the lists of known ops & supplied ops; scan the list, filling 4389 * in entries as we go. 4390 * 4391 * we choose (1) for simplicity, and because performance isn't critical here. 4392 * note that (2) could be sped up using a precomputed hash table on known ops. 4393 * (3) could be faster than either, but only if the lists were very large or 4394 * supplied in sorted order. 4395 * 4396 */ 4397 4398 int 4399 fs_build_vector(void *vector, int *unused_ops, 4400 const fs_operation_trans_def_t *translation, 4401 const fs_operation_def_t *operations) 4402 { 4403 int i, num_trans, num_ops, used; 4404 4405 /* 4406 * Count the number of translations and the number of supplied 4407 * operations. 4408 */ 4409 4410 { 4411 const fs_operation_trans_def_t *p; 4412 4413 for (num_trans = 0, p = translation; 4414 p->name != NULL; 4415 num_trans++, p++) 4416 ; 4417 } 4418 4419 { 4420 const fs_operation_def_t *p; 4421 4422 for (num_ops = 0, p = operations; 4423 p->name != NULL; 4424 num_ops++, p++) 4425 ; 4426 } 4427 4428 /* Walk through each operation known to our caller. There will be */ 4429 /* one entry in the supplied "translation table" for each. */ 4430 4431 used = 0; 4432 4433 for (i = 0; i < num_trans; i++) { 4434 int j, found; 4435 char *curname; 4436 fs_generic_func_p result; 4437 fs_generic_func_p *location; 4438 4439 curname = translation[i].name; 4440 4441 /* Look for a matching operation in the list supplied by the */ 4442 /* file system. */ 4443 4444 found = 0; 4445 4446 for (j = 0; j < num_ops; j++) { 4447 if (strcmp(operations[j].name, curname) == 0) { 4448 used++; 4449 found = 1; 4450 break; 4451 } 4452 } 4453 4454 /* 4455 * If the file system is using a "placeholder" for default 4456 * or error functions, grab the appropriate function out of 4457 * the translation table. If the file system didn't supply 4458 * this operation at all, use the default function. 4459 */ 4460 4461 if (found) { 4462 result = operations[j].func.fs_generic; 4463 if (result == fs_default) { 4464 result = translation[i].defaultFunc; 4465 } else if (result == fs_error) { 4466 result = translation[i].errorFunc; 4467 } else if (result == NULL) { 4468 /* Null values are PROHIBITED */ 4469 return (EINVAL); 4470 } 4471 } else { 4472 result = translation[i].defaultFunc; 4473 } 4474 4475 /* Now store the function into the operations vector. */ 4476 4477 location = (fs_generic_func_p *) 4478 (((char *)vector) + translation[i].offset); 4479 4480 *location = result; 4481 } 4482 4483 *unused_ops = num_ops - used; 4484 4485 return (0); 4486 } 4487 4488 /* Placeholder functions, should never be called. */ 4489 4490 int 4491 fs_error(void) 4492 { 4493 cmn_err(CE_PANIC, "fs_error called"); 4494 return (0); 4495 } 4496 4497 int 4498 fs_default(void) 4499 { 4500 cmn_err(CE_PANIC, "fs_default called"); 4501 return (0); 4502 } 4503 4504 #ifdef __sparc 4505 4506 /* 4507 * Part of the implementation of booting off a mirrored root 4508 * involves a change of dev_t for the root device. To 4509 * accomplish this, first remove the existing hash table 4510 * entry for the root device, convert to the new dev_t, 4511 * then re-insert in the hash table at the head of the list. 4512 */ 4513 void 4514 vfs_root_redev(vfs_t *vfsp, dev_t ndev, int fstype) 4515 { 4516 vfs_list_lock(); 4517 4518 vfs_hash_remove(vfsp); 4519 4520 vfsp->vfs_dev = ndev; 4521 vfs_make_fsid(&vfsp->vfs_fsid, ndev, fstype); 4522 4523 vfs_hash_add(vfsp, 1); 4524 4525 vfs_list_unlock(); 4526 } 4527 4528 #else /* x86 NEWBOOT */ 4529 4530 #if defined(__x86) 4531 extern int hvmboot_rootconf(); 4532 #endif /* __x86 */ 4533 4534 extern ib_boot_prop_t *iscsiboot_prop; 4535 4536 int 4537 rootconf() 4538 { 4539 int error; 4540 struct vfssw *vsw; 4541 extern void pm_init(); 4542 char *fstyp, *fsmod; 4543 int ret = -1; 4544 4545 getrootfs(&fstyp, &fsmod); 4546 4547 #if defined(__x86) 4548 /* 4549 * hvmboot_rootconf() is defined in the hvm_bootstrap misc module, 4550 * which lives in /platform/i86hvm, and hence is only available when 4551 * booted in an x86 hvm environment. If the hvm_bootstrap misc module 4552 * is not available then the modstub for this function will return 0. 4553 * If the hvm_bootstrap misc module is available it will be loaded 4554 * and hvmboot_rootconf() will be invoked. 4555 */ 4556 if (error = hvmboot_rootconf()) 4557 return (error); 4558 #endif /* __x86 */ 4559 4560 if (error = clboot_rootconf()) 4561 return (error); 4562 4563 if (modload("fs", fsmod) == -1) 4564 panic("Cannot _init %s module", fsmod); 4565 4566 RLOCK_VFSSW(); 4567 vsw = vfs_getvfsswbyname(fstyp); 4568 RUNLOCK_VFSSW(); 4569 if (vsw == NULL) { 4570 cmn_err(CE_CONT, "Cannot find %s filesystem\n", fstyp); 4571 return (ENXIO); 4572 } 4573 VFS_INIT(rootvfs, &vsw->vsw_vfsops, 0); 4574 VFS_HOLD(rootvfs); 4575 4576 /* always mount readonly first */ 4577 rootvfs->vfs_flag |= VFS_RDONLY; 4578 4579 pm_init(); 4580 4581 if (netboot && iscsiboot_prop) { 4582 cmn_err(CE_WARN, "NFS boot and iSCSI boot" 4583 " shouldn't happen in the same time"); 4584 return (EINVAL); 4585 } 4586 4587 if (netboot || iscsiboot_prop) { 4588 ret = strplumb(); 4589 if (ret != 0) { 4590 cmn_err(CE_WARN, "Cannot plumb network device %d", ret); 4591 return (EFAULT); 4592 } 4593 } 4594 4595 if ((ret == 0) && iscsiboot_prop) { 4596 ret = modload("drv", "iscsi"); 4597 /* -1 indicates fail */ 4598 if (ret == -1) { 4599 cmn_err(CE_WARN, "Failed to load iscsi module"); 4600 iscsi_boot_prop_free(); 4601 return (EINVAL); 4602 } else { 4603 if (!i_ddi_attach_pseudo_node("iscsi")) { 4604 cmn_err(CE_WARN, 4605 "Failed to attach iscsi driver"); 4606 iscsi_boot_prop_free(); 4607 return (ENODEV); 4608 } 4609 } 4610 } 4611 4612 error = VFS_MOUNTROOT(rootvfs, ROOT_INIT); 4613 vfs_unrefvfssw(vsw); 4614 rootdev = rootvfs->vfs_dev; 4615 4616 if (error) 4617 cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n", 4618 rootfs.bo_name, fstyp); 4619 else 4620 cmn_err(CE_CONT, "?root on %s fstype %s\n", 4621 rootfs.bo_name, fstyp); 4622 return (error); 4623 } 4624 4625 /* 4626 * XXX this is called by nfs only and should probably be removed 4627 * If booted with ASKNAME, prompt on the console for a filesystem 4628 * name and return it. 4629 */ 4630 void 4631 getfsname(char *askfor, char *name, size_t namelen) 4632 { 4633 if (boothowto & RB_ASKNAME) { 4634 printf("%s name: ", askfor); 4635 console_gets(name, namelen); 4636 } 4637 } 4638 4639 /* 4640 * Init the root filesystem type (rootfs.bo_fstype) from the "fstype" 4641 * property. 4642 * 4643 * Filesystem types starting with the prefix "nfs" are diskless clients; 4644 * init the root filename name (rootfs.bo_name), too. 4645 * 4646 * If we are booting via NFS we currently have these options: 4647 * nfs - dynamically choose NFS V2, V3, or V4 (default) 4648 * nfs2 - force NFS V2 4649 * nfs3 - force NFS V3 4650 * nfs4 - force NFS V4 4651 * Because we need to maintain backward compatibility with the naming 4652 * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c) 4653 * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs". The dynamic 4654 * nfs module will map the type back to either "nfs", "nfs3", or "nfs4". 4655 * This is only for root filesystems, all other uses such as cachefs 4656 * will expect that "nfs" == NFS V2. 4657 */ 4658 static void 4659 getrootfs(char **fstypp, char **fsmodp) 4660 { 4661 extern char *strplumb_get_netdev_path(void); 4662 char *propstr = NULL; 4663 4664 /* 4665 * Check fstype property; for diskless it should be one of "nfs", 4666 * "nfs2", "nfs3" or "nfs4". 4667 */ 4668 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 4669 DDI_PROP_DONTPASS, "fstype", &propstr) 4670 == DDI_SUCCESS) { 4671 (void) strncpy(rootfs.bo_fstype, propstr, BO_MAXFSNAME); 4672 ddi_prop_free(propstr); 4673 4674 /* 4675 * if the boot property 'fstype' is not set, but 'zfs-bootfs' is set, 4676 * assume the type of this root filesystem is 'zfs'. 4677 */ 4678 } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 4679 DDI_PROP_DONTPASS, "zfs-bootfs", &propstr) 4680 == DDI_SUCCESS) { 4681 (void) strncpy(rootfs.bo_fstype, "zfs", BO_MAXFSNAME); 4682 ddi_prop_free(propstr); 4683 } 4684 4685 if (strncmp(rootfs.bo_fstype, "nfs", 3) != 0) { 4686 *fstypp = *fsmodp = rootfs.bo_fstype; 4687 return; 4688 } 4689 4690 ++netboot; 4691 4692 if (strcmp(rootfs.bo_fstype, "nfs2") == 0) 4693 (void) strcpy(rootfs.bo_fstype, "nfs"); 4694 else if (strcmp(rootfs.bo_fstype, "nfs") == 0) 4695 (void) strcpy(rootfs.bo_fstype, "nfsdyn"); 4696 4697 /* 4698 * check if path to network interface is specified in bootpath 4699 * or by a hypervisor domain configuration file. 4700 * XXPV - enable strlumb_get_netdev_path() 4701 */ 4702 if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS, 4703 "xpv-nfsroot")) { 4704 (void) strcpy(rootfs.bo_name, "/xpvd/xnf@0"); 4705 } else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), 4706 DDI_PROP_DONTPASS, "bootpath", &propstr) 4707 == DDI_SUCCESS) { 4708 (void) strncpy(rootfs.bo_name, propstr, BO_MAXOBJNAME); 4709 ddi_prop_free(propstr); 4710 } else { 4711 /* attempt to determine netdev_path via boot_mac address */ 4712 netdev_path = strplumb_get_netdev_path(); 4713 if (netdev_path == NULL) 4714 panic("cannot find boot network interface"); 4715 (void) strncpy(rootfs.bo_name, netdev_path, BO_MAXOBJNAME); 4716 } 4717 *fstypp = rootfs.bo_fstype; 4718 *fsmodp = "nfs"; 4719 } 4720 #endif 4721 4722 /* 4723 * VFS feature routines 4724 */ 4725 4726 #define VFTINDEX(feature) (((feature) >> 32) & 0xFFFFFFFF) 4727 #define VFTBITS(feature) ((feature) & 0xFFFFFFFFLL) 4728 4729 /* Register a feature in the vfs */ 4730 void 4731 vfs_set_feature(vfs_t *vfsp, vfs_feature_t feature) 4732 { 4733 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */ 4734 if (vfsp->vfs_implp == NULL) 4735 return; 4736 4737 vfsp->vfs_featureset[VFTINDEX(feature)] |= VFTBITS(feature); 4738 } 4739 4740 /* 4741 * Query a vfs for a feature. 4742 * Returns 1 if feature is present, 0 if not 4743 */ 4744 int 4745 vfs_has_feature(vfs_t *vfsp, vfs_feature_t feature) 4746 { 4747 int ret = 0; 4748 4749 /* Note that vfs_featureset[] is found in *vfsp->vfs_implp */ 4750 if (vfsp->vfs_implp == NULL) 4751 return (ret); 4752 4753 if (vfsp->vfs_featureset[VFTINDEX(feature)] & VFTBITS(feature)) 4754 ret = 1; 4755 4756 return (ret); 4757 } 4758 4759 /* 4760 * Propagate feature set from one vfs to another 4761 */ 4762 void 4763 vfs_propagate_features(vfs_t *from, vfs_t *to) 4764 { 4765 int i; 4766 4767 if (to->vfs_implp == NULL || from->vfs_implp == NULL) 4768 return; 4769 4770 for (i = 1; i <= to->vfs_featureset[0]; i++) { 4771 to->vfs_featureset[i] = from->vfs_featureset[i]; 4772 } 4773 } 4774 4775 #define LOFINODE_PATH "/dev/lofi/%d" 4776 4777 /* 4778 * Return the vnode for the lofi node if there's a lofi mount in place. 4779 * Returns -1 when there's no lofi node, 0 on success, and > 0 on 4780 * failure. 4781 */ 4782 int 4783 vfs_get_lofi(vfs_t *vfsp, vnode_t **vpp) 4784 { 4785 char *path = NULL; 4786 int strsize; 4787 int err; 4788 4789 if (vfsp->vfs_lofi_minor == 0) { 4790 *vpp = NULL; 4791 return (-1); 4792 } 4793 4794 strsize = snprintf(NULL, 0, LOFINODE_PATH, vfsp->vfs_lofi_minor); 4795 path = kmem_alloc(strsize + 1, KM_SLEEP); 4796 (void) snprintf(path, strsize + 1, LOFINODE_PATH, vfsp->vfs_lofi_minor); 4797 4798 /* 4799 * We may be inside a zone, so we need to use the /dev path, but 4800 * it's created asynchronously, so we wait here. 4801 */ 4802 for (;;) { 4803 err = lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, vpp); 4804 4805 if (err != ENOENT) 4806 break; 4807 4808 if ((err = delay_sig(hz / 8)) == EINTR) 4809 break; 4810 } 4811 4812 if (err) 4813 *vpp = NULL; 4814 4815 kmem_free(path, strsize + 1); 4816 return (err); 4817 } 4818