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 char *thissnap;
1015 int err;
1016 boolean_t isfromsnap, istosnap, fromorigin;
1017 boolean_t exclude = B_FALSE;
1018
1019 err = 0;
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 = 0;
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 goto stderr_out;
1424 }
1425
1426 if (!flags->dryrun) {
1427 /* write first begin record */
1428 drr.drr_type = DRR_BEGIN;
1429 drr.drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC;
1430 DMU_SET_STREAM_HDRTYPE(drr.drr_u.drr_begin.
1431 drr_versioninfo, DMU_COMPOUNDSTREAM);
1432 DMU_SET_FEATUREFLAGS(drr.drr_u.drr_begin.
1433 drr_versioninfo, featureflags);
1434 (void) snprintf(drr.drr_u.drr_begin.drr_toname,
1435 sizeof (drr.drr_u.drr_begin.drr_toname),
1436 "%s@%s", zhp->zfs_name, tosnap);
1437 drr.drr_payloadlen = buflen;
1438 err = cksum_and_write(&drr, sizeof (drr), &zc, outfd);
1439
1440 /* write header nvlist */
1441 if (err != -1 && packbuf != NULL) {
1442 err = cksum_and_write(packbuf, buflen, &zc,
1443 outfd);
1444 }
1445 free(packbuf);
1446 if (err == -1) {
1447 err = errno;
1448 goto stderr_out;
1449 }
1450
1451 /* write end record */
1452 bzero(&drr, sizeof (drr));
1453 drr.drr_type = DRR_END;
1454 drr.drr_u.drr_end.drr_checksum = zc;
1455 err = write(outfd, &drr, sizeof (drr));
1456 if (err == -1) {
1457 err = errno;
1458 goto stderr_out;
1459 }
1460
1461 err = 0;
1462 }
1463 }
1464
1465 /* dump each stream */
1466 sdd.fromsnap = fromsnap;
1467 sdd.tosnap = tosnap;
1468 if (tid != 0)
1469 sdd.outfd = pipefd[0];
1470 else
1471 sdd.outfd = outfd;
1472 sdd.replicate = flags->replicate;
1473 sdd.doall = flags->doall;
1474 sdd.fromorigin = flags->fromorigin;
1475 sdd.fss = fss;
1476 sdd.fsavl = fsavl;
1477 sdd.verbose = flags->verbose;
1478 sdd.parsable = flags->parsable;
1479 sdd.progress = flags->progress;
1480 sdd.dryrun = flags->dryrun;
1481 sdd.filter_cb = filter_func;
1482 sdd.filter_cb_arg = cb_arg;
1483 if (debugnvp)
1484 sdd.debugnv = *debugnvp;
1485
1486 /*
1487 * Some flags require that we place user holds on the datasets that are
1488 * being sent so they don't get destroyed during the send. We can skip
1489 * this step if the pool is imported read-only since the datasets cannot
1490 * be destroyed.
1491 */
1492 if (!flags->dryrun && !zpool_get_prop_int(zfs_get_pool_handle(zhp),
1493 ZPOOL_PROP_READONLY, NULL) &&
1494 zfs_spa_version(zhp, &spa_version) == 0 &&
1495 spa_version >= SPA_VERSION_USERREFS &&
1496 (flags->doall || flags->replicate)) {
1497 ++holdseq;
1498 (void) snprintf(sdd.holdtag, sizeof (sdd.holdtag),
1499 ".send-%d-%llu", getpid(), (u_longlong_t)holdseq);
1500 sdd.cleanup_fd = open(ZFS_DEV, O_RDWR|O_EXCL);
1501 if (sdd.cleanup_fd < 0) {
1502 err = errno;
1503 goto stderr_out;
1504 }
1505 sdd.snapholds = fnvlist_alloc();
1506 } else {
1507 sdd.cleanup_fd = -1;
1508 sdd.snapholds = NULL;
1509 }
1510 if (flags->verbose || sdd.snapholds != NULL) {
1511 /*
1512 * Do a verbose no-op dry run to get all the verbose output
1513 * or to gather snapshot hold's before generating any data,
1514 * then do a non-verbose real run to generate the streams.
1515 */
1516 sdd.dryrun = B_TRUE;
1517 err = dump_filesystems(zhp, &sdd);
1518
1519 if (err != 0)
1520 goto stderr_out;
1521
1522 if (flags->verbose) {
1523 if (flags->parsable) {
1524 (void) fprintf(stderr, "size\t%llu\n",
1525 (longlong_t)sdd.size);
1526 } else {
1527 char buf[16];
1528 zfs_nicenum(sdd.size, buf, sizeof (buf));
1529 (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
1530 "total estimated size is %s\n"), buf);
1531 }
1532 }
1533
1534 /* Ensure no snaps found is treated as an error. */
1535 if (!sdd.seento) {
1536 err = ENOENT;
1537 goto err_out;
1538 }
1539
1540 /* Skip the second run if dryrun was requested. */
1541 if (flags->dryrun)
1542 goto err_out;
1543
1544 if (sdd.snapholds != NULL) {
1545 err = zfs_hold_nvl(zhp, sdd.cleanup_fd, sdd.snapholds);
1546 if (err != 0)
1547 goto stderr_out;
1548 fnvlist_free(sdd.snapholds);
1549 sdd.snapholds = NULL;
1550 }
1551
1552 sdd.dryrun = B_FALSE;
1553 sdd.verbose = B_FALSE;
1554 }
1555
1556 err = dump_filesystems(zhp, &sdd);
1557 fsavl_destroy(fsavl);
1558 nvlist_free(fss);
1559
1560 /* Ensure no snaps found is treated as an error. */
1561 if (err == 0 && !sdd.seento)
1562 err = ENOENT;
1563
1564 if (tid != 0) {
1565 if (err != 0)
1566 (void) pthread_cancel(tid);
1567 (void) pthread_join(tid, NULL);
1568 (void) close(pipefd[0]);
1569 }
1570
1571 if (sdd.cleanup_fd != -1) {
1572 VERIFY(0 == close(sdd.cleanup_fd));
1573 sdd.cleanup_fd = -1;
1574 }
1575
1576 if (!flags->dryrun && (flags->replicate || flags->doall ||
1577 flags->props)) {
1578 /*
1579 * write final end record. NB: want to do this even if
1580 * there was some error, because it might not be totally
1581 * failed.
1582 */
1583 dmu_replay_record_t drr = { 0 };
1584 drr.drr_type = DRR_END;
1585 if (write(outfd, &drr, sizeof (drr)) == -1) {
1586 return (zfs_standard_error(zhp->zfs_hdl,
1587 errno, errbuf));
1588 }
1589 }
1590
1591 return (err || sdd.err);
1592
1593 stderr_out:
1594 err = zfs_standard_error(zhp->zfs_hdl, err, errbuf);
1595 err_out:
1596 fsavl_destroy(fsavl);
1597 nvlist_free(fss);
1598 fnvlist_free(sdd.snapholds);
1599
1600 if (sdd.cleanup_fd != -1)
1601 VERIFY(0 == close(sdd.cleanup_fd));
1602 if (tid != 0) {
1603 (void) pthread_cancel(tid);
1604 (void) pthread_join(tid, NULL);
1605 (void) close(pipefd[0]);
1606 }
1607 return (err);
1608 }
1609
1610 /*
1611 * Routines specific to "zfs recv"
1612 */
1613
1614 static int
1615 recv_read(libzfs_handle_t *hdl, int fd, void *buf, int ilen,
1616 boolean_t byteswap, zio_cksum_t *zc)
1617 {
1618 char *cp = buf;
1619 int rv;
1620 int len = ilen;
1621
1622 do {
1623 rv = read(fd, cp, len);
1624 cp += rv;
1625 len -= rv;
1626 } while (rv > 0);
1627
1628 if (rv < 0 || len != 0) {
1629 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1630 "failed to read from stream"));
1631 return (zfs_error(hdl, EZFS_BADSTREAM, dgettext(TEXT_DOMAIN,
1632 "cannot receive")));
1633 }
1634
1635 if (zc) {
1636 if (byteswap)
1637 fletcher_4_incremental_byteswap(buf, ilen, zc);
1638 else
1639 fletcher_4_incremental_native(buf, ilen, zc);
1640 }
1641 return (0);
1642 }
1643
1644 static int
1645 recv_read_nvlist(libzfs_handle_t *hdl, int fd, int len, nvlist_t **nvp,
1646 boolean_t byteswap, zio_cksum_t *zc)
1647 {
1648 char *buf;
1649 int err;
1650
1651 buf = zfs_alloc(hdl, len);
1652 if (buf == NULL)
1653 return (ENOMEM);
1654
1655 err = recv_read(hdl, fd, buf, len, byteswap, zc);
1656 if (err != 0) {
1657 free(buf);
1658 return (err);
1659 }
1660
1661 err = nvlist_unpack(buf, len, nvp, 0);
1662 free(buf);
1663 if (err != 0) {
1664 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
1665 "stream (malformed nvlist)"));
1666 return (EINVAL);
1667 }
1668 return (0);
1669 }
1670
1671 static int
1672 recv_rename(libzfs_handle_t *hdl, const char *name, const char *tryname,
1673 int baselen, char *newname, recvflags_t *flags)
1674 {
1675 static int seq;
1676 zfs_cmd_t zc = { 0 };
1677 int err;
1678 prop_changelist_t *clp;
1679 zfs_handle_t *zhp;
1680
1681 zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET);
1682 if (zhp == NULL)
1683 return (-1);
1684 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
1685 flags->force ? MS_FORCE : 0);
1686 zfs_close(zhp);
1687 if (clp == NULL)
1688 return (-1);
1689 err = changelist_prefix(clp);
1690 if (err)
1691 return (err);
1692
1693 zc.zc_objset_type = DMU_OST_ZFS;
1694 (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
1695
1696 if (tryname) {
1697 (void) strcpy(newname, tryname);
1698
1699 (void) strlcpy(zc.zc_value, tryname, sizeof (zc.zc_value));
1700
1701 if (flags->verbose) {
1702 (void) printf("attempting rename %s to %s\n",
1703 zc.zc_name, zc.zc_value);
1704 }
1705 err = ioctl(hdl->libzfs_fd, ZFS_IOC_RENAME, &zc);
1706 if (err == 0)
1707 changelist_rename(clp, name, tryname);
1708 } else {
1709 err = ENOENT;
1710 }
1711
1712 if (err != 0 && strncmp(name + baselen, "recv-", 5) != 0) {
1713 seq++;
1714
1715 (void) snprintf(newname, ZFS_MAXNAMELEN, "%.*srecv-%u-%u",
1716 baselen, name, getpid(), seq);
1717 (void) strlcpy(zc.zc_value, newname, sizeof (zc.zc_value));
1718
1719 if (flags->verbose) {
1720 (void) printf("failed - trying rename %s to %s\n",
1721 zc.zc_name, zc.zc_value);
1722 }
1723 err = ioctl(hdl->libzfs_fd, ZFS_IOC_RENAME, &zc);
1724 if (err == 0)
1725 changelist_rename(clp, name, newname);
1726 if (err && flags->verbose) {
1727 (void) printf("failed (%u) - "
1728 "will try again on next pass\n", errno);
1729 }
1730 err = EAGAIN;
1731 } else if (flags->verbose) {
1732 if (err == 0)
1733 (void) printf("success\n");
1734 else
1735 (void) printf("failed (%u)\n", errno);
1736 }
1737
1738 (void) changelist_postfix(clp);
1739 changelist_free(clp);
1740
1741 return (err);
1742 }
1743
1744 static int
1745 recv_destroy(libzfs_handle_t *hdl, const char *name, int baselen,
1746 char *newname, recvflags_t *flags)
1747 {
1748 zfs_cmd_t zc = { 0 };
1749 int err = 0;
1750 prop_changelist_t *clp;
1751 zfs_handle_t *zhp;
1752 boolean_t defer = B_FALSE;
1753 int spa_version;
1754
1755 zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET);
1756 if (zhp == NULL)
1757 return (-1);
1758 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
1759 flags->force ? MS_FORCE : 0);
1760 if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
1761 zfs_spa_version(zhp, &spa_version) == 0 &&
1762 spa_version >= SPA_VERSION_USERREFS)
1763 defer = B_TRUE;
1764 zfs_close(zhp);
1765 if (clp == NULL)
1766 return (-1);
1767 err = changelist_prefix(clp);
1768 if (err)
1769 return (err);
1770
1771 zc.zc_objset_type = DMU_OST_ZFS;
1772 zc.zc_defer_destroy = defer;
1773 (void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
1774
1775 if (flags->verbose)
1776 (void) printf("attempting destroy %s\n", zc.zc_name);
1777 err = ioctl(hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc);
1778 if (err == 0) {
1779 if (flags->verbose)
1780 (void) printf("success\n");
1781 changelist_remove(clp, zc.zc_name);
1782 }
1783
1784 (void) changelist_postfix(clp);
1785 changelist_free(clp);
1786
1787 /*
1788 * Deferred destroy might destroy the snapshot or only mark it to be
1789 * destroyed later, and it returns success in either case.
1790 */
1791 if (err != 0 || (defer && zfs_dataset_exists(hdl, name,
1792 ZFS_TYPE_SNAPSHOT))) {
1793 err = recv_rename(hdl, name, NULL, baselen, newname, flags);
1794 }
1795
1796 return (err);
1797 }
1798
1799 typedef struct guid_to_name_data {
1800 uint64_t guid;
1801 char *name;
1802 char *skip;
1803 } guid_to_name_data_t;
1804
1805 static int
1806 guid_to_name_cb(zfs_handle_t *zhp, void *arg)
1807 {
1808 guid_to_name_data_t *gtnd = arg;
1809 int err;
1810
1811 if (gtnd->skip != NULL &&
1812 strcmp(zhp->zfs_name, gtnd->skip) == 0) {
1813 return (0);
1814 }
1815
1816 if (zhp->zfs_dmustats.dds_guid == gtnd->guid) {
1817 (void) strcpy(gtnd->name, zhp->zfs_name);
1818 zfs_close(zhp);
1819 return (EEXIST);
1820 }
1821
1822 err = zfs_iter_children(zhp, guid_to_name_cb, gtnd);
1823 zfs_close(zhp);
1824 return (err);
1825 }
1826
1827 /*
1828 * Attempt to find the local dataset associated with this guid. In the case of
1829 * multiple matches, we attempt to find the "best" match by searching
1830 * progressively larger portions of the hierarchy. This allows one to send a
1831 * tree of datasets individually and guarantee that we will find the source
1832 * guid within that hierarchy, even if there are multiple matches elsewhere.
1833 */
1834 static int
1835 guid_to_name(libzfs_handle_t *hdl, const char *parent, uint64_t guid,
1836 char *name)
1837 {
1838 /* exhaustive search all local snapshots */
1839 char pname[ZFS_MAXNAMELEN];
1840 guid_to_name_data_t gtnd;
1841 int err = 0;
1842 zfs_handle_t *zhp;
1843 char *cp;
1844
1845 gtnd.guid = guid;
1846 gtnd.name = name;
1847 gtnd.skip = NULL;
1848
1849 (void) strlcpy(pname, parent, sizeof (pname));
1850
1851 /*
1852 * Search progressively larger portions of the hierarchy. This will
1853 * select the "most local" version of the origin snapshot in the case
1854 * that there are multiple matching snapshots in the system.
1855 */
1856 while ((cp = strrchr(pname, '/')) != NULL) {
1857
1858 /* Chop off the last component and open the parent */
1859 *cp = '\0';
1860 zhp = make_dataset_handle(hdl, pname);
1861
1862 if (zhp == NULL)
1863 continue;
1864
1865 err = zfs_iter_children(zhp, guid_to_name_cb, >nd);
1866 zfs_close(zhp);
1867 if (err == EEXIST)
1868 return (0);
1869
1870 /*
1871 * Remember the dataset that we already searched, so we
1872 * skip it next time through.
1873 */
1874 gtnd.skip = pname;
1875 }
1876
1877 return (ENOENT);
1878 }
1879
1880 /*
1881 * Return +1 if guid1 is before guid2, 0 if they are the same, and -1 if
1882 * guid1 is after guid2.
1883 */
1884 static int
1885 created_before(libzfs_handle_t *hdl, avl_tree_t *avl,
1886 uint64_t guid1, uint64_t guid2)
1887 {
1888 nvlist_t *nvfs;
1889 char *fsname, *snapname;
1890 char buf[ZFS_MAXNAMELEN];
1891 int rv;
1892 zfs_handle_t *guid1hdl, *guid2hdl;
1893 uint64_t create1, create2;
1894
1895 if (guid2 == 0)
1896 return (0);
1897 if (guid1 == 0)
1898 return (1);
1899
1900 nvfs = fsavl_find(avl, guid1, &snapname);
1901 VERIFY(0 == nvlist_lookup_string(nvfs, "name", &fsname));
1902 (void) snprintf(buf, sizeof (buf), "%s@%s", fsname, snapname);
1903 guid1hdl = zfs_open(hdl, buf, ZFS_TYPE_SNAPSHOT);
1904 if (guid1hdl == NULL)
1905 return (-1);
1906
1907 nvfs = fsavl_find(avl, guid2, &snapname);
1908 VERIFY(0 == nvlist_lookup_string(nvfs, "name", &fsname));
1909 (void) snprintf(buf, sizeof (buf), "%s@%s", fsname, snapname);
1910 guid2hdl = zfs_open(hdl, buf, ZFS_TYPE_SNAPSHOT);
1911 if (guid2hdl == NULL) {
1912 zfs_close(guid1hdl);
1913 return (-1);
1914 }
1915
1916 create1 = zfs_prop_get_int(guid1hdl, ZFS_PROP_CREATETXG);
1917 create2 = zfs_prop_get_int(guid2hdl, ZFS_PROP_CREATETXG);
1918
1919 if (create1 < create2)
1920 rv = -1;
1921 else if (create1 > create2)
1922 rv = +1;
1923 else
1924 rv = 0;
1925
1926 zfs_close(guid1hdl);
1927 zfs_close(guid2hdl);
1928
1929 return (rv);
1930 }
1931
1932 static int
1933 recv_incremental_replication(libzfs_handle_t *hdl, const char *tofs,
1934 recvflags_t *flags, nvlist_t *stream_nv, avl_tree_t *stream_avl,
1935 nvlist_t *renamed)
1936 {
1937 nvlist_t *local_nv;
1938 avl_tree_t *local_avl;
1939 nvpair_t *fselem, *nextfselem;
1940 char *fromsnap;
1941 char newname[ZFS_MAXNAMELEN];
1942 int error;
1943 boolean_t needagain, progress, recursive;
1944 char *s1, *s2;
1945
1946 VERIFY(0 == nvlist_lookup_string(stream_nv, "fromsnap", &fromsnap));
1947
1948 recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") ==
1949 ENOENT);
1950
1951 if (flags->dryrun)
1952 return (0);
1953
1954 again:
1955 needagain = progress = B_FALSE;
1956
1957 if ((error = gather_nvlist(hdl, tofs, fromsnap, NULL,
1958 recursive, &local_nv, &local_avl)) != 0)
1959 return (error);
1960
1961 /*
1962 * Process deletes and renames
1963 */
1964 for (fselem = nvlist_next_nvpair(local_nv, NULL);
1965 fselem; fselem = nextfselem) {
1966 nvlist_t *nvfs, *snaps;
1967 nvlist_t *stream_nvfs = NULL;
1968 nvpair_t *snapelem, *nextsnapelem;
1969 uint64_t fromguid = 0;
1970 uint64_t originguid = 0;
1971 uint64_t stream_originguid = 0;
1972 uint64_t parent_fromsnap_guid, stream_parent_fromsnap_guid;
1973 char *fsname, *stream_fsname;
1974
1975 nextfselem = nvlist_next_nvpair(local_nv, fselem);
1976
1977 VERIFY(0 == nvpair_value_nvlist(fselem, &nvfs));
1978 VERIFY(0 == nvlist_lookup_nvlist(nvfs, "snaps", &snaps));
1979 VERIFY(0 == nvlist_lookup_string(nvfs, "name", &fsname));
1980 VERIFY(0 == nvlist_lookup_uint64(nvfs, "parentfromsnap",
1981 &parent_fromsnap_guid));
1982 (void) nvlist_lookup_uint64(nvfs, "origin", &originguid);
1983
1984 /*
1985 * First find the stream's fs, so we can check for
1986 * a different origin (due to "zfs promote")
1987 */
1988 for (snapelem = nvlist_next_nvpair(snaps, NULL);
1989 snapelem; snapelem = nvlist_next_nvpair(snaps, snapelem)) {
1990 uint64_t thisguid;
1991
1992 VERIFY(0 == nvpair_value_uint64(snapelem, &thisguid));
1993 stream_nvfs = fsavl_find(stream_avl, thisguid, NULL);
1994
1995 if (stream_nvfs != NULL)
1996 break;
1997 }
1998
1999 /* check for promote */
2000 (void) nvlist_lookup_uint64(stream_nvfs, "origin",
2001 &stream_originguid);
2002 if (stream_nvfs && originguid != stream_originguid) {
2003 switch (created_before(hdl, local_avl,
2004 stream_originguid, originguid)) {
2005 case 1: {
2006 /* promote it! */
2007 zfs_cmd_t zc = { 0 };
2008 nvlist_t *origin_nvfs;
2009 char *origin_fsname;
2010
2011 if (flags->verbose)
2012 (void) printf("promoting %s\n", fsname);
2013
2014 origin_nvfs = fsavl_find(local_avl, originguid,
2015 NULL);
2016 VERIFY(0 == nvlist_lookup_string(origin_nvfs,
2017 "name", &origin_fsname));
2018 (void) strlcpy(zc.zc_value, origin_fsname,
2019 sizeof (zc.zc_value));
2020 (void) strlcpy(zc.zc_name, fsname,
2021 sizeof (zc.zc_name));
2022 error = zfs_ioctl(hdl, ZFS_IOC_PROMOTE, &zc);
2023 if (error == 0)
2024 progress = B_TRUE;
2025 break;
2026 }
2027 default:
2028 break;
2029 case -1:
2030 fsavl_destroy(local_avl);
2031 nvlist_free(local_nv);
2032 return (-1);
2033 }
2034 /*
2035 * We had/have the wrong origin, therefore our
2036 * list of snapshots is wrong. Need to handle
2037 * them on the next pass.
2038 */
2039 needagain = B_TRUE;
2040 continue;
2041 }
2042
2043 for (snapelem = nvlist_next_nvpair(snaps, NULL);
2044 snapelem; snapelem = nextsnapelem) {
2045 uint64_t thisguid;
2046 char *stream_snapname;
2047 nvlist_t *found, *props;
2048
2049 nextsnapelem = nvlist_next_nvpair(snaps, snapelem);
2050
2051 VERIFY(0 == nvpair_value_uint64(snapelem, &thisguid));
2052 found = fsavl_find(stream_avl, thisguid,
2053 &stream_snapname);
2054
2055 /* check for delete */
2056 if (found == NULL) {
2057 char name[ZFS_MAXNAMELEN];
2058
2059 if (!flags->force)
2060 continue;
2061
2062 (void) snprintf(name, sizeof (name), "%s@%s",
2063 fsname, nvpair_name(snapelem));
2064
2065 error = recv_destroy(hdl, name,
2066 strlen(fsname)+1, newname, flags);
2067 if (error)
2068 needagain = B_TRUE;
2069 else
2070 progress = B_TRUE;
2071 continue;
2072 }
2073
2074 stream_nvfs = found;
2075
2076 if (0 == nvlist_lookup_nvlist(stream_nvfs, "snapprops",
2077 &props) && 0 == nvlist_lookup_nvlist(props,
2078 stream_snapname, &props)) {
2079 zfs_cmd_t zc = { 0 };
2080
2081 zc.zc_cookie = B_TRUE; /* received */
2082 (void) snprintf(zc.zc_name, sizeof (zc.zc_name),
2083 "%s@%s", fsname, nvpair_name(snapelem));
2084 if (zcmd_write_src_nvlist(hdl, &zc,
2085 props) == 0) {
2086 (void) zfs_ioctl(hdl,
2087 ZFS_IOC_SET_PROP, &zc);
2088 zcmd_free_nvlists(&zc);
2089 }
2090 }
2091
2092 /* check for different snapname */
2093 if (strcmp(nvpair_name(snapelem),
2094 stream_snapname) != 0) {
2095 char name[ZFS_MAXNAMELEN];
2096 char tryname[ZFS_MAXNAMELEN];
2097
2098 (void) snprintf(name, sizeof (name), "%s@%s",
2099 fsname, nvpair_name(snapelem));
2100 (void) snprintf(tryname, sizeof (name), "%s@%s",
2101 fsname, stream_snapname);
2102
2103 error = recv_rename(hdl, name, tryname,
2104 strlen(fsname)+1, newname, flags);
2105 if (error)
2106 needagain = B_TRUE;
2107 else
2108 progress = B_TRUE;
2109 }
2110
2111 if (strcmp(stream_snapname, fromsnap) == 0)
2112 fromguid = thisguid;
2113 }
2114
2115 /* check for delete */
2116 if (stream_nvfs == NULL) {
2117 if (!flags->force)
2118 continue;
2119
2120 error = recv_destroy(hdl, fsname, strlen(tofs)+1,
2121 newname, flags);
2122 if (error)
2123 needagain = B_TRUE;
2124 else
2125 progress = B_TRUE;
2126 continue;
2127 }
2128
2129 if (fromguid == 0) {
2130 if (flags->verbose) {
2131 (void) printf("local fs %s does not have "
2132 "fromsnap (%s in stream); must have "
2133 "been deleted locally; ignoring\n",
2134 fsname, fromsnap);
2135 }
2136 continue;
2137 }
2138
2139 VERIFY(0 == nvlist_lookup_string(stream_nvfs,
2140 "name", &stream_fsname));
2141 VERIFY(0 == nvlist_lookup_uint64(stream_nvfs,
2142 "parentfromsnap", &stream_parent_fromsnap_guid));
2143
2144 s1 = strrchr(fsname, '/');
2145 s2 = strrchr(stream_fsname, '/');
2146
2147 /*
2148 * Check for rename. If the exact receive path is specified, it
2149 * does not count as a rename, but we still need to check the
2150 * datasets beneath it.
2151 */
2152 if ((stream_parent_fromsnap_guid != 0 &&
2153 parent_fromsnap_guid != 0 &&
2154 stream_parent_fromsnap_guid != parent_fromsnap_guid) ||
2155 ((flags->isprefix || strcmp(tofs, fsname) != 0) &&
2156 (s1 != NULL) && (s2 != NULL) && strcmp(s1, s2) != 0)) {
2157 nvlist_t *parent;
2158 char tryname[ZFS_MAXNAMELEN];
2159
2160 parent = fsavl_find(local_avl,
2161 stream_parent_fromsnap_guid, NULL);
2162 /*
2163 * NB: parent might not be found if we used the
2164 * tosnap for stream_parent_fromsnap_guid,
2165 * because the parent is a newly-created fs;
2166 * we'll be able to rename it after we recv the
2167 * new fs.
2168 */
2169 if (parent != NULL) {
2170 char *pname;
2171
2172 VERIFY(0 == nvlist_lookup_string(parent, "name",
2173 &pname));
2174 (void) snprintf(tryname, sizeof (tryname),
2175 "%s%s", pname, strrchr(stream_fsname, '/'));
2176 } else {
2177 tryname[0] = '\0';
2178 if (flags->verbose) {
2179 (void) printf("local fs %s new parent "
2180 "not found\n", fsname);
2181 }
2182 }
2183
2184 newname[0] = '\0';
2185
2186 error = recv_rename(hdl, fsname, tryname,
2187 strlen(tofs)+1, newname, flags);
2188
2189 if (renamed != NULL && newname[0] != '\0') {
2190 VERIFY(0 == nvlist_add_boolean(renamed,
2191 newname));
2192 }
2193
2194 if (error)
2195 needagain = B_TRUE;
2196 else
2197 progress = B_TRUE;
2198 }
2199 }
2200
2201 fsavl_destroy(local_avl);
2202 nvlist_free(local_nv);
2203
2204 if (needagain && progress) {
2205 /* do another pass to fix up temporary names */
2206 if (flags->verbose)
2207 (void) printf("another pass:\n");
2208 goto again;
2209 }
2210
2211 return (needagain);
2212 }
2213
2214 static int
2215 zfs_receive_package(libzfs_handle_t *hdl, int fd, const char *destname,
2216 recvflags_t *flags, dmu_replay_record_t *drr, zio_cksum_t *zc,
2217 char **top_zfs, int cleanup_fd, uint64_t *action_handlep)
2218 {
2219 nvlist_t *stream_nv = NULL;
2220 avl_tree_t *stream_avl = NULL;
2221 char *fromsnap = NULL;
2222 char *cp;
2223 char tofs[ZFS_MAXNAMELEN];
2224 char sendfs[ZFS_MAXNAMELEN];
2225 char errbuf[1024];
2226 dmu_replay_record_t drre;
2227 int error;
2228 boolean_t anyerr = B_FALSE;
2229 boolean_t softerr = B_FALSE;
2230 boolean_t recursive;
2231
2232 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2233 "cannot receive"));
2234
2235 assert(drr->drr_type == DRR_BEGIN);
2236 assert(drr->drr_u.drr_begin.drr_magic == DMU_BACKUP_MAGIC);
2237 assert(DMU_GET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo) ==
2238 DMU_COMPOUNDSTREAM);
2239
2240 /*
2241 * Read in the nvlist from the stream.
2242 */
2243 if (drr->drr_payloadlen != 0) {
2244 error = recv_read_nvlist(hdl, fd, drr->drr_payloadlen,
2245 &stream_nv, flags->byteswap, zc);
2246 if (error) {
2247 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2248 goto out;
2249 }
2250 }
2251
2252 recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") ==
2253 ENOENT);
2254
2255 if (recursive && strchr(destname, '@')) {
2256 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2257 "cannot specify snapshot name for multi-snapshot stream"));
2258 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2259 goto out;
2260 }
2261
2262 /*
2263 * Read in the end record and verify checksum.
2264 */
2265 if (0 != (error = recv_read(hdl, fd, &drre, sizeof (drre),
2266 flags->byteswap, NULL)))
2267 goto out;
2268 if (flags->byteswap) {
2269 drre.drr_type = BSWAP_32(drre.drr_type);
2270 drre.drr_u.drr_end.drr_checksum.zc_word[0] =
2271 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[0]);
2272 drre.drr_u.drr_end.drr_checksum.zc_word[1] =
2273 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[1]);
2274 drre.drr_u.drr_end.drr_checksum.zc_word[2] =
2275 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[2]);
2276 drre.drr_u.drr_end.drr_checksum.zc_word[3] =
2277 BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[3]);
2278 }
2279 if (drre.drr_type != DRR_END) {
2280 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2281 goto out;
2282 }
2283 if (!ZIO_CHECKSUM_EQUAL(drre.drr_u.drr_end.drr_checksum, *zc)) {
2284 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2285 "incorrect header checksum"));
2286 error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2287 goto out;
2288 }
2289
2290 (void) nvlist_lookup_string(stream_nv, "fromsnap", &fromsnap);
2291
2292 if (drr->drr_payloadlen != 0) {
2293 nvlist_t *stream_fss;
2294
2295 VERIFY(0 == nvlist_lookup_nvlist(stream_nv, "fss",
2296 &stream_fss));
2297 if ((stream_avl = fsavl_create(stream_fss)) == NULL) {
2298 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2299 "couldn't allocate avl tree"));
2300 error = zfs_error(hdl, EZFS_NOMEM, errbuf);
2301 goto out;
2302 }
2303
2304 if (fromsnap != NULL) {
2305 nvlist_t *renamed = NULL;
2306 nvpair_t *pair = NULL;
2307
2308 (void) strlcpy(tofs, destname, ZFS_MAXNAMELEN);
2309 if (flags->isprefix) {
2310 struct drr_begin *drrb = &drr->drr_u.drr_begin;
2311 int i;
2312
2313 if (flags->istail) {
2314 cp = strrchr(drrb->drr_toname, '/');
2315 if (cp == NULL) {
2316 (void) strlcat(tofs, "/",
2317 ZFS_MAXNAMELEN);
2318 i = 0;
2319 } else {
2320 i = (cp - drrb->drr_toname);
2321 }
2322 } else {
2323 i = strcspn(drrb->drr_toname, "/@");
2324 }
2325 /* zfs_receive_one() will create_parents() */
2326 (void) strlcat(tofs, &drrb->drr_toname[i],
2327 ZFS_MAXNAMELEN);
2328 *strchr(tofs, '@') = '\0';
2329 }
2330
2331 if (recursive && !flags->dryrun && !flags->nomount) {
2332 VERIFY(0 == nvlist_alloc(&renamed,
2333 NV_UNIQUE_NAME, 0));
2334 }
2335
2336 softerr = recv_incremental_replication(hdl, tofs, flags,
2337 stream_nv, stream_avl, renamed);
2338
2339 /* Unmount renamed filesystems before receiving. */
2340 while ((pair = nvlist_next_nvpair(renamed,
2341 pair)) != NULL) {
2342 zfs_handle_t *zhp;
2343 prop_changelist_t *clp = NULL;
2344
2345 zhp = zfs_open(hdl, nvpair_name(pair),
2346 ZFS_TYPE_FILESYSTEM);
2347 if (zhp != NULL) {
2348 clp = changelist_gather(zhp,
2349 ZFS_PROP_MOUNTPOINT, 0, 0);
2350 zfs_close(zhp);
2351 if (clp != NULL) {
2352 softerr |=
2353 changelist_prefix(clp);
2354 changelist_free(clp);
2355 }
2356 }
2357 }
2358
2359 nvlist_free(renamed);
2360 }
2361 }
2362
2363 /*
2364 * Get the fs specified by the first path in the stream (the top level
2365 * specified by 'zfs send') and pass it to each invocation of
2366 * zfs_receive_one().
2367 */
2368 (void) strlcpy(sendfs, drr->drr_u.drr_begin.drr_toname,
2369 ZFS_MAXNAMELEN);
2370 if ((cp = strchr(sendfs, '@')) != NULL)
2371 *cp = '\0';
2372
2373 /* Finally, receive each contained stream */
2374 do {
2375 /*
2376 * we should figure out if it has a recoverable
2377 * error, in which case do a recv_skip() and drive on.
2378 * Note, if we fail due to already having this guid,
2379 * zfs_receive_one() will take care of it (ie,
2380 * recv_skip() and return 0).
2381 */
2382 error = zfs_receive_impl(hdl, destname, flags, fd,
2383 sendfs, stream_nv, stream_avl, top_zfs, cleanup_fd,
2384 action_handlep);
2385 if (error == ENODATA) {
2386 error = 0;
2387 break;
2388 }
2389 anyerr |= error;
2390 } while (error == 0);
2391
2392 if (drr->drr_payloadlen != 0 && fromsnap != NULL) {
2393 /*
2394 * Now that we have the fs's they sent us, try the
2395 * renames again.
2396 */
2397 softerr = recv_incremental_replication(hdl, tofs, flags,
2398 stream_nv, stream_avl, NULL);
2399 }
2400
2401 out:
2402 fsavl_destroy(stream_avl);
2403 if (stream_nv)
2404 nvlist_free(stream_nv);
2405 if (softerr)
2406 error = -2;
2407 if (anyerr)
2408 error = -1;
2409 return (error);
2410 }
2411
2412 static void
2413 trunc_prop_errs(int truncated)
2414 {
2415 ASSERT(truncated != 0);
2416
2417 if (truncated == 1)
2418 (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
2419 "1 more property could not be set\n"));
2420 else
2421 (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
2422 "%d more properties could not be set\n"), truncated);
2423 }
2424
2425 static int
2426 recv_skip(libzfs_handle_t *hdl, int fd, boolean_t byteswap)
2427 {
2428 dmu_replay_record_t *drr;
2429 void *buf = malloc(1<<20);
2430 char errbuf[1024];
2431
2432 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2433 "cannot receive:"));
2434
2435 /* XXX would be great to use lseek if possible... */
2436 drr = buf;
2437
2438 while (recv_read(hdl, fd, drr, sizeof (dmu_replay_record_t),
2439 byteswap, NULL) == 0) {
2440 if (byteswap)
2441 drr->drr_type = BSWAP_32(drr->drr_type);
2442
2443 switch (drr->drr_type) {
2444 case DRR_BEGIN:
2445 /* NB: not to be used on v2 stream packages */
2446 if (drr->drr_payloadlen != 0) {
2447 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2448 "invalid substream header"));
2449 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
2450 }
2451 break;
2452
2453 case DRR_END:
2454 free(buf);
2455 return (0);
2456
2457 case DRR_OBJECT:
2458 if (byteswap) {
2459 drr->drr_u.drr_object.drr_bonuslen =
2460 BSWAP_32(drr->drr_u.drr_object.
2461 drr_bonuslen);
2462 }
2463 (void) recv_read(hdl, fd, buf,
2464 P2ROUNDUP(drr->drr_u.drr_object.drr_bonuslen, 8),
2465 B_FALSE, NULL);
2466 break;
2467
2468 case DRR_WRITE:
2469 if (byteswap) {
2470 drr->drr_u.drr_write.drr_length =
2471 BSWAP_64(drr->drr_u.drr_write.drr_length);
2472 }
2473 (void) recv_read(hdl, fd, buf,
2474 drr->drr_u.drr_write.drr_length, B_FALSE, NULL);
2475 break;
2476 case DRR_SPILL:
2477 if (byteswap) {
2478 drr->drr_u.drr_write.drr_length =
2479 BSWAP_64(drr->drr_u.drr_spill.drr_length);
2480 }
2481 (void) recv_read(hdl, fd, buf,
2482 drr->drr_u.drr_spill.drr_length, B_FALSE, NULL);
2483 break;
2484 case DRR_WRITE_BYREF:
2485 case DRR_FREEOBJECTS:
2486 case DRR_FREE:
2487 break;
2488
2489 default:
2490 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2491 "invalid record type"));
2492 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
2493 }
2494 }
2495
2496 free(buf);
2497 return (-1);
2498 }
2499
2500 /*
2501 * Restores a backup of tosnap from the file descriptor specified by infd.
2502 */
2503 static int
2504 zfs_receive_one(libzfs_handle_t *hdl, int infd, const char *tosnap,
2505 recvflags_t *flags, dmu_replay_record_t *drr,
2506 dmu_replay_record_t *drr_noswap, const char *sendfs,
2507 nvlist_t *stream_nv, avl_tree_t *stream_avl, char **top_zfs, int cleanup_fd,
2508 uint64_t *action_handlep)
2509 {
2510 zfs_cmd_t zc = { 0 };
2511 time_t begin_time;
2512 int ioctl_err, ioctl_errno, err;
2513 char *cp;
2514 struct drr_begin *drrb = &drr->drr_u.drr_begin;
2515 char errbuf[1024];
2516 char prop_errbuf[1024];
2517 const char *chopprefix;
2518 boolean_t newfs = B_FALSE;
2519 boolean_t stream_wantsnewfs;
2520 uint64_t parent_snapguid = 0;
2521 prop_changelist_t *clp = NULL;
2522 nvlist_t *snapprops_nvlist = NULL;
2523 zprop_errflags_t prop_errflags;
2524 boolean_t recursive;
2525
2526 begin_time = time(NULL);
2527
2528 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2529 "cannot receive"));
2530
2531 recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") ==
2532 ENOENT);
2533
2534 if (stream_avl != NULL) {
2535 char *snapname;
2536 nvlist_t *fs = fsavl_find(stream_avl, drrb->drr_toguid,
2537 &snapname);
2538 nvlist_t *props;
2539 int ret;
2540
2541 (void) nvlist_lookup_uint64(fs, "parentfromsnap",
2542 &parent_snapguid);
2543 err = nvlist_lookup_nvlist(fs, "props", &props);
2544 if (err)
2545 VERIFY(0 == nvlist_alloc(&props, NV_UNIQUE_NAME, 0));
2546
2547 if (flags->canmountoff) {
2548 VERIFY(0 == nvlist_add_uint64(props,
2549 zfs_prop_to_name(ZFS_PROP_CANMOUNT), 0));
2550 }
2551 ret = zcmd_write_src_nvlist(hdl, &zc, props);
2552 if (err)
2553 nvlist_free(props);
2554
2555 if (0 == nvlist_lookup_nvlist(fs, "snapprops", &props)) {
2556 VERIFY(0 == nvlist_lookup_nvlist(props,
2557 snapname, &snapprops_nvlist));
2558 }
2559
2560 if (ret != 0)
2561 return (-1);
2562 }
2563
2564 cp = NULL;
2565
2566 /*
2567 * Determine how much of the snapshot name stored in the stream
2568 * we are going to tack on to the name they specified on the
2569 * command line, and how much we are going to chop off.
2570 *
2571 * If they specified a snapshot, chop the entire name stored in
2572 * the stream.
2573 */
2574 if (flags->istail) {
2575 /*
2576 * A filesystem was specified with -e. We want to tack on only
2577 * the tail of the sent snapshot path.
2578 */
2579 if (strchr(tosnap, '@')) {
2580 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
2581 "argument - snapshot not allowed with -e"));
2582 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2583 }
2584
2585 chopprefix = strrchr(sendfs, '/');
2586
2587 if (chopprefix == NULL) {
2588 /*
2589 * The tail is the poolname, so we need to
2590 * prepend a path separator.
2591 */
2592 int len = strlen(drrb->drr_toname);
2593 cp = malloc(len + 2);
2594 cp[0] = '/';
2595 (void) strcpy(&cp[1], drrb->drr_toname);
2596 chopprefix = cp;
2597 } else {
2598 chopprefix = drrb->drr_toname + (chopprefix - sendfs);
2599 }
2600 } else if (flags->isprefix) {
2601 /*
2602 * A filesystem was specified with -d. We want to tack on
2603 * everything but the first element of the sent snapshot path
2604 * (all but the pool name).
2605 */
2606 if (strchr(tosnap, '@')) {
2607 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
2608 "argument - snapshot not allowed with -d"));
2609 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2610 }
2611
2612 chopprefix = strchr(drrb->drr_toname, '/');
2613 if (chopprefix == NULL)
2614 chopprefix = strchr(drrb->drr_toname, '@');
2615 } else if (strchr(tosnap, '@') == NULL) {
2616 /*
2617 * If a filesystem was specified without -d or -e, we want to
2618 * tack on everything after the fs specified by 'zfs send'.
2619 */
2620 chopprefix = drrb->drr_toname + strlen(sendfs);
2621 } else {
2622 /* A snapshot was specified as an exact path (no -d or -e). */
2623 if (recursive) {
2624 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2625 "cannot specify snapshot name for multi-snapshot "
2626 "stream"));
2627 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
2628 }
2629 chopprefix = drrb->drr_toname + strlen(drrb->drr_toname);
2630 }
2631
2632 ASSERT(strstr(drrb->drr_toname, sendfs) == drrb->drr_toname);
2633 ASSERT(chopprefix > drrb->drr_toname);
2634 ASSERT(chopprefix <= drrb->drr_toname + strlen(drrb->drr_toname));
2635 ASSERT(chopprefix[0] == '/' || chopprefix[0] == '@' ||
2636 chopprefix[0] == '\0');
2637
2638 /*
2639 * Determine name of destination snapshot, store in zc_value.
2640 */
2641 (void) strcpy(zc.zc_value, tosnap);
2642 (void) strncat(zc.zc_value, chopprefix, sizeof (zc.zc_value));
2643 free(cp);
2644 if (!zfs_name_valid(zc.zc_value, ZFS_TYPE_SNAPSHOT)) {
2645 zcmd_free_nvlists(&zc);
2646 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2647 }
2648
2649 /*
2650 * Determine the name of the origin snapshot, store in zc_string.
2651 */
2652 if (drrb->drr_flags & DRR_FLAG_CLONE) {
2653 if (guid_to_name(hdl, zc.zc_value,
2654 drrb->drr_fromguid, zc.zc_string) != 0) {
2655 zcmd_free_nvlists(&zc);
2656 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2657 "local origin for clone %s does not exist"),
2658 zc.zc_value);
2659 return (zfs_error(hdl, EZFS_NOENT, errbuf));
2660 }
2661 if (flags->verbose)
2662 (void) printf("found clone origin %s\n", zc.zc_string);
2663 }
2664
2665 stream_wantsnewfs = (drrb->drr_fromguid == NULL ||
2666 (drrb->drr_flags & DRR_FLAG_CLONE));
2667
2668 if (stream_wantsnewfs) {
2669 /*
2670 * if the parent fs does not exist, look for it based on
2671 * the parent snap GUID
2672 */
2673 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2674 "cannot receive new filesystem stream"));
2675
2676 (void) strcpy(zc.zc_name, zc.zc_value);
2677 cp = strrchr(zc.zc_name, '/');
2678 if (cp)
2679 *cp = '\0';
2680 if (cp &&
2681 !zfs_dataset_exists(hdl, zc.zc_name, ZFS_TYPE_DATASET)) {
2682 char suffix[ZFS_MAXNAMELEN];
2683 (void) strcpy(suffix, strrchr(zc.zc_value, '/'));
2684 if (guid_to_name(hdl, zc.zc_name, parent_snapguid,
2685 zc.zc_value) == 0) {
2686 *strchr(zc.zc_value, '@') = '\0';
2687 (void) strcat(zc.zc_value, suffix);
2688 }
2689 }
2690 } else {
2691 /*
2692 * if the fs does not exist, look for it based on the
2693 * fromsnap GUID
2694 */
2695 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2696 "cannot receive incremental stream"));
2697
2698 (void) strcpy(zc.zc_name, zc.zc_value);
2699 *strchr(zc.zc_name, '@') = '\0';
2700
2701 /*
2702 * If the exact receive path was specified and this is the
2703 * topmost path in the stream, then if the fs does not exist we
2704 * should look no further.
2705 */
2706 if ((flags->isprefix || (*(chopprefix = drrb->drr_toname +
2707 strlen(sendfs)) != '\0' && *chopprefix != '@')) &&
2708 !zfs_dataset_exists(hdl, zc.zc_name, ZFS_TYPE_DATASET)) {
2709 char snap[ZFS_MAXNAMELEN];
2710 (void) strcpy(snap, strchr(zc.zc_value, '@'));
2711 if (guid_to_name(hdl, zc.zc_name, drrb->drr_fromguid,
2712 zc.zc_value) == 0) {
2713 *strchr(zc.zc_value, '@') = '\0';
2714 (void) strcat(zc.zc_value, snap);
2715 }
2716 }
2717 }
2718
2719 (void) strcpy(zc.zc_name, zc.zc_value);
2720 *strchr(zc.zc_name, '@') = '\0';
2721
2722 if (zfs_dataset_exists(hdl, zc.zc_name, ZFS_TYPE_DATASET)) {
2723 zfs_handle_t *zhp;
2724
2725 /*
2726 * Destination fs exists. Therefore this should either
2727 * be an incremental, or the stream specifies a new fs
2728 * (full stream or clone) and they want us to blow it
2729 * away (and have therefore specified -F and removed any
2730 * snapshots).
2731 */
2732 if (stream_wantsnewfs) {
2733 if (!flags->force) {
2734 zcmd_free_nvlists(&zc);
2735 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2736 "destination '%s' exists\n"
2737 "must specify -F to overwrite it"),
2738 zc.zc_name);
2739 return (zfs_error(hdl, EZFS_EXISTS, errbuf));
2740 }
2741 if (ioctl(hdl->libzfs_fd, ZFS_IOC_SNAPSHOT_LIST_NEXT,
2742 &zc) == 0) {
2743 zcmd_free_nvlists(&zc);
2744 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2745 "destination has snapshots (eg. %s)\n"
2746 "must destroy them to overwrite it"),
2747 zc.zc_name);
2748 return (zfs_error(hdl, EZFS_EXISTS, errbuf));
2749 }
2750 }
2751
2752 if ((zhp = zfs_open(hdl, zc.zc_name,
2753 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME)) == NULL) {
2754 zcmd_free_nvlists(&zc);
2755 return (-1);
2756 }
2757
2758 if (stream_wantsnewfs &&
2759 zhp->zfs_dmustats.dds_origin[0]) {
2760 zcmd_free_nvlists(&zc);
2761 zfs_close(zhp);
2762 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2763 "destination '%s' is a clone\n"
2764 "must destroy it to overwrite it"),
2765 zc.zc_name);
2766 return (zfs_error(hdl, EZFS_EXISTS, errbuf));
2767 }
2768
2769 if (!flags->dryrun && zhp->zfs_type == ZFS_TYPE_FILESYSTEM &&
2770 stream_wantsnewfs) {
2771 /* We can't do online recv in this case */
2772 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0, 0);
2773 if (clp == NULL) {
2774 zfs_close(zhp);
2775 zcmd_free_nvlists(&zc);
2776 return (-1);
2777 }
2778 if (changelist_prefix(clp) != 0) {
2779 changelist_free(clp);
2780 zfs_close(zhp);
2781 zcmd_free_nvlists(&zc);
2782 return (-1);
2783 }
2784 }
2785 zfs_close(zhp);
2786 } else {
2787 /*
2788 * Destination filesystem does not exist. Therefore we better
2789 * be creating a new filesystem (either from a full backup, or
2790 * a clone). It would therefore be invalid if the user
2791 * specified only the pool name (i.e. if the destination name
2792 * contained no slash character).
2793 */
2794 if (!stream_wantsnewfs ||
2795 (cp = strrchr(zc.zc_name, '/')) == NULL) {
2796 zcmd_free_nvlists(&zc);
2797 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2798 "destination '%s' does not exist"), zc.zc_name);
2799 return (zfs_error(hdl, EZFS_NOENT, errbuf));
2800 }
2801
2802 /*
2803 * Trim off the final dataset component so we perform the
2804 * recvbackup ioctl to the filesystems's parent.
2805 */
2806 *cp = '\0';
2807
2808 if (flags->isprefix && !flags->istail && !flags->dryrun &&
2809 create_parents(hdl, zc.zc_value, strlen(tosnap)) != 0) {
2810 zcmd_free_nvlists(&zc);
2811 return (zfs_error(hdl, EZFS_BADRESTORE, errbuf));
2812 }
2813
2814 newfs = B_TRUE;
2815 }
2816
2817 zc.zc_begin_record = drr_noswap->drr_u.drr_begin;
2818 zc.zc_cookie = infd;
2819 zc.zc_guid = flags->force;
2820 if (flags->verbose) {
2821 (void) printf("%s %s stream of %s into %s\n",
2822 flags->dryrun ? "would receive" : "receiving",
2823 drrb->drr_fromguid ? "incremental" : "full",
2824 drrb->drr_toname, zc.zc_value);
2825 (void) fflush(stdout);
2826 }
2827
2828 if (flags->dryrun) {
2829 zcmd_free_nvlists(&zc);
2830 return (recv_skip(hdl, infd, flags->byteswap));
2831 }
2832
2833 zc.zc_nvlist_dst = (uint64_t)(uintptr_t)prop_errbuf;
2834 zc.zc_nvlist_dst_size = sizeof (prop_errbuf);
2835 zc.zc_cleanup_fd = cleanup_fd;
2836 zc.zc_action_handle = *action_handlep;
2837
2838 err = ioctl_err = zfs_ioctl(hdl, ZFS_IOC_RECV, &zc);
2839 ioctl_errno = errno;
2840 prop_errflags = (zprop_errflags_t)zc.zc_obj;
2841
2842 if (err == 0) {
2843 nvlist_t *prop_errors;
2844 VERIFY(0 == nvlist_unpack((void *)(uintptr_t)zc.zc_nvlist_dst,
2845 zc.zc_nvlist_dst_size, &prop_errors, 0));
2846
2847 nvpair_t *prop_err = NULL;
2848
2849 while ((prop_err = nvlist_next_nvpair(prop_errors,
2850 prop_err)) != NULL) {
2851 char tbuf[1024];
2852 zfs_prop_t prop;
2853 int intval;
2854
2855 prop = zfs_name_to_prop(nvpair_name(prop_err));
2856 (void) nvpair_value_int32(prop_err, &intval);
2857 if (strcmp(nvpair_name(prop_err),
2858 ZPROP_N_MORE_ERRORS) == 0) {
2859 trunc_prop_errs(intval);
2860 break;
2861 } else {
2862 (void) snprintf(tbuf, sizeof (tbuf),
2863 dgettext(TEXT_DOMAIN,
2864 "cannot receive %s property on %s"),
2865 nvpair_name(prop_err), zc.zc_name);
2866 zfs_setprop_error(hdl, prop, intval, tbuf);
2867 }
2868 }
2869 nvlist_free(prop_errors);
2870 }
2871
2872 zc.zc_nvlist_dst = 0;
2873 zc.zc_nvlist_dst_size = 0;
2874 zcmd_free_nvlists(&zc);
2875
2876 if (err == 0 && snapprops_nvlist) {
2877 zfs_cmd_t zc2 = { 0 };
2878
2879 (void) strcpy(zc2.zc_name, zc.zc_value);
2880 zc2.zc_cookie = B_TRUE; /* received */
2881 if (zcmd_write_src_nvlist(hdl, &zc2, snapprops_nvlist) == 0) {
2882 (void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc2);
2883 zcmd_free_nvlists(&zc2);
2884 }
2885 }
2886
2887 if (err && (ioctl_errno == ENOENT || ioctl_errno == EEXIST)) {
2888 /*
2889 * It may be that this snapshot already exists,
2890 * in which case we want to consume & ignore it
2891 * rather than failing.
2892 */
2893 avl_tree_t *local_avl;
2894 nvlist_t *local_nv, *fs;
2895 cp = strchr(zc.zc_value, '@');
2896
2897 /*
2898 * XXX Do this faster by just iterating over snaps in
2899 * this fs. Also if zc_value does not exist, we will
2900 * get a strange "does not exist" error message.
2901 */
2902 *cp = '\0';
2903 if (gather_nvlist(hdl, zc.zc_value, NULL, NULL, B_FALSE,
2904 &local_nv, &local_avl) == 0) {
2905 *cp = '@';
2906 fs = fsavl_find(local_avl, drrb->drr_toguid, NULL);
2907 fsavl_destroy(local_avl);
2908 nvlist_free(local_nv);
2909
2910 if (fs != NULL) {
2911 if (flags->verbose) {
2912 (void) printf("snap %s already exists; "
2913 "ignoring\n", zc.zc_value);
2914 }
2915 err = ioctl_err = recv_skip(hdl, infd,
2916 flags->byteswap);
2917 }
2918 }
2919 *cp = '@';
2920 }
2921
2922 if (ioctl_err != 0) {
2923 switch (ioctl_errno) {
2924 case ENODEV:
2925 cp = strchr(zc.zc_value, '@');
2926 *cp = '\0';
2927 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2928 "most recent snapshot of %s does not\n"
2929 "match incremental source"), zc.zc_value);
2930 (void) zfs_error(hdl, EZFS_BADRESTORE, errbuf);
2931 *cp = '@';
2932 break;
2933 case ETXTBSY:
2934 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2935 "destination %s has been modified\n"
2936 "since most recent snapshot"), zc.zc_name);
2937 (void) zfs_error(hdl, EZFS_BADRESTORE, errbuf);
2938 break;
2939 case EEXIST:
2940 cp = strchr(zc.zc_value, '@');
2941 if (newfs) {
2942 /* it's the containing fs that exists */
2943 *cp = '\0';
2944 }
2945 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2946 "destination already exists"));
2947 (void) zfs_error_fmt(hdl, EZFS_EXISTS,
2948 dgettext(TEXT_DOMAIN, "cannot restore to %s"),
2949 zc.zc_value);
2950 *cp = '@';
2951 break;
2952 case EINVAL:
2953 (void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2954 break;
2955 case ECKSUM:
2956 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2957 "invalid stream (checksum mismatch)"));
2958 (void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2959 break;
2960 case ENOTSUP:
2961 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2962 "pool must be upgraded to receive this stream."));
2963 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
2964 break;
2965 case EDQUOT:
2966 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2967 "destination %s space quota exceeded"), zc.zc_name);
2968 (void) zfs_error(hdl, EZFS_NOSPC, errbuf);
2969 break;
2970 default:
2971 (void) zfs_standard_error(hdl, ioctl_errno, errbuf);
2972 }
2973 }
2974
2975 /*
2976 * Mount the target filesystem (if created). Also mount any
2977 * children of the target filesystem if we did a replication
2978 * receive (indicated by stream_avl being non-NULL).
2979 */
2980 cp = strchr(zc.zc_value, '@');
2981 if (cp && (ioctl_err == 0 || !newfs)) {
2982 zfs_handle_t *h;
2983
2984 *cp = '\0';
2985 h = zfs_open(hdl, zc.zc_value,
2986 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
2987 if (h != NULL) {
2988 if (h->zfs_type == ZFS_TYPE_VOLUME) {
2989 *cp = '@';
2990 } else if (newfs || stream_avl) {
2991 /*
2992 * Track the first/top of hierarchy fs,
2993 * for mounting and sharing later.
2994 */
2995 if (top_zfs && *top_zfs == NULL)
2996 *top_zfs = zfs_strdup(hdl, zc.zc_value);
2997 }
2998 zfs_close(h);
2999 }
3000 *cp = '@';
3001 }
3002
3003 if (clp) {
3004 err |= changelist_postfix(clp);
3005 changelist_free(clp);
3006 }
3007
3008 if (prop_errflags & ZPROP_ERR_NOCLEAR) {
3009 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Warning: "
3010 "failed to clear unreceived properties on %s"),
3011 zc.zc_name);
3012 (void) fprintf(stderr, "\n");
3013 }
3014 if (prop_errflags & ZPROP_ERR_NORESTORE) {
3015 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Warning: "
3016 "failed to restore original properties on %s"),
3017 zc.zc_name);
3018 (void) fprintf(stderr, "\n");
3019 }
3020
3021 if (err || ioctl_err)
3022 return (-1);
3023
3024 *action_handlep = zc.zc_action_handle;
3025
3026 if (flags->verbose) {
3027 char buf1[64];
3028 char buf2[64];
3029 uint64_t bytes = zc.zc_cookie;
3030 time_t delta = time(NULL) - begin_time;
3031 if (delta == 0)
3032 delta = 1;
3033 zfs_nicenum(bytes, buf1, sizeof (buf1));
3034 zfs_nicenum(bytes/delta, buf2, sizeof (buf1));
3035
3036 (void) printf("received %sB stream in %lu seconds (%sB/sec)\n",
3037 buf1, delta, buf2);
3038 }
3039
3040 return (0);
3041 }
3042
3043 static int
3044 zfs_receive_impl(libzfs_handle_t *hdl, const char *tosnap, recvflags_t *flags,
3045 int infd, const char *sendfs, nvlist_t *stream_nv, avl_tree_t *stream_avl,
3046 char **top_zfs, int cleanup_fd, uint64_t *action_handlep)
3047 {
3048 int err;
3049 dmu_replay_record_t drr, drr_noswap;
3050 struct drr_begin *drrb = &drr.drr_u.drr_begin;
3051 char errbuf[1024];
3052 zio_cksum_t zcksum = { 0 };
3053 uint64_t featureflags;
3054 int hdrtype;
3055
3056 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3057 "cannot receive"));
3058
3059 if (flags->isprefix &&
3060 !zfs_dataset_exists(hdl, tosnap, ZFS_TYPE_DATASET)) {
3061 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "specified fs "
3062 "(%s) does not exist"), tosnap);
3063 return (zfs_error(hdl, EZFS_NOENT, errbuf));
3064 }
3065
3066 /* read in the BEGIN record */
3067 if (0 != (err = recv_read(hdl, infd, &drr, sizeof (drr), B_FALSE,
3068 &zcksum)))
3069 return (err);
3070
3071 if (drr.drr_type == DRR_END || drr.drr_type == BSWAP_32(DRR_END)) {
3072 /* It's the double end record at the end of a package */
3073 return (ENODATA);
3074 }
3075
3076 /* the kernel needs the non-byteswapped begin record */
3077 drr_noswap = drr;
3078
3079 flags->byteswap = B_FALSE;
3080 if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) {
3081 /*
3082 * We computed the checksum in the wrong byteorder in
3083 * recv_read() above; do it again correctly.
3084 */
3085 bzero(&zcksum, sizeof (zio_cksum_t));
3086 fletcher_4_incremental_byteswap(&drr, sizeof (drr), &zcksum);
3087 flags->byteswap = B_TRUE;
3088
3089 drr.drr_type = BSWAP_32(drr.drr_type);
3090 drr.drr_payloadlen = BSWAP_32(drr.drr_payloadlen);
3091 drrb->drr_magic = BSWAP_64(drrb->drr_magic);
3092 drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo);
3093 drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time);
3094 drrb->drr_type = BSWAP_32(drrb->drr_type);
3095 drrb->drr_flags = BSWAP_32(drrb->drr_flags);
3096 drrb->drr_toguid = BSWAP_64(drrb->drr_toguid);
3097 drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid);
3098 }
3099
3100 if (drrb->drr_magic != DMU_BACKUP_MAGIC || drr.drr_type != DRR_BEGIN) {
3101 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
3102 "stream (bad magic number)"));
3103 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
3104 }
3105
3106 featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo);
3107 hdrtype = DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo);
3108
3109 if (!DMU_STREAM_SUPPORTED(featureflags) ||
3110 (hdrtype != DMU_SUBSTREAM && hdrtype != DMU_COMPOUNDSTREAM)) {
3111 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3112 "stream has unsupported feature, feature flags = %lx"),
3113 featureflags);
3114 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
3115 }
3116
3117 if (strchr(drrb->drr_toname, '@') == NULL) {
3118 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
3119 "stream (bad snapshot name)"));
3120 return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
3121 }
3122
3123 if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == DMU_SUBSTREAM) {
3124 char nonpackage_sendfs[ZFS_MAXNAMELEN];
3125 if (sendfs == NULL) {
3126 /*
3127 * We were not called from zfs_receive_package(). Get
3128 * the fs specified by 'zfs send'.
3129 */
3130 char *cp;
3131 (void) strlcpy(nonpackage_sendfs,
3132 drr.drr_u.drr_begin.drr_toname, ZFS_MAXNAMELEN);
3133 if ((cp = strchr(nonpackage_sendfs, '@')) != NULL)
3134 *cp = '\0';
3135 sendfs = nonpackage_sendfs;
3136 }
3137 return (zfs_receive_one(hdl, infd, tosnap, flags,
3138 &drr, &drr_noswap, sendfs, stream_nv, stream_avl,
3139 top_zfs, cleanup_fd, action_handlep));
3140 } else {
3141 assert(DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) ==
3142 DMU_COMPOUNDSTREAM);
3143 return (zfs_receive_package(hdl, infd, tosnap, flags,
3144 &drr, &zcksum, top_zfs, cleanup_fd, action_handlep));
3145 }
3146 }
3147
3148 /*
3149 * Restores a backup of tosnap from the file descriptor specified by infd.
3150 * Return 0 on total success, -2 if some things couldn't be
3151 * destroyed/renamed/promoted, -1 if some things couldn't be received.
3152 * (-1 will override -2).
3153 */
3154 int
3155 zfs_receive(libzfs_handle_t *hdl, const char *tosnap, recvflags_t *flags,
3156 int infd, avl_tree_t *stream_avl)
3157 {
3158 char *top_zfs = NULL;
3159 int err;
3160 int cleanup_fd;
3161 uint64_t action_handle = 0;
3162
3163 cleanup_fd = open(ZFS_DEV, O_RDWR|O_EXCL);
3164 VERIFY(cleanup_fd >= 0);
3165
3166 err = zfs_receive_impl(hdl, tosnap, flags, infd, NULL, NULL,
3167 stream_avl, &top_zfs, cleanup_fd, &action_handle);
3168
3169 VERIFY(0 == close(cleanup_fd));
3170
3171 if (err == 0 && !flags->nomount && top_zfs) {
3172 zfs_handle_t *zhp;
3173 prop_changelist_t *clp;
3174
3175 zhp = zfs_open(hdl, top_zfs, ZFS_TYPE_FILESYSTEM);
3176 if (zhp != NULL) {
3177 clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT,
3178 CL_GATHER_MOUNT_ALWAYS, 0);
3179 zfs_close(zhp);
3180 if (clp != NULL) {
3181 /* mount and share received datasets */
3182 err = changelist_postfix(clp);
3183 changelist_free(clp);
3184 }
3185 }
3186 if (zhp == NULL || clp == NULL || err)
3187 err = -1;
3188 }
3189 if (top_zfs)
3190 free(top_zfs);
3191
3192 return (err);
3193 }