Lines Matching defs:zn
113 zap_hash(zap_name_t *zn)
115 zap_t *zap = zn->zn_zap;
120 h = *(uint64_t *)zn->zn_key_orig;
127 const uint64_t *wp = zn->zn_key_norm;
129 ASSERT(zn->zn_key_intlen == 8);
130 for (int i = 0; i < zn->zn_key_norm_numints;
141 const uint8_t *cp = zn->zn_key_norm;
150 int len = zn->zn_key_norm_numints - 1;
152 ASSERT(zn->zn_key_intlen == 1);
187 zap_match(zap_name_t *zn, const char *matchname)
190 ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY));
192 if (zn->zn_matchtype & MT_NORMALIZE) {
193 size_t namelen = zn->zn_normbuf_len;
204 if (zap_normalize(zn->zn_zap, matchname, norm,
205 zn->zn_normflags, namelen) != 0) {
208 res = (strcmp(zn->zn_key_norm, norm) == 0);
213 res = (strcmp(zn->zn_key_orig, matchname) == 0);
256 zap_name_t *zn = kmem_cache_alloc(cache, KM_SLEEP);
258 zn->zn_zap = zap;
259 zn->zn_normbuf_len = longname ? ZAP_MAXNAMELEN_NEW : ZAP_MAXNAMELEN;
260 return (zn);
264 zap_name_free(zap_name_t *zn)
266 if (zn->zn_normbuf_len == ZAP_MAXNAMELEN) {
267 kmem_cache_free(zap_name_cache, zn);
269 ASSERT3U(zn->zn_normbuf_len, ==, ZAP_MAXNAMELEN_NEW);
270 kmem_cache_free(zap_name_long_cache, zn);
275 zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt)
277 zap_t *zap = zn->zn_zap;
280 /* Make sure zn is allocated for longname if key is long */
282 zn->zn_normbuf_len == ZAP_MAXNAMELEN_NEW);
284 zn->zn_key_intlen = sizeof (*key);
285 zn->zn_key_orig = key;
286 zn->zn_key_orig_numints = key_len;
287 zn->zn_matchtype = mt;
288 zn->zn_normflags = zap->zap_normflags;
296 zn->zn_normflags &= ~U8_TEXTPREP_TOUPPER;
303 if (zap_normalize(zap, key, zn->zn_normbuf,
304 zap->zap_normflags, zn->zn_normbuf_len) != 0)
306 zn->zn_key_norm = zn->zn_normbuf;
307 zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
311 zn->zn_key_norm = zn->zn_key_orig;
312 zn->zn_key_norm_numints = zn->zn_key_orig_numints;
315 zn->zn_hash = zap_hash(zn);
317 if (zap->zap_normflags != zn->zn_normflags) {
322 if (zap_normalize(zap, key, zn->zn_normbuf,
323 zn->zn_normflags, zn->zn_normbuf_len) != 0)
325 zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
335 zap_name_t *zn = zap_name_alloc(zap, (key_len > ZAP_MAXNAMELEN));
336 if (zap_name_init_str(zn, key, mt) != 0) {
337 zap_name_free(zn);
340 return (zn);
346 zap_name_t *zn = kmem_cache_alloc(zap_name_cache, KM_SLEEP);
349 zn->zn_zap = zap;
350 zn->zn_key_intlen = sizeof (*key);
351 zn->zn_key_orig = zn->zn_key_norm = key;
352 zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints;
353 zn->zn_matchtype = 0;
354 zn->zn_normbuf_len = ZAP_MAXNAMELEN;
356 zn->zn_hash = zap_hash(zn);
357 return (zn);
420 mze_find(zap_name_t *zn, zfs_btree_index_t *idx)
424 zfs_btree_t *tree = &zn->zn_zap->zap_m.zap_tree;
426 ASSERT(zn->zn_zap->zap_ismicro);
427 ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock));
429 ASSERT0(zn->zn_hash & 0xffffffff);
430 mze_tofind.mze_hash = zn->zn_hash >> 32;
438 ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd);
439 if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name))
485 mze_canfit_fzap_leaf(zap_name_t *zn, uint64_t hash)
487 zap_t *zap = zn->zn_zap;
570 zap_name_t *zn = zap_name_alloc(zap, B_FALSE);
576 zap_name_init_str(zn, mze->mze_name, 0);
577 mze_insert(zap, i, zn->zn_hash);
580 zap_name_free(zn);
802 zap_name_t *zn = zap_name_alloc(zap, B_FALSE);
809 zap_name_init_str(zn, mze->mze_name, 0);
811 VERIFY0(fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd,
813 zap = zn->zn_zap; /* fzap_add_cd() may change zap */
815 zap_name_free(zn);
1054 * zn may be NULL; if not specified, it will be computed if needed.
1058 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze,
1072 if (zn == NULL) {
1073 zn = zap_name_alloc_str(zap,
1077 if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
1079 zap_name_free(zn);
1088 if (zn == NULL) {
1089 zn = zap_name_alloc_str(zap,
1093 if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
1095 zap_name_free(zn);
1101 zap_name_free(zn);
1125 zap_name_t *zn = zap_name_alloc_str(zap, name, mt);
1126 if (zn == NULL)
1130 err = fzap_lookup(zn, integer_size, num_integers, buf,
1134 mzap_ent_t *mze = mze_find(zn, &idx);
1151 zn, mze, &idx);
1156 zap_name_free(zn);
1183 zap_name_t *zn;
1188 zn = zap_name_alloc_str(zap, name, 0);
1189 if (zn == NULL) {
1194 fzap_prefetch(zn);
1195 zap_name_free(zn);
1244 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1245 if (zn == NULL) {
1250 fzap_prefetch(zn);
1251 zap_name_free(zn);
1289 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1290 if (zn == NULL) {
1295 int err = fzap_lookup(zn, integer_size, num_integers, buf,
1297 zap_name_free(zn);
1354 zap_name_t *zn = zap_name_alloc_str(zap, name, 0);
1355 if (zn == NULL) {
1360 err = fzap_length(zn, integer_size, num_integers);
1363 mzap_ent_t *mze = mze_find(zn, &idx);
1373 zap_name_free(zn);
1388 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1389 if (zn == NULL) {
1393 err = fzap_length(zn, integer_size, num_integers);
1394 zap_name_free(zn);
1400 mzap_addent(zap_name_t *zn, uint64_t value)
1402 zap_t *zap = zn->zn_zap;
1410 ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0);
1414 uint32_t cd = mze_find_unused_cd(zap, zn->zn_hash);
1424 (void) strlcpy(mze->mze_name, zn->zn_key_orig,
1431 mze_insert(zap, i, zn->zn_hash);
1450 zap_name_t *zn = zap_name_alloc_str(zap, key, 0);
1451 if (zn == NULL) {
1456 err = fzap_add(zn, integer_size, num_integers, val, tag, tx);
1457 zap = zn->zn_zap; /* fzap_add() may change zap */
1460 !mze_canfit_fzap_leaf(zn, zn->zn_hash)) {
1461 err = mzap_upgrade(&zn->zn_zap, tag, tx, 0);
1463 err = fzap_add(zn, integer_size, num_integers, val,
1466 zap = zn->zn_zap; /* fzap_add() may change zap */
1469 if (mze_find(zn, &idx) != NULL) {
1472 mzap_addent(zn, *intval);
1475 ASSERT(zap == zn->zn_zap);
1476 zap_name_free(zn);
1521 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1522 if (zn == NULL) {
1526 err = fzap_add(zn, integer_size, num_integers, val, tag, tx);
1527 zap = zn->zn_zap; /* fzap_add() may change zap */
1528 zap_name_free(zn);
1579 zap_name_t *zn = zap_name_alloc_str(zap, name, 0);
1580 if (zn == NULL) {
1585 err = fzap_update(zn, integer_size, num_integers, val,
1587 zap = zn->zn_zap; /* fzap_update() may change zap */
1593 err = mzap_upgrade(&zn->zn_zap, FTAG, tx, 0);
1595 err = fzap_update(zn, integer_size, num_integers,
1598 zap = zn->zn_zap; /* fzap_update() may change zap */
1601 mzap_ent_t *mze = mze_find(zn, &idx);
1605 mzap_addent(zn, *intval);
1608 ASSERT(zap == zn->zn_zap);
1609 zap_name_free(zn);
1622 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1623 if (zn == NULL) {
1627 err = fzap_update(zn, integer_size, num_integers, val, tag, tx);
1628 zap = zn->zn_zap; /* fzap_update() may change zap */
1629 zap_name_free(zn);
1680 zap_name_t *zn = zap_name_alloc_str(zap, name, mt);
1681 if (zn == NULL)
1684 err = fzap_remove(zn, tx);
1687 mzap_ent_t *mze = mze_find(zn, &idx);
1696 zap_name_free(zn);
1735 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1736 if (zn == NULL) {
1740 err = fzap_remove(zn, tx);
1741 zap_name_free(zn);