if (!missing.is_missing(obj, &item)) {
to_remove.insert(key);
} else {
- ::encode(make_pair(obj, item), (*km)[key]);
+ ::encode(obj, (*km)[key]);
+ item.encode_with_flags((*km)[key]);
}
});
if (require_rollback) {
missing.revise_have(oid, have);
}
- void revise_need(hobject_t oid, eversion_t need) {
- missing.revise_need(oid, need);
- }
-
void missing_add(const hobject_t& oid, eversion_t need, eversion_t have) {
- missing.add(oid, need, have);
+ missing.add(oid, need, have, false);
}
//////////////////// get or set log ////////////////////
ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
<< " missing.have is " << missing.get_items().at(hoid).have
<< ", adjusting" << dendl;
- missing.revise_need(hoid, prior_version);
+ missing.revise_need(hoid, prior_version, false);
if (prior_version <= info.log_tail) {
ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
<< " prior_version " << prior_version
rollbacker->trim(i);
}
}
- missing.add(hoid, prior_version, eversion_t());
+ missing.add(hoid, prior_version, eversion_t(), false);
if (prior_version <= info.log_tail) {
ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid
<< " prior_version " << prior_version
// hack to match PG::mark_all_unfound_lost
if (maintain_rollback && p->is_lost_delete() && p->can_rollback()) {
rollbacker->try_stash(p->soid, p->version.version);
- } else if (p->is_delete()) {
+ } else if (p->is_lost_delete()) {
rollbacker->remove(p->soid);
}
}
} else if (p->key() == "rollback_info_trimmed_to") {
::decode(on_disk_rollback_info_trimmed_to, bp);
} else if (p->key().substr(0, 7) == string("missing")) {
- pair<hobject_t, pg_missing_item> p;
- ::decode(p, bp);
- missing.add(p.first, p.second.need, p.second.have);
+ hobject_t oid;
+ pg_missing_item item;
+ ::decode(oid, bp);
+ item.decode_with_flags(bp);
+ missing.add(oid, item.need, item.have, item.is_delete());
} else {
pg_log_entry_t e;
e.decode_with_checksum(bp);
if (did.count(i->soid)) continue;
did.insert(i->soid);
- if (i->is_delete()) continue;
+ // TODO: enable only if we aren't tracking deletes in the log
+ if (i->is_lost_delete()) continue;
bufferlist bv;
int r = store->getattr(
assert(miter->second.have == oi.version);
checked.insert(i->soid);
} else {
- missing.add(i->soid, i->version, oi.version);
+ missing.add(i->soid, i->version, oi.version, i->is_delete());
}
}
} else {
ldpp_dout(dpp, 15) << "read_log_and_missing missing " << *i << dendl;
if (debug_verify_stored_missing) {
auto miter = missing.get_items().find(i->soid);
- assert(miter != missing.get_items().end());
- assert(miter->second.need == i->version);
- assert(miter->second.have == eversion_t());
+ if (i->is_delete()) {
+ assert(miter == missing.get_items().end() ||
+ (miter->second.need == i->version &&
+ miter->second.have == eversion_t()));
+ } else {
+ assert(miter != missing.get_items().end());
+ assert(miter->second.need == i->version);
+ assert(miter->second.have == eversion_t());
+ }
checked.insert(i->soid);
} else {
- missing.add(i->soid, i->version, eversion_t());
+ missing.add(i->soid, i->version, eversion_t(), i->is_delete());
}
}
}
if (i.second.need > log.tail ||
i.first > info.last_backfill) {
ldpp_dout(dpp, -1) << __func__ << ": invalid missing set entry found "
- << i.first
+ << i.first << " " << i.second << " log tail = "
+ << log.tail << " last_backfill = " << info.last_backfill
<< dendl;
assert(0 == "invalid missing set entry found");
}
object_info_t oi(bv);
assert(oi.version == i.second.have);
} else {
- assert(eversion_t() == i.second.have);
+ assert(i.second.is_delete() || eversion_t() == i.second.have);
}
}
} else {
}
} else {
ldpp_dout(dpp, 15) << "read_log_and_missing missing " << *i << dendl;
- missing.add(i->second, i->first, eversion_t());
+ missing.add(i->second, i->first, eversion_t(), false);
}
}
}
*/
struct pg_missing_item {
eversion_t need, have;
- pg_missing_item() {}
- explicit pg_missing_item(eversion_t n) : need(n) {} // have no old version
- pg_missing_item(eversion_t n, eversion_t h) : need(n), have(h) {}
+ enum missing_flags_t {
+ FLAG_NONE = 0,
+ FLAG_DELETE = 1,
+ } flags;
+ pg_missing_item() : flags(FLAG_NONE) {}
+ explicit pg_missing_item(eversion_t n) : need(n), flags(FLAG_NONE) {} // have no old version
+ pg_missing_item(eversion_t n, eversion_t h, bool is_delete=false) : need(n), have(h) {
+ set_delete(is_delete);
+ }
void encode(bufferlist& bl) const {
::encode(need, bl);
::decode(need, bl);
::decode(have, bl);
}
+
+ void set_delete(bool is_delete) {
+ flags = is_delete ? FLAG_DELETE : FLAG_NONE;
+ }
+
+ bool is_delete() const {
+ return (flags & FLAG_DELETE) == FLAG_DELETE;
+ }
+
+ void encode_with_flags(bufferlist& bl) const {
+ encode(bl);
+ ::encode(static_cast<uint8_t>(flags), bl);
+ }
+
+ void decode_with_flags(bufferlist::iterator& bl) {
+ decode(bl);
+ // no versioning on this, but it's stored in a single omap value,
+ // so just check for the end of the bufferlist
+ if (!bl.end()) {
+ uint8_t f;
+ ::decode(f, bl);
+ flags = static_cast<missing_flags_t>(f);
+ }
+ }
+
void dump(Formatter *f) const {
f->dump_stream("need") << need;
f->dump_stream("have") << have;
+ f->dump_stream("flags") << (flags == FLAG_NONE ? "none" : "delete");
}
static void generate_test_instances(list<pg_missing_item*>& o) {
o.push_back(new pg_missing_item);
o.push_back(new pg_missing_item);
o.back()->need = eversion_t(1, 2);
o.back()->have = eversion_t(1, 1);
+ o.push_back(new pg_missing_item);
+ o.back()->need = eversion_t(3, 5);
+ o.back()->have = eversion_t(3, 4);
+ o.back()->flags = FLAG_DELETE;
}
bool operator==(const pg_missing_item &rhs) const {
- return need == rhs.need && have == rhs.have;
+ return need == rhs.need && have == rhs.have && flags == rhs.flags;
}
bool operator!=(const pg_missing_item &rhs) const {
return !(*this == rhs);
* assumes missing is accurate up through the previous log entry.
*/
void add_next_event(const pg_log_entry_t& e) {
- if (e.is_update()) {
- map<hobject_t, item>::iterator missing_it;
- missing_it = missing.find(e.soid);
- bool is_missing_divergent_item = missing_it != missing.end();
- if (e.prior_version == eversion_t() || e.is_clone()) {
- // new object.
- if (is_missing_divergent_item) { // use iterator
- rmissing.erase((missing_it->second).need.version);
- missing_it->second = item(e.version, eversion_t()); // .have = nil
- } else // create new element in missing map
- missing[e.soid] = item(e.version, eversion_t()); // .have = nil
- } else if (is_missing_divergent_item) {
- // already missing (prior).
+ map<hobject_t, item>::iterator missing_it;
+ missing_it = missing.find(e.soid);
+ bool is_missing_divergent_item = missing_it != missing.end();
+ if (e.prior_version == eversion_t() || e.is_clone()) {
+ // new object.
+ if (is_missing_divergent_item) { // use iterator
rmissing.erase((missing_it->second).need.version);
- (missing_it->second).need = e.version; // leave .have unchanged.
- } else if (e.is_backlog()) {
- // May not have prior version
- assert(0 == "these don't exist anymore");
- } else {
- // not missing, we must have prior_version (if any)
- assert(!is_missing_divergent_item);
- missing[e.soid] = item(e.version, e.prior_version);
- }
- rmissing[e.version.version] = e.soid;
- } else if (e.is_delete()) {
- rm(e.soid, e.version);
+ missing_it->second = item(e.version, eversion_t(), e.is_delete()); // .have = nil
+ } else // create new element in missing map
+ missing[e.soid] = item(e.version, eversion_t(), e.is_delete()); // .have = nil
+ } else if (is_missing_divergent_item) {
+ // already missing (prior).
+ rmissing.erase((missing_it->second).need.version);
+ (missing_it->second).need = e.version; // leave .have unchanged.
+ missing_it->second.set_delete(e.is_delete());
+ } else if (e.is_backlog()) {
+ // May not have prior version
+ assert(0 == "these don't exist anymore");
+ } else {
+ // not missing, we must have prior_version (if any)
+ assert(!is_missing_divergent_item);
+ missing[e.soid] = item(e.version, e.prior_version, e.is_delete());
}
-
+ rmissing[e.version.version] = e.soid;
tracker.changed(e.soid);
}
- void revise_need(hobject_t oid, eversion_t need) {
+ void revise_need(hobject_t oid, eversion_t need, bool is_delete) {
if (missing.count(oid)) {
rmissing.erase(missing[oid].need.version);
missing[oid].need = need; // no not adjust .have
+ missing[oid].set_delete(is_delete);
} else {
- missing[oid] = item(need, eversion_t());
+ missing[oid] = item(need, eversion_t(), is_delete);
}
rmissing[need.version] = oid;
}
}
- void add(const hobject_t& oid, eversion_t need, eversion_t have) {
- missing[oid] = item(need, have);
+ void add(const hobject_t& oid, eversion_t need, eversion_t have,
+ bool is_delete) {
+ missing[oid] = item(need, have, is_delete);
rmissing[need.version] = oid;
tracker.changed(oid);
}
void got(const hobject_t& oid, eversion_t v) {
std::map<hobject_t, item>::iterator p = missing.find(oid);
assert(p != missing.end());
- assert(p->second.need <= v);
+ assert(p->second.need <= v || p->second.is_delete());
got(p);
}
i != missing.end();
) {
if ((i->first.get_hash() & mask) == child_pgid.m_seed) {
- omissing->add(i->first, i->second.need, i->second.have);
+ omissing->add(i->first, i->second.need, i->second.have,
+ i->second.is_delete());
rm(i++);
} else {
++i;
}
void encode(bufferlist &bl) const {
- ENCODE_START(3, 2, bl);
+ ENCODE_START(4, 2, bl);
::encode(missing, bl);
+ // since pg_missing_item was not versioned, we encode the new flags
+ // field here explicitly
+ map<hobject_t, uint8_t> missing_flags;
+ for (const auto &p : missing) {
+ if (p.second.flags != pg_missing_item::FLAG_NONE) {
+ missing_flags.insert(make_pair(p.first,
+ static_cast<uint8_t>(p.second.flags)));
+ }
+ }
+ ::encode(missing_flags, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl, int64_t pool = -1) {
for (auto const &i: missing)
tracker.changed(i.first);
- DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
+ DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
::decode(missing, bl);
+ if (struct_v >= 4) {
+ map<hobject_t, uint8_t> missing_flags;
+ ::decode(missing_flags, bl);
+ for (const auto &p : missing_flags) {
+ assert(missing.find(p.first) != missing.end());
+ missing[p.first].flags = static_cast<pg_missing_item::missing_flags_t>(p.second);
+ }
+ }
DECODE_FINISH(bl);
if (struct_v < 3) {
o.push_back(new pg_missing_set);
o.back()->add(
hobject_t(object_t("foo"), "foo", 123, 456, 0, ""),
- eversion_t(5, 6), eversion_t(5, 1));
+ eversion_t(5, 6), eversion_t(5, 1), true);
}
template <typename F>
void get_changed(F &&f) const {
oe.op = pg_log_entry_t::MODIFY;
oe.prior_version = eversion_t();
- missing.add(oe.soid, eversion_t(1,1), eversion_t());
+ missing.add(oe.soid, eversion_t(1,1), eversion_t(), false);
missing.flush();
EXPECT_FALSE(is_dirty());
EXPECT_EQ(1U, log.objects.count(divergent_object));
EXPECT_EQ(4U, log.log.size());
/* DELETE entries from olog that are appended to the hed of the
- log are also added to remove_snap.
+ log, and the divergent version of the object is removed (added
+ to remove_snap)
*/
- EXPECT_EQ(0x7U, remove_snap.front().get_hash());
+ EXPECT_EQ(0x9U, remove_snap.front().get_hash());
EXPECT_EQ(log.head, info.last_update);
EXPECT_TRUE(info.purged_snaps.contains(purged_snap));
EXPECT_TRUE(is_dirty());
e.prior_version = eversion_t(1, 1);
e.soid = divergent_object;
divergent_object = e.soid;
- omissing.add(divergent_object, e.version, eversion_t());
+ omissing.add(divergent_object, e.version, eversion_t(), false);
e.op = pg_log_entry_t::MODIFY;
olog.log.push_back(e);
olog.head = e.version;
e.prior_version = eversion_t(1, 1);
e.soid.set_hash(0x9);
divergent_object = e.soid;
- omissing.add(divergent_object, e.version, eversion_t());
+ omissing.add(divergent_object, e.version, eversion_t(), false);
e.op = pg_log_entry_t::MODIFY;
olog.log.push_back(e);
olog.head = e.version;
t.div.push_back(mk_ple_mod(mk_obj(1), mk_evt(10, 101), mk_evt(10, 100)));
- t.final.add(mk_obj(1), mk_evt(10, 100), mk_evt(0, 0));
+ t.final.add(mk_obj(1), mk_evt(10, 100), mk_evt(0, 0), false);
t.toremove.insert(mk_obj(1));
t.div.push_back(mk_ple_mod(mk_obj(1), mk_evt(10, 101), mk_evt(10, 100)));
t.div.push_back(mk_ple_mod_rb(mk_obj(1), mk_evt(10, 102), mk_evt(10, 101)));
- t.final.add(mk_obj(1), mk_evt(10, 100), mk_evt(0, 0));
+ t.final.add(mk_obj(1), mk_evt(10, 100), mk_evt(0, 0), false);
t.toremove.insert(mk_obj(1));
t.div.push_back(mk_ple_mod_rb(mk_obj(1), mk_evt(10, 101), mk_evt(10, 100)));
t.div.push_back(mk_ple_mod_rb(mk_obj(1), mk_evt(10, 102), mk_evt(10, 101)));
- t.init.add(mk_obj(1), mk_evt(10, 102), mk_evt(0, 0));
- t.final.add(mk_obj(1), mk_evt(10, 100), mk_evt(0, 0));
+ t.init.add(mk_obj(1), mk_evt(10, 102), mk_evt(0, 0), false);
+ t.final.add(mk_obj(1), mk_evt(10, 100), mk_evt(0, 0), false);
t.setup();
run_test_case(t);
t.auth.push_back(mk_ple_mod(mk_obj(1), mk_evt(11, 101), mk_evt(10, 100)));
- t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(0, 0));
+ t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(0, 0), false);
t.toremove.insert(mk_obj(1));
t.auth.push_back(mk_ple_mod(mk_obj(1), mk_evt(11, 101), mk_evt(10, 100)));
- t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(10, 100));
+ t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(10, 100), false);
t.setup();
run_test_case(t);
t.auth.push_back(mk_ple_mod(mk_obj(1), mk_evt(11, 101), mk_evt(10, 100)));
- t.init.add(mk_obj(1), mk_evt(10, 100), mk_evt(8, 80));
- t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(8, 80));
+ t.init.add(mk_obj(1), mk_evt(10, 100), mk_evt(8, 80), false);
+ t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(8, 80), false);
t.setup();
run_test_case(t);
t.auth.push_back(mk_ple_dt(mk_obj(1), mk_evt(11, 101), mk_evt(10, 100)));
- t.init.add(mk_obj(1), mk_evt(10, 100), mk_evt(8, 80));
-
- t.toremove.insert(mk_obj(1));
+ t.init.add(mk_obj(1), mk_evt(10, 100), mk_evt(8, 80), false);
+ t.final.add(mk_obj(1), mk_evt(11, 101), mk_evt(8, 80), true);
t.setup();
run_test_case(t);
t.div.push_back(mk_ple_mod(mk_obj(1), mk_evt(10, 101), mk_evt(10, 100)));
- t.init.add(mk_obj(1), mk_evt(10, 101), mk_evt(10, 100));
+ t.init.add(mk_obj(1), mk_evt(10, 101), mk_evt(10, 100), false);
t.setup();
run_test_case(t);
t.setup();
t.set_div_bounds(mk_evt(9, 79), mk_evt(8, 69));
t.set_auth_bounds(mk_evt(15, 160), mk_evt(9, 77));
- t.final.add(mk_obj(1), mk_evt(15, 150), mk_evt(8, 70));
+ t.final.add(mk_obj(1), mk_evt(15, 150), mk_evt(8, 70), false);
run_test_case(t);
}
t.setup();
t.set_div_bounds(mk_evt(15, 153), mk_evt(15, 151));
t.set_auth_bounds(mk_evt(15, 156), mk_evt(10, 99));
- t.final.add(mk_obj(1), mk_evt(15, 155), mk_evt(15, 150));
+ t.final.add(mk_obj(1), mk_evt(15, 155), mk_evt(15, 150), false);
run_test_case(t);
}
t.setup();
t.set_div_bounds(mk_evt(15, 153), mk_evt(15, 151));
t.set_auth_bounds(mk_evt(16, 156), mk_evt(10, 99));
- t.final.add(mk_obj(1), mk_evt(16, 155), mk_evt(0, 0));
+ t.final.add(mk_obj(1), mk_evt(16, 155), mk_evt(0, 0), false);
t.toremove.insert(mk_obj(1));
run_test_case(t);
}
hobject_t oid(object_t("objname"), "key", 123, 456, 0, "");
pg_missing_t missing;
EXPECT_FALSE(missing.have_missing());
- missing.add(oid, eversion_t(), eversion_t());
+ missing.add(oid, eversion_t(), eversion_t(), false);
EXPECT_TRUE(missing.have_missing());
}
hobject_t oid(object_t("objname"), "key", 123, 456, 0, "");
pg_missing_t missing;
EXPECT_FALSE(missing.have_missing());
- missing.add(oid, eversion_t(), eversion_t());
+ missing.add(oid, eversion_t(), eversion_t(), false);
EXPECT_TRUE(missing.have_missing());
pg_missing_t other;
hobject_t oid(object_t("objname"), "key", 123, 456, 0, "");
pg_missing_t missing;
EXPECT_FALSE(missing.is_missing(oid));
- missing.add(oid, eversion_t(), eversion_t());
+ missing.add(oid, eversion_t(), eversion_t(), false);
EXPECT_TRUE(missing.is_missing(oid));
}
pg_missing_t missing;
eversion_t need(10,5);
EXPECT_FALSE(missing.is_missing(oid, eversion_t()));
- missing.add(oid, need, eversion_t());
+ missing.add(oid, need, eversion_t(), false);
EXPECT_TRUE(missing.is_missing(oid));
EXPECT_FALSE(missing.is_missing(oid, eversion_t()));
EXPECT_TRUE(missing.is_missing(oid, need));
hobject_t oid(object_t("objname"), "key", 123, 456, 0, "");
pg_missing_t missing;
EXPECT_EQ(eversion_t(), missing.have_old(oid));
- missing.add(oid, eversion_t(), eversion_t());
+ missing.add(oid, eversion_t(), eversion_t(), false);
EXPECT_EQ(eversion_t(), missing.have_old(oid));
eversion_t have(1,1);
missing.revise_have(oid, have);
e.op = pg_log_entry_t::DELETE;
EXPECT_TRUE(e.is_delete());
missing.add_next_event(e);
- EXPECT_FALSE(missing.have_missing());
- }
-
- // ERROR op should only be used for dup detection
- {
- pg_missing_t missing;
- pg_log_entry_t e = sample_e;
-
- e.op = pg_log_entry_t::ERROR;
- e.return_code = -ENOENT;
- EXPECT_FALSE(e.is_update());
- EXPECT_FALSE(e.object_is_indexed());
- EXPECT_TRUE(e.reqid_is_indexed());
- EXPECT_FALSE(missing.is_missing(oid));
- missing.add_next_event(e);
- EXPECT_FALSE(missing.is_missing(oid));
- EXPECT_FALSE(e.object_is_indexed());
- EXPECT_TRUE(e.reqid_is_indexed());
- }
-
- // ERROR op should not affect previous entries
- {
- pg_missing_t missing;
- pg_log_entry_t modify = sample_e;
-
- modify.op = pg_log_entry_t::MODIFY;
- EXPECT_FALSE(missing.is_missing(oid));
- missing.add_next_event(modify);
- EXPECT_TRUE(missing.is_missing(oid));
- EXPECT_EQ(missing.get_items().at(oid).need, version);
-
- pg_log_entry_t error = sample_e;
- error.op = pg_log_entry_t::ERROR;
- error.return_code = -ENOENT;
- error.version = eversion_t(11, 5);
- missing.add_next_event(error);
EXPECT_TRUE(missing.is_missing(oid));
- EXPECT_EQ(missing.get_items().at(oid).need, version);
+ EXPECT_EQ(prior_version, missing.get_items().at(oid).have);
+ EXPECT_EQ(version, missing.get_items().at(oid).need);
+ EXPECT_TRUE(missing.get_items().at(oid).is_delete());
+ EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version));
+ EXPECT_EQ(1U, missing.num_missing());
+ EXPECT_EQ(1U, missing.get_rmissing().size());
}
}
// create a new entry
EXPECT_FALSE(missing.is_missing(oid));
eversion_t need(10,10);
- missing.revise_need(oid, need);
+ missing.revise_need(oid, need, false);
EXPECT_TRUE(missing.is_missing(oid));
EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have);
EXPECT_EQ(need, missing.get_items().at(oid).need);
missing.revise_have(oid, have);
eversion_t new_need(10,12);
EXPECT_EQ(have, missing.get_items().at(oid).have);
- missing.revise_need(oid, new_need);
+ missing.revise_need(oid, new_need, false);
EXPECT_EQ(have, missing.get_items().at(oid).have);
EXPECT_EQ(new_need, missing.get_items().at(oid).need);
}
EXPECT_FALSE(missing.is_missing(oid));
// update an existing entry
eversion_t need(10,12);
- missing.add(oid, need, have);
+ missing.add(oid, need, have, false);
EXPECT_TRUE(missing.is_missing(oid));
eversion_t new_have(2,2);
EXPECT_EQ(have, missing.get_items().at(oid).have);
EXPECT_FALSE(missing.is_missing(oid));
eversion_t have(1,1);
eversion_t need(10,10);
- missing.add(oid, need, have);
+ missing.add(oid, need, have, false);
EXPECT_TRUE(missing.is_missing(oid));
EXPECT_EQ(have, missing.get_items().at(oid).have);
EXPECT_EQ(need, missing.get_items().at(oid).need);
EXPECT_FALSE(missing.is_missing(oid));
epoch_t epoch = 10;
eversion_t need(epoch,10);
- missing.add(oid, need, eversion_t());
+ missing.add(oid, need, eversion_t(), false);
EXPECT_TRUE(missing.is_missing(oid));
// rm of an older version is a noop
missing.rm(oid, eversion_t(epoch / 2,20));
hobject_t oid(object_t("objname"), "key", 123, 456, 0, "");
pg_missing_t missing;
EXPECT_FALSE(missing.is_missing(oid));
- missing.add(oid, eversion_t(), eversion_t());
+ missing.add(oid, eversion_t(), eversion_t(), false);
EXPECT_TRUE(missing.is_missing(oid));
auto m = missing.get_items().find(oid);
missing.rm(m);
EXPECT_FALSE(missing.is_missing(oid));
epoch_t epoch = 10;
eversion_t need(epoch,10);
- missing.add(oid, need, eversion_t());
+ missing.add(oid, need, eversion_t(), false);
EXPECT_TRUE(missing.is_missing(oid));
// assert if that the version to be removed is lower than the version of the object
{
hobject_t oid(object_t("objname"), "key", 123, 456, 0, "");
pg_missing_t missing;
EXPECT_FALSE(missing.is_missing(oid));
- missing.add(oid, eversion_t(), eversion_t());
+ missing.add(oid, eversion_t(), eversion_t(), false);
EXPECT_TRUE(missing.is_missing(oid));
auto m = missing.get_items().find(oid);
missing.got(m);
uint32_t hash2 = 2;
hobject_t oid2(object_t("objname"), "key2", 123, hash2, 0, "");
pg_missing_t missing;
- missing.add(oid1, eversion_t(), eversion_t());
- missing.add(oid2, eversion_t(), eversion_t());
+ missing.add(oid1, eversion_t(), eversion_t(), false);
+ missing.add(oid2, eversion_t(), eversion_t(), false);
pg_t child_pgid;
child_pgid.m_seed = 1;
pg_missing_t child;
projects / ceph-ci.git / commitdiff