xref: /illumos-gate/usr/src/uts/common/fs/zfs/dmu_objset.c (revision a2eea2e101e6a163a537dcc6d4e3c4da2a0ea5b2)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
22ea8dc4b6Seschrock  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23fa9e4066Sahrens  * Use is subject to license terms.
24fa9e4066Sahrens  */
25fa9e4066Sahrens 
26fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
27fa9e4066Sahrens 
28fa9e4066Sahrens #include <sys/zfs_context.h>
29fa9e4066Sahrens #include <sys/dmu_objset.h>
30fa9e4066Sahrens #include <sys/dsl_dir.h>
31fa9e4066Sahrens #include <sys/dsl_dataset.h>
32fa9e4066Sahrens #include <sys/dsl_prop.h>
33fa9e4066Sahrens #include <sys/dsl_pool.h>
341d452cf5Sahrens #include <sys/dsl_synctask.h>
35fa9e4066Sahrens #include <sys/dnode.h>
36fa9e4066Sahrens #include <sys/dbuf.h>
37*a2eea2e1Sahrens #include <sys/zvol.h>
38fa9e4066Sahrens #include <sys/dmu_tx.h>
39fa9e4066Sahrens #include <sys/zio_checksum.h>
40fa9e4066Sahrens #include <sys/zap.h>
41fa9e4066Sahrens #include <sys/zil.h>
42fa9e4066Sahrens #include <sys/dmu_impl.h>
43fa9e4066Sahrens 
44fa9e4066Sahrens 
45fa9e4066Sahrens spa_t *
46fa9e4066Sahrens dmu_objset_spa(objset_t *os)
47fa9e4066Sahrens {
48fa9e4066Sahrens 	return (os->os->os_spa);
49fa9e4066Sahrens }
50fa9e4066Sahrens 
51fa9e4066Sahrens zilog_t *
52fa9e4066Sahrens dmu_objset_zil(objset_t *os)
53fa9e4066Sahrens {
54fa9e4066Sahrens 	return (os->os->os_zil);
55fa9e4066Sahrens }
56fa9e4066Sahrens 
57fa9e4066Sahrens dsl_pool_t *
58fa9e4066Sahrens dmu_objset_pool(objset_t *os)
59fa9e4066Sahrens {
60fa9e4066Sahrens 	dsl_dataset_t *ds;
61fa9e4066Sahrens 
62fa9e4066Sahrens 	if ((ds = os->os->os_dsl_dataset) != NULL && ds->ds_dir)
63fa9e4066Sahrens 		return (ds->ds_dir->dd_pool);
64fa9e4066Sahrens 	else
65fa9e4066Sahrens 		return (spa_get_dsl(os->os->os_spa));
66fa9e4066Sahrens }
67fa9e4066Sahrens 
68fa9e4066Sahrens dsl_dataset_t *
69fa9e4066Sahrens dmu_objset_ds(objset_t *os)
70fa9e4066Sahrens {
71fa9e4066Sahrens 	return (os->os->os_dsl_dataset);
72fa9e4066Sahrens }
73fa9e4066Sahrens 
74fa9e4066Sahrens dmu_objset_type_t
75fa9e4066Sahrens dmu_objset_type(objset_t *os)
76fa9e4066Sahrens {
77fa9e4066Sahrens 	return (os->os->os_phys->os_type);
78fa9e4066Sahrens }
79fa9e4066Sahrens 
80fa9e4066Sahrens void
81fa9e4066Sahrens dmu_objset_name(objset_t *os, char *buf)
82fa9e4066Sahrens {
83fa9e4066Sahrens 	dsl_dataset_name(os->os->os_dsl_dataset, buf);
84fa9e4066Sahrens }
85fa9e4066Sahrens 
86fa9e4066Sahrens uint64_t
87fa9e4066Sahrens dmu_objset_id(objset_t *os)
88fa9e4066Sahrens {
89fa9e4066Sahrens 	dsl_dataset_t *ds = os->os->os_dsl_dataset;
90fa9e4066Sahrens 
91fa9e4066Sahrens 	return (ds ? ds->ds_object : 0);
92fa9e4066Sahrens }
93fa9e4066Sahrens 
94fa9e4066Sahrens static void
95fa9e4066Sahrens checksum_changed_cb(void *arg, uint64_t newval)
96fa9e4066Sahrens {
97fa9e4066Sahrens 	objset_impl_t *osi = arg;
98fa9e4066Sahrens 
99fa9e4066Sahrens 	/*
100fa9e4066Sahrens 	 * Inheritance should have been done by now.
101fa9e4066Sahrens 	 */
102fa9e4066Sahrens 	ASSERT(newval != ZIO_CHECKSUM_INHERIT);
103fa9e4066Sahrens 
104fa9e4066Sahrens 	osi->os_checksum = zio_checksum_select(newval, ZIO_CHECKSUM_ON_VALUE);
105fa9e4066Sahrens }
106fa9e4066Sahrens 
107fa9e4066Sahrens static void
108fa9e4066Sahrens compression_changed_cb(void *arg, uint64_t newval)
109fa9e4066Sahrens {
110fa9e4066Sahrens 	objset_impl_t *osi = arg;
111fa9e4066Sahrens 
112fa9e4066Sahrens 	/*
113fa9e4066Sahrens 	 * Inheritance and range checking should have been done by now.
114fa9e4066Sahrens 	 */
115fa9e4066Sahrens 	ASSERT(newval != ZIO_COMPRESS_INHERIT);
116fa9e4066Sahrens 
117fa9e4066Sahrens 	osi->os_compress = zio_compress_select(newval, ZIO_COMPRESS_ON_VALUE);
118fa9e4066Sahrens }
119fa9e4066Sahrens 
120fa9e4066Sahrens void
121fa9e4066Sahrens dmu_objset_byteswap(void *buf, size_t size)
122fa9e4066Sahrens {
123fa9e4066Sahrens 	objset_phys_t *osp = buf;
124fa9e4066Sahrens 
125fa9e4066Sahrens 	ASSERT(size == sizeof (objset_phys_t));
126fa9e4066Sahrens 	dnode_byteswap(&osp->os_meta_dnode);
127fa9e4066Sahrens 	byteswap_uint64_array(&osp->os_zil_header, sizeof (zil_header_t));
128fa9e4066Sahrens 	osp->os_type = BSWAP_64(osp->os_type);
129fa9e4066Sahrens }
130fa9e4066Sahrens 
131ea8dc4b6Seschrock int
132ea8dc4b6Seschrock dmu_objset_open_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *bp,
133ea8dc4b6Seschrock     objset_impl_t **osip)
134fa9e4066Sahrens {
135fa9e4066Sahrens 	objset_impl_t *winner, *osi;
136fa9e4066Sahrens 	int i, err, checksum;
137fa9e4066Sahrens 
138fa9e4066Sahrens 	osi = kmem_zalloc(sizeof (objset_impl_t), KM_SLEEP);
139fa9e4066Sahrens 	osi->os.os = osi;
140fa9e4066Sahrens 	osi->os_dsl_dataset = ds;
141fa9e4066Sahrens 	osi->os_spa = spa;
142fa9e4066Sahrens 	if (bp)
143fa9e4066Sahrens 		osi->os_rootbp = *bp;
144fa9e4066Sahrens 	osi->os_phys = zio_buf_alloc(sizeof (objset_phys_t));
145fa9e4066Sahrens 	if (!BP_IS_HOLE(&osi->os_rootbp)) {
14613506d1eSmaybee 		uint32_t aflags = ARC_WAIT;
147ea8dc4b6Seschrock 		zbookmark_t zb;
148ea8dc4b6Seschrock 		zb.zb_objset = ds ? ds->ds_object : 0;
149ea8dc4b6Seschrock 		zb.zb_object = 0;
150ea8dc4b6Seschrock 		zb.zb_level = -1;
151ea8dc4b6Seschrock 		zb.zb_blkid = 0;
152ea8dc4b6Seschrock 
153fa9e4066Sahrens 		dprintf_bp(&osi->os_rootbp, "reading %s", "");
154ea8dc4b6Seschrock 		err = arc_read(NULL, spa, &osi->os_rootbp,
155fa9e4066Sahrens 		    dmu_ot[DMU_OT_OBJSET].ot_byteswap,
156fa9e4066Sahrens 		    arc_bcopy_func, osi->os_phys,
15713506d1eSmaybee 		    ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL, &aflags, &zb);
158ea8dc4b6Seschrock 		if (err) {
159ea8dc4b6Seschrock 			zio_buf_free(osi->os_phys, sizeof (objset_phys_t));
160ea8dc4b6Seschrock 			kmem_free(osi, sizeof (objset_impl_t));
161ea8dc4b6Seschrock 			return (err);
162ea8dc4b6Seschrock 		}
163fa9e4066Sahrens 	} else {
164fa9e4066Sahrens 		bzero(osi->os_phys, sizeof (objset_phys_t));
165fa9e4066Sahrens 	}
166fa9e4066Sahrens 
167fa9e4066Sahrens 	/*
168fa9e4066Sahrens 	 * Note: the changed_cb will be called once before the register
169fa9e4066Sahrens 	 * func returns, thus changing the checksum/compression from the
17099653d4eSeschrock 	 * default (fletcher2/off).  Snapshots don't need to know, and
17199653d4eSeschrock 	 * registering would complicate clone promotion.
172fa9e4066Sahrens 	 */
17399653d4eSeschrock 	if (ds && ds->ds_phys->ds_num_children == 0) {
174fa9e4066Sahrens 		err = dsl_prop_register(ds, "checksum",
175fa9e4066Sahrens 		    checksum_changed_cb, osi);
176ea8dc4b6Seschrock 		if (err == 0)
177ea8dc4b6Seschrock 			err = dsl_prop_register(ds, "compression",
178ea8dc4b6Seschrock 			    compression_changed_cb, osi);
179ea8dc4b6Seschrock 		if (err) {
180ea8dc4b6Seschrock 			zio_buf_free(osi->os_phys, sizeof (objset_phys_t));
181ea8dc4b6Seschrock 			kmem_free(osi, sizeof (objset_impl_t));
182ea8dc4b6Seschrock 			return (err);
183ea8dc4b6Seschrock 		}
18499653d4eSeschrock 	} else if (ds == NULL) {
185fa9e4066Sahrens 		/* It's the meta-objset. */
186fa9e4066Sahrens 		osi->os_checksum = ZIO_CHECKSUM_FLETCHER_4;
187ea8dc4b6Seschrock 		osi->os_compress = ZIO_COMPRESS_LZJB;
188fa9e4066Sahrens 	}
189fa9e4066Sahrens 
190ea8dc4b6Seschrock 	osi->os_zil = zil_alloc(&osi->os, &osi->os_phys->os_zil_header);
191ea8dc4b6Seschrock 
192fa9e4066Sahrens 	/*
193fa9e4066Sahrens 	 * Metadata always gets compressed and checksummed.
194fa9e4066Sahrens 	 * If the data checksum is multi-bit correctable, and it's not
195fa9e4066Sahrens 	 * a ZBT-style checksum, then it's suitable for metadata as well.
196fa9e4066Sahrens 	 * Otherwise, the metadata checksum defaults to fletcher4.
197fa9e4066Sahrens 	 */
198fa9e4066Sahrens 	checksum = osi->os_checksum;
199fa9e4066Sahrens 
200fa9e4066Sahrens 	if (zio_checksum_table[checksum].ci_correctable &&
201fa9e4066Sahrens 	    !zio_checksum_table[checksum].ci_zbt)
202fa9e4066Sahrens 		osi->os_md_checksum = checksum;
203fa9e4066Sahrens 	else
204fa9e4066Sahrens 		osi->os_md_checksum = ZIO_CHECKSUM_FLETCHER_4;
205ea8dc4b6Seschrock 	osi->os_md_compress = ZIO_COMPRESS_LZJB;
206fa9e4066Sahrens 
207fa9e4066Sahrens 	for (i = 0; i < TXG_SIZE; i++) {
208fa9e4066Sahrens 		list_create(&osi->os_dirty_dnodes[i], sizeof (dnode_t),
209fa9e4066Sahrens 		    offsetof(dnode_t, dn_dirty_link[i]));
210fa9e4066Sahrens 		list_create(&osi->os_free_dnodes[i], sizeof (dnode_t),
211fa9e4066Sahrens 		    offsetof(dnode_t, dn_dirty_link[i]));
212fa9e4066Sahrens 	}
213fa9e4066Sahrens 	list_create(&osi->os_dnodes, sizeof (dnode_t),
214fa9e4066Sahrens 	    offsetof(dnode_t, dn_link));
215fa9e4066Sahrens 	list_create(&osi->os_downgraded_dbufs, sizeof (dmu_buf_impl_t),
216fa9e4066Sahrens 	    offsetof(dmu_buf_impl_t, db_link));
217fa9e4066Sahrens 
2185ad82045Snd 	mutex_init(&osi->os_lock, NULL, MUTEX_DEFAULT, NULL);
2195ad82045Snd 	mutex_init(&osi->os_obj_lock, NULL, MUTEX_DEFAULT, NULL);
2205ad82045Snd 
221fa9e4066Sahrens 	osi->os_meta_dnode = dnode_special_open(osi,
222fa9e4066Sahrens 	    &osi->os_phys->os_meta_dnode, DMU_META_DNODE_OBJECT);
223fa9e4066Sahrens 
224fa9e4066Sahrens 	if (ds != NULL) {
225fa9e4066Sahrens 		winner = dsl_dataset_set_user_ptr(ds, osi, dmu_objset_evict);
226fa9e4066Sahrens 		if (winner) {
227fa9e4066Sahrens 			dmu_objset_evict(ds, osi);
228fa9e4066Sahrens 			osi = winner;
229fa9e4066Sahrens 		}
230fa9e4066Sahrens 	}
231fa9e4066Sahrens 
232ea8dc4b6Seschrock 	*osip = osi;
233ea8dc4b6Seschrock 	return (0);
234fa9e4066Sahrens }
235fa9e4066Sahrens 
236fa9e4066Sahrens /* called from zpl */
237fa9e4066Sahrens int
238fa9e4066Sahrens dmu_objset_open(const char *name, dmu_objset_type_t type, int mode,
239fa9e4066Sahrens     objset_t **osp)
240fa9e4066Sahrens {
241fa9e4066Sahrens 	dsl_dataset_t *ds;
242fa9e4066Sahrens 	int err;
243fa9e4066Sahrens 	objset_t *os;
244fa9e4066Sahrens 	objset_impl_t *osi;
245fa9e4066Sahrens 
246fa9e4066Sahrens 	os = kmem_alloc(sizeof (objset_t), KM_SLEEP);
247fa9e4066Sahrens 	err = dsl_dataset_open(name, mode, os, &ds);
248fa9e4066Sahrens 	if (err) {
249fa9e4066Sahrens 		kmem_free(os, sizeof (objset_t));
250fa9e4066Sahrens 		return (err);
251fa9e4066Sahrens 	}
252fa9e4066Sahrens 
253fa9e4066Sahrens 	osi = dsl_dataset_get_user_ptr(ds);
254fa9e4066Sahrens 	if (osi == NULL) {
255fa9e4066Sahrens 		blkptr_t bp;
256fa9e4066Sahrens 
257fa9e4066Sahrens 		dsl_dataset_get_blkptr(ds, &bp);
258ea8dc4b6Seschrock 		err = dmu_objset_open_impl(dsl_dataset_get_spa(ds),
259ea8dc4b6Seschrock 		    ds, &bp, &osi);
260ea8dc4b6Seschrock 		if (err) {
261ea8dc4b6Seschrock 			dsl_dataset_close(ds, mode, os);
262ea8dc4b6Seschrock 			kmem_free(os, sizeof (objset_t));
263ea8dc4b6Seschrock 			return (err);
264ea8dc4b6Seschrock 		}
265fa9e4066Sahrens 	}
266fa9e4066Sahrens 
267fa9e4066Sahrens 	os->os = osi;
268fa9e4066Sahrens 	os->os_mode = mode;
269fa9e4066Sahrens 
270fa9e4066Sahrens 	if (type != DMU_OST_ANY && type != os->os->os_phys->os_type) {
271fa9e4066Sahrens 		dmu_objset_close(os);
272fa9e4066Sahrens 		return (EINVAL);
273fa9e4066Sahrens 	}
274fa9e4066Sahrens 	*osp = os;
275fa9e4066Sahrens 	return (0);
276fa9e4066Sahrens }
277fa9e4066Sahrens 
278fa9e4066Sahrens void
279fa9e4066Sahrens dmu_objset_close(objset_t *os)
280fa9e4066Sahrens {
281fa9e4066Sahrens 	dsl_dataset_close(os->os->os_dsl_dataset, os->os_mode, os);
282fa9e4066Sahrens 	kmem_free(os, sizeof (objset_t));
283fa9e4066Sahrens }
284fa9e4066Sahrens 
285436b2950Sperrin int
286436b2950Sperrin dmu_objset_evict_dbufs(objset_t *os, int try)
287ea8dc4b6Seschrock {
288ea8dc4b6Seschrock 	objset_impl_t *osi = os->os;
289ea8dc4b6Seschrock 	dnode_t *dn;
290c543ec06Sahrens 
291c543ec06Sahrens 	mutex_enter(&osi->os_lock);
292c543ec06Sahrens 
293c543ec06Sahrens 	/* process the mdn last, since the other dnodes have holds on it */
294c543ec06Sahrens 	list_remove(&osi->os_dnodes, osi->os_meta_dnode);
295c543ec06Sahrens 	list_insert_tail(&osi->os_dnodes, osi->os_meta_dnode);
296ea8dc4b6Seschrock 
297ea8dc4b6Seschrock 	/*
298c543ec06Sahrens 	 * Find the first dnode with holds.  We have to do this dance
299c543ec06Sahrens 	 * because dnode_add_ref() only works if you already have a
300c543ec06Sahrens 	 * hold.  If there are no holds then it has no dbufs so OK to
301c543ec06Sahrens 	 * skip.
302ea8dc4b6Seschrock 	 */
303c543ec06Sahrens 	for (dn = list_head(&osi->os_dnodes);
304c543ec06Sahrens 	    dn && refcount_is_zero(&dn->dn_holds);
305c543ec06Sahrens 	    dn = list_next(&osi->os_dnodes, dn))
306c543ec06Sahrens 		continue;
307c543ec06Sahrens 	if (dn)
308c543ec06Sahrens 		dnode_add_ref(dn, FTAG);
309c543ec06Sahrens 
310c543ec06Sahrens 	while (dn) {
311c543ec06Sahrens 		dnode_t *next_dn = dn;
312c543ec06Sahrens 
313c543ec06Sahrens 		do {
314c543ec06Sahrens 			next_dn = list_next(&osi->os_dnodes, next_dn);
315c543ec06Sahrens 		} while (next_dn && refcount_is_zero(&next_dn->dn_holds));
316c543ec06Sahrens 		if (next_dn)
317c543ec06Sahrens 			dnode_add_ref(next_dn, FTAG);
318c543ec06Sahrens 
319c543ec06Sahrens 		mutex_exit(&osi->os_lock);
320436b2950Sperrin 		if (dnode_evict_dbufs(dn, try)) {
321436b2950Sperrin 			dnode_rele(dn, FTAG);
322436b2950Sperrin 			if (next_dn)
323436b2950Sperrin 				dnode_rele(next_dn, FTAG);
324436b2950Sperrin 			return (1);
325436b2950Sperrin 		}
326c543ec06Sahrens 		dnode_rele(dn, FTAG);
327c543ec06Sahrens 		mutex_enter(&osi->os_lock);
328c543ec06Sahrens 		dn = next_dn;
329ea8dc4b6Seschrock 	}
330ea8dc4b6Seschrock 	mutex_exit(&osi->os_lock);
331436b2950Sperrin 	return (0);
332ea8dc4b6Seschrock }
333ea8dc4b6Seschrock 
334fa9e4066Sahrens void
335fa9e4066Sahrens dmu_objset_evict(dsl_dataset_t *ds, void *arg)
336fa9e4066Sahrens {
337fa9e4066Sahrens 	objset_impl_t *osi = arg;
338ea8dc4b6Seschrock 	objset_t os;
33999653d4eSeschrock 	int i;
340fa9e4066Sahrens 
341fa9e4066Sahrens 	for (i = 0; i < TXG_SIZE; i++) {
342fa9e4066Sahrens 		ASSERT(list_head(&osi->os_dirty_dnodes[i]) == NULL);
343fa9e4066Sahrens 		ASSERT(list_head(&osi->os_free_dnodes[i]) == NULL);
344fa9e4066Sahrens 	}
345fa9e4066Sahrens 
34699653d4eSeschrock 	if (ds && ds->ds_phys->ds_num_children == 0) {
34799653d4eSeschrock 		VERIFY(0 == dsl_prop_unregister(ds, "checksum",
34899653d4eSeschrock 		    checksum_changed_cb, osi));
34999653d4eSeschrock 		VERIFY(0 == dsl_prop_unregister(ds, "compression",
35099653d4eSeschrock 		    compression_changed_cb, osi));
351fa9e4066Sahrens 	}
352fa9e4066Sahrens 
353ea8dc4b6Seschrock 	/*
354ea8dc4b6Seschrock 	 * We should need only a single pass over the dnode list, since
355ea8dc4b6Seschrock 	 * nothing can be added to the list at this point.
356ea8dc4b6Seschrock 	 */
357ea8dc4b6Seschrock 	os.os = osi;
358436b2950Sperrin 	(void) dmu_objset_evict_dbufs(&os, 0);
359ea8dc4b6Seschrock 
360fa9e4066Sahrens 	ASSERT3P(list_head(&osi->os_dnodes), ==, osi->os_meta_dnode);
361fa9e4066Sahrens 	ASSERT3P(list_tail(&osi->os_dnodes), ==, osi->os_meta_dnode);
362fa9e4066Sahrens 	ASSERT3P(list_head(&osi->os_meta_dnode->dn_dbufs), ==, NULL);
363fa9e4066Sahrens 
364fa9e4066Sahrens 	dnode_special_close(osi->os_meta_dnode);
365fa9e4066Sahrens 	zil_free(osi->os_zil);
366fa9e4066Sahrens 
367fa9e4066Sahrens 	zio_buf_free(osi->os_phys, sizeof (objset_phys_t));
3685ad82045Snd 	mutex_destroy(&osi->os_lock);
3695ad82045Snd 	mutex_destroy(&osi->os_obj_lock);
370fa9e4066Sahrens 	kmem_free(osi, sizeof (objset_impl_t));
371fa9e4066Sahrens }
372fa9e4066Sahrens 
373fa9e4066Sahrens /* called from dsl for meta-objset */
374fa9e4066Sahrens objset_impl_t *
375fa9e4066Sahrens dmu_objset_create_impl(spa_t *spa, dsl_dataset_t *ds, dmu_objset_type_t type,
376fa9e4066Sahrens     dmu_tx_t *tx)
377fa9e4066Sahrens {
378fa9e4066Sahrens 	objset_impl_t *osi;
379fa9e4066Sahrens 	dnode_t *mdn;
380fa9e4066Sahrens 
381fa9e4066Sahrens 	ASSERT(dmu_tx_is_syncing(tx));
382ea8dc4b6Seschrock 	VERIFY(0 == dmu_objset_open_impl(spa, ds, NULL, &osi));
383fa9e4066Sahrens 	mdn = osi->os_meta_dnode;
384fa9e4066Sahrens 
385fa9e4066Sahrens 	dnode_allocate(mdn, DMU_OT_DNODE, 1 << DNODE_BLOCK_SHIFT,
386fa9e4066Sahrens 	    DN_MAX_INDBLKSHIFT, DMU_OT_NONE, 0, tx);
387fa9e4066Sahrens 
388fa9e4066Sahrens 	/*
389fa9e4066Sahrens 	 * We don't want to have to increase the meta-dnode's nlevels
390fa9e4066Sahrens 	 * later, because then we could do it in quescing context while
391fa9e4066Sahrens 	 * we are also accessing it in open context.
392fa9e4066Sahrens 	 *
393fa9e4066Sahrens 	 * This precaution is not necessary for the MOS (ds == NULL),
394fa9e4066Sahrens 	 * because the MOS is only updated in syncing context.
395fa9e4066Sahrens 	 * This is most fortunate: the MOS is the only objset that
396fa9e4066Sahrens 	 * needs to be synced multiple times as spa_sync() iterates
397fa9e4066Sahrens 	 * to convergence, so minimizing its dn_nlevels matters.
398fa9e4066Sahrens 	 */
399ea8dc4b6Seschrock 	if (ds != NULL) {
400ea8dc4b6Seschrock 		int levels = 1;
401ea8dc4b6Seschrock 
402ea8dc4b6Seschrock 		/*
403ea8dc4b6Seschrock 		 * Determine the number of levels necessary for the meta-dnode
404ea8dc4b6Seschrock 		 * to contain DN_MAX_OBJECT dnodes.
405ea8dc4b6Seschrock 		 */
406ea8dc4b6Seschrock 		while ((uint64_t)mdn->dn_nblkptr << (mdn->dn_datablkshift +
407ea8dc4b6Seschrock 		    (levels - 1) * (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)) <
408ea8dc4b6Seschrock 		    DN_MAX_OBJECT * sizeof (dnode_phys_t))
409ea8dc4b6Seschrock 			levels++;
410ea8dc4b6Seschrock 
411fa9e4066Sahrens 		mdn->dn_next_nlevels[tx->tx_txg & TXG_MASK] =
412ea8dc4b6Seschrock 		    mdn->dn_nlevels = levels;
413ea8dc4b6Seschrock 	}
414fa9e4066Sahrens 
415fa9e4066Sahrens 	ASSERT(type != DMU_OST_NONE);
416fa9e4066Sahrens 	ASSERT(type != DMU_OST_ANY);
417fa9e4066Sahrens 	ASSERT(type < DMU_OST_NUMTYPES);
418fa9e4066Sahrens 	osi->os_phys->os_type = type;
419fa9e4066Sahrens 
420fa9e4066Sahrens 	dsl_dataset_dirty(ds, tx);
421fa9e4066Sahrens 
422fa9e4066Sahrens 	return (osi);
423fa9e4066Sahrens }
424fa9e4066Sahrens 
425fa9e4066Sahrens struct oscarg {
426fa9e4066Sahrens 	void (*userfunc)(objset_t *os, void *arg, dmu_tx_t *tx);
427fa9e4066Sahrens 	void *userarg;
428fa9e4066Sahrens 	dsl_dataset_t *clone_parent;
429fa9e4066Sahrens 	const char *lastname;
430fa9e4066Sahrens 	dmu_objset_type_t type;
431fa9e4066Sahrens };
432fa9e4066Sahrens 
4331d452cf5Sahrens /* ARGSUSED */
434fa9e4066Sahrens static int
4351d452cf5Sahrens dmu_objset_create_check(void *arg1, void *arg2, dmu_tx_t *tx)
436fa9e4066Sahrens {
4371d452cf5Sahrens 	dsl_dir_t *dd = arg1;
4381d452cf5Sahrens 	struct oscarg *oa = arg2;
4391d452cf5Sahrens 	objset_t *mos = dd->dd_pool->dp_meta_objset;
440fa9e4066Sahrens 	int err;
4411d452cf5Sahrens 	uint64_t ddobj;
4421d452cf5Sahrens 
4431d452cf5Sahrens 	err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj,
4441d452cf5Sahrens 	    oa->lastname, sizeof (uint64_t), 1, &ddobj);
4451d452cf5Sahrens 	if (err != ENOENT)
4461d452cf5Sahrens 		return (err ? err : EEXIST);
4471d452cf5Sahrens 
4481d452cf5Sahrens 	if (oa->clone_parent != NULL) {
4491d452cf5Sahrens 		/*
4501d452cf5Sahrens 		 * You can't clone across pools.
4511d452cf5Sahrens 		 */
4521d452cf5Sahrens 		if (oa->clone_parent->ds_dir->dd_pool != dd->dd_pool)
4531d452cf5Sahrens 			return (EXDEV);
4541d452cf5Sahrens 
4551d452cf5Sahrens 		/*
4561d452cf5Sahrens 		 * You can only clone snapshots, not the head datasets.
4571d452cf5Sahrens 		 */
4581d452cf5Sahrens 		if (oa->clone_parent->ds_phys->ds_num_children == 0)
4591d452cf5Sahrens 			return (EINVAL);
4601d452cf5Sahrens 	}
4611d452cf5Sahrens 	return (0);
4621d452cf5Sahrens }
4631d452cf5Sahrens 
4641d452cf5Sahrens static void
4651d452cf5Sahrens dmu_objset_create_sync(void *arg1, void *arg2, dmu_tx_t *tx)
4661d452cf5Sahrens {
4671d452cf5Sahrens 	dsl_dir_t *dd = arg1;
4681d452cf5Sahrens 	struct oscarg *oa = arg2;
4691d452cf5Sahrens 	dsl_dataset_t *ds;
470fa9e4066Sahrens 	blkptr_t bp;
4711d452cf5Sahrens 	uint64_t dsobj;
472fa9e4066Sahrens 
473fa9e4066Sahrens 	ASSERT(dmu_tx_is_syncing(tx));
474fa9e4066Sahrens 
4751d452cf5Sahrens 	dsobj = dsl_dataset_create_sync(dd, oa->lastname,
476fa9e4066Sahrens 	    oa->clone_parent, tx);
477fa9e4066Sahrens 
4781d452cf5Sahrens 	VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL,
479ea8dc4b6Seschrock 	    DS_MODE_STANDARD | DS_MODE_READONLY, FTAG, &ds));
480fa9e4066Sahrens 	dsl_dataset_get_blkptr(ds, &bp);
481fa9e4066Sahrens 	if (BP_IS_HOLE(&bp)) {
482fa9e4066Sahrens 		objset_impl_t *osi;
483fa9e4066Sahrens 
484fa9e4066Sahrens 		/* This is an empty dmu_objset; not a clone. */
485fa9e4066Sahrens 		osi = dmu_objset_create_impl(dsl_dataset_get_spa(ds),
486fa9e4066Sahrens 		    ds, oa->type, tx);
487fa9e4066Sahrens 
488fa9e4066Sahrens 		if (oa->userfunc)
489fa9e4066Sahrens 			oa->userfunc(&osi->os, oa->userarg, tx);
490fa9e4066Sahrens 	}
491fa9e4066Sahrens 	dsl_dataset_close(ds, DS_MODE_STANDARD | DS_MODE_READONLY, FTAG);
492fa9e4066Sahrens }
493fa9e4066Sahrens 
494fa9e4066Sahrens int
495fa9e4066Sahrens dmu_objset_create(const char *name, dmu_objset_type_t type,
496fa9e4066Sahrens     objset_t *clone_parent,
497fa9e4066Sahrens     void (*func)(objset_t *os, void *arg, dmu_tx_t *tx), void *arg)
498fa9e4066Sahrens {
4991d452cf5Sahrens 	dsl_dir_t *pdd;
500fa9e4066Sahrens 	const char *tail;
501fa9e4066Sahrens 	int err = 0;
5021d452cf5Sahrens 	struct oscarg oa = { 0 };
503fa9e4066Sahrens 
5041d452cf5Sahrens 	ASSERT(strchr(name, '@') == NULL);
5051d452cf5Sahrens 	err = dsl_dir_open(name, FTAG, &pdd, &tail);
506ea8dc4b6Seschrock 	if (err)
507ea8dc4b6Seschrock 		return (err);
508fa9e4066Sahrens 	if (tail == NULL) {
5091d452cf5Sahrens 		dsl_dir_close(pdd, FTAG);
510fa9e4066Sahrens 		return (EEXIST);
511fa9e4066Sahrens 	}
512fa9e4066Sahrens 
513fa9e4066Sahrens 	dprintf("name=%s\n", name);
514fa9e4066Sahrens 
5151d452cf5Sahrens 	oa.userfunc = func;
5161d452cf5Sahrens 	oa.userarg = arg;
5171d452cf5Sahrens 	oa.lastname = tail;
5181d452cf5Sahrens 	oa.type = type;
5191d452cf5Sahrens 	if (clone_parent != NULL) {
520fa9e4066Sahrens 		/*
5211d452cf5Sahrens 		 * You can't clone to a different type.
522fa9e4066Sahrens 		 */
5231d452cf5Sahrens 		if (clone_parent->os->os_phys->os_type != type) {
5241d452cf5Sahrens 			dsl_dir_close(pdd, FTAG);
5251d452cf5Sahrens 			return (EINVAL);
526fa9e4066Sahrens 		}
5271d452cf5Sahrens 		oa.clone_parent = clone_parent->os->os_dsl_dataset;
528fa9e4066Sahrens 	}
5291d452cf5Sahrens 	err = dsl_sync_task_do(pdd->dd_pool, dmu_objset_create_check,
5301d452cf5Sahrens 	    dmu_objset_create_sync, pdd, &oa, 5);
5311d452cf5Sahrens 	dsl_dir_close(pdd, FTAG);
532fa9e4066Sahrens 	return (err);
533fa9e4066Sahrens }
534fa9e4066Sahrens 
535fa9e4066Sahrens int
536fa9e4066Sahrens dmu_objset_destroy(const char *name)
537fa9e4066Sahrens {
538fa9e4066Sahrens 	objset_t *os;
539fa9e4066Sahrens 	int error;
540fa9e4066Sahrens 
541fa9e4066Sahrens 	/*
542fa9e4066Sahrens 	 * If it looks like we'll be able to destroy it, and there's
543fa9e4066Sahrens 	 * an unplayed replay log sitting around, destroy the log.
544fa9e4066Sahrens 	 * It would be nicer to do this in dsl_dataset_destroy_sync(),
545fa9e4066Sahrens 	 * but the replay log objset is modified in open context.
546fa9e4066Sahrens 	 */
547fa9e4066Sahrens 	error = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_EXCLUSIVE, &os);
548fa9e4066Sahrens 	if (error == 0) {
549d80c45e0Sbonwick 		zil_destroy(dmu_objset_zil(os), B_FALSE);
550fa9e4066Sahrens 		dmu_objset_close(os);
551fa9e4066Sahrens 	}
552fa9e4066Sahrens 
553fa9e4066Sahrens 	return (dsl_dataset_destroy(name));
554fa9e4066Sahrens }
555fa9e4066Sahrens 
556fa9e4066Sahrens int
557fa9e4066Sahrens dmu_objset_rollback(const char *name)
558fa9e4066Sahrens {
559fa9e4066Sahrens 	int err;
560fa9e4066Sahrens 	objset_t *os;
561fa9e4066Sahrens 
5621d452cf5Sahrens 	err = dmu_objset_open(name, DMU_OST_ANY,
5631d452cf5Sahrens 	    DS_MODE_EXCLUSIVE | DS_MODE_INCONSISTENT, &os);
564fa9e4066Sahrens 	if (err == 0) {
565fa9e4066Sahrens 		err = zil_suspend(dmu_objset_zil(os));
566fa9e4066Sahrens 		if (err == 0)
567fa9e4066Sahrens 			zil_resume(dmu_objset_zil(os));
568fa9e4066Sahrens 		if (err == 0) {
569fa9e4066Sahrens 			/* XXX uncache everything? */
5701d452cf5Sahrens 			err = dsl_dataset_rollback(os->os->os_dsl_dataset);
571fa9e4066Sahrens 		}
5721d452cf5Sahrens 		dmu_objset_close(os);
573fa9e4066Sahrens 	}
574fa9e4066Sahrens 	return (err);
575fa9e4066Sahrens }
576fa9e4066Sahrens 
5771d452cf5Sahrens struct snaparg {
5781d452cf5Sahrens 	dsl_sync_task_group_t *dstg;
5791d452cf5Sahrens 	char *snapname;
5801d452cf5Sahrens 	char failed[MAXPATHLEN];
5811d452cf5Sahrens };
5821d452cf5Sahrens 
5831d452cf5Sahrens static int
5841d452cf5Sahrens dmu_objset_snapshot_one(char *name, void *arg)
5851d452cf5Sahrens {
5861d452cf5Sahrens 	struct snaparg *sn = arg;
5871d452cf5Sahrens 	objset_t *os;
5881d452cf5Sahrens 	int err;
5891d452cf5Sahrens 
5901d452cf5Sahrens 	(void) strcpy(sn->failed, name);
5911d452cf5Sahrens 
5921d452cf5Sahrens 	err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_STANDARD, &os);
5931d452cf5Sahrens 	if (err != 0)
5941d452cf5Sahrens 		return (err);
5951d452cf5Sahrens 
5961d452cf5Sahrens 	/*
5971d452cf5Sahrens 	 * NB: we need to wait for all in-flight changes to get to disk,
5981d452cf5Sahrens 	 * so that we snapshot those changes.  zil_suspend does this as
5991d452cf5Sahrens 	 * a side effect.
6001d452cf5Sahrens 	 */
6011d452cf5Sahrens 	err = zil_suspend(dmu_objset_zil(os));
6021d452cf5Sahrens 	if (err == 0) {
6031d452cf5Sahrens 		dsl_sync_task_create(sn->dstg, dsl_dataset_snapshot_check,
6041d452cf5Sahrens 		    dsl_dataset_snapshot_sync, os, sn->snapname, 3);
6051d452cf5Sahrens 	}
6061d452cf5Sahrens 	return (err);
6071d452cf5Sahrens }
6081d452cf5Sahrens 
6091d452cf5Sahrens int
6101d452cf5Sahrens dmu_objset_snapshot(char *fsname, char *snapname, boolean_t recursive)
6111d452cf5Sahrens {
6121d452cf5Sahrens 	dsl_sync_task_t *dst;
6131d452cf5Sahrens 	struct snaparg sn = { 0 };
6141d452cf5Sahrens 	char *cp;
6151d452cf5Sahrens 	spa_t *spa;
6161d452cf5Sahrens 	int err;
6171d452cf5Sahrens 
6181d452cf5Sahrens 	(void) strcpy(sn.failed, fsname);
6191d452cf5Sahrens 
6201d452cf5Sahrens 	cp = strchr(fsname, '/');
6211d452cf5Sahrens 	if (cp) {
6221d452cf5Sahrens 		*cp = '\0';
6231d452cf5Sahrens 		err = spa_open(fsname, &spa, FTAG);
6241d452cf5Sahrens 		*cp = '/';
6251d452cf5Sahrens 	} else {
6261d452cf5Sahrens 		err = spa_open(fsname, &spa, FTAG);
6271d452cf5Sahrens 	}
6281d452cf5Sahrens 	if (err)
6291d452cf5Sahrens 		return (err);
6301d452cf5Sahrens 
6311d452cf5Sahrens 	sn.dstg = dsl_sync_task_group_create(spa_get_dsl(spa));
6321d452cf5Sahrens 	sn.snapname = snapname;
6331d452cf5Sahrens 
6340b69c2f0Sahrens 	if (recursive) {
6350b69c2f0Sahrens 		err = dmu_objset_find(fsname,
6360b69c2f0Sahrens 		    dmu_objset_snapshot_one, &sn, DS_FIND_CHILDREN);
6370b69c2f0Sahrens 	} else {
6381d452cf5Sahrens 		err = dmu_objset_snapshot_one(fsname, &sn);
6390b69c2f0Sahrens 	}
6401d452cf5Sahrens 
6411d452cf5Sahrens 	if (err)
6421d452cf5Sahrens 		goto out;
6431d452cf5Sahrens 
6441d452cf5Sahrens 	err = dsl_sync_task_group_wait(sn.dstg);
6451d452cf5Sahrens 
6461d452cf5Sahrens 	for (dst = list_head(&sn.dstg->dstg_tasks); dst;
6471d452cf5Sahrens 	    dst = list_next(&sn.dstg->dstg_tasks, dst)) {
6481d452cf5Sahrens 		objset_t *os = dst->dst_arg1;
6491d452cf5Sahrens 		if (dst->dst_err)
6501d452cf5Sahrens 			dmu_objset_name(os, sn.failed);
6511d452cf5Sahrens 		zil_resume(dmu_objset_zil(os));
6521d452cf5Sahrens 		dmu_objset_close(os);
6531d452cf5Sahrens 	}
6541d452cf5Sahrens out:
6551d452cf5Sahrens 	if (err)
6561d452cf5Sahrens 		(void) strcpy(fsname, sn.failed);
6571d452cf5Sahrens 	dsl_sync_task_group_destroy(sn.dstg);
6581d452cf5Sahrens 	spa_close(spa, FTAG);
6591d452cf5Sahrens 	return (err);
6601d452cf5Sahrens }
6611d452cf5Sahrens 
662fa9e4066Sahrens static void
663fa9e4066Sahrens dmu_objset_sync_dnodes(objset_impl_t *os, list_t *list, dmu_tx_t *tx)
664fa9e4066Sahrens {
665fa9e4066Sahrens 	dnode_t *dn = list_head(list);
666fa9e4066Sahrens 	int level, err;
667fa9e4066Sahrens 
668fa9e4066Sahrens 	for (level = 0; dn = list_head(list); level++) {
669fa9e4066Sahrens 		zio_t *zio;
670fa9e4066Sahrens 		zio = zio_root(os->os_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
671fa9e4066Sahrens 
672fa9e4066Sahrens 		ASSERT3U(level, <=, DN_MAX_LEVELS);
673fa9e4066Sahrens 
674fa9e4066Sahrens 		while (dn) {
675fa9e4066Sahrens 			dnode_t *next = list_next(list, dn);
676fa9e4066Sahrens 
677fa9e4066Sahrens 			list_remove(list, dn);
678fa9e4066Sahrens 			if (dnode_sync(dn, level, zio, tx) == 0) {
679fa9e4066Sahrens 				/*
680fa9e4066Sahrens 				 * This dnode requires syncing at higher
681fa9e4066Sahrens 				 * levels; put it back onto the list.
682fa9e4066Sahrens 				 */
683fa9e4066Sahrens 				if (next)
684fa9e4066Sahrens 					list_insert_before(list, next, dn);
685fa9e4066Sahrens 				else
686fa9e4066Sahrens 					list_insert_tail(list, dn);
687fa9e4066Sahrens 			}
688fa9e4066Sahrens 			dn = next;
689fa9e4066Sahrens 		}
690fa9e4066Sahrens 		err = zio_wait(zio);
691fa9e4066Sahrens 		ASSERT(err == 0);
692fa9e4066Sahrens 	}
693fa9e4066Sahrens }
694fa9e4066Sahrens 
695fa9e4066Sahrens /* ARGSUSED */
696fa9e4066Sahrens static void
697fa9e4066Sahrens killer(zio_t *zio, arc_buf_t *abuf, void *arg)
698fa9e4066Sahrens {
699fa9e4066Sahrens 	objset_impl_t *os = arg;
700fa9e4066Sahrens 	objset_phys_t *osphys = zio->io_data;
701fa9e4066Sahrens 	dnode_phys_t *dnp = &osphys->os_meta_dnode;
702fa9e4066Sahrens 	int i;
703fa9e4066Sahrens 
704fa9e4066Sahrens 	ASSERT3U(zio->io_error, ==, 0);
705fa9e4066Sahrens 
706fa9e4066Sahrens 	/*
707fa9e4066Sahrens 	 * Update rootbp fill count.
708fa9e4066Sahrens 	 */
709fa9e4066Sahrens 	os->os_rootbp.blk_fill = 1;	/* count the meta-dnode */
710fa9e4066Sahrens 	for (i = 0; i < dnp->dn_nblkptr; i++)
711fa9e4066Sahrens 		os->os_rootbp.blk_fill += dnp->dn_blkptr[i].blk_fill;
712fa9e4066Sahrens 
713fa9e4066Sahrens 	BP_SET_TYPE(zio->io_bp, DMU_OT_OBJSET);
714fa9e4066Sahrens 	BP_SET_LEVEL(zio->io_bp, 0);
715fa9e4066Sahrens 
716fa9e4066Sahrens 	if (!DVA_EQUAL(BP_IDENTITY(zio->io_bp),
717fa9e4066Sahrens 	    BP_IDENTITY(&zio->io_bp_orig))) {
718fa9e4066Sahrens 		dsl_dataset_block_kill(os->os_dsl_dataset, &zio->io_bp_orig,
719fa9e4066Sahrens 		    os->os_synctx);
720fa9e4066Sahrens 		dsl_dataset_block_born(os->os_dsl_dataset, zio->io_bp,
721fa9e4066Sahrens 		    os->os_synctx);
722fa9e4066Sahrens 	}
723fa9e4066Sahrens }
724fa9e4066Sahrens 
725fa9e4066Sahrens /* called from dsl */
726fa9e4066Sahrens void
727fa9e4066Sahrens dmu_objset_sync(objset_impl_t *os, dmu_tx_t *tx)
728fa9e4066Sahrens {
729fa9e4066Sahrens 	extern taskq_t *dbuf_tq;
730fa9e4066Sahrens 	int txgoff;
731fa9e4066Sahrens 	list_t *dirty_list;
732fa9e4066Sahrens 	int err;
733ea8dc4b6Seschrock 	zbookmark_t zb;
734fa9e4066Sahrens 	arc_buf_t *abuf =
735fa9e4066Sahrens 	    arc_buf_alloc(os->os_spa, sizeof (objset_phys_t), FTAG);
736fa9e4066Sahrens 
737fa9e4066Sahrens 	ASSERT(dmu_tx_is_syncing(tx));
738fa9e4066Sahrens 	ASSERT(os->os_synctx == NULL);
739fa9e4066Sahrens 	/* XXX the write_done callback should really give us the tx... */
740fa9e4066Sahrens 	os->os_synctx = tx;
741fa9e4066Sahrens 
742fa9e4066Sahrens 	dprintf_ds(os->os_dsl_dataset, "txg=%llu\n", tx->tx_txg);
743fa9e4066Sahrens 
744fa9e4066Sahrens 	txgoff = tx->tx_txg & TXG_MASK;
745fa9e4066Sahrens 
746fa9e4066Sahrens 	dmu_objset_sync_dnodes(os, &os->os_free_dnodes[txgoff], tx);
747fa9e4066Sahrens 	dmu_objset_sync_dnodes(os, &os->os_dirty_dnodes[txgoff], tx);
748fa9e4066Sahrens 
749fa9e4066Sahrens 	/*
750fa9e4066Sahrens 	 * Free intent log blocks up to this tx.
751fa9e4066Sahrens 	 */
752fa9e4066Sahrens 	zil_sync(os->os_zil, tx);
753fa9e4066Sahrens 
754fa9e4066Sahrens 	/*
755fa9e4066Sahrens 	 * Sync meta-dnode
756fa9e4066Sahrens 	 */
757fa9e4066Sahrens 	dirty_list = &os->os_dirty_dnodes[txgoff];
758fa9e4066Sahrens 	ASSERT(list_head(dirty_list) == NULL);
759fa9e4066Sahrens 	list_insert_tail(dirty_list, os->os_meta_dnode);
760fa9e4066Sahrens 	dmu_objset_sync_dnodes(os, dirty_list, tx);
761fa9e4066Sahrens 
762fa9e4066Sahrens 	/*
763fa9e4066Sahrens 	 * Sync the root block.
764fa9e4066Sahrens 	 */
765fa9e4066Sahrens 	bcopy(os->os_phys, abuf->b_data, sizeof (objset_phys_t));
766ea8dc4b6Seschrock 	zb.zb_objset = os->os_dsl_dataset ? os->os_dsl_dataset->ds_object : 0;
767ea8dc4b6Seschrock 	zb.zb_object = 0;
768ea8dc4b6Seschrock 	zb.zb_level = -1;
769ea8dc4b6Seschrock 	zb.zb_blkid = 0;
770fa9e4066Sahrens 	err = arc_write(NULL, os->os_spa, os->os_md_checksum,
77144cd46caSbillm 	    os->os_md_compress,
77244cd46caSbillm 	    dmu_get_replication_level(os->os_spa, &zb, DMU_OT_OBJSET),
77344cd46caSbillm 	    tx->tx_txg, &os->os_rootbp, abuf, killer, os,
774ea8dc4b6Seschrock 	    ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_MUSTSUCCEED, ARC_WAIT, &zb);
775fa9e4066Sahrens 	ASSERT(err == 0);
776ea8dc4b6Seschrock 	VERIFY(arc_buf_remove_ref(abuf, FTAG) == 1);
777fa9e4066Sahrens 
778fa9e4066Sahrens 	dsl_dataset_set_blkptr(os->os_dsl_dataset, &os->os_rootbp, tx);
779fa9e4066Sahrens 
780fa9e4066Sahrens 	ASSERT3P(os->os_synctx, ==, tx);
781fa9e4066Sahrens 	taskq_wait(dbuf_tq);
782fa9e4066Sahrens 	os->os_synctx = NULL;
783fa9e4066Sahrens }
784fa9e4066Sahrens 
785fa9e4066Sahrens void
786*a2eea2e1Sahrens dmu_objset_space(objset_t *os, uint64_t *refdbytesp, uint64_t *availbytesp,
787*a2eea2e1Sahrens     uint64_t *usedobjsp, uint64_t *availobjsp)
788fa9e4066Sahrens {
789*a2eea2e1Sahrens 	dsl_dataset_space(os->os->os_dsl_dataset, refdbytesp, availbytesp,
790*a2eea2e1Sahrens 	    usedobjsp, availobjsp);
791*a2eea2e1Sahrens }
792*a2eea2e1Sahrens 
793*a2eea2e1Sahrens uint64_t
794*a2eea2e1Sahrens dmu_objset_fsid_guid(objset_t *os)
795*a2eea2e1Sahrens {
796*a2eea2e1Sahrens 	return (dsl_dataset_fsid_guid(os->os->os_dsl_dataset));
797*a2eea2e1Sahrens }
798*a2eea2e1Sahrens 
799*a2eea2e1Sahrens void
800*a2eea2e1Sahrens dmu_objset_fast_stat(objset_t *os, dmu_objset_stats_t *stat)
801*a2eea2e1Sahrens {
802*a2eea2e1Sahrens 	stat->dds_type = os->os->os_phys->os_type;
803*a2eea2e1Sahrens 	if (os->os->os_dsl_dataset)
804*a2eea2e1Sahrens 		dsl_dataset_fast_stat(os->os->os_dsl_dataset, stat);
805*a2eea2e1Sahrens }
806*a2eea2e1Sahrens 
807*a2eea2e1Sahrens void
808*a2eea2e1Sahrens dmu_objset_stats(objset_t *os, nvlist_t *nv)
809*a2eea2e1Sahrens {
810*a2eea2e1Sahrens 	ASSERT(os->os->os_dsl_dataset ||
811*a2eea2e1Sahrens 	    os->os->os_phys->os_type == DMU_OST_META);
812*a2eea2e1Sahrens 
813*a2eea2e1Sahrens 	if (os->os->os_dsl_dataset != NULL)
814*a2eea2e1Sahrens 		dsl_dataset_stats(os->os->os_dsl_dataset, nv);
815*a2eea2e1Sahrens 
816*a2eea2e1Sahrens 	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_TYPE,
817*a2eea2e1Sahrens 	    os->os->os_phys->os_type);
818fa9e4066Sahrens }
819fa9e4066Sahrens 
820fa9e4066Sahrens int
821fa9e4066Sahrens dmu_objset_is_snapshot(objset_t *os)
822fa9e4066Sahrens {
823fa9e4066Sahrens 	if (os->os->os_dsl_dataset != NULL)
824fa9e4066Sahrens 		return (dsl_dataset_is_snapshot(os->os->os_dsl_dataset));
825fa9e4066Sahrens 	else
826fa9e4066Sahrens 		return (B_FALSE);
827fa9e4066Sahrens }
828fa9e4066Sahrens 
829fa9e4066Sahrens int
830fa9e4066Sahrens dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
83187e5029aSahrens     uint64_t *idp, uint64_t *offp)
832fa9e4066Sahrens {
833fa9e4066Sahrens 	dsl_dataset_t *ds = os->os->os_dsl_dataset;
834fa9e4066Sahrens 	zap_cursor_t cursor;
835fa9e4066Sahrens 	zap_attribute_t attr;
836fa9e4066Sahrens 
837fa9e4066Sahrens 	if (ds->ds_phys->ds_snapnames_zapobj == 0)
838fa9e4066Sahrens 		return (ENOENT);
839fa9e4066Sahrens 
840fa9e4066Sahrens 	zap_cursor_init_serialized(&cursor,
841fa9e4066Sahrens 	    ds->ds_dir->dd_pool->dp_meta_objset,
842fa9e4066Sahrens 	    ds->ds_phys->ds_snapnames_zapobj, *offp);
843fa9e4066Sahrens 
84487e5029aSahrens 	if (zap_cursor_retrieve(&cursor, &attr) != 0) {
84587e5029aSahrens 		zap_cursor_fini(&cursor);
84687e5029aSahrens 		return (ENOENT);
84787e5029aSahrens 	}
84887e5029aSahrens 
84987e5029aSahrens 	if (strlen(attr.za_name) + 1 > namelen) {
85087e5029aSahrens 		zap_cursor_fini(&cursor);
85187e5029aSahrens 		return (ENAMETOOLONG);
85287e5029aSahrens 	}
85387e5029aSahrens 
85487e5029aSahrens 	(void) strcpy(name, attr.za_name);
85587e5029aSahrens 	if (idp)
85687e5029aSahrens 		*idp = attr.za_first_integer;
85787e5029aSahrens 	zap_cursor_advance(&cursor);
85887e5029aSahrens 	*offp = zap_cursor_serialize(&cursor);
85987e5029aSahrens 	zap_cursor_fini(&cursor);
86087e5029aSahrens 
86187e5029aSahrens 	return (0);
86287e5029aSahrens }
86387e5029aSahrens 
86487e5029aSahrens int
86587e5029aSahrens dmu_dir_list_next(objset_t *os, int namelen, char *name,
86687e5029aSahrens     uint64_t *idp, uint64_t *offp)
86787e5029aSahrens {
86887e5029aSahrens 	dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir;
86987e5029aSahrens 	zap_cursor_t cursor;
87087e5029aSahrens 	zap_attribute_t attr;
87187e5029aSahrens 
87287e5029aSahrens 	/* there is no next dir on a snapshot! */
87387e5029aSahrens 	if (os->os->os_dsl_dataset->ds_object !=
87487e5029aSahrens 	    dd->dd_phys->dd_head_dataset_obj)
875fa9e4066Sahrens 		return (ENOENT);
876fa9e4066Sahrens 
87787e5029aSahrens 	zap_cursor_init_serialized(&cursor,
87887e5029aSahrens 	    dd->dd_pool->dp_meta_objset,
87987e5029aSahrens 	    dd->dd_phys->dd_child_dir_zapobj, *offp);
88087e5029aSahrens 
88187e5029aSahrens 	if (zap_cursor_retrieve(&cursor, &attr) != 0) {
88287e5029aSahrens 		zap_cursor_fini(&cursor);
88387e5029aSahrens 		return (ENOENT);
88487e5029aSahrens 	}
88587e5029aSahrens 
88687e5029aSahrens 	if (strlen(attr.za_name) + 1 > namelen) {
88787e5029aSahrens 		zap_cursor_fini(&cursor);
888fa9e4066Sahrens 		return (ENAMETOOLONG);
88987e5029aSahrens 	}
890fa9e4066Sahrens 
891fa9e4066Sahrens 	(void) strcpy(name, attr.za_name);
89287e5029aSahrens 	if (idp)
89387e5029aSahrens 		*idp = attr.za_first_integer;
894fa9e4066Sahrens 	zap_cursor_advance(&cursor);
895fa9e4066Sahrens 	*offp = zap_cursor_serialize(&cursor);
89687e5029aSahrens 	zap_cursor_fini(&cursor);
897fa9e4066Sahrens 
898fa9e4066Sahrens 	return (0);
899fa9e4066Sahrens }
900fa9e4066Sahrens 
901fa9e4066Sahrens /*
902fa9e4066Sahrens  * Find all objsets under name, and for each, call 'func(child_name, arg)'.
903fa9e4066Sahrens  */
9041d452cf5Sahrens int
9051d452cf5Sahrens dmu_objset_find(char *name, int func(char *, void *), void *arg, int flags)
906fa9e4066Sahrens {
907fa9e4066Sahrens 	dsl_dir_t *dd;
908fa9e4066Sahrens 	objset_t *os;
909fa9e4066Sahrens 	uint64_t snapobj;
910fa9e4066Sahrens 	zap_cursor_t zc;
911fa9e4066Sahrens 	zap_attribute_t attr;
912fa9e4066Sahrens 	char *child;
913ea8dc4b6Seschrock 	int do_self, err;
914fa9e4066Sahrens 
915ea8dc4b6Seschrock 	err = dsl_dir_open(name, FTAG, &dd, NULL);
916ea8dc4b6Seschrock 	if (err)
9171d452cf5Sahrens 		return (err);
918fa9e4066Sahrens 
9191d452cf5Sahrens 	/* NB: the $MOS dir doesn't have a head dataset */
920fa9e4066Sahrens 	do_self = (dd->dd_phys->dd_head_dataset_obj != 0);
921fa9e4066Sahrens 
922fa9e4066Sahrens 	/*
923fa9e4066Sahrens 	 * Iterate over all children.
924fa9e4066Sahrens 	 */
9250b69c2f0Sahrens 	if (flags & DS_FIND_CHILDREN) {
9260b69c2f0Sahrens 		for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset,
9270b69c2f0Sahrens 		    dd->dd_phys->dd_child_dir_zapobj);
9280b69c2f0Sahrens 		    zap_cursor_retrieve(&zc, &attr) == 0;
9290b69c2f0Sahrens 		    (void) zap_cursor_advance(&zc)) {
9300b69c2f0Sahrens 			ASSERT(attr.za_integer_length == sizeof (uint64_t));
9310b69c2f0Sahrens 			ASSERT(attr.za_num_integers == 1);
932fa9e4066Sahrens 
9330b69c2f0Sahrens 			/*
9340b69c2f0Sahrens 			 * No separating '/' because parent's name ends in /.
9350b69c2f0Sahrens 			 */
9360b69c2f0Sahrens 			child = kmem_alloc(MAXPATHLEN, KM_SLEEP);
9370b69c2f0Sahrens 			/* XXX could probably just use name here */
9380b69c2f0Sahrens 			dsl_dir_name(dd, child);
9390b69c2f0Sahrens 			(void) strcat(child, "/");
9400b69c2f0Sahrens 			(void) strcat(child, attr.za_name);
9410b69c2f0Sahrens 			err = dmu_objset_find(child, func, arg, flags);
9420b69c2f0Sahrens 			kmem_free(child, MAXPATHLEN);
9430b69c2f0Sahrens 			if (err)
9440b69c2f0Sahrens 				break;
9450b69c2f0Sahrens 		}
9460b69c2f0Sahrens 		zap_cursor_fini(&zc);
9471d452cf5Sahrens 
9480b69c2f0Sahrens 		if (err) {
9490b69c2f0Sahrens 			dsl_dir_close(dd, FTAG);
9500b69c2f0Sahrens 			return (err);
9510b69c2f0Sahrens 		}
952fa9e4066Sahrens 	}
953fa9e4066Sahrens 
954fa9e4066Sahrens 	/*
955fa9e4066Sahrens 	 * Iterate over all snapshots.
956fa9e4066Sahrens 	 */
957fa9e4066Sahrens 	if ((flags & DS_FIND_SNAPSHOTS) &&
958fa9e4066Sahrens 	    dmu_objset_open(name, DMU_OST_ANY,
959fa9e4066Sahrens 	    DS_MODE_STANDARD | DS_MODE_READONLY, &os) == 0) {
960fa9e4066Sahrens 
961fa9e4066Sahrens 		snapobj = os->os->os_dsl_dataset->ds_phys->ds_snapnames_zapobj;
962fa9e4066Sahrens 		dmu_objset_close(os);
963fa9e4066Sahrens 
964fa9e4066Sahrens 		for (zap_cursor_init(&zc, dd->dd_pool->dp_meta_objset, snapobj);
965fa9e4066Sahrens 		    zap_cursor_retrieve(&zc, &attr) == 0;
966fa9e4066Sahrens 		    (void) zap_cursor_advance(&zc)) {
967fa9e4066Sahrens 			ASSERT(attr.za_integer_length == sizeof (uint64_t));
968fa9e4066Sahrens 			ASSERT(attr.za_num_integers == 1);
969fa9e4066Sahrens 
970fa9e4066Sahrens 			child = kmem_alloc(MAXPATHLEN, KM_SLEEP);
971fa9e4066Sahrens 			/* XXX could probably just use name here */
972fa9e4066Sahrens 			dsl_dir_name(dd, child);
973fa9e4066Sahrens 			(void) strcat(child, "@");
974fa9e4066Sahrens 			(void) strcat(child, attr.za_name);
9751d452cf5Sahrens 			err = func(child, arg);
976fa9e4066Sahrens 			kmem_free(child, MAXPATHLEN);
9771d452cf5Sahrens 			if (err)
9781d452cf5Sahrens 				break;
979fa9e4066Sahrens 		}
98087e5029aSahrens 		zap_cursor_fini(&zc);
981fa9e4066Sahrens 	}
982fa9e4066Sahrens 
983fa9e4066Sahrens 	dsl_dir_close(dd, FTAG);
984fa9e4066Sahrens 
9851d452cf5Sahrens 	if (err)
9861d452cf5Sahrens 		return (err);
9871d452cf5Sahrens 
988fa9e4066Sahrens 	/*
989fa9e4066Sahrens 	 * Apply to self if appropriate.
990fa9e4066Sahrens 	 */
991fa9e4066Sahrens 	if (do_self)
9921d452cf5Sahrens 		err = func(name, arg);
9931d452cf5Sahrens 	return (err);
994fa9e4066Sahrens }
995