[mirror_zfs-debian.git] / lib / libzfs / libzfs_iter.c

/*
 * 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.
 * Copyright (c) 2013 by Delphix. All rights reserved.
 * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <stddef.h>
#include <libintl.h>
#include <libzfs.h>

#include "libzfs_impl.h"

int
zfs_iter_clones(zfs_handle_t *zhp, zfs_iter_f func, void *data)
{
	nvlist_t *nvl = zfs_get_clones_nvl(zhp);
	nvpair_t *pair;

	if (nvl == NULL)
		return (0);

	for (pair = nvlist_next_nvpair(nvl, NULL); pair != NULL;
	    pair = nvlist_next_nvpair(nvl, pair)) {
		zfs_handle_t *clone = zfs_open(zhp->zfs_hdl, nvpair_name(pair),
		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
		if (clone != NULL) {
			int err = func(clone, data);
			if (err != 0)
				return (err);
		}
	}
	return (0);
}

static int
zfs_do_list_ioctl(zfs_handle_t *zhp, int arg, zfs_cmd_t *zc)
{
	int rc;
	uint64_t	orig_cookie;

	orig_cookie = zc->zc_cookie;
top:
	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
	rc = ioctl(zhp->zfs_hdl->libzfs_fd, arg, zc);

	if (rc == -1) {
		switch (errno) {
		case ENOMEM:
			/* expand nvlist memory and try again */
			if (zcmd_expand_dst_nvlist(zhp->zfs_hdl, zc) != 0) {
				zcmd_free_nvlists(zc);
				return (-1);
			}
			zc->zc_cookie = orig_cookie;
			goto top;
		/*
		 * An errno value of ESRCH indicates normal completion.
		 * If ENOENT is returned, then the underlying dataset
		 * has been removed since we obtained the handle.
		 */
		case ESRCH:
		case ENOENT:
			rc = 1;
			break;
		default:
			rc = zfs_standard_error(zhp->zfs_hdl, errno,
			    dgettext(TEXT_DOMAIN,
			    "cannot iterate filesystems"));
			break;
		}
	}
	return (rc);
}

/*
 * Iterate over all child filesystems
 */
int
zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
{
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t *nzhp;
	int ret;

	if (zhp->zfs_type != ZFS_TYPE_FILESYSTEM)
		return (0);

	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
		return (-1);

	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_DATASET_LIST_NEXT,
	    &zc)) == 0) {
		/*
		 * Silently ignore errors, as the only plausible explanation is
		 * that the pool has since been removed.
		 */
		if ((nzhp = make_dataset_handle_zc(zhp->zfs_hdl,
		    &zc)) == NULL) {
			continue;
		}

		if ((ret = func(nzhp, data)) != 0) {
			zcmd_free_nvlists(&zc);
			return (ret);
		}
	}
	zcmd_free_nvlists(&zc);
	return ((ret < 0) ? ret : 0);
}

/*
 * Iterate over all snapshots
 */
int
zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
    void *data)
{
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t *nzhp;
	int ret;

	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT ||
	    zhp->zfs_type == ZFS_TYPE_BOOKMARK)
		return (0);

	zc.zc_simple = simple;

	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
		return (-1);
	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
	    &zc)) == 0) {

		if (simple)
			nzhp = make_dataset_simple_handle_zc(zhp, &zc);
		else
			nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
		if (nzhp == NULL)
			continue;

		if ((ret = func(nzhp, data)) != 0) {
			zcmd_free_nvlists(&zc);
			return (ret);
		}
	}
	zcmd_free_nvlists(&zc);
	return ((ret < 0) ? ret : 0);
}

/*
 * Iterate over all bookmarks
 */
int
zfs_iter_bookmarks(zfs_handle_t *zhp, zfs_iter_f func, void *data)
{
	zfs_handle_t *nzhp;
	nvlist_t *props = NULL;
	nvlist_t *bmarks = NULL;
	int err;
	nvpair_t *pair;

	if ((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT | ZFS_TYPE_BOOKMARK)) != 0)
		return (0);

	/* Setup the requested properties nvlist. */
	props = fnvlist_alloc();
	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_GUID));
	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATETXG));
	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATION));

	if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
		goto out;

	for (pair = nvlist_next_nvpair(bmarks, NULL);
	    pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
		char name[ZFS_MAXNAMELEN];
		char *bmark_name;
		nvlist_t *bmark_props;

		bmark_name = nvpair_name(pair);
		bmark_props = fnvpair_value_nvlist(pair);

		(void) snprintf(name, sizeof (name), "%s#%s", zhp->zfs_name,
		    bmark_name);

		nzhp = make_bookmark_handle(zhp, name, bmark_props);
		if (nzhp == NULL)
			continue;

		if ((err = func(nzhp, data)) != 0)
			goto out;
	}

out:
	fnvlist_free(props);
	fnvlist_free(bmarks);

	return (err);
}

/*
 * Routines for dealing with the sorted snapshot functionality
 */
typedef struct zfs_node {
	zfs_handle_t	*zn_handle;
	avl_node_t	zn_avlnode;
} zfs_node_t;

static int
zfs_sort_snaps(zfs_handle_t *zhp, void *data)
{
	avl_tree_t *avl = data;
	zfs_node_t *node;
	zfs_node_t search;

	search.zn_handle = zhp;
	node = avl_find(avl, &search, NULL);
	if (node) {
		/*
		 * If this snapshot was renamed while we were creating the
		 * AVL tree, it's possible that we already inserted it under
		 * its old name. Remove the old handle before adding the new
		 * one.
		 */
		zfs_close(node->zn_handle);
		avl_remove(avl, node);
		free(node);
	}

	node = zfs_alloc(zhp->zfs_hdl, sizeof (zfs_node_t));
	node->zn_handle = zhp;
	avl_add(avl, node);

	return (0);
}

static int
zfs_snapshot_compare(const void *larg, const void *rarg)
{
	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;
	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;
	uint64_t lcreate, rcreate;

	/*
	 * Sort them according to creation time.  We use the hidden
	 * CREATETXG property to get an absolute ordering of snapshots.
	 */
	lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
	rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);

	if (lcreate < rcreate)
		return (-1);
	else if (lcreate > rcreate)
		return (+1);
	else
		return (0);
}

int
zfs_iter_snapshots_sorted(zfs_handle_t *zhp, zfs_iter_f callback, void *data)
{
	int ret = 0;
	zfs_node_t *node;
	avl_tree_t avl;
	void *cookie = NULL;

	avl_create(&avl, zfs_snapshot_compare,
	    sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));

	ret = zfs_iter_snapshots(zhp, B_FALSE, zfs_sort_snaps, &avl);

	for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))
		ret |= callback(node->zn_handle, data);

	while ((node = avl_destroy_nodes(&avl, &cookie)) != NULL)
		free(node);

	avl_destroy(&avl);

	return (ret);
}

typedef struct {
	char *ssa_first;
	char *ssa_last;
	boolean_t ssa_seenfirst;
	boolean_t ssa_seenlast;
	zfs_iter_f ssa_func;
	void *ssa_arg;
} snapspec_arg_t;

static int
snapspec_cb(zfs_handle_t *zhp, void *arg) {
	snapspec_arg_t *ssa = arg;
	char *shortsnapname;
	int err = 0;

	if (ssa->ssa_seenlast)
		return (0);
	shortsnapname = zfs_strdup(zhp->zfs_hdl,
	    strchr(zfs_get_name(zhp), '@') + 1);

	if (!ssa->ssa_seenfirst && strcmp(shortsnapname, ssa->ssa_first) == 0)
		ssa->ssa_seenfirst = B_TRUE;

	if (ssa->ssa_seenfirst) {
		err = ssa->ssa_func(zhp, ssa->ssa_arg);
	} else {
		zfs_close(zhp);
	}

	if (strcmp(shortsnapname, ssa->ssa_last) == 0)
		ssa->ssa_seenlast = B_TRUE;
	free(shortsnapname);

	return (err);
}

/*
 * spec is a string like "A,B%C,D"
 *
 * <snaps>, where <snaps> can be:
 *      <snap>          (single snapshot)
 *      <snap>%<snap>   (range of snapshots, inclusive)
 *      %<snap>         (range of snapshots, starting with earliest)
 *      <snap>%         (range of snapshots, ending with last)
 *      %               (all snapshots)
 *      <snaps>[,...]   (comma separated list of the above)
 *
 * If a snapshot can not be opened, continue trying to open the others, but
 * return ENOENT at the end.
 */
int
zfs_iter_snapspec(zfs_handle_t *fs_zhp, const char *spec_orig,
    zfs_iter_f func, void *arg)
{
	char *buf, *comma_separated, *cp;
	int err = 0;
	int ret = 0;

	buf = zfs_strdup(fs_zhp->zfs_hdl, spec_orig);
	cp = buf;

	while ((comma_separated = strsep(&cp, ",")) != NULL) {
		char *pct = strchr(comma_separated, '%');
		if (pct != NULL) {
			snapspec_arg_t ssa = { 0 };
			ssa.ssa_func = func;
			ssa.ssa_arg = arg;

			if (pct == comma_separated)
				ssa.ssa_seenfirst = B_TRUE;
			else
				ssa.ssa_first = comma_separated;
			*pct = '\0';
			ssa.ssa_last = pct + 1;

			/*
			 * If there is a lastname specified, make sure it
			 * exists.
			 */
			if (ssa.ssa_last[0] != '\0') {
				char snapname[ZFS_MAXNAMELEN];
				(void) snprintf(snapname, sizeof (snapname),
				    "%s@%s", zfs_get_name(fs_zhp),
				    ssa.ssa_last);
				if (!zfs_dataset_exists(fs_zhp->zfs_hdl,
				    snapname, ZFS_TYPE_SNAPSHOT)) {
					ret = ENOENT;
					continue;
				}
			}

			err = zfs_iter_snapshots_sorted(fs_zhp,
			    snapspec_cb, &ssa);
			if (ret == 0)
				ret = err;
			if (ret == 0 && (!ssa.ssa_seenfirst ||
			    (ssa.ssa_last[0] != '\0' && !ssa.ssa_seenlast))) {
				ret = ENOENT;
			}
		} else {
			char snapname[ZFS_MAXNAMELEN];
			zfs_handle_t *snap_zhp;
			(void) snprintf(snapname, sizeof (snapname), "%s@%s",
			    zfs_get_name(fs_zhp), comma_separated);
			snap_zhp = make_dataset_handle(fs_zhp->zfs_hdl,
			    snapname);
			if (snap_zhp == NULL) {
				ret = ENOENT;
				continue;
			}
			err = func(snap_zhp, arg);
			if (ret == 0)
				ret = err;
		}
	}

	free(buf);
	return (ret);
}

/*
 * Iterate over all children, snapshots and filesystems
 */
int
zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data)
{
	int ret;

	if ((ret = zfs_iter_filesystems(zhp, func, data)) != 0)
		return (ret);

	return (zfs_iter_snapshots(zhp, B_FALSE, func, data));
}


typedef struct iter_stack_frame {
	struct iter_stack_frame *next;
	zfs_handle_t *zhp;
} iter_stack_frame_t;

typedef struct iter_dependents_arg {
	boolean_t first;
	boolean_t allowrecursion;
	iter_stack_frame_t *stack;
	zfs_iter_f func;
	void *data;
} iter_dependents_arg_t;

static int
iter_dependents_cb(zfs_handle_t *zhp, void *arg)
{
	iter_dependents_arg_t *ida = arg;
	int err = 0;
	boolean_t first = ida->first;
	ida->first = B_FALSE;

	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
		err = zfs_iter_clones(zhp, iter_dependents_cb, ida);
	} else if (zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
		iter_stack_frame_t isf;
		iter_stack_frame_t *f;

		/*
		 * check if there is a cycle by seeing if this fs is already
		 * on the stack.
		 */
		for (f = ida->stack; f != NULL; f = f->next) {
			if (f->zhp->zfs_dmustats.dds_guid ==
			    zhp->zfs_dmustats.dds_guid) {
				if (ida->allowrecursion) {
					zfs_close(zhp);
					return (0);
				} else {
					zfs_error_aux(zhp->zfs_hdl,
					    dgettext(TEXT_DOMAIN,
					    "recursive dependency at '%s'"),
					    zfs_get_name(zhp));
					err = zfs_error(zhp->zfs_hdl,
					    EZFS_RECURSIVE,
					    dgettext(TEXT_DOMAIN,
					    "cannot determine dependent "
					    "datasets"));
					zfs_close(zhp);
					return (err);
				}
			}
		}

		isf.zhp = zhp;
		isf.next = ida->stack;
		ida->stack = &isf;
		err = zfs_iter_filesystems(zhp, iter_dependents_cb, ida);
		if (err == 0)
			err = zfs_iter_snapshots(zhp, B_FALSE,
			    iter_dependents_cb, ida);
		ida->stack = isf.next;
	}

	if (!first && err == 0)
		err = ida->func(zhp, ida->data);
	else
		zfs_close(zhp);

	return (err);
}

int
zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
    zfs_iter_f func, void *data)
{
	iter_dependents_arg_t ida;
	ida.allowrecursion = allowrecursion;
	ida.stack = NULL;
	ida.func = func;
	ida.data = data;
	ida.first = B_TRUE;
	return (iter_dependents_cb(zfs_handle_dup(zhp), &ida));
}
Commit	Line	Data
330d06f9 MA	1	/*
	2	* CDDL HEADER START
	3	*
	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.
	7	*
	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.
	12	*
	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]
	18	*
	19	* CDDL HEADER END
	20	*/
	21
	22	/*
	23	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
ea04106b	24	* Copyright (c) 2013 by Delphix. All rights reserved.
e10b0808	25	* Copyright 2014 Nexenta Systems, Inc. All rights reserved.
330d06f9 MA	26	*/
	27
	28	#include <stdio.h>
	29	#include <stdlib.h>
	30	#include <strings.h>
	31	#include <unistd.h>
	32	#include <stddef.h>
	33	#include <libintl.h>
	34	#include <libzfs.h>
	35
	36	#include "libzfs_impl.h"
	37
	38	int
	39	zfs_iter_clones(zfs_handle_t zhp, zfs_iter_f func, void data)
	40	{
	41	nvlist_t *nvl = zfs_get_clones_nvl(zhp);
	42	nvpair_t *pair;
	43
	44	if (nvl == NULL)
	45	return (0);
	46
	47	for (pair = nvlist_next_nvpair(nvl, NULL); pair != NULL;
	48	pair = nvlist_next_nvpair(nvl, pair)) {
	49	zfs_handle_t *clone = zfs_open(zhp->zfs_hdl, nvpair_name(pair),
	50	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	51	if (clone != NULL) {
	52	int err = func(clone, data);
	53	if (err != 0)
	54	return (err);
	55	}
	56	}
	57	return (0);
	58	}
	59
	60	static int
	61	zfs_do_list_ioctl(zfs_handle_t zhp, int arg, zfs_cmd_t zc)
	62	{
	63	int rc;
	64	uint64_t orig_cookie;
	65
	66	orig_cookie = zc->zc_cookie;
	67	top:
	68	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
	69	rc = ioctl(zhp->zfs_hdl->libzfs_fd, arg, zc);
	70
	71	if (rc == -1) {
	72	switch (errno) {
	73	case ENOMEM:
	74	/* expand nvlist memory and try again */
	75	if (zcmd_expand_dst_nvlist(zhp->zfs_hdl, zc) != 0) {
	76	zcmd_free_nvlists(zc);
	77	return (-1);
	78	}
	79	zc->zc_cookie = orig_cookie;
	80	goto top;
	81	/*
	82	* An errno value of ESRCH indicates normal completion.
	83	* If ENOENT is returned, then the underlying dataset
	84	* has been removed since we obtained the handle.
	85	*/
	86	case ESRCH:
	87	case ENOENT:
	88	rc = 1;
	89	break;
90	default:
91	rc = zfs_standard_error(zhp->zfs_hdl, errno,
92	dgettext(TEXT_DOMAIN,
93	"cannot iterate filesystems"));
94	break;
95	}
96	}
97	return (rc);
98	}
99
100	/*
101	* Iterate over all child filesystems
102	*/
103	int
104	zfs_iter_filesystems(zfs_handle_t zhp, zfs_iter_f func, void data)
105	{
a08ee875	106	zfs_cmd_t zc = {"\0"};
330d06f9 MA	107	zfs_handle_t *nzhp;
	108	int ret;
	109
	110	if (zhp->zfs_type != ZFS_TYPE_FILESYSTEM)
	111	return (0);
	112
	113	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
	114	return (-1);
	115
	116	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_DATASET_LIST_NEXT,
	117	&zc)) == 0) {
	118	/*
	119	* Silently ignore errors, as the only plausible explanation is
	120	* that the pool has since been removed.
	121	*/
	122	if ((nzhp = make_dataset_handle_zc(zhp->zfs_hdl,
	123	&zc)) == NULL) {
	124	continue;
	125	}
	126
	127	if ((ret = func(nzhp, data)) != 0) {
	128	zcmd_free_nvlists(&zc);
	129	return (ret);
	130	}
	131	}
	132	zcmd_free_nvlists(&zc);
	133	return ((ret < 0) ? ret : 0);
	134	}
	135
	136	/*
	137	* Iterate over all snapshots
	138	*/
	139	int
	140	zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
	141	void *data)
	142	{
a08ee875	143	zfs_cmd_t zc = {"\0"};
330d06f9 MA	144	zfs_handle_t *nzhp;
	145	int ret;
	146
ea04106b AX	147	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT \|\|
ea04106b AX	148	zhp->zfs_type == ZFS_TYPE_BOOKMARK)
330d06f9 MA	149	return (0);
	150
	151	zc.zc_simple = simple;
	152
	153	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
	154	return (-1);
	155	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
	156	&zc)) == 0) {
	157
	158	if (simple)
	159	nzhp = make_dataset_simple_handle_zc(zhp, &zc);
	160	else
	161	nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
	162	if (nzhp == NULL)
	163	continue;
	164
	165	if ((ret = func(nzhp, data)) != 0) {
	166	zcmd_free_nvlists(&zc);
	167	return (ret);
	168	}
	169	}
	170	zcmd_free_nvlists(&zc);
	171	return ((ret < 0) ? ret : 0);
	172	}
	173
ea04106b AX	174	/*
	175	* Iterate over all bookmarks
	176	*/
	177	int
	178	zfs_iter_bookmarks(zfs_handle_t zhp, zfs_iter_f func, void data)
	179	{
	180	zfs_handle_t *nzhp;
	181	nvlist_t *props = NULL;
	182	nvlist_t *bmarks = NULL;
	183	int err;
	184	nvpair_t *pair;
	185
	186	if ((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT \| ZFS_TYPE_BOOKMARK)) != 0)
	187	return (0);
	188
	189	/* Setup the requested properties nvlist. */
	190	props = fnvlist_alloc();
	191	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_GUID));
	192	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATETXG));
	193	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATION));
	194
ea04106b AX	195	if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
	196	goto out;
	197
	198	for (pair = nvlist_next_nvpair(bmarks, NULL);
	199	pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
	200	char name[ZFS_MAXNAMELEN];
	201	char *bmark_name;
	202	nvlist_t *bmark_props;
	203
	204	bmark_name = nvpair_name(pair);
	205	bmark_props = fnvpair_value_nvlist(pair);
	206
	207	(void) snprintf(name, sizeof (name), "%s#%s", zhp->zfs_name,
	208	bmark_name);
	209
	210	nzhp = make_bookmark_handle(zhp, name, bmark_props);
	211	if (nzhp == NULL)
	212	continue;
	213
	214	if ((err = func(nzhp, data)) != 0)
	215	goto out;
	216	}
	217
	218	out:
	219	fnvlist_free(props);
	220	fnvlist_free(bmarks);
	221
	222	return (err);
	223	}
	224
330d06f9 MA	225	/*
	226	* Routines for dealing with the sorted snapshot functionality
	227	*/
	228	typedef struct zfs_node {
	229	zfs_handle_t *zn_handle;
	230	avl_node_t zn_avlnode;
	231	} zfs_node_t;
	232
	233	static int
	234	zfs_sort_snaps(zfs_handle_t zhp, void data)
	235	{
	236	avl_tree_t *avl = data;
	237	zfs_node_t *node;
	238	zfs_node_t search;
	239
	240	search.zn_handle = zhp;
	241	node = avl_find(avl, &search, NULL);
	242	if (node) {
	243	/*
	244	* If this snapshot was renamed while we were creating the
	245	* AVL tree, it's possible that we already inserted it under
	246	* its old name. Remove the old handle before adding the new
	247	* one.
	248	*/
	249	zfs_close(node->zn_handle);
	250	avl_remove(avl, node);
	251	free(node);
	252	}
	253
	254	node = zfs_alloc(zhp->zfs_hdl, sizeof (zfs_node_t));
	255	node->zn_handle = zhp;
	256	avl_add(avl, node);
	257
	258	return (0);
	259	}
	260
	261	static int
	262	zfs_snapshot_compare(const void larg, const void rarg)
	263	{
	264	zfs_handle_t l = ((zfs_node_t )larg)->zn_handle;
	265	zfs_handle_t r = ((zfs_node_t )rarg)->zn_handle;
	266	uint64_t lcreate, rcreate;
	267
	268	/*
	269	* Sort them according to creation time. We use the hidden
	270	* CREATETXG property to get an absolute ordering of snapshots.
	271	*/
	272	lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
	273	rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);
	274
	275	if (lcreate < rcreate)
	276	return (-1);
	277	else if (lcreate > rcreate)
	278	return (+1);
	279	else
	280	return (0);
	281	}
	282
	283	int
	284	zfs_iter_snapshots_sorted(zfs_handle_t zhp, zfs_iter_f callback, void data)
	285	{
	286	int ret = 0;
	287	zfs_node_t *node;
	288	avl_tree_t avl;
289	void *cookie = NULL;
290
291	avl_create(&avl, zfs_snapshot_compare,
292	sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));
293
294	ret = zfs_iter_snapshots(zhp, B_FALSE, zfs_sort_snaps, &avl);
295
296	for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))
297	ret \|= callback(node->zn_handle, data);
298
299	while ((node = avl_destroy_nodes(&avl, &cookie)) != NULL)
300	free(node);
301
302	avl_destroy(&avl);
303
304	return (ret);
305	}
306
307	typedef struct {
308	char *ssa_first;
309	char *ssa_last;
310	boolean_t ssa_seenfirst;
311	boolean_t ssa_seenlast;
312	zfs_iter_f ssa_func;
313	void *ssa_arg;
314	} snapspec_arg_t;
315
316	static int
317	snapspec_cb(zfs_handle_t zhp, void arg) {
318	snapspec_arg_t *ssa = arg;
319	char *shortsnapname;
320	int err = 0;
321
322	if (ssa->ssa_seenlast)
323	return (0);
324	shortsnapname = zfs_strdup(zhp->zfs_hdl,
325	strchr(zfs_get_name(zhp), '@') + 1);
326
327	if (!ssa->ssa_seenfirst && strcmp(shortsnapname, ssa->ssa_first) == 0)
328	ssa->ssa_seenfirst = B_TRUE;
329
330	if (ssa->ssa_seenfirst) {
331	err = ssa->ssa_func(zhp, ssa->ssa_arg);
332	} else {
333	zfs_close(zhp);
334	}
335
336	if (strcmp(shortsnapname, ssa->ssa_last) == 0)
337	ssa->ssa_seenlast = B_TRUE;
338	free(shortsnapname);
339
340	return (err);
341	}
342
343	/*
344	* spec is a string like "A,B%C,D"
345	*
346	* <snaps>, where <snaps> can be:
347	* <snap> (single snapshot)
348	* <snap>%<snap> (range of snapshots, inclusive)
349	* %<snap> (range of snapshots, starting with earliest)
350	* <snap>% (range of snapshots, ending with last)
351	* % (all snapshots)
352	* <snaps>[,...] (comma separated list of the above)
353	*
354	* If a snapshot can not be opened, continue trying to open the others, but
355	* return ENOENT at the end.
356	*/
357	int
358	zfs_iter_snapspec(zfs_handle_t fs_zhp, const char spec_orig,
359	zfs_iter_f func, void *arg)
360	{
a08ee875	361	char buf, comma_separated, *cp;
330d06f9 MA	362	int err = 0;
	363	int ret = 0;
	364
a08ee875	365	buf = zfs_strdup(fs_zhp->zfs_hdl, spec_orig);
330d06f9 MA	366	cp = buf;
	367
	368	while ((comma_separated = strsep(&cp, ",")) != NULL) {
	369	char *pct = strchr(comma_separated, '%');
	370	if (pct != NULL) {
	371	snapspec_arg_t ssa = { 0 };
	372	ssa.ssa_func = func;
	373	ssa.ssa_arg = arg;
	374
	375	if (pct == comma_separated)
	376	ssa.ssa_seenfirst = B_TRUE;
	377	else
	378	ssa.ssa_first = comma_separated;
	379	*pct = '\0';
	380	ssa.ssa_last = pct + 1;
	381
	382	/*
	383	* If there is a lastname specified, make sure it
	384	* exists.
	385	*/
	386	if (ssa.ssa_last[0] != '\0') {
	387	char snapname[ZFS_MAXNAMELEN];
	388	(void) snprintf(snapname, sizeof (snapname),
	389	"%s@%s", zfs_get_name(fs_zhp),
	390	ssa.ssa_last);
	391	if (!zfs_dataset_exists(fs_zhp->zfs_hdl,
	392	snapname, ZFS_TYPE_SNAPSHOT)) {
	393	ret = ENOENT;
	394	continue;
	395	}
	396	}
	397
	398	err = zfs_iter_snapshots_sorted(fs_zhp,
	399	snapspec_cb, &ssa);
	400	if (ret == 0)
	401	ret = err;
	402	if (ret == 0 && (!ssa.ssa_seenfirst \|\|
	403	(ssa.ssa_last[0] != '\0' && !ssa.ssa_seenlast))) {
	404	ret = ENOENT;
	405	}
	406	} else {
	407	char snapname[ZFS_MAXNAMELEN];
	408	zfs_handle_t *snap_zhp;
	409	(void) snprintf(snapname, sizeof (snapname), "%s@%s",
	410	zfs_get_name(fs_zhp), comma_separated);
	411	snap_zhp = make_dataset_handle(fs_zhp->zfs_hdl,
	412	snapname);
	413	if (snap_zhp == NULL) {
	414	ret = ENOENT;
	415	continue;
	416	}
	417	err = func(snap_zhp, arg);
	418	if (ret == 0)
	419	ret = err;
	420	}
	421	}
	422
a08ee875	423	free(buf);
330d06f9 MA	424	return (ret);
	425	}
	426
	427	/*
	428	* Iterate over all children, snapshots and filesystems
	429	*/
	430	int
	431	zfs_iter_children(zfs_handle_t zhp, zfs_iter_f func, void data)
	432	{
	433	int ret;
	434
	435	if ((ret = zfs_iter_filesystems(zhp, func, data)) != 0)
	436	return (ret);
	437
	438	return (zfs_iter_snapshots(zhp, B_FALSE, func, data));
	439	}
	440
	441
	442	typedef struct iter_stack_frame {
	443	struct iter_stack_frame *next;
	444	zfs_handle_t *zhp;
	445	} iter_stack_frame_t;
	446
	447	typedef struct iter_dependents_arg {
	448	boolean_t first;
	449	boolean_t allowrecursion;
	450	iter_stack_frame_t *stack;
	451	zfs_iter_f func;
	452	void *data;
	453	} iter_dependents_arg_t;
	454
	455	static int
	456	iter_dependents_cb(zfs_handle_t zhp, void arg)
	457	{
	458	iter_dependents_arg_t *ida = arg;
ea04106b	459	int err = 0;
330d06f9 MA	460	boolean_t first = ida->first;
	461	ida->first = B_FALSE;
	462
	463	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
	464	err = zfs_iter_clones(zhp, iter_dependents_cb, ida);
ea04106b	465	} else if (zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
330d06f9 MA	466	iter_stack_frame_t isf;
	467	iter_stack_frame_t *f;
	468
	469	/*
	470	* check if there is a cycle by seeing if this fs is already
	471	* on the stack.
	472	*/
	473	for (f = ida->stack; f != NULL; f = f->next) {
	474	if (f->zhp->zfs_dmustats.dds_guid ==
	475	zhp->zfs_dmustats.dds_guid) {
	476	if (ida->allowrecursion) {
	477	zfs_close(zhp);
	478	return (0);
	479	} else {
	480	zfs_error_aux(zhp->zfs_hdl,
	481	dgettext(TEXT_DOMAIN,
	482	"recursive dependency at '%s'"),
	483	zfs_get_name(zhp));
	484	err = zfs_error(zhp->zfs_hdl,
	485	EZFS_RECURSIVE,
	486	dgettext(TEXT_DOMAIN,
	487	"cannot determine dependent "
	488	"datasets"));
	489	zfs_close(zhp);
	490	return (err);
	491	}
	492	}
	493	}
	494
	495	isf.zhp = zhp;
	496	isf.next = ida->stack;
	497	ida->stack = &isf;
	498	err = zfs_iter_filesystems(zhp, iter_dependents_cb, ida);
	499	if (err == 0)
	500	err = zfs_iter_snapshots(zhp, B_FALSE,
	501	iter_dependents_cb, ida);
	502	ida->stack = isf.next;
	503	}
a08ee875	504
330d06f9 MA	505	if (!first && err == 0)
330d06f9 MA	506	err = ida->func(zhp, ida->data);
a08ee875 LG	507	else
	508	zfs_close(zhp);
	509
330d06f9 MA	510	return (err);
	511	}
	512
	513	int
	514	zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
	515	zfs_iter_f func, void *data)
	516	{
	517	iter_dependents_arg_t ida;
	518	ida.allowrecursion = allowrecursion;
	519	ida.stack = NULL;
	520	ida.func = func;
	521	ida.data = data;
	522	ida.first = B_TRUE;
	523	return (iter_dependents_cb(zfs_handle_dup(zhp), &ida));
	524	}