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