coll_t is now a string. META_COLL and TEMP_COLL are just constants now.
Now there is a constructor that takes pgid_t and snapid_t, rather than
factory methods. It's clear what that constructor does, so wrapping it
in factory methods should be unecessary.
Bump coll_t serialization version to 3. Implement decoding for the old
versions.
Signed-off-by: Colin McCabe <colinm@hq.newdream.net>
void FileStore::get_cdir(coll_t cid, char *s, int len)
{
- int ret = snprintf(s, len, "%s/current/", basedir.c_str());
- s += ret;
- len -= ret;
- s += cid.print(s, len);
+ const string &cid_str(cid.to_str());
+ snprintf(s, len, "%s/current/%s", basedir.c_str(), cid_str.c_str());
}
void FileStore::get_coname(coll_t cid, const sobject_t& oid, char *s, int len)
return out << dbeginl << "osd" << whoami << " " << (osdmap ? osdmap->get_epoch():0) << " ";
}
-
-const coll_t meta_coll(coll_t::TYPE_META);
-const coll_t temp_coll(coll_t::TYPE_TEMP);
-
+const coll_t coll_t::META_COLL("meta");
+const coll_t coll_t::TEMP_COLL("temp");
const struct CompatSet::Feature ceph_osd_feature_compat[] = {
END_FEATURE
object_t oid("disk_bw_test");
for (int i=0; i<1000; i++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- t->write(meta_coll, sobject_t(oid, 0), i*bl.length(), bl.length(), bl);
+ t->write(coll_t::META_COLL, sobject_t(oid, 0), i*bl.length(), bl.length(), bl);
store->queue_transaction(NULL, t);
}
store->sync();
end -= start;
cout << "measured " << (1000.0 / (double)end) << " mb/sec" << std::endl;
ObjectStore::Transaction tr;
- tr.remove(meta_coll, sobject_t(oid, 0));
+ tr.remove(coll_t::META_COLL, sobject_t(oid, 0));
store->apply_transaction(tr);
// set osd weight
::encode(sb, bl);
ObjectStore::Transaction t;
- t.create_collection(meta_coll);
- t.write(meta_coll, OSD_SUPERBLOCK_POBJECT, 0, bl.length(), bl);
- t.create_collection(temp_coll);
+ t.create_collection(coll_t::META_COLL);
+ t.write(coll_t::META_COLL, OSD_SUPERBLOCK_POBJECT, 0, bl.length(), bl);
+ t.create_collection(coll_t::TEMP_COLL);
int r = store->apply_transaction(t);
store->umount();
delete store;
clear_temp();
// make sure (newish) temp dir exists
- if (!store->collection_exists(coll_t(coll_t::TYPE_TEMP))) {
+ if (!store->collection_exists(coll_t::TEMP_COLL)) {
dout(10) << "creating temp pg dir" << dendl;
ObjectStore::Transaction t;
- t.create_collection(coll_t(coll_t::TYPE_TEMP));
+ t.create_collection(coll_t::TEMP_COLL);
store->apply_transaction(t);
}
bufferlist bl;
::encode(superblock, bl);
- t.write(meta_coll, OSD_SUPERBLOCK_POBJECT, 0, bl.length(), bl);
+ t.write(coll_t::META_COLL, OSD_SUPERBLOCK_POBJECT, 0, bl.length(), bl);
}
int OSD::read_superblock()
{
bufferlist bl;
- int r = store->read(meta_coll, OSD_SUPERBLOCK_POBJECT, 0, 0, bl);
+ int r = store->read(coll_t::META_COLL, OSD_SUPERBLOCK_POBJECT, 0, 0, bl);
if (r < 0)
return r;
dout(10) << "clear_temp" << dendl;
vector<sobject_t> objects;
- store->collection_list(temp_coll, objects);
+ store->collection_list(coll_t::TEMP_COLL, objects);
dout(10) << objects.size() << " objects" << dendl;
if (objects.empty())
for (vector<sobject_t>::iterator p = objects.begin();
p != objects.end();
p++)
- t->collection_remove(temp_coll, *p);
+ t->collection_remove(coll_t::TEMP_COLL, *p);
int r = store->queue_transaction(NULL, t);
assert(r == 0);
store->sync_and_flush();
PG *pg = _open_lock_pg(pgid);
// create collection
- assert(!store->collection_exists(coll_t::build_pg_coll(pgid)));
- t.create_collection(coll_t::build_pg_coll(pgid));
+ assert(!store->collection_exists(coll_t(pgid)));
+ t.create_collection(coll_t(pgid));
pg->write_info(t);
pg->write_log(t);
PG *pg = _open_lock_pg(pgid, true);
- assert(!store->collection_exists(coll_t::build_pg_coll(pgid)));
- t.create_collection(coll_t::build_pg_coll(pgid));
+ assert(!store->collection_exists(coll_t(pgid)));
+ t.create_collection(coll_t(pgid));
pg->set_role(0);
pg->acting.swap(acting);
object_t oid(nm);
sobject_t soid(oid, 0);
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- t->write(meta_coll, soid, 0, bsize, bl);
+ t->write(coll_t::META_COLL, soid, 0, bsize, bl);
store->queue_transaction(NULL, t);
- cleanupt->remove(meta_coll, soid);
+ cleanupt->remove(coll_t::META_COLL, soid);
}
store->sync_and_flush();
utime_t end = g_clock.now();
p != m->maps.end();
p++) {
sobject_t poid = get_osdmap_pobject_name(p->first);
- if (store->exists(meta_coll, poid)) {
+ if (store->exists(coll_t::META_COLL, poid)) {
dout(10) << "handle_osd_map already had full map epoch " << p->first << dendl;
logger->inc(l_osd_mapfdup);
bufferlist bl;
dout(10) << "handle_osd_map got full map epoch " << p->first << dendl;
ObjectStore::Transaction *ft = new ObjectStore::Transaction;
- ft->write(meta_coll, poid, 0, p->second.length(), p->second); // store _outside_ transaction; activate_map reads it.
+ ft->write(coll_t::META_COLL, poid, 0, p->second.length(), p->second); // store _outside_ transaction; activate_map reads it.
int r = store->queue_transaction(NULL, ft);
assert(r == 0);
p != m->incremental_maps.end();
p++) {
sobject_t poid = get_inc_osdmap_pobject_name(p->first);
- if (store->exists(meta_coll, poid)) {
+ if (store->exists(coll_t::META_COLL, poid)) {
dout(10) << "handle_osd_map already had incremental map epoch " << p->first << dendl;
logger->inc(l_osd_mapidup);
bufferlist bl;
dout(10) << "handle_osd_map got incremental map epoch " << p->first << dendl;
ObjectStore::Transaction *ft = new ObjectStore::Transaction;
- ft->write(meta_coll, poid, 0, p->second.length(), p->second); // store _outside_ transaction; activate_map reads it.
+ ft->write(coll_t::META_COLL, poid, 0, p->second.length(), p->second); // store _outside_ transaction; activate_map reads it.
int r = store->queue_transaction(NULL, ft);
assert(r == 0);
OSDMap::Incremental inc;
if (m->incremental_maps.count(cur+1) ||
- store->exists(meta_coll, get_inc_osdmap_pobject_name(cur+1))) {
+ store->exists(coll_t::META_COLL, get_inc_osdmap_pobject_name(cur+1))) {
dout(10) << "handle_osd_map decoding inc map epoch " << cur+1 << dendl;
bufferlist bl;
bl.clear();
osdmap->encode(bl);
ObjectStore::Transaction ft;
- ft.write(meta_coll, get_osdmap_pobject_name(cur+1), 0, bl.length(), bl);
+ ft.write(coll_t::META_COLL, get_osdmap_pobject_name(cur+1), 0, bl.length(), bl);
int r = store->apply_transaction(ft);
assert(r == 0);
}
}
else if (m->maps.count(cur+1) ||
- store->exists(meta_coll, get_osdmap_pobject_name(cur+1))) {
+ store->exists(coll_t::META_COLL, get_osdmap_pobject_name(cur+1))) {
dout(10) << "handle_osd_map decoding full map epoch " << cur+1 << dendl;
bufferlist bl;
if (m->maps.count(cur+1))
bool OSD::get_map_bl(epoch_t e, bufferlist& bl)
{
- return store->read(meta_coll, get_osdmap_pobject_name(e), 0, 0, bl) >= 0;
+ return store->read(coll_t::META_COLL, get_osdmap_pobject_name(e), 0, 0, bl) >= 0;
}
bool OSD::get_inc_map_bl(epoch_t e, bufferlist& bl)
{
- return store->read(meta_coll, get_inc_osdmap_pobject_name(e), 0, 0, bl) >= 0;
+ return store->read(coll_t::META_COLL, get_inc_osdmap_pobject_name(e), 0, 0, bl) >= 0;
}
OSDMap *OSD::get_map(epoch_t epoch)
// split objects
vector<sobject_t> olist;
- store->collection_list(coll_t::build_pg_coll(parent->info.pgid), 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;
bufferlist bv;
struct stat st;
- store->stat(coll_t::build_pg_coll(parentid), poid, &st);
- store->getattr(coll_t::build_pg_coll(parentid), poid, OI_ATTR, bv);
+ store->stat(coll_t(parentid), poid, &st);
+ store->getattr(coll_t(parentid), poid, OI_ATTR, bv);
object_info_t oi(bv);
- t.collection_add(coll_t::build_pg_coll(pgid), coll_t::build_pg_coll(parentid), poid);
- t.collection_remove(coll_t::build_pg_coll(parentid), poid);
+ t.collection_add(coll_t(pgid), coll_t(parentid), poid);
+ t.collection_remove(coll_t(parentid), poid);
if (oi.snaps.size()) {
snapid_t first = oi.snaps[0];
- t.collection_add(coll_t::build_snap_pg_coll(pgid, first), coll_t::build_pg_coll(parentid), poid);
- t.collection_remove(coll_t::build_snap_pg_coll(parentid, first), poid);
+ t.collection_add(coll_t(pgid, first), coll_t(parentid), poid);
+ t.collection_remove(coll_t(parentid, first), poid);
if (oi.snaps.size() > 1) {
snapid_t last = oi.snaps[oi.snaps.size()-1];
- t.collection_add(coll_t::build_snap_pg_coll(pgid, last), coll_t::build_pg_coll(parentid), poid);
- t.collection_remove(coll_t::build_snap_pg_coll(parentid, last), poid);
+ t.collection_add(coll_t(pgid, last), coll_t(parentid), poid);
+ t.collection_remove(coll_t(parentid, last), poid);
}
}
<< " -> " << info.purged_snaps
<< " removed " << p << dendl;
snapid_t sn = p.range_start();
- coll_t c = coll_t::build_snap_pg_coll(info.pgid, sn);
+ coll_t c(info.pgid, sn);
t->remove_collection(c);
pg->info.purged_snaps = info.purged_snaps;
p != pg->snap_collections.end();
p++) {
vector<sobject_t> olist;
- store->collection_list(coll_t::build_snap_pg_coll(pgid, *p), olist);
+ store->collection_list(coll_t(pgid, *p), olist);
dout(10) << "_remove_pg " << pgid << " snap " << *p << " " << olist.size() << " objects" << dendl;
for (vector<sobject_t>::iterator q = olist.begin();
q != olist.end();
q++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- t->remove(coll_t::build_snap_pg_coll(pgid, *p), *q);
- t->remove(coll_t::build_pg_coll(pgid), *q); // we may hit this twice, but it's harmless
+ t->remove(coll_t(pgid, *p), *q);
+ t->remove(coll_t(pgid), *q); // we may hit this twice, but it's harmless
int tr = store->queue_transaction(&pg->osr, t);
assert(tr == 0);
}
}
}
- rmt->remove_collection(coll_t::build_snap_pg_coll(pgid, *p));
+ rmt->remove_collection(coll_t(pgid, *p));
}
// (what remains of the) main collection
vector<sobject_t> olist;
- store->collection_list(coll_t::build_pg_coll(pgid), 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();
p != olist.end();
p++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- t->remove(coll_t::build_pg_coll(pgid), *p);
+ t->remove(coll_t(pgid), *p);
int tr = store->queue_transaction(&pg->osr, t);
assert(tr == 0);
dout(10) << "_remove_pg " << pgid << " removing final" << dendl;
{
- rmt->remove_collection(coll_t::build_pg_coll(pgid));
+ rmt->remove_collection(coll_t(pgid));
int tr = store->queue_transaction(NULL, rmt);
assert(tr == 0);
}
dout(20) << "merge_old_entry had " << oe << " new dne : ok" << dendl;
} else {
dout(20) << "merge_old_entry had " << oe << " new dne : deleting" << dendl;
- t.remove(coll_t::build_pg_coll(info.pgid), oe.soid);
+ t.remove(coll_t(info.pgid), oe.soid);
missing.rm(oe.soid, oe.version);
}
}
dout(20) << "merge_log merging " << ne << dendl;
missing.add_next_event(ne);
if (ne.is_delete())
- t.remove(coll_t::build_pg_coll(info.pgid), ne.soid);
+ t.remove(coll_t(info.pgid), ne.soid);
}
// find any divergent or removed items in old log.
log.index(ne);
missing.add_next_event(ne);
if (ne.is_delete())
- t.remove(coll_t::build_pg_coll(info.pgid), ne.soid);
+ t.remove(coll_t(info.pgid), ne.soid);
}
// move aside divergent items
unlock();
vector<sobject_t> olist;
- osd->store->collection_list(coll_t::build_pg_coll(info.pgid), olist);
+ osd->store->collection_list(coll_t(info.pgid), olist);
for (vector<sobject_t>::iterator it = olist.begin();
it != olist.end();
Log::Entry e;
e.soid = poid;
bufferlist bv;
- int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), poid, OI_ATTR, bv);
+ int r = osd->store->getattr(coll_t(info.pgid), poid, OI_ATTR, bv);
if (r < 0)
continue; // musta just been deleted!
object_info_t oi(bv);
::encode(info, infobl);
::encode(past_intervals, infobl);
dout(20) << "write_info info " << infobl.length() << dendl;
- t.collection_setattr(coll_t::build_pg_coll(info.pgid), "info", infobl);
+ t.collection_setattr(coll_t(info.pgid), "info", infobl);
// local state
bufferlist snapbl;
::encode(struct_v, snapbl);
::encode(snap_collections, snapbl);
dout(20) << "write_info snap " << snapbl.length() << dendl;
- t.collection_setattr(coll_t::build_pg_coll(info.pgid), "snap_collections", snapbl);
+ t.collection_setattr(coll_t(info.pgid), "snap_collections", snapbl);
dirty_info = false;
}
ondisklog.head = bl.length();
// write it
- t.remove(meta_coll, log_oid );
- t.write(meta_coll, log_oid , 0, bl.length(), bl);
+ t.remove(coll_t::META_COLL, log_oid );
+ t.write(coll_t::META_COLL, log_oid , 0, bl.length(), bl);
bufferlist blb(sizeof(ondisklog));
::encode(ondisklog, blb);
- t.collection_setattr(coll_t::build_pg_coll(info.pgid), "ondisklog", blb);
+ t.collection_setattr(coll_t(info.pgid), "ondisklog", blb);
dout(10) << "write_log to " << ondisklog.tail << "~" << ondisklog.length() << dendl;
dirty_log = false;
bufferlist blb(sizeof(ondisklog));
::encode(ondisklog, blb);
- t.collection_setattr(coll_t::build_pg_coll(info.pgid), "ondisklog", blb);
+ t.collection_setattr(coll_t(info.pgid), "ondisklog", blb);
if (!g_conf.osd_preserve_trimmed_log)
- t.zero(meta_coll, log_oid, 0, ondisklog.tail & ~4095);
+ t.zero(coll_t::META_COLL, log_oid, 0, ondisklog.tail & ~4095);
}
void PG::trim_peers()
if (ondisklog.head % 4096 < (ondisklog.head + bl.length()) % 4096)
ondisklog.block_map[ondisklog.head] = log_version; // log_version is last event in prev. block
- t.write(meta_coll, log_oid, ondisklog.head, bl.length(), bl );
+ t.write(coll_t::META_COLL, log_oid, ondisklog.head, bl.length(), bl );
ondisklog.head += bl.length();
bufferlist blb(sizeof(ondisklog));
::encode(ondisklog, blb);
- t.collection_setattr(coll_t::build_pg_coll(info.pgid), "ondisklog", blb);
+ t.collection_setattr(coll_t(info.pgid), "ondisklog", blb);
dout(10) << "append_log now " << ondisklog.tail << "~" << ondisklog.length() << dendl;
}
ondisklog.tail = ondisklog.head = 0;
bufferlist blb;
- store->collection_getattr(coll_t::build_pg_coll(info.pgid), "ondisklog", blb);
+ store->collection_getattr(coll_t(info.pgid), "ondisklog", blb);
bufferlist::iterator p = blb.begin();
::decode(ondisklog, p);
if (ondisklog.head > 0) {
// read
bufferlist bl;
- store->read(meta_coll, log_oid, ondisklog.tail, ondisklog.length(), bl);
+ store->read(coll_t::META_COLL, log_oid, ondisklog.tail, ondisklog.length(), bl);
if (bl.length() < ondisklog.length()) {
dout(0) << "read_log got " << bl.length() << " bytes, expected "
<< ondisklog.head << "-" << ondisklog.tail << "="
bufferlist bv;
struct stat st;
- int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), i->soid, OI_ATTR, bv);
+ int r = osd->store->getattr(coll_t(info.pgid), i->soid, OI_ATTR, bv);
if (r >= 0) {
object_info_t oi(bv);
if (oi.version < i->version) {
missing.add(i->soid, i->version, oi.version);
}
} else if (i->soid.snap == CEPH_NOSNAP &&
- osd->store->stat(coll_t::build_pg_coll(info.pgid), i->soid, &st) == 0) {
+ osd->store->stat(coll_t(info.pgid), i->soid, &st) == 0) {
dout(0) << "read_log rebuilding missing xattr on " << *i << dendl;
object_info_t oi(i->soid);
oi.version = i->version;
bufferlist bl;
::encode(oi, bl);
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- t->setattr(coll_t::build_pg_coll(info.pgid), i->soid, OI_ATTR, bl);
+ t->setattr(coll_t(info.pgid), i->soid, OI_ATTR, bl);
int tr = osd->store->queue_transaction(&osr, t);
assert(tr == 0);
{
OndiskLog bounds;
bufferlist blb;
- store->collection_getattr(coll_t::build_pg_coll(info.pgid), "ondisklog", blb);
+ store->collection_getattr(coll_t(info.pgid), "ondisklog", blb);
bufferlist::iterator p = blb.begin();
::decode(bounds, p);
if (bounds.head > 0) {
// read
struct stat st;
- store->stat(meta_coll, log_oid, &st);
+ store->stat(coll_t::META_COLL, log_oid, &st);
bufferlist bl;
- store->read(meta_coll, log_oid, bounds.tail, bounds.length(), bl);
+ store->read(coll_t::META_COLL, log_oid, bounds.tail, bounds.length(), bl);
if (st.st_size != (int)bounds.head) {
ss << "mismatched bounds " << bounds.tail << ".." << bounds.head << " and file size " << st.st_size;
ok = false;
__u8 struct_v;
// info
- store->collection_getattr(coll_t::build_pg_coll(info.pgid), "info", bl);
+ store->collection_getattr(coll_t(info.pgid), "info", bl);
p = bl.begin();
::decode(struct_v, p);
::decode(info, p);
// snap_collections
bl.clear();
- store->collection_getattr(coll_t::build_pg_coll(info.pgid), "snap_collections", bl);
+ store->collection_getattr(coll_t(info.pgid), "snap_collections", bl);
p = bl.begin();
::decode(struct_v, p);
::decode(snap_collections, p);
coll_t PG::make_snap_collection(ObjectStore::Transaction& t, snapid_t s)
{
- coll_t c = coll_t::build_snap_pg_coll(info.pgid, s);
+ coll_t c(info.pgid, s);
if (snap_collections.count(s) == 0) {
snap_collections.insert(s);
dout(10) << "create_snap_collection " << c << ", set now " << snap_collections << dendl;
bufferlist bl;
::encode(snap_collections, bl);
- t.collection_setattr(coll_t::build_pg_coll(info.pgid), "snap_collections", bl);
+ t.collection_setattr(coll_t(info.pgid), "snap_collections", bl);
t.create_collection(c);
}
return c;
void PG::build_scrub_map(ScrubMap &map)
{
dout(10) << "build_scrub_map" << dendl;
- coll_t c = coll_t::build_pg_coll(info.pgid);
+ coll_t c(info.pgid);
// objects
vector<sobject_t> ls;
PGLSResponse response;
response.handle = (collection_list_handle_t)(uint64_t)(p->op.pgls.cookie);
vector<sobject_t> sentries;
- result = osd->store->collection_list_partial(coll_t::build_pg_coll(info.pgid), snapid,
+ result = osd->store->collection_list_partial(coll_t(info.pgid), snapid,
sentries, p->op.pgls.count,
&response.handle);
if (result == 0) {
// skip items not defined for this snapshot
if (iter->snap == CEPH_NOSNAP) {
bufferlist bl;
- osd->store->getattr(coll_t::build_pg_coll(info.pgid), *iter, SS_ATTR, bl);
+ osd->store->getattr(coll_t(info.pgid), *iter, SS_ATTR, bl);
SnapSet snapset(bl);
if (snapid <= snapset.seq)
continue;
} else {
bufferlist bl;
- osd->store->getattr(coll_t::build_pg_coll(info.pgid), *iter, OI_ATTR, bl);
+ osd->store->getattr(coll_t(info.pgid), *iter, OI_ATTR, bl);
object_info_t oi(bl);
bool exists = false;
for (vector<snapid_t>::iterator i = oi.snaps.begin(); i != oi.snaps.end(); ++i)
is_active()) {
snapid_t sn = snap_trimq.range_start();
- coll_t c = coll_t::build_snap_pg_coll(info.pgid, sn);
+ coll_t c(info.pgid, sn);
vector<sobject_t> ls;
osd->store->collection_list(c, ls);
// load clone info
bufferlist bl;
- osd->store->getattr(coll_t::build_pg_coll(info.pgid), coid, OI_ATTR, bl);
+ osd->store->getattr(coll_t(info.pgid), coid, OI_ATTR, bl);
object_info_t coi(bl);
// get snap set context
if (newsnaps.empty()) {
// remove clone
dout(10) << coid << " snaps " << snaps << " -> " << newsnaps << " ... deleting" << dendl;
- t->remove(coll_t::build_pg_coll(info.pgid), coid);
- t->collection_remove(coll_t::build_snap_pg_coll(info.pgid, snaps[0]), coid);
+ t->remove(coll_t(info.pgid), coid);
+ t->collection_remove(coll_t(info.pgid, snaps[0]), coid);
if (snaps.size() > 1)
- t->collection_remove(coll_t::build_snap_pg_coll(info.pgid, snaps[snaps.size()-1]), coid);
+ t->collection_remove(coll_t(info.pgid, snaps[snaps.size()-1]), coid);
// ...from snapset
snapid_t last = coid.snap;
coi.snaps.swap(newsnaps);
bl.clear();
::encode(coi, bl);
- t->setattr(coll_t::build_pg_coll(info.pgid), coid, OI_ATTR, bl);
+ t->setattr(coll_t(info.pgid), coid, OI_ATTR, bl);
if (snaps[0] != newsnaps[0]) {
- t->collection_remove(coll_t::build_snap_pg_coll(info.pgid, snaps[0]), coid);
- t->collection_add(coll_t::build_snap_pg_coll(info.pgid, newsnaps[0]), coll_t::build_pg_coll(info.pgid), coid);
+ t->collection_remove(coll_t(info.pgid, snaps[0]), coid);
+ t->collection_add(coll_t(info.pgid, newsnaps[0]), coll_t(info.pgid), coid);
}
if (snaps.size() > 1 && snaps[snaps.size()-1] != newsnaps[newsnaps.size()-1]) {
- t->collection_remove(coll_t::build_snap_pg_coll(info.pgid, snaps[snaps.size()-1]), coid);
+ t->collection_remove(coll_t(info.pgid, snaps[snaps.size()-1]), coid);
if (newsnaps.size() > 1)
- t->collection_add(coll_t::build_snap_pg_coll(info.pgid, newsnaps[newsnaps.size()-1]), coll_t::build_pg_coll(info.pgid), coid);
+ t->collection_add(coll_t(info.pgid, newsnaps[newsnaps.size()-1]), coll_t(info.pgid), coid);
}
ctx->log.push_back(Log::Entry(Log::Entry::MODIFY, coid, ctx->at_version, ctx->obs->oi.version,
ctx->snapset_obc->obs.oi.version, osd_reqid_t(), ctx->mtime));
ctx->snapset_obc->obs.exists = false;
- t->remove(coll_t::build_pg_coll(info.pgid), snapoid);
+ t->remove(coll_t(info.pgid), snapoid);
} else {
dout(10) << coid << " updating snapset on " << snapoid << dendl;
ctx->log.push_back(Log::Entry(Log::Entry::MODIFY, snapoid, ctx->at_version,
bl.clear();
::encode(snapset, bl);
- t->setattr(coll_t::build_pg_coll(info.pgid), snapoid, SS_ATTR, bl);
+ t->setattr(coll_t(info.pgid), snapoid, SS_ATTR, bl);
bl.clear();
::encode(ctx->snapset_obc->obs.oi, bl);
- t->setattr(coll_t::build_pg_coll(info.pgid), snapoid, OI_ATTR, bl);
+ t->setattr(coll_t(info.pgid), snapoid, OI_ATTR, bl);
}
log_op(ctx->log, eversion_t(), ctx->local_t);
{
// read into a buffer
bufferlist bl;
- int r = osd->store->read(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length, bl);
+ int r = osd->store->read(coll_t(info.pgid), soid, op.extent.offset, op.extent.length, bl);
if (odata.length() == 0)
ctx->data_off = op.extent.offset;
odata.claim(bl);
{
struct stat st;
memset(&st, 0, sizeof(st));
- result = osd->store->stat(coll_t::build_pg_coll(info.pgid), soid, &st);
+ result = osd->store->stat(coll_t(info.pgid), soid, &st);
if (result >= 0) {
uint64_t size = st.st_size;
::encode(size, odata);
string aname;
bp.copy(op.xattr.name_len, aname);
string name = "_" + aname;
- int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, name.c_str(), odata);
+ int r = osd->store->getattr(coll_t(info.pgid), soid, name.c_str(), odata);
if (r >= 0) {
op.xattr.value_len = r;
result = 0;
case CEPH_OSD_OP_GETXATTRS:
{
map<string,bufferptr> attrset;
- result = osd->store->getattrs(coll_t::build_pg_coll(info.pgid), soid, attrset, true);
+ result = osd->store->getattrs(coll_t(info.pgid), soid, attrset, true);
map<string, bufferptr>::iterator iter;
map<string, bufferlist> newattrs;
for (iter = attrset.begin(); iter != attrset.end(); ++iter) {
name[op.xattr.name_len + 1] = 0;
bufferlist xattr;
- result = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, name.c_str(), xattr);
+ result = osd->store->getattr(coll_t(info.pgid), soid, name.c_str(), xattr);
if (result < 0 && result != -EEXIST && result !=-ENODATA)
break;
// write arrives before trimtrunc
dout(10) << " truncate_seq " << op.extent.truncate_seq << " > current " << seq
<< ", truncating to " << op.extent.truncate_size << dendl;
- t.truncate(coll_t::build_pg_coll(info.pgid), soid, op.extent.truncate_size);
+ t.truncate(coll_t(info.pgid), soid, op.extent.truncate_size);
oi.truncate_seq = op.extent.truncate_seq;
oi.truncate_size = op.extent.truncate_size;
}
if (op.extent.length) {
bufferlist nbl;
bp.copy(op.extent.length, nbl);
- t.write(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length, nbl);
+ t.write(coll_t(info.pgid), soid, op.extent.offset, op.extent.length, nbl);
} else {
- t.touch(coll_t::build_pg_coll(info.pgid), soid);
+ t.touch(coll_t(info.pgid), soid);
}
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
bufferlist nbl;
bp.copy(op.extent.length, nbl);
if (ctx->obs->exists)
- t.truncate(coll_t::build_pg_coll(info.pgid), soid, 0);
- t.write(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length, nbl);
+ t.truncate(coll_t(info.pgid), soid, 0);
+ t.write(coll_t(info.pgid), soid, op.extent.offset, op.extent.length, nbl);
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
ssc->snapset.clone_overlap.erase(newest);
{ // zero
assert(op.extent.length);
if (!ctx->obs->exists)
- t.touch(coll_t::build_pg_coll(info.pgid), soid);
- t.zero(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length);
+ t.touch(coll_t(info.pgid), soid);
+ t.zero(coll_t(info.pgid), soid, op.extent.offset, op.extent.length);
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
interval_set<uint64_t> ch;
if (ctx->obs->exists && (flags & CEPH_OSD_OP_FLAG_EXCL))
result = -EEXIST; /* this is an exclusive create */
else {
- t.touch(coll_t::build_pg_coll(info.pgid), soid);
+ t.touch(coll_t(info.pgid), soid);
ssc->snapset.head_exists = true;
}
}
oi.truncate_size = op.extent.truncate_size;
}
- t.truncate(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset);
+ t.truncate(coll_t(info.pgid), soid, op.extent.offset);
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
interval_set<uint64_t> trim;
case CEPH_OSD_OP_SETXATTR:
{
if (!ctx->obs->exists)
- t.touch(coll_t::build_pg_coll(info.pgid), soid);
+ t.touch(coll_t(info.pgid), soid);
string aname;
bp.copy(op.xattr.name_len, aname);
string name = "_" + aname;
bufferlist bl;
bp.copy(op.xattr.value_len, bl);
if (!ctx->obs->exists) // create object if it doesn't yet exist.
- t.touch(coll_t::build_pg_coll(info.pgid), soid);
- t.setattr(coll_t::build_pg_coll(info.pgid), soid, name, bl);
+ t.touch(coll_t(info.pgid), soid);
+ t.setattr(coll_t(info.pgid), soid, name, bl);
ssc->snapset.head_exists = true;
info.stats.num_wr++;
}
string aname;
bp.copy(op.xattr.name_len, aname);
string name = "_" + aname;
- t.rmattr(coll_t::build_pg_coll(info.pgid), soid, name);
+ t.rmattr(coll_t(info.pgid), soid, name);
info.stats.num_wr++;
}
break;
ObjectStore::Transaction& t = ctx->op_t;
if (ctx->obs->exists)
- t.remove(coll_t::build_pg_coll(info.pgid), soid);
+ t.remove(coll_t(info.pgid), soid);
if (ssc->snapset.clones.size()) {
snapid_t newest = *ssc->snapset.clones.rbegin();
add_interval_usage(ssc->snapset.clone_overlap[newest], info.stats);
ctx->obs->exists = true; //we're about to recreate it
map<string, bufferptr> attrs;
- t.clone(coll_t::build_pg_coll(info.pgid),
+ t.clone(coll_t(info.pgid),
rollback_to_sobject, new_head);
- osd->store->getattrs(coll_t::build_pg_coll(info.pgid),
+ osd->store->getattrs(coll_t(info.pgid),
rollback_to_sobject, attrs, false);
osd->filter_xattrs(attrs);
- t.setattrs(coll_t::build_pg_coll(info.pgid), new_head, attrs);
+ t.setattrs(coll_t(info.pgid), new_head, attrs);
ssc->snapset.head_exists = true;
map<snapid_t, interval_set<uint64_t> >::iterator iter =
::encode(*poi, bv);
map<string, bufferptr> attrs;
- osd->store->getattrs(coll_t::build_pg_coll(info.pgid), head, attrs);
+ osd->store->getattrs(coll_t(info.pgid), head, attrs);
osd->filter_xattrs(attrs);
- t.clone(coll_t::build_pg_coll(info.pgid), head, coid);
- t.setattr(coll_t::build_pg_coll(info.pgid), coid, OI_ATTR, bv);
- t.setattrs(coll_t::build_pg_coll(info.pgid), coid, attrs);
+ t.clone(coll_t(info.pgid), head, coid);
+ t.setattr(coll_t(info.pgid), coid, OI_ATTR, bv);
+ t.setattrs(coll_t(info.pgid), coid, attrs);
}
void ReplicatedPG::make_writeable(OpContext *ctx)
// add to snap bound collections
coll_t fc = make_snap_collection(t, snaps[0]);
- t.collection_add(fc, coll_t::build_pg_coll(info.pgid), coid);
+ t.collection_add(fc, coll_t(info.pgid), coid);
if (snaps.size() > 1) {
coll_t lc = make_snap_collection(t, snaps[snaps.size()-1]);
- t.collection_add(lc, coll_t::build_pg_coll(info.pgid), coid);
+ t.collection_add(lc, coll_t(info.pgid), coid);
}
info.stats.num_objects++;
bufferlist bv(sizeof(*poi));
::encode(*poi, bv);
- ctx->op_t.setattr(coll_t::build_pg_coll(info.pgid), soid, OI_ATTR, bv);
+ ctx->op_t.setattr(coll_t(info.pgid), soid, OI_ATTR, bv);
dout(10) << " final snapset " << ctx->obs->ssc->snapset
<< " in " << soid << dendl;
- ctx->op_t.setattr(coll_t::build_pg_coll(info.pgid), soid, SS_ATTR, bss);
+ ctx->op_t.setattr(coll_t(info.pgid), soid, SS_ATTR, bss);
if (!head_existed) {
// if we logically recreated the head, remove old _snapdir object
sobject_t snapoid(soid.oid, CEPH_SNAPDIR);
ctx->snapset_obc = get_object_context(snapoid, false);
if (ctx->snapset_obc && ctx->snapset_obc->obs.exists) {
- ctx->op_t.remove(coll_t::build_pg_coll(info.pgid), snapoid);
+ ctx->op_t.remove(coll_t(info.pgid), snapoid);
dout(10) << " removing old " << snapoid << dendl;
ctx->at_version.version++;
bufferlist bv(sizeof(*poi));
::encode(ctx->snapset_obc->obs.oi, bv);
- ctx->op_t.touch(coll_t::build_pg_coll(info.pgid), snapoid);
- ctx->op_t.setattr(coll_t::build_pg_coll(info.pgid), snapoid, OI_ATTR, bv);
- ctx->op_t.setattr(coll_t::build_pg_coll(info.pgid), snapoid, SS_ATTR, bss);
+ ctx->op_t.touch(coll_t(info.pgid), snapoid);
+ ctx->op_t.setattr(coll_t(info.pgid), snapoid, OI_ATTR, bv);
+ ctx->op_t.setattr(coll_t(info.pgid), snapoid, SS_ATTR, bss);
}
return result;
} else {
// check disk
bufferlist bv;
- int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, OI_ATTR, bv);
+ int r = osd->store->getattr(coll_t(info.pgid), soid, OI_ATTR, bv);
if (r < 0 && !can_create)
return 0; // -ENOENT!
} else {
bufferlist bv;
sobject_t head(oid, CEPH_NOSNAP);
- int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), head, SS_ATTR, bv);
+ int r = osd->store->getattr(coll_t(info.pgid), head, SS_ATTR, bv);
if (r < 0) {
// try _snapset
sobject_t snapdir(oid, CEPH_SNAPDIR);
- r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), snapdir, SS_ATTR, bv);
+ r = osd->store->getattr(coll_t(info.pgid), snapdir, SS_ATTR, bv);
if (r < 0 && !can_create)
return NULL;
}
<< " clone_overlap " << snapset.clone_overlap << dendl;
struct stat st;
- osd->store->stat(coll_t::build_pg_coll(info.pgid), head, &st);
+ osd->store->stat(coll_t(info.pgid), head, &st);
interval_set<uint64_t> cloning;
interval_set<uint64_t> prev;
void ReplicatedPG::push_start(const sobject_t& soid, int peer)
{
struct stat st;
- int r = osd->store->stat(coll_t::build_pg_coll(info.pgid), soid, &st);
+ int r = osd->store->stat(coll_t(info.pgid), soid, &st);
assert(r == 0);
uint64_t size = st.st_size;
bufferlist bl;
- r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, OI_ATTR, bl);
+ r = osd->store->getattr(coll_t(info.pgid), soid, OI_ATTR, bl);
object_info_t oi(bl);
interval_set<uint64_t> data_subset;
p != data_subset.end();
++p) {
bufferlist bit;
- osd->store->read(coll_t::build_pg_coll(info.pgid),
+ osd->store->read(coll_t(info.pgid),
soid, p.get_start(), p.get_len(), bit);
if (p.get_len() != bit.length()) {
dout(10) << " extent " << p.get_start() << "~" << p.get_len()
bl.claim_append(bit);
}
- osd->store->getattrs(coll_t::build_pg_coll(info.pgid), soid, attrset);
+ osd->store->getattrs(coll_t(info.pgid), soid, attrset);
bufferlist bv;
bv.push_back(attrset[OI_ATTR]);
assert(!is_primary()); // we should be a replica or stray.
struct stat st;
- int r = osd->store->stat(coll_t::build_pg_coll(info.pgid), soid, &st);
+ int r = osd->store->stat(coll_t(info.pgid), soid, &st);
if (r != 0) {
stringstream ss;
char buf[80];
coll_t target;
if (first && complete)
- target = coll_t::build_pg_coll(info.pgid);
+ target = coll_t(info.pgid);
else
- target = coll_t(coll_t::TYPE_TEMP);
+ target = coll_t::TEMP_COLL;
// write object and add it to the PG
ObjectStore::Transaction *t = new ObjectStore::Transaction;
if (complete) {
if (!first) {
- t->remove(coll_t::build_pg_coll(info.pgid), soid);
- t->collection_add(coll_t::build_pg_coll(info.pgid), target, soid);
+ t->remove(coll_t(info.pgid), soid);
+ t->collection_add(coll_t(info.pgid), target, soid);
t->collection_remove(target, soid);
}
{
dout(15) << " clone_range " << p->first << " "
<< q.get_start() << "~" << q.get_len() << dendl;
- t->clone_range(coll_t::build_pg_coll(info.pgid), p->first, soid,
+ t->clone_range(coll_t(info.pgid), p->first, soid,
q.get_start(), q.get_len());
}
}
if (data_subset.empty())
- t->touch(coll_t::build_pg_coll(info.pgid), soid);
+ t->touch(coll_t(info.pgid), soid);
- t->setattrs(coll_t::build_pg_coll(info.pgid), soid, op->attrset);
+ t->setattrs(coll_t(info.pgid), soid, op->attrset);
if (soid.snap && soid.snap < CEPH_NOSNAP &&
op->attrset.count(OI_ATTR)) {
bufferlist bl;
object_info_t oi(bl);
if (oi.snaps.size()) {
coll_t lc = make_snap_collection(*t, oi.snaps[0]);
- t->collection_add(lc, coll_t::build_pg_coll(info.pgid), soid);
+ t->collection_add(lc, coll_t(info.pgid), soid);
if (oi.snaps.size() > 1) {
coll_t hc = make_snap_collection(*t, oi.snaps[oi.snaps.size()-1]);
- t->collection_add(hc, coll_t::build_pg_coll(info.pgid), soid);
+ t->collection_add(hc, coll_t(info.pgid), soid);
}
}
}
void ReplicatedPG::remove_object_with_snap_hardlinks(ObjectStore::Transaction& t, const sobject_t& soid)
{
- t.remove(coll_t::build_pg_coll(info.pgid), soid);
+ t.remove(coll_t(info.pgid), soid);
if (soid.snap < CEPH_MAXSNAP) {
bufferlist ba;
- int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, OI_ATTR, ba);
+ int r = osd->store->getattr(coll_t(info.pgid), soid, OI_ATTR, ba);
if (r >= 0) {
// grr, need first snap bound, too.
object_info_t oi(ba);
if (oi.snaps[0] != soid.snap)
- t.remove(coll_t::build_snap_pg_coll(info.pgid, oi.snaps[0]), soid);
- t.remove(coll_t::build_snap_pg_coll(info.pgid, soid.snap), soid);
+ t.remove(coll_t(info.pgid, oi.snaps[0]), soid);
+ t.remove(coll_t(info.pgid, soid.snap), soid);
}
}
}
// be thorough.
vector<sobject_t> ls;
- osd->store->collection_list(coll_t::build_pg_coll(info.pgid), ls);
+ osd->store->collection_list(coll_t(info.pgid), ls);
set<sobject_t> s;
for (vector<sobject_t>::iterator i = ls.begin();
{
dout(10) << "_scrub" << dendl;
- coll_t c = coll_t::build_pg_coll(info.pgid);
+ coll_t c(info.pgid);
bool repair = state_test(PG_STATE_REPAIR);
const char *mode = repair ? "repair":"scrub";
#ifndef CEPH_OSD_TYPES_H
#define CEPH_OSD_TYPES_H
+#include <sstream>
#include <stdio.h>
+#include <stdexcept>
#include "msg/msg_types.h"
#include "include/types.h"
// ----------------------
-struct coll_t {
- enum type_t {
- TYPE_META = 0,
- TYPE_TEMP = 1,
- TYPE_PG = 2
- };
- __u8 type;
- pg_t pgid;
- snapid_t snap;
+class coll_t {
+public:
+ const static coll_t META_COLL;
+ const static coll_t TEMP_COLL;
- coll_t() : type(TYPE_META), snap(0) {}
- coll_t(type_t t) : type(t), snap(0) {}
- coll_t(type_t t, pg_t p, snapid_t s) : type(t), pgid(p), snap(s) {}
-
- static coll_t build_pg_coll(pg_t p) {
- return coll_t(TYPE_PG, p, CEPH_NOSNAP);
- }
- static coll_t build_snap_pg_coll(pg_t p, snapid_t s) {
- return coll_t(TYPE_PG, p, s);
- }
+ coll_t()
+ : str("meta")
+ { }
- bool is_pg(pg_t& p, snapid_t& sn) {
- if (type == TYPE_PG) {
- p = pgid;
- sn = snap;
- return true;
- }
- return false;
- }
+ explicit coll_t(const std::string &str_)
+ : str(str_)
+ { }
- ostream& print(ostream& out) const {
- switch (type) {
- case TYPE_META:
- return out << "meta";
- case TYPE_TEMP:
- return out << "temp";
- case TYPE_PG:
- out << pgid << "_" << snap;
- default:
- return out << "???";
- }
+ explicit coll_t(pg_t pgid, snapid_t snap = CEPH_NOSNAP)
+ : str(pg_and_snap_to_str(pgid, snap))
+ { }
+
+ const std::string& to_str() const {
+ return str;
}
- int print(char *o, int maxlen) {
- switch (type) {
- case TYPE_META:
- return snprintf(o, maxlen, "meta");
- case TYPE_TEMP:
- return snprintf(o, maxlen, "temp");
- case TYPE_PG:
- {
- int len = pgid.print(o, maxlen);
- if (snap != CEPH_NOSNAP)
- len += snprintf(o + len, maxlen - len, "_%llx", (long long unsigned)snap);
- else {
- strncat(o + len, "_head", maxlen - len);
- len += 5;
- }
- return len;
- }
- default:
- return snprintf(o, maxlen, "???");
- }
+
+ bool is_pg(pg_t& pgid, snapid_t& snap) const {
+ const char *cstr(str.c_str());
+
+ if (!pgid.parse(cstr))
+ return false;
+ const char *snap_start = strchr(cstr, '_');
+ if (!snap_start)
+ return false;
+ if (strncmp(snap_start, "_head", 5) == 0)
+ snap = CEPH_NOSNAP;
+ else
+ snap = strtoull(snap_start+1, 0, 16);
+ return true;
}
- bool parse(char *s) {
+
+ bool parse(const char *s) {
if (strncmp(s, "meta", 4) == 0) {
- type = TYPE_META;
- pgid = pg_t();
- snap = 0;
+ str = s;
return true;
}
if (strncmp(s, "temp", 4) == 0) {
- type = TYPE_TEMP;
- pgid = pg_t();
- snap = 0;
+ str = s;
return true;
}
- if (!pgid.parse(s))
- return false;
- char *sn = strchr(s, '_');
- if (!sn)
- return false;
- if (strncmp(sn, "_head", 5) == 0)
- snap = CEPH_NOSNAP;
- else
- snap = strtoull(sn+1, 0, 16);
- type = TYPE_PG;
- return true;
+ pg_t pgid;
+ snapid_t snap;
+ if (is_pg(pgid, snap)) {
+ str = s;
+ return true;
+ }
+ return false;
}
void encode(bufferlist& bl) const {
- __u8 struct_v = 2;
+ __u8 struct_v = 3;
::encode(struct_v, bl);
- ::encode(type, bl);
- ::encode(pgid, bl);
- ::encode(snap, bl);
+ ::encode(str, bl);
}
+
void decode(bufferlist::iterator& bl) {
__u8 struct_v;
::decode(struct_v, bl);
- if (struct_v >= 2)
- ::decode(type, bl);
- ::decode(pgid, bl);
- ::decode(snap, bl);
- if (struct_v < 2) {
- // infer the type
- if (pgid == pg_t() && snap == 0)
- type = TYPE_META;
- else
- type = TYPE_PG;
+ switch (struct_v) {
+ case 1: {
+ pg_t pgid;
+ snapid_t snap;
+
+ ::decode(pgid, bl);
+ ::decode(snap, bl);
+ // infer the type
+ if (pgid == pg_t() && snap == 0)
+ str = "meta";
+ else
+ str = pg_and_snap_to_str(pgid, snap);
+ break;
+ }
+
+ case 2: {
+ int type;
+ pg_t pgid;
+ snapid_t snap;
+
+ ::decode(type, bl);
+ ::decode(pgid, bl);
+ ::decode(snap, bl);
+ switch (type) {
+ case 0:
+ str = "meta";
+ break;
+ case 1:
+ str = "temp";
+ break;
+ case 2:
+ str = pg_and_snap_to_str(pgid, snap);
+ break;
+ default: {
+ ostringstream oss;
+ oss << "coll_t::decode(): can't understand type " << type;
+ throw std::domain_error(oss.str());
+ }
+ }
+ break;
+ }
+
+ case 3:
+ ::decode(str, bl);
+ break;
+
+ default: {
+ ostringstream oss;
+ oss << "coll_t::decode(): don't know how to decode verison "
+ << struct_v;
+ throw std::domain_error(oss.str());
+ }
}
}
+ inline bool operator==(const coll_t& rhs) const {
+ return str == rhs.str;
+ }
+ inline bool operator!=(const coll_t& rhs) const {
+ return str != rhs.str;
+ }
+
+private:
+ static std::string pg_and_snap_to_str(pg_t p, snapid_t s) {
+ std::ostringstream oss;
+ oss << p << "_" << s;
+ return oss.str();
+ }
+
+ std::string str;
};
+
WRITE_CLASS_ENCODER(coll_t)
inline ostream& operator<<(ostream& out, const coll_t& c) {
- return c.print(out);
-}
-
-#define TRIPLE_EQ(l, r, a, b, c) \
- l.a == r.a && l.b == r.b && l.c == r.c;
-#define TRIPLE_NE(l, r, a, b, c) \
- l.a != r.a && l.b != r.b && l.c != r.c;
-#define TRIPLE_LT(l, r, a, b, c) \
- l.a < r.a || (l.a == r.a && (l.b < r.b || \
- (l.b == r.b && l.c < r.c)));
-#define TRIPLE_LTE(l, r, a, b, c) \
- l.a < r.a || (l.a == r.a && (l.b < r.b || \
- (l.b == r.b && l.c <= r.c)));
-#define TRIPLE_GT(l, r, a, b, c) \
- l.a > r.a || (l.a == r.a && (l.b > r.b || \
- (l.b == r.b && l.c > r.c)));
-#define TRIPLE_GTE(l, r, a, b, c) \
- l.a > r.a || (l.a == r.a && (l.b > r.b || \
- (l.b == r.b && l.c >= r.c)));
-
-inline bool operator<(const coll_t& l, const coll_t& r) {
- return TRIPLE_LT(l, r, type, pgid, snap);
-}
-inline bool operator<=(const coll_t& l, const coll_t& r) {
- return TRIPLE_LTE(l, r, type, pgid, snap);
-}
-inline bool operator==(const coll_t& l, const coll_t& r) {
- return TRIPLE_EQ(l, r, type, pgid, snap);
-}
-inline bool operator!=(const coll_t& l, const coll_t& r) {
- return TRIPLE_NE(l, r, type, pgid, snap);
-}
-inline bool operator>(const coll_t& l, const coll_t& r) {
- return TRIPLE_GT(l, r, type, pgid, snap);
-}
-inline bool operator>=(const coll_t& l, const coll_t& r) {
- return TRIPLE_GTE(l, r, type, pgid, snap);
+ out << c.to_str();
+ return out;
}
namespace __gnu_cxx {
template<> struct hash<coll_t> {
size_t operator()(const coll_t &c) const {
- static hash<pg_t> H;
- static rjhash<uint64_t> I;
- return H(c.pgid) ^ I(c.snap + c.type);
+ size_t hash = 0;
+ string str(c.to_str());
+ std::string::const_iterator end(str.end());
+ for (std::string::const_iterator s = str.begin(); s != end; ++s) {
+ hash += *s;
+ hash += (hash << 10);
+ hash ^= (hash >> 6);
+ }
+ hash += (hash << 3);
+ hash ^= (hash >> 11);
+ hash += (hash << 15);
+ return hash;
}
};
}
-
-
inline ostream& operator<<(ostream& out, const ceph_object_layout &ol)
{
out << pg_t(ol.ol_pgid);
projects / ceph.git / commitdiff