xref: /illumos-gate/usr/src/cmd/zfs/zfs_iter.c (revision 1473b8d6)
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.
24  * Copyright (c) 2012 Pawel Jakub Dawidek. All rights reserved.
25  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
26  * Copyright (c) 2013 by Delphix. All rights reserved.
27  */
28 
29 #include <libintl.h>
30 #include <libuutil.h>
31 #include <stddef.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <strings.h>
35 
36 #include <libzfs.h>
37 
38 #include "zfs_util.h"
39 #include "zfs_iter.h"
40 
41 /*
42  * This is a private interface used to gather up all the datasets specified on
43  * the command line so that we can iterate over them in order.
44  *
45  * First, we iterate over all filesystems, gathering them together into an
46  * AVL tree.  We report errors for any explicitly specified datasets
47  * that we couldn't open.
48  *
49  * When finished, we have an AVL tree of ZFS handles.  We go through and execute
50  * the provided callback for each one, passing whatever data the user supplied.
51  */
52 
53 typedef struct zfs_node {
54 	zfs_handle_t	*zn_handle;
55 	uu_avl_node_t	zn_avlnode;
56 } zfs_node_t;
57 
58 typedef struct callback_data {
59 	uu_avl_t		*cb_avl;
60 	int			cb_flags;
61 	zfs_type_t		cb_types;
62 	zfs_sort_column_t	*cb_sortcol;
63 	zprop_list_t		**cb_proplist;
64 	int			cb_depth_limit;
65 	int			cb_depth;
66 	uint8_t			cb_props_table[ZFS_NUM_PROPS];
67 } callback_data_t;
68 
69 uu_avl_pool_t *avl_pool;
70 
71 /*
72  * Include snaps if they were requested or if this a zfs list where types
73  * were not specified and the "listsnapshots" property is set on this pool.
74  */
75 static boolean_t
zfs_include_snapshots(zfs_handle_t * zhp,callback_data_t * cb)76 zfs_include_snapshots(zfs_handle_t *zhp, callback_data_t *cb)
77 {
78 	zpool_handle_t *zph;
79 
80 	if ((cb->cb_flags & ZFS_ITER_PROP_LISTSNAPS) == 0)
81 		return (cb->cb_types & ZFS_TYPE_SNAPSHOT);
82 
83 	zph = zfs_get_pool_handle(zhp);
84 	return (zpool_get_prop_int(zph, ZPOOL_PROP_LISTSNAPS, NULL));
85 }
86 
87 /*
88  * Called for each dataset.  If the object is of an appropriate type,
89  * add it to the avl tree and recurse over any children as necessary.
90  */
91 static int
zfs_callback(zfs_handle_t * zhp,void * data)92 zfs_callback(zfs_handle_t *zhp, void *data)
93 {
94 	callback_data_t *cb = data;
95 	boolean_t should_close = B_TRUE;
96 	boolean_t include_snaps = zfs_include_snapshots(zhp, cb);
97 	boolean_t include_bmarks = (cb->cb_types & ZFS_TYPE_BOOKMARK);
98 
99 	if ((zfs_get_type(zhp) & cb->cb_types) ||
100 	    ((zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) && include_snaps)) {
101 		uu_avl_index_t idx;
102 		zfs_node_t *node = safe_malloc(sizeof (zfs_node_t));
103 
104 		node->zn_handle = zhp;
105 		uu_avl_node_init(node, &node->zn_avlnode, avl_pool);
106 		if (uu_avl_find(cb->cb_avl, node, cb->cb_sortcol,
107 		    &idx) == NULL) {
108 			if (cb->cb_proplist) {
109 				if ((*cb->cb_proplist) &&
110 				    !(*cb->cb_proplist)->pl_all)
111 					zfs_prune_proplist(zhp,
112 					    cb->cb_props_table);
113 
114 				if (zfs_expand_proplist(zhp, cb->cb_proplist,
115 				    (cb->cb_flags & ZFS_ITER_RECVD_PROPS),
116 				    (cb->cb_flags & ZFS_ITER_LITERAL_PROPS))
117 				    != 0) {
118 					free(node);
119 					return (-1);
120 				}
121 			}
122 			uu_avl_insert(cb->cb_avl, node, idx);
123 			should_close = B_FALSE;
124 		} else {
125 			free(node);
126 		}
127 	}
128 
129 	/*
130 	 * Recurse if necessary.
131 	 */
132 	if (cb->cb_flags & ZFS_ITER_RECURSE &&
133 	    ((cb->cb_flags & ZFS_ITER_DEPTH_LIMIT) == 0 ||
134 	    cb->cb_depth < cb->cb_depth_limit)) {
135 		cb->cb_depth++;
136 		if (zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM)
137 			(void) zfs_iter_filesystems(zhp, zfs_callback, data);
138 		if (((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT |
139 		    ZFS_TYPE_BOOKMARK)) == 0) && include_snaps)
140 			(void) zfs_iter_snapshots(zhp,
141 			    (cb->cb_flags & ZFS_ITER_SIMPLE) != 0, zfs_callback,
142 			    data);
143 		if (((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT |
144 		    ZFS_TYPE_BOOKMARK)) == 0) && include_bmarks)
145 			(void) zfs_iter_bookmarks(zhp, zfs_callback, data);
146 		cb->cb_depth--;
147 	}
148 
149 	if (should_close)
150 		zfs_close(zhp);
151 
152 	return (0);
153 }
154 
155 int
zfs_add_sort_column(zfs_sort_column_t ** sc,const char * name,boolean_t reverse)156 zfs_add_sort_column(zfs_sort_column_t **sc, const char *name,
157     boolean_t reverse)
158 {
159 	zfs_sort_column_t *col;
160 	zfs_prop_t prop;
161 
162 	if ((prop = zfs_name_to_prop(name)) == ZPROP_INVAL &&
163 	    !zfs_prop_user(name))
164 		return (-1);
165 
166 	col = safe_malloc(sizeof (zfs_sort_column_t));
167 
168 	col->sc_prop = prop;
169 	col->sc_reverse = reverse;
170 	if (prop == ZPROP_INVAL) {
171 		col->sc_user_prop = safe_malloc(strlen(name) + 1);
172 		(void) strcpy(col->sc_user_prop, name);
173 	}
174 
175 	if (*sc == NULL) {
176 		col->sc_last = col;
177 		*sc = col;
178 	} else {
179 		(*sc)->sc_last->sc_next = col;
180 		(*sc)->sc_last = col;
181 	}
182 
183 	return (0);
184 }
185 
186 void
zfs_free_sort_columns(zfs_sort_column_t * sc)187 zfs_free_sort_columns(zfs_sort_column_t *sc)
188 {
189 	zfs_sort_column_t *col;
190 
191 	while (sc != NULL) {
192 		col = sc->sc_next;
193 		free(sc->sc_user_prop);
194 		free(sc);
195 		sc = col;
196 	}
197 }
198 
199 boolean_t
zfs_sort_only_by_name(const zfs_sort_column_t * sc)200 zfs_sort_only_by_name(const zfs_sort_column_t *sc)
201 {
202 
203 	return (sc != NULL && sc->sc_next == NULL &&
204 	    sc->sc_prop == ZFS_PROP_NAME);
205 }
206 
207 /* ARGSUSED */
208 static int
zfs_compare(const void * larg,const void * rarg,void * unused)209 zfs_compare(const void *larg, const void *rarg, void *unused)
210 {
211 	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;
212 	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;
213 	const char *lname = zfs_get_name(l);
214 	const char *rname = zfs_get_name(r);
215 	char *lat, *rat;
216 	uint64_t lcreate, rcreate;
217 	int ret;
218 
219 	lat = (char *)strchr(lname, '@');
220 	rat = (char *)strchr(rname, '@');
221 
222 	if (lat != NULL)
223 		*lat = '\0';
224 	if (rat != NULL)
225 		*rat = '\0';
226 
227 	ret = strcmp(lname, rname);
228 	if (ret == 0) {
229 		/*
230 		 * If we're comparing a dataset to one of its snapshots, we
231 		 * always make the full dataset first.
232 		 */
233 		if (lat == NULL) {
234 			ret = -1;
235 		} else if (rat == NULL) {
236 			ret = 1;
237 		} else {
238 			/*
239 			 * If we have two snapshots from the same dataset, then
240 			 * we want to sort them according to creation time.  We
241 			 * use the hidden CREATETXG property to get an absolute
242 			 * ordering of snapshots.
243 			 */
244 			lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
245 			rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);
246 
247 			/*
248 			 * Both lcreate and rcreate being 0 means we don't have
249 			 * properties and we should compare full name.
250 			 */
251 			if (lcreate == 0 && rcreate == 0)
252 				ret = strcmp(lat + 1, rat + 1);
253 			else if (lcreate < rcreate)
254 				ret = -1;
255 			else if (lcreate > rcreate)
256 				ret = 1;
257 		}
258 	}
259 
260 	if (lat != NULL)
261 		*lat = '@';
262 	if (rat != NULL)
263 		*rat = '@';
264 
265 	return (ret);
266 }
267 
268 /*
269  * Sort datasets by specified columns.
270  *
271  * o  Numeric types sort in ascending order.
272  * o  String types sort in alphabetical order.
273  * o  Types inappropriate for a row sort that row to the literal
274  *    bottom, regardless of the specified ordering.
275  *
276  * If no sort columns are specified, or two datasets compare equally
277  * across all specified columns, they are sorted alphabetically by name
278  * with snapshots grouped under their parents.
279  */
280 static int
zfs_sort(const void * larg,const void * rarg,void * data)281 zfs_sort(const void *larg, const void *rarg, void *data)
282 {
283 	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;
284 	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;
285 	zfs_sort_column_t *sc = (zfs_sort_column_t *)data;
286 	zfs_sort_column_t *psc;
287 
288 	for (psc = sc; psc != NULL; psc = psc->sc_next) {
289 		char lbuf[ZFS_MAXPROPLEN], rbuf[ZFS_MAXPROPLEN];
290 		char *lstr, *rstr;
291 		uint64_t lnum, rnum;
292 		boolean_t lvalid, rvalid;
293 		int ret = 0;
294 
295 		/*
296 		 * We group the checks below the generic code.  If 'lstr' and
297 		 * 'rstr' are non-NULL, then we do a string based comparison.
298 		 * Otherwise, we compare 'lnum' and 'rnum'.
299 		 */
300 		lstr = rstr = NULL;
301 		if (psc->sc_prop == ZPROP_INVAL) {
302 			nvlist_t *luser, *ruser;
303 			nvlist_t *lval, *rval;
304 
305 			luser = zfs_get_user_props(l);
306 			ruser = zfs_get_user_props(r);
307 
308 			lvalid = (nvlist_lookup_nvlist(luser,
309 			    psc->sc_user_prop, &lval) == 0);
310 			rvalid = (nvlist_lookup_nvlist(ruser,
311 			    psc->sc_user_prop, &rval) == 0);
312 
313 			if (lvalid)
314 				verify(nvlist_lookup_string(lval,
315 				    ZPROP_VALUE, &lstr) == 0);
316 			if (rvalid)
317 				verify(nvlist_lookup_string(rval,
318 				    ZPROP_VALUE, &rstr) == 0);
319 		} else if (psc->sc_prop == ZFS_PROP_NAME) {
320 			lvalid = rvalid = B_TRUE;
321 
322 			(void) strlcpy(lbuf, zfs_get_name(l), sizeof (lbuf));
323 			(void) strlcpy(rbuf, zfs_get_name(r), sizeof (rbuf));
324 
325 			lstr = lbuf;
326 			rstr = rbuf;
327 		} else if (zfs_prop_is_string(psc->sc_prop)) {
328 			lvalid = (zfs_prop_get(l, psc->sc_prop, lbuf,
329 			    sizeof (lbuf), NULL, NULL, 0, B_TRUE) == 0);
330 			rvalid = (zfs_prop_get(r, psc->sc_prop, rbuf,
331 			    sizeof (rbuf), NULL, NULL, 0, B_TRUE) == 0);
332 
333 			lstr = lbuf;
334 			rstr = rbuf;
335 		} else {
336 			lvalid = zfs_prop_valid_for_type(psc->sc_prop,
337 			    zfs_get_type(l));
338 			rvalid = zfs_prop_valid_for_type(psc->sc_prop,
339 			    zfs_get_type(r));
340 
341 			if (lvalid)
342 				(void) zfs_prop_get_numeric(l, psc->sc_prop,
343 				    &lnum, NULL, NULL, 0);
344 			if (rvalid)
345 				(void) zfs_prop_get_numeric(r, psc->sc_prop,
346 				    &rnum, NULL, NULL, 0);
347 		}
348 
349 		if (!lvalid && !rvalid)
350 			continue;
351 		else if (!lvalid)
352 			return (1);
353 		else if (!rvalid)
354 			return (-1);
355 
356 		if (lstr)
357 			ret = strcmp(lstr, rstr);
358 		else if (lnum < rnum)
359 			ret = -1;
360 		else if (lnum > rnum)
361 			ret = 1;
362 
363 		if (ret != 0) {
364 			if (psc->sc_reverse == B_TRUE)
365 				ret = (ret < 0) ? 1 : -1;
366 			return (ret);
367 		}
368 	}
369 
370 	return (zfs_compare(larg, rarg, NULL));
371 }
372 
373 int
zfs_for_each(int argc,char ** argv,int flags,zfs_type_t types,zfs_sort_column_t * sortcol,zprop_list_t ** proplist,int limit,zfs_iter_f callback,void * data)374 zfs_for_each(int argc, char **argv, int flags, zfs_type_t types,
375     zfs_sort_column_t *sortcol, zprop_list_t **proplist, int limit,
376     zfs_iter_f callback, void *data)
377 {
378 	callback_data_t cb = {0};
379 	int ret = 0;
380 	zfs_node_t *node;
381 	uu_avl_walk_t *walk;
382 
383 	avl_pool = uu_avl_pool_create("zfs_pool", sizeof (zfs_node_t),
384 	    offsetof(zfs_node_t, zn_avlnode), zfs_sort, UU_DEFAULT);
385 
386 	if (avl_pool == NULL)
387 		nomem();
388 
389 	cb.cb_sortcol = sortcol;
390 	cb.cb_flags = flags;
391 	cb.cb_proplist = proplist;
392 	cb.cb_types = types;
393 	cb.cb_depth_limit = limit;
394 	/*
395 	 * If cb_proplist is provided then in the zfs_handles created we
396 	 * retain only those properties listed in cb_proplist and sortcol.
397 	 * The rest are pruned. So, the caller should make sure that no other
398 	 * properties other than those listed in cb_proplist/sortcol are
399 	 * accessed.
400 	 *
401 	 * If cb_proplist is NULL then we retain all the properties.  We
402 	 * always retain the zoned property, which some other properties
403 	 * need (userquota & friends), and the createtxg property, which
404 	 * we need to sort snapshots.
405 	 */
406 	if (cb.cb_proplist && *cb.cb_proplist) {
407 		zprop_list_t *p = *cb.cb_proplist;
408 
409 		while (p) {
410 			if (p->pl_prop >= ZFS_PROP_TYPE &&
411 			    p->pl_prop < ZFS_NUM_PROPS) {
412 				cb.cb_props_table[p->pl_prop] = B_TRUE;
413 			}
414 			p = p->pl_next;
415 		}
416 
417 		while (sortcol) {
418 			if (sortcol->sc_prop >= ZFS_PROP_TYPE &&
419 			    sortcol->sc_prop < ZFS_NUM_PROPS) {
420 				cb.cb_props_table[sortcol->sc_prop] = B_TRUE;
421 			}
422 			sortcol = sortcol->sc_next;
423 		}
424 
425 		cb.cb_props_table[ZFS_PROP_ZONED] = B_TRUE;
426 		cb.cb_props_table[ZFS_PROP_CREATETXG] = B_TRUE;
427 	} else {
428 		(void) memset(cb.cb_props_table, B_TRUE,
429 		    sizeof (cb.cb_props_table));
430 	}
431 
432 	if ((cb.cb_avl = uu_avl_create(avl_pool, NULL, UU_DEFAULT)) == NULL)
433 		nomem();
434 
435 	if (argc == 0) {
436 		/*
437 		 * If given no arguments, iterate over all datasets.
438 		 */
439 		cb.cb_flags |= ZFS_ITER_RECURSE;
440 		ret = zfs_iter_root(g_zfs, zfs_callback, &cb);
441 	} else {
442 		int i;
443 		zfs_handle_t *zhp;
444 		zfs_type_t argtype;
445 
446 		/*
447 		 * If we're recursive, then we always allow filesystems as
448 		 * arguments.  If we also are interested in snapshots or
449 		 * bookmarks, then we can take volumes as well.
450 		 */
451 		argtype = types;
452 		if (flags & ZFS_ITER_RECURSE) {
453 			argtype |= ZFS_TYPE_FILESYSTEM;
454 			if (types & (ZFS_TYPE_SNAPSHOT | ZFS_TYPE_BOOKMARK))
455 				argtype |= ZFS_TYPE_VOLUME;
456 		}
457 
458 		for (i = 0; i < argc; i++) {
459 			if (flags & ZFS_ITER_ARGS_CAN_BE_PATHS) {
460 				zhp = zfs_path_to_zhandle(g_zfs, argv[i],
461 				    argtype);
462 			} else {
463 				zhp = zfs_open(g_zfs, argv[i], argtype);
464 			}
465 			if (zhp != NULL)
466 				ret |= zfs_callback(zhp, &cb);
467 			else
468 				ret = 1;
469 		}
470 	}
471 
472 	/*
473 	 * At this point we've got our AVL tree full of zfs handles, so iterate
474 	 * over each one and execute the real user callback.
475 	 */
476 	for (node = uu_avl_first(cb.cb_avl); node != NULL;
477 	    node = uu_avl_next(cb.cb_avl, node))
478 		ret |= callback(node->zn_handle, data);
479 
480 	/*
481 	 * Finally, clean up the AVL tree.
482 	 */
483 	if ((walk = uu_avl_walk_start(cb.cb_avl, UU_WALK_ROBUST)) == NULL)
484 		nomem();
485 
486 	while ((node = uu_avl_walk_next(walk)) != NULL) {
487 		uu_avl_remove(cb.cb_avl, node);
488 		zfs_close(node->zn_handle);
489 		free(node);
490 	}
491 
492 	uu_avl_walk_end(walk);
493 	uu_avl_destroy(cb.cb_avl);
494 	uu_avl_pool_destroy(avl_pool);
495 
496 	return (ret);
497 }
498