1efb80947Sahrens /* 2efb80947Sahrens * CDDL HEADER START 3efb80947Sahrens * 4efb80947Sahrens * The contents of this file are subject to the terms of the 5efb80947Sahrens * Common Development and Distribution License (the "License"). 6efb80947Sahrens * You may not use this file except in compliance with the License. 7efb80947Sahrens * 8efb80947Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9efb80947Sahrens * or http://www.opensolaris.org/os/licensing. 10efb80947Sahrens * See the License for the specific language governing permissions 11efb80947Sahrens * and limitations under the License. 12efb80947Sahrens * 13efb80947Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14efb80947Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15efb80947Sahrens * If applicable, add the following below this CDDL HEADER, with the 16efb80947Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17efb80947Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18efb80947Sahrens * 19efb80947Sahrens * CDDL HEADER END 20efb80947Sahrens */ 21efb80947Sahrens /* 22*0a586ceaSMark Shellenbaum * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23efb80947Sahrens * Use is subject to license terms. 24efb80947Sahrens */ 25efb80947Sahrens 26efb80947Sahrens #include <sys/dmu.h> 27efb80947Sahrens #include <sys/dmu_impl.h> 28efb80947Sahrens #include <sys/dmu_tx.h> 29efb80947Sahrens #include <sys/dbuf.h> 30efb80947Sahrens #include <sys/dnode.h> 31efb80947Sahrens #include <sys/zfs_context.h> 32efb80947Sahrens #include <sys/dmu_objset.h> 33efb80947Sahrens #include <sys/dmu_traverse.h> 34efb80947Sahrens #include <sys/dsl_dataset.h> 35efb80947Sahrens #include <sys/dsl_dir.h> 3692241e0bSTom Erickson #include <sys/dsl_prop.h> 37efb80947Sahrens #include <sys/dsl_pool.h> 38efb80947Sahrens #include <sys/dsl_synctask.h> 39efb80947Sahrens #include <sys/zfs_ioctl.h> 40efb80947Sahrens #include <sys/zap.h> 41efb80947Sahrens #include <sys/zio_checksum.h> 429e69d7d0SLori Alt #include <sys/avl.h> 438e714474SLori Alt #include <sys/ddt.h> 44efb80947Sahrens 453cb34c60Sahrens static char *dmu_recv_tag = "dmu_recv_tag"; 463cb34c60Sahrens 479e69d7d0SLori Alt /* 489e69d7d0SLori Alt * The list of data whose inclusion in a send stream can be pending from 499e69d7d0SLori Alt * one call to backup_cb to another. Multiple calls to dump_free() and 509e69d7d0SLori Alt * dump_freeobjects() can be aggregated into a single DRR_FREE or 519e69d7d0SLori Alt * DRR_FREEOBJECTS replay record. 529e69d7d0SLori Alt */ 539e69d7d0SLori Alt typedef enum { 549e69d7d0SLori Alt PENDING_NONE, 559e69d7d0SLori Alt PENDING_FREE, 569e69d7d0SLori Alt PENDING_FREEOBJECTS 579e69d7d0SLori Alt } pendop_t; 589e69d7d0SLori Alt 59efb80947Sahrens struct backuparg { 60efb80947Sahrens dmu_replay_record_t *drr; 61efb80947Sahrens vnode_t *vp; 623cb34c60Sahrens offset_t *off; 63efb80947Sahrens objset_t *os; 64efb80947Sahrens zio_cksum_t zc; 659e69d7d0SLori Alt uint64_t toguid; 66efb80947Sahrens int err; 679e69d7d0SLori Alt pendop_t pending_op; 68efb80947Sahrens }; 69efb80947Sahrens 70efb80947Sahrens static int 71efb80947Sahrens dump_bytes(struct backuparg *ba, void *buf, int len) 72efb80947Sahrens { 73efb80947Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 74efb80947Sahrens ASSERT3U(len % 8, ==, 0); 75efb80947Sahrens 76efb80947Sahrens fletcher_4_incremental_native(buf, len, &ba->zc); 77efb80947Sahrens ba->err = vn_rdwr(UIO_WRITE, ba->vp, 78efb80947Sahrens (caddr_t)buf, len, 79efb80947Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 803cb34c60Sahrens *ba->off += len; 81efb80947Sahrens return (ba->err); 82efb80947Sahrens } 83efb80947Sahrens 84efb80947Sahrens static int 85efb80947Sahrens dump_free(struct backuparg *ba, uint64_t object, uint64_t offset, 86efb80947Sahrens uint64_t length) 87efb80947Sahrens { 889e69d7d0SLori Alt struct drr_free *drrf = &(ba->drr->drr_u.drr_free); 899e69d7d0SLori Alt 909e69d7d0SLori Alt /* 919e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 929e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 939e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 949e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 959e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 969e69d7d0SLori Alt */ 979e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && ba->pending_op != PENDING_FREE) { 989e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 999e69d7d0SLori Alt return (EINTR); 1009e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1019e69d7d0SLori Alt } 1029e69d7d0SLori Alt 1039e69d7d0SLori Alt if (ba->pending_op == PENDING_FREE) { 1049e69d7d0SLori Alt /* 1059e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 1069e69d7d0SLori Alt * (because dump_dnode is the only place where this 1079e69d7d0SLori Alt * function is called with a -1, and only after flushing 1089e69d7d0SLori Alt * any pending record). 1099e69d7d0SLori Alt */ 1109e69d7d0SLori Alt ASSERT(length != -1ULL); 1119e69d7d0SLori Alt /* 1129e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1139e69d7d0SLori Alt * with pending one. 1149e69d7d0SLori Alt */ 1159e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1169e69d7d0SLori Alt drrf->drr_length == offset) { 1179e69d7d0SLori Alt drrf->drr_length += length; 1189e69d7d0SLori Alt return (0); 1199e69d7d0SLori Alt } else { 1209e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1219e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 1229e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1239e69d7d0SLori Alt return (EINTR); 1249e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1259e69d7d0SLori Alt } 1269e69d7d0SLori Alt } 1279e69d7d0SLori Alt /* create a FREE record and make it pending */ 128efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 129efb80947Sahrens ba->drr->drr_type = DRR_FREE; 1309e69d7d0SLori Alt drrf->drr_object = object; 1319e69d7d0SLori Alt drrf->drr_offset = offset; 1329e69d7d0SLori Alt drrf->drr_length = length; 1339e69d7d0SLori Alt drrf->drr_toguid = ba->toguid; 1349e69d7d0SLori Alt if (length == -1ULL) { 1359e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1369e69d7d0SLori Alt return (EINTR); 1379e69d7d0SLori Alt } else { 1389e69d7d0SLori Alt ba->pending_op = PENDING_FREE; 1399e69d7d0SLori Alt } 140efb80947Sahrens 141efb80947Sahrens return (0); 142efb80947Sahrens } 143efb80947Sahrens 144efb80947Sahrens static int 145efb80947Sahrens dump_data(struct backuparg *ba, dmu_object_type_t type, 1468e714474SLori Alt uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data) 147efb80947Sahrens { 1489e69d7d0SLori Alt struct drr_write *drrw = &(ba->drr->drr_u.drr_write); 1499e69d7d0SLori Alt 1508e714474SLori Alt 1519e69d7d0SLori Alt /* 1529e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1539e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1549e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1559e69d7d0SLori Alt * of different types. 1569e69d7d0SLori Alt */ 1579e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 1589e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1599e69d7d0SLori Alt return (EINTR); 1609e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1619e69d7d0SLori Alt } 162efb80947Sahrens /* write a DATA record */ 163efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 164efb80947Sahrens ba->drr->drr_type = DRR_WRITE; 1659e69d7d0SLori Alt drrw->drr_object = object; 1669e69d7d0SLori Alt drrw->drr_type = type; 1679e69d7d0SLori Alt drrw->drr_offset = offset; 1689e69d7d0SLori Alt drrw->drr_length = blksz; 1699e69d7d0SLori Alt drrw->drr_toguid = ba->toguid; 1708e714474SLori Alt drrw->drr_checksumtype = BP_GET_CHECKSUM(bp); 1718e714474SLori Alt if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup) 1728e714474SLori Alt drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP; 1738e714474SLori Alt DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp)); 1748e714474SLori Alt DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp)); 1758e714474SLori Alt DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp)); 1768e714474SLori Alt drrw->drr_key.ddk_cksum = bp->blk_cksum; 177efb80947Sahrens 1789e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 179efb80947Sahrens return (EINTR); 1809e69d7d0SLori Alt if (dump_bytes(ba, data, blksz) != 0) 181efb80947Sahrens return (EINTR); 182efb80947Sahrens return (0); 183efb80947Sahrens } 184efb80947Sahrens 185*0a586ceaSMark Shellenbaum static int 186*0a586ceaSMark Shellenbaum dump_spill(struct backuparg *ba, uint64_t object, int blksz, void *data) 187*0a586ceaSMark Shellenbaum { 188*0a586ceaSMark Shellenbaum struct drr_spill *drrs = &(ba->drr->drr_u.drr_spill); 189*0a586ceaSMark Shellenbaum 190*0a586ceaSMark Shellenbaum if (ba->pending_op != PENDING_NONE) { 191*0a586ceaSMark Shellenbaum if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 192*0a586ceaSMark Shellenbaum return (EINTR); 193*0a586ceaSMark Shellenbaum ba->pending_op = PENDING_NONE; 194*0a586ceaSMark Shellenbaum } 195*0a586ceaSMark Shellenbaum 196*0a586ceaSMark Shellenbaum /* write a SPILL record */ 197*0a586ceaSMark Shellenbaum bzero(ba->drr, sizeof (dmu_replay_record_t)); 198*0a586ceaSMark Shellenbaum ba->drr->drr_type = DRR_SPILL; 199*0a586ceaSMark Shellenbaum drrs->drr_object = object; 200*0a586ceaSMark Shellenbaum drrs->drr_length = blksz; 201*0a586ceaSMark Shellenbaum drrs->drr_toguid = ba->toguid; 202*0a586ceaSMark Shellenbaum 203*0a586ceaSMark Shellenbaum if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 204*0a586ceaSMark Shellenbaum return (EINTR); 205*0a586ceaSMark Shellenbaum if (dump_bytes(ba, data, blksz)) 206*0a586ceaSMark Shellenbaum return (EINTR); 207*0a586ceaSMark Shellenbaum return (0); 208*0a586ceaSMark Shellenbaum } 209*0a586ceaSMark Shellenbaum 210efb80947Sahrens static int 211efb80947Sahrens dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs) 212efb80947Sahrens { 2139e69d7d0SLori Alt struct drr_freeobjects *drrfo = &(ba->drr->drr_u.drr_freeobjects); 2149e69d7d0SLori Alt 2159e69d7d0SLori Alt /* 2169e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 2179e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 2189e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 2199e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 2209e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 2219e69d7d0SLori Alt */ 2229e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && 2239e69d7d0SLori Alt ba->pending_op != PENDING_FREEOBJECTS) { 2249e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2259e69d7d0SLori Alt return (EINTR); 2269e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2279e69d7d0SLori Alt } 2289e69d7d0SLori Alt if (ba->pending_op == PENDING_FREEOBJECTS) { 2299e69d7d0SLori Alt /* 2309e69d7d0SLori Alt * See whether this free object array can be aggregated 2319e69d7d0SLori Alt * with pending one 2329e69d7d0SLori Alt */ 2339e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2349e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2359e69d7d0SLori Alt return (0); 2369e69d7d0SLori Alt } else { 2379e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2389e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 2399e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2409e69d7d0SLori Alt return (EINTR); 2419e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2429e69d7d0SLori Alt } 2439e69d7d0SLori Alt } 2449e69d7d0SLori Alt 245efb80947Sahrens /* write a FREEOBJECTS record */ 246efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 247efb80947Sahrens ba->drr->drr_type = DRR_FREEOBJECTS; 2489e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2499e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2509e69d7d0SLori Alt drrfo->drr_toguid = ba->toguid; 2519e69d7d0SLori Alt 2529e69d7d0SLori Alt ba->pending_op = PENDING_FREEOBJECTS; 253efb80947Sahrens 254efb80947Sahrens return (0); 255efb80947Sahrens } 256efb80947Sahrens 257efb80947Sahrens static int 258efb80947Sahrens dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp) 259efb80947Sahrens { 2609e69d7d0SLori Alt struct drr_object *drro = &(ba->drr->drr_u.drr_object); 2619e69d7d0SLori Alt 262efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 263efb80947Sahrens return (dump_freeobjects(ba, object, 1)); 264efb80947Sahrens 2659e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 2669e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2679e69d7d0SLori Alt return (EINTR); 2689e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2699e69d7d0SLori Alt } 2709e69d7d0SLori Alt 271efb80947Sahrens /* write an OBJECT record */ 272efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 273efb80947Sahrens ba->drr->drr_type = DRR_OBJECT; 2749e69d7d0SLori Alt drro->drr_object = object; 2759e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2769e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2779e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2789e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2799e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2809e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2819e69d7d0SLori Alt drro->drr_toguid = ba->toguid; 2829e69d7d0SLori Alt 2839e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 284efb80947Sahrens return (EINTR); 285efb80947Sahrens 2869e69d7d0SLori Alt if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 287efb80947Sahrens return (EINTR); 288efb80947Sahrens 289efb80947Sahrens /* free anything past the end of the file */ 290efb80947Sahrens if (dump_free(ba, object, (dnp->dn_maxblkid + 1) * 291efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 292efb80947Sahrens return (EINTR); 293efb80947Sahrens if (ba->err) 294efb80947Sahrens return (EINTR); 295efb80947Sahrens return (0); 296efb80947Sahrens } 297efb80947Sahrens 298efb80947Sahrens #define BP_SPAN(dnp, level) \ 299efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 300efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 301efb80947Sahrens 302b24ab676SJeff Bonwick /* ARGSUSED */ 303efb80947Sahrens static int 304b24ab676SJeff Bonwick backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 305b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 306efb80947Sahrens { 307efb80947Sahrens struct backuparg *ba = arg; 308efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 309efb80947Sahrens int err = 0; 310efb80947Sahrens 311efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 312efb80947Sahrens return (EINTR); 313efb80947Sahrens 314b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 315b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 31614843421SMatthew Ahrens return (0); 317b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 31888b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 31988b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 320efb80947Sahrens err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT); 321efb80947Sahrens } else if (bp == NULL) { 32288b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 32388b7b0f2SMatthew Ahrens err = dump_free(ba, zb->zb_object, zb->zb_blkid * span, span); 32488b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 32588b7b0f2SMatthew Ahrens return (0); 32688b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 32788b7b0f2SMatthew Ahrens dnode_phys_t *blk; 328efb80947Sahrens int i; 329efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 33088b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 33188b7b0f2SMatthew Ahrens arc_buf_t *abuf; 332efb80947Sahrens 33388b7b0f2SMatthew Ahrens if (arc_read_nolock(NULL, spa, bp, 33488b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 33588b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 33688b7b0f2SMatthew Ahrens return (EIO); 33788b7b0f2SMatthew Ahrens 33888b7b0f2SMatthew Ahrens blk = abuf->b_data; 339efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 34088b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 34188b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 342efb80947Sahrens err = dump_dnode(ba, dnobj, blk+i); 343efb80947Sahrens if (err) 344efb80947Sahrens break; 345efb80947Sahrens } 34688b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 347*0a586ceaSMark Shellenbaum } else if (type == DMU_OT_SA) { 348*0a586ceaSMark Shellenbaum uint32_t aflags = ARC_WAIT; 349*0a586ceaSMark Shellenbaum arc_buf_t *abuf; 350*0a586ceaSMark Shellenbaum int blksz = BP_GET_LSIZE(bp); 351*0a586ceaSMark Shellenbaum 352*0a586ceaSMark Shellenbaum if (arc_read_nolock(NULL, spa, bp, 353*0a586ceaSMark Shellenbaum arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 354*0a586ceaSMark Shellenbaum ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 355*0a586ceaSMark Shellenbaum return (EIO); 356*0a586ceaSMark Shellenbaum 357*0a586ceaSMark Shellenbaum err = dump_spill(ba, zb->zb_object, blksz, abuf->b_data); 358*0a586ceaSMark Shellenbaum (void) arc_buf_remove_ref(abuf, &abuf); 35988b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 36088b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 36188b7b0f2SMatthew Ahrens arc_buf_t *abuf; 362efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 36388b7b0f2SMatthew Ahrens 36488b7b0f2SMatthew Ahrens if (arc_read_nolock(NULL, spa, bp, 36588b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 36688b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 36788b7b0f2SMatthew Ahrens return (EIO); 36888b7b0f2SMatthew Ahrens 36988b7b0f2SMatthew Ahrens err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz, 3708e714474SLori Alt blksz, bp, abuf->b_data); 37188b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 372efb80947Sahrens } 373efb80947Sahrens 374efb80947Sahrens ASSERT(err == 0 || err == EINTR); 375efb80947Sahrens return (err); 376efb80947Sahrens } 377efb80947Sahrens 378efb80947Sahrens int 3793cb34c60Sahrens dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 3803cb34c60Sahrens vnode_t *vp, offset_t *off) 381efb80947Sahrens { 382503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 383503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 384efb80947Sahrens dmu_replay_record_t *drr; 385efb80947Sahrens struct backuparg ba; 386efb80947Sahrens int err; 3873cb34c60Sahrens uint64_t fromtxg = 0; 388efb80947Sahrens 389efb80947Sahrens /* tosnap must be a snapshot */ 390efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 391efb80947Sahrens return (EINVAL); 392efb80947Sahrens 393efb80947Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 394efb80947Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 3953cb34c60Sahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 396efb80947Sahrens return (EXDEV); 397efb80947Sahrens 3983cb34c60Sahrens if (fromorigin) { 399088f3894Sahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 400088f3894Sahrens 4013cb34c60Sahrens if (fromsnap) 4023cb34c60Sahrens return (EINVAL); 4033cb34c60Sahrens 404088f3894Sahrens if (dsl_dir_is_clone(ds->ds_dir)) { 4053cb34c60Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 406745cd3c5Smaybee err = dsl_dataset_hold_obj(dp, 407745cd3c5Smaybee ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 4083cb34c60Sahrens rw_exit(&dp->dp_config_rwlock); 4093cb34c60Sahrens if (err) 4103cb34c60Sahrens return (err); 4113cb34c60Sahrens } else { 4123cb34c60Sahrens fromorigin = B_FALSE; 4133cb34c60Sahrens } 4143cb34c60Sahrens } 4153cb34c60Sahrens 4163cb34c60Sahrens 417efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 418efb80947Sahrens drr->drr_type = DRR_BEGIN; 419efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 4209e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 4219e69d7d0SLori Alt DMU_SUBSTREAM); 422efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 423efb80947Sahrens ds->ds_phys->ds_creation_time; 424503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 4253cb34c60Sahrens if (fromorigin) 4263cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 427efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 428ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 429ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 430ab04eb8eStimh 431efb80947Sahrens if (fromds) 432efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 433efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 434efb80947Sahrens 4353cb34c60Sahrens if (fromds) 4363cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 4373cb34c60Sahrens if (fromorigin) 438745cd3c5Smaybee dsl_dataset_rele(fromds, FTAG); 4393cb34c60Sahrens 440efb80947Sahrens ba.drr = drr; 441efb80947Sahrens ba.vp = vp; 442efb80947Sahrens ba.os = tosnap; 4433cb34c60Sahrens ba.off = off; 4449e69d7d0SLori Alt ba.toguid = ds->ds_phys->ds_guid; 445efb80947Sahrens ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0); 4469e69d7d0SLori Alt ba.pending_op = PENDING_NONE; 447efb80947Sahrens 4489e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 449efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 450efb80947Sahrens return (ba.err); 451efb80947Sahrens } 452efb80947Sahrens 45388b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 454efb80947Sahrens backup_cb, &ba); 455efb80947Sahrens 4569e69d7d0SLori Alt if (ba.pending_op != PENDING_NONE) 4579e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) 4589e69d7d0SLori Alt err = EINTR; 4599e69d7d0SLori Alt 460efb80947Sahrens if (err) { 461efb80947Sahrens if (err == EINTR && ba.err) 462efb80947Sahrens err = ba.err; 4637b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 464efb80947Sahrens return (err); 465efb80947Sahrens } 466efb80947Sahrens 467efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 468efb80947Sahrens drr->drr_type = DRR_END; 469efb80947Sahrens drr->drr_u.drr_end.drr_checksum = ba.zc; 4709e69d7d0SLori Alt drr->drr_u.drr_end.drr_toguid = ba.toguid; 471efb80947Sahrens 4729e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 4737b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 474efb80947Sahrens return (ba.err); 4757b5309bbSgw } 476efb80947Sahrens 477efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 478efb80947Sahrens 479efb80947Sahrens return (0); 480efb80947Sahrens } 481efb80947Sahrens 4823cb34c60Sahrens struct recvbeginsyncarg { 4833cb34c60Sahrens const char *tofs; 4843cb34c60Sahrens const char *tosnap; 4853cb34c60Sahrens dsl_dataset_t *origin; 4863cb34c60Sahrens uint64_t fromguid; 4873cb34c60Sahrens dmu_objset_type_t type; 4883cb34c60Sahrens void *tag; 4893cb34c60Sahrens boolean_t force; 490ab04eb8eStimh uint64_t dsflags; 4913cb34c60Sahrens char clonelastname[MAXNAMELEN]; 4923cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 493efb80947Sahrens }; 494efb80947Sahrens 495efb80947Sahrens /* ARGSUSED */ 496efb80947Sahrens static int 497ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 498efb80947Sahrens { 499efb80947Sahrens dsl_dir_t *dd = arg1; 5003cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 501efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 502efb80947Sahrens uint64_t val; 503efb80947Sahrens int err; 504efb80947Sahrens 505efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 5063cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 507efb80947Sahrens 508efb80947Sahrens if (err != ENOENT) 509efb80947Sahrens return (err ? err : EEXIST); 510efb80947Sahrens 5113cb34c60Sahrens if (rbsa->origin) { 5123cb34c60Sahrens /* make sure it's a snap in the same pool */ 5133cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 5143cb34c60Sahrens return (EXDEV); 515ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 5163cb34c60Sahrens return (EINVAL); 5173cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 5183cb34c60Sahrens return (ENODEV); 5193cb34c60Sahrens } 5203cb34c60Sahrens 521efb80947Sahrens return (0); 522efb80947Sahrens } 523efb80947Sahrens 524efb80947Sahrens static void 525ae46e4c7SMatthew Ahrens recv_new_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 526efb80947Sahrens { 527efb80947Sahrens dsl_dir_t *dd = arg1; 5283cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 529745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 530efb80947Sahrens uint64_t dsobj; 531efb80947Sahrens 532ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 5333cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 534ab04eb8eStimh rbsa->origin, flags, cr, tx); 535ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 536503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 537efb80947Sahrens 538ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 539ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 540ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 5413cb34c60Sahrens } 542ecd6cf80Smarks 543ae46e4c7SMatthew Ahrens spa_history_internal_log(LOG_DS_REPLAY_FULL_SYNC, 544ae46e4c7SMatthew Ahrens dd->dd_pool->dp_spa, tx, cr, "dataset = %lld", dsobj); 5453cb34c60Sahrens } 546f18faf3fSek 547f18faf3fSek /* ARGSUSED */ 548f18faf3fSek static int 549ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 550f18faf3fSek { 5513cb34c60Sahrens dsl_dataset_t *ds = arg1; 5523cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5533cb34c60Sahrens int err; 5543cb34c60Sahrens uint64_t val; 555f18faf3fSek 5563cb34c60Sahrens /* must not have any changes since most recent snapshot */ 5573cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 558f18faf3fSek return (ETXTBSY); 559f18faf3fSek 560ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 561ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 562ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 563ae46e4c7SMatthew Ahrens return (ENODEV); 56492241e0bSTom Erickson 56592241e0bSTom Erickson /* 56692241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 56792241e0bSTom Erickson * changes since the fromguid one 56892241e0bSTom Erickson */ 56992241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 57092241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 57192241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 57292241e0bSTom Erickson while (obj != 0) { 57392241e0bSTom Erickson dsl_dataset_t *snap; 57492241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 57592241e0bSTom Erickson obj, FTAG, &snap); 57692241e0bSTom Erickson if (err) 57792241e0bSTom Erickson return (ENODEV); 57892241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 57992241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 58092241e0bSTom Erickson return (ENODEV); 58192241e0bSTom Erickson } 58292241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 58392241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 58492241e0bSTom Erickson break; /* it's ok */ 58592241e0bSTom Erickson } 58692241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 58792241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 58892241e0bSTom Erickson } 58992241e0bSTom Erickson if (obj == 0) 59092241e0bSTom Erickson return (ENODEV); 59192241e0bSTom Erickson } 592ae46e4c7SMatthew Ahrens } else { 593ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 594ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 595ae46e4c7SMatthew Ahrens return (ENODEV); 596ae46e4c7SMatthew Ahrens } 5973cb34c60Sahrens 59847f263f4Sek /* temporary clone name must not exist */ 59947f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 60047f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 60147f263f4Sek rbsa->clonelastname, 8, 1, &val); 60247f263f4Sek if (err == 0) 60347f263f4Sek return (EEXIST); 60447f263f4Sek if (err != ENOENT) 60547f263f4Sek return (err); 60647f263f4Sek 6073cb34c60Sahrens /* new snapshot name must not exist */ 6083cb34c60Sahrens err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 6093cb34c60Sahrens ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 6103cb34c60Sahrens if (err == 0) 6113cb34c60Sahrens return (EEXIST); 6123cb34c60Sahrens if (err != ENOENT) 6133cb34c60Sahrens return (err); 6143cb34c60Sahrens return (0); 615f18faf3fSek } 616f18faf3fSek 617f18faf3fSek /* ARGSUSED */ 618f18faf3fSek static void 619ae46e4c7SMatthew Ahrens recv_existing_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 620f18faf3fSek { 6213cb34c60Sahrens dsl_dataset_t *ohds = arg1; 6223cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 6233cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 624ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 625745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 626f18faf3fSek uint64_t dsobj; 627f18faf3fSek 628ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 629ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 630ae46e4c7SMatthew Ahrens ohds->ds_prev, flags, cr, tx); 631503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 6323cb34c60Sahrens 633ae46e4c7SMatthew Ahrens /* 634ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 635ae46e4c7SMatthew Ahrens * objset in our new dataset. 636ae46e4c7SMatthew Ahrens */ 637ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 638ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 639ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 640ae46e4c7SMatthew Ahrens } 641ae46e4c7SMatthew Ahrens 6423cb34c60Sahrens rbsa->ds = cds; 6433cb34c60Sahrens 6443cb34c60Sahrens spa_history_internal_log(LOG_DS_REPLAY_INC_SYNC, 645745cd3c5Smaybee dp->dp_spa, tx, cr, "dataset = %lld", dsobj); 6463cb34c60Sahrens } 6473cb34c60Sahrens 6483cb34c60Sahrens /* 6493cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 6503cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 6513cb34c60Sahrens */ 6523cb34c60Sahrens int 6539e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 654f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 655efb80947Sahrens { 6563cb34c60Sahrens int err = 0; 6573cb34c60Sahrens boolean_t byteswap; 658ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 6599e69d7d0SLori Alt uint64_t versioninfo; 6603cb34c60Sahrens int flags; 6613cb34c60Sahrens dsl_dataset_t *ds; 662efb80947Sahrens 6633cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 6643cb34c60Sahrens byteswap = FALSE; 6653cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 6663cb34c60Sahrens byteswap = TRUE; 6673cb34c60Sahrens else 6683cb34c60Sahrens return (EINVAL); 6693cb34c60Sahrens 6703cb34c60Sahrens rbsa.tofs = tofs; 6713cb34c60Sahrens rbsa.tosnap = tosnap; 672503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 6733cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 6743cb34c60Sahrens rbsa.type = drrb->drr_type; 6753cb34c60Sahrens rbsa.tag = FTAG; 676ab04eb8eStimh rbsa.dsflags = 0; 6779e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 6783cb34c60Sahrens flags = drrb->drr_flags; 6793cb34c60Sahrens 6803cb34c60Sahrens if (byteswap) { 6813cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 6823cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 6839e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 6843cb34c60Sahrens flags = BSWAP_32(flags); 6853cb34c60Sahrens } 686efb80947Sahrens 6879e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 6883cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 6893cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 690efb80947Sahrens return (EINVAL); 691efb80947Sahrens 692ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 693ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 694ab04eb8eStimh 6953cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 6963cb34c60Sahrens drc->drc_drrb = drrb; 6973cb34c60Sahrens drc->drc_tosnap = tosnap; 6989e69d7d0SLori Alt drc->drc_top_ds = top_ds; 6993cb34c60Sahrens drc->drc_force = force; 700efb80947Sahrens 7013cb34c60Sahrens /* 7023cb34c60Sahrens * Process the begin in syncing context. 7033cb34c60Sahrens */ 704efb80947Sahrens 705ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 706ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 707ae46e4c7SMatthew Ahrens if (err == 0) { 708ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 709efb80947Sahrens 710ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 711ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 712ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 713ae46e4c7SMatthew Ahrens return (EINVAL); 714ae46e4c7SMatthew Ahrens } 715efb80947Sahrens 716f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 717f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 718f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 719f4b94bdeSMatthew Ahrens return (EBUSY); 720f4b94bdeSMatthew Ahrens } 721f4b94bdeSMatthew Ahrens 722ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 723ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 724ae46e4c7SMatthew Ahrens "%%%s", tosnap); 7253cb34c60Sahrens rbsa.force = force; 7263cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 727ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 7283cb34c60Sahrens if (err) { 729f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 730745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 7313cb34c60Sahrens return (err); 7323cb34c60Sahrens } 7333cb34c60Sahrens drc->drc_logical_ds = ds; 7343cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 735ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 736ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 737ae46e4c7SMatthew Ahrens char *cp; 738efb80947Sahrens 739ae46e4c7SMatthew Ahrens /* 740ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 741ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 742ae46e4c7SMatthew Ahrens */ 743ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 744ae46e4c7SMatthew Ahrens return (ENOENT); 745ae46e4c7SMatthew Ahrens 746ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 747ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 748ae46e4c7SMatthew Ahrens *cp = '\0'; 749bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 750ae46e4c7SMatthew Ahrens *cp = '/'; 7513cb34c60Sahrens if (err) 7523cb34c60Sahrens return (err); 753efb80947Sahrens 754ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 755ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 756bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 7573cb34c60Sahrens if (err) 7583cb34c60Sahrens return (err); 7593cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 7603cb34c60Sahrens drc->drc_newfs = B_TRUE; 7613cb34c60Sahrens } 7623cb34c60Sahrens 763ae46e4c7SMatthew Ahrens return (err); 764efb80947Sahrens } 765efb80947Sahrens 7663cb34c60Sahrens struct restorearg { 7673cb34c60Sahrens int err; 7683cb34c60Sahrens int byteswap; 7693cb34c60Sahrens vnode_t *vp; 7703cb34c60Sahrens char *buf; 7713cb34c60Sahrens uint64_t voff; 7723cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 7733cb34c60Sahrens zio_cksum_t cksum; 7749e69d7d0SLori Alt avl_tree_t guid_to_ds_map; 7753cb34c60Sahrens }; 7763cb34c60Sahrens 7779e69d7d0SLori Alt typedef struct guid_map_entry { 7789e69d7d0SLori Alt uint64_t guid; 7799e69d7d0SLori Alt dsl_dataset_t *gme_ds; 7809e69d7d0SLori Alt avl_node_t avlnode; 7819e69d7d0SLori Alt } guid_map_entry_t; 7829e69d7d0SLori Alt 7839e69d7d0SLori Alt static int 7849e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 7859e69d7d0SLori Alt { 7869e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 7879e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 7889e69d7d0SLori Alt 7899e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 7909e69d7d0SLori Alt return (-1); 7919e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 7929e69d7d0SLori Alt return (1); 7939e69d7d0SLori Alt return (0); 7949e69d7d0SLori Alt } 7959e69d7d0SLori Alt 7969e69d7d0SLori Alt /* 7979e69d7d0SLori Alt * This function is a callback used by dmu_objset_find() (which 7989e69d7d0SLori Alt * enumerates the object sets) to build an avl tree that maps guids 7999e69d7d0SLori Alt * to datasets. The resulting table is used when processing DRR_WRITE_BYREF 8009e69d7d0SLori Alt * send stream records. These records, which are used in dedup'ed 8019e69d7d0SLori Alt * streams, do not contain data themselves, but refer to a copy 8029e69d7d0SLori Alt * of the data block that has already been written because it was 8039e69d7d0SLori Alt * earlier in the stream. That previous copy is identified by the 8049e69d7d0SLori Alt * guid of the dataset with the referenced data. 8059e69d7d0SLori Alt */ 8069e69d7d0SLori Alt int 807fd136879SMatthew Ahrens find_ds_by_guid(const char *name, void *arg) 8089e69d7d0SLori Alt { 8099e69d7d0SLori Alt avl_tree_t *guid_map = arg; 810fd136879SMatthew Ahrens dsl_dataset_t *ds, *snapds; 8119e69d7d0SLori Alt guid_map_entry_t *gmep; 812fd136879SMatthew Ahrens dsl_pool_t *dp; 8139e69d7d0SLori Alt int err; 8149e69d7d0SLori Alt uint64_t lastobj, firstobj; 8159e69d7d0SLori Alt 8169e69d7d0SLori Alt if (dsl_dataset_hold(name, FTAG, &ds) != 0) 8179e69d7d0SLori Alt return (0); 8189e69d7d0SLori Alt 8199e69d7d0SLori Alt dp = ds->ds_dir->dd_pool; 8209e69d7d0SLori Alt rw_enter(&dp->dp_config_rwlock, RW_READER); 8219e69d7d0SLori Alt firstobj = ds->ds_dir->dd_phys->dd_origin_obj; 8229e69d7d0SLori Alt lastobj = ds->ds_phys->ds_prev_snap_obj; 8239e69d7d0SLori Alt 8249e69d7d0SLori Alt while (lastobj != firstobj) { 8259e69d7d0SLori Alt err = dsl_dataset_hold_obj(dp, lastobj, guid_map, &snapds); 8269e69d7d0SLori Alt if (err) { 8279e69d7d0SLori Alt /* 8289e69d7d0SLori Alt * Skip this snapshot and move on. It's not 8299e69d7d0SLori Alt * clear why this would ever happen, but the 8309e69d7d0SLori Alt * remainder of the snapshot streadm can be 8319e69d7d0SLori Alt * processed. 8329e69d7d0SLori Alt */ 8339e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 8349e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 8359e69d7d0SLori Alt return (0); 8369e69d7d0SLori Alt } 8379e69d7d0SLori Alt 8389e69d7d0SLori Alt gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 8399e69d7d0SLori Alt gmep->guid = snapds->ds_phys->ds_guid; 8409e69d7d0SLori Alt gmep->gme_ds = snapds; 8419e69d7d0SLori Alt avl_add(guid_map, gmep); 8429e69d7d0SLori Alt lastobj = snapds->ds_phys->ds_prev_snap_obj; 8439e69d7d0SLori Alt } 8449e69d7d0SLori Alt 8459e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 8469e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 8479e69d7d0SLori Alt 8489e69d7d0SLori Alt return (0); 8499e69d7d0SLori Alt } 8509e69d7d0SLori Alt 851efb80947Sahrens static void * 852efb80947Sahrens restore_read(struct restorearg *ra, int len) 853efb80947Sahrens { 854efb80947Sahrens void *rv; 8553cb34c60Sahrens int done = 0; 856efb80947Sahrens 857efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 858efb80947Sahrens ASSERT3U(len % 8, ==, 0); 859efb80947Sahrens 8603cb34c60Sahrens while (done < len) { 861efb80947Sahrens ssize_t resid; 862efb80947Sahrens 863efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 8643cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 865efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 866efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 867efb80947Sahrens 8683cb34c60Sahrens if (resid == len - done) 869efb80947Sahrens ra->err = EINVAL; 8703cb34c60Sahrens ra->voff += len - done - resid; 8713cb34c60Sahrens done = len - resid; 872efb80947Sahrens if (ra->err) 873efb80947Sahrens return (NULL); 874efb80947Sahrens } 875efb80947Sahrens 8763cb34c60Sahrens ASSERT3U(done, ==, len); 8773cb34c60Sahrens rv = ra->buf; 878efb80947Sahrens if (ra->byteswap) 8793cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 880efb80947Sahrens else 8813cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 882efb80947Sahrens return (rv); 883efb80947Sahrens } 884efb80947Sahrens 885efb80947Sahrens static void 886efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 887efb80947Sahrens { 888efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 889efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 890efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 8913cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 892efb80947Sahrens switch (drr->drr_type) { 893efb80947Sahrens case DRR_BEGIN: 894efb80947Sahrens DO64(drr_begin.drr_magic); 8959e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 896efb80947Sahrens DO64(drr_begin.drr_creation_time); 897efb80947Sahrens DO32(drr_begin.drr_type); 8983cb34c60Sahrens DO32(drr_begin.drr_flags); 899efb80947Sahrens DO64(drr_begin.drr_toguid); 900efb80947Sahrens DO64(drr_begin.drr_fromguid); 901efb80947Sahrens break; 902efb80947Sahrens case DRR_OBJECT: 903efb80947Sahrens DO64(drr_object.drr_object); 904efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 905efb80947Sahrens DO32(drr_object.drr_type); 906efb80947Sahrens DO32(drr_object.drr_bonustype); 907efb80947Sahrens DO32(drr_object.drr_blksz); 908efb80947Sahrens DO32(drr_object.drr_bonuslen); 9099e69d7d0SLori Alt DO64(drr_object.drr_toguid); 910efb80947Sahrens break; 911efb80947Sahrens case DRR_FREEOBJECTS: 912efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 913efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 9149e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 915efb80947Sahrens break; 916efb80947Sahrens case DRR_WRITE: 917efb80947Sahrens DO64(drr_write.drr_object); 918efb80947Sahrens DO32(drr_write.drr_type); 919efb80947Sahrens DO64(drr_write.drr_offset); 920efb80947Sahrens DO64(drr_write.drr_length); 9219e69d7d0SLori Alt DO64(drr_write.drr_toguid); 9228e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[0]); 9238e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[1]); 9248e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[2]); 9258e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[3]); 9268e714474SLori Alt DO64(drr_write.drr_key.ddk_prop); 9279e69d7d0SLori Alt break; 9289e69d7d0SLori Alt case DRR_WRITE_BYREF: 9299e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 9309e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 9319e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 9329e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 9339e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 9349e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 9359e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 9368e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]); 9378e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]); 9388e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]); 9398e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]); 9408e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_prop); 941efb80947Sahrens break; 942efb80947Sahrens case DRR_FREE: 943efb80947Sahrens DO64(drr_free.drr_object); 944efb80947Sahrens DO64(drr_free.drr_offset); 945efb80947Sahrens DO64(drr_free.drr_length); 9469e69d7d0SLori Alt DO64(drr_free.drr_toguid); 947efb80947Sahrens break; 948*0a586ceaSMark Shellenbaum case DRR_SPILL: 949*0a586ceaSMark Shellenbaum DO64(drr_spill.drr_object); 950*0a586ceaSMark Shellenbaum DO64(drr_spill.drr_length); 951*0a586ceaSMark Shellenbaum DO64(drr_spill.drr_toguid); 952*0a586ceaSMark Shellenbaum break; 953efb80947Sahrens case DRR_END: 954efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 955efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 956efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 957efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 9589e69d7d0SLori Alt DO64(drr_end.drr_toguid); 959efb80947Sahrens break; 960efb80947Sahrens } 961efb80947Sahrens #undef DO64 962efb80947Sahrens #undef DO32 963efb80947Sahrens } 964efb80947Sahrens 965efb80947Sahrens static int 966efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 967efb80947Sahrens { 968efb80947Sahrens int err; 969efb80947Sahrens dmu_tx_t *tx; 970adee0b6fSTim Haley void *data = NULL; 971efb80947Sahrens 972efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 973efb80947Sahrens drro->drr_type >= DMU_OT_NUMTYPES || 974efb80947Sahrens drro->drr_bonustype >= DMU_OT_NUMTYPES || 9759e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 976efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 977efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 978efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 979efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 980efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 981efb80947Sahrens return (EINVAL); 982efb80947Sahrens } 983efb80947Sahrens 9842bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 9852bf405a2SMark Maybee 9862bf405a2SMark Maybee if (err != 0 && err != ENOENT) 9872bf405a2SMark Maybee return (EINVAL); 9882bf405a2SMark Maybee 989adee0b6fSTim Haley if (drro->drr_bonuslen) { 990adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 991adee0b6fSTim Haley if (ra->err) 992adee0b6fSTim Haley return (ra->err); 993adee0b6fSTim Haley } 994adee0b6fSTim Haley 995efb80947Sahrens if (err == ENOENT) { 996efb80947Sahrens /* currently free, want to be allocated */ 9972bf405a2SMark Maybee tx = dmu_tx_create(os); 998efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 999efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1000efb80947Sahrens if (err) { 1001efb80947Sahrens dmu_tx_abort(tx); 1002efb80947Sahrens return (err); 1003efb80947Sahrens } 1004efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 1005efb80947Sahrens drro->drr_type, drro->drr_blksz, 1006efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 10072bf405a2SMark Maybee dmu_tx_commit(tx); 1008efb80947Sahrens } else { 1009efb80947Sahrens /* currently allocated, want to be allocated */ 1010efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 1011efb80947Sahrens drro->drr_type, drro->drr_blksz, 10122bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 1013efb80947Sahrens } 1014*0a586ceaSMark Shellenbaum if (err) { 1015efb80947Sahrens return (EINVAL); 1016*0a586ceaSMark Shellenbaum } 10172bf405a2SMark Maybee 10182bf405a2SMark Maybee tx = dmu_tx_create(os); 10192bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 10202bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 10212bf405a2SMark Maybee if (err) { 10222bf405a2SMark Maybee dmu_tx_abort(tx); 10232bf405a2SMark Maybee return (err); 1024efb80947Sahrens } 1025efb80947Sahrens 10269e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 10279e69d7d0SLori Alt tx); 1028efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 1029efb80947Sahrens 1030adee0b6fSTim Haley if (data != NULL) { 1031efb80947Sahrens dmu_buf_t *db; 1032adee0b6fSTim Haley 1033efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 1034efb80947Sahrens dmu_buf_will_dirty(db, tx); 1035efb80947Sahrens 10361934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 10371934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 1038efb80947Sahrens if (ra->byteswap) { 1039efb80947Sahrens dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 1040efb80947Sahrens drro->drr_bonuslen); 1041efb80947Sahrens } 1042efb80947Sahrens dmu_buf_rele(db, FTAG); 1043efb80947Sahrens } 1044efb80947Sahrens dmu_tx_commit(tx); 1045efb80947Sahrens return (0); 1046efb80947Sahrens } 1047efb80947Sahrens 1048efb80947Sahrens /* ARGSUSED */ 1049efb80947Sahrens static int 1050efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1051efb80947Sahrens struct drr_freeobjects *drrfo) 1052efb80947Sahrens { 1053efb80947Sahrens uint64_t obj; 1054efb80947Sahrens 1055efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1056efb80947Sahrens return (EINVAL); 1057efb80947Sahrens 1058efb80947Sahrens for (obj = drrfo->drr_firstobj; 1059432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1060432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1061efb80947Sahrens int err; 1062efb80947Sahrens 1063efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1064efb80947Sahrens continue; 1065efb80947Sahrens 1066cdb0ab79Smaybee err = dmu_free_object(os, obj); 1067cdb0ab79Smaybee if (err) 1068efb80947Sahrens return (err); 1069efb80947Sahrens } 1070efb80947Sahrens return (0); 1071efb80947Sahrens } 1072efb80947Sahrens 1073efb80947Sahrens static int 1074efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1075efb80947Sahrens struct drr_write *drrw) 1076efb80947Sahrens { 1077efb80947Sahrens dmu_tx_t *tx; 1078efb80947Sahrens void *data; 1079efb80947Sahrens int err; 1080efb80947Sahrens 1081efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1082efb80947Sahrens drrw->drr_type >= DMU_OT_NUMTYPES) 1083efb80947Sahrens return (EINVAL); 1084efb80947Sahrens 1085efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1086efb80947Sahrens if (data == NULL) 1087efb80947Sahrens return (ra->err); 1088efb80947Sahrens 1089efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1090efb80947Sahrens return (EINVAL); 1091efb80947Sahrens 1092efb80947Sahrens tx = dmu_tx_create(os); 1093efb80947Sahrens 1094efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1095efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1096efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1097efb80947Sahrens if (err) { 1098efb80947Sahrens dmu_tx_abort(tx); 1099efb80947Sahrens return (err); 1100efb80947Sahrens } 1101efb80947Sahrens if (ra->byteswap) 1102efb80947Sahrens dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 1103efb80947Sahrens dmu_write(os, drrw->drr_object, 1104efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1105efb80947Sahrens dmu_tx_commit(tx); 1106efb80947Sahrens return (0); 1107efb80947Sahrens } 1108efb80947Sahrens 11099e69d7d0SLori Alt /* 11109e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 11119e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 11129e69d7d0SLori Alt * system because it came in earlier in the stream. This function 11139e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 11149e69d7d0SLori Alt * data from the stream to fulfill this write. 11159e69d7d0SLori Alt */ 11169e69d7d0SLori Alt static int 11179e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 11189e69d7d0SLori Alt struct drr_write_byref *drrwbr) 11199e69d7d0SLori Alt { 11209e69d7d0SLori Alt dmu_tx_t *tx; 11219e69d7d0SLori Alt int err; 11229e69d7d0SLori Alt guid_map_entry_t gmesrch; 11239e69d7d0SLori Alt guid_map_entry_t *gmep; 11249e69d7d0SLori Alt avl_index_t where; 11259e69d7d0SLori Alt objset_t *ref_os = NULL; 11269e69d7d0SLori Alt dmu_buf_t *dbp; 11279e69d7d0SLori Alt 11289e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 11299e69d7d0SLori Alt return (EINVAL); 11309e69d7d0SLori Alt 11319e69d7d0SLori Alt /* 11329e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 11339e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 11349e69d7d0SLori Alt */ 11359e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 11369e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 11379e69d7d0SLori Alt if ((gmep = avl_find(&ra->guid_to_ds_map, &gmesrch, 11389e69d7d0SLori Alt &where)) == NULL) { 11399e69d7d0SLori Alt return (EINVAL); 11409e69d7d0SLori Alt } 11419e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 11429e69d7d0SLori Alt return (EINVAL); 11439e69d7d0SLori Alt } else { 11449e69d7d0SLori Alt ref_os = os; 11459e69d7d0SLori Alt } 11469e69d7d0SLori Alt 11479e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 11489e69d7d0SLori Alt drrwbr->drr_refoffset, FTAG, &dbp)) 11499e69d7d0SLori Alt return (err); 11509e69d7d0SLori Alt 11519e69d7d0SLori Alt tx = dmu_tx_create(os); 11529e69d7d0SLori Alt 11539e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 11549e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 11559e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 11569e69d7d0SLori Alt if (err) { 11579e69d7d0SLori Alt dmu_tx_abort(tx); 11589e69d7d0SLori Alt return (err); 11599e69d7d0SLori Alt } 11609e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 11619e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 11629e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 11639e69d7d0SLori Alt dmu_tx_commit(tx); 11649e69d7d0SLori Alt return (0); 11659e69d7d0SLori Alt } 11669e69d7d0SLori Alt 1167*0a586ceaSMark Shellenbaum static int 1168*0a586ceaSMark Shellenbaum restore_spill(struct restorearg *ra, objset_t *os, struct drr_spill *drrs) 1169*0a586ceaSMark Shellenbaum { 1170*0a586ceaSMark Shellenbaum dmu_tx_t *tx; 1171*0a586ceaSMark Shellenbaum void *data; 1172*0a586ceaSMark Shellenbaum dmu_buf_t *db, *db_spill; 1173*0a586ceaSMark Shellenbaum int err; 1174*0a586ceaSMark Shellenbaum 1175*0a586ceaSMark Shellenbaum if (drrs->drr_length < SPA_MINBLOCKSIZE || 1176*0a586ceaSMark Shellenbaum drrs->drr_length > SPA_MAXBLOCKSIZE) 1177*0a586ceaSMark Shellenbaum return (EINVAL); 1178*0a586ceaSMark Shellenbaum 1179*0a586ceaSMark Shellenbaum data = restore_read(ra, drrs->drr_length); 1180*0a586ceaSMark Shellenbaum if (data == NULL) 1181*0a586ceaSMark Shellenbaum return (ra->err); 1182*0a586ceaSMark Shellenbaum 1183*0a586ceaSMark Shellenbaum if (dmu_object_info(os, drrs->drr_object, NULL) != 0) 1184*0a586ceaSMark Shellenbaum return (EINVAL); 1185*0a586ceaSMark Shellenbaum 1186*0a586ceaSMark Shellenbaum VERIFY(0 == dmu_bonus_hold(os, drrs->drr_object, FTAG, &db)); 1187*0a586ceaSMark Shellenbaum if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) { 1188*0a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 1189*0a586ceaSMark Shellenbaum return (err); 1190*0a586ceaSMark Shellenbaum } 1191*0a586ceaSMark Shellenbaum 1192*0a586ceaSMark Shellenbaum tx = dmu_tx_create(os); 1193*0a586ceaSMark Shellenbaum 1194*0a586ceaSMark Shellenbaum dmu_tx_hold_spill(tx, db->db_object); 1195*0a586ceaSMark Shellenbaum 1196*0a586ceaSMark Shellenbaum err = dmu_tx_assign(tx, TXG_WAIT); 1197*0a586ceaSMark Shellenbaum if (err) { 1198*0a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 1199*0a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 1200*0a586ceaSMark Shellenbaum dmu_tx_abort(tx); 1201*0a586ceaSMark Shellenbaum return (err); 1202*0a586ceaSMark Shellenbaum } 1203*0a586ceaSMark Shellenbaum dmu_buf_will_dirty(db_spill, tx); 1204*0a586ceaSMark Shellenbaum 1205*0a586ceaSMark Shellenbaum if (db_spill->db_size < drrs->drr_length) 1206*0a586ceaSMark Shellenbaum VERIFY(0 == dbuf_spill_set_blksz(db_spill, 1207*0a586ceaSMark Shellenbaum drrs->drr_length, tx)); 1208*0a586ceaSMark Shellenbaum bcopy(data, db_spill->db_data, drrs->drr_length); 1209*0a586ceaSMark Shellenbaum 1210*0a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 1211*0a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 1212*0a586ceaSMark Shellenbaum 1213*0a586ceaSMark Shellenbaum dmu_tx_commit(tx); 1214*0a586ceaSMark Shellenbaum return (0); 1215*0a586ceaSMark Shellenbaum } 1216*0a586ceaSMark Shellenbaum 1217efb80947Sahrens /* ARGSUSED */ 1218efb80947Sahrens static int 1219efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1220efb80947Sahrens struct drr_free *drrf) 1221efb80947Sahrens { 1222efb80947Sahrens int err; 1223efb80947Sahrens 1224efb80947Sahrens if (drrf->drr_length != -1ULL && 1225efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1226efb80947Sahrens return (EINVAL); 1227efb80947Sahrens 1228efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1229efb80947Sahrens return (EINVAL); 1230efb80947Sahrens 1231cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1232efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1233efb80947Sahrens return (err); 1234efb80947Sahrens } 1235efb80947Sahrens 12363cb34c60Sahrens /* 12373cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 12383cb34c60Sahrens */ 1239efb80947Sahrens int 12403cb34c60Sahrens dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp) 1241efb80947Sahrens { 12423cb34c60Sahrens struct restorearg ra = { 0 }; 1243efb80947Sahrens dmu_replay_record_t *drr; 12443cb34c60Sahrens objset_t *os; 12453cb34c60Sahrens zio_cksum_t pcksum; 12469e69d7d0SLori Alt guid_map_entry_t *gmep; 12479e69d7d0SLori Alt int featureflags; 1248efb80947Sahrens 12493cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1250efb80947Sahrens ra.byteswap = TRUE; 1251efb80947Sahrens 12523cb34c60Sahrens { 12533cb34c60Sahrens /* compute checksum of drr_begin record */ 12543cb34c60Sahrens dmu_replay_record_t *drr; 12553cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 12563cb34c60Sahrens 12573cb34c60Sahrens drr->drr_type = DRR_BEGIN; 12583cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 12593cb34c60Sahrens if (ra.byteswap) { 12603cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 12613cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 12623cb34c60Sahrens } else { 12633cb34c60Sahrens fletcher_4_incremental_native(drr, 12643cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 12653cb34c60Sahrens } 12663cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1267efb80947Sahrens } 1268efb80947Sahrens 1269efb80947Sahrens if (ra.byteswap) { 12703cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1271efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 12729e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1273efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1274efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1275efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1276efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1277efb80947Sahrens } 1278efb80947Sahrens 12793cb34c60Sahrens ra.vp = vp; 12803cb34c60Sahrens ra.voff = *voffp; 12813cb34c60Sahrens ra.bufsize = 1<<20; 12823cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1283efb80947Sahrens 12843cb34c60Sahrens /* these were verified in dmu_recv_begin */ 12859e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 12869e69d7d0SLori Alt DMU_SUBSTREAM); 12873cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1288efb80947Sahrens 1289efb80947Sahrens /* 1290efb80947Sahrens * Open the objset we are modifying. 1291efb80947Sahrens */ 1292503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1293efb80947Sahrens 12943cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1295efb80947Sahrens 12969e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 12979e69d7d0SLori Alt 12989e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 12999e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 13009e69d7d0SLori Alt avl_create(&ra.guid_to_ds_map, guid_compare, 13019e69d7d0SLori Alt sizeof (guid_map_entry_t), 13029e69d7d0SLori Alt offsetof(guid_map_entry_t, avlnode)); 13039e69d7d0SLori Alt (void) dmu_objset_find(drc->drc_top_ds, find_ds_by_guid, 13049e69d7d0SLori Alt (void *)&ra.guid_to_ds_map, 13059e69d7d0SLori Alt DS_FIND_CHILDREN); 13069e69d7d0SLori Alt } 13079e69d7d0SLori Alt 1308efb80947Sahrens /* 1309efb80947Sahrens * Read records and process them. 1310efb80947Sahrens */ 13113cb34c60Sahrens pcksum = ra.cksum; 1312efb80947Sahrens while (ra.err == 0 && 1313efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1314efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1315efb80947Sahrens ra.err = EINTR; 1316efb80947Sahrens goto out; 1317efb80947Sahrens } 1318efb80947Sahrens 1319efb80947Sahrens if (ra.byteswap) 1320efb80947Sahrens backup_byteswap(drr); 1321efb80947Sahrens 1322efb80947Sahrens switch (drr->drr_type) { 1323efb80947Sahrens case DRR_OBJECT: 1324efb80947Sahrens { 1325efb80947Sahrens /* 1326efb80947Sahrens * We need to make a copy of the record header, 1327efb80947Sahrens * because restore_{object,write} may need to 1328efb80947Sahrens * restore_read(), which will invalidate drr. 1329efb80947Sahrens */ 1330efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1331efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1332efb80947Sahrens break; 1333efb80947Sahrens } 1334efb80947Sahrens case DRR_FREEOBJECTS: 1335efb80947Sahrens { 1336efb80947Sahrens struct drr_freeobjects drrfo = 1337efb80947Sahrens drr->drr_u.drr_freeobjects; 1338efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1339efb80947Sahrens break; 1340efb80947Sahrens } 1341efb80947Sahrens case DRR_WRITE: 1342efb80947Sahrens { 1343efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1344efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1345efb80947Sahrens break; 1346efb80947Sahrens } 13479e69d7d0SLori Alt case DRR_WRITE_BYREF: 13489e69d7d0SLori Alt { 13499e69d7d0SLori Alt struct drr_write_byref drrwbr = 13509e69d7d0SLori Alt drr->drr_u.drr_write_byref; 13519e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 13529e69d7d0SLori Alt break; 13539e69d7d0SLori Alt } 1354efb80947Sahrens case DRR_FREE: 1355efb80947Sahrens { 1356efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1357efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1358efb80947Sahrens break; 1359efb80947Sahrens } 1360efb80947Sahrens case DRR_END: 1361efb80947Sahrens { 1362efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1363efb80947Sahrens /* 1364efb80947Sahrens * We compare against the *previous* checksum 1365efb80947Sahrens * value, because the stored checksum is of 1366efb80947Sahrens * everything before the DRR_END record. 1367efb80947Sahrens */ 1368137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1369efb80947Sahrens ra.err = ECKSUM; 1370efb80947Sahrens goto out; 1371efb80947Sahrens } 1372*0a586ceaSMark Shellenbaum case DRR_SPILL: 1373*0a586ceaSMark Shellenbaum { 1374*0a586ceaSMark Shellenbaum struct drr_spill drrs = drr->drr_u.drr_spill; 1375*0a586ceaSMark Shellenbaum ra.err = restore_spill(&ra, os, &drrs); 1376*0a586ceaSMark Shellenbaum break; 1377*0a586ceaSMark Shellenbaum } 1378efb80947Sahrens default: 1379efb80947Sahrens ra.err = EINVAL; 1380efb80947Sahrens goto out; 1381efb80947Sahrens } 13823cb34c60Sahrens pcksum = ra.cksum; 1383efb80947Sahrens } 1384137fa067Sahrens ASSERT(ra.err != 0); 1385efb80947Sahrens 1386efb80947Sahrens out: 13873cb34c60Sahrens if (ra.err != 0) { 1388efb80947Sahrens /* 1389f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1390f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1391efb80947Sahrens */ 13923cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1393f4b94bdeSMatthew Ahrens 1394842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1395842727c2SChris Kirby B_FALSE); 1396f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1397f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1398f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1399f4b94bdeSMatthew Ahrens } 1400efb80947Sahrens } 1401efb80947Sahrens 14029e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 14039e69d7d0SLori Alt void *cookie = NULL; 14049e69d7d0SLori Alt 14059e69d7d0SLori Alt while (gmep = avl_destroy_nodes(&ra.guid_to_ds_map, &cookie)) { 14069e69d7d0SLori Alt dsl_dataset_rele(gmep->gme_ds, &ra.guid_to_ds_map); 14079e69d7d0SLori Alt kmem_free(gmep, sizeof (guid_map_entry_t)); 14089e69d7d0SLori Alt } 14099e69d7d0SLori Alt avl_destroy(&ra.guid_to_ds_map); 14109e69d7d0SLori Alt } 14119e69d7d0SLori Alt 1412efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 14133cb34c60Sahrens *voffp = ra.voff; 1414efb80947Sahrens return (ra.err); 1415efb80947Sahrens } 1416f18faf3fSek 14173cb34c60Sahrens struct recvendsyncarg { 14183cb34c60Sahrens char *tosnap; 14193cb34c60Sahrens uint64_t creation_time; 14203cb34c60Sahrens uint64_t toguid; 14213cb34c60Sahrens }; 14223cb34c60Sahrens 14233cb34c60Sahrens static int 14243cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 14253cb34c60Sahrens { 14263cb34c60Sahrens dsl_dataset_t *ds = arg1; 14273cb34c60Sahrens struct recvendsyncarg *resa = arg2; 14283cb34c60Sahrens 14293cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 14303cb34c60Sahrens } 14313cb34c60Sahrens 14323cb34c60Sahrens static void 14333cb34c60Sahrens recv_end_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 14343cb34c60Sahrens { 14353cb34c60Sahrens dsl_dataset_t *ds = arg1; 14363cb34c60Sahrens struct recvendsyncarg *resa = arg2; 14373cb34c60Sahrens 14383cb34c60Sahrens dsl_dataset_snapshot_sync(ds, resa->tosnap, cr, tx); 14393cb34c60Sahrens 14403cb34c60Sahrens /* set snapshot's creation time and guid */ 14413cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 14423cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 14433cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 14443cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 14453cb34c60Sahrens 14463cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 14473cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 14483cb34c60Sahrens } 14493cb34c60Sahrens 1450ae46e4c7SMatthew Ahrens static int 1451ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1452f18faf3fSek { 1453745cd3c5Smaybee struct recvendsyncarg resa; 1454745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 1455745cd3c5Smaybee int err; 1456f18faf3fSek 14573cb34c60Sahrens /* 1458ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1459ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1460ae46e4c7SMatthew Ahrens * can close it. 14613cb34c60Sahrens */ 1462745cd3c5Smaybee txg_wait_synced(ds->ds_dir->dd_pool, 0); 14633cb34c60Sahrens 1464ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1465ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1466ae46e4c7SMatthew Ahrens drc->drc_force); 1467ae46e4c7SMatthew Ahrens if (err) 1468ae46e4c7SMatthew Ahrens goto out; 1469ae46e4c7SMatthew Ahrens } else { 1470ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1471ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1472842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1473842727c2SChris Kirby B_FALSE); 1474ae46e4c7SMatthew Ahrens return (EBUSY); 14753cb34c60Sahrens } 14763cb34c60Sahrens 1477745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1478745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1479745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 14803cb34c60Sahrens 1481745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1482745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1483745cd3c5Smaybee if (err) { 1484ae46e4c7SMatthew Ahrens /* swap back */ 1485ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 14863cb34c60Sahrens } 14873cb34c60Sahrens 1488ae46e4c7SMatthew Ahrens out: 1489ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1490745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 1491ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 1492f18faf3fSek return (err); 1493f18faf3fSek } 1494ae46e4c7SMatthew Ahrens 1495ae46e4c7SMatthew Ahrens static int 1496ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1497ae46e4c7SMatthew Ahrens { 1498ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1499ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1500ae46e4c7SMatthew Ahrens int err; 1501ae46e4c7SMatthew Ahrens 1502ae46e4c7SMatthew Ahrens /* 1503ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1504ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1505ae46e4c7SMatthew Ahrens * can close it. 1506ae46e4c7SMatthew Ahrens */ 1507ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1508ae46e4c7SMatthew Ahrens 1509ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1510ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1511ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1512ae46e4c7SMatthew Ahrens 1513ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1514ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1515ae46e4c7SMatthew Ahrens if (err) { 1516ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1517ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1518ae46e4c7SMatthew Ahrens } else { 1519ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1520ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1521ae46e4c7SMatthew Ahrens } 1522ae46e4c7SMatthew Ahrens return (err); 1523ae46e4c7SMatthew Ahrens } 1524ae46e4c7SMatthew Ahrens 1525ae46e4c7SMatthew Ahrens int 1526ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1527ae46e4c7SMatthew Ahrens { 1528ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1529ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1530ae46e4c7SMatthew Ahrens else 1531ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1532ae46e4c7SMatthew Ahrens } 1533