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