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> 36*92241e0bSTom 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> 43efb80947Sahrens 443cb34c60Sahrens static char *dmu_recv_tag = "dmu_recv_tag"; 453cb34c60Sahrens 469e69d7d0SLori Alt /* 479e69d7d0SLori Alt * The list of data whose inclusion in a send stream can be pending from 489e69d7d0SLori Alt * one call to backup_cb to another. Multiple calls to dump_free() and 499e69d7d0SLori Alt * dump_freeobjects() can be aggregated into a single DRR_FREE or 509e69d7d0SLori Alt * DRR_FREEOBJECTS replay record. 519e69d7d0SLori Alt */ 529e69d7d0SLori Alt typedef enum { 539e69d7d0SLori Alt PENDING_NONE, 549e69d7d0SLori Alt PENDING_FREE, 559e69d7d0SLori Alt PENDING_FREEOBJECTS 569e69d7d0SLori Alt } pendop_t; 579e69d7d0SLori Alt 58efb80947Sahrens struct backuparg { 59efb80947Sahrens dmu_replay_record_t *drr; 60efb80947Sahrens vnode_t *vp; 613cb34c60Sahrens offset_t *off; 62efb80947Sahrens objset_t *os; 63efb80947Sahrens zio_cksum_t zc; 649e69d7d0SLori Alt uint64_t toguid; 65efb80947Sahrens int err; 669e69d7d0SLori Alt pendop_t pending_op; 67efb80947Sahrens }; 68efb80947Sahrens 69efb80947Sahrens static int 70efb80947Sahrens dump_bytes(struct backuparg *ba, void *buf, int len) 71efb80947Sahrens { 72efb80947Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 73efb80947Sahrens ASSERT3U(len % 8, ==, 0); 74efb80947Sahrens 75efb80947Sahrens fletcher_4_incremental_native(buf, len, &ba->zc); 76efb80947Sahrens ba->err = vn_rdwr(UIO_WRITE, ba->vp, 77efb80947Sahrens (caddr_t)buf, len, 78efb80947Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 793cb34c60Sahrens *ba->off += len; 80efb80947Sahrens return (ba->err); 81efb80947Sahrens } 82efb80947Sahrens 83efb80947Sahrens static int 84efb80947Sahrens dump_free(struct backuparg *ba, uint64_t object, uint64_t offset, 85efb80947Sahrens uint64_t length) 86efb80947Sahrens { 879e69d7d0SLori Alt struct drr_free *drrf = &(ba->drr->drr_u.drr_free); 889e69d7d0SLori Alt 899e69d7d0SLori Alt /* 909e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 919e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 929e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 939e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 949e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 959e69d7d0SLori Alt */ 969e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && ba->pending_op != PENDING_FREE) { 979e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 989e69d7d0SLori Alt return (EINTR); 999e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1009e69d7d0SLori Alt } 1019e69d7d0SLori Alt 1029e69d7d0SLori Alt if (ba->pending_op == PENDING_FREE) { 1039e69d7d0SLori Alt /* 1049e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 1059e69d7d0SLori Alt * (because dump_dnode is the only place where this 1069e69d7d0SLori Alt * function is called with a -1, and only after flushing 1079e69d7d0SLori Alt * any pending record). 1089e69d7d0SLori Alt */ 1099e69d7d0SLori Alt ASSERT(length != -1ULL); 1109e69d7d0SLori Alt /* 1119e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1129e69d7d0SLori Alt * with pending one. 1139e69d7d0SLori Alt */ 1149e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1159e69d7d0SLori Alt drrf->drr_length == offset) { 1169e69d7d0SLori Alt drrf->drr_length += length; 1179e69d7d0SLori Alt return (0); 1189e69d7d0SLori Alt } else { 1199e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1209e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 1219e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1229e69d7d0SLori Alt return (EINTR); 1239e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1249e69d7d0SLori Alt } 1259e69d7d0SLori Alt } 1269e69d7d0SLori Alt /* create a FREE record and make it pending */ 127efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 128efb80947Sahrens ba->drr->drr_type = DRR_FREE; 1299e69d7d0SLori Alt drrf->drr_object = object; 1309e69d7d0SLori Alt drrf->drr_offset = offset; 1319e69d7d0SLori Alt drrf->drr_length = length; 1329e69d7d0SLori Alt drrf->drr_toguid = ba->toguid; 1339e69d7d0SLori Alt if (length == -1ULL) { 1349e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1359e69d7d0SLori Alt return (EINTR); 1369e69d7d0SLori Alt } else { 1379e69d7d0SLori Alt ba->pending_op = PENDING_FREE; 1389e69d7d0SLori Alt } 139efb80947Sahrens 140efb80947Sahrens return (0); 141efb80947Sahrens } 142efb80947Sahrens 143efb80947Sahrens static int 144efb80947Sahrens dump_data(struct backuparg *ba, dmu_object_type_t type, 145efb80947Sahrens uint64_t object, uint64_t offset, int blksz, void *data) 146efb80947Sahrens { 1479e69d7d0SLori Alt struct drr_write *drrw = &(ba->drr->drr_u.drr_write); 1489e69d7d0SLori Alt 1499e69d7d0SLori Alt /* 1509e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1519e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1529e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1539e69d7d0SLori Alt * of different types. 1549e69d7d0SLori Alt */ 1559e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 1569e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1579e69d7d0SLori Alt return (EINTR); 1589e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1599e69d7d0SLori Alt } 160efb80947Sahrens /* write a DATA record */ 161efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 162efb80947Sahrens ba->drr->drr_type = DRR_WRITE; 1639e69d7d0SLori Alt drrw->drr_object = object; 1649e69d7d0SLori Alt drrw->drr_type = type; 1659e69d7d0SLori Alt drrw->drr_offset = offset; 1669e69d7d0SLori Alt drrw->drr_length = blksz; 1679e69d7d0SLori Alt drrw->drr_toguid = ba->toguid; 168efb80947Sahrens 1699e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 170efb80947Sahrens return (EINTR); 1719e69d7d0SLori Alt if (dump_bytes(ba, data, blksz) != 0) 172efb80947Sahrens return (EINTR); 173efb80947Sahrens return (0); 174efb80947Sahrens } 175efb80947Sahrens 176efb80947Sahrens static int 177efb80947Sahrens dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs) 178efb80947Sahrens { 1799e69d7d0SLori Alt struct drr_freeobjects *drrfo = &(ba->drr->drr_u.drr_freeobjects); 1809e69d7d0SLori Alt 1819e69d7d0SLori Alt /* 1829e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 1839e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 1849e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 1859e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 1869e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 1879e69d7d0SLori Alt */ 1889e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE && 1899e69d7d0SLori Alt ba->pending_op != PENDING_FREEOBJECTS) { 1909e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 1919e69d7d0SLori Alt return (EINTR); 1929e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 1939e69d7d0SLori Alt } 1949e69d7d0SLori Alt if (ba->pending_op == PENDING_FREEOBJECTS) { 1959e69d7d0SLori Alt /* 1969e69d7d0SLori Alt * See whether this free object array can be aggregated 1979e69d7d0SLori Alt * with pending one 1989e69d7d0SLori Alt */ 1999e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2009e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2019e69d7d0SLori Alt return (0); 2029e69d7d0SLori Alt } else { 2039e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2049e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, 2059e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2069e69d7d0SLori Alt return (EINTR); 2079e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2089e69d7d0SLori Alt } 2099e69d7d0SLori Alt } 2109e69d7d0SLori Alt 211efb80947Sahrens /* write a FREEOBJECTS record */ 212efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 213efb80947Sahrens ba->drr->drr_type = DRR_FREEOBJECTS; 2149e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2159e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2169e69d7d0SLori Alt drrfo->drr_toguid = ba->toguid; 2179e69d7d0SLori Alt 2189e69d7d0SLori Alt ba->pending_op = PENDING_FREEOBJECTS; 219efb80947Sahrens 220efb80947Sahrens return (0); 221efb80947Sahrens } 222efb80947Sahrens 223efb80947Sahrens static int 224efb80947Sahrens dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp) 225efb80947Sahrens { 2269e69d7d0SLori Alt struct drr_object *drro = &(ba->drr->drr_u.drr_object); 2279e69d7d0SLori Alt 228efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 229efb80947Sahrens return (dump_freeobjects(ba, object, 1)); 230efb80947Sahrens 2319e69d7d0SLori Alt if (ba->pending_op != PENDING_NONE) { 2329e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 2339e69d7d0SLori Alt return (EINTR); 2349e69d7d0SLori Alt ba->pending_op = PENDING_NONE; 2359e69d7d0SLori Alt } 2369e69d7d0SLori Alt 237efb80947Sahrens /* write an OBJECT record */ 238efb80947Sahrens bzero(ba->drr, sizeof (dmu_replay_record_t)); 239efb80947Sahrens ba->drr->drr_type = DRR_OBJECT; 2409e69d7d0SLori Alt drro->drr_object = object; 2419e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2429e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2439e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2449e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2459e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2469e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2479e69d7d0SLori Alt drro->drr_toguid = ba->toguid; 2489e69d7d0SLori Alt 2499e69d7d0SLori Alt if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)) != 0) 250efb80947Sahrens return (EINTR); 251efb80947Sahrens 2529e69d7d0SLori Alt if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 253efb80947Sahrens return (EINTR); 254efb80947Sahrens 255efb80947Sahrens /* free anything past the end of the file */ 256efb80947Sahrens if (dump_free(ba, object, (dnp->dn_maxblkid + 1) * 257efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 258efb80947Sahrens return (EINTR); 259efb80947Sahrens if (ba->err) 260efb80947Sahrens return (EINTR); 261efb80947Sahrens return (0); 262efb80947Sahrens } 263efb80947Sahrens 264efb80947Sahrens #define BP_SPAN(dnp, level) \ 265efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 266efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 267efb80947Sahrens 268b24ab676SJeff Bonwick /* ARGSUSED */ 269efb80947Sahrens static int 270b24ab676SJeff Bonwick backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 271b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 272efb80947Sahrens { 273efb80947Sahrens struct backuparg *ba = arg; 274efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 275efb80947Sahrens int err = 0; 276efb80947Sahrens 277efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 278efb80947Sahrens return (EINTR); 279efb80947Sahrens 280b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 281b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 28214843421SMatthew Ahrens return (0); 283b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 28488b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 28588b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 286efb80947Sahrens err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT); 287efb80947Sahrens } else if (bp == NULL) { 28888b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 28988b7b0f2SMatthew Ahrens err = dump_free(ba, zb->zb_object, zb->zb_blkid * span, span); 29088b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 29188b7b0f2SMatthew Ahrens return (0); 29288b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 29388b7b0f2SMatthew Ahrens dnode_phys_t *blk; 294efb80947Sahrens int i; 295efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 29688b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 29788b7b0f2SMatthew Ahrens arc_buf_t *abuf; 298efb80947Sahrens 29988b7b0f2SMatthew Ahrens if (arc_read_nolock(NULL, spa, bp, 30088b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 30188b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 30288b7b0f2SMatthew Ahrens return (EIO); 30388b7b0f2SMatthew Ahrens 30488b7b0f2SMatthew Ahrens blk = abuf->b_data; 305efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 30688b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 30788b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 308efb80947Sahrens err = dump_dnode(ba, dnobj, blk+i); 309efb80947Sahrens if (err) 310efb80947Sahrens break; 311efb80947Sahrens } 31288b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 31388b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 31488b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 31588b7b0f2SMatthew Ahrens arc_buf_t *abuf; 316efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 31788b7b0f2SMatthew Ahrens 31888b7b0f2SMatthew Ahrens if (arc_read_nolock(NULL, spa, bp, 31988b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 32088b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 32188b7b0f2SMatthew Ahrens return (EIO); 32288b7b0f2SMatthew Ahrens 32388b7b0f2SMatthew Ahrens err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz, 32488b7b0f2SMatthew Ahrens blksz, abuf->b_data); 32588b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 326efb80947Sahrens } 327efb80947Sahrens 328efb80947Sahrens ASSERT(err == 0 || err == EINTR); 329efb80947Sahrens return (err); 330efb80947Sahrens } 331efb80947Sahrens 332efb80947Sahrens int 3333cb34c60Sahrens dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 3343cb34c60Sahrens vnode_t *vp, offset_t *off) 335efb80947Sahrens { 336503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 337503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 338efb80947Sahrens dmu_replay_record_t *drr; 339efb80947Sahrens struct backuparg ba; 340efb80947Sahrens int err; 3413cb34c60Sahrens uint64_t fromtxg = 0; 342efb80947Sahrens 343efb80947Sahrens /* tosnap must be a snapshot */ 344efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 345efb80947Sahrens return (EINVAL); 346efb80947Sahrens 347efb80947Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 348efb80947Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 3493cb34c60Sahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 350efb80947Sahrens return (EXDEV); 351efb80947Sahrens 3523cb34c60Sahrens if (fromorigin) { 353088f3894Sahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 354088f3894Sahrens 3553cb34c60Sahrens if (fromsnap) 3563cb34c60Sahrens return (EINVAL); 3573cb34c60Sahrens 358088f3894Sahrens if (dsl_dir_is_clone(ds->ds_dir)) { 3593cb34c60Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 360745cd3c5Smaybee err = dsl_dataset_hold_obj(dp, 361745cd3c5Smaybee ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 3623cb34c60Sahrens rw_exit(&dp->dp_config_rwlock); 3633cb34c60Sahrens if (err) 3643cb34c60Sahrens return (err); 3653cb34c60Sahrens } else { 3663cb34c60Sahrens fromorigin = B_FALSE; 3673cb34c60Sahrens } 3683cb34c60Sahrens } 3693cb34c60Sahrens 3703cb34c60Sahrens 371efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 372efb80947Sahrens drr->drr_type = DRR_BEGIN; 373efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 3749e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 3759e69d7d0SLori Alt DMU_SUBSTREAM); 376efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 377efb80947Sahrens ds->ds_phys->ds_creation_time; 378503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 3793cb34c60Sahrens if (fromorigin) 3803cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 381efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 382ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 383ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 384ab04eb8eStimh 385efb80947Sahrens if (fromds) 386efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 387efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 388efb80947Sahrens 3893cb34c60Sahrens if (fromds) 3903cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 3913cb34c60Sahrens if (fromorigin) 392745cd3c5Smaybee dsl_dataset_rele(fromds, FTAG); 3933cb34c60Sahrens 394efb80947Sahrens ba.drr = drr; 395efb80947Sahrens ba.vp = vp; 396efb80947Sahrens ba.os = tosnap; 3973cb34c60Sahrens ba.off = off; 3989e69d7d0SLori Alt ba.toguid = ds->ds_phys->ds_guid; 399efb80947Sahrens ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0); 4009e69d7d0SLori Alt ba.pending_op = PENDING_NONE; 401efb80947Sahrens 4029e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 403efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 404efb80947Sahrens return (ba.err); 405efb80947Sahrens } 406efb80947Sahrens 40788b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 408efb80947Sahrens backup_cb, &ba); 409efb80947Sahrens 4109e69d7d0SLori Alt if (ba.pending_op != PENDING_NONE) 4119e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) 4129e69d7d0SLori Alt err = EINTR; 4139e69d7d0SLori Alt 414efb80947Sahrens if (err) { 415efb80947Sahrens if (err == EINTR && ba.err) 416efb80947Sahrens err = ba.err; 4177b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 418efb80947Sahrens return (err); 419efb80947Sahrens } 420efb80947Sahrens 421efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 422efb80947Sahrens drr->drr_type = DRR_END; 423efb80947Sahrens drr->drr_u.drr_end.drr_checksum = ba.zc; 4249e69d7d0SLori Alt drr->drr_u.drr_end.drr_toguid = ba.toguid; 425efb80947Sahrens 4269e69d7d0SLori Alt if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)) != 0) { 4277b5309bbSgw kmem_free(drr, sizeof (dmu_replay_record_t)); 428efb80947Sahrens return (ba.err); 4297b5309bbSgw } 430efb80947Sahrens 431efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 432efb80947Sahrens 433efb80947Sahrens return (0); 434efb80947Sahrens } 435efb80947Sahrens 4363cb34c60Sahrens struct recvbeginsyncarg { 4373cb34c60Sahrens const char *tofs; 4383cb34c60Sahrens const char *tosnap; 4393cb34c60Sahrens dsl_dataset_t *origin; 4403cb34c60Sahrens uint64_t fromguid; 4413cb34c60Sahrens dmu_objset_type_t type; 4423cb34c60Sahrens void *tag; 4433cb34c60Sahrens boolean_t force; 444ab04eb8eStimh uint64_t dsflags; 4453cb34c60Sahrens char clonelastname[MAXNAMELEN]; 4463cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 447efb80947Sahrens }; 448efb80947Sahrens 449efb80947Sahrens /* ARGSUSED */ 450efb80947Sahrens static int 451ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 452efb80947Sahrens { 453efb80947Sahrens dsl_dir_t *dd = arg1; 4543cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 455efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 456efb80947Sahrens uint64_t val; 457efb80947Sahrens int err; 458efb80947Sahrens 459efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 4603cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 461efb80947Sahrens 462efb80947Sahrens if (err != ENOENT) 463efb80947Sahrens return (err ? err : EEXIST); 464efb80947Sahrens 4653cb34c60Sahrens if (rbsa->origin) { 4663cb34c60Sahrens /* make sure it's a snap in the same pool */ 4673cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 4683cb34c60Sahrens return (EXDEV); 469ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 4703cb34c60Sahrens return (EINVAL); 4713cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 4723cb34c60Sahrens return (ENODEV); 4733cb34c60Sahrens } 4743cb34c60Sahrens 475efb80947Sahrens return (0); 476efb80947Sahrens } 477efb80947Sahrens 478efb80947Sahrens static void 479ae46e4c7SMatthew Ahrens recv_new_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 480efb80947Sahrens { 481efb80947Sahrens dsl_dir_t *dd = arg1; 4823cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 483745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 484efb80947Sahrens uint64_t dsobj; 485efb80947Sahrens 486ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 4873cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 488ab04eb8eStimh rbsa->origin, flags, cr, tx); 489ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 490503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 491efb80947Sahrens 492ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 493ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 494ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 4953cb34c60Sahrens } 496ecd6cf80Smarks 497ae46e4c7SMatthew Ahrens spa_history_internal_log(LOG_DS_REPLAY_FULL_SYNC, 498ae46e4c7SMatthew Ahrens dd->dd_pool->dp_spa, tx, cr, "dataset = %lld", dsobj); 4993cb34c60Sahrens } 500f18faf3fSek 501f18faf3fSek /* ARGSUSED */ 502f18faf3fSek static int 503ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 504f18faf3fSek { 5053cb34c60Sahrens dsl_dataset_t *ds = arg1; 5063cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5073cb34c60Sahrens int err; 5083cb34c60Sahrens uint64_t val; 509f18faf3fSek 5103cb34c60Sahrens /* must not have any changes since most recent snapshot */ 5113cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 512f18faf3fSek return (ETXTBSY); 513f18faf3fSek 514ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 515ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 516ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 517ae46e4c7SMatthew Ahrens return (ENODEV); 518*92241e0bSTom Erickson 519*92241e0bSTom Erickson /* 520*92241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 521*92241e0bSTom Erickson * changes since the fromguid one 522*92241e0bSTom Erickson */ 523*92241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 524*92241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 525*92241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 526*92241e0bSTom Erickson while (obj != 0) { 527*92241e0bSTom Erickson dsl_dataset_t *snap; 528*92241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 529*92241e0bSTom Erickson obj, FTAG, &snap); 530*92241e0bSTom Erickson if (err) 531*92241e0bSTom Erickson return (ENODEV); 532*92241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 533*92241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 534*92241e0bSTom Erickson return (ENODEV); 535*92241e0bSTom Erickson } 536*92241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 537*92241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 538*92241e0bSTom Erickson break; /* it's ok */ 539*92241e0bSTom Erickson } 540*92241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 541*92241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 542*92241e0bSTom Erickson } 543*92241e0bSTom Erickson if (obj == 0) 544*92241e0bSTom Erickson return (ENODEV); 545*92241e0bSTom Erickson } 546ae46e4c7SMatthew Ahrens } else { 547ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 548ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 549ae46e4c7SMatthew Ahrens return (ENODEV); 550ae46e4c7SMatthew Ahrens } 5513cb34c60Sahrens 55247f263f4Sek /* temporary clone name must not exist */ 55347f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 55447f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 55547f263f4Sek rbsa->clonelastname, 8, 1, &val); 55647f263f4Sek if (err == 0) 55747f263f4Sek return (EEXIST); 55847f263f4Sek if (err != ENOENT) 55947f263f4Sek return (err); 56047f263f4Sek 5613cb34c60Sahrens /* new snapshot name must not exist */ 5623cb34c60Sahrens err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 5633cb34c60Sahrens ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 5643cb34c60Sahrens if (err == 0) 5653cb34c60Sahrens return (EEXIST); 5663cb34c60Sahrens if (err != ENOENT) 5673cb34c60Sahrens return (err); 5683cb34c60Sahrens return (0); 569f18faf3fSek } 570f18faf3fSek 571f18faf3fSek /* ARGSUSED */ 572f18faf3fSek static void 573ae46e4c7SMatthew Ahrens recv_existing_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 574f18faf3fSek { 5753cb34c60Sahrens dsl_dataset_t *ohds = arg1; 5763cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 5773cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 578ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 579745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 580f18faf3fSek uint64_t dsobj; 581f18faf3fSek 582ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 583ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 584ae46e4c7SMatthew Ahrens ohds->ds_prev, flags, cr, tx); 585503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 5863cb34c60Sahrens 587ae46e4c7SMatthew Ahrens /* 588ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 589ae46e4c7SMatthew Ahrens * objset in our new dataset. 590ae46e4c7SMatthew Ahrens */ 591ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 592ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 593ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 594ae46e4c7SMatthew Ahrens } 595ae46e4c7SMatthew Ahrens 5963cb34c60Sahrens rbsa->ds = cds; 5973cb34c60Sahrens 5983cb34c60Sahrens spa_history_internal_log(LOG_DS_REPLAY_INC_SYNC, 599745cd3c5Smaybee dp->dp_spa, tx, cr, "dataset = %lld", dsobj); 6003cb34c60Sahrens } 6013cb34c60Sahrens 6023cb34c60Sahrens /* 6033cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 6043cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 6053cb34c60Sahrens */ 6063cb34c60Sahrens int 6079e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 608f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 609efb80947Sahrens { 6103cb34c60Sahrens int err = 0; 6113cb34c60Sahrens boolean_t byteswap; 612ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 6139e69d7d0SLori Alt uint64_t versioninfo; 6143cb34c60Sahrens int flags; 6153cb34c60Sahrens dsl_dataset_t *ds; 616efb80947Sahrens 6173cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 6183cb34c60Sahrens byteswap = FALSE; 6193cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 6203cb34c60Sahrens byteswap = TRUE; 6213cb34c60Sahrens else 6223cb34c60Sahrens return (EINVAL); 6233cb34c60Sahrens 6243cb34c60Sahrens rbsa.tofs = tofs; 6253cb34c60Sahrens rbsa.tosnap = tosnap; 626503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 6273cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 6283cb34c60Sahrens rbsa.type = drrb->drr_type; 6293cb34c60Sahrens rbsa.tag = FTAG; 630ab04eb8eStimh rbsa.dsflags = 0; 6319e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 6323cb34c60Sahrens flags = drrb->drr_flags; 6333cb34c60Sahrens 6343cb34c60Sahrens if (byteswap) { 6353cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 6363cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 6379e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 6383cb34c60Sahrens flags = BSWAP_32(flags); 6393cb34c60Sahrens } 640efb80947Sahrens 6419e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 6423cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 6433cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 644efb80947Sahrens return (EINVAL); 645efb80947Sahrens 646ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 647ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 648ab04eb8eStimh 6493cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 6503cb34c60Sahrens drc->drc_drrb = drrb; 6513cb34c60Sahrens drc->drc_tosnap = tosnap; 6529e69d7d0SLori Alt drc->drc_top_ds = top_ds; 6533cb34c60Sahrens drc->drc_force = force; 654efb80947Sahrens 6553cb34c60Sahrens /* 6563cb34c60Sahrens * Process the begin in syncing context. 6573cb34c60Sahrens */ 658efb80947Sahrens 659ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 660ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 661ae46e4c7SMatthew Ahrens if (err == 0) { 662ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 663efb80947Sahrens 664ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 665ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 666ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 667ae46e4c7SMatthew Ahrens return (EINVAL); 668ae46e4c7SMatthew Ahrens } 669efb80947Sahrens 670f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 671f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 672f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 673f4b94bdeSMatthew Ahrens return (EBUSY); 674f4b94bdeSMatthew Ahrens } 675f4b94bdeSMatthew Ahrens 676ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 677ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 678ae46e4c7SMatthew Ahrens "%%%s", tosnap); 6793cb34c60Sahrens rbsa.force = force; 6803cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 681ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 6823cb34c60Sahrens if (err) { 683f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 684745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 6853cb34c60Sahrens return (err); 6863cb34c60Sahrens } 6873cb34c60Sahrens drc->drc_logical_ds = ds; 6883cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 689ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 690ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 691ae46e4c7SMatthew Ahrens char *cp; 692efb80947Sahrens 693ae46e4c7SMatthew Ahrens /* 694ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 695ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 696ae46e4c7SMatthew Ahrens */ 697ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 698ae46e4c7SMatthew Ahrens return (ENOENT); 699ae46e4c7SMatthew Ahrens 700ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 701ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 702ae46e4c7SMatthew Ahrens *cp = '\0'; 703bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 704ae46e4c7SMatthew Ahrens *cp = '/'; 7053cb34c60Sahrens if (err) 7063cb34c60Sahrens return (err); 707efb80947Sahrens 708ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 709ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 710bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 7113cb34c60Sahrens if (err) 7123cb34c60Sahrens return (err); 7133cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 7143cb34c60Sahrens drc->drc_newfs = B_TRUE; 7153cb34c60Sahrens } 7163cb34c60Sahrens 717ae46e4c7SMatthew Ahrens return (err); 718efb80947Sahrens } 719efb80947Sahrens 7203cb34c60Sahrens struct restorearg { 7213cb34c60Sahrens int err; 7223cb34c60Sahrens int byteswap; 7233cb34c60Sahrens vnode_t *vp; 7243cb34c60Sahrens char *buf; 7253cb34c60Sahrens uint64_t voff; 7263cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 7273cb34c60Sahrens zio_cksum_t cksum; 7289e69d7d0SLori Alt avl_tree_t guid_to_ds_map; 7293cb34c60Sahrens }; 7303cb34c60Sahrens 7319e69d7d0SLori Alt typedef struct guid_map_entry { 7329e69d7d0SLori Alt uint64_t guid; 7339e69d7d0SLori Alt dsl_dataset_t *gme_ds; 7349e69d7d0SLori Alt avl_node_t avlnode; 7359e69d7d0SLori Alt } guid_map_entry_t; 7369e69d7d0SLori Alt 7379e69d7d0SLori Alt static int 7389e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 7399e69d7d0SLori Alt { 7409e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 7419e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 7429e69d7d0SLori Alt 7439e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 7449e69d7d0SLori Alt return (-1); 7459e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 7469e69d7d0SLori Alt return (1); 7479e69d7d0SLori Alt return (0); 7489e69d7d0SLori Alt } 7499e69d7d0SLori Alt 7509e69d7d0SLori Alt /* 7519e69d7d0SLori Alt * This function is a callback used by dmu_objset_find() (which 7529e69d7d0SLori Alt * enumerates the object sets) to build an avl tree that maps guids 7539e69d7d0SLori Alt * to datasets. The resulting table is used when processing DRR_WRITE_BYREF 7549e69d7d0SLori Alt * send stream records. These records, which are used in dedup'ed 7559e69d7d0SLori Alt * streams, do not contain data themselves, but refer to a copy 7569e69d7d0SLori Alt * of the data block that has already been written because it was 7579e69d7d0SLori Alt * earlier in the stream. That previous copy is identified by the 7589e69d7d0SLori Alt * guid of the dataset with the referenced data. 7599e69d7d0SLori Alt */ 7609e69d7d0SLori Alt int 7619e69d7d0SLori Alt find_ds_by_guid(char *name, void *arg) 7629e69d7d0SLori Alt { 7639e69d7d0SLori Alt dsl_dataset_t *ds, *snapds; 7649e69d7d0SLori Alt avl_tree_t *guid_map = arg; 7659e69d7d0SLori Alt guid_map_entry_t *gmep; 7669e69d7d0SLori Alt dsl_pool_t *dp; 7679e69d7d0SLori Alt int err; 7689e69d7d0SLori Alt uint64_t lastobj, firstobj; 7699e69d7d0SLori Alt 7709e69d7d0SLori Alt if (dsl_dataset_hold(name, FTAG, &ds) != 0) 7719e69d7d0SLori Alt return (0); 7729e69d7d0SLori Alt 7739e69d7d0SLori Alt dp = ds->ds_dir->dd_pool; 7749e69d7d0SLori Alt rw_enter(&dp->dp_config_rwlock, RW_READER); 7759e69d7d0SLori Alt firstobj = ds->ds_dir->dd_phys->dd_origin_obj; 7769e69d7d0SLori Alt lastobj = ds->ds_phys->ds_prev_snap_obj; 7779e69d7d0SLori Alt 7789e69d7d0SLori Alt while (lastobj != firstobj) { 7799e69d7d0SLori Alt err = dsl_dataset_hold_obj(dp, lastobj, guid_map, &snapds); 7809e69d7d0SLori Alt if (err) { 7819e69d7d0SLori Alt /* 7829e69d7d0SLori Alt * Skip this snapshot and move on. It's not 7839e69d7d0SLori Alt * clear why this would ever happen, but the 7849e69d7d0SLori Alt * remainder of the snapshot streadm can be 7859e69d7d0SLori Alt * processed. 7869e69d7d0SLori Alt */ 7879e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 7889e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 7899e69d7d0SLori Alt return (0); 7909e69d7d0SLori Alt } 7919e69d7d0SLori Alt 7929e69d7d0SLori Alt gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 7939e69d7d0SLori Alt gmep->guid = snapds->ds_phys->ds_guid; 7949e69d7d0SLori Alt gmep->gme_ds = snapds; 7959e69d7d0SLori Alt avl_add(guid_map, gmep); 7969e69d7d0SLori Alt lastobj = snapds->ds_phys->ds_prev_snap_obj; 7979e69d7d0SLori Alt } 7989e69d7d0SLori Alt 7999e69d7d0SLori Alt rw_exit(&dp->dp_config_rwlock); 8009e69d7d0SLori Alt dsl_dataset_rele(ds, FTAG); 8019e69d7d0SLori Alt 8029e69d7d0SLori Alt return (0); 8039e69d7d0SLori Alt } 8049e69d7d0SLori Alt 805efb80947Sahrens static void * 806efb80947Sahrens restore_read(struct restorearg *ra, int len) 807efb80947Sahrens { 808efb80947Sahrens void *rv; 8093cb34c60Sahrens int done = 0; 810efb80947Sahrens 811efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 812efb80947Sahrens ASSERT3U(len % 8, ==, 0); 813efb80947Sahrens 8143cb34c60Sahrens while (done < len) { 815efb80947Sahrens ssize_t resid; 816efb80947Sahrens 817efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 8183cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 819efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 820efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 821efb80947Sahrens 8223cb34c60Sahrens if (resid == len - done) 823efb80947Sahrens ra->err = EINVAL; 8243cb34c60Sahrens ra->voff += len - done - resid; 8253cb34c60Sahrens done = len - resid; 826efb80947Sahrens if (ra->err) 827efb80947Sahrens return (NULL); 828efb80947Sahrens } 829efb80947Sahrens 8303cb34c60Sahrens ASSERT3U(done, ==, len); 8313cb34c60Sahrens rv = ra->buf; 832efb80947Sahrens if (ra->byteswap) 8333cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 834efb80947Sahrens else 8353cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 836efb80947Sahrens return (rv); 837efb80947Sahrens } 838efb80947Sahrens 839efb80947Sahrens static void 840efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 841efb80947Sahrens { 842efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 843efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 844efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 8453cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 846efb80947Sahrens switch (drr->drr_type) { 847efb80947Sahrens case DRR_BEGIN: 848efb80947Sahrens DO64(drr_begin.drr_magic); 8499e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 850efb80947Sahrens DO64(drr_begin.drr_creation_time); 851efb80947Sahrens DO32(drr_begin.drr_type); 8523cb34c60Sahrens DO32(drr_begin.drr_flags); 853efb80947Sahrens DO64(drr_begin.drr_toguid); 854efb80947Sahrens DO64(drr_begin.drr_fromguid); 855efb80947Sahrens break; 856efb80947Sahrens case DRR_OBJECT: 857efb80947Sahrens DO64(drr_object.drr_object); 858efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 859efb80947Sahrens DO32(drr_object.drr_type); 860efb80947Sahrens DO32(drr_object.drr_bonustype); 861efb80947Sahrens DO32(drr_object.drr_blksz); 862efb80947Sahrens DO32(drr_object.drr_bonuslen); 8639e69d7d0SLori Alt DO64(drr_object.drr_toguid); 864efb80947Sahrens break; 865efb80947Sahrens case DRR_FREEOBJECTS: 866efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 867efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 8689e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 869efb80947Sahrens break; 870efb80947Sahrens case DRR_WRITE: 871efb80947Sahrens DO64(drr_write.drr_object); 872efb80947Sahrens DO32(drr_write.drr_type); 873efb80947Sahrens DO64(drr_write.drr_offset); 874efb80947Sahrens DO64(drr_write.drr_length); 8759e69d7d0SLori Alt DO64(drr_write.drr_toguid); 8769e69d7d0SLori Alt DO64(drr_write.drr_blkcksum.zc_word[0]); 8779e69d7d0SLori Alt DO64(drr_write.drr_blkcksum.zc_word[1]); 8789e69d7d0SLori Alt DO64(drr_write.drr_blkcksum.zc_word[2]); 8799e69d7d0SLori Alt DO64(drr_write.drr_blkcksum.zc_word[3]); 8809e69d7d0SLori Alt break; 8819e69d7d0SLori Alt case DRR_WRITE_BYREF: 8829e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 8839e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 8849e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 8859e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 8869e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 8879e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 8889e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 8899e69d7d0SLori Alt DO64(drr_write_byref.drr_blkcksum.zc_word[0]); 8909e69d7d0SLori Alt DO64(drr_write_byref.drr_blkcksum.zc_word[1]); 8919e69d7d0SLori Alt DO64(drr_write_byref.drr_blkcksum.zc_word[2]); 8929e69d7d0SLori Alt DO64(drr_write_byref.drr_blkcksum.zc_word[3]); 893efb80947Sahrens break; 894efb80947Sahrens case DRR_FREE: 895efb80947Sahrens DO64(drr_free.drr_object); 896efb80947Sahrens DO64(drr_free.drr_offset); 897efb80947Sahrens DO64(drr_free.drr_length); 8989e69d7d0SLori Alt DO64(drr_free.drr_toguid); 899efb80947Sahrens break; 900efb80947Sahrens case DRR_END: 901efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 902efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 903efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 904efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 9059e69d7d0SLori Alt DO64(drr_end.drr_toguid); 906efb80947Sahrens break; 907efb80947Sahrens } 908efb80947Sahrens #undef DO64 909efb80947Sahrens #undef DO32 910efb80947Sahrens } 911efb80947Sahrens 912efb80947Sahrens static int 913efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 914efb80947Sahrens { 915efb80947Sahrens int err; 916efb80947Sahrens dmu_tx_t *tx; 917adee0b6fSTim Haley void *data = NULL; 918efb80947Sahrens 919efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 920efb80947Sahrens drro->drr_type >= DMU_OT_NUMTYPES || 921efb80947Sahrens drro->drr_bonustype >= DMU_OT_NUMTYPES || 9229e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 923efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 924efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 925efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 926efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 927efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 928efb80947Sahrens return (EINVAL); 929efb80947Sahrens } 930efb80947Sahrens 9312bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 9322bf405a2SMark Maybee 9332bf405a2SMark Maybee if (err != 0 && err != ENOENT) 9342bf405a2SMark Maybee return (EINVAL); 9352bf405a2SMark Maybee 936adee0b6fSTim Haley if (drro->drr_bonuslen) { 937adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 938adee0b6fSTim Haley if (ra->err) 939adee0b6fSTim Haley return (ra->err); 940adee0b6fSTim Haley } 941adee0b6fSTim Haley 942efb80947Sahrens if (err == ENOENT) { 943efb80947Sahrens /* currently free, want to be allocated */ 9442bf405a2SMark Maybee tx = dmu_tx_create(os); 945efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 946efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 947efb80947Sahrens if (err) { 948efb80947Sahrens dmu_tx_abort(tx); 949efb80947Sahrens return (err); 950efb80947Sahrens } 951efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 952efb80947Sahrens drro->drr_type, drro->drr_blksz, 953efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 9542bf405a2SMark Maybee dmu_tx_commit(tx); 955efb80947Sahrens } else { 956efb80947Sahrens /* currently allocated, want to be allocated */ 957efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 958efb80947Sahrens drro->drr_type, drro->drr_blksz, 9592bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 960efb80947Sahrens } 9612bf405a2SMark Maybee if (err) 962efb80947Sahrens return (EINVAL); 9632bf405a2SMark Maybee 9642bf405a2SMark Maybee tx = dmu_tx_create(os); 9652bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 9662bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 9672bf405a2SMark Maybee if (err) { 9682bf405a2SMark Maybee dmu_tx_abort(tx); 9692bf405a2SMark Maybee return (err); 970efb80947Sahrens } 971efb80947Sahrens 9729e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 9739e69d7d0SLori Alt tx); 974efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 975efb80947Sahrens 976adee0b6fSTim Haley if (data != NULL) { 977efb80947Sahrens dmu_buf_t *db; 978adee0b6fSTim Haley 979efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 980efb80947Sahrens dmu_buf_will_dirty(db, tx); 981efb80947Sahrens 9821934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 9831934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 984efb80947Sahrens if (ra->byteswap) { 985efb80947Sahrens dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 986efb80947Sahrens drro->drr_bonuslen); 987efb80947Sahrens } 988efb80947Sahrens dmu_buf_rele(db, FTAG); 989efb80947Sahrens } 990efb80947Sahrens dmu_tx_commit(tx); 991efb80947Sahrens return (0); 992efb80947Sahrens } 993efb80947Sahrens 994efb80947Sahrens /* ARGSUSED */ 995efb80947Sahrens static int 996efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 997efb80947Sahrens struct drr_freeobjects *drrfo) 998efb80947Sahrens { 999efb80947Sahrens uint64_t obj; 1000efb80947Sahrens 1001efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1002efb80947Sahrens return (EINVAL); 1003efb80947Sahrens 1004efb80947Sahrens for (obj = drrfo->drr_firstobj; 1005432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1006432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1007efb80947Sahrens int err; 1008efb80947Sahrens 1009efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1010efb80947Sahrens continue; 1011efb80947Sahrens 1012cdb0ab79Smaybee err = dmu_free_object(os, obj); 1013cdb0ab79Smaybee if (err) 1014efb80947Sahrens return (err); 1015efb80947Sahrens } 1016efb80947Sahrens return (0); 1017efb80947Sahrens } 1018efb80947Sahrens 1019efb80947Sahrens static int 1020efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1021efb80947Sahrens struct drr_write *drrw) 1022efb80947Sahrens { 1023efb80947Sahrens dmu_tx_t *tx; 1024efb80947Sahrens void *data; 1025efb80947Sahrens int err; 1026efb80947Sahrens 1027efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1028efb80947Sahrens drrw->drr_type >= DMU_OT_NUMTYPES) 1029efb80947Sahrens return (EINVAL); 1030efb80947Sahrens 1031efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1032efb80947Sahrens if (data == NULL) 1033efb80947Sahrens return (ra->err); 1034efb80947Sahrens 1035efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1036efb80947Sahrens return (EINVAL); 1037efb80947Sahrens 1038efb80947Sahrens tx = dmu_tx_create(os); 1039efb80947Sahrens 1040efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1041efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1042efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1043efb80947Sahrens if (err) { 1044efb80947Sahrens dmu_tx_abort(tx); 1045efb80947Sahrens return (err); 1046efb80947Sahrens } 1047efb80947Sahrens if (ra->byteswap) 1048efb80947Sahrens dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 1049efb80947Sahrens dmu_write(os, drrw->drr_object, 1050efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1051efb80947Sahrens dmu_tx_commit(tx); 1052efb80947Sahrens return (0); 1053efb80947Sahrens } 1054efb80947Sahrens 10559e69d7d0SLori Alt /* 10569e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 10579e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 10589e69d7d0SLori Alt * system because it came in earlier in the stream. This function 10599e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 10609e69d7d0SLori Alt * data from the stream to fulfill this write. 10619e69d7d0SLori Alt */ 10629e69d7d0SLori Alt static int 10639e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 10649e69d7d0SLori Alt struct drr_write_byref *drrwbr) 10659e69d7d0SLori Alt { 10669e69d7d0SLori Alt dmu_tx_t *tx; 10679e69d7d0SLori Alt int err; 10689e69d7d0SLori Alt guid_map_entry_t gmesrch; 10699e69d7d0SLori Alt guid_map_entry_t *gmep; 10709e69d7d0SLori Alt avl_index_t where; 10719e69d7d0SLori Alt objset_t *ref_os = NULL; 10729e69d7d0SLori Alt dmu_buf_t *dbp; 10739e69d7d0SLori Alt 10749e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 10759e69d7d0SLori Alt return (EINVAL); 10769e69d7d0SLori Alt 10779e69d7d0SLori Alt /* 10789e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 10799e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 10809e69d7d0SLori Alt */ 10819e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 10829e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 10839e69d7d0SLori Alt if ((gmep = avl_find(&ra->guid_to_ds_map, &gmesrch, 10849e69d7d0SLori Alt &where)) == NULL) { 10859e69d7d0SLori Alt return (EINVAL); 10869e69d7d0SLori Alt } 10879e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 10889e69d7d0SLori Alt return (EINVAL); 10899e69d7d0SLori Alt } else { 10909e69d7d0SLori Alt ref_os = os; 10919e69d7d0SLori Alt } 10929e69d7d0SLori Alt 10939e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 10949e69d7d0SLori Alt drrwbr->drr_refoffset, FTAG, &dbp)) 10959e69d7d0SLori Alt return (err); 10969e69d7d0SLori Alt 10979e69d7d0SLori Alt tx = dmu_tx_create(os); 10989e69d7d0SLori Alt 10999e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 11009e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 11019e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 11029e69d7d0SLori Alt if (err) { 11039e69d7d0SLori Alt dmu_tx_abort(tx); 11049e69d7d0SLori Alt return (err); 11059e69d7d0SLori Alt } 11069e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 11079e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 11089e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 11099e69d7d0SLori Alt dmu_tx_commit(tx); 11109e69d7d0SLori Alt return (0); 11119e69d7d0SLori Alt } 11129e69d7d0SLori Alt 1113efb80947Sahrens /* ARGSUSED */ 1114efb80947Sahrens static int 1115efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1116efb80947Sahrens struct drr_free *drrf) 1117efb80947Sahrens { 1118efb80947Sahrens int err; 1119efb80947Sahrens 1120efb80947Sahrens if (drrf->drr_length != -1ULL && 1121efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1122efb80947Sahrens return (EINVAL); 1123efb80947Sahrens 1124efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1125efb80947Sahrens return (EINVAL); 1126efb80947Sahrens 1127cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1128efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1129efb80947Sahrens return (err); 1130efb80947Sahrens } 1131efb80947Sahrens 11323cb34c60Sahrens /* 11333cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 11343cb34c60Sahrens */ 1135efb80947Sahrens int 11363cb34c60Sahrens dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp) 1137efb80947Sahrens { 11383cb34c60Sahrens struct restorearg ra = { 0 }; 1139efb80947Sahrens dmu_replay_record_t *drr; 11403cb34c60Sahrens objset_t *os; 11413cb34c60Sahrens zio_cksum_t pcksum; 11429e69d7d0SLori Alt guid_map_entry_t *gmep; 11439e69d7d0SLori Alt int featureflags; 1144efb80947Sahrens 11453cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1146efb80947Sahrens ra.byteswap = TRUE; 1147efb80947Sahrens 11483cb34c60Sahrens { 11493cb34c60Sahrens /* compute checksum of drr_begin record */ 11503cb34c60Sahrens dmu_replay_record_t *drr; 11513cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 11523cb34c60Sahrens 11533cb34c60Sahrens drr->drr_type = DRR_BEGIN; 11543cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 11553cb34c60Sahrens if (ra.byteswap) { 11563cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 11573cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 11583cb34c60Sahrens } else { 11593cb34c60Sahrens fletcher_4_incremental_native(drr, 11603cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 11613cb34c60Sahrens } 11623cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1163efb80947Sahrens } 1164efb80947Sahrens 1165efb80947Sahrens if (ra.byteswap) { 11663cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1167efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 11689e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1169efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1170efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1171efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1172efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1173efb80947Sahrens } 1174efb80947Sahrens 11753cb34c60Sahrens ra.vp = vp; 11763cb34c60Sahrens ra.voff = *voffp; 11773cb34c60Sahrens ra.bufsize = 1<<20; 11783cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1179efb80947Sahrens 11803cb34c60Sahrens /* these were verified in dmu_recv_begin */ 11819e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 11829e69d7d0SLori Alt DMU_SUBSTREAM); 11833cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1184efb80947Sahrens 1185efb80947Sahrens /* 1186efb80947Sahrens * Open the objset we are modifying. 1187efb80947Sahrens */ 1188503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1189efb80947Sahrens 11903cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1191efb80947Sahrens 11929e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 11939e69d7d0SLori Alt 11949e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 11959e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 11969e69d7d0SLori Alt avl_create(&ra.guid_to_ds_map, guid_compare, 11979e69d7d0SLori Alt sizeof (guid_map_entry_t), 11989e69d7d0SLori Alt offsetof(guid_map_entry_t, avlnode)); 11999e69d7d0SLori Alt (void) dmu_objset_find(drc->drc_top_ds, find_ds_by_guid, 12009e69d7d0SLori Alt (void *)&ra.guid_to_ds_map, 12019e69d7d0SLori Alt DS_FIND_CHILDREN); 12029e69d7d0SLori Alt } 12039e69d7d0SLori Alt 1204efb80947Sahrens /* 1205efb80947Sahrens * Read records and process them. 1206efb80947Sahrens */ 12073cb34c60Sahrens pcksum = ra.cksum; 1208efb80947Sahrens while (ra.err == 0 && 1209efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1210efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1211efb80947Sahrens ra.err = EINTR; 1212efb80947Sahrens goto out; 1213efb80947Sahrens } 1214efb80947Sahrens 1215efb80947Sahrens if (ra.byteswap) 1216efb80947Sahrens backup_byteswap(drr); 1217efb80947Sahrens 1218efb80947Sahrens switch (drr->drr_type) { 1219efb80947Sahrens case DRR_OBJECT: 1220efb80947Sahrens { 1221efb80947Sahrens /* 1222efb80947Sahrens * We need to make a copy of the record header, 1223efb80947Sahrens * because restore_{object,write} may need to 1224efb80947Sahrens * restore_read(), which will invalidate drr. 1225efb80947Sahrens */ 1226efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1227efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1228efb80947Sahrens break; 1229efb80947Sahrens } 1230efb80947Sahrens case DRR_FREEOBJECTS: 1231efb80947Sahrens { 1232efb80947Sahrens struct drr_freeobjects drrfo = 1233efb80947Sahrens drr->drr_u.drr_freeobjects; 1234efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1235efb80947Sahrens break; 1236efb80947Sahrens } 1237efb80947Sahrens case DRR_WRITE: 1238efb80947Sahrens { 1239efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1240efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1241efb80947Sahrens break; 1242efb80947Sahrens } 12439e69d7d0SLori Alt case DRR_WRITE_BYREF: 12449e69d7d0SLori Alt { 12459e69d7d0SLori Alt struct drr_write_byref drrwbr = 12469e69d7d0SLori Alt drr->drr_u.drr_write_byref; 12479e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 12489e69d7d0SLori Alt break; 12499e69d7d0SLori Alt } 1250efb80947Sahrens case DRR_FREE: 1251efb80947Sahrens { 1252efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1253efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1254efb80947Sahrens break; 1255efb80947Sahrens } 1256efb80947Sahrens case DRR_END: 1257efb80947Sahrens { 1258efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1259efb80947Sahrens /* 1260efb80947Sahrens * We compare against the *previous* checksum 1261efb80947Sahrens * value, because the stored checksum is of 1262efb80947Sahrens * everything before the DRR_END record. 1263efb80947Sahrens */ 1264137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1265efb80947Sahrens ra.err = ECKSUM; 1266efb80947Sahrens goto out; 1267efb80947Sahrens } 1268efb80947Sahrens default: 1269efb80947Sahrens ra.err = EINVAL; 1270efb80947Sahrens goto out; 1271efb80947Sahrens } 12723cb34c60Sahrens pcksum = ra.cksum; 1273efb80947Sahrens } 1274137fa067Sahrens ASSERT(ra.err != 0); 1275efb80947Sahrens 1276efb80947Sahrens out: 12773cb34c60Sahrens if (ra.err != 0) { 1278efb80947Sahrens /* 1279f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1280f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1281efb80947Sahrens */ 12823cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1283f4b94bdeSMatthew Ahrens 1284842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1285842727c2SChris Kirby B_FALSE); 1286f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1287f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1288f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1289f4b94bdeSMatthew Ahrens } 1290efb80947Sahrens } 1291efb80947Sahrens 12929e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 12939e69d7d0SLori Alt void *cookie = NULL; 12949e69d7d0SLori Alt 12959e69d7d0SLori Alt while (gmep = avl_destroy_nodes(&ra.guid_to_ds_map, &cookie)) { 12969e69d7d0SLori Alt dsl_dataset_rele(gmep->gme_ds, &ra.guid_to_ds_map); 12979e69d7d0SLori Alt kmem_free(gmep, sizeof (guid_map_entry_t)); 12989e69d7d0SLori Alt } 12999e69d7d0SLori Alt avl_destroy(&ra.guid_to_ds_map); 13009e69d7d0SLori Alt } 13019e69d7d0SLori Alt 1302efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 13033cb34c60Sahrens *voffp = ra.voff; 1304efb80947Sahrens return (ra.err); 1305efb80947Sahrens } 1306f18faf3fSek 13073cb34c60Sahrens struct recvendsyncarg { 13083cb34c60Sahrens char *tosnap; 13093cb34c60Sahrens uint64_t creation_time; 13103cb34c60Sahrens uint64_t toguid; 13113cb34c60Sahrens }; 13123cb34c60Sahrens 13133cb34c60Sahrens static int 13143cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 13153cb34c60Sahrens { 13163cb34c60Sahrens dsl_dataset_t *ds = arg1; 13173cb34c60Sahrens struct recvendsyncarg *resa = arg2; 13183cb34c60Sahrens 13193cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 13203cb34c60Sahrens } 13213cb34c60Sahrens 13223cb34c60Sahrens static void 13233cb34c60Sahrens recv_end_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 13243cb34c60Sahrens { 13253cb34c60Sahrens dsl_dataset_t *ds = arg1; 13263cb34c60Sahrens struct recvendsyncarg *resa = arg2; 13273cb34c60Sahrens 13283cb34c60Sahrens dsl_dataset_snapshot_sync(ds, resa->tosnap, cr, tx); 13293cb34c60Sahrens 13303cb34c60Sahrens /* set snapshot's creation time and guid */ 13313cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 13323cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 13333cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 13343cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 13353cb34c60Sahrens 13363cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 13373cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 13383cb34c60Sahrens } 13393cb34c60Sahrens 1340ae46e4c7SMatthew Ahrens static int 1341ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1342f18faf3fSek { 1343745cd3c5Smaybee struct recvendsyncarg resa; 1344745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 1345745cd3c5Smaybee int err; 1346f18faf3fSek 13473cb34c60Sahrens /* 1348ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1349ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1350ae46e4c7SMatthew Ahrens * can close it. 13513cb34c60Sahrens */ 1352745cd3c5Smaybee txg_wait_synced(ds->ds_dir->dd_pool, 0); 13533cb34c60Sahrens 1354ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1355ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1356ae46e4c7SMatthew Ahrens drc->drc_force); 1357ae46e4c7SMatthew Ahrens if (err) 1358ae46e4c7SMatthew Ahrens goto out; 1359ae46e4c7SMatthew Ahrens } else { 1360ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1361ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1362842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1363842727c2SChris Kirby B_FALSE); 1364ae46e4c7SMatthew Ahrens return (EBUSY); 13653cb34c60Sahrens } 13663cb34c60Sahrens 1367745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1368745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1369745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 13703cb34c60Sahrens 1371745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1372745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1373745cd3c5Smaybee if (err) { 1374ae46e4c7SMatthew Ahrens /* swap back */ 1375ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 13763cb34c60Sahrens } 13773cb34c60Sahrens 1378ae46e4c7SMatthew Ahrens out: 1379ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1380745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 1381ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 1382f18faf3fSek return (err); 1383f18faf3fSek } 1384ae46e4c7SMatthew Ahrens 1385ae46e4c7SMatthew Ahrens static int 1386ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1387ae46e4c7SMatthew Ahrens { 1388ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1389ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1390ae46e4c7SMatthew Ahrens int err; 1391ae46e4c7SMatthew Ahrens 1392ae46e4c7SMatthew Ahrens /* 1393ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1394ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1395ae46e4c7SMatthew Ahrens * can close it. 1396ae46e4c7SMatthew Ahrens */ 1397ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1398ae46e4c7SMatthew Ahrens 1399ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1400ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1401ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1402ae46e4c7SMatthew Ahrens 1403ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1404ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1405ae46e4c7SMatthew Ahrens if (err) { 1406ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1407ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1408ae46e4c7SMatthew Ahrens } else { 1409ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1410ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1411ae46e4c7SMatthew Ahrens } 1412ae46e4c7SMatthew Ahrens return (err); 1413ae46e4c7SMatthew Ahrens } 1414ae46e4c7SMatthew Ahrens 1415ae46e4c7SMatthew Ahrens int 1416ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1417ae46e4c7SMatthew Ahrens { 1418ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1419ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1420ae46e4c7SMatthew Ahrens else 1421ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1422ae46e4c7SMatthew Ahrens } 1423