osd/osd_types: track pg_history last_interval_{starte,clean}

These will track last_epoch_{started,clean} but match
the first epoch in the interval instead of the epoch when
the event happened.  We didn't end up need this now, but
I suspect it will be useful in the future.

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/osd/PG.cc b/src/osd/PG.cc
index f36e97de65a83f413f2ae1179b37e55ab46a911d..70c9e64605a5195cdec944ea2a6c4f6272b4259f 100644 (file)
--- a/src/osd/PG.cc
+++ b/src/osd/PG.cc
@@ -1837,6 +1837,7 @@ void PG::_activate_committed(epoch_t epoch, epoch_t activation_epoch)
     peer_activated.insert(pg_whoami);
     dout(10) << "_activate_committed " << epoch
             << " peer_activated now " << peer_activated 
+            << " last_interval_started " << info.history.last_interval_started
             << " last_epoch_started " << info.history.last_epoch_started
             << " same_interval_since " << info.history.same_interval_since << dendl;
     assert(!actingbackfill.empty());
@@ -1852,6 +1853,7 @@ void PG::_activate_committed(epoch_t epoch, epoch_t activation_epoch)
       info);
 
     i.info.history.last_epoch_started = activation_epoch;
+    i.info.history.last_interval_started = i.info.history.same_interval_since;
     if (acting.size() >= pool.info.min_size) {
       state_set(PG_STATE_ACTIVE);
     } else {
@@ -1970,6 +1972,7 @@ void PG::mark_clean()
   // NOTE: this is actually a bit premature: we haven't purged the
   // strays yet.
   info.history.last_epoch_clean = get_osdmap()->get_epoch();
+  info.history.last_interval_clean = info.history.same_interval_since;
 
   past_intervals.clear();
 

diff --git a/src/osd/osd_types.cc b/src/osd/osd_types.cc
index 2933e5cf545c8a83a9463aa4621b27f03b1954cd..061938e0ff3af52a2741bed4fc53c6fe07c1d35d 100644 (file)
--- a/src/osd/osd_types.cc
+++ b/src/osd/osd_types.cc
@@ -2539,7 +2539,7 @@ void pool_stat_t::generate_test_instances(list<pool_stat_t*>& o)
 
 void pg_history_t::encode(bufferlist &bl) const
 {
-  ENCODE_START(7, 4, bl);
+  ENCODE_START(8, 4, bl);
   ::encode(epoch_created, bl);
   ::encode(last_epoch_started, bl);
   ::encode(last_epoch_clean, bl);
@@ -2553,12 +2553,14 @@ void pg_history_t::encode(bufferlist &bl) const
   ::encode(last_deep_scrub_stamp, bl);
   ::encode(last_clean_scrub_stamp, bl);
   ::encode(last_epoch_marked_full, bl);
+  ::encode(last_interval_started, bl);
+  ::encode(last_interval_clean, bl);
   ENCODE_FINISH(bl);
 }
 
 void pg_history_t::decode(bufferlist::iterator &bl)
 {
-  DECODE_START_LEGACY_COMPAT_LEN(7, 4, 4, bl);
+  DECODE_START_LEGACY_COMPAT_LEN(8, 4, 4, bl);
   ::decode(epoch_created, bl);
   ::decode(last_epoch_started, bl);
   if (struct_v >= 3)
@@ -2583,6 +2585,21 @@ void pg_history_t::decode(bufferlist::iterator &bl)
   if (struct_v >= 7) {
     ::decode(last_epoch_marked_full, bl);
   }
+  if (struct_v >= 8) {
+    ::decode(last_interval_started, bl);
+    ::decode(last_interval_clean, bl);
+  } else {
+    if (last_epoch_started >= same_interval_since) {
+      last_interval_started = same_interval_since;
+    } else {
+      last_interval_started = last_epoch_started; // best guess
+    }
+    if (last_epoch_clean >= same_interval_since) {
+      last_interval_clean = same_interval_since;
+    } else {
+      last_interval_clean = last_epoch_clean; // best guess
+    }
+  }
   DECODE_FINISH(bl);
 }
 
@@ -2590,7 +2607,9 @@ void pg_history_t::dump(Formatter *f) const
 {
   f->dump_int("epoch_created", epoch_created);
   f->dump_int("last_epoch_started", last_epoch_started);
+  f->dump_int("last_interval_started", last_interval_started);
   f->dump_int("last_epoch_clean", last_epoch_clean);
+  f->dump_int("last_interval_clean", last_interval_clean);
   f->dump_int("last_epoch_split", last_epoch_split);
   f->dump_int("last_epoch_marked_full", last_epoch_marked_full);
   f->dump_int("same_up_since", same_up_since);
@@ -2609,7 +2628,9 @@ void pg_history_t::generate_test_instances(list<pg_history_t*>& o)
   o.push_back(new pg_history_t);
   o.back()->epoch_created = 1;
   o.back()->last_epoch_started = 2;
+  o.back()->last_interval_started = 2;
   o.back()->last_epoch_clean = 3;
+  o.back()->last_interval_clean = 2;
   o.back()->last_epoch_split = 4;
   o.back()->same_up_since = 5;
   o.back()->same_interval_since = 6;

diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index 196f90f4d9ce13deed0329b61139a8984580edb0..31dd71678947e53c6c25ce51b9a3f2dac42aef6b 100644 (file)
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -2087,7 +2087,9 @@ WRITE_CLASS_ENCODER(pg_hit_set_history_t)
 struct pg_history_t {
   epoch_t epoch_created;       // epoch in which PG was created
   epoch_t last_epoch_started;  // lower bound on last epoch started (anywhere, not necessarily locally)
+  epoch_t last_interval_started; // first epoch of last_epoch_started interval
   epoch_t last_epoch_clean;    // lower bound on last epoch the PG was completely clean.
+  epoch_t last_interval_clean; // first epoch of last_epoch_clean interval
   epoch_t last_epoch_split;    // as parent
   epoch_t last_epoch_marked_full;  // pool or cluster
   
@@ -2112,7 +2114,9 @@ struct pg_history_t {
     return
       l.epoch_created == r.epoch_created &&
       l.last_epoch_started == r.last_epoch_started &&
+      l.last_interval_started == r.last_interval_started &&
       l.last_epoch_clean == r.last_epoch_clean &&
+      l.last_interval_clean == r.last_interval_clean &&
       l.last_epoch_split == r.last_epoch_split &&
       l.last_epoch_marked_full == r.last_epoch_marked_full &&
       l.same_up_since == r.same_up_since &&
@@ -2127,7 +2131,11 @@ struct pg_history_t {
 
   pg_history_t()
     : epoch_created(0),
-      last_epoch_started(0), last_epoch_clean(0), last_epoch_split(0),
+      last_epoch_started(0),
+      last_interval_started(0),
+      last_epoch_clean(0),
+      last_interval_clean(0),
+      last_epoch_split(0),
       last_epoch_marked_full(0),
       same_up_since(0), same_interval_since(0), same_primary_since(0) {}
   
@@ -2142,10 +2150,18 @@ struct pg_history_t {
       last_epoch_started = other.last_epoch_started;
       modified = true;
     }
+    if (last_interval_started < other.last_interval_started) {
+      last_interval_started = other.last_interval_started;
+      modified = true;
+    }
     if (last_epoch_clean < other.last_epoch_clean) {
       last_epoch_clean = other.last_epoch_clean;
       modified = true;
     }
+    if (last_interval_clean < other.last_interval_clean) {
+      last_interval_clean = other.last_interval_clean;
+      modified = true;
+    }
     if (last_epoch_split < other.last_epoch_split) {
       last_epoch_split = other.last_epoch_split; 
       modified = true;
@@ -2186,9 +2202,13 @@ WRITE_CLASS_ENCODER(pg_history_t)
 
 inline ostream& operator<<(ostream& out, const pg_history_t& h) {
   return out << "ec=" << h.epoch_created
+            << " lis/c " << h.last_interval_started
+            << "/" << h.last_interval_clean
             << " les/c/f " << h.last_epoch_started << "/" << h.last_epoch_clean
             << "/" << h.last_epoch_marked_full
-            << " " << h.same_up_since << "/" << h.same_interval_since << "/" << h.same_primary_since;
+            << " " << h.same_up_since
+            << "/" << h.same_interval_since
+            << "/" << h.same_primary_since;
 }