PG,PGLog: convert to DoutPrefixProviders

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

diff --git a/src/osd/PG.h b/src/osd/PG.h
index 3f64adbf87d44d61994e7e0a61994d25ac7548a9..e0543cc2a24748e030dcde03b8e93e429d73e5e2 100644 (file)
--- a/src/osd/PG.h
+++ b/src/osd/PG.h
@@ -185,11 +185,7 @@ struct PGPool {
  *
  */
 
-class PG {
-public:
-  std::string gen_prefix() const;
-
-  /*** PG ****/
+class PG : DoutPrefixProvider {
 protected:
   OSDService *osd;
   CephContext *cct;
@@ -198,6 +194,11 @@ protected:
 
   virtual PGBackend *get_pgbackend() = 0;
 public:
+  std::string gen_prefix() const;
+  CephContext *get_cct() const { return cct; }
+  unsigned get_subsys() const { return ceph_subsys_osd; }
+
+  /*** PG ****/
   void update_snap_mapper_bits(uint32_t bits) {
     snap_mapper.update_bits(bits);
   }

diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc
index 5165c52a2e00ef3f3f98b752a7d7f48426eb6b4a..f1eb53c6cc775c40595d65f17761dee6a8fe0d37 100644 (file)
--- a/src/osd/PGLog.cc
+++ b/src/osd/PGLog.cc
@@ -21,6 +21,13 @@
 #include "../include/unordered_map.h"
 
 #define dout_subsys ceph_subsys_osd
+#undef dout_prefix
+#define dout_prefix _prefix(_dout, this)
+
+static ostream& _prefix(std::ostream *_dout, const PGLog *pglog)
+{
+  return *_dout << pglog->gen_prefix();
+}
 
 //////////////////// PGLog::IndexedLog ////////////////////
 
@@ -277,7 +284,8 @@ void PGLog::proc_replica_log(
     olog.can_rollback_to,
     omissing,
     0,
-    0);
+    0,
+    this);
 
   if (lu < oinfo.last_update) {
     dout(10) << " peer osd." << from << " last_update now " << lu << dendl;
@@ -330,15 +338,16 @@ void PGLog::_merge_object_divergent_entries(
   eversion_t olog_can_rollback_to,
   pg_missing_t &missing,
   boost::optional<pair<eversion_t, hobject_t> > *new_divergent_prior,
-  LogEntryHandler *rollbacker
+  LogEntryHandler *rollbacker,
+  const DoutPrefixProvider *dpp
   )
 {
-  dout(10) << __func__ << ": merging hoid " << hoid
-          << " entries: " << entries << dendl;
+  ldpp_dout(dpp, 20) << __func__ << ": merging hoid " << hoid
+                    << " entries: " << entries << dendl;
 
   if (cmp(hoid, info.last_backfill, info.last_backfill_bitwise) > 0) {
-    dout(10) << __func__ << ": hoid " << hoid << " after last_backfill"
-            << dendl;
+    ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid << " after last_backfill"
+                      << dendl;
     return;
   }
 
@@ -368,11 +377,11 @@ void PGLog::_merge_object_divergent_entries(
   const bool object_not_in_store =
     !missing.is_missing(hoid) &&
     entries.rbegin()->is_delete();
-  dout(10) << __func__ << ": hoid " << hoid
-          << " prior_version: " << prior_version
-          << " first_divergent_update: " << first_divergent_update
-          << " last_divergent_update: " << last_divergent_update
-          << dendl;
+  ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                    << " prior_version: " << prior_version
+                    << " first_divergent_update: " << first_divergent_update
+                    << " last_divergent_update: " << last_divergent_update
+                    << dendl;
 
   ceph::unordered_map<hobject_t, pg_log_entry_t*>::const_iterator objiter =
     log.objects.find(hoid);
@@ -381,8 +390,8 @@ void PGLog::_merge_object_divergent_entries(
     /// Case 1)
     assert(objiter->second->version > last_divergent_update);
 
-    dout(10) << __func__ << ": more recent entry found: "
-            << *objiter->second << ", already merged" << dendl;
+    ldpp_dout(dpp, 10) << __func__ << ": more recent entry found: "
+                      << *objiter->second << ", already merged" << dendl;
 
     // ensure missing has been updated appropriately
     if (objiter->second->is_update()) {
@@ -397,13 +406,14 @@ void PGLog::_merge_object_divergent_entries(
     return;
   }
 
-  dout(10) << __func__ << ": hoid " << hoid
-          <<" has no more recent entries in log" << dendl;
+  ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                    <<" has no more recent entries in log" << dendl;
   if (prior_version == eversion_t() || entries.front().is_clone()) {
     /// Case 2)
-    dout(10) << __func__ << ": hoid " << hoid
-            << " prior_version or op type indicates creation, deleting"
-            << dendl;
+    ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                      << " prior_version or op type indicates creation,"
+                      << " deleting"
+                      << dendl;
     if (missing.is_missing(hoid))
       missing.rm(missing.missing.find(hoid));
     if (rollbacker && !object_not_in_store)
@@ -413,24 +423,25 @@ void PGLog::_merge_object_divergent_entries(
 
   if (missing.is_missing(hoid)) {
     /// Case 3)
-    dout(10) << __func__ << ": hoid " << hoid
-            << " missing, " << missing.missing[hoid]
-            << " adjusting" << dendl;
+    ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                      << " missing, " << missing.missing[hoid]
+                      << " adjusting" << dendl;
 
     if (missing.missing[hoid].have == prior_version) {
-      dout(10) << __func__ << ": hoid " << hoid
+      ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
               << " missing.have is prior_version " << prior_version
               << " removing from missing" << dendl;
       missing.rm(missing.missing.find(hoid));
     } else {
-      dout(10) << __func__ << ": hoid " << hoid
-              << " missing.have is " << missing.missing[hoid].have
-              << ", adjusting" << dendl;
+      ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                        << " missing.have is " << missing.missing[hoid].have
+                        << ", adjusting" << dendl;
       missing.revise_need(hoid, prior_version);
       if (prior_version <= info.log_tail) {
-       dout(10) << __func__ << ": hoid " << hoid
-                << " prior_version " << prior_version << " <= info.log_tail "
-                << info.log_tail << dendl;
+       ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                          << " prior_version " << prior_version
+                          << " <= info.log_tail "
+                          << info.log_tail << dendl;
        if (new_divergent_prior)
          *new_divergent_prior = make_pair(prior_version, hoid);
       }
@@ -438,17 +449,18 @@ void PGLog::_merge_object_divergent_entries(
     return;
   }
 
-  dout(10) << __func__ << ": hoid " << hoid
-          << " must be rolled back or recovered, attempting to rollback"
-          << dendl;
+  ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                    << " must be rolled back or recovered,"
+                    << " attempting to rollback"
+                    << dendl;
   bool can_rollback = true;
   /// Distinguish between 4) and 5)
   for (list<pg_log_entry_t>::const_reverse_iterator i = entries.rbegin();
        i != entries.rend();
        ++i) {
     if (!i->mod_desc.can_rollback() || i->version <= olog_can_rollback_to) {
-      dout(10) << __func__ << ": hoid " << hoid << " cannot rollback "
-              << *i << dendl;
+      ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid << " cannot rollback "
+                        << *i << dendl;
       can_rollback = false;
       break;
     }
@@ -460,24 +472,26 @@ void PGLog::_merge_object_divergent_entries(
         i != entries.rend();
         ++i) {
       assert(i->mod_desc.can_rollback() && i->version > olog_can_rollback_to);
-      dout(10) << __func__ << ": hoid " << hoid
-              << " rolling back " << *i << dendl;
+      ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                        << " rolling back " << *i << dendl;
       if (rollbacker)
        rollbacker->rollback(*i);
     }
-    dout(10) << __func__ << ": hoid " << hoid << " rolled back" << dendl;
+    ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                      << " rolled back" << dendl;
     return;
   } else {
     /// Case 5)
-    dout(10) << __func__ << ": hoid " << hoid << " cannot roll back, "
-            << "removing and adding to missing" << dendl;
+    ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid << " cannot roll back, "
+                      << "removing and adding to missing" << dendl;
     if (rollbacker && !object_not_in_store)
       rollbacker->remove(hoid);
     missing.add(hoid, prior_version, eversion_t());
     if (prior_version <= info.log_tail) {
-      dout(10) << __func__ << ": hoid " << hoid
-              << " prior_version " << prior_version << " <= info.log_tail "
-              << info.log_tail << dendl;
+      ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
+                        << " prior_version " << prior_version
+                        << " <= info.log_tail "
+                        << info.log_tail << dendl;
       if (new_divergent_prior)
        *new_divergent_prior = make_pair(prior_version, hoid);
     }
@@ -537,7 +551,8 @@ void PGLog::rewind_divergent_log(ObjectStore::Transaction& t, eversion_t newhead
     log.can_rollback_to,
     missing,
     &new_priors,
-    rollbacker);
+    rollbacker,
+    this);
   for (map<eversion_t, hobject_t>::iterator i = new_priors.begin();
        i != new_priors.end();
        ++i) {
@@ -690,7 +705,8 @@ void PGLog::merge_log(ObjectStore::Transaction& t,
       log.can_rollback_to,
       missing,
       &new_priors,
-      rollbacker);
+      rollbacker,
+      this);
     for (map<eversion_t, hobject_t>::iterator i = new_priors.begin();
         i != new_priors.end();
         ++i) {
@@ -874,15 +890,17 @@ void PGLog::_write_log(
 
 void PGLog::read_log(ObjectStore *store, coll_t pg_coll,
                     coll_t log_coll,
-                   ghobject_t log_oid,
-                   const pg_info_t &info,
-                   map<eversion_t, hobject_t> &divergent_priors,
-                   IndexedLog &log,
-                   pg_missing_t &missing,
-                   ostringstream &oss,
-                   set<string> *log_keys_debug)
+                    ghobject_t log_oid,
+                    const pg_info_t &info,
+                    map<eversion_t, hobject_t> &divergent_priors,
+                    IndexedLog &log,
+                    pg_missing_t &missing,
+                    ostringstream &oss,
+                    const DoutPrefixProvider *dpp,
+                    set<string> *log_keys_debug)
 {
-  dout(20) << "read_log coll " << pg_coll << " log_oid " << log_oid << dendl;
+  ldpp_dout(dpp, 20) << "read_log coll " << pg_coll
+                    << " log_oid " << log_oid << dendl;
 
   // legacy?
   struct stat st;
@@ -903,25 +921,26 @@ void PGLog::read_log(ObjectStore *store, coll_t pg_coll,
       bufferlist bl = p->value();//Copy bufferlist before creating iterator
       bufferlist::iterator bp = bl.begin();
       if (p->key() == "divergent_priors") {
-        ::decode(divergent_priors, bp);
-        dout(20) << "read_log " << divergent_priors.size() << " divergent_priors" << dendl;
+       ::decode(divergent_priors, bp);
+       ldpp_dout(dpp, 20) << "read_log " << divergent_priors.size()
+                          << " divergent_priors" << dendl;
       } else if (p->key() == "can_rollback_to") {
         ::decode(log.can_rollback_to, bp);
       } else if (p->key() == "rollback_info_trimmed_to") {
         ::decode(log.rollback_info_trimmed_to, bp);
       } else {
-        pg_log_entry_t e;
-        e.decode_with_checksum(bp);
-        dout(20) << "read_log " << e << dendl;
-        if (!log.log.empty()) {
-          pg_log_entry_t last_e(log.log.back());
-          assert(last_e.version.version < e.version.version);
-          assert(last_e.version.epoch <= e.version.epoch);
-        }
-        log.log.push_back(e);
-        log.head = e.version;
-        if (log_keys_debug)
-          log_keys_debug->insert(e.get_key_name());
+       pg_log_entry_t e;
+       e.decode_with_checksum(bp);
+       ldpp_dout(dpp, 20) << "read_log " << e << dendl;
+       if (!log.log.empty()) {
+         pg_log_entry_t last_e(log.log.back());
+         assert(last_e.version.version < e.version.version);
+         assert(last_e.version.epoch <= e.version.epoch);
+       }
+       log.log.push_back(e);
+       log.head = e.version;
+       if (log_keys_debug)
+         log_keys_debug->insert(e.get_key_name());
       }
     }
   }
@@ -930,8 +949,9 @@ void PGLog::read_log(ObjectStore *store, coll_t pg_coll,
 
   // build missing
   if (info.last_complete < info.last_update) {
-    dout(10) << "read_log checking for missing items over interval (" << info.last_complete
-            << "," << info.last_update << "]" << dendl;
+    ldpp_dout(dpp, 10) << "read_log checking for missing items over interval ("
+                      << info.last_complete
+                      << "," << info.last_update << "]" << dendl;
 
     set<hobject_t, hobject_t::BitwiseComparator> did;
     for (list<pg_log_entry_t>::reverse_iterator i = log.log.rbegin();
@@ -954,11 +974,12 @@ void PGLog::read_log(ObjectStore *store, coll_t pg_coll,
       if (r >= 0) {
        object_info_t oi(bv);
        if (oi.version < i->version) {
-         dout(15) << "read_log  missing " << *i << " (have " << oi.version << ")" << dendl;
+         ldpp_dout(dpp, 15) << "read_log  missing " << *i
+                            << " (have " << oi.version << ")" << dendl;
          missing.add(i->soid, i->version, oi.version);
        }
       } else {
-       dout(15) << "read_log  missing " << *i << dendl;
+       ldpp_dout(dpp, 15) << "read_log  missing " << *i << dendl;
        missing.add(i->soid, i->version, eversion_t());
       }
     }
@@ -992,11 +1013,11 @@ void PGLog::read_log(ObjectStore *store, coll_t pg_coll,
         */
        assert(oi.version == i->first);
       } else {
-       dout(15) << "read_log  missing " << *i << dendl;
+       ldpp_dout(dpp, 15) << "read_log  missing " << *i << dendl;
        missing.add(i->second, i->first, eversion_t());
       }
     }
   }
-  dout(10) << "read_log done" << dendl;
+  ldpp_dout(dpp, 10) << "read_log done" << dendl;
 }
 

diff --git a/src/osd/PGLog.h b/src/osd/PGLog.h
index 3a9b6979125a226229eaa9fb4a01de3f03cbb3f2..d4025618009134b86b618cc07f5f1778f34f71c6 100644 (file)
--- a/src/osd/PGLog.h
+++ b/src/osd/PGLog.h
@@ -30,7 +30,18 @@ using namespace std;
 #define PGLOG_INDEXED_EXTRA_CALLER_OPS (1 << 2)
 #define PGLOG_INDEXED_ALL              (PGLOG_INDEXED_OBJECTS | PGLOG_INDEXED_CALLER_OPS | PGLOG_INDEXED_EXTRA_CALLER_OPS)
 
-struct PGLog {
+struct PGLog : DoutPrefixProvider {
+  DoutPrefixProvider *prefix_provider;
+  string gen_prefix() const {
+    return prefix_provider ? prefix_provider->gen_prefix() : "";
+  }
+  unsigned get_subsys() const {
+    return prefix_provider ? prefix_provider->get_subsys() : ceph_subsys_osd;
+  }
+  CephContext *get_cct() const {
+    return cct;
+  }
+
   ////////////////////////////// sub classes //////////////////////////////
   struct LogEntryHandler {
     virtual void rollback(
@@ -479,7 +490,8 @@ protected:
   }
 public:
   // cppcheck-suppress noExplicitConstructor
-  PGLog(CephContext *cct = 0) :
+  PGLog(CephContext *cct, DoutPrefixProvider *dpp = 0) :
+    prefix_provider(dpp),
     dirty_from(eversion_t::max()),
     writeout_from(eversion_t::max()), 
     cct(cct), 
@@ -679,7 +691,8 @@ protected:
     eversion_t olog_can_rollback_to,     ///< [in] rollback boundary
     pg_missing_t &omissing,              ///< [in,out] missing to adjust, use
     boost::optional<pair<eversion_t, hobject_t> > *new_divergent_prior,
-    LogEntryHandler *rollbacker          ///< [in] optional rollbacker object
+    LogEntryHandler *rollbacker,         ///< [in] optional rollbacker object
+    const DoutPrefixProvider *dpp        ///< [in] logging provider
     );
 
   /// Merge all entries using above
@@ -690,7 +703,8 @@ protected:
     eversion_t olog_can_rollback_to,     ///< [in] rollback boundary
     pg_missing_t &omissing,              ///< [in,out] missing to adjust, use
     map<eversion_t, hobject_t> *priors,  ///< [out] target for new priors
-    LogEntryHandler *rollbacker          ///< [in] optional rollbacker object
+    LogEntryHandler *rollbacker,         ///< [in] optional rollbacker object
+    const DoutPrefixProvider *dpp        ///< [in] logging provider
     ) {
     map<hobject_t, list<pg_log_entry_t>, hobject_t::BitwiseComparator > split;
     split_by_object(entries, &split);
@@ -706,7 +720,8 @@ protected:
        olog_can_rollback_to,
        omissing,
        &new_divergent_prior,
-       rollbacker);
+       rollbacker,
+       dpp);
       if (priors && new_divergent_prior) {
        (*priors)[new_divergent_prior->first] = new_divergent_prior->second;
       }
@@ -733,7 +748,8 @@ protected:
       log.can_rollback_to,
       missing,
       &new_divergent_prior,
-      rollbacker);
+      rollbacker,
+      this);
     if (new_divergent_prior)
       add_divergent_prior(
        (*new_divergent_prior).first,
@@ -785,6 +801,7 @@ public:
     return read_log(
       store, pg_coll, log_coll, log_oid, info, divergent_priors,
       log, missing, oss,
+      this,
       (pg_log_debug ? &log_keys_debug : 0));
   }
 
@@ -793,6 +810,7 @@ public:
     const pg_info_t &info, map<eversion_t, hobject_t> &divergent_priors,
     IndexedLog &log,
     pg_missing_t &missing, ostringstream &oss,
+    const DoutPrefixProvider *dpp = NULL,
     set<string> *log_keys_debug = 0
     );
 };

diff --git a/src/test/osd/TestPGLog.cc b/src/test/osd/TestPGLog.cc
index f3c61211bb229d8b8d8b1a7b5b689ac12137f172..336c34e204547ceb8005899008487bafc70a7d4c 100644 (file)
--- a/src/test/osd/TestPGLog.cc
+++ b/src/test/osd/TestPGLog.cc
@@ -29,6 +29,7 @@
 
 class PGLogTest : public ::testing::Test, protected PGLog {
 public:
+  PGLogTest() : PGLog(g_ceph_context) {}
   virtual void SetUp() { }
 
   virtual void TearDown() {