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 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/dsl_pool.h> 27 #include <sys/dsl_dataset.h> 28 #include <sys/dsl_dir.h> 29 #include <sys/dsl_synctask.h> 30 #include <sys/dmu_tx.h> 31 #include <sys/dmu_objset.h> 32 #include <sys/arc.h> 33 #include <sys/zap.h> 34 #include <sys/zio.h> 35 #include <sys/zfs_context.h> 36 #include <sys/fs/zfs.h> 37 #include <sys/zfs_znode.h> 38 #include <sys/spa_impl.h> 39 40 int zfs_no_write_throttle = 0; 41 int zfs_write_limit_shift = 3; /* 1/8th of physical memory */ 42 int zfs_txg_synctime_ms = 5000; /* target millisecs to sync a txg */ 43 44 uint64_t zfs_write_limit_min = 32 << 20; /* min write limit is 32MB */ 45 uint64_t zfs_write_limit_max = 0; /* max data payload per txg */ 46 uint64_t zfs_write_limit_inflated = 0; 47 uint64_t zfs_write_limit_override = 0; 48 49 kmutex_t zfs_write_limit_lock; 50 51 static pgcnt_t old_physmem = 0; 52 53 static int 54 dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **ddp) 55 { 56 uint64_t obj; 57 int err; 58 59 err = zap_lookup(dp->dp_meta_objset, 60 dp->dp_root_dir->dd_phys->dd_child_dir_zapobj, 61 name, sizeof (obj), 1, &obj); 62 if (err) 63 return (err); 64 65 return (dsl_dir_open_obj(dp, obj, name, dp, ddp)); 66 } 67 68 static dsl_pool_t * 69 dsl_pool_open_impl(spa_t *spa, uint64_t txg) 70 { 71 dsl_pool_t *dp; 72 blkptr_t *bp = spa_get_rootblkptr(spa); 73 74 dp = kmem_zalloc(sizeof (dsl_pool_t), KM_SLEEP); 75 dp->dp_spa = spa; 76 dp->dp_meta_rootbp = *bp; 77 rw_init(&dp->dp_config_rwlock, NULL, RW_DEFAULT, NULL); 78 dp->dp_write_limit = zfs_write_limit_min; 79 txg_init(dp, txg); 80 81 txg_list_create(&dp->dp_dirty_datasets, 82 offsetof(dsl_dataset_t, ds_dirty_link)); 83 txg_list_create(&dp->dp_dirty_dirs, 84 offsetof(dsl_dir_t, dd_dirty_link)); 85 txg_list_create(&dp->dp_sync_tasks, 86 offsetof(dsl_sync_task_group_t, dstg_node)); 87 list_create(&dp->dp_synced_datasets, sizeof (dsl_dataset_t), 88 offsetof(dsl_dataset_t, ds_synced_link)); 89 90 mutex_init(&dp->dp_lock, NULL, MUTEX_DEFAULT, NULL); 91 mutex_init(&dp->dp_scrub_cancel_lock, NULL, MUTEX_DEFAULT, NULL); 92 93 dp->dp_vnrele_taskq = taskq_create("zfs_vn_rele_taskq", 1, minclsyspri, 94 1, 4, 0); 95 96 return (dp); 97 } 98 99 int 100 dsl_pool_open(spa_t *spa, uint64_t txg, dsl_pool_t **dpp) 101 { 102 int err; 103 dsl_pool_t *dp = dsl_pool_open_impl(spa, txg); 104 dsl_dir_t *dd; 105 dsl_dataset_t *ds; 106 107 rw_enter(&dp->dp_config_rwlock, RW_WRITER); 108 err = dmu_objset_open_impl(spa, NULL, &dp->dp_meta_rootbp, 109 &dp->dp_meta_objset); 110 if (err) 111 goto out; 112 113 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 114 DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1, 115 &dp->dp_root_dir_obj); 116 if (err) 117 goto out; 118 119 err = dsl_dir_open_obj(dp, dp->dp_root_dir_obj, 120 NULL, dp, &dp->dp_root_dir); 121 if (err) 122 goto out; 123 124 err = dsl_pool_open_special_dir(dp, MOS_DIR_NAME, &dp->dp_mos_dir); 125 if (err) 126 goto out; 127 128 if (spa_version(spa) >= SPA_VERSION_ORIGIN) { 129 err = dsl_pool_open_special_dir(dp, ORIGIN_DIR_NAME, &dd); 130 if (err) 131 goto out; 132 err = dsl_dataset_hold_obj(dp, dd->dd_phys->dd_head_dataset_obj, 133 FTAG, &ds); 134 if (err == 0) { 135 err = dsl_dataset_hold_obj(dp, 136 ds->ds_phys->ds_prev_snap_obj, dp, 137 &dp->dp_origin_snap); 138 dsl_dataset_rele(ds, FTAG); 139 } 140 dsl_dir_close(dd, dp); 141 if (err) 142 goto out; 143 } 144 145 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 146 DMU_POOL_TMP_USERREFS, sizeof (uint64_t), 1, 147 &dp->dp_tmp_userrefs_obj); 148 if (err == ENOENT) 149 err = 0; 150 if (err) 151 goto out; 152 153 /* get scrub status */ 154 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 155 DMU_POOL_SCRUB_FUNC, sizeof (uint32_t), 1, 156 &dp->dp_scrub_func); 157 if (err == 0) { 158 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 159 DMU_POOL_SCRUB_QUEUE, sizeof (uint64_t), 1, 160 &dp->dp_scrub_queue_obj); 161 if (err) 162 goto out; 163 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 164 DMU_POOL_SCRUB_MIN_TXG, sizeof (uint64_t), 1, 165 &dp->dp_scrub_min_txg); 166 if (err) 167 goto out; 168 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 169 DMU_POOL_SCRUB_MAX_TXG, sizeof (uint64_t), 1, 170 &dp->dp_scrub_max_txg); 171 if (err) 172 goto out; 173 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 174 DMU_POOL_SCRUB_BOOKMARK, sizeof (uint64_t), 175 sizeof (dp->dp_scrub_bookmark) / sizeof (uint64_t), 176 &dp->dp_scrub_bookmark); 177 if (err) 178 goto out; 179 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 180 DMU_POOL_SCRUB_DDT_BOOKMARK, sizeof (uint64_t), 181 sizeof (dp->dp_scrub_ddt_bookmark) / sizeof (uint64_t), 182 &dp->dp_scrub_ddt_bookmark); 183 if (err && err != ENOENT) 184 goto out; 185 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 186 DMU_POOL_SCRUB_DDT_CLASS_MAX, sizeof (uint64_t), 1, 187 &dp->dp_scrub_ddt_class_max); 188 if (err && err != ENOENT) 189 goto out; 190 err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 191 DMU_POOL_SCRUB_ERRORS, sizeof (uint64_t), 1, 192 &spa->spa_scrub_errors); 193 if (err) 194 goto out; 195 if (spa_version(spa) < SPA_VERSION_DSL_SCRUB) { 196 /* 197 * A new-type scrub was in progress on an old 198 * pool. Restart from the beginning, since the 199 * old software may have changed the pool in the 200 * meantime. 201 */ 202 dsl_pool_scrub_restart(dp); 203 } 204 } else { 205 /* 206 * It's OK if there is no scrub in progress (and if 207 * there was an I/O error, ignore it). 208 */ 209 err = 0; 210 } 211 212 out: 213 rw_exit(&dp->dp_config_rwlock); 214 if (err) 215 dsl_pool_close(dp); 216 else 217 *dpp = dp; 218 219 return (err); 220 } 221 222 void 223 dsl_pool_close(dsl_pool_t *dp) 224 { 225 /* drop our references from dsl_pool_open() */ 226 227 /* 228 * Since we held the origin_snap from "syncing" context (which 229 * includes pool-opening context), it actually only got a "ref" 230 * and not a hold, so just drop that here. 231 */ 232 if (dp->dp_origin_snap) 233 dsl_dataset_drop_ref(dp->dp_origin_snap, dp); 234 if (dp->dp_mos_dir) 235 dsl_dir_close(dp->dp_mos_dir, dp); 236 if (dp->dp_root_dir) 237 dsl_dir_close(dp->dp_root_dir, dp); 238 239 /* undo the dmu_objset_open_impl(mos) from dsl_pool_open() */ 240 if (dp->dp_meta_objset) 241 dmu_objset_evict(dp->dp_meta_objset); 242 243 txg_list_destroy(&dp->dp_dirty_datasets); 244 txg_list_destroy(&dp->dp_sync_tasks); 245 txg_list_destroy(&dp->dp_dirty_dirs); 246 list_destroy(&dp->dp_synced_datasets); 247 248 arc_flush(dp->dp_spa); 249 txg_fini(dp); 250 rw_destroy(&dp->dp_config_rwlock); 251 mutex_destroy(&dp->dp_lock); 252 mutex_destroy(&dp->dp_scrub_cancel_lock); 253 taskq_destroy(dp->dp_vnrele_taskq); 254 if (dp->dp_blkstats) 255 kmem_free(dp->dp_blkstats, sizeof (zfs_all_blkstats_t)); 256 kmem_free(dp, sizeof (dsl_pool_t)); 257 } 258 259 dsl_pool_t * 260 dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg) 261 { 262 int err; 263 dsl_pool_t *dp = dsl_pool_open_impl(spa, txg); 264 dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg); 265 objset_t *os; 266 dsl_dataset_t *ds; 267 uint64_t dsobj; 268 269 /* create and open the MOS (meta-objset) */ 270 dp->dp_meta_objset = dmu_objset_create_impl(spa, 271 NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx); 272 273 /* create the pool directory */ 274 err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 275 DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx); 276 ASSERT3U(err, ==, 0); 277 278 /* create and open the root dir */ 279 dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx); 280 VERIFY(0 == dsl_dir_open_obj(dp, dp->dp_root_dir_obj, 281 NULL, dp, &dp->dp_root_dir)); 282 283 /* create and open the meta-objset dir */ 284 (void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx); 285 VERIFY(0 == dsl_pool_open_special_dir(dp, 286 MOS_DIR_NAME, &dp->dp_mos_dir)); 287 288 if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB) 289 dsl_pool_create_origin(dp, tx); 290 291 /* create the root dataset */ 292 dsobj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx); 293 294 /* create the root objset */ 295 VERIFY(0 == dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds)); 296 os = dmu_objset_create_impl(dp->dp_spa, ds, 297 dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx); 298 #ifdef _KERNEL 299 zfs_create_fs(os, kcred, zplprops, tx); 300 #endif 301 dsl_dataset_rele(ds, FTAG); 302 303 dmu_tx_commit(tx); 304 305 return (dp); 306 } 307 308 void 309 dsl_pool_sync(dsl_pool_t *dp, uint64_t txg) 310 { 311 zio_t *zio; 312 dmu_tx_t *tx; 313 dsl_dir_t *dd; 314 dsl_dataset_t *ds; 315 dsl_sync_task_group_t *dstg; 316 objset_t *mos = dp->dp_meta_objset; 317 hrtime_t start, write_time; 318 uint64_t data_written; 319 int err; 320 321 tx = dmu_tx_create_assigned(dp, txg); 322 323 dp->dp_read_overhead = 0; 324 start = gethrtime(); 325 326 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 327 while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) { 328 /* 329 * We must not sync any non-MOS datasets twice, because 330 * we may have taken a snapshot of them. However, we 331 * may sync newly-created datasets on pass 2. 332 */ 333 ASSERT(!list_link_active(&ds->ds_synced_link)); 334 list_insert_tail(&dp->dp_synced_datasets, ds); 335 dsl_dataset_sync(ds, zio, tx); 336 } 337 DTRACE_PROBE(pool_sync__1setup); 338 err = zio_wait(zio); 339 340 write_time = gethrtime() - start; 341 ASSERT(err == 0); 342 DTRACE_PROBE(pool_sync__2rootzio); 343 344 for (ds = list_head(&dp->dp_synced_datasets); ds; 345 ds = list_next(&dp->dp_synced_datasets, ds)) 346 dmu_objset_do_userquota_updates(ds->ds_objset, tx); 347 348 /* 349 * Sync the datasets again to push out the changes due to 350 * userquota updates. This must be done before we process the 351 * sync tasks, because that could cause a snapshot of a dataset 352 * whose ds_bp will be rewritten when we do this 2nd sync. 353 */ 354 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 355 while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) { 356 ASSERT(list_link_active(&ds->ds_synced_link)); 357 dmu_buf_rele(ds->ds_dbuf, ds); 358 dsl_dataset_sync(ds, zio, tx); 359 } 360 err = zio_wait(zio); 361 362 /* 363 * If anything was added to a deadlist during a zio done callback, 364 * it had to be put on the deferred queue. Enqueue it for real now. 365 */ 366 for (ds = list_head(&dp->dp_synced_datasets); ds; 367 ds = list_next(&dp->dp_synced_datasets, ds)) 368 bplist_sync(&ds->ds_deadlist, 369 bplist_enqueue_cb, &ds->ds_deadlist, tx); 370 371 while (dstg = txg_list_remove(&dp->dp_sync_tasks, txg)) { 372 /* 373 * No more sync tasks should have been added while we 374 * were syncing. 375 */ 376 ASSERT(spa_sync_pass(dp->dp_spa) == 1); 377 dsl_sync_task_group_sync(dstg, tx); 378 } 379 DTRACE_PROBE(pool_sync__3task); 380 381 start = gethrtime(); 382 while (dd = txg_list_remove(&dp->dp_dirty_dirs, txg)) 383 dsl_dir_sync(dd, tx); 384 write_time += gethrtime() - start; 385 386 if (spa_sync_pass(dp->dp_spa) == 1) { 387 dp->dp_scrub_prefetch_zio_root = zio_root(dp->dp_spa, NULL, 388 NULL, ZIO_FLAG_CANFAIL); 389 dsl_pool_scrub_sync(dp, tx); 390 (void) zio_wait(dp->dp_scrub_prefetch_zio_root); 391 } 392 393 start = gethrtime(); 394 if (list_head(&mos->os_dirty_dnodes[txg & TXG_MASK]) != NULL || 395 list_head(&mos->os_free_dnodes[txg & TXG_MASK]) != NULL) { 396 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 397 dmu_objset_sync(mos, zio, tx); 398 err = zio_wait(zio); 399 ASSERT(err == 0); 400 dprintf_bp(&dp->dp_meta_rootbp, "meta objset rootbp is %s", ""); 401 spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp); 402 } 403 write_time += gethrtime() - start; 404 DTRACE_PROBE2(pool_sync__4io, hrtime_t, write_time, 405 hrtime_t, dp->dp_read_overhead); 406 write_time -= dp->dp_read_overhead; 407 408 dmu_tx_commit(tx); 409 410 data_written = dp->dp_space_towrite[txg & TXG_MASK]; 411 dp->dp_space_towrite[txg & TXG_MASK] = 0; 412 ASSERT(dp->dp_tempreserved[txg & TXG_MASK] == 0); 413 414 /* 415 * If the write limit max has not been explicitly set, set it 416 * to a fraction of available physical memory (default 1/8th). 417 * Note that we must inflate the limit because the spa 418 * inflates write sizes to account for data replication. 419 * Check this each sync phase to catch changing memory size. 420 */ 421 if (physmem != old_physmem && zfs_write_limit_shift) { 422 mutex_enter(&zfs_write_limit_lock); 423 old_physmem = physmem; 424 zfs_write_limit_max = ptob(physmem) >> zfs_write_limit_shift; 425 zfs_write_limit_inflated = MAX(zfs_write_limit_min, 426 spa_get_asize(dp->dp_spa, zfs_write_limit_max)); 427 mutex_exit(&zfs_write_limit_lock); 428 } 429 430 /* 431 * Attempt to keep the sync time consistent by adjusting the 432 * amount of write traffic allowed into each transaction group. 433 * Weight the throughput calculation towards the current value: 434 * thru = 3/4 old_thru + 1/4 new_thru 435 * 436 * Note: write_time is in nanosecs, so write_time/MICROSEC 437 * yields millisecs 438 */ 439 ASSERT(zfs_write_limit_min > 0); 440 if (data_written > zfs_write_limit_min / 8 && write_time > MICROSEC) { 441 uint64_t throughput = data_written / (write_time / MICROSEC); 442 443 if (dp->dp_throughput) 444 dp->dp_throughput = throughput / 4 + 445 3 * dp->dp_throughput / 4; 446 else 447 dp->dp_throughput = throughput; 448 dp->dp_write_limit = MIN(zfs_write_limit_inflated, 449 MAX(zfs_write_limit_min, 450 dp->dp_throughput * zfs_txg_synctime_ms)); 451 } 452 } 453 454 void 455 dsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg) 456 { 457 dsl_dataset_t *ds; 458 objset_t *os; 459 460 while (ds = list_head(&dp->dp_synced_datasets)) { 461 list_remove(&dp->dp_synced_datasets, ds); 462 os = ds->ds_objset; 463 zil_clean(os->os_zil); 464 ASSERT(!dmu_objset_is_dirty(os, txg)); 465 dmu_buf_rele(ds->ds_dbuf, ds); 466 } 467 ASSERT(!dmu_objset_is_dirty(dp->dp_meta_objset, txg)); 468 } 469 470 /* 471 * TRUE if the current thread is the tx_sync_thread or if we 472 * are being called from SPA context during pool initialization. 473 */ 474 int 475 dsl_pool_sync_context(dsl_pool_t *dp) 476 { 477 return (curthread == dp->dp_tx.tx_sync_thread || 478 spa_get_dsl(dp->dp_spa) == NULL); 479 } 480 481 uint64_t 482 dsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree) 483 { 484 uint64_t space, resv; 485 486 /* 487 * Reserve about 1.6% (1/64), or at least 32MB, for allocation 488 * efficiency. 489 * XXX The intent log is not accounted for, so it must fit 490 * within this slop. 491 * 492 * If we're trying to assess whether it's OK to do a free, 493 * cut the reservation in half to allow forward progress 494 * (e.g. make it possible to rm(1) files from a full pool). 495 */ 496 space = spa_get_dspace(dp->dp_spa); 497 resv = MAX(space >> 6, SPA_MINDEVSIZE >> 1); 498 if (netfree) 499 resv >>= 1; 500 501 return (space - resv); 502 } 503 504 int 505 dsl_pool_tempreserve_space(dsl_pool_t *dp, uint64_t space, dmu_tx_t *tx) 506 { 507 uint64_t reserved = 0; 508 uint64_t write_limit = (zfs_write_limit_override ? 509 zfs_write_limit_override : dp->dp_write_limit); 510 511 if (zfs_no_write_throttle) { 512 atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], 513 space); 514 return (0); 515 } 516 517 /* 518 * Check to see if we have exceeded the maximum allowed IO for 519 * this transaction group. We can do this without locks since 520 * a little slop here is ok. Note that we do the reserved check 521 * with only half the requested reserve: this is because the 522 * reserve requests are worst-case, and we really don't want to 523 * throttle based off of worst-case estimates. 524 */ 525 if (write_limit > 0) { 526 reserved = dp->dp_space_towrite[tx->tx_txg & TXG_MASK] 527 + dp->dp_tempreserved[tx->tx_txg & TXG_MASK] / 2; 528 529 if (reserved && reserved > write_limit) 530 return (ERESTART); 531 } 532 533 atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], space); 534 535 /* 536 * If this transaction group is over 7/8ths capacity, delay 537 * the caller 1 clock tick. This will slow down the "fill" 538 * rate until the sync process can catch up with us. 539 */ 540 if (reserved && reserved > (write_limit - (write_limit >> 3))) 541 txg_delay(dp, tx->tx_txg, 1); 542 543 return (0); 544 } 545 546 void 547 dsl_pool_tempreserve_clear(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx) 548 { 549 ASSERT(dp->dp_tempreserved[tx->tx_txg & TXG_MASK] >= space); 550 atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], -space); 551 } 552 553 void 554 dsl_pool_memory_pressure(dsl_pool_t *dp) 555 { 556 uint64_t space_inuse = 0; 557 int i; 558 559 if (dp->dp_write_limit == zfs_write_limit_min) 560 return; 561 562 for (i = 0; i < TXG_SIZE; i++) { 563 space_inuse += dp->dp_space_towrite[i]; 564 space_inuse += dp->dp_tempreserved[i]; 565 } 566 dp->dp_write_limit = MAX(zfs_write_limit_min, 567 MIN(dp->dp_write_limit, space_inuse / 4)); 568 } 569 570 void 571 dsl_pool_willuse_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx) 572 { 573 if (space > 0) { 574 mutex_enter(&dp->dp_lock); 575 dp->dp_space_towrite[tx->tx_txg & TXG_MASK] += space; 576 mutex_exit(&dp->dp_lock); 577 } 578 } 579 580 /* ARGSUSED */ 581 static int 582 upgrade_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg) 583 { 584 dmu_tx_t *tx = arg; 585 dsl_dataset_t *ds, *prev = NULL; 586 int err; 587 dsl_pool_t *dp = spa_get_dsl(spa); 588 589 err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 590 if (err) 591 return (err); 592 593 while (ds->ds_phys->ds_prev_snap_obj != 0) { 594 err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj, 595 FTAG, &prev); 596 if (err) { 597 dsl_dataset_rele(ds, FTAG); 598 return (err); 599 } 600 601 if (prev->ds_phys->ds_next_snap_obj != ds->ds_object) 602 break; 603 dsl_dataset_rele(ds, FTAG); 604 ds = prev; 605 prev = NULL; 606 } 607 608 if (prev == NULL) { 609 prev = dp->dp_origin_snap; 610 611 /* 612 * The $ORIGIN can't have any data, or the accounting 613 * will be wrong. 614 */ 615 ASSERT(prev->ds_phys->ds_bp.blk_birth == 0); 616 617 /* The origin doesn't get attached to itself */ 618 if (ds->ds_object == prev->ds_object) { 619 dsl_dataset_rele(ds, FTAG); 620 return (0); 621 } 622 623 dmu_buf_will_dirty(ds->ds_dbuf, tx); 624 ds->ds_phys->ds_prev_snap_obj = prev->ds_object; 625 ds->ds_phys->ds_prev_snap_txg = prev->ds_phys->ds_creation_txg; 626 627 dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx); 628 ds->ds_dir->dd_phys->dd_origin_obj = prev->ds_object; 629 630 dmu_buf_will_dirty(prev->ds_dbuf, tx); 631 prev->ds_phys->ds_num_children++; 632 633 if (ds->ds_phys->ds_next_snap_obj == 0) { 634 ASSERT(ds->ds_prev == NULL); 635 VERIFY(0 == dsl_dataset_hold_obj(dp, 636 ds->ds_phys->ds_prev_snap_obj, ds, &ds->ds_prev)); 637 } 638 } 639 640 ASSERT(ds->ds_dir->dd_phys->dd_origin_obj == prev->ds_object); 641 ASSERT(ds->ds_phys->ds_prev_snap_obj == prev->ds_object); 642 643 if (prev->ds_phys->ds_next_clones_obj == 0) { 644 dmu_buf_will_dirty(prev->ds_dbuf, tx); 645 prev->ds_phys->ds_next_clones_obj = 646 zap_create(dp->dp_meta_objset, 647 DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx); 648 } 649 VERIFY(0 == zap_add_int(dp->dp_meta_objset, 650 prev->ds_phys->ds_next_clones_obj, ds->ds_object, tx)); 651 652 dsl_dataset_rele(ds, FTAG); 653 if (prev != dp->dp_origin_snap) 654 dsl_dataset_rele(prev, FTAG); 655 return (0); 656 } 657 658 void 659 dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx) 660 { 661 ASSERT(dmu_tx_is_syncing(tx)); 662 ASSERT(dp->dp_origin_snap != NULL); 663 664 VERIFY3U(0, ==, dmu_objset_find_spa(dp->dp_spa, NULL, upgrade_clones_cb, 665 tx, DS_FIND_CHILDREN)); 666 } 667 668 void 669 dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx) 670 { 671 uint64_t dsobj; 672 dsl_dataset_t *ds; 673 674 ASSERT(dmu_tx_is_syncing(tx)); 675 ASSERT(dp->dp_origin_snap == NULL); 676 677 /* create the origin dir, ds, & snap-ds */ 678 rw_enter(&dp->dp_config_rwlock, RW_WRITER); 679 dsobj = dsl_dataset_create_sync(dp->dp_root_dir, ORIGIN_DIR_NAME, 680 NULL, 0, kcred, tx); 681 VERIFY(0 == dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds)); 682 dsl_dataset_snapshot_sync(ds, ORIGIN_DIR_NAME, kcred, tx); 683 VERIFY(0 == dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj, 684 dp, &dp->dp_origin_snap)); 685 dsl_dataset_rele(ds, FTAG); 686 rw_exit(&dp->dp_config_rwlock); 687 } 688 689 taskq_t * 690 dsl_pool_vnrele_taskq(dsl_pool_t *dp) 691 { 692 return (dp->dp_vnrele_taskq); 693 } 694 695 /* 696 * Walk through the pool-wide zap object of temporary snapshot user holds 697 * and release them. 698 */ 699 void 700 dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp) 701 { 702 zap_attribute_t za; 703 zap_cursor_t zc; 704 objset_t *mos = dp->dp_meta_objset; 705 uint64_t zapobj = dp->dp_tmp_userrefs_obj; 706 707 if (zapobj == 0) 708 return; 709 ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS); 710 711 for (zap_cursor_init(&zc, mos, zapobj); 712 zap_cursor_retrieve(&zc, &za) == 0; 713 zap_cursor_advance(&zc)) { 714 char *htag; 715 uint64_t dsobj; 716 717 htag = strchr(za.za_name, '-'); 718 *htag = '\0'; 719 ++htag; 720 dsobj = strtonum(za.za_name, NULL); 721 (void) dsl_dataset_user_release_tmp(dp, dsobj, htag); 722 } 723 zap_cursor_fini(&zc); 724 } 725 726 /* 727 * Create the pool-wide zap object for storing temporary snapshot holds. 728 */ 729 void 730 dsl_pool_user_hold_create_obj(dsl_pool_t *dp, dmu_tx_t *tx) 731 { 732 objset_t *mos = dp->dp_meta_objset; 733 734 ASSERT(dp->dp_tmp_userrefs_obj == 0); 735 ASSERT(dmu_tx_is_syncing(tx)); 736 737 dp->dp_tmp_userrefs_obj = zap_create(mos, DMU_OT_USERREFS, 738 DMU_OT_NONE, 0, tx); 739 740 VERIFY(zap_add(mos, DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_TMP_USERREFS, 741 sizeof (uint64_t), 1, &dp->dp_tmp_userrefs_obj, tx) == 0); 742 } 743 744 static int 745 dsl_pool_user_hold_rele_impl(dsl_pool_t *dp, uint64_t dsobj, 746 const char *tag, uint64_t *now, dmu_tx_t *tx, boolean_t holding) 747 { 748 objset_t *mos = dp->dp_meta_objset; 749 uint64_t zapobj = dp->dp_tmp_userrefs_obj; 750 char *name; 751 int error; 752 753 ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS); 754 ASSERT(dmu_tx_is_syncing(tx)); 755 756 /* 757 * If the pool was created prior to SPA_VERSION_USERREFS, the 758 * zap object for temporary holds might not exist yet. 759 */ 760 if (zapobj == 0) { 761 if (holding) { 762 dsl_pool_user_hold_create_obj(dp, tx); 763 zapobj = dp->dp_tmp_userrefs_obj; 764 } else { 765 return (ENOENT); 766 } 767 } 768 769 name = kmem_asprintf("%llx-%s", (u_longlong_t)dsobj, tag); 770 if (holding) 771 error = zap_add(mos, zapobj, name, 8, 1, now, tx); 772 else 773 error = zap_remove(mos, zapobj, name, tx); 774 strfree(name); 775 776 return (error); 777 } 778 779 /* 780 * Add a temporary hold for the given dataset object and tag. 781 */ 782 int 783 dsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj, const char *tag, 784 uint64_t *now, dmu_tx_t *tx) 785 { 786 return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, now, tx, B_TRUE)); 787 } 788 789 /* 790 * Release a temporary hold for the given dataset object and tag. 791 */ 792 int 793 dsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj, const char *tag, 794 dmu_tx_t *tx) 795 { 796 return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, NULL, 797 tx, B_FALSE)); 798 } 799