osd/: split rollback info trims into trims and rollforwards

Also, rollforward on activate() and adjust read_log debugging to
account for non-rollforward entries.

Signed-off-by: Samuel Just <sjust@redhat.com>

diff --git a/src/osd/PG.cc b/src/osd/PG.cc
index 660dae066afd50e65c0d08091ee18e9808e51179..fc466a408243c1f43250d9c05cab21c52b78708c 100644 (file)
--- a/src/osd/PG.cc
+++ b/src/osd/PG.cc
@@ -1848,6 +1848,11 @@ void PG::activate(ObjectStore::Transaction& t,
 
     state_set(PG_STATE_ACTIVATING);
   }
+  if (acting.size() >= pool.info.min_size) {
+    PGLogEntryHandler handler;
+    pg_log.roll_forward(&handler);
+    handler.apply(this, &t);
+  }
 }
 
 bool PG::op_has_sufficient_caps(OpRequestRef& op)
@@ -3056,14 +3061,14 @@ void PG::append_log(
 
   PGLogEntryHandler handler;
   if (!transaction_applied) {
-    pg_log.clear_can_rollback_to(&handler);
+    pg_log.roll_forward(&handler);
     t.register_on_applied(
       new C_UpdateLastRollbackInfoTrimmedToApplied(
        this,
        get_osdmap()->get_epoch(),
        info.last_update));
   } else if (roll_forward_to > pg_log.get_rollback_trimmed_to()) {
-    pg_log.trim_rollback_info(
+    pg_log.roll_forward_to(
       roll_forward_to,
       &handler);
     t.register_on_applied(
@@ -3075,7 +3080,7 @@ void PG::append_log(
 
   pg_log.trim(&handler, trim_to, info);
 
-  dout(10) << __func__ << ": trimming to " << roll_forward_to
+  dout(10) << __func__ << ": rolling forward to " << roll_forward_to
           << " entries " << handler.to_trim << dendl;
   handler.apply(this, &t);
 

diff --git a/src/osd/PG.h b/src/osd/PG.h
index 80133717a2f6d597f2e903c1f75cbd2dc553fd3a..891fe991c6420f606401651d935aac80d823539d 100644 (file)
--- a/src/osd/PG.h
+++ b/src/osd/PG.h
@@ -988,6 +988,9 @@ public:
     void rollback(const pg_log_entry_t &entry) {
       to_rollback.push_back(entry);
     }
+    void rollforward(const pg_log_entry_t &entry) {
+      to_trim.push_back(entry);
+    }
     void trim(const pg_log_entry_t &entry) {
       to_trim.push_back(entry);
     }

diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc
index 3f9870fe9eb23e06fa0832bbd8fca97d7f5fad07..b0fc2e25e2bae99d98383f7dcd72b6a72c2bec35 100644 (file)
--- a/src/osd/PGLog.cc
+++ b/src/osd/PGLog.cc
@@ -30,25 +30,6 @@ static ostream& _prefix(std::ostream *_dout, const PGLog *pglog)
 
 //////////////////// PGLog::IndexedLog ////////////////////
 
-void PGLog::IndexedLog::advance_rollback_info_trimmed_to(
-  eversion_t to,
-  LogEntryHandler *h)
-{
-  assert(to <= can_rollback_to);
-
-  if (to > rollback_info_trimmed_to)
-    rollback_info_trimmed_to = to;
-
-  while (rollback_info_trimmed_to_riter != log.rbegin()) {
-    --rollback_info_trimmed_to_riter;
-    if (rollback_info_trimmed_to_riter->version > rollback_info_trimmed_to) {
-      ++rollback_info_trimmed_to_riter;
-      break;
-    }
-    h->trim(*rollback_info_trimmed_to_riter);
-  }
-}
-
 void PGLog::IndexedLog::filter_log(spg_t pgid, const OSDMap &map, const string &hit_set_namespace)
 {
   IndexedLog out;
@@ -104,7 +85,7 @@ void PGLog::IndexedLog::trim(
 
   if (s > can_rollback_to)
     can_rollback_to = s;
-  advance_rollback_info_trimmed_to(s, handler);
+  trim_rollback_info_to(s, handler);
 
   while (!log.empty()) {
     pg_log_entry_t &e = *log.begin();

diff --git a/src/osd/PGLog.h b/src/osd/PGLog.h
index 25b4412d32161e3b679203013b8bcdc447895274..864866f98f013a8d9997fe9c18ddff7cfa9482a1 100644 (file)
--- a/src/osd/PGLog.h
+++ b/src/osd/PGLog.h
@@ -48,6 +48,8 @@ struct PGLog : DoutPrefixProvider {
   struct LogEntryHandler {
     virtual void rollback(
       const pg_log_entry_t &entry) = 0;
+    virtual void rollforward(
+      const pg_log_entry_t &entry) = 0;
     virtual void remove(
       const hobject_t &hoid) = 0;
     virtual void try_stash(
@@ -96,7 +98,36 @@ struct PGLog : DoutPrefixProvider {
      */
     list<pg_log_entry_t>::reverse_iterator rollback_info_trimmed_to_riter;
   public:
-    void advance_rollback_info_trimmed_to(eversion_t to, LogEntryHandler *h);
+    template <typename F>
+    void advance_can_rollback_to(eversion_t to, F &&f) {
+      assert(to <= can_rollback_to);
+
+      if (to > rollback_info_trimmed_to)
+       rollback_info_trimmed_to = to;
+
+      while (rollback_info_trimmed_to_riter != log.rbegin()) {
+       --rollback_info_trimmed_to_riter;
+       if (rollback_info_trimmed_to_riter->version > rollback_info_trimmed_to) {
+         ++rollback_info_trimmed_to_riter;
+         break;
+       }
+       f(*rollback_info_trimmed_to_riter);
+      }
+    }
+    void trim_rollback_info_to(eversion_t to, LogEntryHandler *h) {
+      advance_can_rollback_to(
+       to,
+       [&](pg_log_entry_t &entry) {
+         h->trim(entry);
+       });
+    }
+    void roll_forward_to(eversion_t to, LogEntryHandler *h) {
+      advance_can_rollback_to(
+       to,
+       [&](pg_log_entry_t &entry) {
+         h->rollforward(entry);
+       });
+    }
 
     /****/
     IndexedLog() :
@@ -568,12 +599,12 @@ public:
     eversion_t trim_to,
     pg_info_t &info);
 
-  void trim_rollback_info(
+  void roll_forward_to(
     eversion_t roll_forward_to,
     LogEntryHandler *h) {
     if (roll_forward_to > log.can_rollback_to)
       log.can_rollback_to = roll_forward_to;
-    log.advance_rollback_info_trimmed_to(
+    log.roll_forward_to(
       roll_forward_to,
       h);
   }
@@ -582,9 +613,8 @@ public:
     return log.rollback_info_trimmed_to;
   }
 
-  void clear_can_rollback_to(LogEntryHandler *h) {
-    log.can_rollback_to = log.head;
-    log.advance_rollback_info_trimmed_to(
+  void roll_forward(LogEntryHandler *h) {
+    roll_forward_to(
       log.head,
       h);
   }
@@ -593,7 +623,7 @@ public:
 
   void reset_backfill_claim_log(const pg_log_t &o, LogEntryHandler *h) {
     log.can_rollback_to = log.head;
-    log.advance_rollback_info_trimmed_to(log.head, h);
+    log.trim_rollback_info_to(log.head, h);
     log.claim_log_and_clear_rollback_info(o);
     missing.clear();
     mark_dirty_to(eversion_t::max());
@@ -1113,6 +1143,7 @@ public:
 
        set<hobject_t, hobject_t::BitwiseComparator> did;
        set<hobject_t, hobject_t::BitwiseComparator> checked;
+       set<hobject_t, hobject_t::BitwiseComparator> skipped;
        for (list<pg_log_entry_t>::reverse_iterator i = log.log.rbegin();
             i != log.log.rend();
             ++i) {
@@ -1124,6 +1155,9 @@ public:
          if (did.count(i->soid)) continue;
          did.insert(i->soid);
 
+         if (i->version > log.can_rollback_to && i->is_rollforward())
+           checked.insert(i->soid);
+
          if (i->is_delete()) continue;
 
          bufferlist bv;

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index 95b40d1a1025e9eb222da44d15c97cd787541b55..a72cc797bfc5fe50944751f19c33fea2ff27b457 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -9996,7 +9996,7 @@ void ReplicatedPG::on_removal(ObjectStore::Transaction *t)
 
   // clear log
   PGLogEntryHandler rollbacker;
-  pg_log.clear_can_rollback_to(&rollbacker);
+  pg_log.roll_forward(&rollbacker);
   rollbacker.apply(this, t);
 
   write_if_dirty(*t);

diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index dffb65418520ad09096320af4c730f143fbdaa50..67c9e8153ef408f70235a6b3569ebd3912f92eb6 100644 (file)
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -2828,6 +2828,8 @@ struct pg_log_entry_t {
       (op == MODIFY || op == DELETE || op == ERROR);
   }
 
+  bool is_rollforward() const { /* TODO */ return false; }
+
   string get_key_name() const;
   void encode_with_checksum(bufferlist& bl) const;
   void decode_with_checksum(bufferlist::iterator& p);

diff --git a/src/test/osd/TestPGLog.cc b/src/test/osd/TestPGLog.cc
index 52981063a0a8af44a366523bd28e9bb6ecedc42c..d232288e94fa040719b3b32210e29821ca34bbc1 100644 (file)
--- a/src/test/osd/TestPGLog.cc
+++ b/src/test/osd/TestPGLog.cc
@@ -162,6 +162,8 @@ public:
       const pg_log_entry_t &entry) {
       rolledback.push_back(entry);
     }
+    void rollforward(
+      const pg_log_entry_t &entry) {}
     void remove(
       const hobject_t &hoid) {
       removed.insert(hoid);
@@ -276,6 +278,8 @@ struct TestHandler : public PGLog::LogEntryHandler {
 
   void rollback(
     const pg_log_entry_t &entry) {}
+  void rollforward(
+    const pg_log_entry_t &entry) {}
   void remove(
     const hobject_t &hoid) {
     removed.push_back(hoid);
@@ -483,7 +487,7 @@ TEST_F(PGLogTest, rewind_divergent_log) {
       add(e);
     }
     TestHandler h(remove_snap);
-    trim_rollback_info(eversion_t(1, 6), &h);
+    roll_forward_to(eversion_t(1, 6), &h);
     rewind_divergent_log(t, eversion_t(1, 5), info, &h,
                         dirty_info, dirty_big_info);
     pg_log_t log;