journal: track commit position for each object splay offset

It's possible, when delaying appends to the journal, that the
current commit position might be in object set X while future
events for a different offset might be in an object set < X.

Signed-off-by: Jason Dillaman <dillaman@redhat.com>

diff --git a/src/cls/journal/cls_journal.cc b/src/cls/journal/cls_journal.cc
index f87c2b2ad8af5c6845fad800bfddc65cf0700a19..632359b677502e438569f8df2f131d9aefec2d43 100644 (file)
--- a/src/cls/journal/cls_journal.cc
+++ b/src/cls/journal/cls_journal.cc
@@ -151,13 +151,8 @@ int expire_tags(cls_method_context_t hctx, const std::string *skip_client_id) {
         return -EIO;
       }
 
-      // cannot expire tags if a client hasn't committed yet
-      if (client.commit_position.entry_positions.empty()) {
-        return 0;
-      }
-
-      for (auto entry_position : client.commit_position.entry_positions) {
-        minimum_tag_tid = MIN(minimum_tag_tid, entry_position.tag_tid);
+      for (auto object_position : client.commit_position.object_positions) {
+        minimum_tag_tid = MIN(minimum_tag_tid, object_position.tag_tid);
       }
     }
     if (!vals.empty()) {
@@ -165,6 +160,11 @@ int expire_tags(cls_method_context_t hctx, const std::string *skip_client_id) {
     }
   } while (r == MAX_KEYS_READ);
 
+  // cannot expire tags if a client hasn't committed yet
+  if (minimum_tag_tid == std::numeric_limits<uint64_t>::max()) {
+    return 0;
+  }
+
   // compute the minimum in-use tag for each class
   std::map<uint64_t, uint64_t> minimum_tag_class_to_tids;
   typedef enum { TAG_PASS_CALCULATE_MINIMUMS,
@@ -665,8 +665,8 @@ int journal_client_commit(cls_method_context_t hctx, bufferlist *in,
   if (r < 0) {
     return r;
   }
-  if (commit_position.entry_positions.size() > splay_width) {
-    CLS_ERR("too many entry positions");
+  if (commit_position.object_positions.size() > splay_width) {
+    CLS_ERR("too many object positions");
     return -EINVAL;
   }
 
@@ -918,8 +918,8 @@ int journal_tag_list(cls_method_context_t hctx, bufferlist *in,
     return r;
   }
 
-  for (auto entry_position : client.commit_position.entry_positions) {
-    minimum_tag_tid = MIN(minimum_tag_tid, entry_position.tag_tid);
+  for (auto object_position : client.commit_position.object_positions) {
+    minimum_tag_tid = MIN(minimum_tag_tid, object_position.tag_tid);
   }
 
   // compute minimum tags in use per-class
@@ -928,7 +928,7 @@ int journal_tag_list(cls_method_context_t hctx, bufferlist *in,
   typedef enum { TAG_PASS_CALCULATE_MINIMUMS,
                  TAG_PASS_LIST,
                  TAG_PASS_DONE } TagPass;
-  int tag_pass = (client.commit_position.entry_positions.empty() ?
+  int tag_pass = (minimum_tag_tid == std::numeric_limits<uint64_t>::max() ?
     TAG_PASS_LIST : TAG_PASS_CALCULATE_MINIMUMS);
   std::string last_read = HEADER_KEY_TAG_PREFIX;
   do {

diff --git a/src/cls/journal/cls_journal_types.cc b/src/cls/journal/cls_journal_types.cc
index 9d8af00957a9d4595662d825ce3e3a17fee7bb77..d686a5049b3276fd034de00f8e89e8eff320da2d 100644 (file)
--- a/src/cls/journal/cls_journal_types.cc
+++ b/src/cls/journal/cls_journal_types.cc
@@ -7,51 +7,50 @@
 namespace cls {
 namespace journal {
 
-void EntryPosition::encode(bufferlist& bl) const {
+void ObjectPosition::encode(bufferlist& bl) const {
   ENCODE_START(1, 1, bl);
+  ::encode(object_number, bl);
   ::encode(tag_tid, bl);
   ::encode(entry_tid, bl);
   ENCODE_FINISH(bl);
 }
 
-void EntryPosition::decode(bufferlist::iterator& iter) {
+void ObjectPosition::decode(bufferlist::iterator& iter) {
   DECODE_START(1, iter);
+  ::decode(object_number, iter);
   ::decode(tag_tid, iter);
   ::decode(entry_tid, iter);
   DECODE_FINISH(iter);
 }
 
-void EntryPosition::dump(Formatter *f) const {
+void ObjectPosition::dump(Formatter *f) const {
+  f->dump_unsigned("object_number", object_number);
   f->dump_unsigned("tag_tid", tag_tid);
   f->dump_unsigned("entry_tid", entry_tid);
 }
 
-void EntryPosition::generate_test_instances(std::list<EntryPosition *> &o) {
-  o.push_back(new EntryPosition());
-  o.push_back(new EntryPosition(1, 2));
+void ObjectPosition::generate_test_instances(std::list<ObjectPosition *> &o) {
+  o.push_back(new ObjectPosition());
+  o.push_back(new ObjectPosition(1, 2, 3));
 }
 
 void ObjectSetPosition::encode(bufferlist& bl) const {
   ENCODE_START(1, 1, bl);
-  ::encode(object_number, bl);
-  ::encode(entry_positions, bl);
+  ::encode(object_positions, bl);
   ENCODE_FINISH(bl);
 }
 
 void ObjectSetPosition::decode(bufferlist::iterator& iter) {
   DECODE_START(1, iter);
-  ::decode(object_number, iter);
-  ::decode(entry_positions, iter);
+  ::decode(object_positions, iter);
   DECODE_FINISH(iter);
 }
 
 void ObjectSetPosition::dump(Formatter *f) const {
-  f->dump_unsigned("object_number", object_number);
-  f->open_array_section("entry_positions");
-  for (EntryPositions::const_iterator it = entry_positions.begin();
-       it != entry_positions.end(); ++it) {
-    f->open_object_section("entry_position");
-    it->dump(f);
+  f->open_array_section("object_positions");
+  for (auto &pos : object_positions) {
+    f->open_object_section("object_position");
+    pos.dump(f);
     f->close_section();
   }
   f->close_section();
@@ -60,7 +59,7 @@ void ObjectSetPosition::dump(Formatter *f) const {
 void ObjectSetPosition::generate_test_instances(
     std::list<ObjectSetPosition *> &o) {
   o.push_back(new ObjectSetPosition());
-  o.push_back(new ObjectSetPosition(1, {{1, 120}, {2, 121}}));
+  o.push_back(new ObjectSetPosition({{0, 1, 120}, {121, 2, 121}}));
 }
 
 void Client::encode(bufferlist& bl) const {
@@ -97,7 +96,7 @@ void Client::generate_test_instances(std::list<Client *> &o) {
 
   o.push_back(new Client());
   o.push_back(new Client("id", data));
-  o.push_back(new Client("id", data, {1, {{1, 120}, {2, 121}}}));
+  o.push_back(new Client("id", data, {{{1, 2, 120}, {2, 3, 121}}}));
 }
 
 void Tag::encode(bufferlist& bl) const {
@@ -134,19 +133,20 @@ void Tag::generate_test_instances(std::list<Tag *> &o) {
 }
 
 std::ostream &operator<<(std::ostream &os,
-                         const EntryPosition &entry_position) {
-  os << "[tag_tid=" << entry_position.tag_tid << ", entry_tid="
-     << entry_position.entry_tid << "]";
+                         const ObjectPosition &object_position) {
+  os << "["
+     << "object_number=" << object_position.object_number << ", "
+     << "tag_tid=" << object_position.tag_tid << ", "
+     << "entry_tid=" << object_position.entry_tid << "]";
   return os;
 }
 
 std::ostream &operator<<(std::ostream &os,
                          const ObjectSetPosition &object_set_position) {
-  os << "[object_number=" << object_set_position.object_number << ", "
-     << "positions=[";
+  os << "[positions=[";
   std::string delim;
-  for (auto &entry_position : object_set_position.entry_positions) {
-    os << entry_position << delim;
+  for (auto &object_position : object_set_position.object_positions) {
+    os << object_position << delim;
     delim = ", ";
   }
   os << "]]";

diff --git a/src/cls/journal/cls_journal_types.h b/src/cls/journal/cls_journal_types.h
index 19a1fcbb56d1bd0e000e1c016c65a60d95a61dc5..2b1d90030f5e6fc1191fb94056828c0db29a7325 100644 (file)
--- a/src/cls/journal/cls_journal_types.h
+++ b/src/cls/journal/cls_journal_types.h
@@ -19,50 +19,54 @@ class Formatter;
 namespace cls {
 namespace journal {
 
-struct EntryPosition {
+struct ObjectPosition {
+  uint64_t object_number;
   uint64_t tag_tid;
   uint64_t entry_tid;
 
-  EntryPosition() : tag_tid(0), entry_tid(0) {}
-  EntryPosition(uint64_t _tag_tid, uint64_t _entry_tid)
-    : tag_tid(_tag_tid), entry_tid(_entry_tid) {}
+  ObjectPosition() : object_number(0), tag_tid(0), entry_tid(0) {}
+  ObjectPosition(uint64_t _object_number, uint64_t _tag_tid,
+                 uint64_t _entry_tid)
+    : object_number(_object_number), tag_tid(_tag_tid), entry_tid(_entry_tid) {}
 
-  inline bool operator==(const EntryPosition& rhs) const {
-    return (tag_tid == rhs.tag_tid && entry_tid == rhs.entry_tid);
+  inline bool operator==(const ObjectPosition& rhs) const {
+    return (object_number == rhs.object_number &&
+            tag_tid == rhs.tag_tid &&
+            entry_tid == rhs.entry_tid);
   }
 
   void encode(bufferlist& bl) const;
   void decode(bufferlist::iterator& iter);
   void dump(Formatter *f) const;
 
-  inline bool operator<(const EntryPosition &rhs) const {
-    if (tag_tid != rhs.tag_tid) {
+  inline bool operator<(const ObjectPosition &rhs) const {
+    if (object_number != rhs.object_number) {
+      return object_number < rhs.object_number;
+    } else if (tag_tid != rhs.tag_tid) {
       return tag_tid < rhs.tag_tid;
     }
     return entry_tid < rhs.entry_tid;
   }
 
-  static void generate_test_instances(std::list<EntryPosition *> &o);
+  static void generate_test_instances(std::list<ObjectPosition *> &o);
 };
 
-typedef std::list<EntryPosition> EntryPositions;
+typedef std::list<ObjectPosition> ObjectPositions;
 
 struct ObjectSetPosition {
-  uint64_t object_number;
-  EntryPositions entry_positions;
+  // stored in most-recent -> least recent committed entry order
+  ObjectPositions object_positions;
 
-  ObjectSetPosition() : object_number(0) {}
-  ObjectSetPosition(uint64_t _object_number,
-                    const EntryPositions &_entry_positions)
-    : object_number(_object_number), entry_positions(_entry_positions) {}
+  ObjectSetPosition() {}
+  ObjectSetPosition(const ObjectPositions &_object_positions)
+    : object_positions(_object_positions) {}
 
   void encode(bufferlist& bl) const;
   void decode(bufferlist::iterator& iter);
   void dump(Formatter *f) const;
 
   inline bool operator==(const ObjectSetPosition &rhs) const {
-    return (object_number == rhs.object_number &&
-            entry_positions == rhs.entry_positions);
+    return (object_positions == rhs.object_positions);
   }
 
   static void generate_test_instances(std::list<ObjectSetPosition *> &o);
@@ -121,13 +125,13 @@ struct Tag {
   static void generate_test_instances(std::list<Tag *> &o);
 };
 
-WRITE_CLASS_ENCODER(EntryPosition);
+WRITE_CLASS_ENCODER(ObjectPosition);
 WRITE_CLASS_ENCODER(ObjectSetPosition);
 WRITE_CLASS_ENCODER(Client);
 WRITE_CLASS_ENCODER(Tag);
 
 std::ostream &operator<<(std::ostream &os,
-                         const EntryPosition &entry_position);
+                         const ObjectPosition &object_position);
 std::ostream &operator<<(std::ostream &os,
                          const ObjectSetPosition &object_set_position);
 std::ostream &operator<<(std::ostream &os,

diff --git a/src/journal/JournalMetadata.cc b/src/journal/JournalMetadata.cc
index 3d70518e8d03cea7654ca1b6126cab8e2c08bd08..99d6871cef40dfc65ef3d87dbe89776d3e48d32e 100644 (file)
--- a/src/journal/JournalMetadata.cc
+++ b/src/journal/JournalMetadata.cc
@@ -21,28 +21,26 @@ using namespace cls::journal;
 namespace {
 
 // does not compare object number
-inline bool entry_positions_less_equal(const ObjectSetPosition &lhs,
+inline bool object_positions_less_equal(const ObjectSetPosition &lhs,
                                        const ObjectSetPosition &rhs) {
-  if (lhs.entry_positions == rhs.entry_positions) {
+  if (lhs.object_positions == rhs.object_positions) {
     return true;
   }
 
-  if (lhs.entry_positions.size() < rhs.entry_positions.size()) {
-    return true;
-  } else if (lhs.entry_positions.size() > rhs.entry_positions.size()) {
-    return false;
+  if (lhs.object_positions.size() != rhs.object_positions.size()) {
+    return lhs.object_positions.size() < rhs.object_positions.size();
   }
 
   std::map<uint64_t, uint64_t> rhs_tids;
-  for (EntryPositions::const_iterator it = rhs.entry_positions.begin();
-       it != rhs.entry_positions.end(); ++it) {
+  for (ObjectPositions::const_iterator it = rhs.object_positions.begin();
+       it != rhs.object_positions.end(); ++it) {
     rhs_tids[it->tag_tid] = it->entry_tid;
   }
 
-  for (EntryPositions::const_iterator it = lhs.entry_positions.begin();
-       it != lhs.entry_positions.end(); ++it) {
-    const EntryPosition &entry_position = *it;
-    if (entry_position.entry_tid < rhs_tids[entry_position.tag_tid]) {
+  for (ObjectPositions::const_iterator it = lhs.object_positions.begin();
+       it != lhs.object_positions.end(); ++it) {
+    const ObjectPosition &object_position = *it;
+    if (object_position.entry_tid < rhs_tids[object_position.tag_tid]) {
       return true;
     }
   }
@@ -503,8 +501,8 @@ void JournalMetadata::set_commit_position(
     Mutex::Locker locker(m_lock);
     ldout(m_cct, 20) << __func__ << ": current=" << m_client.commit_position
                      << ", new=" << commit_position << dendl;
-    if (entry_positions_less_equal(commit_position, m_client.commit_position) ||
-        entry_positions_less_equal(commit_position, m_commit_position)) {
+    if (object_positions_less_equal(commit_position, m_client.commit_position) ||
+        object_positions_less_equal(commit_position, m_commit_position)) {
       stale_ctx = on_safe;
     } else {
       stale_ctx = m_commit_position_ctx;
@@ -716,7 +714,7 @@ bool JournalMetadata::committed(uint64_t commit_tid,
     commit_entry.committed = true;
   }
 
-  if (!m_commit_position.entry_positions.empty()) {
+  if (!m_commit_position.object_positions.empty()) {
     *object_set_position = m_commit_position;
   } else {
     *object_set_position = m_client.commit_position;
@@ -730,27 +728,17 @@ bool JournalMetadata::committed(uint64_t commit_tid,
       break;
     }
 
-    object_set_position->object_number = commit_entry.object_num;
-    if (!object_set_position->entry_positions.empty() &&
-        object_set_position->entry_positions.front().tag_tid ==
-          commit_entry.tag_tid) {
-      object_set_position->entry_positions.front() = EntryPosition(
-        commit_entry.tag_tid, commit_entry.entry_tid);
-    } else {
-      object_set_position->entry_positions.push_front(EntryPosition(
-        commit_entry.tag_tid, commit_entry.entry_tid));
-    }
-    m_pending_commit_tids.erase(it);
+    // TODO
     update_commit_position = true;
   }
 
   if (update_commit_position) {
     // prune the position to have unique tags in commit-order
     std::set<uint64_t> in_use_tag_tids;
-    EntryPositions::iterator it = object_set_position->entry_positions.begin();
-    while (it != object_set_position->entry_positions.end()) {
+    ObjectPositions::iterator it = object_set_position->object_positions.begin();
+    while (it != object_set_position->object_positions.end()) {
       if (!in_use_tag_tids.insert(it->tag_tid).second) {
-        it = object_set_position->entry_positions.erase(it);
+        it = object_set_position->object_positions.erase(it);
       } else {
         ++it;
       }

diff --git a/src/journal/JournalMetadata.h b/src/journal/JournalMetadata.h
index 02d4a9ba4799d31ec6e2dd9a628a6b428fc0a96d..049329b409c87150ba329b3a216a951f8e646a89 100644 (file)
--- a/src/journal/JournalMetadata.h
+++ b/src/journal/JournalMetadata.h
@@ -30,8 +30,8 @@ typedef boost::intrusive_ptr<JournalMetadata> JournalMetadataPtr;
 
 class JournalMetadata : public RefCountedObject, boost::noncopyable {
 public:
-  typedef cls::journal::EntryPosition EntryPosition;
-  typedef cls::journal::EntryPositions EntryPositions;
+  typedef cls::journal::ObjectPosition ObjectPosition;
+  typedef cls::journal::ObjectPositions ObjectPositions;
   typedef cls::journal::ObjectSetPosition ObjectSetPosition;
   typedef cls::journal::Client Client;
   typedef cls::journal::Tag Tag;

diff --git a/src/journal/JournalPlayer.cc b/src/journal/JournalPlayer.cc
index 08513550fa4b626363166eae8a86764228997a35..7b0ad8a1faa4f0d3d7a993b02478f11f5b5ff110 100644 (file)
--- a/src/journal/JournalPlayer.cc
+++ b/src/journal/JournalPlayer.cc
@@ -62,19 +62,23 @@ JournalPlayer::JournalPlayer(librados::IoCtx &ioctx,
 
   ObjectSetPosition commit_position;
   m_journal_metadata->get_commit_position(&commit_position);
-  if (!commit_position.entry_positions.empty()) {
+
+  // TODO
+  /*
+  if (!commit_position.object_positions.empty()) {
     uint8_t splay_width = m_journal_metadata->get_splay_width();
     m_splay_offset = commit_position.object_number % splay_width;
     m_commit_object = commit_position.object_number;
-    m_commit_tag_tid = commit_position.entry_positions.front().tag_tid;
+    m_commit_tag_tid = commit_position.object_positions.front().tag_tid;
 
-    for (EntryPositions::const_iterator it =
-           commit_position.entry_positions.begin();
-         it != commit_position.entry_positions.end(); ++it) {
-      const EntryPosition &entry_position = *it;
-      m_commit_tids[entry_position.tag_tid] = entry_position.entry_tid;
+    for (ObjectPositions::const_iterator it =
+           commit_position.object_positions.begin();
+         it != commit_position.object_positions.end(); ++it) {
+      const ObjectPosition &object_position = *it;
+      m_commit_tids[object_position.tag_tid] = object_position.entry_tid;
     }
   }
+  */
 }
 
 JournalPlayer::~JournalPlayer() {

diff --git a/src/journal/JournalPlayer.h b/src/journal/JournalPlayer.h
index 1e7bdff23b6edb3e20cf46168bb1bc5ad062b019..54b4a93f2a11d499c1c84e95f743f2077ed634d7 100644 (file)
--- a/src/journal/JournalPlayer.h
+++ b/src/journal/JournalPlayer.h
@@ -23,8 +23,8 @@ class ReplayHandler;
 
 class JournalPlayer {
 public:
-  typedef cls::journal::EntryPosition EntryPosition;
-  typedef cls::journal::EntryPositions EntryPositions;
+  typedef cls::journal::ObjectPosition ObjectPosition;
+  typedef cls::journal::ObjectPositions ObjectPositions;
   typedef cls::journal::ObjectSetPosition ObjectSetPosition;
 
   JournalPlayer(librados::IoCtx &ioctx, const std::string &object_oid_prefix,

diff --git a/src/journal/JournalTrimmer.cc b/src/journal/JournalTrimmer.cc
index 9e781cebd01db4b0ea6c31956c3e92cf7cdbdde0..05a767285167693847511267ccf514b42c409852 100644 (file)
--- a/src/journal/JournalTrimmer.cc
+++ b/src/journal/JournalTrimmer.cc
@@ -128,6 +128,8 @@ void JournalTrimmer::handle_commit_position_safe(
 
   Mutex::Locker locker(m_lock);
   if (r == 0) {
+    // TODO
+    /*
     uint8_t splay_width = m_journal_metadata->get_splay_width();
     uint64_t object_set = object_set_position.object_number / splay_width;
 
@@ -153,6 +155,7 @@ void JournalTrimmer::handle_commit_position_safe(
     if (trim_permitted) {
       trim_objects(object_set_position.object_number / splay_width);
     }
+    */
   }
 }
 

diff --git a/src/test/cls_journal/test_cls_journal.cc b/src/test/cls_journal/test_cls_journal.cc
index 3a26e8f66cda3e6cb80f75ded47473a01fffd056..1eb7663da763f402dfc77bc77e2b63ee945a928b 100644 (file)
--- a/src/test/cls_journal/test_cls_journal.cc
+++ b/src/test/cls_journal/test_cls_journal.cc
@@ -293,7 +293,7 @@ TEST_F(TestClsJournal, ClientUnregisterPruneTags) {
   ASSERT_EQ(0, client::tag_create(ioctx, oid, 2, 1, bufferlist()));
 
   librados::ObjectWriteOperation op1;
-  client::client_commit(&op1, "id1", {1, {{2, 120}}});
+  client::client_commit(&op1, "id1", {{{1, 2, 120}}});
   ASSERT_EQ(0, ioctx.operate(oid, &op1));
 
   ASSERT_EQ(0, client::client_unregister(ioctx, oid, "id2"));
@@ -314,12 +314,12 @@ TEST_F(TestClsJournal, ClientCommit) {
   ASSERT_EQ(0, client::create(ioctx, oid, 2, 2, ioctx.get_id()));
   ASSERT_EQ(0, client::client_register(ioctx, oid, "id1", bufferlist()));
 
-  cls::journal::EntryPositions entry_positions;
-  entry_positions = {
-    cls::journal::EntryPosition(234, 120),
-    cls::journal::EntryPosition(235, 121)};
+  cls::journal::ObjectPositions object_positions;
+  object_positions = {
+    cls::journal::ObjectPosition(0, 234, 120),
+    cls::journal::ObjectPosition(3, 235, 121)};
   cls::journal::ObjectSetPosition object_set_position(
-    1, entry_positions);
+    object_positions);
 
   librados::ObjectWriteOperation op2;
   client::client_commit(&op2, "id1", object_set_position);
@@ -342,13 +342,13 @@ TEST_F(TestClsJournal, ClientCommitInvalid) {
   ASSERT_EQ(0, client::create(ioctx, oid, 2, 2, ioctx.get_id()));
   ASSERT_EQ(0, client::client_register(ioctx, oid, "id1", bufferlist()));
 
-  cls::journal::EntryPositions entry_positions;
-  entry_positions = {
-    cls::journal::EntryPosition(234, 120),
-    cls::journal::EntryPosition(234, 121),
-    cls::journal::EntryPosition(235, 121)};
+  cls::journal::ObjectPositions object_positions;
+  object_positions = {
+    cls::journal::ObjectPosition(0, 234, 120),
+    cls::journal::ObjectPosition(4, 234, 121),
+    cls::journal::ObjectPosition(5, 235, 121)};
   cls::journal::ObjectSetPosition object_set_position(
-    1, entry_positions);
+    object_positions);
 
   librados::ObjectWriteOperation op2;
   client::client_commit(&op2, "id1", object_set_position);
@@ -468,7 +468,7 @@ TEST_F(TestClsJournal, TagCreatePrunesTags) {
   ASSERT_EQ(0, client::tag_create(ioctx, oid, 2, 1, bufferlist()));
 
   librados::ObjectWriteOperation op1;
-  client::client_commit(&op1, "id1", {1, {{2, 120}}});
+  client::client_commit(&op1, "id1", {{{1, 2, 120}}});
   ASSERT_EQ(0, ioctx.operate(oid, &op1));
 
   ASSERT_EQ(0, client::tag_create(ioctx, oid, 3, 0, bufferlist()));

diff --git a/src/test/encoding/types.h b/src/test/encoding/types.h
index 4ffab8743cba30f29fd2c74c1dddef456bde4670..b93a2899e2822db9a6e55c79c7bbbaa525d4fc5a 100644 (file)
--- a/src/test/encoding/types.h
+++ b/src/test/encoding/types.h
@@ -330,7 +330,7 @@ TYPE(cls_user_get_header_ret)
 TYPE(cls_user_complete_stats_sync_op)
 
 #include "cls/journal/cls_journal_types.h"
-TYPE(cls::journal::EntryPosition)
+TYPE(cls::journal::ObjectPosition)
 TYPE(cls::journal::ObjectSetPosition)
 TYPE(cls::journal::Client)
 

diff --git a/src/test/journal/test_JournalMetadata.cc b/src/test/journal/test_JournalMetadata.cc
index 1a97ae7c46a8d0fce47cea587e945ce1b2e21e09..be9628e2941cd2da397ee2cb5c8fccd4335de053 100644 (file)
--- a/src/test/journal/test_JournalMetadata.cc
+++ b/src/test/journal/test_JournalMetadata.cc
@@ -68,10 +68,10 @@ TEST_F(TestJournalMetadata, SetCommitPositions) {
   metadata1->get_commit_position(&read_commit_position);
   ASSERT_EQ(commit_position, read_commit_position);
 
-  journal::JournalMetadata::EntryPositions entry_positions;
-  entry_positions = {
-    cls::journal::EntryPosition(123, 122)};
-  commit_position = journal::JournalMetadata::ObjectSetPosition(1, entry_positions);
+  journal::JournalMetadata::ObjectPositions object_positions;
+  object_positions = {
+    cls::journal::ObjectPosition(1, 123, 122)};
+  commit_position = journal::JournalMetadata::ObjectSetPosition(object_positions);
 
   C_SaferCond cond;
   metadata1->set_commit_position(commit_position, &cond);

diff --git a/src/test/journal/test_JournalPlayer.cc b/src/test/journal/test_JournalPlayer.cc
index 28a24b583b75dc23786f8da84d23a399b9137c23..beafc0a692227bba0896c7d0372fa807aa9eeee6 100644 (file)
--- a/src/test/journal/test_JournalPlayer.cc
+++ b/src/test/journal/test_JournalPlayer.cc
@@ -143,10 +143,10 @@ public:
 TEST_F(TestJournalPlayer, Prefetch) {
   std::string oid = get_temp_oid();
 
-  journal::JournalPlayer::EntryPositions positions;
+  journal::JournalPlayer::ObjectPositions positions;
   positions = {
-    cls::journal::EntryPosition(234, 122) };
-  cls::journal::ObjectSetPosition commit_position(0, positions);
+    cls::journal::ObjectPosition(0, 234, 122) };
+  cls::journal::ObjectSetPosition commit_position(positions);
 
   ASSERT_EQ(0, create(oid));
   ASSERT_EQ(0, client_register(oid));
@@ -183,10 +183,10 @@ TEST_F(TestJournalPlayer, Prefetch) {
 TEST_F(TestJournalPlayer, PrefetchSkip) {
   std::string oid = get_temp_oid();
 
-  journal::JournalPlayer::EntryPositions positions;
+  journal::JournalPlayer::ObjectPositions positions;
   positions = {
-    cls::journal::EntryPosition(234, 125) };
-  cls::journal::ObjectSetPosition commit_position(0, positions);
+    cls::journal::ObjectPosition(0, 234, 125) };
+  cls::journal::ObjectSetPosition commit_position(positions);
 
   ASSERT_EQ(0, create(oid));
   ASSERT_EQ(0, client_register(oid));
@@ -246,11 +246,11 @@ TEST_F(TestJournalPlayer, PrefetchWithoutCommit) {
 TEST_F(TestJournalPlayer, PrefetchMultipleTags) {
   std::string oid = get_temp_oid();
 
-  journal::JournalPlayer::EntryPositions positions;
+  journal::JournalPlayer::ObjectPositions positions;
   positions = {
-    cls::journal::EntryPosition(234, 122),
-    cls::journal::EntryPosition(345, 1)};
-  cls::journal::ObjectSetPosition commit_position(0, positions);
+    cls::journal::ObjectPosition(0, 234, 122),
+    cls::journal::ObjectPosition(1, 345, 1)};
+  cls::journal::ObjectSetPosition commit_position(positions);
 
   ASSERT_EQ(0, create(oid));
   ASSERT_EQ(0, client_register(oid));
@@ -316,10 +316,10 @@ TEST_F(TestJournalPlayer, PrefetchCorruptSequence) {
 TEST_F(TestJournalPlayer, PrefetchAndWatch) {
   std::string oid = get_temp_oid();
 
-  journal::JournalPlayer::EntryPositions positions;
+  journal::JournalPlayer::ObjectPositions positions;
   positions = {
-    cls::journal::EntryPosition(234, 122)};
-  cls::journal::ObjectSetPosition commit_position(0, positions);
+    cls::journal::ObjectPosition(0, 234, 122)};
+  cls::journal::ObjectSetPosition commit_position(positions);
 
   ASSERT_EQ(0, create(oid));
   ASSERT_EQ(0, client_register(oid));

diff --git a/src/test/librbd/journal/test_Replay.cc b/src/test/librbd/journal/test_Replay.cc
index 587104c628c28673f69b51f3d0884955b0e7aaf8..7e048a04e55b5b71bc38a2356989750412469751 100644 (file)
--- a/src/test/librbd/journal/test_Replay.cc
+++ b/src/test/librbd/journal/test_Replay.cc
@@ -73,15 +73,15 @@ public:
       *tid = -1;
       return;
     }
-    cls::journal::EntryPositions entry_positions =
-       c->commit_position.entry_positions;
-    cls::journal::EntryPositions::const_iterator p;
-    for (p = entry_positions.begin(); p != entry_positions.end(); ++p) {
+    cls::journal::ObjectPositions object_positions =
+       c->commit_position.object_positions;
+    cls::journal::ObjectPositions::const_iterator p;
+    for (p = object_positions.begin(); p != object_positions.end(); p++) {
       if (p->tag_tid == 0) {
        break;
       }
     }
-    *tid = p == entry_positions.end() ? -1 : p->entry_tid;
+    *tid = p == object_positions.end() ? -1 : p->entry_tid;
 
     C_SaferCond open_cond;
     ictx->journal = new librbd::Journal<>(*ictx);
@@ -599,7 +599,7 @@ TEST_F(TestJournalReplay, Flatten) {
   ASSERT_EQ(-EINVAL, ictx2->operations->flatten(no_op));
 }
 
-TEST_F(TestJournalReplay, EntryPosition) {
+TEST_F(TestJournalReplay, ObjectPosition) {
   REQUIRE_FEATURE(RBD_FEATURE_JOURNALING);
 
   librbd::ImageCtx *ictx;

diff --git a/src/test/rbd_mirror/test_ImageReplayer.cc b/src/test/rbd_mirror/test_ImageReplayer.cc
index a22db52c45654671e8f99ed32ced619f5ad039a1..26135ff4138c25755f1c747934a61ff0339b2fdf 100644 (file)
--- a/src/test/rbd_mirror/test_ImageReplayer.cc
+++ b/src/test/rbd_mirror/test_ImageReplayer.cc
@@ -204,10 +204,10 @@ public:
     std::set<cls::journal::Client>::const_iterator c;
     for (c = registered_clients.begin(); c != registered_clients.end(); c++) {
       std::cout << __func__ << ": client: " << *c << std::endl;
-      cls::journal::EntryPositions entry_positions =
-       c->commit_position.entry_positions;
-      cls::journal::EntryPositions::const_iterator p;
-      for (p = entry_positions.begin(); p != entry_positions.end(); p++) {
+      cls::journal::ObjectPositions object_positions =
+       c->commit_position.object_positions;
+      cls::journal::ObjectPositions::const_iterator p;
+      for (p = object_positions.begin(); p != object_positions.end(); p++) {
        if (c->id == master_client_id) {
          ASSERT_EQ(-1, master_tid);
          master_tid = p->entry_tid;