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 /* 22da03de99SMark Maybee * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23efb80947Sahrens * Use is subject to license terms. 24efb80947Sahrens */ 25efb80947Sahrens 26efb80947Sahrens #include <sys/dmu.h> 27efb80947Sahrens #include <sys/dmu_impl.h> 28efb80947Sahrens #include <sys/dmu_tx.h> 29efb80947Sahrens #include <sys/dbuf.h> 30efb80947Sahrens #include <sys/dnode.h> 31efb80947Sahrens #include <sys/zfs_context.h> 32efb80947Sahrens #include <sys/dmu_objset.h> 33efb80947Sahrens #include <sys/dmu_traverse.h> 34efb80947Sahrens #include <sys/dsl_dataset.h> 35efb80947Sahrens #include <sys/dsl_dir.h> 3692241e0bSTom Erickson #include <sys/dsl_prop.h> 37efb80947Sahrens #include <sys/dsl_pool.h> 38efb80947Sahrens #include <sys/dsl_synctask.h> 39efb80947Sahrens #include <sys/zfs_ioctl.h> 40efb80947Sahrens #include <sys/zap.h> 41efb80947Sahrens #include <sys/zio_checksum.h> 429e69d7d0SLori Alt #include <sys/avl.h> 43*8e714474SLori Alt #include <sys/ddt.h> 44efb80947Sahrens 453cb34c60Sahrens static char *dmu_recv_tag = "dmu_recv_tag"; 463cb34c60Sahrens 479e69d7d0SLori Alt /* 489e69d7d0SLori Alt * The list of data whose inclusion in a send stream can be pending from 499e69d7d0SLori Alt * one call to backup_cb to another. Multiple calls to dump_free() and 509e69d7d0SLori Alt * dump_freeobjects() can be aggregated into a single DRR_FREE or 519e69d7d0SLori Alt * DRR_FREEOBJECTS replay record. 529e69d7d0SLori Alt */ 539e69d7d0SLori Alt typedef enum { 549e69d7d0SLori Alt PENDING_NONE, 559e69d7d0SLori Alt PENDING_FREE, 569e69d7d0SLori Alt PENDING_FREEOBJECTS 579e69d7d0SLori Alt } pendop_t; 589e69d7d0SLori Alt 59efb80947Sahrens struct backuparg { 60efb80947Sahrens dmu_replay_record_t *drr; 61efb80947Sahrens vnode_t *vp; 623cb34c60Sahrens offset_t *off; 63efb80947Sahrens objset_t *os; 64efb80947Sahrens zio_cksum_t zc; 659e69d7d0SLori Alt uint64_t toguid; 66efb80947Sahrens int err; 679e69d7d0SLori Alt pendop_t pending_op; 68efb80947Sahrens }; 69efb80947Sahrens 70efb80947Sahrens static int 71efb80947Sahrens dump_bytes(struct backuparg *ba, void *buf, int len) 72efb80947Sahrens { 73efb80947Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 74efb80947Sahrens ASSERT3U(len % 8, ==, 0); 75efb80947Sahrens 76efb80947Sahrens fletcher_4_incremental_native(buf, len, &ba->zc); 77efb80947Sahrens ba->err = vn_rdwr(UIO_WRITE, ba->vp, 78efb80947Sahrens (caddr_t)buf, len, 79efb80947Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 803cb34c60Sahrens *ba->off += len; 81efb80947Sahrens return (ba->err); 82efb80947Sahrens } 83efb80947Sahrens 84efb80947Sahrens static int 85efb80947Sahrens dump_free(struct backuparg *ba, uint64_t object, uint64_t offset, 86efb80947Sahrens uint64_t length) 87efb80947Sahrens { 889e69d7d0SLori Alt struct drr_free *drrf = &(ba->drr->drr_u.drr_free); 899e69d7d0SLori Alt 909e69d7d0SLori Alt /* 919e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 929e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 939e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 949e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 959e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 969e69d7d0SLori Alt */ 979e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && ba->pending_op != PENDING_FREE) { 989e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 999e69d7d0SLori Alt return (EINTR); 1009e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1019e69d7d0SLori Alt } 1029e69d7d0SLori Alt 1039e69d7d0SLori Alt if (ba->pending_op == PENDING_FREE) { 1049e69d7d0SLori Alt /* 1059e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 1069e69d7d0SLori Alt * (because dump_dnode is the only place where this 1079e69d7d0SLori Alt * function is called with a -1, and only after flushing 1089e69d7d0SLori Alt * any pending record). 1099e69d7d0SLori Alt */ 1109e69d7d0SLori Alt ASSERT(length != -1ULL); 1119e69d7d0SLori Alt /* 1129e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1139e69d7d0SLori Alt * with pending one. 1149e69d7d0SLori Alt */ 1159e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1169e69d7d0SLori Alt drrf->drr_length == offset) { 1179e69d7d0SLori Alt drrf->drr_length += length; 1189e69d7d0SLori Alt return (0); 1199e69d7d0SLori Alt } else { 1209e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1219e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 1229e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1239e69d7d0SLori Alt return (EINTR); 1249e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1259e69d7d0SLori Alt } 1269e69d7d0SLori Alt } 1279e69d7d0SLori Alt /* create a FREE record and make it pending */ 128efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 129efb80947Sahrens ba->drr->drr_type = DRR_FREE; 1309e69d7d0SLori Alt drrf->drr_object = object; 1319e69d7d0SLori Alt drrf->drr_offset = offset; 1329e69d7d0SLori Alt drrf->drr_length = length; 1339e69d7d0SLori Alt drrf->drr_toguid = ba->toguid; 1349e69d7d0SLori Alt if (length == -1ULL) { 1359e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1369e69d7d0SLori Alt return (EINTR); 1379e69d7d0SLori Alt } else { 1389e69d7d0SLori Alt ba->pending_op = PENDING_FREE; 1399e69d7d0SLori Alt } 140efb80947Sahrens 141efb80947Sahrens return (0); 142efb80947Sahrens } 143efb80947Sahrens 144efb80947Sahrens static int 145efb80947Sahrens dump_data(struct backuparg *ba, dmu_object_type_t type, 146*8e714474SLori Alt uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data) 147efb80947Sahrens { 1489e69d7d0SLori Alt struct drr_write *drrw = &(ba->drr->drr_u.drr_write); 1499e69d7d0SLori Alt 150*8e714474SLori Alt 1519e69d7d0SLori Alt /* 1529e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1539e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1549e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1559e69d7d0SLori Alt * of different types. 1569e69d7d0SLori Alt */ 1579e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 1589e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1599e69d7d0SLori Alt return (EINTR); 1609e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1619e69d7d0SLori Alt } 162efb80947Sahrens /* write a DATA record */ 163efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 164efb80947Sahrens ba->drr->drr_type = DRR_WRITE; 1659e69d7d0SLori Alt drrw->drr_object = object; 1669e69d7d0SLori Alt drrw->drr_type = type; 1679e69d7d0SLori Alt drrw->drr_offset = offset; 1689e69d7d0SLori Alt drrw->drr_length = blksz; 1699e69d7d0SLori Alt drrw->drr_toguid = ba->toguid; 170*8e714474SLori Alt drrw->drr_checksumtype = BP_GET_CHECKSUM(bp); 171*8e714474SLori Alt if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup) 172*8e714474SLori Alt drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP; 173*8e714474SLori Alt DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp)); 174*8e714474SLori Alt DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp)); 175*8e714474SLori Alt DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp)); 176*8e714474SLori Alt drrw->drr_key.ddk_cksum = bp->blk_cksum; 177efb80947Sahrens 1789e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 179efb80947Sahrens return (EINTR); 1809e69d7d0SLori Alt if (dump_bytes(ba, data, blksz) != 0) 181efb80947Sahrens return (EINTR); 182efb80947Sahrens return (0); 183efb80947Sahrens } 184efb80947Sahrens 185efb80947Sahrens static int 186efb80947Sahrens dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs) 187efb80947Sahrens { 1889e69d7d0SLori Alt struct drr_freeobjects *drrfo = &(ba->drr->drr_u.drr_freeobjects); 1899e69d7d0SLori Alt 1909e69d7d0SLori Alt /* 1919e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 1929e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 1939e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 1949e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 1959e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 1969e69d7d0SLori Alt */ 1979e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && 1989e69d7d0SLori Alt ba->pending_op != PENDING_FREEOBJECTS) { 1999e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2009e69d7d0SLori Alt return (EINTR); 2019e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2029e69d7d0SLori Alt } 2039e69d7d0SLori Alt if (ba->pending_op == PENDING_FREEOBJECTS) { 2049e69d7d0SLori Alt /* 2059e69d7d0SLori Alt * See whether this free object array can be aggregated 2069e69d7d0SLori Alt * with pending one 2079e69d7d0SLori Alt */ 2089e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2099e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2109e69d7d0SLori Alt return (0); 2119e69d7d0SLori Alt } else { 2129e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2139e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 2149e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2159e69d7d0SLori Alt return (EINTR); 2169e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2179e69d7d0SLori Alt } 2189e69d7d0SLori Alt } 2199e69d7d0SLori Alt 220efb80947Sahrens /* write a FREEOBJECTS record */ 221efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 222efb80947Sahrens ba->drr->drr_type = DRR_FREEOBJECTS; 2239e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2249e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2259e69d7d0SLori Alt drrfo->drr_toguid = ba->toguid; 2269e69d7d0SLori Alt 2279e69d7d0SLori Alt ba->pending_op = PENDING_FREEOBJECTS; 228efb80947Sahrens 229efb80947Sahrens return (0); 230efb80947Sahrens } 231efb80947Sahrens 232efb80947Sahrens static int 233efb80947Sahrens dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp) 234efb80947Sahrens { 2359e69d7d0SLori Alt struct drr_object *drro = &(ba->drr->drr_u.drr_object); 2369e69d7d0SLori Alt 237efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 238efb80947Sahrens return (dump_freeobjects(ba, object, 1)); 239efb80947Sahrens 2409e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 2419e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2429e69d7d0SLori Alt return (EINTR); 2439e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2449e69d7d0SLori Alt } 2459e69d7d0SLori Alt 246efb80947Sahrens /* write an OBJECT record */ 247efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 248efb80947Sahrens ba->drr->drr_type = DRR_OBJECT; 2499e69d7d0SLori Alt drro->drr_object = object; 2509e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2519e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2529e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2539e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2549e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2559e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2569e69d7d0SLori Alt drro->drr_toguid = ba->toguid; 2579e69d7d0SLori Alt 2589e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 259efb80947Sahrens return (EINTR); 260efb80947Sahrens 2619e69d7d0SLori Alt if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 262efb80947Sahrens return (EINTR); 263efb80947Sahrens 264efb80947Sahrens /* free anything past the end of the file */ 265efb80947Sahrens if (dump_free(ba, object, (dnp->dn_maxblkid + 1) * 266efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 267efb80947Sahrens return (EINTR); 268efb80947Sahrens if (ba->err) 269efb80947Sahrens return (EINTR); 270efb80947Sahrens return (0); 271efb80947Sahrens } 272efb80947Sahrens 273efb80947Sahrens #define BP_SPAN(dnp, level) \ 274efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 275efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 276efb80947Sahrens 277b24ab676SJeff Bonwick /* ARGSUSED */ 278efb80947Sahrens static int 279b24ab676SJeff Bonwick backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 280b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 281efb80947Sahrens { 282efb80947Sahrens struct backuparg *ba = arg; 283efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 284efb80947Sahrens int err = 0; 285efb80947Sahrens 286efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 287efb80947Sahrens return (EINTR); 288efb80947Sahrens 289b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 290b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 29114843421SMatthew Ahrens return (0); 292b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 29388b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 29488b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 295efb80947Sahrens err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT); 296efb80947Sahrens } else if (bp == NULL) { 29788b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 29888b7b0f2SMatthew Ahrens err = dump_free(ba, zb->zb_object, zb->zb_blkid * span, span); 29988b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 30088b7b0f2SMatthew Ahrens return (0); 30188b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 30288b7b0f2SMatthew Ahrens dnode_phys_t *blk; 303efb80947Sahrens int i; 304efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 30588b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 30688b7b0f2SMatthew Ahrens arc_buf_t *abuf; 307efb80947Sahrens 30888b7b0f2SMatthew Ahrens if (arc_read_nolock(NULL, spa, bp, 30988b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 31088b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 31188b7b0f2SMatthew Ahrens return (EIO); 31288b7b0f2SMatthew Ahrens 31388b7b0f2SMatthew Ahrens blk = abuf->b_data; 314efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 31588b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 31688b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 317efb80947Sahrens err = dump_dnode(ba, dnobj, blk+i); 318efb80947Sahrens if (err) 319efb80947Sahrens break; 320efb80947Sahrens } 32188b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 32288b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 32388b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 32488b7b0f2SMatthew Ahrens arc_buf_t *abuf; 325efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 32688b7b0f2SMatthew Ahrens 32788b7b0f2SMatthew Ahrens if (arc_read_nolock(NULL, spa, bp, 32888b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 32988b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 33088b7b0f2SMatthew Ahrens return (EIO); 33188b7b0f2SMatthew Ahrens 33288b7b0f2SMatthew Ahrens err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz, 333*8e714474SLori Alt blksz, bp, abuf->b_data); 33488b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 335efb80947Sahrens } 336efb80947Sahrens 337efb80947Sahrens ASSERT(err == 0 || err == EINTR); 338efb80947Sahrens return (err); 339efb80947Sahrens } 340efb80947Sahrens 341efb80947Sahrens int 3423cb34c60Sahrens dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 3433cb34c60Sahrens vnode_t *vp, offset_t *off) 344efb80947Sahrens { 345503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 346503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 347efb80947Sahrens dmu_replay_record_t *drr; 348efb80947Sahrens struct backuparg ba; 349efb80947Sahrens int err; 3503cb34c60Sahrens uint64_t fromtxg = 0; 351efb80947Sahrens 352efb80947Sahrens /* tosnap must be a snapshot */ 353efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 354efb80947Sahrens return (EINVAL); 355efb80947Sahrens 356efb80947Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 357efb80947Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 3583cb34c60Sahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 359efb80947Sahrens return (EXDEV); 360efb80947Sahrens 3613cb34c60Sahrens if (fromorigin) { 362088f3894Sahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 363088f3894Sahrens 3643cb34c60Sahrens if (fromsnap) 3653cb34c60Sahrens return (EINVAL); 3663cb34c60Sahrens 367088f3894Sahrens if (dsl_dir_is_clone(ds->ds_dir)) { 3683cb34c60Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 369745cd3c5Smaybee err = dsl_dataset_hold_obj(dp, 370745cd3c5Smaybee ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 3713cb34c60Sahrens rw_exit(&dp->dp_config_rwlock); 3723cb34c60Sahrens if (err) 3733cb34c60Sahrens return (err); 3743cb34c60Sahrens } else { 3753cb34c60Sahrens fromorigin = B_FALSE; 3763cb34c60Sahrens } 3773cb34c60Sahrens } 3783cb34c60Sahrens 3793cb34c60Sahrens 380efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 381efb80947Sahrens drr->drr_type = DRR_BEGIN; 382efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 3839e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 3849e69d7d0SLori Alt DMU_SUBSTREAM); 385efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 386efb80947Sahrens ds->ds_phys->ds_creation_time; 387503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 3883cb34c60Sahrens if (fromorigin) 3893cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 390efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 391ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 392ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 393ab04eb8eStimh 394efb80947Sahrens if (fromds) 395efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 396efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 397efb80947Sahrens 3983cb34c60Sahrens if (fromds) 3993cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 4003cb34c60Sahrens if (fromorigin) 401745cd3c5Smaybee dsl_dataset_rele(fromds, FTAG); 4023cb34c60Sahrens 403efb80947Sahrens ba.drr = drr; 404efb80947Sahrens ba.vp = vp; 405efb80947Sahrens ba.os = tosnap; 4063cb34c60Sahrens ba.off = off; 4079e69d7d0SLori Alt ba.toguid = ds->ds_phys->ds_guid; 408efb80947Sahrens ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0); 4099e69d7d0SLori Alt ba.pending_op = PENDING_NONE; 410efb80947Sahrens 4119e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 412efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 413efb80947Sahrens return (ba.err); 414efb80947Sahrens } 415efb80947Sahrens 41688b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 417efb80947Sahrens backup_cb, &ba); 418efb80947Sahrens 4199e69d7d0SLori Alt if (ba.pending_op != PENDING_NONE) 4209e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) 4219e69d7d0SLori Alt err = EINTR; 4229e69d7d0SLori Alt 423efb80947Sahrens if (err) { 424efb80947Sahrens if (err == EINTR && ba.err) 425efb80947Sahrens err = ba.err; 4267b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 427efb80947Sahrens return (err); 428efb80947Sahrens } 429efb80947Sahrens 430efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 431efb80947Sahrens drr->drr_type = DRR_END; 432efb80947Sahrens drr->drr_u.drr_end.drr_checksum = ba.zc; 4339e69d7d0SLori Alt drr->drr_u.drr_end.drr_toguid = ba.toguid; 434efb80947Sahrens 4359e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 4367b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 437efb80947Sahrens return (ba.err); 4387b5309bbSgw } 439efb80947Sahrens 440efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 441efb80947Sahrens 442efb80947Sahrens return (0); 443efb80947Sahrens } 444efb80947Sahrens 4453cb34c60Sahrens struct recvbeginsyncarg { 4463cb34c60Sahrens const char *tofs; 4473cb34c60Sahrens const char *tosnap; 4483cb34c60Sahrens dsl_dataset_t *origin; 4493cb34c60Sahrens uint64_t fromguid; 4503cb34c60Sahrens dmu_objset_type_t type; 4513cb34c60Sahrens void *tag; 4523cb34c60Sahrens boolean_t force; 453ab04eb8eStimh uint64_t dsflags; 4543cb34c60Sahrens char clonelastname[MAXNAMELEN]; 4553cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 456efb80947Sahrens }; 457efb80947Sahrens 458efb80947Sahrens /* ARGSUSED */ 459efb80947Sahrens static int 460ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 461efb80947Sahrens { 462efb80947Sahrens dsl_dir_t *dd = arg1; 4633cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 464efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 465efb80947Sahrens uint64_t val; 466efb80947Sahrens int err; 467efb80947Sahrens 468efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 4693cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 470efb80947Sahrens 471efb80947Sahrens if (err != ENOENT) 472efb80947Sahrens return (err ? err : EEXIST); 473efb80947Sahrens 4743cb34c60Sahrens if (rbsa->origin) { 4753cb34c60Sahrens /* make sure it's a snap in the same pool */ 4763cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 4773cb34c60Sahrens return (EXDEV); 478ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 4793cb34c60Sahrens return (EINVAL); 4803cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 4813cb34c60Sahrens return (ENODEV); 4823cb34c60Sahrens } 4833cb34c60Sahrens 484efb80947Sahrens return (0); 485efb80947Sahrens } 486efb80947Sahrens 487efb80947Sahrens static void 488ae46e4c7SMatthew Ahrens recv_new_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 489efb80947Sahrens { 490efb80947Sahrens dsl_dir_t *dd = arg1; 4913cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 492745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 493efb80947Sahrens uint64_t dsobj; 494efb80947Sahrens 495ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 4963cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 497ab04eb8eStimh rbsa->origin, flags, cr, tx); 498ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 499503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 500efb80947Sahrens 501ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 502ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 503ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 5043cb34c60Sahrens } 505ecd6cf80Smarks 506ae46e4c7SMatthew Ahrens spa_history_internal_log(LOG_DS_REPLAY_FULL_SYNC, 507ae46e4c7SMatthew Ahrens dd->dd_pool->dp_spa, tx, cr, "dataset = %lld", dsobj); 5083cb34c60Sahrens } 509f18faf3fSek 510f18faf3fSek /* ARGSUSED */ 511f18faf3fSek static int 512ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 513f18faf3fSek { 5143cb34c60Sahrens dsl_dataset_t *ds = arg1; 5153cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5163cb34c60Sahrens int err; 5173cb34c60Sahrens uint64_t val; 518f18faf3fSek 5193cb34c60Sahrens /* must not have any changes since most recent snapshot */ 5203cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 521f18faf3fSek return (ETXTBSY); 522f18faf3fSek 523ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 524ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 525ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 526ae46e4c7SMatthew Ahrens return (ENODEV); 52792241e0bSTom Erickson 52892241e0bSTom Erickson /* 52992241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 53092241e0bSTom Erickson * changes since the fromguid one 53192241e0bSTom Erickson */ 53292241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 53392241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 53492241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 53592241e0bSTom Erickson while (obj != 0) { 53692241e0bSTom Erickson dsl_dataset_t *snap; 53792241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 53892241e0bSTom Erickson obj, FTAG, &snap); 53992241e0bSTom Erickson if (err) 54092241e0bSTom Erickson return (ENODEV); 54192241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 54292241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 54392241e0bSTom Erickson return (ENODEV); 54492241e0bSTom Erickson } 54592241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 54692241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 54792241e0bSTom Erickson break; /* it's ok */ 54892241e0bSTom Erickson } 54992241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 55092241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 55192241e0bSTom Erickson } 55292241e0bSTom Erickson if (obj == 0) 55392241e0bSTom Erickson return (ENODEV); 55492241e0bSTom Erickson } 555ae46e4c7SMatthew Ahrens } else { 556ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 557ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 558ae46e4c7SMatthew Ahrens return (ENODEV); 559ae46e4c7SMatthew Ahrens } 5603cb34c60Sahrens 56147f263f4Sek /* temporary clone name must not exist */ 56247f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 56347f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 56447f263f4Sek rbsa->clonelastname, 8, 1, &val); 56547f263f4Sek if (err == 0) 56647f263f4Sek return (EEXIST); 56747f263f4Sek if (err != ENOENT) 56847f263f4Sek return (err); 56947f263f4Sek 5703cb34c60Sahrens /* new snapshot name must not exist */ 5713cb34c60Sahrens err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 5723cb34c60Sahrens ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 5733cb34c60Sahrens if (err == 0) 5743cb34c60Sahrens return (EEXIST); 5753cb34c60Sahrens if (err != ENOENT) 5763cb34c60Sahrens return (err); 5773cb34c60Sahrens return (0); 578f18faf3fSek } 579f18faf3fSek 580f18faf3fSek /* ARGSUSED */ 581f18faf3fSek static void 582ae46e4c7SMatthew Ahrens recv_existing_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 583f18faf3fSek { 5843cb34c60Sahrens dsl_dataset_t *ohds = arg1; 5853cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5863cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 587ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 588745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 589f18faf3fSek uint64_t dsobj; 590f18faf3fSek 591ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 592ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 593ae46e4c7SMatthew Ahrens ohds->ds_prev, flags, cr, tx); 594503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 5953cb34c60Sahrens 596ae46e4c7SMatthew Ahrens /* 597ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 598ae46e4c7SMatthew Ahrens * objset in our new dataset. 599ae46e4c7SMatthew Ahrens */ 600ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 601ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 602ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 603ae46e4c7SMatthew Ahrens } 604ae46e4c7SMatthew Ahrens 6053cb34c60Sahrens rbsa->ds = cds; 6063cb34c60Sahrens 6073cb34c60Sahrens spa_history_internal_log(LOG_DS_REPLAY_INC_SYNC, 608745cd3c5Smaybee dp->dp_spa, tx, cr, "dataset = %lld", dsobj); 6093cb34c60Sahrens } 6103cb34c60Sahrens 6113cb34c60Sahrens /* 6123cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 6133cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 6143cb34c60Sahrens */ 6153cb34c60Sahrens int 6169e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 617f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 618efb80947Sahrens { 6193cb34c60Sahrens int err = 0; 6203cb34c60Sahrens boolean_t byteswap; 621ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 6229e69d7d0SLori Alt uint64_t versioninfo; 6233cb34c60Sahrens int flags; 6243cb34c60Sahrens dsl_dataset_t *ds; 625efb80947Sahrens 6263cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 6273cb34c60Sahrens byteswap = FALSE; 6283cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 6293cb34c60Sahrens byteswap = TRUE; 6303cb34c60Sahrens else 6313cb34c60Sahrens return (EINVAL); 6323cb34c60Sahrens 6333cb34c60Sahrens rbsa.tofs = tofs; 6343cb34c60Sahrens rbsa.tosnap = tosnap; 635503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 6363cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 6373cb34c60Sahrens rbsa.type = drrb->drr_type; 6383cb34c60Sahrens rbsa.tag = FTAG; 639ab04eb8eStimh rbsa.dsflags = 0; 6409e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 6413cb34c60Sahrens flags = drrb->drr_flags; 6423cb34c60Sahrens 6433cb34c60Sahrens if (byteswap) { 6443cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 6453cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 6469e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 6473cb34c60Sahrens flags = BSWAP_32(flags); 6483cb34c60Sahrens } 649efb80947Sahrens 6509e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 6513cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 6523cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 653efb80947Sahrens return (EINVAL); 654efb80947Sahrens 655ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 656ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 657ab04eb8eStimh 6583cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 6593cb34c60Sahrens drc->drc_drrb = drrb; 6603cb34c60Sahrens drc->drc_tosnap = tosnap; 6619e69d7d0SLori Alt drc->drc_top_ds = top_ds; 6623cb34c60Sahrens drc->drc_force = force; 663efb80947Sahrens 6643cb34c60Sahrens /* 6653cb34c60Sahrens * Process the begin in syncing context. 6663cb34c60Sahrens */ 667efb80947Sahrens 668ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 669ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 670ae46e4c7SMatthew Ahrens if (err == 0) { 671ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 672efb80947Sahrens 673ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 674ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 675ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 676ae46e4c7SMatthew Ahrens return (EINVAL); 677ae46e4c7SMatthew Ahrens } 678efb80947Sahrens 679f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 680f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 681f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 682f4b94bdeSMatthew Ahrens return (EBUSY); 683f4b94bdeSMatthew Ahrens } 684f4b94bdeSMatthew Ahrens 685ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 686ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 687ae46e4c7SMatthew Ahrens "%%%s", tosnap); 6883cb34c60Sahrens rbsa.force = force; 6893cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 690ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 6913cb34c60Sahrens if (err) { 692f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 693745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 6943cb34c60Sahrens return (err); 6953cb34c60Sahrens } 6963cb34c60Sahrens drc->drc_logical_ds = ds; 6973cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 698ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 699ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 700ae46e4c7SMatthew Ahrens char *cp; 701efb80947Sahrens 702ae46e4c7SMatthew Ahrens /* 703ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 704ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 705ae46e4c7SMatthew Ahrens */ 706ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 707ae46e4c7SMatthew Ahrens return (ENOENT); 708ae46e4c7SMatthew Ahrens 709ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 710ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 711ae46e4c7SMatthew Ahrens *cp = '\0'; 712bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 713ae46e4c7SMatthew Ahrens *cp = '/'; 7143cb34c60Sahrens if (err) 7153cb34c60Sahrens return (err); 716efb80947Sahrens 717ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 718ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 719bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 7203cb34c60Sahrens if (err) 7213cb34c60Sahrens return (err); 7223cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 7233cb34c60Sahrens drc->drc_newfs = B_TRUE; 7243cb34c60Sahrens } 7253cb34c60Sahrens 726ae46e4c7SMatthew Ahrens return (err); 727efb80947Sahrens } 728efb80947Sahrens 7293cb34c60Sahrens struct restorearg { 7303cb34c60Sahrens int err; 7313cb34c60Sahrens int byteswap; 7323cb34c60Sahrens vnode_t *vp; 7333cb34c60Sahrens char *buf; 7343cb34c60Sahrens uint64_t voff; 7353cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 7363cb34c60Sahrens zio_cksum_t cksum; 7379e69d7d0SLori Alt avl_tree_t guid_to_ds_map; 7383cb34c60Sahrens }; 7393cb34c60Sahrens 7409e69d7d0SLori Alt typedef struct guid_map_entry { 7419e69d7d0SLori Alt uint64_t guid; 7429e69d7d0SLori Alt dsl_dataset_t *gme_ds; 7439e69d7d0SLori Alt avl_node_t avlnode; 7449e69d7d0SLori Alt } guid_map_entry_t; 7459e69d7d0SLori Alt 7469e69d7d0SLori Alt static int 7479e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 7489e69d7d0SLori Alt { 7499e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 7509e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 7519e69d7d0SLori Alt 7529e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 7539e69d7d0SLori Alt return (-1); 7549e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 7559e69d7d0SLori Alt return (1); 7569e69d7d0SLori Alt return (0); 7579e69d7d0SLori Alt } 7589e69d7d0SLori Alt 7599e69d7d0SLori Alt /* 7609e69d7d0SLori Alt * This function is a callback used by dmu_objset_find() (which 7619e69d7d0SLori Alt * enumerates the object sets) to build an avl tree that maps guids 7629e69d7d0SLori Alt * to datasets. The resulting table is used when processing DRR_WRITE_BYREF 7639e69d7d0SLori Alt * send stream records. These records, which are used in dedup'ed 7649e69d7d0SLori Alt * streams, do not contain data themselves, but refer to a copy 7659e69d7d0SLori Alt * of the data block that has already been written because it was 7669e69d7d0SLori Alt * earlier in the stream. That previous copy is identified by the 7679e69d7d0SLori Alt * guid of the dataset with the referenced data. 7689e69d7d0SLori Alt */ 7699e69d7d0SLori Alt int 770fd136879SMatthew Ahrens find_ds_by_guid(const char *name, void *arg) 7719e69d7d0SLori Alt { 7729e69d7d0SLori Alt avl_tree_t *guid_map = arg; 773fd136879SMatthew Ahrens dsl_dataset_t *ds, *snapds; 7749e69d7d0SLori Alt guid_map_entry_t *gmep; 775fd136879SMatthew Ahrens dsl_pool_t *dp; 7769e69d7d0SLori Alt int err; 7779e69d7d0SLori Alt uint64_t lastobj, firstobj; 7789e69d7d0SLori Alt 7799e69d7d0SLori Alt if (dsl_dataset_hold(name, FTAG, &ds) != 0) 7809e69d7d0SLori Alt return (0); 7819e69d7d0SLori Alt 7829e69d7d0SLori Alt dp = ds->ds_dir->dd_pool; 7839e69d7d0SLori Alt rw_enter(&dp->dp_config_rwlock, RW_READER); 7849e69d7d0SLori Alt firstobj = ds->ds_dir->dd_phys->dd_origin_obj; 7859e69d7d0SLori Alt lastobj = ds->ds_phys->ds_prev_snap_obj; 7869e69d7d0SLori Alt 7879e69d7d0SLori Alt while (lastobj != firstobj) { 7889e69d7d0SLori Alt err = dsl_dataset_hold_obj(dp, lastobj, guid_map, &snapds); 7899e69d7d0SLori Alt if (err) { 7909e69d7d0SLori Alt /* 7919e69d7d0SLori Alt * Skip this snapshot and move on. It's not 7929e69d7d0SLori Alt * clear why this would ever happen, but the 7939e69d7d0SLori Alt * remainder of the snapshot streadm can be 7949e69d7d0SLori Alt * processed. 7959e69d7d0SLori Alt */ 7969e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 7979e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 7989e69d7d0SLori Alt return (0); 7999e69d7d0SLori Alt } 8009e69d7d0SLori Alt 8019e69d7d0SLori Alt gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 8029e69d7d0SLori Alt gmep->guid = snapds->ds_phys->ds_guid; 8039e69d7d0SLori Alt gmep->gme_ds = snapds; 8049e69d7d0SLori Alt avl_add(guid_map, gmep); 8059e69d7d0SLori Alt lastobj = snapds->ds_phys->ds_prev_snap_obj; 8069e69d7d0SLori Alt } 8079e69d7d0SLori Alt 8089e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 8099e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 8109e69d7d0SLori Alt 8119e69d7d0SLori Alt return (0); 8129e69d7d0SLori Alt } 8139e69d7d0SLori Alt 814efb80947Sahrens static void * 815efb80947Sahrens restore_read(struct restorearg *ra, int len) 816efb80947Sahrens { 817efb80947Sahrens void *rv; 8183cb34c60Sahrens int done = 0; 819efb80947Sahrens 820efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 821efb80947Sahrens ASSERT3U(len % 8, ==, 0); 822efb80947Sahrens 8233cb34c60Sahrens while (done < len) { 824efb80947Sahrens ssize_t resid; 825efb80947Sahrens 826efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 8273cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 828efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 829efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 830efb80947Sahrens 8313cb34c60Sahrens if (resid == len - done) 832efb80947Sahrens ra->err = EINVAL; 8333cb34c60Sahrens ra->voff += len - done - resid; 8343cb34c60Sahrens done = len - resid; 835efb80947Sahrens if (ra->err) 836efb80947Sahrens return (NULL); 837efb80947Sahrens } 838efb80947Sahrens 8393cb34c60Sahrens ASSERT3U(done, ==, len); 8403cb34c60Sahrens rv = ra->buf; 841efb80947Sahrens if (ra->byteswap) 8423cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 843efb80947Sahrens else 8443cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 845efb80947Sahrens return (rv); 846efb80947Sahrens } 847efb80947Sahrens 848efb80947Sahrens static void 849efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 850efb80947Sahrens { 851efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 852efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 853efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 8543cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 855efb80947Sahrens switch (drr->drr_type) { 856efb80947Sahrens case DRR_BEGIN: 857efb80947Sahrens DO64(drr_begin.drr_magic); 8589e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 859efb80947Sahrens DO64(drr_begin.drr_creation_time); 860efb80947Sahrens DO32(drr_begin.drr_type); 8613cb34c60Sahrens DO32(drr_begin.drr_flags); 862efb80947Sahrens DO64(drr_begin.drr_toguid); 863efb80947Sahrens DO64(drr_begin.drr_fromguid); 864efb80947Sahrens break; 865efb80947Sahrens case DRR_OBJECT: 866efb80947Sahrens DO64(drr_object.drr_object); 867efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 868efb80947Sahrens DO32(drr_object.drr_type); 869efb80947Sahrens DO32(drr_object.drr_bonustype); 870efb80947Sahrens DO32(drr_object.drr_blksz); 871efb80947Sahrens DO32(drr_object.drr_bonuslen); 8729e69d7d0SLori Alt DO64(drr_object.drr_toguid); 873efb80947Sahrens break; 874efb80947Sahrens case DRR_FREEOBJECTS: 875efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 876efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 8779e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 878efb80947Sahrens break; 879efb80947Sahrens case DRR_WRITE: 880efb80947Sahrens DO64(drr_write.drr_object); 881efb80947Sahrens DO32(drr_write.drr_type); 882efb80947Sahrens DO64(drr_write.drr_offset); 883efb80947Sahrens DO64(drr_write.drr_length); 8849e69d7d0SLori Alt DO64(drr_write.drr_toguid); 885*8e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[0]); 886*8e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[1]); 887*8e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[2]); 888*8e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[3]); 889*8e714474SLori Alt DO64(drr_write.drr_key.ddk_prop); 8909e69d7d0SLori Alt break; 8919e69d7d0SLori Alt case DRR_WRITE_BYREF: 8929e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 8939e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 8949e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 8959e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 8969e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 8979e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 8989e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 899*8e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]); 900*8e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]); 901*8e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]); 902*8e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]); 903*8e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_prop); 904efb80947Sahrens break; 905efb80947Sahrens case DRR_FREE: 906efb80947Sahrens DO64(drr_free.drr_object); 907efb80947Sahrens DO64(drr_free.drr_offset); 908efb80947Sahrens DO64(drr_free.drr_length); 9099e69d7d0SLori Alt DO64(drr_free.drr_toguid); 910efb80947Sahrens break; 911efb80947Sahrens case DRR_END: 912efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 913efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 914efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 915efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 9169e69d7d0SLori Alt DO64(drr_end.drr_toguid); 917efb80947Sahrens break; 918efb80947Sahrens } 919efb80947Sahrens #undef DO64 920efb80947Sahrens #undef DO32 921efb80947Sahrens } 922efb80947Sahrens 923efb80947Sahrens static int 924efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 925efb80947Sahrens { 926efb80947Sahrens int err; 927efb80947Sahrens dmu_tx_t *tx; 928adee0b6fSTim Haley void *data = NULL; 929efb80947Sahrens 930efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 931efb80947Sahrens drro->drr_type >= DMU_OT_NUMTYPES || 932efb80947Sahrens drro->drr_bonustype >= DMU_OT_NUMTYPES || 9339e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 934efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 935efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 936efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 937efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 938efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 939efb80947Sahrens return (EINVAL); 940efb80947Sahrens } 941efb80947Sahrens 9422bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 9432bf405a2SMark Maybee 9442bf405a2SMark Maybee if (err != 0 && err != ENOENT) 9452bf405a2SMark Maybee return (EINVAL); 9462bf405a2SMark Maybee 947adee0b6fSTim Haley if (drro->drr_bonuslen) { 948adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 949adee0b6fSTim Haley if (ra->err) 950adee0b6fSTim Haley return (ra->err); 951adee0b6fSTim Haley } 952adee0b6fSTim Haley 953efb80947Sahrens if (err == ENOENT) { 954efb80947Sahrens /* currently free, want to be allocated */ 9552bf405a2SMark Maybee tx = dmu_tx_create(os); 956efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 957efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 958efb80947Sahrens if (err) { 959efb80947Sahrens dmu_tx_abort(tx); 960efb80947Sahrens return (err); 961efb80947Sahrens } 962efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 963efb80947Sahrens drro->drr_type, drro->drr_blksz, 964efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 9652bf405a2SMark Maybee dmu_tx_commit(tx); 966efb80947Sahrens } else { 967efb80947Sahrens /* currently allocated, want to be allocated */ 968efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 969efb80947Sahrens drro->drr_type, drro->drr_blksz, 9702bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 971efb80947Sahrens } 9722bf405a2SMark Maybee if (err) 973efb80947Sahrens return (EINVAL); 9742bf405a2SMark Maybee 9752bf405a2SMark Maybee tx = dmu_tx_create(os); 9762bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 9772bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 9782bf405a2SMark Maybee if (err) { 9792bf405a2SMark Maybee dmu_tx_abort(tx); 9802bf405a2SMark Maybee return (err); 981efb80947Sahrens } 982efb80947Sahrens 9839e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 9849e69d7d0SLori Alt tx); 985efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 986efb80947Sahrens 987adee0b6fSTim Haley if (data != NULL) { 988efb80947Sahrens dmu_buf_t *db; 989adee0b6fSTim Haley 990efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 991efb80947Sahrens dmu_buf_will_dirty(db, tx); 992efb80947Sahrens 9931934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 9941934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 995efb80947Sahrens if (ra->byteswap) { 996efb80947Sahrens dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 997efb80947Sahrens drro->drr_bonuslen); 998efb80947Sahrens } 999efb80947Sahrens dmu_buf_rele(db, FTAG); 1000efb80947Sahrens } 1001efb80947Sahrens dmu_tx_commit(tx); 1002efb80947Sahrens return (0); 1003efb80947Sahrens } 1004efb80947Sahrens 1005efb80947Sahrens /* ARGSUSED */ 1006efb80947Sahrens static int 1007efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1008efb80947Sahrens struct drr_freeobjects *drrfo) 1009efb80947Sahrens { 1010efb80947Sahrens uint64_t obj; 1011efb80947Sahrens 1012efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1013efb80947Sahrens return (EINVAL); 1014efb80947Sahrens 1015efb80947Sahrens for (obj = drrfo->drr_firstobj; 1016432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1017432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1018efb80947Sahrens int err; 1019efb80947Sahrens 1020efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1021efb80947Sahrens continue; 1022efb80947Sahrens 1023cdb0ab79Smaybee err = dmu_free_object(os, obj); 1024cdb0ab79Smaybee if (err) 1025efb80947Sahrens return (err); 1026efb80947Sahrens } 1027efb80947Sahrens return (0); 1028efb80947Sahrens } 1029efb80947Sahrens 1030efb80947Sahrens static int 1031efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1032efb80947Sahrens struct drr_write *drrw) 1033efb80947Sahrens { 1034efb80947Sahrens dmu_tx_t *tx; 1035efb80947Sahrens void *data; 1036efb80947Sahrens int err; 1037efb80947Sahrens 1038efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1039efb80947Sahrens drrw->drr_type >= DMU_OT_NUMTYPES) 1040efb80947Sahrens return (EINVAL); 1041efb80947Sahrens 1042efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1043efb80947Sahrens if (data == NULL) 1044efb80947Sahrens return (ra->err); 1045efb80947Sahrens 1046efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1047efb80947Sahrens return (EINVAL); 1048efb80947Sahrens 1049efb80947Sahrens tx = dmu_tx_create(os); 1050efb80947Sahrens 1051efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1052efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1053efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1054efb80947Sahrens if (err) { 1055efb80947Sahrens dmu_tx_abort(tx); 1056efb80947Sahrens return (err); 1057efb80947Sahrens } 1058efb80947Sahrens if (ra->byteswap) 1059efb80947Sahrens dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 1060efb80947Sahrens dmu_write(os, drrw->drr_object, 1061efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1062efb80947Sahrens dmu_tx_commit(tx); 1063efb80947Sahrens return (0); 1064efb80947Sahrens } 1065efb80947Sahrens 10669e69d7d0SLori Alt /* 10679e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 10689e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 10699e69d7d0SLori Alt * system because it came in earlier in the stream. This function 10709e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 10719e69d7d0SLori Alt * data from the stream to fulfill this write. 10729e69d7d0SLori Alt */ 10739e69d7d0SLori Alt static int 10749e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 10759e69d7d0SLori Alt struct drr_write_byref *drrwbr) 10769e69d7d0SLori Alt { 10779e69d7d0SLori Alt dmu_tx_t *tx; 10789e69d7d0SLori Alt int err; 10799e69d7d0SLori Alt guid_map_entry_t gmesrch; 10809e69d7d0SLori Alt guid_map_entry_t *gmep; 10819e69d7d0SLori Alt avl_index_t where; 10829e69d7d0SLori Alt objset_t *ref_os = NULL; 10839e69d7d0SLori Alt dmu_buf_t *dbp; 10849e69d7d0SLori Alt 10859e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 10869e69d7d0SLori Alt return (EINVAL); 10879e69d7d0SLori Alt 10889e69d7d0SLori Alt /* 10899e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 10909e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 10919e69d7d0SLori Alt */ 10929e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 10939e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 10949e69d7d0SLori Alt if ((gmep = avl_find(&ra->guid_to_ds_map, &gmesrch, 10959e69d7d0SLori Alt &where)) == NULL) { 10969e69d7d0SLori Alt return (EINVAL); 10979e69d7d0SLori Alt } 10989e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 10999e69d7d0SLori Alt return (EINVAL); 11009e69d7d0SLori Alt } else { 11019e69d7d0SLori Alt ref_os = os; 11029e69d7d0SLori Alt } 11039e69d7d0SLori Alt 11049e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 11059e69d7d0SLori Alt drrwbr->drr_refoffset, FTAG, &dbp)) 11069e69d7d0SLori Alt return (err); 11079e69d7d0SLori Alt 11089e69d7d0SLori Alt tx = dmu_tx_create(os); 11099e69d7d0SLori Alt 11109e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 11119e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 11129e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 11139e69d7d0SLori Alt if (err) { 11149e69d7d0SLori Alt dmu_tx_abort(tx); 11159e69d7d0SLori Alt return (err); 11169e69d7d0SLori Alt } 11179e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 11189e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 11199e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 11209e69d7d0SLori Alt dmu_tx_commit(tx); 11219e69d7d0SLori Alt return (0); 11229e69d7d0SLori Alt } 11239e69d7d0SLori Alt 1124efb80947Sahrens /* ARGSUSED */ 1125efb80947Sahrens static int 1126efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1127efb80947Sahrens struct drr_free *drrf) 1128efb80947Sahrens { 1129efb80947Sahrens int err; 1130efb80947Sahrens 1131efb80947Sahrens if (drrf->drr_length != -1ULL && 1132efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1133efb80947Sahrens return (EINVAL); 1134efb80947Sahrens 1135efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1136efb80947Sahrens return (EINVAL); 1137efb80947Sahrens 1138cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1139efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1140efb80947Sahrens return (err); 1141efb80947Sahrens } 1142efb80947Sahrens 11433cb34c60Sahrens /* 11443cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 11453cb34c60Sahrens */ 1146efb80947Sahrens int 11473cb34c60Sahrens dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp) 1148efb80947Sahrens { 11493cb34c60Sahrens struct restorearg ra = { 0 }; 1150efb80947Sahrens dmu_replay_record_t *drr; 11513cb34c60Sahrens objset_t *os; 11523cb34c60Sahrens zio_cksum_t pcksum; 11539e69d7d0SLori Alt guid_map_entry_t *gmep; 11549e69d7d0SLori Alt int featureflags; 1155efb80947Sahrens 11563cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1157efb80947Sahrens ra.byteswap = TRUE; 1158efb80947Sahrens 11593cb34c60Sahrens { 11603cb34c60Sahrens /* compute checksum of drr_begin record */ 11613cb34c60Sahrens dmu_replay_record_t *drr; 11623cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 11633cb34c60Sahrens 11643cb34c60Sahrens drr->drr_type = DRR_BEGIN; 11653cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 11663cb34c60Sahrens if (ra.byteswap) { 11673cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 11683cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 11693cb34c60Sahrens } else { 11703cb34c60Sahrens fletcher_4_incremental_native(drr, 11713cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 11723cb34c60Sahrens } 11733cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1174efb80947Sahrens } 1175efb80947Sahrens 1176efb80947Sahrens if (ra.byteswap) { 11773cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1178efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 11799e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1180efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1181efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1182efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1183efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1184efb80947Sahrens } 1185efb80947Sahrens 11863cb34c60Sahrens ra.vp = vp; 11873cb34c60Sahrens ra.voff = *voffp; 11883cb34c60Sahrens ra.bufsize = 1<<20; 11893cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1190efb80947Sahrens 11913cb34c60Sahrens /* these were verified in dmu_recv_begin */ 11929e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 11939e69d7d0SLori Alt DMU_SUBSTREAM); 11943cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1195efb80947Sahrens 1196efb80947Sahrens /* 1197efb80947Sahrens * Open the objset we are modifying. 1198efb80947Sahrens */ 1199503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1200efb80947Sahrens 12013cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1202efb80947Sahrens 12039e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 12049e69d7d0SLori Alt 12059e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 12069e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 12079e69d7d0SLori Alt avl_create(&ra.guid_to_ds_map, guid_compare, 12089e69d7d0SLori Alt sizeof (guid_map_entry_t), 12099e69d7d0SLori Alt offsetof(guid_map_entry_t, avlnode)); 12109e69d7d0SLori Alt (void) dmu_objset_find(drc->drc_top_ds, find_ds_by_guid, 12119e69d7d0SLori Alt (void *)&ra.guid_to_ds_map, 12129e69d7d0SLori Alt DS_FIND_CHILDREN); 12139e69d7d0SLori Alt } 12149e69d7d0SLori Alt 1215efb80947Sahrens /* 1216efb80947Sahrens * Read records and process them. 1217efb80947Sahrens */ 12183cb34c60Sahrens pcksum = ra.cksum; 1219efb80947Sahrens while (ra.err == 0 && 1220efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1221efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1222efb80947Sahrens ra.err = EINTR; 1223efb80947Sahrens goto out; 1224efb80947Sahrens } 1225efb80947Sahrens 1226efb80947Sahrens if (ra.byteswap) 1227efb80947Sahrens backup_byteswap(drr); 1228efb80947Sahrens 1229efb80947Sahrens switch (drr->drr_type) { 1230efb80947Sahrens case DRR_OBJECT: 1231efb80947Sahrens { 1232efb80947Sahrens /* 1233efb80947Sahrens * We need to make a copy of the record header, 1234efb80947Sahrens * because restore_{object,write} may need to 1235efb80947Sahrens * restore_read(), which will invalidate drr. 1236efb80947Sahrens */ 1237efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1238efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1239efb80947Sahrens break; 1240efb80947Sahrens } 1241efb80947Sahrens case DRR_FREEOBJECTS: 1242efb80947Sahrens { 1243efb80947Sahrens struct drr_freeobjects drrfo = 1244efb80947Sahrens drr->drr_u.drr_freeobjects; 1245efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1246efb80947Sahrens break; 1247efb80947Sahrens } 1248efb80947Sahrens case DRR_WRITE: 1249efb80947Sahrens { 1250efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1251efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1252efb80947Sahrens break; 1253efb80947Sahrens } 12549e69d7d0SLori Alt case DRR_WRITE_BYREF: 12559e69d7d0SLori Alt { 12569e69d7d0SLori Alt struct drr_write_byref drrwbr = 12579e69d7d0SLori Alt drr->drr_u.drr_write_byref; 12589e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 12599e69d7d0SLori Alt break; 12609e69d7d0SLori Alt } 1261efb80947Sahrens case DRR_FREE: 1262efb80947Sahrens { 1263efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1264efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1265efb80947Sahrens break; 1266efb80947Sahrens } 1267efb80947Sahrens case DRR_END: 1268efb80947Sahrens { 1269efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1270efb80947Sahrens /* 1271efb80947Sahrens * We compare against the *previous* checksum 1272efb80947Sahrens * value, because the stored checksum is of 1273efb80947Sahrens * everything before the DRR_END record. 1274efb80947Sahrens */ 1275137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1276efb80947Sahrens ra.err = ECKSUM; 1277efb80947Sahrens goto out; 1278efb80947Sahrens } 1279efb80947Sahrens default: 1280efb80947Sahrens ra.err = EINVAL; 1281efb80947Sahrens goto out; 1282efb80947Sahrens } 12833cb34c60Sahrens pcksum = ra.cksum; 1284efb80947Sahrens } 1285137fa067Sahrens ASSERT(ra.err != 0); 1286efb80947Sahrens 1287efb80947Sahrens out: 12883cb34c60Sahrens if (ra.err != 0) { 1289efb80947Sahrens /* 1290f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1291f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1292efb80947Sahrens */ 12933cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1294f4b94bdeSMatthew Ahrens 1295842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1296842727c2SChris Kirby B_FALSE); 1297f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1298f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1299f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1300f4b94bdeSMatthew Ahrens } 1301efb80947Sahrens } 1302efb80947Sahrens 13039e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 13049e69d7d0SLori Alt void *cookie = NULL; 13059e69d7d0SLori Alt 13069e69d7d0SLori Alt while (gmep = avl_destroy_nodes(&ra.guid_to_ds_map, &cookie)) { 13079e69d7d0SLori Alt dsl_dataset_rele(gmep->gme_ds, &ra.guid_to_ds_map); 13089e69d7d0SLori Alt kmem_free(gmep, sizeof (guid_map_entry_t)); 13099e69d7d0SLori Alt } 13109e69d7d0SLori Alt avl_destroy(&ra.guid_to_ds_map); 13119e69d7d0SLori Alt } 13129e69d7d0SLori Alt 1313efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 13143cb34c60Sahrens *voffp = ra.voff; 1315efb80947Sahrens return (ra.err); 1316efb80947Sahrens } 1317f18faf3fSek 13183cb34c60Sahrens struct recvendsyncarg { 13193cb34c60Sahrens char *tosnap; 13203cb34c60Sahrens uint64_t creation_time; 13213cb34c60Sahrens uint64_t toguid; 13223cb34c60Sahrens }; 13233cb34c60Sahrens 13243cb34c60Sahrens static int 13253cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 13263cb34c60Sahrens { 13273cb34c60Sahrens dsl_dataset_t *ds = arg1; 13283cb34c60Sahrens struct recvendsyncarg *resa = arg2; 13293cb34c60Sahrens 13303cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 13313cb34c60Sahrens } 13323cb34c60Sahrens 13333cb34c60Sahrens static void 13343cb34c60Sahrens recv_end_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 13353cb34c60Sahrens { 13363cb34c60Sahrens dsl_dataset_t *ds = arg1; 13373cb34c60Sahrens struct recvendsyncarg *resa = arg2; 13383cb34c60Sahrens 13393cb34c60Sahrens dsl_dataset_snapshot_sync(ds, resa->tosnap, cr, tx); 13403cb34c60Sahrens 13413cb34c60Sahrens /* set snapshot's creation time and guid */ 13423cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 13433cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 13443cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 13453cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 13463cb34c60Sahrens 13473cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 13483cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 13493cb34c60Sahrens } 13503cb34c60Sahrens 1351ae46e4c7SMatthew Ahrens static int 1352ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1353f18faf3fSek { 1354745cd3c5Smaybee struct recvendsyncarg resa; 1355745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 1356745cd3c5Smaybee int err; 1357f18faf3fSek 13583cb34c60Sahrens /* 1359ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1360ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1361ae46e4c7SMatthew Ahrens * can close it. 13623cb34c60Sahrens */ 1363745cd3c5Smaybee txg_wait_synced(ds->ds_dir->dd_pool, 0); 13643cb34c60Sahrens 1365ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1366ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1367ae46e4c7SMatthew Ahrens drc->drc_force); 1368ae46e4c7SMatthew Ahrens if (err) 1369ae46e4c7SMatthew Ahrens goto out; 1370ae46e4c7SMatthew Ahrens } else { 1371ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1372ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1373842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1374842727c2SChris Kirby B_FALSE); 1375ae46e4c7SMatthew Ahrens return (EBUSY); 13763cb34c60Sahrens } 13773cb34c60Sahrens 1378745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1379745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1380745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 13813cb34c60Sahrens 1382745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1383745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1384745cd3c5Smaybee if (err) { 1385ae46e4c7SMatthew Ahrens /* swap back */ 1386ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 13873cb34c60Sahrens } 13883cb34c60Sahrens 1389ae46e4c7SMatthew Ahrens out: 1390ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1391745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 1392ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 1393f18faf3fSek return (err); 1394f18faf3fSek } 1395ae46e4c7SMatthew Ahrens 1396ae46e4c7SMatthew Ahrens static int 1397ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1398ae46e4c7SMatthew Ahrens { 1399ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1400ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1401ae46e4c7SMatthew Ahrens int err; 1402ae46e4c7SMatthew Ahrens 1403ae46e4c7SMatthew Ahrens /* 1404ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1405ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1406ae46e4c7SMatthew Ahrens * can close it. 1407ae46e4c7SMatthew Ahrens */ 1408ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1409ae46e4c7SMatthew Ahrens 1410ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1411ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1412ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1413ae46e4c7SMatthew Ahrens 1414ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1415ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1416ae46e4c7SMatthew Ahrens if (err) { 1417ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1418ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1419ae46e4c7SMatthew Ahrens } else { 1420ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1421ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1422ae46e4c7SMatthew Ahrens } 1423ae46e4c7SMatthew Ahrens return (err); 1424ae46e4c7SMatthew Ahrens } 1425ae46e4c7SMatthew Ahrens 1426ae46e4c7SMatthew Ahrens int 1427ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1428ae46e4c7SMatthew Ahrens { 1429ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1430ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1431ae46e4c7SMatthew Ahrens else 1432ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1433ae46e4c7SMatthew Ahrens } 1434