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
195 if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
196 goto out;
197
198 for (nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL);
199 pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
200 char name[ZFS_MAX_DATASET_NAME_LEN];
201 char *bmark_name;
202 nvlist_t *bmark_props;
203
204 bmark_name = nvpair_name(pair);
205 bmark_props = fnvpair_value_nvlist(pair);
206
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;
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;
|
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_internal(zfs_handle_t *zhp, boolean_t simple,
142 zfs_iter_f func, void *data, boolean_t autosnaps)
143 {
144 zfs_cmd_t zc = { 0 };
145 int ret;
146
147 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT ||
148 zhp->zfs_type == ZFS_TYPE_BOOKMARK ||
149 zhp->zfs_type == ZFS_TYPE_AUTOSNAP)
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
157 while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
158 &zc)) == 0) {
159 zfs_handle_t *nzhp;
160
161 if (simple)
162 nzhp = make_dataset_simple_handle_zc(zhp, &zc);
163 else
164 nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
165 if (nzhp == NULL)
166 continue;
167
168 if (autosnaps) {
169 if (zfs_get_type(nzhp) != ZFS_TYPE_AUTOSNAP) {
170 zfs_close(nzhp);
171 continue;
172 }
173 } else {
174 if (zfs_get_type(nzhp) != ZFS_TYPE_SNAPSHOT) {
175 zfs_close(nzhp);
176 continue;
177 }
178 }
179
180 if ((ret = func(nzhp, data)) != 0) {
181 zcmd_free_nvlists(&zc);
182 return (ret);
183 }
184 }
185
186 zcmd_free_nvlists(&zc);
187 return ((ret < 0) ? ret : 0);
188 }
189
190 /*
191 * Iterate over all snapshots
192 */
193 int
194 zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
195 void *data)
196 {
197 return (zfs_iter_snapshots_internal(zhp, simple, func, data, B_FALSE));
198 }
199
200 int
201 zfs_iter_autosnapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
202 void *data)
203 {
204 return (zfs_iter_snapshots_internal(zhp, simple, func, data, B_TRUE));
205 }
206
207 /*
208 * Iterate over all bookmarks
209 */
210 int
211 zfs_iter_bookmarks(zfs_handle_t *zhp, zfs_iter_f func, void *data)
212 {
213 zfs_handle_t *nzhp;
214 nvlist_t *props = NULL;
215 nvlist_t *bmarks = NULL;
216 int err;
217
218 if ((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT |
219 ZFS_TYPE_BOOKMARK | ZFS_TYPE_AUTOSNAP)) != 0)
220 return (0);
221
222 /* Setup the requested properties nvlist. */
223 props = fnvlist_alloc();
224 fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_GUID));
225 fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATETXG));
226 fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATION));
227
228 if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
229 goto out;
230
231 for (nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL);
232 pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
233 char name[ZFS_MAX_DATASET_NAME_LEN];
234 char *bmark_name;
235 nvlist_t *bmark_props;
236
237 bmark_name = nvpair_name(pair);
238 bmark_props = fnvpair_value_nvlist(pair);
239
440 (void) snprintf(snapname, sizeof (snapname), "%s@%s",
441 zfs_get_name(fs_zhp), comma_separated);
442 snap_zhp = make_dataset_handle(fs_zhp->zfs_hdl,
443 snapname);
444 if (snap_zhp == NULL) {
445 ret = ENOENT;
446 continue;
447 }
448 err = func(snap_zhp, arg);
449 if (ret == 0)
450 ret = err;
451 }
452 }
453
454 free(buf);
455 return (ret);
456 }
457
458 /*
459 * Iterate over all children, snapshots and filesystems
460 */
461 int
462 zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data)
463 {
464 int ret;
465
466 if ((ret = zfs_iter_filesystems(zhp, func, data)) != 0)
467 return (ret);
468
469 return (zfs_iter_snapshots(zhp, B_FALSE, func, data));
470 }
471
472
473 typedef struct iter_stack_frame {
474 struct iter_stack_frame *next;
475 zfs_handle_t *zhp;
476 } iter_stack_frame_t;
477
478 typedef struct iter_dependents_arg {
479 boolean_t first;
480 boolean_t allowrecursion;
481 iter_stack_frame_t *stack;
482 zfs_iter_f func;
483 void *data;
484 } iter_dependents_arg_t;
485
486 static int
487 iter_dependents_cb(zfs_handle_t *zhp, void *arg)
488 {
489 iter_dependents_arg_t *ida = arg;
514 zfs_get_name(zhp));
515 err = zfs_error(zhp->zfs_hdl,
516 EZFS_RECURSIVE,
517 dgettext(TEXT_DOMAIN,
518 "cannot determine dependent "
519 "datasets"));
520 zfs_close(zhp);
521 return (err);
522 }
523 }
524 }
525
526 isf.zhp = zhp;
527 isf.next = ida->stack;
528 ida->stack = &isf;
529 err = zfs_iter_filesystems(zhp, iter_dependents_cb, ida);
530 if (err == 0) {
531 err = zfs_iter_snapshots(zhp, B_FALSE,
532 iter_dependents_cb, ida);
533 }
534
535 if (err == 0) {
536 err = zfs_iter_autosnapshots(zhp, B_FALSE,
537 iter_dependents_cb, ida);
538 }
539
540 ida->stack = isf.next;
541 }
542
543 if (!first && err == 0)
544 err = ida->func(zhp, ida->data);
545 else
546 zfs_close(zhp);
547
548 return (err);
549 }
550
551 int
552 zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
553 zfs_iter_f func, void *data)
554 {
555 iter_dependents_arg_t ida;
556 ida.allowrecursion = allowrecursion;
557 ida.stack = NULL;
558 ida.func = func;
559 ida.data = data;
|