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