bufferlist sbl;
sbl.substr_of(bl, 0, t);
ObjectStore::Transaction tr;
- sobject_t oid(poid, 0);
+ hobject_t oid(poid, 0);
tr.write(coll_t(), oid, off, t, sbl);
store->apply_transaction(tr);
off += t;
generic_dout(2) << "age_empty at " << free << " / " << avail << " / " << pc << " removing " << hex << poid << dec << dendl;
ObjectStore::Transaction t;
- sobject_t oid(poid, 0);
+ hobject_t oid(poid, 0);
t.remove(coll_t(), oid);
store->apply_transaction(t);
age_free_oids.push_back(poid);
object_t oid("disk_bw_test");
for (int i=0; i<1000; i++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- t->write(coll_t::META_COLL, sobject_t(oid, 0), i*bl.length(), bl.length(), bl);
+ t->write(coll_t::META_COLL, hobject_t(oid, 0), i*bl.length(), bl.length(), bl);
store->queue_transaction(NULL, t);
}
store->sync();
end -= start;
dout(0) << "measured " << (1000.0 / (double)end) << " mb/sec" << dendl;
ObjectStore::Transaction tr;
- tr.remove(coll_t::META_COLL, sobject_t(oid, 0));
+ tr.remove(coll_t::META_COLL, hobject_t(oid, 0));
ret = store->apply_transaction(tr);
if (ret) {
derr << "OSD::mkfs: error while benchmarking: apply_transaction returned "
{
dout(10) << "clear_temp" << dendl;
- vector<sobject_t> objects;
+ vector<hobject_t> objects;
store->collection_list(coll_t::TEMP_COLL, objects);
dout(10) << objects.size() << " objects" << dendl;
// delete them.
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- for (vector<sobject_t>::iterator p = objects.begin();
+ for (vector<hobject_t>::iterator p = objects.begin();
p != objects.end();
p++)
t->collection_remove(coll_t::TEMP_COLL, *p);
// create
PG *pg;
- sobject_t logoid = make_pg_log_oid(pgid);
- sobject_t infooid = make_pg_biginfo_oid(pgid);
+ hobject_t logoid = make_pg_log_oid(pgid);
+ hobject_t infooid = make_pg_biginfo_oid(pgid);
if (osdmap->get_pg_type(pgid) == CEPH_PG_TYPE_REP)
pg = new ReplicatedPG(this, pool, pgid, logoid, infooid);
else
char nm[30];
snprintf(nm, sizeof(nm), "disk_bw_test_%lld", (long long)pos);
object_t oid(nm);
- sobject_t soid(oid, 0);
+ hobject_t soid(oid, 0);
ObjectStore::Transaction *t = new ObjectStore::Transaction;
t->write(coll_t::META_COLL, soid, 0, bsize, bl);
store->queue_transaction(NULL, t);
pg->lock();
fout << *pg << std::endl;
- std::map<sobject_t, PG::Missing::item>::iterator mend = pg->missing.missing.end();
- std::map<sobject_t, PG::Missing::item>::iterator mi = pg->missing.missing.begin();
+ std::map<hobject_t, PG::Missing::item>::iterator mend = pg->missing.missing.end();
+ std::map<hobject_t, PG::Missing::item>::iterator mi = pg->missing.missing.begin();
for (; mi != mend; ++mi) {
fout << mi->first << " -> " << mi->second << std::endl;
- map<sobject_t, set<int> >::const_iterator mli =
+ map<hobject_t, set<int> >::const_iterator mli =
pg->missing_loc.find(mi->first);
if (mli == pg->missing_loc.end())
continue;
o->decode(bl);
add_map(o);
- sobject_t fulloid = get_osdmap_pobject_name(e);
+ hobject_t fulloid = get_osdmap_pobject_name(e);
t.write(coll_t::META_COLL, fulloid, 0, bl.length(), bl);
add_map_bl(e, bl);
continue;
if (p != m->incremental_maps.end()) {
dout(10) << "handle_osd_map got inc map for epoch " << e << dendl;
bufferlist& bl = p->second;
- sobject_t oid = get_inc_osdmap_pobject_name(e);
+ hobject_t oid = get_inc_osdmap_pobject_name(e);
t.write(coll_t::META_COLL, oid, 0, bl.length(), bl);
add_map_inc_bl(e, bl);
bufferlist fbl;
o->encode(fbl);
- sobject_t fulloid = get_osdmap_pobject_name(e);
+ hobject_t fulloid = get_osdmap_pobject_name(e);
t.write(coll_t::META_COLL, fulloid, 0, fbl.length(), fbl);
add_map_bl(e, fbl);
continue;
pg_t parentid = parent->info.pgid;
// split objects
- vector<sobject_t> olist;
+ vector<hobject_t> olist;
store->collection_list(coll_t(parent->info.pgid), olist);
- for (vector<sobject_t>::iterator p = olist.begin(); p != olist.end(); p++) {
- sobject_t poid = *p;
+ for (vector<hobject_t>::iterator p = olist.begin(); p != olist.end(); p++) {
+ hobject_t poid = *p;
ceph_object_layout l = osdmap->make_object_layout(poid.oid, parentid.pool(), parentid.preferred());
pg_t pgid = osdmap->raw_pg_to_pg(pg_t(l.ol_pgid));
if (pgid != parentid) {
while (p != parent->log.log.end()) {
list<PG::Log::Entry>::iterator cur = p;
p++;
- sobject_t& poid = cur->soid;
+ hobject_t& poid = cur->soid;
ceph_object_layout l = osdmap->make_object_layout(poid.oid, parentid.pool(), parentid.preferred());
pg_t pgid = osdmap->raw_pg_to_pg(pg_t(l.ol_pgid));
if (pgid != parentid) {
for (snapid_t cur = p.get_start();
cur < p.get_start() + p.get_len();
++cur) {
- vector<sobject_t> olist;
+ vector<hobject_t> olist;
store->collection_list(coll_t(pgid, cur), olist);
dout(10) << "_remove_pg " << pgid << " snap " << cur << " " << olist.size() << " objects" << dendl;
- for (vector<sobject_t>::iterator q = olist.begin();
+ for (vector<hobject_t>::iterator q = olist.begin();
q != olist.end();
q++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
}
// (what remains of the) main collection
- vector<sobject_t> olist;
+ vector<hobject_t> olist;
store->collection_list(coll_t(pgid), olist);
dout(10) << "_remove_pg " << pgid << " " << olist.size() << " objects" << dendl;
- for (vector<sobject_t>::iterator p = olist.begin();
+ for (vector<hobject_t>::iterator p = olist.begin();
p != olist.end();
p++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
pg->put();
}
-void OSD::start_recovery_op(PG *pg, const sobject_t& soid)
+void OSD::start_recovery_op(PG *pg, const hobject_t& soid)
{
recovery_wq.lock();
dout(10) << "start_recovery_op " << *pg << " " << soid
recovery_wq.unlock();
}
-void OSD::finish_recovery_op(PG *pg, const sobject_t& soid, bool dequeue)
+void OSD::finish_recovery_op(PG *pg, const hobject_t& soid, bool dequeue)
{
dout(10) << "finish_recovery_op " << *pg << " " << soid
<< " dequeue=" << dequeue
if ((op->get_flags() & CEPH_OSD_FLAG_PGOP) == 0) {
// missing object?
- sobject_t head(op->get_oid(), CEPH_NOSNAP);
+ hobject_t head(op->get_oid(), CEPH_NOSNAP);
if (pg->is_missing_object(head)) {
pg->wait_for_missing_object(head, op);
pg->unlock();
ClassHandler *class_handler;
int get_nodeid() { return whoami; }
- static sobject_t get_osdmap_pobject_name(epoch_t epoch) {
+ static hobject_t get_osdmap_pobject_name(epoch_t epoch) {
char foo[20];
snprintf(foo, sizeof(foo), "osdmap.%d", epoch);
- return sobject_t(object_t(foo), 0);
+ return hobject_t(object_t(foo), 0);
}
- static sobject_t get_inc_osdmap_pobject_name(epoch_t epoch) {
+ static hobject_t get_inc_osdmap_pobject_name(epoch_t epoch) {
char foo[20];
snprintf(foo, sizeof(foo), "inc_osdmap.%d", epoch);
- return sobject_t(object_t(foo), 0);
+ return hobject_t(object_t(foo), 0);
}
- sobject_t make_pg_log_oid(pg_t pg) {
+ hobject_t make_pg_log_oid(pg_t pg) {
stringstream ss;
ss << "pglog_" << pg;
string s;
getline(ss, s);
- return sobject_t(object_t(s.c_str()), 0);
+ return hobject_t(object_t(s.c_str()), 0);
}
- sobject_t make_pg_biginfo_oid(pg_t pg) {
+ hobject_t make_pg_biginfo_oid(pg_t pg) {
stringstream ss;
ss << "pginfo_" << pg;
string s;
getline(ss, s);
- return sobject_t(object_t(s.c_str()), 0);
+ return hobject_t(object_t(s.c_str()), 0);
}
utime_t defer_recovery_until;
int recovery_ops_active;
#ifdef DEBUG_RECOVERY_OIDS
- map<pg_t, set<sobject_t> > recovery_oids;
+ map<pg_t, set<hobject_t> > recovery_oids;
#endif
struct RecoveryWQ : public ThreadPool::WorkQueue<PG> {
} recovery_wq;
bool queue_for_recovery(PG *pg);
- void start_recovery_op(PG *pg, const sobject_t& soid);
- void finish_recovery_op(PG *pg, const sobject_t& soid, bool dequeue);
+ void start_recovery_op(PG *pg, const hobject_t& soid);
+ void finish_recovery_op(PG *pg, const hobject_t& soid, bool dequeue);
void defer_recovery(PG *pg);
void do_recovery(PG *pg);
bool _recover_now();
we will send the peer enough log to arrive at the same state.
*/
- for (map<sobject_t, Missing::item>::iterator i = omissing.missing.begin();
+ for (map<hobject_t, Missing::item>::iterator i = omissing.missing.begin();
i != omissing.missing.end();
++i) {
dout(10) << "Missing sobject: " << i->first << dendl;
might_have_unfound.insert(from);
search_for_missing(oinfo, &omissing, from);
- for (map<sobject_t, Missing::item>::iterator i = omissing.missing.begin();
+ for (map<hobject_t, Missing::item>::iterator i = omissing.missing.begin();
i != omissing.missing.end();
++i) {
dout(10) << "Final Missing sobject: " << i->first << dendl;
// If the logs don't overlap, we need both backlogs
assert(log.head >= olog.tail || ((log.backlog || log.empty()) && olog.backlog));
- for (map<sobject_t, Missing::item>::iterator i = missing.missing.begin();
+ for (map<hobject_t, Missing::item>::iterator i = missing.missing.begin();
i != missing.missing.end();
++i) {
dout(20) << "Missing sobject: " << i->first << dendl;
if (log.head < olog.tail) {
// We need to throw away our log and process the backlogs
- hash_map<sobject_t, Log::Entry*> old_objects;
+ hash_map<hobject_t, Log::Entry*> old_objects;
old_objects.swap(log.objects);
// swap in other log and index
if (p->version <= log.head) {
dout(10) << "merge_log split point is " << *p << dendl;
- hash_map<sobject_t,Log::Entry*>::const_iterator oldobj = old_objects.find(p->soid);
+ hash_map<hobject_t,Log::Entry*>::const_iterator oldobj = old_objects.find(p->soid);
if (oldobj != old_objects.end() &&
oldobj->second->version == p->version)
p++; // move past the split point, if it also exists in our old log...
}
// Remove objects whose removals we missed
- for (hash_map<sobject_t, Log::Entry*>::iterator i = old_objects.begin();
+ for (hash_map<hobject_t, Log::Entry*>::iterator i = old_objects.begin();
i != old_objects.end();
++i) {
if (!log.objects.count(i->first)) {
bool found_missing = false;
// found items?
- for (map<sobject_t,Missing::item>::iterator p = missing.missing.begin();
+ for (map<hobject_t,Missing::item>::iterator p = missing.missing.begin();
p != missing.missing.end();
++p) {
- const sobject_t &soid(p->first);
+ const hobject_t &soid(p->first);
eversion_t need = p->second.need;
if (oinfo.last_update < need) {
dout(10) << "search_for_missing " << soid << " " << need
dout(10) << "search_for_missing " << soid << " " << need
<< " is on osd" << fromosd << dendl;
- map<sobject_t, set<int> >::iterator ml = missing_loc.find(soid);
+ map<hobject_t, set<int> >::iterator ml = missing_loc.find(soid);
if (ml == missing_loc.end()) {
- map<sobject_t, list<class Message*> >::iterator wmo =
+ map<hobject_t, list<class Message*> >::iterator wmo =
waiting_for_missing_object.find(soid);
if (wmo != waiting_for_missing_object.end()) {
osd->take_waiters(wmo->second);
unlock();
- vector<sobject_t> olist;
+ vector<hobject_t> olist;
osd->store->collection_list(coll, olist);
- for (vector<sobject_t>::iterator it = olist.begin();
+ for (vector<hobject_t>::iterator it = olist.begin();
it != olist.end();
it++) {
- sobject_t poid = *it;
+ hobject_t poid = *it;
Log::Entry e;
e.soid = poid;
/* Mark an object as lost
*/
void PG::mark_obj_as_lost(ObjectStore::Transaction& t,
- const sobject_t &lost_soid)
+ const hobject_t &lost_soid)
{
// Wake anyone waiting for this object. Now that it's been marked as lost,
// we will just return an error code.
- map<sobject_t, list<class Message*> >::iterator wmo =
+ map<hobject_t, list<class Message*> >::iterator wmo =
waiting_for_missing_object.find(lost_soid);
if (wmo != waiting_for_missing_object.end()) {
osd->take_waiters(wmo->second);
utime_t mtime = ceph_clock_now(g_ceph_context);
eversion_t old_last_update = info.last_update;
info.last_update.epoch = osd->osdmap->get_epoch();
- map<sobject_t, Missing::item>::iterator m = missing.missing.begin();
- map<sobject_t, Missing::item>::iterator mend = missing.missing.end();
+ map<hobject_t, Missing::item>::iterator m = missing.missing.begin();
+ map<hobject_t, Missing::item>::iterator mend = missing.missing.end();
while (m != mend) {
- const sobject_t &soid(m->first);
+ const hobject_t &soid(m->first);
if (missing_loc.find(soid) != missing_loc.end()) {
// We only care about unfound objects
++m;
put();
}
-void PG::start_recovery_op(const sobject_t& soid)
+void PG::start_recovery_op(const hobject_t& soid)
{
dout(10) << "start_recovery_op " << soid
#ifdef DEBUG_RECOVERY_OIDS
osd->start_recovery_op(this, soid);
}
-void PG::finish_recovery_op(const sobject_t& soid, bool dequeue)
+void PG::finish_recovery_op(const hobject_t& soid, bool dequeue)
{
dout(10) << "finish_recovery_op " << soid
#ifdef DEBUG_RECOVERY_OIDS
log.reset_recovery_pointers();
finish_sync_event = 0;
- sobject_t soid;
+ hobject_t soid;
while (recovery_ops_active > 0) {
#ifdef DEBUG_RECOVERY_OIDS
soid = *recovering_oids.begin();
dout(10) << "read_log checking for missing items over interval (" << info.last_complete
<< "," << info.last_update << "]" << dendl;
- set<sobject_t> did;
+ set<hobject_t> did;
for (list<Log::Entry>::reverse_iterator i = log.log.rbegin();
i != log.log.rend();
i++) {
}
}
-void PG::take_object_waiters(map<sobject_t, list<Message*> >& m)
+void PG::take_object_waiters(map<hobject_t, list<Message*> >& m)
{
- for (map<sobject_t, list<Message*> >::iterator it = m.begin();
+ for (map<hobject_t, list<Message*> >::iterator it = m.begin();
it != m.end();
it++)
osd->take_waiters(it->second);
/*
* pg lock may or may not be held
*/
-void PG::_scan_list(ScrubMap &map, vector<sobject_t> &ls)
+void PG::_scan_list(ScrubMap &map, vector<hobject_t> &ls)
{
dout(10) << "_scan_list scanning " << ls.size() << " objects" << dendl;
int i = 0;
- for (vector<sobject_t>::iterator p = ls.begin();
+ for (vector<hobject_t>::iterator p = ls.begin();
p != ls.end();
p++, i++) {
- sobject_t poid = *p;
+ hobject_t poid = *p;
struct stat st;
int r = osd->store->stat(coll, poid, &st);
dout(10) << "scrub requesting reserve from osd" << acting[i] << dendl;
vector<OSDOp> scrub(1);
scrub[0].op.op = CEPH_OSD_OP_SCRUB_RESERVE;
- sobject_t poid;
+ hobject_t poid;
eversion_t v;
osd_reqid_t reqid;
MOSDSubOp *subop = new MOSDSubOp(reqid, info.pgid, poid, false, 0,
dout(10) << "scrub requesting unreserve from osd" << acting[i] << dendl;
vector<OSDOp> scrub(1);
scrub[0].op.op = CEPH_OSD_OP_SCRUB_UNRESERVE;
- sobject_t poid;
+ hobject_t poid;
eversion_t v;
osd_reqid_t reqid;
MOSDSubOp *subop = new MOSDSubOp(reqid, info.pgid, poid, false, 0,
osr.flush();
// objects
- vector<sobject_t> ls;
+ vector<hobject_t> ls;
osd->store->collection_list(coll, ls);
_scan_list(map, ls);
{
map.valid_through = last_update_applied;
map.incr_since = v;
- vector<sobject_t> ls;
+ vector<hobject_t> ls;
list<Log::Entry>::iterator p;
if (v == log.tail) {
p = log.log.begin();
osd->store->read(coll_t(), log_oid, 0, 0, map.logbl);
}
-void PG::repair_object(const sobject_t& soid, ScrubMap::object *po, int bad_peer, int ok_peer)
+void PG::repair_object(const hobject_t& soid, ScrubMap::object *po, int bad_peer, int ok_peer)
{
eversion_t v;
bufferlist bv;
vector<OSDOp> scrub(1);
scrub[0].op.op = CEPH_OSD_OP_SCRUB_MAP;
- sobject_t poid;
+ hobject_t poid;
eversion_t v;
osd_reqid_t reqid;
MOSDSubOp *subop = new MOSDSubOp(reqid, info.pgid, poid, false, 0,
}
void PG::_compare_scrubmaps(const map<int,ScrubMap*> &maps,
- map<sobject_t, set<int> > &missing,
- map<sobject_t, set<int> > &inconsistent,
- map<sobject_t, int> &authoritative,
+ map<hobject_t, set<int> > &missing,
+ map<hobject_t, set<int> > &inconsistent,
+ map<hobject_t, int> &authoritative,
ostream &errorstream)
{
- map<sobject_t,ScrubMap::object>::const_iterator i;
+ map<hobject_t,ScrubMap::object>::const_iterator i;
map<int, ScrubMap *>::const_iterator j;
- set<sobject_t> master_set;
+ set<hobject_t> master_set;
// Construct master set
for (j = maps.begin(); j != maps.end(); j++) {
}
// Check maps against master set and each other
- for (set<sobject_t>::const_iterator k = master_set.begin();
+ for (set<hobject_t>::const_iterator k = master_set.begin();
k != master_set.end();
k++) {
map<int, ScrubMap *>::const_iterator auth = maps.end();
stringstream ss;
// Maps from objects with erros to missing/inconsistent peers
- map<sobject_t, set<int> > missing;
- map<sobject_t, set<int> > inconsistent;
+ map<hobject_t, set<int> > missing;
+ map<hobject_t, set<int> > inconsistent;
// Map from object with errors to good peer
- map<sobject_t, int> authoritative;
+ map<hobject_t, int> authoritative;
map<int,ScrubMap *> maps;
dout(2) << "scrub osd" << acting[0] << " has "
state_set(PG_STATE_INCONSISTENT);
if (repair) {
state_clear(PG_STATE_CLEAN);
- for (map<sobject_t, int>::iterator i = authoritative.begin();
+ for (map<hobject_t, int>::iterator i = authoritative.begin();
i != authoritative.end();
i++) {
set<int>::iterator j;
rmissing.swap(o.rmissing);
}
-bool PG::Missing::is_missing(const sobject_t& oid) const
+bool PG::Missing::is_missing(const hobject_t& oid) const
{
return (missing.find(oid) != missing.end());
}
-bool PG::Missing::is_missing(const sobject_t& oid, eversion_t v) const
+bool PG::Missing::is_missing(const hobject_t& oid, eversion_t v) const
{
- map<sobject_t, item>::const_iterator m = missing.find(oid);
+ map<hobject_t, item>::const_iterator m = missing.find(oid);
if (m == missing.end())
return false;
const Missing::item &item(m->second);
return true;
}
-eversion_t PG::Missing::have_old(const sobject_t& oid) const
+eversion_t PG::Missing::have_old(const hobject_t& oid) const
{
- map<sobject_t, item>::const_iterator m = missing.find(oid);
+ map<hobject_t, item>::const_iterator m = missing.find(oid);
if (m == missing.end())
return eversion_t();
const Missing::item &item(m->second);
rm(e.soid, e.version);
}
-void PG::Missing::revise_need(sobject_t oid, eversion_t need)
+void PG::Missing::revise_need(hobject_t oid, eversion_t need)
{
if (missing.count(oid)) {
rmissing.erase(missing[oid].need.version);
rmissing[need.version] = oid;
}
-void PG::Missing::add(const sobject_t& oid, eversion_t need, eversion_t have)
+void PG::Missing::add(const hobject_t& oid, eversion_t need, eversion_t have)
{
missing[oid] = item(need, have);
rmissing[need.version] = oid;
}
-void PG::Missing::rm(const sobject_t& oid, eversion_t v)
+void PG::Missing::rm(const hobject_t& oid, eversion_t v)
{
if (missing.count(oid) && missing[oid].need <= v) {
rmissing.erase(missing[oid].need.version);
}
}
-void PG::Missing::got(const sobject_t& oid, eversion_t v)
+void PG::Missing::got(const hobject_t& oid, eversion_t v)
{
assert(missing.count(oid));
assert(missing[oid].need <= v);
missing.erase(oid);
}
-void PG::Missing::got(const std::map<sobject_t, Missing::item>::iterator &m)
+void PG::Missing::got(const std::map<hobject_t, Missing::item>::iterator &m)
{
rmissing.erase(m->second.need.version);
missing.erase(m);
};
__s32 op;
- sobject_t soid;
+ hobject_t soid;
eversion_t version, prior_version;
osd_reqid_t reqid; // caller+tid to uniquely identify request
utime_t mtime; // this is the _user_ mtime, mind you
bufferlist snaps; // only for clone entries
Entry() : op(0) {}
- Entry(int _op, const sobject_t& _soid,
+ Entry(int _op, const hobject_t& _soid,
const eversion_t& v, const eversion_t& pv,
const osd_reqid_t& rid, const utime_t& mt) :
op(_op), soid(_soid), version(v),
* plus some methods to manipulate it all.
*/
struct IndexedLog : public Log {
- hash_map<sobject_t,Entry*> objects; // ptrs into log. be careful!
+ hash_map<hobject_t,Entry*> objects; // ptrs into log. be careful!
hash_map<osd_reqid_t,Entry*> caller_ops;
// recovery pointers
last_requested = 0;
}
- bool logged_object(const sobject_t& oid) const {
+ bool logged_object(const hobject_t& oid) const {
return objects.count(oid);
}
bool logged_req(const osd_reqid_t &r) const {
// accessors
- Entry *is_updated(const sobject_t& oid) {
+ Entry *is_updated(const hobject_t& oid) {
if (objects.count(oid) && objects[oid]->is_update()) return objects[oid];
return 0;
}
- Entry *is_deleted(const sobject_t& oid) {
+ Entry *is_deleted(const hobject_t& oid) {
if (objects.count(oid) && objects[oid]->is_delete()) return objects[oid];
return 0;
}
};
WRITE_CLASS_ENCODER(item)
- map<sobject_t, item> missing; // oid -> (need v, have v)
- map<version_t, sobject_t> rmissing; // v -> oid
+ map<hobject_t, item> missing; // oid -> (need v, have v)
+ map<version_t, hobject_t> rmissing; // v -> oid
unsigned int num_missing() const;
bool have_missing() const;
void swap(Missing& o);
- bool is_missing(const sobject_t& oid) const;
- bool is_missing(const sobject_t& oid, eversion_t v) const;
- eversion_t have_old(const sobject_t& oid) const;
+ bool is_missing(const hobject_t& oid) const;
+ bool is_missing(const hobject_t& oid, eversion_t v) const;
+ eversion_t have_old(const hobject_t& oid) const;
void add_next_event(Log::Entry& e, const Info &info);
- void revise_need(sobject_t oid, eversion_t need);
- void add(const sobject_t& oid, eversion_t need, eversion_t have);
- void rm(const sobject_t& oid, eversion_t v);
- void got(const sobject_t& oid, eversion_t v);
- void got(const std::map<sobject_t, Missing::item>::iterator &m);
+ void revise_need(hobject_t oid, eversion_t need);
+ void add(const hobject_t& oid, eversion_t need, eversion_t have);
+ void rm(const hobject_t& oid, eversion_t v);
+ void got(const hobject_t& oid, eversion_t v);
+ void got(const std::map<hobject_t, Missing::item>::iterator &m);
void encode(bufferlist &bl) const {
__u8 struct_v = 1;
::decode(struct_v, bl);
::decode(missing, bl);
- for (map<sobject_t,item>::iterator it = missing.begin();
+ for (map<hobject_t,item>::iterator it = missing.begin();
it != missing.end();
++it)
rmissing[it->second.need.version] = it->first;
Info info;
const coll_t coll;
IndexedLog log;
- sobject_t log_oid;
- sobject_t biginfo_oid;
+ hobject_t log_oid;
+ hobject_t biginfo_oid;
OndiskLog ondisklog;
Missing missing;
- map<sobject_t, set<int> > missing_loc;
+ map<hobject_t, set<int> > missing_loc;
interval_set<snapid_t> snap_collections;
map<epoch_t,Interval> past_intervals;
xlist<PG*>::item recovery_item, backlog_item, scrub_item, scrub_finalize_item, snap_trim_item, remove_item, stat_queue_item;
int recovery_ops_active;
#ifdef DEBUG_RECOVERY_OIDS
- set<sobject_t> recovering_oids;
+ set<hobject_t> recovering_oids;
#endif
epoch_t generate_backlog_epoch; // epoch we decided to build a backlog.
// pg waiters
list<class Message*> waiting_for_active;
- map<sobject_t, list<class Message*> > waiting_for_missing_object,
+ map<hobject_t, list<class Message*> > waiting_for_missing_object,
waiting_for_degraded_object;
map<eversion_t,list<Message*> > waiting_for_ondisk;
map<eversion_t,class MOSDOp*> replay_queue;
- void take_object_waiters(map<sobject_t, list<Message*> >& m);
+ void take_object_waiters(map<hobject_t, list<Message*> >& m);
bool block_if_wrlocked(MOSDOp* op, object_info_t& oi);
bool all_unfound_are_lost(const OSDMap* osdmap) const;
void mark_obj_as_lost(ObjectStore::Transaction& t,
- const sobject_t &lost_soid);
+ const hobject_t &lost_soid);
void mark_all_unfound_as_lost(ObjectStore::Transaction& t);
bool calc_min_last_complete_ondisk() {
virtual void _clear_recovery_state() = 0;
void defer_recovery();
virtual void check_recovery_op_pulls(const OSDMap *newmap) = 0;
- void start_recovery_op(const sobject_t& soid);
- void finish_recovery_op(const sobject_t& soid, bool dequeue=false);
+ void start_recovery_op(const hobject_t& soid);
+ void finish_recovery_op(const hobject_t& soid, bool dequeue=false);
loff_t get_log_write_pos() {
return 0;
ScrubMap primary_scrubmap;
MOSDRepScrub *active_rep_scrub;
- void repair_object(const sobject_t& soid, ScrubMap::object *po, int bad_peer, int ok_peer);
+ void repair_object(const hobject_t& soid, ScrubMap::object *po, int bad_peer, int ok_peer);
bool _compare_scrub_objects(ScrubMap::object &auth,
ScrubMap::object &candidate,
ostream &errorstream);
void _compare_scrubmaps(const map<int,ScrubMap*> &maps,
- map<sobject_t, set<int> > &missing,
- map<sobject_t, set<int> > &inconsistent,
- map<sobject_t, int> &authoritative,
+ map<hobject_t, set<int> > &missing,
+ map<hobject_t, set<int> > &inconsistent,
+ map<hobject_t, int> &authoritative,
ostream &errorstream);
void scrub();
void scrub_finalize();
void scrub_clear_state();
bool scrub_gather_replica_maps();
- void _scan_list(ScrubMap &map, vector<sobject_t> &ls);
+ void _scan_list(ScrubMap &map, vector<hobject_t> &ls);
void _request_scrub_map(int replica, eversion_t version);
void build_scrub_map(ScrubMap &map);
void build_inc_scrub_map(ScrubMap &map, eversion_t v);
void sub_op_scrub_stop(class MOSDSubOp *op);
public:
- PG(OSD *o, PGPool *_pool, pg_t p, const sobject_t& loid, const sobject_t& ioid) :
+ PG(OSD *o, PGPool *_pool, pg_t p, const hobject_t& loid, const hobject_t& ioid) :
osd(o), pool(_pool),
_lock("PG::_lock"),
ref(0), deleting(false), dirty_info(false), dirty_log(false),
virtual bool same_for_rep_modify_since(epoch_t e) = 0;
virtual bool is_write_in_progress() = 0;
- virtual bool is_missing_object(const sobject_t& oid) = 0;
- virtual void wait_for_missing_object(const sobject_t& oid, Message *op) = 0;
+ virtual bool is_missing_object(const hobject_t& oid) = 0;
+ virtual void wait_for_missing_object(const hobject_t& oid, Message *op) = 0;
- virtual bool is_degraded_object(const sobject_t& oid) = 0;
- virtual void wait_for_degraded_object(const sobject_t& oid, Message *op) = 0;
+ virtual bool is_degraded_object(const hobject_t& oid) = 0;
+ virtual void wait_for_degraded_object(const hobject_t& oid, Message *op) = 0;
virtual void on_osd_failure(int osd) = 0;
virtual void on_role_change() = 0;
// ====================
// missing objects
-bool ReplicatedPG::is_missing_object(const sobject_t& soid)
+bool ReplicatedPG::is_missing_object(const hobject_t& soid)
{
return missing.missing.count(soid);
}
-void ReplicatedPG::wait_for_missing_object(const sobject_t& soid, Message *m)
+void ReplicatedPG::wait_for_missing_object(const hobject_t& soid, Message *m)
{
assert(is_missing_object(soid));
// we don't have it (yet).
- map<sobject_t, Missing::item>::const_iterator g = missing.missing.find(soid);
+ map<hobject_t, Missing::item>::const_iterator g = missing.missing.find(soid);
assert(g != missing.missing.end());
const eversion_t &v(g->second.need);
- map<sobject_t, pull_info_t>::const_iterator p = pulling.find(soid);
+ map<hobject_t, pull_info_t>::const_iterator p = pulling.find(soid);
if (p != pulling.end()) {
dout(7) << "missing " << soid << " v " << v << ", already pulling." << dendl;
}
waiting_for_missing_object[soid].push_back(m);
}
-bool ReplicatedPG::is_degraded_object(const sobject_t& soid)
+bool ReplicatedPG::is_degraded_object(const hobject_t& soid)
{
if (missing.missing.count(soid))
return true;
return false;
}
-void ReplicatedPG::wait_for_degraded_object(const sobject_t& soid, Message *m)
+void ReplicatedPG::wait_for_degraded_object(const hobject_t& soid, Message *m)
{
assert(is_degraded_object(soid));
return true;
}
-bool ReplicatedPG::pgls_filter(PGLSFilter *filter, sobject_t& sobj, bufferlist& outdata)
+bool ReplicatedPG::pgls_filter(PGLSFilter *filter, hobject_t& sobj, bufferlist& outdata)
{
bufferlist bl;
} else {
dout(10) << " pgls pg=" << op->get_pg() << " count " << p->op.pgls.count << dendl;
// read into a buffer
- vector<sobject_t> sentries;
+ vector<hobject_t> sentries;
PGLSResponse response;
response.handle = (collection_list_handle_t)(uint64_t)(p->op.pgls.cookie);
// it's an offset into the missing set
version_t v = response.handle;
dout(10) << " handle low/missing " << v << dendl;
- map<version_t, sobject_t>::iterator mp = missing.rmissing.lower_bound(v);
+ map<version_t, hobject_t>::iterator mp = missing.rmissing.lower_bound(v);
result = 0;
while (sentries.size() < p->op.pgls.count) {
if (mp == missing.rmissing.end()) {
}
if (result == 0) {
- vector<sobject_t>::iterator iter;
+ vector<hobject_t>::iterator iter;
for (iter = sentries.begin(); iter != sentries.end(); ++iter) {
bool keep = true;
// skip snapdir objects
}
}
-ReplicatedPG::ReplicatedPG(OSD *o, PGPool *_pool, pg_t p, const sobject_t& oid, const sobject_t& ioid) :
+ReplicatedPG::ReplicatedPG(OSD *o, PGPool *_pool, pg_t p, const hobject_t& oid, const hobject_t& ioid) :
PG(o, _pool, p, oid, ioid), snap_trimmer_machine(this)
{
snap_trimmer_machine.initiate();
if (is_primary() || (!(op->get_rmw_flags() & CEPH_OSD_FLAG_LOCALIZE_READS))) {
// missing the specific snap we need; requeue and wait.
assert(!can_create); // only happens on a read
- sobject_t soid(op->get_oid(), snapid);
+ hobject_t soid(op->get_oid(), snapid);
wait_for_missing_object(soid, op);
return;
}
dout(10) << "do_op mode now " << mode << dendl;
// src_oids
- map<sobject_t,ObjectContext*> src_obc;
+ map<hobject_t,ObjectContext*> src_obc;
for (vector<OSDOp>::iterator p = op->ops.begin(); p != op->ops.end(); p++) {
OSDOp& osd_op = *p;
if (osd_op.soid.oid.name.length()) {
&sobc, false, &ssnapid);
if (r == -EAGAIN) {
// missing the specific snap we need; requeue and wait.
- sobject_t soid(osd_op.soid.oid, ssnapid);
+ hobject_t soid(osd_op.soid.oid, ssnapid);
wait_for_missing_object(soid, op);
} else if (r) {
osd->reply_op_error(op, r);
return;
}
- const sobject_t& soid = obc->obs.oi.soid;
+ const hobject_t& soid = obc->obs.oi.soid;
OpContext *ctx = new OpContext(op, op->get_reqid(), op->ops,
&obc->obs, obc->ssc,
this);
* obs_to_trim */
bool ReplicatedPG::get_obs_to_trim(snapid_t &snap_to_trim,
coll_t &col_to_trim,
- vector<sobject_t> &obs_to_trim)
+ vector<hobject_t> &obs_to_trim)
{
assert_locked();
obs_to_trim.clear();
return true;
}
-ReplicatedPG::RepGather *ReplicatedPG::trim_object(const sobject_t &coid,
+ReplicatedPG::RepGather *ReplicatedPG::trim_object(const hobject_t &coid,
const snapid_t &sn)
{
// load clone info
// save head snapset
dout(10) << coid << " new snapset " << snapset << dendl;
- sobject_t snapoid(coid.oid, snapset.head_exists ? CEPH_NOSNAP:CEPH_SNAPDIR);
+ hobject_t snapoid(coid.oid, snapset.head_exists ? CEPH_NOSNAP:CEPH_SNAPDIR);
ctx->snapset_obc = get_object_context(snapoid, coi.oloc, false);
assert(ctx->snapset_obc->registered);
if (snapset.clones.empty() && !snapset.head_exists) {
bool maybe_created = false;
- const sobject_t& soid = oi.soid;
+ const hobject_t& soid = oi.soid;
ObjectStore::Transaction& t = ctx->op_t;
SnapSet& snapset = ctx->new_snapset;
ObjectState& obs = ctx->new_obs;
object_info_t& oi = obs.oi;
- const sobject_t& soid = oi.soid;
+ const hobject_t& soid = oi.soid;
ObjectStore::Transaction& t = ctx->op_t;
if (obs.exists)
SnapSet& snapset = ctx->new_snapset;
ObjectState& obs = ctx->new_obs;
object_info_t& oi = obs.oi;
- const sobject_t& soid = oi.soid;
+ const hobject_t& soid = oi.soid;
ObjectStore::Transaction& t = ctx->op_t;
snapid_t snapid = (uint64_t)op.snap.snapid;
snapid_t cloneid = 0;
/* a different problem, like degraded pool
* with not-yet-restored object. We shouldn't have been able
* to get here; recovery should have completed first! */
- sobject_t rollback_target(soid.oid, cloneid);
+ hobject_t rollback_target(soid.oid, cloneid);
assert(is_missing_object(rollback_target));
dout(20) << "_rollback_to attempted to roll back to a missing object "
<< rollback_target << " (requested snapid: ) " << snapid << dendl;
assert(0);
}
} else { //we got our context, let's use it to do the rollback!
- sobject_t& rollback_to_sobject = rollback_to->obs.oi.soid;
+ hobject_t& rollback_to_sobject = rollback_to->obs.oi.soid;
if (is_degraded_object(rollback_to_sobject)) {
dout(20) << "_rollback_to attempted to roll back to a degraded object "
<< rollback_to_sobject << " (requested snapid: ) " << snapid << dendl;
}
void ReplicatedPG::_make_clone(ObjectStore::Transaction& t,
- const sobject_t& head, const sobject_t& coid,
+ const hobject_t& head, const hobject_t& coid,
object_info_t *poi)
{
bufferlist bv;
void ReplicatedPG::make_writeable(OpContext *ctx)
{
- const sobject_t& soid = ctx->obs->oi.soid;
+ const hobject_t& soid = ctx->obs->oi.soid;
SnapContext& snapc = ctx->snapc;
/*
ObjectState& obs = ctx->new_obs;
snapc.snaps.size() && // there are snaps
snapc.snaps[0] > ctx->new_snapset.seq) { // existing object is old
// clone
- sobject_t coid = soid;
+ hobject_t coid = soid;
coid.snap = snapc.seq;
unsigned l;
OSD::Session *session = (OSD::Session *)ctx->op->get_connection()->get_priv();
ObjectContext *obc = ctx->obc;
object_info_t& oi = ctx->new_obs.oi;
- sobject_t& soid = oi.soid;
+ hobject_t& soid = oi.soid;
entity_name_t entity = ctx->reqid.name;
dout(10) << "do_osd_op_effects applying watch/notify effects on session " << session << dendl;
{
assert(!ctx->ops.empty());
- const sobject_t& soid = ctx->obs->oi.soid;
+ const hobject_t& soid = ctx->obs->oi.soid;
// we'll need this to log
eversion_t old_version = ctx->obs->oi.version;
ctx->op_t.setattr(coll, soid, SS_ATTR, bss);
if (!head_existed) {
// if we logically recreated the head, remove old _snapdir object
- sobject_t snapoid(soid.oid, CEPH_SNAPDIR);
+ hobject_t snapoid(soid.oid, CEPH_SNAPDIR);
ctx->snapset_obc = get_object_context(snapoid, ctx->new_obs.oi.oloc, false);
if (ctx->snapset_obc && ctx->snapset_obc->obs.exists) {
}
} else if (ctx->new_snapset.clones.size()) {
// save snapset on _snap
- sobject_t snapoid(soid.oid, CEPH_SNAPDIR);
+ hobject_t snapoid(soid.oid, CEPH_SNAPDIR);
dout(10) << " final snapset " << ctx->new_snapset
<< " in " << snapoid << dendl;
ctx->at_version.version++;
eversion_t old_last_update, bool old_exists, uint64_t old_size, eversion_t old_version)
{
OpContext *ctx = repop->ctx;
- const sobject_t& soid = ctx->obs->oi.soid;
+ const hobject_t& soid = ctx->obs->oi.soid;
MOSDOp *op = (MOSDOp *)ctx->op;
dout(7) << "issue_repop rep_tid " << repop->rep_tid
// -------------------------------------------------------
-ReplicatedPG::ObjectContext *ReplicatedPG::get_object_context(const sobject_t& soid,
+ReplicatedPG::ObjectContext *ReplicatedPG::get_object_context(const hobject_t& soid,
const object_locator_t& oloc,
bool can_create)
{
- map<sobject_t, ObjectContext*>::iterator p = object_contexts.find(soid);
+ map<hobject_t, ObjectContext*>::iterator p = object_contexts.find(soid);
ObjectContext *obc;
if (p != object_contexts.end()) {
obc = p->second;
snapid_t *psnapid)
{
// want the head?
- sobject_t head(oid, CEPH_NOSNAP);
+ hobject_t head(oid, CEPH_NOSNAP);
if (snapid == CEPH_NOSNAP) {
ObjectContext *obc = get_object_context(head, oloc, can_create);
if (!obc)
put_snapset_context(ssc);
return -ENOENT;
}
- sobject_t soid(oid, ssc->snapset.clones[k]);
+ hobject_t soid(oid, ssc->snapset.clones[k]);
put_snapset_context(ssc); // we're done with ssc
ssc = 0;
}
}
-void ReplicatedPG::put_object_contexts(map<sobject_t,ObjectContext*>& obcv)
+void ReplicatedPG::put_object_contexts(map<hobject_t,ObjectContext*>& obcv)
{
- for (map<sobject_t,ObjectContext*>::iterator p = obcv.begin(); p != obcv.end(); ++p)
+ for (map<hobject_t,ObjectContext*>::iterator p = obcv.begin(); p != obcv.end(); ++p)
put_object_context(p->second);
obcv.clear();
}
ssc = p->second;
} else {
bufferlist bv;
- sobject_t head(oid, CEPH_NOSNAP);
+ hobject_t head(oid, CEPH_NOSNAP);
int r = osd->store->getattr(coll, head, SS_ATTR, bv);
if (r < 0) {
// try _snapset
- sobject_t snapdir(oid, CEPH_SNAPDIR);
+ hobject_t snapdir(oid, CEPH_SNAPDIR);
r = osd->store->getattr(coll, snapdir, SS_ATTR, bv);
if (r < 0 && !can_create)
return NULL;
void ReplicatedPG::sub_op_modify(MOSDSubOp *op)
{
- const sobject_t& soid = op->poid;
+ const hobject_t& soid = op->poid;
const char *opname;
if (op->noop)
// ===========================================================
-void ReplicatedPG::calc_head_subsets(SnapSet& snapset, const sobject_t& head,
+void ReplicatedPG::calc_head_subsets(SnapSet& snapset, const hobject_t& head,
Missing& missing,
interval_set<uint64_t>& data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets)
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets)
{
dout(10) << "calc_head_subsets " << head
<< " clone_overlap " << snapset.clone_overlap << dendl;
prev.insert(0, st.st_size);
for (int j=snapset.clones.size()-1; j>=0; j--) {
- sobject_t c = head;
+ hobject_t c = head;
c.snap = snapset.clones[j];
prev.intersection_of(snapset.clone_overlap[snapset.clones[j]]);
if (!missing.is_missing(c)) {
<< " clone_subsets " << clone_subsets << dendl;
}
-void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, const sobject_t& soid,
+void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, const hobject_t& soid,
Missing& missing,
interval_set<uint64_t>& data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets)
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets)
{
dout(10) << "calc_clone_subsets " << soid
<< " clone_overlap " << snapset.clone_overlap << dendl;
if (size)
prev.insert(0, size);
for (int j=i-1; j>=0; j--) {
- sobject_t c = soid;
+ hobject_t c = soid;
c.snap = snapset.clones[j];
prev.intersection_of(snapset.clone_overlap[snapset.clones[j]]);
if (!missing.is_missing(c)) {
if (size)
next.insert(0, size);
for (unsigned j=i+1; j<snapset.clones.size(); j++) {
- sobject_t c = soid;
+ hobject_t c = soid;
c.snap = snapset.clones[j];
next.intersection_of(snapset.clone_overlap[snapset.clones[j-1]]);
if (!missing.is_missing(c)) {
*/
enum { PULL_NONE, PULL_OTHER, PULL_YES };
-int ReplicatedPG::pull(const sobject_t& soid)
+int ReplicatedPG::pull(const hobject_t& soid)
{
eversion_t v = missing.missing[soid].need;
int fromosd = -1;
- map<sobject_t,set<int> >::iterator q = missing_loc.find(soid);
+ map<hobject_t,set<int> >::iterator q = missing_loc.find(soid);
if (q != missing_loc.end()) {
for (set<int>::iterator p = q->second.begin();
p != q->second.end();
<< " from osd" << fromosd
<< dendl;
- map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t> > clone_subsets;
interval_set<uint64_t> data_subset;
bool need_size = false;
// is this a snapped object? if so, consult the snapset.. we may not need the entire object!
if (soid.snap && soid.snap < CEPH_NOSNAP) {
// do we have the head and/or snapdir?
- sobject_t head = soid;
+ hobject_t head = soid;
head.snap = CEPH_NOSNAP;
if (missing.is_missing(head)) {
if (pulling.count(head)) {
return PULL_YES;
}
-void ReplicatedPG::send_pull_op(const sobject_t& soid, eversion_t v, bool first,
+void ReplicatedPG::send_pull_op(const hobject_t& soid, eversion_t v, bool first,
const interval_set<uint64_t>& data_subset, int fromosd)
{
// send op
* intelligently push an object to a replica. make use of existing
* clones/heads and dup data ranges where possible.
*/
-void ReplicatedPG::push_to_replica(ObjectContext *obc, const sobject_t& soid, int peer)
+void ReplicatedPG::push_to_replica(ObjectContext *obc, const hobject_t& soid, int peer)
{
const object_info_t& oi = obc->obs.oi;
uint64_t size = obc->obs.oi.size;
dout(10) << "push_to_replica " << soid << " v" << oi.version << " size " << size << " to osd" << peer << dendl;
- map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t> > clone_subsets;
interval_set<uint64_t> data_subset;
// are we doing a clone on the replica?
if (soid.snap && soid.snap < CEPH_NOSNAP) {
- sobject_t head = soid;
+ hobject_t head = soid;
head.snap = CEPH_NOSNAP;
if (peer_missing[peer].is_missing(head) &&
peer_missing[peer].have_old(head) == oi.prior_version) {
<< " v" << oi.prior_version
<< ", pushing " << soid << " attrs as a clone op" << dendl;
interval_set<uint64_t> data_subset;
- map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t> > clone_subsets;
if (size)
clone_subsets[head].insert(0, size);
push_start(soid, peer, size, oi.version, data_subset, clone_subsets);
dout(15) << "push_to_replica missing head " << head << ", pushing raw clone" << dendl;
return push_start(soid, peer);
}
- sobject_t snapdir = head;
+ hobject_t snapdir = head;
snapdir.snap = CEPH_SNAPDIR;
if (missing.is_missing(snapdir)) {
dout(15) << "push_to_replica missing snapdir " << snapdir << ", pushing raw clone" << dendl;
push_start(soid, peer, size, oi.version, data_subset, clone_subsets);
}
-void ReplicatedPG::push_start(const sobject_t& soid, int peer)
+void ReplicatedPG::push_start(const hobject_t& soid, int peer)
{
struct stat st;
int r = osd->store->stat(coll, soid, &st);
object_info_t oi(bl);
interval_set<uint64_t> data_subset;
- map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t> > clone_subsets;
data_subset.insert(0, size);
push_start(soid, peer, size, oi.version, data_subset, clone_subsets);
}
-void ReplicatedPG::push_start(const sobject_t& soid, int peer,
+void ReplicatedPG::push_start(const hobject_t& soid, int peer,
uint64_t size, eversion_t version,
interval_set<uint64_t> &data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets)
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets)
{
// take note.
push_info_t *pi = &pushing[soid][peer];
* push - send object to a peer
*/
-int ReplicatedPG::send_push_op(const sobject_t& soid, eversion_t version, int peer,
+int ReplicatedPG::send_push_op(const hobject_t& soid, eversion_t version, int peer,
uint64_t size, bool first, bool complete,
interval_set<uint64_t> &data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets)
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets)
{
// read data+attrs
bufferlist bl;
return 0;
}
-void ReplicatedPG::send_push_op_blank(const sobject_t& soid, int peer)
+void ReplicatedPG::send_push_op_blank(const hobject_t& soid, int peer)
{
// send a blank push back to the primary
osd_reqid_t rid;
dout(10) << "sub_op_push_reply from " << reply->get_source() << " " << *reply << dendl;
int peer = reply->get_source().num();
- const sobject_t& soid = reply->get_poid();
+ const hobject_t& soid = reply->get_poid();
if (pushing.count(soid) == 0) {
dout(10) << "huh, i wasn't pushing " << soid << " to osd" << peer
*/
void ReplicatedPG::sub_op_pull(MOSDSubOp *op)
{
- const sobject_t soid = op->poid;
+ const hobject_t soid = op->poid;
dout(7) << "op_pull " << soid << " v " << op->version
<< " from " << op->get_source()
*/
void ReplicatedPG::sub_op_push(MOSDSubOp *op)
{
- const sobject_t& soid = op->poid;
+ const hobject_t& soid = op->poid;
eversion_t v = op->version;
OSDOp& push = op->ops[0];
}
interval_set<uint64_t> data_subset;
- map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t> > clone_subsets;
bufferlist data;
op->claim_data(data);
}
// clone bits
- for (map<sobject_t, interval_set<uint64_t> >::const_iterator p = clone_subsets.begin();
+ for (map<hobject_t, interval_set<uint64_t> >::const_iterator p = clone_subsets.begin();
p != clone_subsets.end();
++p)
{
waiting_for_missing_object.erase(soid);
} else {
dout(20) << " no waiters on " << soid << dendl;
- /*for (hash_map<sobject_t,list<class Message*> >::iterator p = waiting_for_missing_object.begin();
+ /*for (hash_map<hobject_t,list<class Message*> >::iterator p = waiting_for_missing_object.begin();
p != waiting_for_missing_object.end();
p++)
dout(20) << " " << p->first << dendl;
void ReplicatedPG::_failed_push(MOSDSubOp *op)
{
- const sobject_t& soid = op->poid;
+ const hobject_t& soid = op->poid;
int from = op->get_source().num();
- map<sobject_t,set<int> >::iterator p = missing_loc.find(soid);
+ map<hobject_t,set<int> >::iterator p = missing_loc.find(soid);
if (p != missing_loc.end()) {
dout(0) << "_failed_push " << soid << " from osd" << from
<< ", reps on " << p->second << dendl;
void ReplicatedPG::check_recovery_op_pulls(const OSDMap *osdmap)
{
- for (map<int, set<sobject_t> >::iterator j = pull_from_peer.begin();
+ for (map<int, set<hobject_t> >::iterator j = pull_from_peer.begin();
j != pull_from_peer.end();
) {
if (osdmap->is_up(j->first)) {
dout(10) << "Reseting pulls from osd" << j->first
<< ", osdmap has it marked down" << dendl;
- for (set<sobject_t>::iterator i = j->second.begin();
+ for (set<hobject_t>::iterator i = j->second.begin();
i != j->second.end();
++i) {
assert(pulling.count(*i) == 1);
int started = 0;
int skipped = 0;
- map<version_t, sobject_t>::iterator p = missing.rmissing.lower_bound(log.last_requested);
+ map<version_t, hobject_t>::iterator p = missing.rmissing.lower_bound(log.last_requested);
while (p != missing.rmissing.end()) {
- sobject_t soid;
+ hobject_t soid;
version_t v = p->first;
if (log.objects.count(p->second)) {
Missing::item& item = missing.missing[p->second];
p++;
- sobject_t head = soid;
+ hobject_t head = soid;
head.snap = CEPH_NOSNAP;
bool unfound = (missing_loc.find(soid) == missing_loc.end());
return started;
}
-int ReplicatedPG::recover_object_replicas(const sobject_t& soid, eversion_t v)
+int ReplicatedPG::recover_object_replicas(const hobject_t& soid, eversion_t v)
{
dout(10) << "recover_object_replicas " << soid << dendl;
// oldest first!
const Missing &m(pm->second);
- for (map<version_t, sobject_t>::const_iterator p = m.rmissing.begin();
+ for (map<version_t, hobject_t>::const_iterator p = m.rmissing.begin();
p != m.rmissing.end() && started < max;
++p) {
- const sobject_t soid(p->second);
+ const hobject_t soid(p->second);
if (pushing.count(soid)) {
dout(10) << __func__ << ": already pushing " << soid << dendl;
}
dout(10) << __func__ << ": recover_object_replicas(" << soid << ")" << dendl;
- map<sobject_t,Missing::item>::const_iterator p = m.missing.find(soid);
+ map<hobject_t,Missing::item>::const_iterator p = m.missing.find(soid);
started += recover_object_replicas(soid, p->second.need);
}
}
return started;
}
-void ReplicatedPG::remove_object_with_snap_hardlinks(ObjectStore::Transaction& t, const sobject_t& soid)
+void ReplicatedPG::remove_object_with_snap_hardlinks(ObjectStore::Transaction& t, const hobject_t& soid)
{
t.remove(coll, soid);
if (soid.snap < CEPH_MAXSNAP) {
// FIXME: sloppy pobject vs object conversions abound! ***
// be thorough.
- vector<sobject_t> ls;
+ vector<hobject_t> ls;
osd->store->collection_list(coll, ls);
- set<sobject_t> s;
- for (vector<sobject_t>::iterator i = ls.begin();
+ set<hobject_t> s;
+ for (vector<hobject_t>::iterator i = ls.begin();
i != ls.end();
i++)
if (i->snap == CEPH_NOSNAP)
dout(10) << " " << s.size() << " local objects" << dendl;
- set<sobject_t> did;
+ set<hobject_t> did;
for (list<Log::Entry>::reverse_iterator p = log.log.rbegin();
p != log.log.rend();
p++) {
}
}
- for (set<sobject_t>::iterator i = s.begin();
+ for (set<hobject_t>::iterator i = s.begin();
i != s.end();
i++) {
dout(10) << " deleting stray " << *i << dendl;
} else {
// just scan the log.
- set<sobject_t> did;
+ set<hobject_t> did;
for (list<Log::Entry>::reverse_iterator p = log.log.rbegin();
p != log.log.rend();
p++) {
const char *mode = repair ? "repair":"scrub";
// traverse in reverse order.
- sobject_t head;
+ hobject_t head;
SnapSet snapset;
vector<snapid_t>::reverse_iterator curclone;
bufferlist last_data;
- for (map<sobject_t,ScrubMap::object>::reverse_iterator p = scrubmap.objects.rbegin();
+ for (map<hobject_t,ScrubMap::object>::reverse_iterator p = scrubmap.objects.rbegin();
p != scrubmap.objects.rend();
p++) {
- const sobject_t& soid = p->first;
+ const hobject_t& soid = p->first;
object_stat_sum_t stat;
stat.num_objects++;
::decode(snapset, blp);
// did we finish the last oid?
- if (head != sobject_t()) {
+ if (head != hobject_t()) {
osd->clog.error() << "Missing clone(s) for " << head << "\n";
errors++;
}
// what will be next?
if (snapset.clones.empty())
- head = sobject_t(); // no clones.
+ head = hobject_t(); // no clones.
else {
curclone = snapset.clones.rbegin();
head = p->first;
}
} else if (soid.snap) {
// it's a clone
- assert(head != sobject_t());
+ assert(head != hobject_t());
stat.num_object_clones++;
curclone++;
if (curclone == snapset.clones.rend())
- head = sobject_t();
+ head = hobject_t();
} else {
// it's unversioned.
}
// Primary trimming
- vector<sobject_t> &obs_to_trim = context<SnapTrimmer>().obs_to_trim;
+ vector<hobject_t> &obs_to_trim = context<SnapTrimmer>().obs_to_trim;
snapid_t &snap_to_trim = context<SnapTrimmer>().snap_to_trim;
coll_t &col_to_trim = context<SnapTrimmer>().col_to_trim;
if (!pg->get_obs_to_trim(snap_to_trim,
coll_t col_to_trim(pg->info.pgid, snap_to_trim);
to_trim.erase(snap_to_trim);
- vector<sobject_t> obs_to_trim;
+ vector<hobject_t> obs_to_trim;
pg->osd->store->collection_list(col_to_trim, obs_to_trim);
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- for (vector<sobject_t>::iterator i = obs_to_trim.begin();
+ for (vector<hobject_t>::iterator i = obs_to_trim.begin();
i != obs_to_trim.end();
++i) {
t->collection_remove(col_to_trim, *i);
{
dout(10) << "TrimmingObjects react" << dendl;
ReplicatedPG *pg = context< SnapTrimmer >().pg;
- vector<sobject_t> &obs_to_trim = context<SnapTrimmer>().obs_to_trim;
+ vector<hobject_t> &obs_to_trim = context<SnapTrimmer>().obs_to_trim;
snapid_t &snap_to_trim = context<SnapTrimmer>().snap_to_trim;
set<RepGather *> &repops = context<SnapTrimmer>().repops;
interval_set<uint64_t> modified_ranges;
ObjectContext *obc; // For ref counting purposes
- map<sobject_t,ObjectContext*> src_obc;
+ map<hobject_t,ObjectContext*> src_obc;
ObjectContext *clone_obc; // if we created a clone
ObjectContext *snapset_obc; // if we created/deleted a snapdir
OpContext *ctx;
ObjectContext *obc;
- map<sobject_t,ObjectContext*> src_obc;
+ map<hobject_t,ObjectContext*> src_obc;
tid_t rep_tid;
friend class C_OSD_OpApplied;
// projected object info
- map<sobject_t, ObjectContext*> object_contexts;
+ map<hobject_t, ObjectContext*> object_contexts;
map<object_t, SnapSetContext*> snapset_contexts;
- ObjectContext *lookup_object_context(const sobject_t& soid) {
+ ObjectContext *lookup_object_context(const hobject_t& soid) {
if (object_contexts.count(soid)) {
ObjectContext *obc = object_contexts[soid];
obc->ref++;
}
return NULL;
}
- ObjectContext *get_object_context(const sobject_t& soid, const object_locator_t& oloc,
+ ObjectContext *get_object_context(const hobject_t& soid, const object_locator_t& oloc,
bool can_create);
void register_object_context(ObjectContext *obc) {
if (!obc->registered) {
register_snapset_context(obc->ssc);
}
void put_object_context(ObjectContext *obc);
- void put_object_contexts(map<sobject_t,ObjectContext*>& obcv);
+ void put_object_contexts(map<hobject_t,ObjectContext*>& obcv);
int find_object_context(const object_t& oid, const object_locator_t& oloc,
snapid_t snapid, ObjectContext **pobc,
bool can_create, snapid_t *psnapid=NULL);
bool need_size;
interval_set<uint64_t> data_subset, data_subset_pulling;
};
- map<sobject_t, pull_info_t> pulling;
+ map<hobject_t, pull_info_t> pulling;
// Reverse mapping from osd peer to objects beging pulled from that peer
- map<int, set<sobject_t> > pull_from_peer;
+ map<int, set<hobject_t> > pull_from_peer;
// push
struct push_info_t {
uint64_t size;
eversion_t version;
interval_set<uint64_t> data_subset, data_subset_pushing;
- map<sobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t> > clone_subsets;
};
- map<sobject_t, map<int, push_info_t> > pushing;
+ map<hobject_t, map<int, push_info_t> > pushing;
- int recover_object_replicas(const sobject_t& soid, eversion_t v);
- void calc_head_subsets(SnapSet& snapset, const sobject_t& head,
+ int recover_object_replicas(const hobject_t& soid, eversion_t v);
+ void calc_head_subsets(SnapSet& snapset, const hobject_t& head,
Missing& missing,
interval_set<uint64_t>& data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets);
- void calc_clone_subsets(SnapSet& snapset, const sobject_t& poid, Missing& missing,
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets);
+ void calc_clone_subsets(SnapSet& snapset, const hobject_t& poid, Missing& missing,
interval_set<uint64_t>& data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets);
- void push_to_replica(ObjectContext *obc, const sobject_t& oid, int dest);
- void push_start(const sobject_t& oid, int dest);
- void push_start(const sobject_t& soid, int peer,
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets);
+ void push_to_replica(ObjectContext *obc, const hobject_t& oid, int dest);
+ void push_start(const hobject_t& oid, int dest);
+ void push_start(const hobject_t& soid, int peer,
uint64_t size, eversion_t version,
interval_set<uint64_t> &data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets);
- int send_push_op(const sobject_t& oid, eversion_t version, int dest,
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets);
+ int send_push_op(const hobject_t& oid, eversion_t version, int dest,
uint64_t size, bool first, bool complete,
interval_set<uint64_t>& data_subset,
- map<sobject_t, interval_set<uint64_t> >& clone_subsets);
- void send_push_op_blank(const sobject_t& soid, int peer);
+ map<hobject_t, interval_set<uint64_t> >& clone_subsets);
+ void send_push_op_blank(const hobject_t& soid, int peer);
// Cancels/resets pulls from peer
void check_recovery_op_pulls(const OSDMap *map);
- int pull(const sobject_t& oid);
- void send_pull_op(const sobject_t& soid, eversion_t v, bool first, const interval_set<uint64_t>& data_subset, int fromosd);
+ int pull(const hobject_t& oid);
+ void send_pull_op(const hobject_t& soid, eversion_t v, bool first, const interval_set<uint64_t>& data_subset, int fromosd);
// low level ops
void _make_clone(ObjectStore::Transaction& t,
- const sobject_t& head, const sobject_t& coid,
+ const hobject_t& head, const hobject_t& coid,
object_info_t *poi);
void make_writeable(OpContext *ctx);
void log_op_stats(OpContext *ctx);
void log_op(vector<Log::Entry>& log, eversion_t trim_to, ObjectStore::Transaction& t);
// pg on-disk content
- void remove_object_with_snap_hardlinks(ObjectStore::Transaction& t, const sobject_t& soid);
+ void remove_object_with_snap_hardlinks(ObjectStore::Transaction& t, const hobject_t& soid);
void clean_up_local(ObjectStore::Transaction& t);
void _clear_recovery_state();
int do_xattr_cmp_u64(int op, __u64 v1, bufferlist& xattr);
int do_xattr_cmp_str(int op, string& v1s, bufferlist& xattr);
- bool pgls_filter(PGLSFilter *filter, sobject_t& sobj, bufferlist& outdata);
+ bool pgls_filter(PGLSFilter *filter, hobject_t& sobj, bufferlist& outdata);
int get_pgls_filter(bufferlist::iterator& iter, PGLSFilter **pfilter);
public:
- ReplicatedPG(OSD *o, PGPool *_pool, pg_t p, const sobject_t& oid, const sobject_t& ioid);
+ ReplicatedPG(OSD *o, PGPool *_pool, pg_t p, const hobject_t& oid, const hobject_t& ioid);
~ReplicatedPG() {}
void do_sub_op_reply(MOSDSubOpReply *op);
bool get_obs_to_trim(snapid_t &snap_to_trim,
coll_t &col_to_trim,
- vector<sobject_t> &obs_to_trim);
- RepGather *trim_object(const sobject_t &coid, const snapid_t &sn);
+ vector<hobject_t> &obs_to_trim);
+ RepGather *trim_object(const hobject_t &coid, const snapid_t &sn);
bool snap_trimmer();
int do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
bufferlist& odata);
struct SnapTrimmer : public boost::statechart::state_machine< SnapTrimmer, NotTrimming > {
ReplicatedPG *pg;
set<RepGather *> repops;
- vector<sobject_t> obs_to_trim;
+ vector<hobject_t> obs_to_trim;
snapid_t snap_to_trim;
coll_t col_to_trim;
bool need_share_pg_info;
boost::statechart::custom_reaction< SnapTrim >,
boost::statechart::transition< Reset, NotTrimming >
> reactions;
- vector<sobject_t>::iterator position;
+ vector<hobject_t>::iterator position;
TrimmingObjects(my_context ctx);
void exit();
boost::statechart::result react(const SnapTrim&);
bool same_for_modify_since(epoch_t e);
bool same_for_rep_modify_since(epoch_t e);
- bool is_missing_object(const sobject_t& oid);
- void wait_for_missing_object(const sobject_t& oid, Message *op);
+ bool is_missing_object(const hobject_t& oid);
+ void wait_for_missing_object(const hobject_t& oid, Message *op);
- bool is_degraded_object(const sobject_t& oid);
- void wait_for_degraded_object(const sobject_t& oid, Message *op);
+ bool is_degraded_object(const hobject_t& oid);
+ void wait_for_degraded_object(const hobject_t& oid, Message *op);
void on_osd_failure(int o);
void on_acker_change();
logbl = l.logbl;
valid_through = l.valid_through;
- for (map<sobject_t,object>::const_iterator p = l.objects.begin();
+ for (map<hobject_t,object>::const_iterator p = l.objects.begin();
p != l.objects.end();
p++){
if (p->second.negative) {
- map<sobject_t,object>::iterator q = objects.find(p->first);
+ map<hobject_t,object>::iterator q = objects.find(p->first);
if (q != objects.end()) {
objects.erase(q);
}
CEPH_RBD_RULE,
};
-#define OSD_SUPERBLOCK_POBJECT sobject_t(object_t("osd_superblock"), 0)
+#define OSD_SUPERBLOCK_POBJECT hobject_t(object_t("osd_superblock"), 0)
// placement seed (a hash value)
typedef uint32_t ps_t;
struct object_info_t {
- sobject_t soid;
+ hobject_t soid;
object_locator_t oloc;
string category;
decode(p);
}
- object_info_t(const sobject_t& s, const object_locator_t& o)
+ object_info_t(const hobject_t& s, const object_locator_t& o)
: soid(s), oloc(o), size(0),
lost(false), truncate_seq(0), truncate_size(0) {}
};
WRITE_CLASS_ENCODER(object)
- map<sobject_t,object> objects;
+ map<hobject_t,object> objects;
map<string,bufferptr> attrs;
bufferlist logbl;
eversion_t valid_through;
struct OSDOp {
ceph_osd_op op;
bufferlist data;
- sobject_t soid;
+ hobject_t soid;
OSDOp() {
memset(&op, 0, sizeof(ceph_osd_op));
projects / ceph.git / commitdiff