fs/zfs/zap_micro.c

75 zap_hash(zap_name_t *zn)
77 	zap_t *zap = zn->zn_zap;
82 		h = *(uint64_t *)zn->zn_key_orig;
90 			const uint64_t *wp = zn->zn_key_norm;
92 			ASSERT(zn->zn_key_intlen == 8);
93 			for (i = 0; i < zn->zn_key_norm_numints; wp++, i++) {
97 				for (j = 0; j < zn->zn_key_intlen; j++) {
105 			const uint8_t *cp = zn->zn_key_norm;
114 			len = zn->zn_key_norm_numints - 1;
116 			ASSERT(zn->zn_key_intlen == 1);
154 zap_match(zap_name_t *zn, const char *matchname)
156 	ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY));
158 	if (zn->zn_matchtype == MT_FIRST) {
161 		if (zap_normalize(zn->zn_zap, matchname, norm) != 0)
164 		return (strcmp(zn->zn_key_norm, norm) == 0);
167 		return (strcmp(zn->zn_key_orig, matchname) == 0);
172 zap_name_free(zap_name_t *zn)
174 	kmem_free(zn, sizeof (zap_name_t));
180 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
182 	zn->zn_zap = zap;
183 	zn->zn_key_intlen = sizeof (*key);
184 	zn->zn_key_orig = key;
185 	zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1;
186 	zn->zn_matchtype = mt;
188 		if (zap_normalize(zap, key, zn->zn_normbuf) != 0) {
189 			zap_name_free(zn);
192 		zn->zn_key_norm = zn->zn_normbuf;
193 		zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
196 			zap_name_free(zn);
199 		zn->zn_key_norm = zn->zn_key_orig;
200 		zn->zn_key_norm_numints = zn->zn_key_orig_numints;
203 	zn->zn_hash = zap_hash(zn);
204 	return (zn);
210 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
213 	zn->zn_zap = zap;
214 	zn->zn_key_intlen = sizeof (*key);
215 	zn->zn_key_orig = zn->zn_key_norm = key;
216 	zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints;
217 	zn->zn_matchtype = MT_EXACT;
219 	zn->zn_hash = zap_hash(zn);
220 	return (zn);
294 mze_find(zap_name_t *zn)
299 	avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl;
301 	ASSERT(zn->zn_zap->zap_ismicro);
302 	ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock));
304 	mze_tofind.mze_hash = zn->zn_hash;
311 	for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) {
312 		ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd);
313 		if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name))
316 	if (zn->zn_matchtype == MT_BEST) {
317 		zn->zn_matchtype = MT_FIRST;
422 				zap_name_t *zn;
424 				zn = zap_name_alloc(zap, mze->mze_name,
426 				if (mze_insert(zap, i, zn->zn_hash) == 0)
433 				zap_name_free(zn);
593 		zap_name_t *zn;
598 		zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT);
599 		err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, tx);
600 		zap = zn->zn_zap;	/* fzap_add_cd() may change zap */
601 		zap_name_free(zn);
748  * zn may be NULL; if not specified, it will be computed if needed.
752 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
766 		if (zn == NULL) {
767 			zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name,
771 		if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
773 				zap_name_free(zn);
784 		zap_name_free(zn);
809 	zap_name_t *zn;
814 	zn = zap_name_alloc(zap, name, mt);
815 	if (zn == NULL) {
821 		err = fzap_lookup(zn, integer_size, num_integers, buf,
824 		mze = mze_find(zn);
839 					    zn, mze);
844 	zap_name_free(zn);
855 	zap_name_t *zn;
860 	zn = zap_name_alloc_uint64(zap, key, key_numints);
861 	if (zn == NULL) {
866 	fzap_prefetch(zn);
867 	zap_name_free(zn);
878 	zap_name_t *zn;
883 	zn = zap_name_alloc_uint64(zap, key, key_numints);
884 	if (zn == NULL) {
889 	err = fzap_lookup(zn, integer_size, num_integers, buf,
891 	zap_name_free(zn);
913 	zap_name_t *zn;
918 	zn = zap_name_alloc(zap, name, MT_EXACT);
919 	if (zn == NULL) {
924 		err = fzap_length(zn, integer_size, num_integers);
926 		mze = mze_find(zn);
936 	zap_name_free(zn);
947 	zap_name_t *zn;
952 	zn = zap_name_alloc_uint64(zap, key, key_numints);
953 	if (zn == NULL) {
957 	err = fzap_length(zn, integer_size, num_integers);
958 	zap_name_free(zn);
964 mzap_addent(zap_name_t *zn, uint64_t value)
967 	zap_t *zap = zn->zn_zap;
976 		ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0);
980 	cd = mze_find_unused_cd(zap, zn->zn_hash);
990 			(void) strcpy(mze->mze_name, zn->zn_key_orig);
996 			VERIFY(0 == mze_insert(zap, i, zn->zn_hash));
1016 	zap_name_t *zn;
1021 	zn = zap_name_alloc(zap, key, MT_EXACT);
1022 	if (zn == NULL) {
1027 		err = fzap_add(zn, integer_size, num_integers, val, tx);
1028 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1031 		err = mzap_upgrade(&zn->zn_zap, tx, 0);
1033 			err = fzap_add(zn, integer_size, num_integers, val, tx);
1034 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1036 		mze = mze_find(zn);
1040 			mzap_addent(zn, *intval);
1043 	ASSERT(zap == zn->zn_zap);
1044 	zap_name_free(zn);
1057 	zap_name_t *zn;
1062 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1063 	if (zn == NULL) {
1067 	err = fzap_add(zn, integer_size, num_integers, val, tx);
1068 	zap = zn->zn_zap;	/* fzap_add() may change zap */
1069 	zap_name_free(zn);
1083 	zap_name_t *zn;
1098 	zn = zap_name_alloc(zap, name, MT_EXACT);
1099 	if (zn == NULL) {
1104 		err = fzap_update(zn, integer_size, num_integers, val, tx);
1105 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1110 		err = mzap_upgrade(&zn->zn_zap, tx, 0);
1112 			err = fzap_update(zn, integer_size, num_integers,
1114 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1116 		mze = mze_find(zn);
1121 			mzap_addent(zn, *intval);
1124 	ASSERT(zap == zn->zn_zap);
1125 	zap_name_free(zn);
1137 	zap_name_t *zn;
1143 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1144 	if (zn == NULL) {
1148 	err = fzap_update(zn, integer_size, num_integers, val, tx);
1149 	zap = zn->zn_zap;	/* fzap_update() may change zap */
1150 	zap_name_free(zn);
1169 	zap_name_t *zn;
1174 	zn = zap_name_alloc(zap, name, mt);
1175 	if (zn == NULL) {
1180 		err = fzap_remove(zn, tx);
1182 		mze = mze_find(zn);
1192 	zap_name_free(zn);
1203 	zap_name_t *zn;
1208 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1209 	if (zn == NULL) {
1213 	err = fzap_remove(zn, tx);
1214 	zap_name_free(zn);
1357 	zap_name_t *zn;
1368 	zn = zap_name_alloc(zc->zc_zap, name, mt);
1369 	if (zn == NULL) {
1375 		err = fzap_cursor_move_to_key(zc, zn);
1377 		mze = mze_find(zn);
1387 	zap_name_free(zn);
1449 		zap_name_t *zn = zap_name_alloc(zap, name, MT_EXACT);
1450 		if (zn) {
1451 			err = fzap_count_write(zn, add, towrite,
1453 			zap_name_free(zn);