1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25#include <sys/zio.h> 26#include <sys/spa.h> 27#include <sys/dmu.h> 28#include <sys/zfs_context.h> 29#include <sys/zap.h> 30#include <sys/refcount.h> 31#include <sys/zap_impl.h> 32#include <sys/zap_leaf.h> 33#include <sys/avl.h> 34#include <sys/arc.h> 35 36#ifdef _KERNEL 37#include <sys/sunddi.h> 38#endif 39 40static int mzap_upgrade(zap_t **zapp, dmu_tx_t *tx, zap_flags_t flags); 41 42uint64_t 43zap_getflags(zap_t *zap) 44{ 45 if (zap->zap_ismicro) 46 return (0); 47 return (zap->zap_u.zap_fat.zap_phys->zap_flags); 48} 49 50int 51zap_hashbits(zap_t *zap) 52{ 53 if (zap_getflags(zap) & ZAP_FLAG_HASH64) 54 return (48); 55 else 56 return (28); 57} 58 59uint32_t 60zap_maxcd(zap_t *zap) 61{ 62 if (zap_getflags(zap) & ZAP_FLAG_HASH64) 63 return ((1<<16)-1); 64 else 65 return (-1U); 66} 67 68static uint64_t 69zap_hash(zap_name_t *zn) 70{ 71 zap_t *zap = zn->zn_zap; 72 uint64_t h = 0; 73 74 if (zap_getflags(zap) & ZAP_FLAG_PRE_HASHED_KEY) { 75 ASSERT(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY); 76 h = *(uint64_t *)zn->zn_key_orig; 77 } else { 78 h = zap->zap_salt; 79 ASSERT(h != 0); 80 ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY); 81 82 if (zap_getflags(zap) & ZAP_FLAG_UINT64_KEY) { 83 int i; 84 const uint64_t *wp = zn->zn_key_norm; 85 86 ASSERT(zn->zn_key_intlen == 8); 87 for (i = 0; i < zn->zn_key_norm_numints; wp++, i++) { 88 int j; 89 uint64_t word = *wp; 90 91 for (j = 0; j < zn->zn_key_intlen; j++) { 92 h = (h >> 8) ^ 93 zfs_crc64_table[(h ^ word) & 0xFF]; 94 word >>= NBBY; 95 } 96 } 97 } else { 98 int i, len; 99 const uint8_t *cp = zn->zn_key_norm; 100 101 /* 102 * We previously stored the terminating null on 103 * disk, but didn't hash it, so we need to 104 * continue to not hash it. (The 105 * zn_key_*_numints includes the terminating 106 * null for non-binary keys.) 107 */ 108 len = zn->zn_key_norm_numints - 1; 109 110 ASSERT(zn->zn_key_intlen == 1); 111 for (i = 0; i < len; cp++, i++) { 112 h = (h >> 8) ^ 113 zfs_crc64_table[(h ^ *cp) & 0xFF]; 114 } 115 } 116 } 117 /* 118 * Don't use all 64 bits, since we need some in the cookie for 119 * the collision differentiator. We MUST use the high bits, 120 * since those are the ones that we first pay attention to when 121 * chosing the bucket. 122 */ 123 h &= ~((1ULL << (64 - zap_hashbits(zap))) - 1); 124 125 return (h); 126} 127 128static int 129zap_normalize(zap_t *zap, const char *name, char *namenorm) 130{ 131 size_t inlen, outlen; 132 int err; 133 134 ASSERT(!(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY)); 135 136 inlen = strlen(name) + 1; 137 outlen = ZAP_MAXNAMELEN; 138 139 err = 0; 140 (void) u8_textprep_str((char *)name, &inlen, namenorm, &outlen, 141 zap->zap_normflags | U8_TEXTPREP_IGNORE_NULL | 142 U8_TEXTPREP_IGNORE_INVALID, U8_UNICODE_LATEST, &err); 143 144 return (err); 145} 146 147boolean_t 148zap_match(zap_name_t *zn, const char *matchname) 149{ 150 ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY)); 151 152 if (zn->zn_matchtype == MT_FIRST) { 153 char norm[ZAP_MAXNAMELEN]; 154 155 if (zap_normalize(zn->zn_zap, matchname, norm) != 0) 156 return (B_FALSE); 157 158 return (strcmp(zn->zn_key_norm, norm) == 0); 159 } else { 160 /* MT_BEST or MT_EXACT */ 161 return (strcmp(zn->zn_key_orig, matchname) == 0); 162 } 163} 164 165void 166zap_name_free(zap_name_t *zn) 167{ 168 kmem_free(zn, sizeof (zap_name_t)); 169} 170 171zap_name_t * 172zap_name_alloc(zap_t *zap, const char *key, matchtype_t mt) 173{ 174 zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); 175 176 zn->zn_zap = zap; 177 zn->zn_key_intlen = sizeof (*key); 178 zn->zn_key_orig = key; 179 zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1; 180 zn->zn_matchtype = mt; 181 if (zap->zap_normflags) { 182 if (zap_normalize(zap, key, zn->zn_normbuf) != 0) { 183 zap_name_free(zn); 184 return (NULL); 185 } 186 zn->zn_key_norm = zn->zn_normbuf; 187 zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1; 188 } else { 189 if (mt != MT_EXACT) { 190 zap_name_free(zn); 191 return (NULL); 192 } 193 zn->zn_key_norm = zn->zn_key_orig; 194 zn->zn_key_norm_numints = zn->zn_key_orig_numints; 195 } 196 197 zn->zn_hash = zap_hash(zn); 198 return (zn); 199} 200 201zap_name_t * 202zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints) 203{ 204 zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); 205 206 ASSERT(zap->zap_normflags == 0); 207 zn->zn_zap = zap; 208 zn->zn_key_intlen = sizeof (*key); 209 zn->zn_key_orig = zn->zn_key_norm = key; 210 zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints; 211 zn->zn_matchtype = MT_EXACT; 212 213 zn->zn_hash = zap_hash(zn); 214 return (zn); 215} 216 217static void 218mzap_byteswap(mzap_phys_t *buf, size_t size) 219{ 220 int i, max; 221 buf->mz_block_type = BSWAP_64(buf->mz_block_type); 222 buf->mz_salt = BSWAP_64(buf->mz_salt); 223 buf->mz_normflags = BSWAP_64(buf->mz_normflags); 224 max = (size / MZAP_ENT_LEN) - 1; 225 for (i = 0; i < max; i++) { 226 buf->mz_chunk[i].mze_value = 227 BSWAP_64(buf->mz_chunk[i].mze_value); 228 buf->mz_chunk[i].mze_cd = 229 BSWAP_32(buf->mz_chunk[i].mze_cd); 230 } 231} 232 233void 234zap_byteswap(void *buf, size_t size) 235{ 236 uint64_t block_type; 237 238 block_type = *(uint64_t *)buf; 239 240 if (block_type == ZBT_MICRO || block_type == BSWAP_64(ZBT_MICRO)) { 241 /* ASSERT(magic == ZAP_LEAF_MAGIC); */ 242 mzap_byteswap(buf, size); 243 } else { 244 fzap_byteswap(buf, size); 245 } 246} 247 248static int 249mze_compare(const void *arg1, const void *arg2) 250{ 251 const mzap_ent_t *mze1 = arg1; 252 const mzap_ent_t *mze2 = arg2; 253 254 if (mze1->mze_hash > mze2->mze_hash) 255 return (+1); 256 if (mze1->mze_hash < mze2->mze_hash) 257 return (-1); 258 if (mze1->mze_cd > mze2->mze_cd) 259 return (+1); 260 if (mze1->mze_cd < mze2->mze_cd) 261 return (-1); 262 return (0); 263} 264 265static void 266mze_insert(zap_t *zap, int chunkid, uint64_t hash) 267{ 268 mzap_ent_t *mze; 269 270 ASSERT(zap->zap_ismicro); 271 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 272 273 mze = kmem_alloc(sizeof (mzap_ent_t), KM_SLEEP); 274 mze->mze_chunkid = chunkid; 275 mze->mze_hash = hash; 276 mze->mze_cd = MZE_PHYS(zap, mze)->mze_cd; 277 ASSERT(MZE_PHYS(zap, mze)->mze_name[0] != 0); 278 avl_add(&zap->zap_m.zap_avl, mze); 279} 280 281static mzap_ent_t * 282mze_find(zap_name_t *zn) 283{ 284 mzap_ent_t mze_tofind; 285 mzap_ent_t *mze; 286 avl_index_t idx; 287 avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl; 288 289 ASSERT(zn->zn_zap->zap_ismicro); 290 ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock)); 291 292 mze_tofind.mze_hash = zn->zn_hash; 293 mze_tofind.mze_cd = 0; 294 295again: 296 mze = avl_find(avl, &mze_tofind, &idx); 297 if (mze == NULL) 298 mze = avl_nearest(avl, idx, AVL_AFTER); 299 for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) { 300 ASSERT3U(mze->mze_cd, ==, MZE_PHYS(zn->zn_zap, mze)->mze_cd); 301 if (zap_match(zn, MZE_PHYS(zn->zn_zap, mze)->mze_name)) 302 return (mze); 303 } 304 if (zn->zn_matchtype == MT_BEST) { 305 zn->zn_matchtype = MT_FIRST; 306 goto again; 307 } 308 return (NULL); 309} 310 311static uint32_t 312mze_find_unused_cd(zap_t *zap, uint64_t hash) 313{ 314 mzap_ent_t mze_tofind; 315 mzap_ent_t *mze; 316 avl_index_t idx; 317 avl_tree_t *avl = &zap->zap_m.zap_avl; 318 uint32_t cd; 319 320 ASSERT(zap->zap_ismicro); 321 ASSERT(RW_LOCK_HELD(&zap->zap_rwlock)); 322 323 mze_tofind.mze_hash = hash; 324 mze_tofind.mze_cd = 0; 325 326 cd = 0; 327 for (mze = avl_find(avl, &mze_tofind, &idx); 328 mze && mze->mze_hash == hash; mze = AVL_NEXT(avl, mze)) { 329 if (mze->mze_cd != cd) 330 break; 331 cd++; 332 } 333 334 return (cd); 335} 336 337static void 338mze_remove(zap_t *zap, mzap_ent_t *mze) 339{ 340 ASSERT(zap->zap_ismicro); 341 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 342 343 avl_remove(&zap->zap_m.zap_avl, mze); 344 kmem_free(mze, sizeof (mzap_ent_t)); 345} 346 347static void 348mze_destroy(zap_t *zap) 349{ 350 mzap_ent_t *mze; 351 void *avlcookie = NULL; 352 353 while (mze = avl_destroy_nodes(&zap->zap_m.zap_avl, &avlcookie)) 354 kmem_free(mze, sizeof (mzap_ent_t)); 355 avl_destroy(&zap->zap_m.zap_avl); 356} 357 358static zap_t * 359mzap_open(objset_t *os, uint64_t obj, dmu_buf_t *db) 360{ 361 zap_t *winner; 362 zap_t *zap; 363 int i; 364 365 ASSERT3U(MZAP_ENT_LEN, ==, sizeof (mzap_ent_phys_t)); 366 367 zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP); 368 rw_init(&zap->zap_rwlock, 0, 0, 0); 369 rw_enter(&zap->zap_rwlock, RW_WRITER); 370 zap->zap_objset = os; 371 zap->zap_object = obj; 372 zap->zap_dbuf = db; 373 374 if (*(uint64_t *)db->db_data != ZBT_MICRO) { 375 mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0); 376 zap->zap_f.zap_block_shift = highbit(db->db_size) - 1; 377 } else { 378 zap->zap_ismicro = TRUE; 379 } 380 381 /* 382 * Make sure that zap_ismicro is set before we let others see 383 * it, because zap_lockdir() checks zap_ismicro without the lock 384 * held. 385 */ 386 winner = dmu_buf_set_user(db, zap, &zap->zap_m.zap_phys, zap_evict); 387 388 if (winner != NULL) { 389 rw_exit(&zap->zap_rwlock); 390 rw_destroy(&zap->zap_rwlock); 391 if (!zap->zap_ismicro) 392 mutex_destroy(&zap->zap_f.zap_num_entries_mtx); 393 kmem_free(zap, sizeof (zap_t)); 394 return (winner); 395 } 396 397 if (zap->zap_ismicro) { 398 zap->zap_salt = zap->zap_m.zap_phys->mz_salt; 399 zap->zap_normflags = zap->zap_m.zap_phys->mz_normflags; 400 zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1; 401 avl_create(&zap->zap_m.zap_avl, mze_compare, 402 sizeof (mzap_ent_t), offsetof(mzap_ent_t, mze_node)); 403 404 for (i = 0; i < zap->zap_m.zap_num_chunks; i++) { 405 mzap_ent_phys_t *mze = 406 &zap->zap_m.zap_phys->mz_chunk[i]; 407 if (mze->mze_name[0]) { 408 zap_name_t *zn; 409 410 zap->zap_m.zap_num_entries++; 411 zn = zap_name_alloc(zap, mze->mze_name, 412 MT_EXACT); 413 mze_insert(zap, i, zn->zn_hash); 414 zap_name_free(zn); 415 } 416 } 417 } else { 418 zap->zap_salt = zap->zap_f.zap_phys->zap_salt; 419 zap->zap_normflags = zap->zap_f.zap_phys->zap_normflags; 420 421 ASSERT3U(sizeof (struct zap_leaf_header), ==, 422 2*ZAP_LEAF_CHUNKSIZE); 423 424 /* 425 * The embedded pointer table should not overlap the 426 * other members. 427 */ 428 ASSERT3P(&ZAP_EMBEDDED_PTRTBL_ENT(zap, 0), >, 429 &zap->zap_f.zap_phys->zap_salt); 430 431 /* 432 * The embedded pointer table should end at the end of 433 * the block 434 */ 435 ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap, 436 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) - 437 (uintptr_t)zap->zap_f.zap_phys, ==, 438 zap->zap_dbuf->db_size); 439 } 440 rw_exit(&zap->zap_rwlock); 441 return (zap); 442} 443 444int 445zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx, 446 krw_t lti, boolean_t fatreader, boolean_t adding, zap_t **zapp) 447{ 448 zap_t *zap; 449 dmu_buf_t *db; 450 krw_t lt; 451 int err; 452 453 *zapp = NULL; 454 455 err = dmu_buf_hold(os, obj, 0, NULL, &db, DMU_READ_NO_PREFETCH); 456 if (err) 457 return (err); 458 459#ifdef ZFS_DEBUG 460 { 461 dmu_object_info_t doi; 462 dmu_object_info_from_db(db, &doi); 463 ASSERT(dmu_ot[doi.doi_type].ot_byteswap == zap_byteswap); 464 } 465#endif 466 467 zap = dmu_buf_get_user(db); 468 if (zap == NULL) 469 zap = mzap_open(os, obj, db); 470 471 /* 472 * We're checking zap_ismicro without the lock held, in order to 473 * tell what type of lock we want. Once we have some sort of 474 * lock, see if it really is the right type. In practice this 475 * can only be different if it was upgraded from micro to fat, 476 * and micro wanted WRITER but fat only needs READER. 477 */ 478 lt = (!zap->zap_ismicro && fatreader) ? RW_READER : lti; 479 rw_enter(&zap->zap_rwlock, lt); 480 if (lt != ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)) { 481 /* it was upgraded, now we only need reader */ 482 ASSERT(lt == RW_WRITER); 483 ASSERT(RW_READER == 484 (!zap->zap_ismicro && fatreader) ? RW_READER : lti); 485 rw_downgrade(&zap->zap_rwlock); 486 lt = RW_READER; 487 } 488 489 zap->zap_objset = os; 490 491 if (lt == RW_WRITER) 492 dmu_buf_will_dirty(db, tx); 493 494 ASSERT3P(zap->zap_dbuf, ==, db); 495 496 ASSERT(!zap->zap_ismicro || 497 zap->zap_m.zap_num_entries <= zap->zap_m.zap_num_chunks); 498 if (zap->zap_ismicro && tx && adding && 499 zap->zap_m.zap_num_entries == zap->zap_m.zap_num_chunks) { 500 uint64_t newsz = db->db_size + SPA_MINBLOCKSIZE; 501 if (newsz > MZAP_MAX_BLKSZ) { 502 dprintf("upgrading obj %llu: num_entries=%u\n", 503 obj, zap->zap_m.zap_num_entries); 504 *zapp = zap; 505 return (mzap_upgrade(zapp, tx, 0)); 506 } 507 err = dmu_object_set_blocksize(os, obj, newsz, 0, tx); 508 ASSERT3U(err, ==, 0); 509 zap->zap_m.zap_num_chunks = 510 db->db_size / MZAP_ENT_LEN - 1; 511 } 512 513 *zapp = zap; 514 return (0); 515} 516 517void 518zap_unlockdir(zap_t *zap) 519{ 520 rw_exit(&zap->zap_rwlock); 521 dmu_buf_rele(zap->zap_dbuf, NULL); 522} 523 524static int 525mzap_upgrade(zap_t **zapp, dmu_tx_t *tx, zap_flags_t flags) 526{ 527 mzap_phys_t *mzp; 528 int i, sz, nchunks; 529 int err = 0; 530 zap_t *zap = *zapp; 531 532 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 533 534 sz = zap->zap_dbuf->db_size; 535 mzp = kmem_alloc(sz, KM_SLEEP); 536 bcopy(zap->zap_dbuf->db_data, mzp, sz); 537 nchunks = zap->zap_m.zap_num_chunks; 538 539 if (!flags) { 540 err = dmu_object_set_blocksize(zap->zap_objset, zap->zap_object, 541 1ULL << fzap_default_block_shift, 0, tx); 542 if (err) { 543 kmem_free(mzp, sz); 544 return (err); 545 } 546 } 547 548 dprintf("upgrading obj=%llu with %u chunks\n", 549 zap->zap_object, nchunks); 550 /* XXX destroy the avl later, so we can use the stored hash value */ 551 mze_destroy(zap); 552 553 fzap_upgrade(zap, tx, flags); 554 555 for (i = 0; i < nchunks; i++) { 556 mzap_ent_phys_t *mze = &mzp->mz_chunk[i]; 557 zap_name_t *zn; 558 if (mze->mze_name[0] == 0) 559 continue; 560 dprintf("adding %s=%llu\n", 561 mze->mze_name, mze->mze_value); 562 zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT); 563 err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, tx); 564 zap = zn->zn_zap; /* fzap_add_cd() may change zap */ 565 zap_name_free(zn); 566 if (err) 567 break; 568 } 569 kmem_free(mzp, sz); 570 *zapp = zap; 571 return (err); 572} 573 574static void 575mzap_create_impl(objset_t *os, uint64_t obj, int normflags, zap_flags_t flags, 576 dmu_tx_t *tx) 577{ 578 dmu_buf_t *db; 579 mzap_phys_t *zp; 580 581 VERIFY(0 == dmu_buf_hold(os, obj, 0, FTAG, &db, DMU_READ_NO_PREFETCH)); 582 583#ifdef ZFS_DEBUG 584 { 585 dmu_object_info_t doi; 586 dmu_object_info_from_db(db, &doi); 587 ASSERT(dmu_ot[doi.doi_type].ot_byteswap == zap_byteswap); 588 } 589#endif 590 591 dmu_buf_will_dirty(db, tx); 592 zp = db->db_data; 593 zp->mz_block_type = ZBT_MICRO; 594 zp->mz_salt = ((uintptr_t)db ^ (uintptr_t)tx ^ (obj << 1)) | 1ULL; 595 zp->mz_normflags = normflags; 596 dmu_buf_rele(db, FTAG); 597 598 if (flags != 0) { 599 zap_t *zap; 600 /* Only fat zap supports flags; upgrade immediately. */ 601 VERIFY(0 == zap_lockdir(os, obj, tx, RW_WRITER, 602 B_FALSE, B_FALSE, &zap)); 603 VERIFY3U(0, ==, mzap_upgrade(&zap, tx, flags)); 604 zap_unlockdir(zap); 605 } 606} 607 608int 609zap_create_claim(objset_t *os, uint64_t obj, dmu_object_type_t ot, 610 dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 611{ 612 return (zap_create_claim_norm(os, obj, 613 0, ot, bonustype, bonuslen, tx)); 614} 615 616int 617zap_create_claim_norm(objset_t *os, uint64_t obj, int normflags, 618 dmu_object_type_t ot, 619 dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 620{ 621 int err; 622 623 err = dmu_object_claim(os, obj, ot, 0, bonustype, bonuslen, tx); 624 if (err != 0) 625 return (err); 626 mzap_create_impl(os, obj, normflags, 0, tx); 627 return (0); 628} 629 630uint64_t 631zap_create(objset_t *os, dmu_object_type_t ot, 632 dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 633{ 634 return (zap_create_norm(os, 0, ot, bonustype, bonuslen, tx)); 635} 636 637uint64_t 638zap_create_norm(objset_t *os, int normflags, dmu_object_type_t ot, 639 dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 640{ 641 uint64_t obj = dmu_object_alloc(os, ot, 0, bonustype, bonuslen, tx); 642 643 mzap_create_impl(os, obj, normflags, 0, tx); 644 return (obj); 645} 646 647uint64_t 648zap_create_flags(objset_t *os, int normflags, zap_flags_t flags, 649 dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift, 650 dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 651{ 652 uint64_t obj = dmu_object_alloc(os, ot, 0, bonustype, bonuslen, tx); 653 654 ASSERT(leaf_blockshift >= SPA_MINBLOCKSHIFT && 655 leaf_blockshift <= SPA_MAXBLOCKSHIFT && 656 indirect_blockshift >= SPA_MINBLOCKSHIFT && 657 indirect_blockshift <= SPA_MAXBLOCKSHIFT); 658 659 VERIFY(dmu_object_set_blocksize(os, obj, 660 1ULL << leaf_blockshift, indirect_blockshift, tx) == 0); 661 662 mzap_create_impl(os, obj, normflags, flags, tx); 663 return (obj); 664} 665 666int 667zap_destroy(objset_t *os, uint64_t zapobj, dmu_tx_t *tx) 668{ 669 /* 670 * dmu_object_free will free the object number and free the 671 * data. Freeing the data will cause our pageout function to be 672 * called, which will destroy our data (zap_leaf_t's and zap_t). 673 */ 674 675 return (dmu_object_free(os, zapobj, tx)); 676} 677 678_NOTE(ARGSUSED(0)) 679void 680zap_evict(dmu_buf_t *db, void *vzap) 681{ 682 zap_t *zap = vzap; 683 684 rw_destroy(&zap->zap_rwlock); 685 686 if (zap->zap_ismicro) 687 mze_destroy(zap); 688 else 689 mutex_destroy(&zap->zap_f.zap_num_entries_mtx); 690 691 kmem_free(zap, sizeof (zap_t)); 692} 693 694int 695zap_count(objset_t *os, uint64_t zapobj, uint64_t *count) 696{ 697 zap_t *zap; 698 int err; 699 700 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 701 if (err) 702 return (err); 703 if (!zap->zap_ismicro) { 704 err = fzap_count(zap, count); 705 } else { 706 *count = zap->zap_m.zap_num_entries; 707 } 708 zap_unlockdir(zap); 709 return (err); 710} 711 712/* 713 * zn may be NULL; if not specified, it will be computed if needed. 714 * See also the comment above zap_entry_normalization_conflict(). 715 */ 716static boolean_t 717mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze) 718{ 719 mzap_ent_t *other; 720 int direction = AVL_BEFORE; 721 boolean_t allocdzn = B_FALSE; 722 723 if (zap->zap_normflags == 0) 724 return (B_FALSE); 725 726again: 727 for (other = avl_walk(&zap->zap_m.zap_avl, mze, direction); 728 other && other->mze_hash == mze->mze_hash; 729 other = avl_walk(&zap->zap_m.zap_avl, other, direction)) { 730 731 if (zn == NULL) { 732 zn = zap_name_alloc(zap, MZE_PHYS(zap, mze)->mze_name, 733 MT_FIRST); 734 allocdzn = B_TRUE; 735 } 736 if (zap_match(zn, MZE_PHYS(zap, other)->mze_name)) { 737 if (allocdzn) 738 zap_name_free(zn); 739 return (B_TRUE); 740 } 741 } 742 743 if (direction == AVL_BEFORE) { 744 direction = AVL_AFTER; 745 goto again; 746 } 747 748 if (allocdzn) 749 zap_name_free(zn); 750 return (B_FALSE); 751} 752 753/* 754 * Routines for manipulating attributes. 755 */ 756 757int 758zap_lookup(objset_t *os, uint64_t zapobj, const char *name, 759 uint64_t integer_size, uint64_t num_integers, void *buf) 760{ 761 return (zap_lookup_norm(os, zapobj, name, integer_size, 762 num_integers, buf, MT_EXACT, NULL, 0, NULL)); 763} 764 765int 766zap_lookup_norm(objset_t *os, uint64_t zapobj, const char *name, 767 uint64_t integer_size, uint64_t num_integers, void *buf, 768 matchtype_t mt, char *realname, int rn_len, 769 boolean_t *ncp) 770{ 771 zap_t *zap; 772 int err; 773 mzap_ent_t *mze; 774 zap_name_t *zn; 775 776 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 777 if (err) 778 return (err); 779 zn = zap_name_alloc(zap, name, mt); 780 if (zn == NULL) { 781 zap_unlockdir(zap); 782 return (ENOTSUP); 783 } 784 785 if (!zap->zap_ismicro) { 786 err = fzap_lookup(zn, integer_size, num_integers, buf, 787 realname, rn_len, ncp); 788 } else { 789 mze = mze_find(zn); 790 if (mze == NULL) { 791 err = ENOENT; 792 } else { 793 if (num_integers < 1) { 794 err = EOVERFLOW; 795 } else if (integer_size != 8) { 796 err = EINVAL; 797 } else { 798 *(uint64_t *)buf = 799 MZE_PHYS(zap, mze)->mze_value; 800 (void) strlcpy(realname, 801 MZE_PHYS(zap, mze)->mze_name, rn_len); 802 if (ncp) { 803 *ncp = mzap_normalization_conflict(zap, 804 zn, mze); 805 } 806 } 807 } 808 } 809 zap_name_free(zn); 810 zap_unlockdir(zap); 811 return (err); 812} 813 814int 815zap_prefetch_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 816 int key_numints) 817{ 818 zap_t *zap; 819 int err; 820 zap_name_t *zn; 821 822 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 823 if (err) 824 return (err); 825 zn = zap_name_alloc_uint64(zap, key, key_numints); 826 if (zn == NULL) { 827 zap_unlockdir(zap); 828 return (ENOTSUP); 829 } 830 831 fzap_prefetch(zn); 832 zap_name_free(zn); 833 zap_unlockdir(zap); 834 return (err); 835} 836 837int 838zap_lookup_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 839 int key_numints, uint64_t integer_size, uint64_t num_integers, void *buf) 840{ 841 zap_t *zap; 842 int err; 843 zap_name_t *zn; 844 845 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 846 if (err) 847 return (err); 848 zn = zap_name_alloc_uint64(zap, key, key_numints); 849 if (zn == NULL) { 850 zap_unlockdir(zap); 851 return (ENOTSUP); 852 } 853 854 err = fzap_lookup(zn, integer_size, num_integers, buf, 855 NULL, 0, NULL); 856 zap_name_free(zn); 857 zap_unlockdir(zap); 858 return (err); 859} 860 861int 862zap_contains(objset_t *os, uint64_t zapobj, const char *name) 863{ 864 int err = (zap_lookup_norm(os, zapobj, name, 0, 865 0, NULL, MT_EXACT, NULL, 0, NULL)); 866 if (err == EOVERFLOW || err == EINVAL) 867 err = 0; /* found, but skipped reading the value */ 868 return (err); 869} 870 871int 872zap_length(objset_t *os, uint64_t zapobj, const char *name, 873 uint64_t *integer_size, uint64_t *num_integers) 874{ 875 zap_t *zap; 876 int err; 877 mzap_ent_t *mze; 878 zap_name_t *zn; 879 880 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 881 if (err) 882 return (err); 883 zn = zap_name_alloc(zap, name, MT_EXACT); 884 if (zn == NULL) { 885 zap_unlockdir(zap); 886 return (ENOTSUP); 887 } 888 if (!zap->zap_ismicro) { 889 err = fzap_length(zn, integer_size, num_integers); 890 } else { 891 mze = mze_find(zn); 892 if (mze == NULL) { 893 err = ENOENT; 894 } else { 895 if (integer_size) 896 *integer_size = 8; 897 if (num_integers) 898 *num_integers = 1; 899 } 900 } 901 zap_name_free(zn); 902 zap_unlockdir(zap); 903 return (err); 904} 905 906int 907zap_length_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 908 int key_numints, uint64_t *integer_size, uint64_t *num_integers) 909{ 910 zap_t *zap; 911 int err; 912 zap_name_t *zn; 913 914 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 915 if (err) 916 return (err); 917 zn = zap_name_alloc_uint64(zap, key, key_numints); 918 if (zn == NULL) { 919 zap_unlockdir(zap); 920 return (ENOTSUP); 921 } 922 err = fzap_length(zn, integer_size, num_integers); 923 zap_name_free(zn); 924 zap_unlockdir(zap); 925 return (err); 926} 927 928static void 929mzap_addent(zap_name_t *zn, uint64_t value) 930{ 931 int i; 932 zap_t *zap = zn->zn_zap; 933 int start = zap->zap_m.zap_alloc_next; 934 uint32_t cd; 935 936 ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 937 938#ifdef ZFS_DEBUG 939 for (i = 0; i < zap->zap_m.zap_num_chunks; i++) { 940 mzap_ent_phys_t *mze = &zap->zap_m.zap_phys->mz_chunk[i]; 941 ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0); 942 } 943#endif 944 945 cd = mze_find_unused_cd(zap, zn->zn_hash); 946 /* given the limited size of the microzap, this can't happen */ 947 ASSERT(cd < zap_maxcd(zap)); 948 949again: 950 for (i = start; i < zap->zap_m.zap_num_chunks; i++) { 951 mzap_ent_phys_t *mze = &zap->zap_m.zap_phys->mz_chunk[i]; 952 if (mze->mze_name[0] == 0) { 953 mze->mze_value = value; 954 mze->mze_cd = cd; 955 (void) strcpy(mze->mze_name, zn->zn_key_orig); 956 zap->zap_m.zap_num_entries++; 957 zap->zap_m.zap_alloc_next = i+1; 958 if (zap->zap_m.zap_alloc_next == 959 zap->zap_m.zap_num_chunks) 960 zap->zap_m.zap_alloc_next = 0; 961 mze_insert(zap, i, zn->zn_hash); 962 return; 963 } 964 } 965 if (start != 0) { 966 start = 0; 967 goto again; 968 } 969 ASSERT(!"out of entries!"); 970} 971 972int 973zap_add(objset_t *os, uint64_t zapobj, const char *key, 974 int integer_size, uint64_t num_integers, 975 const void *val, dmu_tx_t *tx) 976{ 977 zap_t *zap; 978 int err; 979 mzap_ent_t *mze; 980 const uint64_t *intval = val; 981 zap_name_t *zn; 982 983 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 984 if (err) 985 return (err); 986 zn = zap_name_alloc(zap, key, MT_EXACT); 987 if (zn == NULL) { 988 zap_unlockdir(zap); 989 return (ENOTSUP); 990 } 991 if (!zap->zap_ismicro) { 992 err = fzap_add(zn, integer_size, num_integers, val, tx); 993 zap = zn->zn_zap; /* fzap_add() may change zap */ 994 } else if (integer_size != 8 || num_integers != 1 || 995 strlen(key) >= MZAP_NAME_LEN) { 996 err = mzap_upgrade(&zn->zn_zap, tx, 0); 997 if (err == 0) 998 err = fzap_add(zn, integer_size, num_integers, val, tx); 999 zap = zn->zn_zap; /* fzap_add() may change zap */ 1000 } else { 1001 mze = mze_find(zn); 1002 if (mze != NULL) { 1003 err = EEXIST; 1004 } else { 1005 mzap_addent(zn, *intval); 1006 } 1007 } 1008 ASSERT(zap == zn->zn_zap); 1009 zap_name_free(zn); 1010 if (zap != NULL) /* may be NULL if fzap_add() failed */ 1011 zap_unlockdir(zap); 1012 return (err); 1013} 1014 1015int 1016zap_add_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1017 int key_numints, int integer_size, uint64_t num_integers, 1018 const void *val, dmu_tx_t *tx) 1019{ 1020 zap_t *zap; 1021 int err; 1022 zap_name_t *zn; 1023 1024 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 1025 if (err) 1026 return (err); 1027 zn = zap_name_alloc_uint64(zap, key, key_numints); 1028 if (zn == NULL) { 1029 zap_unlockdir(zap); 1030 return (ENOTSUP); 1031 } 1032 err = fzap_add(zn, integer_size, num_integers, val, tx); 1033 zap = zn->zn_zap; /* fzap_add() may change zap */ 1034 zap_name_free(zn); 1035 if (zap != NULL) /* may be NULL if fzap_add() failed */ 1036 zap_unlockdir(zap); 1037 return (err); 1038} 1039 1040int 1041zap_update(objset_t *os, uint64_t zapobj, const char *name, 1042 int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx) 1043{ 1044 zap_t *zap; 1045 mzap_ent_t *mze; 1046 uint64_t oldval; 1047 const uint64_t *intval = val; 1048 zap_name_t *zn; 1049 int err; 1050 1051#ifdef ZFS_DEBUG 1052 /* 1053 * If there is an old value, it shouldn't change across the 1054 * lockdir (eg, due to bprewrite's xlation). 1055 */ 1056 if (integer_size == 8 && num_integers == 1) 1057 (void) zap_lookup(os, zapobj, name, 8, 1, &oldval); 1058#endif 1059 1060 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 1061 if (err) 1062 return (err); 1063 zn = zap_name_alloc(zap, name, MT_EXACT); 1064 if (zn == NULL) { 1065 zap_unlockdir(zap); 1066 return (ENOTSUP); 1067 } 1068 if (!zap->zap_ismicro) { 1069 err = fzap_update(zn, integer_size, num_integers, val, tx); 1070 zap = zn->zn_zap; /* fzap_update() may change zap */ 1071 } else if (integer_size != 8 || num_integers != 1 || 1072 strlen(name) >= MZAP_NAME_LEN) { 1073 dprintf("upgrading obj %llu: intsz=%u numint=%llu name=%s\n", 1074 zapobj, integer_size, num_integers, name); 1075 err = mzap_upgrade(&zn->zn_zap, tx, 0); 1076 if (err == 0) 1077 err = fzap_update(zn, integer_size, num_integers, 1078 val, tx); 1079 zap = zn->zn_zap; /* fzap_update() may change zap */ 1080 } else { 1081 mze = mze_find(zn); 1082 if (mze != NULL) { 1083 ASSERT3U(MZE_PHYS(zap, mze)->mze_value, ==, oldval); 1084 MZE_PHYS(zap, mze)->mze_value = *intval; 1085 } else { 1086 mzap_addent(zn, *intval); 1087 } 1088 } 1089 ASSERT(zap == zn->zn_zap); 1090 zap_name_free(zn); 1091 if (zap != NULL) /* may be NULL if fzap_upgrade() failed */ 1092 zap_unlockdir(zap); 1093 return (err); 1094} 1095 1096int 1097zap_update_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1098 int key_numints, 1099 int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx) 1100{ 1101 zap_t *zap; 1102 zap_name_t *zn; 1103 int err; 1104 1105 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 1106 if (err) 1107 return (err); 1108 zn = zap_name_alloc_uint64(zap, key, key_numints); 1109 if (zn == NULL) { 1110 zap_unlockdir(zap); 1111 return (ENOTSUP); 1112 } 1113 err = fzap_update(zn, integer_size, num_integers, val, tx); 1114 zap = zn->zn_zap; /* fzap_update() may change zap */ 1115 zap_name_free(zn); 1116 if (zap != NULL) /* may be NULL if fzap_upgrade() failed */ 1117 zap_unlockdir(zap); 1118 return (err); 1119} 1120 1121int 1122zap_remove(objset_t *os, uint64_t zapobj, const char *name, dmu_tx_t *tx) 1123{ 1124 return (zap_remove_norm(os, zapobj, name, MT_EXACT, tx)); 1125} 1126 1127int 1128zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name, 1129 matchtype_t mt, dmu_tx_t *tx) 1130{ 1131 zap_t *zap; 1132 int err; 1133 mzap_ent_t *mze; 1134 zap_name_t *zn; 1135 1136 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, &zap); 1137 if (err) 1138 return (err); 1139 zn = zap_name_alloc(zap, name, mt); 1140 if (zn == NULL) { 1141 zap_unlockdir(zap); 1142 return (ENOTSUP); 1143 } 1144 if (!zap->zap_ismicro) { 1145 err = fzap_remove(zn, tx); 1146 } else { 1147 mze = mze_find(zn); 1148 if (mze == NULL) { 1149 err = ENOENT; 1150 } else { 1151 zap->zap_m.zap_num_entries--; 1152 bzero(&zap->zap_m.zap_phys->mz_chunk[mze->mze_chunkid], 1153 sizeof (mzap_ent_phys_t)); 1154 mze_remove(zap, mze); 1155 } 1156 } 1157 zap_name_free(zn); 1158 zap_unlockdir(zap); 1159 return (err); 1160} 1161 1162int 1163zap_remove_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1164 int key_numints, dmu_tx_t *tx) 1165{ 1166 zap_t *zap; 1167 int err; 1168 zap_name_t *zn; 1169 1170 err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, &zap); 1171 if (err) 1172 return (err); 1173 zn = zap_name_alloc_uint64(zap, key, key_numints); 1174 if (zn == NULL) { 1175 zap_unlockdir(zap); 1176 return (ENOTSUP); 1177 } 1178 err = fzap_remove(zn, tx); 1179 zap_name_free(zn); 1180 zap_unlockdir(zap); 1181 return (err); 1182} 1183 1184/* 1185 * Routines for iterating over the attributes. 1186 */ 1187 1188void 1189zap_cursor_init_serialized(zap_cursor_t *zc, objset_t *os, uint64_t zapobj, 1190 uint64_t serialized) 1191{ 1192 zc->zc_objset = os; 1193 zc->zc_zap = NULL; 1194 zc->zc_leaf = NULL; 1195 zc->zc_zapobj = zapobj; 1196 zc->zc_serialized = serialized; 1197 zc->zc_hash = 0; 1198 zc->zc_cd = 0; 1199} 1200 1201void 1202zap_cursor_init(zap_cursor_t *zc, objset_t *os, uint64_t zapobj) 1203{ 1204 zap_cursor_init_serialized(zc, os, zapobj, 0); 1205} 1206 1207void 1208zap_cursor_fini(zap_cursor_t *zc) 1209{ 1210 if (zc->zc_zap) { 1211 rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1212 zap_unlockdir(zc->zc_zap); 1213 zc->zc_zap = NULL; 1214 } 1215 if (zc->zc_leaf) { 1216 rw_enter(&zc->zc_leaf->l_rwlock, RW_READER); 1217 zap_put_leaf(zc->zc_leaf); 1218 zc->zc_leaf = NULL; 1219 } 1220 zc->zc_objset = NULL; 1221} 1222 1223uint64_t 1224zap_cursor_serialize(zap_cursor_t *zc) 1225{ 1226 if (zc->zc_hash == -1ULL) 1227 return (-1ULL); 1228 if (zc->zc_zap == NULL) 1229 return (zc->zc_serialized); 1230 ASSERT((zc->zc_hash & zap_maxcd(zc->zc_zap)) == 0); 1231 ASSERT(zc->zc_cd < zap_maxcd(zc->zc_zap)); 1232 1233 /* 1234 * We want to keep the high 32 bits of the cursor zero if we can, so 1235 * that 32-bit programs can access this. So usually use a small 1236 * (28-bit) hash value so we can fit 4 bits of cd into the low 32-bits 1237 * of the cursor. 1238 * 1239 * [ collision differentiator | zap_hashbits()-bit hash value ] 1240 */ 1241 return ((zc->zc_hash >> (64 - zap_hashbits(zc->zc_zap))) | 1242 ((uint64_t)zc->zc_cd << zap_hashbits(zc->zc_zap))); 1243} 1244 1245int 1246zap_cursor_retrieve(zap_cursor_t *zc, zap_attribute_t *za) 1247{ 1248 int err; 1249 avl_index_t idx; 1250 mzap_ent_t mze_tofind; 1251 mzap_ent_t *mze; 1252 1253 if (zc->zc_hash == -1ULL) 1254 return (ENOENT); 1255 1256 if (zc->zc_zap == NULL) { 1257 int hb; 1258 err = zap_lockdir(zc->zc_objset, zc->zc_zapobj, NULL, 1259 RW_READER, TRUE, FALSE, &zc->zc_zap); 1260 if (err) 1261 return (err); 1262 1263 /* 1264 * To support zap_cursor_init_serialized, advance, retrieve, 1265 * we must add to the existing zc_cd, which may already 1266 * be 1 due to the zap_cursor_advance. 1267 */ 1268 ASSERT(zc->zc_hash == 0); 1269 hb = zap_hashbits(zc->zc_zap); 1270 zc->zc_hash = zc->zc_serialized << (64 - hb); 1271 zc->zc_cd += zc->zc_serialized >> hb; 1272 if (zc->zc_cd >= zap_maxcd(zc->zc_zap)) /* corrupt serialized */ 1273 zc->zc_cd = 0; 1274 } else { 1275 rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1276 } 1277 if (!zc->zc_zap->zap_ismicro) { 1278 err = fzap_cursor_retrieve(zc->zc_zap, zc, za); 1279 } else { 1280 err = ENOENT; 1281 1282 mze_tofind.mze_hash = zc->zc_hash; 1283 mze_tofind.mze_cd = zc->zc_cd; 1284 1285 mze = avl_find(&zc->zc_zap->zap_m.zap_avl, &mze_tofind, &idx); 1286 if (mze == NULL) { 1287 mze = avl_nearest(&zc->zc_zap->zap_m.zap_avl, 1288 idx, AVL_AFTER); 1289 } 1290 if (mze) { 1291 mzap_ent_phys_t *mzep = MZE_PHYS(zc->zc_zap, mze); 1292 ASSERT3U(mze->mze_cd, ==, mzep->mze_cd); 1293 za->za_normalization_conflict = 1294 mzap_normalization_conflict(zc->zc_zap, NULL, mze); 1295 za->za_integer_length = 8; 1296 za->za_num_integers = 1; 1297 za->za_first_integer = mzep->mze_value; 1298 (void) strcpy(za->za_name, mzep->mze_name); 1299 zc->zc_hash = mze->mze_hash; 1300 zc->zc_cd = mze->mze_cd; 1301 err = 0; 1302 } else { 1303 zc->zc_hash = -1ULL; 1304 } 1305 } 1306 rw_exit(&zc->zc_zap->zap_rwlock); 1307 return (err); 1308} 1309 1310void 1311zap_cursor_advance(zap_cursor_t *zc) 1312{ 1313 if (zc->zc_hash == -1ULL) 1314 return; 1315 zc->zc_cd++; 1316} 1317 1318int 1319zap_cursor_move_to_key(zap_cursor_t *zc, const char *name, matchtype_t mt) 1320{ 1321 int err = 0; 1322 mzap_ent_t *mze; 1323 zap_name_t *zn; 1324 1325 if (zc->zc_zap == NULL) { 1326 err = zap_lockdir(zc->zc_objset, zc->zc_zapobj, NULL, 1327 RW_READER, TRUE, FALSE, &zc->zc_zap); 1328 if (err) 1329 return (err); 1330 } else { 1331 rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1332 } 1333 1334 zn = zap_name_alloc(zc->zc_zap, name, mt); 1335 if (zn == NULL) { 1336 rw_exit(&zc->zc_zap->zap_rwlock); 1337 return (ENOTSUP); 1338 } 1339 1340 if (!zc->zc_zap->zap_ismicro) { 1341 err = fzap_cursor_move_to_key(zc, zn); 1342 } else { 1343 mze = mze_find(zn); 1344 if (mze == NULL) { 1345 err = ENOENT; 1346 goto out; 1347 } 1348 zc->zc_hash = mze->mze_hash; 1349 zc->zc_cd = mze->mze_cd; 1350 } 1351 1352out: 1353 zap_name_free(zn); 1354 rw_exit(&zc->zc_zap->zap_rwlock); 1355 return (err); 1356} 1357 1358int 1359zap_get_stats(objset_t *os, uint64_t zapobj, zap_stats_t *zs) 1360{ 1361 int err; 1362 zap_t *zap; 1363 1364 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 1365 if (err) 1366 return (err); 1367 1368 bzero(zs, sizeof (zap_stats_t)); 1369 1370 if (zap->zap_ismicro) { 1371 zs->zs_blocksize = zap->zap_dbuf->db_size; 1372 zs->zs_num_entries = zap->zap_m.zap_num_entries; 1373 zs->zs_num_blocks = 1; 1374 } else { 1375 fzap_get_stats(zap, zs); 1376 } 1377 zap_unlockdir(zap); 1378 return (0); 1379} 1380 1381int 1382zap_count_write(objset_t *os, uint64_t zapobj, const char *name, int add, 1383 uint64_t *towrite, uint64_t *tooverwrite) 1384{ 1385 zap_t *zap; 1386 int err = 0; 1387 1388 1389 /* 1390 * Since, we don't have a name, we cannot figure out which blocks will 1391 * be affected in this operation. So, account for the worst case : 1392 * - 3 blocks overwritten: target leaf, ptrtbl block, header block 1393 * - 4 new blocks written if adding: 1394 * - 2 blocks for possibly split leaves, 1395 * - 2 grown ptrtbl blocks 1396 * 1397 * This also accomodates the case where an add operation to a fairly 1398 * large microzap results in a promotion to fatzap. 1399 */ 1400 if (name == NULL) { 1401 *towrite += (3 + (add ? 4 : 0)) * SPA_MAXBLOCKSIZE; 1402 return (err); 1403 } 1404 1405 /* 1406 * We lock the zap with adding == FALSE. Because, if we pass 1407 * the actual value of add, it could trigger a mzap_upgrade(). 1408 * At present we are just evaluating the possibility of this operation 1409 * and hence we donot want to trigger an upgrade. 1410 */ 1411 err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 1412 if (err) 1413 return (err); 1414 1415 if (!zap->zap_ismicro) { 1416 zap_name_t *zn = zap_name_alloc(zap, name, MT_EXACT); 1417 if (zn) { 1418 err = fzap_count_write(zn, add, towrite, 1419 tooverwrite); 1420 zap_name_free(zn); 1421 } else { 1422 /* 1423 * We treat this case as similar to (name == NULL) 1424 */ 1425 *towrite += (3 + (add ? 4 : 0)) * SPA_MAXBLOCKSIZE; 1426 } 1427 } else { 1428 /* 1429 * We are here if (name != NULL) and this is a micro-zap. 1430 * We account for the header block depending on whether it 1431 * is freeable. 1432 * 1433 * Incase of an add-operation it is hard to find out 1434 * if this add will promote this microzap to fatzap. 1435 * Hence, we consider the worst case and account for the 1436 * blocks assuming this microzap would be promoted to a 1437 * fatzap. 1438 * 1439 * 1 block overwritten : header block 1440 * 4 new blocks written : 2 new split leaf, 2 grown 1441 * ptrtbl blocks 1442 */ 1443 if (dmu_buf_freeable(zap->zap_dbuf)) 1444 *tooverwrite += SPA_MAXBLOCKSIZE; 1445 else 1446 *towrite += SPA_MAXBLOCKSIZE; 1447 1448 if (add) { 1449 *towrite += 4 * SPA_MAXBLOCKSIZE; 1450 } 1451 } 1452 1453 zap_unlockdir(zap); 1454 return (err); 1455} 1456