From a41679a6013ddedd77a2fce665055240f47c607d Mon Sep 17 00:00:00 2001 From: Sage Weil Date: Wed, 1 Feb 2012 14:28:04 -0800 Subject: [PATCH] osd: PG::Log -> pg_log_t Signed-off-by: Sage Weil --- src/messages/MOSDPGLog.h | 2 +- src/osd/PG.cc | 69 +--------------------- src/osd/PG.h | 121 ++------------------------------------ src/osd/osd_types.cc | 114 +++++++++++++++++++++++++++++++++++ src/osd/osd_types.h | 96 ++++++++++++++++++++++++++++++ src/test/encoding/types.h | 1 + 6 files changed, 221 insertions(+), 182 deletions(-) diff --git a/src/messages/MOSDPGLog.h b/src/messages/MOSDPGLog.h index 832e053f8b6e9..e71a0000d45a3 100644 --- a/src/messages/MOSDPGLog.h +++ b/src/messages/MOSDPGLog.h @@ -28,7 +28,7 @@ class MOSDPGLog : public Message { public: pg_info_t info; - PG::Log log; + pg_log_t log; PG::Missing missing; epoch_t get_epoch() { return epoch; } diff --git a/src/osd/PG.cc b/src/osd/PG.cc index 723ba9b1e55ed..abb10e35b0406 100644 --- a/src/osd/PG.cc +++ b/src/osd/PG.cc @@ -70,59 +70,6 @@ std::string PG::gen_prefix() const } -/******* PG::Log ********/ - -void PG::Log::copy_after(const Log &other, eversion_t v) -{ - head = other.head; - tail = other.tail; - for (list::const_reverse_iterator i = other.log.rbegin(); - i != other.log.rend(); - i++) { - assert(i->version > other.tail); - if (i->version <= v) { - // make tail accurate. - tail = i->version; - break; - } - log.push_front(*i); - } -} - -void PG::Log::copy_range(const Log &other, eversion_t from, eversion_t to) -{ - list::const_reverse_iterator i = other.log.rbegin(); - assert(i != other.log.rend()); - while (i->version > to) { - ++i; - assert(i != other.log.rend()); - } - assert(i->version == to); - head = to; - for ( ; i != other.log.rend(); ++i) { - if (i->version <= from) { - tail = i->version; - break; - } - log.push_front(*i); - } -} - -void PG::Log::copy_up_to(const Log &other, int max) -{ - int n = 0; - head = other.head; - tail = other.tail; - for (list::const_reverse_iterator i = other.log.rbegin(); - i != other.log.rend(); - ++i) { - if (n++ >= max) { - tail = i->version; - break; - } - log.push_front(*i); - } -} void PG::IndexedLog::trim(ObjectStore::Transaction& t, eversion_t s) { @@ -149,7 +96,7 @@ void PG::IndexedLog::trim(ObjectStore::Transaction& t, eversion_t s) /********* PG **********/ -void PG::proc_master_log(ObjectStore::Transaction& t, pg_info_t &oinfo, Log &olog, Missing& omissing, int from) +void PG::proc_master_log(ObjectStore::Transaction& t, pg_info_t &oinfo, pg_log_t &olog, Missing& omissing, int from) { dout(10) << "proc_master_log for osd." << from << ": " << olog << " " << omissing << dendl; assert(!is_active() && is_primary()); @@ -168,7 +115,7 @@ void PG::proc_master_log(ObjectStore::Transaction& t, pg_info_t &oinfo, Log &olo } void PG::proc_replica_log(ObjectStore::Transaction& t, - pg_info_t &oinfo, Log &olog, Missing& omissing, int from) + pg_info_t &oinfo, pg_log_t &olog, Missing& omissing, int from) { dout(10) << "proc_replica_log for osd." << from << ": " << oinfo << " " << olog << " " << omissing << dendl; @@ -363,7 +310,7 @@ bool PG::merge_old_entry(ObjectStore::Transaction& t, pg_log_entry_t& oe) } void PG::merge_log(ObjectStore::Transaction& t, - pg_info_t &oinfo, Log &olog, int fromosd) + pg_info_t &oinfo, pg_log_t &olog, int fromosd) { dout(10) << "merge_log " << olog << " from osd." << fromosd << " into " << log << dendl; @@ -621,16 +568,6 @@ void PG::discover_all_missing(map< int, map > &query_map) } -ostream& PG::Log::print(ostream& out) const -{ - out << *this << std::endl; - for (list::const_iterator p = log.begin(); - p != log.end(); - p++) - out << *p << std::endl; - return out; -} - ostream& PG::IndexedLog::print(ostream& out) const { out << *this << std::endl; diff --git a/src/osd/PG.h b/src/osd/PG.h index 066a54b0e4ecc..eebfa884b0892 100644 --- a/src/osd/PG.h +++ b/src/osd/PG.h @@ -160,113 +160,11 @@ public: std::string gen_prefix() const; - /* - * Log - incremental log of recent pg changes. - * serves as a recovery queue for recent changes. - */ - struct Log { - /* - * head - newest entry (update|delete) - * tail - entry previous to oldest (update|delete) for which we have - * complete negative information. - * i.e. we can infer pg contents for any store whose last_update >= tail. - */ - eversion_t head; // newest entry - eversion_t tail; // version prior to oldest - - list log; // the actual log. - - Log() {} - - void clear() { - eversion_t z; - head = tail = z; - log.clear(); - } - - bool empty() const { - return log.empty(); - } - - bool null() const { - return head.version == 0 && head.epoch == 0; - } - - size_t approx_size() const { - return head.version - tail.version; - } - - list::iterator find_entry(eversion_t v) { - int fromhead = head.version - v.version; - int fromtail = v.version - tail.version; - list::iterator p; - if (fromhead < fromtail) { - p = log.end(); - p--; - while (p->version > v) - p--; - return p; - } else { - p = log.begin(); - while (p->version < v) - p++; - return p; - } - } - - void encode(bufferlist& bl) const { - __u8 struct_v = 2; - ::encode(struct_v, bl); - ::encode(head, bl); - ::encode(tail, bl); - ::encode(log, bl); - } - void decode(bufferlist::iterator &bl) { - __u8 struct_v = 1; - ::decode(struct_v, bl); - ::decode(head, bl); - ::decode(tail, bl); - if (struct_v < 2) { - bool backlog; - ::decode(backlog, bl); - } - ::decode(log, bl); - } - - /** - * copy entries from the tail of another Log - * - * @param other Log to copy from - * @param from copy entries after this version - */ - void copy_after(const Log &other, eversion_t from); - - /** - * copy a range of entries from another Log - * - * @param other Log to copy from - * @param from copy entries after this version - * @parem to up to and including this version - */ - void copy_range(const Log &other, eversion_t from, eversion_t to); - - /** - * copy up to N entries - * - * @param o source log - * @param max max number of entreis to copy - */ - void copy_up_to(const Log &other, int max); - - ostream& print(ostream& out) const; - }; - WRITE_CLASS_ENCODER(Log) - /** * IndexLog - adds in-memory index of the log, by oid. * plus some methods to manipulate it all. */ - struct IndexedLog : public Log { + struct IndexedLog : public pg_log_t { hash_map objects; // ptrs into log. be careful! hash_map caller_ops; @@ -277,7 +175,7 @@ public: /****/ IndexedLog() {} - void claim_log(const Log& o) { + void claim_log(const pg_log_t& o) { log = o.log; head = o.head; tail = o.tail; @@ -286,7 +184,7 @@ public: void zero() { unindex(); - Log::clear(); + pg_log_t::clear(); reset_recovery_pointers(); } void reset_recovery_pointers() { @@ -1278,13 +1176,13 @@ public: virtual void calc_trim_to() = 0; - void proc_replica_log(ObjectStore::Transaction& t, pg_info_t &oinfo, Log &olog, + void proc_replica_log(ObjectStore::Transaction& t, pg_info_t &oinfo, pg_log_t &olog, Missing& omissing, int from); - void proc_master_log(ObjectStore::Transaction& t, pg_info_t &oinfo, Log &olog, + void proc_master_log(ObjectStore::Transaction& t, pg_info_t &oinfo, pg_log_t &olog, Missing& omissing, int from); bool proc_replica_info(int from, pg_info_t &info); bool merge_old_entry(ObjectStore::Transaction& t, pg_log_entry_t& oe); - void merge_log(ObjectStore::Transaction& t, pg_info_t &oinfo, Log &olog, int from); + void merge_log(ObjectStore::Transaction& t, pg_info_t &oinfo, pg_log_t &olog, int from); bool search_for_missing(const pg_info_t &oinfo, const Missing *omissing, int fromosd); @@ -1556,16 +1454,9 @@ public: WRITE_CLASS_ENCODER(PG::Missing::item) WRITE_CLASS_ENCODER(PG::Missing) -WRITE_CLASS_ENCODER(PG::Log) WRITE_CLASS_ENCODER(PG::Interval) WRITE_CLASS_ENCODER(PG::OndiskLog) -inline ostream& operator<<(ostream& out, const PG::Log& log) -{ - out << "log(" << log.tail << "," << log.head << "]"; - return out; -} - inline ostream& operator<<(ostream& out, const PG::Missing::item& i) { out << i.need; diff --git a/src/osd/osd_types.cc b/src/osd/osd_types.cc index 3a60814f65a43..3933292cd9cfc 100644 --- a/src/osd/osd_types.cc +++ b/src/osd/osd_types.cc @@ -1172,6 +1172,120 @@ ostream& operator<<(ostream& out, const pg_log_entry_t& e) } +// -- pg_log_t -- + +void pg_log_t::encode(bufferlist& bl) const +{ + __u8 struct_v = 2; + ::encode(struct_v, bl); + ::encode(head, bl); + ::encode(tail, bl); + ::encode(log, bl); +} + +void pg_log_t::decode(bufferlist::iterator &bl) +{ + __u8 struct_v = 1; + ::decode(struct_v, bl); + ::decode(head, bl); + ::decode(tail, bl); + if (struct_v < 2) { + bool backlog; + ::decode(backlog, bl); + } + ::decode(log, bl); +} + +void pg_log_t::dump(Formatter *f) const +{ + f->dump_stream("head") << head; + f->dump_stream("tail") << head; + f->open_array_section("log"); + for (list::const_iterator p = log.begin(); p != log.end(); ++p) { + f->open_object_section("entry"); + p->dump(f); + f->close_section(); + } + f->close_section(); +} + +void pg_log_t::generate_test_instances(list& o) +{ + o.push_back(new pg_log_t); + + // this is nonsensical: + o.push_back(new pg_log_t); + o.back()->head = eversion_t(1,2); + o.back()->tail = eversion_t(3,4); + list e; + pg_log_entry_t::generate_test_instances(e); + for (list::iterator p = e.begin(); p != e.end(); ++p) + o.back()->log.push_back(**p); +} + +void pg_log_t::copy_after(const pg_log_t &other, eversion_t v) +{ + head = other.head; + tail = other.tail; + for (list::const_reverse_iterator i = other.log.rbegin(); + i != other.log.rend(); + i++) { + assert(i->version > other.tail); + if (i->version <= v) { + // make tail accurate. + tail = i->version; + break; + } + log.push_front(*i); + } +} + +void pg_log_t::copy_range(const pg_log_t &other, eversion_t from, eversion_t to) +{ + list::const_reverse_iterator i = other.log.rbegin(); + assert(i != other.log.rend()); + while (i->version > to) { + ++i; + assert(i != other.log.rend()); + } + assert(i->version == to); + head = to; + for ( ; i != other.log.rend(); ++i) { + if (i->version <= from) { + tail = i->version; + break; + } + log.push_front(*i); + } +} + +void pg_log_t::copy_up_to(const pg_log_t &other, int max) +{ + int n = 0; + head = other.head; + tail = other.tail; + for (list::const_reverse_iterator i = other.log.rbegin(); + i != other.log.rend(); + ++i) { + if (n++ >= max) { + tail = i->version; + break; + } + log.push_front(*i); + } +} + +ostream& pg_log_t::print(ostream& out) const +{ + out << *this << std::endl; + for (list::const_iterator p = log.begin(); + p != log.end(); + p++) + out << *p << std::endl; + return out; +} + + // -- OSDSuperblock -- void OSDSuperblock::encode(bufferlist &bl) const diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h index bbcdbc19243c3..d116f8585acaf 100644 --- a/src/osd/osd_types.h +++ b/src/osd/osd_types.h @@ -1102,6 +1102,102 @@ ostream& operator<<(ostream& out, const pg_log_entry_t& e); +/** + * pg_log_t - incremental log of recent pg changes. + * + * serves as a recovery queue for recent changes. + */ +struct pg_log_t { + /* + * head - newest entry (update|delete) + * tail - entry previous to oldest (update|delete) for which we have + * complete negative information. + * i.e. we can infer pg contents for any store whose last_update >= tail. + */ + eversion_t head; // newest entry + eversion_t tail; // version prior to oldest + + list log; // the actual log. + + pg_log_t() {} + + void clear() { + eversion_t z; + head = tail = z; + log.clear(); + } + + bool empty() const { + return log.empty(); + } + + bool null() const { + return head.version == 0 && head.epoch == 0; + } + + size_t approx_size() const { + return head.version - tail.version; + } + + list::iterator find_entry(eversion_t v) { + int fromhead = head.version - v.version; + int fromtail = v.version - tail.version; + list::iterator p; + if (fromhead < fromtail) { + p = log.end(); + p--; + while (p->version > v) + p--; + return p; + } else { + p = log.begin(); + while (p->version < v) + p++; + return p; + } + } + + /** + * copy entries from the tail of another pg_log_t + * + * @param other pg_log_t to copy from + * @param from copy entries after this version + */ + void copy_after(const pg_log_t &other, eversion_t from); + + /** + * copy a range of entries from another pg_log_t + * + * @param other pg_log_t to copy from + * @param from copy entries after this version + * @parem to up to and including this version + */ + void copy_range(const pg_log_t &other, eversion_t from, eversion_t to); + + /** + * copy up to N entries + * + * @param o source log + * @param max max number of entreis to copy + */ + void copy_up_to(const pg_log_t &other, int max); + + ostream& print(ostream& out) const; + + void encode(bufferlist &bl) const; + void decode(bufferlist::iterator &bl); + void dump(Formatter *f) const; + static void generate_test_instances(list& o); +}; +WRITE_CLASS_ENCODER(pg_log_t) + +inline ostream& operator<<(ostream& out, const pg_log_t& log) +{ + out << "log(" << log.tail << "," << log.head << "]"; + return out; +} + + struct osd_peer_stat_t { diff --git a/src/test/encoding/types.h b/src/test/encoding/types.h index 04480688b2870..6744a13a5113a 100644 --- a/src/test/encoding/types.h +++ b/src/test/encoding/types.h @@ -31,6 +31,7 @@ TYPE(pg_history_t) TYPE(pg_info_t) TYPE(pg_query_t) TYPE(pg_log_entry_t) +TYPE(pg_log_t) TYPE(watch_info_t) TYPE(object_info_t) -- 2.39.5