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

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

diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc
index 5046980eae56ceb7f6c94154fdd2139eb5b9999d..cecdb98553230ab3bb5cbfd687dd0c7bcce1de07 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.cc
+++ b/src/crimson/os/seastore/async_cleaner.cc
@@ -131,7 +131,7 @@ void segments_info_t::add_segment_manager(
   auto ssize = segment_manager.get_segment_size();
   auto nsegments = segment_manager.get_num_segments();
   auto sm_size = segment_manager.get_available_size();
-  INFO("adding segment manager {}, size={}, ssize={}, segments={}",
+  INFO("adding segment manager {}, size=0x{:x}, segment size=0x{:x}, segments={}",
        device_id_printer_t{d_id}, sm_size, ssize, nsegments);
   ceph_assert(ssize > 0);
   ceph_assert(nsegments > 0);
@@ -329,9 +329,9 @@ std::ostream &operator<<(std::ostream &os, const segments_info_t &infos)
             << ", closed=" << infos.get_num_closed()
             << ", type_journal=" << infos.get_num_type_journal()
             << ", type_ool=" << infos.get_num_type_ool()
-            << ", total=" << infos.get_total_bytes() << "B"
-            << ", available=" << infos.get_available_bytes() << "B"
-            << ", unavailable=" << infos.get_unavailable_bytes() << "B"
+            << ", total=0x" << std::hex << infos.get_total_bytes() << "B"
+            << ", available=0x" << infos.get_available_bytes() << "B"
+            << ", unavailable=0x" << infos.get_unavailable_bytes() << "B" << std::dec
             << ", available_ratio=" << infos.get_available_ratio()
             << ", submitted_head=" << infos.get_submitted_journal_head()
             << ", time_bound=" << sea_time_point_printer_t{infos.get_time_bound()}
@@ -765,10 +765,10 @@ int64_t SpaceTrackerDetailed::SegmentMap::allocate(
   for (auto i = b; i < e; ++i) {
     if (bitmap[i]) {
       if (!error) {
-        ERROR("found allocated in {}, {} ~ {}", segment, offset, len);
+        ERROR("found allocated in {}, 0x{:x}~0x{:x}", segment, offset, len);
        error = true;
       }
-      DEBUG("block {} allocated", i * block_size);
+      DEBUG("block 0x{:x}B allocated", i * block_size);
     }
     bitmap[i] = true;
   }
@@ -792,10 +792,10 @@ int64_t SpaceTrackerDetailed::SegmentMap::release(
   for (auto i = b; i < e; ++i) {
     if (!bitmap[i]) {
       if (!error) {
-       ERROR("found unallocated in {}, {} ~ {}", segment, offset, len);
+       ERROR("found unallocated in {}, 0x{:x}~0x{:x}", segment, offset, len);
        error = true;
       }
-      DEBUG("block {} unallocated", i * block_size);
+      DEBUG("block 0x{:x}B unallocated", i * block_size);
     }
     bitmap[i] = false;
   }
@@ -831,7 +831,7 @@ void SpaceTrackerDetailed::SegmentMap::dump_usage(extent_len_t block_size) const
   INFO("dump start");
   for (unsigned i = 0; i < bitmap.size(); ++i) {
     if (bitmap[i]) {
-      LOCAL_LOGGER.info("    {} still live", i * block_size);
+      LOCAL_LOGGER.info("    0x{:x}B still live", i * block_size);
     }
   }
 }
@@ -847,7 +847,7 @@ void SpaceTrackerDetailed::dump_usage(segment_id_t id) const
 void SpaceTrackerSimple::dump_usage(segment_id_t id) const
 {
   LOG_PREFIX(SpaceTrackerSimple::dump_usage);
-  INFO("id: {}, live_bytes: {}",
+  INFO("id: {}, live_bytes: 0x{:x}",
        id, live_bytes_by_segment[id].live_bytes);
 }
 
@@ -1165,7 +1165,7 @@ SegmentCleaner::do_reclaim_space(
            [this, &extents, &t](auto &ent)
          {
            LOG_PREFIX(SegmentCleaner::do_reclaim_space);
-           TRACET("getting extent of type {} at {}~{}",
+           TRACET("getting extent of type {} at {}~0x{:x}",
              t,
              ent.type,
              ent.paddr,
@@ -1568,7 +1568,7 @@ void SegmentCleaner::mark_space_used(
 
   background_callback->maybe_wake_background();
   assert(ret > 0);
-  DEBUG("segment {} new len: {}~{}, live_bytes: {}",
+  DEBUG("segment {} new len: {}~0x{:x}, live_bytes: 0x{:x}",
         seg_addr.get_segment_id(),
         addr,
         len,
@@ -1591,7 +1591,7 @@ void SegmentCleaner::mark_space_free(
   stats.used_bytes -= len;
   auto& seg_addr = addr.as_seg_paddr();
 
-  DEBUG("segment {} free len: {}~{}",
+  DEBUG("segment {} free len: {}~0x{:x}",
         seg_addr.get_segment_id(), addr, len);
   auto old_usage = calc_utilization(seg_addr.get_segment_id());
   [[maybe_unused]] auto ret = space_tracker->release(
@@ -1602,7 +1602,7 @@ void SegmentCleaner::mark_space_free(
   adjust_segment_util(old_usage, new_usage);
   background_callback->maybe_wake_blocked_io();
   assert(ret >= 0);
-  DEBUG("segment {} free len: {}~{}, live_bytes: {}",
+  DEBUG("segment {} free len: {}~0x{:x}, live_bytes: 0x{:x}",
         seg_addr.get_segment_id(),
         addr,
         len,
@@ -1687,11 +1687,11 @@ void SegmentCleaner::print(std::ostream &os, bool is_detailed) const
      << ", reclaim_ratio=" << get_reclaim_ratio()
      << ", alive_ratio=" << get_alive_ratio();
   if (is_detailed) {
-    os << ", unavailable_unreclaimable="
+    os << ", unavailable_unreclaimable=0x" << std::hex
        << get_unavailable_unreclaimable_bytes() << "B"
-       << ", unavailable_reclaimble="
+       << ", unavailable_reclaimble=0x"
        << get_unavailable_reclaimable_bytes() << "B"
-       << ", alive=" << stats.used_bytes << "B"
+       << ", alive=0x" << stats.used_bytes << "B" << std::dec
        << ", " << segments;
   }
   os << ")";
@@ -1722,7 +1722,7 @@ void RBMCleaner::mark_space_used(
   for (auto rbm : rbms) {
     if (addr.get_device_id() == rbm->get_device_id()) {
       if (rbm->get_start() <= addr) {
-       DEBUG("allocate addr: {} len: {}", addr, len);
+       DEBUG("allocate addr: {} len: 0x{:x}", addr, len);
        stats.used_bytes += len;
        rbm->mark_space_used(addr, len);
       }
@@ -1741,7 +1741,7 @@ void RBMCleaner::mark_space_free(
   for (auto rbm : rbms) {
     if (addr.get_device_id() == rbm->get_device_id()) {
       if (rbm->get_start() <= addr) {
-       DEBUG("free addr: {} len: {}", addr, len);
+       DEBUG("free addr: {} len: 0x{:x}", addr, len);
        ceph_assert(stats.used_bytes >= len);
        stats.used_bytes -= len;
        rbm->mark_space_free(addr, len);

diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc
index 254e3eb0da4ea2bccc758ea085cd7c51e1b056c6..cdd9c542d95e86ab9ba66efbfa0c63bdc4539396 100644 (file)
--- a/src/crimson/os/seastore/cache.cc
+++ b/src/crimson/os/seastore/cache.cc
@@ -30,7 +30,7 @@ namespace crimson::os::seastore {
 
 std::ostream &operator<<(std::ostream &out, const backref_entry_t &ent) {
   return out << "backref_entry_t{"
-            << ent.paddr << "~" << ent.len << ", "
+            << ent.paddr << "~0x" << std::hex << ent.len << std::dec << ", "
             << "laddr: " << ent.laddr << ", "
             << "type: " << ent.type << ", "
             << "seq: " << ent.seq << ", "
@@ -44,7 +44,7 @@ Cache::Cache(
          "seastore_cache_lru_size"))
 {
   LOG_PREFIX(Cache::Cache);
-  INFO("created, lru_capacity={}B", lru.get_capacity_bytes());
+  INFO("created, lru_capacity=0x{:x}B", lru.get_capacity_bytes());
   register_metrics();
   segment_providers_by_device_id.resize(DEVICE_ID_MAX, nullptr);
 }

diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h
index 520df473f2f64ac417271e7d69f70079a61d8556..07647f6c7cf557c66a1c6e52e542ea308cc066a4 100644 (file)
--- a/src/crimson/os/seastore/cache.h
+++ b/src/crimson/os/seastore/cache.h
@@ -1336,7 +1336,7 @@ public:
   {
     LOG_PREFIX(Cache::init_cached_extents);
     SUBINFOT(seastore_cache,
-        "start with {}({}B) extents, {} dirty, dirty_from={}, alloc_from={}",
+        "start with {}(0x{:x}B) extents, {} dirty, dirty_from={}, alloc_from={}",
         t,
         extents_index.size(),
         extents_index.get_bytes(),
@@ -1379,7 +1379,7 @@ public:
       }
     ).si_then([this, FNAME, &t] {
       SUBINFOT(seastore_cache,
-          "finish with {}({}B) extents, {} dirty, dirty_from={}, alloc_from={}",
+          "finish with {}(0x{:x}B) extents, {} dirty, dirty_from={}, alloc_from={}",
           t,
           extents_index.size(),
           extents_index.get_bytes(),

diff --git a/src/crimson/os/seastore/device.cc b/src/crimson/os/seastore/device.cc
index c3bda82a7f6f74ac3e775d390395cda9551caa69..cc83eb54826a6bfdf368ec36d26b55659e70e341 100644 (file)
--- a/src/crimson/os/seastore/device.cc
+++ b/src/crimson/os/seastore/device.cc
@@ -12,7 +12,7 @@ namespace crimson::os::seastore {
 std::ostream& operator<<(std::ostream& out, const device_spec_t& ds)
 {
   return out << "device_spec("
-             << "magic=" << ds.magic
+             << "magic=0x" << std::hex << ds.magic << std::dec
              << ", dtype=" << ds.dtype
              << ", " << device_id_printer_t{ds.id}
              << ")";

diff --git a/src/crimson/os/seastore/extent_placement_manager.cc b/src/crimson/os/seastore/extent_placement_manager.cc
index 0458fbfed748051ee16de3f7517ca0bdc62a9ca0..fd19eeb7e58eb40434ac84571d92d57fa136a2cd 100644 (file)
--- a/src/crimson/os/seastore/extent_placement_manager.cc
+++ b/src/crimson/os/seastore/extent_placement_manager.cc
@@ -1069,8 +1069,8 @@ RandomBlockOolWriter::do_write(
       w_info.bp = bp;
       writes.push_back(w_info);
     }
-    TRACE("current extent: base off {} len {},\
-      maybe-merged current extent: base off {} len {}",
+    TRACE("current extent: {}~0x{:x},\
+      maybe-merged current extent: {}~0x{:x}",
       paddr, ex->get_length(), writes.back().offset, writes.back().bp.length());
   }
 

diff --git a/src/crimson/os/seastore/extent_placement_manager.h b/src/crimson/os/seastore/extent_placement_manager.h
index 47fe71ae464f6404be9199a21e28cfd0c4f11fa8..4ff9729c5f4402d526778579a24b3890cddf3991 100644 (file)
--- a/src/crimson/os/seastore/extent_placement_manager.h
+++ b/src/crimson/os/seastore/extent_placement_manager.h
@@ -236,9 +236,9 @@ struct io_usage_t {
   cleaner_usage_t cleaner_usage;
   friend std::ostream &operator<<(std::ostream &out, const io_usage_t &usage) {
     return out << "io_usage_t("
-               << "inline_usage=" << usage.inline_usage
-               << ", main_cleaner_usage=" << usage.cleaner_usage.main_usage
-               << ", cold_cleaner_usage=" << usage.cleaner_usage.cold_ool_usage
+               << "inline_usage=0x" << std::hex << usage.inline_usage
+               << ", main_cleaner_usage=0x" << usage.cleaner_usage.main_usage
+               << ", cold_cleaner_usage=0x" << usage.cleaner_usage.cold_ool_usage << std::dec
                << ")";
   }
 };
@@ -424,7 +424,7 @@ public:
                         : ext.start + (ext.len - left);
           allocs.emplace_back(alloc_result_t{start, std::move(bp), gen});
           SUBDEBUGT(seastore_epm,
-                    "allocated {} {}B extent at {}, hint={}, gen={}",
+                    "allocated {} 0x{:x}B extent at {}, hint={}, gen={}",
                     t, type, len, start, hint, gen);
           left -= len;
         }

diff --git a/src/crimson/os/seastore/object_data_handler.cc b/src/crimson/os/seastore/object_data_handler.cc
index 36413f1206a3e64e5569f74b462fe7462ae75841..8f817a521cfee716f6d1fedbc967be0a48ea7299 100644 (file)
--- a/src/crimson/os/seastore/object_data_handler.cc
+++ b/src/crimson/os/seastore/object_data_handler.cc
@@ -525,7 +525,7 @@ ObjectDataHandler::write_ret do_insertions(
       if (region.is_data()) {
        assert_aligned(region.len);
        ceph_assert(region.len == region.bl->length());
-       DEBUGT("allocating extent: {}~{}",
+       DEBUGT("allocating extent: {}~0x{:x}",
               ctx.t,
               region.addr,
               region.len);
@@ -556,7 +556,7 @@ ObjectDataHandler::write_ret do_insertions(
          ObjectDataHandler::write_iertr::pass_further{}
        );
       } else if (region.is_zero()) {
-       DEBUGT("reserving: {}~{}",
+       DEBUGT("reserving: {}~0x{:x}",
               ctx.t,
               region.addr,
               region.len);
@@ -698,7 +698,7 @@ public:
               << ", aligned_data_end=" << overwrite_plan.aligned_data_end
               << ", left_operation=" << overwrite_plan.left_operation
               << ", right_operation=" << overwrite_plan.right_operation
-              << ", block_size=" << overwrite_plan.block_size
+              << ", block_size=0x" << std::hex << overwrite_plan.block_size << std::dec
               << ", is_left_fresh=" << overwrite_plan.is_left_fresh
               << ", is_right_fresh=" << overwrite_plan.is_right_fresh
               << ")";
@@ -1059,13 +1059,13 @@ ObjectDataHandler::write_ret ObjectDataHandler::prepare_data_reservation(
   ceph_assert(size <= max_object_size);
   if (!object_data.is_null()) {
     ceph_assert(object_data.get_reserved_data_len() == max_object_size);
-    DEBUGT("reservation present: {}~{}",
+    DEBUGT("reservation present: {}~0x{:x}",
            ctx.t,
            object_data.get_reserved_data_base(),
            object_data.get_reserved_data_len());
     return write_iertr::now();
   } else {
-    DEBUGT("reserving: {}~{}",
+    DEBUGT("reserving: {}~0x{:x}",
            ctx.t,
            ctx.onode.get_data_hint(),
            max_object_size);
@@ -1098,7 +1098,7 @@ ObjectDataHandler::clear_ret ObjectDataHandler::trim_data_reservation(
       LOG_PREFIX(ObjectDataHandler::trim_data_reservation);
       auto data_base = object_data.get_reserved_data_base();
       auto data_len = object_data.get_reserved_data_len();
-      DEBUGT("object_data: {}~{}", ctx.t, data_base, data_len);
+      DEBUGT("object_data: {}~0x{:x}", ctx.t, data_base, data_len);
       laddr_t aligned_start = (data_base + size).get_aligned_laddr();
       loffset_t aligned_length =
          data_len - aligned_start.get_byte_distance<loffset_t>(data_base);
@@ -1134,7 +1134,7 @@ ObjectDataHandler::clear_ret ObjectDataHandler::trim_data_reservation(
           if (append_len == 0) {
             LOG_PREFIX(ObjectDataHandler::trim_data_reservation);
             TRACET("First pin overlaps the boundary and has aligned data"
-              "create existing at addr:{}, len:{}",
+              "create existing at addr:{}, len:0x{:x}",
               ctx.t, pin.get_key(), size - pin_offset);
             to_write.push_back(extent_to_write_t::create_existing(
               pin.duplicate(),
@@ -1156,7 +1156,7 @@ ObjectDataHandler::clear_ret ObjectDataHandler::trim_data_reservation(
               write_bl.append_zero(append_len);
               LOG_PREFIX(ObjectDataHandler::trim_data_reservation);
               TRACET("First pin overlaps the boundary and has unaligned data"
-                "create data at addr:{}, len:{}",
+                "create data at addr:{}, len:0x{:x}",
                 ctx.t, pin.get_key(), write_bl.length());
              to_write.push_back(extent_to_write_t::create_data(
                pin.get_key(),
@@ -1303,7 +1303,7 @@ ObjectDataHandler::write_ret ObjectDataHandler::overwrite(
     (auto &pins, auto &to_write) mutable
   {
     LOG_PREFIX(ObjectDataHandler::overwrite);
-    DEBUGT("overwrite: {}~{}",
+    DEBUGT("overwrite: 0x{:x}~0x{:x}",
            ctx.t,
            offset,
            len);
@@ -1393,7 +1393,7 @@ ObjectDataHandler::zero_ret ObjectDataHandler::zero(
     ctx,
     [this, ctx, offset, len](auto &object_data) {
       LOG_PREFIX(ObjectDataHandler::zero);
-      DEBUGT("zero to {}~{}, object_data: {}~{}, is_null {}",
+      DEBUGT("zero to 0x{:x}~0x{:x}, object_data: {}~0x{:x}, is_null {}",
              ctx.t,
              offset,
              len,
@@ -1434,7 +1434,7 @@ ObjectDataHandler::write_ret ObjectDataHandler::write(
     ctx,
     [this, ctx, offset, &bl](auto &object_data) {
       LOG_PREFIX(ObjectDataHandler::write);
-      DEBUGT("writing to {}~{}, object_data: {}~{}, is_null {}",
+      DEBUGT("writing to 0x{:x}~0x{:x}, object_data: {}~0x{:x}, is_null {}",
              ctx.t,
              offset,
             bl.length(),
@@ -1479,7 +1479,7 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
       ctx,
       [ctx, obj_offset, len, &ret](const auto &object_data) {
       LOG_PREFIX(ObjectDataHandler::read);
-      DEBUGT("reading {}~{}",
+      DEBUGT("reading {}~0x{:x}",
              ctx.t,
              object_data.get_reserved_data_base(),
              object_data.get_reserved_data_len());
@@ -1536,7 +1536,7 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
               l_current_end.get_byte_distance<extent_len_t>(l_current);
 
             if (pin->get_val().is_zero()) {
-              DEBUGT("got {}~{} from zero-pin {}~{}",
+              DEBUGT("got {}~0x{:x} from zero-pin {}~0x{:x}",
                 ctx.t,
                 l_current,
                 read_len,
@@ -1553,7 +1553,7 @@ ObjectDataHandler::read_ret ObjectDataHandler::read(
               l_current_end_aligned.get_byte_distance<extent_len_t>(pin_start);
             read_len_aligned -= read_start_aligned;
             extent_len_t unalign_start_offset = read_start - read_start_aligned;
-            DEBUGT("reading {}~{} from pin {}~{}",
+            DEBUGT("reading {}~0x{:x} from pin {}~0x{:x}",
               ctx.t,
               l_current,
               read_len,
@@ -1609,7 +1609,7 @@ ObjectDataHandler::fiemap_ret ObjectDataHandler::fiemap(
       [ctx, obj_offset, len, &ret](const auto &object_data) {
       LOG_PREFIX(ObjectDataHandler::fiemap);
       DEBUGT(
-       "{}~{}, reservation {}~{}",
+       "0x{:x}~0x{:x}, reservation {}~0x{:x}",
         ctx.t,
         obj_offset,
         len,
@@ -1664,7 +1664,7 @@ ObjectDataHandler::truncate_ret ObjectDataHandler::truncate(
     ctx,
     [this, ctx, offset](auto &object_data) {
       LOG_PREFIX(ObjectDataHandler::truncate);
-      DEBUGT("truncating {}~{} offset: {}",
+      DEBUGT("truncating {}~0x{:x} offset: 0x{:x}",
             ctx.t,
             object_data.get_reserved_data_base(),
             object_data.get_reserved_data_len(),
@@ -1707,7 +1707,7 @@ ObjectDataHandler::clone_ret ObjectDataHandler::clone_extents(
   laddr_t data_base)
 {
   LOG_PREFIX(ObjectDataHandler::clone_extents);
-  TRACET(" object_data: {}~{}, data_base: {}",
+  TRACET("object_data: {}~0x{:x}, data_base: 0x{:x}",
     ctx.t,
     object_data.get_reserved_data_base(),
     object_data.get_reserved_data_len(),
@@ -1792,7 +1792,7 @@ ObjectDataHandler::clone_ret ObjectDataHandler::clone(
       auto len = object_data.get_reserved_data_len();
       object_data.clear();
       LOG_PREFIX(ObjectDataHandler::clone);
-      DEBUGT("cloned obj reserve_data_base: {}, len {}",
+      DEBUGT("cloned obj reserve_data_base: {}, len 0x{:x}",
        ctx.t,
        d_object_data.get_reserved_data_base(),
        d_object_data.get_reserved_data_len());
@@ -1802,7 +1802,7 @@ ObjectDataHandler::clone_ret ObjectDataHandler::clone(
        d_object_data.get_reserved_data_len()
       ).si_then([&d_object_data, ctx, &object_data, base, len, this] {
        LOG_PREFIX("ObjectDataHandler::clone");
-       DEBUGT("head obj reserve_data_base: {}, len {}",
+       DEBUGT("head obj reserve_data_base: {}, len 0x{:x}",
          ctx.t,
          object_data.get_reserved_data_base(),
          object_data.get_reserved_data_len());

diff --git a/src/crimson/os/seastore/onode.cc b/src/crimson/os/seastore/onode.cc
index f3fd6eb18a5ac6500dd778275f89e569aad48b92..dc8f6e87c8ea7b901b1723f4fe014599d1a9cb3a 100644 (file)
--- a/src/crimson/os/seastore/onode.cc
+++ b/src/crimson/os/seastore/onode.cc
@@ -11,7 +11,7 @@ std::ostream& operator<<(std::ostream &out, const Onode &rhs)
   auto &layout = rhs.get_layout();
   return out << "Onode("
             << "hobj=" << rhs.hobj << ", "
-             << "size=" << static_cast<uint32_t>(layout.size)
+             << "size=0x" << std::hex << static_cast<uint32_t>(layout.size) << std::dec
              << ")";
 }
 

diff --git a/src/crimson/os/seastore/record_scanner.cc b/src/crimson/os/seastore/record_scanner.cc
index 5fab11505cef61d880336199d14384f468d03f3b..172ba77577e2791d725a7190a325af99d3ad3447 100644 (file)
--- a/src/crimson/os/seastore/record_scanner.cc
+++ b/src/crimson/os/seastore/record_scanner.cc
@@ -18,7 +18,7 @@ RecordScanner::scan_valid_records(
 {
   LOG_PREFIX(RecordScanner::scan_valid_records);
   initialize_cursor(cursor);
-  DEBUG("starting at {}, budget={}", cursor, budget);
+  DEBUG("starting at {}, budget=0x{:x}", cursor, budget);
   auto retref = std::make_unique<size_t>(0);
   auto &budget_used = *retref;
   return crimson::repeat(
@@ -91,7 +91,7 @@ RecordScanner::scan_valid_records(
        }
       }().safe_then([=, &budget_used, &cursor] {
        if (cursor.is_complete() || budget_used >= budget) {
-         DEBUG("finish at {}, budget_used={}, budget={}",
+         DEBUG("finish at {}, budget_used=0x{:x}, budget=0x{:x}",
                 cursor, budget_used, budget);
          return seastar::stop_iteration::yes;
        } else {
@@ -112,13 +112,13 @@ RecordScanner::read_validate_record_metadata(
   paddr_t start = cursor.seq.offset;
   auto block_size = cursor.get_block_size();
   if (get_segment_off(cursor.seq.offset) + block_size > get_segment_end_offset(cursor.seq.offset)) {
-    DEBUG("failed -- record group header block {}~4096 > segment_size {}",
-      start, get_segment_end_offset(cursor.seq.offset));
+    DEBUG("failed -- record group header block {}~0x{:x} > segment_size 0x{:x}",
+      start, block_size, get_segment_end_offset(cursor.seq.offset));
     return read_validate_record_metadata_ret(
       read_validate_record_metadata_ertr::ready_future_marker{},
       std::nullopt);
   }
-  TRACE("reading record group header block {}~4096", start);
+  TRACE("reading record group header block {}~0x{:x}", start, block_size);
   return read(start, block_size
   ).safe_then([this, FNAME, nonce, block_size, &cursor](bufferptr bptr)
               -> read_validate_record_metadata_ret {
@@ -159,7 +159,7 @@ RecordScanner::read_validate_record_metadata(
 
     paddr_t rest_start = cursor.seq.offset.add_offset(block_size);
     auto rest_len = header.mdlength - block_size;
-    TRACE("reading record group header rest {}~{}", rest_start, rest_len);
+    TRACE("reading record group header rest {}~0x{:x}", rest_start, rest_len);
     return read(rest_start, rest_len
     ).safe_then([header=std::move(header), bl=std::move(bl)
                 ](auto&& bptail) mutable {
@@ -189,7 +189,7 @@ RecordScanner::read_validate_data_ret RecordScanner::read_validate_data(
 {
   LOG_PREFIX(RecordScanner::read_validate_data);
   auto data_addr = record_base.add_offset(header.mdlength);
-  TRACE("reading record group data blocks {}~{}", data_addr, header.dlength);
+  TRACE("reading record group data blocks {}~0x{:x}", data_addr, header.dlength);
   return read(
     data_addr,
     header.dlength
@@ -220,7 +220,7 @@ RecordScanner::consume_next_records(
       total_length
     }
   };
-  DEBUG("processing {} at {}, budget_used={}",
+  DEBUG("processing {} at {}, budget_used=0x{:x}",
         next.header, locator, budget_used);
   return handler(
     locator,

diff --git a/src/crimson/os/seastore/seastore.cc b/src/crimson/os/seastore/seastore.cc
index 2bf55d5cde7699b276eb1dd4bbd7c39b318b4ca5..5b51083f3442e60fba72a0f55a258278eba3c098 100644 (file)
--- a/src/crimson/os/seastore/seastore.cc
+++ b/src/crimson/os/seastore/seastore.cc
@@ -1331,7 +1331,7 @@ seastar::future<struct stat> SeaStore::Shard::_stat(
   st.st_blksize = device->get_block_size();
   st.st_blocks = (st.st_size + st.st_blksize - 1) / st.st_blksize;
   st.st_nlink = 1;
-  DEBUGT("oid={}, size={}, blksize={}",
+  DEBUGT("oid={}, size=0x{:x}, blksize=0x{:x}",
          t, oid, st.st_size, st.st_blksize);
   return seastar::make_ready_future<struct stat>(st);
 }
@@ -1640,7 +1640,7 @@ seastar::future<> SeaStore::Shard::do_transaction_no_callbacks(
     [this, num_bytes](auto &ctx) {
       LOG_PREFIX(SeaStoreS::do_transaction_no_callbacks);
       return with_trans_intr(*ctx.transaction, [&ctx, this, FNAME, num_bytes](auto &t) {
-        DEBUGT("cid={}, {} operations, {} bytes, {} colls, {} objects ...",
+        DEBUGT("cid={}, {} operations, 0x{:x} bytes, {} colls, {} objects ...",
                t, ctx.ch->get_cid(),
                ctx.ext_transaction.get_num_ops(),
                num_bytes,

diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc
index 450118e5e7570ac28dadf6f7d708fcad4d09960c..a57f56d4ab4571c85973ddfdc45f42724ad18c7f 100644 (file)
--- a/src/crimson/os/seastore/seastore_types.cc
+++ b/src/crimson/os/seastore/seastore_types.cc
@@ -351,11 +351,11 @@ std::ostream &operator<<(std::ostream &out, const delta_info_t &delta)
             << "type: " << delta.type
             << ", paddr: " << delta.paddr
             << ", laddr: " << delta.laddr
-            << ", prev_crc: " << delta.prev_crc
-            << ", final_crc: " << delta.final_crc
-            << ", length: " << delta.length
+            << ", prev_crc: 0x" << std::hex << delta.prev_crc
+            << ", final_crc: 0x" << delta.final_crc
+            << ", length: 0x" << delta.length << std::dec
             << ", pversion: " << delta.pversion
-            << ", ext_seq: " << delta.ext_seq
+            << ", ext_seq: " << segment_seq_printer_t{delta.ext_seq}
             << ", seg_type: " << delta.seg_type
             << ")";
 }
@@ -373,7 +373,7 @@ std::ostream &operator<<(std::ostream &out, const extent_info_t &info)
   return out << "extent_info_t("
             << "type: " << info.type
             << ", addr: " << info.addr
-            << ", len: " << info.len
+            << ", len: 0x" << std::hex << info.len << std::dec
             << ")";
 }
 
@@ -387,7 +387,7 @@ std::ostream &operator<<(std::ostream &out, const segment_header_t &header)
              << " " << rewrite_gen_printer_t{header.generation}
              << ", dirty_tail=" << header.dirty_tail
              << ", alloc_tail=" << header.alloc_tail
-             << ", segment_nonce=" << header.segment_nonce
+             << ", segment_nonce=0x" << std::hex << header.segment_nonce << std::dec
             << ", modify_time=" << mod_time_point_printer_t{header.modify_time}
              << ")";
 }
@@ -398,7 +398,7 @@ std::ostream &operator<<(std::ostream &out, const segment_tail_t &tail)
              << tail.physical_segment_id
              << " " << tail.type
              << " " << segment_seq_printer_t{tail.segment_seq}
-             << ", segment_nonce=" << tail.segment_nonce
+             << ", segment_nonce=0x" << std::hex << tail.segment_nonce << std::dec
              << ", modify_time=" << mod_time_point_printer_t{tail.modify_time}
              << ", num_extents=" << tail.num_extents
              << ")";
@@ -464,8 +464,8 @@ std::ostream &operator<<(std::ostream& out, const record_size_t& rsize)
 {
   return out << "record_size_t("
              << "record_type=" << rsize.record_type
-             << "raw_md=" << rsize.get_raw_mdlength()
-             << ", data=" << rsize.dlength
+             << "raw_md=0x" << std::hex << rsize.get_raw_mdlength()
+             << ", data=0x" << rsize.dlength << std::dec
              << ")";
 }
 
@@ -509,11 +509,11 @@ std::ostream& operator<<(std::ostream& out, const record_group_header_t& h)
 {
   return out << "record_group_header_t("
              << "num_records=" << h.records
-             << ", mdlength=" << h.mdlength
-             << ", dlength=" << h.dlength
-             << ", nonce=" << h.segment_nonce
+             << ", mdlength=0x" << std::hex << h.mdlength
+             << ", dlength=0x" << h.dlength
+             << ", segment_nonce=0x" << h.segment_nonce << std::dec
              << ", committed_to=" << h.committed_to
-             << ", data_crc=" << h.data_crc
+             << ", data_crc=0x" << std::hex << h.data_crc << std::dec
              << ")";
 }
 
@@ -556,9 +556,9 @@ std::ostream& operator<<(std::ostream& out, const record_group_size_t& size)
 {
   return out << "record_group_size_t("
              << "record_type=" << size.record_type
-             << "raw_md=" << size.get_raw_mdlength()
-             << ", data=" << size.dlength
-             << ", block_size=" << size.block_size
+             << "raw_md=0x" << std::hex << size.get_raw_mdlength()
+             << ", data=0x" << size.dlength
+             << ", block_size=0x" << size.block_size << std::dec
              << ", fullness=" << size.get_fullness()
              << ")";
 }
@@ -913,7 +913,7 @@ std::ostream& operator<<(std::ostream& out, const write_result_t& w)
 {
   return out << "write_result_t("
              << "start=" << w.start_seq
-             << ", length=" << w.length
+             << ", length=0x" << std::hex << w.length << std::dec
              << ")";
 }
 

diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc
index 745df70235b72c5a4c32d7a4fcadcb346233057f..94e9b3b9ab1536f48a216cae9349965033c45f03 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.cc
+++ b/src/crimson/os/seastore/transaction_manager.cc
@@ -221,7 +221,7 @@ TransactionManager::ref_ret TransactionManager::inc_ref(
   TRACET("{}", t, offset);
   return lba_manager->incref_extent(t, offset
   ).si_then([FNAME, offset, &t](auto result) {
-    DEBUGT("extent refcount is incremented to {} -- {}~{}, {}",
+    DEBUGT("extent refcount is incremented to {} -- {}~0x{:x}, {}",
            t, result.refcount, offset, result.length, result.addr);
     return result.refcount;
   });
@@ -508,7 +508,7 @@ TransactionManager::get_next_dirty_extents(
   size_t max_bytes)
 {
   LOG_PREFIX(TransactionManager::get_next_dirty_extents);
-  DEBUGT("max_bytes={}B, seq={}", t, max_bytes, seq);
+  DEBUGT("max_bytes=0x{:x}B, seq={}", t, max_bytes, seq);
   return cache->get_next_dirty_extents(t, seq, max_bytes);
 }
 

diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h
index 0317d3b4bb888755a0045a372ffd8a618a1ceceb..dc6cc20cf59cde10a3306d560f712c78479109e7 100644 (file)
--- a/src/crimson/os/seastore/transaction_manager.h
+++ b/src/crimson/os/seastore/transaction_manager.h
@@ -1066,7 +1066,7 @@ private:
         auto crc = ref->calc_crc32c();
         SUBTRACET(
          seastore_tm,
-         "got extent -- {}, chksum in the lba tree: {}, actual chksum: {}",
+         "got extent -- {}, chksum in the lba tree: 0x{:x}, actual chksum: 0x{:x}",
          t,
          *ref,
          pin->get_checksum(),
@@ -1080,7 +1080,7 @@ private:
         }
         if (unlikely(inconsistent)) {
          SUBERRORT(seastore_tm,
-           "extent checksum inconsistent, recorded: {}, actual: {}, {}",
+           "extent checksum inconsistent, recorded: 0x{:x}, actual: 0x{:x}, {}",
            t,
            pin->get_checksum(),
            crc,
@@ -1142,7 +1142,7 @@ private:
       auto crc = ref->calc_crc32c();
       SUBTRACET(
        seastore_tm,
-       "got extent -- {}, chksum in the lba tree: {}, actual chksum: {}",
+       "got extent -- {}, chksum in the lba tree: 0x{:x}, actual chksum: 0x{:x}",
        t,
        *ref,
        pin->get_checksum(),
@@ -1157,7 +1157,7 @@ private:
       }
       if (unlikely(inconsistent)) {
        SUBERRORT(seastore_tm,
-         "extent checksum inconsistent, recorded: {}, actual: {}, {}",
+         "extent checksum inconsistent, recorded: 0x{:x}, actual: 0x{:x}, {}",
          t,
          pin->get_checksum(),
          crc,