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 /* 228afd4dd6Sperrin * Copyright 2006 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. 56fa9e4066Sahrens */ 57fa9e4066Sahrens 58fa9e4066Sahrens #include <fs/fs_subr.h> 59fa9e4066Sahrens #include <sys/zfs_ctldir.h> 60fa9e4066Sahrens #include <sys/zfs_ioctl.h> 61fa9e4066Sahrens #include <sys/zfs_vfsops.h> 62fa9e4066Sahrens #include <sys/gfs.h> 63fa9e4066Sahrens #include <sys/stat.h> 64fa9e4066Sahrens #include <sys/dmu.h> 65fa9e4066Sahrens #include <sys/mount.h> 66fa9e4066Sahrens 67fa9e4066Sahrens typedef struct { 68fa9e4066Sahrens char *se_name; 69fa9e4066Sahrens vnode_t *se_root; 70fa9e4066Sahrens avl_node_t se_node; 71fa9e4066Sahrens } zfs_snapentry_t; 72fa9e4066Sahrens 73fa9e4066Sahrens static int 74fa9e4066Sahrens snapentry_compare(const void *a, const void *b) 75fa9e4066Sahrens { 76fa9e4066Sahrens const zfs_snapentry_t *sa = a; 77fa9e4066Sahrens const zfs_snapentry_t *sb = b; 78fa9e4066Sahrens int ret = strcmp(sa->se_name, sb->se_name); 79fa9e4066Sahrens 80fa9e4066Sahrens if (ret < 0) 81fa9e4066Sahrens return (-1); 82fa9e4066Sahrens else if (ret > 0) 83fa9e4066Sahrens return (1); 84fa9e4066Sahrens else 85fa9e4066Sahrens return (0); 86fa9e4066Sahrens } 87fa9e4066Sahrens 88fa9e4066Sahrens vnodeops_t *zfsctl_ops_root; 89fa9e4066Sahrens vnodeops_t *zfsctl_ops_snapdir; 90fa9e4066Sahrens vnodeops_t *zfsctl_ops_snapshot; 91fa9e4066Sahrens 92fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_root[]; 93fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapdir[]; 94fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapshot[]; 95fa9e4066Sahrens 96fa9e4066Sahrens static vnode_t *zfsctl_mknode_snapdir(vnode_t *); 97fa9e4066Sahrens static vnode_t *zfsctl_snapshot_mknode(vnode_t *, uint64_t objset); 98fa9e4066Sahrens 99fa9e4066Sahrens static gfs_opsvec_t zfsctl_opsvec[] = { 100fa9e4066Sahrens { ".zfs", zfsctl_tops_root, &zfsctl_ops_root }, 101fa9e4066Sahrens { ".zfs/snapshot", zfsctl_tops_snapdir, &zfsctl_ops_snapdir }, 102fa9e4066Sahrens { ".zfs/snapshot/vnode", zfsctl_tops_snapshot, &zfsctl_ops_snapshot }, 103fa9e4066Sahrens { NULL } 104fa9e4066Sahrens }; 105fa9e4066Sahrens 106fa9e4066Sahrens typedef struct zfsctl_node { 107fa9e4066Sahrens gfs_dir_t zc_gfs_private; 108fa9e4066Sahrens uint64_t zc_id; 109a32fded1Sek timestruc_t zc_cmtime; /* ctime and mtime, always the same */ 110fa9e4066Sahrens } zfsctl_node_t; 111fa9e4066Sahrens 112fa9e4066Sahrens typedef struct zfsctl_snapdir { 113fa9e4066Sahrens zfsctl_node_t sd_node; 114fa9e4066Sahrens kmutex_t sd_lock; 115fa9e4066Sahrens avl_tree_t sd_snaps; 116fa9e4066Sahrens } zfsctl_snapdir_t; 117fa9e4066Sahrens 118fa9e4066Sahrens /* 119fa9e4066Sahrens * Root directory elements. We have only a single static entry, 'snapshot'. 120fa9e4066Sahrens */ 121fa9e4066Sahrens static gfs_dirent_t zfsctl_root_entries[] = { 122fa9e4066Sahrens { "snapshot", zfsctl_mknode_snapdir, GFS_CACHE_VNODE }, 123fa9e4066Sahrens { NULL } 124fa9e4066Sahrens }; 125fa9e4066Sahrens 126fa9e4066Sahrens /* include . and .. in the calculation */ 127fa9e4066Sahrens #define NROOT_ENTRIES ((sizeof (zfsctl_root_entries) / \ 128fa9e4066Sahrens sizeof (gfs_dirent_t)) + 1) 129fa9e4066Sahrens 130fa9e4066Sahrens 131fa9e4066Sahrens /* 132fa9e4066Sahrens * Initialize the various GFS pieces we'll need to create and manipulate .zfs 133fa9e4066Sahrens * directories. This is called from the ZFS init routine, and initializes the 134fa9e4066Sahrens * vnode ops vectors that we'll be using. 135fa9e4066Sahrens */ 136fa9e4066Sahrens void 137fa9e4066Sahrens zfsctl_init(void) 138fa9e4066Sahrens { 139fa9e4066Sahrens VERIFY(gfs_make_opsvec(zfsctl_opsvec) == 0); 140fa9e4066Sahrens } 141fa9e4066Sahrens 142fa9e4066Sahrens void 143fa9e4066Sahrens zfsctl_fini(void) 144fa9e4066Sahrens { 145fa9e4066Sahrens /* 146fa9e4066Sahrens * Remove vfsctl vnode ops 147fa9e4066Sahrens */ 148fa9e4066Sahrens if (zfsctl_ops_root) 149fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_root); 150fa9e4066Sahrens if (zfsctl_ops_snapdir) 151fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_snapdir); 152fa9e4066Sahrens if (zfsctl_ops_snapshot) 153fa9e4066Sahrens vn_freevnodeops(zfsctl_ops_snapshot); 154fa9e4066Sahrens 155fa9e4066Sahrens zfsctl_ops_root = NULL; 156fa9e4066Sahrens zfsctl_ops_snapdir = NULL; 157fa9e4066Sahrens zfsctl_ops_snapshot = NULL; 158fa9e4066Sahrens } 159fa9e4066Sahrens 160fa9e4066Sahrens /* 161fa9e4066Sahrens * Return the inode number associated with the 'snapshot' directory. 162fa9e4066Sahrens */ 163fa9e4066Sahrens /* ARGSUSED */ 164fa9e4066Sahrens static ino64_t 165fa9e4066Sahrens zfsctl_root_inode_cb(vnode_t *vp, int index) 166fa9e4066Sahrens { 167fa9e4066Sahrens ASSERT(index == 0); 168fa9e4066Sahrens return (ZFSCTL_INO_SNAPDIR); 169fa9e4066Sahrens } 170fa9e4066Sahrens 171fa9e4066Sahrens /* 172fa9e4066Sahrens * Create the '.zfs' directory. This directory is cached as part of the VFS 173fa9e4066Sahrens * structure. This results in a hold on the vfs_t. The code in zfs_umount() 174fa9e4066Sahrens * therefore checks against a vfs_count of 2 instead of 1. This reference 175fa9e4066Sahrens * is removed when the ctldir is destroyed in the unmount. 176fa9e4066Sahrens */ 177fa9e4066Sahrens void 178fa9e4066Sahrens zfsctl_create(zfsvfs_t *zfsvfs) 179fa9e4066Sahrens { 180a32fded1Sek vnode_t *vp, *rvp; 181fa9e4066Sahrens zfsctl_node_t *zcp; 182fa9e4066Sahrens 183fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir == NULL); 184fa9e4066Sahrens 185fa9e4066Sahrens vp = gfs_root_create(sizeof (zfsctl_node_t), zfsvfs->z_vfs, 186fa9e4066Sahrens zfsctl_ops_root, ZFSCTL_INO_ROOT, zfsctl_root_entries, 187fa9e4066Sahrens zfsctl_root_inode_cb, MAXNAMELEN, NULL, NULL); 188fa9e4066Sahrens zcp = vp->v_data; 189fa9e4066Sahrens zcp->zc_id = ZFSCTL_INO_ROOT; 190fa9e4066Sahrens 191a32fded1Sek VERIFY(VFS_ROOT(zfsvfs->z_vfs, &rvp) == 0); 192a32fded1Sek ZFS_TIME_DECODE(&zcp->zc_cmtime, VTOZ(rvp)->z_phys->zp_crtime); 193a32fded1Sek VN_RELE(rvp); 194a32fded1Sek 195fa9e4066Sahrens /* 196fa9e4066Sahrens * We're only faking the fact that we have a root of a filesystem for 197fa9e4066Sahrens * the sake of the GFS interfaces. Undo the flag manipulation it did 198fa9e4066Sahrens * for us. 199fa9e4066Sahrens */ 200fa9e4066Sahrens vp->v_flag &= ~(VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT); 201fa9e4066Sahrens 202fa9e4066Sahrens zfsvfs->z_ctldir = vp; 203fa9e4066Sahrens } 204fa9e4066Sahrens 205fa9e4066Sahrens /* 2068afd4dd6Sperrin * Destroy the '.zfs' directory. Only called when the filesystem is unmounted. 2078afd4dd6Sperrin * There might still be more references if we were force unmounted, but only 2088afd4dd6Sperrin * new zfs_inactive() calls can occur and they don't reference .zfs 209fa9e4066Sahrens */ 210fa9e4066Sahrens void 211fa9e4066Sahrens zfsctl_destroy(zfsvfs_t *zfsvfs) 212fa9e4066Sahrens { 213fa9e4066Sahrens VN_RELE(zfsvfs->z_ctldir); 214fa9e4066Sahrens zfsvfs->z_ctldir = NULL; 215fa9e4066Sahrens } 216fa9e4066Sahrens 217fa9e4066Sahrens /* 218fa9e4066Sahrens * Given a root znode, retrieve the associated .zfs directory. 219fa9e4066Sahrens * Add a hold to the vnode and return it. 220fa9e4066Sahrens */ 221fa9e4066Sahrens vnode_t * 222fa9e4066Sahrens zfsctl_root(znode_t *zp) 223fa9e4066Sahrens { 224fa9e4066Sahrens ASSERT(zfs_has_ctldir(zp)); 225fa9e4066Sahrens VN_HOLD(zp->z_zfsvfs->z_ctldir); 226fa9e4066Sahrens return (zp->z_zfsvfs->z_ctldir); 227fa9e4066Sahrens } 228fa9e4066Sahrens 229fa9e4066Sahrens /* 230fa9e4066Sahrens * Common open routine. Disallow any write access. 231fa9e4066Sahrens */ 232fa9e4066Sahrens /* ARGSUSED */ 233fa9e4066Sahrens static int 234fa9e4066Sahrens zfsctl_common_open(vnode_t **vpp, int flags, cred_t *cr) 235fa9e4066Sahrens { 236fa9e4066Sahrens if (flags & FWRITE) 237fa9e4066Sahrens return (EACCES); 238fa9e4066Sahrens 239fa9e4066Sahrens return (0); 240fa9e4066Sahrens } 241fa9e4066Sahrens 242fa9e4066Sahrens /* 243fa9e4066Sahrens * Common close routine. Nothing to do here. 244fa9e4066Sahrens */ 245fa9e4066Sahrens /* ARGSUSED */ 246fa9e4066Sahrens static int 247fa9e4066Sahrens zfsctl_common_close(vnode_t *vpp, int flags, int count, offset_t off, 248fa9e4066Sahrens cred_t *cr) 249fa9e4066Sahrens { 250fa9e4066Sahrens return (0); 251fa9e4066Sahrens } 252fa9e4066Sahrens 253fa9e4066Sahrens /* 254fa9e4066Sahrens * Common access routine. Disallow writes. 255fa9e4066Sahrens */ 256fa9e4066Sahrens /* ARGSUSED */ 257fa9e4066Sahrens static int 258fa9e4066Sahrens zfsctl_common_access(vnode_t *vp, int mode, int flags, cred_t *cr) 259fa9e4066Sahrens { 260fa9e4066Sahrens if (mode & VWRITE) 261fa9e4066Sahrens return (EACCES); 262fa9e4066Sahrens 263fa9e4066Sahrens return (0); 264fa9e4066Sahrens } 265fa9e4066Sahrens 266fa9e4066Sahrens /* 267fa9e4066Sahrens * Common getattr function. Fill in basic information. 268fa9e4066Sahrens */ 269fa9e4066Sahrens static void 270fa9e4066Sahrens zfsctl_common_getattr(vnode_t *vp, vattr_t *vap) 271fa9e4066Sahrens { 272a32fded1Sek zfsctl_node_t *zcp = vp->v_data; 273a32fded1Sek timestruc_t now; 274fa9e4066Sahrens 275fa9e4066Sahrens vap->va_uid = 0; 276fa9e4066Sahrens vap->va_gid = 0; 277fa9e4066Sahrens vap->va_rdev = 0; 278fa9e4066Sahrens /* 279fa9e4066Sahrens * We are a purly virtual object, so we have no 280fa9e4066Sahrens * blocksize or allocated blocks. 281fa9e4066Sahrens */ 282fa9e4066Sahrens vap->va_blksize = 0; 283fa9e4066Sahrens vap->va_nblocks = 0; 284fa9e4066Sahrens vap->va_seq = 0; 285fa9e4066Sahrens vap->va_fsid = vp->v_vfsp->vfs_dev; 286fa9e4066Sahrens vap->va_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | 287fa9e4066Sahrens S_IROTH | S_IXOTH; 288fa9e4066Sahrens vap->va_type = VDIR; 289fa9e4066Sahrens /* 290a32fded1Sek * We live in the now (for atime). 291fa9e4066Sahrens */ 292fa9e4066Sahrens gethrestime(&now); 293a32fded1Sek vap->va_atime = now; 294a32fded1Sek vap->va_mtime = vap->va_ctime = zcp->zc_cmtime; 295fa9e4066Sahrens } 296fa9e4066Sahrens 297fa9e4066Sahrens static int 298fa9e4066Sahrens zfsctl_common_fid(vnode_t *vp, fid_t *fidp) 299fa9e4066Sahrens { 300fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 301fa9e4066Sahrens zfsctl_node_t *zcp = vp->v_data; 302fa9e4066Sahrens uint64_t object = zcp->zc_id; 303fa9e4066Sahrens zfid_short_t *zfid; 304fa9e4066Sahrens int i; 305fa9e4066Sahrens 306fa9e4066Sahrens ZFS_ENTER(zfsvfs); 307fa9e4066Sahrens 308fa9e4066Sahrens if (fidp->fid_len < SHORT_FID_LEN) { 309fa9e4066Sahrens fidp->fid_len = SHORT_FID_LEN; 3100f2dc02eSek ZFS_EXIT(zfsvfs); 311fa9e4066Sahrens return (ENOSPC); 312fa9e4066Sahrens } 313fa9e4066Sahrens 314fa9e4066Sahrens zfid = (zfid_short_t *)fidp; 315fa9e4066Sahrens 316fa9e4066Sahrens zfid->zf_len = SHORT_FID_LEN; 317fa9e4066Sahrens 318fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_object); i++) 319fa9e4066Sahrens zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 320fa9e4066Sahrens 321fa9e4066Sahrens /* .zfs znodes always have a generation number of 0 */ 322fa9e4066Sahrens for (i = 0; i < sizeof (zfid->zf_gen); i++) 323fa9e4066Sahrens zfid->zf_gen[i] = 0; 324fa9e4066Sahrens 325fa9e4066Sahrens ZFS_EXIT(zfsvfs); 326fa9e4066Sahrens return (0); 327fa9e4066Sahrens } 328fa9e4066Sahrens 329fa9e4066Sahrens /* 330fa9e4066Sahrens * .zfs inode namespace 331fa9e4066Sahrens * 332fa9e4066Sahrens * We need to generate unique inode numbers for all files and directories 333fa9e4066Sahrens * within the .zfs pseudo-filesystem. We use the following scheme: 334fa9e4066Sahrens * 335fa9e4066Sahrens * ENTRY ZFSCTL_INODE 336fa9e4066Sahrens * .zfs 1 337fa9e4066Sahrens * .zfs/snapshot 2 338fa9e4066Sahrens * .zfs/snapshot/<snap> objectid(snap) 339fa9e4066Sahrens */ 340fa9e4066Sahrens 341fa9e4066Sahrens #define ZFSCTL_INO_SNAP(id) (id) 342fa9e4066Sahrens 343fa9e4066Sahrens /* 344fa9e4066Sahrens * Get root directory attributes. 345fa9e4066Sahrens */ 346fa9e4066Sahrens /* ARGSUSED */ 347fa9e4066Sahrens static int 348fa9e4066Sahrens zfsctl_root_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr) 349fa9e4066Sahrens { 350fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 351fa9e4066Sahrens 352fa9e4066Sahrens ZFS_ENTER(zfsvfs); 353fa9e4066Sahrens vap->va_nodeid = ZFSCTL_INO_ROOT; 354fa9e4066Sahrens vap->va_nlink = vap->va_size = NROOT_ENTRIES; 355fa9e4066Sahrens 356fa9e4066Sahrens zfsctl_common_getattr(vp, vap); 357fa9e4066Sahrens ZFS_EXIT(zfsvfs); 358fa9e4066Sahrens 359fa9e4066Sahrens return (0); 360fa9e4066Sahrens } 361fa9e4066Sahrens 362fa9e4066Sahrens /* 363fa9e4066Sahrens * Special case the handling of "..". 364fa9e4066Sahrens */ 365fa9e4066Sahrens /* ARGSUSED */ 366fa9e4066Sahrens int 367fa9e4066Sahrens zfsctl_root_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 368fa9e4066Sahrens int flags, vnode_t *rdir, cred_t *cr) 369fa9e4066Sahrens { 370fa9e4066Sahrens zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 371fa9e4066Sahrens int err; 372fa9e4066Sahrens 373fa9e4066Sahrens ZFS_ENTER(zfsvfs); 374fa9e4066Sahrens 375fa9e4066Sahrens if (strcmp(nm, "..") == 0) { 376fa9e4066Sahrens err = VFS_ROOT(dvp->v_vfsp, vpp); 377fa9e4066Sahrens } else { 378fa9e4066Sahrens err = gfs_dir_lookup(dvp, nm, vpp); 379fa9e4066Sahrens } 380fa9e4066Sahrens 381fa9e4066Sahrens ZFS_EXIT(zfsvfs); 382fa9e4066Sahrens 383fa9e4066Sahrens return (err); 384fa9e4066Sahrens } 385fa9e4066Sahrens 386fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_root[] = { 387fa9e4066Sahrens { VOPNAME_OPEN, zfsctl_common_open }, 388fa9e4066Sahrens { VOPNAME_CLOSE, zfsctl_common_close }, 389fa9e4066Sahrens { VOPNAME_IOCTL, fs_inval }, 390fa9e4066Sahrens { VOPNAME_GETATTR, zfsctl_root_getattr }, 391fa9e4066Sahrens { VOPNAME_ACCESS, zfsctl_common_access }, 392fa9e4066Sahrens { VOPNAME_READDIR, gfs_vop_readdir }, 393fa9e4066Sahrens { VOPNAME_LOOKUP, zfsctl_root_lookup }, 394fa9e4066Sahrens { VOPNAME_SEEK, fs_seek }, 395fa9e4066Sahrens { VOPNAME_INACTIVE, (fs_generic_func_p) gfs_vop_inactive }, 396fa9e4066Sahrens { VOPNAME_FID, zfsctl_common_fid }, 397fa9e4066Sahrens { NULL } 398fa9e4066Sahrens }; 399fa9e4066Sahrens 400fa9e4066Sahrens static int 401fa9e4066Sahrens zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname) 402fa9e4066Sahrens { 403fa9e4066Sahrens objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os; 404fa9e4066Sahrens 405fa9e4066Sahrens dmu_objset_name(os, zname); 4065422900bSmaybee if (strlen(zname) + 1 + strlen(name) >= len) 407fa9e4066Sahrens return (ENAMETOOLONG); 4085422900bSmaybee (void) strcat(zname, "@"); 409fa9e4066Sahrens (void) strcat(zname, name); 410fa9e4066Sahrens return (0); 411fa9e4066Sahrens } 412fa9e4066Sahrens 413fa9e4066Sahrens static int 414fa9e4066Sahrens zfsctl_unmount_snap(vnode_t *dvp, const char *name, int force, cred_t *cr) 415fa9e4066Sahrens { 416fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 417fa9e4066Sahrens zfs_snapentry_t search, *sep; 418fa9e4066Sahrens avl_index_t where; 419fa9e4066Sahrens int err; 420fa9e4066Sahrens 421fa9e4066Sahrens ASSERT(MUTEX_HELD(&sdp->sd_lock)); 422fa9e4066Sahrens 423fa9e4066Sahrens search.se_name = (char *)name; 424fa9e4066Sahrens if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) == NULL) 425fa9e4066Sahrens return (ENOENT); 426fa9e4066Sahrens 427fa9e4066Sahrens ASSERT(vn_ismntpt(sep->se_root)); 428fa9e4066Sahrens 429fa9e4066Sahrens /* this will be dropped by dounmount() */ 430fa9e4066Sahrens if ((err = vn_vfswlock(sep->se_root)) != 0) 431fa9e4066Sahrens return (err); 432fa9e4066Sahrens 433fa9e4066Sahrens VN_HOLD(sep->se_root); 434bbf4a8dfSmaybee err = dounmount(vn_mountedvfs(sep->se_root), force, kcred); 435bbf4a8dfSmaybee if (err) { 436bbf4a8dfSmaybee VN_RELE(sep->se_root); 437fa9e4066Sahrens return (err); 438bbf4a8dfSmaybee } 439fa9e4066Sahrens ASSERT(sep->se_root->v_count == 1); 440fa9e4066Sahrens gfs_vop_inactive(sep->se_root, cr); 441fa9e4066Sahrens 442fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 443fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 444fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 445fa9e4066Sahrens 446fa9e4066Sahrens return (0); 447fa9e4066Sahrens } 448fa9e4066Sahrens 449fa9e4066Sahrens 4505422900bSmaybee static void 451fa9e4066Sahrens zfsctl_rename_snap(zfsctl_snapdir_t *sdp, zfs_snapentry_t *sep, const char *nm) 452fa9e4066Sahrens { 453fa9e4066Sahrens avl_index_t where; 454fa9e4066Sahrens vfs_t *vfsp; 455fa9e4066Sahrens refstr_t *pathref; 456fa9e4066Sahrens char newpath[MAXNAMELEN]; 457fa9e4066Sahrens char *tail; 458fa9e4066Sahrens 459fa9e4066Sahrens ASSERT(MUTEX_HELD(&sdp->sd_lock)); 460fa9e4066Sahrens ASSERT(sep != NULL); 461fa9e4066Sahrens 462fa9e4066Sahrens vfsp = vn_mountedvfs(sep->se_root); 463fa9e4066Sahrens ASSERT(vfsp != NULL); 464fa9e4066Sahrens 4655422900bSmaybee vfs_lock_wait(vfsp); 466fa9e4066Sahrens 467fa9e4066Sahrens /* 468fa9e4066Sahrens * Change the name in the AVL tree. 469fa9e4066Sahrens */ 470fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 471fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 472fa9e4066Sahrens sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP); 473fa9e4066Sahrens (void) strcpy(sep->se_name, nm); 474fa9e4066Sahrens VERIFY(avl_find(&sdp->sd_snaps, sep, &where) == NULL); 475fa9e4066Sahrens avl_insert(&sdp->sd_snaps, sep, where); 476fa9e4066Sahrens 477fa9e4066Sahrens /* 478fa9e4066Sahrens * Change the current mountpoint info: 479fa9e4066Sahrens * - update the tail of the mntpoint path 480fa9e4066Sahrens * - update the tail of the resource path 481fa9e4066Sahrens */ 482fa9e4066Sahrens pathref = vfs_getmntpoint(vfsp); 483*0b69c2f0Sahrens (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath)); 484*0b69c2f0Sahrens VERIFY((tail = strrchr(newpath, '/')) != NULL); 485*0b69c2f0Sahrens *(tail+1) = '\0'; 486*0b69c2f0Sahrens ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath)); 487fa9e4066Sahrens (void) strcat(newpath, nm); 488fa9e4066Sahrens refstr_rele(pathref); 489fa9e4066Sahrens vfs_setmntpoint(vfsp, newpath); 490fa9e4066Sahrens 491fa9e4066Sahrens pathref = vfs_getresource(vfsp); 492*0b69c2f0Sahrens (void) strncpy(newpath, refstr_value(pathref), sizeof (newpath)); 493*0b69c2f0Sahrens VERIFY((tail = strrchr(newpath, '@')) != NULL); 494*0b69c2f0Sahrens *(tail+1) = '\0'; 495*0b69c2f0Sahrens ASSERT3U(strlen(newpath) + strlen(nm), <, sizeof (newpath)); 496fa9e4066Sahrens (void) strcat(newpath, nm); 497fa9e4066Sahrens refstr_rele(pathref); 498fa9e4066Sahrens vfs_setresource(vfsp, newpath); 499fa9e4066Sahrens 500fa9e4066Sahrens vfs_unlock(vfsp); 501fa9e4066Sahrens } 502fa9e4066Sahrens 503fa9e4066Sahrens static int 504fa9e4066Sahrens zfsctl_snapdir_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, 505fa9e4066Sahrens cred_t *cr) 506fa9e4066Sahrens { 507fa9e4066Sahrens zfsctl_snapdir_t *sdp = sdvp->v_data; 508fa9e4066Sahrens zfs_snapentry_t search, *sep; 509fa9e4066Sahrens avl_index_t where; 510fa9e4066Sahrens char from[MAXNAMELEN], to[MAXNAMELEN]; 511fa9e4066Sahrens int err; 512fa9e4066Sahrens 5135422900bSmaybee err = zfsctl_snapshot_zname(sdvp, snm, MAXNAMELEN, from); 5145422900bSmaybee if (err) 5155422900bSmaybee return (err); 516fa9e4066Sahrens err = zfs_secpolicy_write(from, NULL, cr); 517fa9e4066Sahrens if (err) 518fa9e4066Sahrens return (err); 519fa9e4066Sahrens 520fa9e4066Sahrens /* 521fa9e4066Sahrens * Cannot move snapshots out of the snapdir. 522fa9e4066Sahrens */ 523fa9e4066Sahrens if (sdvp != tdvp) 524fa9e4066Sahrens return (EINVAL); 525fa9e4066Sahrens 526fa9e4066Sahrens if (strcmp(snm, tnm) == 0) 527fa9e4066Sahrens return (0); 528fa9e4066Sahrens 5295422900bSmaybee err = zfsctl_snapshot_zname(tdvp, tnm, MAXNAMELEN, to); 5305422900bSmaybee if (err) 5315422900bSmaybee return (err); 5325422900bSmaybee 533fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 534fa9e4066Sahrens 535fa9e4066Sahrens search.se_name = (char *)snm; 5365422900bSmaybee if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) == NULL) { 5375422900bSmaybee mutex_exit(&sdp->sd_lock); 5385422900bSmaybee return (ENOENT); 539fa9e4066Sahrens } 540fa9e4066Sahrens 541fa9e4066Sahrens err = dmu_objset_rename(from, to); 5425422900bSmaybee if (err == 0) 5435422900bSmaybee zfsctl_rename_snap(sdp, sep, tnm); 544fa9e4066Sahrens 545fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 546fa9e4066Sahrens 547fa9e4066Sahrens return (err); 548fa9e4066Sahrens } 549fa9e4066Sahrens 550fa9e4066Sahrens /* ARGSUSED */ 551fa9e4066Sahrens static int 552fa9e4066Sahrens zfsctl_snapdir_remove(vnode_t *dvp, char *name, vnode_t *cwd, cred_t *cr) 553fa9e4066Sahrens { 554fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 555fa9e4066Sahrens char snapname[MAXNAMELEN]; 556fa9e4066Sahrens int err; 557fa9e4066Sahrens 5585422900bSmaybee err = zfsctl_snapshot_zname(dvp, name, MAXNAMELEN, snapname); 5595422900bSmaybee if (err) 5605422900bSmaybee return (err); 561fa9e4066Sahrens err = zfs_secpolicy_write(snapname, NULL, cr); 562fa9e4066Sahrens if (err) 563fa9e4066Sahrens return (err); 564fa9e4066Sahrens 565fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 566fa9e4066Sahrens 567fa9e4066Sahrens err = zfsctl_unmount_snap(dvp, name, 0, cr); 568fa9e4066Sahrens if (err) { 569fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 570fa9e4066Sahrens return (err); 571fa9e4066Sahrens } 572fa9e4066Sahrens 573fa9e4066Sahrens err = dmu_objset_destroy(snapname); 574fa9e4066Sahrens 575fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 576fa9e4066Sahrens 577fa9e4066Sahrens return (err); 578fa9e4066Sahrens } 579fa9e4066Sahrens 580fa9e4066Sahrens /* 581fa9e4066Sahrens * Lookup entry point for the 'snapshot' directory. Try to open the 582fa9e4066Sahrens * snapshot if it exist, creating the pseudo filesystem vnode as necessary. 583fa9e4066Sahrens * Perform a mount of the associated dataset on top of the vnode. 584fa9e4066Sahrens */ 585fa9e4066Sahrens /* ARGSUSED */ 586fa9e4066Sahrens static int 587fa9e4066Sahrens zfsctl_snapdir_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 588fa9e4066Sahrens int flags, vnode_t *rdir, cred_t *cr) 589fa9e4066Sahrens { 590fa9e4066Sahrens zfsctl_snapdir_t *sdp = dvp->v_data; 591fa9e4066Sahrens objset_t *snap; 592fa9e4066Sahrens char snapname[MAXNAMELEN]; 593fa9e4066Sahrens char *mountpoint; 594fa9e4066Sahrens zfs_snapentry_t *sep, search; 595fa9e4066Sahrens struct mounta margs; 596fa9e4066Sahrens vfs_t *vfsp; 597fa9e4066Sahrens size_t mountpoint_len; 598fa9e4066Sahrens avl_index_t where; 599fa9e4066Sahrens zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data; 600fa9e4066Sahrens int err; 601fa9e4066Sahrens 602fa9e4066Sahrens ASSERT(dvp->v_type == VDIR); 603fa9e4066Sahrens 604fa9e4066Sahrens if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) 605fa9e4066Sahrens return (0); 606fa9e4066Sahrens 607fa9e4066Sahrens /* 608fa9e4066Sahrens * If we get a recursive call, that means we got called 609fa9e4066Sahrens * from the domount() code while it was trying to look up the 610fa9e4066Sahrens * spec (which looks like a local path for zfs). We need to 611fa9e4066Sahrens * add some flag to domount() to tell it not to do this lookup. 612fa9e4066Sahrens */ 613fa9e4066Sahrens if (MUTEX_HELD(&sdp->sd_lock)) 614fa9e4066Sahrens return (ENOENT); 615fa9e4066Sahrens 616fa9e4066Sahrens ZFS_ENTER(zfsvfs); 617fa9e4066Sahrens 618fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 619fa9e4066Sahrens search.se_name = (char *)nm; 620fa9e4066Sahrens if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) != NULL) { 621fa9e4066Sahrens *vpp = sep->se_root; 622fa9e4066Sahrens VN_HOLD(*vpp); 623bbf4a8dfSmaybee err = traverse(vpp); 624bbf4a8dfSmaybee if (err) { 625bbf4a8dfSmaybee VN_RELE(*vpp); 626bbf4a8dfSmaybee *vpp = NULL; 627bbf4a8dfSmaybee } else if (*vpp == sep->se_root) { 628bbf4a8dfSmaybee /* 629bbf4a8dfSmaybee * The snapshot was unmounted behind our backs, 630bbf4a8dfSmaybee * try to remount it. 631bbf4a8dfSmaybee */ 632fa9e4066Sahrens goto domount; 633bb963f1cSmaybee } 634fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 635fa9e4066Sahrens ZFS_EXIT(zfsvfs); 636bbf4a8dfSmaybee return (err); 637fa9e4066Sahrens } 638fa9e4066Sahrens 639fa9e4066Sahrens /* 640fa9e4066Sahrens * The requested snapshot is not currently mounted, look it up. 641fa9e4066Sahrens */ 6425422900bSmaybee err = zfsctl_snapshot_zname(dvp, nm, MAXNAMELEN, snapname); 6435422900bSmaybee if (err) { 6445422900bSmaybee mutex_exit(&sdp->sd_lock); 6455422900bSmaybee ZFS_EXIT(zfsvfs); 6465422900bSmaybee return (err); 6475422900bSmaybee } 648fa9e4066Sahrens if (dmu_objset_open(snapname, DMU_OST_ZFS, 649fa9e4066Sahrens DS_MODE_STANDARD | DS_MODE_READONLY, &snap) != 0) { 650fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 651fa9e4066Sahrens ZFS_EXIT(zfsvfs); 652fa9e4066Sahrens return (ENOENT); 653fa9e4066Sahrens } 654fa9e4066Sahrens 655fa9e4066Sahrens sep = kmem_alloc(sizeof (zfs_snapentry_t), KM_SLEEP); 656fa9e4066Sahrens sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP); 657fa9e4066Sahrens (void) strcpy(sep->se_name, nm); 658fa9e4066Sahrens *vpp = sep->se_root = zfsctl_snapshot_mknode(dvp, dmu_objset_id(snap)); 659fa9e4066Sahrens avl_insert(&sdp->sd_snaps, sep, where); 660fa9e4066Sahrens 661fa9e4066Sahrens dmu_objset_close(snap); 662fa9e4066Sahrens domount: 663fa9e4066Sahrens mountpoint_len = strlen(refstr_value(dvp->v_vfsp->vfs_mntpt)) + 664fa9e4066Sahrens strlen("/.zfs/snapshot/") + strlen(nm) + 1; 665fa9e4066Sahrens mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP); 666fa9e4066Sahrens (void) snprintf(mountpoint, mountpoint_len, "%s/.zfs/snapshot/%s", 667fa9e4066Sahrens refstr_value(dvp->v_vfsp->vfs_mntpt), nm); 668fa9e4066Sahrens 669fa9e4066Sahrens margs.spec = snapname; 670fa9e4066Sahrens margs.dir = mountpoint; 671fa9e4066Sahrens margs.flags = MS_SYSSPACE | MS_NOMNTTAB; 672fa9e4066Sahrens margs.fstype = "zfs"; 673fa9e4066Sahrens margs.dataptr = NULL; 674fa9e4066Sahrens margs.datalen = 0; 675fa9e4066Sahrens margs.optptr = NULL; 676fa9e4066Sahrens margs.optlen = 0; 677fa9e4066Sahrens 678fa9e4066Sahrens err = domount("zfs", &margs, *vpp, kcred, &vfsp); 679fa9e4066Sahrens kmem_free(mountpoint, mountpoint_len); 680fa9e4066Sahrens 68195c9592aSmaybee if (err == 0) { 68295c9592aSmaybee /* 68395c9592aSmaybee * Return the mounted root rather than the covered mount point. 68495c9592aSmaybee */ 68595c9592aSmaybee VFS_RELE(vfsp); 68695c9592aSmaybee err = traverse(vpp); 68795c9592aSmaybee } 688fa9e4066Sahrens 68995c9592aSmaybee if (err == 0) { 69095c9592aSmaybee /* 69195c9592aSmaybee * Fix up the root vnode. 69295c9592aSmaybee */ 69395c9592aSmaybee ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs); 69495c9592aSmaybee VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs; 69595c9592aSmaybee (*vpp)->v_vfsp = zfsvfs->z_vfs; 69695c9592aSmaybee (*vpp)->v_flag &= ~VROOT; 69795c9592aSmaybee } 698fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 699fa9e4066Sahrens ZFS_EXIT(zfsvfs); 700fa9e4066Sahrens 701bb963f1cSmaybee /* 702bb963f1cSmaybee * If we had an error, drop our hold on the vnode and 703bb963f1cSmaybee * zfsctl_snapshot_inactive() will clean up. 704bb963f1cSmaybee */ 705bb963f1cSmaybee if (err) { 70695c9592aSmaybee VN_RELE(*vpp); 707bb963f1cSmaybee *vpp = NULL; 708bb963f1cSmaybee } 70995c9592aSmaybee return (err); 710fa9e4066Sahrens } 711fa9e4066Sahrens 712fa9e4066Sahrens /* ARGSUSED */ 713fa9e4066Sahrens static int 714fa9e4066Sahrens zfsctl_snapdir_readdir_cb(vnode_t *vp, struct dirent64 *dp, int *eofp, 715fa9e4066Sahrens offset_t *offp, offset_t *nextp, void *data) 716fa9e4066Sahrens { 717fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 718fa9e4066Sahrens char snapname[MAXNAMELEN]; 719fa9e4066Sahrens uint64_t id, cookie; 720fa9e4066Sahrens 721fa9e4066Sahrens ZFS_ENTER(zfsvfs); 722fa9e4066Sahrens 723fa9e4066Sahrens cookie = *offp; 724fa9e4066Sahrens if (dmu_snapshot_list_next(zfsvfs->z_os, MAXNAMELEN, snapname, &id, 725fa9e4066Sahrens &cookie) == ENOENT) { 726fa9e4066Sahrens *eofp = 1; 727fa9e4066Sahrens ZFS_EXIT(zfsvfs); 728fa9e4066Sahrens return (0); 729fa9e4066Sahrens } 730fa9e4066Sahrens 731fa9e4066Sahrens (void) strcpy(dp->d_name, snapname); 732fa9e4066Sahrens dp->d_ino = ZFSCTL_INO_SNAP(id); 733fa9e4066Sahrens *nextp = cookie; 734fa9e4066Sahrens 735fa9e4066Sahrens ZFS_EXIT(zfsvfs); 736fa9e4066Sahrens 737fa9e4066Sahrens return (0); 738fa9e4066Sahrens } 739fa9e4066Sahrens 740fa9e4066Sahrens vnode_t * 741fa9e4066Sahrens zfsctl_mknode_snapdir(vnode_t *pvp) 742fa9e4066Sahrens { 743fa9e4066Sahrens vnode_t *vp; 744fa9e4066Sahrens zfsctl_snapdir_t *sdp; 745fa9e4066Sahrens 746fa9e4066Sahrens vp = gfs_dir_create(sizeof (zfsctl_snapdir_t), pvp, 747fa9e4066Sahrens zfsctl_ops_snapdir, NULL, NULL, MAXNAMELEN, 748fa9e4066Sahrens zfsctl_snapdir_readdir_cb, NULL); 749fa9e4066Sahrens sdp = vp->v_data; 750fa9e4066Sahrens sdp->sd_node.zc_id = ZFSCTL_INO_SNAPDIR; 751a32fded1Sek sdp->sd_node.zc_cmtime = ((zfsctl_node_t *)pvp->v_data)->zc_cmtime; 752fa9e4066Sahrens mutex_init(&sdp->sd_lock, NULL, MUTEX_DEFAULT, NULL); 753fa9e4066Sahrens avl_create(&sdp->sd_snaps, snapentry_compare, 754fa9e4066Sahrens sizeof (zfs_snapentry_t), offsetof(zfs_snapentry_t, se_node)); 755fa9e4066Sahrens return (vp); 756fa9e4066Sahrens } 757fa9e4066Sahrens 758fa9e4066Sahrens /* ARGSUSED */ 759fa9e4066Sahrens static int 760fa9e4066Sahrens zfsctl_snapdir_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr) 761fa9e4066Sahrens { 762fa9e4066Sahrens zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data; 763fa9e4066Sahrens zfsctl_snapdir_t *sdp = vp->v_data; 764fa9e4066Sahrens 765fa9e4066Sahrens ZFS_ENTER(zfsvfs); 766fa9e4066Sahrens zfsctl_common_getattr(vp, vap); 767fa9e4066Sahrens vap->va_nodeid = gfs_file_inode(vp); 768fa9e4066Sahrens vap->va_nlink = vap->va_size = avl_numnodes(&sdp->sd_snaps) + 2; 769fa9e4066Sahrens ZFS_EXIT(zfsvfs); 770fa9e4066Sahrens 771fa9e4066Sahrens return (0); 772fa9e4066Sahrens } 773fa9e4066Sahrens 774bb963f1cSmaybee /* ARGSUSED */ 775fa9e4066Sahrens static void 776fa9e4066Sahrens zfsctl_snapdir_inactive(vnode_t *vp, cred_t *cr) 777fa9e4066Sahrens { 778fa9e4066Sahrens zfsctl_snapdir_t *sdp = vp->v_data; 779bb963f1cSmaybee void *private; 780bb963f1cSmaybee 781bb963f1cSmaybee private = gfs_dir_inactive(vp); 782bb963f1cSmaybee if (private != NULL) { 783bb963f1cSmaybee ASSERT(avl_numnodes(&sdp->sd_snaps) == 0); 784bb963f1cSmaybee mutex_destroy(&sdp->sd_lock); 785bb963f1cSmaybee avl_destroy(&sdp->sd_snaps); 786bb963f1cSmaybee kmem_free(private, sizeof (zfsctl_snapdir_t)); 787bb963f1cSmaybee } 788fa9e4066Sahrens } 789fa9e4066Sahrens 790fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapdir[] = { 791fa9e4066Sahrens { VOPNAME_OPEN, zfsctl_common_open }, 792fa9e4066Sahrens { VOPNAME_CLOSE, zfsctl_common_close }, 793fa9e4066Sahrens { VOPNAME_IOCTL, fs_inval }, 794fa9e4066Sahrens { VOPNAME_GETATTR, zfsctl_snapdir_getattr }, 795fa9e4066Sahrens { VOPNAME_ACCESS, zfsctl_common_access }, 796fa9e4066Sahrens { VOPNAME_RENAME, zfsctl_snapdir_rename }, 797fa9e4066Sahrens { VOPNAME_RMDIR, zfsctl_snapdir_remove }, 798fa9e4066Sahrens { VOPNAME_READDIR, gfs_vop_readdir }, 799fa9e4066Sahrens { VOPNAME_LOOKUP, zfsctl_snapdir_lookup }, 800fa9e4066Sahrens { VOPNAME_SEEK, fs_seek }, 801fa9e4066Sahrens { VOPNAME_INACTIVE, (fs_generic_func_p) zfsctl_snapdir_inactive }, 802fa9e4066Sahrens { VOPNAME_FID, zfsctl_common_fid }, 803fa9e4066Sahrens { NULL } 804fa9e4066Sahrens }; 805fa9e4066Sahrens 806fa9e4066Sahrens static vnode_t * 807fa9e4066Sahrens zfsctl_snapshot_mknode(vnode_t *pvp, uint64_t objset) 808fa9e4066Sahrens { 809fa9e4066Sahrens vnode_t *vp; 810fa9e4066Sahrens zfsctl_node_t *zcp; 811fa9e4066Sahrens 812fa9e4066Sahrens vp = gfs_dir_create(sizeof (zfsctl_node_t), pvp, 813fa9e4066Sahrens zfsctl_ops_snapshot, NULL, NULL, MAXNAMELEN, NULL, NULL); 814fa9e4066Sahrens zcp = vp->v_data; 815fa9e4066Sahrens zcp->zc_id = objset; 816fa9e4066Sahrens 817fa9e4066Sahrens return (vp); 818fa9e4066Sahrens } 819fa9e4066Sahrens 820fa9e4066Sahrens static void 821fa9e4066Sahrens zfsctl_snapshot_inactive(vnode_t *vp, cred_t *cr) 822fa9e4066Sahrens { 823fa9e4066Sahrens zfsctl_snapdir_t *sdp; 824fa9e4066Sahrens zfs_snapentry_t *sep, *next; 825fa9e4066Sahrens vnode_t *dvp; 826fa9e4066Sahrens 827fa9e4066Sahrens VERIFY(gfs_dir_lookup(vp, "..", &dvp) == 0); 828fa9e4066Sahrens sdp = dvp->v_data; 829fa9e4066Sahrens 830fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 831fa9e4066Sahrens 832fa9e4066Sahrens if (vp->v_count > 1) { 833fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 834fa9e4066Sahrens return; 835fa9e4066Sahrens } 836fa9e4066Sahrens ASSERT(!vn_ismntpt(vp)); 837fa9e4066Sahrens 838fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 839fa9e4066Sahrens while (sep != NULL) { 840fa9e4066Sahrens next = AVL_NEXT(&sdp->sd_snaps, sep); 841fa9e4066Sahrens 842fa9e4066Sahrens if (sep->se_root == vp) { 843fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 844fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 845fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 846fa9e4066Sahrens break; 847fa9e4066Sahrens } 848fa9e4066Sahrens sep = next; 849fa9e4066Sahrens } 850fa9e4066Sahrens ASSERT(sep != NULL); 851fa9e4066Sahrens 852fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 853fa9e4066Sahrens VN_RELE(dvp); 854fa9e4066Sahrens 855bb963f1cSmaybee /* 856bb963f1cSmaybee * Dispose of the vnode for the snapshot mount point. 857bb963f1cSmaybee * This is safe to do because once this entry has been removed 858bb963f1cSmaybee * from the AVL tree, it can't be found again, so cannot become 859bb963f1cSmaybee * "active". If we lookup the same name again we will end up 860bb963f1cSmaybee * creating a new vnode. 861bb963f1cSmaybee */ 862fa9e4066Sahrens gfs_vop_inactive(vp, cr); 863fa9e4066Sahrens } 864fa9e4066Sahrens 865fa9e4066Sahrens 866fa9e4066Sahrens /* 867fa9e4066Sahrens * These VP's should never see the light of day. They should always 868fa9e4066Sahrens * be covered. 869fa9e4066Sahrens */ 870fa9e4066Sahrens static const fs_operation_def_t zfsctl_tops_snapshot[] = { 871fa9e4066Sahrens VOPNAME_INACTIVE, (fs_generic_func_p) zfsctl_snapshot_inactive, 872fa9e4066Sahrens NULL, NULL 873fa9e4066Sahrens }; 874fa9e4066Sahrens 875fa9e4066Sahrens int 876fa9e4066Sahrens zfsctl_lookup_objset(vfs_t *vfsp, uint64_t objsetid, zfsvfs_t **zfsvfsp) 877fa9e4066Sahrens { 878fa9e4066Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 879fa9e4066Sahrens vnode_t *dvp, *vp; 880fa9e4066Sahrens zfsctl_snapdir_t *sdp; 881fa9e4066Sahrens zfsctl_node_t *zcp; 882fa9e4066Sahrens zfs_snapentry_t *sep; 883fa9e4066Sahrens int error; 884fa9e4066Sahrens 885fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir != NULL); 886fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp, 887fa9e4066Sahrens NULL, 0, NULL, kcred); 888fa9e4066Sahrens if (error != 0) 889fa9e4066Sahrens return (error); 890fa9e4066Sahrens sdp = dvp->v_data; 891fa9e4066Sahrens 892fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 893fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 894fa9e4066Sahrens while (sep != NULL) { 895fa9e4066Sahrens vp = sep->se_root; 896fa9e4066Sahrens zcp = vp->v_data; 897fa9e4066Sahrens if (zcp->zc_id == objsetid) 898fa9e4066Sahrens break; 899fa9e4066Sahrens 900fa9e4066Sahrens sep = AVL_NEXT(&sdp->sd_snaps, sep); 901fa9e4066Sahrens } 902fa9e4066Sahrens 903fa9e4066Sahrens if (sep != NULL) { 904fa9e4066Sahrens VN_HOLD(vp); 905fa9e4066Sahrens error = traverse(&vp); 906bbf4a8dfSmaybee if (error == 0) { 907bbf4a8dfSmaybee if (vp == sep->se_root) 908bbf4a8dfSmaybee error = EINVAL; 909bbf4a8dfSmaybee else 910bbf4a8dfSmaybee *zfsvfsp = VTOZ(vp)->z_zfsvfs; 911bbf4a8dfSmaybee } 912fea70b54Snd mutex_exit(&sdp->sd_lock); 913fa9e4066Sahrens VN_RELE(vp); 914fa9e4066Sahrens } else { 915fa9e4066Sahrens error = EINVAL; 916fea70b54Snd mutex_exit(&sdp->sd_lock); 917fa9e4066Sahrens } 918fa9e4066Sahrens 919fa9e4066Sahrens VN_RELE(dvp); 920fa9e4066Sahrens 921fa9e4066Sahrens return (error); 922fa9e4066Sahrens } 923fa9e4066Sahrens 924fa9e4066Sahrens /* 925fa9e4066Sahrens * Unmount any snapshots for the given filesystem. This is called from 926fa9e4066Sahrens * zfs_umount() - if we have a ctldir, then go through and unmount all the 927fa9e4066Sahrens * snapshots. 928fa9e4066Sahrens */ 929fa9e4066Sahrens int 930fa9e4066Sahrens zfsctl_umount_snapshots(vfs_t *vfsp, int fflags, cred_t *cr) 931fa9e4066Sahrens { 932fa9e4066Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 933fa9e4066Sahrens vnode_t *dvp, *svp; 934fa9e4066Sahrens zfsctl_snapdir_t *sdp; 935fa9e4066Sahrens zfs_snapentry_t *sep, *next; 936fa9e4066Sahrens int error; 937fa9e4066Sahrens 938fa9e4066Sahrens ASSERT(zfsvfs->z_ctldir != NULL); 939fa9e4066Sahrens error = zfsctl_root_lookup(zfsvfs->z_ctldir, "snapshot", &dvp, 940fa9e4066Sahrens NULL, 0, NULL, cr); 941fa9e4066Sahrens if (error != 0) 942fa9e4066Sahrens return (error); 943fa9e4066Sahrens sdp = dvp->v_data; 944fa9e4066Sahrens 945fa9e4066Sahrens mutex_enter(&sdp->sd_lock); 946fa9e4066Sahrens 947fa9e4066Sahrens sep = avl_first(&sdp->sd_snaps); 948fa9e4066Sahrens while (sep != NULL) { 949fa9e4066Sahrens svp = sep->se_root; 950fa9e4066Sahrens next = AVL_NEXT(&sdp->sd_snaps, sep); 951fa9e4066Sahrens 952fa9e4066Sahrens /* 953fa9e4066Sahrens * If this snapshot is not mounted, then it must 954fa9e4066Sahrens * have just been unmounted by somebody else, and 955fa9e4066Sahrens * will be cleaned up by zfsctl_snapdir_inactive(). 956fa9e4066Sahrens */ 957fa9e4066Sahrens if (vn_ismntpt(svp)) { 958fa9e4066Sahrens if ((error = vn_vfswlock(svp)) != 0) 959fa9e4066Sahrens goto out; 960fa9e4066Sahrens 961fa9e4066Sahrens VN_HOLD(svp); 962fa9e4066Sahrens error = dounmount(vn_mountedvfs(svp), fflags, cr); 963fa9e4066Sahrens if (error) { 964fa9e4066Sahrens VN_RELE(svp); 965fa9e4066Sahrens goto out; 966fa9e4066Sahrens } 967fa9e4066Sahrens 968fa9e4066Sahrens avl_remove(&sdp->sd_snaps, sep); 969fa9e4066Sahrens kmem_free(sep->se_name, strlen(sep->se_name) + 1); 970fa9e4066Sahrens kmem_free(sep, sizeof (zfs_snapentry_t)); 971fa9e4066Sahrens 972fa9e4066Sahrens /* 973fa9e4066Sahrens * We can't use VN_RELE(), as that will try to 974fa9e4066Sahrens * invoke zfsctl_snapdir_inactive(), and that 975fa9e4066Sahrens * would lead to an attempt to re-grab the sd_lock. 976fa9e4066Sahrens */ 977fa9e4066Sahrens ASSERT3U(svp->v_count, ==, 1); 978fa9e4066Sahrens gfs_vop_inactive(svp, cr); 979fa9e4066Sahrens } 980fa9e4066Sahrens sep = next; 981fa9e4066Sahrens } 982fa9e4066Sahrens out: 983fa9e4066Sahrens mutex_exit(&sdp->sd_lock); 984fa9e4066Sahrens VN_RELE(dvp); 985fa9e4066Sahrens 986fa9e4066Sahrens return (error); 987fa9e4066Sahrens } 988