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. 24*ad135b5dSChristopher 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 */ 60efb80947Sahrens ASSERT3U(len % 8, ==, 0); 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 809e69d7d0SLori Alt /* 819e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREE, push it out, 829e69d7d0SLori Alt * since free block aggregation can only be done for blocks of the 839e69d7d0SLori Alt * same type (i.e., DRR_FREE records can only be aggregated with 849e69d7d0SLori Alt * other DRR_FREE records. DRR_FREEOBJECTS records can only be 859e69d7d0SLori Alt * aggregated with other DRR_FREEOBJECTS records. 869e69d7d0SLori Alt */ 874e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE && 884e3c9f44SBill Pijewski dsp->dsa_pending_op != PENDING_FREE) { 894e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 904e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 919e69d7d0SLori Alt return (EINTR); 924e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 939e69d7d0SLori Alt } 949e69d7d0SLori Alt 954e3c9f44SBill Pijewski if (dsp->dsa_pending_op == PENDING_FREE) { 969e69d7d0SLori Alt /* 979e69d7d0SLori Alt * There should never be a PENDING_FREE if length is -1 989e69d7d0SLori Alt * (because dump_dnode is the only place where this 999e69d7d0SLori Alt * function is called with a -1, and only after flushing 1009e69d7d0SLori Alt * any pending record). 1019e69d7d0SLori Alt */ 1029e69d7d0SLori Alt ASSERT(length != -1ULL); 1039e69d7d0SLori Alt /* 1049e69d7d0SLori Alt * Check to see whether this free block can be aggregated 1059e69d7d0SLori Alt * with pending one. 1069e69d7d0SLori Alt */ 1079e69d7d0SLori Alt if (drrf->drr_object == object && drrf->drr_offset + 1089e69d7d0SLori Alt drrf->drr_length == offset) { 1099e69d7d0SLori Alt drrf->drr_length += length; 1109e69d7d0SLori Alt return (0); 1119e69d7d0SLori Alt } else { 1129e69d7d0SLori Alt /* not a continuation. Push out pending record */ 1134e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1149e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 1159e69d7d0SLori Alt return (EINTR); 1164e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 1179e69d7d0SLori Alt } 1189e69d7d0SLori Alt } 1199e69d7d0SLori Alt /* create a FREE record and make it pending */ 1204e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 1214e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_FREE; 1229e69d7d0SLori Alt drrf->drr_object = object; 1239e69d7d0SLori Alt drrf->drr_offset = offset; 1249e69d7d0SLori Alt drrf->drr_length = length; 1254e3c9f44SBill Pijewski drrf->drr_toguid = dsp->dsa_toguid; 1269e69d7d0SLori Alt if (length == -1ULL) { 1274e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1284e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 1299e69d7d0SLori Alt return (EINTR); 1309e69d7d0SLori Alt } else { 1314e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_FREE; 1329e69d7d0SLori Alt } 133efb80947Sahrens 134efb80947Sahrens return (0); 135efb80947Sahrens } 136efb80947Sahrens 137efb80947Sahrens static int 1384e3c9f44SBill Pijewski dump_data(dmu_sendarg_t *dsp, dmu_object_type_t type, 1398e714474SLori Alt uint64_t object, uint64_t offset, int blksz, const blkptr_t *bp, void *data) 140efb80947Sahrens { 1414e3c9f44SBill Pijewski struct drr_write *drrw = &(dsp->dsa_drr->drr_u.drr_write); 1429e69d7d0SLori Alt 1438e714474SLori Alt 1449e69d7d0SLori Alt /* 1459e69d7d0SLori Alt * If there is any kind of pending aggregation (currently either 1469e69d7d0SLori Alt * a grouping of free objects or free blocks), push it out to 1479e69d7d0SLori Alt * the stream, since aggregation can't be done across operations 1489e69d7d0SLori Alt * of different types. 1499e69d7d0SLori Alt */ 1504e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) { 1514e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1524e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 1539e69d7d0SLori Alt return (EINTR); 1544e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 1559e69d7d0SLori Alt } 156efb80947Sahrens /* write a DATA record */ 1574e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 1584e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_WRITE; 1599e69d7d0SLori Alt drrw->drr_object = object; 1609e69d7d0SLori Alt drrw->drr_type = type; 1619e69d7d0SLori Alt drrw->drr_offset = offset; 1629e69d7d0SLori Alt drrw->drr_length = blksz; 1634e3c9f44SBill Pijewski drrw->drr_toguid = dsp->dsa_toguid; 1648e714474SLori Alt drrw->drr_checksumtype = BP_GET_CHECKSUM(bp); 1658e714474SLori Alt if (zio_checksum_table[drrw->drr_checksumtype].ci_dedup) 1668e714474SLori Alt drrw->drr_checksumflags |= DRR_CHECKSUM_DEDUP; 1678e714474SLori Alt DDK_SET_LSIZE(&drrw->drr_key, BP_GET_LSIZE(bp)); 1688e714474SLori Alt DDK_SET_PSIZE(&drrw->drr_key, BP_GET_PSIZE(bp)); 1698e714474SLori Alt DDK_SET_COMPRESS(&drrw->drr_key, BP_GET_COMPRESS(bp)); 1708e714474SLori Alt drrw->drr_key.ddk_cksum = bp->blk_cksum; 171efb80947Sahrens 1724e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0) 173efb80947Sahrens return (EINTR); 1744e3c9f44SBill Pijewski if (dump_bytes(dsp, data, blksz) != 0) 175efb80947Sahrens return (EINTR); 176efb80947Sahrens return (0); 177efb80947Sahrens } 178efb80947Sahrens 1790a586ceaSMark Shellenbaum static int 1804e3c9f44SBill Pijewski dump_spill(dmu_sendarg_t *dsp, uint64_t object, int blksz, void *data) 1810a586ceaSMark Shellenbaum { 1824e3c9f44SBill Pijewski struct drr_spill *drrs = &(dsp->dsa_drr->drr_u.drr_spill); 1830a586ceaSMark Shellenbaum 1844e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) { 1854e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 1864e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 1870a586ceaSMark Shellenbaum return (EINTR); 1884e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 1890a586ceaSMark Shellenbaum } 1900a586ceaSMark Shellenbaum 1910a586ceaSMark Shellenbaum /* write a SPILL record */ 1924e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 1934e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_SPILL; 1940a586ceaSMark Shellenbaum drrs->drr_object = object; 1950a586ceaSMark Shellenbaum drrs->drr_length = blksz; 1964e3c9f44SBill Pijewski drrs->drr_toguid = dsp->dsa_toguid; 1970a586ceaSMark Shellenbaum 1984e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t))) 1990a586ceaSMark Shellenbaum return (EINTR); 2004e3c9f44SBill Pijewski if (dump_bytes(dsp, data, blksz)) 2010a586ceaSMark Shellenbaum return (EINTR); 2020a586ceaSMark Shellenbaum return (0); 2030a586ceaSMark Shellenbaum } 2040a586ceaSMark Shellenbaum 205efb80947Sahrens static int 2064e3c9f44SBill Pijewski dump_freeobjects(dmu_sendarg_t *dsp, uint64_t firstobj, uint64_t numobjs) 207efb80947Sahrens { 2084e3c9f44SBill Pijewski struct drr_freeobjects *drrfo = &(dsp->dsa_drr->drr_u.drr_freeobjects); 2099e69d7d0SLori Alt 2109e69d7d0SLori Alt /* 2119e69d7d0SLori Alt * If there is a pending op, but it's not PENDING_FREEOBJECTS, 2129e69d7d0SLori Alt * push it out, since free block aggregation can only be done for 2139e69d7d0SLori Alt * blocks of the same type (i.e., DRR_FREE records can only be 2149e69d7d0SLori Alt * aggregated with other DRR_FREE records. DRR_FREEOBJECTS records 2159e69d7d0SLori Alt * can only be aggregated with other DRR_FREEOBJECTS records. 2169e69d7d0SLori Alt */ 2174e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE && 2184e3c9f44SBill Pijewski dsp->dsa_pending_op != PENDING_FREEOBJECTS) { 2194e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 2204e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 2219e69d7d0SLori Alt return (EINTR); 2224e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 2239e69d7d0SLori Alt } 2244e3c9f44SBill Pijewski if (dsp->dsa_pending_op == PENDING_FREEOBJECTS) { 2259e69d7d0SLori Alt /* 2269e69d7d0SLori Alt * See whether this free object array can be aggregated 2279e69d7d0SLori Alt * with pending one 2289e69d7d0SLori Alt */ 2299e69d7d0SLori Alt if (drrfo->drr_firstobj + drrfo->drr_numobjs == firstobj) { 2309e69d7d0SLori Alt drrfo->drr_numobjs += numobjs; 2319e69d7d0SLori Alt return (0); 2329e69d7d0SLori Alt } else { 2339e69d7d0SLori Alt /* can't be aggregated. Push out pending record */ 2344e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 2359e69d7d0SLori Alt sizeof (dmu_replay_record_t)) != 0) 2369e69d7d0SLori Alt return (EINTR); 2374e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 2389e69d7d0SLori Alt } 2399e69d7d0SLori Alt } 2409e69d7d0SLori Alt 241efb80947Sahrens /* write a FREEOBJECTS record */ 2424e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 2434e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_FREEOBJECTS; 2449e69d7d0SLori Alt drrfo->drr_firstobj = firstobj; 2459e69d7d0SLori Alt drrfo->drr_numobjs = numobjs; 2464e3c9f44SBill Pijewski drrfo->drr_toguid = dsp->dsa_toguid; 2479e69d7d0SLori Alt 2484e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_FREEOBJECTS; 249efb80947Sahrens 250efb80947Sahrens return (0); 251efb80947Sahrens } 252efb80947Sahrens 253efb80947Sahrens static int 2544e3c9f44SBill Pijewski dump_dnode(dmu_sendarg_t *dsp, uint64_t object, dnode_phys_t *dnp) 255efb80947Sahrens { 2564e3c9f44SBill Pijewski struct drr_object *drro = &(dsp->dsa_drr->drr_u.drr_object); 2579e69d7d0SLori Alt 258efb80947Sahrens if (dnp == NULL || dnp->dn_type == DMU_OT_NONE) 2594e3c9f44SBill Pijewski return (dump_freeobjects(dsp, object, 1)); 260efb80947Sahrens 2614e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) { 2624e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, 2634e3c9f44SBill Pijewski sizeof (dmu_replay_record_t)) != 0) 2649e69d7d0SLori Alt return (EINTR); 2654e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 2669e69d7d0SLori Alt } 2679e69d7d0SLori Alt 268efb80947Sahrens /* write an OBJECT record */ 2694e3c9f44SBill Pijewski bzero(dsp->dsa_drr, sizeof (dmu_replay_record_t)); 2704e3c9f44SBill Pijewski dsp->dsa_drr->drr_type = DRR_OBJECT; 2719e69d7d0SLori Alt drro->drr_object = object; 2729e69d7d0SLori Alt drro->drr_type = dnp->dn_type; 2739e69d7d0SLori Alt drro->drr_bonustype = dnp->dn_bonustype; 2749e69d7d0SLori Alt drro->drr_blksz = dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT; 2759e69d7d0SLori Alt drro->drr_bonuslen = dnp->dn_bonuslen; 2769e69d7d0SLori Alt drro->drr_checksumtype = dnp->dn_checksum; 2779e69d7d0SLori Alt drro->drr_compress = dnp->dn_compress; 2784e3c9f44SBill Pijewski drro->drr_toguid = dsp->dsa_toguid; 2799e69d7d0SLori Alt 2804e3c9f44SBill Pijewski if (dump_bytes(dsp, dsp->dsa_drr, sizeof (dmu_replay_record_t)) != 0) 281efb80947Sahrens return (EINTR); 282efb80947Sahrens 2834e3c9f44SBill Pijewski if (dump_bytes(dsp, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)) != 0) 284efb80947Sahrens return (EINTR); 285efb80947Sahrens 286efb80947Sahrens /* free anything past the end of the file */ 2874e3c9f44SBill Pijewski if (dump_free(dsp, object, (dnp->dn_maxblkid + 1) * 288efb80947Sahrens (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL)) 289efb80947Sahrens return (EINTR); 2904e3c9f44SBill Pijewski if (dsp->dsa_err) 291efb80947Sahrens return (EINTR); 292efb80947Sahrens return (0); 293efb80947Sahrens } 294efb80947Sahrens 295efb80947Sahrens #define BP_SPAN(dnp, level) \ 296efb80947Sahrens (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \ 297efb80947Sahrens (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) 298efb80947Sahrens 299b24ab676SJeff Bonwick /* ARGSUSED */ 300efb80947Sahrens static int 3013f9d6ad7SLin Ling backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf, 302b24ab676SJeff Bonwick const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 303efb80947Sahrens { 3044e3c9f44SBill Pijewski dmu_sendarg_t *dsp = arg; 305efb80947Sahrens dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE; 306efb80947Sahrens int err = 0; 307efb80947Sahrens 308efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) 309efb80947Sahrens return (EINTR); 310efb80947Sahrens 311b24ab676SJeff Bonwick if (zb->zb_object != DMU_META_DNODE_OBJECT && 312b24ab676SJeff Bonwick DMU_OBJECT_IS_SPECIAL(zb->zb_object)) { 31314843421SMatthew Ahrens return (0); 314b24ab676SJeff Bonwick } else if (bp == NULL && zb->zb_object == DMU_META_DNODE_OBJECT) { 31588b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 31688b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT; 3174e3c9f44SBill Pijewski err = dump_freeobjects(dsp, dnobj, span >> DNODE_SHIFT); 318efb80947Sahrens } else if (bp == NULL) { 31988b7b0f2SMatthew Ahrens uint64_t span = BP_SPAN(dnp, zb->zb_level); 3204e3c9f44SBill Pijewski err = dump_free(dsp, zb->zb_object, zb->zb_blkid * span, span); 32188b7b0f2SMatthew Ahrens } else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) { 32288b7b0f2SMatthew Ahrens return (0); 32388b7b0f2SMatthew Ahrens } else if (type == DMU_OT_DNODE) { 32488b7b0f2SMatthew Ahrens dnode_phys_t *blk; 325efb80947Sahrens int i; 326efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 32788b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 32888b7b0f2SMatthew Ahrens arc_buf_t *abuf; 329efb80947Sahrens 3303f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 33188b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 33288b7b0f2SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 33388b7b0f2SMatthew Ahrens return (EIO); 33488b7b0f2SMatthew Ahrens 33588b7b0f2SMatthew Ahrens blk = abuf->b_data; 336efb80947Sahrens for (i = 0; i < blksz >> DNODE_SHIFT; i++) { 33788b7b0f2SMatthew Ahrens uint64_t dnobj = (zb->zb_blkid << 33888b7b0f2SMatthew Ahrens (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i; 3394e3c9f44SBill Pijewski err = dump_dnode(dsp, dnobj, blk+i); 340efb80947Sahrens if (err) 341efb80947Sahrens break; 342efb80947Sahrens } 34388b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 3440a586ceaSMark Shellenbaum } else if (type == DMU_OT_SA) { 3450a586ceaSMark Shellenbaum uint32_t aflags = ARC_WAIT; 3460a586ceaSMark Shellenbaum arc_buf_t *abuf; 3470a586ceaSMark Shellenbaum int blksz = BP_GET_LSIZE(bp); 3480a586ceaSMark Shellenbaum 3490a586ceaSMark Shellenbaum if (arc_read_nolock(NULL, spa, bp, 3500a586ceaSMark Shellenbaum arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 3510a586ceaSMark Shellenbaum ZIO_FLAG_CANFAIL, &aflags, zb) != 0) 3520a586ceaSMark Shellenbaum return (EIO); 3530a586ceaSMark Shellenbaum 3544e3c9f44SBill Pijewski err = dump_spill(dsp, zb->zb_object, blksz, abuf->b_data); 3550a586ceaSMark Shellenbaum (void) arc_buf_remove_ref(abuf, &abuf); 35688b7b0f2SMatthew Ahrens } else { /* it's a level-0 block of a regular object */ 35788b7b0f2SMatthew Ahrens uint32_t aflags = ARC_WAIT; 35888b7b0f2SMatthew Ahrens arc_buf_t *abuf; 359efb80947Sahrens int blksz = BP_GET_LSIZE(bp); 36088b7b0f2SMatthew Ahrens 3613f9d6ad7SLin Ling if (dsl_read(NULL, spa, bp, pbuf, 36288b7b0f2SMatthew Ahrens arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ, 36319b94df9SMatthew Ahrens ZIO_FLAG_CANFAIL, &aflags, zb) != 0) { 36419b94df9SMatthew Ahrens if (zfs_send_corrupt_data) { 36519b94df9SMatthew Ahrens /* Send a block filled with 0x"zfs badd bloc" */ 36619b94df9SMatthew Ahrens abuf = arc_buf_alloc(spa, blksz, &abuf, 36719b94df9SMatthew Ahrens ARC_BUFC_DATA); 36819b94df9SMatthew Ahrens uint64_t *ptr; 36919b94df9SMatthew Ahrens for (ptr = abuf->b_data; 37019b94df9SMatthew Ahrens (char *)ptr < (char *)abuf->b_data + blksz; 37119b94df9SMatthew Ahrens ptr++) 37219b94df9SMatthew Ahrens *ptr = 0x2f5baddb10c; 37319b94df9SMatthew Ahrens } else { 37419b94df9SMatthew Ahrens return (EIO); 37519b94df9SMatthew Ahrens } 37619b94df9SMatthew Ahrens } 37788b7b0f2SMatthew Ahrens 3784e3c9f44SBill Pijewski err = dump_data(dsp, type, zb->zb_object, zb->zb_blkid * blksz, 3798e714474SLori Alt blksz, bp, abuf->b_data); 38088b7b0f2SMatthew Ahrens (void) arc_buf_remove_ref(abuf, &abuf); 381efb80947Sahrens } 382efb80947Sahrens 383efb80947Sahrens ASSERT(err == 0 || err == EINTR); 384efb80947Sahrens return (err); 385efb80947Sahrens } 386efb80947Sahrens 387efb80947Sahrens int 3884e3c9f44SBill Pijewski dmu_send(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 3894e3c9f44SBill Pijewski int outfd, vnode_t *vp, offset_t *off) 390efb80947Sahrens { 391503ad85cSMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 392503ad85cSMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 393efb80947Sahrens dmu_replay_record_t *drr; 3944e3c9f44SBill Pijewski dmu_sendarg_t *dsp; 395efb80947Sahrens int err; 3963cb34c60Sahrens uint64_t fromtxg = 0; 397efb80947Sahrens 398efb80947Sahrens /* tosnap must be a snapshot */ 399efb80947Sahrens if (ds->ds_phys->ds_next_snap_obj == 0) 400efb80947Sahrens return (EINVAL); 401efb80947Sahrens 402efb80947Sahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 403efb80947Sahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 4043cb34c60Sahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 405efb80947Sahrens return (EXDEV); 406efb80947Sahrens 4073cb34c60Sahrens if (fromorigin) { 408088f3894Sahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 409088f3894Sahrens 4103cb34c60Sahrens if (fromsnap) 4113cb34c60Sahrens return (EINVAL); 4123cb34c60Sahrens 413088f3894Sahrens if (dsl_dir_is_clone(ds->ds_dir)) { 4143cb34c60Sahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 415745cd3c5Smaybee err = dsl_dataset_hold_obj(dp, 416745cd3c5Smaybee ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 4173cb34c60Sahrens rw_exit(&dp->dp_config_rwlock); 4183cb34c60Sahrens if (err) 4193cb34c60Sahrens return (err); 4203cb34c60Sahrens } else { 4213cb34c60Sahrens fromorigin = B_FALSE; 4223cb34c60Sahrens } 4233cb34c60Sahrens } 4243cb34c60Sahrens 4253cb34c60Sahrens 426efb80947Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 427efb80947Sahrens drr->drr_type = DRR_BEGIN; 428efb80947Sahrens drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC; 4299e69d7d0SLori Alt DMU_SET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo, 4309e69d7d0SLori Alt DMU_SUBSTREAM); 431dc7cd546SMark Shellenbaum 432dc7cd546SMark Shellenbaum #ifdef _KERNEL 433dc7cd546SMark Shellenbaum if (dmu_objset_type(tosnap) == DMU_OST_ZFS) { 434dc7cd546SMark Shellenbaum uint64_t version; 4354e3c9f44SBill Pijewski if (zfs_get_zplprop(tosnap, ZFS_PROP_VERSION, &version) != 0) { 4364e3c9f44SBill Pijewski kmem_free(drr, sizeof (dmu_replay_record_t)); 437dc7cd546SMark Shellenbaum return (EINVAL); 4384e3c9f44SBill Pijewski } 439dc7cd546SMark Shellenbaum if (version == ZPL_VERSION_SA) { 440dc7cd546SMark Shellenbaum DMU_SET_FEATUREFLAGS( 441dc7cd546SMark Shellenbaum drr->drr_u.drr_begin.drr_versioninfo, 442dc7cd546SMark Shellenbaum DMU_BACKUP_FEATURE_SA_SPILL); 443dc7cd546SMark Shellenbaum } 444dc7cd546SMark Shellenbaum } 445dc7cd546SMark Shellenbaum #endif 446dc7cd546SMark Shellenbaum 447efb80947Sahrens drr->drr_u.drr_begin.drr_creation_time = 448efb80947Sahrens ds->ds_phys->ds_creation_time; 449503ad85cSMatthew Ahrens drr->drr_u.drr_begin.drr_type = tosnap->os_phys->os_type; 4503cb34c60Sahrens if (fromorigin) 4513cb34c60Sahrens drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE; 452efb80947Sahrens drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid; 453ab04eb8eStimh if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET) 454ab04eb8eStimh drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA; 455ab04eb8eStimh 456efb80947Sahrens if (fromds) 457efb80947Sahrens drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid; 458efb80947Sahrens dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname); 459efb80947Sahrens 4603cb34c60Sahrens if (fromds) 4613cb34c60Sahrens fromtxg = fromds->ds_phys->ds_creation_txg; 4623cb34c60Sahrens if (fromorigin) 463745cd3c5Smaybee dsl_dataset_rele(fromds, FTAG); 4643cb34c60Sahrens 4654e3c9f44SBill Pijewski dsp = kmem_zalloc(sizeof (dmu_sendarg_t), KM_SLEEP); 4664e3c9f44SBill Pijewski 4674e3c9f44SBill Pijewski dsp->dsa_drr = drr; 4684e3c9f44SBill Pijewski dsp->dsa_vp = vp; 4694e3c9f44SBill Pijewski dsp->dsa_outfd = outfd; 4704e3c9f44SBill Pijewski dsp->dsa_proc = curproc; 4714e3c9f44SBill Pijewski dsp->dsa_os = tosnap; 4724e3c9f44SBill Pijewski dsp->dsa_off = off; 4734e3c9f44SBill Pijewski dsp->dsa_toguid = ds->ds_phys->ds_guid; 4744e3c9f44SBill Pijewski ZIO_SET_CHECKSUM(&dsp->dsa_zc, 0, 0, 0, 0); 4754e3c9f44SBill Pijewski dsp->dsa_pending_op = PENDING_NONE; 4764e3c9f44SBill Pijewski 4774e3c9f44SBill Pijewski mutex_enter(&ds->ds_sendstream_lock); 4784e3c9f44SBill Pijewski list_insert_head(&ds->ds_sendstreams, dsp); 4794e3c9f44SBill Pijewski mutex_exit(&ds->ds_sendstream_lock); 4804e3c9f44SBill Pijewski 4814e3c9f44SBill Pijewski if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) { 4824e3c9f44SBill Pijewski err = dsp->dsa_err; 4834e3c9f44SBill Pijewski goto out; 484efb80947Sahrens } 485efb80947Sahrens 48688b7b0f2SMatthew Ahrens err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH, 4874e3c9f44SBill Pijewski backup_cb, dsp); 488efb80947Sahrens 4894e3c9f44SBill Pijewski if (dsp->dsa_pending_op != PENDING_NONE) 4904e3c9f44SBill Pijewski if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) 4919e69d7d0SLori Alt err = EINTR; 4929e69d7d0SLori Alt 493efb80947Sahrens if (err) { 4944e3c9f44SBill Pijewski if (err == EINTR && dsp->dsa_err) 4954e3c9f44SBill Pijewski err = dsp->dsa_err; 4964e3c9f44SBill Pijewski goto out; 497efb80947Sahrens } 498efb80947Sahrens 499efb80947Sahrens bzero(drr, sizeof (dmu_replay_record_t)); 500efb80947Sahrens drr->drr_type = DRR_END; 5014e3c9f44SBill Pijewski drr->drr_u.drr_end.drr_checksum = dsp->dsa_zc; 5024e3c9f44SBill Pijewski drr->drr_u.drr_end.drr_toguid = dsp->dsa_toguid; 503efb80947Sahrens 5044e3c9f44SBill Pijewski if (dump_bytes(dsp, drr, sizeof (dmu_replay_record_t)) != 0) { 5054e3c9f44SBill Pijewski err = dsp->dsa_err; 5064e3c9f44SBill Pijewski goto out; 5077b5309bbSgw } 508efb80947Sahrens 5094e3c9f44SBill Pijewski out: 5104e3c9f44SBill Pijewski mutex_enter(&ds->ds_sendstream_lock); 5114e3c9f44SBill Pijewski list_remove(&ds->ds_sendstreams, dsp); 5124e3c9f44SBill Pijewski mutex_exit(&ds->ds_sendstream_lock); 5134e3c9f44SBill Pijewski 514efb80947Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 5154e3c9f44SBill Pijewski kmem_free(dsp, sizeof (dmu_sendarg_t)); 516efb80947Sahrens 5174e3c9f44SBill Pijewski return (err); 518efb80947Sahrens } 519efb80947Sahrens 52019b94df9SMatthew Ahrens int 52119b94df9SMatthew Ahrens dmu_send_estimate(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin, 52219b94df9SMatthew Ahrens uint64_t *sizep) 52319b94df9SMatthew Ahrens { 52419b94df9SMatthew Ahrens dsl_dataset_t *ds = tosnap->os_dsl_dataset; 52519b94df9SMatthew Ahrens dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL; 52619b94df9SMatthew Ahrens dsl_pool_t *dp = ds->ds_dir->dd_pool; 52719b94df9SMatthew Ahrens int err; 52819b94df9SMatthew Ahrens uint64_t size; 52919b94df9SMatthew Ahrens 53019b94df9SMatthew Ahrens /* tosnap must be a snapshot */ 53119b94df9SMatthew Ahrens if (ds->ds_phys->ds_next_snap_obj == 0) 53219b94df9SMatthew Ahrens return (EINVAL); 53319b94df9SMatthew Ahrens 53419b94df9SMatthew Ahrens /* fromsnap must be an earlier snapshot from the same fs as tosnap */ 53519b94df9SMatthew Ahrens if (fromds && (ds->ds_dir != fromds->ds_dir || 53619b94df9SMatthew Ahrens fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg)) 53719b94df9SMatthew Ahrens return (EXDEV); 53819b94df9SMatthew Ahrens 53919b94df9SMatthew Ahrens if (fromorigin) { 54019b94df9SMatthew Ahrens if (fromsnap) 54119b94df9SMatthew Ahrens return (EINVAL); 54219b94df9SMatthew Ahrens 54319b94df9SMatthew Ahrens if (dsl_dir_is_clone(ds->ds_dir)) { 54419b94df9SMatthew Ahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 54519b94df9SMatthew Ahrens err = dsl_dataset_hold_obj(dp, 54619b94df9SMatthew Ahrens ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds); 54719b94df9SMatthew Ahrens rw_exit(&dp->dp_config_rwlock); 54819b94df9SMatthew Ahrens if (err) 54919b94df9SMatthew Ahrens return (err); 55019b94df9SMatthew Ahrens } else { 55119b94df9SMatthew Ahrens fromorigin = B_FALSE; 55219b94df9SMatthew Ahrens } 55319b94df9SMatthew Ahrens } 55419b94df9SMatthew Ahrens 55519b94df9SMatthew Ahrens /* Get uncompressed size estimate of changed data. */ 55619b94df9SMatthew Ahrens if (fromds == NULL) { 55719b94df9SMatthew Ahrens size = ds->ds_phys->ds_uncompressed_bytes; 55819b94df9SMatthew Ahrens } else { 55919b94df9SMatthew Ahrens uint64_t used, comp; 56019b94df9SMatthew Ahrens err = dsl_dataset_space_written(fromds, ds, 56119b94df9SMatthew Ahrens &used, &comp, &size); 56219b94df9SMatthew Ahrens if (fromorigin) 56319b94df9SMatthew Ahrens dsl_dataset_rele(fromds, FTAG); 56419b94df9SMatthew Ahrens if (err) 56519b94df9SMatthew Ahrens return (err); 56619b94df9SMatthew Ahrens } 56719b94df9SMatthew Ahrens 56819b94df9SMatthew Ahrens /* 56919b94df9SMatthew Ahrens * Assume that space (both on-disk and in-stream) is dominated by 57019b94df9SMatthew Ahrens * data. We will adjust for indirect blocks and the copies property, 57119b94df9SMatthew Ahrens * but ignore per-object space used (eg, dnodes and DRR_OBJECT records). 57219b94df9SMatthew Ahrens */ 57319b94df9SMatthew Ahrens 57419b94df9SMatthew Ahrens /* 57519b94df9SMatthew Ahrens * Subtract out approximate space used by indirect blocks. 57619b94df9SMatthew Ahrens * Assume most space is used by data blocks (non-indirect, non-dnode). 57719b94df9SMatthew Ahrens * Assume all blocks are recordsize. Assume ditto blocks and 57819b94df9SMatthew Ahrens * internal fragmentation counter out compression. 57919b94df9SMatthew Ahrens * 58019b94df9SMatthew Ahrens * Therefore, space used by indirect blocks is sizeof(blkptr_t) per 58119b94df9SMatthew Ahrens * block, which we observe in practice. 58219b94df9SMatthew Ahrens */ 58319b94df9SMatthew Ahrens uint64_t recordsize; 58419b94df9SMatthew Ahrens rw_enter(&dp->dp_config_rwlock, RW_READER); 58519b94df9SMatthew Ahrens err = dsl_prop_get_ds(ds, "recordsize", 58619b94df9SMatthew Ahrens sizeof (recordsize), 1, &recordsize, NULL); 58719b94df9SMatthew Ahrens rw_exit(&dp->dp_config_rwlock); 58819b94df9SMatthew Ahrens if (err) 58919b94df9SMatthew Ahrens return (err); 59019b94df9SMatthew Ahrens size -= size / recordsize * sizeof (blkptr_t); 59119b94df9SMatthew Ahrens 59219b94df9SMatthew Ahrens /* Add in the space for the record associated with each block. */ 59319b94df9SMatthew Ahrens size += size / recordsize * sizeof (dmu_replay_record_t); 59419b94df9SMatthew Ahrens 59519b94df9SMatthew Ahrens *sizep = size; 59619b94df9SMatthew Ahrens 59719b94df9SMatthew Ahrens return (0); 59819b94df9SMatthew Ahrens } 59919b94df9SMatthew Ahrens 6003cb34c60Sahrens struct recvbeginsyncarg { 6013cb34c60Sahrens const char *tofs; 6023cb34c60Sahrens const char *tosnap; 6033cb34c60Sahrens dsl_dataset_t *origin; 6043cb34c60Sahrens uint64_t fromguid; 6053cb34c60Sahrens dmu_objset_type_t type; 6063cb34c60Sahrens void *tag; 6073cb34c60Sahrens boolean_t force; 608ab04eb8eStimh uint64_t dsflags; 6093cb34c60Sahrens char clonelastname[MAXNAMELEN]; 6103cb34c60Sahrens dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */ 6113f9d6ad7SLin Ling cred_t *cr; 612efb80947Sahrens }; 613efb80947Sahrens 614efb80947Sahrens /* ARGSUSED */ 615efb80947Sahrens static int 616ae46e4c7SMatthew Ahrens recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx) 617efb80947Sahrens { 618efb80947Sahrens dsl_dir_t *dd = arg1; 6193cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 620efb80947Sahrens objset_t *mos = dd->dd_pool->dp_meta_objset; 621efb80947Sahrens uint64_t val; 622efb80947Sahrens int err; 623efb80947Sahrens 624efb80947Sahrens err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj, 6253cb34c60Sahrens strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val); 626efb80947Sahrens 627efb80947Sahrens if (err != ENOENT) 628efb80947Sahrens return (err ? err : EEXIST); 629efb80947Sahrens 6303cb34c60Sahrens if (rbsa->origin) { 6313cb34c60Sahrens /* make sure it's a snap in the same pool */ 6323cb34c60Sahrens if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool) 6333cb34c60Sahrens return (EXDEV); 634ae46e4c7SMatthew Ahrens if (!dsl_dataset_is_snapshot(rbsa->origin)) 6353cb34c60Sahrens return (EINVAL); 6363cb34c60Sahrens if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid) 6373cb34c60Sahrens return (ENODEV); 6383cb34c60Sahrens } 6393cb34c60Sahrens 640efb80947Sahrens return (0); 641efb80947Sahrens } 642efb80947Sahrens 643efb80947Sahrens static void 6443f9d6ad7SLin Ling recv_new_sync(void *arg1, void *arg2, dmu_tx_t *tx) 645efb80947Sahrens { 646efb80947Sahrens dsl_dir_t *dd = arg1; 6473cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 648745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 649efb80947Sahrens uint64_t dsobj; 650efb80947Sahrens 651ae46e4c7SMatthew Ahrens /* Create and open new dataset. */ 6523cb34c60Sahrens dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1, 6533f9d6ad7SLin Ling rbsa->origin, flags, rbsa->cr, tx); 654ae46e4c7SMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj, 655503ad85cSMatthew Ahrens B_TRUE, dmu_recv_tag, &rbsa->ds)); 656efb80947Sahrens 657ae46e4c7SMatthew Ahrens if (rbsa->origin == NULL) { 658ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dd->dd_pool->dp_spa, 659ae46e4c7SMatthew Ahrens rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx); 6603cb34c60Sahrens } 661ecd6cf80Smarks 6623f9d6ad7SLin Ling spa_history_log_internal(LOG_DS_REPLAY_FULL_SYNC, 6633f9d6ad7SLin Ling dd->dd_pool->dp_spa, tx, "dataset = %lld", dsobj); 6643cb34c60Sahrens } 665f18faf3fSek 666f18faf3fSek /* ARGSUSED */ 667f18faf3fSek static int 668ae46e4c7SMatthew Ahrens recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx) 669f18faf3fSek { 6703cb34c60Sahrens dsl_dataset_t *ds = arg1; 6713cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 6723cb34c60Sahrens int err; 6733cb34c60Sahrens uint64_t val; 674f18faf3fSek 6753cb34c60Sahrens /* must not have any changes since most recent snapshot */ 6763cb34c60Sahrens if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds)) 677f18faf3fSek return (ETXTBSY); 678f18faf3fSek 679feaa74e4SMark Maybee /* new snapshot name must not exist */ 680feaa74e4SMark Maybee err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 681feaa74e4SMark Maybee ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val); 682feaa74e4SMark Maybee if (err == 0) 683feaa74e4SMark Maybee return (EEXIST); 684feaa74e4SMark Maybee if (err != ENOENT) 685feaa74e4SMark Maybee return (err); 686feaa74e4SMark Maybee 687ae46e4c7SMatthew Ahrens if (rbsa->fromguid) { 688ae46e4c7SMatthew Ahrens /* if incremental, most recent snapshot must match fromguid */ 689ae46e4c7SMatthew Ahrens if (ds->ds_prev == NULL) 690ae46e4c7SMatthew Ahrens return (ENODEV); 69192241e0bSTom Erickson 69292241e0bSTom Erickson /* 69392241e0bSTom Erickson * most recent snapshot must match fromguid, or there are no 69492241e0bSTom Erickson * changes since the fromguid one 69592241e0bSTom Erickson */ 69692241e0bSTom Erickson if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid) { 69792241e0bSTom Erickson uint64_t birth = ds->ds_prev->ds_phys->ds_bp.blk_birth; 69892241e0bSTom Erickson uint64_t obj = ds->ds_prev->ds_phys->ds_prev_snap_obj; 69992241e0bSTom Erickson while (obj != 0) { 70092241e0bSTom Erickson dsl_dataset_t *snap; 70192241e0bSTom Erickson err = dsl_dataset_hold_obj(ds->ds_dir->dd_pool, 70292241e0bSTom Erickson obj, FTAG, &snap); 70392241e0bSTom Erickson if (err) 70492241e0bSTom Erickson return (ENODEV); 70592241e0bSTom Erickson if (snap->ds_phys->ds_creation_txg < birth) { 70692241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 70792241e0bSTom Erickson return (ENODEV); 70892241e0bSTom Erickson } 70992241e0bSTom Erickson if (snap->ds_phys->ds_guid == rbsa->fromguid) { 71092241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 71192241e0bSTom Erickson break; /* it's ok */ 71292241e0bSTom Erickson } 71392241e0bSTom Erickson obj = snap->ds_phys->ds_prev_snap_obj; 71492241e0bSTom Erickson dsl_dataset_rele(snap, FTAG); 71592241e0bSTom Erickson } 71692241e0bSTom Erickson if (obj == 0) 71792241e0bSTom Erickson return (ENODEV); 71892241e0bSTom Erickson } 719ae46e4c7SMatthew Ahrens } else { 720ae46e4c7SMatthew Ahrens /* if full, most recent snapshot must be $ORIGIN */ 721ae46e4c7SMatthew Ahrens if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL) 722ae46e4c7SMatthew Ahrens return (ENODEV); 723ae46e4c7SMatthew Ahrens } 7243cb34c60Sahrens 72547f263f4Sek /* temporary clone name must not exist */ 72647f263f4Sek err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset, 72747f263f4Sek ds->ds_dir->dd_phys->dd_child_dir_zapobj, 72847f263f4Sek rbsa->clonelastname, 8, 1, &val); 72947f263f4Sek if (err == 0) 73047f263f4Sek return (EEXIST); 73147f263f4Sek if (err != ENOENT) 73247f263f4Sek return (err); 73347f263f4Sek 7343cb34c60Sahrens return (0); 735f18faf3fSek } 736f18faf3fSek 737f18faf3fSek /* ARGSUSED */ 738f18faf3fSek static void 7393f9d6ad7SLin Ling recv_existing_sync(void *arg1, void *arg2, dmu_tx_t *tx) 740f18faf3fSek { 7413cb34c60Sahrens dsl_dataset_t *ohds = arg1; 7423cb34c60Sahrens struct recvbeginsyncarg *rbsa = arg2; 7433cb34c60Sahrens dsl_pool_t *dp = ohds->ds_dir->dd_pool; 744ae46e4c7SMatthew Ahrens dsl_dataset_t *cds; 745745cd3c5Smaybee uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags; 746f18faf3fSek uint64_t dsobj; 747f18faf3fSek 748ae46e4c7SMatthew Ahrens /* create and open the temporary clone */ 749ae46e4c7SMatthew Ahrens dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname, 7503f9d6ad7SLin Ling ohds->ds_prev, flags, rbsa->cr, tx); 751503ad85cSMatthew Ahrens VERIFY(0 == dsl_dataset_own_obj(dp, dsobj, B_TRUE, dmu_recv_tag, &cds)); 7523cb34c60Sahrens 753ae46e4c7SMatthew Ahrens /* 754ae46e4c7SMatthew Ahrens * If we actually created a non-clone, we need to create the 755ae46e4c7SMatthew Ahrens * objset in our new dataset. 756ae46e4c7SMatthew Ahrens */ 757ae46e4c7SMatthew Ahrens if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) { 758ae46e4c7SMatthew Ahrens (void) dmu_objset_create_impl(dp->dp_spa, 759ae46e4c7SMatthew Ahrens cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx); 760ae46e4c7SMatthew Ahrens } 761ae46e4c7SMatthew Ahrens 7623cb34c60Sahrens rbsa->ds = cds; 7633cb34c60Sahrens 7643f9d6ad7SLin Ling spa_history_log_internal(LOG_DS_REPLAY_INC_SYNC, 7653f9d6ad7SLin Ling dp->dp_spa, tx, "dataset = %lld", dsobj); 7663cb34c60Sahrens } 7673cb34c60Sahrens 768dc7cd546SMark Shellenbaum static boolean_t 769dc7cd546SMark Shellenbaum dmu_recv_verify_features(dsl_dataset_t *ds, struct drr_begin *drrb) 770dc7cd546SMark Shellenbaum { 771dc7cd546SMark Shellenbaum int featureflags; 772dc7cd546SMark Shellenbaum 773dc7cd546SMark Shellenbaum featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 774dc7cd546SMark Shellenbaum 775dc7cd546SMark Shellenbaum /* Verify pool version supports SA if SA_SPILL feature set */ 776dc7cd546SMark Shellenbaum return ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) && 777dc7cd546SMark Shellenbaum (spa_version(dsl_dataset_get_spa(ds)) < SPA_VERSION_SA)); 778dc7cd546SMark Shellenbaum } 779dc7cd546SMark Shellenbaum 7803cb34c60Sahrens /* 7813cb34c60Sahrens * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 7823cb34c60Sahrens * succeeds; otherwise we will leak the holds on the datasets. 7833cb34c60Sahrens */ 7843cb34c60Sahrens int 7859e69d7d0SLori Alt dmu_recv_begin(char *tofs, char *tosnap, char *top_ds, struct drr_begin *drrb, 786f4b94bdeSMatthew Ahrens boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc) 787efb80947Sahrens { 7883cb34c60Sahrens int err = 0; 7893cb34c60Sahrens boolean_t byteswap; 790ae46e4c7SMatthew Ahrens struct recvbeginsyncarg rbsa = { 0 }; 7919e69d7d0SLori Alt uint64_t versioninfo; 7923cb34c60Sahrens int flags; 7933cb34c60Sahrens dsl_dataset_t *ds; 794efb80947Sahrens 7953cb34c60Sahrens if (drrb->drr_magic == DMU_BACKUP_MAGIC) 7963cb34c60Sahrens byteswap = FALSE; 7973cb34c60Sahrens else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 7983cb34c60Sahrens byteswap = TRUE; 7993cb34c60Sahrens else 8003cb34c60Sahrens return (EINVAL); 8013cb34c60Sahrens 8023cb34c60Sahrens rbsa.tofs = tofs; 8033cb34c60Sahrens rbsa.tosnap = tosnap; 804503ad85cSMatthew Ahrens rbsa.origin = origin ? origin->os_dsl_dataset : NULL; 8053cb34c60Sahrens rbsa.fromguid = drrb->drr_fromguid; 8063cb34c60Sahrens rbsa.type = drrb->drr_type; 8073cb34c60Sahrens rbsa.tag = FTAG; 808ab04eb8eStimh rbsa.dsflags = 0; 8093f9d6ad7SLin Ling rbsa.cr = CRED(); 8109e69d7d0SLori Alt versioninfo = drrb->drr_versioninfo; 8113cb34c60Sahrens flags = drrb->drr_flags; 8123cb34c60Sahrens 8133cb34c60Sahrens if (byteswap) { 8143cb34c60Sahrens rbsa.type = BSWAP_32(rbsa.type); 8153cb34c60Sahrens rbsa.fromguid = BSWAP_64(rbsa.fromguid); 8169e69d7d0SLori Alt versioninfo = BSWAP_64(versioninfo); 8173cb34c60Sahrens flags = BSWAP_32(flags); 8183cb34c60Sahrens } 819efb80947Sahrens 8209e69d7d0SLori Alt if (DMU_GET_STREAM_HDRTYPE(versioninfo) == DMU_COMPOUNDSTREAM || 8213cb34c60Sahrens rbsa.type >= DMU_OST_NUMTYPES || 8223cb34c60Sahrens ((flags & DRR_FLAG_CLONE) && origin == NULL)) 823efb80947Sahrens return (EINVAL); 824efb80947Sahrens 825ab04eb8eStimh if (flags & DRR_FLAG_CI_DATA) 826ab04eb8eStimh rbsa.dsflags = DS_FLAG_CI_DATASET; 827ab04eb8eStimh 8283cb34c60Sahrens bzero(drc, sizeof (dmu_recv_cookie_t)); 8293cb34c60Sahrens drc->drc_drrb = drrb; 8303cb34c60Sahrens drc->drc_tosnap = tosnap; 8319e69d7d0SLori Alt drc->drc_top_ds = top_ds; 8323cb34c60Sahrens drc->drc_force = force; 833efb80947Sahrens 8343cb34c60Sahrens /* 8353cb34c60Sahrens * Process the begin in syncing context. 8363cb34c60Sahrens */ 837efb80947Sahrens 838ae46e4c7SMatthew Ahrens /* open the dataset we are logically receiving into */ 839ae46e4c7SMatthew Ahrens err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds); 840ae46e4c7SMatthew Ahrens if (err == 0) { 841dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 842dc7cd546SMark Shellenbaum dsl_dataset_rele(ds, dmu_recv_tag); 843dc7cd546SMark Shellenbaum return (ENOTSUP); 844dc7cd546SMark Shellenbaum } 845ae46e4c7SMatthew Ahrens /* target fs already exists; recv into temp clone */ 846efb80947Sahrens 847ae46e4c7SMatthew Ahrens /* Can't recv a clone into an existing fs */ 848ae46e4c7SMatthew Ahrens if (flags & DRR_FLAG_CLONE) { 849ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 850ae46e4c7SMatthew Ahrens return (EINVAL); 851ae46e4c7SMatthew Ahrens } 852efb80947Sahrens 853f4b94bdeSMatthew Ahrens /* must not have an incremental recv already in progress */ 854f4b94bdeSMatthew Ahrens if (!mutex_tryenter(&ds->ds_recvlock)) { 855f4b94bdeSMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 856f4b94bdeSMatthew Ahrens return (EBUSY); 857f4b94bdeSMatthew Ahrens } 858f4b94bdeSMatthew Ahrens 859ae46e4c7SMatthew Ahrens /* tmp clone name is: tofs/%tosnap" */ 860ae46e4c7SMatthew Ahrens (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname), 861ae46e4c7SMatthew Ahrens "%%%s", tosnap); 8623cb34c60Sahrens rbsa.force = force; 8633cb34c60Sahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 864ae46e4c7SMatthew Ahrens recv_existing_check, recv_existing_sync, ds, &rbsa, 5); 8653cb34c60Sahrens if (err) { 866f4b94bdeSMatthew Ahrens mutex_exit(&ds->ds_recvlock); 867745cd3c5Smaybee dsl_dataset_rele(ds, dmu_recv_tag); 8683cb34c60Sahrens return (err); 8693cb34c60Sahrens } 8703cb34c60Sahrens drc->drc_logical_ds = ds; 8713cb34c60Sahrens drc->drc_real_ds = rbsa.ds; 872ae46e4c7SMatthew Ahrens } else if (err == ENOENT) { 873ae46e4c7SMatthew Ahrens /* target fs does not exist; must be a full backup or clone */ 874ae46e4c7SMatthew Ahrens char *cp; 875efb80947Sahrens 876ae46e4c7SMatthew Ahrens /* 877ae46e4c7SMatthew Ahrens * If it's a non-clone incremental, we are missing the 878ae46e4c7SMatthew Ahrens * target fs, so fail the recv. 879ae46e4c7SMatthew Ahrens */ 880ae46e4c7SMatthew Ahrens if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) 881ae46e4c7SMatthew Ahrens return (ENOENT); 882ae46e4c7SMatthew Ahrens 883ae46e4c7SMatthew Ahrens /* Open the parent of tofs */ 884ae46e4c7SMatthew Ahrens cp = strrchr(tofs, '/'); 885ae46e4c7SMatthew Ahrens *cp = '\0'; 886bdd1c119SChris Kirby err = dsl_dataset_hold(tofs, FTAG, &ds); 887ae46e4c7SMatthew Ahrens *cp = '/'; 8883cb34c60Sahrens if (err) 8893cb34c60Sahrens return (err); 890efb80947Sahrens 891dc7cd546SMark Shellenbaum if (dmu_recv_verify_features(ds, drrb)) { 8928fe33373SMatthew Ahrens dsl_dataset_rele(ds, FTAG); 893dc7cd546SMark Shellenbaum return (ENOTSUP); 894dc7cd546SMark Shellenbaum } 895dc7cd546SMark Shellenbaum 896ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 897ae46e4c7SMatthew Ahrens recv_new_check, recv_new_sync, ds->ds_dir, &rbsa, 5); 898bdd1c119SChris Kirby dsl_dataset_rele(ds, FTAG); 8993cb34c60Sahrens if (err) 9003cb34c60Sahrens return (err); 9013cb34c60Sahrens drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds; 9023cb34c60Sahrens drc->drc_newfs = B_TRUE; 9033cb34c60Sahrens } 9043cb34c60Sahrens 905ae46e4c7SMatthew Ahrens return (err); 906efb80947Sahrens } 907efb80947Sahrens 9083cb34c60Sahrens struct restorearg { 9093cb34c60Sahrens int err; 9103cb34c60Sahrens int byteswap; 9113cb34c60Sahrens vnode_t *vp; 9123cb34c60Sahrens char *buf; 9133cb34c60Sahrens uint64_t voff; 9143cb34c60Sahrens int bufsize; /* amount of memory allocated for buf */ 9153cb34c60Sahrens zio_cksum_t cksum; 916c99e4bdcSChris Kirby avl_tree_t *guid_to_ds_map; 9173cb34c60Sahrens }; 9183cb34c60Sahrens 9199e69d7d0SLori Alt typedef struct guid_map_entry { 9209e69d7d0SLori Alt uint64_t guid; 9219e69d7d0SLori Alt dsl_dataset_t *gme_ds; 9229e69d7d0SLori Alt avl_node_t avlnode; 9239e69d7d0SLori Alt } guid_map_entry_t; 9249e69d7d0SLori Alt 9259e69d7d0SLori Alt static int 9269e69d7d0SLori Alt guid_compare(const void *arg1, const void *arg2) 9279e69d7d0SLori Alt { 9289e69d7d0SLori Alt const guid_map_entry_t *gmep1 = arg1; 9299e69d7d0SLori Alt const guid_map_entry_t *gmep2 = arg2; 9309e69d7d0SLori Alt 9319e69d7d0SLori Alt if (gmep1->guid < gmep2->guid) 9329e69d7d0SLori Alt return (-1); 9339e69d7d0SLori Alt else if (gmep1->guid > gmep2->guid) 9349e69d7d0SLori Alt return (1); 9359e69d7d0SLori Alt return (0); 9369e69d7d0SLori Alt } 9379e69d7d0SLori Alt 938c99e4bdcSChris Kirby static void 939c99e4bdcSChris Kirby free_guid_map_onexit(void *arg) 940c99e4bdcSChris Kirby { 941c99e4bdcSChris Kirby avl_tree_t *ca = arg; 942c99e4bdcSChris Kirby void *cookie = NULL; 943c99e4bdcSChris Kirby guid_map_entry_t *gmep; 944c99e4bdcSChris Kirby 945c99e4bdcSChris Kirby while ((gmep = avl_destroy_nodes(ca, &cookie)) != NULL) { 946c99e4bdcSChris Kirby dsl_dataset_rele(gmep->gme_ds, ca); 947c99e4bdcSChris Kirby kmem_free(gmep, sizeof (guid_map_entry_t)); 948c99e4bdcSChris Kirby } 949c99e4bdcSChris Kirby avl_destroy(ca); 950c99e4bdcSChris Kirby kmem_free(ca, sizeof (avl_tree_t)); 951c99e4bdcSChris Kirby } 952c99e4bdcSChris Kirby 953efb80947Sahrens static void * 954efb80947Sahrens restore_read(struct restorearg *ra, int len) 955efb80947Sahrens { 956efb80947Sahrens void *rv; 9573cb34c60Sahrens int done = 0; 958efb80947Sahrens 959efb80947Sahrens /* some things will require 8-byte alignment, so everything must */ 960efb80947Sahrens ASSERT3U(len % 8, ==, 0); 961efb80947Sahrens 9623cb34c60Sahrens while (done < len) { 963efb80947Sahrens ssize_t resid; 964efb80947Sahrens 965efb80947Sahrens ra->err = vn_rdwr(UIO_READ, ra->vp, 9663cb34c60Sahrens (caddr_t)ra->buf + done, len - done, 967efb80947Sahrens ra->voff, UIO_SYSSPACE, FAPPEND, 968efb80947Sahrens RLIM64_INFINITY, CRED(), &resid); 969efb80947Sahrens 9703cb34c60Sahrens if (resid == len - done) 971efb80947Sahrens ra->err = EINVAL; 9723cb34c60Sahrens ra->voff += len - done - resid; 9733cb34c60Sahrens done = len - resid; 974efb80947Sahrens if (ra->err) 975efb80947Sahrens return (NULL); 976efb80947Sahrens } 977efb80947Sahrens 9783cb34c60Sahrens ASSERT3U(done, ==, len); 9793cb34c60Sahrens rv = ra->buf; 980efb80947Sahrens if (ra->byteswap) 9813cb34c60Sahrens fletcher_4_incremental_byteswap(rv, len, &ra->cksum); 982efb80947Sahrens else 9833cb34c60Sahrens fletcher_4_incremental_native(rv, len, &ra->cksum); 984efb80947Sahrens return (rv); 985efb80947Sahrens } 986efb80947Sahrens 987efb80947Sahrens static void 988efb80947Sahrens backup_byteswap(dmu_replay_record_t *drr) 989efb80947Sahrens { 990efb80947Sahrens #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 991efb80947Sahrens #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 992efb80947Sahrens drr->drr_type = BSWAP_32(drr->drr_type); 9933cb34c60Sahrens drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 994efb80947Sahrens switch (drr->drr_type) { 995efb80947Sahrens case DRR_BEGIN: 996efb80947Sahrens DO64(drr_begin.drr_magic); 9979e69d7d0SLori Alt DO64(drr_begin.drr_versioninfo); 998efb80947Sahrens DO64(drr_begin.drr_creation_time); 999efb80947Sahrens DO32(drr_begin.drr_type); 10003cb34c60Sahrens DO32(drr_begin.drr_flags); 1001efb80947Sahrens DO64(drr_begin.drr_toguid); 1002efb80947Sahrens DO64(drr_begin.drr_fromguid); 1003efb80947Sahrens break; 1004efb80947Sahrens case DRR_OBJECT: 1005efb80947Sahrens DO64(drr_object.drr_object); 1006efb80947Sahrens /* DO64(drr_object.drr_allocation_txg); */ 1007efb80947Sahrens DO32(drr_object.drr_type); 1008efb80947Sahrens DO32(drr_object.drr_bonustype); 1009efb80947Sahrens DO32(drr_object.drr_blksz); 1010efb80947Sahrens DO32(drr_object.drr_bonuslen); 10119e69d7d0SLori Alt DO64(drr_object.drr_toguid); 1012efb80947Sahrens break; 1013efb80947Sahrens case DRR_FREEOBJECTS: 1014efb80947Sahrens DO64(drr_freeobjects.drr_firstobj); 1015efb80947Sahrens DO64(drr_freeobjects.drr_numobjs); 10169e69d7d0SLori Alt DO64(drr_freeobjects.drr_toguid); 1017efb80947Sahrens break; 1018efb80947Sahrens case DRR_WRITE: 1019efb80947Sahrens DO64(drr_write.drr_object); 1020efb80947Sahrens DO32(drr_write.drr_type); 1021efb80947Sahrens DO64(drr_write.drr_offset); 1022efb80947Sahrens DO64(drr_write.drr_length); 10239e69d7d0SLori Alt DO64(drr_write.drr_toguid); 10248e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[0]); 10258e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[1]); 10268e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[2]); 10278e714474SLori Alt DO64(drr_write.drr_key.ddk_cksum.zc_word[3]); 10288e714474SLori Alt DO64(drr_write.drr_key.ddk_prop); 10299e69d7d0SLori Alt break; 10309e69d7d0SLori Alt case DRR_WRITE_BYREF: 10319e69d7d0SLori Alt DO64(drr_write_byref.drr_object); 10329e69d7d0SLori Alt DO64(drr_write_byref.drr_offset); 10339e69d7d0SLori Alt DO64(drr_write_byref.drr_length); 10349e69d7d0SLori Alt DO64(drr_write_byref.drr_toguid); 10359e69d7d0SLori Alt DO64(drr_write_byref.drr_refguid); 10369e69d7d0SLori Alt DO64(drr_write_byref.drr_refobject); 10379e69d7d0SLori Alt DO64(drr_write_byref.drr_refoffset); 10388e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[0]); 10398e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[1]); 10408e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[2]); 10418e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_cksum.zc_word[3]); 10428e714474SLori Alt DO64(drr_write_byref.drr_key.ddk_prop); 1043efb80947Sahrens break; 1044efb80947Sahrens case DRR_FREE: 1045efb80947Sahrens DO64(drr_free.drr_object); 1046efb80947Sahrens DO64(drr_free.drr_offset); 1047efb80947Sahrens DO64(drr_free.drr_length); 10489e69d7d0SLori Alt DO64(drr_free.drr_toguid); 1049efb80947Sahrens break; 10500a586ceaSMark Shellenbaum case DRR_SPILL: 10510a586ceaSMark Shellenbaum DO64(drr_spill.drr_object); 10520a586ceaSMark Shellenbaum DO64(drr_spill.drr_length); 10530a586ceaSMark Shellenbaum DO64(drr_spill.drr_toguid); 10540a586ceaSMark Shellenbaum break; 1055efb80947Sahrens case DRR_END: 1056efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[0]); 1057efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[1]); 1058efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[2]); 1059efb80947Sahrens DO64(drr_end.drr_checksum.zc_word[3]); 10609e69d7d0SLori Alt DO64(drr_end.drr_toguid); 1061efb80947Sahrens break; 1062efb80947Sahrens } 1063efb80947Sahrens #undef DO64 1064efb80947Sahrens #undef DO32 1065efb80947Sahrens } 1066efb80947Sahrens 1067efb80947Sahrens static int 1068efb80947Sahrens restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro) 1069efb80947Sahrens { 1070efb80947Sahrens int err; 1071efb80947Sahrens dmu_tx_t *tx; 1072adee0b6fSTim Haley void *data = NULL; 1073efb80947Sahrens 1074efb80947Sahrens if (drro->drr_type == DMU_OT_NONE || 1075*ad135b5dSChristopher Siden !DMU_OT_IS_VALID(drro->drr_type) || 1076*ad135b5dSChristopher Siden !DMU_OT_IS_VALID(drro->drr_bonustype) || 10779e69d7d0SLori Alt drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 1078efb80947Sahrens drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 1079efb80947Sahrens P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 1080efb80947Sahrens drro->drr_blksz < SPA_MINBLOCKSIZE || 1081efb80947Sahrens drro->drr_blksz > SPA_MAXBLOCKSIZE || 1082efb80947Sahrens drro->drr_bonuslen > DN_MAX_BONUSLEN) { 1083efb80947Sahrens return (EINVAL); 1084efb80947Sahrens } 1085efb80947Sahrens 10862bf405a2SMark Maybee err = dmu_object_info(os, drro->drr_object, NULL); 10872bf405a2SMark Maybee 10882bf405a2SMark Maybee if (err != 0 && err != ENOENT) 10892bf405a2SMark Maybee return (EINVAL); 10902bf405a2SMark Maybee 1091adee0b6fSTim Haley if (drro->drr_bonuslen) { 1092adee0b6fSTim Haley data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8)); 1093adee0b6fSTim Haley if (ra->err) 1094adee0b6fSTim Haley return (ra->err); 1095adee0b6fSTim Haley } 1096adee0b6fSTim Haley 1097efb80947Sahrens if (err == ENOENT) { 1098efb80947Sahrens /* currently free, want to be allocated */ 10992bf405a2SMark Maybee tx = dmu_tx_create(os); 1100efb80947Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 1101efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1102efb80947Sahrens if (err) { 1103efb80947Sahrens dmu_tx_abort(tx); 1104efb80947Sahrens return (err); 1105efb80947Sahrens } 1106efb80947Sahrens err = dmu_object_claim(os, drro->drr_object, 1107efb80947Sahrens drro->drr_type, drro->drr_blksz, 1108efb80947Sahrens drro->drr_bonustype, drro->drr_bonuslen, tx); 11092bf405a2SMark Maybee dmu_tx_commit(tx); 1110efb80947Sahrens } else { 1111efb80947Sahrens /* currently allocated, want to be allocated */ 1112efb80947Sahrens err = dmu_object_reclaim(os, drro->drr_object, 1113efb80947Sahrens drro->drr_type, drro->drr_blksz, 11142bf405a2SMark Maybee drro->drr_bonustype, drro->drr_bonuslen); 1115efb80947Sahrens } 11160a586ceaSMark Shellenbaum if (err) { 1117efb80947Sahrens return (EINVAL); 11180a586ceaSMark Shellenbaum } 11192bf405a2SMark Maybee 11202bf405a2SMark Maybee tx = dmu_tx_create(os); 11212bf405a2SMark Maybee dmu_tx_hold_bonus(tx, drro->drr_object); 11222bf405a2SMark Maybee err = dmu_tx_assign(tx, TXG_WAIT); 11232bf405a2SMark Maybee if (err) { 11242bf405a2SMark Maybee dmu_tx_abort(tx); 11252bf405a2SMark Maybee return (err); 1126efb80947Sahrens } 1127efb80947Sahrens 11289e69d7d0SLori Alt dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksumtype, 11299e69d7d0SLori Alt tx); 1130efb80947Sahrens dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 1131efb80947Sahrens 1132adee0b6fSTim Haley if (data != NULL) { 1133efb80947Sahrens dmu_buf_t *db; 1134adee0b6fSTim Haley 1135efb80947Sahrens VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 1136efb80947Sahrens dmu_buf_will_dirty(db, tx); 1137efb80947Sahrens 11381934e92fSmaybee ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 11391934e92fSmaybee bcopy(data, db->db_data, drro->drr_bonuslen); 1140efb80947Sahrens if (ra->byteswap) { 1141*ad135b5dSChristopher Siden dmu_object_byteswap_t byteswap = 1142*ad135b5dSChristopher Siden DMU_OT_BYTESWAP(drro->drr_bonustype); 1143*ad135b5dSChristopher Siden dmu_ot_byteswap[byteswap].ob_func(db->db_data, 1144efb80947Sahrens drro->drr_bonuslen); 1145efb80947Sahrens } 1146efb80947Sahrens dmu_buf_rele(db, FTAG); 1147efb80947Sahrens } 1148efb80947Sahrens dmu_tx_commit(tx); 1149efb80947Sahrens return (0); 1150efb80947Sahrens } 1151efb80947Sahrens 1152efb80947Sahrens /* ARGSUSED */ 1153efb80947Sahrens static int 1154efb80947Sahrens restore_freeobjects(struct restorearg *ra, objset_t *os, 1155efb80947Sahrens struct drr_freeobjects *drrfo) 1156efb80947Sahrens { 1157efb80947Sahrens uint64_t obj; 1158efb80947Sahrens 1159efb80947Sahrens if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1160efb80947Sahrens return (EINVAL); 1161efb80947Sahrens 1162efb80947Sahrens for (obj = drrfo->drr_firstobj; 1163432f72fdSahrens obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 1164432f72fdSahrens (void) dmu_object_next(os, &obj, FALSE, 0)) { 1165efb80947Sahrens int err; 1166efb80947Sahrens 1167efb80947Sahrens if (dmu_object_info(os, obj, NULL) != 0) 1168efb80947Sahrens continue; 1169efb80947Sahrens 1170cdb0ab79Smaybee err = dmu_free_object(os, obj); 1171cdb0ab79Smaybee if (err) 1172efb80947Sahrens return (err); 1173efb80947Sahrens } 1174efb80947Sahrens return (0); 1175efb80947Sahrens } 1176efb80947Sahrens 1177efb80947Sahrens static int 1178efb80947Sahrens restore_write(struct restorearg *ra, objset_t *os, 1179efb80947Sahrens struct drr_write *drrw) 1180efb80947Sahrens { 1181efb80947Sahrens dmu_tx_t *tx; 1182efb80947Sahrens void *data; 1183efb80947Sahrens int err; 1184efb80947Sahrens 1185efb80947Sahrens if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 1186*ad135b5dSChristopher Siden !DMU_OT_IS_VALID(drrw->drr_type)) 1187efb80947Sahrens return (EINVAL); 1188efb80947Sahrens 1189efb80947Sahrens data = restore_read(ra, drrw->drr_length); 1190efb80947Sahrens if (data == NULL) 1191efb80947Sahrens return (ra->err); 1192efb80947Sahrens 1193efb80947Sahrens if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 1194efb80947Sahrens return (EINVAL); 1195efb80947Sahrens 1196efb80947Sahrens tx = dmu_tx_create(os); 1197efb80947Sahrens 1198efb80947Sahrens dmu_tx_hold_write(tx, drrw->drr_object, 1199efb80947Sahrens drrw->drr_offset, drrw->drr_length); 1200efb80947Sahrens err = dmu_tx_assign(tx, TXG_WAIT); 1201efb80947Sahrens if (err) { 1202efb80947Sahrens dmu_tx_abort(tx); 1203efb80947Sahrens return (err); 1204efb80947Sahrens } 1205*ad135b5dSChristopher Siden if (ra->byteswap) { 1206*ad135b5dSChristopher Siden dmu_object_byteswap_t byteswap = 1207*ad135b5dSChristopher Siden DMU_OT_BYTESWAP(drrw->drr_type); 1208*ad135b5dSChristopher Siden dmu_ot_byteswap[byteswap].ob_func(data, drrw->drr_length); 1209*ad135b5dSChristopher Siden } 1210efb80947Sahrens dmu_write(os, drrw->drr_object, 1211efb80947Sahrens drrw->drr_offset, drrw->drr_length, data, tx); 1212efb80947Sahrens dmu_tx_commit(tx); 1213efb80947Sahrens return (0); 1214efb80947Sahrens } 1215efb80947Sahrens 12169e69d7d0SLori Alt /* 12179e69d7d0SLori Alt * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 12189e69d7d0SLori Alt * streams to refer to a copy of the data that is already on the 12199e69d7d0SLori Alt * system because it came in earlier in the stream. This function 12209e69d7d0SLori Alt * finds the earlier copy of the data, and uses that copy instead of 12219e69d7d0SLori Alt * data from the stream to fulfill this write. 12229e69d7d0SLori Alt */ 12239e69d7d0SLori Alt static int 12249e69d7d0SLori Alt restore_write_byref(struct restorearg *ra, objset_t *os, 12259e69d7d0SLori Alt struct drr_write_byref *drrwbr) 12269e69d7d0SLori Alt { 12279e69d7d0SLori Alt dmu_tx_t *tx; 12289e69d7d0SLori Alt int err; 12299e69d7d0SLori Alt guid_map_entry_t gmesrch; 12309e69d7d0SLori Alt guid_map_entry_t *gmep; 12319e69d7d0SLori Alt avl_index_t where; 12329e69d7d0SLori Alt objset_t *ref_os = NULL; 12339e69d7d0SLori Alt dmu_buf_t *dbp; 12349e69d7d0SLori Alt 12359e69d7d0SLori Alt if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 12369e69d7d0SLori Alt return (EINVAL); 12379e69d7d0SLori Alt 12389e69d7d0SLori Alt /* 12399e69d7d0SLori Alt * If the GUID of the referenced dataset is different from the 12409e69d7d0SLori Alt * GUID of the target dataset, find the referenced dataset. 12419e69d7d0SLori Alt */ 12429e69d7d0SLori Alt if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 12439e69d7d0SLori Alt gmesrch.guid = drrwbr->drr_refguid; 1244c99e4bdcSChris Kirby if ((gmep = avl_find(ra->guid_to_ds_map, &gmesrch, 12459e69d7d0SLori Alt &where)) == NULL) { 12469e69d7d0SLori Alt return (EINVAL); 12479e69d7d0SLori Alt } 12489e69d7d0SLori Alt if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 12499e69d7d0SLori Alt return (EINVAL); 12509e69d7d0SLori Alt } else { 12519e69d7d0SLori Alt ref_os = os; 12529e69d7d0SLori Alt } 12539e69d7d0SLori Alt 12549e69d7d0SLori Alt if (err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 125547cb52daSJeff Bonwick drrwbr->drr_refoffset, FTAG, &dbp, DMU_READ_PREFETCH)) 12569e69d7d0SLori Alt return (err); 12579e69d7d0SLori Alt 12589e69d7d0SLori Alt tx = dmu_tx_create(os); 12599e69d7d0SLori Alt 12609e69d7d0SLori Alt dmu_tx_hold_write(tx, drrwbr->drr_object, 12619e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length); 12629e69d7d0SLori Alt err = dmu_tx_assign(tx, TXG_WAIT); 12639e69d7d0SLori Alt if (err) { 12649e69d7d0SLori Alt dmu_tx_abort(tx); 12659e69d7d0SLori Alt return (err); 12669e69d7d0SLori Alt } 12679e69d7d0SLori Alt dmu_write(os, drrwbr->drr_object, 12689e69d7d0SLori Alt drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 12699e69d7d0SLori Alt dmu_buf_rele(dbp, FTAG); 12709e69d7d0SLori Alt dmu_tx_commit(tx); 12719e69d7d0SLori Alt return (0); 12729e69d7d0SLori Alt } 12739e69d7d0SLori Alt 12740a586ceaSMark Shellenbaum static int 12750a586ceaSMark Shellenbaum restore_spill(struct restorearg *ra, objset_t *os, struct drr_spill *drrs) 12760a586ceaSMark Shellenbaum { 12770a586ceaSMark Shellenbaum dmu_tx_t *tx; 12780a586ceaSMark Shellenbaum void *data; 12790a586ceaSMark Shellenbaum dmu_buf_t *db, *db_spill; 12800a586ceaSMark Shellenbaum int err; 12810a586ceaSMark Shellenbaum 12820a586ceaSMark Shellenbaum if (drrs->drr_length < SPA_MINBLOCKSIZE || 12830a586ceaSMark Shellenbaum drrs->drr_length > SPA_MAXBLOCKSIZE) 12840a586ceaSMark Shellenbaum return (EINVAL); 12850a586ceaSMark Shellenbaum 12860a586ceaSMark Shellenbaum data = restore_read(ra, drrs->drr_length); 12870a586ceaSMark Shellenbaum if (data == NULL) 12880a586ceaSMark Shellenbaum return (ra->err); 12890a586ceaSMark Shellenbaum 12900a586ceaSMark Shellenbaum if (dmu_object_info(os, drrs->drr_object, NULL) != 0) 12910a586ceaSMark Shellenbaum return (EINVAL); 12920a586ceaSMark Shellenbaum 12930a586ceaSMark Shellenbaum VERIFY(0 == dmu_bonus_hold(os, drrs->drr_object, FTAG, &db)); 12940a586ceaSMark Shellenbaum if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) { 12950a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 12960a586ceaSMark Shellenbaum return (err); 12970a586ceaSMark Shellenbaum } 12980a586ceaSMark Shellenbaum 12990a586ceaSMark Shellenbaum tx = dmu_tx_create(os); 13000a586ceaSMark Shellenbaum 13010a586ceaSMark Shellenbaum dmu_tx_hold_spill(tx, db->db_object); 13020a586ceaSMark Shellenbaum 13030a586ceaSMark Shellenbaum err = dmu_tx_assign(tx, TXG_WAIT); 13040a586ceaSMark Shellenbaum if (err) { 13050a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 13060a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 13070a586ceaSMark Shellenbaum dmu_tx_abort(tx); 13080a586ceaSMark Shellenbaum return (err); 13090a586ceaSMark Shellenbaum } 13100a586ceaSMark Shellenbaum dmu_buf_will_dirty(db_spill, tx); 13110a586ceaSMark Shellenbaum 13120a586ceaSMark Shellenbaum if (db_spill->db_size < drrs->drr_length) 13130a586ceaSMark Shellenbaum VERIFY(0 == dbuf_spill_set_blksz(db_spill, 13140a586ceaSMark Shellenbaum drrs->drr_length, tx)); 13150a586ceaSMark Shellenbaum bcopy(data, db_spill->db_data, drrs->drr_length); 13160a586ceaSMark Shellenbaum 13170a586ceaSMark Shellenbaum dmu_buf_rele(db, FTAG); 13180a586ceaSMark Shellenbaum dmu_buf_rele(db_spill, FTAG); 13190a586ceaSMark Shellenbaum 13200a586ceaSMark Shellenbaum dmu_tx_commit(tx); 13210a586ceaSMark Shellenbaum return (0); 13220a586ceaSMark Shellenbaum } 13230a586ceaSMark Shellenbaum 1324efb80947Sahrens /* ARGSUSED */ 1325efb80947Sahrens static int 1326efb80947Sahrens restore_free(struct restorearg *ra, objset_t *os, 1327efb80947Sahrens struct drr_free *drrf) 1328efb80947Sahrens { 1329efb80947Sahrens int err; 1330efb80947Sahrens 1331efb80947Sahrens if (drrf->drr_length != -1ULL && 1332efb80947Sahrens drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1333efb80947Sahrens return (EINVAL); 1334efb80947Sahrens 1335efb80947Sahrens if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 1336efb80947Sahrens return (EINVAL); 1337efb80947Sahrens 1338cdb0ab79Smaybee err = dmu_free_long_range(os, drrf->drr_object, 1339efb80947Sahrens drrf->drr_offset, drrf->drr_length); 1340efb80947Sahrens return (err); 1341efb80947Sahrens } 1342efb80947Sahrens 13433cb34c60Sahrens /* 13443cb34c60Sahrens * NB: callers *must* call dmu_recv_end() if this succeeds. 13453cb34c60Sahrens */ 1346efb80947Sahrens int 1347c99e4bdcSChris Kirby dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp, 1348c99e4bdcSChris Kirby int cleanup_fd, uint64_t *action_handlep) 1349efb80947Sahrens { 13503cb34c60Sahrens struct restorearg ra = { 0 }; 1351efb80947Sahrens dmu_replay_record_t *drr; 13523cb34c60Sahrens objset_t *os; 13533cb34c60Sahrens zio_cksum_t pcksum; 13549e69d7d0SLori Alt int featureflags; 1355efb80947Sahrens 13563cb34c60Sahrens if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 1357efb80947Sahrens ra.byteswap = TRUE; 1358efb80947Sahrens 13593cb34c60Sahrens { 13603cb34c60Sahrens /* compute checksum of drr_begin record */ 13613cb34c60Sahrens dmu_replay_record_t *drr; 13623cb34c60Sahrens drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 13633cb34c60Sahrens 13643cb34c60Sahrens drr->drr_type = DRR_BEGIN; 13653cb34c60Sahrens drr->drr_u.drr_begin = *drc->drc_drrb; 13663cb34c60Sahrens if (ra.byteswap) { 13673cb34c60Sahrens fletcher_4_incremental_byteswap(drr, 13683cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 13693cb34c60Sahrens } else { 13703cb34c60Sahrens fletcher_4_incremental_native(drr, 13713cb34c60Sahrens sizeof (dmu_replay_record_t), &ra.cksum); 13723cb34c60Sahrens } 13733cb34c60Sahrens kmem_free(drr, sizeof (dmu_replay_record_t)); 1374efb80947Sahrens } 1375efb80947Sahrens 1376efb80947Sahrens if (ra.byteswap) { 13773cb34c60Sahrens struct drr_begin *drrb = drc->drc_drrb; 1378efb80947Sahrens drrb->drr_magic = BSWAP_64(drrb->drr_magic); 13799e69d7d0SLori Alt drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo); 1380efb80947Sahrens drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 1381efb80947Sahrens drrb->drr_type = BSWAP_32(drrb->drr_type); 1382efb80947Sahrens drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 1383efb80947Sahrens drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 1384efb80947Sahrens } 1385efb80947Sahrens 13863cb34c60Sahrens ra.vp = vp; 13873cb34c60Sahrens ra.voff = *voffp; 13883cb34c60Sahrens ra.bufsize = 1<<20; 13893cb34c60Sahrens ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1390efb80947Sahrens 13913cb34c60Sahrens /* these were verified in dmu_recv_begin */ 13929e69d7d0SLori Alt ASSERT(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo) == 13939e69d7d0SLori Alt DMU_SUBSTREAM); 13943cb34c60Sahrens ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1395efb80947Sahrens 1396efb80947Sahrens /* 1397efb80947Sahrens * Open the objset we are modifying. 1398efb80947Sahrens */ 1399503ad85cSMatthew Ahrens VERIFY(dmu_objset_from_ds(drc->drc_real_ds, &os) == 0); 1400efb80947Sahrens 14013cb34c60Sahrens ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1402efb80947Sahrens 14039e69d7d0SLori Alt featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 14049e69d7d0SLori Alt 14059e69d7d0SLori Alt /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 14069e69d7d0SLori Alt if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 1407a7f53a56SChris Kirby minor_t minor; 1408a7f53a56SChris Kirby 1409c99e4bdcSChris Kirby if (cleanup_fd == -1) { 1410c99e4bdcSChris Kirby ra.err = EBADF; 1411c99e4bdcSChris Kirby goto out; 1412c99e4bdcSChris Kirby } 1413a7f53a56SChris Kirby ra.err = zfs_onexit_fd_hold(cleanup_fd, &minor); 1414a7f53a56SChris Kirby if (ra.err) { 1415a7f53a56SChris Kirby cleanup_fd = -1; 1416a7f53a56SChris Kirby goto out; 1417a7f53a56SChris Kirby } 1418a7f53a56SChris Kirby 1419c99e4bdcSChris Kirby if (*action_handlep == 0) { 1420c99e4bdcSChris Kirby ra.guid_to_ds_map = 1421c99e4bdcSChris Kirby kmem_alloc(sizeof (avl_tree_t), KM_SLEEP); 1422c99e4bdcSChris Kirby avl_create(ra.guid_to_ds_map, guid_compare, 1423c99e4bdcSChris Kirby sizeof (guid_map_entry_t), 1424c99e4bdcSChris Kirby offsetof(guid_map_entry_t, avlnode)); 1425a7f53a56SChris Kirby ra.err = zfs_onexit_add_cb(minor, 1426c99e4bdcSChris Kirby free_guid_map_onexit, ra.guid_to_ds_map, 1427c99e4bdcSChris Kirby action_handlep); 1428c99e4bdcSChris Kirby if (ra.err) 1429c99e4bdcSChris Kirby goto out; 1430c99e4bdcSChris Kirby } else { 1431a7f53a56SChris Kirby ra.err = zfs_onexit_cb_data(minor, *action_handlep, 1432c99e4bdcSChris Kirby (void **)&ra.guid_to_ds_map); 1433c99e4bdcSChris Kirby if (ra.err) 1434c99e4bdcSChris Kirby goto out; 1435c99e4bdcSChris Kirby } 1436ec5cf9d5SAlexander Stetsenko 1437ec5cf9d5SAlexander Stetsenko drc->drc_guid_to_ds_map = ra.guid_to_ds_map; 14389e69d7d0SLori Alt } 14399e69d7d0SLori Alt 1440efb80947Sahrens /* 1441efb80947Sahrens * Read records and process them. 1442efb80947Sahrens */ 14433cb34c60Sahrens pcksum = ra.cksum; 1444efb80947Sahrens while (ra.err == 0 && 1445efb80947Sahrens NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1446efb80947Sahrens if (issig(JUSTLOOKING) && issig(FORREAL)) { 1447efb80947Sahrens ra.err = EINTR; 1448efb80947Sahrens goto out; 1449efb80947Sahrens } 1450efb80947Sahrens 1451efb80947Sahrens if (ra.byteswap) 1452efb80947Sahrens backup_byteswap(drr); 1453efb80947Sahrens 1454efb80947Sahrens switch (drr->drr_type) { 1455efb80947Sahrens case DRR_OBJECT: 1456efb80947Sahrens { 1457efb80947Sahrens /* 1458efb80947Sahrens * We need to make a copy of the record header, 1459efb80947Sahrens * because restore_{object,write} may need to 1460efb80947Sahrens * restore_read(), which will invalidate drr. 1461efb80947Sahrens */ 1462efb80947Sahrens struct drr_object drro = drr->drr_u.drr_object; 1463efb80947Sahrens ra.err = restore_object(&ra, os, &drro); 1464efb80947Sahrens break; 1465efb80947Sahrens } 1466efb80947Sahrens case DRR_FREEOBJECTS: 1467efb80947Sahrens { 1468efb80947Sahrens struct drr_freeobjects drrfo = 1469efb80947Sahrens drr->drr_u.drr_freeobjects; 1470efb80947Sahrens ra.err = restore_freeobjects(&ra, os, &drrfo); 1471efb80947Sahrens break; 1472efb80947Sahrens } 1473efb80947Sahrens case DRR_WRITE: 1474efb80947Sahrens { 1475efb80947Sahrens struct drr_write drrw = drr->drr_u.drr_write; 1476efb80947Sahrens ra.err = restore_write(&ra, os, &drrw); 1477efb80947Sahrens break; 1478efb80947Sahrens } 14799e69d7d0SLori Alt case DRR_WRITE_BYREF: 14809e69d7d0SLori Alt { 14819e69d7d0SLori Alt struct drr_write_byref drrwbr = 14829e69d7d0SLori Alt drr->drr_u.drr_write_byref; 14839e69d7d0SLori Alt ra.err = restore_write_byref(&ra, os, &drrwbr); 14849e69d7d0SLori Alt break; 14859e69d7d0SLori Alt } 1486efb80947Sahrens case DRR_FREE: 1487efb80947Sahrens { 1488efb80947Sahrens struct drr_free drrf = drr->drr_u.drr_free; 1489efb80947Sahrens ra.err = restore_free(&ra, os, &drrf); 1490efb80947Sahrens break; 1491efb80947Sahrens } 1492efb80947Sahrens case DRR_END: 1493efb80947Sahrens { 1494efb80947Sahrens struct drr_end drre = drr->drr_u.drr_end; 1495efb80947Sahrens /* 1496efb80947Sahrens * We compare against the *previous* checksum 1497efb80947Sahrens * value, because the stored checksum is of 1498efb80947Sahrens * everything before the DRR_END record. 1499efb80947Sahrens */ 1500137fa067Sahrens if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1501efb80947Sahrens ra.err = ECKSUM; 1502efb80947Sahrens goto out; 1503efb80947Sahrens } 15040a586ceaSMark Shellenbaum case DRR_SPILL: 15050a586ceaSMark Shellenbaum { 15060a586ceaSMark Shellenbaum struct drr_spill drrs = drr->drr_u.drr_spill; 15070a586ceaSMark Shellenbaum ra.err = restore_spill(&ra, os, &drrs); 15080a586ceaSMark Shellenbaum break; 15090a586ceaSMark Shellenbaum } 1510efb80947Sahrens default: 1511efb80947Sahrens ra.err = EINVAL; 1512efb80947Sahrens goto out; 1513efb80947Sahrens } 15143cb34c60Sahrens pcksum = ra.cksum; 1515efb80947Sahrens } 1516137fa067Sahrens ASSERT(ra.err != 0); 1517efb80947Sahrens 1518efb80947Sahrens out: 1519a7f53a56SChris Kirby if ((featureflags & DMU_BACKUP_FEATURE_DEDUP) && (cleanup_fd != -1)) 1520a7f53a56SChris Kirby zfs_onexit_fd_rele(cleanup_fd); 1521a7f53a56SChris Kirby 15223cb34c60Sahrens if (ra.err != 0) { 1523efb80947Sahrens /* 1524f4b94bdeSMatthew Ahrens * destroy what we created, so we don't leave it in the 1525f4b94bdeSMatthew Ahrens * inconsistent restoring state. 1526efb80947Sahrens */ 15273cb34c60Sahrens txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1528f4b94bdeSMatthew Ahrens 1529842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1530842727c2SChris Kirby B_FALSE); 1531f4b94bdeSMatthew Ahrens if (drc->drc_real_ds != drc->drc_logical_ds) { 1532f4b94bdeSMatthew Ahrens mutex_exit(&drc->drc_logical_ds->ds_recvlock); 1533f4b94bdeSMatthew Ahrens dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 1534f4b94bdeSMatthew Ahrens } 1535efb80947Sahrens } 1536efb80947Sahrens 1537efb80947Sahrens kmem_free(ra.buf, ra.bufsize); 15383cb34c60Sahrens *voffp = ra.voff; 1539efb80947Sahrens return (ra.err); 1540efb80947Sahrens } 1541f18faf3fSek 15423cb34c60Sahrens struct recvendsyncarg { 15433cb34c60Sahrens char *tosnap; 15443cb34c60Sahrens uint64_t creation_time; 15453cb34c60Sahrens uint64_t toguid; 15463cb34c60Sahrens }; 15473cb34c60Sahrens 15483cb34c60Sahrens static int 15493cb34c60Sahrens recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 15503cb34c60Sahrens { 15513cb34c60Sahrens dsl_dataset_t *ds = arg1; 15523cb34c60Sahrens struct recvendsyncarg *resa = arg2; 15533cb34c60Sahrens 15543cb34c60Sahrens return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 15553cb34c60Sahrens } 15563cb34c60Sahrens 15573cb34c60Sahrens static void 15583f9d6ad7SLin Ling recv_end_sync(void *arg1, void *arg2, dmu_tx_t *tx) 15593cb34c60Sahrens { 15603cb34c60Sahrens dsl_dataset_t *ds = arg1; 15613cb34c60Sahrens struct recvendsyncarg *resa = arg2; 15623cb34c60Sahrens 15633f9d6ad7SLin Ling dsl_dataset_snapshot_sync(ds, resa->tosnap, tx); 15643cb34c60Sahrens 15653cb34c60Sahrens /* set snapshot's creation time and guid */ 15663cb34c60Sahrens dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 15673cb34c60Sahrens ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 15683cb34c60Sahrens ds->ds_prev->ds_phys->ds_guid = resa->toguid; 15693cb34c60Sahrens ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 15703cb34c60Sahrens 15713cb34c60Sahrens dmu_buf_will_dirty(ds->ds_dbuf, tx); 15723cb34c60Sahrens ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 15733cb34c60Sahrens } 15743cb34c60Sahrens 1575ec5cf9d5SAlexander Stetsenko static int 1576ec5cf9d5SAlexander Stetsenko add_ds_to_guidmap(avl_tree_t *guid_map, dsl_dataset_t *ds) 1577ec5cf9d5SAlexander Stetsenko { 1578ec5cf9d5SAlexander Stetsenko dsl_pool_t *dp = ds->ds_dir->dd_pool; 1579ec5cf9d5SAlexander Stetsenko uint64_t snapobj = ds->ds_phys->ds_prev_snap_obj; 1580ec5cf9d5SAlexander Stetsenko dsl_dataset_t *snapds; 1581ec5cf9d5SAlexander Stetsenko guid_map_entry_t *gmep; 1582ec5cf9d5SAlexander Stetsenko int err; 1583ec5cf9d5SAlexander Stetsenko 1584ec5cf9d5SAlexander Stetsenko ASSERT(guid_map != NULL); 1585ec5cf9d5SAlexander Stetsenko 1586ec5cf9d5SAlexander Stetsenko rw_enter(&dp->dp_config_rwlock, RW_READER); 1587ec5cf9d5SAlexander Stetsenko err = dsl_dataset_hold_obj(dp, snapobj, guid_map, &snapds); 1588ec5cf9d5SAlexander Stetsenko if (err == 0) { 1589ec5cf9d5SAlexander Stetsenko gmep = kmem_alloc(sizeof (guid_map_entry_t), KM_SLEEP); 1590ec5cf9d5SAlexander Stetsenko gmep->guid = snapds->ds_phys->ds_guid; 1591ec5cf9d5SAlexander Stetsenko gmep->gme_ds = snapds; 1592ec5cf9d5SAlexander Stetsenko avl_add(guid_map, gmep); 1593ec5cf9d5SAlexander Stetsenko } 1594ec5cf9d5SAlexander Stetsenko 1595ec5cf9d5SAlexander Stetsenko rw_exit(&dp->dp_config_rwlock); 1596ec5cf9d5SAlexander Stetsenko return (err); 1597ec5cf9d5SAlexander Stetsenko } 1598ec5cf9d5SAlexander Stetsenko 1599ae46e4c7SMatthew Ahrens static int 1600ae46e4c7SMatthew Ahrens dmu_recv_existing_end(dmu_recv_cookie_t *drc) 1601f18faf3fSek { 1602745cd3c5Smaybee struct recvendsyncarg resa; 1603745cd3c5Smaybee dsl_dataset_t *ds = drc->drc_logical_ds; 160419b94df9SMatthew Ahrens int err, myerr; 1605f18faf3fSek 16063cb34c60Sahrens /* 1607ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1608ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1609ae46e4c7SMatthew Ahrens * can close it. 16103cb34c60Sahrens */ 1611745cd3c5Smaybee txg_wait_synced(ds->ds_dir->dd_pool, 0); 16123cb34c60Sahrens 1613ae46e4c7SMatthew Ahrens if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1614ae46e4c7SMatthew Ahrens err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1615ae46e4c7SMatthew Ahrens drc->drc_force); 1616ae46e4c7SMatthew Ahrens if (err) 1617ae46e4c7SMatthew Ahrens goto out; 1618ae46e4c7SMatthew Ahrens } else { 1619ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1620ae46e4c7SMatthew Ahrens dsl_dataset_rele(ds, dmu_recv_tag); 1621842727c2SChris Kirby (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, 1622842727c2SChris Kirby B_FALSE); 1623ae46e4c7SMatthew Ahrens return (EBUSY); 16243cb34c60Sahrens } 16253cb34c60Sahrens 1626745cd3c5Smaybee resa.creation_time = drc->drc_drrb->drr_creation_time; 1627745cd3c5Smaybee resa.toguid = drc->drc_drrb->drr_toguid; 1628745cd3c5Smaybee resa.tosnap = drc->drc_tosnap; 16293cb34c60Sahrens 1630745cd3c5Smaybee err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1631745cd3c5Smaybee recv_end_check, recv_end_sync, ds, &resa, 3); 1632745cd3c5Smaybee if (err) { 1633ae46e4c7SMatthew Ahrens /* swap back */ 1634ae46e4c7SMatthew Ahrens (void) dsl_dataset_clone_swap(drc->drc_real_ds, ds, B_TRUE); 16353cb34c60Sahrens } 16363cb34c60Sahrens 1637ae46e4c7SMatthew Ahrens out: 1638ae46e4c7SMatthew Ahrens mutex_exit(&ds->ds_recvlock); 1639ec5cf9d5SAlexander Stetsenko if (err == 0 && drc->drc_guid_to_ds_map != NULL) 1640ec5cf9d5SAlexander Stetsenko (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds); 1641745cd3c5Smaybee dsl_dataset_disown(ds, dmu_recv_tag); 164219b94df9SMatthew Ahrens myerr = dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE); 164319b94df9SMatthew Ahrens ASSERT3U(myerr, ==, 0); 1644f18faf3fSek return (err); 1645f18faf3fSek } 1646ae46e4c7SMatthew Ahrens 1647ae46e4c7SMatthew Ahrens static int 1648ae46e4c7SMatthew Ahrens dmu_recv_new_end(dmu_recv_cookie_t *drc) 1649ae46e4c7SMatthew Ahrens { 1650ae46e4c7SMatthew Ahrens struct recvendsyncarg resa; 1651ae46e4c7SMatthew Ahrens dsl_dataset_t *ds = drc->drc_logical_ds; 1652ae46e4c7SMatthew Ahrens int err; 1653ae46e4c7SMatthew Ahrens 1654ae46e4c7SMatthew Ahrens /* 1655ae46e4c7SMatthew Ahrens * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean() 1656ae46e4c7SMatthew Ahrens * expects it to have a ds_user_ptr (and zil), but clone_swap() 1657ae46e4c7SMatthew Ahrens * can close it. 1658ae46e4c7SMatthew Ahrens */ 1659ae46e4c7SMatthew Ahrens txg_wait_synced(ds->ds_dir->dd_pool, 0); 1660ae46e4c7SMatthew Ahrens 1661ae46e4c7SMatthew Ahrens resa.creation_time = drc->drc_drrb->drr_creation_time; 1662ae46e4c7SMatthew Ahrens resa.toguid = drc->drc_drrb->drr_toguid; 1663ae46e4c7SMatthew Ahrens resa.tosnap = drc->drc_tosnap; 1664ae46e4c7SMatthew Ahrens 1665ae46e4c7SMatthew Ahrens err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1666ae46e4c7SMatthew Ahrens recv_end_check, recv_end_sync, ds, &resa, 3); 1667ae46e4c7SMatthew Ahrens if (err) { 1668ae46e4c7SMatthew Ahrens /* clean up the fs we just recv'd into */ 1669ae46e4c7SMatthew Ahrens (void) dsl_dataset_destroy(ds, dmu_recv_tag, B_FALSE); 1670ae46e4c7SMatthew Ahrens } else { 1671ec5cf9d5SAlexander Stetsenko if (drc->drc_guid_to_ds_map != NULL) 1672ec5cf9d5SAlexander Stetsenko (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds); 1673ae46e4c7SMatthew Ahrens /* release the hold from dmu_recv_begin */ 1674ae46e4c7SMatthew Ahrens dsl_dataset_disown(ds, dmu_recv_tag); 1675ae46e4c7SMatthew Ahrens } 1676ae46e4c7SMatthew Ahrens return (err); 1677ae46e4c7SMatthew Ahrens } 1678ae46e4c7SMatthew Ahrens 1679ae46e4c7SMatthew Ahrens int 1680ae46e4c7SMatthew Ahrens dmu_recv_end(dmu_recv_cookie_t *drc) 1681ae46e4c7SMatthew Ahrens { 1682ae46e4c7SMatthew Ahrens if (drc->drc_logical_ds != drc->drc_real_ds) 1683ae46e4c7SMatthew Ahrens return (dmu_recv_existing_end(drc)); 1684ae46e4c7SMatthew Ahrens else 1685ae46e4c7SMatthew Ahrens return (dmu_recv_new_end(drc)); 1686ae46e4c7SMatthew Ahrens } 1687