1eda14cbcSMatt Macy /* 2eda14cbcSMatt Macy * CDDL HEADER START 3eda14cbcSMatt Macy * 4eda14cbcSMatt Macy * The contents of this file are subject to the terms of the 5eda14cbcSMatt Macy * Common Development and Distribution License (the "License"). 6eda14cbcSMatt Macy * You may not use this file except in compliance with the License. 7eda14cbcSMatt Macy * 8eda14cbcSMatt Macy * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9271171e0SMartin Matuska * or https://opensource.org/licenses/CDDL-1.0. 10eda14cbcSMatt Macy * See the License for the specific language governing permissions 11eda14cbcSMatt Macy * and limitations under the License. 12eda14cbcSMatt Macy * 13eda14cbcSMatt Macy * When distributing Covered Code, include this CDDL HEADER in each 14eda14cbcSMatt Macy * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15eda14cbcSMatt Macy * If applicable, add the following below this CDDL HEADER, with the 16eda14cbcSMatt Macy * fields enclosed by brackets "[]" replaced with your own identifying 17eda14cbcSMatt Macy * information: Portions Copyright [yyyy] [name of copyright owner] 18eda14cbcSMatt Macy * 19eda14cbcSMatt Macy * CDDL HEADER END 20eda14cbcSMatt Macy */ 21eda14cbcSMatt Macy 22eda14cbcSMatt Macy /* 23eda14cbcSMatt Macy * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24eda14cbcSMatt Macy * Copyright (c) 2011, 2018 by Delphix. All rights reserved. 25eda14cbcSMatt Macy * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved. 26eda14cbcSMatt Macy * Copyright 2017 Nexenta Systems, Inc. 27eda14cbcSMatt Macy */ 28eda14cbcSMatt Macy 29eda14cbcSMatt Macy #include <sys/zio.h> 30eda14cbcSMatt Macy #include <sys/spa.h> 31eda14cbcSMatt Macy #include <sys/dmu.h> 32eda14cbcSMatt Macy #include <sys/zfs_context.h> 33eda14cbcSMatt Macy #include <sys/zap.h> 34eda14cbcSMatt Macy #include <sys/zap_impl.h> 35eda14cbcSMatt Macy #include <sys/zap_leaf.h> 36dbd5678dSMartin Matuska #include <sys/btree.h> 37eda14cbcSMatt Macy #include <sys/arc.h> 38eda14cbcSMatt Macy #include <sys/dmu_objset.h> 39eda14cbcSMatt Macy 40eda14cbcSMatt Macy #ifdef _KERNEL 41eda14cbcSMatt Macy #include <sys/sunddi.h> 42eda14cbcSMatt Macy #endif 43eda14cbcSMatt Macy 4415f0b8c3SMartin Matuska int zap_micro_max_size = MZAP_MAX_BLKSZ; 4515f0b8c3SMartin Matuska 46eda14cbcSMatt Macy static int mzap_upgrade(zap_t **zapp, 47a0b956f5SMartin Matuska const void *tag, dmu_tx_t *tx, zap_flags_t flags); 48eda14cbcSMatt Macy 49eda14cbcSMatt Macy uint64_t 50eda14cbcSMatt Macy zap_getflags(zap_t *zap) 51eda14cbcSMatt Macy { 52eda14cbcSMatt Macy if (zap->zap_ismicro) 53eda14cbcSMatt Macy return (0); 54eda14cbcSMatt Macy return (zap_f_phys(zap)->zap_flags); 55eda14cbcSMatt Macy } 56eda14cbcSMatt Macy 57eda14cbcSMatt Macy int 58eda14cbcSMatt Macy zap_hashbits(zap_t *zap) 59eda14cbcSMatt Macy { 60eda14cbcSMatt Macy if (zap_getflags(zap) & ZAP_FLAG_HASH64) 61eda14cbcSMatt Macy return (48); 62eda14cbcSMatt Macy else 63eda14cbcSMatt Macy return (28); 64eda14cbcSMatt Macy } 65eda14cbcSMatt Macy 66eda14cbcSMatt Macy uint32_t 67eda14cbcSMatt Macy zap_maxcd(zap_t *zap) 68eda14cbcSMatt Macy { 69eda14cbcSMatt Macy if (zap_getflags(zap) & ZAP_FLAG_HASH64) 70eda14cbcSMatt Macy return ((1<<16)-1); 71eda14cbcSMatt Macy else 72eda14cbcSMatt Macy return (-1U); 73eda14cbcSMatt Macy } 74eda14cbcSMatt Macy 75eda14cbcSMatt Macy static uint64_t 76eda14cbcSMatt Macy zap_hash(zap_name_t *zn) 77eda14cbcSMatt Macy { 78eda14cbcSMatt Macy zap_t *zap = zn->zn_zap; 79eda14cbcSMatt Macy uint64_t h = 0; 80eda14cbcSMatt Macy 81eda14cbcSMatt Macy if (zap_getflags(zap) & ZAP_FLAG_PRE_HASHED_KEY) { 82eda14cbcSMatt Macy ASSERT(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY); 83eda14cbcSMatt Macy h = *(uint64_t *)zn->zn_key_orig; 84eda14cbcSMatt Macy } else { 85eda14cbcSMatt Macy h = zap->zap_salt; 86eda14cbcSMatt Macy ASSERT(h != 0); 87eda14cbcSMatt Macy ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY); 88eda14cbcSMatt Macy 89eda14cbcSMatt Macy if (zap_getflags(zap) & ZAP_FLAG_UINT64_KEY) { 90eda14cbcSMatt Macy const uint64_t *wp = zn->zn_key_norm; 91eda14cbcSMatt Macy 92eda14cbcSMatt Macy ASSERT(zn->zn_key_intlen == 8); 93eda14cbcSMatt Macy for (int i = 0; i < zn->zn_key_norm_numints; 94eda14cbcSMatt Macy wp++, i++) { 95eda14cbcSMatt Macy uint64_t word = *wp; 96eda14cbcSMatt Macy 97dbd5678dSMartin Matuska for (int j = 0; j < 8; j++) { 98eda14cbcSMatt Macy h = (h >> 8) ^ 99eda14cbcSMatt Macy zfs_crc64_table[(h ^ word) & 0xFF]; 100eda14cbcSMatt Macy word >>= NBBY; 101eda14cbcSMatt Macy } 102eda14cbcSMatt Macy } 103eda14cbcSMatt Macy } else { 104eda14cbcSMatt Macy const uint8_t *cp = zn->zn_key_norm; 105eda14cbcSMatt Macy 106eda14cbcSMatt Macy /* 107eda14cbcSMatt Macy * We previously stored the terminating null on 108eda14cbcSMatt Macy * disk, but didn't hash it, so we need to 109eda14cbcSMatt Macy * continue to not hash it. (The 110eda14cbcSMatt Macy * zn_key_*_numints includes the terminating 111eda14cbcSMatt Macy * null for non-binary keys.) 112eda14cbcSMatt Macy */ 113eda14cbcSMatt Macy int len = zn->zn_key_norm_numints - 1; 114eda14cbcSMatt Macy 115eda14cbcSMatt Macy ASSERT(zn->zn_key_intlen == 1); 116eda14cbcSMatt Macy for (int i = 0; i < len; cp++, i++) { 117eda14cbcSMatt Macy h = (h >> 8) ^ 118eda14cbcSMatt Macy zfs_crc64_table[(h ^ *cp) & 0xFF]; 119eda14cbcSMatt Macy } 120eda14cbcSMatt Macy } 121eda14cbcSMatt Macy } 122eda14cbcSMatt Macy /* 123eda14cbcSMatt Macy * Don't use all 64 bits, since we need some in the cookie for 124eda14cbcSMatt Macy * the collision differentiator. We MUST use the high bits, 125eda14cbcSMatt Macy * since those are the ones that we first pay attention to when 126eda14cbcSMatt Macy * choosing the bucket. 127eda14cbcSMatt Macy */ 128eda14cbcSMatt Macy h &= ~((1ULL << (64 - zap_hashbits(zap))) - 1); 129eda14cbcSMatt Macy 130eda14cbcSMatt Macy return (h); 131eda14cbcSMatt Macy } 132eda14cbcSMatt Macy 133eda14cbcSMatt Macy static int 134eda14cbcSMatt Macy zap_normalize(zap_t *zap, const char *name, char *namenorm, int normflags) 135eda14cbcSMatt Macy { 136eda14cbcSMatt Macy ASSERT(!(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY)); 137eda14cbcSMatt Macy 138eda14cbcSMatt Macy size_t inlen = strlen(name) + 1; 139eda14cbcSMatt Macy size_t outlen = ZAP_MAXNAMELEN; 140eda14cbcSMatt Macy 141eda14cbcSMatt Macy int err = 0; 142eda14cbcSMatt Macy (void) u8_textprep_str((char *)name, &inlen, namenorm, &outlen, 143eda14cbcSMatt Macy normflags | U8_TEXTPREP_IGNORE_NULL | U8_TEXTPREP_IGNORE_INVALID, 144eda14cbcSMatt Macy U8_UNICODE_LATEST, &err); 145eda14cbcSMatt Macy 146eda14cbcSMatt Macy return (err); 147eda14cbcSMatt Macy } 148eda14cbcSMatt Macy 149eda14cbcSMatt Macy boolean_t 150eda14cbcSMatt Macy zap_match(zap_name_t *zn, const char *matchname) 151eda14cbcSMatt Macy { 152eda14cbcSMatt Macy ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY)); 153eda14cbcSMatt Macy 154eda14cbcSMatt Macy if (zn->zn_matchtype & MT_NORMALIZE) { 155eda14cbcSMatt Macy char norm[ZAP_MAXNAMELEN]; 156eda14cbcSMatt Macy 157eda14cbcSMatt Macy if (zap_normalize(zn->zn_zap, matchname, norm, 158eda14cbcSMatt Macy zn->zn_normflags) != 0) 159eda14cbcSMatt Macy return (B_FALSE); 160eda14cbcSMatt Macy 161eda14cbcSMatt Macy return (strcmp(zn->zn_key_norm, norm) == 0); 162eda14cbcSMatt Macy } else { 163eda14cbcSMatt Macy return (strcmp(zn->zn_key_orig, matchname) == 0); 164eda14cbcSMatt Macy } 165eda14cbcSMatt Macy } 166eda14cbcSMatt Macy 167dbd5678dSMartin Matuska static zap_name_t * 168dbd5678dSMartin Matuska zap_name_alloc(zap_t *zap) 169dbd5678dSMartin Matuska { 170dbd5678dSMartin Matuska zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); 171dbd5678dSMartin Matuska zn->zn_zap = zap; 172dbd5678dSMartin Matuska return (zn); 173dbd5678dSMartin Matuska } 174dbd5678dSMartin Matuska 175eda14cbcSMatt Macy void 176eda14cbcSMatt Macy zap_name_free(zap_name_t *zn) 177eda14cbcSMatt Macy { 178eda14cbcSMatt Macy kmem_free(zn, sizeof (zap_name_t)); 179eda14cbcSMatt Macy } 180eda14cbcSMatt Macy 181dbd5678dSMartin Matuska static int 182dbd5678dSMartin Matuska zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt) 183eda14cbcSMatt Macy { 184dbd5678dSMartin Matuska zap_t *zap = zn->zn_zap; 185eda14cbcSMatt Macy 186eda14cbcSMatt Macy zn->zn_key_intlen = sizeof (*key); 187eda14cbcSMatt Macy zn->zn_key_orig = key; 188eda14cbcSMatt Macy zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1; 189eda14cbcSMatt Macy zn->zn_matchtype = mt; 190eda14cbcSMatt Macy zn->zn_normflags = zap->zap_normflags; 191eda14cbcSMatt Macy 192eda14cbcSMatt Macy /* 193eda14cbcSMatt Macy * If we're dealing with a case sensitive lookup on a mixed or 194eda14cbcSMatt Macy * insensitive fs, remove U8_TEXTPREP_TOUPPER or the lookup 195eda14cbcSMatt Macy * will fold case to all caps overriding the lookup request. 196eda14cbcSMatt Macy */ 197eda14cbcSMatt Macy if (mt & MT_MATCH_CASE) 198eda14cbcSMatt Macy zn->zn_normflags &= ~U8_TEXTPREP_TOUPPER; 199eda14cbcSMatt Macy 200eda14cbcSMatt Macy if (zap->zap_normflags) { 201eda14cbcSMatt Macy /* 202eda14cbcSMatt Macy * We *must* use zap_normflags because this normalization is 203eda14cbcSMatt Macy * what the hash is computed from. 204eda14cbcSMatt Macy */ 205eda14cbcSMatt Macy if (zap_normalize(zap, key, zn->zn_normbuf, 206dbd5678dSMartin Matuska zap->zap_normflags) != 0) 207dbd5678dSMartin Matuska return (SET_ERROR(ENOTSUP)); 208eda14cbcSMatt Macy zn->zn_key_norm = zn->zn_normbuf; 209eda14cbcSMatt Macy zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1; 210eda14cbcSMatt Macy } else { 211dbd5678dSMartin Matuska if (mt != 0) 212dbd5678dSMartin Matuska return (SET_ERROR(ENOTSUP)); 213eda14cbcSMatt Macy zn->zn_key_norm = zn->zn_key_orig; 214eda14cbcSMatt Macy zn->zn_key_norm_numints = zn->zn_key_orig_numints; 215eda14cbcSMatt Macy } 216eda14cbcSMatt Macy 217eda14cbcSMatt Macy zn->zn_hash = zap_hash(zn); 218eda14cbcSMatt Macy 219eda14cbcSMatt Macy if (zap->zap_normflags != zn->zn_normflags) { 220eda14cbcSMatt Macy /* 221eda14cbcSMatt Macy * We *must* use zn_normflags because this normalization is 222eda14cbcSMatt Macy * what the matching is based on. (Not the hash!) 223eda14cbcSMatt Macy */ 224eda14cbcSMatt Macy if (zap_normalize(zap, key, zn->zn_normbuf, 225dbd5678dSMartin Matuska zn->zn_normflags) != 0) 226dbd5678dSMartin Matuska return (SET_ERROR(ENOTSUP)); 227eda14cbcSMatt Macy zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1; 228eda14cbcSMatt Macy } 229eda14cbcSMatt Macy 230dbd5678dSMartin Matuska return (0); 231dbd5678dSMartin Matuska } 232dbd5678dSMartin Matuska 233dbd5678dSMartin Matuska zap_name_t * 234dbd5678dSMartin Matuska zap_name_alloc_str(zap_t *zap, const char *key, matchtype_t mt) 235dbd5678dSMartin Matuska { 236dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc(zap); 237dbd5678dSMartin Matuska if (zap_name_init_str(zn, key, mt) != 0) { 238dbd5678dSMartin Matuska zap_name_free(zn); 239dbd5678dSMartin Matuska return (NULL); 240dbd5678dSMartin Matuska } 241eda14cbcSMatt Macy return (zn); 242eda14cbcSMatt Macy } 243eda14cbcSMatt Macy 244eda14cbcSMatt Macy static zap_name_t * 245eda14cbcSMatt Macy zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints) 246eda14cbcSMatt Macy { 247eda14cbcSMatt Macy zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); 248eda14cbcSMatt Macy 249eda14cbcSMatt Macy ASSERT(zap->zap_normflags == 0); 250eda14cbcSMatt Macy zn->zn_zap = zap; 251eda14cbcSMatt Macy zn->zn_key_intlen = sizeof (*key); 252eda14cbcSMatt Macy zn->zn_key_orig = zn->zn_key_norm = key; 253eda14cbcSMatt Macy zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints; 254eda14cbcSMatt Macy zn->zn_matchtype = 0; 255eda14cbcSMatt Macy 256eda14cbcSMatt Macy zn->zn_hash = zap_hash(zn); 257eda14cbcSMatt Macy return (zn); 258eda14cbcSMatt Macy } 259eda14cbcSMatt Macy 260eda14cbcSMatt Macy static void 261eda14cbcSMatt Macy mzap_byteswap(mzap_phys_t *buf, size_t size) 262eda14cbcSMatt Macy { 263eda14cbcSMatt Macy buf->mz_block_type = BSWAP_64(buf->mz_block_type); 264eda14cbcSMatt Macy buf->mz_salt = BSWAP_64(buf->mz_salt); 265eda14cbcSMatt Macy buf->mz_normflags = BSWAP_64(buf->mz_normflags); 266eda14cbcSMatt Macy int max = (size / MZAP_ENT_LEN) - 1; 267eda14cbcSMatt Macy for (int i = 0; i < max; i++) { 268eda14cbcSMatt Macy buf->mz_chunk[i].mze_value = 269eda14cbcSMatt Macy BSWAP_64(buf->mz_chunk[i].mze_value); 270eda14cbcSMatt Macy buf->mz_chunk[i].mze_cd = 271eda14cbcSMatt Macy BSWAP_32(buf->mz_chunk[i].mze_cd); 272eda14cbcSMatt Macy } 273eda14cbcSMatt Macy } 274eda14cbcSMatt Macy 275eda14cbcSMatt Macy void 276eda14cbcSMatt Macy zap_byteswap(void *buf, size_t size) 277eda14cbcSMatt Macy { 278eda14cbcSMatt Macy uint64_t block_type = *(uint64_t *)buf; 279eda14cbcSMatt Macy 280eda14cbcSMatt Macy if (block_type == ZBT_MICRO || block_type == BSWAP_64(ZBT_MICRO)) { 281eda14cbcSMatt Macy /* ASSERT(magic == ZAP_LEAF_MAGIC); */ 282eda14cbcSMatt Macy mzap_byteswap(buf, size); 283eda14cbcSMatt Macy } else { 284eda14cbcSMatt Macy fzap_byteswap(buf, size); 285eda14cbcSMatt Macy } 286eda14cbcSMatt Macy } 287eda14cbcSMatt Macy 2884e8d558cSMartin Matuska __attribute__((always_inline)) inline 289eda14cbcSMatt Macy static int 290eda14cbcSMatt Macy mze_compare(const void *arg1, const void *arg2) 291eda14cbcSMatt Macy { 292eda14cbcSMatt Macy const mzap_ent_t *mze1 = arg1; 293eda14cbcSMatt Macy const mzap_ent_t *mze2 = arg2; 294eda14cbcSMatt Macy 295dbd5678dSMartin Matuska return (TREE_CMP((uint64_t)(mze1->mze_hash) << 32 | mze1->mze_cd, 296dbd5678dSMartin Matuska (uint64_t)(mze2->mze_hash) << 32 | mze2->mze_cd)); 297eda14cbcSMatt Macy } 298eda14cbcSMatt Macy 2994e8d558cSMartin Matuska ZFS_BTREE_FIND_IN_BUF_FUNC(mze_find_in_buf, mzap_ent_t, 3004e8d558cSMartin Matuska mze_compare) 3014e8d558cSMartin Matuska 302eda14cbcSMatt Macy static void 303dbd5678dSMartin Matuska mze_insert(zap_t *zap, uint16_t chunkid, uint64_t hash) 304eda14cbcSMatt Macy { 305dbd5678dSMartin Matuska mzap_ent_t mze; 306dbd5678dSMartin Matuska 307eda14cbcSMatt Macy ASSERT(zap->zap_ismicro); 308eda14cbcSMatt Macy ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 309eda14cbcSMatt Macy 310dbd5678dSMartin Matuska mze.mze_chunkid = chunkid; 311dbd5678dSMartin Matuska ASSERT0(hash & 0xffffffff); 312dbd5678dSMartin Matuska mze.mze_hash = hash >> 32; 313dbd5678dSMartin Matuska ASSERT3U(MZE_PHYS(zap, &mze)->mze_cd, <=, 0xffff); 314dbd5678dSMartin Matuska mze.mze_cd = (uint16_t)MZE_PHYS(zap, &mze)->mze_cd; 315dbd5678dSMartin Matuska ASSERT(MZE_PHYS(zap, &mze)->mze_name[0] != 0); 316dbd5678dSMartin Matuska zfs_btree_add(&zap->zap_m.zap_tree, &mze); 317eda14cbcSMatt Macy } 318eda14cbcSMatt Macy 319eda14cbcSMatt Macy static mzap_ent_t * 320dbd5678dSMartin Matuska mze_find(zap_name_t *zn, zfs_btree_index_t *idx) 321eda14cbcSMatt Macy { 322eda14cbcSMatt Macy mzap_ent_t mze_tofind; 323eda14cbcSMatt Macy mzap_ent_t *mze; 324dbd5678dSMartin Matuska zfs_btree_t *tree = &zn->zn_zap->zap_m.zap_tree; 325eda14cbcSMatt Macy 326eda14cbcSMatt Macy ASSERT(zn->zn_zap->zap_ismicro); 327eda14cbcSMatt Macy ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock)); 328eda14cbcSMatt Macy 329dbd5678dSMartin Matuska ASSERT0(zn->zn_hash & 0xffffffff); 330dbd5678dSMartin Matuska mze_tofind.mze_hash = zn->zn_hash >> 32; 331eda14cbcSMatt Macy mze_tofind.mze_cd = 0; 332eda14cbcSMatt Macy 333dbd5678dSMartin Matuska mze = zfs_btree_find(tree, &mze_tofind, idx); 334eda14cbcSMatt Macy if (mze == NULL) 335dbd5678dSMartin Matuska mze = zfs_btree_next(tree, idx, idx); 336dbd5678dSMartin Matuska for (; mze && mze->mze_hash == mze_tofind.mze_hash; 337dbd5678dSMartin Matuska mze = zfs_btree_next(tree, idx, idx)) { 338eda14cbcSMatt Macy ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd); 339eda14cbcSMatt Macy if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name)) 340eda14cbcSMatt Macy return (mze); 341eda14cbcSMatt Macy } 342eda14cbcSMatt Macy 343eda14cbcSMatt Macy return (NULL); 344eda14cbcSMatt Macy } 345eda14cbcSMatt Macy 346eda14cbcSMatt Macy static uint32_t 347eda14cbcSMatt Macy mze_find_unused_cd(zap_t *zap, uint64_t hash) 348eda14cbcSMatt Macy { 349eda14cbcSMatt Macy mzap_ent_t mze_tofind; 350dbd5678dSMartin Matuska zfs_btree_index_t idx; 351dbd5678dSMartin Matuska zfs_btree_t *tree = &zap->zap_m.zap_tree; 352eda14cbcSMatt Macy 353eda14cbcSMatt Macy ASSERT(zap->zap_ismicro); 354eda14cbcSMatt Macy ASSERT(RW_LOCK_HELD(&zap->zap_rwlock)); 355eda14cbcSMatt Macy 356dbd5678dSMartin Matuska ASSERT0(hash & 0xffffffff); 357dbd5678dSMartin Matuska hash >>= 32; 358eda14cbcSMatt Macy mze_tofind.mze_hash = hash; 359eda14cbcSMatt Macy mze_tofind.mze_cd = 0; 360eda14cbcSMatt Macy 361eda14cbcSMatt Macy uint32_t cd = 0; 362dbd5678dSMartin Matuska for (mzap_ent_t *mze = zfs_btree_find(tree, &mze_tofind, &idx); 363dbd5678dSMartin Matuska mze && mze->mze_hash == hash; 364dbd5678dSMartin Matuska mze = zfs_btree_next(tree, &idx, &idx)) { 365eda14cbcSMatt Macy if (mze->mze_cd != cd) 366eda14cbcSMatt Macy break; 367eda14cbcSMatt Macy cd++; 368eda14cbcSMatt Macy } 369eda14cbcSMatt Macy 370eda14cbcSMatt Macy return (cd); 371eda14cbcSMatt Macy } 372eda14cbcSMatt Macy 373eda14cbcSMatt Macy /* 374eda14cbcSMatt Macy * Each mzap entry requires at max : 4 chunks 375eda14cbcSMatt Macy * 3 chunks for names + 1 chunk for value. 376eda14cbcSMatt Macy */ 377eda14cbcSMatt Macy #define MZAP_ENT_CHUNKS (1 + ZAP_LEAF_ARRAY_NCHUNKS(MZAP_NAME_LEN) + \ 378eda14cbcSMatt Macy ZAP_LEAF_ARRAY_NCHUNKS(sizeof (uint64_t))) 379eda14cbcSMatt Macy 380eda14cbcSMatt Macy /* 381eda14cbcSMatt Macy * Check if the current entry keeps the colliding entries under the fatzap leaf 382eda14cbcSMatt Macy * size. 383eda14cbcSMatt Macy */ 384eda14cbcSMatt Macy static boolean_t 385eda14cbcSMatt Macy mze_canfit_fzap_leaf(zap_name_t *zn, uint64_t hash) 386eda14cbcSMatt Macy { 387eda14cbcSMatt Macy zap_t *zap = zn->zn_zap; 388eda14cbcSMatt Macy mzap_ent_t mze_tofind; 389dbd5678dSMartin Matuska zfs_btree_index_t idx; 390dbd5678dSMartin Matuska zfs_btree_t *tree = &zap->zap_m.zap_tree; 391eda14cbcSMatt Macy uint32_t mzap_ents = 0; 392eda14cbcSMatt Macy 393dbd5678dSMartin Matuska ASSERT0(hash & 0xffffffff); 394dbd5678dSMartin Matuska hash >>= 32; 395eda14cbcSMatt Macy mze_tofind.mze_hash = hash; 396eda14cbcSMatt Macy mze_tofind.mze_cd = 0; 397eda14cbcSMatt Macy 398dbd5678dSMartin Matuska for (mzap_ent_t *mze = zfs_btree_find(tree, &mze_tofind, &idx); 399dbd5678dSMartin Matuska mze && mze->mze_hash == hash; 400dbd5678dSMartin Matuska mze = zfs_btree_next(tree, &idx, &idx)) { 401eda14cbcSMatt Macy mzap_ents++; 402eda14cbcSMatt Macy } 403eda14cbcSMatt Macy 404eda14cbcSMatt Macy /* Include the new entry being added */ 405eda14cbcSMatt Macy mzap_ents++; 406eda14cbcSMatt Macy 407eda14cbcSMatt Macy return (ZAP_LEAF_NUMCHUNKS_DEF > (mzap_ents * MZAP_ENT_CHUNKS)); 408eda14cbcSMatt Macy } 409eda14cbcSMatt Macy 410eda14cbcSMatt Macy static void 411eda14cbcSMatt Macy mze_destroy(zap_t *zap) 412eda14cbcSMatt Macy { 413dbd5678dSMartin Matuska zfs_btree_clear(&zap->zap_m.zap_tree); 414dbd5678dSMartin Matuska zfs_btree_destroy(&zap->zap_m.zap_tree); 415eda14cbcSMatt Macy } 416eda14cbcSMatt Macy 417eda14cbcSMatt Macy static zap_t * 418*783d3ff6SMartin Matuska mzap_open(dmu_buf_t *db) 419eda14cbcSMatt Macy { 420eda14cbcSMatt Macy zap_t *winner; 421eda14cbcSMatt Macy uint64_t *zap_hdr = (uint64_t *)db->db_data; 422eda14cbcSMatt Macy uint64_t zap_block_type = zap_hdr[0]; 423eda14cbcSMatt Macy uint64_t zap_magic = zap_hdr[1]; 424eda14cbcSMatt Macy 425eda14cbcSMatt Macy ASSERT3U(MZAP_ENT_LEN, ==, sizeof (mzap_ent_phys_t)); 426eda14cbcSMatt Macy 427eda14cbcSMatt Macy zap_t *zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP); 428eda14cbcSMatt Macy rw_init(&zap->zap_rwlock, NULL, RW_DEFAULT, NULL); 429eda14cbcSMatt Macy rw_enter(&zap->zap_rwlock, RW_WRITER); 430*783d3ff6SMartin Matuska zap->zap_objset = dmu_buf_get_objset(db); 431*783d3ff6SMartin Matuska zap->zap_object = db->db_object; 432eda14cbcSMatt Macy zap->zap_dbuf = db; 433eda14cbcSMatt Macy 434eda14cbcSMatt Macy if (zap_block_type != ZBT_MICRO) { 435eda14cbcSMatt Macy mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, MUTEX_DEFAULT, 436eda14cbcSMatt Macy 0); 437eda14cbcSMatt Macy zap->zap_f.zap_block_shift = highbit64(db->db_size) - 1; 438eda14cbcSMatt Macy if (zap_block_type != ZBT_HEADER || zap_magic != ZAP_MAGIC) { 439eda14cbcSMatt Macy winner = NULL; /* No actual winner here... */ 440eda14cbcSMatt Macy goto handle_winner; 441eda14cbcSMatt Macy } 442eda14cbcSMatt Macy } else { 443eda14cbcSMatt Macy zap->zap_ismicro = TRUE; 444eda14cbcSMatt Macy } 445eda14cbcSMatt Macy 446eda14cbcSMatt Macy /* 447eda14cbcSMatt Macy * Make sure that zap_ismicro is set before we let others see 448eda14cbcSMatt Macy * it, because zap_lockdir() checks zap_ismicro without the lock 449eda14cbcSMatt Macy * held. 450eda14cbcSMatt Macy */ 451eda14cbcSMatt Macy dmu_buf_init_user(&zap->zap_dbu, zap_evict_sync, NULL, &zap->zap_dbuf); 452eda14cbcSMatt Macy winner = dmu_buf_set_user(db, &zap->zap_dbu); 453eda14cbcSMatt Macy 454eda14cbcSMatt Macy if (winner != NULL) 455eda14cbcSMatt Macy goto handle_winner; 456eda14cbcSMatt Macy 457eda14cbcSMatt Macy if (zap->zap_ismicro) { 458eda14cbcSMatt Macy zap->zap_salt = zap_m_phys(zap)->mz_salt; 459eda14cbcSMatt Macy zap->zap_normflags = zap_m_phys(zap)->mz_normflags; 460eda14cbcSMatt Macy zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1; 461eda14cbcSMatt Macy 462dbd5678dSMartin Matuska /* 463dbd5678dSMartin Matuska * Reduce B-tree leaf from 4KB to 512 bytes to reduce memmove() 464dbd5678dSMartin Matuska * overhead on massive inserts below. It still allows to store 465dbd5678dSMartin Matuska * 62 entries before we have to add 2KB B-tree core node. 466dbd5678dSMartin Matuska */ 467dbd5678dSMartin Matuska zfs_btree_create_custom(&zap->zap_m.zap_tree, mze_compare, 4684e8d558cSMartin Matuska mze_find_in_buf, sizeof (mzap_ent_t), 512); 469dbd5678dSMartin Matuska 470dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc(zap); 471dbd5678dSMartin Matuska for (uint16_t i = 0; i < zap->zap_m.zap_num_chunks; i++) { 472eda14cbcSMatt Macy mzap_ent_phys_t *mze = 473eda14cbcSMatt Macy &zap_m_phys(zap)->mz_chunk[i]; 474eda14cbcSMatt Macy if (mze->mze_name[0]) { 475eda14cbcSMatt Macy zap->zap_m.zap_num_entries++; 476dbd5678dSMartin Matuska zap_name_init_str(zn, mze->mze_name, 0); 477eda14cbcSMatt Macy mze_insert(zap, i, zn->zn_hash); 478dbd5678dSMartin Matuska } 479dbd5678dSMartin Matuska } 480eda14cbcSMatt Macy zap_name_free(zn); 481eda14cbcSMatt Macy } else { 482eda14cbcSMatt Macy zap->zap_salt = zap_f_phys(zap)->zap_salt; 483eda14cbcSMatt Macy zap->zap_normflags = zap_f_phys(zap)->zap_normflags; 484eda14cbcSMatt Macy 485eda14cbcSMatt Macy ASSERT3U(sizeof (struct zap_leaf_header), ==, 486eda14cbcSMatt Macy 2*ZAP_LEAF_CHUNKSIZE); 487eda14cbcSMatt Macy 488eda14cbcSMatt Macy /* 489eda14cbcSMatt Macy * The embedded pointer table should not overlap the 490eda14cbcSMatt Macy * other members. 491eda14cbcSMatt Macy */ 492eda14cbcSMatt Macy ASSERT3P(&ZAP_EMBEDDED_PTRTBL_ENT(zap, 0), >, 493eda14cbcSMatt Macy &zap_f_phys(zap)->zap_salt); 494eda14cbcSMatt Macy 495eda14cbcSMatt Macy /* 496eda14cbcSMatt Macy * The embedded pointer table should end at the end of 497eda14cbcSMatt Macy * the block 498eda14cbcSMatt Macy */ 499eda14cbcSMatt Macy ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap, 500eda14cbcSMatt Macy 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) - 501eda14cbcSMatt Macy (uintptr_t)zap_f_phys(zap), ==, 502eda14cbcSMatt Macy zap->zap_dbuf->db_size); 503eda14cbcSMatt Macy } 504eda14cbcSMatt Macy rw_exit(&zap->zap_rwlock); 505eda14cbcSMatt Macy return (zap); 506eda14cbcSMatt Macy 507eda14cbcSMatt Macy handle_winner: 508eda14cbcSMatt Macy rw_exit(&zap->zap_rwlock); 509eda14cbcSMatt Macy rw_destroy(&zap->zap_rwlock); 510eda14cbcSMatt Macy if (!zap->zap_ismicro) 511eda14cbcSMatt Macy mutex_destroy(&zap->zap_f.zap_num_entries_mtx); 512eda14cbcSMatt Macy kmem_free(zap, sizeof (zap_t)); 513eda14cbcSMatt Macy return (winner); 514eda14cbcSMatt Macy } 515eda14cbcSMatt Macy 516eda14cbcSMatt Macy /* 517eda14cbcSMatt Macy * This routine "consumes" the caller's hold on the dbuf, which must 518eda14cbcSMatt Macy * have the specified tag. 519eda14cbcSMatt Macy */ 520eda14cbcSMatt Macy static int 521*783d3ff6SMartin Matuska zap_lockdir_impl(dnode_t *dn, dmu_buf_t *db, const void *tag, dmu_tx_t *tx, 522eda14cbcSMatt Macy krw_t lti, boolean_t fatreader, boolean_t adding, zap_t **zapp) 523eda14cbcSMatt Macy { 524eda14cbcSMatt Macy ASSERT0(db->db_offset); 525eda14cbcSMatt Macy objset_t *os = dmu_buf_get_objset(db); 526eda14cbcSMatt Macy uint64_t obj = db->db_object; 527eda14cbcSMatt Macy dmu_object_info_t doi; 528eda14cbcSMatt Macy 529eda14cbcSMatt Macy *zapp = NULL; 530eda14cbcSMatt Macy 531*783d3ff6SMartin Matuska dmu_object_info_from_dnode(dn, &doi); 532eda14cbcSMatt Macy if (DMU_OT_BYTESWAP(doi.doi_type) != DMU_BSWAP_ZAP) 533eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 534eda14cbcSMatt Macy 535eda14cbcSMatt Macy zap_t *zap = dmu_buf_get_user(db); 536eda14cbcSMatt Macy if (zap == NULL) { 537*783d3ff6SMartin Matuska zap = mzap_open(db); 538eda14cbcSMatt Macy if (zap == NULL) { 539eda14cbcSMatt Macy /* 540eda14cbcSMatt Macy * mzap_open() didn't like what it saw on-disk. 541eda14cbcSMatt Macy * Check for corruption! 542eda14cbcSMatt Macy */ 543eda14cbcSMatt Macy return (SET_ERROR(EIO)); 544eda14cbcSMatt Macy } 545eda14cbcSMatt Macy } 546eda14cbcSMatt Macy 547eda14cbcSMatt Macy /* 548eda14cbcSMatt Macy * We're checking zap_ismicro without the lock held, in order to 549eda14cbcSMatt Macy * tell what type of lock we want. Once we have some sort of 550eda14cbcSMatt Macy * lock, see if it really is the right type. In practice this 551eda14cbcSMatt Macy * can only be different if it was upgraded from micro to fat, 552eda14cbcSMatt Macy * and micro wanted WRITER but fat only needs READER. 553eda14cbcSMatt Macy */ 554eda14cbcSMatt Macy krw_t lt = (!zap->zap_ismicro && fatreader) ? RW_READER : lti; 555eda14cbcSMatt Macy rw_enter(&zap->zap_rwlock, lt); 556eda14cbcSMatt Macy if (lt != ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)) { 557eda14cbcSMatt Macy /* it was upgraded, now we only need reader */ 558eda14cbcSMatt Macy ASSERT(lt == RW_WRITER); 559eda14cbcSMatt Macy ASSERT(RW_READER == 560eda14cbcSMatt Macy ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)); 561eda14cbcSMatt Macy rw_downgrade(&zap->zap_rwlock); 562eda14cbcSMatt Macy lt = RW_READER; 563eda14cbcSMatt Macy } 564eda14cbcSMatt Macy 565eda14cbcSMatt Macy zap->zap_objset = os; 566*783d3ff6SMartin Matuska zap->zap_dnode = dn; 567eda14cbcSMatt Macy 568eda14cbcSMatt Macy if (lt == RW_WRITER) 569eda14cbcSMatt Macy dmu_buf_will_dirty(db, tx); 570eda14cbcSMatt Macy 571eda14cbcSMatt Macy ASSERT3P(zap->zap_dbuf, ==, db); 572eda14cbcSMatt Macy 573eda14cbcSMatt Macy ASSERT(!zap->zap_ismicro || 574eda14cbcSMatt Macy zap->zap_m.zap_num_entries <= zap->zap_m.zap_num_chunks); 575eda14cbcSMatt Macy if (zap->zap_ismicro && tx && adding && 576eda14cbcSMatt Macy zap->zap_m.zap_num_entries == zap->zap_m.zap_num_chunks) { 577eda14cbcSMatt Macy uint64_t newsz = db->db_size + SPA_MINBLOCKSIZE; 57815f0b8c3SMartin Matuska if (newsz > zap_micro_max_size) { 579eda14cbcSMatt Macy dprintf("upgrading obj %llu: num_entries=%u\n", 58033b8c039SMartin Matuska (u_longlong_t)obj, zap->zap_m.zap_num_entries); 581eda14cbcSMatt Macy *zapp = zap; 582eda14cbcSMatt Macy int err = mzap_upgrade(zapp, tag, tx, 0); 583eda14cbcSMatt Macy if (err != 0) 584eda14cbcSMatt Macy rw_exit(&zap->zap_rwlock); 585eda14cbcSMatt Macy return (err); 586eda14cbcSMatt Macy } 587eda14cbcSMatt Macy VERIFY0(dmu_object_set_blocksize(os, obj, newsz, 0, tx)); 588eda14cbcSMatt Macy zap->zap_m.zap_num_chunks = 589eda14cbcSMatt Macy db->db_size / MZAP_ENT_LEN - 1; 590eda14cbcSMatt Macy } 591eda14cbcSMatt Macy 592eda14cbcSMatt Macy *zapp = zap; 593eda14cbcSMatt Macy return (0); 594eda14cbcSMatt Macy } 595eda14cbcSMatt Macy 596eda14cbcSMatt Macy static int 597eda14cbcSMatt Macy zap_lockdir_by_dnode(dnode_t *dn, dmu_tx_t *tx, 598a0b956f5SMartin Matuska krw_t lti, boolean_t fatreader, boolean_t adding, const void *tag, 599a0b956f5SMartin Matuska zap_t **zapp) 600eda14cbcSMatt Macy { 601eda14cbcSMatt Macy dmu_buf_t *db; 602*783d3ff6SMartin Matuska int err; 603eda14cbcSMatt Macy 604*783d3ff6SMartin Matuska err = dmu_buf_hold_by_dnode(dn, 0, tag, &db, DMU_READ_NO_PREFETCH); 605*783d3ff6SMartin Matuska if (err != 0) 606eda14cbcSMatt Macy return (err); 607*783d3ff6SMartin Matuska err = zap_lockdir_impl(dn, db, tag, tx, lti, fatreader, adding, zapp); 608*783d3ff6SMartin Matuska if (err != 0) 609eda14cbcSMatt Macy dmu_buf_rele(db, tag); 610*783d3ff6SMartin Matuska else 611*783d3ff6SMartin Matuska VERIFY(dnode_add_ref(dn, tag)); 612eda14cbcSMatt Macy return (err); 613eda14cbcSMatt Macy } 614eda14cbcSMatt Macy 615eda14cbcSMatt Macy int 616eda14cbcSMatt Macy zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx, 617a0b956f5SMartin Matuska krw_t lti, boolean_t fatreader, boolean_t adding, const void *tag, 618a0b956f5SMartin Matuska zap_t **zapp) 619eda14cbcSMatt Macy { 620*783d3ff6SMartin Matuska dnode_t *dn; 621eda14cbcSMatt Macy dmu_buf_t *db; 622*783d3ff6SMartin Matuska int err; 623eda14cbcSMatt Macy 624*783d3ff6SMartin Matuska err = dnode_hold(os, obj, tag, &dn); 625eda14cbcSMatt Macy if (err != 0) 626eda14cbcSMatt Macy return (err); 627*783d3ff6SMartin Matuska err = dmu_buf_hold_by_dnode(dn, 0, tag, &db, DMU_READ_NO_PREFETCH); 628*783d3ff6SMartin Matuska if (err != 0) { 629*783d3ff6SMartin Matuska dnode_rele(dn, tag); 630*783d3ff6SMartin Matuska return (err); 631eda14cbcSMatt Macy } 632*783d3ff6SMartin Matuska err = zap_lockdir_impl(dn, db, tag, tx, lti, fatreader, adding, zapp); 633*783d3ff6SMartin Matuska if (err != 0) { 634eda14cbcSMatt Macy dmu_buf_rele(db, tag); 635*783d3ff6SMartin Matuska dnode_rele(dn, tag); 636*783d3ff6SMartin Matuska } 637eda14cbcSMatt Macy return (err); 638eda14cbcSMatt Macy } 639eda14cbcSMatt Macy 640eda14cbcSMatt Macy void 641a0b956f5SMartin Matuska zap_unlockdir(zap_t *zap, const void *tag) 642eda14cbcSMatt Macy { 643eda14cbcSMatt Macy rw_exit(&zap->zap_rwlock); 644*783d3ff6SMartin Matuska dnode_rele(zap->zap_dnode, tag); 645eda14cbcSMatt Macy dmu_buf_rele(zap->zap_dbuf, tag); 646eda14cbcSMatt Macy } 647eda14cbcSMatt Macy 648eda14cbcSMatt Macy static int 649a0b956f5SMartin Matuska mzap_upgrade(zap_t **zapp, const void *tag, dmu_tx_t *tx, zap_flags_t flags) 650eda14cbcSMatt Macy { 651eda14cbcSMatt Macy int err = 0; 652eda14cbcSMatt Macy zap_t *zap = *zapp; 653eda14cbcSMatt Macy 654eda14cbcSMatt Macy ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 655eda14cbcSMatt Macy 656eda14cbcSMatt Macy int sz = zap->zap_dbuf->db_size; 657eda14cbcSMatt Macy mzap_phys_t *mzp = vmem_alloc(sz, KM_SLEEP); 658da5137abSMartin Matuska memcpy(mzp, zap->zap_dbuf->db_data, sz); 659eda14cbcSMatt Macy int nchunks = zap->zap_m.zap_num_chunks; 660eda14cbcSMatt Macy 661eda14cbcSMatt Macy if (!flags) { 662eda14cbcSMatt Macy err = dmu_object_set_blocksize(zap->zap_objset, zap->zap_object, 663eda14cbcSMatt Macy 1ULL << fzap_default_block_shift, 0, tx); 664eda14cbcSMatt Macy if (err != 0) { 665eda14cbcSMatt Macy vmem_free(mzp, sz); 666eda14cbcSMatt Macy return (err); 667eda14cbcSMatt Macy } 668eda14cbcSMatt Macy } 669eda14cbcSMatt Macy 670eda14cbcSMatt Macy dprintf("upgrading obj=%llu with %u chunks\n", 67133b8c039SMartin Matuska (u_longlong_t)zap->zap_object, nchunks); 672dbd5678dSMartin Matuska /* XXX destroy the tree later, so we can use the stored hash value */ 673eda14cbcSMatt Macy mze_destroy(zap); 674eda14cbcSMatt Macy 675eda14cbcSMatt Macy fzap_upgrade(zap, tx, flags); 676eda14cbcSMatt Macy 677dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc(zap); 678eda14cbcSMatt Macy for (int i = 0; i < nchunks; i++) { 679eda14cbcSMatt Macy mzap_ent_phys_t *mze = &mzp->mz_chunk[i]; 680eda14cbcSMatt Macy if (mze->mze_name[0] == 0) 681eda14cbcSMatt Macy continue; 682eda14cbcSMatt Macy dprintf("adding %s=%llu\n", 68333b8c039SMartin Matuska mze->mze_name, (u_longlong_t)mze->mze_value); 684dbd5678dSMartin Matuska zap_name_init_str(zn, mze->mze_name, 0); 685eda14cbcSMatt Macy /* If we fail here, we would end up losing entries */ 686eda14cbcSMatt Macy VERIFY0(fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, 687eda14cbcSMatt Macy tag, tx)); 688eda14cbcSMatt Macy zap = zn->zn_zap; /* fzap_add_cd() may change zap */ 689eda14cbcSMatt Macy } 690dbd5678dSMartin Matuska zap_name_free(zn); 691eda14cbcSMatt Macy vmem_free(mzp, sz); 692eda14cbcSMatt Macy *zapp = zap; 693eda14cbcSMatt Macy return (0); 694eda14cbcSMatt Macy } 695eda14cbcSMatt Macy 696eda14cbcSMatt Macy /* 697eda14cbcSMatt Macy * The "normflags" determine the behavior of the matchtype_t which is 698eda14cbcSMatt Macy * passed to zap_lookup_norm(). Names which have the same normalized 699eda14cbcSMatt Macy * version will be stored with the same hash value, and therefore we can 700eda14cbcSMatt Macy * perform normalization-insensitive lookups. We can be Unicode form- 701eda14cbcSMatt Macy * insensitive and/or case-insensitive. The following flags are valid for 702eda14cbcSMatt Macy * "normflags": 703eda14cbcSMatt Macy * 704eda14cbcSMatt Macy * U8_TEXTPREP_NFC 705eda14cbcSMatt Macy * U8_TEXTPREP_NFD 706eda14cbcSMatt Macy * U8_TEXTPREP_NFKC 707eda14cbcSMatt Macy * U8_TEXTPREP_NFKD 708eda14cbcSMatt Macy * U8_TEXTPREP_TOUPPER 709eda14cbcSMatt Macy * 710eda14cbcSMatt Macy * The *_NF* (Normalization Form) flags are mutually exclusive; at most one 711eda14cbcSMatt Macy * of them may be supplied. 712eda14cbcSMatt Macy */ 713eda14cbcSMatt Macy void 714eda14cbcSMatt Macy mzap_create_impl(dnode_t *dn, int normflags, zap_flags_t flags, dmu_tx_t *tx) 715eda14cbcSMatt Macy { 716eda14cbcSMatt Macy dmu_buf_t *db; 717eda14cbcSMatt Macy 718eda14cbcSMatt Macy VERIFY0(dmu_buf_hold_by_dnode(dn, 0, FTAG, &db, DMU_READ_NO_PREFETCH)); 719eda14cbcSMatt Macy 720eda14cbcSMatt Macy dmu_buf_will_dirty(db, tx); 721eda14cbcSMatt Macy mzap_phys_t *zp = db->db_data; 722eda14cbcSMatt Macy zp->mz_block_type = ZBT_MICRO; 723eda14cbcSMatt Macy zp->mz_salt = 724eda14cbcSMatt Macy ((uintptr_t)db ^ (uintptr_t)tx ^ (dn->dn_object << 1)) | 1ULL; 725eda14cbcSMatt Macy zp->mz_normflags = normflags; 726eda14cbcSMatt Macy 727eda14cbcSMatt Macy if (flags != 0) { 728eda14cbcSMatt Macy zap_t *zap; 729eda14cbcSMatt Macy /* Only fat zap supports flags; upgrade immediately. */ 730*783d3ff6SMartin Matuska VERIFY(dnode_add_ref(dn, FTAG)); 731*783d3ff6SMartin Matuska VERIFY0(zap_lockdir_impl(dn, db, FTAG, tx, RW_WRITER, 732eda14cbcSMatt Macy B_FALSE, B_FALSE, &zap)); 733eda14cbcSMatt Macy VERIFY0(mzap_upgrade(&zap, FTAG, tx, flags)); 734eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 735eda14cbcSMatt Macy } else { 736eda14cbcSMatt Macy dmu_buf_rele(db, FTAG); 737eda14cbcSMatt Macy } 738eda14cbcSMatt Macy } 739eda14cbcSMatt Macy 740eda14cbcSMatt Macy static uint64_t 741eda14cbcSMatt Macy zap_create_impl(objset_t *os, int normflags, zap_flags_t flags, 742eda14cbcSMatt Macy dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift, 743eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, int dnodesize, 744a0b956f5SMartin Matuska dnode_t **allocated_dnode, const void *tag, dmu_tx_t *tx) 745eda14cbcSMatt Macy { 746eda14cbcSMatt Macy uint64_t obj; 747eda14cbcSMatt Macy 748eda14cbcSMatt Macy ASSERT3U(DMU_OT_BYTESWAP(ot), ==, DMU_BSWAP_ZAP); 749eda14cbcSMatt Macy 750eda14cbcSMatt Macy if (allocated_dnode == NULL) { 751eda14cbcSMatt Macy dnode_t *dn; 752eda14cbcSMatt Macy obj = dmu_object_alloc_hold(os, ot, 1ULL << leaf_blockshift, 753eda14cbcSMatt Macy indirect_blockshift, bonustype, bonuslen, dnodesize, 754eda14cbcSMatt Macy &dn, FTAG, tx); 755eda14cbcSMatt Macy mzap_create_impl(dn, normflags, flags, tx); 756eda14cbcSMatt Macy dnode_rele(dn, FTAG); 757eda14cbcSMatt Macy } else { 758eda14cbcSMatt Macy obj = dmu_object_alloc_hold(os, ot, 1ULL << leaf_blockshift, 759eda14cbcSMatt Macy indirect_blockshift, bonustype, bonuslen, dnodesize, 760eda14cbcSMatt Macy allocated_dnode, tag, tx); 761eda14cbcSMatt Macy mzap_create_impl(*allocated_dnode, normflags, flags, tx); 762eda14cbcSMatt Macy } 763eda14cbcSMatt Macy 764eda14cbcSMatt Macy return (obj); 765eda14cbcSMatt Macy } 766eda14cbcSMatt Macy 767eda14cbcSMatt Macy int 768eda14cbcSMatt Macy zap_create_claim(objset_t *os, uint64_t obj, dmu_object_type_t ot, 769eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 770eda14cbcSMatt Macy { 771eda14cbcSMatt Macy return (zap_create_claim_dnsize(os, obj, ot, bonustype, bonuslen, 772eda14cbcSMatt Macy 0, tx)); 773eda14cbcSMatt Macy } 774eda14cbcSMatt Macy 775eda14cbcSMatt Macy int 776eda14cbcSMatt Macy zap_create_claim_dnsize(objset_t *os, uint64_t obj, dmu_object_type_t ot, 777eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx) 778eda14cbcSMatt Macy { 779eda14cbcSMatt Macy return (zap_create_claim_norm_dnsize(os, obj, 780eda14cbcSMatt Macy 0, ot, bonustype, bonuslen, dnodesize, tx)); 781eda14cbcSMatt Macy } 782eda14cbcSMatt Macy 783eda14cbcSMatt Macy int 784eda14cbcSMatt Macy zap_create_claim_norm(objset_t *os, uint64_t obj, int normflags, 785eda14cbcSMatt Macy dmu_object_type_t ot, 786eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 787eda14cbcSMatt Macy { 788eda14cbcSMatt Macy return (zap_create_claim_norm_dnsize(os, obj, normflags, ot, bonustype, 789eda14cbcSMatt Macy bonuslen, 0, tx)); 790eda14cbcSMatt Macy } 791eda14cbcSMatt Macy 792eda14cbcSMatt Macy int 793eda14cbcSMatt Macy zap_create_claim_norm_dnsize(objset_t *os, uint64_t obj, int normflags, 794eda14cbcSMatt Macy dmu_object_type_t ot, dmu_object_type_t bonustype, int bonuslen, 795eda14cbcSMatt Macy int dnodesize, dmu_tx_t *tx) 796eda14cbcSMatt Macy { 797eda14cbcSMatt Macy dnode_t *dn; 798eda14cbcSMatt Macy int error; 799eda14cbcSMatt Macy 800eda14cbcSMatt Macy ASSERT3U(DMU_OT_BYTESWAP(ot), ==, DMU_BSWAP_ZAP); 801eda14cbcSMatt Macy error = dmu_object_claim_dnsize(os, obj, ot, 0, bonustype, bonuslen, 802eda14cbcSMatt Macy dnodesize, tx); 803eda14cbcSMatt Macy if (error != 0) 804eda14cbcSMatt Macy return (error); 805eda14cbcSMatt Macy 806eda14cbcSMatt Macy error = dnode_hold(os, obj, FTAG, &dn); 807eda14cbcSMatt Macy if (error != 0) 808eda14cbcSMatt Macy return (error); 809eda14cbcSMatt Macy 810eda14cbcSMatt Macy mzap_create_impl(dn, normflags, 0, tx); 811eda14cbcSMatt Macy 812eda14cbcSMatt Macy dnode_rele(dn, FTAG); 813eda14cbcSMatt Macy 814eda14cbcSMatt Macy return (0); 815eda14cbcSMatt Macy } 816eda14cbcSMatt Macy 817eda14cbcSMatt Macy uint64_t 818eda14cbcSMatt Macy zap_create(objset_t *os, dmu_object_type_t ot, 819eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 820eda14cbcSMatt Macy { 821eda14cbcSMatt Macy return (zap_create_norm(os, 0, ot, bonustype, bonuslen, tx)); 822eda14cbcSMatt Macy } 823eda14cbcSMatt Macy 824eda14cbcSMatt Macy uint64_t 825eda14cbcSMatt Macy zap_create_dnsize(objset_t *os, dmu_object_type_t ot, 826eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx) 827eda14cbcSMatt Macy { 828eda14cbcSMatt Macy return (zap_create_norm_dnsize(os, 0, ot, bonustype, bonuslen, 829eda14cbcSMatt Macy dnodesize, tx)); 830eda14cbcSMatt Macy } 831eda14cbcSMatt Macy 832eda14cbcSMatt Macy uint64_t 833eda14cbcSMatt Macy zap_create_norm(objset_t *os, int normflags, dmu_object_type_t ot, 834eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 835eda14cbcSMatt Macy { 836eda14cbcSMatt Macy return (zap_create_norm_dnsize(os, normflags, ot, bonustype, bonuslen, 837eda14cbcSMatt Macy 0, tx)); 838eda14cbcSMatt Macy } 839eda14cbcSMatt Macy 840eda14cbcSMatt Macy uint64_t 841eda14cbcSMatt Macy zap_create_norm_dnsize(objset_t *os, int normflags, dmu_object_type_t ot, 842eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx) 843eda14cbcSMatt Macy { 844eda14cbcSMatt Macy return (zap_create_impl(os, normflags, 0, ot, 0, 0, 845eda14cbcSMatt Macy bonustype, bonuslen, dnodesize, NULL, NULL, tx)); 846eda14cbcSMatt Macy } 847eda14cbcSMatt Macy 848eda14cbcSMatt Macy uint64_t 849eda14cbcSMatt Macy zap_create_flags(objset_t *os, int normflags, zap_flags_t flags, 850eda14cbcSMatt Macy dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift, 851eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 852eda14cbcSMatt Macy { 853eda14cbcSMatt Macy return (zap_create_flags_dnsize(os, normflags, flags, ot, 854eda14cbcSMatt Macy leaf_blockshift, indirect_blockshift, bonustype, bonuslen, 0, tx)); 855eda14cbcSMatt Macy } 856eda14cbcSMatt Macy 857eda14cbcSMatt Macy uint64_t 858eda14cbcSMatt Macy zap_create_flags_dnsize(objset_t *os, int normflags, zap_flags_t flags, 859eda14cbcSMatt Macy dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift, 860eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, int dnodesize, dmu_tx_t *tx) 861eda14cbcSMatt Macy { 862eda14cbcSMatt Macy return (zap_create_impl(os, normflags, flags, ot, leaf_blockshift, 863eda14cbcSMatt Macy indirect_blockshift, bonustype, bonuslen, dnodesize, NULL, NULL, 864eda14cbcSMatt Macy tx)); 865eda14cbcSMatt Macy } 866eda14cbcSMatt Macy 867eda14cbcSMatt Macy /* 868eda14cbcSMatt Macy * Create a zap object and return a pointer to the newly allocated dnode via 869eda14cbcSMatt Macy * the allocated_dnode argument. The returned dnode will be held and the 870eda14cbcSMatt Macy * caller is responsible for releasing the hold by calling dnode_rele(). 871eda14cbcSMatt Macy */ 872eda14cbcSMatt Macy uint64_t 873eda14cbcSMatt Macy zap_create_hold(objset_t *os, int normflags, zap_flags_t flags, 874eda14cbcSMatt Macy dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift, 875eda14cbcSMatt Macy dmu_object_type_t bonustype, int bonuslen, int dnodesize, 876a0b956f5SMartin Matuska dnode_t **allocated_dnode, const void *tag, dmu_tx_t *tx) 877eda14cbcSMatt Macy { 878eda14cbcSMatt Macy return (zap_create_impl(os, normflags, flags, ot, leaf_blockshift, 879eda14cbcSMatt Macy indirect_blockshift, bonustype, bonuslen, dnodesize, 880eda14cbcSMatt Macy allocated_dnode, tag, tx)); 881eda14cbcSMatt Macy } 882eda14cbcSMatt Macy 883eda14cbcSMatt Macy int 884eda14cbcSMatt Macy zap_destroy(objset_t *os, uint64_t zapobj, dmu_tx_t *tx) 885eda14cbcSMatt Macy { 886eda14cbcSMatt Macy /* 887eda14cbcSMatt Macy * dmu_object_free will free the object number and free the 888eda14cbcSMatt Macy * data. Freeing the data will cause our pageout function to be 889eda14cbcSMatt Macy * called, which will destroy our data (zap_leaf_t's and zap_t). 890eda14cbcSMatt Macy */ 891eda14cbcSMatt Macy 892eda14cbcSMatt Macy return (dmu_object_free(os, zapobj, tx)); 893eda14cbcSMatt Macy } 894eda14cbcSMatt Macy 895eda14cbcSMatt Macy void 896eda14cbcSMatt Macy zap_evict_sync(void *dbu) 897eda14cbcSMatt Macy { 898eda14cbcSMatt Macy zap_t *zap = dbu; 899eda14cbcSMatt Macy 900eda14cbcSMatt Macy rw_destroy(&zap->zap_rwlock); 901eda14cbcSMatt Macy 902eda14cbcSMatt Macy if (zap->zap_ismicro) 903eda14cbcSMatt Macy mze_destroy(zap); 904eda14cbcSMatt Macy else 905eda14cbcSMatt Macy mutex_destroy(&zap->zap_f.zap_num_entries_mtx); 906eda14cbcSMatt Macy 907eda14cbcSMatt Macy kmem_free(zap, sizeof (zap_t)); 908eda14cbcSMatt Macy } 909eda14cbcSMatt Macy 910eda14cbcSMatt Macy int 911eda14cbcSMatt Macy zap_count(objset_t *os, uint64_t zapobj, uint64_t *count) 912eda14cbcSMatt Macy { 913eda14cbcSMatt Macy zap_t *zap; 914eda14cbcSMatt Macy 915eda14cbcSMatt Macy int err = 916eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 917eda14cbcSMatt Macy if (err != 0) 918eda14cbcSMatt Macy return (err); 919eda14cbcSMatt Macy if (!zap->zap_ismicro) { 920eda14cbcSMatt Macy err = fzap_count(zap, count); 921eda14cbcSMatt Macy } else { 922eda14cbcSMatt Macy *count = zap->zap_m.zap_num_entries; 923eda14cbcSMatt Macy } 924eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 925eda14cbcSMatt Macy return (err); 926eda14cbcSMatt Macy } 927eda14cbcSMatt Macy 928eda14cbcSMatt Macy /* 929eda14cbcSMatt Macy * zn may be NULL; if not specified, it will be computed if needed. 930eda14cbcSMatt Macy * See also the comment above zap_entry_normalization_conflict(). 931eda14cbcSMatt Macy */ 932eda14cbcSMatt Macy static boolean_t 933dbd5678dSMartin Matuska mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze, 934dbd5678dSMartin Matuska zfs_btree_index_t *idx) 935eda14cbcSMatt Macy { 936eda14cbcSMatt Macy boolean_t allocdzn = B_FALSE; 937dbd5678dSMartin Matuska mzap_ent_t *other; 938dbd5678dSMartin Matuska zfs_btree_index_t oidx; 939eda14cbcSMatt Macy 940eda14cbcSMatt Macy if (zap->zap_normflags == 0) 941eda14cbcSMatt Macy return (B_FALSE); 942eda14cbcSMatt Macy 943dbd5678dSMartin Matuska for (other = zfs_btree_prev(&zap->zap_m.zap_tree, idx, &oidx); 944eda14cbcSMatt Macy other && other->mze_hash == mze->mze_hash; 945dbd5678dSMartin Matuska other = zfs_btree_prev(&zap->zap_m.zap_tree, &oidx, &oidx)) { 946eda14cbcSMatt Macy 947eda14cbcSMatt Macy if (zn == NULL) { 948dbd5678dSMartin Matuska zn = zap_name_alloc_str(zap, 949dbd5678dSMartin Matuska MZE_PHYS(zap, mze)->mze_name, MT_NORMALIZE); 950eda14cbcSMatt Macy allocdzn = B_TRUE; 951eda14cbcSMatt Macy } 952eda14cbcSMatt Macy if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) { 953eda14cbcSMatt Macy if (allocdzn) 954eda14cbcSMatt Macy zap_name_free(zn); 955eda14cbcSMatt Macy return (B_TRUE); 956eda14cbcSMatt Macy } 957eda14cbcSMatt Macy } 958eda14cbcSMatt Macy 959dbd5678dSMartin Matuska for (other = zfs_btree_next(&zap->zap_m.zap_tree, idx, &oidx); 960dbd5678dSMartin Matuska other && other->mze_hash == mze->mze_hash; 961dbd5678dSMartin Matuska other = zfs_btree_next(&zap->zap_m.zap_tree, &oidx, &oidx)) { 962dbd5678dSMartin Matuska 963dbd5678dSMartin Matuska if (zn == NULL) { 964dbd5678dSMartin Matuska zn = zap_name_alloc_str(zap, 965dbd5678dSMartin Matuska MZE_PHYS(zap, mze)->mze_name, MT_NORMALIZE); 966dbd5678dSMartin Matuska allocdzn = B_TRUE; 967dbd5678dSMartin Matuska } 968dbd5678dSMartin Matuska if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) { 969dbd5678dSMartin Matuska if (allocdzn) 970dbd5678dSMartin Matuska zap_name_free(zn); 971dbd5678dSMartin Matuska return (B_TRUE); 972dbd5678dSMartin Matuska } 973eda14cbcSMatt Macy } 974eda14cbcSMatt Macy 975eda14cbcSMatt Macy if (allocdzn) 976eda14cbcSMatt Macy zap_name_free(zn); 977eda14cbcSMatt Macy return (B_FALSE); 978eda14cbcSMatt Macy } 979eda14cbcSMatt Macy 980eda14cbcSMatt Macy /* 981eda14cbcSMatt Macy * Routines for manipulating attributes. 982eda14cbcSMatt Macy */ 983eda14cbcSMatt Macy 984eda14cbcSMatt Macy int 985eda14cbcSMatt Macy zap_lookup(objset_t *os, uint64_t zapobj, const char *name, 986eda14cbcSMatt Macy uint64_t integer_size, uint64_t num_integers, void *buf) 987eda14cbcSMatt Macy { 988eda14cbcSMatt Macy return (zap_lookup_norm(os, zapobj, name, integer_size, 989eda14cbcSMatt Macy num_integers, buf, 0, NULL, 0, NULL)); 990eda14cbcSMatt Macy } 991eda14cbcSMatt Macy 992eda14cbcSMatt Macy static int 993eda14cbcSMatt Macy zap_lookup_impl(zap_t *zap, const char *name, 994eda14cbcSMatt Macy uint64_t integer_size, uint64_t num_integers, void *buf, 995eda14cbcSMatt Macy matchtype_t mt, char *realname, int rn_len, 996eda14cbcSMatt Macy boolean_t *ncp) 997eda14cbcSMatt Macy { 998eda14cbcSMatt Macy int err = 0; 999eda14cbcSMatt Macy 1000dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc_str(zap, name, mt); 1001eda14cbcSMatt Macy if (zn == NULL) 1002eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1003eda14cbcSMatt Macy 1004eda14cbcSMatt Macy if (!zap->zap_ismicro) { 1005eda14cbcSMatt Macy err = fzap_lookup(zn, integer_size, num_integers, buf, 1006eda14cbcSMatt Macy realname, rn_len, ncp); 1007eda14cbcSMatt Macy } else { 1008dbd5678dSMartin Matuska zfs_btree_index_t idx; 1009dbd5678dSMartin Matuska mzap_ent_t *mze = mze_find(zn, &idx); 1010eda14cbcSMatt Macy if (mze == NULL) { 1011eda14cbcSMatt Macy err = SET_ERROR(ENOENT); 1012eda14cbcSMatt Macy } else { 1013eda14cbcSMatt Macy if (num_integers < 1) { 1014eda14cbcSMatt Macy err = SET_ERROR(EOVERFLOW); 1015eda14cbcSMatt Macy } else if (integer_size != 8) { 1016eda14cbcSMatt Macy err = SET_ERROR(EINVAL); 1017eda14cbcSMatt Macy } else { 1018eda14cbcSMatt Macy *(uint64_t *)buf = 1019eda14cbcSMatt Macy MZE_PHYS(zap, mze)->mze_value; 1020dbd5678dSMartin Matuska if (realname != NULL) 1021eda14cbcSMatt Macy (void) strlcpy(realname, 1022dbd5678dSMartin Matuska MZE_PHYS(zap, mze)->mze_name, 1023dbd5678dSMartin Matuska rn_len); 1024eda14cbcSMatt Macy if (ncp) { 1025eda14cbcSMatt Macy *ncp = mzap_normalization_conflict(zap, 1026dbd5678dSMartin Matuska zn, mze, &idx); 1027eda14cbcSMatt Macy } 1028eda14cbcSMatt Macy } 1029eda14cbcSMatt Macy } 1030eda14cbcSMatt Macy } 1031eda14cbcSMatt Macy zap_name_free(zn); 1032eda14cbcSMatt Macy return (err); 1033eda14cbcSMatt Macy } 1034eda14cbcSMatt Macy 1035eda14cbcSMatt Macy int 1036eda14cbcSMatt Macy zap_lookup_norm(objset_t *os, uint64_t zapobj, const char *name, 1037eda14cbcSMatt Macy uint64_t integer_size, uint64_t num_integers, void *buf, 1038eda14cbcSMatt Macy matchtype_t mt, char *realname, int rn_len, 1039eda14cbcSMatt Macy boolean_t *ncp) 1040eda14cbcSMatt Macy { 1041eda14cbcSMatt Macy zap_t *zap; 1042eda14cbcSMatt Macy 1043eda14cbcSMatt Macy int err = 1044eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1045eda14cbcSMatt Macy if (err != 0) 1046eda14cbcSMatt Macy return (err); 1047eda14cbcSMatt Macy err = zap_lookup_impl(zap, name, integer_size, 1048eda14cbcSMatt Macy num_integers, buf, mt, realname, rn_len, ncp); 1049eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1050eda14cbcSMatt Macy return (err); 1051eda14cbcSMatt Macy } 1052eda14cbcSMatt Macy 1053eda14cbcSMatt Macy int 1054eda14cbcSMatt Macy zap_prefetch(objset_t *os, uint64_t zapobj, const char *name) 1055eda14cbcSMatt Macy { 1056eda14cbcSMatt Macy zap_t *zap; 1057eda14cbcSMatt Macy int err; 1058eda14cbcSMatt Macy zap_name_t *zn; 1059eda14cbcSMatt Macy 1060eda14cbcSMatt Macy err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1061eda14cbcSMatt Macy if (err) 1062eda14cbcSMatt Macy return (err); 1063dbd5678dSMartin Matuska zn = zap_name_alloc_str(zap, name, 0); 1064eda14cbcSMatt Macy if (zn == NULL) { 1065eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1066eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1067eda14cbcSMatt Macy } 1068eda14cbcSMatt Macy 1069eda14cbcSMatt Macy fzap_prefetch(zn); 1070eda14cbcSMatt Macy zap_name_free(zn); 1071eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1072eda14cbcSMatt Macy return (err); 1073eda14cbcSMatt Macy } 1074eda14cbcSMatt Macy 1075eda14cbcSMatt Macy int 1076eda14cbcSMatt Macy zap_lookup_by_dnode(dnode_t *dn, const char *name, 1077eda14cbcSMatt Macy uint64_t integer_size, uint64_t num_integers, void *buf) 1078eda14cbcSMatt Macy { 1079eda14cbcSMatt Macy return (zap_lookup_norm_by_dnode(dn, name, integer_size, 1080eda14cbcSMatt Macy num_integers, buf, 0, NULL, 0, NULL)); 1081eda14cbcSMatt Macy } 1082eda14cbcSMatt Macy 1083eda14cbcSMatt Macy int 1084eda14cbcSMatt Macy zap_lookup_norm_by_dnode(dnode_t *dn, const char *name, 1085eda14cbcSMatt Macy uint64_t integer_size, uint64_t num_integers, void *buf, 1086eda14cbcSMatt Macy matchtype_t mt, char *realname, int rn_len, 1087eda14cbcSMatt Macy boolean_t *ncp) 1088eda14cbcSMatt Macy { 1089eda14cbcSMatt Macy zap_t *zap; 1090eda14cbcSMatt Macy 1091eda14cbcSMatt Macy int err = zap_lockdir_by_dnode(dn, NULL, RW_READER, TRUE, FALSE, 1092eda14cbcSMatt Macy FTAG, &zap); 1093eda14cbcSMatt Macy if (err != 0) 1094eda14cbcSMatt Macy return (err); 1095eda14cbcSMatt Macy err = zap_lookup_impl(zap, name, integer_size, 1096eda14cbcSMatt Macy num_integers, buf, mt, realname, rn_len, ncp); 1097eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1098eda14cbcSMatt Macy return (err); 1099eda14cbcSMatt Macy } 1100eda14cbcSMatt Macy 1101eda14cbcSMatt Macy int 1102eda14cbcSMatt Macy zap_prefetch_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1103eda14cbcSMatt Macy int key_numints) 1104eda14cbcSMatt Macy { 1105eda14cbcSMatt Macy zap_t *zap; 1106eda14cbcSMatt Macy 1107eda14cbcSMatt Macy int err = 1108eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1109eda14cbcSMatt Macy if (err != 0) 1110eda14cbcSMatt Macy return (err); 1111eda14cbcSMatt Macy zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints); 1112eda14cbcSMatt Macy if (zn == NULL) { 1113eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1114eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1115eda14cbcSMatt Macy } 1116eda14cbcSMatt Macy 1117eda14cbcSMatt Macy fzap_prefetch(zn); 1118eda14cbcSMatt Macy zap_name_free(zn); 1119eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1120eda14cbcSMatt Macy return (err); 1121eda14cbcSMatt Macy } 1122eda14cbcSMatt Macy 1123eda14cbcSMatt Macy int 1124eda14cbcSMatt Macy zap_lookup_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1125eda14cbcSMatt Macy int key_numints, uint64_t integer_size, uint64_t num_integers, void *buf) 1126eda14cbcSMatt Macy { 1127eda14cbcSMatt Macy zap_t *zap; 1128eda14cbcSMatt Macy 1129eda14cbcSMatt Macy int err = 1130eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1131eda14cbcSMatt Macy if (err != 0) 1132eda14cbcSMatt Macy return (err); 1133eda14cbcSMatt Macy zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints); 1134eda14cbcSMatt Macy if (zn == NULL) { 1135eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1136eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1137eda14cbcSMatt Macy } 1138eda14cbcSMatt Macy 1139eda14cbcSMatt Macy err = fzap_lookup(zn, integer_size, num_integers, buf, 1140eda14cbcSMatt Macy NULL, 0, NULL); 1141eda14cbcSMatt Macy zap_name_free(zn); 1142eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1143eda14cbcSMatt Macy return (err); 1144eda14cbcSMatt Macy } 1145eda14cbcSMatt Macy 1146eda14cbcSMatt Macy int 1147eda14cbcSMatt Macy zap_contains(objset_t *os, uint64_t zapobj, const char *name) 1148eda14cbcSMatt Macy { 1149eda14cbcSMatt Macy int err = zap_lookup_norm(os, zapobj, name, 0, 1150eda14cbcSMatt Macy 0, NULL, 0, NULL, 0, NULL); 1151eda14cbcSMatt Macy if (err == EOVERFLOW || err == EINVAL) 1152eda14cbcSMatt Macy err = 0; /* found, but skipped reading the value */ 1153eda14cbcSMatt Macy return (err); 1154eda14cbcSMatt Macy } 1155eda14cbcSMatt Macy 1156eda14cbcSMatt Macy int 1157eda14cbcSMatt Macy zap_length(objset_t *os, uint64_t zapobj, const char *name, 1158eda14cbcSMatt Macy uint64_t *integer_size, uint64_t *num_integers) 1159eda14cbcSMatt Macy { 1160eda14cbcSMatt Macy zap_t *zap; 1161eda14cbcSMatt Macy 1162eda14cbcSMatt Macy int err = 1163eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1164eda14cbcSMatt Macy if (err != 0) 1165eda14cbcSMatt Macy return (err); 1166dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc_str(zap, name, 0); 1167eda14cbcSMatt Macy if (zn == NULL) { 1168eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1169eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1170eda14cbcSMatt Macy } 1171eda14cbcSMatt Macy if (!zap->zap_ismicro) { 1172eda14cbcSMatt Macy err = fzap_length(zn, integer_size, num_integers); 1173eda14cbcSMatt Macy } else { 1174dbd5678dSMartin Matuska zfs_btree_index_t idx; 1175dbd5678dSMartin Matuska mzap_ent_t *mze = mze_find(zn, &idx); 1176eda14cbcSMatt Macy if (mze == NULL) { 1177eda14cbcSMatt Macy err = SET_ERROR(ENOENT); 1178eda14cbcSMatt Macy } else { 1179eda14cbcSMatt Macy if (integer_size) 1180eda14cbcSMatt Macy *integer_size = 8; 1181eda14cbcSMatt Macy if (num_integers) 1182eda14cbcSMatt Macy *num_integers = 1; 1183eda14cbcSMatt Macy } 1184eda14cbcSMatt Macy } 1185eda14cbcSMatt Macy zap_name_free(zn); 1186eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1187eda14cbcSMatt Macy return (err); 1188eda14cbcSMatt Macy } 1189eda14cbcSMatt Macy 1190eda14cbcSMatt Macy int 1191eda14cbcSMatt Macy zap_length_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1192eda14cbcSMatt Macy int key_numints, uint64_t *integer_size, uint64_t *num_integers) 1193eda14cbcSMatt Macy { 1194eda14cbcSMatt Macy zap_t *zap; 1195eda14cbcSMatt Macy 1196eda14cbcSMatt Macy int err = 1197eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1198eda14cbcSMatt Macy if (err != 0) 1199eda14cbcSMatt Macy return (err); 1200eda14cbcSMatt Macy zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints); 1201eda14cbcSMatt Macy if (zn == NULL) { 1202eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1203eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1204eda14cbcSMatt Macy } 1205eda14cbcSMatt Macy err = fzap_length(zn, integer_size, num_integers); 1206eda14cbcSMatt Macy zap_name_free(zn); 1207eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1208eda14cbcSMatt Macy return (err); 1209eda14cbcSMatt Macy } 1210eda14cbcSMatt Macy 1211eda14cbcSMatt Macy static void 1212eda14cbcSMatt Macy mzap_addent(zap_name_t *zn, uint64_t value) 1213eda14cbcSMatt Macy { 1214eda14cbcSMatt Macy zap_t *zap = zn->zn_zap; 1215dbd5678dSMartin Matuska uint16_t start = zap->zap_m.zap_alloc_next; 1216eda14cbcSMatt Macy 1217eda14cbcSMatt Macy ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 1218eda14cbcSMatt Macy 1219eda14cbcSMatt Macy #ifdef ZFS_DEBUG 1220eda14cbcSMatt Macy for (int i = 0; i < zap->zap_m.zap_num_chunks; i++) { 1221eda14cbcSMatt Macy mzap_ent_phys_t *mze = &zap_m_phys(zap)->mz_chunk[i]; 1222eda14cbcSMatt Macy ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0); 1223eda14cbcSMatt Macy } 1224eda14cbcSMatt Macy #endif 1225eda14cbcSMatt Macy 1226eda14cbcSMatt Macy uint32_t cd = mze_find_unused_cd(zap, zn->zn_hash); 1227eda14cbcSMatt Macy /* given the limited size of the microzap, this can't happen */ 1228eda14cbcSMatt Macy ASSERT(cd < zap_maxcd(zap)); 1229eda14cbcSMatt Macy 1230eda14cbcSMatt Macy again: 1231dbd5678dSMartin Matuska for (uint16_t i = start; i < zap->zap_m.zap_num_chunks; i++) { 1232eda14cbcSMatt Macy mzap_ent_phys_t *mze = &zap_m_phys(zap)->mz_chunk[i]; 1233eda14cbcSMatt Macy if (mze->mze_name[0] == 0) { 1234eda14cbcSMatt Macy mze->mze_value = value; 1235eda14cbcSMatt Macy mze->mze_cd = cd; 1236eda14cbcSMatt Macy (void) strlcpy(mze->mze_name, zn->zn_key_orig, 1237eda14cbcSMatt Macy sizeof (mze->mze_name)); 1238eda14cbcSMatt Macy zap->zap_m.zap_num_entries++; 1239eda14cbcSMatt Macy zap->zap_m.zap_alloc_next = i+1; 1240eda14cbcSMatt Macy if (zap->zap_m.zap_alloc_next == 1241eda14cbcSMatt Macy zap->zap_m.zap_num_chunks) 1242eda14cbcSMatt Macy zap->zap_m.zap_alloc_next = 0; 1243eda14cbcSMatt Macy mze_insert(zap, i, zn->zn_hash); 1244eda14cbcSMatt Macy return; 1245eda14cbcSMatt Macy } 1246eda14cbcSMatt Macy } 1247eda14cbcSMatt Macy if (start != 0) { 1248eda14cbcSMatt Macy start = 0; 1249eda14cbcSMatt Macy goto again; 1250eda14cbcSMatt Macy } 1251eda14cbcSMatt Macy cmn_err(CE_PANIC, "out of entries!"); 1252eda14cbcSMatt Macy } 1253eda14cbcSMatt Macy 1254eda14cbcSMatt Macy static int 1255eda14cbcSMatt Macy zap_add_impl(zap_t *zap, const char *key, 1256eda14cbcSMatt Macy int integer_size, uint64_t num_integers, 1257a0b956f5SMartin Matuska const void *val, dmu_tx_t *tx, const void *tag) 1258eda14cbcSMatt Macy { 1259eda14cbcSMatt Macy const uint64_t *intval = val; 1260eda14cbcSMatt Macy int err = 0; 1261eda14cbcSMatt Macy 1262dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc_str(zap, key, 0); 1263eda14cbcSMatt Macy if (zn == NULL) { 1264eda14cbcSMatt Macy zap_unlockdir(zap, tag); 1265eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1266eda14cbcSMatt Macy } 1267eda14cbcSMatt Macy if (!zap->zap_ismicro) { 1268eda14cbcSMatt Macy err = fzap_add(zn, integer_size, num_integers, val, tag, tx); 1269eda14cbcSMatt Macy zap = zn->zn_zap; /* fzap_add() may change zap */ 1270eda14cbcSMatt Macy } else if (integer_size != 8 || num_integers != 1 || 1271eda14cbcSMatt Macy strlen(key) >= MZAP_NAME_LEN || 1272eda14cbcSMatt Macy !mze_canfit_fzap_leaf(zn, zn->zn_hash)) { 1273eda14cbcSMatt Macy err = mzap_upgrade(&zn->zn_zap, tag, tx, 0); 1274eda14cbcSMatt Macy if (err == 0) { 1275eda14cbcSMatt Macy err = fzap_add(zn, integer_size, num_integers, val, 1276eda14cbcSMatt Macy tag, tx); 1277eda14cbcSMatt Macy } 1278eda14cbcSMatt Macy zap = zn->zn_zap; /* fzap_add() may change zap */ 1279eda14cbcSMatt Macy } else { 1280dbd5678dSMartin Matuska zfs_btree_index_t idx; 1281dbd5678dSMartin Matuska if (mze_find(zn, &idx) != NULL) { 1282eda14cbcSMatt Macy err = SET_ERROR(EEXIST); 1283eda14cbcSMatt Macy } else { 1284eda14cbcSMatt Macy mzap_addent(zn, *intval); 1285eda14cbcSMatt Macy } 1286eda14cbcSMatt Macy } 1287eda14cbcSMatt Macy ASSERT(zap == zn->zn_zap); 1288eda14cbcSMatt Macy zap_name_free(zn); 1289eda14cbcSMatt Macy if (zap != NULL) /* may be NULL if fzap_add() failed */ 1290eda14cbcSMatt Macy zap_unlockdir(zap, tag); 1291eda14cbcSMatt Macy return (err); 1292eda14cbcSMatt Macy } 1293eda14cbcSMatt Macy 1294eda14cbcSMatt Macy int 1295eda14cbcSMatt Macy zap_add(objset_t *os, uint64_t zapobj, const char *key, 1296eda14cbcSMatt Macy int integer_size, uint64_t num_integers, 1297eda14cbcSMatt Macy const void *val, dmu_tx_t *tx) 1298eda14cbcSMatt Macy { 1299eda14cbcSMatt Macy zap_t *zap; 1300eda14cbcSMatt Macy int err; 1301eda14cbcSMatt Macy 1302eda14cbcSMatt Macy err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1303eda14cbcSMatt Macy if (err != 0) 1304eda14cbcSMatt Macy return (err); 1305eda14cbcSMatt Macy err = zap_add_impl(zap, key, integer_size, num_integers, val, tx, FTAG); 1306eda14cbcSMatt Macy /* zap_add_impl() calls zap_unlockdir() */ 1307eda14cbcSMatt Macy return (err); 1308eda14cbcSMatt Macy } 1309eda14cbcSMatt Macy 1310eda14cbcSMatt Macy int 1311eda14cbcSMatt Macy zap_add_by_dnode(dnode_t *dn, const char *key, 1312eda14cbcSMatt Macy int integer_size, uint64_t num_integers, 1313eda14cbcSMatt Macy const void *val, dmu_tx_t *tx) 1314eda14cbcSMatt Macy { 1315eda14cbcSMatt Macy zap_t *zap; 1316eda14cbcSMatt Macy int err; 1317eda14cbcSMatt Macy 1318eda14cbcSMatt Macy err = zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1319eda14cbcSMatt Macy if (err != 0) 1320eda14cbcSMatt Macy return (err); 1321eda14cbcSMatt Macy err = zap_add_impl(zap, key, integer_size, num_integers, val, tx, FTAG); 1322eda14cbcSMatt Macy /* zap_add_impl() calls zap_unlockdir() */ 1323eda14cbcSMatt Macy return (err); 1324eda14cbcSMatt Macy } 1325eda14cbcSMatt Macy 1326*783d3ff6SMartin Matuska static int 1327*783d3ff6SMartin Matuska zap_add_uint64_impl(zap_t *zap, const uint64_t *key, 1328*783d3ff6SMartin Matuska int key_numints, int integer_size, uint64_t num_integers, 1329*783d3ff6SMartin Matuska const void *val, dmu_tx_t *tx, const void *tag) 1330*783d3ff6SMartin Matuska { 1331*783d3ff6SMartin Matuska int err; 1332*783d3ff6SMartin Matuska 1333*783d3ff6SMartin Matuska zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints); 1334*783d3ff6SMartin Matuska if (zn == NULL) { 1335*783d3ff6SMartin Matuska zap_unlockdir(zap, tag); 1336*783d3ff6SMartin Matuska return (SET_ERROR(ENOTSUP)); 1337*783d3ff6SMartin Matuska } 1338*783d3ff6SMartin Matuska err = fzap_add(zn, integer_size, num_integers, val, tag, tx); 1339*783d3ff6SMartin Matuska zap = zn->zn_zap; /* fzap_add() may change zap */ 1340*783d3ff6SMartin Matuska zap_name_free(zn); 1341*783d3ff6SMartin Matuska if (zap != NULL) /* may be NULL if fzap_add() failed */ 1342*783d3ff6SMartin Matuska zap_unlockdir(zap, tag); 1343*783d3ff6SMartin Matuska return (err); 1344*783d3ff6SMartin Matuska } 1345*783d3ff6SMartin Matuska 1346eda14cbcSMatt Macy int 1347eda14cbcSMatt Macy zap_add_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1348eda14cbcSMatt Macy int key_numints, int integer_size, uint64_t num_integers, 1349eda14cbcSMatt Macy const void *val, dmu_tx_t *tx) 1350eda14cbcSMatt Macy { 1351eda14cbcSMatt Macy zap_t *zap; 1352eda14cbcSMatt Macy 1353eda14cbcSMatt Macy int err = 1354eda14cbcSMatt Macy zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1355eda14cbcSMatt Macy if (err != 0) 1356eda14cbcSMatt Macy return (err); 1357*783d3ff6SMartin Matuska err = zap_add_uint64_impl(zap, key, key_numints, 1358*783d3ff6SMartin Matuska integer_size, num_integers, val, tx, FTAG); 1359*783d3ff6SMartin Matuska /* zap_add_uint64_impl() calls zap_unlockdir() */ 1360*783d3ff6SMartin Matuska return (err); 1361eda14cbcSMatt Macy } 1362*783d3ff6SMartin Matuska 1363*783d3ff6SMartin Matuska int 1364*783d3ff6SMartin Matuska zap_add_uint64_by_dnode(dnode_t *dn, const uint64_t *key, 1365*783d3ff6SMartin Matuska int key_numints, int integer_size, uint64_t num_integers, 1366*783d3ff6SMartin Matuska const void *val, dmu_tx_t *tx) 1367*783d3ff6SMartin Matuska { 1368*783d3ff6SMartin Matuska zap_t *zap; 1369*783d3ff6SMartin Matuska 1370*783d3ff6SMartin Matuska int err = 1371*783d3ff6SMartin Matuska zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1372*783d3ff6SMartin Matuska if (err != 0) 1373*783d3ff6SMartin Matuska return (err); 1374*783d3ff6SMartin Matuska err = zap_add_uint64_impl(zap, key, key_numints, 1375*783d3ff6SMartin Matuska integer_size, num_integers, val, tx, FTAG); 1376*783d3ff6SMartin Matuska /* zap_add_uint64_impl() calls zap_unlockdir() */ 1377eda14cbcSMatt Macy return (err); 1378eda14cbcSMatt Macy } 1379eda14cbcSMatt Macy 1380eda14cbcSMatt Macy int 1381eda14cbcSMatt Macy zap_update(objset_t *os, uint64_t zapobj, const char *name, 1382eda14cbcSMatt Macy int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx) 1383eda14cbcSMatt Macy { 1384eda14cbcSMatt Macy zap_t *zap; 1385eda14cbcSMatt Macy const uint64_t *intval = val; 1386eda14cbcSMatt Macy 1387eda14cbcSMatt Macy int err = 1388eda14cbcSMatt Macy zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1389eda14cbcSMatt Macy if (err != 0) 1390eda14cbcSMatt Macy return (err); 1391dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc_str(zap, name, 0); 1392eda14cbcSMatt Macy if (zn == NULL) { 1393eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1394eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1395eda14cbcSMatt Macy } 1396eda14cbcSMatt Macy if (!zap->zap_ismicro) { 1397eda14cbcSMatt Macy err = fzap_update(zn, integer_size, num_integers, val, 1398eda14cbcSMatt Macy FTAG, tx); 1399eda14cbcSMatt Macy zap = zn->zn_zap; /* fzap_update() may change zap */ 1400eda14cbcSMatt Macy } else if (integer_size != 8 || num_integers != 1 || 1401eda14cbcSMatt Macy strlen(name) >= MZAP_NAME_LEN) { 1402eda14cbcSMatt Macy dprintf("upgrading obj %llu: intsz=%u numint=%llu name=%s\n", 140333b8c039SMartin Matuska (u_longlong_t)zapobj, integer_size, 140433b8c039SMartin Matuska (u_longlong_t)num_integers, name); 1405eda14cbcSMatt Macy err = mzap_upgrade(&zn->zn_zap, FTAG, tx, 0); 1406eda14cbcSMatt Macy if (err == 0) { 1407eda14cbcSMatt Macy err = fzap_update(zn, integer_size, num_integers, 1408eda14cbcSMatt Macy val, FTAG, tx); 1409eda14cbcSMatt Macy } 1410eda14cbcSMatt Macy zap = zn->zn_zap; /* fzap_update() may change zap */ 1411eda14cbcSMatt Macy } else { 1412dbd5678dSMartin Matuska zfs_btree_index_t idx; 1413dbd5678dSMartin Matuska mzap_ent_t *mze = mze_find(zn, &idx); 1414eda14cbcSMatt Macy if (mze != NULL) { 1415eda14cbcSMatt Macy MZE_PHYS(zap, mze)->mze_value = *intval; 1416eda14cbcSMatt Macy } else { 1417eda14cbcSMatt Macy mzap_addent(zn, *intval); 1418eda14cbcSMatt Macy } 1419eda14cbcSMatt Macy } 1420eda14cbcSMatt Macy ASSERT(zap == zn->zn_zap); 1421eda14cbcSMatt Macy zap_name_free(zn); 1422eda14cbcSMatt Macy if (zap != NULL) /* may be NULL if fzap_upgrade() failed */ 1423eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1424eda14cbcSMatt Macy return (err); 1425eda14cbcSMatt Macy } 1426eda14cbcSMatt Macy 1427*783d3ff6SMartin Matuska static int 1428*783d3ff6SMartin Matuska zap_update_uint64_impl(zap_t *zap, const uint64_t *key, int key_numints, 1429*783d3ff6SMartin Matuska int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx, 1430*783d3ff6SMartin Matuska const void *tag) 1431*783d3ff6SMartin Matuska { 1432*783d3ff6SMartin Matuska int err; 1433*783d3ff6SMartin Matuska 1434*783d3ff6SMartin Matuska zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints); 1435*783d3ff6SMartin Matuska if (zn == NULL) { 1436*783d3ff6SMartin Matuska zap_unlockdir(zap, tag); 1437*783d3ff6SMartin Matuska return (SET_ERROR(ENOTSUP)); 1438*783d3ff6SMartin Matuska } 1439*783d3ff6SMartin Matuska err = fzap_update(zn, integer_size, num_integers, val, tag, tx); 1440*783d3ff6SMartin Matuska zap = zn->zn_zap; /* fzap_update() may change zap */ 1441*783d3ff6SMartin Matuska zap_name_free(zn); 1442*783d3ff6SMartin Matuska if (zap != NULL) /* may be NULL if fzap_upgrade() failed */ 1443*783d3ff6SMartin Matuska zap_unlockdir(zap, tag); 1444*783d3ff6SMartin Matuska return (err); 1445*783d3ff6SMartin Matuska } 1446*783d3ff6SMartin Matuska 1447eda14cbcSMatt Macy int 1448eda14cbcSMatt Macy zap_update_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1449*783d3ff6SMartin Matuska int key_numints, int integer_size, uint64_t num_integers, const void *val, 1450*783d3ff6SMartin Matuska dmu_tx_t *tx) 1451eda14cbcSMatt Macy { 1452eda14cbcSMatt Macy zap_t *zap; 1453eda14cbcSMatt Macy 1454eda14cbcSMatt Macy int err = 1455eda14cbcSMatt Macy zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1456eda14cbcSMatt Macy if (err != 0) 1457eda14cbcSMatt Macy return (err); 1458*783d3ff6SMartin Matuska err = zap_update_uint64_impl(zap, key, key_numints, 1459*783d3ff6SMartin Matuska integer_size, num_integers, val, tx, FTAG); 1460*783d3ff6SMartin Matuska /* zap_update_uint64_impl() calls zap_unlockdir() */ 1461*783d3ff6SMartin Matuska return (err); 1462eda14cbcSMatt Macy } 1463*783d3ff6SMartin Matuska 1464*783d3ff6SMartin Matuska int 1465*783d3ff6SMartin Matuska zap_update_uint64_by_dnode(dnode_t *dn, const uint64_t *key, int key_numints, 1466*783d3ff6SMartin Matuska int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx) 1467*783d3ff6SMartin Matuska { 1468*783d3ff6SMartin Matuska zap_t *zap; 1469*783d3ff6SMartin Matuska 1470*783d3ff6SMartin Matuska int err = 1471*783d3ff6SMartin Matuska zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap); 1472*783d3ff6SMartin Matuska if (err != 0) 1473*783d3ff6SMartin Matuska return (err); 1474*783d3ff6SMartin Matuska err = zap_update_uint64_impl(zap, key, key_numints, 1475*783d3ff6SMartin Matuska integer_size, num_integers, val, tx, FTAG); 1476*783d3ff6SMartin Matuska /* zap_update_uint64_impl() calls zap_unlockdir() */ 1477eda14cbcSMatt Macy return (err); 1478eda14cbcSMatt Macy } 1479eda14cbcSMatt Macy 1480eda14cbcSMatt Macy int 1481eda14cbcSMatt Macy zap_remove(objset_t *os, uint64_t zapobj, const char *name, dmu_tx_t *tx) 1482eda14cbcSMatt Macy { 1483eda14cbcSMatt Macy return (zap_remove_norm(os, zapobj, name, 0, tx)); 1484eda14cbcSMatt Macy } 1485eda14cbcSMatt Macy 1486eda14cbcSMatt Macy static int 1487eda14cbcSMatt Macy zap_remove_impl(zap_t *zap, const char *name, 1488eda14cbcSMatt Macy matchtype_t mt, dmu_tx_t *tx) 1489eda14cbcSMatt Macy { 1490eda14cbcSMatt Macy int err = 0; 1491eda14cbcSMatt Macy 1492dbd5678dSMartin Matuska zap_name_t *zn = zap_name_alloc_str(zap, name, mt); 1493eda14cbcSMatt Macy if (zn == NULL) 1494eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 1495eda14cbcSMatt Macy if (!zap->zap_ismicro) { 1496eda14cbcSMatt Macy err = fzap_remove(zn, tx); 1497eda14cbcSMatt Macy } else { 1498dbd5678dSMartin Matuska zfs_btree_index_t idx; 1499dbd5678dSMartin Matuska mzap_ent_t *mze = mze_find(zn, &idx); 1500eda14cbcSMatt Macy if (mze == NULL) { 1501eda14cbcSMatt Macy err = SET_ERROR(ENOENT); 1502eda14cbcSMatt Macy } else { 1503eda14cbcSMatt Macy zap->zap_m.zap_num_entries--; 1504dbd5678dSMartin Matuska memset(MZE_PHYS(zap, mze), 0, sizeof (mzap_ent_phys_t)); 1505dbd5678dSMartin Matuska zfs_btree_remove_idx(&zap->zap_m.zap_tree, &idx); 1506eda14cbcSMatt Macy } 1507eda14cbcSMatt Macy } 1508eda14cbcSMatt Macy zap_name_free(zn); 1509eda14cbcSMatt Macy return (err); 1510eda14cbcSMatt Macy } 1511eda14cbcSMatt Macy 1512eda14cbcSMatt Macy int 1513eda14cbcSMatt Macy zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name, 1514eda14cbcSMatt Macy matchtype_t mt, dmu_tx_t *tx) 1515eda14cbcSMatt Macy { 1516eda14cbcSMatt Macy zap_t *zap; 1517eda14cbcSMatt Macy int err; 1518eda14cbcSMatt Macy 1519eda14cbcSMatt Macy err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap); 1520eda14cbcSMatt Macy if (err) 1521eda14cbcSMatt Macy return (err); 1522eda14cbcSMatt Macy err = zap_remove_impl(zap, name, mt, tx); 1523eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1524eda14cbcSMatt Macy return (err); 1525eda14cbcSMatt Macy } 1526eda14cbcSMatt Macy 1527eda14cbcSMatt Macy int 1528eda14cbcSMatt Macy zap_remove_by_dnode(dnode_t *dn, const char *name, dmu_tx_t *tx) 1529eda14cbcSMatt Macy { 1530eda14cbcSMatt Macy zap_t *zap; 1531eda14cbcSMatt Macy int err; 1532eda14cbcSMatt Macy 1533eda14cbcSMatt Macy err = zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap); 1534eda14cbcSMatt Macy if (err) 1535eda14cbcSMatt Macy return (err); 1536eda14cbcSMatt Macy err = zap_remove_impl(zap, name, 0, tx); 1537eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1538eda14cbcSMatt Macy return (err); 1539eda14cbcSMatt Macy } 1540eda14cbcSMatt Macy 1541*783d3ff6SMartin Matuska static int 1542*783d3ff6SMartin Matuska zap_remove_uint64_impl(zap_t *zap, const uint64_t *key, int key_numints, 1543*783d3ff6SMartin Matuska dmu_tx_t *tx, const void *tag) 1544*783d3ff6SMartin Matuska { 1545*783d3ff6SMartin Matuska int err; 1546*783d3ff6SMartin Matuska 1547*783d3ff6SMartin Matuska zap_name_t *zn = zap_name_alloc_uint64(zap, key, key_numints); 1548*783d3ff6SMartin Matuska if (zn == NULL) { 1549*783d3ff6SMartin Matuska zap_unlockdir(zap, tag); 1550*783d3ff6SMartin Matuska return (SET_ERROR(ENOTSUP)); 1551*783d3ff6SMartin Matuska } 1552*783d3ff6SMartin Matuska err = fzap_remove(zn, tx); 1553*783d3ff6SMartin Matuska zap_name_free(zn); 1554*783d3ff6SMartin Matuska zap_unlockdir(zap, tag); 1555*783d3ff6SMartin Matuska return (err); 1556*783d3ff6SMartin Matuska } 1557*783d3ff6SMartin Matuska 1558eda14cbcSMatt Macy int 1559eda14cbcSMatt Macy zap_remove_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1560eda14cbcSMatt Macy int key_numints, dmu_tx_t *tx) 1561eda14cbcSMatt Macy { 1562eda14cbcSMatt Macy zap_t *zap; 1563eda14cbcSMatt Macy 1564eda14cbcSMatt Macy int err = 1565eda14cbcSMatt Macy zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap); 1566eda14cbcSMatt Macy if (err != 0) 1567eda14cbcSMatt Macy return (err); 1568*783d3ff6SMartin Matuska err = zap_remove_uint64_impl(zap, key, key_numints, tx, FTAG); 1569*783d3ff6SMartin Matuska /* zap_remove_uint64_impl() calls zap_unlockdir() */ 1570*783d3ff6SMartin Matuska return (err); 1571eda14cbcSMatt Macy } 1572*783d3ff6SMartin Matuska 1573*783d3ff6SMartin Matuska int 1574*783d3ff6SMartin Matuska zap_remove_uint64_by_dnode(dnode_t *dn, const uint64_t *key, int key_numints, 1575*783d3ff6SMartin Matuska dmu_tx_t *tx) 1576*783d3ff6SMartin Matuska { 1577*783d3ff6SMartin Matuska zap_t *zap; 1578*783d3ff6SMartin Matuska 1579*783d3ff6SMartin Matuska int err = 1580*783d3ff6SMartin Matuska zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap); 1581*783d3ff6SMartin Matuska if (err != 0) 1582*783d3ff6SMartin Matuska return (err); 1583*783d3ff6SMartin Matuska err = zap_remove_uint64_impl(zap, key, key_numints, tx, FTAG); 1584*783d3ff6SMartin Matuska /* zap_remove_uint64_impl() calls zap_unlockdir() */ 1585eda14cbcSMatt Macy return (err); 1586eda14cbcSMatt Macy } 1587eda14cbcSMatt Macy 1588eda14cbcSMatt Macy /* 1589eda14cbcSMatt Macy * Routines for iterating over the attributes. 1590eda14cbcSMatt Macy */ 1591eda14cbcSMatt Macy 1592eda14cbcSMatt Macy static void 1593eda14cbcSMatt Macy zap_cursor_init_impl(zap_cursor_t *zc, objset_t *os, uint64_t zapobj, 1594eda14cbcSMatt Macy uint64_t serialized, boolean_t prefetch) 1595eda14cbcSMatt Macy { 1596eda14cbcSMatt Macy zc->zc_objset = os; 1597eda14cbcSMatt Macy zc->zc_zap = NULL; 1598eda14cbcSMatt Macy zc->zc_leaf = NULL; 1599eda14cbcSMatt Macy zc->zc_zapobj = zapobj; 1600eda14cbcSMatt Macy zc->zc_serialized = serialized; 1601eda14cbcSMatt Macy zc->zc_hash = 0; 1602eda14cbcSMatt Macy zc->zc_cd = 0; 1603eda14cbcSMatt Macy zc->zc_prefetch = prefetch; 1604eda14cbcSMatt Macy } 1605eda14cbcSMatt Macy void 1606eda14cbcSMatt Macy zap_cursor_init_serialized(zap_cursor_t *zc, objset_t *os, uint64_t zapobj, 1607eda14cbcSMatt Macy uint64_t serialized) 1608eda14cbcSMatt Macy { 1609eda14cbcSMatt Macy zap_cursor_init_impl(zc, os, zapobj, serialized, B_TRUE); 1610eda14cbcSMatt Macy } 1611eda14cbcSMatt Macy 1612eda14cbcSMatt Macy /* 1613eda14cbcSMatt Macy * Initialize a cursor at the beginning of the ZAP object. The entire 1614eda14cbcSMatt Macy * ZAP object will be prefetched. 1615eda14cbcSMatt Macy */ 1616eda14cbcSMatt Macy void 1617eda14cbcSMatt Macy zap_cursor_init(zap_cursor_t *zc, objset_t *os, uint64_t zapobj) 1618eda14cbcSMatt Macy { 1619eda14cbcSMatt Macy zap_cursor_init_impl(zc, os, zapobj, 0, B_TRUE); 1620eda14cbcSMatt Macy } 1621eda14cbcSMatt Macy 1622eda14cbcSMatt Macy /* 1623eda14cbcSMatt Macy * Initialize a cursor at the beginning, but request that we not prefetch 1624eda14cbcSMatt Macy * the entire ZAP object. 1625eda14cbcSMatt Macy */ 1626eda14cbcSMatt Macy void 1627eda14cbcSMatt Macy zap_cursor_init_noprefetch(zap_cursor_t *zc, objset_t *os, uint64_t zapobj) 1628eda14cbcSMatt Macy { 1629eda14cbcSMatt Macy zap_cursor_init_impl(zc, os, zapobj, 0, B_FALSE); 1630eda14cbcSMatt Macy } 1631eda14cbcSMatt Macy 1632eda14cbcSMatt Macy void 1633eda14cbcSMatt Macy zap_cursor_fini(zap_cursor_t *zc) 1634eda14cbcSMatt Macy { 1635eda14cbcSMatt Macy if (zc->zc_zap) { 1636eda14cbcSMatt Macy rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1637eda14cbcSMatt Macy zap_unlockdir(zc->zc_zap, NULL); 1638eda14cbcSMatt Macy zc->zc_zap = NULL; 1639eda14cbcSMatt Macy } 1640eda14cbcSMatt Macy if (zc->zc_leaf) { 1641eda14cbcSMatt Macy rw_enter(&zc->zc_leaf->l_rwlock, RW_READER); 1642eda14cbcSMatt Macy zap_put_leaf(zc->zc_leaf); 1643eda14cbcSMatt Macy zc->zc_leaf = NULL; 1644eda14cbcSMatt Macy } 1645eda14cbcSMatt Macy zc->zc_objset = NULL; 1646eda14cbcSMatt Macy } 1647eda14cbcSMatt Macy 1648eda14cbcSMatt Macy uint64_t 1649eda14cbcSMatt Macy zap_cursor_serialize(zap_cursor_t *zc) 1650eda14cbcSMatt Macy { 1651eda14cbcSMatt Macy if (zc->zc_hash == -1ULL) 1652eda14cbcSMatt Macy return (-1ULL); 1653eda14cbcSMatt Macy if (zc->zc_zap == NULL) 1654eda14cbcSMatt Macy return (zc->zc_serialized); 1655eda14cbcSMatt Macy ASSERT((zc->zc_hash & zap_maxcd(zc->zc_zap)) == 0); 1656eda14cbcSMatt Macy ASSERT(zc->zc_cd < zap_maxcd(zc->zc_zap)); 1657eda14cbcSMatt Macy 1658eda14cbcSMatt Macy /* 1659eda14cbcSMatt Macy * We want to keep the high 32 bits of the cursor zero if we can, so 1660eda14cbcSMatt Macy * that 32-bit programs can access this. So usually use a small 1661eda14cbcSMatt Macy * (28-bit) hash value so we can fit 4 bits of cd into the low 32-bits 1662eda14cbcSMatt Macy * of the cursor. 1663eda14cbcSMatt Macy * 1664eda14cbcSMatt Macy * [ collision differentiator | zap_hashbits()-bit hash value ] 1665eda14cbcSMatt Macy */ 1666eda14cbcSMatt Macy return ((zc->zc_hash >> (64 - zap_hashbits(zc->zc_zap))) | 1667eda14cbcSMatt Macy ((uint64_t)zc->zc_cd << zap_hashbits(zc->zc_zap))); 1668eda14cbcSMatt Macy } 1669eda14cbcSMatt Macy 1670eda14cbcSMatt Macy int 1671eda14cbcSMatt Macy zap_cursor_retrieve(zap_cursor_t *zc, zap_attribute_t *za) 1672eda14cbcSMatt Macy { 1673eda14cbcSMatt Macy int err; 1674eda14cbcSMatt Macy 1675eda14cbcSMatt Macy if (zc->zc_hash == -1ULL) 1676eda14cbcSMatt Macy return (SET_ERROR(ENOENT)); 1677eda14cbcSMatt Macy 1678eda14cbcSMatt Macy if (zc->zc_zap == NULL) { 1679eda14cbcSMatt Macy int hb; 1680eda14cbcSMatt Macy err = zap_lockdir(zc->zc_objset, zc->zc_zapobj, NULL, 1681eda14cbcSMatt Macy RW_READER, TRUE, FALSE, NULL, &zc->zc_zap); 1682eda14cbcSMatt Macy if (err != 0) 1683eda14cbcSMatt Macy return (err); 1684eda14cbcSMatt Macy 1685eda14cbcSMatt Macy /* 1686eda14cbcSMatt Macy * To support zap_cursor_init_serialized, advance, retrieve, 1687eda14cbcSMatt Macy * we must add to the existing zc_cd, which may already 1688eda14cbcSMatt Macy * be 1 due to the zap_cursor_advance. 1689eda14cbcSMatt Macy */ 1690eda14cbcSMatt Macy ASSERT(zc->zc_hash == 0); 1691eda14cbcSMatt Macy hb = zap_hashbits(zc->zc_zap); 1692eda14cbcSMatt Macy zc->zc_hash = zc->zc_serialized << (64 - hb); 1693eda14cbcSMatt Macy zc->zc_cd += zc->zc_serialized >> hb; 1694eda14cbcSMatt Macy if (zc->zc_cd >= zap_maxcd(zc->zc_zap)) /* corrupt serialized */ 1695eda14cbcSMatt Macy zc->zc_cd = 0; 1696eda14cbcSMatt Macy } else { 1697eda14cbcSMatt Macy rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1698eda14cbcSMatt Macy } 1699eda14cbcSMatt Macy if (!zc->zc_zap->zap_ismicro) { 1700eda14cbcSMatt Macy err = fzap_cursor_retrieve(zc->zc_zap, zc, za); 1701eda14cbcSMatt Macy } else { 1702dbd5678dSMartin Matuska zfs_btree_index_t idx; 1703eda14cbcSMatt Macy mzap_ent_t mze_tofind; 1704eda14cbcSMatt Macy 1705dbd5678dSMartin Matuska mze_tofind.mze_hash = zc->zc_hash >> 32; 1706eda14cbcSMatt Macy mze_tofind.mze_cd = zc->zc_cd; 1707eda14cbcSMatt Macy 1708dbd5678dSMartin Matuska mzap_ent_t *mze = zfs_btree_find(&zc->zc_zap->zap_m.zap_tree, 1709dbd5678dSMartin Matuska &mze_tofind, &idx); 1710eda14cbcSMatt Macy if (mze == NULL) { 1711dbd5678dSMartin Matuska mze = zfs_btree_next(&zc->zc_zap->zap_m.zap_tree, 1712dbd5678dSMartin Matuska &idx, &idx); 1713eda14cbcSMatt Macy } 1714eda14cbcSMatt Macy if (mze) { 1715eda14cbcSMatt Macy mzap_ent_phys_t *mzep = MZE_PHYS(zc->zc_zap, mze); 1716eda14cbcSMatt Macy ASSERT3U(mze->mze_cd, ==, mzep->mze_cd); 1717eda14cbcSMatt Macy za->za_normalization_conflict = 1718dbd5678dSMartin Matuska mzap_normalization_conflict(zc->zc_zap, NULL, 1719dbd5678dSMartin Matuska mze, &idx); 1720eda14cbcSMatt Macy za->za_integer_length = 8; 1721eda14cbcSMatt Macy za->za_num_integers = 1; 1722eda14cbcSMatt Macy za->za_first_integer = mzep->mze_value; 1723eda14cbcSMatt Macy (void) strlcpy(za->za_name, mzep->mze_name, 1724eda14cbcSMatt Macy sizeof (za->za_name)); 1725dbd5678dSMartin Matuska zc->zc_hash = (uint64_t)mze->mze_hash << 32; 1726eda14cbcSMatt Macy zc->zc_cd = mze->mze_cd; 1727eda14cbcSMatt Macy err = 0; 1728eda14cbcSMatt Macy } else { 1729eda14cbcSMatt Macy zc->zc_hash = -1ULL; 1730eda14cbcSMatt Macy err = SET_ERROR(ENOENT); 1731eda14cbcSMatt Macy } 1732eda14cbcSMatt Macy } 1733eda14cbcSMatt Macy rw_exit(&zc->zc_zap->zap_rwlock); 1734eda14cbcSMatt Macy return (err); 1735eda14cbcSMatt Macy } 1736eda14cbcSMatt Macy 1737eda14cbcSMatt Macy void 1738eda14cbcSMatt Macy zap_cursor_advance(zap_cursor_t *zc) 1739eda14cbcSMatt Macy { 1740eda14cbcSMatt Macy if (zc->zc_hash == -1ULL) 1741eda14cbcSMatt Macy return; 1742eda14cbcSMatt Macy zc->zc_cd++; 1743eda14cbcSMatt Macy } 1744eda14cbcSMatt Macy 1745eda14cbcSMatt Macy int 1746eda14cbcSMatt Macy zap_get_stats(objset_t *os, uint64_t zapobj, zap_stats_t *zs) 1747eda14cbcSMatt Macy { 1748eda14cbcSMatt Macy zap_t *zap; 1749eda14cbcSMatt Macy 1750eda14cbcSMatt Macy int err = 1751eda14cbcSMatt Macy zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, FTAG, &zap); 1752eda14cbcSMatt Macy if (err != 0) 1753eda14cbcSMatt Macy return (err); 1754eda14cbcSMatt Macy 1755da5137abSMartin Matuska memset(zs, 0, sizeof (zap_stats_t)); 1756eda14cbcSMatt Macy 1757eda14cbcSMatt Macy if (zap->zap_ismicro) { 1758eda14cbcSMatt Macy zs->zs_blocksize = zap->zap_dbuf->db_size; 1759eda14cbcSMatt Macy zs->zs_num_entries = zap->zap_m.zap_num_entries; 1760eda14cbcSMatt Macy zs->zs_num_blocks = 1; 1761eda14cbcSMatt Macy } else { 1762eda14cbcSMatt Macy fzap_get_stats(zap, zs); 1763eda14cbcSMatt Macy } 1764eda14cbcSMatt Macy zap_unlockdir(zap, FTAG); 1765eda14cbcSMatt Macy return (0); 1766eda14cbcSMatt Macy } 1767eda14cbcSMatt Macy 1768eda14cbcSMatt Macy #if defined(_KERNEL) 1769eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create); 1770eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_dnsize); 1771eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_norm); 1772eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_norm_dnsize); 1773eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_flags); 1774eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_flags_dnsize); 1775eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_claim); 1776eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_claim_norm); 1777eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_claim_norm_dnsize); 1778eda14cbcSMatt Macy EXPORT_SYMBOL(zap_create_hold); 1779eda14cbcSMatt Macy EXPORT_SYMBOL(zap_destroy); 1780eda14cbcSMatt Macy EXPORT_SYMBOL(zap_lookup); 1781eda14cbcSMatt Macy EXPORT_SYMBOL(zap_lookup_by_dnode); 1782eda14cbcSMatt Macy EXPORT_SYMBOL(zap_lookup_norm); 1783eda14cbcSMatt Macy EXPORT_SYMBOL(zap_lookup_uint64); 1784eda14cbcSMatt Macy EXPORT_SYMBOL(zap_contains); 1785eda14cbcSMatt Macy EXPORT_SYMBOL(zap_prefetch); 1786eda14cbcSMatt Macy EXPORT_SYMBOL(zap_prefetch_uint64); 1787eda14cbcSMatt Macy EXPORT_SYMBOL(zap_add); 1788eda14cbcSMatt Macy EXPORT_SYMBOL(zap_add_by_dnode); 1789eda14cbcSMatt Macy EXPORT_SYMBOL(zap_add_uint64); 1790*783d3ff6SMartin Matuska EXPORT_SYMBOL(zap_add_uint64_by_dnode); 1791eda14cbcSMatt Macy EXPORT_SYMBOL(zap_update); 1792eda14cbcSMatt Macy EXPORT_SYMBOL(zap_update_uint64); 1793*783d3ff6SMartin Matuska EXPORT_SYMBOL(zap_update_uint64_by_dnode); 1794eda14cbcSMatt Macy EXPORT_SYMBOL(zap_length); 1795eda14cbcSMatt Macy EXPORT_SYMBOL(zap_length_uint64); 1796eda14cbcSMatt Macy EXPORT_SYMBOL(zap_remove); 1797eda14cbcSMatt Macy EXPORT_SYMBOL(zap_remove_by_dnode); 1798eda14cbcSMatt Macy EXPORT_SYMBOL(zap_remove_norm); 1799eda14cbcSMatt Macy EXPORT_SYMBOL(zap_remove_uint64); 1800*783d3ff6SMartin Matuska EXPORT_SYMBOL(zap_remove_uint64_by_dnode); 1801eda14cbcSMatt Macy EXPORT_SYMBOL(zap_count); 1802eda14cbcSMatt Macy EXPORT_SYMBOL(zap_value_search); 1803eda14cbcSMatt Macy EXPORT_SYMBOL(zap_join); 1804eda14cbcSMatt Macy EXPORT_SYMBOL(zap_join_increment); 1805eda14cbcSMatt Macy EXPORT_SYMBOL(zap_add_int); 1806eda14cbcSMatt Macy EXPORT_SYMBOL(zap_remove_int); 1807eda14cbcSMatt Macy EXPORT_SYMBOL(zap_lookup_int); 1808eda14cbcSMatt Macy EXPORT_SYMBOL(zap_increment_int); 1809eda14cbcSMatt Macy EXPORT_SYMBOL(zap_add_int_key); 1810eda14cbcSMatt Macy EXPORT_SYMBOL(zap_lookup_int_key); 1811eda14cbcSMatt Macy EXPORT_SYMBOL(zap_increment); 1812eda14cbcSMatt Macy EXPORT_SYMBOL(zap_cursor_init); 1813eda14cbcSMatt Macy EXPORT_SYMBOL(zap_cursor_fini); 1814eda14cbcSMatt Macy EXPORT_SYMBOL(zap_cursor_retrieve); 1815eda14cbcSMatt Macy EXPORT_SYMBOL(zap_cursor_advance); 1816eda14cbcSMatt Macy EXPORT_SYMBOL(zap_cursor_serialize); 1817eda14cbcSMatt Macy EXPORT_SYMBOL(zap_cursor_init_serialized); 1818eda14cbcSMatt Macy EXPORT_SYMBOL(zap_get_stats); 181915f0b8c3SMartin Matuska 182015f0b8c3SMartin Matuska /* CSTYLED */ 182115f0b8c3SMartin Matuska ZFS_MODULE_PARAM(zfs, , zap_micro_max_size, INT, ZMOD_RW, 182215f0b8c3SMartin Matuska "Maximum micro ZAP size, before converting to a fat ZAP, in bytes"); 1823eda14cbcSMatt Macy #endif 1824