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