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 /* 22dc7cd546SMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23efb80947Sahrens */ 24*ec5cf9d5SAlexander Stetsenko /* 25*ec5cf9d5SAlexander Stetsenko * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 26*ec5cf9d5SAlexander Stetsenko */ 27efb80947Sahrens 28efb80947Sahrens #include <sys/dmu.h> 29efb80947Sahrens #include <sys/dmu_impl.h> 30efb80947Sahrens #include <sys/dmu_tx.h> 31efb80947Sahrens #include <sys/dbuf.h> 32efb80947Sahrens #include <sys/dnode.h> 33efb80947Sahrens #include <sys/zfs_context.h> 34efb80947Sahrens #include <sys/dmu_objset.h> 35efb80947Sahrens #include <sys/dmu_traverse.h> 36efb80947Sahrens #include <sys/dsl_dataset.h> 37efb80947Sahrens #include <sys/dsl_dir.h> 3892241e0bSTom Erickson #include <sys/dsl_prop.h> 39efb80947Sahrens #include <sys/dsl_pool.h> 40efb80947Sahrens #include <sys/dsl_synctask.h> 41efb80947Sahrens #include <sys/zfs_ioctl.h> 42efb80947Sahrens #include <sys/zap.h> 43efb80947Sahrens #include <sys/zio_checksum.h> 44dc7cd546SMark Shellenbaum #include <sys/zfs_znode.h> 45cde58dbcSMatthew Ahrens #include <zfs_fletcher.h> 469e69d7d0SLori Alt #include <sys/avl.h> 478e714474SLori Alt #include <sys/ddt.h> 48c99e4bdcSChris Kirby #include <sys/zfs_onexit.h> 49efb80947Sahrens 503cb34c60Sahrens static char *dmu_recv_tag = "dmu_recv_tag"; 513cb34c60Sahrens 529e69d7d0SLori Alt /* 539e69d7d0SLori Alt * The list of data whose inclusion in a send stream can be pending from 549e69d7d0SLori Alt * one call to backup_cb to another. Multiple calls to dump_free() and 559e69d7d0SLori Alt * dump_freeobjects() can be aggregated into a single DRR_FREE or 569e69d7d0SLori Alt * DRR_FREEOBJECTS replay record. 579e69d7d0SLori Alt */ 589e69d7d0SLori Alt typedef enum { 599e69d7d0SLori Alt PENDING_NONE, 609e69d7d0SLori Alt PENDING_FREE, 619e69d7d0SLori Alt PENDING_FREEOBJECTS 629e69d7d0SLori Alt } pendop_t; 639e69d7d0SLori Alt 64efb80947Sahrens struct backuparg { 65efb80947Sahrens dmu_replay_record_t *drr; 66efb80947Sahrens vnode_t *vp; 673cb34c60Sahrens offset_t *off; 68efb80947Sahrens objset_t *os; 69efb80947Sahrens zio_cksum_t zc; 709e69d7d0SLori Alt uint64_t toguid; 71efb80947Sahrens int err; 729e69d7d0SLori Alt pendop_t pending_op; 73efb80947Sahrens }; 74efb80947Sahrens 75efb80947Sahrens static int 76efb80947Sahrens dump_bytes(struct backuparg *ba, void *buf, int len) 77efb80947Sahrens { 78efb80947Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 79efb80947Sahrens ASSERT3U(len % 8, ==, 0); 80efb80947Sahrens 81efb80947Sahrens fletcher_4_incremental_native(buf, len, &ba->zc); 82efb80947Sahrens ba->err = vn_rdwr(UIO_WRITE, ba->vp, 83efb80947Sahrens (caddr_t)buf, len, 84efb80947Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 853cb34c60Sahrens *ba->off += len; 86efb80947Sahrens return (ba->err); 87efb80947Sahrens } 88efb80947Sahrens 89efb80947Sahrens static int 90efb80947Sahrens dump_free(struct backuparg *ba, uint64_t object, uint64_t offset, 91efb80947Sahrens uint64_t length) 92efb80947Sahrens { 939e69d7d0SLori Alt struct drr_free *drrf = &(ba->drr->drr_u.drr_free); 949e69d7d0SLori Alt 959e69d7d0SLori Alt /* 969e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 979e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 989e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 999e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 1009e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 1019e69d7d0SLori Alt */ 1029e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && ba->pending_op != PENDING_FREE) { 1039e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1049e69d7d0SLori Alt return (EINTR); 1059e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1069e69d7d0SLori Alt } 1079e69d7d0SLori Alt 1089e69d7d0SLori Alt if (ba->pending_op == PENDING_FREE) { 1099e69d7d0SLori Alt /* 1109e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 1119e69d7d0SLori Alt * (because dump_dnode is the only place where this 1129e69d7d0SLori Alt * function is called with a -1, and only after flushing 1139e69d7d0SLori Alt * any pending record). 1149e69d7d0SLori Alt */ 1159e69d7d0SLori Alt ASSERT(length != -1ULL); 1169e69d7d0SLori Alt /* 1179e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1189e69d7d0SLori Alt * with pending one. 1199e69d7d0SLori Alt */ 1209e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1219e69d7d0SLori Alt drrf->drr_length == offset) { 1229e69d7d0SLori Alt drrf->drr_length += length; 1239e69d7d0SLori Alt return (0); 1249e69d7d0SLori Alt } else { 1259e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1269e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 1279e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1289e69d7d0SLori Alt return (EINTR); 1299e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1309e69d7d0SLori Alt } 1319e69d7d0SLori Alt } 1329e69d7d0SLori Alt /* create a FREE record and make it pending */ 133efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 134efb80947Sahrens ba->drr->drr_type = DRR_FREE; 1359e69d7d0SLori Alt drrf->drr_object = object; 1369e69d7d0SLori Alt drrf->drr_offset = offset; 1379e69d7d0SLori Alt drrf->drr_length = length; 1389e69d7d0SLori Alt drrf->drr_toguid = ba->toguid; 1399e69d7d0SLori Alt if (length == -1ULL) { 1409e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1419e69d7d0SLori Alt return (EINTR); 1429e69d7d0SLori Alt } else { 1439e69d7d0SLori Alt ba->pending_op = PENDING_FREE; 1449e69d7d0SLori Alt } 145efb80947Sahrens 146efb80947Sahrens return (0); 147efb80947Sahrens } 148efb80947Sahrens 149efb80947Sahrens static int 150efb80947Sahrens dump_data(struct backuparg *ba, dmu_object_type_t type, 1518e714474SLori Alt uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data) 152efb80947Sahrens { 1539e69d7d0SLori Alt struct drr_write *drrw = &(ba->drr->drr_u.drr_write); 1549e69d7d0SLori Alt 1558e714474SLori Alt 1569e69d7d0SLori Alt /* 1579e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1589e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1599e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1609e69d7d0SLori Alt * of different types. 1619e69d7d0SLori Alt */ 1629e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 1639e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1649e69d7d0SLori Alt return (EINTR); 1659e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1669e69d7d0SLori Alt } 167efb80947Sahrens /* write a DATA record */ 168efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 169efb80947Sahrens ba->drr->drr_type = DRR_WRITE; 1709e69d7d0SLori Alt drrw->drr_object = object; 1719e69d7d0SLori Alt drrw->drr_type = type; 1729e69d7d0SLori Alt drrw->drr_offset = offset; 1739e69d7d0SLori Alt drrw->drr_length = blksz; 1749e69d7d0SLori Alt drrw->drr_toguid = ba->toguid; 1758e714474SLori Alt drrw->drr_checksumtype = BP_GET_CHECKSUM(bp); 1768e714474SLori Alt if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup) 1778e714474SLori Alt drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP; 1788e714474SLori Alt DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp)); 1798e714474SLori Alt DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp)); 1808e714474SLori Alt DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp)); 1818e714474SLori Alt drrw->drr_key.ddk_cksum = bp->blk_cksum; 182efb80947Sahrens 1839e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 184efb80947Sahrens return (EINTR); 1859e69d7d0SLori Alt if (dump_bytes(ba, data, blksz) != 0) 186efb80947Sahrens return (EINTR); 187efb80947Sahrens return (0); 188efb80947Sahrens } 189efb80947Sahrens 1900a586ceaSMark Shellenbaum static int 1910a586ceaSMark Shellenbaum dump_spill(struct backuparg *ba, uint64_t object, int blksz, void *data) 1920a586ceaSMark Shellenbaum { 1930a586ceaSMark Shellenbaum struct drr_spill *drrs = &(ba->drr->drr_u.drr_spill); 1940a586ceaSMark Shellenbaum 1950a586ceaSMark Shellenbaum if (ba->pending_op != PENDING_NONE) { 1960a586ceaSMark Shellenbaum if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1970a586ceaSMark Shellenbaum return (EINTR); 1980a586ceaSMark Shellenbaum ba->pending_op = PENDING_NONE; 1990a586ceaSMark Shellenbaum } 2000a586ceaSMark Shellenbaum 2010a586ceaSMark Shellenbaum /* write a SPILL record */ 2020a586ceaSMark Shellenbaum bzero(ba->drr, sizeof (dmu_replay_record_t)); 2030a586ceaSMark Shellenbaum ba->drr->drr_type = DRR_SPILL; 2040a586ceaSMark Shellenbaum drrs->drr_object = object; 2050a586ceaSMark Shellenbaum drrs->drr_length = blksz; 2060a586ceaSMark Shellenbaum drrs->drr_toguid = ba->toguid; 2070a586ceaSMark Shellenbaum 2080a586ceaSMark Shellenbaum if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 2090a586ceaSMark Shellenbaum return (EINTR); 2100a586ceaSMark Shellenbaum if (dump_bytes(ba, data, blksz)) 2110a586ceaSMark Shellenbaum return (EINTR); 2120a586ceaSMark Shellenbaum return (0); 2130a586ceaSMark Shellenbaum } 2140a586ceaSMark Shellenbaum 215efb80947Sahrens static int 216efb80947Sahrens dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs) 217efb80947Sahrens { 2189e69d7d0SLori Alt struct drr_freeobjects *drrfo = &(ba->drr->drr_u.drr_freeobjects); 2199e69d7d0SLori Alt 2209e69d7d0SLori Alt /* 2219e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 2229e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 2239e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 2249e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 2259e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 2269e69d7d0SLori Alt */ 2279e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && 2289e69d7d0SLori Alt ba->pending_op != PENDING_FREEOBJECTS) { 2299e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2309e69d7d0SLori Alt return (EINTR); 2319e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2329e69d7d0SLori Alt } 2339e69d7d0SLori Alt if (ba->pending_op == PENDING_FREEOBJECTS) { 2349e69d7d0SLori Alt /* 2359e69d7d0SLori Alt * See whether this free object array can be aggregated 2369e69d7d0SLori Alt * with pending one 2379e69d7d0SLori Alt */ 2389e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2399e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2409e69d7d0SLori Alt return (0); 2419e69d7d0SLori Alt } else { 2429e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2439e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 2449e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2459e69d7d0SLori Alt return (EINTR); 2469e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2479e69d7d0SLori Alt } 2489e69d7d0SLori Alt } 2499e69d7d0SLori Alt 250efb80947Sahrens /* write a FREEOBJECTS record */ 251efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 252efb80947Sahrens ba->drr->drr_type = DRR_FREEOBJECTS; 2539e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2549e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2559e69d7d0SLori Alt drrfo->drr_toguid = ba->toguid; 2569e69d7d0SLori Alt 2579e69d7d0SLori Alt ba->pending_op = PENDING_FREEOBJECTS; 258efb80947Sahrens 259efb80947Sahrens return (0); 260efb80947Sahrens } 261efb80947Sahrens 262efb80947Sahrens static int 263efb80947Sahrens dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp) 264efb80947Sahrens { 2659e69d7d0SLori Alt struct drr_object *drro = &(ba->drr->drr_u.drr_object); 2669e69d7d0SLori Alt 267efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 268efb80947Sahrens return (dump_freeobjects(ba, object, 1)); 269efb80947Sahrens 2709e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 2719e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2729e69d7d0SLori Alt return (EINTR); 2739e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2749e69d7d0SLori Alt } 2759e69d7d0SLori Alt 276efb80947Sahrens /* write an OBJECT record */ 277efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 278efb80947Sahrens ba->drr->drr_type = DRR_OBJECT; 2799e69d7d0SLori Alt drro->drr_object = object; 2809e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2819e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2829e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2839e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2849e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2859e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2869e69d7d0SLori Alt drro->drr_toguid = ba->toguid; 2879e69d7d0SLori Alt 2889e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 289efb80947Sahrens return (EINTR); 290efb80947Sahrens 2919e69d7d0SLori Alt if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 292efb80947Sahrens return (EINTR); 293efb80947Sahrens 294efb80947Sahrens /* free anything past the end of the file */ 295efb80947Sahrens if (dump_free(ba, object, (dnp->dn_maxblkid + 1) * 296efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 297efb80947Sahrens return (EINTR); 298efb80947Sahrens if (ba->err) 299efb80947Sahrens return (EINTR); 300efb80947Sahrens return (0); 301efb80947Sahrens } 302efb80947Sahrens 303efb80947Sahrens #define BP_SPAN(dnp, level) \ 304efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 305efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 306efb80947Sahrens 307b24ab676SJeff Bonwick /* ARGSUSED */ 308efb80947Sahrens static int 3093f9d6ad7SLin Ling backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf, 310b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 311efb80947Sahrens { 312efb80947Sahrens struct backuparg *ba = arg; 313efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 314efb80947Sahrens int err = 0; 315efb80947Sahrens 316efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 317efb80947Sahrens return (EINTR); 318efb80947Sahrens 319b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 320b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 32114843421SMatthew Ahrens return (0); 322b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 32388b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 32488b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 325efb80947Sahrens err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT); 326efb80947Sahrens } else if (bp == NULL) { 32788b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 32888b7b0f2SMatthew Ahrens err = dump_free(ba, zb->zb_object, zb->zb_blkid * span, span); 32988b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 33088b7b0f2SMatthew Ahrens return (0); 33188b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 33288b7b0f2SMatthew Ahrens dnode_phys_t *blk; 333efb80947Sahrens int i; 334efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 33588b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 33688b7b0f2SMatthew Ahrens arc_buf_t *abuf; 337efb80947Sahrens 3383f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 33988b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 34088b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 34188b7b0f2SMatthew Ahrens return (EIO); 34288b7b0f2SMatthew Ahrens 34388b7b0f2SMatthew Ahrens blk = abuf->b_data; 344efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 34588b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 34688b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 347efb80947Sahrens err = dump_dnode(ba, dnobj, blk+i); 348efb80947Sahrens if (err) 349efb80947Sahrens break; 350efb80947Sahrens } 35188b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 3520a586ceaSMark Shellenbaum } else if (type == DMU_OT_SA) { 3530a586ceaSMark Shellenbaum uint32_t aflags = ARC_WAIT; 3540a586ceaSMark Shellenbaum arc_buf_t *abuf; 3550a586ceaSMark Shellenbaum int blksz = BP_GET_LSIZE(bp); 3560a586ceaSMark Shellenbaum 3570a586ceaSMark Shellenbaum if (arc_read_nolock(NULL, spa, bp, 3580a586ceaSMark Shellenbaum arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 3590a586ceaSMark Shellenbaum ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 3600a586ceaSMark Shellenbaum return (EIO); 3610a586ceaSMark Shellenbaum 3620a586ceaSMark Shellenbaum err = dump_spill(ba, zb->zb_object, blksz, abuf->b_data); 3630a586ceaSMark Shellenbaum (void) arc_buf_remove_ref(abuf, &abuf); 36488b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 36588b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 36688b7b0f2SMatthew Ahrens arc_buf_t *abuf; 367efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 36888b7b0f2SMatthew Ahrens 3693f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 37088b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 37188b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 37288b7b0f2SMatthew Ahrens return (EIO); 37388b7b0f2SMatthew Ahrens 37488b7b0f2SMatthew Ahrens err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz, 3758e714474SLori Alt blksz, bp, abuf->b_data); 37688b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 377efb80947Sahrens } 378efb80947Sahrens 379efb80947Sahrens ASSERT(err == 0 || err == EINTR); 380efb80947Sahrens return (err); 381efb80947Sahrens } 382efb80947Sahrens 383efb80947Sahrens int 3843cb34c60Sahrens dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 3853cb34c60Sahrens vnode_t *vp, offset_t *off) 386efb80947Sahrens { 387503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 388503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 389efb80947Sahrens dmu_replay_record_t *drr; 390efb80947Sahrens struct backuparg ba; 391efb80947Sahrens int err; 3923cb34c60Sahrens uint64_t fromtxg = 0; 393efb80947Sahrens 394efb80947Sahrens /* tosnap must be a snapshot */ 395efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 396efb80947Sahrens return (EINVAL); 397efb80947Sahrens 398efb80947Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 399efb80947Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 4003cb34c60Sahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 401efb80947Sahrens return (EXDEV); 402efb80947Sahrens 4033cb34c60Sahrens if (fromorigin) { 404088f3894Sahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 405088f3894Sahrens 4063cb34c60Sahrens if (fromsnap) 4073cb34c60Sahrens return (EINVAL); 4083cb34c60Sahrens 409088f3894Sahrens if (dsl_dir_is_clone(ds->ds_dir)) { 4103cb34c60Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 411745cd3c5Smaybee err = dsl_dataset_hold_obj(dp, 412745cd3c5Smaybee ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 4133cb34c60Sahrens rw_exit(&dp->dp_config_rwlock); 4143cb34c60Sahrens if (err) 4153cb34c60Sahrens return (err); 4163cb34c60Sahrens } else { 4173cb34c60Sahrens fromorigin = B_FALSE; 4183cb34c60Sahrens } 4193cb34c60Sahrens } 4203cb34c60Sahrens 4213cb34c60Sahrens 422efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 423efb80947Sahrens drr->drr_type = DRR_BEGIN; 424efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 4259e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 4269e69d7d0SLori Alt DMU_SUBSTREAM); 427dc7cd546SMark Shellenbaum 428dc7cd546SMark Shellenbaum #ifdef _KERNEL 429dc7cd546SMark Shellenbaum if (dmu_objset_type(tosnap) == DMU_OST_ZFS) { 430dc7cd546SMark Shellenbaum uint64_t version; 431dc7cd546SMark Shellenbaum if (zfs_get_zplprop(tosnap, ZFS_PROP_VERSION, &version) != 0) 432dc7cd546SMark Shellenbaum return (EINVAL); 433dc7cd546SMark Shellenbaum if (version == ZPL_VERSION_SA) { 434dc7cd546SMark Shellenbaum DMU_SET_FEATUREFLAGS( 435dc7cd546SMark Shellenbaum drr->drr_u.drr_begin.drr_versioninfo, 436dc7cd546SMark Shellenbaum DMU_BACKUP_FEATURE_SA_SPILL); 437dc7cd546SMark Shellenbaum } 438dc7cd546SMark Shellenbaum } 439dc7cd546SMark Shellenbaum #endif 440dc7cd546SMark Shellenbaum 441efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 442efb80947Sahrens ds->ds_phys->ds_creation_time; 443503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 4443cb34c60Sahrens if (fromorigin) 4453cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 446efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 447ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 448ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 449ab04eb8eStimh 450efb80947Sahrens if (fromds) 451efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 452efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 453efb80947Sahrens 4543cb34c60Sahrens if (fromds) 4553cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 4563cb34c60Sahrens if (fromorigin) 457745cd3c5Smaybee dsl_dataset_rele(fromds, FTAG); 4583cb34c60Sahrens 459efb80947Sahrens ba.drr = drr; 460efb80947Sahrens ba.vp = vp; 461efb80947Sahrens ba.os = tosnap; 4623cb34c60Sahrens ba.off = off; 4639e69d7d0SLori Alt ba.toguid = ds->ds_phys->ds_guid; 464efb80947Sahrens ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0); 4659e69d7d0SLori Alt ba.pending_op = PENDING_NONE; 466efb80947Sahrens 4679e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 468efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 469efb80947Sahrens return (ba.err); 470efb80947Sahrens } 471efb80947Sahrens 47288b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 473efb80947Sahrens backup_cb, &ba); 474efb80947Sahrens 4759e69d7d0SLori Alt if (ba.pending_op != PENDING_NONE) 4769e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) 4779e69d7d0SLori Alt err = EINTR; 4789e69d7d0SLori Alt 479efb80947Sahrens if (err) { 480efb80947Sahrens if (err == EINTR && ba.err) 481efb80947Sahrens err = ba.err; 4827b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 483efb80947Sahrens return (err); 484efb80947Sahrens } 485efb80947Sahrens 486efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 487efb80947Sahrens drr->drr_type = DRR_END; 488efb80947Sahrens drr->drr_u.drr_end.drr_checksum = ba.zc; 4899e69d7d0SLori Alt drr->drr_u.drr_end.drr_toguid = ba.toguid; 490efb80947Sahrens 4919e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 4927b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 493efb80947Sahrens return (ba.err); 4947b5309bbSgw } 495efb80947Sahrens 496efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 497efb80947Sahrens 498efb80947Sahrens return (0); 499efb80947Sahrens } 500efb80947Sahrens 5013cb34c60Sahrens struct recvbeginsyncarg { 5023cb34c60Sahrens const char *tofs; 5033cb34c60Sahrens const char *tosnap; 5043cb34c60Sahrens dsl_dataset_t *origin; 5053cb34c60Sahrens uint64_t fromguid; 5063cb34c60Sahrens dmu_objset_type_t type; 5073cb34c60Sahrens void *tag; 5083cb34c60Sahrens boolean_t force; 509ab04eb8eStimh uint64_t dsflags; 5103cb34c60Sahrens char clonelastname[MAXNAMELEN]; 5113cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 5123f9d6ad7SLin Ling cred_t *cr; 513efb80947Sahrens }; 514efb80947Sahrens 515efb80947Sahrens /* ARGSUSED */ 516efb80947Sahrens static int 517ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 518efb80947Sahrens { 519efb80947Sahrens dsl_dir_t *dd = arg1; 5203cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 521efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 522efb80947Sahrens uint64_t val; 523efb80947Sahrens int err; 524efb80947Sahrens 525efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 5263cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 527efb80947Sahrens 528efb80947Sahrens if (err != ENOENT) 529efb80947Sahrens return (err ? err : EEXIST); 530efb80947Sahrens 5313cb34c60Sahrens if (rbsa->origin) { 5323cb34c60Sahrens /* make sure it's a snap in the same pool */ 5333cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 5343cb34c60Sahrens return (EXDEV); 535ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 5363cb34c60Sahrens return (EINVAL); 5373cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 5383cb34c60Sahrens return (ENODEV); 5393cb34c60Sahrens } 5403cb34c60Sahrens 541efb80947Sahrens return (0); 542efb80947Sahrens } 543efb80947Sahrens 544efb80947Sahrens static void 5453f9d6ad7SLin Ling recv_new_sync(void *arg1, void *arg2, dmu_tx_t *tx) 546efb80947Sahrens { 547efb80947Sahrens dsl_dir_t *dd = arg1; 5483cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 549745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 550efb80947Sahrens uint64_t dsobj; 551efb80947Sahrens 552ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 5533cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 5543f9d6ad7SLin Ling rbsa->origin, flags, rbsa->cr, tx); 555ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 556503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 557efb80947Sahrens 558ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 559ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 560ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 5613cb34c60Sahrens } 562ecd6cf80Smarks 5633f9d6ad7SLin Ling spa_history_log_internal(LOG_DS_REPLAY_FULL_SYNC, 5643f9d6ad7SLin Ling dd->dd_pool->dp_spa, tx, "dataset = %lld", dsobj); 5653cb34c60Sahrens } 566f18faf3fSek 567f18faf3fSek /* ARGSUSED */ 568f18faf3fSek static int 569ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 570f18faf3fSek { 5713cb34c60Sahrens dsl_dataset_t *ds = arg1; 5723cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5733cb34c60Sahrens int err; 5743cb34c60Sahrens uint64_t val; 575f18faf3fSek 5763cb34c60Sahrens /* must not have any changes since most recent snapshot */ 5773cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 578f18faf3fSek return (ETXTBSY); 579f18faf3fSek 580feaa74e4SMark Maybee /* new snapshot name must not exist */ 581feaa74e4SMark Maybee err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 582feaa74e4SMark Maybee ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 583feaa74e4SMark Maybee if (err == 0) 584feaa74e4SMark Maybee return (EEXIST); 585feaa74e4SMark Maybee if (err != ENOENT) 586feaa74e4SMark Maybee return (err); 587feaa74e4SMark Maybee 588ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 589ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 590ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 591ae46e4c7SMatthew Ahrens return (ENODEV); 59292241e0bSTom Erickson 59392241e0bSTom Erickson /* 59492241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 59592241e0bSTom Erickson * changes since the fromguid one 59692241e0bSTom Erickson */ 59792241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 59892241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 59992241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 60092241e0bSTom Erickson while (obj != 0) { 60192241e0bSTom Erickson dsl_dataset_t *snap; 60292241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 60392241e0bSTom Erickson obj, FTAG, &snap); 60492241e0bSTom Erickson if (err) 60592241e0bSTom Erickson return (ENODEV); 60692241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 60792241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 60892241e0bSTom Erickson return (ENODEV); 60992241e0bSTom Erickson } 61092241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 61192241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 61292241e0bSTom Erickson break; /* it's ok */ 61392241e0bSTom Erickson } 61492241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 61592241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 61692241e0bSTom Erickson } 61792241e0bSTom Erickson if (obj == 0) 61892241e0bSTom Erickson return (ENODEV); 61992241e0bSTom Erickson } 620ae46e4c7SMatthew Ahrens } else { 621ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 622ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 623ae46e4c7SMatthew Ahrens return (ENODEV); 624ae46e4c7SMatthew Ahrens } 6253cb34c60Sahrens 62647f263f4Sek /* temporary clone name must not exist */ 62747f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 62847f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 62947f263f4Sek rbsa->clonelastname, 8, 1, &val); 63047f263f4Sek if (err == 0) 63147f263f4Sek return (EEXIST); 63247f263f4Sek if (err != ENOENT) 63347f263f4Sek return (err); 63447f263f4Sek 6353cb34c60Sahrens return (0); 636f18faf3fSek } 637f18faf3fSek 638f18faf3fSek /* ARGSUSED */ 639f18faf3fSek static void 6403f9d6ad7SLin Ling recv_existing_sync(void *arg1, void *arg2, dmu_tx_t *tx) 641f18faf3fSek { 6423cb34c60Sahrens dsl_dataset_t *ohds = arg1; 6433cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 6443cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 645ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 646745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 647f18faf3fSek uint64_t dsobj; 648f18faf3fSek 649ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 650ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 6513f9d6ad7SLin Ling ohds->ds_prev, flags, rbsa->cr, tx); 652503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 6533cb34c60Sahrens 654ae46e4c7SMatthew Ahrens /* 655ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 656ae46e4c7SMatthew Ahrens * objset in our new dataset. 657ae46e4c7SMatthew Ahrens */ 658ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 659ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 660ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 661ae46e4c7SMatthew Ahrens } 662ae46e4c7SMatthew Ahrens 6633cb34c60Sahrens rbsa->ds = cds; 6643cb34c60Sahrens 6653f9d6ad7SLin Ling spa_history_log_internal(LOG_DS_REPLAY_INC_SYNC, 6663f9d6ad7SLin Ling dp->dp_spa, tx, "dataset = %lld", dsobj); 6673cb34c60Sahrens } 6683cb34c60Sahrens 669dc7cd546SMark Shellenbaum static boolean_t 670dc7cd546SMark Shellenbaum dmu_recv_verify_features(dsl_dataset_t *ds, struct drr_begin *drrb) 671dc7cd546SMark Shellenbaum { 672dc7cd546SMark Shellenbaum int featureflags; 673dc7cd546SMark Shellenbaum 674dc7cd546SMark Shellenbaum featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 675dc7cd546SMark Shellenbaum 676dc7cd546SMark Shellenbaum /* Verify pool version supports SA if SA_SPILL feature set */ 677dc7cd546SMark Shellenbaum return ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) && 678dc7cd546SMark Shellenbaum (spa_version(dsl_dataset_get_spa(ds)) < SPA_VERSION_SA)); 679dc7cd546SMark Shellenbaum } 680dc7cd546SMark Shellenbaum 6813cb34c60Sahrens /* 6823cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 6833cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 6843cb34c60Sahrens */ 6853cb34c60Sahrens int 6869e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 687f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 688efb80947Sahrens { 6893cb34c60Sahrens int err = 0; 6903cb34c60Sahrens boolean_t byteswap; 691ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 6929e69d7d0SLori Alt uint64_t versioninfo; 6933cb34c60Sahrens int flags; 6943cb34c60Sahrens dsl_dataset_t *ds; 695efb80947Sahrens 6963cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 6973cb34c60Sahrens byteswap = FALSE; 6983cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 6993cb34c60Sahrens byteswap = TRUE; 7003cb34c60Sahrens else 7013cb34c60Sahrens return (EINVAL); 7023cb34c60Sahrens 7033cb34c60Sahrens rbsa.tofs = tofs; 7043cb34c60Sahrens rbsa.tosnap = tosnap; 705503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 7063cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 7073cb34c60Sahrens rbsa.type = drrb->drr_type; 7083cb34c60Sahrens rbsa.tag = FTAG; 709ab04eb8eStimh rbsa.dsflags = 0; 7103f9d6ad7SLin Ling rbsa.cr = CRED(); 7119e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 7123cb34c60Sahrens flags = drrb->drr_flags; 7133cb34c60Sahrens 7143cb34c60Sahrens if (byteswap) { 7153cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 7163cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 7179e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 7183cb34c60Sahrens flags = BSWAP_32(flags); 7193cb34c60Sahrens } 720efb80947Sahrens 7219e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 7223cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 7233cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 724efb80947Sahrens return (EINVAL); 725efb80947Sahrens 726ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 727ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 728ab04eb8eStimh 7293cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 7303cb34c60Sahrens drc->drc_drrb = drrb; 7313cb34c60Sahrens drc->drc_tosnap = tosnap; 7329e69d7d0SLori Alt drc->drc_top_ds = top_ds; 7333cb34c60Sahrens drc->drc_force = force; 734efb80947Sahrens 7353cb34c60Sahrens /* 7363cb34c60Sahrens * Process the begin in syncing context. 7373cb34c60Sahrens */ 738efb80947Sahrens 739ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 740ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 741ae46e4c7SMatthew Ahrens if (err == 0) { 742dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 743dc7cd546SMark Shellenbaum dsl_dataset_rele(ds, dmu_recv_tag); 744dc7cd546SMark Shellenbaum return (ENOTSUP); 745dc7cd546SMark Shellenbaum } 746ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 747efb80947Sahrens 748ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 749ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 750ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 751ae46e4c7SMatthew Ahrens return (EINVAL); 752ae46e4c7SMatthew Ahrens } 753efb80947Sahrens 754f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 755f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 756f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 757f4b94bdeSMatthew Ahrens return (EBUSY); 758f4b94bdeSMatthew Ahrens } 759f4b94bdeSMatthew Ahrens 760ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 761ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 762ae46e4c7SMatthew Ahrens "%%%s", tosnap); 7633cb34c60Sahrens rbsa.force = force; 7643cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 765ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 7663cb34c60Sahrens if (err) { 767f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 768745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 7693cb34c60Sahrens return (err); 7703cb34c60Sahrens } 7713cb34c60Sahrens drc->drc_logical_ds = ds; 7723cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 773ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 774ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 775ae46e4c7SMatthew Ahrens char *cp; 776efb80947Sahrens 777ae46e4c7SMatthew Ahrens /* 778ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 779ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 780ae46e4c7SMatthew Ahrens */ 781ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 782ae46e4c7SMatthew Ahrens return (ENOENT); 783ae46e4c7SMatthew Ahrens 784ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 785ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 786ae46e4c7SMatthew Ahrens *cp = '\0'; 787bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 788ae46e4c7SMatthew Ahrens *cp = '/'; 7893cb34c60Sahrens if (err) 7903cb34c60Sahrens return (err); 791efb80947Sahrens 792dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 7938fe33373SMatthew Ahrens dsl_dataset_rele(ds, FTAG); 794dc7cd546SMark Shellenbaum return (ENOTSUP); 795dc7cd546SMark Shellenbaum } 796dc7cd546SMark Shellenbaum 797ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 798ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 799bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 8003cb34c60Sahrens if (err) 8013cb34c60Sahrens return (err); 8023cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 8033cb34c60Sahrens drc->drc_newfs = B_TRUE; 8043cb34c60Sahrens } 8053cb34c60Sahrens 806ae46e4c7SMatthew Ahrens return (err); 807efb80947Sahrens } 808efb80947Sahrens 8093cb34c60Sahrens struct restorearg { 8103cb34c60Sahrens int err; 8113cb34c60Sahrens int byteswap; 8123cb34c60Sahrens vnode_t *vp; 8133cb34c60Sahrens char *buf; 8143cb34c60Sahrens uint64_t voff; 8153cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 8163cb34c60Sahrens zio_cksum_t cksum; 817c99e4bdcSChris Kirby avl_tree_t *guid_to_ds_map; 8183cb34c60Sahrens }; 8193cb34c60Sahrens 8209e69d7d0SLori Alt typedef struct guid_map_entry { 8219e69d7d0SLori Alt uint64_t guid; 8229e69d7d0SLori Alt dsl_dataset_t *gme_ds; 8239e69d7d0SLori Alt avl_node_t avlnode; 8249e69d7d0SLori Alt } guid_map_entry_t; 8259e69d7d0SLori Alt 8269e69d7d0SLori Alt static int 8279e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 8289e69d7d0SLori Alt { 8299e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 8309e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 8319e69d7d0SLori Alt 8329e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 8339e69d7d0SLori Alt return (-1); 8349e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 8359e69d7d0SLori Alt return (1); 8369e69d7d0SLori Alt return (0); 8379e69d7d0SLori Alt } 8389e69d7d0SLori Alt 839c99e4bdcSChris Kirby static void 840c99e4bdcSChris Kirby free_guid_map_onexit(void *arg) 841c99e4bdcSChris Kirby { 842c99e4bdcSChris Kirby avl_tree_t *ca = arg; 843c99e4bdcSChris Kirby void *cookie = NULL; 844c99e4bdcSChris Kirby guid_map_entry_t *gmep; 845c99e4bdcSChris Kirby 846c99e4bdcSChris Kirby while ((gmep = avl_destroy_nodes(ca, &cookie)) != NULL) { 847c99e4bdcSChris Kirby dsl_dataset_rele(gmep->gme_ds, ca); 848c99e4bdcSChris Kirby kmem_free(gmep, sizeof (guid_map_entry_t)); 849c99e4bdcSChris Kirby } 850c99e4bdcSChris Kirby avl_destroy(ca); 851c99e4bdcSChris Kirby kmem_free(ca, sizeof (avl_tree_t)); 852c99e4bdcSChris Kirby } 853c99e4bdcSChris Kirby 854efb80947Sahrens static void * 855efb80947Sahrens restore_read(struct restorearg *ra, int len) 856efb80947Sahrens { 857efb80947Sahrens void *rv; 8583cb34c60Sahrens int done = 0; 859efb80947Sahrens 860efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 861efb80947Sahrens ASSERT3U(len % 8, ==, 0); 862efb80947Sahrens 8633cb34c60Sahrens while (done < len) { 864efb80947Sahrens ssize_t resid; 865efb80947Sahrens 866efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 8673cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 868efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 869efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 870efb80947Sahrens 8713cb34c60Sahrens if (resid == len - done) 872efb80947Sahrens ra->err = EINVAL; 8733cb34c60Sahrens ra->voff += len - done - resid; 8743cb34c60Sahrens done = len - resid; 875efb80947Sahrens if (ra->err) 876efb80947Sahrens return (NULL); 877efb80947Sahrens } 878efb80947Sahrens 8793cb34c60Sahrens ASSERT3U(done, ==, len); 8803cb34c60Sahrens rv = ra->buf; 881efb80947Sahrens if (ra->byteswap) 8823cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 883efb80947Sahrens else 8843cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 885efb80947Sahrens return (rv); 886efb80947Sahrens } 887efb80947Sahrens 888efb80947Sahrens static void 889efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 890efb80947Sahrens { 891efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 892efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 893efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 8943cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 895efb80947Sahrens switch (drr->drr_type) { 896efb80947Sahrens case DRR_BEGIN: 897efb80947Sahrens DO64(drr_begin.drr_magic); 8989e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 899efb80947Sahrens DO64(drr_begin.drr_creation_time); 900efb80947Sahrens DO32(drr_begin.drr_type); 9013cb34c60Sahrens DO32(drr_begin.drr_flags); 902efb80947Sahrens DO64(drr_begin.drr_toguid); 903efb80947Sahrens DO64(drr_begin.drr_fromguid); 904efb80947Sahrens break; 905efb80947Sahrens case DRR_OBJECT: 906efb80947Sahrens DO64(drr_object.drr_object); 907efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 908efb80947Sahrens DO32(drr_object.drr_type); 909efb80947Sahrens DO32(drr_object.drr_bonustype); 910efb80947Sahrens DO32(drr_object.drr_blksz); 911efb80947Sahrens DO32(drr_object.drr_bonuslen); 9129e69d7d0SLori Alt DO64(drr_object.drr_toguid); 913efb80947Sahrens break; 914efb80947Sahrens case DRR_FREEOBJECTS: 915efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 916efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 9179e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 918efb80947Sahrens break; 919efb80947Sahrens case DRR_WRITE: 920efb80947Sahrens DO64(drr_write.drr_object); 921efb80947Sahrens DO32(drr_write.drr_type); 922efb80947Sahrens DO64(drr_write.drr_offset); 923efb80947Sahrens DO64(drr_write.drr_length); 9249e69d7d0SLori Alt DO64(drr_write.drr_toguid); 9258e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[0]); 9268e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[1]); 9278e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[2]); 9288e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[3]); 9298e714474SLori Alt DO64(drr_write.drr_key.ddk_prop); 9309e69d7d0SLori Alt break; 9319e69d7d0SLori Alt case DRR_WRITE_BYREF: 9329e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 9339e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 9349e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 9359e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 9369e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 9379e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 9389e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 9398e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]); 9408e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]); 9418e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]); 9428e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]); 9438e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_prop); 944efb80947Sahrens break; 945efb80947Sahrens case DRR_FREE: 946efb80947Sahrens DO64(drr_free.drr_object); 947efb80947Sahrens DO64(drr_free.drr_offset); 948efb80947Sahrens DO64(drr_free.drr_length); 9499e69d7d0SLori Alt DO64(drr_free.drr_toguid); 950efb80947Sahrens break; 9510a586ceaSMark Shellenbaum case DRR_SPILL: 9520a586ceaSMark Shellenbaum DO64(drr_spill.drr_object); 9530a586ceaSMark Shellenbaum DO64(drr_spill.drr_length); 9540a586ceaSMark Shellenbaum DO64(drr_spill.drr_toguid); 9550a586ceaSMark Shellenbaum break; 956efb80947Sahrens case DRR_END: 957efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 958efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 959efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 960efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 9619e69d7d0SLori Alt DO64(drr_end.drr_toguid); 962efb80947Sahrens break; 963efb80947Sahrens } 964efb80947Sahrens #undef DO64 965efb80947Sahrens #undef DO32 966efb80947Sahrens } 967efb80947Sahrens 968efb80947Sahrens static int 969efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 970efb80947Sahrens { 971efb80947Sahrens int err; 972efb80947Sahrens dmu_tx_t *tx; 973adee0b6fSTim Haley void *data = NULL; 974efb80947Sahrens 975efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 976efb80947Sahrens drro->drr_type >= DMU_OT_NUMTYPES || 977efb80947Sahrens drro->drr_bonustype >= DMU_OT_NUMTYPES || 9789e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 979efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 980efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 981efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 982efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 983efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 984efb80947Sahrens return (EINVAL); 985efb80947Sahrens } 986efb80947Sahrens 9872bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 9882bf405a2SMark Maybee 9892bf405a2SMark Maybee if (err != 0 && err != ENOENT) 9902bf405a2SMark Maybee return (EINVAL); 9912bf405a2SMark Maybee 992adee0b6fSTim Haley if (drro->drr_bonuslen) { 993adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 994adee0b6fSTim Haley if (ra->err) 995adee0b6fSTim Haley return (ra->err); 996adee0b6fSTim Haley } 997adee0b6fSTim Haley 998efb80947Sahrens if (err == ENOENT) { 999efb80947Sahrens /* currently free, want to be allocated */ 10002bf405a2SMark Maybee tx = dmu_tx_create(os); 1001efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 1002efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1003efb80947Sahrens if (err) { 1004efb80947Sahrens dmu_tx_abort(tx); 1005efb80947Sahrens return (err); 1006efb80947Sahrens } 1007efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 1008efb80947Sahrens drro->drr_type, drro->drr_blksz, 1009efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 10102bf405a2SMark Maybee dmu_tx_commit(tx); 1011efb80947Sahrens } else { 1012efb80947Sahrens /* currently allocated, want to be allocated */ 1013efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 1014efb80947Sahrens drro->drr_type, drro->drr_blksz, 10152bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 1016efb80947Sahrens } 10170a586ceaSMark Shellenbaum if (err) { 1018efb80947Sahrens return (EINVAL); 10190a586ceaSMark Shellenbaum } 10202bf405a2SMark Maybee 10212bf405a2SMark Maybee tx = dmu_tx_create(os); 10222bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 10232bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 10242bf405a2SMark Maybee if (err) { 10252bf405a2SMark Maybee dmu_tx_abort(tx); 10262bf405a2SMark Maybee return (err); 1027efb80947Sahrens } 1028efb80947Sahrens 10299e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 10309e69d7d0SLori Alt tx); 1031efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 1032efb80947Sahrens 1033adee0b6fSTim Haley if (data != NULL) { 1034efb80947Sahrens dmu_buf_t *db; 1035adee0b6fSTim Haley 1036efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 1037efb80947Sahrens dmu_buf_will_dirty(db, tx); 1038efb80947Sahrens 10391934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 10401934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 1041efb80947Sahrens if (ra->byteswap) { 1042efb80947Sahrens dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 1043efb80947Sahrens drro->drr_bonuslen); 1044efb80947Sahrens } 1045efb80947Sahrens dmu_buf_rele(db, FTAG); 1046efb80947Sahrens } 1047efb80947Sahrens dmu_tx_commit(tx); 1048efb80947Sahrens return (0); 1049efb80947Sahrens } 1050efb80947Sahrens 1051efb80947Sahrens /* ARGSUSED */ 1052efb80947Sahrens static int 1053efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1054efb80947Sahrens struct drr_freeobjects *drrfo) 1055efb80947Sahrens { 1056efb80947Sahrens uint64_t obj; 1057efb80947Sahrens 1058efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1059efb80947Sahrens return (EINVAL); 1060efb80947Sahrens 1061efb80947Sahrens for (obj = drrfo->drr_firstobj; 1062432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1063432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1064efb80947Sahrens int err; 1065efb80947Sahrens 1066efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1067efb80947Sahrens continue; 1068efb80947Sahrens 1069cdb0ab79Smaybee err = dmu_free_object(os, obj); 1070cdb0ab79Smaybee if (err) 1071efb80947Sahrens return (err); 1072efb80947Sahrens } 1073efb80947Sahrens return (0); 1074efb80947Sahrens } 1075efb80947Sahrens 1076efb80947Sahrens static int 1077efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1078efb80947Sahrens struct drr_write *drrw) 1079efb80947Sahrens { 1080efb80947Sahrens dmu_tx_t *tx; 1081efb80947Sahrens void *data; 1082efb80947Sahrens int err; 1083efb80947Sahrens 1084efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1085efb80947Sahrens drrw->drr_type >= DMU_OT_NUMTYPES) 1086efb80947Sahrens return (EINVAL); 1087efb80947Sahrens 1088efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1089efb80947Sahrens if (data == NULL) 1090efb80947Sahrens return (ra->err); 1091efb80947Sahrens 1092efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1093efb80947Sahrens return (EINVAL); 1094efb80947Sahrens 1095efb80947Sahrens tx = dmu_tx_create(os); 1096efb80947Sahrens 1097efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1098efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1099efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1100efb80947Sahrens if (err) { 1101efb80947Sahrens dmu_tx_abort(tx); 1102efb80947Sahrens return (err); 1103efb80947Sahrens } 1104efb80947Sahrens if (ra->byteswap) 1105efb80947Sahrens dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 1106efb80947Sahrens dmu_write(os, drrw->drr_object, 1107efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1108efb80947Sahrens dmu_tx_commit(tx); 1109efb80947Sahrens return (0); 1110efb80947Sahrens } 1111efb80947Sahrens 11129e69d7d0SLori Alt /* 11139e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 11149e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 11159e69d7d0SLori Alt * system because it came in earlier in the stream. This function 11169e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 11179e69d7d0SLori Alt * data from the stream to fulfill this write. 11189e69d7d0SLori Alt */ 11199e69d7d0SLori Alt static int 11209e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 11219e69d7d0SLori Alt struct drr_write_byref *drrwbr) 11229e69d7d0SLori Alt { 11239e69d7d0SLori Alt dmu_tx_t *tx; 11249e69d7d0SLori Alt int err; 11259e69d7d0SLori Alt guid_map_entry_t gmesrch; 11269e69d7d0SLori Alt guid_map_entry_t *gmep; 11279e69d7d0SLori Alt avl_index_t where; 11289e69d7d0SLori Alt objset_t *ref_os = NULL; 11299e69d7d0SLori Alt dmu_buf_t *dbp; 11309e69d7d0SLori Alt 11319e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 11329e69d7d0SLori Alt return (EINVAL); 11339e69d7d0SLori Alt 11349e69d7d0SLori Alt /* 11359e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 11369e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 11379e69d7d0SLori Alt */ 11389e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 11399e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 1140c99e4bdcSChris Kirby if ((gmep = avl_find(ra->guid_to_ds_map, &gmesrch, 11419e69d7d0SLori Alt &where)) == NULL) { 11429e69d7d0SLori Alt return (EINVAL); 11439e69d7d0SLori Alt } 11449e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 11459e69d7d0SLori Alt return (EINVAL); 11469e69d7d0SLori Alt } else { 11479e69d7d0SLori Alt ref_os = os; 11489e69d7d0SLori Alt } 11499e69d7d0SLori Alt 11509e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 115147cb52daSJeff Bonwick drrwbr->drr_refoffset, FTAG, &dbp, DMU_READ_PREFETCH)) 11529e69d7d0SLori Alt return (err); 11539e69d7d0SLori Alt 11549e69d7d0SLori Alt tx = dmu_tx_create(os); 11559e69d7d0SLori Alt 11569e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 11579e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 11589e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 11599e69d7d0SLori Alt if (err) { 11609e69d7d0SLori Alt dmu_tx_abort(tx); 11619e69d7d0SLori Alt return (err); 11629e69d7d0SLori Alt } 11639e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 11649e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 11659e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 11669e69d7d0SLori Alt dmu_tx_commit(tx); 11679e69d7d0SLori Alt return (0); 11689e69d7d0SLori Alt } 11699e69d7d0SLori Alt 11700a586ceaSMark Shellenbaum static int 11710a586ceaSMark Shellenbaum restore_spill(struct restorearg *ra, objset_t *os, struct drr_spill *drrs) 11720a586ceaSMark Shellenbaum { 11730a586ceaSMark Shellenbaum dmu_tx_t *tx; 11740a586ceaSMark Shellenbaum void *data; 11750a586ceaSMark Shellenbaum dmu_buf_t *db, *db_spill; 11760a586ceaSMark Shellenbaum int err; 11770a586ceaSMark Shellenbaum 11780a586ceaSMark Shellenbaum if (drrs->drr_length < SPA_MINBLOCKSIZE || 11790a586ceaSMark Shellenbaum drrs->drr_length > SPA_MAXBLOCKSIZE) 11800a586ceaSMark Shellenbaum return (EINVAL); 11810a586ceaSMark Shellenbaum 11820a586ceaSMark Shellenbaum data = restore_read(ra, drrs->drr_length); 11830a586ceaSMark Shellenbaum if (data == NULL) 11840a586ceaSMark Shellenbaum return (ra->err); 11850a586ceaSMark Shellenbaum 11860a586ceaSMark Shellenbaum if (dmu_object_info(os, drrs->drr_object, NULL) != 0) 11870a586ceaSMark Shellenbaum return (EINVAL); 11880a586ceaSMark Shellenbaum 11890a586ceaSMark Shellenbaum VERIFY(0 == dmu_bonus_hold(os, drrs->drr_object, FTAG, &db)); 11900a586ceaSMark Shellenbaum if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) { 11910a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 11920a586ceaSMark Shellenbaum return (err); 11930a586ceaSMark Shellenbaum } 11940a586ceaSMark Shellenbaum 11950a586ceaSMark Shellenbaum tx = dmu_tx_create(os); 11960a586ceaSMark Shellenbaum 11970a586ceaSMark Shellenbaum dmu_tx_hold_spill(tx, db->db_object); 11980a586ceaSMark Shellenbaum 11990a586ceaSMark Shellenbaum err = dmu_tx_assign(tx, TXG_WAIT); 12000a586ceaSMark Shellenbaum if (err) { 12010a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 12020a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 12030a586ceaSMark Shellenbaum dmu_tx_abort(tx); 12040a586ceaSMark Shellenbaum return (err); 12050a586ceaSMark Shellenbaum } 12060a586ceaSMark Shellenbaum dmu_buf_will_dirty(db_spill, tx); 12070a586ceaSMark Shellenbaum 12080a586ceaSMark Shellenbaum if (db_spill->db_size < drrs->drr_length) 12090a586ceaSMark Shellenbaum VERIFY(0 == dbuf_spill_set_blksz(db_spill, 12100a586ceaSMark Shellenbaum drrs->drr_length, tx)); 12110a586ceaSMark Shellenbaum bcopy(data, db_spill->db_data, drrs->drr_length); 12120a586ceaSMark Shellenbaum 12130a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 12140a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 12150a586ceaSMark Shellenbaum 12160a586ceaSMark Shellenbaum dmu_tx_commit(tx); 12170a586ceaSMark Shellenbaum return (0); 12180a586ceaSMark Shellenbaum } 12190a586ceaSMark Shellenbaum 1220efb80947Sahrens /* ARGSUSED */ 1221efb80947Sahrens static int 1222efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1223efb80947Sahrens struct drr_free *drrf) 1224efb80947Sahrens { 1225efb80947Sahrens int err; 1226efb80947Sahrens 1227efb80947Sahrens if (drrf->drr_length != -1ULL && 1228efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1229efb80947Sahrens return (EINVAL); 1230efb80947Sahrens 1231efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1232efb80947Sahrens return (EINVAL); 1233efb80947Sahrens 1234cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1235efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1236efb80947Sahrens return (err); 1237efb80947Sahrens } 1238efb80947Sahrens 12393cb34c60Sahrens /* 12403cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 12413cb34c60Sahrens */ 1242efb80947Sahrens int 1243c99e4bdcSChris Kirby dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp, 1244c99e4bdcSChris Kirby int cleanup_fd, uint64_t *action_handlep) 1245efb80947Sahrens { 12463cb34c60Sahrens struct restorearg ra = { 0 }; 1247efb80947Sahrens dmu_replay_record_t *drr; 12483cb34c60Sahrens objset_t *os; 12493cb34c60Sahrens zio_cksum_t pcksum; 12509e69d7d0SLori Alt int featureflags; 1251efb80947Sahrens 12523cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1253efb80947Sahrens ra.byteswap = TRUE; 1254efb80947Sahrens 12553cb34c60Sahrens { 12563cb34c60Sahrens /* compute checksum of drr_begin record */ 12573cb34c60Sahrens dmu_replay_record_t *drr; 12583cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 12593cb34c60Sahrens 12603cb34c60Sahrens drr->drr_type = DRR_BEGIN; 12613cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 12623cb34c60Sahrens if (ra.byteswap) { 12633cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 12643cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 12653cb34c60Sahrens } else { 12663cb34c60Sahrens fletcher_4_incremental_native(drr, 12673cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 12683cb34c60Sahrens } 12693cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1270efb80947Sahrens } 1271efb80947Sahrens 1272efb80947Sahrens if (ra.byteswap) { 12733cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1274efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 12759e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1276efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1277efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1278efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1279efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1280efb80947Sahrens } 1281efb80947Sahrens 12823cb34c60Sahrens ra.vp = vp; 12833cb34c60Sahrens ra.voff = *voffp; 12843cb34c60Sahrens ra.bufsize = 1<<20; 12853cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1286efb80947Sahrens 12873cb34c60Sahrens /* these were verified in dmu_recv_begin */ 12889e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 12899e69d7d0SLori Alt DMU_SUBSTREAM); 12903cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1291efb80947Sahrens 1292efb80947Sahrens /* 1293efb80947Sahrens * Open the objset we are modifying. 1294efb80947Sahrens */ 1295503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1296efb80947Sahrens 12973cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1298efb80947Sahrens 12999e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 13009e69d7d0SLori Alt 13019e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 13029e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 1303a7f53a56SChris Kirby minor_t minor; 1304a7f53a56SChris Kirby 1305c99e4bdcSChris Kirby if (cleanup_fd == -1) { 1306c99e4bdcSChris Kirby ra.err = EBADF; 1307c99e4bdcSChris Kirby goto out; 1308c99e4bdcSChris Kirby } 1309a7f53a56SChris Kirby ra.err = zfs_onexit_fd_hold(cleanup_fd, &minor); 1310a7f53a56SChris Kirby if (ra.err) { 1311a7f53a56SChris Kirby cleanup_fd = -1; 1312a7f53a56SChris Kirby goto out; 1313a7f53a56SChris Kirby } 1314a7f53a56SChris Kirby 1315c99e4bdcSChris Kirby if (*action_handlep == 0) { 1316c99e4bdcSChris Kirby ra.guid_to_ds_map = 1317c99e4bdcSChris Kirby kmem_alloc(sizeof (avl_tree_t), KM_SLEEP); 1318c99e4bdcSChris Kirby avl_create(ra.guid_to_ds_map, guid_compare, 1319c99e4bdcSChris Kirby sizeof (guid_map_entry_t), 1320c99e4bdcSChris Kirby offsetof(guid_map_entry_t, avlnode)); 1321a7f53a56SChris Kirby ra.err = zfs_onexit_add_cb(minor, 1322c99e4bdcSChris Kirby free_guid_map_onexit, ra.guid_to_ds_map, 1323c99e4bdcSChris Kirby action_handlep); 1324c99e4bdcSChris Kirby if (ra.err) 1325c99e4bdcSChris Kirby goto out; 1326c99e4bdcSChris Kirby } else { 1327a7f53a56SChris Kirby ra.err = zfs_onexit_cb_data(minor, *action_handlep, 1328c99e4bdcSChris Kirby (void **)&ra.guid_to_ds_map); 1329c99e4bdcSChris Kirby if (ra.err) 1330c99e4bdcSChris Kirby goto out; 1331c99e4bdcSChris Kirby } 1332*ec5cf9d5SAlexander Stetsenko 1333*ec5cf9d5SAlexander Stetsenko drc->drc_guid_to_ds_map = ra.guid_to_ds_map; 13349e69d7d0SLori Alt } 13359e69d7d0SLori Alt 1336efb80947Sahrens /* 1337efb80947Sahrens * Read records and process them. 1338efb80947Sahrens */ 13393cb34c60Sahrens pcksum = ra.cksum; 1340efb80947Sahrens while (ra.err == 0 && 1341efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1342efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1343efb80947Sahrens ra.err = EINTR; 1344efb80947Sahrens goto out; 1345efb80947Sahrens } 1346efb80947Sahrens 1347efb80947Sahrens if (ra.byteswap) 1348efb80947Sahrens backup_byteswap(drr); 1349efb80947Sahrens 1350efb80947Sahrens switch (drr->drr_type) { 1351efb80947Sahrens case DRR_OBJECT: 1352efb80947Sahrens { 1353efb80947Sahrens /* 1354efb80947Sahrens * We need to make a copy of the record header, 1355efb80947Sahrens * because restore_{object,write} may need to 1356efb80947Sahrens * restore_read(), which will invalidate drr. 1357efb80947Sahrens */ 1358efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1359efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1360efb80947Sahrens break; 1361efb80947Sahrens } 1362efb80947Sahrens case DRR_FREEOBJECTS: 1363efb80947Sahrens { 1364efb80947Sahrens struct drr_freeobjects drrfo = 1365efb80947Sahrens drr->drr_u.drr_freeobjects; 1366efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1367efb80947Sahrens break; 1368efb80947Sahrens } 1369efb80947Sahrens case DRR_WRITE: 1370efb80947Sahrens { 1371efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1372efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1373efb80947Sahrens break; 1374efb80947Sahrens } 13759e69d7d0SLori Alt case DRR_WRITE_BYREF: 13769e69d7d0SLori Alt { 13779e69d7d0SLori Alt struct drr_write_byref drrwbr = 13789e69d7d0SLori Alt drr->drr_u.drr_write_byref; 13799e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 13809e69d7d0SLori Alt break; 13819e69d7d0SLori Alt } 1382efb80947Sahrens case DRR_FREE: 1383efb80947Sahrens { 1384efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1385efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1386efb80947Sahrens break; 1387efb80947Sahrens } 1388efb80947Sahrens case DRR_END: 1389efb80947Sahrens { 1390efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1391efb80947Sahrens /* 1392efb80947Sahrens * We compare against the *previous* checksum 1393efb80947Sahrens * value, because the stored checksum is of 1394efb80947Sahrens * everything before the DRR_END record. 1395efb80947Sahrens */ 1396137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1397efb80947Sahrens ra.err = ECKSUM; 1398efb80947Sahrens goto out; 1399efb80947Sahrens } 14000a586ceaSMark Shellenbaum case DRR_SPILL: 14010a586ceaSMark Shellenbaum { 14020a586ceaSMark Shellenbaum struct drr_spill drrs = drr->drr_u.drr_spill; 14030a586ceaSMark Shellenbaum ra.err = restore_spill(&ra, os, &drrs); 14040a586ceaSMark Shellenbaum break; 14050a586ceaSMark Shellenbaum } 1406efb80947Sahrens default: 1407efb80947Sahrens ra.err = EINVAL; 1408efb80947Sahrens goto out; 1409efb80947Sahrens } 14103cb34c60Sahrens pcksum = ra.cksum; 1411efb80947Sahrens } 1412137fa067Sahrens ASSERT(ra.err != 0); 1413efb80947Sahrens 1414efb80947Sahrens out: 1415a7f53a56SChris Kirby if ((featureflags & DMU_BACKUP_FEATURE_DEDUP) && (cleanup_fd != -1)) 1416a7f53a56SChris Kirby zfs_onexit_fd_rele(cleanup_fd); 1417a7f53a56SChris Kirby 14183cb34c60Sahrens if (ra.err != 0) { 1419efb80947Sahrens /* 1420f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1421f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1422efb80947Sahrens */ 14233cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1424f4b94bdeSMatthew Ahrens 1425842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1426842727c2SChris Kirby B_FALSE); 1427f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1428f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1429f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1430f4b94bdeSMatthew Ahrens } 1431efb80947Sahrens } 1432efb80947Sahrens 1433efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 14343cb34c60Sahrens *voffp = ra.voff; 1435efb80947Sahrens return (ra.err); 1436efb80947Sahrens } 1437f18faf3fSek 14383cb34c60Sahrens struct recvendsyncarg { 14393cb34c60Sahrens char *tosnap; 14403cb34c60Sahrens uint64_t creation_time; 14413cb34c60Sahrens uint64_t toguid; 14423cb34c60Sahrens }; 14433cb34c60Sahrens 14443cb34c60Sahrens static int 14453cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 14463cb34c60Sahrens { 14473cb34c60Sahrens dsl_dataset_t *ds = arg1; 14483cb34c60Sahrens struct recvendsyncarg *resa = arg2; 14493cb34c60Sahrens 14503cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 14513cb34c60Sahrens } 14523cb34c60Sahrens 14533cb34c60Sahrens static void 14543f9d6ad7SLin Ling recv_end_sync(void *arg1, void *arg2, dmu_tx_t *tx) 14553cb34c60Sahrens { 14563cb34c60Sahrens dsl_dataset_t *ds = arg1; 14573cb34c60Sahrens struct recvendsyncarg *resa = arg2; 14583cb34c60Sahrens 14593f9d6ad7SLin Ling dsl_dataset_snapshot_sync(ds, resa->tosnap, tx); 14603cb34c60Sahrens 14613cb34c60Sahrens /* set snapshot's creation time and guid */ 14623cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 14633cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 14643cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 14653cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 14663cb34c60Sahrens 14673cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 14683cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 14693cb34c60Sahrens } 14703cb34c60Sahrens 1471*ec5cf9d5SAlexander Stetsenko static int 1472*ec5cf9d5SAlexander Stetsenko add_ds_to_guidmap(avl_tree_t *guid_map, dsl_dataset_t *ds) 1473*ec5cf9d5SAlexander Stetsenko { 1474*ec5cf9d5SAlexander Stetsenko dsl_pool_t *dp = ds->ds_dir->dd_pool; 1475*ec5cf9d5SAlexander Stetsenko uint64_t snapobj = ds->ds_phys->ds_prev_snap_obj; 1476*ec5cf9d5SAlexander Stetsenko dsl_dataset_t *snapds; 1477*ec5cf9d5SAlexander Stetsenko guid_map_entry_t *gmep; 1478*ec5cf9d5SAlexander Stetsenko int err; 1479*ec5cf9d5SAlexander Stetsenko 1480*ec5cf9d5SAlexander Stetsenko ASSERT(guid_map != NULL); 1481*ec5cf9d5SAlexander Stetsenko 1482*ec5cf9d5SAlexander Stetsenko rw_enter(&dp->dp_config_rwlock, RW_READER); 1483*ec5cf9d5SAlexander Stetsenko err = dsl_dataset_hold_obj(dp, snapobj, guid_map, &snapds); 1484*ec5cf9d5SAlexander Stetsenko if (err == 0) { 1485*ec5cf9d5SAlexander Stetsenko gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 1486*ec5cf9d5SAlexander Stetsenko gmep->guid = snapds->ds_phys->ds_guid; 1487*ec5cf9d5SAlexander Stetsenko gmep->gme_ds = snapds; 1488*ec5cf9d5SAlexander Stetsenko avl_add(guid_map, gmep); 1489*ec5cf9d5SAlexander Stetsenko } 1490*ec5cf9d5SAlexander Stetsenko 1491*ec5cf9d5SAlexander Stetsenko rw_exit(&dp->dp_config_rwlock); 1492*ec5cf9d5SAlexander Stetsenko return (err); 1493*ec5cf9d5SAlexander Stetsenko } 1494*ec5cf9d5SAlexander Stetsenko 1495ae46e4c7SMatthew Ahrens static int 1496ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1497f18faf3fSek { 1498745cd3c5Smaybee struct recvendsyncarg resa; 1499745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 1500745cd3c5Smaybee int err; 1501f18faf3fSek 15023cb34c60Sahrens /* 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. 15063cb34c60Sahrens */ 1507745cd3c5Smaybee txg_wait_synced(ds->ds_dir->dd_pool, 0); 15083cb34c60Sahrens 1509ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1510ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1511ae46e4c7SMatthew Ahrens drc->drc_force); 1512ae46e4c7SMatthew Ahrens if (err) 1513ae46e4c7SMatthew Ahrens goto out; 1514ae46e4c7SMatthew Ahrens } else { 1515ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1516ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1517842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1518842727c2SChris Kirby B_FALSE); 1519ae46e4c7SMatthew Ahrens return (EBUSY); 15203cb34c60Sahrens } 15213cb34c60Sahrens 1522745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1523745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1524745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 15253cb34c60Sahrens 1526745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1527745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1528745cd3c5Smaybee if (err) { 1529ae46e4c7SMatthew Ahrens /* swap back */ 1530ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 15313cb34c60Sahrens } 15323cb34c60Sahrens 1533ae46e4c7SMatthew Ahrens out: 1534ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1535*ec5cf9d5SAlexander Stetsenko if (err == 0 && drc->drc_guid_to_ds_map != NULL) 1536*ec5cf9d5SAlexander Stetsenko (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds); 1537745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 1538ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 1539f18faf3fSek return (err); 1540f18faf3fSek } 1541ae46e4c7SMatthew Ahrens 1542ae46e4c7SMatthew Ahrens static int 1543ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1544ae46e4c7SMatthew Ahrens { 1545ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1546ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1547ae46e4c7SMatthew Ahrens int err; 1548ae46e4c7SMatthew Ahrens 1549ae46e4c7SMatthew Ahrens /* 1550ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1551ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1552ae46e4c7SMatthew Ahrens * can close it. 1553ae46e4c7SMatthew Ahrens */ 1554ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1555ae46e4c7SMatthew Ahrens 1556ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1557ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1558ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1559ae46e4c7SMatthew Ahrens 1560ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1561ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1562ae46e4c7SMatthew Ahrens if (err) { 1563ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1564ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1565ae46e4c7SMatthew Ahrens } else { 1566*ec5cf9d5SAlexander Stetsenko if (drc->drc_guid_to_ds_map != NULL) 1567*ec5cf9d5SAlexander Stetsenko (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds); 1568ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1569ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1570ae46e4c7SMatthew Ahrens } 1571ae46e4c7SMatthew Ahrens return (err); 1572ae46e4c7SMatthew Ahrens } 1573ae46e4c7SMatthew Ahrens 1574ae46e4c7SMatthew Ahrens int 1575ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1576ae46e4c7SMatthew Ahrens { 1577ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1578ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1579ae46e4c7SMatthew Ahrens else 1580ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1581ae46e4c7SMatthew Ahrens } 1582