Deleted Added
sdiff udiff text old ( 296519 ) new ( 299439 )
full compact
zap_micro.c (296519) zap_micro.c (299439)
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

--- 359 unchanged lines hidden (view full) ---

368}
369
370static zap_t *
371mzap_open(objset_t *os, uint64_t obj, dmu_buf_t *db)
372{
373 zap_t *winner;
374 zap_t *zap;
375 int i;
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

--- 359 unchanged lines hidden (view full) ---

368}
369
370static zap_t *
371mzap_open(objset_t *os, uint64_t obj, dmu_buf_t *db)
372{
373 zap_t *winner;
374 zap_t *zap;
375 int i;
376 uint64_t *zap_hdr = (uint64_t *)db->db_data;
377 uint64_t zap_block_type = zap_hdr[0];
378 uint64_t zap_magic = zap_hdr[1];
376
377 ASSERT3U(MZAP_ENT_LEN, ==, sizeof (mzap_ent_phys_t));
378
379 zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP);
380 rw_init(&zap->zap_rwlock, 0, 0, 0);
381 rw_enter(&zap->zap_rwlock, RW_WRITER);
382 zap->zap_objset = os;
383 zap->zap_object = obj;
384 zap->zap_dbuf = db;
385
379
380 ASSERT3U(MZAP_ENT_LEN, ==, sizeof (mzap_ent_phys_t));
381
382 zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP);
383 rw_init(&zap->zap_rwlock, 0, 0, 0);
384 rw_enter(&zap->zap_rwlock, RW_WRITER);
385 zap->zap_objset = os;
386 zap->zap_object = obj;
387 zap->zap_dbuf = db;
388
386 if (*(uint64_t *)db->db_data != ZBT_MICRO) {
389 if (zap_block_type != ZBT_MICRO) {
387 mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0);
388 zap->zap_f.zap_block_shift = highbit64(db->db_size) - 1;
390 mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0);
391 zap->zap_f.zap_block_shift = highbit64(db->db_size) - 1;
392 if (zap_block_type != ZBT_HEADER || zap_magic != ZAP_MAGIC) {
393 winner = NULL; /* No actual winner here... */
394 goto handle_winner;
395 }
389 } else {
390 zap->zap_ismicro = TRUE;
391 }
392
393 /*
394 * Make sure that zap_ismicro is set before we let others see
395 * it, because zap_lockdir() checks zap_ismicro without the lock
396 * held.
397 */
398 dmu_buf_init_user(&zap->zap_dbu, zap_evict, &zap->zap_dbuf);
399 winner = dmu_buf_set_user(db, &zap->zap_dbu);
400
396 } else {
397 zap->zap_ismicro = TRUE;
398 }
399
400 /*
401 * Make sure that zap_ismicro is set before we let others see
402 * it, because zap_lockdir() checks zap_ismicro without the lock
403 * held.
404 */
405 dmu_buf_init_user(&zap->zap_dbu, zap_evict, &zap->zap_dbuf);
406 winner = dmu_buf_set_user(db, &zap->zap_dbu);
407
401 if (winner != NULL) {
402 rw_exit(&zap->zap_rwlock);
403 rw_destroy(&zap->zap_rwlock);
404 if (!zap->zap_ismicro)
405 mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
406 kmem_free(zap, sizeof (zap_t));
407 return (winner);
408 }
408 if (winner != NULL)
409 goto handle_winner;
409
410 if (zap->zap_ismicro) {
411 zap->zap_salt = zap_m_phys(zap)->mz_salt;
412 zap->zap_normflags = zap_m_phys(zap)->mz_normflags;
413 zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1;
414 avl_create(&zap->zap_m.zap_avl, mze_compare,
415 sizeof (mzap_ent_t), offsetof(mzap_ent_t, mze_node));
416

--- 35 unchanged lines hidden (view full) ---

452 */
453 ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap,
454 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) -
455 (uintptr_t)zap_f_phys(zap), ==,
456 zap->zap_dbuf->db_size);
457 }
458 rw_exit(&zap->zap_rwlock);
459 return (zap);
410
411 if (zap->zap_ismicro) {
412 zap->zap_salt = zap_m_phys(zap)->mz_salt;
413 zap->zap_normflags = zap_m_phys(zap)->mz_normflags;
414 zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1;
415 avl_create(&zap->zap_m.zap_avl, mze_compare,
416 sizeof (mzap_ent_t), offsetof(mzap_ent_t, mze_node));
417

--- 35 unchanged lines hidden (view full) ---

453 */
454 ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap,
455 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) -
456 (uintptr_t)zap_f_phys(zap), ==,
457 zap->zap_dbuf->db_size);
458 }
459 rw_exit(&zap->zap_rwlock);
460 return (zap);
461
462handle_winner:
463 rw_exit(&zap->zap_rwlock);
464 rw_destroy(&zap->zap_rwlock);
465 if (!zap->zap_ismicro)
466 mutex_destroy(&zap->zap_f.zap_num_entries_mtx);
467 kmem_free(zap, sizeof (zap_t));
468 return (winner);
460}
461
462int
463zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx,
464 krw_t lti, boolean_t fatreader, boolean_t adding, zap_t **zapp)
465{
466 zap_t *zap;
467 dmu_buf_t *db;

--- 10 unchanged lines hidden (view full) ---

478 {
479 dmu_object_info_t doi;
480 dmu_object_info_from_db(db, &doi);
481 ASSERT3U(DMU_OT_BYTESWAP(doi.doi_type), ==, DMU_BSWAP_ZAP);
482 }
483#endif
484
485 zap = dmu_buf_get_user(db);
469}
470
471int
472zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx,
473 krw_t lti, boolean_t fatreader, boolean_t adding, zap_t **zapp)
474{
475 zap_t *zap;
476 dmu_buf_t *db;

--- 10 unchanged lines hidden (view full) ---

487 {
488 dmu_object_info_t doi;
489 dmu_object_info_from_db(db, &doi);
490 ASSERT3U(DMU_OT_BYTESWAP(doi.doi_type), ==, DMU_BSWAP_ZAP);
491 }
492#endif
493
494 zap = dmu_buf_get_user(db);
486 if (zap == NULL)
495 if (zap == NULL) {
487 zap = mzap_open(os, obj, db);
496 zap = mzap_open(os, obj, db);
497 if (zap == NULL) {
498 /*
499 * mzap_open() didn't like what it saw on-disk.
500 * Check for corruption!
501 */
502 dmu_buf_rele(db, NULL);
503 return (SET_ERROR(EIO));
504 }
505 }
488
489 /*
490 * We're checking zap_ismicro without the lock held, in order to
491 * tell what type of lock we want. Once we have some sort of
492 * lock, see if it really is the right type. In practice this
493 * can only be different if it was upgraded from micro to fat,
494 * and micro wanted WRITER but fat only needs READER.
495 */

--- 975 unchanged lines hidden --- 		506
507 /*
508 * We're checking zap_ismicro without the lock held, in order to
509 * tell what type of lock we want. Once we have some sort of
510 * lock, see if it really is the right type. In practice this
511 * can only be different if it was upgraded from micro to fat,
512 * and micro wanted WRITER but fat only needs READER.
513 */

--- 975 unchanged lines hidden ---