import quincy beta 17.1.0

[ceph.git] / ceph / src / rgw / rgw_cr_rados.h

diff --git a/ceph/src/rgw/rgw_cr_rados.h b/ceph/src/rgw/rgw_cr_rados.h
index 87fa65b5514a17ff4824435ffaa6a53e16879113..23ee4a6a9d08f279b5ce2a22210caff252cad5ec 100644 (file)
--- a/ceph/src/rgw/rgw_cr_rados.h
+++ b/ceph/src/rgw/rgw_cr_rados.h
@@ -69,7 +69,7 @@ public:
 
 
 class RGWAsyncRadosProcessor {
-  deque<RGWAsyncRadosRequest *> m_req_queue;
+  std::deque<RGWAsyncRadosRequest *> m_req_queue;
   std::atomic<bool> going_down = { false };
 protected:
   CephContext *cct;
@@ -119,13 +119,13 @@ public:
 template <class P>
 class RGWSimpleWriteOnlyAsyncCR : public RGWSimpleCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
 
   P params;
   const DoutPrefixProvider *dpp;
 
   class Request : public RGWAsyncRadosRequest {
-    rgw::sal::RGWRadosStore *store;
+    rgw::sal::RadosStore* store;
     P params;
     const DoutPrefixProvider *dpp;
   protected:
@@ -133,7 +133,7 @@ class RGWSimpleWriteOnlyAsyncCR : public RGWSimpleCoroutine {
   public:
     Request(RGWCoroutine *caller,
             RGWAioCompletionNotifier *cn,
-            rgw::sal::RGWRadosStore *store,
+            rgw::sal::RadosStore* store,
             const P& _params,
             const DoutPrefixProvider *dpp) : RGWAsyncRadosRequest(caller, cn),
                                 store(store),
@@ -143,7 +143,7 @@ class RGWSimpleWriteOnlyAsyncCR : public RGWSimpleCoroutine {
 
  public:
   RGWSimpleWriteOnlyAsyncCR(RGWAsyncRadosProcessor *_async_rados,
-                           rgw::sal::RGWRadosStore *_store,
+                           rgw::sal::RadosStore* _store,
                            const P& _params,
                             const DoutPrefixProvider *_dpp) : RGWSimpleCoroutine(_store->ctx()),
                                                 async_rados(_async_rados),
@@ -180,14 +180,14 @@ class RGWSimpleWriteOnlyAsyncCR : public RGWSimpleCoroutine {
 template <class P, class R>
 class RGWSimpleAsyncCR : public RGWSimpleCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
 
   P params;
   std::shared_ptr<R> result;
   const DoutPrefixProvider *dpp;
 
   class Request : public RGWAsyncRadosRequest {
-    rgw::sal::RGWRadosStore *store;
+    rgw::sal::RadosStore* store;
     P params;
     std::shared_ptr<R> result;
     const DoutPrefixProvider *dpp;
@@ -197,7 +197,7 @@ class RGWSimpleAsyncCR : public RGWSimpleCoroutine {
     Request(const DoutPrefixProvider *dpp,
             RGWCoroutine *caller,
             RGWAioCompletionNotifier *cn,
-            rgw::sal::RGWRadosStore *_store,
+            rgw::sal::RadosStore* _store,
             const P& _params,
             std::shared_ptr<R>& _result,
             const DoutPrefixProvider *_dpp) : RGWAsyncRadosRequest(caller, cn),
@@ -209,7 +209,7 @@ class RGWSimpleAsyncCR : public RGWSimpleCoroutine {
 
  public:
   RGWSimpleAsyncCR(RGWAsyncRadosProcessor *_async_rados,
-                   rgw::sal::RGWRadosStore *_store,
+                   rgw::sal::RadosStore* _store,
                    const P& _params,
                    std::shared_ptr<R>& _result,
                    const DoutPrefixProvider *_dpp) : RGWSimpleCoroutine(_store->ctx()),
@@ -248,7 +248,7 @@ class RGWSimpleAsyncCR : public RGWSimpleCoroutine {
 
 class RGWGenericAsyncCR : public RGWSimpleCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
 
 
 public:
@@ -330,7 +330,7 @@ public:
                        bool want_attrs, bool raw_attrs);
 
   bufferlist bl;
-  map<string, bufferlist> attrs;
+  std::map<std::string, bufferlist> attrs;
   RGWObjVersionTracker objv_tracker;
 };
 
@@ -356,45 +356,45 @@ class RGWAsyncPutSystemObjAttrs : public RGWAsyncRadosRequest {
   const DoutPrefixProvider *dpp;
   RGWSI_SysObj *svc;
   rgw_raw_obj obj;
-  map<string, bufferlist> attrs;
+  std::map<std::string, bufferlist> attrs;
 
 protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
   RGWAsyncPutSystemObjAttrs(const DoutPrefixProvider *dpp, RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWSI_SysObj *_svc,
                        RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
-                       map<string, bufferlist> _attrs);
+                       std::map<std::string, bufferlist> _attrs);
 
   RGWObjVersionTracker objv_tracker;
 };
 
 class RGWAsyncLockSystemObj : public RGWAsyncRadosRequest {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_raw_obj obj;
-  string lock_name;
-  string cookie;
+  std::string lock_name;
+  std::string cookie;
   uint32_t duration_secs;
 
 protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
-  RGWAsyncLockSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RGWRadosStore *_store,
+  RGWAsyncLockSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RadosStore* _store,
                         RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
-                       const string& _name, const string& _cookie, uint32_t _duration_secs);
+                       const std::string& _name, const std::string& _cookie, uint32_t _duration_secs);
 };
 
 class RGWAsyncUnlockSystemObj : public RGWAsyncRadosRequest {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_raw_obj obj;
-  string lock_name;
-  string cookie;
+  std::string lock_name;
+  std::string cookie;
 
 protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
-  RGWAsyncUnlockSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RGWRadosStore *_store,
+  RGWAsyncUnlockSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RadosStore* _store,
                         RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
-                       const string& _name, const string& _cookie);
+                       const std::string& _name, const std::string& _cookie);
 };
 
 template <class T>
@@ -483,14 +483,14 @@ class RGWSimpleRadosReadAttrsCR : public RGWSimpleCoroutine {
   RGWSI_SysObj *svc;
 
   rgw_raw_obj obj;
-  map<string, bufferlist> *pattrs;
+  std::map<std::string, bufferlist> *pattrs;
   bool raw_attrs;
   RGWObjVersionTracker* objv_tracker;
   RGWAsyncGetSystemObj *req = nullptr;
 
 public:
   RGWSimpleRadosReadAttrsCR(const DoutPrefixProvider *_dpp, RGWAsyncRadosProcessor *_async_rados, RGWSI_SysObj *_svc,
-                            const rgw_raw_obj& _obj, map<string, bufferlist> *_pattrs,
+                            const rgw_raw_obj& _obj, std::map<std::string, bufferlist> *_pattrs,
                             bool _raw_attrs, RGWObjVersionTracker* objv_tracker = nullptr)
     : RGWSimpleCoroutine(_svc->ctx()),
       dpp(_dpp),
@@ -568,14 +568,14 @@ class RGWSimpleRadosWriteAttrsCR : public RGWSimpleCoroutine {
   RGWObjVersionTracker *objv_tracker;
 
   rgw_raw_obj obj;
-  map<string, bufferlist> attrs;
+  std::map<std::string, bufferlist> attrs;
   RGWAsyncPutSystemObjAttrs *req = nullptr;
 
 public:
   RGWSimpleRadosWriteAttrsCR(const DoutPrefixProvider *_dpp, 
                              RGWAsyncRadosProcessor *_async_rados,
                              RGWSI_SysObj *_svc, const rgw_raw_obj& _obj,
-                             map<string, bufferlist> _attrs,
+                             std::map<std::string, bufferlist> _attrs,
                              RGWObjVersionTracker *objv_tracker = nullptr)
     : RGWSimpleCoroutine(_svc->ctx()), dpp(_dpp), async_rados(_async_rados),
       svc(_svc), objv_tracker(objv_tracker), obj(_obj),
@@ -608,8 +608,8 @@ public:
 };
 
 class RGWRadosSetOmapKeysCR : public RGWSimpleCoroutine {
-  rgw::sal::RGWRadosStore *store;
-  map<string, bufferlist> entries;
+  rgw::sal::RadosStore* store;
+  std::map<std::string, bufferlist> entries;
 
   rgw_rados_ref ref;
 
@@ -618,9 +618,9 @@ class RGWRadosSetOmapKeysCR : public RGWSimpleCoroutine {
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
 
 public:
-  RGWRadosSetOmapKeysCR(rgw::sal::RGWRadosStore *_store,
+  RGWRadosSetOmapKeysCR(rgw::sal::RadosStore* _store,
                      const rgw_raw_obj& _obj,
-                     map<string, bufferlist>& _entries);
+                     std::map<std::string, bufferlist>& _entries);
 
   int send_request(const DoutPrefixProvider *dpp) override;
   int request_complete() override;
@@ -635,17 +635,17 @@ class RGWRadosGetOmapKeysCR : public RGWSimpleCoroutine {
   };
   using ResultPtr = std::shared_ptr<Result>;
 
-  RGWRadosGetOmapKeysCR(rgw::sal::RGWRadosStore *_store, const rgw_raw_obj& _obj,
-                        const string& _marker, int _max_entries,
+  RGWRadosGetOmapKeysCR(rgw::sal::RadosStore* _store, const rgw_raw_obj& _obj,
+                        const std::string& _marker, int _max_entries,
                         ResultPtr result);
 
   int send_request(const DoutPrefixProvider *dpp) override;
   int request_complete() override;
 
  private:
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_raw_obj obj;
-  string marker;
+  std::string marker;
   int max_entries;
   ResultPtr result;
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
@@ -660,37 +660,37 @@ class RGWRadosGetOmapValsCR : public RGWSimpleCoroutine {
   };
   using ResultPtr = std::shared_ptr<Result>;
 
-  RGWRadosGetOmapValsCR(rgw::sal::RGWRadosStore *_store, const rgw_raw_obj& _obj,
-                        const string& _marker, int _max_entries,
+  RGWRadosGetOmapValsCR(rgw::sal::RadosStore* _store, const rgw_raw_obj& _obj,
+                        const std::string& _marker, int _max_entries,
                         ResultPtr result);
 
   int send_request(const DoutPrefixProvider *dpp) override;
   int request_complete() override;
 
  private:
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_raw_obj obj;
-  string marker;
+  std::string marker;
   int max_entries;
   ResultPtr result;
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
 };
 
 class RGWRadosRemoveOmapKeysCR : public RGWSimpleCoroutine {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
 
   rgw_rados_ref ref;
 
-  set<string> keys;
+  std::set<std::string> keys;
 
   rgw_raw_obj obj;
 
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
 
 public:
-  RGWRadosRemoveOmapKeysCR(rgw::sal::RGWRadosStore *_store,
+  RGWRadosRemoveOmapKeysCR(rgw::sal::RadosStore* _store,
                      const rgw_raw_obj& _obj,
-                     const set<string>& _keys);
+                     const std::set<std::string>& _keys);
 
   int send_request(const DoutPrefixProvider *dpp) override;
 
@@ -698,14 +698,14 @@ public:
 };
 
 class RGWRadosRemoveCR : public RGWSimpleCoroutine {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   librados::IoCtx ioctx;
   const rgw_raw_obj obj;
   RGWObjVersionTracker* objv_tracker;
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
 
 public:
-  RGWRadosRemoveCR(rgw::sal::RGWRadosStore *store, const rgw_raw_obj& obj,
+  RGWRadosRemoveCR(rgw::sal::RadosStore* store, const rgw_raw_obj& obj,
                    RGWObjVersionTracker* objv_tracker = nullptr);
 
   int send_request(const DoutPrefixProvider *dpp) override;
@@ -714,9 +714,9 @@ public:
 
 class RGWSimpleRadosLockCR : public RGWSimpleCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
-  string lock_name;
-  string cookie;
+  rgw::sal::RadosStore* store;
+  std::string lock_name;
+  std::string cookie;
   uint32_t duration;
 
   rgw_raw_obj obj;
@@ -724,10 +724,10 @@ class RGWSimpleRadosLockCR : public RGWSimpleCoroutine {
   RGWAsyncLockSystemObj *req;
 
 public:
-  RGWSimpleRadosLockCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWSimpleRadosLockCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                      const rgw_raw_obj& _obj,
-                      const string& _lock_name,
-                     const string& _cookie,
+                      const std::string& _lock_name,
+                     const std::string& _cookie,
                      uint32_t _duration);
   ~RGWSimpleRadosLockCR() override {
     request_cleanup();
@@ -747,19 +747,19 @@ public:
 
 class RGWSimpleRadosUnlockCR : public RGWSimpleCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
-  string lock_name;
-  string cookie;
+  rgw::sal::RadosStore* store;
+  std::string lock_name;
+  std::string cookie;
 
   rgw_raw_obj obj;
 
   RGWAsyncUnlockSystemObj *req;
 
 public:
-  RGWSimpleRadosUnlockCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWSimpleRadosUnlockCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                      const rgw_raw_obj& _obj, 
-                      const string& _lock_name,
-                     const string& _cookie);
+                      const std::string& _lock_name,
+                     const std::string& _cookie);
   ~RGWSimpleRadosUnlockCR() override {
     request_cleanup();
   }
@@ -771,28 +771,28 @@ public:
 
 #define OMAP_APPEND_MAX_ENTRIES_DEFAULT 100
 
-class RGWOmapAppend : public RGWConsumerCR<string> {
+class RGWOmapAppend : public RGWConsumerCR<std::string> {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
 
   rgw_raw_obj obj;
 
   bool going_down;
 
   int num_pending_entries;
-  list<string> pending_entries;
+  std::list<std::string> pending_entries;
 
-  map<string, bufferlist> entries;
+  std::map<std::string, bufferlist> entries;
 
   uint64_t window_size;
   uint64_t total_entries;
 public:
-  RGWOmapAppend(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWOmapAppend(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                 const rgw_raw_obj& _obj,
                 uint64_t _window_size = OMAP_APPEND_MAX_ENTRIES_DEFAULT);
   int operate(const DoutPrefixProvider *dpp) override;
   void flush_pending();
-  bool append(const string& s);
+  bool append(const std::string& s);
   bool finish();
 
   uint64_t get_total_entries() {
@@ -806,14 +806,14 @@ public:
 
 class RGWShardedOmapCRManager {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   RGWCoroutine *op;
 
   int num_shards;
 
-  vector<RGWOmapAppend *> shards;
+  std::vector<RGWOmapAppend *> shards;
 public:
-  RGWShardedOmapCRManager(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store, RGWCoroutine *_op, int _num_shards, const rgw_pool& pool, const string& oid_prefix)
+  RGWShardedOmapCRManager(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store, RGWCoroutine *_op, int _num_shards, const rgw_pool& pool, const std::string& oid_prefix)
                       : async_rados(_async_rados),
                        store(_store), op(_op), num_shards(_num_shards) {
     shards.reserve(num_shards);
@@ -833,13 +833,13 @@ public:
     }
   }
 
-  bool append(const string& entry, int shard_id) {
+  bool append(const std::string& entry, int shard_id) {
     return shards[shard_id]->append(entry);
   }
   bool finish() {
     bool success = true;
-    for (vector<RGWOmapAppend *>::iterator iter = shards.begin(); iter != shards.end(); ++iter) {
-      success &= ((*iter)->finish() && (!(*iter)->is_error()));
+    for (auto& append_op : shards) {
+      success &= (append_op->finish() && (!append_op->is_error()));
     }
     return success;
   }
@@ -850,7 +850,7 @@ public:
 };
 
 class RGWAsyncGetBucketInstanceInfo : public RGWAsyncRadosRequest {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_bucket bucket;
   const DoutPrefixProvider *dpp;
 
@@ -858,29 +858,29 @@ protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
   RGWAsyncGetBucketInstanceInfo(RGWCoroutine *caller, RGWAioCompletionNotifier *cn,
-                                rgw::sal::RGWRadosStore *_store, const rgw_bucket& bucket,
+                                rgw::sal::RadosStore* _store, const rgw_bucket& bucket,
                                 const DoutPrefixProvider *dpp)
     : RGWAsyncRadosRequest(caller, cn), store(_store), bucket(bucket), dpp(dpp) {}
 
   RGWBucketInfo bucket_info;
-  map<string, bufferlist> attrs;
+  std::map<std::string, bufferlist> attrs;
 };
 
 class RGWGetBucketInstanceInfoCR : public RGWSimpleCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_bucket bucket;
   RGWBucketInfo *bucket_info;
-  map<string, bufferlist> *pattrs;
+  std::map<std::string, bufferlist> *pattrs;
   const DoutPrefixProvider *dpp;
 
   RGWAsyncGetBucketInstanceInfo *req{nullptr};
   
 public:
   // rgw_bucket constructor
-  RGWGetBucketInstanceInfoCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWGetBucketInstanceInfoCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                              const rgw_bucket& _bucket, RGWBucketInfo *_bucket_info,
-                             map<string, bufferlist> *_pattrs, const DoutPrefixProvider *dpp)
+                             std::map<std::string, bufferlist> *_pattrs, const DoutPrefixProvider *dpp)
     : RGWSimpleCoroutine(_store->ctx()), async_rados(_async_rados), store(_store),
       bucket(_bucket), bucket_info(_bucket_info), pattrs(_pattrs), dpp(dpp) {}
   ~RGWGetBucketInstanceInfoCR() override {
@@ -910,13 +910,15 @@ public:
 };
 
 class RGWRadosBILogTrimCR : public RGWSimpleCoroutine {
+  const RGWBucketInfo& bucket_info;
+  int shard_id;
   RGWRados::BucketShard bs;
   std::string start_marker;
   std::string end_marker;
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
  public:
   RGWRadosBILogTrimCR(const DoutPrefixProvider *dpp,
-                      rgw::sal::RGWRadosStore *store, const RGWBucketInfo& bucket_info,
+                      rgw::sal::RadosStore* store, const RGWBucketInfo& bucket_info,
                       int shard_id, const std::string& start_marker,
                       const std::string& end_marker);
 
@@ -925,7 +927,7 @@ class RGWRadosBILogTrimCR : public RGWSimpleCoroutine {
 };
 
 class RGWAsyncFetchRemoteObj : public RGWAsyncRadosRequest {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_zone_id source_zone;
 
   std::optional<rgw_user> user_id;
@@ -949,7 +951,7 @@ class RGWAsyncFetchRemoteObj : public RGWAsyncRadosRequest {
 protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
-  RGWAsyncFetchRemoteObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RGWRadosStore *_store,
+  RGWAsyncFetchRemoteObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RadosStore* _store,
                          const rgw_zone_id& _source_zone,
                          std::optional<rgw_user>& _user_id,
                          const rgw_bucket& _src_bucket,
@@ -985,7 +987,7 @@ public:
 class RGWFetchRemoteObjCR : public RGWSimpleCoroutine {
   CephContext *cct;
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_zone_id source_zone;
 
   std::optional<rgw_user> user_id;
@@ -1010,7 +1012,7 @@ class RGWFetchRemoteObjCR : public RGWSimpleCoroutine {
   const DoutPrefixProvider *dpp;
 
 public:
-  RGWFetchRemoteObjCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWFetchRemoteObjCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                       const rgw_zone_id& _source_zone,
                       std::optional<rgw_user> _user_id,
                       const rgw_bucket& _src_bucket,
@@ -1065,7 +1067,7 @@ public:
 };
 
 class RGWAsyncStatRemoteObj : public RGWAsyncRadosRequest {
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_zone_id source_zone;
 
   rgw_bucket src_bucket;
@@ -1073,22 +1075,22 @@ class RGWAsyncStatRemoteObj : public RGWAsyncRadosRequest {
 
   ceph::real_time *pmtime;
   uint64_t *psize;
-  string *petag;
-  map<string, bufferlist> *pattrs;
-  map<string, string> *pheaders;
+  std::string *petag;
+  std::map<std::string, bufferlist> *pattrs;
+  std::map<std::string, std::string> *pheaders;
 
 protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
-  RGWAsyncStatRemoteObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RGWRadosStore *_store,
+  RGWAsyncStatRemoteObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RadosStore* _store,
                          const rgw_zone_id& _source_zone,
                          rgw_bucket& _src_bucket,
                          const rgw_obj_key& _key,
                          ceph::real_time *_pmtime,
                          uint64_t *_psize,
-                         string *_petag,
-                         map<string, bufferlist> *_pattrs,
-                         map<string, string> *_pheaders) : RGWAsyncRadosRequest(caller, cn), store(_store),
+                         std::string *_petag,
+                         std::map<std::string, bufferlist> *_pattrs,
+                         std::map<std::string, std::string> *_pheaders) : RGWAsyncRadosRequest(caller, cn), store(_store),
                                                       source_zone(_source_zone),
                                                       src_bucket(_src_bucket),
                                                       key(_key),
@@ -1102,7 +1104,7 @@ public:
 class RGWStatRemoteObjCR : public RGWSimpleCoroutine {
   CephContext *cct;
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_zone_id source_zone;
 
   rgw_bucket src_bucket;
@@ -1110,22 +1112,22 @@ class RGWStatRemoteObjCR : public RGWSimpleCoroutine {
 
   ceph::real_time *pmtime;
   uint64_t *psize;
-  string *petag;
-  map<string, bufferlist> *pattrs;
-  map<string, string> *pheaders;
+  std::string *petag;
+  std::map<std::string, bufferlist> *pattrs;
+  std::map<std::string, std::string> *pheaders;
 
   RGWAsyncStatRemoteObj *req;
 
 public:
-  RGWStatRemoteObjCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWStatRemoteObjCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                       const rgw_zone_id& _source_zone,
                       rgw_bucket& _src_bucket,
                       const rgw_obj_key& _key,
                       ceph::real_time *_pmtime,
                       uint64_t *_psize,
-                      string *_petag,
-                      map<string, bufferlist> *_pattrs,
-                      map<string, string> *_pheaders) : RGWSimpleCoroutine(_store->ctx()), cct(_store->ctx()),
+                      std::string *_petag,
+                      std::map<std::string, bufferlist> *_pattrs,
+                      std::map<std::string, std::string> *_pheaders) : RGWSimpleCoroutine(_store->ctx()), cct(_store->ctx()),
                                        async_rados(_async_rados), store(_store),
                                        source_zone(_source_zone),
                                        src_bucket(_src_bucket),
@@ -1163,17 +1165,17 @@ public:
 
 class RGWAsyncRemoveObj : public RGWAsyncRadosRequest {
   const DoutPrefixProvider *dpp;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_zone_id source_zone;
 
   RGWBucketInfo bucket_info;
 
   rgw_obj_key key;
-  string owner;
-  string owner_display_name;
+  std::string owner;
+  std::string owner_display_name;
   bool versioned;
   uint64_t versioned_epoch;
-  string marker_version_id;
+  std::string marker_version_id;
 
   bool del_if_older;
   ceph::real_time timestamp;
@@ -1183,12 +1185,12 @@ protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
   RGWAsyncRemoveObj(const DoutPrefixProvider *_dpp, RGWCoroutine *caller, RGWAioCompletionNotifier *cn, 
-                         rgw::sal::RGWRadosStore *_store,
+                         rgw::sal::RadosStore* _store,
                          const rgw_zone_id& _source_zone,
                          RGWBucketInfo& _bucket_info,
                          const rgw_obj_key& _key,
-                         const string& _owner,
-                         const string& _owner_display_name,
+                         const std::string& _owner,
+                         const std::string& _owner_display_name,
                          bool _versioned,
                          uint64_t _versioned_epoch,
                          bool _delete_marker,
@@ -1218,7 +1220,7 @@ class RGWRemoveObjCR : public RGWSimpleCoroutine {
   const DoutPrefixProvider *dpp;
   CephContext *cct;
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   rgw_zone_id source_zone;
 
   RGWBucketInfo bucket_info;
@@ -1227,8 +1229,8 @@ class RGWRemoveObjCR : public RGWSimpleCoroutine {
   bool versioned;
   uint64_t versioned_epoch;
   bool delete_marker;
-  string owner;
-  string owner_display_name;
+  std::string owner;
+  std::string owner_display_name;
 
   bool del_if_older;
   real_time timestamp;
@@ -1238,14 +1240,14 @@ class RGWRemoveObjCR : public RGWSimpleCoroutine {
   rgw_zone_set *zones_trace;
 
 public:
-  RGWRemoveObjCR(const DoutPrefixProvider *_dpp, RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWRemoveObjCR(const DoutPrefixProvider *_dpp, RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                       const rgw_zone_id& _source_zone,
                       RGWBucketInfo& _bucket_info,
                       const rgw_obj_key& _key,
                       bool _versioned,
                       uint64_t _versioned_epoch,
-                      string *_owner,
-                      string *_owner_display_name,
+                      std::string *_owner,
+                      std::string *_owner_display_name,
                       bool _delete_marker,
                       real_time *_timestamp,
                       rgw_zone_set *_zones_trace) : RGWSimpleCoroutine(_store->ctx()), dpp(_dpp), cct(_store->ctx()),
@@ -1295,12 +1297,12 @@ public:
 
 class RGWContinuousLeaseCR : public RGWCoroutine {
   RGWAsyncRadosProcessor *async_rados;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
 
   const rgw_raw_obj obj;
 
-  const string lock_name;
-  const string cookie;
+  const std::string lock_name;
+  const std::string cookie;
 
   int interval;
   bool going_down{ false };
@@ -1311,15 +1313,17 @@ class RGWContinuousLeaseCR : public RGWCoroutine {
   bool aborted{false};
 
 public:
-  RGWContinuousLeaseCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RGWRadosStore *_store,
+  RGWContinuousLeaseCR(RGWAsyncRadosProcessor *_async_rados, rgw::sal::RadosStore* _store,
                        const rgw_raw_obj& _obj,
-                       const string& _lock_name, int _interval, RGWCoroutine *_caller)
+                       const std::string& _lock_name, int _interval, RGWCoroutine *_caller)
     : RGWCoroutine(_store->ctx()), async_rados(_async_rados), store(_store),
     obj(_obj), lock_name(_lock_name),
     cookie(RGWSimpleRadosLockCR::gen_random_cookie(cct)),
     interval(_interval), caller(_caller)
   {}
 
+  virtual ~RGWContinuousLeaseCR() override;
+
   int operate(const DoutPrefixProvider *dpp) override;
 
   bool is_locked() const {
@@ -1342,15 +1346,15 @@ public:
 
 class RGWRadosTimelogAddCR : public RGWSimpleCoroutine {
   const DoutPrefixProvider *dpp;
-  rgw::sal::RGWRadosStore *store;
-  list<cls_log_entry> entries;
+  rgw::sal::RadosStore* store;
+  std::list<cls_log_entry> entries;
 
-  string oid;
+  std::string oid;
 
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
 
 public:
-  RGWRadosTimelogAddCR(const DoutPrefixProvider *dpp, rgw::sal::RGWRadosStore *_store, const string& _oid,
+  RGWRadosTimelogAddCR(const DoutPrefixProvider *dpp, rgw::sal::RadosStore* _store, const std::string& _oid,
                        const cls_log_entry& entry);
 
   int send_request(const DoutPrefixProvider *dpp) override;
@@ -1359,7 +1363,7 @@ public:
 
 class RGWRadosTimelogTrimCR : public RGWSimpleCoroutine {
   const DoutPrefixProvider *dpp;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
  protected:
   std::string oid;
@@ -1370,7 +1374,7 @@ class RGWRadosTimelogTrimCR : public RGWSimpleCoroutine {
 
  public:
   RGWRadosTimelogTrimCR(const DoutPrefixProvider *dpp, 
-                        rgw::sal::RGWRadosStore *store, const std::string& oid,
+                        rgw::sal::RadosStore* store, const std::string& oid,
                         const real_time& start_time, const real_time& end_time,
                         const std::string& from_marker,
                         const std::string& to_marker);
@@ -1386,15 +1390,15 @@ class RGWSyncLogTrimCR : public RGWRadosTimelogTrimCR {
  public:
   static constexpr const char* max_marker = "99999999";
 
-  RGWSyncLogTrimCR(const DoutPrefixProvider *dpp, 
-                   rgw::sal::RGWRadosStore *store, const std::string& oid,
+  RGWSyncLogTrimCR(const DoutPrefixProvider *dpp,
+                   rgw::sal::RadosStore* store, const std::string& oid,
                    const std::string& to_marker, std::string *last_trim_marker);
   int request_complete() override;
 };
 
 class RGWAsyncStatObj : public RGWAsyncRadosRequest {
   const DoutPrefixProvider *dpp;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   RGWBucketInfo bucket_info;
   rgw_obj obj;
   uint64_t *psize;
@@ -1404,7 +1408,7 @@ class RGWAsyncStatObj : public RGWAsyncRadosRequest {
 protected:
   int _send_request(const DoutPrefixProvider *dpp) override;
 public:
-  RGWAsyncStatObj(const DoutPrefixProvider *dpp, RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RGWRadosStore *store,
+  RGWAsyncStatObj(const DoutPrefixProvider *dpp, RGWCoroutine *caller, RGWAioCompletionNotifier *cn, rgw::sal::RadosStore* store,
                   const RGWBucketInfo& _bucket_info, const rgw_obj& obj, uint64_t *psize = nullptr,
                   real_time *pmtime = nullptr, uint64_t *pepoch = nullptr,
                   RGWObjVersionTracker *objv_tracker = nullptr)
@@ -1414,7 +1418,7 @@ public:
 
 class RGWStatObjCR : public RGWSimpleCoroutine {
   const DoutPrefixProvider *dpp;
-  rgw::sal::RGWRadosStore *store;
+  rgw::sal::RadosStore* store;
   RGWAsyncRadosProcessor *async_rados;
   RGWBucketInfo bucket_info;
   rgw_obj obj;
@@ -1424,7 +1428,7 @@ class RGWStatObjCR : public RGWSimpleCoroutine {
   RGWObjVersionTracker *objv_tracker;
   RGWAsyncStatObj *req = nullptr;
  public:
-  RGWStatObjCR(const DoutPrefixProvider *dpp, RGWAsyncRadosProcessor *async_rados, rgw::sal::RGWRadosStore *store,
+  RGWStatObjCR(const DoutPrefixProvider *dpp, RGWAsyncRadosProcessor *async_rados, rgw::sal::RadosStore* store,
          const RGWBucketInfo& _bucket_info, const rgw_obj& obj, uint64_t *psize = nullptr,
          real_time* pmtime = nullptr, uint64_t *pepoch = nullptr,
          RGWObjVersionTracker *objv_tracker = nullptr);
@@ -1439,7 +1443,7 @@ class RGWStatObjCR : public RGWSimpleCoroutine {
 
 /// coroutine wrapper for IoCtx::aio_notify()
 class RGWRadosNotifyCR : public RGWSimpleCoroutine {
-  rgw::sal::RGWRadosStore *const store;
+  rgw::sal::RadosStore* const store;
   const rgw_raw_obj obj;
   bufferlist request;
   const uint64_t timeout_ms;
@@ -1448,7 +1452,7 @@ class RGWRadosNotifyCR : public RGWSimpleCoroutine {
   boost::intrusive_ptr<RGWAioCompletionNotifier> cn;
 
 public:
-  RGWRadosNotifyCR(rgw::sal::RGWRadosStore *store, const rgw_raw_obj& obj,
+  RGWRadosNotifyCR(rgw::sal::RadosStore* store, const rgw_raw_obj& obj,
                    bufferlist& request, uint64_t timeout_ms,
                    bufferlist *response);