xref: /illumos-gate/usr/src/uts/common/fs/zfs/zap_micro.c (revision ab04eb8ef60d9dc9614d6cccffc474f24ca1d162)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5f65e61c0Sahrens  * Common Development and Distribution License (the "License").
6f65e61c0Sahrens  * 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 /*
22*ab04eb8eStimh  * Copyright 2008 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/spa.h>
29fa9e4066Sahrens #include <sys/dmu.h>
30fa9e4066Sahrens #include <sys/zfs_context.h>
31fa9e4066Sahrens #include <sys/zap.h>
32ea8dc4b6Seschrock #include <sys/refcount.h>
33fa9e4066Sahrens #include <sys/zap_impl.h>
3487e5029aSahrens #include <sys/zap_leaf.h>
35fa9e4066Sahrens #include <sys/avl.h>
36de8267e0Stimh 
37de8267e0Stimh #ifdef _KERNEL
38de8267e0Stimh #include <sys/sunddi.h>
39de8267e0Stimh #endif
40fa9e4066Sahrens 
41ad860c82Sbonwick static int mzap_upgrade(zap_t **zapp, dmu_tx_t *tx);
42fa9e4066Sahrens 
43fa9e4066Sahrens 
44da6c28aaSamw static uint64_t
45da6c28aaSamw zap_hash(zap_t *zap, const char *normname)
46da6c28aaSamw {
47da6c28aaSamw 	const uint8_t *cp;
48da6c28aaSamw 	uint8_t c;
49da6c28aaSamw 	uint64_t crc = zap->zap_salt;
50da6c28aaSamw 
51da6c28aaSamw 	/* NB: name must already be normalized, if necessary */
52da6c28aaSamw 
53da6c28aaSamw 	ASSERT(crc != 0);
54da6c28aaSamw 	ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY);
55da6c28aaSamw 	for (cp = (const uint8_t *)normname; (c = *cp) != '\0'; cp++) {
56da6c28aaSamw 		crc = (crc >> 8) ^ zfs_crc64_table[(crc ^ c) & 0xFF];
57da6c28aaSamw 	}
58da6c28aaSamw 
59da6c28aaSamw 	/*
60da6c28aaSamw 	 * Only use 28 bits, since we need 4 bits in the cookie for the
61da6c28aaSamw 	 * collision differentiator.  We MUST use the high bits, since
62da6c28aaSamw 	 * those are the ones that we first pay attention to when
63da6c28aaSamw 	 * chosing the bucket.
64da6c28aaSamw 	 */
65da6c28aaSamw 	crc &= ~((1ULL << (64 - ZAP_HASHBITS)) - 1);
66da6c28aaSamw 
67da6c28aaSamw 	return (crc);
68da6c28aaSamw }
69da6c28aaSamw 
70da6c28aaSamw static int
71da6c28aaSamw zap_normalize(zap_t *zap, const char *name, char *namenorm)
72da6c28aaSamw {
73da6c28aaSamw 	size_t inlen, outlen;
74da6c28aaSamw 	int err;
75da6c28aaSamw 
76da6c28aaSamw 	inlen = strlen(name) + 1;
77da6c28aaSamw 	outlen = ZAP_MAXNAMELEN;
78da6c28aaSamw 
79da6c28aaSamw 	err = 0;
80da6c28aaSamw 	(void) u8_textprep_str((char *)name, &inlen, namenorm, &outlen,
81da6c28aaSamw 	    zap->zap_normflags | U8_TEXTPREP_IGNORE_NULL, U8_UNICODE_LATEST,
82da6c28aaSamw 	    &err);
83da6c28aaSamw 
84da6c28aaSamw 	return (err);
85da6c28aaSamw }
86da6c28aaSamw 
87da6c28aaSamw boolean_t
88da6c28aaSamw zap_match(zap_name_t *zn, const char *matchname)
89da6c28aaSamw {
90da6c28aaSamw 	if (zn->zn_matchtype == MT_FIRST) {
91da6c28aaSamw 		char norm[ZAP_MAXNAMELEN];
92da6c28aaSamw 
93da6c28aaSamw 		if (zap_normalize(zn->zn_zap, matchname, norm) != 0)
94da6c28aaSamw 			return (B_FALSE);
95da6c28aaSamw 
96da6c28aaSamw 		return (strcmp(zn->zn_name_norm, norm) == 0);
97da6c28aaSamw 	} else {
98da6c28aaSamw 		/* MT_BEST or MT_EXACT */
99da6c28aaSamw 		return (strcmp(zn->zn_name_orij, matchname) == 0);
100da6c28aaSamw 	}
101da6c28aaSamw }
102da6c28aaSamw 
103da6c28aaSamw void
104da6c28aaSamw zap_name_free(zap_name_t *zn)
105da6c28aaSamw {
106da6c28aaSamw 	kmem_free(zn, sizeof (zap_name_t));
107da6c28aaSamw }
108da6c28aaSamw 
109da6c28aaSamw /* XXX combine this with zap_lockdir()? */
110da6c28aaSamw zap_name_t *
111da6c28aaSamw zap_name_alloc(zap_t *zap, const char *name, matchtype_t mt)
112da6c28aaSamw {
113da6c28aaSamw 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
114da6c28aaSamw 
115da6c28aaSamw 	zn->zn_zap = zap;
116da6c28aaSamw 	zn->zn_name_orij = name;
117da6c28aaSamw 	zn->zn_matchtype = mt;
118da6c28aaSamw 	if (zap->zap_normflags) {
119da6c28aaSamw 		if (zap_normalize(zap, name, zn->zn_normbuf) != 0) {
120da6c28aaSamw 			zap_name_free(zn);
121da6c28aaSamw 			return (NULL);
122da6c28aaSamw 		}
123da6c28aaSamw 		zn->zn_name_norm = zn->zn_normbuf;
124da6c28aaSamw 	} else {
125da6c28aaSamw 		if (mt != MT_EXACT) {
126da6c28aaSamw 			zap_name_free(zn);
127da6c28aaSamw 			return (NULL);
128da6c28aaSamw 		}
129da6c28aaSamw 		zn->zn_name_norm = zn->zn_name_orij;
130da6c28aaSamw 	}
131da6c28aaSamw 
132da6c28aaSamw 	zn->zn_hash = zap_hash(zap, zn->zn_name_norm);
133da6c28aaSamw 	return (zn);
134da6c28aaSamw }
135da6c28aaSamw 
136fa9e4066Sahrens static void
137fa9e4066Sahrens mzap_byteswap(mzap_phys_t *buf, size_t size)
138fa9e4066Sahrens {
139fa9e4066Sahrens 	int i, max;
140fa9e4066Sahrens 	buf->mz_block_type = BSWAP_64(buf->mz_block_type);
141fa9e4066Sahrens 	buf->mz_salt = BSWAP_64(buf->mz_salt);
142*ab04eb8eStimh 	buf->mz_normflags = BSWAP_64(buf->mz_normflags);
143fa9e4066Sahrens 	max = (size / MZAP_ENT_LEN) - 1;
144fa9e4066Sahrens 	for (i = 0; i < max; i++) {
145fa9e4066Sahrens 		buf->mz_chunk[i].mze_value =
146fa9e4066Sahrens 		    BSWAP_64(buf->mz_chunk[i].mze_value);
147fa9e4066Sahrens 		buf->mz_chunk[i].mze_cd =
148fa9e4066Sahrens 		    BSWAP_32(buf->mz_chunk[i].mze_cd);
149fa9e4066Sahrens 	}
150fa9e4066Sahrens }
151fa9e4066Sahrens 
152fa9e4066Sahrens void
153fa9e4066Sahrens zap_byteswap(void *buf, size_t size)
154fa9e4066Sahrens {
155fa9e4066Sahrens 	uint64_t block_type;
156fa9e4066Sahrens 
157fa9e4066Sahrens 	block_type = *(uint64_t *)buf;
158fa9e4066Sahrens 
1595ad82045Snd 	if (block_type == ZBT_MICRO || block_type == BSWAP_64(ZBT_MICRO)) {
160fa9e4066Sahrens 		/* ASSERT(magic == ZAP_LEAF_MAGIC); */
161fa9e4066Sahrens 		mzap_byteswap(buf, size);
1625ad82045Snd 	} else {
163fa9e4066Sahrens 		fzap_byteswap(buf, size);
164fa9e4066Sahrens 	}
165fa9e4066Sahrens }
166fa9e4066Sahrens 
167fa9e4066Sahrens static int
168fa9e4066Sahrens mze_compare(const void *arg1, const void *arg2)
169fa9e4066Sahrens {
170fa9e4066Sahrens 	const mzap_ent_t *mze1 = arg1;
171fa9e4066Sahrens 	const mzap_ent_t *mze2 = arg2;
172fa9e4066Sahrens 
173fa9e4066Sahrens 	if (mze1->mze_hash > mze2->mze_hash)
174fa9e4066Sahrens 		return (+1);
175fa9e4066Sahrens 	if (mze1->mze_hash < mze2->mze_hash)
176fa9e4066Sahrens 		return (-1);
177fa9e4066Sahrens 	if (mze1->mze_phys.mze_cd > mze2->mze_phys.mze_cd)
178fa9e4066Sahrens 		return (+1);
179fa9e4066Sahrens 	if (mze1->mze_phys.mze_cd < mze2->mze_phys.mze_cd)
180fa9e4066Sahrens 		return (-1);
181fa9e4066Sahrens 	return (0);
182fa9e4066Sahrens }
183fa9e4066Sahrens 
184fa9e4066Sahrens static void
185fa9e4066Sahrens mze_insert(zap_t *zap, int chunkid, uint64_t hash, mzap_ent_phys_t *mzep)
186fa9e4066Sahrens {
187fa9e4066Sahrens 	mzap_ent_t *mze;
188fa9e4066Sahrens 
189fa9e4066Sahrens 	ASSERT(zap->zap_ismicro);
190fa9e4066Sahrens 	ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
191fa9e4066Sahrens 	ASSERT(mzep->mze_cd < ZAP_MAXCD);
192fa9e4066Sahrens 
193fa9e4066Sahrens 	mze = kmem_alloc(sizeof (mzap_ent_t), KM_SLEEP);
194fa9e4066Sahrens 	mze->mze_chunkid = chunkid;
195fa9e4066Sahrens 	mze->mze_hash = hash;
196fa9e4066Sahrens 	mze->mze_phys = *mzep;
197fa9e4066Sahrens 	avl_add(&zap->zap_m.zap_avl, mze);
198fa9e4066Sahrens }
199fa9e4066Sahrens 
200fa9e4066Sahrens static mzap_ent_t *
201da6c28aaSamw mze_find(zap_name_t *zn)
202fa9e4066Sahrens {
203fa9e4066Sahrens 	mzap_ent_t mze_tofind;
204fa9e4066Sahrens 	mzap_ent_t *mze;
205fa9e4066Sahrens 	avl_index_t idx;
206da6c28aaSamw 	avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl;
207fa9e4066Sahrens 
208da6c28aaSamw 	ASSERT(zn->zn_zap->zap_ismicro);
209da6c28aaSamw 	ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock));
210fa9e4066Sahrens 
211da6c28aaSamw 	if (strlen(zn->zn_name_norm) >= sizeof (mze_tofind.mze_phys.mze_name))
212fa9e4066Sahrens 		return (NULL);
213fa9e4066Sahrens 
214da6c28aaSamw 	mze_tofind.mze_hash = zn->zn_hash;
215fa9e4066Sahrens 	mze_tofind.mze_phys.mze_cd = 0;
216fa9e4066Sahrens 
217da6c28aaSamw again:
218fa9e4066Sahrens 	mze = avl_find(avl, &mze_tofind, &idx);
219fa9e4066Sahrens 	if (mze == NULL)
220fa9e4066Sahrens 		mze = avl_nearest(avl, idx, AVL_AFTER);
221da6c28aaSamw 	for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) {
222da6c28aaSamw 		if (zap_match(zn, mze->mze_phys.mze_name))
223fa9e4066Sahrens 			return (mze);
224fa9e4066Sahrens 	}
225da6c28aaSamw 	if (zn->zn_matchtype == MT_BEST) {
226da6c28aaSamw 		zn->zn_matchtype = MT_FIRST;
227da6c28aaSamw 		goto again;
228da6c28aaSamw 	}
229fa9e4066Sahrens 	return (NULL);
230fa9e4066Sahrens }
231fa9e4066Sahrens 
232fa9e4066Sahrens static uint32_t
233fa9e4066Sahrens mze_find_unused_cd(zap_t *zap, uint64_t hash)
234fa9e4066Sahrens {
235fa9e4066Sahrens 	mzap_ent_t mze_tofind;
236fa9e4066Sahrens 	mzap_ent_t *mze;
237fa9e4066Sahrens 	avl_index_t idx;
238fa9e4066Sahrens 	avl_tree_t *avl = &zap->zap_m.zap_avl;
239fa9e4066Sahrens 	uint32_t cd;
240fa9e4066Sahrens 
241fa9e4066Sahrens 	ASSERT(zap->zap_ismicro);
242fa9e4066Sahrens 	ASSERT(RW_LOCK_HELD(&zap->zap_rwlock));
243fa9e4066Sahrens 
244fa9e4066Sahrens 	mze_tofind.mze_hash = hash;
245fa9e4066Sahrens 	mze_tofind.mze_phys.mze_cd = 0;
246fa9e4066Sahrens 
247fa9e4066Sahrens 	cd = 0;
248fa9e4066Sahrens 	for (mze = avl_find(avl, &mze_tofind, &idx);
249fa9e4066Sahrens 	    mze && mze->mze_hash == hash; mze = AVL_NEXT(avl, mze)) {
250fa9e4066Sahrens 		if (mze->mze_phys.mze_cd != cd)
251fa9e4066Sahrens 			break;
252fa9e4066Sahrens 		cd++;
253fa9e4066Sahrens 	}
254fa9e4066Sahrens 
255fa9e4066Sahrens 	return (cd);
256fa9e4066Sahrens }
257fa9e4066Sahrens 
258fa9e4066Sahrens static void
259fa9e4066Sahrens mze_remove(zap_t *zap, mzap_ent_t *mze)
260fa9e4066Sahrens {
261fa9e4066Sahrens 	ASSERT(zap->zap_ismicro);
262fa9e4066Sahrens 	ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
263fa9e4066Sahrens 
264fa9e4066Sahrens 	avl_remove(&zap->zap_m.zap_avl, mze);
265fa9e4066Sahrens 	kmem_free(mze, sizeof (mzap_ent_t));
266fa9e4066Sahrens }
267fa9e4066Sahrens 
268fa9e4066Sahrens static void
269fa9e4066Sahrens mze_destroy(zap_t *zap)
270fa9e4066Sahrens {
271fa9e4066Sahrens 	mzap_ent_t *mze;
272fa9e4066Sahrens 	void *avlcookie = NULL;
273fa9e4066Sahrens 
274fa9e4066Sahrens 	while (mze = avl_destroy_nodes(&zap->zap_m.zap_avl, &avlcookie))
275fa9e4066Sahrens 		kmem_free(mze, sizeof (mzap_ent_t));
276fa9e4066Sahrens 	avl_destroy(&zap->zap_m.zap_avl);
277fa9e4066Sahrens }
278fa9e4066Sahrens 
279fa9e4066Sahrens static zap_t *
280fa9e4066Sahrens mzap_open(objset_t *os, uint64_t obj, dmu_buf_t *db)
281fa9e4066Sahrens {
282fa9e4066Sahrens 	zap_t *winner;
283fa9e4066Sahrens 	zap_t *zap;
284fa9e4066Sahrens 	int i;
285fa9e4066Sahrens 
286fa9e4066Sahrens 	ASSERT3U(MZAP_ENT_LEN, ==, sizeof (mzap_ent_phys_t));
287fa9e4066Sahrens 
288fa9e4066Sahrens 	zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP);
289fa9e4066Sahrens 	rw_init(&zap->zap_rwlock, 0, 0, 0);
290fa9e4066Sahrens 	rw_enter(&zap->zap_rwlock, RW_WRITER);
291fa9e4066Sahrens 	zap->zap_objset = os;
292fa9e4066Sahrens 	zap->zap_object = obj;
293fa9e4066Sahrens 	zap->zap_dbuf = db;
294fa9e4066Sahrens 
295da6c28aaSamw 	if (*(uint64_t *)db->db_data != ZBT_MICRO) {
296fa9e4066Sahrens 		mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0);
297f65e61c0Sahrens 		zap->zap_f.zap_block_shift = highbit(db->db_size) - 1;
298fa9e4066Sahrens 	} else {
299fa9e4066Sahrens 		zap->zap_ismicro = TRUE;
300fa9e4066Sahrens 	}
301fa9e4066Sahrens 
302fa9e4066Sahrens 	/*
303fa9e4066Sahrens 	 * Make sure that zap_ismicro is set before we let others see
304fa9e4066Sahrens 	 * it, because zap_lockdir() checks zap_ismicro without the lock
305fa9e4066Sahrens 	 * held.
306fa9e4066Sahrens 	 */
307455d5089Sahrens 	winner = dmu_buf_set_user(db, zap, &zap->zap_m.zap_phys, zap_evict);
308fa9e4066Sahrens 
309fa9e4066Sahrens 	if (winner != NULL) {
310c25056deSgw 		rw_exit(&zap->zap_rwlock);
311c25056deSgw 		rw_destroy(&zap->zap_rwlock);
312c25056deSgw 		if (!zap->zap_ismicro)
313c25056deSgw 			mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
314fa9e4066Sahrens 		kmem_free(zap, sizeof (zap_t));
315fa9e4066Sahrens 		return (winner);
316fa9e4066Sahrens 	}
317fa9e4066Sahrens 
318fa9e4066Sahrens 	if (zap->zap_ismicro) {
319fa9e4066Sahrens 		zap->zap_salt = zap->zap_m.zap_phys->mz_salt;
320da6c28aaSamw 		zap->zap_normflags = zap->zap_m.zap_phys->mz_normflags;
321fa9e4066Sahrens 		zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1;
322fa9e4066Sahrens 		avl_create(&zap->zap_m.zap_avl, mze_compare,
323fa9e4066Sahrens 		    sizeof (mzap_ent_t), offsetof(mzap_ent_t, mze_node));
324fa9e4066Sahrens 
325fa9e4066Sahrens 		for (i = 0; i < zap->zap_m.zap_num_chunks; i++) {
326fa9e4066Sahrens 			mzap_ent_phys_t *mze =
327fa9e4066Sahrens 			    &zap->zap_m.zap_phys->mz_chunk[i];
328fa9e4066Sahrens 			if (mze->mze_name[0]) {
329da6c28aaSamw 				zap_name_t *zn;
330da6c28aaSamw 
331fa9e4066Sahrens 				zap->zap_m.zap_num_entries++;
332da6c28aaSamw 				zn = zap_name_alloc(zap, mze->mze_name,
333da6c28aaSamw 				    MT_EXACT);
334da6c28aaSamw 				mze_insert(zap, i, zn->zn_hash, mze);
335da6c28aaSamw 				zap_name_free(zn);
336fa9e4066Sahrens 			}
337fa9e4066Sahrens 		}
338fa9e4066Sahrens 	} else {
339fa9e4066Sahrens 		zap->zap_salt = zap->zap_f.zap_phys->zap_salt;
340da6c28aaSamw 		zap->zap_normflags = zap->zap_f.zap_phys->zap_normflags;
341f65e61c0Sahrens 
342f65e61c0Sahrens 		ASSERT3U(sizeof (struct zap_leaf_header), ==,
343f65e61c0Sahrens 		    2*ZAP_LEAF_CHUNKSIZE);
344f65e61c0Sahrens 
345f65e61c0Sahrens 		/*
346f65e61c0Sahrens 		 * The embedded pointer table should not overlap the
347f65e61c0Sahrens 		 * other members.
348f65e61c0Sahrens 		 */
349f65e61c0Sahrens 		ASSERT3P(&ZAP_EMBEDDED_PTRTBL_ENT(zap, 0), >,
350f65e61c0Sahrens 		    &zap->zap_f.zap_phys->zap_salt);
351f65e61c0Sahrens 
352f65e61c0Sahrens 		/*
353f65e61c0Sahrens 		 * The embedded pointer table should end at the end of
354f65e61c0Sahrens 		 * the block
355f65e61c0Sahrens 		 */
356f65e61c0Sahrens 		ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap,
357f65e61c0Sahrens 		    1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) -
358f65e61c0Sahrens 		    (uintptr_t)zap->zap_f.zap_phys, ==,
359f65e61c0Sahrens 		    zap->zap_dbuf->db_size);
360fa9e4066Sahrens 	}
361fa9e4066Sahrens 	rw_exit(&zap->zap_rwlock);
362fa9e4066Sahrens 	return (zap);
363fa9e4066Sahrens }
364fa9e4066Sahrens 
365fa9e4066Sahrens int
366fa9e4066Sahrens zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx,
367c5f9e431Sahrens     krw_t lti, boolean_t fatreader, boolean_t adding, zap_t **zapp)
368fa9e4066Sahrens {
369fa9e4066Sahrens 	zap_t *zap;
370fa9e4066Sahrens 	dmu_buf_t *db;
371fa9e4066Sahrens 	krw_t lt;
372fa9e4066Sahrens 	int err;
373fa9e4066Sahrens 
374fa9e4066Sahrens 	*zapp = NULL;
375fa9e4066Sahrens 
376ea8dc4b6Seschrock 	err = dmu_buf_hold(os, obj, 0, NULL, &db);
377ea8dc4b6Seschrock 	if (err)
378ea8dc4b6Seschrock 		return (err);
379fa9e4066Sahrens 
380fa9e4066Sahrens #ifdef ZFS_DEBUG
381fa9e4066Sahrens 	{
382fa9e4066Sahrens 		dmu_object_info_t doi;
383fa9e4066Sahrens 		dmu_object_info_from_db(db, &doi);
384fa9e4066Sahrens 		ASSERT(dmu_ot[doi.doi_type].ot_byteswap == zap_byteswap);
385fa9e4066Sahrens 	}
386fa9e4066Sahrens #endif
387fa9e4066Sahrens 
388fa9e4066Sahrens 	zap = dmu_buf_get_user(db);
389fa9e4066Sahrens 	if (zap == NULL)
390fa9e4066Sahrens 		zap = mzap_open(os, obj, db);
391fa9e4066Sahrens 
392fa9e4066Sahrens 	/*
393fa9e4066Sahrens 	 * We're checking zap_ismicro without the lock held, in order to
394fa9e4066Sahrens 	 * tell what type of lock we want.  Once we have some sort of
395fa9e4066Sahrens 	 * lock, see if it really is the right type.  In practice this
396fa9e4066Sahrens 	 * can only be different if it was upgraded from micro to fat,
397fa9e4066Sahrens 	 * and micro wanted WRITER but fat only needs READER.
398fa9e4066Sahrens 	 */
399fa9e4066Sahrens 	lt = (!zap->zap_ismicro && fatreader) ? RW_READER : lti;
400fa9e4066Sahrens 	rw_enter(&zap->zap_rwlock, lt);
401fa9e4066Sahrens 	if (lt != ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)) {
402fa9e4066Sahrens 		/* it was upgraded, now we only need reader */
403fa9e4066Sahrens 		ASSERT(lt == RW_WRITER);
404fa9e4066Sahrens 		ASSERT(RW_READER ==
405fa9e4066Sahrens 		    (!zap->zap_ismicro && fatreader) ? RW_READER : lti);
406fa9e4066Sahrens 		rw_downgrade(&zap->zap_rwlock);
407fa9e4066Sahrens 		lt = RW_READER;
408fa9e4066Sahrens 	}
409fa9e4066Sahrens 
410fa9e4066Sahrens 	zap->zap_objset = os;
411fa9e4066Sahrens 
412fa9e4066Sahrens 	if (lt == RW_WRITER)
413fa9e4066Sahrens 		dmu_buf_will_dirty(db, tx);
414fa9e4066Sahrens 
415fa9e4066Sahrens 	ASSERT3P(zap->zap_dbuf, ==, db);
416fa9e4066Sahrens 
417fa9e4066Sahrens 	ASSERT(!zap->zap_ismicro ||
418fa9e4066Sahrens 	    zap->zap_m.zap_num_entries <= zap->zap_m.zap_num_chunks);
419c5f9e431Sahrens 	if (zap->zap_ismicro && tx && adding &&
420fa9e4066Sahrens 	    zap->zap_m.zap_num_entries == zap->zap_m.zap_num_chunks) {
421fa9e4066Sahrens 		uint64_t newsz = db->db_size + SPA_MINBLOCKSIZE;
422fa9e4066Sahrens 		if (newsz > MZAP_MAX_BLKSZ) {
423fa9e4066Sahrens 			dprintf("upgrading obj %llu: num_entries=%u\n",
424fa9e4066Sahrens 			    obj, zap->zap_m.zap_num_entries);
425fa9e4066Sahrens 			*zapp = zap;
426ad860c82Sbonwick 			return (mzap_upgrade(zapp, tx));
427fa9e4066Sahrens 		}
428fa9e4066Sahrens 		err = dmu_object_set_blocksize(os, obj, newsz, 0, tx);
429fa9e4066Sahrens 		ASSERT3U(err, ==, 0);
430fa9e4066Sahrens 		zap->zap_m.zap_num_chunks =
431fa9e4066Sahrens 		    db->db_size / MZAP_ENT_LEN - 1;
432fa9e4066Sahrens 	}
433fa9e4066Sahrens 
434fa9e4066Sahrens 	*zapp = zap;
435fa9e4066Sahrens 	return (0);
436fa9e4066Sahrens }
437fa9e4066Sahrens 
438fa9e4066Sahrens void
439fa9e4066Sahrens zap_unlockdir(zap_t *zap)
440fa9e4066Sahrens {
441fa9e4066Sahrens 	rw_exit(&zap->zap_rwlock);
442ea8dc4b6Seschrock 	dmu_buf_rele(zap->zap_dbuf, NULL);
443fa9e4066Sahrens }
444fa9e4066Sahrens 
445ad860c82Sbonwick static int
446ad860c82Sbonwick mzap_upgrade(zap_t **zapp, dmu_tx_t *tx)
447fa9e4066Sahrens {
448fa9e4066Sahrens 	mzap_phys_t *mzp;
449fa9e4066Sahrens 	int i, sz, nchunks, err;
450ad860c82Sbonwick 	zap_t *zap = *zapp;
451fa9e4066Sahrens 
452fa9e4066Sahrens 	ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
453fa9e4066Sahrens 
454fa9e4066Sahrens 	sz = zap->zap_dbuf->db_size;
455fa9e4066Sahrens 	mzp = kmem_alloc(sz, KM_SLEEP);
456fa9e4066Sahrens 	bcopy(zap->zap_dbuf->db_data, mzp, sz);
457fa9e4066Sahrens 	nchunks = zap->zap_m.zap_num_chunks;
458fa9e4066Sahrens 
459fa9e4066Sahrens 	err = dmu_object_set_blocksize(zap->zap_objset, zap->zap_object,
460f65e61c0Sahrens 	    1ULL << fzap_default_block_shift, 0, tx);
461ad860c82Sbonwick 	if (err) {
462ad860c82Sbonwick 		kmem_free(mzp, sz);
463ad860c82Sbonwick 		return (err);
464ad860c82Sbonwick 	}
465fa9e4066Sahrens 
466fa9e4066Sahrens 	dprintf("upgrading obj=%llu with %u chunks\n",
467fa9e4066Sahrens 	    zap->zap_object, nchunks);
468da6c28aaSamw 	/* XXX destroy the avl later, so we can use the stored hash value */
469fa9e4066Sahrens 	mze_destroy(zap);
470fa9e4066Sahrens 
471fa9e4066Sahrens 	fzap_upgrade(zap, tx);
472fa9e4066Sahrens 
473fa9e4066Sahrens 	for (i = 0; i < nchunks; i++) {
474fa9e4066Sahrens 		int err;
475fa9e4066Sahrens 		mzap_ent_phys_t *mze = &mzp->mz_chunk[i];
476da6c28aaSamw 		zap_name_t *zn;
477fa9e4066Sahrens 		if (mze->mze_name[0] == 0)
478fa9e4066Sahrens 			continue;
479fa9e4066Sahrens 		dprintf("adding %s=%llu\n",
480fa9e4066Sahrens 		    mze->mze_name, mze->mze_value);
481da6c28aaSamw 		zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT);
482ad860c82Sbonwick 		err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, tx);
483ad860c82Sbonwick 		zap = zn->zn_zap;	/* fzap_add_cd() may change zap */
484da6c28aaSamw 		zap_name_free(zn);
485ad860c82Sbonwick 		if (err)
486ad860c82Sbonwick 			break;
487fa9e4066Sahrens 	}
488fa9e4066Sahrens 	kmem_free(mzp, sz);
489ad860c82Sbonwick 	*zapp = zap;
490ad860c82Sbonwick 	return (err);
491fa9e4066Sahrens }
492fa9e4066Sahrens 
493fa9e4066Sahrens static void
494da6c28aaSamw mzap_create_impl(objset_t *os, uint64_t obj, int normflags, dmu_tx_t *tx)
495fa9e4066Sahrens {
496fa9e4066Sahrens 	dmu_buf_t *db;
497fa9e4066Sahrens 	mzap_phys_t *zp;
498fa9e4066Sahrens 
499ea8dc4b6Seschrock 	VERIFY(0 == dmu_buf_hold(os, obj, 0, FTAG, &db));
500fa9e4066Sahrens 
501fa9e4066Sahrens #ifdef ZFS_DEBUG
502fa9e4066Sahrens 	{
503fa9e4066Sahrens 		dmu_object_info_t doi;
504fa9e4066Sahrens 		dmu_object_info_from_db(db, &doi);
505fa9e4066Sahrens 		ASSERT(dmu_ot[doi.doi_type].ot_byteswap == zap_byteswap);
506fa9e4066Sahrens 	}
507fa9e4066Sahrens #endif
508fa9e4066Sahrens 
509fa9e4066Sahrens 	dmu_buf_will_dirty(db, tx);
510fa9e4066Sahrens 	zp = db->db_data;
511fa9e4066Sahrens 	zp->mz_block_type = ZBT_MICRO;
512fa9e4066Sahrens 	zp->mz_salt = ((uintptr_t)db ^ (uintptr_t)tx ^ (obj << 1)) | 1ULL;
513da6c28aaSamw 	zp->mz_normflags = normflags;
514ea8dc4b6Seschrock 	dmu_buf_rele(db, FTAG);
515fa9e4066Sahrens }
516fa9e4066Sahrens 
517fa9e4066Sahrens int
518fa9e4066Sahrens zap_create_claim(objset_t *os, uint64_t obj, dmu_object_type_t ot,
519fa9e4066Sahrens     dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
520da6c28aaSamw {
521da6c28aaSamw 	return (zap_create_claim_norm(os, obj,
522da6c28aaSamw 	    0, ot, bonustype, bonuslen, tx));
523da6c28aaSamw }
524da6c28aaSamw 
525da6c28aaSamw int
526da6c28aaSamw zap_create_claim_norm(objset_t *os, uint64_t obj, int normflags,
527da6c28aaSamw     dmu_object_type_t ot,
528da6c28aaSamw     dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
529fa9e4066Sahrens {
530fa9e4066Sahrens 	int err;
531fa9e4066Sahrens 
532fa9e4066Sahrens 	err = dmu_object_claim(os, obj, ot, 0, bonustype, bonuslen, tx);
533fa9e4066Sahrens 	if (err != 0)
534fa9e4066Sahrens 		return (err);
535da6c28aaSamw 	mzap_create_impl(os, obj, normflags, tx);
536fa9e4066Sahrens 	return (0);
537fa9e4066Sahrens }
538fa9e4066Sahrens 
539fa9e4066Sahrens uint64_t
540fa9e4066Sahrens zap_create(objset_t *os, dmu_object_type_t ot,
541fa9e4066Sahrens     dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
542da6c28aaSamw {
543da6c28aaSamw 	return (zap_create_norm(os, 0, ot, bonustype, bonuslen, tx));
544da6c28aaSamw }
545da6c28aaSamw 
546da6c28aaSamw uint64_t
547da6c28aaSamw zap_create_norm(objset_t *os, int normflags, dmu_object_type_t ot,
548da6c28aaSamw     dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx)
549fa9e4066Sahrens {
550fa9e4066Sahrens 	uint64_t obj = dmu_object_alloc(os, ot, 0, bonustype, bonuslen, tx);
551fa9e4066Sahrens 
552da6c28aaSamw 	mzap_create_impl(os, obj, normflags, tx);
553fa9e4066Sahrens 	return (obj);
554fa9e4066Sahrens }
555fa9e4066Sahrens 
556fa9e4066Sahrens int
557fa9e4066Sahrens zap_destroy(objset_t *os, uint64_t zapobj, dmu_tx_t *tx)
558fa9e4066Sahrens {
559fa9e4066Sahrens 	/*
560fa9e4066Sahrens 	 * dmu_object_free will free the object number and free the
561fa9e4066Sahrens 	 * data.  Freeing the data will cause our pageout function to be
562fa9e4066Sahrens 	 * called, which will destroy our data (zap_leaf_t's and zap_t).
563fa9e4066Sahrens 	 */
564fa9e4066Sahrens 
565fa9e4066Sahrens 	return (dmu_object_free(os, zapobj, tx));
566fa9e4066Sahrens }
567fa9e4066Sahrens 
568fa9e4066Sahrens _NOTE(ARGSUSED(0))
569fa9e4066Sahrens void
570455d5089Sahrens zap_evict(dmu_buf_t *db, void *vzap)
571fa9e4066Sahrens {
572455d5089Sahrens 	zap_t *zap = vzap;
573fa9e4066Sahrens 
574fa9e4066Sahrens 	rw_destroy(&zap->zap_rwlock);
575fa9e4066Sahrens 
576f65e61c0Sahrens 	if (zap->zap_ismicro)
577fa9e4066Sahrens 		mze_destroy(zap);
578c25056deSgw 	else
579c25056deSgw 		mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
580fa9e4066Sahrens 
581fa9e4066Sahrens 	kmem_free(zap, sizeof (zap_t));
582fa9e4066Sahrens }
583fa9e4066Sahrens 
584fa9e4066Sahrens int
585fa9e4066Sahrens zap_count(objset_t *os, uint64_t zapobj, uint64_t *count)
586fa9e4066Sahrens {
587fa9e4066Sahrens 	zap_t *zap;
588fa9e4066Sahrens 	int err;
589fa9e4066Sahrens 
590c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap);
591fa9e4066Sahrens 	if (err)
592fa9e4066Sahrens 		return (err);
593fa9e4066Sahrens 	if (!zap->zap_ismicro) {
594fa9e4066Sahrens 		err = fzap_count(zap, count);
595fa9e4066Sahrens 	} else {
596fa9e4066Sahrens 		*count = zap->zap_m.zap_num_entries;
597fa9e4066Sahrens 	}
598fa9e4066Sahrens 	zap_unlockdir(zap);
599fa9e4066Sahrens 	return (err);
600fa9e4066Sahrens }
601fa9e4066Sahrens 
602fa9e4066Sahrens /*
603da6c28aaSamw  * zn may be NULL; if not specified, it will be computed if needed.
604da6c28aaSamw  * See also the comment above zap_entry_normalization_conflict().
605da6c28aaSamw  */
606da6c28aaSamw static boolean_t
607da6c28aaSamw mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
608da6c28aaSamw {
609da6c28aaSamw 	mzap_ent_t *other;
610da6c28aaSamw 	int direction = AVL_BEFORE;
611da6c28aaSamw 	boolean_t allocdzn = B_FALSE;
612da6c28aaSamw 
613da6c28aaSamw 	if (zap->zap_normflags == 0)
614da6c28aaSamw 		return (B_FALSE);
615da6c28aaSamw 
616da6c28aaSamw again:
617da6c28aaSamw 	for (other = avl_walk(&zap->zap_m.zap_avl, mze, direction);
618da6c28aaSamw 	    other && other->mze_hash == mze->mze_hash;
619da6c28aaSamw 	    other = avl_walk(&zap->zap_m.zap_avl, other, direction)) {
620da6c28aaSamw 
621da6c28aaSamw 		if (zn == NULL) {
622da6c28aaSamw 			zn = zap_name_alloc(zap, mze->mze_phys.mze_name,
623da6c28aaSamw 			    MT_FIRST);
624da6c28aaSamw 			allocdzn = B_TRUE;
625da6c28aaSamw 		}
626da6c28aaSamw 		if (zap_match(zn, other->mze_phys.mze_name)) {
627da6c28aaSamw 			if (allocdzn)
628da6c28aaSamw 				zap_name_free(zn);
629da6c28aaSamw 			return (B_TRUE);
630da6c28aaSamw 		}
631da6c28aaSamw 	}
632da6c28aaSamw 
633da6c28aaSamw 	if (direction == AVL_BEFORE) {
634da6c28aaSamw 		direction = AVL_AFTER;
635da6c28aaSamw 		goto again;
636da6c28aaSamw 	}
637da6c28aaSamw 
638da6c28aaSamw 	if (allocdzn)
639da6c28aaSamw 		zap_name_free(zn);
640da6c28aaSamw 	return (B_FALSE);
641da6c28aaSamw }
642da6c28aaSamw 
643da6c28aaSamw /*
644da6c28aaSamw  * Routines for manipulating attributes.
645fa9e4066Sahrens  */
646fa9e4066Sahrens 
647fa9e4066Sahrens int
648fa9e4066Sahrens zap_lookup(objset_t *os, uint64_t zapobj, const char *name,
649fa9e4066Sahrens     uint64_t integer_size, uint64_t num_integers, void *buf)
650da6c28aaSamw {
651da6c28aaSamw 	return (zap_lookup_norm(os, zapobj, name, integer_size,
652da6c28aaSamw 	    num_integers, buf, MT_EXACT, NULL, 0, NULL));
653da6c28aaSamw }
654da6c28aaSamw 
655da6c28aaSamw int
656da6c28aaSamw zap_lookup_norm(objset_t *os, uint64_t zapobj, const char *name,
657da6c28aaSamw     uint64_t integer_size, uint64_t num_integers, void *buf,
658da6c28aaSamw     matchtype_t mt, char *realname, int rn_len,
659da6c28aaSamw     boolean_t *ncp)
660fa9e4066Sahrens {
661fa9e4066Sahrens 	zap_t *zap;
662fa9e4066Sahrens 	int err;
663fa9e4066Sahrens 	mzap_ent_t *mze;
664da6c28aaSamw 	zap_name_t *zn;
665fa9e4066Sahrens 
666c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap);
667fa9e4066Sahrens 	if (err)
668fa9e4066Sahrens 		return (err);
669da6c28aaSamw 	zn = zap_name_alloc(zap, name, mt);
670da6c28aaSamw 	if (zn == NULL) {
671da6c28aaSamw 		zap_unlockdir(zap);
672da6c28aaSamw 		return (ENOTSUP);
673da6c28aaSamw 	}
674da6c28aaSamw 
675fa9e4066Sahrens 	if (!zap->zap_ismicro) {
676da6c28aaSamw 		err = fzap_lookup(zn, integer_size, num_integers, buf,
677da6c28aaSamw 		    realname, rn_len, ncp);
678fa9e4066Sahrens 	} else {
679da6c28aaSamw 		mze = mze_find(zn);
680fa9e4066Sahrens 		if (mze == NULL) {
681fa9e4066Sahrens 			err = ENOENT;
682fa9e4066Sahrens 		} else {
683da6c28aaSamw 			if (num_integers < 1) {
684fa9e4066Sahrens 				err = EOVERFLOW;
685da6c28aaSamw 			} else if (integer_size != 8) {
686fa9e4066Sahrens 				err = EINVAL;
687da6c28aaSamw 			} else {
688fa9e4066Sahrens 				*(uint64_t *)buf = mze->mze_phys.mze_value;
689da6c28aaSamw 				(void) strlcpy(realname,
690da6c28aaSamw 				    mze->mze_phys.mze_name, rn_len);
691da6c28aaSamw 				if (ncp) {
692da6c28aaSamw 					*ncp = mzap_normalization_conflict(zap,
693da6c28aaSamw 					    zn, mze);
694da6c28aaSamw 				}
695da6c28aaSamw 			}
696fa9e4066Sahrens 		}
697fa9e4066Sahrens 	}
698da6c28aaSamw 	zap_name_free(zn);
699fa9e4066Sahrens 	zap_unlockdir(zap);
700fa9e4066Sahrens 	return (err);
701fa9e4066Sahrens }
702fa9e4066Sahrens 
703fa9e4066Sahrens int
704fa9e4066Sahrens zap_length(objset_t *os, uint64_t zapobj, const char *name,
705fa9e4066Sahrens     uint64_t *integer_size, uint64_t *num_integers)
706fa9e4066Sahrens {
707fa9e4066Sahrens 	zap_t *zap;
708fa9e4066Sahrens 	int err;
709fa9e4066Sahrens 	mzap_ent_t *mze;
710da6c28aaSamw 	zap_name_t *zn;
711fa9e4066Sahrens 
712c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap);
713fa9e4066Sahrens 	if (err)
714fa9e4066Sahrens 		return (err);
715da6c28aaSamw 	zn = zap_name_alloc(zap, name, MT_EXACT);
716da6c28aaSamw 	if (zn == NULL) {
717da6c28aaSamw 		zap_unlockdir(zap);
718da6c28aaSamw 		return (ENOTSUP);
719da6c28aaSamw 	}
720fa9e4066Sahrens 	if (!zap->zap_ismicro) {
721da6c28aaSamw 		err = fzap_length(zn, integer_size, num_integers);
722fa9e4066Sahrens 	} else {
723da6c28aaSamw 		mze = mze_find(zn);
724fa9e4066Sahrens 		if (mze == NULL) {
725fa9e4066Sahrens 			err = ENOENT;
726fa9e4066Sahrens 		} else {
727fa9e4066Sahrens 			if (integer_size)
728fa9e4066Sahrens 				*integer_size = 8;
729fa9e4066Sahrens 			if (num_integers)
730fa9e4066Sahrens 				*num_integers = 1;
731fa9e4066Sahrens 		}
732fa9e4066Sahrens 	}
733da6c28aaSamw 	zap_name_free(zn);
734fa9e4066Sahrens 	zap_unlockdir(zap);
735fa9e4066Sahrens 	return (err);
736fa9e4066Sahrens }
737fa9e4066Sahrens 
738fa9e4066Sahrens static void
739da6c28aaSamw mzap_addent(zap_name_t *zn, uint64_t value)
740fa9e4066Sahrens {
741fa9e4066Sahrens 	int i;
742da6c28aaSamw 	zap_t *zap = zn->zn_zap;
743fa9e4066Sahrens 	int start = zap->zap_m.zap_alloc_next;
744fa9e4066Sahrens 	uint32_t cd;
745fa9e4066Sahrens 
746da6c28aaSamw 	dprintf("obj=%llu %s=%llu\n", zap->zap_object,
747da6c28aaSamw 	    zn->zn_name_orij, value);
748fa9e4066Sahrens 	ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
749fa9e4066Sahrens 
750fa9e4066Sahrens #ifdef ZFS_DEBUG
751fa9e4066Sahrens 	for (i = 0; i < zap->zap_m.zap_num_chunks; i++) {
752fa9e4066Sahrens 		mzap_ent_phys_t *mze = &zap->zap_m.zap_phys->mz_chunk[i];
753da6c28aaSamw 		ASSERT(strcmp(zn->zn_name_orij, mze->mze_name) != 0);
754fa9e4066Sahrens 	}
755fa9e4066Sahrens #endif
756fa9e4066Sahrens 
757da6c28aaSamw 	cd = mze_find_unused_cd(zap, zn->zn_hash);
758fa9e4066Sahrens 	/* given the limited size of the microzap, this can't happen */
759fa9e4066Sahrens 	ASSERT(cd != ZAP_MAXCD);
760fa9e4066Sahrens 
761fa9e4066Sahrens again:
762fa9e4066Sahrens 	for (i = start; i < zap->zap_m.zap_num_chunks; i++) {
763fa9e4066Sahrens 		mzap_ent_phys_t *mze = &zap->zap_m.zap_phys->mz_chunk[i];
764fa9e4066Sahrens 		if (mze->mze_name[0] == 0) {
765fa9e4066Sahrens 			mze->mze_value = value;
766fa9e4066Sahrens 			mze->mze_cd = cd;
767da6c28aaSamw 			(void) strcpy(mze->mze_name, zn->zn_name_orij);
768fa9e4066Sahrens 			zap->zap_m.zap_num_entries++;
769fa9e4066Sahrens 			zap->zap_m.zap_alloc_next = i+1;
770fa9e4066Sahrens 			if (zap->zap_m.zap_alloc_next ==
771fa9e4066Sahrens 			    zap->zap_m.zap_num_chunks)
772fa9e4066Sahrens 				zap->zap_m.zap_alloc_next = 0;
773da6c28aaSamw 			mze_insert(zap, i, zn->zn_hash, mze);
774fa9e4066Sahrens 			return;
775fa9e4066Sahrens 		}
776fa9e4066Sahrens 	}
777fa9e4066Sahrens 	if (start != 0) {
778fa9e4066Sahrens 		start = 0;
779fa9e4066Sahrens 		goto again;
780fa9e4066Sahrens 	}
781fa9e4066Sahrens 	ASSERT(!"out of entries!");
782fa9e4066Sahrens }
783fa9e4066Sahrens 
784fa9e4066Sahrens int
785fa9e4066Sahrens zap_add(objset_t *os, uint64_t zapobj, const char *name,
786fa9e4066Sahrens     int integer_size, uint64_t num_integers,
787fa9e4066Sahrens     const void *val, dmu_tx_t *tx)
788fa9e4066Sahrens {
789fa9e4066Sahrens 	zap_t *zap;
790fa9e4066Sahrens 	int err;
791fa9e4066Sahrens 	mzap_ent_t *mze;
792fa9e4066Sahrens 	const uint64_t *intval = val;
793da6c28aaSamw 	zap_name_t *zn;
794fa9e4066Sahrens 
795c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap);
796fa9e4066Sahrens 	if (err)
797fa9e4066Sahrens 		return (err);
798da6c28aaSamw 	zn = zap_name_alloc(zap, name, MT_EXACT);
799da6c28aaSamw 	if (zn == NULL) {
800da6c28aaSamw 		zap_unlockdir(zap);
801da6c28aaSamw 		return (ENOTSUP);
802da6c28aaSamw 	}
803fa9e4066Sahrens 	if (!zap->zap_ismicro) {
804da6c28aaSamw 		err = fzap_add(zn, integer_size, num_integers, val, tx);
805ad860c82Sbonwick 		zap = zn->zn_zap;	/* fzap_add() may change zap */
806fa9e4066Sahrens 	} else if (integer_size != 8 || num_integers != 1 ||
807fa9e4066Sahrens 	    strlen(name) >= MZAP_NAME_LEN) {
808fa9e4066Sahrens 		dprintf("upgrading obj %llu: intsz=%u numint=%llu name=%s\n",
809fa9e4066Sahrens 		    zapobj, integer_size, num_integers, name);
810ad860c82Sbonwick 		err = mzap_upgrade(&zn->zn_zap, tx);
811ad860c82Sbonwick 		if (err == 0)
812ad860c82Sbonwick 			err = fzap_add(zn, integer_size, num_integers, val, tx);
813ad860c82Sbonwick 		zap = zn->zn_zap;	/* fzap_add() may change zap */
814fa9e4066Sahrens 	} else {
815da6c28aaSamw 		mze = mze_find(zn);
816fa9e4066Sahrens 		if (mze != NULL) {
817fa9e4066Sahrens 			err = EEXIST;
818fa9e4066Sahrens 		} else {
819da6c28aaSamw 			mzap_addent(zn, *intval);
820fa9e4066Sahrens 		}
821fa9e4066Sahrens 	}
822ad860c82Sbonwick 	ASSERT(zap == zn->zn_zap);
823da6c28aaSamw 	zap_name_free(zn);
824ad860c82Sbonwick 	if (zap != NULL)	/* may be NULL if fzap_add() failed */
825ad860c82Sbonwick 		zap_unlockdir(zap);
826fa9e4066Sahrens 	return (err);
827fa9e4066Sahrens }
828fa9e4066Sahrens 
829fa9e4066Sahrens int
830fa9e4066Sahrens zap_update(objset_t *os, uint64_t zapobj, const char *name,
831fa9e4066Sahrens     int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx)
832fa9e4066Sahrens {
833fa9e4066Sahrens 	zap_t *zap;
834fa9e4066Sahrens 	mzap_ent_t *mze;
835fa9e4066Sahrens 	const uint64_t *intval = val;
836da6c28aaSamw 	zap_name_t *zn;
837fa9e4066Sahrens 	int err;
838fa9e4066Sahrens 
839c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap);
840fa9e4066Sahrens 	if (err)
841fa9e4066Sahrens 		return (err);
842da6c28aaSamw 	zn = zap_name_alloc(zap, name, MT_EXACT);
843da6c28aaSamw 	if (zn == NULL) {
844da6c28aaSamw 		zap_unlockdir(zap);
845da6c28aaSamw 		return (ENOTSUP);
846da6c28aaSamw 	}
847fa9e4066Sahrens 	if (!zap->zap_ismicro) {
848da6c28aaSamw 		err = fzap_update(zn, integer_size, num_integers, val, tx);
849ad860c82Sbonwick 		zap = zn->zn_zap;	/* fzap_update() may change zap */
850fa9e4066Sahrens 	} else if (integer_size != 8 || num_integers != 1 ||
851fa9e4066Sahrens 	    strlen(name) >= MZAP_NAME_LEN) {
852fa9e4066Sahrens 		dprintf("upgrading obj %llu: intsz=%u numint=%llu name=%s\n",
853fa9e4066Sahrens 		    zapobj, integer_size, num_integers, name);
854ad860c82Sbonwick 		err = mzap_upgrade(&zn->zn_zap, tx);
855ad860c82Sbonwick 		if (err == 0)
856ad860c82Sbonwick 			err = fzap_update(zn, integer_size, num_integers,
857ad860c82Sbonwick 			    val, tx);
858ad860c82Sbonwick 		zap = zn->zn_zap;	/* fzap_update() may change zap */
859fa9e4066Sahrens 	} else {
860da6c28aaSamw 		mze = mze_find(zn);
861fa9e4066Sahrens 		if (mze != NULL) {
862fa9e4066Sahrens 			mze->mze_phys.mze_value = *intval;
863fa9e4066Sahrens 			zap->zap_m.zap_phys->mz_chunk
864fa9e4066Sahrens 			    [mze->mze_chunkid].mze_value = *intval;
865fa9e4066Sahrens 		} else {
866da6c28aaSamw 			mzap_addent(zn, *intval);
867fa9e4066Sahrens 		}
868fa9e4066Sahrens 	}
869ad860c82Sbonwick 	ASSERT(zap == zn->zn_zap);
870da6c28aaSamw 	zap_name_free(zn);
871ad860c82Sbonwick 	if (zap != NULL)	/* may be NULL if fzap_upgrade() failed */
872ad860c82Sbonwick 		zap_unlockdir(zap);
873455d5089Sahrens 	return (err);
874fa9e4066Sahrens }
875fa9e4066Sahrens 
876fa9e4066Sahrens int
877fa9e4066Sahrens zap_remove(objset_t *os, uint64_t zapobj, const char *name, dmu_tx_t *tx)
878da6c28aaSamw {
879da6c28aaSamw 	return (zap_remove_norm(os, zapobj, name, MT_EXACT, tx));
880da6c28aaSamw }
881da6c28aaSamw 
882da6c28aaSamw int
883da6c28aaSamw zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name,
884da6c28aaSamw     matchtype_t mt, dmu_tx_t *tx)
885fa9e4066Sahrens {
886fa9e4066Sahrens 	zap_t *zap;
887fa9e4066Sahrens 	int err;
888fa9e4066Sahrens 	mzap_ent_t *mze;
889da6c28aaSamw 	zap_name_t *zn;
890fa9e4066Sahrens 
891c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, &zap);
892fa9e4066Sahrens 	if (err)
893fa9e4066Sahrens 		return (err);
894da6c28aaSamw 	zn = zap_name_alloc(zap, name, mt);
895da6c28aaSamw 	if (zn == NULL) {
896da6c28aaSamw 		zap_unlockdir(zap);
897da6c28aaSamw 		return (ENOTSUP);
898da6c28aaSamw 	}
899fa9e4066Sahrens 	if (!zap->zap_ismicro) {
900da6c28aaSamw 		err = fzap_remove(zn, tx);
901fa9e4066Sahrens 	} else {
902da6c28aaSamw 		mze = mze_find(zn);
903fa9e4066Sahrens 		if (mze == NULL) {
904fa9e4066Sahrens 			err = ENOENT;
905fa9e4066Sahrens 		} else {
906fa9e4066Sahrens 			zap->zap_m.zap_num_entries--;
907fa9e4066Sahrens 			bzero(&zap->zap_m.zap_phys->mz_chunk[mze->mze_chunkid],
908fa9e4066Sahrens 			    sizeof (mzap_ent_phys_t));
909fa9e4066Sahrens 			mze_remove(zap, mze);
910fa9e4066Sahrens 		}
911fa9e4066Sahrens 	}
912da6c28aaSamw 	zap_name_free(zn);
913fa9e4066Sahrens 	zap_unlockdir(zap);
914fa9e4066Sahrens 	return (err);
915fa9e4066Sahrens }
916fa9e4066Sahrens 
917fa9e4066Sahrens /*
918fa9e4066Sahrens  * Routines for iterating over the attributes.
919fa9e4066Sahrens  */
920fa9e4066Sahrens 
921fa9e4066Sahrens /*
922fa9e4066Sahrens  * We want to keep the high 32 bits of the cursor zero if we can, so
923fa9e4066Sahrens  * that 32-bit programs can access this.  So use a small hash value so
924fa9e4066Sahrens  * we can fit 4 bits of cd into the 32-bit cursor.
925fa9e4066Sahrens  *
926fa9e4066Sahrens  * [ 4 zero bits | 32-bit collision differentiator | 28-bit hash value ]
927fa9e4066Sahrens  */
928fa9e4066Sahrens void
929fa9e4066Sahrens zap_cursor_init_serialized(zap_cursor_t *zc, objset_t *os, uint64_t zapobj,
930fa9e4066Sahrens     uint64_t serialized)
931fa9e4066Sahrens {
932fa9e4066Sahrens 	zc->zc_objset = os;
93387e5029aSahrens 	zc->zc_zap = NULL;
93487e5029aSahrens 	zc->zc_leaf = NULL;
935fa9e4066Sahrens 	zc->zc_zapobj = zapobj;
936fa9e4066Sahrens 	if (serialized == -1ULL) {
937fa9e4066Sahrens 		zc->zc_hash = -1ULL;
938fa9e4066Sahrens 		zc->zc_cd = 0;
939fa9e4066Sahrens 	} else {
940fa9e4066Sahrens 		zc->zc_hash = serialized << (64-ZAP_HASHBITS);
941fa9e4066Sahrens 		zc->zc_cd = serialized >> ZAP_HASHBITS;
942fa9e4066Sahrens 		if (zc->zc_cd >= ZAP_MAXCD) /* corrupt serialized */
943fa9e4066Sahrens 			zc->zc_cd = 0;
944fa9e4066Sahrens 	}
945fa9e4066Sahrens }
946fa9e4066Sahrens 
94787e5029aSahrens void
94887e5029aSahrens zap_cursor_init(zap_cursor_t *zc, objset_t *os, uint64_t zapobj)
94987e5029aSahrens {
95087e5029aSahrens 	zap_cursor_init_serialized(zc, os, zapobj, 0);
95187e5029aSahrens }
95287e5029aSahrens 
95387e5029aSahrens void
95487e5029aSahrens zap_cursor_fini(zap_cursor_t *zc)
95587e5029aSahrens {
95687e5029aSahrens 	if (zc->zc_zap) {
95787e5029aSahrens 		rw_enter(&zc->zc_zap->zap_rwlock, RW_READER);
95887e5029aSahrens 		zap_unlockdir(zc->zc_zap);
95987e5029aSahrens 		zc->zc_zap = NULL;
96087e5029aSahrens 	}
96187e5029aSahrens 	if (zc->zc_leaf) {
96287e5029aSahrens 		rw_enter(&zc->zc_leaf->l_rwlock, RW_READER);
96387e5029aSahrens 		zap_put_leaf(zc->zc_leaf);
96487e5029aSahrens 		zc->zc_leaf = NULL;
96587e5029aSahrens 	}
96687e5029aSahrens 	zc->zc_objset = NULL;
96787e5029aSahrens }
96887e5029aSahrens 
969fa9e4066Sahrens uint64_t
970fa9e4066Sahrens zap_cursor_serialize(zap_cursor_t *zc)
971fa9e4066Sahrens {
972fa9e4066Sahrens 	if (zc->zc_hash == -1ULL)
973fa9e4066Sahrens 		return (-1ULL);
974fa9e4066Sahrens 	ASSERT((zc->zc_hash & (ZAP_MAXCD-1)) == 0);
975fa9e4066Sahrens 	ASSERT(zc->zc_cd < ZAP_MAXCD);
976fa9e4066Sahrens 	return ((zc->zc_hash >> (64-ZAP_HASHBITS)) |
977fa9e4066Sahrens 	    ((uint64_t)zc->zc_cd << ZAP_HASHBITS));
978fa9e4066Sahrens }
979fa9e4066Sahrens 
980fa9e4066Sahrens int
981fa9e4066Sahrens zap_cursor_retrieve(zap_cursor_t *zc, zap_attribute_t *za)
982fa9e4066Sahrens {
983fa9e4066Sahrens 	int err;
984fa9e4066Sahrens 	avl_index_t idx;
985fa9e4066Sahrens 	mzap_ent_t mze_tofind;
986fa9e4066Sahrens 	mzap_ent_t *mze;
987fa9e4066Sahrens 
988fa9e4066Sahrens 	if (zc->zc_hash == -1ULL)
989fa9e4066Sahrens 		return (ENOENT);
990fa9e4066Sahrens 
99187e5029aSahrens 	if (zc->zc_zap == NULL) {
99287e5029aSahrens 		err = zap_lockdir(zc->zc_objset, zc->zc_zapobj, NULL,
993c5f9e431Sahrens 		    RW_READER, TRUE, FALSE, &zc->zc_zap);
99487e5029aSahrens 		if (err)
99587e5029aSahrens 			return (err);
99687e5029aSahrens 	} else {
99787e5029aSahrens 		rw_enter(&zc->zc_zap->zap_rwlock, RW_READER);
99887e5029aSahrens 	}
99987e5029aSahrens 	if (!zc->zc_zap->zap_ismicro) {
100087e5029aSahrens 		err = fzap_cursor_retrieve(zc->zc_zap, zc, za);
1001fa9e4066Sahrens 	} else {
1002fa9e4066Sahrens 		err = ENOENT;
1003fa9e4066Sahrens 
1004fa9e4066Sahrens 		mze_tofind.mze_hash = zc->zc_hash;
1005fa9e4066Sahrens 		mze_tofind.mze_phys.mze_cd = zc->zc_cd;
1006fa9e4066Sahrens 
100787e5029aSahrens 		mze = avl_find(&zc->zc_zap->zap_m.zap_avl, &mze_tofind, &idx);
100887e5029aSahrens 		if (mze == NULL) {
100987e5029aSahrens 			mze = avl_nearest(&zc->zc_zap->zap_m.zap_avl,
101087e5029aSahrens 			    idx, AVL_AFTER);
101187e5029aSahrens 		}
1012fa9e4066Sahrens 		if (mze) {
1013da6c28aaSamw 			ASSERT(0 == bcmp(&mze->mze_phys,
1014da6c28aaSamw 			    &zc->zc_zap->zap_m.zap_phys->mz_chunk
1015da6c28aaSamw 			    [mze->mze_chunkid], sizeof (mze->mze_phys)));
1016da6c28aaSamw 
1017da6c28aaSamw 			za->za_normalization_conflict =
1018da6c28aaSamw 			    mzap_normalization_conflict(zc->zc_zap, NULL, mze);
1019fa9e4066Sahrens 			za->za_integer_length = 8;
1020fa9e4066Sahrens 			za->za_num_integers = 1;
1021fa9e4066Sahrens 			za->za_first_integer = mze->mze_phys.mze_value;
1022fa9e4066Sahrens 			(void) strcpy(za->za_name, mze->mze_phys.mze_name);
1023fa9e4066Sahrens 			zc->zc_hash = mze->mze_hash;
1024fa9e4066Sahrens 			zc->zc_cd = mze->mze_phys.mze_cd;
1025fa9e4066Sahrens 			err = 0;
1026fa9e4066Sahrens 		} else {
1027fa9e4066Sahrens 			zc->zc_hash = -1ULL;
1028fa9e4066Sahrens 		}
1029fa9e4066Sahrens 	}
103087e5029aSahrens 	rw_exit(&zc->zc_zap->zap_rwlock);
1031fa9e4066Sahrens 	return (err);
1032fa9e4066Sahrens }
1033fa9e4066Sahrens 
1034fa9e4066Sahrens void
1035fa9e4066Sahrens zap_cursor_advance(zap_cursor_t *zc)
1036fa9e4066Sahrens {
1037fa9e4066Sahrens 	if (zc->zc_hash == -1ULL)
1038fa9e4066Sahrens 		return;
1039fa9e4066Sahrens 	zc->zc_cd++;
1040fa9e4066Sahrens 	if (zc->zc_cd >= ZAP_MAXCD) {
1041fa9e4066Sahrens 		zc->zc_cd = 0;
1042fa9e4066Sahrens 		zc->zc_hash += 1ULL<<(64-ZAP_HASHBITS);
1043fa9e4066Sahrens 		if (zc->zc_hash == 0) /* EOF */
1044fa9e4066Sahrens 			zc->zc_hash = -1ULL;
1045fa9e4066Sahrens 	}
1046fa9e4066Sahrens }
1047fa9e4066Sahrens 
1048fa9e4066Sahrens int
1049fa9e4066Sahrens zap_get_stats(objset_t *os, uint64_t zapobj, zap_stats_t *zs)
1050fa9e4066Sahrens {
1051fa9e4066Sahrens 	int err;
1052fa9e4066Sahrens 	zap_t *zap;
1053fa9e4066Sahrens 
1054c5f9e431Sahrens 	err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap);
1055fa9e4066Sahrens 	if (err)
1056fa9e4066Sahrens 		return (err);
1057fa9e4066Sahrens 
1058fa9e4066Sahrens 	bzero(zs, sizeof (zap_stats_t));
1059fa9e4066Sahrens 
1060fa9e4066Sahrens 	if (zap->zap_ismicro) {
1061fa9e4066Sahrens 		zs->zs_blocksize = zap->zap_dbuf->db_size;
1062fa9e4066Sahrens 		zs->zs_num_entries = zap->zap_m.zap_num_entries;
1063fa9e4066Sahrens 		zs->zs_num_blocks = 1;
1064fa9e4066Sahrens 	} else {
1065fa9e4066Sahrens 		fzap_get_stats(zap, zs);
1066fa9e4066Sahrens 	}
1067fa9e4066Sahrens 	zap_unlockdir(zap);
1068fa9e4066Sahrens 	return (0);
1069fa9e4066Sahrens }
1070