/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * ZFS control directory (a.k.a. ".zfs")

 *

 * This directory provides a common location for all ZFS meta-objects.

 * Currently, this is only the 'snapshot' directory, but this may expand in the

 * future.  The elements are built using the GFS primitives, as the hierarchy

 * does not actually exist on disk.

 *

 * For 'snapshot', we don't want to have all snapshots always mounted, because

 * this would take up a huge amount of space in /etc/mnttab.  We have three

 * types of objects:

 *

 * 	ctldir ------> snapshotdir -------> snapshot

 *                                             |

 *                                             |

 *                                             V

 *                                         mounted fs

 *

 * The 'snapshot' node contains just enough information to lookup '..' and act

 * as a mountpoint for the snapshot.  Whenever we lookup a specific snapshot, we

 * perform an automount of the underlying filesystem and return the

 * corresponding vnode.

 *

 * All mounts are handled automatically by the kernel, but unmounts are

 * (currently) handled from user land.  The main reason is that there is no

 * reliable way to auto-unmount the filesystem when it's "no longer in use".

 * When the user unmounts a filesystem, we call zfsctl_unmount(), which

 * unmounts any snapshots within the snapshot directory.

 *

 * The '.zfs', '.zfs/snapshot', and all directories created under

 * '.zfs/snapshot' (ie: '.zfs/snapshot/<snapname>') are all GFS nodes and

 * share the same vfs_t as the head filesystem (what '.zfs' lives under).

 *

 * File systems mounted ontop of the GFS nodes '.zfs/snapshot/<snapname>'

 * (ie: snapshots) are ZFS nodes and have their own unique vfs_t.

 * However, vnodes within these mounted on file systems have their v_vfsp

 * fields set to the head filesystem to make NFS happy (see

 * zfsctl_snapdir_lookup()). We VFS_HOLD the head filesystem's vfs_t

 * so that it cannot be freed until all snapshots have been unmounted.

 */

#include <fs/fs_subr.h>

#include <sys/zfs_ctldir.h>

#include <sys/zfs_ioctl.h>

#include <sys/zfs_vfsops.h>

#include <sys/vfs_opreg.h>

#include <sys/gfs.h>

#include <sys/stat.h>

#include <sys/dmu.h>

#include <sys/dsl_deleg.h>

#include <sys/mount.h>

#include <sys/sunddi.h>

#include "zfs_namecheck.h"

typedef struct zfsctl_node {

	gfs_dir_t	zc_gfs_private;

	uint64_t	zc_id;

	timestruc_t	zc_cmtime;	/* ctime and mtime, always the same */

} zfsctl_node_t;

typedef struct zfsctl_snapdir {

	zfsctl_node_t	sd_node;

	kmutex_t	sd_lock;

	avl_tree_t	sd_snaps;

} zfsctl_snapdir_t;

typedef struct {

	char		*se_name;

	vnode_t		*se_root;

	avl_node_t	se_node;

} zfs_snapentry_t;

static int

snapentry_compare(const void *a, const void *b)

{

	const zfs_snapentry_t *sa = a;

	const zfs_snapentry_t *sb = b;

	int ret = strcmp(sa->se_name, sb->se_name);

	if (ret < 0)

		return (-1);

	else if (ret > 0)

		return (1);

	else

		return (0);

}

vnodeops_t *zfsctl_ops_root;

vnodeops_t *zfsctl_ops_snapdir;

vnodeops_t *zfsctl_ops_snapshot;

vnodeops_t *zfsctl_ops_shares;

vnodeops_t *zfsctl_ops_shares_dir;

static const fs_operation_def_t zfsctl_tops_root[];

static const fs_operation_def_t zfsctl_tops_snapdir[];

static const fs_operation_def_t zfsctl_tops_snapshot[];

static const fs_operation_def_t zfsctl_tops_shares[];

static vnode_t *zfsctl_mknode_snapdir(vnode_t *);

static vnode_t *zfsctl_mknode_shares(vnode_t *);

static vnode_t *zfsctl_snapshot_mknode(vnode_t *, uint64_t objset);

static int zfsctl_unmount_snap(zfs_snapentry_t *, int, cred_t *);

static gfs_opsvec_t zfsctl_opsvec[] = {

	{ ".zfs", zfsctl_tops_root, &zfsctl_ops_root },

	{ ".zfs/snapshot", zfsctl_tops_snapdir, &zfsctl_ops_snapdir },

	{ ".zfs/snapshot/vnode", zfsctl_tops_snapshot, &zfsctl_ops_snapshot },

	{ ".zfs/shares", zfsctl_tops_shares, &zfsctl_ops_shares_dir },

	{ ".zfs/shares/vnode", zfsctl_tops_shares, &zfsctl_ops_shares },

	{ NULL }

};

/*

 * Root directory elements.  We only have two entries

 * snapshot and shares.

 */

static gfs_dirent_t zfsctl_root_entries[] = {

	{ "snapshot", zfsctl_mknode_snapdir, GFS_CACHE_VNODE },

	{ "shares", zfsctl_mknode_shares, GFS_CACHE_VNODE },

	{ NULL }

};

/* include . and .. in the calculation */

#define	NROOT_ENTRIES	((sizeof (zfsctl_root_entries) / \

    sizeof (gfs_dirent_t)) + 1)

/*

 * Initialize the various GFS pieces we'll need to create and manipulate .zfs

 * directories.  This is called from the ZFS init routine, and initializes the

 * vnode ops vectors that we'll be using.

 */

void

zfsctl_init(void)

{

	VERIFY(gfs_make_opsvec(zfsctl_opsvec) == 0);

}

void

zfsctl_fini(void)

{

	/*

	 * Remove vfsctl vnode ops

	 */

	if (zfsctl_ops_root)

		vn_freevnodeops(zfsctl_ops_root);

	if (zfsctl_ops_snapdir)

		vn_freevnodeops(zfsctl_ops_snapdir);

	if (zfsctl_ops_snapshot)

		vn_freevnodeops(zfsctl_ops_snapshot);

	if (zfsctl_ops_shares)

		vn_freevnodeops(zfsctl_ops_shares);

	if (zfsctl_ops_shares_dir)

		vn_freevnodeops(zfsctl_ops_shares_dir);

	zfsctl_ops_root = NULL;

	zfsctl_ops_snapdir = NULL;

	zfsctl_ops_snapshot = NULL;

	zfsctl_ops_shares = NULL;

	zfsctl_ops_shares_dir = NULL;

}

boolean_t

zfsctl_is_node(vnode_t *vp)

{

	return (vn_matchops(vp, zfsctl_ops_root) ||

	    vn_matchops(vp, zfsctl_ops_snapdir) ||

	    vn_matchops(vp, zfsctl_ops_snapshot) ||

	    vn_matchops(vp, zfsctl_ops_shares) ||

	    vn_matchops(vp, zfsctl_ops_shares_dir));

}

/*

 * Return the inode number associated with the 'snapshot' or

 * 'shares' directory.

 */

/* ARGSUSED */

static ino64_t

zfsctl_root_inode_cb(vnode_t *vp, int index)

{

	zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;

	ASSERT(index <= 2);

	if (index == 0)

		return (ZFSCTL_INO_SNAPDIR);

	return (zfsvfs->z_shares_dir);

}

/*

 * Create the '.zfs' directory.  This directory is cached as part of the VFS

 * structure.  This results in a hold on the vfs_t.  The code in zfs_umount()

 * therefore checks against a vfs_count of 2 instead of 1.  This reference

 * is removed when the ctldir is destroyed in the unmount.

 */

void

zfsctl_create(zfsvfs_t *zfsvfs)

{

	vnode_t *vp, *rvp;

	zfsctl_node_t *zcp;

	uint64_t crtime[2];

	ASSERT(zfsvfs->z_ctldir == NULL);

	vp = gfs_root_create(sizeof (zfsctl_node_t), zfsvfs->z_vfs,

	    zfsctl_ops_root, ZFSCTL_INO_ROOT, zfsctl_root_entries,

	    zfsctl_root_inode_cb, MAXNAMELEN, NULL, NULL);

	zcp = vp->v_data;

	zcp->zc_id = ZFSCTL_INO_ROOT;

	VERIFY(VFS_ROOT(zfsvfs->z_vfs, &rvp) == 0);

	VERIFY(0 == sa_lookup(VTOZ(rvp)->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs),

	    &crtime, sizeof (crtime)));

	ZFS_TIME_DECODE(&zcp->zc_cmtime, crtime);

	VN_RELE(rvp);

	/*

	 * We're only faking the fact that we have a root of a filesystem for

	 * the sake of the GFS interfaces.  Undo the flag manipulation it did

	 * for us.

	 */

	vp->v_flag &= ~(VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT);

	zfsvfs->z_ctldir = vp;

}

/*

 * Destroy the '.zfs' directory.  Only called when the filesystem is unmounted.

 * There might still be more references if we were force unmounted, but only

 * new zfs_inactive() calls can occur and they don't reference .zfs

 */

void

zfsctl_destroy(zfsvfs_t *zfsvfs)

{

	VN_RELE(zfsvfs->z_ctldir);

	zfsvfs->z_ctldir = NULL;

}

/*

 * Given a root znode, retrieve the associated .zfs directory.

 * Add a hold to the vnode and return it.

 */

vnode_t *

zfsctl_root(znode_t *zp)

{

	ASSERT(zfs_has_ctldir(zp));

	VN_HOLD(zp->z_zfsvfs->z_ctldir);

	return (zp->z_zfsvfs->z_ctldir);

}

/*

 * Common open routine.  Disallow any write access.

 */

/* ARGSUSED */

static int

zfsctl_common_open(vnode_t **vpp, int flags, cred_t *cr, caller_context_t *ct)

{

	if (flags & FWRITE)

		return (EACCES);

	return (0);

}

/*

 * Common close routine.  Nothing to do here.

 */

/* ARGSUSED */

static int

zfsctl_common_close(vnode_t *vpp, int flags, int count, offset_t off,

    cred_t *cr, caller_context_t *ct)

{

	return (0);

}

/*

 * Common access routine.  Disallow writes.

 */

/* ARGSUSED */

static int

zfsctl_common_access(vnode_t *vp, int mode, int flags, cred_t *cr,

    caller_context_t *ct)

{

	if (flags & V_ACE_MASK) {

		if (mode & ACE_ALL_WRITE_PERMS)

			return (EACCES);

	} else {

		if (mode & VWRITE)

			return (EACCES);

	}

	return (0);

}

/*

 * Common getattr function.  Fill in basic information.

 */

static void

zfsctl_common_getattr(vnode_t *vp, vattr_t *vap)

{

	timestruc_t	now;

	vap->va_uid = 0;

	vap->va_gid = 0;

	vap->va_rdev = 0;

	/*

	 * We are a purely virtual object, so we have no

	 * blocksize or allocated blocks.

	 */

	vap->va_blksize = 0;

	vap->va_nblocks = 0;

	vap->va_seq = 0;

	vap->va_fsid = vp->v_vfsp->vfs_dev;

	vap->va_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP |

	    S_IROTH | S_IXOTH;

	vap->va_type = VDIR;

	/*

	 * We live in the now (for atime).

	 */

	gethrestime(&now);

	vap->va_atime = now;

}

/*ARGSUSED*/

static int

zfsctl_common_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)

{

	zfsvfs_t	*zfsvfs = vp->v_vfsp->vfs_data;

	zfsctl_node_t	*zcp = vp->v_data;

	uint64_t	object = zcp->zc_id;

	zfid_short_t	*zfid;

	int		i;

	ZFS_ENTER(zfsvfs);

	if (fidp->fid_len < SHORT_FID_LEN) {

		fidp->fid_len = SHORT_FID_LEN;

		ZFS_EXIT(zfsvfs);

		return (ENOSPC);

	}

	zfid = (zfid_short_t *)fidp;

	zfid->zf_len = SHORT_FID_LEN;

	for (i = 0; i < sizeof (zfid->zf_object); i++)

		zfid->zf_object[i] = (uint8_t)(object >> (8 * i));

	/* .zfs znodes always have a generation number of 0 */

	for (i = 0; i < sizeof (zfid->zf_gen); i++)

		zfid->zf_gen[i] = 0;

	ZFS_EXIT(zfsvfs);

	return (0);

}

/*ARGSUSED*/

static int

zfsctl_shares_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)

{

	zfsvfs_t	*zfsvfs = vp->v_vfsp->vfs_data;

	znode_t		*dzp;

	int		error;

	ZFS_ENTER(zfsvfs);

	if (zfsvfs->z_shares_dir == 0) {

		ZFS_EXIT(zfsvfs);

		return (ENOTSUP);

	}

	if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp)) == 0) {

		error = VOP_FID(ZTOV(dzp), fidp, ct);

		VN_RELE(ZTOV(dzp));

	}

	ZFS_EXIT(zfsvfs);

	return (error);

}

/*

 * .zfs inode namespace

 *

 * We need to generate unique inode numbers for all files and directories

 * within the .zfs pseudo-filesystem.  We use the following scheme:

 *

 * 	ENTRY			ZFSCTL_INODE

 * 	.zfs			1

 * 	.zfs/snapshot		2

 * 	.zfs/snapshot/<snap>	objectid(snap)

 */

#define	ZFSCTL_INO_SNAP(id)	(id)

/*

 * Get root directory attributes.

 */

/* ARGSUSED */

static int

zfsctl_root_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,

    caller_context_t *ct)

{

	zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;

	zfsctl_node_t *zcp = vp->v_data;

	ZFS_ENTER(zfsvfs);

	vap->va_nodeid = ZFSCTL_INO_ROOT;

	vap->va_nlink = vap->va_size = NROOT_ENTRIES;

	vap->va_mtime = vap->va_ctime = zcp->zc_cmtime;

	zfsctl_common_getattr(vp, vap);

	ZFS_EXIT(zfsvfs);

	return (0);

}

/*

 * Special case the handling of "..".

 */

/* ARGSUSED */

int

zfsctl_root_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,

    int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,

    int *direntflags, pathname_t *realpnp)

{

	zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;

	int err;

	/*

	 * No extended attributes allowed under .zfs

	 */

	if (flags & LOOKUP_XATTR)

		return (EINVAL);

	ZFS_ENTER(zfsvfs);

	if (strcmp(nm, "..") == 0) {

		err = VFS_ROOT(dvp->v_vfsp, vpp);

	} else {

		err = gfs_vop_lookup(dvp, nm, vpp, pnp, flags, rdir,

		    cr, ct, direntflags, realpnp);

	}

	ZFS_EXIT(zfsvfs);

	return (err);

}

static int

zfsctl_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,

    caller_context_t *ct)

{

	/*

	 * We only care about ACL_ENABLED so that libsec can

	 * display ACL correctly and not default to POSIX draft.

	 */

	if (cmd == _PC_ACL_ENABLED) {

		*valp = _ACL_ACE_ENABLED;

		return (0);

	}

	return (fs_pathconf(vp, cmd, valp, cr, ct));

}

static const fs_operation_def_t zfsctl_tops_root[] = {

	{ VOPNAME_OPEN,		{ .vop_open = zfsctl_common_open }	},

	{ VOPNAME_CLOSE,	{ .vop_close = zfsctl_common_close }	},

	{ VOPNAME_IOCTL,	{ .error = fs_inval }			},

	{ VOPNAME_GETATTR,	{ .vop_getattr = zfsctl_root_getattr }	},

	{ VOPNAME_ACCESS,	{ .vop_access = zfsctl_common_access }	},

	{ VOPNAME_READDIR,	{ .vop_readdir = gfs_vop_readdir } 	},

	{ VOPNAME_LOOKUP,	{ .vop_lookup = zfsctl_root_lookup }	},

	{ VOPNAME_SEEK,		{ .vop_seek = fs_seek }			},

	{ VOPNAME_INACTIVE,	{ .vop_inactive = gfs_vop_inactive }	},

	{ VOPNAME_PATHCONF,	{ .vop_pathconf = zfsctl_pathconf }	},

	{ VOPNAME_FID,		{ .vop_fid = zfsctl_common_fid	}	},

	{ NULL }

};

static int

zfsctl_snapshot_zname(vnode_t *vp, const char *name, int len, char *zname)

{

	objset_t *os = ((zfsvfs_t *)((vp)->v_vfsp->vfs_data))->z_os;

	if (snapshot_namecheck(name, NULL, NULL) != 0)