4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
26 * ZFS control directory (a.k.a. ".zfs")
28 * This directory provides a common location for all ZFS meta-objects.
29 * Currently, this is only the 'snapshot' directory, but this may expand in the
30 * future. The elements are built using the GFS primitives, as the hierarchy
31 * does not actually exist on disk.
33 * For 'snapshot', we don't want to have all snapshots always mounted, because
34 * this would take up a huge amount of space in /etc/mtab. We have three
37 * ctldir ------> snapshotdir -------> snapshot
43 * The 'snapshot' node contains just enough information to lookup '..' and act
44 * as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we
45 * perform an automount of the underlying filesystem and return the
46 * corresponding vnode.
48 * All mounts are handled automatically by the kernel, but unmounts are
49 * (currently) handled from user land. The main reason is that there is no
50 * reliable way to auto-unmount the filesystem when it's "no longer in use".
51 * When the user unmounts a filesystem, we call zfsctl_unmount(), which
52 * unmounts any snapshots within the snapshot directory.
54 * The '.zfs', '.zfs/snapshot', and all directories created under
55 * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') are all GFS nodes and
56 * share the same vfs_t as the head filesystem (what '.zfs' lives under).
58 * File systems mounted ontop of the GFS nodes '.zfs/snapshot/<snapname>'
59 * (ie: snapshots) are ZFS nodes and have their own unique vfs_t.
60 * However, vnodes within these mounted on file systems have their v_vfsp
61 * fields set to the head filesystem to make NFS happy (see
62 * zfsctl_snapdir_lookup()). We VFS_HOLD the head filesystem's vfs_t
63 * so that it cannot be freed until all snapshots have been unmounted.
68 #include <fs/fs_subr.h>
69 #include <sys/zfs_ctldir.h>
70 #include <sys/zfs_ioctl.h>
71 #include <sys/zfs_vfsops.h>
72 #include <sys/vfs_opreg.h>
76 #include <sys/dsl_deleg.h>
77 #include <sys/mount.h>
78 #include <sys/sunddi.h>
80 #include "zfs_namecheck.h"
82 typedef struct zfsctl_node
{
83 gfs_dir_t zc_gfs_private
;
85 timestruc_t zc_cmtime
; /* ctime and mtime, always the same */
88 typedef struct zfsctl_snapdir
{
89 zfsctl_node_t sd_node
;
101 snapentry_compare(const void *a
, const void *b
)
103 const zfs_snapentry_t
*sa
= a
;
104 const zfs_snapentry_t
*sb
= b
;
105 int ret
= strcmp(sa
->se_name
, sb
->se_name
);
115 vnodeops_t
*zfsctl_ops_root
;
116 vnodeops_t
*zfsctl_ops_snapdir
;
117 vnodeops_t
*zfsctl_ops_snapshot
;
118 vnodeops_t
*zfsctl_ops_shares
;
119 vnodeops_t
*zfsctl_ops_shares_dir
;
121 static const fs_operation_def_t zfsctl_tops_root
[];
122 static const fs_operation_def_t zfsctl_tops_snapdir
[];
123 static const fs_operation_def_t zfsctl_tops_snapshot
[];
124 static const fs_operation_def_t zfsctl_tops_shares
[];
126 static vnode_t
*zfsctl_mknode_snapdir(vnode_t
*);
127 static vnode_t
*zfsctl_mknode_shares(vnode_t
*);
128 static vnode_t
*zfsctl_snapshot_mknode(vnode_t
*, uint64_t objset
);
129 static int zfsctl_unmount_snap(zfs_snapentry_t
*, int, cred_t
*);
132 * Root directory elements. We only have two entries
133 * snapshot and shares.
135 static gfs_dirent_t zfsctl_root_entries
[] = {
136 { "snapshot", zfsctl_mknode_snapdir
, GFS_CACHE_VNODE
},
137 { "shares", zfsctl_mknode_shares
, GFS_CACHE_VNODE
},
141 /* include . and .. in the calculation */
142 #define NROOT_ENTRIES ((sizeof (zfsctl_root_entries) / \
143 sizeof (gfs_dirent_t)) + 1)
147 * Initialize the various GFS pieces we'll need to create and manipulate .zfs
148 * directories. This is called from the ZFS init routine, and initializes the
149 * vnode ops vectors that we'll be using.
160 * Remove vfsctl vnode ops
163 vn_freevnodeops(zfsctl_ops_root
);
164 if (zfsctl_ops_snapdir
)
165 vn_freevnodeops(zfsctl_ops_snapdir
);
166 if (zfsctl_ops_snapshot
)
167 vn_freevnodeops(zfsctl_ops_snapshot
);
168 if (zfsctl_ops_shares
)
169 vn_freevnodeops(zfsctl_ops_shares
);
170 if (zfsctl_ops_shares_dir
)
171 vn_freevnodeops(zfsctl_ops_shares_dir
);
173 zfsctl_ops_root
= NULL
;
174 zfsctl_ops_snapdir
= NULL
;
175 zfsctl_ops_snapshot
= NULL
;
176 zfsctl_ops_shares
= NULL
;
177 zfsctl_ops_shares_dir
= NULL
;
181 zfsctl_is_node(vnode_t
*vp
)
183 return (vn_matchops(vp
, zfsctl_ops_root
) ||
184 vn_matchops(vp
, zfsctl_ops_snapdir
) ||
185 vn_matchops(vp
, zfsctl_ops_snapshot
) ||
186 vn_matchops(vp
, zfsctl_ops_shares
) ||
187 vn_matchops(vp
, zfsctl_ops_shares_dir
));
192 * Return the inode number associated with the 'snapshot' or
193 * 'shares' directory.
197 zfsctl_root_inode_cb(vnode_t
*vp
, int index
)
199 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
204 return (ZFSCTL_INO_SNAPDIR
);
206 return (zfsvfs
->z_shares_dir
);
210 * Create the '.zfs' directory. This directory is cached as part of the VFS
211 * structure. This results in a hold on the vfs_t. The code in zfs_umount()
212 * therefore checks against a vfs_count of 2 instead of 1. This reference
213 * is removed when the ctldir is destroyed in the unmount.
216 zfsctl_create(zfsvfs_t
*zfsvfs
)
222 ASSERT(zfsvfs
->z_ctldir
== NULL
);
224 vp
= gfs_root_create(sizeof (zfsctl_node_t
), zfsvfs
->z_vfs
,
225 zfsctl_ops_root
, ZFSCTL_INO_ROOT
, zfsctl_root_entries
,
226 zfsctl_root_inode_cb
, MAXNAMELEN
, NULL
, NULL
);
228 zcp
->zc_id
= ZFSCTL_INO_ROOT
;
230 VERIFY(VFS_ROOT(zfsvfs
->z_vfs
, &rvp
) == 0);
231 VERIFY(0 == sa_lookup(VTOZ(rvp
)->z_sa_hdl
, SA_ZPL_CRTIME(zfsvfs
),
232 &crtime
, sizeof (crtime
)));
233 ZFS_TIME_DECODE(&zcp
->zc_cmtime
, crtime
);
237 * We're only faking the fact that we have a root of a filesystem for
238 * the sake of the GFS interfaces. Undo the flag manipulation it did
241 vp
->v_flag
&= ~(VROOT
| VNOCACHE
| VNOMAP
| VNOSWAP
| VNOMOUNT
);
243 zfsvfs
->z_ctldir
= vp
;
247 * Destroy the '.zfs' directory. Only called when the filesystem is unmounted.
248 * There might still be more references if we were force unmounted, but only
249 * new zfs_inactive() calls can occur and they don't reference .zfs
252 zfsctl_destroy(zfsvfs_t
*zfsvfs
)
254 VN_RELE(zfsvfs
->z_ctldir
);
255 zfsvfs
->z_ctldir
= NULL
;
259 * Given a root znode, retrieve the associated .zfs directory.
260 * Add a hold to the vnode and return it.
263 zfsctl_root(znode_t
*zp
)
265 ASSERT(zfs_has_ctldir(zp
));
266 VN_HOLD(zp
->z_zfsvfs
->z_ctldir
);
267 return (zp
->z_zfsvfs
->z_ctldir
);
271 * Common open routine. Disallow any write access.
275 zfsctl_common_open(vnode_t
**vpp
, int flags
, cred_t
*cr
, caller_context_t
*ct
)
284 * Common close routine. Nothing to do here.
288 zfsctl_common_close(vnode_t
*vpp
, int flags
, int count
, offset_t off
,
289 cred_t
*cr
, caller_context_t
*ct
)
295 * Common access routine. Disallow writes.
299 zfsctl_common_access(vnode_t
*vp
, int mode
, int flags
, cred_t
*cr
,
300 caller_context_t
*ct
)
302 if (flags
& V_ACE_MASK
) {
303 if (mode
& ACE_ALL_WRITE_PERMS
)
314 * Common getattr function. Fill in basic information.
317 zfsctl_common_getattr(vnode_t
*vp
, vattr_t
*vap
)
325 * We are a purely virtual object, so we have no
326 * blocksize or allocated blocks.
331 vap
->va_fsid
= vp
->v_vfsp
->vfs_dev
;
332 vap
->va_mode
= S_IRUSR
| S_IXUSR
| S_IRGRP
| S_IXGRP
|
336 * We live in the now (for atime).
344 zfsctl_common_fid(vnode_t
*vp
, fid_t
*fidp
, caller_context_t
*ct
)
346 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
347 zfsctl_node_t
*zcp
= vp
->v_data
;
348 uint64_t object
= zcp
->zc_id
;
354 if (fidp
->fid_len
< SHORT_FID_LEN
) {
355 fidp
->fid_len
= SHORT_FID_LEN
;
360 zfid
= (zfid_short_t
*)fidp
;
362 zfid
->zf_len
= SHORT_FID_LEN
;
364 for (i
= 0; i
< sizeof (zfid
->zf_object
); i
++)
365 zfid
->zf_object
[i
] = (uint8_t)(object
>> (8 * i
));
367 /* .zfs znodes always have a generation number of 0 */
368 for (i
= 0; i
< sizeof (zfid
->zf_gen
); i
++)
378 zfsctl_shares_fid(vnode_t
*vp
, fid_t
*fidp
, caller_context_t
*ct
)
380 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
386 if (zfsvfs
->z_shares_dir
== 0) {
391 if ((error
= zfs_zget(zfsvfs
, zfsvfs
->z_shares_dir
, &dzp
)) == 0) {
392 error
= VOP_FID(ZTOV(dzp
), fidp
, ct
);
400 * .zfs inode namespace
402 * We need to generate unique inode numbers for all files and directories
403 * within the .zfs pseudo-filesystem. We use the following scheme:
408 * .zfs/snapshot/<snap> objectid(snap)
411 #define ZFSCTL_INO_SNAP(id) (id)
414 * Get root directory attributes.
418 zfsctl_root_getattr(vnode_t
*vp
, vattr_t
*vap
, int flags
, cred_t
*cr
,
419 caller_context_t
*ct
)
421 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
422 zfsctl_node_t
*zcp
= vp
->v_data
;
425 vap
->va_nodeid
= ZFSCTL_INO_ROOT
;
426 vap
->va_nlink
= vap
->va_size
= NROOT_ENTRIES
;
427 vap
->va_mtime
= vap
->va_ctime
= zcp
->zc_cmtime
;
429 zfsctl_common_getattr(vp
, vap
);
436 * Special case the handling of "..".
440 zfsctl_root_lookup(vnode_t
*dvp
, char *nm
, vnode_t
**vpp
, pathname_t
*pnp
,
441 int flags
, vnode_t
*rdir
, cred_t
*cr
, caller_context_t
*ct
,
442 int *direntflags
, pathname_t
*realpnp
)
444 zfsvfs_t
*zfsvfs
= dvp
->v_vfsp
->vfs_data
;
448 * No extended attributes allowed under .zfs
450 if (flags
& LOOKUP_XATTR
)
455 if (strcmp(nm
, "..") == 0) {
456 err
= VFS_ROOT(dvp
->v_vfsp
, vpp
);
458 err
= gfs_vop_lookup(dvp
, nm
, vpp
, pnp
, flags
, rdir
,
459 cr
, ct
, direntflags
, realpnp
);
468 zfsctl_pathconf(vnode_t
*vp
, int cmd
, ulong_t
*valp
, cred_t
*cr
,
469 caller_context_t
*ct
)
472 * We only care about ACL_ENABLED so that libsec can
473 * display ACL correctly and not default to POSIX draft.
475 if (cmd
== _PC_ACL_ENABLED
) {
476 *valp
= _ACL_ACE_ENABLED
;
480 return (fs_pathconf(vp
, cmd
, valp
, cr
, ct
));
483 static const fs_operation_def_t zfsctl_tops_root
[] = {
484 { VOPNAME_OPEN
, { .vop_open
= zfsctl_common_open
} },
485 { VOPNAME_CLOSE
, { .vop_close
= zfsctl_common_close
} },
486 { VOPNAME_IOCTL
, { .error
= fs_inval
} },
487 { VOPNAME_GETATTR
, { .vop_getattr
= zfsctl_root_getattr
} },
488 { VOPNAME_ACCESS
, { .vop_access
= zfsctl_common_access
} },
489 { VOPNAME_READDIR
, { .vop_readdir
= gfs_vop_readdir
} },
490 { VOPNAME_LOOKUP
, { .vop_lookup
= zfsctl_root_lookup
} },
491 { VOPNAME_SEEK
, { .vop_seek
= fs_seek
} },
492 { VOPNAME_INACTIVE
, { .vop_inactive
= gfs_vop_inactive
} },
493 { VOPNAME_PATHCONF
, { .vop_pathconf
= zfsctl_pathconf
} },
494 { VOPNAME_FID
, { .vop_fid
= zfsctl_common_fid
} },
499 zfsctl_snapshot_zname(vnode_t
*vp
, const char *name
, int len
, char *zname
)
501 objset_t
*os
= ((zfsvfs_t
*)((vp
)->v_vfsp
->vfs_data
))->z_os
;
503 if (snapshot_namecheck(name
, NULL
, NULL
) != 0)
505 dmu_objset_name(os
, zname
);
506 if (strlen(zname
) + 1 + strlen(name
) >= len
)
507 return (ENAMETOOLONG
);
508 (void) strcat(zname
, "@");
509 (void) strcat(zname
, name
);
514 zfsctl_unmount_snap(zfs_snapentry_t
*sep
, int fflags
, cred_t
*cr
)
516 vnode_t
*svp
= sep
->se_root
;
519 ASSERT(vn_ismntpt(svp
));
521 /* this will be dropped by dounmount() */
522 if ((error
= vn_vfswlock(svp
)) != 0)
526 error
= dounmount(vn_mountedvfs(svp
), fflags
, cr
);
533 * We can't use VN_RELE(), as that will try to invoke
534 * zfsctl_snapdir_inactive(), which would cause us to destroy
535 * the sd_lock mutex held by our caller.
537 ASSERT(svp
->v_count
== 1);
538 gfs_vop_inactive(svp
, cr
, NULL
);
540 kmem_free(sep
->se_name
, strlen(sep
->se_name
) + 1);
541 kmem_free(sep
, sizeof (zfs_snapentry_t
));
547 zfsctl_rename_snap(zfsctl_snapdir_t
*sdp
, zfs_snapentry_t
*sep
, const char *nm
)
552 char newpath
[MAXNAMELEN
];
555 ASSERT(MUTEX_HELD(&sdp
->sd_lock
));
558 vfsp
= vn_mountedvfs(sep
->se_root
);
559 ASSERT(vfsp
!= NULL
);
564 * Change the name in the AVL tree.
566 avl_remove(&sdp
->sd_snaps
, sep
);
567 kmem_free(sep
->se_name
, strlen(sep
->se_name
) + 1);
568 sep
->se_name
= kmem_alloc(strlen(nm
) + 1, KM_SLEEP
);
569 (void) strcpy(sep
->se_name
, nm
);
570 VERIFY(avl_find(&sdp
->sd_snaps
, sep
, &where
) == NULL
);
571 avl_insert(&sdp
->sd_snaps
, sep
, where
);
574 * Change the current mountpoint info:
575 * - update the tail of the mntpoint path
576 * - update the tail of the resource path
578 pathref
= vfs_getmntpoint(vfsp
);
579 (void) strncpy(newpath
, refstr_value(pathref
), sizeof (newpath
));
580 VERIFY((tail
= strrchr(newpath
, '/')) != NULL
);
582 ASSERT3U(strlen(newpath
) + strlen(nm
), <, sizeof (newpath
));
583 (void) strcat(newpath
, nm
);
584 refstr_rele(pathref
);
585 vfs_setmntpoint(vfsp
, newpath
, 0);
587 pathref
= vfs_getresource(vfsp
);
588 (void) strncpy(newpath
, refstr_value(pathref
), sizeof (newpath
));
589 VERIFY((tail
= strrchr(newpath
, '@')) != NULL
);
591 ASSERT3U(strlen(newpath
) + strlen(nm
), <, sizeof (newpath
));
592 (void) strcat(newpath
, nm
);
593 refstr_rele(pathref
);
594 vfs_setresource(vfsp
, newpath
, 0);
601 zfsctl_snapdir_rename(vnode_t
*sdvp
, char *snm
, vnode_t
*tdvp
, char *tnm
,
602 cred_t
*cr
, caller_context_t
*ct
, int flags
)
604 zfsctl_snapdir_t
*sdp
= sdvp
->v_data
;
605 zfs_snapentry_t search
, *sep
;
608 char from
[MAXNAMELEN
], to
[MAXNAMELEN
];
609 char real
[MAXNAMELEN
];
612 zfsvfs
= sdvp
->v_vfsp
->vfs_data
;
615 if ((flags
& FIGNORECASE
) || zfsvfs
->z_case
== ZFS_CASE_INSENSITIVE
) {
616 err
= dmu_snapshot_realname(zfsvfs
->z_os
, snm
, real
,
620 } else if (err
!= ENOTSUP
) {
628 err
= zfsctl_snapshot_zname(sdvp
, snm
, MAXNAMELEN
, from
);
630 err
= zfsctl_snapshot_zname(tdvp
, tnm
, MAXNAMELEN
, to
);
632 err
= zfs_secpolicy_rename_perms(from
, to
, cr
);
637 * Cannot move snapshots out of the snapdir.
642 if (strcmp(snm
, tnm
) == 0)
645 mutex_enter(&sdp
->sd_lock
);
647 search
.se_name
= (char *)snm
;
648 if ((sep
= avl_find(&sdp
->sd_snaps
, &search
, &where
)) == NULL
) {
649 mutex_exit(&sdp
->sd_lock
);
653 err
= dmu_objset_rename(from
, to
, B_FALSE
);
655 zfsctl_rename_snap(sdp
, sep
, tnm
);
657 mutex_exit(&sdp
->sd_lock
);
664 zfsctl_snapdir_remove(vnode_t
*dvp
, char *name
, vnode_t
*cwd
, cred_t
*cr
,
665 caller_context_t
*ct
, int flags
)
667 zfsctl_snapdir_t
*sdp
= dvp
->v_data
;
668 zfs_snapentry_t
*sep
;
669 zfs_snapentry_t search
;
671 char snapname
[MAXNAMELEN
];
672 char real
[MAXNAMELEN
];
675 zfsvfs
= dvp
->v_vfsp
->vfs_data
;
678 if ((flags
& FIGNORECASE
) || zfsvfs
->z_case
== ZFS_CASE_INSENSITIVE
) {
680 err
= dmu_snapshot_realname(zfsvfs
->z_os
, name
, real
,
684 } else if (err
!= ENOTSUP
) {
692 err
= zfsctl_snapshot_zname(dvp
, name
, MAXNAMELEN
, snapname
);
694 err
= zfs_secpolicy_destroy_perms(snapname
, cr
);
698 mutex_enter(&sdp
->sd_lock
);
700 search
.se_name
= name
;
701 sep
= avl_find(&sdp
->sd_snaps
, &search
, NULL
);
703 avl_remove(&sdp
->sd_snaps
, sep
);
704 err
= zfsctl_unmount_snap(sep
, MS_FORCE
, cr
);
706 avl_add(&sdp
->sd_snaps
, sep
);
708 err
= dmu_objset_destroy(snapname
, B_FALSE
);
713 mutex_exit(&sdp
->sd_lock
);
719 * This creates a snapshot under '.zfs/snapshot'.
723 zfsctl_snapdir_mkdir(vnode_t
*dvp
, char *dirname
, vattr_t
*vap
, vnode_t
**vpp
,
724 cred_t
*cr
, caller_context_t
*cc
, int flags
, vsecattr_t
*vsecp
)
726 zfsvfs_t
*zfsvfs
= dvp
->v_vfsp
->vfs_data
;
727 char name
[MAXNAMELEN
];
729 static enum symfollow follow
= NO_FOLLOW
;
730 static enum uio_seg seg
= UIO_SYSSPACE
;
732 if (snapshot_namecheck(dirname
, NULL
, NULL
) != 0)
735 dmu_objset_name(zfsvfs
->z_os
, name
);
739 err
= zfs_secpolicy_snapshot_perms(name
, cr
);
744 err
= dmu_objset_snapshot(name
, dirname
, NULL
, NULL
,
745 B_FALSE
, B_FALSE
, -1);
748 err
= lookupnameat(dirname
, seg
, follow
, NULL
, vpp
, dvp
);
755 * Lookup entry point for the 'snapshot' directory. Try to open the
756 * snapshot if it exist, creating the pseudo filesystem vnode as necessary.
757 * Perform a mount of the associated dataset on top of the vnode.
761 zfsctl_snapdir_lookup(vnode_t
*dvp
, char *nm
, vnode_t
**vpp
, pathname_t
*pnp
,
762 int flags
, vnode_t
*rdir
, cred_t
*cr
, caller_context_t
*ct
,
763 int *direntflags
, pathname_t
*realpnp
)
765 zfsctl_snapdir_t
*sdp
= dvp
->v_data
;
767 char snapname
[MAXNAMELEN
];
768 char real
[MAXNAMELEN
];
770 zfs_snapentry_t
*sep
, search
;
773 size_t mountpoint_len
;
775 zfsvfs_t
*zfsvfs
= dvp
->v_vfsp
->vfs_data
;
779 * No extended attributes allowed under .zfs
781 if (flags
& LOOKUP_XATTR
)
784 ASSERT(dvp
->v_type
== VDIR
);
787 * If we get a recursive call, that means we got called
788 * from the domount() code while it was trying to look up the
789 * spec (which looks like a local path for zfs). We need to
790 * add some flag to domount() to tell it not to do this lookup.
792 if (MUTEX_HELD(&sdp
->sd_lock
))
797 if (gfs_lookup_dot(vpp
, dvp
, zfsvfs
->z_ctldir
, nm
) == 0) {
802 if (flags
& FIGNORECASE
) {
803 boolean_t conflict
= B_FALSE
;
805 err
= dmu_snapshot_realname(zfsvfs
->z_os
, nm
, real
,
806 MAXNAMELEN
, &conflict
);
809 } else if (err
!= ENOTSUP
) {
814 (void) strlcpy(realpnp
->pn_buf
, nm
,
815 realpnp
->pn_bufsize
);
816 if (conflict
&& direntflags
)
817 *direntflags
= ED_CASE_CONFLICT
;
820 mutex_enter(&sdp
->sd_lock
);
821 search
.se_name
= (char *)nm
;
822 if ((sep
= avl_find(&sdp
->sd_snaps
, &search
, &where
)) != NULL
) {
829 } else if (*vpp
== sep
->se_root
) {
831 * The snapshot was unmounted behind our backs,
837 * VROOT was set during the traverse call. We need
838 * to clear it since we're pretending to be part
839 * of our parent's vfs.
841 (*vpp
)->v_flag
&= ~VROOT
;
843 mutex_exit(&sdp
->sd_lock
);
849 * The requested snapshot is not currently mounted, look it up.
851 err
= zfsctl_snapshot_zname(dvp
, nm
, MAXNAMELEN
, snapname
);
853 mutex_exit(&sdp
->sd_lock
);
856 * handle "ls *" or "?" in a graceful manner,
857 * forcing EILSEQ to ENOENT.
858 * Since shell ultimately passes "*" or "?" as name to lookup
860 return (err
== EILSEQ
? ENOENT
: err
);
862 if (dmu_objset_hold(snapname
, FTAG
, &snap
) != 0) {
863 mutex_exit(&sdp
->sd_lock
);
868 sep
= kmem_alloc(sizeof (zfs_snapentry_t
), KM_SLEEP
);
869 sep
->se_name
= kmem_alloc(strlen(nm
) + 1, KM_SLEEP
);
870 (void) strcpy(sep
->se_name
, nm
);
871 *vpp
= sep
->se_root
= zfsctl_snapshot_mknode(dvp
, dmu_objset_id(snap
));
872 avl_insert(&sdp
->sd_snaps
, sep
, where
);
874 dmu_objset_rele(snap
, FTAG
);
876 mountpoint_len
= strlen(refstr_value(dvp
->v_vfsp
->vfs_mntpt
)) +
877 strlen("/.zfs/snapshot/") + strlen(nm
) + 1;
878 mountpoint
= kmem_alloc(mountpoint_len
, KM_SLEEP
);
879 (void) snprintf(mountpoint
, mountpoint_len
, "%s/.zfs/snapshot/%s",
880 refstr_value(dvp
->v_vfsp
->vfs_mntpt
), nm
);
882 margs
.spec
= snapname
;
883 margs
.dir
= mountpoint
;
884 margs
.flags
= MS_SYSSPACE
| MS_NOMNTTAB
;
885 margs
.fstype
= "zfs";
886 margs
.dataptr
= NULL
;
891 err
= domount("zfs", &margs
, *vpp
, kcred
, &vfsp
);
892 kmem_free(mountpoint
, mountpoint_len
);
896 * Return the mounted root rather than the covered mount point.
897 * Takes the GFS vnode at .zfs/snapshot/<snapname> and returns
898 * the ZFS vnode mounted on top of the GFS node. This ZFS
899 * vnode is the root of the newly created vfsp.
907 * Fix up the root vnode mounted on .zfs/snapshot/<snapname>.
909 * This is where we lie about our v_vfsp in order to
910 * make .zfs/snapshot/<snapname> accessible over NFS
911 * without requiring manual mounts of <snapname>.
913 ASSERT(VTOZ(*vpp
)->z_zfsvfs
!= zfsvfs
);
914 VTOZ(*vpp
)->z_zfsvfs
->z_parent
= zfsvfs
;
915 (*vpp
)->v_vfsp
= zfsvfs
->z_vfs
;
916 (*vpp
)->v_flag
&= ~VROOT
;
918 mutex_exit(&sdp
->sd_lock
);
922 * If we had an error, drop our hold on the vnode and
923 * zfsctl_snapshot_inactive() will clean up.
934 zfsctl_shares_lookup(vnode_t
*dvp
, char *nm
, vnode_t
**vpp
, pathname_t
*pnp
,
935 int flags
, vnode_t
*rdir
, cred_t
*cr
, caller_context_t
*ct
,
936 int *direntflags
, pathname_t
*realpnp
)
938 zfsvfs_t
*zfsvfs
= dvp
->v_vfsp
->vfs_data
;
944 if (gfs_lookup_dot(vpp
, dvp
, zfsvfs
->z_ctldir
, nm
) == 0) {
949 if (zfsvfs
->z_shares_dir
== 0) {
953 if ((error
= zfs_zget(zfsvfs
, zfsvfs
->z_shares_dir
, &dzp
)) == 0)
954 error
= VOP_LOOKUP(ZTOV(dzp
), nm
, vpp
, pnp
,
955 flags
, rdir
, cr
, ct
, direntflags
, realpnp
);
965 zfsctl_snapdir_readdir_cb(vnode_t
*vp
, void *dp
, int *eofp
,
966 offset_t
*offp
, offset_t
*nextp
, void *data
, int flags
)
968 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
969 char snapname
[MAXNAMELEN
];
971 boolean_t case_conflict
;
977 error
= dmu_snapshot_list_next(zfsvfs
->z_os
, MAXNAMELEN
, snapname
, &id
,
978 &cookie
, &case_conflict
);
981 if (error
== ENOENT
) {
988 if (flags
& V_RDDIR_ENTFLAGS
) {
989 edirent_t
*eodp
= dp
;
991 (void) strcpy(eodp
->ed_name
, snapname
);
992 eodp
->ed_ino
= ZFSCTL_INO_SNAP(id
);
993 eodp
->ed_eflags
= case_conflict
? ED_CASE_CONFLICT
: 0;
995 struct dirent64
*odp
= dp
;
997 (void) strcpy(odp
->d_name
, snapname
);
998 odp
->d_ino
= ZFSCTL_INO_SNAP(id
);
1009 zfsctl_shares_readdir(vnode_t
*vp
, uio_t
*uiop
, cred_t
*cr
, int *eofp
,
1010 caller_context_t
*ct
, int flags
)
1012 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
1018 if (zfsvfs
->z_shares_dir
== 0) {
1022 if ((error
= zfs_zget(zfsvfs
, zfsvfs
->z_shares_dir
, &dzp
)) == 0) {
1023 error
= VOP_READDIR(ZTOV(dzp
), uiop
, cr
, eofp
, ct
, flags
);
1035 * pvp is the '.zfs' directory (zfsctl_node_t).
1036 * Creates vp, which is '.zfs/snapshot' (zfsctl_snapdir_t).
1038 * This function is the callback to create a GFS vnode for '.zfs/snapshot'
1039 * when a lookup is performed on .zfs for "snapshot".
1042 zfsctl_mknode_snapdir(vnode_t
*pvp
)
1045 zfsctl_snapdir_t
*sdp
;
1047 vp
= gfs_dir_create(sizeof (zfsctl_snapdir_t
), pvp
,
1048 zfsctl_ops_snapdir
, NULL
, NULL
, MAXNAMELEN
,
1049 zfsctl_snapdir_readdir_cb
, NULL
);
1051 sdp
->sd_node
.zc_id
= ZFSCTL_INO_SNAPDIR
;
1052 sdp
->sd_node
.zc_cmtime
= ((zfsctl_node_t
*)pvp
->v_data
)->zc_cmtime
;
1053 mutex_init(&sdp
->sd_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1054 avl_create(&sdp
->sd_snaps
, snapentry_compare
,
1055 sizeof (zfs_snapentry_t
), offsetof(zfs_snapentry_t
, se_node
));
1060 zfsctl_mknode_shares(vnode_t
*pvp
)
1065 vp
= gfs_dir_create(sizeof (zfsctl_node_t
), pvp
,
1066 zfsctl_ops_shares
, NULL
, NULL
, MAXNAMELEN
,
1069 sdp
->zc_cmtime
= ((zfsctl_node_t
*)pvp
->v_data
)->zc_cmtime
;
1076 zfsctl_shares_getattr(vnode_t
*vp
, vattr_t
*vap
, int flags
, cred_t
*cr
,
1077 caller_context_t
*ct
)
1079 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
1084 if (zfsvfs
->z_shares_dir
== 0) {
1088 if ((error
= zfs_zget(zfsvfs
, zfsvfs
->z_shares_dir
, &dzp
)) == 0) {
1089 error
= VOP_GETATTR(ZTOV(dzp
), vap
, flags
, cr
, ct
);
1100 zfsctl_snapdir_getattr(vnode_t
*vp
, vattr_t
*vap
, int flags
, cred_t
*cr
,
1101 caller_context_t
*ct
)
1103 zfsvfs_t
*zfsvfs
= vp
->v_vfsp
->vfs_data
;
1104 zfsctl_snapdir_t
*sdp
= vp
->v_data
;
1107 zfsctl_common_getattr(vp
, vap
);
1108 vap
->va_nodeid
= gfs_file_inode(vp
);
1109 vap
->va_nlink
= vap
->va_size
= avl_numnodes(&sdp
->sd_snaps
) + 2;
1110 vap
->va_ctime
= vap
->va_mtime
= dmu_objset_snap_cmtime(zfsvfs
->z_os
);
1118 zfsctl_snapdir_inactive(vnode_t
*vp
, cred_t
*cr
, caller_context_t
*ct
)
1120 zfsctl_snapdir_t
*sdp
= vp
->v_data
;
1123 private = gfs_dir_inactive(vp
);
1124 if (private != NULL
) {
1125 ASSERT(avl_numnodes(&sdp
->sd_snaps
) == 0);
1126 mutex_destroy(&sdp
->sd_lock
);
1127 avl_destroy(&sdp
->sd_snaps
);
1128 kmem_free(private, sizeof (zfsctl_snapdir_t
));
1132 static const fs_operation_def_t zfsctl_tops_snapdir
[] = {
1133 { VOPNAME_OPEN
, { .vop_open
= zfsctl_common_open
} },
1134 { VOPNAME_CLOSE
, { .vop_close
= zfsctl_common_close
} },
1135 { VOPNAME_IOCTL
, { .error
= fs_inval
} },
1136 { VOPNAME_GETATTR
, { .vop_getattr
= zfsctl_snapdir_getattr
} },
1137 { VOPNAME_ACCESS
, { .vop_access
= zfsctl_common_access
} },
1138 { VOPNAME_RENAME
, { .vop_rename
= zfsctl_snapdir_rename
} },
1139 { VOPNAME_RMDIR
, { .vop_rmdir
= zfsctl_snapdir_remove
} },
1140 { VOPNAME_MKDIR
, { .vop_mkdir
= zfsctl_snapdir_mkdir
} },
1141 { VOPNAME_READDIR
, { .vop_readdir
= gfs_vop_readdir
} },
1142 { VOPNAME_LOOKUP
, { .vop_lookup
= zfsctl_snapdir_lookup
} },
1143 { VOPNAME_SEEK
, { .vop_seek
= fs_seek
} },
1144 { VOPNAME_INACTIVE
, { .vop_inactive
= zfsctl_snapdir_inactive
} },
1145 { VOPNAME_FID
, { .vop_fid
= zfsctl_common_fid
} },
1149 static const fs_operation_def_t zfsctl_tops_shares
[] = {
1150 { VOPNAME_OPEN
, { .vop_open
= zfsctl_common_open
} },
1151 { VOPNAME_CLOSE
, { .vop_close
= zfsctl_common_close
} },
1152 { VOPNAME_IOCTL
, { .error
= fs_inval
} },
1153 { VOPNAME_GETATTR
, { .vop_getattr
= zfsctl_shares_getattr
} },
1154 { VOPNAME_ACCESS
, { .vop_access
= zfsctl_common_access
} },
1155 { VOPNAME_READDIR
, { .vop_readdir
= zfsctl_shares_readdir
} },
1156 { VOPNAME_LOOKUP
, { .vop_lookup
= zfsctl_shares_lookup
} },
1157 { VOPNAME_SEEK
, { .vop_seek
= fs_seek
} },
1158 { VOPNAME_INACTIVE
, { .vop_inactive
= gfs_vop_inactive
} },
1159 { VOPNAME_FID
, { .vop_fid
= zfsctl_shares_fid
} },
1164 * pvp is the GFS vnode '.zfs/snapshot'.
1166 * This creates a GFS node under '.zfs/snapshot' representing each
1167 * snapshot. This newly created GFS node is what we mount snapshot
1171 zfsctl_snapshot_mknode(vnode_t
*pvp
, uint64_t objset
)
1176 vp
= gfs_dir_create(sizeof (zfsctl_node_t
), pvp
,
1177 zfsctl_ops_snapshot
, NULL
, NULL
, MAXNAMELEN
, NULL
, NULL
);
1179 zcp
->zc_id
= objset
;
1185 zfsctl_snapshot_inactive(vnode_t
*vp
, cred_t
*cr
, caller_context_t
*ct
)
1187 zfsctl_snapdir_t
*sdp
;
1188 zfs_snapentry_t
*sep
, *next
;
1191 VERIFY(gfs_dir_lookup(vp
, "..", &dvp
, cr
, 0, NULL
, NULL
) == 0);
1194 mutex_enter(&sdp
->sd_lock
);
1196 if (vp
->v_count
> 1) {
1197 mutex_exit(&sdp
->sd_lock
);
1200 ASSERT(!vn_ismntpt(vp
));
1202 sep
= avl_first(&sdp
->sd_snaps
);
1203 while (sep
!= NULL
) {
1204 next
= AVL_NEXT(&sdp
->sd_snaps
, sep
);
1206 if (sep
->se_root
== vp
) {
1207 avl_remove(&sdp
->sd_snaps
, sep
);
1208 kmem_free(sep
->se_name
, strlen(sep
->se_name
) + 1);
1209 kmem_free(sep
, sizeof (zfs_snapentry_t
));
1214 ASSERT(sep
!= NULL
);
1216 mutex_exit(&sdp
->sd_lock
);
1220 * Dispose of the vnode for the snapshot mount point.
1221 * This is safe to do because once this entry has been removed
1222 * from the AVL tree, it can't be found again, so cannot become
1223 * "active". If we lookup the same name again we will end up
1224 * creating a new vnode.
1226 gfs_vop_inactive(vp
, cr
, ct
);
1231 * These VP's should never see the light of day. They should always
1234 static const fs_operation_def_t zfsctl_tops_snapshot
[] = {
1235 VOPNAME_INACTIVE
, { .vop_inactive
= zfsctl_snapshot_inactive
},
1240 zfsctl_lookup_objset(vfs_t
*vfsp
, uint64_t objsetid
, zfsvfs_t
**zfsvfsp
)
1242 zfsvfs_t
*zfsvfs
= vfsp
->vfs_data
;
1244 zfsctl_snapdir_t
*sdp
;
1246 zfs_snapentry_t
*sep
;
1249 ASSERT(zfsvfs
->z_ctldir
!= NULL
);
1250 error
= zfsctl_root_lookup(zfsvfs
->z_ctldir
, "snapshot", &dvp
,
1251 NULL
, 0, NULL
, kcred
, NULL
, NULL
, NULL
);
1256 mutex_enter(&sdp
->sd_lock
);
1257 sep
= avl_first(&sdp
->sd_snaps
);
1258 while (sep
!= NULL
) {
1261 if (zcp
->zc_id
== objsetid
)
1264 sep
= AVL_NEXT(&sdp
->sd_snaps
, sep
);
1270 * Return the mounted root rather than the covered mount point.
1271 * Takes the GFS vnode at .zfs/snapshot/<snapshot objsetid>
1272 * and returns the ZFS vnode mounted on top of the GFS node.
1273 * This ZFS vnode is the root of the vfs for objset 'objsetid'.
1275 error
= traverse(&vp
);
1277 if (vp
== sep
->se_root
)
1280 *zfsvfsp
= VTOZ(vp
)->z_zfsvfs
;
1282 mutex_exit(&sdp
->sd_lock
);
1286 mutex_exit(&sdp
->sd_lock
);
1295 * Unmount any snapshots for the given filesystem. This is called from
1296 * zfs_umount() - if we have a ctldir, then go through and unmount all the
1300 zfsctl_umount_snapshots(vfs_t
*vfsp
, int fflags
, cred_t
*cr
)
1302 zfsvfs_t
*zfsvfs
= vfsp
->vfs_data
;
1304 zfsctl_snapdir_t
*sdp
;
1305 zfs_snapentry_t
*sep
, *next
;
1308 ASSERT(zfsvfs
->z_ctldir
!= NULL
);
1309 error
= zfsctl_root_lookup(zfsvfs
->z_ctldir
, "snapshot", &dvp
,
1310 NULL
, 0, NULL
, cr
, NULL
, NULL
, NULL
);
1315 mutex_enter(&sdp
->sd_lock
);
1317 sep
= avl_first(&sdp
->sd_snaps
);
1318 while (sep
!= NULL
) {
1319 next
= AVL_NEXT(&sdp
->sd_snaps
, sep
);
1322 * If this snapshot is not mounted, then it must
1323 * have just been unmounted by somebody else, and
1324 * will be cleaned up by zfsctl_snapdir_inactive().
1326 if (vn_ismntpt(sep
->se_root
)) {
1327 avl_remove(&sdp
->sd_snaps
, sep
);
1328 error
= zfsctl_unmount_snap(sep
, fflags
, cr
);
1330 avl_add(&sdp
->sd_snaps
, sep
);
1337 mutex_exit(&sdp
->sd_lock
);
1342 #endif /* HAVE_ZPL */