1efb80947Sahrens /* 2efb80947Sahrens * CDDL HEADER START 3efb80947Sahrens * 4efb80947Sahrens * The contents of this file are subject to the terms of the 5efb80947Sahrens * Common Development and Distribution License (the "License"). 6efb80947Sahrens * You may not use this file except in compliance with the License. 7efb80947Sahrens * 8efb80947Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9efb80947Sahrens * or http://www.opensolaris.org/os/licensing. 10efb80947Sahrens * See the License for the specific language governing permissions 11efb80947Sahrens * and limitations under the License. 12efb80947Sahrens * 13efb80947Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14efb80947Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15efb80947Sahrens * If applicable, add the following below this CDDL HEADER, with the 16efb80947Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17efb80947Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18efb80947Sahrens * 19efb80947Sahrens * CDDL HEADER END 20efb80947Sahrens */ 21efb80947Sahrens /* 22dc7cd546SMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23ec5cf9d5SAlexander Stetsenko * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 24ad135b5dSChristopher Siden * Copyright (c) 2012 by Delphix. All rights reserved. 254e3c9f44SBill Pijewski * Copyright (c) 2012, Joyent, Inc. All rights reserved. 26ec5cf9d5SAlexander Stetsenko */ 27efb80947Sahrens 28efb80947Sahrens #include <sys/dmu.h> 29efb80947Sahrens #include <sys/dmu_impl.h> 30efb80947Sahrens #include <sys/dmu_tx.h> 31efb80947Sahrens #include <sys/dbuf.h> 32efb80947Sahrens #include <sys/dnode.h> 33efb80947Sahrens #include <sys/zfs_context.h> 34efb80947Sahrens #include <sys/dmu_objset.h> 35efb80947Sahrens #include <sys/dmu_traverse.h> 36efb80947Sahrens #include <sys/dsl_dataset.h> 37efb80947Sahrens #include <sys/dsl_dir.h> 3892241e0bSTom Erickson #include <sys/dsl_prop.h> 39efb80947Sahrens #include <sys/dsl_pool.h> 40efb80947Sahrens #include <sys/dsl_synctask.h> 41efb80947Sahrens #include <sys/zfs_ioctl.h> 42efb80947Sahrens #include <sys/zap.h> 43efb80947Sahrens #include <sys/zio_checksum.h> 44dc7cd546SMark Shellenbaum #include <sys/zfs_znode.h> 45cde58dbcSMatthew Ahrens #include <zfs_fletcher.h> 469e69d7d0SLori Alt #include <sys/avl.h> 478e714474SLori Alt #include <sys/ddt.h> 48c99e4bdcSChris Kirby #include <sys/zfs_onexit.h> 49efb80947Sahrens 5019b94df9SMatthew Ahrens /* Set this tunable to TRUE to replace corrupt data with 0x2f5baddb10c */ 5119b94df9SMatthew Ahrens int zfs_send_corrupt_data = B_FALSE; 5219b94df9SMatthew Ahrens 533cb34c60Sahrens static char *dmu_recv_tag = "dmu_recv_tag"; 543cb34c60Sahrens 55efb80947Sahrens static int 564e3c9f44SBill Pijewski dump_bytes(dmu_sendarg_t *dsp, void *buf, int len) 57efb80947Sahrens { 584e3c9f44SBill Pijewski dsl_dataset_t *ds = dsp->dsa_os->os_dsl_dataset; 59efb80947Sahrens ssize_t resid; /* have to get resid to get detailed errno */ 60*fb09f5aaSMadhav Suresh ASSERT0(len % 8); 61efb80947Sahrens 624e3c9f44SBill Pijewski fletcher_4_incremental_native(buf, len, &dsp->dsa_zc); 634e3c9f44SBill Pijewski dsp->dsa_err = vn_rdwr(UIO_WRITE, dsp->dsa_vp, 64efb80947Sahrens (caddr_t)buf, len, 65efb80947Sahrens 0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid); 664e3c9f44SBill Pijewski 674e3c9f44SBill Pijewski mutex_enter(&ds->ds_sendstream_lock); 684e3c9f44SBill Pijewski *dsp->dsa_off += len; 694e3c9f44SBill Pijewski mutex_exit(&ds->ds_sendstream_lock); 704e3c9f44SBill Pijewski 714e3c9f44SBill Pijewski return (dsp->dsa_err); 72efb80947Sahrens } 73efb80947Sahrens 74efb80947Sahrens static int 754e3c9f44SBill Pijewski dump_free(dmu_sendarg_t *dsp, uint64_t object, uint64_t offset, 76efb80947Sahrens uint64_t length) 77efb80947Sahrens { 784e3c9f44SBill Pijewski struct drr_free *drrf = &(dsp->dsa_drr->drr_u.drr_free); 799e69d7d0SLori Alt 80534029e5SSimon Klinkert if (length != -1ULL && offset + length < offset) 81534029e5SSimon Klinkert length = -1ULL; 82534029e5SSimon Klinkert 839e69d7d0SLori Alt /* 849e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 859e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 869e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 879e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 889e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 899e69d7d0SLori Alt */ 904e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE && 914e3c9f44SBill Pijewski dsp->dsa_pending_op != PENDING_FREE) { 924e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 934e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 949e69d7d0SLori Alt return (EINTR); 954e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 969e69d7d0SLori Alt } 979e69d7d0SLori Alt 984e3c9f44SBill Pijewski if (dsp->dsa_pending_op == PENDING_FREE) { 999e69d7d0SLori Alt /* 1009e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 1019e69d7d0SLori Alt * (because dump_dnode is the only place where this 1029e69d7d0SLori Alt * function is called with a -1, and only after flushing 1039e69d7d0SLori Alt * any pending record). 1049e69d7d0SLori Alt */ 1059e69d7d0SLori Alt ASSERT(length != -1ULL); 1069e69d7d0SLori Alt /* 1079e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1089e69d7d0SLori Alt * with pending one. 1099e69d7d0SLori Alt */ 1109e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1119e69d7d0SLori Alt drrf->drr_length == offset) { 1129e69d7d0SLori Alt drrf->drr_length += length; 1139e69d7d0SLori Alt return (0); 1149e69d7d0SLori Alt } else { 1159e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1164e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1179e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1189e69d7d0SLori Alt return (EINTR); 1194e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 1209e69d7d0SLori Alt } 1219e69d7d0SLori Alt } 1229e69d7d0SLori Alt /* create a FREE record and make it pending */ 1234e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 1244e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_FREE; 1259e69d7d0SLori Alt drrf->drr_object = object; 1269e69d7d0SLori Alt drrf->drr_offset = offset; 1279e69d7d0SLori Alt drrf->drr_length = length; 1284e3c9f44SBill Pijewski drrf->drr_toguid = dsp->dsa_toguid; 1299e69d7d0SLori Alt if (length == -1ULL) { 1304e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1314e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 1329e69d7d0SLori Alt return (EINTR); 1339e69d7d0SLori Alt } else { 1344e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_FREE; 1359e69d7d0SLori Alt } 136efb80947Sahrens 137efb80947Sahrens return (0); 138efb80947Sahrens } 139efb80947Sahrens 140efb80947Sahrens static int 1414e3c9f44SBill Pijewski dump_data(dmu_sendarg_t *dsp, dmu_object_type_t type, 1428e714474SLori Alt uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data) 143efb80947Sahrens { 1444e3c9f44SBill Pijewski struct drr_write *drrw = &(dsp->dsa_drr->drr_u.drr_write); 1459e69d7d0SLori Alt 1468e714474SLori Alt 1479e69d7d0SLori Alt /* 1489e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1499e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1509e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1519e69d7d0SLori Alt * of different types. 1529e69d7d0SLori Alt */ 1534e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) { 1544e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1554e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 1569e69d7d0SLori Alt return (EINTR); 1574e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 1589e69d7d0SLori Alt } 159efb80947Sahrens /* write a DATA record */ 1604e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 1614e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_WRITE; 1629e69d7d0SLori Alt drrw->drr_object = object; 1639e69d7d0SLori Alt drrw->drr_type = type; 1649e69d7d0SLori Alt drrw->drr_offset = offset; 1659e69d7d0SLori Alt drrw->drr_length = blksz; 1664e3c9f44SBill Pijewski drrw->drr_toguid = dsp->dsa_toguid; 1678e714474SLori Alt drrw->drr_checksumtype = BP_GET_CHECKSUM(bp); 1688e714474SLori Alt if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup) 1698e714474SLori Alt drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP; 1708e714474SLori Alt DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp)); 1718e714474SLori Alt DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp)); 1728e714474SLori Alt DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp)); 1738e714474SLori Alt drrw->drr_key.ddk_cksum = bp->blk_cksum; 174efb80947Sahrens 1754e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0) 176efb80947Sahrens return (EINTR); 1774e3c9f44SBill Pijewski if (dump_bytes(dsp, data, blksz) != 0) 178efb80947Sahrens return (EINTR); 179efb80947Sahrens return (0); 180efb80947Sahrens } 181efb80947Sahrens 1820a586ceaSMark Shellenbaum static int 1834e3c9f44SBill Pijewski dump_spill(dmu_sendarg_t *dsp, uint64_t object, int blksz, void *data) 1840a586ceaSMark Shellenbaum { 1854e3c9f44SBill Pijewski struct drr_spill *drrs = &(dsp->dsa_drr->drr_u.drr_spill); 1860a586ceaSMark Shellenbaum 1874e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) { 1884e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1894e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 1900a586ceaSMark Shellenbaum return (EINTR); 1914e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 1920a586ceaSMark Shellenbaum } 1930a586ceaSMark Shellenbaum 1940a586ceaSMark Shellenbaum /* write a SPILL record */ 1954e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 1964e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_SPILL; 1970a586ceaSMark Shellenbaum drrs->drr_object = object; 1980a586ceaSMark Shellenbaum drrs->drr_length = blksz; 1994e3c9f44SBill Pijewski drrs->drr_toguid = dsp->dsa_toguid; 2000a586ceaSMark Shellenbaum 2014e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t))) 2020a586ceaSMark Shellenbaum return (EINTR); 2034e3c9f44SBill Pijewski if (dump_bytes(dsp, data, blksz)) 2040a586ceaSMark Shellenbaum return (EINTR); 2050a586ceaSMark Shellenbaum return (0); 2060a586ceaSMark Shellenbaum } 2070a586ceaSMark Shellenbaum 208efb80947Sahrens static int 2094e3c9f44SBill Pijewski dump_freeobjects(dmu_sendarg_t *dsp, uint64_t firstobj, uint64_t numobjs) 210efb80947Sahrens { 2114e3c9f44SBill Pijewski struct drr_freeobjects *drrfo = &(dsp->dsa_drr->drr_u.drr_freeobjects); 2129e69d7d0SLori Alt 2139e69d7d0SLori Alt /* 2149e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 2159e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 2169e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 2179e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 2189e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 2199e69d7d0SLori Alt */ 2204e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE && 2214e3c9f44SBill Pijewski dsp->dsa_pending_op != PENDING_FREEOBJECTS) { 2224e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 2234e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 2249e69d7d0SLori Alt return (EINTR); 2254e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 2269e69d7d0SLori Alt } 2274e3c9f44SBill Pijewski if (dsp->dsa_pending_op == PENDING_FREEOBJECTS) { 2289e69d7d0SLori Alt /* 2299e69d7d0SLori Alt * See whether this free object array can be aggregated 2309e69d7d0SLori Alt * with pending one 2319e69d7d0SLori Alt */ 2329e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2339e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2349e69d7d0SLori Alt return (0); 2359e69d7d0SLori Alt } else { 2369e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2374e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 2389e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2399e69d7d0SLori Alt return (EINTR); 2404e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 2419e69d7d0SLori Alt } 2429e69d7d0SLori Alt } 2439e69d7d0SLori Alt 244efb80947Sahrens /* write a FREEOBJECTS record */ 2454e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 2464e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_FREEOBJECTS; 2479e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2489e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2494e3c9f44SBill Pijewski drrfo->drr_toguid = dsp->dsa_toguid; 2509e69d7d0SLori Alt 2514e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_FREEOBJECTS; 252efb80947Sahrens 253efb80947Sahrens return (0); 254efb80947Sahrens } 255efb80947Sahrens 256efb80947Sahrens static int 2574e3c9f44SBill Pijewski dump_dnode(dmu_sendarg_t *dsp, uint64_t object, dnode_phys_t *dnp) 258efb80947Sahrens { 2594e3c9f44SBill Pijewski struct drr_object *drro = &(dsp->dsa_drr->drr_u.drr_object); 2609e69d7d0SLori Alt 261efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 2624e3c9f44SBill Pijewski return (dump_freeobjects(dsp, object, 1)); 263efb80947Sahrens 2644e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) { 2654e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 2664e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 2679e69d7d0SLori Alt return (EINTR); 2684e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 2699e69d7d0SLori Alt } 2709e69d7d0SLori Alt 271efb80947Sahrens /* write an OBJECT record */ 2724e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 2734e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_OBJECT; 2749e69d7d0SLori Alt drro->drr_object = object; 2759e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2769e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2779e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2789e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2799e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2809e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2814e3c9f44SBill Pijewski drro->drr_toguid = dsp->dsa_toguid; 2829e69d7d0SLori Alt 2834e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0) 284efb80947Sahrens return (EINTR); 285efb80947Sahrens 2864e3c9f44SBill Pijewski if (dump_bytes(dsp, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 287efb80947Sahrens return (EINTR); 288efb80947Sahrens 289efb80947Sahrens /* free anything past the end of the file */ 2904e3c9f44SBill Pijewski if (dump_free(dsp, object, (dnp->dn_maxblkid + 1) * 291efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 292efb80947Sahrens return (EINTR); 2934e3c9f44SBill Pijewski if (dsp->dsa_err) 294efb80947Sahrens return (EINTR); 295efb80947Sahrens return (0); 296efb80947Sahrens } 297efb80947Sahrens 298efb80947Sahrens #define BP_SPAN(dnp, level) \ 299efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 300efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 301efb80947Sahrens 302b24ab676SJeff Bonwick /* ARGSUSED */ 303efb80947Sahrens static int 3043f9d6ad7SLin Ling backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf, 305b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 306efb80947Sahrens { 3074e3c9f44SBill Pijewski dmu_sendarg_t *dsp = arg; 308efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 309efb80947Sahrens int err = 0; 310efb80947Sahrens 311efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 312efb80947Sahrens return (EINTR); 313efb80947Sahrens 314b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 315b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 31614843421SMatthew Ahrens return (0); 317b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 31888b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 31988b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 3204e3c9f44SBill Pijewski err = dump_freeobjects(dsp, dnobj, span >> DNODE_SHIFT); 321efb80947Sahrens } else if (bp == NULL) { 32288b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 3234e3c9f44SBill Pijewski err = dump_free(dsp, zb->zb_object, zb->zb_blkid * span, span); 32488b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 32588b7b0f2SMatthew Ahrens return (0); 32688b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 32788b7b0f2SMatthew Ahrens dnode_phys_t *blk; 328efb80947Sahrens int i; 329efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 33088b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 33188b7b0f2SMatthew Ahrens arc_buf_t *abuf; 332efb80947Sahrens 3333f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 33488b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 33588b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 33688b7b0f2SMatthew Ahrens return (EIO); 33788b7b0f2SMatthew Ahrens 33888b7b0f2SMatthew Ahrens blk = abuf->b_data; 339efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 34088b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 34188b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 3424e3c9f44SBill Pijewski err = dump_dnode(dsp, dnobj, blk+i); 343efb80947Sahrens if (err) 344efb80947Sahrens break; 345efb80947Sahrens } 34688b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 3470a586ceaSMark Shellenbaum } else if (type == DMU_OT_SA) { 3480a586ceaSMark Shellenbaum uint32_t aflags = ARC_WAIT; 3490a586ceaSMark Shellenbaum arc_buf_t *abuf; 3500a586ceaSMark Shellenbaum int blksz = BP_GET_LSIZE(bp); 3510a586ceaSMark Shellenbaum 3520a586ceaSMark Shellenbaum if (arc_read_nolock(NULL, spa, bp, 3530a586ceaSMark Shellenbaum arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 3540a586ceaSMark Shellenbaum ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 3550a586ceaSMark Shellenbaum return (EIO); 3560a586ceaSMark Shellenbaum 3574e3c9f44SBill Pijewski err = dump_spill(dsp, zb->zb_object, blksz, abuf->b_data); 3580a586ceaSMark Shellenbaum (void) arc_buf_remove_ref(abuf, &abuf); 35988b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 36088b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 36188b7b0f2SMatthew Ahrens arc_buf_t *abuf; 362efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 36388b7b0f2SMatthew Ahrens 3643f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 36588b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 36619b94df9SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) { 36719b94df9SMatthew Ahrens if (zfs_send_corrupt_data) { 36819b94df9SMatthew Ahrens /* Send a block filled with 0x"zfs badd bloc" */ 36919b94df9SMatthew Ahrens abuf = arc_buf_alloc(spa, blksz, &abuf, 37019b94df9SMatthew Ahrens ARC_BUFC_DATA); 37119b94df9SMatthew Ahrens uint64_t *ptr; 37219b94df9SMatthew Ahrens for (ptr = abuf->b_data; 37319b94df9SMatthew Ahrens (char *)ptr < (char *)abuf->b_data + blksz; 37419b94df9SMatthew Ahrens ptr++) 37519b94df9SMatthew Ahrens *ptr = 0x2f5baddb10c; 37619b94df9SMatthew Ahrens } else { 37719b94df9SMatthew Ahrens return (EIO); 37819b94df9SMatthew Ahrens } 37919b94df9SMatthew Ahrens } 38088b7b0f2SMatthew Ahrens 3814e3c9f44SBill Pijewski err = dump_data(dsp, type, zb->zb_object, zb->zb_blkid * blksz, 3828e714474SLori Alt blksz, bp, abuf->b_data); 38388b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 384efb80947Sahrens } 385efb80947Sahrens 386efb80947Sahrens ASSERT(err == 0 || err == EINTR); 387efb80947Sahrens return (err); 388efb80947Sahrens } 389efb80947Sahrens 3904445fffbSMatthew Ahrens /* 3914445fffbSMatthew Ahrens * Return TRUE if 'earlier' is an earlier snapshot in 'later's timeline. 3924445fffbSMatthew Ahrens * For example, they could both be snapshots of the same filesystem, and 3934445fffbSMatthew Ahrens * 'earlier' is before 'later'. Or 'earlier' could be the origin of 3944445fffbSMatthew Ahrens * 'later's filesystem. Or 'earlier' could be an older snapshot in the origin's 3954445fffbSMatthew Ahrens * filesystem. Or 'earlier' could be the origin's origin. 3964445fffbSMatthew Ahrens */ 3974445fffbSMatthew Ahrens static boolean_t 3984445fffbSMatthew Ahrens is_before(dsl_dataset_t *later, dsl_dataset_t *earlier) 3994445fffbSMatthew Ahrens { 4004445fffbSMatthew Ahrens dsl_pool_t *dp = later->ds_dir->dd_pool; 4014445fffbSMatthew Ahrens int error; 4024445fffbSMatthew Ahrens boolean_t ret; 4034445fffbSMatthew Ahrens dsl_dataset_t *origin; 4044445fffbSMatthew Ahrens 4054445fffbSMatthew Ahrens if (earlier->ds_phys->ds_creation_txg >= 4064445fffbSMatthew Ahrens later->ds_phys->ds_creation_txg) 4074445fffbSMatthew Ahrens return (B_FALSE); 4084445fffbSMatthew Ahrens 4094445fffbSMatthew Ahrens if (later->ds_dir == earlier->ds_dir) 4104445fffbSMatthew Ahrens return (B_TRUE); 4114445fffbSMatthew Ahrens if (!dsl_dir_is_clone(later->ds_dir)) 4124445fffbSMatthew Ahrens return (B_FALSE); 4134445fffbSMatthew Ahrens 4144445fffbSMatthew Ahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 4154445fffbSMatthew Ahrens if (later->ds_dir->dd_phys->dd_origin_obj == earlier->ds_object) { 4164445fffbSMatthew Ahrens rw_exit(&dp->dp_config_rwlock); 4174445fffbSMatthew Ahrens return (B_TRUE); 4184445fffbSMatthew Ahrens } 4194445fffbSMatthew Ahrens error = dsl_dataset_hold_obj(dp, 4204445fffbSMatthew Ahrens later->ds_dir->dd_phys->dd_origin_obj, FTAG, &origin); 4214445fffbSMatthew Ahrens rw_exit(&dp->dp_config_rwlock); 4224445fffbSMatthew Ahrens if (error != 0) 4234445fffbSMatthew Ahrens return (B_FALSE); 4244445fffbSMatthew Ahrens ret = is_before(origin, earlier); 4254445fffbSMatthew Ahrens dsl_dataset_rele(origin, FTAG); 4264445fffbSMatthew Ahrens return (ret); 4274445fffbSMatthew Ahrens } 4284445fffbSMatthew Ahrens 429efb80947Sahrens int 4304445fffbSMatthew Ahrens dmu_send(objset_t *tosnap, objset_t *fromsnap, int outfd, vnode_t *vp, 4314445fffbSMatthew Ahrens offset_t *off) 432efb80947Sahrens { 433503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 434503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 435efb80947Sahrens dmu_replay_record_t *drr; 4364e3c9f44SBill Pijewski dmu_sendarg_t *dsp; 437efb80947Sahrens int err; 4383cb34c60Sahrens uint64_t fromtxg = 0; 439efb80947Sahrens 440efb80947Sahrens /* tosnap must be a snapshot */ 441efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 442efb80947Sahrens return (EINVAL); 443efb80947Sahrens 4444445fffbSMatthew Ahrens /* 4454445fffbSMatthew Ahrens * fromsnap must be an earlier snapshot from the same fs as tosnap, 4464445fffbSMatthew Ahrens * or the origin's fs. 4474445fffbSMatthew Ahrens */ 4484445fffbSMatthew Ahrens if (fromds != NULL && !is_before(ds, fromds)) 449efb80947Sahrens return (EXDEV); 450efb80947Sahrens 451efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 452efb80947Sahrens drr->drr_type = DRR_BEGIN; 453efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 4549e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 4559e69d7d0SLori Alt DMU_SUBSTREAM); 456dc7cd546SMark Shellenbaum 457dc7cd546SMark Shellenbaum #ifdef _KERNEL 458dc7cd546SMark Shellenbaum if (dmu_objset_type(tosnap) == DMU_OST_ZFS) { 459dc7cd546SMark Shellenbaum uint64_t version; 4604e3c9f44SBill Pijewski if (zfs_get_zplprop(tosnap, ZFS_PROP_VERSION, &version) != 0) { 4614e3c9f44SBill Pijewski kmem_free(drr, sizeof (dmu_replay_record_t)); 462dc7cd546SMark Shellenbaum return (EINVAL); 4634e3c9f44SBill Pijewski } 464dc7cd546SMark Shellenbaum if (version == ZPL_VERSION_SA) { 465dc7cd546SMark Shellenbaum DMU_SET_FEATUREFLAGS( 466dc7cd546SMark Shellenbaum drr->drr_u.drr_begin.drr_versioninfo, 467dc7cd546SMark Shellenbaum DMU_BACKUP_FEATURE_SA_SPILL); 468dc7cd546SMark Shellenbaum } 469dc7cd546SMark Shellenbaum } 470dc7cd546SMark Shellenbaum #endif 471dc7cd546SMark Shellenbaum 472efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 473efb80947Sahrens ds->ds_phys->ds_creation_time; 474503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 4754445fffbSMatthew Ahrens if (fromds != NULL && ds->ds_dir != fromds->ds_dir) 4763cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 477efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 478ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 479ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 480ab04eb8eStimh 481efb80947Sahrens if (fromds) 482efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 483efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 484efb80947Sahrens 4853cb34c60Sahrens if (fromds) 4863cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 4873cb34c60Sahrens 4884e3c9f44SBill Pijewski dsp = kmem_zalloc(sizeof (dmu_sendarg_t), KM_SLEEP); 4894e3c9f44SBill Pijewski 4904e3c9f44SBill Pijewski dsp->dsa_drr = drr; 4914e3c9f44SBill Pijewski dsp->dsa_vp = vp; 4924e3c9f44SBill Pijewski dsp->dsa_outfd = outfd; 4934e3c9f44SBill Pijewski dsp->dsa_proc = curproc; 4944e3c9f44SBill Pijewski dsp->dsa_os = tosnap; 4954e3c9f44SBill Pijewski dsp->dsa_off = off; 4964e3c9f44SBill Pijewski dsp->dsa_toguid = ds->ds_phys->ds_guid; 4974e3c9f44SBill Pijewski ZIO_SET_CHECKSUM(&dsp->dsa_zc, 0, 0, 0, 0); 4984e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 4994e3c9f44SBill Pijewski 5004e3c9f44SBill Pijewski mutex_enter(&ds->ds_sendstream_lock); 5014e3c9f44SBill Pijewski list_insert_head(&ds->ds_sendstreams, dsp); 5024e3c9f44SBill Pijewski mutex_exit(&ds->ds_sendstream_lock); 5034e3c9f44SBill Pijewski 5044e3c9f44SBill Pijewski if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) { 5054e3c9f44SBill Pijewski err = dsp->dsa_err; 5064e3c9f44SBill Pijewski goto out; 507efb80947Sahrens } 508efb80947Sahrens 50988b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 5104e3c9f44SBill Pijewski backup_cb, dsp); 511efb80947Sahrens 5124e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) 5134e3c9f44SBill Pijewski if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) 5149e69d7d0SLori Alt err = EINTR; 5159e69d7d0SLori Alt 516efb80947Sahrens if (err) { 5174e3c9f44SBill Pijewski if (err == EINTR && dsp->dsa_err) 5184e3c9f44SBill Pijewski err = dsp->dsa_err; 5194e3c9f44SBill Pijewski goto out; 520efb80947Sahrens } 521efb80947Sahrens 522efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 523efb80947Sahrens drr->drr_type = DRR_END; 5244e3c9f44SBill Pijewski drr->drr_u.drr_end.drr_checksum = dsp->dsa_zc; 5254e3c9f44SBill Pijewski drr->drr_u.drr_end.drr_toguid = dsp->dsa_toguid; 526efb80947Sahrens 5274e3c9f44SBill Pijewski if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) { 5284e3c9f44SBill Pijewski err = dsp->dsa_err; 5294e3c9f44SBill Pijewski goto out; 5307b5309bbSgw } 531efb80947Sahrens 5324e3c9f44SBill Pijewski out: 5334e3c9f44SBill Pijewski mutex_enter(&ds->ds_sendstream_lock); 5344e3c9f44SBill Pijewski list_remove(&ds->ds_sendstreams, dsp); 5354e3c9f44SBill Pijewski mutex_exit(&ds->ds_sendstream_lock); 5364e3c9f44SBill Pijewski 537efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 5384e3c9f44SBill Pijewski kmem_free(dsp, sizeof (dmu_sendarg_t)); 539efb80947Sahrens 5404e3c9f44SBill Pijewski return (err); 541efb80947Sahrens } 542efb80947Sahrens 54319b94df9SMatthew Ahrens int 5444445fffbSMatthew Ahrens dmu_send_estimate(objset_t *tosnap, objset_t *fromsnap, uint64_t *sizep) 54519b94df9SMatthew Ahrens { 54619b94df9SMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 54719b94df9SMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 54819b94df9SMatthew Ahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 54919b94df9SMatthew Ahrens int err; 55019b94df9SMatthew Ahrens uint64_t size; 55119b94df9SMatthew Ahrens 55219b94df9SMatthew Ahrens /* tosnap must be a snapshot */ 55319b94df9SMatthew Ahrens if (ds->ds_phys->ds_next_snap_obj == 0) 55419b94df9SMatthew Ahrens return (EINVAL); 55519b94df9SMatthew Ahrens 5564445fffbSMatthew Ahrens /* 5574445fffbSMatthew Ahrens * fromsnap must be an earlier snapshot from the same fs as tosnap, 5584445fffbSMatthew Ahrens * or the origin's fs. 5594445fffbSMatthew Ahrens */ 5604445fffbSMatthew Ahrens if (fromds != NULL && !is_before(ds, fromds)) 56119b94df9SMatthew Ahrens return (EXDEV); 56219b94df9SMatthew Ahrens 56319b94df9SMatthew Ahrens /* Get uncompressed size estimate of changed data. */ 56419b94df9SMatthew Ahrens if (fromds == NULL) { 56519b94df9SMatthew Ahrens size = ds->ds_phys->ds_uncompressed_bytes; 56619b94df9SMatthew Ahrens } else { 56719b94df9SMatthew Ahrens uint64_t used, comp; 56819b94df9SMatthew Ahrens err = dsl_dataset_space_written(fromds, ds, 56919b94df9SMatthew Ahrens &used, &comp, &size); 57019b94df9SMatthew Ahrens if (err) 57119b94df9SMatthew Ahrens return (err); 57219b94df9SMatthew Ahrens } 57319b94df9SMatthew Ahrens 57419b94df9SMatthew Ahrens /* 57519b94df9SMatthew Ahrens * Assume that space (both on-disk and in-stream) is dominated by 57619b94df9SMatthew Ahrens * data. We will adjust for indirect blocks and the copies property, 57719b94df9SMatthew Ahrens * but ignore per-object space used (eg, dnodes and DRR_OBJECT records). 57819b94df9SMatthew Ahrens */ 57919b94df9SMatthew Ahrens 58019b94df9SMatthew Ahrens /* 58119b94df9SMatthew Ahrens * Subtract out approximate space used by indirect blocks. 58219b94df9SMatthew Ahrens * Assume most space is used by data blocks (non-indirect, non-dnode). 58319b94df9SMatthew Ahrens * Assume all blocks are recordsize. Assume ditto blocks and 58419b94df9SMatthew Ahrens * internal fragmentation counter out compression. 58519b94df9SMatthew Ahrens * 58619b94df9SMatthew Ahrens * Therefore, space used by indirect blocks is sizeof(blkptr_t) per 58719b94df9SMatthew Ahrens * block, which we observe in practice. 58819b94df9SMatthew Ahrens */ 58919b94df9SMatthew Ahrens uint64_t recordsize; 59019b94df9SMatthew Ahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 59119b94df9SMatthew Ahrens err = dsl_prop_get_ds(ds, "recordsize", 59219b94df9SMatthew Ahrens sizeof (recordsize), 1, &recordsize, NULL); 59319b94df9SMatthew Ahrens rw_exit(&dp->dp_config_rwlock); 59419b94df9SMatthew Ahrens if (err) 59519b94df9SMatthew Ahrens return (err); 59619b94df9SMatthew Ahrens size -= size / recordsize * sizeof (blkptr_t); 59719b94df9SMatthew Ahrens 59819b94df9SMatthew Ahrens /* Add in the space for the record associated with each block. */ 59919b94df9SMatthew Ahrens size += size / recordsize * sizeof (dmu_replay_record_t); 60019b94df9SMatthew Ahrens 60119b94df9SMatthew Ahrens *sizep = size; 60219b94df9SMatthew Ahrens 60319b94df9SMatthew Ahrens return (0); 60419b94df9SMatthew Ahrens } 60519b94df9SMatthew Ahrens 6063cb34c60Sahrens struct recvbeginsyncarg { 6073cb34c60Sahrens const char *tofs; 6083cb34c60Sahrens const char *tosnap; 6093cb34c60Sahrens dsl_dataset_t *origin; 6103cb34c60Sahrens uint64_t fromguid; 6113cb34c60Sahrens dmu_objset_type_t type; 6123cb34c60Sahrens void *tag; 6133cb34c60Sahrens boolean_t force; 614ab04eb8eStimh uint64_t dsflags; 6153cb34c60Sahrens char clonelastname[MAXNAMELEN]; 6163cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 6173f9d6ad7SLin Ling cred_t *cr; 618efb80947Sahrens }; 619efb80947Sahrens 620efb80947Sahrens /* ARGSUSED */ 621efb80947Sahrens static int 622ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 623efb80947Sahrens { 624efb80947Sahrens dsl_dir_t *dd = arg1; 6253cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 626efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 627efb80947Sahrens uint64_t val; 628efb80947Sahrens int err; 629efb80947Sahrens 630efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 6313cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 632efb80947Sahrens 633efb80947Sahrens if (err != ENOENT) 634efb80947Sahrens return (err ? err : EEXIST); 635efb80947Sahrens 6363cb34c60Sahrens if (rbsa->origin) { 6373cb34c60Sahrens /* make sure it's a snap in the same pool */ 6383cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 6393cb34c60Sahrens return (EXDEV); 640ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 6413cb34c60Sahrens return (EINVAL); 6423cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 6433cb34c60Sahrens return (ENODEV); 6443cb34c60Sahrens } 6453cb34c60Sahrens 646efb80947Sahrens return (0); 647efb80947Sahrens } 648efb80947Sahrens 649efb80947Sahrens static void 6503f9d6ad7SLin Ling recv_new_sync(void *arg1, void *arg2, dmu_tx_t *tx) 651efb80947Sahrens { 652efb80947Sahrens dsl_dir_t *dd = arg1; 6533cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 654745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 655efb80947Sahrens uint64_t dsobj; 656efb80947Sahrens 657ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 6583cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 6593f9d6ad7SLin Ling rbsa->origin, flags, rbsa->cr, tx); 660ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 661503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 662efb80947Sahrens 663ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 664ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 665ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 6663cb34c60Sahrens } 667ecd6cf80Smarks 6684445fffbSMatthew Ahrens spa_history_log_internal_ds(rbsa->ds, "receive new", tx, ""); 6693cb34c60Sahrens } 670f18faf3fSek 671f18faf3fSek /* ARGSUSED */ 672f18faf3fSek static int 673ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 674f18faf3fSek { 6753cb34c60Sahrens dsl_dataset_t *ds = arg1; 6763cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 6773cb34c60Sahrens int err; 6783cb34c60Sahrens uint64_t val; 679f18faf3fSek 6803cb34c60Sahrens /* must not have any changes since most recent snapshot */ 6813cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 682f18faf3fSek return (ETXTBSY); 683f18faf3fSek 684feaa74e4SMark Maybee /* new snapshot name must not exist */ 685feaa74e4SMark Maybee err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 686feaa74e4SMark Maybee ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 687feaa74e4SMark Maybee if (err == 0) 688feaa74e4SMark Maybee return (EEXIST); 689feaa74e4SMark Maybee if (err != ENOENT) 690feaa74e4SMark Maybee return (err); 691feaa74e4SMark Maybee 692ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 693ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 694ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 695ae46e4c7SMatthew Ahrens return (ENODEV); 69692241e0bSTom Erickson 69792241e0bSTom Erickson /* 69892241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 69992241e0bSTom Erickson * changes since the fromguid one 70092241e0bSTom Erickson */ 70192241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 70292241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 70392241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 70492241e0bSTom Erickson while (obj != 0) { 70592241e0bSTom Erickson dsl_dataset_t *snap; 70692241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 70792241e0bSTom Erickson obj, FTAG, &snap); 70892241e0bSTom Erickson if (err) 70992241e0bSTom Erickson return (ENODEV); 71092241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 71192241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 71292241e0bSTom Erickson return (ENODEV); 71392241e0bSTom Erickson } 71492241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 71592241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 71692241e0bSTom Erickson break; /* it's ok */ 71792241e0bSTom Erickson } 71892241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 71992241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 72092241e0bSTom Erickson } 72192241e0bSTom Erickson if (obj == 0) 72292241e0bSTom Erickson return (ENODEV); 72392241e0bSTom Erickson } 724ae46e4c7SMatthew Ahrens } else { 725ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 726ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 727ae46e4c7SMatthew Ahrens return (ENODEV); 728ae46e4c7SMatthew Ahrens } 7293cb34c60Sahrens 73047f263f4Sek /* temporary clone name must not exist */ 73147f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 73247f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 73347f263f4Sek rbsa->clonelastname, 8, 1, &val); 73447f263f4Sek if (err == 0) 73547f263f4Sek return (EEXIST); 73647f263f4Sek if (err != ENOENT) 73747f263f4Sek return (err); 73847f263f4Sek 7393cb34c60Sahrens return (0); 740f18faf3fSek } 741f18faf3fSek 742f18faf3fSek /* ARGSUSED */ 743f18faf3fSek static void 7443f9d6ad7SLin Ling recv_existing_sync(void *arg1, void *arg2, dmu_tx_t *tx) 745f18faf3fSek { 7463cb34c60Sahrens dsl_dataset_t *ohds = arg1; 7473cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 7483cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 749ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 750745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 751f18faf3fSek uint64_t dsobj; 752f18faf3fSek 753ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 754ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 7553f9d6ad7SLin Ling ohds->ds_prev, flags, rbsa->cr, tx); 756503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 7573cb34c60Sahrens 758ae46e4c7SMatthew Ahrens /* 759ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 760ae46e4c7SMatthew Ahrens * objset in our new dataset. 761ae46e4c7SMatthew Ahrens */ 762ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 763ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 764ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 765ae46e4c7SMatthew Ahrens } 766ae46e4c7SMatthew Ahrens 7673cb34c60Sahrens rbsa->ds = cds; 7683cb34c60Sahrens 7694445fffbSMatthew Ahrens spa_history_log_internal_ds(cds, "receive over existing", tx, ""); 7703cb34c60Sahrens } 7713cb34c60Sahrens 772dc7cd546SMark Shellenbaum static boolean_t 773dc7cd546SMark Shellenbaum dmu_recv_verify_features(dsl_dataset_t *ds, struct drr_begin *drrb) 774dc7cd546SMark Shellenbaum { 775dc7cd546SMark Shellenbaum int featureflags; 776dc7cd546SMark Shellenbaum 777dc7cd546SMark Shellenbaum featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 778dc7cd546SMark Shellenbaum 779dc7cd546SMark Shellenbaum /* Verify pool version supports SA if SA_SPILL feature set */ 780dc7cd546SMark Shellenbaum return ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) && 781dc7cd546SMark Shellenbaum (spa_version(dsl_dataset_get_spa(ds)) < SPA_VERSION_SA)); 782dc7cd546SMark Shellenbaum } 783dc7cd546SMark Shellenbaum 7843cb34c60Sahrens /* 7853cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 7863cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 7873cb34c60Sahrens */ 7883cb34c60Sahrens int 7899e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 790f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 791efb80947Sahrens { 7923cb34c60Sahrens int err = 0; 7933cb34c60Sahrens boolean_t byteswap; 794ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 7959e69d7d0SLori Alt uint64_t versioninfo; 7963cb34c60Sahrens int flags; 7973cb34c60Sahrens dsl_dataset_t *ds; 798efb80947Sahrens 7993cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 8003cb34c60Sahrens byteswap = FALSE; 8013cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 8023cb34c60Sahrens byteswap = TRUE; 8033cb34c60Sahrens else 8043cb34c60Sahrens return (EINVAL); 8053cb34c60Sahrens 8063cb34c60Sahrens rbsa.tofs = tofs; 8073cb34c60Sahrens rbsa.tosnap = tosnap; 808503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 8093cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 8103cb34c60Sahrens rbsa.type = drrb->drr_type; 8113cb34c60Sahrens rbsa.tag = FTAG; 812ab04eb8eStimh rbsa.dsflags = 0; 8133f9d6ad7SLin Ling rbsa.cr = CRED(); 8149e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 8153cb34c60Sahrens flags = drrb->drr_flags; 8163cb34c60Sahrens 8173cb34c60Sahrens if (byteswap) { 8183cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 8193cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 8209e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 8213cb34c60Sahrens flags = BSWAP_32(flags); 8223cb34c60Sahrens } 823efb80947Sahrens 8249e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 8253cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 8263cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 827efb80947Sahrens return (EINVAL); 828efb80947Sahrens 829ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 830ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 831ab04eb8eStimh 8323cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 8333cb34c60Sahrens drc->drc_drrb = drrb; 8343cb34c60Sahrens drc->drc_tosnap = tosnap; 8359e69d7d0SLori Alt drc->drc_top_ds = top_ds; 8363cb34c60Sahrens drc->drc_force = force; 837efb80947Sahrens 8383cb34c60Sahrens /* 8393cb34c60Sahrens * Process the begin in syncing context. 8403cb34c60Sahrens */ 841efb80947Sahrens 842ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 843ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 844ae46e4c7SMatthew Ahrens if (err == 0) { 845dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 846dc7cd546SMark Shellenbaum dsl_dataset_rele(ds, dmu_recv_tag); 847dc7cd546SMark Shellenbaum return (ENOTSUP); 848dc7cd546SMark Shellenbaum } 849ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 850efb80947Sahrens 851ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 852ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 853ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 854ae46e4c7SMatthew Ahrens return (EINVAL); 855ae46e4c7SMatthew Ahrens } 856efb80947Sahrens 857f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 858f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 859f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 860f4b94bdeSMatthew Ahrens return (EBUSY); 861f4b94bdeSMatthew Ahrens } 862f4b94bdeSMatthew Ahrens 863ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 864ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 865ae46e4c7SMatthew Ahrens "%%%s", tosnap); 8663cb34c60Sahrens rbsa.force = force; 8673cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 868ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 8693cb34c60Sahrens if (err) { 870f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 871745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 8723cb34c60Sahrens return (err); 8733cb34c60Sahrens } 8743cb34c60Sahrens drc->drc_logical_ds = ds; 8753cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 876ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 877ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 878ae46e4c7SMatthew Ahrens char *cp; 879efb80947Sahrens 880ae46e4c7SMatthew Ahrens /* 881ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 882ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 883ae46e4c7SMatthew Ahrens */ 884ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 885ae46e4c7SMatthew Ahrens return (ENOENT); 886ae46e4c7SMatthew Ahrens 887ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 888ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 889ae46e4c7SMatthew Ahrens *cp = '\0'; 890bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 891ae46e4c7SMatthew Ahrens *cp = '/'; 8923cb34c60Sahrens if (err) 8933cb34c60Sahrens return (err); 894efb80947Sahrens 895dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 8968fe33373SMatthew Ahrens dsl_dataset_rele(ds, FTAG); 897dc7cd546SMark Shellenbaum return (ENOTSUP); 898dc7cd546SMark Shellenbaum } 899dc7cd546SMark Shellenbaum 900ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 901ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 902bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 9033cb34c60Sahrens if (err) 9043cb34c60Sahrens return (err); 9053cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 9063cb34c60Sahrens drc->drc_newfs = B_TRUE; 9073cb34c60Sahrens } 9083cb34c60Sahrens 909ae46e4c7SMatthew Ahrens return (err); 910efb80947Sahrens } 911efb80947Sahrens 9123cb34c60Sahrens struct restorearg { 9133cb34c60Sahrens int err; 9143cb34c60Sahrens int byteswap; 9153cb34c60Sahrens vnode_t *vp; 9163cb34c60Sahrens char *buf; 9173cb34c60Sahrens uint64_t voff; 9183cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 9193cb34c60Sahrens zio_cksum_t cksum; 920c99e4bdcSChris Kirby avl_tree_t *guid_to_ds_map; 9213cb34c60Sahrens }; 9223cb34c60Sahrens 9239e69d7d0SLori Alt typedef struct guid_map_entry { 9249e69d7d0SLori Alt uint64_t guid; 9259e69d7d0SLori Alt dsl_dataset_t *gme_ds; 9269e69d7d0SLori Alt avl_node_t avlnode; 9279e69d7d0SLori Alt } guid_map_entry_t; 9289e69d7d0SLori Alt 9299e69d7d0SLori Alt static int 9309e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 9319e69d7d0SLori Alt { 9329e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 9339e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 9349e69d7d0SLori Alt 9359e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 9369e69d7d0SLori Alt return (-1); 9379e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 9389e69d7d0SLori Alt return (1); 9399e69d7d0SLori Alt return (0); 9409e69d7d0SLori Alt } 9419e69d7d0SLori Alt 942c99e4bdcSChris Kirby static void 943c99e4bdcSChris Kirby free_guid_map_onexit(void *arg) 944c99e4bdcSChris Kirby { 945c99e4bdcSChris Kirby avl_tree_t *ca = arg; 946c99e4bdcSChris Kirby void *cookie = NULL; 947c99e4bdcSChris Kirby guid_map_entry_t *gmep; 948c99e4bdcSChris Kirby 949c99e4bdcSChris Kirby while ((gmep = avl_destroy_nodes(ca, &cookie)) != NULL) { 950c99e4bdcSChris Kirby dsl_dataset_rele(gmep->gme_ds, ca); 951c99e4bdcSChris Kirby kmem_free(gmep, sizeof (guid_map_entry_t)); 952c99e4bdcSChris Kirby } 953c99e4bdcSChris Kirby avl_destroy(ca); 954c99e4bdcSChris Kirby kmem_free(ca, sizeof (avl_tree_t)); 955c99e4bdcSChris Kirby } 956c99e4bdcSChris Kirby 957efb80947Sahrens static void * 958efb80947Sahrens restore_read(struct restorearg *ra, int len) 959efb80947Sahrens { 960efb80947Sahrens void *rv; 9613cb34c60Sahrens int done = 0; 962efb80947Sahrens 963efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 964*fb09f5aaSMadhav Suresh ASSERT0(len % 8); 965efb80947Sahrens 9663cb34c60Sahrens while (done < len) { 967efb80947Sahrens ssize_t resid; 968efb80947Sahrens 969efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 9703cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 971efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 972efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 973efb80947Sahrens 9743cb34c60Sahrens if (resid == len - done) 975efb80947Sahrens ra->err = EINVAL; 9763cb34c60Sahrens ra->voff += len - done - resid; 9773cb34c60Sahrens done = len - resid; 978efb80947Sahrens if (ra->err) 979efb80947Sahrens return (NULL); 980efb80947Sahrens } 981efb80947Sahrens 9823cb34c60Sahrens ASSERT3U(done, ==, len); 9833cb34c60Sahrens rv = ra->buf; 984efb80947Sahrens if (ra->byteswap) 9853cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 986efb80947Sahrens else 9873cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 988efb80947Sahrens return (rv); 989efb80947Sahrens } 990efb80947Sahrens 991efb80947Sahrens static void 992efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 993efb80947Sahrens { 994efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 995efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 996efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 9973cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 998efb80947Sahrens switch (drr->drr_type) { 999efb80947Sahrens case DRR_BEGIN: 1000efb80947Sahrens DO64(drr_begin.drr_magic); 10019e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 1002efb80947Sahrens DO64(drr_begin.drr_creation_time); 1003efb80947Sahrens DO32(drr_begin.drr_type); 10043cb34c60Sahrens DO32(drr_begin.drr_flags); 1005efb80947Sahrens DO64(drr_begin.drr_toguid); 1006efb80947Sahrens DO64(drr_begin.drr_fromguid); 1007efb80947Sahrens break; 1008efb80947Sahrens case DRR_OBJECT: 1009efb80947Sahrens DO64(drr_object.drr_object); 1010efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 1011efb80947Sahrens DO32(drr_object.drr_type); 1012efb80947Sahrens DO32(drr_object.drr_bonustype); 1013efb80947Sahrens DO32(drr_object.drr_blksz); 1014efb80947Sahrens DO32(drr_object.drr_bonuslen); 10159e69d7d0SLori Alt DO64(drr_object.drr_toguid); 1016efb80947Sahrens break; 1017efb80947Sahrens case DRR_FREEOBJECTS: 1018efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 1019efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 10209e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 1021efb80947Sahrens break; 1022efb80947Sahrens case DRR_WRITE: 1023efb80947Sahrens DO64(drr_write.drr_object); 1024efb80947Sahrens DO32(drr_write.drr_type); 1025efb80947Sahrens DO64(drr_write.drr_offset); 1026efb80947Sahrens DO64(drr_write.drr_length); 10279e69d7d0SLori Alt DO64(drr_write.drr_toguid); 10288e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[0]); 10298e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[1]); 10308e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[2]); 10318e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[3]); 10328e714474SLori Alt DO64(drr_write.drr_key.ddk_prop); 10339e69d7d0SLori Alt break; 10349e69d7d0SLori Alt case DRR_WRITE_BYREF: 10359e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 10369e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 10379e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 10389e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 10399e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 10409e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 10419e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 10428e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]); 10438e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]); 10448e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]); 10458e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]); 10468e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_prop); 1047efb80947Sahrens break; 1048efb80947Sahrens case DRR_FREE: 1049efb80947Sahrens DO64(drr_free.drr_object); 1050efb80947Sahrens DO64(drr_free.drr_offset); 1051efb80947Sahrens DO64(drr_free.drr_length); 10529e69d7d0SLori Alt DO64(drr_free.drr_toguid); 1053efb80947Sahrens break; 10540a586ceaSMark Shellenbaum case DRR_SPILL: 10550a586ceaSMark Shellenbaum DO64(drr_spill.drr_object); 10560a586ceaSMark Shellenbaum DO64(drr_spill.drr_length); 10570a586ceaSMark Shellenbaum DO64(drr_spill.drr_toguid); 10580a586ceaSMark Shellenbaum break; 1059efb80947Sahrens case DRR_END: 1060efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 1061efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 1062efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 1063efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 10649e69d7d0SLori Alt DO64(drr_end.drr_toguid); 1065efb80947Sahrens break; 1066efb80947Sahrens } 1067efb80947Sahrens #undef DO64 1068efb80947Sahrens #undef DO32 1069efb80947Sahrens } 1070efb80947Sahrens 1071efb80947Sahrens static int 1072efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 1073efb80947Sahrens { 1074efb80947Sahrens int err; 1075efb80947Sahrens dmu_tx_t *tx; 1076adee0b6fSTim Haley void *data = NULL; 1077efb80947Sahrens 1078efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 1079ad135b5dSChristopher Siden !DMU_OT_IS_VALID(drro->drr_type) || 1080ad135b5dSChristopher Siden !DMU_OT_IS_VALID(drro->drr_bonustype) || 10819e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 1082efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 1083efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 1084efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 1085efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 1086efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 1087efb80947Sahrens return (EINVAL); 1088efb80947Sahrens } 1089efb80947Sahrens 10902bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 10912bf405a2SMark Maybee 10922bf405a2SMark Maybee if (err != 0 && err != ENOENT) 10932bf405a2SMark Maybee return (EINVAL); 10942bf405a2SMark Maybee 1095adee0b6fSTim Haley if (drro->drr_bonuslen) { 1096adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 1097adee0b6fSTim Haley if (ra->err) 1098adee0b6fSTim Haley return (ra->err); 1099adee0b6fSTim Haley } 1100adee0b6fSTim Haley 1101efb80947Sahrens if (err == ENOENT) { 1102efb80947Sahrens /* currently free, want to be allocated */ 11032bf405a2SMark Maybee tx = dmu_tx_create(os); 1104efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 1105efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1106efb80947Sahrens if (err) { 1107efb80947Sahrens dmu_tx_abort(tx); 1108efb80947Sahrens return (err); 1109efb80947Sahrens } 1110efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 1111efb80947Sahrens drro->drr_type, drro->drr_blksz, 1112efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 11132bf405a2SMark Maybee dmu_tx_commit(tx); 1114efb80947Sahrens } else { 1115efb80947Sahrens /* currently allocated, want to be allocated */ 1116efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 1117efb80947Sahrens drro->drr_type, drro->drr_blksz, 11182bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 1119efb80947Sahrens } 11200a586ceaSMark Shellenbaum if (err) { 1121efb80947Sahrens return (EINVAL); 11220a586ceaSMark Shellenbaum } 11232bf405a2SMark Maybee 11242bf405a2SMark Maybee tx = dmu_tx_create(os); 11252bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 11262bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 11272bf405a2SMark Maybee if (err) { 11282bf405a2SMark Maybee dmu_tx_abort(tx); 11292bf405a2SMark Maybee return (err); 1130efb80947Sahrens } 1131efb80947Sahrens 11329e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 11339e69d7d0SLori Alt tx); 1134efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 1135efb80947Sahrens 1136adee0b6fSTim Haley if (data != NULL) { 1137efb80947Sahrens dmu_buf_t *db; 1138adee0b6fSTim Haley 1139efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 1140efb80947Sahrens dmu_buf_will_dirty(db, tx); 1141efb80947Sahrens 11421934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 11431934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 1144efb80947Sahrens if (ra->byteswap) { 1145ad135b5dSChristopher Siden dmu_object_byteswap_t byteswap = 1146ad135b5dSChristopher Siden DMU_OT_BYTESWAP(drro->drr_bonustype); 1147ad135b5dSChristopher Siden dmu_ot_byteswap[byteswap].ob_func(db->db_data, 1148efb80947Sahrens drro->drr_bonuslen); 1149efb80947Sahrens } 1150efb80947Sahrens dmu_buf_rele(db, FTAG); 1151efb80947Sahrens } 1152efb80947Sahrens dmu_tx_commit(tx); 1153efb80947Sahrens return (0); 1154efb80947Sahrens } 1155efb80947Sahrens 1156efb80947Sahrens /* ARGSUSED */ 1157efb80947Sahrens static int 1158efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1159efb80947Sahrens struct drr_freeobjects *drrfo) 1160efb80947Sahrens { 1161efb80947Sahrens uint64_t obj; 1162efb80947Sahrens 1163efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1164efb80947Sahrens return (EINVAL); 1165efb80947Sahrens 1166efb80947Sahrens for (obj = drrfo->drr_firstobj; 1167432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1168432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1169efb80947Sahrens int err; 1170efb80947Sahrens 1171efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1172efb80947Sahrens continue; 1173efb80947Sahrens 1174cdb0ab79Smaybee err = dmu_free_object(os, obj); 1175cdb0ab79Smaybee if (err) 1176efb80947Sahrens return (err); 1177efb80947Sahrens } 1178efb80947Sahrens return (0); 1179efb80947Sahrens } 1180efb80947Sahrens 1181efb80947Sahrens static int 1182efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1183efb80947Sahrens struct drr_write *drrw) 1184efb80947Sahrens { 1185efb80947Sahrens dmu_tx_t *tx; 1186efb80947Sahrens void *data; 1187efb80947Sahrens int err; 1188efb80947Sahrens 1189efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1190ad135b5dSChristopher Siden !DMU_OT_IS_VALID(drrw->drr_type)) 1191efb80947Sahrens return (EINVAL); 1192efb80947Sahrens 1193efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1194efb80947Sahrens if (data == NULL) 1195efb80947Sahrens return (ra->err); 1196efb80947Sahrens 1197efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1198efb80947Sahrens return (EINVAL); 1199efb80947Sahrens 1200efb80947Sahrens tx = dmu_tx_create(os); 1201efb80947Sahrens 1202efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1203efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1204efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1205efb80947Sahrens if (err) { 1206efb80947Sahrens dmu_tx_abort(tx); 1207efb80947Sahrens return (err); 1208efb80947Sahrens } 1209ad135b5dSChristopher Siden if (ra->byteswap) { 1210ad135b5dSChristopher Siden dmu_object_byteswap_t byteswap = 1211ad135b5dSChristopher Siden DMU_OT_BYTESWAP(drrw->drr_type); 1212ad135b5dSChristopher Siden dmu_ot_byteswap[byteswap].ob_func(data, drrw->drr_length); 1213ad135b5dSChristopher Siden } 1214efb80947Sahrens dmu_write(os, drrw->drr_object, 1215efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1216efb80947Sahrens dmu_tx_commit(tx); 1217efb80947Sahrens return (0); 1218efb80947Sahrens } 1219efb80947Sahrens 12209e69d7d0SLori Alt /* 12219e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 12229e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 12239e69d7d0SLori Alt * system because it came in earlier in the stream. This function 12249e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 12259e69d7d0SLori Alt * data from the stream to fulfill this write. 12269e69d7d0SLori Alt */ 12279e69d7d0SLori Alt static int 12289e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 12299e69d7d0SLori Alt struct drr_write_byref *drrwbr) 12309e69d7d0SLori Alt { 12319e69d7d0SLori Alt dmu_tx_t *tx; 12329e69d7d0SLori Alt int err; 12339e69d7d0SLori Alt guid_map_entry_t gmesrch; 12349e69d7d0SLori Alt guid_map_entry_t *gmep; 12359e69d7d0SLori Alt avl_index_t where; 12369e69d7d0SLori Alt objset_t *ref_os = NULL; 12379e69d7d0SLori Alt dmu_buf_t *dbp; 12389e69d7d0SLori Alt 12399e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 12409e69d7d0SLori Alt return (EINVAL); 12419e69d7d0SLori Alt 12429e69d7d0SLori Alt /* 12439e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 12449e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 12459e69d7d0SLori Alt */ 12469e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 12479e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 1248c99e4bdcSChris Kirby if ((gmep = avl_find(ra->guid_to_ds_map, &gmesrch, 12499e69d7d0SLori Alt &where)) == NULL) { 12509e69d7d0SLori Alt return (EINVAL); 12519e69d7d0SLori Alt } 12529e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 12539e69d7d0SLori Alt return (EINVAL); 12549e69d7d0SLori Alt } else { 12559e69d7d0SLori Alt ref_os = os; 12569e69d7d0SLori Alt } 12579e69d7d0SLori Alt 12589e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 125947cb52daSJeff Bonwick drrwbr->drr_refoffset, FTAG, &dbp, DMU_READ_PREFETCH)) 12609e69d7d0SLori Alt return (err); 12619e69d7d0SLori Alt 12629e69d7d0SLori Alt tx = dmu_tx_create(os); 12639e69d7d0SLori Alt 12649e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 12659e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 12669e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 12679e69d7d0SLori Alt if (err) { 12689e69d7d0SLori Alt dmu_tx_abort(tx); 12699e69d7d0SLori Alt return (err); 12709e69d7d0SLori Alt } 12719e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 12729e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 12739e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 12749e69d7d0SLori Alt dmu_tx_commit(tx); 12759e69d7d0SLori Alt return (0); 12769e69d7d0SLori Alt } 12779e69d7d0SLori Alt 12780a586ceaSMark Shellenbaum static int 12790a586ceaSMark Shellenbaum restore_spill(struct restorearg *ra, objset_t *os, struct drr_spill *drrs) 12800a586ceaSMark Shellenbaum { 12810a586ceaSMark Shellenbaum dmu_tx_t *tx; 12820a586ceaSMark Shellenbaum void *data; 12830a586ceaSMark Shellenbaum dmu_buf_t *db, *db_spill; 12840a586ceaSMark Shellenbaum int err; 12850a586ceaSMark Shellenbaum 12860a586ceaSMark Shellenbaum if (drrs->drr_length < SPA_MINBLOCKSIZE || 12870a586ceaSMark Shellenbaum drrs->drr_length > SPA_MAXBLOCKSIZE) 12880a586ceaSMark Shellenbaum return (EINVAL); 12890a586ceaSMark Shellenbaum 12900a586ceaSMark Shellenbaum data = restore_read(ra, drrs->drr_length); 12910a586ceaSMark Shellenbaum if (data == NULL) 12920a586ceaSMark Shellenbaum return (ra->err); 12930a586ceaSMark Shellenbaum 12940a586ceaSMark Shellenbaum if (dmu_object_info(os, drrs->drr_object, NULL) != 0) 12950a586ceaSMark Shellenbaum return (EINVAL); 12960a586ceaSMark Shellenbaum 12970a586ceaSMark Shellenbaum VERIFY(0 == dmu_bonus_hold(os, drrs->drr_object, FTAG, &db)); 12980a586ceaSMark Shellenbaum if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) { 12990a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 13000a586ceaSMark Shellenbaum return (err); 13010a586ceaSMark Shellenbaum } 13020a586ceaSMark Shellenbaum 13030a586ceaSMark Shellenbaum tx = dmu_tx_create(os); 13040a586ceaSMark Shellenbaum 13050a586ceaSMark Shellenbaum dmu_tx_hold_spill(tx, db->db_object); 13060a586ceaSMark Shellenbaum 13070a586ceaSMark Shellenbaum err = dmu_tx_assign(tx, TXG_WAIT); 13080a586ceaSMark Shellenbaum if (err) { 13090a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 13100a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 13110a586ceaSMark Shellenbaum dmu_tx_abort(tx); 13120a586ceaSMark Shellenbaum return (err); 13130a586ceaSMark Shellenbaum } 13140a586ceaSMark Shellenbaum dmu_buf_will_dirty(db_spill, tx); 13150a586ceaSMark Shellenbaum 13160a586ceaSMark Shellenbaum if (db_spill->db_size < drrs->drr_length) 13170a586ceaSMark Shellenbaum VERIFY(0 == dbuf_spill_set_blksz(db_spill, 13180a586ceaSMark Shellenbaum drrs->drr_length, tx)); 13190a586ceaSMark Shellenbaum bcopy(data, db_spill->db_data, drrs->drr_length); 13200a586ceaSMark Shellenbaum 13210a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 13220a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 13230a586ceaSMark Shellenbaum 13240a586ceaSMark Shellenbaum dmu_tx_commit(tx); 13250a586ceaSMark Shellenbaum return (0); 13260a586ceaSMark Shellenbaum } 13270a586ceaSMark Shellenbaum 1328efb80947Sahrens /* ARGSUSED */ 1329efb80947Sahrens static int 1330efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1331efb80947Sahrens struct drr_free *drrf) 1332efb80947Sahrens { 1333efb80947Sahrens int err; 1334efb80947Sahrens 1335efb80947Sahrens if (drrf->drr_length != -1ULL && 1336efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1337efb80947Sahrens return (EINVAL); 1338efb80947Sahrens 1339efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1340efb80947Sahrens return (EINVAL); 1341efb80947Sahrens 1342cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1343efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1344efb80947Sahrens return (err); 1345efb80947Sahrens } 1346efb80947Sahrens 13473cb34c60Sahrens /* 13483cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 13493cb34c60Sahrens */ 1350efb80947Sahrens int 1351c99e4bdcSChris Kirby dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp, 1352c99e4bdcSChris Kirby int cleanup_fd, uint64_t *action_handlep) 1353efb80947Sahrens { 13543cb34c60Sahrens struct restorearg ra = { 0 }; 1355efb80947Sahrens dmu_replay_record_t *drr; 13563cb34c60Sahrens objset_t *os; 13573cb34c60Sahrens zio_cksum_t pcksum; 13589e69d7d0SLori Alt int featureflags; 1359efb80947Sahrens 13603cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1361efb80947Sahrens ra.byteswap = TRUE; 1362efb80947Sahrens 13633cb34c60Sahrens { 13643cb34c60Sahrens /* compute checksum of drr_begin record */ 13653cb34c60Sahrens dmu_replay_record_t *drr; 13663cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 13673cb34c60Sahrens 13683cb34c60Sahrens drr->drr_type = DRR_BEGIN; 13693cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 13703cb34c60Sahrens if (ra.byteswap) { 13713cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 13723cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 13733cb34c60Sahrens } else { 13743cb34c60Sahrens fletcher_4_incremental_native(drr, 13753cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 13763cb34c60Sahrens } 13773cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1378efb80947Sahrens } 1379efb80947Sahrens 1380efb80947Sahrens if (ra.byteswap) { 13813cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1382efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 13839e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1384efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1385efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1386efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1387efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1388efb80947Sahrens } 1389efb80947Sahrens 13903cb34c60Sahrens ra.vp = vp; 13913cb34c60Sahrens ra.voff = *voffp; 13923cb34c60Sahrens ra.bufsize = 1<<20; 13933cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1394efb80947Sahrens 13953cb34c60Sahrens /* these were verified in dmu_recv_begin */ 13969e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 13979e69d7d0SLori Alt DMU_SUBSTREAM); 13983cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1399efb80947Sahrens 1400efb80947Sahrens /* 1401efb80947Sahrens * Open the objset we are modifying. 1402efb80947Sahrens */ 1403503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1404efb80947Sahrens 14053cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1406efb80947Sahrens 14079e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 14089e69d7d0SLori Alt 14099e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 14109e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 1411a7f53a56SChris Kirby minor_t minor; 1412a7f53a56SChris Kirby 1413c99e4bdcSChris Kirby if (cleanup_fd == -1) { 1414c99e4bdcSChris Kirby ra.err = EBADF; 1415c99e4bdcSChris Kirby goto out; 1416c99e4bdcSChris Kirby } 1417a7f53a56SChris Kirby ra.err = zfs_onexit_fd_hold(cleanup_fd, &minor); 1418a7f53a56SChris Kirby if (ra.err) { 1419a7f53a56SChris Kirby cleanup_fd = -1; 1420a7f53a56SChris Kirby goto out; 1421a7f53a56SChris Kirby } 1422a7f53a56SChris Kirby 1423c99e4bdcSChris Kirby if (*action_handlep == 0) { 1424c99e4bdcSChris Kirby ra.guid_to_ds_map = 1425c99e4bdcSChris Kirby kmem_alloc(sizeof (avl_tree_t), KM_SLEEP); 1426c99e4bdcSChris Kirby avl_create(ra.guid_to_ds_map, guid_compare, 1427c99e4bdcSChris Kirby sizeof (guid_map_entry_t), 1428c99e4bdcSChris Kirby offsetof(guid_map_entry_t, avlnode)); 1429a7f53a56SChris Kirby ra.err = zfs_onexit_add_cb(minor, 1430c99e4bdcSChris Kirby free_guid_map_onexit, ra.guid_to_ds_map, 1431c99e4bdcSChris Kirby action_handlep); 1432c99e4bdcSChris Kirby if (ra.err) 1433c99e4bdcSChris Kirby goto out; 1434c99e4bdcSChris Kirby } else { 1435a7f53a56SChris Kirby ra.err = zfs_onexit_cb_data(minor, *action_handlep, 1436c99e4bdcSChris Kirby (void **)&ra.guid_to_ds_map); 1437c99e4bdcSChris Kirby if (ra.err) 1438c99e4bdcSChris Kirby goto out; 1439c99e4bdcSChris Kirby } 1440ec5cf9d5SAlexander Stetsenko 1441ec5cf9d5SAlexander Stetsenko drc->drc_guid_to_ds_map = ra.guid_to_ds_map; 14429e69d7d0SLori Alt } 14439e69d7d0SLori Alt 1444efb80947Sahrens /* 1445efb80947Sahrens * Read records and process them. 1446efb80947Sahrens */ 14473cb34c60Sahrens pcksum = ra.cksum; 1448efb80947Sahrens while (ra.err == 0 && 1449efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1450efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1451efb80947Sahrens ra.err = EINTR; 1452efb80947Sahrens goto out; 1453efb80947Sahrens } 1454efb80947Sahrens 1455efb80947Sahrens if (ra.byteswap) 1456efb80947Sahrens backup_byteswap(drr); 1457efb80947Sahrens 1458efb80947Sahrens switch (drr->drr_type) { 1459efb80947Sahrens case DRR_OBJECT: 1460efb80947Sahrens { 1461efb80947Sahrens /* 1462efb80947Sahrens * We need to make a copy of the record header, 1463efb80947Sahrens * because restore_{object,write} may need to 1464efb80947Sahrens * restore_read(), which will invalidate drr. 1465efb80947Sahrens */ 1466efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1467efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1468efb80947Sahrens break; 1469efb80947Sahrens } 1470efb80947Sahrens case DRR_FREEOBJECTS: 1471efb80947Sahrens { 1472efb80947Sahrens struct drr_freeobjects drrfo = 1473efb80947Sahrens drr->drr_u.drr_freeobjects; 1474efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1475efb80947Sahrens break; 1476efb80947Sahrens } 1477efb80947Sahrens case DRR_WRITE: 1478efb80947Sahrens { 1479efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1480efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1481efb80947Sahrens break; 1482efb80947Sahrens } 14839e69d7d0SLori Alt case DRR_WRITE_BYREF: 14849e69d7d0SLori Alt { 14859e69d7d0SLori Alt struct drr_write_byref drrwbr = 14869e69d7d0SLori Alt drr->drr_u.drr_write_byref; 14879e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 14889e69d7d0SLori Alt break; 14899e69d7d0SLori Alt } 1490efb80947Sahrens case DRR_FREE: 1491efb80947Sahrens { 1492efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1493efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1494efb80947Sahrens break; 1495efb80947Sahrens } 1496efb80947Sahrens case DRR_END: 1497efb80947Sahrens { 1498efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1499efb80947Sahrens /* 1500efb80947Sahrens * We compare against the *previous* checksum 1501efb80947Sahrens * value, because the stored checksum is of 1502efb80947Sahrens * everything before the DRR_END record. 1503efb80947Sahrens */ 1504137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1505efb80947Sahrens ra.err = ECKSUM; 1506efb80947Sahrens goto out; 1507efb80947Sahrens } 15080a586ceaSMark Shellenbaum case DRR_SPILL: 15090a586ceaSMark Shellenbaum { 15100a586ceaSMark Shellenbaum struct drr_spill drrs = drr->drr_u.drr_spill; 15110a586ceaSMark Shellenbaum ra.err = restore_spill(&ra, os, &drrs); 15120a586ceaSMark Shellenbaum break; 15130a586ceaSMark Shellenbaum } 1514efb80947Sahrens default: 1515efb80947Sahrens ra.err = EINVAL; 1516efb80947Sahrens goto out; 1517efb80947Sahrens } 15183cb34c60Sahrens pcksum = ra.cksum; 1519efb80947Sahrens } 1520137fa067Sahrens ASSERT(ra.err != 0); 1521efb80947Sahrens 1522efb80947Sahrens out: 1523a7f53a56SChris Kirby if ((featureflags & DMU_BACKUP_FEATURE_DEDUP) && (cleanup_fd != -1)) 1524a7f53a56SChris Kirby zfs_onexit_fd_rele(cleanup_fd); 1525a7f53a56SChris Kirby 15263cb34c60Sahrens if (ra.err != 0) { 1527efb80947Sahrens /* 1528f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1529f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1530efb80947Sahrens */ 15313cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1532f4b94bdeSMatthew Ahrens 1533842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1534842727c2SChris Kirby B_FALSE); 1535f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1536f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1537f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1538f4b94bdeSMatthew Ahrens } 1539efb80947Sahrens } 1540efb80947Sahrens 1541efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 15423cb34c60Sahrens *voffp = ra.voff; 1543efb80947Sahrens return (ra.err); 1544efb80947Sahrens } 1545f18faf3fSek 15463cb34c60Sahrens struct recvendsyncarg { 15473cb34c60Sahrens char *tosnap; 15483cb34c60Sahrens uint64_t creation_time; 15493cb34c60Sahrens uint64_t toguid; 15503cb34c60Sahrens }; 15513cb34c60Sahrens 15523cb34c60Sahrens static int 15533cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 15543cb34c60Sahrens { 15553cb34c60Sahrens dsl_dataset_t *ds = arg1; 15563cb34c60Sahrens struct recvendsyncarg *resa = arg2; 15573cb34c60Sahrens 15583cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 15593cb34c60Sahrens } 15603cb34c60Sahrens 15613cb34c60Sahrens static void 15623f9d6ad7SLin Ling recv_end_sync(void *arg1, void *arg2, dmu_tx_t *tx) 15633cb34c60Sahrens { 15643cb34c60Sahrens dsl_dataset_t *ds = arg1; 15653cb34c60Sahrens struct recvendsyncarg *resa = arg2; 15663cb34c60Sahrens 15673f9d6ad7SLin Ling dsl_dataset_snapshot_sync(ds, resa->tosnap, tx); 15683cb34c60Sahrens 15693cb34c60Sahrens /* set snapshot's creation time and guid */ 15703cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 15713cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 15723cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 15733cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 15743cb34c60Sahrens 15753cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 15763cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 15774445fffbSMatthew Ahrens spa_history_log_internal_ds(ds, "finished receiving", tx, ""); 15783cb34c60Sahrens } 15793cb34c60Sahrens 1580ec5cf9d5SAlexander Stetsenko static int 1581ec5cf9d5SAlexander Stetsenko add_ds_to_guidmap(avl_tree_t *guid_map, dsl_dataset_t *ds) 1582ec5cf9d5SAlexander Stetsenko { 1583ec5cf9d5SAlexander Stetsenko dsl_pool_t *dp = ds->ds_dir->dd_pool; 1584ec5cf9d5SAlexander Stetsenko uint64_t snapobj = ds->ds_phys->ds_prev_snap_obj; 1585ec5cf9d5SAlexander Stetsenko dsl_dataset_t *snapds; 1586ec5cf9d5SAlexander Stetsenko guid_map_entry_t *gmep; 1587ec5cf9d5SAlexander Stetsenko int err; 1588ec5cf9d5SAlexander Stetsenko 1589ec5cf9d5SAlexander Stetsenko ASSERT(guid_map != NULL); 1590ec5cf9d5SAlexander Stetsenko 1591ec5cf9d5SAlexander Stetsenko rw_enter(&dp->dp_config_rwlock, RW_READER); 1592ec5cf9d5SAlexander Stetsenko err = dsl_dataset_hold_obj(dp, snapobj, guid_map, &snapds); 1593ec5cf9d5SAlexander Stetsenko if (err == 0) { 1594ec5cf9d5SAlexander Stetsenko gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 1595ec5cf9d5SAlexander Stetsenko gmep->guid = snapds->ds_phys->ds_guid; 1596ec5cf9d5SAlexander Stetsenko gmep->gme_ds = snapds; 1597ec5cf9d5SAlexander Stetsenko avl_add(guid_map, gmep); 1598ec5cf9d5SAlexander Stetsenko } 1599ec5cf9d5SAlexander Stetsenko 1600ec5cf9d5SAlexander Stetsenko rw_exit(&dp->dp_config_rwlock); 1601ec5cf9d5SAlexander Stetsenko return (err); 1602ec5cf9d5SAlexander Stetsenko } 1603ec5cf9d5SAlexander Stetsenko 1604ae46e4c7SMatthew Ahrens static int 1605ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1606f18faf3fSek { 1607745cd3c5Smaybee struct recvendsyncarg resa; 1608745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 160919b94df9SMatthew Ahrens int err, myerr; 1610f18faf3fSek 1611ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1612ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1613ae46e4c7SMatthew Ahrens drc->drc_force); 1614ae46e4c7SMatthew Ahrens if (err) 1615ae46e4c7SMatthew Ahrens goto out; 1616ae46e4c7SMatthew Ahrens } else { 1617ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1618ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1619842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1620842727c2SChris Kirby B_FALSE); 1621ae46e4c7SMatthew Ahrens return (EBUSY); 16223cb34c60Sahrens } 16233cb34c60Sahrens 1624745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1625745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1626745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 16273cb34c60Sahrens 1628745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1629745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1630745cd3c5Smaybee if (err) { 1631ae46e4c7SMatthew Ahrens /* swap back */ 1632ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 16333cb34c60Sahrens } 16343cb34c60Sahrens 1635ae46e4c7SMatthew Ahrens out: 1636ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1637ec5cf9d5SAlexander Stetsenko if (err == 0 && drc->drc_guid_to_ds_map != NULL) 1638ec5cf9d5SAlexander Stetsenko (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds); 1639745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 164019b94df9SMatthew Ahrens myerr = dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 1641*fb09f5aaSMadhav Suresh ASSERT0(myerr); 1642f18faf3fSek return (err); 1643f18faf3fSek } 1644ae46e4c7SMatthew Ahrens 1645ae46e4c7SMatthew Ahrens static int 1646ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1647ae46e4c7SMatthew Ahrens { 1648ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1649ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1650ae46e4c7SMatthew Ahrens int err; 1651ae46e4c7SMatthew Ahrens 1652ae46e4c7SMatthew Ahrens /* 1653ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1654ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1655ae46e4c7SMatthew Ahrens * can close it. 1656ae46e4c7SMatthew Ahrens */ 1657ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1658ae46e4c7SMatthew Ahrens 1659ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1660ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1661ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1662ae46e4c7SMatthew Ahrens 1663ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1664ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1665ae46e4c7SMatthew Ahrens if (err) { 1666ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1667ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1668ae46e4c7SMatthew Ahrens } else { 1669ec5cf9d5SAlexander Stetsenko if (drc->drc_guid_to_ds_map != NULL) 1670ec5cf9d5SAlexander Stetsenko (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds); 1671ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1672ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1673ae46e4c7SMatthew Ahrens } 1674ae46e4c7SMatthew Ahrens return (err); 1675ae46e4c7SMatthew Ahrens } 1676ae46e4c7SMatthew Ahrens 1677ae46e4c7SMatthew Ahrens int 1678ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1679ae46e4c7SMatthew Ahrens { 1680ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1681ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1682ae46e4c7SMatthew Ahrens else 1683ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1684ae46e4c7SMatthew Ahrens } 1685