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) 2012 Pawel Jakub Dawidek <pawel@dawidek.net>.
25 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
26 * Copyright (c) 2013 by Delphix. All rights reserved.
43 * This is a private interface used to gather up all the datasets specified on
44 * the command line so that we can iterate over them in order.
46 * First, we iterate over all filesystems, gathering them together into an
47 * AVL tree. We report errors for any explicitly specified datasets
48 * that we couldn't open.
50 * When finished, we have an AVL tree of ZFS handles. We go through and execute
51 * the provided callback for each one, passing whatever data the user supplied.
54 typedef struct zfs_node
{
55 zfs_handle_t
*zn_handle
;
56 uu_avl_node_t zn_avlnode
;
59 typedef struct callback_data
{
63 zfs_sort_column_t
*cb_sortcol
;
64 zprop_list_t
**cb_proplist
;
67 uint8_t cb_props_table
[ZFS_NUM_PROPS
];
70 uu_avl_pool_t
*avl_pool
;
73 * Include snaps if they were requested or if this a zfs list where types
74 * were not specified and the "listsnapshots" property is set on this pool.
77 zfs_include_snapshots(zfs_handle_t
*zhp
, callback_data_t
*cb
)
81 if ((cb
->cb_flags
& ZFS_ITER_PROP_LISTSNAPS
) == 0)
82 return (cb
->cb_types
& ZFS_TYPE_SNAPSHOT
);
84 zph
= zfs_get_pool_handle(zhp
);
85 return (zpool_get_prop_int(zph
, ZPOOL_PROP_LISTSNAPS
, NULL
));
89 * Called for each dataset. If the object is of an appropriate type,
90 * add it to the avl tree and recurse over any children as necessary.
93 zfs_callback(zfs_handle_t
*zhp
, void *data
)
95 callback_data_t
*cb
= data
;
96 boolean_t should_close
= B_TRUE
;
97 boolean_t include_snaps
= zfs_include_snapshots(zhp
, cb
);
98 boolean_t include_bmarks
= (cb
->cb_types
& ZFS_TYPE_BOOKMARK
);
100 if ((zfs_get_type(zhp
) & cb
->cb_types
) ||
101 ((zfs_get_type(zhp
) == ZFS_TYPE_SNAPSHOT
) && include_snaps
)) {
103 zfs_node_t
*node
= safe_malloc(sizeof (zfs_node_t
));
105 node
->zn_handle
= zhp
;
106 uu_avl_node_init(node
, &node
->zn_avlnode
, avl_pool
);
107 if (uu_avl_find(cb
->cb_avl
, node
, cb
->cb_sortcol
,
109 if (cb
->cb_proplist
) {
110 if ((*cb
->cb_proplist
) &&
111 !(*cb
->cb_proplist
)->pl_all
)
112 zfs_prune_proplist(zhp
,
115 if (zfs_expand_proplist(zhp
, cb
->cb_proplist
,
116 (cb
->cb_flags
& ZFS_ITER_RECVD_PROPS
),
117 (cb
->cb_flags
& ZFS_ITER_LITERAL_PROPS
))
123 uu_avl_insert(cb
->cb_avl
, node
, idx
);
124 should_close
= B_FALSE
;
131 * Recurse if necessary.
133 if (cb
->cb_flags
& ZFS_ITER_RECURSE
&&
134 ((cb
->cb_flags
& ZFS_ITER_DEPTH_LIMIT
) == 0 ||
135 cb
->cb_depth
< cb
->cb_depth_limit
)) {
139 * If we are not looking for filesystems, we don't need to
140 * recurse into filesystems when we are at our depth limit.
142 if ((cb
->cb_depth
< cb
->cb_depth_limit
||
143 (cb
->cb_flags
& ZFS_ITER_DEPTH_LIMIT
) == 0 ||
145 (ZFS_TYPE_FILESYSTEM
| ZFS_TYPE_VOLUME
))) &&
146 zfs_get_type(zhp
) == ZFS_TYPE_FILESYSTEM
) {
147 (void) zfs_iter_filesystems(zhp
, zfs_callback
, data
);
150 if (((zfs_get_type(zhp
) & (ZFS_TYPE_SNAPSHOT
|
151 ZFS_TYPE_BOOKMARK
)) == 0) && include_snaps
) {
152 (void) zfs_iter_snapshots(zhp
,
153 (cb
->cb_flags
& ZFS_ITER_SIMPLE
) != 0,
154 zfs_callback
, data
, 0, 0);
157 if (((zfs_get_type(zhp
) & (ZFS_TYPE_SNAPSHOT
|
158 ZFS_TYPE_BOOKMARK
)) == 0) && include_bmarks
) {
159 (void) zfs_iter_bookmarks(zhp
, zfs_callback
, data
);
172 zfs_add_sort_column(zfs_sort_column_t
**sc
, const char *name
,
175 zfs_sort_column_t
*col
;
178 if ((prop
= zfs_name_to_prop(name
)) == ZPROP_INVAL
&&
179 !zfs_prop_user(name
))
182 col
= safe_malloc(sizeof (zfs_sort_column_t
));
185 col
->sc_reverse
= reverse
;
186 if (prop
== ZPROP_INVAL
) {
187 col
->sc_user_prop
= safe_malloc(strlen(name
) + 1);
188 (void) strcpy(col
->sc_user_prop
, name
);
195 (*sc
)->sc_last
->sc_next
= col
;
196 (*sc
)->sc_last
= col
;
203 zfs_free_sort_columns(zfs_sort_column_t
*sc
)
205 zfs_sort_column_t
*col
;
209 free(sc
->sc_user_prop
);
216 zfs_sort_only_by_name(const zfs_sort_column_t
*sc
)
218 return (sc
!= NULL
&& sc
->sc_next
== NULL
&&
219 sc
->sc_prop
== ZFS_PROP_NAME
);
224 zfs_compare(const void *larg
, const void *rarg
, void *unused
)
226 zfs_handle_t
*l
= ((zfs_node_t
*)larg
)->zn_handle
;
227 zfs_handle_t
*r
= ((zfs_node_t
*)rarg
)->zn_handle
;
228 const char *lname
= zfs_get_name(l
);
229 const char *rname
= zfs_get_name(r
);
231 uint64_t lcreate
, rcreate
;
234 lat
= (char *)strchr(lname
, '@');
235 rat
= (char *)strchr(rname
, '@');
242 ret
= strcmp(lname
, rname
);
245 * If we're comparing a dataset to one of its snapshots, we
246 * always make the full dataset first.
250 } else if (rat
== NULL
) {
254 * If we have two snapshots from the same dataset, then
255 * we want to sort them according to creation time. We
256 * use the hidden CREATETXG property to get an absolute
257 * ordering of snapshots.
259 lcreate
= zfs_prop_get_int(l
, ZFS_PROP_CREATETXG
);
260 rcreate
= zfs_prop_get_int(r
, ZFS_PROP_CREATETXG
);
263 * Both lcreate and rcreate being 0 means we don't have
264 * properties and we should compare full name.
266 if (lcreate
== 0 && rcreate
== 0)
267 ret
= strcmp(lat
+ 1, rat
+ 1);
268 else if (lcreate
< rcreate
)
270 else if (lcreate
> rcreate
)
284 * Sort datasets by specified columns.
286 * o Numeric types sort in ascending order.
287 * o String types sort in alphabetical order.
288 * o Types inappropriate for a row sort that row to the literal
289 * bottom, regardless of the specified ordering.
291 * If no sort columns are specified, or two datasets compare equally
292 * across all specified columns, they are sorted alphabetically by name
293 * with snapshots grouped under their parents.
296 zfs_sort(const void *larg
, const void *rarg
, void *data
)
298 zfs_handle_t
*l
= ((zfs_node_t
*)larg
)->zn_handle
;
299 zfs_handle_t
*r
= ((zfs_node_t
*)rarg
)->zn_handle
;
300 zfs_sort_column_t
*sc
= (zfs_sort_column_t
*)data
;
301 zfs_sort_column_t
*psc
;
303 for (psc
= sc
; psc
!= NULL
; psc
= psc
->sc_next
) {
304 char lbuf
[ZFS_MAXPROPLEN
], rbuf
[ZFS_MAXPROPLEN
];
307 boolean_t lvalid
, rvalid
;
311 * We group the checks below the generic code. If 'lstr' and
312 * 'rstr' are non-NULL, then we do a string based comparison.
313 * Otherwise, we compare 'lnum' and 'rnum'.
316 if (psc
->sc_prop
== ZPROP_INVAL
) {
317 nvlist_t
*luser
, *ruser
;
318 nvlist_t
*lval
, *rval
;
320 luser
= zfs_get_user_props(l
);
321 ruser
= zfs_get_user_props(r
);
323 lvalid
= (nvlist_lookup_nvlist(luser
,
324 psc
->sc_user_prop
, &lval
) == 0);
325 rvalid
= (nvlist_lookup_nvlist(ruser
,
326 psc
->sc_user_prop
, &rval
) == 0);
329 verify(nvlist_lookup_string(lval
,
330 ZPROP_VALUE
, &lstr
) == 0);
332 verify(nvlist_lookup_string(rval
,
333 ZPROP_VALUE
, &rstr
) == 0);
334 } else if (psc
->sc_prop
== ZFS_PROP_NAME
) {
335 lvalid
= rvalid
= B_TRUE
;
337 (void) strlcpy(lbuf
, zfs_get_name(l
), sizeof (lbuf
));
338 (void) strlcpy(rbuf
, zfs_get_name(r
), sizeof (rbuf
));
342 } else if (zfs_prop_is_string(psc
->sc_prop
)) {
343 lvalid
= (zfs_prop_get(l
, psc
->sc_prop
, lbuf
,
344 sizeof (lbuf
), NULL
, NULL
, 0, B_TRUE
) == 0);
345 rvalid
= (zfs_prop_get(r
, psc
->sc_prop
, rbuf
,
346 sizeof (rbuf
), NULL
, NULL
, 0, B_TRUE
) == 0);
351 lvalid
= zfs_prop_valid_for_type(psc
->sc_prop
,
352 zfs_get_type(l
), B_FALSE
);
353 rvalid
= zfs_prop_valid_for_type(psc
->sc_prop
,
354 zfs_get_type(r
), B_FALSE
);
357 (void) zfs_prop_get_numeric(l
, psc
->sc_prop
,
358 &lnum
, NULL
, NULL
, 0);
360 (void) zfs_prop_get_numeric(r
, psc
->sc_prop
,
361 &rnum
, NULL
, NULL
, 0);
364 if (!lvalid
&& !rvalid
)
372 ret
= strcmp(lstr
, rstr
);
373 else if (lnum
< rnum
)
375 else if (lnum
> rnum
)
379 if (psc
->sc_reverse
== B_TRUE
)
380 ret
= (ret
< 0) ? 1 : -1;
385 return (zfs_compare(larg
, rarg
, NULL
));
389 zfs_for_each(int argc
, char **argv
, int flags
, zfs_type_t types
,
390 zfs_sort_column_t
*sortcol
, zprop_list_t
**proplist
, int limit
,
391 zfs_iter_f callback
, void *data
)
393 callback_data_t cb
= {0};
398 avl_pool
= uu_avl_pool_create("zfs_pool", sizeof (zfs_node_t
),
399 offsetof(zfs_node_t
, zn_avlnode
), zfs_sort
, UU_DEFAULT
);
401 if (avl_pool
== NULL
)
404 cb
.cb_sortcol
= sortcol
;
406 cb
.cb_proplist
= proplist
;
408 cb
.cb_depth_limit
= limit
;
410 * If cb_proplist is provided then in the zfs_handles created we
411 * retain only those properties listed in cb_proplist and sortcol.
412 * The rest are pruned. So, the caller should make sure that no other
413 * properties other than those listed in cb_proplist/sortcol are
416 * If cb_proplist is NULL then we retain all the properties. We
417 * always retain the zoned property, which some other properties
418 * need (userquota & friends), and the createtxg property, which
419 * we need to sort snapshots.
421 if (cb
.cb_proplist
&& *cb
.cb_proplist
) {
422 zprop_list_t
*p
= *cb
.cb_proplist
;
425 if (p
->pl_prop
>= ZFS_PROP_TYPE
&&
426 p
->pl_prop
< ZFS_NUM_PROPS
) {
427 cb
.cb_props_table
[p
->pl_prop
] = B_TRUE
;
433 if (sortcol
->sc_prop
>= ZFS_PROP_TYPE
&&
434 sortcol
->sc_prop
< ZFS_NUM_PROPS
) {
435 cb
.cb_props_table
[sortcol
->sc_prop
] = B_TRUE
;
437 sortcol
= sortcol
->sc_next
;
440 cb
.cb_props_table
[ZFS_PROP_ZONED
] = B_TRUE
;
441 cb
.cb_props_table
[ZFS_PROP_CREATETXG
] = B_TRUE
;
443 (void) memset(cb
.cb_props_table
, B_TRUE
,
444 sizeof (cb
.cb_props_table
));
447 if ((cb
.cb_avl
= uu_avl_create(avl_pool
, NULL
, UU_DEFAULT
)) == NULL
)
452 * If given no arguments, iterate over all datasets.
454 cb
.cb_flags
|= ZFS_ITER_RECURSE
;
455 ret
= zfs_iter_root(g_zfs
, zfs_callback
, &cb
);
462 * If we're recursive, then we always allow filesystems as
463 * arguments. If we also are interested in snapshots or
464 * bookmarks, then we can take volumes as well.
467 if (flags
& ZFS_ITER_RECURSE
) {
468 argtype
|= ZFS_TYPE_FILESYSTEM
;
469 if (types
& (ZFS_TYPE_SNAPSHOT
| ZFS_TYPE_BOOKMARK
))
470 argtype
|= ZFS_TYPE_VOLUME
;
473 for (i
= 0; i
< argc
; i
++) {
474 if (flags
& ZFS_ITER_ARGS_CAN_BE_PATHS
) {
475 zhp
= zfs_path_to_zhandle(g_zfs
, argv
[i
],
478 zhp
= zfs_open(g_zfs
, argv
[i
], argtype
);
481 ret
|= zfs_callback(zhp
, &cb
);
488 * At this point we've got our AVL tree full of zfs handles, so iterate
489 * over each one and execute the real user callback.
491 for (node
= uu_avl_first(cb
.cb_avl
); node
!= NULL
;
492 node
= uu_avl_next(cb
.cb_avl
, node
))
493 ret
|= callback(node
->zn_handle
, data
);
496 * Finally, clean up the AVL tree.
498 if ((walk
= uu_avl_walk_start(cb
.cb_avl
, UU_WALK_ROBUST
)) == NULL
)
501 while ((node
= uu_avl_walk_next(walk
)) != NULL
) {
502 uu_avl_remove(cb
.cb_avl
, node
);
503 zfs_close(node
->zn_handle
);
507 uu_avl_walk_end(walk
);
508 uu_avl_destroy(cb
.cb_avl
);
509 uu_avl_pool_destroy(avl_pool
);