1*0fa1b3ccSPaul Dagnelie /* 2*0fa1b3ccSPaul Dagnelie * CDDL HEADER START 3*0fa1b3ccSPaul Dagnelie * 4*0fa1b3ccSPaul Dagnelie * The contents of this file are subject to the terms of the 5*0fa1b3ccSPaul Dagnelie * Common Development and Distribution License (the "License"). 6*0fa1b3ccSPaul Dagnelie * You may not use this file except in compliance with the License. 7*0fa1b3ccSPaul Dagnelie * 8*0fa1b3ccSPaul Dagnelie * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9*0fa1b3ccSPaul Dagnelie * or http://www.opensolaris.org/os/licensing. 10*0fa1b3ccSPaul Dagnelie * See the License for the specific language governing permissions 11*0fa1b3ccSPaul Dagnelie * and limitations under the License. 12*0fa1b3ccSPaul Dagnelie * 13*0fa1b3ccSPaul Dagnelie * When distributing Covered Code, include this CDDL HEADER in each 14*0fa1b3ccSPaul Dagnelie * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15*0fa1b3ccSPaul Dagnelie * If applicable, add the following below this CDDL HEADER, with the 16*0fa1b3ccSPaul Dagnelie * fields enclosed by brackets "[]" replaced with your own identifying 17*0fa1b3ccSPaul Dagnelie * information: Portions Copyright [yyyy] [name of copyright owner] 18*0fa1b3ccSPaul Dagnelie * 19*0fa1b3ccSPaul Dagnelie * CDDL HEADER END 20*0fa1b3ccSPaul Dagnelie */ 21*0fa1b3ccSPaul Dagnelie /* 22*0fa1b3ccSPaul Dagnelie * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23*0fa1b3ccSPaul Dagnelie * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 24*0fa1b3ccSPaul Dagnelie * Copyright (c) 2011, 2015 by Delphix. All rights reserved. 25*0fa1b3ccSPaul Dagnelie * Copyright (c) 2014, Joyent, Inc. All rights reserved. 26*0fa1b3ccSPaul Dagnelie * Copyright 2014 HybridCluster. All rights reserved. 27*0fa1b3ccSPaul Dagnelie * Copyright 2016 RackTop Systems. 28*0fa1b3ccSPaul Dagnelie * Copyright (c) 2014 Integros [integros.com] 29*0fa1b3ccSPaul Dagnelie */ 30*0fa1b3ccSPaul Dagnelie 31*0fa1b3ccSPaul Dagnelie #include <sys/dmu.h> 32*0fa1b3ccSPaul Dagnelie #include <sys/dmu_impl.h> 33*0fa1b3ccSPaul Dagnelie #include <sys/dmu_tx.h> 34*0fa1b3ccSPaul Dagnelie #include <sys/dbuf.h> 35*0fa1b3ccSPaul Dagnelie #include <sys/dnode.h> 36*0fa1b3ccSPaul Dagnelie #include <sys/zfs_context.h> 37*0fa1b3ccSPaul Dagnelie #include <sys/dmu_objset.h> 38*0fa1b3ccSPaul Dagnelie #include <sys/dmu_traverse.h> 39*0fa1b3ccSPaul Dagnelie #include <sys/dsl_dataset.h> 40*0fa1b3ccSPaul Dagnelie #include <sys/dsl_dir.h> 41*0fa1b3ccSPaul Dagnelie #include <sys/dsl_prop.h> 42*0fa1b3ccSPaul Dagnelie #include <sys/dsl_pool.h> 43*0fa1b3ccSPaul Dagnelie #include <sys/dsl_synctask.h> 44*0fa1b3ccSPaul Dagnelie #include <sys/zfs_ioctl.h> 45*0fa1b3ccSPaul Dagnelie #include <sys/zap.h> 46*0fa1b3ccSPaul Dagnelie #include <sys/zio_checksum.h> 47*0fa1b3ccSPaul Dagnelie #include <sys/zfs_znode.h> 48*0fa1b3ccSPaul Dagnelie #include <zfs_fletcher.h> 49*0fa1b3ccSPaul Dagnelie #include <sys/avl.h> 50*0fa1b3ccSPaul Dagnelie #include <sys/ddt.h> 51*0fa1b3ccSPaul Dagnelie #include <sys/zfs_onexit.h> 52*0fa1b3ccSPaul Dagnelie #include <sys/dmu_recv.h> 53*0fa1b3ccSPaul Dagnelie #include <sys/dsl_destroy.h> 54*0fa1b3ccSPaul Dagnelie #include <sys/blkptr.h> 55*0fa1b3ccSPaul Dagnelie #include <sys/dsl_bookmark.h> 56*0fa1b3ccSPaul Dagnelie #include <sys/zfeature.h> 57*0fa1b3ccSPaul Dagnelie #include <sys/bqueue.h> 58*0fa1b3ccSPaul Dagnelie 59*0fa1b3ccSPaul Dagnelie int zfs_recv_queue_length = SPA_MAXBLOCKSIZE; 60*0fa1b3ccSPaul Dagnelie 61*0fa1b3ccSPaul Dagnelie static char *dmu_recv_tag = "dmu_recv_tag"; 62*0fa1b3ccSPaul Dagnelie const char *recv_clone_name = "%recv"; 63*0fa1b3ccSPaul Dagnelie 64*0fa1b3ccSPaul Dagnelie static void byteswap_record(dmu_replay_record_t *drr); 65*0fa1b3ccSPaul Dagnelie 66*0fa1b3ccSPaul Dagnelie typedef struct dmu_recv_begin_arg { 67*0fa1b3ccSPaul Dagnelie const char *drba_origin; 68*0fa1b3ccSPaul Dagnelie dmu_recv_cookie_t *drba_cookie; 69*0fa1b3ccSPaul Dagnelie cred_t *drba_cred; 70*0fa1b3ccSPaul Dagnelie uint64_t drba_snapobj; 71*0fa1b3ccSPaul Dagnelie } dmu_recv_begin_arg_t; 72*0fa1b3ccSPaul Dagnelie 73*0fa1b3ccSPaul Dagnelie static int 74*0fa1b3ccSPaul Dagnelie recv_begin_check_existing_impl(dmu_recv_begin_arg_t *drba, dsl_dataset_t *ds, 75*0fa1b3ccSPaul Dagnelie uint64_t fromguid) 76*0fa1b3ccSPaul Dagnelie { 77*0fa1b3ccSPaul Dagnelie uint64_t val; 78*0fa1b3ccSPaul Dagnelie int error; 79*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = ds->ds_dir->dd_pool; 80*0fa1b3ccSPaul Dagnelie 81*0fa1b3ccSPaul Dagnelie /* temporary clone name must not exist */ 82*0fa1b3ccSPaul Dagnelie error = zap_lookup(dp->dp_meta_objset, 83*0fa1b3ccSPaul Dagnelie dsl_dir_phys(ds->ds_dir)->dd_child_dir_zapobj, recv_clone_name, 84*0fa1b3ccSPaul Dagnelie 8, 1, &val); 85*0fa1b3ccSPaul Dagnelie if (error != ENOENT) 86*0fa1b3ccSPaul Dagnelie return (error == 0 ? EBUSY : error); 87*0fa1b3ccSPaul Dagnelie 88*0fa1b3ccSPaul Dagnelie /* new snapshot name must not exist */ 89*0fa1b3ccSPaul Dagnelie error = zap_lookup(dp->dp_meta_objset, 90*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds)->ds_snapnames_zapobj, 91*0fa1b3ccSPaul Dagnelie drba->drba_cookie->drc_tosnap, 8, 1, &val); 92*0fa1b3ccSPaul Dagnelie if (error != ENOENT) 93*0fa1b3ccSPaul Dagnelie return (error == 0 ? EEXIST : error); 94*0fa1b3ccSPaul Dagnelie 95*0fa1b3ccSPaul Dagnelie /* 96*0fa1b3ccSPaul Dagnelie * Check snapshot limit before receiving. We'll recheck again at the 97*0fa1b3ccSPaul Dagnelie * end, but might as well abort before receiving if we're already over 98*0fa1b3ccSPaul Dagnelie * the limit. 99*0fa1b3ccSPaul Dagnelie * 100*0fa1b3ccSPaul Dagnelie * Note that we do not check the file system limit with 101*0fa1b3ccSPaul Dagnelie * dsl_dir_fscount_check because the temporary %clones don't count 102*0fa1b3ccSPaul Dagnelie * against that limit. 103*0fa1b3ccSPaul Dagnelie */ 104*0fa1b3ccSPaul Dagnelie error = dsl_fs_ss_limit_check(ds->ds_dir, 1, ZFS_PROP_SNAPSHOT_LIMIT, 105*0fa1b3ccSPaul Dagnelie NULL, drba->drba_cred); 106*0fa1b3ccSPaul Dagnelie if (error != 0) 107*0fa1b3ccSPaul Dagnelie return (error); 108*0fa1b3ccSPaul Dagnelie 109*0fa1b3ccSPaul Dagnelie if (fromguid != 0) { 110*0fa1b3ccSPaul Dagnelie dsl_dataset_t *snap; 111*0fa1b3ccSPaul Dagnelie uint64_t obj = dsl_dataset_phys(ds)->ds_prev_snap_obj; 112*0fa1b3ccSPaul Dagnelie 113*0fa1b3ccSPaul Dagnelie /* Find snapshot in this dir that matches fromguid. */ 114*0fa1b3ccSPaul Dagnelie while (obj != 0) { 115*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold_obj(dp, obj, FTAG, 116*0fa1b3ccSPaul Dagnelie &snap); 117*0fa1b3ccSPaul Dagnelie if (error != 0) 118*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENODEV)); 119*0fa1b3ccSPaul Dagnelie if (snap->ds_dir != ds->ds_dir) { 120*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 121*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENODEV)); 122*0fa1b3ccSPaul Dagnelie } 123*0fa1b3ccSPaul Dagnelie if (dsl_dataset_phys(snap)->ds_guid == fromguid) 124*0fa1b3ccSPaul Dagnelie break; 125*0fa1b3ccSPaul Dagnelie obj = dsl_dataset_phys(snap)->ds_prev_snap_obj; 126*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 127*0fa1b3ccSPaul Dagnelie } 128*0fa1b3ccSPaul Dagnelie if (obj == 0) 129*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENODEV)); 130*0fa1b3ccSPaul Dagnelie 131*0fa1b3ccSPaul Dagnelie if (drba->drba_cookie->drc_force) { 132*0fa1b3ccSPaul Dagnelie drba->drba_snapobj = obj; 133*0fa1b3ccSPaul Dagnelie } else { 134*0fa1b3ccSPaul Dagnelie /* 135*0fa1b3ccSPaul Dagnelie * If we are not forcing, there must be no 136*0fa1b3ccSPaul Dagnelie * changes since fromsnap. 137*0fa1b3ccSPaul Dagnelie */ 138*0fa1b3ccSPaul Dagnelie if (dsl_dataset_modified_since_snap(ds, snap)) { 139*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 140*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ETXTBSY)); 141*0fa1b3ccSPaul Dagnelie } 142*0fa1b3ccSPaul Dagnelie drba->drba_snapobj = ds->ds_prev->ds_object; 143*0fa1b3ccSPaul Dagnelie } 144*0fa1b3ccSPaul Dagnelie 145*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 146*0fa1b3ccSPaul Dagnelie } else { 147*0fa1b3ccSPaul Dagnelie /* if full, then must be forced */ 148*0fa1b3ccSPaul Dagnelie if (!drba->drba_cookie->drc_force) 149*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EEXIST)); 150*0fa1b3ccSPaul Dagnelie /* start from $ORIGIN@$ORIGIN, if supported */ 151*0fa1b3ccSPaul Dagnelie drba->drba_snapobj = dp->dp_origin_snap != NULL ? 152*0fa1b3ccSPaul Dagnelie dp->dp_origin_snap->ds_object : 0; 153*0fa1b3ccSPaul Dagnelie } 154*0fa1b3ccSPaul Dagnelie 155*0fa1b3ccSPaul Dagnelie return (0); 156*0fa1b3ccSPaul Dagnelie 157*0fa1b3ccSPaul Dagnelie } 158*0fa1b3ccSPaul Dagnelie 159*0fa1b3ccSPaul Dagnelie static int 160*0fa1b3ccSPaul Dagnelie dmu_recv_begin_check(void *arg, dmu_tx_t *tx) 161*0fa1b3ccSPaul Dagnelie { 162*0fa1b3ccSPaul Dagnelie dmu_recv_begin_arg_t *drba = arg; 163*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = dmu_tx_pool(tx); 164*0fa1b3ccSPaul Dagnelie struct drr_begin *drrb = drba->drba_cookie->drc_drrb; 165*0fa1b3ccSPaul Dagnelie uint64_t fromguid = drrb->drr_fromguid; 166*0fa1b3ccSPaul Dagnelie int flags = drrb->drr_flags; 167*0fa1b3ccSPaul Dagnelie int error; 168*0fa1b3ccSPaul Dagnelie uint64_t featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 169*0fa1b3ccSPaul Dagnelie dsl_dataset_t *ds; 170*0fa1b3ccSPaul Dagnelie const char *tofs = drba->drba_cookie->drc_tofs; 171*0fa1b3ccSPaul Dagnelie 172*0fa1b3ccSPaul Dagnelie /* already checked */ 173*0fa1b3ccSPaul Dagnelie ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC); 174*0fa1b3ccSPaul Dagnelie ASSERT(!(featureflags & DMU_BACKUP_FEATURE_RESUMING)); 175*0fa1b3ccSPaul Dagnelie 176*0fa1b3ccSPaul Dagnelie if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == 177*0fa1b3ccSPaul Dagnelie DMU_COMPOUNDSTREAM || 178*0fa1b3ccSPaul Dagnelie drrb->drr_type >= DMU_OST_NUMTYPES || 179*0fa1b3ccSPaul Dagnelie ((flags & DRR_FLAG_CLONE) && drba->drba_origin == NULL)) 180*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 181*0fa1b3ccSPaul Dagnelie 182*0fa1b3ccSPaul Dagnelie /* Verify pool version supports SA if SA_SPILL feature set */ 183*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) && 184*0fa1b3ccSPaul Dagnelie spa_version(dp->dp_spa) < SPA_VERSION_SA) 185*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 186*0fa1b3ccSPaul Dagnelie 187*0fa1b3ccSPaul Dagnelie if (drba->drba_cookie->drc_resumable && 188*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_EXTENSIBLE_DATASET)) 189*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 190*0fa1b3ccSPaul Dagnelie 191*0fa1b3ccSPaul Dagnelie /* 192*0fa1b3ccSPaul Dagnelie * The receiving code doesn't know how to translate a WRITE_EMBEDDED 193*0fa1b3ccSPaul Dagnelie * record to a plain WRITE record, so the pool must have the 194*0fa1b3ccSPaul Dagnelie * EMBEDDED_DATA feature enabled if the stream has WRITE_EMBEDDED 195*0fa1b3ccSPaul Dagnelie * records. Same with WRITE_EMBEDDED records that use LZ4 compression. 196*0fa1b3ccSPaul Dagnelie */ 197*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_EMBED_DATA) && 198*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_EMBEDDED_DATA)) 199*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 200*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_LZ4) && 201*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LZ4_COMPRESS)) 202*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 203*0fa1b3ccSPaul Dagnelie 204*0fa1b3ccSPaul Dagnelie /* 205*0fa1b3ccSPaul Dagnelie * The receiving code doesn't know how to translate large blocks 206*0fa1b3ccSPaul Dagnelie * to smaller ones, so the pool must have the LARGE_BLOCKS 207*0fa1b3ccSPaul Dagnelie * feature enabled if the stream has LARGE_BLOCKS. Same with 208*0fa1b3ccSPaul Dagnelie * large dnodes. 209*0fa1b3ccSPaul Dagnelie */ 210*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) && 211*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LARGE_BLOCKS)) 212*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 213*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_LARGE_DNODE) && 214*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LARGE_DNODE)) 215*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 216*0fa1b3ccSPaul Dagnelie 217*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold(dp, tofs, FTAG, &ds); 218*0fa1b3ccSPaul Dagnelie if (error == 0) { 219*0fa1b3ccSPaul Dagnelie /* target fs already exists; recv into temp clone */ 220*0fa1b3ccSPaul Dagnelie 221*0fa1b3ccSPaul Dagnelie /* Can't recv a clone into an existing fs */ 222*0fa1b3ccSPaul Dagnelie if (flags & DRR_FLAG_CLONE || drba->drba_origin) { 223*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 224*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 225*0fa1b3ccSPaul Dagnelie } 226*0fa1b3ccSPaul Dagnelie 227*0fa1b3ccSPaul Dagnelie error = recv_begin_check_existing_impl(drba, ds, fromguid); 228*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 229*0fa1b3ccSPaul Dagnelie } else if (error == ENOENT) { 230*0fa1b3ccSPaul Dagnelie /* target fs does not exist; must be a full backup or clone */ 231*0fa1b3ccSPaul Dagnelie char buf[ZFS_MAX_DATASET_NAME_LEN]; 232*0fa1b3ccSPaul Dagnelie 233*0fa1b3ccSPaul Dagnelie /* 234*0fa1b3ccSPaul Dagnelie * If it's a non-clone incremental, we are missing the 235*0fa1b3ccSPaul Dagnelie * target fs, so fail the recv. 236*0fa1b3ccSPaul Dagnelie */ 237*0fa1b3ccSPaul Dagnelie if (fromguid != 0 && !(flags & DRR_FLAG_CLONE || 238*0fa1b3ccSPaul Dagnelie drba->drba_origin)) 239*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOENT)); 240*0fa1b3ccSPaul Dagnelie 241*0fa1b3ccSPaul Dagnelie /* 242*0fa1b3ccSPaul Dagnelie * If we're receiving a full send as a clone, and it doesn't 243*0fa1b3ccSPaul Dagnelie * contain all the necessary free records and freeobject 244*0fa1b3ccSPaul Dagnelie * records, reject it. 245*0fa1b3ccSPaul Dagnelie */ 246*0fa1b3ccSPaul Dagnelie if (fromguid == 0 && drba->drba_origin && 247*0fa1b3ccSPaul Dagnelie !(flags & DRR_FLAG_FREERECORDS)) 248*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 249*0fa1b3ccSPaul Dagnelie 250*0fa1b3ccSPaul Dagnelie /* Open the parent of tofs */ 251*0fa1b3ccSPaul Dagnelie ASSERT3U(strlen(tofs), <, sizeof (buf)); 252*0fa1b3ccSPaul Dagnelie (void) strlcpy(buf, tofs, strrchr(tofs, '/') - tofs + 1); 253*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold(dp, buf, FTAG, &ds); 254*0fa1b3ccSPaul Dagnelie if (error != 0) 255*0fa1b3ccSPaul Dagnelie return (error); 256*0fa1b3ccSPaul Dagnelie 257*0fa1b3ccSPaul Dagnelie /* 258*0fa1b3ccSPaul Dagnelie * Check filesystem and snapshot limits before receiving. We'll 259*0fa1b3ccSPaul Dagnelie * recheck snapshot limits again at the end (we create the 260*0fa1b3ccSPaul Dagnelie * filesystems and increment those counts during begin_sync). 261*0fa1b3ccSPaul Dagnelie */ 262*0fa1b3ccSPaul Dagnelie error = dsl_fs_ss_limit_check(ds->ds_dir, 1, 263*0fa1b3ccSPaul Dagnelie ZFS_PROP_FILESYSTEM_LIMIT, NULL, drba->drba_cred); 264*0fa1b3ccSPaul Dagnelie if (error != 0) { 265*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 266*0fa1b3ccSPaul Dagnelie return (error); 267*0fa1b3ccSPaul Dagnelie } 268*0fa1b3ccSPaul Dagnelie 269*0fa1b3ccSPaul Dagnelie error = dsl_fs_ss_limit_check(ds->ds_dir, 1, 270*0fa1b3ccSPaul Dagnelie ZFS_PROP_SNAPSHOT_LIMIT, NULL, drba->drba_cred); 271*0fa1b3ccSPaul Dagnelie if (error != 0) { 272*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 273*0fa1b3ccSPaul Dagnelie return (error); 274*0fa1b3ccSPaul Dagnelie } 275*0fa1b3ccSPaul Dagnelie 276*0fa1b3ccSPaul Dagnelie if (drba->drba_origin != NULL) { 277*0fa1b3ccSPaul Dagnelie dsl_dataset_t *origin; 278*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold(dp, drba->drba_origin, 279*0fa1b3ccSPaul Dagnelie FTAG, &origin); 280*0fa1b3ccSPaul Dagnelie if (error != 0) { 281*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 282*0fa1b3ccSPaul Dagnelie return (error); 283*0fa1b3ccSPaul Dagnelie } 284*0fa1b3ccSPaul Dagnelie if (!origin->ds_is_snapshot) { 285*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin, FTAG); 286*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 287*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 288*0fa1b3ccSPaul Dagnelie } 289*0fa1b3ccSPaul Dagnelie if (dsl_dataset_phys(origin)->ds_guid != fromguid && 290*0fa1b3ccSPaul Dagnelie fromguid != 0) { 291*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin, FTAG); 292*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 293*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENODEV)); 294*0fa1b3ccSPaul Dagnelie } 295*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin, FTAG); 296*0fa1b3ccSPaul Dagnelie } 297*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 298*0fa1b3ccSPaul Dagnelie error = 0; 299*0fa1b3ccSPaul Dagnelie } 300*0fa1b3ccSPaul Dagnelie return (error); 301*0fa1b3ccSPaul Dagnelie } 302*0fa1b3ccSPaul Dagnelie 303*0fa1b3ccSPaul Dagnelie static void 304*0fa1b3ccSPaul Dagnelie dmu_recv_begin_sync(void *arg, dmu_tx_t *tx) 305*0fa1b3ccSPaul Dagnelie { 306*0fa1b3ccSPaul Dagnelie dmu_recv_begin_arg_t *drba = arg; 307*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = dmu_tx_pool(tx); 308*0fa1b3ccSPaul Dagnelie objset_t *mos = dp->dp_meta_objset; 309*0fa1b3ccSPaul Dagnelie struct drr_begin *drrb = drba->drba_cookie->drc_drrb; 310*0fa1b3ccSPaul Dagnelie const char *tofs = drba->drba_cookie->drc_tofs; 311*0fa1b3ccSPaul Dagnelie dsl_dataset_t *ds, *newds; 312*0fa1b3ccSPaul Dagnelie uint64_t dsobj; 313*0fa1b3ccSPaul Dagnelie int error; 314*0fa1b3ccSPaul Dagnelie uint64_t crflags = 0; 315*0fa1b3ccSPaul Dagnelie 316*0fa1b3ccSPaul Dagnelie if (drrb->drr_flags & DRR_FLAG_CI_DATA) 317*0fa1b3ccSPaul Dagnelie crflags |= DS_FLAG_CI_DATASET; 318*0fa1b3ccSPaul Dagnelie 319*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold(dp, tofs, FTAG, &ds); 320*0fa1b3ccSPaul Dagnelie if (error == 0) { 321*0fa1b3ccSPaul Dagnelie /* create temporary clone */ 322*0fa1b3ccSPaul Dagnelie dsl_dataset_t *snap = NULL; 323*0fa1b3ccSPaul Dagnelie if (drba->drba_snapobj != 0) { 324*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_hold_obj(dp, 325*0fa1b3ccSPaul Dagnelie drba->drba_snapobj, FTAG, &snap)); 326*0fa1b3ccSPaul Dagnelie } 327*0fa1b3ccSPaul Dagnelie dsobj = dsl_dataset_create_sync(ds->ds_dir, recv_clone_name, 328*0fa1b3ccSPaul Dagnelie snap, crflags, drba->drba_cred, tx); 329*0fa1b3ccSPaul Dagnelie if (drba->drba_snapobj != 0) 330*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 331*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 332*0fa1b3ccSPaul Dagnelie } else { 333*0fa1b3ccSPaul Dagnelie dsl_dir_t *dd; 334*0fa1b3ccSPaul Dagnelie const char *tail; 335*0fa1b3ccSPaul Dagnelie dsl_dataset_t *origin = NULL; 336*0fa1b3ccSPaul Dagnelie 337*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dir_hold(dp, tofs, FTAG, &dd, &tail)); 338*0fa1b3ccSPaul Dagnelie 339*0fa1b3ccSPaul Dagnelie if (drba->drba_origin != NULL) { 340*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_hold(dp, drba->drba_origin, 341*0fa1b3ccSPaul Dagnelie FTAG, &origin)); 342*0fa1b3ccSPaul Dagnelie } 343*0fa1b3ccSPaul Dagnelie 344*0fa1b3ccSPaul Dagnelie /* Create new dataset. */ 345*0fa1b3ccSPaul Dagnelie dsobj = dsl_dataset_create_sync(dd, 346*0fa1b3ccSPaul Dagnelie strrchr(tofs, '/') + 1, 347*0fa1b3ccSPaul Dagnelie origin, crflags, drba->drba_cred, tx); 348*0fa1b3ccSPaul Dagnelie if (origin != NULL) 349*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin, FTAG); 350*0fa1b3ccSPaul Dagnelie dsl_dir_rele(dd, FTAG); 351*0fa1b3ccSPaul Dagnelie drba->drba_cookie->drc_newfs = B_TRUE; 352*0fa1b3ccSPaul Dagnelie } 353*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_own_obj(dp, dsobj, dmu_recv_tag, &newds)); 354*0fa1b3ccSPaul Dagnelie 355*0fa1b3ccSPaul Dagnelie if (drba->drba_cookie->drc_resumable) { 356*0fa1b3ccSPaul Dagnelie dsl_dataset_zapify(newds, tx); 357*0fa1b3ccSPaul Dagnelie if (drrb->drr_fromguid != 0) { 358*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_FROMGUID, 359*0fa1b3ccSPaul Dagnelie 8, 1, &drrb->drr_fromguid, tx)); 360*0fa1b3ccSPaul Dagnelie } 361*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_TOGUID, 362*0fa1b3ccSPaul Dagnelie 8, 1, &drrb->drr_toguid, tx)); 363*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_TONAME, 364*0fa1b3ccSPaul Dagnelie 1, strlen(drrb->drr_toname) + 1, drrb->drr_toname, tx)); 365*0fa1b3ccSPaul Dagnelie uint64_t one = 1; 366*0fa1b3ccSPaul Dagnelie uint64_t zero = 0; 367*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_OBJECT, 368*0fa1b3ccSPaul Dagnelie 8, 1, &one, tx)); 369*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_OFFSET, 370*0fa1b3ccSPaul Dagnelie 8, 1, &zero, tx)); 371*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_BYTES, 372*0fa1b3ccSPaul Dagnelie 8, 1, &zero, tx)); 373*0fa1b3ccSPaul Dagnelie if (DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) & 374*0fa1b3ccSPaul Dagnelie DMU_BACKUP_FEATURE_LARGE_BLOCKS) { 375*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_LARGEBLOCK, 376*0fa1b3ccSPaul Dagnelie 8, 1, &one, tx)); 377*0fa1b3ccSPaul Dagnelie } 378*0fa1b3ccSPaul Dagnelie if (DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) & 379*0fa1b3ccSPaul Dagnelie DMU_BACKUP_FEATURE_EMBED_DATA) { 380*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_EMBEDOK, 381*0fa1b3ccSPaul Dagnelie 8, 1, &one, tx)); 382*0fa1b3ccSPaul Dagnelie } 383*0fa1b3ccSPaul Dagnelie if (DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) & 384*0fa1b3ccSPaul Dagnelie DMU_BACKUP_FEATURE_COMPRESSED) { 385*0fa1b3ccSPaul Dagnelie VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_COMPRESSOK, 386*0fa1b3ccSPaul Dagnelie 8, 1, &one, tx)); 387*0fa1b3ccSPaul Dagnelie } 388*0fa1b3ccSPaul Dagnelie } 389*0fa1b3ccSPaul Dagnelie 390*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(newds->ds_dbuf, tx); 391*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(newds)->ds_flags |= DS_FLAG_INCONSISTENT; 392*0fa1b3ccSPaul Dagnelie 393*0fa1b3ccSPaul Dagnelie /* 394*0fa1b3ccSPaul Dagnelie * If we actually created a non-clone, we need to create the 395*0fa1b3ccSPaul Dagnelie * objset in our new dataset. 396*0fa1b3ccSPaul Dagnelie */ 397*0fa1b3ccSPaul Dagnelie rrw_enter(&newds->ds_bp_rwlock, RW_READER, FTAG); 398*0fa1b3ccSPaul Dagnelie if (BP_IS_HOLE(dsl_dataset_get_blkptr(newds))) { 399*0fa1b3ccSPaul Dagnelie (void) dmu_objset_create_impl(dp->dp_spa, 400*0fa1b3ccSPaul Dagnelie newds, dsl_dataset_get_blkptr(newds), drrb->drr_type, tx); 401*0fa1b3ccSPaul Dagnelie } 402*0fa1b3ccSPaul Dagnelie rrw_exit(&newds->ds_bp_rwlock, FTAG); 403*0fa1b3ccSPaul Dagnelie 404*0fa1b3ccSPaul Dagnelie drba->drba_cookie->drc_ds = newds; 405*0fa1b3ccSPaul Dagnelie 406*0fa1b3ccSPaul Dagnelie spa_history_log_internal_ds(newds, "receive", tx, ""); 407*0fa1b3ccSPaul Dagnelie } 408*0fa1b3ccSPaul Dagnelie 409*0fa1b3ccSPaul Dagnelie static int 410*0fa1b3ccSPaul Dagnelie dmu_recv_resume_begin_check(void *arg, dmu_tx_t *tx) 411*0fa1b3ccSPaul Dagnelie { 412*0fa1b3ccSPaul Dagnelie dmu_recv_begin_arg_t *drba = arg; 413*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = dmu_tx_pool(tx); 414*0fa1b3ccSPaul Dagnelie struct drr_begin *drrb = drba->drba_cookie->drc_drrb; 415*0fa1b3ccSPaul Dagnelie int error; 416*0fa1b3ccSPaul Dagnelie uint64_t featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo); 417*0fa1b3ccSPaul Dagnelie dsl_dataset_t *ds; 418*0fa1b3ccSPaul Dagnelie const char *tofs = drba->drba_cookie->drc_tofs; 419*0fa1b3ccSPaul Dagnelie 420*0fa1b3ccSPaul Dagnelie /* 6 extra bytes for /%recv */ 421*0fa1b3ccSPaul Dagnelie char recvname[ZFS_MAX_DATASET_NAME_LEN + 6]; 422*0fa1b3ccSPaul Dagnelie 423*0fa1b3ccSPaul Dagnelie /* already checked */ 424*0fa1b3ccSPaul Dagnelie ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC); 425*0fa1b3ccSPaul Dagnelie ASSERT(featureflags & DMU_BACKUP_FEATURE_RESUMING); 426*0fa1b3ccSPaul Dagnelie 427*0fa1b3ccSPaul Dagnelie if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == 428*0fa1b3ccSPaul Dagnelie DMU_COMPOUNDSTREAM || 429*0fa1b3ccSPaul Dagnelie drrb->drr_type >= DMU_OST_NUMTYPES) 430*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 431*0fa1b3ccSPaul Dagnelie 432*0fa1b3ccSPaul Dagnelie /* Verify pool version supports SA if SA_SPILL feature set */ 433*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) && 434*0fa1b3ccSPaul Dagnelie spa_version(dp->dp_spa) < SPA_VERSION_SA) 435*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 436*0fa1b3ccSPaul Dagnelie 437*0fa1b3ccSPaul Dagnelie /* 438*0fa1b3ccSPaul Dagnelie * The receiving code doesn't know how to translate a WRITE_EMBEDDED 439*0fa1b3ccSPaul Dagnelie * record to a plain WRITE record, so the pool must have the 440*0fa1b3ccSPaul Dagnelie * EMBEDDED_DATA feature enabled if the stream has WRITE_EMBEDDED 441*0fa1b3ccSPaul Dagnelie * records. Same with WRITE_EMBEDDED records that use LZ4 compression. 442*0fa1b3ccSPaul Dagnelie */ 443*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_EMBED_DATA) && 444*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_EMBEDDED_DATA)) 445*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 446*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_LZ4) && 447*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LZ4_COMPRESS)) 448*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 449*0fa1b3ccSPaul Dagnelie 450*0fa1b3ccSPaul Dagnelie /* 451*0fa1b3ccSPaul Dagnelie * The receiving code doesn't know how to translate large blocks 452*0fa1b3ccSPaul Dagnelie * to smaller ones, so the pool must have the LARGE_BLOCKS 453*0fa1b3ccSPaul Dagnelie * feature enabled if the stream has LARGE_BLOCKS. Same with 454*0fa1b3ccSPaul Dagnelie * large dnodes. 455*0fa1b3ccSPaul Dagnelie */ 456*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) && 457*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LARGE_BLOCKS)) 458*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 459*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_LARGE_DNODE) && 460*0fa1b3ccSPaul Dagnelie !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_LARGE_DNODE)) 461*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ENOTSUP)); 462*0fa1b3ccSPaul Dagnelie 463*0fa1b3ccSPaul Dagnelie (void) snprintf(recvname, sizeof (recvname), "%s/%s", 464*0fa1b3ccSPaul Dagnelie tofs, recv_clone_name); 465*0fa1b3ccSPaul Dagnelie 466*0fa1b3ccSPaul Dagnelie if (dsl_dataset_hold(dp, recvname, FTAG, &ds) != 0) { 467*0fa1b3ccSPaul Dagnelie /* %recv does not exist; continue in tofs */ 468*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold(dp, tofs, FTAG, &ds); 469*0fa1b3ccSPaul Dagnelie if (error != 0) 470*0fa1b3ccSPaul Dagnelie return (error); 471*0fa1b3ccSPaul Dagnelie } 472*0fa1b3ccSPaul Dagnelie 473*0fa1b3ccSPaul Dagnelie /* check that ds is marked inconsistent */ 474*0fa1b3ccSPaul Dagnelie if (!DS_IS_INCONSISTENT(ds)) { 475*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 476*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 477*0fa1b3ccSPaul Dagnelie } 478*0fa1b3ccSPaul Dagnelie 479*0fa1b3ccSPaul Dagnelie /* check that there is resuming data, and that the toguid matches */ 480*0fa1b3ccSPaul Dagnelie if (!dsl_dataset_is_zapified(ds)) { 481*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 482*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 483*0fa1b3ccSPaul Dagnelie } 484*0fa1b3ccSPaul Dagnelie uint64_t val; 485*0fa1b3ccSPaul Dagnelie error = zap_lookup(dp->dp_meta_objset, ds->ds_object, 486*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_TOGUID, sizeof (val), 1, &val); 487*0fa1b3ccSPaul Dagnelie if (error != 0 || drrb->drr_toguid != val) { 488*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 489*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 490*0fa1b3ccSPaul Dagnelie } 491*0fa1b3ccSPaul Dagnelie 492*0fa1b3ccSPaul Dagnelie /* 493*0fa1b3ccSPaul Dagnelie * Check if the receive is still running. If so, it will be owned. 494*0fa1b3ccSPaul Dagnelie * Note that nothing else can own the dataset (e.g. after the receive 495*0fa1b3ccSPaul Dagnelie * fails) because it will be marked inconsistent. 496*0fa1b3ccSPaul Dagnelie */ 497*0fa1b3ccSPaul Dagnelie if (dsl_dataset_has_owner(ds)) { 498*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 499*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EBUSY)); 500*0fa1b3ccSPaul Dagnelie } 501*0fa1b3ccSPaul Dagnelie 502*0fa1b3ccSPaul Dagnelie /* There should not be any snapshots of this fs yet. */ 503*0fa1b3ccSPaul Dagnelie if (ds->ds_prev != NULL && ds->ds_prev->ds_dir == ds->ds_dir) { 504*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 505*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 506*0fa1b3ccSPaul Dagnelie } 507*0fa1b3ccSPaul Dagnelie 508*0fa1b3ccSPaul Dagnelie /* 509*0fa1b3ccSPaul Dagnelie * Note: resume point will be checked when we process the first WRITE 510*0fa1b3ccSPaul Dagnelie * record. 511*0fa1b3ccSPaul Dagnelie */ 512*0fa1b3ccSPaul Dagnelie 513*0fa1b3ccSPaul Dagnelie /* check that the origin matches */ 514*0fa1b3ccSPaul Dagnelie val = 0; 515*0fa1b3ccSPaul Dagnelie (void) zap_lookup(dp->dp_meta_objset, ds->ds_object, 516*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_FROMGUID, sizeof (val), 1, &val); 517*0fa1b3ccSPaul Dagnelie if (drrb->drr_fromguid != val) { 518*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 519*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 520*0fa1b3ccSPaul Dagnelie } 521*0fa1b3ccSPaul Dagnelie 522*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 523*0fa1b3ccSPaul Dagnelie return (0); 524*0fa1b3ccSPaul Dagnelie } 525*0fa1b3ccSPaul Dagnelie 526*0fa1b3ccSPaul Dagnelie static void 527*0fa1b3ccSPaul Dagnelie dmu_recv_resume_begin_sync(void *arg, dmu_tx_t *tx) 528*0fa1b3ccSPaul Dagnelie { 529*0fa1b3ccSPaul Dagnelie dmu_recv_begin_arg_t *drba = arg; 530*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = dmu_tx_pool(tx); 531*0fa1b3ccSPaul Dagnelie const char *tofs = drba->drba_cookie->drc_tofs; 532*0fa1b3ccSPaul Dagnelie dsl_dataset_t *ds; 533*0fa1b3ccSPaul Dagnelie uint64_t dsobj; 534*0fa1b3ccSPaul Dagnelie /* 6 extra bytes for /%recv */ 535*0fa1b3ccSPaul Dagnelie char recvname[ZFS_MAX_DATASET_NAME_LEN + 6]; 536*0fa1b3ccSPaul Dagnelie 537*0fa1b3ccSPaul Dagnelie (void) snprintf(recvname, sizeof (recvname), "%s/%s", 538*0fa1b3ccSPaul Dagnelie tofs, recv_clone_name); 539*0fa1b3ccSPaul Dagnelie 540*0fa1b3ccSPaul Dagnelie if (dsl_dataset_hold(dp, recvname, FTAG, &ds) != 0) { 541*0fa1b3ccSPaul Dagnelie /* %recv does not exist; continue in tofs */ 542*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_hold(dp, tofs, FTAG, &ds)); 543*0fa1b3ccSPaul Dagnelie drba->drba_cookie->drc_newfs = B_TRUE; 544*0fa1b3ccSPaul Dagnelie } 545*0fa1b3ccSPaul Dagnelie 546*0fa1b3ccSPaul Dagnelie /* clear the inconsistent flag so that we can own it */ 547*0fa1b3ccSPaul Dagnelie ASSERT(DS_IS_INCONSISTENT(ds)); 548*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(ds->ds_dbuf, tx); 549*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds)->ds_flags &= ~DS_FLAG_INCONSISTENT; 550*0fa1b3ccSPaul Dagnelie dsobj = ds->ds_object; 551*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(ds, FTAG); 552*0fa1b3ccSPaul Dagnelie 553*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_own_obj(dp, dsobj, dmu_recv_tag, &ds)); 554*0fa1b3ccSPaul Dagnelie 555*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(ds->ds_dbuf, tx); 556*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_INCONSISTENT; 557*0fa1b3ccSPaul Dagnelie 558*0fa1b3ccSPaul Dagnelie rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG); 559*0fa1b3ccSPaul Dagnelie ASSERT(!BP_IS_HOLE(dsl_dataset_get_blkptr(ds))); 560*0fa1b3ccSPaul Dagnelie rrw_exit(&ds->ds_bp_rwlock, FTAG); 561*0fa1b3ccSPaul Dagnelie 562*0fa1b3ccSPaul Dagnelie drba->drba_cookie->drc_ds = ds; 563*0fa1b3ccSPaul Dagnelie 564*0fa1b3ccSPaul Dagnelie spa_history_log_internal_ds(ds, "resume receive", tx, ""); 565*0fa1b3ccSPaul Dagnelie } 566*0fa1b3ccSPaul Dagnelie 567*0fa1b3ccSPaul Dagnelie /* 568*0fa1b3ccSPaul Dagnelie * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin() 569*0fa1b3ccSPaul Dagnelie * succeeds; otherwise we will leak the holds on the datasets. 570*0fa1b3ccSPaul Dagnelie */ 571*0fa1b3ccSPaul Dagnelie int 572*0fa1b3ccSPaul Dagnelie dmu_recv_begin(char *tofs, char *tosnap, dmu_replay_record_t *drr_begin, 573*0fa1b3ccSPaul Dagnelie boolean_t force, boolean_t resumable, char *origin, dmu_recv_cookie_t *drc) 574*0fa1b3ccSPaul Dagnelie { 575*0fa1b3ccSPaul Dagnelie dmu_recv_begin_arg_t drba = { 0 }; 576*0fa1b3ccSPaul Dagnelie 577*0fa1b3ccSPaul Dagnelie bzero(drc, sizeof (dmu_recv_cookie_t)); 578*0fa1b3ccSPaul Dagnelie drc->drc_drr_begin = drr_begin; 579*0fa1b3ccSPaul Dagnelie drc->drc_drrb = &drr_begin->drr_u.drr_begin; 580*0fa1b3ccSPaul Dagnelie drc->drc_tosnap = tosnap; 581*0fa1b3ccSPaul Dagnelie drc->drc_tofs = tofs; 582*0fa1b3ccSPaul Dagnelie drc->drc_force = force; 583*0fa1b3ccSPaul Dagnelie drc->drc_resumable = resumable; 584*0fa1b3ccSPaul Dagnelie drc->drc_cred = CRED(); 585*0fa1b3ccSPaul Dagnelie drc->drc_clone = (origin != NULL); 586*0fa1b3ccSPaul Dagnelie 587*0fa1b3ccSPaul Dagnelie if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) { 588*0fa1b3ccSPaul Dagnelie drc->drc_byteswap = B_TRUE; 589*0fa1b3ccSPaul Dagnelie (void) fletcher_4_incremental_byteswap(drr_begin, 590*0fa1b3ccSPaul Dagnelie sizeof (dmu_replay_record_t), &drc->drc_cksum); 591*0fa1b3ccSPaul Dagnelie byteswap_record(drr_begin); 592*0fa1b3ccSPaul Dagnelie } else if (drc->drc_drrb->drr_magic == DMU_BACKUP_MAGIC) { 593*0fa1b3ccSPaul Dagnelie (void) fletcher_4_incremental_native(drr_begin, 594*0fa1b3ccSPaul Dagnelie sizeof (dmu_replay_record_t), &drc->drc_cksum); 595*0fa1b3ccSPaul Dagnelie } else { 596*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 597*0fa1b3ccSPaul Dagnelie } 598*0fa1b3ccSPaul Dagnelie 599*0fa1b3ccSPaul Dagnelie drba.drba_origin = origin; 600*0fa1b3ccSPaul Dagnelie drba.drba_cookie = drc; 601*0fa1b3ccSPaul Dagnelie drba.drba_cred = CRED(); 602*0fa1b3ccSPaul Dagnelie 603*0fa1b3ccSPaul Dagnelie if (DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo) & 604*0fa1b3ccSPaul Dagnelie DMU_BACKUP_FEATURE_RESUMING) { 605*0fa1b3ccSPaul Dagnelie return (dsl_sync_task(tofs, 606*0fa1b3ccSPaul Dagnelie dmu_recv_resume_begin_check, dmu_recv_resume_begin_sync, 607*0fa1b3ccSPaul Dagnelie &drba, 5, ZFS_SPACE_CHECK_NORMAL)); 608*0fa1b3ccSPaul Dagnelie } else { 609*0fa1b3ccSPaul Dagnelie return (dsl_sync_task(tofs, 610*0fa1b3ccSPaul Dagnelie dmu_recv_begin_check, dmu_recv_begin_sync, 611*0fa1b3ccSPaul Dagnelie &drba, 5, ZFS_SPACE_CHECK_NORMAL)); 612*0fa1b3ccSPaul Dagnelie } 613*0fa1b3ccSPaul Dagnelie } 614*0fa1b3ccSPaul Dagnelie 615*0fa1b3ccSPaul Dagnelie struct receive_record_arg { 616*0fa1b3ccSPaul Dagnelie dmu_replay_record_t header; 617*0fa1b3ccSPaul Dagnelie void *payload; /* Pointer to a buffer containing the payload */ 618*0fa1b3ccSPaul Dagnelie /* 619*0fa1b3ccSPaul Dagnelie * If the record is a write, pointer to the arc_buf_t containing the 620*0fa1b3ccSPaul Dagnelie * payload. 621*0fa1b3ccSPaul Dagnelie */ 622*0fa1b3ccSPaul Dagnelie arc_buf_t *write_buf; 623*0fa1b3ccSPaul Dagnelie int payload_size; 624*0fa1b3ccSPaul Dagnelie uint64_t bytes_read; /* bytes read from stream when record created */ 625*0fa1b3ccSPaul Dagnelie boolean_t eos_marker; /* Marks the end of the stream */ 626*0fa1b3ccSPaul Dagnelie bqueue_node_t node; 627*0fa1b3ccSPaul Dagnelie }; 628*0fa1b3ccSPaul Dagnelie 629*0fa1b3ccSPaul Dagnelie struct receive_writer_arg { 630*0fa1b3ccSPaul Dagnelie objset_t *os; 631*0fa1b3ccSPaul Dagnelie boolean_t byteswap; 632*0fa1b3ccSPaul Dagnelie bqueue_t q; 633*0fa1b3ccSPaul Dagnelie 634*0fa1b3ccSPaul Dagnelie /* 635*0fa1b3ccSPaul Dagnelie * These three args are used to signal to the main thread that we're 636*0fa1b3ccSPaul Dagnelie * done. 637*0fa1b3ccSPaul Dagnelie */ 638*0fa1b3ccSPaul Dagnelie kmutex_t mutex; 639*0fa1b3ccSPaul Dagnelie kcondvar_t cv; 640*0fa1b3ccSPaul Dagnelie boolean_t done; 641*0fa1b3ccSPaul Dagnelie 642*0fa1b3ccSPaul Dagnelie int err; 643*0fa1b3ccSPaul Dagnelie /* A map from guid to dataset to help handle dedup'd streams. */ 644*0fa1b3ccSPaul Dagnelie avl_tree_t *guid_to_ds_map; 645*0fa1b3ccSPaul Dagnelie boolean_t resumable; 646*0fa1b3ccSPaul Dagnelie uint64_t last_object; 647*0fa1b3ccSPaul Dagnelie uint64_t last_offset; 648*0fa1b3ccSPaul Dagnelie uint64_t max_object; /* highest object ID referenced in stream */ 649*0fa1b3ccSPaul Dagnelie uint64_t bytes_read; /* bytes read when current record created */ 650*0fa1b3ccSPaul Dagnelie }; 651*0fa1b3ccSPaul Dagnelie 652*0fa1b3ccSPaul Dagnelie struct objlist { 653*0fa1b3ccSPaul Dagnelie list_t list; /* List of struct receive_objnode. */ 654*0fa1b3ccSPaul Dagnelie /* 655*0fa1b3ccSPaul Dagnelie * Last object looked up. Used to assert that objects are being looked 656*0fa1b3ccSPaul Dagnelie * up in ascending order. 657*0fa1b3ccSPaul Dagnelie */ 658*0fa1b3ccSPaul Dagnelie uint64_t last_lookup; 659*0fa1b3ccSPaul Dagnelie }; 660*0fa1b3ccSPaul Dagnelie 661*0fa1b3ccSPaul Dagnelie struct receive_objnode { 662*0fa1b3ccSPaul Dagnelie list_node_t node; 663*0fa1b3ccSPaul Dagnelie uint64_t object; 664*0fa1b3ccSPaul Dagnelie }; 665*0fa1b3ccSPaul Dagnelie 666*0fa1b3ccSPaul Dagnelie struct receive_arg { 667*0fa1b3ccSPaul Dagnelie objset_t *os; 668*0fa1b3ccSPaul Dagnelie vnode_t *vp; /* The vnode to read the stream from */ 669*0fa1b3ccSPaul Dagnelie uint64_t voff; /* The current offset in the stream */ 670*0fa1b3ccSPaul Dagnelie uint64_t bytes_read; 671*0fa1b3ccSPaul Dagnelie /* 672*0fa1b3ccSPaul Dagnelie * A record that has had its payload read in, but hasn't yet been handed 673*0fa1b3ccSPaul Dagnelie * off to the worker thread. 674*0fa1b3ccSPaul Dagnelie */ 675*0fa1b3ccSPaul Dagnelie struct receive_record_arg *rrd; 676*0fa1b3ccSPaul Dagnelie /* A record that has had its header read in, but not its payload. */ 677*0fa1b3ccSPaul Dagnelie struct receive_record_arg *next_rrd; 678*0fa1b3ccSPaul Dagnelie zio_cksum_t cksum; 679*0fa1b3ccSPaul Dagnelie zio_cksum_t prev_cksum; 680*0fa1b3ccSPaul Dagnelie int err; 681*0fa1b3ccSPaul Dagnelie boolean_t byteswap; 682*0fa1b3ccSPaul Dagnelie /* Sorted list of objects not to issue prefetches for. */ 683*0fa1b3ccSPaul Dagnelie struct objlist ignore_objlist; 684*0fa1b3ccSPaul Dagnelie }; 685*0fa1b3ccSPaul Dagnelie 686*0fa1b3ccSPaul Dagnelie typedef struct guid_map_entry { 687*0fa1b3ccSPaul Dagnelie uint64_t guid; 688*0fa1b3ccSPaul Dagnelie dsl_dataset_t *gme_ds; 689*0fa1b3ccSPaul Dagnelie avl_node_t avlnode; 690*0fa1b3ccSPaul Dagnelie } guid_map_entry_t; 691*0fa1b3ccSPaul Dagnelie 692*0fa1b3ccSPaul Dagnelie static int 693*0fa1b3ccSPaul Dagnelie guid_compare(const void *arg1, const void *arg2) 694*0fa1b3ccSPaul Dagnelie { 695*0fa1b3ccSPaul Dagnelie const guid_map_entry_t *gmep1 = arg1; 696*0fa1b3ccSPaul Dagnelie const guid_map_entry_t *gmep2 = arg2; 697*0fa1b3ccSPaul Dagnelie 698*0fa1b3ccSPaul Dagnelie if (gmep1->guid < gmep2->guid) 699*0fa1b3ccSPaul Dagnelie return (-1); 700*0fa1b3ccSPaul Dagnelie else if (gmep1->guid > gmep2->guid) 701*0fa1b3ccSPaul Dagnelie return (1); 702*0fa1b3ccSPaul Dagnelie return (0); 703*0fa1b3ccSPaul Dagnelie } 704*0fa1b3ccSPaul Dagnelie 705*0fa1b3ccSPaul Dagnelie static void 706*0fa1b3ccSPaul Dagnelie free_guid_map_onexit(void *arg) 707*0fa1b3ccSPaul Dagnelie { 708*0fa1b3ccSPaul Dagnelie avl_tree_t *ca = arg; 709*0fa1b3ccSPaul Dagnelie void *cookie = NULL; 710*0fa1b3ccSPaul Dagnelie guid_map_entry_t *gmep; 711*0fa1b3ccSPaul Dagnelie 712*0fa1b3ccSPaul Dagnelie while ((gmep = avl_destroy_nodes(ca, &cookie)) != NULL) { 713*0fa1b3ccSPaul Dagnelie dsl_dataset_long_rele(gmep->gme_ds, gmep); 714*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(gmep->gme_ds, gmep); 715*0fa1b3ccSPaul Dagnelie kmem_free(gmep, sizeof (guid_map_entry_t)); 716*0fa1b3ccSPaul Dagnelie } 717*0fa1b3ccSPaul Dagnelie avl_destroy(ca); 718*0fa1b3ccSPaul Dagnelie kmem_free(ca, sizeof (avl_tree_t)); 719*0fa1b3ccSPaul Dagnelie } 720*0fa1b3ccSPaul Dagnelie 721*0fa1b3ccSPaul Dagnelie static int 722*0fa1b3ccSPaul Dagnelie receive_read(struct receive_arg *ra, int len, void *buf) 723*0fa1b3ccSPaul Dagnelie { 724*0fa1b3ccSPaul Dagnelie int done = 0; 725*0fa1b3ccSPaul Dagnelie 726*0fa1b3ccSPaul Dagnelie /* 727*0fa1b3ccSPaul Dagnelie * The code doesn't rely on this (lengths being multiples of 8). See 728*0fa1b3ccSPaul Dagnelie * comment in dump_bytes. 729*0fa1b3ccSPaul Dagnelie */ 730*0fa1b3ccSPaul Dagnelie ASSERT0(len % 8); 731*0fa1b3ccSPaul Dagnelie 732*0fa1b3ccSPaul Dagnelie while (done < len) { 733*0fa1b3ccSPaul Dagnelie ssize_t resid; 734*0fa1b3ccSPaul Dagnelie 735*0fa1b3ccSPaul Dagnelie ra->err = vn_rdwr(UIO_READ, ra->vp, 736*0fa1b3ccSPaul Dagnelie (char *)buf + done, len - done, 737*0fa1b3ccSPaul Dagnelie ra->voff, UIO_SYSSPACE, FAPPEND, 738*0fa1b3ccSPaul Dagnelie RLIM64_INFINITY, CRED(), &resid); 739*0fa1b3ccSPaul Dagnelie 740*0fa1b3ccSPaul Dagnelie if (resid == len - done) { 741*0fa1b3ccSPaul Dagnelie /* 742*0fa1b3ccSPaul Dagnelie * Note: ECKSUM indicates that the receive 743*0fa1b3ccSPaul Dagnelie * was interrupted and can potentially be resumed. 744*0fa1b3ccSPaul Dagnelie */ 745*0fa1b3ccSPaul Dagnelie ra->err = SET_ERROR(ECKSUM); 746*0fa1b3ccSPaul Dagnelie } 747*0fa1b3ccSPaul Dagnelie ra->voff += len - done - resid; 748*0fa1b3ccSPaul Dagnelie done = len - resid; 749*0fa1b3ccSPaul Dagnelie if (ra->err != 0) 750*0fa1b3ccSPaul Dagnelie return (ra->err); 751*0fa1b3ccSPaul Dagnelie } 752*0fa1b3ccSPaul Dagnelie 753*0fa1b3ccSPaul Dagnelie ra->bytes_read += len; 754*0fa1b3ccSPaul Dagnelie 755*0fa1b3ccSPaul Dagnelie ASSERT3U(done, ==, len); 756*0fa1b3ccSPaul Dagnelie return (0); 757*0fa1b3ccSPaul Dagnelie } 758*0fa1b3ccSPaul Dagnelie 759*0fa1b3ccSPaul Dagnelie static void 760*0fa1b3ccSPaul Dagnelie byteswap_record(dmu_replay_record_t *drr) 761*0fa1b3ccSPaul Dagnelie { 762*0fa1b3ccSPaul Dagnelie #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X)) 763*0fa1b3ccSPaul Dagnelie #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X)) 764*0fa1b3ccSPaul Dagnelie drr->drr_type = BSWAP_32(drr->drr_type); 765*0fa1b3ccSPaul Dagnelie drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen); 766*0fa1b3ccSPaul Dagnelie 767*0fa1b3ccSPaul Dagnelie switch (drr->drr_type) { 768*0fa1b3ccSPaul Dagnelie case DRR_BEGIN: 769*0fa1b3ccSPaul Dagnelie DO64(drr_begin.drr_magic); 770*0fa1b3ccSPaul Dagnelie DO64(drr_begin.drr_versioninfo); 771*0fa1b3ccSPaul Dagnelie DO64(drr_begin.drr_creation_time); 772*0fa1b3ccSPaul Dagnelie DO32(drr_begin.drr_type); 773*0fa1b3ccSPaul Dagnelie DO32(drr_begin.drr_flags); 774*0fa1b3ccSPaul Dagnelie DO64(drr_begin.drr_toguid); 775*0fa1b3ccSPaul Dagnelie DO64(drr_begin.drr_fromguid); 776*0fa1b3ccSPaul Dagnelie break; 777*0fa1b3ccSPaul Dagnelie case DRR_OBJECT: 778*0fa1b3ccSPaul Dagnelie DO64(drr_object.drr_object); 779*0fa1b3ccSPaul Dagnelie DO32(drr_object.drr_type); 780*0fa1b3ccSPaul Dagnelie DO32(drr_object.drr_bonustype); 781*0fa1b3ccSPaul Dagnelie DO32(drr_object.drr_blksz); 782*0fa1b3ccSPaul Dagnelie DO32(drr_object.drr_bonuslen); 783*0fa1b3ccSPaul Dagnelie DO64(drr_object.drr_toguid); 784*0fa1b3ccSPaul Dagnelie break; 785*0fa1b3ccSPaul Dagnelie case DRR_FREEOBJECTS: 786*0fa1b3ccSPaul Dagnelie DO64(drr_freeobjects.drr_firstobj); 787*0fa1b3ccSPaul Dagnelie DO64(drr_freeobjects.drr_numobjs); 788*0fa1b3ccSPaul Dagnelie DO64(drr_freeobjects.drr_toguid); 789*0fa1b3ccSPaul Dagnelie break; 790*0fa1b3ccSPaul Dagnelie case DRR_WRITE: 791*0fa1b3ccSPaul Dagnelie DO64(drr_write.drr_object); 792*0fa1b3ccSPaul Dagnelie DO32(drr_write.drr_type); 793*0fa1b3ccSPaul Dagnelie DO64(drr_write.drr_offset); 794*0fa1b3ccSPaul Dagnelie DO64(drr_write.drr_logical_size); 795*0fa1b3ccSPaul Dagnelie DO64(drr_write.drr_toguid); 796*0fa1b3ccSPaul Dagnelie ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_write.drr_key.ddk_cksum); 797*0fa1b3ccSPaul Dagnelie DO64(drr_write.drr_key.ddk_prop); 798*0fa1b3ccSPaul Dagnelie DO64(drr_write.drr_compressed_size); 799*0fa1b3ccSPaul Dagnelie break; 800*0fa1b3ccSPaul Dagnelie case DRR_WRITE_BYREF: 801*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_object); 802*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_offset); 803*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_length); 804*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_toguid); 805*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_refguid); 806*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_refobject); 807*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_refoffset); 808*0fa1b3ccSPaul Dagnelie ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_write_byref. 809*0fa1b3ccSPaul Dagnelie drr_key.ddk_cksum); 810*0fa1b3ccSPaul Dagnelie DO64(drr_write_byref.drr_key.ddk_prop); 811*0fa1b3ccSPaul Dagnelie break; 812*0fa1b3ccSPaul Dagnelie case DRR_WRITE_EMBEDDED: 813*0fa1b3ccSPaul Dagnelie DO64(drr_write_embedded.drr_object); 814*0fa1b3ccSPaul Dagnelie DO64(drr_write_embedded.drr_offset); 815*0fa1b3ccSPaul Dagnelie DO64(drr_write_embedded.drr_length); 816*0fa1b3ccSPaul Dagnelie DO64(drr_write_embedded.drr_toguid); 817*0fa1b3ccSPaul Dagnelie DO32(drr_write_embedded.drr_lsize); 818*0fa1b3ccSPaul Dagnelie DO32(drr_write_embedded.drr_psize); 819*0fa1b3ccSPaul Dagnelie break; 820*0fa1b3ccSPaul Dagnelie case DRR_FREE: 821*0fa1b3ccSPaul Dagnelie DO64(drr_free.drr_object); 822*0fa1b3ccSPaul Dagnelie DO64(drr_free.drr_offset); 823*0fa1b3ccSPaul Dagnelie DO64(drr_free.drr_length); 824*0fa1b3ccSPaul Dagnelie DO64(drr_free.drr_toguid); 825*0fa1b3ccSPaul Dagnelie break; 826*0fa1b3ccSPaul Dagnelie case DRR_SPILL: 827*0fa1b3ccSPaul Dagnelie DO64(drr_spill.drr_object); 828*0fa1b3ccSPaul Dagnelie DO64(drr_spill.drr_length); 829*0fa1b3ccSPaul Dagnelie DO64(drr_spill.drr_toguid); 830*0fa1b3ccSPaul Dagnelie break; 831*0fa1b3ccSPaul Dagnelie case DRR_END: 832*0fa1b3ccSPaul Dagnelie DO64(drr_end.drr_toguid); 833*0fa1b3ccSPaul Dagnelie ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_end.drr_checksum); 834*0fa1b3ccSPaul Dagnelie break; 835*0fa1b3ccSPaul Dagnelie } 836*0fa1b3ccSPaul Dagnelie 837*0fa1b3ccSPaul Dagnelie if (drr->drr_type != DRR_BEGIN) { 838*0fa1b3ccSPaul Dagnelie ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_checksum.drr_checksum); 839*0fa1b3ccSPaul Dagnelie } 840*0fa1b3ccSPaul Dagnelie 841*0fa1b3ccSPaul Dagnelie #undef DO64 842*0fa1b3ccSPaul Dagnelie #undef DO32 843*0fa1b3ccSPaul Dagnelie } 844*0fa1b3ccSPaul Dagnelie 845*0fa1b3ccSPaul Dagnelie static inline uint8_t 846*0fa1b3ccSPaul Dagnelie deduce_nblkptr(dmu_object_type_t bonus_type, uint64_t bonus_size) 847*0fa1b3ccSPaul Dagnelie { 848*0fa1b3ccSPaul Dagnelie if (bonus_type == DMU_OT_SA) { 849*0fa1b3ccSPaul Dagnelie return (1); 850*0fa1b3ccSPaul Dagnelie } else { 851*0fa1b3ccSPaul Dagnelie return (1 + 852*0fa1b3ccSPaul Dagnelie ((DN_OLD_MAX_BONUSLEN - 853*0fa1b3ccSPaul Dagnelie MIN(DN_OLD_MAX_BONUSLEN, bonus_size)) >> SPA_BLKPTRSHIFT)); 854*0fa1b3ccSPaul Dagnelie } 855*0fa1b3ccSPaul Dagnelie } 856*0fa1b3ccSPaul Dagnelie 857*0fa1b3ccSPaul Dagnelie static void 858*0fa1b3ccSPaul Dagnelie save_resume_state(struct receive_writer_arg *rwa, 859*0fa1b3ccSPaul Dagnelie uint64_t object, uint64_t offset, dmu_tx_t *tx) 860*0fa1b3ccSPaul Dagnelie { 861*0fa1b3ccSPaul Dagnelie int txgoff = dmu_tx_get_txg(tx) & TXG_MASK; 862*0fa1b3ccSPaul Dagnelie 863*0fa1b3ccSPaul Dagnelie if (!rwa->resumable) 864*0fa1b3ccSPaul Dagnelie return; 865*0fa1b3ccSPaul Dagnelie 866*0fa1b3ccSPaul Dagnelie /* 867*0fa1b3ccSPaul Dagnelie * We use ds_resume_bytes[] != 0 to indicate that we need to 868*0fa1b3ccSPaul Dagnelie * update this on disk, so it must not be 0. 869*0fa1b3ccSPaul Dagnelie */ 870*0fa1b3ccSPaul Dagnelie ASSERT(rwa->bytes_read != 0); 871*0fa1b3ccSPaul Dagnelie 872*0fa1b3ccSPaul Dagnelie /* 873*0fa1b3ccSPaul Dagnelie * We only resume from write records, which have a valid 874*0fa1b3ccSPaul Dagnelie * (non-meta-dnode) object number. 875*0fa1b3ccSPaul Dagnelie */ 876*0fa1b3ccSPaul Dagnelie ASSERT(object != 0); 877*0fa1b3ccSPaul Dagnelie 878*0fa1b3ccSPaul Dagnelie /* 879*0fa1b3ccSPaul Dagnelie * For resuming to work correctly, we must receive records in order, 880*0fa1b3ccSPaul Dagnelie * sorted by object,offset. This is checked by the callers, but 881*0fa1b3ccSPaul Dagnelie * assert it here for good measure. 882*0fa1b3ccSPaul Dagnelie */ 883*0fa1b3ccSPaul Dagnelie ASSERT3U(object, >=, rwa->os->os_dsl_dataset->ds_resume_object[txgoff]); 884*0fa1b3ccSPaul Dagnelie ASSERT(object != rwa->os->os_dsl_dataset->ds_resume_object[txgoff] || 885*0fa1b3ccSPaul Dagnelie offset >= rwa->os->os_dsl_dataset->ds_resume_offset[txgoff]); 886*0fa1b3ccSPaul Dagnelie ASSERT3U(rwa->bytes_read, >=, 887*0fa1b3ccSPaul Dagnelie rwa->os->os_dsl_dataset->ds_resume_bytes[txgoff]); 888*0fa1b3ccSPaul Dagnelie 889*0fa1b3ccSPaul Dagnelie rwa->os->os_dsl_dataset->ds_resume_object[txgoff] = object; 890*0fa1b3ccSPaul Dagnelie rwa->os->os_dsl_dataset->ds_resume_offset[txgoff] = offset; 891*0fa1b3ccSPaul Dagnelie rwa->os->os_dsl_dataset->ds_resume_bytes[txgoff] = rwa->bytes_read; 892*0fa1b3ccSPaul Dagnelie } 893*0fa1b3ccSPaul Dagnelie 894*0fa1b3ccSPaul Dagnelie static int 895*0fa1b3ccSPaul Dagnelie receive_object(struct receive_writer_arg *rwa, struct drr_object *drro, 896*0fa1b3ccSPaul Dagnelie void *data) 897*0fa1b3ccSPaul Dagnelie { 898*0fa1b3ccSPaul Dagnelie dmu_object_info_t doi; 899*0fa1b3ccSPaul Dagnelie dmu_tx_t *tx; 900*0fa1b3ccSPaul Dagnelie uint64_t object; 901*0fa1b3ccSPaul Dagnelie int err; 902*0fa1b3ccSPaul Dagnelie uint8_t dn_slots = drro->drr_dn_slots != 0 ? 903*0fa1b3ccSPaul Dagnelie drro->drr_dn_slots : DNODE_MIN_SLOTS; 904*0fa1b3ccSPaul Dagnelie 905*0fa1b3ccSPaul Dagnelie if (drro->drr_type == DMU_OT_NONE || 906*0fa1b3ccSPaul Dagnelie !DMU_OT_IS_VALID(drro->drr_type) || 907*0fa1b3ccSPaul Dagnelie !DMU_OT_IS_VALID(drro->drr_bonustype) || 908*0fa1b3ccSPaul Dagnelie drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS || 909*0fa1b3ccSPaul Dagnelie drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 910*0fa1b3ccSPaul Dagnelie P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 911*0fa1b3ccSPaul Dagnelie drro->drr_blksz < SPA_MINBLOCKSIZE || 912*0fa1b3ccSPaul Dagnelie drro->drr_blksz > spa_maxblocksize(dmu_objset_spa(rwa->os)) || 913*0fa1b3ccSPaul Dagnelie drro->drr_bonuslen > 914*0fa1b3ccSPaul Dagnelie DN_BONUS_SIZE(spa_maxdnodesize(dmu_objset_spa(rwa->os))) || 915*0fa1b3ccSPaul Dagnelie dn_slots > 916*0fa1b3ccSPaul Dagnelie (spa_maxdnodesize(dmu_objset_spa(rwa->os)) >> DNODE_SHIFT)) { 917*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 918*0fa1b3ccSPaul Dagnelie } 919*0fa1b3ccSPaul Dagnelie 920*0fa1b3ccSPaul Dagnelie err = dmu_object_info(rwa->os, drro->drr_object, &doi); 921*0fa1b3ccSPaul Dagnelie 922*0fa1b3ccSPaul Dagnelie if (err != 0 && err != ENOENT && err != EEXIST) 923*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 924*0fa1b3ccSPaul Dagnelie 925*0fa1b3ccSPaul Dagnelie if (drro->drr_object > rwa->max_object) 926*0fa1b3ccSPaul Dagnelie rwa->max_object = drro->drr_object; 927*0fa1b3ccSPaul Dagnelie 928*0fa1b3ccSPaul Dagnelie /* 929*0fa1b3ccSPaul Dagnelie * If we are losing blkptrs or changing the block size this must 930*0fa1b3ccSPaul Dagnelie * be a new file instance. We must clear out the previous file 931*0fa1b3ccSPaul Dagnelie * contents before we can change this type of metadata in the dnode. 932*0fa1b3ccSPaul Dagnelie */ 933*0fa1b3ccSPaul Dagnelie if (err == 0) { 934*0fa1b3ccSPaul Dagnelie int nblkptr; 935*0fa1b3ccSPaul Dagnelie 936*0fa1b3ccSPaul Dagnelie object = drro->drr_object; 937*0fa1b3ccSPaul Dagnelie 938*0fa1b3ccSPaul Dagnelie nblkptr = deduce_nblkptr(drro->drr_bonustype, 939*0fa1b3ccSPaul Dagnelie drro->drr_bonuslen); 940*0fa1b3ccSPaul Dagnelie 941*0fa1b3ccSPaul Dagnelie if (drro->drr_blksz != doi.doi_data_block_size || 942*0fa1b3ccSPaul Dagnelie nblkptr < doi.doi_nblkptr || 943*0fa1b3ccSPaul Dagnelie dn_slots != doi.doi_dnodesize >> DNODE_SHIFT) { 944*0fa1b3ccSPaul Dagnelie err = dmu_free_long_range(rwa->os, drro->drr_object, 945*0fa1b3ccSPaul Dagnelie 0, DMU_OBJECT_END); 946*0fa1b3ccSPaul Dagnelie if (err != 0) 947*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 948*0fa1b3ccSPaul Dagnelie } 949*0fa1b3ccSPaul Dagnelie } else if (err == EEXIST) { 950*0fa1b3ccSPaul Dagnelie /* 951*0fa1b3ccSPaul Dagnelie * The object requested is currently an interior slot of a 952*0fa1b3ccSPaul Dagnelie * multi-slot dnode. This will be resolved when the next txg 953*0fa1b3ccSPaul Dagnelie * is synced out, since the send stream will have told us 954*0fa1b3ccSPaul Dagnelie * to free this slot when we freed the associated dnode 955*0fa1b3ccSPaul Dagnelie * earlier in the stream. 956*0fa1b3ccSPaul Dagnelie */ 957*0fa1b3ccSPaul Dagnelie txg_wait_synced(dmu_objset_pool(rwa->os), 0); 958*0fa1b3ccSPaul Dagnelie object = drro->drr_object; 959*0fa1b3ccSPaul Dagnelie } else { 960*0fa1b3ccSPaul Dagnelie /* object is free and we are about to allocate a new one */ 961*0fa1b3ccSPaul Dagnelie object = DMU_NEW_OBJECT; 962*0fa1b3ccSPaul Dagnelie } 963*0fa1b3ccSPaul Dagnelie 964*0fa1b3ccSPaul Dagnelie /* 965*0fa1b3ccSPaul Dagnelie * If this is a multi-slot dnode there is a chance that this 966*0fa1b3ccSPaul Dagnelie * object will expand into a slot that is already used by 967*0fa1b3ccSPaul Dagnelie * another object from the previous snapshot. We must free 968*0fa1b3ccSPaul Dagnelie * these objects before we attempt to allocate the new dnode. 969*0fa1b3ccSPaul Dagnelie */ 970*0fa1b3ccSPaul Dagnelie if (dn_slots > 1) { 971*0fa1b3ccSPaul Dagnelie boolean_t need_sync = B_FALSE; 972*0fa1b3ccSPaul Dagnelie 973*0fa1b3ccSPaul Dagnelie for (uint64_t slot = drro->drr_object + 1; 974*0fa1b3ccSPaul Dagnelie slot < drro->drr_object + dn_slots; 975*0fa1b3ccSPaul Dagnelie slot++) { 976*0fa1b3ccSPaul Dagnelie dmu_object_info_t slot_doi; 977*0fa1b3ccSPaul Dagnelie 978*0fa1b3ccSPaul Dagnelie err = dmu_object_info(rwa->os, slot, &slot_doi); 979*0fa1b3ccSPaul Dagnelie if (err == ENOENT || err == EEXIST) 980*0fa1b3ccSPaul Dagnelie continue; 981*0fa1b3ccSPaul Dagnelie else if (err != 0) 982*0fa1b3ccSPaul Dagnelie return (err); 983*0fa1b3ccSPaul Dagnelie 984*0fa1b3ccSPaul Dagnelie err = dmu_free_long_object(rwa->os, slot); 985*0fa1b3ccSPaul Dagnelie 986*0fa1b3ccSPaul Dagnelie if (err != 0) 987*0fa1b3ccSPaul Dagnelie return (err); 988*0fa1b3ccSPaul Dagnelie 989*0fa1b3ccSPaul Dagnelie need_sync = B_TRUE; 990*0fa1b3ccSPaul Dagnelie } 991*0fa1b3ccSPaul Dagnelie 992*0fa1b3ccSPaul Dagnelie if (need_sync) 993*0fa1b3ccSPaul Dagnelie txg_wait_synced(dmu_objset_pool(rwa->os), 0); 994*0fa1b3ccSPaul Dagnelie } 995*0fa1b3ccSPaul Dagnelie 996*0fa1b3ccSPaul Dagnelie tx = dmu_tx_create(rwa->os); 997*0fa1b3ccSPaul Dagnelie dmu_tx_hold_bonus(tx, object); 998*0fa1b3ccSPaul Dagnelie err = dmu_tx_assign(tx, TXG_WAIT); 999*0fa1b3ccSPaul Dagnelie if (err != 0) { 1000*0fa1b3ccSPaul Dagnelie dmu_tx_abort(tx); 1001*0fa1b3ccSPaul Dagnelie return (err); 1002*0fa1b3ccSPaul Dagnelie } 1003*0fa1b3ccSPaul Dagnelie 1004*0fa1b3ccSPaul Dagnelie if (object == DMU_NEW_OBJECT) { 1005*0fa1b3ccSPaul Dagnelie /* currently free, want to be allocated */ 1006*0fa1b3ccSPaul Dagnelie err = dmu_object_claim_dnsize(rwa->os, drro->drr_object, 1007*0fa1b3ccSPaul Dagnelie drro->drr_type, drro->drr_blksz, 1008*0fa1b3ccSPaul Dagnelie drro->drr_bonustype, drro->drr_bonuslen, 1009*0fa1b3ccSPaul Dagnelie dn_slots << DNODE_SHIFT, tx); 1010*0fa1b3ccSPaul Dagnelie } else if (drro->drr_type != doi.doi_type || 1011*0fa1b3ccSPaul Dagnelie drro->drr_blksz != doi.doi_data_block_size || 1012*0fa1b3ccSPaul Dagnelie drro->drr_bonustype != doi.doi_bonus_type || 1013*0fa1b3ccSPaul Dagnelie drro->drr_bonuslen != doi.doi_bonus_size || 1014*0fa1b3ccSPaul Dagnelie drro->drr_dn_slots != (doi.doi_dnodesize >> DNODE_SHIFT)) { 1015*0fa1b3ccSPaul Dagnelie /* currently allocated, but with different properties */ 1016*0fa1b3ccSPaul Dagnelie err = dmu_object_reclaim_dnsize(rwa->os, drro->drr_object, 1017*0fa1b3ccSPaul Dagnelie drro->drr_type, drro->drr_blksz, 1018*0fa1b3ccSPaul Dagnelie drro->drr_bonustype, drro->drr_bonuslen, 1019*0fa1b3ccSPaul Dagnelie drro->drr_dn_slots << DNODE_SHIFT, tx); 1020*0fa1b3ccSPaul Dagnelie } 1021*0fa1b3ccSPaul Dagnelie if (err != 0) { 1022*0fa1b3ccSPaul Dagnelie dmu_tx_commit(tx); 1023*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1024*0fa1b3ccSPaul Dagnelie } 1025*0fa1b3ccSPaul Dagnelie 1026*0fa1b3ccSPaul Dagnelie dmu_object_set_checksum(rwa->os, drro->drr_object, 1027*0fa1b3ccSPaul Dagnelie drro->drr_checksumtype, tx); 1028*0fa1b3ccSPaul Dagnelie dmu_object_set_compress(rwa->os, drro->drr_object, 1029*0fa1b3ccSPaul Dagnelie drro->drr_compress, tx); 1030*0fa1b3ccSPaul Dagnelie 1031*0fa1b3ccSPaul Dagnelie if (data != NULL) { 1032*0fa1b3ccSPaul Dagnelie dmu_buf_t *db; 1033*0fa1b3ccSPaul Dagnelie 1034*0fa1b3ccSPaul Dagnelie VERIFY0(dmu_bonus_hold(rwa->os, drro->drr_object, FTAG, &db)); 1035*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(db, tx); 1036*0fa1b3ccSPaul Dagnelie 1037*0fa1b3ccSPaul Dagnelie ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 1038*0fa1b3ccSPaul Dagnelie bcopy(data, db->db_data, drro->drr_bonuslen); 1039*0fa1b3ccSPaul Dagnelie if (rwa->byteswap) { 1040*0fa1b3ccSPaul Dagnelie dmu_object_byteswap_t byteswap = 1041*0fa1b3ccSPaul Dagnelie DMU_OT_BYTESWAP(drro->drr_bonustype); 1042*0fa1b3ccSPaul Dagnelie dmu_ot_byteswap[byteswap].ob_func(db->db_data, 1043*0fa1b3ccSPaul Dagnelie drro->drr_bonuslen); 1044*0fa1b3ccSPaul Dagnelie } 1045*0fa1b3ccSPaul Dagnelie dmu_buf_rele(db, FTAG); 1046*0fa1b3ccSPaul Dagnelie } 1047*0fa1b3ccSPaul Dagnelie dmu_tx_commit(tx); 1048*0fa1b3ccSPaul Dagnelie 1049*0fa1b3ccSPaul Dagnelie return (0); 1050*0fa1b3ccSPaul Dagnelie } 1051*0fa1b3ccSPaul Dagnelie 1052*0fa1b3ccSPaul Dagnelie /* ARGSUSED */ 1053*0fa1b3ccSPaul Dagnelie static int 1054*0fa1b3ccSPaul Dagnelie receive_freeobjects(struct receive_writer_arg *rwa, 1055*0fa1b3ccSPaul Dagnelie struct drr_freeobjects *drrfo) 1056*0fa1b3ccSPaul Dagnelie { 1057*0fa1b3ccSPaul Dagnelie uint64_t obj; 1058*0fa1b3ccSPaul Dagnelie int next_err = 0; 1059*0fa1b3ccSPaul Dagnelie 1060*0fa1b3ccSPaul Dagnelie if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 1061*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1062*0fa1b3ccSPaul Dagnelie 1063*0fa1b3ccSPaul Dagnelie for (obj = drrfo->drr_firstobj == 0 ? 1 : drrfo->drr_firstobj; 1064*0fa1b3ccSPaul Dagnelie obj < drrfo->drr_firstobj + drrfo->drr_numobjs && next_err == 0; 1065*0fa1b3ccSPaul Dagnelie next_err = dmu_object_next(rwa->os, &obj, FALSE, 0)) { 1066*0fa1b3ccSPaul Dagnelie int err; 1067*0fa1b3ccSPaul Dagnelie 1068*0fa1b3ccSPaul Dagnelie err = dmu_object_info(rwa->os, obj, NULL); 1069*0fa1b3ccSPaul Dagnelie if (err == ENOENT) 1070*0fa1b3ccSPaul Dagnelie continue; 1071*0fa1b3ccSPaul Dagnelie else if (err != 0) 1072*0fa1b3ccSPaul Dagnelie return (err); 1073*0fa1b3ccSPaul Dagnelie 1074*0fa1b3ccSPaul Dagnelie err = dmu_free_long_object(rwa->os, obj); 1075*0fa1b3ccSPaul Dagnelie if (err != 0) 1076*0fa1b3ccSPaul Dagnelie return (err); 1077*0fa1b3ccSPaul Dagnelie 1078*0fa1b3ccSPaul Dagnelie if (obj > rwa->max_object) 1079*0fa1b3ccSPaul Dagnelie rwa->max_object = obj; 1080*0fa1b3ccSPaul Dagnelie } 1081*0fa1b3ccSPaul Dagnelie if (next_err != ESRCH) 1082*0fa1b3ccSPaul Dagnelie return (next_err); 1083*0fa1b3ccSPaul Dagnelie return (0); 1084*0fa1b3ccSPaul Dagnelie } 1085*0fa1b3ccSPaul Dagnelie 1086*0fa1b3ccSPaul Dagnelie static int 1087*0fa1b3ccSPaul Dagnelie receive_write(struct receive_writer_arg *rwa, struct drr_write *drrw, 1088*0fa1b3ccSPaul Dagnelie arc_buf_t *abuf) 1089*0fa1b3ccSPaul Dagnelie { 1090*0fa1b3ccSPaul Dagnelie dmu_tx_t *tx; 1091*0fa1b3ccSPaul Dagnelie int err; 1092*0fa1b3ccSPaul Dagnelie 1093*0fa1b3ccSPaul Dagnelie if (drrw->drr_offset + drrw->drr_logical_size < drrw->drr_offset || 1094*0fa1b3ccSPaul Dagnelie !DMU_OT_IS_VALID(drrw->drr_type)) 1095*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1096*0fa1b3ccSPaul Dagnelie 1097*0fa1b3ccSPaul Dagnelie /* 1098*0fa1b3ccSPaul Dagnelie * For resuming to work, records must be in increasing order 1099*0fa1b3ccSPaul Dagnelie * by (object, offset). 1100*0fa1b3ccSPaul Dagnelie */ 1101*0fa1b3ccSPaul Dagnelie if (drrw->drr_object < rwa->last_object || 1102*0fa1b3ccSPaul Dagnelie (drrw->drr_object == rwa->last_object && 1103*0fa1b3ccSPaul Dagnelie drrw->drr_offset < rwa->last_offset)) { 1104*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1105*0fa1b3ccSPaul Dagnelie } 1106*0fa1b3ccSPaul Dagnelie rwa->last_object = drrw->drr_object; 1107*0fa1b3ccSPaul Dagnelie rwa->last_offset = drrw->drr_offset; 1108*0fa1b3ccSPaul Dagnelie 1109*0fa1b3ccSPaul Dagnelie if (rwa->last_object > rwa->max_object) 1110*0fa1b3ccSPaul Dagnelie rwa->max_object = rwa->last_object; 1111*0fa1b3ccSPaul Dagnelie 1112*0fa1b3ccSPaul Dagnelie if (dmu_object_info(rwa->os, drrw->drr_object, NULL) != 0) 1113*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1114*0fa1b3ccSPaul Dagnelie 1115*0fa1b3ccSPaul Dagnelie tx = dmu_tx_create(rwa->os); 1116*0fa1b3ccSPaul Dagnelie 1117*0fa1b3ccSPaul Dagnelie dmu_tx_hold_write(tx, drrw->drr_object, 1118*0fa1b3ccSPaul Dagnelie drrw->drr_offset, drrw->drr_logical_size); 1119*0fa1b3ccSPaul Dagnelie err = dmu_tx_assign(tx, TXG_WAIT); 1120*0fa1b3ccSPaul Dagnelie if (err != 0) { 1121*0fa1b3ccSPaul Dagnelie dmu_tx_abort(tx); 1122*0fa1b3ccSPaul Dagnelie return (err); 1123*0fa1b3ccSPaul Dagnelie } 1124*0fa1b3ccSPaul Dagnelie if (rwa->byteswap) { 1125*0fa1b3ccSPaul Dagnelie dmu_object_byteswap_t byteswap = 1126*0fa1b3ccSPaul Dagnelie DMU_OT_BYTESWAP(drrw->drr_type); 1127*0fa1b3ccSPaul Dagnelie dmu_ot_byteswap[byteswap].ob_func(abuf->b_data, 1128*0fa1b3ccSPaul Dagnelie DRR_WRITE_PAYLOAD_SIZE(drrw)); 1129*0fa1b3ccSPaul Dagnelie } 1130*0fa1b3ccSPaul Dagnelie 1131*0fa1b3ccSPaul Dagnelie /* use the bonus buf to look up the dnode in dmu_assign_arcbuf */ 1132*0fa1b3ccSPaul Dagnelie dmu_buf_t *bonus; 1133*0fa1b3ccSPaul Dagnelie if (dmu_bonus_hold(rwa->os, drrw->drr_object, FTAG, &bonus) != 0) 1134*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1135*0fa1b3ccSPaul Dagnelie dmu_assign_arcbuf(bonus, drrw->drr_offset, abuf, tx); 1136*0fa1b3ccSPaul Dagnelie 1137*0fa1b3ccSPaul Dagnelie /* 1138*0fa1b3ccSPaul Dagnelie * Note: If the receive fails, we want the resume stream to start 1139*0fa1b3ccSPaul Dagnelie * with the same record that we last successfully received (as opposed 1140*0fa1b3ccSPaul Dagnelie * to the next record), so that we can verify that we are 1141*0fa1b3ccSPaul Dagnelie * resuming from the correct location. 1142*0fa1b3ccSPaul Dagnelie */ 1143*0fa1b3ccSPaul Dagnelie save_resume_state(rwa, drrw->drr_object, drrw->drr_offset, tx); 1144*0fa1b3ccSPaul Dagnelie dmu_tx_commit(tx); 1145*0fa1b3ccSPaul Dagnelie dmu_buf_rele(bonus, FTAG); 1146*0fa1b3ccSPaul Dagnelie 1147*0fa1b3ccSPaul Dagnelie return (0); 1148*0fa1b3ccSPaul Dagnelie } 1149*0fa1b3ccSPaul Dagnelie 1150*0fa1b3ccSPaul Dagnelie /* 1151*0fa1b3ccSPaul Dagnelie * Handle a DRR_WRITE_BYREF record. This record is used in dedup'ed 1152*0fa1b3ccSPaul Dagnelie * streams to refer to a copy of the data that is already on the 1153*0fa1b3ccSPaul Dagnelie * system because it came in earlier in the stream. This function 1154*0fa1b3ccSPaul Dagnelie * finds the earlier copy of the data, and uses that copy instead of 1155*0fa1b3ccSPaul Dagnelie * data from the stream to fulfill this write. 1156*0fa1b3ccSPaul Dagnelie */ 1157*0fa1b3ccSPaul Dagnelie static int 1158*0fa1b3ccSPaul Dagnelie receive_write_byref(struct receive_writer_arg *rwa, 1159*0fa1b3ccSPaul Dagnelie struct drr_write_byref *drrwbr) 1160*0fa1b3ccSPaul Dagnelie { 1161*0fa1b3ccSPaul Dagnelie dmu_tx_t *tx; 1162*0fa1b3ccSPaul Dagnelie int err; 1163*0fa1b3ccSPaul Dagnelie guid_map_entry_t gmesrch; 1164*0fa1b3ccSPaul Dagnelie guid_map_entry_t *gmep; 1165*0fa1b3ccSPaul Dagnelie avl_index_t where; 1166*0fa1b3ccSPaul Dagnelie objset_t *ref_os = NULL; 1167*0fa1b3ccSPaul Dagnelie dmu_buf_t *dbp; 1168*0fa1b3ccSPaul Dagnelie 1169*0fa1b3ccSPaul Dagnelie if (drrwbr->drr_offset + drrwbr->drr_length < drrwbr->drr_offset) 1170*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1171*0fa1b3ccSPaul Dagnelie 1172*0fa1b3ccSPaul Dagnelie /* 1173*0fa1b3ccSPaul Dagnelie * If the GUID of the referenced dataset is different from the 1174*0fa1b3ccSPaul Dagnelie * GUID of the target dataset, find the referenced dataset. 1175*0fa1b3ccSPaul Dagnelie */ 1176*0fa1b3ccSPaul Dagnelie if (drrwbr->drr_toguid != drrwbr->drr_refguid) { 1177*0fa1b3ccSPaul Dagnelie gmesrch.guid = drrwbr->drr_refguid; 1178*0fa1b3ccSPaul Dagnelie if ((gmep = avl_find(rwa->guid_to_ds_map, &gmesrch, 1179*0fa1b3ccSPaul Dagnelie &where)) == NULL) { 1180*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1181*0fa1b3ccSPaul Dagnelie } 1182*0fa1b3ccSPaul Dagnelie if (dmu_objset_from_ds(gmep->gme_ds, &ref_os)) 1183*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1184*0fa1b3ccSPaul Dagnelie } else { 1185*0fa1b3ccSPaul Dagnelie ref_os = rwa->os; 1186*0fa1b3ccSPaul Dagnelie } 1187*0fa1b3ccSPaul Dagnelie 1188*0fa1b3ccSPaul Dagnelie if (drrwbr->drr_object > rwa->max_object) 1189*0fa1b3ccSPaul Dagnelie rwa->max_object = drrwbr->drr_object; 1190*0fa1b3ccSPaul Dagnelie 1191*0fa1b3ccSPaul Dagnelie err = dmu_buf_hold(ref_os, drrwbr->drr_refobject, 1192*0fa1b3ccSPaul Dagnelie drrwbr->drr_refoffset, FTAG, &dbp, DMU_READ_PREFETCH); 1193*0fa1b3ccSPaul Dagnelie if (err != 0) 1194*0fa1b3ccSPaul Dagnelie return (err); 1195*0fa1b3ccSPaul Dagnelie 1196*0fa1b3ccSPaul Dagnelie tx = dmu_tx_create(rwa->os); 1197*0fa1b3ccSPaul Dagnelie 1198*0fa1b3ccSPaul Dagnelie dmu_tx_hold_write(tx, drrwbr->drr_object, 1199*0fa1b3ccSPaul Dagnelie drrwbr->drr_offset, drrwbr->drr_length); 1200*0fa1b3ccSPaul Dagnelie err = dmu_tx_assign(tx, TXG_WAIT); 1201*0fa1b3ccSPaul Dagnelie if (err != 0) { 1202*0fa1b3ccSPaul Dagnelie dmu_tx_abort(tx); 1203*0fa1b3ccSPaul Dagnelie return (err); 1204*0fa1b3ccSPaul Dagnelie } 1205*0fa1b3ccSPaul Dagnelie dmu_write(rwa->os, drrwbr->drr_object, 1206*0fa1b3ccSPaul Dagnelie drrwbr->drr_offset, drrwbr->drr_length, dbp->db_data, tx); 1207*0fa1b3ccSPaul Dagnelie dmu_buf_rele(dbp, FTAG); 1208*0fa1b3ccSPaul Dagnelie 1209*0fa1b3ccSPaul Dagnelie /* See comment in restore_write. */ 1210*0fa1b3ccSPaul Dagnelie save_resume_state(rwa, drrwbr->drr_object, drrwbr->drr_offset, tx); 1211*0fa1b3ccSPaul Dagnelie dmu_tx_commit(tx); 1212*0fa1b3ccSPaul Dagnelie return (0); 1213*0fa1b3ccSPaul Dagnelie } 1214*0fa1b3ccSPaul Dagnelie 1215*0fa1b3ccSPaul Dagnelie static int 1216*0fa1b3ccSPaul Dagnelie receive_write_embedded(struct receive_writer_arg *rwa, 1217*0fa1b3ccSPaul Dagnelie struct drr_write_embedded *drrwe, void *data) 1218*0fa1b3ccSPaul Dagnelie { 1219*0fa1b3ccSPaul Dagnelie dmu_tx_t *tx; 1220*0fa1b3ccSPaul Dagnelie int err; 1221*0fa1b3ccSPaul Dagnelie 1222*0fa1b3ccSPaul Dagnelie if (drrwe->drr_offset + drrwe->drr_length < drrwe->drr_offset) 1223*0fa1b3ccSPaul Dagnelie return (EINVAL); 1224*0fa1b3ccSPaul Dagnelie 1225*0fa1b3ccSPaul Dagnelie if (drrwe->drr_psize > BPE_PAYLOAD_SIZE) 1226*0fa1b3ccSPaul Dagnelie return (EINVAL); 1227*0fa1b3ccSPaul Dagnelie 1228*0fa1b3ccSPaul Dagnelie if (drrwe->drr_etype >= NUM_BP_EMBEDDED_TYPES) 1229*0fa1b3ccSPaul Dagnelie return (EINVAL); 1230*0fa1b3ccSPaul Dagnelie if (drrwe->drr_compression >= ZIO_COMPRESS_FUNCTIONS) 1231*0fa1b3ccSPaul Dagnelie return (EINVAL); 1232*0fa1b3ccSPaul Dagnelie 1233*0fa1b3ccSPaul Dagnelie if (drrwe->drr_object > rwa->max_object) 1234*0fa1b3ccSPaul Dagnelie rwa->max_object = drrwe->drr_object; 1235*0fa1b3ccSPaul Dagnelie 1236*0fa1b3ccSPaul Dagnelie tx = dmu_tx_create(rwa->os); 1237*0fa1b3ccSPaul Dagnelie 1238*0fa1b3ccSPaul Dagnelie dmu_tx_hold_write(tx, drrwe->drr_object, 1239*0fa1b3ccSPaul Dagnelie drrwe->drr_offset, drrwe->drr_length); 1240*0fa1b3ccSPaul Dagnelie err = dmu_tx_assign(tx, TXG_WAIT); 1241*0fa1b3ccSPaul Dagnelie if (err != 0) { 1242*0fa1b3ccSPaul Dagnelie dmu_tx_abort(tx); 1243*0fa1b3ccSPaul Dagnelie return (err); 1244*0fa1b3ccSPaul Dagnelie } 1245*0fa1b3ccSPaul Dagnelie 1246*0fa1b3ccSPaul Dagnelie dmu_write_embedded(rwa->os, drrwe->drr_object, 1247*0fa1b3ccSPaul Dagnelie drrwe->drr_offset, data, drrwe->drr_etype, 1248*0fa1b3ccSPaul Dagnelie drrwe->drr_compression, drrwe->drr_lsize, drrwe->drr_psize, 1249*0fa1b3ccSPaul Dagnelie rwa->byteswap ^ ZFS_HOST_BYTEORDER, tx); 1250*0fa1b3ccSPaul Dagnelie 1251*0fa1b3ccSPaul Dagnelie /* See comment in restore_write. */ 1252*0fa1b3ccSPaul Dagnelie save_resume_state(rwa, drrwe->drr_object, drrwe->drr_offset, tx); 1253*0fa1b3ccSPaul Dagnelie dmu_tx_commit(tx); 1254*0fa1b3ccSPaul Dagnelie return (0); 1255*0fa1b3ccSPaul Dagnelie } 1256*0fa1b3ccSPaul Dagnelie 1257*0fa1b3ccSPaul Dagnelie static int 1258*0fa1b3ccSPaul Dagnelie receive_spill(struct receive_writer_arg *rwa, struct drr_spill *drrs, 1259*0fa1b3ccSPaul Dagnelie void *data) 1260*0fa1b3ccSPaul Dagnelie { 1261*0fa1b3ccSPaul Dagnelie dmu_tx_t *tx; 1262*0fa1b3ccSPaul Dagnelie dmu_buf_t *db, *db_spill; 1263*0fa1b3ccSPaul Dagnelie int err; 1264*0fa1b3ccSPaul Dagnelie 1265*0fa1b3ccSPaul Dagnelie if (drrs->drr_length < SPA_MINBLOCKSIZE || 1266*0fa1b3ccSPaul Dagnelie drrs->drr_length > spa_maxblocksize(dmu_objset_spa(rwa->os))) 1267*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1268*0fa1b3ccSPaul Dagnelie 1269*0fa1b3ccSPaul Dagnelie if (dmu_object_info(rwa->os, drrs->drr_object, NULL) != 0) 1270*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1271*0fa1b3ccSPaul Dagnelie 1272*0fa1b3ccSPaul Dagnelie if (drrs->drr_object > rwa->max_object) 1273*0fa1b3ccSPaul Dagnelie rwa->max_object = drrs->drr_object; 1274*0fa1b3ccSPaul Dagnelie 1275*0fa1b3ccSPaul Dagnelie VERIFY0(dmu_bonus_hold(rwa->os, drrs->drr_object, FTAG, &db)); 1276*0fa1b3ccSPaul Dagnelie if ((err = dmu_spill_hold_by_bonus(db, FTAG, &db_spill)) != 0) { 1277*0fa1b3ccSPaul Dagnelie dmu_buf_rele(db, FTAG); 1278*0fa1b3ccSPaul Dagnelie return (err); 1279*0fa1b3ccSPaul Dagnelie } 1280*0fa1b3ccSPaul Dagnelie 1281*0fa1b3ccSPaul Dagnelie tx = dmu_tx_create(rwa->os); 1282*0fa1b3ccSPaul Dagnelie 1283*0fa1b3ccSPaul Dagnelie dmu_tx_hold_spill(tx, db->db_object); 1284*0fa1b3ccSPaul Dagnelie 1285*0fa1b3ccSPaul Dagnelie err = dmu_tx_assign(tx, TXG_WAIT); 1286*0fa1b3ccSPaul Dagnelie if (err != 0) { 1287*0fa1b3ccSPaul Dagnelie dmu_buf_rele(db, FTAG); 1288*0fa1b3ccSPaul Dagnelie dmu_buf_rele(db_spill, FTAG); 1289*0fa1b3ccSPaul Dagnelie dmu_tx_abort(tx); 1290*0fa1b3ccSPaul Dagnelie return (err); 1291*0fa1b3ccSPaul Dagnelie } 1292*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(db_spill, tx); 1293*0fa1b3ccSPaul Dagnelie 1294*0fa1b3ccSPaul Dagnelie if (db_spill->db_size < drrs->drr_length) 1295*0fa1b3ccSPaul Dagnelie VERIFY(0 == dbuf_spill_set_blksz(db_spill, 1296*0fa1b3ccSPaul Dagnelie drrs->drr_length, tx)); 1297*0fa1b3ccSPaul Dagnelie bcopy(data, db_spill->db_data, drrs->drr_length); 1298*0fa1b3ccSPaul Dagnelie 1299*0fa1b3ccSPaul Dagnelie dmu_buf_rele(db, FTAG); 1300*0fa1b3ccSPaul Dagnelie dmu_buf_rele(db_spill, FTAG); 1301*0fa1b3ccSPaul Dagnelie 1302*0fa1b3ccSPaul Dagnelie dmu_tx_commit(tx); 1303*0fa1b3ccSPaul Dagnelie return (0); 1304*0fa1b3ccSPaul Dagnelie } 1305*0fa1b3ccSPaul Dagnelie 1306*0fa1b3ccSPaul Dagnelie /* ARGSUSED */ 1307*0fa1b3ccSPaul Dagnelie static int 1308*0fa1b3ccSPaul Dagnelie receive_free(struct receive_writer_arg *rwa, struct drr_free *drrf) 1309*0fa1b3ccSPaul Dagnelie { 1310*0fa1b3ccSPaul Dagnelie int err; 1311*0fa1b3ccSPaul Dagnelie 1312*0fa1b3ccSPaul Dagnelie if (drrf->drr_length != -1ULL && 1313*0fa1b3ccSPaul Dagnelie drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 1314*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1315*0fa1b3ccSPaul Dagnelie 1316*0fa1b3ccSPaul Dagnelie if (dmu_object_info(rwa->os, drrf->drr_object, NULL) != 0) 1317*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1318*0fa1b3ccSPaul Dagnelie 1319*0fa1b3ccSPaul Dagnelie if (drrf->drr_object > rwa->max_object) 1320*0fa1b3ccSPaul Dagnelie rwa->max_object = drrf->drr_object; 1321*0fa1b3ccSPaul Dagnelie 1322*0fa1b3ccSPaul Dagnelie err = dmu_free_long_range(rwa->os, drrf->drr_object, 1323*0fa1b3ccSPaul Dagnelie drrf->drr_offset, drrf->drr_length); 1324*0fa1b3ccSPaul Dagnelie 1325*0fa1b3ccSPaul Dagnelie return (err); 1326*0fa1b3ccSPaul Dagnelie } 1327*0fa1b3ccSPaul Dagnelie 1328*0fa1b3ccSPaul Dagnelie /* used to destroy the drc_ds on error */ 1329*0fa1b3ccSPaul Dagnelie static void 1330*0fa1b3ccSPaul Dagnelie dmu_recv_cleanup_ds(dmu_recv_cookie_t *drc) 1331*0fa1b3ccSPaul Dagnelie { 1332*0fa1b3ccSPaul Dagnelie if (drc->drc_resumable) { 1333*0fa1b3ccSPaul Dagnelie /* wait for our resume state to be written to disk */ 1334*0fa1b3ccSPaul Dagnelie txg_wait_synced(drc->drc_ds->ds_dir->dd_pool, 0); 1335*0fa1b3ccSPaul Dagnelie dsl_dataset_disown(drc->drc_ds, dmu_recv_tag); 1336*0fa1b3ccSPaul Dagnelie } else { 1337*0fa1b3ccSPaul Dagnelie char name[ZFS_MAX_DATASET_NAME_LEN]; 1338*0fa1b3ccSPaul Dagnelie dsl_dataset_name(drc->drc_ds, name); 1339*0fa1b3ccSPaul Dagnelie dsl_dataset_disown(drc->drc_ds, dmu_recv_tag); 1340*0fa1b3ccSPaul Dagnelie (void) dsl_destroy_head(name); 1341*0fa1b3ccSPaul Dagnelie } 1342*0fa1b3ccSPaul Dagnelie } 1343*0fa1b3ccSPaul Dagnelie 1344*0fa1b3ccSPaul Dagnelie static void 1345*0fa1b3ccSPaul Dagnelie receive_cksum(struct receive_arg *ra, int len, void *buf) 1346*0fa1b3ccSPaul Dagnelie { 1347*0fa1b3ccSPaul Dagnelie if (ra->byteswap) { 1348*0fa1b3ccSPaul Dagnelie (void) fletcher_4_incremental_byteswap(buf, len, &ra->cksum); 1349*0fa1b3ccSPaul Dagnelie } else { 1350*0fa1b3ccSPaul Dagnelie (void) fletcher_4_incremental_native(buf, len, &ra->cksum); 1351*0fa1b3ccSPaul Dagnelie } 1352*0fa1b3ccSPaul Dagnelie } 1353*0fa1b3ccSPaul Dagnelie 1354*0fa1b3ccSPaul Dagnelie /* 1355*0fa1b3ccSPaul Dagnelie * Read the payload into a buffer of size len, and update the current record's 1356*0fa1b3ccSPaul Dagnelie * payload field. 1357*0fa1b3ccSPaul Dagnelie * Allocate ra->next_rrd and read the next record's header into 1358*0fa1b3ccSPaul Dagnelie * ra->next_rrd->header. 1359*0fa1b3ccSPaul Dagnelie * Verify checksum of payload and next record. 1360*0fa1b3ccSPaul Dagnelie */ 1361*0fa1b3ccSPaul Dagnelie static int 1362*0fa1b3ccSPaul Dagnelie receive_read_payload_and_next_header(struct receive_arg *ra, int len, void *buf) 1363*0fa1b3ccSPaul Dagnelie { 1364*0fa1b3ccSPaul Dagnelie int err; 1365*0fa1b3ccSPaul Dagnelie 1366*0fa1b3ccSPaul Dagnelie if (len != 0) { 1367*0fa1b3ccSPaul Dagnelie ASSERT3U(len, <=, SPA_MAXBLOCKSIZE); 1368*0fa1b3ccSPaul Dagnelie err = receive_read(ra, len, buf); 1369*0fa1b3ccSPaul Dagnelie if (err != 0) 1370*0fa1b3ccSPaul Dagnelie return (err); 1371*0fa1b3ccSPaul Dagnelie receive_cksum(ra, len, buf); 1372*0fa1b3ccSPaul Dagnelie 1373*0fa1b3ccSPaul Dagnelie /* note: rrd is NULL when reading the begin record's payload */ 1374*0fa1b3ccSPaul Dagnelie if (ra->rrd != NULL) { 1375*0fa1b3ccSPaul Dagnelie ra->rrd->payload = buf; 1376*0fa1b3ccSPaul Dagnelie ra->rrd->payload_size = len; 1377*0fa1b3ccSPaul Dagnelie ra->rrd->bytes_read = ra->bytes_read; 1378*0fa1b3ccSPaul Dagnelie } 1379*0fa1b3ccSPaul Dagnelie } 1380*0fa1b3ccSPaul Dagnelie 1381*0fa1b3ccSPaul Dagnelie ra->prev_cksum = ra->cksum; 1382*0fa1b3ccSPaul Dagnelie 1383*0fa1b3ccSPaul Dagnelie ra->next_rrd = kmem_zalloc(sizeof (*ra->next_rrd), KM_SLEEP); 1384*0fa1b3ccSPaul Dagnelie err = receive_read(ra, sizeof (ra->next_rrd->header), 1385*0fa1b3ccSPaul Dagnelie &ra->next_rrd->header); 1386*0fa1b3ccSPaul Dagnelie ra->next_rrd->bytes_read = ra->bytes_read; 1387*0fa1b3ccSPaul Dagnelie if (err != 0) { 1388*0fa1b3ccSPaul Dagnelie kmem_free(ra->next_rrd, sizeof (*ra->next_rrd)); 1389*0fa1b3ccSPaul Dagnelie ra->next_rrd = NULL; 1390*0fa1b3ccSPaul Dagnelie return (err); 1391*0fa1b3ccSPaul Dagnelie } 1392*0fa1b3ccSPaul Dagnelie if (ra->next_rrd->header.drr_type == DRR_BEGIN) { 1393*0fa1b3ccSPaul Dagnelie kmem_free(ra->next_rrd, sizeof (*ra->next_rrd)); 1394*0fa1b3ccSPaul Dagnelie ra->next_rrd = NULL; 1395*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1396*0fa1b3ccSPaul Dagnelie } 1397*0fa1b3ccSPaul Dagnelie 1398*0fa1b3ccSPaul Dagnelie /* 1399*0fa1b3ccSPaul Dagnelie * Note: checksum is of everything up to but not including the 1400*0fa1b3ccSPaul Dagnelie * checksum itself. 1401*0fa1b3ccSPaul Dagnelie */ 1402*0fa1b3ccSPaul Dagnelie ASSERT3U(offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum), 1403*0fa1b3ccSPaul Dagnelie ==, sizeof (dmu_replay_record_t) - sizeof (zio_cksum_t)); 1404*0fa1b3ccSPaul Dagnelie receive_cksum(ra, 1405*0fa1b3ccSPaul Dagnelie offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum), 1406*0fa1b3ccSPaul Dagnelie &ra->next_rrd->header); 1407*0fa1b3ccSPaul Dagnelie 1408*0fa1b3ccSPaul Dagnelie zio_cksum_t cksum_orig = 1409*0fa1b3ccSPaul Dagnelie ra->next_rrd->header.drr_u.drr_checksum.drr_checksum; 1410*0fa1b3ccSPaul Dagnelie zio_cksum_t *cksump = 1411*0fa1b3ccSPaul Dagnelie &ra->next_rrd->header.drr_u.drr_checksum.drr_checksum; 1412*0fa1b3ccSPaul Dagnelie 1413*0fa1b3ccSPaul Dagnelie if (ra->byteswap) 1414*0fa1b3ccSPaul Dagnelie byteswap_record(&ra->next_rrd->header); 1415*0fa1b3ccSPaul Dagnelie 1416*0fa1b3ccSPaul Dagnelie if ((!ZIO_CHECKSUM_IS_ZERO(cksump)) && 1417*0fa1b3ccSPaul Dagnelie !ZIO_CHECKSUM_EQUAL(ra->cksum, *cksump)) { 1418*0fa1b3ccSPaul Dagnelie kmem_free(ra->next_rrd, sizeof (*ra->next_rrd)); 1419*0fa1b3ccSPaul Dagnelie ra->next_rrd = NULL; 1420*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ECKSUM)); 1421*0fa1b3ccSPaul Dagnelie } 1422*0fa1b3ccSPaul Dagnelie 1423*0fa1b3ccSPaul Dagnelie receive_cksum(ra, sizeof (cksum_orig), &cksum_orig); 1424*0fa1b3ccSPaul Dagnelie 1425*0fa1b3ccSPaul Dagnelie return (0); 1426*0fa1b3ccSPaul Dagnelie } 1427*0fa1b3ccSPaul Dagnelie 1428*0fa1b3ccSPaul Dagnelie static void 1429*0fa1b3ccSPaul Dagnelie objlist_create(struct objlist *list) 1430*0fa1b3ccSPaul Dagnelie { 1431*0fa1b3ccSPaul Dagnelie list_create(&list->list, sizeof (struct receive_objnode), 1432*0fa1b3ccSPaul Dagnelie offsetof(struct receive_objnode, node)); 1433*0fa1b3ccSPaul Dagnelie list->last_lookup = 0; 1434*0fa1b3ccSPaul Dagnelie } 1435*0fa1b3ccSPaul Dagnelie 1436*0fa1b3ccSPaul Dagnelie static void 1437*0fa1b3ccSPaul Dagnelie objlist_destroy(struct objlist *list) 1438*0fa1b3ccSPaul Dagnelie { 1439*0fa1b3ccSPaul Dagnelie for (struct receive_objnode *n = list_remove_head(&list->list); 1440*0fa1b3ccSPaul Dagnelie n != NULL; n = list_remove_head(&list->list)) { 1441*0fa1b3ccSPaul Dagnelie kmem_free(n, sizeof (*n)); 1442*0fa1b3ccSPaul Dagnelie } 1443*0fa1b3ccSPaul Dagnelie list_destroy(&list->list); 1444*0fa1b3ccSPaul Dagnelie } 1445*0fa1b3ccSPaul Dagnelie 1446*0fa1b3ccSPaul Dagnelie /* 1447*0fa1b3ccSPaul Dagnelie * This function looks through the objlist to see if the specified object number 1448*0fa1b3ccSPaul Dagnelie * is contained in the objlist. In the process, it will remove all object 1449*0fa1b3ccSPaul Dagnelie * numbers in the list that are smaller than the specified object number. Thus, 1450*0fa1b3ccSPaul Dagnelie * any lookup of an object number smaller than a previously looked up object 1451*0fa1b3ccSPaul Dagnelie * number will always return false; therefore, all lookups should be done in 1452*0fa1b3ccSPaul Dagnelie * ascending order. 1453*0fa1b3ccSPaul Dagnelie */ 1454*0fa1b3ccSPaul Dagnelie static boolean_t 1455*0fa1b3ccSPaul Dagnelie objlist_exists(struct objlist *list, uint64_t object) 1456*0fa1b3ccSPaul Dagnelie { 1457*0fa1b3ccSPaul Dagnelie struct receive_objnode *node = list_head(&list->list); 1458*0fa1b3ccSPaul Dagnelie ASSERT3U(object, >=, list->last_lookup); 1459*0fa1b3ccSPaul Dagnelie list->last_lookup = object; 1460*0fa1b3ccSPaul Dagnelie while (node != NULL && node->object < object) { 1461*0fa1b3ccSPaul Dagnelie VERIFY3P(node, ==, list_remove_head(&list->list)); 1462*0fa1b3ccSPaul Dagnelie kmem_free(node, sizeof (*node)); 1463*0fa1b3ccSPaul Dagnelie node = list_head(&list->list); 1464*0fa1b3ccSPaul Dagnelie } 1465*0fa1b3ccSPaul Dagnelie return (node != NULL && node->object == object); 1466*0fa1b3ccSPaul Dagnelie } 1467*0fa1b3ccSPaul Dagnelie 1468*0fa1b3ccSPaul Dagnelie /* 1469*0fa1b3ccSPaul Dagnelie * The objlist is a list of object numbers stored in ascending order. However, 1470*0fa1b3ccSPaul Dagnelie * the insertion of new object numbers does not seek out the correct location to 1471*0fa1b3ccSPaul Dagnelie * store a new object number; instead, it appends it to the list for simplicity. 1472*0fa1b3ccSPaul Dagnelie * Thus, any users must take care to only insert new object numbers in ascending 1473*0fa1b3ccSPaul Dagnelie * order. 1474*0fa1b3ccSPaul Dagnelie */ 1475*0fa1b3ccSPaul Dagnelie static void 1476*0fa1b3ccSPaul Dagnelie objlist_insert(struct objlist *list, uint64_t object) 1477*0fa1b3ccSPaul Dagnelie { 1478*0fa1b3ccSPaul Dagnelie struct receive_objnode *node = kmem_zalloc(sizeof (*node), KM_SLEEP); 1479*0fa1b3ccSPaul Dagnelie node->object = object; 1480*0fa1b3ccSPaul Dagnelie #ifdef ZFS_DEBUG 1481*0fa1b3ccSPaul Dagnelie struct receive_objnode *last_object = list_tail(&list->list); 1482*0fa1b3ccSPaul Dagnelie uint64_t last_objnum = (last_object != NULL ? last_object->object : 0); 1483*0fa1b3ccSPaul Dagnelie ASSERT3U(node->object, >, last_objnum); 1484*0fa1b3ccSPaul Dagnelie #endif 1485*0fa1b3ccSPaul Dagnelie list_insert_tail(&list->list, node); 1486*0fa1b3ccSPaul Dagnelie } 1487*0fa1b3ccSPaul Dagnelie 1488*0fa1b3ccSPaul Dagnelie /* 1489*0fa1b3ccSPaul Dagnelie * Issue the prefetch reads for any necessary indirect blocks. 1490*0fa1b3ccSPaul Dagnelie * 1491*0fa1b3ccSPaul Dagnelie * We use the object ignore list to tell us whether or not to issue prefetches 1492*0fa1b3ccSPaul Dagnelie * for a given object. We do this for both correctness (in case the blocksize 1493*0fa1b3ccSPaul Dagnelie * of an object has changed) and performance (if the object doesn't exist, don't 1494*0fa1b3ccSPaul Dagnelie * needlessly try to issue prefetches). We also trim the list as we go through 1495*0fa1b3ccSPaul Dagnelie * the stream to prevent it from growing to an unbounded size. 1496*0fa1b3ccSPaul Dagnelie * 1497*0fa1b3ccSPaul Dagnelie * The object numbers within will always be in sorted order, and any write 1498*0fa1b3ccSPaul Dagnelie * records we see will also be in sorted order, but they're not sorted with 1499*0fa1b3ccSPaul Dagnelie * respect to each other (i.e. we can get several object records before 1500*0fa1b3ccSPaul Dagnelie * receiving each object's write records). As a result, once we've reached a 1501*0fa1b3ccSPaul Dagnelie * given object number, we can safely remove any reference to lower object 1502*0fa1b3ccSPaul Dagnelie * numbers in the ignore list. In practice, we receive up to 32 object records 1503*0fa1b3ccSPaul Dagnelie * before receiving write records, so the list can have up to 32 nodes in it. 1504*0fa1b3ccSPaul Dagnelie */ 1505*0fa1b3ccSPaul Dagnelie /* ARGSUSED */ 1506*0fa1b3ccSPaul Dagnelie static void 1507*0fa1b3ccSPaul Dagnelie receive_read_prefetch(struct receive_arg *ra, 1508*0fa1b3ccSPaul Dagnelie uint64_t object, uint64_t offset, uint64_t length) 1509*0fa1b3ccSPaul Dagnelie { 1510*0fa1b3ccSPaul Dagnelie if (!objlist_exists(&ra->ignore_objlist, object)) { 1511*0fa1b3ccSPaul Dagnelie dmu_prefetch(ra->os, object, 1, offset, length, 1512*0fa1b3ccSPaul Dagnelie ZIO_PRIORITY_SYNC_READ); 1513*0fa1b3ccSPaul Dagnelie } 1514*0fa1b3ccSPaul Dagnelie } 1515*0fa1b3ccSPaul Dagnelie 1516*0fa1b3ccSPaul Dagnelie /* 1517*0fa1b3ccSPaul Dagnelie * Read records off the stream, issuing any necessary prefetches. 1518*0fa1b3ccSPaul Dagnelie */ 1519*0fa1b3ccSPaul Dagnelie static int 1520*0fa1b3ccSPaul Dagnelie receive_read_record(struct receive_arg *ra) 1521*0fa1b3ccSPaul Dagnelie { 1522*0fa1b3ccSPaul Dagnelie int err; 1523*0fa1b3ccSPaul Dagnelie 1524*0fa1b3ccSPaul Dagnelie switch (ra->rrd->header.drr_type) { 1525*0fa1b3ccSPaul Dagnelie case DRR_OBJECT: 1526*0fa1b3ccSPaul Dagnelie { 1527*0fa1b3ccSPaul Dagnelie struct drr_object *drro = &ra->rrd->header.drr_u.drr_object; 1528*0fa1b3ccSPaul Dagnelie uint32_t size = P2ROUNDUP(drro->drr_bonuslen, 8); 1529*0fa1b3ccSPaul Dagnelie void *buf = kmem_zalloc(size, KM_SLEEP); 1530*0fa1b3ccSPaul Dagnelie dmu_object_info_t doi; 1531*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, size, buf); 1532*0fa1b3ccSPaul Dagnelie if (err != 0) { 1533*0fa1b3ccSPaul Dagnelie kmem_free(buf, size); 1534*0fa1b3ccSPaul Dagnelie return (err); 1535*0fa1b3ccSPaul Dagnelie } 1536*0fa1b3ccSPaul Dagnelie err = dmu_object_info(ra->os, drro->drr_object, &doi); 1537*0fa1b3ccSPaul Dagnelie /* 1538*0fa1b3ccSPaul Dagnelie * See receive_read_prefetch for an explanation why we're 1539*0fa1b3ccSPaul Dagnelie * storing this object in the ignore_obj_list. 1540*0fa1b3ccSPaul Dagnelie */ 1541*0fa1b3ccSPaul Dagnelie if (err == ENOENT || 1542*0fa1b3ccSPaul Dagnelie (err == 0 && doi.doi_data_block_size != drro->drr_blksz)) { 1543*0fa1b3ccSPaul Dagnelie objlist_insert(&ra->ignore_objlist, drro->drr_object); 1544*0fa1b3ccSPaul Dagnelie err = 0; 1545*0fa1b3ccSPaul Dagnelie } 1546*0fa1b3ccSPaul Dagnelie return (err); 1547*0fa1b3ccSPaul Dagnelie } 1548*0fa1b3ccSPaul Dagnelie case DRR_FREEOBJECTS: 1549*0fa1b3ccSPaul Dagnelie { 1550*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, 0, NULL); 1551*0fa1b3ccSPaul Dagnelie return (err); 1552*0fa1b3ccSPaul Dagnelie } 1553*0fa1b3ccSPaul Dagnelie case DRR_WRITE: 1554*0fa1b3ccSPaul Dagnelie { 1555*0fa1b3ccSPaul Dagnelie struct drr_write *drrw = &ra->rrd->header.drr_u.drr_write; 1556*0fa1b3ccSPaul Dagnelie arc_buf_t *abuf; 1557*0fa1b3ccSPaul Dagnelie boolean_t is_meta = DMU_OT_IS_METADATA(drrw->drr_type); 1558*0fa1b3ccSPaul Dagnelie if (DRR_WRITE_COMPRESSED(drrw)) { 1559*0fa1b3ccSPaul Dagnelie ASSERT3U(drrw->drr_compressed_size, >, 0); 1560*0fa1b3ccSPaul Dagnelie ASSERT3U(drrw->drr_logical_size, >=, 1561*0fa1b3ccSPaul Dagnelie drrw->drr_compressed_size); 1562*0fa1b3ccSPaul Dagnelie ASSERT(!is_meta); 1563*0fa1b3ccSPaul Dagnelie abuf = arc_loan_compressed_buf( 1564*0fa1b3ccSPaul Dagnelie dmu_objset_spa(ra->os), 1565*0fa1b3ccSPaul Dagnelie drrw->drr_compressed_size, drrw->drr_logical_size, 1566*0fa1b3ccSPaul Dagnelie drrw->drr_compressiontype); 1567*0fa1b3ccSPaul Dagnelie } else { 1568*0fa1b3ccSPaul Dagnelie abuf = arc_loan_buf(dmu_objset_spa(ra->os), 1569*0fa1b3ccSPaul Dagnelie is_meta, drrw->drr_logical_size); 1570*0fa1b3ccSPaul Dagnelie } 1571*0fa1b3ccSPaul Dagnelie 1572*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, 1573*0fa1b3ccSPaul Dagnelie DRR_WRITE_PAYLOAD_SIZE(drrw), abuf->b_data); 1574*0fa1b3ccSPaul Dagnelie if (err != 0) { 1575*0fa1b3ccSPaul Dagnelie dmu_return_arcbuf(abuf); 1576*0fa1b3ccSPaul Dagnelie return (err); 1577*0fa1b3ccSPaul Dagnelie } 1578*0fa1b3ccSPaul Dagnelie ra->rrd->write_buf = abuf; 1579*0fa1b3ccSPaul Dagnelie receive_read_prefetch(ra, drrw->drr_object, drrw->drr_offset, 1580*0fa1b3ccSPaul Dagnelie drrw->drr_logical_size); 1581*0fa1b3ccSPaul Dagnelie return (err); 1582*0fa1b3ccSPaul Dagnelie } 1583*0fa1b3ccSPaul Dagnelie case DRR_WRITE_BYREF: 1584*0fa1b3ccSPaul Dagnelie { 1585*0fa1b3ccSPaul Dagnelie struct drr_write_byref *drrwb = 1586*0fa1b3ccSPaul Dagnelie &ra->rrd->header.drr_u.drr_write_byref; 1587*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, 0, NULL); 1588*0fa1b3ccSPaul Dagnelie receive_read_prefetch(ra, drrwb->drr_object, drrwb->drr_offset, 1589*0fa1b3ccSPaul Dagnelie drrwb->drr_length); 1590*0fa1b3ccSPaul Dagnelie return (err); 1591*0fa1b3ccSPaul Dagnelie } 1592*0fa1b3ccSPaul Dagnelie case DRR_WRITE_EMBEDDED: 1593*0fa1b3ccSPaul Dagnelie { 1594*0fa1b3ccSPaul Dagnelie struct drr_write_embedded *drrwe = 1595*0fa1b3ccSPaul Dagnelie &ra->rrd->header.drr_u.drr_write_embedded; 1596*0fa1b3ccSPaul Dagnelie uint32_t size = P2ROUNDUP(drrwe->drr_psize, 8); 1597*0fa1b3ccSPaul Dagnelie void *buf = kmem_zalloc(size, KM_SLEEP); 1598*0fa1b3ccSPaul Dagnelie 1599*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, size, buf); 1600*0fa1b3ccSPaul Dagnelie if (err != 0) { 1601*0fa1b3ccSPaul Dagnelie kmem_free(buf, size); 1602*0fa1b3ccSPaul Dagnelie return (err); 1603*0fa1b3ccSPaul Dagnelie } 1604*0fa1b3ccSPaul Dagnelie 1605*0fa1b3ccSPaul Dagnelie receive_read_prefetch(ra, drrwe->drr_object, drrwe->drr_offset, 1606*0fa1b3ccSPaul Dagnelie drrwe->drr_length); 1607*0fa1b3ccSPaul Dagnelie return (err); 1608*0fa1b3ccSPaul Dagnelie } 1609*0fa1b3ccSPaul Dagnelie case DRR_FREE: 1610*0fa1b3ccSPaul Dagnelie { 1611*0fa1b3ccSPaul Dagnelie /* 1612*0fa1b3ccSPaul Dagnelie * It might be beneficial to prefetch indirect blocks here, but 1613*0fa1b3ccSPaul Dagnelie * we don't really have the data to decide for sure. 1614*0fa1b3ccSPaul Dagnelie */ 1615*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, 0, NULL); 1616*0fa1b3ccSPaul Dagnelie return (err); 1617*0fa1b3ccSPaul Dagnelie } 1618*0fa1b3ccSPaul Dagnelie case DRR_END: 1619*0fa1b3ccSPaul Dagnelie { 1620*0fa1b3ccSPaul Dagnelie struct drr_end *drre = &ra->rrd->header.drr_u.drr_end; 1621*0fa1b3ccSPaul Dagnelie if (!ZIO_CHECKSUM_EQUAL(ra->prev_cksum, drre->drr_checksum)) 1622*0fa1b3ccSPaul Dagnelie return (SET_ERROR(ECKSUM)); 1623*0fa1b3ccSPaul Dagnelie return (0); 1624*0fa1b3ccSPaul Dagnelie } 1625*0fa1b3ccSPaul Dagnelie case DRR_SPILL: 1626*0fa1b3ccSPaul Dagnelie { 1627*0fa1b3ccSPaul Dagnelie struct drr_spill *drrs = &ra->rrd->header.drr_u.drr_spill; 1628*0fa1b3ccSPaul Dagnelie void *buf = kmem_zalloc(drrs->drr_length, KM_SLEEP); 1629*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(ra, drrs->drr_length, 1630*0fa1b3ccSPaul Dagnelie buf); 1631*0fa1b3ccSPaul Dagnelie if (err != 0) 1632*0fa1b3ccSPaul Dagnelie kmem_free(buf, drrs->drr_length); 1633*0fa1b3ccSPaul Dagnelie return (err); 1634*0fa1b3ccSPaul Dagnelie } 1635*0fa1b3ccSPaul Dagnelie default: 1636*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1637*0fa1b3ccSPaul Dagnelie } 1638*0fa1b3ccSPaul Dagnelie } 1639*0fa1b3ccSPaul Dagnelie 1640*0fa1b3ccSPaul Dagnelie /* 1641*0fa1b3ccSPaul Dagnelie * Commit the records to the pool. 1642*0fa1b3ccSPaul Dagnelie */ 1643*0fa1b3ccSPaul Dagnelie static int 1644*0fa1b3ccSPaul Dagnelie receive_process_record(struct receive_writer_arg *rwa, 1645*0fa1b3ccSPaul Dagnelie struct receive_record_arg *rrd) 1646*0fa1b3ccSPaul Dagnelie { 1647*0fa1b3ccSPaul Dagnelie int err; 1648*0fa1b3ccSPaul Dagnelie 1649*0fa1b3ccSPaul Dagnelie /* Processing in order, therefore bytes_read should be increasing. */ 1650*0fa1b3ccSPaul Dagnelie ASSERT3U(rrd->bytes_read, >=, rwa->bytes_read); 1651*0fa1b3ccSPaul Dagnelie rwa->bytes_read = rrd->bytes_read; 1652*0fa1b3ccSPaul Dagnelie 1653*0fa1b3ccSPaul Dagnelie switch (rrd->header.drr_type) { 1654*0fa1b3ccSPaul Dagnelie case DRR_OBJECT: 1655*0fa1b3ccSPaul Dagnelie { 1656*0fa1b3ccSPaul Dagnelie struct drr_object *drro = &rrd->header.drr_u.drr_object; 1657*0fa1b3ccSPaul Dagnelie err = receive_object(rwa, drro, rrd->payload); 1658*0fa1b3ccSPaul Dagnelie kmem_free(rrd->payload, rrd->payload_size); 1659*0fa1b3ccSPaul Dagnelie rrd->payload = NULL; 1660*0fa1b3ccSPaul Dagnelie return (err); 1661*0fa1b3ccSPaul Dagnelie } 1662*0fa1b3ccSPaul Dagnelie case DRR_FREEOBJECTS: 1663*0fa1b3ccSPaul Dagnelie { 1664*0fa1b3ccSPaul Dagnelie struct drr_freeobjects *drrfo = 1665*0fa1b3ccSPaul Dagnelie &rrd->header.drr_u.drr_freeobjects; 1666*0fa1b3ccSPaul Dagnelie return (receive_freeobjects(rwa, drrfo)); 1667*0fa1b3ccSPaul Dagnelie } 1668*0fa1b3ccSPaul Dagnelie case DRR_WRITE: 1669*0fa1b3ccSPaul Dagnelie { 1670*0fa1b3ccSPaul Dagnelie struct drr_write *drrw = &rrd->header.drr_u.drr_write; 1671*0fa1b3ccSPaul Dagnelie err = receive_write(rwa, drrw, rrd->write_buf); 1672*0fa1b3ccSPaul Dagnelie /* if receive_write() is successful, it consumes the arc_buf */ 1673*0fa1b3ccSPaul Dagnelie if (err != 0) 1674*0fa1b3ccSPaul Dagnelie dmu_return_arcbuf(rrd->write_buf); 1675*0fa1b3ccSPaul Dagnelie rrd->write_buf = NULL; 1676*0fa1b3ccSPaul Dagnelie rrd->payload = NULL; 1677*0fa1b3ccSPaul Dagnelie return (err); 1678*0fa1b3ccSPaul Dagnelie } 1679*0fa1b3ccSPaul Dagnelie case DRR_WRITE_BYREF: 1680*0fa1b3ccSPaul Dagnelie { 1681*0fa1b3ccSPaul Dagnelie struct drr_write_byref *drrwbr = 1682*0fa1b3ccSPaul Dagnelie &rrd->header.drr_u.drr_write_byref; 1683*0fa1b3ccSPaul Dagnelie return (receive_write_byref(rwa, drrwbr)); 1684*0fa1b3ccSPaul Dagnelie } 1685*0fa1b3ccSPaul Dagnelie case DRR_WRITE_EMBEDDED: 1686*0fa1b3ccSPaul Dagnelie { 1687*0fa1b3ccSPaul Dagnelie struct drr_write_embedded *drrwe = 1688*0fa1b3ccSPaul Dagnelie &rrd->header.drr_u.drr_write_embedded; 1689*0fa1b3ccSPaul Dagnelie err = receive_write_embedded(rwa, drrwe, rrd->payload); 1690*0fa1b3ccSPaul Dagnelie kmem_free(rrd->payload, rrd->payload_size); 1691*0fa1b3ccSPaul Dagnelie rrd->payload = NULL; 1692*0fa1b3ccSPaul Dagnelie return (err); 1693*0fa1b3ccSPaul Dagnelie } 1694*0fa1b3ccSPaul Dagnelie case DRR_FREE: 1695*0fa1b3ccSPaul Dagnelie { 1696*0fa1b3ccSPaul Dagnelie struct drr_free *drrf = &rrd->header.drr_u.drr_free; 1697*0fa1b3ccSPaul Dagnelie return (receive_free(rwa, drrf)); 1698*0fa1b3ccSPaul Dagnelie } 1699*0fa1b3ccSPaul Dagnelie case DRR_SPILL: 1700*0fa1b3ccSPaul Dagnelie { 1701*0fa1b3ccSPaul Dagnelie struct drr_spill *drrs = &rrd->header.drr_u.drr_spill; 1702*0fa1b3ccSPaul Dagnelie err = receive_spill(rwa, drrs, rrd->payload); 1703*0fa1b3ccSPaul Dagnelie kmem_free(rrd->payload, rrd->payload_size); 1704*0fa1b3ccSPaul Dagnelie rrd->payload = NULL; 1705*0fa1b3ccSPaul Dagnelie return (err); 1706*0fa1b3ccSPaul Dagnelie } 1707*0fa1b3ccSPaul Dagnelie default: 1708*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1709*0fa1b3ccSPaul Dagnelie } 1710*0fa1b3ccSPaul Dagnelie } 1711*0fa1b3ccSPaul Dagnelie 1712*0fa1b3ccSPaul Dagnelie /* 1713*0fa1b3ccSPaul Dagnelie * dmu_recv_stream's worker thread; pull records off the queue, and then call 1714*0fa1b3ccSPaul Dagnelie * receive_process_record When we're done, signal the main thread and exit. 1715*0fa1b3ccSPaul Dagnelie */ 1716*0fa1b3ccSPaul Dagnelie static void 1717*0fa1b3ccSPaul Dagnelie receive_writer_thread(void *arg) 1718*0fa1b3ccSPaul Dagnelie { 1719*0fa1b3ccSPaul Dagnelie struct receive_writer_arg *rwa = arg; 1720*0fa1b3ccSPaul Dagnelie struct receive_record_arg *rrd; 1721*0fa1b3ccSPaul Dagnelie for (rrd = bqueue_dequeue(&rwa->q); !rrd->eos_marker; 1722*0fa1b3ccSPaul Dagnelie rrd = bqueue_dequeue(&rwa->q)) { 1723*0fa1b3ccSPaul Dagnelie /* 1724*0fa1b3ccSPaul Dagnelie * If there's an error, the main thread will stop putting things 1725*0fa1b3ccSPaul Dagnelie * on the queue, but we need to clear everything in it before we 1726*0fa1b3ccSPaul Dagnelie * can exit. 1727*0fa1b3ccSPaul Dagnelie */ 1728*0fa1b3ccSPaul Dagnelie if (rwa->err == 0) { 1729*0fa1b3ccSPaul Dagnelie rwa->err = receive_process_record(rwa, rrd); 1730*0fa1b3ccSPaul Dagnelie } else if (rrd->write_buf != NULL) { 1731*0fa1b3ccSPaul Dagnelie dmu_return_arcbuf(rrd->write_buf); 1732*0fa1b3ccSPaul Dagnelie rrd->write_buf = NULL; 1733*0fa1b3ccSPaul Dagnelie rrd->payload = NULL; 1734*0fa1b3ccSPaul Dagnelie } else if (rrd->payload != NULL) { 1735*0fa1b3ccSPaul Dagnelie kmem_free(rrd->payload, rrd->payload_size); 1736*0fa1b3ccSPaul Dagnelie rrd->payload = NULL; 1737*0fa1b3ccSPaul Dagnelie } 1738*0fa1b3ccSPaul Dagnelie kmem_free(rrd, sizeof (*rrd)); 1739*0fa1b3ccSPaul Dagnelie } 1740*0fa1b3ccSPaul Dagnelie kmem_free(rrd, sizeof (*rrd)); 1741*0fa1b3ccSPaul Dagnelie mutex_enter(&rwa->mutex); 1742*0fa1b3ccSPaul Dagnelie rwa->done = B_TRUE; 1743*0fa1b3ccSPaul Dagnelie cv_signal(&rwa->cv); 1744*0fa1b3ccSPaul Dagnelie mutex_exit(&rwa->mutex); 1745*0fa1b3ccSPaul Dagnelie thread_exit(); 1746*0fa1b3ccSPaul Dagnelie } 1747*0fa1b3ccSPaul Dagnelie 1748*0fa1b3ccSPaul Dagnelie static int 1749*0fa1b3ccSPaul Dagnelie resume_check(struct receive_arg *ra, nvlist_t *begin_nvl) 1750*0fa1b3ccSPaul Dagnelie { 1751*0fa1b3ccSPaul Dagnelie uint64_t val; 1752*0fa1b3ccSPaul Dagnelie objset_t *mos = dmu_objset_pool(ra->os)->dp_meta_objset; 1753*0fa1b3ccSPaul Dagnelie uint64_t dsobj = dmu_objset_id(ra->os); 1754*0fa1b3ccSPaul Dagnelie uint64_t resume_obj, resume_off; 1755*0fa1b3ccSPaul Dagnelie 1756*0fa1b3ccSPaul Dagnelie if (nvlist_lookup_uint64(begin_nvl, 1757*0fa1b3ccSPaul Dagnelie "resume_object", &resume_obj) != 0 || 1758*0fa1b3ccSPaul Dagnelie nvlist_lookup_uint64(begin_nvl, 1759*0fa1b3ccSPaul Dagnelie "resume_offset", &resume_off) != 0) { 1760*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1761*0fa1b3ccSPaul Dagnelie } 1762*0fa1b3ccSPaul Dagnelie VERIFY0(zap_lookup(mos, dsobj, 1763*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_OBJECT, sizeof (val), 1, &val)); 1764*0fa1b3ccSPaul Dagnelie if (resume_obj != val) 1765*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1766*0fa1b3ccSPaul Dagnelie VERIFY0(zap_lookup(mos, dsobj, 1767*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_OFFSET, sizeof (val), 1, &val)); 1768*0fa1b3ccSPaul Dagnelie if (resume_off != val) 1769*0fa1b3ccSPaul Dagnelie return (SET_ERROR(EINVAL)); 1770*0fa1b3ccSPaul Dagnelie 1771*0fa1b3ccSPaul Dagnelie return (0); 1772*0fa1b3ccSPaul Dagnelie } 1773*0fa1b3ccSPaul Dagnelie 1774*0fa1b3ccSPaul Dagnelie /* 1775*0fa1b3ccSPaul Dagnelie * Read in the stream's records, one by one, and apply them to the pool. There 1776*0fa1b3ccSPaul Dagnelie * are two threads involved; the thread that calls this function will spin up a 1777*0fa1b3ccSPaul Dagnelie * worker thread, read the records off the stream one by one, and issue 1778*0fa1b3ccSPaul Dagnelie * prefetches for any necessary indirect blocks. It will then push the records 1779*0fa1b3ccSPaul Dagnelie * onto an internal blocking queue. The worker thread will pull the records off 1780*0fa1b3ccSPaul Dagnelie * the queue, and actually write the data into the DMU. This way, the worker 1781*0fa1b3ccSPaul Dagnelie * thread doesn't have to wait for reads to complete, since everything it needs 1782*0fa1b3ccSPaul Dagnelie * (the indirect blocks) will be prefetched. 1783*0fa1b3ccSPaul Dagnelie * 1784*0fa1b3ccSPaul Dagnelie * NB: callers *must* call dmu_recv_end() if this succeeds. 1785*0fa1b3ccSPaul Dagnelie */ 1786*0fa1b3ccSPaul Dagnelie int 1787*0fa1b3ccSPaul Dagnelie dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp, 1788*0fa1b3ccSPaul Dagnelie int cleanup_fd, uint64_t *action_handlep) 1789*0fa1b3ccSPaul Dagnelie { 1790*0fa1b3ccSPaul Dagnelie int err = 0; 1791*0fa1b3ccSPaul Dagnelie struct receive_arg ra = { 0 }; 1792*0fa1b3ccSPaul Dagnelie struct receive_writer_arg rwa = { 0 }; 1793*0fa1b3ccSPaul Dagnelie int featureflags; 1794*0fa1b3ccSPaul Dagnelie nvlist_t *begin_nvl = NULL; 1795*0fa1b3ccSPaul Dagnelie 1796*0fa1b3ccSPaul Dagnelie ra.byteswap = drc->drc_byteswap; 1797*0fa1b3ccSPaul Dagnelie ra.cksum = drc->drc_cksum; 1798*0fa1b3ccSPaul Dagnelie ra.vp = vp; 1799*0fa1b3ccSPaul Dagnelie ra.voff = *voffp; 1800*0fa1b3ccSPaul Dagnelie 1801*0fa1b3ccSPaul Dagnelie if (dsl_dataset_is_zapified(drc->drc_ds)) { 1802*0fa1b3ccSPaul Dagnelie (void) zap_lookup(drc->drc_ds->ds_dir->dd_pool->dp_meta_objset, 1803*0fa1b3ccSPaul Dagnelie drc->drc_ds->ds_object, DS_FIELD_RESUME_BYTES, 1804*0fa1b3ccSPaul Dagnelie sizeof (ra.bytes_read), 1, &ra.bytes_read); 1805*0fa1b3ccSPaul Dagnelie } 1806*0fa1b3ccSPaul Dagnelie 1807*0fa1b3ccSPaul Dagnelie objlist_create(&ra.ignore_objlist); 1808*0fa1b3ccSPaul Dagnelie 1809*0fa1b3ccSPaul Dagnelie /* these were verified in dmu_recv_begin */ 1810*0fa1b3ccSPaul Dagnelie ASSERT3U(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo), ==, 1811*0fa1b3ccSPaul Dagnelie DMU_SUBSTREAM); 1812*0fa1b3ccSPaul Dagnelie ASSERT3U(drc->drc_drrb->drr_type, <, DMU_OST_NUMTYPES); 1813*0fa1b3ccSPaul Dagnelie 1814*0fa1b3ccSPaul Dagnelie /* 1815*0fa1b3ccSPaul Dagnelie * Open the objset we are modifying. 1816*0fa1b3ccSPaul Dagnelie */ 1817*0fa1b3ccSPaul Dagnelie VERIFY0(dmu_objset_from_ds(drc->drc_ds, &ra.os)); 1818*0fa1b3ccSPaul Dagnelie 1819*0fa1b3ccSPaul Dagnelie ASSERT(dsl_dataset_phys(drc->drc_ds)->ds_flags & DS_FLAG_INCONSISTENT); 1820*0fa1b3ccSPaul Dagnelie 1821*0fa1b3ccSPaul Dagnelie featureflags = DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo); 1822*0fa1b3ccSPaul Dagnelie 1823*0fa1b3ccSPaul Dagnelie /* if this stream is dedup'ed, set up the avl tree for guid mapping */ 1824*0fa1b3ccSPaul Dagnelie if (featureflags & DMU_BACKUP_FEATURE_DEDUP) { 1825*0fa1b3ccSPaul Dagnelie minor_t minor; 1826*0fa1b3ccSPaul Dagnelie 1827*0fa1b3ccSPaul Dagnelie if (cleanup_fd == -1) { 1828*0fa1b3ccSPaul Dagnelie ra.err = SET_ERROR(EBADF); 1829*0fa1b3ccSPaul Dagnelie goto out; 1830*0fa1b3ccSPaul Dagnelie } 1831*0fa1b3ccSPaul Dagnelie ra.err = zfs_onexit_fd_hold(cleanup_fd, &minor); 1832*0fa1b3ccSPaul Dagnelie if (ra.err != 0) { 1833*0fa1b3ccSPaul Dagnelie cleanup_fd = -1; 1834*0fa1b3ccSPaul Dagnelie goto out; 1835*0fa1b3ccSPaul Dagnelie } 1836*0fa1b3ccSPaul Dagnelie 1837*0fa1b3ccSPaul Dagnelie if (*action_handlep == 0) { 1838*0fa1b3ccSPaul Dagnelie rwa.guid_to_ds_map = 1839*0fa1b3ccSPaul Dagnelie kmem_alloc(sizeof (avl_tree_t), KM_SLEEP); 1840*0fa1b3ccSPaul Dagnelie avl_create(rwa.guid_to_ds_map, guid_compare, 1841*0fa1b3ccSPaul Dagnelie sizeof (guid_map_entry_t), 1842*0fa1b3ccSPaul Dagnelie offsetof(guid_map_entry_t, avlnode)); 1843*0fa1b3ccSPaul Dagnelie err = zfs_onexit_add_cb(minor, 1844*0fa1b3ccSPaul Dagnelie free_guid_map_onexit, rwa.guid_to_ds_map, 1845*0fa1b3ccSPaul Dagnelie action_handlep); 1846*0fa1b3ccSPaul Dagnelie if (ra.err != 0) 1847*0fa1b3ccSPaul Dagnelie goto out; 1848*0fa1b3ccSPaul Dagnelie } else { 1849*0fa1b3ccSPaul Dagnelie err = zfs_onexit_cb_data(minor, *action_handlep, 1850*0fa1b3ccSPaul Dagnelie (void **)&rwa.guid_to_ds_map); 1851*0fa1b3ccSPaul Dagnelie if (ra.err != 0) 1852*0fa1b3ccSPaul Dagnelie goto out; 1853*0fa1b3ccSPaul Dagnelie } 1854*0fa1b3ccSPaul Dagnelie 1855*0fa1b3ccSPaul Dagnelie drc->drc_guid_to_ds_map = rwa.guid_to_ds_map; 1856*0fa1b3ccSPaul Dagnelie } 1857*0fa1b3ccSPaul Dagnelie 1858*0fa1b3ccSPaul Dagnelie uint32_t payloadlen = drc->drc_drr_begin->drr_payloadlen; 1859*0fa1b3ccSPaul Dagnelie void *payload = NULL; 1860*0fa1b3ccSPaul Dagnelie if (payloadlen != 0) 1861*0fa1b3ccSPaul Dagnelie payload = kmem_alloc(payloadlen, KM_SLEEP); 1862*0fa1b3ccSPaul Dagnelie 1863*0fa1b3ccSPaul Dagnelie err = receive_read_payload_and_next_header(&ra, payloadlen, payload); 1864*0fa1b3ccSPaul Dagnelie if (err != 0) { 1865*0fa1b3ccSPaul Dagnelie if (payloadlen != 0) 1866*0fa1b3ccSPaul Dagnelie kmem_free(payload, payloadlen); 1867*0fa1b3ccSPaul Dagnelie goto out; 1868*0fa1b3ccSPaul Dagnelie } 1869*0fa1b3ccSPaul Dagnelie if (payloadlen != 0) { 1870*0fa1b3ccSPaul Dagnelie err = nvlist_unpack(payload, payloadlen, &begin_nvl, KM_SLEEP); 1871*0fa1b3ccSPaul Dagnelie kmem_free(payload, payloadlen); 1872*0fa1b3ccSPaul Dagnelie if (err != 0) 1873*0fa1b3ccSPaul Dagnelie goto out; 1874*0fa1b3ccSPaul Dagnelie } 1875*0fa1b3ccSPaul Dagnelie 1876*0fa1b3ccSPaul Dagnelie if (featureflags & DMU_BACKUP_FEATURE_RESUMING) { 1877*0fa1b3ccSPaul Dagnelie err = resume_check(&ra, begin_nvl); 1878*0fa1b3ccSPaul Dagnelie if (err != 0) 1879*0fa1b3ccSPaul Dagnelie goto out; 1880*0fa1b3ccSPaul Dagnelie } 1881*0fa1b3ccSPaul Dagnelie 1882*0fa1b3ccSPaul Dagnelie (void) bqueue_init(&rwa.q, zfs_recv_queue_length, 1883*0fa1b3ccSPaul Dagnelie offsetof(struct receive_record_arg, node)); 1884*0fa1b3ccSPaul Dagnelie cv_init(&rwa.cv, NULL, CV_DEFAULT, NULL); 1885*0fa1b3ccSPaul Dagnelie mutex_init(&rwa.mutex, NULL, MUTEX_DEFAULT, NULL); 1886*0fa1b3ccSPaul Dagnelie rwa.os = ra.os; 1887*0fa1b3ccSPaul Dagnelie rwa.byteswap = drc->drc_byteswap; 1888*0fa1b3ccSPaul Dagnelie rwa.resumable = drc->drc_resumable; 1889*0fa1b3ccSPaul Dagnelie 1890*0fa1b3ccSPaul Dagnelie (void) thread_create(NULL, 0, receive_writer_thread, &rwa, 0, curproc, 1891*0fa1b3ccSPaul Dagnelie TS_RUN, minclsyspri); 1892*0fa1b3ccSPaul Dagnelie /* 1893*0fa1b3ccSPaul Dagnelie * We're reading rwa.err without locks, which is safe since we are the 1894*0fa1b3ccSPaul Dagnelie * only reader, and the worker thread is the only writer. It's ok if we 1895*0fa1b3ccSPaul Dagnelie * miss a write for an iteration or two of the loop, since the writer 1896*0fa1b3ccSPaul Dagnelie * thread will keep freeing records we send it until we send it an eos 1897*0fa1b3ccSPaul Dagnelie * marker. 1898*0fa1b3ccSPaul Dagnelie * 1899*0fa1b3ccSPaul Dagnelie * We can leave this loop in 3 ways: First, if rwa.err is 1900*0fa1b3ccSPaul Dagnelie * non-zero. In that case, the writer thread will free the rrd we just 1901*0fa1b3ccSPaul Dagnelie * pushed. Second, if we're interrupted; in that case, either it's the 1902*0fa1b3ccSPaul Dagnelie * first loop and ra.rrd was never allocated, or it's later, and ra.rrd 1903*0fa1b3ccSPaul Dagnelie * has been handed off to the writer thread who will free it. Finally, 1904*0fa1b3ccSPaul Dagnelie * if receive_read_record fails or we're at the end of the stream, then 1905*0fa1b3ccSPaul Dagnelie * we free ra.rrd and exit. 1906*0fa1b3ccSPaul Dagnelie */ 1907*0fa1b3ccSPaul Dagnelie while (rwa.err == 0) { 1908*0fa1b3ccSPaul Dagnelie if (issig(JUSTLOOKING) && issig(FORREAL)) { 1909*0fa1b3ccSPaul Dagnelie err = SET_ERROR(EINTR); 1910*0fa1b3ccSPaul Dagnelie break; 1911*0fa1b3ccSPaul Dagnelie } 1912*0fa1b3ccSPaul Dagnelie 1913*0fa1b3ccSPaul Dagnelie ASSERT3P(ra.rrd, ==, NULL); 1914*0fa1b3ccSPaul Dagnelie ra.rrd = ra.next_rrd; 1915*0fa1b3ccSPaul Dagnelie ra.next_rrd = NULL; 1916*0fa1b3ccSPaul Dagnelie /* Allocates and loads header into ra.next_rrd */ 1917*0fa1b3ccSPaul Dagnelie err = receive_read_record(&ra); 1918*0fa1b3ccSPaul Dagnelie 1919*0fa1b3ccSPaul Dagnelie if (ra.rrd->header.drr_type == DRR_END || err != 0) { 1920*0fa1b3ccSPaul Dagnelie kmem_free(ra.rrd, sizeof (*ra.rrd)); 1921*0fa1b3ccSPaul Dagnelie ra.rrd = NULL; 1922*0fa1b3ccSPaul Dagnelie break; 1923*0fa1b3ccSPaul Dagnelie } 1924*0fa1b3ccSPaul Dagnelie 1925*0fa1b3ccSPaul Dagnelie bqueue_enqueue(&rwa.q, ra.rrd, 1926*0fa1b3ccSPaul Dagnelie sizeof (struct receive_record_arg) + ra.rrd->payload_size); 1927*0fa1b3ccSPaul Dagnelie ra.rrd = NULL; 1928*0fa1b3ccSPaul Dagnelie } 1929*0fa1b3ccSPaul Dagnelie if (ra.next_rrd == NULL) 1930*0fa1b3ccSPaul Dagnelie ra.next_rrd = kmem_zalloc(sizeof (*ra.next_rrd), KM_SLEEP); 1931*0fa1b3ccSPaul Dagnelie ra.next_rrd->eos_marker = B_TRUE; 1932*0fa1b3ccSPaul Dagnelie bqueue_enqueue(&rwa.q, ra.next_rrd, 1); 1933*0fa1b3ccSPaul Dagnelie 1934*0fa1b3ccSPaul Dagnelie mutex_enter(&rwa.mutex); 1935*0fa1b3ccSPaul Dagnelie while (!rwa.done) { 1936*0fa1b3ccSPaul Dagnelie cv_wait(&rwa.cv, &rwa.mutex); 1937*0fa1b3ccSPaul Dagnelie } 1938*0fa1b3ccSPaul Dagnelie mutex_exit(&rwa.mutex); 1939*0fa1b3ccSPaul Dagnelie 1940*0fa1b3ccSPaul Dagnelie /* 1941*0fa1b3ccSPaul Dagnelie * If we are receiving a full stream as a clone, all object IDs which 1942*0fa1b3ccSPaul Dagnelie * are greater than the maximum ID referenced in the stream are 1943*0fa1b3ccSPaul Dagnelie * by definition unused and must be freed. Note that it's possible that 1944*0fa1b3ccSPaul Dagnelie * we've resumed this send and the first record we received was the END 1945*0fa1b3ccSPaul Dagnelie * record. In that case, max_object would be 0, but we shouldn't start 1946*0fa1b3ccSPaul Dagnelie * freeing all objects from there; instead we should start from the 1947*0fa1b3ccSPaul Dagnelie * resumeobj. 1948*0fa1b3ccSPaul Dagnelie */ 1949*0fa1b3ccSPaul Dagnelie if (drc->drc_clone && drc->drc_drrb->drr_fromguid == 0) { 1950*0fa1b3ccSPaul Dagnelie uint64_t obj; 1951*0fa1b3ccSPaul Dagnelie if (nvlist_lookup_uint64(begin_nvl, "resume_object", &obj) != 0) 1952*0fa1b3ccSPaul Dagnelie obj = 0; 1953*0fa1b3ccSPaul Dagnelie if (rwa.max_object > obj) 1954*0fa1b3ccSPaul Dagnelie obj = rwa.max_object; 1955*0fa1b3ccSPaul Dagnelie obj++; 1956*0fa1b3ccSPaul Dagnelie int free_err = 0; 1957*0fa1b3ccSPaul Dagnelie int next_err = 0; 1958*0fa1b3ccSPaul Dagnelie 1959*0fa1b3ccSPaul Dagnelie while (next_err == 0) { 1960*0fa1b3ccSPaul Dagnelie free_err = dmu_free_long_object(rwa.os, obj); 1961*0fa1b3ccSPaul Dagnelie if (free_err != 0 && free_err != ENOENT) 1962*0fa1b3ccSPaul Dagnelie break; 1963*0fa1b3ccSPaul Dagnelie 1964*0fa1b3ccSPaul Dagnelie next_err = dmu_object_next(rwa.os, &obj, FALSE, 0); 1965*0fa1b3ccSPaul Dagnelie } 1966*0fa1b3ccSPaul Dagnelie 1967*0fa1b3ccSPaul Dagnelie if (err == 0) { 1968*0fa1b3ccSPaul Dagnelie if (free_err != 0 && free_err != ENOENT) 1969*0fa1b3ccSPaul Dagnelie err = free_err; 1970*0fa1b3ccSPaul Dagnelie else if (next_err != ESRCH) 1971*0fa1b3ccSPaul Dagnelie err = next_err; 1972*0fa1b3ccSPaul Dagnelie } 1973*0fa1b3ccSPaul Dagnelie } 1974*0fa1b3ccSPaul Dagnelie 1975*0fa1b3ccSPaul Dagnelie cv_destroy(&rwa.cv); 1976*0fa1b3ccSPaul Dagnelie mutex_destroy(&rwa.mutex); 1977*0fa1b3ccSPaul Dagnelie bqueue_destroy(&rwa.q); 1978*0fa1b3ccSPaul Dagnelie if (err == 0) 1979*0fa1b3ccSPaul Dagnelie err = rwa.err; 1980*0fa1b3ccSPaul Dagnelie 1981*0fa1b3ccSPaul Dagnelie out: 1982*0fa1b3ccSPaul Dagnelie nvlist_free(begin_nvl); 1983*0fa1b3ccSPaul Dagnelie if ((featureflags & DMU_BACKUP_FEATURE_DEDUP) && (cleanup_fd != -1)) 1984*0fa1b3ccSPaul Dagnelie zfs_onexit_fd_rele(cleanup_fd); 1985*0fa1b3ccSPaul Dagnelie 1986*0fa1b3ccSPaul Dagnelie if (err != 0) { 1987*0fa1b3ccSPaul Dagnelie /* 1988*0fa1b3ccSPaul Dagnelie * Clean up references. If receive is not resumable, 1989*0fa1b3ccSPaul Dagnelie * destroy what we created, so we don't leave it in 1990*0fa1b3ccSPaul Dagnelie * the inconsistent state. 1991*0fa1b3ccSPaul Dagnelie */ 1992*0fa1b3ccSPaul Dagnelie dmu_recv_cleanup_ds(drc); 1993*0fa1b3ccSPaul Dagnelie } 1994*0fa1b3ccSPaul Dagnelie 1995*0fa1b3ccSPaul Dagnelie *voffp = ra.voff; 1996*0fa1b3ccSPaul Dagnelie objlist_destroy(&ra.ignore_objlist); 1997*0fa1b3ccSPaul Dagnelie return (err); 1998*0fa1b3ccSPaul Dagnelie } 1999*0fa1b3ccSPaul Dagnelie 2000*0fa1b3ccSPaul Dagnelie static int 2001*0fa1b3ccSPaul Dagnelie dmu_recv_end_check(void *arg, dmu_tx_t *tx) 2002*0fa1b3ccSPaul Dagnelie { 2003*0fa1b3ccSPaul Dagnelie dmu_recv_cookie_t *drc = arg; 2004*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = dmu_tx_pool(tx); 2005*0fa1b3ccSPaul Dagnelie int error; 2006*0fa1b3ccSPaul Dagnelie 2007*0fa1b3ccSPaul Dagnelie ASSERT3P(drc->drc_ds->ds_owner, ==, dmu_recv_tag); 2008*0fa1b3ccSPaul Dagnelie 2009*0fa1b3ccSPaul Dagnelie if (!drc->drc_newfs) { 2010*0fa1b3ccSPaul Dagnelie dsl_dataset_t *origin_head; 2011*0fa1b3ccSPaul Dagnelie 2012*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold(dp, drc->drc_tofs, FTAG, &origin_head); 2013*0fa1b3ccSPaul Dagnelie if (error != 0) 2014*0fa1b3ccSPaul Dagnelie return (error); 2015*0fa1b3ccSPaul Dagnelie if (drc->drc_force) { 2016*0fa1b3ccSPaul Dagnelie /* 2017*0fa1b3ccSPaul Dagnelie * We will destroy any snapshots in tofs (i.e. before 2018*0fa1b3ccSPaul Dagnelie * origin_head) that are after the origin (which is 2019*0fa1b3ccSPaul Dagnelie * the snap before drc_ds, because drc_ds can not 2020*0fa1b3ccSPaul Dagnelie * have any snaps of its own). 2021*0fa1b3ccSPaul Dagnelie */ 2022*0fa1b3ccSPaul Dagnelie uint64_t obj; 2023*0fa1b3ccSPaul Dagnelie 2024*0fa1b3ccSPaul Dagnelie obj = dsl_dataset_phys(origin_head)->ds_prev_snap_obj; 2025*0fa1b3ccSPaul Dagnelie while (obj != 2026*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj) { 2027*0fa1b3ccSPaul Dagnelie dsl_dataset_t *snap; 2028*0fa1b3ccSPaul Dagnelie error = dsl_dataset_hold_obj(dp, obj, FTAG, 2029*0fa1b3ccSPaul Dagnelie &snap); 2030*0fa1b3ccSPaul Dagnelie if (error != 0) 2031*0fa1b3ccSPaul Dagnelie break; 2032*0fa1b3ccSPaul Dagnelie if (snap->ds_dir != origin_head->ds_dir) 2033*0fa1b3ccSPaul Dagnelie error = SET_ERROR(EINVAL); 2034*0fa1b3ccSPaul Dagnelie if (error == 0) { 2035*0fa1b3ccSPaul Dagnelie error = dsl_destroy_snapshot_check_impl( 2036*0fa1b3ccSPaul Dagnelie snap, B_FALSE); 2037*0fa1b3ccSPaul Dagnelie } 2038*0fa1b3ccSPaul Dagnelie obj = dsl_dataset_phys(snap)->ds_prev_snap_obj; 2039*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 2040*0fa1b3ccSPaul Dagnelie if (error != 0) 2041*0fa1b3ccSPaul Dagnelie break; 2042*0fa1b3ccSPaul Dagnelie } 2043*0fa1b3ccSPaul Dagnelie if (error != 0) { 2044*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin_head, FTAG); 2045*0fa1b3ccSPaul Dagnelie return (error); 2046*0fa1b3ccSPaul Dagnelie } 2047*0fa1b3ccSPaul Dagnelie } 2048*0fa1b3ccSPaul Dagnelie error = dsl_dataset_clone_swap_check_impl(drc->drc_ds, 2049*0fa1b3ccSPaul Dagnelie origin_head, drc->drc_force, drc->drc_owner, tx); 2050*0fa1b3ccSPaul Dagnelie if (error != 0) { 2051*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin_head, FTAG); 2052*0fa1b3ccSPaul Dagnelie return (error); 2053*0fa1b3ccSPaul Dagnelie } 2054*0fa1b3ccSPaul Dagnelie error = dsl_dataset_snapshot_check_impl(origin_head, 2055*0fa1b3ccSPaul Dagnelie drc->drc_tosnap, tx, B_TRUE, 1, drc->drc_cred); 2056*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin_head, FTAG); 2057*0fa1b3ccSPaul Dagnelie if (error != 0) 2058*0fa1b3ccSPaul Dagnelie return (error); 2059*0fa1b3ccSPaul Dagnelie 2060*0fa1b3ccSPaul Dagnelie error = dsl_destroy_head_check_impl(drc->drc_ds, 1); 2061*0fa1b3ccSPaul Dagnelie } else { 2062*0fa1b3ccSPaul Dagnelie error = dsl_dataset_snapshot_check_impl(drc->drc_ds, 2063*0fa1b3ccSPaul Dagnelie drc->drc_tosnap, tx, B_TRUE, 1, drc->drc_cred); 2064*0fa1b3ccSPaul Dagnelie } 2065*0fa1b3ccSPaul Dagnelie return (error); 2066*0fa1b3ccSPaul Dagnelie } 2067*0fa1b3ccSPaul Dagnelie 2068*0fa1b3ccSPaul Dagnelie static void 2069*0fa1b3ccSPaul Dagnelie dmu_recv_end_sync(void *arg, dmu_tx_t *tx) 2070*0fa1b3ccSPaul Dagnelie { 2071*0fa1b3ccSPaul Dagnelie dmu_recv_cookie_t *drc = arg; 2072*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp = dmu_tx_pool(tx); 2073*0fa1b3ccSPaul Dagnelie 2074*0fa1b3ccSPaul Dagnelie spa_history_log_internal_ds(drc->drc_ds, "finish receiving", 2075*0fa1b3ccSPaul Dagnelie tx, "snap=%s", drc->drc_tosnap); 2076*0fa1b3ccSPaul Dagnelie 2077*0fa1b3ccSPaul Dagnelie if (!drc->drc_newfs) { 2078*0fa1b3ccSPaul Dagnelie dsl_dataset_t *origin_head; 2079*0fa1b3ccSPaul Dagnelie 2080*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_hold(dp, drc->drc_tofs, FTAG, 2081*0fa1b3ccSPaul Dagnelie &origin_head)); 2082*0fa1b3ccSPaul Dagnelie 2083*0fa1b3ccSPaul Dagnelie if (drc->drc_force) { 2084*0fa1b3ccSPaul Dagnelie /* 2085*0fa1b3ccSPaul Dagnelie * Destroy any snapshots of drc_tofs (origin_head) 2086*0fa1b3ccSPaul Dagnelie * after the origin (the snap before drc_ds). 2087*0fa1b3ccSPaul Dagnelie */ 2088*0fa1b3ccSPaul Dagnelie uint64_t obj; 2089*0fa1b3ccSPaul Dagnelie 2090*0fa1b3ccSPaul Dagnelie obj = dsl_dataset_phys(origin_head)->ds_prev_snap_obj; 2091*0fa1b3ccSPaul Dagnelie while (obj != 2092*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj) { 2093*0fa1b3ccSPaul Dagnelie dsl_dataset_t *snap; 2094*0fa1b3ccSPaul Dagnelie VERIFY0(dsl_dataset_hold_obj(dp, obj, FTAG, 2095*0fa1b3ccSPaul Dagnelie &snap)); 2096*0fa1b3ccSPaul Dagnelie ASSERT3P(snap->ds_dir, ==, origin_head->ds_dir); 2097*0fa1b3ccSPaul Dagnelie obj = dsl_dataset_phys(snap)->ds_prev_snap_obj; 2098*0fa1b3ccSPaul Dagnelie dsl_destroy_snapshot_sync_impl(snap, 2099*0fa1b3ccSPaul Dagnelie B_FALSE, tx); 2100*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(snap, FTAG); 2101*0fa1b3ccSPaul Dagnelie } 2102*0fa1b3ccSPaul Dagnelie } 2103*0fa1b3ccSPaul Dagnelie VERIFY3P(drc->drc_ds->ds_prev, ==, 2104*0fa1b3ccSPaul Dagnelie origin_head->ds_prev); 2105*0fa1b3ccSPaul Dagnelie 2106*0fa1b3ccSPaul Dagnelie dsl_dataset_clone_swap_sync_impl(drc->drc_ds, 2107*0fa1b3ccSPaul Dagnelie origin_head, tx); 2108*0fa1b3ccSPaul Dagnelie dsl_dataset_snapshot_sync_impl(origin_head, 2109*0fa1b3ccSPaul Dagnelie drc->drc_tosnap, tx); 2110*0fa1b3ccSPaul Dagnelie 2111*0fa1b3ccSPaul Dagnelie /* set snapshot's creation time and guid */ 2112*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(origin_head->ds_prev->ds_dbuf, tx); 2113*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(origin_head->ds_prev)->ds_creation_time = 2114*0fa1b3ccSPaul Dagnelie drc->drc_drrb->drr_creation_time; 2115*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(origin_head->ds_prev)->ds_guid = 2116*0fa1b3ccSPaul Dagnelie drc->drc_drrb->drr_toguid; 2117*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(origin_head->ds_prev)->ds_flags &= 2118*0fa1b3ccSPaul Dagnelie ~DS_FLAG_INCONSISTENT; 2119*0fa1b3ccSPaul Dagnelie 2120*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(origin_head->ds_dbuf, tx); 2121*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(origin_head)->ds_flags &= 2122*0fa1b3ccSPaul Dagnelie ~DS_FLAG_INCONSISTENT; 2123*0fa1b3ccSPaul Dagnelie 2124*0fa1b3ccSPaul Dagnelie drc->drc_newsnapobj = 2125*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(origin_head)->ds_prev_snap_obj; 2126*0fa1b3ccSPaul Dagnelie 2127*0fa1b3ccSPaul Dagnelie dsl_dataset_rele(origin_head, FTAG); 2128*0fa1b3ccSPaul Dagnelie dsl_destroy_head_sync_impl(drc->drc_ds, tx); 2129*0fa1b3ccSPaul Dagnelie 2130*0fa1b3ccSPaul Dagnelie if (drc->drc_owner != NULL) 2131*0fa1b3ccSPaul Dagnelie VERIFY3P(origin_head->ds_owner, ==, drc->drc_owner); 2132*0fa1b3ccSPaul Dagnelie } else { 2133*0fa1b3ccSPaul Dagnelie dsl_dataset_t *ds = drc->drc_ds; 2134*0fa1b3ccSPaul Dagnelie 2135*0fa1b3ccSPaul Dagnelie dsl_dataset_snapshot_sync_impl(ds, drc->drc_tosnap, tx); 2136*0fa1b3ccSPaul Dagnelie 2137*0fa1b3ccSPaul Dagnelie /* set snapshot's creation time and guid */ 2138*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 2139*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds->ds_prev)->ds_creation_time = 2140*0fa1b3ccSPaul Dagnelie drc->drc_drrb->drr_creation_time; 2141*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds->ds_prev)->ds_guid = 2142*0fa1b3ccSPaul Dagnelie drc->drc_drrb->drr_toguid; 2143*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds->ds_prev)->ds_flags &= 2144*0fa1b3ccSPaul Dagnelie ~DS_FLAG_INCONSISTENT; 2145*0fa1b3ccSPaul Dagnelie 2146*0fa1b3ccSPaul Dagnelie dmu_buf_will_dirty(ds->ds_dbuf, tx); 2147*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(ds)->ds_flags &= ~DS_FLAG_INCONSISTENT; 2148*0fa1b3ccSPaul Dagnelie if (dsl_dataset_has_resume_receive_state(ds)) { 2149*0fa1b3ccSPaul Dagnelie (void) zap_remove(dp->dp_meta_objset, ds->ds_object, 2150*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_FROMGUID, tx); 2151*0fa1b3ccSPaul Dagnelie (void) zap_remove(dp->dp_meta_objset, ds->ds_object, 2152*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_OBJECT, tx); 2153*0fa1b3ccSPaul Dagnelie (void) zap_remove(dp->dp_meta_objset, ds->ds_object, 2154*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_OFFSET, tx); 2155*0fa1b3ccSPaul Dagnelie (void) zap_remove(dp->dp_meta_objset, ds->ds_object, 2156*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_BYTES, tx); 2157*0fa1b3ccSPaul Dagnelie (void) zap_remove(dp->dp_meta_objset, ds->ds_object, 2158*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_TOGUID, tx); 2159*0fa1b3ccSPaul Dagnelie (void) zap_remove(dp->dp_meta_objset, ds->ds_object, 2160*0fa1b3ccSPaul Dagnelie DS_FIELD_RESUME_TONAME, tx); 2161*0fa1b3ccSPaul Dagnelie } 2162*0fa1b3ccSPaul Dagnelie drc->drc_newsnapobj = 2163*0fa1b3ccSPaul Dagnelie dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj; 2164*0fa1b3ccSPaul Dagnelie } 2165*0fa1b3ccSPaul Dagnelie /* 2166*0fa1b3ccSPaul Dagnelie * Release the hold from dmu_recv_begin. This must be done before 2167*0fa1b3ccSPaul Dagnelie * we return to open context, so that when we free the dataset's dnode, 2168*0fa1b3ccSPaul Dagnelie * we can evict its bonus buffer. 2169*0fa1b3ccSPaul Dagnelie */ 2170*0fa1b3ccSPaul Dagnelie dsl_dataset_disown(drc->drc_ds, dmu_recv_tag); 2171*0fa1b3ccSPaul Dagnelie drc->drc_ds = NULL; 2172*0fa1b3ccSPaul Dagnelie } 2173*0fa1b3ccSPaul Dagnelie 2174*0fa1b3ccSPaul Dagnelie static int 2175*0fa1b3ccSPaul Dagnelie add_ds_to_guidmap(const char *name, avl_tree_t *guid_map, uint64_t snapobj) 2176*0fa1b3ccSPaul Dagnelie { 2177*0fa1b3ccSPaul Dagnelie dsl_pool_t *dp; 2178*0fa1b3ccSPaul Dagnelie dsl_dataset_t *snapds; 2179*0fa1b3ccSPaul Dagnelie guid_map_entry_t *gmep; 2180*0fa1b3ccSPaul Dagnelie int err; 2181*0fa1b3ccSPaul Dagnelie 2182*0fa1b3ccSPaul Dagnelie ASSERT(guid_map != NULL); 2183*0fa1b3ccSPaul Dagnelie 2184*0fa1b3ccSPaul Dagnelie err = dsl_pool_hold(name, FTAG, &dp); 2185*0fa1b3ccSPaul Dagnelie if (err != 0) 2186*0fa1b3ccSPaul Dagnelie return (err); 2187*0fa1b3ccSPaul Dagnelie gmep = kmem_alloc(sizeof (*gmep), KM_SLEEP); 2188*0fa1b3ccSPaul Dagnelie err = dsl_dataset_hold_obj(dp, snapobj, gmep, &snapds); 2189*0fa1b3ccSPaul Dagnelie if (err == 0) { 2190*0fa1b3ccSPaul Dagnelie gmep->guid = dsl_dataset_phys(snapds)->ds_guid; 2191*0fa1b3ccSPaul Dagnelie gmep->gme_ds = snapds; 2192*0fa1b3ccSPaul Dagnelie avl_add(guid_map, gmep); 2193*0fa1b3ccSPaul Dagnelie dsl_dataset_long_hold(snapds, gmep); 2194*0fa1b3ccSPaul Dagnelie } else { 2195*0fa1b3ccSPaul Dagnelie kmem_free(gmep, sizeof (*gmep)); 2196*0fa1b3ccSPaul Dagnelie } 2197*0fa1b3ccSPaul Dagnelie 2198*0fa1b3ccSPaul Dagnelie dsl_pool_rele(dp, FTAG); 2199*0fa1b3ccSPaul Dagnelie return (err); 2200*0fa1b3ccSPaul Dagnelie } 2201*0fa1b3ccSPaul Dagnelie 2202*0fa1b3ccSPaul Dagnelie static int dmu_recv_end_modified_blocks = 3; 2203*0fa1b3ccSPaul Dagnelie 2204*0fa1b3ccSPaul Dagnelie static int 2205*0fa1b3ccSPaul Dagnelie dmu_recv_existing_end(dmu_recv_cookie_t *drc) 2206*0fa1b3ccSPaul Dagnelie { 2207*0fa1b3ccSPaul Dagnelie #ifdef _KERNEL 2208*0fa1b3ccSPaul Dagnelie /* 2209*0fa1b3ccSPaul Dagnelie * We will be destroying the ds; make sure its origin is unmounted if 2210*0fa1b3ccSPaul Dagnelie * necessary. 2211*0fa1b3ccSPaul Dagnelie */ 2212*0fa1b3ccSPaul Dagnelie char name[ZFS_MAX_DATASET_NAME_LEN]; 2213*0fa1b3ccSPaul Dagnelie dsl_dataset_name(drc->drc_ds, name); 2214*0fa1b3ccSPaul Dagnelie zfs_destroy_unmount_origin(name); 2215*0fa1b3ccSPaul Dagnelie #endif 2216*0fa1b3ccSPaul Dagnelie 2217*0fa1b3ccSPaul Dagnelie return (dsl_sync_task(drc->drc_tofs, 2218*0fa1b3ccSPaul Dagnelie dmu_recv_end_check, dmu_recv_end_sync, drc, 2219*0fa1b3ccSPaul Dagnelie dmu_recv_end_modified_blocks, ZFS_SPACE_CHECK_NORMAL)); 2220*0fa1b3ccSPaul Dagnelie } 2221*0fa1b3ccSPaul Dagnelie 2222*0fa1b3ccSPaul Dagnelie static int 2223*0fa1b3ccSPaul Dagnelie dmu_recv_new_end(dmu_recv_cookie_t *drc) 2224*0fa1b3ccSPaul Dagnelie { 2225*0fa1b3ccSPaul Dagnelie return (dsl_sync_task(drc->drc_tofs, 2226*0fa1b3ccSPaul Dagnelie dmu_recv_end_check, dmu_recv_end_sync, drc, 2227*0fa1b3ccSPaul Dagnelie dmu_recv_end_modified_blocks, ZFS_SPACE_CHECK_NORMAL)); 2228*0fa1b3ccSPaul Dagnelie } 2229*0fa1b3ccSPaul Dagnelie 2230*0fa1b3ccSPaul Dagnelie int 2231*0fa1b3ccSPaul Dagnelie dmu_recv_end(dmu_recv_cookie_t *drc, void *owner) 2232*0fa1b3ccSPaul Dagnelie { 2233*0fa1b3ccSPaul Dagnelie int error; 2234*0fa1b3ccSPaul Dagnelie 2235*0fa1b3ccSPaul Dagnelie drc->drc_owner = owner; 2236*0fa1b3ccSPaul Dagnelie 2237*0fa1b3ccSPaul Dagnelie if (drc->drc_newfs) 2238*0fa1b3ccSPaul Dagnelie error = dmu_recv_new_end(drc); 2239*0fa1b3ccSPaul Dagnelie else 2240*0fa1b3ccSPaul Dagnelie error = dmu_recv_existing_end(drc); 2241*0fa1b3ccSPaul Dagnelie 2242*0fa1b3ccSPaul Dagnelie if (error != 0) { 2243*0fa1b3ccSPaul Dagnelie dmu_recv_cleanup_ds(drc); 2244*0fa1b3ccSPaul Dagnelie } else if (drc->drc_guid_to_ds_map != NULL) { 2245*0fa1b3ccSPaul Dagnelie (void) add_ds_to_guidmap(drc->drc_tofs, 2246*0fa1b3ccSPaul Dagnelie drc->drc_guid_to_ds_map, 2247*0fa1b3ccSPaul Dagnelie drc->drc_newsnapobj); 2248*0fa1b3ccSPaul Dagnelie } 2249*0fa1b3ccSPaul Dagnelie return (error); 2250*0fa1b3ccSPaul Dagnelie } 2251*0fa1b3ccSPaul Dagnelie 2252*0fa1b3ccSPaul Dagnelie /* 2253*0fa1b3ccSPaul Dagnelie * Return TRUE if this objset is currently being received into. 2254*0fa1b3ccSPaul Dagnelie */ 2255*0fa1b3ccSPaul Dagnelie boolean_t 2256*0fa1b3ccSPaul Dagnelie dmu_objset_is_receiving(objset_t *os) 2257*0fa1b3ccSPaul Dagnelie { 2258*0fa1b3ccSPaul Dagnelie return (os->os_dsl_dataset != NULL && 2259*0fa1b3ccSPaul Dagnelie os->os_dsl_dataset->ds_owner == dmu_recv_tag); 2260*0fa1b3ccSPaul Dagnelie } 2261