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]
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (C) 2011 Lawrence Livermore National Security, LLC.
25 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
27 * Rewritten for Linux by:
28 * Rohan Puri <rohan.puri15@gmail.com>
29 * Brian Behlendorf <behlendorf1@llnl.gov>
33 * ZFS control directory (a.k.a. ".zfs")
35 * This directory provides a common location for all ZFS meta-objects.
36 * Currently, this is only the 'snapshot' and 'shares' directory, but this may
37 * expand in the future. The elements are built dynamically, as the hierarchy
38 * does not actually exist on disk.
40 * For 'snapshot', we don't want to have all snapshots always mounted, because
41 * this would take up a huge amount of space in /etc/mnttab. We have three
44 * ctldir ------> snapshotdir -------> snapshot
50 * The 'snapshot' node contains just enough information to lookup '..' and act
51 * as a mountpoint for the snapshot. Whenever we lookup a specific snapshot, we
52 * perform an automount of the underlying filesystem and return the
53 * corresponding inode.
55 * All mounts are handled automatically by an user mode helper which invokes
56 * the mount mount procedure. Unmounts are handled by allowing the mount
57 * point to expire so the kernel may automatically unmount it.
59 * The '.zfs', '.zfs/snapshot', and all directories created under
60 * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') all share the same
61 * share the same zfs_sb_t as the head filesystem (what '.zfs' lives under).
63 * File systems mounted on top of the '.zfs/snapshot/<snapname>' paths
64 * (ie: snapshots) are complete ZFS filesystems and have their own unique
65 * zfs_sb_t. However, the fsid reported by these mounts will be the same
66 * as that used by the parent zfs_sb_t to make NFS happy.
69 #include <sys/types.h>
70 #include <sys/param.h>
72 #include <sys/systm.h>
73 #include <sys/sysmacros.h>
74 #include <sys/pathname.h>
76 #include <sys/vfs_opreg.h>
77 #include <sys/zfs_ctldir.h>
78 #include <sys/zfs_ioctl.h>
79 #include <sys/zfs_vfsops.h>
80 #include <sys/zfs_vnops.h>
83 #include <sys/dsl_deleg.h>
84 #include <sys/mount.h>
86 #include "zfs_namecheck.h"
89 * Control Directory Tunables (.zfs)
91 int zfs_expire_snapshot = ZFSCTL_EXPIRE_SNAPSHOT;
94 * Dedicated task queue for unmounting snapshots.
96 static taskq_t *zfs_expire_taskq;
98 static zfs_snapentry_t *
99 zfsctl_sep_alloc(void)
101 return kmem_zalloc(sizeof (zfs_snapentry_t), KM_SLEEP);
105 zfsctl_sep_free(zfs_snapentry_t *sep)
107 kmem_free(sep->se_name, MAXNAMELEN);
108 kmem_free(sep->se_path, PATH_MAX);
109 kmem_free(sep, sizeof (zfs_snapentry_t));
113 * Attempt to expire an automounted snapshot, unmounts are attempted every
114 * 'zfs_expire_snapshot' seconds until they succeed. The work request is
115 * responsible for rescheduling itself and freeing the zfs_expire_snapshot_t.
118 zfsctl_expire_snapshot(void *data)
120 zfs_snapentry_t *sep = (zfs_snapentry_t *)data;
121 zfs_sb_t *zsb = ITOZSB(sep->se_inode);
124 error = zfsctl_unmount_snapshot(zsb, sep->se_name, MNT_EXPIRE);
126 sep->se_taskqid = taskq_dispatch_delay(zfs_expire_taskq,
127 zfsctl_expire_snapshot, sep, TQ_SLEEP,
128 ddi_get_lbolt() + zfs_expire_snapshot * HZ);
132 snapentry_compare(const void *a, const void *b)
134 const zfs_snapentry_t *sa = a;
135 const zfs_snapentry_t *sb = b;
136 int ret = strcmp(sa->se_name, sb->se_name);
147 zfsctl_is_node(struct inode *ip)
149 return (ITOZ(ip)->z_is_ctldir);
153 zfsctl_is_snapdir(struct inode *ip)
155 return (zfsctl_is_node(ip) && (ip->i_ino <= ZFSCTL_INO_SNAPDIRS));
159 * Allocate a new inode with the passed id and ops.
161 static struct inode *
162 zfsctl_inode_alloc(zfs_sb_t *zsb, uint64_t id,
163 const struct file_operations *fops, const struct inode_operations *ops)
165 struct timespec now = current_fs_time(zsb->z_sb);
169 ip = new_inode(zsb->z_sb);
174 ASSERT3P(zp->z_dirlocks, ==, NULL);
175 ASSERT3P(zp->z_acl_cached, ==, NULL);
176 ASSERT3P(zp->z_xattr_cached, ==, NULL);
179 zp->z_atime_dirty = 0;
180 zp->z_zn_prefetch = 0;
196 zp->z_is_zvol = B_FALSE;
197 zp->z_is_mapped = B_FALSE;
198 zp->z_is_ctldir = B_TRUE;
199 zp->z_is_sa = B_FALSE;
200 zp->z_is_stale = B_FALSE;
202 ip->i_mode = (S_IFDIR | S_IRUGO | S_IXUGO);
205 ip->i_blkbits = SPA_MINBLOCKSHIFT;
212 if (insert_inode_locked(ip)) {
213 unlock_new_inode(ip);
218 mutex_enter(&zsb->z_znodes_lock);
219 list_insert_tail(&zsb->z_all_znodes, zp);
222 mutex_exit(&zsb->z_znodes_lock);
224 unlock_new_inode(ip);
230 * Lookup the inode with given id, it will be allocated if needed.
232 static struct inode *
233 zfsctl_inode_lookup(zfs_sb_t *zsb, uint64_t id,
234 const struct file_operations *fops, const struct inode_operations *ops)
236 struct inode *ip = NULL;
239 ip = ilookup(zsb->z_sb, (unsigned long)id);
243 /* May fail due to concurrent zfsctl_inode_alloc() */
244 ip = zfsctl_inode_alloc(zsb, id, fops, ops);
251 * Free zfsctl inode specific structures, currently there are none.
254 zfsctl_inode_destroy(struct inode *ip)
260 * An inode is being evicted from the cache.
263 zfsctl_inode_inactive(struct inode *ip)
265 if (zfsctl_is_snapdir(ip))
266 zfsctl_snapdir_inactive(ip);
270 * Create the '.zfs' directory. This directory is cached as part of the VFS
271 * structure. This results in a hold on the zfs_sb_t. The code in zfs_umount()
272 * therefore checks against a vfs_count of 2 instead of 1. This reference
273 * is removed when the ctldir is destroyed in the unmount. All other entities
274 * under the '.zfs' directory are created dynamically as needed.
276 * Because the dynamically created '.zfs' directory entries assume the use
277 * of 64-bit inode numbers this support must be disabled on 32-bit systems.
280 zfsctl_create(zfs_sb_t *zsb)
282 #if defined(CONFIG_64BIT)
283 ASSERT(zsb->z_ctldir == NULL);
285 zsb->z_ctldir = zfsctl_inode_alloc(zsb, ZFSCTL_INO_ROOT,
286 &zpl_fops_root, &zpl_ops_root);
287 if (zsb->z_ctldir == NULL)
293 #endif /* CONFIG_64BIT */
297 * Destroy the '.zfs' directory. Only called when the filesystem is unmounted.
300 zfsctl_destroy(zfs_sb_t *zsb)
303 zsb->z_ctldir = NULL;
307 * Given a root znode, retrieve the associated .zfs directory.
308 * Add a hold to the vnode and return it.
311 zfsctl_root(znode_t *zp)
313 ASSERT(zfs_has_ctldir(zp));
314 igrab(ZTOZSB(zp)->z_ctldir);
315 return (ZTOZSB(zp)->z_ctldir);
320 zfsctl_fid(struct inode *ip, fid_t *fidp)
322 znode_t *zp = ITOZ(ip);
323 zfs_sb_t *zsb = ITOZSB(ip);
324 uint64_t object = zp->z_id;
330 if (fidp->fid_len < SHORT_FID_LEN) {
331 fidp->fid_len = SHORT_FID_LEN;
336 zfid = (zfid_short_t *)fidp;
338 zfid->zf_len = SHORT_FID_LEN;
340 for (i = 0; i < sizeof (zfid->zf_object); i++)
341 zfid->zf_object[i] = (uint8_t)(object >> (8 * i));
343 /* .zfs znodes always have a generation number of 0 */
344 for (i = 0; i < sizeof (zfid->zf_gen); i++)
352 zfsctl_snapshot_zname(struct inode *ip, const char *name, int len, char *zname)
354 objset_t *os = ITOZSB(ip)->z_os;
356 if (snapshot_namecheck(name, NULL, NULL) != 0)
359 dmu_objset_name(os, zname);
360 if ((strlen(zname) + 1 + strlen(name)) >= len)
361 return (ENAMETOOLONG);
363 (void) strcat(zname, "@");
364 (void) strcat(zname, name);
370 zfsctl_snapshot_zpath(struct path *path, int len, char *zpath)
372 char *path_buffer, *path_ptr;
373 int path_len, error = 0;
375 path_buffer = kmem_alloc(len, KM_SLEEP);
377 path_ptr = d_path(path, path_buffer, len);
378 if (IS_ERR(path_ptr)) {
379 error = -PTR_ERR(path_ptr);
383 path_len = path_buffer + len - 1 - path_ptr;
384 if (path_len > len) {
389 memcpy(zpath, path_ptr, path_len);
390 zpath[path_len] = '\0';
392 kmem_free(path_buffer, len);
398 * Special case the handling of "..".
402 zfsctl_root_lookup(struct inode *dip, char *name, struct inode **ipp,
403 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
405 zfs_sb_t *zsb = ITOZSB(dip);
410 if (strcmp(name, "..") == 0) {
411 *ipp = dip->i_sb->s_root->d_inode;
412 } else if (strcmp(name, ZFS_SNAPDIR_NAME) == 0) {
413 *ipp = zfsctl_inode_lookup(zsb, ZFSCTL_INO_SNAPDIR,
414 &zpl_fops_snapdir, &zpl_ops_snapdir);
415 } else if (strcmp(name, ZFS_SHAREDIR_NAME) == 0) {
416 *ipp = zfsctl_inode_lookup(zsb, ZFSCTL_INO_SHARES,
417 &zpl_fops_shares, &zpl_ops_shares);
431 * Lookup entry point for the 'snapshot' directory. Try to open the
432 * snapshot if it exist, creating the pseudo filesystem inode as necessary.
433 * Perform a mount of the associated dataset on top of the inode.
437 zfsctl_snapdir_lookup(struct inode *dip, char *name, struct inode **ipp,
438 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
440 zfs_sb_t *zsb = ITOZSB(dip);
446 error = dmu_snapshot_lookup(zsb->z_os, name, &id);
452 *ipp = zfsctl_inode_lookup(zsb, ZFSCTL_INO_SNAPDIRS - id,
453 &simple_dir_operations, &simple_dir_inode_operations);
455 #ifdef HAVE_AUTOMOUNT
456 (*ipp)->i_flags |= S_AUTOMOUNT;
457 #endif /* HAVE_AUTOMOUNT */
468 zfsctl_rename_snap(zfs_sb_t *zsb, zfs_snapentry_t *sep, const char *name)
472 ASSERT(MUTEX_HELD(&zsb->z_ctldir_lock));
476 * Change the name in the AVL tree.
478 avl_remove(&zsb->z_ctldir_snaps, sep);
479 (void) strcpy(sep->se_name, name);
480 VERIFY(avl_find(&zsb->z_ctldir_snaps, sep, &where) == NULL);
481 avl_insert(&zsb->z_ctldir_snaps, sep, where);
485 * Renaming a directory under '.zfs/snapshot' will automatically trigger
486 * a rename of the snapshot to the new given name. The rename is confined
487 * to the '.zfs/snapshot' directory snapshots cannot be moved elsewhere.
491 zfsctl_snapdir_rename(struct inode *sdip, char *sname,
492 struct inode *tdip, char *tname, cred_t *cr, int flags)
494 zfs_sb_t *zsb = ITOZSB(sdip);
495 zfs_snapentry_t search, *sep;
497 char *to, *from, *real;
502 to = kmem_alloc(MAXNAMELEN, KM_SLEEP);
503 from = kmem_alloc(MAXNAMELEN, KM_SLEEP);
504 real = kmem_alloc(MAXNAMELEN, KM_SLEEP);
506 if (zsb->z_case == ZFS_CASE_INSENSITIVE) {
507 error = dmu_snapshot_realname(zsb->z_os, sname, real,
511 } else if (error != ENOTSUP) {
516 error = zfsctl_snapshot_zname(sdip, sname, MAXNAMELEN, from);
518 error = zfsctl_snapshot_zname(tdip, tname, MAXNAMELEN, to);
520 error = zfs_secpolicy_rename_perms(from, to, cr);
525 * Cannot move snapshots out of the snapdir.
533 * No-op when names are identical.
535 if (strcmp(sname, tname) == 0) {
540 mutex_enter(&zsb->z_ctldir_lock);
542 error = dmu_objset_rename(from, to, B_FALSE);
546 search.se_name = (char *)sname;
547 sep = avl_find(&zsb->z_ctldir_snaps, &search, &where);
549 zfsctl_rename_snap(zsb, sep, tname);
552 mutex_exit(&zsb->z_ctldir_lock);
554 kmem_free(from, MAXNAMELEN);
555 kmem_free(to, MAXNAMELEN);
556 kmem_free(real, MAXNAMELEN);
564 * Removing a directory under '.zfs/snapshot' will automatically trigger
565 * the removal of the snapshot with the given name.
569 zfsctl_snapdir_remove(struct inode *dip, char *name, cred_t *cr, int flags)
571 zfs_sb_t *zsb = ITOZSB(dip);
572 char *snapname, *real;
577 snapname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
578 real = kmem_alloc(MAXNAMELEN, KM_SLEEP);
580 if (zsb->z_case == ZFS_CASE_INSENSITIVE) {
581 error = dmu_snapshot_realname(zsb->z_os, name, real,
585 } else if (error != ENOTSUP) {
590 error = zfsctl_snapshot_zname(dip, name, MAXNAMELEN, snapname);
592 error = zfs_secpolicy_destroy_perms(snapname, cr);
596 error = zfsctl_unmount_snapshot(zsb, name, MNT_FORCE);
597 if ((error == 0) || (error == ENOENT))
598 error = dmu_objset_destroy(snapname, B_FALSE);
600 kmem_free(snapname, MAXNAMELEN);
601 kmem_free(real, MAXNAMELEN);
609 * Creating a directory under '.zfs/snapshot' will automatically trigger
610 * the creation of a new snapshot with the given name.
614 zfsctl_snapdir_mkdir(struct inode *dip, char *dirname, vattr_t *vap,
615 struct inode **ipp, cred_t *cr, int flags)
617 zfs_sb_t *zsb = ITOZSB(dip);
621 dsname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
623 if (snapshot_namecheck(dirname, NULL, NULL) != 0) {
628 dmu_objset_name(zsb->z_os, dsname);
630 error = zfs_secpolicy_snapshot_perms(dsname, cr);
635 error = dmu_objset_snapshot(dsname, dirname,
636 NULL, NULL, B_FALSE, B_FALSE, -1);
640 error = zfsctl_snapdir_lookup(dip, dirname, ipp,
644 kmem_free(dsname, MAXNAMELEN);
650 * When a .zfs/snapshot/<snapshot> inode is evicted they must be removed
651 * from the snapshot list. This will normally happen as part of the auto
652 * unmount, however in the case of a manual snapshot unmount this will be
653 * the only notification we receive.
656 zfsctl_snapdir_inactive(struct inode *ip)
658 zfs_sb_t *zsb = ITOZSB(ip);
659 zfs_snapentry_t *sep, *next;
661 mutex_enter(&zsb->z_ctldir_lock);
663 sep = avl_first(&zsb->z_ctldir_snaps);
664 while (sep != NULL) {
665 next = AVL_NEXT(&zsb->z_ctldir_snaps, sep);
667 if (sep->se_inode == ip) {
668 avl_remove(&zsb->z_ctldir_snaps, sep);
669 taskq_cancel_id(zfs_expire_taskq, sep->se_taskqid);
670 zfsctl_sep_free(sep);
676 mutex_exit(&zsb->z_ctldir_lock);
680 * Attempt to unmount a snapshot by making a call to user space.
681 * There is no assurance that this can or will succeed, is just a
682 * best effort. In the case where it does fail, perhaps because
683 * it's in use, the unmount will fail harmlessly.
685 #define SET_UNMOUNT_CMD \
686 "exec 0</dev/null " \
689 "umount -t zfs -n %s'%s'"
692 __zfsctl_unmount_snapshot(zfs_snapentry_t *sep, int flags)
694 char *argv[] = { "/bin/sh", "-c", NULL, NULL };
695 char *envp[] = { NULL };
698 argv[2] = kmem_asprintf(SET_UNMOUNT_CMD,
699 flags & MNT_FORCE ? "-f " : "", sep->se_path);
700 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
704 * The umount system utility will return 256 on error. We must
705 * assume this error is because the file system is busy so it is
706 * converted to the more sensible EBUSY.
712 * This was the result of a manual unmount, cancel the delayed work
713 * to prevent zfsctl_expire_snapshot() from attempting a unmount.
715 if ((error == 0) && !(flags & MNT_EXPIRE))
716 taskq_cancel_id(zfs_expire_taskq, sep->se_taskqid);
723 zfsctl_unmount_snapshot(zfs_sb_t *zsb, char *name, int flags)
725 zfs_snapentry_t search;
726 zfs_snapentry_t *sep;
729 mutex_enter(&zsb->z_ctldir_lock);
731 search.se_name = name;
732 sep = avl_find(&zsb->z_ctldir_snaps, &search, NULL);
734 avl_remove(&zsb->z_ctldir_snaps, sep);
735 error = __zfsctl_unmount_snapshot(sep, flags);
737 avl_add(&zsb->z_ctldir_snaps, sep);
739 zfsctl_sep_free(sep);
744 mutex_exit(&zsb->z_ctldir_lock);
745 ASSERT3S(error, >=, 0);
751 * Traverse all mounted snapshots and attempt to unmount them. This
752 * is best effort, on failure EEXIST is returned and count will be set
753 * to the number of file snapshots which could not be unmounted.
756 zfsctl_unmount_snapshots(zfs_sb_t *zsb, int flags, int *count)
758 zfs_snapentry_t *sep, *next;
763 ASSERT(zsb->z_ctldir != NULL);
764 mutex_enter(&zsb->z_ctldir_lock);
766 sep = avl_first(&zsb->z_ctldir_snaps);
767 while (sep != NULL) {
768 next = AVL_NEXT(&zsb->z_ctldir_snaps, sep);
769 avl_remove(&zsb->z_ctldir_snaps, sep);
770 error = __zfsctl_unmount_snapshot(sep, flags);
771 if (error == EBUSY) {
772 avl_add(&zsb->z_ctldir_snaps, sep);
775 zfsctl_sep_free(sep);
781 mutex_exit(&zsb->z_ctldir_lock);
783 return ((*count > 0) ? EEXIST : 0);
786 #define SET_MOUNT_CMD \
787 "exec 0</dev/null " \
790 "mount -t zfs -n '%s' '%s'"
793 zfsctl_mount_snapshot(struct path *path, int flags)
795 struct dentry *dentry = path->dentry;
796 struct inode *ip = dentry->d_inode;
797 zfs_sb_t *zsb = ITOZSB(ip);
798 char *full_name, *full_path;
799 zfs_snapentry_t *sep;
800 zfs_snapentry_t search;
801 char *argv[] = { "/bin/sh", "-c", NULL, NULL };
802 char *envp[] = { NULL };
807 full_name = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
808 full_path = kmem_zalloc(PATH_MAX, KM_SLEEP);
810 error = zfsctl_snapshot_zname(ip, dname(dentry), MAXNAMELEN, full_name);
814 error = zfsctl_snapshot_zpath(path, PATH_MAX, full_path);
819 * Attempt to mount the snapshot from user space. Normally this
820 * would be done using the vfs_kern_mount() function, however that
821 * function is marked GPL-only and cannot be used. On error we
822 * careful to log the real error to the console and return EISDIR
823 * to safely abort the automount. This should be very rare.
825 argv[2] = kmem_asprintf(SET_MOUNT_CMD, full_name, full_path);
826 error = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
829 printk("ZFS: Unable to automount %s at %s: %d\n",
830 full_name, full_path, error);
835 mutex_enter(&zsb->z_ctldir_lock);
838 * Ensure a previous entry does not exist, if it does safely remove
839 * it any cancel the outstanding expiration. This can occur when a
840 * snapshot is manually unmounted and then an automount is triggered.
842 search.se_name = full_name;
843 sep = avl_find(&zsb->z_ctldir_snaps, &search, NULL);
845 avl_remove(&zsb->z_ctldir_snaps, sep);
846 taskq_cancel_id(zfs_expire_taskq, sep->se_taskqid);
847 zfsctl_sep_free(sep);
850 sep = zfsctl_sep_alloc();
851 sep->se_name = full_name;
852 sep->se_path = full_path;
854 avl_add(&zsb->z_ctldir_snaps, sep);
856 sep->se_taskqid = taskq_dispatch_delay(zfs_expire_taskq,
857 zfsctl_expire_snapshot, sep, TQ_SLEEP,
858 ddi_get_lbolt() + zfs_expire_snapshot * HZ);
860 mutex_exit(&zsb->z_ctldir_lock);
863 kmem_free(full_name, MAXNAMELEN);
864 kmem_free(full_path, PATH_MAX);
873 * Check if this super block has a matching objset id.
876 zfsctl_test_super(struct super_block *sb, void *objsetidp)
878 zfs_sb_t *zsb = sb->s_fs_info;
879 uint64_t objsetid = *(uint64_t *)objsetidp;
881 return (dmu_objset_id(zsb->z_os) == objsetid);
885 * Prevent a new super block from being allocated if an existing one
886 * could not be located. We only want to preform a lookup operation.
889 zfsctl_set_super(struct super_block *sb, void *objsetidp)
895 zfsctl_lookup_objset(struct super_block *sb, uint64_t objsetid, zfs_sb_t **zsbp)
897 zfs_sb_t *zsb = sb->s_fs_info;
898 struct super_block *sbp;
899 zfs_snapentry_t *sep;
903 ASSERT(zsb->z_ctldir != NULL);
905 mutex_enter(&zsb->z_ctldir_lock);
908 * Verify that the snapshot is mounted.
910 sep = avl_first(&zsb->z_ctldir_snaps);
911 while (sep != NULL) {
912 error = dmu_snapshot_lookup(zsb->z_os, sep->se_name, &id);
919 sep = AVL_NEXT(&zsb->z_ctldir_snaps, sep);
924 * Lookup the mounted root rather than the covered mount
925 * point. This may fail if the snapshot has just been
926 * unmounted by an unrelated user space process. This
927 * race cannot occur to an expired mount point because
928 * we hold the zsb->z_ctldir_lock to prevent the race.
930 sbp = zpl_sget(&zpl_fs_type, zfsctl_test_super,
931 zfsctl_set_super, 0, &id);
933 error = -PTR_ERR(sbp);
935 *zsbp = sbp->s_fs_info;
936 deactivate_super(sbp);
942 mutex_exit(&zsb->z_ctldir_lock);
943 ASSERT3S(error, >=, 0);
950 zfsctl_shares_lookup(struct inode *dip, char *name, struct inode **ipp,
951 int flags, cred_t *cr, int *direntflags, pathname_t *realpnp)
953 zfs_sb_t *zsb = ITOZSB(dip);
960 if (zsb->z_shares_dir == 0) {
965 error = zfs_zget(zsb, zsb->z_shares_dir, &dzp);
971 error = zfs_lookup(ZTOI(dzp), name, &ip, 0, cr, NULL, NULL);
981 * Initialize the various pieces we'll need to create and manipulate .zfs
982 * directories. Currently this is unused but available.
987 zfs_expire_taskq = taskq_create("z_unmount", 1, maxclsyspri,
988 1, 8, TASKQ_PREPOPULATE);
992 * Cleanup the various pieces we needed for .zfs directories. In particular
993 * ensure the expiry timer is canceled safely.
998 taskq_destroy(zfs_expire_taskq);
1001 module_param(zfs_expire_snapshot, int, 0644);
1002 MODULE_PARM_DESC(zfs_expire_snapshot, "Seconds to expire .zfs/snapshot");