/*

 * 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 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 *

 * Portions Copyright 2007 Ramprakash Jelari

 */

#include <libintl.h>

#include <libuutil.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <zone.h>

#include <libzfs.h>

#include "libzfs_impl.h"

/*

 * Structure to keep track of dataset state.  Before changing the 'sharenfs' or

 * 'mountpoint' property, we record whether the filesystem was previously

 * mounted/shared.  This prior state dictates whether we remount/reshare the

 * dataset after the property has been changed.

 *

 * The interface consists of the following sequence of functions:

 *

 * 	changelist_gather()

 * 	changelist_prefix()

 * 	< change property >

 * 	changelist_postfix()

 * 	changelist_free()

 *

 * Other interfaces:

 *

 * changelist_remove() - remove a node from a gathered list

 * changelist_rename() - renames all datasets appropriately when doing a rename

 * changelist_unshare() - unshares all the nodes in a given changelist

 * changelist_haszonedchild() - check if there is any child exported to

 *				a local zone

 */

typedef struct prop_changenode {

	zfs_handle_t		*cn_handle;

	int			cn_shared;

	int			cn_mounted;

	int			cn_zoned;

	boolean_t		cn_needpost;	/* is postfix() needed? */

	uu_list_node_t		cn_listnode;

} prop_changenode_t;

struct prop_changelist {

	zfs_prop_t		cl_prop;

	zfs_prop_t		cl_realprop;

	zfs_prop_t		cl_shareprop;  /* used with sharenfs/sharesmb */

	uu_list_pool_t		*cl_pool;

	uu_list_t		*cl_list;

	boolean_t		cl_waslegacy;

	boolean_t		cl_allchildren;

	boolean_t		cl_alldependents;

	int			cl_mflags;	/* Mount flags */

	int			cl_gflags;	/* Gather request flags */

	boolean_t		cl_haszonedchild;

	boolean_t		cl_sorted;

};

/*

 * If the property is 'mountpoint', go through and unmount filesystems as

 * necessary.  We don't do the same for 'sharenfs', because we can just re-share

 * with different options without interrupting service. We do handle 'sharesmb'

 * since there may be old resource names that need to be removed.

 */

int

changelist_prefix(prop_changelist_t *clp)

{

	prop_changenode_t *cn;

	int ret = 0;

	if (clp->cl_prop != ZFS_PROP_MOUNTPOINT &&

	    clp->cl_prop != ZFS_PROP_SHARESMB)

		return (0);

	for (cn = uu_list_first(clp->cl_list); cn != NULL;

	    cn = uu_list_next(clp->cl_list, cn)) {

		/* if a previous loop failed, set the remaining to false */

		if (ret == -1) {

			cn->cn_needpost = B_FALSE;

			continue;

		}

		/*

		 * If we are in the global zone, but this dataset is exported

		 * to a local zone, do nothing.

		 */

		if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)

			continue;

		if (ZFS_IS_VOLUME(cn->cn_handle)) {

			switch (clp->cl_realprop) {

			case ZFS_PROP_NAME:

				/*

				 * If this was a rename, unshare the zvol, and

				 * remove the /dev/zvol links.

				 */

				(void) zfs_unshare_iscsi(cn->cn_handle);

				if (zvol_remove_link(cn->cn_handle->zfs_hdl,

				    cn->cn_handle->zfs_name) != 0) {

					ret = -1;

					cn->cn_needpost = B_FALSE;

					(void) zfs_share_iscsi(cn->cn_handle);

				}

				break;

			case ZFS_PROP_VOLSIZE:

				/*

				 * If this was a change to the volume size, we

				 * need to unshare and reshare the volume.

				 */

				(void) zfs_unshare_iscsi(cn->cn_handle);

				break;

			}

		} else {

			/*

			 * Do the property specific processing.

			 */

			switch (clp->cl_prop) {

			case ZFS_PROP_MOUNTPOINT:

				if (zfs_unmount(cn->cn_handle, NULL,

				    clp->cl_mflags) != 0) {

					ret = -1;

					cn->cn_needpost = B_FALSE;

				}

				break;

			case ZFS_PROP_SHARESMB:

				(void) zfs_unshare_smb(cn->cn_handle, NULL);

				break;

			}

		}

	}

	if (ret == -1)

		(void) changelist_postfix(clp);

	return (ret);

}

/*

 * If the property is 'mountpoint' or 'sharenfs', go through and remount and/or

 * reshare the filesystems as necessary.  In changelist_gather() we recorded

 * whether the filesystem was previously shared or mounted.  The action we take

 * depends on the previous state, and whether the value was previously 'legacy'.

 * For non-legacy properties, we only remount/reshare the filesystem if it was

 * previously mounted/shared.  Otherwise, we always remount/reshare the

 * filesystem.

 */

int

changelist_postfix(prop_changelist_t *clp)

{

	prop_changenode_t *cn;

	char shareopts[ZFS_MAXPROPLEN];

	int errors = 0;

	libzfs_handle_t *hdl;

	/*

	 * If we're changing the mountpoint, attempt to destroy the underlying

	 * mountpoint.  All other datasets will have inherited from this dataset

	 * (in which case their mountpoints exist in the filesystem in the new

	 * location), or have explicit mountpoints set (in which case they won't

	 * be in the changelist).

	 */

	if ((cn = uu_list_last(clp->cl_list)) == NULL)

		return (0);

	if (clp->cl_prop == ZFS_PROP_MOUNTPOINT)

		remove_mountpoint(cn->cn_handle);

	/*

	 * It is possible that the changelist_prefix() used libshare

	 * to unshare some entries. Since libshare caches data, an

	 * attempt to reshare during postfix can fail unless libshare

	 * is uninitialized here so that it will reinitialize later.

	 */

	if (cn->cn_handle != NULL) {

		hdl = cn->cn_handle->zfs_hdl;

		assert(hdl != NULL);

		zfs_uninit_libshare(hdl);

	}

	/*

	 * We walk the datasets in reverse, because we want to mount any parent

	 * datasets before mounting the children.  We walk all datasets even if

	 * there are errors.

	 */

	for (cn = uu_list_last(clp->cl_list); cn != NULL;

	    cn = uu_list_prev(clp->cl_list, cn)) {

		boolean_t sharenfs;

		boolean_t sharesmb;

		/*

		 * If we are in the global zone, but this dataset is exported

		 * to a local zone, do nothing.

		 */

		if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)

			continue;

		/* Only do post-processing if it's required */

		if (!cn->cn_needpost)

			continue;

		cn->cn_needpost = B_FALSE;

		zfs_refresh_properties(cn->cn_handle);

		if (ZFS_IS_VOLUME(cn->cn_handle)) {

			/*

			 * If we're doing a rename, recreate the /dev/zvol

			 * links.

			 */

			if (clp->cl_realprop == ZFS_PROP_NAME &&

			    zvol_create_link(cn->cn_handle->zfs_hdl,

			    cn->cn_handle->zfs_name) != 0) {

				errors++;

			} else if (cn->cn_shared ||

			    clp->cl_prop == ZFS_PROP_SHAREISCSI) {

				if (zfs_prop_get(cn->cn_handle,

				    ZFS_PROP_SHAREISCSI, shareopts,

				    sizeof (shareopts), NULL, NULL, 0,

				    B_FALSE) == 0 &&

				    strcmp(shareopts, "off") == 0) {

					errors +=

					    zfs_unshare_iscsi(cn->cn_handle);

				} else {

					errors +=

					    zfs_share_iscsi(cn->cn_handle);

				}

			}

			continue;

		}

		/*

		 * Remount if previously mounted or mountpoint was legacy,

		 * or sharenfs or sharesmb  property is set.

		 */

		sharenfs = ((zfs_prop_get(cn->cn_handle, ZFS_PROP_SHARENFS,

		    shareopts, sizeof (shareopts), NULL, NULL, 0,

		    B_FALSE) == 0) && (strcmp(shareopts, "off") != 0));

		sharesmb = ((zfs_prop_get(cn->cn_handle, ZFS_PROP_SHARESMB,

		    shareopts, sizeof (shareopts), NULL, NULL, 0,

		    B_FALSE) == 0) && (strcmp(shareopts, "off") != 0));

		if ((cn->cn_mounted || clp->cl_waslegacy || sharenfs ||

		    sharesmb) && !zfs_is_mounted(cn->cn_handle, NULL) &&

		    zfs_mount(cn->cn_handle, NULL, 0) != 0)

			errors++;

		/*

		 * We always re-share even if the filesystem is currently

		 * shared, so that we can adopt any new options.

		 */

		if (sharenfs)

			errors += zfs_share_nfs(cn->cn_handle);

		else if (cn->cn_shared || clp->cl_waslegacy)

			errors += zfs_unshare_nfs(cn->cn_handle, NULL);

		if (sharesmb)

			errors += zfs_share_smb(cn->cn_handle);

		else if (cn->cn_shared || clp->cl_waslegacy)

			errors += zfs_unshare_smb(cn->cn_handle, NULL);

	}

	return (errors ? -1 : 0);

}

/*

 * Is this "dataset" a child of "parent"?

 */

boolean_t

isa_child_of(const char *dataset, const char *parent)

{

	int len;

	len = strlen(parent);

	if (strncmp(dataset, parent, len) == 0 &&

	    (dataset[len] == '@' || dataset[len] == '/' ||

	    dataset[len] == '\0'))

		return (B_TRUE);

	else

		return (B_FALSE);

}

/*

 * If we rename a filesystem, child filesystem handles are no longer valid

 * since we identify each dataset by its name in the ZFS namespace.  As a

 * result, we have to go through and fix up all the names appropriately.  We

 * could do this automatically if libzfs kept track of all open handles, but

 * this is a lot less work.

 */

void

changelist_rename(prop_changelist_t *clp, const char *src, const char *dst)

{

	prop_changenode_t *cn;

	char newname[ZFS_MAXNAMELEN];

	for (cn = uu_list_first(clp->cl_list); cn != NULL;

	    cn = uu_list_next(clp->cl_list, cn)) {

		/*

		 * Do not rename a clone that's not in the source hierarchy.

		 */

		if (!isa_child_of(cn->cn_handle->zfs_name, src))

			continue;

		/*

		 * Destroy the previous mountpoint if needed.

		 */

		remove_mountpoint(cn->cn_handle);

		(void) strlcpy(newname, dst, sizeof (newname));

		(void) strcat(newname, cn->cn_handle->zfs_name + strlen(src));

		(void) strlcpy(cn->cn_handle->zfs_name, newname,

		    sizeof (cn->cn_handle->zfs_name));

	}

}

/*

 * Given a gathered changelist for the 'sharenfs' or 'sharesmb' property,

 * unshare all the datasets in the list.

 */

int

changelist_unshare(prop_changelist_t *clp, zfs_share_proto_t *proto)

{

	prop_changenode_t *cn;

	int ret = 0;

	if (clp->cl_prop != ZFS_PROP_SHARENFS &&

	    clp->cl_prop != ZFS_PROP_SHARESMB)

		return (0);

	for (cn = uu_list_first(clp->cl_list); cn != NULL;

	    cn = uu_list_next(clp->cl_list, cn)) {

		if (zfs_unshare_proto(cn->cn_handle, NULL, proto) != 0)

			ret = -1;

	}

	return (ret);

}

/*

 * Check if there is any child exported to a local zone in a given changelist.

 * This information has already been recorded while gathering the changelist

 * via changelist_gather().

 */

int

changelist_haszonedchild(prop_changelist_t *clp)

{

	return (clp->cl_haszonedchild);

}

/*

 * Remove a node from a gathered list.

 */

void

changelist_remove(prop_changelist_t *clp, const char *name)

{

	prop_changenode_t *cn;

	for (cn = uu_list_first(clp->cl_list); cn != NULL;

	    cn = uu_list_next(clp->cl_list, cn)) {

		if (strcmp(cn->cn_handle->zfs_name, name) == 0) {

			uu_list_remove(clp->cl_list, cn);

			zfs_close(cn->cn_handle);

			free(cn);

			return;

		}

	}

}

/*

 * Release any memory associated with a changelist.

 */

void

changelist_free(prop_changelist_t *clp)

{

	prop_changenode_t *cn;

	void *cookie;

	if (clp->cl_list) {

		cookie = NULL;

		while ((cn = uu_list_teardown(clp->cl_list, &cookie)) != NULL) {

			zfs_close(cn->cn_handle);

			free(cn);

		}

		uu_list_destroy(clp->cl_list);

	}

	if (clp->cl_pool)

		uu_list_pool_destroy(clp->cl_pool);

	free(clp);

}

static int

change_one(zfs_handle_t *zhp, void *data)

{

	prop_changelist_t *clp = data;

	char property[ZFS_MAXPROPLEN];

	char where[64];

	prop_changenode_t *cn;

	zprop_source_t sourcetype;

	zprop_source_t share_sourcetype;

	/*

	 * We only want to unmount/unshare those filesystems that may inherit

	 * from the target filesystem.  If we find any filesystem with a

	 * locally set mountpoint, we ignore any children since changing the

	 * property will not affect them.  If this is a rename, we iterate

	 * over all children regardless, since we need them unmounted in

	 * order to do the rename.  Also, if this is a volume and we're doing

	 * a rename, then always add it to the changelist.

	 */

	if (!(ZFS_IS_VOLUME(zhp) && clp->cl_realprop == ZFS_PROP_NAME) &&

	    zfs_prop_get(zhp, clp->cl_prop, property,

	    sizeof (property), &sourcetype, where, sizeof (where),

	    B_FALSE) != 0) {

		zfs_close(zhp);

		return (0);

	}

	/*

	 * If we are "watching" sharenfs or sharesmb

	 * then check out the companion property which is tracked

	 * in cl_shareprop

	 */

	if (clp->cl_shareprop != ZPROP_INVAL &&

	    zfs_prop_get(zhp, clp->cl_shareprop, property,

	    sizeof (property), &share_sourcetype, where, sizeof (where),

	    B_FALSE) != 0) {

		zfs_close(zhp);

		return (0);

	}

	if (clp->cl_alldependents || clp->cl_allchildren ||

	    sourcetype == ZPROP_SRC_DEFAULT ||

	    sourcetype == ZPROP_SRC_INHERITED ||

	    (clp->cl_shareprop != ZPROP_INVAL &&

	    (share_sourcetype == ZPROP_SRC_DEFAULT ||

	    share_sourcetype == ZPROP_SRC_INHERITED))) {

		if ((cn = zfs_alloc(zfs_get_handle(zhp),

		    sizeof (prop_changenode_t))) == NULL) {

			zfs_close(zhp);

			return (-1);

		}

		cn->cn_handle = zhp;

		cn->cn_mounted = (clp->cl_gflags & CL_GATHER_MOUNT_ALWAYS) ||

		    zfs_is_mounted(zhp, NULL);

		cn->cn_shared = zfs_is_shared(zhp);

		cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);

		cn->cn_needpost = B_TRUE;

		/* Indicate if any child is exported to a local zone. */

		if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)

			clp->cl_haszonedchild = B_TRUE;

		uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool);

		if (clp->cl_sorted) {

			uu_list_index_t idx;

			(void) uu_list_find(clp->cl_list, cn, NULL,

			    &idx);

			uu_list_insert(clp->cl_list, cn, idx);

		} else {