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 <fs/fs_subr.h>
  69 #include <sys/zfs_ctldir.h>
  70 #include <sys/zfs_ioctl.h>
  71 #include <sys/zfs_vfsops.h>
  72 #include <sys/vfs_opreg.h>
  73 #include <sys/gfs.h>
  74 #include <sys/stat.h>
  75 #include <sys/dmu.h>
  76 #include <sys/dsl_destroy.h>
  77 #include <sys/dsl_deleg.h>
  78 #include <sys/mount.h>
  79 #include <sys/sunddi.h>
  80 
  81 #include "zfs_namecheck.h"
  82 
  83 typedef struct zfsctl_node {
  84         gfs_dir_t       zc_gfs_private;
  85         uint64_t        zc_id;
  86         timestruc_t     zc_cmtime;      /* ctime and mtime, always the same */
  87 } zfsctl_node_t;
  88 
  89 typedef struct zfsctl_snapdir {
  90         zfsctl_node_t   sd_node;
  91         kmutex_t        sd_lock;
  92         avl_tree_t      sd_snaps;
  93 } zfsctl_snapdir_t;
  94 
  95 typedef struct {
  96         char            *se_name;
  97         vnode_t         *se_root;
  98         avl_node_t      se_node;
  99 } zfs_snapentry_t;
 100 
 101 static int
 102 snapentry_compare(const void *a, const void *b)
 103 {
 104         const zfs_snapentry_t *sa = a;
 105         const zfs_snapentry_t *sb = b;
 106         int ret = strcmp(sa->se_name, sb->se_name);
 107 
 108         if (ret < 0)
 109                 return (-1);
 110         else if (ret > 0)
 111                 return (1);
 112         else
 113                 return (0);
 114 }
 115 
 116 vnodeops_t *zfsctl_ops_root;
 117 vnodeops_t *zfsctl_ops_snapdir;
 118 vnodeops_t *zfsctl_ops_snapshot;
 119 vnodeops_t *zfsctl_ops_shares;
 120 vnodeops_t *zfsctl_ops_shares_dir;
 121 
 122 static const fs_operation_def_t zfsctl_tops_root[];
 123 static const fs_operation_def_t zfsctl_tops_snapdir[];
 124 static const fs_operation_def_t zfsctl_tops_snapshot[];
 125 static const fs_operation_def_t zfsctl_tops_shares[];
 126 
 127 static vnode_t *zfsctl_mknode_snapdir(vnode_t *);
 128 static vnode_t *zfsctl_mknode_shares(vnode_t *);
 129 static vnode_t *zfsctl_snapshot_mknode(vnode_t *, uint64_t objset);
 130 static int zfsctl_unmount_snap(zfs_snapentry_t *, int, cred_t *);
 131 
 132 static gfs_opsvec_t zfsctl_opsvec[] = {
 133         { ".zfs", zfsctl_tops_root, &zfsctl_ops_root },
 134         { ".zfs/snapshot", zfsctl_tops_snapdir, &zfsctl_ops_snapdir },
 135         { ".zfs/snapshot/vnode", zfsctl_tops_snapshot, &zfsctl_ops_snapshot },
 136         { ".zfs/shares", zfsctl_tops_shares, &zfsctl_ops_shares_dir },
 137         { ".zfs/shares/vnode", zfsctl_tops_shares, &zfsctl_ops_shares },
 138         { NULL }
 139 };
 140 
 141 /*
 142  * Root directory elements.  We only have two entries
 143  * snapshot and shares.
 144  */
 145 static gfs_dirent_t zfsctl_root_entries[] = {
 146         { "snapshot", zfsctl_mknode_snapdir, GFS_CACHE_VNODE },
 147         { "shares", zfsctl_mknode_shares, GFS_CACHE_VNODE },
 148         { NULL }
 149 };
 150 
 151 /* include . and .. in the calculation */
 152 #define NROOT_ENTRIES   ((sizeof (zfsctl_root_entries) / \
 153     sizeof (gfs_dirent_t)) + 1)
 154 
 155 
 156 /*
 157  * Initialize the various GFS pieces we'll need to create and manipulate .zfs
 158  * directories.  This is called from the ZFS init routine, and initializes the
 159  * vnode ops vectors that we'll be using.
 160  */
 161 void
 162 zfsctl_init(void)
 163 {
 164         VERIFY(gfs_make_opsvec(zfsctl_opsvec) == 0);
 165 }
 166 
 167 void
 168 zfsctl_fini(void)
 169 {
 170         /*
 171          * Remove vfsctl vnode ops
 172          */
 173         if (zfsctl_ops_root)
 174                 vn_freevnodeops(zfsctl_ops_root);
 175         if (zfsctl_ops_snapdir)
 176                 vn_freevnodeops(zfsctl_ops_snapdir);
 177         if (zfsctl_ops_snapshot)
 178                 vn_freevnodeops(zfsctl_ops_snapshot);
 179         if (zfsctl_ops_shares)
 180                 vn_freevnodeops(zfsctl_ops_shares);
 181         if (zfsctl_ops_shares_dir)
 182                 vn_freevnodeops(zfsctl_ops_shares_dir);
 183 
 184         zfsctl_ops_root = NULL;
 185         zfsctl_ops_snapdir = NULL;
 186         zfsctl_ops_snapshot = NULL;
 187         zfsctl_ops_shares = NULL;
 188         zfsctl_ops_shares_dir = NULL;
 189 }
 190 
 191 boolean_t
 192 zfsctl_is_node(vnode_t *vp)
 193 {
 194         return (vn_matchops(vp, zfsctl_ops_root) ||
 195             vn_matchops(vp, zfsctl_ops_snapdir) ||
 196             vn_matchops(vp, zfsctl_ops_snapshot) ||
 197             vn_matchops(vp, zfsctl_ops_shares) ||
 198             vn_matchops(vp, zfsctl_ops_shares_dir));
 199 
 200 }
 201 
 202 /*
 203  * Return the inode number associated with the 'snapshot' or
 204  * 'shares' directory.
 205  */
 206 /* ARGSUSED */
 207 static ino64_t
 208 zfsctl_root_inode_cb(vnode_t *vp, int index)
 209 {
 210         zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
 211 
 212         ASSERT(index <= 2);
 213 
 214         if (index == 0)
 215                 return (ZFSCTL_INO_SNAPDIR);
 216 
 217         return (zfsvfs->z_shares_dir);
 218 }
 219 
 220 /*
 221  * Create the '.zfs' directory.  This directory is cached as part of the VFS
 222  * structure.  This results in a hold on the vfs_t.  The code in zfs_umount()
 223  * therefore checks against a vfs_count of 2 instead of 1.  This reference
 224  * is removed when the ctldir is destroyed in the unmount.
 225  */
 226 void
 227 zfsctl_create(zfsvfs_t *zfsvfs)
 228 {
 229         vnode_t *vp, *rvp;
 230         zfsctl_node_t *zcp;
 231         uint64_t crtime[2];
 232 
 233         ASSERT(zfsvfs->z_ctldir == NULL);
 234 
 235         vp = gfs_root_create(sizeof (zfsctl_node_t), zfsvfs->z_vfs,
 236             zfsctl_ops_root, ZFSCTL_INO_ROOT, zfsctl_root_entries,
 237             zfsctl_root_inode_cb, MAXNAMELEN, NULL, NULL);
 238         zcp = vp->v_data;
 239         zcp->zc_id = ZFSCTL_INO_ROOT;
 240 
 241         VERIFY(VFS_ROOT(zfsvfs->z_vfs, &rvp) == 0);
 242         VERIFY(0 == sa_lookup(VTOZ(rvp)->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs),
 243             &crtime, sizeof (crtime)));
 244         ZFS_TIME_DECODE(&zcp->zc_cmtime, crtime);
 245         VN_RELE(rvp);
 246 
 247         /*
 248          * We're only faking the fact that we have a root of a filesystem for
 249          * the sake of the GFS interfaces.  Undo the flag manipulation it did
 250          * for us.
 251          */
 252         vp->v_flag &= ~(VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT);
 253 
 254         zfsvfs->z_ctldir = vp;
 255 }
 256 
 257 /*
 258  * Destroy the '.zfs' directory.  Only called when the filesystem is unmounted.
 259  * There might still be more references if we were force unmounted, but only
 260  * new zfs_inactive() calls can occur and they don't reference .zfs
 261  */
 262 void
 263 zfsctl_destroy(zfsvfs_t *zfsvfs)
 264 {
 265         VN_RELE(zfsvfs->z_ctldir);
 266         zfsvfs->z_ctldir = NULL;
 267 }
 268 
 269 /*
 270  * Given a root znode, retrieve the associated .zfs directory.
 271  * Add a hold to the vnode and return it.
 272  */
 273 vnode_t *
 274 zfsctl_root(znode_t *zp)
 275 {
 276         ASSERT(zfs_has_ctldir(zp));
 277         VN_HOLD(zp->z_zfsvfs->z_ctldir);
 278         return (zp->z_zfsvfs->z_ctldir);
 279 }
 280 
 281 /*
 282  * Common open routine.  Disallow any write access.
 283  */
 284 /* ARGSUSED */
 285 static int
 286 zfsctl_common_open(vnode_t **vpp, int flags, cred_t *cr, caller_context_t *ct)
 287 {
 288         if (flags & FWRITE)
 289                 return (SET_ERROR(EACCES));
 290 
 291         return (0);
 292 }
 293 
 294 /*
 295  * Common close routine.  Nothing to do here.
 296  */
 297 /* ARGSUSED */
 298 static int
 299 zfsctl_common_close(vnode_t *vpp, int flags, int count, offset_t off,
 300     cred_t *cr, caller_context_t *ct)
 301 {
 302         return (0);
 303 }
 304 
 305 /*
 306  * Common access routine.  Disallow writes.
 307  */
 308 /* ARGSUSED */
 309 static int
 310 zfsctl_common_access(vnode_t *vp, int mode, int flags, cred_t *cr,
 311     caller_context_t *ct)
 312 {
 313         if (flags & V_ACE_MASK) {
 314                 if (mode & ACE_ALL_WRITE_PERMS)
 315                         return (SET_ERROR(EACCES));
 316         } else {
 317                 if (mode & VWRITE)
 318                         return (SET_ERROR(EACCES));
 319         }
 320 
 321         return (0);
 322 }
 323 
 324 /*
 325  * Common getattr function.  Fill in basic information.
 326  */
 327 static void
 328 zfsctl_common_getattr(vnode_t *vp, vattr_t *vap)
 329 {
 330         timestruc_t     now;
 331 
 332         vap->va_uid = 0;
 333         vap->va_gid = 0;
 334         vap->va_rdev = 0;
 335         /*
 336          * We are a purely virtual object, so we have no
 337          * blocksize or allocated blocks.
 338          */
 339         vap->va_blksize = 0;
 340         vap->va_nblocks = 0;
 341         vap->va_seq = 0;
 342         vap->va_fsid = vp->v_vfsp->vfs_dev;
 343         vap->va_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP |
 344             S_IROTH | S_IXOTH;
 345         vap->va_type = VDIR;
 346         /*
 347          * We live in the now (for atime).
 348          */
 349         gethrestime(&now);
 350         vap->va_atime = now;
 351 }
 352 
 353 /*ARGSUSED*/
 354 static int
 355 zfsctl_common_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
 356 {
 357         zfsvfs_t        *zfsvfs = vp->v_vfsp->vfs_data;
 358         zfsctl_node_t   *zcp = vp->v_data;
 359         uint64_t        object = zcp->zc_id;
 360         zfid_short_t    *zfid;
 361         int             i;
 362 
 363         ZFS_ENTER(zfsvfs);
 364 
 365         if (fidp->fid_len < SHORT_FID_LEN) {
 366                 fidp->fid_len = SHORT_FID_LEN;
 367                 ZFS_EXIT(zfsvfs);
 368                 return (SET_ERROR(ENOSPC));
 369         }
 370 
 371         zfid = (zfid_short_t *)fidp;
 372 
 373         zfid->zf_len = SHORT_FID_LEN;
 374 
 375         for (i = 0; i < sizeof (zfid->zf_object); i++)
 376                 zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
 377 
 378         /* .zfs znodes always have a generation number of 0 */
 379         for (i = 0; i < sizeof (zfid->zf_gen); i++)
 380                 zfid->zf_gen[i] = 0;
 381 
 382         ZFS_EXIT(zfsvfs);
 383         return (0);
 384 }
 385 
 386 
 387 /*ARGSUSED*/
 388 static int
 389 zfsctl_shares_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
 390 {
 391         zfsvfs_t        *zfsvfs = vp->v_vfsp->vfs_data;
 392         znode_t         *dzp;
 393         int             error;
 394 
 395         ZFS_ENTER(zfsvfs);
 396 
 397         if (zfsvfs->z_shares_dir == 0) {
 398                 ZFS_EXIT(zfsvfs);
 399                 return (SET_ERROR(ENOTSUP));
 400         }
 401 
 402         if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {
 403                 error = VOP_FID(ZTOV(dzp), fidp, ct);
 404                 VN_RELE(ZTOV(dzp));
 405         }
 406 
 407         ZFS_EXIT(zfsvfs);
 408         return (error);
 409 }
 410 /*
 411  * .zfs inode namespace
 412  *
 413  * We need to generate unique inode numbers for all files and directories
 414  * within the .zfs pseudo-filesystem.  We use the following scheme:
 415  *
 416  *      ENTRY                   ZFSCTL_INODE
 417  *      .zfs                    1
 418  *      .zfs/snapshot           2
 419  *      .zfs/snapshot/<snap>      objectid(snap)
 420  */
 421 
 422 #define ZFSCTL_INO_SNAP(id)     (id)
 423 
 424 /*
 425  * Get root directory attributes.
 426  */
 427 /* ARGSUSED */
 428 static int
 429 zfsctl_root_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
 430     caller_context_t *ct)
 431 {
 432         zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
 433         zfsctl_node_t *zcp = vp->v_data;
 434 
 435         ZFS_ENTER(zfsvfs);
 436         vap->va_nodeid = ZFSCTL_INO_ROOT;
 437         vap->va_nlink = vap->va_size = NROOT_ENTRIES;
 438         vap->va_mtime = vap->va_ctime = zcp->zc_cmtime;
 439 
 440         zfsctl_common_getattr(vp, vap);
 441         ZFS_EXIT(zfsvfs);
 442 
 443         return (0);
 444 }
 445 
 446 /*
 447  * Special case the handling of "..".
 448  */
 449 /* ARGSUSED */
 450 int
 451 zfsctl_root_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
 452     int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
 453     int *direntflags, pathname_t *realpnp)
 454 {
 455         zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
 456         int err;
 457 
 458         /*
 459          * No extended attributes allowed under .zfs
 460          */
 461         if (flags & LOOKUP_XATTR)
 462                 return (SET_ERROR(EINVAL));
 463 
 464         ZFS_ENTER(zfsvfs);
 465 
 466         if (strcmp(nm, "..") == 0) {
 467                 err = VFS_ROOT(dvp->v_vfsp, vpp);
 468         } else {
 469                 err = gfs_vop_lookup(dvp, nm, vpp, pnp, flags, rdir,
 470                     cr, ct, direntflags, realpnp);
 471         }
 472 
 473         ZFS_EXIT(zfsvfs);
 474 
 475         return (err);
 476 }
 477 
 478 static int
 479 zfsctl_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
 480     caller_context_t *ct)
 481 {
 482         /*
 483          * We only care about ACL_ENABLED so that libsec can
 484          * display ACL correctly and not default to POSIX draft.
 485          */
 486         if (cmd == _PC_ACL_ENABLED) {
 487                 *valp = _ACL_ACE_ENABLED;
 488                 return (0);
 489         }
 490 
 491         return (fs_pathconf(vp, cmd, valp, cr, ct));
 492 }
 493 
 494 static const fs_operation_def_t zfsctl_tops_root[] = {
 495         { VOPNAME_OPEN,         { .vop_open = zfsctl_common_open }      },
 496         { VOPNAME_CLOSE,        { .vop_close = zfsctl_common_close }    },
 497         { VOPNAME_IOCTL,        { .error = fs_inval }                   },
 498         { VOPNAME_GETATTR,      { .vop_getattr = zfsctl_root_getattr }  },
 499         { VOPNAME_ACCESS,       { .vop_access = zfsctl_common_access }  },
 500         { VOPNAME_READDIR,      { .vop_readdir = gfs_vop_readdir }      },
 501         { VOPNAME_LOOKUP,       { .vop_lookup = zfsctl_root_lookup }    },
 502         { VOPNAME_SEEK,         { .vop_seek = fs_seek }                 },
 503         { VOPNAME_INACTIVE,     { .vop_inactive = gfs_vop_inactive }    },
 504         { VOPNAME_PATHCONF,     { .vop_pathconf = zfsctl_pathconf }     },
 505         { VOPNAME_FID,          { .vop_fid = zfsctl_common_fid  }       },
 506         { NULL }
 507 };
 508 
 509 /*
 510  * Gets the full dataset name that corresponds to the given snapshot name
 511  * Example:
 512  *      zfsctl_snapshot_zname("snap1") -> "mypool/myfs@snap1"
 513  */
 514 static int
 515 zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname)
 516 {
 517         objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os;
 518 
 519         if (zfs_component_namecheck(name, NULL, NULL) != 0)
 520                 return (SET_ERROR(EILSEQ));
 521         dmu_objset_name(os, zname);
 522         if (strlen(zname) + 1 + strlen(name) >= len)
 523                 return (SET_ERROR(ENAMETOOLONG));
 524         (void) strcat(zname, "@");
 525         (void) strcat(zname, name);
 526         return (0);
 527 }
 528 
 529 static int
 530 zfsctl_unmount_snap(zfs_snapentry_t *sep, int fflags, cred_t *cr)
 531 {
 532         vnode_t *svp = sep->se_root;
 533         int error;
 534 
 535         ASSERT(vn_ismntpt(svp));
 536 
 537         /* this will be dropped by dounmount() */
 538         if ((error = vn_vfswlock(svp)) != 0)
 539                 return (error);
 540 
 541         VN_HOLD(svp);
 542         error = dounmount(vn_mountedvfs(svp), fflags, cr);
 543         if (error) {
 544                 VN_RELE(svp);
 545                 return (error);
 546         }
 547 
 548         /*
 549          * We can't use VN_RELE(), as that will try to invoke
 550          * zfsctl_snapdir_inactive(), which would cause us to destroy
 551          * the sd_lock mutex held by our caller.
 552          */
 553         ASSERT(svp->v_count == 1);
 554         gfs_vop_inactive(svp, cr, NULL);
 555 
 556         kmem_free(sep->se_name, strlen(sep->se_name) + 1);
 557         kmem_free(sep, sizeof (zfs_snapentry_t));
 558 
 559         return (0);
 560 }
 561 
 562 static void
 563 zfsctl_rename_snap(zfsctl_snapdir_t *sdp, zfs_snapentry_t *sep, const char *nm)
 564 {
 565         avl_index_t where;
 566         vfs_t *vfsp;
 567         refstr_t *pathref;
 568         char newpath[MAXNAMELEN];
 569         char *tail;
 570 
 571         ASSERT(MUTEX_HELD(&sdp->sd_lock));
 572         ASSERT(sep != NULL);
 573 
 574         vfsp = vn_mountedvfs(sep->se_root);
 575         ASSERT(vfsp != NULL);
 576 
 577         vfs_lock_wait(vfsp);
 578 
 579         /*
 580          * Change the name in the AVL tree.
 581          */
 582         avl_remove(&sdp->sd_snaps, sep);
 583         kmem_free(sep->se_name, strlen(sep->se_name) + 1);
 584         sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP);
 585         (void) strcpy(sep->se_name, nm);
 586         VERIFY(avl_find(&sdp->sd_snaps, sep, &where) == NULL);
 587         avl_insert(&sdp->sd_snaps, sep, where);
 588 
 589         /*
 590          * Change the current mountpoint info:
 591          *      - update the tail of the mntpoint path
 592          *      - update the tail of the resource path
 593          */
 594         pathref = vfs_getmntpoint(vfsp);
 595         (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath));
 596         VERIFY((tail = strrchr(newpath, '/')) != NULL);
 597         *(tail+1) = '\0';
 598         ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath));
 599         (void) strcat(newpath, nm);
 600         refstr_rele(pathref);
 601         vfs_setmntpoint(vfsp, newpath, 0);
 602 
 603         pathref = vfs_getresource(vfsp);
 604         (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath));
 605         VERIFY((tail = strrchr(newpath, '@')) != NULL);
 606         *(tail+1) = '\0';
 607         ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath));
 608         (void) strcat(newpath, nm);
 609         refstr_rele(pathref);
 610         vfs_setresource(vfsp, newpath, 0);
 611 
 612         vfs_unlock(vfsp);
 613 }
 614 
 615 /*ARGSUSED*/
 616 static int
 617 zfsctl_snapdir_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm,
 618     cred_t *cr, caller_context_t *ct, int flags)
 619 {
 620         zfsctl_snapdir_t *sdp = sdvp->v_data;
 621         zfs_snapentry_t search, *sep;
 622         zfsvfs_t *zfsvfs;
 623         avl_index_t where;
 624         char from[ZFS_MAX_DATASET_NAME_LEN], to[ZFS_MAX_DATASET_NAME_LEN];
 625         char real[ZFS_MAX_DATASET_NAME_LEN], fsname[ZFS_MAX_DATASET_NAME_LEN];
 626         int err;
 627 
 628         zfsvfs = sdvp->v_vfsp->vfs_data;
 629         ZFS_ENTER(zfsvfs);
 630 
 631         if ((flags & FIGNORECASE) || zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
 632                 err = dmu_snapshot_realname(zfsvfs->z_os, snm, real,
 633                     sizeof (real), NULL);
 634                 if (err == 0) {
 635                         snm = real;
 636                 } else if (err != ENOTSUP) {
 637                         ZFS_EXIT(zfsvfs);
 638                         return (err);
 639                 }
 640         }
 641 
 642         ZFS_EXIT(zfsvfs);
 643 
 644         dmu_objset_name(zfsvfs->z_os, fsname);
 645 
 646         err = zfsctl_snapshot_zname(sdvp, snm, sizeof (from), from);
 647         if (err == 0)
 648                 err = zfsctl_snapshot_zname(tdvp, tnm, sizeof (to), to);
 649         if (err == 0)
 650                 err = zfs_secpolicy_rename_perms(from, to, cr);
 651         if (err != 0)
 652                 return (err);
 653 
 654         /*
 655          * Cannot move snapshots out of the snapdir.
 656          */
 657         if (sdvp != tdvp)
 658                 return (SET_ERROR(EINVAL));
 659 
 660         if (strcmp(snm, tnm) == 0)
 661                 return (0);
 662 
 663         mutex_enter(&sdp->sd_lock);
 664 
 665         search.se_name = (char *)snm;
 666         if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) == NULL) {
 667                 mutex_exit(&sdp->sd_lock);
 668                 return (SET_ERROR(ENOENT));
 669         }
 670 
 671         err = dsl_dataset_rename_snapshot(fsname, snm, tnm, B_FALSE);
 672         if (err == 0)
 673                 zfsctl_rename_snap(sdp, sep, tnm);
 674 
 675         mutex_exit(&sdp->sd_lock);
 676 
 677         return (err);
 678 }
 679 
 680 /* ARGSUSED */
 681 static int
 682 zfsctl_snapdir_remove(vnode_t *dvp, char *name, vnode_t *cwd, cred_t *cr,
 683     caller_context_t *ct, int flags)
 684 {
 685         zfsctl_snapdir_t *sdp = dvp->v_data;
 686         zfs_snapentry_t *sep;
 687         zfs_snapentry_t search;
 688         zfsvfs_t *zfsvfs;
 689         char snapname[ZFS_MAX_DATASET_NAME_LEN];
 690         char real[ZFS_MAX_DATASET_NAME_LEN];
 691         int err;
 692 
 693         zfsvfs = dvp->v_vfsp->vfs_data;
 694         ZFS_ENTER(zfsvfs);
 695 
 696         if ((flags & FIGNORECASE) || zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
 697 
 698                 err = dmu_snapshot_realname(zfsvfs->z_os, name, real,
 699                     sizeof (real), NULL);
 700                 if (err == 0) {
 701                         name = real;
 702                 } else if (err != ENOTSUP) {
 703                         ZFS_EXIT(zfsvfs);
 704                         return (err);
 705                 }
 706         }
 707 
 708         ZFS_EXIT(zfsvfs);
 709 
 710         err = zfsctl_snapshot_zname(dvp, name, sizeof (snapname), snapname);
 711         if (err == 0)
 712                 err = zfs_secpolicy_destroy_perms(snapname, cr);
 713         if (err != 0)
 714                 return (err);
 715 
 716         mutex_enter(&sdp->sd_lock);
 717 
 718         search.se_name = name;
 719         sep = avl_find(&sdp->sd_snaps, &search, NULL);
 720         if (sep) {
 721                 avl_remove(&sdp->sd_snaps, sep);
 722                 err = zfsctl_unmount_snap(sep, MS_FORCE, cr);
 723                 if (err != 0)
 724                         avl_add(&sdp->sd_snaps, sep);
 725                 else
 726                         err = dsl_destroy_snapshot(snapname, B_FALSE);
 727         } else {
 728                 err = SET_ERROR(ENOENT);
 729         }
 730 
 731         mutex_exit(&sdp->sd_lock);
 732 
 733         return (err);
 734 }
 735 
 736 /*
 737  * This creates a snapshot under '.zfs/snapshot'.
 738  */
 739 /* ARGSUSED */
 740 static int
 741 zfsctl_snapdir_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t  **vpp,
 742     cred_t *cr, caller_context_t *cc, int flags, vsecattr_t *vsecp)
 743 {
 744         zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
 745         char name[ZFS_MAX_DATASET_NAME_LEN];
 746         int err;
 747         static enum symfollow follow = NO_FOLLOW;
 748         static enum uio_seg seg = UIO_SYSSPACE;
 749 
 750         if (zfs_component_namecheck(dirname, NULL, NULL) != 0)
 751                 return (SET_ERROR(EILSEQ));
 752 
 753         dmu_objset_name(zfsvfs->z_os, name);
 754 
 755         *vpp = NULL;
 756 
 757         err = zfs_secpolicy_snapshot_perms(name, cr);
 758         if (err != 0)
 759                 return (err);
 760 
 761         if (err == 0) {
 762                 err = dmu_objset_snapshot_one(name, dirname);
 763                 if (err != 0)
 764                         return (err);
 765                 err = lookupnameat(dirname, seg, follow, NULL, vpp, dvp);
 766         }
 767 
 768         return (err);
 769 }
 770 
 771 /*
 772  * Lookup entry point for the 'snapshot' directory.  Try to open the
 773  * snapshot if it exist, creating the pseudo filesystem vnode as necessary.
 774  * Perform a mount of the associated dataset on top of the vnode.
 775  */
 776 /* ARGSUSED */
 777 static int
 778 zfsctl_snapdir_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
 779     int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
 780     int *direntflags, pathname_t *realpnp)
 781 {
 782         zfsctl_snapdir_t *sdp = dvp->v_data;
 783         objset_t *snap;
 784         char snapname[ZFS_MAX_DATASET_NAME_LEN];
 785         char real[ZFS_MAX_DATASET_NAME_LEN];
 786         char *mountpoint;
 787         zfs_snapentry_t *sep, search;
 788         struct mounta margs;
 789         vfs_t *vfsp;
 790         size_t mountpoint_len;
 791         avl_index_t where;
 792         zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
 793         int err;
 794 
 795         /*
 796          * No extended attributes allowed under .zfs
 797          */
 798         if (flags & LOOKUP_XATTR)
 799                 return (SET_ERROR(EINVAL));
 800 
 801         ASSERT(dvp->v_type == VDIR);
 802 
 803         /*
 804          * If we get a recursive call, that means we got called
 805          * from the domount() code while it was trying to look up the
 806          * spec (which looks like a local path for zfs).  We need to
 807          * add some flag to domount() to tell it not to do this lookup.
 808          */
 809         if (MUTEX_HELD(&sdp->sd_lock))
 810                 return (SET_ERROR(ENOENT));
 811 
 812         ZFS_ENTER(zfsvfs);
 813 
 814         if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) {
 815                 ZFS_EXIT(zfsvfs);
 816                 return (0);
 817         }
 818 
 819         if (flags & FIGNORECASE) {
 820                 boolean_t conflict = B_FALSE;
 821 
 822                 err = dmu_snapshot_realname(zfsvfs->z_os, nm, real,
 823                     sizeof (real), &conflict);
 824                 if (err == 0) {
 825                         nm = real;
 826                 } else if (err != ENOTSUP) {
 827                         ZFS_EXIT(zfsvfs);
 828                         return (err);
 829                 }
 830                 if (realpnp)
 831                         (void) strlcpy(realpnp->pn_buf, nm,
 832                             realpnp->pn_bufsize);
 833                 if (conflict && direntflags)
 834                         *direntflags = ED_CASE_CONFLICT;
 835         }
 836 
 837         mutex_enter(&sdp->sd_lock);
 838         search.se_name = (char *)nm;
 839         if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) != NULL) {
 840                 *vpp = sep->se_root;
 841                 VN_HOLD(*vpp);
 842                 err = traverse(vpp);
 843                 if (err != 0) {
 844                         VN_RELE(*vpp);
 845                         *vpp = NULL;
 846                 } else if (*vpp == sep->se_root) {
 847                         /*
 848                          * The snapshot was unmounted behind our backs,
 849                          * try to remount it.
 850                          */
 851                         goto domount;
 852                 } else {
 853                         /*
 854                          * VROOT was set during the traverse call.  We need
 855                          * to clear it since we're pretending to be part
 856                          * of our parent's vfs.
 857                          */
 858                         (*vpp)->v_flag &= ~VROOT;
 859                 }
 860                 mutex_exit(&sdp->sd_lock);
 861                 ZFS_EXIT(zfsvfs);
 862                 return (err);
 863         }
 864 
 865         /*
 866          * The requested snapshot is not currently mounted, look it up.
 867          */
 868         err = zfsctl_snapshot_zname(dvp, nm, sizeof (snapname), snapname);
 869         if (err != 0) {
 870                 mutex_exit(&sdp->sd_lock);
 871                 ZFS_EXIT(zfsvfs);
 872                 /*
 873                  * handle "ls *" or "?" in a graceful manner,
 874                  * forcing EILSEQ to ENOENT.
 875                  * Since shell ultimately passes "*" or "?" as name to lookup
 876                  */
 877                 return (err == EILSEQ ? ENOENT : err);
 878         }
 879         if (dmu_objset_hold(snapname, FTAG, &snap) != 0) {
 880                 mutex_exit(&sdp->sd_lock);
 881                 ZFS_EXIT(zfsvfs);
 882                 return (SET_ERROR(ENOENT));
 883         }
 884 
 885         sep = kmem_alloc(sizeof (zfs_snapentry_t), KM_SLEEP);
 886         sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP);
 887         (void) strcpy(sep->se_name, nm);
 888         *vpp = sep->se_root = zfsctl_snapshot_mknode(dvp, dmu_objset_id(snap));
 889         avl_insert(&sdp->sd_snaps, sep, where);
 890 
 891         dmu_objset_rele(snap, FTAG);
 892 domount:
 893         mountpoint_len = strlen(refstr_value(dvp->v_vfsp->vfs_mntpt)) +
 894             strlen("/.zfs/snapshot/") + strlen(nm) + 1;
 895         mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP);
 896         (void) snprintf(mountpoint, mountpoint_len, "%s/.zfs/snapshot/%s",
 897             refstr_value(dvp->v_vfsp->vfs_mntpt), nm);
 898 
 899         margs.spec = snapname;
 900         margs.dir = mountpoint;
 901         margs.flags = MS_SYSSPACE | MS_NOMNTTAB;
 902         margs.fstype = "zfs";
 903         margs.dataptr = NULL;
 904         margs.datalen = 0;
 905         margs.optptr = NULL;
 906         margs.optlen = 0;
 907 
 908         err = domount("zfs", &margs, *vpp, kcred, &vfsp);
 909         kmem_free(mountpoint, mountpoint_len);
 910 
 911         if (err == 0) {
 912                 /*
 913                  * Return the mounted root rather than the covered mount point.
 914                  * Takes the GFS vnode at .zfs/snapshot/<snapname> and returns
 915                  * the ZFS vnode mounted on top of the GFS node.  This ZFS
 916                  * vnode is the root of the newly created vfsp.
 917                  */
 918                 VFS_RELE(vfsp);
 919                 err = traverse(vpp);
 920         }
 921 
 922         if (err == 0) {
 923                 /*
 924                  * Fix up the root vnode mounted on .zfs/snapshot/<snapname>.
 925                  *
 926                  * This is where we lie about our v_vfsp in order to
 927                  * make .zfs/snapshot/<snapname> accessible over NFS
 928                  * without requiring manual mounts of <snapname>.
 929                  */
 930                 ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs);
 931                 VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs;
 932                 (*vpp)->v_vfsp = zfsvfs->z_vfs;
 933                 (*vpp)->v_flag &= ~VROOT;
 934         }
 935         mutex_exit(&sdp->sd_lock);
 936         ZFS_EXIT(zfsvfs);
 937 
 938         /*
 939          * If we had an error, drop our hold on the vnode and
 940          * zfsctl_snapshot_inactive() will clean up.
 941          */
 942         if (err != 0) {
 943                 VN_RELE(*vpp);
 944                 *vpp = NULL;
 945         }
 946         return (err);
 947 }
 948 
 949 /* ARGSUSED */
 950 static int
 951 zfsctl_shares_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
 952     int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
 953     int *direntflags, pathname_t *realpnp)
 954 {
 955         zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
 956         znode_t *dzp;
 957         int error;
 958 
 959         ZFS_ENTER(zfsvfs);
 960 
 961         if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) {
 962                 ZFS_EXIT(zfsvfs);
 963                 return (0);
 964         }
 965 
 966         if (zfsvfs->z_shares_dir == 0) {
 967                 ZFS_EXIT(zfsvfs);
 968                 return (SET_ERROR(ENOTSUP));
 969         }
 970         if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {
 971                 error = VOP_LOOKUP(ZTOV(dzp), nm, vpp, pnp,
 972                     flags, rdir, cr, ct, direntflags, realpnp);
 973                 VN_RELE(ZTOV(dzp));
 974         }
 975 
 976         ZFS_EXIT(zfsvfs);
 977 
 978         return (error);
 979 }
 980 
 981 /* ARGSUSED */
 982 static int
 983 zfsctl_snapdir_readdir_cb(vnode_t *vp, void *dp, int *eofp,
 984     offset_t *offp, offset_t *nextp, void *data, int flags)
 985 {
 986         zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
 987         char snapname[ZFS_MAX_DATASET_NAME_LEN];
 988         uint64_t id, cookie;
 989         boolean_t case_conflict;
 990         int error;
 991 
 992         ZFS_ENTER(zfsvfs);
 993 
 994         cookie = *offp;
 995         dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG);
 996         error = dmu_snapshot_list_next(zfsvfs->z_os,
 997             sizeof (snapname), snapname, &id, &cookie, &case_conflict);
 998         dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG);
 999         if (error) {
1000                 ZFS_EXIT(zfsvfs);
1001                 if (error == ENOENT) {
1002                         *eofp = 1;
1003                         return (0);
1004                 }
1005                 return (error);
1006         }
1007 
1008         if (flags & V_RDDIR_ENTFLAGS) {
1009                 edirent_t *eodp = dp;
1010 
1011                 (void) strcpy(eodp->ed_name, snapname);
1012                 eodp->ed_ino = ZFSCTL_INO_SNAP(id);
1013                 eodp->ed_eflags = case_conflict ? ED_CASE_CONFLICT : 0;
1014         } else {
1015                 struct dirent64 *odp = dp;
1016 
1017                 (void) strcpy(odp->d_name, snapname);
1018                 odp->d_ino = ZFSCTL_INO_SNAP(id);
1019         }
1020         *nextp = cookie;
1021 
1022         ZFS_EXIT(zfsvfs);
1023 
1024         return (0);
1025 }
1026 
1027 /* ARGSUSED */
1028 static int
1029 zfsctl_shares_readdir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp,
1030     caller_context_t *ct, int flags)
1031 {
1032         zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
1033         znode_t *dzp;
1034         int error;
1035 
1036         ZFS_ENTER(zfsvfs);
1037 
1038         if (zfsvfs->z_shares_dir == 0) {
1039                 ZFS_EXIT(zfsvfs);
1040                 return (SET_ERROR(ENOTSUP));
1041         }
1042         if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {
1043                 error = VOP_READDIR(ZTOV(dzp), uiop, cr, eofp, ct, flags);
1044                 VN_RELE(ZTOV(dzp));
1045         } else {
1046                 *eofp = 1;
1047                 error = SET_ERROR(ENOENT);
1048         }
1049 
1050         ZFS_EXIT(zfsvfs);
1051         return (error);
1052 }
1053 
1054 /*
1055  * pvp is the '.zfs' directory (zfsctl_node_t).
1056  *
1057  * Creates vp, which is '.zfs/snapshot' (zfsctl_snapdir_t).
1058  *
1059  * This function is the callback to create a GFS vnode for '.zfs/snapshot'
1060  * when a lookup is performed on .zfs for "snapshot".
1061  */
1062 vnode_t *
1063 zfsctl_mknode_snapdir(vnode_t *pvp)
1064 {
1065         vnode_t *vp;
1066         zfsctl_snapdir_t *sdp;
1067 
1068         vp = gfs_dir_create(sizeof (zfsctl_snapdir_t), pvp,
1069             zfsctl_ops_snapdir, NULL, NULL, MAXNAMELEN,
1070             zfsctl_snapdir_readdir_cb, NULL);
1071         sdp = vp->v_data;
1072         sdp->sd_node.zc_id = ZFSCTL_INO_SNAPDIR;
1073         sdp->sd_node.zc_cmtime = ((zfsctl_node_t *)pvp->v_data)->zc_cmtime;
1074         mutex_init(&sdp->sd_lock, NULL, MUTEX_DEFAULT, NULL);
1075         avl_create(&sdp->sd_snaps, snapentry_compare,
1076             sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t, se_node));
1077         return (vp);
1078 }
1079 
1080 vnode_t *
1081 zfsctl_mknode_shares(vnode_t *pvp)
1082 {
1083         vnode_t *vp;
1084         zfsctl_node_t *sdp;
1085 
1086         vp = gfs_dir_create(sizeof (zfsctl_node_t), pvp,
1087             zfsctl_ops_shares, NULL, NULL, MAXNAMELEN,
1088             NULL, NULL);
1089         sdp = vp->v_data;
1090         sdp->zc_cmtime = ((zfsctl_node_t *)pvp->v_data)->zc_cmtime;
1091         return (vp);
1092 
1093 }
1094 
1095 /* ARGSUSED */
1096 static int
1097 zfsctl_shares_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
1098     caller_context_t *ct)
1099 {
1100         zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
1101         znode_t *dzp;
1102         int error;
1103 
1104         ZFS_ENTER(zfsvfs);
1105         if (zfsvfs->z_shares_dir == 0) {
1106                 ZFS_EXIT(zfsvfs);
1107                 return (SET_ERROR(ENOTSUP));
1108         }
1109         if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {
1110                 error = VOP_GETATTR(ZTOV(dzp), vap, flags, cr, ct);
1111                 VN_RELE(ZTOV(dzp));
1112         }
1113         ZFS_EXIT(zfsvfs);
1114         return (error);
1115 
1116 
1117 }
1118 
1119 /* ARGSUSED */
1120 static int
1121 zfsctl_snapdir_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
1122     caller_context_t *ct)
1123 {
1124         zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
1125         zfsctl_snapdir_t *sdp = vp->v_data;
1126 
1127         ZFS_ENTER(zfsvfs);
1128         zfsctl_common_getattr(vp, vap);
1129         vap->va_nodeid = gfs_file_inode(vp);
1130         vap->va_nlink = vap->va_size = avl_numnodes(&sdp->sd_snaps) + 2;
1131         vap->va_ctime = vap->va_mtime = dmu_objset_snap_cmtime(zfsvfs->z_os);
1132         ZFS_EXIT(zfsvfs);
1133 
1134         return (0);
1135 }
1136 
1137 /* ARGSUSED */
1138 static void
1139 zfsctl_snapdir_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
1140 {
1141         zfsctl_snapdir_t *sdp = vp->v_data;
1142         void *private;
1143 
1144         private = gfs_dir_inactive(vp);
1145         if (private != NULL) {
1146                 ASSERT(avl_numnodes(&sdp->sd_snaps) == 0);
1147                 mutex_destroy(&sdp->sd_lock);
1148                 avl_destroy(&sdp->sd_snaps);
1149                 kmem_free(private, sizeof (zfsctl_snapdir_t));
1150         }
1151 }
1152 
1153 static const fs_operation_def_t zfsctl_tops_snapdir[] = {
1154         { VOPNAME_OPEN,         { .vop_open = zfsctl_common_open }      },
1155         { VOPNAME_CLOSE,        { .vop_close = zfsctl_common_close }    },
1156         { VOPNAME_IOCTL,        { .error = fs_inval }                   },
1157         { VOPNAME_GETATTR,      { .vop_getattr = zfsctl_snapdir_getattr } },
1158         { VOPNAME_ACCESS,       { .vop_access = zfsctl_common_access }  },
1159         { VOPNAME_RENAME,       { .vop_rename = zfsctl_snapdir_rename } },
1160         { VOPNAME_RMDIR,        { .vop_rmdir = zfsctl_snapdir_remove }  },
1161         { VOPNAME_MKDIR,        { .vop_mkdir = zfsctl_snapdir_mkdir }   },
1162         { VOPNAME_READDIR,      { .vop_readdir = gfs_vop_readdir }      },
1163         { VOPNAME_LOOKUP,       { .vop_lookup = zfsctl_snapdir_lookup } },
1164         { VOPNAME_SEEK,         { .vop_seek = fs_seek }                 },
1165         { VOPNAME_INACTIVE,     { .vop_inactive = zfsctl_snapdir_inactive } },
1166         { VOPNAME_FID,          { .vop_fid = zfsctl_common_fid }        },
1167         { NULL }
1168 };
1169 
1170 static const fs_operation_def_t zfsctl_tops_shares[] = {
1171         { VOPNAME_OPEN,         { .vop_open = zfsctl_common_open }      },
1172         { VOPNAME_CLOSE,        { .vop_close = zfsctl_common_close }    },
1173         { VOPNAME_IOCTL,        { .error = fs_inval }                   },
1174         { VOPNAME_GETATTR,      { .vop_getattr = zfsctl_shares_getattr } },
1175         { VOPNAME_ACCESS,       { .vop_access = zfsctl_common_access }  },
1176         { VOPNAME_READDIR,      { .vop_readdir = zfsctl_shares_readdir } },
1177         { VOPNAME_LOOKUP,       { .vop_lookup = zfsctl_shares_lookup }  },
1178         { VOPNAME_SEEK,         { .vop_seek = fs_seek }                 },
1179         { VOPNAME_INACTIVE,     { .vop_inactive = gfs_vop_inactive } },
1180         { VOPNAME_FID,          { .vop_fid = zfsctl_shares_fid } },
1181         { NULL }
1182 };
1183 
1184 /*
1185  * pvp is the GFS vnode '.zfs/snapshot'.
1186  *
1187  * This creates a GFS node under '.zfs/snapshot' representing each
1188  * snapshot.  This newly created GFS node is what we mount snapshot
1189  * vfs_t's ontop of.
1190  */
1191 static vnode_t *
1192 zfsctl_snapshot_mknode(vnode_t *pvp, uint64_t objset)
1193 {
1194         vnode_t *vp;
1195         zfsctl_node_t *zcp;
1196 
1197         vp = gfs_dir_create(sizeof (zfsctl_node_t), pvp,
1198             zfsctl_ops_snapshot, NULL, NULL, MAXNAMELEN, NULL, NULL);
1199         zcp = vp->v_data;
1200         zcp->zc_id = objset;
1201 
1202         return (vp);
1203 }
1204 
1205 static void
1206 zfsctl_snapshot_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
1207 {
1208         zfsctl_snapdir_t *sdp;
1209         zfs_snapentry_t *sep, *next;
1210         vnode_t *dvp;
1211 
1212         VERIFY(gfs_dir_lookup(vp, "..", &dvp, cr, 0, NULL, NULL) == 0);
1213         sdp = dvp->v_data;
1214 
1215         mutex_enter(&sdp->sd_lock);
1216 
1217         mutex_enter(&vp->v_lock);
1218         if (vp->v_count > 1) {
1219                 vp->v_count--;
1220                 mutex_exit(&vp->v_lock);
1221                 mutex_exit(&sdp->sd_lock);
1222                 VN_RELE(dvp);
1223                 return;
1224         }
1225         mutex_exit(&vp->v_lock);
1226         ASSERT(!vn_ismntpt(vp));
1227 
1228         sep = avl_first(&sdp->sd_snaps);
1229         while (sep != NULL) {
1230                 next = AVL_NEXT(&sdp->sd_snaps, sep);
1231 
1232                 if (sep->se_root == vp) {
1233                         avl_remove(&sdp->sd_snaps, sep);
1234                         kmem_free(sep->se_name, strlen(sep->se_name) + 1);
1235                         kmem_free(sep, sizeof (zfs_snapentry_t));
1236                         break;
1237                 }
1238                 sep = next;
1239         }
1240         ASSERT(sep != NULL);
1241 
1242         mutex_exit(&sdp->sd_lock);
1243         VN_RELE(dvp);
1244 
1245         /*
1246          * Dispose of the vnode for the snapshot mount point.
1247          * This is safe to do because once this entry has been removed
1248          * from the AVL tree, it can't be found again, so cannot become
1249          * "active".  If we lookup the same name again we will end up
1250          * creating a new vnode.
1251          */
1252         gfs_vop_inactive(vp, cr, ct);
1253 }
1254 
1255 
1256 /*
1257  * These VP's should never see the light of day.  They should always
1258  * be covered.
1259  */
1260 static const fs_operation_def_t zfsctl_tops_snapshot[] = {
1261         VOPNAME_INACTIVE, { .vop_inactive =  zfsctl_snapshot_inactive },
1262         NULL, NULL
1263 };
1264 
1265 int
1266 zfsctl_lookup_objset(vfs_t *vfsp, uint64_t objsetid, zfsvfs_t **zfsvfsp)
1267 {
1268         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1269         vnode_t *dvp, *vp;
1270         zfsctl_snapdir_t *sdp;
1271         zfsctl_node_t *zcp;
1272         zfs_snapentry_t *sep;
1273         int error;
1274 
1275         ASSERT(zfsvfs->z_ctldir != NULL);
1276         error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp,
1277             NULL, 0, NULL, kcred, NULL, NULL, NULL);
1278         if (error != 0)
1279                 return (error);
1280         sdp = dvp->v_data;
1281 
1282         mutex_enter(&sdp->sd_lock);
1283         sep = avl_first(&sdp->sd_snaps);
1284         while (sep != NULL) {
1285                 vp = sep->se_root;
1286                 zcp = vp->v_data;
1287                 if (zcp->zc_id == objsetid)
1288                         break;
1289 
1290                 sep = AVL_NEXT(&sdp->sd_snaps, sep);
1291         }
1292 
1293         if (sep != NULL) {
1294                 VN_HOLD(vp);
1295                 /*
1296                  * Return the mounted root rather than the covered mount point.
1297                  * Takes the GFS vnode at .zfs/snapshot/<snapshot objsetid>
1298                  * and returns the ZFS vnode mounted on top of the GFS node.
1299                  * This ZFS vnode is the root of the vfs for objset 'objsetid'.
1300                  */
1301                 error = traverse(&vp);
1302                 if (error == 0) {
1303                         if (vp == sep->se_root)
1304                                 error = SET_ERROR(EINVAL);
1305                         else
1306                                 *zfsvfsp = VTOZ(vp)->z_zfsvfs;
1307                 }
1308                 mutex_exit(&sdp->sd_lock);
1309                 VN_RELE(vp);
1310         } else {
1311                 error = SET_ERROR(EINVAL);
1312                 mutex_exit(&sdp->sd_lock);
1313         }
1314 
1315         VN_RELE(dvp);
1316 
1317         return (error);
1318 }
1319 
1320 /*
1321  * Unmount any snapshots for the given filesystem.  This is called from
1322  * zfs_umount() - if we have a ctldir, then go through and unmount all the
1323  * snapshots.
1324  */
1325 int
1326 zfsctl_umount_snapshots(vfs_t *vfsp, int fflags, cred_t *cr)
1327 {
1328         zfsvfs_t *zfsvfs = vfsp->vfs_data;
1329         vnode_t *dvp;
1330         zfsctl_snapdir_t *sdp;
1331         zfs_snapentry_t *sep, *next;
1332         int error;
1333 
1334         ASSERT(zfsvfs->z_ctldir != NULL);
1335         error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp,
1336             NULL, 0, NULL, cr, NULL, NULL, NULL);
1337         if (error != 0)
1338                 return (error);
1339         sdp = dvp->v_data;
1340 
1341         mutex_enter(&sdp->sd_lock);
1342 
1343         sep = avl_first(&sdp->sd_snaps);
1344         while (sep != NULL) {
1345                 next = AVL_NEXT(&sdp->sd_snaps, sep);
1346 
1347                 /*
1348                  * If this snapshot is not mounted, then it must
1349                  * have just been unmounted by somebody else, and
1350                  * will be cleaned up by zfsctl_snapdir_inactive().
1351                  */
1352                 if (vn_ismntpt(sep->se_root)) {
1353                         avl_remove(&sdp->sd_snaps, sep);
1354                         error = zfsctl_unmount_snap(sep, fflags, cr);
1355                         if (error) {
1356                                 avl_add(&sdp->sd_snaps, sep);
1357                                 break;
1358                         }
1359                 }
1360                 sep = next;
1361         }
1362 
1363         mutex_exit(&sdp->sd_lock);
1364         VN_RELE(dvp);
1365 
1366         return (error);
1367 }