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