Lines Matching refs:zap
34 #include <sys/zap.h>
46 extern inline mzap_phys_t *zap_m_phys(zap_t *zap);
52 zap_getflags(zap_t *zap)
54 if (zap->zap_ismicro)
56 return (zap_f_phys(zap)->zap_flags);
60 zap_hashbits(zap_t *zap)
62 if (zap_getflags(zap) & ZAP_FLAG_HASH64)
69 zap_maxcd(zap_t *zap)
71 if (zap_getflags(zap) & ZAP_FLAG_HASH64)
80 zap_t *zap = zn->zn_zap;
83 if (zap_getflags(zap) & ZAP_FLAG_PRE_HASHED_KEY) {
84 ASSERT(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY);
87 h = zap->zap_salt;
91 if (zap_getflags(zap) & ZAP_FLAG_UINT64_KEY) {
130 h &= ~((1ULL << (64 - zap_hashbits(zap))) - 1);
136 zap_normalize(zap_t *zap, const char *name, char *namenorm, int normflags)
138 ASSERT(!(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY));
176 zap_name_alloc(zap_t *zap, const char *key, matchtype_t mt)
180 zn->zn_zap = zap;
185 zn->zn_normflags = zap->zap_normflags;
195 if (zap->zap_normflags) {
200 if (zap_normalize(zap, key, zn->zn_normbuf,
201 zap->zap_normflags) != 0) {
218 if (zap->zap_normflags != zn->zn_normflags) {
223 if (zap_normalize(zap, key, zn->zn_normbuf,
235 zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints)
239 ASSERT(zap->zap_normflags == 0);
240 zn->zn_zap = zap;
292 mze_insert(zap_t *zap, int chunkid, uint64_t hash)
296 ASSERT(zap->zap_ismicro);
297 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
302 mze->mze_cd = MZE_PHYS(zap, mze)->mze_cd;
303 ASSERT(MZE_PHYS(zap, mze)->mze_name[0] != 0);
304 if (avl_find(&zap->zap_m.zap_avl, mze, &idx) != NULL) {
308 avl_insert(&zap->zap_m.zap_avl, mze, idx);
339 mze_find_unused_cd(zap_t *zap, uint64_t hash)
343 avl_tree_t *avl = &zap->zap_m.zap_avl;
345 ASSERT(zap->zap_ismicro);
346 ASSERT(RW_LOCK_HELD(&zap->zap_rwlock));
363 mze_remove(zap_t *zap, mzap_ent_t *mze)
365 ASSERT(zap->zap_ismicro);
366 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
368 avl_remove(&zap->zap_m.zap_avl, mze);
373 mze_destroy(zap_t *zap)
378 while (mze = avl_destroy_nodes(&zap->zap_m.zap_avl, &avlcookie))
380 avl_destroy(&zap->zap_m.zap_avl);
393 zap_t *zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP);
394 rw_init(&zap->zap_rwlock, 0, 0, 0);
395 rw_enter(&zap->zap_rwlock, RW_WRITER);
396 zap->zap_objset = os;
397 zap->zap_object = obj;
398 zap->zap_dbuf = db;
401 mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0);
402 zap->zap_f.zap_block_shift = highbit64(db->db_size) - 1;
408 zap->zap_ismicro = TRUE;
416 dmu_buf_init_user(&zap->zap_dbu, zap_evict_sync, NULL, &zap->zap_dbuf);
417 winner = dmu_buf_set_user(db, &zap->zap_dbu);
422 if (zap->zap_ismicro) {
423 zap->zap_salt = zap_m_phys(zap)->mz_salt;
424 zap->zap_normflags = zap_m_phys(zap)->mz_normflags;
425 zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1;
426 avl_create(&zap->zap_m.zap_avl, mze_compare,
429 for (int i = 0; i < zap->zap_m.zap_num_chunks; i++) {
431 &zap_m_phys(zap)->mz_chunk[i];
435 zn = zap_name_alloc(zap, mze->mze_name, 0);
436 if (mze_insert(zap, i, zn->zn_hash) == 0)
437 zap->zap_m.zap_num_entries++;
447 zap->zap_salt = zap_f_phys(zap)->zap_salt;
448 zap->zap_normflags = zap_f_phys(zap)->zap_normflags;
457 ASSERT3P(&ZAP_EMBEDDED_PTRTBL_ENT(zap, 0), >,
458 &zap_f_phys(zap)->zap_salt);
464 ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap,
465 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) -
466 (uintptr_t)zap_f_phys(zap), ==,
467 zap->zap_dbuf->db_size);
469 rw_exit(&zap->zap_rwlock);
470 return (zap);
473 rw_exit(&zap->zap_rwlock);
474 rw_destroy(&zap->zap_rwlock);
475 if (!zap->zap_ismicro)
476 mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
477 kmem_free(zap, sizeof (zap_t));
495 zap_t *zap = dmu_buf_get_user(db);
496 if (zap == NULL) {
497 zap = mzap_open(os, obj, db);
498 if (zap == NULL) {
514 krw_t lt = (!zap->zap_ismicro && fatreader) ? RW_READER : lti;
515 rw_enter(&zap->zap_rwlock, lt);
516 if (lt != ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)) {
520 (!zap->zap_ismicro && fatreader) ? RW_READER : lti);
521 rw_downgrade(&zap->zap_rwlock);
525 zap->zap_objset = os;
530 ASSERT3P(zap->zap_dbuf, ==, db);
532 ASSERT(!zap->zap_ismicro ||
533 zap->zap_m.zap_num_entries <= zap->zap_m.zap_num_chunks);
534 if (zap->zap_ismicro && tx && adding &&
535 zap->zap_m.zap_num_entries == zap->zap_m.zap_num_chunks) {
539 obj, zap->zap_m.zap_num_entries);
540 *zapp = zap;
543 rw_exit(&zap->zap_rwlock);
547 zap->zap_m.zap_num_chunks =
551 *zapp = zap;
603 zap_unlockdir(zap_t *zap, void *tag)
605 rw_exit(&zap->zap_rwlock);
606 dmu_buf_rele(zap->zap_dbuf, tag);
613 zap_t *zap = *zapp;
615 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
617 int sz = zap->zap_dbuf->db_size;
619 bcopy(zap->zap_dbuf->db_data, mzp, sz);
620 int nchunks = zap->zap_m.zap_num_chunks;
623 err = dmu_object_set_blocksize(zap->zap_objset, zap->zap_object,
632 zap->zap_object, nchunks);
634 mze_destroy(zap);
636 fzap_upgrade(zap, tx, flags);
644 zap_name_t *zn = zap_name_alloc(zap, mze->mze_name, 0);
647 zap = zn->zn_zap; /* fzap_add_cd() may change zap */
653 *zapp = zap;
689 zap_t *zap;
690 /* Only fat zap supports flags; upgrade immediately. */
692 B_FALSE, B_FALSE, &zap));
693 VERIFY0(mzap_upgrade(&zap, FTAG, tx, flags));
694 zap_unlockdir(zap, FTAG);
820 zap_t *zap = dbu;
822 rw_destroy(&zap->zap_rwlock);
824 if (zap->zap_ismicro)
825 mze_destroy(zap);
827 mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
829 kmem_free(zap, sizeof (zap_t));
835 zap_t *zap;
838 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
841 if (!zap->zap_ismicro) {
842 err = fzap_count(zap, count);
844 *count = zap->zap_m.zap_num_entries;
846 zap_unlockdir(zap, FTAG);
855 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
860 if (zap->zap_normflags == 0)
864 for (mzap_ent_t *other = avl_walk(&zap->zap_m.zap_avl, mze, direction);
866 other = avl_walk(&zap->zap_m.zap_avl, other, direction)) {
869 zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name,
873 if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
903 zap_lookup_impl(zap_t *zap, const char *name,
910 zap_name_t *zn = zap_name_alloc(zap, name, mt);
914 if (!zap->zap_ismicro) {
928 MZE_PHYS(zap, mze)->mze_value;
930 MZE_PHYS(zap, mze)->mze_name, rn_len);
932 *ncp = mzap_normalization_conflict(zap,
948 zap_t *zap;
951 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
954 err = zap_lookup_impl(zap, name, integer_size,
956 zap_unlockdir(zap, FTAG);
974 zap_t *zap;
977 FTAG, &zap);
980 err = zap_lookup_impl(zap, name, integer_size,
982 zap_unlockdir(zap, FTAG);
990 zap_t *zap;
993 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
996 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
998 zap_unlockdir(zap, FTAG);
1004 zap_unlockdir(zap, FTAG);
1012 zap_t *zap;
1015 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
1018 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1020 zap_unlockdir(zap, FTAG);
1027 zap_unlockdir(zap, FTAG);
1045 zap_t *zap;
1048 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
1051 zap_name_t *zn = zap_name_alloc(zap, name, 0);
1053 zap_unlockdir(zap, FTAG);
1056 if (!zap->zap_ismicro) {
1070 zap_unlockdir(zap, FTAG);
1078 zap_t *zap;
1081 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
1084 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1086 zap_unlockdir(zap, FTAG);
1091 zap_unlockdir(zap, FTAG);
1098 zap_t *zap = zn->zn_zap;
1099 int start = zap->zap_m.zap_alloc_next;
1101 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
1104 for (int i = 0; i < zap->zap_m.zap_num_chunks; i++) {
1105 mzap_ent_phys_t *mze = &zap_m_phys(zap)->mz_chunk[i];
1110 uint32_t cd = mze_find_unused_cd(zap, zn->zn_hash);
1112 ASSERT(cd < zap_maxcd(zap));
1115 for (int i = start; i < zap->zap_m.zap_num_chunks; i++) {
1116 mzap_ent_phys_t *mze = &zap_m_phys(zap)->mz_chunk[i];
1121 zap->zap_m.zap_num_entries++;
1122 zap->zap_m.zap_alloc_next = i+1;
1123 if (zap->zap_m.zap_alloc_next ==
1124 zap->zap_m.zap_num_chunks)
1125 zap->zap_m.zap_alloc_next = 0;
1126 VERIFY(0 == mze_insert(zap, i, zn->zn_hash));
1138 zap_add_impl(zap_t *zap, const char *key,
1145 zap_name_t *zn = zap_name_alloc(zap, key, 0);
1147 zap_unlockdir(zap, tag);
1150 if (!zap->zap_ismicro) {
1152 zap = zn->zn_zap; /* fzap_add() may change zap */
1160 zap = zn->zn_zap; /* fzap_add() may change zap */
1168 ASSERT(zap == zn->zn_zap);
1170 if (zap != NULL) /* may be NULL if fzap_add() failed */
1171 zap_unlockdir(zap, tag);
1180 zap_t *zap;
1183 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1186 err = zap_add_impl(zap, key, integer_size, num_integers, val, tx, FTAG);
1196 zap_t *zap;
1199 err = zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1202 err = zap_add_impl(zap, key, integer_size, num_integers, val, tx, FTAG);
1212 zap_t *zap;
1215 zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1218 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1220 zap_unlockdir(zap, FTAG);
1224 zap = zn->zn_zap; /* fzap_add() may change zap */
1226 if (zap != NULL) /* may be NULL if fzap_add() failed */
1227 zap_unlockdir(zap, FTAG);
1235 zap_t *zap;
1249 zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1252 zap_name_t *zn = zap_name_alloc(zap, name, 0);
1254 zap_unlockdir(zap, FTAG);
1257 if (!zap->zap_ismicro) {
1260 zap = zn->zn_zap; /* fzap_update() may change zap */
1270 zap = zn->zn_zap; /* fzap_update() may change zap */
1274 ASSERT3U(MZE_PHYS(zap, mze)->mze_value, ==, oldval);
1275 MZE_PHYS(zap, mze)->mze_value = *intval;
1280 ASSERT(zap == zn->zn_zap);
1282 if (zap != NULL) /* may be NULL if fzap_upgrade() failed */
1283 zap_unlockdir(zap, FTAG);
1292 zap_t *zap;
1295 zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1298 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1300 zap_unlockdir(zap, FTAG);
1304 zap = zn->zn_zap; /* fzap_update() may change zap */
1306 if (zap != NULL) /* may be NULL if fzap_upgrade() failed */
1307 zap_unlockdir(zap, FTAG);
1318 zap_remove_impl(zap_t *zap, const char *name,
1323 zap_name_t *zn = zap_name_alloc(zap, name, mt);
1326 if (!zap->zap_ismicro) {
1333 zap->zap_m.zap_num_entries--;
1334 bzero(&zap_m_phys(zap)->mz_chunk[mze->mze_chunkid],
1336 mze_remove(zap, mze);
1347 zap_t *zap;
1350 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
1353 err = zap_remove_impl(zap, name, mt, tx);
1354 zap_unlockdir(zap, FTAG);
1361 zap_t *zap;
1364 err = zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
1367 err = zap_remove_impl(zap, name, 0, tx);
1368 zap_unlockdir(zap, FTAG);
1376 zap_t *zap;
1379 zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
1382 zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints);
1384 zap_unlockdir(zap, FTAG);
1389 zap_unlockdir(zap, FTAG);
1591 zap_t *zap;
1594 zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
1600 if (zap->zap_ismicro) {
1601 zs->zs_blocksize = zap->zap_dbuf->db_size;
1602 zs->zs_num_entries = zap->zap_m.zap_num_entries;
1605 fzap_get_stats(zap, zs);
1607 zap_unlockdir(zap, FTAG);