4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2011, 2015 by Delphix. All rights reserved.
24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
26 * Copyright (c) 2011, 2014 by Delphix. All rights reserved.
30 #include <sys/dmu_impl.h>
31 #include <sys/dmu_tx.h>
33 #include <sys/dnode.h>
34 #include <sys/zfs_context.h>
35 #include <sys/dmu_objset.h>
36 #include <sys/dmu_traverse.h>
37 #include <sys/dsl_dataset.h>
38 #include <sys/dsl_dir.h>
39 #include <sys/dsl_prop.h>
40 #include <sys/dsl_pool.h>
41 #include <sys/dsl_synctask.h>
42 #include <sys/spa_impl.h>
43 #include <sys/zfs_ioctl.h>
45 #include <sys/zio_checksum.h>
46 #include <sys/zfs_znode.h>
47 #include <zfs_fletcher.h>
50 #include <sys/zfs_onexit.h>
51 #include <sys/dmu_send.h>
52 #include <sys/dsl_destroy.h>
53 #include <sys/blkptr.h>
54 #include <sys/dsl_bookmark.h>
55 #include <sys/zfeature.h>
57 /* Set this tunable to TRUE to replace corrupt data with 0x2f5baddb10c */
58 int zfs_send_corrupt_data = B_FALSE;
60 static char *dmu_recv_tag = "dmu_recv_tag";
61 static const char *recv_clone_name = "%recv";
63 typedef struct dump_bytes_io {
64 dmu_sendarg_t *dbi_dsp;
70 dump_bytes_cb(void *arg)
72 dump_bytes_io_t *dbi = (dump_bytes_io_t *)arg;
73 dmu_sendarg_t *dsp = dbi->dbi_dsp;
74 dsl_dataset_t *ds = dsp->dsa_os->os_dsl_dataset;
75 ssize_t resid; /* have to get resid to get detailed errno */
76 ASSERT0(dbi->dbi_len % 8);
78 fletcher_4_incremental_native(dbi->dbi_buf, dbi->dbi_len, &dsp->dsa_zc);
79 dsp->dsa_err = vn_rdwr(UIO_WRITE, dsp->dsa_vp,
80 (caddr_t)dbi->dbi_buf, dbi->dbi_len,
81 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid);
83 mutex_enter(&ds->ds_sendstream_lock);
84 *dsp->dsa_off += dbi->dbi_len;
85 mutex_exit(&ds->ds_sendstream_lock);
89 dump_bytes(dmu_sendarg_t *dsp, void *buf, int len)
97 #if defined(HAVE_LARGE_STACKS)
101 * The vn_rdwr() call is performed in a taskq to ensure that there is
102 * always enough stack space to write safely to the target filesystem.
103 * The ZIO_TYPE_FREE threads are used because there can be a lot of
104 * them and they are used in vdev_file.c for a similar purpose.
106 spa_taskq_dispatch_sync(dmu_objset_spa(dsp->dsa_os), ZIO_TYPE_FREE,
107 ZIO_TASKQ_ISSUE, dump_bytes_cb, &dbi, TQ_SLEEP);
108 #endif /* HAVE_LARGE_STACKS */
110 return (dsp->dsa_err);
114 dump_free(dmu_sendarg_t *dsp, uint64_t object, uint64_t offset,
117 struct drr_free *drrf = &(dsp->dsa_drr->drr_u.drr_free);
120 * When we receive a free record, dbuf_free_range() assumes
121 * that the receiving system doesn't have any dbufs in the range
122 * being freed. This is always true because there is a one-record
123 * constraint: we only send one WRITE record for any given
124 * object+offset. We know that the one-record constraint is
125 * true because we always send data in increasing order by
128 * If the increasing-order constraint ever changes, we should find
129 * another way to assert that the one-record constraint is still
132 ASSERT(object > dsp->dsa_last_data_object ||
133 (object == dsp->dsa_last_data_object &&
134 offset > dsp->dsa_last_data_offset));
137 * If we are doing a non-incremental send, then there can't
138 * be any data in the dataset we're receiving into. Therefore
139 * a free record would simply be a no-op. Save space by not
140 * sending it to begin with.
142 if (!dsp->dsa_incremental)
145 if (length != -1ULL && offset + length < offset)
149 * If there is a pending op, but it's not PENDING_FREE, push it out,
150 * since free block aggregation can only be done for blocks of the
151 * same type (i.e., DRR_FREE records can only be aggregated with
152 * other DRR_FREE records. DRR_FREEOBJECTS records can only be
153 * aggregated with other DRR_FREEOBJECTS records.
155 if (dsp->dsa_pending_op != PENDING_NONE &&
156 dsp->dsa_pending_op != PENDING_FREE) {
157 if (dump_bytes(dsp, dsp->dsa_drr,
158 sizeof (dmu_replay_record_t)) != 0)
159 return (SET_ERROR(EINTR));
160 dsp->dsa_pending_op = PENDING_NONE;
163 if (dsp->dsa_pending_op == PENDING_FREE) {
165 * There should never be a PENDING_FREE if length is -1
166 * (because dump_dnode is the only place where this
167 * function is called with a -1, and only after flushing
168 * any pending record).
170 ASSERT(length != -1ULL);
172 * Check to see whether this free block can be aggregated
175 if (drrf->drr_object == object && drrf->drr_offset +
176 drrf->drr_length == offset) {
177 drrf->drr_length += length;
180 /* not a continuation. Push out pending record */
181 if (dump_bytes(dsp, dsp->dsa_drr,
182 sizeof (dmu_replay_record_t)) != 0)
183 return (SET_ERROR(EINTR));
184 dsp->dsa_pending_op = PENDING_NONE;
187 /* create a FREE record and make it pending */
188 bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t));
189 dsp->dsa_drr->drr_type = DRR_FREE;
190 drrf->drr_object = object;
191 drrf->drr_offset = offset;
192 drrf->drr_length = length;
193 drrf->drr_toguid = dsp->dsa_toguid;
194 if (length == -1ULL) {
195 if (dump_bytes(dsp, dsp->dsa_drr,
196 sizeof (dmu_replay_record_t)) != 0)
197 return (SET_ERROR(EINTR));
199 dsp->dsa_pending_op = PENDING_FREE;
206 dump_write(dmu_sendarg_t *dsp, dmu_object_type_t type,
207 uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data)
209 struct drr_write *drrw = &(dsp->dsa_drr->drr_u.drr_write);
212 * We send data in increasing object, offset order.
213 * See comment in dump_free() for details.
215 ASSERT(object > dsp->dsa_last_data_object ||
216 (object == dsp->dsa_last_data_object &&
217 offset > dsp->dsa_last_data_offset));
218 dsp->dsa_last_data_object = object;
219 dsp->dsa_last_data_offset = offset + blksz - 1;
222 * If there is any kind of pending aggregation (currently either
223 * a grouping of free objects or free blocks), push it out to
224 * the stream, since aggregation can't be done across operations
225 * of different types.
227 if (dsp->dsa_pending_op != PENDING_NONE) {
228 if (dump_bytes(dsp, dsp->dsa_drr,
229 sizeof (dmu_replay_record_t)) != 0)
230 return (SET_ERROR(EINTR));
231 dsp->dsa_pending_op = PENDING_NONE;
233 /* write a DATA record */
234 bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t));
235 dsp->dsa_drr->drr_type = DRR_WRITE;
236 drrw->drr_object = object;
237 drrw->drr_type = type;
238 drrw->drr_offset = offset;
239 drrw->drr_length = blksz;
240 drrw->drr_toguid = dsp->dsa_toguid;
241 if (bp == NULL || BP_IS_EMBEDDED(bp)) {
243 * There's no pre-computed checksum for partial-block
244 * writes or embedded BP's, so (like
245 * fletcher4-checkummed blocks) userland will have to
246 * compute a dedup-capable checksum itself.
248 drrw->drr_checksumtype = ZIO_CHECKSUM_OFF;
250 drrw->drr_checksumtype = BP_GET_CHECKSUM(bp);
251 if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup)
252 drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP;
253 DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp));
254 DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp));
255 DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp));
256 drrw->drr_key.ddk_cksum = bp->blk_cksum;
259 if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0)
260 return (SET_ERROR(EINTR));
261 if (dump_bytes(dsp, data, blksz) != 0)
262 return (SET_ERROR(EINTR));
267 dump_write_embedded(dmu_sendarg_t *dsp, uint64_t object, uint64_t offset,
268 int blksz, const blkptr_t *bp)
270 char buf[BPE_PAYLOAD_SIZE];
271 struct drr_write_embedded *drrw =
272 &(dsp->dsa_drr->drr_u.drr_write_embedded);
274 if (dsp->dsa_pending_op != PENDING_NONE) {
275 if (dump_bytes(dsp, dsp->dsa_drr,
276 sizeof (dmu_replay_record_t)) != 0)
278 dsp->dsa_pending_op = PENDING_NONE;
281 ASSERT(BP_IS_EMBEDDED(bp));
283 bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t));
284 dsp->dsa_drr->drr_type = DRR_WRITE_EMBEDDED;
285 drrw->drr_object = object;
286 drrw->drr_offset = offset;
287 drrw->drr_length = blksz;
288 drrw->drr_toguid = dsp->dsa_toguid;
289 drrw->drr_compression = BP_GET_COMPRESS(bp);
290 drrw->drr_etype = BPE_GET_ETYPE(bp);
291 drrw->drr_lsize = BPE_GET_LSIZE(bp);
292 drrw->drr_psize = BPE_GET_PSIZE(bp);
294 decode_embedded_bp_compressed(bp, buf);
296 if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0)
298 if (dump_bytes(dsp, buf, P2ROUNDUP(drrw->drr_psize, 8)) != 0)
304 dump_spill(dmu_sendarg_t *dsp, uint64_t object, int blksz, void *data)
306 struct drr_spill *drrs = &(dsp->dsa_drr->drr_u.drr_spill);
308 if (dsp->dsa_pending_op != PENDING_NONE) {
309 if (dump_bytes(dsp, dsp->dsa_drr,
310 sizeof (dmu_replay_record_t)) != 0)
311 return (SET_ERROR(EINTR));
312 dsp->dsa_pending_op = PENDING_NONE;
315 /* write a SPILL record */
316 bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t));
317 dsp->dsa_drr->drr_type = DRR_SPILL;
318 drrs->drr_object = object;
319 drrs->drr_length = blksz;
320 drrs->drr_toguid = dsp->dsa_toguid;
322 if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)))
323 return (SET_ERROR(EINTR));
324 if (dump_bytes(dsp, data, blksz))
325 return (SET_ERROR(EINTR));
330 dump_freeobjects(dmu_sendarg_t *dsp, uint64_t firstobj, uint64_t numobjs)
332 struct drr_freeobjects *drrfo = &(dsp->dsa_drr->drr_u.drr_freeobjects);
334 /* See comment in dump_free(). */
335 if (!dsp->dsa_incremental)
339 * If there is a pending op, but it's not PENDING_FREEOBJECTS,
340 * push it out, since free block aggregation can only be done for
341 * blocks of the same type (i.e., DRR_FREE records can only be
342 * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records
343 * can only be aggregated with other DRR_FREEOBJECTS records.
345 if (dsp->dsa_pending_op != PENDING_NONE &&
346 dsp->dsa_pending_op != PENDING_FREEOBJECTS) {
347 if (dump_bytes(dsp, dsp->dsa_drr,
348 sizeof (dmu_replay_record_t)) != 0)
349 return (SET_ERROR(EINTR));
350 dsp->dsa_pending_op = PENDING_NONE;
352 if (dsp->dsa_pending_op == PENDING_FREEOBJECTS) {
354 * See whether this free object array can be aggregated
357 if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) {
358 drrfo->drr_numobjs += numobjs;
361 /* can't be aggregated. Push out pending record */
362 if (dump_bytes(dsp, dsp->dsa_drr,
363 sizeof (dmu_replay_record_t)) != 0)
364 return (SET_ERROR(EINTR));
365 dsp->dsa_pending_op = PENDING_NONE;
369 /* write a FREEOBJECTS record */
370 bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t));
371 dsp->dsa_drr->drr_type = DRR_FREEOBJECTS;
372 drrfo->drr_firstobj = firstobj;
373 drrfo->drr_numobjs = numobjs;
374 drrfo->drr_toguid = dsp->dsa_toguid;
376 dsp->dsa_pending_op = PENDING_FREEOBJECTS;
382 dump_dnode(dmu_sendarg_t *dsp, uint64_t object, dnode_phys_t *dnp)
384 struct drr_object *drro = &(dsp->dsa_drr->drr_u.drr_object);
386 if (dnp == NULL || dnp->dn_type == DMU_OT_NONE)
387 return (dump_freeobjects(dsp, object, 1));
389 if (dsp->dsa_pending_op != PENDING_NONE) {
390 if (dump_bytes(dsp, dsp->dsa_drr,
391 sizeof (dmu_replay_record_t)) != 0)
392 return (SET_ERROR(EINTR));
393 dsp->dsa_pending_op = PENDING_NONE;
396 /* write an OBJECT record */
397 bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t));
398 dsp->dsa_drr->drr_type = DRR_OBJECT;
399 drro->drr_object = object;
400 drro->drr_type = dnp->dn_type;
401 drro->drr_bonustype = dnp->dn_bonustype;
402 drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT;
403 drro->drr_bonuslen = dnp->dn_bonuslen;
404 drro->drr_checksumtype = dnp->dn_checksum;
405 drro->drr_compress = dnp->dn_compress;
406 drro->drr_toguid = dsp->dsa_toguid;
408 if (!(dsp->dsa_featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) &&
409 drro->drr_blksz > SPA_OLD_MAXBLOCKSIZE)
410 drro->drr_blksz = SPA_OLD_MAXBLOCKSIZE;
412 if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0)
413 return (SET_ERROR(EINTR));
415 if (dump_bytes(dsp, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0)
416 return (SET_ERROR(EINTR));
418 /* Free anything past the end of the file. */
419 if (dump_free(dsp, object, (dnp->dn_maxblkid + 1) *
420 (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL) != 0)
421 return (SET_ERROR(EINTR));
422 if (dsp->dsa_err != 0)
423 return (SET_ERROR(EINTR));
428 backup_do_embed(dmu_sendarg_t *dsp, const blkptr_t *bp)
430 if (!BP_IS_EMBEDDED(bp))
434 * Compression function must be legacy, or explicitly enabled.
436 if ((BP_GET_COMPRESS(bp) >= ZIO_COMPRESS_LEGACY_FUNCTIONS &&
437 !(dsp->dsa_featureflags & DMU_BACKUP_FEATURE_EMBED_DATA_LZ4)))
441 * Embed type must be explicitly enabled.
443 switch (BPE_GET_ETYPE(bp)) {
444 case BP_EMBEDDED_TYPE_DATA:
445 if (dsp->dsa_featureflags & DMU_BACKUP_FEATURE_EMBED_DATA)
454 #define BP_SPAN(dnp, level) \
455 (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \
456 (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT)))
460 backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
461 const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
463 dmu_sendarg_t *dsp = arg;
464 dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE;
467 if (issig(JUSTLOOKING) && issig(FORREAL))
468 return (SET_ERROR(EINTR));
470 if (zb->zb_object != DMU_META_DNODE_OBJECT &&
471 DMU_OBJECT_IS_SPECIAL(zb->zb_object)) {
473 } else if (zb->zb_level == ZB_ZIL_LEVEL) {
475 * If we are sending a non-snapshot (which is allowed on
476 * read-only pools), it may have a ZIL, which must be ignored.
479 } else if (BP_IS_HOLE(bp) &&
480 zb->zb_object == DMU_META_DNODE_OBJECT) {
481 uint64_t span = BP_SPAN(dnp, zb->zb_level);
482 uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT;
483 err = dump_freeobjects(dsp, dnobj, span >> DNODE_SHIFT);
484 } else if (BP_IS_HOLE(bp)) {
485 uint64_t span = BP_SPAN(dnp, zb->zb_level);
486 err = dump_free(dsp, zb->zb_object, zb->zb_blkid * span, span);
487 } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) {
489 } else if (type == DMU_OT_DNODE) {
492 int blksz = BP_GET_LSIZE(bp);
493 arc_flags_t aflags = ARC_FLAG_WAIT;
496 if (arc_read(NULL, spa, bp, arc_getbuf_func, &abuf,
497 ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL,
499 return (SET_ERROR(EIO));
502 for (i = 0; i < blksz >> DNODE_SHIFT; i++) {
503 uint64_t dnobj = (zb->zb_blkid <<
504 (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i;
505 err = dump_dnode(dsp, dnobj, blk+i);
509 (void) arc_buf_remove_ref(abuf, &abuf);
510 } else if (type == DMU_OT_SA) {
511 arc_flags_t aflags = ARC_FLAG_WAIT;
513 int blksz = BP_GET_LSIZE(bp);
515 if (arc_read(NULL, spa, bp, arc_getbuf_func, &abuf,
516 ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL,
518 return (SET_ERROR(EIO));
520 err = dump_spill(dsp, zb->zb_object, blksz, abuf->b_data);
521 (void) arc_buf_remove_ref(abuf, &abuf);
522 } else if (backup_do_embed(dsp, bp)) {
523 /* it's an embedded level-0 block of a regular object */
524 int blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT;
525 err = dump_write_embedded(dsp, zb->zb_object,
526 zb->zb_blkid * blksz, blksz, bp);
527 } else { /* it's a level-0 block of a regular object */
529 arc_flags_t aflags = ARC_FLAG_WAIT;
531 int blksz = BP_GET_LSIZE(bp);
533 ASSERT3U(blksz, ==, dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
534 ASSERT0(zb->zb_level);
535 if (arc_read(NULL, spa, bp, arc_getbuf_func, &abuf,
536 ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL,
538 if (zfs_send_corrupt_data) {
540 /* Send a block filled with 0x"zfs badd bloc" */
541 abuf = arc_buf_alloc(spa, blksz, &abuf,
543 for (ptr = abuf->b_data;
544 (char *)ptr < (char *)abuf->b_data + blksz;
546 *ptr = 0x2f5baddb10cULL;
548 return (SET_ERROR(EIO));
552 offset = zb->zb_blkid * blksz;
554 if (!(dsp->dsa_featureflags &
555 DMU_BACKUP_FEATURE_LARGE_BLOCKS) &&
556 blksz > SPA_OLD_MAXBLOCKSIZE) {
557 char *buf = abuf->b_data;
558 while (blksz > 0 && err == 0) {
559 int n = MIN(blksz, SPA_OLD_MAXBLOCKSIZE);
560 err = dump_write(dsp, type, zb->zb_object,
561 offset, n, NULL, buf);
567 err = dump_write(dsp, type, zb->zb_object,
568 offset, blksz, bp, abuf->b_data);
570 (void) arc_buf_remove_ref(abuf, &abuf);
573 ASSERT(err == 0 || err == EINTR);
578 * Releases dp using the specified tag.
581 dmu_send_impl(void *tag, dsl_pool_t *dp, dsl_dataset_t *ds,
582 zfs_bookmark_phys_t *fromzb, boolean_t is_clone, boolean_t embedok,
583 boolean_t large_block_ok, int outfd, vnode_t *vp, offset_t *off)
586 dmu_replay_record_t *drr;
589 uint64_t fromtxg = 0;
590 uint64_t featureflags = 0;
592 err = dmu_objset_from_ds(ds, &os);
594 dsl_pool_rele(dp, tag);
598 drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP);
599 drr->drr_type = DRR_BEGIN;
600 drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC;
601 DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo,
605 if (dmu_objset_type(os) == DMU_OST_ZFS) {
607 if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &version) != 0) {
608 kmem_free(drr, sizeof (dmu_replay_record_t));
609 dsl_pool_rele(dp, tag);
610 return (SET_ERROR(EINVAL));
612 if (version >= ZPL_VERSION_SA) {
613 featureflags |= DMU_BACKUP_FEATURE_SA_SPILL;
618 if (large_block_ok && ds->ds_feature_inuse[SPA_FEATURE_LARGE_BLOCKS])
619 featureflags |= DMU_BACKUP_FEATURE_LARGE_BLOCKS;
621 spa_feature_is_active(dp->dp_spa, SPA_FEATURE_EMBEDDED_DATA)) {
622 featureflags |= DMU_BACKUP_FEATURE_EMBED_DATA;
623 if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_LZ4_COMPRESS))
624 featureflags |= DMU_BACKUP_FEATURE_EMBED_DATA_LZ4;
629 DMU_SET_FEATUREFLAGS(drr->drr_u.drr_begin.drr_versioninfo,
632 drr->drr_u.drr_begin.drr_creation_time =
633 dsl_dataset_phys(ds)->ds_creation_time;
634 drr->drr_u.drr_begin.drr_type = dmu_objset_type(os);
636 drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE;
637 drr->drr_u.drr_begin.drr_toguid = dsl_dataset_phys(ds)->ds_guid;
638 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
639 drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA;
641 if (fromzb != NULL) {
642 drr->drr_u.drr_begin.drr_fromguid = fromzb->zbm_guid;
643 fromtxg = fromzb->zbm_creation_txg;
645 dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname);
646 if (!ds->ds_is_snapshot) {
647 (void) strlcat(drr->drr_u.drr_begin.drr_toname, "@--head--",
648 sizeof (drr->drr_u.drr_begin.drr_toname));
651 dsp = kmem_zalloc(sizeof (dmu_sendarg_t), KM_SLEEP);
655 dsp->dsa_outfd = outfd;
656 dsp->dsa_proc = curproc;
659 dsp->dsa_toguid = dsl_dataset_phys(ds)->ds_guid;
660 ZIO_SET_CHECKSUM(&dsp->dsa_zc, 0, 0, 0, 0);
661 dsp->dsa_pending_op = PENDING_NONE;
662 dsp->dsa_incremental = (fromzb != NULL);
663 dsp->dsa_featureflags = featureflags;
665 mutex_enter(&ds->ds_sendstream_lock);
666 list_insert_head(&ds->ds_sendstreams, dsp);
667 mutex_exit(&ds->ds_sendstream_lock);
669 dsl_dataset_long_hold(ds, FTAG);
670 dsl_pool_rele(dp, tag);
672 if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) {
677 err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH,
680 if (dsp->dsa_pending_op != PENDING_NONE)
681 if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0)
682 err = SET_ERROR(EINTR);
685 if (err == EINTR && dsp->dsa_err != 0)
690 bzero(drr, sizeof (dmu_replay_record_t));
691 drr->drr_type = DRR_END;
692 drr->drr_u.drr_end.drr_checksum = dsp->dsa_zc;
693 drr->drr_u.drr_end.drr_toguid = dsp->dsa_toguid;
695 if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) {
701 mutex_enter(&ds->ds_sendstream_lock);
702 list_remove(&ds->ds_sendstreams, dsp);
703 mutex_exit(&ds->ds_sendstream_lock);
705 kmem_free(drr, sizeof (dmu_replay_record_t));
706 kmem_free(dsp, sizeof (dmu_sendarg_t));
708 dsl_dataset_long_rele(ds, FTAG);
714 dmu_send_obj(const char *pool, uint64_t tosnap, uint64_t fromsnap,
715 boolean_t embedok, boolean_t large_block_ok,
716 int outfd, vnode_t *vp, offset_t *off)
720 dsl_dataset_t *fromds = NULL;
723 err = dsl_pool_hold(pool, FTAG, &dp);
727 err = dsl_dataset_hold_obj(dp, tosnap, FTAG, &ds);
729 dsl_pool_rele(dp, FTAG);
734 zfs_bookmark_phys_t zb;
737 err = dsl_dataset_hold_obj(dp, fromsnap, FTAG, &fromds);
739 dsl_dataset_rele(ds, FTAG);
740 dsl_pool_rele(dp, FTAG);
743 if (!dsl_dataset_is_before(ds, fromds, 0))
744 err = SET_ERROR(EXDEV);
745 zb.zbm_creation_time =
746 dsl_dataset_phys(fromds)->ds_creation_time;
747 zb.zbm_creation_txg = dsl_dataset_phys(fromds)->ds_creation_txg;
748 zb.zbm_guid = dsl_dataset_phys(fromds)->ds_guid;
749 is_clone = (fromds->ds_dir != ds->ds_dir);
750 dsl_dataset_rele(fromds, FTAG);
751 err = dmu_send_impl(FTAG, dp, ds, &zb, is_clone,
752 embedok, large_block_ok, outfd, vp, off);
754 err = dmu_send_impl(FTAG, dp, ds, NULL, B_FALSE,
755 embedok, large_block_ok, outfd, vp, off);
757 dsl_dataset_rele(ds, FTAG);
762 dmu_send(const char *tosnap, const char *fromsnap,
763 boolean_t embedok, boolean_t large_block_ok,
764 int outfd, vnode_t *vp, offset_t *off)
769 boolean_t owned = B_FALSE;
771 if (fromsnap != NULL && strpbrk(fromsnap, "@#") == NULL)
772 return (SET_ERROR(EINVAL));
774 err = dsl_pool_hold(tosnap, FTAG, &dp);
778 if (strchr(tosnap, '@') == NULL && spa_writeable(dp->dp_spa)) {
780 * We are sending a filesystem or volume. Ensure
781 * that it doesn't change by owning the dataset.
783 err = dsl_dataset_own(dp, tosnap, FTAG, &ds);
786 err = dsl_dataset_hold(dp, tosnap, FTAG, &ds);
789 dsl_pool_rele(dp, FTAG);
793 if (fromsnap != NULL) {
794 zfs_bookmark_phys_t zb;
795 boolean_t is_clone = B_FALSE;
796 int fsnamelen = strchr(tosnap, '@') - tosnap;
799 * If the fromsnap is in a different filesystem, then
800 * mark the send stream as a clone.
802 if (strncmp(tosnap, fromsnap, fsnamelen) != 0 ||
803 (fromsnap[fsnamelen] != '@' &&
804 fromsnap[fsnamelen] != '#')) {
808 if (strchr(fromsnap, '@')) {
809 dsl_dataset_t *fromds;
810 err = dsl_dataset_hold(dp, fromsnap, FTAG, &fromds);
812 if (!dsl_dataset_is_before(ds, fromds, 0))
813 err = SET_ERROR(EXDEV);
814 zb.zbm_creation_time =
815 dsl_dataset_phys(fromds)->ds_creation_time;
816 zb.zbm_creation_txg =
817 dsl_dataset_phys(fromds)->ds_creation_txg;
818 zb.zbm_guid = dsl_dataset_phys(fromds)->ds_guid;
819 is_clone = (ds->ds_dir != fromds->ds_dir);
820 dsl_dataset_rele(fromds, FTAG);
823 err = dsl_bookmark_lookup(dp, fromsnap, ds, &zb);
826 dsl_dataset_rele(ds, FTAG);
827 dsl_pool_rele(dp, FTAG);
830 err = dmu_send_impl(FTAG, dp, ds, &zb, is_clone,
831 embedok, large_block_ok, outfd, vp, off);
833 err = dmu_send_impl(FTAG, dp, ds, NULL, B_FALSE,
834 embedok, large_block_ok, outfd, vp, off);
837 dsl_dataset_disown(ds, FTAG);
839 dsl_dataset_rele(ds, FTAG);
844 dmu_adjust_send_estimate_for_indirects(dsl_dataset_t *ds, uint64_t size,
849 * Assume that space (both on-disk and in-stream) is dominated by
850 * data. We will adjust for indirect blocks and the copies property,
851 * but ignore per-object space used (eg, dnodes and DRR_OBJECT records).
855 * Subtract out approximate space used by indirect blocks.
856 * Assume most space is used by data blocks (non-indirect, non-dnode).
857 * Assume all blocks are recordsize. Assume ditto blocks and
858 * internal fragmentation counter out compression.
860 * Therefore, space used by indirect blocks is sizeof(blkptr_t) per
861 * block, which we observe in practice.
864 err = dsl_prop_get_int_ds(ds, "recordsize", &recordsize);
867 size -= size / recordsize * sizeof (blkptr_t);
869 /* Add in the space for the record associated with each block. */
870 size += size / recordsize * sizeof (dmu_replay_record_t);
878 dmu_send_estimate(dsl_dataset_t *ds, dsl_dataset_t *fromds, uint64_t *sizep)
883 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
885 /* tosnap must be a snapshot */
886 if (!ds->ds_is_snapshot)
887 return (SET_ERROR(EINVAL));
889 /* fromsnap, if provided, must be a snapshot */
890 if (fromds != NULL && !fromds->ds_is_snapshot)
891 return (SET_ERROR(EINVAL));
894 * fromsnap must be an earlier snapshot from the same fs as tosnap,
895 * or the origin's fs.
897 if (fromds != NULL && !dsl_dataset_is_before(ds, fromds, 0))
898 return (SET_ERROR(EXDEV));
900 /* Get uncompressed size estimate of changed data. */
901 if (fromds == NULL) {
902 size = dsl_dataset_phys(ds)->ds_uncompressed_bytes;
905 err = dsl_dataset_space_written(fromds, ds,
906 &used, &comp, &size);
911 err = dmu_adjust_send_estimate_for_indirects(ds, size, sizep);
916 * Simple callback used to traverse the blocks of a snapshot and sum their
921 dmu_calculate_send_traversal(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
922 const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
924 uint64_t *spaceptr = arg;
925 if (bp != NULL && !BP_IS_HOLE(bp)) {
926 *spaceptr += BP_GET_UCSIZE(bp);
932 * Given a desination snapshot and a TXG, calculate the approximate size of a
933 * send stream sent from that TXG. from_txg may be zero, indicating that the
934 * whole snapshot will be sent.
937 dmu_send_estimate_from_txg(dsl_dataset_t *ds, uint64_t from_txg,
943 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
945 /* tosnap must be a snapshot */
946 if (!dsl_dataset_is_snapshot(ds))
947 return (SET_ERROR(EINVAL));
949 /* verify that from_txg is before the provided snapshot was taken */
950 if (from_txg >= dsl_dataset_phys(ds)->ds_creation_txg) {
951 return (SET_ERROR(EXDEV));
954 * traverse the blocks of the snapshot with birth times after
955 * from_txg, summing their uncompressed size
957 err = traverse_dataset(ds, from_txg, TRAVERSE_POST,
958 dmu_calculate_send_traversal, &size);
962 err = dmu_adjust_send_estimate_for_indirects(ds, size, sizep);
966 typedef struct dmu_recv_begin_arg {
967 const char *drba_origin;
968 dmu_recv_cookie_t *drba_cookie;
970 uint64_t drba_snapobj;
971 } dmu_recv_begin_arg_t;
974 recv_begin_check_existing_impl(dmu_recv_begin_arg_t *drba, dsl_dataset_t *ds,
979 dsl_pool_t *dp = ds->ds_dir->dd_pool;
981 /* temporary clone name must not exist */
982 error = zap_lookup(dp->dp_meta_objset,
983 dsl_dir_phys(ds->ds_dir)->dd_child_dir_zapobj, recv_clone_name,
986 return (error == 0 ? EBUSY : error);
988 /* new snapshot name must not exist */
989 error = zap_lookup(dp->dp_meta_objset,
990 dsl_dataset_phys(ds)->ds_snapnames_zapobj,
991 drba->drba_cookie->drc_tosnap, 8, 1, &val);
993 return (error == 0 ? EEXIST : error);
996 * Check snapshot limit before receiving. We'll recheck again at the
997 * end, but might as well abort before receiving if we're already over
1000 * Note that we do not check the file system limit with
1001 * dsl_dir_fscount_check because the temporary %clones don't count
1002 * against that limit.
1004 error = dsl_fs_ss_limit_check(ds->ds_dir, 1, ZFS_PROP_SNAPSHOT_LIMIT,
1005 NULL, drba->drba_cred);
1009 if (fromguid != 0) {
1010 dsl_dataset_t *snap;
1011 uint64_t obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
1013 /* Find snapshot in this dir that matches fromguid. */
1015 error = dsl_dataset_hold_obj(dp, obj, FTAG,
1018 return (SET_ERROR(ENODEV));
1019 if (snap->ds_dir != ds->ds_dir) {
1020 dsl_dataset_rele(snap, FTAG);
1021 return (SET_ERROR(ENODEV));
1023 if (dsl_dataset_phys(snap)->ds_guid == fromguid)
1025 obj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
1026 dsl_dataset_rele(snap, FTAG);
1029 return (SET_ERROR(ENODEV));
1031 if (drba->drba_cookie->drc_force) {
1032 drba->drba_snapobj = obj;
1035 * If we are not forcing, there must be no
1036 * changes since fromsnap.
1038 if (dsl_dataset_modified_since_snap(ds, snap)) {
1039 dsl_dataset_rele(snap, FTAG);
1040 return (SET_ERROR(ETXTBSY));
1042 drba->drba_snapobj = ds->ds_prev->ds_object;
1045 dsl_dataset_rele(snap, FTAG);
1047 /* if full, then must be forced */
1048 if (!drba->drba_cookie->drc_force)
1049 return (SET_ERROR(EEXIST));
1050 /* start from $ORIGIN@$ORIGIN, if supported */
1051 drba->drba_snapobj = dp->dp_origin_snap != NULL ?
1052 dp->dp_origin_snap->ds_object : 0;
1060 dmu_recv_begin_check(void *arg, dmu_tx_t *tx)
1062 dmu_recv_begin_arg_t *drba = arg;
1063 dsl_pool_t *dp = dmu_tx_pool(tx);
1064 struct drr_begin *drrb = drba->drba_cookie->drc_drrb;
1065 uint64_t fromguid = drrb->drr_fromguid;
1066 int flags = drrb->drr_flags;
1068 uint64_t featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo);
1070 const char *tofs = drba->drba_cookie->drc_tofs;
1072 /* already checked */
1073 ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC);
1075 if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) ==
1076 DMU_COMPOUNDSTREAM ||
1077 drrb->drr_type >= DMU_OST_NUMTYPES ||
1078 ((flags & DRR_FLAG_CLONE) && drba->drba_origin == NULL))
1079 return (SET_ERROR(EINVAL));
1081 /* Verify pool version supports SA if SA_SPILL feature set */
1082 if ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) &&
1083 spa_version(dp->dp_spa) < SPA_VERSION_SA)
1084 return (SET_ERROR(ENOTSUP));
1087 * The receiving code doesn't know how to translate a WRITE_EMBEDDED
1088 * record to a plan WRITE record, so the pool must have the
1089 * EMBEDDED_DATA feature enabled if the stream has WRITE_EMBEDDED
1090 * records. Same with WRITE_EMBEDDED records that use LZ4 compression.
1092 if ((featureflags & DMU_BACKUP_FEATURE_EMBED_DATA) &&
1093 !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_EMBEDDED_DATA))
1094 return (SET_ERROR(ENOTSUP));
1095 if ((featureflags & DMU_BACKUP_FEATURE_EMBED_DATA_LZ4) &&
1096 !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LZ4_COMPRESS))
1097 return (SET_ERROR(ENOTSUP));
1100 * The receiving code doesn't know how to translate large blocks
1101 * to smaller ones, so the pool must have the LARGE_BLOCKS
1102 * feature enabled if the stream has LARGE_BLOCKS.
1104 if ((featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) &&
1105 !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LARGE_BLOCKS))
1106 return (SET_ERROR(ENOTSUP));
1108 error = dsl_dataset_hold(dp, tofs, FTAG, &ds);
1110 /* target fs already exists; recv into temp clone */
1112 /* Can't recv a clone into an existing fs */
1113 if (flags & DRR_FLAG_CLONE) {
1114 dsl_dataset_rele(ds, FTAG);
1115 return (SET_ERROR(EINVAL));
1118 error = recv_begin_check_existing_impl(drba, ds, fromguid);
1119 dsl_dataset_rele(ds, FTAG);
1120 } else if (error == ENOENT) {
1121 /* target fs does not exist; must be a full backup or clone */
1122 char buf[MAXNAMELEN];
1125 * If it's a non-clone incremental, we are missing the
1126 * target fs, so fail the recv.
1128 if (fromguid != 0 && !(flags & DRR_FLAG_CLONE))
1129 return (SET_ERROR(ENOENT));
1131 /* Open the parent of tofs */
1132 ASSERT3U(strlen(tofs), <, MAXNAMELEN);
1133 (void) strlcpy(buf, tofs, strrchr(tofs, '/') - tofs + 1);
1134 error = dsl_dataset_hold(dp, buf, FTAG, &ds);
1139 * Check filesystem and snapshot limits before receiving. We'll
1140 * recheck snapshot limits again at the end (we create the
1141 * filesystems and increment those counts during begin_sync).
1143 error = dsl_fs_ss_limit_check(ds->ds_dir, 1,
1144 ZFS_PROP_FILESYSTEM_LIMIT, NULL, drba->drba_cred);
1146 dsl_dataset_rele(ds, FTAG);
1150 error = dsl_fs_ss_limit_check(ds->ds_dir, 1,
1151 ZFS_PROP_SNAPSHOT_LIMIT, NULL, drba->drba_cred);
1153 dsl_dataset_rele(ds, FTAG);
1157 if (drba->drba_origin != NULL) {
1158 dsl_dataset_t *origin;
1159 error = dsl_dataset_hold(dp, drba->drba_origin,
1162 dsl_dataset_rele(ds, FTAG);
1165 if (!origin->ds_is_snapshot) {
1166 dsl_dataset_rele(origin, FTAG);
1167 dsl_dataset_rele(ds, FTAG);
1168 return (SET_ERROR(EINVAL));
1170 if (dsl_dataset_phys(origin)->ds_guid != fromguid) {
1171 dsl_dataset_rele(origin, FTAG);
1172 dsl_dataset_rele(ds, FTAG);
1173 return (SET_ERROR(ENODEV));
1175 dsl_dataset_rele(origin, FTAG);
1177 dsl_dataset_rele(ds, FTAG);
1184 dmu_recv_begin_sync(void *arg, dmu_tx_t *tx)
1186 dmu_recv_begin_arg_t *drba = arg;
1187 dsl_pool_t *dp = dmu_tx_pool(tx);
1188 struct drr_begin *drrb = drba->drba_cookie->drc_drrb;
1189 const char *tofs = drba->drba_cookie->drc_tofs;
1190 dsl_dataset_t *ds, *newds;
1195 crflags = (drrb->drr_flags & DRR_FLAG_CI_DATA) ?
1196 DS_FLAG_CI_DATASET : 0;
1198 error = dsl_dataset_hold(dp, tofs, FTAG, &ds);
1200 /* create temporary clone */
1201 dsl_dataset_t *snap = NULL;
1202 if (drba->drba_snapobj != 0) {
1203 VERIFY0(dsl_dataset_hold_obj(dp,
1204 drba->drba_snapobj, FTAG, &snap));
1206 dsobj = dsl_dataset_create_sync(ds->ds_dir, recv_clone_name,
1207 snap, crflags, drba->drba_cred, tx);
1208 dsl_dataset_rele(snap, FTAG);
1209 dsl_dataset_rele(ds, FTAG);
1213 dsl_dataset_t *origin = NULL;
1215 VERIFY0(dsl_dir_hold(dp, tofs, FTAG, &dd, &tail));
1217 if (drba->drba_origin != NULL) {
1218 VERIFY0(dsl_dataset_hold(dp, drba->drba_origin,
1222 /* Create new dataset. */
1223 dsobj = dsl_dataset_create_sync(dd,
1224 strrchr(tofs, '/') + 1,
1225 origin, crflags, drba->drba_cred, tx);
1227 dsl_dataset_rele(origin, FTAG);
1228 dsl_dir_rele(dd, FTAG);
1229 drba->drba_cookie->drc_newfs = B_TRUE;
1231 VERIFY0(dsl_dataset_own_obj(dp, dsobj, dmu_recv_tag, &newds));
1233 dmu_buf_will_dirty(newds->ds_dbuf, tx);
1234 dsl_dataset_phys(newds)->ds_flags |= DS_FLAG_INCONSISTENT;
1237 * If we actually created a non-clone, we need to create the
1238 * objset in our new dataset.
1240 if (BP_IS_HOLE(dsl_dataset_get_blkptr(newds))) {
1241 (void) dmu_objset_create_impl(dp->dp_spa,
1242 newds, dsl_dataset_get_blkptr(newds), drrb->drr_type, tx);
1245 drba->drba_cookie->drc_ds = newds;
1247 spa_history_log_internal_ds(newds, "receive", tx, "");
1251 * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin()
1252 * succeeds; otherwise we will leak the holds on the datasets.
1255 dmu_recv_begin(char *tofs, char *tosnap, struct drr_begin *drrb,
1256 boolean_t force, char *origin, dmu_recv_cookie_t *drc)
1258 dmu_recv_begin_arg_t drba = { 0 };
1259 dmu_replay_record_t *drr;
1261 bzero(drc, sizeof (dmu_recv_cookie_t));
1262 drc->drc_drrb = drrb;
1263 drc->drc_tosnap = tosnap;
1264 drc->drc_tofs = tofs;
1265 drc->drc_force = force;
1266 drc->drc_cred = CRED();
1268 if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC))
1269 drc->drc_byteswap = B_TRUE;
1270 else if (drrb->drr_magic != DMU_BACKUP_MAGIC)
1271 return (SET_ERROR(EINVAL));
1273 drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP);
1274 drr->drr_type = DRR_BEGIN;
1275 drr->drr_u.drr_begin = *drc->drc_drrb;
1276 if (drc->drc_byteswap) {
1277 fletcher_4_incremental_byteswap(drr,
1278 sizeof (dmu_replay_record_t), &drc->drc_cksum);
1280 fletcher_4_incremental_native(drr,
1281 sizeof (dmu_replay_record_t), &drc->drc_cksum);
1283 kmem_free(drr, sizeof (dmu_replay_record_t));
1285 if (drc->drc_byteswap) {
1286 drrb->drr_magic = BSWAP_64(drrb->drr_magic);
1287 drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo);
1288 drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time);
1289 drrb->drr_type = BSWAP_32(drrb->drr_type);
1290 drrb->drr_toguid = BSWAP_64(drrb->drr_toguid);
1291 drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid);
1294 drba.drba_origin = origin;
1295 drba.drba_cookie = drc;
1296 drba.drba_cred = CRED();
1298 return (dsl_sync_task(tofs, dmu_recv_begin_check, dmu_recv_begin_sync,
1299 &drba, 5, ZFS_SPACE_CHECK_NORMAL));
1308 int bufsize; /* amount of memory allocated for buf */
1310 avl_tree_t *guid_to_ds_map;
1313 typedef struct guid_map_entry {
1315 dsl_dataset_t *gme_ds;
1320 guid_compare(const void *arg1, const void *arg2)
1322 const guid_map_entry_t *gmep1 = arg1;
1323 const guid_map_entry_t *gmep2 = arg2;
1325 if (gmep1->guid < gmep2->guid)
1327 else if (gmep1->guid > gmep2->guid)
1333 free_guid_map_onexit(void *arg)
1335 avl_tree_t *ca = arg;
1336 void *cookie = NULL;
1337 guid_map_entry_t *gmep;
1339 while ((gmep = avl_destroy_nodes(ca, &cookie)) != NULL) {
1340 dsl_dataset_long_rele(gmep->gme_ds, gmep);
1341 dsl_dataset_rele(gmep->gme_ds, gmep);
1342 kmem_free(gmep, sizeof (guid_map_entry_t));
1345 kmem_free(ca, sizeof (avl_tree_t));
1349 restore_read(struct restorearg *ra, int len, char *buf)
1356 /* some things will require 8-byte alignment, so everything must */
1358 ASSERT3U(len, <=, ra->bufsize);
1360 while (done < len) {
1363 ra->err = vn_rdwr(UIO_READ, ra->vp,
1364 buf + done, len - done,
1365 ra->voff, UIO_SYSSPACE, FAPPEND,
1366 RLIM64_INFINITY, CRED(), &resid);
1368 if (resid == len - done)
1369 ra->err = SET_ERROR(EINVAL);
1370 ra->voff += len - done - resid;
1376 ASSERT3U(done, ==, len);
1378 fletcher_4_incremental_byteswap(buf, len, &ra->cksum);
1380 fletcher_4_incremental_native(buf, len, &ra->cksum);
1384 noinline static void
1385 backup_byteswap(dmu_replay_record_t *drr)
1387 #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X))
1388 #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X))
1389 drr->drr_type = BSWAP_32(drr->drr_type);
1390 drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen);
1391 switch (drr->drr_type) {
1393 DO64(drr_begin.drr_magic);
1394 DO64(drr_begin.drr_versioninfo);
1395 DO64(drr_begin.drr_creation_time);
1396 DO32(drr_begin.drr_type);
1397 DO32(drr_begin.drr_flags);
1398 DO64(drr_begin.drr_toguid);
1399 DO64(drr_begin.drr_fromguid);
1402 DO64(drr_object.drr_object);
1403 DO32(drr_object.drr_type);
1404 DO32(drr_object.drr_bonustype);
1405 DO32(drr_object.drr_blksz);
1406 DO32(drr_object.drr_bonuslen);
1407 DO64(drr_object.drr_toguid);
1409 case DRR_FREEOBJECTS:
1410 DO64(drr_freeobjects.drr_firstobj);
1411 DO64(drr_freeobjects.drr_numobjs);
1412 DO64(drr_freeobjects.drr_toguid);
1415 DO64(drr_write.drr_object);
1416 DO32(drr_write.drr_type);
1417 DO64(drr_write.drr_offset);
1418 DO64(drr_write.drr_length);
1419 DO64(drr_write.drr_toguid);
1420 DO64(drr_write.drr_key.ddk_cksum.zc_word[0]);
1421 DO64(drr_write.drr_key.ddk_cksum.zc_word[1]);
1422 DO64(drr_write.drr_key.ddk_cksum.zc_word[2]);
1423 DO64(drr_write.drr_key.ddk_cksum.zc_word[3]);
1424 DO64(drr_write.drr_key.ddk_prop);
1426 case DRR_WRITE_BYREF:
1427 DO64(drr_write_byref.drr_object);
1428 DO64(drr_write_byref.drr_offset);
1429 DO64(drr_write_byref.drr_length);
1430 DO64(drr_write_byref.drr_toguid);
1431 DO64(drr_write_byref.drr_refguid);
1432 DO64(drr_write_byref.drr_refobject);
1433 DO64(drr_write_byref.drr_refoffset);
1434 DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]);
1435 DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]);
1436 DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]);
1437 DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]);
1438 DO64(drr_write_byref.drr_key.ddk_prop);
1440 case DRR_WRITE_EMBEDDED:
1441 DO64(drr_write_embedded.drr_object);
1442 DO64(drr_write_embedded.drr_offset);
1443 DO64(drr_write_embedded.drr_length);
1444 DO64(drr_write_embedded.drr_toguid);
1445 DO32(drr_write_embedded.drr_lsize);
1446 DO32(drr_write_embedded.drr_psize);
1449 DO64(drr_free.drr_object);
1450 DO64(drr_free.drr_offset);
1451 DO64(drr_free.drr_length);
1452 DO64(drr_free.drr_toguid);
1455 DO64(drr_spill.drr_object);
1456 DO64(drr_spill.drr_length);
1457 DO64(drr_spill.drr_toguid);
1460 DO64(drr_end.drr_checksum.zc_word[0]);
1461 DO64(drr_end.drr_checksum.zc_word[1]);
1462 DO64(drr_end.drr_checksum.zc_word[2]);
1463 DO64(drr_end.drr_checksum.zc_word[3]);
1464 DO64(drr_end.drr_toguid);
1473 static inline uint8_t
1474 deduce_nblkptr(dmu_object_type_t bonus_type, uint64_t bonus_size)
1476 if (bonus_type == DMU_OT_SA) {
1480 ((DN_MAX_BONUSLEN - bonus_size) >> SPA_BLKPTRSHIFT));
1485 restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro)
1487 dmu_object_info_t doi;
1493 if (drro->drr_type == DMU_OT_NONE ||
1494 !DMU_OT_IS_VALID(drro->drr_type) ||
1495 !DMU_OT_IS_VALID(drro->drr_bonustype) ||
1496 drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS ||
1497 drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS ||
1498 P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) ||
1499 drro->drr_blksz < SPA_MINBLOCKSIZE ||
1500 drro->drr_blksz > spa_maxblocksize(dmu_objset_spa(os)) ||
1501 drro->drr_bonuslen > DN_MAX_BONUSLEN) {
1502 return (SET_ERROR(EINVAL));
1505 err = dmu_object_info(os, drro->drr_object, &doi);
1507 if (err != 0 && err != ENOENT)
1508 return (SET_ERROR(EINVAL));
1509 object = err == 0 ? drro->drr_object : DMU_NEW_OBJECT;
1511 if (drro->drr_bonuslen) {
1512 data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8), NULL);
1518 * If we are losing blkptrs or changing the block size this must
1519 * be a new file instance. We must clear out the previous file
1520 * contents before we can change this type of metadata in the dnode.
1525 nblkptr = deduce_nblkptr(drro->drr_bonustype,
1526 drro->drr_bonuslen);
1528 if (drro->drr_blksz != doi.doi_data_block_size ||
1529 nblkptr < doi.doi_nblkptr) {
1530 err = dmu_free_long_range(os, drro->drr_object,
1533 return (SET_ERROR(EINVAL));
1537 tx = dmu_tx_create(os);
1538 dmu_tx_hold_bonus(tx, object);
1539 err = dmu_tx_assign(tx, TXG_WAIT);
1545 if (object == DMU_NEW_OBJECT) {
1546 /* currently free, want to be allocated */
1547 err = dmu_object_claim(os, drro->drr_object,
1548 drro->drr_type, drro->drr_blksz,
1549 drro->drr_bonustype, drro->drr_bonuslen, tx);
1550 } else if (drro->drr_type != doi.doi_type ||
1551 drro->drr_blksz != doi.doi_data_block_size ||
1552 drro->drr_bonustype != doi.doi_bonus_type ||
1553 drro->drr_bonuslen != doi.doi_bonus_size) {
1554 /* currently allocated, but with different properties */
1555 err = dmu_object_reclaim(os, drro->drr_object,
1556 drro->drr_type, drro->drr_blksz,
1557 drro->drr_bonustype, drro->drr_bonuslen, tx);
1561 return (SET_ERROR(EINVAL));
1564 dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype,
1566 dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx);
1571 VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db));
1572 dmu_buf_will_dirty(db, tx);
1574 ASSERT3U(db->db_size, >=, drro->drr_bonuslen);
1575 bcopy(data, db->db_data, drro->drr_bonuslen);
1577 dmu_object_byteswap_t byteswap =
1578 DMU_OT_BYTESWAP(drro->drr_bonustype);
1579 dmu_ot_byteswap[byteswap].ob_func(db->db_data,
1580 drro->drr_bonuslen);
1582 dmu_buf_rele(db, FTAG);
1590 restore_freeobjects(struct restorearg *ra, objset_t *os,
1591 struct drr_freeobjects *drrfo)
1595 if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj)
1596 return (SET_ERROR(EINVAL));
1598 for (obj = drrfo->drr_firstobj;
1599 obj < drrfo->drr_firstobj + drrfo->drr_numobjs;
1600 (void) dmu_object_next(os, &obj, FALSE, 0)) {
1603 if (dmu_object_info(os, obj, NULL) != 0)
1606 err = dmu_free_long_object(os, obj);
1614 restore_write(struct restorearg *ra, objset_t *os,
1615 struct drr_write *drrw)
1623 if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset ||
1624 !DMU_OT_IS_VALID(drrw->drr_type))
1625 return (SET_ERROR(EINVAL));
1627 if (dmu_object_info(os, drrw->drr_object, NULL) != 0)
1628 return (SET_ERROR(EINVAL));
1630 if (dmu_bonus_hold(os, drrw->drr_object, FTAG, &bonus) != 0)
1631 return (SET_ERROR(EINVAL));
1633 abuf = dmu_request_arcbuf(bonus, drrw->drr_length);
1635 data = restore_read(ra, drrw->drr_length, abuf->b_data);
1637 dmu_return_arcbuf(abuf);
1638 dmu_buf_rele(bonus, FTAG);
1642 tx = dmu_tx_create(os);
1644 dmu_tx_hold_write(tx, drrw->drr_object,
1645 drrw->drr_offset, drrw->drr_length);
1646 err = dmu_tx_assign(tx, TXG_WAIT);
1648 dmu_return_arcbuf(abuf);
1649 dmu_buf_rele(bonus, FTAG);
1654 dmu_object_byteswap_t byteswap =
1655 DMU_OT_BYTESWAP(drrw->drr_type);
1656 dmu_ot_byteswap[byteswap].ob_func(data, drrw->drr_length);
1658 dmu_assign_arcbuf(bonus, drrw->drr_offset, abuf, tx);
1660 dmu_buf_rele(bonus, FTAG);
1665 * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed
1666 * streams to refer to a copy of the data that is already on the
1667 * system because it came in earlier in the stream. This function
1668 * finds the earlier copy of the data, and uses that copy instead of
1669 * data from the stream to fulfill this write.
1672 restore_write_byref(struct restorearg *ra, objset_t *os,
1673 struct drr_write_byref *drrwbr)
1677 guid_map_entry_t gmesrch;
1678 guid_map_entry_t *gmep;
1680 objset_t *ref_os = NULL;
1683 if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset)
1684 return (SET_ERROR(EINVAL));
1687 * If the GUID of the referenced dataset is different from the
1688 * GUID of the target dataset, find the referenced dataset.
1690 if (drrwbr->drr_toguid != drrwbr->drr_refguid) {
1691 gmesrch.guid = drrwbr->drr_refguid;
1692 if ((gmep = avl_find(ra->guid_to_ds_map, &gmesrch,
1694 return (SET_ERROR(EINVAL));
1696 if (dmu_objset_from_ds(gmep->gme_ds, &ref_os))
1697 return (SET_ERROR(EINVAL));
1702 err = dmu_buf_hold(ref_os, drrwbr->drr_refobject,
1703 drrwbr->drr_refoffset, FTAG, &dbp, DMU_READ_PREFETCH);
1707 tx = dmu_tx_create(os);
1709 dmu_tx_hold_write(tx, drrwbr->drr_object,
1710 drrwbr->drr_offset, drrwbr->drr_length);
1711 err = dmu_tx_assign(tx, TXG_WAIT);
1716 dmu_write(os, drrwbr->drr_object,
1717 drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx);
1718 dmu_buf_rele(dbp, FTAG);
1724 restore_write_embedded(struct restorearg *ra, objset_t *os,
1725 struct drr_write_embedded *drrwnp)
1731 if (drrwnp->drr_offset + drrwnp->drr_length < drrwnp->drr_offset)
1734 if (drrwnp->drr_psize > BPE_PAYLOAD_SIZE)
1737 if (drrwnp->drr_etype >= NUM_BP_EMBEDDED_TYPES)
1739 if (drrwnp->drr_compression >= ZIO_COMPRESS_FUNCTIONS)
1742 data = restore_read(ra, P2ROUNDUP(drrwnp->drr_psize, 8), NULL);
1746 tx = dmu_tx_create(os);
1748 dmu_tx_hold_write(tx, drrwnp->drr_object,
1749 drrwnp->drr_offset, drrwnp->drr_length);
1750 err = dmu_tx_assign(tx, TXG_WAIT);
1756 dmu_write_embedded(os, drrwnp->drr_object,
1757 drrwnp->drr_offset, data, drrwnp->drr_etype,
1758 drrwnp->drr_compression, drrwnp->drr_lsize, drrwnp->drr_psize,
1759 ra->byteswap ^ ZFS_HOST_BYTEORDER, tx);
1766 restore_spill(struct restorearg *ra, objset_t *os, struct drr_spill *drrs)
1770 dmu_buf_t *db, *db_spill;
1773 if (drrs->drr_length < SPA_MINBLOCKSIZE ||
1774 drrs->drr_length > spa_maxblocksize(dmu_objset_spa(os)))
1775 return (SET_ERROR(EINVAL));
1777 data = restore_read(ra, drrs->drr_length, NULL);
1781 if (dmu_object_info(os, drrs->drr_object, NULL) != 0)
1782 return (SET_ERROR(EINVAL));
1784 VERIFY(0 == dmu_bonus_hold(os, drrs->drr_object, FTAG, &db));
1785 if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) {
1786 dmu_buf_rele(db, FTAG);
1790 tx = dmu_tx_create(os);
1792 dmu_tx_hold_spill(tx, db->db_object);
1794 err = dmu_tx_assign(tx, TXG_WAIT);
1796 dmu_buf_rele(db, FTAG);
1797 dmu_buf_rele(db_spill, FTAG);
1801 dmu_buf_will_dirty(db_spill, tx);
1803 if (db_spill->db_size < drrs->drr_length)
1804 VERIFY(0 == dbuf_spill_set_blksz(db_spill,
1805 drrs->drr_length, tx));
1806 bcopy(data, db_spill->db_data, drrs->drr_length);
1808 dmu_buf_rele(db, FTAG);
1809 dmu_buf_rele(db_spill, FTAG);
1817 restore_free(struct restorearg *ra, objset_t *os,
1818 struct drr_free *drrf)
1822 if (drrf->drr_length != -1ULL &&
1823 drrf->drr_offset + drrf->drr_length < drrf->drr_offset)
1824 return (SET_ERROR(EINVAL));
1826 if (dmu_object_info(os, drrf->drr_object, NULL) != 0)
1827 return (SET_ERROR(EINVAL));
1829 err = dmu_free_long_range(os, drrf->drr_object,
1830 drrf->drr_offset, drrf->drr_length);
1834 /* used to destroy the drc_ds on error */
1836 dmu_recv_cleanup_ds(dmu_recv_cookie_t *drc)
1838 char name[MAXNAMELEN];
1839 dsl_dataset_name(drc->drc_ds, name);
1840 dsl_dataset_disown(drc->drc_ds, dmu_recv_tag);
1841 (void) dsl_destroy_head(name);
1845 * NB: callers *must* call dmu_recv_end() if this succeeds.
1848 dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp,
1849 int cleanup_fd, uint64_t *action_handlep)
1851 struct restorearg ra = { 0 };
1852 dmu_replay_record_t *drr;
1857 ra.byteswap = drc->drc_byteswap;
1858 ra.cksum = drc->drc_cksum;
1861 ra.bufsize = SPA_MAXBLOCKSIZE;
1862 ra.buf = vmem_alloc(ra.bufsize, KM_SLEEP);
1864 /* these were verified in dmu_recv_begin */
1865 ASSERT3U(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo), ==,
1867 ASSERT3U(drc->drc_drrb->drr_type, <, DMU_OST_NUMTYPES);
1870 * Open the objset we are modifying.
1872 VERIFY0(dmu_objset_from_ds(drc->drc_ds, &os));
1874 ASSERT(dsl_dataset_phys(drc->drc_ds)->ds_flags & DS_FLAG_INCONSISTENT);
1876 featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo);
1878 /* if this stream is dedup'ed, set up the avl tree for guid mapping */
1879 if (featureflags & DMU_BACKUP_FEATURE_DEDUP) {
1882 if (cleanup_fd == -1) {
1883 ra.err = SET_ERROR(EBADF);
1886 ra.err = zfs_onexit_fd_hold(cleanup_fd, &minor);
1892 if (*action_handlep == 0) {
1894 kmem_alloc(sizeof (avl_tree_t), KM_SLEEP);
1895 avl_create(ra.guid_to_ds_map, guid_compare,
1896 sizeof (guid_map_entry_t),
1897 offsetof(guid_map_entry_t, avlnode));
1898 ra.err = zfs_onexit_add_cb(minor,
1899 free_guid_map_onexit, ra.guid_to_ds_map,
1904 ra.err = zfs_onexit_cb_data(minor, *action_handlep,
1905 (void **)&ra.guid_to_ds_map);
1910 drc->drc_guid_to_ds_map = ra.guid_to_ds_map;
1914 * Read records and process them.
1917 while (ra.err == 0 &&
1918 NULL != (drr = restore_read(&ra, sizeof (*drr), NULL))) {
1919 if (issig(JUSTLOOKING) && issig(FORREAL)) {
1920 ra.err = SET_ERROR(EINTR);
1925 backup_byteswap(drr);
1927 switch (drr->drr_type) {
1931 * We need to make a copy of the record header,
1932 * because restore_{object,write} may need to
1933 * restore_read(), which will invalidate drr.
1935 struct drr_object drro = drr->drr_u.drr_object;
1936 ra.err = restore_object(&ra, os, &drro);
1939 case DRR_FREEOBJECTS:
1941 struct drr_freeobjects drrfo =
1942 drr->drr_u.drr_freeobjects;
1943 ra.err = restore_freeobjects(&ra, os, &drrfo);
1948 struct drr_write drrw = drr->drr_u.drr_write;
1949 ra.err = restore_write(&ra, os, &drrw);
1952 case DRR_WRITE_BYREF:
1954 struct drr_write_byref drrwbr =
1955 drr->drr_u.drr_write_byref;
1956 ra.err = restore_write_byref(&ra, os, &drrwbr);
1959 case DRR_WRITE_EMBEDDED:
1961 struct drr_write_embedded drrwe =
1962 drr->drr_u.drr_write_embedded;
1963 ra.err = restore_write_embedded(&ra, os, &drrwe);
1968 struct drr_free drrf = drr->drr_u.drr_free;
1969 ra.err = restore_free(&ra, os, &drrf);
1974 struct drr_end drre = drr->drr_u.drr_end;
1976 * We compare against the *previous* checksum
1977 * value, because the stored checksum is of
1978 * everything before the DRR_END record.
1980 if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum))
1981 ra.err = SET_ERROR(ECKSUM);
1986 struct drr_spill drrs = drr->drr_u.drr_spill;
1987 ra.err = restore_spill(&ra, os, &drrs);
1991 ra.err = SET_ERROR(EINVAL);
1996 ASSERT(ra.err != 0);
1999 if ((featureflags & DMU_BACKUP_FEATURE_DEDUP) && (cleanup_fd != -1))
2000 zfs_onexit_fd_rele(cleanup_fd);
2004 * destroy what we created, so we don't leave it in the
2005 * inconsistent restoring state.
2007 dmu_recv_cleanup_ds(drc);
2010 vmem_free(ra.buf, ra.bufsize);
2016 dmu_recv_end_check(void *arg, dmu_tx_t *tx)
2018 dmu_recv_cookie_t *drc = arg;
2019 dsl_pool_t *dp = dmu_tx_pool(tx);
2022 ASSERT3P(drc->drc_ds->ds_owner, ==, dmu_recv_tag);
2024 if (!drc->drc_newfs) {
2025 dsl_dataset_t *origin_head;
2027 error = dsl_dataset_hold(dp, drc->drc_tofs, FTAG, &origin_head);
2030 if (drc->drc_force) {
2032 * We will destroy any snapshots in tofs (i.e. before
2033 * origin_head) that are after the origin (which is
2034 * the snap before drc_ds, because drc_ds can not
2035 * have any snaps of its own).
2039 obj = dsl_dataset_phys(origin_head)->ds_prev_snap_obj;
2041 dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj) {
2042 dsl_dataset_t *snap;
2043 error = dsl_dataset_hold_obj(dp, obj, FTAG,
2047 if (snap->ds_dir != origin_head->ds_dir)
2048 error = SET_ERROR(EINVAL);
2050 error = dsl_destroy_snapshot_check_impl(
2053 obj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
2054 dsl_dataset_rele(snap, FTAG);
2059 dsl_dataset_rele(origin_head, FTAG);
2063 error = dsl_dataset_clone_swap_check_impl(drc->drc_ds,
2064 origin_head, drc->drc_force, drc->drc_owner, tx);
2066 dsl_dataset_rele(origin_head, FTAG);
2069 error = dsl_dataset_snapshot_check_impl(origin_head,
2070 drc->drc_tosnap, tx, B_TRUE, 1, drc->drc_cred);
2071 dsl_dataset_rele(origin_head, FTAG);
2075 error = dsl_destroy_head_check_impl(drc->drc_ds, 1);
2077 error = dsl_dataset_snapshot_check_impl(drc->drc_ds,
2078 drc->drc_tosnap, tx, B_TRUE, 1, drc->drc_cred);
2084 dmu_recv_end_sync(void *arg, dmu_tx_t *tx)
2086 dmu_recv_cookie_t *drc = arg;
2087 dsl_pool_t *dp = dmu_tx_pool(tx);
2089 spa_history_log_internal_ds(drc->drc_ds, "finish receiving",
2090 tx, "snap=%s", drc->drc_tosnap);
2092 if (!drc->drc_newfs) {
2093 dsl_dataset_t *origin_head;
2095 VERIFY0(dsl_dataset_hold(dp, drc->drc_tofs, FTAG,
2098 if (drc->drc_force) {
2100 * Destroy any snapshots of drc_tofs (origin_head)
2101 * after the origin (the snap before drc_ds).
2105 obj = dsl_dataset_phys(origin_head)->ds_prev_snap_obj;
2107 dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj) {
2108 dsl_dataset_t *snap;
2109 VERIFY0(dsl_dataset_hold_obj(dp, obj, FTAG,
2111 ASSERT3P(snap->ds_dir, ==, origin_head->ds_dir);
2112 obj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
2113 dsl_destroy_snapshot_sync_impl(snap,
2115 dsl_dataset_rele(snap, FTAG);
2118 VERIFY3P(drc->drc_ds->ds_prev, ==,
2119 origin_head->ds_prev);
2121 dsl_dataset_clone_swap_sync_impl(drc->drc_ds,
2123 dsl_dataset_snapshot_sync_impl(origin_head,
2124 drc->drc_tosnap, tx);
2126 /* set snapshot's creation time and guid */
2127 dmu_buf_will_dirty(origin_head->ds_prev->ds_dbuf, tx);
2128 dsl_dataset_phys(origin_head->ds_prev)->ds_creation_time =
2129 drc->drc_drrb->drr_creation_time;
2130 dsl_dataset_phys(origin_head->ds_prev)->ds_guid =
2131 drc->drc_drrb->drr_toguid;
2132 dsl_dataset_phys(origin_head->ds_prev)->ds_flags &=
2133 ~DS_FLAG_INCONSISTENT;
2135 dmu_buf_will_dirty(origin_head->ds_dbuf, tx);
2136 dsl_dataset_phys(origin_head)->ds_flags &=
2137 ~DS_FLAG_INCONSISTENT;
2139 dsl_dataset_rele(origin_head, FTAG);
2140 dsl_destroy_head_sync_impl(drc->drc_ds, tx);
2142 if (drc->drc_owner != NULL)
2143 VERIFY3P(origin_head->ds_owner, ==, drc->drc_owner);
2145 dsl_dataset_t *ds = drc->drc_ds;
2147 dsl_dataset_snapshot_sync_impl(ds, drc->drc_tosnap, tx);
2149 /* set snapshot's creation time and guid */
2150 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
2151 dsl_dataset_phys(ds->ds_prev)->ds_creation_time =
2152 drc->drc_drrb->drr_creation_time;
2153 dsl_dataset_phys(ds->ds_prev)->ds_guid =
2154 drc->drc_drrb->drr_toguid;
2155 dsl_dataset_phys(ds->ds_prev)->ds_flags &=
2156 ~DS_FLAG_INCONSISTENT;
2158 dmu_buf_will_dirty(ds->ds_dbuf, tx);
2159 dsl_dataset_phys(ds)->ds_flags &= ~DS_FLAG_INCONSISTENT;
2161 drc->drc_newsnapobj = dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj;
2163 * Release the hold from dmu_recv_begin. This must be done before
2164 * we return to open context, so that when we free the dataset's dnode,
2165 * we can evict its bonus buffer.
2167 dsl_dataset_disown(drc->drc_ds, dmu_recv_tag);
2172 add_ds_to_guidmap(const char *name, avl_tree_t *guid_map, uint64_t snapobj)
2175 dsl_dataset_t *snapds;
2176 guid_map_entry_t *gmep;
2179 ASSERT(guid_map != NULL);
2181 err = dsl_pool_hold(name, FTAG, &dp);
2184 gmep = kmem_alloc(sizeof (*gmep), KM_SLEEP);
2185 err = dsl_dataset_hold_obj(dp, snapobj, gmep, &snapds);
2187 gmep->guid = dsl_dataset_phys(snapds)->ds_guid;
2188 gmep->gme_ds = snapds;
2189 avl_add(guid_map, gmep);
2190 dsl_dataset_long_hold(snapds, gmep);
2192 kmem_free(gmep, sizeof (*gmep));
2195 dsl_pool_rele(dp, FTAG);
2199 static int dmu_recv_end_modified_blocks = 3;
2202 dmu_recv_existing_end(dmu_recv_cookie_t *drc)
2210 * We will be destroying the ds; make sure its origin is unmounted if
2213 name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
2214 dsl_dataset_name(drc->drc_ds, name);
2215 zfs_destroy_unmount_origin(name);
2216 kmem_free(name, MAXNAMELEN);
2219 error = dsl_sync_task(drc->drc_tofs,
2220 dmu_recv_end_check, dmu_recv_end_sync, drc,
2221 dmu_recv_end_modified_blocks, ZFS_SPACE_CHECK_NORMAL);
2224 dmu_recv_cleanup_ds(drc);
2229 dmu_recv_new_end(dmu_recv_cookie_t *drc)
2233 error = dsl_sync_task(drc->drc_tofs,
2234 dmu_recv_end_check, dmu_recv_end_sync, drc,
2235 dmu_recv_end_modified_blocks, ZFS_SPACE_CHECK_NORMAL);
2238 dmu_recv_cleanup_ds(drc);
2239 } else if (drc->drc_guid_to_ds_map != NULL) {
2240 (void) add_ds_to_guidmap(drc->drc_tofs,
2241 drc->drc_guid_to_ds_map,
2242 drc->drc_newsnapobj);
2248 dmu_recv_end(dmu_recv_cookie_t *drc, void *owner)
2250 drc->drc_owner = owner;
2253 return (dmu_recv_new_end(drc));
2255 return (dmu_recv_existing_end(drc));
2259 * Return TRUE if this objset is currently being received into.
2262 dmu_objset_is_receiving(objset_t *os)
2264 return (os->os_dsl_dataset != NULL &&
2265 os->os_dsl_dataset->ds_owner == dmu_recv_tag);
2268 #if defined(_KERNEL)
2269 module_param(zfs_send_corrupt_data, int, 0644);
2270 MODULE_PARM_DESC(zfs_send_corrupt_data, "Allow sending corrupt data");