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