Remove block_order and replace << >> by / * data_block_size

src/blockstore/blockstore_disk.cpp

@@ -95,7 +95,7 @@ void blockstore_disk_t::parse_config(std::map<std::string, std::string> & 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");
     }

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;
 

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.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.block_order) % (bs->dsk.meta_block_size / bs->dsk.clean_entry_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);
     }
 }
 

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

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 sector = ((clean_loc / dsk.data_block_size) / (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 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(

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

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))