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 * Copyright (c) 2012, 2015 by Delphix. All rights reserved. 24 * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. 25 */ 26 27 /* 28 * ZFS control directory (a.k.a. ".zfs") 29 * 30 * This directory provides a common location for all ZFS meta-objects. 31 * Currently, this is only the 'snapshot' directory, but this may expand in the 32 * future. The elements are built using the GFS primitives, as the hierarchy 33 * does not actually exist on disk. 34 * 35 * For 'snapshot', we don't want to have all snapshots always mounted, because 36 * this would take up a huge amount of space in /etc/mnttab. We have three 37 * types of objects: 38 * 39 * ctldir ------> snapshotdir -------> snapshot 40 * | 41 * | 42 * V 43 * mounted fs 44 * 45 * The 'snapshot' node contains just enough information to lookup '..' and act 46 * as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we 47 * perform an automount of the underlying filesystem and return the 48 * corresponding vnode. 49 * 50 * All mounts are handled automatically by the kernel, but unmounts are 51 * (currently) handled from user land. The main reason is that there is no 52 * reliable way to auto-unmount the filesystem when it's "no longer in use". 53 * When the user unmounts a filesystem, we call zfsctl_unmount(), which 54 * unmounts any snapshots within the snapshot directory. 55 * 56 * The '.zfs', '.zfs/snapshot', and all directories created under 57 * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') are all GFS nodes and 58 * share the same vfs_t as the head filesystem (what '.zfs' lives under). 59 * 60 * File systems mounted ontop of the GFS nodes '.zfs/snapshot/<snapname>' 61 * (ie: snapshots) are ZFS nodes and have their own unique vfs_t. 62 * However, vnodes within these mounted on file systems have their v_vfsp 63 * fields set to the head filesystem to make NFS happy (see 64 * zfsctl_snapdir_lookup()). We VFS_HOLD the head filesystem's vfs_t 65 * so that it cannot be freed until all snapshots have been unmounted. 66 */ 67 68 #include <sys/types.h> 69 #include <sys/param.h> 70 #include <sys/libkern.h> 71 #include <sys/dirent.h> 72 #include <sys/zfs_context.h> 73 #include <sys/zfs_ctldir.h> 74 #include <sys/zfs_ioctl.h> 75 #include <sys/zfs_vfsops.h> 76 #include <sys/namei.h> 77 #include <sys/stat.h> 78 #include <sys/dmu.h> 79 #include <sys/dsl_dataset.h> 80 #include <sys/dsl_destroy.h> 81 #include <sys/dsl_deleg.h> 82 #include <sys/mount.h> 83 #include <sys/zap.h> 84 #include <sys/sysproto.h> 85 86 #include "zfs_namecheck.h" 87 88 #include <sys/kernel.h> 89 #include <sys/ccompat.h> 90 91 /* Common access mode for all virtual directories under the ctldir */ 92 const uint16_t zfsctl_ctldir_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | 93 S_IROTH | S_IXOTH; 94 95 /* 96 * "Synthetic" filesystem implementation. 97 */ 98 99 /* 100 * Assert that A implies B. 101 */ 102 #define KASSERT_IMPLY(A, B, msg) KASSERT(!(A) || (B), (msg)); 103 104 static MALLOC_DEFINE(M_SFSNODES, "sfs_nodes", "synthetic-fs nodes"); 105 106 typedef struct sfs_node { 107 char sn_name[ZFS_MAX_DATASET_NAME_LEN]; 108 uint64_t sn_parent_id; 109 uint64_t sn_id; 110 } sfs_node_t; 111 112 /* 113 * Check the parent's ID as well as the node's to account for a chance 114 * that IDs originating from different domains (snapshot IDs, artificial 115 * IDs, znode IDs) may clash. 116 */ 117 static int 118 sfs_compare_ids(struct vnode *vp, void *arg) 119 { 120 sfs_node_t *n1 = vp->v_data; 121 sfs_node_t *n2 = arg; 122 bool equal; 123 124 equal = n1->sn_id == n2->sn_id && 125 n1->sn_parent_id == n2->sn_parent_id; 126 127 /* Zero means equality. */ 128 return (!equal); 129 } 130 131 static int 132 sfs_vnode_get(const struct mount *mp, int flags, uint64_t parent_id, 133 uint64_t id, struct vnode **vpp) 134 { 135 sfs_node_t search; 136 int err; 137 138 search.sn_id = id; 139 search.sn_parent_id = parent_id; 140 err = vfs_hash_get(mp, (uint32_t)id, flags, curthread, vpp, 141 sfs_compare_ids, &search); 142 return (err); 143 } 144 145 static int 146 sfs_vnode_insert(struct vnode *vp, int flags, uint64_t parent_id, 147 uint64_t id, struct vnode **vpp) 148 { 149 int err; 150 151 KASSERT(vp->v_data != NULL, ("sfs_vnode_insert with NULL v_data")); 152 err = vfs_hash_insert(vp, (uint32_t)id, flags, curthread, vpp, 153 sfs_compare_ids, vp->v_data); 154 return (err); 155 } 156 157 static void 158 sfs_vnode_remove(struct vnode *vp) 159 { 160 vfs_hash_remove(vp); 161 } 162 163 typedef void sfs_vnode_setup_fn(vnode_t *vp, void *arg); 164 165 static int 166 sfs_vgetx(struct mount *mp, int flags, uint64_t parent_id, uint64_t id, 167 const char *tag, struct vop_vector *vops, 168 sfs_vnode_setup_fn setup, void *arg, 169 struct vnode **vpp) 170 { 171 struct vnode *vp; 172 int error; 173 174 error = sfs_vnode_get(mp, flags, parent_id, id, vpp); 175 if (error != 0 || *vpp != NULL) { 176 KASSERT_IMPLY(error == 0, (*vpp)->v_data != NULL, 177 "sfs vnode with no data"); 178 return (error); 179 } 180 181 /* Allocate a new vnode/inode. */ 182 error = getnewvnode(tag, mp, vops, &vp); 183 if (error != 0) { 184 *vpp = NULL; 185 return (error); 186 } 187 188 /* 189 * Exclusively lock the vnode vnode while it's being constructed. 190 */ 191 lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL); 192 error = insmntque(vp, mp); 193 if (error != 0) { 194 *vpp = NULL; 195 return (error); 196 } 197 198 setup(vp, arg); 199 200 error = sfs_vnode_insert(vp, flags, parent_id, id, vpp); 201 if (error != 0 || *vpp != NULL) { 202 KASSERT_IMPLY(error == 0, (*vpp)->v_data != NULL, 203 "sfs vnode with no data"); 204 return (error); 205 } 206 207 *vpp = vp; 208 return (0); 209 } 210 211 static void 212 sfs_print_node(sfs_node_t *node) 213 { 214 printf("\tname = %s\n", node->sn_name); 215 printf("\tparent_id = %ju\n", (uintmax_t)node->sn_parent_id); 216 printf("\tid = %ju\n", (uintmax_t)node->sn_id); 217 } 218 219 static sfs_node_t * 220 sfs_alloc_node(size_t size, const char *name, uint64_t parent_id, uint64_t id) 221 { 222 struct sfs_node *node; 223 224 KASSERT(strlen(name) < sizeof (node->sn_name), 225 ("sfs node name is too long")); 226 KASSERT(size >= sizeof (*node), ("sfs node size is too small")); 227 node = malloc(size, M_SFSNODES, M_WAITOK | M_ZERO); 228 strlcpy(node->sn_name, name, sizeof (node->sn_name)); 229 node->sn_parent_id = parent_id; 230 node->sn_id = id; 231 232 return (node); 233 } 234 235 static void 236 sfs_destroy_node(sfs_node_t *node) 237 { 238 free(node, M_SFSNODES); 239 } 240 241 static void * 242 sfs_reclaim_vnode(vnode_t *vp) 243 { 244 void *data; 245 246 sfs_vnode_remove(vp); 247 data = vp->v_data; 248 vp->v_data = NULL; 249 return (data); 250 } 251 252 static int 253 sfs_readdir_common(uint64_t parent_id, uint64_t id, struct vop_readdir_args *ap, 254 uio_t *uio, off_t *offp) 255 { 256 struct dirent entry; 257 int error; 258 259 /* Reset ncookies for subsequent use of vfs_read_dirent. */ 260 if (ap->a_ncookies != NULL) 261 *ap->a_ncookies = 0; 262 263 if (uio->uio_resid < sizeof (entry)) 264 return (SET_ERROR(EINVAL)); 265 266 if (uio->uio_offset < 0) 267 return (SET_ERROR(EINVAL)); 268 if (uio->uio_offset == 0) { 269 entry.d_fileno = id; 270 entry.d_type = DT_DIR; 271 entry.d_name[0] = '.'; 272 entry.d_name[1] = '\0'; 273 entry.d_namlen = 1; 274 entry.d_reclen = sizeof (entry); 275 error = vfs_read_dirent(ap, &entry, uio->uio_offset); 276 if (error != 0) 277 return (SET_ERROR(error)); 278 } 279 280 if (uio->uio_offset < sizeof (entry)) 281 return (SET_ERROR(EINVAL)); 282 if (uio->uio_offset == sizeof (entry)) { 283 entry.d_fileno = parent_id; 284 entry.d_type = DT_DIR; 285 entry.d_name[0] = '.'; 286 entry.d_name[1] = '.'; 287 entry.d_name[2] = '\0'; 288 entry.d_namlen = 2; 289 entry.d_reclen = sizeof (entry); 290 error = vfs_read_dirent(ap, &entry, uio->uio_offset); 291 if (error != 0) 292 return (SET_ERROR(error)); 293 } 294 295 if (offp != NULL) 296 *offp = 2 * sizeof (entry); 297 return (0); 298 } 299 300 301 /* 302 * .zfs inode namespace 303 * 304 * We need to generate unique inode numbers for all files and directories 305 * within the .zfs pseudo-filesystem. We use the following scheme: 306 * 307 * ENTRY ZFSCTL_INODE 308 * .zfs 1 309 * .zfs/snapshot 2 310 * .zfs/snapshot/<snap> objectid(snap) 311 */ 312 #define ZFSCTL_INO_SNAP(id) (id) 313 314 static struct vop_vector zfsctl_ops_root; 315 static struct vop_vector zfsctl_ops_snapdir; 316 static struct vop_vector zfsctl_ops_snapshot; 317 318 void 319 zfsctl_init(void) 320 { 321 } 322 323 void 324 zfsctl_fini(void) 325 { 326 } 327 328 boolean_t 329 zfsctl_is_node(vnode_t *vp) 330 { 331 return (vn_matchops(vp, zfsctl_ops_root) || 332 vn_matchops(vp, zfsctl_ops_snapdir) || 333 vn_matchops(vp, zfsctl_ops_snapshot)); 334 335 } 336 337 typedef struct zfsctl_root { 338 sfs_node_t node; 339 sfs_node_t *snapdir; 340 timestruc_t cmtime; 341 } zfsctl_root_t; 342 343 344 /* 345 * Create the '.zfs' directory. 346 */ 347 void 348 zfsctl_create(zfsvfs_t *zfsvfs) 349 { 350 zfsctl_root_t *dot_zfs; 351 sfs_node_t *snapdir; 352 vnode_t *rvp; 353 uint64_t crtime[2]; 354 355 ASSERT(zfsvfs->z_ctldir == NULL); 356 357 snapdir = sfs_alloc_node(sizeof (*snapdir), "snapshot", ZFSCTL_INO_ROOT, 358 ZFSCTL_INO_SNAPDIR); 359 dot_zfs = (zfsctl_root_t *)sfs_alloc_node(sizeof (*dot_zfs), ".zfs", 0, 360 ZFSCTL_INO_ROOT); 361 dot_zfs->snapdir = snapdir; 362 363 VERIFY(VFS_ROOT(zfsvfs->z_vfs, LK_EXCLUSIVE, &rvp) == 0); 364 VERIFY(0 == sa_lookup(VTOZ(rvp)->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs), 365 &crtime, sizeof (crtime))); 366 ZFS_TIME_DECODE(&dot_zfs->cmtime, crtime); 367 vput(rvp); 368 369 zfsvfs->z_ctldir = dot_zfs; 370 } 371 372 /* 373 * Destroy the '.zfs' directory. Only called when the filesystem is unmounted. 374 * The nodes must not have any associated vnodes by now as they should be 375 * vflush-ed. 376 */ 377 void 378 zfsctl_destroy(zfsvfs_t *zfsvfs) 379 { 380 sfs_destroy_node(zfsvfs->z_ctldir->snapdir); 381 sfs_destroy_node((sfs_node_t *)zfsvfs->z_ctldir); 382 zfsvfs->z_ctldir = NULL; 383 } 384 385 static int 386 zfsctl_fs_root_vnode(struct mount *mp, void *arg __unused, int flags, 387 struct vnode **vpp) 388 { 389 return (VFS_ROOT(mp, flags, vpp)); 390 } 391 392 static void 393 zfsctl_common_vnode_setup(vnode_t *vp, void *arg) 394 { 395 ASSERT_VOP_ELOCKED(vp, __func__); 396 397 /* We support shared locking. */ 398 VN_LOCK_ASHARE(vp); 399 vp->v_type = VDIR; 400 vp->v_data = arg; 401 } 402 403 static int 404 zfsctl_root_vnode(struct mount *mp, void *arg __unused, int flags, 405 struct vnode **vpp) 406 { 407 void *node; 408 int err; 409 410 node = ((zfsvfs_t *)mp->mnt_data)->z_ctldir; 411 err = sfs_vgetx(mp, flags, 0, ZFSCTL_INO_ROOT, "zfs", &zfsctl_ops_root, 412 zfsctl_common_vnode_setup, node, vpp); 413 return (err); 414 } 415 416 static int 417 zfsctl_snapdir_vnode(struct mount *mp, void *arg __unused, int flags, 418 struct vnode **vpp) 419 { 420 void *node; 421 int err; 422 423 node = ((zfsvfs_t *)mp->mnt_data)->z_ctldir->snapdir; 424 err = sfs_vgetx(mp, flags, ZFSCTL_INO_ROOT, ZFSCTL_INO_SNAPDIR, "zfs", 425 &zfsctl_ops_snapdir, zfsctl_common_vnode_setup, node, vpp); 426 return (err); 427 } 428 429 /* 430 * Given a root znode, retrieve the associated .zfs directory. 431 * Add a hold to the vnode and return it. 432 */ 433 int 434 zfsctl_root(zfsvfs_t *zfsvfs, int flags, vnode_t **vpp) 435 { 436 int error; 437 438 error = zfsctl_root_vnode(zfsvfs->z_vfs, NULL, flags, vpp); 439 return (error); 440 } 441 442 /* 443 * Common open routine. Disallow any write access. 444 */ 445 static int 446 zfsctl_common_open(struct vop_open_args *ap) 447 { 448 int flags = ap->a_mode; 449 450 if (flags & FWRITE) 451 return (SET_ERROR(EACCES)); 452 453 return (0); 454 } 455 456 /* 457 * Common close routine. Nothing to do here. 458 */ 459 /* ARGSUSED */ 460 static int 461 zfsctl_common_close(struct vop_close_args *ap) 462 { 463 return (0); 464 } 465 466 /* 467 * Common access routine. Disallow writes. 468 */ 469 static int 470 zfsctl_common_access(struct vop_access_args *ap) 471 { 472 accmode_t accmode = ap->a_accmode; 473 474 if (accmode & VWRITE) 475 return (SET_ERROR(EACCES)); 476 return (0); 477 } 478 479 /* 480 * Common getattr function. Fill in basic information. 481 */ 482 static void 483 zfsctl_common_getattr(vnode_t *vp, vattr_t *vap) 484 { 485 timestruc_t now; 486 sfs_node_t *node; 487 488 node = vp->v_data; 489 490 vap->va_uid = 0; 491 vap->va_gid = 0; 492 vap->va_rdev = 0; 493 /* 494 * We are a purely virtual object, so we have no 495 * blocksize or allocated blocks. 496 */ 497 vap->va_blksize = 0; 498 vap->va_nblocks = 0; 499 vap->va_seq = 0; 500 vn_fsid(vp, vap); 501 vap->va_mode = zfsctl_ctldir_mode; 502 vap->va_type = VDIR; 503 /* 504 * We live in the now (for atime). 505 */ 506 gethrestime(&now); 507 vap->va_atime = now; 508 /* FreeBSD: Reset chflags(2) flags. */ 509 vap->va_flags = 0; 510 511 vap->va_nodeid = node->sn_id; 512 513 /* At least '.' and '..'. */ 514 vap->va_nlink = 2; 515 } 516 517 #ifndef _OPENSOLARIS_SYS_VNODE_H_ 518 struct vop_fid_args { 519 struct vnode *a_vp; 520 struct fid *a_fid; 521 }; 522 #endif 523 524 static int 525 zfsctl_common_fid(struct vop_fid_args *ap) 526 { 527 vnode_t *vp = ap->a_vp; 528 fid_t *fidp = (void *)ap->a_fid; 529 sfs_node_t *node = vp->v_data; 530 uint64_t object = node->sn_id; 531 zfid_short_t *zfid; 532 int i; 533 534 zfid = (zfid_short_t *)fidp; 535 zfid->zf_len = SHORT_FID_LEN; 536 537 for (i = 0; i < sizeof (zfid->zf_object); i++) 538 zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 539 540 /* .zfs nodes always have a generation number of 0 */ 541 for (i = 0; i < sizeof (zfid->zf_gen); i++) 542 zfid->zf_gen[i] = 0; 543 544 return (0); 545 } 546 547 #ifndef _SYS_SYSPROTO_H_ 548 struct vop_reclaim_args { 549 struct vnode *a_vp; 550 struct thread *a_td; 551 }; 552 #endif 553 554 static int 555 zfsctl_common_reclaim(struct vop_reclaim_args *ap) 556 { 557 vnode_t *vp = ap->a_vp; 558 559 (void) sfs_reclaim_vnode(vp); 560 return (0); 561 } 562 563 #ifndef _SYS_SYSPROTO_H_ 564 struct vop_print_args { 565 struct vnode *a_vp; 566 }; 567 #endif 568 569 static int 570 zfsctl_common_print(struct vop_print_args *ap) 571 { 572 sfs_print_node(ap->a_vp->v_data); 573 return (0); 574 } 575 576 #ifndef _SYS_SYSPROTO_H_ 577 struct vop_getattr_args { 578 struct vnode *a_vp; 579 struct vattr *a_vap; 580 struct ucred *a_cred; 581 }; 582 #endif 583 584 /* 585 * Get root directory attributes. 586 */ 587 static int 588 zfsctl_root_getattr(struct vop_getattr_args *ap) 589 { 590 struct vnode *vp = ap->a_vp; 591 struct vattr *vap = ap->a_vap; 592 zfsctl_root_t *node = vp->v_data; 593 594 zfsctl_common_getattr(vp, vap); 595 vap->va_ctime = node->cmtime; 596 vap->va_mtime = vap->va_ctime; 597 vap->va_birthtime = vap->va_ctime; 598 vap->va_nlink += 1; /* snapdir */ 599 vap->va_size = vap->va_nlink; 600 return (0); 601 } 602 603 /* 604 * When we lookup "." we still can be asked to lock it 605 * differently, can't we? 606 */ 607 static int 608 zfsctl_relock_dot(vnode_t *dvp, int ltype) 609 { 610 vref(dvp); 611 if (ltype != VOP_ISLOCKED(dvp)) { 612 if (ltype == LK_EXCLUSIVE) 613 vn_lock(dvp, LK_UPGRADE | LK_RETRY); 614 else /* if (ltype == LK_SHARED) */ 615 vn_lock(dvp, LK_DOWNGRADE | LK_RETRY); 616 617 /* Relock for the "." case may left us with reclaimed vnode. */ 618 if (VN_IS_DOOMED(dvp)) { 619 vrele(dvp); 620 return (SET_ERROR(ENOENT)); 621 } 622 } 623 return (0); 624 } 625 626 /* 627 * Special case the handling of "..". 628 */ 629 static int 630 zfsctl_root_lookup(struct vop_lookup_args *ap) 631 { 632 struct componentname *cnp = ap->a_cnp; 633 vnode_t *dvp = ap->a_dvp; 634 vnode_t **vpp = ap->a_vpp; 635 int flags = ap->a_cnp->cn_flags; 636 int lkflags = ap->a_cnp->cn_lkflags; 637 int nameiop = ap->a_cnp->cn_nameiop; 638 int err; 639 640 ASSERT(dvp->v_type == VDIR); 641 642 if ((flags & ISLASTCN) != 0 && nameiop != LOOKUP) 643 return (SET_ERROR(ENOTSUP)); 644 645 if (cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.') { 646 err = zfsctl_relock_dot(dvp, lkflags & LK_TYPE_MASK); 647 if (err == 0) 648 *vpp = dvp; 649 } else if ((flags & ISDOTDOT) != 0) { 650 err = vn_vget_ino_gen(dvp, zfsctl_fs_root_vnode, NULL, 651 lkflags, vpp); 652 } else if (strncmp(cnp->cn_nameptr, "snapshot", cnp->cn_namelen) == 0) { 653 err = zfsctl_snapdir_vnode(dvp->v_mount, NULL, lkflags, vpp); 654 } else { 655 err = SET_ERROR(ENOENT); 656 } 657 if (err != 0) 658 *vpp = NULL; 659 return (err); 660 } 661 662 static int 663 zfsctl_root_readdir(struct vop_readdir_args *ap) 664 { 665 struct dirent entry; 666 vnode_t *vp = ap->a_vp; 667 zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 668 zfsctl_root_t *node = vp->v_data; 669 uio_t *uio = ap->a_uio; 670 int *eofp = ap->a_eofflag; 671 off_t dots_offset; 672 int error; 673 674 ASSERT(vp->v_type == VDIR); 675 676 error = sfs_readdir_common(zfsvfs->z_root, ZFSCTL_INO_ROOT, ap, uio, 677 &dots_offset); 678 if (error != 0) { 679 if (error == ENAMETOOLONG) /* ran out of destination space */ 680 error = 0; 681 return (error); 682 } 683 if (uio->uio_offset != dots_offset) 684 return (SET_ERROR(EINVAL)); 685 686 CTASSERT(sizeof (node->snapdir->sn_name) <= sizeof (entry.d_name)); 687 entry.d_fileno = node->snapdir->sn_id; 688 entry.d_type = DT_DIR; 689 strcpy(entry.d_name, node->snapdir->sn_name); 690 entry.d_namlen = strlen(entry.d_name); 691 entry.d_reclen = sizeof (entry); 692 error = vfs_read_dirent(ap, &entry, uio->uio_offset); 693 if (error != 0) { 694 if (error == ENAMETOOLONG) 695 error = 0; 696 return (SET_ERROR(error)); 697 } 698 if (eofp != NULL) 699 *eofp = 1; 700 return (0); 701 } 702 703 static int 704 zfsctl_root_vptocnp(struct vop_vptocnp_args *ap) 705 { 706 static const char dotzfs_name[4] = ".zfs"; 707 vnode_t *dvp; 708 int error; 709 710 if (*ap->a_buflen < sizeof (dotzfs_name)) 711 return (SET_ERROR(ENOMEM)); 712 713 error = vn_vget_ino_gen(ap->a_vp, zfsctl_fs_root_vnode, NULL, 714 LK_SHARED, &dvp); 715 if (error != 0) 716 return (SET_ERROR(error)); 717 718 VOP_UNLOCK1(dvp); 719 *ap->a_vpp = dvp; 720 *ap->a_buflen -= sizeof (dotzfs_name); 721 bcopy(dotzfs_name, ap->a_buf + *ap->a_buflen, sizeof (dotzfs_name)); 722 return (0); 723 } 724 725 static int 726 zfsctl_common_pathconf(struct vop_pathconf_args *ap) 727 { 728 /* 729 * We care about ACL variables so that user land utilities like ls 730 * can display them correctly. Since the ctldir's st_dev is set to be 731 * the same as the parent dataset, we must support all variables that 732 * it supports. 733 */ 734 switch (ap->a_name) { 735 case _PC_LINK_MAX: 736 *ap->a_retval = MIN(LONG_MAX, ZFS_LINK_MAX); 737 return (0); 738 739 case _PC_FILESIZEBITS: 740 *ap->a_retval = 64; 741 return (0); 742 743 case _PC_MIN_HOLE_SIZE: 744 *ap->a_retval = (int)SPA_MINBLOCKSIZE; 745 return (0); 746 747 case _PC_ACL_EXTENDED: 748 *ap->a_retval = 0; 749 return (0); 750 751 case _PC_ACL_NFS4: 752 *ap->a_retval = 1; 753 return (0); 754 755 case _PC_ACL_PATH_MAX: 756 *ap->a_retval = ACL_MAX_ENTRIES; 757 return (0); 758 759 case _PC_NAME_MAX: 760 *ap->a_retval = NAME_MAX; 761 return (0); 762 763 default: 764 return (vop_stdpathconf(ap)); 765 } 766 } 767 768 /* 769 * Returns a trivial ACL 770 */ 771 static int 772 zfsctl_common_getacl(struct vop_getacl_args *ap) 773 { 774 int i; 775 776 if (ap->a_type != ACL_TYPE_NFS4) 777 return (EINVAL); 778 779 acl_nfs4_sync_acl_from_mode(ap->a_aclp, zfsctl_ctldir_mode, 0); 780 /* 781 * acl_nfs4_sync_acl_from_mode assumes that the owner can always modify 782 * attributes. That is not the case for the ctldir, so we must clear 783 * those bits. We also must clear ACL_READ_NAMED_ATTRS, because xattrs 784 * aren't supported by the ctldir. 785 */ 786 for (i = 0; i < ap->a_aclp->acl_cnt; i++) { 787 struct acl_entry *entry; 788 entry = &(ap->a_aclp->acl_entry[i]); 789 entry->ae_perm &= ~(ACL_WRITE_ACL | ACL_WRITE_OWNER | 790 ACL_WRITE_ATTRIBUTES | ACL_WRITE_NAMED_ATTRS | 791 ACL_READ_NAMED_ATTRS); 792 } 793 794 return (0); 795 } 796 797 static struct vop_vector zfsctl_ops_root = { 798 .vop_default = &default_vnodeops, 799 #if __FreeBSD_version >= 1300121 800 .vop_fplookup_vexec = VOP_EAGAIN, 801 #endif 802 .vop_open = zfsctl_common_open, 803 .vop_close = zfsctl_common_close, 804 .vop_ioctl = VOP_EINVAL, 805 .vop_getattr = zfsctl_root_getattr, 806 .vop_access = zfsctl_common_access, 807 .vop_readdir = zfsctl_root_readdir, 808 .vop_lookup = zfsctl_root_lookup, 809 .vop_inactive = VOP_NULL, 810 .vop_reclaim = zfsctl_common_reclaim, 811 .vop_fid = zfsctl_common_fid, 812 .vop_print = zfsctl_common_print, 813 .vop_vptocnp = zfsctl_root_vptocnp, 814 .vop_pathconf = zfsctl_common_pathconf, 815 .vop_getacl = zfsctl_common_getacl, 816 }; 817 VFS_VOP_VECTOR_REGISTER(zfsctl_ops_root); 818 819 static int 820 zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname) 821 { 822 objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 823 824 dmu_objset_name(os, zname); 825 if (strlen(zname) + 1 + strlen(name) >= len) 826 return (SET_ERROR(ENAMETOOLONG)); 827 (void) strcat(zname, "@"); 828 (void) strcat(zname, name); 829 return (0); 830 } 831 832 static int 833 zfsctl_snapshot_lookup(vnode_t *vp, const char *name, uint64_t *id) 834 { 835 objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 836 int err; 837 838 err = dsl_dataset_snap_lookup(dmu_objset_ds(os), name, id); 839 return (err); 840 } 841 842 /* 843 * Given a vnode get a root vnode of a filesystem mounted on top of 844 * the vnode, if any. The root vnode is referenced and locked. 845 * If no filesystem is mounted then the orinal vnode remains referenced 846 * and locked. If any error happens the orinal vnode is unlocked and 847 * released. 848 */ 849 static int 850 zfsctl_mounted_here(vnode_t **vpp, int flags) 851 { 852 struct mount *mp; 853 int err; 854 855 ASSERT_VOP_LOCKED(*vpp, __func__); 856 ASSERT3S((*vpp)->v_type, ==, VDIR); 857 858 if ((mp = (*vpp)->v_mountedhere) != NULL) { 859 err = vfs_busy(mp, 0); 860 KASSERT(err == 0, ("vfs_busy(mp, 0) failed with %d", err)); 861 KASSERT(vrefcnt(*vpp) > 1, ("unreferenced mountpoint")); 862 vput(*vpp); 863 err = VFS_ROOT(mp, flags, vpp); 864 vfs_unbusy(mp); 865 return (err); 866 } 867 return (EJUSTRETURN); 868 } 869 870 typedef struct { 871 const char *snap_name; 872 uint64_t snap_id; 873 } snapshot_setup_arg_t; 874 875 static void 876 zfsctl_snapshot_vnode_setup(vnode_t *vp, void *arg) 877 { 878 snapshot_setup_arg_t *ssa = arg; 879 sfs_node_t *node; 880 881 ASSERT_VOP_ELOCKED(vp, __func__); 882 883 node = sfs_alloc_node(sizeof (sfs_node_t), 884 ssa->snap_name, ZFSCTL_INO_SNAPDIR, ssa->snap_id); 885 zfsctl_common_vnode_setup(vp, node); 886 887 /* We have to support recursive locking. */ 888 VN_LOCK_AREC(vp); 889 } 890 891 /* 892 * Lookup entry point for the 'snapshot' directory. Try to open the 893 * snapshot if it exist, creating the pseudo filesystem vnode as necessary. 894 * Perform a mount of the associated dataset on top of the vnode. 895 * There are four possibilities: 896 * - the snapshot node and vnode do not exist 897 * - the snapshot vnode is covered by the mounted snapshot 898 * - the snapshot vnode is not covered yet, the mount operation is in progress 899 * - the snapshot vnode is not covered, because the snapshot has been unmounted 900 * The last two states are transient and should be relatively short-lived. 901 */ 902 static int 903 zfsctl_snapdir_lookup(struct vop_lookup_args *ap) 904 { 905 vnode_t *dvp = ap->a_dvp; 906 vnode_t **vpp = ap->a_vpp; 907 struct componentname *cnp = ap->a_cnp; 908 char name[NAME_MAX + 1]; 909 char fullname[ZFS_MAX_DATASET_NAME_LEN]; 910 char *mountpoint; 911 size_t mountpoint_len; 912 zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 913 uint64_t snap_id; 914 int nameiop = cnp->cn_nameiop; 915 int lkflags = cnp->cn_lkflags; 916 int flags = cnp->cn_flags; 917 int err; 918 919 ASSERT(dvp->v_type == VDIR); 920 921 if ((flags & ISLASTCN) != 0 && nameiop != LOOKUP) 922 return (SET_ERROR(ENOTSUP)); 923 924 if (cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.') { 925 err = zfsctl_relock_dot(dvp, lkflags & LK_TYPE_MASK); 926 if (err == 0) 927 *vpp = dvp; 928 return (err); 929 } 930 if (flags & ISDOTDOT) { 931 err = vn_vget_ino_gen(dvp, zfsctl_root_vnode, NULL, lkflags, 932 vpp); 933 return (err); 934 } 935 936 if (cnp->cn_namelen >= sizeof (name)) 937 return (SET_ERROR(ENAMETOOLONG)); 938 939 strlcpy(name, ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen + 1); 940 err = zfsctl_snapshot_lookup(dvp, name, &snap_id); 941 if (err != 0) 942 return (SET_ERROR(ENOENT)); 943 944 for (;;) { 945 snapshot_setup_arg_t ssa; 946 947 ssa.snap_name = name; 948 ssa.snap_id = snap_id; 949 err = sfs_vgetx(dvp->v_mount, LK_SHARED, ZFSCTL_INO_SNAPDIR, 950 snap_id, "zfs", &zfsctl_ops_snapshot, 951 zfsctl_snapshot_vnode_setup, &ssa, vpp); 952 if (err != 0) 953 return (err); 954 955 /* Check if a new vnode has just been created. */ 956 if (VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE) 957 break; 958 959 /* 960 * Check if a snapshot is already mounted on top of the vnode. 961 */ 962 err = zfsctl_mounted_here(vpp, lkflags); 963 if (err != EJUSTRETURN) 964 return (err); 965 966 /* 967 * If the vnode is not covered, then either the mount operation 968 * is in progress or the snapshot has already been unmounted 969 * but the vnode hasn't been inactivated and reclaimed yet. 970 * We can try to re-use the vnode in the latter case. 971 */ 972 VI_LOCK(*vpp); 973 if (((*vpp)->v_iflag & VI_MOUNT) == 0) { 974 /* 975 * Upgrade to exclusive lock in order to: 976 * - avoid race conditions 977 * - satisfy the contract of mount_snapshot() 978 */ 979 err = VOP_LOCK(*vpp, LK_TRYUPGRADE | LK_INTERLOCK); 980 if (err == 0) 981 break; 982 } else { 983 VI_UNLOCK(*vpp); 984 } 985 986 /* 987 * In this state we can loop on uncontested locks and starve 988 * the thread doing the lengthy, non-trivial mount operation. 989 * So, yield to prevent that from happening. 990 */ 991 vput(*vpp); 992 kern_yield(PRI_USER); 993 } 994 995 VERIFY0(zfsctl_snapshot_zname(dvp, name, sizeof (fullname), fullname)); 996 997 mountpoint_len = strlen(dvp->v_vfsp->mnt_stat.f_mntonname) + 998 strlen("/" ZFS_CTLDIR_NAME "/snapshot/") + strlen(name) + 1; 999 mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP); 1000 (void) snprintf(mountpoint, mountpoint_len, 1001 "%s/" ZFS_CTLDIR_NAME "/snapshot/%s", 1002 dvp->v_vfsp->mnt_stat.f_mntonname, name); 1003 1004 err = mount_snapshot(curthread, vpp, "zfs", mountpoint, fullname, 0); 1005 kmem_free(mountpoint, mountpoint_len); 1006 if (err == 0) { 1007 /* 1008 * Fix up the root vnode mounted on .zfs/snapshot/<snapname>. 1009 * 1010 * This is where we lie about our v_vfsp in order to 1011 * make .zfs/snapshot/<snapname> accessible over NFS 1012 * without requiring manual mounts of <snapname>. 1013 */ 1014 ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs); 1015 VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs; 1016 1017 /* Clear the root flag (set via VFS_ROOT) as well. */ 1018 (*vpp)->v_vflag &= ~VV_ROOT; 1019 } 1020 1021 if (err != 0) 1022 *vpp = NULL; 1023 return (err); 1024 } 1025 1026 static int 1027 zfsctl_snapdir_readdir(struct vop_readdir_args *ap) 1028 { 1029 char snapname[ZFS_MAX_DATASET_NAME_LEN]; 1030 struct dirent entry; 1031 vnode_t *vp = ap->a_vp; 1032 zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1033 uio_t *uio = ap->a_uio; 1034 int *eofp = ap->a_eofflag; 1035 off_t dots_offset; 1036 int error; 1037 1038 ASSERT(vp->v_type == VDIR); 1039 1040 error = sfs_readdir_common(ZFSCTL_INO_ROOT, ZFSCTL_INO_SNAPDIR, ap, uio, 1041 &dots_offset); 1042 if (error != 0) { 1043 if (error == ENAMETOOLONG) /* ran out of destination space */ 1044 error = 0; 1045 return (error); 1046 } 1047 1048 ZFS_ENTER(zfsvfs); 1049 for (;;) { 1050 uint64_t cookie; 1051 uint64_t id; 1052 1053 cookie = uio->uio_offset - dots_offset; 1054 1055 dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG); 1056 error = dmu_snapshot_list_next(zfsvfs->z_os, sizeof (snapname), 1057 snapname, &id, &cookie, NULL); 1058 dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG); 1059 if (error != 0) { 1060 if (error == ENOENT) { 1061 if (eofp != NULL) 1062 *eofp = 1; 1063 error = 0; 1064 } 1065 ZFS_EXIT(zfsvfs); 1066 return (error); 1067 } 1068 1069 entry.d_fileno = id; 1070 entry.d_type = DT_DIR; 1071 strcpy(entry.d_name, snapname); 1072 entry.d_namlen = strlen(entry.d_name); 1073 entry.d_reclen = sizeof (entry); 1074 error = vfs_read_dirent(ap, &entry, uio->uio_offset); 1075 if (error != 0) { 1076 if (error == ENAMETOOLONG) 1077 error = 0; 1078 ZFS_EXIT(zfsvfs); 1079 return (SET_ERROR(error)); 1080 } 1081 uio->uio_offset = cookie + dots_offset; 1082 } 1083 /* NOTREACHED */ 1084 } 1085 1086 static int 1087 zfsctl_snapdir_getattr(struct vop_getattr_args *ap) 1088 { 1089 vnode_t *vp = ap->a_vp; 1090 vattr_t *vap = ap->a_vap; 1091 zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1092 dsl_dataset_t *ds; 1093 uint64_t snap_count; 1094 int err; 1095 1096 ZFS_ENTER(zfsvfs); 1097 ds = dmu_objset_ds(zfsvfs->z_os); 1098 zfsctl_common_getattr(vp, vap); 1099 vap->va_ctime = dmu_objset_snap_cmtime(zfsvfs->z_os); 1100 vap->va_mtime = vap->va_ctime; 1101 vap->va_birthtime = vap->va_ctime; 1102 if (dsl_dataset_phys(ds)->ds_snapnames_zapobj != 0) { 1103 err = zap_count(dmu_objset_pool(ds->ds_objset)->dp_meta_objset, 1104 dsl_dataset_phys(ds)->ds_snapnames_zapobj, &snap_count); 1105 if (err != 0) { 1106 ZFS_EXIT(zfsvfs); 1107 return (err); 1108 } 1109 vap->va_nlink += snap_count; 1110 } 1111 vap->va_size = vap->va_nlink; 1112 1113 ZFS_EXIT(zfsvfs); 1114 return (0); 1115 } 1116 1117 static struct vop_vector zfsctl_ops_snapdir = { 1118 .vop_default = &default_vnodeops, 1119 #if __FreeBSD_version >= 1300121 1120 .vop_fplookup_vexec = VOP_EAGAIN, 1121 #endif 1122 .vop_open = zfsctl_common_open, 1123 .vop_close = zfsctl_common_close, 1124 .vop_getattr = zfsctl_snapdir_getattr, 1125 .vop_access = zfsctl_common_access, 1126 .vop_readdir = zfsctl_snapdir_readdir, 1127 .vop_lookup = zfsctl_snapdir_lookup, 1128 .vop_reclaim = zfsctl_common_reclaim, 1129 .vop_fid = zfsctl_common_fid, 1130 .vop_print = zfsctl_common_print, 1131 .vop_pathconf = zfsctl_common_pathconf, 1132 .vop_getacl = zfsctl_common_getacl, 1133 }; 1134 VFS_VOP_VECTOR_REGISTER(zfsctl_ops_snapdir); 1135 1136 1137 static int 1138 zfsctl_snapshot_inactive(struct vop_inactive_args *ap) 1139 { 1140 vnode_t *vp = ap->a_vp; 1141 1142 VERIFY(vrecycle(vp) == 1); 1143 return (0); 1144 } 1145 1146 static int 1147 zfsctl_snapshot_reclaim(struct vop_reclaim_args *ap) 1148 { 1149 vnode_t *vp = ap->a_vp; 1150 void *data = vp->v_data; 1151 1152 sfs_reclaim_vnode(vp); 1153 sfs_destroy_node(data); 1154 return (0); 1155 } 1156 1157 static int 1158 zfsctl_snapshot_vptocnp(struct vop_vptocnp_args *ap) 1159 { 1160 struct mount *mp; 1161 vnode_t *dvp; 1162 vnode_t *vp; 1163 sfs_node_t *node; 1164 size_t len; 1165 int locked; 1166 int error; 1167 1168 vp = ap->a_vp; 1169 node = vp->v_data; 1170 len = strlen(node->sn_name); 1171 if (*ap->a_buflen < len) 1172 return (SET_ERROR(ENOMEM)); 1173 1174 /* 1175 * Prevent unmounting of the snapshot while the vnode lock 1176 * is not held. That is not strictly required, but allows 1177 * us to assert that an uncovered snapshot vnode is never 1178 * "leaked". 1179 */ 1180 mp = vp->v_mountedhere; 1181 if (mp == NULL) 1182 return (SET_ERROR(ENOENT)); 1183 error = vfs_busy(mp, 0); 1184 KASSERT(error == 0, ("vfs_busy(mp, 0) failed with %d", error)); 1185 1186 /* 1187 * We can vput the vnode as we can now depend on the reference owned 1188 * by the busied mp. But we also need to hold the vnode, because 1189 * the reference may go after vfs_unbusy() which has to be called 1190 * before we can lock the vnode again. 1191 */ 1192 locked = VOP_ISLOCKED(vp); 1193 #if __FreeBSD_version >= 1300045 1194 enum vgetstate vs = vget_prep(vp); 1195 #else 1196 vhold(vp); 1197 #endif 1198 vput(vp); 1199 1200 /* Look up .zfs/snapshot, our parent. */ 1201 error = zfsctl_snapdir_vnode(vp->v_mount, NULL, LK_SHARED, &dvp); 1202 if (error == 0) { 1203 VOP_UNLOCK1(dvp); 1204 *ap->a_vpp = dvp; 1205 *ap->a_buflen -= len; 1206 bcopy(node->sn_name, ap->a_buf + *ap->a_buflen, len); 1207 } 1208 vfs_unbusy(mp); 1209 #if __FreeBSD_version >= 1300045 1210 vget_finish(vp, locked | LK_RETRY, vs); 1211 #else 1212 vget(vp, locked | LK_VNHELD | LK_RETRY, curthread); 1213 #endif 1214 return (error); 1215 } 1216 1217 /* 1218 * These VP's should never see the light of day. They should always 1219 * be covered. 1220 */ 1221 static struct vop_vector zfsctl_ops_snapshot = { 1222 #if __FreeBSD_version >= 1300121 1223 .vop_fplookup_vexec = VOP_EAGAIN, 1224 #endif 1225 .vop_inactive = zfsctl_snapshot_inactive, 1226 #if __FreeBSD_version >= 1300045 1227 .vop_need_inactive = vop_stdneed_inactive, 1228 #endif 1229 .vop_reclaim = zfsctl_snapshot_reclaim, 1230 .vop_vptocnp = zfsctl_snapshot_vptocnp, 1231 .vop_lock1 = vop_stdlock, 1232 .vop_unlock = vop_stdunlock, 1233 .vop_islocked = vop_stdislocked, 1234 .vop_advlockpurge = vop_stdadvlockpurge, /* called by vgone */ 1235 .vop_print = zfsctl_common_print, 1236 }; 1237 VFS_VOP_VECTOR_REGISTER(zfsctl_ops_snapshot); 1238 1239 int 1240 zfsctl_lookup_objset(vfs_t *vfsp, uint64_t objsetid, zfsvfs_t **zfsvfsp) 1241 { 1242 zfsvfs_t *zfsvfs __unused = vfsp->vfs_data; 1243 vnode_t *vp; 1244 int error; 1245 1246 ASSERT(zfsvfs->z_ctldir != NULL); 1247 *zfsvfsp = NULL; 1248 error = sfs_vnode_get(vfsp, LK_EXCLUSIVE, 1249 ZFSCTL_INO_SNAPDIR, objsetid, &vp); 1250 if (error == 0 && vp != NULL) { 1251 /* 1252 * XXX Probably need to at least reference, if not busy, the mp. 1253 */ 1254 if (vp->v_mountedhere != NULL) 1255 *zfsvfsp = vp->v_mountedhere->mnt_data; 1256 vput(vp); 1257 } 1258 if (*zfsvfsp == NULL) 1259 return (SET_ERROR(EINVAL)); 1260 return (0); 1261 } 1262 1263 /* 1264 * Unmount any snapshots for the given filesystem. This is called from 1265 * zfs_umount() - if we have a ctldir, then go through and unmount all the 1266 * snapshots. 1267 */ 1268 int 1269 zfsctl_umount_snapshots(vfs_t *vfsp, int fflags, cred_t *cr) 1270 { 1271 char snapname[ZFS_MAX_DATASET_NAME_LEN]; 1272 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1273 struct mount *mp; 1274 vnode_t *vp; 1275 uint64_t cookie; 1276 int error; 1277 1278 ASSERT(zfsvfs->z_ctldir != NULL); 1279 1280 cookie = 0; 1281 for (;;) { 1282 uint64_t id; 1283 1284 dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG); 1285 error = dmu_snapshot_list_next(zfsvfs->z_os, sizeof (snapname), 1286 snapname, &id, &cookie, NULL); 1287 dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG); 1288 if (error != 0) { 1289 if (error == ENOENT) 1290 error = 0; 1291 break; 1292 } 1293 1294 for (;;) { 1295 error = sfs_vnode_get(vfsp, LK_EXCLUSIVE, 1296 ZFSCTL_INO_SNAPDIR, id, &vp); 1297 if (error != 0 || vp == NULL) 1298 break; 1299 1300 mp = vp->v_mountedhere; 1301 1302 /* 1303 * v_mountedhere being NULL means that the 1304 * (uncovered) vnode is in a transient state 1305 * (mounting or unmounting), so loop until it 1306 * settles down. 1307 */ 1308 if (mp != NULL) 1309 break; 1310 vput(vp); 1311 } 1312 if (error != 0) 1313 break; 1314 if (vp == NULL) 1315 continue; /* no mountpoint, nothing to do */ 1316 1317 /* 1318 * The mount-point vnode is kept locked to avoid spurious EBUSY 1319 * from a concurrent umount. 1320 * The vnode lock must have recursive locking enabled. 1321 */ 1322 vfs_ref(mp); 1323 error = dounmount(mp, fflags, curthread); 1324 KASSERT_IMPLY(error == 0, vrefcnt(vp) == 1, 1325 ("extra references after unmount")); 1326 vput(vp); 1327 if (error != 0) 1328 break; 1329 } 1330 KASSERT_IMPLY((fflags & MS_FORCE) != 0, error == 0, 1331 ("force unmounting failed")); 1332 return (error); 1333 } 1334 1335 int 1336 zfsctl_snapshot_unmount(const char *snapname, int flags __unused) 1337 { 1338 vfs_t *vfsp = NULL; 1339 zfsvfs_t *zfsvfs = NULL; 1340 1341 if (strchr(snapname, '@') == NULL) 1342 return (0); 1343 1344 int err = getzfsvfs(snapname, &zfsvfs); 1345 if (err != 0) { 1346 ASSERT3P(zfsvfs, ==, NULL); 1347 return (0); 1348 } 1349 vfsp = zfsvfs->z_vfs; 1350 1351 ASSERT(!dsl_pool_config_held(dmu_objset_pool(zfsvfs->z_os))); 1352 1353 vfs_ref(vfsp); 1354 vfs_unbusy(vfsp); 1355 return (dounmount(vfsp, MS_FORCE, curthread)); 1356 } 1357