fs/zfs/zap_micro.c

78 zap_hash(zap_name_t *zn)
80 	zap_t *zap = zn->zn_zap;
85 		h = *(uint64_t *)zn->zn_key_orig;
92 			const uint64_t *wp = zn->zn_key_norm;
94 			ASSERT(zn->zn_key_intlen == 8);
95 			for (int i = 0; i < zn->zn_key_norm_numints;
99 				for (int j = 0; j < zn->zn_key_intlen; j++) {
106 			const uint8_t *cp = zn->zn_key_norm;
115 			int len = zn->zn_key_norm_numints - 1;
117 			ASSERT(zn->zn_key_intlen == 1);
152 zap_match(zap_name_t *zn, const char *matchname)
154 	ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY));
156 	if (zn->zn_matchtype & MT_NORMALIZE) {
159 		if (zap_normalize(zn->zn_zap, matchname, norm,
160 		    zn->zn_normflags) != 0)
163 		return (strcmp(zn->zn_key_norm, norm) == 0);
165 		return (strcmp(zn->zn_key_orig, matchname) == 0);
170 zap_name_free(zap_name_t *zn)
172 	kmem_free(zn, sizeof (zap_name_t));
178 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
180 	zn->zn_zap = zap;
181 	zn->zn_key_intlen = sizeof (*key);
182 	zn->zn_key_orig = key;
183 	zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1;
184 	zn->zn_matchtype = mt;
185 	zn->zn_normflags = zap->zap_normflags;
193 		zn->zn_normflags &= ~U8_TEXTPREP_TOUPPER;
200 		if (zap_normalize(zap, key, zn->zn_normbuf,
202 			zap_name_free(zn);
205 		zn->zn_key_norm = zn->zn_normbuf;
206 		zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
209 			zap_name_free(zn);
212 		zn->zn_key_norm = zn->zn_key_orig;
213 		zn->zn_key_norm_numints = zn->zn_key_orig_numints;
216 	zn->zn_hash = zap_hash(zn);
218 	if (zap->zap_normflags != zn->zn_normflags) {
223 		if (zap_normalize(zap, key, zn->zn_normbuf,
224 		    zn->zn_normflags) != 0) {
225 			zap_name_free(zn);
228 		zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
231 	return (zn);
237 	zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP);
240 	zn->zn_zap = zap;
241 	zn->zn_key_intlen = sizeof (*key);
242 	zn->zn_key_orig = zn->zn_key_norm = key;
243 	zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints;
244 	zn->zn_matchtype = 0;
246 	zn->zn_hash = zap_hash(zn);
247 	return (zn);
313 mze_find(zap_name_t *zn)
318 	avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl;
320 	ASSERT(zn->zn_zap->zap_ismicro);
321 	ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock));
323 	mze_tofind.mze_hash = zn->zn_hash;
329 	for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) {
330 		ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd);
331 		if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name))
433 				zap_name_t *zn;
435 				zn = zap_name_alloc(zap, mze->mze_name, 0);
436 				if (mze_insert(zap, i, zn->zn_hash) == 0)
443 				zap_name_free(zn);
644 		zap_name_t *zn = zap_name_alloc(zap, mze->mze_name, 0);
645 		err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd,
647 		zap = zn->zn_zap;	/* fzap_add_cd() may change zap */
648 		zap_name_free(zn);
805  * zn may be NULL; if not specified, it will be computed if needed.
809 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
822 		if (zn == NULL) {
823 			zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name,
827 		if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
829 				zap_name_free(zn);
840 		zap_name_free(zn);
864 	zap_name_t *zn = zap_name_alloc(zap, name, mt);
865 	if (zn == NULL)
869 		err = fzap_lookup(zn, integer_size, num_integers, buf,
872 		mzap_ent_t *mze = mze_find(zn);
887 					    zn, mze);
892 	zap_name_free(zn);
950 	zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
951 	if (zn == NULL) {
956 	fzap_prefetch(zn);
957 	zap_name_free(zn);
972 	zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
973 	if (zn == NULL) {
978 	err = fzap_lookup(zn, integer_size, num_integers, buf,
980 	zap_name_free(zn);
1005 	zap_name_t *zn = zap_name_alloc(zap, name, 0);
1006 	if (zn == NULL) {
1011 		err = fzap_length(zn, integer_size, num_integers);
1013 		mzap_ent_t *mze = mze_find(zn);
1023 	zap_name_free(zn);
1038 	zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1039 	if (zn == NULL) {
1043 	err = fzap_length(zn, integer_size, num_integers);
1044 	zap_name_free(zn);
1050 mzap_addent(zap_name_t *zn, uint64_t value)
1052 	zap_t *zap = zn->zn_zap;
1060 		ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0);
1064 	uint32_t cd = mze_find_unused_cd(zap, zn->zn_hash);
1074 			(void) strcpy(mze->mze_name, zn->zn_key_orig);
1080 			VERIFY(0 == mze_insert(zap, i, zn->zn_hash));
1099 	zap_name_t *zn = zap_name_alloc(zap, key, 0);
1100 	if (zn == NULL) {
1105 		err = fzap_add(zn, integer_size, num_integers, val, tag, tx);
1106 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1109 		err = mzap_upgrade(&zn->zn_zap, tag, tx, 0);
1111 			err = fzap_add(zn, integer_size, num_integers, val,
1114 		zap = zn->zn_zap;	/* fzap_add() may change zap */
1116 		if (mze_find(zn) != NULL) {
1119 			mzap_addent(zn, *intval);
1122 	ASSERT(zap == zn->zn_zap);
1123 	zap_name_free(zn);
1172 	zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1173 	if (zn == NULL) {
1177 	err = fzap_add(zn, integer_size, num_integers, val, FTAG, tx);
1178 	zap = zn->zn_zap;	/* fzap_add() may change zap */
1179 	zap_name_free(zn);
1206 	zap_name_t *zn = zap_name_alloc(zap, name, 0);
1207 	if (zn == NULL) {
1212 		err = fzap_update(zn, integer_size, num_integers, val,
1214 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1219 		err = mzap_upgrade(&zn->zn_zap, FTAG, tx, 0);
1221 			err = fzap_update(zn, integer_size, num_integers,
1224 		zap = zn->zn_zap;	/* fzap_update() may change zap */
1226 		mzap_ent_t *mze = mze_find(zn);
1231 			mzap_addent(zn, *intval);
1234 	ASSERT(zap == zn->zn_zap);
1235 	zap_name_free(zn);
1252 	zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1253 	if (zn == NULL) {
1257 	err = fzap_update(zn, integer_size, num_integers, val, FTAG, tx);
1258 	zap = zn->zn_zap;	/* fzap_update() may change zap */
1259 	zap_name_free(zn);
1277 	zap_name_t *zn = zap_name_alloc(zap, name, mt);
1278 	if (zn == NULL)
1281 		err = fzap_remove(zn, tx);
1283 		mzap_ent_t *mze = mze_find(zn);
1293 	zap_name_free(zn);
1336 	zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1337 	if (zn == NULL) {
1341 	err = fzap_remove(zn, tx);
1342 	zap_name_free(zn);
1486 	zap_name_t *zn;
1497 	zn = zap_name_alloc(zc->zc_zap, name, mt);
1498 	if (zn == NULL) {
1504 		err = fzap_cursor_move_to_key(zc, zn);
1506 		mze = mze_find(zn);
1516 	zap_name_free(zn);