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.
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.
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]
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.
37 #include <sys/mntent.h>
39 #include "libzfs_impl.h"
42 zfs_iter_clones(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
44 nvlist_t
*nvl
= zfs_get_clones_nvl(zhp
);
50 for (pair
= nvlist_next_nvpair(nvl
, NULL
); pair
!= NULL
;
51 pair
= nvlist_next_nvpair(nvl
, pair
)) {
52 zfs_handle_t
*clone
= zfs_open(zhp
->zfs_hdl
, nvpair_name(pair
),
53 ZFS_TYPE_FILESYSTEM
| ZFS_TYPE_VOLUME
);
55 int err
= func(clone
, data
);
64 zfs_do_list_ioctl(zfs_handle_t
*zhp
, int arg
, zfs_cmd_t
*zc
)
69 orig_cookie
= zc
->zc_cookie
;
71 (void) strlcpy(zc
->zc_name
, zhp
->zfs_name
, sizeof (zc
->zc_name
));
72 rc
= zfs_ioctl(zhp
->zfs_hdl
, arg
, zc
);
77 /* expand nvlist memory and try again */
78 if (zcmd_expand_dst_nvlist(zhp
->zfs_hdl
, zc
) != 0) {
79 zcmd_free_nvlists(zc
);
82 zc
->zc_cookie
= orig_cookie
;
85 * An errno value of ESRCH indicates normal completion.
86 * If ENOENT is returned, then the underlying dataset
87 * has been removed since we obtained the handle.
94 rc
= zfs_standard_error(zhp
->zfs_hdl
, errno
,
96 "cannot iterate filesystems"));
104 * Iterate over all child filesystems
107 zfs_iter_filesystems(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
109 zfs_cmd_t zc
= {"\0"};
113 if (zhp
->zfs_type
!= ZFS_TYPE_FILESYSTEM
)
116 if (zcmd_alloc_dst_nvlist(zhp
->zfs_hdl
, &zc
, 0) != 0)
119 while ((ret
= zfs_do_list_ioctl(zhp
, ZFS_IOC_DATASET_LIST_NEXT
,
122 * Silently ignore errors, as the only plausible explanation is
123 * that the pool has since been removed.
125 if ((nzhp
= make_dataset_handle_zc(zhp
->zfs_hdl
,
130 if ((ret
= func(nzhp
, data
)) != 0) {
131 zcmd_free_nvlists(&zc
);
135 zcmd_free_nvlists(&zc
);
136 return ((ret
< 0) ? ret
: 0);
140 * Iterate over all snapshots
143 zfs_iter_snapshots(zfs_handle_t
*zhp
, boolean_t simple
, zfs_iter_f func
,
144 void *data
, uint64_t min_txg
, uint64_t max_txg
)
146 zfs_cmd_t zc
= {"\0"};
149 nvlist_t
*range_nvl
= NULL
;
151 if (zhp
->zfs_type
== ZFS_TYPE_SNAPSHOT
||
152 zhp
->zfs_type
== ZFS_TYPE_BOOKMARK
)
155 zc
.zc_simple
= simple
;
157 if (zcmd_alloc_dst_nvlist(zhp
->zfs_hdl
, &zc
, 0) != 0)
161 range_nvl
= fnvlist_alloc();
162 fnvlist_add_uint64(range_nvl
, SNAP_ITER_MIN_TXG
, min_txg
);
165 if (range_nvl
== NULL
)
166 range_nvl
= fnvlist_alloc();
167 fnvlist_add_uint64(range_nvl
, SNAP_ITER_MAX_TXG
, max_txg
);
170 if (range_nvl
!= NULL
&&
171 zcmd_write_src_nvlist(zhp
->zfs_hdl
, &zc
, range_nvl
) != 0) {
172 zcmd_free_nvlists(&zc
);
173 fnvlist_free(range_nvl
);
177 while ((ret
= zfs_do_list_ioctl(zhp
, ZFS_IOC_SNAPSHOT_LIST_NEXT
,
181 nzhp
= make_dataset_simple_handle_zc(zhp
, &zc
);
183 nzhp
= make_dataset_handle_zc(zhp
->zfs_hdl
, &zc
);
187 if ((ret
= func(nzhp
, data
)) != 0) {
188 zcmd_free_nvlists(&zc
);
189 fnvlist_free(range_nvl
);
193 zcmd_free_nvlists(&zc
);
194 fnvlist_free(range_nvl
);
195 return ((ret
< 0) ? ret
: 0);
199 * Iterate over all bookmarks
202 zfs_iter_bookmarks(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
205 nvlist_t
*props
= NULL
;
206 nvlist_t
*bmarks
= NULL
;
210 if ((zfs_get_type(zhp
) & (ZFS_TYPE_SNAPSHOT
| ZFS_TYPE_BOOKMARK
)) != 0)
213 /* Setup the requested properties nvlist. */
214 props
= fnvlist_alloc();
215 for (zfs_prop_t p
= 0; p
< ZFS_NUM_PROPS
; p
++) {
216 if (zfs_prop_valid_for_type(p
, ZFS_TYPE_BOOKMARK
, B_FALSE
)) {
217 fnvlist_add_boolean(props
, zfs_prop_to_name(p
));
220 fnvlist_add_boolean(props
, "redact_complete");
222 if ((err
= lzc_get_bookmarks(zhp
->zfs_name
, props
, &bmarks
)) != 0)
225 for (pair
= nvlist_next_nvpair(bmarks
, NULL
);
226 pair
!= NULL
; pair
= nvlist_next_nvpair(bmarks
, pair
)) {
227 char name
[ZFS_MAX_DATASET_NAME_LEN
];
229 nvlist_t
*bmark_props
;
231 bmark_name
= nvpair_name(pair
);
232 bmark_props
= fnvpair_value_nvlist(pair
);
234 if (snprintf(name
, sizeof (name
), "%s#%s", zhp
->zfs_name
,
235 bmark_name
) >= sizeof (name
)) {
240 nzhp
= make_bookmark_handle(zhp
, name
, bmark_props
);
244 if ((err
= func(nzhp
, data
)) != 0)
250 fnvlist_free(bmarks
);
256 * Routines for dealing with the sorted snapshot functionality
258 typedef struct zfs_node
{
259 zfs_handle_t
*zn_handle
;
260 avl_node_t zn_avlnode
;
264 zfs_sort_snaps(zfs_handle_t
*zhp
, void *data
)
266 avl_tree_t
*avl
= data
;
270 search
.zn_handle
= zhp
;
271 node
= avl_find(avl
, &search
, NULL
);
274 * If this snapshot was renamed while we were creating the
275 * AVL tree, it's possible that we already inserted it under
276 * its old name. Remove the old handle before adding the new
279 zfs_close(node
->zn_handle
);
280 avl_remove(avl
, node
);
284 node
= zfs_alloc(zhp
->zfs_hdl
, sizeof (zfs_node_t
));
285 node
->zn_handle
= zhp
;
292 zfs_snapshot_compare(const void *larg
, const void *rarg
)
294 zfs_handle_t
*l
= ((zfs_node_t
*)larg
)->zn_handle
;
295 zfs_handle_t
*r
= ((zfs_node_t
*)rarg
)->zn_handle
;
296 uint64_t lcreate
, rcreate
;
299 * Sort them according to creation time. We use the hidden
300 * CREATETXG property to get an absolute ordering of snapshots.
302 lcreate
= zfs_prop_get_int(l
, ZFS_PROP_CREATETXG
);
303 rcreate
= zfs_prop_get_int(r
, ZFS_PROP_CREATETXG
);
305 return (TREE_CMP(lcreate
, rcreate
));
309 zfs_iter_snapshots_sorted(zfs_handle_t
*zhp
, zfs_iter_f callback
, void *data
,
310 uint64_t min_txg
, uint64_t max_txg
)
317 avl_create(&avl
, zfs_snapshot_compare
,
318 sizeof (zfs_node_t
), offsetof(zfs_node_t
, zn_avlnode
));
320 ret
= zfs_iter_snapshots(zhp
, B_FALSE
, zfs_sort_snaps
, &avl
, min_txg
,
323 for (node
= avl_first(&avl
); node
!= NULL
; node
= AVL_NEXT(&avl
, node
))
324 ret
|= callback(node
->zn_handle
, data
);
326 while ((node
= avl_destroy_nodes(&avl
, &cookie
)) != NULL
)
337 boolean_t ssa_seenfirst
;
338 boolean_t ssa_seenlast
;
344 snapspec_cb(zfs_handle_t
*zhp
, void *arg
)
346 snapspec_arg_t
*ssa
= arg
;
347 const char *shortsnapname
;
350 if (ssa
->ssa_seenlast
)
353 shortsnapname
= strchr(zfs_get_name(zhp
), '@') + 1;
354 if (!ssa
->ssa_seenfirst
&& strcmp(shortsnapname
, ssa
->ssa_first
) == 0)
355 ssa
->ssa_seenfirst
= B_TRUE
;
356 if (strcmp(shortsnapname
, ssa
->ssa_last
) == 0)
357 ssa
->ssa_seenlast
= B_TRUE
;
359 if (ssa
->ssa_seenfirst
) {
360 err
= ssa
->ssa_func(zhp
, ssa
->ssa_arg
);
369 * spec is a string like "A,B%C,D"
371 * <snaps>, where <snaps> can be:
372 * <snap> (single snapshot)
373 * <snap>%<snap> (range of snapshots, inclusive)
374 * %<snap> (range of snapshots, starting with earliest)
375 * <snap>% (range of snapshots, ending with last)
377 * <snaps>[,...] (comma separated list of the above)
379 * If a snapshot can not be opened, continue trying to open the others, but
380 * return ENOENT at the end.
383 zfs_iter_snapspec(zfs_handle_t
*fs_zhp
, const char *spec_orig
,
384 zfs_iter_f func
, void *arg
)
386 char *buf
, *comma_separated
, *cp
;
390 buf
= zfs_strdup(fs_zhp
->zfs_hdl
, spec_orig
);
393 while ((comma_separated
= strsep(&cp
, ",")) != NULL
) {
394 char *pct
= strchr(comma_separated
, '%');
396 snapspec_arg_t ssa
= { 0 };
400 if (pct
== comma_separated
)
401 ssa
.ssa_seenfirst
= B_TRUE
;
403 ssa
.ssa_first
= comma_separated
;
405 ssa
.ssa_last
= pct
+ 1;
408 * If there is a lastname specified, make sure it
411 if (ssa
.ssa_last
[0] != '\0') {
412 char snapname
[ZFS_MAX_DATASET_NAME_LEN
];
413 (void) snprintf(snapname
, sizeof (snapname
),
414 "%s@%s", zfs_get_name(fs_zhp
),
416 if (!zfs_dataset_exists(fs_zhp
->zfs_hdl
,
417 snapname
, ZFS_TYPE_SNAPSHOT
)) {
423 err
= zfs_iter_snapshots_sorted(fs_zhp
,
424 snapspec_cb
, &ssa
, 0, 0);
427 if (ret
== 0 && (!ssa
.ssa_seenfirst
||
428 (ssa
.ssa_last
[0] != '\0' && !ssa
.ssa_seenlast
))) {
432 char snapname
[ZFS_MAX_DATASET_NAME_LEN
];
433 zfs_handle_t
*snap_zhp
;
434 (void) snprintf(snapname
, sizeof (snapname
), "%s@%s",
435 zfs_get_name(fs_zhp
), comma_separated
);
436 snap_zhp
= make_dataset_handle(fs_zhp
->zfs_hdl
,
438 if (snap_zhp
== NULL
) {
442 err
= func(snap_zhp
, arg
);
453 * Iterate over all children, snapshots and filesystems
454 * Process snapshots before filesystems because they are nearer the input
455 * handle: this is extremely important when used with zfs_iter_f functions
456 * looking for data, following the logic that we would like to find it as soon
457 * and as close as possible.
460 zfs_iter_children(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
464 if ((ret
= zfs_iter_snapshots(zhp
, B_FALSE
, func
, data
, 0, 0)) != 0)
467 return (zfs_iter_filesystems(zhp
, func
, data
));
471 typedef struct iter_stack_frame
{
472 struct iter_stack_frame
*next
;
474 } iter_stack_frame_t
;
476 typedef struct iter_dependents_arg
{
478 boolean_t allowrecursion
;
479 iter_stack_frame_t
*stack
;
482 } iter_dependents_arg_t
;
485 iter_dependents_cb(zfs_handle_t
*zhp
, void *arg
)
487 iter_dependents_arg_t
*ida
= arg
;
489 boolean_t first
= ida
->first
;
490 ida
->first
= B_FALSE
;
492 if (zhp
->zfs_type
== ZFS_TYPE_SNAPSHOT
) {
493 err
= zfs_iter_clones(zhp
, iter_dependents_cb
, ida
);
494 } else if (zhp
->zfs_type
!= ZFS_TYPE_BOOKMARK
) {
495 iter_stack_frame_t isf
;
496 iter_stack_frame_t
*f
;
499 * check if there is a cycle by seeing if this fs is already
502 for (f
= ida
->stack
; f
!= NULL
; f
= f
->next
) {
503 if (f
->zhp
->zfs_dmustats
.dds_guid
==
504 zhp
->zfs_dmustats
.dds_guid
) {
505 if (ida
->allowrecursion
) {
509 zfs_error_aux(zhp
->zfs_hdl
,
510 dgettext(TEXT_DOMAIN
,
511 "recursive dependency at '%s'"),
513 err
= zfs_error(zhp
->zfs_hdl
,
515 dgettext(TEXT_DOMAIN
,
516 "cannot determine dependent "
525 isf
.next
= ida
->stack
;
527 err
= zfs_iter_filesystems(zhp
, iter_dependents_cb
, ida
);
529 err
= zfs_iter_snapshots(zhp
, B_FALSE
,
530 iter_dependents_cb
, ida
, 0, 0);
531 ida
->stack
= isf
.next
;
534 if (!first
&& err
== 0)
535 err
= ida
->func(zhp
, ida
->data
);
543 zfs_iter_dependents(zfs_handle_t
*zhp
, boolean_t allowrecursion
,
544 zfs_iter_f func
, void *data
)
546 iter_dependents_arg_t ida
;
547 ida
.allowrecursion
= allowrecursion
;
552 return (iter_dependents_cb(zfs_handle_dup(zhp
), &ida
));
556 * Iterate over mounted children of the specified dataset
559 zfs_iter_mounted(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
561 char mnt_prop
[ZFS_MAXPROPLEN
];
563 zfs_handle_t
*mtab_zhp
;
564 size_t namelen
= strlen(zhp
->zfs_name
);
568 if ((mnttab
= fopen(MNTTAB
, "re")) == NULL
)
571 while (err
== 0 && getmntent(mnttab
, &entry
) == 0) {
572 /* Ignore non-ZFS entries */
573 if (strcmp(entry
.mnt_fstype
, MNTTYPE_ZFS
) != 0)
576 /* Ignore datasets not within the provided dataset */
577 if (strncmp(entry
.mnt_special
, zhp
->zfs_name
, namelen
) != 0 ||
578 entry
.mnt_special
[namelen
] != '/')
581 /* Skip snapshot of any child dataset */
582 if (strchr(entry
.mnt_special
, '@') != NULL
)
585 if ((mtab_zhp
= zfs_open(zhp
->zfs_hdl
, entry
.mnt_special
,
586 ZFS_TYPE_FILESYSTEM
)) == NULL
)
589 /* Ignore legacy mounts as they are user managed */
590 verify(zfs_prop_get(mtab_zhp
, ZFS_PROP_MOUNTPOINT
, mnt_prop
,
591 sizeof (mnt_prop
), NULL
, NULL
, 0, B_FALSE
) == 0);
592 if (strcmp(mnt_prop
, "legacy") == 0) {
597 err
= func(mtab_zhp
, data
);