osd_types: make pg_missing_t::[r]missing private

We want to ensure that nothing is mutating these outside
of the interface.

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

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index f8942ef7b98701658eca3d12aa2445221c5b4055..015e6beedf745179c48635a3eb3954d44cedce71 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -5703,9 +5703,9 @@ void OSD::do_command(Connection *con, ceph_tid_t tid, vector<string>& cmd, buffe
 
       fout << *pg << std::endl;
       std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator mend =
-       pg->pg_log.get_missing().missing.end();
+       pg->pg_log.get_missing().get_items().end();
       std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator mi =
-       pg->pg_log.get_missing().missing.begin();
+       pg->pg_log.get_missing().get_items().begin();
       for (; mi != mend; ++mi) {
        fout << mi->first << " -> " << mi->second << std::endl;
        if (!pg->missing_loc.needs_recovery(mi->first))

diff --git a/src/osd/PG.cc b/src/osd/PG.cc
index 765955ca88e7bbe64797aecaeeb3a625ba283941..aa94b74c8f5dfbfc2f9169ac5e94c84085ed80a8 100644 (file)
--- a/src/osd/PG.cc
+++ b/src/osd/PG.cc
@@ -337,8 +337,9 @@ void PG::proc_replica_log(
   dout(10) << " peer osd." << from << " now " << oinfo << " " << omissing << dendl;
   might_have_unfound.insert(from);
 
-  for (map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::iterator i = omissing.missing.begin();
-       i != omissing.missing.end();
+  for (map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator i =
+        omissing.get_items().begin();
+       i != omissing.get_items().end();
        ++i) {
     dout(20) << " after missing " << i->first << " need " << i->second.need
             << " have " << i->second.have << dendl;

diff --git a/src/osd/PG.h b/src/osd/PG.h
index 3e77fb94688867031e947c18f67c01c63747a1cc..cc196430e38fb6691fbc6b7649647b3e5891a2f3 100644 (file)
--- a/src/osd/PG.h
+++ b/src/osd/PG.h
@@ -383,8 +383,8 @@ public:
     }
     void add_active_missing(const pg_missing_t &missing) {
       for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i =
-            missing.missing.begin();
-          i != missing.missing.end();
+            missing.get_items().begin();
+          i != missing.get_items().end();
           ++i) {
        map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator j =
          needs_recovery_map.find(i->first);
@@ -440,8 +440,8 @@ public:
       const map<pg_shard_t, pg_info_t> &pinfo) {
       recovered(hoid);
       boost::optional<pg_missing_t::item> item;
-      auto miter = missing.missing.find(hoid);
-      if (miter != missing.missing.end()) {
+      auto miter = missing.get_items().find(hoid);
+      if (miter != missing.get_items().end()) {
        item = miter->second;
       } else {
        for (auto &&i: to_recover) {
@@ -449,8 +449,8 @@ public:
            continue;
          auto pmiter = pmissing.find(i);
          assert(pmiter != pmissing.end());
-         miter = pmiter->second.missing.find(hoid);
-         if (miter != pmiter->second.missing.end()) {
+         miter = pmiter->second.get_items().find(hoid);
+         if (miter != pmiter->second.get_items().end()) {
            item = miter->second;
            break;
          }

diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc
index c8e30d1f7138092096064189c343e597a257098e..bda3e76b200d14e794807acfc9b1c57ad06b1602 100644 (file)
--- a/src/osd/PGLog.cc
+++ b/src/osd/PGLog.cc
@@ -216,8 +216,8 @@ void PGLog::proc_replica_log(
     we will send the peer enough log to arrive at the same state.
   */
 
-  for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator i = omissing.missing.begin();
-       i != omissing.missing.end();
+  for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i = omissing.get_items().begin();
+       i != omissing.get_items().end();
        ++i) {
     dout(20) << " before missing " << i->first << " need " << i->second.need
             << " have " << i->second.have << dendl;
@@ -293,7 +293,7 @@ void PGLog::proc_replica_log(
 
   if (omissing.have_missing()) {
     eversion_t first_missing =
-      omissing.missing[omissing.rmissing.begin()->second].need;
+      omissing.get_items().at(omissing.get_rmissing().begin()->second).need;
     oinfo.last_complete = eversion_t();
     list<pg_log_entry_t>::const_iterator i = olog.log.begin();
     for (;
@@ -395,7 +395,7 @@ void PGLog::_merge_object_divergent_entries(
     // ensure missing has been updated appropriately
     if (objiter->second->is_update()) {
       assert(missing.is_missing(hoid) &&
-            missing.missing[hoid].need == objiter->second->version);
+            missing.get_items().at(hoid).need == objiter->second->version);
     } else {
       assert(!missing.is_missing(hoid));
     }
@@ -414,7 +414,7 @@ void PGLog::_merge_object_divergent_entries(
                       << " deleting"
                       << dendl;
     if (missing.is_missing(hoid))
-      missing.rm(missing.missing.find(hoid));
+      missing.rm(missing.get_items().find(hoid));
     if (rollbacker && !object_not_in_store)
       rollbacker->remove(hoid);
     return;
@@ -423,17 +423,17 @@ void PGLog::_merge_object_divergent_entries(
   if (missing.is_missing(hoid)) {
     /// Case 3)
     ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
-                      << " missing, " << missing.missing[hoid]
+                      << " missing, " << missing.get_items().at(hoid)
                       << " adjusting" << dendl;
 
-    if (missing.missing[hoid].have == prior_version) {
+    if (missing.get_items().at(hoid).have == prior_version) {
       ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
               << " missing.have is prior_version " << prior_version
               << " removing from missing" << dendl;
-      missing.rm(missing.missing.find(hoid));
+      missing.rm(missing.get_items().find(hoid));
     } else {
       ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
-                        << " missing.have is " << missing.missing[hoid].have
+                        << " missing.have is " << missing.get_items().at(hoid).have
                         << ", adjusting" << dendl;
       missing.revise_need(hoid, prior_version);
       if (prior_version <= info.log_tail) {
@@ -624,8 +624,8 @@ void PGLog::merge_log(ObjectStore::Transaction& t,
   // The logs must overlap.
   assert(log.head >= olog.tail && olog.head >= log.tail);
 
-  for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator i = missing.missing.begin();
-       i != missing.missing.end();
+  for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i = missing.get_items().begin();
+       i != missing.get_items().end();
        ++i) {
     dout(20) << "pg_missing_t sobject: " << i->first << dendl;
   }

diff --git a/src/osd/PGLog.h b/src/osd/PGLog.h
index 167934fe3425b0b7fce2839c453ae6dba8f3fb55..f53f05d4f19cfee1f29ec534df6dc54ddb79eac7 100644 (file)
--- a/src/osd/PGLog.h
+++ b/src/osd/PGLog.h
@@ -631,13 +631,14 @@ public:
       missing.got(oid, v);
       
       // raise last_complete?
-      if (missing.missing.empty()) {
+      if (missing.get_items().empty()) {
        log.complete_to = log.log.end();
        info.last_complete = info.last_update;
       }
       while (log.complete_to != log.log.end()) {
-       if (missing.missing[missing.rmissing.begin()->second].need <=
-           log.complete_to->version)
+       if (missing.get_items().at(
+             missing.get_rmissing().begin()->second
+             ).need <= log.complete_to->version)
          break;
        if (info.last_complete < log.complete_to->version)
          info.last_complete = log.complete_to->version;
@@ -652,7 +653,9 @@ public:
   void activate_not_complete(pg_info_t &info) {
     log.complete_to = log.log.begin();
     while (log.complete_to->version <
-          missing.missing[missing.rmissing.begin()->second].need)
+          missing.get_items().at(
+            missing.get_rmissing().begin()->second
+            ).need)
       ++log.complete_to;
     assert(log.complete_to != log.log.end());
     if (log.complete_to == log.log.begin()) {

diff --git a/src/osd/ReplicatedBackend.cc b/src/osd/ReplicatedBackend.cc
index d9610f5d4af8af3c46ed62fcb79a62ec20791df2..c72ad925696046ddabd72c9ddd2154e149e2b41c 100644 (file)
--- a/src/osd/ReplicatedBackend.cc
+++ b/src/osd/ReplicatedBackend.cc
@@ -1416,8 +1416,8 @@ void ReplicatedBackend::prepare_pull(
   ObjectContextRef headctx,
   RPGHandle *h)
 {
-  assert(get_parent()->get_local_missing().missing.count(soid));
-  eversion_t _v = get_parent()->get_local_missing().missing.find(
+  assert(get_parent()->get_local_missing().get_items().count(soid));
+  eversion_t _v = get_parent()->get_local_missing().get_items().find(
     soid)->second.need;
   assert(_v == v);
   const map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &missing_loc(
@@ -1444,11 +1444,11 @@ void ReplicatedBackend::prepare_pull(
   assert(peer_missing.count(fromshard));
   const pg_missing_t &pmissing = peer_missing.find(fromshard)->second;
   if (pmissing.is_missing(soid, v)) {
-    assert(pmissing.missing.find(soid)->second.have != v);
+    assert(pmissing.get_items().find(soid)->second.have != v);
     dout(10) << "pulling soid " << soid << " from osd " << fromshard
-            << " at version " << pmissing.missing.find(soid)->second.have
+            << " at version " << pmissing.get_items().find(soid)->second.have
             << " rather than at version " << v << dendl;
-    v = pmissing.missing.find(soid)->second.have;
+    v = pmissing.get_items().find(soid)->second.have;
     assert(get_parent()->get_log().get_log().objects.count(soid) &&
           (get_parent()->get_log().get_log().objects.find(soid)->second->op ==
            pg_log_entry_t::LOST_REVERT) &&

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index 2fd435e0f7fccab9c4979a388b983265d7661ff5..478da38c622075a9986ff996407cdcfdba70dd25 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -186,7 +186,7 @@ void ReplicatedPG::on_local_recover(
   }
 
   if (pg_log.get_missing().is_missing(recovery_info.soid) &&
-      pg_log.get_missing().missing.find(recovery_info.soid)->second.need > recovery_info.version) {
+      pg_log.get_missing().get_items().find(recovery_info.soid)->second.need > recovery_info.version) {
     assert(is_primary());
     const pg_log_entry_t *latest = pg_log.get_log().objects.find(recovery_info.soid)->second;
     if (latest->op == pg_log_entry_t::LOST_REVERT &&
@@ -236,7 +236,7 @@ void ReplicatedPG::on_local_recover(
       requeue_ops(waiting_for_unreadable_object[hoid]);
       waiting_for_unreadable_object.erase(hoid);
     }
-    if (pg_log.get_missing().missing.size() == 0) {
+    if (pg_log.get_missing().get_items().size() == 0) {
       requeue_ops(waiting_for_all_missing);
       waiting_for_all_missing.clear();
     }
@@ -354,7 +354,7 @@ PerfCounters *ReplicatedPG::get_logger()
 
 bool ReplicatedPG::is_missing_object(const hobject_t& soid) const
 {
-  return pg_log.get_missing().missing.count(soid);
+  return pg_log.get_missing().get_items().count(soid);
 }
 
 void ReplicatedPG::maybe_kick_recovery(
@@ -405,7 +405,7 @@ bool ReplicatedPG::is_degraded_or_backfilling_object(const hobject_t& soid)
    */
   if (waiting_for_degraded_object.count(soid))
     return true;
-  if (pg_log.get_missing().missing.count(soid))
+  if (pg_log.get_missing().get_items().count(soid))
     return true;
   assert(!actingbackfill.empty());
   for (set<pg_shard_t>::iterator i = actingbackfill.begin();
@@ -414,7 +414,7 @@ bool ReplicatedPG::is_degraded_or_backfilling_object(const hobject_t& soid)
     if (*i == get_primary()) continue;
     pg_shard_t peer = *i;
     if (peer_missing.count(peer) &&
-       peer_missing[peer].missing.count(soid))
+       peer_missing[peer].get_items().count(soid))
       return true;
 
     // Object is degraded if after last_backfill AND
@@ -848,7 +848,7 @@ int ReplicatedPG::do_command(
 
 bool ReplicatedPG::pg_op_must_wait(MOSDOp *op)
 {
-  if (pg_log.get_missing().missing.empty())
+  if (pg_log.get_missing().get_items().empty())
     return false;
   for (vector<OSDOp>::iterator p = op->ops.begin(); p != op->ops.end(); ++p) {
     if (p->op.op == CEPH_OSD_OP_PGLS || p->op.op == CEPH_OSD_OP_PGNLS ||
@@ -957,18 +957,18 @@ void ReplicatedPG::do_pg_op(OpRequestRef op)
          break;
        }
 
-       assert(snapid == CEPH_NOSNAP || pg_log.get_missing().missing.empty());
+       assert(snapid == CEPH_NOSNAP || pg_log.get_missing().get_items().empty());
 
        // ensure sort order is correct
        pg_log.resort_missing(get_sort_bitwise());
 
        map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator missing_iter =
-         pg_log.get_missing().missing.lower_bound(current);
+         pg_log.get_missing().get_items().lower_bound(current);
        vector<hobject_t>::iterator ls_iter = sentries.begin();
        hobject_t _max = hobject_t::get_max();
        while (1) {
          const hobject_t &mcand =
-           missing_iter == pg_log.get_missing().missing.end() ?
+           missing_iter == pg_log.get_missing().get_items().end() ?
            _max :
            missing_iter->first;
          const hobject_t &lcand =
@@ -1061,7 +1061,7 @@ void ReplicatedPG::do_pg_op(OpRequestRef op)
        }
 
        if (next.is_max() &&
-           missing_iter == pg_log.get_missing().missing.end() &&
+           missing_iter == pg_log.get_missing().get_items().end() &&
            ls_iter == sentries.end()) {
          result = 1;
 
@@ -1144,18 +1144,18 @@ void ReplicatedPG::do_pg_op(OpRequestRef op)
          break;
        }
 
-       assert(snapid == CEPH_NOSNAP || pg_log.get_missing().missing.empty());
+       assert(snapid == CEPH_NOSNAP || pg_log.get_missing().get_items().empty());
 
        // ensure sort order is correct
        pg_log.resort_missing(get_sort_bitwise());
 
        map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator missing_iter =
-         pg_log.get_missing().missing.lower_bound(current);
+         pg_log.get_missing().get_items().lower_bound(current);
        vector<hobject_t>::iterator ls_iter = sentries.begin();
        hobject_t _max = hobject_t::get_max();
        while (1) {
          const hobject_t &mcand =
-           missing_iter == pg_log.get_missing().missing.end() ?
+           missing_iter == pg_log.get_missing().get_items().end() ?
            _max :
            missing_iter->first;
          const hobject_t &lcand =
@@ -1230,7 +1230,7 @@ void ReplicatedPG::do_pg_op(OpRequestRef op)
                                               candidate.get_key()));
        }
        if (next.is_max() &&
-           missing_iter == pg_log.get_missing().missing.end() &&
+           missing_iter == pg_log.get_missing().get_items().end() &&
            ls_iter == sentries.end()) {
          result = 1;
        }
@@ -9490,7 +9490,7 @@ int ReplicatedPG::recover_missing(
        return PULL_NONE;
       } else {
        int r = recover_missing(
-         head, pg_log.get_missing().missing.find(head)->second.need, priority,
+         head, pg_log.get_missing().get_items().find(head)->second.need, priority,
          h);
        if (r != PULL_NONE)
          return PULL_OTHER;
@@ -9504,7 +9504,7 @@ int ReplicatedPG::recover_missing(
        return PULL_NONE;
       } else {
        int r = recover_missing(
-         head, pg_log.get_missing().missing.find(head)->second.need, priority,
+         head, pg_log.get_missing().get_items().find(head)->second.need, priority,
          h);
        if (r != PULL_NONE)
          return PULL_OTHER;
@@ -9705,7 +9705,7 @@ eversion_t ReplicatedPG::pick_newest_available(const hobject_t& oid)
   eversion_t v;
 
   assert(pg_log.get_missing().is_missing(oid));
-  v = pg_log.get_missing().missing.find(oid)->second.have;
+  v = pg_log.get_missing().get_items().find(oid)->second.have;
   dout(10) << "pick_newest_available " << oid << " " << v << " on osd." << osd->whoami << " (local)" << dendl;
 
   assert(!actingbackfill.empty());
@@ -9718,7 +9718,7 @@ eversion_t ReplicatedPG::pick_newest_available(const hobject_t& oid)
       assert(is_backfill_targets(peer));
       continue;
     }
-    eversion_t h = peer_missing[peer].missing[oid].have;
+    eversion_t h = peer_missing[peer].get_items().at(oid).have;
     dout(10) << "pick_newest_available " << oid << " " << h << " on osd." << peer << dendl;
     if (h > v)
       v = h;
@@ -10471,7 +10471,7 @@ bool ReplicatedPG::start_recovery_ops(
   if (missing.num_missing() > 0) {
     // this shouldn't happen!
     osd->clog->error() << info.pgid << " recovery ending with " << missing.num_missing()
-                     << ": " << missing.missing << "\n";
+                      << ": " << missing.get_items() << "\n";
     return work_in_progress;
   }
 
@@ -10528,7 +10528,7 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl
   dout(10) << "recover_primary recovering " << recovering.size()
           << " in pg" << dendl;
   dout(10) << "recover_primary " << missing << dendl;
-  dout(25) << "recover_primary " << missing.missing << dendl;
+  dout(25) << "recover_primary " << missing.get_items() << dendl;
 
   // look at log!
   pg_log_entry_t *latest = 0;
@@ -10537,8 +10537,8 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl
 
   PGBackend::RecoveryHandle *h = pgbackend->open_recovery_op();
   map<version_t, hobject_t>::const_iterator p =
-    missing.rmissing.lower_bound(pg_log.get_log().last_requested);
-  while (p != missing.rmissing.end()) {
+    missing.get_rmissing().lower_bound(pg_log.get_log().last_requested);
+  while (p != missing.get_rmissing().end()) {
     handle.reset_tp_timeout();
     hobject_t soid;
     version_t v = p->first;
@@ -10551,7 +10551,7 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl
       latest = 0;
       soid = p->second;
     }
-    const pg_missing_t::item& item = missing.missing.find(p->second)->second;
+    const pg_missing_t::item& item = missing.get_items().find(p->second)->second;
     ++p;
 
     hobject_t head = soid;
@@ -10629,7 +10629,7 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl
                 p != peer_missing.end();
                 ++p)
              if (p->second.is_missing(soid, need) &&
-                 p->second.missing[soid].have == alternate_need) {
+                 p->second.get_items().at(soid).have == alternate_need) {
                missing_loc.add_location(soid, p->first);
              }
            dout(10) << " will pull " << alternate_need << " or " << need
@@ -10758,12 +10758,12 @@ uint64_t ReplicatedPG::recover_replicas(uint64_t max, ThreadPool::TPHandle &hand
     size_t m_sz = pm->second.num_missing();
 
     dout(10) << " peer osd." << peer << " missing " << m_sz << " objects." << dendl;
-    dout(20) << " peer osd." << peer << " missing " << pm->second.missing << dendl;
+    dout(20) << " peer osd." << peer << " missing " << pm->second.get_items() << dendl;
 
     // oldest first!
     const pg_missing_t &m(pm->second);
-    for (map<version_t, hobject_t>::const_iterator p = m.rmissing.begin();
-          p != m.rmissing.end() && started < max;
+    for (map<version_t, hobject_t>::const_iterator p = m.get_rmissing().begin();
+        p != m.get_rmissing().end() && started < max;
           ++p) {
       handle.reset_tp_timeout();
       const hobject_t soid(p->second);
@@ -10805,7 +10805,7 @@ uint64_t ReplicatedPG::recover_replicas(uint64_t max, ThreadPool::TPHandle &hand
       }
 
       dout(10) << __func__ << ": recover_object_replicas(" << soid << ")" << dendl;
-      map<hobject_t,pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator r = m.missing.find(soid);
+      map<hobject_t,pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator r = m.get_items().find(soid);
       started += prep_object_replica_pushes(soid, r->second.need,
                                            h);
     }

diff --git a/src/osd/osd_types.cc b/src/osd/osd_types.cc
index 58f66d5bc84a2c048645977aa111af14549a814b..8cb98af1fff9bedd59ee8dfaa55b60f4e0982b56 100644 (file)
--- a/src/osd/osd_types.cc
+++ b/src/osd/osd_types.cc
@@ -3957,7 +3957,7 @@ void pg_missing_t::rm(const hobject_t& oid, eversion_t v)
     rm(p);
 }
 
-void pg_missing_t::rm(const std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::iterator &m)
+void pg_missing_t::rm(std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator m)
 {
   rmissing.erase(m->second.need.version);
   missing.erase(m);
@@ -3971,7 +3971,7 @@ void pg_missing_t::got(const hobject_t& oid, eversion_t v)
   got(p);
 }
 
-void pg_missing_t::got(const std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::iterator &m)
+void pg_missing_t::got(std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::iterator m)
 {
   rmissing.erase(m->second.need.version);
   missing.erase(m);

diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index 694232bbb67c8764d9658f3910bf131442f06267..169ee2390a1473b1106f4acf39afa26196835f0c 100644 (file)
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -2744,7 +2744,8 @@ inline ostream& operator<<(ostream& out, const pg_log_t& log)
  *  kept in memory, as a supplement to pg_log_t
  *  also used to pass missing info in messages.
  */
-struct pg_missing_t {
+class pg_missing_t {
+public:
   struct item {
     eversion_t need, have;
     item() {}
@@ -2772,23 +2773,32 @@ struct pg_missing_t {
   }; 
   WRITE_CLASS_ENCODER(item)
 
+private:
   map<hobject_t, item, hobject_t::ComparatorWithDefault> missing;  // oid -> (need v, have v)
   map<version_t, hobject_t> rmissing;  // v -> oid
 
+public:
+  const map<hobject_t, item, hobject_t::ComparatorWithDefault> &get_items() const {
+    return missing;
+  }
+  const map<version_t, hobject_t> &get_rmissing() const {
+    return rmissing;
+  }
   unsigned int num_missing() const;
   bool have_missing() const;
-  void swap(pg_missing_t& o);
   bool is_missing(const hobject_t& oid) const;
   bool is_missing(const hobject_t& oid, eversion_t v) const;
   eversion_t have_old(const hobject_t& oid) const;
+
+  void swap(pg_missing_t& o);
   void add_next_event(const pg_log_entry_t& e);
   void revise_need(hobject_t oid, eversion_t need);
   void revise_have(hobject_t oid, eversion_t have);
   void add(const hobject_t& oid, eversion_t need, eversion_t have);
   void rm(const hobject_t& oid, eversion_t v);
-  void rm(const std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::iterator &m);
+  void rm(std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator m);
   void got(const hobject_t& oid, eversion_t v);
-  void got(const std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::iterator &m);
+  void got(std::map<hobject_t, pg_missing_t::item, hobject_t::ComparatorWithDefault>::const_iterator m);
   void split_into(pg_t child_pgid, unsigned split_bits, pg_missing_t *omissing);
 
   void clear() {

diff --git a/src/test/osd/TestPGLog.cc b/src/test/osd/TestPGLog.cc
index f92cbe313004a480a53505f1c0f523ab8f295a39..8f39c1111a259da3367a411cd569be1bfdb0ed76 100644 (file)
--- a/src/test/osd/TestPGLog.cc
+++ b/src/test/osd/TestPGLog.cc
@@ -123,10 +123,10 @@ public:
       fulldiv.tail = divinfo.log_tail;
       divinfo.last_backfill = hobject_t::get_max();
 
-      if (init.missing.empty()) {
+      if (init.get_items().empty()) {
        divinfo.last_complete = divinfo.last_update;
       } else {
-       eversion_t fmissing = init.missing[init.rmissing.begin()->second].need;
+       eversion_t fmissing = init.get_items().at(init.get_rmissing().begin()->second).need;
        for (list<pg_log_entry_t>::const_iterator i = fulldiv.log.begin();
             i != fulldiv.log.end();
             ++i) {
@@ -176,14 +176,13 @@ public:
   void verify_missing(
     const TestCase &tcase,
     const pg_missing_t &missing) {
-    ASSERT_EQ(tcase.final.missing.size(), missing.missing.size());
-    for (map<hobject_t, pg_missing_t::item>::const_iterator i =
-          missing.missing.begin();
-        i != missing.missing.end();
+    ASSERT_EQ(tcase.final.get_items().size(), missing.get_items().size());
+    for (auto i = missing.get_items().begin();
+        i != missing.get_items().end();
         ++i) {
-      EXPECT_TRUE(tcase.final.missing.count(i->first));
-      EXPECT_EQ(tcase.final.missing.find(i->first)->second.need, i->second.need);
-      EXPECT_EQ(tcase.final.missing.find(i->first)->second.have, i->second.have);
+      EXPECT_TRUE(tcase.final.get_items().count(i->first));
+      EXPECT_EQ(tcase.final.get_items().find(i->first)->second.need, i->second.need);
+      EXPECT_EQ(tcase.final.get_items().find(i->first)->second.have, i->second.have);
     }
   }
 
@@ -1515,7 +1514,7 @@ TEST_F(PGLogTest, proc_replica_log) {
     EXPECT_TRUE(t.empty());
     EXPECT_TRUE(omissing.have_missing());
     EXPECT_TRUE(omissing.is_missing(divergent_object));
-    EXPECT_EQ(eversion_t(1, 2), omissing.missing[divergent_object].need);
+    EXPECT_EQ(eversion_t(1, 2), omissing.get_items().at(divergent_object).need);
     EXPECT_EQ(eversion_t(1, 6), oinfo.last_update);
     EXPECT_EQ(eversion_t(1, 1), oinfo.last_complete);
   }
@@ -1604,8 +1603,8 @@ TEST_F(PGLogTest, proc_replica_log) {
     EXPECT_TRUE(t.empty());
     EXPECT_TRUE(omissing.have_missing());
     EXPECT_TRUE(omissing.is_missing(divergent_object));
-    EXPECT_EQ(omissing.missing[divergent_object].have, eversion_t(0, 0));
-    EXPECT_EQ(omissing.missing[divergent_object].need, eversion_t(1, 1));
+    EXPECT_EQ(omissing.get_items().at(divergent_object).have, eversion_t(0, 0));
+    EXPECT_EQ(omissing.get_items().at(divergent_object).need, eversion_t(1, 1));
     EXPECT_EQ(last_update, oinfo.last_update);
   }
 
@@ -1687,7 +1686,7 @@ TEST_F(PGLogTest, proc_replica_log) {
     EXPECT_TRUE(t.empty());
     EXPECT_TRUE(omissing.have_missing());
     EXPECT_TRUE(omissing.is_missing(divergent_object));
-    EXPECT_EQ(eversion_t(1, 3), omissing.missing[divergent_object].need);
+    EXPECT_EQ(eversion_t(1, 3), omissing.get_items().at(divergent_object).need);
     EXPECT_EQ(olog.head, oinfo.last_update);
     EXPECT_EQ(olog.head, oinfo.last_complete);
 
@@ -1696,8 +1695,8 @@ TEST_F(PGLogTest, proc_replica_log) {
     EXPECT_TRUE(t.empty());
     EXPECT_TRUE(omissing.have_missing());
     EXPECT_TRUE(omissing.is_missing(divergent_object));
-    EXPECT_EQ(omissing.missing[divergent_object].have, eversion_t(0, 0));
-    EXPECT_EQ(omissing.missing[divergent_object].need, eversion_t(1, 1));
+    EXPECT_EQ(omissing.get_items().at(divergent_object).have, eversion_t(0, 0));
+    EXPECT_EQ(omissing.get_items().at(divergent_object).need, eversion_t(1, 1));
     EXPECT_EQ(last_update, oinfo.last_update);
   }
 
@@ -1783,7 +1782,7 @@ TEST_F(PGLogTest, proc_replica_log) {
     EXPECT_TRUE(t.empty());
     EXPECT_TRUE(omissing.have_missing());
     EXPECT_TRUE(omissing.is_missing(divergent_object));
-    EXPECT_EQ(divergent_version, omissing.missing[divergent_object].need);
+    EXPECT_EQ(divergent_version, omissing.get_items().at(divergent_object).need);
     EXPECT_EQ(olog.head, oinfo.last_update);
     EXPECT_EQ(olog.head, oinfo.last_complete);
 
@@ -1791,7 +1790,7 @@ TEST_F(PGLogTest, proc_replica_log) {
 
     EXPECT_TRUE(t.empty());
     EXPECT_TRUE(omissing.have_missing());
-    EXPECT_TRUE(omissing.missing.begin()->second.need == eversion_t(1, 1));
+    EXPECT_TRUE(omissing.get_items().begin()->second.need == eversion_t(1, 1));
     EXPECT_EQ(last_update, oinfo.last_update);
     EXPECT_EQ(eversion_t(0, 0), oinfo.last_complete);
   }

diff --git a/src/test/osd/types.cc b/src/test/osd/types.cc
index ade7dd1a4411e12b55499df6595ccd7a4d7e836b..3d24d9823698390429f6e5c83867a6db7491c644 100644 (file)
--- a/src/test/osd/types.cc
+++ b/src/test/osd/types.cc
@@ -824,16 +824,16 @@ TEST(pg_missing_t, add_next_event)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add_next_event(e);
     EXPECT_TRUE(missing.is_missing(oid));
-    EXPECT_EQ(eversion_t(), missing.missing[oid].have);
-    EXPECT_EQ(oid, missing.rmissing[e.version.version]);
+    EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have);
+    EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
 
     // adding the same object replaces the previous one
     missing.add_next_event(e);
     EXPECT_TRUE(missing.is_missing(oid));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
   }
 
   // new object (CLONE)
@@ -849,16 +849,16 @@ TEST(pg_missing_t, add_next_event)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add_next_event(e);
     EXPECT_TRUE(missing.is_missing(oid));
-    EXPECT_EQ(eversion_t(), missing.missing[oid].have);
-    EXPECT_EQ(oid, missing.rmissing[e.version.version]);
+    EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have);
+    EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
 
     // adding the same object replaces the previous one
     missing.add_next_event(e);
     EXPECT_TRUE(missing.is_missing(oid));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
   }
 
   // existing object (MODIFY)
@@ -874,18 +874,18 @@ TEST(pg_missing_t, add_next_event)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add_next_event(e);
     EXPECT_TRUE(missing.is_missing(oid));
-    EXPECT_EQ(eversion_t(), missing.missing[oid].have);
-    EXPECT_EQ(oid, missing.rmissing[e.version.version]);
+    EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have);
+    EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
 
     // adding the same object with a different version
     e.prior_version = prior_version;
     missing.add_next_event(e);
-    EXPECT_EQ(eversion_t(), missing.missing[oid].have);
+    EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have);
     EXPECT_TRUE(missing.is_missing(oid));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
   }
 
   // object with prior version (MODIFY)
@@ -900,11 +900,11 @@ TEST(pg_missing_t, add_next_event)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add_next_event(e);
     EXPECT_TRUE(missing.is_missing(oid));
-    EXPECT_EQ(prior_version, missing.missing[oid].have);
-    EXPECT_EQ(version, missing.missing[oid].need);
-    EXPECT_EQ(oid, missing.rmissing[e.version.version]);
+    EXPECT_EQ(prior_version, missing.get_items().at(oid).have);
+    EXPECT_EQ(version, missing.get_items().at(oid).need);
+    EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version));
     EXPECT_EQ(1U, missing.num_missing());
-    EXPECT_EQ(1U, missing.rmissing.size());
+    EXPECT_EQ(1U, missing.get_rmissing().size());
   }
 
   // obsolete (BACKLOG)
@@ -965,7 +965,7 @@ TEST(pg_missing_t, add_next_event)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add_next_event(modify);
     EXPECT_TRUE(missing.is_missing(oid));
-    EXPECT_EQ(missing.missing[oid].need, version);
+    EXPECT_EQ(missing.get_items().at(oid).need, version);
 
     pg_log_entry_t error = sample_e;
     error.op = pg_log_entry_t::ERROR;
@@ -973,7 +973,7 @@ TEST(pg_missing_t, add_next_event)
     error.version = eversion_t(11, 5);
     missing.add_next_event(error);
     EXPECT_TRUE(missing.is_missing(oid));
-    EXPECT_EQ(missing.missing[oid].need, version);
+    EXPECT_EQ(missing.get_items().at(oid).need, version);
   }
 }
 
@@ -986,16 +986,16 @@ TEST(pg_missing_t, revise_need)
   eversion_t need(10,10);
   missing.revise_need(oid, need);
   EXPECT_TRUE(missing.is_missing(oid));
-  EXPECT_EQ(eversion_t(), missing.missing[oid].have);
-  EXPECT_EQ(need, missing.missing[oid].need);
+  EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have);
+  EXPECT_EQ(need, missing.get_items().at(oid).need);
   // update an existing entry and preserve have
   eversion_t have(1,1);
   missing.revise_have(oid, have);
   eversion_t new_need(10,12);
-  EXPECT_EQ(have, missing.missing[oid].have);
+  EXPECT_EQ(have, missing.get_items().at(oid).have);
   missing.revise_need(oid, new_need);
-  EXPECT_EQ(have, missing.missing[oid].have);
-  EXPECT_EQ(new_need, missing.missing[oid].need);
+  EXPECT_EQ(have, missing.get_items().at(oid).have);
+  EXPECT_EQ(new_need, missing.get_items().at(oid).need);
 }
 
 TEST(pg_missing_t, revise_have)
@@ -1012,10 +1012,10 @@ TEST(pg_missing_t, revise_have)
   missing.add(oid, need, have);
   EXPECT_TRUE(missing.is_missing(oid));
   eversion_t new_have(2,2);
-  EXPECT_EQ(have, missing.missing[oid].have);
+  EXPECT_EQ(have, missing.get_items().at(oid).have);
   missing.revise_have(oid, new_have);
-  EXPECT_EQ(new_have, missing.missing[oid].have);
-  EXPECT_EQ(need, missing.missing[oid].need);
+  EXPECT_EQ(new_have, missing.get_items().at(oid).have);
+  EXPECT_EQ(need, missing.get_items().at(oid).need);
 }
 
 TEST(pg_missing_t, add)
@@ -1027,8 +1027,8 @@ TEST(pg_missing_t, add)
   eversion_t need(10,10);
   missing.add(oid, need, have);
   EXPECT_TRUE(missing.is_missing(oid));
-  EXPECT_EQ(have, missing.missing[oid].have);
-  EXPECT_EQ(need, missing.missing[oid].need);
+  EXPECT_EQ(have, missing.get_items().at(oid).have);
+  EXPECT_EQ(need, missing.get_items().at(oid).need);
 }
 
 TEST(pg_missing_t, rm)
@@ -1056,7 +1056,7 @@ TEST(pg_missing_t, rm)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add(oid, eversion_t(), eversion_t());
     EXPECT_TRUE(missing.is_missing(oid));
-    const std::map<hobject_t, pg_missing_t::item>::iterator m = missing.missing.find(oid);
+    auto m = missing.get_items().find(oid);
     missing.rm(m);
     EXPECT_FALSE(missing.is_missing(oid));
   }
@@ -1088,7 +1088,7 @@ TEST(pg_missing_t, got)
     EXPECT_FALSE(missing.is_missing(oid));
     missing.add(oid, eversion_t(), eversion_t());
     EXPECT_TRUE(missing.is_missing(oid));
-    const std::map<hobject_t, pg_missing_t::item>::iterator m = missing.missing.find(oid);
+    auto m = missing.get_items().find(oid);
     missing.got(m);
     EXPECT_FALSE(missing.is_missing(oid));
   }