xref: /titanic_51/usr/src/cmd/zfs/zfs_iter.c (revision fa9e4066f08beec538e775443c5be79dd423fcab)
1*fa9e4066Sahrens /*
2*fa9e4066Sahrens  * CDDL HEADER START
3*fa9e4066Sahrens  *
4*fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5*fa9e4066Sahrens  * Common Development and Distribution License, Version 1.0 only
6*fa9e4066Sahrens  * (the "License").  You may not use this file except in compliance
7*fa9e4066Sahrens  * with the License.
8*fa9e4066Sahrens  *
9*fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10*fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
11*fa9e4066Sahrens  * See the License for the specific language governing permissions
12*fa9e4066Sahrens  * and limitations under the License.
13*fa9e4066Sahrens  *
14*fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
15*fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16*fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
17*fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
18*fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
19*fa9e4066Sahrens  *
20*fa9e4066Sahrens  * CDDL HEADER END
21*fa9e4066Sahrens  */
22*fa9e4066Sahrens /*
23*fa9e4066Sahrens  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24*fa9e4066Sahrens  * Use is subject to license terms.
25*fa9e4066Sahrens  */
26*fa9e4066Sahrens 
27*fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
28*fa9e4066Sahrens 
29*fa9e4066Sahrens #include <libintl.h>
30*fa9e4066Sahrens #include <libuutil.h>
31*fa9e4066Sahrens #include <stddef.h>
32*fa9e4066Sahrens #include <stdio.h>
33*fa9e4066Sahrens #include <stdlib.h>
34*fa9e4066Sahrens #include <strings.h>
35*fa9e4066Sahrens 
36*fa9e4066Sahrens #include <libzfs.h>
37*fa9e4066Sahrens 
38*fa9e4066Sahrens #include "zfs_util.h"
39*fa9e4066Sahrens 
40*fa9e4066Sahrens /*
41*fa9e4066Sahrens  * This is a private interface used to gather up all the datasets specified on
42*fa9e4066Sahrens  * the command line so that we can iterate over them in order.
43*fa9e4066Sahrens  *
44*fa9e4066Sahrens  * First, we iterate over all filesystems, gathering them together into an
45*fa9e4066Sahrens  * AVL tree sorted by name.  For snapshots, we order them according to
46*fa9e4066Sahrens  * creation time.  We report errors for any explicitly specified datasets
47*fa9e4066Sahrens  * that we couldn't open.
48*fa9e4066Sahrens  *
49*fa9e4066Sahrens  * When finished, we have an AVL tree of ZFS handles.  We go through and execute
50*fa9e4066Sahrens  * the provided callback for each one, passing whatever data the user supplied.
51*fa9e4066Sahrens  */
52*fa9e4066Sahrens 
53*fa9e4066Sahrens typedef struct zfs_node {
54*fa9e4066Sahrens 	zfs_handle_t	*zn_handle;
55*fa9e4066Sahrens 	uu_avl_node_t	zn_avlnode;
56*fa9e4066Sahrens } zfs_node_t;
57*fa9e4066Sahrens 
58*fa9e4066Sahrens typedef struct callback_data {
59*fa9e4066Sahrens 	uu_avl_t	*cb_avl;
60*fa9e4066Sahrens 	int		cb_recurse;
61*fa9e4066Sahrens 	zfs_type_t	cb_types;
62*fa9e4066Sahrens } callback_data_t;
63*fa9e4066Sahrens 
64*fa9e4066Sahrens uu_avl_pool_t *avl_pool;
65*fa9e4066Sahrens 
66*fa9e4066Sahrens /*
67*fa9e4066Sahrens  * Called for each dataset.  If the object the object is of an appropriate type,
68*fa9e4066Sahrens  * add it to the avl tree and recurse over any children as necessary.
69*fa9e4066Sahrens  */
70*fa9e4066Sahrens int
71*fa9e4066Sahrens zfs_callback(zfs_handle_t *zhp, void *data)
72*fa9e4066Sahrens {
73*fa9e4066Sahrens 	callback_data_t *cb = data;
74*fa9e4066Sahrens 	int dontclose = 0;
75*fa9e4066Sahrens 
76*fa9e4066Sahrens 	/*
77*fa9e4066Sahrens 	 * If this object is of the appropriate type, add it to the AVL tree.
78*fa9e4066Sahrens 	 */
79*fa9e4066Sahrens 	if (zfs_get_type(zhp) & cb->cb_types) {
80*fa9e4066Sahrens 		uu_avl_index_t idx;
81*fa9e4066Sahrens 		zfs_node_t *node = safe_malloc(sizeof (zfs_node_t));
82*fa9e4066Sahrens 
83*fa9e4066Sahrens 		node->zn_handle = zhp;
84*fa9e4066Sahrens 		uu_avl_node_init(node, &node->zn_avlnode, avl_pool);
85*fa9e4066Sahrens 		if (uu_avl_find(cb->cb_avl, node, NULL, &idx) == NULL) {
86*fa9e4066Sahrens 			uu_avl_insert(cb->cb_avl, node, idx);
87*fa9e4066Sahrens 			dontclose = 1;
88*fa9e4066Sahrens 		} else {
89*fa9e4066Sahrens 			free(node);
90*fa9e4066Sahrens 		}
91*fa9e4066Sahrens 	}
92*fa9e4066Sahrens 
93*fa9e4066Sahrens 	/*
94*fa9e4066Sahrens 	 * If 'recurse' is set, and the datasets can have datasets of the
95*fa9e4066Sahrens 	 * appropriate type, then recurse over its children.
96*fa9e4066Sahrens 	 */
97*fa9e4066Sahrens 	if (cb->cb_recurse && (zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM ||
98*fa9e4066Sahrens 	    (cb->cb_types & ZFS_TYPE_SNAPSHOT)))
99*fa9e4066Sahrens 		(void) zfs_iter_children(zhp, zfs_callback, data);
100*fa9e4066Sahrens 
101*fa9e4066Sahrens 	if (!dontclose)
102*fa9e4066Sahrens 		zfs_close(zhp);
103*fa9e4066Sahrens 
104*fa9e4066Sahrens 	return (0);
105*fa9e4066Sahrens }
106*fa9e4066Sahrens 
107*fa9e4066Sahrens /* ARGSUSED */
108*fa9e4066Sahrens static int
109*fa9e4066Sahrens zfs_compare(const void *larg, const void *rarg, void *unused)
110*fa9e4066Sahrens {
111*fa9e4066Sahrens 	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;
112*fa9e4066Sahrens 	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;
113*fa9e4066Sahrens 	const char *lname = zfs_get_name(l);
114*fa9e4066Sahrens 	const char *rname = zfs_get_name(r);
115*fa9e4066Sahrens 	char *lat, *rat;
116*fa9e4066Sahrens 	uint64_t lcreate, rcreate;
117*fa9e4066Sahrens 	int ret;
118*fa9e4066Sahrens 
119*fa9e4066Sahrens 	lat = (char *)strchr(lname, '@');
120*fa9e4066Sahrens 	rat = (char *)strchr(rname, '@');
121*fa9e4066Sahrens 
122*fa9e4066Sahrens 	if (lat != NULL)
123*fa9e4066Sahrens 		*lat = '\0';
124*fa9e4066Sahrens 	if (rat != NULL)
125*fa9e4066Sahrens 		*rat = '\0';
126*fa9e4066Sahrens 
127*fa9e4066Sahrens 	ret = strcmp(lname, rname);
128*fa9e4066Sahrens 	if (ret == 0) {
129*fa9e4066Sahrens 		/*
130*fa9e4066Sahrens 		 * If we're comparing a dataset to one of its snapshots, we
131*fa9e4066Sahrens 		 * always make the full dataset first.
132*fa9e4066Sahrens 		 */
133*fa9e4066Sahrens 		if (lat == NULL) {
134*fa9e4066Sahrens 			ret = -1;
135*fa9e4066Sahrens 		} else if (rat == NULL) {
136*fa9e4066Sahrens 			ret = 1;
137*fa9e4066Sahrens 		} else {
138*fa9e4066Sahrens 			/*
139*fa9e4066Sahrens 			 * If we have two snapshots from the same dataset, then
140*fa9e4066Sahrens 			 * we want to sort them according to creation time.  We
141*fa9e4066Sahrens 			 * use the hidden CREATETXG property to get an absolute
142*fa9e4066Sahrens 			 * ordering of snapshots.
143*fa9e4066Sahrens 			 */
144*fa9e4066Sahrens 			lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
145*fa9e4066Sahrens 			rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);
146*fa9e4066Sahrens 
147*fa9e4066Sahrens 			if (lcreate < rcreate)
148*fa9e4066Sahrens 				ret = -1;
149*fa9e4066Sahrens 			else if (lcreate > rcreate)
150*fa9e4066Sahrens 				ret = 1;
151*fa9e4066Sahrens 		}
152*fa9e4066Sahrens 	}
153*fa9e4066Sahrens 
154*fa9e4066Sahrens 	if (lat != NULL)
155*fa9e4066Sahrens 		*lat = '@';
156*fa9e4066Sahrens 	if (rat != NULL)
157*fa9e4066Sahrens 		*rat = '@';
158*fa9e4066Sahrens 
159*fa9e4066Sahrens 	return (ret);
160*fa9e4066Sahrens }
161*fa9e4066Sahrens 
162*fa9e4066Sahrens int
163*fa9e4066Sahrens zfs_for_each(int argc, char **argv, int recurse, zfs_type_t types,
164*fa9e4066Sahrens     zfs_iter_f callback, void *data)
165*fa9e4066Sahrens {
166*fa9e4066Sahrens 	callback_data_t cb;
167*fa9e4066Sahrens 	int ret = 0;
168*fa9e4066Sahrens 	zfs_node_t *node;
169*fa9e4066Sahrens 	uu_avl_walk_t *walk;
170*fa9e4066Sahrens 
171*fa9e4066Sahrens 	avl_pool = uu_avl_pool_create("zfs_pool", sizeof (zfs_node_t),
172*fa9e4066Sahrens 	    offsetof(zfs_node_t, zn_avlnode), zfs_compare, UU_DEFAULT);
173*fa9e4066Sahrens 
174*fa9e4066Sahrens 	if (avl_pool == NULL) {
175*fa9e4066Sahrens 		(void) fprintf(stderr,
176*fa9e4066Sahrens 		    gettext("internal error: out of memory\n"));
177*fa9e4066Sahrens 		exit(1);
178*fa9e4066Sahrens 	}
179*fa9e4066Sahrens 
180*fa9e4066Sahrens 	cb.cb_recurse = recurse;
181*fa9e4066Sahrens 	cb.cb_types = types;
182*fa9e4066Sahrens 	if ((cb.cb_avl = uu_avl_create(avl_pool, NULL, UU_DEFAULT)) == NULL) {
183*fa9e4066Sahrens 		(void) fprintf(stderr,
184*fa9e4066Sahrens 		    gettext("internal error: out of memory\n"));
185*fa9e4066Sahrens 		exit(1);
186*fa9e4066Sahrens 	}
187*fa9e4066Sahrens 
188*fa9e4066Sahrens 	if (argc == 0) {
189*fa9e4066Sahrens 		/*
190*fa9e4066Sahrens 		 * If given no arguments, iterate over all datasets.
191*fa9e4066Sahrens 		 */
192*fa9e4066Sahrens 		cb.cb_recurse = 1;
193*fa9e4066Sahrens 		ret = zfs_iter_root(zfs_callback, &cb);
194*fa9e4066Sahrens 	} else {
195*fa9e4066Sahrens 		int i;
196*fa9e4066Sahrens 		zfs_handle_t *zhp;
197*fa9e4066Sahrens 		zfs_type_t argtype;
198*fa9e4066Sahrens 
199*fa9e4066Sahrens 		/*
200*fa9e4066Sahrens 		 * If we're recursive, then we always allow filesystems as
201*fa9e4066Sahrens 		 * arguments.  If we also are interested in snapshots, then we
202*fa9e4066Sahrens 		 * can take volumes as well.
203*fa9e4066Sahrens 		 */
204*fa9e4066Sahrens 		argtype = types;
205*fa9e4066Sahrens 		if (recurse) {
206*fa9e4066Sahrens 			argtype |= ZFS_TYPE_FILESYSTEM;
207*fa9e4066Sahrens 			if (types & ZFS_TYPE_SNAPSHOT)
208*fa9e4066Sahrens 				argtype |= ZFS_TYPE_VOLUME;
209*fa9e4066Sahrens 		}
210*fa9e4066Sahrens 
211*fa9e4066Sahrens 		for (i = 0; i < argc; i++) {
212*fa9e4066Sahrens 			if ((zhp = zfs_open(argv[i], argtype)) != NULL)
213*fa9e4066Sahrens 				ret = zfs_callback(zhp, &cb);
214*fa9e4066Sahrens 			else
215*fa9e4066Sahrens 				ret = 1;
216*fa9e4066Sahrens 		}
217*fa9e4066Sahrens 	}
218*fa9e4066Sahrens 
219*fa9e4066Sahrens 	/*
220*fa9e4066Sahrens 	 * At this point we've got our AVL tree full of zfs handles, so iterate
221*fa9e4066Sahrens 	 * over each one and execute the real user callback.
222*fa9e4066Sahrens 	 */
223*fa9e4066Sahrens 	for (node = uu_avl_first(cb.cb_avl); node != NULL;
224*fa9e4066Sahrens 	    node = uu_avl_next(cb.cb_avl, node))
225*fa9e4066Sahrens 		ret |= callback(node->zn_handle, data);
226*fa9e4066Sahrens 
227*fa9e4066Sahrens 	/*
228*fa9e4066Sahrens 	 * Finally, clean up the AVL tree.
229*fa9e4066Sahrens 	 */
230*fa9e4066Sahrens 	if ((walk = uu_avl_walk_start(cb.cb_avl, UU_WALK_ROBUST)) == NULL) {
231*fa9e4066Sahrens 		(void) fprintf(stderr,
232*fa9e4066Sahrens 		    gettext("internal error: out of memory"));
233*fa9e4066Sahrens 		exit(1);
234*fa9e4066Sahrens 	}
235*fa9e4066Sahrens 
236*fa9e4066Sahrens 	while ((node = uu_avl_walk_next(walk)) != NULL) {
237*fa9e4066Sahrens 		uu_avl_remove(cb.cb_avl, node);
238*fa9e4066Sahrens 		zfs_close(node->zn_handle);
239*fa9e4066Sahrens 		free(node);
240*fa9e4066Sahrens 	}
241*fa9e4066Sahrens 
242*fa9e4066Sahrens 	uu_avl_walk_end(walk);
243*fa9e4066Sahrens 	uu_avl_destroy(cb.cb_avl);
244*fa9e4066Sahrens 	uu_avl_pool_destroy(avl_pool);
245*fa9e4066Sahrens 
246*fa9e4066Sahrens 	return (ret);
247*fa9e4066Sahrens }
248