RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-02-24 11:37:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

osd: key Missing::rmissing on version (not eversion)

Browse Source 
This switches the key to the uint64_t (version_t) only, which is still
unique given a particular timeline (which is all we care about given a
particular Missing::missing).  The last_requested pointer is updated
accordingly.

This will facilitate a hack to make PGLS work for degraded PGs (by using
the rmissing version offset as a cookie).

Signed-off-by: Sage Weil <sage.weil@dreamhost.com>
This commit is contained in:
Sage Weil 2011-05-11 13:58:09 -07:00
parent 0f42099ae7
commit 82f9a923ea
3 changed files with 25 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/osd/PG.cc
View File

@ -1534,7 +1534,7 @@ void PG::activate(ObjectStore::Transaction& t, list<Context*>& tfin,
while (log.complete_to->version <= info.last_complete)
log.complete_to++;
assert(log.complete_to != log.log.end());
log.last_requested = eversion_t();
log.last_requested = 0;
dout(10) << "activate - complete_to = " << log.complete_to->version << dendl;
if (is_primary()) {
dout(10) << "activate - starting recovery" << dendl;
@ -2804,7 +2804,7 @@ void PG::repair_object(const sobject_t& soid, ScrubMap::object *po, int bad_peer
missing.add(soid, oi.version, eversion_t());
missing_loc[soid].insert(ok_peer);
log.last_requested = eversion_t();
log.last_requested = 0;
}
osd->queue_for_recovery(this);
}
@ -3622,18 +3622,18 @@ void PG::Missing::add_next_event(Log::Entry& e)
// new object.
//assert(missing.count(e.soid) == 0); // might already be missing divergent item.
if (missing.count(e.soid)) // already missing divergent item
rmissing.erase(missing[e.soid].need);
rmissing.erase(missing[e.soid].need.version);
missing[e.soid] = item(e.version, eversion_t()); // .have = nil
} else if (missing.count(e.soid)) {
// already missing (prior).
//assert(missing[e.soid].need == e.prior_version);
rmissing.erase(missing[e.soid].need);
rmissing.erase(missing[e.soid].need.version);
missing[e.soid].need = e.version; // leave .have unchanged.
} else {
// not missing, we must have prior_version (if any)
missing[e.soid] = item(e.version, e.prior_version);
}
rmissing[e.version] = e.soid;
rmissing[e.version.version] = e.soid;
} else
rm(e.soid, e.version);
}
@ -3645,12 +3645,12 @@ void PG::Missing::add_event(Log::Entry& e)
if (missing[e.soid].need >= e.version)
return; // already missing same or newer.
// missing older, revise need
rmissing.erase(missing[e.soid].need);
rmissing.erase(missing[e.soid].need.version);
missing[e.soid].need = e.version;
} else
// not missing => have prior_version (if any)
missing[e.soid] = item(e.version, e.prior_version);
rmissing[e.version] = e.soid;
rmissing[e.version.version] = e.soid;
} else
rm(e.soid, e.version);
}
@ -3658,24 +3658,24 @@ void PG::Missing::add_event(Log::Entry& e)
void PG::Missing::revise_need(sobject_t oid, eversion_t need)
{
if (missing.count(oid)) {
rmissing.erase(missing[oid].need);
rmissing.erase(missing[oid].need.version);
missing[oid].need = need; // no not adjust .have
} else {
missing[oid] = item(need, eversion_t());
}
rmissing[need] = oid;
rmissing[need.version] = oid;
}
void PG::Missing::add(const sobject_t& oid, eversion_t need, eversion_t have)
{
missing[oid] = item(need, have);
rmissing[need] = oid;
rmissing[need.version] = oid;
}
void PG::Missing::rm(const sobject_t& oid, eversion_t v)
{
if (missing.count(oid) && missing[oid].need <= v) {
rmissing.erase(missing[oid].need);
rmissing.erase(missing[oid].need.version);
missing.erase(oid);
}
}
@ -3684,13 +3684,13 @@ void PG::Missing::got(const sobject_t& oid, eversion_t v)
{
assert(missing.count(oid));
assert(missing[oid].need <= v);
rmissing.erase(missing[oid].need);
rmissing.erase(missing[oid].need.version);
missing.erase(oid);
}
void PG::Missing::got(const std::map<sobject_t, Missing::item>::iterator &m)
{
rmissing.erase(m->second.need);
rmissing.erase(m->second.need.version);
missing.erase(m);
}

8
src/osd/PG.h
View File

@ -492,7 +492,7 @@ public:
// recovery pointers
list<Entry>::iterator complete_to; // not inclusive of referenced item
eversion_t last_requested; // last object requested by primary
version_t last_requested; // last object requested by primary
/****/
IndexedLog() {}
@ -504,7 +504,7 @@ public:
}
void reset_recovery_pointers() {
complete_to = log.end();
last_requested = eversion_t();
last_requested = 0;
}
bool logged_object(const sobject_t& oid) const {
@ -651,7 +651,7 @@ public:
WRITE_CLASS_ENCODER(item)
map<sobject_t, item> missing; // oid -> (need v, have v)
map<eversion_t, sobject_t> rmissing; // v -> oid
map<version_t, sobject_t> rmissing; // v -> oid
unsigned int num_missing() const;
bool have_missing() const;
@ -681,7 +681,7 @@ public:
for (map<sobject_t,item>::iterator it = missing.begin();
it != missing.end();
++it)
rmissing[it->second.need] = it->first;
rmissing[it->second.need.version] = it->first;
}
};
WRITE_CLASS_ENCODER(Missing)

14
src/osd/ReplicatedPG.cc
View File

@ -4222,7 +4222,7 @@ void ReplicatedPG::check_recovery_op_pulls(const OSDMap *osdmap)
pulling.erase(*i);
finish_recovery_op(*i);
}
log.last_requested = eversion_t();
log.last_requested = 0;
pull_from_peer.erase(j++);
}
}
@ -4290,10 +4290,10 @@ int ReplicatedPG::recover_primary(int max)
int started = 0;
int skipped = 0;
map<eversion_t, sobject_t>::iterator p = missing.rmissing.lower_bound(log.last_requested);
map<version_t, sobject_t>::iterator p = missing.rmissing.lower_bound(log.last_requested);
while (p != missing.rmissing.end()) {
sobject_t soid;
eversion_t v = p->first;
version_t v = p->first;
if (log.objects.count(p->second)) {
latest = log.objects[p->second];
@ -4447,15 +4447,16 @@ int ReplicatedPG::recover_replicas(int max)
// oldest first!
const Missing &m(pm->second);
for (map<eversion_t, sobject_t>::const_iterator p = m.rmissing.begin();
for (map<version_t, sobject_t>::const_iterator p = m.rmissing.begin();
p != m.rmissing.end() && started < max;
++p) {
const sobject_t soid(p->second);
eversion_t v = p->first;
if (pushing.count(soid)) {
dout(10) << __func__ << ": already pushing " << soid << dendl;
continue;
}
if (missing.is_missing(soid)) {
if (missing_loc.find(soid) == missing_loc.end())
dout(10) << __func__ << ": " << soid << " still unfound" << dendl;
@ -4465,7 +4466,8 @@ int ReplicatedPG::recover_replicas(int max)
}
dout(10) << __func__ << ": recover_object_replicas(" << soid << ")" << dendl;
started += recover_object_replicas(soid, v);
map<sobject_t,Missing::item>::const_iterator p = m.missing.find(soid);
started += recover_object_replicas(soid, p->second.need);
}
}