src/rados: Changing null_yield to optional_yield

Passing optional_yield at all places in rgw_bucket.cc

Signed-off-by: Kalpesh Pandya <kapandya@redhat.com>

diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc
index a83e5fba808782f90bab3ccbda39e584387a3b11..a321380d1203097200d19445a294d8ae1da9b258 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.cc
+++ b/src/rgw/driver/rados/rgw_bucket.cc
@@ -142,7 +142,7 @@ bool rgw_bucket_object_check_filter(const std::string& oid)
   return rgw_obj_key::oid_to_key_in_ns(oid, &key, empty_ns);
 }
 
-int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key)
+int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key, optional_yield y)
 {
   if (key.instance.empty()) {
     key.instance = "null";
@@ -150,7 +150,7 @@ int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, r
 
   std::unique_ptr<rgw::sal::Object> object = bucket->get_object(key);
 
-  return object->delete_object(dpp, null_yield);
+  return object->delete_object(dpp, y);
 }
 
 static void set_err_msg(std::string *sink, std::string msg)
@@ -267,7 +267,7 @@ int RGWBucket::set_quota(RGWBucketAdminOpState& op_state, const DoutPrefixProvid
   return r;
 }
 
-int RGWBucket::remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, std::string *err_msg)
+int RGWBucket::remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg)
 {
   std::string object_name = op_state.get_object_name();
 
@@ -275,7 +275,7 @@ int RGWBucket::remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpStat
 
   bucket = op_state.get_bucket()->clone();
 
-  int ret = rgw_remove_object(dpp, driver, bucket.get(), key);
+  int ret = rgw_remove_object(dpp, driver, bucket.get(), key, y);
   if (ret < 0) {
     set_err_msg(err_msg, "unable to remove object" + cpp_strerror(-ret));
     return ret;
@@ -321,7 +321,7 @@ static void dump_index_check(map<RGWObjCategory, RGWStorageStats> existing_stats
 
 int RGWBucket::check_bad_index_multipart(RGWBucketAdminOpState& op_state,
                                         RGWFormatterFlusher& flusher,
-                                        const DoutPrefixProvider *dpp,
+                                        const DoutPrefixProvider *dpp, optional_yield y,
                                         std::string *err_msg)
 {
   const bool fix_index = op_state.will_fix_index();
@@ -337,7 +337,7 @@ int RGWBucket::check_bad_index_multipart(RGWBucketAdminOpState& op_state,
   bool is_truncated;
   do {
     rgw::sal::Bucket::ListResults results;
-    int r = bucket->list(dpp, params, listing_max_entries, results, null_yield);
+    int r = bucket->list(dpp, params, listing_max_entries, results, y);
     if (r < 0) {
       set_err_msg(err_msg, "failed to list objects in bucket=" + bucket->get_name() +
               " err=" +  cpp_strerror(-r));
@@ -572,15 +572,15 @@ int RGWBucket::get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolic
 
 
 int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                  RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp)
+                  RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp, optional_yield y)
 {
   RGWBucket bucket;
 
-  int ret = bucket.init(driver, op_state, null_yield, dpp);
+  int ret = bucket.init(driver, op_state, y, dpp);
   if (ret < 0)
     return ret;
 
-  ret = bucket.get_policy(op_state, policy, null_yield, dpp);
+  ret = bucket.get_policy(op_state, policy, y, dpp);
   if (ret < 0)
     return ret;
 
@@ -591,11 +591,11 @@ int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState
 
 
 int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                  RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp)
+                  RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y)
 {
   RGWAccessControlPolicy policy(driver->ctx());
 
-  int ret = get_policy(driver, op_state, policy, dpp);
+  int ret = get_policy(driver, op_state, policy, dpp, y);
   if (ret < 0)
     return ret;
 
@@ -613,11 +613,11 @@ int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState
 }
 
 int RGWBucketAdminOp::dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                  ostream& os, const DoutPrefixProvider *dpp)
+                  ostream& os, const DoutPrefixProvider *dpp, optional_yield y)
 {
   RGWAccessControlPolicy_S3 policy(driver->ctx());
 
-  int ret = get_policy(driver, op_state, policy, dpp);
+  int ret = get_policy(driver, op_state, policy, dpp, y);
   if (ret < 0)
     return ret;
 
@@ -626,18 +626,18 @@ int RGWBucketAdminOp::dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpS
   return 0;
 }
 
-int RGWBucketAdminOp::unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp)
+int RGWBucketAdminOp::unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y)
 {
   RGWBucket bucket;
 
-  int ret = bucket.init(driver, op_state, null_yield, dpp);
+  int ret = bucket.init(driver, op_state, y, dpp);
   if (ret < 0)
     return ret;
 
-  return static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(op_state.get_user_id(), op_state.get_bucket()->get_info().bucket, null_yield, dpp, true);
+  return static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(op_state.get_user_id(), op_state.get_bucket()->get_info().bucket, y, dpp, true);
 }
 
-int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, string *err)
+int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, string *err)
 {
   if (!op_state.is_user_op()) {
     set_err_msg(err, "empty user id");
@@ -645,7 +645,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
   }
 
   RGWBucket bucket;
-  int ret = bucket.init(driver, op_state, null_yield, dpp, err);
+  int ret = bucket.init(driver, op_state, y, dpp, err);
   if (ret < 0)
     return ret;
 
@@ -700,7 +700,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
     return -EIO;
   }
 
-  int r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(owner.get_id(), old_bucket->get_info().bucket, null_yield, dpp, false);
+  int r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(owner.get_id(), old_bucket->get_info().bucket, y, dpp, false);
   if (r < 0) {
     set_err_msg(err, "could not unlink policy from user " + owner.get_id().to_str());
     return r;
@@ -741,7 +741,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
   rgw::sal::Attrs ep_attrs;
   rgw_ep_info ep_data{ep, ep_attrs};
 
-  r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->link_bucket(op_state.get_user_id(), loc_bucket->get_info().bucket, loc_bucket->get_info().creation_time, null_yield, dpp, true, &ep_data);
+  r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->link_bucket(op_state.get_user_id(), loc_bucket->get_info().bucket, loc_bucket->get_info().creation_time, y, dpp, true, &ep_data);
   if (r < 0) {
     set_err_msg(err, "failed to relink bucket");
     return r;
@@ -750,7 +750,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
   if (*loc_bucket != *old_bucket) {
     // like RGWRados::delete_bucket -- excepting no bucket_index work.
     r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->remove_bucket_entrypoint_info(
-                                       old_bucket->get_key(), null_yield, dpp,
+                                       old_bucket->get_key(), y, dpp,
                                        RGWBucketCtl::Bucket::RemoveParams()
                                        .set_objv_tracker(&ep_data.ep_objv));
     if (r < 0) {
@@ -759,7 +759,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
     }
     r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->remove_bucket_instance_info(
                                        old_bucket->get_key(), old_bucket->get_info(),
-                                       null_yield, dpp,
+                                       y, dpp,
                                        RGWBucketCtl::BucketInstance::RemoveParams()
                                        .set_objv_tracker(&ep_data.ep_objv));
     if (r < 0) {
@@ -771,15 +771,15 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
   return 0;
 }
 
-int RGWBucketAdminOp::chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const string& marker, const DoutPrefixProvider *dpp, string *err)
+int RGWBucketAdminOp::chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const string& marker, const DoutPrefixProvider *dpp, optional_yield y, string *err)
 {
   RGWBucket bucket;
 
-  int ret = bucket.init(driver, op_state, null_yield, dpp, err);
+  int ret = bucket.init(driver, op_state, y, dpp, err);
   if (ret < 0)
     return ret;
 
-  return bucket.chown(op_state, marker, null_yield, dpp, err);
+  return bucket.chown(op_state, marker, y, dpp, err);
 
 }
 
@@ -793,14 +793,14 @@ int RGWBucketAdminOp::check_index(rgw::sal::Driver* driver, RGWBucketAdminOpStat
 
   RGWBucket bucket;
 
-  ret = bucket.init(driver, op_state, null_yield, dpp);
+  ret = bucket.init(driver, op_state, y, dpp);
   if (ret < 0)
     return ret;
 
   Formatter *formatter = flusher.get_formatter();
   flusher.start(0);
 
-  ret = bucket.check_bad_index_multipart(op_state, flusher, dpp);
+  ret = bucket.check_bad_index_multipart(op_state, flusher, dpp, y);
   if (ret < 0)
     return ret;
 
@@ -839,21 +839,21 @@ int RGWBucketAdminOp::remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpSt
   return ret;
 }
 
-int RGWBucketAdminOp::remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp)
+int RGWBucketAdminOp::remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y)
 {
   RGWBucket bucket;
 
-  int ret = bucket.init(driver, op_state, null_yield, dpp);
+  int ret = bucket.init(driver, op_state, y, dpp);
   if (ret < 0)
     return ret;
 
-  return bucket.remove_object(dpp, op_state);
+  return bucket.remove_object(dpp, op_state, y);
 }
 
-int RGWBucketAdminOp::sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, string *err_msg)
+int RGWBucketAdminOp::sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, string *err_msg)
 {
   RGWBucket bucket;
-  int ret = bucket.init(driver, op_state, null_yield, dpp, err_msg);
+  int ret = bucket.init(driver, op_state, y, dpp, err_msg);
   if (ret < 0)
   {
     return ret;
@@ -865,12 +865,12 @@ static int bucket_stats(rgw::sal::Driver* driver,
                        const std::string& tenant_name,
                        const std::string& bucket_name,
                        Formatter *formatter,
-                        const DoutPrefixProvider *dpp)
+                        const DoutPrefixProvider *dpp, optional_yield y)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
   map<RGWObjCategory, RGWStorageStats> stats;
 
-  int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, null_yield);
+  int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, y);
   if (ret < 0) {
     return ret;
   }
@@ -1101,7 +1101,7 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
         }
 
         if (show_stats) {
-          bucket_stats(driver, user_id.tenant, obj_name, formatter, dpp);
+          bucket_stats(driver, user_id.tenant, obj_name, formatter, dpp, y);
        } else {
           formatter->dump_string("bucket", obj_name);
        }
@@ -1117,7 +1117,7 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
 
     formatter->close_section();
   } else if (!bucket_name.empty()) {
-    ret = bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp);
+    ret = bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp, y);
     if (ret < 0) {
       return ret;
     }
@@ -1134,7 +1134,7 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
                                                   &truncated);
       for (auto& bucket_name : buckets) {
         if (show_stats) {
-          bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp);
+          bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp, y);
        } else {
           formatter->dump_string("bucket", bucket_name);
        }
@@ -1150,11 +1150,11 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
   return 0;
 }
 
-int RGWBucketAdminOp::set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp)
+int RGWBucketAdminOp::set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y)
 {
   RGWBucket bucket;
 
-  int ret = bucket.init(driver, op_state, null_yield, dpp);
+  int ret = bucket.init(driver, op_state, y, dpp);
   if (ret < 0)
     return ret;
   return bucket.set_quota(op_state, dpp);
@@ -1172,7 +1172,7 @@ using bucket_instance_ls = std::vector<RGWBucketInfo>;
 void get_stale_instances(rgw::sal::Driver* driver, const std::string& bucket_name,
                          const vector<std::string>& lst,
                          bucket_instance_ls& stale_instances,
-                         const DoutPrefixProvider *dpp)
+                         const DoutPrefixProvider *dpp, optional_yield y)
 {
 
   bucket_instance_ls other_instances;
@@ -1183,7 +1183,7 @@ void get_stale_instances(rgw::sal::Driver* driver, const std::string& bucket_nam
     std::unique_ptr<rgw::sal::Bucket> bucket;
     rgw_bucket rbucket;
     rgw_bucket_parse_bucket_key(driver->ctx(), bucket_instance, &rbucket, nullptr);
-    int r = driver->get_bucket(dpp, nullptr, rbucket, &bucket, null_yield);
+    int r = driver->get_bucket(dpp, nullptr, rbucket, &bucket, y);
     if (r < 0){
       // this can only happen if someone deletes us right when we're processing
       ldpp_dout(dpp, -1) << "Bucket instance is invalid: " << bucket_instance
@@ -1203,7 +1203,7 @@ void get_stale_instances(rgw::sal::Driver* driver, const std::string& bucket_nam
   auto [tenant, bname] = split_tenant(bucket_name);
   RGWBucketInfo cur_bucket_info;
   std::unique_ptr<rgw::sal::Bucket> cur_bucket;
-  int r = driver->get_bucket(dpp, nullptr, tenant, bname, &cur_bucket, null_yield);
+  int r = driver->get_bucket(dpp, nullptr, tenant, bname, &cur_bucket, y);
   if (r < 0) {
     if (r == -ENOENT) {
       // bucket doesn't exist, everything is stale then
@@ -1264,7 +1264,7 @@ static int process_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpSta
                                    const DoutPrefixProvider *dpp,
                                    std::function<void(const bucket_instance_ls&,
                                                       Formatter *,
-                                                      rgw::sal::Driver*)> process_f)
+                                                      rgw::sal::Driver*)> process_f, optional_yield y)
 {
   std::string marker;
   void *handle;
@@ -1304,7 +1304,7 @@ static int process_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpSta
       }
       for (const auto& kv: bucket_instance_map) {
         bucket_instance_ls stale_lst;
-        get_stale_instances(driver, kv.first, kv.second, stale_lst, dpp);
+        get_stale_instances(driver, kv.first, kv.second, stale_lst, dpp, y);
         process_f(stale_lst, formatter, driver);
       }
     }
@@ -1316,7 +1316,7 @@ static int process_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpSta
 int RGWBucketAdminOp::list_stale_instances(rgw::sal::Driver* driver,
                                            RGWBucketAdminOpState& op_state,
                                            RGWFormatterFlusher& flusher,
-                                           const DoutPrefixProvider *dpp)
+                                           const DoutPrefixProvider *dpp, optional_yield y)
 {
   auto process_f = [](const bucket_instance_ls& lst,
                       Formatter *formatter,
@@ -1324,14 +1324,14 @@ int RGWBucketAdminOp::list_stale_instances(rgw::sal::Driver* driver,
                      for (const auto& binfo: lst)
                        formatter->dump_string("key", binfo.bucket.get_key());
                    };
-  return process_stale_instances(driver, op_state, flusher, dpp, process_f);
+  return process_stale_instances(driver, op_state, flusher, dpp, process_f, y);
 }
 
 
 int RGWBucketAdminOp::clear_stale_instances(rgw::sal::Driver* driver,
                                             RGWBucketAdminOpState& op_state,
                                             RGWFormatterFlusher& flusher,
-                                            const DoutPrefixProvider *dpp)
+                                            const DoutPrefixProvider *dpp, optional_yield y)
 {
   auto process_f = [dpp](const bucket_instance_ls& lst,
                       Formatter *formatter,
@@ -1351,16 +1351,16 @@ int RGWBucketAdminOp::clear_stale_instances(rgw::sal::Driver* driver,
                      }
                    };
 
-  return process_stale_instances(driver, op_state, flusher, dpp, process_f);
+  return process_stale_instances(driver, op_state, flusher, dpp, process_f, y);
 }
 
 static int fix_single_bucket_lc(rgw::sal::Driver* driver,
                                 const std::string& tenant_name,
                                 const std::string& bucket_name,
-                                const DoutPrefixProvider *dpp)
+                                const DoutPrefixProvider *dpp, optional_yield y)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, null_yield);
+  int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, y);
   if (ret < 0) {
     // TODO: Should we handle the case where the bucket could've been removed between
     // listing and fetching?
@@ -1388,7 +1388,7 @@ static void process_single_lc_entry(rgw::sal::Driver* driver,
                                     const std::string& bucket_name,
                                     const DoutPrefixProvider *dpp)
 {
-  int ret = fix_single_bucket_lc(driver, tenant_name, bucket_name, dpp);
+  int ret = fix_single_bucket_lc(driver, tenant_name, bucket_name, dpp, null_yield);
   format_lc_status(formatter, tenant_name, bucket_name, -ret);
 }
 
@@ -1446,12 +1446,12 @@ int RGWBucketAdminOp::fix_lc_shards(rgw::sal::Driver* driver,
 static bool has_object_expired(const DoutPrefixProvider *dpp,
                               rgw::sal::Driver* driver,
                               rgw::sal::Bucket* bucket,
-                              const rgw_obj_key& key, utime_t& delete_at)
+                              const rgw_obj_key& key, utime_t& delete_at, optional_yield y)
 {
   std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
   bufferlist delete_at_bl;
 
-  int ret = rgw_object_get_attr(dpp, driver, obj.get(), RGW_ATTR_DELETE_AT, delete_at_bl, null_yield);
+  int ret = rgw_object_get_attr(dpp, driver, obj.get(), RGW_ATTR_DELETE_AT, delete_at_bl, y);
   if (ret < 0) {
     return false;  // no delete at attr, proceed
   }
@@ -1471,7 +1471,7 @@ static bool has_object_expired(const DoutPrefixProvider *dpp,
 static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
                                 rgw::sal::Driver* driver,
                                 rgw::sal::Bucket* bucket,
-                                RGWFormatterFlusher& flusher, bool dry_run)
+                                RGWFormatterFlusher& flusher, bool dry_run, optional_yield y)
 {
   if (bucket->get_key().bucket_id == bucket->get_key().marker) {
     ldpp_dout(dpp, -1) << "Not a resharded bucket skipping" << dendl;
@@ -1492,7 +1492,7 @@ static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
   params.allow_unordered = true;
 
   do {
-    int ret = bucket->list(dpp, params, listing_max_entries, results, null_yield);
+    int ret = bucket->list(dpp, params, listing_max_entries, results, y);
     if (ret < 0) {
       ldpp_dout(dpp, -1) << "ERROR failed to list objects in the bucket" << dendl;
       return ret;
@@ -1500,13 +1500,13 @@ static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
     for (const auto& obj : results.objs) {
       rgw_obj_key key(obj.key);
       utime_t delete_at;
-      if (has_object_expired(dpp, driver, bucket, key, delete_at)) {
+      if (has_object_expired(dpp, driver, bucket, key, delete_at, y)) {
        formatter->open_object_section("object_status");
        formatter->dump_string("object", key.name);
        formatter->dump_stream("delete_at") << delete_at;
 
        if (!dry_run) {
-         ret = rgw_remove_object(dpp, driver, bucket, key);
+         ret = rgw_remove_object(dpp, driver, bucket, key, y);
          formatter->dump_int("status", ret);
        }
 
@@ -1522,10 +1522,10 @@ static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
 int RGWBucketAdminOp::fix_obj_expiry(rgw::sal::Driver* driver,
                                     RGWBucketAdminOpState& op_state,
                                     RGWFormatterFlusher& flusher,
-                                     const DoutPrefixProvider *dpp, bool dry_run)
+                                     const DoutPrefixProvider *dpp, optional_yield y, bool dry_run)
 {
   RGWBucket admin_bucket;
-  int ret = admin_bucket.init(driver, op_state, null_yield, dpp);
+  int ret = admin_bucket.init(driver, op_state, y, dpp);
   if (ret < 0) {
     ldpp_dout(dpp, -1) << "failed to initialize bucket" << dendl;
     return ret;
@@ -1536,7 +1536,7 @@ int RGWBucketAdminOp::fix_obj_expiry(rgw::sal::Driver* driver,
     return ret;
   }
 
-  return fix_bucket_obj_expiry(dpp, driver, bucket.get(), flusher, dry_run);
+  return fix_bucket_obj_expiry(dpp, driver, bucket.get(), flusher, dry_run, y);
 }
 
 void RGWBucketCompleteInfo::dump(Formatter *f) const {

diff --git a/src/rgw/driver/rados/rgw_bucket.h b/src/rgw/driver/rados/rgw_bucket.h
index c6aafd3be1a8c63100444007018beaaeb2f121de..7788d5aa56dc53d49877a5d2afab97c87accb724 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.h
+++ b/src/rgw/driver/rados/rgw_bucket.h
@@ -207,7 +207,7 @@ public:
   static RGWBucketInstanceMetadataHandlerBase *alloc(rgw::sal::Driver* driver);
 };
 
-extern int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key);
+extern int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key, optional_yield y);
 
 extern int rgw_object_get_attr(rgw::sal::Driver* driver, rgw::sal::Object* obj,
                               const char* attr_name, bufferlist& out_bl,
@@ -325,7 +325,7 @@ public:
 
   int check_bad_index_multipart(RGWBucketAdminOpState& op_state,
               RGWFormatterFlusher& flusher,
-              const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
+              const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL);
 
   int check_object_index(const DoutPrefixProvider *dpp, 
                          RGWBucketAdminOpState& op_state,
@@ -343,7 +343,7 @@ public:
             optional_yield y, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
   int set_quota(RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 
-  int remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
+  int remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg = NULL);
   int policy_bl_to_stream(bufferlist& bl, std::ostream& o);
   int get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolicy& policy, optional_yield y, const DoutPrefixProvider *dpp);
   int sync(RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
@@ -356,41 +356,41 @@ public:
 class RGWBucketAdminOp {
 public:
   static int get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                  RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
+                  RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y);
   static int get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                  RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp);
+                  RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp, optional_yield y);
   static int dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                  std::ostream& os, const DoutPrefixProvider *dpp);
+                  std::ostream& os, const DoutPrefixProvider *dpp, optional_yield y);
 
-  static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
-  static int link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
-  static int chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const std::string& marker, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
+  static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y);
+  static int link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL);
+  static int chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const std::string& marker, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL);
 
   static int check_index(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
                   RGWFormatterFlusher& flusher, optional_yield y, const DoutPrefixProvider *dpp);
 
   static int remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, optional_yield y,
                           const DoutPrefixProvider *dpp, bool bypass_gc = false, bool keep_index_consistent = true);
-  static int remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
+  static int remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y);
   static int info(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher, optional_yield y, const DoutPrefixProvider *dpp);
   static int limit_check(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
                         const std::list<std::string>& user_ids,
                         RGWFormatterFlusher& flusher, optional_yield y,
                          const DoutPrefixProvider *dpp,
                         bool warnings_only = false);
-  static int set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
+  static int set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y);
 
   static int list_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                                 RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
+                                 RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y);
 
   static int clear_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                                  RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
+                                  RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y);
   static int fix_lc_shards(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
                            RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
   static int fix_obj_expiry(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
-                           RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, bool dry_run = false);
+                           RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y, bool dry_run = false);
 
-  static int sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
+  static int sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL);
 };
 
 struct rgw_ep_info {

diff --git a/src/rgw/driver/rados/rgw_rest_bucket.cc b/src/rgw/driver/rados/rgw_rest_bucket.cc
index ebe4e429cc9833c5862bca77a35b7cdd743332ba..69e3f42f15e23338619002537d2036de70bb3712 100644 (file)
--- a/src/rgw/driver/rados/rgw_rest_bucket.cc
+++ b/src/rgw/driver/rados/rgw_rest_bucket.cc
@@ -79,7 +79,7 @@ void RGWOp_Get_Policy::execute(optional_yield y)
   op_state.set_bucket_name(bucket);
   op_state.set_object(object);
 
-  op_ret = RGWBucketAdminOp::get_policy(driver, op_state, flusher, this);
+  op_ret = RGWBucketAdminOp::get_policy(driver, op_state, flusher, this, y);
 }
 
 class RGWOp_Check_Bucket_Index : public RGWRESTOp {
@@ -156,7 +156,7 @@ void RGWOp_Bucket_Link::execute(optional_yield y)
     ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
     return;
   }
-  op_ret = RGWBucketAdminOp::link(driver, op_state, s);
+  op_ret = RGWBucketAdminOp::link(driver, op_state, s, y);
 }
 
 class RGWOp_Bucket_Unlink : public RGWRESTOp {
@@ -194,7 +194,7 @@ void RGWOp_Bucket_Unlink::execute(optional_yield y)
     ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
     return;
   }
-  op_ret = RGWBucketAdminOp::unlink(driver, op_state, s);
+  op_ret = RGWBucketAdminOp::unlink(driver, op_state, s, y);
 }
 
 class RGWOp_Bucket_Remove : public RGWRESTOp {
@@ -310,7 +310,7 @@ void RGWOp_Set_Bucket_Quota::execute(optional_yield y)
   op_state.set_bucket_name(bucket_name);
   op_state.set_quota(quota);
 
-  op_ret = RGWBucketAdminOp::set_quota(driver, op_state, s);
+  op_ret = RGWBucketAdminOp::set_quota(driver, op_state, s, y);
 }
 
 class RGWOp_Sync_Bucket : public RGWRESTOp {
@@ -342,7 +342,7 @@ void RGWOp_Sync_Bucket::execute(optional_yield y)
   op_state.set_tenant(tenant);
   op_state.set_sync_bucket(sync_bucket);
 
-  op_ret = RGWBucketAdminOp::sync_bucket(driver, op_state, s);
+  op_ret = RGWBucketAdminOp::sync_bucket(driver, op_state, s, y);
 }
 
 class RGWOp_Object_Remove: public RGWRESTOp {
@@ -372,7 +372,7 @@ void RGWOp_Object_Remove::execute(optional_yield y)
   op_state.set_bucket_name(bucket);
   op_state.set_object(object);
 
-  op_ret = RGWBucketAdminOp::remove_object(driver, op_state, s);
+  op_ret = RGWBucketAdminOp::remove_object(driver, op_state, s, y);
 }
 
 

diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc
index 1c911c441be5a1a6ef6457ce46f2163064910a94..2f0b6d94f675f91c79b7e8fcb2bf2c9512a0b7c7 100644 (file)
--- a/src/rgw/driver/rados/rgw_sal_rados.cc
+++ b/src/rgw/driver/rados/rgw_sal_rados.cc
@@ -438,7 +438,7 @@ int RadosBucket::remove_bucket(const DoutPrefixProvider* dpp,
     for (const auto& obj : results.objs) {
       rgw_obj_key key(obj.key);
       /* xxx dang */
-      ret = rgw_remove_object(dpp, store, this, key);
+      ret = rgw_remove_object(dpp, store, this, key, y);
       if (ret < 0 && ret != -ENOENT) {
        return ret;
       }

diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index e499eb1f3b12a2f5e97a644d5d8716903338b99b..e82ddf163ee85b91d2108e261c5fd323112e58f9 100644 (file)
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -6900,13 +6900,13 @@ int main(int argc, const char **argv)
 
   if (opt_cmd == OPT::POLICY) {
     if (format == "xml") {
-      int ret = RGWBucketAdminOp::dump_s3_policy(driver, bucket_op, cout, dpp());
+      int ret = RGWBucketAdminOp::dump_s3_policy(driver, bucket_op, cout, dpp(), null_yield);
       if (ret < 0) {
         cerr << "ERROR: failed to get policy: " << cpp_strerror(-ret) << std::endl;
         return -ret;
       }
     } else {
-      int ret = RGWBucketAdminOp::get_policy(driver, bucket_op, stream_flusher, dpp());
+      int ret = RGWBucketAdminOp::get_policy(driver, bucket_op, stream_flusher, dpp(), null_yield);
       if (ret < 0) {
         cerr << "ERROR: failed to get policy: " << cpp_strerror(-ret) << std::endl;
         return -ret;
@@ -7096,7 +7096,7 @@ int main(int argc, const char **argv)
     bucket_op.set_bucket_id(bucket_id);
     bucket_op.set_new_bucket_name(new_bucket_name);
     string err;
-    int r = RGWBucketAdminOp::link(driver, bucket_op, dpp(), &err);
+    int r = RGWBucketAdminOp::link(driver, bucket_op, dpp(), null_yield, &err);
     if (r < 0) {
       cerr << "failure: " << cpp_strerror(-r) << ": " << err << std::endl;
       return -r;
@@ -7104,7 +7104,7 @@ int main(int argc, const char **argv)
   }
 
   if (opt_cmd == OPT::BUCKET_UNLINK) {
-    int r = RGWBucketAdminOp::unlink(driver, bucket_op, dpp());
+    int r = RGWBucketAdminOp::unlink(driver, bucket_op, dpp(), null_yield);
     if (r < 0) {
       cerr << "failure: " << cpp_strerror(-r) << std::endl;
       return -r;
@@ -7179,7 +7179,7 @@ int main(int argc, const char **argv)
     bucket_op.set_new_bucket_name(new_bucket_name);
     string err;
 
-    int r = RGWBucketAdminOp::chown(driver, bucket_op, marker, dpp(), &err);
+    int r = RGWBucketAdminOp::chown(driver, bucket_op, marker, dpp(), null_yield, &err);
     if (r < 0) {
       cerr << "failure: " << cpp_strerror(-r) << ": " << err << std::endl;
       return -r;
@@ -7736,7 +7736,7 @@ next:
       return -ret;
     }
     rgw_obj_key key(object, object_version);
-    ret = rgw_remove_object(dpp(), driver, bucket.get(), key);
+    ret = rgw_remove_object(dpp(), driver, bucket.get(), key, null_yield);
 
     if (ret < 0) {
       cerr << "ERROR: object remove returned: " << cpp_strerror(-ret) << std::endl;
@@ -7863,7 +7863,7 @@ next:
   }
 
   if (opt_cmd == OPT::OBJECTS_EXPIRE_STALE_LIST) {
-    ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), true);
+    ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), null_yield, true);
     if (ret < 0) {
       cerr << "ERROR: listing returned " << cpp_strerror(-ret) << std::endl;
       return -ret;
@@ -7871,7 +7871,7 @@ next:
   }
 
   if (opt_cmd == OPT::OBJECTS_EXPIRE_STALE_RM) {
-    ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), false);
+    ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), null_yield, false);
     if (ret < 0) {
       cerr << "ERROR: removing returned " << cpp_strerror(-ret) << std::endl;
       return -ret;
@@ -9211,7 +9211,7 @@ next:
     }
     bucket_op.set_tenant(tenant);
     string err_msg;
-    ret = RGWBucketAdminOp::sync_bucket(driver, bucket_op, dpp(), &err_msg);
+    ret = RGWBucketAdminOp::sync_bucket(driver, bucket_op, dpp(), null_yield, &err_msg);
     if (ret < 0) {
       cerr << err_msg << std::endl;
       return -ret;
@@ -10397,7 +10397,7 @@ next:
      return EINVAL;
    }
 
-   ret = RGWBucketAdminOp::list_stale_instances(driver, bucket_op, stream_flusher, dpp());
+   ret = RGWBucketAdminOp::list_stale_instances(driver, bucket_op, stream_flusher, dpp(), null_yield);
    if (ret < 0) {
      cerr << "ERROR: listing stale instances" << cpp_strerror(-ret) << std::endl;
    }
@@ -10409,7 +10409,7 @@ next:
      return EINVAL;
    }
 
-   ret = RGWBucketAdminOp::clear_stale_instances(driver, bucket_op, stream_flusher, dpp());
+   ret = RGWBucketAdminOp::clear_stale_instances(driver, bucket_op, stream_flusher, dpp(), null_yield);
    if (ret < 0) {
      cerr << "ERROR: deleting stale instances" << cpp_strerror(-ret) << std::endl;
    }