xref: /illumos-gate/usr/src/uts/common/fs/zfs/zfs_ctldir.c (revision 8bf40bf00a7564d0ccb4a33906734188cb2d1e9b)
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