sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dmu_send.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include <sys/dmu.h>
  29 #include <sys/dmu_impl.h>
  30 #include <sys/dmu_tx.h>
  31 #include <sys/dbuf.h>
  32 #include <sys/dnode.h>
  33 #include <sys/zfs_context.h>
  34 #include <sys/dmu_objset.h>
  35 #include <sys/dmu_traverse.h>
  36 #include <sys/dsl_dataset.h>
  37 #include <sys/dsl_dir.h>
  38 #include <sys/dsl_pool.h>
  39 #include <sys/dsl_synctask.h>
  40 #include <sys/zfs_ioctl.h>
  41 #include <sys/zap.h>
  42 #include <sys/zio_checksum.h>
  43
  44 static char *dmu_recv_tag = "dmu_recv_tag";
  45
  46 struct backuparg {
  47         dmu_replay_record_t *drr;
  48         kthread_t *td;
  49         struct file *fp;
  50         offset_t *off;
  51         objset_t *os;
  52         zio_cksum_t zc;
  53         int err;
  54 };
  55
  56 static int
  57 dump_bytes(struct backuparg *ba, void *buf, int len)
  58 {
  59         struct uio auio;
  60         struct iovec aiov;
  61
  62         ASSERT3U(len % 8, ==, 0);
  63
  64         fletcher_4_incremental_native(buf, len, &ba->zc);
  65
  66         aiov.iov_base = buf;
  67         aiov.iov_len = len;
  68         auio.uio_iov = &aiov;
  69         auio.uio_iovcnt = 1;
  70         auio.uio_resid = len;
  71         auio.uio_segflg = UIO_SYSSPACE;
  72         auio.uio_rw = UIO_WRITE;
  73         auio.uio_offset = (off_t)-1;
  74         auio.uio_td = ba->td;
  75 #ifdef _KERNEL
  76         if (ba->fp->f_type == DTYPE_VNODE)
  77                 bwillwrite();
  78         ba->err = fo_write(ba->fp, &auio, ba->td->td_ucred, 0, ba->td);
  79 #else
  80         fprintf(stderr, "%s: returning EOPNOTSUPP\n", __func__);
  81         ba->err = EOPNOTSUPP;
  82 #endif
  83         *ba->off += len;
  84
  85         return (ba->err);
  86 }
  87
  88 static int
  89 dump_free(struct backuparg *ba, uint64_t object, uint64_t offset,
  90     uint64_t length)
  91 {
  92         /* write a FREE record */
  93         bzero(ba->drr, sizeof (dmu_replay_record_t));
  94         ba->drr->drr_type = DRR_FREE;
  95         ba->drr->drr_u.drr_free.drr_object = object;
  96         ba->drr->drr_u.drr_free.drr_offset = offset;
  97         ba->drr->drr_u.drr_free.drr_length = length;
  98
  99         if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
 100                 return (EINTR);
 101         return (0);
 102 }
 103
 104 static int
 105 dump_data(struct backuparg *ba, dmu_object_type_t type,
 106     uint64_t object, uint64_t offset, int blksz, void *data)
 107 {
 108         /* write a DATA record */
 109         bzero(ba->drr, sizeof (dmu_replay_record_t));
 110         ba->drr->drr_type = DRR_WRITE;
 111         ba->drr->drr_u.drr_write.drr_object = object;
 112         ba->drr->drr_u.drr_write.drr_type = type;
 113         ba->drr->drr_u.drr_write.drr_offset = offset;
 114         ba->drr->drr_u.drr_write.drr_length = blksz;
 115
 116         if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
 117                 return (EINTR);
 118         if (dump_bytes(ba, data, blksz))
 119                 return (EINTR);
 120         return (0);
 121 }
 122
 123 static int
 124 dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs)
 125 {
 126         /* write a FREEOBJECTS record */
 127         bzero(ba->drr, sizeof (dmu_replay_record_t));
 128         ba->drr->drr_type = DRR_FREEOBJECTS;
 129         ba->drr->drr_u.drr_freeobjects.drr_firstobj = firstobj;
 130         ba->drr->drr_u.drr_freeobjects.drr_numobjs = numobjs;
 131
 132         if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
 133                 return (EINTR);
 134         return (0);
 135 }
 136
 137 static int
 138 dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp)
 139 {
 140         if (dnp == NULL || dnp->dn_type == DMU_OT_NONE)
 141                 return (dump_freeobjects(ba, object, 1));
 142
 143         /* write an OBJECT record */
 144         bzero(ba->drr, sizeof (dmu_replay_record_t));
 145         ba->drr->drr_type = DRR_OBJECT;
 146         ba->drr->drr_u.drr_object.drr_object = object;
 147         ba->drr->drr_u.drr_object.drr_type = dnp->dn_type;
 148         ba->drr->drr_u.drr_object.drr_bonustype = dnp->dn_bonustype;
 149         ba->drr->drr_u.drr_object.drr_blksz =
 150             dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT;
 151         ba->drr->drr_u.drr_object.drr_bonuslen = dnp->dn_bonuslen;
 152         ba->drr->drr_u.drr_object.drr_checksum = dnp->dn_checksum;
 153         ba->drr->drr_u.drr_object.drr_compress = dnp->dn_compress;
 154
 155         if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
 156                 return (EINTR);
 157
 158         if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)))
 159                 return (EINTR);
 160
 161         /* free anything past the end of the file */
 162         if (dump_free(ba, object, (dnp->dn_maxblkid + 1) *
 163             (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL))
 164                 return (EINTR);
 165         if (ba->err)
 166                 return (EINTR);
 167         return (0);
 168 }
 169
 170 #define BP_SPAN(dnp, level) \
 171         (((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \
 172         (level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT)))
 173
 174 static int
 175 backup_cb(traverse_blk_cache_t *bc, spa_t *spa, void *arg)
 176 {
 177         struct backuparg *ba = arg;
 178         uint64_t object = bc->bc_bookmark.zb_object;
 179         int level = bc->bc_bookmark.zb_level;
 180         uint64_t blkid = bc->bc_bookmark.zb_blkid;
 181         blkptr_t *bp = bc->bc_blkptr.blk_birth ? &bc->bc_blkptr : NULL;
 182         dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE;
 183         void *data = bc->bc_data;
 184         int err = 0;
 185
 186         if (issig(JUSTLOOKING) && issig(FORREAL))
 187                 return (EINTR);
 188
 189         ASSERT(data || bp == NULL);
 190
 191         if (bp == NULL && object == 0) {
 192                 uint64_t span = BP_SPAN(bc->bc_dnode, level);
 193                 uint64_t dnobj = (blkid * span) >> DNODE_SHIFT;
 194                 err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT);
 195         } else if (bp == NULL) {
 196                 uint64_t span = BP_SPAN(bc->bc_dnode, level);
 197                 err = dump_free(ba, object, blkid * span, span);
 198         } else if (data && level == 0 && type == DMU_OT_DNODE) {
 199                 dnode_phys_t *blk = data;
 200                 int i;
 201                 int blksz = BP_GET_LSIZE(bp);
 202
 203                 for (i = 0; i < blksz >> DNODE_SHIFT; i++) {
 204                         uint64_t dnobj =
 205                             (blkid << (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i;
 206                         err = dump_dnode(ba, dnobj, blk+i);
 207                         if (err)
 208                                 break;
 209                 }
 210         } else if (level == 0 &&
 211             type != DMU_OT_DNODE && type != DMU_OT_OBJSET) {
 212                 int blksz = BP_GET_LSIZE(bp);
 213                 if (data == NULL) {
 214                         uint32_t aflags = ARC_WAIT;
 215                         arc_buf_t *abuf;
 216                         zbookmark_t zb;
 217
 218                         zb.zb_objset = ba->os->os->os_dsl_dataset->ds_object;
 219                         zb.zb_object = object;
 220                         zb.zb_level = level;
 221                         zb.zb_blkid = blkid;
 222                         (void) arc_read_nolock(NULL, spa, bp,
 223                             arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ,
 224                             ZIO_FLAG_MUSTSUCCEED, &aflags, &zb);
 225
 226                         if (abuf) {
 227                                 err = dump_data(ba, type, object, blkid * blksz,
 228                                     blksz, abuf->b_data);
 229                                 (void) arc_buf_remove_ref(abuf, &abuf);
 230                         }
 231                 } else {
 232                         err = dump_data(ba, type, object, blkid * blksz,
 233                             blksz, data);
 234                 }
 235         }
 236
 237         ASSERT(err == 0 || err == EINTR);
 238         return (err);
 239 }
 240
 241 int
 242 dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin,
 243     struct file *fp, offset_t *off)
 244 {
 245         dsl_dataset_t *ds = tosnap->os->os_dsl_dataset;
 246         dsl_dataset_t *fromds = fromsnap ? fromsnap->os->os_dsl_dataset : NULL;
 247         dmu_replay_record_t *drr;
 248         struct backuparg ba;
 249         int err;
 250         uint64_t fromtxg = 0;
 251
 252         /* tosnap must be a snapshot */
 253         if (ds->ds_phys->ds_next_snap_obj == 0)
 254                 return (EINVAL);
 255
 256         /* fromsnap must be an earlier snapshot from the same fs as tosnap */
 257         if (fromds && (ds->ds_dir != fromds->ds_dir ||
 258             fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg))
 259                 return (EXDEV);
 260
 261         if (fromorigin) {
 262                 dsl_pool_t *dp = ds->ds_dir->dd_pool;
 263
 264                 if (fromsnap)
 265                         return (EINVAL);
 266
 267                 if (dsl_dir_is_clone(ds->ds_dir)) {
 268                         rw_enter(&dp->dp_config_rwlock, RW_READER);
 269                         err = dsl_dataset_hold_obj(dp,
 270                             ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds);
 271                         rw_exit(&dp->dp_config_rwlock);
 272                         if (err)
 273                                 return (err);
 274                 } else {
 275                         fromorigin = B_FALSE;
 276                 }
 277         }
 278
 279
 280         drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP);
 281         drr->drr_type = DRR_BEGIN;
 282         drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC;
 283         drr->drr_u.drr_begin.drr_version = DMU_BACKUP_STREAM_VERSION;
 284         drr->drr_u.drr_begin.drr_creation_time =
 285             ds->ds_phys->ds_creation_time;
 286         drr->drr_u.drr_begin.drr_type = tosnap->os->os_phys->os_type;
 287         if (fromorigin)
 288                 drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE;
 289         drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid;
 290         if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET)
 291                 drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA;
 292
 293         if (fromds)
 294                 drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid;
 295         dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname);
 296
 297         if (fromds)
 298                 fromtxg = fromds->ds_phys->ds_creation_txg;
 299         if (fromorigin)
 300                 dsl_dataset_rele(fromds, FTAG);
 301
 302         ba.drr = drr;
 303         ba.td = curthread;
 304         ba.fp = fp;
 305         ba.os = tosnap;
 306         ba.off = off;
 307         ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0);
 308
 309         if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) {
 310                 kmem_free(drr, sizeof (dmu_replay_record_t));
 311                 return (ba.err);
 312         }
 313
 314         err = traverse_dsl_dataset(ds, fromtxg,
 315             ADVANCE_PRE | ADVANCE_HOLES | ADVANCE_DATA | ADVANCE_NOLOCK,
 316             backup_cb, &ba);
 317
 318         if (err) {
 319                 if (err == EINTR && ba.err)
 320                         err = ba.err;
 321                 kmem_free(drr, sizeof (dmu_replay_record_t));
 322                 return (err);
 323         }
 324
 325         bzero(drr, sizeof (dmu_replay_record_t));
 326         drr->drr_type = DRR_END;
 327         drr->drr_u.drr_end.drr_checksum = ba.zc;
 328
 329         if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) {
 330                 kmem_free(drr, sizeof (dmu_replay_record_t));
 331                 return (ba.err);
 332         }
 333
 334         kmem_free(drr, sizeof (dmu_replay_record_t));
 335
 336         return (0);
 337 }
 338
 339 struct recvbeginsyncarg {
 340         const char *tofs;
 341         const char *tosnap;
 342         dsl_dataset_t *origin;
 343         uint64_t fromguid;
 344         dmu_objset_type_t type;
 345         void *tag;
 346         boolean_t force;
 347         uint64_t dsflags;
 348         char clonelastname[MAXNAMELEN];
 349         dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */
 350 };
 351
 352 static dsl_dataset_t *
 353 recv_full_sync_impl(dsl_pool_t *dp, uint64_t dsobj, dmu_objset_type_t type,
 354     cred_t *cr, dmu_tx_t *tx)
 355 {
 356         dsl_dataset_t *ds;
 357
 358         /* This should always work, since we just created it */
 359         /* XXX - create should return an owned ds */
 360         VERIFY(0 == dsl_dataset_own_obj(dp, dsobj,
 361             DS_MODE_INCONSISTENT, dmu_recv_tag, &ds));
 362
 363         if (type != DMU_OST_NONE) {
 364                 (void) dmu_objset_create_impl(dp->dp_spa,
 365                     ds, &ds->ds_phys->ds_bp, type, tx);
 366         }
 367
 368         spa_history_internal_log(LOG_DS_REPLAY_FULL_SYNC,
 369             dp->dp_spa, tx, cr, "dataset = %lld", dsobj);
 370
 371         return (ds);
 372 }
 373
 374 /* ARGSUSED */
 375 static int
 376 recv_full_check(void *arg1, void *arg2, dmu_tx_t *tx)
 377 {
 378         dsl_dir_t *dd = arg1;
 379         struct recvbeginsyncarg *rbsa = arg2;
 380         objset_t *mos = dd->dd_pool->dp_meta_objset;
 381         uint64_t val;
 382         int err;
 383
 384         err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj,
 385             strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val);
 386
 387         if (err != ENOENT)
 388                 return (err ? err : EEXIST);
 389
 390         if (rbsa->origin) {
 391                 /* make sure it's a snap in the same pool */
 392                 if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool)
 393                         return (EXDEV);
 394                 if (rbsa->origin->ds_phys->ds_num_children == 0)
 395                         return (EINVAL);
 396                 if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid)
 397                         return (ENODEV);
 398         }
 399
 400         return (0);
 401 }
 402
 403 static void
 404 recv_full_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
 405 {
 406         dsl_dir_t *dd = arg1;
 407         struct recvbeginsyncarg *rbsa = arg2;
 408         uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags;
 409         uint64_t dsobj;
 410
 411         dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1,
 412             rbsa->origin, flags, cr, tx);
 413
 414         rbsa->ds = recv_full_sync_impl(dd->dd_pool, dsobj,
 415             rbsa->origin ? DMU_OST_NONE : rbsa->type, cr, tx);
 416 }
 417
 418 static int
 419 recv_full_existing_check(void *arg1, void *arg2, dmu_tx_t *tx)
 420 {
 421         dsl_dataset_t *ds = arg1;
 422         struct recvbeginsyncarg *rbsa = arg2;
 423         int err;
 424
 425         /* must be a head ds */
 426         if (ds->ds_phys->ds_next_snap_obj != 0)
 427                 return (EINVAL);
 428
 429         /* must not be a clone ds */
 430         if (dsl_dir_is_clone(ds->ds_dir))
 431                 return (EINVAL);
 432
 433         err = dsl_dataset_destroy_check(ds, rbsa->tag, tx);
 434         if (err)
 435                 return (err);
 436
 437         if (rbsa->origin) {
 438                 /* make sure it's a snap in the same pool */
 439                 if (rbsa->origin->ds_dir->dd_pool != ds->ds_dir->dd_pool)
 440                         return (EXDEV);
 441                 if (rbsa->origin->ds_phys->ds_num_children == 0)
 442                         return (EINVAL);
 443                 if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid)
 444                         return (ENODEV);
 445         }
 446
 447         return (0);
 448 }
 449
 450 static void
 451 recv_full_existing_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
 452 {
 453         dsl_dataset_t *ds = arg1;
 454         struct recvbeginsyncarg *rbsa = arg2;
 455         dsl_dir_t *dd = ds->ds_dir;
 456         uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags;
 457         uint64_t dsobj;
 458
 459         /*
 460          * NB: caller must provide an extra hold on the dsl_dir_t, so it
 461          * won't go away when dsl_dataset_destroy_sync() closes the
 462          * dataset.
 463          */
 464         dsl_dataset_destroy_sync(ds, rbsa->tag, cr, tx);
 465
 466         dsobj = dsl_dataset_create_sync_dd(dd, rbsa->origin, flags, tx);
 467
 468         rbsa->ds = recv_full_sync_impl(dd->dd_pool, dsobj,
 469             rbsa->origin ? DMU_OST_NONE : rbsa->type, cr, tx);
 470 }
 471
 472 /* ARGSUSED */
 473 static int
 474 recv_incremental_check(void *arg1, void *arg2, dmu_tx_t *tx)
 475 {
 476         dsl_dataset_t *ds = arg1;
 477         struct recvbeginsyncarg *rbsa = arg2;
 478         int err;
 479         uint64_t val;
 480
 481         /* must not have any changes since most recent snapshot */
 482         if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds))
 483                 return (ETXTBSY);
 484
 485         /* must already be a snapshot of this fs */
 486         if (ds->ds_phys->ds_prev_snap_obj == 0)
 487                 return (ENODEV);
 488
 489         /* most recent snapshot must match fromguid */
 490         if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid)
 491                 return (ENODEV);
 492
 493         /* temporary clone name must not exist */
 494         err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset,
 495             ds->ds_dir->dd_phys->dd_child_dir_zapobj,
 496             rbsa->clonelastname, 8, 1, &val);
 497         if (err == 0)
 498                 return (EEXIST);
 499         if (err != ENOENT)
 500                 return (err);
 501
 502         /* new snapshot name must not exist */
 503         err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset,
 504             ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val);
 505         if (err == 0)
 506                 return (EEXIST);
 507         if (err != ENOENT)
 508                 return (err);
 509         return (0);
 510 }
 511
 512 /* ARGSUSED */
 513 static void
 514 recv_online_incremental_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
 515 {
 516         dsl_dataset_t *ohds = arg1;
 517         struct recvbeginsyncarg *rbsa = arg2;
 518         dsl_pool_t *dp = ohds->ds_dir->dd_pool;
 519         dsl_dataset_t *ods, *cds;
 520         uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags;
 521         uint64_t dsobj;
 522
 523         /* create the temporary clone */
 524         VERIFY(0 == dsl_dataset_hold_obj(dp, ohds->ds_phys->ds_prev_snap_obj,
 525             FTAG, &ods));
 526         dsobj = dsl_dataset_create_sync(ohds->ds_dir,
 527             rbsa->clonelastname, ods, flags, cr, tx);
 528         dsl_dataset_rele(ods, FTAG);
 529
 530         /* open the temporary clone */
 531         VERIFY(0 == dsl_dataset_own_obj(dp, dsobj,
 532             DS_MODE_INCONSISTENT, dmu_recv_tag, &cds));
 533
 534         /* copy the refquota from the target fs to the clone */
 535         if (ohds->ds_quota > 0)
 536                 dsl_dataset_set_quota_sync(cds, &ohds->ds_quota, cr, tx);
 537
 538         rbsa->ds = cds;
 539
 540         spa_history_internal_log(LOG_DS_REPLAY_INC_SYNC,
 541             dp->dp_spa, tx, cr, "dataset = %lld", dsobj);
 542 }
 543
 544 /* ARGSUSED */
 545 static void
 546 recv_offline_incremental_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
 547 {
 548         dsl_dataset_t *ds = arg1;
 549
 550         dmu_buf_will_dirty(ds->ds_dbuf, tx);
 551         ds->ds_phys->ds_flags |= DS_FLAG_INCONSISTENT;
 552
 553         spa_history_internal_log(LOG_DS_REPLAY_INC_SYNC,
 554             ds->ds_dir->dd_pool->dp_spa, tx, cr, "dataset = %lld",
 555             ds->ds_object);
 556 }
 557
 558 /*
 559  * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin()
 560  * succeeds; otherwise we will leak the holds on the datasets.
 561  */
 562 int
 563 dmu_recv_begin(char *tofs, char *tosnap, struct drr_begin *drrb,
 564     boolean_t force, objset_t *origin, boolean_t online, dmu_recv_cookie_t *drc)
 565 {
 566         int err = 0;
 567         boolean_t byteswap;
 568         struct recvbeginsyncarg rbsa;
 569         uint64_t version;
 570         int flags;
 571         dsl_dataset_t *ds;
 572
 573         if (drrb->drr_magic == DMU_BACKUP_MAGIC)
 574                 byteswap = FALSE;
 575         else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC))
 576                 byteswap = TRUE;
 577         else
 578                 return (EINVAL);
 579
 580         rbsa.tofs = tofs;
 581         rbsa.tosnap = tosnap;
 582         rbsa.origin = origin ? origin->os->os_dsl_dataset : NULL;
 583         rbsa.fromguid = drrb->drr_fromguid;
 584         rbsa.type = drrb->drr_type;
 585         rbsa.tag = FTAG;
 586         rbsa.dsflags = 0;
 587         version = drrb->drr_version;
 588         flags = drrb->drr_flags;
 589
 590         if (byteswap) {
 591                 rbsa.type = BSWAP_32(rbsa.type);
 592                 rbsa.fromguid = BSWAP_64(rbsa.fromguid);
 593                 version = BSWAP_64(version);
 594                 flags = BSWAP_32(flags);
 595         }
 596
 597         if (version != DMU_BACKUP_STREAM_VERSION ||
 598             rbsa.type >= DMU_OST_NUMTYPES ||
 599             ((flags & DRR_FLAG_CLONE) && origin == NULL))
 600                 return (EINVAL);
 601
 602         if (flags & DRR_FLAG_CI_DATA)
 603                 rbsa.dsflags = DS_FLAG_CI_DATASET;
 604
 605         bzero(drc, sizeof (dmu_recv_cookie_t));
 606         drc->drc_drrb = drrb;
 607         drc->drc_tosnap = tosnap;
 608         drc->drc_force = force;
 609
 610         /*
 611          * Process the begin in syncing context.
 612          */
 613         if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE) && !online) {
 614                 /* offline incremental receive */
 615                 err = dsl_dataset_own(tofs, 0, dmu_recv_tag, &ds);
 616                 if (err)
 617                         return (err);
 618
 619                 /*
 620                  * Only do the rollback if the most recent snapshot
 621                  * matches the incremental source
 622                  */
 623                 if (force) {
 624                         if (ds->ds_prev == NULL ||
 625                             ds->ds_prev->ds_phys->ds_guid !=
 626                             rbsa.fromguid) {
 627                                 dsl_dataset_disown(ds, dmu_recv_tag);
 628                                 return (ENODEV);
 629                         }
 630                         (void) dsl_dataset_rollback(ds, DMU_OST_NONE);
 631                 }
 632                 rbsa.force = B_FALSE;
 633                 err = dsl_sync_task_do(ds->ds_dir->dd_pool,
 634                     recv_incremental_check,
 635                     recv_offline_incremental_sync, ds, &rbsa, 1);
 636                 if (err) {
 637                         dsl_dataset_disown(ds, dmu_recv_tag);
 638                         return (err);
 639                 }
 640                 drc->drc_logical_ds = drc->drc_real_ds = ds;
 641         } else if (rbsa.fromguid && !(flags & DRR_FLAG_CLONE)) {
 642                 /* online incremental receive */
 643
 644                 /* tmp clone name is: tofs/%tosnap" */
 645                 (void) snprintf(rbsa.clonelastname, sizeof (rbsa.clonelastname),
 646                     "%%%s", tosnap);
 647
 648                 /* open the dataset we are logically receiving into */
 649                 err = dsl_dataset_hold(tofs, dmu_recv_tag, &ds);
 650                 if (err)
 651                         return (err);
 652
 653                 rbsa.force = force;
 654                 err = dsl_sync_task_do(ds->ds_dir->dd_pool,
 655                     recv_incremental_check,
 656                     recv_online_incremental_sync, ds, &rbsa, 5);
 657                 if (err) {
 658                         dsl_dataset_rele(ds, dmu_recv_tag);
 659                         return (err);
 660                 }
 661                 drc->drc_logical_ds = ds;
 662                 drc->drc_real_ds = rbsa.ds;
 663         } else {
 664                 /* create new fs -- full backup or clone */
 665                 dsl_dir_t *dd = NULL;
 666                 const char *tail;
 667
 668                 err = dsl_dir_open(tofs, FTAG, &dd, &tail);
 669                 if (err)
 670                         return (err);
 671                 if (tail == NULL) {
 672                         if (!force) {
 673                                 dsl_dir_close(dd, FTAG);
 674                                 return (EEXIST);
 675                         }
 676
 677                         rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
 678                         err = dsl_dataset_own_obj(dd->dd_pool,
 679                             dd->dd_phys->dd_head_dataset_obj,
 680                             DS_MODE_INCONSISTENT, FTAG, &ds);
 681                         rw_exit(&dd->dd_pool->dp_config_rwlock);
 682                         if (err) {
 683                                 dsl_dir_close(dd, FTAG);
 684                                 return (err);
 685                         }
 686
 687                         dsl_dataset_make_exclusive(ds, FTAG);
 688                         err = dsl_sync_task_do(dd->dd_pool,
 689                             recv_full_existing_check,
 690                             recv_full_existing_sync, ds, &rbsa, 5);
 691                         dsl_dataset_disown(ds, FTAG);
 692                 } else {
 693                         err = dsl_sync_task_do(dd->dd_pool, recv_full_check,
 694                             recv_full_sync, dd, &rbsa, 5);
 695                 }
 696                 dsl_dir_close(dd, FTAG);
 697                 if (err)
 698                         return (err);
 699                 drc->drc_logical_ds = drc->drc_real_ds = rbsa.ds;
 700                 drc->drc_newfs = B_TRUE;
 701         }
 702
 703         return (0);
 704 }
 705
 706 struct restorearg {
 707         int err;
 708         int byteswap;
 709         kthread_t *td;
 710         struct file *fp;
 711         char *buf;
 712         uint64_t voff;
 713         int bufsize; /* amount of memory allocated for buf */
 714         zio_cksum_t cksum;
 715 };
 716
 717 static int
 718 restore_bytes(struct restorearg *ra, void *buf, int len, off_t off, int *resid)
 719 {
 720         struct uio auio;
 721         struct iovec aiov;
 722         int error;
 723
 724         aiov.iov_base = buf;
 725         aiov.iov_len = len;
 726         auio.uio_iov = &aiov;
 727         auio.uio_iovcnt = 1;
 728         auio.uio_resid = len;
 729         auio.uio_segflg = UIO_SYSSPACE;
 730         auio.uio_rw = UIO_READ;
 731         auio.uio_offset = off;
 732         auio.uio_td = ra->td;
 733 #ifdef _KERNEL
 734         error = fo_read(ra->fp, &auio, ra->td->td_ucred, FOF_OFFSET, ra->td);
 735 #else
 736         fprintf(stderr, "%s: returning EOPNOTSUPP\n", __func__);
 737         error = EOPNOTSUPP;
 738 #endif
 739         *resid = auio.uio_resid;
 740         return (error);
 741 }
 742
 743 static void *
 744 restore_read(struct restorearg *ra, int len)
 745 {
 746         void *rv;
 747         int done = 0;
 748
 749         /* some things will require 8-byte alignment, so everything must */
 750         ASSERT3U(len % 8, ==, 0);
 751
 752         while (done < len) {
 753                 int resid;
 754
 755                 ra->err = restore_bytes(ra, (caddr_t)ra->buf + done,
 756                     len - done, ra->voff, &resid);
 757
 758                 if (resid == len - done)
 759                         ra->err = EINVAL;
 760                 ra->voff += len - done - resid;
 761                 done = len - resid;
 762                 if (ra->err)
 763                         return (NULL);
 764         }
 765
 766         ASSERT3U(done, ==, len);
 767         rv = ra->buf;
 768         if (ra->byteswap)
 769                 fletcher_4_incremental_byteswap(rv, len, &ra->cksum);
 770         else
 771                 fletcher_4_incremental_native(rv, len, &ra->cksum);
 772         return (rv);
 773 }
 774
 775 static void
 776 backup_byteswap(dmu_replay_record_t *drr)
 777 {
 778 #define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X))
 779 #define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X))
 780         drr->drr_type = BSWAP_32(drr->drr_type);
 781         drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen);
 782         switch (drr->drr_type) {
 783         case DRR_BEGIN:
 784                 DO64(drr_begin.drr_magic);
 785                 DO64(drr_begin.drr_version);
 786                 DO64(drr_begin.drr_creation_time);
 787                 DO32(drr_begin.drr_type);
 788                 DO32(drr_begin.drr_flags);
 789                 DO64(drr_begin.drr_toguid);
 790                 DO64(drr_begin.drr_fromguid);
 791                 break;
 792         case DRR_OBJECT:
 793                 DO64(drr_object.drr_object);
 794                 /* DO64(drr_object.drr_allocation_txg); */
 795                 DO32(drr_object.drr_type);
 796                 DO32(drr_object.drr_bonustype);
 797                 DO32(drr_object.drr_blksz);
 798                 DO32(drr_object.drr_bonuslen);
 799                 break;
 800         case DRR_FREEOBJECTS:
 801                 DO64(drr_freeobjects.drr_firstobj);
 802                 DO64(drr_freeobjects.drr_numobjs);
 803                 break;
 804         case DRR_WRITE:
 805                 DO64(drr_write.drr_object);
 806                 DO32(drr_write.drr_type);
 807                 DO64(drr_write.drr_offset);
 808                 DO64(drr_write.drr_length);
 809                 break;
 810         case DRR_FREE:
 811                 DO64(drr_free.drr_object);
 812                 DO64(drr_free.drr_offset);
 813                 DO64(drr_free.drr_length);
 814                 break;
 815         case DRR_END:
 816                 DO64(drr_end.drr_checksum.zc_word[0]);
 817                 DO64(drr_end.drr_checksum.zc_word[1]);
 818                 DO64(drr_end.drr_checksum.zc_word[2]);
 819                 DO64(drr_end.drr_checksum.zc_word[3]);
 820                 break;
 821         }
 822 #undef DO64
 823 #undef DO32
 824 }
 825
 826 static int
 827 restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro)
 828 {
 829         int err;
 830         dmu_tx_t *tx;
 831
 832         err = dmu_object_info(os, drro->drr_object, NULL);
 833
 834         if (err != 0 && err != ENOENT)
 835                 return (EINVAL);
 836
 837         if (drro->drr_type == DMU_OT_NONE ||
 838             drro->drr_type >= DMU_OT_NUMTYPES ||
 839             drro->drr_bonustype >= DMU_OT_NUMTYPES ||
 840             drro->drr_checksum >= ZIO_CHECKSUM_FUNCTIONS ||
 841             drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS ||
 842             P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) ||
 843             drro->drr_blksz < SPA_MINBLOCKSIZE ||
 844             drro->drr_blksz > SPA_MAXBLOCKSIZE ||
 845             drro->drr_bonuslen > DN_MAX_BONUSLEN) {
 846                 return (EINVAL);
 847         }
 848
 849         tx = dmu_tx_create(os);
 850
 851         if (err == ENOENT) {
 852                 /* currently free, want to be allocated */
 853                 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
 854                 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 1);
 855                 err = dmu_tx_assign(tx, TXG_WAIT);
 856                 if (err) {
 857                         dmu_tx_abort(tx);
 858                         return (err);
 859                 }
 860                 err = dmu_object_claim(os, drro->drr_object,
 861                     drro->drr_type, drro->drr_blksz,
 862                     drro->drr_bonustype, drro->drr_bonuslen, tx);
 863         } else {
 864                 /* currently allocated, want to be allocated */
 865                 dmu_tx_hold_bonus(tx, drro->drr_object);
 866                 /*
 867                  * We may change blocksize and delete old content,
 868                  * so need to hold_write and hold_free.
 869                  */
 870                 dmu_tx_hold_write(tx, drro->drr_object, 0, 1);
 871                 dmu_tx_hold_free(tx, drro->drr_object, 0, DMU_OBJECT_END);
 872                 err = dmu_tx_assign(tx, TXG_WAIT);
 873                 if (err) {
 874                         dmu_tx_abort(tx);
 875                         return (err);
 876                 }
 877
 878                 err = dmu_object_reclaim(os, drro->drr_object,
 879                     drro->drr_type, drro->drr_blksz,
 880                     drro->drr_bonustype, drro->drr_bonuslen, tx);
 881         }
 882         if (err) {
 883                 dmu_tx_commit(tx);
 884                 return (EINVAL);
 885         }
 886
 887         dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksum, tx);
 888         dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx);
 889
 890         if (drro->drr_bonuslen) {
 891                 dmu_buf_t *db;
 892                 void *data;
 893                 VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db));
 894                 dmu_buf_will_dirty(db, tx);
 895
 896                 ASSERT3U(db->db_size, >=, drro->drr_bonuslen);
 897                 data = restore_read(ra, P2ROUNDUP(drro->drr_bonuslen, 8));
 898                 if (data == NULL) {
 899                         dmu_tx_commit(tx);
 900                         return (ra->err);
 901                 }
 902                 bcopy(data, db->db_data, drro->drr_bonuslen);
 903                 if (ra->byteswap) {
 904                         dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data,
 905                             drro->drr_bonuslen);
 906                 }
 907                 dmu_buf_rele(db, FTAG);
 908         }
 909         dmu_tx_commit(tx);
 910         return (0);
 911 }
 912
 913 /* ARGSUSED */
 914 static int
 915 restore_freeobjects(struct restorearg *ra, objset_t *os,
 916     struct drr_freeobjects *drrfo)
 917 {
 918         uint64_t obj;
 919
 920         if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj)
 921                 return (EINVAL);
 922
 923         for (obj = drrfo->drr_firstobj;
 924             obj < drrfo->drr_firstobj + drrfo->drr_numobjs;
 925             (void) dmu_object_next(os, &obj, FALSE, 0)) {
 926                 int err;
 927
 928                 if (dmu_object_info(os, obj, NULL) != 0)
 929                         continue;
 930
 931                 err = dmu_free_object(os, obj);
 932                 if (err)
 933                         return (err);
 934         }
 935         return (0);
 936 }
 937
 938 static int
 939 restore_write(struct restorearg *ra, objset_t *os,
 940     struct drr_write *drrw)
 941 {
 942         dmu_tx_t *tx;
 943         void *data;
 944         int err;
 945
 946         if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset ||
 947             drrw->drr_type >= DMU_OT_NUMTYPES)
 948                 return (EINVAL);
 949
 950         data = restore_read(ra, drrw->drr_length);
 951         if (data == NULL)
 952                 return (ra->err);
 953
 954         if (dmu_object_info(os, drrw->drr_object, NULL) != 0)
 955                 return (EINVAL);
 956
 957         tx = dmu_tx_create(os);
 958
 959         dmu_tx_hold_write(tx, drrw->drr_object,
 960             drrw->drr_offset, drrw->drr_length);
 961         err = dmu_tx_assign(tx, TXG_WAIT);
 962         if (err) {
 963                 dmu_tx_abort(tx);
 964                 return (err);
 965         }
 966         if (ra->byteswap)
 967                 dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length);
 968         dmu_write(os, drrw->drr_object,
 969             drrw->drr_offset, drrw->drr_length, data, tx);
 970         dmu_tx_commit(tx);
 971         return (0);
 972 }
 973
 974 /* ARGSUSED */
 975 static int
 976 restore_free(struct restorearg *ra, objset_t *os,
 977     struct drr_free *drrf)
 978 {
 979         int err;
 980
 981         if (drrf->drr_length != -1ULL &&
 982             drrf->drr_offset + drrf->drr_length < drrf->drr_offset)
 983                 return (EINVAL);
 984
 985         if (dmu_object_info(os, drrf->drr_object, NULL) != 0)
 986                 return (EINVAL);
 987
 988         err = dmu_free_long_range(os, drrf->drr_object,
 989             drrf->drr_offset, drrf->drr_length);
 990         return (err);
 991 }
 992
 993 void
 994 dmu_recv_abort_cleanup(dmu_recv_cookie_t *drc)
 995 {
 996         if (drc->drc_newfs || drc->drc_real_ds != drc->drc_logical_ds) {
 997                 /*
 998                  * online incremental or new fs: destroy the fs (which
 999                  * may be a clone) that we created
1000                  */
1001                 (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag);
1002                 if (drc->drc_real_ds != drc->drc_logical_ds)
1003                         dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag);
1004         } else {
1005                 /*
1006                  * offline incremental: rollback to most recent snapshot.
1007                  */
1008                 (void) dsl_dataset_rollback(drc->drc_real_ds, DMU_OST_NONE);
1009                 dsl_dataset_disown(drc->drc_real_ds, dmu_recv_tag);
1010         }
1011 }
1012
1013 /*
1014  * NB: callers *must* call dmu_recv_end() if this succeeds.
1015  */
1016 int
1017 dmu_recv_stream(dmu_recv_cookie_t *drc, struct file *fp, offset_t *voffp)
1018 {
1019         kthread_t *td = curthread;
1020         struct restorearg ra = { 0 };
1021         dmu_replay_record_t *drr;
1022         objset_t *os;
1023         zio_cksum_t pcksum;
1024
1025         if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC))
1026                 ra.byteswap = TRUE;
1027
1028         {
1029                 /* compute checksum of drr_begin record */
1030                 dmu_replay_record_t *drr;
1031                 drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP);
1032
1033                 drr->drr_type = DRR_BEGIN;
1034                 drr->drr_u.drr_begin = *drc->drc_drrb;
1035                 if (ra.byteswap) {
1036                         fletcher_4_incremental_byteswap(drr,
1037                             sizeof (dmu_replay_record_t), &ra.cksum);
1038                 } else {
1039                         fletcher_4_incremental_native(drr,
1040                             sizeof (dmu_replay_record_t), &ra.cksum);
1041                 }
1042                 kmem_free(drr, sizeof (dmu_replay_record_t));
1043         }
1044
1045         if (ra.byteswap) {
1046                 struct drr_begin *drrb = drc->drc_drrb;
1047                 drrb->drr_magic = BSWAP_64(drrb->drr_magic);
1048                 drrb->drr_version = BSWAP_64(drrb->drr_version);
1049                 drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time);
1050                 drrb->drr_type = BSWAP_32(drrb->drr_type);
1051                 drrb->drr_toguid = BSWAP_64(drrb->drr_toguid);
1052                 drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid);
1053         }
1054
1055         ra.td = td;
1056         ra.fp = fp;
1057         ra.voff = *voffp;
1058         ra.bufsize = 1<<20;
1059         ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP);
1060
1061         /* these were verified in dmu_recv_begin */
1062         ASSERT(drc->drc_drrb->drr_version == DMU_BACKUP_STREAM_VERSION);
1063         ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES);
1064
1065         /*
1066          * Open the objset we are modifying.
1067          */
1068         VERIFY(dmu_objset_open_ds(drc->drc_real_ds, DMU_OST_ANY, &os) == 0);
1069
1070         ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT);
1071
1072         /*
1073          * Read records and process them.
1074          */
1075         pcksum = ra.cksum;
1076         while (ra.err == 0 &&
1077             NULL != (drr = restore_read(&ra, sizeof (*drr)))) {
1078                 if (issig(JUSTLOOKING) && issig(FORREAL)) {
1079                         ra.err = EINTR;
1080                         goto out;
1081                 }
1082
1083                 if (ra.byteswap)
1084                         backup_byteswap(drr);
1085
1086                 switch (drr->drr_type) {
1087                 case DRR_OBJECT:
1088                 {
1089                         /*
1090                          * We need to make a copy of the record header,
1091                          * because restore_{object,write} may need to
1092                          * restore_read(), which will invalidate drr.
1093                          */
1094                         struct drr_object drro = drr->drr_u.drr_object;
1095                         ra.err = restore_object(&ra, os, &drro);
1096                         break;
1097                 }
1098                 case DRR_FREEOBJECTS:
1099                 {
1100                         struct drr_freeobjects drrfo =
1101                             drr->drr_u.drr_freeobjects;
1102                         ra.err = restore_freeobjects(&ra, os, &drrfo);
1103                         break;
1104                 }
1105                 case DRR_WRITE:
1106                 {
1107                         struct drr_write drrw = drr->drr_u.drr_write;
1108                         ra.err = restore_write(&ra, os, &drrw);
1109                         break;
1110                 }
1111                 case DRR_FREE:
1112                 {
1113                         struct drr_free drrf = drr->drr_u.drr_free;
1114                         ra.err = restore_free(&ra, os, &drrf);
1115                         break;
1116                 }
1117                 case DRR_END:
1118                 {
1119                         struct drr_end drre = drr->drr_u.drr_end;
1120                         /*
1121                          * We compare against the *previous* checksum
1122                          * value, because the stored checksum is of
1123                          * everything before the DRR_END record.
1124                          */
1125                         if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum))
1126                                 ra.err = ECKSUM;
1127                         goto out;
1128                 }
1129                 default:
1130                         ra.err = EINVAL;
1131                         goto out;
1132                 }
1133                 pcksum = ra.cksum;
1134         }
1135         ASSERT(ra.err != 0);
1136
1137 out:
1138         dmu_objset_close(os);
1139
1140         if (ra.err != 0) {
1141                 /*
1142                  * rollback or destroy what we created, so we don't
1143                  * leave it in the restoring state.
1144                  */
1145                 txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0);
1146                 dmu_recv_abort_cleanup(drc);
1147         }
1148
1149         kmem_free(ra.buf, ra.bufsize);
1150         *voffp = ra.voff;
1151         return (ra.err);
1152 }
1153
1154 struct recvendsyncarg {
1155         char *tosnap;
1156         uint64_t creation_time;
1157         uint64_t toguid;
1158 };
1159
1160 static int
1161 recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx)
1162 {
1163         dsl_dataset_t *ds = arg1;
1164         struct recvendsyncarg *resa = arg2;
1165
1166         return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx));
1167 }
1168
1169 static void
1170 recv_end_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
1171 {
1172         dsl_dataset_t *ds = arg1;
1173         struct recvendsyncarg *resa = arg2;
1174
1175         dsl_dataset_snapshot_sync(ds, resa->tosnap, cr, tx);
1176
1177         /* set snapshot's creation time and guid */
1178         dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
1179         ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time;
1180         ds->ds_prev->ds_phys->ds_guid = resa->toguid;
1181         ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT;
1182
1183         dmu_buf_will_dirty(ds->ds_dbuf, tx);
1184         ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT;
1185 }
1186
1187 int
1188 dmu_recv_end(dmu_recv_cookie_t *drc)
1189 {
1190         struct recvendsyncarg resa;
1191         dsl_dataset_t *ds = drc->drc_logical_ds;
1192         int err;
1193
1194         /*
1195          * XXX hack; seems the ds is still dirty and
1196          * dsl_pool_zil_clean() expects it to have a ds_user_ptr
1197          * (and zil), but clone_swap() can close it.
1198          */
1199         txg_wait_synced(ds->ds_dir->dd_pool, 0);
1200
1201         if (ds != drc->drc_real_ds) {
1202                 /* we are doing an online recv */
1203                 if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) {
1204                         err = dsl_dataset_clone_swap(drc->drc_real_ds, ds,
1205                             drc->drc_force);
1206                         if (err)
1207                                 dsl_dataset_disown(ds, dmu_recv_tag);
1208                 } else {
1209                         err = EBUSY;
1210                         dsl_dataset_rele(ds, dmu_recv_tag);
1211                 }
1212                 /* dsl_dataset_destroy() will disown the ds */
1213                 (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag);
1214                 if (err)
1215                         return (err);
1216         }
1217
1218         resa.creation_time = drc->drc_drrb->drr_creation_time;
1219         resa.toguid = drc->drc_drrb->drr_toguid;
1220         resa.tosnap = drc->drc_tosnap;
1221
1222         err = dsl_sync_task_do(ds->ds_dir->dd_pool,
1223             recv_end_check, recv_end_sync, ds, &resa, 3);
1224         if (err) {
1225                 if (drc->drc_newfs) {
1226                         ASSERT(ds == drc->drc_real_ds);
1227                         (void) dsl_dataset_destroy(ds, dmu_recv_tag);
1228                         return (err);
1229                 } else {
1230                         (void) dsl_dataset_rollback(ds, DMU_OST_NONE);
1231                 }
1232         }
1233
1234         /* release the hold from dmu_recv_begin */
1235         dsl_dataset_disown(ds, dmu_recv_tag);
1236         return (err);
1237 }