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 http://www.opensolaris.org/os/licensing.
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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
28 * Copyright 2015 Toomas Soome <tsoome@me.com>
29 */
30
31 #include <assert.h>
32 #include <libintl.h>
33 #include <libnvpair.h>
34 #include <libzfs.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <strings.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <unistd.h>
42 #include <errno.h>
43
44 #include <libbe.h>
45 #include <libbe_priv.h>
46
47 /*
48 * Callback data used for zfs_iter calls.
49 */
50 typedef struct list_callback_data {
51 char *zpool_name;
52 char *be_name;
53 be_node_list_t *be_nodes_head;
54 be_node_list_t *be_nodes;
55 char current_be[MAXPATHLEN];
56 } list_callback_data_t;
57
58 /*
59 * Private function prototypes
60 */
61 static int be_add_children_callback(zfs_handle_t *zhp, void *data);
62 static int be_get_list_callback(zpool_handle_t *, void *);
63 static int be_get_node_data(zfs_handle_t *, be_node_list_t *, char *,
64 const char *, char *, char *);
65 static int be_get_zone_node_data(be_node_list_t *, char *);
66 static int be_get_ds_data(zfs_handle_t *, char *, be_dataset_list_t *,
67 be_node_list_t *);
68 static int be_get_ss_data(zfs_handle_t *, char *, be_snapshot_list_t *,
69 be_node_list_t *);
70 static void be_sort_list(be_node_list_t **,
71 int (*)(const void *, const void *));
72 static int be_qsort_compare_BEs_name(const void *, const void *);
73 static int be_qsort_compare_BEs_name_rev(const void *, const void *);
74 static int be_qsort_compare_BEs_date(const void *, const void *);
75 static int be_qsort_compare_BEs_date_rev(const void *, const void *);
76 static int be_qsort_compare_BEs_space(const void *, const void *);
77 static int be_qsort_compare_BEs_space_rev(const void *, const void *);
78 static int be_qsort_compare_snapshots(const void *x, const void *y);
79 static int be_qsort_compare_datasets(const void *x, const void *y);
80 static void *be_list_alloc(int *, size_t);
81
82 /*
83 * Private data.
84 */
85 static char be_container_ds[MAXPATHLEN];
86 static boolean_t zone_be = B_FALSE;
87
88 /* ******************************************************************** */
89 /* Public Functions */
90 /* ******************************************************************** */
91
92 /*
93 * Function: be_list
94 * Description: Calls _be_list which finds all the BEs on the system and
95 * returns the datasets and snapshots belonging to each BE.
96 * Also data, such as dataset and snapshot properties,
97 * for each BE and their snapshots and datasets is
98 * returned. The data returned is as described in the
99 * be_dataset_list_t, be_snapshot_list_t and be_node_list_t
100 * structures.
101 * Parameters:
102 * be_name - The name of the BE to look up.
103 * If NULL a list of all BEs will be returned.
104 * be_nodes - A reference pointer to the list of BEs. The list
105 * structure will be allocated by _be_list and must
106 * be freed by a call to be_free_list. If there are no
107 * BEs found on the system this reference will be
108 * set to NULL.
109 * Return:
110 * BE_SUCCESS - Success
111 * be_errno_t - Failure
112 * Scope:
113 * Public
114 */
115 int
116 be_list(char *be_name, be_node_list_t **be_nodes)
117 {
118 int ret = BE_SUCCESS;
119
120 /* Initialize libzfs handle */
121 if (!be_zfs_init())
122 return (BE_ERR_INIT);
123
124 /* Validate be_name if its not NULL */
125 if (be_name != NULL) {
126 if (!be_valid_be_name(be_name)) {
127 be_print_err(gettext("be_list: "
128 "invalid BE name %s\n"), be_name);
129 return (BE_ERR_INVAL);
130 }
131 }
132
133 ret = _be_list(be_name, be_nodes);
134
135 be_zfs_fini();
136
137 return (ret);
138 }
139
140 /*
141 * Function: be_sort
142 * Description: Sort BE node list
143 * Parameters:
144 * pointer to address of list head
145 * sort order type
146 * Returns:
147 * nothing
148 * Side effect:
149 * node list sorted by name
150 * Scope:
151 * Public
152 */
153 void
154 be_sort(be_node_list_t **be_nodes, int order)
155 {
156 int (*compar)(const void *, const void *) = be_qsort_compare_BEs_date;
157
158 if (be_nodes == NULL)
159 return;
160
161 switch (order) {
162 case BE_SORT_UNSPECIFIED:
163 case BE_SORT_DATE:
164 compar = be_qsort_compare_BEs_date;
165 break;
166 case BE_SORT_DATE_REV:
167 compar = be_qsort_compare_BEs_date_rev;
168 break;
169 case BE_SORT_NAME:
170 compar = be_qsort_compare_BEs_name;
171 break;
172 case BE_SORT_NAME_REV:
173 compar = be_qsort_compare_BEs_name_rev;
174 break;
175 case BE_SORT_SPACE:
176 compar = be_qsort_compare_BEs_space;
177 break;
178 case BE_SORT_SPACE_REV:
179 compar = be_qsort_compare_BEs_space_rev;
180 break;
181 default:
182 be_print_err(gettext("be_sort: invalid sort order %d\n"),
183 order);
184 return;
185 }
186
187 be_sort_list(be_nodes, compar);
188 }
189
190 /* ******************************************************************** */
191 /* Semi-Private Functions */
192 /* ******************************************************************** */
193
194 /*
195 * Function: _be_list
196 * Description: This does the actual work described in be_list.
197 * Parameters:
198 * be_name - The name of the BE to look up.
199 * If NULL a list of all BEs will be returned.
200 * be_nodes - A reference pointer to the list of BEs. The list
201 * structure will be allocated here and must
202 * be freed by a call to be_free_list. If there are no
203 * BEs found on the system this reference will be
204 * set to NULL.
205 * Return:
206 * BE_SUCCESS - Success
207 * be_errno_t - Failure
208 * Scope:
209 * Semi-private (library wide use only)
210 */
211 int
212 _be_list(char *be_name, be_node_list_t **be_nodes)
213 {
214 list_callback_data_t cb = { 0 };
215 be_transaction_data_t bt = { 0 };
216 int ret = BE_SUCCESS;
217 zpool_handle_t *zphp;
218 char *rpool = NULL;
219 struct be_defaults be_defaults;
220
221 if (be_nodes == NULL)
222 return (BE_ERR_INVAL);
223
224 be_get_defaults(&be_defaults);
225
226 if (be_find_current_be(&bt) != BE_SUCCESS) {
227 /*
228 * We were unable to find a currently booted BE which
229 * probably means that we're not booted in a BE envoronment.
230 * None of the BE's will be marked as the active BE.
231 */
232 (void) strcpy(cb.current_be, "-");
233 } else {
234 (void) strncpy(cb.current_be, bt.obe_name,
235 sizeof (cb.current_be));
236 rpool = bt.obe_zpool;
237 }
238
239 /*
240 * If be_name is NULL we'll look for all BE's on the system.
241 * If not then we will only return data for the specified BE.
242 */
243 if (be_name != NULL)
244 cb.be_name = strdup(be_name);
245
246 if (be_defaults.be_deflt_rpool_container && rpool != NULL) {
247 if ((zphp = zpool_open(g_zfs, rpool)) == NULL) {
248 be_print_err(gettext("be_list: failed to "
249 "open rpool (%s): %s\n"), rpool,
250 libzfs_error_description(g_zfs));
251 free(cb.be_name);
252 return (zfs_err_to_be_err(g_zfs));
253 }
254
255 ret = be_get_list_callback(zphp, &cb);
256 } else {
257 if ((zpool_iter(g_zfs, be_get_list_callback, &cb)) != 0) {
258 if (cb.be_nodes_head != NULL) {
259 be_free_list(cb.be_nodes_head);
260 cb.be_nodes_head = NULL;
261 cb.be_nodes = NULL;
262 }
263 ret = BE_ERR_BE_NOENT;
264 }
265 }
266
267 if (cb.be_nodes_head == NULL) {
268 if (be_name != NULL)
269 be_print_err(gettext("be_list: BE (%s) does not "
270 "exist\n"), be_name);
271 else
272 be_print_err(gettext("be_list: No BE's found\n"));
273 ret = BE_ERR_BE_NOENT;
274 }
275
276 *be_nodes = cb.be_nodes_head;
277
278 free(cb.be_name);
279
280 be_sort(be_nodes, BE_SORT_DATE);
281
282 return (ret);
283 }
284
285 /*
286 * Function: be_free_list
287 * Description: Frees up all the data allocated for the list of BEs,
288 * datasets and snapshots returned by be_list.
289 * Parameters:
290 * be_node - be_nodes_t structure returned from call to be_list.
291 * Returns:
292 * none
293 * Scope:
294 * Semi-private (library wide use only)
295 */
296 void
297 be_free_list(be_node_list_t *be_nodes)
298 {
299 be_node_list_t *temp_node = NULL;
300 be_node_list_t *list = be_nodes;
301
302 while (list != NULL) {
303 be_dataset_list_t *datasets = list->be_node_datasets;
304 be_snapshot_list_t *snapshots = list->be_node_snapshots;
305
306 while (datasets != NULL) {
307 be_dataset_list_t *temp_ds = datasets;
308 datasets = datasets->be_next_dataset;
309 free(temp_ds->be_dataset_name);
310 free(temp_ds->be_ds_mntpt);
311 free(temp_ds->be_ds_plcy_type);
312 free(temp_ds);
313 }
314
315 while (snapshots != NULL) {
316 be_snapshot_list_t *temp_ss = snapshots;
317 snapshots = snapshots->be_next_snapshot;
318 free(temp_ss->be_snapshot_name);
319 free(temp_ss->be_snapshot_type);
320 free(temp_ss);
321 }
322
323 temp_node = list;
324 list = list->be_next_node;
325 free(temp_node->be_node_name);
326 free(temp_node->be_root_ds);
327 free(temp_node->be_rpool);
328 free(temp_node->be_mntpt);
329 free(temp_node->be_policy_type);
330 free(temp_node->be_uuid_str);
331 free(temp_node);
332 }
333 }
334
335 /*
336 * Function: be_get_zone_be_list
337 * Description: Finds all the BEs for this zone on the system.
338 * Parameters:
339 * zone_be_name - The name of the BE to look up.
340 * zone_be_container_ds - The dataset for the zone.
341 * zbe_nodes - A reference pointer to the list of BEs. The list
342 * structure will be allocated here and must
343 * be freed by a call to be_free_list. If there are no
344 * BEs found on the system this reference will be
345 * set to NULL.
346 * Return:
347 * BE_SUCCESS - Success
348 * be_errno_t - Failure
349 * Scope:
350 * Semi-private (library wide use only)
351 */
352 int
353 be_get_zone_be_list(
354 /* LINTED */
355 char *zone_be_name,
356 char *zone_be_container_ds,
357 be_node_list_t **zbe_nodes)
358 {
359 zfs_handle_t *zhp = NULL;
360 list_callback_data_t cb = { 0 };
361 int ret = BE_SUCCESS;
362
363 if (zbe_nodes == NULL)
364 return (BE_ERR_INVAL);
365
366 if (!zfs_dataset_exists(g_zfs, zone_be_container_ds,
367 ZFS_TYPE_FILESYSTEM)) {
368 return (BE_ERR_BE_NOENT);
369 }
370
371 zone_be = B_TRUE;
372
373 if ((zhp = zfs_open(g_zfs, zone_be_container_ds,
374 ZFS_TYPE_FILESYSTEM)) == NULL) {
375 be_print_err(gettext("be_get_zone_be_list: failed to open "
376 "the zone BE dataset %s: %s\n"), zone_be_container_ds,
377 libzfs_error_description(g_zfs));
378 ret = zfs_err_to_be_err(g_zfs);
379 goto cleanup;
380 }
381
382 (void) strcpy(be_container_ds, zone_be_container_ds);
383
384 if (cb.be_nodes_head == NULL) {
385 if ((cb.be_nodes_head = be_list_alloc(&ret,
386 sizeof (be_node_list_t))) == NULL) {
387 ZFS_CLOSE(zhp);
388 goto cleanup;
389 }
390 cb.be_nodes = cb.be_nodes_head;
391 }
392 if (ret == 0)
393 ret = zfs_iter_filesystems(zhp, be_add_children_callback, &cb);
394 ZFS_CLOSE(zhp);
395
396 *zbe_nodes = cb.be_nodes_head;
397
398 cleanup:
399 zone_be = B_FALSE;
400
401 return (ret);
402 }
403
404 /* ******************************************************************** */
405 /* Private Functions */
406 /* ******************************************************************** */
407
408 /*
409 * Function: be_get_list_callback
410 * Description: Callback function used by zfs_iter to look through all
411 * the pools on the system looking for BEs. If a BE name was
412 * specified only that BE's information will be collected and
413 * returned.
414 * Parameters:
415 * zlp - handle to the first zfs dataset. (provided by the
416 * zfs_iter_* call)
417 * data - pointer to the callback data and where we'll pass
418 * the BE information back.
419 * Returns:
420 * 0 - Success
421 * be_errno_t - Failure
422 * Scope:
423 * Private
424 */
425 static int
426 be_get_list_callback(zpool_handle_t *zlp, void *data)
427 {
428 list_callback_data_t *cb = (list_callback_data_t *)data;
429 char be_ds[MAXPATHLEN];
430 char *open_ds = NULL;
431 char *rpool = NULL;
432 zfs_handle_t *zhp = NULL;
433 int ret = 0;
434
435 cb->zpool_name = rpool = (char *)zpool_get_name(zlp);
436
437 /*
438 * Generate string for the BE container dataset
439 */
440 be_make_container_ds(rpool, be_container_ds,
441 sizeof (be_container_ds));
442
443 /*
444 * If a BE name was specified we use it's root dataset in place of
445 * the container dataset. This is because we only want to collect
446 * the information for the specified BE.
447 */
448 if (cb->be_name != NULL) {
449 if (!be_valid_be_name(cb->be_name))
450 return (BE_ERR_INVAL);
451 /*
452 * Generate string for the BE root dataset
453 */
454 be_make_root_ds(rpool, cb->be_name, be_ds, sizeof (be_ds));
455 open_ds = be_ds;
456 } else {
457 open_ds = be_container_ds;
458 }
459
460 /*
461 * Check if the dataset exists
462 */
463 if (!zfs_dataset_exists(g_zfs, open_ds,
464 ZFS_TYPE_FILESYSTEM)) {
465 /*
466 * The specified dataset does not exist in this pool or
467 * there are no valid BE's in this pool. Try the next zpool.
468 */
469 zpool_close(zlp);
470 return (0);
471 }
472
473 if ((zhp = zfs_open(g_zfs, open_ds, ZFS_TYPE_FILESYSTEM)) == NULL) {
474 be_print_err(gettext("be_get_list_callback: failed to open "
475 "the BE dataset %s: %s\n"), open_ds,
476 libzfs_error_description(g_zfs));
477 ret = zfs_err_to_be_err(g_zfs);
478 zpool_close(zlp);
479 return (ret);
480 }
481
482 /*
483 * If a BE name was specified we iterate through the datasets
484 * and snapshots for this BE only. Otherwise we will iterate
485 * through the next level of datasets to find all the BE's
486 * within the pool
487 */
488 if (cb->be_name != NULL) {
489 if (cb->be_nodes_head == NULL) {
490 if ((cb->be_nodes_head = be_list_alloc(&ret,
491 sizeof (be_node_list_t))) == NULL) {
492 ZFS_CLOSE(zhp);
493 zpool_close(zlp);
494 return (ret);
495 }
496 cb->be_nodes = cb->be_nodes_head;
497 }
498
499 if ((ret = be_get_node_data(zhp, cb->be_nodes, cb->be_name,
500 rpool, cb->current_be, be_ds)) != BE_SUCCESS) {
501 ZFS_CLOSE(zhp);
502 zpool_close(zlp);
503 return (ret);
504 }
505 ret = zfs_iter_snapshots(zhp, be_add_children_callback, cb);
506 }
507
508 if (ret == 0)
509 ret = zfs_iter_filesystems(zhp, be_add_children_callback, cb);
510 ZFS_CLOSE(zhp);
511
512 zpool_close(zlp);
513 return (ret);
514 }
515
516 /*
517 * Function: be_add_children_callback
518 * Description: Callback function used by zfs_iter to look through all
519 * the datasets and snapshots for each BE and add them to
520 * the lists of information to be passed back.
521 * Parameters:
522 * zhp - handle to the first zfs dataset. (provided by the
523 * zfs_iter_* call)
524 * data - pointer to the callback data and where we'll pass
525 * the BE information back.
526 * Returns:
527 * 0 - Success
528 * be_errno_t - Failure
529 * Scope:
530 * Private
531 */
532 static int
533 be_add_children_callback(zfs_handle_t *zhp, void *data)
534 {
535 list_callback_data_t *cb = (list_callback_data_t *)data;
536 char *str = NULL, *ds_path = NULL;
537 int ret = 0;
538 struct be_defaults be_defaults;
539
540 be_get_defaults(&be_defaults);
541
542 ds_path = str = strdup(zfs_get_name(zhp));
543
544 /*
545 * get past the end of the container dataset plus the trailing "/"
546 */
547 str = str + (strlen(be_container_ds) + 1);
548 if (be_defaults.be_deflt_rpool_container) {
549 /* just skip if invalid */
550 if (!be_valid_be_name(str))
551 return (BE_SUCCESS);
552 }
553
554 if (cb->be_nodes_head == NULL) {
555 if ((cb->be_nodes_head = be_list_alloc(&ret,
556 sizeof (be_node_list_t))) == NULL) {
557 ZFS_CLOSE(zhp);
558 return (ret);
559 }
560 cb->be_nodes = cb->be_nodes_head;
561 }
562
563 if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT && !zone_be) {
564 be_snapshot_list_t *snapshots = NULL;
565 if (cb->be_nodes->be_node_snapshots == NULL) {
566 if ((cb->be_nodes->be_node_snapshots =
567 be_list_alloc(&ret, sizeof (be_snapshot_list_t)))
568 == NULL || ret != BE_SUCCESS) {
569 ZFS_CLOSE(zhp);
570 return (ret);
571 }
572 cb->be_nodes->be_node_snapshots->be_next_snapshot =
573 NULL;
574 snapshots = cb->be_nodes->be_node_snapshots;
575 } else {
576 for (snapshots = cb->be_nodes->be_node_snapshots;
577 snapshots != NULL;
578 snapshots = snapshots->be_next_snapshot) {
579 if (snapshots->be_next_snapshot != NULL)
580 continue;
581 /*
582 * We're at the end of the list add the
583 * new snapshot.
584 */
585 if ((snapshots->be_next_snapshot =
586 be_list_alloc(&ret,
587 sizeof (be_snapshot_list_t))) == NULL ||
588 ret != BE_SUCCESS) {
589 ZFS_CLOSE(zhp);
590 return (ret);
591 }
592 snapshots = snapshots->be_next_snapshot;
593 snapshots->be_next_snapshot = NULL;
594 break;
595 }
596 }
597 if ((ret = be_get_ss_data(zhp, str, snapshots,
598 cb->be_nodes)) != BE_SUCCESS) {
599 ZFS_CLOSE(zhp);
600 return (ret);
601 }
602 } else if (strchr(str, '/') == NULL) {
603 if (cb->be_nodes->be_node_name != NULL) {
604 if ((cb->be_nodes->be_next_node =
605 be_list_alloc(&ret, sizeof (be_node_list_t))) ==
606 NULL || ret != BE_SUCCESS) {
607 ZFS_CLOSE(zhp);
608 return (ret);
609 }
610 cb->be_nodes = cb->be_nodes->be_next_node;
611 cb->be_nodes->be_next_node = NULL;
612 }
613
614 /*
615 * If this is a zone root dataset then we only need
616 * the name of the zone BE at this point. We grab that
617 * and return.
618 */
619 if (zone_be) {
620 ret = be_get_zone_node_data(cb->be_nodes, str);
621 ZFS_CLOSE(zhp);
622 return (ret);
623 }
624
625 if ((ret = be_get_node_data(zhp, cb->be_nodes, str,
626 cb->zpool_name, cb->current_be, ds_path)) != BE_SUCCESS) {
627 ZFS_CLOSE(zhp);
628 return (ret);
629 }
630 } else if (strchr(str, '/') != NULL && !zone_be) {
631 be_dataset_list_t *datasets = NULL;
632 if (cb->be_nodes->be_node_datasets == NULL) {
633 if ((cb->be_nodes->be_node_datasets =
634 be_list_alloc(&ret, sizeof (be_dataset_list_t)))
635 == NULL || ret != BE_SUCCESS) {
636 ZFS_CLOSE(zhp);
637 return (ret);
638 }
639 cb->be_nodes->be_node_datasets->be_next_dataset = NULL;
640 datasets = cb->be_nodes->be_node_datasets;
641 } else {
642 for (datasets = cb->be_nodes->be_node_datasets;
643 datasets != NULL;
644 datasets = datasets->be_next_dataset) {
645 if (datasets->be_next_dataset != NULL)
646 continue;
647 /*
648 * We're at the end of the list add
649 * the new dataset.
650 */
651 if ((datasets->be_next_dataset =
652 be_list_alloc(&ret,
653 sizeof (be_dataset_list_t)))
654 == NULL || ret != BE_SUCCESS) {
655 ZFS_CLOSE(zhp);
656 return (ret);
657 }
658 datasets = datasets->be_next_dataset;
659 datasets->be_next_dataset = NULL;
660 break;
661 }
662 }
663
664 if ((ret = be_get_ds_data(zhp, str,
665 datasets, cb->be_nodes)) != BE_SUCCESS) {
666 ZFS_CLOSE(zhp);
667 return (ret);
668 }
669 }
670 ret = zfs_iter_children(zhp, be_add_children_callback, cb);
671 if (ret != 0) {
672 be_print_err(gettext("be_add_children_callback: "
673 "encountered error: %s\n"),
674 libzfs_error_description(g_zfs));
675 ret = zfs_err_to_be_err(g_zfs);
676 }
677 ZFS_CLOSE(zhp);
678 return (ret);
679 }
680
681 /*
682 * Function: be_sort_list
683 * Description: Sort BE node list
684 * Parameters:
685 * pointer to address of list head
686 * compare function
687 * Returns:
688 * nothing
689 * Side effect:
690 * node list sorted by name
691 * Scope:
692 * Private
693 */
694 static void
695 be_sort_list(be_node_list_t **pstart, int (*compar)(const void *, const void *))
696 {
697 size_t ibe, nbe;
698 be_node_list_t *p = NULL;
699 be_node_list_t **ptrlist = NULL;
700
701 if (pstart == NULL)
702 return;
703 /* build array of linked list BE struct pointers */
704 for (p = *pstart, nbe = 0; p != NULL; nbe++, p = p->be_next_node) {
705 ptrlist = realloc(ptrlist,
706 sizeof (be_node_list_t *) * (nbe + 2));
707 ptrlist[nbe] = p;
708 }
709 if (nbe == 0)
710 return;
711 /* in-place list quicksort using qsort(3C) */
712 if (nbe > 1) /* no sort if less than 2 BEs */
713 qsort(ptrlist, nbe, sizeof (be_node_list_t *), compar);
714
715 ptrlist[nbe] = NULL; /* add linked list terminator */
716 *pstart = ptrlist[0]; /* set new linked list header */
717 /* for each BE in list */
718 for (ibe = 0; ibe < nbe; ibe++) {
719 size_t k, ns; /* subordinate index, count */
720
721 /* rewrite list pointer chain, including terminator */
722 ptrlist[ibe]->be_next_node = ptrlist[ibe + 1];
723 /* sort subordinate snapshots */
724 if (ptrlist[ibe]->be_node_num_snapshots > 1) {
725 const size_t nmax = ptrlist[ibe]->be_node_num_snapshots;
726 be_snapshot_list_t ** const slist =
727 malloc(sizeof (be_snapshot_list_t *) * (nmax + 1));
728 be_snapshot_list_t *p;
729
730 if (slist == NULL)
731 continue;
732 /* build array of linked list snapshot struct ptrs */
733 for (ns = 0, p = ptrlist[ibe]->be_node_snapshots;
734 ns < nmax && p != NULL;
735 ns++, p = p->be_next_snapshot) {
736 slist[ns] = p;
737 }
738 if (ns < 2)
739 goto end_snapshot;
740 slist[ns] = NULL; /* add terminator */
741 /* in-place list quicksort using qsort(3C) */
742 qsort(slist, ns, sizeof (be_snapshot_list_t *),
743 be_qsort_compare_snapshots);
744 /* rewrite list pointer chain, including terminator */
745 ptrlist[ibe]->be_node_snapshots = slist[0];
746 for (k = 0; k < ns; k++)
747 slist[k]->be_next_snapshot = slist[k + 1];
748 end_snapshot:
749 free(slist);
750 }
751 /* sort subordinate datasets */
752 if (ptrlist[ibe]->be_node_num_datasets > 1) {
753 const size_t nmax = ptrlist[ibe]->be_node_num_datasets;
754 be_dataset_list_t ** const slist =
755 malloc(sizeof (be_dataset_list_t *) * (nmax + 1));
756 be_dataset_list_t *p;
757
758 if (slist == NULL)
759 continue;
760 /* build array of linked list dataset struct ptrs */
761 for (ns = 0, p = ptrlist[ibe]->be_node_datasets;
762 ns < nmax && p != NULL;
763 ns++, p = p->be_next_dataset) {
764 slist[ns] = p;
765 }
766 if (ns < 2) /* subordinate datasets < 2 - no sort */
767 goto end_dataset;
768 slist[ns] = NULL; /* add terminator */
769 /* in-place list quicksort using qsort(3C) */
770 qsort(slist, ns, sizeof (be_dataset_list_t *),
771 be_qsort_compare_datasets);
772 /* rewrite list pointer chain, including terminator */
773 ptrlist[ibe]->be_node_datasets = slist[0];
774 for (k = 0; k < ns; k++)
775 slist[k]->be_next_dataset = slist[k + 1];
776 end_dataset:
777 free(slist);
778 }
779 }
780 free:
781 free(ptrlist);
782 }
783
784 /*
785 * Function: be_qsort_compare_BEs_date
786 * Description: compare BE creation times for qsort(3C)
787 * will sort BE list from oldest to most recent
788 * Parameters:
789 * x,y - BEs with names to compare
790 * Returns:
791 * positive if x>y, negative if y>x, 0 if equal
792 * Scope:
793 * Private
794 */
795 static int
796 be_qsort_compare_BEs_date(const void *x, const void *y)
797 {
798 be_node_list_t *p = *(be_node_list_t **)x;
799 be_node_list_t *q = *(be_node_list_t **)y;
800
801 assert(p != NULL);
802 assert(q != NULL);
803
804 if (p->be_node_creation > q->be_node_creation)
805 return (1);
806 if (p->be_node_creation < q->be_node_creation)
807 return (-1);
808 return (0);
809 }
810
811 /*
812 * Function: be_qsort_compare_BEs_date_rev
813 * Description: compare BE creation times for qsort(3C)
814 * will sort BE list from recent to oldest
815 * Parameters:
816 * x,y - BEs with names to compare
817 * Returns:
818 * positive if y>x, negative if x>y, 0 if equal
819 * Scope:
820 * Private
821 */
822 static int
823 be_qsort_compare_BEs_date_rev(const void *x, const void *y)
824 {
825 return (be_qsort_compare_BEs_date(y, x));
826 }
827
828 /*
829 * Function: be_qsort_compare_BEs_name
830 * Description: lexical compare of BE names for qsort(3C)
831 * Parameters:
832 * x,y - BEs with names to compare
833 * Returns:
834 * positive if x>y, negative if y>x, 0 if equal
835 * Scope:
836 * Private
837 */
838 static int
839 be_qsort_compare_BEs_name(const void *x, const void *y)
840 {
841 be_node_list_t *p = *(be_node_list_t **)x;
842 be_node_list_t *q = *(be_node_list_t **)y;
843
844 assert(p != NULL);
845 assert(p->be_node_name != NULL);
846 assert(q != NULL);
847 assert(q->be_node_name != NULL);
848
849 return (strcmp(p->be_node_name, q->be_node_name));
850 }
851
852 /*
853 * Function: be_qsort_compare_BEs_name_rev
854 * Description: reverse lexical compare of BE names for qsort(3C)
855 * Parameters:
856 * x,y - BEs with names to compare
857 * Returns:
858 * positive if y>x, negative if x>y, 0 if equal
859 * Scope:
860 * Private
861 */
862 static int
863 be_qsort_compare_BEs_name_rev(const void *x, const void *y)
864 {
865 return (be_qsort_compare_BEs_name(y, x));
866 }
867
868 /*
869 * Function: be_qsort_compare_BEs_space
870 * Description: compare BE sizes for qsort(3C)
871 * will sort BE list in growing order
872 * Parameters:
873 * x,y - BEs with names to compare
874 * Returns:
875 * positive if x>y, negative if y>x, 0 if equal
876 * Scope:
877 * Private
878 */
879 static int
880 be_qsort_compare_BEs_space(const void *x, const void *y)
881 {
882 be_node_list_t *p = *(be_node_list_t **)x;
883 be_node_list_t *q = *(be_node_list_t **)y;
884
885 assert(p != NULL);
886 assert(q != NULL);
887
888 if (p->be_space_used > q->be_space_used)
889 return (1);
890 if (p->be_space_used < q->be_space_used)
891 return (-1);
892 return (0);
893 }
894
895 /*
896 * Function: be_qsort_compare_BEs_space_rev
897 * Description: compare BE sizes for qsort(3C)
898 * will sort BE list in shrinking
899 * Parameters:
900 * x,y - BEs with names to compare
901 * Returns:
902 * positive if y>x, negative if x>y, 0 if equal
903 * Scope:
904 * Private
905 */
906 static int
907 be_qsort_compare_BEs_space_rev(const void *x, const void *y)
908 {
909 return (be_qsort_compare_BEs_space(y, x));
910 }
911
912 /*
913 * Function: be_qsort_compare_snapshots
914 * Description: lexical compare of BE names for qsort(3C)
915 * Parameters:
916 * x,y - BE snapshots with names to compare
917 * Returns:
918 * positive if y>x, negative if x>y, 0 if equal
919 * Scope:
920 * Private
921 */
922 static int
923 be_qsort_compare_snapshots(const void *x, const void *y)
924 {
925 be_snapshot_list_t *p = *(be_snapshot_list_t **)x;
926 be_snapshot_list_t *q = *(be_snapshot_list_t **)y;
927
928 if (p == NULL || p->be_snapshot_name == NULL)
929 return (1);
930 if (q == NULL || q->be_snapshot_name == NULL)
931 return (-1);
932 return (strcmp(p->be_snapshot_name, q->be_snapshot_name));
933 }
934
935 /*
936 * Function: be_qsort_compare_datasets
937 * Description: lexical compare of dataset names for qsort(3C)
938 * Parameters:
939 * x,y - BE snapshots with names to compare
940 * Returns:
941 * positive if y>x, negative if x>y, 0 if equal
942 * Scope:
943 * Private
944 */
945 static int
946 be_qsort_compare_datasets(const void *x, const void *y)
947 {
948 be_dataset_list_t *p = *(be_dataset_list_t **)x;
949 be_dataset_list_t *q = *(be_dataset_list_t **)y;
950
951 if (p == NULL || p->be_dataset_name == NULL)
952 return (1);
953 if (q == NULL || q->be_dataset_name == NULL)
954 return (-1);
955 return (strcmp(p->be_dataset_name, q->be_dataset_name));
956 }
957
958 /*
959 * Function: be_get_node_data
960 * Description: Helper function used to collect all the information to fill
961 * in the be_node_list structure to be returned by be_list.
962 * Parameters:
963 * zhp - Handle to the root dataset for the BE whose information
964 * we're collecting.
965 * be_node - a pointer to the node structure we're filling in.
966 * be_name - The BE name of the node whose information we're
967 * collecting.
968 * current_be - the name of the currently active BE.
969 * be_ds - The dataset name for the BE.
970 *
971 * Returns:
972 * BE_SUCCESS - Success
973 * be_errno_t - Failure
974 * Scope:
975 * Private
976 */
977 static int
978 be_get_node_data(
979 zfs_handle_t *zhp,
980 be_node_list_t *be_node,
981 char *be_name,
982 const char *rpool,
983 char *current_be,
984 char *be_ds)
985 {
986 char prop_buf[MAXPATHLEN];
987 nvlist_t *userprops = NULL;
988 nvlist_t *propval = NULL;
989 nvlist_t *zone_propval = NULL;
990 char *prop_str = NULL;
991 char *zone_prop_str = NULL;
992 char *grub_default_bootfs = NULL;
993 zpool_handle_t *zphp = NULL;
994 int err = 0;
995
996 if (be_node == NULL || be_name == NULL || current_be == NULL ||
997 be_ds == NULL) {
998 be_print_err(gettext("be_get_node_data: invalid arguments, "
999 "can not be NULL\n"));
1000 return (BE_ERR_INVAL);
1001 }
1002
1003 errno = 0;
1004
1005 be_node->be_root_ds = strdup(be_ds);
1006 if ((err = errno) != 0 || be_node->be_root_ds == NULL) {
1007 be_print_err(gettext("be_get_node_data: failed to "
1008 "copy root dataset name\n"));
1009 return (errno_to_be_err(err));
1010 }
1011
1012 be_node->be_node_name = strdup(be_name);
1013 if ((err = errno) != 0 || be_node->be_node_name == NULL) {
1014 be_print_err(gettext("be_get_node_data: failed to "
1015 "copy BE name\n"));
1016 return (errno_to_be_err(err));
1017 }
1018 if (strncmp(be_name, current_be, MAXPATHLEN) == 0)
1019 be_node->be_active = B_TRUE;
1020 else
1021 be_node->be_active = B_FALSE;
1022
1023 be_node->be_rpool = strdup(rpool);
1024 if (be_node->be_rpool == NULL || (err = errno) != 0) {
1025 be_print_err(gettext("be_get_node_data: failed to "
1026 "copy root pool name\n"));
1027 return (errno_to_be_err(err));
1028 }
1029
1030 be_node->be_space_used = zfs_prop_get_int(zhp, ZFS_PROP_USED);
1031
1032 if (getzoneid() == GLOBAL_ZONEID) {
1033 if ((zphp = zpool_open(g_zfs, rpool)) == NULL) {
1034 be_print_err(gettext("be_get_node_data: failed to open "
1035 "pool (%s): %s\n"), rpool,
1036 libzfs_error_description(g_zfs));
1037 return (zfs_err_to_be_err(g_zfs));
1038 }
1039
1040 (void) zpool_get_prop(zphp, ZPOOL_PROP_BOOTFS, prop_buf,
1041 ZFS_MAXPROPLEN, NULL, B_FALSE);
1042 if (be_has_grub() && (be_default_grub_bootfs(rpool,
1043 &grub_default_bootfs) == BE_SUCCESS) &&
1044 grub_default_bootfs != NULL)
1045 if (strcmp(grub_default_bootfs, be_ds) == 0)
1046 be_node->be_active_on_boot = B_TRUE;
1047 else
1048 be_node->be_active_on_boot = B_FALSE;
1049 else if (prop_buf != NULL && strcmp(prop_buf, be_ds) == 0)
1050 be_node->be_active_on_boot = B_TRUE;
1051 else
1052 be_node->be_active_on_boot = B_FALSE;
1053
1054 be_node->be_global_active = B_TRUE;
1055
1056 free(grub_default_bootfs);
1057 zpool_close(zphp);
1058 } else {
1059 if (be_zone_compare_uuids(be_node->be_root_ds))
1060 be_node->be_global_active = B_TRUE;
1061 else
1062 be_node->be_global_active = B_FALSE;
1063 }
1064
1065 /*
1066 * If the dataset is mounted use the mount point
1067 * returned from the zfs_is_mounted call. If the
1068 * dataset is not mounted then pull the mount
1069 * point information out of the zfs properties.
1070 */
1071 be_node->be_mounted = zfs_is_mounted(zhp,
1072 &(be_node->be_mntpt));
1073 if (!be_node->be_mounted) {
1074 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, prop_buf,
1075 ZFS_MAXPROPLEN, NULL, NULL, 0, B_FALSE) == 0)
1076 be_node->be_mntpt = strdup(prop_buf);
1077 else
1078 return (zfs_err_to_be_err(g_zfs));
1079 }
1080
1081 be_node->be_node_creation = (time_t)zfs_prop_get_int(zhp,
1082 ZFS_PROP_CREATION);
1083
1084 /* Get all user properties used for libbe */
1085 if ((userprops = zfs_get_user_props(zhp)) == NULL) {
1086 be_node->be_policy_type = strdup(be_default_policy());
1087 } else {
1088 if (getzoneid() != GLOBAL_ZONEID) {
1089 if (nvlist_lookup_nvlist(userprops,
1090 BE_ZONE_ACTIVE_PROPERTY, &zone_propval) != 0 ||
1091 zone_propval == NULL) {
1092 be_node->be_active_on_boot = B_FALSE;
1093 } else {
1094 verify(nvlist_lookup_string(zone_propval,
1095 ZPROP_VALUE, &zone_prop_str) == 0);
1096 if (strcmp(zone_prop_str, "on") == 0) {
1097 be_node->be_active_on_boot = B_TRUE;
1098 } else {
1099 be_node->be_active_on_boot = B_FALSE;
1100 }
1101 }
1102 }
1103
1104 if (nvlist_lookup_nvlist(userprops, BE_POLICY_PROPERTY,
1105 &propval) != 0 || propval == NULL) {
1106 be_node->be_policy_type =
1107 strdup(be_default_policy());
1108 } else {
1109 verify(nvlist_lookup_string(propval, ZPROP_VALUE,
1110 &prop_str) == 0);
1111 if (prop_str == NULL || strcmp(prop_str, "-") == 0 ||
1112 strcmp(prop_str, "") == 0)
1113 be_node->be_policy_type =
1114 strdup(be_default_policy());
1115 else
1116 be_node->be_policy_type = strdup(prop_str);
1117 }
1118 if (getzoneid() != GLOBAL_ZONEID) {
1119 if (nvlist_lookup_nvlist(userprops,
1120 BE_ZONE_PARENTBE_PROPERTY, &propval) != 0 &&
1121 nvlist_lookup_string(propval, ZPROP_VALUE,
1122 &prop_str) == 0) {
1123 be_node->be_uuid_str = strdup(prop_str);
1124 }
1125 } else {
1126 if (nvlist_lookup_nvlist(userprops, BE_UUID_PROPERTY,
1127 &propval) == 0 && nvlist_lookup_string(propval,
1128 ZPROP_VALUE, &prop_str) == 0) {
1129 be_node->be_uuid_str = strdup(prop_str);
1130 }
1131 }
1132 }
1133
1134 /*
1135 * Increment the dataset counter to include the root dataset
1136 * of the BE.
1137 */
1138 be_node->be_node_num_datasets++;
1139
1140 return (BE_SUCCESS);
1141 }
1142
1143 /*
1144 * Function: be_get_ds_data
1145 * Description: Helper function used by be_add_children_callback to collect
1146 * the dataset related information that will be returned by
1147 * be_list.
1148 * Parameters:
1149 * zhp - Handle to the zfs dataset whose information we're
1150 * collecting.
1151 * name - The name of the dataset we're processing.
1152 * dataset - A pointer to the be_dataset_list structure
1153 * we're filling in.
1154 * node - The node structure that this dataset belongs to.
1155 * Return:
1156 * BE_SUCCESS - Success
1157 * be_errno_t - Failure
1158 * Scope:
1159 * Private
1160 */
1161 static int
1162 be_get_ds_data(
1163 zfs_handle_t *zfshp,
1164 char *name,
1165 be_dataset_list_t *dataset,
1166 be_node_list_t *node)
1167 {
1168 char prop_buf[ZFS_MAXPROPLEN];
1169 nvlist_t *propval = NULL;
1170 nvlist_t *userprops = NULL;
1171 char *prop_str = NULL;
1172 int err = 0;
1173
1174 if (zfshp == NULL || name == NULL || dataset == NULL || node == NULL) {
1175 be_print_err(gettext("be_get_ds_data: invalid arguments, "
1176 "can not be NULL\n"));
1177 return (BE_ERR_INVAL);
1178 }
1179
1180 errno = 0;
1181
1182 dataset->be_dataset_name = strdup(name);
1183 if ((err = errno) != 0) {
1184 be_print_err(gettext("be_get_ds_data: failed to copy "
1185 "dataset name\n"));
1186 return (errno_to_be_err(err));
1187 }
1188
1189 dataset->be_ds_space_used = zfs_prop_get_int(zfshp, ZFS_PROP_USED);
1190
1191 /*
1192 * If the dataset is mounted use the mount point
1193 * returned from the zfs_is_mounted call. If the
1194 * dataset is not mounted then pull the mount
1195 * point information out of the zfs properties.
1196 */
1197 if (!(dataset->be_ds_mounted = zfs_is_mounted(zfshp,
1198 &(dataset->be_ds_mntpt)))) {
1199 if (zfs_prop_get(zfshp, ZFS_PROP_MOUNTPOINT,
1200 prop_buf, ZFS_MAXPROPLEN, NULL, NULL, 0,
1201 B_FALSE) == 0)
1202 dataset->be_ds_mntpt = strdup(prop_buf);
1203 else
1204 return (zfs_err_to_be_err(g_zfs));
1205 }
1206 dataset->be_ds_creation =
1207 (time_t)zfs_prop_get_int(zfshp, ZFS_PROP_CREATION);
1208
1209 /*
1210 * Get the user property used for the libbe
1211 * cleaup policy
1212 */
1213 if ((userprops = zfs_get_user_props(zfshp)) == NULL) {
1214 dataset->be_ds_plcy_type =
1215 strdup(node->be_policy_type);
1216 } else {
1217 if (nvlist_lookup_nvlist(userprops,
1218 BE_POLICY_PROPERTY, &propval) != 0 ||
1219 propval == NULL) {
1220 dataset->be_ds_plcy_type =
1221 strdup(node->be_policy_type);
1222 } else {
1223 verify(nvlist_lookup_string(propval,
1224 ZPROP_VALUE, &prop_str) == 0);
1225 if (prop_str == NULL ||
1226 strcmp(prop_str, "-") == 0 ||
1227 strcmp(prop_str, "") == 0)
1228 dataset->be_ds_plcy_type
1229 = strdup(node->be_policy_type);
1230 else
1231 dataset->be_ds_plcy_type = strdup(prop_str);
1232 }
1233 }
1234
1235 node->be_node_num_datasets++;
1236 return (BE_SUCCESS);
1237 }
1238
1239 /*
1240 * Function: be_get_ss_data
1241 * Description: Helper function used by be_add_children_callback to collect
1242 * the dataset related information that will be returned by
1243 * be_list.
1244 * Parameters:
1245 * zhp - Handle to the zfs snapshot whose information we're
1246 * collecting.
1247 * name - The name of the snapshot we're processing.
1248 * shapshot - A pointer to the be_snapshot_list structure
1249 * we're filling in.
1250 * node - The node structure that this snapshot belongs to.
1251 * Returns:
1252 * BE_SUCCESS - Success
1253 * be_errno_t - Failure
1254 * Scope:
1255 * Private
1256 */
1257 static int
1258 be_get_ss_data(
1259 zfs_handle_t *zfshp,
1260 char *name,
1261 be_snapshot_list_t *snapshot,
1262 be_node_list_t *node)
1263 {
1264 nvlist_t *propval = NULL;
1265 nvlist_t *userprops = NULL;
1266 char *prop_str = NULL;
1267 int err = 0;
1268
1269 if (zfshp == NULL || name == NULL || snapshot == NULL || node == NULL) {
1270 be_print_err(gettext("be_get_ss_data: invalid arguments, "
1271 "can not be NULL\n"));
1272 return (BE_ERR_INVAL);
1273 }
1274
1275 errno = 0;
1276
1277 snapshot->be_snapshot_name = strdup(name);
1278 if ((err = errno) != 0) {
1279 be_print_err(gettext("be_get_ss_data: failed to copy name\n"));
1280 return (errno_to_be_err(err));
1281 }
1282
1283 snapshot->be_snapshot_creation = (time_t)zfs_prop_get_int(zfshp,
1284 ZFS_PROP_CREATION);
1285
1286 /*
1287 * Try to get this snapshot's cleanup policy from its
1288 * user properties first. If not there, use default
1289 * cleanup policy.
1290 */
1291 if ((userprops = zfs_get_user_props(zfshp)) != NULL &&
1292 nvlist_lookup_nvlist(userprops, BE_POLICY_PROPERTY,
1293 &propval) == 0 && nvlist_lookup_string(propval,
1294 ZPROP_VALUE, &prop_str) == 0) {
1295 snapshot->be_snapshot_type =
1296 strdup(prop_str);
1297 } else {
1298 snapshot->be_snapshot_type =
1299 strdup(be_default_policy());
1300 }
1301
1302 snapshot->be_snapshot_space_used = zfs_prop_get_int(zfshp,
1303 ZFS_PROP_USED);
1304
1305 node->be_node_num_snapshots++;
1306 return (BE_SUCCESS);
1307 }
1308
1309 /*
1310 * Function: be_list_alloc
1311 * Description: Helper function used to allocate memory for the various
1312 * sructures that make up a BE node.
1313 * Parameters:
1314 * err - Used to return any errors encountered.
1315 * BE_SUCCESS - Success
1316 * BE_ERR_NOMEM - Allocation failure
1317 * size - The size of memory to allocate.
1318 * Returns:
1319 * Success - A pointer to the allocated memory
1320 * Failure - NULL
1321 * Scope:
1322 * Private
1323 */
1324 static void*
1325 be_list_alloc(int *err, size_t size)
1326 {
1327 void *bep = NULL;
1328
1329 bep = calloc(1, size);
1330 if (bep == NULL) {
1331 be_print_err(gettext("be_list_alloc: memory "
1332 "allocation failed\n"));
1333 *err = BE_ERR_NOMEM;
1334 }
1335 *err = BE_SUCCESS;
1336 return (bep);
1337 }
1338
1339 /*
1340 * Function: be_get_zone_node_data
1341 * Description: Helper function used to collect all the information to
1342 * fill in the be_node_list structure to be returned by
1343 * be_get_zone_list.
1344 * Parameters:
1345 * be_node - a pointer to the node structure we're filling in.
1346 * be_name - The BE name of the node whose information we're
1347 * Returns:
1348 * BE_SUCCESS - Success
1349 * be_errno_t - Failure
1350 * Scope:
1351 * Private
1352 *
1353 * NOTE: This function currently only collects the zone BE name but when
1354 * support for beadm/libbe in a zone is provided it will need to fill
1355 * in the rest of the information needed for a zone BE.
1356 */
1357 static int
1358 be_get_zone_node_data(be_node_list_t *be_node, char *be_name)
1359 {
1360 if ((be_node->be_node_name = strdup(be_name)) != NULL)
1361 return (BE_SUCCESS);
1362 return (BE_ERR_NOMEM);
1363 }