os: const ref (p)object_t arguments where possible

diff --git a/src/os/FileStore.cc b/src/os/FileStore.cc
index 4117931546bd4980ceaecee0de83e76662f996f8..cbbee28e469d8c02bbc203f2b9891b38b36e37b5 100644 (file)
--- a/src/os/FileStore.cc
+++ b/src/os/FileStore.cc
@@ -701,16 +701,16 @@ unsigned FileStore::_apply_transaction(Transaction& t)
       
     case Transaction::OP_CLONE:
       {
-       pobject_t oid = t.get_oid();
-       pobject_t noid = t.get_oid();
+       const pobject_t& oid = t.get_oid();
+       const pobject_t& noid = t.get_oid();
        _clone(t.get_cid(), oid, noid);
       }
       break;
 
     case Transaction::OP_CLONERANGE:
       {
-       pobject_t oid = t.get_oid();
-       pobject_t noid = t.get_oid();
+       const pobject_t& oid = t.get_oid();
+       const pobject_t& noid = t.get_oid();
        __u64 off = t.get_length();
        __u64 len = t.get_length();
        _clone_range(t.get_cid(), oid, noid, off, len);
@@ -1340,7 +1340,7 @@ int FileStore::_zero(coll_t cid, const pobject_t& oid, __u64 offset, size_t len)
   return _write(cid, oid, offset, len, bl);
 }
 
-int FileStore::_clone(coll_t cid, pobject_t oldoid, pobject_t newoid)
+int FileStore::_clone(coll_t cid, const pobject_t& oldoid, const pobject_t& newoid)
 {
   char ofn[PATH_MAX], nfn[PATH_MAX];
   get_coname(cid, oldoid, ofn);
@@ -1422,7 +1422,7 @@ int FileStore::_do_clone_range(int from, int to, __u64 off, __u64 len)
   return r;
 }
 
-int FileStore::_clone_range(coll_t cid, pobject_t oldoid, pobject_t newoid, __u64 off, __u64 len)
+int FileStore::_clone_range(coll_t cid, const pobject_t& oldoid, const pobject_t& newoid, __u64 off, __u64 len)
 {
   char ofn[PATH_MAX], nfn[PATH_MAX];
   get_coname(cid, oldoid, ofn);
@@ -2002,7 +2002,7 @@ int FileStore::_destroy_collection(coll_t c)
 }
 
 
-int FileStore::_collection_add(coll_t c, coll_t cid, pobject_t o) 
+int FileStore::_collection_add(coll_t c, coll_t cid, const pobject_t& o) 
 {
   if (fake_collections) return collections.collection_add(c, o);
 
@@ -2017,7 +2017,7 @@ int FileStore::_collection_add(coll_t c, coll_t cid, pobject_t o)
   return r;
 }
 
-int FileStore::_collection_remove(coll_t c, pobject_t o) 
+int FileStore::_collection_remove(coll_t c, const pobject_t& o) 
 {
   if (fake_collections) return collections.collection_remove(c, o);
 

diff --git a/src/os/FileStore.h b/src/os/FileStore.h
index 3fc39ad5ac6becc69d9dd72bc5145ccacf89ad88..1cce31b268c59da91d77a868bd686b4b5db5c683 100644 (file)
--- a/src/os/FileStore.h
+++ b/src/os/FileStore.h
@@ -112,8 +112,8 @@ class FileStore : public JournalingObjectStore {
   int _write(coll_t cid, const pobject_t& oid, __u64 offset, size_t len, const bufferlist& bl);
   int _zero(coll_t cid, const pobject_t& oid, __u64 offset, size_t len);
   int _truncate(coll_t cid, const pobject_t& oid, __u64 size);
-  int _clone(coll_t cid, pobject_t oldoid, pobject_t newoid);
-  int _clone_range(coll_t cid, pobject_t oldoid, pobject_t newoid, __u64 off, __u64 len);
+  int _clone(coll_t cid, const pobject_t& oldoid, const pobject_t& newoid);
+  int _clone_range(coll_t cid, const pobject_t& oldoid, const pobject_t& newoid, __u64 off, __u64 len);
   int _do_clone_range(int from, int to, __u64 off, __u64 len);
   int _remove(coll_t cid, const pobject_t& oid);
 
@@ -152,10 +152,9 @@ class FileStore : public JournalingObjectStore {
 
   int _create_collection(coll_t c);
   int _destroy_collection(coll_t c);
-  int _collection_add(coll_t c, coll_t ocid, pobject_t o);
-  int _collection_remove(coll_t c, pobject_t o);
+  int _collection_add(coll_t c, coll_t ocid, const pobject_t& o);
+  int _collection_remove(coll_t c, const pobject_t& o);
 
-  int pick_object_revision_lt(coll_t cid, pobject_t& oid) { return -1; }
   void trim_from_cache(coll_t cid, const pobject_t& oid, __u64 offset, size_t len) {}
   int is_cached(coll_t cid, const pobject_t& oid, __u64 offset, size_t len) { return -1; }
 };

diff --git a/src/os/ObjectStore.h b/src/os/ObjectStore.h
index f31cdc1f9267da2650500cd343858513057fc80c..134164006a1ce1e9e10a772b517d9038d2ec24c4 100644 (file)
--- a/src/os/ObjectStore.h
+++ b/src/os/ObjectStore.h
@@ -413,7 +413,6 @@ public:
   virtual int statfs(struct statfs *buf) = 0;
 
   // objects
-  virtual int pick_object_revision_lt(coll_t cid, pobject_t& oid) = 0;
   virtual bool exists(coll_t cid, const pobject_t& oid) = 0;                   // useful?
   virtual int stat(coll_t cid, const pobject_t& oid, struct stat *st) = 0;     // struct stat?
   virtual int read(coll_t cid, const pobject_t& oid, __u64 offset, size_t len, bufferlist& bl) = 0;

diff --git a/src/osd/PG.h b/src/osd/PG.h
index c99770339301a3a92473073ba96d3795a7b4ec63..683bd55a898b92da60b40e314fea84420ad8960b 100644 (file)
--- a/src/osd/PG.h
+++ b/src/osd/PG.h
@@ -199,7 +199,7 @@ public:
       bufferlist snaps;   // only for clone entries
       
       Entry() : op(0) {}
-      Entry(int _op, sobject_t _soid,
+      Entry(int _op, const sobject_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),
@@ -311,7 +311,7 @@ public:
       last_requested = sobject_t();
     }
 
-    bool logged_object(sobject_t oid) const {
+    bool logged_object(const sobject_t& oid) const {
       return objects.count(oid);
     }
     bool logged_req(const osd_reqid_t &r) const {
@@ -349,11 +349,11 @@ public:
 
 
     // accessors
-    Entry *is_updated(sobject_t oid) {
+    Entry *is_updated(const sobject_t& oid) {
       if (objects.count(oid) && objects[oid]->is_update()) return objects[oid];
       return 0;
     }
-    Entry *is_deleted(sobject_t oid) {
+    Entry *is_deleted(const sobject_t& oid) {
       if (objects.count(oid) && objects[oid]->is_delete()) return objects[oid];
       return 0;
     }
@@ -437,13 +437,13 @@ public:
       rmissing.swap(o.rmissing);
     }
 
-    bool is_missing(sobject_t oid) {
+    bool is_missing(const sobject_t& oid) {
       return missing.count(oid);
     }
-    bool is_missing(sobject_t oid, eversion_t v) {
+    bool is_missing(const sobject_t& oid, eversion_t v) {
       return missing.count(oid) && missing[oid].need <= v;
     }
-    eversion_t have_old(sobject_t oid) {
+    eversion_t have_old(const sobject_t& oid) {
       return missing.count(oid) ? missing[oid].have : eversion_t();
     }
     
@@ -499,18 +499,18 @@ public:
       rmissing[need] = oid;
     }
 
-    void add(sobject_t oid, eversion_t need, eversion_t have) {
+    void add(const sobject_t& oid, eversion_t need, eversion_t have) {
       missing[oid] = item(need, have);
       rmissing[need] = oid;
     }
     
-    void rm(sobject_t oid, eversion_t when) {
+    void rm(const sobject_t& oid, eversion_t when) {
       if (missing.count(oid) && missing[oid].need < when) {
         rmissing.erase(missing[oid].need);
         missing.erase(oid);
       }
     }
-    void got(sobject_t oid, eversion_t v) {
+    void got(const sobject_t& oid, eversion_t v) {
       assert(missing.count(oid));
       assert(missing[oid].need <= v);
       rmissing.erase(missing[oid].need);
@@ -843,8 +843,8 @@ public:
   virtual bool same_for_rep_modify_since(epoch_t e) = 0;
 
   virtual bool is_write_in_progress() = 0;
-  virtual bool is_missing_object(sobject_t oid) = 0;
-  virtual void wait_for_missing_object(sobject_t oid, Message *op) = 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 void on_osd_failure(int osd) = 0;
   virtual void on_role_change() = 0;

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index 575c4a52d214091b0a178538e24b6ba5332775bb..b9fb8cbb2a059e5be84f011dcdda610a1b72e3fb 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -71,13 +71,13 @@ bool ReplicatedPG::same_for_rep_modify_since(epoch_t e)
 // ====================
 // missing objects
 
-bool ReplicatedPG::is_missing_object(sobject_t soid)
+bool ReplicatedPG::is_missing_object(const sobject_t& soid)
 {
   return missing.missing.count(soid);
 }
  
 
-void ReplicatedPG::wait_for_missing_object(sobject_t soid, Message *m)
+void ReplicatedPG::wait_for_missing_object(const sobject_t& soid, Message *m)
 {
   assert(is_missing_object(soid));
 
@@ -379,7 +379,7 @@ void ReplicatedPG::do_pg_op(MOSDOp *op)
 
     case CEPH_OSD_OP_PGLS:
       {
-       vector<pobject_t> pobjects;
+       vector<sobject_t> pobjects;
        // ???
        vector<object_t> objects;
        // ???
@@ -660,15 +660,15 @@ bool ReplicatedPG::snap_trimmer()
         is_active()) {
     snapid_t sn = *info.dead_snaps.begin();
     coll_t c = info.pgid.to_snap_coll(sn);
-    vector<pobject_t> ls;
+    vector<sobject_t> ls;
     osd->store->collection_list(c, ls);
     if (ls.size() != info.stats.num_objects)
       dout(10) << " WARNING: " << ls.size() << " != num_objects " << info.stats.num_objects << dendl;
 
     dout(10) << "snap_trimmer collection " << c << " has " << ls.size() << " items" << dendl;
 
-    for (vector<pobject_t>::iterator p = ls.begin(); p != ls.end(); p++) {
-      sobject_t coid = *p;
+    for (vector<sobject_t>::iterator p = ls.begin(); p != ls.end(); p++) {
+      const sobject_t& coid = *p;
 
       ObjectStore::Transaction t;
 
@@ -1247,7 +1247,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<ceph_osd_op>& ops,
 
 
 void ReplicatedPG::_make_clone(ObjectStore::Transaction& t,
-                              sobject_t head, pobject_t coid,
+                              const sobject_t& head, const sobject_t& coid,
                               object_info_t *poi)
 {
   bufferlist bv;
@@ -1757,7 +1757,7 @@ ReplicatedPG::ObjectContext *ReplicatedPG::get_object_context(const sobject_t& s
 }
 
 
-int ReplicatedPG::find_object_context(object_t oid, snapid_t snapid,
+int ReplicatedPG::find_object_context(const object_t& oid, snapid_t snapid,
                                      ObjectContext **pobc,
                                      bool can_create)
 {
@@ -2004,7 +2004,7 @@ public:
 
 void ReplicatedPG::sub_op_modify(MOSDSubOp *op)
 {
-  sobject_t soid = op->poid;
+  const sobject_t& soid = op->poid;
 
   const char *opname;
   if (op->noop)
@@ -2141,10 +2141,10 @@ void ReplicatedPG::sub_op_modify_reply(MOSDSubOpReply *r)
 
 // ===========================================================
 
-void ReplicatedPG::calc_head_subsets(SnapSet& snapset, pobject_t head,
+void ReplicatedPG::calc_head_subsets(SnapSet& snapset, const sobject_t& head,
                                     Missing& missing,
                                     interval_set<__u64>& data_subset,
-                                    map<pobject_t, interval_set<__u64> >& clone_subsets)
+                                    map<sobject_t, interval_set<__u64> >& clone_subsets)
 {
   dout(10) << "calc_head_subsets " << head
           << " clone_overlap " << snapset.clone_overlap << dendl;
@@ -2158,7 +2158,7 @@ void ReplicatedPG::calc_head_subsets(SnapSet& snapset, pobject_t head,
     prev.insert(0, st.st_size);    
   
   for (int j=snapset.clones.size()-1; j>=0; j--) {
-    pobject_t c = head;
+    sobject_t c = head;
     c.snap = snapset.clones[j];
     prev.intersection_of(snapset.clone_overlap[snapset.clones[j]]);
     if (!missing.is_missing(c)) {
@@ -2182,10 +2182,10 @@ void ReplicatedPG::calc_head_subsets(SnapSet& snapset, pobject_t head,
           << "  clone_subsets " << clone_subsets << dendl;
 }
 
-void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, sobject_t soid,
+void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, const sobject_t& soid,
                                      Missing& missing,
                                      interval_set<__u64>& data_subset,
-                                     map<pobject_t, interval_set<__u64> >& clone_subsets)
+                                     map<sobject_t, interval_set<__u64> >& clone_subsets)
 {
   dout(10) << "calc_clone_subsets " << soid
           << " clone_overlap " << snapset.clone_overlap << dendl;
@@ -2222,7 +2222,7 @@ void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, sobject_t soid,
   if (size)
     next.insert(0, size);    
   for (unsigned j=i+1; j<snapset.clones.size(); j++) {
-    pobject_t c = soid;
+    sobject_t c = soid;
     c.snap = snapset.clones[j];
     next.intersection_of(snapset.clone_overlap[snapset.clones[j-1]]);
     if (!missing.is_missing(c)) {
@@ -2249,7 +2249,7 @@ void ReplicatedPG::calc_clone_subsets(SnapSet& snapset, sobject_t soid,
 
 /** pull - request object from a peer
  */
-bool ReplicatedPG::pull(sobject_t soid)
+bool ReplicatedPG::pull(const sobject_t& soid)
 {
   eversion_t v = missing.missing[soid].need;
 
@@ -2273,12 +2273,12 @@ bool ReplicatedPG::pull(sobject_t soid)
   if (fromosd < 0)
     return false;
 
-  map<pobject_t, interval_set<__u64> > clone_subsets;
+  map<sobject_t, interval_set<__u64> > clone_subsets;
   interval_set<__u64> data_subset;
 
   // is this a snapped object?  if so, consult the snapset.. we may not need the entire object!
   if (soid.snap && soid.snap < CEPH_NOSNAP) {
-    pobject_t head = soid;
+    sobject_t head = soid;
     head.snap = CEPH_NOSNAP;
     
     // do we have the head?
@@ -2333,7 +2333,7 @@ bool ReplicatedPG::pull(sobject_t soid)
  * intelligently push an object to a replica.  make use of existing
  * clones/heads and dup data ranges where possible.
  */
-void ReplicatedPG::push_to_replica(sobject_t soid, int peer)
+void ReplicatedPG::push_to_replica(const sobject_t& soid, int peer)
 {
   dout(10) << "push_to_replica " << soid << " osd" << peer << dendl;
 
@@ -2342,7 +2342,7 @@ void ReplicatedPG::push_to_replica(sobject_t soid, int peer)
   int r = osd->store->stat(info.pgid.to_coll(), soid, &st);
   assert(r == 0);
   
-  map<pobject_t, interval_set<__u64> > clone_subsets;
+  map<sobject_t, interval_set<__u64> > clone_subsets;
   interval_set<__u64> data_subset;
 
   bufferlist bv;
@@ -2352,7 +2352,7 @@ void ReplicatedPG::push_to_replica(sobject_t soid, int peer)
   
   // are we doing a clone on the replica?
   if (soid.snap && soid.snap < CEPH_NOSNAP) {  
-    pobject_t head = soid;
+    sobject_t head = soid;
     head.snap = CEPH_NOSNAP;
     if (peer_missing[peer].is_missing(head) &&
        peer_missing[peer].have_old(head) == oi.prior_version) {
@@ -2360,7 +2360,7 @@ void ReplicatedPG::push_to_replica(sobject_t soid, int peer)
               << " v" << oi.prior_version 
               << ", pushing " << soid << " attrs as a clone op" << dendl;
       interval_set<__u64> data_subset;
-      map<pobject_t, interval_set<__u64> > clone_subsets;
+      map<sobject_t, interval_set<__u64> > clone_subsets;
       clone_subsets[head].insert(0, st.st_size);
       push(soid, peer, data_subset, clone_subsets);
       return;
@@ -2396,16 +2396,16 @@ void ReplicatedPG::push_to_replica(sobject_t soid, int peer)
 /*
  * push - send object to a peer
  */
-void ReplicatedPG::push(sobject_t soid, int peer)
+void ReplicatedPG::push(const sobject_t& soid, int peer)
 {
   interval_set<__u64> subset;
-  map<pobject_t, interval_set<__u64> > clone_subsets;
+  map<sobject_t, interval_set<__u64> > clone_subsets;
   push(soid, peer, subset, clone_subsets);
 }
 
-void ReplicatedPG::push(sobject_t soid, int peer, 
+void ReplicatedPG::push(const sobject_t& soid, int peer, 
                        interval_set<__u64> &data_subset,
-                       map<pobject_t, interval_set<__u64> >& clone_subsets)
+                       map<sobject_t, interval_set<__u64> >& clone_subsets)
 {
   // read data+attrs
   bufferlist bl;
@@ -2472,7 +2472,7 @@ void ReplicatedPG::sub_op_push_reply(MOSDSubOpReply *reply)
   dout(10) << "sub_op_push_reply from " << reply->get_source() << " " << *reply << dendl;
   
   int peer = reply->get_source().num();
-  sobject_t soid = reply->get_poid();
+  const sobject_t& soid = reply->get_poid();
   
   if (pushing.count(soid) &&
       pushing[soid].count(peer)) {
@@ -2504,7 +2504,7 @@ void ReplicatedPG::sub_op_push_reply(MOSDSubOpReply *reply)
  */
 void ReplicatedPG::sub_op_pull(MOSDSubOp *op)
 {
-  const pobject_t soid = op->poid;
+  const sobject_t soid = op->poid;
   const eversion_t v = op->version;
 
   dout(7) << "op_pull " << soid << " v " << op->version
@@ -2523,7 +2523,7 @@ void ReplicatedPG::sub_op_pull(MOSDSubOp *op)
  */
 void ReplicatedPG::sub_op_push(MOSDSubOp *op)
 {
-  sobject_t soid = op->poid;
+  const sobject_t& soid = op->poid;
   eversion_t v = op->version;
   ceph_osd_op& push = op->ops[0];
 
@@ -2537,7 +2537,7 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
           << dendl;
 
   interval_set<__u64> data_subset;
-  map<pobject_t, interval_set<__u64> > clone_subsets;
+  map<sobject_t, interval_set<__u64> > clone_subsets;
 
   // are we missing (this specific version)?
   //  (if version is wrong, it is either old (we don't want it) or 
@@ -2561,7 +2561,7 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
   if (is_primary()) {
     if (soid.snap && soid.snap < CEPH_NOSNAP) {
       // clone.  make sure we have enough data.
-      pobject_t head = soid;
+      sobject_t head = soid;
       head.snap = CEPH_NOSNAP;
       assert(!missing.is_missing(head));
 
@@ -2625,7 +2625,7 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
   t.remove(info.pgid.to_coll(), soid);  // in case old version exists
 
   __u64 boff = 0;
-  for (map<pobject_t, interval_set<__u64> >::iterator p = clone_subsets.begin();
+  for (map<sobject_t, interval_set<__u64> >::iterator p = clone_subsets.begin();
        p != clone_subsets.end();
        p++)
     for (map<__u64,__u64>::iterator q = p->second.m.begin();
@@ -2853,7 +2853,7 @@ int ReplicatedPG::recover_primary(int max)
     latest = log.objects[p->first];
     assert(latest);
 
-    sobject_t soid(latest->soid);
+    const sobject_t& soid(latest->soid);
     sobject_t head = soid;
     head.snap = CEPH_NOSNAP;
 
@@ -2962,7 +2962,7 @@ int ReplicatedPG::recover_replicas(int max)
       continue;
     
     // oldest first!
-    sobject_t soid = peer_missing[peer].rmissing.begin()->second;
+    const sobject_t& soid = peer_missing[peer].rmissing.begin()->second;
     eversion_t v = peer_missing[peer].rmissing.begin()->first;
 
     push_to_replica(soid, peer);
@@ -3008,14 +3008,14 @@ void ReplicatedPG::clean_up_local(ObjectStore::Transaction& t)
     // FIXME: sloppy pobject vs object conversions abound!  ***
     
     // be thorough.
-    vector<pobject_t> ls;
+    vector<sobject_t> ls;
     osd->store->collection_list(info.pgid.to_coll(), ls);
     if (ls.size() != info.stats.num_objects)
       dout(10) << " WARNING: " << ls.size() << " != num_objects " << info.stats.num_objects << dendl;
 
     set<sobject_t> s;
     
-    for (vector<pobject_t>::iterator i = ls.begin();
+    for (vector<sobject_t>::iterator i = ls.begin();
          i != ls.end();
          i++) 
       s.insert(*i);
@@ -3093,7 +3093,7 @@ int ReplicatedPG::_scrub(ScrubMap& scrubmap)
   for (vector<ScrubMap::object>::reverse_iterator p = scrubmap.objects.rbegin(); 
        p != scrubmap.objects.rend(); 
        p++) {
-    sobject_t soid = p->poid;
+    const sobject_t& soid = p->poid;
     stat.num_objects++;
 
     // basic checks.

diff --git a/src/osd/ReplicatedPG.h b/src/osd/ReplicatedPG.h
index e13418f0f1af4b8019e9d2e5086c0c4f772e4b01..481fc194a050ba5615307a3b1d1c83dbb0205405 100644 (file)
--- a/src/osd/ReplicatedPG.h
+++ b/src/osd/ReplicatedPG.h
@@ -362,7 +362,7 @@ protected:
     }
   }
   void put_object_context(ObjectContext *obc);
-  int find_object_context(object_t oid, snapid_t snapid, ObjectContext **pobc, bool can_create);
+  int find_object_context(const object_t& oid, snapid_t snapid, ObjectContext **pobc, bool can_create);
 
   bool is_write_in_progress() {
     return !object_contexts.empty();
@@ -378,25 +378,25 @@ protected:
   map<sobject_t, pair<eversion_t, int> > pulling;  // which objects are currently being pulled, and from where
   map<sobject_t, set<int> > pushing;
 
-  void calc_head_subsets(SnapSet& snapset, sobject_t head,
+  void calc_head_subsets(SnapSet& snapset, const sobject_t& head,
                         Missing& missing,
                         interval_set<__u64>& data_subset,
                         map<sobject_t, interval_set<__u64> >& clone_subsets);
-  void calc_clone_subsets(SnapSet& snapset, sobject_t poid, Missing& missing,
+  void calc_clone_subsets(SnapSet& snapset, const sobject_t& poid, Missing& missing,
                          interval_set<__u64>& data_subset,
                          map<sobject_t, interval_set<__u64> >& clone_subsets);
-  void push_to_replica(sobject_t oid, int dest);
-  void push(sobject_t oid, int dest);
-  void push(sobject_t oid, int dest, interval_set<__u64>& data_subset, 
+  void push_to_replica(const sobject_t& oid, int dest);
+  void push(const sobject_t& oid, int dest);
+  void push(const sobject_t& oid, int dest, interval_set<__u64>& data_subset, 
            map<sobject_t, interval_set<__u64> >& clone_subsets);
-  bool pull(sobject_t oid);
+  bool pull(const sobject_t& oid);
 
 
   // low level ops
   void op_ondisk(RepGather *repop);
 
   void _make_clone(ObjectStore::Transaction& t,
-                  sobject_t head, sobject_t coid,
+                  const sobject_t& head, const sobject_t& coid,
                   object_info_t *poi);
   void make_writeable(OpContext *ctx);
   void log_op_stats(const sobject_t &soid, OpContext *ctx);
@@ -453,8 +453,8 @@ public:
   bool same_for_modify_since(epoch_t e);
   bool same_for_rep_modify_since(epoch_t e);
 
-  bool is_missing_object(sobject_t oid);
-  void wait_for_missing_object(sobject_t oid, Message *op);
+  bool is_missing_object(const sobject_t& oid);
+  void wait_for_missing_object(const sobject_t& oid, Message *op);
 
   void on_osd_failure(int o);
   void on_acker_change();