import quincy beta 17.1.0

[ceph.git] / ceph / src / crimson / os / seastore / onode_manager / staged-fltree / node_extent_manager / dummy.h

diff --git a/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h b/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h
index 830ea4a7db80e9658357d96060fa117d6fe2020b..52aee6a75fcefcc53f8a1ce3f373d134a4a42440 100644 (file)
--- a/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h
+++ b/ceph/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h
@@ -7,8 +7,8 @@
 #include <seastar/core/sleep.hh>
 
 #include "include/buffer_raw.h"
+#include "crimson/os/seastore/logging.h"
 
-#include "crimson/common/log.h"
 #include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h"
 
 /**
@@ -26,14 +26,12 @@ class DummySuper final: public Super {
   ~DummySuper() override = default;
  protected:
   laddr_t get_root_laddr() const override { return *p_root_laddr; }
-  void write_root_laddr(context_t, laddr_t addr) override {
-    logger().info("OTree::Dummy: update root {:#x} ...", addr);
+  void write_root_laddr(context_t c, laddr_t addr) override {
+    LOG_PREFIX(OTree::Dummy);
+    SUBDEBUGT(seastore_onode, "update root {:#x} ...", c.t, addr);
     *p_root_laddr = addr;
   }
  private:
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
   laddr_t* p_root_laddr;
 };
 
@@ -42,7 +40,16 @@ class DummyNodeExtent final: public NodeExtent {
   DummyNodeExtent(ceph::bufferptr &&ptr) : NodeExtent(std::move(ptr)) {
     state = extent_state_t::INITIAL_WRITE_PENDING;
   }
+  DummyNodeExtent(const DummyNodeExtent& other) = delete;
   ~DummyNodeExtent() override = default;
+
+  void retire() {
+    assert(state == extent_state_t::INITIAL_WRITE_PENDING);
+    state = extent_state_t::INVALID;
+    bufferptr empty_bptr;
+    get_bptr().swap(empty_bptr);
+  }
+
  protected:
   NodeExtentRef mutate(context_t, DeltaRecorderURef&&) override {
     ceph_abort("impossible path"); }
@@ -63,25 +70,27 @@ class DummyNodeExtentManager final: public NodeExtentManager {
   static constexpr size_t ALIGNMENT = 4096;
  public:
   ~DummyNodeExtentManager() override = default;
+  std::size_t size() const { return allocate_map.size(); }
+
  protected:
   bool is_read_isolated() const override { return false; }
 
-  tm_future<NodeExtentRef> read_extent(
-      Transaction& t, laddr_t addr, extent_len_t len) override {
-    logger().trace("OTree::Dummy: reading {}B at {:#x} ...", len, addr);
+  read_iertr::future<NodeExtentRef> read_extent(
+      Transaction& t, laddr_t addr) override {
+    SUBTRACET(seastore_onode, "reading at {:#x} ...", t, addr);
     if constexpr (SYNC) {
-      return read_extent_sync(t, addr, len);
+      return read_extent_sync(t, addr);
     } else {
       using namespace std::chrono_literals;
-      return seastar::sleep(1us).then([this, &t, addr, len] {
-        return read_extent_sync(t, addr, len);
+      return seastar::sleep(1us).then([this, &t, addr] {
+        return read_extent_sync(t, addr);
       });
     }
   }
 
-  tm_future<NodeExtentRef> alloc_extent(
-      Transaction& t, extent_len_t len) override {
-    logger().trace("OTree::Dummy: allocating {}B ...", len);
+  alloc_iertr::future<NodeExtentRef> alloc_extent(
+      Transaction& t, laddr_t hint, extent_len_t len) override {
+    SUBTRACET(seastore_onode, "allocating {}B with hint {:#x} ...", t, len, hint);
     if constexpr (SYNC) {
       return alloc_extent_sync(t, len);
     } else {
@@ -92,9 +101,24 @@ class DummyNodeExtentManager final: public NodeExtentManager {
     }
   }
 
-  tm_future<Super::URef> get_super(
+  retire_iertr::future<> retire_extent(
+      Transaction& t, NodeExtentRef extent) override {
+    SUBTRACET(seastore_onode,
+        "retiring {}B at {:#x} -- {} ...",
+        t, extent->get_length(), extent->get_laddr(), *extent);
+    if constexpr (SYNC) {
+      return retire_extent_sync(t, extent);
+    } else {
+      using namespace std::chrono_literals;
+      return seastar::sleep(1us).then([this, &t, extent] {
+        return retire_extent_sync(t, extent);
+      });
+    }
+  }
+
+  getsuper_iertr::future<Super::URef> get_super(
       Transaction& t, RootNodeTracker& tracker) override {
-    logger().trace("OTree::Dummy: get root ...");
+    SUBTRACET(seastore_onode, "get root ...", t);
     if constexpr (SYNC) {
       return get_super_sync(t, tracker);
     } else {
@@ -110,19 +134,19 @@ class DummyNodeExtentManager final: public NodeExtentManager {
   }
 
  private:
-  tm_future<NodeExtentRef> read_extent_sync(
-      Transaction& t, laddr_t addr, extent_len_t len) {
+  read_iertr::future<NodeExtentRef> read_extent_sync(
+      Transaction& t, laddr_t addr) {
     auto iter = allocate_map.find(addr);
     assert(iter != allocate_map.end());
     auto extent = iter->second;
-    logger().trace("OTree::Dummy: read {}B at {:#x}",
-                   extent->get_length(), extent->get_laddr());
+    SUBTRACET(seastore_onode,
+        "read {}B at {:#x} -- {}",
+        t, extent->get_length(), extent->get_laddr(), *extent);
     assert(extent->get_laddr() == addr);
-    assert(extent->get_length() == len);
-    return tm_ertr::make_ready_future<NodeExtentRef>(extent);
+    return read_iertr::make_ready_future<NodeExtentRef>(extent);
   }
 
-  tm_future<NodeExtentRef> alloc_extent_sync(
+  alloc_iertr::future<NodeExtentRef> alloc_extent_sync(
       Transaction& t, extent_len_t len) {
     assert(len % ALIGNMENT == 0);
     auto r = ceph::buffer::create_aligned(len, ALIGNMENT);
@@ -132,22 +156,34 @@ class DummyNodeExtentManager final: public NodeExtentManager {
     extent->set_laddr(addr);
     assert(allocate_map.find(extent->get_laddr()) == allocate_map.end());
     allocate_map.insert({extent->get_laddr(), extent});
-    logger().debug("OTree::Dummy: allocated {}B at {:#x}",
-                   extent->get_length(), extent->get_laddr());
+    SUBDEBUGT(seastore_onode,
+        "allocated {}B at {:#x} -- {}",
+        t, extent->get_length(), extent->get_laddr(), *extent);
     assert(extent->get_length() == len);
-    return tm_ertr::make_ready_future<NodeExtentRef>(extent);
+    return alloc_iertr::make_ready_future<NodeExtentRef>(extent);
   }
 
-  tm_future<Super::URef> get_super_sync(
+  retire_iertr::future<> retire_extent_sync(
+      Transaction& t, NodeExtentRef _extent) {
+    auto& extent = static_cast<DummyNodeExtent&>(*_extent.get());
+    auto addr = extent.get_laddr();
+    auto len = extent.get_length();
+    extent.retire();
+    auto iter = allocate_map.find(addr);
+    assert(iter != allocate_map.end());
+    allocate_map.erase(iter);
+    SUBDEBUGT(seastore_onode, "retired {}B at {:#x}", t, len, addr);
+    return retire_iertr::now();
+  }
+
+  getsuper_iertr::future<Super::URef> get_super_sync(
       Transaction& t, RootNodeTracker& tracker) {
-    logger().debug("OTree::Dummy: got root {:#x}", root_laddr);
-    return tm_ertr::make_ready_future<Super::URef>(
+    SUBTRACET(seastore_onode, "got root {:#x}", t, root_laddr);
+    return getsuper_iertr::make_ready_future<Super::URef>(
         Super::URef(new DummySuper(t, tracker, &root_laddr)));
   }
 
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
+  static LOG_PREFIX(OTree::Dummy);
 
   std::map<laddr_t, Ref<DummyNodeExtent>> allocate_map;
   laddr_t root_laddr = L_ADDR_NULL;