1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 50f2dc02eSek * Common Development and Distribution License (the "License"). 60f2dc02eSek * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 22d39ee142SMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 239adfa60dSMatthew Ahrens * Copyright (c) 2012, 2015 by Delphix. All rights reserved. 240f92170fSDan McDonald * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens /* 28fa9e4066Sahrens * ZFS control directory (a.k.a. ".zfs") 29fa9e4066Sahrens * 30fa9e4066Sahrens * This directory provides a common location for all ZFS meta-objects. 31fa9e4066Sahrens * Currently, this is only the 'snapshot' directory, but this may expand in the 32fa9e4066Sahrens * future. The elements are built using the GFS primitives, as the hierarchy 33fa9e4066Sahrens * does not actually exist on disk. 34fa9e4066Sahrens * 35fa9e4066Sahrens * For 'snapshot', we don't want to have all snapshots always mounted, because 36fa9e4066Sahrens * this would take up a huge amount of space in /etc/mnttab. We have three 37fa9e4066Sahrens * types of objects: 38fa9e4066Sahrens * 39fa9e4066Sahrens * ctldir ------> snapshotdir -------> snapshot 40fa9e4066Sahrens * | 41fa9e4066Sahrens * | 42fa9e4066Sahrens * V 43fa9e4066Sahrens * mounted fs 44fa9e4066Sahrens * 45fa9e4066Sahrens * The 'snapshot' node contains just enough information to lookup '..' and act 46fa9e4066Sahrens * as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we 47fa9e4066Sahrens * perform an automount of the underlying filesystem and return the 48fa9e4066Sahrens * corresponding vnode. 49fa9e4066Sahrens * 50fa9e4066Sahrens * All mounts are handled automatically by the kernel, but unmounts are 51fa9e4066Sahrens * (currently) handled from user land. The main reason is that there is no 52fa9e4066Sahrens * reliable way to auto-unmount the filesystem when it's "no longer in use". 53fa9e4066Sahrens * When the user unmounts a filesystem, we call zfsctl_unmount(), which 54fa9e4066Sahrens * unmounts any snapshots within the snapshot directory. 55f18faf3fSek * 56f18faf3fSek * The '.zfs', '.zfs/snapshot', and all directories created under 57f18faf3fSek * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') are all GFS nodes and 58f18faf3fSek * share the same vfs_t as the head filesystem (what '.zfs' lives under). 59f18faf3fSek * 60f18faf3fSek * File systems mounted ontop of the GFS nodes '.zfs/snapshot/<snapname>' 61f18faf3fSek * (ie: snapshots) are ZFS nodes and have their own unique vfs_t. 62f18faf3fSek * However, vnodes within these mounted on file systems have their v_vfsp 63f18faf3fSek * fields set to the head filesystem to make NFS happy (see 648bf40bf0Sck * zfsctl_snapdir_lookup()). We VFS_HOLD the head filesystem's vfs_t 658bf40bf0Sck * so that it cannot be freed until all snapshots have been unmounted. 66fa9e4066Sahrens */ 67fa9e4066Sahrens 68fa9e4066Sahrens #include <fs/fs_subr.h> 69fa9e4066Sahrens #include <sys/zfs_ctldir.h> 70fa9e4066Sahrens #include <sys/zfs_ioctl.h> 71fa9e4066Sahrens #include <sys/zfs_vfsops.h> 72aa59c4cbSrsb #include <sys/vfs_opreg.h> 73fa9e4066Sahrens #include <sys/gfs.h> 74fa9e4066Sahrens #include <sys/stat.h> 75fa9e4066Sahrens #include <sys/dmu.h> 763b2aab18SMatthew Ahrens #include <sys/dsl_destroy.h> 77ecd6cf80Smarks #include <sys/dsl_deleg.h> 78fa9e4066Sahrens #include <sys/mount.h> 79ab04eb8eStimh #include <sys/sunddi.h> 80fa9e4066Sahrens 816d1e0b89Smarks #include "zfs_namecheck.h" 826d1e0b89Smarks 838bf40bf0Sck typedef struct zfsctl_node { 848bf40bf0Sck gfs_dir_t zc_gfs_private; 858bf40bf0Sck uint64_t zc_id; 868bf40bf0Sck timestruc_t zc_cmtime; /* ctime and mtime, always the same */ 878bf40bf0Sck } zfsctl_node_t; 888bf40bf0Sck 898bf40bf0Sck typedef struct zfsctl_snapdir { 908bf40bf0Sck zfsctl_node_t sd_node; 918bf40bf0Sck kmutex_t sd_lock; 928bf40bf0Sck avl_tree_t sd_snaps; 938bf40bf0Sck } zfsctl_snapdir_t; 948bf40bf0Sck 95fa9e4066Sahrens typedef struct { 96fa9e4066Sahrens char *se_name; 97fa9e4066Sahrens vnode_t *se_root; 98fa9e4066Sahrens avl_node_t se_node; 99fa9e4066Sahrens } zfs_snapentry_t; 100fa9e4066Sahrens 101fa9e4066Sahrens static int 102fa9e4066Sahrens snapentry_compare(const void *a, const void *b) 103fa9e4066Sahrens { 104fa9e4066Sahrens const zfs_snapentry_t *sa = a; 105fa9e4066Sahrens const zfs_snapentry_t *sb = b; 106fa9e4066Sahrens int ret = strcmp(sa->se_name, sb->se_name); 107fa9e4066Sahrens 108fa9e4066Sahrens if (ret < 0) 109fa9e4066Sahrens return (-1); 110fa9e4066Sahrens else if (ret > 0) 111fa9e4066Sahrens return (1); 112fa9e4066Sahrens else 113fa9e4066Sahrens return (0); 114fa9e4066Sahrens } 115fa9e4066Sahrens 116fa9e4066Sahrens vnodeops_t *zfsctl_ops_root; 117fa9e4066Sahrens vnodeops_t *zfsctl_ops_snapdir; 118fa9e4066Sahrens vnodeops_t *zfsctl_ops_snapshot; 119743a77edSAlan Wright vnodeops_t *zfsctl_ops_shares; 120fa9e4066Sahrens 121fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_root[]; 122fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapdir[]; 123fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapshot[]; 124743a77edSAlan Wright static const fs_operation_def_t zfsctl_tops_shares[]; 125fa9e4066Sahrens 126fa9e4066Sahrens static vnode_t *zfsctl_mknode_snapdir(vnode_t *); 127743a77edSAlan Wright static vnode_t *zfsctl_mknode_shares(vnode_t *); 128fa9e4066Sahrens static vnode_t *zfsctl_snapshot_mknode(vnode_t *, uint64_t objset); 1298bf40bf0Sck static int zfsctl_unmount_snap(zfs_snapentry_t *, int, cred_t *); 130fa9e4066Sahrens 131fa9e4066Sahrens static gfs_opsvec_t zfsctl_opsvec[] = { 132fa9e4066Sahrens { ".zfs", zfsctl_tops_root, &zfsctl_ops_root }, 133fa9e4066Sahrens { ".zfs/snapshot", zfsctl_tops_snapdir, &zfsctl_ops_snapdir }, 134fa9e4066Sahrens { ".zfs/snapshot/vnode", zfsctl_tops_snapshot, &zfsctl_ops_snapshot }, 135*b7f9f60cSAndriy Gapon { ".zfs/shares", zfsctl_tops_shares, &zfsctl_ops_shares }, 136fa9e4066Sahrens { NULL } 137fa9e4066Sahrens }; 138fa9e4066Sahrens 139fa9e4066Sahrens /* 140743a77edSAlan Wright * Root directory elements. We only have two entries 141743a77edSAlan Wright * snapshot and shares. 142fa9e4066Sahrens */ 143fa9e4066Sahrens static gfs_dirent_t zfsctl_root_entries[] = { 144fa9e4066Sahrens { "snapshot", zfsctl_mknode_snapdir, GFS_CACHE_VNODE }, 145743a77edSAlan Wright { "shares", zfsctl_mknode_shares, GFS_CACHE_VNODE }, 146fa9e4066Sahrens { NULL } 147fa9e4066Sahrens }; 148fa9e4066Sahrens 149fa9e4066Sahrens /* include . and .. in the calculation */ 150fa9e4066Sahrens #define NROOT_ENTRIES ((sizeof (zfsctl_root_entries) / \ 151fa9e4066Sahrens sizeof (gfs_dirent_t)) + 1) 152fa9e4066Sahrens 153fa9e4066Sahrens 154fa9e4066Sahrens /* 155fa9e4066Sahrens * Initialize the various GFS pieces we'll need to create and manipulate .zfs 156fa9e4066Sahrens * directories. This is called from the ZFS init routine, and initializes the 157fa9e4066Sahrens * vnode ops vectors that we'll be using. 158fa9e4066Sahrens */ 159fa9e4066Sahrens void 160fa9e4066Sahrens zfsctl_init(void) 161fa9e4066Sahrens { 162fa9e4066Sahrens VERIFY(gfs_make_opsvec(zfsctl_opsvec) == 0); 163fa9e4066Sahrens } 164fa9e4066Sahrens 165fa9e4066Sahrens void 166fa9e4066Sahrens zfsctl_fini(void) 167fa9e4066Sahrens { 168fa9e4066Sahrens /* 169fa9e4066Sahrens * Remove vfsctl vnode ops 170fa9e4066Sahrens */ 171fa9e4066Sahrens if (zfsctl_ops_root) 172fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_root); 173fa9e4066Sahrens if (zfsctl_ops_snapdir) 174fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_snapdir); 175fa9e4066Sahrens if (zfsctl_ops_snapshot) 176fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_snapshot); 177743a77edSAlan Wright if (zfsctl_ops_shares) 178743a77edSAlan Wright vn_freevnodeops(zfsctl_ops_shares); 179fa9e4066Sahrens 180fa9e4066Sahrens zfsctl_ops_root = NULL; 181fa9e4066Sahrens zfsctl_ops_snapdir = NULL; 182fa9e4066Sahrens zfsctl_ops_snapshot = NULL; 183743a77edSAlan Wright zfsctl_ops_shares = NULL; 184fa9e4066Sahrens } 185fa9e4066Sahrens 186d39ee142SMark Shellenbaum boolean_t 187d39ee142SMark Shellenbaum zfsctl_is_node(vnode_t *vp) 188d39ee142SMark Shellenbaum { 189d39ee142SMark Shellenbaum return (vn_matchops(vp, zfsctl_ops_root) || 190d39ee142SMark Shellenbaum vn_matchops(vp, zfsctl_ops_snapdir) || 191d39ee142SMark Shellenbaum vn_matchops(vp, zfsctl_ops_snapshot) || 192*b7f9f60cSAndriy Gapon vn_matchops(vp, zfsctl_ops_shares)); 193d39ee142SMark Shellenbaum 194d39ee142SMark Shellenbaum } 195d39ee142SMark Shellenbaum 196fa9e4066Sahrens /* 197743a77edSAlan Wright * Return the inode number associated with the 'snapshot' or 198743a77edSAlan Wright * 'shares' directory. 199fa9e4066Sahrens */ 200fa9e4066Sahrens /* ARGSUSED */ 201fa9e4066Sahrens static ino64_t 202fa9e4066Sahrens zfsctl_root_inode_cb(vnode_t *vp, int index) 203fa9e4066Sahrens { 204743a77edSAlan Wright zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 205743a77edSAlan Wright 206*b7f9f60cSAndriy Gapon ASSERT(index < 2); 207743a77edSAlan Wright 208743a77edSAlan Wright if (index == 0) 209743a77edSAlan Wright return (ZFSCTL_INO_SNAPDIR); 210743a77edSAlan Wright 211743a77edSAlan Wright return (zfsvfs->z_shares_dir); 212fa9e4066Sahrens } 213fa9e4066Sahrens 214fa9e4066Sahrens /* 215fa9e4066Sahrens * Create the '.zfs' directory. This directory is cached as part of the VFS 216fa9e4066Sahrens * structure. This results in a hold on the vfs_t. The code in zfs_umount() 217fa9e4066Sahrens * therefore checks against a vfs_count of 2 instead of 1. This reference 218fa9e4066Sahrens * is removed when the ctldir is destroyed in the unmount. 219fa9e4066Sahrens */ 220fa9e4066Sahrens void 221fa9e4066Sahrens zfsctl_create(zfsvfs_t *zfsvfs) 222fa9e4066Sahrens { 223a32fded1Sek vnode_t *vp, *rvp; 224fa9e4066Sahrens zfsctl_node_t *zcp; 2250a586ceaSMark Shellenbaum uint64_t crtime[2]; 226fa9e4066Sahrens 227fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir == NULL); 228fa9e4066Sahrens 229fa9e4066Sahrens vp = gfs_root_create(sizeof (zfsctl_node_t), zfsvfs->z_vfs, 230fa9e4066Sahrens zfsctl_ops_root, ZFSCTL_INO_ROOT, zfsctl_root_entries, 231fa9e4066Sahrens zfsctl_root_inode_cb, MAXNAMELEN, NULL, NULL); 232fa9e4066Sahrens zcp = vp->v_data; 233fa9e4066Sahrens zcp->zc_id = ZFSCTL_INO_ROOT; 234fa9e4066Sahrens 235a32fded1Sek VERIFY(VFS_ROOT(zfsvfs->z_vfs, &rvp) == 0); 2360a586ceaSMark Shellenbaum VERIFY(0 == sa_lookup(VTOZ(rvp)->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs), 2370a586ceaSMark Shellenbaum &crtime, sizeof (crtime))); 2380a586ceaSMark Shellenbaum ZFS_TIME_DECODE(&zcp->zc_cmtime, crtime); 239a32fded1Sek VN_RELE(rvp); 240a32fded1Sek 241fa9e4066Sahrens /* 242fa9e4066Sahrens * We're only faking the fact that we have a root of a filesystem for 243fa9e4066Sahrens * the sake of the GFS interfaces. Undo the flag manipulation it did 244fa9e4066Sahrens * for us. 245fa9e4066Sahrens */ 246fa9e4066Sahrens vp->v_flag &= ~(VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT); 247fa9e4066Sahrens 248fa9e4066Sahrens zfsvfs->z_ctldir = vp; 249fa9e4066Sahrens } 250fa9e4066Sahrens 251fa9e4066Sahrens /* 2528afd4dd6Sperrin * Destroy the '.zfs' directory. Only called when the filesystem is unmounted. 2538afd4dd6Sperrin * There might still be more references if we were force unmounted, but only 2548afd4dd6Sperrin * new zfs_inactive() calls can occur and they don't reference .zfs 255fa9e4066Sahrens */ 256fa9e4066Sahrens void 257fa9e4066Sahrens zfsctl_destroy(zfsvfs_t *zfsvfs) 258fa9e4066Sahrens { 259fa9e4066Sahrens VN_RELE(zfsvfs->z_ctldir); 260fa9e4066Sahrens zfsvfs->z_ctldir = NULL; 261fa9e4066Sahrens } 262fa9e4066Sahrens 263fa9e4066Sahrens /* 264fa9e4066Sahrens * Given a root znode, retrieve the associated .zfs directory. 265fa9e4066Sahrens * Add a hold to the vnode and return it. 266fa9e4066Sahrens */ 267fa9e4066Sahrens vnode_t * 268fa9e4066Sahrens zfsctl_root(znode_t *zp) 269fa9e4066Sahrens { 270fa9e4066Sahrens ASSERT(zfs_has_ctldir(zp)); 271fa9e4066Sahrens VN_HOLD(zp->z_zfsvfs->z_ctldir); 272fa9e4066Sahrens return (zp->z_zfsvfs->z_ctldir); 273fa9e4066Sahrens } 274fa9e4066Sahrens 275fa9e4066Sahrens /* 276fa9e4066Sahrens * Common open routine. Disallow any write access. 277fa9e4066Sahrens */ 278fa9e4066Sahrens /* ARGSUSED */ 279fa9e4066Sahrens static int 280da6c28aaSamw zfsctl_common_open(vnode_t **vpp, int flags, cred_t *cr, caller_context_t *ct) 281fa9e4066Sahrens { 282fa9e4066Sahrens if (flags & FWRITE) 283be6fd75aSMatthew Ahrens return (SET_ERROR(EACCES)); 284fa9e4066Sahrens 285fa9e4066Sahrens return (0); 286fa9e4066Sahrens } 287fa9e4066Sahrens 288fa9e4066Sahrens /* 289fa9e4066Sahrens * Common close routine. Nothing to do here. 290fa9e4066Sahrens */ 291fa9e4066Sahrens /* ARGSUSED */ 292fa9e4066Sahrens static int 293fa9e4066Sahrens zfsctl_common_close(vnode_t *vpp, int flags, int count, offset_t off, 294da6c28aaSamw cred_t *cr, caller_context_t *ct) 295fa9e4066Sahrens { 296fa9e4066Sahrens return (0); 297fa9e4066Sahrens } 298fa9e4066Sahrens 299fa9e4066Sahrens /* 300fa9e4066Sahrens * Common access routine. Disallow writes. 301fa9e4066Sahrens */ 302fa9e4066Sahrens /* ARGSUSED */ 303fa9e4066Sahrens static int 304da6c28aaSamw zfsctl_common_access(vnode_t *vp, int mode, int flags, cred_t *cr, 305da6c28aaSamw caller_context_t *ct) 306fa9e4066Sahrens { 30760030f27SMark Shellenbaum if (flags & V_ACE_MASK) { 30860030f27SMark Shellenbaum if (mode & ACE_ALL_WRITE_PERMS) 309be6fd75aSMatthew Ahrens return (SET_ERROR(EACCES)); 31060030f27SMark Shellenbaum } else { 31160030f27SMark Shellenbaum if (mode & VWRITE) 312be6fd75aSMatthew Ahrens return (SET_ERROR(EACCES)); 31360030f27SMark Shellenbaum } 314fa9e4066Sahrens 315fa9e4066Sahrens return (0); 316fa9e4066Sahrens } 317fa9e4066Sahrens 318fa9e4066Sahrens /* 319fa9e4066Sahrens * Common getattr function. Fill in basic information. 320fa9e4066Sahrens */ 321fa9e4066Sahrens static void 322fa9e4066Sahrens zfsctl_common_getattr(vnode_t *vp, vattr_t *vap) 323fa9e4066Sahrens { 324a32fded1Sek timestruc_t now; 325fa9e4066Sahrens 326fa9e4066Sahrens vap->va_uid = 0; 327fa9e4066Sahrens vap->va_gid = 0; 328fa9e4066Sahrens vap->va_rdev = 0; 329fa9e4066Sahrens /* 33071eb0538SChris Kirby * We are a purely virtual object, so we have no 331fa9e4066Sahrens * blocksize or allocated blocks. 332fa9e4066Sahrens */ 333fa9e4066Sahrens vap->va_blksize = 0; 334fa9e4066Sahrens vap->va_nblocks = 0; 335fa9e4066Sahrens vap->va_seq = 0; 336fa9e4066Sahrens vap->va_fsid = vp->v_vfsp->vfs_dev; 337fa9e4066Sahrens vap->va_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | 338fa9e4066Sahrens S_IROTH | S_IXOTH; 339fa9e4066Sahrens vap->va_type = VDIR; 340fa9e4066Sahrens /* 341a32fded1Sek * We live in the now (for atime). 342fa9e4066Sahrens */ 343fa9e4066Sahrens gethrestime(&now); 344a32fded1Sek vap->va_atime = now; 345fa9e4066Sahrens } 346fa9e4066Sahrens 347da6c28aaSamw /*ARGSUSED*/ 348fa9e4066Sahrens static int 349da6c28aaSamw zfsctl_common_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct) 350fa9e4066Sahrens { 351fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 352fa9e4066Sahrens zfsctl_node_t *zcp = vp->v_data; 353fa9e4066Sahrens uint64_t object = zcp->zc_id; 354fa9e4066Sahrens zfid_short_t *zfid; 355fa9e4066Sahrens int i; 356fa9e4066Sahrens 357fa9e4066Sahrens ZFS_ENTER(zfsvfs); 358fa9e4066Sahrens 359fa9e4066Sahrens if (fidp->fid_len < SHORT_FID_LEN) { 360fa9e4066Sahrens fidp->fid_len = SHORT_FID_LEN; 3610f2dc02eSek ZFS_EXIT(zfsvfs); 362be6fd75aSMatthew Ahrens return (SET_ERROR(ENOSPC)); 363fa9e4066Sahrens } 364fa9e4066Sahrens 365fa9e4066Sahrens zfid = (zfid_short_t *)fidp; 366fa9e4066Sahrens 367fa9e4066Sahrens zfid->zf_len = SHORT_FID_LEN; 368fa9e4066Sahrens 369fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_object); i++) 370fa9e4066Sahrens zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 371fa9e4066Sahrens 372fa9e4066Sahrens /* .zfs znodes always have a generation number of 0 */ 373fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_gen); i++) 374fa9e4066Sahrens zfid->zf_gen[i] = 0; 375fa9e4066Sahrens 376fa9e4066Sahrens ZFS_EXIT(zfsvfs); 377fa9e4066Sahrens return (0); 378fa9e4066Sahrens } 379fa9e4066Sahrens 380743a77edSAlan Wright 381743a77edSAlan Wright /*ARGSUSED*/ 382743a77edSAlan Wright static int 383743a77edSAlan Wright zfsctl_shares_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct) 384743a77edSAlan Wright { 385743a77edSAlan Wright zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 386743a77edSAlan Wright znode_t *dzp; 387743a77edSAlan Wright int error; 388743a77edSAlan Wright 389743a77edSAlan Wright ZFS_ENTER(zfsvfs); 3909e1320c0SMark Shellenbaum 3919e1320c0SMark Shellenbaum if (zfsvfs->z_shares_dir == 0) { 3929e1320c0SMark Shellenbaum ZFS_EXIT(zfsvfs); 393be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTSUP)); 3949e1320c0SMark Shellenbaum } 3959e1320c0SMark Shellenbaum 396743a77edSAlan Wright if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) { 397743a77edSAlan Wright error = VOP_FID(ZTOV(dzp), fidp, ct); 398743a77edSAlan Wright VN_RELE(ZTOV(dzp)); 399743a77edSAlan Wright } 400743a77edSAlan Wright 401743a77edSAlan Wright ZFS_EXIT(zfsvfs); 402743a77edSAlan Wright return (error); 403743a77edSAlan Wright } 404fa9e4066Sahrens /* 405fa9e4066Sahrens * .zfs inode namespace 406fa9e4066Sahrens * 407fa9e4066Sahrens * We need to generate unique inode numbers for all files and directories 408fa9e4066Sahrens * within the .zfs pseudo-filesystem. We use the following scheme: 409fa9e4066Sahrens * 410fa9e4066Sahrens * ENTRY ZFSCTL_INODE 411fa9e4066Sahrens * .zfs 1 412fa9e4066Sahrens * .zfs/snapshot 2 413fa9e4066Sahrens * .zfs/snapshot/<snap> objectid(snap) 414fa9e4066Sahrens */ 415fa9e4066Sahrens 416fa9e4066Sahrens #define ZFSCTL_INO_SNAP(id) (id) 417fa9e4066Sahrens 418fa9e4066Sahrens /* 419fa9e4066Sahrens * Get root directory attributes. 420fa9e4066Sahrens */ 421fa9e4066Sahrens /* ARGSUSED */ 422fa9e4066Sahrens static int 423da6c28aaSamw zfsctl_root_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 424da6c28aaSamw caller_context_t *ct) 425fa9e4066Sahrens { 426fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 42771eb0538SChris Kirby zfsctl_node_t *zcp = vp->v_data; 428fa9e4066Sahrens 429fa9e4066Sahrens ZFS_ENTER(zfsvfs); 430fa9e4066Sahrens vap->va_nodeid = ZFSCTL_INO_ROOT; 431fa9e4066Sahrens vap->va_nlink = vap->va_size = NROOT_ENTRIES; 43271eb0538SChris Kirby vap->va_mtime = vap->va_ctime = zcp->zc_cmtime; 433fa9e4066Sahrens 434fa9e4066Sahrens zfsctl_common_getattr(vp, vap); 435fa9e4066Sahrens ZFS_EXIT(zfsvfs); 436fa9e4066Sahrens 437fa9e4066Sahrens return (0); 438fa9e4066Sahrens } 439fa9e4066Sahrens 440fa9e4066Sahrens /* 441fa9e4066Sahrens * Special case the handling of "..". 442fa9e4066Sahrens */ 443fa9e4066Sahrens /* ARGSUSED */ 444fa9e4066Sahrens int 445fa9e4066Sahrens zfsctl_root_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 446da6c28aaSamw int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, 447da6c28aaSamw int *direntflags, pathname_t *realpnp) 448fa9e4066Sahrens { 449fa9e4066Sahrens zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 450fa9e4066Sahrens int err; 451fa9e4066Sahrens 452da6c28aaSamw /* 453da6c28aaSamw * No extended attributes allowed under .zfs 454da6c28aaSamw */ 455da6c28aaSamw if (flags & LOOKUP_XATTR) 456be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 457da6c28aaSamw 458fa9e4066Sahrens ZFS_ENTER(zfsvfs); 459fa9e4066Sahrens 460fa9e4066Sahrens if (strcmp(nm, "..") == 0) { 461fa9e4066Sahrens err = VFS_ROOT(dvp->v_vfsp, vpp); 462fa9e4066Sahrens } else { 463ab04eb8eStimh err = gfs_vop_lookup(dvp, nm, vpp, pnp, flags, rdir, 464ab04eb8eStimh cr, ct, direntflags, realpnp); 465fa9e4066Sahrens } 466fa9e4066Sahrens 467fa9e4066Sahrens ZFS_EXIT(zfsvfs); 468fa9e4066Sahrens 469fa9e4066Sahrens return (err); 470fa9e4066Sahrens } 471fa9e4066Sahrens 47260030f27SMark Shellenbaum static int 47360030f27SMark Shellenbaum zfsctl_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr, 47460030f27SMark Shellenbaum caller_context_t *ct) 47560030f27SMark Shellenbaum { 47660030f27SMark Shellenbaum /* 47760030f27SMark Shellenbaum * We only care about ACL_ENABLED so that libsec can 47860030f27SMark Shellenbaum * display ACL correctly and not default to POSIX draft. 47960030f27SMark Shellenbaum */ 48060030f27SMark Shellenbaum if (cmd == _PC_ACL_ENABLED) { 48160030f27SMark Shellenbaum *valp = _ACL_ACE_ENABLED; 48260030f27SMark Shellenbaum return (0); 48360030f27SMark Shellenbaum } 48460030f27SMark Shellenbaum 48560030f27SMark Shellenbaum return (fs_pathconf(vp, cmd, valp, cr, ct)); 48660030f27SMark Shellenbaum } 48760030f27SMark Shellenbaum 488fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_root[] = { 489aa59c4cbSrsb { VOPNAME_OPEN, { .vop_open = zfsctl_common_open } }, 490aa59c4cbSrsb { VOPNAME_CLOSE, { .vop_close = zfsctl_common_close } }, 491aa59c4cbSrsb { VOPNAME_IOCTL, { .error = fs_inval } }, 492aa59c4cbSrsb { VOPNAME_GETATTR, { .vop_getattr = zfsctl_root_getattr } }, 493aa59c4cbSrsb { VOPNAME_ACCESS, { .vop_access = zfsctl_common_access } }, 494aa59c4cbSrsb { VOPNAME_READDIR, { .vop_readdir = gfs_vop_readdir } }, 495aa59c4cbSrsb { VOPNAME_LOOKUP, { .vop_lookup = zfsctl_root_lookup } }, 496aa59c4cbSrsb { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 497aa59c4cbSrsb { VOPNAME_INACTIVE, { .vop_inactive = gfs_vop_inactive } }, 49860030f27SMark Shellenbaum { VOPNAME_PATHCONF, { .vop_pathconf = zfsctl_pathconf } }, 499aa59c4cbSrsb { VOPNAME_FID, { .vop_fid = zfsctl_common_fid } }, 500fa9e4066Sahrens { NULL } 501fa9e4066Sahrens }; 502fa9e4066Sahrens 5033e30c24aSWill Andrews /* 5043e30c24aSWill Andrews * Gets the full dataset name that corresponds to the given snapshot name 5053e30c24aSWill Andrews * Example: 5063e30c24aSWill Andrews * zfsctl_snapshot_zname("snap1") -> "mypool/myfs@snap1" 5073e30c24aSWill Andrews */ 508fa9e4066Sahrens static int 509fa9e4066Sahrens zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname) 510fa9e4066Sahrens { 511fa9e4066Sahrens objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 512fa9e4066Sahrens 51378f17100SMatthew Ahrens if (zfs_component_namecheck(name, NULL, NULL) != 0) 514be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ)); 515fa9e4066Sahrens dmu_objset_name(os, zname); 5165422900bSmaybee if (strlen(zname) + 1 + strlen(name) >= len) 517be6fd75aSMatthew Ahrens return (SET_ERROR(ENAMETOOLONG)); 5185422900bSmaybee (void) strcat(zname, "@"); 519fa9e4066Sahrens (void) strcat(zname, name); 520fa9e4066Sahrens return (0); 521fa9e4066Sahrens } 522fa9e4066Sahrens 5238bf40bf0Sck static int 5248bf40bf0Sck zfsctl_unmount_snap(zfs_snapentry_t *sep, int fflags, cred_t *cr) 525fa9e4066Sahrens { 5268bf40bf0Sck vnode_t *svp = sep->se_root; 5278bf40bf0Sck int error; 528fa9e4066Sahrens 5298bf40bf0Sck ASSERT(vn_ismntpt(svp)); 530fa9e4066Sahrens 531fa9e4066Sahrens /* this will be dropped by dounmount() */ 5328bf40bf0Sck if ((error = vn_vfswlock(svp)) != 0) 5338bf40bf0Sck return (error); 534fa9e4066Sahrens 5358bf40bf0Sck VN_HOLD(svp); 5368bf40bf0Sck error = dounmount(vn_mountedvfs(svp), fflags, cr); 5378bf40bf0Sck if (error) { 5388bf40bf0Sck VN_RELE(svp); 5398bf40bf0Sck return (error); 540bbf4a8dfSmaybee } 541142ae85dSChris Kirby 5428bf40bf0Sck /* 5438bf40bf0Sck * We can't use VN_RELE(), as that will try to invoke 5448bf40bf0Sck * zfsctl_snapdir_inactive(), which would cause us to destroy 5458bf40bf0Sck * the sd_lock mutex held by our caller. 5468bf40bf0Sck */ 5478bf40bf0Sck ASSERT(svp->v_count == 1); 5488bf40bf0Sck gfs_vop_inactive(svp, cr, NULL); 549fa9e4066Sahrens 550fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 551fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 552fa9e4066Sahrens 553fa9e4066Sahrens return (0); 554fa9e4066Sahrens } 555fa9e4066Sahrens 5565422900bSmaybee static void 557fa9e4066Sahrens zfsctl_rename_snap(zfsctl_snapdir_t *sdp, zfs_snapentry_t *sep, const char *nm) 558fa9e4066Sahrens { 559fa9e4066Sahrens avl_index_t where; 560fa9e4066Sahrens vfs_t *vfsp; 561fa9e4066Sahrens refstr_t *pathref; 562fa9e4066Sahrens char newpath[MAXNAMELEN]; 563fa9e4066Sahrens char *tail; 564fa9e4066Sahrens 565fa9e4066Sahrens ASSERT(MUTEX_HELD(&sdp->sd_lock)); 566fa9e4066Sahrens ASSERT(sep != NULL); 567fa9e4066Sahrens 568fa9e4066Sahrens vfsp = vn_mountedvfs(sep->se_root); 569fa9e4066Sahrens ASSERT(vfsp != NULL); 570fa9e4066Sahrens 5715422900bSmaybee vfs_lock_wait(vfsp); 572fa9e4066Sahrens 573fa9e4066Sahrens /* 574fa9e4066Sahrens * Change the name in the AVL tree. 575fa9e4066Sahrens */ 576fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 577fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 578fa9e4066Sahrens sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP); 579fa9e4066Sahrens (void) strcpy(sep->se_name, nm); 580fa9e4066Sahrens VERIFY(avl_find(&sdp->sd_snaps, sep, &where) == NULL); 581fa9e4066Sahrens avl_insert(&sdp->sd_snaps, sep, where); 582fa9e4066Sahrens 583fa9e4066Sahrens /* 584fa9e4066Sahrens * Change the current mountpoint info: 585fa9e4066Sahrens * - update the tail of the mntpoint path 586fa9e4066Sahrens * - update the tail of the resource path 587fa9e4066Sahrens */ 588fa9e4066Sahrens pathref = vfs_getmntpoint(vfsp); 5890b69c2f0Sahrens (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath)); 5900b69c2f0Sahrens VERIFY((tail = strrchr(newpath, '/')) != NULL); 5910b69c2f0Sahrens *(tail+1) = '\0'; 5920b69c2f0Sahrens ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath)); 593fa9e4066Sahrens (void) strcat(newpath, nm); 594fa9e4066Sahrens refstr_rele(pathref); 595d7de0ceaSRobert Harris vfs_setmntpoint(vfsp, newpath, 0); 596fa9e4066Sahrens 597fa9e4066Sahrens pathref = vfs_getresource(vfsp); 5980b69c2f0Sahrens (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath)); 5990b69c2f0Sahrens VERIFY((tail = strrchr(newpath, '@')) != NULL); 6000b69c2f0Sahrens *(tail+1) = '\0'; 6010b69c2f0Sahrens ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath)); 602fa9e4066Sahrens (void) strcat(newpath, nm); 603fa9e4066Sahrens refstr_rele(pathref); 604d7de0ceaSRobert Harris vfs_setresource(vfsp, newpath, 0); 605fa9e4066Sahrens 606fa9e4066Sahrens vfs_unlock(vfsp); 607fa9e4066Sahrens } 608fa9e4066Sahrens 609da6c28aaSamw /*ARGSUSED*/ 610fa9e4066Sahrens static int 611fa9e4066Sahrens zfsctl_snapdir_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, 612da6c28aaSamw cred_t *cr, caller_context_t *ct, int flags) 613fa9e4066Sahrens { 614fa9e4066Sahrens zfsctl_snapdir_t *sdp = sdvp->v_data; 615fa9e4066Sahrens zfs_snapentry_t search, *sep; 616ab04eb8eStimh zfsvfs_t *zfsvfs; 617fa9e4066Sahrens avl_index_t where; 6189adfa60dSMatthew Ahrens char from[ZFS_MAX_DATASET_NAME_LEN], to[ZFS_MAX_DATASET_NAME_LEN]; 6199adfa60dSMatthew Ahrens char real[ZFS_MAX_DATASET_NAME_LEN], fsname[ZFS_MAX_DATASET_NAME_LEN]; 620fa9e4066Sahrens int err; 621fa9e4066Sahrens 622ab04eb8eStimh zfsvfs = sdvp->v_vfsp->vfs_data; 623ab04eb8eStimh ZFS_ENTER(zfsvfs); 624ab04eb8eStimh 625ab04eb8eStimh if ((flags & FIGNORECASE) || zfsvfs->z_case == ZFS_CASE_INSENSITIVE) { 626ab04eb8eStimh err = dmu_snapshot_realname(zfsvfs->z_os, snm, real, 6279adfa60dSMatthew Ahrens sizeof (real), NULL); 628ab04eb8eStimh if (err == 0) { 629ab04eb8eStimh snm = real; 630ab04eb8eStimh } else if (err != ENOTSUP) { 631ab04eb8eStimh ZFS_EXIT(zfsvfs); 632ab04eb8eStimh return (err); 633ab04eb8eStimh } 634ab04eb8eStimh } 635ab04eb8eStimh 636ab04eb8eStimh ZFS_EXIT(zfsvfs); 637ecd6cf80Smarks 6383b2aab18SMatthew Ahrens dmu_objset_name(zfsvfs->z_os, fsname); 6393b2aab18SMatthew Ahrens 6409adfa60dSMatthew Ahrens err = zfsctl_snapshot_zname(sdvp, snm, sizeof (from), from); 6413b2aab18SMatthew Ahrens if (err == 0) 6429adfa60dSMatthew Ahrens err = zfsctl_snapshot_zname(tdvp, tnm, sizeof (to), to); 6433b2aab18SMatthew Ahrens if (err == 0) 644ab04eb8eStimh err = zfs_secpolicy_rename_perms(from, to, cr); 6453b2aab18SMatthew Ahrens if (err != 0) 646fa9e4066Sahrens return (err); 647fa9e4066Sahrens 648fa9e4066Sahrens /* 649fa9e4066Sahrens * Cannot move snapshots out of the snapdir. 650fa9e4066Sahrens */ 651fa9e4066Sahrens if (sdvp != tdvp) 652be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 653fa9e4066Sahrens 654fa9e4066Sahrens if (strcmp(snm, tnm) == 0) 655fa9e4066Sahrens return (0); 656fa9e4066Sahrens 657fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 658fa9e4066Sahrens 659fa9e4066Sahrens search.se_name = (char *)snm; 6605422900bSmaybee if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) == NULL) { 6615422900bSmaybee mutex_exit(&sdp->sd_lock); 662be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 663fa9e4066Sahrens } 664fa9e4066Sahrens 6653b2aab18SMatthew Ahrens err = dsl_dataset_rename_snapshot(fsname, snm, tnm, B_FALSE); 6665422900bSmaybee if (err == 0) 6675422900bSmaybee zfsctl_rename_snap(sdp, sep, tnm); 668fa9e4066Sahrens 669fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 670fa9e4066Sahrens 671fa9e4066Sahrens return (err); 672fa9e4066Sahrens } 673fa9e4066Sahrens 674fa9e4066Sahrens /* ARGSUSED */ 675fa9e4066Sahrens static int 676da6c28aaSamw zfsctl_snapdir_remove(vnode_t *dvp, char *name, vnode_t *cwd, cred_t *cr, 677da6c28aaSamw caller_context_t *ct, int flags) 678fa9e4066Sahrens { 679fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 6808bf40bf0Sck zfs_snapentry_t *sep; 6818bf40bf0Sck zfs_snapentry_t search; 682ab04eb8eStimh zfsvfs_t *zfsvfs; 6839adfa60dSMatthew Ahrens char snapname[ZFS_MAX_DATASET_NAME_LEN]; 6849adfa60dSMatthew Ahrens char real[ZFS_MAX_DATASET_NAME_LEN]; 685fa9e4066Sahrens int err; 686fa9e4066Sahrens 687ab04eb8eStimh zfsvfs = dvp->v_vfsp->vfs_data; 688ab04eb8eStimh ZFS_ENTER(zfsvfs); 689ab04eb8eStimh 690ab04eb8eStimh if ((flags & FIGNORECASE) || zfsvfs->z_case == ZFS_CASE_INSENSITIVE) { 691ab04eb8eStimh 692ab04eb8eStimh err = dmu_snapshot_realname(zfsvfs->z_os, name, real, 6939adfa60dSMatthew Ahrens sizeof (real), NULL); 694ab04eb8eStimh if (err == 0) { 695ab04eb8eStimh name = real; 696ab04eb8eStimh } else if (err != ENOTSUP) { 697ab04eb8eStimh ZFS_EXIT(zfsvfs); 698ab04eb8eStimh return (err); 699ab04eb8eStimh } 700ab04eb8eStimh } 701ab04eb8eStimh 702ab04eb8eStimh ZFS_EXIT(zfsvfs); 703ab04eb8eStimh 7049adfa60dSMatthew Ahrens err = zfsctl_snapshot_zname(dvp, name, sizeof (snapname), snapname); 7053b2aab18SMatthew Ahrens if (err == 0) 706ab04eb8eStimh err = zfs_secpolicy_destroy_perms(snapname, cr); 7073b2aab18SMatthew Ahrens if (err != 0) 7085422900bSmaybee return (err); 709ecd6cf80Smarks 710fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 711fa9e4066Sahrens 7128bf40bf0Sck search.se_name = name; 7138bf40bf0Sck sep = avl_find(&sdp->sd_snaps, &search, NULL); 7148bf40bf0Sck if (sep) { 7158bf40bf0Sck avl_remove(&sdp->sd_snaps, sep); 7168bf40bf0Sck err = zfsctl_unmount_snap(sep, MS_FORCE, cr); 7173b2aab18SMatthew Ahrens if (err != 0) 7188bf40bf0Sck avl_add(&sdp->sd_snaps, sep); 7198bf40bf0Sck else 7203b2aab18SMatthew Ahrens err = dsl_destroy_snapshot(snapname, B_FALSE); 7218bf40bf0Sck } else { 722be6fd75aSMatthew Ahrens err = SET_ERROR(ENOENT); 723fa9e4066Sahrens } 724fa9e4066Sahrens 725fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 726fa9e4066Sahrens 727fa9e4066Sahrens return (err); 728fa9e4066Sahrens } 729fa9e4066Sahrens 730f18faf3fSek /* 731f18faf3fSek * This creates a snapshot under '.zfs/snapshot'. 732f18faf3fSek */ 733ecd6cf80Smarks /* ARGSUSED */ 734ecd6cf80Smarks static int 735ecd6cf80Smarks zfsctl_snapdir_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t **vpp, 736da6c28aaSamw cred_t *cr, caller_context_t *cc, int flags, vsecattr_t *vsecp) 737ecd6cf80Smarks { 738ecd6cf80Smarks zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 7399adfa60dSMatthew Ahrens char name[ZFS_MAX_DATASET_NAME_LEN]; 740ecd6cf80Smarks int err; 741ecd6cf80Smarks static enum symfollow follow = NO_FOLLOW; 742ecd6cf80Smarks static enum uio_seg seg = UIO_SYSSPACE; 743ecd6cf80Smarks 74478f17100SMatthew Ahrens if (zfs_component_namecheck(dirname, NULL, NULL) != 0) 745be6fd75aSMatthew Ahrens return (SET_ERROR(EILSEQ)); 7466d1e0b89Smarks 747ecd6cf80Smarks dmu_objset_name(zfsvfs->z_os, name); 748ecd6cf80Smarks 749ecd6cf80Smarks *vpp = NULL; 750ecd6cf80Smarks 751ecd6cf80Smarks err = zfs_secpolicy_snapshot_perms(name, cr); 7523b2aab18SMatthew Ahrens if (err != 0) 753ecd6cf80Smarks return (err); 754ecd6cf80Smarks 755ecd6cf80Smarks if (err == 0) { 7564445fffbSMatthew Ahrens err = dmu_objset_snapshot_one(name, dirname); 7573b2aab18SMatthew Ahrens if (err != 0) 758ecd6cf80Smarks return (err); 759ecd6cf80Smarks err = lookupnameat(dirname, seg, follow, NULL, vpp, dvp); 760ecd6cf80Smarks } 761ecd6cf80Smarks 762ecd6cf80Smarks return (err); 763ecd6cf80Smarks } 764ecd6cf80Smarks 765fa9e4066Sahrens /* 766fa9e4066Sahrens * Lookup entry point for the 'snapshot' directory. Try to open the 767fa9e4066Sahrens * snapshot if it exist, creating the pseudo filesystem vnode as necessary. 768fa9e4066Sahrens * Perform a mount of the associated dataset on top of the vnode. 769fa9e4066Sahrens */ 770fa9e4066Sahrens /* ARGSUSED */ 771fa9e4066Sahrens static int 772fa9e4066Sahrens zfsctl_snapdir_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 773da6c28aaSamw int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, 774da6c28aaSamw int *direntflags, pathname_t *realpnp) 775fa9e4066Sahrens { 776fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 777fa9e4066Sahrens objset_t *snap; 7789adfa60dSMatthew Ahrens char snapname[ZFS_MAX_DATASET_NAME_LEN]; 7799adfa60dSMatthew Ahrens char real[ZFS_MAX_DATASET_NAME_LEN]; 780fa9e4066Sahrens char *mountpoint; 781fa9e4066Sahrens zfs_snapentry_t *sep, search; 782fa9e4066Sahrens struct mounta margs; 783fa9e4066Sahrens vfs_t *vfsp; 784fa9e4066Sahrens size_t mountpoint_len; 785fa9e4066Sahrens avl_index_t where; 786fa9e4066Sahrens zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 787fa9e4066Sahrens int err; 788fa9e4066Sahrens 789da6c28aaSamw /* 790da6c28aaSamw * No extended attributes allowed under .zfs 791da6c28aaSamw */ 792da6c28aaSamw if (flags & LOOKUP_XATTR) 793be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 794da6c28aaSamw 795fa9e4066Sahrens ASSERT(dvp->v_type == VDIR); 796fa9e4066Sahrens 797fa9e4066Sahrens /* 798fa9e4066Sahrens * If we get a recursive call, that means we got called 799fa9e4066Sahrens * from the domount() code while it was trying to look up the 800fa9e4066Sahrens * spec (which looks like a local path for zfs). We need to 801fa9e4066Sahrens * add some flag to domount() to tell it not to do this lookup. 802fa9e4066Sahrens */ 803fa9e4066Sahrens if (MUTEX_HELD(&sdp->sd_lock)) 804be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 805fa9e4066Sahrens 806fa9e4066Sahrens ZFS_ENTER(zfsvfs); 807fa9e4066Sahrens 808142ae85dSChris Kirby if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) { 809142ae85dSChris Kirby ZFS_EXIT(zfsvfs); 810142ae85dSChris Kirby return (0); 811142ae85dSChris Kirby } 812142ae85dSChris Kirby 813ab04eb8eStimh if (flags & FIGNORECASE) { 814ab04eb8eStimh boolean_t conflict = B_FALSE; 815ab04eb8eStimh 816ab04eb8eStimh err = dmu_snapshot_realname(zfsvfs->z_os, nm, real, 8179adfa60dSMatthew Ahrens sizeof (real), &conflict); 818ab04eb8eStimh if (err == 0) { 819ab04eb8eStimh nm = real; 820ab04eb8eStimh } else if (err != ENOTSUP) { 821ab04eb8eStimh ZFS_EXIT(zfsvfs); 822ab04eb8eStimh return (err); 823ab04eb8eStimh } 824ab04eb8eStimh if (realpnp) 825ab04eb8eStimh (void) strlcpy(realpnp->pn_buf, nm, 826ab04eb8eStimh realpnp->pn_bufsize); 827ab04eb8eStimh if (conflict && direntflags) 828ab04eb8eStimh *direntflags = ED_CASE_CONFLICT; 829ab04eb8eStimh } 830ab04eb8eStimh 831fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 832fa9e4066Sahrens search.se_name = (char *)nm; 833fa9e4066Sahrens if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) != NULL) { 834fa9e4066Sahrens *vpp = sep->se_root; 835fa9e4066Sahrens VN_HOLD(*vpp); 836bbf4a8dfSmaybee err = traverse(vpp); 8373b2aab18SMatthew Ahrens if (err != 0) { 838bbf4a8dfSmaybee VN_RELE(*vpp); 839bbf4a8dfSmaybee *vpp = NULL; 840bbf4a8dfSmaybee } else if (*vpp == sep->se_root) { 841bbf4a8dfSmaybee /* 842bbf4a8dfSmaybee * The snapshot was unmounted behind our backs, 843bbf4a8dfSmaybee * try to remount it. 844bbf4a8dfSmaybee */ 845fa9e4066Sahrens goto domount; 8468bf40bf0Sck } else { 8478bf40bf0Sck /* 8488bf40bf0Sck * VROOT was set during the traverse call. We need 8498bf40bf0Sck * to clear it since we're pretending to be part 8508bf40bf0Sck * of our parent's vfs. 8518bf40bf0Sck */ 8528bf40bf0Sck (*vpp)->v_flag &= ~VROOT; 853bb963f1cSmaybee } 854fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 855fa9e4066Sahrens ZFS_EXIT(zfsvfs); 856bbf4a8dfSmaybee return (err); 857fa9e4066Sahrens } 858fa9e4066Sahrens 859fa9e4066Sahrens /* 860fa9e4066Sahrens * The requested snapshot is not currently mounted, look it up. 861fa9e4066Sahrens */ 8629adfa60dSMatthew Ahrens err = zfsctl_snapshot_zname(dvp, nm, sizeof (snapname), snapname); 8633b2aab18SMatthew Ahrens if (err != 0) { 8645422900bSmaybee mutex_exit(&sdp->sd_lock); 8655422900bSmaybee ZFS_EXIT(zfsvfs); 8662283022cSmarks /* 8672283022cSmarks * handle "ls *" or "?" in a graceful manner, 8682283022cSmarks * forcing EILSEQ to ENOENT. 8692283022cSmarks * Since shell ultimately passes "*" or "?" as name to lookup 8702283022cSmarks */ 8712283022cSmarks return (err == EILSEQ ? ENOENT : err); 8725422900bSmaybee } 873503ad85cSMatthew Ahrens if (dmu_objset_hold(snapname, FTAG, &snap) != 0) { 874fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 875fa9e4066Sahrens ZFS_EXIT(zfsvfs); 876be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 877fa9e4066Sahrens } 878fa9e4066Sahrens 879fa9e4066Sahrens sep = kmem_alloc(sizeof (zfs_snapentry_t), KM_SLEEP); 880fa9e4066Sahrens sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP); 881fa9e4066Sahrens (void) strcpy(sep->se_name, nm); 882fa9e4066Sahrens *vpp = sep->se_root = zfsctl_snapshot_mknode(dvp, dmu_objset_id(snap)); 883fa9e4066Sahrens avl_insert(&sdp->sd_snaps, sep, where); 884fa9e4066Sahrens 885503ad85cSMatthew Ahrens dmu_objset_rele(snap, FTAG); 886fa9e4066Sahrens domount: 887fa9e4066Sahrens mountpoint_len = strlen(refstr_value(dvp->v_vfsp->vfs_mntpt)) + 888fa9e4066Sahrens strlen("/.zfs/snapshot/") + strlen(nm) + 1; 889fa9e4066Sahrens mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP); 890fa9e4066Sahrens (void) snprintf(mountpoint, mountpoint_len, "%s/.zfs/snapshot/%s", 891fa9e4066Sahrens refstr_value(dvp->v_vfsp->vfs_mntpt), nm); 892fa9e4066Sahrens 893fa9e4066Sahrens margs.spec = snapname; 894fa9e4066Sahrens margs.dir = mountpoint; 895fa9e4066Sahrens margs.flags = MS_SYSSPACE | MS_NOMNTTAB; 896fa9e4066Sahrens margs.fstype = "zfs"; 897fa9e4066Sahrens margs.dataptr = NULL; 898fa9e4066Sahrens margs.datalen = 0; 899fa9e4066Sahrens margs.optptr = NULL; 900fa9e4066Sahrens margs.optlen = 0; 901fa9e4066Sahrens 902fa9e4066Sahrens err = domount("zfs", &margs, *vpp, kcred, &vfsp); 903fa9e4066Sahrens kmem_free(mountpoint, mountpoint_len); 904fa9e4066Sahrens 90595c9592aSmaybee if (err == 0) { 90695c9592aSmaybee /* 90795c9592aSmaybee * Return the mounted root rather than the covered mount point. 908f18faf3fSek * Takes the GFS vnode at .zfs/snapshot/<snapname> and returns 909f18faf3fSek * the ZFS vnode mounted on top of the GFS node. This ZFS 910142ae85dSChris Kirby * vnode is the root of the newly created vfsp. 91195c9592aSmaybee */ 91295c9592aSmaybee VFS_RELE(vfsp); 91395c9592aSmaybee err = traverse(vpp); 91495c9592aSmaybee } 915fa9e4066Sahrens 91695c9592aSmaybee if (err == 0) { 91795c9592aSmaybee /* 918f18faf3fSek * Fix up the root vnode mounted on .zfs/snapshot/<snapname>. 919ed097989Sek * 920ed097989Sek * This is where we lie about our v_vfsp in order to 921f18faf3fSek * make .zfs/snapshot/<snapname> accessible over NFS 922f18faf3fSek * without requiring manual mounts of <snapname>. 92395c9592aSmaybee */ 92495c9592aSmaybee ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs); 92595c9592aSmaybee VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs; 92695c9592aSmaybee (*vpp)->v_vfsp = zfsvfs->z_vfs; 92795c9592aSmaybee (*vpp)->v_flag &= ~VROOT; 92895c9592aSmaybee } 929fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 930fa9e4066Sahrens ZFS_EXIT(zfsvfs); 931fa9e4066Sahrens 932bb963f1cSmaybee /* 933bb963f1cSmaybee * If we had an error, drop our hold on the vnode and 934bb963f1cSmaybee * zfsctl_snapshot_inactive() will clean up. 935bb963f1cSmaybee */ 9363b2aab18SMatthew Ahrens if (err != 0) { 93795c9592aSmaybee VN_RELE(*vpp); 938bb963f1cSmaybee *vpp = NULL; 939bb963f1cSmaybee } 94095c9592aSmaybee return (err); 941fa9e4066Sahrens } 942fa9e4066Sahrens 943743a77edSAlan Wright /* ARGSUSED */ 944743a77edSAlan Wright static int 945743a77edSAlan Wright zfsctl_shares_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 946743a77edSAlan Wright int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, 947743a77edSAlan Wright int *direntflags, pathname_t *realpnp) 948743a77edSAlan Wright { 949743a77edSAlan Wright zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 950743a77edSAlan Wright znode_t *dzp; 951743a77edSAlan Wright int error; 952743a77edSAlan Wright 953743a77edSAlan Wright ZFS_ENTER(zfsvfs); 954743a77edSAlan Wright 955743a77edSAlan Wright if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) { 956743a77edSAlan Wright ZFS_EXIT(zfsvfs); 957743a77edSAlan Wright return (0); 958743a77edSAlan Wright } 959743a77edSAlan Wright 9609e1320c0SMark Shellenbaum if (zfsvfs->z_shares_dir == 0) { 9619e1320c0SMark Shellenbaum ZFS_EXIT(zfsvfs); 962be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTSUP)); 9639e1320c0SMark Shellenbaum } 9640f92170fSDan McDonald if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) { 965743a77edSAlan Wright error = VOP_LOOKUP(ZTOV(dzp), nm, vpp, pnp, 966743a77edSAlan Wright flags, rdir, cr, ct, direntflags, realpnp); 9670f92170fSDan McDonald VN_RELE(ZTOV(dzp)); 9680f92170fSDan McDonald } 969743a77edSAlan Wright 970743a77edSAlan Wright ZFS_EXIT(zfsvfs); 971743a77edSAlan Wright 972743a77edSAlan Wright return (error); 973743a77edSAlan Wright } 974743a77edSAlan Wright 975fa9e4066Sahrens /* ARGSUSED */ 976fa9e4066Sahrens static int 977b38f0970Sck zfsctl_snapdir_readdir_cb(vnode_t *vp, void *dp, int *eofp, 978b38f0970Sck offset_t *offp, offset_t *nextp, void *data, int flags) 979fa9e4066Sahrens { 980fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 9819adfa60dSMatthew Ahrens char snapname[ZFS_MAX_DATASET_NAME_LEN]; 982fa9e4066Sahrens uint64_t id, cookie; 983b38f0970Sck boolean_t case_conflict; 984b38f0970Sck int error; 985fa9e4066Sahrens 986fa9e4066Sahrens ZFS_ENTER(zfsvfs); 987fa9e4066Sahrens 988fa9e4066Sahrens cookie = *offp; 9893b2aab18SMatthew Ahrens dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG); 9909adfa60dSMatthew Ahrens error = dmu_snapshot_list_next(zfsvfs->z_os, 9919adfa60dSMatthew Ahrens sizeof (snapname), snapname, &id, &cookie, &case_conflict); 9923b2aab18SMatthew Ahrens dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG); 993b38f0970Sck if (error) { 994fa9e4066Sahrens ZFS_EXIT(zfsvfs); 995b38f0970Sck if (error == ENOENT) { 996b38f0970Sck *eofp = 1; 997b38f0970Sck return (0); 998b38f0970Sck } 999b38f0970Sck return (error); 1000fa9e4066Sahrens } 1001fa9e4066Sahrens 1002b38f0970Sck if (flags & V_RDDIR_ENTFLAGS) { 1003b38f0970Sck edirent_t *eodp = dp; 1004b38f0970Sck 1005b38f0970Sck (void) strcpy(eodp->ed_name, snapname); 1006b38f0970Sck eodp->ed_ino = ZFSCTL_INO_SNAP(id); 1007b38f0970Sck eodp->ed_eflags = case_conflict ? ED_CASE_CONFLICT : 0; 1008b38f0970Sck } else { 1009b38f0970Sck struct dirent64 *odp = dp; 1010b38f0970Sck 1011b38f0970Sck (void) strcpy(odp->d_name, snapname); 1012b38f0970Sck odp->d_ino = ZFSCTL_INO_SNAP(id); 1013b38f0970Sck } 1014fa9e4066Sahrens *nextp = cookie; 1015fa9e4066Sahrens 1016fa9e4066Sahrens ZFS_EXIT(zfsvfs); 1017fa9e4066Sahrens 1018fa9e4066Sahrens return (0); 1019fa9e4066Sahrens } 1020fa9e4066Sahrens 1021743a77edSAlan Wright /* ARGSUSED */ 1022743a77edSAlan Wright static int 1023743a77edSAlan Wright zfsctl_shares_readdir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp, 1024743a77edSAlan Wright caller_context_t *ct, int flags) 1025743a77edSAlan Wright { 1026743a77edSAlan Wright zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1027743a77edSAlan Wright znode_t *dzp; 1028743a77edSAlan Wright int error; 1029743a77edSAlan Wright 1030743a77edSAlan Wright ZFS_ENTER(zfsvfs); 1031743a77edSAlan Wright 10329e1320c0SMark Shellenbaum if (zfsvfs->z_shares_dir == 0) { 10339e1320c0SMark Shellenbaum ZFS_EXIT(zfsvfs); 1034be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTSUP)); 10359e1320c0SMark Shellenbaum } 1036743a77edSAlan Wright if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) { 1037743a77edSAlan Wright error = VOP_READDIR(ZTOV(dzp), uiop, cr, eofp, ct, flags); 1038743a77edSAlan Wright VN_RELE(ZTOV(dzp)); 1039743a77edSAlan Wright } else { 1040743a77edSAlan Wright *eofp = 1; 1041be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT); 1042743a77edSAlan Wright } 1043743a77edSAlan Wright 1044743a77edSAlan Wright ZFS_EXIT(zfsvfs); 1045743a77edSAlan Wright return (error); 1046743a77edSAlan Wright } 1047743a77edSAlan Wright 1048f18faf3fSek /* 1049f18faf3fSek * pvp is the '.zfs' directory (zfsctl_node_t). 1050f7170741SWill Andrews * 1051f18faf3fSek * Creates vp, which is '.zfs/snapshot' (zfsctl_snapdir_t). 1052f18faf3fSek * 1053f18faf3fSek * This function is the callback to create a GFS vnode for '.zfs/snapshot' 1054f18faf3fSek * when a lookup is performed on .zfs for "snapshot". 1055f18faf3fSek */ 1056fa9e4066Sahrens vnode_t * 1057fa9e4066Sahrens zfsctl_mknode_snapdir(vnode_t *pvp) 1058fa9e4066Sahrens { 1059fa9e4066Sahrens vnode_t *vp; 1060fa9e4066Sahrens zfsctl_snapdir_t *sdp; 1061fa9e4066Sahrens 1062fa9e4066Sahrens vp = gfs_dir_create(sizeof (zfsctl_snapdir_t), pvp, 1063fa9e4066Sahrens zfsctl_ops_snapdir, NULL, NULL, MAXNAMELEN, 1064fa9e4066Sahrens zfsctl_snapdir_readdir_cb, NULL); 1065fa9e4066Sahrens sdp = vp->v_data; 1066fa9e4066Sahrens sdp->sd_node.zc_id = ZFSCTL_INO_SNAPDIR; 1067a32fded1Sek sdp->sd_node.zc_cmtime = ((zfsctl_node_t *)pvp->v_data)->zc_cmtime; 1068fa9e4066Sahrens mutex_init(&sdp->sd_lock, NULL, MUTEX_DEFAULT, NULL); 1069fa9e4066Sahrens avl_create(&sdp->sd_snaps, snapentry_compare, 1070fa9e4066Sahrens sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t, se_node)); 1071fa9e4066Sahrens return (vp); 1072fa9e4066Sahrens } 1073fa9e4066Sahrens 1074743a77edSAlan Wright vnode_t * 1075743a77edSAlan Wright zfsctl_mknode_shares(vnode_t *pvp) 1076743a77edSAlan Wright { 1077743a77edSAlan Wright vnode_t *vp; 1078743a77edSAlan Wright zfsctl_node_t *sdp; 1079743a77edSAlan Wright 1080743a77edSAlan Wright vp = gfs_dir_create(sizeof (zfsctl_node_t), pvp, 1081743a77edSAlan Wright zfsctl_ops_shares, NULL, NULL, MAXNAMELEN, 1082743a77edSAlan Wright NULL, NULL); 1083743a77edSAlan Wright sdp = vp->v_data; 1084743a77edSAlan Wright sdp->zc_cmtime = ((zfsctl_node_t *)pvp->v_data)->zc_cmtime; 1085743a77edSAlan Wright return (vp); 1086743a77edSAlan Wright 1087743a77edSAlan Wright } 1088743a77edSAlan Wright 1089743a77edSAlan Wright /* ARGSUSED */ 1090743a77edSAlan Wright static int 1091743a77edSAlan Wright zfsctl_shares_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 1092743a77edSAlan Wright caller_context_t *ct) 1093743a77edSAlan Wright { 1094743a77edSAlan Wright zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1095743a77edSAlan Wright znode_t *dzp; 1096743a77edSAlan Wright int error; 1097743a77edSAlan Wright 1098743a77edSAlan Wright ZFS_ENTER(zfsvfs); 10999e1320c0SMark Shellenbaum if (zfsvfs->z_shares_dir == 0) { 11009e1320c0SMark Shellenbaum ZFS_EXIT(zfsvfs); 1101be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTSUP)); 11029e1320c0SMark Shellenbaum } 1103743a77edSAlan Wright if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) { 1104743a77edSAlan Wright error = VOP_GETATTR(ZTOV(dzp), vap, flags, cr, ct); 1105743a77edSAlan Wright VN_RELE(ZTOV(dzp)); 1106743a77edSAlan Wright } 1107743a77edSAlan Wright ZFS_EXIT(zfsvfs); 1108743a77edSAlan Wright return (error); 1109743a77edSAlan Wright 1110743a77edSAlan Wright 1111743a77edSAlan Wright } 1112743a77edSAlan Wright 1113fa9e4066Sahrens /* ARGSUSED */ 1114fa9e4066Sahrens static int 1115da6c28aaSamw zfsctl_snapdir_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 1116da6c28aaSamw caller_context_t *ct) 1117fa9e4066Sahrens { 1118fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 1119fa9e4066Sahrens zfsctl_snapdir_t *sdp = vp->v_data; 1120fa9e4066Sahrens 1121fa9e4066Sahrens ZFS_ENTER(zfsvfs); 1122fa9e4066Sahrens zfsctl_common_getattr(vp, vap); 1123fa9e4066Sahrens vap->va_nodeid = gfs_file_inode(vp); 1124fa9e4066Sahrens vap->va_nlink = vap->va_size = avl_numnodes(&sdp->sd_snaps) + 2; 112571eb0538SChris Kirby vap->va_ctime = vap->va_mtime = dmu_objset_snap_cmtime(zfsvfs->z_os); 1126fa9e4066Sahrens ZFS_EXIT(zfsvfs); 1127fa9e4066Sahrens 1128fa9e4066Sahrens return (0); 1129fa9e4066Sahrens } 1130fa9e4066Sahrens 1131bb963f1cSmaybee /* ARGSUSED */ 1132fa9e4066Sahrens static void 1133da6c28aaSamw zfsctl_snapdir_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct) 1134fa9e4066Sahrens { 1135fa9e4066Sahrens zfsctl_snapdir_t *sdp = vp->v_data; 1136bb963f1cSmaybee void *private; 1137bb963f1cSmaybee 1138bb963f1cSmaybee private = gfs_dir_inactive(vp); 1139bb963f1cSmaybee if (private != NULL) { 1140bb963f1cSmaybee ASSERT(avl_numnodes(&sdp->sd_snaps) == 0); 1141bb963f1cSmaybee mutex_destroy(&sdp->sd_lock); 1142bb963f1cSmaybee avl_destroy(&sdp->sd_snaps); 1143bb963f1cSmaybee kmem_free(private, sizeof (zfsctl_snapdir_t)); 1144bb963f1cSmaybee } 1145fa9e4066Sahrens } 1146fa9e4066Sahrens 1147fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapdir[] = { 1148aa59c4cbSrsb { VOPNAME_OPEN, { .vop_open = zfsctl_common_open } }, 1149aa59c4cbSrsb { VOPNAME_CLOSE, { .vop_close = zfsctl_common_close } }, 1150aa59c4cbSrsb { VOPNAME_IOCTL, { .error = fs_inval } }, 1151aa59c4cbSrsb { VOPNAME_GETATTR, { .vop_getattr = zfsctl_snapdir_getattr } }, 1152aa59c4cbSrsb { VOPNAME_ACCESS, { .vop_access = zfsctl_common_access } }, 1153aa59c4cbSrsb { VOPNAME_RENAME, { .vop_rename = zfsctl_snapdir_rename } }, 1154aa59c4cbSrsb { VOPNAME_RMDIR, { .vop_rmdir = zfsctl_snapdir_remove } }, 1155ecd6cf80Smarks { VOPNAME_MKDIR, { .vop_mkdir = zfsctl_snapdir_mkdir } }, 1156aa59c4cbSrsb { VOPNAME_READDIR, { .vop_readdir = gfs_vop_readdir } }, 1157aa59c4cbSrsb { VOPNAME_LOOKUP, { .vop_lookup = zfsctl_snapdir_lookup } }, 1158aa59c4cbSrsb { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 1159aa59c4cbSrsb { VOPNAME_INACTIVE, { .vop_inactive = zfsctl_snapdir_inactive } }, 1160aa59c4cbSrsb { VOPNAME_FID, { .vop_fid = zfsctl_common_fid } }, 1161fa9e4066Sahrens { NULL } 1162fa9e4066Sahrens }; 1163fa9e4066Sahrens 1164743a77edSAlan Wright static const fs_operation_def_t zfsctl_tops_shares[] = { 1165743a77edSAlan Wright { VOPNAME_OPEN, { .vop_open = zfsctl_common_open } }, 1166743a77edSAlan Wright { VOPNAME_CLOSE, { .vop_close = zfsctl_common_close } }, 1167743a77edSAlan Wright { VOPNAME_IOCTL, { .error = fs_inval } }, 1168743a77edSAlan Wright { VOPNAME_GETATTR, { .vop_getattr = zfsctl_shares_getattr } }, 1169743a77edSAlan Wright { VOPNAME_ACCESS, { .vop_access = zfsctl_common_access } }, 1170743a77edSAlan Wright { VOPNAME_READDIR, { .vop_readdir = zfsctl_shares_readdir } }, 1171743a77edSAlan Wright { VOPNAME_LOOKUP, { .vop_lookup = zfsctl_shares_lookup } }, 1172743a77edSAlan Wright { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 1173743a77edSAlan Wright { VOPNAME_INACTIVE, { .vop_inactive = gfs_vop_inactive } }, 1174743a77edSAlan Wright { VOPNAME_FID, { .vop_fid = zfsctl_shares_fid } }, 1175743a77edSAlan Wright { NULL } 1176743a77edSAlan Wright }; 1177743a77edSAlan Wright 1178f18faf3fSek /* 1179f18faf3fSek * pvp is the GFS vnode '.zfs/snapshot'. 1180f18faf3fSek * 1181f18faf3fSek * This creates a GFS node under '.zfs/snapshot' representing each 1182f18faf3fSek * snapshot. This newly created GFS node is what we mount snapshot 1183f18faf3fSek * vfs_t's ontop of. 1184f18faf3fSek */ 1185fa9e4066Sahrens static vnode_t * 1186fa9e4066Sahrens zfsctl_snapshot_mknode(vnode_t *pvp, uint64_t objset) 1187fa9e4066Sahrens { 1188fa9e4066Sahrens vnode_t *vp; 1189fa9e4066Sahrens zfsctl_node_t *zcp; 1190fa9e4066Sahrens 1191fa9e4066Sahrens vp = gfs_dir_create(sizeof (zfsctl_node_t), pvp, 1192fa9e4066Sahrens zfsctl_ops_snapshot, NULL, NULL, MAXNAMELEN, NULL, NULL); 1193fa9e4066Sahrens zcp = vp->v_data; 1194fa9e4066Sahrens zcp->zc_id = objset; 1195fa9e4066Sahrens 1196fa9e4066Sahrens return (vp); 1197fa9e4066Sahrens } 1198fa9e4066Sahrens 1199fa9e4066Sahrens static void 1200da6c28aaSamw zfsctl_snapshot_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct) 1201fa9e4066Sahrens { 1202fa9e4066Sahrens zfsctl_snapdir_t *sdp; 1203fa9e4066Sahrens zfs_snapentry_t *sep, *next; 1204fa9e4066Sahrens vnode_t *dvp; 1205fa9e4066Sahrens 1206ab04eb8eStimh VERIFY(gfs_dir_lookup(vp, "..", &dvp, cr, 0, NULL, NULL) == 0); 1207fa9e4066Sahrens sdp = dvp->v_data; 1208fa9e4066Sahrens 1209fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 1210fa9e4066Sahrens 121120a95fb2SMatthew Ahrens mutex_enter(&vp->v_lock); 1212fa9e4066Sahrens if (vp->v_count > 1) { 121320a95fb2SMatthew Ahrens vp->v_count--; 121420a95fb2SMatthew Ahrens mutex_exit(&vp->v_lock); 1215fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 121620a95fb2SMatthew Ahrens VN_RELE(dvp); 1217fa9e4066Sahrens return; 1218fa9e4066Sahrens } 121920a95fb2SMatthew Ahrens mutex_exit(&vp->v_lock); 1220fa9e4066Sahrens ASSERT(!vn_ismntpt(vp)); 1221fa9e4066Sahrens 1222fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 1223fa9e4066Sahrens while (sep != NULL) { 1224fa9e4066Sahrens next = AVL_NEXT(&sdp->sd_snaps, sep); 1225fa9e4066Sahrens 1226fa9e4066Sahrens if (sep->se_root == vp) { 1227fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 1228fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 1229fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 1230fa9e4066Sahrens break; 1231fa9e4066Sahrens } 1232fa9e4066Sahrens sep = next; 1233fa9e4066Sahrens } 1234fa9e4066Sahrens ASSERT(sep != NULL); 1235fa9e4066Sahrens 1236fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 1237fa9e4066Sahrens VN_RELE(dvp); 1238fa9e4066Sahrens 1239bb963f1cSmaybee /* 1240bb963f1cSmaybee * Dispose of the vnode for the snapshot mount point. 1241bb963f1cSmaybee * This is safe to do because once this entry has been removed 1242bb963f1cSmaybee * from the AVL tree, it can't be found again, so cannot become 1243bb963f1cSmaybee * "active". If we lookup the same name again we will end up 1244bb963f1cSmaybee * creating a new vnode. 1245bb963f1cSmaybee */ 1246da6c28aaSamw gfs_vop_inactive(vp, cr, ct); 1247fa9e4066Sahrens } 1248fa9e4066Sahrens 1249fa9e4066Sahrens 1250fa9e4066Sahrens /* 1251fa9e4066Sahrens * These VP's should never see the light of day. They should always 1252fa9e4066Sahrens * be covered. 1253fa9e4066Sahrens */ 1254fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapshot[] = { 1255aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfsctl_snapshot_inactive }, 1256fa9e4066Sahrens NULL, NULL 1257fa9e4066Sahrens }; 1258fa9e4066Sahrens 1259fa9e4066Sahrens int 1260fa9e4066Sahrens zfsctl_lookup_objset(vfs_t *vfsp, uint64_t objsetid, zfsvfs_t **zfsvfsp) 1261fa9e4066Sahrens { 1262fa9e4066Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 1263fa9e4066Sahrens vnode_t *dvp, *vp; 1264fa9e4066Sahrens zfsctl_snapdir_t *sdp; 1265fa9e4066Sahrens zfsctl_node_t *zcp; 1266fa9e4066Sahrens zfs_snapentry_t *sep; 1267fa9e4066Sahrens int error; 1268fa9e4066Sahrens 1269fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir != NULL); 1270fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp, 1271da6c28aaSamw NULL, 0, NULL, kcred, NULL, NULL, NULL); 1272fa9e4066Sahrens if (error != 0) 1273fa9e4066Sahrens return (error); 1274fa9e4066Sahrens sdp = dvp->v_data; 1275fa9e4066Sahrens 1276fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 1277fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 1278fa9e4066Sahrens while (sep != NULL) { 1279fa9e4066Sahrens vp = sep->se_root; 1280fa9e4066Sahrens zcp = vp->v_data; 1281fa9e4066Sahrens if (zcp->zc_id == objsetid) 1282fa9e4066Sahrens break; 1283fa9e4066Sahrens 1284fa9e4066Sahrens sep = AVL_NEXT(&sdp->sd_snaps, sep); 1285fa9e4066Sahrens } 1286fa9e4066Sahrens 1287fa9e4066Sahrens if (sep != NULL) { 1288fa9e4066Sahrens VN_HOLD(vp); 1289f18faf3fSek /* 1290f18faf3fSek * Return the mounted root rather than the covered mount point. 1291f18faf3fSek * Takes the GFS vnode at .zfs/snapshot/<snapshot objsetid> 1292f18faf3fSek * and returns the ZFS vnode mounted on top of the GFS node. 1293f18faf3fSek * This ZFS vnode is the root of the vfs for objset 'objsetid'. 1294f18faf3fSek */ 1295fa9e4066Sahrens error = traverse(&vp); 1296bbf4a8dfSmaybee if (error == 0) { 1297bbf4a8dfSmaybee if (vp == sep->se_root) 1298be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 1299bbf4a8dfSmaybee else 1300bbf4a8dfSmaybee *zfsvfsp = VTOZ(vp)->z_zfsvfs; 1301bbf4a8dfSmaybee } 1302fea70b54Snd mutex_exit(&sdp->sd_lock); 1303fa9e4066Sahrens VN_RELE(vp); 1304fa9e4066Sahrens } else { 1305be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 1306fea70b54Snd mutex_exit(&sdp->sd_lock); 1307fa9e4066Sahrens } 1308fa9e4066Sahrens 1309fa9e4066Sahrens VN_RELE(dvp); 1310fa9e4066Sahrens 1311fa9e4066Sahrens return (error); 1312fa9e4066Sahrens } 1313fa9e4066Sahrens 1314fa9e4066Sahrens /* 1315fa9e4066Sahrens * Unmount any snapshots for the given filesystem. This is called from 1316fa9e4066Sahrens * zfs_umount() - if we have a ctldir, then go through and unmount all the 1317fa9e4066Sahrens * snapshots. 1318fa9e4066Sahrens */ 1319fa9e4066Sahrens int 1320fa9e4066Sahrens zfsctl_umount_snapshots(vfs_t *vfsp, int fflags, cred_t *cr) 1321fa9e4066Sahrens { 1322fa9e4066Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 13238bf40bf0Sck vnode_t *dvp; 1324fa9e4066Sahrens zfsctl_snapdir_t *sdp; 1325fa9e4066Sahrens zfs_snapentry_t *sep, *next; 1326fa9e4066Sahrens int error; 1327fa9e4066Sahrens 1328fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir != NULL); 1329fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp, 1330da6c28aaSamw NULL, 0, NULL, cr, NULL, NULL, NULL); 1331fa9e4066Sahrens if (error != 0) 1332fa9e4066Sahrens return (error); 1333fa9e4066Sahrens sdp = dvp->v_data; 1334fa9e4066Sahrens 1335fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 1336fa9e4066Sahrens 1337fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 1338fa9e4066Sahrens while (sep != NULL) { 1339fa9e4066Sahrens next = AVL_NEXT(&sdp->sd_snaps, sep); 1340fa9e4066Sahrens 1341fa9e4066Sahrens /* 1342fa9e4066Sahrens * If this snapshot is not mounted, then it must 1343fa9e4066Sahrens * have just been unmounted by somebody else, and 1344fa9e4066Sahrens * will be cleaned up by zfsctl_snapdir_inactive(). 1345fa9e4066Sahrens */ 13468bf40bf0Sck if (vn_ismntpt(sep->se_root)) { 13478bf40bf0Sck avl_remove(&sdp->sd_snaps, sep); 13488bf40bf0Sck error = zfsctl_unmount_snap(sep, fflags, cr); 1349fa9e4066Sahrens if (error) { 13508bf40bf0Sck avl_add(&sdp->sd_snaps, sep); 13518bf40bf0Sck break; 1352fa9e4066Sahrens } 1353fa9e4066Sahrens } 1354fa9e4066Sahrens sep = next; 1355fa9e4066Sahrens } 13568bf40bf0Sck 1357fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 1358fa9e4066Sahrens VN_RELE(dvp); 1359fa9e4066Sahrens 1360fa9e4066Sahrens return (error); 1361fa9e4066Sahrens } 1362