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, 2015 by Delphix. All rights reserved.
25 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
36 #include "libzfs_impl.h"
39 zfs_iter_clones(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
41 nvlist_t
*nvl
= zfs_get_clones_nvl(zhp
);
47 for (pair
= nvlist_next_nvpair(nvl
, NULL
); pair
!= NULL
;
48 pair
= nvlist_next_nvpair(nvl
, pair
)) {
49 zfs_handle_t
*clone
= zfs_open(zhp
->zfs_hdl
, nvpair_name(pair
),
50 ZFS_TYPE_FILESYSTEM
| ZFS_TYPE_VOLUME
);
52 int err
= func(clone
, data
);
61 zfs_do_list_ioctl(zfs_handle_t
*zhp
, int arg
, zfs_cmd_t
*zc
)
66 orig_cookie
= zc
->zc_cookie
;
68 (void) strlcpy(zc
->zc_name
, zhp
->zfs_name
, sizeof (zc
->zc_name
));
69 rc
= ioctl(zhp
->zfs_hdl
->libzfs_fd
, arg
, zc
);
74 /* expand nvlist memory and try again */
75 if (zcmd_expand_dst_nvlist(zhp
->zfs_hdl
, zc
) != 0) {
76 zcmd_free_nvlists(zc
);
79 zc
->zc_cookie
= orig_cookie
;
82 * An errno value of ESRCH indicates normal completion.
83 * If ENOENT is returned, then the underlying dataset
84 * has been removed since we obtained the handle.
91 rc
= zfs_standard_error(zhp
->zfs_hdl
, errno
,
93 "cannot iterate filesystems"));
101 * Iterate over all child filesystems
104 zfs_iter_filesystems(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
106 zfs_cmd_t zc
= {"\0"};
110 if (zhp
->zfs_type
!= ZFS_TYPE_FILESYSTEM
)
113 if (zcmd_alloc_dst_nvlist(zhp
->zfs_hdl
, &zc
, 0) != 0)
116 while ((ret
= zfs_do_list_ioctl(zhp
, ZFS_IOC_DATASET_LIST_NEXT
,
119 * Silently ignore errors, as the only plausible explanation is
120 * that the pool has since been removed.
122 if ((nzhp
= make_dataset_handle_zc(zhp
->zfs_hdl
,
127 if ((ret
= func(nzhp
, data
)) != 0) {
128 zcmd_free_nvlists(&zc
);
132 zcmd_free_nvlists(&zc
);
133 return ((ret
< 0) ? ret
: 0);
137 * Iterate over all snapshots
140 zfs_iter_snapshots(zfs_handle_t
*zhp
, boolean_t simple
, zfs_iter_f func
,
143 zfs_cmd_t zc
= {"\0"};
147 if (zhp
->zfs_type
== ZFS_TYPE_SNAPSHOT
||
148 zhp
->zfs_type
== ZFS_TYPE_BOOKMARK
)
151 zc
.zc_simple
= simple
;
153 if (zcmd_alloc_dst_nvlist(zhp
->zfs_hdl
, &zc
, 0) != 0)
155 while ((ret
= zfs_do_list_ioctl(zhp
, ZFS_IOC_SNAPSHOT_LIST_NEXT
,
159 nzhp
= make_dataset_simple_handle_zc(zhp
, &zc
);
161 nzhp
= make_dataset_handle_zc(zhp
->zfs_hdl
, &zc
);
165 if ((ret
= func(nzhp
, data
)) != 0) {
166 zcmd_free_nvlists(&zc
);
170 zcmd_free_nvlists(&zc
);
171 return ((ret
< 0) ? ret
: 0);
175 * Iterate over all bookmarks
178 zfs_iter_bookmarks(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
181 nvlist_t
*props
= NULL
;
182 nvlist_t
*bmarks
= NULL
;
186 if ((zfs_get_type(zhp
) & (ZFS_TYPE_SNAPSHOT
| ZFS_TYPE_BOOKMARK
)) != 0)
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
));
195 if ((err
= lzc_get_bookmarks(zhp
->zfs_name
, props
, &bmarks
)) != 0)
198 for (pair
= nvlist_next_nvpair(bmarks
, NULL
);
199 pair
!= NULL
; pair
= nvlist_next_nvpair(bmarks
, pair
)) {
200 char name
[ZFS_MAX_DATASET_NAME_LEN
];
202 nvlist_t
*bmark_props
;
204 bmark_name
= nvpair_name(pair
);
205 bmark_props
= fnvpair_value_nvlist(pair
);
207 if (snprintf(name
, sizeof (name
), "%s#%s", zhp
->zfs_name
,
208 bmark_name
) >= sizeof (name
)) {
213 nzhp
= make_bookmark_handle(zhp
, name
, bmark_props
);
217 if ((err
= func(nzhp
, data
)) != 0)
223 fnvlist_free(bmarks
);
229 * Routines for dealing with the sorted snapshot functionality
231 typedef struct zfs_node
{
232 zfs_handle_t
*zn_handle
;
233 avl_node_t zn_avlnode
;
237 zfs_sort_snaps(zfs_handle_t
*zhp
, void *data
)
239 avl_tree_t
*avl
= data
;
243 search
.zn_handle
= zhp
;
244 node
= avl_find(avl
, &search
, NULL
);
247 * If this snapshot was renamed while we were creating the
248 * AVL tree, it's possible that we already inserted it under
249 * its old name. Remove the old handle before adding the new
252 zfs_close(node
->zn_handle
);
253 avl_remove(avl
, node
);
257 node
= zfs_alloc(zhp
->zfs_hdl
, sizeof (zfs_node_t
));
258 node
->zn_handle
= zhp
;
265 zfs_snapshot_compare(const void *larg
, const void *rarg
)
267 zfs_handle_t
*l
= ((zfs_node_t
*)larg
)->zn_handle
;
268 zfs_handle_t
*r
= ((zfs_node_t
*)rarg
)->zn_handle
;
269 uint64_t lcreate
, rcreate
;
272 * Sort them according to creation time. We use the hidden
273 * CREATETXG property to get an absolute ordering of snapshots.
275 lcreate
= zfs_prop_get_int(l
, ZFS_PROP_CREATETXG
);
276 rcreate
= zfs_prop_get_int(r
, ZFS_PROP_CREATETXG
);
278 return (AVL_CMP(lcreate
, rcreate
));
282 zfs_iter_snapshots_sorted(zfs_handle_t
*zhp
, zfs_iter_f callback
, void *data
)
289 avl_create(&avl
, zfs_snapshot_compare
,
290 sizeof (zfs_node_t
), offsetof(zfs_node_t
, zn_avlnode
));
292 ret
= zfs_iter_snapshots(zhp
, B_FALSE
, zfs_sort_snaps
, &avl
);
294 for (node
= avl_first(&avl
); node
!= NULL
; node
= AVL_NEXT(&avl
, node
))
295 ret
|= callback(node
->zn_handle
, data
);
297 while ((node
= avl_destroy_nodes(&avl
, &cookie
)) != NULL
)
308 boolean_t ssa_seenfirst
;
309 boolean_t ssa_seenlast
;
315 snapspec_cb(zfs_handle_t
*zhp
, void *arg
)
317 snapspec_arg_t
*ssa
= arg
;
318 const char *shortsnapname
;
321 if (ssa
->ssa_seenlast
)
324 shortsnapname
= strchr(zfs_get_name(zhp
), '@') + 1;
325 if (!ssa
->ssa_seenfirst
&& strcmp(shortsnapname
, ssa
->ssa_first
) == 0)
326 ssa
->ssa_seenfirst
= B_TRUE
;
327 if (strcmp(shortsnapname
, ssa
->ssa_last
) == 0)
328 ssa
->ssa_seenlast
= B_TRUE
;
330 if (ssa
->ssa_seenfirst
) {
331 err
= ssa
->ssa_func(zhp
, ssa
->ssa_arg
);
340 * spec is a string like "A,B%C,D"
342 * <snaps>, where <snaps> can be:
343 * <snap> (single snapshot)
344 * <snap>%<snap> (range of snapshots, inclusive)
345 * %<snap> (range of snapshots, starting with earliest)
346 * <snap>% (range of snapshots, ending with last)
348 * <snaps>[,...] (comma separated list of the above)
350 * If a snapshot can not be opened, continue trying to open the others, but
351 * return ENOENT at the end.
354 zfs_iter_snapspec(zfs_handle_t
*fs_zhp
, const char *spec_orig
,
355 zfs_iter_f func
, void *arg
)
357 char *buf
, *comma_separated
, *cp
;
361 buf
= zfs_strdup(fs_zhp
->zfs_hdl
, spec_orig
);
364 while ((comma_separated
= strsep(&cp
, ",")) != NULL
) {
365 char *pct
= strchr(comma_separated
, '%');
367 snapspec_arg_t ssa
= { 0 };
371 if (pct
== comma_separated
)
372 ssa
.ssa_seenfirst
= B_TRUE
;
374 ssa
.ssa_first
= comma_separated
;
376 ssa
.ssa_last
= pct
+ 1;
379 * If there is a lastname specified, make sure it
382 if (ssa
.ssa_last
[0] != '\0') {
383 char snapname
[ZFS_MAX_DATASET_NAME_LEN
];
384 (void) snprintf(snapname
, sizeof (snapname
),
385 "%s@%s", zfs_get_name(fs_zhp
),
387 if (!zfs_dataset_exists(fs_zhp
->zfs_hdl
,
388 snapname
, ZFS_TYPE_SNAPSHOT
)) {
394 err
= zfs_iter_snapshots_sorted(fs_zhp
,
398 if (ret
== 0 && (!ssa
.ssa_seenfirst
||
399 (ssa
.ssa_last
[0] != '\0' && !ssa
.ssa_seenlast
))) {
403 char snapname
[ZFS_MAX_DATASET_NAME_LEN
];
404 zfs_handle_t
*snap_zhp
;
405 (void) snprintf(snapname
, sizeof (snapname
), "%s@%s",
406 zfs_get_name(fs_zhp
), comma_separated
);
407 snap_zhp
= make_dataset_handle(fs_zhp
->zfs_hdl
,
409 if (snap_zhp
== NULL
) {
413 err
= func(snap_zhp
, arg
);
424 * Iterate over all children, snapshots and filesystems
427 zfs_iter_children(zfs_handle_t
*zhp
, zfs_iter_f func
, void *data
)
431 if ((ret
= zfs_iter_snapshots(zhp
, B_FALSE
, func
, data
)) != 0)
434 return (zfs_iter_filesystems(zhp
, func
, data
));
438 typedef struct iter_stack_frame
{
439 struct iter_stack_frame
*next
;
441 } iter_stack_frame_t
;
443 typedef struct iter_dependents_arg
{
445 boolean_t allowrecursion
;
446 iter_stack_frame_t
*stack
;
449 } iter_dependents_arg_t
;
452 iter_dependents_cb(zfs_handle_t
*zhp
, void *arg
)
454 iter_dependents_arg_t
*ida
= arg
;
456 boolean_t first
= ida
->first
;
457 ida
->first
= B_FALSE
;
459 if (zhp
->zfs_type
== ZFS_TYPE_SNAPSHOT
) {
460 err
= zfs_iter_clones(zhp
, iter_dependents_cb
, ida
);
461 } else if (zhp
->zfs_type
!= ZFS_TYPE_BOOKMARK
) {
462 iter_stack_frame_t isf
;
463 iter_stack_frame_t
*f
;
466 * check if there is a cycle by seeing if this fs is already
469 for (f
= ida
->stack
; f
!= NULL
; f
= f
->next
) {
470 if (f
->zhp
->zfs_dmustats
.dds_guid
==
471 zhp
->zfs_dmustats
.dds_guid
) {
472 if (ida
->allowrecursion
) {
476 zfs_error_aux(zhp
->zfs_hdl
,
477 dgettext(TEXT_DOMAIN
,
478 "recursive dependency at '%s'"),
480 err
= zfs_error(zhp
->zfs_hdl
,
482 dgettext(TEXT_DOMAIN
,
483 "cannot determine dependent "
492 isf
.next
= ida
->stack
;
494 err
= zfs_iter_filesystems(zhp
, iter_dependents_cb
, ida
);
496 err
= zfs_iter_snapshots(zhp
, B_FALSE
,
497 iter_dependents_cb
, ida
);
498 ida
->stack
= isf
.next
;
501 if (!first
&& err
== 0)
502 err
= ida
->func(zhp
, ida
->data
);
510 zfs_iter_dependents(zfs_handle_t
*zhp
, boolean_t allowrecursion
,
511 zfs_iter_f func
, void *data
)
513 iter_dependents_arg_t ida
;
514 ida
.allowrecursion
= allowrecursion
;
519 return (iter_dependents_cb(zfs_handle_dup(zhp
), &ida
));