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 */ 24efb80947Sahrens 25efb80947Sahrens #include <sys/dmu.h> 26efb80947Sahrens #include <sys/dmu_impl.h> 27efb80947Sahrens #include <sys/dmu_tx.h> 28efb80947Sahrens #include <sys/dbuf.h> 29efb80947Sahrens #include <sys/dnode.h> 30efb80947Sahrens #include <sys/zfs_context.h> 31efb80947Sahrens #include <sys/dmu_objset.h> 32efb80947Sahrens #include <sys/dmu_traverse.h> 33efb80947Sahrens #include <sys/dsl_dataset.h> 34efb80947Sahrens #include <sys/dsl_dir.h> 3592241e0bSTom Erickson #include <sys/dsl_prop.h> 36efb80947Sahrens #include <sys/dsl_pool.h> 37efb80947Sahrens #include <sys/dsl_synctask.h> 38efb80947Sahrens #include <sys/zfs_ioctl.h> 39efb80947Sahrens #include <sys/zap.h> 40efb80947Sahrens #include <sys/zio_checksum.h> 41dc7cd546SMark Shellenbaum #include <sys/zfs_znode.h> 42cde58dbcSMatthew Ahrens #include <zfs_fletcher.h> 439e69d7d0SLori Alt #include <sys/avl.h> 448e714474SLori Alt #include <sys/ddt.h> 45*c99e4bdcSChris Kirby #include <sys/zfs_onexit.h> 46efb80947Sahrens 473cb34c60Sahrens static char *dmu_recv_tag = "dmu_recv_tag"; 483cb34c60Sahrens 499e69d7d0SLori Alt /* 509e69d7d0SLori Alt * The list of data whose inclusion in a send stream can be pending from 519e69d7d0SLori Alt * one call to backup_cb to another. Multiple calls to dump_free() and 529e69d7d0SLori Alt * dump_freeobjects() can be aggregated into a single DRR_FREE or 539e69d7d0SLori Alt * DRR_FREEOBJECTS replay record. 549e69d7d0SLori Alt */ 559e69d7d0SLori Alt typedef enum { 569e69d7d0SLori Alt PENDING_NONE, 579e69d7d0SLori Alt PENDING_FREE, 589e69d7d0SLori Alt PENDING_FREEOBJECTS 599e69d7d0SLori Alt } pendop_t; 609e69d7d0SLori Alt 61efb80947Sahrens struct backuparg { 62efb80947Sahrens dmu_replay_record_t *drr; 63efb80947Sahrens vnode_t *vp; 643cb34c60Sahrens offset_t *off; 65efb80947Sahrens objset_t *os; 66efb80947Sahrens zio_cksum_t zc; 679e69d7d0SLori Alt uint64_t toguid; 68efb80947Sahrens int err; 699e69d7d0SLori Alt pendop_t pending_op; 70efb80947Sahrens }; 71efb80947Sahrens 72efb80947Sahrens static int 73efb80947Sahrens dump_bytes(struct backuparg *ba, void *buf, int len) 74efb80947Sahrens { 75efb80947Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 76efb80947Sahrens ASSERT3U(len % 8, ==, 0); 77efb80947Sahrens 78efb80947Sahrens fletcher_4_incremental_native(buf, len, &ba->zc); 79efb80947Sahrens ba->err = vn_rdwr(UIO_WRITE, ba->vp, 80efb80947Sahrens (caddr_t)buf, len, 81efb80947Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 823cb34c60Sahrens *ba->off += len; 83efb80947Sahrens return (ba->err); 84efb80947Sahrens } 85efb80947Sahrens 86efb80947Sahrens static int 87efb80947Sahrens dump_free(struct backuparg *ba, uint64_t object, uint64_t offset, 88efb80947Sahrens uint64_t length) 89efb80947Sahrens { 909e69d7d0SLori Alt struct drr_free *drrf = &(ba->drr->drr_u.drr_free); 919e69d7d0SLori Alt 929e69d7d0SLori Alt /* 939e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 949e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 959e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 969e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 979e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 989e69d7d0SLori Alt */ 999e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && ba->pending_op != PENDING_FREE) { 1009e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1019e69d7d0SLori Alt return (EINTR); 1029e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1039e69d7d0SLori Alt } 1049e69d7d0SLori Alt 1059e69d7d0SLori Alt if (ba->pending_op == PENDING_FREE) { 1069e69d7d0SLori Alt /* 1079e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 1089e69d7d0SLori Alt * (because dump_dnode is the only place where this 1099e69d7d0SLori Alt * function is called with a -1, and only after flushing 1109e69d7d0SLori Alt * any pending record). 1119e69d7d0SLori Alt */ 1129e69d7d0SLori Alt ASSERT(length != -1ULL); 1139e69d7d0SLori Alt /* 1149e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1159e69d7d0SLori Alt * with pending one. 1169e69d7d0SLori Alt */ 1179e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1189e69d7d0SLori Alt drrf->drr_length == offset) { 1199e69d7d0SLori Alt drrf->drr_length += length; 1209e69d7d0SLori Alt return (0); 1219e69d7d0SLori Alt } else { 1229e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1239e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 1249e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1259e69d7d0SLori Alt return (EINTR); 1269e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1279e69d7d0SLori Alt } 1289e69d7d0SLori Alt } 1299e69d7d0SLori Alt /* create a FREE record and make it pending */ 130efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 131efb80947Sahrens ba->drr->drr_type = DRR_FREE; 1329e69d7d0SLori Alt drrf->drr_object = object; 1339e69d7d0SLori Alt drrf->drr_offset = offset; 1349e69d7d0SLori Alt drrf->drr_length = length; 1359e69d7d0SLori Alt drrf->drr_toguid = ba->toguid; 1369e69d7d0SLori Alt if (length == -1ULL) { 1379e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1389e69d7d0SLori Alt return (EINTR); 1399e69d7d0SLori Alt } else { 1409e69d7d0SLori Alt ba->pending_op = PENDING_FREE; 1419e69d7d0SLori Alt } 142efb80947Sahrens 143efb80947Sahrens return (0); 144efb80947Sahrens } 145efb80947Sahrens 146efb80947Sahrens static int 147efb80947Sahrens dump_data(struct backuparg *ba, dmu_object_type_t type, 1488e714474SLori Alt uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data) 149efb80947Sahrens { 1509e69d7d0SLori Alt struct drr_write *drrw = &(ba->drr->drr_u.drr_write); 1519e69d7d0SLori Alt 1528e714474SLori Alt 1539e69d7d0SLori Alt /* 1549e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1559e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1569e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1579e69d7d0SLori Alt * of different types. 1589e69d7d0SLori Alt */ 1599e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 1609e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1619e69d7d0SLori Alt return (EINTR); 1629e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1639e69d7d0SLori Alt } 164efb80947Sahrens /* write a DATA record */ 165efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 166efb80947Sahrens ba->drr->drr_type = DRR_WRITE; 1679e69d7d0SLori Alt drrw->drr_object = object; 1689e69d7d0SLori Alt drrw->drr_type = type; 1699e69d7d0SLori Alt drrw->drr_offset = offset; 1709e69d7d0SLori Alt drrw->drr_length = blksz; 1719e69d7d0SLori Alt drrw->drr_toguid = ba->toguid; 1728e714474SLori Alt drrw->drr_checksumtype = BP_GET_CHECKSUM(bp); 1738e714474SLori Alt if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup) 1748e714474SLori Alt drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP; 1758e714474SLori Alt DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp)); 1768e714474SLori Alt DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp)); 1778e714474SLori Alt DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp)); 1788e714474SLori Alt drrw->drr_key.ddk_cksum = bp->blk_cksum; 179efb80947Sahrens 1809e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 181efb80947Sahrens return (EINTR); 1829e69d7d0SLori Alt if (dump_bytes(ba, data, blksz) != 0) 183efb80947Sahrens return (EINTR); 184efb80947Sahrens return (0); 185efb80947Sahrens } 186efb80947Sahrens 1870a586ceaSMark Shellenbaum static int 1880a586ceaSMark Shellenbaum dump_spill(struct backuparg *ba, uint64_t object, int blksz, void *data) 1890a586ceaSMark Shellenbaum { 1900a586ceaSMark Shellenbaum struct drr_spill *drrs = &(ba->drr->drr_u.drr_spill); 1910a586ceaSMark Shellenbaum 1920a586ceaSMark Shellenbaum if (ba->pending_op != PENDING_NONE) { 1930a586ceaSMark Shellenbaum if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1940a586ceaSMark Shellenbaum return (EINTR); 1950a586ceaSMark Shellenbaum ba->pending_op = PENDING_NONE; 1960a586ceaSMark Shellenbaum } 1970a586ceaSMark Shellenbaum 1980a586ceaSMark Shellenbaum /* write a SPILL record */ 1990a586ceaSMark Shellenbaum bzero(ba->drr, sizeof (dmu_replay_record_t)); 2000a586ceaSMark Shellenbaum ba->drr->drr_type = DRR_SPILL; 2010a586ceaSMark Shellenbaum drrs->drr_object = object; 2020a586ceaSMark Shellenbaum drrs->drr_length = blksz; 2030a586ceaSMark Shellenbaum drrs->drr_toguid = ba->toguid; 2040a586ceaSMark Shellenbaum 2050a586ceaSMark Shellenbaum if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t))) 2060a586ceaSMark Shellenbaum return (EINTR); 2070a586ceaSMark Shellenbaum if (dump_bytes(ba, data, blksz)) 2080a586ceaSMark Shellenbaum return (EINTR); 2090a586ceaSMark Shellenbaum return (0); 2100a586ceaSMark Shellenbaum } 2110a586ceaSMark Shellenbaum 212efb80947Sahrens static int 213efb80947Sahrens dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs) 214efb80947Sahrens { 2159e69d7d0SLori Alt struct drr_freeobjects *drrfo = &(ba->drr->drr_u.drr_freeobjects); 2169e69d7d0SLori Alt 2179e69d7d0SLori Alt /* 2189e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 2199e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 2209e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 2219e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 2229e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 2239e69d7d0SLori Alt */ 2249e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && 2259e69d7d0SLori Alt ba->pending_op != PENDING_FREEOBJECTS) { 2269e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2279e69d7d0SLori Alt return (EINTR); 2289e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2299e69d7d0SLori Alt } 2309e69d7d0SLori Alt if (ba->pending_op == PENDING_FREEOBJECTS) { 2319e69d7d0SLori Alt /* 2329e69d7d0SLori Alt * See whether this free object array can be aggregated 2339e69d7d0SLori Alt * with pending one 2349e69d7d0SLori Alt */ 2359e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2369e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2379e69d7d0SLori Alt return (0); 2389e69d7d0SLori Alt } else { 2399e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2409e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 2419e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2429e69d7d0SLori Alt return (EINTR); 2439e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2449e69d7d0SLori Alt } 2459e69d7d0SLori Alt } 2469e69d7d0SLori Alt 247efb80947Sahrens /* write a FREEOBJECTS record */ 248efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 249efb80947Sahrens ba->drr->drr_type = DRR_FREEOBJECTS; 2509e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2519e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2529e69d7d0SLori Alt drrfo->drr_toguid = ba->toguid; 2539e69d7d0SLori Alt 2549e69d7d0SLori Alt ba->pending_op = PENDING_FREEOBJECTS; 255efb80947Sahrens 256efb80947Sahrens return (0); 257efb80947Sahrens } 258efb80947Sahrens 259efb80947Sahrens static int 260efb80947Sahrens dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp) 261efb80947Sahrens { 2629e69d7d0SLori Alt struct drr_object *drro = &(ba->drr->drr_u.drr_object); 2639e69d7d0SLori Alt 264efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 265efb80947Sahrens return (dump_freeobjects(ba, object, 1)); 266efb80947Sahrens 2679e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 2689e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2699e69d7d0SLori Alt return (EINTR); 2709e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2719e69d7d0SLori Alt } 2729e69d7d0SLori Alt 273efb80947Sahrens /* write an OBJECT record */ 274efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 275efb80947Sahrens ba->drr->drr_type = DRR_OBJECT; 2769e69d7d0SLori Alt drro->drr_object = object; 2779e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2789e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2799e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2809e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2819e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2829e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2839e69d7d0SLori Alt drro->drr_toguid = ba->toguid; 2849e69d7d0SLori Alt 2859e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 286efb80947Sahrens return (EINTR); 287efb80947Sahrens 2889e69d7d0SLori Alt if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 289efb80947Sahrens return (EINTR); 290efb80947Sahrens 291efb80947Sahrens /* free anything past the end of the file */ 292efb80947Sahrens if (dump_free(ba, object, (dnp->dn_maxblkid + 1) * 293efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 294efb80947Sahrens return (EINTR); 295efb80947Sahrens if (ba->err) 296efb80947Sahrens return (EINTR); 297efb80947Sahrens return (0); 298efb80947Sahrens } 299efb80947Sahrens 300efb80947Sahrens #define BP_SPAN(dnp, level) \ 301efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 302efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 303efb80947Sahrens 304b24ab676SJeff Bonwick /* ARGSUSED */ 305efb80947Sahrens static int 3063f9d6ad7SLin Ling backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf, 307b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 308efb80947Sahrens { 309efb80947Sahrens struct backuparg *ba = arg; 310efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 311efb80947Sahrens int err = 0; 312efb80947Sahrens 313efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 314efb80947Sahrens return (EINTR); 315efb80947Sahrens 316b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 317b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 31814843421SMatthew Ahrens return (0); 319b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 32088b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 32188b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 322efb80947Sahrens err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT); 323efb80947Sahrens } else if (bp == NULL) { 32488b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 32588b7b0f2SMatthew Ahrens err = dump_free(ba, zb->zb_object, zb->zb_blkid * span, span); 32688b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 32788b7b0f2SMatthew Ahrens return (0); 32888b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 32988b7b0f2SMatthew Ahrens dnode_phys_t *blk; 330efb80947Sahrens int i; 331efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 33288b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 33388b7b0f2SMatthew Ahrens arc_buf_t *abuf; 334efb80947Sahrens 3353f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 33688b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 33788b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 33888b7b0f2SMatthew Ahrens return (EIO); 33988b7b0f2SMatthew Ahrens 34088b7b0f2SMatthew Ahrens blk = abuf->b_data; 341efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 34288b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 34388b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 344efb80947Sahrens err = dump_dnode(ba, dnobj, blk+i); 345efb80947Sahrens if (err) 346efb80947Sahrens break; 347efb80947Sahrens } 34888b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 3490a586ceaSMark Shellenbaum } else if (type == DMU_OT_SA) { 3500a586ceaSMark Shellenbaum uint32_t aflags = ARC_WAIT; 3510a586ceaSMark Shellenbaum arc_buf_t *abuf; 3520a586ceaSMark Shellenbaum int blksz = BP_GET_LSIZE(bp); 3530a586ceaSMark Shellenbaum 3540a586ceaSMark Shellenbaum if (arc_read_nolock(NULL, spa, bp, 3550a586ceaSMark Shellenbaum arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 3560a586ceaSMark Shellenbaum ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 3570a586ceaSMark Shellenbaum return (EIO); 3580a586ceaSMark Shellenbaum 3590a586ceaSMark Shellenbaum err = dump_spill(ba, zb->zb_object, blksz, abuf->b_data); 3600a586ceaSMark Shellenbaum (void) arc_buf_remove_ref(abuf, &abuf); 36188b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 36288b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 36388b7b0f2SMatthew Ahrens arc_buf_t *abuf; 364efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 36588b7b0f2SMatthew Ahrens 3663f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 36788b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 36888b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 36988b7b0f2SMatthew Ahrens return (EIO); 37088b7b0f2SMatthew Ahrens 37188b7b0f2SMatthew Ahrens err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz, 3728e714474SLori Alt blksz, bp, abuf->b_data); 37388b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 374efb80947Sahrens } 375efb80947Sahrens 376efb80947Sahrens ASSERT(err == 0 || err == EINTR); 377efb80947Sahrens return (err); 378efb80947Sahrens } 379efb80947Sahrens 380efb80947Sahrens int 3813cb34c60Sahrens dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 3823cb34c60Sahrens vnode_t *vp, offset_t *off) 383efb80947Sahrens { 384503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 385503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 386efb80947Sahrens dmu_replay_record_t *drr; 387efb80947Sahrens struct backuparg ba; 388efb80947Sahrens int err; 3893cb34c60Sahrens uint64_t fromtxg = 0; 390efb80947Sahrens 391efb80947Sahrens /* tosnap must be a snapshot */ 392efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 393efb80947Sahrens return (EINVAL); 394efb80947Sahrens 395efb80947Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 396efb80947Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 3973cb34c60Sahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 398efb80947Sahrens return (EXDEV); 399efb80947Sahrens 4003cb34c60Sahrens if (fromorigin) { 401088f3894Sahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 402088f3894Sahrens 4033cb34c60Sahrens if (fromsnap) 4043cb34c60Sahrens return (EINVAL); 4053cb34c60Sahrens 406088f3894Sahrens if (dsl_dir_is_clone(ds->ds_dir)) { 4073cb34c60Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 408745cd3c5Smaybee err = dsl_dataset_hold_obj(dp, 409745cd3c5Smaybee ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 4103cb34c60Sahrens rw_exit(&dp->dp_config_rwlock); 4113cb34c60Sahrens if (err) 4123cb34c60Sahrens return (err); 4133cb34c60Sahrens } else { 4143cb34c60Sahrens fromorigin = B_FALSE; 4153cb34c60Sahrens } 4163cb34c60Sahrens } 4173cb34c60Sahrens 4183cb34c60Sahrens 419efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 420efb80947Sahrens drr->drr_type = DRR_BEGIN; 421efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 4229e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 4239e69d7d0SLori Alt DMU_SUBSTREAM); 424dc7cd546SMark Shellenbaum 425dc7cd546SMark Shellenbaum #ifdef _KERNEL 426dc7cd546SMark Shellenbaum if (dmu_objset_type(tosnap) == DMU_OST_ZFS) { 427dc7cd546SMark Shellenbaum uint64_t version; 428dc7cd546SMark Shellenbaum if (zfs_get_zplprop(tosnap, ZFS_PROP_VERSION, &version) != 0) 429dc7cd546SMark Shellenbaum return (EINVAL); 430dc7cd546SMark Shellenbaum if (version == ZPL_VERSION_SA) { 431dc7cd546SMark Shellenbaum DMU_SET_FEATUREFLAGS( 432dc7cd546SMark Shellenbaum drr->drr_u.drr_begin.drr_versioninfo, 433dc7cd546SMark Shellenbaum DMU_BACKUP_FEATURE_SA_SPILL); 434dc7cd546SMark Shellenbaum } 435dc7cd546SMark Shellenbaum } 436dc7cd546SMark Shellenbaum #endif 437dc7cd546SMark Shellenbaum 438efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 439efb80947Sahrens ds->ds_phys->ds_creation_time; 440503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 4413cb34c60Sahrens if (fromorigin) 4423cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 443efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 444ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 445ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 446ab04eb8eStimh 447efb80947Sahrens if (fromds) 448efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 449efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 450efb80947Sahrens 4513cb34c60Sahrens if (fromds) 4523cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 4533cb34c60Sahrens if (fromorigin) 454745cd3c5Smaybee dsl_dataset_rele(fromds, FTAG); 4553cb34c60Sahrens 456efb80947Sahrens ba.drr = drr; 457efb80947Sahrens ba.vp = vp; 458efb80947Sahrens ba.os = tosnap; 4593cb34c60Sahrens ba.off = off; 4609e69d7d0SLori Alt ba.toguid = ds->ds_phys->ds_guid; 461efb80947Sahrens ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0); 4629e69d7d0SLori Alt ba.pending_op = PENDING_NONE; 463efb80947Sahrens 4649e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 465efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 466efb80947Sahrens return (ba.err); 467efb80947Sahrens } 468efb80947Sahrens 46988b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 470efb80947Sahrens backup_cb, &ba); 471efb80947Sahrens 4729e69d7d0SLori Alt if (ba.pending_op != PENDING_NONE) 4739e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) 4749e69d7d0SLori Alt err = EINTR; 4759e69d7d0SLori Alt 476efb80947Sahrens if (err) { 477efb80947Sahrens if (err == EINTR && ba.err) 478efb80947Sahrens err = ba.err; 4797b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 480efb80947Sahrens return (err); 481efb80947Sahrens } 482efb80947Sahrens 483efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 484efb80947Sahrens drr->drr_type = DRR_END; 485efb80947Sahrens drr->drr_u.drr_end.drr_checksum = ba.zc; 4869e69d7d0SLori Alt drr->drr_u.drr_end.drr_toguid = ba.toguid; 487efb80947Sahrens 4889e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 4897b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 490efb80947Sahrens return (ba.err); 4917b5309bbSgw } 492efb80947Sahrens 493efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 494efb80947Sahrens 495efb80947Sahrens return (0); 496efb80947Sahrens } 497efb80947Sahrens 4983cb34c60Sahrens struct recvbeginsyncarg { 4993cb34c60Sahrens const char *tofs; 5003cb34c60Sahrens const char *tosnap; 5013cb34c60Sahrens dsl_dataset_t *origin; 5023cb34c60Sahrens uint64_t fromguid; 5033cb34c60Sahrens dmu_objset_type_t type; 5043cb34c60Sahrens void *tag; 5053cb34c60Sahrens boolean_t force; 506ab04eb8eStimh uint64_t dsflags; 5073cb34c60Sahrens char clonelastname[MAXNAMELEN]; 5083cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 5093f9d6ad7SLin Ling cred_t *cr; 510efb80947Sahrens }; 511efb80947Sahrens 512efb80947Sahrens /* ARGSUSED */ 513efb80947Sahrens static int 514ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 515efb80947Sahrens { 516efb80947Sahrens dsl_dir_t *dd = arg1; 5173cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 518efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 519efb80947Sahrens uint64_t val; 520efb80947Sahrens int err; 521efb80947Sahrens 522efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 5233cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 524efb80947Sahrens 525efb80947Sahrens if (err != ENOENT) 526efb80947Sahrens return (err ? err : EEXIST); 527efb80947Sahrens 5283cb34c60Sahrens if (rbsa->origin) { 5293cb34c60Sahrens /* make sure it's a snap in the same pool */ 5303cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 5313cb34c60Sahrens return (EXDEV); 532ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 5333cb34c60Sahrens return (EINVAL); 5343cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 5353cb34c60Sahrens return (ENODEV); 5363cb34c60Sahrens } 5373cb34c60Sahrens 538efb80947Sahrens return (0); 539efb80947Sahrens } 540efb80947Sahrens 541efb80947Sahrens static void 5423f9d6ad7SLin Ling recv_new_sync(void *arg1, void *arg2, dmu_tx_t *tx) 543efb80947Sahrens { 544efb80947Sahrens dsl_dir_t *dd = arg1; 5453cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 546745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 547efb80947Sahrens uint64_t dsobj; 548efb80947Sahrens 549ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 5503cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 5513f9d6ad7SLin Ling rbsa->origin, flags, rbsa->cr, tx); 552ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 553503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 554efb80947Sahrens 555ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 556ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 557ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 5583cb34c60Sahrens } 559ecd6cf80Smarks 5603f9d6ad7SLin Ling spa_history_log_internal(LOG_DS_REPLAY_FULL_SYNC, 5613f9d6ad7SLin Ling dd->dd_pool->dp_spa, tx, "dataset = %lld", dsobj); 5623cb34c60Sahrens } 563f18faf3fSek 564f18faf3fSek /* ARGSUSED */ 565f18faf3fSek static int 566ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 567f18faf3fSek { 5683cb34c60Sahrens dsl_dataset_t *ds = arg1; 5693cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5703cb34c60Sahrens int err; 5713cb34c60Sahrens uint64_t val; 572f18faf3fSek 5733cb34c60Sahrens /* must not have any changes since most recent snapshot */ 5743cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 575f18faf3fSek return (ETXTBSY); 576f18faf3fSek 577ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 578ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 579ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 580ae46e4c7SMatthew Ahrens return (ENODEV); 58192241e0bSTom Erickson 58292241e0bSTom Erickson /* 58392241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 58492241e0bSTom Erickson * changes since the fromguid one 58592241e0bSTom Erickson */ 58692241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 58792241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 58892241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 58992241e0bSTom Erickson while (obj != 0) { 59092241e0bSTom Erickson dsl_dataset_t *snap; 59192241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 59292241e0bSTom Erickson obj, FTAG, &snap); 59392241e0bSTom Erickson if (err) 59492241e0bSTom Erickson return (ENODEV); 59592241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 59692241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 59792241e0bSTom Erickson return (ENODEV); 59892241e0bSTom Erickson } 59992241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 60092241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 60192241e0bSTom Erickson break; /* it's ok */ 60292241e0bSTom Erickson } 60392241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 60492241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 60592241e0bSTom Erickson } 60692241e0bSTom Erickson if (obj == 0) 60792241e0bSTom Erickson return (ENODEV); 60892241e0bSTom Erickson } 609ae46e4c7SMatthew Ahrens } else { 610ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 611ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 612ae46e4c7SMatthew Ahrens return (ENODEV); 613ae46e4c7SMatthew Ahrens } 6143cb34c60Sahrens 61547f263f4Sek /* temporary clone name must not exist */ 61647f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 61747f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 61847f263f4Sek rbsa->clonelastname, 8, 1, &val); 61947f263f4Sek if (err == 0) 62047f263f4Sek return (EEXIST); 62147f263f4Sek if (err != ENOENT) 62247f263f4Sek return (err); 62347f263f4Sek 6243cb34c60Sahrens /* new snapshot name must not exist */ 6253cb34c60Sahrens err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 6263cb34c60Sahrens ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 6273cb34c60Sahrens if (err == 0) 6283cb34c60Sahrens return (EEXIST); 6293cb34c60Sahrens if (err != ENOENT) 6303cb34c60Sahrens return (err); 6313cb34c60Sahrens return (0); 632f18faf3fSek } 633f18faf3fSek 634f18faf3fSek /* ARGSUSED */ 635f18faf3fSek static void 6363f9d6ad7SLin Ling recv_existing_sync(void *arg1, void *arg2, dmu_tx_t *tx) 637f18faf3fSek { 6383cb34c60Sahrens dsl_dataset_t *ohds = arg1; 6393cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 6403cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 641ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 642745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 643f18faf3fSek uint64_t dsobj; 644f18faf3fSek 645ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 646ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 6473f9d6ad7SLin Ling ohds->ds_prev, flags, rbsa->cr, tx); 648503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 6493cb34c60Sahrens 650ae46e4c7SMatthew Ahrens /* 651ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 652ae46e4c7SMatthew Ahrens * objset in our new dataset. 653ae46e4c7SMatthew Ahrens */ 654ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 655ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 656ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 657ae46e4c7SMatthew Ahrens } 658ae46e4c7SMatthew Ahrens 6593cb34c60Sahrens rbsa->ds = cds; 6603cb34c60Sahrens 6613f9d6ad7SLin Ling spa_history_log_internal(LOG_DS_REPLAY_INC_SYNC, 6623f9d6ad7SLin Ling dp->dp_spa, tx, "dataset = %lld", dsobj); 6633cb34c60Sahrens } 6643cb34c60Sahrens 665dc7cd546SMark Shellenbaum 666dc7cd546SMark Shellenbaum static boolean_t 667dc7cd546SMark Shellenbaum dmu_recv_verify_features(dsl_dataset_t *ds, struct drr_begin *drrb) 668dc7cd546SMark Shellenbaum { 669dc7cd546SMark Shellenbaum int featureflags; 670dc7cd546SMark Shellenbaum 671dc7cd546SMark Shellenbaum featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 672dc7cd546SMark Shellenbaum 673dc7cd546SMark Shellenbaum /* Verify pool version supports SA if SA_SPILL feature set */ 674dc7cd546SMark Shellenbaum return ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) && 675dc7cd546SMark Shellenbaum (spa_version(dsl_dataset_get_spa(ds)) < SPA_VERSION_SA)); 676dc7cd546SMark Shellenbaum } 677dc7cd546SMark Shellenbaum 6783cb34c60Sahrens /* 6793cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 6803cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 6813cb34c60Sahrens */ 6823cb34c60Sahrens int 6839e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 684f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 685efb80947Sahrens { 6863cb34c60Sahrens int err = 0; 6873cb34c60Sahrens boolean_t byteswap; 688ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 6899e69d7d0SLori Alt uint64_t versioninfo; 6903cb34c60Sahrens int flags; 6913cb34c60Sahrens dsl_dataset_t *ds; 692efb80947Sahrens 6933cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 6943cb34c60Sahrens byteswap = FALSE; 6953cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 6963cb34c60Sahrens byteswap = TRUE; 6973cb34c60Sahrens else 6983cb34c60Sahrens return (EINVAL); 6993cb34c60Sahrens 7003cb34c60Sahrens rbsa.tofs = tofs; 7013cb34c60Sahrens rbsa.tosnap = tosnap; 702503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 7033cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 7043cb34c60Sahrens rbsa.type = drrb->drr_type; 7053cb34c60Sahrens rbsa.tag = FTAG; 706ab04eb8eStimh rbsa.dsflags = 0; 7073f9d6ad7SLin Ling rbsa.cr = CRED(); 7089e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 7093cb34c60Sahrens flags = drrb->drr_flags; 7103cb34c60Sahrens 7113cb34c60Sahrens if (byteswap) { 7123cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 7133cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 7149e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 7153cb34c60Sahrens flags = BSWAP_32(flags); 7163cb34c60Sahrens } 717efb80947Sahrens 7189e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 7193cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 7203cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 721efb80947Sahrens return (EINVAL); 722efb80947Sahrens 723ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 724ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 725ab04eb8eStimh 7263cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 7273cb34c60Sahrens drc->drc_drrb = drrb; 7283cb34c60Sahrens drc->drc_tosnap = tosnap; 7299e69d7d0SLori Alt drc->drc_top_ds = top_ds; 7303cb34c60Sahrens drc->drc_force = force; 731efb80947Sahrens 7323cb34c60Sahrens /* 7333cb34c60Sahrens * Process the begin in syncing context. 7343cb34c60Sahrens */ 735efb80947Sahrens 736ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 737ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 738ae46e4c7SMatthew Ahrens if (err == 0) { 739dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 740dc7cd546SMark Shellenbaum dsl_dataset_rele(ds, dmu_recv_tag); 741dc7cd546SMark Shellenbaum return (ENOTSUP); 742dc7cd546SMark Shellenbaum } 743ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 744efb80947Sahrens 745ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 746ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 747ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 748ae46e4c7SMatthew Ahrens return (EINVAL); 749ae46e4c7SMatthew Ahrens } 750efb80947Sahrens 751f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 752f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 753f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 754f4b94bdeSMatthew Ahrens return (EBUSY); 755f4b94bdeSMatthew Ahrens } 756f4b94bdeSMatthew Ahrens 757ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 758ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 759ae46e4c7SMatthew Ahrens "%%%s", tosnap); 7603cb34c60Sahrens rbsa.force = force; 7613cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 762ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 7633cb34c60Sahrens if (err) { 764f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 765745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 7663cb34c60Sahrens return (err); 7673cb34c60Sahrens } 7683cb34c60Sahrens drc->drc_logical_ds = ds; 7693cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 770ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 771ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 772ae46e4c7SMatthew Ahrens char *cp; 773efb80947Sahrens 774ae46e4c7SMatthew Ahrens /* 775ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 776ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 777ae46e4c7SMatthew Ahrens */ 778ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 779ae46e4c7SMatthew Ahrens return (ENOENT); 780ae46e4c7SMatthew Ahrens 781ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 782ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 783ae46e4c7SMatthew Ahrens *cp = '\0'; 784bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 785ae46e4c7SMatthew Ahrens *cp = '/'; 7863cb34c60Sahrens if (err) 7873cb34c60Sahrens return (err); 788efb80947Sahrens 789dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 790dc7cd546SMark Shellenbaum dsl_dataset_rele(ds, dmu_recv_tag); 791dc7cd546SMark Shellenbaum return (ENOTSUP); 792dc7cd546SMark Shellenbaum } 793dc7cd546SMark Shellenbaum 794ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 795ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 796bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 7973cb34c60Sahrens if (err) 7983cb34c60Sahrens return (err); 7993cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 8003cb34c60Sahrens drc->drc_newfs = B_TRUE; 8013cb34c60Sahrens } 8023cb34c60Sahrens 803ae46e4c7SMatthew Ahrens return (err); 804efb80947Sahrens } 805efb80947Sahrens 8063cb34c60Sahrens struct restorearg { 8073cb34c60Sahrens int err; 8083cb34c60Sahrens int byteswap; 8093cb34c60Sahrens vnode_t *vp; 8103cb34c60Sahrens char *buf; 8113cb34c60Sahrens uint64_t voff; 8123cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 8133cb34c60Sahrens zio_cksum_t cksum; 814*c99e4bdcSChris Kirby avl_tree_t *guid_to_ds_map; 8153cb34c60Sahrens }; 8163cb34c60Sahrens 8179e69d7d0SLori Alt typedef struct guid_map_entry { 8189e69d7d0SLori Alt uint64_t guid; 8199e69d7d0SLori Alt dsl_dataset_t *gme_ds; 8209e69d7d0SLori Alt avl_node_t avlnode; 8219e69d7d0SLori Alt } guid_map_entry_t; 8229e69d7d0SLori Alt 8239e69d7d0SLori Alt static int 8249e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 8259e69d7d0SLori Alt { 8269e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 8279e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 8289e69d7d0SLori Alt 8299e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 8309e69d7d0SLori Alt return (-1); 8319e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 8329e69d7d0SLori Alt return (1); 8339e69d7d0SLori Alt return (0); 8349e69d7d0SLori Alt } 8359e69d7d0SLori Alt 8369e69d7d0SLori Alt /* 8379e69d7d0SLori Alt * This function is a callback used by dmu_objset_find() (which 8389e69d7d0SLori Alt * enumerates the object sets) to build an avl tree that maps guids 8399e69d7d0SLori Alt * to datasets. The resulting table is used when processing DRR_WRITE_BYREF 8409e69d7d0SLori Alt * send stream records. These records, which are used in dedup'ed 8419e69d7d0SLori Alt * streams, do not contain data themselves, but refer to a copy 8429e69d7d0SLori Alt * of the data block that has already been written because it was 8439e69d7d0SLori Alt * earlier in the stream. That previous copy is identified by the 8449e69d7d0SLori Alt * guid of the dataset with the referenced data. 8459e69d7d0SLori Alt */ 8469e69d7d0SLori Alt int 847fd136879SMatthew Ahrens find_ds_by_guid(const char *name, void *arg) 8489e69d7d0SLori Alt { 8499e69d7d0SLori Alt avl_tree_t *guid_map = arg; 850fd136879SMatthew Ahrens dsl_dataset_t *ds, *snapds; 8519e69d7d0SLori Alt guid_map_entry_t *gmep; 852fd136879SMatthew Ahrens dsl_pool_t *dp; 8539e69d7d0SLori Alt int err; 8549e69d7d0SLori Alt uint64_t lastobj, firstobj; 8559e69d7d0SLori Alt 8569e69d7d0SLori Alt if (dsl_dataset_hold(name, FTAG, &ds) != 0) 8579e69d7d0SLori Alt return (0); 8589e69d7d0SLori Alt 8599e69d7d0SLori Alt dp = ds->ds_dir->dd_pool; 8609e69d7d0SLori Alt rw_enter(&dp->dp_config_rwlock, RW_READER); 8619e69d7d0SLori Alt firstobj = ds->ds_dir->dd_phys->dd_origin_obj; 8629e69d7d0SLori Alt lastobj = ds->ds_phys->ds_prev_snap_obj; 8639e69d7d0SLori Alt 8649e69d7d0SLori Alt while (lastobj != firstobj) { 8659e69d7d0SLori Alt err = dsl_dataset_hold_obj(dp, lastobj, guid_map, &snapds); 8669e69d7d0SLori Alt if (err) { 8679e69d7d0SLori Alt /* 8689e69d7d0SLori Alt * Skip this snapshot and move on. It's not 8699e69d7d0SLori Alt * clear why this would ever happen, but the 8709e69d7d0SLori Alt * remainder of the snapshot streadm can be 8719e69d7d0SLori Alt * processed. 8729e69d7d0SLori Alt */ 8739e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 8749e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 8759e69d7d0SLori Alt return (0); 8769e69d7d0SLori Alt } 8779e69d7d0SLori Alt 8789e69d7d0SLori Alt gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 8799e69d7d0SLori Alt gmep->guid = snapds->ds_phys->ds_guid; 8809e69d7d0SLori Alt gmep->gme_ds = snapds; 8819e69d7d0SLori Alt avl_add(guid_map, gmep); 8829e69d7d0SLori Alt lastobj = snapds->ds_phys->ds_prev_snap_obj; 8839e69d7d0SLori Alt } 8849e69d7d0SLori Alt 8859e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 8869e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 8879e69d7d0SLori Alt 8889e69d7d0SLori Alt return (0); 8899e69d7d0SLori Alt } 8909e69d7d0SLori Alt 891*c99e4bdcSChris Kirby static void 892*c99e4bdcSChris Kirby free_guid_map_onexit(void *arg) 893*c99e4bdcSChris Kirby { 894*c99e4bdcSChris Kirby avl_tree_t *ca = arg; 895*c99e4bdcSChris Kirby void *cookie = NULL; 896*c99e4bdcSChris Kirby guid_map_entry_t *gmep; 897*c99e4bdcSChris Kirby 898*c99e4bdcSChris Kirby while ((gmep = avl_destroy_nodes(ca, &cookie)) != NULL) { 899*c99e4bdcSChris Kirby dsl_dataset_rele(gmep->gme_ds, ca); 900*c99e4bdcSChris Kirby kmem_free(gmep, sizeof (guid_map_entry_t)); 901*c99e4bdcSChris Kirby } 902*c99e4bdcSChris Kirby avl_destroy(ca); 903*c99e4bdcSChris Kirby kmem_free(ca, sizeof (avl_tree_t)); 904*c99e4bdcSChris Kirby } 905*c99e4bdcSChris Kirby 906efb80947Sahrens static void * 907efb80947Sahrens restore_read(struct restorearg *ra, int len) 908efb80947Sahrens { 909efb80947Sahrens void *rv; 9103cb34c60Sahrens int done = 0; 911efb80947Sahrens 912efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 913efb80947Sahrens ASSERT3U(len % 8, ==, 0); 914efb80947Sahrens 9153cb34c60Sahrens while (done < len) { 916efb80947Sahrens ssize_t resid; 917efb80947Sahrens 918efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 9193cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 920efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 921efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 922efb80947Sahrens 9233cb34c60Sahrens if (resid == len - done) 924efb80947Sahrens ra->err = EINVAL; 9253cb34c60Sahrens ra->voff += len - done - resid; 9263cb34c60Sahrens done = len - resid; 927efb80947Sahrens if (ra->err) 928efb80947Sahrens return (NULL); 929efb80947Sahrens } 930efb80947Sahrens 9313cb34c60Sahrens ASSERT3U(done, ==, len); 9323cb34c60Sahrens rv = ra->buf; 933efb80947Sahrens if (ra->byteswap) 9343cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 935efb80947Sahrens else 9363cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 937efb80947Sahrens return (rv); 938efb80947Sahrens } 939efb80947Sahrens 940efb80947Sahrens static void 941efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 942efb80947Sahrens { 943efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 944efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 945efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 9463cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 947efb80947Sahrens switch (drr->drr_type) { 948efb80947Sahrens case DRR_BEGIN: 949efb80947Sahrens DO64(drr_begin.drr_magic); 9509e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 951efb80947Sahrens DO64(drr_begin.drr_creation_time); 952efb80947Sahrens DO32(drr_begin.drr_type); 9533cb34c60Sahrens DO32(drr_begin.drr_flags); 954efb80947Sahrens DO64(drr_begin.drr_toguid); 955efb80947Sahrens DO64(drr_begin.drr_fromguid); 956efb80947Sahrens break; 957efb80947Sahrens case DRR_OBJECT: 958efb80947Sahrens DO64(drr_object.drr_object); 959efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 960efb80947Sahrens DO32(drr_object.drr_type); 961efb80947Sahrens DO32(drr_object.drr_bonustype); 962efb80947Sahrens DO32(drr_object.drr_blksz); 963efb80947Sahrens DO32(drr_object.drr_bonuslen); 9649e69d7d0SLori Alt DO64(drr_object.drr_toguid); 965efb80947Sahrens break; 966efb80947Sahrens case DRR_FREEOBJECTS: 967efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 968efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 9699e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 970efb80947Sahrens break; 971efb80947Sahrens case DRR_WRITE: 972efb80947Sahrens DO64(drr_write.drr_object); 973efb80947Sahrens DO32(drr_write.drr_type); 974efb80947Sahrens DO64(drr_write.drr_offset); 975efb80947Sahrens DO64(drr_write.drr_length); 9769e69d7d0SLori Alt DO64(drr_write.drr_toguid); 9778e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[0]); 9788e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[1]); 9798e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[2]); 9808e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[3]); 9818e714474SLori Alt DO64(drr_write.drr_key.ddk_prop); 9829e69d7d0SLori Alt break; 9839e69d7d0SLori Alt case DRR_WRITE_BYREF: 9849e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 9859e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 9869e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 9879e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 9889e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 9899e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 9909e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 9918e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]); 9928e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]); 9938e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]); 9948e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]); 9958e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_prop); 996efb80947Sahrens break; 997efb80947Sahrens case DRR_FREE: 998efb80947Sahrens DO64(drr_free.drr_object); 999efb80947Sahrens DO64(drr_free.drr_offset); 1000efb80947Sahrens DO64(drr_free.drr_length); 10019e69d7d0SLori Alt DO64(drr_free.drr_toguid); 1002efb80947Sahrens break; 10030a586ceaSMark Shellenbaum case DRR_SPILL: 10040a586ceaSMark Shellenbaum DO64(drr_spill.drr_object); 10050a586ceaSMark Shellenbaum DO64(drr_spill.drr_length); 10060a586ceaSMark Shellenbaum DO64(drr_spill.drr_toguid); 10070a586ceaSMark Shellenbaum break; 1008efb80947Sahrens case DRR_END: 1009efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 1010efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 1011efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 1012efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 10139e69d7d0SLori Alt DO64(drr_end.drr_toguid); 1014efb80947Sahrens break; 1015efb80947Sahrens } 1016efb80947Sahrens #undef DO64 1017efb80947Sahrens #undef DO32 1018efb80947Sahrens } 1019efb80947Sahrens 1020efb80947Sahrens static int 1021efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 1022efb80947Sahrens { 1023efb80947Sahrens int err; 1024efb80947Sahrens dmu_tx_t *tx; 1025adee0b6fSTim Haley void *data = NULL; 1026efb80947Sahrens 1027efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 1028efb80947Sahrens drro->drr_type >= DMU_OT_NUMTYPES || 1029efb80947Sahrens drro->drr_bonustype >= DMU_OT_NUMTYPES || 10309e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 1031efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 1032efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 1033efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 1034efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 1035efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 1036efb80947Sahrens return (EINVAL); 1037efb80947Sahrens } 1038efb80947Sahrens 10392bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 10402bf405a2SMark Maybee 10412bf405a2SMark Maybee if (err != 0 && err != ENOENT) 10422bf405a2SMark Maybee return (EINVAL); 10432bf405a2SMark Maybee 1044adee0b6fSTim Haley if (drro->drr_bonuslen) { 1045adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 1046adee0b6fSTim Haley if (ra->err) 1047adee0b6fSTim Haley return (ra->err); 1048adee0b6fSTim Haley } 1049adee0b6fSTim Haley 1050efb80947Sahrens if (err == ENOENT) { 1051efb80947Sahrens /* currently free, want to be allocated */ 10522bf405a2SMark Maybee tx = dmu_tx_create(os); 1053efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 1054efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1055efb80947Sahrens if (err) { 1056efb80947Sahrens dmu_tx_abort(tx); 1057efb80947Sahrens return (err); 1058efb80947Sahrens } 1059efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 1060efb80947Sahrens drro->drr_type, drro->drr_blksz, 1061efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 10622bf405a2SMark Maybee dmu_tx_commit(tx); 1063efb80947Sahrens } else { 1064efb80947Sahrens /* currently allocated, want to be allocated */ 1065efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 1066efb80947Sahrens drro->drr_type, drro->drr_blksz, 10672bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 1068efb80947Sahrens } 10690a586ceaSMark Shellenbaum if (err) { 1070efb80947Sahrens return (EINVAL); 10710a586ceaSMark Shellenbaum } 10722bf405a2SMark Maybee 10732bf405a2SMark Maybee tx = dmu_tx_create(os); 10742bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 10752bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 10762bf405a2SMark Maybee if (err) { 10772bf405a2SMark Maybee dmu_tx_abort(tx); 10782bf405a2SMark Maybee return (err); 1079efb80947Sahrens } 1080efb80947Sahrens 10819e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 10829e69d7d0SLori Alt tx); 1083efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 1084efb80947Sahrens 1085adee0b6fSTim Haley if (data != NULL) { 1086efb80947Sahrens dmu_buf_t *db; 1087adee0b6fSTim Haley 1088efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 1089efb80947Sahrens dmu_buf_will_dirty(db, tx); 1090efb80947Sahrens 10911934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 10921934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 1093efb80947Sahrens if (ra->byteswap) { 1094efb80947Sahrens dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 1095efb80947Sahrens drro->drr_bonuslen); 1096efb80947Sahrens } 1097efb80947Sahrens dmu_buf_rele(db, FTAG); 1098efb80947Sahrens } 1099efb80947Sahrens dmu_tx_commit(tx); 1100efb80947Sahrens return (0); 1101efb80947Sahrens } 1102efb80947Sahrens 1103efb80947Sahrens /* ARGSUSED */ 1104efb80947Sahrens static int 1105efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1106efb80947Sahrens struct drr_freeobjects *drrfo) 1107efb80947Sahrens { 1108efb80947Sahrens uint64_t obj; 1109efb80947Sahrens 1110efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1111efb80947Sahrens return (EINVAL); 1112efb80947Sahrens 1113efb80947Sahrens for (obj = drrfo->drr_firstobj; 1114432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1115432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1116efb80947Sahrens int err; 1117efb80947Sahrens 1118efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1119efb80947Sahrens continue; 1120efb80947Sahrens 1121cdb0ab79Smaybee err = dmu_free_object(os, obj); 1122cdb0ab79Smaybee if (err) 1123efb80947Sahrens return (err); 1124efb80947Sahrens } 1125efb80947Sahrens return (0); 1126efb80947Sahrens } 1127efb80947Sahrens 1128efb80947Sahrens static int 1129efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1130efb80947Sahrens struct drr_write *drrw) 1131efb80947Sahrens { 1132efb80947Sahrens dmu_tx_t *tx; 1133efb80947Sahrens void *data; 1134efb80947Sahrens int err; 1135efb80947Sahrens 1136efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1137efb80947Sahrens drrw->drr_type >= DMU_OT_NUMTYPES) 1138efb80947Sahrens return (EINVAL); 1139efb80947Sahrens 1140efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1141efb80947Sahrens if (data == NULL) 1142efb80947Sahrens return (ra->err); 1143efb80947Sahrens 1144efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1145efb80947Sahrens return (EINVAL); 1146efb80947Sahrens 1147efb80947Sahrens tx = dmu_tx_create(os); 1148efb80947Sahrens 1149efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1150efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1151efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1152efb80947Sahrens if (err) { 1153efb80947Sahrens dmu_tx_abort(tx); 1154efb80947Sahrens return (err); 1155efb80947Sahrens } 1156efb80947Sahrens if (ra->byteswap) 1157efb80947Sahrens dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 1158efb80947Sahrens dmu_write(os, drrw->drr_object, 1159efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1160efb80947Sahrens dmu_tx_commit(tx); 1161efb80947Sahrens return (0); 1162efb80947Sahrens } 1163efb80947Sahrens 11649e69d7d0SLori Alt /* 11659e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 11669e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 11679e69d7d0SLori Alt * system because it came in earlier in the stream. This function 11689e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 11699e69d7d0SLori Alt * data from the stream to fulfill this write. 11709e69d7d0SLori Alt */ 11719e69d7d0SLori Alt static int 11729e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 11739e69d7d0SLori Alt struct drr_write_byref *drrwbr) 11749e69d7d0SLori Alt { 11759e69d7d0SLori Alt dmu_tx_t *tx; 11769e69d7d0SLori Alt int err; 11779e69d7d0SLori Alt guid_map_entry_t gmesrch; 11789e69d7d0SLori Alt guid_map_entry_t *gmep; 11799e69d7d0SLori Alt avl_index_t where; 11809e69d7d0SLori Alt objset_t *ref_os = NULL; 11819e69d7d0SLori Alt dmu_buf_t *dbp; 11829e69d7d0SLori Alt 11839e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 11849e69d7d0SLori Alt return (EINVAL); 11859e69d7d0SLori Alt 11869e69d7d0SLori Alt /* 11879e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 11889e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 11899e69d7d0SLori Alt */ 11909e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 11919e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 1192*c99e4bdcSChris Kirby if ((gmep = avl_find(ra->guid_to_ds_map, &gmesrch, 11939e69d7d0SLori Alt &where)) == NULL) { 11949e69d7d0SLori Alt return (EINVAL); 11959e69d7d0SLori Alt } 11969e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 11979e69d7d0SLori Alt return (EINVAL); 11989e69d7d0SLori Alt } else { 11999e69d7d0SLori Alt ref_os = os; 12009e69d7d0SLori Alt } 12019e69d7d0SLori Alt 12029e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 120347cb52daSJeff Bonwick drrwbr->drr_refoffset, FTAG, &dbp, DMU_READ_PREFETCH)) 12049e69d7d0SLori Alt return (err); 12059e69d7d0SLori Alt 12069e69d7d0SLori Alt tx = dmu_tx_create(os); 12079e69d7d0SLori Alt 12089e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 12099e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 12109e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 12119e69d7d0SLori Alt if (err) { 12129e69d7d0SLori Alt dmu_tx_abort(tx); 12139e69d7d0SLori Alt return (err); 12149e69d7d0SLori Alt } 12159e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 12169e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 12179e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 12189e69d7d0SLori Alt dmu_tx_commit(tx); 12199e69d7d0SLori Alt return (0); 12209e69d7d0SLori Alt } 12219e69d7d0SLori Alt 12220a586ceaSMark Shellenbaum static int 12230a586ceaSMark Shellenbaum restore_spill(struct restorearg *ra, objset_t *os, struct drr_spill *drrs) 12240a586ceaSMark Shellenbaum { 12250a586ceaSMark Shellenbaum dmu_tx_t *tx; 12260a586ceaSMark Shellenbaum void *data; 12270a586ceaSMark Shellenbaum dmu_buf_t *db, *db_spill; 12280a586ceaSMark Shellenbaum int err; 12290a586ceaSMark Shellenbaum 12300a586ceaSMark Shellenbaum if (drrs->drr_length < SPA_MINBLOCKSIZE || 12310a586ceaSMark Shellenbaum drrs->drr_length > SPA_MAXBLOCKSIZE) 12320a586ceaSMark Shellenbaum return (EINVAL); 12330a586ceaSMark Shellenbaum 12340a586ceaSMark Shellenbaum data = restore_read(ra, drrs->drr_length); 12350a586ceaSMark Shellenbaum if (data == NULL) 12360a586ceaSMark Shellenbaum return (ra->err); 12370a586ceaSMark Shellenbaum 12380a586ceaSMark Shellenbaum if (dmu_object_info(os, drrs->drr_object, NULL) != 0) 12390a586ceaSMark Shellenbaum return (EINVAL); 12400a586ceaSMark Shellenbaum 12410a586ceaSMark Shellenbaum VERIFY(0 == dmu_bonus_hold(os, drrs->drr_object, FTAG, &db)); 12420a586ceaSMark Shellenbaum if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) { 12430a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 12440a586ceaSMark Shellenbaum return (err); 12450a586ceaSMark Shellenbaum } 12460a586ceaSMark Shellenbaum 12470a586ceaSMark Shellenbaum tx = dmu_tx_create(os); 12480a586ceaSMark Shellenbaum 12490a586ceaSMark Shellenbaum dmu_tx_hold_spill(tx, db->db_object); 12500a586ceaSMark Shellenbaum 12510a586ceaSMark Shellenbaum err = dmu_tx_assign(tx, TXG_WAIT); 12520a586ceaSMark Shellenbaum if (err) { 12530a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 12540a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 12550a586ceaSMark Shellenbaum dmu_tx_abort(tx); 12560a586ceaSMark Shellenbaum return (err); 12570a586ceaSMark Shellenbaum } 12580a586ceaSMark Shellenbaum dmu_buf_will_dirty(db_spill, tx); 12590a586ceaSMark Shellenbaum 12600a586ceaSMark Shellenbaum if (db_spill->db_size < drrs->drr_length) 12610a586ceaSMark Shellenbaum VERIFY(0 == dbuf_spill_set_blksz(db_spill, 12620a586ceaSMark Shellenbaum drrs->drr_length, tx)); 12630a586ceaSMark Shellenbaum bcopy(data, db_spill->db_data, drrs->drr_length); 12640a586ceaSMark Shellenbaum 12650a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 12660a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 12670a586ceaSMark Shellenbaum 12680a586ceaSMark Shellenbaum dmu_tx_commit(tx); 12690a586ceaSMark Shellenbaum return (0); 12700a586ceaSMark Shellenbaum } 12710a586ceaSMark Shellenbaum 1272efb80947Sahrens /* ARGSUSED */ 1273efb80947Sahrens static int 1274efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1275efb80947Sahrens struct drr_free *drrf) 1276efb80947Sahrens { 1277efb80947Sahrens int err; 1278efb80947Sahrens 1279efb80947Sahrens if (drrf->drr_length != -1ULL && 1280efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1281efb80947Sahrens return (EINVAL); 1282efb80947Sahrens 1283efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1284efb80947Sahrens return (EINVAL); 1285efb80947Sahrens 1286cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1287efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1288efb80947Sahrens return (err); 1289efb80947Sahrens } 1290efb80947Sahrens 12913cb34c60Sahrens /* 12923cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 12933cb34c60Sahrens */ 1294efb80947Sahrens int 1295*c99e4bdcSChris Kirby dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp, 1296*c99e4bdcSChris Kirby int cleanup_fd, uint64_t *action_handlep) 1297efb80947Sahrens { 12983cb34c60Sahrens struct restorearg ra = { 0 }; 1299efb80947Sahrens dmu_replay_record_t *drr; 13003cb34c60Sahrens objset_t *os; 13013cb34c60Sahrens zio_cksum_t pcksum; 13029e69d7d0SLori Alt int featureflags; 1303efb80947Sahrens 13043cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1305efb80947Sahrens ra.byteswap = TRUE; 1306efb80947Sahrens 13073cb34c60Sahrens { 13083cb34c60Sahrens /* compute checksum of drr_begin record */ 13093cb34c60Sahrens dmu_replay_record_t *drr; 13103cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 13113cb34c60Sahrens 13123cb34c60Sahrens drr->drr_type = DRR_BEGIN; 13133cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 13143cb34c60Sahrens if (ra.byteswap) { 13153cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 13163cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 13173cb34c60Sahrens } else { 13183cb34c60Sahrens fletcher_4_incremental_native(drr, 13193cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 13203cb34c60Sahrens } 13213cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1322efb80947Sahrens } 1323efb80947Sahrens 1324efb80947Sahrens if (ra.byteswap) { 13253cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1326efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 13279e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1328efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1329efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1330efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1331efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1332efb80947Sahrens } 1333efb80947Sahrens 13343cb34c60Sahrens ra.vp = vp; 13353cb34c60Sahrens ra.voff = *voffp; 13363cb34c60Sahrens ra.bufsize = 1<<20; 13373cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1338efb80947Sahrens 13393cb34c60Sahrens /* these were verified in dmu_recv_begin */ 13409e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 13419e69d7d0SLori Alt DMU_SUBSTREAM); 13423cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1343efb80947Sahrens 1344efb80947Sahrens /* 1345efb80947Sahrens * Open the objset we are modifying. 1346efb80947Sahrens */ 1347503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1348efb80947Sahrens 13493cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1350efb80947Sahrens 13519e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 13529e69d7d0SLori Alt 13539e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 13549e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 1355*c99e4bdcSChris Kirby if (cleanup_fd == -1) { 1356*c99e4bdcSChris Kirby ra.err = EBADF; 1357*c99e4bdcSChris Kirby goto out; 1358*c99e4bdcSChris Kirby } 1359*c99e4bdcSChris Kirby if (*action_handlep == 0) { 1360*c99e4bdcSChris Kirby ra.guid_to_ds_map = 1361*c99e4bdcSChris Kirby kmem_alloc(sizeof (avl_tree_t), KM_SLEEP); 1362*c99e4bdcSChris Kirby avl_create(ra.guid_to_ds_map, guid_compare, 1363*c99e4bdcSChris Kirby sizeof (guid_map_entry_t), 1364*c99e4bdcSChris Kirby offsetof(guid_map_entry_t, avlnode)); 1365*c99e4bdcSChris Kirby (void) dmu_objset_find(drc->drc_top_ds, find_ds_by_guid, 1366*c99e4bdcSChris Kirby (void *)ra.guid_to_ds_map, 1367*c99e4bdcSChris Kirby DS_FIND_CHILDREN); 1368*c99e4bdcSChris Kirby ra.err = zfs_onexit_add_cb(cleanup_fd, 1369*c99e4bdcSChris Kirby free_guid_map_onexit, ra.guid_to_ds_map, 1370*c99e4bdcSChris Kirby action_handlep); 1371*c99e4bdcSChris Kirby if (ra.err) 1372*c99e4bdcSChris Kirby goto out; 1373*c99e4bdcSChris Kirby } else { 1374*c99e4bdcSChris Kirby ra.err = zfs_onexit_cb_data(cleanup_fd, *action_handlep, 1375*c99e4bdcSChris Kirby (void **)&ra.guid_to_ds_map); 1376*c99e4bdcSChris Kirby if (ra.err) 1377*c99e4bdcSChris Kirby goto out; 1378*c99e4bdcSChris Kirby } 13799e69d7d0SLori Alt } 13809e69d7d0SLori Alt 1381efb80947Sahrens /* 1382efb80947Sahrens * Read records and process them. 1383efb80947Sahrens */ 13843cb34c60Sahrens pcksum = ra.cksum; 1385efb80947Sahrens while (ra.err == 0 && 1386efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1387efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1388efb80947Sahrens ra.err = EINTR; 1389efb80947Sahrens goto out; 1390efb80947Sahrens } 1391efb80947Sahrens 1392efb80947Sahrens if (ra.byteswap) 1393efb80947Sahrens backup_byteswap(drr); 1394efb80947Sahrens 1395efb80947Sahrens switch (drr->drr_type) { 1396efb80947Sahrens case DRR_OBJECT: 1397efb80947Sahrens { 1398efb80947Sahrens /* 1399efb80947Sahrens * We need to make a copy of the record header, 1400efb80947Sahrens * because restore_{object,write} may need to 1401efb80947Sahrens * restore_read(), which will invalidate drr. 1402efb80947Sahrens */ 1403efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1404efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1405efb80947Sahrens break; 1406efb80947Sahrens } 1407efb80947Sahrens case DRR_FREEOBJECTS: 1408efb80947Sahrens { 1409efb80947Sahrens struct drr_freeobjects drrfo = 1410efb80947Sahrens drr->drr_u.drr_freeobjects; 1411efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1412efb80947Sahrens break; 1413efb80947Sahrens } 1414efb80947Sahrens case DRR_WRITE: 1415efb80947Sahrens { 1416efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1417efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1418efb80947Sahrens break; 1419efb80947Sahrens } 14209e69d7d0SLori Alt case DRR_WRITE_BYREF: 14219e69d7d0SLori Alt { 14229e69d7d0SLori Alt struct drr_write_byref drrwbr = 14239e69d7d0SLori Alt drr->drr_u.drr_write_byref; 14249e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 14259e69d7d0SLori Alt break; 14269e69d7d0SLori Alt } 1427efb80947Sahrens case DRR_FREE: 1428efb80947Sahrens { 1429efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1430efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1431efb80947Sahrens break; 1432efb80947Sahrens } 1433efb80947Sahrens case DRR_END: 1434efb80947Sahrens { 1435efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1436efb80947Sahrens /* 1437efb80947Sahrens * We compare against the *previous* checksum 1438efb80947Sahrens * value, because the stored checksum is of 1439efb80947Sahrens * everything before the DRR_END record. 1440efb80947Sahrens */ 1441137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1442efb80947Sahrens ra.err = ECKSUM; 1443efb80947Sahrens goto out; 1444efb80947Sahrens } 14450a586ceaSMark Shellenbaum case DRR_SPILL: 14460a586ceaSMark Shellenbaum { 14470a586ceaSMark Shellenbaum struct drr_spill drrs = drr->drr_u.drr_spill; 14480a586ceaSMark Shellenbaum ra.err = restore_spill(&ra, os, &drrs); 14490a586ceaSMark Shellenbaum break; 14500a586ceaSMark Shellenbaum } 1451efb80947Sahrens default: 1452efb80947Sahrens ra.err = EINVAL; 1453efb80947Sahrens goto out; 1454efb80947Sahrens } 14553cb34c60Sahrens pcksum = ra.cksum; 1456efb80947Sahrens } 1457137fa067Sahrens ASSERT(ra.err != 0); 1458efb80947Sahrens 1459efb80947Sahrens out: 14603cb34c60Sahrens if (ra.err != 0) { 1461efb80947Sahrens /* 1462f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1463f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1464efb80947Sahrens */ 14653cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1466f4b94bdeSMatthew Ahrens 1467842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1468842727c2SChris Kirby B_FALSE); 1469f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1470f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1471f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1472f4b94bdeSMatthew Ahrens } 1473efb80947Sahrens } 1474efb80947Sahrens 1475efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 14763cb34c60Sahrens *voffp = ra.voff; 1477efb80947Sahrens return (ra.err); 1478efb80947Sahrens } 1479f18faf3fSek 14803cb34c60Sahrens struct recvendsyncarg { 14813cb34c60Sahrens char *tosnap; 14823cb34c60Sahrens uint64_t creation_time; 14833cb34c60Sahrens uint64_t toguid; 14843cb34c60Sahrens }; 14853cb34c60Sahrens 14863cb34c60Sahrens static int 14873cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 14883cb34c60Sahrens { 14893cb34c60Sahrens dsl_dataset_t *ds = arg1; 14903cb34c60Sahrens struct recvendsyncarg *resa = arg2; 14913cb34c60Sahrens 14923cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 14933cb34c60Sahrens } 14943cb34c60Sahrens 14953cb34c60Sahrens static void 14963f9d6ad7SLin Ling recv_end_sync(void *arg1, void *arg2, dmu_tx_t *tx) 14973cb34c60Sahrens { 14983cb34c60Sahrens dsl_dataset_t *ds = arg1; 14993cb34c60Sahrens struct recvendsyncarg *resa = arg2; 15003cb34c60Sahrens 15013f9d6ad7SLin Ling dsl_dataset_snapshot_sync(ds, resa->tosnap, tx); 15023cb34c60Sahrens 15033cb34c60Sahrens /* set snapshot's creation time and guid */ 15043cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 15053cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 15063cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 15073cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 15083cb34c60Sahrens 15093cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 15103cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 15113cb34c60Sahrens } 15123cb34c60Sahrens 1513ae46e4c7SMatthew Ahrens static int 1514ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1515f18faf3fSek { 1516745cd3c5Smaybee struct recvendsyncarg resa; 1517745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 1518745cd3c5Smaybee int err; 1519f18faf3fSek 15203cb34c60Sahrens /* 1521ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1522ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1523ae46e4c7SMatthew Ahrens * can close it. 15243cb34c60Sahrens */ 1525745cd3c5Smaybee txg_wait_synced(ds->ds_dir->dd_pool, 0); 15263cb34c60Sahrens 1527ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1528ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1529ae46e4c7SMatthew Ahrens drc->drc_force); 1530ae46e4c7SMatthew Ahrens if (err) 1531ae46e4c7SMatthew Ahrens goto out; 1532ae46e4c7SMatthew Ahrens } else { 1533ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1534ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1535842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1536842727c2SChris Kirby B_FALSE); 1537ae46e4c7SMatthew Ahrens return (EBUSY); 15383cb34c60Sahrens } 15393cb34c60Sahrens 1540745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1541745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1542745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 15433cb34c60Sahrens 1544745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1545745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1546745cd3c5Smaybee if (err) { 1547ae46e4c7SMatthew Ahrens /* swap back */ 1548ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 15493cb34c60Sahrens } 15503cb34c60Sahrens 1551ae46e4c7SMatthew Ahrens out: 1552ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1553745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 1554ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 1555f18faf3fSek return (err); 1556f18faf3fSek } 1557ae46e4c7SMatthew Ahrens 1558ae46e4c7SMatthew Ahrens static int 1559ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1560ae46e4c7SMatthew Ahrens { 1561ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1562ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1563ae46e4c7SMatthew Ahrens int err; 1564ae46e4c7SMatthew Ahrens 1565ae46e4c7SMatthew Ahrens /* 1566ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1567ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1568ae46e4c7SMatthew Ahrens * can close it. 1569ae46e4c7SMatthew Ahrens */ 1570ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1571ae46e4c7SMatthew Ahrens 1572ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1573ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1574ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1575ae46e4c7SMatthew Ahrens 1576ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1577ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1578ae46e4c7SMatthew Ahrens if (err) { 1579ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1580ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1581ae46e4c7SMatthew Ahrens } else { 1582ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1583ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1584ae46e4c7SMatthew Ahrens } 1585ae46e4c7SMatthew Ahrens return (err); 1586ae46e4c7SMatthew Ahrens } 1587ae46e4c7SMatthew Ahrens 1588ae46e4c7SMatthew Ahrens int 1589ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1590ae46e4c7SMatthew Ahrens { 1591ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1592ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1593ae46e4c7SMatthew Ahrens else 1594ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1595ae46e4c7SMatthew Ahrens } 1596