lib/libzfs/libzfs_iter.c

   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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2013, 2015 by Delphix. All rights reserved.
  25  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
  26  * Copyright (c) 2019 Datto Inc.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <strings.h>
  32 #include <unistd.h>
  33 #include <stddef.h>
  34 #include <libintl.h>
  35 #include <libzfs.h>
  36 #include <libzutil.h>
  37 #include <sys/mntent.h>
  38
  39 #include "libzfs_impl.h"
  40
  41 int
  42 zfs_iter_clones(zfs_handle_t *zhp, zfs_iter_f func, void *data)
  43 {
  44         nvlist_t *nvl = zfs_get_clones_nvl(zhp);
  45         nvpair_t *pair;
  46
  47         if (nvl == NULL)
  48                 return (0);
  49
  50         for (pair = nvlist_next_nvpair(nvl, NULL); pair != NULL;
  51             pair = nvlist_next_nvpair(nvl, pair)) {
  52                 zfs_handle_t *clone = zfs_open(zhp->zfs_hdl, nvpair_name(pair),
  53                     ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
  54                 if (clone != NULL) {
  55                         int err = func(clone, data);
  56                         if (err != 0)
  57                                 return (err);
  58                 }
  59         }
  60         return (0);
  61 }
  62
  63 static int
  64 zfs_do_list_ioctl(zfs_handle_t *zhp, int arg, zfs_cmd_t *zc)
  65 {
  66         int rc;
  67         uint64_t        orig_cookie;
  68
  69         orig_cookie = zc->zc_cookie;
  70 top:
  71         (void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
  72         rc = ioctl(zhp->zfs_hdl->libzfs_fd, arg, zc);
  73
  74         if (rc == -1) {
  75                 switch (errno) {
  76                 case ENOMEM:
  77                         /* expand nvlist memory and try again */
  78                         if (zcmd_expand_dst_nvlist(zhp->zfs_hdl, zc) != 0) {
  79                                 zcmd_free_nvlists(zc);
  80                                 return (-1);
  81                         }
  82                         zc->zc_cookie = orig_cookie;
  83                         goto top;
  84                 /*
  85                  * An errno value of ESRCH indicates normal completion.
  86                  * If ENOENT is returned, then the underlying dataset
  87                  * has been removed since we obtained the handle.
  88                  */
  89                 case ESRCH:
  90                 case ENOENT:
  91                         rc = 1;
  92                         break;
  93                 default:
  94                         rc = zfs_standard_error(zhp->zfs_hdl, errno,
  95                             dgettext(TEXT_DOMAIN,
  96                             "cannot iterate filesystems"));
  97                         break;
  98                 }
  99         }
 100         return (rc);
 101 }
 102
 103 /*
 104  * Iterate over all child filesystems
 105  */
 106 int
 107 zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
 108 {
 109         zfs_cmd_t zc = {"\0"};
 110         zfs_handle_t *nzhp;
 111         int ret;
 112
 113         if (zhp->zfs_type != ZFS_TYPE_FILESYSTEM)
 114                 return (0);
 115
 116         if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
 117                 return (-1);
 118
 119         while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_DATASET_LIST_NEXT,
 120             &zc)) == 0) {
 121                 /*
 122                  * Silently ignore errors, as the only plausible explanation is
 123                  * that the pool has since been removed.
 124                  */
 125                 if ((nzhp = make_dataset_handle_zc(zhp->zfs_hdl,
 126                     &zc)) == NULL) {
 127                         continue;
 128                 }
 129
 130                 if ((ret = func(nzhp, data)) != 0) {
 131                         zcmd_free_nvlists(&zc);
 132                         return (ret);
 133                 }
 134         }
 135         zcmd_free_nvlists(&zc);
 136         return ((ret < 0) ? ret : 0);
 137 }
 138
 139 /*
 140  * Iterate over all snapshots
 141  */
 142 int
 143 zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
 144     void *data, uint64_t min_txg, uint64_t max_txg)
 145 {
 146         zfs_cmd_t zc = {"\0"};
 147         zfs_handle_t *nzhp;
 148         int ret;
 149         nvlist_t *range_nvl = NULL;
 150
 151         if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT ||
 152             zhp->zfs_type == ZFS_TYPE_BOOKMARK)
 153                 return (0);
 154
 155         zc.zc_simple = simple;
 156
 157         if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
 158                 return (-1);
 159
 160         if (min_txg != 0) {
 161                 range_nvl = fnvlist_alloc();
 162                 fnvlist_add_uint64(range_nvl, SNAP_ITER_MIN_TXG, min_txg);
 163         }
 164         if (max_txg != 0) {
 165                 if (range_nvl == NULL)
 166                         range_nvl = fnvlist_alloc();
 167                 fnvlist_add_uint64(range_nvl, SNAP_ITER_MAX_TXG, max_txg);
 168         }
 169
 170         if (range_nvl != NULL &&
 171             zcmd_write_src_nvlist(zhp->zfs_hdl, &zc, range_nvl) != 0) {
 172                 zcmd_free_nvlists(&zc);
 173                 fnvlist_free(range_nvl);
 174                 return (-1);
 175         }
 176
 177         while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
 178             &zc)) == 0) {
 179
 180                 if (simple)
 181                         nzhp = make_dataset_simple_handle_zc(zhp, &zc);
 182                 else
 183                         nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
 184                 if (nzhp == NULL)
 185                         continue;
 186
 187                 if ((ret = func(nzhp, data)) != 0) {
 188                         zcmd_free_nvlists(&zc);
 189                         fnvlist_free(range_nvl);
 190                         return (ret);
 191                 }
 192         }
 193         zcmd_free_nvlists(&zc);
 194         fnvlist_free(range_nvl);
 195         return ((ret < 0) ? ret : 0);
 196 }
 197
 198 /*
 199  * Iterate over all bookmarks
 200  */
 201 int
 202 zfs_iter_bookmarks(zfs_handle_t *zhp, zfs_iter_f func, void *data)
 203 {
 204         zfs_handle_t *nzhp;
 205         nvlist_t *props = NULL;
 206         nvlist_t *bmarks = NULL;
 207         int err;
 208         nvpair_t *pair;
 209
 210         if ((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT | ZFS_TYPE_BOOKMARK)) != 0)
 211                 return (0);
 212
 213         /* Setup the requested properties nvlist. */
 214         props = fnvlist_alloc();
 215         fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_GUID));
 216         fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATETXG));
 217         fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_CREATION));
 218         fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_IVSET_GUID));
 219
 220         if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
 221                 goto out;
 222
 223         for (pair = nvlist_next_nvpair(bmarks, NULL);
 224             pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
 225                 char name[ZFS_MAX_DATASET_NAME_LEN];
 226                 char *bmark_name;
 227                 nvlist_t *bmark_props;
 228
 229                 bmark_name = nvpair_name(pair);
 230                 bmark_props = fnvpair_value_nvlist(pair);
 231
 232                 if (snprintf(name, sizeof (name), "%s#%s", zhp->zfs_name,
 233                     bmark_name) >= sizeof (name)) {
 234                         err = EINVAL;
 235                         goto out;
 236                 }
 237
 238                 nzhp = make_bookmark_handle(zhp, name, bmark_props);
 239                 if (nzhp == NULL)
 240                         continue;
 241
 242                 if ((err = func(nzhp, data)) != 0)
 243                         goto out;
 244         }
 245
 246 out:
 247         fnvlist_free(props);
 248         fnvlist_free(bmarks);
 249
 250         return (err);
 251 }
 252
 253 /*
 254  * Routines for dealing with the sorted snapshot functionality
 255  */
 256 typedef struct zfs_node {
 257         zfs_handle_t    *zn_handle;
 258         avl_node_t      zn_avlnode;
 259 } zfs_node_t;
 260
 261 static int
 262 zfs_sort_snaps(zfs_handle_t *zhp, void *data)
 263 {
 264         avl_tree_t *avl = data;
 265         zfs_node_t *node;
 266         zfs_node_t search;
 267
 268         search.zn_handle = zhp;
 269         node = avl_find(avl, &search, NULL);
 270         if (node) {
 271                 /*
 272                  * If this snapshot was renamed while we were creating the
 273                  * AVL tree, it's possible that we already inserted it under
 274                  * its old name. Remove the old handle before adding the new
 275                  * one.
 276                  */
 277                 zfs_close(node->zn_handle);
 278                 avl_remove(avl, node);
 279                 free(node);
 280         }
 281
 282         node = zfs_alloc(zhp->zfs_hdl, sizeof (zfs_node_t));
 283         node->zn_handle = zhp;
 284         avl_add(avl, node);
 285
 286         return (0);
 287 }
 288
 289 static int
 290 zfs_snapshot_compare(const void *larg, const void *rarg)
 291 {
 292         zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;
 293         zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;
 294         uint64_t lcreate, rcreate;
 295
 296         /*
 297          * Sort them according to creation time.  We use the hidden
 298          * CREATETXG property to get an absolute ordering of snapshots.
 299          */
 300         lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
 301         rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);
 302
 303         return (AVL_CMP(lcreate, rcreate));
 304 }
 305
 306 int
 307 zfs_iter_snapshots_sorted(zfs_handle_t *zhp, zfs_iter_f callback, void *data,
 308     uint64_t min_txg, uint64_t max_txg)
 309 {
 310         int ret = 0;
 311         zfs_node_t *node;
 312         avl_tree_t avl;
 313         void *cookie = NULL;
 314
 315         avl_create(&avl, zfs_snapshot_compare,
 316             sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));
 317
 318         ret = zfs_iter_snapshots(zhp, B_FALSE, zfs_sort_snaps, &avl, min_txg,
 319             max_txg);
 320
 321         for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))
 322                 ret |= callback(node->zn_handle, data);
 323
 324         while ((node = avl_destroy_nodes(&avl, &cookie)) != NULL)
 325                 free(node);
 326
 327         avl_destroy(&avl);
 328
 329         return (ret);
 330 }
 331
 332 typedef struct {
 333         char *ssa_first;
 334         char *ssa_last;
 335         boolean_t ssa_seenfirst;
 336         boolean_t ssa_seenlast;
 337         zfs_iter_f ssa_func;
 338         void *ssa_arg;
 339 } snapspec_arg_t;
 340
 341 static int
 342 snapspec_cb(zfs_handle_t *zhp, void *arg)
 343 {
 344         snapspec_arg_t *ssa = arg;
 345         const char *shortsnapname;
 346         int err = 0;
 347
 348         if (ssa->ssa_seenlast)
 349                 return (0);
 350
 351         shortsnapname = strchr(zfs_get_name(zhp), '@') + 1;
 352         if (!ssa->ssa_seenfirst && strcmp(shortsnapname, ssa->ssa_first) == 0)
 353                 ssa->ssa_seenfirst = B_TRUE;
 354         if (strcmp(shortsnapname, ssa->ssa_last) == 0)
 355                 ssa->ssa_seenlast = B_TRUE;
 356
 357         if (ssa->ssa_seenfirst) {
 358                 err = ssa->ssa_func(zhp, ssa->ssa_arg);
 359         } else {
 360                 zfs_close(zhp);
 361         }
 362
 363         return (err);
 364 }
 365
 366 /*
 367  * spec is a string like "A,B%C,D"
 368  *
 369  * <snaps>, where <snaps> can be:
 370  *      <snap>          (single snapshot)
 371  *      <snap>%<snap>   (range of snapshots, inclusive)
 372  *      %<snap>         (range of snapshots, starting with earliest)
 373  *      <snap>%         (range of snapshots, ending with last)
 374  *      %               (all snapshots)
 375  *      <snaps>[,...]   (comma separated list of the above)
 376  *
 377  * If a snapshot can not be opened, continue trying to open the others, but
 378  * return ENOENT at the end.
 379  */
 380 int
 381 zfs_iter_snapspec(zfs_handle_t *fs_zhp, const char *spec_orig,
 382     zfs_iter_f func, void *arg)
 383 {
 384         char *buf, *comma_separated, *cp;
 385         int err = 0;
 386         int ret = 0;
 387
 388         buf = zfs_strdup(fs_zhp->zfs_hdl, spec_orig);
 389         cp = buf;
 390
 391         while ((comma_separated = strsep(&cp, ",")) != NULL) {
 392                 char *pct = strchr(comma_separated, '%');
 393                 if (pct != NULL) {
 394                         snapspec_arg_t ssa = { 0 };
 395                         ssa.ssa_func = func;
 396                         ssa.ssa_arg = arg;
 397
 398                         if (pct == comma_separated)
 399                                 ssa.ssa_seenfirst = B_TRUE;
 400                         else
 401                                 ssa.ssa_first = comma_separated;
 402                         *pct = '\0';
 403                         ssa.ssa_last = pct + 1;
 404
 405                         /*
 406                          * If there is a lastname specified, make sure it
 407                          * exists.
 408                          */
 409                         if (ssa.ssa_last[0] != '\0') {
 410                                 char snapname[ZFS_MAX_DATASET_NAME_LEN];
 411                                 (void) snprintf(snapname, sizeof (snapname),
 412                                     "%s@%s", zfs_get_name(fs_zhp),
 413                                     ssa.ssa_last);
 414                                 if (!zfs_dataset_exists(fs_zhp->zfs_hdl,
 415                                     snapname, ZFS_TYPE_SNAPSHOT)) {
 416                                         ret = ENOENT;
 417                                         continue;
 418                                 }
 419                         }
 420
 421                         err = zfs_iter_snapshots_sorted(fs_zhp,
 422                             snapspec_cb, &ssa, 0, 0);
 423                         if (ret == 0)
 424                                 ret = err;
 425                         if (ret == 0 && (!ssa.ssa_seenfirst ||
 426                             (ssa.ssa_last[0] != '\0' && !ssa.ssa_seenlast))) {
 427                                 ret = ENOENT;
 428                         }
 429                 } else {
 430                         char snapname[ZFS_MAX_DATASET_NAME_LEN];
 431                         zfs_handle_t *snap_zhp;
 432                         (void) snprintf(snapname, sizeof (snapname), "%s@%s",
 433                             zfs_get_name(fs_zhp), comma_separated);
 434                         snap_zhp = make_dataset_handle(fs_zhp->zfs_hdl,
 435                             snapname);
 436                         if (snap_zhp == NULL) {
 437                                 ret = ENOENT;
 438                                 continue;
 439                         }
 440                         err = func(snap_zhp, arg);
 441                         if (ret == 0)
 442                                 ret = err;
 443                 }
 444         }
 445
 446         free(buf);
 447         return (ret);
 448 }
 449
 450 /*
 451  * Iterate over all children, snapshots and filesystems
 452  * Process snapshots before filesystems because they are nearer the input
 453  * handle: this is extremely important when used with zfs_iter_f functions
 454  * looking for data, following the logic that we would like to find it as soon
 455  * and as close as possible.
 456  */
 457 int
 458 zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data)
 459 {
 460         int ret;
 461
 462         if ((ret = zfs_iter_snapshots(zhp, B_FALSE, func, data, 0, 0)) != 0)
 463                 return (ret);
 464
 465         return (zfs_iter_filesystems(zhp, func, data));
 466 }
 467
 468
 469 typedef struct iter_stack_frame {
 470         struct iter_stack_frame *next;
 471         zfs_handle_t *zhp;
 472 } iter_stack_frame_t;
 473
 474 typedef struct iter_dependents_arg {
 475         boolean_t first;
 476         boolean_t allowrecursion;
 477         iter_stack_frame_t *stack;
 478         zfs_iter_f func;
 479         void *data;
 480 } iter_dependents_arg_t;
 481
 482 static int
 483 iter_dependents_cb(zfs_handle_t *zhp, void *arg)
 484 {
 485         iter_dependents_arg_t *ida = arg;
 486         int err = 0;
 487         boolean_t first = ida->first;
 488         ida->first = B_FALSE;
 489
 490         if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
 491                 err = zfs_iter_clones(zhp, iter_dependents_cb, ida);
 492         } else if (zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
 493                 iter_stack_frame_t isf;
 494                 iter_stack_frame_t *f;
 495
 496                 /*
 497                  * check if there is a cycle by seeing if this fs is already
 498                  * on the stack.
 499                  */
 500                 for (f = ida->stack; f != NULL; f = f->next) {
 501                         if (f->zhp->zfs_dmustats.dds_guid ==
 502                             zhp->zfs_dmustats.dds_guid) {
 503                                 if (ida->allowrecursion) {
 504                                         zfs_close(zhp);
 505                                         return (0);
 506                                 } else {
 507                                         zfs_error_aux(zhp->zfs_hdl,
 508                                             dgettext(TEXT_DOMAIN,
 509                                             "recursive dependency at '%s'"),
 510                                             zfs_get_name(zhp));
 511                                         err = zfs_error(zhp->zfs_hdl,
 512                                             EZFS_RECURSIVE,
 513                                             dgettext(TEXT_DOMAIN,
 514                                             "cannot determine dependent "
 515                                             "datasets"));
 516                                         zfs_close(zhp);
 517                                         return (err);
 518                                 }
 519                         }
 520                 }
 521
 522                 isf.zhp = zhp;
 523                 isf.next = ida->stack;
 524                 ida->stack = &isf;
 525                 err = zfs_iter_filesystems(zhp, iter_dependents_cb, ida);
 526                 if (err == 0)
 527                         err = zfs_iter_snapshots(zhp, B_FALSE,
 528                             iter_dependents_cb, ida, 0, 0);
 529                 ida->stack = isf.next;
 530         }
 531
 532         if (!first && err == 0)
 533                 err = ida->func(zhp, ida->data);
 534         else
 535                 zfs_close(zhp);
 536
 537         return (err);
 538 }
 539
 540 int
 541 zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
 542     zfs_iter_f func, void *data)
 543 {
 544         iter_dependents_arg_t ida;
 545         ida.allowrecursion = allowrecursion;
 546         ida.stack = NULL;
 547         ida.func = func;
 548         ida.data = data;
 549         ida.first = B_TRUE;
 550         return (iter_dependents_cb(zfs_handle_dup(zhp), &ida));
 551 }
 552
 553 /*
 554  * Iterate over mounted children of the specified dataset
 555  */
 556 int
 557 zfs_iter_mounted(zfs_handle_t *zhp, zfs_iter_f func, void *data)
 558 {
 559         char mnt_prop[ZFS_MAXPROPLEN];
 560         struct mnttab entry;
 561         zfs_handle_t *mtab_zhp;
 562         size_t namelen = strlen(zhp->zfs_name);
 563         FILE *mnttab;
 564         int err = 0;
 565
 566         if ((mnttab = fopen(MNTTAB, "r")) == NULL)
 567                 return (ENOENT);
 568
 569         while (err == 0 && getmntent(mnttab, &entry) == 0) {
 570                 /* Ignore non-ZFS entries */
 571                 if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
 572                         continue;
 573
 574                 /* Ignore datasets not within the provided dataset */
 575                 if (strncmp(entry.mnt_special, zhp->zfs_name, namelen) != 0 ||
 576                     (entry.mnt_special[namelen] != '/' &&
 577                     entry.mnt_special[namelen] != '@'))
 578                         continue;
 579
 580                 if ((mtab_zhp = zfs_open(zhp->zfs_hdl, entry.mnt_special,
 581                     ZFS_TYPE_FILESYSTEM)) == NULL)
 582                         continue;
 583
 584                 /* Ignore legacy mounts as they are user managed */
 585                 verify(zfs_prop_get(mtab_zhp, ZFS_PROP_MOUNTPOINT, mnt_prop,
 586                     sizeof (mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
 587                 if (strcmp(mnt_prop, "legacy") == 0) {
 588                         zfs_close(mtab_zhp);
 589                         continue;
 590                 }
 591
 592                 err = func(mtab_zhp, data);
 593         }
 594
 595         fclose(mnttab);
 596
 597         return (err);
 598 }