From be1858848e14af8c60e7bc03260bfc41d2db7ea4 Mon Sep 17 00:00:00 2001 From: Vitaliy Filippov Date: Sat, 22 Nov 2025 18:10:32 +0300 Subject: [PATCH] Remove block_order and replace << >> by / * data_block_size --- src/blockstore/blockstore_disk.cpp | 2 +- src/blockstore/blockstore_disk.h | 1 - src/blockstore/blockstore_flush.cpp | 24 ++++++++++++------------ src/blockstore/blockstore_init.cpp | 14 +++++++------- src/blockstore/blockstore_read.cpp | 10 +++++----- src/blockstore/blockstore_rollback.cpp | 4 ++-- src/blockstore/blockstore_write.cpp | 4 ++-- 7 files changed, 29 insertions(+), 30 deletions(-) diff --git a/src/blockstore/blockstore_disk.cpp b/src/blockstore/blockstore_disk.cpp index 86446a03..111bacce 100644 --- a/src/blockstore/blockstore_disk.cpp +++ b/src/blockstore/blockstore_disk.cpp @@ -95,7 +95,7 @@ void blockstore_disk_t::parse_config(std::map & config { data_block_size = (1 << DEFAULT_DATA_BLOCK_ORDER); } - if ((block_order = is_power_of_two(data_block_size)) >= 64 || data_block_size < MIN_DATA_BLOCK_SIZE || data_block_size >= MAX_DATA_BLOCK_SIZE) + if (is_power_of_two(data_block_size) >= 64 || data_block_size < MIN_DATA_BLOCK_SIZE || data_block_size >= MAX_DATA_BLOCK_SIZE) { throw std::runtime_error("Bad block size"); } diff --git a/src/blockstore/blockstore_disk.h b/src/blockstore/blockstore_disk.h index 1747b81c..db2dc71d 100644 --- a/src/blockstore/blockstore_disk.h +++ b/src/blockstore/blockstore_disk.h @@ -46,7 +46,6 @@ struct blockstore_disk_t uint64_t data_offset, data_device_sect, data_device_size, data_len; uint64_t journal_offset, journal_device_sect, journal_device_size, journal_len; - uint32_t block_order = 0; uint64_t block_count = 0; uint32_t clean_entry_bitmap_size = 0, clean_entry_size = 0, clean_dyn_size = 0; diff --git a/src/blockstore/blockstore_flush.cpp b/src/blockstore/blockstore_flush.cpp index 293ba2f0..633c4175 100644 --- a/src/blockstore/blockstore_flush.cpp +++ b/src/blockstore/blockstore_flush.cpp @@ -542,7 +542,7 @@ resume_2: if (old_entry->oid.inode != 0 && old_entry->oid != cur.oid) { printf("Fatal error (metadata corruption or bug): tried to wipe metadata entry %ju (%jx:%jx v%ju) as old location of %jx:%jx\n", - old_clean_loc >> bs->dsk.block_order, old_entry->oid.inode, old_entry->oid.stripe, + old_clean_loc / bs->dsk.data_block_size, old_entry->oid.inode, old_entry->oid.stripe, old_entry->version, cur.oid.inode, cur.oid.stripe); exit(1); } @@ -645,7 +645,7 @@ void journal_flusher_co::update_metadata_entry() has_delete ? "Fatal error (metadata corruption or bug): tried to delete metadata entry %ju (%jx:%jx v%ju) while deleting %jx:%jx v%ju\n" : "Fatal error (metadata corruption or bug): tried to overwrite non-zero metadata entry %ju (%jx:%jx v%ju) with %jx:%jx v%ju\n", - clean_loc >> bs->dsk.block_order, new_entry->oid.inode, new_entry->oid.stripe, + clean_loc / bs->dsk.data_block_size, new_entry->oid.inode, new_entry->oid.stripe, new_entry->version, cur.oid.inode, cur.oid.stripe, cur.version ); exit(1); @@ -695,7 +695,7 @@ void journal_flusher_co::update_metadata_entry() new_entry->version = cur.version; if (!bs->inmemory_meta) { - auto inmem_bmp = (uint8_t*)bs->clean_bitmaps + (clean_loc >> bs->dsk.block_order)*2*bs->dsk.clean_entry_bitmap_size; + auto inmem_bmp = (uint8_t*)bs->clean_bitmaps + (clean_loc / bs->dsk.data_block_size)*2*bs->dsk.clean_entry_bitmap_size; memcpy(inmem_bmp, new_clean_bitmap, 2*bs->dsk.clean_entry_bitmap_size); } if (bs->dsk.meta_format >= BLOCKSTORE_META_FORMAT_V2) @@ -848,7 +848,7 @@ bool journal_flusher_co::clear_incomplete_csum_block_bits(int wait_base) { printf( "Fatal error (metadata corruption or bug): tried to make holes in %ju (%jx:%jx v%ju) with %jx:%jx v%ju\n", - clean_loc >> bs->dsk.block_order, new_entry->oid.inode, new_entry->oid.stripe, + clean_loc / bs->dsk.data_block_size, new_entry->oid.inode, new_entry->oid.stripe, new_entry->version, cur.oid.inode, cur.oid.stripe, cur.version ); } @@ -864,7 +864,7 @@ bool journal_flusher_co::clear_incomplete_csum_block_bits(int wait_base) calc_block_checksums(new_data_csums, true); if (!bs->inmemory_meta) { - auto inmem_bmp = (uint8_t*)bs->clean_bitmaps + (clean_loc >> bs->dsk.block_order)*2*bs->dsk.clean_entry_bitmap_size; + auto inmem_bmp = (uint8_t*)bs->clean_bitmaps + (clean_loc / bs->dsk.data_block_size)*2*bs->dsk.clean_entry_bitmap_size; memcpy(inmem_bmp, new_clean_bitmap, 2*bs->dsk.clean_entry_bitmap_size); } if (bs->dsk.meta_format >= BLOCKSTORE_META_FORMAT_V2) @@ -1231,8 +1231,8 @@ bool journal_flusher_co::modify_meta_read(uint64_t meta_loc, flusher_meta_write_ // And yet another option is to use LSM trees for metadata, but it sophisticates everything a lot, // so I'll avoid it as long as I can. wr.submitted = false; - wr.sector = ((meta_loc >> bs->dsk.block_order) / (bs->dsk.meta_block_size / bs->dsk.clean_entry_size)) * bs->dsk.meta_block_size; - wr.pos = ((meta_loc >> bs->dsk.block_order) % (bs->dsk.meta_block_size / bs->dsk.clean_entry_size)); + wr.sector = ((meta_loc / bs->dsk.data_block_size) / (bs->dsk.meta_block_size / bs->dsk.clean_entry_size)) * bs->dsk.meta_block_size; + wr.pos = ((meta_loc / bs->dsk.data_block_size) % (bs->dsk.meta_block_size / bs->dsk.clean_entry_size)); if (bs->inmemory_meta) { wr.buf = (uint8_t*)bs->metadata_buffer + wr.sector; @@ -1292,14 +1292,14 @@ void journal_flusher_co::free_data_blocks() #ifdef BLOCKSTORE_DEBUG printf("%s block %ju from %jx:%jx v%ju (new location is %ju)\n", used ? "Postpone free" : "Free", - old_clean_loc >> bs->dsk.block_order, + old_clean_loc / bs->dsk.data_block_size, cur.oid.inode, cur.oid.stripe, cur.version, - clean_loc >> bs->dsk.block_order); + clean_loc / bs->dsk.data_block_size); #endif if (used) uo_it->second.was_freed = true; else - bs->data_alloc->set(old_clean_loc >> bs->dsk.block_order, false); + bs->data_alloc->set(old_clean_loc / bs->dsk.data_block_size, false); } if (has_delete) { @@ -1309,13 +1309,13 @@ void journal_flusher_co::free_data_blocks() #ifdef BLOCKSTORE_DEBUG printf("%s block %ju from %jx:%jx v%ju (delete)\n", used ? "Postpone free" : "Free", - old_clean_loc >> bs->dsk.block_order, + old_clean_loc / bs->dsk.data_block_size, cur.oid.inode, cur.oid.stripe, cur.version); #endif if (used) uo_it->second.was_freed = true; else - bs->data_alloc->set(old_clean_loc >> bs->dsk.block_order, false); + bs->data_alloc->set(old_clean_loc / bs->dsk.data_block_size, false); } } diff --git a/src/blockstore/blockstore_init.cpp b/src/blockstore/blockstore_init.cpp index 703c1f47..31c0c0c3 100644 --- a/src/blockstore/blockstore_init.cpp +++ b/src/blockstore/blockstore_init.cpp @@ -372,7 +372,7 @@ bool blockstore_init_meta::handle_meta_block(uint8_t *buf, uint64_t entries_per_ // free the previous block // here we have to zero out the previous entry because otherwise we'll hit // "tried to overwrite non-zero metadata entry" later - uint64_t old_clean_loc = clean_it->second.location >> bs->dsk.block_order; + uint64_t old_clean_loc = clean_it->second.location / bs->dsk.data_block_size; if (bs->inmemory_meta) { uint64_t sector = (old_clean_loc / entries_per_block) * bs->dsk.meta_block_size; @@ -390,7 +390,7 @@ bool blockstore_init_meta::handle_meta_block(uint8_t *buf, uint64_t entries_per_ } else { - entries_to_zero.push_back(clean_it->second.location >> bs->dsk.block_order); + entries_to_zero.push_back(clean_it->second.location / bs->dsk.data_block_size); } #ifdef BLOCKSTORE_DEBUG printf("Free block %ju from %jx:%jx v%ju (new location is %ju)\n", @@ -412,7 +412,7 @@ bool blockstore_init_meta::handle_meta_block(uint8_t *buf, uint64_t entries_per_ bs->data_alloc->set(done_cnt+i, true); clean_db[entry->oid] = (struct clean_entry){ .version = entry->version, - .location = (done_cnt+i) << bs->dsk.block_order, + .location = (done_cnt+i) * bs->dsk.data_block_size, }; } else @@ -1001,7 +1001,7 @@ int blockstore_init_journal::handle_journal_part(void *buf, uint64_t done_pos, u printf( "je_big_write%s oid=%jx:%jx ver=%ju loc=%ju\n", je->type == JE_BIG_WRITE_INSTANT ? "_instant" : "", - je->big_write.oid.inode, je->big_write.oid.stripe, je->big_write.version, je->big_write.location >> bs->dsk.block_order + je->big_write.oid.inode, je->big_write.oid.stripe, je->big_write.version, je->big_write.location / bs->dsk.data_block_size ); #endif auto dirty_it = bs->dirty_db.upper_bound((obj_ver_id){ @@ -1064,7 +1064,7 @@ int blockstore_init_journal::handle_journal_part(void *buf, uint64_t done_pos, u .journal_sector = proc_pos, .dyn_data = dyn, }).first; - if (bs->data_alloc->get(je->big_write.location >> bs->dsk.block_order)) + if (bs->data_alloc->get(je->big_write.location / bs->dsk.data_block_size)) { // This is probably a big_write that's already flushed and freed, but it may // also indicate a bug. So we remember such entries and recheck them afterwards. @@ -1077,11 +1077,11 @@ int blockstore_init_journal::handle_journal_part(void *buf, uint64_t done_pos, u #ifdef BLOCKSTORE_DEBUG printf( "Allocate block (journal) %ju: %jx:%jx v%ju\n", - je->big_write.location >> bs->dsk.block_order, + je->big_write.location / bs->dsk.data_block_size, ov.oid.inode, ov.oid.stripe, ov.version ); #endif - bs->data_alloc->set(je->big_write.location >> bs->dsk.block_order, true); + bs->data_alloc->set(je->big_write.location / bs->dsk.data_block_size, true); } bs->journal.used_sectors[proc_pos]++; #ifdef BLOCKSTORE_DEBUG diff --git a/src/blockstore/blockstore_read.cpp b/src/blockstore/blockstore_read.cpp index 15d6e091..fdd6ef06 100644 --- a/src/blockstore/blockstore_read.cpp +++ b/src/blockstore/blockstore_read.cpp @@ -151,7 +151,7 @@ int blockstore_impl_t::fulfill_read(blockstore_op_t *read_op, uint8_t* blockstore_impl_t::get_clean_entry_bitmap(uint64_t block_loc, int offset) { uint8_t *clean_entry_bitmap; - uint64_t meta_loc = block_loc >> dsk.block_order; + uint64_t meta_loc = block_loc / dsk.data_block_size; if (inmemory_meta) { uint64_t sector = (meta_loc / (dsk.meta_block_size / dsk.clean_entry_size)) * dsk.meta_block_size; @@ -691,8 +691,8 @@ bool blockstore_impl_t::fulfill_clean_read(blockstore_op_t *read_op, uint64_t & uint8_t* blockstore_impl_t::read_clean_meta_block(blockstore_op_t *op, uint64_t clean_loc, int rv_pos) { auto & rv = PRIV(op)->read_vec; - auto sector = ((clean_loc >> dsk.block_order) / (dsk.meta_block_size / dsk.clean_entry_size)) * dsk.meta_block_size; - auto pos = ((clean_loc >> dsk.block_order) % (dsk.meta_block_size / dsk.clean_entry_size)) * dsk.clean_entry_size; + auto sector = ((clean_loc / dsk.data_block_size) / (dsk.meta_block_size / dsk.clean_entry_size)) * dsk.meta_block_size; + auto pos = ((clean_loc / dsk.data_block_size) % (dsk.meta_block_size / dsk.clean_entry_size)) * dsk.clean_entry_size; uint8_t *buf = (uint8_t*)memalign_or_die(MEM_ALIGNMENT, dsk.meta_block_size); rv.insert(rv.begin()+rv_pos, (copy_buffer_t){ .copy_flags = COPY_BUF_META_BLOCK|COPY_BUF_CSUM_FILL, @@ -806,7 +806,7 @@ bool blockstore_impl_t::verify_clean_padded_checksums(blockstore_op_t *op, uint6 uint32_t offset = clean_loc % dsk.data_block_size; if (from_journal) return verify_padded_checksums(dyn_data, dyn_data + dsk.clean_entry_bitmap_size, offset, iov, n_iov, bad_block_cb); - clean_loc = (clean_loc >> dsk.block_order) << dsk.block_order; + clean_loc = (clean_loc / dsk.data_block_size) * dsk.data_block_size; if (!dyn_data) { assert(inmemory_meta); @@ -866,7 +866,7 @@ void blockstore_impl_t::handle_read_event(ring_data_t *data, blockstore_op_t *op { // BIG_WRITE from journal or clean data // Do not verify checksums if the data location is/was mutated by flushers - auto & uo = used_clean_objects.at((rv[i].disk_offset >> dsk.block_order) << dsk.block_order); + auto & uo = used_clean_objects.at((rv[i].disk_offset / dsk.data_block_size) * dsk.data_block_size); if (!uo.was_changed) { verify_clean_padded_checksums( diff --git a/src/blockstore/blockstore_rollback.cpp b/src/blockstore/blockstore_rollback.cpp index fed4a07b..a9621d7b 100644 --- a/src/blockstore/blockstore_rollback.cpp +++ b/src/blockstore/blockstore_rollback.cpp @@ -210,10 +210,10 @@ void blockstore_impl_t::erase_dirty(blockstore_dirty_db_t::iterator dirty_start, dirty_it->second.location != UINT64_MAX) { #ifdef BLOCKSTORE_DEBUG - printf("Free block %ju from %jx:%jx v%ju\n", dirty_it->second.location >> dsk.block_order, + printf("Free block %ju from %jx:%jx v%ju\n", dirty_it->second.location / dsk.data_block_size, dirty_it->first.oid.inode, dirty_it->first.oid.stripe, dirty_it->first.version); #endif - data_alloc->set(dirty_it->second.location >> dsk.block_order, false); + data_alloc->set(dirty_it->second.location / dsk.data_block_size, false); } auto used = --journal.used_sectors.at(dirty_it->second.journal_sector); #ifdef BLOCKSTORE_DEBUG diff --git a/src/blockstore/blockstore_write.cpp b/src/blockstore/blockstore_write.cpp index 9eac8c97..26322394 100644 --- a/src/blockstore/blockstore_write.cpp +++ b/src/blockstore/blockstore_write.cpp @@ -340,7 +340,7 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op) } BS_SUBMIT_GET_SQE(sqe, data); write_iodepth++; - dirty_it->second.location = loc << dsk.block_order; + dirty_it->second.location = loc * dsk.data_block_size; dirty_it->second.state = (dirty_it->second.state & ~BS_ST_WORKFLOW_MASK) | BS_ST_SUBMITTED; #ifdef BLOCKSTORE_DEBUG printf( @@ -366,7 +366,7 @@ int blockstore_impl_t::dequeue_write(blockstore_op_t *op) data->iov.iov_len = op->len + stripe_offset + stripe_end; // to check it in the callback data->callback = [this, op](ring_data_t *data) { handle_write_event(data, op); }; io_uring_prep_writev( - sqe, dsk.data_fd, PRIV(op)->iov_zerofill, vcnt, dsk.data_offset + (loc << dsk.block_order) + op->offset - stripe_offset + sqe, dsk.data_fd, PRIV(op)->iov_zerofill, vcnt, dsk.data_offset + (loc * dsk.data_block_size) + op->offset - stripe_offset ); PRIV(op)->pending_ops = 1; if (!(dirty_it->second.state & BS_ST_INSTANT))