rgw: metadata handler for bucket set_attr operations

Signed-off-by: Yehuda Sadeh <yehuda@inktank.com>

9 files changed, 160 insertions, 82 deletions

diff --git a/src/rgw/rgw_bucket.cc b/src/rgw/rgw_bucket.cc
index 53f6bf96c9f..934caf3a751 100644
--- a/src/rgw/rgw_bucket.cc
+++ b/src/rgw/rgw_bucket.cc
@@ -72,24 +72,6 @@ int rgw_read_user_buckets(RGWRados *store, string user_id, RGWUserBuckets& bucke
   return 0;
 }
 
-/**
- * Store the set of buckets associated with a user on a n xattr
- * not used with all backends
- * This completely overwrites any previously-stored list, so be careful!
- * Returns 0 on success, -ERR# otherwise.
- */
-int rgw_write_buckets_attr(RGWRados *store, string user_id, RGWUserBuckets& buckets)
-{
-  bufferlist bl;
-  buckets.encode(bl);
-
-  rgw_obj obj(store->zone.user_uid_pool, user_id);
-
-  int ret = store->set_attr(NULL, obj, RGW_ATTR_BUCKETS, bl);
-
-  return ret;
-}
-
 int rgw_add_bucket(RGWRados *store, string user_id, rgw_bucket& bucket)
 {
   int ret;
@@ -170,7 +152,7 @@ int RGWBucket::create_bucket(string bucket_str, string& user_id, string& display
 
   obj.init(bucket, no_oid);
 
-  ret = store->set_attr(NULL, obj, RGW_ATTR_ACL, aclbl);
+  ret = store->set_attr(NULL, obj, RGW_ATTR_ACL, aclbl, &objv_tracker);
   if (ret < 0) {
     lderr(store->ctx()) << "ERROR: failed to set acl on bucket" << dendl;
     goto done;
@@ -184,6 +166,15 @@ done:
   return ret;
 }
 
+int rgw_bucket_set_attrs(RGWRados *store, rgw_obj& obj,
+                         map<string, bufferlist>& attrs,
+                         map<string, bufferlist>* rmattrs,
+                         RGWObjVersionTracker *objv_tracker)
+{
+  return store->meta_mgr->set_attrs(bucket_meta_handler, obj.bucket.name,
+                                    obj, attrs, rmattrs, objv_tracker);
+}
+
 static void dump_mulipart_index_results(list<std::string>& objs_to_unlink,
         Formatter *f)
 {
@@ -401,8 +392,9 @@ int RGWBucket::link(RGWBucketAdminOpState& op_state, std::string *err_msg)
   string uid_str(user_id);
   bufferlist aclbl;
   rgw_obj obj(bucket, no_oid);
+  RGWObjVersionTracker objv_tracker;
 
-  int r = store->get_attr(NULL, obj, RGW_ATTR_ACL, aclbl);
+  int r = store->get_attr(NULL, obj, RGW_ATTR_ACL, aclbl, &objv_tracker);
   if (r >= 0) {
     RGWAccessControlPolicy policy;
     ACLOwner owner;
@@ -438,7 +430,7 @@ int RGWBucket::link(RGWBucketAdminOpState& op_state, std::string *err_msg)
     aclbl.clear();
     policy.encode(aclbl);
 
-    r = store->set_attr(NULL, obj, RGW_ATTR_ACL, aclbl);
+    r = store->set_attr(NULL, obj, RGW_ATTR_ACL, aclbl, &objv_tracker);
     if (r < 0)
       return r;
 
@@ -699,7 +691,7 @@ int RGWBucket::get_policy(RGWBucketAdminOpState& op_state, ostream& o)
 
   bufferlist bl;
   rgw_obj obj(bucket, object_name);
-  int ret = store->get_attr(NULL, obj, RGW_ATTR_ACL, bl);
+  int ret = store->get_attr(NULL, obj, RGW_ATTR_ACL, bl, NULL);
   if (ret < 0)
     return ret;
 
@@ -1326,7 +1318,6 @@ public:
   };
 
   int remove(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker) {
-#warning FIXME: use objv_tracker
     rgw_bucket bucket;
     int r = init_bucket(store, entry, bucket, &objv_tracker);
     if (r < 0) {
diff --git a/src/rgw/rgw_bucket.h b/src/rgw/rgw_bucket.h
index d8915e364a8..e302de9baaf 100644
--- a/src/rgw/rgw_bucket.h
+++ b/src/rgw/rgw_bucket.h
@@ -91,19 +91,17 @@ extern void rgw_bucket_init(RGWMetadataManager *mm);
 extern int rgw_read_user_buckets(RGWRados *store, string user_id, RGWUserBuckets& buckets,
                                  const string& marker, uint64_t max, bool need_stats);
 
-/**
- * Store the set of buckets associated with a user.
- * This completely overwrites any previously-stored list, so be careful!
- * Returns 0 on success, -ERR# otherwise.
- */
-extern int rgw_write_buckets_attr(RGWRados *store, string user_id, RGWUserBuckets& buckets);
-
 extern int rgw_add_bucket(RGWRados *store, string user_id, rgw_bucket& bucket);
 extern int rgw_remove_user_bucket_info(RGWRados *store, string user_id, rgw_bucket& bucket);
 
 extern int rgw_remove_object(RGWRados *store, rgw_bucket& bucket, std::string& object);
 extern int rgw_remove_bucket(RGWRados *store, rgw_bucket& bucket, bool delete_children);
 
+extern int rgw_bucket_set_attrs(RGWRados *store, rgw_obj& obj,
+                                map<string, bufferlist>& attrs,
+                                map<string, bufferlist>* rmattrs,
+                                RGWObjVersionTracker *objv_tracker);
+
 extern void check_bad_user_bucket_mapping(RGWRados *store, const string& user_id, bool fix);
 
 struct RGWBucketAdminOpState {
diff --git a/src/rgw/rgw_cache.h b/src/rgw/rgw_cache.h
index ec09552b524..d920b3ae1ce 100644
--- a/src/rgw/rgw_cache.h
+++ b/src/rgw/rgw_cache.h
@@ -185,10 +185,11 @@ class RGWCache  : public T
 public:
   RGWCache() {}
 
-  int set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl);
+  int set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl, RGWObjVersionTracker *objv_tracker);
   int set_attrs(void *ctx, rgw_obj& obj, 
                 map<string, bufferlist>& attrs,
-                map<string, bufferlist>* rmattrs);
+                map<string, bufferlist>* rmattrs,
+                RGWObjVersionTracker *objv_tracker);
   int put_obj_meta_impl(void *ctx, rgw_obj& obj, uint64_t size, time_t *mtime,
                    map<std::string, bufferlist>& attrs, RGWObjCategory category, int flags,
                    map<std::string, bufferlist>* rmattrs, const bufferlist *data,
@@ -286,7 +287,7 @@ int RGWCache<T>::get_obj(void *ctx, RGWObjVersionTracker *objv_tracker, void **h
 }
 
 template <class T>
-int RGWCache<T>::set_attr(void *ctx, rgw_obj& obj, const char *attr_name, bufferlist& bl)
+int RGWCache<T>::set_attr(void *ctx, rgw_obj& obj, const char *attr_name, bufferlist& bl, RGWObjVersionTracker *objv_tracker)
 {
   rgw_bucket bucket;
   string oid;
@@ -299,7 +300,7 @@ int RGWCache<T>::set_attr(void *ctx, rgw_obj& obj, const char *attr_name, buffer
     info.status = 0;
     info.flags = CACHE_FLAG_MODIFY_XATTRS;
   }
-  int ret = T::set_attr(ctx, obj, attr_name, bl);
+  int ret = T::set_attr(ctx, obj, attr_name, bl, objv_tracker);
   if (cacheable) {
     string name = normal_name(bucket, oid);
     if (ret >= 0) {
@@ -318,7 +319,8 @@ int RGWCache<T>::set_attr(void *ctx, rgw_obj& obj, const char *attr_name, buffer
 template <class T>
 int RGWCache<T>::set_attrs(void *ctx, rgw_obj& obj, 
                            map<string, bufferlist>& attrs,
-                           map<string, bufferlist>* rmattrs) 
+                           map<string, bufferlist>* rmattrs,
+                           RGWObjVersionTracker *objv_tracker) 
 {
   rgw_bucket bucket;
   string oid;
@@ -333,7 +335,7 @@ int RGWCache<T>::set_attrs(void *ctx, rgw_obj& obj,
     info.status = 0;
     info.flags = CACHE_FLAG_MODIFY_XATTRS;
   }
-  int ret = T::set_attrs(ctx, obj, attrs, rmattrs);
+  int ret = T::set_attrs(ctx, obj, attrs, rmattrs, objv_tracker);
   if (cacheable) {
     string name = normal_name(bucket, oid);
     if (ret >= 0) {
diff --git a/src/rgw/rgw_metadata.cc b/src/rgw/rgw_metadata.cc
index 423d96bde4f..c474a6d0de7 100644
--- a/src/rgw/rgw_metadata.cc
+++ b/src/rgw/rgw_metadata.cc
@@ -472,11 +472,10 @@ void RGWMetadataManager::get_sections(list<string>& sections)
   }
 }
 
-int RGWMetadataManager::put_entry(RGWMetadataHandler *handler, string& key, bufferlist& bl, bool exclusive,
-                                  RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs)
+int RGWMetadataManager::pre_modify(RGWMetadataHandler *handler, string& section, string& key,
+                                   RGWMetadataLogData& log_data, RGWObjVersionTracker *objv_tracker)
 {
-  bufferlist logbl;
-  string section = handler->get_type();
+  section = handler->get_type();
 
   /* if write version has not been set, and there's a read version, set it so that we can
    * log it
@@ -487,31 +486,74 @@ int RGWMetadataManager::put_entry(RGWMetadataHandler *handler, string& key, buff
     objv_tracker->write_version.ver++;
   }
 
-  RGWMetadataLogData log_data;
   log_data.read_version = objv_tracker->read_version;
   log_data.write_version = objv_tracker->write_version;
 
   log_data.status = MDLOG_STATUS_WRITING;
 
+  bufferlist logbl;
   ::encode(log_data, logbl);
 
   int ret = md_log->add_entry(store, section, key, logbl);
   if (ret < 0)
     return ret;
 
-  ret = handler->put_entry(store, key, bl, exclusive, objv_tracker, pattrs);
-  if (ret < 0)
-    return ret;
+  return 0;
+}
 
+int RGWMetadataManager::post_modify(string& section, string& key, RGWMetadataLogData& log_data,
+                                    RGWObjVersionTracker *objv_tracker)
+{
   log_data.status = MDLOG_STATUS_COMPLETE;
 
-  logbl.clear();
+  bufferlist logbl;
   ::encode(log_data, logbl);
 
-  ret = md_log->add_entry(store, section, key, logbl);
+  int ret = md_log->add_entry(store, section, key, logbl);
   if (ret < 0)
     return ret;
 
   return 0;
 }
 
+int RGWMetadataManager::put_entry(RGWMetadataHandler *handler, string& key, bufferlist& bl, bool exclusive,
+                                  RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs)
+{
+  string section;
+  RGWMetadataLogData log_data;
+  int ret = pre_modify(handler, section, key, log_data, objv_tracker);
+  if (ret < 0)
+    return ret;
+
+  ret = handler->put_entry(store, key, bl, exclusive, objv_tracker, pattrs);
+  if (ret < 0)
+    return ret;
+
+  ret = post_modify(section, key, log_data, objv_tracker);
+  if (ret < 0)
+    return ret;
+
+  return 0;
+}
+
+int RGWMetadataManager::set_attrs(RGWMetadataHandler *handler, string& key,
+                                  rgw_obj& obj, map<string, bufferlist>& attrs,
+                                  map<string, bufferlist>* rmattrs,
+                                  RGWObjVersionTracker *objv_tracker)
+{
+  string section;
+  RGWMetadataLogData log_data;
+  int ret = pre_modify(handler, section, key, log_data, objv_tracker);
+  if (ret < 0)
+    return ret;
+
+  ret = store->set_attrs(NULL, obj, attrs, rmattrs, objv_tracker);
+  if (ret < 0)
+    return ret;
+
+  ret = post_modify(section, key, log_data, objv_tracker);
+  if (ret < 0)
+    return ret;
+
+  return 0;
+}
diff --git a/src/rgw/rgw_metadata.h b/src/rgw/rgw_metadata.h
index 266769e2e9c..b9e10fd7326 100644
--- a/src/rgw/rgw_metadata.h
+++ b/src/rgw/rgw_metadata.h
@@ -92,6 +92,8 @@ public:
   int trim(RGWRados *store, utime_t& from_time, utime_t& end_time);
 };
 
+class RGWMetadataLogData;
+
 class RGWMetadataManager {
   map<string, RGWMetadataHandler *> handlers;
   CephContext *cct;
@@ -101,6 +103,10 @@ class RGWMetadataManager {
   void parse_metadata_key(const string& metadata_key, string& type, string& entry);
 
   int find_handler(const string& metadata_key, RGWMetadataHandler **handler, string& entry);
+  int pre_modify(RGWMetadataHandler *handler, string& section, string& key,
+                 RGWMetadataLogData& log_data, RGWObjVersionTracker *objv_tracker);
+  int post_modify(string& section, string& key, RGWMetadataLogData& log_data,
+                 RGWObjVersionTracker *objv_tracker);
 
 public:
   RGWMetadataManager(CephContext *_cct, RGWRados *_store);
@@ -112,6 +118,12 @@ public:
 
   int put_entry(RGWMetadataHandler *handler, string& key, bufferlist& bl, bool exclusive,
                 RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs = NULL);
+  int set_attr(RGWMetadataHandler *handler, string& key, rgw_obj& obj, string& attr, bufferlist& bl,
+               RGWObjVersionTracker *objv_tracker);
+ int set_attrs(RGWMetadataHandler *handler, string& key,
+               rgw_obj& obj, map<string, bufferlist>& attrs,
+               map<string, bufferlist>* rmattrs,
+               RGWObjVersionTracker *objv_tracker);
   int get(string& metadata_key, Formatter *f);
   int put(string& metadata_key, bufferlist& bl);
   int remove(string& metadata_key);
diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index d1bba263c91..0ed9f6893eb 100644
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -193,7 +193,8 @@ static int get_policy_from_attr(CephContext *cct, RGWRados *store, void *ctx, RG
   int ret = 0;
 
   if (obj.bucket.name.size()) {
-    ret = store->get_attr(ctx, obj, RGW_ATTR_ACL, bl);
+    RGWObjVersionTracker objv_tracker;
+    ret = store->get_attr(ctx, obj, RGW_ATTR_ACL, bl, &objv_tracker);
 
     if (ret >= 0) {
       bufferlist::iterator iter = bl.begin();
@@ -213,7 +214,6 @@ static int get_policy_from_attr(CephContext *cct, RGWRados *store, void *ctx, RG
       /* object exists, but policy is broken */
       RGWBucketInfo info;
       RGWUserInfo uinfo;
-      RGWObjVersionTracker objv_tracker;
       int r = store->get_bucket_info(ctx, obj.bucket.name, info, &objv_tracker);
       if (r < 0)
         goto done;
@@ -229,11 +229,12 @@ done:
   return ret;
 }
 
-static int get_obj_attrs(RGWRados *store, struct req_state *s, rgw_obj& obj, map<string, bufferlist>& attrs, uint64_t *obj_size)
+static int get_obj_attrs(RGWRados *store, struct req_state *s, rgw_obj& obj, map<string, bufferlist>& attrs,
+                         uint64_t *obj_size, RGWObjVersionTracker *objv_tracker)
 {
   void *handle;
   int ret = store->prepare_get_obj(s->obj_ctx, obj, NULL, NULL, &attrs, NULL,
-                                      NULL, NULL, NULL, NULL, NULL, obj_size, NULL, &handle, &s->err);
+                                      NULL, NULL, NULL, NULL, NULL, obj_size, objv_tracker, &handle, &s->err);
   store->finish_get_obj(&handle);
   return ret;
 }
@@ -1573,6 +1574,8 @@ void RGWPutMetadata::execute()
   map<string, bufferlist>::iterator iter;
   bufferlist bl, cors_bl;
 
+  bool object_op = (!s->object_str.empty());
+
   rgw_obj obj(s->bucket, s->object_str);
 
   store->set_atomic(s->obj_ctx, obj);
@@ -1583,8 +1586,13 @@ void RGWPutMetadata::execute()
 
   rgw_get_request_metadata(s, attrs);
 
+  RGWObjVersionTracker objv_tracker;
+
+  /* no need to track object versioning, need it for bucket's data only */
+  RGWObjVersionTracker *ptracker = (object_op ? NULL : &objv_tracker);
+
   /* check if obj exists, read orig attrs */
-  ret = get_obj_attrs(store, s, obj, orig_attrs, NULL);
+  ret = get_obj_attrs(store, s, obj, orig_attrs, NULL, ptracker);
   if (ret < 0)
     return;
 
@@ -1606,7 +1614,11 @@ void RGWPutMetadata::execute()
     cors_config.encode(cors_bl);
     attrs[RGW_ATTR_CORS] = cors_bl;
   }
-  ret = store->set_attrs(s->obj_ctx, obj, attrs, &rmattrs);
+  if (object_op) {
+    ret = store->set_attrs(s->obj_ctx, obj, attrs, &rmattrs, ptracker);
+  } else {
+    ret = rgw_bucket_set_attrs(store, obj, attrs, &rmattrs, ptracker);
+  }
 }
 
 int RGWDeleteObj::verify_permission()
@@ -1883,10 +1895,15 @@ void RGWPutACLs::execute()
     *_dout << dendl;
   }
 
+  bool object_op = (!s->object_str.empty());
+
+  RGWObjVersionTracker objv_tracker;
+  RGWObjVersionTracker *ptracker = (object_op ? NULL : &objv_tracker);
+
   new_policy.encode(bl);
   obj.init(s->bucket, s->object_str);
   store->set_atomic(s->obj_ctx, obj);
-  ret = store->set_attr(s->obj_ctx, obj, RGW_ATTR_ACL, bl);
+  ret = store->set_attr(s->obj_ctx, obj, RGW_ATTR_ACL, bl, ptracker);
 }
 
 int RGWGetCORS::verify_permission()
@@ -1953,11 +1970,16 @@ void RGWPutCORS::execute()
     *_dout << dendl;
   }
 
+  bool object_op = (!s->object_str.empty());
+
+  RGWObjVersionTracker objv_tracker;
+  RGWObjVersionTracker *ptracker = (object_op ? NULL : &objv_tracker);
+
   string no_obj;
   cors_config->encode(bl);
   obj.init(s->bucket, no_obj);
   store->set_atomic(s->obj_ctx, obj);
-  ret = store->set_attr(s->obj_ctx, obj, RGW_ATTR_CORS, bl);
+  ret = store->set_attr(s->obj_ctx, obj, RGW_ATTR_CORS, bl, ptracker);
 }
 
 int RGWDeleteCORS::verify_permission()
@@ -1982,8 +2004,13 @@ void RGWDeleteCORS::execute()
   store->set_atomic(s->obj_ctx, obj);
   map<string, bufferlist> orig_attrs, attrs, rmattrs;
   map<string, bufferlist>::iterator iter;
+  bool object_op = (!s->object_str.empty());
+
+  RGWObjVersionTracker objv_tracker;
+  RGWObjVersionTracker *ptracker = (object_op ? NULL : &objv_tracker);
+
   /* check if obj exists, read orig attrs */
-  ret = get_obj_attrs(store, s, obj, orig_attrs, NULL);
+  ret = get_obj_attrs(store, s, obj, orig_attrs, NULL, ptracker);
   if (ret < 0)
     return;
 
@@ -1997,7 +2024,7 @@ void RGWDeleteCORS::execute()
       attrs[name] = iter->second;
     }
   }
-  ret = store->set_attrs(s->obj_ctx, obj, attrs, &rmattrs);
+  ret = store->set_attrs(s->obj_ctx, obj, attrs, &rmattrs, ptracker);
 }
 
 void RGWOptionsCORS::get_response_params(string& hdrs, string& exp_hdrs, unsigned *max_age) {
@@ -2132,7 +2159,7 @@ static int get_multiparts_info(RGWRados *store, struct req_state *s, string& met
   rgw_obj obj;
   obj.init_ns(s->bucket, meta_oid, mp_ns);
 
-  int ret = get_obj_attrs(store, s, obj, attrs, NULL);
+  int ret = get_obj_attrs(store, s, obj, attrs, NULL, NULL);
   if (ret < 0)
     return ret;
 
@@ -2571,7 +2598,7 @@ int RGWHandler::read_cors_config(void)
   string no_object;
   rgw_obj no_obj(s->bucket, no_object);
   if (no_obj.bucket.name.size()) {
-    ret = store->get_attr(s->obj_ctx, no_obj, RGW_ATTR_CORS, bl);
+    ret = store->get_attr(s->obj_ctx, no_obj, RGW_ATTR_CORS, bl, NULL);
     if (ret >= 0) {
       bufferlist::iterator iter = bl.begin();
       s->bucket_cors = new RGWCORSConfiguration();
diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc
index b213ddac9f3..058818bd082 100644
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -2482,7 +2482,8 @@ int RGWRados::get_obj_state(RGWRadosCtx *rctx, rgw_obj& obj, RGWObjState **state
  * dest: bufferlist to store the result in
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::get_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& dest)
+int RGWRados::get_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& dest,
+                       RGWObjVersionTracker *objv_tracker)
 {
   rgw_bucket bucket;
   std::string oid, key;
@@ -2514,8 +2515,17 @@ int RGWRados::get_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& de
       return 0;
     return -ENODATA;
   }
+
+  ObjectReadOperation op;
+
+  if (objv_tracker) {
+    objv_tracker->prepare_op_for_read(&op);
+  }
+
+  int rval;
+  op.getxattr(name, &dest, &rval);
   
-  r = io_ctx.getxattr(actual_obj, name, dest);
+  r = io_ctx.operate(actual_obj, &op, NULL);
   if (r < 0)
     return r;
 
@@ -2619,7 +2629,7 @@ int RGWRados::prepare_atomic_for_write(RGWRadosCtx *rctx, rgw_obj& obj,
  * bl: the contents of the attr
  * Returns: 0 on success, -ERR# otherwise.
  */
-int RGWRados::set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl)
+int RGWRados::set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl, RGWObjVersionTracker *objv_tracker)
 {
   rgw_bucket bucket;
   std::string oid, key;
@@ -2645,6 +2655,10 @@ int RGWRados::set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl
   if (r < 0)
     return r;
 
+  if (objv_tracker) {
+    objv_tracker->prepare_op_for_write(&op);
+  }
+
   op.setxattr(name, bl);
 
   io_ctx.locator_set_key(key);
@@ -2661,7 +2675,8 @@ int RGWRados::set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl
 
 int RGWRados::set_attrs(void *ctx, rgw_obj& obj,
                         map<string, bufferlist>& attrs,
-                        map<string, bufferlist>* rmattrs)
+                        map<string, bufferlist>* rmattrs,
+                        RGWObjVersionTracker *objv_tracker)
 {
   rgw_bucket bucket;
   std::string oid, key;
@@ -2689,6 +2704,10 @@ int RGWRados::set_attrs(void *ctx, rgw_obj& obj,
   if (r < 0)
     return r;
 
+  if (objv_tracker) {
+    objv_tracker->prepare_op_for_write(&op);
+  }
+
   map<string, bufferlist>::iterator iter;
   if (rmattrs) {
     for (iter = rmattrs->begin(); iter != rmattrs->end(); ++iter) {
@@ -2828,7 +2847,7 @@ int RGWRados::prepare_get_obj(void *ctx, rgw_obj& obj,
     }
   }
   if (if_match || if_nomatch) {
-    r = get_attr(rctx, obj, RGW_ATTR_ETAG, etag);
+    r = get_attr(rctx, obj, RGW_ATTR_ETAG, etag, NULL);
     if (r < 0)
       goto done_err;
 
diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h
index 99a2a4c9e25..444fdecf1a2 100644
--- a/src/rgw/rgw_rados.h
+++ b/src/rgw/rgw_rados.h
@@ -822,7 +822,8 @@ public:
    * dest: bufferlist to store the result in
    * Returns: 0 on success, -ERR# otherwise.
    */
-  virtual int get_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& dest);
+  virtual int get_attr(void *ctx, rgw_obj& obj, const char *name,
+                       bufferlist& dest, RGWObjVersionTracker *objv_tracker);
 
   /**
    * Set an attr on an object.
@@ -832,11 +833,13 @@ public:
    * bl: the contents of the attr
    * Returns: 0 on success, -ERR# otherwise.
    */
-  virtual int set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl);
+  virtual int set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl,
+                       RGWObjVersionTracker *objv_tracker);
 
   virtual int set_attrs(void *ctx, rgw_obj& obj,
                         map<string, bufferlist>& attrs,
-                        map<string, bufferlist>* rmattrs);
+                        map<string, bufferlist>* rmattrs,
+                        RGWObjVersionTracker *objv_tracker);
 
 /**
  * Get data about an object out of RADOS and into memory.
diff --git a/src/rgw/rgw_user.h b/src/rgw/rgw_user.h
index 72eb42b0ad1..aca835bbb0f 100644
--- a/src/rgw/rgw_user.h
+++ b/src/rgw/rgw_user.h
@@ -80,22 +80,6 @@ extern int rgw_delete_user(RGWRados *store, RGWUserInfo& user);
  * Store a list of the user's buckets, with associated functinos.
  */
 
-/**
- * Get all the buckets owned by a user and fill up an RGWUserBuckets with them.
- * Returns: 0 on success, -ERR# on failure.
- */
-//extern int rgw_read_user_buckets(RGWRados *store, string user_id, RGWUserBuckets& buckets, bool need_stats);
-
-/**
- * Store the set of buckets associated with a user.
- * This completely overwrites any previously-stored list, so be careful!
- * Returns 0 on success, -ERR# otherwise.
- */
-//extern int rgw_write_buckets_attr(RGWRados *store, string user_id, RGWUserBuckets& buckets);
-
-//extern int rgw_add_bucket(RGWRados *store, string user_id, rgw_bucket& bucket);
-//extern int rgw_remove_user_bucket_info(RGWRados *store, string user_id, rgw_bucket& bucket);
-
 /*
  * remove the different indexes
  */