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