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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/param.h> 28 #include <sys/systm.h> 29 #include <sys/sysmacros.h> 30 #include <sys/kmem.h> 31 #include <sys/pathname.h> 32 #include <sys/vnode.h> 33 #include <sys/vfs.h> 34 #include <sys/vfs_opreg.h> 35 #include <sys/mntent.h> 36 #include <sys/mount.h> 37 #include <sys/cmn_err.h> 38 #include "fs/fs_subr.h" 39 #include <sys/zfs_znode.h> 40 #include <sys/zfs_dir.h> 41 #include <sys/zil.h> 42 #include <sys/fs/zfs.h> 43 #include <sys/dmu.h> 44 #include <sys/dsl_prop.h> 45 #include <sys/dsl_dataset.h> 46 #include <sys/dsl_deleg.h> 47 #include <sys/spa.h> 48 #include <sys/zap.h> 49 #include <sys/varargs.h> 50 #include <sys/policy.h> 51 #include <sys/atomic.h> 52 #include <sys/mkdev.h> 53 #include <sys/modctl.h> 54 #include <sys/refstr.h> 55 #include <sys/zfs_ioctl.h> 56 #include <sys/zfs_ctldir.h> 57 #include <sys/zfs_fuid.h> 58 #include <sys/bootconf.h> 59 #include <sys/sunddi.h> 60 #include <sys/dnlc.h> 61 #include <sys/dmu_objset.h> 62 #include <sys/spa_boot.h> 63 64 int zfsfstype; 65 vfsops_t *zfs_vfsops = NULL; 66 static major_t zfs_major; 67 static minor_t zfs_minor; 68 static kmutex_t zfs_dev_mtx; 69 70 static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr); 71 static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr); 72 static int zfs_mountroot(vfs_t *vfsp, enum whymountroot); 73 static int zfs_root(vfs_t *vfsp, vnode_t **vpp); 74 static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp); 75 static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp); 76 static void zfs_freevfs(vfs_t *vfsp); 77 78 static const fs_operation_def_t zfs_vfsops_template[] = { 79 VFSNAME_MOUNT, { .vfs_mount = zfs_mount }, 80 VFSNAME_MOUNTROOT, { .vfs_mountroot = zfs_mountroot }, 81 VFSNAME_UNMOUNT, { .vfs_unmount = zfs_umount }, 82 VFSNAME_ROOT, { .vfs_root = zfs_root }, 83 VFSNAME_STATVFS, { .vfs_statvfs = zfs_statvfs }, 84 VFSNAME_SYNC, { .vfs_sync = zfs_sync }, 85 VFSNAME_VGET, { .vfs_vget = zfs_vget }, 86 VFSNAME_FREEVFS, { .vfs_freevfs = zfs_freevfs }, 87 NULL, NULL 88 }; 89 90 static const fs_operation_def_t zfs_vfsops_eio_template[] = { 91 VFSNAME_FREEVFS, { .vfs_freevfs = zfs_freevfs }, 92 NULL, NULL 93 }; 94 95 /* 96 * We need to keep a count of active fs's. 97 * This is necessary to prevent our module 98 * from being unloaded after a umount -f 99 */ 100 static uint32_t zfs_active_fs_count = 0; 101 102 static char *noatime_cancel[] = { MNTOPT_ATIME, NULL }; 103 static char *atime_cancel[] = { MNTOPT_NOATIME, NULL }; 104 static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL }; 105 static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL }; 106 107 /* 108 * MO_DEFAULT is not used since the default value is determined 109 * by the equivalent property. 110 */ 111 static mntopt_t mntopts[] = { 112 { MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL }, 113 { MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL }, 114 { MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL }, 115 { MNTOPT_ATIME, atime_cancel, NULL, 0, NULL } 116 }; 117 118 static mntopts_t zfs_mntopts = { 119 sizeof (mntopts) / sizeof (mntopt_t), 120 mntopts 121 }; 122 123 /*ARGSUSED*/ 124 int 125 zfs_sync(vfs_t *vfsp, short flag, cred_t *cr) 126 { 127 /* 128 * Data integrity is job one. We don't want a compromised kernel 129 * writing to the storage pool, so we never sync during panic. 130 */ 131 if (panicstr) 132 return (0); 133 134 /* 135 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS 136 * to sync metadata, which they would otherwise cache indefinitely. 137 * Semantically, the only requirement is that the sync be initiated. 138 * The DMU syncs out txgs frequently, so there's nothing to do. 139 */ 140 if (flag & SYNC_ATTR) 141 return (0); 142 143 if (vfsp != NULL) { 144 /* 145 * Sync a specific filesystem. 146 */ 147 zfsvfs_t *zfsvfs = vfsp->vfs_data; 148 149 ZFS_ENTER(zfsvfs); 150 if (zfsvfs->z_log != NULL) 151 zil_commit(zfsvfs->z_log, UINT64_MAX, 0); 152 else 153 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0); 154 ZFS_EXIT(zfsvfs); 155 } else { 156 /* 157 * Sync all ZFS filesystems. This is what happens when you 158 * run sync(1M). Unlike other filesystems, ZFS honors the 159 * request by waiting for all pools to commit all dirty data. 160 */ 161 spa_sync_allpools(); 162 } 163 164 return (0); 165 } 166 167 static int 168 zfs_create_unique_device(dev_t *dev) 169 { 170 major_t new_major; 171 172 do { 173 ASSERT3U(zfs_minor, <=, MAXMIN32); 174 minor_t start = zfs_minor; 175 do { 176 mutex_enter(&zfs_dev_mtx); 177 if (zfs_minor >= MAXMIN32) { 178 /* 179 * If we're still using the real major 180 * keep out of /dev/zfs and /dev/zvol minor 181 * number space. If we're using a getudev()'ed 182 * major number, we can use all of its minors. 183 */ 184 if (zfs_major == ddi_name_to_major(ZFS_DRIVER)) 185 zfs_minor = ZFS_MIN_MINOR; 186 else 187 zfs_minor = 0; 188 } else { 189 zfs_minor++; 190 } 191 *dev = makedevice(zfs_major, zfs_minor); 192 mutex_exit(&zfs_dev_mtx); 193 } while (vfs_devismounted(*dev) && zfs_minor != start); 194 if (zfs_minor == start) { 195 /* 196 * We are using all ~262,000 minor numbers for the 197 * current major number. Create a new major number. 198 */ 199 if ((new_major = getudev()) == (major_t)-1) { 200 cmn_err(CE_WARN, 201 "zfs_mount: Can't get unique major " 202 "device number."); 203 return (-1); 204 } 205 mutex_enter(&zfs_dev_mtx); 206 zfs_major = new_major; 207 zfs_minor = 0; 208 209 mutex_exit(&zfs_dev_mtx); 210 } else { 211 break; 212 } 213 /* CONSTANTCONDITION */ 214 } while (1); 215 216 return (0); 217 } 218 219 static void 220 atime_changed_cb(void *arg, uint64_t newval) 221 { 222 zfsvfs_t *zfsvfs = arg; 223 224 if (newval == TRUE) { 225 zfsvfs->z_atime = TRUE; 226 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME); 227 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0); 228 } else { 229 zfsvfs->z_atime = FALSE; 230 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME); 231 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0); 232 } 233 } 234 235 static void 236 xattr_changed_cb(void *arg, uint64_t newval) 237 { 238 zfsvfs_t *zfsvfs = arg; 239 240 if (newval == TRUE) { 241 /* XXX locking on vfs_flag? */ 242 zfsvfs->z_vfs->vfs_flag |= VFS_XATTR; 243 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR); 244 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0); 245 } else { 246 /* XXX locking on vfs_flag? */ 247 zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR; 248 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR); 249 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0); 250 } 251 } 252 253 static void 254 blksz_changed_cb(void *arg, uint64_t newval) 255 { 256 zfsvfs_t *zfsvfs = arg; 257 258 if (newval < SPA_MINBLOCKSIZE || 259 newval > SPA_MAXBLOCKSIZE || !ISP2(newval)) 260 newval = SPA_MAXBLOCKSIZE; 261 262 zfsvfs->z_max_blksz = newval; 263 zfsvfs->z_vfs->vfs_bsize = newval; 264 } 265 266 static void 267 readonly_changed_cb(void *arg, uint64_t newval) 268 { 269 zfsvfs_t *zfsvfs = arg; 270 271 if (newval) { 272 /* XXX locking on vfs_flag? */ 273 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY; 274 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW); 275 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0); 276 } else { 277 /* XXX locking on vfs_flag? */ 278 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY; 279 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO); 280 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0); 281 } 282 } 283 284 static void 285 devices_changed_cb(void *arg, uint64_t newval) 286 { 287 zfsvfs_t *zfsvfs = arg; 288 289 if (newval == FALSE) { 290 zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES; 291 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES); 292 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0); 293 } else { 294 zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES; 295 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES); 296 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0); 297 } 298 } 299 300 static void 301 setuid_changed_cb(void *arg, uint64_t newval) 302 { 303 zfsvfs_t *zfsvfs = arg; 304 305 if (newval == FALSE) { 306 zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID; 307 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID); 308 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0); 309 } else { 310 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID; 311 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID); 312 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0); 313 } 314 } 315 316 static void 317 exec_changed_cb(void *arg, uint64_t newval) 318 { 319 zfsvfs_t *zfsvfs = arg; 320 321 if (newval == FALSE) { 322 zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC; 323 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC); 324 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0); 325 } else { 326 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC; 327 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC); 328 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0); 329 } 330 } 331 332 /* 333 * The nbmand mount option can be changed at mount time. 334 * We can't allow it to be toggled on live file systems or incorrect 335 * behavior may be seen from cifs clients 336 * 337 * This property isn't registered via dsl_prop_register(), but this callback 338 * will be called when a file system is first mounted 339 */ 340 static void 341 nbmand_changed_cb(void *arg, uint64_t newval) 342 { 343 zfsvfs_t *zfsvfs = arg; 344 if (newval == FALSE) { 345 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND); 346 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0); 347 } else { 348 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND); 349 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0); 350 } 351 } 352 353 static void 354 snapdir_changed_cb(void *arg, uint64_t newval) 355 { 356 zfsvfs_t *zfsvfs = arg; 357 358 zfsvfs->z_show_ctldir = newval; 359 } 360 361 static void 362 vscan_changed_cb(void *arg, uint64_t newval) 363 { 364 zfsvfs_t *zfsvfs = arg; 365 366 zfsvfs->z_vscan = newval; 367 } 368 369 static void 370 acl_mode_changed_cb(void *arg, uint64_t newval) 371 { 372 zfsvfs_t *zfsvfs = arg; 373 374 zfsvfs->z_acl_mode = newval; 375 } 376 377 static void 378 acl_inherit_changed_cb(void *arg, uint64_t newval) 379 { 380 zfsvfs_t *zfsvfs = arg; 381 382 zfsvfs->z_acl_inherit = newval; 383 } 384 385 static int 386 zfs_register_callbacks(vfs_t *vfsp) 387 { 388 struct dsl_dataset *ds = NULL; 389 objset_t *os = NULL; 390 zfsvfs_t *zfsvfs = NULL; 391 uint64_t nbmand; 392 int readonly, do_readonly = B_FALSE; 393 int setuid, do_setuid = B_FALSE; 394 int exec, do_exec = B_FALSE; 395 int devices, do_devices = B_FALSE; 396 int xattr, do_xattr = B_FALSE; 397 int atime, do_atime = B_FALSE; 398 int error = 0; 399 400 ASSERT(vfsp); 401 zfsvfs = vfsp->vfs_data; 402 ASSERT(zfsvfs); 403 os = zfsvfs->z_os; 404 405 /* 406 * The act of registering our callbacks will destroy any mount 407 * options we may have. In order to enable temporary overrides 408 * of mount options, we stash away the current values and 409 * restore them after we register the callbacks. 410 */ 411 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) { 412 readonly = B_TRUE; 413 do_readonly = B_TRUE; 414 } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) { 415 readonly = B_FALSE; 416 do_readonly = B_TRUE; 417 } 418 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) { 419 devices = B_FALSE; 420 setuid = B_FALSE; 421 do_devices = B_TRUE; 422 do_setuid = B_TRUE; 423 } else { 424 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) { 425 devices = B_FALSE; 426 do_devices = B_TRUE; 427 } else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) { 428 devices = B_TRUE; 429 do_devices = B_TRUE; 430 } 431 432 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) { 433 setuid = B_FALSE; 434 do_setuid = B_TRUE; 435 } else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) { 436 setuid = B_TRUE; 437 do_setuid = B_TRUE; 438 } 439 } 440 if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) { 441 exec = B_FALSE; 442 do_exec = B_TRUE; 443 } else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) { 444 exec = B_TRUE; 445 do_exec = B_TRUE; 446 } 447 if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) { 448 xattr = B_FALSE; 449 do_xattr = B_TRUE; 450 } else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) { 451 xattr = B_TRUE; 452 do_xattr = B_TRUE; 453 } 454 if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) { 455 atime = B_FALSE; 456 do_atime = B_TRUE; 457 } else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) { 458 atime = B_TRUE; 459 do_atime = B_TRUE; 460 } 461 462 /* 463 * nbmand is a special property. It can only be changed at 464 * mount time. 465 * 466 * This is weird, but it is documented to only be changeable 467 * at mount time. 468 */ 469 if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) { 470 nbmand = B_FALSE; 471 } else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) { 472 nbmand = B_TRUE; 473 } else { 474 char osname[MAXNAMELEN]; 475 476 dmu_objset_name(os, osname); 477 if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand, 478 NULL)) { 479 return (error); 480 } 481 } 482 483 /* 484 * Register property callbacks. 485 * 486 * It would probably be fine to just check for i/o error from 487 * the first prop_register(), but I guess I like to go 488 * overboard... 489 */ 490 ds = dmu_objset_ds(os); 491 error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs); 492 error = error ? error : dsl_prop_register(ds, 493 "xattr", xattr_changed_cb, zfsvfs); 494 error = error ? error : dsl_prop_register(ds, 495 "recordsize", blksz_changed_cb, zfsvfs); 496 error = error ? error : dsl_prop_register(ds, 497 "readonly", readonly_changed_cb, zfsvfs); 498 error = error ? error : dsl_prop_register(ds, 499 "devices", devices_changed_cb, zfsvfs); 500 error = error ? error : dsl_prop_register(ds, 501 "setuid", setuid_changed_cb, zfsvfs); 502 error = error ? error : dsl_prop_register(ds, 503 "exec", exec_changed_cb, zfsvfs); 504 error = error ? error : dsl_prop_register(ds, 505 "snapdir", snapdir_changed_cb, zfsvfs); 506 error = error ? error : dsl_prop_register(ds, 507 "aclmode", acl_mode_changed_cb, zfsvfs); 508 error = error ? error : dsl_prop_register(ds, 509 "aclinherit", acl_inherit_changed_cb, zfsvfs); 510 error = error ? error : dsl_prop_register(ds, 511 "vscan", vscan_changed_cb, zfsvfs); 512 if (error) 513 goto unregister; 514 515 /* 516 * Invoke our callbacks to restore temporary mount options. 517 */ 518 if (do_readonly) 519 readonly_changed_cb(zfsvfs, readonly); 520 if (do_setuid) 521 setuid_changed_cb(zfsvfs, setuid); 522 if (do_exec) 523 exec_changed_cb(zfsvfs, exec); 524 if (do_devices) 525 devices_changed_cb(zfsvfs, devices); 526 if (do_xattr) 527 xattr_changed_cb(zfsvfs, xattr); 528 if (do_atime) 529 atime_changed_cb(zfsvfs, atime); 530 531 nbmand_changed_cb(zfsvfs, nbmand); 532 533 return (0); 534 535 unregister: 536 /* 537 * We may attempt to unregister some callbacks that are not 538 * registered, but this is OK; it will simply return ENOMSG, 539 * which we will ignore. 540 */ 541 (void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs); 542 (void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs); 543 (void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs); 544 (void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs); 545 (void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs); 546 (void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs); 547 (void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs); 548 (void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs); 549 (void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs); 550 (void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb, 551 zfsvfs); 552 (void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zfsvfs); 553 return (error); 554 555 } 556 557 static int 558 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting) 559 { 560 int error; 561 562 error = zfs_register_callbacks(zfsvfs->z_vfs); 563 if (error) 564 return (error); 565 566 /* 567 * Set the objset user_ptr to track its zfsvfs. 568 */ 569 mutex_enter(&zfsvfs->z_os->os->os_user_ptr_lock); 570 dmu_objset_set_user(zfsvfs->z_os, zfsvfs); 571 mutex_exit(&zfsvfs->z_os->os->os_user_ptr_lock); 572 573 /* 574 * If we are not mounting (ie: online recv), then we don't 575 * have to worry about replaying the log as we blocked all 576 * operations out since we closed the ZIL. 577 */ 578 if (mounting) { 579 boolean_t readonly; 580 581 /* 582 * During replay we remove the read only flag to 583 * allow replays to succeed. 584 */ 585 readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY; 586 if (readonly != 0) 587 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY; 588 else 589 zfs_unlinked_drain(zfsvfs); 590 591 zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data); 592 if (zil_disable) { 593 zil_destroy(zfsvfs->z_log, 0); 594 zfsvfs->z_log = NULL; 595 } else { 596 /* 597 * Parse and replay the intent log. 598 * 599 * Because of ziltest, this must be done after 600 * zfs_unlinked_drain(). (Further note: ziltest 601 * doesn't use readonly mounts, where 602 * zfs_unlinked_drain() isn't called.) This is because 603 * ziltest causes spa_sync() to think it's committed, 604 * but actually it is not, so the intent log contains 605 * many txg's worth of changes. 606 * 607 * In particular, if object N is in the unlinked set in 608 * the last txg to actually sync, then it could be 609 * actually freed in a later txg and then reallocated 610 * in a yet later txg. This would write a "create 611 * object N" record to the intent log. Normally, this 612 * would be fine because the spa_sync() would have 613 * written out the fact that object N is free, before 614 * we could write the "create object N" intent log 615 * record. 616 * 617 * But when we are in ziltest mode, we advance the "open 618 * txg" without actually spa_sync()-ing the changes to 619 * disk. So we would see that object N is still 620 * allocated and in the unlinked set, and there is an 621 * intent log record saying to allocate it. 622 */ 623 zfsvfs->z_replay = B_TRUE; 624 zil_replay(zfsvfs->z_os, zfsvfs, zfs_replay_vector); 625 zfsvfs->z_replay = B_FALSE; 626 } 627 zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */ 628 } 629 630 return (0); 631 } 632 633 static void 634 zfs_freezfsvfs(zfsvfs_t *zfsvfs) 635 { 636 mutex_destroy(&zfsvfs->z_znodes_lock); 637 mutex_destroy(&zfsvfs->z_online_recv_lock); 638 mutex_destroy(&zfsvfs->z_lock); 639 list_destroy(&zfsvfs->z_all_znodes); 640 rrw_destroy(&zfsvfs->z_teardown_lock); 641 rw_destroy(&zfsvfs->z_teardown_inactive_lock); 642 rw_destroy(&zfsvfs->z_fuid_lock); 643 kmem_free(zfsvfs, sizeof (zfsvfs_t)); 644 } 645 646 static int 647 zfs_domount(vfs_t *vfsp, char *osname) 648 { 649 dev_t mount_dev; 650 uint64_t recordsize, readonly; 651 int error = 0; 652 int mode; 653 zfsvfs_t *zfsvfs; 654 znode_t *zp = NULL; 655 656 ASSERT(vfsp); 657 ASSERT(osname); 658 659 /* 660 * Initialize the zfs-specific filesystem structure. 661 * Should probably make this a kmem cache, shuffle fields, 662 * and just bzero up to z_hold_mtx[]. 663 */ 664 zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP); 665 zfsvfs->z_vfs = vfsp; 666 zfsvfs->z_parent = zfsvfs; 667 zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE; 668 zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE; 669 zfsvfs->z_fuid_dirty = B_FALSE; 670 671 mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 672 mutex_init(&zfsvfs->z_online_recv_lock, NULL, MUTEX_DEFAULT, NULL); 673 mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL); 674 list_create(&zfsvfs->z_all_znodes, sizeof (znode_t), 675 offsetof(znode_t, z_link_node)); 676 rrw_init(&zfsvfs->z_teardown_lock); 677 rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL); 678 rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL); 679 680 /* Initialize the generic filesystem structure. */ 681 vfsp->vfs_bcount = 0; 682 vfsp->vfs_data = NULL; 683 684 if (zfs_create_unique_device(&mount_dev) == -1) { 685 error = ENODEV; 686 goto out; 687 } 688 ASSERT(vfs_devismounted(mount_dev) == 0); 689 690 if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize, 691 NULL)) 692 goto out; 693 694 vfsp->vfs_dev = mount_dev; 695 vfsp->vfs_fstype = zfsfstype; 696 vfsp->vfs_bsize = recordsize; 697 vfsp->vfs_flag |= VFS_NOTRUNC; 698 vfsp->vfs_data = zfsvfs; 699 700 if (error = dsl_prop_get_integer(osname, "readonly", &readonly, NULL)) 701 goto out; 702 703 mode = DS_MODE_OWNER; 704 if (readonly) 705 mode |= DS_MODE_READONLY; 706 707 error = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os); 708 if (error == EROFS) { 709 mode = DS_MODE_OWNER | DS_MODE_READONLY; 710 error = dmu_objset_open(osname, DMU_OST_ZFS, mode, 711 &zfsvfs->z_os); 712 } 713 714 if (error) 715 goto out; 716 717 if (error = zfs_init_fs(zfsvfs, &zp)) 718 goto out; 719 720 /* The call to zfs_init_fs leaves the vnode held, release it here. */ 721 VN_RELE(ZTOV(zp)); 722 723 /* 724 * Set features for file system. 725 */ 726 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os); 727 if (zfsvfs->z_use_fuids) { 728 vfs_set_feature(vfsp, VFSFT_XVATTR); 729 vfs_set_feature(vfsp, VFSFT_SYSATTR_VIEWS); 730 vfs_set_feature(vfsp, VFSFT_ACEMASKONACCESS); 731 vfs_set_feature(vfsp, VFSFT_ACLONCREATE); 732 } 733 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) { 734 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS); 735 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE); 736 vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE); 737 } else if (zfsvfs->z_case == ZFS_CASE_MIXED) { 738 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS); 739 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE); 740 } 741 742 if (dmu_objset_is_snapshot(zfsvfs->z_os)) { 743 uint64_t pval; 744 745 ASSERT(mode & DS_MODE_READONLY); 746 atime_changed_cb(zfsvfs, B_FALSE); 747 readonly_changed_cb(zfsvfs, B_TRUE); 748 if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL)) 749 goto out; 750 xattr_changed_cb(zfsvfs, pval); 751 zfsvfs->z_issnap = B_TRUE; 752 } else { 753 error = zfsvfs_setup(zfsvfs, B_TRUE); 754 } 755 756 if (!zfsvfs->z_issnap) 757 zfsctl_create(zfsvfs); 758 out: 759 if (error) { 760 if (zfsvfs->z_os) 761 dmu_objset_close(zfsvfs->z_os); 762 zfs_freezfsvfs(zfsvfs); 763 } else { 764 atomic_add_32(&zfs_active_fs_count, 1); 765 } 766 767 return (error); 768 } 769 770 void 771 zfs_unregister_callbacks(zfsvfs_t *zfsvfs) 772 { 773 objset_t *os = zfsvfs->z_os; 774 struct dsl_dataset *ds; 775 776 /* 777 * Unregister properties. 778 */ 779 if (!dmu_objset_is_snapshot(os)) { 780 ds = dmu_objset_ds(os); 781 VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb, 782 zfsvfs) == 0); 783 784 VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb, 785 zfsvfs) == 0); 786 787 VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, 788 zfsvfs) == 0); 789 790 VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb, 791 zfsvfs) == 0); 792 793 VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb, 794 zfsvfs) == 0); 795 796 VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb, 797 zfsvfs) == 0); 798 799 VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb, 800 zfsvfs) == 0); 801 802 VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, 803 zfsvfs) == 0); 804 805 VERIFY(dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, 806 zfsvfs) == 0); 807 808 VERIFY(dsl_prop_unregister(ds, "aclinherit", 809 acl_inherit_changed_cb, zfsvfs) == 0); 810 811 VERIFY(dsl_prop_unregister(ds, "vscan", 812 vscan_changed_cb, zfsvfs) == 0); 813 } 814 } 815 816 /* 817 * Convert a decimal digit string to a uint64_t integer. 818 */ 819 static int 820 str_to_uint64(char *str, uint64_t *objnum) 821 { 822 uint64_t num = 0; 823 824 while (*str) { 825 if (*str < '0' || *str > '9') 826 return (EINVAL); 827 828 num = num*10 + *str++ - '0'; 829 } 830 831 *objnum = num; 832 return (0); 833 } 834 835 /* 836 * The boot path passed from the boot loader is in the form of 837 * "rootpool-name/root-filesystem-object-number'. Convert this 838 * string to a dataset name: "rootpool-name/root-filesystem-name". 839 */ 840 static int 841 zfs_parse_bootfs(char *bpath, char *outpath) 842 { 843 char *slashp; 844 uint64_t objnum; 845 int error; 846 847 if (*bpath == 0 || *bpath == '/') 848 return (EINVAL); 849 850 (void) strcpy(outpath, bpath); 851 852 slashp = strchr(bpath, '/'); 853 854 /* if no '/', just return the pool name */ 855 if (slashp == NULL) { 856 return (0); 857 } 858 859 /* if not a number, just return the root dataset name */ 860 if (str_to_uint64(slashp+1, &objnum)) { 861 return (0); 862 } 863 864 *slashp = '\0'; 865 error = dsl_dsobj_to_dsname(bpath, objnum, outpath); 866 *slashp = '/'; 867 868 return (error); 869 } 870 871 static int 872 zfs_mountroot(vfs_t *vfsp, enum whymountroot why) 873 { 874 int error = 0; 875 static int zfsrootdone = 0; 876 zfsvfs_t *zfsvfs = NULL; 877 znode_t *zp = NULL; 878 vnode_t *vp = NULL; 879 char *zfs_bootfs; 880 char *zfs_devid; 881 882 ASSERT(vfsp); 883 884 /* 885 * The filesystem that we mount as root is defined in the 886 * boot property "zfs-bootfs" with a format of 887 * "poolname/root-dataset-objnum". 888 */ 889 if (why == ROOT_INIT) { 890 if (zfsrootdone++) 891 return (EBUSY); 892 /* 893 * the process of doing a spa_load will require the 894 * clock to be set before we could (for example) do 895 * something better by looking at the timestamp on 896 * an uberblock, so just set it to -1. 897 */ 898 clkset(-1); 899 900 if ((zfs_bootfs = spa_get_bootprop("zfs-bootfs")) == NULL) { 901 cmn_err(CE_NOTE, "spa_get_bootfs: can not get " 902 "bootfs name"); 903 return (EINVAL); 904 } 905 zfs_devid = spa_get_bootprop("diskdevid"); 906 error = spa_import_rootpool(rootfs.bo_name, zfs_devid); 907 if (zfs_devid) 908 spa_free_bootprop(zfs_devid); 909 if (error) { 910 spa_free_bootprop(zfs_bootfs); 911 cmn_err(CE_NOTE, "spa_import_rootpool: error %d", 912 error); 913 return (error); 914 } 915 if (error = zfs_parse_bootfs(zfs_bootfs, rootfs.bo_name)) { 916 spa_free_bootprop(zfs_bootfs); 917 cmn_err(CE_NOTE, "zfs_parse_bootfs: error %d", 918 error); 919 return (error); 920 } 921 922 spa_free_bootprop(zfs_bootfs); 923 924 if (error = vfs_lock(vfsp)) 925 return (error); 926 927 if (error = zfs_domount(vfsp, rootfs.bo_name)) { 928 cmn_err(CE_NOTE, "zfs_domount: error %d", error); 929 goto out; 930 } 931 932 zfsvfs = (zfsvfs_t *)vfsp->vfs_data; 933 ASSERT(zfsvfs); 934 if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) { 935 cmn_err(CE_NOTE, "zfs_zget: error %d", error); 936 goto out; 937 } 938 939 vp = ZTOV(zp); 940 mutex_enter(&vp->v_lock); 941 vp->v_flag |= VROOT; 942 mutex_exit(&vp->v_lock); 943 rootvp = vp; 944 945 /* 946 * Leave rootvp held. The root file system is never unmounted. 947 */ 948 949 vfs_add((struct vnode *)0, vfsp, 950 (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0); 951 out: 952 vfs_unlock(vfsp); 953 return (error); 954 } else if (why == ROOT_REMOUNT) { 955 readonly_changed_cb(vfsp->vfs_data, B_FALSE); 956 vfsp->vfs_flag |= VFS_REMOUNT; 957 958 /* refresh mount options */ 959 zfs_unregister_callbacks(vfsp->vfs_data); 960 return (zfs_register_callbacks(vfsp)); 961 962 } else if (why == ROOT_UNMOUNT) { 963 zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data); 964 (void) zfs_sync(vfsp, 0, 0); 965 return (0); 966 } 967 968 /* 969 * if "why" is equal to anything else other than ROOT_INIT, 970 * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it. 971 */ 972 return (ENOTSUP); 973 } 974 975 /*ARGSUSED*/ 976 static int 977 zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 978 { 979 char *osname; 980 pathname_t spn; 981 int error = 0; 982 uio_seg_t fromspace = (uap->flags & MS_SYSSPACE) ? 983 UIO_SYSSPACE : UIO_USERSPACE; 984 int canwrite; 985 986 if (mvp->v_type != VDIR) 987 return (ENOTDIR); 988 989 mutex_enter(&mvp->v_lock); 990 if ((uap->flags & MS_REMOUNT) == 0 && 991 (uap->flags & MS_OVERLAY) == 0 && 992 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 993 mutex_exit(&mvp->v_lock); 994 return (EBUSY); 995 } 996 mutex_exit(&mvp->v_lock); 997 998 /* 999 * ZFS does not support passing unparsed data in via MS_DATA. 1000 * Users should use the MS_OPTIONSTR interface; this means 1001 * that all option parsing is already done and the options struct 1002 * can be interrogated. 1003 */ 1004 if ((uap->flags & MS_DATA) && uap->datalen > 0) 1005 return (EINVAL); 1006 1007 /* 1008 * Get the objset name (the "special" mount argument). 1009 */ 1010 if (error = pn_get(uap->spec, fromspace, &spn)) 1011 return (error); 1012 1013 osname = spn.pn_path; 1014 1015 /* 1016 * Check for mount privilege? 1017 * 1018 * If we don't have privilege then see if 1019 * we have local permission to allow it 1020 */ 1021 error = secpolicy_fs_mount(cr, mvp, vfsp); 1022 if (error) { 1023 error = dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr); 1024 if (error == 0) { 1025 vattr_t vattr; 1026 1027 /* 1028 * Make sure user is the owner of the mount point 1029 * or has sufficient privileges. 1030 */ 1031 1032 vattr.va_mask = AT_UID; 1033 1034 if (error = VOP_GETATTR(mvp, &vattr, 0, cr, NULL)) { 1035 goto out; 1036 } 1037 1038 if (secpolicy_vnode_owner(cr, vattr.va_uid) != 0 && 1039 VOP_ACCESS(mvp, VWRITE, 0, cr, NULL) != 0) { 1040 error = EPERM; 1041 goto out; 1042 } 1043 1044 secpolicy_fs_mount_clearopts(cr, vfsp); 1045 } else { 1046 goto out; 1047 } 1048 } 1049 1050 /* 1051 * Refuse to mount a filesystem if we are in a local zone and the 1052 * dataset is not visible. 1053 */ 1054 if (!INGLOBALZONE(curproc) && 1055 (!zone_dataset_visible(osname, &canwrite) || !canwrite)) { 1056 error = EPERM; 1057 goto out; 1058 } 1059 1060 /* 1061 * When doing a remount, we simply refresh our temporary properties 1062 * according to those options set in the current VFS options. 1063 */ 1064 if (uap->flags & MS_REMOUNT) { 1065 /* refresh mount options */ 1066 zfs_unregister_callbacks(vfsp->vfs_data); 1067 error = zfs_register_callbacks(vfsp); 1068 goto out; 1069 } 1070 1071 error = zfs_domount(vfsp, osname); 1072 1073 /* 1074 * Add an extra VFS_HOLD on our parent vfs so that it can't 1075 * disappear due to a forced unmount. 1076 */ 1077 if (((zfsvfs_t *)vfsp->vfs_data)->z_issnap) 1078 VFS_HOLD(mvp->v_vfsp); 1079 1080 out: 1081 pn_free(&spn); 1082 return (error); 1083 } 1084 1085 static int 1086 zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp) 1087 { 1088 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1089 dev32_t d32; 1090 uint64_t refdbytes, availbytes, usedobjs, availobjs; 1091 1092 ZFS_ENTER(zfsvfs); 1093 1094 dmu_objset_space(zfsvfs->z_os, 1095 &refdbytes, &availbytes, &usedobjs, &availobjs); 1096 1097 /* 1098 * The underlying storage pool actually uses multiple block sizes. 1099 * We report the fragsize as the smallest block size we support, 1100 * and we report our blocksize as the filesystem's maximum blocksize. 1101 */ 1102 statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT; 1103 statp->f_bsize = zfsvfs->z_max_blksz; 1104 1105 /* 1106 * The following report "total" blocks of various kinds in the 1107 * file system, but reported in terms of f_frsize - the 1108 * "fragment" size. 1109 */ 1110 1111 statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT; 1112 statp->f_bfree = availbytes >> SPA_MINBLOCKSHIFT; 1113 statp->f_bavail = statp->f_bfree; /* no root reservation */ 1114 1115 /* 1116 * statvfs() should really be called statufs(), because it assumes 1117 * static metadata. ZFS doesn't preallocate files, so the best 1118 * we can do is report the max that could possibly fit in f_files, 1119 * and that minus the number actually used in f_ffree. 1120 * For f_ffree, report the smaller of the number of object available 1121 * and the number of blocks (each object will take at least a block). 1122 */ 1123 statp->f_ffree = MIN(availobjs, statp->f_bfree); 1124 statp->f_favail = statp->f_ffree; /* no "root reservation" */ 1125 statp->f_files = statp->f_ffree + usedobjs; 1126 1127 (void) cmpldev(&d32, vfsp->vfs_dev); 1128 statp->f_fsid = d32; 1129 1130 /* 1131 * We're a zfs filesystem. 1132 */ 1133 (void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name); 1134 1135 statp->f_flag = vf_to_stf(vfsp->vfs_flag); 1136 1137 statp->f_namemax = ZFS_MAXNAMELEN; 1138 1139 /* 1140 * We have all of 32 characters to stuff a string here. 1141 * Is there anything useful we could/should provide? 1142 */ 1143 bzero(statp->f_fstr, sizeof (statp->f_fstr)); 1144 1145 ZFS_EXIT(zfsvfs); 1146 return (0); 1147 } 1148 1149 static int 1150 zfs_root(vfs_t *vfsp, vnode_t **vpp) 1151 { 1152 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1153 znode_t *rootzp; 1154 int error; 1155 1156 ZFS_ENTER(zfsvfs); 1157 1158 error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp); 1159 if (error == 0) 1160 *vpp = ZTOV(rootzp); 1161 1162 ZFS_EXIT(zfsvfs); 1163 return (error); 1164 } 1165 1166 /* 1167 * Teardown the zfsvfs::z_os. 1168 * 1169 * Note, if 'unmounting' if FALSE, we return with the 'z_teardown_lock' 1170 * and 'z_teardown_inactive_lock' held. 1171 */ 1172 static int 1173 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting) 1174 { 1175 znode_t *zp; 1176 1177 rrw_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG); 1178 1179 if (!unmounting) { 1180 /* 1181 * We purge the parent filesystem's vfsp as the parent 1182 * filesystem and all of its snapshots have their vnode's 1183 * v_vfsp set to the parent's filesystem's vfsp. Note, 1184 * 'z_parent' is self referential for non-snapshots. 1185 */ 1186 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0); 1187 } 1188 1189 /* 1190 * Close the zil. NB: Can't close the zil while zfs_inactive 1191 * threads are blocked as zil_close can call zfs_inactive. 1192 */ 1193 if (zfsvfs->z_log) { 1194 zil_close(zfsvfs->z_log); 1195 zfsvfs->z_log = NULL; 1196 } 1197 1198 rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER); 1199 1200 /* 1201 * If we are not unmounting (ie: online recv) and someone already 1202 * unmounted this file system while we were doing the switcheroo, 1203 * or a reopen of z_os failed then just bail out now. 1204 */ 1205 if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) { 1206 rw_exit(&zfsvfs->z_teardown_inactive_lock); 1207 rrw_exit(&zfsvfs->z_teardown_lock, FTAG); 1208 return (EIO); 1209 } 1210 1211 /* 1212 * At this point there are no vops active, and any new vops will 1213 * fail with EIO since we have z_teardown_lock for writer (only 1214 * relavent for forced unmount). 1215 * 1216 * Release all holds on dbufs. 1217 */ 1218 mutex_enter(&zfsvfs->z_znodes_lock); 1219 for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL; 1220 zp = list_next(&zfsvfs->z_all_znodes, zp)) 1221 if (zp->z_dbuf) { 1222 ASSERT(ZTOV(zp)->v_count > 0); 1223 zfs_znode_dmu_fini(zp); 1224 } 1225 mutex_exit(&zfsvfs->z_znodes_lock); 1226 1227 /* 1228 * If we are unmounting, set the unmounted flag and let new vops 1229 * unblock. zfs_inactive will have the unmounted behavior, and all 1230 * other vops will fail with EIO. 1231 */ 1232 if (unmounting) { 1233 zfsvfs->z_unmounted = B_TRUE; 1234 rrw_exit(&zfsvfs->z_teardown_lock, FTAG); 1235 rw_exit(&zfsvfs->z_teardown_inactive_lock); 1236 } 1237 1238 /* 1239 * z_os will be NULL if there was an error in attempting to reopen 1240 * zfsvfs, so just return as the properties had already been 1241 * unregistered and cached data had been evicted before. 1242 */ 1243 if (zfsvfs->z_os == NULL) 1244 return (0); 1245 1246 /* 1247 * Unregister properties. 1248 */ 1249 zfs_unregister_callbacks(zfsvfs); 1250 1251 /* 1252 * Evict cached data 1253 */ 1254 if (dmu_objset_evict_dbufs(zfsvfs->z_os)) { 1255 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0); 1256 (void) dmu_objset_evict_dbufs(zfsvfs->z_os); 1257 } 1258 1259 return (0); 1260 } 1261 1262 /*ARGSUSED*/ 1263 static int 1264 zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr) 1265 { 1266 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1267 objset_t *os; 1268 int ret; 1269 1270 ret = secpolicy_fs_unmount(cr, vfsp); 1271 if (ret) { 1272 ret = dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource), 1273 ZFS_DELEG_PERM_MOUNT, cr); 1274 if (ret) 1275 return (ret); 1276 } 1277 1278 /* 1279 * We purge the parent filesystem's vfsp as the parent filesystem 1280 * and all of its snapshots have their vnode's v_vfsp set to the 1281 * parent's filesystem's vfsp. Note, 'z_parent' is self 1282 * referential for non-snapshots. 1283 */ 1284 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0); 1285 1286 /* 1287 * Unmount any snapshots mounted under .zfs before unmounting the 1288 * dataset itself. 1289 */ 1290 if (zfsvfs->z_ctldir != NULL && 1291 (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) { 1292 return (ret); 1293 } 1294 1295 if (!(fflag & MS_FORCE)) { 1296 /* 1297 * Check the number of active vnodes in the file system. 1298 * Our count is maintained in the vfs structure, but the 1299 * number is off by 1 to indicate a hold on the vfs 1300 * structure itself. 1301 * 1302 * The '.zfs' directory maintains a reference of its 1303 * own, and any active references underneath are 1304 * reflected in the vnode count. 1305 */ 1306 if (zfsvfs->z_ctldir == NULL) { 1307 if (vfsp->vfs_count > 1) 1308 return (EBUSY); 1309 } else { 1310 if (vfsp->vfs_count > 2 || 1311 zfsvfs->z_ctldir->v_count > 1) 1312 return (EBUSY); 1313 } 1314 } 1315 1316 vfsp->vfs_flag |= VFS_UNMOUNTED; 1317 1318 VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0); 1319 os = zfsvfs->z_os; 1320 1321 /* 1322 * z_os will be NULL if there was an error in 1323 * attempting to reopen zfsvfs. 1324 */ 1325 if (os != NULL) { 1326 /* 1327 * Unset the objset user_ptr. 1328 */ 1329 mutex_enter(&os->os->os_user_ptr_lock); 1330 dmu_objset_set_user(os, NULL); 1331 mutex_exit(&os->os->os_user_ptr_lock); 1332 1333 /* 1334 * Finally release the objset 1335 */ 1336 dmu_objset_close(os); 1337 } 1338 1339 /* 1340 * We can now safely destroy the '.zfs' directory node. 1341 */ 1342 if (zfsvfs->z_ctldir != NULL) 1343 zfsctl_destroy(zfsvfs); 1344 1345 return (0); 1346 } 1347 1348 static int 1349 zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 1350 { 1351 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1352 znode_t *zp; 1353 uint64_t object = 0; 1354 uint64_t fid_gen = 0; 1355 uint64_t gen_mask; 1356 uint64_t zp_gen; 1357 int i, err; 1358 1359 *vpp = NULL; 1360 1361 ZFS_ENTER(zfsvfs); 1362 1363 if (fidp->fid_len == LONG_FID_LEN) { 1364 zfid_long_t *zlfid = (zfid_long_t *)fidp; 1365 uint64_t objsetid = 0; 1366 uint64_t setgen = 0; 1367 1368 for (i = 0; i < sizeof (zlfid->zf_setid); i++) 1369 objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i); 1370 1371 for (i = 0; i < sizeof (zlfid->zf_setgen); i++) 1372 setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i); 1373 1374 ZFS_EXIT(zfsvfs); 1375 1376 err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs); 1377 if (err) 1378 return (EINVAL); 1379 ZFS_ENTER(zfsvfs); 1380 } 1381 1382 if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) { 1383 zfid_short_t *zfid = (zfid_short_t *)fidp; 1384 1385 for (i = 0; i < sizeof (zfid->zf_object); i++) 1386 object |= ((uint64_t)zfid->zf_object[i]) << (8 * i); 1387 1388 for (i = 0; i < sizeof (zfid->zf_gen); i++) 1389 fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i); 1390 } else { 1391 ZFS_EXIT(zfsvfs); 1392 return (EINVAL); 1393 } 1394 1395 /* A zero fid_gen means we are in the .zfs control directories */ 1396 if (fid_gen == 0 && 1397 (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) { 1398 *vpp = zfsvfs->z_ctldir; 1399 ASSERT(*vpp != NULL); 1400 if (object == ZFSCTL_INO_SNAPDIR) { 1401 VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL, 1402 0, NULL, NULL, NULL, NULL, NULL) == 0); 1403 } else { 1404 VN_HOLD(*vpp); 1405 } 1406 ZFS_EXIT(zfsvfs); 1407 return (0); 1408 } 1409 1410 gen_mask = -1ULL >> (64 - 8 * i); 1411 1412 dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask); 1413 if (err = zfs_zget(zfsvfs, object, &zp)) { 1414 ZFS_EXIT(zfsvfs); 1415 return (err); 1416 } 1417 zp_gen = zp->z_phys->zp_gen & gen_mask; 1418 if (zp_gen == 0) 1419 zp_gen = 1; 1420 if (zp->z_unlinked || zp_gen != fid_gen) { 1421 dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen); 1422 VN_RELE(ZTOV(zp)); 1423 ZFS_EXIT(zfsvfs); 1424 return (EINVAL); 1425 } 1426 1427 *vpp = ZTOV(zp); 1428 ZFS_EXIT(zfsvfs); 1429 return (0); 1430 } 1431 1432 /* 1433 * Block out VOPs and close zfsvfs_t::z_os 1434 * 1435 * Note, if successful, then we return with the 'z_teardown_lock' and 1436 * 'z_teardown_inactive_lock' write held. 1437 */ 1438 int 1439 zfs_suspend_fs(zfsvfs_t *zfsvfs, char *name, int *mode) 1440 { 1441 int error; 1442 1443 if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0) 1444 return (error); 1445 1446 *mode = zfsvfs->z_os->os_mode; 1447 dmu_objset_name(zfsvfs->z_os, name); 1448 dmu_objset_close(zfsvfs->z_os); 1449 1450 return (0); 1451 } 1452 1453 /* 1454 * Reopen zfsvfs_t::z_os and release VOPs. 1455 */ 1456 int 1457 zfs_resume_fs(zfsvfs_t *zfsvfs, const char *osname, int mode) 1458 { 1459 int err; 1460 1461 ASSERT(RRW_WRITE_HELD(&zfsvfs->z_teardown_lock)); 1462 ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock)); 1463 1464 err = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os); 1465 if (err) { 1466 zfsvfs->z_os = NULL; 1467 } else { 1468 znode_t *zp; 1469 1470 VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0); 1471 1472 /* 1473 * Attempt to re-establish all the active znodes with 1474 * their dbufs. If a zfs_rezget() fails, then we'll let 1475 * any potential callers discover that via ZFS_ENTER_VERIFY_VP 1476 * when they try to use their znode. 1477 */ 1478 mutex_enter(&zfsvfs->z_znodes_lock); 1479 for (zp = list_head(&zfsvfs->z_all_znodes); zp; 1480 zp = list_next(&zfsvfs->z_all_znodes, zp)) { 1481 (void) zfs_rezget(zp); 1482 } 1483 mutex_exit(&zfsvfs->z_znodes_lock); 1484 1485 } 1486 1487 /* release the VOPs */ 1488 rw_exit(&zfsvfs->z_teardown_inactive_lock); 1489 rrw_exit(&zfsvfs->z_teardown_lock, FTAG); 1490 1491 if (err) { 1492 /* 1493 * Since we couldn't reopen zfsvfs::z_os, force 1494 * unmount this file system. 1495 */ 1496 if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0) 1497 (void) dounmount(zfsvfs->z_vfs, MS_FORCE, CRED()); 1498 } 1499 return (err); 1500 } 1501 1502 static void 1503 zfs_freevfs(vfs_t *vfsp) 1504 { 1505 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1506 int i; 1507 1508 for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 1509 mutex_destroy(&zfsvfs->z_hold_mtx[i]); 1510 1511 zfs_fuid_destroy(zfsvfs); 1512 1513 /* 1514 * If this is a snapshot, we have an extra VFS_HOLD on our parent 1515 * from zfs_mount(). Release it here. 1516 */ 1517 if (zfsvfs->z_issnap) 1518 VFS_RELE(zfsvfs->z_parent->z_vfs); 1519 1520 zfs_freezfsvfs(zfsvfs); 1521 1522 atomic_add_32(&zfs_active_fs_count, -1); 1523 } 1524 1525 /* 1526 * VFS_INIT() initialization. Note that there is no VFS_FINI(), 1527 * so we can't safely do any non-idempotent initialization here. 1528 * Leave that to zfs_init() and zfs_fini(), which are called 1529 * from the module's _init() and _fini() entry points. 1530 */ 1531 /*ARGSUSED*/ 1532 static int 1533 zfs_vfsinit(int fstype, char *name) 1534 { 1535 int error; 1536 1537 zfsfstype = fstype; 1538 1539 /* 1540 * Setup vfsops and vnodeops tables. 1541 */ 1542 error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops); 1543 if (error != 0) { 1544 cmn_err(CE_WARN, "zfs: bad vfs ops template"); 1545 } 1546 1547 error = zfs_create_op_tables(); 1548 if (error) { 1549 zfs_remove_op_tables(); 1550 cmn_err(CE_WARN, "zfs: bad vnode ops template"); 1551 (void) vfs_freevfsops_by_type(zfsfstype); 1552 return (error); 1553 } 1554 1555 mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL); 1556 1557 /* 1558 * Unique major number for all zfs mounts. 1559 * If we run out of 32-bit minors, we'll getudev() another major. 1560 */ 1561 zfs_major = ddi_name_to_major(ZFS_DRIVER); 1562 zfs_minor = ZFS_MIN_MINOR; 1563 1564 return (0); 1565 } 1566 1567 void 1568 zfs_init(void) 1569 { 1570 /* 1571 * Initialize .zfs directory structures 1572 */ 1573 zfsctl_init(); 1574 1575 /* 1576 * Initialize znode cache, vnode ops, etc... 1577 */ 1578 zfs_znode_init(); 1579 } 1580 1581 void 1582 zfs_fini(void) 1583 { 1584 zfsctl_fini(); 1585 zfs_znode_fini(); 1586 } 1587 1588 int 1589 zfs_busy(void) 1590 { 1591 return (zfs_active_fs_count != 0); 1592 } 1593 1594 int 1595 zfs_set_version(const char *name, uint64_t newvers) 1596 { 1597 int error; 1598 objset_t *os; 1599 dmu_tx_t *tx; 1600 uint64_t curvers; 1601 1602 /* 1603 * XXX for now, require that the filesystem be unmounted. Would 1604 * be nice to find the zfsvfs_t and just update that if 1605 * possible. 1606 */ 1607 1608 if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION) 1609 return (EINVAL); 1610 1611 error = dmu_objset_open(name, DMU_OST_ZFS, DS_MODE_OWNER, &os); 1612 if (error) 1613 return (error); 1614 1615 error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR, 1616 8, 1, &curvers); 1617 if (error) 1618 goto out; 1619 if (newvers < curvers) { 1620 error = EINVAL; 1621 goto out; 1622 } 1623 1624 tx = dmu_tx_create(os); 1625 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, 0, ZPL_VERSION_STR); 1626 error = dmu_tx_assign(tx, TXG_WAIT); 1627 if (error) { 1628 dmu_tx_abort(tx); 1629 goto out; 1630 } 1631 error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR, 8, 1, 1632 &newvers, tx); 1633 1634 spa_history_internal_log(LOG_DS_UPGRADE, 1635 dmu_objset_spa(os), tx, CRED(), 1636 "oldver=%llu newver=%llu dataset = %llu", curvers, newvers, 1637 dmu_objset_id(os)); 1638 dmu_tx_commit(tx); 1639 1640 out: 1641 dmu_objset_close(os); 1642 return (error); 1643 } 1644 1645 /* 1646 * Read a property stored within the master node. 1647 */ 1648 int 1649 zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value) 1650 { 1651 const char *pname; 1652 int error = ENOENT; 1653 1654 /* 1655 * Look up the file system's value for the property. For the 1656 * version property, we look up a slightly different string. 1657 */ 1658 if (prop == ZFS_PROP_VERSION) 1659 pname = ZPL_VERSION_STR; 1660 else 1661 pname = zfs_prop_to_name(prop); 1662 1663 if (os != NULL) 1664 error = zap_lookup(os, MASTER_NODE_OBJ, pname, 8, 1, value); 1665 1666 if (error == ENOENT) { 1667 /* No value set, use the default value */ 1668 switch (prop) { 1669 case ZFS_PROP_VERSION: 1670 *value = ZPL_VERSION; 1671 break; 1672 case ZFS_PROP_NORMALIZE: 1673 case ZFS_PROP_UTF8ONLY: 1674 *value = 0; 1675 break; 1676 case ZFS_PROP_CASE: 1677 *value = ZFS_CASE_SENSITIVE; 1678 break; 1679 default: 1680 return (error); 1681 } 1682 error = 0; 1683 } 1684 return (error); 1685 } 1686 1687 static vfsdef_t vfw = { 1688 VFSDEF_VERSION, 1689 MNTTYPE_ZFS, 1690 zfs_vfsinit, 1691 VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_VOLATILEDEV|VSW_STATS| 1692 VSW_XID, 1693 &zfs_mntopts 1694 }; 1695 1696 struct modlfs zfs_modlfs = { 1697 &mod_fsops, "ZFS filesystem version " SPA_VERSION_STRING, &vfw 1698 }; 1699