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