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