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 https://opensource.org/licenses/CDDL-1.0. 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 zfs_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 (zfs_uio_resid(uio) < sizeof (entry)) 264 return (SET_ERROR(EINVAL)); 265 266 if (zfs_uio_offset(uio) < 0) 267 return (SET_ERROR(EINVAL)); 268 if (zfs_uio_offset(uio) == 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, zfs_uio_offset(uio)); 276 if (error != 0) 277 return (SET_ERROR(error)); 278 } 279 280 if (zfs_uio_offset(uio) < sizeof (entry)) 281 return (SET_ERROR(EINVAL)); 282 if (zfs_uio_offset(uio) == 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, zfs_uio_offset(uio)); 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 ASSERT3P(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 VERIFY0(VFS_ROOT(zfsvfs->z_vfs, LK_EXCLUSIVE, &rvp)); 364 VERIFY0(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 static int 460 zfsctl_common_close(struct vop_close_args *ap) 461 { 462 (void) ap; 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_gen = 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 ASSERT3S(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 zfs_uio_t uio; 670 int *eofp = ap->a_eofflag; 671 off_t dots_offset; 672 int error; 673 674 zfs_uio_init(&uio, ap->a_uio); 675 676 ASSERT3S(vp->v_type, ==, VDIR); 677 678 error = sfs_readdir_common(zfsvfs->z_root, ZFSCTL_INO_ROOT, ap, &uio, 679 &dots_offset); 680 if (error != 0) { 681 if (error == ENAMETOOLONG) /* ran out of destination space */ 682 error = 0; 683 return (error); 684 } 685 if (zfs_uio_offset(&uio) != dots_offset) 686 return (SET_ERROR(EINVAL)); 687 688 _Static_assert(sizeof (node->snapdir->sn_name) <= sizeof (entry.d_name), 689 "node->snapdir->sn_name too big for entry.d_name"); 690 entry.d_fileno = node->snapdir->sn_id; 691 entry.d_type = DT_DIR; 692 strcpy(entry.d_name, node->snapdir->sn_name); 693 entry.d_namlen = strlen(entry.d_name); 694 entry.d_reclen = sizeof (entry); 695 error = vfs_read_dirent(ap, &entry, zfs_uio_offset(&uio)); 696 if (error != 0) { 697 if (error == ENAMETOOLONG) 698 error = 0; 699 return (SET_ERROR(error)); 700 } 701 if (eofp != NULL) 702 *eofp = 1; 703 return (0); 704 } 705 706 static int 707 zfsctl_root_vptocnp(struct vop_vptocnp_args *ap) 708 { 709 static const char dotzfs_name[4] = ".zfs"; 710 vnode_t *dvp; 711 int error; 712 713 if (*ap->a_buflen < sizeof (dotzfs_name)) 714 return (SET_ERROR(ENOMEM)); 715 716 error = vn_vget_ino_gen(ap->a_vp, zfsctl_fs_root_vnode, NULL, 717 LK_SHARED, &dvp); 718 if (error != 0) 719 return (SET_ERROR(error)); 720 721 VOP_UNLOCK1(dvp); 722 *ap->a_vpp = dvp; 723 *ap->a_buflen -= sizeof (dotzfs_name); 724 memcpy(ap->a_buf + *ap->a_buflen, dotzfs_name, sizeof (dotzfs_name)); 725 return (0); 726 } 727 728 static int 729 zfsctl_common_pathconf(struct vop_pathconf_args *ap) 730 { 731 /* 732 * We care about ACL variables so that user land utilities like ls 733 * can display them correctly. Since the ctldir's st_dev is set to be 734 * the same as the parent dataset, we must support all variables that 735 * it supports. 736 */ 737 switch (ap->a_name) { 738 case _PC_LINK_MAX: 739 *ap->a_retval = MIN(LONG_MAX, ZFS_LINK_MAX); 740 return (0); 741 742 case _PC_FILESIZEBITS: 743 *ap->a_retval = 64; 744 return (0); 745 746 case _PC_MIN_HOLE_SIZE: 747 *ap->a_retval = (int)SPA_MINBLOCKSIZE; 748 return (0); 749 750 case _PC_ACL_EXTENDED: 751 *ap->a_retval = 0; 752 return (0); 753 754 case _PC_ACL_NFS4: 755 *ap->a_retval = 1; 756 return (0); 757 758 case _PC_ACL_PATH_MAX: 759 *ap->a_retval = ACL_MAX_ENTRIES; 760 return (0); 761 762 case _PC_NAME_MAX: 763 *ap->a_retval = NAME_MAX; 764 return (0); 765 766 default: 767 return (vop_stdpathconf(ap)); 768 } 769 } 770 771 /* 772 * Returns a trivial ACL 773 */ 774 static int 775 zfsctl_common_getacl(struct vop_getacl_args *ap) 776 { 777 int i; 778 779 if (ap->a_type != ACL_TYPE_NFS4) 780 return (EINVAL); 781 782 acl_nfs4_sync_acl_from_mode(ap->a_aclp, zfsctl_ctldir_mode, 0); 783 /* 784 * acl_nfs4_sync_acl_from_mode assumes that the owner can always modify 785 * attributes. That is not the case for the ctldir, so we must clear 786 * those bits. We also must clear ACL_READ_NAMED_ATTRS, because xattrs 787 * aren't supported by the ctldir. 788 */ 789 for (i = 0; i < ap->a_aclp->acl_cnt; i++) { 790 struct acl_entry *entry; 791 entry = &(ap->a_aclp->acl_entry[i]); 792 entry->ae_perm &= ~(ACL_WRITE_ACL | ACL_WRITE_OWNER | 793 ACL_WRITE_ATTRIBUTES | ACL_WRITE_NAMED_ATTRS | 794 ACL_READ_NAMED_ATTRS); 795 } 796 797 return (0); 798 } 799 800 static struct vop_vector zfsctl_ops_root = { 801 .vop_default = &default_vnodeops, 802 #if __FreeBSD_version >= 1300121 803 .vop_fplookup_vexec = VOP_EAGAIN, 804 #endif 805 #if __FreeBSD_version >= 1300139 806 .vop_fplookup_symlink = VOP_EAGAIN, 807 #endif 808 .vop_open = zfsctl_common_open, 809 .vop_close = zfsctl_common_close, 810 .vop_ioctl = VOP_EINVAL, 811 .vop_getattr = zfsctl_root_getattr, 812 .vop_access = zfsctl_common_access, 813 .vop_readdir = zfsctl_root_readdir, 814 .vop_lookup = zfsctl_root_lookup, 815 .vop_inactive = VOP_NULL, 816 .vop_reclaim = zfsctl_common_reclaim, 817 .vop_fid = zfsctl_common_fid, 818 .vop_print = zfsctl_common_print, 819 .vop_vptocnp = zfsctl_root_vptocnp, 820 .vop_pathconf = zfsctl_common_pathconf, 821 .vop_getacl = zfsctl_common_getacl, 822 #if __FreeBSD_version >= 1400043 823 .vop_add_writecount = vop_stdadd_writecount_nomsync, 824 #endif 825 }; 826 VFS_VOP_VECTOR_REGISTER(zfsctl_ops_root); 827 828 static int 829 zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname) 830 { 831 objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 832 833 dmu_objset_name(os, zname); 834 if (strlen(zname) + 1 + strlen(name) >= len) 835 return (SET_ERROR(ENAMETOOLONG)); 836 (void) strcat(zname, "@"); 837 (void) strcat(zname, name); 838 return (0); 839 } 840 841 static int 842 zfsctl_snapshot_lookup(vnode_t *vp, const char *name, uint64_t *id) 843 { 844 objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 845 int err; 846 847 err = dsl_dataset_snap_lookup(dmu_objset_ds(os), name, id); 848 return (err); 849 } 850 851 /* 852 * Given a vnode get a root vnode of a filesystem mounted on top of 853 * the vnode, if any. The root vnode is referenced and locked. 854 * If no filesystem is mounted then the orinal vnode remains referenced 855 * and locked. If any error happens the orinal vnode is unlocked and 856 * released. 857 */ 858 static int 859 zfsctl_mounted_here(vnode_t **vpp, int flags) 860 { 861 struct mount *mp; 862 int err; 863 864 ASSERT_VOP_LOCKED(*vpp, __func__); 865 ASSERT3S((*vpp)->v_type, ==, VDIR); 866 867 if ((mp = (*vpp)->v_mountedhere) != NULL) { 868 err = vfs_busy(mp, 0); 869 KASSERT(err == 0, ("vfs_busy(mp, 0) failed with %d", err)); 870 KASSERT(vrefcnt(*vpp) > 1, ("unreferenced mountpoint")); 871 vput(*vpp); 872 err = VFS_ROOT(mp, flags, vpp); 873 vfs_unbusy(mp); 874 return (err); 875 } 876 return (EJUSTRETURN); 877 } 878 879 typedef struct { 880 const char *snap_name; 881 uint64_t snap_id; 882 } snapshot_setup_arg_t; 883 884 static void 885 zfsctl_snapshot_vnode_setup(vnode_t *vp, void *arg) 886 { 887 snapshot_setup_arg_t *ssa = arg; 888 sfs_node_t *node; 889 890 ASSERT_VOP_ELOCKED(vp, __func__); 891 892 node = sfs_alloc_node(sizeof (sfs_node_t), 893 ssa->snap_name, ZFSCTL_INO_SNAPDIR, ssa->snap_id); 894 zfsctl_common_vnode_setup(vp, node); 895 896 /* We have to support recursive locking. */ 897 VN_LOCK_AREC(vp); 898 } 899 900 /* 901 * Lookup entry point for the 'snapshot' directory. Try to open the 902 * snapshot if it exist, creating the pseudo filesystem vnode as necessary. 903 * Perform a mount of the associated dataset on top of the vnode. 904 * There are four possibilities: 905 * - the snapshot node and vnode do not exist 906 * - the snapshot vnode is covered by the mounted snapshot 907 * - the snapshot vnode is not covered yet, the mount operation is in progress 908 * - the snapshot vnode is not covered, because the snapshot has been unmounted 909 * The last two states are transient and should be relatively short-lived. 910 */ 911 static int 912 zfsctl_snapdir_lookup(struct vop_lookup_args *ap) 913 { 914 vnode_t *dvp = ap->a_dvp; 915 vnode_t **vpp = ap->a_vpp; 916 struct componentname *cnp = ap->a_cnp; 917 char name[NAME_MAX + 1]; 918 char fullname[ZFS_MAX_DATASET_NAME_LEN]; 919 char *mountpoint; 920 size_t mountpoint_len; 921 zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 922 uint64_t snap_id; 923 int nameiop = cnp->cn_nameiop; 924 int lkflags = cnp->cn_lkflags; 925 int flags = cnp->cn_flags; 926 int err; 927 928 ASSERT3S(dvp->v_type, ==, VDIR); 929 930 if ((flags & ISLASTCN) != 0 && nameiop != LOOKUP) 931 return (SET_ERROR(ENOTSUP)); 932 933 if (cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.') { 934 err = zfsctl_relock_dot(dvp, lkflags & LK_TYPE_MASK); 935 if (err == 0) 936 *vpp = dvp; 937 return (err); 938 } 939 if (flags & ISDOTDOT) { 940 err = vn_vget_ino_gen(dvp, zfsctl_root_vnode, NULL, lkflags, 941 vpp); 942 return (err); 943 } 944 945 if (cnp->cn_namelen >= sizeof (name)) 946 return (SET_ERROR(ENAMETOOLONG)); 947 948 strlcpy(name, ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen + 1); 949 err = zfsctl_snapshot_lookup(dvp, name, &snap_id); 950 if (err != 0) 951 return (SET_ERROR(ENOENT)); 952 953 for (;;) { 954 snapshot_setup_arg_t ssa; 955 956 ssa.snap_name = name; 957 ssa.snap_id = snap_id; 958 err = sfs_vgetx(dvp->v_mount, LK_SHARED, ZFSCTL_INO_SNAPDIR, 959 snap_id, "zfs", &zfsctl_ops_snapshot, 960 zfsctl_snapshot_vnode_setup, &ssa, vpp); 961 if (err != 0) 962 return (err); 963 964 /* Check if a new vnode has just been created. */ 965 if (VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE) 966 break; 967 968 /* 969 * Check if a snapshot is already mounted on top of the vnode. 970 */ 971 err = zfsctl_mounted_here(vpp, lkflags); 972 if (err != EJUSTRETURN) 973 return (err); 974 975 /* 976 * If the vnode is not covered, then either the mount operation 977 * is in progress or the snapshot has already been unmounted 978 * but the vnode hasn't been inactivated and reclaimed yet. 979 * We can try to re-use the vnode in the latter case. 980 */ 981 VI_LOCK(*vpp); 982 if (((*vpp)->v_iflag & VI_MOUNT) == 0) { 983 VI_UNLOCK(*vpp); 984 /* 985 * Upgrade to exclusive lock in order to: 986 * - avoid race conditions 987 * - satisfy the contract of mount_snapshot() 988 */ 989 err = VOP_LOCK(*vpp, LK_TRYUPGRADE); 990 if (err == 0) 991 break; 992 } else { 993 VI_UNLOCK(*vpp); 994 } 995 996 /* 997 * In this state we can loop on uncontested locks and starve 998 * the thread doing the lengthy, non-trivial mount operation. 999 * So, yield to prevent that from happening. 1000 */ 1001 vput(*vpp); 1002 kern_yield(PRI_USER); 1003 } 1004 1005 VERIFY0(zfsctl_snapshot_zname(dvp, name, sizeof (fullname), fullname)); 1006 1007 mountpoint_len = strlen(dvp->v_vfsp->mnt_stat.f_mntonname) + 1008 strlen("/" ZFS_CTLDIR_NAME "/snapshot/") + strlen(name) + 1; 1009 mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP); 1010 (void) snprintf(mountpoint, mountpoint_len, 1011 "%s/" ZFS_CTLDIR_NAME "/snapshot/%s", 1012 dvp->v_vfsp->mnt_stat.f_mntonname, name); 1013 1014 err = mount_snapshot(curthread, vpp, "zfs", mountpoint, fullname, 0); 1015 kmem_free(mountpoint, mountpoint_len); 1016 if (err == 0) { 1017 /* 1018 * Fix up the root vnode mounted on .zfs/snapshot/<snapname>. 1019 * 1020 * This is where we lie about our v_vfsp in order to 1021 * make .zfs/snapshot/<snapname> accessible over NFS 1022 * without requiring manual mounts of <snapname>. 1023 */ 1024 ASSERT3P(VTOZ(*vpp)->z_zfsvfs, !=, zfsvfs); 1025 VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs; 1026 1027 /* Clear the root flag (set via VFS_ROOT) as well. */ 1028 (*vpp)->v_vflag &= ~VV_ROOT; 1029 } 1030 1031 if (err != 0) 1032 *vpp = NULL; 1033 return (err); 1034 } 1035 1036 static int 1037 zfsctl_snapdir_readdir(struct vop_readdir_args *ap) 1038 { 1039 char snapname[ZFS_MAX_DATASET_NAME_LEN]; 1040 struct dirent entry; 1041 vnode_t *vp = ap->a_vp; 1042 zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1043 zfs_uio_t uio; 1044 int *eofp = ap->a_eofflag; 1045 off_t dots_offset; 1046 int error; 1047 1048 zfs_uio_init(&uio, ap->a_uio); 1049 1050 ASSERT3S(vp->v_type, ==, VDIR); 1051 1052 error = sfs_readdir_common(ZFSCTL_INO_ROOT, ZFSCTL_INO_SNAPDIR, ap, 1053 &uio, &dots_offset); 1054 if (error != 0) { 1055 if (error == ENAMETOOLONG) /* ran out of destination space */ 1056 error = 0; 1057 return (error); 1058 } 1059 1060 if ((error = zfs_enter(zfsvfs, FTAG)) != 0) 1061 return (error); 1062 for (;;) { 1063 uint64_t cookie; 1064 uint64_t id; 1065 1066 cookie = zfs_uio_offset(&uio) - dots_offset; 1067 1068 dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG); 1069 error = dmu_snapshot_list_next(zfsvfs->z_os, sizeof (snapname), 1070 snapname, &id, &cookie, NULL); 1071 dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG); 1072 if (error != 0) { 1073 if (error == ENOENT) { 1074 if (eofp != NULL) 1075 *eofp = 1; 1076 error = 0; 1077 } 1078 zfs_exit(zfsvfs, FTAG); 1079 return (error); 1080 } 1081 1082 entry.d_fileno = id; 1083 entry.d_type = DT_DIR; 1084 strcpy(entry.d_name, snapname); 1085 entry.d_namlen = strlen(entry.d_name); 1086 entry.d_reclen = sizeof (entry); 1087 error = vfs_read_dirent(ap, &entry, zfs_uio_offset(&uio)); 1088 if (error != 0) { 1089 if (error == ENAMETOOLONG) 1090 error = 0; 1091 zfs_exit(zfsvfs, FTAG); 1092 return (SET_ERROR(error)); 1093 } 1094 zfs_uio_setoffset(&uio, cookie + dots_offset); 1095 } 1096 __builtin_unreachable(); 1097 } 1098 1099 static int 1100 zfsctl_snapdir_getattr(struct vop_getattr_args *ap) 1101 { 1102 vnode_t *vp = ap->a_vp; 1103 vattr_t *vap = ap->a_vap; 1104 zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1105 dsl_dataset_t *ds; 1106 uint64_t snap_count; 1107 int err; 1108 1109 if ((err = zfs_enter(zfsvfs, FTAG)) != 0) 1110 return (err); 1111 ds = dmu_objset_ds(zfsvfs->z_os); 1112 zfsctl_common_getattr(vp, vap); 1113 vap->va_ctime = dmu_objset_snap_cmtime(zfsvfs->z_os); 1114 vap->va_mtime = vap->va_ctime; 1115 vap->va_birthtime = vap->va_ctime; 1116 if (dsl_dataset_phys(ds)->ds_snapnames_zapobj != 0) { 1117 err = zap_count(dmu_objset_pool(ds->ds_objset)->dp_meta_objset, 1118 dsl_dataset_phys(ds)->ds_snapnames_zapobj, &snap_count); 1119 if (err != 0) { 1120 zfs_exit(zfsvfs, FTAG); 1121 return (err); 1122 } 1123 vap->va_nlink += snap_count; 1124 } 1125 vap->va_size = vap->va_nlink; 1126 1127 zfs_exit(zfsvfs, FTAG); 1128 return (0); 1129 } 1130 1131 static struct vop_vector zfsctl_ops_snapdir = { 1132 .vop_default = &default_vnodeops, 1133 #if __FreeBSD_version >= 1300121 1134 .vop_fplookup_vexec = VOP_EAGAIN, 1135 #endif 1136 #if __FreeBSD_version >= 1300139 1137 .vop_fplookup_symlink = VOP_EAGAIN, 1138 #endif 1139 .vop_open = zfsctl_common_open, 1140 .vop_close = zfsctl_common_close, 1141 .vop_getattr = zfsctl_snapdir_getattr, 1142 .vop_access = zfsctl_common_access, 1143 .vop_readdir = zfsctl_snapdir_readdir, 1144 .vop_lookup = zfsctl_snapdir_lookup, 1145 .vop_reclaim = zfsctl_common_reclaim, 1146 .vop_fid = zfsctl_common_fid, 1147 .vop_print = zfsctl_common_print, 1148 .vop_pathconf = zfsctl_common_pathconf, 1149 .vop_getacl = zfsctl_common_getacl, 1150 #if __FreeBSD_version >= 1400043 1151 .vop_add_writecount = vop_stdadd_writecount_nomsync, 1152 #endif 1153 }; 1154 VFS_VOP_VECTOR_REGISTER(zfsctl_ops_snapdir); 1155 1156 1157 static int 1158 zfsctl_snapshot_inactive(struct vop_inactive_args *ap) 1159 { 1160 vnode_t *vp = ap->a_vp; 1161 1162 vrecycle(vp); 1163 return (0); 1164 } 1165 1166 static int 1167 zfsctl_snapshot_reclaim(struct vop_reclaim_args *ap) 1168 { 1169 vnode_t *vp = ap->a_vp; 1170 void *data = vp->v_data; 1171 1172 sfs_reclaim_vnode(vp); 1173 sfs_destroy_node(data); 1174 return (0); 1175 } 1176 1177 static int 1178 zfsctl_snapshot_vptocnp(struct vop_vptocnp_args *ap) 1179 { 1180 struct mount *mp; 1181 vnode_t *dvp; 1182 vnode_t *vp; 1183 sfs_node_t *node; 1184 size_t len; 1185 int locked; 1186 int error; 1187 1188 vp = ap->a_vp; 1189 node = vp->v_data; 1190 len = strlen(node->sn_name); 1191 if (*ap->a_buflen < len) 1192 return (SET_ERROR(ENOMEM)); 1193 1194 /* 1195 * Prevent unmounting of the snapshot while the vnode lock 1196 * is not held. That is not strictly required, but allows 1197 * us to assert that an uncovered snapshot vnode is never 1198 * "leaked". 1199 */ 1200 mp = vp->v_mountedhere; 1201 if (mp == NULL) 1202 return (SET_ERROR(ENOENT)); 1203 error = vfs_busy(mp, 0); 1204 KASSERT(error == 0, ("vfs_busy(mp, 0) failed with %d", error)); 1205 1206 /* 1207 * We can vput the vnode as we can now depend on the reference owned 1208 * by the busied mp. But we also need to hold the vnode, because 1209 * the reference may go after vfs_unbusy() which has to be called 1210 * before we can lock the vnode again. 1211 */ 1212 locked = VOP_ISLOCKED(vp); 1213 #if __FreeBSD_version >= 1300045 1214 enum vgetstate vs = vget_prep(vp); 1215 #else 1216 vhold(vp); 1217 #endif 1218 vput(vp); 1219 1220 /* Look up .zfs/snapshot, our parent. */ 1221 error = zfsctl_snapdir_vnode(vp->v_mount, NULL, LK_SHARED, &dvp); 1222 if (error == 0) { 1223 VOP_UNLOCK1(dvp); 1224 *ap->a_vpp = dvp; 1225 *ap->a_buflen -= len; 1226 memcpy(ap->a_buf + *ap->a_buflen, node->sn_name, len); 1227 } 1228 vfs_unbusy(mp); 1229 #if __FreeBSD_version >= 1300045 1230 vget_finish(vp, locked | LK_RETRY, vs); 1231 #else 1232 vget(vp, locked | LK_VNHELD | LK_RETRY, curthread); 1233 #endif 1234 return (error); 1235 } 1236 1237 /* 1238 * These VP's should never see the light of day. They should always 1239 * be covered. 1240 */ 1241 static struct vop_vector zfsctl_ops_snapshot = { 1242 .vop_default = NULL, /* ensure very restricted access */ 1243 #if __FreeBSD_version >= 1300121 1244 .vop_fplookup_vexec = VOP_EAGAIN, 1245 #endif 1246 #if __FreeBSD_version >= 1300139 1247 .vop_fplookup_symlink = VOP_EAGAIN, 1248 #endif 1249 .vop_open = zfsctl_common_open, 1250 .vop_close = zfsctl_common_close, 1251 .vop_inactive = zfsctl_snapshot_inactive, 1252 #if __FreeBSD_version >= 1300045 1253 .vop_need_inactive = vop_stdneed_inactive, 1254 #endif 1255 .vop_reclaim = zfsctl_snapshot_reclaim, 1256 .vop_vptocnp = zfsctl_snapshot_vptocnp, 1257 .vop_lock1 = vop_stdlock, 1258 .vop_unlock = vop_stdunlock, 1259 .vop_islocked = vop_stdislocked, 1260 .vop_advlockpurge = vop_stdadvlockpurge, /* called by vgone */ 1261 .vop_print = zfsctl_common_print, 1262 #if __FreeBSD_version >= 1400043 1263 .vop_add_writecount = vop_stdadd_writecount_nomsync, 1264 #endif 1265 }; 1266 VFS_VOP_VECTOR_REGISTER(zfsctl_ops_snapshot); 1267 1268 int 1269 zfsctl_lookup_objset(vfs_t *vfsp, uint64_t objsetid, zfsvfs_t **zfsvfsp) 1270 { 1271 zfsvfs_t *zfsvfs __unused = vfsp->vfs_data; 1272 vnode_t *vp; 1273 int error; 1274 1275 ASSERT3P(zfsvfs->z_ctldir, !=, NULL); 1276 *zfsvfsp = NULL; 1277 error = sfs_vnode_get(vfsp, LK_EXCLUSIVE, 1278 ZFSCTL_INO_SNAPDIR, objsetid, &vp); 1279 if (error == 0 && vp != NULL) { 1280 /* 1281 * XXX Probably need to at least reference, if not busy, the mp. 1282 */ 1283 if (vp->v_mountedhere != NULL) 1284 *zfsvfsp = vp->v_mountedhere->mnt_data; 1285 vput(vp); 1286 } 1287 if (*zfsvfsp == NULL) 1288 return (SET_ERROR(EINVAL)); 1289 return (0); 1290 } 1291 1292 /* 1293 * Unmount any snapshots for the given filesystem. This is called from 1294 * zfs_umount() - if we have a ctldir, then go through and unmount all the 1295 * snapshots. 1296 */ 1297 int 1298 zfsctl_umount_snapshots(vfs_t *vfsp, int fflags, cred_t *cr) 1299 { 1300 char snapname[ZFS_MAX_DATASET_NAME_LEN]; 1301 zfsvfs_t *zfsvfs = vfsp->vfs_data; 1302 struct mount *mp; 1303 vnode_t *vp; 1304 uint64_t cookie; 1305 int error; 1306 1307 ASSERT3P(zfsvfs->z_ctldir, !=, NULL); 1308 1309 cookie = 0; 1310 for (;;) { 1311 uint64_t id; 1312 1313 dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG); 1314 error = dmu_snapshot_list_next(zfsvfs->z_os, sizeof (snapname), 1315 snapname, &id, &cookie, NULL); 1316 dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG); 1317 if (error != 0) { 1318 if (error == ENOENT) 1319 error = 0; 1320 break; 1321 } 1322 1323 for (;;) { 1324 error = sfs_vnode_get(vfsp, LK_EXCLUSIVE, 1325 ZFSCTL_INO_SNAPDIR, id, &vp); 1326 if (error != 0 || vp == NULL) 1327 break; 1328 1329 mp = vp->v_mountedhere; 1330 1331 /* 1332 * v_mountedhere being NULL means that the 1333 * (uncovered) vnode is in a transient state 1334 * (mounting or unmounting), so loop until it 1335 * settles down. 1336 */ 1337 if (mp != NULL) 1338 break; 1339 vput(vp); 1340 } 1341 if (error != 0) 1342 break; 1343 if (vp == NULL) 1344 continue; /* no mountpoint, nothing to do */ 1345 1346 /* 1347 * The mount-point vnode is kept locked to avoid spurious EBUSY 1348 * from a concurrent umount. 1349 * The vnode lock must have recursive locking enabled. 1350 */ 1351 vfs_ref(mp); 1352 error = dounmount(mp, fflags, curthread); 1353 KASSERT_IMPLY(error == 0, vrefcnt(vp) == 1, 1354 ("extra references after unmount")); 1355 vput(vp); 1356 if (error != 0) 1357 break; 1358 } 1359 KASSERT_IMPLY((fflags & MS_FORCE) != 0, error == 0, 1360 ("force unmounting failed")); 1361 return (error); 1362 } 1363 1364 int 1365 zfsctl_snapshot_unmount(const char *snapname, int flags __unused) 1366 { 1367 vfs_t *vfsp = NULL; 1368 zfsvfs_t *zfsvfs = NULL; 1369 1370 if (strchr(snapname, '@') == NULL) 1371 return (0); 1372 1373 int err = getzfsvfs(snapname, &zfsvfs); 1374 if (err != 0) { 1375 ASSERT3P(zfsvfs, ==, NULL); 1376 return (0); 1377 } 1378 vfsp = zfsvfs->z_vfs; 1379 1380 ASSERT(!dsl_pool_config_held(dmu_objset_pool(zfsvfs->z_os))); 1381 1382 vfs_ref(vfsp); 1383 vfs_unbusy(vfsp); 1384 return (dounmount(vfsp, MS_FORCE, curthread)); 1385 } 1386