crimson/os/seastore: convert offset/length in segment logs to hex format

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>

diff --git a/src/crimson/os/seastore/journal/record_submitter.cc b/src/crimson/os/seastore/journal/record_submitter.cc
index adf8251b8a7c2acfb44e60023f6816ebf11a306b..4976eee96e714a6d6a4b69f0bbe8ee2e350ffcf2 100644 (file)
--- a/src/crimson/os/seastore/journal/record_submitter.cc
+++ b/src/crimson/os/seastore/journal/record_submitter.cc
@@ -24,7 +24,7 @@ RecordBatch::add_pending(
   LOG_PREFIX(RecordBatch::add_pending);
   auto new_size = get_encoded_length_after(record, block_size);
   auto dlength_offset = pending.size.dlength;
-  TRACE("{} batches={}, write_size={}, dlength_offset={} ...",
+  TRACE("{} batches={}, write_size=0x{:x}, dlength_offset=0x{:x} ...",
         name,
         pending.get_size() + 1,
         new_size.get_encoded_length(),
@@ -144,7 +144,7 @@ RecordSubmitter::RecordSubmitter(
     batches(new RecordBatch[io_depth + 1])
 {
   LOG_PREFIX(RecordSubmitter);
-  INFO("{} io_depth_limit={}, batch_capacity={}, batch_flush_size={}, "
+  INFO("{} io_depth_limit={}, batch_capacity={}, batch_flush_size=0x{:x}, "
        "preferred_fullness={}",
        get_name(), io_depth, batch_capacity,
        batch_flush_size, preferred_fullness);

diff --git a/src/crimson/os/seastore/journal/segment_allocator.cc b/src/crimson/os/seastore/journal/segment_allocator.cc
index 11f3cc8fd319ee0797c3e1ba64d0e4e1e4a4d20a..5405662b91e5dc97a6658197a641242f7ffd09c8 100644 (file)
--- a/src/crimson/os/seastore/journal/segment_allocator.cc
+++ b/src/crimson/os/seastore/journal/segment_allocator.cc
@@ -189,7 +189,7 @@ SegmentAllocator::write(ceph::bufferlist&& to_write)
   auto write_length = to_write.length();
   auto write_start_offset = written_to;
   if (unlikely(LOCAL_LOGGER.is_enabled(seastar::log_level::trace))) {
-    TRACE("{} {}~{}", print_name, get_written_to(), write_length);
+    TRACE("{} {}~0x{:x}", print_name, get_written_to(), write_length);
   }
   assert(write_length > 0);
   assert((write_length % get_block_size()) == 0);
@@ -250,7 +250,7 @@ SegmentAllocator::close_segment()
     close_seg_info.num_extents};
   ceph::bufferlist bl;
   encode(tail, bl);
-  INFO("{} close segment {}, written_to={}",
+  INFO("{} close segment {}, written_to=0x{:x}",
        print_name,
        tail,
        written_to);

diff --git a/src/crimson/os/seastore/journal/segmented_journal.cc b/src/crimson/os/seastore/journal/segmented_journal.cc
index eca45f113c25c2f18c4f9c445346d8246d965964..6be2ad4936a0ae477b104bc16034273cecda3643 100644 (file)
--- a/src/crimson/os/seastore/journal/segmented_journal.cc
+++ b/src/crimson/os/seastore/journal/segmented_journal.cc
@@ -424,7 +424,7 @@ SegmentedJournal::submit_record(
   ).get_encoded_length();
   auto max_record_length = journal_segment_allocator.get_max_write_length();
   if (expected_size > max_record_length) {
-    ERROR("H{} {} exceeds max record size {}",
+    ERROR("H{} {} exceeds max record size 0x{:x}",
           (void*)&handle, record, max_record_length);
     return crimson::ct_error::erange::make();
   }

diff --git a/src/crimson/os/seastore/segment_manager.cc b/src/crimson/os/seastore/segment_manager.cc
index 1be9cce5f6bf6867e59d446b17399c872410b177..3eced41081e799c37f96cd6e9119c1898512927e 100644 (file)
--- a/src/crimson/os/seastore/segment_manager.cc
+++ b/src/crimson/os/seastore/segment_manager.cc
@@ -16,10 +16,10 @@ namespace crimson::os::seastore {
 std::ostream& operator<<(std::ostream& out, const block_shard_info_t& sf)
 {
   out << "("
-      << "size=" << sf.size
-      << ", segments=" <<sf.segments
-      << ", tracker_offset=" <<sf.tracker_offset
-      << ", first_segment_offset=" <<sf.first_segment_offset
+      << "size=0x" << std::hex << sf.size << std::dec
+      << ", segments=" << sf.segments
+      << ", tracker_offset=0x" << std::hex << sf.tracker_offset
+      << ", first_segment_offset=0x" << sf.first_segment_offset << std::dec
       <<")";
   return out;
 }
@@ -28,8 +28,8 @@ std::ostream& operator<<(std::ostream& out, const block_sm_superblock_t& sb)
 {
   out << "superblock("
       << "shard_num=" << sb.shard_num
-      << ", segment_size=" << sb.segment_size
-      << ", block_size=" << sb.block_size
+      << ", segment_size=0x" << std::hex << sb.segment_size
+      << ", block_size=0x" << sb.block_size << std::dec
       << ", shard_info:";
   for (auto &sf : sb.shard_infos) {
     out << sf

diff --git a/src/crimson/os/seastore/segment_manager/block.cc b/src/crimson/os/seastore/segment_manager/block.cc
index 0500271f81a6887fed5230ffb4b828bea04e45b2..7077aad7407065b249bfe73e409bb6e4c0fc9e70 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/block.cc
+++ b/src/crimson/os/seastore/segment_manager/block.cc
@@ -60,7 +60,7 @@ static write_ertr::future<> do_write(
 {
   LOG_PREFIX(block_do_write);
   auto len = bptr.length();
-  TRACE("{} poffset={}~{} ...",
+  TRACE("{} poffset=0x{:x}~0x{:x} ...",
         device_id_printer_t{device_id}, offset, len);
   return device.dma_write(
     offset,
@@ -68,16 +68,16 @@ static write_ertr::future<> do_write(
     len
   ).handle_exception(
     [FNAME, device_id, offset, len](auto e) -> write_ertr::future<size_t> {
-    ERROR("{} poffset={}~{} got error -- {}",
+    ERROR("{} poffset=0x{:x}~0x{:x} got error -- {}",
           device_id_printer_t{device_id}, offset, len, e);
     return crimson::ct_error::input_output_error::make();
   }).then([FNAME, device_id, offset, len](auto result) -> write_ertr::future<> {
     if (result != len) {
-      ERROR("{} poffset={}~{} write len={} inconsistent",
+      ERROR("{} poffset=0x{:x}~0x{:x} write len=0x{:x} inconsistent",
             device_id_printer_t{device_id}, offset, len, result);
       return crimson::ct_error::input_output_error::make();
     }
-    TRACE("{} poffset={}~{} done", device_id_printer_t{device_id}, offset, len);
+    TRACE("{} poffset=0x{:x}~0x{:x} done", device_id_printer_t{device_id}, offset, len);
     return write_ertr::now();
   });
 }
@@ -90,7 +90,7 @@ static write_ertr::future<> do_writev(
   size_t block_size)
 {
   LOG_PREFIX(block_do_writev);
-  TRACE("{} poffset={}~{}, {} buffers",
+  TRACE("{} poffset=0x{:x}~0x{:x}, {} buffers",
         device_id_printer_t{device_id}, offset, bl.length(), bl.get_num_buffers());
 
   // writev requires each buffer to be aligned to the disks' block
@@ -109,22 +109,22 @@ static write_ertr::future<> do_writev(
       auto off = offset + p.offset;
       auto len = p.length;
       auto& iov = p.iov;
-      TRACE("{} poffset={}~{} dma_write ...",
+      TRACE("{} poffset=0x{:x}~0x{:x} dma_write ...",
             device_id_printer_t{device_id}, off, len);
       return device.dma_write(off, std::move(iov)
       ).handle_exception(
         [FNAME, device_id, off, len](auto e) -> write_ertr::future<size_t>
       {
-        ERROR("{} poffset={}~{} dma_write got error -- {}",
+        ERROR("{} poffset=0x{:x}~0x{:x} dma_write got error -- {}",
               device_id_printer_t{device_id}, off, len, e);
        return crimson::ct_error::input_output_error::make();
       }).then([FNAME, device_id, off, len](size_t written) -> write_ertr::future<> {
        if (written != len) {
-          ERROR("{} poffset={}~{} dma_write len={} inconsistent",
+          ERROR("{} poffset=0x{:x}~0x{:x} dma_write len=0x{:x} inconsistent",
                 device_id_printer_t{device_id}, off, len, written);
          return crimson::ct_error::input_output_error::make();
        }
-        TRACE("{} poffset={}~{} dma_write done",
+        TRACE("{} poffset=0x{:x}~0x{:x} dma_write done",
               device_id_printer_t{device_id}, off, len);
        return write_ertr::now();
       });
@@ -140,7 +140,7 @@ static read_ertr::future<> do_read(
   bufferptr &bptr)
 {
   LOG_PREFIX(block_do_read);
-  TRACE("{} poffset={}~{} ...", device_id_printer_t{device_id}, offset, len);
+  TRACE("{} poffset=0x{:x}~0x{:x} ...", device_id_printer_t{device_id}, offset, len);
   assert(len <= bptr.length());
   return device.dma_read(
     offset,
@@ -153,16 +153,16 @@ static read_ertr::future<> do_read(
     // once seastar::future<T>::handle_exception() returns seastar::futurize_t<T>
     [FNAME, device_id, offset, len](auto e) -> read_ertr::future<size_t>
   {
-    ERROR("{} poffset={}~{} got error -- {}",
+    ERROR("{} poffset=0x{:x}~0x{:x} got error -- {}",
           device_id_printer_t{device_id}, offset, len, e);
     return crimson::ct_error::input_output_error::make();
   }).then([FNAME, device_id, offset, len](auto result) -> read_ertr::future<> {
     if (result != len) {
-      ERROR("{} poffset={}~{} read len={} inconsistent",
+      ERROR("{} poffset=0x{:x}~0x{:x} read len=0x{:x} inconsistent",
             device_id_printer_t{device_id}, offset, len, result);
       return crimson::ct_error::input_output_error::make();
     }
-    TRACE("{} poffset={}~{} done", device_id_printer_t{device_id}, offset, len);
+    TRACE("{} poffset=0x{:x}~0x{:x} done", device_id_printer_t{device_id}, offset, len);
     return read_ertr::now();
   });
 }
@@ -174,7 +174,7 @@ SegmentStateTracker::write_out(
   uint64_t offset)
 {
   LOG_PREFIX(SegmentStateTracker::write_out);
-  DEBUG("{} poffset={}~{}",
+  DEBUG("{} poffset=0x{:x}~0x{:x}",
         device_id_printer_t{device_id}, offset, bptr.length());
   return do_write(device_id, device, offset, bptr);
 }
@@ -186,7 +186,7 @@ SegmentStateTracker::read_in(
   uint64_t offset)
 {
   LOG_PREFIX(SegmentStateTracker::read_in);
-  DEBUG("{} poffset={}~{}",
+  DEBUG("{} poffset=0x{:x}~0x{:x}",
         device_id_printer_t{device_id}, offset, bptr.length());
   return do_read(
     device_id,
@@ -230,7 +230,7 @@ block_sm_superblock_t make_superblock(
                              + i * segments_per_shard * config_segment_size;
   }
 
-  INFO("{} disk_size={}, segment_size={}, block_size={}",
+  INFO("{} disk_size=0x{:x}, segment_size=0x{:x}, block_size=0x{:x}",
        device_id_printer_t{device_id},
        size,
        uint64_t(config_segment_size),
@@ -255,7 +255,7 @@ static check_create_device_ret check_create_device(
   size_t size)
 {
   LOG_PREFIX(block_check_create_device);
-  INFO("path={}, size={}", path, size);
+  INFO("path={}, size=0x{:x}", path, size);
   return seastar::open_file_dma(
     path,
     seastar::open_flags::exclusive |
@@ -266,7 +266,7 @@ static check_create_device_ret check_create_device(
       file,
       [size, FNAME, &path](auto &f) -> seastar::future<>
     {
-      DEBUG("path={} created, truncating to {}", path, size);
+      DEBUG("path={} created, truncating to 0x{:x}", path, size);
       ceph_assert(f);
       return f.truncate(
         size
@@ -318,8 +318,8 @@ open_device_ret open_device(
     ).then([stat, &path, FNAME](auto file) mutable {
       return file.size().then([stat, file, &path, FNAME](auto size) mutable {
         stat.size = size;
-        INFO("path={} successful, size={}, block_size={}", 
-        path, stat.size, stat.block_size);
+        INFO("path={} successful, size=0x{:x}, block_size=0x{:x}",
+             path, stat.size, stat.block_size);
         return std::make_pair(file, stat);
       });
     });
@@ -410,19 +410,19 @@ Segment::write_ertr::future<> BlockSegment::write(
 {
   LOG_PREFIX(BlockSegment::write);
   auto paddr = paddr_t::make_seg_paddr(id, offset);
-  DEBUG("{} offset={}~{} poffset={} ...",
+  DEBUG("{} offset=0x{:x}~0x{:x} poffset=0x{:x} ...",
         id, offset, bl.length(), manager.get_offset(paddr));
 
   if (offset < write_pointer ||
       offset % manager.superblock.block_size != 0 ||
       bl.length() % manager.superblock.block_size != 0) {
-    ERROR("{} offset={}~{} poffset={} invalid write",
+    ERROR("{} offset=0x{:x}~0x{:x} poffset=0x{:x} invalid write",
           id, offset, bl.length(), manager.get_offset(paddr));
     return crimson::ct_error::invarg::make();
   }
 
   if (offset + bl.length() > manager.superblock.segment_size) {
-    ERROR("{} offset={}~{} poffset={} write out of the range {}",
+    ERROR("{} offset=0x{:x}~0x{:x} poffset=0x{:x} write out of the range 0x{:x}",
           id, offset, bl.length(), manager.get_offset(paddr),
           manager.superblock.segment_size);
     return crimson::ct_error::enospc::make();
@@ -443,7 +443,7 @@ Segment::close_ertr::future<> BlockSegmentManager::segment_close(
   LOG_PREFIX(BlockSegmentManager::segment_close);
   auto s_id = id.device_segment_id();
   int unused_bytes = get_segment_size() - write_pointer;
-  INFO("{} unused_bytes={} ...", id, unused_bytes);
+  INFO("{} unused_bytes=0x{:x} ...", id, unused_bytes);
 
   assert(unused_bytes >= 0);
   assert(id.device_id() == get_device_id());
@@ -693,24 +693,24 @@ SegmentManager::read_ertr::future<> BlockSegmentManager::read(
   auto s_id = id.device_segment_id();
   auto s_off = seg_addr.get_segment_off();
   auto p_off = get_offset(addr);
-  DEBUG("{} offset={}~{} poffset={} ...", id, s_off, len, p_off);
+  DEBUG("{} offset=0x{:x}~0x{:x} poffset=0x{:x} ...", id, s_off, len, p_off);
 
   assert(addr.get_device_id() == get_device_id());
 
   if (s_off % superblock.block_size != 0 ||
       len % superblock.block_size != 0) {
-    ERROR("{} offset={}~{} poffset={} invalid read", id, s_off, len, p_off);
+    ERROR("{} offset=0x{:x}~0x{:x} poffset=0x{:x} invalid read", id, s_off, len, p_off);
     return crimson::ct_error::invarg::make();
   }
 
   if (s_id >= get_num_segments()) {
-    ERROR("{} offset={}~{} poffset={} segment-id out of range {}",
+    ERROR("{} offset=0x{:x}~0x{:x} poffset=0x{:x} segment-id out of range {}",
           id, s_off, len, p_off, get_num_segments());
     return crimson::ct_error::invarg::make();
   }
 
   if (s_off + len > superblock.segment_size) {
-    ERROR("{} offset={}~{} poffset={} read out of range {}",
+    ERROR("{} offset=0x{:x}~0x{:x} poffset=0x{:x} read out of range 0x{:x}",
           id, s_off, len, p_off, superblock.segment_size);
     return crimson::ct_error::invarg::make();
   }
@@ -718,7 +718,7 @@ SegmentManager::read_ertr::future<> BlockSegmentManager::read(
   if (tracker->get(s_id) == segment_state_t::EMPTY) {
     // XXX: not an error during scanning,
     // might need refactor to increase the log level
-    DEBUG("{} offset={}~{} poffset={} invalid state {}",
+    DEBUG("{} offset=0x{:x}~0x{:x} poffset=0x{:x} invalid state {}",
           id, s_off, len, p_off, tracker->get(s_id));
     return crimson::ct_error::enoent::make();
   }

diff --git a/src/crimson/os/seastore/segment_manager/ephemeral.cc b/src/crimson/os/seastore/segment_manager/ephemeral.cc
index 4a4873afb94d9665135c919f1bd3756c6dc74895..bdd97e88733de2c6a929e5c28607d09a7f1e97ce 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/ephemeral.cc
+++ b/src/crimson/os/seastore/segment_manager/ephemeral.cc
@@ -20,8 +20,11 @@ namespace {
 namespace crimson::os::seastore::segment_manager {
 
 std::ostream &operator<<(std::ostream &lhs, const ephemeral_config_t &c) {
-  return lhs << "ephemeral_config_t(size=" << c.size << ", block_size=" << c.block_size
-            << ", segment_size=" << c.segment_size << ")";
+  return lhs << "ephemeral_config_t(size=0x"
+             << std::hex << c.size
+             << ", block_size=0x" << c.block_size
+             << ", segment_size=0x" << c.segment_size
+             << std::dec << ")";
 }
 
 EphemeralSegmentManagerRef create_test_ephemeral() {
@@ -141,7 +144,8 @@ Segment::write_ertr::future<> EphemeralSegmentManager::segment_write(
 {
   auto& seg_addr = addr.as_seg_paddr();
   logger().debug(
-    "segment_write to segment {} at offset {}, physical offset {}, len {}, crc {}",
+    "segment_write to segment {} at offset 0x{:x}, "
+    "physical offset 0x{:x}, len 0x{:x}, crc 0x{:x}",
     seg_addr.get_segment_id(),
     seg_addr.get_segment_off(),
     get_offset(addr),
@@ -268,7 +272,7 @@ SegmentManager::read_ertr::future<> EphemeralSegmentManager::read(
 
   if (seg_addr.get_segment_off() + len > config.segment_size) {
     logger().error(
-      "EphemeralSegmentManager::read: invalid offset {}~{}!",
+      "EphemeralSegmentManager::read: invalid offset {}~0x{:x}!",
       addr,
       len);
     return crimson::ct_error::invarg::make();
@@ -279,7 +283,8 @@ SegmentManager::read_ertr::future<> EphemeralSegmentManager::read(
   bufferlist bl;
   bl.push_back(out);
   logger().debug(
-    "segment_read to segment {} at offset {}, physical offset {}, length {}, crc {}",
+    "segment_read to segment {} at offset 0x{:x}, "
+    "physical offset 0x{:x}, length 0x{:x}, crc 0x{:x}",
     seg_addr.get_segment_id().device_segment_id(),
     seg_addr.get_segment_off(),
     get_offset(addr),

diff --git a/src/crimson/os/seastore/segment_manager/zbd.cc b/src/crimson/os/seastore/segment_manager/zbd.cc
index 88521a947f86463287b136c122e8bfe53e9c6afb..22efbed5940afc5d2b672a7c5b8726b582cc7e3d 100644 (file)
--- a/src/crimson/os/seastore/segment_manager/zbd.cc
+++ b/src/crimson/os/seastore/segment_manager/zbd.cc
@@ -56,7 +56,7 @@ static open_device_ret open_device(
     path, seastar::follow_symlink::yes
   ).then([FNAME, mode, &path](auto stat) mutable {
     return seastar::open_file_dma(path, mode).then([=](auto file) {
-       DEBUG("open of device {} successful, size {}",
+       DEBUG("open of device {} successful, size 0x{:x}",
         path,
         stat.size);
       return std::make_pair(file, stat);
@@ -100,11 +100,12 @@ static zbd_sm_metadata_t make_metadata(
 
   WARN("Ignoring configuration values for device and segment size");
   INFO(
-    "device size: {}, available size: {}, block size: {}, allocated size: {},"
-    " total zones {}, zone size: {}, zone capacity: {},"
-    " total segments: {}, zones per segment: {}, segment size: {}"
+    "device size: 0x{:x}, available size: 0x{:x},"
+    " block size: 0x{:x}, allocated size: 0x{:x},"
+    " total zones {}, zone size: 0x{:x}, zone capacity: 0x{:x},"
+    " total segments: {}, zones per segment: {}, segment size: 0x{:x}"
     " conv zones: {}, swr zones: {}, per shard segments: {}"
-    " per shard available size: {}",
+    " per shard available size: 0x{:x}",
     total_size,
     available_size,
     data.block_size,
@@ -126,8 +127,8 @@ static zbd_sm_metadata_t make_metadata(
     shard_infos[i].segments = per_shard_segments;
     shard_infos[i].first_segment_offset = zone_size * skipped_zones
       + i * segment_size * per_shard_segments;
-    INFO("First segment offset for shard {} is: {}",
-                   i, shard_infos[i].first_segment_offset);
+    INFO("First segment offset for shard {} is: 0x{:x}",
+         i, shard_infos[i].first_segment_offset);
   }
 
   zbd_sm_metadata_t ret = zbd_sm_metadata_t{
@@ -248,7 +249,7 @@ static write_ertr::future<> do_write(
   bufferptr &bptr)
 {
   LOG_PREFIX(ZBDSegmentManager::do_write);
-  DEBUG("offset {} len {}",
+  DEBUG("offset 0x{:x} len 0x{:x}",
     offset,
     bptr.length());
   return device.dma_write(
@@ -277,7 +278,7 @@ static write_ertr::future<> do_writev(
   size_t block_size)
 {
   LOG_PREFIX(ZBDSegmentManager::do_writev);
-  DEBUG("{} offset {} len {}",
+  DEBUG("{} offset 0x{:x} len 0x{:x}",
     device_id_printer_t{device_id}, offset, bl.length());
   // writev requires each buffer to be aligned to the disks' block
   // size, we need to rebuild here
@@ -295,23 +296,23 @@ static write_ertr::future<> do_writev(
       auto off = offset + p.offset;
       auto len = p.length;
       auto& iov = p.iov;
-      DEBUG("{} poffset={}~{} dma_write ...",
+      DEBUG("{} poffset=0x{:x}~0x{:x} dma_write ...",
            device_id_printer_t{device_id},
             off, len);
       return device.dma_write(off, std::move(iov)
       ).handle_exception(
         [FNAME, device_id, off, len](auto e) -> write_ertr::future<size_t>
       {
-        ERROR("{} poffset={}~{} dma_write got error -- {}",
+        ERROR("{} poffset=0x{:x}~0x{:x} dma_write got error -- {}",
              device_id_printer_t{device_id}, off, len, e);
         return crimson::ct_error::input_output_error::make();
       }).then([FNAME, device_id, off, len](size_t written) -> write_ertr::future<> {
         if (written != len) {
-          ERROR("{} poffset={}~{} dma_write len={} inconsistent",
+          ERROR("{} poffset=0x{:x}~0x{:x} dma_write len=0x{:x} inconsistent",
                device_id_printer_t{device_id}, off, len, written);
           return crimson::ct_error::input_output_error::make();
         }
-        DEBUG("{} poffset={}~{} dma_write done",
+        DEBUG("{} poffset=0x{:x}~0x{:x} dma_write done",
              device_id_printer_t{device_id},
               off, len);
         return write_ertr::now();
@@ -329,12 +330,12 @@ write_metadata(seastar::file &device, zbd_sm_metadata_t sb)
     bufferptr(ceph::buffer::create_page_aligned(sb.block_size)),
     [=, &device](auto &bp) {
       LOG_PREFIX(ZBDSegmentManager::write_metadata);
-      DEBUG("block_size {}", sb.block_size);
+      DEBUG("block_size 0x{:x}", sb.block_size);
       bufferlist bl;
       encode(sb, bl);
       auto iter = bl.begin();
       assert(bl.length() < sb.block_size);
-      DEBUG("buffer length {}", bl.length());
+      DEBUG("buffer length 0x{:x}", bl.length());
       iter.copy(bl.length(), bp.c_str());
       DEBUG("doing writeout");
       return do_write(device, 0, bp);
@@ -349,7 +350,7 @@ static read_ertr::future<> do_read(
 {
   LOG_PREFIX(ZBDSegmentManager::do_read);
   assert(len <= bptr.length());
-  DEBUG("offset {} len {}",
+  DEBUG("offset 0x{:x} len 0x{:x}",
     offset,
     len);
   return device.dma_read(
@@ -659,7 +660,7 @@ SegmentManager::read_ertr::future<> ZBDSegmentManager::read(
   }
   
   if (seg_addr.get_segment_off() + len > metadata.segment_capacity) {
-    ERROR("invalid read offset {}, len {}",
+    ERROR("invalid read offset {}, len 0x{:x}",
       addr,
       len);
     return crimson::ct_error::invarg::make();
@@ -703,7 +704,7 @@ Segment::write_ertr::future<> ZBDSegmentManager::segment_write(
   assert(addr.get_device_id() == get_device_id());
   assert((bl.length() % metadata.block_size) == 0);
   auto& seg_addr = addr.as_seg_paddr();
-  DEBUG("write to segment {} at offset {}, physical offset {}, len {}",
+  DEBUG("write to segment {} at offset 0x{:x}, physical offset 0x{:x}, len 0x{:x}",
     seg_addr.get_segment_id(),
     seg_addr.get_segment_off(),
     get_offset(addr),
@@ -756,7 +757,7 @@ Segment::write_ertr::future<> ZBDSegment::write(
   LOG_PREFIX(ZBDSegment::write);
   if (offset != write_pointer || offset % manager.metadata.block_size != 0) {
     ERROR("Segment offset and zone write pointer mismatch. "
-          "segment {} segment-offset {} write pointer {}",
+          "segment {} segment-offset 0x{:x} write pointer 0x{:x}",
           id, offset, write_pointer);
     return crimson::ct_error::invarg::make();
   }
@@ -772,7 +773,7 @@ Segment::write_ertr::future<> ZBDSegment::write_padding_bytes(
   size_t padding_bytes)
 {
   LOG_PREFIX(ZBDSegment::write_padding_bytes);
-  DEBUG("Writing {} padding bytes to segment {} at wp {}",
+  DEBUG("Writing 0x{:x} padding bytes to segment {} at wp 0x{:x}",
         padding_bytes, id, write_pointer);
 
   return crimson::repeat([FNAME, padding_bytes, this] () mutable {
@@ -804,7 +805,7 @@ Segment::write_ertr::future<> ZBDSegment::advance_wp(
 {
   LOG_PREFIX(ZBDSegment::advance_wp);
 
-  DEBUG("Advancing write pointer from {} to {}", write_pointer, offset);
+  DEBUG("Advancing write pointer from 0x{:x} to 0x{:x}", write_pointer, offset);
   if (offset < write_pointer) {
     return crimson::ct_error::invarg::make();
   }

diff --git a/src/crimson/os/seastore/segment_manager_group.cc b/src/crimson/os/seastore/segment_manager_group.cc
index 332b794b70ee2a43a0d8ff9a733c4fc428e5ed4e..f4822c9a18c5555939ff50815694ef462f9a46ee 100644 (file)
--- a/src/crimson/os/seastore/segment_manager_group.cc
+++ b/src/crimson/os/seastore/segment_manager_group.cc
@@ -26,13 +26,13 @@ SegmentManagerGroup::read_segment_tail(segment_id_t segment)
     }
   ).safe_then([=, &segment_manager](bufferptr bptr) -> read_segment_tail_ret {
     LOG_PREFIX(SegmentManagerGroup::read_segment_tail);
-    DEBUG("segment {} bptr size {}", segment, bptr.length());
+    DEBUG("segment {} bptr size 0x{:x}", segment, bptr.length());
 
     segment_tail_t tail;
     bufferlist bl;
     bl.push_back(bptr);
 
-    DEBUG("segment {} block crc {}",
+    DEBUG("segment {} block crc 0x{:x}",
           segment,
           bl.begin().crc32c(segment_manager.get_block_size(), 0));
 
@@ -66,13 +66,13 @@ SegmentManagerGroup::read_segment_header(segment_id_t segment)
     }
   ).safe_then([=, &segment_manager](bufferptr bptr) -> read_segment_header_ret {
     LOG_PREFIX(SegmentManagerGroup::read_segment_header);
-    DEBUG("segment {} bptr size {}", segment, bptr.length());
+    DEBUG("segment {} bptr size 0x{:x}", segment, bptr.length());
 
     segment_header_t header;
     bufferlist bl;
     bl.push_back(bptr);
 
-    DEBUG("segment {} block crc {}",
+    DEBUG("segment {} block crc 0x{:x}",
           segment,
           bl.begin().crc32c(segment_manager.get_block_size(), 0));
 
@@ -111,7 +111,7 @@ SegmentManagerGroup::read(paddr_t start, size_t len)
   LOG_PREFIX(SegmentManagerGroup::read);
   assert(has_device(start.get_device_id()));
   auto& segment_manager = *segment_managers[start.get_device_id()];
-  TRACE("reading data {}~{}", start, len);
+  TRACE("reading data {}~0x{:x}", start, len);
   return segment_manager.read(
     start,
     len