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