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 https://opensource.org/licenses/CDDL-1.0.
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, 2019 by Delphix. All rights reserved.
25 * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
26 * Copyright (c) 2019 Datto Inc.
27 */
28
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <unistd.h>
33#include <stddef.h>
34#include <libintl.h>
35#include <libzfs.h>
36#include <libzutil.h>
37#include <sys/mntent.h>
38
39#include "libzfs_impl.h"
40
41static int
42zfs_iter_clones(zfs_handle_t *zhp, int flags __maybe_unused, zfs_iter_f func,
43    void *data)
44{
45	nvlist_t *nvl = zfs_get_clones_nvl(zhp);
46	nvpair_t *pair;
47
48	if (nvl == NULL)
49		return (0);
50
51	for (pair = nvlist_next_nvpair(nvl, NULL); pair != NULL;
52	    pair = nvlist_next_nvpair(nvl, pair)) {
53		zfs_handle_t *clone = zfs_open(zhp->zfs_hdl, nvpair_name(pair),
54		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
55		if (clone != NULL) {
56			int err = func(clone, data);
57			if (err != 0)
58				return (err);
59		}
60	}
61	return (0);
62}
63
64static int
65zfs_do_list_ioctl(zfs_handle_t *zhp, int arg, zfs_cmd_t *zc)
66{
67	int rc;
68	uint64_t	orig_cookie;
69
70	orig_cookie = zc->zc_cookie;
71top:
72	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
73	zc->zc_objset_stats.dds_creation_txg = 0;
74	rc = zfs_ioctl(zhp->zfs_hdl, arg, zc);
75
76	if (rc == -1) {
77		switch (errno) {
78		case ENOMEM:
79			/* expand nvlist memory and try again */
80			zcmd_expand_dst_nvlist(zhp->zfs_hdl, zc);
81			zc->zc_cookie = orig_cookie;
82			goto top;
83		/*
84		 * An errno value of ESRCH indicates normal completion.
85		 * If ENOENT is returned, then the underlying dataset
86		 * has been removed since we obtained the handle.
87		 */
88		case ESRCH:
89		case ENOENT:
90			rc = 1;
91			break;
92		default:
93			rc = zfs_standard_error(zhp->zfs_hdl, errno,
94			    dgettext(TEXT_DOMAIN,
95			    "cannot iterate filesystems"));
96			break;
97		}
98	}
99	return (rc);
100}
101
102/*
103 * Iterate over all child filesystems
104 */
105int
106zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
107{
108	return (zfs_iter_filesystems_v2(zhp, 0, func, data));
109}
110
111int
112zfs_iter_filesystems_v2(zfs_handle_t *zhp, int flags, zfs_iter_f func,
113    void *data)
114{
115	zfs_cmd_t zc = {"\0"};
116	zfs_handle_t *nzhp;
117	int ret;
118
119	if (zhp->zfs_type != ZFS_TYPE_FILESYSTEM)
120		return (0);
121
122	zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0);
123
124	if ((flags & ZFS_ITER_SIMPLE) == ZFS_ITER_SIMPLE)
125		zc.zc_simple = B_TRUE;
126
127	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_DATASET_LIST_NEXT,
128	    &zc)) == 0) {
129		if (zc.zc_simple)
130			nzhp = make_dataset_simple_handle_zc(zhp, &zc);
131		else
132			nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
133		/*
134		 * Silently ignore errors, as the only plausible explanation is
135		 * that the pool has since been removed.
136		 */
137		if (nzhp == NULL)
138			continue;
139
140		if ((ret = func(nzhp, data)) != 0) {
141			zcmd_free_nvlists(&zc);
142			return (ret);
143		}
144	}
145	zcmd_free_nvlists(&zc);
146	return ((ret < 0) ? ret : 0);
147}
148
149/*
150 * Iterate over all snapshots
151 */
152int
153zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
154    void *data, uint64_t min_txg, uint64_t max_txg)
155{
156	return (zfs_iter_snapshots_v2(zhp, simple ? ZFS_ITER_SIMPLE : 0, func,
157	    data, min_txg, max_txg));
158}
159
160int
161zfs_iter_snapshots_v2(zfs_handle_t *zhp, int flags, zfs_iter_f func,
162    void *data, uint64_t min_txg, uint64_t max_txg)
163{
164	zfs_cmd_t zc = {"\0"};
165	zfs_handle_t *nzhp;
166	int ret;
167	nvlist_t *range_nvl = NULL;
168
169	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT ||
170	    zhp->zfs_type == ZFS_TYPE_BOOKMARK)
171		return (0);
172
173	zc.zc_simple = (flags & ZFS_ITER_SIMPLE) != 0;
174
175	zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0);
176
177	if (min_txg != 0) {
178		range_nvl = fnvlist_alloc();
179		fnvlist_add_uint64(range_nvl, SNAP_ITER_MIN_TXG, min_txg);
180	}
181	if (max_txg != 0) {
182		if (range_nvl == NULL)
183			range_nvl = fnvlist_alloc();
184		fnvlist_add_uint64(range_nvl, SNAP_ITER_MAX_TXG, max_txg);
185	}
186
187	if (range_nvl != NULL)
188		zcmd_write_src_nvlist(zhp->zfs_hdl, &zc, range_nvl);
189
190	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
191	    &zc)) == 0) {
192
193		if (zc.zc_simple)
194			nzhp = make_dataset_simple_handle_zc(zhp, &zc);
195		else
196			nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
197		if (nzhp == NULL)
198			continue;
199
200		if ((ret = func(nzhp, data)) != 0) {
201			zcmd_free_nvlists(&zc);
202			fnvlist_free(range_nvl);
203			return (ret);
204		}
205	}
206	zcmd_free_nvlists(&zc);
207	fnvlist_free(range_nvl);
208	return ((ret < 0) ? ret : 0);
209}
210
211/*
212 * Iterate over all bookmarks
213 */
214int
215zfs_iter_bookmarks(zfs_handle_t *zhp, zfs_iter_f func, void *data)
216{
217	return (zfs_iter_bookmarks_v2(zhp, 0, func, data));
218}
219
220int
221zfs_iter_bookmarks_v2(zfs_handle_t *zhp, int flags __maybe_unused,
222    zfs_iter_f func, void *data)
223{
224	zfs_handle_t *nzhp;
225	nvlist_t *props = NULL;
226	nvlist_t *bmarks = NULL;
227	int err;
228	nvpair_t *pair;
229
230	if ((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT | ZFS_TYPE_BOOKMARK)) != 0)
231		return (0);
232
233	/* Setup the requested properties nvlist. */
234	props = fnvlist_alloc();
235	for (zfs_prop_t p = 0; p < ZFS_NUM_PROPS; p++) {
236		if (zfs_prop_valid_for_type(p, ZFS_TYPE_BOOKMARK, B_FALSE)) {
237			fnvlist_add_boolean(props, zfs_prop_to_name(p));
238		}
239	}
240	fnvlist_add_boolean(props, "redact_complete");
241
242	if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
243		goto out;
244
245	for (pair = nvlist_next_nvpair(bmarks, NULL);
246	    pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
247		char name[ZFS_MAX_DATASET_NAME_LEN];
248		const char *bmark_name;
249		nvlist_t *bmark_props;
250
251		bmark_name = nvpair_name(pair);
252		bmark_props = fnvpair_value_nvlist(pair);
253
254		if (snprintf(name, sizeof (name), "%s#%s", zhp->zfs_name,
255		    bmark_name) >= sizeof (name)) {
256			err = EINVAL;
257			goto out;
258		}
259
260		nzhp = make_bookmark_handle(zhp, name, bmark_props);
261		if (nzhp == NULL)
262			continue;
263
264		if ((err = func(nzhp, data)) != 0)
265			goto out;
266	}
267
268out:
269	fnvlist_free(props);
270	fnvlist_free(bmarks);
271
272	return (err);
273}
274
275/*
276 * Routines for dealing with the sorted snapshot functionality
277 */
278typedef struct zfs_node {
279	zfs_handle_t	*zn_handle;
280	avl_node_t	zn_avlnode;
281} zfs_node_t;
282
283static int
284zfs_sort_snaps(zfs_handle_t *zhp, void *data)
285{
286	avl_tree_t *avl = data;
287	zfs_node_t *node;
288	zfs_node_t search;
289
290	search.zn_handle = zhp;
291	node = avl_find(avl, &search, NULL);
292	if (node) {
293		/*
294		 * If this snapshot was renamed while we were creating the
295		 * AVL tree, it's possible that we already inserted it under
296		 * its old name. Remove the old handle before adding the new
297		 * one.
298		 */
299		zfs_close(node->zn_handle);
300		avl_remove(avl, node);
301		free(node);
302	}
303
304	node = zfs_alloc(zhp->zfs_hdl, sizeof (zfs_node_t));
305	node->zn_handle = zhp;
306	avl_add(avl, node);
307
308	return (0);
309}
310
311static int
312zfs_snapshot_compare(const void *larg, const void *rarg)
313{
314	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;
315	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;
316	uint64_t lcreate, rcreate;
317
318	/*
319	 * Sort them according to creation time.  We use the hidden
320	 * CREATETXG property to get an absolute ordering of snapshots.
321	 */
322	lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
323	rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);
324
325	return (TREE_CMP(lcreate, rcreate));
326}
327
328int
329zfs_iter_snapshots_sorted(zfs_handle_t *zhp, zfs_iter_f callback,
330    void *data, uint64_t min_txg, uint64_t max_txg)
331{
332	return (zfs_iter_snapshots_sorted_v2(zhp, 0, callback, data,
333	    min_txg, max_txg));
334}
335
336int
337zfs_iter_snapshots_sorted_v2(zfs_handle_t *zhp, int flags, zfs_iter_f callback,
338    void *data, uint64_t min_txg, uint64_t max_txg)
339{
340	int ret = 0;
341	zfs_node_t *node;
342	avl_tree_t avl;
343	void *cookie = NULL;
344
345	avl_create(&avl, zfs_snapshot_compare,
346	    sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));
347
348	ret = zfs_iter_snapshots_v2(zhp, flags, zfs_sort_snaps, &avl, min_txg,
349	    max_txg);
350
351	for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))
352		ret |= callback(node->zn_handle, data);
353
354	while ((node = avl_destroy_nodes(&avl, &cookie)) != NULL)
355		free(node);
356
357	avl_destroy(&avl);
358
359	return (ret);
360}
361
362typedef struct {
363	char *ssa_first;
364	char *ssa_last;
365	boolean_t ssa_seenfirst;
366	boolean_t ssa_seenlast;
367	zfs_iter_f ssa_func;
368	void *ssa_arg;
369} snapspec_arg_t;
370
371static int
372snapspec_cb(zfs_handle_t *zhp, void *arg)
373{
374	snapspec_arg_t *ssa = arg;
375	const char *shortsnapname;
376	int err = 0;
377
378	if (ssa->ssa_seenlast)
379		return (0);
380
381	shortsnapname = strchr(zfs_get_name(zhp), '@') + 1;
382	if (!ssa->ssa_seenfirst && strcmp(shortsnapname, ssa->ssa_first) == 0)
383		ssa->ssa_seenfirst = B_TRUE;
384	if (strcmp(shortsnapname, ssa->ssa_last) == 0)
385		ssa->ssa_seenlast = B_TRUE;
386
387	if (ssa->ssa_seenfirst) {
388		err = ssa->ssa_func(zhp, ssa->ssa_arg);
389	} else {
390		zfs_close(zhp);
391	}
392
393	return (err);
394}
395
396/*
397 * spec is a string like "A,B%C,D"
398 *
399 * <snaps>, where <snaps> can be:
400 *      <snap>          (single snapshot)
401 *      <snap>%<snap>   (range of snapshots, inclusive)
402 *      %<snap>         (range of snapshots, starting with earliest)
403 *      <snap>%         (range of snapshots, ending with last)
404 *      %               (all snapshots)
405 *      <snaps>[,...]   (comma separated list of the above)
406 *
407 * If a snapshot can not be opened, continue trying to open the others, but
408 * return ENOENT at the end.
409 */
410int
411zfs_iter_snapspec(zfs_handle_t *fs_zhp, const char *spec_orig,
412    zfs_iter_f func, void *arg)
413{
414	return (zfs_iter_snapspec_v2(fs_zhp, 0, spec_orig, func, arg));
415}
416
417int
418zfs_iter_snapspec_v2(zfs_handle_t *fs_zhp, int flags, const char *spec_orig,
419    zfs_iter_f func, void *arg)
420{
421	char *buf, *comma_separated, *cp;
422	int err = 0;
423	int ret = 0;
424
425	buf = zfs_strdup(fs_zhp->zfs_hdl, spec_orig);
426	cp = buf;
427
428	while ((comma_separated = strsep(&cp, ",")) != NULL) {
429		char *pct = strchr(comma_separated, '%');
430		if (pct != NULL) {
431			snapspec_arg_t ssa = { 0 };
432			ssa.ssa_func = func;
433			ssa.ssa_arg = arg;
434
435			if (pct == comma_separated)
436				ssa.ssa_seenfirst = B_TRUE;
437			else
438				ssa.ssa_first = comma_separated;
439			*pct = '\0';
440			ssa.ssa_last = pct + 1;
441
442			/*
443			 * If there is a lastname specified, make sure it
444			 * exists.
445			 */
446			if (ssa.ssa_last[0] != '\0') {
447				char snapname[ZFS_MAX_DATASET_NAME_LEN];
448				(void) snprintf(snapname, sizeof (snapname),
449				    "%s@%s", zfs_get_name(fs_zhp),
450				    ssa.ssa_last);
451				if (!zfs_dataset_exists(fs_zhp->zfs_hdl,
452				    snapname, ZFS_TYPE_SNAPSHOT)) {
453					ret = ENOENT;
454					continue;
455				}
456			}
457
458			err = zfs_iter_snapshots_sorted_v2(fs_zhp, flags,
459			    snapspec_cb, &ssa, 0, 0);
460			if (ret == 0)
461				ret = err;
462			if (ret == 0 && (!ssa.ssa_seenfirst ||
463			    (ssa.ssa_last[0] != '\0' && !ssa.ssa_seenlast))) {
464				ret = ENOENT;
465			}
466		} else {
467			char snapname[ZFS_MAX_DATASET_NAME_LEN];
468			zfs_handle_t *snap_zhp;
469			(void) snprintf(snapname, sizeof (snapname), "%s@%s",
470			    zfs_get_name(fs_zhp), comma_separated);
471			snap_zhp = make_dataset_handle(fs_zhp->zfs_hdl,
472			    snapname);
473			if (snap_zhp == NULL) {
474				ret = ENOENT;
475				continue;
476			}
477			err = func(snap_zhp, arg);
478			if (ret == 0)
479				ret = err;
480		}
481	}
482
483	free(buf);
484	return (ret);
485}
486
487/*
488 * Iterate over all children, snapshots and filesystems
489 * Process snapshots before filesystems because they are nearer the input
490 * handle: this is extremely important when used with zfs_iter_f functions
491 * looking for data, following the logic that we would like to find it as soon
492 * and as close as possible.
493 */
494int
495zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data)
496{
497	return (zfs_iter_children_v2(zhp, 0, func, data));
498}
499
500int
501zfs_iter_children_v2(zfs_handle_t *zhp, int flags, zfs_iter_f func, void *data)
502{
503	int ret;
504
505	if ((ret = zfs_iter_snapshots_v2(zhp, flags, func, data, 0, 0)) != 0)
506		return (ret);
507
508	return (zfs_iter_filesystems_v2(zhp, flags, func, data));
509}
510
511
512typedef struct iter_stack_frame {
513	struct iter_stack_frame *next;
514	zfs_handle_t *zhp;
515} iter_stack_frame_t;
516
517typedef struct iter_dependents_arg {
518	boolean_t first;
519	int flags;
520	boolean_t allowrecursion;
521	iter_stack_frame_t *stack;
522	zfs_iter_f func;
523	void *data;
524} iter_dependents_arg_t;
525
526static int
527iter_dependents_cb(zfs_handle_t *zhp, void *arg)
528{
529	iter_dependents_arg_t *ida = arg;
530	int err = 0;
531	boolean_t first = ida->first;
532	ida->first = B_FALSE;
533
534	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
535		err = zfs_iter_clones(zhp, ida->flags, iter_dependents_cb, ida);
536	} else if (zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
537		iter_stack_frame_t isf;
538		iter_stack_frame_t *f;
539
540		/*
541		 * check if there is a cycle by seeing if this fs is already
542		 * on the stack.
543		 */
544		for (f = ida->stack; f != NULL; f = f->next) {
545			if (f->zhp->zfs_dmustats.dds_guid ==
546			    zhp->zfs_dmustats.dds_guid) {
547				if (ida->allowrecursion) {
548					zfs_close(zhp);
549					return (0);
550				} else {
551					zfs_error_aux(zhp->zfs_hdl,
552					    dgettext(TEXT_DOMAIN,
553					    "recursive dependency at '%s'"),
554					    zfs_get_name(zhp));
555					err = zfs_error(zhp->zfs_hdl,
556					    EZFS_RECURSIVE,
557					    dgettext(TEXT_DOMAIN,
558					    "cannot determine dependent "
559					    "datasets"));
560					zfs_close(zhp);
561					return (err);
562				}
563			}
564		}
565
566		isf.zhp = zhp;
567		isf.next = ida->stack;
568		ida->stack = &isf;
569		err = zfs_iter_filesystems_v2(zhp, ida->flags,
570		    iter_dependents_cb, ida);
571		if (err == 0)
572			err = zfs_iter_snapshots_v2(zhp, ida->flags,
573			    iter_dependents_cb, ida, 0, 0);
574		ida->stack = isf.next;
575	}
576
577	if (!first && err == 0)
578		err = ida->func(zhp, ida->data);
579	else
580		zfs_close(zhp);
581
582	return (err);
583}
584
585int
586zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
587    zfs_iter_f func, void *data)
588{
589	return (zfs_iter_dependents_v2(zhp, 0, allowrecursion, func, data));
590}
591
592int
593zfs_iter_dependents_v2(zfs_handle_t *zhp, int flags, boolean_t allowrecursion,
594    zfs_iter_f func, void *data)
595{
596	iter_dependents_arg_t ida;
597	ida.flags = flags;
598	ida.allowrecursion = allowrecursion;
599	ida.stack = NULL;
600	ida.func = func;
601	ida.data = data;
602	ida.first = B_TRUE;
603	return (iter_dependents_cb(zfs_handle_dup(zhp), &ida));
604}
605
606/*
607 * Iterate over mounted children of the specified dataset
608 */
609int
610zfs_iter_mounted(zfs_handle_t *zhp, zfs_iter_f func, void *data)
611{
612	char mnt_prop[ZFS_MAXPROPLEN];
613	struct mnttab entry;
614	zfs_handle_t *mtab_zhp;
615	size_t namelen = strlen(zhp->zfs_name);
616	FILE *mnttab;
617	int err = 0;
618
619	if ((mnttab = fopen(MNTTAB, "re")) == NULL)
620		return (ENOENT);
621
622	while (err == 0 && getmntent(mnttab, &entry) == 0) {
623		/* Ignore non-ZFS entries */
624		if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
625			continue;
626
627		/* Ignore datasets not within the provided dataset */
628		if (strncmp(entry.mnt_special, zhp->zfs_name, namelen) != 0 ||
629		    entry.mnt_special[namelen] != '/')
630			continue;
631
632		/* Skip snapshot of any child dataset */
633		if (strchr(entry.mnt_special, '@') != NULL)
634			continue;
635
636		if ((mtab_zhp = zfs_open(zhp->zfs_hdl, entry.mnt_special,
637		    ZFS_TYPE_FILESYSTEM)) == NULL)
638			continue;
639
640		/* Ignore legacy mounts as they are user managed */
641		verify(zfs_prop_get(mtab_zhp, ZFS_PROP_MOUNTPOINT, mnt_prop,
642		    sizeof (mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
643		if (strcmp(mnt_prop, "legacy") == 0) {
644			zfs_close(mtab_zhp);
645			continue;
646		}
647
648		err = func(mtab_zhp, data);
649	}
650
651	fclose(mnttab);
652
653	return (err);
654}
655