fs/zfs/zap_micro.c

69 zap_hash(zap_name_t *zn)
71 	zap_t *zap = zn->zn_zap;
76 		h = *(uint64_t *)zn->zn_key_orig;
84 			const uint64_t *wp = zn->zn_key_norm;
86 			ASSERT(zn->zn_key_intlen == 8);
87 			for (i = 0; i < zn->zn_key_norm_numints; wp++, i++) {
91 				for (j = 0; j < zn->zn_key_intlen; j++) {
99 			const uint8_t *cp = zn->zn_key_norm;
108 			len = zn->zn_key_norm_numints - 1;
110 			ASSERT(zn->zn_key_intlen == 1);
148 zap_match(zap_name_t *zn, const char *matchname)
150 	ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY));
152 	if (zn->zn_matchtype == MT_FIRST) {
155 		if (zap_normalize(zn->zn_zap, matchname, norm) != 0)
158 		return (strcmp(zn->zn_key_norm, norm) == 0);
161 		return (strcmp(zn->zn_key_orig, matchname) == 0);
166 zap_name_free(zap_name_t *zn)
168 	kmem_free(zn, sizeof (zap_name_t));
174 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
176 	zn->zn_zap = zap;
177 	zn->zn_key_intlen = sizeof (*key);
178 	zn->zn_key_orig = key;
179 	zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1;
180 	zn->zn_matchtype = mt;
182 		if (zap_normalize(zap, key, zn->zn_normbuf) != 0) {
183 			zap_name_free(zn);
186 		zn->zn_key_norm = zn->zn_normbuf;
187 		zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
190 			zap_name_free(zn);
193 		zn->zn_key_norm = zn->zn_key_orig;
194 		zn->zn_key_norm_numints = zn->zn_key_orig_numints;
197 	zn->zn_hash = zap_hash(zn);
198 	return (zn);
204 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
207 	zn->zn_zap = zap;
208 	zn->zn_key_intlen = sizeof (*key);
209 	zn->zn_key_orig = zn->zn_key_norm = key;
210 	zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints;
211 	zn->zn_matchtype = MT_EXACT;
213 	zn->zn_hash = zap_hash(zn);
214 	return (zn);
282 mze_find(zap_name_t *zn)
287 	avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl;
289 	ASSERT(zn->zn_zap->zap_ismicro);
290 	ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock));
292 	mze_tofind.mze_hash = zn->zn_hash;
299 	for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) {
300 		ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd);
301 		if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name))
304 	if (zn->zn_matchtype == MT_BEST) {
305 		zn->zn_matchtype = MT_FIRST;
408 				zap_name_t *zn;
411 				zn = zap_name_alloc(zap, mze->mze_name,
413 				mze_insert(zap, i, zn->zn_hash);
414 				zap_name_free(zn);
557 		zap_name_t *zn;
562 		zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT);
563 		err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, tx);
564 		zap = zn->zn_zap;	/* fzap_add_cd() may change zap */
565 		zap_name_free(zn);
713  * zn may be NULL; if not specified, it will be computed if needed.
717 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
731 		if (zn == NULL) {
732 			zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name,
736 		if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
738 				zap_name_free(zn);
749 		zap_name_free(zn);
774 	zap_name_t *zn;
779 	zn = zap_name_alloc(zap, name, mt);
780 	if (zn == NULL) {
786 		err = fzap_lookup(zn, integer_size, num_integers, buf,
789 		mze = mze_find(zn);
804 					    zn, mze);
809 	zap_name_free(zn);
820 	zap_name_t *zn;
825 	zn = zap_name_alloc_uint64(zap, key, key_numints);
826 	if (zn == NULL) {
831 	fzap_prefetch(zn);
832 	zap_name_free(zn);
843 	zap_name_t *zn;
848 	zn = zap_name_alloc_uint64(zap, key, key_numints);
849 	if (zn == NULL) {
854 	err = fzap_lookup(zn, integer_size, num_integers, buf,
856 	zap_name_free(zn);
878 	zap_name_t *zn;
883 	zn = zap_name_alloc(zap, name, MT_EXACT);
884 	if (zn == NULL) {
889 		err = fzap_length(zn, integer_size, num_integers);
891 		mze = mze_find(zn);
901 	zap_name_free(zn);
912 	zap_name_t *zn;
917 	zn = zap_name_alloc_uint64(zap, key, key_numints);
918 	if (zn == NULL) {
922 	err = fzap_length(zn, integer_size, num_integers);
923 	zap_name_free(zn);
929 mzap_addent(zap_name_t *zn, uint64_t value)
932 	zap_t *zap = zn->zn_zap;
941 		ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0);
945 	cd = mze_find_unused_cd(zap, zn->zn_hash);
955 			(void) strcpy(mze->mze_name, zn->zn_key_orig);
961 			mze_insert(zap, i, zn->zn_hash);
981 	zap_name_t *zn;
986 	zn = zap_name_alloc(zap, key, MT_EXACT);
987 	if (zn == NULL) {
992 		err = fzap_add(zn, integer_size, num_integers, val, tx);
993 		zap = zn->zn_zap;	/* fzap_add() may change zap */
996 		err = mzap_upgrade(&zn->zn_zap, tx, 0);
998 			err = fzap_add(zn, integer_size, num_integers, val, tx);
999 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1001 		mze = mze_find(zn);
1005 			mzap_addent(zn, *intval);
1008 	ASSERT(zap == zn->zn_zap);
1009 	zap_name_free(zn);
1022 	zap_name_t *zn;
1027 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1028 	if (zn == NULL) {
1032 	err = fzap_add(zn, integer_size, num_integers, val, tx);
1033 	zap = zn->zn_zap;	/* fzap_add() may change zap */
1034 	zap_name_free(zn);
1048 	zap_name_t *zn;
1063 	zn = zap_name_alloc(zap, name, MT_EXACT);
1064 	if (zn == NULL) {
1069 		err = fzap_update(zn, integer_size, num_integers, val, tx);
1070 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1075 		err = mzap_upgrade(&zn->zn_zap, tx, 0);
1077 			err = fzap_update(zn, integer_size, num_integers,
1079 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1081 		mze = mze_find(zn);
1086 			mzap_addent(zn, *intval);
1089 	ASSERT(zap == zn->zn_zap);
1090 	zap_name_free(zn);
1102 	zap_name_t *zn;
1108 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1109 	if (zn == NULL) {
1113 	err = fzap_update(zn, integer_size, num_integers, val, tx);
1114 	zap = zn->zn_zap;	/* fzap_update() may change zap */
1115 	zap_name_free(zn);
1134 	zap_name_t *zn;
1139 	zn = zap_name_alloc(zap, name, mt);
1140 	if (zn == NULL) {
1145 		err = fzap_remove(zn, tx);
1147 		mze = mze_find(zn);
1157 	zap_name_free(zn);
1168 	zap_name_t *zn;
1173 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1174 	if (zn == NULL) {
1178 	err = fzap_remove(zn, tx);
1179 	zap_name_free(zn);
1323 	zap_name_t *zn;
1334 	zn = zap_name_alloc(zc->zc_zap, name, mt);
1335 	if (zn == NULL) {
1341 		err = fzap_cursor_move_to_key(zc, zn);
1343 		mze = mze_find(zn);
1353 	zap_name_free(zn);
1416 		zap_name_t *zn = zap_name_alloc(zap, name, MT_EXACT);
1417 		if (zn) {
1418 			err = fzap_count_write(zn, add, towrite,
1420 			zap_name_free(zn);