From: Colin Patrick McCabe <cmccabe@alumni.cmu.edu>
Date: Thu, 30 Sep 2010 23:59:53 +0000 (-0700)
Subject: osd: generalize coll_t to a string
X-Git-Tag: v0.22~84
X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=a4138c905053cf79a03b50fa766c08ad718b8c58;p=ceph.git

osd: generalize coll_t to a string

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>
---

diff --git a/src/os/FileStore.cc b/src/os/FileStore.cc
index 76cb1d76cff1c..398444d1d0698 100644
--- a/src/os/FileStore.cc
+++ b/src/os/FileStore.cc
@@ -223,10 +223,8 @@ bool FileStore::parse_coll(char *s, coll_t& c)
 
 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) 
diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index dab596a81a2ca..c7f0477fa76cf 100644
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -100,10 +100,8 @@ static ostream& _prefix(ostream& out, int whoami, OSDMap *osdmap) {
   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
@@ -180,7 +178,7 @@ int OSD::mkfs(const char *dev, const char *jdev, ceph_fsid_t fsid, int whoami)
     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();
@@ -188,7 +186,7 @@ int OSD::mkfs(const char *dev, const char *jdev, ceph_fsid_t fsid, int whoami)
     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
@@ -199,9 +197,9 @@ int OSD::mkfs(const char *dev, const char *jdev, ceph_fsid_t fsid, int whoami)
   ::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;
@@ -493,10 +491,10 @@ int OSD::init()
   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);
   }
 
@@ -755,13 +753,13 @@ void OSD::write_superblock(ObjectStore::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;
 
@@ -802,7 +800,7 @@ void OSD::clear_temp()
   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())
@@ -813,7 +811,7 @@ void OSD::clear_temp()
   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();
@@ -901,8 +899,8 @@ PG *OSD::_create_lock_pg(pg_t pgid, ObjectStore::Transaction& t)
   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);
@@ -919,8 +917,8 @@ PG *OSD::_create_lock_new_pg(pg_t pgid, vector<int>& acting, ObjectStore::Transa
 
   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);
@@ -1791,9 +1789,9 @@ void OSD::handle_command(MMonCommand *m)
       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();
@@ -2348,7 +2346,7 @@ void OSD::handle_osd_map(MOSDMap *m)
        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;
@@ -2359,7 +2357,7 @@ void OSD::handle_osd_map(MOSDMap *m)
 
     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);
 
@@ -2375,7 +2373,7 @@ void OSD::handle_osd_map(MOSDMap *m)
        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;
@@ -2386,7 +2384,7 @@ void OSD::handle_osd_map(MOSDMap *m)
 
     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);
 
@@ -2412,7 +2410,7 @@ void OSD::handle_osd_map(MOSDMap *m)
     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;
@@ -2438,7 +2436,7 @@ void OSD::handle_osd_map(MOSDMap *m)
       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);
 
@@ -2458,7 +2456,7 @@ void OSD::handle_osd_map(MOSDMap *m)
       }
     }
     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))
@@ -2945,12 +2943,12 @@ void OSD::send_incremental_map(epoch_t since, const entity_inst_t& inst, bool la
 
 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)
@@ -3213,7 +3211,7 @@ void OSD::split_pg(PG *parent, map<pg_t,PG*>& children, ObjectStore::Transaction
 
   // 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;
@@ -3226,20 +3224,20 @@ void OSD::split_pg(PG *parent, map<pg_t,PG*>& children, ObjectStore::Transaction
       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);
 	}
       }
 
@@ -3723,7 +3721,7 @@ void OSD::_process_pg_info(epoch_t epoch, int from,
 		     << " -> " << 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;
@@ -4052,14 +4050,14 @@ void OSD::_remove_pg(PG *pg)
        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);
 
@@ -4073,18 +4071,18 @@ void OSD::_remove_pg(PG *pg)
 	}
       }
     }
-    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);
 
@@ -4117,7 +4115,7 @@ void OSD::_remove_pg(PG *pg)
   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);
   }
diff --git a/src/osd/PG.cc b/src/osd/PG.cc
index be2ed55f140b9..3163ac77a4f76 100644
--- a/src/osd/PG.cc
+++ b/src/osd/PG.cc
@@ -316,7 +316,7 @@ bool PG::merge_old_entry(ObjectStore::Transaction& t, Log::Entry& oe)
       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);
     }
   }
@@ -373,7 +373,7 @@ void PG::merge_log(ObjectStore::Transaction& t,
       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.
@@ -458,7 +458,7 @@ void PG::merge_log(ObjectStore::Transaction& t,
 	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
@@ -544,7 +544,7 @@ bool PG::build_backlog_map(map<eversion_t,Log::Entry>& omap)
   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();
@@ -554,7 +554,7 @@ bool PG::build_backlog_map(map<eversion_t,Log::Entry>& omap)
     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);
@@ -1991,7 +1991,7 @@ void PG::write_info(ObjectStore::Transaction& t)
   ::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;
@@ -1999,7 +1999,7 @@ void PG::write_info(ObjectStore::Transaction& t)
   ::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;
 }
@@ -2035,12 +2035,12 @@ void PG::write_log(ObjectStore::Transaction& t)
   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;
@@ -2090,10 +2090,10 @@ void PG::trim_ondisklog_to(ObjectStore::Transaction& t, eversion_t v)
   
   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()
@@ -2136,13 +2136,13 @@ void PG::append_log(ObjectStore::Transaction &t, bufferlist& bl,
   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;
 }
 
@@ -2152,7 +2152,7 @@ void PG::read_log(ObjectStore *store)
   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);
 
@@ -2164,7 +2164,7 @@ void PG::read_log(ObjectStore *store)
   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 << "="
@@ -2253,7 +2253,7 @@ void PG::read_log(ObjectStore *store)
       
       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) {
@@ -2261,7 +2261,7 @@ void PG::read_log(ObjectStore *store)
 	  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;
@@ -2272,7 +2272,7 @@ void PG::read_log(ObjectStore *store)
 	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);
 
@@ -2292,7 +2292,7 @@ bool PG::check_log_for_corruption(ObjectStore *store)
 {
   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);
 
@@ -2307,9 +2307,9 @@ bool PG::check_log_for_corruption(ObjectStore *store)
   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;
@@ -2365,7 +2365,7 @@ void PG::read_state(ObjectStore *store)
   __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);
@@ -2373,7 +2373,7 @@ void PG::read_state(ObjectStore *store)
   
   // 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);
@@ -2383,13 +2383,13 @@ void PG::read_state(ObjectStore *store)
 
 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;
@@ -2486,7 +2486,7 @@ void PG::sub_op_scrub_reply(MOSDSubOpReply *op)
 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;
diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index 542005f8d7f55..e56347d65cb02 100644
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -157,7 +157,7 @@ void ReplicatedPG::do_pg_op(MOSDOp *op)
         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) {
@@ -171,13 +171,13 @@ void ReplicatedPG::do_pg_op(MOSDOp *op)
 	      // 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)
@@ -494,7 +494,7 @@ bool ReplicatedPG::snap_trimmer()
 	 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);
 
@@ -517,7 +517,7 @@ bool ReplicatedPG::snap_trimmer()
 
       // 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
@@ -562,10 +562,10 @@ bool ReplicatedPG::snap_trimmer()
       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;
@@ -600,16 +600,16 @@ bool ReplicatedPG::snap_trimmer()
 	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,
@@ -629,7 +629,7 @@ bool ReplicatedPG::snap_trimmer()
 				      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, 
@@ -640,11 +640,11 @@ bool ReplicatedPG::snap_trimmer()
 
 	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);
@@ -814,7 +814,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
       {
 	// 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);
@@ -885,7 +885,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
       {
 	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);
@@ -900,7 +900,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	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;
@@ -913,7 +913,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
    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) {
@@ -936,7 +936,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	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;
 	
@@ -999,16 +999,16 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	  // 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();
@@ -1036,8 +1036,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	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);
@@ -1064,8 +1064,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
       { // 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;
@@ -1084,7 +1084,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	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;
         }
       }
@@ -1114,7 +1114,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	  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;
@@ -1150,15 +1150,15 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
     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++;
       }
@@ -1169,7 +1169,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 	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;
@@ -1463,7 +1463,7 @@ inline void ReplicatedPG::_delete_head(OpContext *ctx)
   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);
@@ -1527,12 +1527,12 @@ void ReplicatedPG::_rollback_to(OpContext *ctx, ceph_osd_op& op)
       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 =
@@ -1555,12 +1555,12 @@ void ReplicatedPG::_make_clone(ObjectStore::Transaction& t,
   ::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)
@@ -1617,10 +1617,10 @@ 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++;
@@ -1705,18 +1705,18 @@ int ReplicatedPG::prepare_transaction(OpContext *ctx)
 
     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++;
@@ -1745,9 +1745,9 @@ int ReplicatedPG::prepare_transaction(OpContext *ctx)
 
     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;
@@ -2186,7 +2186,7 @@ ReplicatedPG::ObjectContext *ReplicatedPG::get_object_context(const sobject_t& s
   } 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!
 
@@ -2335,11 +2335,11 @@ ReplicatedPG::SnapSetContext *ReplicatedPG::get_snapset_context(const object_t&
   } 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;
     }
@@ -2570,7 +2570,7 @@ void ReplicatedPG::calc_head_subsets(SnapSet& snapset, const sobject_t& head,
 	   << " 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;
@@ -2845,12 +2845,12 @@ void ReplicatedPG::push_to_replica(ObjectContext *obc, const sobject_t& soid, in
 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;
@@ -2898,7 +2898,7 @@ void ReplicatedPG::send_push_op(const sobject_t& soid, int peer,
        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()
@@ -2908,7 +2908,7 @@ void ReplicatedPG::send_push_op(const sobject_t& soid, int peer,
     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]);
@@ -3018,7 +3018,7 @@ void ReplicatedPG::sub_op_pull(MOSDSubOp *op)
   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];
@@ -3242,9 +3242,9 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
 
   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;
@@ -3268,8 +3268,8 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
   
   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);
     }
 
@@ -3284,15 +3284,15 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
       {
 	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;
@@ -3300,10 +3300,10 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
       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);
 	}
       }
     }
@@ -3735,16 +3735,16 @@ int ReplicatedPG::recover_replicas(int max)
 
 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);
     }
   }
 }
@@ -3765,7 +3765,7 @@ void ReplicatedPG::clean_up_local(ObjectStore::Transaction& t)
     
     // 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();
@@ -3835,7 +3835,7 @@ int ReplicatedPG::_scrub(ScrubMap& scrubmap, int& errors, int& fixed)
 {
   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";
 
diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index 744abd1f9d7cb..9e88978d6b180 100644
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -15,7 +15,9 @@
 #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"
@@ -227,172 +229,166 @@ namespace __gnu_cxx {
 
 // ----------------------
 
-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);