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) 2012 by Delphix. All rights reserved. 25 * Copyright (c) 2012, Joyent, Inc. All rights reserved. 26 */ 27 28 #include <assert.h> 29 #include <ctype.h> 30 #include <errno.h> 31 #include <libintl.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <strings.h> 35 #include <unistd.h> 36 #include <stddef.h> 37 #include <fcntl.h> 38 #include <sys/mount.h> 39 #include <pthread.h> 40 #include <umem.h> 41 #include <time.h> 42 43 #include <libzfs.h> 44 45 #include "zfs_namecheck.h" 46 #include "zfs_prop.h" 47 #include "zfs_fletcher.h" 48 #include "libzfs_impl.h" 49 #include <sha2.h> 50 #include <sys/zio_checksum.h> 51 #include <sys/ddt.h> 52 53 /* in libzfs_dataset.c */ 54 extern void zfs_setprop_error(libzfs_handle_t *, zfs_prop_t, int, char *); 55 56 static int zfs_receive_impl(libzfs_handle_t *, const char *, recvflags_t *, 57 int, const char *, nvlist_t *, avl_tree_t *, char **, int, uint64_t *); 58 59 static const zio_cksum_t zero_cksum = { 0 }; 60 61 typedef struct dedup_arg { 62 int inputfd; 63 int outputfd; 64 libzfs_handle_t *dedup_hdl; 65 } dedup_arg_t; 66 67 typedef struct progress_arg { 68 zfs_handle_t *pa_zhp; 69 int pa_fd; 70 boolean_t pa_parsable; 71 } progress_arg_t; 72 73 typedef struct dataref { 74 uint64_t ref_guid; 75 uint64_t ref_object; 76 uint64_t ref_offset; 77 } dataref_t; 78 79 typedef struct dedup_entry { 80 struct dedup_entry *dde_next; 81 zio_cksum_t dde_chksum; 82 uint64_t dde_prop; 83 dataref_t dde_ref; 84 } dedup_entry_t; 85 86 #define MAX_DDT_PHYSMEM_PERCENT 20 87 #define SMALLEST_POSSIBLE_MAX_DDT_MB 128 88 89 typedef struct dedup_table { 90 dedup_entry_t **dedup_hash_array; 91 umem_cache_t *ddecache; 92 uint64_t max_ddt_size; /* max dedup table size in bytes */ 93 uint64_t cur_ddt_size; /* current dedup table size in bytes */ 94 uint64_t ddt_count; 95 int numhashbits; 96 boolean_t ddt_full; 97 } dedup_table_t; 98 99 static int 100 high_order_bit(uint64_t n) 101 { 102 int count; 103 104 for (count = 0; n != 0; count++) 105 n >>= 1; 106 return (count); 107 } 108 109 static size_t 110 ssread(void *buf, size_t len, FILE *stream) 111 { 112 size_t outlen; 113 114 if ((outlen = fread(buf, len, 1, stream)) == 0) 115 return (0); 116 117 return (outlen); 118 } 119 120 static void 121 ddt_hash_append(libzfs_handle_t *hdl, dedup_table_t *ddt, dedup_entry_t **ddepp, 122 zio_cksum_t *cs, uint64_t prop, dataref_t *dr) 123 { 124 dedup_entry_t *dde; 125 126 if (ddt->cur_ddt_size >= ddt->max_ddt_size) { 127 if (ddt->ddt_full == B_FALSE) { 128 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 129 "Dedup table full. Deduplication will continue " 130 "with existing table entries")); 131 ddt->ddt_full = B_TRUE; 132 } 133 return; 134 } 135 136 if ((dde = umem_cache_alloc(ddt->ddecache, UMEM_DEFAULT)) 137 != NULL) { 138 assert(*ddepp == NULL); 139 dde->dde_next = NULL; 140 dde->dde_chksum = *cs; 141 dde->dde_prop = prop; 142 dde->dde_ref = *dr; 143 *ddepp = dde; 144 ddt->cur_ddt_size += sizeof (dedup_entry_t); 145 ddt->ddt_count++; 146 } 147 } 148 149 /* 150 * Using the specified dedup table, do a lookup for an entry with 151 * the checksum cs. If found, return the block's reference info 152 * in *dr. Otherwise, insert a new entry in the dedup table, using 153 * the reference information specified by *dr. 154 * 155 * return value: true - entry was found 156 * false - entry was not found 157 */ 158 static boolean_t 159 ddt_update(libzfs_handle_t *hdl, dedup_table_t *ddt, zio_cksum_t *cs, 160 uint64_t prop, dataref_t *dr) 161 { 162 uint32_t hashcode; 163 dedup_entry_t **ddepp; 164 165 hashcode = BF64_GET(cs->zc_word[0], 0, ddt->numhashbits); 166 167 for (ddepp = &(ddt->dedup_hash_array[hashcode]); *ddepp != NULL; 168 ddepp = &((*ddepp)->dde_next)) { 169 if (ZIO_CHECKSUM_EQUAL(((*ddepp)->dde_chksum), *cs) && 170 (*ddepp)->dde_prop == prop) { 171 *dr = (*ddepp)->dde_ref; 172 return (B_TRUE); 173 } 174 } 175 ddt_hash_append(hdl, ddt, ddepp, cs, prop, dr); 176 return (B_FALSE); 177 } 178 179 static int 180 cksum_and_write(const void *buf, uint64_t len, zio_cksum_t *zc, int outfd) 181 { 182 fletcher_4_incremental_native(buf, len, zc); 183 return (write(outfd, buf, len)); 184 } 185 186 /* 187 * This function is started in a separate thread when the dedup option 188 * has been requested. The main send thread determines the list of 189 * snapshots to be included in the send stream and makes the ioctl calls 190 * for each one. But instead of having the ioctl send the output to the 191 * the output fd specified by the caller of zfs_send()), the 192 * ioctl is told to direct the output to a pipe, which is read by the 193 * alternate thread running THIS function. This function does the 194 * dedup'ing by: 195 * 1. building a dedup table (the DDT) 196 * 2. doing checksums on each data block and inserting a record in the DDT 197 * 3. looking for matching checksums, and 198 * 4. sending a DRR_WRITE_BYREF record instead of a write record whenever 199 * a duplicate block is found. 200 * The output of this function then goes to the output fd requested 201 * by the caller of zfs_send(). 202 */ 203 static void * 204 cksummer(void *arg) 205 { 206 dedup_arg_t *dda = arg; 207 char *buf = malloc(1<<20); 208 dmu_replay_record_t thedrr; 209 dmu_replay_record_t *drr = &thedrr; 210 struct drr_begin *drrb = &thedrr.drr_u.drr_begin; 211 struct drr_end *drre = &thedrr.drr_u.drr_end; 212 struct drr_object *drro = &thedrr.drr_u.drr_object; 213 struct drr_write *drrw = &thedrr.drr_u.drr_write; 214 struct drr_spill *drrs = &thedrr.drr_u.drr_spill; 215 FILE *ofp; 216 int outfd; 217 dmu_replay_record_t wbr_drr = {0}; 218 struct drr_write_byref *wbr_drrr = &wbr_drr.drr_u.drr_write_byref; 219 dedup_table_t ddt; 220 zio_cksum_t stream_cksum; 221 uint64_t physmem = sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE); 222 uint64_t numbuckets; 223 224 ddt.max_ddt_size = 225 MAX((physmem * MAX_DDT_PHYSMEM_PERCENT)/100, 226 SMALLEST_POSSIBLE_MAX_DDT_MB<<20); 227 228 numbuckets = ddt.max_ddt_size/(sizeof (dedup_entry_t)); 229 230 /* 231 * numbuckets must be a power of 2. Increase number to 232 * a power of 2 if necessary. 233 */ 234 if (!ISP2(numbuckets)) 235 numbuckets = 1 << high_order_bit(numbuckets); 236 237 ddt.dedup_hash_array = calloc(numbuckets, sizeof (dedup_entry_t *)); 238 ddt.ddecache = umem_cache_create("dde", sizeof (dedup_entry_t), 0, 239 NULL, NULL, NULL, NULL, NULL, 0); 240 ddt.cur_ddt_size = numbuckets * sizeof (dedup_entry_t *); 241 ddt.numhashbits = high_order_bit(numbuckets) - 1; 242 ddt.ddt_full = B_FALSE; 243 244 /* Initialize the write-by-reference block. */ 245 wbr_drr.drr_type = DRR_WRITE_BYREF; 246 wbr_drr.drr_payloadlen = 0; 247 248 outfd = dda->outputfd; 249 ofp = fdopen(dda->inputfd, "r"); 250 while (ssread(drr, sizeof (dmu_replay_record_t), ofp) != 0) { 251 252 switch (drr->drr_type) { 253 case DRR_BEGIN: 254 { 255 int fflags; 256 ZIO_SET_CHECKSUM(&stream_cksum, 0, 0, 0, 0); 257 258 /* set the DEDUP feature flag for this stream */ 259 fflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 260 fflags |= (DMU_BACKUP_FEATURE_DEDUP | 261 DMU_BACKUP_FEATURE_DEDUPPROPS); 262 DMU_SET_FEATUREFLAGS(drrb->drr_versioninfo, fflags); 263 264 if (cksum_and_write(drr, sizeof (dmu_replay_record_t), 265 &stream_cksum, outfd) == -1) 266 goto out; 267 if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == 268 DMU_COMPOUNDSTREAM && drr->drr_payloadlen != 0) { 269 int sz = drr->drr_payloadlen; 270 271 if (sz > 1<<20) { 272 free(buf); 273 buf = malloc(sz); 274 } 275 (void) ssread(buf, sz, ofp); 276 if (ferror(stdin)) 277 perror("fread"); 278 if (cksum_and_write(buf, sz, &stream_cksum, 279 outfd) == -1) 280 goto out; 281 } 282 break; 283 } 284 285 case DRR_END: 286 { 287 /* use the recalculated checksum */ 288 ZIO_SET_CHECKSUM(&drre->drr_checksum, 289 stream_cksum.zc_word[0], stream_cksum.zc_word[1], 290 stream_cksum.zc_word[2], stream_cksum.zc_word[3]); 291 if ((write(outfd, drr, 292 sizeof (dmu_replay_record_t))) == -1) 293 goto out; 294 break; 295 } 296 297 case DRR_OBJECT: 298 { 299 if (cksum_and_write(drr, sizeof (dmu_replay_record_t), 300 &stream_cksum, outfd) == -1) 301 goto out; 302 if (drro->drr_bonuslen > 0) { 303 (void) ssread(buf, 304 P2ROUNDUP((uint64_t)drro->drr_bonuslen, 8), 305 ofp); 306 if (cksum_and_write(buf, 307 P2ROUNDUP((uint64_t)drro->drr_bonuslen, 8), 308 &stream_cksum, outfd) == -1) 309 goto out; 310 } 311 break; 312 } 313 314 case DRR_SPILL: 315 { 316 if (cksum_and_write(drr, sizeof (dmu_replay_record_t), 317 &stream_cksum, outfd) == -1) 318 goto out; 319 (void) ssread(buf, drrs->drr_length, ofp); 320 if (cksum_and_write(buf, drrs->drr_length, 321 &stream_cksum, outfd) == -1) 322 goto out; 323 break; 324 } 325 326 case DRR_FREEOBJECTS: 327 { 328 if (cksum_and_write(drr, sizeof (dmu_replay_record_t), 329 &stream_cksum, outfd) == -1) 330 goto out; 331 break; 332 } 333 334 case DRR_WRITE: 335 { 336 dataref_t dataref; 337 338 (void) ssread(buf, drrw->drr_length, ofp); 339 340 /* 341 * Use the existing checksum if it's dedup-capable, 342 * else calculate a SHA256 checksum for it. 343 */ 344 345 if (ZIO_CHECKSUM_EQUAL(drrw->drr_key.ddk_cksum, 346 zero_cksum) || 347 !DRR_IS_DEDUP_CAPABLE(drrw->drr_checksumflags)) { 348 SHA256_CTX ctx; 349 zio_cksum_t tmpsha256; 350 351 SHA256Init(&ctx); 352 SHA256Update(&ctx, buf, drrw->drr_length); 353 SHA256Final(&tmpsha256, &ctx); 354 drrw->drr_key.ddk_cksum.zc_word[0] = 355 BE_64(tmpsha256.zc_word[0]); 356 drrw->drr_key.ddk_cksum.zc_word[1] = 357 BE_64(tmpsha256.zc_word[1]); 358 drrw->drr_key.ddk_cksum.zc_word[2] = 359 BE_64(tmpsha256.zc_word[2]); 360 drrw->drr_key.ddk_cksum.zc_word[3] = 361 BE_64(tmpsha256.zc_word[3]); 362 drrw->drr_checksumtype = ZIO_CHECKSUM_SHA256; 363 drrw->drr_checksumflags = DRR_CHECKSUM_DEDUP; 364 } 365 366 dataref.ref_guid = drrw->drr_toguid; 367 dataref.ref_object = drrw->drr_object; 368 dataref.ref_offset = drrw->drr_offset; 369 370 if (ddt_update(dda->dedup_hdl, &ddt, 371 &drrw->drr_key.ddk_cksum, drrw->drr_key.ddk_prop, 372 &dataref)) { 373 /* block already present in stream */ 374 wbr_drrr->drr_object = drrw->drr_object; 375 wbr_drrr->drr_offset = drrw->drr_offset; 376 wbr_drrr->drr_length = drrw->drr_length; 377 wbr_drrr->drr_toguid = drrw->drr_toguid; 378 wbr_drrr->drr_refguid = dataref.ref_guid; 379 wbr_drrr->drr_refobject = 380 dataref.ref_object; 381 wbr_drrr->drr_refoffset = 382 dataref.ref_offset; 383 384 wbr_drrr->drr_checksumtype = 385 drrw->drr_checksumtype; 386 wbr_drrr->drr_checksumflags = 387 drrw->drr_checksumtype; 388 wbr_drrr->drr_key.ddk_cksum = 389 drrw->drr_key.ddk_cksum; 390 wbr_drrr->drr_key.ddk_prop = 391 drrw->drr_key.ddk_prop; 392 393 if (cksum_and_write(&wbr_drr, 394 sizeof (dmu_replay_record_t), &stream_cksum, 395 outfd) == -1) 396 goto out; 397 } else { 398 /* block not previously seen */ 399 if (cksum_and_write(drr, 400 sizeof (dmu_replay_record_t), &stream_cksum, 401 outfd) == -1) 402 goto out; 403 if (cksum_and_write(buf, 404 drrw->drr_length, 405 &stream_cksum, outfd) == -1) 406 goto out; 407 } 408 break; 409 } 410 411 case DRR_FREE: 412 { 413 if (cksum_and_write(drr, sizeof (dmu_replay_record_t), 414 &stream_cksum, outfd) == -1) 415 goto out; 416 break; 417 } 418 419 default: 420 (void) printf("INVALID record type 0x%x\n", 421 drr->drr_type); 422 /* should never happen, so assert */ 423 assert(B_FALSE); 424 } 425 } 426 out: 427 umem_cache_destroy(ddt.ddecache); 428 free(ddt.dedup_hash_array); 429 free(buf); 430 (void) fclose(ofp); 431 432 return (NULL); 433 } 434 435 /* 436 * Routines for dealing with the AVL tree of fs-nvlists 437 */ 438 typedef struct fsavl_node { 439 avl_node_t fn_node; 440 nvlist_t *fn_nvfs; 441 char *fn_snapname; 442 uint64_t fn_guid; 443 } fsavl_node_t; 444 445 static int 446 fsavl_compare(const void *arg1, const void *arg2) 447 { 448 const fsavl_node_t *fn1 = arg1; 449 const fsavl_node_t *fn2 = arg2; 450 451 if (fn1->fn_guid > fn2->fn_guid) 452 return (+1); 453 else if (fn1->fn_guid < fn2->fn_guid) 454 return (-1); 455 else 456 return (0); 457 } 458 459 /* 460 * Given the GUID of a snapshot, find its containing filesystem and 461 * (optionally) name. 462 */ 463 static nvlist_t * 464 fsavl_find(avl_tree_t *avl, uint64_t snapguid, char **snapname) 465 { 466 fsavl_node_t fn_find; 467 fsavl_node_t *fn; 468 469 fn_find.fn_guid = snapguid; 470 471 fn = avl_find(avl, &fn_find, NULL); 472 if (fn) { 473 if (snapname) 474 *snapname = fn->fn_snapname; 475 return (fn->fn_nvfs); 476 } 477 return (NULL); 478 } 479 480 static void 481 fsavl_destroy(avl_tree_t *avl) 482 { 483 fsavl_node_t *fn; 484 void *cookie; 485 486 if (avl == NULL) 487 return; 488 489 cookie = NULL; 490 while ((fn = avl_destroy_nodes(avl, &cookie)) != NULL) 491 free(fn); 492 avl_destroy(avl); 493 free(avl); 494 } 495 496 /* 497 * Given an nvlist, produce an avl tree of snapshots, ordered by guid 498 */ 499 static avl_tree_t * 500 fsavl_create(nvlist_t *fss) 501 { 502 avl_tree_t *fsavl; 503 nvpair_t *fselem = NULL; 504 505 if ((fsavl = malloc(sizeof (avl_tree_t))) == NULL) 506 return (NULL); 507 508 avl_create(fsavl, fsavl_compare, sizeof (fsavl_node_t), 509 offsetof(fsavl_node_t, fn_node)); 510 511 while ((fselem = nvlist_next_nvpair(fss, fselem)) != NULL) { 512 nvlist_t *nvfs, *snaps; 513 nvpair_t *snapelem = NULL; 514 515 VERIFY(0 == nvpair_value_nvlist(fselem, &nvfs)); 516 VERIFY(0 == nvlist_lookup_nvlist(nvfs, "snaps", &snaps)); 517 518 while ((snapelem = 519 nvlist_next_nvpair(snaps, snapelem)) != NULL) { 520 fsavl_node_t *fn; 521 uint64_t guid; 522 523 VERIFY(0 == nvpair_value_uint64(snapelem, &guid)); 524 if ((fn = malloc(sizeof (fsavl_node_t))) == NULL) { 525 fsavl_destroy(fsavl); 526 return (NULL); 527 } 528 fn->fn_nvfs = nvfs; 529 fn->fn_snapname = nvpair_name(snapelem); 530 fn->fn_guid = guid; 531 532 /* 533 * Note: if there are multiple snaps with the 534 * same GUID, we ignore all but one. 535 */ 536 if (avl_find(fsavl, fn, NULL) == NULL) 537 avl_add(fsavl, fn); 538 else 539 free(fn); 540 } 541 } 542 543 return (fsavl); 544 } 545 546 /* 547 * Routines for dealing with the giant nvlist of fs-nvlists, etc. 548 */ 549 typedef struct send_data { 550 uint64_t parent_fromsnap_guid; 551 nvlist_t *parent_snaps; 552 nvlist_t *fss; 553 nvlist_t *snapprops; 554 const char *fromsnap; 555 const char *tosnap; 556 boolean_t recursive; 557 558 /* 559 * The header nvlist is of the following format: 560 * { 561 * "tosnap" -> string 562 * "fromsnap" -> string (if incremental) 563 * "fss" -> { 564 * id -> { 565 * 566 * "name" -> string (full name; for debugging) 567 * "parentfromsnap" -> number (guid of fromsnap in parent) 568 * 569 * "props" -> { name -> value (only if set here) } 570 * "snaps" -> { name (lastname) -> number (guid) } 571 * "snapprops" -> { name (lastname) -> { name -> value } } 572 * 573 * "origin" -> number (guid) (if clone) 574 * "sent" -> boolean (not on-disk) 575 * } 576 * } 577 * } 578 * 579 */ 580 } send_data_t; 581 582 static void send_iterate_prop(zfs_handle_t *zhp, nvlist_t *nv); 583 584 static int 585 send_iterate_snap(zfs_handle_t *zhp, void *arg) 586 { 587 send_data_t *sd = arg; 588 uint64_t guid = zhp->zfs_dmustats.dds_guid; 589 char *snapname; 590 nvlist_t *nv; 591 592 snapname = strrchr(zhp->zfs_name, '@')+1; 593 594 VERIFY(0 == nvlist_add_uint64(sd->parent_snaps, snapname, guid)); 595 /* 596 * NB: if there is no fromsnap here (it's a newly created fs in 597 * an incremental replication), we will substitute the tosnap. 598 */ 599 if ((sd->fromsnap && strcmp(snapname, sd->fromsnap) == 0) || 600 (sd->parent_fromsnap_guid == 0 && sd->tosnap && 601 strcmp(snapname, sd->tosnap) == 0)) { 602 sd->parent_fromsnap_guid = guid; 603 } 604 605 VERIFY(0 == nvlist_alloc(&nv, NV_UNIQUE_NAME, 0)); 606 send_iterate_prop(zhp, nv); 607 VERIFY(0 == nvlist_add_nvlist(sd->snapprops, snapname, nv)); 608 nvlist_free(nv); 609 610 zfs_close(zhp); 611 return (0); 612 } 613 614 static void 615 send_iterate_prop(zfs_handle_t *zhp, nvlist_t *nv) 616 { 617 nvpair_t *elem = NULL; 618 619 while ((elem = nvlist_next_nvpair(zhp->zfs_props, elem)) != NULL) { 620 char *propname = nvpair_name(elem); 621 zfs_prop_t prop = zfs_name_to_prop(propname); 622 nvlist_t *propnv; 623 624 if (!zfs_prop_user(propname)) { 625 /* 626 * Realistically, this should never happen. However, 627 * we want the ability to add DSL properties without 628 * needing to make incompatible version changes. We 629 * need to ignore unknown properties to allow older 630 * software to still send datasets containing these 631 * properties, with the unknown properties elided. 632 */ 633 if (prop == ZPROP_INVAL) 634 continue; 635 636 if (zfs_prop_readonly(prop)) 637 continue; 638 } 639 640 verify(nvpair_value_nvlist(elem, &propnv) == 0); 641 if (prop == ZFS_PROP_QUOTA || prop == ZFS_PROP_RESERVATION || 642 prop == ZFS_PROP_REFQUOTA || 643 prop == ZFS_PROP_REFRESERVATION) { 644 char *source; 645 uint64_t value; 646 verify(nvlist_lookup_uint64(propnv, 647 ZPROP_VALUE, &value) == 0); 648 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) 649 continue; 650 /* 651 * May have no source before SPA_VERSION_RECVD_PROPS, 652 * but is still modifiable. 653 */ 654 if (nvlist_lookup_string(propnv, 655 ZPROP_SOURCE, &source) == 0) { 656 if ((strcmp(source, zhp->zfs_name) != 0) && 657 (strcmp(source, 658 ZPROP_SOURCE_VAL_RECVD) != 0)) 659 continue; 660 } 661 } else { 662 char *source; 663 if (nvlist_lookup_string(propnv, 664 ZPROP_SOURCE, &source) != 0) 665 continue; 666 if ((strcmp(source, zhp->zfs_name) != 0) && 667 (strcmp(source, ZPROP_SOURCE_VAL_RECVD) != 0)) 668 continue; 669 } 670 671 if (zfs_prop_user(propname) || 672 zfs_prop_get_type(prop) == PROP_TYPE_STRING) { 673 char *value; 674 verify(nvlist_lookup_string(propnv, 675 ZPROP_VALUE, &value) == 0); 676 VERIFY(0 == nvlist_add_string(nv, propname, value)); 677 } else { 678 uint64_t value; 679 verify(nvlist_lookup_uint64(propnv, 680 ZPROP_VALUE, &value) == 0); 681 VERIFY(0 == nvlist_add_uint64(nv, propname, value)); 682 } 683 } 684 } 685 686 /* 687 * recursively generate nvlists describing datasets. See comment 688 * for the data structure send_data_t above for description of contents 689 * of the nvlist. 690 */ 691 static int 692 send_iterate_fs(zfs_handle_t *zhp, void *arg) 693 { 694 send_data_t *sd = arg; 695 nvlist_t *nvfs, *nv; 696 int rv = 0; 697 uint64_t parent_fromsnap_guid_save = sd->parent_fromsnap_guid; 698 uint64_t guid = zhp->zfs_dmustats.dds_guid; 699 char guidstring[64]; 700 701 VERIFY(0 == nvlist_alloc(&nvfs, NV_UNIQUE_NAME, 0)); 702 VERIFY(0 == nvlist_add_string(nvfs, "name", zhp->zfs_name)); 703 VERIFY(0 == nvlist_add_uint64(nvfs, "parentfromsnap", 704 sd->parent_fromsnap_guid)); 705 706 if (zhp->zfs_dmustats.dds_origin[0]) { 707 zfs_handle_t *origin = zfs_open(zhp->zfs_hdl, 708 zhp->zfs_dmustats.dds_origin, ZFS_TYPE_SNAPSHOT); 709 if (origin == NULL) 710 return (-1); 711 VERIFY(0 == nvlist_add_uint64(nvfs, "origin", 712 origin->zfs_dmustats.dds_guid)); 713 } 714 715 /* iterate over props */ 716 VERIFY(0 == nvlist_alloc(&nv, NV_UNIQUE_NAME, 0)); 717 send_iterate_prop(zhp, nv); 718 VERIFY(0 == nvlist_add_nvlist(nvfs, "props", nv)); 719 nvlist_free(nv); 720 721 /* iterate over snaps, and set sd->parent_fromsnap_guid */ 722 sd->parent_fromsnap_guid = 0; 723 VERIFY(0 == nvlist_alloc(&sd->parent_snaps, NV_UNIQUE_NAME, 0)); 724 VERIFY(0 == nvlist_alloc(&sd->snapprops, NV_UNIQUE_NAME, 0)); 725 (void) zfs_iter_snapshots(zhp, send_iterate_snap, sd); 726 VERIFY(0 == nvlist_add_nvlist(nvfs, "snaps", sd->parent_snaps)); 727 VERIFY(0 == nvlist_add_nvlist(nvfs, "snapprops", sd->snapprops)); 728 nvlist_free(sd->parent_snaps); 729 nvlist_free(sd->snapprops); 730 731 /* add this fs to nvlist */ 732 (void) snprintf(guidstring, sizeof (guidstring), 733 "0x%llx", (longlong_t)guid); 734 VERIFY(0 == nvlist_add_nvlist(sd->fss, guidstring, nvfs)); 735 nvlist_free(nvfs); 736 737 /* iterate over children */ 738 if (sd->recursive) 739 rv = zfs_iter_filesystems(zhp, send_iterate_fs, sd); 740 741 sd->parent_fromsnap_guid = parent_fromsnap_guid_save; 742 743 zfs_close(zhp); 744 return (rv); 745 } 746 747 static int 748 gather_nvlist(libzfs_handle_t *hdl, const char *fsname, const char *fromsnap, 749 const char *tosnap, boolean_t recursive, nvlist_t **nvlp, avl_tree_t **avlp) 750 { 751 zfs_handle_t *zhp; 752 send_data_t sd = { 0 }; 753 int error; 754 755 zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 756 if (zhp == NULL) 757 return (EZFS_BADTYPE); 758 759 VERIFY(0 == nvlist_alloc(&sd.fss, NV_UNIQUE_NAME, 0)); 760 sd.fromsnap = fromsnap; 761 sd.tosnap = tosnap; 762 sd.recursive = recursive; 763 764 if ((error = send_iterate_fs(zhp, &sd)) != 0) { 765 nvlist_free(sd.fss); 766 if (avlp != NULL) 767 *avlp = NULL; 768 *nvlp = NULL; 769 return (error); 770 } 771 772 if (avlp != NULL && (*avlp = fsavl_create(sd.fss)) == NULL) { 773 nvlist_free(sd.fss); 774 *nvlp = NULL; 775 return (EZFS_NOMEM); 776 } 777 778 *nvlp = sd.fss; 779 return (0); 780 } 781 782 /* 783 * Routines specific to "zfs send" 784 */ 785 typedef struct send_dump_data { 786 /* these are all just the short snapname (the part after the @) */ 787 const char *fromsnap; 788 const char *tosnap; 789 char prevsnap[ZFS_MAXNAMELEN]; 790 uint64_t prevsnap_obj; 791 boolean_t seenfrom, seento, replicate, doall, fromorigin; 792 boolean_t verbose, dryrun, parsable, progress; 793 int outfd; 794 boolean_t err; 795 nvlist_t *fss; 796 nvlist_t *snapholds; 797 avl_tree_t *fsavl; 798 snapfilter_cb_t *filter_cb; 799 void *filter_cb_arg; 800 nvlist_t *debugnv; 801 char holdtag[ZFS_MAXNAMELEN]; 802 int cleanup_fd; 803 uint64_t size; 804 } send_dump_data_t; 805 806 static int 807 estimate_ioctl(zfs_handle_t *zhp, uint64_t fromsnap_obj, 808 boolean_t fromorigin, uint64_t *sizep) 809 { 810 zfs_cmd_t zc = { 0 }; 811 libzfs_handle_t *hdl = zhp->zfs_hdl; 812 813 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 814 assert(fromsnap_obj == 0 || !fromorigin); 815 816 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 817 zc.zc_obj = fromorigin; 818 zc.zc_sendobj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID); 819 zc.zc_fromobj = fromsnap_obj; 820 zc.zc_guid = 1; /* estimate flag */ 821 822 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_SEND, &zc) != 0) { 823 char errbuf[1024]; 824 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 825 "warning: cannot estimate space for '%s'"), zhp->zfs_name); 826 827 switch (errno) { 828 case EXDEV: 829 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 830 "not an earlier snapshot from the same fs")); 831 return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf)); 832 833 case ENOENT: 834 if (zfs_dataset_exists(hdl, zc.zc_name, 835 ZFS_TYPE_SNAPSHOT)) { 836 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 837 "incremental source (@%s) does not exist"), 838 zc.zc_value); 839 } 840 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 841 842 case EDQUOT: 843 case EFBIG: 844 case EIO: 845 case ENOLINK: 846 case ENOSPC: 847 case ENOSTR: 848 case ENXIO: 849 case EPIPE: 850 case ERANGE: 851 case EFAULT: 852 case EROFS: 853 zfs_error_aux(hdl, strerror(errno)); 854 return (zfs_error(hdl, EZFS_BADBACKUP, errbuf)); 855 856 default: 857 return (zfs_standard_error(hdl, errno, errbuf)); 858 } 859 } 860 861 *sizep = zc.zc_objset_type; 862 863 return (0); 864 } 865 866 /* 867 * Dumps a backup of the given snapshot (incremental from fromsnap if it's not 868 * NULL) to the file descriptor specified by outfd. 869 */ 870 static int 871 dump_ioctl(zfs_handle_t *zhp, const char *fromsnap, uint64_t fromsnap_obj, 872 boolean_t fromorigin, int outfd, nvlist_t *debugnv) 873 { 874 zfs_cmd_t zc = { 0 }; 875 libzfs_handle_t *hdl = zhp->zfs_hdl; 876 nvlist_t *thisdbg; 877 878 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 879 assert(fromsnap_obj == 0 || !fromorigin); 880 881 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 882 zc.zc_cookie = outfd; 883 zc.zc_obj = fromorigin; 884 zc.zc_sendobj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID); 885 zc.zc_fromobj = fromsnap_obj; 886 887 VERIFY(0 == nvlist_alloc(&thisdbg, NV_UNIQUE_NAME, 0)); 888 if (fromsnap && fromsnap[0] != '\0') { 889 VERIFY(0 == nvlist_add_string(thisdbg, 890 "fromsnap", fromsnap)); 891 } 892 893 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_SEND, &zc) != 0) { 894 char errbuf[1024]; 895 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 896 "warning: cannot send '%s'"), zhp->zfs_name); 897 898 VERIFY(0 == nvlist_add_uint64(thisdbg, "error", errno)); 899 if (debugnv) { 900 VERIFY(0 == nvlist_add_nvlist(debugnv, 901 zhp->zfs_name, thisdbg)); 902 } 903 nvlist_free(thisdbg); 904 905 switch (errno) { 906 case EXDEV: 907 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 908 "not an earlier snapshot from the same fs")); 909 return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf)); 910 911 case ENOENT: 912 if (zfs_dataset_exists(hdl, zc.zc_name, 913 ZFS_TYPE_SNAPSHOT)) { 914 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 915 "incremental source (@%s) does not exist"), 916 zc.zc_value); 917 } 918 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 919 920 case EDQUOT: 921 case EFBIG: 922 case EIO: 923 case ENOLINK: 924 case ENOSPC: 925 case ENOSTR: 926 case ENXIO: 927 case EPIPE: 928 case ERANGE: 929 case EFAULT: 930 case EROFS: 931 zfs_error_aux(hdl, strerror(errno)); 932 return (zfs_error(hdl, EZFS_BADBACKUP, errbuf)); 933 934 default: 935 return (zfs_standard_error(hdl, errno, errbuf)); 936 } 937 } 938 939 if (debugnv) 940 VERIFY(0 == nvlist_add_nvlist(debugnv, zhp->zfs_name, thisdbg)); 941 nvlist_free(thisdbg); 942 943 return (0); 944 } 945 946 static void 947 gather_holds(zfs_handle_t *zhp, send_dump_data_t *sdd) 948 { 949 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 950 951 /* 952 * zfs_send() only sets snapholds for sends that need them, 953 * e.g. replication and doall. 954 */ 955 if (sdd->snapholds == NULL) 956 return; 957 958 fnvlist_add_string(sdd->snapholds, zhp->zfs_name, sdd->holdtag); 959 } 960 961 static void * 962 send_progress_thread(void *arg) 963 { 964 progress_arg_t *pa = arg; 965 966 zfs_cmd_t zc = { 0 }; 967 zfs_handle_t *zhp = pa->pa_zhp; 968 libzfs_handle_t *hdl = zhp->zfs_hdl; 969 unsigned long long bytes; 970 char buf[16]; 971 972 time_t t; 973 struct tm *tm; 974 975 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 976 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 977 978 if (!pa->pa_parsable) 979 (void) fprintf(stderr, "TIME SENT SNAPSHOT\n"); 980 981 /* 982 * Print the progress from ZFS_IOC_SEND_PROGRESS every second. 983 */ 984 for (;;) { 985 (void) sleep(1); 986 987 zc.zc_cookie = pa->pa_fd; 988 if (zfs_ioctl(hdl, ZFS_IOC_SEND_PROGRESS, &zc) != 0) 989 return ((void *)-1); 990 991 (void) time(&t); 992 tm = localtime(&t); 993 bytes = zc.zc_cookie; 994 995 if (pa->pa_parsable) { 996 (void) fprintf(stderr, "%02d:%02d:%02d\t%llu\t%s\n", 997 tm->tm_hour, tm->tm_min, tm->tm_sec, 998 bytes, zhp->zfs_name); 999 } else { 1000 zfs_nicenum(bytes, buf, sizeof (buf)); 1001 (void) fprintf(stderr, "%02d:%02d:%02d %5s %s\n", 1002 tm->tm_hour, tm->tm_min, tm->tm_sec, 1003 buf, zhp->zfs_name); 1004 } 1005 } 1006 } 1007 1008 static int 1009 dump_snapshot(zfs_handle_t *zhp, void *arg) 1010 { 1011 send_dump_data_t *sdd = arg; 1012 progress_arg_t pa = { 0 }; 1013 pthread_t tid; 1014 1015 char *thissnap; 1016 int err; 1017 boolean_t isfromsnap, istosnap, fromorigin; 1018 boolean_t exclude = B_FALSE; 1019 1020 thissnap = strchr(zhp->zfs_name, '@') + 1; 1021 isfromsnap = (sdd->fromsnap != NULL && 1022 strcmp(sdd->fromsnap, thissnap) == 0); 1023 1024 if (!sdd->seenfrom && isfromsnap) { 1025 gather_holds(zhp, sdd); 1026 sdd->seenfrom = B_TRUE; 1027 (void) strcpy(sdd->prevsnap, thissnap); 1028 sdd->prevsnap_obj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID); 1029 zfs_close(zhp); 1030 return (0); 1031 } 1032 1033 if (sdd->seento || !sdd->seenfrom) { 1034 zfs_close(zhp); 1035 return (0); 1036 } 1037 1038 istosnap = (strcmp(sdd->tosnap, thissnap) == 0); 1039 if (istosnap) 1040 sdd->seento = B_TRUE; 1041 1042 if (!sdd->doall && !isfromsnap && !istosnap) { 1043 if (sdd->replicate) { 1044 char *snapname; 1045 nvlist_t *snapprops; 1046 /* 1047 * Filter out all intermediate snapshots except origin 1048 * snapshots needed to replicate clones. 1049 */ 1050 nvlist_t *nvfs = fsavl_find(sdd->fsavl, 1051 zhp->zfs_dmustats.dds_guid, &snapname); 1052 1053 VERIFY(0 == nvlist_lookup_nvlist(nvfs, 1054 "snapprops", &snapprops)); 1055 VERIFY(0 == nvlist_lookup_nvlist(snapprops, 1056 thissnap, &snapprops)); 1057 exclude = !nvlist_exists(snapprops, "is_clone_origin"); 1058 } else { 1059 exclude = B_TRUE; 1060 } 1061 } 1062 1063 /* 1064 * If a filter function exists, call it to determine whether 1065 * this snapshot will be sent. 1066 */ 1067 if (exclude || (sdd->filter_cb != NULL && 1068 sdd->filter_cb(zhp, sdd->filter_cb_arg) == B_FALSE)) { 1069 /* 1070 * This snapshot is filtered out. Don't send it, and don't 1071 * set prevsnap_obj, so it will be as if this snapshot didn't 1072 * exist, and the next accepted snapshot will be sent as 1073 * an incremental from the last accepted one, or as the 1074 * first (and full) snapshot in the case of a replication, 1075 * non-incremental send. 1076 */ 1077 zfs_close(zhp); 1078 return (0); 1079 } 1080 1081 gather_holds(zhp, sdd); 1082 fromorigin = sdd->prevsnap[0] == '\0' && 1083 (sdd->fromorigin || sdd->replicate); 1084 1085 if (sdd->verbose) { 1086 uint64_t size; 1087 err = estimate_ioctl(zhp, sdd->prevsnap_obj, 1088 fromorigin, &size); 1089 1090 if (sdd->parsable) { 1091 if (sdd->prevsnap[0] != '\0') { 1092 (void) fprintf(stderr, "incremental\t%s\t%s", 1093 sdd->prevsnap, zhp->zfs_name); 1094 } else { 1095 (void) fprintf(stderr, "full\t%s", 1096 zhp->zfs_name); 1097 } 1098 } else { 1099 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1100 "send from @%s to %s"), 1101 sdd->prevsnap, zhp->zfs_name); 1102 } 1103 if (err == 0) { 1104 if (sdd->parsable) { 1105 (void) fprintf(stderr, "\t%llu\n", 1106 (longlong_t)size); 1107 } else { 1108 char buf[16]; 1109 zfs_nicenum(size, buf, sizeof (buf)); 1110 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1111 " estimated size is %s\n"), buf); 1112 } 1113 sdd->size += size; 1114 } else { 1115 (void) fprintf(stderr, "\n"); 1116 } 1117 } 1118 1119 if (!sdd->dryrun) { 1120 /* 1121 * If progress reporting is requested, spawn a new thread to 1122 * poll ZFS_IOC_SEND_PROGRESS at a regular interval. 1123 */ 1124 if (sdd->progress) { 1125 pa.pa_zhp = zhp; 1126 pa.pa_fd = sdd->outfd; 1127 pa.pa_parsable = sdd->parsable; 1128 1129 if (err = pthread_create(&tid, NULL, 1130 send_progress_thread, &pa)) { 1131 zfs_close(zhp); 1132 return (err); 1133 } 1134 } 1135 1136 err = dump_ioctl(zhp, sdd->prevsnap, sdd->prevsnap_obj, 1137 fromorigin, sdd->outfd, sdd->debugnv); 1138 1139 if (sdd->progress) { 1140 (void) pthread_cancel(tid); 1141 (void) pthread_join(tid, NULL); 1142 } 1143 } 1144 1145 (void) strcpy(sdd->prevsnap, thissnap); 1146 sdd->prevsnap_obj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID); 1147 zfs_close(zhp); 1148 return (err); 1149 } 1150 1151 static int 1152 dump_filesystem(zfs_handle_t *zhp, void *arg) 1153 { 1154 int rv = 0; 1155 send_dump_data_t *sdd = arg; 1156 boolean_t missingfrom = B_FALSE; 1157 zfs_cmd_t zc = { 0 }; 1158 1159 (void) snprintf(zc.zc_name, sizeof (zc.zc_name), "%s@%s", 1160 zhp->zfs_name, sdd->tosnap); 1161 if (ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) { 1162 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1163 "WARNING: could not send %s@%s: does not exist\n"), 1164 zhp->zfs_name, sdd->tosnap); 1165 sdd->err = B_TRUE; 1166 return (0); 1167 } 1168 1169 if (sdd->replicate && sdd->fromsnap) { 1170 /* 1171 * If this fs does not have fromsnap, and we're doing 1172 * recursive, we need to send a full stream from the 1173 * beginning (or an incremental from the origin if this 1174 * is a clone). If we're doing non-recursive, then let 1175 * them get the error. 1176 */ 1177 (void) snprintf(zc.zc_name, sizeof (zc.zc_name), "%s@%s", 1178 zhp->zfs_name, sdd->fromsnap); 1179 if (ioctl(zhp->zfs_hdl->libzfs_fd, 1180 ZFS_IOC_OBJSET_STATS, &zc) != 0) { 1181 missingfrom = B_TRUE; 1182 } 1183 } 1184 1185 sdd->seenfrom = sdd->seento = sdd->prevsnap[0] = 0; 1186 sdd->prevsnap_obj = 0; 1187 if (sdd->fromsnap == NULL || missingfrom) 1188 sdd->seenfrom = B_TRUE; 1189 1190 rv = zfs_iter_snapshots_sorted(zhp, dump_snapshot, arg); 1191 if (!sdd->seenfrom) { 1192 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1193 "WARNING: could not send %s@%s:\n" 1194 "incremental source (%s@%s) does not exist\n"), 1195 zhp->zfs_name, sdd->tosnap, 1196 zhp->zfs_name, sdd->fromsnap); 1197 sdd->err = B_TRUE; 1198 } else if (!sdd->seento) { 1199 if (sdd->fromsnap) { 1200 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1201 "WARNING: could not send %s@%s:\n" 1202 "incremental source (%s@%s) " 1203 "is not earlier than it\n"), 1204 zhp->zfs_name, sdd->tosnap, 1205 zhp->zfs_name, sdd->fromsnap); 1206 } else { 1207 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1208 "WARNING: " 1209 "could not send %s@%s: does not exist\n"), 1210 zhp->zfs_name, sdd->tosnap); 1211 } 1212 sdd->err = B_TRUE; 1213 } 1214 1215 return (rv); 1216 } 1217 1218 static int 1219 dump_filesystems(zfs_handle_t *rzhp, void *arg) 1220 { 1221 send_dump_data_t *sdd = arg; 1222 nvpair_t *fspair; 1223 boolean_t needagain, progress; 1224 1225 if (!sdd->replicate) 1226 return (dump_filesystem(rzhp, sdd)); 1227 1228 /* Mark the clone origin snapshots. */ 1229 for (fspair = nvlist_next_nvpair(sdd->fss, NULL); fspair; 1230 fspair = nvlist_next_nvpair(sdd->fss, fspair)) { 1231 nvlist_t *nvfs; 1232 uint64_t origin_guid = 0; 1233 1234 VERIFY(0 == nvpair_value_nvlist(fspair, &nvfs)); 1235 (void) nvlist_lookup_uint64(nvfs, "origin", &origin_guid); 1236 if (origin_guid != 0) { 1237 char *snapname; 1238 nvlist_t *origin_nv = fsavl_find(sdd->fsavl, 1239 origin_guid, &snapname); 1240 if (origin_nv != NULL) { 1241 nvlist_t *snapprops; 1242 VERIFY(0 == nvlist_lookup_nvlist(origin_nv, 1243 "snapprops", &snapprops)); 1244 VERIFY(0 == nvlist_lookup_nvlist(snapprops, 1245 snapname, &snapprops)); 1246 VERIFY(0 == nvlist_add_boolean( 1247 snapprops, "is_clone_origin")); 1248 } 1249 } 1250 } 1251 again: 1252 needagain = progress = B_FALSE; 1253 for (fspair = nvlist_next_nvpair(sdd->fss, NULL); fspair; 1254 fspair = nvlist_next_nvpair(sdd->fss, fspair)) { 1255 nvlist_t *fslist, *parent_nv; 1256 char *fsname; 1257 zfs_handle_t *zhp; 1258 int err; 1259 uint64_t origin_guid = 0; 1260 uint64_t parent_guid = 0; 1261 1262 VERIFY(nvpair_value_nvlist(fspair, &fslist) == 0); 1263 if (nvlist_lookup_boolean(fslist, "sent") == 0) 1264 continue; 1265 1266 VERIFY(nvlist_lookup_string(fslist, "name", &fsname) == 0); 1267 (void) nvlist_lookup_uint64(fslist, "origin", &origin_guid); 1268 (void) nvlist_lookup_uint64(fslist, "parentfromsnap", 1269 &parent_guid); 1270 1271 if (parent_guid != 0) { 1272 parent_nv = fsavl_find(sdd->fsavl, parent_guid, NULL); 1273 if (!nvlist_exists(parent_nv, "sent")) { 1274 /* parent has not been sent; skip this one */ 1275 needagain = B_TRUE; 1276 continue; 1277 } 1278 } 1279 1280 if (origin_guid != 0) { 1281 nvlist_t *origin_nv = fsavl_find(sdd->fsavl, 1282 origin_guid, NULL); 1283 if (origin_nv != NULL && 1284 !nvlist_exists(origin_nv, "sent")) { 1285 /* 1286 * origin has not been sent yet; 1287 * skip this clone. 1288 */ 1289 needagain = B_TRUE; 1290 continue; 1291 } 1292 } 1293 1294 zhp = zfs_open(rzhp->zfs_hdl, fsname, ZFS_TYPE_DATASET); 1295 if (zhp == NULL) 1296 return (-1); 1297 err = dump_filesystem(zhp, sdd); 1298 VERIFY(nvlist_add_boolean(fslist, "sent") == 0); 1299 progress = B_TRUE; 1300 zfs_close(zhp); 1301 if (err) 1302 return (err); 1303 } 1304 if (needagain) { 1305 assert(progress); 1306 goto again; 1307 } 1308 1309 /* clean out the sent flags in case we reuse this fss */ 1310 for (fspair = nvlist_next_nvpair(sdd->fss, NULL); fspair; 1311 fspair = nvlist_next_nvpair(sdd->fss, fspair)) { 1312 nvlist_t *fslist; 1313 1314 VERIFY(nvpair_value_nvlist(fspair, &fslist) == 0); 1315 (void) nvlist_remove_all(fslist, "sent"); 1316 } 1317 1318 return (0); 1319 } 1320 1321 /* 1322 * Generate a send stream for the dataset identified by the argument zhp. 1323 * 1324 * The content of the send stream is the snapshot identified by 1325 * 'tosnap'. Incremental streams are requested in two ways: 1326 * - from the snapshot identified by "fromsnap" (if non-null) or 1327 * - from the origin of the dataset identified by zhp, which must 1328 * be a clone. In this case, "fromsnap" is null and "fromorigin" 1329 * is TRUE. 1330 * 1331 * The send stream is recursive (i.e. dumps a hierarchy of snapshots) and 1332 * uses a special header (with a hdrtype field of DMU_COMPOUNDSTREAM) 1333 * if "replicate" is set. If "doall" is set, dump all the intermediate 1334 * snapshots. The DMU_COMPOUNDSTREAM header is used in the "doall" 1335 * case too. If "props" is set, send properties. 1336 */ 1337 int 1338 zfs_send(zfs_handle_t *zhp, const char *fromsnap, const char *tosnap, 1339 sendflags_t *flags, int outfd, snapfilter_cb_t filter_func, 1340 void *cb_arg, nvlist_t **debugnvp) 1341 { 1342 char errbuf[1024]; 1343 send_dump_data_t sdd = { 0 }; 1344 int err = 0; 1345 nvlist_t *fss = NULL; 1346 avl_tree_t *fsavl = NULL; 1347 static uint64_t holdseq; 1348 int spa_version; 1349 pthread_t tid; 1350 int pipefd[2]; 1351 dedup_arg_t dda = { 0 }; 1352 int featureflags = 0; 1353 1354 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1355 "cannot send '%s'"), zhp->zfs_name); 1356 1357 if (fromsnap && fromsnap[0] == '\0') { 1358 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1359 "zero-length incremental source")); 1360 return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf)); 1361 } 1362 1363 if (zhp->zfs_type == ZFS_TYPE_FILESYSTEM) { 1364 uint64_t version; 1365 version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION); 1366 if (version >= ZPL_VERSION_SA) { 1367 featureflags |= DMU_BACKUP_FEATURE_SA_SPILL; 1368 } 1369 } 1370 1371 if (flags->dedup && !flags->dryrun) { 1372 featureflags |= (DMU_BACKUP_FEATURE_DEDUP | 1373 DMU_BACKUP_FEATURE_DEDUPPROPS); 1374 if (err = pipe(pipefd)) { 1375 zfs_error_aux(zhp->zfs_hdl, strerror(errno)); 1376 return (zfs_error(zhp->zfs_hdl, EZFS_PIPEFAILED, 1377 errbuf)); 1378 } 1379 dda.outputfd = outfd; 1380 dda.inputfd = pipefd[1]; 1381 dda.dedup_hdl = zhp->zfs_hdl; 1382 if (err = pthread_create(&tid, NULL, cksummer, &dda)) { 1383 (void) close(pipefd[0]); 1384 (void) close(pipefd[1]); 1385 zfs_error_aux(zhp->zfs_hdl, strerror(errno)); 1386 return (zfs_error(zhp->zfs_hdl, 1387 EZFS_THREADCREATEFAILED, errbuf)); 1388 } 1389 } 1390 1391 if (flags->replicate || flags->doall || flags->props) { 1392 dmu_replay_record_t drr = { 0 }; 1393 char *packbuf = NULL; 1394 size_t buflen = 0; 1395 zio_cksum_t zc = { 0 }; 1396 1397 if (flags->replicate || flags->props) { 1398 nvlist_t *hdrnv; 1399 1400 VERIFY(0 == nvlist_alloc(&hdrnv, NV_UNIQUE_NAME, 0)); 1401 if (fromsnap) { 1402 VERIFY(0 == nvlist_add_string(hdrnv, 1403 "fromsnap", fromsnap)); 1404 } 1405 VERIFY(0 == nvlist_add_string(hdrnv, "tosnap", tosnap)); 1406 if (!flags->replicate) { 1407 VERIFY(0 == nvlist_add_boolean(hdrnv, 1408 "not_recursive")); 1409 } 1410 1411 err = gather_nvlist(zhp->zfs_hdl, zhp->zfs_name, 1412 fromsnap, tosnap, flags->replicate, &fss, &fsavl); 1413 if (err) 1414 goto err_out; 1415 VERIFY(0 == nvlist_add_nvlist(hdrnv, "fss", fss)); 1416 err = nvlist_pack(hdrnv, &packbuf, &buflen, 1417 NV_ENCODE_XDR, 0); 1418 if (debugnvp) 1419 *debugnvp = hdrnv; 1420 else 1421 nvlist_free(hdrnv); 1422 if (err) { 1423 fsavl_destroy(fsavl); 1424 nvlist_free(fss); 1425 goto stderr_out; 1426 } 1427 } 1428 1429 if (!flags->dryrun) { 1430 /* write first begin record */ 1431 drr.drr_type = DRR_BEGIN; 1432 drr.drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 1433 DMU_SET_STREAM_HDRTYPE(drr.drr_u.drr_begin. 1434 drr_versioninfo, DMU_COMPOUNDSTREAM); 1435 DMU_SET_FEATUREFLAGS(drr.drr_u.drr_begin. 1436 drr_versioninfo, featureflags); 1437 (void) snprintf(drr.drr_u.drr_begin.drr_toname, 1438 sizeof (drr.drr_u.drr_begin.drr_toname), 1439 "%s@%s", zhp->zfs_name, tosnap); 1440 drr.drr_payloadlen = buflen; 1441 err = cksum_and_write(&drr, sizeof (drr), &zc, outfd); 1442 1443 /* write header nvlist */ 1444 if (err != -1 && packbuf != NULL) { 1445 err = cksum_and_write(packbuf, buflen, &zc, 1446 outfd); 1447 } 1448 free(packbuf); 1449 if (err == -1) { 1450 fsavl_destroy(fsavl); 1451 nvlist_free(fss); 1452 err = errno; 1453 goto stderr_out; 1454 } 1455 1456 /* write end record */ 1457 bzero(&drr, sizeof (drr)); 1458 drr.drr_type = DRR_END; 1459 drr.drr_u.drr_end.drr_checksum = zc; 1460 err = write(outfd, &drr, sizeof (drr)); 1461 if (err == -1) { 1462 fsavl_destroy(fsavl); 1463 nvlist_free(fss); 1464 err = errno; 1465 goto stderr_out; 1466 } 1467 1468 err = 0; 1469 } 1470 } 1471 1472 /* dump each stream */ 1473 sdd.fromsnap = fromsnap; 1474 sdd.tosnap = tosnap; 1475 if (flags->dedup) 1476 sdd.outfd = pipefd[0]; 1477 else 1478 sdd.outfd = outfd; 1479 sdd.replicate = flags->replicate; 1480 sdd.doall = flags->doall; 1481 sdd.fromorigin = flags->fromorigin; 1482 sdd.fss = fss; 1483 sdd.fsavl = fsavl; 1484 sdd.verbose = flags->verbose; 1485 sdd.parsable = flags->parsable; 1486 sdd.progress = flags->progress; 1487 sdd.dryrun = flags->dryrun; 1488 sdd.filter_cb = filter_func; 1489 sdd.filter_cb_arg = cb_arg; 1490 if (debugnvp) 1491 sdd.debugnv = *debugnvp; 1492 1493 /* 1494 * Some flags require that we place user holds on the datasets that are 1495 * being sent so they don't get destroyed during the send. We can skip 1496 * this step if the pool is imported read-only since the datasets cannot 1497 * be destroyed. 1498 */ 1499 if (!flags->dryrun && !zpool_get_prop_int(zfs_get_pool_handle(zhp), 1500 ZPOOL_PROP_READONLY, NULL) && 1501 zfs_spa_version(zhp, &spa_version) == 0 && 1502 spa_version >= SPA_VERSION_USERREFS && 1503 (flags->doall || flags->replicate)) { 1504 ++holdseq; 1505 (void) snprintf(sdd.holdtag, sizeof (sdd.holdtag), 1506 ".send-%d-%llu", getpid(), (u_longlong_t)holdseq); 1507 sdd.cleanup_fd = open(ZFS_DEV, O_RDWR|O_EXCL); 1508 if (sdd.cleanup_fd < 0) { 1509 err = errno; 1510 goto stderr_out; 1511 } 1512 sdd.snapholds = fnvlist_alloc(); 1513 } else { 1514 sdd.cleanup_fd = -1; 1515 sdd.snapholds = NULL; 1516 } 1517 if (flags->verbose) { 1518 /* 1519 * Do a verbose no-op dry run to get all the verbose output 1520 * before generating any data. Then do a non-verbose real 1521 * run to generate the streams. 1522 */ 1523 sdd.dryrun = B_TRUE; 1524 err = dump_filesystems(zhp, &sdd); 1525 sdd.dryrun = flags->dryrun; 1526 sdd.verbose = B_FALSE; 1527 if (flags->parsable) { 1528 (void) fprintf(stderr, "size\t%llu\n", 1529 (longlong_t)sdd.size); 1530 } else { 1531 char buf[16]; 1532 zfs_nicenum(sdd.size, buf, sizeof (buf)); 1533 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 1534 "total estimated size is %s\n"), buf); 1535 } 1536 } 1537 1538 if (sdd.snapholds != NULL) { 1539 /* Holds are required. */ 1540 if (!flags->verbose) { 1541 /* 1542 * A verbose dry run wasn't done so do a non-verbose 1543 * dry run to gather snapshot hold's. 1544 */ 1545 sdd.dryrun = B_TRUE; 1546 err = dump_filesystems(zhp, &sdd); 1547 sdd.dryrun = flags->dryrun; 1548 } 1549 1550 if (err != 0) { 1551 fnvlist_free(sdd.snapholds); 1552 goto stderr_out; 1553 } 1554 1555 err = zfs_hold_nvl(zhp, sdd.cleanup_fd, sdd.snapholds); 1556 fnvlist_free(sdd.snapholds); 1557 if (err != 0) 1558 goto stderr_out; 1559 } 1560 1561 err = dump_filesystems(zhp, &sdd); 1562 fsavl_destroy(fsavl); 1563 nvlist_free(fss); 1564 1565 if (flags->dedup) { 1566 (void) close(pipefd[0]); 1567 (void) pthread_join(tid, NULL); 1568 } 1569 1570 if (sdd.cleanup_fd != -1) { 1571 VERIFY(0 == close(sdd.cleanup_fd)); 1572 sdd.cleanup_fd = -1; 1573 } 1574 1575 if (!flags->dryrun && (flags->replicate || flags->doall || 1576 flags->props)) { 1577 /* 1578 * write final end record. NB: want to do this even if 1579 * there was some error, because it might not be totally 1580 * failed. 1581 */ 1582 dmu_replay_record_t drr = { 0 }; 1583 drr.drr_type = DRR_END; 1584 if (write(outfd, &drr, sizeof (drr)) == -1) { 1585 return (zfs_standard_error(zhp->zfs_hdl, 1586 errno, errbuf)); 1587 } 1588 } 1589 1590 return (err || sdd.err); 1591 1592 stderr_out: 1593 err = zfs_standard_error(zhp->zfs_hdl, err, errbuf); 1594 err_out: 1595 if (sdd.cleanup_fd != -1) 1596 VERIFY(0 == close(sdd.cleanup_fd)); 1597 if (flags->dedup) { 1598 (void) pthread_cancel(tid); 1599 (void) pthread_join(tid, NULL); 1600 (void) close(pipefd[0]); 1601 } 1602 return (err); 1603 } 1604 1605 /* 1606 * Routines specific to "zfs recv" 1607 */ 1608 1609 static int 1610 recv_read(libzfs_handle_t *hdl, int fd, void *buf, int ilen, 1611 boolean_t byteswap, zio_cksum_t *zc) 1612 { 1613 char *cp = buf; 1614 int rv; 1615 int len = ilen; 1616 1617 do { 1618 rv = read(fd, cp, len); 1619 cp += rv; 1620 len -= rv; 1621 } while (rv > 0); 1622 1623 if (rv < 0 || len != 0) { 1624 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1625 "failed to read from stream")); 1626 return (zfs_error(hdl, EZFS_BADSTREAM, dgettext(TEXT_DOMAIN, 1627 "cannot receive"))); 1628 } 1629 1630 if (zc) { 1631 if (byteswap) 1632 fletcher_4_incremental_byteswap(buf, ilen, zc); 1633 else 1634 fletcher_4_incremental_native(buf, ilen, zc); 1635 } 1636 return (0); 1637 } 1638 1639 static int 1640 recv_read_nvlist(libzfs_handle_t *hdl, int fd, int len, nvlist_t **nvp, 1641 boolean_t byteswap, zio_cksum_t *zc) 1642 { 1643 char *buf; 1644 int err; 1645 1646 buf = zfs_alloc(hdl, len); 1647 if (buf == NULL) 1648 return (ENOMEM); 1649 1650 err = recv_read(hdl, fd, buf, len, byteswap, zc); 1651 if (err != 0) { 1652 free(buf); 1653 return (err); 1654 } 1655 1656 err = nvlist_unpack(buf, len, nvp, 0); 1657 free(buf); 1658 if (err != 0) { 1659 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 1660 "stream (malformed nvlist)")); 1661 return (EINVAL); 1662 } 1663 return (0); 1664 } 1665 1666 static int 1667 recv_rename(libzfs_handle_t *hdl, const char *name, const char *tryname, 1668 int baselen, char *newname, recvflags_t *flags) 1669 { 1670 static int seq; 1671 zfs_cmd_t zc = { 0 }; 1672 int err; 1673 prop_changelist_t *clp; 1674 zfs_handle_t *zhp; 1675 1676 zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET); 1677 if (zhp == NULL) 1678 return (-1); 1679 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0, 1680 flags->force ? MS_FORCE : 0); 1681 zfs_close(zhp); 1682 if (clp == NULL) 1683 return (-1); 1684 err = changelist_prefix(clp); 1685 if (err) 1686 return (err); 1687 1688 zc.zc_objset_type = DMU_OST_ZFS; 1689 (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name)); 1690 1691 if (tryname) { 1692 (void) strcpy(newname, tryname); 1693 1694 (void) strlcpy(zc.zc_value, tryname, sizeof (zc.zc_value)); 1695 1696 if (flags->verbose) { 1697 (void) printf("attempting rename %s to %s\n", 1698 zc.zc_name, zc.zc_value); 1699 } 1700 err = ioctl(hdl->libzfs_fd, ZFS_IOC_RENAME, &zc); 1701 if (err == 0) 1702 changelist_rename(clp, name, tryname); 1703 } else { 1704 err = ENOENT; 1705 } 1706 1707 if (err != 0 && strncmp(name + baselen, "recv-", 5) != 0) { 1708 seq++; 1709 1710 (void) snprintf(newname, ZFS_MAXNAMELEN, "%.*srecv-%u-%u", 1711 baselen, name, getpid(), seq); 1712 (void) strlcpy(zc.zc_value, newname, sizeof (zc.zc_value)); 1713 1714 if (flags->verbose) { 1715 (void) printf("failed - trying rename %s to %s\n", 1716 zc.zc_name, zc.zc_value); 1717 } 1718 err = ioctl(hdl->libzfs_fd, ZFS_IOC_RENAME, &zc); 1719 if (err == 0) 1720 changelist_rename(clp, name, newname); 1721 if (err && flags->verbose) { 1722 (void) printf("failed (%u) - " 1723 "will try again on next pass\n", errno); 1724 } 1725 err = EAGAIN; 1726 } else if (flags->verbose) { 1727 if (err == 0) 1728 (void) printf("success\n"); 1729 else 1730 (void) printf("failed (%u)\n", errno); 1731 } 1732 1733 (void) changelist_postfix(clp); 1734 changelist_free(clp); 1735 1736 return (err); 1737 } 1738 1739 static int 1740 recv_destroy(libzfs_handle_t *hdl, const char *name, int baselen, 1741 char *newname, recvflags_t *flags) 1742 { 1743 zfs_cmd_t zc = { 0 }; 1744 int err = 0; 1745 prop_changelist_t *clp; 1746 zfs_handle_t *zhp; 1747 boolean_t defer = B_FALSE; 1748 int spa_version; 1749 1750 zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET); 1751 if (zhp == NULL) 1752 return (-1); 1753 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0, 1754 flags->force ? MS_FORCE : 0); 1755 if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT && 1756 zfs_spa_version(zhp, &spa_version) == 0 && 1757 spa_version >= SPA_VERSION_USERREFS) 1758 defer = B_TRUE; 1759 zfs_close(zhp); 1760 if (clp == NULL) 1761 return (-1); 1762 err = changelist_prefix(clp); 1763 if (err) 1764 return (err); 1765 1766 zc.zc_objset_type = DMU_OST_ZFS; 1767 zc.zc_defer_destroy = defer; 1768 (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name)); 1769 1770 if (flags->verbose) 1771 (void) printf("attempting destroy %s\n", zc.zc_name); 1772 err = ioctl(hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc); 1773 if (err == 0) { 1774 if (flags->verbose) 1775 (void) printf("success\n"); 1776 changelist_remove(clp, zc.zc_name); 1777 } 1778 1779 (void) changelist_postfix(clp); 1780 changelist_free(clp); 1781 1782 /* 1783 * Deferred destroy might destroy the snapshot or only mark it to be 1784 * destroyed later, and it returns success in either case. 1785 */ 1786 if (err != 0 || (defer && zfs_dataset_exists(hdl, name, 1787 ZFS_TYPE_SNAPSHOT))) { 1788 err = recv_rename(hdl, name, NULL, baselen, newname, flags); 1789 } 1790 1791 return (err); 1792 } 1793 1794 typedef struct guid_to_name_data { 1795 uint64_t guid; 1796 char *name; 1797 char *skip; 1798 } guid_to_name_data_t; 1799 1800 static int 1801 guid_to_name_cb(zfs_handle_t *zhp, void *arg) 1802 { 1803 guid_to_name_data_t *gtnd = arg; 1804 int err; 1805 1806 if (gtnd->skip != NULL && 1807 strcmp(zhp->zfs_name, gtnd->skip) == 0) { 1808 return (0); 1809 } 1810 1811 if (zhp->zfs_dmustats.dds_guid == gtnd->guid) { 1812 (void) strcpy(gtnd->name, zhp->zfs_name); 1813 zfs_close(zhp); 1814 return (EEXIST); 1815 } 1816 1817 err = zfs_iter_children(zhp, guid_to_name_cb, gtnd); 1818 zfs_close(zhp); 1819 return (err); 1820 } 1821 1822 /* 1823 * Attempt to find the local dataset associated with this guid. In the case of 1824 * multiple matches, we attempt to find the "best" match by searching 1825 * progressively larger portions of the hierarchy. This allows one to send a 1826 * tree of datasets individually and guarantee that we will find the source 1827 * guid within that hierarchy, even if there are multiple matches elsewhere. 1828 */ 1829 static int 1830 guid_to_name(libzfs_handle_t *hdl, const char *parent, uint64_t guid, 1831 char *name) 1832 { 1833 /* exhaustive search all local snapshots */ 1834 char pname[ZFS_MAXNAMELEN]; 1835 guid_to_name_data_t gtnd; 1836 int err = 0; 1837 zfs_handle_t *zhp; 1838 char *cp; 1839 1840 gtnd.guid = guid; 1841 gtnd.name = name; 1842 gtnd.skip = NULL; 1843 1844 (void) strlcpy(pname, parent, sizeof (pname)); 1845 1846 /* 1847 * Search progressively larger portions of the hierarchy. This will 1848 * select the "most local" version of the origin snapshot in the case 1849 * that there are multiple matching snapshots in the system. 1850 */ 1851 while ((cp = strrchr(pname, '/')) != NULL) { 1852 1853 /* Chop off the last component and open the parent */ 1854 *cp = '\0'; 1855 zhp = make_dataset_handle(hdl, pname); 1856 1857 if (zhp == NULL) 1858 continue; 1859 1860 err = zfs_iter_children(zhp, guid_to_name_cb, >nd); 1861 zfs_close(zhp); 1862 if (err == EEXIST) 1863 return (0); 1864 1865 /* 1866 * Remember the dataset that we already searched, so we 1867 * skip it next time through. 1868 */ 1869 gtnd.skip = pname; 1870 } 1871 1872 return (ENOENT); 1873 } 1874 1875 /* 1876 * Return +1 if guid1 is before guid2, 0 if they are the same, and -1 if 1877 * guid1 is after guid2. 1878 */ 1879 static int 1880 created_before(libzfs_handle_t *hdl, avl_tree_t *avl, 1881 uint64_t guid1, uint64_t guid2) 1882 { 1883 nvlist_t *nvfs; 1884 char *fsname, *snapname; 1885 char buf[ZFS_MAXNAMELEN]; 1886 int rv; 1887 zfs_handle_t *guid1hdl, *guid2hdl; 1888 uint64_t create1, create2; 1889 1890 if (guid2 == 0) 1891 return (0); 1892 if (guid1 == 0) 1893 return (1); 1894 1895 nvfs = fsavl_find(avl, guid1, &snapname); 1896 VERIFY(0 == nvlist_lookup_string(nvfs, "name", &fsname)); 1897 (void) snprintf(buf, sizeof (buf), "%s@%s", fsname, snapname); 1898 guid1hdl = zfs_open(hdl, buf, ZFS_TYPE_SNAPSHOT); 1899 if (guid1hdl == NULL) 1900 return (-1); 1901 1902 nvfs = fsavl_find(avl, guid2, &snapname); 1903 VERIFY(0 == nvlist_lookup_string(nvfs, "name", &fsname)); 1904 (void) snprintf(buf, sizeof (buf), "%s@%s", fsname, snapname); 1905 guid2hdl = zfs_open(hdl, buf, ZFS_TYPE_SNAPSHOT); 1906 if (guid2hdl == NULL) { 1907 zfs_close(guid1hdl); 1908 return (-1); 1909 } 1910 1911 create1 = zfs_prop_get_int(guid1hdl, ZFS_PROP_CREATETXG); 1912 create2 = zfs_prop_get_int(guid2hdl, ZFS_PROP_CREATETXG); 1913 1914 if (create1 < create2) 1915 rv = -1; 1916 else if (create1 > create2) 1917 rv = +1; 1918 else 1919 rv = 0; 1920 1921 zfs_close(guid1hdl); 1922 zfs_close(guid2hdl); 1923 1924 return (rv); 1925 } 1926 1927 static int 1928 recv_incremental_replication(libzfs_handle_t *hdl, const char *tofs, 1929 recvflags_t *flags, nvlist_t *stream_nv, avl_tree_t *stream_avl, 1930 nvlist_t *renamed) 1931 { 1932 nvlist_t *local_nv; 1933 avl_tree_t *local_avl; 1934 nvpair_t *fselem, *nextfselem; 1935 char *fromsnap; 1936 char newname[ZFS_MAXNAMELEN]; 1937 int error; 1938 boolean_t needagain, progress, recursive; 1939 char *s1, *s2; 1940 1941 VERIFY(0 == nvlist_lookup_string(stream_nv, "fromsnap", &fromsnap)); 1942 1943 recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") == 1944 ENOENT); 1945 1946 if (flags->dryrun) 1947 return (0); 1948 1949 again: 1950 needagain = progress = B_FALSE; 1951 1952 if ((error = gather_nvlist(hdl, tofs, fromsnap, NULL, 1953 recursive, &local_nv, &local_avl)) != 0) 1954 return (error); 1955 1956 /* 1957 * Process deletes and renames 1958 */ 1959 for (fselem = nvlist_next_nvpair(local_nv, NULL); 1960 fselem; fselem = nextfselem) { 1961 nvlist_t *nvfs, *snaps; 1962 nvlist_t *stream_nvfs = NULL; 1963 nvpair_t *snapelem, *nextsnapelem; 1964 uint64_t fromguid = 0; 1965 uint64_t originguid = 0; 1966 uint64_t stream_originguid = 0; 1967 uint64_t parent_fromsnap_guid, stream_parent_fromsnap_guid; 1968 char *fsname, *stream_fsname; 1969 1970 nextfselem = nvlist_next_nvpair(local_nv, fselem); 1971 1972 VERIFY(0 == nvpair_value_nvlist(fselem, &nvfs)); 1973 VERIFY(0 == nvlist_lookup_nvlist(nvfs, "snaps", &snaps)); 1974 VERIFY(0 == nvlist_lookup_string(nvfs, "name", &fsname)); 1975 VERIFY(0 == nvlist_lookup_uint64(nvfs, "parentfromsnap", 1976 &parent_fromsnap_guid)); 1977 (void) nvlist_lookup_uint64(nvfs, "origin", &originguid); 1978 1979 /* 1980 * First find the stream's fs, so we can check for 1981 * a different origin (due to "zfs promote") 1982 */ 1983 for (snapelem = nvlist_next_nvpair(snaps, NULL); 1984 snapelem; snapelem = nvlist_next_nvpair(snaps, snapelem)) { 1985 uint64_t thisguid; 1986 1987 VERIFY(0 == nvpair_value_uint64(snapelem, &thisguid)); 1988 stream_nvfs = fsavl_find(stream_avl, thisguid, NULL); 1989 1990 if (stream_nvfs != NULL) 1991 break; 1992 } 1993 1994 /* check for promote */ 1995 (void) nvlist_lookup_uint64(stream_nvfs, "origin", 1996 &stream_originguid); 1997 if (stream_nvfs && originguid != stream_originguid) { 1998 switch (created_before(hdl, local_avl, 1999 stream_originguid, originguid)) { 2000 case 1: { 2001 /* promote it! */ 2002 zfs_cmd_t zc = { 0 }; 2003 nvlist_t *origin_nvfs; 2004 char *origin_fsname; 2005 2006 if (flags->verbose) 2007 (void) printf("promoting %s\n", fsname); 2008 2009 origin_nvfs = fsavl_find(local_avl, originguid, 2010 NULL); 2011 VERIFY(0 == nvlist_lookup_string(origin_nvfs, 2012 "name", &origin_fsname)); 2013 (void) strlcpy(zc.zc_value, origin_fsname, 2014 sizeof (zc.zc_value)); 2015 (void) strlcpy(zc.zc_name, fsname, 2016 sizeof (zc.zc_name)); 2017 error = zfs_ioctl(hdl, ZFS_IOC_PROMOTE, &zc); 2018 if (error == 0) 2019 progress = B_TRUE; 2020 break; 2021 } 2022 default: 2023 break; 2024 case -1: 2025 fsavl_destroy(local_avl); 2026 nvlist_free(local_nv); 2027 return (-1); 2028 } 2029 /* 2030 * We had/have the wrong origin, therefore our 2031 * list of snapshots is wrong. Need to handle 2032 * them on the next pass. 2033 */ 2034 needagain = B_TRUE; 2035 continue; 2036 } 2037 2038 for (snapelem = nvlist_next_nvpair(snaps, NULL); 2039 snapelem; snapelem = nextsnapelem) { 2040 uint64_t thisguid; 2041 char *stream_snapname; 2042 nvlist_t *found, *props; 2043 2044 nextsnapelem = nvlist_next_nvpair(snaps, snapelem); 2045 2046 VERIFY(0 == nvpair_value_uint64(snapelem, &thisguid)); 2047 found = fsavl_find(stream_avl, thisguid, 2048 &stream_snapname); 2049 2050 /* check for delete */ 2051 if (found == NULL) { 2052 char name[ZFS_MAXNAMELEN]; 2053 2054 if (!flags->force) 2055 continue; 2056 2057 (void) snprintf(name, sizeof (name), "%s@%s", 2058 fsname, nvpair_name(snapelem)); 2059 2060 error = recv_destroy(hdl, name, 2061 strlen(fsname)+1, newname, flags); 2062 if (error) 2063 needagain = B_TRUE; 2064 else 2065 progress = B_TRUE; 2066 continue; 2067 } 2068 2069 stream_nvfs = found; 2070 2071 if (0 == nvlist_lookup_nvlist(stream_nvfs, "snapprops", 2072 &props) && 0 == nvlist_lookup_nvlist(props, 2073 stream_snapname, &props)) { 2074 zfs_cmd_t zc = { 0 }; 2075 2076 zc.zc_cookie = B_TRUE; /* received */ 2077 (void) snprintf(zc.zc_name, sizeof (zc.zc_name), 2078 "%s@%s", fsname, nvpair_name(snapelem)); 2079 if (zcmd_write_src_nvlist(hdl, &zc, 2080 props) == 0) { 2081 (void) zfs_ioctl(hdl, 2082 ZFS_IOC_SET_PROP, &zc); 2083 zcmd_free_nvlists(&zc); 2084 } 2085 } 2086 2087 /* check for different snapname */ 2088 if (strcmp(nvpair_name(snapelem), 2089 stream_snapname) != 0) { 2090 char name[ZFS_MAXNAMELEN]; 2091 char tryname[ZFS_MAXNAMELEN]; 2092 2093 (void) snprintf(name, sizeof (name), "%s@%s", 2094 fsname, nvpair_name(snapelem)); 2095 (void) snprintf(tryname, sizeof (name), "%s@%s", 2096 fsname, stream_snapname); 2097 2098 error = recv_rename(hdl, name, tryname, 2099 strlen(fsname)+1, newname, flags); 2100 if (error) 2101 needagain = B_TRUE; 2102 else 2103 progress = B_TRUE; 2104 } 2105 2106 if (strcmp(stream_snapname, fromsnap) == 0) 2107 fromguid = thisguid; 2108 } 2109 2110 /* check for delete */ 2111 if (stream_nvfs == NULL) { 2112 if (!flags->force) 2113 continue; 2114 2115 error = recv_destroy(hdl, fsname, strlen(tofs)+1, 2116 newname, flags); 2117 if (error) 2118 needagain = B_TRUE; 2119 else 2120 progress = B_TRUE; 2121 continue; 2122 } 2123 2124 if (fromguid == 0) { 2125 if (flags->verbose) { 2126 (void) printf("local fs %s does not have " 2127 "fromsnap (%s in stream); must have " 2128 "been deleted locally; ignoring\n", 2129 fsname, fromsnap); 2130 } 2131 continue; 2132 } 2133 2134 VERIFY(0 == nvlist_lookup_string(stream_nvfs, 2135 "name", &stream_fsname)); 2136 VERIFY(0 == nvlist_lookup_uint64(stream_nvfs, 2137 "parentfromsnap", &stream_parent_fromsnap_guid)); 2138 2139 s1 = strrchr(fsname, '/'); 2140 s2 = strrchr(stream_fsname, '/'); 2141 2142 /* 2143 * Check for rename. If the exact receive path is specified, it 2144 * does not count as a rename, but we still need to check the 2145 * datasets beneath it. 2146 */ 2147 if ((stream_parent_fromsnap_guid != 0 && 2148 parent_fromsnap_guid != 0 && 2149 stream_parent_fromsnap_guid != parent_fromsnap_guid) || 2150 ((flags->isprefix || strcmp(tofs, fsname) != 0) && 2151 (s1 != NULL) && (s2 != NULL) && strcmp(s1, s2) != 0)) { 2152 nvlist_t *parent; 2153 char tryname[ZFS_MAXNAMELEN]; 2154 2155 parent = fsavl_find(local_avl, 2156 stream_parent_fromsnap_guid, NULL); 2157 /* 2158 * NB: parent might not be found if we used the 2159 * tosnap for stream_parent_fromsnap_guid, 2160 * because the parent is a newly-created fs; 2161 * we'll be able to rename it after we recv the 2162 * new fs. 2163 */ 2164 if (parent != NULL) { 2165 char *pname; 2166 2167 VERIFY(0 == nvlist_lookup_string(parent, "name", 2168 &pname)); 2169 (void) snprintf(tryname, sizeof (tryname), 2170 "%s%s", pname, strrchr(stream_fsname, '/')); 2171 } else { 2172 tryname[0] = '\0'; 2173 if (flags->verbose) { 2174 (void) printf("local fs %s new parent " 2175 "not found\n", fsname); 2176 } 2177 } 2178 2179 newname[0] = '\0'; 2180 2181 error = recv_rename(hdl, fsname, tryname, 2182 strlen(tofs)+1, newname, flags); 2183 2184 if (renamed != NULL && newname[0] != '\0') { 2185 VERIFY(0 == nvlist_add_boolean(renamed, 2186 newname)); 2187 } 2188 2189 if (error) 2190 needagain = B_TRUE; 2191 else 2192 progress = B_TRUE; 2193 } 2194 } 2195 2196 fsavl_destroy(local_avl); 2197 nvlist_free(local_nv); 2198 2199 if (needagain && progress) { 2200 /* do another pass to fix up temporary names */ 2201 if (flags->verbose) 2202 (void) printf("another pass:\n"); 2203 goto again; 2204 } 2205 2206 return (needagain); 2207 } 2208 2209 static int 2210 zfs_receive_package(libzfs_handle_t *hdl, int fd, const char *destname, 2211 recvflags_t *flags, dmu_replay_record_t *drr, zio_cksum_t *zc, 2212 char **top_zfs, int cleanup_fd, uint64_t *action_handlep) 2213 { 2214 nvlist_t *stream_nv = NULL; 2215 avl_tree_t *stream_avl = NULL; 2216 char *fromsnap = NULL; 2217 char *cp; 2218 char tofs[ZFS_MAXNAMELEN]; 2219 char sendfs[ZFS_MAXNAMELEN]; 2220 char errbuf[1024]; 2221 dmu_replay_record_t drre; 2222 int error; 2223 boolean_t anyerr = B_FALSE; 2224 boolean_t softerr = B_FALSE; 2225 boolean_t recursive; 2226 2227 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2228 "cannot receive")); 2229 2230 assert(drr->drr_type == DRR_BEGIN); 2231 assert(drr->drr_u.drr_begin.drr_magic == DMU_BACKUP_MAGIC); 2232 assert(DMU_GET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo) == 2233 DMU_COMPOUNDSTREAM); 2234 2235 /* 2236 * Read in the nvlist from the stream. 2237 */ 2238 if (drr->drr_payloadlen != 0) { 2239 error = recv_read_nvlist(hdl, fd, drr->drr_payloadlen, 2240 &stream_nv, flags->byteswap, zc); 2241 if (error) { 2242 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2243 goto out; 2244 } 2245 } 2246 2247 recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") == 2248 ENOENT); 2249 2250 if (recursive && strchr(destname, '@')) { 2251 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2252 "cannot specify snapshot name for multi-snapshot stream")); 2253 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2254 goto out; 2255 } 2256 2257 /* 2258 * Read in the end record and verify checksum. 2259 */ 2260 if (0 != (error = recv_read(hdl, fd, &drre, sizeof (drre), 2261 flags->byteswap, NULL))) 2262 goto out; 2263 if (flags->byteswap) { 2264 drre.drr_type = BSWAP_32(drre.drr_type); 2265 drre.drr_u.drr_end.drr_checksum.zc_word[0] = 2266 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[0]); 2267 drre.drr_u.drr_end.drr_checksum.zc_word[1] = 2268 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[1]); 2269 drre.drr_u.drr_end.drr_checksum.zc_word[2] = 2270 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[2]); 2271 drre.drr_u.drr_end.drr_checksum.zc_word[3] = 2272 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[3]); 2273 } 2274 if (drre.drr_type != DRR_END) { 2275 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2276 goto out; 2277 } 2278 if (!ZIO_CHECKSUM_EQUAL(drre.drr_u.drr_end.drr_checksum, *zc)) { 2279 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2280 "incorrect header checksum")); 2281 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2282 goto out; 2283 } 2284 2285 (void) nvlist_lookup_string(stream_nv, "fromsnap", &fromsnap); 2286 2287 if (drr->drr_payloadlen != 0) { 2288 nvlist_t *stream_fss; 2289 2290 VERIFY(0 == nvlist_lookup_nvlist(stream_nv, "fss", 2291 &stream_fss)); 2292 if ((stream_avl = fsavl_create(stream_fss)) == NULL) { 2293 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2294 "couldn't allocate avl tree")); 2295 error = zfs_error(hdl, EZFS_NOMEM, errbuf); 2296 goto out; 2297 } 2298 2299 if (fromsnap != NULL) { 2300 nvlist_t *renamed = NULL; 2301 nvpair_t *pair = NULL; 2302 2303 (void) strlcpy(tofs, destname, ZFS_MAXNAMELEN); 2304 if (flags->isprefix) { 2305 struct drr_begin *drrb = &drr->drr_u.drr_begin; 2306 int i; 2307 2308 if (flags->istail) { 2309 cp = strrchr(drrb->drr_toname, '/'); 2310 if (cp == NULL) { 2311 (void) strlcat(tofs, "/", 2312 ZFS_MAXNAMELEN); 2313 i = 0; 2314 } else { 2315 i = (cp - drrb->drr_toname); 2316 } 2317 } else { 2318 i = strcspn(drrb->drr_toname, "/@"); 2319 } 2320 /* zfs_receive_one() will create_parents() */ 2321 (void) strlcat(tofs, &drrb->drr_toname[i], 2322 ZFS_MAXNAMELEN); 2323 *strchr(tofs, '@') = '\0'; 2324 } 2325 2326 if (recursive && !flags->dryrun && !flags->nomount) { 2327 VERIFY(0 == nvlist_alloc(&renamed, 2328 NV_UNIQUE_NAME, 0)); 2329 } 2330 2331 softerr = recv_incremental_replication(hdl, tofs, flags, 2332 stream_nv, stream_avl, renamed); 2333 2334 /* Unmount renamed filesystems before receiving. */ 2335 while ((pair = nvlist_next_nvpair(renamed, 2336 pair)) != NULL) { 2337 zfs_handle_t *zhp; 2338 prop_changelist_t *clp = NULL; 2339 2340 zhp = zfs_open(hdl, nvpair_name(pair), 2341 ZFS_TYPE_FILESYSTEM); 2342 if (zhp != NULL) { 2343 clp = changelist_gather(zhp, 2344 ZFS_PROP_MOUNTPOINT, 0, 0); 2345 zfs_close(zhp); 2346 if (clp != NULL) { 2347 softerr |= 2348 changelist_prefix(clp); 2349 changelist_free(clp); 2350 } 2351 } 2352 } 2353 2354 nvlist_free(renamed); 2355 } 2356 } 2357 2358 /* 2359 * Get the fs specified by the first path in the stream (the top level 2360 * specified by 'zfs send') and pass it to each invocation of 2361 * zfs_receive_one(). 2362 */ 2363 (void) strlcpy(sendfs, drr->drr_u.drr_begin.drr_toname, 2364 ZFS_MAXNAMELEN); 2365 if ((cp = strchr(sendfs, '@')) != NULL) 2366 *cp = '\0'; 2367 2368 /* Finally, receive each contained stream */ 2369 do { 2370 /* 2371 * we should figure out if it has a recoverable 2372 * error, in which case do a recv_skip() and drive on. 2373 * Note, if we fail due to already having this guid, 2374 * zfs_receive_one() will take care of it (ie, 2375 * recv_skip() and return 0). 2376 */ 2377 error = zfs_receive_impl(hdl, destname, flags, fd, 2378 sendfs, stream_nv, stream_avl, top_zfs, cleanup_fd, 2379 action_handlep); 2380 if (error == ENODATA) { 2381 error = 0; 2382 break; 2383 } 2384 anyerr |= error; 2385 } while (error == 0); 2386 2387 if (drr->drr_payloadlen != 0 && fromsnap != NULL) { 2388 /* 2389 * Now that we have the fs's they sent us, try the 2390 * renames again. 2391 */ 2392 softerr = recv_incremental_replication(hdl, tofs, flags, 2393 stream_nv, stream_avl, NULL); 2394 } 2395 2396 out: 2397 fsavl_destroy(stream_avl); 2398 if (stream_nv) 2399 nvlist_free(stream_nv); 2400 if (softerr) 2401 error = -2; 2402 if (anyerr) 2403 error = -1; 2404 return (error); 2405 } 2406 2407 static void 2408 trunc_prop_errs(int truncated) 2409 { 2410 ASSERT(truncated != 0); 2411 2412 if (truncated == 1) 2413 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 2414 "1 more property could not be set\n")); 2415 else 2416 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, 2417 "%d more properties could not be set\n"), truncated); 2418 } 2419 2420 static int 2421 recv_skip(libzfs_handle_t *hdl, int fd, boolean_t byteswap) 2422 { 2423 dmu_replay_record_t *drr; 2424 void *buf = malloc(1<<20); 2425 char errbuf[1024]; 2426 2427 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2428 "cannot receive:")); 2429 2430 /* XXX would be great to use lseek if possible... */ 2431 drr = buf; 2432 2433 while (recv_read(hdl, fd, drr, sizeof (dmu_replay_record_t), 2434 byteswap, NULL) == 0) { 2435 if (byteswap) 2436 drr->drr_type = BSWAP_32(drr->drr_type); 2437 2438 switch (drr->drr_type) { 2439 case DRR_BEGIN: 2440 /* NB: not to be used on v2 stream packages */ 2441 if (drr->drr_payloadlen != 0) { 2442 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2443 "invalid substream header")); 2444 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 2445 } 2446 break; 2447 2448 case DRR_END: 2449 free(buf); 2450 return (0); 2451 2452 case DRR_OBJECT: 2453 if (byteswap) { 2454 drr->drr_u.drr_object.drr_bonuslen = 2455 BSWAP_32(drr->drr_u.drr_object. 2456 drr_bonuslen); 2457 } 2458 (void) recv_read(hdl, fd, buf, 2459 P2ROUNDUP(drr->drr_u.drr_object.drr_bonuslen, 8), 2460 B_FALSE, NULL); 2461 break; 2462 2463 case DRR_WRITE: 2464 if (byteswap) { 2465 drr->drr_u.drr_write.drr_length = 2466 BSWAP_64(drr->drr_u.drr_write.drr_length); 2467 } 2468 (void) recv_read(hdl, fd, buf, 2469 drr->drr_u.drr_write.drr_length, B_FALSE, NULL); 2470 break; 2471 case DRR_SPILL: 2472 if (byteswap) { 2473 drr->drr_u.drr_write.drr_length = 2474 BSWAP_64(drr->drr_u.drr_spill.drr_length); 2475 } 2476 (void) recv_read(hdl, fd, buf, 2477 drr->drr_u.drr_spill.drr_length, B_FALSE, NULL); 2478 break; 2479 case DRR_WRITE_BYREF: 2480 case DRR_FREEOBJECTS: 2481 case DRR_FREE: 2482 break; 2483 2484 default: 2485 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2486 "invalid record type")); 2487 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 2488 } 2489 } 2490 2491 free(buf); 2492 return (-1); 2493 } 2494 2495 /* 2496 * Restores a backup of tosnap from the file descriptor specified by infd. 2497 */ 2498 static int 2499 zfs_receive_one(libzfs_handle_t *hdl, int infd, const char *tosnap, 2500 recvflags_t *flags, dmu_replay_record_t *drr, 2501 dmu_replay_record_t *drr_noswap, const char *sendfs, 2502 nvlist_t *stream_nv, avl_tree_t *stream_avl, char **top_zfs, int cleanup_fd, 2503 uint64_t *action_handlep) 2504 { 2505 zfs_cmd_t zc = { 0 }; 2506 time_t begin_time; 2507 int ioctl_err, ioctl_errno, err; 2508 char *cp; 2509 struct drr_begin *drrb = &drr->drr_u.drr_begin; 2510 char errbuf[1024]; 2511 char prop_errbuf[1024]; 2512 const char *chopprefix; 2513 boolean_t newfs = B_FALSE; 2514 boolean_t stream_wantsnewfs; 2515 uint64_t parent_snapguid = 0; 2516 prop_changelist_t *clp = NULL; 2517 nvlist_t *snapprops_nvlist = NULL; 2518 zprop_errflags_t prop_errflags; 2519 boolean_t recursive; 2520 2521 begin_time = time(NULL); 2522 2523 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2524 "cannot receive")); 2525 2526 recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") == 2527 ENOENT); 2528 2529 if (stream_avl != NULL) { 2530 char *snapname; 2531 nvlist_t *fs = fsavl_find(stream_avl, drrb->drr_toguid, 2532 &snapname); 2533 nvlist_t *props; 2534 int ret; 2535 2536 (void) nvlist_lookup_uint64(fs, "parentfromsnap", 2537 &parent_snapguid); 2538 err = nvlist_lookup_nvlist(fs, "props", &props); 2539 if (err) 2540 VERIFY(0 == nvlist_alloc(&props, NV_UNIQUE_NAME, 0)); 2541 2542 if (flags->canmountoff) { 2543 VERIFY(0 == nvlist_add_uint64(props, 2544 zfs_prop_to_name(ZFS_PROP_CANMOUNT), 0)); 2545 } 2546 ret = zcmd_write_src_nvlist(hdl, &zc, props); 2547 if (err) 2548 nvlist_free(props); 2549 2550 if (0 == nvlist_lookup_nvlist(fs, "snapprops", &props)) { 2551 VERIFY(0 == nvlist_lookup_nvlist(props, 2552 snapname, &snapprops_nvlist)); 2553 } 2554 2555 if (ret != 0) 2556 return (-1); 2557 } 2558 2559 cp = NULL; 2560 2561 /* 2562 * Determine how much of the snapshot name stored in the stream 2563 * we are going to tack on to the name they specified on the 2564 * command line, and how much we are going to chop off. 2565 * 2566 * If they specified a snapshot, chop the entire name stored in 2567 * the stream. 2568 */ 2569 if (flags->istail) { 2570 /* 2571 * A filesystem was specified with -e. We want to tack on only 2572 * the tail of the sent snapshot path. 2573 */ 2574 if (strchr(tosnap, '@')) { 2575 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 2576 "argument - snapshot not allowed with -e")); 2577 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2578 } 2579 2580 chopprefix = strrchr(sendfs, '/'); 2581 2582 if (chopprefix == NULL) { 2583 /* 2584 * The tail is the poolname, so we need to 2585 * prepend a path separator. 2586 */ 2587 int len = strlen(drrb->drr_toname); 2588 cp = malloc(len + 2); 2589 cp[0] = '/'; 2590 (void) strcpy(&cp[1], drrb->drr_toname); 2591 chopprefix = cp; 2592 } else { 2593 chopprefix = drrb->drr_toname + (chopprefix - sendfs); 2594 } 2595 } else if (flags->isprefix) { 2596 /* 2597 * A filesystem was specified with -d. We want to tack on 2598 * everything but the first element of the sent snapshot path 2599 * (all but the pool name). 2600 */ 2601 if (strchr(tosnap, '@')) { 2602 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 2603 "argument - snapshot not allowed with -d")); 2604 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2605 } 2606 2607 chopprefix = strchr(drrb->drr_toname, '/'); 2608 if (chopprefix == NULL) 2609 chopprefix = strchr(drrb->drr_toname, '@'); 2610 } else if (strchr(tosnap, '@') == NULL) { 2611 /* 2612 * If a filesystem was specified without -d or -e, we want to 2613 * tack on everything after the fs specified by 'zfs send'. 2614 */ 2615 chopprefix = drrb->drr_toname + strlen(sendfs); 2616 } else { 2617 /* A snapshot was specified as an exact path (no -d or -e). */ 2618 if (recursive) { 2619 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2620 "cannot specify snapshot name for multi-snapshot " 2621 "stream")); 2622 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 2623 } 2624 chopprefix = drrb->drr_toname + strlen(drrb->drr_toname); 2625 } 2626 2627 ASSERT(strstr(drrb->drr_toname, sendfs) == drrb->drr_toname); 2628 ASSERT(chopprefix > drrb->drr_toname); 2629 ASSERT(chopprefix <= drrb->drr_toname + strlen(drrb->drr_toname)); 2630 ASSERT(chopprefix[0] == '/' || chopprefix[0] == '@' || 2631 chopprefix[0] == '\0'); 2632 2633 /* 2634 * Determine name of destination snapshot, store in zc_value. 2635 */ 2636 (void) strcpy(zc.zc_value, tosnap); 2637 (void) strncat(zc.zc_value, chopprefix, sizeof (zc.zc_value)); 2638 free(cp); 2639 if (!zfs_name_valid(zc.zc_value, ZFS_TYPE_SNAPSHOT)) { 2640 zcmd_free_nvlists(&zc); 2641 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 2642 } 2643 2644 /* 2645 * Determine the name of the origin snapshot, store in zc_string. 2646 */ 2647 if (drrb->drr_flags & DRR_FLAG_CLONE) { 2648 if (guid_to_name(hdl, zc.zc_value, 2649 drrb->drr_fromguid, zc.zc_string) != 0) { 2650 zcmd_free_nvlists(&zc); 2651 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2652 "local origin for clone %s does not exist"), 2653 zc.zc_value); 2654 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 2655 } 2656 if (flags->verbose) 2657 (void) printf("found clone origin %s\n", zc.zc_string); 2658 } 2659 2660 stream_wantsnewfs = (drrb->drr_fromguid == NULL || 2661 (drrb->drr_flags & DRR_FLAG_CLONE)); 2662 2663 if (stream_wantsnewfs) { 2664 /* 2665 * if the parent fs does not exist, look for it based on 2666 * the parent snap GUID 2667 */ 2668 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2669 "cannot receive new filesystem stream")); 2670 2671 (void) strcpy(zc.zc_name, zc.zc_value); 2672 cp = strrchr(zc.zc_name, '/'); 2673 if (cp) 2674 *cp = '\0'; 2675 if (cp && 2676 !zfs_dataset_exists(hdl, zc.zc_name, ZFS_TYPE_DATASET)) { 2677 char suffix[ZFS_MAXNAMELEN]; 2678 (void) strcpy(suffix, strrchr(zc.zc_value, '/')); 2679 if (guid_to_name(hdl, zc.zc_name, parent_snapguid, 2680 zc.zc_value) == 0) { 2681 *strchr(zc.zc_value, '@') = '\0'; 2682 (void) strcat(zc.zc_value, suffix); 2683 } 2684 } 2685 } else { 2686 /* 2687 * if the fs does not exist, look for it based on the 2688 * fromsnap GUID 2689 */ 2690 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2691 "cannot receive incremental stream")); 2692 2693 (void) strcpy(zc.zc_name, zc.zc_value); 2694 *strchr(zc.zc_name, '@') = '\0'; 2695 2696 /* 2697 * If the exact receive path was specified and this is the 2698 * topmost path in the stream, then if the fs does not exist we 2699 * should look no further. 2700 */ 2701 if ((flags->isprefix || (*(chopprefix = drrb->drr_toname + 2702 strlen(sendfs)) != '\0' && *chopprefix != '@')) && 2703 !zfs_dataset_exists(hdl, zc.zc_name, ZFS_TYPE_DATASET)) { 2704 char snap[ZFS_MAXNAMELEN]; 2705 (void) strcpy(snap, strchr(zc.zc_value, '@')); 2706 if (guid_to_name(hdl, zc.zc_name, drrb->drr_fromguid, 2707 zc.zc_value) == 0) { 2708 *strchr(zc.zc_value, '@') = '\0'; 2709 (void) strcat(zc.zc_value, snap); 2710 } 2711 } 2712 } 2713 2714 (void) strcpy(zc.zc_name, zc.zc_value); 2715 *strchr(zc.zc_name, '@') = '\0'; 2716 2717 if (zfs_dataset_exists(hdl, zc.zc_name, ZFS_TYPE_DATASET)) { 2718 zfs_handle_t *zhp; 2719 2720 /* 2721 * Destination fs exists. Therefore this should either 2722 * be an incremental, or the stream specifies a new fs 2723 * (full stream or clone) and they want us to blow it 2724 * away (and have therefore specified -F and removed any 2725 * snapshots). 2726 */ 2727 if (stream_wantsnewfs) { 2728 if (!flags->force) { 2729 zcmd_free_nvlists(&zc); 2730 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2731 "destination '%s' exists\n" 2732 "must specify -F to overwrite it"), 2733 zc.zc_name); 2734 return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 2735 } 2736 if (ioctl(hdl->libzfs_fd, ZFS_IOC_SNAPSHOT_LIST_NEXT, 2737 &zc) == 0) { 2738 zcmd_free_nvlists(&zc); 2739 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2740 "destination has snapshots (eg. %s)\n" 2741 "must destroy them to overwrite it"), 2742 zc.zc_name); 2743 return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 2744 } 2745 } 2746 2747 if ((zhp = zfs_open(hdl, zc.zc_name, 2748 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME)) == NULL) { 2749 zcmd_free_nvlists(&zc); 2750 return (-1); 2751 } 2752 2753 if (stream_wantsnewfs && 2754 zhp->zfs_dmustats.dds_origin[0]) { 2755 zcmd_free_nvlists(&zc); 2756 zfs_close(zhp); 2757 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2758 "destination '%s' is a clone\n" 2759 "must destroy it to overwrite it"), 2760 zc.zc_name); 2761 return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 2762 } 2763 2764 if (!flags->dryrun && zhp->zfs_type == ZFS_TYPE_FILESYSTEM && 2765 stream_wantsnewfs) { 2766 /* We can't do online recv in this case */ 2767 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0, 0); 2768 if (clp == NULL) { 2769 zfs_close(zhp); 2770 zcmd_free_nvlists(&zc); 2771 return (-1); 2772 } 2773 if (changelist_prefix(clp) != 0) { 2774 changelist_free(clp); 2775 zfs_close(zhp); 2776 zcmd_free_nvlists(&zc); 2777 return (-1); 2778 } 2779 } 2780 zfs_close(zhp); 2781 } else { 2782 /* 2783 * Destination filesystem does not exist. Therefore we better 2784 * be creating a new filesystem (either from a full backup, or 2785 * a clone). It would therefore be invalid if the user 2786 * specified only the pool name (i.e. if the destination name 2787 * contained no slash character). 2788 */ 2789 if (!stream_wantsnewfs || 2790 (cp = strrchr(zc.zc_name, '/')) == NULL) { 2791 zcmd_free_nvlists(&zc); 2792 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2793 "destination '%s' does not exist"), zc.zc_name); 2794 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 2795 } 2796 2797 /* 2798 * Trim off the final dataset component so we perform the 2799 * recvbackup ioctl to the filesystems's parent. 2800 */ 2801 *cp = '\0'; 2802 2803 if (flags->isprefix && !flags->istail && !flags->dryrun && 2804 create_parents(hdl, zc.zc_value, strlen(tosnap)) != 0) { 2805 zcmd_free_nvlists(&zc); 2806 return (zfs_error(hdl, EZFS_BADRESTORE, errbuf)); 2807 } 2808 2809 newfs = B_TRUE; 2810 } 2811 2812 zc.zc_begin_record = drr_noswap->drr_u.drr_begin; 2813 zc.zc_cookie = infd; 2814 zc.zc_guid = flags->force; 2815 if (flags->verbose) { 2816 (void) printf("%s %s stream of %s into %s\n", 2817 flags->dryrun ? "would receive" : "receiving", 2818 drrb->drr_fromguid ? "incremental" : "full", 2819 drrb->drr_toname, zc.zc_value); 2820 (void) fflush(stdout); 2821 } 2822 2823 if (flags->dryrun) { 2824 zcmd_free_nvlists(&zc); 2825 return (recv_skip(hdl, infd, flags->byteswap)); 2826 } 2827 2828 zc.zc_nvlist_dst = (uint64_t)(uintptr_t)prop_errbuf; 2829 zc.zc_nvlist_dst_size = sizeof (prop_errbuf); 2830 zc.zc_cleanup_fd = cleanup_fd; 2831 zc.zc_action_handle = *action_handlep; 2832 2833 err = ioctl_err = zfs_ioctl(hdl, ZFS_IOC_RECV, &zc); 2834 ioctl_errno = errno; 2835 prop_errflags = (zprop_errflags_t)zc.zc_obj; 2836 2837 if (err == 0) { 2838 nvlist_t *prop_errors; 2839 VERIFY(0 == nvlist_unpack((void *)(uintptr_t)zc.zc_nvlist_dst, 2840 zc.zc_nvlist_dst_size, &prop_errors, 0)); 2841 2842 nvpair_t *prop_err = NULL; 2843 2844 while ((prop_err = nvlist_next_nvpair(prop_errors, 2845 prop_err)) != NULL) { 2846 char tbuf[1024]; 2847 zfs_prop_t prop; 2848 int intval; 2849 2850 prop = zfs_name_to_prop(nvpair_name(prop_err)); 2851 (void) nvpair_value_int32(prop_err, &intval); 2852 if (strcmp(nvpair_name(prop_err), 2853 ZPROP_N_MORE_ERRORS) == 0) { 2854 trunc_prop_errs(intval); 2855 break; 2856 } else { 2857 (void) snprintf(tbuf, sizeof (tbuf), 2858 dgettext(TEXT_DOMAIN, 2859 "cannot receive %s property on %s"), 2860 nvpair_name(prop_err), zc.zc_name); 2861 zfs_setprop_error(hdl, prop, intval, tbuf); 2862 } 2863 } 2864 nvlist_free(prop_errors); 2865 } 2866 2867 zc.zc_nvlist_dst = 0; 2868 zc.zc_nvlist_dst_size = 0; 2869 zcmd_free_nvlists(&zc); 2870 2871 if (err == 0 && snapprops_nvlist) { 2872 zfs_cmd_t zc2 = { 0 }; 2873 2874 (void) strcpy(zc2.zc_name, zc.zc_value); 2875 zc2.zc_cookie = B_TRUE; /* received */ 2876 if (zcmd_write_src_nvlist(hdl, &zc2, snapprops_nvlist) == 0) { 2877 (void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc2); 2878 zcmd_free_nvlists(&zc2); 2879 } 2880 } 2881 2882 if (err && (ioctl_errno == ENOENT || ioctl_errno == EEXIST)) { 2883 /* 2884 * It may be that this snapshot already exists, 2885 * in which case we want to consume & ignore it 2886 * rather than failing. 2887 */ 2888 avl_tree_t *local_avl; 2889 nvlist_t *local_nv, *fs; 2890 cp = strchr(zc.zc_value, '@'); 2891 2892 /* 2893 * XXX Do this faster by just iterating over snaps in 2894 * this fs. Also if zc_value does not exist, we will 2895 * get a strange "does not exist" error message. 2896 */ 2897 *cp = '\0'; 2898 if (gather_nvlist(hdl, zc.zc_value, NULL, NULL, B_FALSE, 2899 &local_nv, &local_avl) == 0) { 2900 *cp = '@'; 2901 fs = fsavl_find(local_avl, drrb->drr_toguid, NULL); 2902 fsavl_destroy(local_avl); 2903 nvlist_free(local_nv); 2904 2905 if (fs != NULL) { 2906 if (flags->verbose) { 2907 (void) printf("snap %s already exists; " 2908 "ignoring\n", zc.zc_value); 2909 } 2910 err = ioctl_err = recv_skip(hdl, infd, 2911 flags->byteswap); 2912 } 2913 } 2914 *cp = '@'; 2915 } 2916 2917 if (ioctl_err != 0) { 2918 switch (ioctl_errno) { 2919 case ENODEV: 2920 cp = strchr(zc.zc_value, '@'); 2921 *cp = '\0'; 2922 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2923 "most recent snapshot of %s does not\n" 2924 "match incremental source"), zc.zc_value); 2925 (void) zfs_error(hdl, EZFS_BADRESTORE, errbuf); 2926 *cp = '@'; 2927 break; 2928 case ETXTBSY: 2929 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2930 "destination %s has been modified\n" 2931 "since most recent snapshot"), zc.zc_name); 2932 (void) zfs_error(hdl, EZFS_BADRESTORE, errbuf); 2933 break; 2934 case EEXIST: 2935 cp = strchr(zc.zc_value, '@'); 2936 if (newfs) { 2937 /* it's the containing fs that exists */ 2938 *cp = '\0'; 2939 } 2940 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2941 "destination already exists")); 2942 (void) zfs_error_fmt(hdl, EZFS_EXISTS, 2943 dgettext(TEXT_DOMAIN, "cannot restore to %s"), 2944 zc.zc_value); 2945 *cp = '@'; 2946 break; 2947 case EINVAL: 2948 (void) zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2949 break; 2950 case ECKSUM: 2951 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2952 "invalid stream (checksum mismatch)")); 2953 (void) zfs_error(hdl, EZFS_BADSTREAM, errbuf); 2954 break; 2955 case ENOTSUP: 2956 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2957 "pool must be upgraded to receive this stream.")); 2958 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf); 2959 break; 2960 case EDQUOT: 2961 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2962 "destination %s space quota exceeded"), zc.zc_name); 2963 (void) zfs_error(hdl, EZFS_NOSPC, errbuf); 2964 break; 2965 default: 2966 (void) zfs_standard_error(hdl, ioctl_errno, errbuf); 2967 } 2968 } 2969 2970 /* 2971 * Mount the target filesystem (if created). Also mount any 2972 * children of the target filesystem if we did a replication 2973 * receive (indicated by stream_avl being non-NULL). 2974 */ 2975 cp = strchr(zc.zc_value, '@'); 2976 if (cp && (ioctl_err == 0 || !newfs)) { 2977 zfs_handle_t *h; 2978 2979 *cp = '\0'; 2980 h = zfs_open(hdl, zc.zc_value, 2981 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 2982 if (h != NULL) { 2983 if (h->zfs_type == ZFS_TYPE_VOLUME) { 2984 *cp = '@'; 2985 } else if (newfs || stream_avl) { 2986 /* 2987 * Track the first/top of hierarchy fs, 2988 * for mounting and sharing later. 2989 */ 2990 if (top_zfs && *top_zfs == NULL) 2991 *top_zfs = zfs_strdup(hdl, zc.zc_value); 2992 } 2993 zfs_close(h); 2994 } 2995 *cp = '@'; 2996 } 2997 2998 if (clp) { 2999 err |= changelist_postfix(clp); 3000 changelist_free(clp); 3001 } 3002 3003 if (prop_errflags & ZPROP_ERR_NOCLEAR) { 3004 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Warning: " 3005 "failed to clear unreceived properties on %s"), 3006 zc.zc_name); 3007 (void) fprintf(stderr, "\n"); 3008 } 3009 if (prop_errflags & ZPROP_ERR_NORESTORE) { 3010 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Warning: " 3011 "failed to restore original properties on %s"), 3012 zc.zc_name); 3013 (void) fprintf(stderr, "\n"); 3014 } 3015 3016 if (err || ioctl_err) 3017 return (-1); 3018 3019 *action_handlep = zc.zc_action_handle; 3020 3021 if (flags->verbose) { 3022 char buf1[64]; 3023 char buf2[64]; 3024 uint64_t bytes = zc.zc_cookie; 3025 time_t delta = time(NULL) - begin_time; 3026 if (delta == 0) 3027 delta = 1; 3028 zfs_nicenum(bytes, buf1, sizeof (buf1)); 3029 zfs_nicenum(bytes/delta, buf2, sizeof (buf1)); 3030 3031 (void) printf("received %sB stream in %lu seconds (%sB/sec)\n", 3032 buf1, delta, buf2); 3033 } 3034 3035 return (0); 3036 } 3037 3038 static int 3039 zfs_receive_impl(libzfs_handle_t *hdl, const char *tosnap, recvflags_t *flags, 3040 int infd, const char *sendfs, nvlist_t *stream_nv, avl_tree_t *stream_avl, 3041 char **top_zfs, int cleanup_fd, uint64_t *action_handlep) 3042 { 3043 int err; 3044 dmu_replay_record_t drr, drr_noswap; 3045 struct drr_begin *drrb = &drr.drr_u.drr_begin; 3046 char errbuf[1024]; 3047 zio_cksum_t zcksum = { 0 }; 3048 uint64_t featureflags; 3049 int hdrtype; 3050 3051 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 3052 "cannot receive")); 3053 3054 if (flags->isprefix && 3055 !zfs_dataset_exists(hdl, tosnap, ZFS_TYPE_DATASET)) { 3056 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "specified fs " 3057 "(%s) does not exist"), tosnap); 3058 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 3059 } 3060 3061 /* read in the BEGIN record */ 3062 if (0 != (err = recv_read(hdl, infd, &drr, sizeof (drr), B_FALSE, 3063 &zcksum))) 3064 return (err); 3065 3066 if (drr.drr_type == DRR_END || drr.drr_type == BSWAP_32(DRR_END)) { 3067 /* It's the double end record at the end of a package */ 3068 return (ENODATA); 3069 } 3070 3071 /* the kernel needs the non-byteswapped begin record */ 3072 drr_noswap = drr; 3073 3074 flags->byteswap = B_FALSE; 3075 if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) { 3076 /* 3077 * We computed the checksum in the wrong byteorder in 3078 * recv_read() above; do it again correctly. 3079 */ 3080 bzero(&zcksum, sizeof (zio_cksum_t)); 3081 fletcher_4_incremental_byteswap(&drr, sizeof (drr), &zcksum); 3082 flags->byteswap = B_TRUE; 3083 3084 drr.drr_type = BSWAP_32(drr.drr_type); 3085 drr.drr_payloadlen = BSWAP_32(drr.drr_payloadlen); 3086 drrb->drr_magic = BSWAP_64(drrb->drr_magic); 3087 drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 3088 drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 3089 drrb->drr_type = BSWAP_32(drrb->drr_type); 3090 drrb->drr_flags = BSWAP_32(drrb->drr_flags); 3091 drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 3092 drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 3093 } 3094 3095 if (drrb->drr_magic != DMU_BACKUP_MAGIC || drr.drr_type != DRR_BEGIN) { 3096 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 3097 "stream (bad magic number)")); 3098 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 3099 } 3100 3101 featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 3102 hdrtype = DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo); 3103 3104 if (!DMU_STREAM_SUPPORTED(featureflags) || 3105 (hdrtype != DMU_SUBSTREAM && hdrtype != DMU_COMPOUNDSTREAM)) { 3106 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3107 "stream has unsupported feature, feature flags = %lx"), 3108 featureflags); 3109 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 3110 } 3111 3112 if (strchr(drrb->drr_toname, '@') == NULL) { 3113 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid " 3114 "stream (bad snapshot name)")); 3115 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf)); 3116 } 3117 3118 if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == DMU_SUBSTREAM) { 3119 char nonpackage_sendfs[ZFS_MAXNAMELEN]; 3120 if (sendfs == NULL) { 3121 /* 3122 * We were not called from zfs_receive_package(). Get 3123 * the fs specified by 'zfs send'. 3124 */ 3125 char *cp; 3126 (void) strlcpy(nonpackage_sendfs, 3127 drr.drr_u.drr_begin.drr_toname, ZFS_MAXNAMELEN); 3128 if ((cp = strchr(nonpackage_sendfs, '@')) != NULL) 3129 *cp = '\0'; 3130 sendfs = nonpackage_sendfs; 3131 } 3132 return (zfs_receive_one(hdl, infd, tosnap, flags, 3133 &drr, &drr_noswap, sendfs, stream_nv, stream_avl, 3134 top_zfs, cleanup_fd, action_handlep)); 3135 } else { 3136 assert(DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == 3137 DMU_COMPOUNDSTREAM); 3138 return (zfs_receive_package(hdl, infd, tosnap, flags, 3139 &drr, &zcksum, top_zfs, cleanup_fd, action_handlep)); 3140 } 3141 } 3142 3143 /* 3144 * Restores a backup of tosnap from the file descriptor specified by infd. 3145 * Return 0 on total success, -2 if some things couldn't be 3146 * destroyed/renamed/promoted, -1 if some things couldn't be received. 3147 * (-1 will override -2). 3148 */ 3149 int 3150 zfs_receive(libzfs_handle_t *hdl, const char *tosnap, recvflags_t *flags, 3151 int infd, avl_tree_t *stream_avl) 3152 { 3153 char *top_zfs = NULL; 3154 int err; 3155 int cleanup_fd; 3156 uint64_t action_handle = 0; 3157 3158 cleanup_fd = open(ZFS_DEV, O_RDWR|O_EXCL); 3159 VERIFY(cleanup_fd >= 0); 3160 3161 err = zfs_receive_impl(hdl, tosnap, flags, infd, NULL, NULL, 3162 stream_avl, &top_zfs, cleanup_fd, &action_handle); 3163 3164 VERIFY(0 == close(cleanup_fd)); 3165 3166 if (err == 0 && !flags->nomount && top_zfs) { 3167 zfs_handle_t *zhp; 3168 prop_changelist_t *clp; 3169 3170 zhp = zfs_open(hdl, top_zfs, ZFS_TYPE_FILESYSTEM); 3171 if (zhp != NULL) { 3172 clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, 3173 CL_GATHER_MOUNT_ALWAYS, 0); 3174 zfs_close(zhp); 3175 if (clp != NULL) { 3176 /* mount and share received datasets */ 3177 err = changelist_postfix(clp); 3178 changelist_free(clp); 3179 } 3180 } 3181 if (zhp == NULL || clp == NULL || err) 3182 err = -1; 3183 } 3184 if (top_zfs) 3185 free(top_zfs); 3186 3187 return (err); 3188 }