module/os/freebsd/zfs/zfs_ctldir.c

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