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