From: Jason Dillaman Date: Tue, 23 Feb 2016 19:02:39 +0000 (-0500) Subject: journal: track commit position for each object splay offset X-Git-Tag: v10.1.0~258^2~6 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=44d25fd51a4b9be0ad58abf2284846e47f0a464a;p=ceph.git 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 --- diff --git a/src/cls/journal/cls_journal.cc b/src/cls/journal/cls_journal.cc index f87c2b2ad8af..632359b67750 100644 --- 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::max()) { + return 0; + } + // compute the minimum in-use tag for each class std::map 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::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 9d8af00957a9..d686a5049b32 100644 --- 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 &o) { - o.push_back(new EntryPosition()); - o.push_back(new EntryPosition(1, 2)); +void ObjectPosition::generate_test_instances(std::list &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 &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 &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 &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 19a1fcbb56d1..2b1d90030f5e 100644 --- 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 &o); + static void generate_test_instances(std::list &o); }; -typedef std::list EntryPositions; +typedef std::list 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 &o); @@ -121,13 +125,13 @@ struct Tag { static void generate_test_instances(std::list &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 3d70518e8d03..99d6871cef40 100644 --- 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 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 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 02d4a9ba4799..049329b409c8 100644 --- a/src/journal/JournalMetadata.h +++ b/src/journal/JournalMetadata.h @@ -30,8 +30,8 @@ typedef boost::intrusive_ptr 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 08513550fa4b..7b0ad8a1faa4 100644 --- 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 1e7bdff23b6e..54b4a93f2a11 100644 --- 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 9e781cebd01d..05a767285167 100644 --- 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 3a26e8f66cda..1eb7663da763 100644 --- 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 4ffab8743cba..b93a2899e282 100644 --- 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 1a97ae7c46a8..be9628e2941c 100644 --- 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 28a24b583b75..beafc0a69222 100644 --- 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 587104c628c2..7e048a04e55b 100644 --- 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 a22db52c4565..26135ff4138c 100644 --- a/src/test/rbd_mirror/test_ImageReplayer.cc +++ b/src/test/rbd_mirror/test_ImageReplayer.cc @@ -204,10 +204,10 @@ public: std::set::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;