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