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 /* 22*8bf40bf0Sck * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens /* 29fa9e4066Sahrens * ZFS control directory (a.k.a. ".zfs") 30fa9e4066Sahrens * 31fa9e4066Sahrens * This directory provides a common location for all ZFS meta-objects. 32fa9e4066Sahrens * Currently, this is only the 'snapshot' directory, but this may expand in the 33fa9e4066Sahrens * future. The elements are built using the GFS primitives, as the hierarchy 34fa9e4066Sahrens * does not actually exist on disk. 35fa9e4066Sahrens * 36fa9e4066Sahrens * For 'snapshot', we don't want to have all snapshots always mounted, because 37fa9e4066Sahrens * this would take up a huge amount of space in /etc/mnttab. We have three 38fa9e4066Sahrens * types of objects: 39fa9e4066Sahrens * 40fa9e4066Sahrens * ctldir ------> snapshotdir -------> snapshot 41fa9e4066Sahrens * | 42fa9e4066Sahrens * | 43fa9e4066Sahrens * V 44fa9e4066Sahrens * mounted fs 45fa9e4066Sahrens * 46fa9e4066Sahrens * The 'snapshot' node contains just enough information to lookup '..' and act 47fa9e4066Sahrens * as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we 48fa9e4066Sahrens * perform an automount of the underlying filesystem and return the 49fa9e4066Sahrens * corresponding vnode. 50fa9e4066Sahrens * 51fa9e4066Sahrens * All mounts are handled automatically by the kernel, but unmounts are 52fa9e4066Sahrens * (currently) handled from user land. The main reason is that there is no 53fa9e4066Sahrens * reliable way to auto-unmount the filesystem when it's "no longer in use". 54fa9e4066Sahrens * When the user unmounts a filesystem, we call zfsctl_unmount(), which 55fa9e4066Sahrens * unmounts any snapshots within the snapshot directory. 56f18faf3fSek * 57f18faf3fSek * The '.zfs', '.zfs/snapshot', and all directories created under 58f18faf3fSek * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') are all GFS nodes and 59f18faf3fSek * share the same vfs_t as the head filesystem (what '.zfs' lives under). 60f18faf3fSek * 61f18faf3fSek * File systems mounted ontop of the GFS nodes '.zfs/snapshot/<snapname>' 62f18faf3fSek * (ie: snapshots) are ZFS nodes and have their own unique vfs_t. 63f18faf3fSek * However, vnodes within these mounted on file systems have their v_vfsp 64f18faf3fSek * fields set to the head filesystem to make NFS happy (see 65*8bf40bf0Sck * zfsctl_snapdir_lookup()). We VFS_HOLD the head filesystem's vfs_t 66*8bf40bf0Sck * so that it cannot be freed until all snapshots have been unmounted. 67fa9e4066Sahrens */ 68fa9e4066Sahrens 69fa9e4066Sahrens #include <fs/fs_subr.h> 70fa9e4066Sahrens #include <sys/zfs_ctldir.h> 71fa9e4066Sahrens #include <sys/zfs_ioctl.h> 72fa9e4066Sahrens #include <sys/zfs_vfsops.h> 73aa59c4cbSrsb #include <sys/vfs_opreg.h> 74fa9e4066Sahrens #include <sys/gfs.h> 75fa9e4066Sahrens #include <sys/stat.h> 76fa9e4066Sahrens #include <sys/dmu.h> 77ecd6cf80Smarks #include <sys/dsl_deleg.h> 78fa9e4066Sahrens #include <sys/mount.h> 79fa9e4066Sahrens 80*8bf40bf0Sck typedef struct zfsctl_node { 81*8bf40bf0Sck gfs_dir_t zc_gfs_private; 82*8bf40bf0Sck uint64_t zc_id; 83*8bf40bf0Sck timestruc_t zc_cmtime; /* ctime and mtime, always the same */ 84*8bf40bf0Sck } zfsctl_node_t; 85*8bf40bf0Sck 86*8bf40bf0Sck typedef struct zfsctl_snapdir { 87*8bf40bf0Sck zfsctl_node_t sd_node; 88*8bf40bf0Sck kmutex_t sd_lock; 89*8bf40bf0Sck avl_tree_t sd_snaps; 90*8bf40bf0Sck } zfsctl_snapdir_t; 91*8bf40bf0Sck 92fa9e4066Sahrens typedef struct { 93fa9e4066Sahrens char *se_name; 94fa9e4066Sahrens vnode_t *se_root; 95fa9e4066Sahrens avl_node_t se_node; 96fa9e4066Sahrens } zfs_snapentry_t; 97fa9e4066Sahrens 98fa9e4066Sahrens static int 99fa9e4066Sahrens snapentry_compare(const void *a, const void *b) 100fa9e4066Sahrens { 101fa9e4066Sahrens const zfs_snapentry_t *sa = a; 102fa9e4066Sahrens const zfs_snapentry_t *sb = b; 103fa9e4066Sahrens int ret = strcmp(sa->se_name, sb->se_name); 104fa9e4066Sahrens 105fa9e4066Sahrens if (ret < 0) 106fa9e4066Sahrens return (-1); 107fa9e4066Sahrens else if (ret > 0) 108fa9e4066Sahrens return (1); 109fa9e4066Sahrens else 110fa9e4066Sahrens return (0); 111fa9e4066Sahrens } 112fa9e4066Sahrens 113fa9e4066Sahrens vnodeops_t *zfsctl_ops_root; 114fa9e4066Sahrens vnodeops_t *zfsctl_ops_snapdir; 115fa9e4066Sahrens vnodeops_t *zfsctl_ops_snapshot; 116fa9e4066Sahrens 117fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_root[]; 118fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapdir[]; 119fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapshot[]; 120fa9e4066Sahrens 121fa9e4066Sahrens static vnode_t *zfsctl_mknode_snapdir(vnode_t *); 122fa9e4066Sahrens static vnode_t *zfsctl_snapshot_mknode(vnode_t *, uint64_t objset); 123*8bf40bf0Sck static int zfsctl_unmount_snap(zfs_snapentry_t *, int, cred_t *); 124fa9e4066Sahrens 125fa9e4066Sahrens static gfs_opsvec_t zfsctl_opsvec[] = { 126fa9e4066Sahrens { ".zfs", zfsctl_tops_root, &zfsctl_ops_root }, 127fa9e4066Sahrens { ".zfs/snapshot", zfsctl_tops_snapdir, &zfsctl_ops_snapdir }, 128fa9e4066Sahrens { ".zfs/snapshot/vnode", zfsctl_tops_snapshot, &zfsctl_ops_snapshot }, 129fa9e4066Sahrens { NULL } 130fa9e4066Sahrens }; 131fa9e4066Sahrens 132fa9e4066Sahrens /* 133fa9e4066Sahrens * Root directory elements. We have only a single static entry, 'snapshot'. 134fa9e4066Sahrens */ 135fa9e4066Sahrens static gfs_dirent_t zfsctl_root_entries[] = { 136fa9e4066Sahrens { "snapshot", zfsctl_mknode_snapdir, GFS_CACHE_VNODE }, 137fa9e4066Sahrens { NULL } 138fa9e4066Sahrens }; 139fa9e4066Sahrens 140fa9e4066Sahrens /* include . and .. in the calculation */ 141fa9e4066Sahrens #define NROOT_ENTRIES ((sizeof (zfsctl_root_entries) / \ 142fa9e4066Sahrens sizeof (gfs_dirent_t)) + 1) 143fa9e4066Sahrens 144fa9e4066Sahrens 145fa9e4066Sahrens /* 146fa9e4066Sahrens * Initialize the various GFS pieces we'll need to create and manipulate .zfs 147fa9e4066Sahrens * directories. This is called from the ZFS init routine, and initializes the 148fa9e4066Sahrens * vnode ops vectors that we'll be using. 149fa9e4066Sahrens */ 150fa9e4066Sahrens void 151fa9e4066Sahrens zfsctl_init(void) 152fa9e4066Sahrens { 153fa9e4066Sahrens VERIFY(gfs_make_opsvec(zfsctl_opsvec) == 0); 154fa9e4066Sahrens } 155fa9e4066Sahrens 156fa9e4066Sahrens void 157fa9e4066Sahrens zfsctl_fini(void) 158fa9e4066Sahrens { 159fa9e4066Sahrens /* 160fa9e4066Sahrens * Remove vfsctl vnode ops 161fa9e4066Sahrens */ 162fa9e4066Sahrens if (zfsctl_ops_root) 163fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_root); 164fa9e4066Sahrens if (zfsctl_ops_snapdir) 165fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_snapdir); 166fa9e4066Sahrens if (zfsctl_ops_snapshot) 167fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_snapshot); 168fa9e4066Sahrens 169fa9e4066Sahrens zfsctl_ops_root = NULL; 170fa9e4066Sahrens zfsctl_ops_snapdir = NULL; 171fa9e4066Sahrens zfsctl_ops_snapshot = NULL; 172fa9e4066Sahrens } 173fa9e4066Sahrens 174fa9e4066Sahrens /* 175fa9e4066Sahrens * Return the inode number associated with the 'snapshot' directory. 176fa9e4066Sahrens */ 177fa9e4066Sahrens /* ARGSUSED */ 178fa9e4066Sahrens static ino64_t 179fa9e4066Sahrens zfsctl_root_inode_cb(vnode_t *vp, int index) 180fa9e4066Sahrens { 181fa9e4066Sahrens ASSERT(index == 0); 182fa9e4066Sahrens return (ZFSCTL_INO_SNAPDIR); 183fa9e4066Sahrens } 184fa9e4066Sahrens 185fa9e4066Sahrens /* 186fa9e4066Sahrens * Create the '.zfs' directory. This directory is cached as part of the VFS 187fa9e4066Sahrens * structure. This results in a hold on the vfs_t. The code in zfs_umount() 188fa9e4066Sahrens * therefore checks against a vfs_count of 2 instead of 1. This reference 189fa9e4066Sahrens * is removed when the ctldir is destroyed in the unmount. 190fa9e4066Sahrens */ 191fa9e4066Sahrens void 192fa9e4066Sahrens zfsctl_create(zfsvfs_t *zfsvfs) 193fa9e4066Sahrens { 194a32fded1Sek vnode_t *vp, *rvp; 195fa9e4066Sahrens zfsctl_node_t *zcp; 196fa9e4066Sahrens 197fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir == NULL); 198fa9e4066Sahrens 199fa9e4066Sahrens vp = gfs_root_create(sizeof (zfsctl_node_t), zfsvfs->z_vfs, 200fa9e4066Sahrens zfsctl_ops_root, ZFSCTL_INO_ROOT, zfsctl_root_entries, 201fa9e4066Sahrens zfsctl_root_inode_cb, MAXNAMELEN, NULL, NULL); 202fa9e4066Sahrens zcp = vp->v_data; 203fa9e4066Sahrens zcp->zc_id = ZFSCTL_INO_ROOT; 204fa9e4066Sahrens 205a32fded1Sek VERIFY(VFS_ROOT(zfsvfs->z_vfs, &rvp) == 0); 206a32fded1Sek ZFS_TIME_DECODE(&zcp->zc_cmtime, VTOZ(rvp)->z_phys->zp_crtime); 207a32fded1Sek VN_RELE(rvp); 208a32fded1Sek 209fa9e4066Sahrens /* 210fa9e4066Sahrens * We're only faking the fact that we have a root of a filesystem for 211fa9e4066Sahrens * the sake of the GFS interfaces. Undo the flag manipulation it did 212fa9e4066Sahrens * for us. 213fa9e4066Sahrens */ 214fa9e4066Sahrens vp->v_flag &= ~(VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT); 215fa9e4066Sahrens 216fa9e4066Sahrens zfsvfs->z_ctldir = vp; 217fa9e4066Sahrens } 218fa9e4066Sahrens 219fa9e4066Sahrens /* 2208afd4dd6Sperrin * Destroy the '.zfs' directory. Only called when the filesystem is unmounted. 2218afd4dd6Sperrin * There might still be more references if we were force unmounted, but only 2228afd4dd6Sperrin * new zfs_inactive() calls can occur and they don't reference .zfs 223fa9e4066Sahrens */ 224fa9e4066Sahrens void 225fa9e4066Sahrens zfsctl_destroy(zfsvfs_t *zfsvfs) 226fa9e4066Sahrens { 227fa9e4066Sahrens VN_RELE(zfsvfs->z_ctldir); 228fa9e4066Sahrens zfsvfs->z_ctldir = NULL; 229fa9e4066Sahrens } 230fa9e4066Sahrens 231fa9e4066Sahrens /* 232fa9e4066Sahrens * Given a root znode, retrieve the associated .zfs directory. 233fa9e4066Sahrens * Add a hold to the vnode and return it. 234fa9e4066Sahrens */ 235fa9e4066Sahrens vnode_t * 236fa9e4066Sahrens zfsctl_root(znode_t *zp) 237fa9e4066Sahrens { 238fa9e4066Sahrens ASSERT(zfs_has_ctldir(zp)); 239fa9e4066Sahrens VN_HOLD(zp->z_zfsvfs->z_ctldir); 240fa9e4066Sahrens return (zp->z_zfsvfs->z_ctldir); 241fa9e4066Sahrens } 242fa9e4066Sahrens 243fa9e4066Sahrens /* 244fa9e4066Sahrens * Common open routine. Disallow any write access. 245fa9e4066Sahrens */ 246fa9e4066Sahrens /* ARGSUSED */ 247fa9e4066Sahrens static int 248da6c28aaSamw zfsctl_common_open(vnode_t **vpp, int flags, cred_t *cr, caller_context_t *ct) 249fa9e4066Sahrens { 250fa9e4066Sahrens if (flags & FWRITE) 251fa9e4066Sahrens return (EACCES); 252fa9e4066Sahrens 253fa9e4066Sahrens return (0); 254fa9e4066Sahrens } 255fa9e4066Sahrens 256fa9e4066Sahrens /* 257fa9e4066Sahrens * Common close routine. Nothing to do here. 258fa9e4066Sahrens */ 259fa9e4066Sahrens /* ARGSUSED */ 260fa9e4066Sahrens static int 261fa9e4066Sahrens zfsctl_common_close(vnode_t *vpp, int flags, int count, offset_t off, 262da6c28aaSamw cred_t *cr, caller_context_t *ct) 263fa9e4066Sahrens { 264fa9e4066Sahrens return (0); 265fa9e4066Sahrens } 266fa9e4066Sahrens 267fa9e4066Sahrens /* 268fa9e4066Sahrens * Common access routine. Disallow writes. 269fa9e4066Sahrens */ 270fa9e4066Sahrens /* ARGSUSED */ 271fa9e4066Sahrens static int 272da6c28aaSamw zfsctl_common_access(vnode_t *vp, int mode, int flags, cred_t *cr, 273da6c28aaSamw caller_context_t *ct) 274fa9e4066Sahrens { 275fa9e4066Sahrens if (mode & VWRITE) 276fa9e4066Sahrens return (EACCES); 277fa9e4066Sahrens 278fa9e4066Sahrens return (0); 279fa9e4066Sahrens } 280fa9e4066Sahrens 281fa9e4066Sahrens /* 282fa9e4066Sahrens * Common getattr function. Fill in basic information. 283fa9e4066Sahrens */ 284fa9e4066Sahrens static void 285fa9e4066Sahrens zfsctl_common_getattr(vnode_t *vp, vattr_t *vap) 286fa9e4066Sahrens { 287a32fded1Sek zfsctl_node_t *zcp = vp->v_data; 288a32fded1Sek timestruc_t now; 289fa9e4066Sahrens 290fa9e4066Sahrens vap->va_uid = 0; 291fa9e4066Sahrens vap->va_gid = 0; 292fa9e4066Sahrens vap->va_rdev = 0; 293fa9e4066Sahrens /* 294fa9e4066Sahrens * We are a purly virtual object, so we have no 295fa9e4066Sahrens * blocksize or allocated blocks. 296fa9e4066Sahrens */ 297fa9e4066Sahrens vap->va_blksize = 0; 298fa9e4066Sahrens vap->va_nblocks = 0; 299fa9e4066Sahrens vap->va_seq = 0; 300fa9e4066Sahrens vap->va_fsid = vp->v_vfsp->vfs_dev; 301fa9e4066Sahrens vap->va_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | 302fa9e4066Sahrens S_IROTH | S_IXOTH; 303fa9e4066Sahrens vap->va_type = VDIR; 304fa9e4066Sahrens /* 305a32fded1Sek * We live in the now (for atime). 306fa9e4066Sahrens */ 307fa9e4066Sahrens gethrestime(&now); 308a32fded1Sek vap->va_atime = now; 309a32fded1Sek vap->va_mtime = vap->va_ctime = zcp->zc_cmtime; 310fa9e4066Sahrens } 311fa9e4066Sahrens 312da6c28aaSamw /*ARGSUSED*/ 313fa9e4066Sahrens static int 314da6c28aaSamw zfsctl_common_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct) 315fa9e4066Sahrens { 316fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 317fa9e4066Sahrens zfsctl_node_t *zcp = vp->v_data; 318fa9e4066Sahrens uint64_t object = zcp->zc_id; 319fa9e4066Sahrens zfid_short_t *zfid; 320fa9e4066Sahrens int i; 321fa9e4066Sahrens 322fa9e4066Sahrens ZFS_ENTER(zfsvfs); 323fa9e4066Sahrens 324fa9e4066Sahrens if (fidp->fid_len < SHORT_FID_LEN) { 325fa9e4066Sahrens fidp->fid_len = SHORT_FID_LEN; 3260f2dc02eSek ZFS_EXIT(zfsvfs); 327fa9e4066Sahrens return (ENOSPC); 328fa9e4066Sahrens } 329fa9e4066Sahrens 330fa9e4066Sahrens zfid = (zfid_short_t *)fidp; 331fa9e4066Sahrens 332fa9e4066Sahrens zfid->zf_len = SHORT_FID_LEN; 333fa9e4066Sahrens 334fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_object); i++) 335fa9e4066Sahrens zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 336fa9e4066Sahrens 337fa9e4066Sahrens /* .zfs znodes always have a generation number of 0 */ 338fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_gen); i++) 339fa9e4066Sahrens zfid->zf_gen[i] = 0; 340fa9e4066Sahrens 341fa9e4066Sahrens ZFS_EXIT(zfsvfs); 342fa9e4066Sahrens return (0); 343fa9e4066Sahrens } 344fa9e4066Sahrens 345fa9e4066Sahrens /* 346fa9e4066Sahrens * .zfs inode namespace 347fa9e4066Sahrens * 348fa9e4066Sahrens * We need to generate unique inode numbers for all files and directories 349fa9e4066Sahrens * within the .zfs pseudo-filesystem. We use the following scheme: 350fa9e4066Sahrens * 351fa9e4066Sahrens * ENTRY ZFSCTL_INODE 352fa9e4066Sahrens * .zfs 1 353fa9e4066Sahrens * .zfs/snapshot 2 354fa9e4066Sahrens * .zfs/snapshot/<snap> objectid(snap) 355fa9e4066Sahrens */ 356fa9e4066Sahrens 357fa9e4066Sahrens #define ZFSCTL_INO_SNAP(id) (id) 358fa9e4066Sahrens 359fa9e4066Sahrens /* 360fa9e4066Sahrens * Get root directory attributes. 361fa9e4066Sahrens */ 362fa9e4066Sahrens /* ARGSUSED */ 363fa9e4066Sahrens static int 364da6c28aaSamw zfsctl_root_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 365da6c28aaSamw caller_context_t *ct) 366fa9e4066Sahrens { 367fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 368fa9e4066Sahrens 369fa9e4066Sahrens ZFS_ENTER(zfsvfs); 370fa9e4066Sahrens vap->va_nodeid = ZFSCTL_INO_ROOT; 371fa9e4066Sahrens vap->va_nlink = vap->va_size = NROOT_ENTRIES; 372fa9e4066Sahrens 373fa9e4066Sahrens zfsctl_common_getattr(vp, vap); 374fa9e4066Sahrens ZFS_EXIT(zfsvfs); 375fa9e4066Sahrens 376fa9e4066Sahrens return (0); 377fa9e4066Sahrens } 378fa9e4066Sahrens 379fa9e4066Sahrens /* 380fa9e4066Sahrens * Special case the handling of "..". 381fa9e4066Sahrens */ 382fa9e4066Sahrens /* ARGSUSED */ 383fa9e4066Sahrens int 384fa9e4066Sahrens zfsctl_root_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 385da6c28aaSamw int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, 386da6c28aaSamw int *direntflags, pathname_t *realpnp) 387fa9e4066Sahrens { 388fa9e4066Sahrens zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 389fa9e4066Sahrens int err; 390fa9e4066Sahrens 391da6c28aaSamw /* 392da6c28aaSamw * No extended attributes allowed under .zfs 393da6c28aaSamw */ 394da6c28aaSamw if (flags & LOOKUP_XATTR) 395da6c28aaSamw return (EINVAL); 396da6c28aaSamw 397fa9e4066Sahrens ZFS_ENTER(zfsvfs); 398fa9e4066Sahrens 399fa9e4066Sahrens if (strcmp(nm, "..") == 0) { 400fa9e4066Sahrens err = VFS_ROOT(dvp->v_vfsp, vpp); 401fa9e4066Sahrens } else { 402da6c28aaSamw err = gfs_dir_lookup(dvp, nm, vpp, cr); 403fa9e4066Sahrens } 404fa9e4066Sahrens 405fa9e4066Sahrens ZFS_EXIT(zfsvfs); 406fa9e4066Sahrens 407fa9e4066Sahrens return (err); 408fa9e4066Sahrens } 409fa9e4066Sahrens 410fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_root[] = { 411aa59c4cbSrsb { VOPNAME_OPEN, { .vop_open = zfsctl_common_open } }, 412aa59c4cbSrsb { VOPNAME_CLOSE, { .vop_close = zfsctl_common_close } }, 413aa59c4cbSrsb { VOPNAME_IOCTL, { .error = fs_inval } }, 414aa59c4cbSrsb { VOPNAME_GETATTR, { .vop_getattr = zfsctl_root_getattr } }, 415aa59c4cbSrsb { VOPNAME_ACCESS, { .vop_access = zfsctl_common_access } }, 416aa59c4cbSrsb { VOPNAME_READDIR, { .vop_readdir = gfs_vop_readdir } }, 417aa59c4cbSrsb { VOPNAME_LOOKUP, { .vop_lookup = zfsctl_root_lookup } }, 418aa59c4cbSrsb { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 419aa59c4cbSrsb { VOPNAME_INACTIVE, { .vop_inactive = gfs_vop_inactive } }, 420aa59c4cbSrsb { VOPNAME_FID, { .vop_fid = zfsctl_common_fid } }, 421fa9e4066Sahrens { NULL } 422fa9e4066Sahrens }; 423fa9e4066Sahrens 424fa9e4066Sahrens static int 425fa9e4066Sahrens zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname) 426fa9e4066Sahrens { 427fa9e4066Sahrens objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 428fa9e4066Sahrens 429fa9e4066Sahrens dmu_objset_name(os, zname); 4305422900bSmaybee if (strlen(zname) + 1 + strlen(name) >= len) 431fa9e4066Sahrens return (ENAMETOOLONG); 4325422900bSmaybee (void) strcat(zname, "@"); 433fa9e4066Sahrens (void) strcat(zname, name); 434fa9e4066Sahrens return (0); 435fa9e4066Sahrens } 436fa9e4066Sahrens 437*8bf40bf0Sck static int 438*8bf40bf0Sck zfsctl_unmount_snap(zfs_snapentry_t *sep, int fflags, cred_t *cr) 439fa9e4066Sahrens { 440*8bf40bf0Sck vnode_t *svp = sep->se_root; 441*8bf40bf0Sck int error; 442fa9e4066Sahrens 443*8bf40bf0Sck ASSERT(vn_ismntpt(svp)); 444fa9e4066Sahrens 445fa9e4066Sahrens /* this will be dropped by dounmount() */ 446*8bf40bf0Sck if ((error = vn_vfswlock(svp)) != 0) 447*8bf40bf0Sck return (error); 448fa9e4066Sahrens 449*8bf40bf0Sck VN_HOLD(svp); 450*8bf40bf0Sck error = dounmount(vn_mountedvfs(svp), fflags, cr); 451*8bf40bf0Sck if (error) { 452*8bf40bf0Sck VN_RELE(svp); 453*8bf40bf0Sck return (error); 454bbf4a8dfSmaybee } 455*8bf40bf0Sck VFS_RELE(svp->v_vfsp); 456*8bf40bf0Sck /* 457*8bf40bf0Sck * We can't use VN_RELE(), as that will try to invoke 458*8bf40bf0Sck * zfsctl_snapdir_inactive(), which would cause us to destroy 459*8bf40bf0Sck * the sd_lock mutex held by our caller. 460*8bf40bf0Sck */ 461*8bf40bf0Sck ASSERT(svp->v_count == 1); 462*8bf40bf0Sck gfs_vop_inactive(svp, cr, NULL); 463fa9e4066Sahrens 464fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 465fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 466fa9e4066Sahrens 467fa9e4066Sahrens return (0); 468fa9e4066Sahrens } 469fa9e4066Sahrens 4705422900bSmaybee static void 471fa9e4066Sahrens zfsctl_rename_snap(zfsctl_snapdir_t *sdp, zfs_snapentry_t *sep, const char *nm) 472fa9e4066Sahrens { 473fa9e4066Sahrens avl_index_t where; 474fa9e4066Sahrens vfs_t *vfsp; 475fa9e4066Sahrens refstr_t *pathref; 476fa9e4066Sahrens char newpath[MAXNAMELEN]; 477fa9e4066Sahrens char *tail; 478fa9e4066Sahrens 479fa9e4066Sahrens ASSERT(MUTEX_HELD(&sdp->sd_lock)); 480fa9e4066Sahrens ASSERT(sep != NULL); 481fa9e4066Sahrens 482fa9e4066Sahrens vfsp = vn_mountedvfs(sep->se_root); 483fa9e4066Sahrens ASSERT(vfsp != NULL); 484fa9e4066Sahrens 4855422900bSmaybee vfs_lock_wait(vfsp); 486fa9e4066Sahrens 487fa9e4066Sahrens /* 488fa9e4066Sahrens * Change the name in the AVL tree. 489fa9e4066Sahrens */ 490fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 491fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 492fa9e4066Sahrens sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP); 493fa9e4066Sahrens (void) strcpy(sep->se_name, nm); 494fa9e4066Sahrens VERIFY(avl_find(&sdp->sd_snaps, sep, &where) == NULL); 495fa9e4066Sahrens avl_insert(&sdp->sd_snaps, sep, where); 496fa9e4066Sahrens 497fa9e4066Sahrens /* 498fa9e4066Sahrens * Change the current mountpoint info: 499fa9e4066Sahrens * - update the tail of the mntpoint path 500fa9e4066Sahrens * - update the tail of the resource path 501fa9e4066Sahrens */ 502fa9e4066Sahrens pathref = vfs_getmntpoint(vfsp); 5030b69c2f0Sahrens (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath)); 5040b69c2f0Sahrens VERIFY((tail = strrchr(newpath, '/')) != NULL); 5050b69c2f0Sahrens *(tail+1) = '\0'; 5060b69c2f0Sahrens ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath)); 507fa9e4066Sahrens (void) strcat(newpath, nm); 508fa9e4066Sahrens refstr_rele(pathref); 509fa9e4066Sahrens vfs_setmntpoint(vfsp, newpath); 510fa9e4066Sahrens 511fa9e4066Sahrens pathref = vfs_getresource(vfsp); 5120b69c2f0Sahrens (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath)); 5130b69c2f0Sahrens VERIFY((tail = strrchr(newpath, '@')) != NULL); 5140b69c2f0Sahrens *(tail+1) = '\0'; 5150b69c2f0Sahrens ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath)); 516fa9e4066Sahrens (void) strcat(newpath, nm); 517fa9e4066Sahrens refstr_rele(pathref); 518fa9e4066Sahrens vfs_setresource(vfsp, newpath); 519fa9e4066Sahrens 520fa9e4066Sahrens vfs_unlock(vfsp); 521fa9e4066Sahrens } 522fa9e4066Sahrens 523da6c28aaSamw /*ARGSUSED*/ 524fa9e4066Sahrens static int 525fa9e4066Sahrens zfsctl_snapdir_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, 526da6c28aaSamw cred_t *cr, caller_context_t *ct, int flags) 527fa9e4066Sahrens { 528fa9e4066Sahrens zfsctl_snapdir_t *sdp = sdvp->v_data; 529fa9e4066Sahrens zfs_snapentry_t search, *sep; 530fa9e4066Sahrens avl_index_t where; 531fa9e4066Sahrens char from[MAXNAMELEN], to[MAXNAMELEN]; 532fa9e4066Sahrens int err; 533fa9e4066Sahrens 5345422900bSmaybee err = zfsctl_snapshot_zname(sdvp, snm, MAXNAMELEN, from); 5355422900bSmaybee if (err) 5365422900bSmaybee return (err); 537ecd6cf80Smarks 538ecd6cf80Smarks err = zfsctl_snapshot_zname(tdvp, tnm, MAXNAMELEN, to); 539fa9e4066Sahrens if (err) 540fa9e4066Sahrens return (err); 541fa9e4066Sahrens 542ecd6cf80Smarks if (err = zfs_secpolicy_rename_perms(from, to, cr)) 543ecd6cf80Smarks return (err); 544fa9e4066Sahrens /* 545fa9e4066Sahrens * Cannot move snapshots out of the snapdir. 546fa9e4066Sahrens */ 547fa9e4066Sahrens if (sdvp != tdvp) 548fa9e4066Sahrens return (EINVAL); 549fa9e4066Sahrens 550fa9e4066Sahrens if (strcmp(snm, tnm) == 0) 551fa9e4066Sahrens return (0); 552fa9e4066Sahrens 553fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 554fa9e4066Sahrens 555fa9e4066Sahrens search.se_name = (char *)snm; 5565422900bSmaybee if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) == NULL) { 5575422900bSmaybee mutex_exit(&sdp->sd_lock); 5585422900bSmaybee return (ENOENT); 559fa9e4066Sahrens } 560fa9e4066Sahrens 561cdf5b4caSmmusante err = dmu_objset_rename(from, to, B_FALSE); 5625422900bSmaybee if (err == 0) 5635422900bSmaybee zfsctl_rename_snap(sdp, sep, tnm); 564fa9e4066Sahrens 565fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 566fa9e4066Sahrens 567fa9e4066Sahrens return (err); 568fa9e4066Sahrens } 569fa9e4066Sahrens 570fa9e4066Sahrens /* ARGSUSED */ 571fa9e4066Sahrens static int 572da6c28aaSamw zfsctl_snapdir_remove(vnode_t *dvp, char *name, vnode_t *cwd, cred_t *cr, 573da6c28aaSamw caller_context_t *ct, int flags) 574fa9e4066Sahrens { 575fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 576*8bf40bf0Sck zfs_snapentry_t *sep; 577*8bf40bf0Sck zfs_snapentry_t search; 578fa9e4066Sahrens char snapname[MAXNAMELEN]; 579fa9e4066Sahrens int err; 580fa9e4066Sahrens 5815422900bSmaybee err = zfsctl_snapshot_zname(dvp, name, MAXNAMELEN, snapname); 5825422900bSmaybee if (err) 5835422900bSmaybee return (err); 584ecd6cf80Smarks 585ecd6cf80Smarks if (err = zfs_secpolicy_destroy_perms(snapname, cr)) 586fa9e4066Sahrens return (err); 587fa9e4066Sahrens 588fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 589fa9e4066Sahrens 590*8bf40bf0Sck search.se_name = name; 591*8bf40bf0Sck sep = avl_find(&sdp->sd_snaps, &search, NULL); 592*8bf40bf0Sck if (sep) { 593*8bf40bf0Sck avl_remove(&sdp->sd_snaps, sep); 594*8bf40bf0Sck err = zfsctl_unmount_snap(sep, MS_FORCE, cr); 595*8bf40bf0Sck if (err) 596*8bf40bf0Sck avl_add(&sdp->sd_snaps, sep); 597*8bf40bf0Sck else 598*8bf40bf0Sck err = dmu_objset_destroy(snapname); 599*8bf40bf0Sck } else { 600*8bf40bf0Sck err = ENOENT; 601fa9e4066Sahrens } 602fa9e4066Sahrens 603fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 604fa9e4066Sahrens 605fa9e4066Sahrens return (err); 606fa9e4066Sahrens } 607fa9e4066Sahrens 608f18faf3fSek /* 609f18faf3fSek * This creates a snapshot under '.zfs/snapshot'. 610f18faf3fSek */ 611ecd6cf80Smarks /* ARGSUSED */ 612ecd6cf80Smarks static int 613ecd6cf80Smarks zfsctl_snapdir_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t **vpp, 614da6c28aaSamw cred_t *cr, caller_context_t *cc, int flags, vsecattr_t *vsecp) 615ecd6cf80Smarks { 616ecd6cf80Smarks zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 617ecd6cf80Smarks char name[MAXNAMELEN]; 618ecd6cf80Smarks int err; 619ecd6cf80Smarks static enum symfollow follow = NO_FOLLOW; 620ecd6cf80Smarks static enum uio_seg seg = UIO_SYSSPACE; 621ecd6cf80Smarks 622ecd6cf80Smarks dmu_objset_name(zfsvfs->z_os, name); 623ecd6cf80Smarks 624ecd6cf80Smarks *vpp = NULL; 625ecd6cf80Smarks 626ecd6cf80Smarks err = zfs_secpolicy_snapshot_perms(name, cr); 627ecd6cf80Smarks if (err) 628ecd6cf80Smarks return (err); 629ecd6cf80Smarks 630ecd6cf80Smarks if (err == 0) { 631ecd6cf80Smarks err = dmu_objset_snapshot(name, dirname, B_FALSE); 632ecd6cf80Smarks if (err) 633ecd6cf80Smarks return (err); 634ecd6cf80Smarks err = lookupnameat(dirname, seg, follow, NULL, vpp, dvp); 635ecd6cf80Smarks } 636ecd6cf80Smarks 637ecd6cf80Smarks return (err); 638ecd6cf80Smarks } 639ecd6cf80Smarks 640fa9e4066Sahrens /* 641fa9e4066Sahrens * Lookup entry point for the 'snapshot' directory. Try to open the 642fa9e4066Sahrens * snapshot if it exist, creating the pseudo filesystem vnode as necessary. 643fa9e4066Sahrens * Perform a mount of the associated dataset on top of the vnode. 644fa9e4066Sahrens */ 645fa9e4066Sahrens /* ARGSUSED */ 646fa9e4066Sahrens static int 647fa9e4066Sahrens zfsctl_snapdir_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 648da6c28aaSamw int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, 649da6c28aaSamw int *direntflags, pathname_t *realpnp) 650fa9e4066Sahrens { 651fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 652fa9e4066Sahrens objset_t *snap; 653fa9e4066Sahrens char snapname[MAXNAMELEN]; 654fa9e4066Sahrens char *mountpoint; 655fa9e4066Sahrens zfs_snapentry_t *sep, search; 656fa9e4066Sahrens struct mounta margs; 657fa9e4066Sahrens vfs_t *vfsp; 658fa9e4066Sahrens size_t mountpoint_len; 659fa9e4066Sahrens avl_index_t where; 660fa9e4066Sahrens zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 661fa9e4066Sahrens int err; 662fa9e4066Sahrens 663da6c28aaSamw /* 664da6c28aaSamw * No extended attributes allowed under .zfs 665da6c28aaSamw */ 666da6c28aaSamw if (flags & LOOKUP_XATTR) 667da6c28aaSamw return (EINVAL); 668da6c28aaSamw 669fa9e4066Sahrens ASSERT(dvp->v_type == VDIR); 670fa9e4066Sahrens 671fa9e4066Sahrens if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) 672fa9e4066Sahrens return (0); 673fa9e4066Sahrens 674fa9e4066Sahrens /* 675fa9e4066Sahrens * If we get a recursive call, that means we got called 676fa9e4066Sahrens * from the domount() code while it was trying to look up the 677fa9e4066Sahrens * spec (which looks like a local path for zfs). We need to 678fa9e4066Sahrens * add some flag to domount() to tell it not to do this lookup. 679fa9e4066Sahrens */ 680fa9e4066Sahrens if (MUTEX_HELD(&sdp->sd_lock)) 681fa9e4066Sahrens return (ENOENT); 682fa9e4066Sahrens 683fa9e4066Sahrens ZFS_ENTER(zfsvfs); 684fa9e4066Sahrens 685fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 686fa9e4066Sahrens search.se_name = (char *)nm; 687fa9e4066Sahrens if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) != NULL) { 688fa9e4066Sahrens *vpp = sep->se_root; 689fa9e4066Sahrens VN_HOLD(*vpp); 690bbf4a8dfSmaybee err = traverse(vpp); 691bbf4a8dfSmaybee if (err) { 692bbf4a8dfSmaybee VN_RELE(*vpp); 693bbf4a8dfSmaybee *vpp = NULL; 694bbf4a8dfSmaybee } else if (*vpp == sep->se_root) { 695bbf4a8dfSmaybee /* 696bbf4a8dfSmaybee * The snapshot was unmounted behind our backs, 697bbf4a8dfSmaybee * try to remount it. 698bbf4a8dfSmaybee */ 699fa9e4066Sahrens goto domount; 700*8bf40bf0Sck } else { 701*8bf40bf0Sck /* 702*8bf40bf0Sck * VROOT was set during the traverse call. We need 703*8bf40bf0Sck * to clear it since we're pretending to be part 704*8bf40bf0Sck * of our parent's vfs. 705*8bf40bf0Sck */ 706*8bf40bf0Sck (*vpp)->v_flag &= ~VROOT; 707bb963f1cSmaybee } 708fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 709fa9e4066Sahrens ZFS_EXIT(zfsvfs); 710bbf4a8dfSmaybee return (err); 711fa9e4066Sahrens } 712fa9e4066Sahrens 713fa9e4066Sahrens /* 714fa9e4066Sahrens * The requested snapshot is not currently mounted, look it up. 715fa9e4066Sahrens */ 7165422900bSmaybee err = zfsctl_snapshot_zname(dvp, nm, MAXNAMELEN, snapname); 7175422900bSmaybee if (err) { 7185422900bSmaybee mutex_exit(&sdp->sd_lock); 7195422900bSmaybee ZFS_EXIT(zfsvfs); 7205422900bSmaybee return (err); 7215422900bSmaybee } 722fa9e4066Sahrens if (dmu_objset_open(snapname, DMU_OST_ZFS, 723fa9e4066Sahrens DS_MODE_STANDARD | DS_MODE_READONLY, &snap) != 0) { 724fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 725fa9e4066Sahrens ZFS_EXIT(zfsvfs); 726fa9e4066Sahrens return (ENOENT); 727fa9e4066Sahrens } 728fa9e4066Sahrens 729fa9e4066Sahrens sep = kmem_alloc(sizeof (zfs_snapentry_t), KM_SLEEP); 730fa9e4066Sahrens sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP); 731fa9e4066Sahrens (void) strcpy(sep->se_name, nm); 732fa9e4066Sahrens *vpp = sep->se_root = zfsctl_snapshot_mknode(dvp, dmu_objset_id(snap)); 733fa9e4066Sahrens avl_insert(&sdp->sd_snaps, sep, where); 734fa9e4066Sahrens 735fa9e4066Sahrens dmu_objset_close(snap); 736fa9e4066Sahrens domount: 737fa9e4066Sahrens mountpoint_len = strlen(refstr_value(dvp->v_vfsp->vfs_mntpt)) + 738fa9e4066Sahrens strlen("/.zfs/snapshot/") + strlen(nm) + 1; 739fa9e4066Sahrens mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP); 740fa9e4066Sahrens (void) snprintf(mountpoint, mountpoint_len, "%s/.zfs/snapshot/%s", 741fa9e4066Sahrens refstr_value(dvp->v_vfsp->vfs_mntpt), nm); 742fa9e4066Sahrens 743fa9e4066Sahrens margs.spec = snapname; 744fa9e4066Sahrens margs.dir = mountpoint; 745fa9e4066Sahrens margs.flags = MS_SYSSPACE | MS_NOMNTTAB; 746fa9e4066Sahrens margs.fstype = "zfs"; 747fa9e4066Sahrens margs.dataptr = NULL; 748fa9e4066Sahrens margs.datalen = 0; 749fa9e4066Sahrens margs.optptr = NULL; 750fa9e4066Sahrens margs.optlen = 0; 751fa9e4066Sahrens 752fa9e4066Sahrens err = domount("zfs", &margs, *vpp, kcred, &vfsp); 753fa9e4066Sahrens kmem_free(mountpoint, mountpoint_len); 754fa9e4066Sahrens 75595c9592aSmaybee if (err == 0) { 75695c9592aSmaybee /* 75795c9592aSmaybee * Return the mounted root rather than the covered mount point. 758f18faf3fSek * Takes the GFS vnode at .zfs/snapshot/<snapname> and returns 759f18faf3fSek * the ZFS vnode mounted on top of the GFS node. This ZFS 760f18faf3fSek * vnode is the root the newly created vfsp. 76195c9592aSmaybee */ 76295c9592aSmaybee VFS_RELE(vfsp); 76395c9592aSmaybee err = traverse(vpp); 76495c9592aSmaybee } 765fa9e4066Sahrens 76695c9592aSmaybee if (err == 0) { 76795c9592aSmaybee /* 768f18faf3fSek * Fix up the root vnode mounted on .zfs/snapshot/<snapname>. 769ed097989Sek * 770ed097989Sek * This is where we lie about our v_vfsp in order to 771f18faf3fSek * make .zfs/snapshot/<snapname> accessible over NFS 772f18faf3fSek * without requiring manual mounts of <snapname>. 77395c9592aSmaybee */ 77495c9592aSmaybee ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs); 77595c9592aSmaybee VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs; 77695c9592aSmaybee (*vpp)->v_vfsp = zfsvfs->z_vfs; 77795c9592aSmaybee (*vpp)->v_flag &= ~VROOT; 77895c9592aSmaybee } 779fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 780fa9e4066Sahrens ZFS_EXIT(zfsvfs); 781fa9e4066Sahrens 782bb963f1cSmaybee /* 783bb963f1cSmaybee * If we had an error, drop our hold on the vnode and 784bb963f1cSmaybee * zfsctl_snapshot_inactive() will clean up. 785bb963f1cSmaybee */ 786bb963f1cSmaybee if (err) { 78795c9592aSmaybee VN_RELE(*vpp); 788bb963f1cSmaybee *vpp = NULL; 789bb963f1cSmaybee } 79095c9592aSmaybee return (err); 791fa9e4066Sahrens } 792fa9e4066Sahrens 793fa9e4066Sahrens /* ARGSUSED */ 794fa9e4066Sahrens static int 795b38f0970Sck zfsctl_snapdir_readdir_cb(vnode_t *vp, void *dp, int *eofp, 796b38f0970Sck offset_t *offp, offset_t *nextp, void *data, int flags) 797fa9e4066Sahrens { 798fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 799fa9e4066Sahrens char snapname[MAXNAMELEN]; 800fa9e4066Sahrens uint64_t id, cookie; 801b38f0970Sck boolean_t case_conflict; 802b38f0970Sck int error; 803fa9e4066Sahrens 804fa9e4066Sahrens ZFS_ENTER(zfsvfs); 805fa9e4066Sahrens 806fa9e4066Sahrens cookie = *offp; 807b38f0970Sck error = dmu_snapshot_list_next(zfsvfs->z_os, MAXNAMELEN, snapname, &id, 808b38f0970Sck &cookie, &case_conflict); 809b38f0970Sck if (error) { 810fa9e4066Sahrens ZFS_EXIT(zfsvfs); 811b38f0970Sck if (error == ENOENT) { 812b38f0970Sck *eofp = 1; 813b38f0970Sck return (0); 814b38f0970Sck } 815b38f0970Sck return (error); 816fa9e4066Sahrens } 817fa9e4066Sahrens 818b38f0970Sck if (flags & V_RDDIR_ENTFLAGS) { 819b38f0970Sck edirent_t *eodp = dp; 820b38f0970Sck 821b38f0970Sck (void) strcpy(eodp->ed_name, snapname); 822b38f0970Sck eodp->ed_ino = ZFSCTL_INO_SNAP(id); 823b38f0970Sck eodp->ed_eflags = case_conflict ? ED_CASE_CONFLICT : 0; 824b38f0970Sck } else { 825b38f0970Sck struct dirent64 *odp = dp; 826b38f0970Sck 827b38f0970Sck (void) strcpy(odp->d_name, snapname); 828b38f0970Sck odp->d_ino = ZFSCTL_INO_SNAP(id); 829b38f0970Sck } 830fa9e4066Sahrens *nextp = cookie; 831fa9e4066Sahrens 832fa9e4066Sahrens ZFS_EXIT(zfsvfs); 833fa9e4066Sahrens 834fa9e4066Sahrens return (0); 835fa9e4066Sahrens } 836fa9e4066Sahrens 837f18faf3fSek /* 838f18faf3fSek * pvp is the '.zfs' directory (zfsctl_node_t). 839f18faf3fSek * Creates vp, which is '.zfs/snapshot' (zfsctl_snapdir_t). 840f18faf3fSek * 841f18faf3fSek * This function is the callback to create a GFS vnode for '.zfs/snapshot' 842f18faf3fSek * when a lookup is performed on .zfs for "snapshot". 843f18faf3fSek */ 844fa9e4066Sahrens vnode_t * 845fa9e4066Sahrens zfsctl_mknode_snapdir(vnode_t *pvp) 846fa9e4066Sahrens { 847fa9e4066Sahrens vnode_t *vp; 848fa9e4066Sahrens zfsctl_snapdir_t *sdp; 849fa9e4066Sahrens 850fa9e4066Sahrens vp = gfs_dir_create(sizeof (zfsctl_snapdir_t), pvp, 851fa9e4066Sahrens zfsctl_ops_snapdir, NULL, NULL, MAXNAMELEN, 852fa9e4066Sahrens zfsctl_snapdir_readdir_cb, NULL); 853fa9e4066Sahrens sdp = vp->v_data; 854fa9e4066Sahrens sdp->sd_node.zc_id = ZFSCTL_INO_SNAPDIR; 855a32fded1Sek sdp->sd_node.zc_cmtime = ((zfsctl_node_t *)pvp->v_data)->zc_cmtime; 856fa9e4066Sahrens mutex_init(&sdp->sd_lock, NULL, MUTEX_DEFAULT, NULL); 857fa9e4066Sahrens avl_create(&sdp->sd_snaps, snapentry_compare, 858fa9e4066Sahrens sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t, se_node)); 859fa9e4066Sahrens return (vp); 860fa9e4066Sahrens } 861fa9e4066Sahrens 862fa9e4066Sahrens /* ARGSUSED */ 863fa9e4066Sahrens static int 864da6c28aaSamw zfsctl_snapdir_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 865da6c28aaSamw caller_context_t *ct) 866fa9e4066Sahrens { 867fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 868fa9e4066Sahrens zfsctl_snapdir_t *sdp = vp->v_data; 869fa9e4066Sahrens 870fa9e4066Sahrens ZFS_ENTER(zfsvfs); 871fa9e4066Sahrens zfsctl_common_getattr(vp, vap); 872fa9e4066Sahrens vap->va_nodeid = gfs_file_inode(vp); 873fa9e4066Sahrens vap->va_nlink = vap->va_size = avl_numnodes(&sdp->sd_snaps) + 2; 874fa9e4066Sahrens ZFS_EXIT(zfsvfs); 875fa9e4066Sahrens 876fa9e4066Sahrens return (0); 877fa9e4066Sahrens } 878fa9e4066Sahrens 879bb963f1cSmaybee /* ARGSUSED */ 880fa9e4066Sahrens static void 881da6c28aaSamw zfsctl_snapdir_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct) 882fa9e4066Sahrens { 883fa9e4066Sahrens zfsctl_snapdir_t *sdp = vp->v_data; 884bb963f1cSmaybee void *private; 885bb963f1cSmaybee 886bb963f1cSmaybee private = gfs_dir_inactive(vp); 887bb963f1cSmaybee if (private != NULL) { 888bb963f1cSmaybee ASSERT(avl_numnodes(&sdp->sd_snaps) == 0); 889bb963f1cSmaybee mutex_destroy(&sdp->sd_lock); 890bb963f1cSmaybee avl_destroy(&sdp->sd_snaps); 891bb963f1cSmaybee kmem_free(private, sizeof (zfsctl_snapdir_t)); 892bb963f1cSmaybee } 893fa9e4066Sahrens } 894fa9e4066Sahrens 895fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapdir[] = { 896aa59c4cbSrsb { VOPNAME_OPEN, { .vop_open = zfsctl_common_open } }, 897aa59c4cbSrsb { VOPNAME_CLOSE, { .vop_close = zfsctl_common_close } }, 898aa59c4cbSrsb { VOPNAME_IOCTL, { .error = fs_inval } }, 899aa59c4cbSrsb { VOPNAME_GETATTR, { .vop_getattr = zfsctl_snapdir_getattr } }, 900aa59c4cbSrsb { VOPNAME_ACCESS, { .vop_access = zfsctl_common_access } }, 901aa59c4cbSrsb { VOPNAME_RENAME, { .vop_rename = zfsctl_snapdir_rename } }, 902aa59c4cbSrsb { VOPNAME_RMDIR, { .vop_rmdir = zfsctl_snapdir_remove } }, 903ecd6cf80Smarks { VOPNAME_MKDIR, { .vop_mkdir = zfsctl_snapdir_mkdir } }, 904aa59c4cbSrsb { VOPNAME_READDIR, { .vop_readdir = gfs_vop_readdir } }, 905aa59c4cbSrsb { VOPNAME_LOOKUP, { .vop_lookup = zfsctl_snapdir_lookup } }, 906aa59c4cbSrsb { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 907aa59c4cbSrsb { VOPNAME_INACTIVE, { .vop_inactive = zfsctl_snapdir_inactive } }, 908aa59c4cbSrsb { VOPNAME_FID, { .vop_fid = zfsctl_common_fid } }, 909fa9e4066Sahrens { NULL } 910fa9e4066Sahrens }; 911fa9e4066Sahrens 912f18faf3fSek /* 913f18faf3fSek * pvp is the GFS vnode '.zfs/snapshot'. 914f18faf3fSek * 915f18faf3fSek * This creates a GFS node under '.zfs/snapshot' representing each 916f18faf3fSek * snapshot. This newly created GFS node is what we mount snapshot 917f18faf3fSek * vfs_t's ontop of. 918f18faf3fSek */ 919fa9e4066Sahrens static vnode_t * 920fa9e4066Sahrens zfsctl_snapshot_mknode(vnode_t *pvp, uint64_t objset) 921fa9e4066Sahrens { 922fa9e4066Sahrens vnode_t *vp; 923fa9e4066Sahrens zfsctl_node_t *zcp; 924fa9e4066Sahrens 925fa9e4066Sahrens vp = gfs_dir_create(sizeof (zfsctl_node_t), pvp, 926fa9e4066Sahrens zfsctl_ops_snapshot, NULL, NULL, MAXNAMELEN, NULL, NULL); 927fa9e4066Sahrens zcp = vp->v_data; 928fa9e4066Sahrens zcp->zc_id = objset; 929*8bf40bf0Sck VFS_HOLD(vp->v_vfsp); 930fa9e4066Sahrens 931fa9e4066Sahrens return (vp); 932fa9e4066Sahrens } 933fa9e4066Sahrens 934fa9e4066Sahrens static void 935da6c28aaSamw zfsctl_snapshot_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct) 936fa9e4066Sahrens { 937fa9e4066Sahrens zfsctl_snapdir_t *sdp; 938fa9e4066Sahrens zfs_snapentry_t *sep, *next; 939fa9e4066Sahrens vnode_t *dvp; 940fa9e4066Sahrens 941da6c28aaSamw VERIFY(gfs_dir_lookup(vp, "..", &dvp, cr) == 0); 942fa9e4066Sahrens sdp = dvp->v_data; 943fa9e4066Sahrens 944fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 945fa9e4066Sahrens 946fa9e4066Sahrens if (vp->v_count > 1) { 947fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 948fa9e4066Sahrens return; 949fa9e4066Sahrens } 950fa9e4066Sahrens ASSERT(!vn_ismntpt(vp)); 951fa9e4066Sahrens 952fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 953fa9e4066Sahrens while (sep != NULL) { 954fa9e4066Sahrens next = AVL_NEXT(&sdp->sd_snaps, sep); 955fa9e4066Sahrens 956fa9e4066Sahrens if (sep->se_root == vp) { 957fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 958fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 959fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 960fa9e4066Sahrens break; 961fa9e4066Sahrens } 962fa9e4066Sahrens sep = next; 963fa9e4066Sahrens } 964fa9e4066Sahrens ASSERT(sep != NULL); 965fa9e4066Sahrens 966fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 967fa9e4066Sahrens VN_RELE(dvp); 968*8bf40bf0Sck VFS_RELE(vp->v_vfsp); 969fa9e4066Sahrens 970bb963f1cSmaybee /* 971bb963f1cSmaybee * Dispose of the vnode for the snapshot mount point. 972bb963f1cSmaybee * This is safe to do because once this entry has been removed 973bb963f1cSmaybee * from the AVL tree, it can't be found again, so cannot become 974bb963f1cSmaybee * "active". If we lookup the same name again we will end up 975bb963f1cSmaybee * creating a new vnode. 976bb963f1cSmaybee */ 977da6c28aaSamw gfs_vop_inactive(vp, cr, ct); 978fa9e4066Sahrens } 979fa9e4066Sahrens 980fa9e4066Sahrens 981fa9e4066Sahrens /* 982fa9e4066Sahrens * These VP's should never see the light of day. They should always 983fa9e4066Sahrens * be covered. 984fa9e4066Sahrens */ 985fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapshot[] = { 986aa59c4cbSrsb VOPNAME_INACTIVE, { .vop_inactive = zfsctl_snapshot_inactive }, 987fa9e4066Sahrens NULL, NULL 988fa9e4066Sahrens }; 989fa9e4066Sahrens 990fa9e4066Sahrens int 991fa9e4066Sahrens zfsctl_lookup_objset(vfs_t *vfsp, uint64_t objsetid, zfsvfs_t **zfsvfsp) 992fa9e4066Sahrens { 993fa9e4066Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 994fa9e4066Sahrens vnode_t *dvp, *vp; 995fa9e4066Sahrens zfsctl_snapdir_t *sdp; 996fa9e4066Sahrens zfsctl_node_t *zcp; 997fa9e4066Sahrens zfs_snapentry_t *sep; 998fa9e4066Sahrens int error; 999fa9e4066Sahrens 1000fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir != NULL); 1001fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp, 1002da6c28aaSamw NULL, 0, NULL, kcred, NULL, NULL, NULL); 1003fa9e4066Sahrens if (error != 0) 1004fa9e4066Sahrens return (error); 1005fa9e4066Sahrens sdp = dvp->v_data; 1006fa9e4066Sahrens 1007fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 1008fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 1009fa9e4066Sahrens while (sep != NULL) { 1010fa9e4066Sahrens vp = sep->se_root; 1011fa9e4066Sahrens zcp = vp->v_data; 1012fa9e4066Sahrens if (zcp->zc_id == objsetid) 1013fa9e4066Sahrens break; 1014fa9e4066Sahrens 1015fa9e4066Sahrens sep = AVL_NEXT(&sdp->sd_snaps, sep); 1016fa9e4066Sahrens } 1017fa9e4066Sahrens 1018fa9e4066Sahrens if (sep != NULL) { 1019fa9e4066Sahrens VN_HOLD(vp); 1020f18faf3fSek /* 1021f18faf3fSek * Return the mounted root rather than the covered mount point. 1022f18faf3fSek * Takes the GFS vnode at .zfs/snapshot/<snapshot objsetid> 1023f18faf3fSek * and returns the ZFS vnode mounted on top of the GFS node. 1024f18faf3fSek * This ZFS vnode is the root of the vfs for objset 'objsetid'. 1025f18faf3fSek */ 1026fa9e4066Sahrens error = traverse(&vp); 1027bbf4a8dfSmaybee if (error == 0) { 1028bbf4a8dfSmaybee if (vp == sep->se_root) 1029bbf4a8dfSmaybee error = EINVAL; 1030bbf4a8dfSmaybee else 1031bbf4a8dfSmaybee *zfsvfsp = VTOZ(vp)->z_zfsvfs; 1032bbf4a8dfSmaybee } 1033fea70b54Snd mutex_exit(&sdp->sd_lock); 1034fa9e4066Sahrens VN_RELE(vp); 1035fa9e4066Sahrens } else { 1036fa9e4066Sahrens error = EINVAL; 1037fea70b54Snd mutex_exit(&sdp->sd_lock); 1038fa9e4066Sahrens } 1039fa9e4066Sahrens 1040fa9e4066Sahrens VN_RELE(dvp); 1041fa9e4066Sahrens 1042fa9e4066Sahrens return (error); 1043fa9e4066Sahrens } 1044fa9e4066Sahrens 1045fa9e4066Sahrens /* 1046fa9e4066Sahrens * Unmount any snapshots for the given filesystem. This is called from 1047fa9e4066Sahrens * zfs_umount() - if we have a ctldir, then go through and unmount all the 1048fa9e4066Sahrens * snapshots. 1049fa9e4066Sahrens */ 1050fa9e4066Sahrens int 1051fa9e4066Sahrens zfsctl_umount_snapshots(vfs_t *vfsp, int fflags, cred_t *cr) 1052fa9e4066Sahrens { 1053fa9e4066Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 1054*8bf40bf0Sck vnode_t *dvp; 1055fa9e4066Sahrens zfsctl_snapdir_t *sdp; 1056fa9e4066Sahrens zfs_snapentry_t *sep, *next; 1057fa9e4066Sahrens int error; 1058fa9e4066Sahrens 1059fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir != NULL); 1060fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp, 1061da6c28aaSamw NULL, 0, NULL, cr, NULL, NULL, NULL); 1062fa9e4066Sahrens if (error != 0) 1063fa9e4066Sahrens return (error); 1064fa9e4066Sahrens sdp = dvp->v_data; 1065fa9e4066Sahrens 1066fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 1067fa9e4066Sahrens 1068fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 1069fa9e4066Sahrens while (sep != NULL) { 1070fa9e4066Sahrens next = AVL_NEXT(&sdp->sd_snaps, sep); 1071fa9e4066Sahrens 1072fa9e4066Sahrens /* 1073fa9e4066Sahrens * If this snapshot is not mounted, then it must 1074fa9e4066Sahrens * have just been unmounted by somebody else, and 1075fa9e4066Sahrens * will be cleaned up by zfsctl_snapdir_inactive(). 1076fa9e4066Sahrens */ 1077*8bf40bf0Sck if (vn_ismntpt(sep->se_root)) { 1078*8bf40bf0Sck avl_remove(&sdp->sd_snaps, sep); 1079*8bf40bf0Sck error = zfsctl_unmount_snap(sep, fflags, cr); 1080fa9e4066Sahrens if (error) { 1081*8bf40bf0Sck avl_add(&sdp->sd_snaps, sep); 1082*8bf40bf0Sck break; 1083fa9e4066Sahrens } 1084fa9e4066Sahrens } 1085fa9e4066Sahrens sep = next; 1086fa9e4066Sahrens } 1087*8bf40bf0Sck 1088fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 1089fa9e4066Sahrens VN_RELE(dvp); 1090fa9e4066Sahrens 1091fa9e4066Sahrens return (error); 1092fa9e4066Sahrens } 1093