dsl_pool.c revision 240415
1168404Spjd/* 2168404Spjd * CDDL HEADER START 3168404Spjd * 4168404Spjd * The contents of this file are subject to the terms of the 5168404Spjd * Common Development and Distribution License (the "License"). 6168404Spjd * You may not use this file except in compliance with the License. 7168404Spjd * 8168404Spjd * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9168404Spjd * or http://www.opensolaris.org/os/licensing. 10168404Spjd * See the License for the specific language governing permissions 11168404Spjd * and limitations under the License. 12168404Spjd * 13168404Spjd * When distributing Covered Code, include this CDDL HEADER in each 14168404Spjd * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15168404Spjd * If applicable, add the following below this CDDL HEADER, with the 16168404Spjd * fields enclosed by brackets "[]" replaced with your own identifying 17168404Spjd * information: Portions Copyright [yyyy] [name of copyright owner] 18168404Spjd * 19168404Spjd * CDDL HEADER END 20168404Spjd */ 21168404Spjd/* 22219089Spjd * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23236884Smm * Copyright (c) 2012 by Delphix. All rights reserved. 24168404Spjd */ 25168404Spjd 26168404Spjd#include <sys/dsl_pool.h> 27168404Spjd#include <sys/dsl_dataset.h> 28219089Spjd#include <sys/dsl_prop.h> 29168404Spjd#include <sys/dsl_dir.h> 30168404Spjd#include <sys/dsl_synctask.h> 31219089Spjd#include <sys/dsl_scan.h> 32219089Spjd#include <sys/dnode.h> 33168404Spjd#include <sys/dmu_tx.h> 34168404Spjd#include <sys/dmu_objset.h> 35168404Spjd#include <sys/arc.h> 36168404Spjd#include <sys/zap.h> 37168404Spjd#include <sys/zio.h> 38168404Spjd#include <sys/zfs_context.h> 39168404Spjd#include <sys/fs/zfs.h> 40185029Spjd#include <sys/zfs_znode.h> 41185029Spjd#include <sys/spa_impl.h> 42219089Spjd#include <sys/dsl_deadlist.h> 43236884Smm#include <sys/bptree.h> 44236884Smm#include <sys/zfeature.h> 45239620Smm#include <sys/zil_impl.h> 46168404Spjd 47185029Spjdint zfs_no_write_throttle = 0; 48185029Spjdint zfs_write_limit_shift = 3; /* 1/8th of physical memory */ 49219089Spjdint zfs_txg_synctime_ms = 1000; /* target millisecs to sync a txg */ 50185029Spjd 51185029Spjduint64_t zfs_write_limit_min = 32 << 20; /* min write limit is 32MB */ 52185029Spjduint64_t zfs_write_limit_max = 0; /* max data payload per txg */ 53185029Spjduint64_t zfs_write_limit_inflated = 0; 54185029Spjduint64_t zfs_write_limit_override = 0; 55185029Spjd 56185029Spjdkmutex_t zfs_write_limit_lock; 57185029Spjd 58185029Spjdstatic pgcnt_t old_physmem = 0; 59185029Spjd 60219089SpjdSYSCTL_DECL(_vfs_zfs); 61219089SpjdTUNABLE_INT("vfs.zfs.no_write_throttle", &zfs_no_write_throttle); 62219089SpjdSYSCTL_INT(_vfs_zfs, OID_AUTO, no_write_throttle, CTLFLAG_RDTUN, 63219089Spjd &zfs_no_write_throttle, 0, ""); 64219089SpjdTUNABLE_INT("vfs.zfs.write_limit_shift", &zfs_write_limit_shift); 65219089SpjdSYSCTL_INT(_vfs_zfs, OID_AUTO, write_limit_shift, CTLFLAG_RDTUN, 66219089Spjd &zfs_write_limit_shift, 0, "2^N of physical memory"); 67219089SpjdSYSCTL_DECL(_vfs_zfs_txg); 68219089SpjdTUNABLE_INT("vfs.zfs.txg.synctime_ms", &zfs_txg_synctime_ms); 69219089SpjdSYSCTL_INT(_vfs_zfs_txg, OID_AUTO, synctime_ms, CTLFLAG_RDTUN, 70219089Spjd &zfs_txg_synctime_ms, 0, "Target milliseconds to sync a txg"); 71219089Spjd 72219089SpjdTUNABLE_QUAD("vfs.zfs.write_limit_min", &zfs_write_limit_min); 73219089SpjdSYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_min, CTLFLAG_RDTUN, 74219089Spjd &zfs_write_limit_min, 0, "Minimum write limit"); 75219089SpjdTUNABLE_QUAD("vfs.zfs.write_limit_max", &zfs_write_limit_max); 76219089SpjdSYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_max, CTLFLAG_RDTUN, 77219089Spjd &zfs_write_limit_max, 0, "Maximum data payload per txg"); 78219089SpjdTUNABLE_QUAD("vfs.zfs.write_limit_inflated", &zfs_write_limit_inflated); 79219089SpjdSYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_inflated, CTLFLAG_RDTUN, 80219089Spjd &zfs_write_limit_inflated, 0, ""); 81219089SpjdTUNABLE_QUAD("vfs.zfs.write_limit_override", &zfs_write_limit_override); 82219089SpjdSYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_override, CTLFLAG_RDTUN, 83219089Spjd &zfs_write_limit_override, 0, ""); 84219089Spjd 85219089Spjdint 86185029Spjddsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **ddp) 87168404Spjd{ 88168404Spjd uint64_t obj; 89168404Spjd int err; 90168404Spjd 91168404Spjd err = zap_lookup(dp->dp_meta_objset, 92168404Spjd dp->dp_root_dir->dd_phys->dd_child_dir_zapobj, 93185029Spjd name, sizeof (obj), 1, &obj); 94168404Spjd if (err) 95168404Spjd return (err); 96168404Spjd 97185029Spjd return (dsl_dir_open_obj(dp, obj, name, dp, ddp)); 98168404Spjd} 99168404Spjd 100168404Spjdstatic dsl_pool_t * 101168404Spjddsl_pool_open_impl(spa_t *spa, uint64_t txg) 102168404Spjd{ 103168404Spjd dsl_pool_t *dp; 104168404Spjd blkptr_t *bp = spa_get_rootblkptr(spa); 105168404Spjd 106168404Spjd dp = kmem_zalloc(sizeof (dsl_pool_t), KM_SLEEP); 107168404Spjd dp->dp_spa = spa; 108168404Spjd dp->dp_meta_rootbp = *bp; 109168404Spjd rw_init(&dp->dp_config_rwlock, NULL, RW_DEFAULT, NULL); 110185029Spjd dp->dp_write_limit = zfs_write_limit_min; 111168404Spjd txg_init(dp, txg); 112168404Spjd 113168404Spjd txg_list_create(&dp->dp_dirty_datasets, 114168404Spjd offsetof(dsl_dataset_t, ds_dirty_link)); 115239620Smm txg_list_create(&dp->dp_dirty_zilogs, 116239620Smm offsetof(zilog_t, zl_dirty_link)); 117168404Spjd txg_list_create(&dp->dp_dirty_dirs, 118168404Spjd offsetof(dsl_dir_t, dd_dirty_link)); 119168404Spjd txg_list_create(&dp->dp_sync_tasks, 120168404Spjd offsetof(dsl_sync_task_group_t, dstg_node)); 121168404Spjd 122185029Spjd mutex_init(&dp->dp_lock, NULL, MUTEX_DEFAULT, NULL); 123185029Spjd 124196307Spjd dp->dp_vnrele_taskq = taskq_create("zfs_vn_rele_taskq", 1, minclsyspri, 125196307Spjd 1, 4, 0); 126196307Spjd 127168404Spjd return (dp); 128168404Spjd} 129168404Spjd 130168404Spjdint 131236884Smmdsl_pool_init(spa_t *spa, uint64_t txg, dsl_pool_t **dpp) 132168404Spjd{ 133168404Spjd int err; 134168404Spjd dsl_pool_t *dp = dsl_pool_open_impl(spa, txg); 135236884Smm 136236884Smm err = dmu_objset_open_impl(spa, NULL, &dp->dp_meta_rootbp, 137236884Smm &dp->dp_meta_objset); 138236884Smm if (err != 0) 139236884Smm dsl_pool_close(dp); 140236884Smm else 141236884Smm *dpp = dp; 142236884Smm 143236884Smm return (err); 144236884Smm} 145236884Smm 146236884Smmint 147236884Smmdsl_pool_open(dsl_pool_t *dp) 148236884Smm{ 149236884Smm int err; 150185029Spjd dsl_dir_t *dd; 151185029Spjd dsl_dataset_t *ds; 152219089Spjd uint64_t obj; 153168404Spjd 154185029Spjd rw_enter(&dp->dp_config_rwlock, RW_WRITER); 155168404Spjd err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 156168404Spjd DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1, 157168404Spjd &dp->dp_root_dir_obj); 158168404Spjd if (err) 159168404Spjd goto out; 160168404Spjd 161168404Spjd err = dsl_dir_open_obj(dp, dp->dp_root_dir_obj, 162168404Spjd NULL, dp, &dp->dp_root_dir); 163168404Spjd if (err) 164168404Spjd goto out; 165168404Spjd 166185029Spjd err = dsl_pool_open_special_dir(dp, MOS_DIR_NAME, &dp->dp_mos_dir); 167168404Spjd if (err) 168168404Spjd goto out; 169168404Spjd 170236884Smm if (spa_version(dp->dp_spa) >= SPA_VERSION_ORIGIN) { 171185029Spjd err = dsl_pool_open_special_dir(dp, ORIGIN_DIR_NAME, &dd); 172185029Spjd if (err) 173185029Spjd goto out; 174185029Spjd err = dsl_dataset_hold_obj(dp, dd->dd_phys->dd_head_dataset_obj, 175185029Spjd FTAG, &ds); 176209962Smm if (err == 0) { 177209962Smm err = dsl_dataset_hold_obj(dp, 178219089Spjd ds->ds_phys->ds_prev_snap_obj, dp, 179219089Spjd &dp->dp_origin_snap); 180209962Smm dsl_dataset_rele(ds, FTAG); 181209962Smm } 182209962Smm dsl_dir_close(dd, dp); 183185029Spjd if (err) 184185029Spjd goto out; 185185029Spjd } 186185029Spjd 187236884Smm if (spa_version(dp->dp_spa) >= SPA_VERSION_DEADLISTS) { 188219089Spjd err = dsl_pool_open_special_dir(dp, FREE_DIR_NAME, 189219089Spjd &dp->dp_free_dir); 190185029Spjd if (err) 191185029Spjd goto out; 192219089Spjd 193185029Spjd err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 194219089Spjd DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj); 195185029Spjd if (err) 196185029Spjd goto out; 197219089Spjd VERIFY3U(0, ==, bpobj_open(&dp->dp_free_bpobj, 198219089Spjd dp->dp_meta_objset, obj)); 199185029Spjd } 200185029Spjd 201236884Smm if (spa_feature_is_active(dp->dp_spa, 202236884Smm &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY])) { 203236884Smm err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 204236884Smm DMU_POOL_BPTREE_OBJ, sizeof (uint64_t), 1, 205236884Smm &dp->dp_bptree_obj); 206236884Smm if (err != 0) 207236884Smm goto out; 208236884Smm } 209236884Smm 210239774Smm if (spa_feature_is_active(dp->dp_spa, 211239774Smm &spa_feature_table[SPA_FEATURE_EMPTY_BPOBJ])) { 212239774Smm err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 213239774Smm DMU_POOL_EMPTY_BPOBJ, sizeof (uint64_t), 1, 214239774Smm &dp->dp_empty_bpobj); 215239774Smm if (err != 0) 216239774Smm goto out; 217239774Smm } 218239774Smm 219219089Spjd err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 220219089Spjd DMU_POOL_TMP_USERREFS, sizeof (uint64_t), 1, 221219089Spjd &dp->dp_tmp_userrefs_obj); 222219089Spjd if (err == ENOENT) 223219089Spjd err = 0; 224219089Spjd if (err) 225219089Spjd goto out; 226219089Spjd 227236884Smm err = dsl_scan_init(dp, dp->dp_tx.tx_open_txg); 228219089Spjd 229168404Spjdout: 230168404Spjd rw_exit(&dp->dp_config_rwlock); 231168404Spjd return (err); 232168404Spjd} 233168404Spjd 234168404Spjdvoid 235168404Spjddsl_pool_close(dsl_pool_t *dp) 236168404Spjd{ 237185029Spjd /* drop our references from dsl_pool_open() */ 238185029Spjd 239185029Spjd /* 240185029Spjd * Since we held the origin_snap from "syncing" context (which 241185029Spjd * includes pool-opening context), it actually only got a "ref" 242185029Spjd * and not a hold, so just drop that here. 243185029Spjd */ 244185029Spjd if (dp->dp_origin_snap) 245185029Spjd dsl_dataset_drop_ref(dp->dp_origin_snap, dp); 246168404Spjd if (dp->dp_mos_dir) 247168404Spjd dsl_dir_close(dp->dp_mos_dir, dp); 248219089Spjd if (dp->dp_free_dir) 249219089Spjd dsl_dir_close(dp->dp_free_dir, dp); 250168404Spjd if (dp->dp_root_dir) 251168404Spjd dsl_dir_close(dp->dp_root_dir, dp); 252168404Spjd 253219089Spjd bpobj_close(&dp->dp_free_bpobj); 254219089Spjd 255168404Spjd /* undo the dmu_objset_open_impl(mos) from dsl_pool_open() */ 256168404Spjd if (dp->dp_meta_objset) 257219089Spjd dmu_objset_evict(dp->dp_meta_objset); 258168404Spjd 259168404Spjd txg_list_destroy(&dp->dp_dirty_datasets); 260239620Smm txg_list_destroy(&dp->dp_dirty_zilogs); 261219089Spjd txg_list_destroy(&dp->dp_sync_tasks); 262168404Spjd txg_list_destroy(&dp->dp_dirty_dirs); 263168404Spjd 264185029Spjd arc_flush(dp->dp_spa); 265168404Spjd txg_fini(dp); 266219089Spjd dsl_scan_fini(dp); 267168404Spjd rw_destroy(&dp->dp_config_rwlock); 268185029Spjd mutex_destroy(&dp->dp_lock); 269196307Spjd taskq_destroy(dp->dp_vnrele_taskq); 270208047Smm if (dp->dp_blkstats) 271208047Smm kmem_free(dp->dp_blkstats, sizeof (zfs_all_blkstats_t)); 272168404Spjd kmem_free(dp, sizeof (dsl_pool_t)); 273168404Spjd} 274168404Spjd 275168404Spjddsl_pool_t * 276185029Spjddsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg) 277168404Spjd{ 278168404Spjd int err; 279168404Spjd dsl_pool_t *dp = dsl_pool_open_impl(spa, txg); 280168404Spjd dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg); 281219089Spjd objset_t *os; 282185029Spjd dsl_dataset_t *ds; 283219089Spjd uint64_t obj; 284185029Spjd 285185029Spjd /* create and open the MOS (meta-objset) */ 286219089Spjd dp->dp_meta_objset = dmu_objset_create_impl(spa, 287219089Spjd NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx); 288168404Spjd 289168404Spjd /* create the pool directory */ 290168404Spjd err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 291168404Spjd DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx); 292240415Smm ASSERT0(err); 293168404Spjd 294219089Spjd /* Initialize scan structures */ 295219089Spjd VERIFY3U(0, ==, dsl_scan_init(dp, txg)); 296219089Spjd 297168404Spjd /* create and open the root dir */ 298185029Spjd dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx); 299168404Spjd VERIFY(0 == dsl_dir_open_obj(dp, dp->dp_root_dir_obj, 300168404Spjd NULL, dp, &dp->dp_root_dir)); 301168404Spjd 302168404Spjd /* create and open the meta-objset dir */ 303185029Spjd (void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx); 304185029Spjd VERIFY(0 == dsl_pool_open_special_dir(dp, 305185029Spjd MOS_DIR_NAME, &dp->dp_mos_dir)); 306168404Spjd 307219089Spjd if (spa_version(spa) >= SPA_VERSION_DEADLISTS) { 308219089Spjd /* create and open the free dir */ 309219089Spjd (void) dsl_dir_create_sync(dp, dp->dp_root_dir, 310219089Spjd FREE_DIR_NAME, tx); 311219089Spjd VERIFY(0 == dsl_pool_open_special_dir(dp, 312219089Spjd FREE_DIR_NAME, &dp->dp_free_dir)); 313219089Spjd 314219089Spjd /* create and open the free_bplist */ 315219089Spjd obj = bpobj_alloc(dp->dp_meta_objset, SPA_MAXBLOCKSIZE, tx); 316219089Spjd VERIFY(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 317219089Spjd DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx) == 0); 318219089Spjd VERIFY3U(0, ==, bpobj_open(&dp->dp_free_bpobj, 319219089Spjd dp->dp_meta_objset, obj)); 320219089Spjd } 321219089Spjd 322185029Spjd if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB) 323185029Spjd dsl_pool_create_origin(dp, tx); 324185029Spjd 325185029Spjd /* create the root dataset */ 326219089Spjd obj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx); 327185029Spjd 328185029Spjd /* create the root objset */ 329219089Spjd VERIFY(0 == dsl_dataset_hold_obj(dp, obj, FTAG, &ds)); 330219089Spjd os = dmu_objset_create_impl(dp->dp_spa, ds, 331185029Spjd dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx); 332185029Spjd#ifdef _KERNEL 333219089Spjd zfs_create_fs(os, kcred, zplprops, tx); 334185029Spjd#endif 335185029Spjd dsl_dataset_rele(ds, FTAG); 336185029Spjd 337168404Spjd dmu_tx_commit(tx); 338168404Spjd 339168404Spjd return (dp); 340168404Spjd} 341168404Spjd 342239620Smm/* 343239620Smm * Account for the meta-objset space in its placeholder dsl_dir. 344239620Smm */ 345239620Smmvoid 346239620Smmdsl_pool_mos_diduse_space(dsl_pool_t *dp, 347239620Smm int64_t used, int64_t comp, int64_t uncomp) 348239620Smm{ 349239620Smm ASSERT3U(comp, ==, uncomp); /* it's all metadata */ 350239620Smm mutex_enter(&dp->dp_lock); 351239620Smm dp->dp_mos_used_delta += used; 352239620Smm dp->dp_mos_compressed_delta += comp; 353239620Smm dp->dp_mos_uncompressed_delta += uncomp; 354239620Smm mutex_exit(&dp->dp_lock); 355239620Smm} 356239620Smm 357219089Spjdstatic int 358219089Spjddeadlist_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 359219089Spjd{ 360219089Spjd dsl_deadlist_t *dl = arg; 361228103Smm dsl_pool_t *dp = dmu_objset_pool(dl->dl_os); 362228103Smm rw_enter(&dp->dp_config_rwlock, RW_READER); 363219089Spjd dsl_deadlist_insert(dl, bp, tx); 364228103Smm rw_exit(&dp->dp_config_rwlock); 365219089Spjd return (0); 366219089Spjd} 367219089Spjd 368168404Spjdvoid 369168404Spjddsl_pool_sync(dsl_pool_t *dp, uint64_t txg) 370168404Spjd{ 371168404Spjd zio_t *zio; 372168404Spjd dmu_tx_t *tx; 373168404Spjd dsl_dir_t *dd; 374168404Spjd dsl_dataset_t *ds; 375219089Spjd objset_t *mos = dp->dp_meta_objset; 376185029Spjd hrtime_t start, write_time; 377185029Spjd uint64_t data_written; 378168404Spjd int err; 379239620Smm list_t synced_datasets; 380168404Spjd 381239620Smm list_create(&synced_datasets, sizeof (dsl_dataset_t), 382239620Smm offsetof(dsl_dataset_t, ds_synced_link)); 383239620Smm 384219089Spjd /* 385219089Spjd * We need to copy dp_space_towrite() before doing 386219089Spjd * dsl_sync_task_group_sync(), because 387219089Spjd * dsl_dataset_snapshot_reserve_space() will increase 388219089Spjd * dp_space_towrite but not actually write anything. 389219089Spjd */ 390219089Spjd data_written = dp->dp_space_towrite[txg & TXG_MASK]; 391219089Spjd 392168404Spjd tx = dmu_tx_create_assigned(dp, txg); 393168404Spjd 394185029Spjd dp->dp_read_overhead = 0; 395207427Smm start = gethrtime(); 396209962Smm 397168404Spjd zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 398168404Spjd while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) { 399209962Smm /* 400209962Smm * We must not sync any non-MOS datasets twice, because 401209962Smm * we may have taken a snapshot of them. However, we 402209962Smm * may sync newly-created datasets on pass 2. 403209962Smm */ 404209962Smm ASSERT(!list_link_active(&ds->ds_synced_link)); 405239620Smm list_insert_tail(&synced_datasets, ds); 406168404Spjd dsl_dataset_sync(ds, zio, tx); 407168404Spjd } 408185029Spjd DTRACE_PROBE(pool_sync__1setup); 409209962Smm err = zio_wait(zio); 410185029Spjd 411185029Spjd write_time = gethrtime() - start; 412168404Spjd ASSERT(err == 0); 413185029Spjd DTRACE_PROBE(pool_sync__2rootzio); 414168404Spjd 415239620Smm /* 416239620Smm * After the data blocks have been written (ensured by the zio_wait() 417239620Smm * above), update the user/group space accounting. 418239620Smm */ 419239620Smm for (ds = list_head(&synced_datasets); ds; 420239620Smm ds = list_next(&synced_datasets, ds)) 421219089Spjd dmu_objset_do_userquota_updates(ds->ds_objset, tx); 422209962Smm 423209962Smm /* 424209962Smm * Sync the datasets again to push out the changes due to 425219089Spjd * userspace updates. This must be done before we process the 426239620Smm * sync tasks, so that any snapshots will have the correct 427239620Smm * user accounting information (and we won't get confused 428239620Smm * about which blocks are part of the snapshot). 429209962Smm */ 430209962Smm zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 431209962Smm while (ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) { 432209962Smm ASSERT(list_link_active(&ds->ds_synced_link)); 433209962Smm dmu_buf_rele(ds->ds_dbuf, ds); 434209962Smm dsl_dataset_sync(ds, zio, tx); 435209962Smm } 436209962Smm err = zio_wait(zio); 437209962Smm 438219089Spjd /* 439239620Smm * Now that the datasets have been completely synced, we can 440239620Smm * clean up our in-memory structures accumulated while syncing: 441239620Smm * 442239620Smm * - move dead blocks from the pending deadlist to the on-disk deadlist 443239620Smm * - clean up zil records 444239620Smm * - release hold from dsl_dataset_dirty() 445219089Spjd */ 446239620Smm while (ds = list_remove_head(&synced_datasets)) { 447239620Smm objset_t *os = ds->ds_objset; 448219089Spjd bplist_iterate(&ds->ds_pending_deadlist, 449219089Spjd deadlist_enqueue_cb, &ds->ds_deadlist, tx); 450239620Smm ASSERT(!dmu_objset_is_dirty(os, txg)); 451239620Smm dmu_buf_rele(ds->ds_dbuf, ds); 452219089Spjd } 453219089Spjd 454185029Spjd start = gethrtime(); 455168404Spjd while (dd = txg_list_remove(&dp->dp_dirty_dirs, txg)) 456168404Spjd dsl_dir_sync(dd, tx); 457185029Spjd write_time += gethrtime() - start; 458168404Spjd 459239620Smm /* 460239620Smm * The MOS's space is accounted for in the pool/$MOS 461239620Smm * (dp_mos_dir). We can't modify the mos while we're syncing 462239620Smm * it, so we remember the deltas and apply them here. 463239620Smm */ 464239620Smm if (dp->dp_mos_used_delta != 0 || dp->dp_mos_compressed_delta != 0 || 465239620Smm dp->dp_mos_uncompressed_delta != 0) { 466239620Smm dsl_dir_diduse_space(dp->dp_mos_dir, DD_USED_HEAD, 467239620Smm dp->dp_mos_used_delta, 468239620Smm dp->dp_mos_compressed_delta, 469239620Smm dp->dp_mos_uncompressed_delta, tx); 470239620Smm dp->dp_mos_used_delta = 0; 471239620Smm dp->dp_mos_compressed_delta = 0; 472239620Smm dp->dp_mos_uncompressed_delta = 0; 473239620Smm } 474239620Smm 475185029Spjd start = gethrtime(); 476219089Spjd if (list_head(&mos->os_dirty_dnodes[txg & TXG_MASK]) != NULL || 477219089Spjd list_head(&mos->os_free_dnodes[txg & TXG_MASK]) != NULL) { 478168404Spjd zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED); 479219089Spjd dmu_objset_sync(mos, zio, tx); 480168404Spjd err = zio_wait(zio); 481168404Spjd ASSERT(err == 0); 482168404Spjd dprintf_bp(&dp->dp_meta_rootbp, "meta objset rootbp is %s", ""); 483168404Spjd spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp); 484168404Spjd } 485185029Spjd write_time += gethrtime() - start; 486185029Spjd DTRACE_PROBE2(pool_sync__4io, hrtime_t, write_time, 487185029Spjd hrtime_t, dp->dp_read_overhead); 488185029Spjd write_time -= dp->dp_read_overhead; 489168404Spjd 490239620Smm /* 491239620Smm * If we modify a dataset in the same txg that we want to destroy it, 492239620Smm * its dsl_dir's dd_dbuf will be dirty, and thus have a hold on it. 493239620Smm * dsl_dir_destroy_check() will fail if there are unexpected holds. 494239620Smm * Therefore, we want to sync the MOS (thus syncing the dd_dbuf 495239620Smm * and clearing the hold on it) before we process the sync_tasks. 496239620Smm * The MOS data dirtied by the sync_tasks will be synced on the next 497239620Smm * pass. 498239620Smm */ 499239620Smm DTRACE_PROBE(pool_sync__3task); 500239620Smm if (!txg_list_empty(&dp->dp_sync_tasks, txg)) { 501239620Smm dsl_sync_task_group_t *dstg; 502239620Smm /* 503239620Smm * No more sync tasks should have been added while we 504239620Smm * were syncing. 505239620Smm */ 506239620Smm ASSERT(spa_sync_pass(dp->dp_spa) == 1); 507239620Smm while (dstg = txg_list_remove(&dp->dp_sync_tasks, txg)) 508239620Smm dsl_sync_task_group_sync(dstg, tx); 509239620Smm } 510239620Smm 511168404Spjd dmu_tx_commit(tx); 512185029Spjd 513185029Spjd dp->dp_space_towrite[txg & TXG_MASK] = 0; 514185029Spjd ASSERT(dp->dp_tempreserved[txg & TXG_MASK] == 0); 515185029Spjd 516185029Spjd /* 517185029Spjd * If the write limit max has not been explicitly set, set it 518185029Spjd * to a fraction of available physical memory (default 1/8th). 519185029Spjd * Note that we must inflate the limit because the spa 520185029Spjd * inflates write sizes to account for data replication. 521185029Spjd * Check this each sync phase to catch changing memory size. 522185029Spjd */ 523185029Spjd if (physmem != old_physmem && zfs_write_limit_shift) { 524185029Spjd mutex_enter(&zfs_write_limit_lock); 525185029Spjd old_physmem = physmem; 526185029Spjd zfs_write_limit_max = ptob(physmem) >> zfs_write_limit_shift; 527185029Spjd zfs_write_limit_inflated = MAX(zfs_write_limit_min, 528185029Spjd spa_get_asize(dp->dp_spa, zfs_write_limit_max)); 529185029Spjd mutex_exit(&zfs_write_limit_lock); 530185029Spjd } 531185029Spjd 532185029Spjd /* 533185029Spjd * Attempt to keep the sync time consistent by adjusting the 534185029Spjd * amount of write traffic allowed into each transaction group. 535185029Spjd * Weight the throughput calculation towards the current value: 536185029Spjd * thru = 3/4 old_thru + 1/4 new_thru 537219089Spjd * 538219089Spjd * Note: write_time is in nanosecs, so write_time/MICROSEC 539219089Spjd * yields millisecs 540185029Spjd */ 541185029Spjd ASSERT(zfs_write_limit_min > 0); 542219089Spjd if (data_written > zfs_write_limit_min / 8 && write_time > MICROSEC) { 543219089Spjd uint64_t throughput = data_written / (write_time / MICROSEC); 544219089Spjd 545185029Spjd if (dp->dp_throughput) 546185029Spjd dp->dp_throughput = throughput / 4 + 547185029Spjd 3 * dp->dp_throughput / 4; 548185029Spjd else 549185029Spjd dp->dp_throughput = throughput; 550185029Spjd dp->dp_write_limit = MIN(zfs_write_limit_inflated, 551185029Spjd MAX(zfs_write_limit_min, 552219089Spjd dp->dp_throughput * zfs_txg_synctime_ms)); 553185029Spjd } 554168404Spjd} 555168404Spjd 556168404Spjdvoid 557219089Spjddsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg) 558168404Spjd{ 559239620Smm zilog_t *zilog; 560168404Spjd dsl_dataset_t *ds; 561168404Spjd 562239620Smm while (zilog = txg_list_remove(&dp->dp_dirty_zilogs, txg)) { 563239620Smm ds = dmu_objset_ds(zilog->zl_os); 564239620Smm zil_clean(zilog, txg); 565239620Smm ASSERT(!dmu_objset_is_dirty(zilog->zl_os, txg)); 566239620Smm dmu_buf_rele(ds->ds_dbuf, zilog); 567168404Spjd } 568219089Spjd ASSERT(!dmu_objset_is_dirty(dp->dp_meta_objset, txg)); 569168404Spjd} 570168404Spjd 571168404Spjd/* 572168404Spjd * TRUE if the current thread is the tx_sync_thread or if we 573168404Spjd * are being called from SPA context during pool initialization. 574168404Spjd */ 575168404Spjdint 576168404Spjddsl_pool_sync_context(dsl_pool_t *dp) 577168404Spjd{ 578168404Spjd return (curthread == dp->dp_tx.tx_sync_thread || 579236884Smm spa_is_initializing(dp->dp_spa)); 580168404Spjd} 581168404Spjd 582168404Spjduint64_t 583168404Spjddsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree) 584168404Spjd{ 585168404Spjd uint64_t space, resv; 586168404Spjd 587168404Spjd /* 588168404Spjd * Reserve about 1.6% (1/64), or at least 32MB, for allocation 589168404Spjd * efficiency. 590168404Spjd * XXX The intent log is not accounted for, so it must fit 591168404Spjd * within this slop. 592168404Spjd * 593168404Spjd * If we're trying to assess whether it's OK to do a free, 594168404Spjd * cut the reservation in half to allow forward progress 595168404Spjd * (e.g. make it possible to rm(1) files from a full pool). 596168404Spjd */ 597168404Spjd space = spa_get_dspace(dp->dp_spa); 598168404Spjd resv = MAX(space >> 6, SPA_MINDEVSIZE >> 1); 599168404Spjd if (netfree) 600168404Spjd resv >>= 1; 601168404Spjd 602168404Spjd return (space - resv); 603168404Spjd} 604185029Spjd 605185029Spjdint 606185029Spjddsl_pool_tempreserve_space(dsl_pool_t *dp, uint64_t space, dmu_tx_t *tx) 607185029Spjd{ 608185029Spjd uint64_t reserved = 0; 609185029Spjd uint64_t write_limit = (zfs_write_limit_override ? 610185029Spjd zfs_write_limit_override : dp->dp_write_limit); 611185029Spjd 612185029Spjd if (zfs_no_write_throttle) { 613185029Spjd atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], 614185029Spjd space); 615185029Spjd return (0); 616185029Spjd } 617185029Spjd 618185029Spjd /* 619185029Spjd * Check to see if we have exceeded the maximum allowed IO for 620185029Spjd * this transaction group. We can do this without locks since 621185029Spjd * a little slop here is ok. Note that we do the reserved check 622185029Spjd * with only half the requested reserve: this is because the 623185029Spjd * reserve requests are worst-case, and we really don't want to 624185029Spjd * throttle based off of worst-case estimates. 625185029Spjd */ 626185029Spjd if (write_limit > 0) { 627185029Spjd reserved = dp->dp_space_towrite[tx->tx_txg & TXG_MASK] 628185029Spjd + dp->dp_tempreserved[tx->tx_txg & TXG_MASK] / 2; 629185029Spjd 630185029Spjd if (reserved && reserved > write_limit) 631185029Spjd return (ERESTART); 632185029Spjd } 633185029Spjd 634185029Spjd atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], space); 635185029Spjd 636185029Spjd /* 637185029Spjd * If this transaction group is over 7/8ths capacity, delay 638185029Spjd * the caller 1 clock tick. This will slow down the "fill" 639185029Spjd * rate until the sync process can catch up with us. 640185029Spjd */ 641185029Spjd if (reserved && reserved > (write_limit - (write_limit >> 3))) 642185029Spjd txg_delay(dp, tx->tx_txg, 1); 643185029Spjd 644185029Spjd return (0); 645185029Spjd} 646185029Spjd 647185029Spjdvoid 648185029Spjddsl_pool_tempreserve_clear(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx) 649185029Spjd{ 650185029Spjd ASSERT(dp->dp_tempreserved[tx->tx_txg & TXG_MASK] >= space); 651185029Spjd atomic_add_64(&dp->dp_tempreserved[tx->tx_txg & TXG_MASK], -space); 652185029Spjd} 653185029Spjd 654185029Spjdvoid 655185029Spjddsl_pool_memory_pressure(dsl_pool_t *dp) 656185029Spjd{ 657185029Spjd uint64_t space_inuse = 0; 658185029Spjd int i; 659185029Spjd 660185029Spjd if (dp->dp_write_limit == zfs_write_limit_min) 661185029Spjd return; 662185029Spjd 663185029Spjd for (i = 0; i < TXG_SIZE; i++) { 664185029Spjd space_inuse += dp->dp_space_towrite[i]; 665185029Spjd space_inuse += dp->dp_tempreserved[i]; 666185029Spjd } 667185029Spjd dp->dp_write_limit = MAX(zfs_write_limit_min, 668185029Spjd MIN(dp->dp_write_limit, space_inuse / 4)); 669185029Spjd} 670185029Spjd 671185029Spjdvoid 672185029Spjddsl_pool_willuse_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx) 673185029Spjd{ 674185029Spjd if (space > 0) { 675185029Spjd mutex_enter(&dp->dp_lock); 676185029Spjd dp->dp_space_towrite[tx->tx_txg & TXG_MASK] += space; 677185029Spjd mutex_exit(&dp->dp_lock); 678185029Spjd } 679185029Spjd} 680185029Spjd 681185029Spjd/* ARGSUSED */ 682185029Spjdstatic int 683185029Spjdupgrade_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg) 684185029Spjd{ 685185029Spjd dmu_tx_t *tx = arg; 686185029Spjd dsl_dataset_t *ds, *prev = NULL; 687185029Spjd int err; 688185029Spjd dsl_pool_t *dp = spa_get_dsl(spa); 689185029Spjd 690185029Spjd err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 691185029Spjd if (err) 692185029Spjd return (err); 693185029Spjd 694185029Spjd while (ds->ds_phys->ds_prev_snap_obj != 0) { 695185029Spjd err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj, 696185029Spjd FTAG, &prev); 697185029Spjd if (err) { 698185029Spjd dsl_dataset_rele(ds, FTAG); 699185029Spjd return (err); 700185029Spjd } 701185029Spjd 702185029Spjd if (prev->ds_phys->ds_next_snap_obj != ds->ds_object) 703185029Spjd break; 704185029Spjd dsl_dataset_rele(ds, FTAG); 705185029Spjd ds = prev; 706185029Spjd prev = NULL; 707185029Spjd } 708185029Spjd 709185029Spjd if (prev == NULL) { 710185029Spjd prev = dp->dp_origin_snap; 711185029Spjd 712185029Spjd /* 713185029Spjd * The $ORIGIN can't have any data, or the accounting 714185029Spjd * will be wrong. 715185029Spjd */ 716185029Spjd ASSERT(prev->ds_phys->ds_bp.blk_birth == 0); 717185029Spjd 718185029Spjd /* The origin doesn't get attached to itself */ 719185029Spjd if (ds->ds_object == prev->ds_object) { 720185029Spjd dsl_dataset_rele(ds, FTAG); 721185029Spjd return (0); 722185029Spjd } 723185029Spjd 724185029Spjd dmu_buf_will_dirty(ds->ds_dbuf, tx); 725185029Spjd ds->ds_phys->ds_prev_snap_obj = prev->ds_object; 726185029Spjd ds->ds_phys->ds_prev_snap_txg = prev->ds_phys->ds_creation_txg; 727185029Spjd 728185029Spjd dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx); 729185029Spjd ds->ds_dir->dd_phys->dd_origin_obj = prev->ds_object; 730185029Spjd 731185029Spjd dmu_buf_will_dirty(prev->ds_dbuf, tx); 732185029Spjd prev->ds_phys->ds_num_children++; 733185029Spjd 734185029Spjd if (ds->ds_phys->ds_next_snap_obj == 0) { 735185029Spjd ASSERT(ds->ds_prev == NULL); 736185029Spjd VERIFY(0 == dsl_dataset_hold_obj(dp, 737185029Spjd ds->ds_phys->ds_prev_snap_obj, ds, &ds->ds_prev)); 738185029Spjd } 739185029Spjd } 740185029Spjd 741185029Spjd ASSERT(ds->ds_dir->dd_phys->dd_origin_obj == prev->ds_object); 742185029Spjd ASSERT(ds->ds_phys->ds_prev_snap_obj == prev->ds_object); 743185029Spjd 744185029Spjd if (prev->ds_phys->ds_next_clones_obj == 0) { 745209962Smm dmu_buf_will_dirty(prev->ds_dbuf, tx); 746185029Spjd prev->ds_phys->ds_next_clones_obj = 747185029Spjd zap_create(dp->dp_meta_objset, 748185029Spjd DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx); 749185029Spjd } 750185029Spjd VERIFY(0 == zap_add_int(dp->dp_meta_objset, 751185029Spjd prev->ds_phys->ds_next_clones_obj, ds->ds_object, tx)); 752185029Spjd 753185029Spjd dsl_dataset_rele(ds, FTAG); 754185029Spjd if (prev != dp->dp_origin_snap) 755185029Spjd dsl_dataset_rele(prev, FTAG); 756185029Spjd return (0); 757185029Spjd} 758185029Spjd 759185029Spjdvoid 760185029Spjddsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx) 761185029Spjd{ 762185029Spjd ASSERT(dmu_tx_is_syncing(tx)); 763185029Spjd ASSERT(dp->dp_origin_snap != NULL); 764185029Spjd 765209962Smm VERIFY3U(0, ==, dmu_objset_find_spa(dp->dp_spa, NULL, upgrade_clones_cb, 766209962Smm tx, DS_FIND_CHILDREN)); 767185029Spjd} 768185029Spjd 769219089Spjd/* ARGSUSED */ 770219089Spjdstatic int 771219089Spjdupgrade_dir_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg) 772219089Spjd{ 773219089Spjd dmu_tx_t *tx = arg; 774219089Spjd dsl_dataset_t *ds; 775219089Spjd dsl_pool_t *dp = spa_get_dsl(spa); 776219089Spjd objset_t *mos = dp->dp_meta_objset; 777219089Spjd 778219089Spjd VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds)); 779219089Spjd 780219089Spjd if (ds->ds_dir->dd_phys->dd_origin_obj) { 781219089Spjd dsl_dataset_t *origin; 782219089Spjd 783219089Spjd VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, 784219089Spjd ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &origin)); 785219089Spjd 786219089Spjd if (origin->ds_dir->dd_phys->dd_clones == 0) { 787219089Spjd dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx); 788219089Spjd origin->ds_dir->dd_phys->dd_clones = zap_create(mos, 789219089Spjd DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx); 790219089Spjd } 791219089Spjd 792219089Spjd VERIFY3U(0, ==, zap_add_int(dp->dp_meta_objset, 793219089Spjd origin->ds_dir->dd_phys->dd_clones, dsobj, tx)); 794219089Spjd 795219089Spjd dsl_dataset_rele(origin, FTAG); 796219089Spjd } 797219089Spjd 798219089Spjd dsl_dataset_rele(ds, FTAG); 799219089Spjd return (0); 800219089Spjd} 801219089Spjd 802185029Spjdvoid 803219089Spjddsl_pool_upgrade_dir_clones(dsl_pool_t *dp, dmu_tx_t *tx) 804219089Spjd{ 805219089Spjd ASSERT(dmu_tx_is_syncing(tx)); 806219089Spjd uint64_t obj; 807219089Spjd 808219089Spjd (void) dsl_dir_create_sync(dp, dp->dp_root_dir, FREE_DIR_NAME, tx); 809219089Spjd VERIFY(0 == dsl_pool_open_special_dir(dp, 810219089Spjd FREE_DIR_NAME, &dp->dp_free_dir)); 811219089Spjd 812219089Spjd /* 813219089Spjd * We can't use bpobj_alloc(), because spa_version() still 814219089Spjd * returns the old version, and we need a new-version bpobj with 815219089Spjd * subobj support. So call dmu_object_alloc() directly. 816219089Spjd */ 817219089Spjd obj = dmu_object_alloc(dp->dp_meta_objset, DMU_OT_BPOBJ, 818219089Spjd SPA_MAXBLOCKSIZE, DMU_OT_BPOBJ_HDR, sizeof (bpobj_phys_t), tx); 819219089Spjd VERIFY3U(0, ==, zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 820219089Spjd DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx)); 821219089Spjd VERIFY3U(0, ==, bpobj_open(&dp->dp_free_bpobj, 822219089Spjd dp->dp_meta_objset, obj)); 823219089Spjd 824219089Spjd VERIFY3U(0, ==, dmu_objset_find_spa(dp->dp_spa, NULL, 825219089Spjd upgrade_dir_clones_cb, tx, DS_FIND_CHILDREN)); 826219089Spjd} 827219089Spjd 828219089Spjdvoid 829185029Spjddsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx) 830185029Spjd{ 831185029Spjd uint64_t dsobj; 832185029Spjd dsl_dataset_t *ds; 833185029Spjd 834185029Spjd ASSERT(dmu_tx_is_syncing(tx)); 835185029Spjd ASSERT(dp->dp_origin_snap == NULL); 836185029Spjd 837185029Spjd /* create the origin dir, ds, & snap-ds */ 838185029Spjd rw_enter(&dp->dp_config_rwlock, RW_WRITER); 839185029Spjd dsobj = dsl_dataset_create_sync(dp->dp_root_dir, ORIGIN_DIR_NAME, 840185029Spjd NULL, 0, kcred, tx); 841185029Spjd VERIFY(0 == dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds)); 842219089Spjd dsl_dataset_snapshot_sync(ds, ORIGIN_DIR_NAME, tx); 843185029Spjd VERIFY(0 == dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj, 844185029Spjd dp, &dp->dp_origin_snap)); 845185029Spjd dsl_dataset_rele(ds, FTAG); 846185029Spjd rw_exit(&dp->dp_config_rwlock); 847185029Spjd} 848196307Spjd 849196307Spjdtaskq_t * 850196307Spjddsl_pool_vnrele_taskq(dsl_pool_t *dp) 851196307Spjd{ 852196307Spjd return (dp->dp_vnrele_taskq); 853196307Spjd} 854219089Spjd 855219089Spjd/* 856219089Spjd * Walk through the pool-wide zap object of temporary snapshot user holds 857219089Spjd * and release them. 858219089Spjd */ 859219089Spjdvoid 860219089Spjddsl_pool_clean_tmp_userrefs(dsl_pool_t *dp) 861219089Spjd{ 862219089Spjd zap_attribute_t za; 863219089Spjd zap_cursor_t zc; 864219089Spjd objset_t *mos = dp->dp_meta_objset; 865219089Spjd uint64_t zapobj = dp->dp_tmp_userrefs_obj; 866219089Spjd 867219089Spjd if (zapobj == 0) 868219089Spjd return; 869219089Spjd ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS); 870219089Spjd 871219089Spjd for (zap_cursor_init(&zc, mos, zapobj); 872219089Spjd zap_cursor_retrieve(&zc, &za) == 0; 873219089Spjd zap_cursor_advance(&zc)) { 874219089Spjd char *htag; 875219089Spjd uint64_t dsobj; 876219089Spjd 877219089Spjd htag = strchr(za.za_name, '-'); 878219089Spjd *htag = '\0'; 879219089Spjd ++htag; 880219089Spjd dsobj = strtonum(za.za_name, NULL); 881219089Spjd (void) dsl_dataset_user_release_tmp(dp, dsobj, htag, B_FALSE); 882219089Spjd } 883219089Spjd zap_cursor_fini(&zc); 884219089Spjd} 885219089Spjd 886219089Spjd/* 887219089Spjd * Create the pool-wide zap object for storing temporary snapshot holds. 888219089Spjd */ 889219089Spjdvoid 890219089Spjddsl_pool_user_hold_create_obj(dsl_pool_t *dp, dmu_tx_t *tx) 891219089Spjd{ 892219089Spjd objset_t *mos = dp->dp_meta_objset; 893219089Spjd 894219089Spjd ASSERT(dp->dp_tmp_userrefs_obj == 0); 895219089Spjd ASSERT(dmu_tx_is_syncing(tx)); 896219089Spjd 897236884Smm dp->dp_tmp_userrefs_obj = zap_create_link(mos, DMU_OT_USERREFS, 898236884Smm DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_TMP_USERREFS, tx); 899219089Spjd} 900219089Spjd 901219089Spjdstatic int 902219089Spjddsl_pool_user_hold_rele_impl(dsl_pool_t *dp, uint64_t dsobj, 903219089Spjd const char *tag, uint64_t *now, dmu_tx_t *tx, boolean_t holding) 904219089Spjd{ 905219089Spjd objset_t *mos = dp->dp_meta_objset; 906219089Spjd uint64_t zapobj = dp->dp_tmp_userrefs_obj; 907219089Spjd char *name; 908219089Spjd int error; 909219089Spjd 910219089Spjd ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS); 911219089Spjd ASSERT(dmu_tx_is_syncing(tx)); 912219089Spjd 913219089Spjd /* 914219089Spjd * If the pool was created prior to SPA_VERSION_USERREFS, the 915219089Spjd * zap object for temporary holds might not exist yet. 916219089Spjd */ 917219089Spjd if (zapobj == 0) { 918219089Spjd if (holding) { 919219089Spjd dsl_pool_user_hold_create_obj(dp, tx); 920219089Spjd zapobj = dp->dp_tmp_userrefs_obj; 921219089Spjd } else { 922219089Spjd return (ENOENT); 923219089Spjd } 924219089Spjd } 925219089Spjd 926219089Spjd name = kmem_asprintf("%llx-%s", (u_longlong_t)dsobj, tag); 927219089Spjd if (holding) 928219089Spjd error = zap_add(mos, zapobj, name, 8, 1, now, tx); 929219089Spjd else 930219089Spjd error = zap_remove(mos, zapobj, name, tx); 931219089Spjd strfree(name); 932219089Spjd 933219089Spjd return (error); 934219089Spjd} 935219089Spjd 936219089Spjd/* 937219089Spjd * Add a temporary hold for the given dataset object and tag. 938219089Spjd */ 939219089Spjdint 940219089Spjddsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj, const char *tag, 941219089Spjd uint64_t *now, dmu_tx_t *tx) 942219089Spjd{ 943219089Spjd return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, now, tx, B_TRUE)); 944219089Spjd} 945219089Spjd 946219089Spjd/* 947219089Spjd * Release a temporary hold for the given dataset object and tag. 948219089Spjd */ 949219089Spjdint 950219089Spjddsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj, const char *tag, 951219089Spjd dmu_tx_t *tx) 952219089Spjd{ 953219089Spjd return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, NULL, 954219089Spjd tx, B_FALSE)); 955219089Spjd} 956