Lines Matching defs:zap
32 #include <sys/zap.h>
44 extern inline mzap_phys_t *zap_m_phys(zap_t *zap);
50 zap_getflags(zap_t *zap)
52 if (zap->zap_ismicro)
54 return (zap_f_phys(zap)->zap_flags);
58 zap_hashbits(zap_t *zap)
60 if (zap_getflags(zap) & ZAP_FLAG_HASH64)
67 zap_maxcd(zap_t *zap)
69 if (zap_getflags(zap) & ZAP_FLAG_HASH64)
78 zap_t *zap = zn->zn_zap;
81 if (zap_getflags(zap) & ZAP_FLAG_PRE_HASHED_KEY) {
82 ASSERT(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY);
85 h = zap->zap_salt;
89 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)
141 ASSERT(!(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY));
148 zap->zap_normflags | U8_TEXTPREP_IGNORE_NULL |
179 zap_name_alloc(zap_t *zap, const char *key, matchtype_t mt)
183 zn->zn_zap = zap;
188 if (zap->zap_normflags) {
189 if (zap_normalize(zap, key, zn->zn_normbuf) != 0) {
209 zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints)
213 ASSERT(zap->zap_normflags == 0);
214 zn->zn_zap = zap;
273 mze_insert(zap_t *zap, int chunkid, uint64_t hash)
277 ASSERT(zap->zap_ismicro);
278 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
283 mze->mze_cd = MZE_PHYS(zap, mze)->mze_cd;
284 ASSERT(MZE_PHYS(zap, mze)->mze_name[0] != 0);
285 avl_add(&zap->zap_m.zap_avl, mze);
319 mze_find_unused_cd(zap_t *zap, uint64_t hash)
324 avl_tree_t *avl = &zap->zap_m.zap_avl;
327 ASSERT(zap->zap_ismicro);
328 ASSERT(RW_LOCK_HELD(&zap->zap_rwlock));
345 mze_remove(zap_t *zap, mzap_ent_t *mze)
347 ASSERT(zap->zap_ismicro);
348 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
350 avl_remove(&zap->zap_m.zap_avl, mze);
355 mze_destroy(zap_t *zap)
360 while (mze = avl_destroy_nodes(&zap->zap_m.zap_avl, &avlcookie))
362 avl_destroy(&zap->zap_m.zap_avl);
369 zap_t *zap;
377 zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP);
378 rw_init(&zap->zap_rwlock, 0, 0, 0);
379 rw_enter(&zap->zap_rwlock, RW_WRITER);
380 zap->zap_objset = os;
381 zap->zap_object = obj;
382 zap->zap_dbuf = db;
385 mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0);
386 zap->zap_f.zap_block_shift = highbit64(db->db_size) - 1;
392 zap->zap_ismicro = TRUE;
400 dmu_buf_init_user(&zap->zap_dbu, zap_evict_sync, NULL, &zap->zap_dbuf);
401 winner = dmu_buf_set_user(db, &zap->zap_dbu);
406 if (zap->zap_ismicro) {
407 zap->zap_salt = zap_m_phys(zap)->mz_salt;
408 zap->zap_normflags = zap_m_phys(zap)->mz_normflags;
409 zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1;
410 avl_create(&zap->zap_m.zap_avl, mze_compare,
413 for (i = 0; i < zap->zap_m.zap_num_chunks; i++) {
415 &zap_m_phys(zap)->mz_chunk[i];
419 zap->zap_m.zap_num_entries++;
420 zn = zap_name_alloc(zap, mze->mze_name,
422 mze_insert(zap, i, zn->zn_hash);
427 zap->zap_salt = zap_f_phys(zap)->zap_salt;
428 zap->zap_normflags = zap_f_phys(zap)->zap_normflags;
437 ASSERT3P(&ZAP_EMBEDDED_PTRTBL_ENT(zap, 0), >,
438 &zap_f_phys(zap)->zap_salt);
444 ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap,
445 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) -
446 (uintptr_t)zap_f_phys(zap), ==,
447 zap->zap_dbuf->db_size);
449 rw_exit(&zap->zap_rwlock);
450 return (zap);
453 rw_exit(&zap->zap_rwlock);
454 rw_destroy(&zap->zap_rwlock);
455 if (!zap->zap_ismicro)
456 mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
457 kmem_free(zap, sizeof (zap_t));
465 zap_t *zap;
482 zap = dmu_buf_get_user(db);
483 if (zap == NULL) {
484 zap = mzap_open(os, obj, db);
485 if (zap == NULL) {
501 lt = (!zap->zap_ismicro && fatreader) ? RW_READER : lti;
502 rw_enter(&zap->zap_rwlock, lt);
503 if (lt != ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)) {
507 (!zap->zap_ismicro && fatreader) ? RW_READER : lti);
508 rw_downgrade(&zap->zap_rwlock);
512 zap->zap_objset = os;
517 ASSERT3P(zap->zap_dbuf, ==, db);
519 ASSERT(!zap->zap_ismicro ||
520 zap->zap_m.zap_num_entries <= zap->zap_m.zap_num_chunks);
521 if (zap->zap_ismicro && tx && adding &&
522 zap->zap_m.zap_num_entries == zap->zap_m.zap_num_chunks) {
526 obj, zap->zap_m.zap_num_entries);
527 *zapp = zap;
530 rw_exit(&zap->zap_rwlock);
534 zap->zap_m.zap_num_chunks =
538 *zapp = zap;
577 zap_unlockdir(zap_t *zap, void *tag)
579 rw_exit(&zap->zap_rwlock);
580 dmu_buf_rele(zap->zap_dbuf, tag);
589 zap_t *zap = *zapp;
591 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
593 sz = zap->zap_dbuf->db_size;
595 bcopy(zap->zap_dbuf->db_data, mzp, sz);
596 nchunks = zap->zap_m.zap_num_chunks;
599 err = dmu_object_set_blocksize(zap->zap_objset, zap->zap_object,
608 zap->zap_object, nchunks);
610 mze_destroy(zap);
612 fzap_upgrade(zap, tx, flags);
621 zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT);
624 zap = zn->zn_zap; /* fzap_add_cd() may change zap */
630 *zapp = zap;
659 zap_t *zap;
660 /* Only fat zap supports flags; upgrade immediately. */
662 B_FALSE, B_FALSE, FTAG, &zap));
663 VERIFY3U(0, ==, mzap_upgrade(&zap, FTAG, tx, flags));
664 zap_unlockdir(zap, FTAG);
741 zap_t *zap = dbu;
743 rw_destroy(&zap->zap_rwlock);
745 if (zap->zap_ismicro)
746 mze_destroy(zap);
748 mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
750 kmem_free(zap, sizeof (zap_t));
756 zap_t *zap;
759 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
762 if (!zap->zap_ismicro) {
763 err = fzap_count(zap, count);
765 *count = zap->zap_m.zap_num_entries;
767 zap_unlockdir(zap, FTAG);
776 mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze)
782 if (zap->zap_normflags == 0)
786 for (other = avl_walk(&zap->zap_m.zap_avl, mze, direction);
788 other = avl_walk(&zap->zap_m.zap_avl, other, direction)) {
791 zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name,
795 if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) {
825 zap_lookup_impl(zap_t *zap, const char *name,
834 zn = zap_name_alloc(zap, name, mt);
838 if (!zap->zap_ismicro) {
852 MZE_PHYS(zap, mze)->mze_value;
854 MZE_PHYS(zap, mze)->mze_name, rn_len);
856 *ncp = mzap_normalization_conflict(zap,
872 zap_t *zap;
875 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
878 err = zap_lookup_impl(zap, name, integer_size,
880 zap_unlockdir(zap, FTAG);
898 zap_t *zap;
902 FTAG, &zap);
905 err = zap_lookup_impl(zap, name, integer_size,
907 zap_unlockdir(zap, FTAG);
915 zap_t *zap;
919 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
922 zn = zap_name_alloc_uint64(zap, key, key_numints);
924 zap_unlockdir(zap, FTAG);
930 zap_unlockdir(zap, FTAG);
938 zap_t *zap;
942 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
945 zn = zap_name_alloc_uint64(zap, key, key_numints);
947 zap_unlockdir(zap, FTAG);
954 zap_unlockdir(zap, FTAG);
972 zap_t *zap;
977 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
980 zn = zap_name_alloc(zap, name, MT_EXACT);
982 zap_unlockdir(zap, FTAG);
985 if (!zap->zap_ismicro) {
999 zap_unlockdir(zap, FTAG);
1007 zap_t *zap;
1011 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
1014 zn = zap_name_alloc_uint64(zap, key, key_numints);
1016 zap_unlockdir(zap, FTAG);
1021 zap_unlockdir(zap, FTAG);
1029 zap_t *zap = zn->zn_zap;
1030 int start = zap->zap_m.zap_alloc_next;
1033 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock));
1036 for (i = 0; i < zap->zap_m.zap_num_chunks; i++) {
1037 mzap_ent_phys_t *mze = &zap_m_phys(zap)->mz_chunk[i];
1042 cd = mze_find_unused_cd(zap, zn->zn_hash);
1044 ASSERT(cd < zap_maxcd(zap));
1047 for (i = start; i < zap->zap_m.zap_num_chunks; i++) {
1048 mzap_ent_phys_t *mze = &zap_m_phys(zap)->mz_chunk[i];
1053 zap->zap_m.zap_num_entries++;
1054 zap->zap_m.zap_alloc_next = i+1;
1055 if (zap->zap_m.zap_alloc_next ==
1056 zap->zap_m.zap_num_chunks)
1057 zap->zap_m.zap_alloc_next = 0;
1058 mze_insert(zap, i, zn->zn_hash);
1074 zap_t *zap;
1080 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1083 zn = zap_name_alloc(zap, key, MT_EXACT);
1085 zap_unlockdir(zap, FTAG);
1088 if (!zap->zap_ismicro) {
1090 zap = zn->zn_zap; /* fzap_add() may change zap */
1098 zap = zn->zn_zap; /* fzap_add() may change zap */
1107 ASSERT(zap == zn->zn_zap);
1109 if (zap != NULL) /* may be NULL if fzap_add() failed */
1110 zap_unlockdir(zap, FTAG);
1119 zap_t *zap;
1123 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1126 zn = zap_name_alloc_uint64(zap, key, key_numints);
1128 zap_unlockdir(zap, FTAG);
1132 zap = zn->zn_zap; /* fzap_add() may change zap */
1134 if (zap != NULL) /* may be NULL if fzap_add() failed */
1135 zap_unlockdir(zap, FTAG);
1143 zap_t *zap;
1159 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1162 zn = zap_name_alloc(zap, name, MT_EXACT);
1164 zap_unlockdir(zap, FTAG);
1167 if (!zap->zap_ismicro) {
1170 zap = zn->zn_zap; /* fzap_update() may change zap */
1180 zap = zn->zn_zap; /* fzap_update() may change zap */
1184 ASSERT3U(MZE_PHYS(zap, mze)->mze_value, ==, oldval);
1185 MZE_PHYS(zap, mze)->mze_value = *intval;
1190 ASSERT(zap == zn->zn_zap);
1192 if (zap != NULL) /* may be NULL if fzap_upgrade() failed */
1193 zap_unlockdir(zap, FTAG);
1202 zap_t *zap;
1206 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
1209 zn = zap_name_alloc_uint64(zap, key, key_numints);
1211 zap_unlockdir(zap, FTAG);
1215 zap = zn->zn_zap; /* fzap_update() may change zap */
1217 if (zap != NULL) /* may be NULL if fzap_upgrade() failed */
1218 zap_unlockdir(zap, FTAG);
1232 zap_t *zap;
1237 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
1240 zn = zap_name_alloc(zap, name, mt);
1242 zap_unlockdir(zap, FTAG);
1245 if (!zap->zap_ismicro) {
1252 zap->zap_m.zap_num_entries--;
1253 bzero(&zap_m_phys(zap)->mz_chunk[mze->mze_chunkid],
1255 mze_remove(zap, mze);
1259 zap_unlockdir(zap, FTAG);
1267 zap_t *zap;
1271 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
1274 zn = zap_name_alloc_uint64(zap, key, key_numints);
1276 zap_unlockdir(zap, FTAG);
1281 zap_unlockdir(zap, FTAG);
1422 zap_t *zap;
1424 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap);
1430 if (zap->zap_ismicro) {
1431 zs->zs_blocksize = zap->zap_dbuf->db_size;
1432 zs->zs_num_entries = zap->zap_m.zap_num_entries;
1435 fzap_get_stats(zap, zs);
1437 zap_unlockdir(zap, FTAG);
1445 zap_t *zap;
1466 * We lock the zap with adding == FALSE. Because, if we pass
1472 FTAG, &zap);
1476 if (!zap->zap_ismicro) {
1477 zap_name_t *zn = zap_name_alloc(zap, name, MT_EXACT);
1491 * We are here if (name != NULL) and this is a micro-zap.
1505 if (dmu_buf_freeable(zap->zap_dbuf)) {
1519 zap_unlockdir(zap, FTAG);