fs/zfs/zap_micro.c

70 zap_hash(zap_name_t *zn)
72 	zap_t *zap = zn->zn_zap;
77 		h = *(uint64_t *)zn->zn_key_orig;
85 			const uint64_t *wp = zn->zn_key_norm;
87 			ASSERT(zn->zn_key_intlen == 8);
88 			for (i = 0; i < zn->zn_key_norm_numints; wp++, i++) {
92 				for (j = 0; j < zn->zn_key_intlen; j++) {
100 			const uint8_t *cp = zn->zn_key_norm;
109 			len = zn->zn_key_norm_numints - 1;
111 			ASSERT(zn->zn_key_intlen == 1);
149 zap_match(zap_name_t *zn, const char *matchname)
151 	ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY));
153 	if (zn->zn_matchtype == MT_FIRST) {
156 		if (zap_normalize(zn->zn_zap, matchname, norm) != 0)
159 		return (strcmp(zn->zn_key_norm, norm) == 0);
162 		return (strcmp(zn->zn_key_orig, matchname) == 0);
167 zap_name_free(zap_name_t *zn)
169 	kmem_free(zn, sizeof (zap_name_t));
175 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
177 	zn->zn_zap = zap;
178 	zn->zn_key_intlen = sizeof (*key);
179 	zn->zn_key_orig = key;
180 	zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1;
181 	zn->zn_matchtype = mt;
183 		if (zap_normalize(zap, key, zn->zn_normbuf) != 0) {
184 			zap_name_free(zn);
187 		zn->zn_key_norm = zn->zn_normbuf;
188 		zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
191 			zap_name_free(zn);
194 		zn->zn_key_norm = zn->zn_key_orig;
195 		zn->zn_key_norm_numints = zn->zn_key_orig_numints;
198 	zn->zn_hash = zap_hash(zn);
199 	return (zn);
205 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
208 	zn->zn_zap = zap;
209 	zn->zn_key_intlen = sizeof (*key);
210 	zn->zn_key_orig = zn->zn_key_norm = key;
211 	zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints;
212 	zn->zn_matchtype = MT_EXACT;
214 	zn->zn_hash = zap_hash(zn);
215 	return (zn);
289 mze_find(zap_name_t *zn)
294 	avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl;
296 	ASSERT(zn->zn_zap->zap_ismicro);
297 	ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock));
299 	mze_tofind.mze_hash = zn->zn_hash;
306 	for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) {
307 		ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd);
308 		if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name))
311 	if (zn->zn_matchtype == MT_BEST) {
312 		zn->zn_matchtype = MT_FIRST;
415 				zap_name_t *zn;
417 				zn = zap_name_alloc(zap, mze->mze_name,
419 				if (mze_insert(zap, i, zn->zn_hash) == 0)
426 				zap_name_free(zn);
569 		zap_name_t *zn;
574 		zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT);
575 		err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, tx);
576 		zap = zn->zn_zap;	/* fzap_add_cd() may change zap */
577 		zap_name_free(zn);
725  * zn may be NULL; if not specified, it will be computed if needed.
729 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
743 		if (zn == NULL) {
744 			zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name,
748 		if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
750 				zap_name_free(zn);
761 		zap_name_free(zn);
786 	zap_name_t *zn;
791 	zn = zap_name_alloc(zap, name, mt);
792 	if (zn == NULL) {
798 		err = fzap_lookup(zn, integer_size, num_integers, buf,
801 		mze = mze_find(zn);
816 					    zn, mze);
821 	zap_name_free(zn);
832 	zap_name_t *zn;
837 	zn = zap_name_alloc_uint64(zap, key, key_numints);
838 	if (zn == NULL) {
843 	fzap_prefetch(zn);
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 	err = fzap_lookup(zn, integer_size, num_integers, buf,
868 	zap_name_free(zn);
890 	zap_name_t *zn;
895 	zn = zap_name_alloc(zap, name, MT_EXACT);
896 	if (zn == NULL) {
901 		err = fzap_length(zn, integer_size, num_integers);
903 		mze = mze_find(zn);
913 	zap_name_free(zn);
924 	zap_name_t *zn;
929 	zn = zap_name_alloc_uint64(zap, key, key_numints);
930 	if (zn == NULL) {
934 	err = fzap_length(zn, integer_size, num_integers);
935 	zap_name_free(zn);
941 mzap_addent(zap_name_t *zn, uint64_t value)
944 	zap_t *zap = zn->zn_zap;
953 		ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0);
957 	cd = mze_find_unused_cd(zap, zn->zn_hash);
967 			(void) strcpy(mze->mze_name, zn->zn_key_orig);
973 			VERIFY(0 == mze_insert(zap, i, zn->zn_hash));
993 	zap_name_t *zn;
998 	zn = zap_name_alloc(zap, key, MT_EXACT);
999 	if (zn == NULL) {
1004 		err = fzap_add(zn, integer_size, num_integers, val, tx);
1005 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1008 		err = mzap_upgrade(&zn->zn_zap, tx, 0);
1010 			err = fzap_add(zn, integer_size, num_integers, val, tx);
1011 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1013 		mze = mze_find(zn);
1017 			mzap_addent(zn, *intval);
1020 	ASSERT(zap == zn->zn_zap);
1021 	zap_name_free(zn);
1034 	zap_name_t *zn;
1039 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1040 	if (zn == NULL) {
1044 	err = fzap_add(zn, integer_size, num_integers, val, tx);
1045 	zap = zn->zn_zap;	/* fzap_add() may change zap */
1046 	zap_name_free(zn);
1060 	zap_name_t *zn;
1075 	zn = zap_name_alloc(zap, name, MT_EXACT);
1076 	if (zn == NULL) {
1081 		err = fzap_update(zn, integer_size, num_integers, val, tx);
1082 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1087 		err = mzap_upgrade(&zn->zn_zap, tx, 0);
1089 			err = fzap_update(zn, integer_size, num_integers,
1091 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1093 		mze = mze_find(zn);
1098 			mzap_addent(zn, *intval);
1101 	ASSERT(zap == zn->zn_zap);
1102 	zap_name_free(zn);
1114 	zap_name_t *zn;
1120 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1121 	if (zn == NULL) {
1125 	err = fzap_update(zn, integer_size, num_integers, val, tx);
1126 	zap = zn->zn_zap;	/* fzap_update() may change zap */
1127 	zap_name_free(zn);
1146 	zap_name_t *zn;
1151 	zn = zap_name_alloc(zap, name, mt);
1152 	if (zn == NULL) {
1157 		err = fzap_remove(zn, tx);
1159 		mze = mze_find(zn);
1169 	zap_name_free(zn);
1180 	zap_name_t *zn;
1185 	zn = zap_name_alloc_uint64(zap, key, key_numints);
1186 	if (zn == NULL) {
1190 	err = fzap_remove(zn, tx);
1191 	zap_name_free(zn);
1334 	zap_name_t *zn;
1345 	zn = zap_name_alloc(zc->zc_zap, name, mt);
1346 	if (zn == NULL) {
1352 		err = fzap_cursor_move_to_key(zc, zn);
1354 		mze = mze_find(zn);
1364 	zap_name_free(zn);
1427 		zap_name_t *zn = zap_name_alloc(zap, name, MT_EXACT);
1428 		if (zn) {
1429 			err = fzap_count_write(zn, add, towrite,
1431 			zap_name_free(zn);