xref: /illumos-gate/usr/src/uts/common/fs/zfs/dsl_dataset.c (revision 8c69cc8fbe729fa7b091e901c4b50508ccc6bb33)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2011, 2017 by Delphix. All rights reserved.
25  * Copyright (c) 2014, Joyent, Inc. All rights reserved.
26  * Copyright (c) 2014 RackTop Systems.
27  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
28  * Copyright (c) 2014 Integros [integros.com]
29  * Copyright 2016, OmniTI Computer Consulting, Inc. All rights reserved.
30  * Copyright 2017 Nexenta Systems, Inc.
31  */
32 
33 #include <sys/dmu_objset.h>
34 #include <sys/dsl_dataset.h>
35 #include <sys/dsl_dir.h>
36 #include <sys/dsl_prop.h>
37 #include <sys/dsl_synctask.h>
38 #include <sys/dmu_traverse.h>
39 #include <sys/dmu_impl.h>
40 #include <sys/dmu_tx.h>
41 #include <sys/arc.h>
42 #include <sys/zio.h>
43 #include <sys/zap.h>
44 #include <sys/zfeature.h>
45 #include <sys/unique.h>
46 #include <sys/zfs_context.h>
47 #include <sys/zfs_ioctl.h>
48 #include <sys/spa.h>
49 #include <sys/zfs_znode.h>
50 #include <sys/zfs_onexit.h>
51 #include <sys/zvol.h>
52 #include <sys/dsl_scan.h>
53 #include <sys/dsl_deadlist.h>
54 #include <sys/dsl_destroy.h>
55 #include <sys/dsl_userhold.h>
56 #include <sys/dsl_bookmark.h>
57 #include <sys/dmu_send.h>
58 #include <sys/zio_checksum.h>
59 #include <sys/zio_compress.h>
60 #include <zfs_fletcher.h>
61 
62 /*
63  * The SPA supports block sizes up to 16MB.  However, very large blocks
64  * can have an impact on i/o latency (e.g. tying up a spinning disk for
65  * ~300ms), and also potentially on the memory allocator.  Therefore,
66  * we do not allow the recordsize to be set larger than zfs_max_recordsize
67  * (default 1MB).  Larger blocks can be created by changing this tunable,
68  * and pools with larger blocks can always be imported and used, regardless
69  * of this setting.
70  */
71 int zfs_max_recordsize = 1 * 1024 * 1024;
72 
73 #define	SWITCH64(x, y) \
74 	{ \
75 		uint64_t __tmp = (x); \
76 		(x) = (y); \
77 		(y) = __tmp; \
78 	}
79 
80 #define	DS_REF_MAX	(1ULL << 62)
81 
82 extern inline dsl_dataset_phys_t *dsl_dataset_phys(dsl_dataset_t *ds);
83 
84 extern int spa_asize_inflation;
85 
86 static zil_header_t zero_zil;
87 
88 /*
89  * Figure out how much of this delta should be propogated to the dsl_dir
90  * layer.  If there's a refreservation, that space has already been
91  * partially accounted for in our ancestors.
92  */
93 static int64_t
94 parent_delta(dsl_dataset_t *ds, int64_t delta)
95 {
96 	dsl_dataset_phys_t *ds_phys;
97 	uint64_t old_bytes, new_bytes;
98 
99 	if (ds->ds_reserved == 0)
100 		return (delta);
101 
102 	ds_phys = dsl_dataset_phys(ds);
103 	old_bytes = MAX(ds_phys->ds_unique_bytes, ds->ds_reserved);
104 	new_bytes = MAX(ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
105 
106 	ASSERT3U(ABS((int64_t)(new_bytes - old_bytes)), <=, ABS(delta));
107 	return (new_bytes - old_bytes);
108 }
109 
110 void
111 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
112 {
113 	int used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
114 	int compressed = BP_GET_PSIZE(bp);
115 	int uncompressed = BP_GET_UCSIZE(bp);
116 	int64_t delta;
117 
118 	dprintf_bp(bp, "ds=%p", ds);
119 
120 	ASSERT(dmu_tx_is_syncing(tx));
121 	/* It could have been compressed away to nothing */
122 	if (BP_IS_HOLE(bp))
123 		return;
124 	ASSERT(BP_GET_TYPE(bp) != DMU_OT_NONE);
125 	ASSERT(DMU_OT_IS_VALID(BP_GET_TYPE(bp)));
126 	if (ds == NULL) {
127 		dsl_pool_mos_diduse_space(tx->tx_pool,
128 		    used, compressed, uncompressed);
129 		return;
130 	}
131 
132 	ASSERT3U(bp->blk_birth, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
133 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
134 	mutex_enter(&ds->ds_lock);
135 	delta = parent_delta(ds, used);
136 	dsl_dataset_phys(ds)->ds_referenced_bytes += used;
137 	dsl_dataset_phys(ds)->ds_compressed_bytes += compressed;
138 	dsl_dataset_phys(ds)->ds_uncompressed_bytes += uncompressed;
139 	dsl_dataset_phys(ds)->ds_unique_bytes += used;
140 
141 	if (BP_GET_LSIZE(bp) > SPA_OLD_MAXBLOCKSIZE) {
142 		ds->ds_feature_activation_needed[SPA_FEATURE_LARGE_BLOCKS] =
143 		    B_TRUE;
144 	}
145 
146 	spa_feature_t f = zio_checksum_to_feature(BP_GET_CHECKSUM(bp));
147 	if (f != SPA_FEATURE_NONE)
148 		ds->ds_feature_activation_needed[f] = B_TRUE;
149 
150 	mutex_exit(&ds->ds_lock);
151 	dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD, delta,
152 	    compressed, uncompressed, tx);
153 	dsl_dir_transfer_space(ds->ds_dir, used - delta,
154 	    DD_USED_REFRSRV, DD_USED_HEAD, tx);
155 }
156 
157 int
158 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
159     boolean_t async)
160 {
161 	int used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
162 	int compressed = BP_GET_PSIZE(bp);
163 	int uncompressed = BP_GET_UCSIZE(bp);
164 
165 	if (BP_IS_HOLE(bp))
166 		return (0);
167 
168 	ASSERT(dmu_tx_is_syncing(tx));
169 	ASSERT(bp->blk_birth <= tx->tx_txg);
170 
171 	if (ds == NULL) {
172 		dsl_free(tx->tx_pool, tx->tx_txg, bp);
173 		dsl_pool_mos_diduse_space(tx->tx_pool,
174 		    -used, -compressed, -uncompressed);
175 		return (used);
176 	}
177 	ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
178 
179 	ASSERT(!ds->ds_is_snapshot);
180 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
181 
182 	if (bp->blk_birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
183 		int64_t delta;
184 
185 		dprintf_bp(bp, "freeing ds=%llu", ds->ds_object);
186 		dsl_free(tx->tx_pool, tx->tx_txg, bp);
187 
188 		mutex_enter(&ds->ds_lock);
189 		ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
190 		    !DS_UNIQUE_IS_ACCURATE(ds));
191 		delta = parent_delta(ds, -used);
192 		dsl_dataset_phys(ds)->ds_unique_bytes -= used;
193 		mutex_exit(&ds->ds_lock);
194 		dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD,
195 		    delta, -compressed, -uncompressed, tx);
196 		dsl_dir_transfer_space(ds->ds_dir, -used - delta,
197 		    DD_USED_REFRSRV, DD_USED_HEAD, tx);
198 	} else {
199 		dprintf_bp(bp, "putting on dead list: %s", "");
200 		if (async) {
201 			/*
202 			 * We are here as part of zio's write done callback,
203 			 * which means we're a zio interrupt thread.  We can't
204 			 * call dsl_deadlist_insert() now because it may block
205 			 * waiting for I/O.  Instead, put bp on the deferred
206 			 * queue and let dsl_pool_sync() finish the job.
207 			 */
208 			bplist_append(&ds->ds_pending_deadlist, bp);
209 		} else {
210 			dsl_deadlist_insert(&ds->ds_deadlist, bp, tx);
211 		}
212 		ASSERT3U(ds->ds_prev->ds_object, ==,
213 		    dsl_dataset_phys(ds)->ds_prev_snap_obj);
214 		ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_num_children > 0);
215 		/* if (bp->blk_birth > prev prev snap txg) prev unique += bs */
216 		if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
217 		    ds->ds_object && bp->blk_birth >
218 		    dsl_dataset_phys(ds->ds_prev)->ds_prev_snap_txg) {
219 			dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
220 			mutex_enter(&ds->ds_prev->ds_lock);
221 			dsl_dataset_phys(ds->ds_prev)->ds_unique_bytes += used;
222 			mutex_exit(&ds->ds_prev->ds_lock);
223 		}
224 		if (bp->blk_birth > ds->ds_dir->dd_origin_txg) {
225 			dsl_dir_transfer_space(ds->ds_dir, used,
226 			    DD_USED_HEAD, DD_USED_SNAP, tx);
227 		}
228 	}
229 	mutex_enter(&ds->ds_lock);
230 	ASSERT3U(dsl_dataset_phys(ds)->ds_referenced_bytes, >=, used);
231 	dsl_dataset_phys(ds)->ds_referenced_bytes -= used;
232 	ASSERT3U(dsl_dataset_phys(ds)->ds_compressed_bytes, >=, compressed);
233 	dsl_dataset_phys(ds)->ds_compressed_bytes -= compressed;
234 	ASSERT3U(dsl_dataset_phys(ds)->ds_uncompressed_bytes, >=, uncompressed);
235 	dsl_dataset_phys(ds)->ds_uncompressed_bytes -= uncompressed;
236 	mutex_exit(&ds->ds_lock);
237 
238 	return (used);
239 }
240 
241 /*
242  * We have to release the fsid syncronously or we risk that a subsequent
243  * mount of the same dataset will fail to unique_insert the fsid.  This
244  * failure would manifest itself as the fsid of this dataset changing
245  * between mounts which makes NFS clients quite unhappy.
246  */
247 static void
248 dsl_dataset_evict_sync(void *dbu)
249 {
250 	dsl_dataset_t *ds = dbu;
251 
252 	ASSERT(ds->ds_owner == NULL);
253 
254 	unique_remove(ds->ds_fsid_guid);
255 }
256 
257 static void
258 dsl_dataset_evict_async(void *dbu)
259 {
260 	dsl_dataset_t *ds = dbu;
261 
262 	ASSERT(ds->ds_owner == NULL);
263 
264 	ds->ds_dbuf = NULL;
265 
266 	if (ds->ds_objset != NULL)
267 		dmu_objset_evict(ds->ds_objset);
268 
269 	if (ds->ds_prev) {
270 		dsl_dataset_rele(ds->ds_prev, ds);
271 		ds->ds_prev = NULL;
272 	}
273 
274 	bplist_destroy(&ds->ds_pending_deadlist);
275 	if (ds->ds_deadlist.dl_os != NULL)
276 		dsl_deadlist_close(&ds->ds_deadlist);
277 	if (ds->ds_dir)
278 		dsl_dir_async_rele(ds->ds_dir, ds);
279 
280 	ASSERT(!list_link_active(&ds->ds_synced_link));
281 
282 	list_destroy(&ds->ds_prop_cbs);
283 	mutex_destroy(&ds->ds_lock);
284 	mutex_destroy(&ds->ds_opening_lock);
285 	mutex_destroy(&ds->ds_sendstream_lock);
286 	refcount_destroy(&ds->ds_longholds);
287 	rrw_destroy(&ds->ds_bp_rwlock);
288 
289 	kmem_free(ds, sizeof (dsl_dataset_t));
290 }
291 
292 int
293 dsl_dataset_get_snapname(dsl_dataset_t *ds)
294 {
295 	dsl_dataset_phys_t *headphys;
296 	int err;
297 	dmu_buf_t *headdbuf;
298 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
299 	objset_t *mos = dp->dp_meta_objset;
300 
301 	if (ds->ds_snapname[0])
302 		return (0);
303 	if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0)
304 		return (0);
305 
306 	err = dmu_bonus_hold(mos, dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj,
307 	    FTAG, &headdbuf);
308 	if (err != 0)
309 		return (err);
310 	headphys = headdbuf->db_data;
311 	err = zap_value_search(dp->dp_meta_objset,
312 	    headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname);
313 	dmu_buf_rele(headdbuf, FTAG);
314 	return (err);
315 }
316 
317 int
318 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
319 {
320 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
321 	uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
322 	matchtype_t mt = 0;
323 	int err;
324 
325 	if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
326 		mt = MT_NORMALIZE;
327 
328 	err = zap_lookup_norm(mos, snapobj, name, 8, 1,
329 	    value, mt, NULL, 0, NULL);
330 	if (err == ENOTSUP && (mt & MT_NORMALIZE))
331 		err = zap_lookup(mos, snapobj, name, 8, 1, value);
332 	return (err);
333 }
334 
335 int
336 dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
337     boolean_t adj_cnt)
338 {
339 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
340 	uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
341 	matchtype_t mt = 0;
342 	int err;
343 
344 	dsl_dir_snap_cmtime_update(ds->ds_dir);
345 
346 	if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
347 		mt = MT_NORMALIZE;
348 
349 	err = zap_remove_norm(mos, snapobj, name, mt, tx);
350 	if (err == ENOTSUP && (mt & MT_NORMALIZE))
351 		err = zap_remove(mos, snapobj, name, tx);
352 
353 	if (err == 0 && adj_cnt)
354 		dsl_fs_ss_count_adjust(ds->ds_dir, -1,
355 		    DD_FIELD_SNAPSHOT_COUNT, tx);
356 
357 	return (err);
358 }
359 
360 boolean_t
361 dsl_dataset_try_add_ref(dsl_pool_t *dp, dsl_dataset_t *ds, void *tag)
362 {
363 	dmu_buf_t *dbuf = ds->ds_dbuf;
364 	boolean_t result = B_FALSE;
365 
366 	if (dbuf != NULL && dmu_buf_try_add_ref(dbuf, dp->dp_meta_objset,
367 	    ds->ds_object, DMU_BONUS_BLKID, tag)) {
368 
369 		if (ds == dmu_buf_get_user(dbuf))
370 			result = B_TRUE;
371 		else
372 			dmu_buf_rele(dbuf, tag);
373 	}
374 
375 	return (result);
376 }
377 
378 int
379 dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag,
380     dsl_dataset_t **dsp)
381 {
382 	objset_t *mos = dp->dp_meta_objset;
383 	dmu_buf_t *dbuf;
384 	dsl_dataset_t *ds;
385 	int err;
386 	dmu_object_info_t doi;
387 
388 	ASSERT(dsl_pool_config_held(dp));
389 
390 	err = dmu_bonus_hold(mos, dsobj, tag, &dbuf);
391 	if (err != 0)
392 		return (err);
393 
394 	/* Make sure dsobj has the correct object type. */
395 	dmu_object_info_from_db(dbuf, &doi);
396 	if (doi.doi_bonus_type != DMU_OT_DSL_DATASET) {
397 		dmu_buf_rele(dbuf, tag);
398 		return (SET_ERROR(EINVAL));
399 	}
400 
401 	ds = dmu_buf_get_user(dbuf);
402 	if (ds == NULL) {
403 		dsl_dataset_t *winner = NULL;
404 
405 		ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
406 		ds->ds_dbuf = dbuf;
407 		ds->ds_object = dsobj;
408 		ds->ds_is_snapshot = dsl_dataset_phys(ds)->ds_num_children != 0;
409 
410 		mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
411 		mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
412 		mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL);
413 		rrw_init(&ds->ds_bp_rwlock, B_FALSE);
414 		refcount_create(&ds->ds_longholds);
415 
416 		bplist_create(&ds->ds_pending_deadlist);
417 		dsl_deadlist_open(&ds->ds_deadlist,
418 		    mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
419 
420 		list_create(&ds->ds_sendstreams, sizeof (dmu_sendarg_t),
421 		    offsetof(dmu_sendarg_t, dsa_link));
422 
423 		list_create(&ds->ds_prop_cbs, sizeof (dsl_prop_cb_record_t),
424 		    offsetof(dsl_prop_cb_record_t, cbr_ds_node));
425 
426 		if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
427 			for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
428 				if (!(spa_feature_table[f].fi_flags &
429 				    ZFEATURE_FLAG_PER_DATASET))
430 					continue;
431 				err = zap_contains(mos, dsobj,
432 				    spa_feature_table[f].fi_guid);
433 				if (err == 0) {
434 					ds->ds_feature_inuse[f] = B_TRUE;
435 				} else {
436 					ASSERT3U(err, ==, ENOENT);
437 					err = 0;
438 				}
439 			}
440 		}
441 
442 		err = dsl_dir_hold_obj(dp,
443 		    dsl_dataset_phys(ds)->ds_dir_obj, NULL, ds, &ds->ds_dir);
444 		if (err != 0) {
445 			mutex_destroy(&ds->ds_lock);
446 			mutex_destroy(&ds->ds_opening_lock);
447 			mutex_destroy(&ds->ds_sendstream_lock);
448 			refcount_destroy(&ds->ds_longholds);
449 			bplist_destroy(&ds->ds_pending_deadlist);
450 			dsl_deadlist_close(&ds->ds_deadlist);
451 			kmem_free(ds, sizeof (dsl_dataset_t));
452 			dmu_buf_rele(dbuf, tag);
453 			return (err);
454 		}
455 
456 		if (!ds->ds_is_snapshot) {
457 			ds->ds_snapname[0] = '\0';
458 			if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
459 				err = dsl_dataset_hold_obj(dp,
460 				    dsl_dataset_phys(ds)->ds_prev_snap_obj,
461 				    ds, &ds->ds_prev);
462 			}
463 			if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
464 				int zaperr = zap_lookup(mos, ds->ds_object,
465 				    DS_FIELD_BOOKMARK_NAMES,
466 				    sizeof (ds->ds_bookmarks), 1,
467 				    &ds->ds_bookmarks);
468 				if (zaperr != ENOENT)
469 					VERIFY0(zaperr);
470 			}
471 		} else {
472 			if (zfs_flags & ZFS_DEBUG_SNAPNAMES)
473 				err = dsl_dataset_get_snapname(ds);
474 			if (err == 0 &&
475 			    dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
476 				err = zap_count(
477 				    ds->ds_dir->dd_pool->dp_meta_objset,
478 				    dsl_dataset_phys(ds)->ds_userrefs_obj,
479 				    &ds->ds_userrefs);
480 			}
481 		}
482 
483 		if (err == 0 && !ds->ds_is_snapshot) {
484 			err = dsl_prop_get_int_ds(ds,
485 			    zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
486 			    &ds->ds_reserved);
487 			if (err == 0) {
488 				err = dsl_prop_get_int_ds(ds,
489 				    zfs_prop_to_name(ZFS_PROP_REFQUOTA),
490 				    &ds->ds_quota);
491 			}
492 		} else {
493 			ds->ds_reserved = ds->ds_quota = 0;
494 		}
495 
496 		dmu_buf_init_user(&ds->ds_dbu, dsl_dataset_evict_sync,
497 		    dsl_dataset_evict_async, &ds->ds_dbuf);
498 		if (err == 0)
499 			winner = dmu_buf_set_user_ie(dbuf, &ds->ds_dbu);
500 
501 		if (err != 0 || winner != NULL) {
502 			bplist_destroy(&ds->ds_pending_deadlist);
503 			dsl_deadlist_close(&ds->ds_deadlist);
504 			if (ds->ds_prev)
505 				dsl_dataset_rele(ds->ds_prev, ds);
506 			dsl_dir_rele(ds->ds_dir, ds);
507 			mutex_destroy(&ds->ds_lock);
508 			mutex_destroy(&ds->ds_opening_lock);
509 			mutex_destroy(&ds->ds_sendstream_lock);
510 			refcount_destroy(&ds->ds_longholds);
511 			kmem_free(ds, sizeof (dsl_dataset_t));
512 			if (err != 0) {
513 				dmu_buf_rele(dbuf, tag);
514 				return (err);
515 			}
516 			ds = winner;
517 		} else {
518 			ds->ds_fsid_guid =
519 			    unique_insert(dsl_dataset_phys(ds)->ds_fsid_guid);
520 			if (ds->ds_fsid_guid !=
521 			    dsl_dataset_phys(ds)->ds_fsid_guid) {
522 				zfs_dbgmsg("ds_fsid_guid changed from "
523 				    "%llx to %llx for pool %s dataset id %llu",
524 				    (long long)
525 				    dsl_dataset_phys(ds)->ds_fsid_guid,
526 				    (long long)ds->ds_fsid_guid,
527 				    spa_name(dp->dp_spa),
528 				    dsobj);
529 			}
530 		}
531 	}
532 	ASSERT3P(ds->ds_dbuf, ==, dbuf);
533 	ASSERT3P(dsl_dataset_phys(ds), ==, dbuf->db_data);
534 	ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0 ||
535 	    spa_version(dp->dp_spa) < SPA_VERSION_ORIGIN ||
536 	    dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
537 	*dsp = ds;
538 	return (0);
539 }
540 
541 int
542 dsl_dataset_hold(dsl_pool_t *dp, const char *name,
543     void *tag, dsl_dataset_t **dsp)
544 {
545 	dsl_dir_t *dd;
546 	const char *snapname;
547 	uint64_t obj;
548 	int err = 0;
549 	dsl_dataset_t *ds;
550 
551 	err = dsl_dir_hold(dp, name, FTAG, &dd, &snapname);
552 	if (err != 0)
553 		return (err);
554 
555 	ASSERT(dsl_pool_config_held(dp));
556 	obj = dsl_dir_phys(dd)->dd_head_dataset_obj;
557 	if (obj != 0)
558 		err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
559 	else
560 		err = SET_ERROR(ENOENT);
561 
562 	/* we may be looking for a snapshot */
563 	if (err == 0 && snapname != NULL) {
564 		dsl_dataset_t *snap_ds;
565 
566 		if (*snapname++ != '@') {
567 			dsl_dataset_rele(ds, tag);
568 			dsl_dir_rele(dd, FTAG);
569 			return (SET_ERROR(ENOENT));
570 		}
571 
572 		dprintf("looking for snapshot '%s'\n", snapname);
573 		err = dsl_dataset_snap_lookup(ds, snapname, &obj);
574 		if (err == 0)
575 			err = dsl_dataset_hold_obj(dp, obj, tag, &snap_ds);
576 		dsl_dataset_rele(ds, tag);
577 
578 		if (err == 0) {
579 			mutex_enter(&snap_ds->ds_lock);
580 			if (snap_ds->ds_snapname[0] == 0)
581 				(void) strlcpy(snap_ds->ds_snapname, snapname,
582 				    sizeof (snap_ds->ds_snapname));
583 			mutex_exit(&snap_ds->ds_lock);
584 			ds = snap_ds;
585 		}
586 	}
587 	if (err == 0)
588 		*dsp = ds;
589 	dsl_dir_rele(dd, FTAG);
590 	return (err);
591 }
592 
593 int
594 dsl_dataset_own_obj(dsl_pool_t *dp, uint64_t dsobj,
595     void *tag, dsl_dataset_t **dsp)
596 {
597 	int err = dsl_dataset_hold_obj(dp, dsobj, tag, dsp);
598 	if (err != 0)
599 		return (err);
600 	if (!dsl_dataset_tryown(*dsp, tag)) {
601 		dsl_dataset_rele(*dsp, tag);
602 		*dsp = NULL;
603 		return (SET_ERROR(EBUSY));
604 	}
605 	return (0);
606 }
607 
608 int
609 dsl_dataset_own(dsl_pool_t *dp, const char *name,
610     void *tag, dsl_dataset_t **dsp)
611 {
612 	int err = dsl_dataset_hold(dp, name, tag, dsp);
613 	if (err != 0)
614 		return (err);
615 	if (!dsl_dataset_tryown(*dsp, tag)) {
616 		dsl_dataset_rele(*dsp, tag);
617 		return (SET_ERROR(EBUSY));
618 	}
619 	return (0);
620 }
621 
622 /*
623  * See the comment above dsl_pool_hold() for details.  In summary, a long
624  * hold is used to prevent destruction of a dataset while the pool hold
625  * is dropped, allowing other concurrent operations (e.g. spa_sync()).
626  *
627  * The dataset and pool must be held when this function is called.  After it
628  * is called, the pool hold may be released while the dataset is still held
629  * and accessed.
630  */
631 void
632 dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag)
633 {
634 	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
635 	(void) refcount_add(&ds->ds_longholds, tag);
636 }
637 
638 void
639 dsl_dataset_long_rele(dsl_dataset_t *ds, void *tag)
640 {
641 	(void) refcount_remove(&ds->ds_longholds, tag);
642 }
643 
644 /* Return B_TRUE if there are any long holds on this dataset. */
645 boolean_t
646 dsl_dataset_long_held(dsl_dataset_t *ds)
647 {
648 	return (!refcount_is_zero(&ds->ds_longholds));
649 }
650 
651 void
652 dsl_dataset_name(dsl_dataset_t *ds, char *name)
653 {
654 	if (ds == NULL) {
655 		(void) strcpy(name, "mos");
656 	} else {
657 		dsl_dir_name(ds->ds_dir, name);
658 		VERIFY0(dsl_dataset_get_snapname(ds));
659 		if (ds->ds_snapname[0]) {
660 			VERIFY3U(strlcat(name, "@", ZFS_MAX_DATASET_NAME_LEN),
661 			    <, ZFS_MAX_DATASET_NAME_LEN);
662 			/*
663 			 * We use a "recursive" mutex so that we
664 			 * can call dprintf_ds() with ds_lock held.
665 			 */
666 			if (!MUTEX_HELD(&ds->ds_lock)) {
667 				mutex_enter(&ds->ds_lock);
668 				VERIFY3U(strlcat(name, ds->ds_snapname,
669 				    ZFS_MAX_DATASET_NAME_LEN), <,
670 				    ZFS_MAX_DATASET_NAME_LEN);
671 				mutex_exit(&ds->ds_lock);
672 			} else {
673 				VERIFY3U(strlcat(name, ds->ds_snapname,
674 				    ZFS_MAX_DATASET_NAME_LEN), <,
675 				    ZFS_MAX_DATASET_NAME_LEN);
676 			}
677 		}
678 	}
679 }
680 
681 int
682 dsl_dataset_namelen(dsl_dataset_t *ds)
683 {
684 	VERIFY0(dsl_dataset_get_snapname(ds));
685 	mutex_enter(&ds->ds_lock);
686 	int len = dsl_dir_namelen(ds->ds_dir) + 1 + strlen(ds->ds_snapname);
687 	mutex_exit(&ds->ds_lock);
688 	return (len);
689 }
690 
691 void
692 dsl_dataset_rele(dsl_dataset_t *ds, void *tag)
693 {
694 	dmu_buf_rele(ds->ds_dbuf, tag);
695 }
696 
697 void
698 dsl_dataset_disown(dsl_dataset_t *ds, void *tag)
699 {
700 	ASSERT3P(ds->ds_owner, ==, tag);
701 	ASSERT(ds->ds_dbuf != NULL);
702 
703 	mutex_enter(&ds->ds_lock);
704 	ds->ds_owner = NULL;
705 	mutex_exit(&ds->ds_lock);
706 	dsl_dataset_long_rele(ds, tag);
707 	dsl_dataset_rele(ds, tag);
708 }
709 
710 boolean_t
711 dsl_dataset_tryown(dsl_dataset_t *ds, void *tag)
712 {
713 	boolean_t gotit = FALSE;
714 
715 	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
716 	mutex_enter(&ds->ds_lock);
717 	if (ds->ds_owner == NULL && !DS_IS_INCONSISTENT(ds)) {
718 		ds->ds_owner = tag;
719 		dsl_dataset_long_hold(ds, tag);
720 		gotit = TRUE;
721 	}
722 	mutex_exit(&ds->ds_lock);
723 	return (gotit);
724 }
725 
726 boolean_t
727 dsl_dataset_has_owner(dsl_dataset_t *ds)
728 {
729 	boolean_t rv;
730 	mutex_enter(&ds->ds_lock);
731 	rv = (ds->ds_owner != NULL);
732 	mutex_exit(&ds->ds_lock);
733 	return (rv);
734 }
735 
736 static void
737 dsl_dataset_activate_feature(uint64_t dsobj, spa_feature_t f, dmu_tx_t *tx)
738 {
739 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
740 	objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
741 	uint64_t zero = 0;
742 
743 	VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
744 
745 	spa_feature_incr(spa, f, tx);
746 	dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
747 
748 	VERIFY0(zap_add(mos, dsobj, spa_feature_table[f].fi_guid,
749 	    sizeof (zero), 1, &zero, tx));
750 }
751 
752 void
753 dsl_dataset_deactivate_feature(uint64_t dsobj, spa_feature_t f, dmu_tx_t *tx)
754 {
755 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
756 	objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
757 
758 	VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
759 
760 	VERIFY0(zap_remove(mos, dsobj, spa_feature_table[f].fi_guid, tx));
761 	spa_feature_decr(spa, f, tx);
762 }
763 
764 uint64_t
765 dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
766     uint64_t flags, dmu_tx_t *tx)
767 {
768 	dsl_pool_t *dp = dd->dd_pool;
769 	dmu_buf_t *dbuf;
770 	dsl_dataset_phys_t *dsphys;
771 	uint64_t dsobj;
772 	objset_t *mos = dp->dp_meta_objset;
773 
774 	if (origin == NULL)
775 		origin = dp->dp_origin_snap;
776 
777 	ASSERT(origin == NULL || origin->ds_dir->dd_pool == dp);
778 	ASSERT(origin == NULL || dsl_dataset_phys(origin)->ds_num_children > 0);
779 	ASSERT(dmu_tx_is_syncing(tx));
780 	ASSERT(dsl_dir_phys(dd)->dd_head_dataset_obj == 0);
781 
782 	dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
783 	    DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
784 	VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
785 	dmu_buf_will_dirty(dbuf, tx);
786 	dsphys = dbuf->db_data;
787 	bzero(dsphys, sizeof (dsl_dataset_phys_t));
788 	dsphys->ds_dir_obj = dd->dd_object;
789 	dsphys->ds_flags = flags;
790 	dsphys->ds_fsid_guid = unique_create();
791 	(void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
792 	    sizeof (dsphys->ds_guid));
793 	dsphys->ds_snapnames_zapobj =
794 	    zap_create_norm(mos, U8_TEXTPREP_TOUPPER, DMU_OT_DSL_DS_SNAP_MAP,
795 	    DMU_OT_NONE, 0, tx);
796 	dsphys->ds_creation_time = gethrestime_sec();
797 	dsphys->ds_creation_txg = tx->tx_txg == TXG_INITIAL ? 1 : tx->tx_txg;
798 
799 	if (origin == NULL) {
800 		dsphys->ds_deadlist_obj = dsl_deadlist_alloc(mos, tx);
801 	} else {
802 		dsl_dataset_t *ohds; /* head of the origin snapshot */
803 
804 		dsphys->ds_prev_snap_obj = origin->ds_object;
805 		dsphys->ds_prev_snap_txg =
806 		    dsl_dataset_phys(origin)->ds_creation_txg;
807 		dsphys->ds_referenced_bytes =
808 		    dsl_dataset_phys(origin)->ds_referenced_bytes;
809 		dsphys->ds_compressed_bytes =
810 		    dsl_dataset_phys(origin)->ds_compressed_bytes;
811 		dsphys->ds_uncompressed_bytes =
812 		    dsl_dataset_phys(origin)->ds_uncompressed_bytes;
813 		rrw_enter(&origin->ds_bp_rwlock, RW_READER, FTAG);
814 		dsphys->ds_bp = dsl_dataset_phys(origin)->ds_bp;
815 		rrw_exit(&origin->ds_bp_rwlock, FTAG);
816 
817 		/*
818 		 * Inherit flags that describe the dataset's contents
819 		 * (INCONSISTENT) or properties (Case Insensitive).
820 		 */
821 		dsphys->ds_flags |= dsl_dataset_phys(origin)->ds_flags &
822 		    (DS_FLAG_INCONSISTENT | DS_FLAG_CI_DATASET);
823 
824 		for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
825 			if (origin->ds_feature_inuse[f])
826 				dsl_dataset_activate_feature(dsobj, f, tx);
827 		}
828 
829 		dmu_buf_will_dirty(origin->ds_dbuf, tx);
830 		dsl_dataset_phys(origin)->ds_num_children++;
831 
832 		VERIFY0(dsl_dataset_hold_obj(dp,
833 		    dsl_dir_phys(origin->ds_dir)->dd_head_dataset_obj,
834 		    FTAG, &ohds));
835 		dsphys->ds_deadlist_obj = dsl_deadlist_clone(&ohds->ds_deadlist,
836 		    dsphys->ds_prev_snap_txg, dsphys->ds_prev_snap_obj, tx);
837 		dsl_dataset_rele(ohds, FTAG);
838 
839 		if (spa_version(dp->dp_spa) >= SPA_VERSION_NEXT_CLONES) {
840 			if (dsl_dataset_phys(origin)->ds_next_clones_obj == 0) {
841 				dsl_dataset_phys(origin)->ds_next_clones_obj =
842 				    zap_create(mos,
843 				    DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
844 			}
845 			VERIFY0(zap_add_int(mos,
846 			    dsl_dataset_phys(origin)->ds_next_clones_obj,
847 			    dsobj, tx));
848 		}
849 
850 		dmu_buf_will_dirty(dd->dd_dbuf, tx);
851 		dsl_dir_phys(dd)->dd_origin_obj = origin->ds_object;
852 		if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
853 			if (dsl_dir_phys(origin->ds_dir)->dd_clones == 0) {
854 				dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
855 				dsl_dir_phys(origin->ds_dir)->dd_clones =
856 				    zap_create(mos,
857 				    DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
858 			}
859 			VERIFY0(zap_add_int(mos,
860 			    dsl_dir_phys(origin->ds_dir)->dd_clones,
861 			    dsobj, tx));
862 		}
863 	}
864 
865 	if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
866 		dsphys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
867 
868 	dmu_buf_rele(dbuf, FTAG);
869 
870 	dmu_buf_will_dirty(dd->dd_dbuf, tx);
871 	dsl_dir_phys(dd)->dd_head_dataset_obj = dsobj;
872 
873 	return (dsobj);
874 }
875 
876 static void
877 dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx)
878 {
879 	objset_t *os;
880 
881 	VERIFY0(dmu_objset_from_ds(ds, &os));
882 	if (bcmp(&os->os_zil_header, &zero_zil, sizeof (zero_zil)) != 0) {
883 		dsl_pool_t *dp = ds->ds_dir->dd_pool;
884 		zio_t *zio;
885 
886 		bzero(&os->os_zil_header, sizeof (os->os_zil_header));
887 
888 		zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
889 		dsl_dataset_sync(ds, zio, tx);
890 		VERIFY0(zio_wait(zio));
891 
892 		/* dsl_dataset_sync_done will drop this reference. */
893 		dmu_buf_add_ref(ds->ds_dbuf, ds);
894 		dsl_dataset_sync_done(ds, tx);
895 	}
896 }
897 
898 uint64_t
899 dsl_dataset_create_sync(dsl_dir_t *pdd, const char *lastname,
900     dsl_dataset_t *origin, uint64_t flags, cred_t *cr, dmu_tx_t *tx)
901 {
902 	dsl_pool_t *dp = pdd->dd_pool;
903 	uint64_t dsobj, ddobj;
904 	dsl_dir_t *dd;
905 
906 	ASSERT(dmu_tx_is_syncing(tx));
907 	ASSERT(lastname[0] != '@');
908 
909 	ddobj = dsl_dir_create_sync(dp, pdd, lastname, tx);
910 	VERIFY0(dsl_dir_hold_obj(dp, ddobj, lastname, FTAG, &dd));
911 
912 	dsobj = dsl_dataset_create_sync_dd(dd, origin,
913 	    flags & ~DS_CREATE_FLAG_NODIRTY, tx);
914 
915 	dsl_deleg_set_create_perms(dd, tx, cr);
916 
917 	/*
918 	 * Since we're creating a new node we know it's a leaf, so we can
919 	 * initialize the counts if the limit feature is active.
920 	 */
921 	if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_FS_SS_LIMIT)) {
922 		uint64_t cnt = 0;
923 		objset_t *os = dd->dd_pool->dp_meta_objset;
924 
925 		dsl_dir_zapify(dd, tx);
926 		VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_FILESYSTEM_COUNT,
927 		    sizeof (cnt), 1, &cnt, tx));
928 		VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_SNAPSHOT_COUNT,
929 		    sizeof (cnt), 1, &cnt, tx));
930 	}
931 
932 	dsl_dir_rele(dd, FTAG);
933 
934 	/*
935 	 * If we are creating a clone, make sure we zero out any stale
936 	 * data from the origin snapshots zil header.
937 	 */
938 	if (origin != NULL && !(flags & DS_CREATE_FLAG_NODIRTY)) {
939 		dsl_dataset_t *ds;
940 
941 		VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
942 		dsl_dataset_zero_zil(ds, tx);
943 		dsl_dataset_rele(ds, FTAG);
944 	}
945 
946 	return (dsobj);
947 }
948 
949 /*
950  * The unique space in the head dataset can be calculated by subtracting
951  * the space used in the most recent snapshot, that is still being used
952  * in this file system, from the space currently in use.  To figure out
953  * the space in the most recent snapshot still in use, we need to take
954  * the total space used in the snapshot and subtract out the space that
955  * has been freed up since the snapshot was taken.
956  */
957 void
958 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
959 {
960 	uint64_t mrs_used;
961 	uint64_t dlused, dlcomp, dluncomp;
962 
963 	ASSERT(!ds->ds_is_snapshot);
964 
965 	if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0)
966 		mrs_used = dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes;
967 	else
968 		mrs_used = 0;
969 
970 	dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
971 
972 	ASSERT3U(dlused, <=, mrs_used);
973 	dsl_dataset_phys(ds)->ds_unique_bytes =
974 	    dsl_dataset_phys(ds)->ds_referenced_bytes - (mrs_used - dlused);
975 
976 	if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
977 	    SPA_VERSION_UNIQUE_ACCURATE)
978 		dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
979 }
980 
981 void
982 dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
983     dmu_tx_t *tx)
984 {
985 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
986 	uint64_t count;
987 	int err;
988 
989 	ASSERT(dsl_dataset_phys(ds)->ds_num_children >= 2);
990 	err = zap_remove_int(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
991 	    obj, tx);
992 	/*
993 	 * The err should not be ENOENT, but a bug in a previous version
994 	 * of the code could cause upgrade_clones_cb() to not set
995 	 * ds_next_snap_obj when it should, leading to a missing entry.
996 	 * If we knew that the pool was created after
997 	 * SPA_VERSION_NEXT_CLONES, we could assert that it isn't
998 	 * ENOENT.  However, at least we can check that we don't have
999 	 * too many entries in the next_clones_obj even after failing to
1000 	 * remove this one.
1001 	 */
1002 	if (err != ENOENT)
1003 		VERIFY0(err);
1004 	ASSERT0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1005 	    &count));
1006 	ASSERT3U(count, <=, dsl_dataset_phys(ds)->ds_num_children - 2);
1007 }
1008 
1009 
1010 blkptr_t *
1011 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
1012 {
1013 	return (&dsl_dataset_phys(ds)->ds_bp);
1014 }
1015 
1016 spa_t *
1017 dsl_dataset_get_spa(dsl_dataset_t *ds)
1018 {
1019 	return (ds->ds_dir->dd_pool->dp_spa);
1020 }
1021 
1022 void
1023 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
1024 {
1025 	dsl_pool_t *dp;
1026 
1027 	if (ds == NULL) /* this is the meta-objset */
1028 		return;
1029 
1030 	ASSERT(ds->ds_objset != NULL);
1031 
1032 	if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0)
1033 		panic("dirtying snapshot!");
1034 
1035 	/* Must not dirty a dataset in the same txg where it got snapshotted. */
1036 	ASSERT3U(tx->tx_txg, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
1037 
1038 	dp = ds->ds_dir->dd_pool;
1039 	if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg)) {
1040 		/* up the hold count until we can be written out */
1041 		dmu_buf_add_ref(ds->ds_dbuf, ds);
1042 	}
1043 }
1044 
1045 boolean_t
1046 dsl_dataset_is_dirty(dsl_dataset_t *ds)
1047 {
1048 	for (int t = 0; t < TXG_SIZE; t++) {
1049 		if (txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1050 		    ds, t))
1051 			return (B_TRUE);
1052 	}
1053 	return (B_FALSE);
1054 }
1055 
1056 static int
1057 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
1058 {
1059 	uint64_t asize;
1060 
1061 	if (!dmu_tx_is_syncing(tx))
1062 		return (0);
1063 
1064 	/*
1065 	 * If there's an fs-only reservation, any blocks that might become
1066 	 * owned by the snapshot dataset must be accommodated by space
1067 	 * outside of the reservation.
1068 	 */
1069 	ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
1070 	asize = MIN(dsl_dataset_phys(ds)->ds_unique_bytes, ds->ds_reserved);
1071 	if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
1072 		return (SET_ERROR(ENOSPC));
1073 
1074 	/*
1075 	 * Propagate any reserved space for this snapshot to other
1076 	 * snapshot checks in this sync group.
1077 	 */
1078 	if (asize > 0)
1079 		dsl_dir_willuse_space(ds->ds_dir, asize, tx);
1080 
1081 	return (0);
1082 }
1083 
1084 int
1085 dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
1086     dmu_tx_t *tx, boolean_t recv, uint64_t cnt, cred_t *cr)
1087 {
1088 	int error;
1089 	uint64_t value;
1090 
1091 	ds->ds_trysnap_txg = tx->tx_txg;
1092 
1093 	if (!dmu_tx_is_syncing(tx))
1094 		return (0);
1095 
1096 	/*
1097 	 * We don't allow multiple snapshots of the same txg.  If there
1098 	 * is already one, try again.
1099 	 */
1100 	if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
1101 		return (SET_ERROR(EAGAIN));
1102 
1103 	/*
1104 	 * Check for conflicting snapshot name.
1105 	 */
1106 	error = dsl_dataset_snap_lookup(ds, snapname, &value);
1107 	if (error == 0)
1108 		return (SET_ERROR(EEXIST));
1109 	if (error != ENOENT)
1110 		return (error);
1111 
1112 	/*
1113 	 * We don't allow taking snapshots of inconsistent datasets, such as
1114 	 * those into which we are currently receiving.  However, if we are
1115 	 * creating this snapshot as part of a receive, this check will be
1116 	 * executed atomically with respect to the completion of the receive
1117 	 * itself but prior to the clearing of DS_FLAG_INCONSISTENT; in this
1118 	 * case we ignore this, knowing it will be fixed up for us shortly in
1119 	 * dmu_recv_end_sync().
1120 	 */
1121 	if (!recv && DS_IS_INCONSISTENT(ds))
1122 		return (SET_ERROR(EBUSY));
1123 
1124 	/*
1125 	 * Skip the check for temporary snapshots or if we have already checked
1126 	 * the counts in dsl_dataset_snapshot_check. This means we really only
1127 	 * check the count here when we're receiving a stream.
1128 	 */
1129 	if (cnt != 0 && cr != NULL) {
1130 		error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1131 		    ZFS_PROP_SNAPSHOT_LIMIT, NULL, cr);
1132 		if (error != 0)
1133 			return (error);
1134 	}
1135 
1136 	error = dsl_dataset_snapshot_reserve_space(ds, tx);
1137 	if (error != 0)
1138 		return (error);
1139 
1140 	return (0);
1141 }
1142 
1143 int
1144 dsl_dataset_snapshot_check(void *arg, dmu_tx_t *tx)
1145 {
1146 	dsl_dataset_snapshot_arg_t *ddsa = arg;
1147 	dsl_pool_t *dp = dmu_tx_pool(tx);
1148 	nvpair_t *pair;
1149 	int rv = 0;
1150 
1151 	/*
1152 	 * Pre-compute how many total new snapshots will be created for each
1153 	 * level in the tree and below. This is needed for validating the
1154 	 * snapshot limit when either taking a recursive snapshot or when
1155 	 * taking multiple snapshots.
1156 	 *
1157 	 * The problem is that the counts are not actually adjusted when
1158 	 * we are checking, only when we finally sync. For a single snapshot,
1159 	 * this is easy, the count will increase by 1 at each node up the tree,
1160 	 * but its more complicated for the recursive/multiple snapshot case.
1161 	 *
1162 	 * The dsl_fs_ss_limit_check function does recursively check the count
1163 	 * at each level up the tree but since it is validating each snapshot
1164 	 * independently we need to be sure that we are validating the complete
1165 	 * count for the entire set of snapshots. We do this by rolling up the
1166 	 * counts for each component of the name into an nvlist and then
1167 	 * checking each of those cases with the aggregated count.
1168 	 *
1169 	 * This approach properly handles not only the recursive snapshot
1170 	 * case (where we get all of those on the ddsa_snaps list) but also
1171 	 * the sibling case (e.g. snapshot a/b and a/c so that we will also
1172 	 * validate the limit on 'a' using a count of 2).
1173 	 *
1174 	 * We validate the snapshot names in the third loop and only report
1175 	 * name errors once.
1176 	 */
1177 	if (dmu_tx_is_syncing(tx)) {
1178 		nvlist_t *cnt_track = NULL;
1179 		cnt_track = fnvlist_alloc();
1180 
1181 		/* Rollup aggregated counts into the cnt_track list */
1182 		for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1183 		    pair != NULL;
1184 		    pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1185 			char *pdelim;
1186 			uint64_t val;
1187 			char nm[MAXPATHLEN];
1188 
1189 			(void) strlcpy(nm, nvpair_name(pair), sizeof (nm));
1190 			pdelim = strchr(nm, '@');
1191 			if (pdelim == NULL)
1192 				continue;
1193 			*pdelim = '\0';
1194 
1195 			do {
1196 				if (nvlist_lookup_uint64(cnt_track, nm,
1197 				    &val) == 0) {
1198 					/* update existing entry */
1199 					fnvlist_add_uint64(cnt_track, nm,
1200 					    val + 1);
1201 				} else {
1202 					/* add to list */
1203 					fnvlist_add_uint64(cnt_track, nm, 1);
1204 				}
1205 
1206 				pdelim = strrchr(nm, '/');
1207 				if (pdelim != NULL)
1208 					*pdelim = '\0';
1209 			} while (pdelim != NULL);
1210 		}
1211 
1212 		/* Check aggregated counts at each level */
1213 		for (pair = nvlist_next_nvpair(cnt_track, NULL);
1214 		    pair != NULL; pair = nvlist_next_nvpair(cnt_track, pair)) {
1215 			int error = 0;
1216 			char *name;
1217 			uint64_t cnt = 0;
1218 			dsl_dataset_t *ds;
1219 
1220 			name = nvpair_name(pair);
1221 			cnt = fnvpair_value_uint64(pair);
1222 			ASSERT(cnt > 0);
1223 
1224 			error = dsl_dataset_hold(dp, name, FTAG, &ds);
1225 			if (error == 0) {
1226 				error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1227 				    ZFS_PROP_SNAPSHOT_LIMIT, NULL,
1228 				    ddsa->ddsa_cr);
1229 				dsl_dataset_rele(ds, FTAG);
1230 			}
1231 
1232 			if (error != 0) {
1233 				if (ddsa->ddsa_errors != NULL)
1234 					fnvlist_add_int32(ddsa->ddsa_errors,
1235 					    name, error);
1236 				rv = error;
1237 				/* only report one error for this check */
1238 				break;
1239 			}
1240 		}
1241 		nvlist_free(cnt_track);
1242 	}
1243 
1244 	for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1245 	    pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1246 		int error = 0;
1247 		dsl_dataset_t *ds;
1248 		char *name, *atp;
1249 		char dsname[ZFS_MAX_DATASET_NAME_LEN];
1250 
1251 		name = nvpair_name(pair);
1252 		if (strlen(name) >= ZFS_MAX_DATASET_NAME_LEN)
1253 			error = SET_ERROR(ENAMETOOLONG);
1254 		if (error == 0) {
1255 			atp = strchr(name, '@');
1256 			if (atp == NULL)
1257 				error = SET_ERROR(EINVAL);
1258 			if (error == 0)
1259 				(void) strlcpy(dsname, name, atp - name + 1);
1260 		}
1261 		if (error == 0)
1262 			error = dsl_dataset_hold(dp, dsname, FTAG, &ds);
1263 		if (error == 0) {
1264 			/* passing 0/NULL skips dsl_fs_ss_limit_check */
1265 			error = dsl_dataset_snapshot_check_impl(ds,
1266 			    atp + 1, tx, B_FALSE, 0, NULL);
1267 			dsl_dataset_rele(ds, FTAG);
1268 		}
1269 
1270 		if (error != 0) {
1271 			if (ddsa->ddsa_errors != NULL) {
1272 				fnvlist_add_int32(ddsa->ddsa_errors,
1273 				    name, error);
1274 			}
1275 			rv = error;
1276 		}
1277 	}
1278 
1279 	return (rv);
1280 }
1281 
1282 void
1283 dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
1284     dmu_tx_t *tx)
1285 {
1286 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
1287 	dmu_buf_t *dbuf;
1288 	dsl_dataset_phys_t *dsphys;
1289 	uint64_t dsobj, crtxg;
1290 	objset_t *mos = dp->dp_meta_objset;
1291 	objset_t *os;
1292 
1293 	ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
1294 
1295 	/*
1296 	 * If we are on an old pool, the zil must not be active, in which
1297 	 * case it will be zeroed.  Usually zil_suspend() accomplishes this.
1298 	 */
1299 	ASSERT(spa_version(dmu_tx_pool(tx)->dp_spa) >= SPA_VERSION_FAST_SNAP ||
1300 	    dmu_objset_from_ds(ds, &os) != 0 ||
1301 	    bcmp(&os->os_phys->os_zil_header, &zero_zil,
1302 	    sizeof (zero_zil)) == 0);
1303 
1304 	/* Should not snapshot a dirty dataset. */
1305 	ASSERT(!txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1306 	    ds, tx->tx_txg));
1307 
1308 	dsl_fs_ss_count_adjust(ds->ds_dir, 1, DD_FIELD_SNAPSHOT_COUNT, tx);
1309 
1310 	/*
1311 	 * The origin's ds_creation_txg has to be < TXG_INITIAL
1312 	 */
1313 	if (strcmp(snapname, ORIGIN_DIR_NAME) == 0)
1314 		crtxg = 1;
1315 	else
1316 		crtxg = tx->tx_txg;
1317 
1318 	dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
1319 	    DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
1320 	VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
1321 	dmu_buf_will_dirty(dbuf, tx);
1322 	dsphys = dbuf->db_data;
1323 	bzero(dsphys, sizeof (dsl_dataset_phys_t));
1324 	dsphys->ds_dir_obj = ds->ds_dir->dd_object;
1325 	dsphys->ds_fsid_guid = unique_create();
1326 	(void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
1327 	    sizeof (dsphys->ds_guid));
1328 	dsphys->ds_prev_snap_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
1329 	dsphys->ds_prev_snap_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
1330 	dsphys->ds_next_snap_obj = ds->ds_object;
1331 	dsphys->ds_num_children = 1;
1332 	dsphys->ds_creation_time = gethrestime_sec();
1333 	dsphys->ds_creation_txg = crtxg;
1334 	dsphys->ds_deadlist_obj = dsl_dataset_phys(ds)->ds_deadlist_obj;
1335 	dsphys->ds_referenced_bytes = dsl_dataset_phys(ds)->ds_referenced_bytes;
1336 	dsphys->ds_compressed_bytes = dsl_dataset_phys(ds)->ds_compressed_bytes;
1337 	dsphys->ds_uncompressed_bytes =
1338 	    dsl_dataset_phys(ds)->ds_uncompressed_bytes;
1339 	dsphys->ds_flags = dsl_dataset_phys(ds)->ds_flags;
1340 	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
1341 	dsphys->ds_bp = dsl_dataset_phys(ds)->ds_bp;
1342 	rrw_exit(&ds->ds_bp_rwlock, FTAG);
1343 	dmu_buf_rele(dbuf, FTAG);
1344 
1345 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
1346 		if (ds->ds_feature_inuse[f])
1347 			dsl_dataset_activate_feature(dsobj, f, tx);
1348 	}
1349 
1350 	ASSERT3U(ds->ds_prev != 0, ==,
1351 	    dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);
1352 	if (ds->ds_prev) {
1353 		uint64_t next_clones_obj =
1354 		    dsl_dataset_phys(ds->ds_prev)->ds_next_clones_obj;
1355 		ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1356 		    ds->ds_object ||
1357 		    dsl_dataset_phys(ds->ds_prev)->ds_num_children > 1);
1358 		if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1359 		    ds->ds_object) {
1360 			dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
1361 			ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, ==,
1362 			    dsl_dataset_phys(ds->ds_prev)->ds_creation_txg);
1363 			dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj = dsobj;
1364 		} else if (next_clones_obj != 0) {
1365 			dsl_dataset_remove_from_next_clones(ds->ds_prev,
1366 			    dsphys->ds_next_snap_obj, tx);
1367 			VERIFY0(zap_add_int(mos,
1368 			    next_clones_obj, dsobj, tx));
1369 		}
1370 	}
1371 
1372 	/*
1373 	 * If we have a reference-reservation on this dataset, we will
1374 	 * need to increase the amount of refreservation being charged
1375 	 * since our unique space is going to zero.
1376 	 */
1377 	if (ds->ds_reserved) {
1378 		int64_t delta;
1379 		ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
1380 		delta = MIN(dsl_dataset_phys(ds)->ds_unique_bytes,
1381 		    ds->ds_reserved);
1382 		dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
1383 		    delta, 0, 0, tx);
1384 	}
1385 
1386 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
1387 	dsl_dataset_phys(ds)->ds_deadlist_obj =
1388 	    dsl_deadlist_clone(&ds->ds_deadlist, UINT64_MAX,
1389 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
1390 	dsl_deadlist_close(&ds->ds_deadlist);
1391 	dsl_deadlist_open(&ds->ds_deadlist, mos,
1392 	    dsl_dataset_phys(ds)->ds_deadlist_obj);
1393 	dsl_deadlist_add_key(&ds->ds_deadlist,
1394 	    dsl_dataset_phys(ds)->ds_prev_snap_txg, tx);
1395 
1396 	ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, <, tx->tx_txg);
1397 	dsl_dataset_phys(ds)->ds_prev_snap_obj = dsobj;
1398 	dsl_dataset_phys(ds)->ds_prev_snap_txg = crtxg;
1399 	dsl_dataset_phys(ds)->ds_unique_bytes = 0;
1400 	if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
1401 		dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1402 
1403 	VERIFY0(zap_add(mos, dsl_dataset_phys(ds)->ds_snapnames_zapobj,
1404 	    snapname, 8, 1, &dsobj, tx));
1405 
1406 	if (ds->ds_prev)
1407 		dsl_dataset_rele(ds->ds_prev, ds);
1408 	VERIFY0(dsl_dataset_hold_obj(dp,
1409 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, ds, &ds->ds_prev));
1410 
1411 	dsl_scan_ds_snapshotted(ds, tx);
1412 
1413 	dsl_dir_snap_cmtime_update(ds->ds_dir);
1414 
1415 	spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, "");
1416 }
1417 
1418 void
1419 dsl_dataset_snapshot_sync(void *arg, dmu_tx_t *tx)
1420 {
1421 	dsl_dataset_snapshot_arg_t *ddsa = arg;
1422 	dsl_pool_t *dp = dmu_tx_pool(tx);
1423 	nvpair_t *pair;
1424 
1425 	for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1426 	    pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1427 		dsl_dataset_t *ds;
1428 		char *name, *atp;
1429 		char dsname[ZFS_MAX_DATASET_NAME_LEN];
1430 
1431 		name = nvpair_name(pair);
1432 		atp = strchr(name, '@');
1433 		(void) strlcpy(dsname, name, atp - name + 1);
1434 		VERIFY0(dsl_dataset_hold(dp, dsname, FTAG, &ds));
1435 
1436 		dsl_dataset_snapshot_sync_impl(ds, atp + 1, tx);
1437 		if (ddsa->ddsa_props != NULL) {
1438 			dsl_props_set_sync_impl(ds->ds_prev,
1439 			    ZPROP_SRC_LOCAL, ddsa->ddsa_props, tx);
1440 		}
1441 		dsl_dataset_rele(ds, FTAG);
1442 	}
1443 }
1444 
1445 /*
1446  * The snapshots must all be in the same pool.
1447  * All-or-nothing: if there are any failures, nothing will be modified.
1448  */
1449 int
1450 dsl_dataset_snapshot(nvlist_t *snaps, nvlist_t *props, nvlist_t *errors)
1451 {
1452 	dsl_dataset_snapshot_arg_t ddsa;
1453 	nvpair_t *pair;
1454 	boolean_t needsuspend;
1455 	int error;
1456 	spa_t *spa;
1457 	char *firstname;
1458 	nvlist_t *suspended = NULL;
1459 
1460 	pair = nvlist_next_nvpair(snaps, NULL);
1461 	if (pair == NULL)
1462 		return (0);
1463 	firstname = nvpair_name(pair);
1464 
1465 	error = spa_open(firstname, &spa, FTAG);
1466 	if (error != 0)
1467 		return (error);
1468 	needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
1469 	spa_close(spa, FTAG);
1470 
1471 	if (needsuspend) {
1472 		suspended = fnvlist_alloc();
1473 		for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
1474 		    pair = nvlist_next_nvpair(snaps, pair)) {
1475 			char fsname[ZFS_MAX_DATASET_NAME_LEN];
1476 			char *snapname = nvpair_name(pair);
1477 			char *atp;
1478 			void *cookie;
1479 
1480 			atp = strchr(snapname, '@');
1481 			if (atp == NULL) {
1482 				error = SET_ERROR(EINVAL);
1483 				break;
1484 			}
1485 			(void) strlcpy(fsname, snapname, atp - snapname + 1);
1486 
1487 			error = zil_suspend(fsname, &cookie);
1488 			if (error != 0)
1489 				break;
1490 			fnvlist_add_uint64(suspended, fsname,
1491 			    (uintptr_t)cookie);
1492 		}
1493 	}
1494 
1495 	ddsa.ddsa_snaps = snaps;
1496 	ddsa.ddsa_props = props;
1497 	ddsa.ddsa_errors = errors;
1498 	ddsa.ddsa_cr = CRED();
1499 
1500 	if (error == 0) {
1501 		error = dsl_sync_task(firstname, dsl_dataset_snapshot_check,
1502 		    dsl_dataset_snapshot_sync, &ddsa,
1503 		    fnvlist_num_pairs(snaps) * 3, ZFS_SPACE_CHECK_NORMAL);
1504 	}
1505 
1506 	if (suspended != NULL) {
1507 		for (pair = nvlist_next_nvpair(suspended, NULL); pair != NULL;
1508 		    pair = nvlist_next_nvpair(suspended, pair)) {
1509 			zil_resume((void *)(uintptr_t)
1510 			    fnvpair_value_uint64(pair));
1511 		}
1512 		fnvlist_free(suspended);
1513 	}
1514 
1515 	return (error);
1516 }
1517 
1518 typedef struct dsl_dataset_snapshot_tmp_arg {
1519 	const char *ddsta_fsname;
1520 	const char *ddsta_snapname;
1521 	minor_t ddsta_cleanup_minor;
1522 	const char *ddsta_htag;
1523 } dsl_dataset_snapshot_tmp_arg_t;
1524 
1525 static int
1526 dsl_dataset_snapshot_tmp_check(void *arg, dmu_tx_t *tx)
1527 {
1528 	dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
1529 	dsl_pool_t *dp = dmu_tx_pool(tx);
1530 	dsl_dataset_t *ds;
1531 	int error;
1532 
1533 	error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
1534 	if (error != 0)
1535 		return (error);
1536 
1537 	/* NULL cred means no limit check for tmp snapshot */
1538 	error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
1539 	    tx, B_FALSE, 0, NULL);
1540 	if (error != 0) {
1541 		dsl_dataset_rele(ds, FTAG);
1542 		return (error);
1543 	}
1544 
1545 	if (spa_version(dp->dp_spa) < SPA_VERSION_USERREFS) {
1546 		dsl_dataset_rele(ds, FTAG);
1547 		return (SET_ERROR(ENOTSUP));
1548 	}
1549 	error = dsl_dataset_user_hold_check_one(NULL, ddsta->ddsta_htag,
1550 	    B_TRUE, tx);
1551 	if (error != 0) {
1552 		dsl_dataset_rele(ds, FTAG);
1553 		return (error);
1554 	}
1555 
1556 	dsl_dataset_rele(ds, FTAG);
1557 	return (0);
1558 }
1559 
1560 static void
1561 dsl_dataset_snapshot_tmp_sync(void *arg, dmu_tx_t *tx)
1562 {
1563 	dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
1564 	dsl_pool_t *dp = dmu_tx_pool(tx);
1565 	dsl_dataset_t *ds;
1566 
1567 	VERIFY0(dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds));
1568 
1569 	dsl_dataset_snapshot_sync_impl(ds, ddsta->ddsta_snapname, tx);
1570 	dsl_dataset_user_hold_sync_one(ds->ds_prev, ddsta->ddsta_htag,
1571 	    ddsta->ddsta_cleanup_minor, gethrestime_sec(), tx);
1572 	dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, tx);
1573 
1574 	dsl_dataset_rele(ds, FTAG);
1575 }
1576 
1577 int
1578 dsl_dataset_snapshot_tmp(const char *fsname, const char *snapname,
1579     minor_t cleanup_minor, const char *htag)
1580 {
1581 	dsl_dataset_snapshot_tmp_arg_t ddsta;
1582 	int error;
1583 	spa_t *spa;
1584 	boolean_t needsuspend;
1585 	void *cookie;
1586 
1587 	ddsta.ddsta_fsname = fsname;
1588 	ddsta.ddsta_snapname = snapname;
1589 	ddsta.ddsta_cleanup_minor = cleanup_minor;
1590 	ddsta.ddsta_htag = htag;
1591 
1592 	error = spa_open(fsname, &spa, FTAG);
1593 	if (error != 0)
1594 		return (error);
1595 	needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
1596 	spa_close(spa, FTAG);
1597 
1598 	if (needsuspend) {
1599 		error = zil_suspend(fsname, &cookie);
1600 		if (error != 0)
1601 			return (error);
1602 	}
1603 
1604 	error = dsl_sync_task(fsname, dsl_dataset_snapshot_tmp_check,
1605 	    dsl_dataset_snapshot_tmp_sync, &ddsta, 3, ZFS_SPACE_CHECK_RESERVED);
1606 
1607 	if (needsuspend)
1608 		zil_resume(cookie);
1609 	return (error);
1610 }
1611 
1612 void
1613 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *zio, dmu_tx_t *tx)
1614 {
1615 	ASSERT(dmu_tx_is_syncing(tx));
1616 	ASSERT(ds->ds_objset != NULL);
1617 	ASSERT(dsl_dataset_phys(ds)->ds_next_snap_obj == 0);
1618 
1619 	/*
1620 	 * in case we had to change ds_fsid_guid when we opened it,
1621 	 * sync it out now.
1622 	 */
1623 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
1624 	dsl_dataset_phys(ds)->ds_fsid_guid = ds->ds_fsid_guid;
1625 
1626 	if (ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] != 0) {
1627 		VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1628 		    ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
1629 		    &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
1630 		VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1631 		    ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
1632 		    &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
1633 		VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1634 		    ds->ds_object, DS_FIELD_RESUME_BYTES, 8, 1,
1635 		    &ds->ds_resume_bytes[tx->tx_txg & TXG_MASK], tx));
1636 		ds->ds_resume_object[tx->tx_txg & TXG_MASK] = 0;
1637 		ds->ds_resume_offset[tx->tx_txg & TXG_MASK] = 0;
1638 		ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] = 0;
1639 	}
1640 
1641 	dmu_objset_sync(ds->ds_objset, zio, tx);
1642 
1643 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
1644 		if (ds->ds_feature_activation_needed[f]) {
1645 			if (ds->ds_feature_inuse[f])
1646 				continue;
1647 			dsl_dataset_activate_feature(ds->ds_object, f, tx);
1648 			ds->ds_feature_inuse[f] = B_TRUE;
1649 		}
1650 	}
1651 }
1652 
1653 static int
1654 deadlist_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1655 {
1656 	dsl_deadlist_t *dl = arg;
1657 	dsl_deadlist_insert(dl, bp, tx);
1658 	return (0);
1659 }
1660 
1661 void
1662 dsl_dataset_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx)
1663 {
1664 	objset_t *os = ds->ds_objset;
1665 
1666 	bplist_iterate(&ds->ds_pending_deadlist,
1667 	    deadlist_enqueue_cb, &ds->ds_deadlist, tx);
1668 
1669 	if (os->os_synced_dnodes != NULL) {
1670 		multilist_destroy(os->os_synced_dnodes);
1671 		os->os_synced_dnodes = NULL;
1672 	}
1673 
1674 	ASSERT(!dmu_objset_is_dirty(os, dmu_tx_get_txg(tx)));
1675 
1676 	dmu_buf_rele(ds->ds_dbuf, ds);
1677 }
1678 
1679 int
1680 get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
1681 {
1682 	uint64_t count = 0;
1683 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1684 	zap_cursor_t zc;
1685 	zap_attribute_t za;
1686 
1687 	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1688 
1689 	/*
1690 	 * There may be missing entries in ds_next_clones_obj
1691 	 * due to a bug in a previous version of the code.
1692 	 * Only trust it if it has the right number of entries.
1693 	 */
1694 	if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
1695 		VERIFY0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1696 		    &count));
1697 	}
1698 	if (count != dsl_dataset_phys(ds)->ds_num_children - 1) {
1699 		return (ENOENT);
1700 	}
1701 	for (zap_cursor_init(&zc, mos,
1702 	    dsl_dataset_phys(ds)->ds_next_clones_obj);
1703 	    zap_cursor_retrieve(&zc, &za) == 0;
1704 	    zap_cursor_advance(&zc)) {
1705 		dsl_dataset_t *clone;
1706 		char buf[ZFS_MAX_DATASET_NAME_LEN];
1707 		VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
1708 		    za.za_first_integer, FTAG, &clone));
1709 		dsl_dir_name(clone->ds_dir, buf);
1710 		fnvlist_add_boolean(val, buf);
1711 		dsl_dataset_rele(clone, FTAG);
1712 	}
1713 	zap_cursor_fini(&zc);
1714 	return (0);
1715 }
1716 
1717 void
1718 get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv)
1719 {
1720 	nvlist_t *propval = fnvlist_alloc();
1721 	nvlist_t *val;
1722 
1723 	/*
1724 	 * We use nvlist_alloc() instead of fnvlist_alloc() because the
1725 	 * latter would allocate the list with NV_UNIQUE_NAME flag.
1726 	 * As a result, every time a clone name is appended to the list
1727 	 * it would be (linearly) searched for for a duplicate name.
1728 	 * We already know that all clone names must be unique and we
1729 	 * want avoid the quadratic complexity of double-checking that
1730 	 * because we can have a large number of clones.
1731 	 */
1732 	VERIFY0(nvlist_alloc(&val, 0, KM_SLEEP));
1733 
1734 	if (get_clones_stat_impl(ds, val) == 0) {
1735 		fnvlist_add_nvlist(propval, ZPROP_VALUE, val);
1736 		fnvlist_add_nvlist(nv, zfs_prop_to_name(ZFS_PROP_CLONES),
1737 		    propval);
1738 	}
1739 
1740 	nvlist_free(val);
1741 	nvlist_free(propval);
1742 }
1743 
1744 /*
1745  * Returns a string that represents the receive resume stats token. It should
1746  * be freed with strfree().
1747  */
1748 char *
1749 get_receive_resume_stats_impl(dsl_dataset_t *ds)
1750 {
1751 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
1752 
1753 	if (dsl_dataset_has_resume_receive_state(ds)) {
1754 		char *str;
1755 		void *packed;
1756 		uint8_t *compressed;
1757 		uint64_t val;
1758 		nvlist_t *token_nv = fnvlist_alloc();
1759 		size_t packed_size, compressed_size;
1760 
1761 		if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1762 		    DS_FIELD_RESUME_FROMGUID, sizeof (val), 1, &val) == 0) {
1763 			fnvlist_add_uint64(token_nv, "fromguid", val);
1764 		}
1765 		if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1766 		    DS_FIELD_RESUME_OBJECT, sizeof (val), 1, &val) == 0) {
1767 			fnvlist_add_uint64(token_nv, "object", val);
1768 		}
1769 		if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1770 		    DS_FIELD_RESUME_OFFSET, sizeof (val), 1, &val) == 0) {
1771 			fnvlist_add_uint64(token_nv, "offset", val);
1772 		}
1773 		if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1774 		    DS_FIELD_RESUME_BYTES, sizeof (val), 1, &val) == 0) {
1775 			fnvlist_add_uint64(token_nv, "bytes", val);
1776 		}
1777 		if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1778 		    DS_FIELD_RESUME_TOGUID, sizeof (val), 1, &val) == 0) {
1779 			fnvlist_add_uint64(token_nv, "toguid", val);
1780 		}
1781 		char buf[256];
1782 		if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1783 		    DS_FIELD_RESUME_TONAME, 1, sizeof (buf), buf) == 0) {
1784 			fnvlist_add_string(token_nv, "toname", buf);
1785 		}
1786 		if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1787 		    DS_FIELD_RESUME_LARGEBLOCK) == 0) {
1788 			fnvlist_add_boolean(token_nv, "largeblockok");
1789 		}
1790 		if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1791 		    DS_FIELD_RESUME_EMBEDOK) == 0) {
1792 			fnvlist_add_boolean(token_nv, "embedok");
1793 		}
1794 		if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1795 		    DS_FIELD_RESUME_COMPRESSOK) == 0) {
1796 			fnvlist_add_boolean(token_nv, "compressok");
1797 		}
1798 		packed = fnvlist_pack(token_nv, &packed_size);
1799 		fnvlist_free(token_nv);
1800 		compressed = kmem_alloc(packed_size, KM_SLEEP);
1801 
1802 		compressed_size = gzip_compress(packed, compressed,
1803 		    packed_size, packed_size, 6);
1804 
1805 		zio_cksum_t cksum;
1806 		fletcher_4_native(compressed, compressed_size, NULL, &cksum);
1807 
1808 		str = kmem_alloc(compressed_size * 2 + 1, KM_SLEEP);
1809 		for (int i = 0; i < compressed_size; i++) {
1810 			(void) sprintf(str + i * 2, "%02x", compressed[i]);
1811 		}
1812 		str[compressed_size * 2] = '\0';
1813 		char *propval = kmem_asprintf("%u-%llx-%llx-%s",
1814 		    ZFS_SEND_RESUME_TOKEN_VERSION,
1815 		    (longlong_t)cksum.zc_word[0],
1816 		    (longlong_t)packed_size, str);
1817 		kmem_free(packed, packed_size);
1818 		kmem_free(str, compressed_size * 2 + 1);
1819 		kmem_free(compressed, packed_size);
1820 		return (propval);
1821 	}
1822 	return (strdup(""));
1823 }
1824 
1825 /*
1826  * Returns a string that represents the receive resume stats token of the
1827  * dataset's child. It should be freed with strfree().
1828  */
1829 char *
1830 get_child_receive_stats(dsl_dataset_t *ds)
1831 {
1832 	char recvname[ZFS_MAX_DATASET_NAME_LEN + 6];
1833 	dsl_dataset_t *recv_ds;
1834 	dsl_dataset_name(ds, recvname);
1835 	if (strlcat(recvname, "/", sizeof (recvname)) <
1836 	    sizeof (recvname) &&
1837 	    strlcat(recvname, recv_clone_name, sizeof (recvname)) <
1838 	    sizeof (recvname) &&
1839 	    dsl_dataset_hold(ds->ds_dir->dd_pool, recvname, FTAG,
1840 	    &recv_ds)  == 0) {
1841 		char *propval = get_receive_resume_stats_impl(recv_ds);
1842 		dsl_dataset_rele(recv_ds, FTAG);
1843 		return (propval);
1844 	}
1845 	return (strdup(""));
1846 }
1847 
1848 static void
1849 get_receive_resume_stats(dsl_dataset_t *ds, nvlist_t *nv)
1850 {
1851 	char *propval = get_receive_resume_stats_impl(ds);
1852 	if (strcmp(propval, "") != 0) {
1853 		dsl_prop_nvlist_add_string(nv,
1854 		    ZFS_PROP_RECEIVE_RESUME_TOKEN, propval);
1855 	} else {
1856 		char *childval = get_child_receive_stats(ds);
1857 		if (strcmp(childval, "") != 0) {
1858 			dsl_prop_nvlist_add_string(nv,
1859 			    ZFS_PROP_RECEIVE_RESUME_TOKEN, childval);
1860 		}
1861 		strfree(childval);
1862 	}
1863 	strfree(propval);
1864 }
1865 
1866 uint64_t
1867 dsl_get_refratio(dsl_dataset_t *ds)
1868 {
1869 	uint64_t ratio = dsl_dataset_phys(ds)->ds_compressed_bytes == 0 ? 100 :
1870 	    (dsl_dataset_phys(ds)->ds_uncompressed_bytes * 100 /
1871 	    dsl_dataset_phys(ds)->ds_compressed_bytes);
1872 	return (ratio);
1873 }
1874 
1875 uint64_t
1876 dsl_get_logicalreferenced(dsl_dataset_t *ds)
1877 {
1878 	return (dsl_dataset_phys(ds)->ds_uncompressed_bytes);
1879 }
1880 
1881 uint64_t
1882 dsl_get_compressratio(dsl_dataset_t *ds)
1883 {
1884 	if (ds->ds_is_snapshot) {
1885 		return (dsl_get_refratio(ds));
1886 	} else {
1887 		dsl_dir_t *dd = ds->ds_dir;
1888 		mutex_enter(&dd->dd_lock);
1889 		uint64_t val = dsl_dir_get_compressratio(dd);
1890 		mutex_exit(&dd->dd_lock);
1891 		return (val);
1892 	}
1893 }
1894 
1895 uint64_t
1896 dsl_get_used(dsl_dataset_t *ds)
1897 {
1898 	if (ds->ds_is_snapshot) {
1899 		return (dsl_dataset_phys(ds)->ds_unique_bytes);
1900 	} else {
1901 		dsl_dir_t *dd = ds->ds_dir;
1902 		mutex_enter(&dd->dd_lock);
1903 		uint64_t val = dsl_dir_get_used(dd);
1904 		mutex_exit(&dd->dd_lock);
1905 		return (val);
1906 	}
1907 }
1908 
1909 uint64_t
1910 dsl_get_creation(dsl_dataset_t *ds)
1911 {
1912 	return (dsl_dataset_phys(ds)->ds_creation_time);
1913 }
1914 
1915 uint64_t
1916 dsl_get_creationtxg(dsl_dataset_t *ds)
1917 {
1918 	return (dsl_dataset_phys(ds)->ds_creation_txg);
1919 }
1920 
1921 uint64_t
1922 dsl_get_refquota(dsl_dataset_t *ds)
1923 {
1924 	return (ds->ds_quota);
1925 }
1926 
1927 uint64_t
1928 dsl_get_refreservation(dsl_dataset_t *ds)
1929 {
1930 	return (ds->ds_reserved);
1931 }
1932 
1933 uint64_t
1934 dsl_get_guid(dsl_dataset_t *ds)
1935 {
1936 	return (dsl_dataset_phys(ds)->ds_guid);
1937 }
1938 
1939 uint64_t
1940 dsl_get_unique(dsl_dataset_t *ds)
1941 {
1942 	return (dsl_dataset_phys(ds)->ds_unique_bytes);
1943 }
1944 
1945 uint64_t
1946 dsl_get_objsetid(dsl_dataset_t *ds)
1947 {
1948 	return (ds->ds_object);
1949 }
1950 
1951 uint64_t
1952 dsl_get_userrefs(dsl_dataset_t *ds)
1953 {
1954 	return (ds->ds_userrefs);
1955 }
1956 
1957 uint64_t
1958 dsl_get_defer_destroy(dsl_dataset_t *ds)
1959 {
1960 	return (DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
1961 }
1962 
1963 uint64_t
1964 dsl_get_referenced(dsl_dataset_t *ds)
1965 {
1966 	return (dsl_dataset_phys(ds)->ds_referenced_bytes);
1967 }
1968 
1969 uint64_t
1970 dsl_get_numclones(dsl_dataset_t *ds)
1971 {
1972 	ASSERT(ds->ds_is_snapshot);
1973 	return (dsl_dataset_phys(ds)->ds_num_children - 1);
1974 }
1975 
1976 uint64_t
1977 dsl_get_inconsistent(dsl_dataset_t *ds)
1978 {
1979 	return ((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT) ?
1980 	    1 : 0);
1981 }
1982 
1983 uint64_t
1984 dsl_get_available(dsl_dataset_t *ds)
1985 {
1986 	uint64_t refdbytes = dsl_get_referenced(ds);
1987 	uint64_t availbytes = dsl_dir_space_available(ds->ds_dir,
1988 	    NULL, 0, TRUE);
1989 	if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
1990 		availbytes +=
1991 		    ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
1992 	}
1993 	if (ds->ds_quota != 0) {
1994 		/*
1995 		 * Adjust available bytes according to refquota
1996 		 */
1997 		if (refdbytes < ds->ds_quota) {
1998 			availbytes = MIN(availbytes,
1999 			    ds->ds_quota - refdbytes);
2000 		} else {
2001 			availbytes = 0;
2002 		}
2003 	}
2004 	return (availbytes);
2005 }
2006 
2007 int
2008 dsl_get_written(dsl_dataset_t *ds, uint64_t *written)
2009 {
2010 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
2011 	dsl_dataset_t *prev;
2012 	int err = dsl_dataset_hold_obj(dp,
2013 	    dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
2014 	if (err == 0) {
2015 		uint64_t comp, uncomp;
2016 		err = dsl_dataset_space_written(prev, ds, written,
2017 		    &comp, &uncomp);
2018 		dsl_dataset_rele(prev, FTAG);
2019 	}
2020 	return (err);
2021 }
2022 
2023 /*
2024  * 'snap' should be a buffer of size ZFS_MAX_DATASET_NAME_LEN.
2025  */
2026 int
2027 dsl_get_prev_snap(dsl_dataset_t *ds, char *snap)
2028 {
2029 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
2030 	if (ds->ds_prev != NULL && ds->ds_prev != dp->dp_origin_snap) {
2031 		dsl_dataset_name(ds->ds_prev, snap);
2032 		return (0);
2033 	} else {
2034 		return (ENOENT);
2035 	}
2036 }
2037 
2038 /*
2039  * Returns the mountpoint property and source for the given dataset in the value
2040  * and source buffers. The value buffer must be at least as large as MAXPATHLEN
2041  * and the source buffer as least as large a ZFS_MAX_DATASET_NAME_LEN.
2042  * Returns 0 on success and an error on failure.
2043  */
2044 int
2045 dsl_get_mountpoint(dsl_dataset_t *ds, const char *dsname, char *value,
2046     char *source)
2047 {
2048 	int error;
2049 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
2050 
2051 	/* Retrieve the mountpoint value stored in the zap opbject */
2052 	error = dsl_prop_get_ds(ds, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1,
2053 	    ZAP_MAXVALUELEN, value, source);
2054 	if (error != 0) {
2055 		return (error);
2056 	}
2057 
2058 	/* Process the dsname and source to find the full mountpoint string */
2059 	if (value[0] == '/') {
2060 		char *buf = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
2061 		char *root = buf;
2062 		const char *relpath;
2063 
2064 		/*
2065 		 * If we inherit the mountpoint, even from a dataset
2066 		 * with a received value, the source will be the path of
2067 		 * the dataset we inherit from. If source is
2068 		 * ZPROP_SOURCE_VAL_RECVD, the received value is not
2069 		 * inherited.
2070 		 */
2071 		if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) {
2072 			relpath = "";
2073 		} else {
2074 			ASSERT0(strncmp(dsname, source, strlen(source)));
2075 			relpath = dsname + strlen(source);
2076 			if (relpath[0] == '/')
2077 				relpath++;
2078 		}
2079 
2080 		spa_altroot(dp->dp_spa, root, ZAP_MAXVALUELEN);
2081 
2082 		/*
2083 		 * Special case an alternate root of '/'. This will
2084 		 * avoid having multiple leading slashes in the
2085 		 * mountpoint path.
2086 		 */
2087 		if (strcmp(root, "/") == 0)
2088 			root++;
2089 
2090 		/*
2091 		 * If the mountpoint is '/' then skip over this
2092 		 * if we are obtaining either an alternate root or
2093 		 * an inherited mountpoint.
2094 		 */
2095 		char *mnt = value;
2096 		if (value[1] == '\0' && (root[0] != '\0' ||
2097 		    relpath[0] != '\0'))
2098 			mnt = value + 1;
2099 
2100 		if (relpath[0] == '\0') {
2101 			(void) snprintf(value, ZAP_MAXVALUELEN, "%s%s",
2102 			    root, mnt);
2103 		} else {
2104 			(void) snprintf(value, ZAP_MAXVALUELEN, "%s%s%s%s",
2105 			    root, mnt, relpath[0] == '@' ? "" : "/",
2106 			    relpath);
2107 		}
2108 		kmem_free(buf, ZAP_MAXVALUELEN);
2109 	} else {
2110 		/* 'legacy' or 'none' */
2111 		(void) snprintf(value, ZAP_MAXVALUELEN, "%s", value);
2112 	}
2113 	return (0);
2114 }
2115 
2116 void
2117 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
2118 {
2119 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
2120 
2121 	ASSERT(dsl_pool_config_held(dp));
2122 
2123 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRATIO,
2124 	    dsl_get_refratio(ds));
2125 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_LOGICALREFERENCED,
2126 	    dsl_get_logicalreferenced(ds));
2127 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO,
2128 	    dsl_get_compressratio(ds));
2129 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,
2130 	    dsl_get_used(ds));
2131 
2132 	if (ds->ds_is_snapshot) {
2133 		get_clones_stat(ds, nv);
2134 	} else {
2135 		char buf[ZFS_MAX_DATASET_NAME_LEN];
2136 		if (dsl_get_prev_snap(ds, buf) == 0)
2137 			dsl_prop_nvlist_add_string(nv, ZFS_PROP_PREV_SNAP,
2138 			    buf);
2139 		dsl_dir_stats(ds->ds_dir, nv);
2140 	}
2141 
2142 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_AVAILABLE,
2143 	    dsl_get_available(ds));
2144 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFERENCED,
2145 	    dsl_get_referenced(ds));
2146 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATION,
2147 	    dsl_get_creation(ds));
2148 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATETXG,
2149 	    dsl_get_creationtxg(ds));
2150 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFQUOTA,
2151 	    dsl_get_refquota(ds));
2152 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRESERVATION,
2153 	    dsl_get_refreservation(ds));
2154 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_GUID,
2155 	    dsl_get_guid(ds));
2156 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_UNIQUE,
2157 	    dsl_get_unique(ds));
2158 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_OBJSETID,
2159 	    dsl_get_objsetid(ds));
2160 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USERREFS,
2161 	    dsl_get_userrefs(ds));
2162 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_DEFER_DESTROY,
2163 	    dsl_get_defer_destroy(ds));
2164 
2165 	if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
2166 		uint64_t written;
2167 		if (dsl_get_written(ds, &written) == 0) {
2168 			dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_WRITTEN,
2169 			    written);
2170 		}
2171 	}
2172 
2173 	if (!dsl_dataset_is_snapshot(ds)) {
2174 		/*
2175 		 * A failed "newfs" (e.g. full) resumable receive leaves
2176 		 * the stats set on this dataset.  Check here for the prop.
2177 		 */
2178 		get_receive_resume_stats(ds, nv);
2179 
2180 		/*
2181 		 * A failed incremental resumable receive leaves the
2182 		 * stats set on our child named "%recv".  Check the child
2183 		 * for the prop.
2184 		 */
2185 		/* 6 extra bytes for /%recv */
2186 		char recvname[ZFS_MAX_DATASET_NAME_LEN + 6];
2187 		dsl_dataset_t *recv_ds;
2188 		dsl_dataset_name(ds, recvname);
2189 		if (strlcat(recvname, "/", sizeof (recvname)) <
2190 		    sizeof (recvname) &&
2191 		    strlcat(recvname, recv_clone_name, sizeof (recvname)) <
2192 		    sizeof (recvname) &&
2193 		    dsl_dataset_hold(dp, recvname, FTAG, &recv_ds) == 0) {
2194 			get_receive_resume_stats(recv_ds, nv);
2195 			dsl_dataset_rele(recv_ds, FTAG);
2196 		}
2197 	}
2198 }
2199 
2200 void
2201 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
2202 {
2203 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
2204 	ASSERT(dsl_pool_config_held(dp));
2205 
2206 	stat->dds_creation_txg = dsl_get_creationtxg(ds);
2207 	stat->dds_inconsistent = dsl_get_inconsistent(ds);
2208 	stat->dds_guid = dsl_get_guid(ds);
2209 	stat->dds_origin[0] = '\0';
2210 	if (ds->ds_is_snapshot) {
2211 		stat->dds_is_snapshot = B_TRUE;
2212 		stat->dds_num_clones = dsl_get_numclones(ds);
2213 	} else {
2214 		stat->dds_is_snapshot = B_FALSE;
2215 		stat->dds_num_clones = 0;
2216 
2217 		if (dsl_dir_is_clone(ds->ds_dir)) {
2218 			dsl_dir_get_origin(ds->ds_dir, stat->dds_origin);
2219 		}
2220 	}
2221 }
2222 
2223 uint64_t
2224 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
2225 {
2226 	return (ds->ds_fsid_guid);
2227 }
2228 
2229 void
2230 dsl_dataset_space(dsl_dataset_t *ds,
2231     uint64_t *refdbytesp, uint64_t *availbytesp,
2232     uint64_t *usedobjsp, uint64_t *availobjsp)
2233 {
2234 	*refdbytesp = dsl_dataset_phys(ds)->ds_referenced_bytes;
2235 	*availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
2236 	if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes)
2237 		*availbytesp +=
2238 		    ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2239 	if (ds->ds_quota != 0) {
2240 		/*
2241 		 * Adjust available bytes according to refquota
2242 		 */
2243 		if (*refdbytesp < ds->ds_quota)
2244 			*availbytesp = MIN(*availbytesp,
2245 			    ds->ds_quota - *refdbytesp);
2246 		else
2247 			*availbytesp = 0;
2248 	}
2249 	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2250 	*usedobjsp = BP_GET_FILL(&dsl_dataset_phys(ds)->ds_bp);
2251 	rrw_exit(&ds->ds_bp_rwlock, FTAG);
2252 	*availobjsp = DN_MAX_OBJECT - *usedobjsp;
2253 }
2254 
2255 boolean_t
2256 dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap)
2257 {
2258 	dsl_pool_t *dp = ds->ds_dir->dd_pool;
2259 	uint64_t birth;
2260 
2261 	ASSERT(dsl_pool_config_held(dp));
2262 	if (snap == NULL)
2263 		return (B_FALSE);
2264 	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2265 	birth = dsl_dataset_get_blkptr(ds)->blk_birth;
2266 	rrw_exit(&ds->ds_bp_rwlock, FTAG);
2267 	if (birth > dsl_dataset_phys(snap)->ds_creation_txg) {
2268 		objset_t *os, *os_snap;
2269 		/*
2270 		 * It may be that only the ZIL differs, because it was
2271 		 * reset in the head.  Don't count that as being
2272 		 * modified.
2273 		 */
2274 		if (dmu_objset_from_ds(ds, &os) != 0)
2275 			return (B_TRUE);
2276 		if (dmu_objset_from_ds(snap, &os_snap) != 0)
2277 			return (B_TRUE);
2278 		return (bcmp(&os->os_phys->os_meta_dnode,
2279 		    &os_snap->os_phys->os_meta_dnode,
2280 		    sizeof (os->os_phys->os_meta_dnode)) != 0);
2281 	}
2282 	return (B_FALSE);
2283 }
2284 
2285 typedef struct dsl_dataset_rename_snapshot_arg {
2286 	const char *ddrsa_fsname;
2287 	const char *ddrsa_oldsnapname;
2288 	const char *ddrsa_newsnapname;
2289 	boolean_t ddrsa_recursive;
2290 	dmu_tx_t *ddrsa_tx;
2291 } dsl_dataset_rename_snapshot_arg_t;
2292 
2293 /* ARGSUSED */
2294 static int
2295 dsl_dataset_rename_snapshot_check_impl(dsl_pool_t *dp,
2296     dsl_dataset_t *hds, void *arg)
2297 {
2298 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2299 	int error;
2300 	uint64_t val;
2301 
2302 	error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2303 	if (error != 0) {
2304 		/* ignore nonexistent snapshots */
2305 		return (error == ENOENT ? 0 : error);
2306 	}
2307 
2308 	/* new name should not exist */
2309 	error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_newsnapname, &val);
2310 	if (error == 0)
2311 		error = SET_ERROR(EEXIST);
2312 	else if (error == ENOENT)
2313 		error = 0;
2314 
2315 	/* dataset name + 1 for the "@" + the new snapshot name must fit */
2316 	if (dsl_dir_namelen(hds->ds_dir) + 1 +
2317 	    strlen(ddrsa->ddrsa_newsnapname) >= ZFS_MAX_DATASET_NAME_LEN)
2318 		error = SET_ERROR(ENAMETOOLONG);
2319 
2320 	return (error);
2321 }
2322 
2323 static int
2324 dsl_dataset_rename_snapshot_check(void *arg, dmu_tx_t *tx)
2325 {
2326 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2327 	dsl_pool_t *dp = dmu_tx_pool(tx);
2328 	dsl_dataset_t *hds;
2329 	int error;
2330 
2331 	error = dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds);
2332 	if (error != 0)
2333 		return (error);
2334 
2335 	if (ddrsa->ddrsa_recursive) {
2336 		error = dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
2337 		    dsl_dataset_rename_snapshot_check_impl, ddrsa,
2338 		    DS_FIND_CHILDREN);
2339 	} else {
2340 		error = dsl_dataset_rename_snapshot_check_impl(dp, hds, ddrsa);
2341 	}
2342 	dsl_dataset_rele(hds, FTAG);
2343 	return (error);
2344 }
2345 
2346 static int
2347 dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,
2348     dsl_dataset_t *hds, void *arg)
2349 {
2350 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2351 	dsl_dataset_t *ds;
2352 	uint64_t val;
2353 	dmu_tx_t *tx = ddrsa->ddrsa_tx;
2354 	int error;
2355 
2356 	error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2357 	ASSERT(error == 0 || error == ENOENT);
2358 	if (error == ENOENT) {
2359 		/* ignore nonexistent snapshots */
2360 		return (0);
2361 	}
2362 
2363 	VERIFY0(dsl_dataset_hold_obj(dp, val, FTAG, &ds));
2364 
2365 	/* log before we change the name */
2366 	spa_history_log_internal_ds(ds, "rename", tx,
2367 	    "-> @%s", ddrsa->ddrsa_newsnapname);
2368 
2369 	VERIFY0(dsl_dataset_snap_remove(hds, ddrsa->ddrsa_oldsnapname, tx,
2370 	    B_FALSE));
2371 	mutex_enter(&ds->ds_lock);
2372 	(void) strcpy(ds->ds_snapname, ddrsa->ddrsa_newsnapname);
2373 	mutex_exit(&ds->ds_lock);
2374 	VERIFY0(zap_add(dp->dp_meta_objset,
2375 	    dsl_dataset_phys(hds)->ds_snapnames_zapobj,
2376 	    ds->ds_snapname, 8, 1, &ds->ds_object, tx));
2377 
2378 	dsl_dataset_rele(ds, FTAG);
2379 	return (0);
2380 }
2381 
2382 static void
2383 dsl_dataset_rename_snapshot_sync(void *arg, dmu_tx_t *tx)
2384 {
2385 	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2386 	dsl_pool_t *dp = dmu_tx_pool(tx);
2387 	dsl_dataset_t *hds;
2388 
2389 	VERIFY0(dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds));
2390 	ddrsa->ddrsa_tx = tx;
2391 	if (ddrsa->ddrsa_recursive) {
2392 		VERIFY0(dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
2393 		    dsl_dataset_rename_snapshot_sync_impl, ddrsa,
2394 		    DS_FIND_CHILDREN));
2395 	} else {
2396 		VERIFY0(dsl_dataset_rename_snapshot_sync_impl(dp, hds, ddrsa));
2397 	}
2398 	dsl_dataset_rele(hds, FTAG);
2399 }
2400 
2401 int
2402 dsl_dataset_rename_snapshot(const char *fsname,
2403     const char *oldsnapname, const char *newsnapname, boolean_t recursive)
2404 {
2405 	dsl_dataset_rename_snapshot_arg_t ddrsa;
2406 
2407 	ddrsa.ddrsa_fsname = fsname;
2408 	ddrsa.ddrsa_oldsnapname = oldsnapname;
2409 	ddrsa.ddrsa_newsnapname = newsnapname;
2410 	ddrsa.ddrsa_recursive = recursive;
2411 
2412 	return (dsl_sync_task(fsname, dsl_dataset_rename_snapshot_check,
2413 	    dsl_dataset_rename_snapshot_sync, &ddrsa,
2414 	    1, ZFS_SPACE_CHECK_RESERVED));
2415 }
2416 
2417 /*
2418  * If we're doing an ownership handoff, we need to make sure that there is
2419  * only one long hold on the dataset.  We're not allowed to change anything here
2420  * so we don't permanently release the long hold or regular hold here.  We want
2421  * to do this only when syncing to avoid the dataset unexpectedly going away
2422  * when we release the long hold.
2423  */
2424 static int
2425 dsl_dataset_handoff_check(dsl_dataset_t *ds, void *owner, dmu_tx_t *tx)
2426 {
2427 	boolean_t held;
2428 
2429 	if (!dmu_tx_is_syncing(tx))
2430 		return (0);
2431 
2432 	if (owner != NULL) {
2433 		VERIFY3P(ds->ds_owner, ==, owner);
2434 		dsl_dataset_long_rele(ds, owner);
2435 	}
2436 
2437 	held = dsl_dataset_long_held(ds);
2438 
2439 	if (owner != NULL)
2440 		dsl_dataset_long_hold(ds, owner);
2441 
2442 	if (held)
2443 		return (SET_ERROR(EBUSY));
2444 
2445 	return (0);
2446 }
2447 
2448 int
2449 dsl_dataset_rollback_check(void *arg, dmu_tx_t *tx)
2450 {
2451 	dsl_dataset_rollback_arg_t *ddra = arg;
2452 	dsl_pool_t *dp = dmu_tx_pool(tx);
2453 	dsl_dataset_t *ds;
2454 	int64_t unused_refres_delta;
2455 	int error;
2456 
2457 	error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
2458 	if (error != 0)
2459 		return (error);
2460 
2461 	/* must not be a snapshot */
2462 	if (ds->ds_is_snapshot) {
2463 		dsl_dataset_rele(ds, FTAG);
2464 		return (SET_ERROR(EINVAL));
2465 	}
2466 
2467 	/* must have a most recent snapshot */
2468 	if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
2469 		dsl_dataset_rele(ds, FTAG);
2470 		return (SET_ERROR(EINVAL));
2471 	}
2472 
2473 	/*
2474 	 * No rollback to a snapshot created in the current txg, because
2475 	 * the rollback may dirty the dataset and create blocks that are
2476 	 * not reachable from the rootbp while having a birth txg that
2477 	 * falls into the snapshot's range.
2478 	 */
2479 	if (dmu_tx_is_syncing(tx) &&
2480 	    dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg) {
2481 		dsl_dataset_rele(ds, FTAG);
2482 		return (SET_ERROR(EAGAIN));
2483 	}
2484 
2485 	/*
2486 	 * If the expected target snapshot is specified, then check that
2487 	 * the latest snapshot is it.
2488 	 */
2489 	if (ddra->ddra_tosnap != NULL) {
2490 		char namebuf[ZFS_MAX_DATASET_NAME_LEN];
2491 
2492 		dsl_dataset_name(ds->ds_prev, namebuf);
2493 		if (strcmp(namebuf, ddra->ddra_tosnap) != 0)
2494 			return (SET_ERROR(EXDEV));
2495 	}
2496 
2497 	/* must not have any bookmarks after the most recent snapshot */
2498 	nvlist_t *proprequest = fnvlist_alloc();
2499 	fnvlist_add_boolean(proprequest, zfs_prop_to_name(ZFS_PROP_CREATETXG));
2500 	nvlist_t *bookmarks = fnvlist_alloc();
2501 	error = dsl_get_bookmarks_impl(ds, proprequest, bookmarks);
2502 	fnvlist_free(proprequest);
2503 	if (error != 0)
2504 		return (error);
2505 	for (nvpair_t *pair = nvlist_next_nvpair(bookmarks, NULL);
2506 	    pair != NULL; pair = nvlist_next_nvpair(bookmarks, pair)) {
2507 		nvlist_t *valuenv =
2508 		    fnvlist_lookup_nvlist(fnvpair_value_nvlist(pair),
2509 		    zfs_prop_to_name(ZFS_PROP_CREATETXG));
2510 		uint64_t createtxg = fnvlist_lookup_uint64(valuenv, "value");
2511 		if (createtxg > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
2512 			fnvlist_free(bookmarks);
2513 			dsl_dataset_rele(ds, FTAG);
2514 			return (SET_ERROR(EEXIST));
2515 		}
2516 	}
2517 	fnvlist_free(bookmarks);
2518 
2519 	error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
2520 	if (error != 0) {
2521 		dsl_dataset_rele(ds, FTAG);
2522 		return (error);
2523 	}
2524 
2525 	/*
2526 	 * Check if the snap we are rolling back to uses more than
2527 	 * the refquota.
2528 	 */
2529 	if (ds->ds_quota != 0 &&
2530 	    dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
2531 		dsl_dataset_rele(ds, FTAG);
2532 		return (SET_ERROR(EDQUOT));
2533 	}
2534 
2535 	/*
2536 	 * When we do the clone swap, we will temporarily use more space
2537 	 * due to the refreservation (the head will no longer have any
2538 	 * unique space, so the entire amount of the refreservation will need
2539 	 * to be free).  We will immediately destroy the clone, freeing
2540 	 * this space, but the freeing happens over many txg's.
2541 	 */
2542 	unused_refres_delta = (int64_t)MIN(ds->ds_reserved,
2543 	    dsl_dataset_phys(ds)->ds_unique_bytes);
2544 
2545 	if (unused_refres_delta > 0 &&
2546 	    unused_refres_delta >
2547 	    dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE)) {
2548 		dsl_dataset_rele(ds, FTAG);
2549 		return (SET_ERROR(ENOSPC));
2550 	}
2551 
2552 	dsl_dataset_rele(ds, FTAG);
2553 	return (0);
2554 }
2555 
2556 void
2557 dsl_dataset_rollback_sync(void *arg, dmu_tx_t *tx)
2558 {
2559 	dsl_dataset_rollback_arg_t *ddra = arg;
2560 	dsl_pool_t *dp = dmu_tx_pool(tx);
2561 	dsl_dataset_t *ds, *clone;
2562 	uint64_t cloneobj;
2563 	char namebuf[ZFS_MAX_DATASET_NAME_LEN];
2564 
2565 	VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
2566 
2567 	dsl_dataset_name(ds->ds_prev, namebuf);
2568 	fnvlist_add_string(ddra->ddra_result, "target", namebuf);
2569 
2570 	cloneobj = dsl_dataset_create_sync(ds->ds_dir, "%rollback",
2571 	    ds->ds_prev, DS_CREATE_FLAG_NODIRTY, kcred, tx);
2572 
2573 	VERIFY0(dsl_dataset_hold_obj(dp, cloneobj, FTAG, &clone));
2574 
2575 	dsl_dataset_clone_swap_sync_impl(clone, ds, tx);
2576 	dsl_dataset_zero_zil(ds, tx);
2577 
2578 	dsl_destroy_head_sync_impl(clone, tx);
2579 
2580 	dsl_dataset_rele(clone, FTAG);
2581 	dsl_dataset_rele(ds, FTAG);
2582 }
2583 
2584 /*
2585  * Rolls back the given filesystem or volume to the most recent snapshot.
2586  * The name of the most recent snapshot will be returned under key "target"
2587  * in the result nvlist.
2588  *
2589  * If owner != NULL:
2590  * - The existing dataset MUST be owned by the specified owner at entry
2591  * - Upon return, dataset will still be held by the same owner, whether we
2592  *   succeed or not.
2593  *
2594  * This mode is required any time the existing filesystem is mounted.  See
2595  * notes above zfs_suspend_fs() for further details.
2596  */
2597 int
2598 dsl_dataset_rollback(const char *fsname, const char *tosnap, void *owner,
2599     nvlist_t *result)
2600 {
2601 	dsl_dataset_rollback_arg_t ddra;
2602 
2603 	ddra.ddra_fsname = fsname;
2604 	ddra.ddra_tosnap = tosnap;
2605 	ddra.ddra_owner = owner;
2606 	ddra.ddra_result = result;
2607 
2608 	return (dsl_sync_task(fsname, dsl_dataset_rollback_check,
2609 	    dsl_dataset_rollback_sync, &ddra,
2610 	    1, ZFS_SPACE_CHECK_RESERVED));
2611 }
2612 
2613 struct promotenode {
2614 	list_node_t link;
2615 	dsl_dataset_t *ds;
2616 };
2617 
2618 static int snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep);
2619 static int promote_hold(dsl_dataset_promote_arg_t *ddpa, dsl_pool_t *dp,
2620     void *tag);
2621 static void promote_rele(dsl_dataset_promote_arg_t *ddpa, void *tag);
2622 
2623 int
2624 dsl_dataset_promote_check(void *arg, dmu_tx_t *tx)
2625 {
2626 	dsl_dataset_promote_arg_t *ddpa = arg;
2627 	dsl_pool_t *dp = dmu_tx_pool(tx);
2628 	dsl_dataset_t *hds;
2629 	struct promotenode *snap;
2630 	dsl_dataset_t *origin_ds;
2631 	int err;
2632 	uint64_t unused;
2633 	uint64_t ss_mv_cnt;
2634 	size_t max_snap_len;
2635 	boolean_t conflicting_snaps;
2636 
2637 	err = promote_hold(ddpa, dp, FTAG);
2638 	if (err != 0)
2639 		return (err);
2640 
2641 	hds = ddpa->ddpa_clone;
2642 	snap = list_head(&ddpa->shared_snaps);
2643 	origin_ds = snap->ds;
2644 	max_snap_len = MAXNAMELEN - strlen(ddpa->ddpa_clonename) - 1;
2645 
2646 	snap = list_head(&ddpa->origin_snaps);
2647 
2648 	if (dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE) {
2649 		promote_rele(ddpa, FTAG);
2650 		return (SET_ERROR(EXDEV));
2651 	}
2652 
2653 	/*
2654 	 * Compute and check the amount of space to transfer.  Since this is
2655 	 * so expensive, don't do the preliminary check.
2656 	 */
2657 	if (!dmu_tx_is_syncing(tx)) {
2658 		promote_rele(ddpa, FTAG);
2659 		return (0);
2660 	}
2661 
2662 	/* compute origin's new unique space */
2663 	snap = list_tail(&ddpa->clone_snaps);
2664 	ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
2665 	    origin_ds->ds_object);
2666 	dsl_deadlist_space_range(&snap->ds->ds_deadlist,
2667 	    dsl_dataset_phys(origin_ds)->ds_prev_snap_txg, UINT64_MAX,
2668 	    &ddpa->unique, &unused, &unused);
2669 
2670 	/*
2671 	 * Walk the snapshots that we are moving
2672 	 *
2673 	 * Compute space to transfer.  Consider the incremental changes
2674 	 * to used by each snapshot:
2675 	 * (my used) = (prev's used) + (blocks born) - (blocks killed)
2676 	 * So each snapshot gave birth to:
2677 	 * (blocks born) = (my used) - (prev's used) + (blocks killed)
2678 	 * So a sequence would look like:
2679 	 * (uN - u(N-1) + kN) + ... + (u1 - u0 + k1) + (u0 - 0 + k0)
2680 	 * Which simplifies to:
2681 	 * uN + kN + kN-1 + ... + k1 + k0
2682 	 * Note however, if we stop before we reach the ORIGIN we get:
2683 	 * uN + kN + kN-1 + ... + kM - uM-1
2684 	 */
2685 	conflicting_snaps = B_FALSE;
2686 	ss_mv_cnt = 0;
2687 	ddpa->used = dsl_dataset_phys(origin_ds)->ds_referenced_bytes;
2688 	ddpa->comp = dsl_dataset_phys(origin_ds)->ds_compressed_bytes;
2689 	ddpa->uncomp = dsl_dataset_phys(origin_ds)->ds_uncompressed_bytes;
2690 	for (snap = list_head(&ddpa->shared_snaps); snap;
2691 	    snap = list_next(&ddpa->shared_snaps, snap)) {
2692 		uint64_t val, dlused, dlcomp, dluncomp;
2693 		dsl_dataset_t *ds = snap->ds;
2694 
2695 		ss_mv_cnt++;
2696 
2697 		/*
2698 		 * If there are long holds, we won't be able to evict
2699 		 * the objset.
2700 		 */
2701 		if (dsl_dataset_long_held(ds)) {
2702 			err = SET_ERROR(EBUSY);
2703 			goto out;
2704 		}
2705 
2706 		/* Check that the snapshot name does not conflict */
2707 		VERIFY0(dsl_dataset_get_snapname(ds));
2708 		if (strlen(ds->ds_snapname) >= max_snap_len) {
2709 			err = SET_ERROR(ENAMETOOLONG);
2710 			goto out;
2711 		}
2712 		err = dsl_dataset_snap_lookup(hds, ds->ds_snapname, &val);
2713 		if (err == 0) {
2714 			fnvlist_add_boolean(ddpa->err_ds,
2715 			    snap->ds->ds_snapname);
2716 			conflicting_snaps = B_TRUE;
2717 		} else if (err != ENOENT) {
2718 			goto out;
2719 		}
2720 
2721 		/* The very first snapshot does not have a deadlist */
2722 		if (dsl_dataset_phys(ds)->ds_prev_snap_obj == 0)
2723 			continue;
2724 
2725 		dsl_deadlist_space(&ds->ds_deadlist,
2726 		    &dlused, &dlcomp, &dluncomp);
2727 		ddpa->used += dlused;
2728 		ddpa->comp += dlcomp;
2729 		ddpa->uncomp += dluncomp;
2730 	}
2731 
2732 	/*
2733 	 * In order to return the full list of conflicting snapshots, we check
2734 	 * whether there was a conflict after traversing all of them.
2735 	 */
2736 	if (conflicting_snaps) {
2737 		err = SET_ERROR(EEXIST);
2738 		goto out;
2739 	}
2740 
2741 	/*
2742 	 * If we are a clone of a clone then we never reached ORIGIN,
2743 	 * so we need to subtract out the clone origin's used space.
2744 	 */
2745 	if (ddpa->origin_origin) {
2746 		ddpa->used -=
2747 		    dsl_dataset_phys(ddpa->origin_origin)->ds_referenced_bytes;
2748 		ddpa->comp -=
2749 		    dsl_dataset_phys(ddpa->origin_origin)->ds_compressed_bytes;
2750 		ddpa->uncomp -=
2751 		    dsl_dataset_phys(ddpa->origin_origin)->
2752 		    ds_uncompressed_bytes;
2753 	}
2754 
2755 	/* Check that there is enough space and limit headroom here */
2756 	err = dsl_dir_transfer_possible(origin_ds->ds_dir, hds->ds_dir,
2757 	    0, ss_mv_cnt, ddpa->used, ddpa->cr);
2758 	if (err != 0)
2759 		goto out;
2760 
2761 	/*
2762 	 * Compute the amounts of space that will be used by snapshots
2763 	 * after the promotion (for both origin and clone).  For each,
2764 	 * it is the amount of space that will be on all of their
2765 	 * deadlists (that was not born before their new origin).
2766 	 */
2767 	if (dsl_dir_phys(hds->ds_dir)->dd_flags & DD_FLAG_USED_BREAKDOWN) {
2768 		uint64_t space;
2769 
2770 		/*
2771 		 * Note, typically this will not be a clone of a clone,
2772 		 * so dd_origin_txg will be < TXG_INITIAL, so
2773 		 * these snaplist_space() -> dsl_deadlist_space_range()
2774 		 * calls will be fast because they do not have to
2775 		 * iterate over all bps.
2776 		 */
2777 		snap = list_head(&ddpa->origin_snaps);
2778 		err = snaplist_space(&ddpa->shared_snaps,
2779 		    snap->ds->ds_dir->dd_origin_txg, &ddpa->cloneusedsnap);
2780 		if (err != 0)
2781 			goto out;
2782 
2783 		err = snaplist_space(&ddpa->clone_snaps,
2784 		    snap->ds->ds_dir->dd_origin_txg, &space);
2785 		if (err != 0)
2786 			goto out;
2787 		ddpa->cloneusedsnap += space;
2788 	}
2789 	if (dsl_dir_phys(origin_ds->ds_dir)->dd_flags &
2790 	    DD_FLAG_USED_BREAKDOWN) {
2791 		err = snaplist_space(&ddpa->origin_snaps,
2792 		    dsl_dataset_phys(origin_ds)->ds_creation_txg,
2793 		    &ddpa->originusedsnap);
2794 		if (err != 0)
2795 			goto out;
2796 	}
2797 
2798 out:
2799 	promote_rele(ddpa, FTAG);
2800 	return (err);
2801 }
2802 
2803 void
2804 dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx)
2805 {
2806 	dsl_dataset_promote_arg_t *ddpa = arg;
2807 	dsl_pool_t *dp = dmu_tx_pool(tx);
2808 	dsl_dataset_t *hds;
2809 	struct promotenode *snap;
2810 	dsl_dataset_t *origin_ds;
2811 	dsl_dataset_t *origin_head;
2812 	dsl_dir_t *dd;
2813 	dsl_dir_t *odd = NULL;
2814 	uint64_t oldnext_obj;
2815 	int64_t delta;
2816 
2817 	VERIFY0(promote_hold(ddpa, dp, FTAG));
2818 	hds = ddpa->ddpa_clone;
2819 
2820 	ASSERT0(dsl_dataset_phys(hds)->ds_flags & DS_FLAG_NOPROMOTE);
2821 
2822 	snap = list_head(&ddpa->shared_snaps);
2823 	origin_ds = snap->ds;
2824 	dd = hds->ds_dir;
2825 
2826 	snap = list_head(&ddpa->origin_snaps);
2827 	origin_head = snap->ds;
2828 
2829 	/*
2830 	 * We need to explicitly open odd, since origin_ds's dd will be
2831 	 * changing.
2832 	 */
2833 	VERIFY0(dsl_dir_hold_obj(dp, origin_ds->ds_dir->dd_object,
2834 	    NULL, FTAG, &odd));
2835 
2836 	/* change origin's next snap */
2837 	dmu_buf_will_dirty(origin_ds->ds_dbuf, tx);
2838 	oldnext_obj = dsl_dataset_phys(origin_ds)->ds_next_snap_obj;
2839 	snap = list_tail(&ddpa->clone_snaps);
2840 	ASSERT3U(dsl_dataset_phys(snap->ds)->ds_prev_snap_obj, ==,
2841 	    origin_ds->ds_object);
2842 	dsl_dataset_phys(origin_ds)->ds_next_snap_obj = snap->ds->ds_object;
2843 
2844 	/* change the origin's next clone */
2845 	if (dsl_dataset_phys(origin_ds)->ds_next_clones_obj) {
2846 		dsl_dataset_remove_from_next_clones(origin_ds,
2847 		    snap->ds->ds_object, tx);
2848 		VERIFY0(zap_add_int(dp->dp_meta_objset,
2849 		    dsl_dataset_phys(origin_ds)->ds_next_clones_obj,
2850 		    oldnext_obj, tx));
2851 	}
2852 
2853 	/* change origin */
2854 	dmu_buf_will_dirty(dd->dd_dbuf, tx);
2855 	ASSERT3U(dsl_dir_phys(dd)->dd_origin_obj, ==, origin_ds->ds_object);
2856 	dsl_dir_phys(dd)->dd_origin_obj = dsl_dir_phys(odd)->dd_origin_obj;
2857 	dd->dd_origin_txg = origin_head->ds_dir->dd_origin_txg;
2858 	dmu_buf_will_dirty(odd->dd_dbuf, tx);
2859 	dsl_dir_phys(odd)->dd_origin_obj = origin_ds->ds_object;
2860 	origin_head->ds_dir->dd_origin_txg =
2861 	    dsl_dataset_phys(origin_ds)->ds_creation_txg;
2862 
2863 	/* change dd_clone entries */
2864 	if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
2865 		VERIFY0(zap_remove_int(dp->dp_meta_objset,
2866 		    dsl_dir_phys(odd)->dd_clones, hds->ds_object, tx));
2867 		VERIFY0(zap_add_int(dp->dp_meta_objset,
2868 		    dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
2869 		    hds->ds_object, tx));
2870 
2871 		VERIFY0(zap_remove_int(dp->dp_meta_objset,
2872 		    dsl_dir_phys(ddpa->origin_origin->ds_dir)->dd_clones,
2873 		    origin_head->ds_object, tx));
2874 		if (dsl_dir_phys(dd)->dd_clones == 0) {
2875 			dsl_dir_phys(dd)->dd_clones =
2876 			    zap_create(dp->dp_meta_objset, DMU_OT_DSL_CLONES,
2877 			    DMU_OT_NONE, 0, tx);
2878 		}
2879 		VERIFY0(zap_add_int(dp->dp_meta_objset,
2880 		    dsl_dir_phys(dd)->dd_clones, origin_head->ds_object, tx));
2881 	}
2882 
2883 	/* move snapshots to this dir */
2884 	for (snap = list_head(&ddpa->shared_snaps); snap;
2885 	    snap = list_next(&ddpa->shared_snaps, snap)) {
2886 		dsl_dataset_t *ds = snap->ds;
2887 
2888 		/*
2889 		 * Property callbacks are registered to a particular
2890 		 * dsl_dir.  Since ours is changing, evict the objset
2891 		 * so that they will be unregistered from the old dsl_dir.
2892 		 */
2893 		if (ds->ds_objset) {
2894 			dmu_objset_evict(ds->ds_objset);
2895 			ds->ds_objset = NULL;
2896 		}
2897 
2898 		/* move snap name entry */
2899 		VERIFY0(dsl_dataset_get_snapname(ds));
2900 		VERIFY0(dsl_dataset_snap_remove(origin_head,
2901 		    ds->ds_snapname, tx, B_TRUE));
2902 		VERIFY0(zap_add(dp->dp_meta_objset,
2903 		    dsl_dataset_phys(hds)->ds_snapnames_zapobj, ds->ds_snapname,
2904 		    8, 1, &ds->ds_object, tx));
2905 		dsl_fs_ss_count_adjust(hds->ds_dir, 1,
2906 		    DD_FIELD_SNAPSHOT_COUNT, tx);
2907 
2908 		/* change containing dsl_dir */
2909 		dmu_buf_will_dirty(ds->ds_dbuf, tx);
2910 		ASSERT3U(dsl_dataset_phys(ds)->ds_dir_obj, ==, odd->dd_object);
2911 		dsl_dataset_phys(ds)->ds_dir_obj = dd->dd_object;
2912 		ASSERT3P(ds->ds_dir, ==, odd);
2913 		dsl_dir_rele(ds->ds_dir, ds);
2914 		VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,
2915 		    NULL, ds, &ds->ds_dir));
2916 
2917 		/* move any clone references */
2918 		if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
2919 		    spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
2920 			zap_cursor_t zc;
2921 			zap_attribute_t za;
2922 
2923 			for (zap_cursor_init(&zc, dp->dp_meta_objset,
2924 			    dsl_dataset_phys(ds)->ds_next_clones_obj);
2925 			    zap_cursor_retrieve(&zc, &za) == 0;
2926 			    zap_cursor_advance(&zc)) {
2927 				dsl_dataset_t *cnds;
2928 				uint64_t o;
2929 
2930 				if (za.za_first_integer == oldnext_obj) {
2931 					/*
2932 					 * We've already moved the
2933 					 * origin's reference.
2934 					 */
2935 					continue;
2936 				}
2937 
2938 				VERIFY0(dsl_dataset_hold_obj(dp,
2939 				    za.za_first_integer, FTAG, &cnds));
2940 				o = dsl_dir_phys(cnds->ds_dir)->
2941 				    dd_head_dataset_obj;
2942 
2943 				VERIFY0(zap_remove_int(dp->dp_meta_objset,
2944 				    dsl_dir_phys(odd)->dd_clones, o, tx));
2945 				VERIFY0(zap_add_int(dp->dp_meta_objset,
2946 				    dsl_dir_phys(dd)->dd_clones, o, tx));
2947 				dsl_dataset_rele(cnds, FTAG);
2948 			}
2949 			zap_cursor_fini(&zc);
2950 		}
2951 
2952 		ASSERT(!dsl_prop_hascb(ds));
2953 	}
2954 
2955 	/*
2956 	 * Change space accounting.
2957 	 * Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either
2958 	 * both be valid, or both be 0 (resulting in delta == 0).  This
2959 	 * is true for each of {clone,origin} independently.
2960 	 */
2961 
2962 	delta = ddpa->cloneusedsnap -
2963 	    dsl_dir_phys(dd)->dd_used_breakdown[DD_USED_SNAP];
2964 	ASSERT3S(delta, >=, 0);
2965 	ASSERT3U(ddpa->used, >=, delta);
2966 	dsl_dir_diduse_space(dd, DD_USED_SNAP, delta, 0, 0, tx);
2967 	dsl_dir_diduse_space(dd, DD_USED_HEAD,
2968 	    ddpa->used - delta, ddpa->comp, ddpa->uncomp, tx);
2969 
2970 	delta = ddpa->originusedsnap -
2971 	    dsl_dir_phys(odd)->dd_used_breakdown[DD_USED_SNAP];
2972 	ASSERT3S(delta, <=, 0);
2973 	ASSERT3U(ddpa->used, >=, -delta);
2974 	dsl_dir_diduse_space(odd, DD_USED_SNAP, delta, 0, 0, tx);
2975 	dsl_dir_diduse_space(odd, DD_USED_HEAD,
2976 	    -ddpa->used - delta, -ddpa->comp, -ddpa->uncomp, tx);
2977 
2978 	dsl_dataset_phys(origin_ds)->ds_unique_bytes = ddpa->unique;
2979 
2980 	/* log history record */
2981 	spa_history_log_internal_ds(hds, "promote", tx, "");
2982 
2983 	dsl_dir_rele(odd, FTAG);
2984 	promote_rele(ddpa, FTAG);
2985 }
2986 
2987 /*
2988  * Make a list of dsl_dataset_t's for the snapshots between first_obj
2989  * (exclusive) and last_obj (inclusive).  The list will be in reverse
2990  * order (last_obj will be the list_head()).  If first_obj == 0, do all
2991  * snapshots back to this dataset's origin.
2992  */
2993 static int
2994 snaplist_make(dsl_pool_t *dp,
2995     uint64_t first_obj, uint64_t last_obj, list_t *l, void *tag)
2996 {
2997 	uint64_t obj = last_obj;
2998 
2999 	list_create(l, sizeof (struct promotenode),
3000 	    offsetof(struct promotenode, link));
3001 
3002 	while (obj != first_obj) {
3003 		dsl_dataset_t *ds;
3004 		struct promotenode *snap;
3005 		int err;
3006 
3007 		err = dsl_dataset_hold_obj(dp, obj, tag, &ds);
3008 		ASSERT(err != ENOENT);
3009 		if (err != 0)
3010 			return (err);
3011 
3012 		if (first_obj == 0)
3013 			first_obj = dsl_dir_phys(ds->ds_dir)->dd_origin_obj;
3014 
3015 		snap = kmem_alloc(sizeof (*snap), KM_SLEEP);
3016 		snap->ds = ds;
3017 		list_insert_tail(l, snap);
3018 		obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
3019 	}
3020 
3021 	return (0);
3022 }
3023 
3024 static int
3025 snaplist_space(list_t *l, uint64_t mintxg, uint64_t *spacep)
3026 {
3027 	struct promotenode *snap;
3028 
3029 	*spacep = 0;
3030 	for (snap = list_head(l); snap; snap = list_next(l, snap)) {
3031 		uint64_t used, comp, uncomp;
3032 		dsl_deadlist_space_range(&snap->ds->ds_deadlist,
3033 		    mintxg, UINT64_MAX, &used, &comp, &uncomp);
3034 		*spacep += used;
3035 	}
3036 	return (0);
3037 }
3038 
3039 static void
3040 snaplist_destroy(list_t *l, void *tag)
3041 {
3042 	struct promotenode *snap;
3043 
3044 	if (l == NULL || !list_link_active(&l->list_head))
3045 		return;
3046 
3047 	while ((snap = list_tail(l)) != NULL) {
3048 		list_remove(l, snap);
3049 		dsl_dataset_rele(snap->ds, tag);
3050 		kmem_free(snap, sizeof (*snap));
3051 	}
3052 	list_destroy(l);
3053 }
3054 
3055 static int
3056 promote_hold(dsl_dataset_promote_arg_t *ddpa, dsl_pool_t *dp, void *tag)
3057 {
3058 	int error;
3059 	dsl_dir_t *dd;
3060 	struct promotenode *snap;
3061 
3062 	error = dsl_dataset_hold(dp, ddpa->ddpa_clonename, tag,
3063 	    &ddpa->ddpa_clone);
3064 	if (error != 0)
3065 		return (error);
3066 	dd = ddpa->ddpa_clone->ds_dir;
3067 
3068 	if (ddpa->ddpa_clone->ds_is_snapshot ||
3069 	    !dsl_dir_is_clone(dd)) {
3070 		dsl_dataset_rele(ddpa->ddpa_clone, tag);
3071 		return (SET_ERROR(EINVAL));
3072 	}
3073 
3074 	error = snaplist_make(dp, 0, dsl_dir_phys(dd)->dd_origin_obj,
3075 	    &ddpa->shared_snaps, tag);
3076 	if (error != 0)
3077 		goto out;
3078 
3079 	error = snaplist_make(dp, 0, ddpa->ddpa_clone->ds_object,
3080 	    &ddpa->clone_snaps, tag);
3081 	if (error != 0)
3082 		goto out;
3083 
3084 	snap = list_head(&ddpa->shared_snaps);
3085 	ASSERT3U(snap->ds->ds_object, ==, dsl_dir_phys(dd)->dd_origin_obj);
3086 	error = snaplist_make(dp, dsl_dir_phys(dd)->dd_origin_obj,
3087 	    dsl_dir_phys(snap->ds->ds_dir)->dd_head_dataset_obj,
3088 	    &ddpa->origin_snaps, tag);
3089 	if (error != 0)
3090 		goto out;
3091 
3092 	if (dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj != 0) {
3093 		error = dsl_dataset_hold_obj(dp,
3094 		    dsl_dir_phys(snap->ds->ds_dir)->dd_origin_obj,
3095 		    tag, &ddpa->origin_origin);
3096 		if (error != 0)
3097 			goto out;
3098 	}
3099 out:
3100 	if (error != 0)
3101 		promote_rele(ddpa, tag);
3102 	return (error);
3103 }
3104 
3105 static void
3106 promote_rele(dsl_dataset_promote_arg_t *ddpa, void *tag)
3107 {
3108 	snaplist_destroy(&ddpa->shared_snaps, tag);
3109 	snaplist_destroy(&ddpa->clone_snaps, tag);
3110 	snaplist_destroy(&ddpa->origin_snaps, tag);
3111 	if (ddpa->origin_origin != NULL)
3112 		dsl_dataset_rele(ddpa->origin_origin, tag);
3113 	dsl_dataset_rele(ddpa->ddpa_clone, tag);
3114 }
3115 
3116 /*
3117  * Promote a clone.
3118  *
3119  * If it fails due to a conflicting snapshot name, "conflsnap" will be filled
3120  * in with the name.  (It must be at least ZFS_MAX_DATASET_NAME_LEN bytes long.)
3121  */
3122 int
3123 dsl_dataset_promote(const char *name, char *conflsnap)
3124 {
3125 	dsl_dataset_promote_arg_t ddpa = { 0 };
3126 	uint64_t numsnaps;
3127 	int error;
3128 	nvpair_t *snap_pair;
3129 	objset_t *os;
3130 
3131 	/*
3132 	 * We will modify space proportional to the number of
3133 	 * snapshots.  Compute numsnaps.
3134 	 */
3135 	error = dmu_objset_hold(name, FTAG, &os);
3136 	if (error != 0)
3137 		return (error);
3138 	error = zap_count(dmu_objset_pool(os)->dp_meta_objset,
3139 	    dsl_dataset_phys(dmu_objset_ds(os))->ds_snapnames_zapobj,
3140 	    &numsnaps);
3141 	dmu_objset_rele(os, FTAG);
3142 	if (error != 0)
3143 		return (error);
3144 
3145 	ddpa.ddpa_clonename = name;
3146 	ddpa.err_ds = fnvlist_alloc();
3147 	ddpa.cr = CRED();
3148 
3149 	error = dsl_sync_task(name, dsl_dataset_promote_check,
3150 	    dsl_dataset_promote_sync, &ddpa,
3151 	    2 + numsnaps, ZFS_SPACE_CHECK_RESERVED);
3152 
3153 	/*
3154 	 * Return the first conflicting snapshot found.
3155 	 */
3156 	snap_pair = nvlist_next_nvpair(ddpa.err_ds, NULL);
3157 	if (snap_pair != NULL && conflsnap != NULL)
3158 		(void) strcpy(conflsnap, nvpair_name(snap_pair));
3159 
3160 	fnvlist_free(ddpa.err_ds);
3161 	return (error);
3162 }
3163 
3164 int
3165 dsl_dataset_clone_swap_check_impl(dsl_dataset_t *clone,
3166     dsl_dataset_t *origin_head, boolean_t force, void *owner, dmu_tx_t *tx)
3167 {
3168 	/*
3169 	 * "slack" factor for received datasets with refquota set on them.
3170 	 * See the bottom of this function for details on its use.
3171 	 */
3172 	uint64_t refquota_slack = DMU_MAX_ACCESS * spa_asize_inflation;
3173 	int64_t unused_refres_delta;
3174 
3175 	/* they should both be heads */
3176 	if (clone->ds_is_snapshot ||
3177 	    origin_head->ds_is_snapshot)
3178 		return (SET_ERROR(EINVAL));
3179 
3180 	/* if we are not forcing, the branch point should be just before them */
3181 	if (!force && clone->ds_prev != origin_head->ds_prev)
3182 		return (SET_ERROR(EINVAL));
3183 
3184 	/* clone should be the clone (unless they are unrelated) */
3185 	if (clone->ds_prev != NULL &&
3186 	    clone->ds_prev != clone->ds_dir->dd_pool->dp_origin_snap &&
3187 	    origin_head->ds_dir != clone->ds_prev->ds_dir)
3188 		return (SET_ERROR(EINVAL));
3189 
3190 	/* the clone should be a child of the origin */
3191 	if (clone->ds_dir->dd_parent != origin_head->ds_dir)
3192 		return (SET_ERROR(EINVAL));
3193 
3194 	/* origin_head shouldn't be modified unless 'force' */
3195 	if (!force &&
3196 	    dsl_dataset_modified_since_snap(origin_head, origin_head->ds_prev))
3197 		return (SET_ERROR(ETXTBSY));
3198 
3199 	/* origin_head should have no long holds (e.g. is not mounted) */
3200 	if (dsl_dataset_handoff_check(origin_head, owner, tx))
3201 		return (SET_ERROR(EBUSY));
3202 
3203 	/* check amount of any unconsumed refreservation */
3204 	unused_refres_delta =
3205 	    (int64_t)MIN(origin_head->ds_reserved,
3206 	    dsl_dataset_phys(origin_head)->ds_unique_bytes) -
3207 	    (int64_t)MIN(origin_head->ds_reserved,
3208 	    dsl_dataset_phys(clone)->ds_unique_bytes);
3209 
3210 	if (unused_refres_delta > 0 &&
3211 	    unused_refres_delta >
3212 	    dsl_dir_space_available(origin_head->ds_dir, NULL, 0, TRUE))
3213 		return (SET_ERROR(ENOSPC));
3214 
3215 	/*
3216 	 * The clone can't be too much over the head's refquota.
3217 	 *
3218 	 * To ensure that the entire refquota can be used, we allow one
3219 	 * transaction to exceed the the refquota.  Therefore, this check
3220 	 * needs to also allow for the space referenced to be more than the
3221 	 * refquota.  The maximum amount of space that one transaction can use
3222 	 * on disk is DMU_MAX_ACCESS * spa_asize_inflation.  Allowing this
3223 	 * overage ensures that we are able to receive a filesystem that
3224 	 * exceeds the refquota on the source system.
3225 	 *
3226 	 * So that overage is the refquota_slack we use below.
3227 	 */
3228 	if (origin_head->ds_quota != 0 &&
3229 	    dsl_dataset_phys(clone)->ds_referenced_bytes >
3230 	    origin_head->ds_quota + refquota_slack)
3231 		return (SET_ERROR(EDQUOT));
3232 
3233 	return (0);
3234 }
3235 
3236 void
3237 dsl_dataset_clone_swap_sync_impl(dsl_dataset_t *clone,
3238     dsl_dataset_t *origin_head, dmu_tx_t *tx)
3239 {
3240 	dsl_pool_t *dp = dmu_tx_pool(tx);
3241 	int64_t unused_refres_delta;
3242 
3243 	ASSERT(clone->ds_reserved == 0);
3244 	/*
3245 	 * NOTE: On DEBUG kernels there could be a race between this and
3246 	 * the check function if spa_asize_inflation is adjusted...
3247 	 */
3248 	ASSERT(origin_head->ds_quota == 0 ||
3249 	    dsl_dataset_phys(clone)->ds_unique_bytes <= origin_head->ds_quota +
3250 	    DMU_MAX_ACCESS * spa_asize_inflation);
3251 	ASSERT3P(clone->ds_prev, ==, origin_head->ds_prev);
3252 
3253 	/*
3254 	 * Swap per-dataset feature flags.
3255 	 */
3256 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
3257 		if (!(spa_feature_table[f].fi_flags &
3258 		    ZFEATURE_FLAG_PER_DATASET)) {
3259 			ASSERT(!clone->ds_feature_inuse[f]);
3260 			ASSERT(!origin_head->ds_feature_inuse[f]);
3261 			continue;
3262 		}
3263 
3264 		boolean_t clone_inuse = clone->ds_feature_inuse[f];
3265 		boolean_t origin_head_inuse = origin_head->ds_feature_inuse[f];
3266 
3267 		if (clone_inuse) {
3268 			dsl_dataset_deactivate_feature(clone->ds_object, f, tx);
3269 			clone->ds_feature_inuse[f] = B_FALSE;
3270 		}
3271 		if (origin_head_inuse) {
3272 			dsl_dataset_deactivate_feature(origin_head->ds_object,
3273 			    f, tx);
3274 			origin_head->ds_feature_inuse[f] = B_FALSE;
3275 		}
3276 		if (clone_inuse) {
3277 			dsl_dataset_activate_feature(origin_head->ds_object,
3278 			    f, tx);
3279 			origin_head->ds_feature_inuse[f] = B_TRUE;
3280 		}
3281 		if (origin_head_inuse) {
3282 			dsl_dataset_activate_feature(clone->ds_object, f, tx);
3283 			clone->ds_feature_inuse[f] = B_TRUE;
3284 		}
3285 	}
3286 
3287 	dmu_buf_will_dirty(clone->ds_dbuf, tx);
3288 	dmu_buf_will_dirty(origin_head->ds_dbuf, tx);
3289 
3290 	if (clone->ds_objset != NULL) {
3291 		dmu_objset_evict(clone->ds_objset);
3292 		clone->ds_objset = NULL;
3293 	}
3294 
3295 	if (origin_head->ds_objset != NULL) {
3296 		dmu_objset_evict(origin_head->ds_objset);
3297 		origin_head->ds_objset = NULL;
3298 	}
3299 
3300 	unused_refres_delta =
3301 	    (int64_t)MIN(origin_head->ds_reserved,
3302 	    dsl_dataset_phys(origin_head)->ds_unique_bytes) -
3303 	    (int64_t)MIN(origin_head->ds_reserved,
3304 	    dsl_dataset_phys(clone)->ds_unique_bytes);
3305 
3306 	/*
3307 	 * Reset origin's unique bytes, if it exists.
3308 	 */
3309 	if (clone->ds_prev) {
3310 		dsl_dataset_t *origin = clone->ds_prev;
3311 		uint64_t comp, uncomp;
3312 
3313 		dmu_buf_will_dirty(origin->ds_dbuf, tx);
3314 		dsl_deadlist_space_range(&clone->ds_deadlist,
3315 		    dsl_dataset_phys(origin)->ds_prev_snap_txg, UINT64_MAX,
3316 		    &dsl_dataset_phys(origin)->ds_unique_bytes, &comp, &uncomp);
3317 	}
3318 
3319 	/* swap blkptrs */
3320 	{
3321 		rrw_enter(&clone->ds_bp_rwlock, RW_WRITER, FTAG);
3322 		rrw_enter(&origin_head->ds_bp_rwlock, RW_WRITER, FTAG);
3323 		blkptr_t tmp;
3324 		tmp = dsl_dataset_phys(origin_head)->ds_bp;
3325 		dsl_dataset_phys(origin_head)->ds_bp =
3326 		    dsl_dataset_phys(clone)->ds_bp;
3327 		dsl_dataset_phys(clone)->ds_bp = tmp;
3328 		rrw_exit(&origin_head->ds_bp_rwlock, FTAG);
3329 		rrw_exit(&clone->ds_bp_rwlock, FTAG);
3330 	}
3331 
3332 	/* set dd_*_bytes */
3333 	{
3334 		int64_t dused, dcomp, duncomp;
3335 		uint64_t cdl_used, cdl_comp, cdl_uncomp;
3336 		uint64_t odl_used, odl_comp, odl_uncomp;
3337 
3338 		ASSERT3U(dsl_dir_phys(clone->ds_dir)->
3339 		    dd_used_breakdown[DD_USED_SNAP], ==, 0);
3340 
3341 		dsl_deadlist_space(&clone->ds_deadlist,
3342 		    &cdl_used, &cdl_comp, &cdl_uncomp);
3343 		dsl_deadlist_space(&origin_head->ds_deadlist,
3344 		    &odl_used, &odl_comp, &odl_uncomp);
3345 
3346 		dused = dsl_dataset_phys(clone)->ds_referenced_bytes +
3347 		    cdl_used -
3348 		    (dsl_dataset_phys(origin_head)->ds_referenced_bytes +
3349 		    odl_used);
3350 		dcomp = dsl_dataset_phys(clone)->ds_compressed_bytes +
3351 		    cdl_comp -
3352 		    (dsl_dataset_phys(origin_head)->ds_compressed_bytes +
3353 		    odl_comp);
3354 		duncomp = dsl_dataset_phys(clone)->ds_uncompressed_bytes +
3355 		    cdl_uncomp -
3356 		    (dsl_dataset_phys(origin_head)->ds_uncompressed_bytes +
3357 		    odl_uncomp);
3358 
3359 		dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_HEAD,
3360 		    dused, dcomp, duncomp, tx);
3361 		dsl_dir_diduse_space(clone->ds_dir, DD_USED_HEAD,
3362 		    -dused, -dcomp, -duncomp, tx);
3363 
3364 		/*
3365 		 * The difference in the space used by snapshots is the
3366 		 * difference in snapshot space due to the head's
3367 		 * deadlist (since that's the only thing that's
3368 		 * changing that affects the snapused).
3369 		 */
3370 		dsl_deadlist_space_range(&clone->ds_deadlist,
3371 		    origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
3372 		    &cdl_used, &cdl_comp, &cdl_uncomp);
3373 		dsl_deadlist_space_range(&origin_head->ds_deadlist,
3374 		    origin_head->ds_dir->dd_origin_txg, UINT64_MAX,
3375 		    &odl_used, &odl_comp, &odl_uncomp);
3376 		dsl_dir_transfer_space(origin_head->ds_dir, cdl_used - odl_used,
3377 		    DD_USED_HEAD, DD_USED_SNAP, tx);
3378 	}
3379 
3380 	/* swap ds_*_bytes */
3381 	SWITCH64(dsl_dataset_phys(origin_head)->ds_referenced_bytes,
3382 	    dsl_dataset_phys(clone)->ds_referenced_bytes);
3383 	SWITCH64(dsl_dataset_phys(origin_head)->ds_compressed_bytes,
3384 	    dsl_dataset_phys(clone)->ds_compressed_bytes);
3385 	SWITCH64(dsl_dataset_phys(origin_head)->ds_uncompressed_bytes,
3386 	    dsl_dataset_phys(clone)->ds_uncompressed_bytes);
3387 	SWITCH64(dsl_dataset_phys(origin_head)->ds_unique_bytes,
3388 	    dsl_dataset_phys(clone)->ds_unique_bytes);
3389 
3390 	/* apply any parent delta for change in unconsumed refreservation */
3391 	dsl_dir_diduse_space(origin_head->ds_dir, DD_USED_REFRSRV,
3392 	    unused_refres_delta, 0, 0, tx);
3393 
3394 	/*
3395 	 * Swap deadlists.
3396 	 */
3397 	dsl_deadlist_close(&clone->ds_deadlist);
3398 	dsl_deadlist_close(&origin_head->ds_deadlist);
3399 	SWITCH64(dsl_dataset_phys(origin_head)->ds_deadlist_obj,
3400 	    dsl_dataset_phys(clone)->ds_deadlist_obj);
3401 	dsl_deadlist_open(&clone->ds_deadlist, dp->dp_meta_objset,
3402 	    dsl_dataset_phys(clone)->ds_deadlist_obj);
3403 	dsl_deadlist_open(&origin_head->ds_deadlist, dp->dp_meta_objset,
3404 	    dsl_dataset_phys(origin_head)->ds_deadlist_obj);
3405 
3406 	dsl_scan_ds_clone_swapped(origin_head, clone, tx);
3407 
3408 	spa_history_log_internal_ds(clone, "clone swap", tx,
3409 	    "parent=%s", origin_head->ds_dir->dd_myname);
3410 }
3411 
3412 /*
3413  * Given a pool name and a dataset object number in that pool,
3414  * return the name of that dataset.
3415  */
3416 int
3417 dsl_dsobj_to_dsname(char *pname, uint64_t obj, char *buf)
3418 {
3419 	dsl_pool_t *dp;
3420 	dsl_dataset_t *ds;
3421 	int error;
3422 
3423 	error = dsl_pool_hold(pname, FTAG, &dp);
3424 	if (error != 0)
3425 		return (error);
3426 
3427 	error = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
3428 	if (error == 0) {
3429 		dsl_dataset_name(ds, buf);
3430 		dsl_dataset_rele(ds, FTAG);
3431 	}
3432 	dsl_pool_rele(dp, FTAG);
3433 
3434 	return (error);
3435 }
3436 
3437 int
3438 dsl_dataset_check_quota(dsl_dataset_t *ds, boolean_t check_quota,
3439     uint64_t asize, uint64_t inflight, uint64_t *used, uint64_t *ref_rsrv)
3440 {
3441 	int error = 0;
3442 
3443 	ASSERT3S(asize, >, 0);
3444 
3445 	/*
3446 	 * *ref_rsrv is the portion of asize that will come from any
3447 	 * unconsumed refreservation space.
3448 	 */
3449 	*ref_rsrv = 0;
3450 
3451 	mutex_enter(&ds->ds_lock);
3452 	/*
3453 	 * Make a space adjustment for reserved bytes.
3454 	 */
3455 	if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
3456 		ASSERT3U(*used, >=,
3457 		    ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
3458 		*used -=
3459 		    (ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes);
3460 		*ref_rsrv =
3461 		    asize - MIN(asize, parent_delta(ds, asize + inflight));
3462 	}
3463 
3464 	if (!check_quota || ds->ds_quota == 0) {
3465 		mutex_exit(&ds->ds_lock);
3466 		return (0);
3467 	}
3468 	/*
3469 	 * If they are requesting more space, and our current estimate
3470 	 * is over quota, they get to try again unless the actual
3471 	 * on-disk is over quota and there are no pending changes (which
3472 	 * may free up space for us).
3473 	 */
3474 	if (dsl_dataset_phys(ds)->ds_referenced_bytes + inflight >=
3475 	    ds->ds_quota) {
3476 		if (inflight > 0 ||
3477 		    dsl_dataset_phys(ds)->ds_referenced_bytes < ds->ds_quota)
3478 			error = SET_ERROR(ERESTART);
3479 		else
3480 			error = SET_ERROR(EDQUOT);
3481 	}
3482 	mutex_exit(&ds->ds_lock);
3483 
3484 	return (error);
3485 }
3486 
3487 typedef struct dsl_dataset_set_qr_arg {
3488 	const char *ddsqra_name;
3489 	zprop_source_t ddsqra_source;
3490 	uint64_t ddsqra_value;
3491 } dsl_dataset_set_qr_arg_t;
3492 
3493 
3494 /* ARGSUSED */
3495 static int
3496 dsl_dataset_set_refquota_check(void *arg, dmu_tx_t *tx)
3497 {
3498 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
3499 	dsl_pool_t *dp = dmu_tx_pool(tx);
3500 	dsl_dataset_t *ds;
3501 	int error;
3502 	uint64_t newval;
3503 
3504 	if (spa_version(dp->dp_spa) < SPA_VERSION_REFQUOTA)
3505 		return (SET_ERROR(ENOTSUP));
3506 
3507 	error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
3508 	if (error != 0)
3509 		return (error);
3510 
3511 	if (ds->ds_is_snapshot) {
3512 		dsl_dataset_rele(ds, FTAG);
3513 		return (SET_ERROR(EINVAL));
3514 	}
3515 
3516 	error = dsl_prop_predict(ds->ds_dir,
3517 	    zfs_prop_to_name(ZFS_PROP_REFQUOTA),
3518 	    ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
3519 	if (error != 0) {
3520 		dsl_dataset_rele(ds, FTAG);
3521 		return (error);
3522 	}
3523 
3524 	if (newval == 0) {
3525 		dsl_dataset_rele(ds, FTAG);
3526 		return (0);
3527 	}
3528 
3529 	if (newval < dsl_dataset_phys(ds)->ds_referenced_bytes ||
3530 	    newval < ds->ds_reserved) {
3531 		dsl_dataset_rele(ds, FTAG);
3532 		return (SET_ERROR(ENOSPC));
3533 	}
3534 
3535 	dsl_dataset_rele(ds, FTAG);
3536 	return (0);
3537 }
3538 
3539 static void
3540 dsl_dataset_set_refquota_sync(void *arg, dmu_tx_t *tx)
3541 {
3542 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
3543 	dsl_pool_t *dp = dmu_tx_pool(tx);
3544 	dsl_dataset_t *ds;
3545 	uint64_t newval;
3546 
3547 	VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
3548 
3549 	dsl_prop_set_sync_impl(ds,
3550 	    zfs_prop_to_name(ZFS_PROP_REFQUOTA),
3551 	    ddsqra->ddsqra_source, sizeof (ddsqra->ddsqra_value), 1,
3552 	    &ddsqra->ddsqra_value, tx);
3553 
3554 	VERIFY0(dsl_prop_get_int_ds(ds,
3555 	    zfs_prop_to_name(ZFS_PROP_REFQUOTA), &newval));
3556 
3557 	if (ds->ds_quota != newval) {
3558 		dmu_buf_will_dirty(ds->ds_dbuf, tx);
3559 		ds->ds_quota = newval;
3560 	}
3561 	dsl_dataset_rele(ds, FTAG);
3562 }
3563 
3564 int
3565 dsl_dataset_set_refquota(const char *dsname, zprop_source_t source,
3566     uint64_t refquota)
3567 {
3568 	dsl_dataset_set_qr_arg_t ddsqra;
3569 
3570 	ddsqra.ddsqra_name = dsname;
3571 	ddsqra.ddsqra_source = source;
3572 	ddsqra.ddsqra_value = refquota;
3573 
3574 	return (dsl_sync_task(dsname, dsl_dataset_set_refquota_check,
3575 	    dsl_dataset_set_refquota_sync, &ddsqra, 0, ZFS_SPACE_CHECK_NONE));
3576 }
3577 
3578 static int
3579 dsl_dataset_set_refreservation_check(void *arg, dmu_tx_t *tx)
3580 {
3581 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
3582 	dsl_pool_t *dp = dmu_tx_pool(tx);
3583 	dsl_dataset_t *ds;
3584 	int error;
3585 	uint64_t newval, unique;
3586 
3587 	if (spa_version(dp->dp_spa) < SPA_VERSION_REFRESERVATION)
3588 		return (SET_ERROR(ENOTSUP));
3589 
3590 	error = dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds);
3591 	if (error != 0)
3592 		return (error);
3593 
3594 	if (ds->ds_is_snapshot) {
3595 		dsl_dataset_rele(ds, FTAG);
3596 		return (SET_ERROR(EINVAL));
3597 	}
3598 
3599 	error = dsl_prop_predict(ds->ds_dir,
3600 	    zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
3601 	    ddsqra->ddsqra_source, ddsqra->ddsqra_value, &newval);
3602 	if (error != 0) {
3603 		dsl_dataset_rele(ds, FTAG);
3604 		return (error);
3605 	}
3606 
3607 	/*
3608 	 * If we are doing the preliminary check in open context, the
3609 	 * space estimates may be inaccurate.
3610 	 */
3611 	if (!dmu_tx_is_syncing(tx)) {
3612 		dsl_dataset_rele(ds, FTAG);
3613 		return (0);
3614 	}
3615 
3616 	mutex_enter(&ds->ds_lock);
3617 	if (!DS_UNIQUE_IS_ACCURATE(ds))
3618 		dsl_dataset_recalc_head_uniq(ds);
3619 	unique = dsl_dataset_phys(ds)->ds_unique_bytes;
3620 	mutex_exit(&ds->ds_lock);
3621 
3622 	if (MAX(unique, newval) > MAX(unique, ds->ds_reserved)) {
3623 		uint64_t delta = MAX(unique, newval) -
3624 		    MAX(unique, ds->ds_reserved);
3625 
3626 		if (delta >
3627 		    dsl_dir_space_available(ds->ds_dir, NULL, 0, B_TRUE) ||
3628 		    (ds->ds_quota > 0 && newval > ds->ds_quota)) {
3629 			dsl_dataset_rele(ds, FTAG);
3630 			return (SET_ERROR(ENOSPC));
3631 		}
3632 	}
3633 
3634 	dsl_dataset_rele(ds, FTAG);
3635 	return (0);
3636 }
3637 
3638 void
3639 dsl_dataset_set_refreservation_sync_impl(dsl_dataset_t *ds,
3640     zprop_source_t source, uint64_t value, dmu_tx_t *tx)
3641 {
3642 	uint64_t newval;
3643 	uint64_t unique;
3644 	int64_t delta;
3645 
3646 	dsl_prop_set_sync_impl(ds, zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
3647 	    source, sizeof (value), 1, &value, tx);
3648 
3649 	VERIFY0(dsl_prop_get_int_ds(ds,
3650 	    zfs_prop_to_name(ZFS_PROP_REFRESERVATION), &newval));
3651 
3652 	dmu_buf_will_dirty(ds->ds_dbuf, tx);
3653 	mutex_enter(&ds->ds_dir->dd_lock);
3654 	mutex_enter(&ds->ds_lock);
3655 	ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
3656 	unique = dsl_dataset_phys(ds)->ds_unique_bytes;
3657 	delta = MAX(0, (int64_t)(newval - unique)) -
3658 	    MAX(0, (int64_t)(ds->ds_reserved - unique));
3659 	ds->ds_reserved = newval;
3660 	mutex_exit(&ds->ds_lock);
3661 
3662 	dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV, delta, 0, 0, tx);
3663 	mutex_exit(&ds->ds_dir->dd_lock);
3664 }
3665 
3666 static void
3667 dsl_dataset_set_refreservation_sync(void *arg, dmu_tx_t *tx)
3668 {
3669 	dsl_dataset_set_qr_arg_t *ddsqra = arg;
3670 	dsl_pool_t *dp = dmu_tx_pool(tx);
3671 	dsl_dataset_t *ds;
3672 
3673 	VERIFY0(dsl_dataset_hold(dp, ddsqra->ddsqra_name, FTAG, &ds));
3674 	dsl_dataset_set_refreservation_sync_impl(ds,
3675 	    ddsqra->ddsqra_source, ddsqra->ddsqra_value, tx);
3676 	dsl_dataset_rele(ds, FTAG);
3677 }
3678 
3679 int
3680 dsl_dataset_set_refreservation(const char *dsname, zprop_source_t source,
3681     uint64_t refreservation)
3682 {
3683 	dsl_dataset_set_qr_arg_t ddsqra;
3684 
3685 	ddsqra.ddsqra_name = dsname;
3686 	ddsqra.ddsqra_source = source;
3687 	ddsqra.ddsqra_value = refreservation;
3688 
3689 	return (dsl_sync_task(dsname, dsl_dataset_set_refreservation_check,
3690 	    dsl_dataset_set_refreservation_sync, &ddsqra,
3691 	    0, ZFS_SPACE_CHECK_NONE));
3692 }
3693 
3694 /*
3695  * Return (in *usedp) the amount of space written in new that is not
3696  * present in oldsnap.  New may be a snapshot or the head.  Old must be
3697  * a snapshot before new, in new's filesystem (or its origin).  If not then
3698  * fail and return EINVAL.
3699  *
3700  * The written space is calculated by considering two components:  First, we
3701  * ignore any freed space, and calculate the written as new's used space
3702  * minus old's used space.  Next, we add in the amount of space that was freed
3703  * between the two snapshots, thus reducing new's used space relative to old's.
3704  * Specifically, this is the space that was born before old->ds_creation_txg,
3705  * and freed before new (ie. on new's deadlist or a previous deadlist).
3706  *
3707  * space freed                         [---------------------]
3708  * snapshots                       ---O-------O--------O-------O------
3709  *                                         oldsnap            new
3710  */
3711 int
3712 dsl_dataset_space_written(dsl_dataset_t *oldsnap, dsl_dataset_t *new,
3713     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
3714 {
3715 	int err = 0;
3716 	uint64_t snapobj;
3717 	dsl_pool_t *dp = new->ds_dir->dd_pool;
3718 
3719 	ASSERT(dsl_pool_config_held(dp));
3720 
3721 	*usedp = 0;
3722 	*usedp += dsl_dataset_phys(new)->ds_referenced_bytes;
3723 	*usedp -= dsl_dataset_phys(oldsnap)->ds_referenced_bytes;
3724 
3725 	*compp = 0;
3726 	*compp += dsl_dataset_phys(new)->ds_compressed_bytes;
3727 	*compp -= dsl_dataset_phys(oldsnap)->ds_compressed_bytes;
3728 
3729 	*uncompp = 0;
3730 	*uncompp += dsl_dataset_phys(new)->ds_uncompressed_bytes;
3731 	*uncompp -= dsl_dataset_phys(oldsnap)->ds_uncompressed_bytes;
3732 
3733 	snapobj = new->ds_object;
3734 	while (snapobj != oldsnap->ds_object) {
3735 		dsl_dataset_t *snap;
3736 		uint64_t used, comp, uncomp;
3737 
3738 		if (snapobj == new->ds_object) {
3739 			snap = new;
3740 		} else {
3741 			err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &snap);
3742 			if (err != 0)
3743 				break;
3744 		}
3745 
3746 		if (dsl_dataset_phys(snap)->ds_prev_snap_txg ==
3747 		    dsl_dataset_phys(oldsnap)->ds_creation_txg) {
3748 			/*
3749 			 * The blocks in the deadlist can not be born after
3750 			 * ds_prev_snap_txg, so get the whole deadlist space,
3751 			 * which is more efficient (especially for old-format
3752 			 * deadlists).  Unfortunately the deadlist code
3753 			 * doesn't have enough information to make this
3754 			 * optimization itself.
3755 			 */
3756 			dsl_deadlist_space(&snap->ds_deadlist,
3757 			    &used, &comp, &uncomp);
3758 		} else {
3759 			dsl_deadlist_space_range(&snap->ds_deadlist,
3760 			    0, dsl_dataset_phys(oldsnap)->ds_creation_txg,
3761 			    &used, &comp, &uncomp);
3762 		}
3763 		*usedp += used;
3764 		*compp += comp;
3765 		*uncompp += uncomp;
3766 
3767 		/*
3768 		 * If we get to the beginning of the chain of snapshots
3769 		 * (ds_prev_snap_obj == 0) before oldsnap, then oldsnap
3770 		 * was not a snapshot of/before new.
3771 		 */
3772 		snapobj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
3773 		if (snap != new)
3774 			dsl_dataset_rele(snap, FTAG);
3775 		if (snapobj == 0) {
3776 			err = SET_ERROR(EINVAL);
3777 			break;
3778 		}
3779 
3780 	}
3781 	return (err);
3782 }
3783 
3784 /*
3785  * Return (in *usedp) the amount of space that will be reclaimed if firstsnap,
3786  * lastsnap, and all snapshots in between are deleted.
3787  *
3788  * blocks that would be freed            [---------------------------]
3789  * snapshots                       ---O-------O--------O-------O--------O
3790  *                                        firstsnap        lastsnap
3791  *
3792  * This is the set of blocks that were born after the snap before firstsnap,
3793  * (birth > firstsnap->prev_snap_txg) and died before the snap after the
3794  * last snap (ie, is on lastsnap->ds_next->ds_deadlist or an earlier deadlist).
3795  * We calculate this by iterating over the relevant deadlists (from the snap
3796  * after lastsnap, backward to the snap after firstsnap), summing up the
3797  * space on the deadlist that was born after the snap before firstsnap.
3798  */
3799 int
3800 dsl_dataset_space_wouldfree(dsl_dataset_t *firstsnap,
3801     dsl_dataset_t *lastsnap,
3802     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
3803 {
3804 	int err = 0;
3805 	uint64_t snapobj;
3806 	dsl_pool_t *dp = firstsnap->ds_dir->dd_pool;
3807 
3808 	ASSERT(firstsnap->ds_is_snapshot);
3809 	ASSERT(lastsnap->ds_is_snapshot);
3810 
3811 	/*
3812 	 * Check that the snapshots are in the same dsl_dir, and firstsnap
3813 	 * is before lastsnap.
3814 	 */
3815 	if (firstsnap->ds_dir != lastsnap->ds_dir ||
3816 	    dsl_dataset_phys(firstsnap)->ds_creation_txg >
3817 	    dsl_dataset_phys(lastsnap)->ds_creation_txg)
3818 		return (SET_ERROR(EINVAL));
3819 
3820 	*usedp = *compp = *uncompp = 0;
3821 
3822 	snapobj = dsl_dataset_phys(lastsnap)->ds_next_snap_obj;
3823 	while (snapobj != firstsnap->ds_object) {
3824 		dsl_dataset_t *ds;
3825 		uint64_t used, comp, uncomp;
3826 
3827 		err = dsl_dataset_hold_obj(dp, snapobj, FTAG, &ds);
3828 		if (err != 0)
3829 			break;
3830 
3831 		dsl_deadlist_space_range(&ds->ds_deadlist,
3832 		    dsl_dataset_phys(firstsnap)->ds_prev_snap_txg, UINT64_MAX,
3833 		    &used, &comp, &uncomp);
3834 		*usedp += used;
3835 		*compp += comp;
3836 		*uncompp += uncomp;
3837 
3838 		snapobj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
3839 		ASSERT3U(snapobj, !=, 0);
3840 		dsl_dataset_rele(ds, FTAG);
3841 	}
3842 	return (err);
3843 }
3844 
3845 /*
3846  * Return TRUE if 'earlier' is an earlier snapshot in 'later's timeline.
3847  * For example, they could both be snapshots of the same filesystem, and
3848  * 'earlier' is before 'later'.  Or 'earlier' could be the origin of
3849  * 'later's filesystem.  Or 'earlier' could be an older snapshot in the origin's
3850  * filesystem.  Or 'earlier' could be the origin's origin.
3851  *
3852  * If non-zero, earlier_txg is used instead of earlier's ds_creation_txg.
3853  */
3854 boolean_t
3855 dsl_dataset_is_before(dsl_dataset_t *later, dsl_dataset_t *earlier,
3856     uint64_t earlier_txg)
3857 {
3858 	dsl_pool_t *dp = later->ds_dir->dd_pool;
3859 	int error;
3860 	boolean_t ret;
3861 
3862 	ASSERT(dsl_pool_config_held(dp));
3863 	ASSERT(earlier->ds_is_snapshot || earlier_txg != 0);
3864 
3865 	if (earlier_txg == 0)
3866 		earlier_txg = dsl_dataset_phys(earlier)->ds_creation_txg;
3867 
3868 	if (later->ds_is_snapshot &&
3869 	    earlier_txg >= dsl_dataset_phys(later)->ds_creation_txg)
3870 		return (B_FALSE);
3871 
3872 	if (later->ds_dir == earlier->ds_dir)
3873 		return (B_TRUE);
3874 	if (!dsl_dir_is_clone(later->ds_dir))
3875 		return (B_FALSE);
3876 
3877 	if (dsl_dir_phys(later->ds_dir)->dd_origin_obj == earlier->ds_object)
3878 		return (B_TRUE);
3879 	dsl_dataset_t *origin;
3880 	error = dsl_dataset_hold_obj(dp,
3881 	    dsl_dir_phys(later->ds_dir)->dd_origin_obj, FTAG, &origin);
3882 	if (error != 0)
3883 		return (B_FALSE);
3884 	ret = dsl_dataset_is_before(origin, earlier, earlier_txg);
3885 	dsl_dataset_rele(origin, FTAG);
3886 	return (ret);
3887 }
3888 
3889 void
3890 dsl_dataset_zapify(dsl_dataset_t *ds, dmu_tx_t *tx)
3891 {
3892 	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
3893 	dmu_object_zapify(mos, ds->ds_object, DMU_OT_DSL_DATASET, tx);
3894 }
3895 
3896 boolean_t
3897 dsl_dataset_is_zapified(dsl_dataset_t *ds)
3898 {
3899 	dmu_object_info_t doi;
3900 
3901 	dmu_object_info_from_db(ds->ds_dbuf, &doi);
3902 	return (doi.doi_type == DMU_OTN_ZAP_METADATA);
3903 }
3904 
3905 boolean_t
3906 dsl_dataset_has_resume_receive_state(dsl_dataset_t *ds)
3907 {
3908 	return (dsl_dataset_is_zapified(ds) &&
3909 	    zap_contains(ds->ds_dir->dd_pool->dp_meta_objset,
3910 	    ds->ds_object, DS_FIELD_RESUME_TOGUID) == 0);
3911 }
3912