rgw: pass optional_yield to all index ops

prepare for coroutine support by making the yield context available to
all index ops

Signed-off-by: Casey Bodley <cbodley@redhat.com>

diff --git a/src/rgw/driver/posix/rgw_sal_posix.cc b/src/rgw/driver/posix/rgw_sal_posix.cc
index 69e9d36321d804ff6b7577ae925eb38fd2940a5d..df625c8c07841148b9a604aaa46bd21e9776804e 100644 (file)
--- a/src/rgw/driver/posix/rgw_sal_posix.cc
+++ b/src/rgw/driver/posix/rgw_sal_posix.cc
@@ -2468,7 +2468,7 @@ int POSIXBucket::set_acl(const DoutPrefixProvider* dpp,
   return write_attrs(dpp, y);
 }
 
-int POSIXBucket::read_stats(const DoutPrefixProvider *dpp,
+int POSIXBucket::read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                            const bucket_index_layout_generation& idx_layout,
                            int shard_id, std::string* bucket_ver, std::string* master_ver,
                            std::map<RGWObjCategory, RGWStorageStats>& stats,
@@ -2477,14 +2477,14 @@ int POSIXBucket::read_stats(const DoutPrefixProvider *dpp,
   auto& main = stats[RGWObjCategory::Main];
 
   // TODO: bucket stats shouldn't have to list all objects
-  return dir->for_each(dpp, [this, dpp, &main] (const char* name) {
+  return dir->for_each(dpp, [this, dpp, y, &main] (const char* name) {
     if (name[0] == '.') {
       /* Skip dotfiles */
       return 0;
     }
 
     std::unique_ptr<FSEnt> dent;
-    int ret = dir->get_ent(dpp, null_yield, name, std::string(), dent);
+    int ret = dir->get_ent(dpp, y, name, std::string(), dent);
     if (ret < 0) {
       ret = errno;
       ldpp_dout(dpp, 0) << "ERROR: could not get ent for object " << name << ": "
@@ -2617,17 +2617,19 @@ int POSIXBucket::remove_objs_from_index(const DoutPrefixProvider *dpp, std::list
   return 0;
 }
 
-int POSIXBucket::check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
+int POSIXBucket::check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                             std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                             std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
 {
   return 0;
 }
 
-int POSIXBucket::rebuild_index(const DoutPrefixProvider *dpp)
+int POSIXBucket::rebuild_index(const DoutPrefixProvider *dpp, optional_yield y)
 {
   return 0;
 }
 
-int POSIXBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
+int POSIXBucket::set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout)
 {
   return 0;
 }
@@ -2907,6 +2909,12 @@ int POSIXObject::list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
   return -EOPNOTSUPP;
 }
 
+bool POSIXObject::is_sync_completed(const DoutPrefixProvider* dpp, optional_yield y,
+                                    const ceph::real_time& obj_mtime)
+{
+  return false;
+}
+
 int POSIXObject::load_obj_state(const DoutPrefixProvider* dpp, optional_yield y, bool follow_olh)
 {
   int ret = stat(dpp);

diff --git a/src/rgw/driver/posix/rgw_sal_posix.h b/src/rgw/driver/posix/rgw_sal_posix.h
index 45968193566a1932d8f3a043684dd857f7ba3433..3af36d02a4c12b69c0fe7840fb25ad9ef6bcd4d9 100644 (file)
--- a/src/rgw/driver/posix/rgw_sal_posix.h
+++ b/src/rgw/driver/posix/rgw_sal_posix.h
@@ -514,7 +514,7 @@ public:
   virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
   virtual int set_acl(const DoutPrefixProvider* dpp, RGWAccessControlPolicy& acl,
                      optional_yield y) override;
-  virtual int read_stats(const DoutPrefixProvider *dpp,
+  virtual int read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                         const bucket_index_layout_generation& idx_layout,
                         int shard_id, std::string* bucket_ver, std::string* master_ver,
                         std::map<RGWObjCategory, RGWStorageStats>& stats,
@@ -538,9 +538,11 @@ public:
                         RGWUsageIter& usage_iter, std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
   virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
   virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) override;
-  virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
-  virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
-  virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
+  virtual int check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                          std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                          std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
+  virtual int rebuild_index(const DoutPrefixProvider *dpp, optional_yield y) override;
+  virtual int set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout) override;
   virtual int purge_instance(const DoutPrefixProvider* dpp, optional_yield y) override;
 
   virtual std::unique_ptr<Bucket> clone() override {
@@ -662,6 +664,8 @@ public:
                         bool* truncated, list_parts_each_t each_func,
                         optional_yield y) override;
 
+  bool is_sync_completed(const DoutPrefixProvider* dpp, optional_yield y,
+                         const ceph::real_time& obj_mtime) override;
   virtual int load_obj_state(const DoutPrefixProvider* dpp, optional_yield y, bool follow_olh = true) override;
   virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs,
                            Attrs* delattrs, optional_yield y, uint32_t flags) override;

diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc
index 45545a104723464b0599e599708ab0a7ed64bfeb..a2dbe9a25021eeed4382f4164de97ba83242c114 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.cc
+++ b/src/rgw/driver/rados/rgw_bucket.cc
@@ -563,7 +563,7 @@ int RGWBucket::check_object_index(const DoutPrefixProvider *dpp,
   }
 
   // use a quicker/shorter tag timeout during this process
-  bucket->set_tag_timeout(dpp, BUCKET_TAG_QUICK_TIMEOUT);
+  bucket->set_tag_timeout(dpp, y, BUCKET_TAG_QUICK_TIMEOUT);
 
   rgw::sal::Bucket::ListResults results;
   results.is_truncated = true;
@@ -591,7 +591,7 @@ int RGWBucket::check_object_index(const DoutPrefixProvider *dpp,
   formatter->close_section();
 
   // restore normal tag timeout for bucket
-  bucket->set_tag_timeout(dpp, 0);
+  bucket->set_tag_timeout(dpp, y, 0);
 
   return 0;
 }
@@ -988,7 +988,7 @@ int RGWBucket::check_index_unlinked(rgw::sal::RadosStore* const rados_store,
   return 0;
 }
 
-int RGWBucket::check_index(const DoutPrefixProvider *dpp,
+int RGWBucket::check_index(const DoutPrefixProvider *dpp, optional_yield y,
         RGWBucketAdminOpState& op_state,
         map<RGWObjCategory, RGWStorageStats>& existing_stats,
         map<RGWObjCategory, RGWStorageStats>& calculated_stats,
@@ -996,14 +996,14 @@ int RGWBucket::check_index(const DoutPrefixProvider *dpp,
 {
   bool fix_index = op_state.will_fix_index();
 
-  int r = bucket->check_index(dpp, existing_stats, calculated_stats);
+  int r = bucket->check_index(dpp, y, existing_stats, calculated_stats);
   if (r < 0) {
     set_err_msg(err_msg, "failed to check index error=" + cpp_strerror(-r));
     return r;
   }
 
   if (fix_index) {
-    r = bucket->rebuild_index(dpp);
+    r = bucket->rebuild_index(dpp, y);
     if (r < 0) {
       set_err_msg(err_msg, "failed to rebuild index err=" + cpp_strerror(-r));
       return r;
@@ -1420,7 +1420,7 @@ int RGWBucketAdminOp::check_index(rgw::sal::Driver* driver,
     }
   }
 
-  ret = bucket.check_index(dpp, op_state, existing_stats, calculated_stats);
+  ret = bucket.check_index(dpp, y, op_state, existing_stats, calculated_stats);
   if (ret < 0) {
     return ret;
   }
@@ -1499,7 +1499,7 @@ static int bucket_stats(rgw::sal::Driver* driver,
 
   std::string bucket_ver, master_ver;
   std::string max_marker;
-  ret = bucket->read_stats(dpp, index, RGW_NO_SHARD, &bucket_ver, &master_ver, stats, &max_marker);
+  ret = bucket->read_stats(dpp, y, index, RGW_NO_SHARD, &bucket_ver, &master_ver, stats, &max_marker);
   if (ret < 0) {
     cerr << "error getting bucket stats bucket=" << bucket->get_name() << " ret=" << ret << std::endl;
     return ret;
@@ -1613,7 +1613,7 @@ int RGWBucketAdminOp::limit_check(rgw::sal::Driver* driver,
        /* need stats for num_entries */
        string bucket_ver, master_ver;
        std::map<RGWObjCategory, RGWStorageStats> stats;
-       ret = bucket->read_stats(dpp, index, RGW_NO_SHARD, &bucket_ver, &master_ver, stats, nullptr);
+       ret = bucket->read_stats(dpp, y, index, RGW_NO_SHARD, &bucket_ver, &master_ver, stats, nullptr);
 
        if (ret < 0)
          continue;
@@ -2915,7 +2915,7 @@ int RGWBucketInstanceMetadataHandler::put_post(
     const std::optional<RGWBucketCompleteInfo>& old_bci,
     RGWObjVersionTracker& objv_tracker)
 {
-  int ret = svc_bi->init_index(dpp, bci.info, bci.info.layout.current_index);
+  int ret = svc_bi->init_index(dpp, y, bci.info, bci.info.layout.current_index);
   if (ret < 0) {
     return ret;
   }

diff --git a/src/rgw/driver/rados/rgw_bucket.h b/src/rgw/driver/rados/rgw_bucket.h
index 0bbe45659430cbb128cce0a566969167f9cba406..8a7167f1139f347ba854153406ab4e180bc38730 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.h
+++ b/src/rgw/driver/rados/rgw_bucket.h
@@ -347,7 +347,7 @@ public:
   int check_index_unlinked(rgw::sal::RadosStore* rados_store, const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state,
                            RGWFormatterFlusher& flusher);
 
-  int check_index(const DoutPrefixProvider *dpp,
+  int check_index(const DoutPrefixProvider *dpp, optional_yield y,
           RGWBucketAdminOpState& op_state,
           std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
           std::map<RGWObjCategory, RGWStorageStats>& calculated_stats,

diff --git a/src/rgw/driver/rados/rgw_rados.cc b/src/rgw/driver/rados/rgw_rados.cc
index 09054e4b401155bcccac9055c983fb8063d034cf..0cae52de13d92882390c0a6f2cff0e49b1f35864 100644 (file)
--- a/src/rgw/driver/rados/rgw_rados.cc
+++ b/src/rgw/driver/rados/rgw_rados.cc
@@ -2449,7 +2449,7 @@ int RGWRados::create_bucket(const DoutPrefixProvider* dpp,
     }
 
     if (zone_placement) {
-      ret = svc.bi->init_index(dpp, info, info.layout.current_index);
+      ret = svc.bi->init_index(dpp, y, info, info.layout.current_index);
       if (ret < 0) {
         return ret;
       }
@@ -2475,7 +2475,7 @@ int RGWRados::create_bucket(const DoutPrefixProvider* dpp,
       /* only remove it if it's a different bucket instance */
       if (orig_info.bucket.bucket_id != bucket.bucket_id) {
         if (zone_placement) {
-          r = svc.bi->clean_index(dpp, info, info.layout.current_index);
+          r = svc.bi->clean_index(dpp, y, info, info.layout.current_index);
           if (r < 0) {
             ldpp_dout(dpp, 0) << "WARNING: could not remove bucket index (r=" << r << ")" << dendl;
           }
@@ -5988,7 +5988,8 @@ static void accumulate_raw_stats(const rgw_bucket_dir_header& header,
   }
 }
 
-int RGWRados::bucket_check_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info,
+int RGWRados::bucket_check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                                 const RGWBucketInfo& bucket_info,
                                 map<RGWObjCategory, RGWStorageStats> *existing_stats,
                                 map<RGWObjCategory, RGWStorageStats> *calculated_stats)
 {
@@ -6024,7 +6025,8 @@ int RGWRados::bucket_check_index(const DoutPrefixProvider *dpp, RGWBucketInfo& b
   return 0;
 }
 
-int RGWRados::bucket_rebuild_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info)
+int RGWRados::bucket_rebuild_index(const DoutPrefixProvider *dpp, optional_yield y,
+                                   const RGWBucketInfo& bucket_info)
 {
   librados::IoCtx index_pool;
   map<int, string> bucket_objs;
@@ -9401,7 +9403,7 @@ int RGWRados::raw_obj_stat(const DoutPrefixProvider *dpp,
   return 0;
 }
 
-int RGWRados::get_bucket_stats(const DoutPrefixProvider *dpp,
+int RGWRados::get_bucket_stats(const DoutPrefixProvider *dpp, optional_yield y,
                               RGWBucketInfo& bucket_info,
                               const rgw::bucket_index_layout_generation& idx_layout,
                               int shard_id, string *bucket_ver, string *master_ver,

diff --git a/src/rgw/driver/rados/rgw_rados.h b/src/rgw/driver/rados/rgw_rados.h
index 13fde2926055f4218f6a2bc24fbd4787c071e5e2..57e60ceb7818ed9dfe2cc6e22a4d7b2cc6adec2f 100644 (file)
--- a/src/rgw/driver/rados/rgw_rados.h
+++ b/src/rgw/driver/rados/rgw_rados.h
@@ -1455,7 +1455,8 @@ public:
     rctx->set_compressed(obj);
   }
   int decode_policy(const DoutPrefixProvider *dpp, bufferlist& bl, ACLOwner *owner);
-  int get_bucket_stats(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout, int shard_id, std::string *bucket_ver, std::string *master_ver,
+  int get_bucket_stats(const DoutPrefixProvider *dpp, optional_yield y,
+                       RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout, int shard_id, std::string *bucket_ver, std::string *master_ver,
       std::map<RGWObjCategory, RGWStorageStats>& stats, std::string *max_marker, bool* syncstopped = NULL);
   int get_bucket_stats_async(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout, int shard_id, boost::intrusive_ptr<rgw::sal::ReadStatsCB> cb);
 
@@ -1589,10 +1590,12 @@ public:
 
   int process_lc(const std::unique_ptr<rgw::sal::Bucket>& optional_bucket);
 
-  int bucket_check_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info,
+  int bucket_check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                         const RGWBucketInfo& bucket_info,
                          std::map<RGWObjCategory, RGWStorageStats> *existing_stats,
                          std::map<RGWObjCategory, RGWStorageStats> *calculated_stats);
-  int bucket_rebuild_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info);
+  int bucket_rebuild_index(const DoutPrefixProvider *dpp, optional_yield y,
+                           const RGWBucketInfo& bucket_info);
 
   // Search the bucket for encrypted multipart uploads, and increase their mtime
   // slightly to generate a bilog entry to trigger a resync to repair any

diff --git a/src/rgw/driver/rados/rgw_reshard.cc b/src/rgw/driver/rados/rgw_reshard.cc
index c7fc3df43a21a141624b8b8ed8e68a60df643d67..e6fc82b7edd5cc4881ec5ad605a37f620206a28a 100644 (file)
--- a/src/rgw/driver/rados/rgw_reshard.cc
+++ b/src/rgw/driver/rados/rgw_reshard.cc
@@ -374,7 +374,7 @@ static int remove_old_reshard_instance(rgw::sal::RadosStore* store,
   }
 
   // delete its shard objects (ignore errors)
-  store->svc()->bi->clean_index(dpp, info, info.layout.current_index);
+  store->svc()->bi->clean_index(dpp, y, info, info.layout.current_index);
   // delete the bucket instance metadata
   return store->ctl()->bucket->remove_bucket_instance_info(bucket, info, y, dpp);
 }
@@ -385,19 +385,19 @@ static int init_target_index(rgw::sal::RadosStore* store,
                              const rgw::bucket_index_layout_generation& index,
                              ReshardFaultInjector& fault,
                              bool& support_logrecord,
-                             const DoutPrefixProvider* dpp)
+                             const DoutPrefixProvider* dpp, optional_yield y)
 {
 
   int ret = 0;
   if (ret = fault.check("init_index");
       ret == 0) { // no fault injected, initialize index
-    ret = store->svc()->bi->init_index(dpp, bucket_info, index, true);
+    ret = store->svc()->bi->init_index(dpp, y, bucket_info, index, true);
   }
   if (ret == -EOPNOTSUPP) {
     ldpp_dout(dpp, 0) << "WARNING: " << "init_index() does not supported logrecord, "
                       << "falling back to block reshard mode." << dendl;
     support_logrecord = false;
-    ret = store->svc()->bi->init_index(dpp, bucket_info, index, false);
+    ret = store->svc()->bi->init_index(dpp, y, bucket_info, index, false);
   } else if (ret < 0) {
     ldpp_dout(dpp, 0) << "ERROR: " << __func__ << " failed to initialize "
        "target index shard objects: " << cpp_strerror(ret) << dendl;
@@ -407,12 +407,12 @@ static int init_target_index(rgw::sal::RadosStore* store,
   if (!bucket_info.datasync_flag_enabled()) {
     // if bucket sync is disabled, disable it on each of the new shards too
     auto log = rgw::log_layout_from_index(0, index);
-    ret = store->svc()->bilog_rados->log_stop(dpp, bucket_info, log, -1);
+    ret = store->svc()->bilog_rados->log_stop(dpp, y, bucket_info, log, -1);
     if (ret < 0) {
       ldpp_dout(dpp, 0) << "ERROR: " << __func__ << " failed to disable "
           "bucket sync on the target index shard objects: "
           << cpp_strerror(ret) << dendl;
-      store->svc()->bi->clean_index(dpp, bucket_info, index);
+      store->svc()->bi->clean_index(dpp, y, bucket_info, index);
       return ret;
     }
   }
@@ -459,14 +459,14 @@ static int init_target_layout(rgw::sal::RadosStore* store,
     ldpp_dout(dpp, 10) << __func__ << " removing existing target index "
         "objects from a previous reshard attempt" << dendl;
     // delete its existing shard objects (ignore errors)
-    store->svc()->bi->clean_index(dpp, bucket_info, *bucket_info.layout.target_index);
+    store->svc()->bi->clean_index(dpp, y, bucket_info, *bucket_info.layout.target_index);
     // don't reuse this same generation in the new target layout, in case
     // something is still trying to operate on its shard objects
     target.gen = bucket_info.layout.target_index->gen + 1;
   }
 
   // create the index shard objects
-  int ret = init_target_index(store, bucket_info, target, fault, support_logrecord, dpp);
+  int ret = init_target_index(store, bucket_info, target, fault, support_logrecord, dpp, y);
   if (ret < 0) {
     return ret;
   }
@@ -527,7 +527,7 @@ static int init_target_layout(rgw::sal::RadosStore* store,
     bucket_info.layout = std::move(prev);  // restore in-memory layout
 
     // delete the target shard objects (ignore errors)
-    store->svc()->bi->clean_index(dpp, bucket_info, target);
+    store->svc()->bi->clean_index(dpp, y, bucket_info, target);
     return ret;
   }
 
@@ -545,7 +545,7 @@ static int revert_target_layout(rgw::sal::RadosStore* store,
   auto prev = bucket_info.layout; // make a copy for cleanup
 
   // remove target index shard objects
-  int ret = store->svc()->bi->clean_index(dpp, bucket_info, *prev.target_index);
+  int ret = store->svc()->bi->clean_index(dpp, y, bucket_info, *prev.target_index);
   if (ret < 0) {
     ldpp_dout(dpp, 1) << "WARNING: " << __func__ << " failed to remove "
         "target index with: " << cpp_strerror(ret) << dendl;
@@ -659,11 +659,11 @@ static int init_reshard(rgw::sal::RadosStore* store,
     if (ret = fault.check("logrecord_writes");
         ret == 0) { // no fault injected, record log with writing to the current index shards
       ret = store->svc()->bi_rados->set_reshard_status(
-          dpp, bucket_info, cls_rgw_reshard_status::IN_LOGRECORD);
+          dpp, y, bucket_info, cls_rgw_reshard_status::IN_LOGRECORD);
     }
   } else {
     ret = store->svc()->bi_rados->set_reshard_status(
-        dpp, bucket_info, cls_rgw_reshard_status::IN_PROGRESS);
+        dpp, y, bucket_info, cls_rgw_reshard_status::IN_PROGRESS);
   }
   if (ret < 0) {
     ldpp_dout(dpp, 0) << "ERROR: " << __func__ << " failed to pause "
@@ -731,7 +731,7 @@ static int change_reshard_state(rgw::sal::RadosStore* store,
 
     // unblock writes to the current index shard objects
     int ret2 = store->svc()->bi_rados->set_reshard_status(
-        dpp, bucket_info, cls_rgw_reshard_status::NOT_RESHARDING);
+        dpp, y, bucket_info, cls_rgw_reshard_status::NOT_RESHARDING);
     if (ret2 < 0) {
       ldpp_dout(dpp, 1) << "WARNING: " << __func__ << " failed to unblock "
           "writes to current index objects: " << cpp_strerror(ret2) << dendl;
@@ -743,7 +743,7 @@ static int change_reshard_state(rgw::sal::RadosStore* store,
   if (ret = fault.check("block_writes");
       ret == 0) { // no fault injected, block writes to the current index shards
     ret = store->svc()->bi_rados->set_reshard_status(
-        dpp, bucket_info, cls_rgw_reshard_status::IN_PROGRESS);
+        dpp, y, bucket_info, cls_rgw_reshard_status::IN_PROGRESS);
   }
 
   if (ret < 0) {
@@ -765,7 +765,7 @@ static int cancel_reshard(rgw::sal::RadosStore* store,
 {
   // unblock writes to the current index shard objects
   int ret = store->svc()->bi_rados->set_reshard_status(
-      dpp, bucket_info, cls_rgw_reshard_status::NOT_RESHARDING);
+      dpp, y, bucket_info, cls_rgw_reshard_status::NOT_RESHARDING);
   if (ret < 0) {
     ldpp_dout(dpp, 1) << "WARNING: " << __func__ << " failed to unblock "
         "writes to current index objects: " << cpp_strerror(ret) << dendl;
@@ -864,7 +864,7 @@ static int commit_reshard(rgw::sal::RadosStore* store,
 
     // unblock writes to the current index shard objects
     int ret2 = store->svc()->bi_rados->set_reshard_status(
-        dpp, bucket_info, cls_rgw_reshard_status::NOT_RESHARDING);
+        dpp, y, bucket_info, cls_rgw_reshard_status::NOT_RESHARDING);
     if (ret2 < 0) {
       ldpp_dout(dpp, 1) << "WARNING: " << __func__ << " failed to unblock "
           "writes to current index objects: " << cpp_strerror(ret2) << dendl;
@@ -900,7 +900,7 @@ static int commit_reshard(rgw::sal::RadosStore* store,
       });
   if (log == logs.end()) {
     // delete the index objects (ignore errors)
-    store->svc()->bi->clean_index(dpp, bucket_info, prev.current_index);
+    store->svc()->bi->clean_index(dpp, y, bucket_info, prev.current_index);
   }
   return 0;
 } // commit_reshard
@@ -1251,9 +1251,10 @@ int RGWBucketReshard::do_reshard(const rgw::bucket_index_layout_generation& curr
   return 0;
 } // RGWBucketReshard::do_reshard
 
-int RGWBucketReshard::get_status(const DoutPrefixProvider *dpp, list<cls_rgw_bucket_instance_entry> *status)
+int RGWBucketReshard::get_status(const DoutPrefixProvider *dpp, optional_yield y,
+                                 list<cls_rgw_bucket_instance_entry> *status)
 {
-  return store->svc()->bi_rados->get_reshard_status(dpp, bucket_info, status);
+  return store->svc()->bi_rados->get_reshard_status(dpp, y, bucket_info, status);
 }
 
 int RGWBucketReshard::execute(int num_shards,
@@ -1600,7 +1601,7 @@ int RGWReshard::process_entry(const cls_rgw_reshard_entry& entry,
 
     // determine how many entries there are in the bucket index
     std::map<RGWObjCategory, RGWStorageStats> stats;
-    ret = store->getRados()->get_bucket_stats(dpp, bucket_info,
+    ret = store->getRados()->get_bucket_stats(dpp, y, bucket_info,
                                              bucket_info.layout.current_index,
                                              -1, nullptr, nullptr, stats, nullptr, nullptr);
     if (ret < 0) {

diff --git a/src/rgw/driver/rados/rgw_reshard.h b/src/rgw/driver/rados/rgw_reshard.h
index 7a889318902d099931b7289077e493fe56a152e6..081521a360493174edd5ecd5a26f7599cdce3114 100644 (file)
--- a/src/rgw/driver/rados/rgw_reshard.h
+++ b/src/rgw/driver/rados/rgw_reshard.h
@@ -117,7 +117,8 @@ public:
               bool verbose = false, std::ostream *out = nullptr,
               ceph::Formatter *formatter = nullptr,
              RGWReshard *reshard_log = nullptr);
-  int get_status(const DoutPrefixProvider *dpp, std::list<cls_rgw_bucket_instance_entry> *status);
+  int get_status(const DoutPrefixProvider *dpp, optional_yield y,
+                 std::list<cls_rgw_bucket_instance_entry> *status);
   int cancel(const DoutPrefixProvider* dpp, optional_yield y);
   int renew_lock_if_needed(const DoutPrefixProvider *dpp);
 

diff --git a/src/rgw/driver/rados/rgw_rest_log.cc b/src/rgw/driver/rados/rgw_rest_log.cc
index 19e7ea6a72d30133c5e5c4cbfaad5450f7808c42..0f1ea2a783e4f19938e59833c270ed3cc7daddc8 100644 (file)
--- a/src/rgw/driver/rados/rgw_rest_log.cc
+++ b/src/rgw/driver/rados/rgw_rest_log.cc
@@ -451,7 +451,7 @@ void RGWOp_BILog_List::execute(optional_yield y) {
   send_response();
   do {
     list<rgw_bi_log_entry> entries;
-    int ret = static_cast<rgw::sal::RadosStore*>(driver)->svc()->bilog_rados->log_list(s, bucket->get_info(), log_layout, shard_id,
+    int ret = static_cast<rgw::sal::RadosStore*>(driver)->svc()->bilog_rados->log_list(s, y, bucket->get_info(), log_layout, shard_id,
                                                marker, max_entries - count,
                                                entries, &truncated);
     if (ret < 0) {
@@ -557,7 +557,7 @@ void RGWOp_BILog_Info::execute(optional_yield y) {
   map<RGWObjCategory, RGWStorageStats> stats;
   const auto& index = log_to_index_layout(logs.back());
 
-  int ret =  bucket->read_stats(s, index, shard_id, &bucket_ver, &master_ver, stats, &max_marker, &syncstopped);
+  int ret =  bucket->read_stats(s, y, index, shard_id, &bucket_ver, &master_ver, stats, &max_marker, &syncstopped);
   if (ret < 0 && ret != -ENOENT) {
     op_ret = ret;
     return;
@@ -641,7 +641,7 @@ void RGWOp_BILog_Delete::execute(optional_yield y) {
     return;
   }
 
-  op_ret = bilog_trim(this, static_cast<rgw::sal::RadosStore*>(driver),
+  op_ret = bilog_trim(this, y, static_cast<rgw::sal::RadosStore*>(driver),
                      bucket->get_info(), gen, shard_id,
                      start_marker, end_marker);
   if (op_ret < 0) {

diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc
index 7bd2af63dd55e75943ff84ec6c6cf7379fa6cacc..447e33ef8d115ec90d7be2816c91e87fa2be034f 100644 (file)
--- a/src/rgw/driver/rados/rgw_sal_rados.cc
+++ b/src/rgw/driver/rados/rgw_sal_rados.cc
@@ -494,7 +494,7 @@ int RadosBucket::remove_bypass_gc(int concurrent_max, bool
     return ret;
 
   const auto& index = info.get_current_index();
-  ret = read_stats(dpp, index, RGW_NO_SHARD, &bucket_ver, &master_ver, stats, NULL);
+  ret = read_stats(dpp, y, index, RGW_NO_SHARD, &bucket_ver, &master_ver, stats, NULL);
   if (ret < 0)
     return ret;
 
@@ -638,13 +638,13 @@ int RadosBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y)
   return ret;
 }
 
-int RadosBucket::read_stats(const DoutPrefixProvider *dpp,
+int RadosBucket::read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                            const bucket_index_layout_generation& idx_layout,
                            int shard_id, std::string* bucket_ver, std::string* master_ver,
                            std::map<RGWObjCategory, RGWStorageStats>& stats,
                            std::string* max_marker, bool* syncstopped)
 {
-  return store->getRados()->get_bucket_stats(dpp, info, idx_layout, shard_id, bucket_ver, master_ver, stats, max_marker, syncstopped);
+  return store->getRados()->get_bucket_stats(dpp, y, info, idx_layout, shard_id, bucket_ver, master_ver, stats, max_marker, syncstopped);
 }
 
 int RadosBucket::read_stats_async(const DoutPrefixProvider *dpp,
@@ -797,17 +797,19 @@ int RadosBucket::remove_objs_from_index(const DoutPrefixProvider *dpp, std::list
   return store->getRados()->remove_objs_from_index(dpp, info, objs_to_unlink);
 }
 
-int RadosBucket::check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
+int RadosBucket::check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                             std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                             std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
 {
-  return store->getRados()->bucket_check_index(dpp, info, &existing_stats, &calculated_stats);
+  return store->getRados()->bucket_check_index(dpp, y, info, &existing_stats, &calculated_stats);
 }
 
-int RadosBucket::rebuild_index(const DoutPrefixProvider *dpp)
+int RadosBucket::rebuild_index(const DoutPrefixProvider *dpp, optional_yield y)
 {
-  return store->getRados()->bucket_rebuild_index(dpp, info);
+  return store->getRados()->bucket_rebuild_index(dpp, y, info);
 }
 
-int RadosBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
+int RadosBucket::set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout)
 {
   return store->getRados()->cls_obj_set_bucket_tag_timeout(dpp, info, timeout);
 }
@@ -2535,7 +2537,8 @@ RadosObject::~RadosObject()
 }
 
 bool RadosObject::is_sync_completed(const DoutPrefixProvider* dpp,
-   const ceph::real_time& obj_mtime)
+                                    optional_yield y,
+                                    const ceph::real_time& obj_mtime)
 {
   const auto& bucket_info = get_bucket()->get_info();
   if (bucket_info.is_indexless()) {
@@ -2552,7 +2555,7 @@ bool RadosObject::is_sync_completed(const DoutPrefixProvider* dpp,
 
   const int shard_id = RGWSI_BucketIndex_RADOS::bucket_shard_index(get_key(), shard_count);
 
-  int ret = store->svc()->bilog_rados->log_list(dpp, bucket_info, log_layout, shard_id,
+  int ret = store->svc()->bilog_rados->log_list(dpp, y, bucket_info, log_layout, shard_id,
     marker, 1, entries, &truncated);
 
   if (ret < 0) {

diff --git a/src/rgw/driver/rados/rgw_sal_rados.h b/src/rgw/driver/rados/rgw_sal_rados.h
index 08ab55bcf8278fadb0b0505f1299d3c2c75bf05e..9e99d69b3b75d74ed11702a3502292b67c017676 100644 (file)
--- a/src/rgw/driver/rados/rgw_sal_rados.h
+++ b/src/rgw/driver/rados/rgw_sal_rados.h
@@ -598,8 +598,8 @@ class RadosObject : public StoreObject {
       StoreObject::set_compressed();
     }
 
-    virtual bool is_sync_completed(const DoutPrefixProvider* dpp,
-      const ceph::real_time& obj_mtime) override;
+    bool is_sync_completed(const DoutPrefixProvider* dpp, optional_yield y,
+                           const ceph::real_time& obj_mtime) override;
     /* For rgw_admin.cc */
     RGWObjState& get_state() { return state; }
     virtual int load_obj_state(const DoutPrefixProvider* dpp, optional_yield y, bool follow_olh = true) override;
@@ -735,7 +735,7 @@ class RadosBucket : public StoreBucket {
     int create(const DoutPrefixProvider* dpp, const CreateParams& params,
                optional_yield y) override;
     virtual int load_bucket(const DoutPrefixProvider* dpp, optional_yield y) override;
-    virtual int read_stats(const DoutPrefixProvider *dpp,
+    virtual int read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                            const bucket_index_layout_generation& idx_layout,
                            int shard_id, std::string* bucket_ver, std::string* master_ver,
                            std::map<RGWObjCategory, RGWStorageStats>& stats,
@@ -759,9 +759,11 @@ class RadosBucket : public StoreBucket {
                           std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
     virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
     virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) override;
-    virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
-    virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
-    virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
+    virtual int check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                            std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                            std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
+    virtual int rebuild_index(const DoutPrefixProvider *dpp, optional_yield y) override;
+    virtual int set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout) override;
     virtual int purge_instance(const DoutPrefixProvider* dpp, optional_yield y) override;
     virtual std::unique_ptr<Bucket> clone() override {
       return std::make_unique<RadosBucket>(*this);

diff --git a/src/rgw/driver/rados/rgw_trim_bilog.cc b/src/rgw/driver/rados/rgw_trim_bilog.cc
index 93dbf6d64d07065066f0c0aaa6e719e1d5134c94..7ce5f802e63988f7abfa51f3a5bb56f558694565 100644 (file)
--- a/src/rgw/driver/rados/rgw_trim_bilog.cc
+++ b/src/rgw/driver/rados/rgw_trim_bilog.cc
@@ -1487,7 +1487,8 @@ std::ostream& BucketTrimManager::gen_prefix(std::ostream& out) const
 
 } // namespace rgw
 
-int bilog_trim(const DoutPrefixProvider* p, rgw::sal::RadosStore* store,
+int bilog_trim(const DoutPrefixProvider* p, optional_yield y,
+              rgw::sal::RadosStore* store,
               RGWBucketInfo& bucket_info, uint64_t gen, int shard_id,
               std::string_view start_marker, std::string_view end_marker)
 {
@@ -1501,7 +1502,7 @@ int bilog_trim(const DoutPrefixProvider* p, rgw::sal::RadosStore* store,
 
   auto log_layout = *log;
 
-  auto r = store->svc()->bilog_rados->log_trim(p, bucket_info, log_layout, shard_id, start_marker, end_marker);
+  auto r = store->svc()->bilog_rados->log_trim(p, y, bucket_info, log_layout, shard_id, start_marker, end_marker);
   if (r < 0) {
     ldpp_dout(p, 5) << __PRETTY_FUNCTION__ << ":" << __LINE__
                    << "ERROR: bilog_rados->log_trim returned r=" << r << dendl;

diff --git a/src/rgw/driver/rados/rgw_trim_bilog.h b/src/rgw/driver/rados/rgw_trim_bilog.h
index 6a11d24766be2085911916b37c0c3141c164b53b..9eb59655adf7ed99f8044f314f903c9e7a7ad41b 100644 (file)
--- a/src/rgw/driver/rados/rgw_trim_bilog.h
+++ b/src/rgw/driver/rados/rgw_trim_bilog.h
@@ -21,6 +21,7 @@
 
 #include "include/common_fwd.h"
 #include "include/encoding.h"
+#include "common/async/yield_context.h"
 #include "common/ceph_time.h"
 #include "common/dout.h"
 #include "rgw_common.h"
@@ -116,6 +117,7 @@ struct BucketTrimStatus {
 
 WRITE_CLASS_ENCODER(rgw::BucketTrimStatus);
 
-int bilog_trim(const DoutPrefixProvider* p, rgw::sal::RadosStore* store,
+int bilog_trim(const DoutPrefixProvider* p, optional_yield y,
+              rgw::sal::RadosStore* store,
               RGWBucketInfo& bucket_info, uint64_t gen, int shard_id,
               std::string_view start_marker, std::string_view end_marker);

diff --git a/src/rgw/radosgw-admin/radosgw-admin.cc b/src/rgw/radosgw-admin/radosgw-admin.cc
index 802ca73b308fbc40df82073f7a463710584c77f0..e5b7dcee58eed7732a8f1ea684cb613312136e57 100644 (file)
--- a/src/rgw/radosgw-admin/radosgw-admin.cc
+++ b/src/rgw/radosgw-admin/radosgw-admin.cc
@@ -8770,7 +8770,7 @@ next:
                        bucket->get_info(), bucket->get_attrs(),
                        nullptr /* no callback */);
     list<cls_rgw_bucket_instance_entry> status;
-    int r = br.get_status(dpp(), &status);
+    int r = br.get_status(dpp(), null_yield, &status);
     if (r < 0) {
       cerr << "ERROR: could not get resharding status for bucket " <<
        bucket_name << std::endl;
@@ -10314,7 +10314,7 @@ next:
 
     do {
       list<rgw_bi_log_entry> entries;
-      ret = static_cast<rgw::sal::RadosStore*>(driver)->svc()->bilog_rados->log_list(dpp(), bucket->get_info(), log_layout, shard_id, marker, max_entries - count, entries, &truncated);
+      ret = static_cast<rgw::sal::RadosStore*>(driver)->svc()->bilog_rados->log_list(dpp(), null_yield, bucket->get_info(), log_layout, shard_id, marker, max_entries - count, entries, &truncated);
       if (ret < 0) {
         cerr << "ERROR: list_bi_log_entries(): " << cpp_strerror(-ret) << std::endl;
         return -ret;
@@ -10808,7 +10808,7 @@ next:
     if (!gen) {
       gen = 0;
     }
-    ret = bilog_trim(dpp(), static_cast<rgw::sal::RadosStore*>(driver),
+    ret = bilog_trim(dpp(), null_yield, static_cast<rgw::sal::RadosStore*>(driver),
                     bucket->get_info(), *gen,
                     shard_id, start_marker, end_marker);
     if (ret < 0) {

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 3ad16c558022c4f2406a50440d756d3d0569a937..288a09ae16087f8e0d05b72944aef8d1280c9c3b 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -911,19 +911,19 @@ void rgw_build_iam_environment(rgw::sal::Driver* driver,
 }
 
 void handle_replication_status_header(
-    const DoutPrefixProvider *dpp,
+    const DoutPrefixProvider *dpp, optional_yield y,
     rgw::sal::Attrs& attrs,
     req_state* s,
     const ceph::real_time &obj_mtime) {
   auto attr_iter = attrs.find(RGW_ATTR_OBJ_REPLICATION_STATUS);
   if (attr_iter != attrs.end() && attr_iter->second.to_str() == "PENDING") {
-    if (s->object->is_sync_completed(dpp, obj_mtime)) {
+    if (s->object->is_sync_completed(dpp, y, obj_mtime)) {
       s->object->set_atomic();
       rgw::sal::Attrs setattrs, rmattrs;
       bufferlist bl;
       bl.append("COMPLETED");
       setattrs[RGW_ATTR_OBJ_REPLICATION_STATUS] = bl;
-      int ret = s->object->set_obj_attrs(dpp, &setattrs, &rmattrs, s->yield, 0);
+      int ret = s->object->set_obj_attrs(dpp, &setattrs, &rmattrs, y, 0);
       if (ret < 0) {
         ldpp_dout(dpp, 0) << "ERROR: failed to set object replication status to COMPLETED ret=" << ret << dendl;
         return;
@@ -2456,7 +2456,7 @@ void RGWGetObj::execute(optional_yield y)
     filter = &*decompress;
   }
 
-  handle_replication_status_header(this, attrs, s, lastmod);
+  handle_replication_status_header(this, y, attrs, s, lastmod);
 
   attr_iter = attrs.find(RGW_ATTR_OBJ_REPLICATION_TRACE);
   if (attr_iter != attrs.end()) {
@@ -3122,7 +3122,7 @@ static int load_bucket_stats(const DoutPrefixProvider* dpp, optional_yield y,
   std::string bver, mver; // ignored
   std::map<RGWObjCategory, RGWStorageStats> categories;
 
-  int r = bucket.read_stats(dpp, index, -1, &bver, &mver, categories);
+  int r = bucket.read_stats(dpp, y, index, -1, &bver, &mver, categories);
   if (r < 0) {
     return r;
   }

diff --git a/src/rgw/rgw_quota.cc b/src/rgw/rgw_quota.cc
index 70bded92ee06d5f73c7f9f207cd70def5fa90822..60392d37eee7420d4b4cd6fb83d9f08284e70ac3 100644 (file)
--- a/src/rgw/rgw_quota.cc
+++ b/src/rgw/rgw_quota.cc
@@ -267,7 +267,7 @@ int RGWBucketStatsCache::fetch_stats_from_storage(const rgw_owner& owner, const
   string master_ver;
 
   map<RGWObjCategory, RGWStorageStats> bucket_stats;
-  r = bucket->read_stats(dpp, index, RGW_NO_SHARD, &bucket_ver,
+  r = bucket->read_stats(dpp, y, index, RGW_NO_SHARD, &bucket_ver,
                         &master_ver, bucket_stats, nullptr);
   if (r < 0) {
     ldpp_dout(dpp, 0) << "could not get bucket stats for bucket="

diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h
index 33a176ebefde8c868e2bc3ca165bb9a99295190c..435de6ba75a8f428e96708caa2df3d5ef6184696 100644 (file)
--- a/src/rgw/rgw_sal.h
+++ b/src/rgw/rgw_sal.h
@@ -904,7 +904,7 @@ class Bucket {
     /** Load this bucket from the backing store.  Requires the key to be set, fills other fields. */
     virtual int load_bucket(const DoutPrefixProvider* dpp, optional_yield y) = 0;
     /** Read the bucket stats from the backing Store, synchronous */
-    virtual int read_stats(const DoutPrefixProvider *dpp,
+    virtual int read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                           const bucket_index_layout_generation& idx_layout,
                           int shard_id, std::string* bucket_ver, std::string* master_ver,
                           std::map<RGWObjCategory, RGWStorageStats>& stats,
@@ -946,11 +946,13 @@ class Bucket {
     /** Remove objects from the bucket index of this bucket.  May be removed from API */
     virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) = 0;
     /** Check the state of the bucket index, and get stats from it.  May be removed from API */
-    virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) = 0;
+    virtual int check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                            std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                            std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) = 0;
     /** Rebuild the bucket index.  May be removed from API */
-    virtual int rebuild_index(const DoutPrefixProvider *dpp) = 0;
+    virtual int rebuild_index(const DoutPrefixProvider *dpp, optional_yield y) = 0;
     /** Set a timeout on the check_index() call.  May be removed from API */
-    virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) = 0;
+    virtual int set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout) = 0;
     /** Remove this specific bucket instance from the backing store.  May be removed from API */
     virtual int purge_instance(const DoutPrefixProvider* dpp, optional_yield y) = 0;
 
@@ -1208,7 +1210,8 @@ class Object {
     virtual bool is_compressed() = 0;
     /** Check if object is synced */
     virtual bool is_sync_completed(const DoutPrefixProvider* dpp,
-      const ceph::real_time& obj_mtime) = 0;
+                                   optional_yield y,
+                                   const ceph::real_time& obj_mtime) = 0;
     /** Invalidate cached info about this object, except atomic, prefetch, and
      * compressed */
     virtual void invalidate() = 0;

diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc
index 945d72fa40dd4e7d9ae3a9ffeb69d9720e8a4d79..d5e8b73d4dc5259969fab2c094c26a32f3335912 100644 (file)
--- a/src/rgw/rgw_sal_dbstore.cc
+++ b/src/rgw/rgw_sal_dbstore.cc
@@ -203,7 +203,7 @@ namespace rgw::sal {
   }
 
   /* stats - Not for first pass */
-  int DBBucket::read_stats(const DoutPrefixProvider *dpp,
+  int DBBucket::read_stats(const DoutPrefixProvider *dpp, optional_yield y,
       const bucket_index_layout_generation& idx_layout,
       int shard_id,
       std::string *bucket_ver, std::string *master_ver,
@@ -309,19 +309,21 @@ namespace rgw::sal {
     return 0;
   }
 
-  int DBBucket::check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
+  int DBBucket::check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                            std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                            std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
   {
     /* XXX: stats not supported yet */
     return 0;
   }
 
-  int DBBucket::rebuild_index(const DoutPrefixProvider *dpp)
+  int DBBucket::rebuild_index(const DoutPrefixProvider *dpp, optional_yield y)
   {
     /* there is no index table in dbstore. Not applicable */
     return 0;
   }
 
-  int DBBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
+  int DBBucket::set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout)
   {
     /* XXX: CHECK: set tag timeout for all the bucket objects? */
     return 0;
@@ -496,6 +498,12 @@ namespace rgw::sal {
     return -EOPNOTSUPP;
   }
 
+  bool DBObject::is_sync_completed(const DoutPrefixProvider* dpp, optional_yield y,
+                                   const ceph::real_time& obj_mtime)
+  {
+    return false;
+  }
+
   int DBObject::load_obj_state(const DoutPrefixProvider* dpp, optional_yield y, bool follow_olh)
   {
     RGWObjState* astate;

diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h
index 3fabc6d5ec18684cce6e96e0561d3437e89f0858..0173baf297cc387002d78c0790fb9caf5a55fa85 100644 (file)
--- a/src/rgw/rgw_sal_dbstore.h
+++ b/src/rgw/rgw_sal_dbstore.h
@@ -152,7 +152,7 @@ protected:
                  const CreateParams& params,
                  optional_yield y) override;
       virtual int load_bucket(const DoutPrefixProvider *dpp, optional_yield y) override;
-      virtual int read_stats(const DoutPrefixProvider *dpp,
+      virtual int read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                             const bucket_index_layout_generation& idx_layout,
                             int shard_id,
           std::string *bucket_ver, std::string *master_ver,
@@ -175,9 +175,11 @@ protected:
           std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
       virtual int trim_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch, optional_yield y) override;
       virtual int remove_objs_from_index(const DoutPrefixProvider *dpp, std::list<rgw_obj_index_key>& objs_to_unlink) override;
-      virtual int check_index(const DoutPrefixProvider *dpp, std::map<RGWObjCategory, RGWStorageStats>& existing_stats, std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
-      virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
-      virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
+      virtual int check_index(const DoutPrefixProvider *dpp, optional_yield y,
+                              std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
+                              std::map<RGWObjCategory, RGWStorageStats>& calculated_stats) override;
+      virtual int rebuild_index(const DoutPrefixProvider *dpp, optional_yield y) override;
+      virtual int set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout) override;
       virtual int purge_instance(const DoutPrefixProvider *dpp, optional_yield y) override;
       virtual std::unique_ptr<Bucket> clone() override {
         return std::make_unique<DBBucket>(*this);
@@ -564,6 +566,8 @@ protected:
                           bool* truncated, list_parts_each_t each_func,
                           optional_yield y) override;
 
+      bool is_sync_completed(const DoutPrefixProvider* dpp, optional_yield y,
+                             const ceph::real_time& obj_mtime) override;
       virtual int load_obj_state(const DoutPrefixProvider* dpp, optional_yield y, bool follow_olh = true) override;
       virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
       virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp,

diff --git a/src/rgw/rgw_sal_filter.cc b/src/rgw/rgw_sal_filter.cc
index 70fb306c7b3a4cc8434c9a47f7c7a46df5b5ae69..e7e23df02161c3289649b50f3d155216e05be2f0 100644 (file)
--- a/src/rgw/rgw_sal_filter.cc
+++ b/src/rgw/rgw_sal_filter.cc
@@ -844,14 +844,14 @@ int FilterBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y)
   return next->load_bucket(dpp, y);
 }
 
-int FilterBucket::read_stats(const DoutPrefixProvider *dpp,
+int FilterBucket::read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                             const bucket_index_layout_generation& idx_layout,
                             int shard_id, std::string* bucket_ver,
                             std::string* master_ver,
                             std::map<RGWObjCategory, RGWStorageStats>& stats,
                             std::string* max_marker, bool* syncstopped)
 {
-  return next->read_stats(dpp, idx_layout, shard_id, bucket_ver, master_ver,
+  return next->read_stats(dpp, y, idx_layout, shard_id, bucket_ver, master_ver,
                          stats, max_marker, syncstopped);
 }
 
@@ -935,21 +935,21 @@ int FilterBucket::remove_objs_from_index(const DoutPrefixProvider *dpp,
   return next->remove_objs_from_index(dpp, objs_to_unlink);
 }
 
-int FilterBucket::check_index(const DoutPrefixProvider *dpp,
+int FilterBucket::check_index(const DoutPrefixProvider *dpp, optional_yield y,
                              std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
                              std::map<RGWObjCategory, RGWStorageStats>& calculated_stats)
 {
-  return next->check_index(dpp, existing_stats, calculated_stats);
+  return next->check_index(dpp, y, existing_stats, calculated_stats);
 }
 
-int FilterBucket::rebuild_index(const DoutPrefixProvider *dpp)
+int FilterBucket::rebuild_index(const DoutPrefixProvider *dpp, optional_yield y)
 {
-  return next->rebuild_index(dpp);
+  return next->rebuild_index(dpp, y);
 }
 
-int FilterBucket::set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout)
+int FilterBucket::set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout)
 {
-  return next->set_tag_timeout(dpp, timeout);
+  return next->set_tag_timeout(dpp, y, timeout);
 }
 
 int FilterBucket::purge_instance(const DoutPrefixProvider* dpp, optional_yield y)

diff --git a/src/rgw/rgw_sal_filter.h b/src/rgw/rgw_sal_filter.h
index b3e3a031d74751a7106a4c72ed5ec94ed9689c59..52e4a4120e7e1e414e08567c0345b2c641c53969 100644 (file)
--- a/src/rgw/rgw_sal_filter.h
+++ b/src/rgw/rgw_sal_filter.h
@@ -582,7 +582,7 @@ public:
                     const CreateParams& params,
                     optional_yield y) override;
   virtual int load_bucket(const DoutPrefixProvider* dpp, optional_yield y) override;
-  virtual int read_stats(const DoutPrefixProvider *dpp,
+  virtual int read_stats(const DoutPrefixProvider *dpp, optional_yield y,
                         const bucket_index_layout_generation& idx_layout,
                         int shard_id, std::string* bucket_ver, std::string* master_ver,
                         std::map<RGWObjCategory, RGWStorageStats>& stats,
@@ -618,13 +618,13 @@ public:
   virtual int remove_objs_from_index(const DoutPrefixProvider *dpp,
                                     std::list<rgw_obj_index_key>&
                                     objs_to_unlink) override;
-  virtual int check_index(const DoutPrefixProvider *dpp,
+  virtual int check_index(const DoutPrefixProvider *dpp, optional_yield y,
                          std::map<RGWObjCategory, RGWStorageStats>&
                          existing_stats,
                          std::map<RGWObjCategory, RGWStorageStats>&
                          calculated_stats) override;
-  virtual int rebuild_index(const DoutPrefixProvider *dpp) override;
-  virtual int set_tag_timeout(const DoutPrefixProvider *dpp, uint64_t timeout) override;
+  virtual int rebuild_index(const DoutPrefixProvider *dpp, optional_yield y) override;
+  virtual int set_tag_timeout(const DoutPrefixProvider *dpp, optional_yield y, uint64_t timeout) override;
   virtual int purge_instance(const DoutPrefixProvider* dpp, optional_yield y) override;
   virtual bool empty() const override { return next->empty(); }
   virtual const std::string& get_name() const override { return next->get_name(); }
@@ -785,8 +785,10 @@ public:
   virtual bool is_prefetch_data() override { return next->is_prefetch_data(); }
   virtual void set_compressed() override { return next->set_compressed(); }
   virtual bool is_compressed() override { return next->is_compressed(); }
-  virtual bool is_sync_completed(const DoutPrefixProvider* dpp,
-    const ceph::real_time& obj_mtime) override { return next->is_sync_completed(dpp, obj_mtime); }
+  bool is_sync_completed(const DoutPrefixProvider* dpp, optional_yield y,
+                         const ceph::real_time& obj_mtime) override {
+    return next->is_sync_completed(dpp, y, obj_mtime);
+  }
   virtual void invalidate() override { return next->invalidate(); }
   virtual bool empty() const override { return next->empty(); }
   virtual const std::string &get_name() const override { return next->get_name(); }

diff --git a/src/rgw/rgw_sal_store.h b/src/rgw/rgw_sal_store.h
index 524a879eede47782f313a0c244a682c0cd9e311b..2bad882c52a41aa36eba37d259ad8b494ebb7207 100644 (file)
--- a/src/rgw/rgw_sal_store.h
+++ b/src/rgw/rgw_sal_store.h
@@ -299,8 +299,6 @@ class StoreObject : public Object {
     virtual bool is_prefetch_data() override { return state.prefetch_data; }
     virtual void set_compressed() override { state.compressed = true; }
     virtual bool is_compressed() override { return state.compressed; }
-    virtual bool is_sync_completed(const DoutPrefixProvider* dpp,
-      const ceph::real_time& obj_mtime) override { return false; }
     virtual void invalidate() override {
       rgw_obj obj = state.obj;
       bool is_atomic = state.is_atomic;

diff --git a/src/rgw/services/svc_bi.h b/src/rgw/services/svc_bi.h
index 3ab61e7421ae9d41e54e2dd2920c03779322bb2d..516c08402c196fcff7356c54184a7ddae549fb95 100644 (file)
--- a/src/rgw/services/svc_bi.h
+++ b/src/rgw/services/svc_bi.h
@@ -29,11 +29,11 @@ public:
   RGWSI_BucketIndex(CephContext *cct) : RGWServiceInstance(cct) {}
   virtual ~RGWSI_BucketIndex() {}
 
-  virtual int init_index(const DoutPrefixProvider *dpp,
+  virtual int init_index(const DoutPrefixProvider *dpp, optional_yield y,
                          const RGWBucketInfo& bucket_info,
                          const rgw::bucket_index_layout_generation& idx_layout,
                          bool judge_support_logrecord = false) = 0;
-  virtual int clean_index(const DoutPrefixProvider *dpp,
+  virtual int clean_index(const DoutPrefixProvider *dpp, optional_yield y,
                           const RGWBucketInfo& bucket_info,
                           const rgw::bucket_index_layout_generation& idx_layout) = 0;
 

diff --git a/src/rgw/services/svc_bi_rados.cc b/src/rgw/services/svc_bi_rados.cc
index 98e6b87bcf7be239a9865b37a102c478a84c4a36..a82aae180b8d5baab1053902df7432a052a66211 100644 (file)
--- a/src/rgw/services/svc_bi_rados.cc
+++ b/src/rgw/services/svc_bi_rados.cc
@@ -355,6 +355,7 @@ int RGWSI_BucketIndex_RADOS::cls_bucket_head(const DoutPrefixProvider *dpp,
 }
 
 int RGWSI_BucketIndex_RADOS::init_index(const DoutPrefixProvider *dpp,
+                                        optional_yield y,
                                         const RGWBucketInfo& bucket_info,
                                         const rgw::bucket_index_layout_generation& idx_layout,
                                         bool judge_support_logrecord)
@@ -388,7 +389,9 @@ int RGWSI_BucketIndex_RADOS::init_index(const DoutPrefixProvider *dpp,
   }
 }
 
-int RGWSI_BucketIndex_RADOS::clean_index(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info,
+int RGWSI_BucketIndex_RADOS::clean_index(const DoutPrefixProvider *dpp,
+                                         optional_yield y,
+                                         const RGWBucketInfo& bucket_info,
                                          const rgw::bucket_index_layout_generation& idx_layout)
 {
   if (idx_layout.layout.type != rgw::BucketIndexType::Normal) {
@@ -449,7 +452,10 @@ int RGWSI_BucketIndex_RADOS::read_stats(const DoutPrefixProvider *dpp,
   return 0;
 }
 
-int RGWSI_BucketIndex_RADOS::get_reshard_status(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, list<cls_rgw_bucket_instance_entry> *status)
+int RGWSI_BucketIndex_RADOS::get_reshard_status(const DoutPrefixProvider *dpp,
+                                                optional_yield y,
+                                                const RGWBucketInfo& bucket_info,
+                                                list<cls_rgw_bucket_instance_entry> *status)
 {
   map<int, string> bucket_objs;
 
@@ -481,6 +487,7 @@ int RGWSI_BucketIndex_RADOS::get_reshard_status(const DoutPrefixProvider *dpp, c
 }
 
 int RGWSI_BucketIndex_RADOS::set_reshard_status(const DoutPrefixProvider *dpp,
+                                                optional_yield y,
                                                 const RGWBucketInfo& bucket_info,
                                                 cls_rgw_reshard_status status)
 {
@@ -543,9 +550,9 @@ int RGWSI_BucketIndex_RADOS::handle_overwrite(const DoutPrefixProvider *dpp,
 
   int ret;
   if (!new_sync_enabled) {
-    ret = svc.bilog->log_stop(dpp, info, bilog, -1);
+    ret = svc.bilog->log_stop(dpp, y, info, bilog, -1);
   } else {
-    ret = svc.bilog->log_start(dpp, info, bilog, -1);
+    ret = svc.bilog->log_start(dpp, y, info, bilog, -1);
   }
   if (ret < 0) {
     ldpp_dout(dpp, -1) << "ERROR: failed writing bilog (bucket=" << info.bucket << "); ret=" << ret << dendl;

diff --git a/src/rgw/services/svc_bi_rados.h b/src/rgw/services/svc_bi_rados.h
index ba9aee88ff868e0fc0787673607dc411cc8a0fd3..24a9fa14a68a083bb2b85dee7e761c4dc78f7c36 100644 (file)
--- a/src/rgw/services/svc_bi_rados.h
+++ b/src/rgw/services/svc_bi_rados.h
@@ -121,11 +121,11 @@ public:
     return bucket_shard_index(sharding_key, num_shards);
   }
 
-  int init_index(const DoutPrefixProvider *dpp,
+  int init_index(const DoutPrefixProvider *dpp, optional_yield y,
                  const RGWBucketInfo& bucket_info,
                  const rgw::bucket_index_layout_generation& idx_layout,
                  bool judge_support_logrecord = false) override;
-  int clean_index(const DoutPrefixProvider *dpp,
+  int clean_index(const DoutPrefixProvider *dpp, optional_yield y,
                   const RGWBucketInfo& bucket_info,
                   const rgw::bucket_index_layout_generation& idx_layout) override;
 
@@ -136,9 +136,10 @@ public:
                  RGWBucketEnt *stats,
                  optional_yield y) override;
 
-  int get_reshard_status(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info,
+  int get_reshard_status(const DoutPrefixProvider *dpp, optional_yield y,
+                         const RGWBucketInfo& bucket_info,
                          std::list<cls_rgw_bucket_instance_entry> *status);
-  int set_reshard_status(const DoutPrefixProvider *dpp,
+  int set_reshard_status(const DoutPrefixProvider *dpp, optional_yield y,
                          const RGWBucketInfo& bucket_info,
                          cls_rgw_reshard_status status);
   int trim_reshard_log(const DoutPrefixProvider* dpp, optional_yield,

diff --git a/src/rgw/services/svc_bilog_rados.cc b/src/rgw/services/svc_bilog_rados.cc
index 1212f104815571334b432d712c6376fc0e52bbf4..71bcbd5660d585b82041d347905744662ac1f1cc 100644 (file)
--- a/src/rgw/services/svc_bilog_rados.cc
+++ b/src/rgw/services/svc_bilog_rados.cc
@@ -20,7 +20,7 @@ void RGWSI_BILog_RADOS::init(RGWSI_BucketIndex_RADOS *bi_rados_svc)
   svc.bi = bi_rados_svc;
 }
 
-int RGWSI_BILog_RADOS::log_trim(const DoutPrefixProvider *dpp,
+int RGWSI_BILog_RADOS::log_trim(const DoutPrefixProvider *dpp, optional_yield y,
                                const RGWBucketInfo& bucket_info,
                                const rgw::bucket_log_layout_generation& log_layout,
                                int shard_id,
@@ -54,7 +54,10 @@ int RGWSI_BILog_RADOS::log_trim(const DoutPrefixProvider *dpp,
                              cct->_conf->rgw_bucket_index_max_aio)();
 }
 
-int RGWSI_BILog_RADOS::log_start(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_log_layout_generation& log_layout, int shard_id)
+int RGWSI_BILog_RADOS::log_start(const DoutPrefixProvider *dpp, optional_yield y,
+                                 const RGWBucketInfo& bucket_info,
+                                 const rgw::bucket_log_layout_generation& log_layout,
+                                 int shard_id)
 {
   librados::IoCtx index_pool;
   map<int, string> bucket_objs;
@@ -67,7 +70,10 @@ int RGWSI_BILog_RADOS::log_start(const DoutPrefixProvider *dpp, const RGWBucketI
   return CLSRGWIssueResyncBucketBILog(index_pool, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
 }
 
-int RGWSI_BILog_RADOS::log_stop(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_log_layout_generation& log_layout, int shard_id)
+int RGWSI_BILog_RADOS::log_stop(const DoutPrefixProvider *dpp, optional_yield y,
+                                const RGWBucketInfo& bucket_info,
+                                const rgw::bucket_log_layout_generation& log_layout,
+                                int shard_id)
 {
   librados::IoCtx index_pool;
   map<int, string> bucket_objs;
@@ -90,7 +96,7 @@ static void build_bucket_index_marker(const string& shard_id_str,
   }
 }
 
-int RGWSI_BILog_RADOS::log_list(const DoutPrefixProvider *dpp,
+int RGWSI_BILog_RADOS::log_list(const DoutPrefixProvider *dpp, optional_yield y,
                                const RGWBucketInfo& bucket_info,
                                const rgw::bucket_log_layout_generation& log_layout,
                                int shard_id, string& marker, uint32_t max,

diff --git a/src/rgw/services/svc_bilog_rados.h b/src/rgw/services/svc_bilog_rados.h
index e9c948d3fa2746c97ddc87d0f507e58a2a7c519e..ab36e4fbd656ced030df68b3662e2f24fbafffca 100644 (file)
--- a/src/rgw/services/svc_bilog_rados.h
+++ b/src/rgw/services/svc_bilog_rados.h
@@ -29,15 +29,23 @@ public:
 
   void init(RGWSI_BucketIndex_RADOS *bi_rados_svc);
 
-  int log_start(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_log_layout_generation& log_layout, int shard_id);
-  int log_stop(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_log_layout_generation& log_layout, int shard_id);
+  int log_start(const DoutPrefixProvider *dpp, optional_yield y,
+                const RGWBucketInfo& bucket_info,
+                const rgw::bucket_log_layout_generation& log_layout,
+                int shard_id);
+  int log_stop(const DoutPrefixProvider *dpp, optional_yield y,
+               const RGWBucketInfo& bucket_info,
+               const rgw::bucket_log_layout_generation& log_layout,
+               int shard_id);
 
-  int log_trim(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info,
+  int log_trim(const DoutPrefixProvider *dpp, optional_yield y,
+               const RGWBucketInfo& bucket_info,
                const rgw::bucket_log_layout_generation& log_layout,
                int shard_id,
                std::string_view start_marker,
                std::string_view end_marker);
-  int log_list(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info,
+  int log_list(const DoutPrefixProvider *dpp, optional_yield y,
+               const RGWBucketInfo& bucket_info,
                const rgw::bucket_log_layout_generation& log_layout,
                int shard_id,
                std::string& marker,