/usr/src/uts/common/fs/zfs/zfs_vfsops.c
C | 2303 lines | 1503 code | 326 blank | 474 comment | 397 complexity | 93a155c7638877746adb1d04151f97bc MD5 | raw file
Large files files are truncated, but you can click here to view the full file
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) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25/* Portions Copyright 2010 Robert Milkowski */ 26 27#include <sys/types.h> 28#include <sys/param.h> 29#include <sys/systm.h> 30#include <sys/sysmacros.h> 31#include <sys/kmem.h> 32#include <sys/pathname.h> 33#include <sys/vnode.h> 34#include <sys/vfs.h> 35#include <sys/vfs_opreg.h> 36#include <sys/mntent.h> 37#include <sys/mount.h> 38#include <sys/cmn_err.h> 39#include "fs/fs_subr.h" 40#include <sys/zfs_znode.h> 41#include <sys/zfs_dir.h> 42#include <sys/zil.h> 43#include <sys/fs/zfs.h> 44#include <sys/dmu.h> 45#include <sys/dsl_prop.h> 46#include <sys/dsl_dataset.h> 47#include <sys/dsl_deleg.h> 48#include <sys/spa.h> 49#include <sys/zap.h> 50#include <sys/sa.h> 51#include <sys/varargs.h> 52#include <sys/policy.h> 53#include <sys/atomic.h> 54#include <sys/mkdev.h> 55#include <sys/modctl.h> 56#include <sys/refstr.h> 57#include <sys/zfs_ioctl.h> 58#include <sys/zfs_ctldir.h> 59#include <sys/zfs_fuid.h> 60#include <sys/bootconf.h> 61#include <sys/sunddi.h> 62#include <sys/dnlc.h> 63#include <sys/dmu_objset.h> 64#include <sys/spa_boot.h> 65#include <sys/sa.h> 66#include "zfs_comutil.h" 67 68int zfsfstype; 69vfsops_t *zfs_vfsops = NULL; 70static major_t zfs_major; 71static minor_t zfs_minor; 72static kmutex_t zfs_dev_mtx; 73 74extern int sys_shutdown; 75 76static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr); 77static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr); 78static int zfs_mountroot(vfs_t *vfsp, enum whymountroot); 79static int zfs_root(vfs_t *vfsp, vnode_t **vpp); 80static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp); 81static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp); 82static void zfs_freevfs(vfs_t *vfsp); 83 84static const fs_operation_def_t zfs_vfsops_template[] = { 85 VFSNAME_MOUNT, { .vfs_mount = zfs_mount }, 86 VFSNAME_MOUNTROOT, { .vfs_mountroot = zfs_mountroot }, 87 VFSNAME_UNMOUNT, { .vfs_unmount = zfs_umount }, 88 VFSNAME_ROOT, { .vfs_root = zfs_root }, 89 VFSNAME_STATVFS, { .vfs_statvfs = zfs_statvfs }, 90 VFSNAME_SYNC, { .vfs_sync = zfs_sync }, 91 VFSNAME_VGET, { .vfs_vget = zfs_vget }, 92 VFSNAME_FREEVFS, { .vfs_freevfs = zfs_freevfs }, 93 NULL, NULL 94}; 95 96static const fs_operation_def_t zfs_vfsops_eio_template[] = { 97 VFSNAME_FREEVFS, { .vfs_freevfs = zfs_freevfs }, 98 NULL, NULL 99}; 100 101/* 102 * We need to keep a count of active fs's. 103 * This is necessary to prevent our module 104 * from being unloaded after a umount -f 105 */ 106static uint32_t zfs_active_fs_count = 0; 107 108static char *noatime_cancel[] = { MNTOPT_ATIME, NULL }; 109static char *atime_cancel[] = { MNTOPT_NOATIME, NULL }; 110static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL }; 111static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL }; 112 113/* 114 * MO_DEFAULT is not used since the default value is determined 115 * by the equivalent property. 116 */ 117static mntopt_t mntopts[] = { 118 { MNTOPT_NOXATTR, noxattr_cancel, NULL, 0, NULL }, 119 { MNTOPT_XATTR, xattr_cancel, NULL, 0, NULL }, 120 { MNTOPT_NOATIME, noatime_cancel, NULL, 0, NULL }, 121 { MNTOPT_ATIME, atime_cancel, NULL, 0, NULL } 122}; 123 124static mntopts_t zfs_mntopts = { 125 sizeof (mntopts) / sizeof (mntopt_t), 126 mntopts 127}; 128 129/*ARGSUSED*/ 130int 131zfs_sync(vfs_t *vfsp, short flag, cred_t *cr) 132{ 133 /* 134 * Data integrity is job one. We don't want a compromised kernel 135 * writing to the storage pool, so we never sync during panic. 136 */ 137 if (panicstr) 138 return (0); 139 140 /* 141 * SYNC_ATTR is used by fsflush() to force old filesystems like UFS 142 * to sync metadata, which they would otherwise cache indefinitely. 143 * Semantically, the only requirement is that the sync be initiated. 144 * The DMU syncs out txgs frequently, so there's nothing to do. 145 */ 146 if (flag & SYNC_ATTR) 147 return (0); 148 149 if (vfsp != NULL) { 150 /* 151 * Sync a specific filesystem. 152 */ 153 zfsvfs_t *zfsvfs = vfsp->vfs_data; 154 dsl_pool_t *dp; 155 156 ZFS_ENTER(zfsvfs); 157 dp = dmu_objset_pool(zfsvfs->z_os); 158 159 /* 160 * If the system is shutting down, then skip any 161 * filesystems which may exist on a suspended pool. 162 */ 163 if (sys_shutdown && spa_suspended(dp->dp_spa)) { 164 ZFS_EXIT(zfsvfs); 165 return (0); 166 } 167 168 if (zfsvfs->z_log != NULL) 169 zil_commit(zfsvfs->z_log, 0); 170 171 ZFS_EXIT(zfsvfs); 172 } else { 173 /* 174 * Sync all ZFS filesystems. This is what happens when you 175 * run sync(1M). Unlike other filesystems, ZFS honors the 176 * request by waiting for all pools to commit all dirty data. 177 */ 178 spa_sync_allpools(); 179 } 180 181 return (0); 182} 183 184static int 185zfs_create_unique_device(dev_t *dev) 186{ 187 major_t new_major; 188 189 do { 190 ASSERT3U(zfs_minor, <=, MAXMIN32); 191 minor_t start = zfs_minor; 192 do { 193 mutex_enter(&zfs_dev_mtx); 194 if (zfs_minor >= MAXMIN32) { 195 /* 196 * If we're still using the real major 197 * keep out of /dev/zfs and /dev/zvol minor 198 * number space. If we're using a getudev()'ed 199 * major number, we can use all of its minors. 200 */ 201 if (zfs_major == ddi_name_to_major(ZFS_DRIVER)) 202 zfs_minor = ZFS_MIN_MINOR; 203 else 204 zfs_minor = 0; 205 } else { 206 zfs_minor++; 207 } 208 *dev = makedevice(zfs_major, zfs_minor); 209 mutex_exit(&zfs_dev_mtx); 210 } while (vfs_devismounted(*dev) && zfs_minor != start); 211 if (zfs_minor == start) { 212 /* 213 * We are using all ~262,000 minor numbers for the 214 * current major number. Create a new major number. 215 */ 216 if ((new_major = getudev()) == (major_t)-1) { 217 cmn_err(CE_WARN, 218 "zfs_mount: Can't get unique major " 219 "device number."); 220 return (-1); 221 } 222 mutex_enter(&zfs_dev_mtx); 223 zfs_major = new_major; 224 zfs_minor = 0; 225 226 mutex_exit(&zfs_dev_mtx); 227 } else { 228 break; 229 } 230 /* CONSTANTCONDITION */ 231 } while (1); 232 233 return (0); 234} 235 236static void 237atime_changed_cb(void *arg, uint64_t newval) 238{ 239 zfsvfs_t *zfsvfs = arg; 240 241 if (newval == TRUE) { 242 zfsvfs->z_atime = TRUE; 243 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME); 244 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0); 245 } else { 246 zfsvfs->z_atime = FALSE; 247 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME); 248 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0); 249 } 250} 251 252static void 253xattr_changed_cb(void *arg, uint64_t newval) 254{ 255 zfsvfs_t *zfsvfs = arg; 256 257 if (newval == TRUE) { 258 /* XXX locking on vfs_flag? */ 259 zfsvfs->z_vfs->vfs_flag |= VFS_XATTR; 260 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR); 261 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0); 262 } else { 263 /* XXX locking on vfs_flag? */ 264 zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR; 265 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR); 266 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0); 267 } 268} 269 270static void 271blksz_changed_cb(void *arg, uint64_t newval) 272{ 273 zfsvfs_t *zfsvfs = arg; 274 275 if (newval < SPA_MINBLOCKSIZE || 276 newval > SPA_MAXBLOCKSIZE || !ISP2(newval)) 277 newval = SPA_MAXBLOCKSIZE; 278 279 zfsvfs->z_max_blksz = newval; 280 zfsvfs->z_vfs->vfs_bsize = newval; 281} 282 283static void 284readonly_changed_cb(void *arg, uint64_t newval) 285{ 286 zfsvfs_t *zfsvfs = arg; 287 288 if (newval) { 289 /* XXX locking on vfs_flag? */ 290 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY; 291 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW); 292 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0); 293 } else { 294 /* XXX locking on vfs_flag? */ 295 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY; 296 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO); 297 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0); 298 } 299} 300 301static void 302devices_changed_cb(void *arg, uint64_t newval) 303{ 304 zfsvfs_t *zfsvfs = arg; 305 306 if (newval == FALSE) { 307 zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES; 308 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES); 309 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0); 310 } else { 311 zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES; 312 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES); 313 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0); 314 } 315} 316 317static void 318setuid_changed_cb(void *arg, uint64_t newval) 319{ 320 zfsvfs_t *zfsvfs = arg; 321 322 if (newval == FALSE) { 323 zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID; 324 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID); 325 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0); 326 } else { 327 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID; 328 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID); 329 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0); 330 } 331} 332 333static void 334exec_changed_cb(void *arg, uint64_t newval) 335{ 336 zfsvfs_t *zfsvfs = arg; 337 338 if (newval == FALSE) { 339 zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC; 340 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC); 341 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0); 342 } else { 343 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC; 344 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC); 345 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0); 346 } 347} 348 349/* 350 * The nbmand mount option can be changed at mount time. 351 * We can't allow it to be toggled on live file systems or incorrect 352 * behavior may be seen from cifs clients 353 * 354 * This property isn't registered via dsl_prop_register(), but this callback 355 * will be called when a file system is first mounted 356 */ 357static void 358nbmand_changed_cb(void *arg, uint64_t newval) 359{ 360 zfsvfs_t *zfsvfs = arg; 361 if (newval == FALSE) { 362 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND); 363 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0); 364 } else { 365 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND); 366 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0); 367 } 368} 369 370static void 371snapdir_changed_cb(void *arg, uint64_t newval) 372{ 373 zfsvfs_t *zfsvfs = arg; 374 375 zfsvfs->z_show_ctldir = newval; 376} 377 378static void 379vscan_changed_cb(void *arg, uint64_t newval) 380{ 381 zfsvfs_t *zfsvfs = arg; 382 383 zfsvfs->z_vscan = newval; 384} 385 386static void 387acl_inherit_changed_cb(void *arg, uint64_t newval) 388{ 389 zfsvfs_t *zfsvfs = arg; 390 391 zfsvfs->z_acl_inherit = newval; 392} 393 394static int 395zfs_register_callbacks(vfs_t *vfsp) 396{ 397 struct dsl_dataset *ds = NULL; 398 objset_t *os = NULL; 399 zfsvfs_t *zfsvfs = NULL; 400 uint64_t nbmand; 401 int readonly, do_readonly = B_FALSE; 402 int setuid, do_setuid = B_FALSE; 403 int exec, do_exec = B_FALSE; 404 int devices, do_devices = B_FALSE; 405 int xattr, do_xattr = B_FALSE; 406 int atime, do_atime = B_FALSE; 407 int error = 0; 408 409 ASSERT(vfsp); 410 zfsvfs = vfsp->vfs_data; 411 ASSERT(zfsvfs); 412 os = zfsvfs->z_os; 413 414 /* 415 * The act of registering our callbacks will destroy any mount 416 * options we may have. In order to enable temporary overrides 417 * of mount options, we stash away the current values and 418 * restore them after we register the callbacks. 419 */ 420 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL) || 421 !spa_writeable(dmu_objset_spa(os))) { 422 readonly = B_TRUE; 423 do_readonly = B_TRUE; 424 } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) { 425 readonly = B_FALSE; 426 do_readonly = B_TRUE; 427 } 428 if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) { 429 devices = B_FALSE; 430 setuid = B_FALSE; 431 do_devices = B_TRUE; 432 do_setuid = B_TRUE; 433 } else { 434 if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) { 435 devices = B_FALSE; 436 do_devices = B_TRUE; 437 } else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) { 438 devices = B_TRUE; 439 do_devices = B_TRUE; 440 } 441 442 if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) { 443 setuid = B_FALSE; 444 do_setuid = B_TRUE; 445 } else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) { 446 setuid = B_TRUE; 447 do_setuid = B_TRUE; 448 } 449 } 450 if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) { 451 exec = B_FALSE; 452 do_exec = B_TRUE; 453 } else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) { 454 exec = B_TRUE; 455 do_exec = B_TRUE; 456 } 457 if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) { 458 xattr = B_FALSE; 459 do_xattr = B_TRUE; 460 } else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) { 461 xattr = B_TRUE; 462 do_xattr = B_TRUE; 463 } 464 if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) { 465 atime = B_FALSE; 466 do_atime = B_TRUE; 467 } else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) { 468 atime = B_TRUE; 469 do_atime = B_TRUE; 470 } 471 472 /* 473 * nbmand is a special property. It can only be changed at 474 * mount time. 475 * 476 * This is weird, but it is documented to only be changeable 477 * at mount time. 478 */ 479 if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) { 480 nbmand = B_FALSE; 481 } else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) { 482 nbmand = B_TRUE; 483 } else { 484 char osname[MAXNAMELEN]; 485 486 dmu_objset_name(os, osname); 487 if (error = dsl_prop_get_integer(osname, "nbmand", &nbmand, 488 NULL)) { 489 return (error); 490 } 491 } 492 493 /* 494 * Register property callbacks. 495 * 496 * It would probably be fine to just check for i/o error from 497 * the first prop_register(), but I guess I like to go 498 * overboard... 499 */ 500 ds = dmu_objset_ds(os); 501 error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs); 502 error = error ? error : dsl_prop_register(ds, 503 "xattr", xattr_changed_cb, zfsvfs); 504 error = error ? error : dsl_prop_register(ds, 505 "recordsize", blksz_changed_cb, zfsvfs); 506 error = error ? error : dsl_prop_register(ds, 507 "readonly", readonly_changed_cb, zfsvfs); 508 error = error ? error : dsl_prop_register(ds, 509 "devices", devices_changed_cb, zfsvfs); 510 error = error ? error : dsl_prop_register(ds, 511 "setuid", setuid_changed_cb, zfsvfs); 512 error = error ? error : dsl_prop_register(ds, 513 "exec", exec_changed_cb, zfsvfs); 514 error = error ? error : dsl_prop_register(ds, 515 "snapdir", snapdir_changed_cb, zfsvfs); 516 error = error ? error : dsl_prop_register(ds, 517 "aclinherit", acl_inherit_changed_cb, zfsvfs); 518 error = error ? error : dsl_prop_register(ds, 519 "vscan", vscan_changed_cb, zfsvfs); 520 if (error) 521 goto unregister; 522 523 /* 524 * Invoke our callbacks to restore temporary mount options. 525 */ 526 if (do_readonly) 527 readonly_changed_cb(zfsvfs, readonly); 528 if (do_setuid) 529 setuid_changed_cb(zfsvfs, setuid); 530 if (do_exec) 531 exec_changed_cb(zfsvfs, exec); 532 if (do_devices) 533 devices_changed_cb(zfsvfs, devices); 534 if (do_xattr) 535 xattr_changed_cb(zfsvfs, xattr); 536 if (do_atime) 537 atime_changed_cb(zfsvfs, atime); 538 539 nbmand_changed_cb(zfsvfs, nbmand); 540 541 return (0); 542 543unregister: 544 /* 545 * We may attempt to unregister some callbacks that are not 546 * registered, but this is OK; it will simply return ENOMSG, 547 * which we will ignore. 548 */ 549 (void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs); 550 (void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zfsvfs); 551 (void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs); 552 (void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs); 553 (void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs); 554 (void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs); 555 (void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs); 556 (void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs); 557 (void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb, 558 zfsvfs); 559 (void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zfsvfs); 560 return (error); 561 562} 563 564static int 565zfs_space_delta_cb(dmu_object_type_t bonustype, void *data, 566 uint64_t *userp, uint64_t *groupp) 567{ 568 znode_phys_t *znp = data; 569 int error = 0; 570 571 /* 572 * Is it a valid type of object to track? 573 */ 574 if (bonustype != DMU_OT_ZNODE && bonustype != DMU_OT_SA) 575 return (ENOENT); 576 577 /* 578 * If we have a NULL data pointer 579 * then assume the id's aren't changing and 580 * return EEXIST to the dmu to let it know to 581 * use the same ids 582 */ 583 if (data == NULL) 584 return (EEXIST); 585 586 if (bonustype == DMU_OT_ZNODE) { 587 *userp = znp->zp_uid; 588 *groupp = znp->zp_gid; 589 } else { 590 int hdrsize; 591 592 ASSERT(bonustype == DMU_OT_SA); 593 hdrsize = sa_hdrsize(data); 594 595 if (hdrsize != 0) { 596 *userp = *((uint64_t *)((uintptr_t)data + hdrsize + 597 SA_UID_OFFSET)); 598 *groupp = *((uint64_t *)((uintptr_t)data + hdrsize + 599 SA_GID_OFFSET)); 600 } else { 601 /* 602 * This should only happen for newly created 603 * files that haven't had the znode data filled 604 * in yet. 605 */ 606 *userp = 0; 607 *groupp = 0; 608 } 609 } 610 return (error); 611} 612 613static void 614fuidstr_to_sid(zfsvfs_t *zfsvfs, const char *fuidstr, 615 char *domainbuf, int buflen, uid_t *ridp) 616{ 617 uint64_t fuid; 618 const char *domain; 619 620 fuid = strtonum(fuidstr, NULL); 621 622 domain = zfs_fuid_find_by_idx(zfsvfs, FUID_INDEX(fuid)); 623 if (domain) 624 (void) strlcpy(domainbuf, domain, buflen); 625 else 626 domainbuf[0] = '\0'; 627 *ridp = FUID_RID(fuid); 628} 629 630static uint64_t 631zfs_userquota_prop_to_obj(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type) 632{ 633 switch (type) { 634 case ZFS_PROP_USERUSED: 635 return (DMU_USERUSED_OBJECT); 636 case ZFS_PROP_GROUPUSED: 637 return (DMU_GROUPUSED_OBJECT); 638 case ZFS_PROP_USERQUOTA: 639 return (zfsvfs->z_userquota_obj); 640 case ZFS_PROP_GROUPQUOTA: 641 return (zfsvfs->z_groupquota_obj); 642 } 643 return (0); 644} 645 646int 647zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type, 648 uint64_t *cookiep, void *vbuf, uint64_t *bufsizep) 649{ 650 int error; 651 zap_cursor_t zc; 652 zap_attribute_t za; 653 zfs_useracct_t *buf = vbuf; 654 uint64_t obj; 655 656 if (!dmu_objset_userspace_present(zfsvfs->z_os)) 657 return (ENOTSUP); 658 659 obj = zfs_userquota_prop_to_obj(zfsvfs, type); 660 if (obj == 0) { 661 *bufsizep = 0; 662 return (0); 663 } 664 665 for (zap_cursor_init_serialized(&zc, zfsvfs->z_os, obj, *cookiep); 666 (error = zap_cursor_retrieve(&zc, &za)) == 0; 667 zap_cursor_advance(&zc)) { 668 if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) > 669 *bufsizep) 670 break; 671 672 fuidstr_to_sid(zfsvfs, za.za_name, 673 buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid); 674 675 buf->zu_space = za.za_first_integer; 676 buf++; 677 } 678 if (error == ENOENT) 679 error = 0; 680 681 ASSERT3U((uintptr_t)buf - (uintptr_t)vbuf, <=, *bufsizep); 682 *bufsizep = (uintptr_t)buf - (uintptr_t)vbuf; 683 *cookiep = zap_cursor_serialize(&zc); 684 zap_cursor_fini(&zc); 685 return (error); 686} 687 688/* 689 * buf must be big enough (eg, 32 bytes) 690 */ 691static int 692id_to_fuidstr(zfsvfs_t *zfsvfs, const char *domain, uid_t rid, 693 char *buf, boolean_t addok) 694{ 695 uint64_t fuid; 696 int domainid = 0; 697 698 if (domain && domain[0]) { 699 domainid = zfs_fuid_find_by_domain(zfsvfs, domain, NULL, addok); 700 if (domainid == -1) 701 return (ENOENT); 702 } 703 fuid = FUID_ENCODE(domainid, rid); 704 (void) sprintf(buf, "%llx", (longlong_t)fuid); 705 return (0); 706} 707 708int 709zfs_userspace_one(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type, 710 const char *domain, uint64_t rid, uint64_t *valp) 711{ 712 char buf[32]; 713 int err; 714 uint64_t obj; 715 716 *valp = 0; 717 718 if (!dmu_objset_userspace_present(zfsvfs->z_os)) 719 return (ENOTSUP); 720 721 obj = zfs_userquota_prop_to_obj(zfsvfs, type); 722 if (obj == 0) 723 return (0); 724 725 err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_FALSE); 726 if (err) 727 return (err); 728 729 err = zap_lookup(zfsvfs->z_os, obj, buf, 8, 1, valp); 730 if (err == ENOENT) 731 err = 0; 732 return (err); 733} 734 735int 736zfs_set_userquota(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type, 737 const char *domain, uint64_t rid, uint64_t quota) 738{ 739 char buf[32]; 740 int err; 741 dmu_tx_t *tx; 742 uint64_t *objp; 743 boolean_t fuid_dirtied; 744 745 if (type != ZFS_PROP_USERQUOTA && type != ZFS_PROP_GROUPQUOTA) 746 return (EINVAL); 747 748 if (zfsvfs->z_version < ZPL_VERSION_USERSPACE) 749 return (ENOTSUP); 750 751 objp = (type == ZFS_PROP_USERQUOTA) ? &zfsvfs->z_userquota_obj : 752 &zfsvfs->z_groupquota_obj; 753 754 err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_TRUE); 755 if (err) 756 return (err); 757 fuid_dirtied = zfsvfs->z_fuid_dirty; 758 759 tx = dmu_tx_create(zfsvfs->z_os); 760 dmu_tx_hold_zap(tx, *objp ? *objp : DMU_NEW_OBJECT, B_TRUE, NULL); 761 if (*objp == 0) { 762 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE, 763 zfs_userquota_prop_prefixes[type]); 764 } 765 if (fuid_dirtied) 766 zfs_fuid_txhold(zfsvfs, tx); 767 err = dmu_tx_assign(tx, TXG_WAIT); 768 if (err) { 769 dmu_tx_abort(tx); 770 return (err); 771 } 772 773 mutex_enter(&zfsvfs->z_lock); 774 if (*objp == 0) { 775 *objp = zap_create(zfsvfs->z_os, DMU_OT_USERGROUP_QUOTA, 776 DMU_OT_NONE, 0, tx); 777 VERIFY(0 == zap_add(zfsvfs->z_os, MASTER_NODE_OBJ, 778 zfs_userquota_prop_prefixes[type], 8, 1, objp, tx)); 779 } 780 mutex_exit(&zfsvfs->z_lock); 781 782 if (quota == 0) { 783 err = zap_remove(zfsvfs->z_os, *objp, buf, tx); 784 if (err == ENOENT) 785 err = 0; 786 } else { 787 err = zap_update(zfsvfs->z_os, *objp, buf, 8, 1, "a, tx); 788 } 789 ASSERT(err == 0); 790 if (fuid_dirtied) 791 zfs_fuid_sync(zfsvfs, tx); 792 dmu_tx_commit(tx); 793 return (err); 794} 795 796boolean_t 797zfs_fuid_overquota(zfsvfs_t *zfsvfs, boolean_t isgroup, uint64_t fuid) 798{ 799 char buf[32]; 800 uint64_t used, quota, usedobj, quotaobj; 801 int err; 802 803 usedobj = isgroup ? DMU_GROUPUSED_OBJECT : DMU_USERUSED_OBJECT; 804 quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj; 805 806 if (quotaobj == 0 || zfsvfs->z_replay) 807 return (B_FALSE); 808 809 (void) sprintf(buf, "%llx", (longlong_t)fuid); 810 err = zap_lookup(zfsvfs->z_os, quotaobj, buf, 8, 1, "a); 811 if (err != 0) 812 return (B_FALSE); 813 814 err = zap_lookup(zfsvfs->z_os, usedobj, buf, 8, 1, &used); 815 if (err != 0) 816 return (B_FALSE); 817 return (used >= quota); 818} 819 820boolean_t 821zfs_owner_overquota(zfsvfs_t *zfsvfs, znode_t *zp, boolean_t isgroup) 822{ 823 uint64_t fuid; 824 uint64_t quotaobj; 825 826 quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj; 827 828 fuid = isgroup ? zp->z_gid : zp->z_uid; 829 830 if (quotaobj == 0 || zfsvfs->z_replay) 831 return (B_FALSE); 832 833 return (zfs_fuid_overquota(zfsvfs, isgroup, fuid)); 834} 835 836int 837zfsvfs_create(const char *osname, zfsvfs_t **zfvp) 838{ 839 objset_t *os; 840 zfsvfs_t *zfsvfs; 841 uint64_t zval; 842 int i, error; 843 uint64_t sa_obj; 844 845 zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP); 846 847 /* 848 * We claim to always be readonly so we can open snapshots; 849 * other ZPL code will prevent us from writing to snapshots. 850 */ 851 error = dmu_objset_own(osname, DMU_OST_ZFS, B_TRUE, zfsvfs, &os); 852 if (error) { 853 kmem_free(zfsvfs, sizeof (zfsvfs_t)); 854 return (error); 855 } 856 857 /* 858 * Initialize the zfs-specific filesystem structure. 859 * Should probably make this a kmem cache, shuffle fields, 860 * and just bzero up to z_hold_mtx[]. 861 */ 862 zfsvfs->z_vfs = NULL; 863 zfsvfs->z_parent = zfsvfs; 864 zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE; 865 zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE; 866 zfsvfs->z_os = os; 867 868 error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version); 869 if (error) { 870 goto out; 871 } else if (zfsvfs->z_version > 872 zfs_zpl_version_map(spa_version(dmu_objset_spa(os)))) { 873 (void) printf("Can't mount a version %lld file system " 874 "on a version %lld pool\n. Pool must be upgraded to mount " 875 "this file system.", (u_longlong_t)zfsvfs->z_version, 876 (u_longlong_t)spa_version(dmu_objset_spa(os))); 877 error = ENOTSUP; 878 goto out; 879 } 880 if ((error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &zval)) != 0) 881 goto out; 882 zfsvfs->z_norm = (int)zval; 883 884 if ((error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &zval)) != 0) 885 goto out; 886 zfsvfs->z_utf8 = (zval != 0); 887 888 if ((error = zfs_get_zplprop(os, ZFS_PROP_CASE, &zval)) != 0) 889 goto out; 890 zfsvfs->z_case = (uint_t)zval; 891 892 /* 893 * Fold case on file systems that are always or sometimes case 894 * insensitive. 895 */ 896 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE || 897 zfsvfs->z_case == ZFS_CASE_MIXED) 898 zfsvfs->z_norm |= U8_TEXTPREP_TOUPPER; 899 900 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os); 901 zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os); 902 903 if (zfsvfs->z_use_sa) { 904 /* should either have both of these objects or none */ 905 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1, 906 &sa_obj); 907 if (error) 908 return (error); 909 } else { 910 /* 911 * Pre SA versions file systems should never touch 912 * either the attribute registration or layout objects. 913 */ 914 sa_obj = 0; 915 } 916 917 error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END, 918 &zfsvfs->z_attr_table); 919 if (error) 920 goto out; 921 922 if (zfsvfs->z_version >= ZPL_VERSION_SA) 923 sa_register_update_callback(os, zfs_sa_upgrade); 924 925 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, 926 &zfsvfs->z_root); 927 if (error) 928 goto out; 929 ASSERT(zfsvfs->z_root != 0); 930 931 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1, 932 &zfsvfs->z_unlinkedobj); 933 if (error) 934 goto out; 935 936 error = zap_lookup(os, MASTER_NODE_OBJ, 937 zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA], 938 8, 1, &zfsvfs->z_userquota_obj); 939 if (error && error != ENOENT) 940 goto out; 941 942 error = zap_lookup(os, MASTER_NODE_OBJ, 943 zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA], 944 8, 1, &zfsvfs->z_groupquota_obj); 945 if (error && error != ENOENT) 946 goto out; 947 948 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES, 8, 1, 949 &zfsvfs->z_fuid_obj); 950 if (error && error != ENOENT) 951 goto out; 952 953 error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SHARES_DIR, 8, 1, 954 &zfsvfs->z_shares_dir); 955 if (error && error != ENOENT) 956 goto out; 957 958 mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 959 mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL); 960 list_create(&zfsvfs->z_all_znodes, sizeof (znode_t), 961 offsetof(znode_t, z_link_node)); 962 rrw_init(&zfsvfs->z_teardown_lock); 963 rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL); 964 rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL); 965 for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 966 mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL); 967 968 *zfvp = zfsvfs; 969 return (0); 970 971out: 972 dmu_objset_disown(os, zfsvfs); 973 *zfvp = NULL; 974 kmem_free(zfsvfs, sizeof (zfsvfs_t)); 975 return (error); 976} 977 978static int 979zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting) 980{ 981 int error; 982 983 error = zfs_register_callbacks(zfsvfs->z_vfs); 984 if (error) 985 return (error); 986 987 /* 988 * Set the objset user_ptr to track its zfsvfs. 989 */ 990 mutex_enter(&zfsvfs->z_os->os_user_ptr_lock); 991 dmu_objset_set_user(zfsvfs->z_os, zfsvfs); 992 mutex_exit(&zfsvfs->z_os->os_user_ptr_lock); 993 994 zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data); 995 996 /* 997 * If we are not mounting (ie: online recv), then we don't 998 * have to worry about replaying the log as we blocked all 999 * operations out since we closed the ZIL. 1000 */ 1001 if (mounting) { 1002 boolean_t readonly; 1003 1004 /* 1005 * During replay we remove the read only flag to 1006 * allow replays to succeed. 1007 */ 1008 readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY; 1009 if (readonly != 0) 1010 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY; 1011 else 1012 zfs_unlinked_drain(zfsvfs); 1013 1014 /* 1015 * Parse and replay the intent log. 1016 * 1017 * Because of ziltest, this must be done after 1018 * zfs_unlinked_drain(). (Further note: ziltest 1019 * doesn't use readonly mounts, where 1020 * zfs_unlinked_drain() isn't called.) This is because 1021 * ziltest causes spa_sync() to think it's committed, 1022 * but actually it is not, so the intent log contains 1023 * many txg's worth of changes. 1024 * 1025 * In particular, if object N is in the unlinked set in 1026 * the last txg to actually sync, then it could be 1027 * actually freed in a later txg and then reallocated 1028 * in a yet later txg. This would write a "create 1029 * object N" record to the intent log. Normally, this 1030 * would be fine because the spa_sync() would have 1031 * written out the fact that object N is free, before 1032 * we could write the "create object N" intent log 1033 * record. 1034 * 1035 * But when we are in ziltest mode, we advance the "open 1036 * txg" without actually spa_sync()-ing the changes to 1037 * disk. So we would see that object N is still 1038 * allocated and in the unlinked set, and there is an 1039 * intent log record saying to allocate it. 1040 */ 1041 if (spa_writeable(dmu_objset_spa(zfsvfs->z_os))) { 1042 if (zil_replay_disable) { 1043 zil_destroy(zfsvfs->z_log, B_FALSE); 1044 } else { 1045 zfsvfs->z_replay = B_TRUE; 1046 zil_replay(zfsvfs->z_os, zfsvfs, 1047 zfs_replay_vector); 1048 zfsvfs->z_replay = B_FALSE; 1049 } 1050 } 1051 zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */ 1052 } 1053 1054 return (0); 1055} 1056 1057void 1058zfsvfs_free(zfsvfs_t *zfsvfs) 1059{ 1060 int i; 1061 extern krwlock_t zfsvfs_lock; /* in zfs_znode.c */ 1062 1063 /* 1064 * This is a barrier to prevent the filesystem from going away in 1065 * zfs_znode_move() until we can safely ensure that the filesystem is 1066 * not unmounted. We consider the filesystem valid before the barrier 1067 * and invalid after the barrier. 1068 */ 1069 rw_enter(&zfsvfs_lock, RW_READER); 1070 rw_exit(&zfsvfs_lock); 1071 1072 zfs_fuid_destroy(zfsvfs); 1073 1074 mutex_destroy(&zfsvfs->z_znodes_lock); 1075 mutex_destroy(&zfsvfs->z_lock); 1076 list_destroy(&zfsvfs->z_all_znodes); 1077 rrw_destroy(&zfsvfs->z_teardown_lock); 1078 rw_destroy(&zfsvfs->z_teardown_inactive_lock); 1079 rw_destroy(&zfsvfs->z_fuid_lock); 1080 for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 1081 mutex_destroy(&zfsvfs->z_hold_mtx[i]); 1082 kmem_free(zfsvfs, sizeof (zfsvfs_t)); 1083} 1084 1085static void 1086zfs_set_fuid_feature(zfsvfs_t *zfsvfs) 1087{ 1088 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os); 1089 if (zfsvfs->z_vfs) { 1090 if (zfsvfs->z_use_fuids) { 1091 vfs_set_feature(zfsvfs->z_vfs, VFSFT_XVATTR); 1092 vfs_set_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS); 1093 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS); 1094 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE); 1095 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER); 1096 vfs_set_feature(zfsvfs->z_vfs, VFSFT_REPARSE); 1097 } else { 1098 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_XVATTR); 1099 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS); 1100 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS); 1101 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE); 1102 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER); 1103 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_REPARSE); 1104 } 1105 } 1106 zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os); 1107} 1108 1109static int 1110zfs_domount(vfs_t *vfsp, char *osname) 1111{ 1112 dev_t mount_dev; 1113 uint64_t recordsize, fsid_guid; 1114 int error = 0; 1115 zfsvfs_t *zfsvfs; 1116 1117 ASSERT(vfsp); 1118 ASSERT(osname); 1119 1120 error = zfsvfs_create(osname, &zfsvfs); 1121 if (error) 1122 return (error); 1123 zfsvfs->z_vfs = vfsp; 1124 1125 /* Initialize the generic filesystem structure. */ 1126 vfsp->vfs_bcount = 0; 1127 vfsp->vfs_data = NULL; 1128 1129 if (zfs_create_unique_device(&mount_dev) == -1) { 1130 error = ENODEV; 1131 goto out; 1132 } 1133 ASSERT(vfs_devismounted(mount_dev) == 0); 1134 1135 if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize, 1136 NULL)) 1137 goto out; 1138 1139 vfsp->vfs_dev = mount_dev; 1140 vfsp->vfs_fstype = zfsfstype; 1141 vfsp->vfs_bsize = recordsize; 1142 vfsp->vfs_flag |= VFS_NOTRUNC; 1143 vfsp->vfs_data = zfsvfs; 1144 1145 /* 1146 * The fsid is 64 bits, composed of an 8-bit fs type, which 1147 * separates our fsid from any other filesystem types, and a 1148 * 56-bit objset unique ID. The objset unique ID is unique to 1149 * all objsets open on this system, provided by unique_create(). 1150 * The 8-bit fs type must be put in the low bits of fsid[1] 1151 * because that's where other Solaris filesystems put it. 1152 */ 1153 fsid_guid = dmu_objset_fsid_guid(zfsvfs->z_os); 1154 ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0); 1155 vfsp->vfs_fsid.val[0] = fsid_guid; 1156 vfsp->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) | 1157 zfsfstype & 0xFF; 1158 1159 /* 1160 * Set features for file system. 1161 */ 1162 zfs_set_fuid_feature(zfsvfs); 1163 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) { 1164 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS); 1165 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE); 1166 vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE); 1167 } else if (zfsvfs->z_case == ZFS_CASE_MIXED) { 1168 vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS); 1169 vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE); 1170 } 1171 vfs_set_feature(vfsp, VFSFT_ZEROCOPY_SUPPORTED); 1172 1173 if (dmu_objset_is_snapshot(zfsvfs->z_os)) { 1174 uint64_t pval; 1175 1176 atime_changed_cb(zfsvfs, B_FALSE); 1177 readonly_changed_cb(zfsvfs, B_TRUE); 1178 if (error = dsl_prop_get_integer(osname, "xattr", &pval, NULL)) 1179 goto out; 1180 xattr_changed_cb(zfsvfs, pval); 1181 zfsvfs->z_issnap = B_TRUE; 1182 zfsvfs->z_os->os_sync = ZFS_SYNC_DISABLED; 1183 1184 mutex_enter(&zfsvfs->z_os->os_user_ptr_lock); 1185 dmu_objset_set_user(zfsvfs->z_os, zfsvfs); 1186 mutex_exit(&zfsvfs->z_os->os_user_ptr_lock); 1187 } else { 1188 error = zfsvfs_setup(zfsvfs, B_TRUE); 1189 } 1190 1191 if (!zfsvfs->z_issnap) 1192 zfsctl_create(zfsvfs); 1193out: 1194 if (error) { 1195 dmu_objset_disown(zfsvfs->z_os, zfsvfs); 1196 zfsvfs_free(zfsvfs); 1197 } else { 1198 atomic_add_32(&zfs_active_fs_count, 1); 1199 } 1200 1201 return (error); 1202} 1203 1204void 1205zfs_unregister_callbacks(zfsvfs_t *zfsvfs) 1206{ 1207 objset_t *os = zfsvfs->z_os; 1208 struct dsl_dataset *ds; 1209 1210 /* 1211 * Unregister properties. 1212 */ 1213 if (!dmu_objset_is_snapshot(os)) { 1214 ds = dmu_objset_ds(os); 1215 VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb, 1216 zfsvfs) == 0); 1217 1218 VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb, 1219 zfsvfs) == 0); 1220 1221 VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, 1222 zfsvfs) == 0); 1223 1224 VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb, 1225 zfsvfs) == 0); 1226 1227 VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb, 1228 zfsvfs) == 0); 1229 1230 VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb, 1231 zfsvfs) == 0); 1232 1233 VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb, 1234 zfsvfs) == 0); 1235 1236 VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, 1237 zfsvfs) == 0); 1238 1239 VERIFY(dsl_prop_unregister(ds, "aclinherit", 1240 acl_inherit_changed_cb, zfsvfs) == 0); 1241 1242 VERIFY(dsl_prop_unregister(ds, "vscan", 1243 vscan_changed_cb, zfsvfs) == 0); 1244 } 1245} 1246 1247/* 1248 * Convert a decimal digit string to a uint64_t integer. 1249 */ 1250static int 1251str_to_uint64(char *str, uint64_t *objnum) 1252{ 1253 uint64_t num = 0; 1254 1255 while (*str) { 1256 if (*str < '0' || *str > '9') 1257 return (EINVAL); 1258 1259 num = num*10 + *str++ - '0'; 1260 } 1261 1262 *objnum = num; 1263 return (0); 1264} 1265 1266/* 1267 * The boot path passed from the boot loader is in the form of 1268 * "rootpool-name/root-filesystem-object-number'. Convert this 1269 * string to a dataset name: "rootpool-name/root-filesystem-name". 1270 */ 1271static int 1272zfs_parse_bootfs(char *bpath, char *outpath) 1273{ 1274 char *slashp; 1275 uint64_t objnum; 1276 int error; 1277 1278 if (*bpath == 0 || *bpath == '/') 1279 return (EINVAL); 1280 1281 (void) strcpy(outpath, bpath); 1282 1283 slashp = strchr(bpath, '/'); 1284 1285 /* if no '/', just return the pool name */ 1286 if (slashp == NULL) { 1287 return (0); 1288 } 1289 1290 /* if not a number, just return the root dataset name */ 1291 if (str_to_uint64(slashp+1, &objnum)) { 1292 return (0); 1293 } 1294 1295 *slashp = '\0'; 1296 error = dsl_dsobj_to_dsname(bpath, objnum, outpath); 1297 *slashp = '/'; 1298 1299 return (error); 1300} 1301 1302/* 1303 * zfs_check_global_label: 1304 * Check that the hex label string is appropriate for the dataset 1305 * being mounted into the global_zone proper. 1306 * 1307 * Return an error if the hex label string is not default or 1308 * admin_low/admin_high. For admin_low labels, the corresponding 1309 * dataset must be readonly. 1310 */ 1311int 1312zfs_check_global_label(const char *dsname, const char *hexsl) 1313{ 1314 if (strcasecmp(hexsl, ZFS_MLSLABEL_DEFAULT) == 0) 1315 return (0); 1316 if (strcasecmp(hexsl, ADMIN_HIGH) == 0) 1317 return (0); 1318 if (strcasecmp(hexsl, ADMIN_LOW) == 0) { 1319 /* must be readonly */ 1320 uint64_t rdonly; 1321 1322 if (dsl_prop_get_integer(dsname, 1323 zfs_prop_to_name(ZFS_PROP_READONLY), &rdonly, NULL)) 1324 return (EACCES); 1325 return (rdonly ? 0 : EACCES); 1326 } 1327 return (EACCES); 1328} 1329 1330/* 1331 * zfs_mount_label_policy: 1332 * Determine whether the mount is allowed according to MAC check. 1333 * by comparing (where appropriate) label of the dataset against 1334 * the label of the zone being mounted into. If the dataset has 1335 * no label, create one. 1336 * 1337 * Returns: 1338 * 0 : access allowed 1339 * >0 : error code, such as EACCES 1340 */ 1341static int 1342zfs_mount_label_policy(vfs_t *vfsp, char *osname) 1343{ 1344 int error, retv; 1345 zone_t *mntzone = NULL; 1346 ts_label_t *mnt_tsl; 1347 bslabel_t *mnt_sl; 1348 bslabel_t ds_sl; 1349 char ds_hexsl[MAXNAMELEN]; 1350 1351 retv = EACCES; /* assume the worst */ 1352 1353 /* 1354 * Start by getting the dataset label if it exists. 1355 */ 1356 error = dsl_prop_get(osname, zfs_prop_to_name(ZFS_PROP_MLSLABEL), 1357 1, sizeof (ds_hexsl), &ds_hexsl, NULL); 1358 if (error) 1359 return (EACCES); 1360 1361 /* 1362 * If labeling is NOT enabled, then disallow the mount of datasets 1363 * which have a non-default label already. No other label checks 1364 * are needed. 1365 */ 1366 if (!is_system_labeled()) { 1367 if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0) 1368 return (0); 1369 return (EACCES); 1370 } 1371 1372 /* 1373 * Get the label of the mountpoint. If mounting into the global 1374 * zone (i.e. mountpoint is not within an active zone and the 1375 * zoned property is off), the label must be default or 1376 * admin_low/admin_high only; no other checks are needed. 1377 */ 1378 mntzone = zone_find_by_any_path(refstr_value(vfsp->vfs_mntpt), B_FALSE); 1379 if (mntzone->zone_id == GLOBAL_ZONEID) { 1380 uint64_t zoned; 1381 1382 zone_rele(mntzone); 1383 1384 if (dsl_prop_get_integer(osname, 1385 zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL)) 1386 return (EACCES); 1387 if (!zoned) 1388 return (zfs_check_global_label(osname, ds_hexsl)); 1389 else 1390 /* 1391 * This is the case of a zone dataset being mounted 1392 * initially, before the zone has been fully created; 1393 * allow this mount into global zone. 1394 */ 1395 return (0); 1396 } 1397 1398 mnt_tsl = mntzone->zone_slabel; 1399 ASSERT(mnt_tsl != NULL); 1400 label_hold(mnt_tsl); 1401 mnt_sl = label2bslabel(mnt_tsl); 1402 1403 if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) == 0) { 1404 /* 1405 * The dataset doesn't have a real label, so fabricate one. 1406 */ 1407 char *str = NULL; 1408 1409 if (l_to_str_internal(mnt_sl, &str) == 0 && 1410 dsl_prop_set(osname, zfs_prop_to_name(ZFS_PROP_MLSLABEL), 1411 ZPROP_SRC_LOCAL, 1, strlen(str) + 1, str) == 0) 1412 retv = 0; 1413 if (str != NULL) 1414 kmem_free(str, strlen(str) + 1); 1415 } else if (hexstr_to_label(ds_hexsl, &ds_sl) == 0) { 1416 /* 1417 * Now compare labels to complete the MAC check. If the 1418 * labels are equal then allow access. If the mountpoint 1419 * label dominates the dataset label, allow readonly access. 1420 * Otherwise, access is denied. 1421 */ 1422 if (blequal(mnt_sl, &ds_sl)) 1423 retv = 0; 1424 else if (bldominates(mnt_sl, &ds_sl)) { 1425 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 1426 retv = 0; 1427 } 1428 } 1429 1430 label_rele(mnt_tsl); 1431 zone_rele(mntzone); 1432 return (retv); 1433} 1434 1435static int 1436zfs_mountroot(vfs_t *vfsp, enum whymountroot why) 1437{ 1438 int error = 0; 1439 static int zfsrootdone = 0; 1440 zfsvfs_t *zfsvfs = NULL; 1441 znode_t *zp = NULL; 1442 vnode_t *vp = NULL; 1443 char *zfs_bootfs; 1444 char *zfs_devid; 1445 1446 ASSERT(vfsp); 1447 1448 /* 1449 * The filesystem that we mount as root is defined in the 1450 * boot property "zfs-bootfs" with a format of 1451 * "poolname/root-dataset-objnum". 1452 */ 1453 if (why == ROOT_INIT) { 1454 if (zfsrootdone++) 1455 return (EBUSY); 1456 /* 1457 * the process of doing a spa_load will require the 1458 * clock to be set before we could (for example) do 1459 * something better by looking at the timestamp on 1460 * an uberblock, so just set it to -1. 1461 */ 1462 clkset(-1); 1463 1464 if ((zfs_bootfs = spa_get_bootprop("zfs-bootfs")) == NULL) { 1465 cmn_err(CE_NOTE, "spa_get_bootfs: can not get " 1466 "bootfs name"); 1467 return (EINVAL); 1468 } 1469 zfs_devid = spa_get_bootprop("diskdevid"); 1470 error = spa_import_rootpool(rootfs.bo_name, zfs_devid); 1471 if (zfs_devid) 1472 spa_free_bootprop(zfs_devid); 1473 if (error) { 1474 spa_free_bootprop(zfs_bootfs); 1475 cmn_err(CE_NOTE, "spa_import_rootpool: error %d", 1476 error); 1477 return (error); 1478 } 1479 if (error = zfs_parse_bootfs(zfs_bootfs, rootfs.bo_name)) { 1480 spa_free_bootprop(zfs_bootfs); 1481 cmn_err(CE_NOTE, "zfs_parse_bootfs: error %d", 1482 error); 1483 return (error); 1484 } 1485 1486 spa_free_bootprop(zfs_bootfs); 1487 1488 if (error = vfs_lock(vfsp)) 1489 return (error); 1490 1491 if (error = zfs_domount(vfsp, rootfs.bo_name)) { 1492 cmn_err(CE_NOTE, "zfs_domount: error %d", error); 1493 goto out; 1494 } 1495 1496 zfsvfs = (zfsvfs_t *)vfsp->vfs_data; 1497 ASSERT(zfsvfs); 1498 if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) { 1499 cmn_err(CE_NOTE, "zfs_zget: error %d", error); 1500 goto out; 1501 } 1502 1503 vp = ZTOV(zp); 1504 mutex_enter(&vp->v_lock); 1505 vp->v_flag |= VROOT; 1506 mutex_exit(&vp->v_lock); 1507 rootvp = vp; 1508 1509 /* 1510 * Leave rootvp held. The root file system is never unmounted. 1511 */ 1512 1513 vfs_add((struct vnode *)0, vfsp, 1514 (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0); 1515out: 1516 vfs_unlock(vfsp); 1517 return (error); 1518 } else if (why == ROOT_REMOUNT) { 1519 readonly_changed_cb(vfsp->vfs_data, B_FALSE); 1520 vfsp->vfs_flag |= VFS_REMOUNT; 1521 1522 /* refresh mount options */ 1523 zfs_unregister_callbacks(vfsp->vfs_data); 1524 return (zfs_register_callbacks(vfsp)); 1525 1526 } else if (why == ROOT_UNMOUNT) { 1527 zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data); 1528 (void) zfs_sync(vfsp, 0, 0); 1529 return (0); 1530 } 1531 1532 /* 1533 * if "why" is equal to anything else other than ROOT_INIT, 1534 * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it. 1535 */ 1536 return (ENOTSUP); 1537} 1538 1539/*ARGSUSED*/ 1540static int 1541zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 1542{ 1543 char *osname; 1544 pathname_t spn; 1545 int error = 0; 1546 uio_seg_t fromspace = (uap->flags & MS_SYSSPACE) ? 1547 UIO_SYSSPACE : UIO_USERSPACE; 1548 int canwrite; 1549 1550 if (mvp->v_type != VDIR) 1551 return (ENOTDIR); 1552 1553 mutex_enter(&mvp->v_lock); 1554 if ((uap->flags & MS_REMOUNT) == 0 && 1555 (uap->flags & MS_OVERLAY) == 0 && 1556 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 1557 mutex_exit(&mvp->v_lock); 1558 return (EBUSY); 1559 } 1560 mutex_exit(&mvp->v_lock); 1561 1562 /* 1563 * ZFS does not support passing unparsed data in via MS_DATA. 1564 * Users should use the MS_OPTIONSTR interface; this means 1565 * that all option parsing is already done and the options struct 1566 * can be interrogated. 1567 */ 1568 if ((uap->flags & MS_DATA) && uap->datalen > 0) 1569 return (EINVAL); 1570 1571 /* 1572 * Get the objset name (the "special" mount argument). 1573 */ 1574 if (error = pn_get(uap->spec, fromspace, &spn)) 1575 return (error); 1576 1577 osname = spn.pn_path; 1578 1579 /* 1580 * Check for mount privilege? 1581 * 1582 * If we don't have privilege then see if 1583 * we have local permission to allow it 1584 */ 1585 error = secpolicy_fs_mount(cr, mvp, vfsp); 1586 if (error) { 1587 if (dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) == 0) { 1588 vattr_t vattr; 1589 1590 /* 1591 * Make sure user is the owner of the mount point 1592 * or has sufficient privileges. 1593 */ 1594 1595 vattr.va_mask = AT_UID; 1596 1597 if (VOP_GETATTR(mvp, &vattr, 0, cr, NULL)) { 1598 goto out; 1599 } 1600 1601 if (secpolicy_vnode_owner(cr, vattr.va_uid) != 0 && 1602 VOP_ACCESS(mvp, VWRITE, 0, cr, NULL) != 0) { 1603 goto out; 1604 } 1605 secpolicy_fs_mount_clearopts(cr, vfsp); 1606 } else { 1607 goto out; 1608 } 1609 } 1610 1611 /* 1612 * Refuse to mount a filesystem if we are in a local zone and the 1613 * dataset is not visible. 1614 */ 1615 if (!INGLOBALZONE(curproc) && 1616 (!zone_dataset_visible(osname, &canwrite) || !canwrite)) { 1617 error = EPERM; 1618 goto out; 1619 } 1620 1621 error = zfs_mount_label_policy(vfsp, osname); 1622 if (error) 1623 goto out; 1624 1625 /* 1626 * When doing a remount, we simply refresh our temporary properties 1627 * according to those options set in the current VFS options. 1628 */ 1629 if (uap->flags & MS_REMOUNT) { 1630 /* refresh mount options */ 1631 zfs_unregister_callbacks(vfsp->vfs_data); 1632 error = zfs_register_callbacks(vfsp); 1633 goto out; 1634 } 1635 1636 error = zfs_domount(vfsp, osname); 1637 1638 /* 1639 * Add an extra VFS_HOLD on our parent vfs so that it can't 1640 * disappear due to a forced unmount. 1641 */ 1642 if (error == 0 && ((zfsvfs_t *)vfsp->vfs_data)->z_issnap) 1643 VFS_HOLD(mvp->v_vfsp); 1644 1645out: 1646 pn_free(&spn); 1647 return (error); 1648} 1649 1650static int 1651zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp) 1652{ 1653 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1654 dev32_t d32; 1655 uint64_t refdbytes, availbytes, usedobjs, availobjs; 1656 1657 ZFS_ENTER(zfsvfs); 1658 1659 dmu_objset_space(zfsvfs->z_os, 1660 &refdbytes, &availbytes, &usedobjs, &availobjs); 1661 1662 /* 1663 * The underlying storage pool actually uses multiple block sizes. 1664 * We report the fragsize as the smallest block size we support, 1665 * and we report our blocksize as the filesystem's maximum blocksize. 1666 */ 1667 statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT; 1668 statp->f_bsize = zfsvfs->z_max_blksz; 1669 1670 /* 1671 * The following report "total" blocks of various kinds in the 1672 * file system, but reported in terms of f_frsize - the 1673 * "fragment" size. 1674 */ 1675 1676 statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT; 1677 statp->f_bfree = availbytes >> SPA_MINBLOCKSHIFT; 1678 statp->f_bavail = statp->f_bfree; /* no root reservation */ 1679 1680 /* 1681 * statvfs() should really be called statufs(), because it assumes 1682 * static metadata. ZFS doesn't preallocate files, so the best 1683 * we can do is report the max that could possibly fit in f_files, 1684 * and that minus the number actually used in f_ffree. 1685 * For f_ffree, report the smaller of the number of object available 1686 * and the number of blocks (each object will take at least a block). 1687 */ 1688 statp->f_ffree = MIN(availobjs, statp->f_bfree); 1689 statp->f_favail = statp->f_ffree; /* no "root reservation" */ 1690 statp->f_files = statp->f_ffree + usedobjs; 1691 1692 (void) cmpldev(&d32, vfsp->vfs_dev); 1693 statp->f_fsid = d32; 1694 1695 /* 1696 * We're a zfs filesystem. 1697 */ 1698 (void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name); 1699 1700 statp->f_flag = vf_to_stf(vfsp->vfs_flag); 1701 1702 statp->f_namemax = ZFS_MAXNAMELEN; 1703 1704 /* 1705 * We have all of 32 characters to stuff a string here. 1706 * Is there anything useful we could/should provide? 1707 */ 1708 bzero(statp->f_fstr, sizeof (statp->f_fstr)); 1709 1710 ZFS_EXIT(zfsvfs); 1711 return (0); 1712} 1713 1714static int 1715zfs_root(vfs_t *vfsp, vnode_t **vpp) 1716{ 1717 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1718 znode_t *rootzp; 1719 int error; 1720 1721 ZFS_ENTER(zfsvfs); 1722 1723 error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp); 1724 if (error == 0) 1725 *vpp = ZTOV(rootzp); 1726 1727 ZFS_EXIT(zfsvfs); 1728 return (error); 1729} 1730 1731/* 1732 * Teardown the zfsvfs::z_os. 1733 * 1734 * Note, if 'unmounting' if FALSE, we return with the 'z_teardown_lock' 1735 * and 'z_teardown_inactive_lock' held. 1736 */ 1737static int 1738zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting) 1739{ 1740 znode_t *zp; 1741 1742 rrw_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG); 1743 1744 if (!unmounting) { 1745 /* 1746 * We purge the parent filesystem's vfsp as the parent 1747 * filesystem and all of its snapshots have their vnode's 1748 * v_vfsp set to the parent's filesystem's vfsp. Note, 1749 * 'z_parent' is self referential for non-snapshots. 1750 */ 1751 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0); 1752 } 1753 1754 /* 1755 * Close the zil. NB: Can't close the zil while zfs_inactive 1756 * threads are blocked as zil_close can call zfs_inactive. 1757 */ 1758 if (zfsvfs->z_log) { 1759 zil_close(zfsvfs->z_log); 1760 zfsvfs->z_log = NULL; 1761 } 1762 1763 rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER); 1764 1765 /* 1766 * If we are not unmounting (ie: online recv) and someone already 1767 * unmounted this file system while we were doing the switcheroo, 1768 * or a reopen of z_os failed then just bail out now. 1769 */ 1770 if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) { 1771 rw_exit(&zfsvfs->z_teardown_inactive_lock); 1772 rrw_exit(&zfsvfs->z_teardown_lock, FTAG); 1773 return (EIO); 1774 } 1775 1776 /* 1777 * At this point there are no vops active, and any new vops will 1778 * fail with EIO since we have z_teardown_lock for writer (only 1779 * relavent for forced unmount). 1780 * 1781 * Release all holds on dbufs. 1782 */ 1783 mutex_enter(&zfsvfs->z_znodes_lock); 1784 for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL; 1785 zp = list_next(&zfsvfs->z_all_znodes, zp)) 1786 if (zp->z_sa_hdl) { 1787 ASSERT(ZTOV(zp)->v_count > 0); 1788 zfs_znode_dmu_fini(zp); 1789 } 1790 mutex_exit(&zfsvfs->z_znodes_lock); 1791 1792 /* 1793 * If we are unmounting, set the unmounted flag and let new vops 1794 * unblock. zfs_inactive will have the unmounted behavior, and all 1795 * other vops will fail with EIO. 1796 */ 1797 if (unmounting) { 1798 zfsvfs->z_unmounted = B_TRUE; 1799 rrw_exit(&zfsvfs->z_teardown_lock, FTAG); 1800 rw_exit(&zfsvfs->z_teardown_inactive_lock); 1801 } 1802 1803 /* 1804 * z_os will be NULL if there was an error in attempting to reopen 1805 * zfsvfs, so just return as the properties had already been 1806 * unregistered and cached data had been evicted before. 1807 */ 1808 if (zfsvfs->z_os == NULL) 1809 return (0); 1810 1811 /* 1812 * Unregister properties. 1813 */ 1814 zfs_unregister_callbacks(zfsvfs); 1815 1816 /* 1817 * Evict cached data 1818 */ 1819 if (dmu_objset_is_dirty_anywhere(zfsvfs->z_os)) 1820 if (!(zfsvfs->z_vfs->vfs_flag & VFS_RDONLY)) 1821 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0); 1822 (void) dmu_objset_evict_dbufs(zfsvfs->z_os); 1823 1824 return (0); 1825} 1826 1827/*ARGSUSED*/ 1828static int 1829zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr) 1830{ 1831 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1832 objset_t *os; 1833 int ret; 1834 1835 ret = secpolicy_fs_unmount(cr, vfsp); 1836 if (ret) { 1837 if (dsl_deleg_access((char *)refstr_value(vfsp->vfs_resource), 1838 ZFS_DELEG_PERM_MOUNT, cr)) 1839 return (ret); 1840 } 1841 1842 /* 1843 * We purge the parent filesystem's vfsp as the parent filesystem 1844 * and all of its snapshots have their vnode's v_vfsp set to the 1845 * parent's filesystem's vfsp. Note, 'z_parent' is self 1846 * referential for non-snapshots. 1847 */ 1848 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0); 1849 1850 /* 1851 * Unmount any snapshots mounted under .zfs before unmounting the 1852 * dataset itself. 1853 */ 1854 if (zfsvfs->z_ctldir != NULL && 1855 (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) { 1856 return (ret); 1857 } 1858 1859 if (!(fflag & MS_FORCE)) { 1860 /* 1861 * Check the number of active vnodes in the file system. 1862 * Our count is maintained in the vfs structure, but the 1863 * number is off by 1 to indicate a hold on the vfs 1864 * structure itself. 1865 * 1866 * The '.zfs' directory maintains a reference of its 1867 * own, and any active references underneath are 1868 * reflected in the vnode count. 1869 */ 1870 if (zfsvfs->z_ctldir == NULL) { 1871 if (vfsp->vfs_count > 1) 1872 return (EBUSY); 1873 } else { 1874 if (vfsp->vfs_count > 2 || 1875 zfsvfs->z_ctldir->v_count > 1) 1876 return (EBUSY); 1877 } 1878 } 1879 1880 vfsp->vfs_flag |= VFS_UNMOUNTED; 1881 1882 VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0); 1883 os = zfsvfs->z_os; 1884 1885 /* 1886 * z_os will be NULL if there was an error in 1887 * attempting to reopen zfsvfs. 1888 */ 1889 if (os != NULL) { 1890 /* 1891 * Unset the objset user_ptr. 1892 */ 1893 mutex_enter(&os->os_user_ptr_lock); 1894 dmu_objset_set_user(os, NULL); 1895 mutex_exit(&os->os_user_ptr_lock); 1896 1897 /* 1898 * Finally release the objset 1899 */ 1900 dmu_objset_disown(os, zfsvfs); 1901 } 1902 1903 /* 1904 * We can now safely destroy the '.zfs' directory node. 1905 */ 1906 if (zfsvfs->z_ctldir != NULL) 1907 zfsctl_destroy(zfsvfs); 1908 1909 return (0); 1910} 1911 1912static int 1913zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 1914{ 1915 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1916 znode_t *zp; 1917 uint64_t object = 0; 1918 uint64_t fid_gen = 0; 1919 uint64_t gen_mask; 1920 uint64_t zp_gen; 1921 int i, err; 1922 1923 *vpp = NULL; 1924 1925 ZFS_ENTER(zfsvfs); 1926 1927 if (fidp->fid_len == LONG_FID_LEN) { 1928 zfid_long_t *zlfid = (zfid_long_t *)fidp; 1929 uint64_t objsetid = 0; 1930 uint64_t setgen = 0; 1931 1932 for (i = 0; i < sizeof (zlfid->zf_setid); i++) 1933 objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i); 1934 1935…
Large files files are truncated, but you can click here to view the full file