osd: key Missing::rmissing on version (not eversion)

This switches the key to the uint64_t (version_t) only, which is still
unique given a particular timeline (which is all we care about given a
particular Missing::missing).  The last_requested pointer is updated
accordingly.

This will facilitate a hack to make PGLS work for degraded PGs (by using
the rmissing version offset as a cookie).

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

diff --git a/src/osd/PG.cc b/src/osd/PG.cc
index 9e0205fc50f55860be83acfe473d23e36595b2f2..90ba170aae4747d3cbb789fc2047abc4a6344fa9 100644 (file)
--- a/src/osd/PG.cc
+++ b/src/osd/PG.cc
@@ -1534,7 +1534,7 @@ void PG::activate(ObjectStore::Transaction& t, list<Context*>& tfin,
     while (log.complete_to->version <= info.last_complete)
       log.complete_to++;
     assert(log.complete_to != log.log.end());
-    log.last_requested = eversion_t();
+    log.last_requested = 0;
     dout(10) << "activate -     complete_to = " << log.complete_to->version << dendl;
     if (is_primary()) {
       dout(10) << "activate - starting recovery" << dendl;
@@ -2804,7 +2804,7 @@ void PG::repair_object(const sobject_t& soid, ScrubMap::object *po, int bad_peer
     missing.add(soid, oi.version, eversion_t());
     missing_loc[soid].insert(ok_peer);
 
-    log.last_requested = eversion_t();
+    log.last_requested = 0;
   }
   osd->queue_for_recovery(this);
 }
@@ -3622,18 +3622,18 @@ void PG::Missing::add_next_event(Log::Entry& e)
       // new object.
       //assert(missing.count(e.soid) == 0);  // might already be missing divergent item.
       if (missing.count(e.soid))  // already missing divergent item
-       rmissing.erase(missing[e.soid].need);
+       rmissing.erase(missing[e.soid].need.version);
       missing[e.soid] = item(e.version, eversion_t());  // .have = nil
     } else if (missing.count(e.soid)) {
       // already missing (prior).
       //assert(missing[e.soid].need == e.prior_version);
-      rmissing.erase(missing[e.soid].need);
+      rmissing.erase(missing[e.soid].need.version);
       missing[e.soid].need = e.version;  // leave .have unchanged.
     } else {
       // not missing, we must have prior_version (if any)
       missing[e.soid] = item(e.version, e.prior_version);
     }
-    rmissing[e.version] = e.soid;
+    rmissing[e.version.version] = e.soid;
   } else
     rm(e.soid, e.version);
 }
@@ -3645,12 +3645,12 @@ void PG::Missing::add_event(Log::Entry& e)
       if (missing[e.soid].need >= e.version)
        return;   // already missing same or newer.
       // missing older, revise need
-      rmissing.erase(missing[e.soid].need);
+      rmissing.erase(missing[e.soid].need.version);
       missing[e.soid].need = e.version;
     } else
       // not missing => have prior_version (if any)
       missing[e.soid] = item(e.version, e.prior_version);
-    rmissing[e.version] = e.soid;
+    rmissing[e.version.version] = e.soid;
   } else
     rm(e.soid, e.version);
 }
@@ -3658,24 +3658,24 @@ void PG::Missing::add_event(Log::Entry& e)
 void PG::Missing::revise_need(sobject_t oid, eversion_t need)
 {
   if (missing.count(oid)) {
-    rmissing.erase(missing[oid].need);
+    rmissing.erase(missing[oid].need.version);
     missing[oid].need = need;            // no not adjust .have
   } else {
     missing[oid] = item(need, eversion_t());
   }
-  rmissing[need] = oid;
+  rmissing[need.version] = oid;
 }
 
 void PG::Missing::add(const sobject_t& oid, eversion_t need, eversion_t have)
 {
   missing[oid] = item(need, have);
-  rmissing[need] = oid;
+  rmissing[need.version] = oid;
 }
 
 void PG::Missing::rm(const sobject_t& oid, eversion_t v)
 {
   if (missing.count(oid) && missing[oid].need <= v) {
-    rmissing.erase(missing[oid].need);
+    rmissing.erase(missing[oid].need.version);
     missing.erase(oid);
   }
 }
@@ -3684,13 +3684,13 @@ void PG::Missing::got(const sobject_t& oid, eversion_t v)
 {
   assert(missing.count(oid));
   assert(missing[oid].need <= v);
-  rmissing.erase(missing[oid].need);
+  rmissing.erase(missing[oid].need.version);
   missing.erase(oid);
 }
 
 void PG::Missing::got(const std::map<sobject_t, Missing::item>::iterator &m)
 {
-  rmissing.erase(m->second.need);
+  rmissing.erase(m->second.need.version);
   missing.erase(m);
 }
 

diff --git a/src/osd/PG.h b/src/osd/PG.h
index cad6e87c079b92aac06596e941405138446fe351..321e2af2452e2295633c05a5d74d6a9aca328d90 100644 (file)
--- a/src/osd/PG.h
+++ b/src/osd/PG.h
@@ -492,7 +492,7 @@ public:
 
     // recovery pointers
     list<Entry>::iterator complete_to;  // not inclusive of referenced item
-    eversion_t last_requested;           // last object requested by primary
+    version_t last_requested;           // last object requested by primary
 
     /****/
     IndexedLog() {}
@@ -504,7 +504,7 @@ public:
     }
     void reset_recovery_pointers() {
       complete_to = log.end();
-      last_requested = eversion_t();
+      last_requested = 0;
     }
 
     bool logged_object(const sobject_t& oid) const {
@@ -651,7 +651,7 @@ public:
     WRITE_CLASS_ENCODER(item)
 
     map<sobject_t, item> missing;         // oid -> (need v, have v)
-    map<eversion_t, sobject_t> rmissing;  // v -> oid
+    map<version_t, sobject_t> rmissing;  // v -> oid
 
     unsigned int num_missing() const;
     bool have_missing() const;
@@ -681,7 +681,7 @@ public:
       for (map<sobject_t,item>::iterator it = missing.begin();
           it != missing.end();
           ++it)
-       rmissing[it->second.need] = it->first;
+       rmissing[it->second.need.version] = it->first;
     }
   };
   WRITE_CLASS_ENCODER(Missing)

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index ffa12f36f131b9a557c919c716e645a361ced048..e9c71c8d838cea45ea69833be720f6c95a215304 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -4222,7 +4222,7 @@ void ReplicatedPG::check_recovery_op_pulls(const OSDMap *osdmap)
       pulling.erase(*i);
       finish_recovery_op(*i);
     }
-    log.last_requested = eversion_t();
+    log.last_requested = 0;
     pull_from_peer.erase(j++);
   }
 }
@@ -4290,10 +4290,10 @@ int ReplicatedPG::recover_primary(int max)
   int started = 0;
   int skipped = 0;
 
-  map<eversion_t, sobject_t>::iterator p = missing.rmissing.lower_bound(log.last_requested);
+  map<version_t, sobject_t>::iterator p = missing.rmissing.lower_bound(log.last_requested);
   while (p != missing.rmissing.end()) {
     sobject_t soid;
-    eversion_t v = p->first;
+    version_t v = p->first;
 
     if (log.objects.count(p->second)) {
       latest = log.objects[p->second];
@@ -4447,15 +4447,16 @@ int ReplicatedPG::recover_replicas(int max)
 
     // oldest first!
     const Missing &m(pm->second);
-    for (map<eversion_t, sobject_t>::const_iterator p = m.rmissing.begin();
+    for (map<version_t, sobject_t>::const_iterator p = m.rmissing.begin();
           p != m.rmissing.end() && started < max;
           ++p) {
       const sobject_t soid(p->second);
-      eversion_t v = p->first;
+
       if (pushing.count(soid)) {
        dout(10) << __func__ << ": already pushing " << soid << dendl;
        continue;
       }
+
       if (missing.is_missing(soid)) {
        if (missing_loc.find(soid) == missing_loc.end())
          dout(10) << __func__ << ": " << soid << " still unfound" << dendl;
@@ -4465,7 +4466,8 @@ int ReplicatedPG::recover_replicas(int max)
       }
 
       dout(10) << __func__ << ": recover_object_replicas(" << soid << ")" << dendl;
-      started += recover_object_replicas(soid, v);
+      map<sobject_t,Missing::item>::const_iterator p = m.missing.find(soid);
+      started += recover_object_replicas(soid, p->second.need);
     }
   }