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 2008 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 err = dmu_object_info(os, drro->drr_object, NULL); 779 780 if (err != 0 && err != ENOENT) 781 return (EINVAL); 782 783 if (drro->drr_type == DMU_OT_NONE || 784 drro->drr_type >= DMU_OT_NUMTYPES || 785 drro->drr_bonustype >= DMU_OT_NUMTYPES || 786 drro->drr_checksum >= ZIO_CHECKSUM_FUNCTIONS || 787 drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS || 788 P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) || 789 drro->drr_blksz < SPA_MINBLOCKSIZE || 790 drro->drr_blksz > SPA_MAXBLOCKSIZE || 791 drro->drr_bonuslen > DN_MAX_BONUSLEN) { 792 return (EINVAL); 793 } 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 tx = dmu_tx_create(os); 802 803 if (err == ENOENT) { 804 /* currently free, want to be allocated */ 805 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 806 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 1); 807 err = dmu_tx_assign(tx, TXG_WAIT); 808 if (err) { 809 dmu_tx_abort(tx); 810 return (err); 811 } 812 err = dmu_object_claim(os, drro->drr_object, 813 drro->drr_type, drro->drr_blksz, 814 drro->drr_bonustype, drro->drr_bonuslen, tx); 815 } else { 816 /* currently allocated, want to be allocated */ 817 dmu_tx_hold_bonus(tx, drro->drr_object); 818 /* 819 * We may change blocksize, so need to 820 * hold_write 821 */ 822 dmu_tx_hold_write(tx, drro->drr_object, 0, 1); 823 err = dmu_tx_assign(tx, TXG_WAIT); 824 if (err) { 825 dmu_tx_abort(tx); 826 return (err); 827 } 828 829 err = dmu_object_reclaim(os, drro->drr_object, 830 drro->drr_type, drro->drr_blksz, 831 drro->drr_bonustype, drro->drr_bonuslen, tx); 832 } 833 if (err) { 834 dmu_tx_commit(tx); 835 return (EINVAL); 836 } 837 838 dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksum, tx); 839 dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx); 840 841 if (data != NULL) { 842 dmu_buf_t *db; 843 844 VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db)); 845 dmu_buf_will_dirty(db, tx); 846 847 ASSERT3U(db->db_size, >=, drro->drr_bonuslen); 848 bcopy(data, db->db_data, drro->drr_bonuslen); 849 if (ra->byteswap) { 850 dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data, 851 drro->drr_bonuslen); 852 } 853 dmu_buf_rele(db, FTAG); 854 } 855 dmu_tx_commit(tx); 856 return (0); 857 } 858 859 /* ARGSUSED */ 860 static int 861 restore_freeobjects(struct restorearg *ra, objset_t *os, 862 struct drr_freeobjects *drrfo) 863 { 864 uint64_t obj; 865 866 if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj) 867 return (EINVAL); 868 869 for (obj = drrfo->drr_firstobj; 870 obj < drrfo->drr_firstobj + drrfo->drr_numobjs; 871 (void) dmu_object_next(os, &obj, FALSE, 0)) { 872 int err; 873 874 if (dmu_object_info(os, obj, NULL) != 0) 875 continue; 876 877 err = dmu_free_object(os, obj); 878 if (err) 879 return (err); 880 } 881 return (0); 882 } 883 884 static int 885 restore_write(struct restorearg *ra, objset_t *os, 886 struct drr_write *drrw) 887 { 888 dmu_tx_t *tx; 889 void *data; 890 int err; 891 892 if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset || 893 drrw->drr_type >= DMU_OT_NUMTYPES) 894 return (EINVAL); 895 896 data = restore_read(ra, drrw->drr_length); 897 if (data == NULL) 898 return (ra->err); 899 900 if (dmu_object_info(os, drrw->drr_object, NULL) != 0) 901 return (EINVAL); 902 903 tx = dmu_tx_create(os); 904 905 dmu_tx_hold_write(tx, drrw->drr_object, 906 drrw->drr_offset, drrw->drr_length); 907 err = dmu_tx_assign(tx, TXG_WAIT); 908 if (err) { 909 dmu_tx_abort(tx); 910 return (err); 911 } 912 if (ra->byteswap) 913 dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length); 914 dmu_write(os, drrw->drr_object, 915 drrw->drr_offset, drrw->drr_length, data, tx); 916 dmu_tx_commit(tx); 917 return (0); 918 } 919 920 /* ARGSUSED */ 921 static int 922 restore_free(struct restorearg *ra, objset_t *os, 923 struct drr_free *drrf) 924 { 925 int err; 926 927 if (drrf->drr_length != -1ULL && 928 drrf->drr_offset + drrf->drr_length < drrf->drr_offset) 929 return (EINVAL); 930 931 if (dmu_object_info(os, drrf->drr_object, NULL) != 0) 932 return (EINVAL); 933 934 err = dmu_free_long_range(os, drrf->drr_object, 935 drrf->drr_offset, drrf->drr_length); 936 return (err); 937 } 938 939 void 940 dmu_recv_abort_cleanup(dmu_recv_cookie_t *drc) 941 { 942 if (drc->drc_newfs || drc->drc_real_ds != drc->drc_logical_ds) { 943 /* 944 * online incremental or new fs: destroy the fs (which 945 * may be a clone) that we created 946 */ 947 (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag); 948 if (drc->drc_real_ds != drc->drc_logical_ds) 949 dsl_dataset_rele(drc->drc_logical_ds, dmu_recv_tag); 950 } else { 951 /* 952 * offline incremental: rollback to most recent snapshot. 953 */ 954 (void) dsl_dataset_rollback(drc->drc_real_ds, DMU_OST_NONE); 955 dsl_dataset_disown(drc->drc_real_ds, dmu_recv_tag); 956 } 957 } 958 959 /* 960 * NB: callers *must* call dmu_recv_end() if this succeeds. 961 */ 962 int 963 dmu_recv_stream(dmu_recv_cookie_t *drc, vnode_t *vp, offset_t *voffp) 964 { 965 struct restorearg ra = { 0 }; 966 dmu_replay_record_t *drr; 967 objset_t *os; 968 zio_cksum_t pcksum; 969 970 if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) 971 ra.byteswap = TRUE; 972 973 { 974 /* compute checksum of drr_begin record */ 975 dmu_replay_record_t *drr; 976 drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP); 977 978 drr->drr_type = DRR_BEGIN; 979 drr->drr_u.drr_begin = *drc->drc_drrb; 980 if (ra.byteswap) { 981 fletcher_4_incremental_byteswap(drr, 982 sizeof (dmu_replay_record_t), &ra.cksum); 983 } else { 984 fletcher_4_incremental_native(drr, 985 sizeof (dmu_replay_record_t), &ra.cksum); 986 } 987 kmem_free(drr, sizeof (dmu_replay_record_t)); 988 } 989 990 if (ra.byteswap) { 991 struct drr_begin *drrb = drc->drc_drrb; 992 drrb->drr_magic = BSWAP_64(drrb->drr_magic); 993 drrb->drr_version = BSWAP_64(drrb->drr_version); 994 drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time); 995 drrb->drr_type = BSWAP_32(drrb->drr_type); 996 drrb->drr_toguid = BSWAP_64(drrb->drr_toguid); 997 drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid); 998 } 999 1000 ra.vp = vp; 1001 ra.voff = *voffp; 1002 ra.bufsize = 1<<20; 1003 ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP); 1004 1005 /* these were verified in dmu_recv_begin */ 1006 ASSERT(drc->drc_drrb->drr_version == DMU_BACKUP_STREAM_VERSION); 1007 ASSERT(drc->drc_drrb->drr_type < DMU_OST_NUMTYPES); 1008 1009 /* 1010 * Open the objset we are modifying. 1011 */ 1012 VERIFY(dmu_objset_open_ds(drc->drc_real_ds, DMU_OST_ANY, &os) == 0); 1013 1014 ASSERT(drc->drc_real_ds->ds_phys->ds_flags & DS_FLAG_INCONSISTENT); 1015 1016 /* 1017 * Read records and process them. 1018 */ 1019 pcksum = ra.cksum; 1020 while (ra.err == 0 && 1021 NULL != (drr = restore_read(&ra, sizeof (*drr)))) { 1022 if (issig(JUSTLOOKING) && issig(FORREAL)) { 1023 ra.err = EINTR; 1024 goto out; 1025 } 1026 1027 if (ra.byteswap) 1028 backup_byteswap(drr); 1029 1030 switch (drr->drr_type) { 1031 case DRR_OBJECT: 1032 { 1033 /* 1034 * We need to make a copy of the record header, 1035 * because restore_{object,write} may need to 1036 * restore_read(), which will invalidate drr. 1037 */ 1038 struct drr_object drro = drr->drr_u.drr_object; 1039 ra.err = restore_object(&ra, os, &drro); 1040 break; 1041 } 1042 case DRR_FREEOBJECTS: 1043 { 1044 struct drr_freeobjects drrfo = 1045 drr->drr_u.drr_freeobjects; 1046 ra.err = restore_freeobjects(&ra, os, &drrfo); 1047 break; 1048 } 1049 case DRR_WRITE: 1050 { 1051 struct drr_write drrw = drr->drr_u.drr_write; 1052 ra.err = restore_write(&ra, os, &drrw); 1053 break; 1054 } 1055 case DRR_FREE: 1056 { 1057 struct drr_free drrf = drr->drr_u.drr_free; 1058 ra.err = restore_free(&ra, os, &drrf); 1059 break; 1060 } 1061 case DRR_END: 1062 { 1063 struct drr_end drre = drr->drr_u.drr_end; 1064 /* 1065 * We compare against the *previous* checksum 1066 * value, because the stored checksum is of 1067 * everything before the DRR_END record. 1068 */ 1069 if (!ZIO_CHECKSUM_EQUAL(drre.drr_checksum, pcksum)) 1070 ra.err = ECKSUM; 1071 goto out; 1072 } 1073 default: 1074 ra.err = EINVAL; 1075 goto out; 1076 } 1077 pcksum = ra.cksum; 1078 } 1079 ASSERT(ra.err != 0); 1080 1081 out: 1082 dmu_objset_close(os); 1083 1084 if (ra.err != 0) { 1085 /* 1086 * rollback or destroy what we created, so we don't 1087 * leave it in the restoring state. 1088 */ 1089 txg_wait_synced(drc->drc_real_ds->ds_dir->dd_pool, 0); 1090 dmu_recv_abort_cleanup(drc); 1091 } 1092 1093 kmem_free(ra.buf, ra.bufsize); 1094 *voffp = ra.voff; 1095 return (ra.err); 1096 } 1097 1098 struct recvendsyncarg { 1099 char *tosnap; 1100 uint64_t creation_time; 1101 uint64_t toguid; 1102 }; 1103 1104 static int 1105 recv_end_check(void *arg1, void *arg2, dmu_tx_t *tx) 1106 { 1107 dsl_dataset_t *ds = arg1; 1108 struct recvendsyncarg *resa = arg2; 1109 1110 return (dsl_dataset_snapshot_check(ds, resa->tosnap, tx)); 1111 } 1112 1113 static void 1114 recv_end_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 1115 { 1116 dsl_dataset_t *ds = arg1; 1117 struct recvendsyncarg *resa = arg2; 1118 1119 dsl_dataset_snapshot_sync(ds, resa->tosnap, cr, tx); 1120 1121 /* set snapshot's creation time and guid */ 1122 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx); 1123 ds->ds_prev->ds_phys->ds_creation_time = resa->creation_time; 1124 ds->ds_prev->ds_phys->ds_guid = resa->toguid; 1125 ds->ds_prev->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 1126 1127 dmu_buf_will_dirty(ds->ds_dbuf, tx); 1128 ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT; 1129 } 1130 1131 int 1132 dmu_recv_end(dmu_recv_cookie_t *drc) 1133 { 1134 struct recvendsyncarg resa; 1135 dsl_dataset_t *ds = drc->drc_logical_ds; 1136 int err; 1137 1138 /* 1139 * XXX hack; seems the ds is still dirty and 1140 * dsl_pool_zil_clean() expects it to have a ds_user_ptr 1141 * (and zil), but clone_swap() can close it. 1142 */ 1143 txg_wait_synced(ds->ds_dir->dd_pool, 0); 1144 1145 if (ds != drc->drc_real_ds) { 1146 /* we are doing an online recv */ 1147 if (dsl_dataset_tryown(ds, FALSE, dmu_recv_tag)) { 1148 err = dsl_dataset_clone_swap(drc->drc_real_ds, ds, 1149 drc->drc_force); 1150 if (err) 1151 dsl_dataset_disown(ds, dmu_recv_tag); 1152 } else { 1153 err = EBUSY; 1154 dsl_dataset_rele(ds, dmu_recv_tag); 1155 } 1156 /* dsl_dataset_destroy() will disown the ds */ 1157 (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag); 1158 if (err) 1159 return (err); 1160 } 1161 1162 resa.creation_time = drc->drc_drrb->drr_creation_time; 1163 resa.toguid = drc->drc_drrb->drr_toguid; 1164 resa.tosnap = drc->drc_tosnap; 1165 1166 err = dsl_sync_task_do(ds->ds_dir->dd_pool, 1167 recv_end_check, recv_end_sync, ds, &resa, 3); 1168 if (err) { 1169 if (drc->drc_newfs) { 1170 ASSERT(ds == drc->drc_real_ds); 1171 (void) dsl_dataset_destroy(ds, dmu_recv_tag); 1172 return (err); 1173 } else { 1174 (void) dsl_dataset_rollback(ds, DMU_OST_NONE); 1175 } 1176 } 1177 1178 /* release the hold from dmu_recv_begin */ 1179 dsl_dataset_disown(ds, dmu_recv_tag); 1180 return (err); 1181 } 1182