xref: /illumos-gate/usr/src/uts/common/fs/zfs/dsl_pool.c (revision 244781f10dcd82684fd8163c016540667842f203)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
223f9d6ad7SLin Ling  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
232a104a52SAlex Reece  * Copyright (c) 2011, 2014 by Delphix. All rights reserved.
24a7a845e4SSteven Hartland  * Copyright (c) 2013 Steven Hartland. All rights reserved.
25bc9014e6SJustin Gibbs  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
26fa9e4066Sahrens  */
27fa9e4066Sahrens 
28fa9e4066Sahrens #include <sys/dsl_pool.h>
29fa9e4066Sahrens #include <sys/dsl_dataset.h>
303f9d6ad7SLin Ling #include <sys/dsl_prop.h>
31fa9e4066Sahrens #include <sys/dsl_dir.h>
321d452cf5Sahrens #include <sys/dsl_synctask.h>
333f9d6ad7SLin Ling #include <sys/dsl_scan.h>
343f9d6ad7SLin Ling #include <sys/dnode.h>
35fa9e4066Sahrens #include <sys/dmu_tx.h>
36fa9e4066Sahrens #include <sys/dmu_objset.h>
37fa9e4066Sahrens #include <sys/arc.h>
38fa9e4066Sahrens #include <sys/zap.h>
39c717a561Smaybee #include <sys/zio.h>
40fa9e4066Sahrens #include <sys/zfs_context.h>
41fa9e4066Sahrens #include <sys/fs/zfs.h>
42088f3894Sahrens #include <sys/zfs_znode.h>
43088f3894Sahrens #include <sys/spa_impl.h>
44cde58dbcSMatthew Ahrens #include <sys/dsl_deadlist.h>
45ad135b5dSChristopher Siden #include <sys/bptree.h>
46ad135b5dSChristopher Siden #include <sys/zfeature.h>
47ce636f8bSMatthew Ahrens #include <sys/zil_impl.h>
483b2aab18SMatthew Ahrens #include <sys/dsl_userhold.h>
49fa9e4066Sahrens 
5069962b56SMatthew Ahrens /*
5169962b56SMatthew Ahrens  * ZFS Write Throttle
5269962b56SMatthew Ahrens  * ------------------
5369962b56SMatthew Ahrens  *
5469962b56SMatthew Ahrens  * ZFS must limit the rate of incoming writes to the rate at which it is able
5569962b56SMatthew Ahrens  * to sync data modifications to the backend storage. Throttling by too much
5669962b56SMatthew Ahrens  * creates an artificial limit; throttling by too little can only be sustained
5769962b56SMatthew Ahrens  * for short periods and would lead to highly lumpy performance. On a per-pool
5869962b56SMatthew Ahrens  * basis, ZFS tracks the amount of modified (dirty) data. As operations change
5969962b56SMatthew Ahrens  * data, the amount of dirty data increases; as ZFS syncs out data, the amount
6069962b56SMatthew Ahrens  * of dirty data decreases. When the amount of dirty data exceeds a
6169962b56SMatthew Ahrens  * predetermined threshold further modifications are blocked until the amount
6269962b56SMatthew Ahrens  * of dirty data decreases (as data is synced out).
6369962b56SMatthew Ahrens  *
6469962b56SMatthew Ahrens  * The limit on dirty data is tunable, and should be adjusted according to
6569962b56SMatthew Ahrens  * both the IO capacity and available memory of the system. The larger the
6669962b56SMatthew Ahrens  * window, the more ZFS is able to aggregate and amortize metadata (and data)
6769962b56SMatthew Ahrens  * changes. However, memory is a limited resource, and allowing for more dirty
6869962b56SMatthew Ahrens  * data comes at the cost of keeping other useful data in memory (for example
6969962b56SMatthew Ahrens  * ZFS data cached by the ARC).
7069962b56SMatthew Ahrens  *
7169962b56SMatthew Ahrens  * Implementation
7269962b56SMatthew Ahrens  *
7369962b56SMatthew Ahrens  * As buffers are modified dsl_pool_willuse_space() increments both the per-
7469962b56SMatthew Ahrens  * txg (dp_dirty_pertxg[]) and poolwide (dp_dirty_total) accounting of
7569962b56SMatthew Ahrens  * dirty space used; dsl_pool_dirty_space() decrements those values as data
7669962b56SMatthew Ahrens  * is synced out from dsl_pool_sync(). While only the poolwide value is
7769962b56SMatthew Ahrens  * relevant, the per-txg value is useful for debugging. The tunable
7869962b56SMatthew Ahrens  * zfs_dirty_data_max determines the dirty space limit. Once that value is
7969962b56SMatthew Ahrens  * exceeded, new writes are halted until space frees up.
8069962b56SMatthew Ahrens  *
8169962b56SMatthew Ahrens  * The zfs_dirty_data_sync tunable dictates the threshold at which we
8269962b56SMatthew Ahrens  * ensure that there is a txg syncing (see the comment in txg.c for a full
8369962b56SMatthew Ahrens  * description of transaction group stages).
8469962b56SMatthew Ahrens  *
8569962b56SMatthew Ahrens  * The IO scheduler uses both the dirty space limit and current amount of
8669962b56SMatthew Ahrens  * dirty data as inputs. Those values affect the number of concurrent IOs ZFS
8769962b56SMatthew Ahrens  * issues. See the comment in vdev_queue.c for details of the IO scheduler.
8869962b56SMatthew Ahrens  *
8969962b56SMatthew Ahrens  * The delay is also calculated based on the amount of dirty data.  See the
9069962b56SMatthew Ahrens  * comment above dmu_tx_delay() for details.
9169962b56SMatthew Ahrens  */
9269962b56SMatthew Ahrens 
9369962b56SMatthew Ahrens /*
9469962b56SMatthew Ahrens  * zfs_dirty_data_max will be set to zfs_dirty_data_max_percent% of all memory,
9569962b56SMatthew Ahrens  * capped at zfs_dirty_data_max_max.  It can also be overridden in /etc/system.
9669962b56SMatthew Ahrens  */
9769962b56SMatthew Ahrens uint64_t zfs_dirty_data_max;
9869962b56SMatthew Ahrens uint64_t zfs_dirty_data_max_max = 4ULL * 1024 * 1024 * 1024;
9969962b56SMatthew Ahrens int zfs_dirty_data_max_percent = 10;
10069962b56SMatthew Ahrens 
10169962b56SMatthew Ahrens /*
10269962b56SMatthew Ahrens  * If there is at least this much dirty data, push out a txg.
10369962b56SMatthew Ahrens  */
10469962b56SMatthew Ahrens uint64_t zfs_dirty_data_sync = 64 * 1024 * 1024;
10569962b56SMatthew Ahrens 
10669962b56SMatthew Ahrens /*
10769962b56SMatthew Ahrens  * Once there is this amount of dirty data, the dmu_tx_delay() will kick in
10869962b56SMatthew Ahrens  * and delay each transaction.
10969962b56SMatthew Ahrens  * This value should be >= zfs_vdev_async_write_active_max_dirty_percent.
11069962b56SMatthew Ahrens  */
11169962b56SMatthew Ahrens int zfs_delay_min_dirty_percent = 60;
11269962b56SMatthew Ahrens 
11369962b56SMatthew Ahrens /*
11469962b56SMatthew Ahrens  * This controls how quickly the delay approaches infinity.
115d85a1e96SMatthew Ahrens  * Larger values cause it to delay more for a given amount of dirty data.
116d85a1e96SMatthew Ahrens  * Therefore larger values will cause there to be less dirty data for a
11769962b56SMatthew Ahrens  * given throughput.
11869962b56SMatthew Ahrens  *
11969962b56SMatthew Ahrens  * For the smoothest delay, this value should be about 1 billion divided
12069962b56SMatthew Ahrens  * by the maximum number of operations per second.  This will smoothly
12169962b56SMatthew Ahrens  * handle between 10x and 1/10th this number.
12269962b56SMatthew Ahrens  *
12369962b56SMatthew Ahrens  * Note: zfs_delay_scale * zfs_dirty_data_max must be < 2^64, due to the
12469962b56SMatthew Ahrens  * multiply in dmu_tx_delay().
12569962b56SMatthew Ahrens  */
12669962b56SMatthew Ahrens uint64_t zfs_delay_scale = 1000 * 1000 * 1000 / 2000;
12705715f94SMark Maybee 
1281ab7f2deSmaybee 
1290689f76cSAdam Leventhal hrtime_t zfs_throttle_delay = MSEC2NSEC(10);
1300689f76cSAdam Leventhal hrtime_t zfs_throttle_resolution = MSEC2NSEC(10);
1310689f76cSAdam Leventhal 
1323f9d6ad7SLin Ling int
133088f3894Sahrens dsl_pool_open_special_dir(dsl_pool_t *dp, const char *name, dsl_dir_t **ddp)
134fa9e4066Sahrens {
135fa9e4066Sahrens 	uint64_t obj;
136fa9e4066Sahrens 	int err;
137fa9e4066Sahrens 
138fa9e4066Sahrens 	err = zap_lookup(dp->dp_meta_objset,
139c1379625SJustin T. Gibbs 	    dsl_dir_phys(dp->dp_root_dir)->dd_child_dir_zapobj,
140088f3894Sahrens 	    name, sizeof (obj), 1, &obj);
141ea8dc4b6Seschrock 	if (err)
142ea8dc4b6Seschrock 		return (err);
143fa9e4066Sahrens 
1443b2aab18SMatthew Ahrens 	return (dsl_dir_hold_obj(dp, obj, name, dp, ddp));
145fa9e4066Sahrens }
146fa9e4066Sahrens 
147fa9e4066Sahrens static dsl_pool_t *
148fa9e4066Sahrens dsl_pool_open_impl(spa_t *spa, uint64_t txg)
149fa9e4066Sahrens {
150fa9e4066Sahrens 	dsl_pool_t *dp;
151fa9e4066Sahrens 	blkptr_t *bp = spa_get_rootblkptr(spa);
152fa9e4066Sahrens 
153fa9e4066Sahrens 	dp = kmem_zalloc(sizeof (dsl_pool_t), KM_SLEEP);
154fa9e4066Sahrens 	dp->dp_spa = spa;
155fa9e4066Sahrens 	dp->dp_meta_rootbp = *bp;
1563b2aab18SMatthew Ahrens 	rrw_init(&dp->dp_config_rwlock, B_TRUE);
157fa9e4066Sahrens 	txg_init(dp, txg);
158fa9e4066Sahrens 
159fa9e4066Sahrens 	txg_list_create(&dp->dp_dirty_datasets,
160fa9e4066Sahrens 	    offsetof(dsl_dataset_t, ds_dirty_link));
161ce636f8bSMatthew Ahrens 	txg_list_create(&dp->dp_dirty_zilogs,
162ce636f8bSMatthew Ahrens 	    offsetof(zilog_t, zl_dirty_link));
163fa9e4066Sahrens 	txg_list_create(&dp->dp_dirty_dirs,
164fa9e4066Sahrens 	    offsetof(dsl_dir_t, dd_dirty_link));
1651d452cf5Sahrens 	txg_list_create(&dp->dp_sync_tasks,
1663b2aab18SMatthew Ahrens 	    offsetof(dsl_sync_task_t, dst_node));
167fa9e4066Sahrens 
1681ab7f2deSmaybee 	mutex_init(&dp->dp_lock, NULL, MUTEX_DEFAULT, NULL);
16969962b56SMatthew Ahrens 	cv_init(&dp->dp_spaceavail_cv, NULL, CV_DEFAULT, NULL);
1701ab7f2deSmaybee 
1719d3574bfSNeil Perrin 	dp->dp_vnrele_taskq = taskq_create("zfs_vn_rele_taskq", 1, minclsyspri,
1729d3574bfSNeil Perrin 	    1, 4, 0);
1739d3574bfSNeil Perrin 
174fa9e4066Sahrens 	return (dp);
175fa9e4066Sahrens }
176fa9e4066Sahrens 
177ea8dc4b6Seschrock int
178ad135b5dSChristopher Siden dsl_pool_init(spa_t *spa, uint64_t txg, dsl_pool_t **dpp)
179fa9e4066Sahrens {
180fa9e4066Sahrens 	int err;
181fa9e4066Sahrens 	dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
182ad135b5dSChristopher Siden 
183ad135b5dSChristopher Siden 	err = dmu_objset_open_impl(spa, NULL, &dp->dp_meta_rootbp,
184ad135b5dSChristopher Siden 	    &dp->dp_meta_objset);
185ad135b5dSChristopher Siden 	if (err != 0)
186ad135b5dSChristopher Siden 		dsl_pool_close(dp);
187ad135b5dSChristopher Siden 	else
188ad135b5dSChristopher Siden 		*dpp = dp;
189ad135b5dSChristopher Siden 
190ad135b5dSChristopher Siden 	return (err);
191ad135b5dSChristopher Siden }
192ad135b5dSChristopher Siden 
193ad135b5dSChristopher Siden int
194ad135b5dSChristopher Siden dsl_pool_open(dsl_pool_t *dp)
195ad135b5dSChristopher Siden {
196ad135b5dSChristopher Siden 	int err;
197088f3894Sahrens 	dsl_dir_t *dd;
198088f3894Sahrens 	dsl_dataset_t *ds;
199cde58dbcSMatthew Ahrens 	uint64_t obj;
200fa9e4066Sahrens 
2013b2aab18SMatthew Ahrens 	rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
202fa9e4066Sahrens 	err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
203fa9e4066Sahrens 	    DMU_POOL_ROOT_DATASET, sizeof (uint64_t), 1,
204fa9e4066Sahrens 	    &dp->dp_root_dir_obj);
205ea8dc4b6Seschrock 	if (err)
206ea8dc4b6Seschrock 		goto out;
207ea8dc4b6Seschrock 
2083b2aab18SMatthew Ahrens 	err = dsl_dir_hold_obj(dp, dp->dp_root_dir_obj,
209ea8dc4b6Seschrock 	    NULL, dp, &dp->dp_root_dir);
210ea8dc4b6Seschrock 	if (err)
211ea8dc4b6Seschrock 		goto out;
212fa9e4066Sahrens 
213088f3894Sahrens 	err = dsl_pool_open_special_dir(dp, MOS_DIR_NAME, &dp->dp_mos_dir);
214ea8dc4b6Seschrock 	if (err)
215ea8dc4b6Seschrock 		goto out;
216ea8dc4b6Seschrock 
217ad135b5dSChristopher Siden 	if (spa_version(dp->dp_spa) >= SPA_VERSION_ORIGIN) {
218088f3894Sahrens 		err = dsl_pool_open_special_dir(dp, ORIGIN_DIR_NAME, &dd);
219088f3894Sahrens 		if (err)
220088f3894Sahrens 			goto out;
221c1379625SJustin T. Gibbs 		err = dsl_dataset_hold_obj(dp,
222c1379625SJustin T. Gibbs 		    dsl_dir_phys(dd)->dd_head_dataset_obj, FTAG, &ds);
2238f63aa46SLin Ling 		if (err == 0) {
2248f63aa46SLin Ling 			err = dsl_dataset_hold_obj(dp,
225c1379625SJustin T. Gibbs 			    dsl_dataset_phys(ds)->ds_prev_snap_obj, dp,
2268f63aa46SLin Ling 			    &dp->dp_origin_snap);
2278f63aa46SLin Ling 			dsl_dataset_rele(ds, FTAG);
2288f63aa46SLin Ling 		}
2293b2aab18SMatthew Ahrens 		dsl_dir_rele(dd, dp);
230088f3894Sahrens 		if (err)
231088f3894Sahrens 			goto out;
232088f3894Sahrens 	}
233088f3894Sahrens 
234ad135b5dSChristopher Siden 	if (spa_version(dp->dp_spa) >= SPA_VERSION_DEADLISTS) {
235cde58dbcSMatthew Ahrens 		err = dsl_pool_open_special_dir(dp, FREE_DIR_NAME,
236cde58dbcSMatthew Ahrens 		    &dp->dp_free_dir);
237cde58dbcSMatthew Ahrens 		if (err)
238cde58dbcSMatthew Ahrens 			goto out;
239cde58dbcSMatthew Ahrens 
240cde58dbcSMatthew Ahrens 		err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
241cde58dbcSMatthew Ahrens 		    DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj);
242cde58dbcSMatthew Ahrens 		if (err)
243cde58dbcSMatthew Ahrens 			goto out;
2443b2aab18SMatthew Ahrens 		VERIFY0(bpobj_open(&dp->dp_free_bpobj,
245cde58dbcSMatthew Ahrens 		    dp->dp_meta_objset, obj));
246cde58dbcSMatthew Ahrens 	}
247cde58dbcSMatthew Ahrens 
2487fd05ac4SMatthew Ahrens 	/*
2497fd05ac4SMatthew Ahrens 	 * Note: errors ignored, because the leak dir will not exist if we
2507fd05ac4SMatthew Ahrens 	 * have not encountered a leak yet.
2517fd05ac4SMatthew Ahrens 	 */
2527fd05ac4SMatthew Ahrens 	(void) dsl_pool_open_special_dir(dp, LEAK_DIR_NAME,
2537fd05ac4SMatthew Ahrens 	    &dp->dp_leak_dir);
2547fd05ac4SMatthew Ahrens 
2552acef22dSMatthew Ahrens 	if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_ASYNC_DESTROY)) {
256ad135b5dSChristopher Siden 		err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
257ad135b5dSChristopher Siden 		    DMU_POOL_BPTREE_OBJ, sizeof (uint64_t), 1,
258ad135b5dSChristopher Siden 		    &dp->dp_bptree_obj);
259ad135b5dSChristopher Siden 		if (err != 0)
260ad135b5dSChristopher Siden 			goto out;
261ad135b5dSChristopher Siden 	}
262ad135b5dSChristopher Siden 
2632acef22dSMatthew Ahrens 	if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_EMPTY_BPOBJ)) {
264f1745736SMatthew Ahrens 		err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
265f1745736SMatthew Ahrens 		    DMU_POOL_EMPTY_BPOBJ, sizeof (uint64_t), 1,
266f1745736SMatthew Ahrens 		    &dp->dp_empty_bpobj);
267f1745736SMatthew Ahrens 		if (err != 0)
268f1745736SMatthew Ahrens 			goto out;
269f1745736SMatthew Ahrens 	}
270f1745736SMatthew Ahrens 
271ca45db41SChris Kirby 	err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
272ca45db41SChris Kirby 	    DMU_POOL_TMP_USERREFS, sizeof (uint64_t), 1,
273ca45db41SChris Kirby 	    &dp->dp_tmp_userrefs_obj);
274ca45db41SChris Kirby 	if (err == ENOENT)
275ca45db41SChris Kirby 		err = 0;
276ca45db41SChris Kirby 	if (err)
277ca45db41SChris Kirby 		goto out;
278ca45db41SChris Kirby 
279ad135b5dSChristopher Siden 	err = dsl_scan_init(dp, dp->dp_tx.tx_open_txg);
280088f3894Sahrens 
281ea8dc4b6Seschrock out:
2823b2aab18SMatthew Ahrens 	rrw_exit(&dp->dp_config_rwlock, FTAG);
283ea8dc4b6Seschrock 	return (err);
284fa9e4066Sahrens }
285fa9e4066Sahrens 
286fa9e4066Sahrens void
287fa9e4066Sahrens dsl_pool_close(dsl_pool_t *dp)
288fa9e4066Sahrens {
289088f3894Sahrens 	/*
29069962b56SMatthew Ahrens 	 * Drop our references from dsl_pool_open().
29169962b56SMatthew Ahrens 	 *
292088f3894Sahrens 	 * Since we held the origin_snap from "syncing" context (which
293088f3894Sahrens 	 * includes pool-opening context), it actually only got a "ref"
294088f3894Sahrens 	 * and not a hold, so just drop that here.
295088f3894Sahrens 	 */
296088f3894Sahrens 	if (dp->dp_origin_snap)
2973b2aab18SMatthew Ahrens 		dsl_dataset_rele(dp->dp_origin_snap, dp);
298ea8dc4b6Seschrock 	if (dp->dp_mos_dir)
2993b2aab18SMatthew Ahrens 		dsl_dir_rele(dp->dp_mos_dir, dp);
300cde58dbcSMatthew Ahrens 	if (dp->dp_free_dir)
3013b2aab18SMatthew Ahrens 		dsl_dir_rele(dp->dp_free_dir, dp);
3027fd05ac4SMatthew Ahrens 	if (dp->dp_leak_dir)
3037fd05ac4SMatthew Ahrens 		dsl_dir_rele(dp->dp_leak_dir, dp);
304ea8dc4b6Seschrock 	if (dp->dp_root_dir)
3053b2aab18SMatthew Ahrens 		dsl_dir_rele(dp->dp_root_dir, dp);
306fa9e4066Sahrens 
307cde58dbcSMatthew Ahrens 	bpobj_close(&dp->dp_free_bpobj);
308cde58dbcSMatthew Ahrens 
309fa9e4066Sahrens 	/* undo the dmu_objset_open_impl(mos) from dsl_pool_open() */
310ea8dc4b6Seschrock 	if (dp->dp_meta_objset)
311503ad85cSMatthew Ahrens 		dmu_objset_evict(dp->dp_meta_objset);
312fa9e4066Sahrens 
313fa9e4066Sahrens 	txg_list_destroy(&dp->dp_dirty_datasets);
314ce636f8bSMatthew Ahrens 	txg_list_destroy(&dp->dp_dirty_zilogs);
31554a91118SChris Kirby 	txg_list_destroy(&dp->dp_sync_tasks);
316fa9e4066Sahrens 	txg_list_destroy(&dp->dp_dirty_dirs);
317fa9e4066Sahrens 
318*244781f1SPrakash Surya 	/*
319*244781f1SPrakash Surya 	 * We can't set retry to TRUE since we're explicitly specifying
320*244781f1SPrakash Surya 	 * a spa to flush. This is good enough; any missed buffers for
321*244781f1SPrakash Surya 	 * this spa won't cause trouble, and they'll eventually fall
322*244781f1SPrakash Surya 	 * out of the ARC just like any other unused buffer.
323*244781f1SPrakash Surya 	 */
324*244781f1SPrakash Surya 	arc_flush(dp->dp_spa, FALSE);
325*244781f1SPrakash Surya 
326fa9e4066Sahrens 	txg_fini(dp);
3273f9d6ad7SLin Ling 	dsl_scan_fini(dp);
328bc9014e6SJustin Gibbs 	dmu_buf_user_evict_wait();
329bc9014e6SJustin Gibbs 
3303b2aab18SMatthew Ahrens 	rrw_destroy(&dp->dp_config_rwlock);
3311ab7f2deSmaybee 	mutex_destroy(&dp->dp_lock);
3329d3574bfSNeil Perrin 	taskq_destroy(dp->dp_vnrele_taskq);
33388b7b0f2SMatthew Ahrens 	if (dp->dp_blkstats)
33488b7b0f2SMatthew Ahrens 		kmem_free(dp->dp_blkstats, sizeof (zfs_all_blkstats_t));
335fa9e4066Sahrens 	kmem_free(dp, sizeof (dsl_pool_t));
336fa9e4066Sahrens }
337fa9e4066Sahrens 
338fa9e4066Sahrens dsl_pool_t *
3390a48a24eStimh dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg)
340fa9e4066Sahrens {
341fa9e4066Sahrens 	int err;
342fa9e4066Sahrens 	dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
343fa9e4066Sahrens 	dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg);
344503ad85cSMatthew Ahrens 	objset_t *os;
345088f3894Sahrens 	dsl_dataset_t *ds;
346cde58dbcSMatthew Ahrens 	uint64_t obj;
347088f3894Sahrens 
3483b2aab18SMatthew Ahrens 	rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
3493b2aab18SMatthew Ahrens 
350088f3894Sahrens 	/* create and open the MOS (meta-objset) */
351503ad85cSMatthew Ahrens 	dp->dp_meta_objset = dmu_objset_create_impl(spa,
352503ad85cSMatthew Ahrens 	    NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx);
353fa9e4066Sahrens 
354fa9e4066Sahrens 	/* create the pool directory */
355fa9e4066Sahrens 	err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
356fa9e4066Sahrens 	    DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx);
357fb09f5aaSMadhav Suresh 	ASSERT0(err);
358fa9e4066Sahrens 
3593f9d6ad7SLin Ling 	/* Initialize scan structures */
3603b2aab18SMatthew Ahrens 	VERIFY0(dsl_scan_init(dp, txg));
3613f9d6ad7SLin Ling 
362fa9e4066Sahrens 	/* create and open the root dir */
363088f3894Sahrens 	dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx);
3643b2aab18SMatthew Ahrens 	VERIFY0(dsl_dir_hold_obj(dp, dp->dp_root_dir_obj,
365ea8dc4b6Seschrock 	    NULL, dp, &dp->dp_root_dir));
366fa9e4066Sahrens 
367fa9e4066Sahrens 	/* create and open the meta-objset dir */
368088f3894Sahrens 	(void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx);
3693b2aab18SMatthew Ahrens 	VERIFY0(dsl_pool_open_special_dir(dp,
370088f3894Sahrens 	    MOS_DIR_NAME, &dp->dp_mos_dir));
371088f3894Sahrens 
372cde58dbcSMatthew Ahrens 	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
373cde58dbcSMatthew Ahrens 		/* create and open the free dir */
374cde58dbcSMatthew Ahrens 		(void) dsl_dir_create_sync(dp, dp->dp_root_dir,
375cde58dbcSMatthew Ahrens 		    FREE_DIR_NAME, tx);
3763b2aab18SMatthew Ahrens 		VERIFY0(dsl_pool_open_special_dir(dp,
377cde58dbcSMatthew Ahrens 		    FREE_DIR_NAME, &dp->dp_free_dir));
378cde58dbcSMatthew Ahrens 
379cde58dbcSMatthew Ahrens 		/* create and open the free_bplist */
380b5152584SMatthew Ahrens 		obj = bpobj_alloc(dp->dp_meta_objset, SPA_OLD_MAXBLOCKSIZE, tx);
381cde58dbcSMatthew Ahrens 		VERIFY(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
382cde58dbcSMatthew Ahrens 		    DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx) == 0);
3833b2aab18SMatthew Ahrens 		VERIFY0(bpobj_open(&dp->dp_free_bpobj,
384cde58dbcSMatthew Ahrens 		    dp->dp_meta_objset, obj));
385cde58dbcSMatthew Ahrens 	}
386cde58dbcSMatthew Ahrens 
387088f3894Sahrens 	if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB)
388088f3894Sahrens 		dsl_pool_create_origin(dp, tx);
389088f3894Sahrens 
390088f3894Sahrens 	/* create the root dataset */
391cde58dbcSMatthew Ahrens 	obj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx);
392088f3894Sahrens 
393088f3894Sahrens 	/* create the root objset */
3943b2aab18SMatthew Ahrens 	VERIFY0(dsl_dataset_hold_obj(dp, obj, FTAG, &ds));
395503ad85cSMatthew Ahrens 	os = dmu_objset_create_impl(dp->dp_spa, ds,
396088f3894Sahrens 	    dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx);
397088f3894Sahrens #ifdef _KERNEL
398503ad85cSMatthew Ahrens 	zfs_create_fs(os, kcred, zplprops, tx);
399088f3894Sahrens #endif
400088f3894Sahrens 	dsl_dataset_rele(ds, FTAG);
401fa9e4066Sahrens 
402fa9e4066Sahrens 	dmu_tx_commit(tx);
403fa9e4066Sahrens 
4043b2aab18SMatthew Ahrens 	rrw_exit(&dp->dp_config_rwlock, FTAG);
4053b2aab18SMatthew Ahrens 
406fa9e4066Sahrens 	return (dp);
407fa9e4066Sahrens }
408fa9e4066Sahrens 
409ce636f8bSMatthew Ahrens /*
410ce636f8bSMatthew Ahrens  * Account for the meta-objset space in its placeholder dsl_dir.
411ce636f8bSMatthew Ahrens  */
412ce636f8bSMatthew Ahrens void
413ce636f8bSMatthew Ahrens dsl_pool_mos_diduse_space(dsl_pool_t *dp,
414ce636f8bSMatthew Ahrens     int64_t used, int64_t comp, int64_t uncomp)
415ce636f8bSMatthew Ahrens {
416ce636f8bSMatthew Ahrens 	ASSERT3U(comp, ==, uncomp); /* it's all metadata */
417ce636f8bSMatthew Ahrens 	mutex_enter(&dp->dp_lock);
418ce636f8bSMatthew Ahrens 	dp->dp_mos_used_delta += used;
419ce636f8bSMatthew Ahrens 	dp->dp_mos_compressed_delta += comp;
420ce636f8bSMatthew Ahrens 	dp->dp_mos_uncompressed_delta += uncomp;
421ce636f8bSMatthew Ahrens 	mutex_exit(&dp->dp_lock);
422ce636f8bSMatthew Ahrens }
423ce636f8bSMatthew Ahrens 
424cde58dbcSMatthew Ahrens static int
425cde58dbcSMatthew Ahrens deadlist_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
426cde58dbcSMatthew Ahrens {
427cde58dbcSMatthew Ahrens 	dsl_deadlist_t *dl = arg;
428cde58dbcSMatthew Ahrens 	dsl_deadlist_insert(dl, bp, tx);
429cde58dbcSMatthew Ahrens 	return (0);
430cde58dbcSMatthew Ahrens }
431cde58dbcSMatthew Ahrens 
43269962b56SMatthew Ahrens static void
43369962b56SMatthew Ahrens dsl_pool_sync_mos(dsl_pool_t *dp, dmu_tx_t *tx)
43469962b56SMatthew Ahrens {
43569962b56SMatthew Ahrens 	zio_t *zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
43669962b56SMatthew Ahrens 	dmu_objset_sync(dp->dp_meta_objset, zio, tx);
43769962b56SMatthew Ahrens 	VERIFY0(zio_wait(zio));
43869962b56SMatthew Ahrens 	dprintf_bp(&dp->dp_meta_rootbp, "meta objset rootbp is %s", "");
43969962b56SMatthew Ahrens 	spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp);
44069962b56SMatthew Ahrens }
44169962b56SMatthew Ahrens 
44269962b56SMatthew Ahrens static void
44369962b56SMatthew Ahrens dsl_pool_dirty_delta(dsl_pool_t *dp, int64_t delta)
44469962b56SMatthew Ahrens {
44569962b56SMatthew Ahrens 	ASSERT(MUTEX_HELD(&dp->dp_lock));
44669962b56SMatthew Ahrens 
44769962b56SMatthew Ahrens 	if (delta < 0)
44869962b56SMatthew Ahrens 		ASSERT3U(-delta, <=, dp->dp_dirty_total);
44969962b56SMatthew Ahrens 
45069962b56SMatthew Ahrens 	dp->dp_dirty_total += delta;
45169962b56SMatthew Ahrens 
45269962b56SMatthew Ahrens 	/*
45369962b56SMatthew Ahrens 	 * Note: we signal even when increasing dp_dirty_total.
45469962b56SMatthew Ahrens 	 * This ensures forward progress -- each thread wakes the next waiter.
45569962b56SMatthew Ahrens 	 */
45669962b56SMatthew Ahrens 	if (dp->dp_dirty_total <= zfs_dirty_data_max)
45769962b56SMatthew Ahrens 		cv_signal(&dp->dp_spaceavail_cv);
45869962b56SMatthew Ahrens }
45969962b56SMatthew Ahrens 
460fa9e4066Sahrens void
461fa9e4066Sahrens dsl_pool_sync(dsl_pool_t *dp, uint64_t txg)
462fa9e4066Sahrens {
463c717a561Smaybee 	zio_t *zio;
464fa9e4066Sahrens 	dmu_tx_t *tx;
465c717a561Smaybee 	dsl_dir_t *dd;
466c717a561Smaybee 	dsl_dataset_t *ds;
467503ad85cSMatthew Ahrens 	objset_t *mos = dp->dp_meta_objset;
468ce636f8bSMatthew Ahrens 	list_t synced_datasets;
469ce636f8bSMatthew Ahrens 
470ce636f8bSMatthew Ahrens 	list_create(&synced_datasets, sizeof (dsl_dataset_t),
471ce636f8bSMatthew Ahrens 	    offsetof(dsl_dataset_t, ds_synced_link));
472fa9e4066Sahrens 
473fa9e4066Sahrens 	tx = dmu_tx_create_assigned(dp, txg);
474fa9e4066Sahrens 
47569962b56SMatthew Ahrens 	/*
47669962b56SMatthew Ahrens 	 * Write out all dirty blocks of dirty datasets.
47769962b56SMatthew Ahrens 	 */
478c717a561Smaybee 	zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
47969962b56SMatthew Ahrens 	while ((ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) != NULL) {
48014843421SMatthew Ahrens 		/*
48114843421SMatthew Ahrens 		 * We must not sync any non-MOS datasets twice, because
48214843421SMatthew Ahrens 		 * we may have taken a snapshot of them.  However, we
48314843421SMatthew Ahrens 		 * may sync newly-created datasets on pass 2.
48414843421SMatthew Ahrens 		 */
48514843421SMatthew Ahrens 		ASSERT(!list_link_active(&ds->ds_synced_link));
486ce636f8bSMatthew Ahrens 		list_insert_tail(&synced_datasets, ds);
487c717a561Smaybee 		dsl_dataset_sync(ds, zio, tx);
488c717a561Smaybee 	}
48969962b56SMatthew Ahrens 	VERIFY0(zio_wait(zio));
49014843421SMatthew Ahrens 
49169962b56SMatthew Ahrens 	/*
49269962b56SMatthew Ahrens 	 * We have written all of the accounted dirty data, so our
49369962b56SMatthew Ahrens 	 * dp_space_towrite should now be zero.  However, some seldom-used
49469962b56SMatthew Ahrens 	 * code paths do not adhere to this (e.g. dbuf_undirty(), also
49569962b56SMatthew Ahrens 	 * rounding error in dbuf_write_physdone).
49669962b56SMatthew Ahrens 	 * Shore up the accounting of any dirtied space now.
49769962b56SMatthew Ahrens 	 */
49869962b56SMatthew Ahrens 	dsl_pool_undirty_space(dp, dp->dp_dirty_pertxg[txg & TXG_MASK], txg);
499c717a561Smaybee 
500ce636f8bSMatthew Ahrens 	/*
501ce636f8bSMatthew Ahrens 	 * After the data blocks have been written (ensured by the zio_wait()
502ce636f8bSMatthew Ahrens 	 * above), update the user/group space accounting.
503ce636f8bSMatthew Ahrens 	 */
50469962b56SMatthew Ahrens 	for (ds = list_head(&synced_datasets); ds != NULL;
50569962b56SMatthew Ahrens 	    ds = list_next(&synced_datasets, ds)) {
5060a586ceaSMark Shellenbaum 		dmu_objset_do_userquota_updates(ds->ds_objset, tx);
50769962b56SMatthew Ahrens 	}
50814843421SMatthew Ahrens 
50914843421SMatthew Ahrens 	/*
51014843421SMatthew Ahrens 	 * Sync the datasets again to push out the changes due to
5113f9d6ad7SLin Ling 	 * userspace updates.  This must be done before we process the
512ce636f8bSMatthew Ahrens 	 * sync tasks, so that any snapshots will have the correct
513ce636f8bSMatthew Ahrens 	 * user accounting information (and we won't get confused
514ce636f8bSMatthew Ahrens 	 * about which blocks are part of the snapshot).
51514843421SMatthew Ahrens 	 */
51614843421SMatthew Ahrens 	zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
51769962b56SMatthew Ahrens 	while ((ds = txg_list_remove(&dp->dp_dirty_datasets, txg)) != NULL) {
51814843421SMatthew Ahrens 		ASSERT(list_link_active(&ds->ds_synced_link));
51914843421SMatthew Ahrens 		dmu_buf_rele(ds->ds_dbuf, ds);
52014843421SMatthew Ahrens 		dsl_dataset_sync(ds, zio, tx);
52114843421SMatthew Ahrens 	}
52269962b56SMatthew Ahrens 	VERIFY0(zio_wait(zio));
52314843421SMatthew Ahrens 
524b24ab676SJeff Bonwick 	/*
525ce636f8bSMatthew Ahrens 	 * Now that the datasets have been completely synced, we can
526ce636f8bSMatthew Ahrens 	 * clean up our in-memory structures accumulated while syncing:
527ce636f8bSMatthew Ahrens 	 *
528ce636f8bSMatthew Ahrens 	 *  - move dead blocks from the pending deadlist to the on-disk deadlist
529ce636f8bSMatthew Ahrens 	 *  - release hold from dsl_dataset_dirty()
530b24ab676SJeff Bonwick 	 */
53169962b56SMatthew Ahrens 	while ((ds = list_remove_head(&synced_datasets)) != NULL) {
532ce636f8bSMatthew Ahrens 		objset_t *os = ds->ds_objset;
533cde58dbcSMatthew Ahrens 		bplist_iterate(&ds->ds_pending_deadlist,
534cde58dbcSMatthew Ahrens 		    deadlist_enqueue_cb, &ds->ds_deadlist, tx);
535ce636f8bSMatthew Ahrens 		ASSERT(!dmu_objset_is_dirty(os, txg));
536ce636f8bSMatthew Ahrens 		dmu_buf_rele(ds->ds_dbuf, ds);
537cde58dbcSMatthew Ahrens 	}
53869962b56SMatthew Ahrens 	while ((dd = txg_list_remove(&dp->dp_dirty_dirs, txg)) != NULL) {
539c717a561Smaybee 		dsl_dir_sync(dd, tx);
54069962b56SMatthew Ahrens 	}
541fa9e4066Sahrens 
542ce636f8bSMatthew Ahrens 	/*
543ce636f8bSMatthew Ahrens 	 * The MOS's space is accounted for in the pool/$MOS
544ce636f8bSMatthew Ahrens 	 * (dp_mos_dir).  We can't modify the mos while we're syncing
545ce636f8bSMatthew Ahrens 	 * it, so we remember the deltas and apply them here.
546ce636f8bSMatthew Ahrens 	 */
547ce636f8bSMatthew Ahrens 	if (dp->dp_mos_used_delta != 0 || dp->dp_mos_compressed_delta != 0 ||
548ce636f8bSMatthew Ahrens 	    dp->dp_mos_uncompressed_delta != 0) {
549ce636f8bSMatthew Ahrens 		dsl_dir_diduse_space(dp->dp_mos_dir, DD_USED_HEAD,
550ce636f8bSMatthew Ahrens 		    dp->dp_mos_used_delta,
551ce636f8bSMatthew Ahrens 		    dp->dp_mos_compressed_delta,
552ce636f8bSMatthew Ahrens 		    dp->dp_mos_uncompressed_delta, tx);
553ce636f8bSMatthew Ahrens 		dp->dp_mos_used_delta = 0;
554ce636f8bSMatthew Ahrens 		dp->dp_mos_compressed_delta = 0;
555ce636f8bSMatthew Ahrens 		dp->dp_mos_uncompressed_delta = 0;
556ce636f8bSMatthew Ahrens 	}
557ce636f8bSMatthew Ahrens 
558503ad85cSMatthew Ahrens 	if (list_head(&mos->os_dirty_dnodes[txg & TXG_MASK]) != NULL ||
559503ad85cSMatthew Ahrens 	    list_head(&mos->os_free_dnodes[txg & TXG_MASK]) != NULL) {
56069962b56SMatthew Ahrens 		dsl_pool_sync_mos(dp, tx);
561fa9e4066Sahrens 	}
562fa9e4066Sahrens 
563ce636f8bSMatthew Ahrens 	/*
564ce636f8bSMatthew Ahrens 	 * If we modify a dataset in the same txg that we want to destroy it,
565ce636f8bSMatthew Ahrens 	 * its dsl_dir's dd_dbuf will be dirty, and thus have a hold on it.
566ce636f8bSMatthew Ahrens 	 * dsl_dir_destroy_check() will fail if there are unexpected holds.
567ce636f8bSMatthew Ahrens 	 * Therefore, we want to sync the MOS (thus syncing the dd_dbuf
568ce636f8bSMatthew Ahrens 	 * and clearing the hold on it) before we process the sync_tasks.
569ce636f8bSMatthew Ahrens 	 * The MOS data dirtied by the sync_tasks will be synced on the next
570ce636f8bSMatthew Ahrens 	 * pass.
571ce636f8bSMatthew Ahrens 	 */
572ce636f8bSMatthew Ahrens 	if (!txg_list_empty(&dp->dp_sync_tasks, txg)) {
5733b2aab18SMatthew Ahrens 		dsl_sync_task_t *dst;
574ce636f8bSMatthew Ahrens 		/*
575ce636f8bSMatthew Ahrens 		 * No more sync tasks should have been added while we
576ce636f8bSMatthew Ahrens 		 * were syncing.
577ce636f8bSMatthew Ahrens 		 */
57869962b56SMatthew Ahrens 		ASSERT3U(spa_sync_pass(dp->dp_spa), ==, 1);
57969962b56SMatthew Ahrens 		while ((dst = txg_list_remove(&dp->dp_sync_tasks, txg)) != NULL)
5803b2aab18SMatthew Ahrens 			dsl_sync_task_sync(dst, tx);
581ce636f8bSMatthew Ahrens 	}
582ce636f8bSMatthew Ahrens 
583fa9e4066Sahrens 	dmu_tx_commit(tx);
58405715f94SMark Maybee 
58569962b56SMatthew Ahrens 	DTRACE_PROBE2(dsl_pool_sync__done, dsl_pool_t *dp, dp, uint64_t, txg);
586fa9e4066Sahrens }
587fa9e4066Sahrens 
588fa9e4066Sahrens void
589b24ab676SJeff Bonwick dsl_pool_sync_done(dsl_pool_t *dp, uint64_t txg)
590fa9e4066Sahrens {
591ce636f8bSMatthew Ahrens 	zilog_t *zilog;
592fa9e4066Sahrens 
593ce636f8bSMatthew Ahrens 	while (zilog = txg_list_remove(&dp->dp_dirty_zilogs, txg)) {
59469962b56SMatthew Ahrens 		dsl_dataset_t *ds = dmu_objset_ds(zilog->zl_os);
595ce636f8bSMatthew Ahrens 		zil_clean(zilog, txg);
596ce636f8bSMatthew Ahrens 		ASSERT(!dmu_objset_is_dirty(zilog->zl_os, txg));
597ce636f8bSMatthew Ahrens 		dmu_buf_rele(ds->ds_dbuf, zilog);
598fa9e4066Sahrens 	}
599b24ab676SJeff Bonwick 	ASSERT(!dmu_objset_is_dirty(dp->dp_meta_objset, txg));
600fa9e4066Sahrens }
601fa9e4066Sahrens 
602c717a561Smaybee /*
603c717a561Smaybee  * TRUE if the current thread is the tx_sync_thread or if we
604c717a561Smaybee  * are being called from SPA context during pool initialization.
605c717a561Smaybee  */
606fa9e4066Sahrens int
607fa9e4066Sahrens dsl_pool_sync_context(dsl_pool_t *dp)
608fa9e4066Sahrens {
609fa9e4066Sahrens 	return (curthread == dp->dp_tx.tx_sync_thread ||
610ad135b5dSChristopher Siden 	    spa_is_initializing(dp->dp_spa));
611fa9e4066Sahrens }
612fa9e4066Sahrens 
613fa9e4066Sahrens uint64_t
614fa9e4066Sahrens dsl_pool_adjustedsize(dsl_pool_t *dp, boolean_t netfree)
615fa9e4066Sahrens {
616fa9e4066Sahrens 	uint64_t space, resv;
617fa9e4066Sahrens 
618fa9e4066Sahrens 	/*
619fa9e4066Sahrens 	 * If we're trying to assess whether it's OK to do a free,
620fa9e4066Sahrens 	 * cut the reservation in half to allow forward progress
621fa9e4066Sahrens 	 * (e.g. make it possible to rm(1) files from a full pool).
622fa9e4066Sahrens 	 */
623485bbbf5SGeorge Wilson 	space = spa_get_dspace(dp->dp_spa);
624c39f2c8cSChristopher Siden 	resv = spa_get_slop_space(dp->dp_spa);
625fa9e4066Sahrens 	if (netfree)
626fa9e4066Sahrens 		resv >>= 1;
627fa9e4066Sahrens 
628fa9e4066Sahrens 	return (space - resv);
629fa9e4066Sahrens }
6301ab7f2deSmaybee 
63169962b56SMatthew Ahrens boolean_t
63269962b56SMatthew Ahrens dsl_pool_need_dirty_delay(dsl_pool_t *dp)
6331ab7f2deSmaybee {
63469962b56SMatthew Ahrens 	uint64_t delay_min_bytes =
63569962b56SMatthew Ahrens 	    zfs_dirty_data_max * zfs_delay_min_dirty_percent / 100;
63669962b56SMatthew Ahrens 	boolean_t rv;
6371ab7f2deSmaybee 
63869962b56SMatthew Ahrens 	mutex_enter(&dp->dp_lock);
63969962b56SMatthew Ahrens 	if (dp->dp_dirty_total > zfs_dirty_data_sync)
64069962b56SMatthew Ahrens 		txg_kick(dp);
64169962b56SMatthew Ahrens 	rv = (dp->dp_dirty_total > delay_min_bytes);
64269962b56SMatthew Ahrens 	mutex_exit(&dp->dp_lock);
64369962b56SMatthew Ahrens 	return (rv);
6441ab7f2deSmaybee }
6451ab7f2deSmaybee 
6461ab7f2deSmaybee void
64769962b56SMatthew Ahrens dsl_pool_dirty_space(dsl_pool_t *dp, int64_t space, dmu_tx_t *tx)
6481ab7f2deSmaybee {
64969962b56SMatthew Ahrens 	if (space > 0) {
65069962b56SMatthew Ahrens 		mutex_enter(&dp->dp_lock);
65169962b56SMatthew Ahrens 		dp->dp_dirty_pertxg[tx->tx_txg & TXG_MASK] += space;
65269962b56SMatthew Ahrens 		dsl_pool_dirty_delta(dp, space);
65369962b56SMatthew Ahrens 		mutex_exit(&dp->dp_lock);
6541ab7f2deSmaybee 	}
6551ab7f2deSmaybee }
6561ab7f2deSmaybee 
6571ab7f2deSmaybee void
65869962b56SMatthew Ahrens dsl_pool_undirty_space(dsl_pool_t *dp, int64_t space, uint64_t txg)
6591ab7f2deSmaybee {
66069962b56SMatthew Ahrens 	ASSERT3S(space, >=, 0);
66169962b56SMatthew Ahrens 	if (space == 0)
66269962b56SMatthew Ahrens 		return;
66369962b56SMatthew Ahrens 	mutex_enter(&dp->dp_lock);
66469962b56SMatthew Ahrens 	if (dp->dp_dirty_pertxg[txg & TXG_MASK] < space) {
66569962b56SMatthew Ahrens 		/* XXX writing something we didn't dirty? */
66669962b56SMatthew Ahrens 		space = dp->dp_dirty_pertxg[txg & TXG_MASK];
6671ab7f2deSmaybee 	}
66869962b56SMatthew Ahrens 	ASSERT3U(dp->dp_dirty_pertxg[txg & TXG_MASK], >=, space);
66969962b56SMatthew Ahrens 	dp->dp_dirty_pertxg[txg & TXG_MASK] -= space;
67069962b56SMatthew Ahrens 	ASSERT3U(dp->dp_dirty_total, >=, space);
67169962b56SMatthew Ahrens 	dsl_pool_dirty_delta(dp, -space);
67269962b56SMatthew Ahrens 	mutex_exit(&dp->dp_lock);
6731ab7f2deSmaybee }
674088f3894Sahrens 
675088f3894Sahrens /* ARGSUSED */
676088f3894Sahrens static int
6773b2aab18SMatthew Ahrens upgrade_clones_cb(dsl_pool_t *dp, dsl_dataset_t *hds, void *arg)
678088f3894Sahrens {
679088f3894Sahrens 	dmu_tx_t *tx = arg;
680088f3894Sahrens 	dsl_dataset_t *ds, *prev = NULL;
681088f3894Sahrens 	int err;
682088f3894Sahrens 
6833b2aab18SMatthew Ahrens 	err = dsl_dataset_hold_obj(dp, hds->ds_object, FTAG, &ds);
684088f3894Sahrens 	if (err)
685088f3894Sahrens 		return (err);
686088f3894Sahrens 
687c1379625SJustin T. Gibbs 	while (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
688c1379625SJustin T. Gibbs 		err = dsl_dataset_hold_obj(dp,
689c1379625SJustin T. Gibbs 		    dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
690088f3894Sahrens 		if (err) {
691088f3894Sahrens 			dsl_dataset_rele(ds, FTAG);
692088f3894Sahrens 			return (err);
693088f3894Sahrens 		}
694088f3894Sahrens 
695c1379625SJustin T. Gibbs 		if (dsl_dataset_phys(prev)->ds_next_snap_obj != ds->ds_object)
696088f3894Sahrens 			break;
697088f3894Sahrens 		dsl_dataset_rele(ds, FTAG);
698088f3894Sahrens 		ds = prev;
699088f3894Sahrens 		prev = NULL;
700088f3894Sahrens 	}
701088f3894Sahrens 
702088f3894Sahrens 	if (prev == NULL) {
703088f3894Sahrens 		prev = dp->dp_origin_snap;
704088f3894Sahrens 
705088f3894Sahrens 		/*
706088f3894Sahrens 		 * The $ORIGIN can't have any data, or the accounting
707088f3894Sahrens 		 * will be wrong.
708088f3894Sahrens 		 */
709c1379625SJustin T. Gibbs 		ASSERT0(dsl_dataset_phys(prev)->ds_bp.blk_birth);
710088f3894Sahrens 
711088f3894Sahrens 		/* The origin doesn't get attached to itself */
712088f3894Sahrens 		if (ds->ds_object == prev->ds_object) {
713088f3894Sahrens 			dsl_dataset_rele(ds, FTAG);
714088f3894Sahrens 			return (0);
715088f3894Sahrens 		}
716088f3894Sahrens 
717088f3894Sahrens 		dmu_buf_will_dirty(ds->ds_dbuf, tx);
718c1379625SJustin T. Gibbs 		dsl_dataset_phys(ds)->ds_prev_snap_obj = prev->ds_object;
719c1379625SJustin T. Gibbs 		dsl_dataset_phys(ds)->ds_prev_snap_txg =
720c1379625SJustin T. Gibbs 		    dsl_dataset_phys(prev)->ds_creation_txg;
721088f3894Sahrens 
722088f3894Sahrens 		dmu_buf_will_dirty(ds->ds_dir->dd_dbuf, tx);
723c1379625SJustin T. Gibbs 		dsl_dir_phys(ds->ds_dir)->dd_origin_obj = prev->ds_object;
724088f3894Sahrens 
725088f3894Sahrens 		dmu_buf_will_dirty(prev->ds_dbuf, tx);
726c1379625SJustin T. Gibbs 		dsl_dataset_phys(prev)->ds_num_children++;
727088f3894Sahrens 
728c1379625SJustin T. Gibbs 		if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0) {
729088f3894Sahrens 			ASSERT(ds->ds_prev == NULL);
7303b2aab18SMatthew Ahrens 			VERIFY0(dsl_dataset_hold_obj(dp,
731c1379625SJustin T. Gibbs 			    dsl_dataset_phys(ds)->ds_prev_snap_obj,
732c1379625SJustin T. Gibbs 			    ds, &ds->ds_prev));
733088f3894Sahrens 		}
734088f3894Sahrens 	}
735088f3894Sahrens 
736c1379625SJustin T. Gibbs 	ASSERT3U(dsl_dir_phys(ds->ds_dir)->dd_origin_obj, ==, prev->ds_object);
737c1379625SJustin T. Gibbs 	ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_obj, ==, prev->ds_object);
738088f3894Sahrens 
739c1379625SJustin T. Gibbs 	if (dsl_dataset_phys(prev)->ds_next_clones_obj == 0) {
740c33e334fSMatthew Ahrens 		dmu_buf_will_dirty(prev->ds_dbuf, tx);
741c1379625SJustin T. Gibbs 		dsl_dataset_phys(prev)->ds_next_clones_obj =
742088f3894Sahrens 		    zap_create(dp->dp_meta_objset,
743088f3894Sahrens 		    DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
744088f3894Sahrens 	}
7453b2aab18SMatthew Ahrens 	VERIFY0(zap_add_int(dp->dp_meta_objset,
746c1379625SJustin T. Gibbs 	    dsl_dataset_phys(prev)->ds_next_clones_obj, ds->ds_object, tx));
747088f3894Sahrens 
748088f3894Sahrens 	dsl_dataset_rele(ds, FTAG);
749088f3894Sahrens 	if (prev != dp->dp_origin_snap)
750088f3894Sahrens 		dsl_dataset_rele(prev, FTAG);
751088f3894Sahrens 	return (0);
752088f3894Sahrens }
753088f3894Sahrens 
754088f3894Sahrens void
755088f3894Sahrens dsl_pool_upgrade_clones(dsl_pool_t *dp, dmu_tx_t *tx)
756088f3894Sahrens {
757088f3894Sahrens 	ASSERT(dmu_tx_is_syncing(tx));
758088f3894Sahrens 	ASSERT(dp->dp_origin_snap != NULL);
759088f3894Sahrens 
7603b2aab18SMatthew Ahrens 	VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj, upgrade_clones_cb,
761c33e334fSMatthew Ahrens 	    tx, DS_FIND_CHILDREN));
762088f3894Sahrens }
763088f3894Sahrens 
764cde58dbcSMatthew Ahrens /* ARGSUSED */
765cde58dbcSMatthew Ahrens static int
7663b2aab18SMatthew Ahrens upgrade_dir_clones_cb(dsl_pool_t *dp, dsl_dataset_t *ds, void *arg)
767cde58dbcSMatthew Ahrens {
768cde58dbcSMatthew Ahrens 	dmu_tx_t *tx = arg;
769cde58dbcSMatthew Ahrens 	objset_t *mos = dp->dp_meta_objset;
770cde58dbcSMatthew Ahrens 
771c1379625SJustin T. Gibbs 	if (dsl_dir_phys(ds->ds_dir)->dd_origin_obj != 0) {
772cde58dbcSMatthew Ahrens 		dsl_dataset_t *origin;
773cde58dbcSMatthew Ahrens 
7743b2aab18SMatthew Ahrens 		VERIFY0(dsl_dataset_hold_obj(dp,
775c1379625SJustin T. Gibbs 		    dsl_dir_phys(ds->ds_dir)->dd_origin_obj, FTAG, &origin));
776cde58dbcSMatthew Ahrens 
777c1379625SJustin T. Gibbs 		if (dsl_dir_phys(origin->ds_dir)->dd_clones == 0) {
778cde58dbcSMatthew Ahrens 			dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
779c1379625SJustin T. Gibbs 			dsl_dir_phys(origin->ds_dir)->dd_clones =
780c1379625SJustin T. Gibbs 			    zap_create(mos, DMU_OT_DSL_CLONES, DMU_OT_NONE,
781c1379625SJustin T. Gibbs 			    0, tx);
782cde58dbcSMatthew Ahrens 		}
783cde58dbcSMatthew Ahrens 
7843b2aab18SMatthew Ahrens 		VERIFY0(zap_add_int(dp->dp_meta_objset,
785c1379625SJustin T. Gibbs 		    dsl_dir_phys(origin->ds_dir)->dd_clones,
786c1379625SJustin T. Gibbs 		    ds->ds_object, tx));
787cde58dbcSMatthew Ahrens 
788cde58dbcSMatthew Ahrens 		dsl_dataset_rele(origin, FTAG);
789cde58dbcSMatthew Ahrens 	}
790cde58dbcSMatthew Ahrens 	return (0);
791cde58dbcSMatthew Ahrens }
792cde58dbcSMatthew Ahrens 
793cde58dbcSMatthew Ahrens void
794cde58dbcSMatthew Ahrens dsl_pool_upgrade_dir_clones(dsl_pool_t *dp, dmu_tx_t *tx)
795cde58dbcSMatthew Ahrens {
796cde58dbcSMatthew Ahrens 	ASSERT(dmu_tx_is_syncing(tx));
797cde58dbcSMatthew Ahrens 	uint64_t obj;
798cde58dbcSMatthew Ahrens 
799cde58dbcSMatthew Ahrens 	(void) dsl_dir_create_sync(dp, dp->dp_root_dir, FREE_DIR_NAME, tx);
8003b2aab18SMatthew Ahrens 	VERIFY0(dsl_pool_open_special_dir(dp,
801cde58dbcSMatthew Ahrens 	    FREE_DIR_NAME, &dp->dp_free_dir));
802cde58dbcSMatthew Ahrens 
803cde58dbcSMatthew Ahrens 	/*
804cde58dbcSMatthew Ahrens 	 * We can't use bpobj_alloc(), because spa_version() still
805cde58dbcSMatthew Ahrens 	 * returns the old version, and we need a new-version bpobj with
806cde58dbcSMatthew Ahrens 	 * subobj support.  So call dmu_object_alloc() directly.
807cde58dbcSMatthew Ahrens 	 */
808cde58dbcSMatthew Ahrens 	obj = dmu_object_alloc(dp->dp_meta_objset, DMU_OT_BPOBJ,
809b5152584SMatthew Ahrens 	    SPA_OLD_MAXBLOCKSIZE, DMU_OT_BPOBJ_HDR, sizeof (bpobj_phys_t), tx);
8103b2aab18SMatthew Ahrens 	VERIFY0(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
811cde58dbcSMatthew Ahrens 	    DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx));
8123b2aab18SMatthew Ahrens 	VERIFY0(bpobj_open(&dp->dp_free_bpobj, dp->dp_meta_objset, obj));
813cde58dbcSMatthew Ahrens 
8143b2aab18SMatthew Ahrens 	VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
815cde58dbcSMatthew Ahrens 	    upgrade_dir_clones_cb, tx, DS_FIND_CHILDREN));
816cde58dbcSMatthew Ahrens }
817cde58dbcSMatthew Ahrens 
818088f3894Sahrens void
819088f3894Sahrens dsl_pool_create_origin(dsl_pool_t *dp, dmu_tx_t *tx)
820088f3894Sahrens {
821088f3894Sahrens 	uint64_t dsobj;
822088f3894Sahrens 	dsl_dataset_t *ds;
823088f3894Sahrens 
824088f3894Sahrens 	ASSERT(dmu_tx_is_syncing(tx));
825088f3894Sahrens 	ASSERT(dp->dp_origin_snap == NULL);
8263b2aab18SMatthew Ahrens 	ASSERT(rrw_held(&dp->dp_config_rwlock, RW_WRITER));
827088f3894Sahrens 
828088f3894Sahrens 	/* create the origin dir, ds, & snap-ds */
829088f3894Sahrens 	dsobj = dsl_dataset_create_sync(dp->dp_root_dir, ORIGIN_DIR_NAME,
830088f3894Sahrens 	    NULL, 0, kcred, tx);
8313b2aab18SMatthew Ahrens 	VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
8323b2aab18SMatthew Ahrens 	dsl_dataset_snapshot_sync_impl(ds, ORIGIN_DIR_NAME, tx);
833c1379625SJustin T. Gibbs 	VERIFY0(dsl_dataset_hold_obj(dp, dsl_dataset_phys(ds)->ds_prev_snap_obj,
834088f3894Sahrens 	    dp, &dp->dp_origin_snap));
835088f3894Sahrens 	dsl_dataset_rele(ds, FTAG);
836088f3894Sahrens }
8379d3574bfSNeil Perrin 
8389d3574bfSNeil Perrin taskq_t *
8399d3574bfSNeil Perrin dsl_pool_vnrele_taskq(dsl_pool_t *dp)
8409d3574bfSNeil Perrin {
8419d3574bfSNeil Perrin 	return (dp->dp_vnrele_taskq);
8429d3574bfSNeil Perrin }
843ca45db41SChris Kirby 
844ca45db41SChris Kirby /*
845ca45db41SChris Kirby  * Walk through the pool-wide zap object of temporary snapshot user holds
846ca45db41SChris Kirby  * and release them.
847ca45db41SChris Kirby  */
848ca45db41SChris Kirby void
849ca45db41SChris Kirby dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp)
850ca45db41SChris Kirby {
851ca45db41SChris Kirby 	zap_attribute_t za;
852ca45db41SChris Kirby 	zap_cursor_t zc;
853ca45db41SChris Kirby 	objset_t *mos = dp->dp_meta_objset;
854ca45db41SChris Kirby 	uint64_t zapobj = dp->dp_tmp_userrefs_obj;
855a7a845e4SSteven Hartland 	nvlist_t *holds;
856ca45db41SChris Kirby 
857ca45db41SChris Kirby 	if (zapobj == 0)
858ca45db41SChris Kirby 		return;
859ca45db41SChris Kirby 	ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
860ca45db41SChris Kirby 
861a7a845e4SSteven Hartland 	holds = fnvlist_alloc();
862a7a845e4SSteven Hartland 
863ca45db41SChris Kirby 	for (zap_cursor_init(&zc, mos, zapobj);
864ca45db41SChris Kirby 	    zap_cursor_retrieve(&zc, &za) == 0;
865ca45db41SChris Kirby 	    zap_cursor_advance(&zc)) {
866ca45db41SChris Kirby 		char *htag;
867a7a845e4SSteven Hartland 		nvlist_t *tags;
868ca45db41SChris Kirby 
869ca45db41SChris Kirby 		htag = strchr(za.za_name, '-');
870ca45db41SChris Kirby 		*htag = '\0';
871ca45db41SChris Kirby 		++htag;
872a7a845e4SSteven Hartland 		if (nvlist_lookup_nvlist(holds, za.za_name, &tags) != 0) {
873a7a845e4SSteven Hartland 			tags = fnvlist_alloc();
874a7a845e4SSteven Hartland 			fnvlist_add_boolean(tags, htag);
875a7a845e4SSteven Hartland 			fnvlist_add_nvlist(holds, za.za_name, tags);
876a7a845e4SSteven Hartland 			fnvlist_free(tags);
877a7a845e4SSteven Hartland 		} else {
878a7a845e4SSteven Hartland 			fnvlist_add_boolean(tags, htag);
879a7a845e4SSteven Hartland 		}
880ca45db41SChris Kirby 	}
881a7a845e4SSteven Hartland 	dsl_dataset_user_release_tmp(dp, holds);
882a7a845e4SSteven Hartland 	fnvlist_free(holds);
883ca45db41SChris Kirby 	zap_cursor_fini(&zc);
884ca45db41SChris Kirby }
885ca45db41SChris Kirby 
886ca45db41SChris Kirby /*
887ca45db41SChris Kirby  * Create the pool-wide zap object for storing temporary snapshot holds.
888ca45db41SChris Kirby  */
889ca45db41SChris Kirby void
890ca45db41SChris Kirby dsl_pool_user_hold_create_obj(dsl_pool_t *dp, dmu_tx_t *tx)
891ca45db41SChris Kirby {
892ca45db41SChris Kirby 	objset_t *mos = dp->dp_meta_objset;
893ca45db41SChris Kirby 
894ca45db41SChris Kirby 	ASSERT(dp->dp_tmp_userrefs_obj == 0);
895ca45db41SChris Kirby 	ASSERT(dmu_tx_is_syncing(tx));
896ca45db41SChris Kirby 
897ad135b5dSChristopher Siden 	dp->dp_tmp_userrefs_obj = zap_create_link(mos, DMU_OT_USERREFS,
898ad135b5dSChristopher Siden 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_TMP_USERREFS, tx);
899ca45db41SChris Kirby }
900ca45db41SChris Kirby 
901ca45db41SChris Kirby static int
902ca45db41SChris Kirby dsl_pool_user_hold_rele_impl(dsl_pool_t *dp, uint64_t dsobj,
9033b2aab18SMatthew Ahrens     const char *tag, uint64_t now, dmu_tx_t *tx, boolean_t holding)
904ca45db41SChris Kirby {
905ca45db41SChris Kirby 	objset_t *mos = dp->dp_meta_objset;
906ca45db41SChris Kirby 	uint64_t zapobj = dp->dp_tmp_userrefs_obj;
907ca45db41SChris Kirby 	char *name;
908ca45db41SChris Kirby 	int error;
909ca45db41SChris Kirby 
910ca45db41SChris Kirby 	ASSERT(spa_version(dp->dp_spa) >= SPA_VERSION_USERREFS);
911ca45db41SChris Kirby 	ASSERT(dmu_tx_is_syncing(tx));
912ca45db41SChris Kirby 
913ca45db41SChris Kirby 	/*
914ca45db41SChris Kirby 	 * If the pool was created prior to SPA_VERSION_USERREFS, the
915ca45db41SChris Kirby 	 * zap object for temporary holds might not exist yet.
916ca45db41SChris Kirby 	 */
917ca45db41SChris Kirby 	if (zapobj == 0) {
918ca45db41SChris Kirby 		if (holding) {
919ca45db41SChris Kirby 			dsl_pool_user_hold_create_obj(dp, tx);
920ca45db41SChris Kirby 			zapobj = dp->dp_tmp_userrefs_obj;
921ca45db41SChris Kirby 		} else {
922be6fd75aSMatthew Ahrens 			return (SET_ERROR(ENOENT));
923ca45db41SChris Kirby 		}
924ca45db41SChris Kirby 	}
925ca45db41SChris Kirby 
926ca45db41SChris Kirby 	name = kmem_asprintf("%llx-%s", (u_longlong_t)dsobj, tag);
927ca45db41SChris Kirby 	if (holding)
9283b2aab18SMatthew Ahrens 		error = zap_add(mos, zapobj, name, 8, 1, &now, tx);
929ca45db41SChris Kirby 	else
930ca45db41SChris Kirby 		error = zap_remove(mos, zapobj, name, tx);
931ca45db41SChris Kirby 	strfree(name);
932ca45db41SChris Kirby 
933ca45db41SChris Kirby 	return (error);
934ca45db41SChris Kirby }
935ca45db41SChris Kirby 
936ca45db41SChris Kirby /*
937ca45db41SChris Kirby  * Add a temporary hold for the given dataset object and tag.
938ca45db41SChris Kirby  */
939ca45db41SChris Kirby int
940ca45db41SChris Kirby dsl_pool_user_hold(dsl_pool_t *dp, uint64_t dsobj, const char *tag,
9413b2aab18SMatthew Ahrens     uint64_t now, dmu_tx_t *tx)
942ca45db41SChris Kirby {
94315508ac0SChris Kirby 	return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, now, tx, B_TRUE));
944ca45db41SChris Kirby }
945ca45db41SChris Kirby 
946ca45db41SChris Kirby /*
947ca45db41SChris Kirby  * Release a temporary hold for the given dataset object and tag.
948ca45db41SChris Kirby  */
949ca45db41SChris Kirby int
950ca45db41SChris Kirby dsl_pool_user_release(dsl_pool_t *dp, uint64_t dsobj, const char *tag,
951ca45db41SChris Kirby     dmu_tx_t *tx)
952ca45db41SChris Kirby {
953ca45db41SChris Kirby 	return (dsl_pool_user_hold_rele_impl(dp, dsobj, tag, NULL,
954ca45db41SChris Kirby 	    tx, B_FALSE));
955ca45db41SChris Kirby }
9563b2aab18SMatthew Ahrens 
9573b2aab18SMatthew Ahrens /*
9583b2aab18SMatthew Ahrens  * DSL Pool Configuration Lock
9593b2aab18SMatthew Ahrens  *
9603b2aab18SMatthew Ahrens  * The dp_config_rwlock protects against changes to DSL state (e.g. dataset
9613b2aab18SMatthew Ahrens  * creation / destruction / rename / property setting).  It must be held for
9623b2aab18SMatthew Ahrens  * read to hold a dataset or dsl_dir.  I.e. you must call
9633b2aab18SMatthew Ahrens  * dsl_pool_config_enter() or dsl_pool_hold() before calling
9643b2aab18SMatthew Ahrens  * dsl_{dataset,dir}_hold{_obj}.  In most circumstances, the dp_config_rwlock
9653b2aab18SMatthew Ahrens  * must be held continuously until all datasets and dsl_dirs are released.
9663b2aab18SMatthew Ahrens  *
9673b2aab18SMatthew Ahrens  * The only exception to this rule is that if a "long hold" is placed on
9683b2aab18SMatthew Ahrens  * a dataset, then the dp_config_rwlock may be dropped while the dataset
9693b2aab18SMatthew Ahrens  * is still held.  The long hold will prevent the dataset from being
9703b2aab18SMatthew Ahrens  * destroyed -- the destroy will fail with EBUSY.  A long hold can be
9713b2aab18SMatthew Ahrens  * obtained by calling dsl_dataset_long_hold(), or by "owning" a dataset
9723b2aab18SMatthew Ahrens  * (by calling dsl_{dataset,objset}_{try}own{_obj}).
9733b2aab18SMatthew Ahrens  *
9743b2aab18SMatthew Ahrens  * Legitimate long-holders (including owners) should be long-running, cancelable
9753b2aab18SMatthew Ahrens  * tasks that should cause "zfs destroy" to fail.  This includes DMU
9763b2aab18SMatthew Ahrens  * consumers (i.e. a ZPL filesystem being mounted or ZVOL being open),
9773b2aab18SMatthew Ahrens  * "zfs send", and "zfs diff".  There are several other long-holders whose
9783b2aab18SMatthew Ahrens  * uses are suboptimal (e.g. "zfs promote", and zil_suspend()).
9793b2aab18SMatthew Ahrens  *
9803b2aab18SMatthew Ahrens  * The usual formula for long-holding would be:
9813b2aab18SMatthew Ahrens  * dsl_pool_hold()
9823b2aab18SMatthew Ahrens  * dsl_dataset_hold()
9833b2aab18SMatthew Ahrens  * ... perform checks ...
9843b2aab18SMatthew Ahrens  * dsl_dataset_long_hold()
9853b2aab18SMatthew Ahrens  * dsl_pool_rele()
9863b2aab18SMatthew Ahrens  * ... perform long-running task ...
9873b2aab18SMatthew Ahrens  * dsl_dataset_long_rele()
9883b2aab18SMatthew Ahrens  * dsl_dataset_rele()
9893b2aab18SMatthew Ahrens  *
9903b2aab18SMatthew Ahrens  * Note that when the long hold is released, the dataset is still held but
9913b2aab18SMatthew Ahrens  * the pool is not held.  The dataset may change arbitrarily during this time
9923b2aab18SMatthew Ahrens  * (e.g. it could be destroyed).  Therefore you shouldn't do anything to the
9933b2aab18SMatthew Ahrens  * dataset except release it.
9943b2aab18SMatthew Ahrens  *
9953b2aab18SMatthew Ahrens  * User-initiated operations (e.g. ioctls, zfs_ioc_*()) are either read-only
9963b2aab18SMatthew Ahrens  * or modifying operations.
9973b2aab18SMatthew Ahrens  *
9983b2aab18SMatthew Ahrens  * Modifying operations should generally use dsl_sync_task().  The synctask
9993b2aab18SMatthew Ahrens  * infrastructure enforces proper locking strategy with respect to the
10003b2aab18SMatthew Ahrens  * dp_config_rwlock.  See the comment above dsl_sync_task() for details.
10013b2aab18SMatthew Ahrens  *
10023b2aab18SMatthew Ahrens  * Read-only operations will manually hold the pool, then the dataset, obtain
10033b2aab18SMatthew Ahrens  * information from the dataset, then release the pool and dataset.
10043b2aab18SMatthew Ahrens  * dmu_objset_{hold,rele}() are convenience routines that also do the pool
10053b2aab18SMatthew Ahrens  * hold/rele.
10063b2aab18SMatthew Ahrens  */
10073b2aab18SMatthew Ahrens 
10083b2aab18SMatthew Ahrens int
10093b2aab18SMatthew Ahrens dsl_pool_hold(const char *name, void *tag, dsl_pool_t **dp)
10103b2aab18SMatthew Ahrens {
10113b2aab18SMatthew Ahrens 	spa_t *spa;
10123b2aab18SMatthew Ahrens 	int error;
10133b2aab18SMatthew Ahrens 
10143b2aab18SMatthew Ahrens 	error = spa_open(name, &spa, tag);
10153b2aab18SMatthew Ahrens 	if (error == 0) {
10163b2aab18SMatthew Ahrens 		*dp = spa_get_dsl(spa);
10173b2aab18SMatthew Ahrens 		dsl_pool_config_enter(*dp, tag);
10183b2aab18SMatthew Ahrens 	}
10193b2aab18SMatthew Ahrens 	return (error);
10203b2aab18SMatthew Ahrens }
10213b2aab18SMatthew Ahrens 
10223b2aab18SMatthew Ahrens void
10233b2aab18SMatthew Ahrens dsl_pool_rele(dsl_pool_t *dp, void *tag)
10243b2aab18SMatthew Ahrens {
10253b2aab18SMatthew Ahrens 	dsl_pool_config_exit(dp, tag);
10263b2aab18SMatthew Ahrens 	spa_close(dp->dp_spa, tag);
10273b2aab18SMatthew Ahrens }
10283b2aab18SMatthew Ahrens 
10293b2aab18SMatthew Ahrens void
10303b2aab18SMatthew Ahrens dsl_pool_config_enter(dsl_pool_t *dp, void *tag)
10313b2aab18SMatthew Ahrens {
10323b2aab18SMatthew Ahrens 	/*
10333b2aab18SMatthew Ahrens 	 * We use a "reentrant" reader-writer lock, but not reentrantly.
10343b2aab18SMatthew Ahrens 	 *
10353b2aab18SMatthew Ahrens 	 * The rrwlock can (with the track_all flag) track all reading threads,
10363b2aab18SMatthew Ahrens 	 * which is very useful for debugging which code path failed to release
10373b2aab18SMatthew Ahrens 	 * the lock, and for verifying that the *current* thread does hold
10383b2aab18SMatthew Ahrens 	 * the lock.
10393b2aab18SMatthew Ahrens 	 *
10403b2aab18SMatthew Ahrens 	 * (Unlike a rwlock, which knows that N threads hold it for
10413b2aab18SMatthew Ahrens 	 * read, but not *which* threads, so rw_held(RW_READER) returns TRUE
10423b2aab18SMatthew Ahrens 	 * if any thread holds it for read, even if this thread doesn't).
10433b2aab18SMatthew Ahrens 	 */
10443b2aab18SMatthew Ahrens 	ASSERT(!rrw_held(&dp->dp_config_rwlock, RW_READER));
10453b2aab18SMatthew Ahrens 	rrw_enter(&dp->dp_config_rwlock, RW_READER, tag);
10463b2aab18SMatthew Ahrens }
10473b2aab18SMatthew Ahrens 
10483b2aab18SMatthew Ahrens void
10493b2aab18SMatthew Ahrens dsl_pool_config_exit(dsl_pool_t *dp, void *tag)
10503b2aab18SMatthew Ahrens {
10513b2aab18SMatthew Ahrens 	rrw_exit(&dp->dp_config_rwlock, tag);
10523b2aab18SMatthew Ahrens }
10533b2aab18SMatthew Ahrens 
10543b2aab18SMatthew Ahrens boolean_t
10553b2aab18SMatthew Ahrens dsl_pool_config_held(dsl_pool_t *dp)
10563b2aab18SMatthew Ahrens {
10573b2aab18SMatthew Ahrens 	return (RRW_LOCK_HELD(&dp->dp_config_rwlock));
10583b2aab18SMatthew Ahrens }
1059