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, int 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 } 523