rgw/lc: use flag and named constants instead of booleans as argument in interface

Signed-off-by: Juan Zhu <jzhu4@dev-10-34-20-139.pw1.bcc.bloomberg.com>

diff --git a/src/rgw/driver/d4n/rgw_sal_d4n.cc b/src/rgw/driver/d4n/rgw_sal_d4n.cc
index 8647519855d370a59fd4dc6cfea1b25c8002845c..e2624690ebdd6d3977a73b151ac979f3884112c1 100644 (file)
--- a/src/rgw/driver/d4n/rgw_sal_d4n.cc
+++ b/src/rgw/driver/d4n/rgw_sal_d4n.cc
@@ -361,7 +361,7 @@ int D4NFilterObject::D4NFilterReadOp::prepare(optional_yield y, const DoutPrefix
 }
 
 int D4NFilterObject::D4NFilterDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
-                                                   optional_yield y, bool log_op)
+                                                   optional_yield y, uint32_t flags)
 {
   int delDirReturn = source->filter->get_block_dir()->delValue(source->filter->get_cache_block());
 
@@ -379,7 +379,7 @@ int D4NFilterObject::D4NFilterDeleteOp::delete_obj(const DoutPrefixProvider* dpp
     ldpp_dout(dpp, 20) << "D4N Filter: Cache delete operation succeeded." << dendl;
   }
 
-  return next->delete_obj(dpp, y, log_op);
+  return next->delete_obj(dpp, y, flags);
 }
 
 int D4NFilterWriter::prepare(optional_yield y) 
@@ -416,7 +416,7 @@ int D4NFilterWriter::complete(size_t accounted_size, const std::string& etag,
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   cache_block* temp_cache_block = filter->get_cache_block();
   RGWBlockDirectory* temp_block_dir = filter->get_block_dir();
@@ -438,7 +438,7 @@ int D4NFilterWriter::complete(size_t accounted_size, const std::string& etag,
   RGWObjState* astate;
   int ret = next->complete(accounted_size, etag, mtime, set_mtime, attrs,
                        delete_at, if_match, if_nomatch, user_data, zones_trace,
-                       canceled, rctx, log_op);
+                       canceled, rctx, flags);
   obj->get_obj_attrs(rctx.y, save_dpp, NULL);
   obj->get_obj_state(save_dpp, &astate, rctx.y);
 

diff --git a/src/rgw/driver/d4n/rgw_sal_d4n.h b/src/rgw/driver/d4n/rgw_sal_d4n.h
index d6ab2f7351bf11764c48278fa644ed0a6c8bf56a..840eb99f6048f3dee56cdbd016e6fbab941d53b4 100644 (file)
--- a/src/rgw/driver/d4n/rgw_sal_d4n.h
+++ b/src/rgw/driver/d4n/rgw_sal_d4n.h
@@ -111,7 +111,7 @@ class D4NFilterObject : public FilterObject {
                                                                                     source(_source) {}
       virtual ~D4NFilterDeleteOp() = default;
 
-      virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) override;
+      virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) override;
     };
 
     D4NFilterObject(std::unique_ptr<Object> _next, D4NFilterDriver* _filter) : FilterObject(std::move(_next)),
@@ -178,7 +178,7 @@ class D4NFilterWriter : public FilterWriter {
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
    bool is_atomic() { return atomic; };
    const DoutPrefixProvider* dpp() { return save_dpp; }
 };

diff --git a/src/rgw/driver/daos/rgw_sal_daos.cc b/src/rgw/driver/daos/rgw_sal_daos.cc
index 6e6581be90186e11461fa857b42ebe129972ff06..43ae35be42658ab2759fef511e0822e1df954826 100644 (file)
--- a/src/rgw/driver/daos/rgw_sal_daos.cc
+++ b/src/rgw/driver/daos/rgw_sal_daos.cc
@@ -1018,7 +1018,7 @@ int DaosObject::transition(Bucket* bucket,
                            const rgw_placement_rule& placement_rule,
                            const real_time& mtime, uint64_t olh_epoch,
                            const DoutPrefixProvider* dpp, optional_yield y,
-                           bool log_op) {
+                           uint32_t flags) {
   return DAOS_NOT_IMPLEMENTED_LOG(dpp);
 }
 
@@ -1168,7 +1168,7 @@ DaosObject::DaosDeleteOp::DaosDeleteOp(DaosObject* _source) : source(_source) {}
 // 3. Handle empty directories
 // 4. Fail when file doesn't exist
 int DaosObject::DaosDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
-                                         optional_yield y, bool log_op) {
+                                         optional_yield y, uint32_t flags) {
   ldpp_dout(dpp, 20) << "DaosDeleteOp::delete_obj "
                      << source->get_key().get_oid() << " from "
                      << source->get_bucket()->get_name() << dendl;
@@ -1197,13 +1197,13 @@ int DaosObject::DaosDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
 }
 
 int DaosObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y,
-                              bool prevent_versioning) {
+                              uint32_t flags) {
   ldpp_dout(dpp, 20) << "DEBUG: delete_object" << dendl;
   DaosObject::DaosDeleteOp del_op(this);
   del_op.params.bucket_owner = bucket->get_info().owner;
   del_op.params.versioning_status = bucket->get_info().versioning_status();
 
-  return del_op.delete_obj(dpp, y);
+  return del_op.delete_obj(dpp, y, flags);
 }
 
 int DaosObject::copy_object(
@@ -1507,7 +1507,7 @@ int DaosAtomicWriter::complete(
     ceph::real_time set_mtime, std::map<std::string, bufferlist>& attrs,
     ceph::real_time delete_at, const char* if_match, const char* if_nomatch,
     const std::string* user_data, rgw_zone_set* zones_trace, bool* canceled,
-    optional_yield y, bool log_op) {
+    optional_yield y, uint32_t flags) {
   ldpp_dout(dpp, 20) << "DEBUG: complete" << dendl;
   bufferlist bl;
   rgw_bucket_dir_entry ent;
@@ -1564,7 +1564,7 @@ int DaosAtomicWriter::complete(
 }
 
 int DaosMultipartUpload::abort(const DoutPrefixProvider* dpp,
-                               CephContext* cct, optional_yield y, bool log_op) {
+                               CephContext* cct, optional_yield y) {
   // Remove upload from bucket multipart index
   ldpp_dout(dpp, 20) << "DEBUG: abort" << dendl;
   return ds3_upload_remove(bucket->get_name().c_str(), get_upload_id().c_str(),
@@ -2031,7 +2031,7 @@ int DaosMultipartWriter::complete(
     ceph::real_time set_mtime, std::map<std::string, bufferlist>& attrs,
     ceph::real_time delete_at, const char* if_match, const char* if_nomatch,
     const std::string* user_data, rgw_zone_set* zones_trace, bool* canceled,
-    const req_context& rctx, bool log_op) {
+    const req_context& rctx, uint32_t flags) {
   ldpp_dout(dpp, 20) << "DaosMultipartWriter::complete(): enter part="
                      << part_num_str << dendl;
 

diff --git a/src/rgw/driver/daos/rgw_sal_daos.h b/src/rgw/driver/daos/rgw_sal_daos.h
index db024169a8c912b87890c7c19aea2bddd48071fa..c5cfefc222d101a029a0ab608ccfba189737385a 100644 (file)
--- a/src/rgw/driver/daos/rgw_sal_daos.h
+++ b/src/rgw/driver/daos/rgw_sal_daos.h
@@ -581,7 +581,7 @@ class DaosObject : public StoreObject {
     DaosDeleteOp(DaosObject* _source);
 
     virtual int delete_obj(const DoutPrefixProvider* dpp,
-                           optional_yield y, bool log_op) override;
+                           optional_yield y, uint32_t flags) override;
   };
 
   ds3_obj_t* ds3o = nullptr;
@@ -598,7 +598,7 @@ class DaosObject : public StoreObject {
   virtual ~DaosObject();
 
   virtual int delete_object(const DoutPrefixProvider* dpp, optional_yield y,
-                            bool prevent_versioning = false) override;
+                            uint32_t flags) override;
   virtual int copy_object(
       User* user, req_info* info, const rgw_zone_id& source_zone,
       rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
@@ -642,7 +642,7 @@ class DaosObject : public StoreObject {
                          const real_time& mtime, uint64_t olh_epoch,
                          const DoutPrefixProvider* dpp,
                          optional_yield y,
-                         bool log_op) override;
+                         uint32_t flags) override;
   virtual int transition_to_cloud(Bucket* bucket, rgw::sal::PlacementTier* tier,
                                   rgw_bucket_dir_entry& o,
                                   std::set<std::string>& cloud_targets,
@@ -747,7 +747,7 @@ class DaosAtomicWriter : public StoreWriter {
                        const char* if_nomatch, const std::string* user_data,
                        rgw_zone_set* zones_trace, bool* canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 class DaosMultipartWriter : public StoreWriter {
@@ -793,7 +793,7 @@ class DaosMultipartWriter : public StoreWriter {
                        const char* if_nomatch, const std::string* user_data,
                        rgw_zone_set* zones_trace, bool* canceled,
                        optional_yield y,
-                       bool log_op) override;
+                       uint32_t flags) override;
 
   const std::string& get_bucket_name();
 };
@@ -849,7 +849,7 @@ class DaosMultipartUpload : public StoreMultipartUpload {
                          int num_parts, int marker, int* next_marker,
                          bool* truncated,
                          bool assume_unsorted = false) override;
-  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) override;
+  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
   virtual int complete(const DoutPrefixProvider* dpp, optional_yield y,
                        CephContext* cct, std::map<int, std::string>& part_etags,
                        std::list<rgw_obj_index_key>& remove_objs,

diff --git a/src/rgw/driver/motr/rgw_sal_motr.cc b/src/rgw/driver/motr/rgw_sal_motr.cc
index 6bb7f19f5ccee9a7704d51ac863ab7bea3e0ce14..55a396436167cc93aef77b517f2ef663ba4b6878 100644 (file)
--- a/src/rgw/driver/motr/rgw_sal_motr.cc
+++ b/src/rgw/driver/motr/rgw_sal_motr.cc
@@ -584,7 +584,7 @@ int MotrBucket::remove(const DoutPrefixProvider *dpp, bool delete_children, opti
 
       std::unique_ptr<rgw::sal::Object> object = get_object(key);
 
-      ret = object->delete_object(dpp, null_yield);
+      ret = object->delete_object(dpp, null_yield, rgw::sal::FLAG_LOG_OP);
       if (ret < 0 && ret != -ENOENT) {
         ldpp_dout(dpp, 0) << "ERROR: remove_bucket rgw_remove_object failed rc=" << ret << dendl;
              return ret;
@@ -1295,7 +1295,7 @@ int MotrObject::transition(Bucket* bucket,
     uint64_t olh_epoch,
     const DoutPrefixProvider* dpp,
     optional_yield y,
-    bool log_op)
+    uint32_t flags)
 {
   return 0;
 }
@@ -1457,7 +1457,7 @@ MotrObject::MotrDeleteOp::MotrDeleteOp(MotrObject *_source) :
 // Delete::delete_obj() in rgw_rados.cc shows how rados backend process the
 // params.
 // 2. Delete an object when its versioning is turned on.
-int MotrObject::MotrDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op)
+int MotrObject::MotrDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags)
 {
   ldpp_dout(dpp, 20) << "delete " << source->get_key().get_oid() << " from " << source->get_bucket()->get_name() << dendl;
 
@@ -1501,13 +1501,13 @@ int MotrObject::MotrDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional
   return 0;
 }
 
-int MotrObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning)
+int MotrObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags)
 {
   MotrObject::MotrDeleteOp del_op(this);
   del_op.params.bucket_owner = bucket->get_info().owner;
   del_op.params.versioning_status = bucket->get_info().versioning_status();
 
-  return del_op.delete_obj(dpp, y);
+  return del_op.delete_obj(dpp, y, flags);
 }
 
 int MotrObject::copy_object(User* user,
@@ -2326,7 +2326,7 @@ int MotrAtomicWriter::complete(size_t accounted_size, const std::string& etag,
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   int rc = 0;
 
@@ -2465,7 +2465,7 @@ int MotrMultipartUpload::delete_parts(const DoutPrefixProvider *dpp)
   return store->delete_motr_idx_by_name(obj_part_iname);
 }
 
-int MotrMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y, bool log_op)
+int MotrMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
 {
   int rc;
   // Check if multipart upload exists
@@ -2984,7 +2984,7 @@ int MotrMultipartWriter::complete(size_t accounted_size, const std::string& etag
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        optional_yield y,
-                       bool log_op)
+                       uint32_t flags)
 {
   // Should the dir entry(object metadata) be updated? For example
   // mtime.

diff --git a/src/rgw/driver/motr/rgw_sal_motr.h b/src/rgw/driver/motr/rgw_sal_motr.h
index c15212415d805c2e3f413aa9d4b883598200ba61..3cc3b37fa9ad0e4073a172540dc30727efc93f3f 100644 (file)
--- a/src/rgw/driver/motr/rgw_sal_motr.h
+++ b/src/rgw/driver/motr/rgw_sal_motr.h
@@ -660,7 +660,7 @@ class MotrObject : public StoreObject {
       public:
         MotrDeleteOp(MotrObject* _source);
 
-        virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) override;
+        virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) override;
     };
 
     MotrObject() = default;
@@ -676,7 +676,7 @@ class MotrObject : public StoreObject {
 
     virtual int delete_object(const DoutPrefixProvider* dpp,
         optional_yield y,
-        bool prevent_versioning = false) override;
+        uint32_t flags) override;
     virtual int copy_object(User* user,
         req_info* info, const rgw_zone_id& source_zone,
         rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
@@ -711,7 +711,7 @@ class MotrObject : public StoreObject {
         uint64_t olh_epoch,
         const DoutPrefixProvider* dpp,
         optional_yield y,
-        bool log_op) override;
+        uint32_t flags) override;
     virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
     virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
 
@@ -814,7 +814,7 @@ class MotrAtomicWriter : public StoreWriter {
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 
   unsigned populate_bvec(unsigned len, bufferlist::iterator &bi);
   void cleanup();
@@ -862,7 +862,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        optional_yield y,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 // The implementation of multipart upload in POC roughly follows the
@@ -937,7 +937,7 @@ public:
                         int num_parts, int marker,
                         int* next_marker, bool* truncated,
                         bool assume_unsorted = false) override;
-  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) override;
+  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
   virtual int complete(const DoutPrefixProvider* dpp,
                       optional_yield y, CephContext* cct,
                       std::map<int, std::string>& part_etags,

diff --git a/src/rgw/driver/posix/rgw_sal_posix.cc b/src/rgw/driver/posix/rgw_sal_posix.cc
index 2670f7872cd2eff4bac55406a730cab94be9fba6..8ca6a09275bd543d99e04838ca1ba3379a6fdcaa 100644 (file)
--- a/src/rgw/driver/posix/rgw_sal_posix.cc
+++ b/src/rgw/driver/posix/rgw_sal_posix.cc
@@ -1371,7 +1371,7 @@ int POSIXBucket::copy(const DoutPrefixProvider *dpp, optional_yield y,
   std::unique_ptr<POSIXBucket> dsb;
 
   // Delete the target, in case it's not a multipart
-  int ret = dest->delete_object(dpp, y);
+  int ret = dest->delete_object(dpp, y, rgw::sal::FLAG_LOG_OP);
   if (ret < 0) {
     ldpp_dout(dpp, 0) << "ERROR: could not remove dest object "
                       << dest->get_name() << dendl;
@@ -1423,7 +1423,7 @@ int POSIXBucket::copy(const DoutPrefixProvider *dpp, optional_yield y,
 
 int POSIXObject::delete_object(const DoutPrefixProvider* dpp,
                                optional_yield y,
-                               bool prevent_versioning)
+                               uint32_t flags)
 {
   POSIXBucket *b = static_cast<POSIXBucket*>(get_bucket());
   if (!b) {
@@ -1659,7 +1659,7 @@ int POSIXObject::transition(Bucket* bucket,
                            uint64_t olh_epoch,
                            const DoutPrefixProvider* dpp,
                            optional_yield y,
-                            bool log_op)
+                            uint32_t flags)
 {
   return -ERR_NOT_IMPLEMENTED;
 }
@@ -1890,7 +1890,7 @@ int POSIXObject::open(const DoutPrefixProvider* dpp, bool create, bool temp_file
   return 0;
 }
 
-int POSIXObject::link_temp_file(const DoutPrefixProvider *dpp, optional_yield y)
+int POSIXObject::link_temp_file(const DoutPrefixProvider *dpp, optional_yield y, uint32_t flags)
 {
   if (obj_fd < 0) {
     return 0;
@@ -1916,7 +1916,7 @@ int POSIXObject::link_temp_file(const DoutPrefixProvider *dpp, optional_yield y)
   }
 
   // Delete the target, in case it's a multipart
-  ret = delete_object(dpp, y);
+  ret = delete_object(dpp, y, flags);
   if (ret < 0) {
     ldpp_dout(dpp, 0) << "ERROR: could not remove dest object "
                       << get_name() << dendl;
@@ -2367,9 +2367,9 @@ int POSIXObject::POSIXReadOp::get_attr(const DoutPrefixProvider* dpp, const char
 }
 
 int POSIXObject::POSIXDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
-                                          optional_yield y, bool log_op)
+                                          optional_yield y, uint32_t flags)
 {
-  return source->delete_object(dpp, y, false);
+  return source->delete_object(dpp, y, flags);
 }
 
 int POSIXObject::copy(const DoutPrefixProvider *dpp, optional_yield y,
@@ -2385,7 +2385,7 @@ int POSIXObject::copy(const DoutPrefixProvider *dpp, optional_yield y,
   }
 
   // Delete the target, in case it's a multipart
-  ret = dobj->delete_object(dpp, y);
+  ret = dobj->delete_object(dpp, y, rgw::sal::FLAG_LOG_OP);
   if (ret < 0) {
     ldpp_dout(dpp, 0) << "ERROR: could not remove dest object "
                       << dobj->get_name() << dendl;
@@ -2573,7 +2573,7 @@ int POSIXMultipartUpload::list_parts(const DoutPrefixProvider *dpp, CephContext
   return 0;
 }
 
-int POSIXMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y, bool log_op)
+int POSIXMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
 {
   int ret;
 
@@ -2811,7 +2811,7 @@ int POSIXMultipartWriter::complete(size_t accounted_size, const std::string& eta
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   int ret;
   POSIXUploadPartInfo info;
@@ -2879,7 +2879,7 @@ int POSIXAtomicWriter::complete(size_t accounted_size, const std::string& etag,
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   int ret;
 
@@ -2928,7 +2928,7 @@ int POSIXAtomicWriter::complete(size_t accounted_size, const std::string& etag,
     }
   }
 
-  ret = obj.link_temp_file(rctx.dpp, rctx.y);
+  ret = obj.link_temp_file(rctx.dpp, rctx.y, flags);
   if (ret < 0) {
     ldpp_dout(dpp, 20) << "ERROR: POSIXAtomicWriter failed writing temp file" << dendl;
     return ret;

diff --git a/src/rgw/driver/posix/rgw_sal_posix.h b/src/rgw/driver/posix/rgw_sal_posix.h
index 42c46242640c472fef20dbd46a3b4021d129fdeb..61ca13dc76f594e337a807a19907ce2ebd4ff050 100644 (file)
--- a/src/rgw/driver/posix/rgw_sal_posix.h
+++ b/src/rgw/driver/posix/rgw_sal_posix.h
@@ -298,7 +298,7 @@ public:
       source(_source) {}
     virtual ~POSIXDeleteOp() = default;
 
-    virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) override;
+    virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) override;
   };
 
   POSIXObject(POSIXDriver *_dr, const rgw_obj_key& _k)
@@ -319,7 +319,7 @@ public:
 
   virtual int delete_object(const DoutPrefixProvider* dpp,
                            optional_yield y,
-                           bool prevent_versioning = false) override;
+                           uint32_t flags) override;
   virtual int copy_object(User* user,
                req_info* info, const rgw_zone_id& source_zone,
                rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
@@ -356,7 +356,7 @@ public:
                         uint64_t olh_epoch,
                         const DoutPrefixProvider* dpp,
                         optional_yield y,
-                         bool log_op) override;
+                         uint32_t flags) override;
   virtual int transition_to_cloud(Bucket* bucket,
                         rgw::sal::PlacementTier* tier,
                         rgw_bucket_dir_entry& o,
@@ -387,7 +387,7 @@ public:
   int close();
   int write(int64_t ofs, bufferlist& bl, const DoutPrefixProvider* dpp, optional_yield y);
   int write_attr(const DoutPrefixProvider* dpp, optional_yield y, const std::string& key, bufferlist& value);
-  int link_temp_file(const DoutPrefixProvider* dpp, optional_yield y);
+  int link_temp_file(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags);
   void gen_temp_fname();
   /* TODO dang Escape the object name for file use */
   const std::string get_fname();
@@ -545,7 +545,7 @@ public:
                         int num_parts, int marker,
                         int* next_marker, bool* truncated, optional_yield y,
                         bool assume_unsorted = false) override;
-  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) override;
+  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
   virtual int complete(const DoutPrefixProvider* dpp,
                       optional_yield y, CephContext* cct,
                       std::map<int, std::string>& part_etags,
@@ -608,7 +608,7 @@ public:
                       const std::string *user_data,
                       rgw_zone_set *zones_trace, bool *canceled,
                       const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 class POSIXMultipartWriter : public StoreWriter {
@@ -648,7 +648,7 @@ public:
                       const std::string *user_data,
                       rgw_zone_set *zones_trace, bool *canceled,
                       const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 
 };
 

diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc
index aac80909634fb6e0d99a55352feab0cf177f4914..d0eacf81e8c121a32600461af843acc531dbdd33 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.cc
+++ b/src/rgw/driver/rados/rgw_bucket.cc
@@ -148,7 +148,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, y);
+  return object->delete_object(dpp, y, rgw::sal::FLAG_LOG_OP);
 }
 
 static void set_err_msg(std::string *sink, std::string msg)

diff --git a/src/rgw/driver/rados/rgw_object_expirer_core.cc b/src/rgw/driver/rados/rgw_object_expirer_core.cc
index 269043f94df1f4680fda8d2b9d0c4c5f408aca55..c285443d0b0ae674a004657b44dea3fb1da9abf5 100644 (file)
--- a/src/rgw/driver/rados/rgw_object_expirer_core.cc
+++ b/src/rgw/driver/rados/rgw_object_expirer_core.cc
@@ -225,7 +225,7 @@ int RGWObjectExpirer::garbage_single_object(const DoutPrefixProvider *dpp, objex
 
   std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
   obj->set_atomic();
-  ret = obj->delete_object(dpp, null_yield);
+  ret = obj->delete_object(dpp, null_yield, rgw::sal::FLAG_LOG_OP);
 
   return ret;
 }

diff --git a/src/rgw/driver/rados/rgw_putobj_processor.cc b/src/rgw/driver/rados/rgw_putobj_processor.cc
index 8b86b570480b2c83d16b9a977448055a7cad49f6..d7462587c87cb3f44d82de05d97c9fd89964aaff 100644 (file)
--- a/src/rgw/driver/rados/rgw_putobj_processor.cc
+++ b/src/rgw/driver/rados/rgw_putobj_processor.cc
@@ -345,7 +345,7 @@ int AtomicObjectProcessor::complete(size_t accounted_size,
                                     rgw_zone_set *zones_trace,
                                     bool *pcanceled, 
                                     const req_context& rctx,
-                                    bool log_op)
+                                    uint32_t flags)
 {
   int r = writer.drain();
   if (r < 0) {
@@ -382,7 +382,8 @@ int AtomicObjectProcessor::complete(size_t accounted_size,
 
   read_cloudtier_info_from_attrs(attrs, obj_op.meta.category, manifest);
 
-  r = obj_op.write_meta(actual_size, accounted_size, attrs, rctx, log_op);
+  r = obj_op.write_meta(actual_size, accounted_size, attrs, rctx,
+                        flags & rgw::sal::FLAG_LOG_OP);
   if (r < 0) {
     if (r == -ETIMEDOUT) {
       // The head object write may eventually succeed, clear the set of objects for deletion. if it
@@ -488,7 +489,7 @@ int MultipartObjectProcessor::complete(size_t accounted_size,
                                        rgw_zone_set *zones_trace,
                                        bool *pcanceled, 
                                        const req_context& rctx,
-                                       bool log_op)
+                                       uint32_t flags)
 {
   int r = writer.drain();
   if (r < 0) {
@@ -512,7 +513,8 @@ int MultipartObjectProcessor::complete(size_t accounted_size,
   obj_op.meta.zones_trace = zones_trace;
   obj_op.meta.modify_tail = true;
 
-  r = obj_op.write_meta(actual_size, accounted_size, attrs, rctx, log_op);
+  r = obj_op.write_meta(actual_size, accounted_size, attrs, rctx,
+                        flags & rgw::sal::FLAG_LOG_OP);
   if (r < 0)
     return r;
 
@@ -693,7 +695,7 @@ int AppendObjectProcessor::complete(size_t accounted_size, const string &etag, c
                                     ceph::real_time set_mtime, rgw::sal::Attrs& attrs,
                                     ceph::real_time delete_at, const char *if_match, const char *if_nomatch,
                                     const string *user_data, rgw_zone_set *zones_trace, bool *pcanceled,
-                                    const req_context& rctx, bool log_op)
+                                    const req_context& rctx, uint32_t flags)
 {
   int r = writer.drain();
   if (r < 0)
@@ -751,7 +753,7 @@ int AppendObjectProcessor::complete(size_t accounted_size, const string &etag, c
   }
   r = obj_op.write_meta(actual_size + cur_size,
                        accounted_size + *cur_accounted_size,
-                       attrs, rctx, log_op);
+                       attrs, rctx, flags & rgw::sal::FLAG_LOG_OP);
   if (r < 0) {
     return r;
   }

diff --git a/src/rgw/driver/rados/rgw_putobj_processor.h b/src/rgw/driver/rados/rgw_putobj_processor.h
index 7b92402d2d7d4146b05edb35563eb8f88dea2f4e..53b14c41ee08ec92b84de8a0ed748953d24a0b9f 100644 (file)
--- a/src/rgw/driver/rados/rgw_putobj_processor.h
+++ b/src/rgw/driver/rados/rgw_putobj_processor.h
@@ -191,7 +191,7 @@ class AtomicObjectProcessor : public ManifestObjectProcessor {
                const std::string *user_data,
                rgw_zone_set *zones_trace, bool *canceled,
                const req_context& rctx,
-               bool log_op = true) override;
+               uint32_t flags) override;
 
 };
 
@@ -239,7 +239,7 @@ class MultipartObjectProcessor : public ManifestObjectProcessor {
                const std::string *user_data,
                rgw_zone_set *zones_trace, bool *canceled,
                const req_context& rctx,
-               bool log_op = true) override;
+               uint32_t flags) override;
 
 };
 
@@ -276,7 +276,7 @@ class MultipartObjectProcessor : public ManifestObjectProcessor {
                  const char *if_match, const char *if_nomatch, const std::string *user_data,
                  rgw_zone_set *zones_trace, bool *canceled,
                  const req_context& rctx,
-                 bool log_op = true) override;
+                 uint32_t flags) override;
   };
 
 } // namespace putobj

diff --git a/src/rgw/driver/rados/rgw_rados.cc b/src/rgw/driver/rados/rgw_rados.cc
index a8ecb4bfa099b3f981956b5f8ee9c8c0fe5241b9..f167dce6e992b67139415f10aa054876121d7e42 100644 (file)
--- a/src/rgw/driver/rados/rgw_rados.cc
+++ b/src/rgw/driver/rados/rgw_rados.cc
@@ -4432,7 +4432,7 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
     bool canceled = false;
     ret = processor.complete(accounted_size, etag, mtime, set_mtime,
                              attrs, delete_at, nullptr, nullptr, nullptr,
-                             zones_trace, &canceled, rctx);
+                             zones_trace, &canceled, rctx, rgw::sal::FLAG_LOG_OP);
     if (ret < 0) {
       goto set_err_state;
     }
@@ -4970,7 +4970,8 @@ int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx,
 
   const req_context rctx{dpp, y, nullptr};
   return processor.complete(accounted_size, etag, mtime, set_mtime, attrs, delete_at,
-                            nullptr, nullptr, nullptr, nullptr, nullptr, rctx, log_op);
+                            nullptr, nullptr, nullptr, nullptr, nullptr, rctx,
+                            log_op ? rgw::sal::FLAG_LOG_OP : 0);
 }
 
 int RGWRados::transition_obj(RGWObjectCtx& obj_ctx,
@@ -5814,7 +5815,7 @@ int RGWRados::delete_obj(const DoutPrefixProvider *dpp,
   del_op.params.expiration_time = expiration_time;
   del_op.params.zones_trace = zones_trace;
 
-  return del_op.delete_obj(y, dpp, log_op);
+  return del_op.delete_obj(y, dpp, log_op ? rgw::sal::FLAG_LOG_OP : 0);
 }
 
 int RGWRados::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, optional_yield y)

diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc
index e5ac7229bf6c58fef600fb3a8eb3cf556fc39070..709e748cb49933cb47af22238b9ef4a95c9029ed 100644 (file)
--- a/src/rgw/driver/rados/rgw_sal_rados.cc
+++ b/src/rgw/driver/rados/rgw_sal_rados.cc
@@ -811,7 +811,7 @@ int RadosBucket::abort_multiparts(const DoutPrefixProvider* dpp,
 
     if (!uploads.empty()) {
       for (const auto& upload : uploads) {
-       ret = upload->abort(dpp, cct, y, true);
+       ret = upload->abort(dpp, cct, y);
         if (ret < 0) {
          // we're doing a best-effort; if something cannot be found,
          // log it and keep moving forward
@@ -1703,9 +1703,10 @@ int RadosObject::transition(Bucket* bucket,
                            uint64_t olh_epoch,
                            const DoutPrefixProvider* dpp,
                            optional_yield y,
-                            bool log_op)
+                            uint32_t flags)
 {
-  return store->getRados()->transition_obj(*rados_ctx, bucket->get_info(), get_obj(), placement_rule, mtime, olh_epoch, dpp, y, log_op);
+  return store->getRados()->transition_obj(*rados_ctx, bucket->get_info(), get_obj(), placement_rule,
+                                           mtime, olh_epoch, dpp, y, flags & FLAG_LOG_OP);
 }
 
 int RadosObject::transition_to_cloud(Bucket* bucket,
@@ -1987,7 +1988,7 @@ RadosObject::RadosDeleteOp::RadosDeleteOp(RadosObject *_source) :
        parent_op(&op_target)
 { }
 
-int RadosObject::RadosDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op)
+int RadosObject::RadosDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags)
 {
   parent_op.params.bucket_owner = params.bucket_owner.id;
   parent_op.params.versioning_status = params.versioning_status;
@@ -2004,7 +2005,7 @@ int RadosObject::RadosDeleteOp::delete_obj(const DoutPrefixProvider* dpp, option
   parent_op.params.abortmp = params.abortmp;
   parent_op.params.parts_accounted_size = params.parts_accounted_size;
 
-  int ret = parent_op.delete_obj(y, dpp, log_op);
+  int ret = parent_op.delete_obj(y, dpp, flags & FLAG_LOG_OP);
   if (ret < 0)
     return ret;
 
@@ -2016,15 +2017,16 @@ int RadosObject::RadosDeleteOp::delete_obj(const DoutPrefixProvider* dpp, option
 
 int RadosObject::delete_object(const DoutPrefixProvider* dpp,
                               optional_yield y,
-                              bool prevent_versioning)
+                              uint32_t flags)
 {
   RGWRados::Object del_target(store->getRados(), bucket->get_info(), *rados_ctx, get_obj());
   RGWRados::Object::Delete del_op(&del_target);
 
   del_op.params.bucket_owner = bucket->get_info().owner;
-  del_op.params.versioning_status = prevent_versioning ? 0 : bucket->get_info().versioning_status();
+  del_op.params.versioning_status = (flags & FLAG_PREVENT_VERSIONING)
+                                    ? 0 : bucket->get_info().versioning_status();
 
-  return del_op.delete_obj(y, dpp);
+  return del_op.delete_obj(y, dpp, flags & FLAG_LOG_OP);
 }
 
 int RadosObject::copy_object(User* user,
@@ -2155,7 +2157,7 @@ int RadosMultipartUpload::cleanup_part_history(const DoutPrefixProvider* dpp,
 }
 
 
-int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y, bool log_op)
+int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
 {
   std::unique_ptr<rgw::sal::Object> meta_obj = get_meta_obj();
   meta_obj->set_in_extra_data(true);
@@ -2183,7 +2185,7 @@ int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct,
        std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(
                                    rgw_obj_key(obj_part->oid, std::string(), RGW_OBJ_NS_MULTIPART));
        obj->set_hash_source(mp_obj.get_key());
-       ret = obj->delete_object(dpp, y, log_op);
+       ret = obj->delete_object(dpp, y, 0);
         if (ret < 0 && ret != -ENOENT)
           return ret;
       } else {
@@ -2233,7 +2235,7 @@ int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct,
   del_op->params.parts_accounted_size = parts_accounted_size;
 
   // and also remove the metadata obj
-  ret = del_op->delete_obj(dpp, y, log_op);
+  ret = del_op->delete_obj(dpp, y, 0);
   if (ret < 0) {
     ldpp_dout(dpp, 20) << __func__ << ": del_op.delete_obj returned " <<
       ret << dendl;
@@ -2851,10 +2853,10 @@ int RadosAtomicWriter::complete(size_t accounted_size, const std::string& etag,
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   return processor.complete(accounted_size, etag, mtime, set_mtime, attrs, delete_at,
-                           if_match, if_nomatch, user_data, zones_trace, canceled, rctx, log_op);
+                           if_match, if_nomatch, user_data, zones_trace, canceled, rctx, flags);
 }
 
 int RadosAppendWriter::prepare(optional_yield y)
@@ -2875,10 +2877,10 @@ int RadosAppendWriter::complete(size_t accounted_size, const std::string& etag,
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   return processor.complete(accounted_size, etag, mtime, set_mtime, attrs, delete_at,
-                           if_match, if_nomatch, user_data, zones_trace, canceled, rctx, log_op);
+                           if_match, if_nomatch, user_data, zones_trace, canceled, rctx, flags);
 }
 
 int RadosMultipartWriter::prepare(optional_yield y)
@@ -2899,10 +2901,10 @@ int RadosMultipartWriter::complete(size_t accounted_size, const std::string& eta
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   return processor.complete(accounted_size, etag, mtime, set_mtime, attrs, delete_at,
-                           if_match, if_nomatch, user_data, zones_trace, canceled, rctx, log_op);
+                           if_match, if_nomatch, user_data, zones_trace, canceled, rctx, flags);
 }
 
 bool RadosZoneGroup::placement_target_exists(std::string& target) const

diff --git a/src/rgw/driver/rados/rgw_sal_rados.h b/src/rgw/driver/rados/rgw_sal_rados.h
index a05403856111b795aa72e6cef8f78b621193e577..7b810504457b4b99f3c3a151b2c549b487f25b45 100644 (file)
--- a/src/rgw/driver/rados/rgw_sal_rados.h
+++ b/src/rgw/driver/rados/rgw_sal_rados.h
@@ -332,7 +332,7 @@ class RadosObject : public StoreObject {
     public:
       RadosDeleteOp(RadosObject* _source);
 
-      virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) override;
+      virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) override;
     };
 
     RadosObject(RadosStore *_st, const rgw_obj_key& _k)
@@ -364,7 +364,7 @@ class RadosObject : public StoreObject {
       rados_ctx->invalidate(get_obj());
     }
     virtual int delete_object(const DoutPrefixProvider* dpp,
-                             optional_yield y, bool prevent_versioning) override;
+                             optional_yield y, uint32_t flags) override;
     virtual int copy_object(User* user,
                req_info* info, const rgw_zone_id& source_zone,
                rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
@@ -414,7 +414,7 @@ class RadosObject : public StoreObject {
                           uint64_t olh_epoch,
                           const DoutPrefixProvider* dpp,
                           optional_yield y,
-                           bool log_op) override;
+                           uint32_t flags) override;
     virtual int transition_to_cloud(Bucket* bucket,
                           rgw::sal::PlacementTier* tier,
                           rgw_bucket_dir_entry& o,
@@ -610,7 +610,7 @@ public:
                         int num_parts, int marker,
                         int* next_marker, bool* truncated, optional_yield y,
                         bool assume_unsorted = false) override;
-  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) override;
+  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
   virtual int complete(const DoutPrefixProvider* dpp,
                       optional_yield y, CephContext* cct,
                       std::map<int, std::string>& part_etags,
@@ -754,7 +754,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 class RadosAppendWriter : public StoreWriter {
@@ -802,7 +802,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 class RadosMultipartWriter : public StoreWriter {
@@ -848,7 +848,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 class RadosLuaManager : public StoreLuaManager {

diff --git a/src/rgw/rgw_data_access.cc b/src/rgw/rgw_data_access.cc
index 07bf12e37460b960df94deb3b7aa84eac75ca1b6..76cadc9c8bfc0dcd1ec7509aa2775462027804fd 100644 (file)
--- a/src/rgw/rgw_data_access.cc
+++ b/src/rgw/rgw_data_access.cc
@@ -212,7 +212,8 @@ int RGWDataAccess::Object::put(bufferlist& data,
                            attrs, delete_at,
                             nullptr, nullptr,
                             puser_data,
-                            nullptr, nullptr, rctx);
+                            nullptr, nullptr,
+                            rctx, rgw::sal::FLAG_LOG_OP);
 }
 
 void RGWDataAccess::Object::set_policy(const RGWAccessControlPolicy& policy)

diff --git a/src/rgw/rgw_lc.cc b/src/rgw/rgw_lc.cc
index 43fe22eab1f0c299910fc5b272599f54a49025b3..c25e4ffc648b922b0ac62564a85ab0402b6485fa 100644 (file)
--- a/src/rgw/rgw_lc.cc
+++ b/src/rgw/rgw_lc.cc
@@ -588,8 +588,9 @@ static int remove_expired_obj(
     return ret;
   }
 
-  bool log_op = !remove_indeed || !zonegroup_lc_check(dpp, oc.driver->get_zone());
-  ret =  del_op->delete_obj(dpp, null_yield, log_op);
+  uint32_t flags = (!remove_indeed || !zonegroup_lc_check(dpp, oc.driver->get_zone()))
+                   ? rgw::sal::FLAG_LOG_OP : 0;
+  ret =  del_op->delete_obj(dpp, null_yield, flags);
   if (ret < 0) {
     ldpp_dout(dpp, 1) <<
       fmt::format("ERROR: {} failed, with error: {}", __func__, ret) << dendl;
@@ -885,8 +886,7 @@ int RGWLC::handle_multipart_expiration(rgw::sal::Bucket* target,
         return ret;
       }
 
-      bool log_op = !zonegroup_lc_check(wk->get_lc(), driver->get_zone());
-      ret = mpu->abort(this, cct, null_yield, log_op);
+      ret = mpu->abort(this, cct, null_yield);
       if (ret == 0) {
         int publish_ret = notify->publish_commit(
             this, obj_state->size,
@@ -1465,9 +1465,10 @@ public:
         return -EINVAL;
       }
 
-      bool log_op = !zonegroup_lc_check(oc.dpp, oc.driver->get_zone());
+      uint32_t flags = !zonegroup_lc_check(oc.dpp, oc.driver->get_zone())
+                       ? rgw::sal::FLAG_LOG_OP : 0;
       int r = oc.obj->transition(oc.bucket, target_placement, o.meta.mtime,
-                                 o.versioned_epoch, oc.dpp, null_yield, log_op);
+                                 o.versioned_epoch, oc.dpp, null_yield, flags);
       if (r < 0) {
         ldpp_dout(oc.dpp, 0) << "ERROR: failed to transition obj " 
                             << oc.bucket << ":" << o.key 

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 12fc4a706d9c1e41688d8cdc18dc3daf5d569df3..9103db49cdd9e8dfb3899851aeca4a4ab984fa52 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -4530,7 +4530,7 @@ void RGWPutObj::execute(optional_yield y)
   op_ret = processor->complete(s->obj_size, etag, &mtime, real_time(), attrs,
                                (delete_at ? *delete_at : real_time()), if_match, if_nomatch,
                                (user_data.empty() ? nullptr : &user_data), nullptr, nullptr,
-                               rctx, true);
+                               rctx, rgw::sal::FLAG_LOG_OP);
   tracepoint(rgw_op, processor_complete_exit, s->req_id.c_str());
 
   // send request to notification manager
@@ -4799,7 +4799,7 @@ void RGWPostObj::execute(optional_yield y)
     op_ret = processor->complete(s->obj_size, etag, nullptr, real_time(), attrs,
                                 (delete_at ? *delete_at : real_time()),
                                 nullptr, nullptr, nullptr, nullptr, nullptr,
-                                rctx, true);
+                                rctx, rgw::sal::FLAG_LOG_OP);
     if (op_ret < 0) {
       return;
     }
@@ -5357,7 +5357,7 @@ void RGWDeleteObj::execute(optional_yield y)
       del_op->params.olh_epoch = epoch;
       del_op->params.marker_version_id = version_id;
 
-      op_ret = del_op->delete_obj(this, y, true);
+      op_ret = del_op->delete_obj(this, y, rgw::sal::FLAG_LOG_OP);
       if (op_ret >= 0) {
        delete_marker = del_op->result.delete_marker;
        version_id = del_op->result.version_id;
@@ -6787,7 +6787,7 @@ void RGWCompleteMultipart::complete()
   // when the bucket is, as that would add an unneeded delete marker
   // moved to complete to prevent segmentation fault in publish commit
   if (meta_obj.get() != nullptr) {
-    int ret = meta_obj->delete_object(this, null_yield, true /* prevent versioning */);
+    int ret = meta_obj->delete_object(this, null_yield, rgw::sal::FLAG_PREVENT_VERSIONING | rgw::sal::FLAG_LOG_OP);
     if (ret >= 0) {
       /* serializer's exclusive lock is released */
       serializer->clear_locked();
@@ -6896,7 +6896,7 @@ void RGWAbortMultipart::execute(optional_yield y)
   }
   multipart_trace = tracing::rgw::tracer.add_span(name(), trace_ctx);
 
-  op_ret = upload->abort(this, s->cct, y, true);
+  op_ret = upload->abort(this, s->cct, y);
 }
 
 int RGWListMultipart::verify_permission(optional_yield y)
@@ -7262,7 +7262,7 @@ void RGWDeleteMultiObj::handle_individual_object(const rgw_obj_key& o, optional_
   del_op->params.bucket_owner = s->bucket_owner;
   del_op->params.marker_version_id = version_id;
 
-  op_ret = del_op->delete_obj(this, y, true);
+  op_ret = del_op->delete_obj(this, y, rgw::sal::FLAG_LOG_OP);
   if (op_ret == -ENOENT) {
     op_ret = 0;
   }
@@ -7436,7 +7436,7 @@ bool RGWBulkDelete::Deleter::delete_single(const acct_path_t& path, optional_yie
     del_op->params.obj_owner = bowner;
     del_op->params.bucket_owner = bucket_owner;
 
-    ret = del_op->delete_obj(dpp, y, true);
+    ret = del_op->delete_obj(dpp, y, rgw::sal::FLAG_LOG_OP);
     if (ret < 0) {
       goto delop_fail;
     }
@@ -7949,7 +7949,7 @@ int RGWBulkUploadOp::handle_file(const std::string_view path,
   op_ret = processor->complete(size, etag, nullptr, ceph::real_time(),
                               attrs, ceph::real_time() /* delete_at */,
                               nullptr, nullptr, nullptr, nullptr, nullptr,
-                              rctx, true);
+                              rctx, rgw::sal::FLAG_LOG_OP);
   if (op_ret < 0) {
     ldpp_dout(this, 20) << "processor::complete returned op_ret=" << op_ret << dendl;
   }

diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h
index 33891d08a4c10e4f4958d9b392efbd9e1aadea6d..943905af17a4f1121bb1800e1cc820105118a419 100644 (file)
--- a/src/rgw/rgw_sal.h
+++ b/src/rgw/rgw_sal.h
@@ -191,6 +191,9 @@ enum AttrsMod {
   ATTRSMOD_MERGE   = 2
 };
 
+static constexpr uint32_t FLAG_LOG_OP = 0x0001;
+static constexpr uint32_t FLAG_PREVENT_VERSIONING = 0x0002;
+
 // a simple streaming data processing abstraction
 /**
  * @brief A simple streaming data processing abstraction
@@ -225,7 +228,7 @@ class ObjectProcessor : public DataProcessor {
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) = 0;
+                       uint32_t flags) = 0;
 };
 
 /** A list of key-value attributes */
@@ -888,7 +891,7 @@ class Object {
       virtual ~DeleteOp() = default;
 
       /** Delete the object */
-      virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) = 0;
+      virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) = 0;
     };
 
     Object() {}
@@ -897,7 +900,7 @@ class Object {
     /** Shortcut synchronous delete call for common deletes */
     virtual int delete_object(const DoutPrefixProvider* dpp,
                              optional_yield y,
-                             bool prevent_versioning = false) = 0;
+                             uint32_t flags) = 0;
     /** Copy an this object to another object. */
     virtual int copy_object(User* user,
                req_info* info, const rgw_zone_id& source_zone,
@@ -966,7 +969,7 @@ class Object {
                           uint64_t olh_epoch,
                           const DoutPrefixProvider* dpp,
                           optional_yield y,
-                           bool log_op) = 0;
+                           uint32_t flags) = 0;
     /** Move an object to the cloud */
     virtual int transition_to_cloud(Bucket* bucket,
                           rgw::sal::PlacementTier* tier,
@@ -1145,7 +1148,7 @@ public:
                         int* next_marker, bool* truncated, optional_yield y,
                         bool assume_unsorted = false) = 0;
   /** Abort this upload */
-  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) = 0;
+  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) = 0;
   /** Complete this upload, making it available as a normal object */
   virtual int complete(const DoutPrefixProvider* dpp,
                       optional_yield y, CephContext* cct,
@@ -1375,7 +1378,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) = 0;
+                       uint32_t flags) = 0;
 };
 
 

diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc
index 68baf3d8bd46bb9ad055eb6ed8403f907534fdda..2dc9fc95d105dd5ba29deb23f5d1c788af24967b 100644 (file)
--- a/src/rgw/rgw_sal_dbstore.cc
+++ b/src/rgw/rgw_sal_dbstore.cc
@@ -619,7 +619,7 @@ namespace rgw::sal {
       uint64_t olh_epoch,
       const DoutPrefixProvider* dpp,
       optional_yield y,
-      bool log_op)
+      uint32_t flags)
   {
     DB::Object op_target(store->getDB(),
         get_bucket()->get_info(), get_obj());
@@ -700,7 +700,7 @@ namespace rgw::sal {
     parent_op(&op_target)
   { }
 
-  int DBObject::DBDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op)
+  int DBObject::DBDeleteOp::delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags)
   {
     parent_op.params.bucket_owner = params.bucket_owner.id;
     parent_op.params.versioning_status = params.versioning_status;
@@ -727,7 +727,7 @@ namespace rgw::sal {
     return ret;
   }
 
-  int DBObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning)
+  int DBObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags)
   {
     DB::Object del_target(store->getDB(), bucket->get_info(), get_obj());
     DB::Object::Delete del_op(&del_target);
@@ -786,7 +786,7 @@ namespace rgw::sal {
     return 0;
   }
 
-  int DBMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y, bool log_op)
+  int DBMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
   {
     std::unique_ptr<rgw::sal::Object> meta_obj = get_meta_obj();
     meta_obj->set_in_extra_data(true);
@@ -800,7 +800,7 @@ namespace rgw::sal {
     // Since the data objects are associated with meta obj till
     // MultipartUpload::Complete() is done, removing the metadata obj
     // should remove all the uploads so far.
-    ret = del_op->delete_obj(dpp, null_yield, log_op);
+    ret = del_op->delete_obj(dpp, null_yield, 0);
     if (ret < 0) {
       ldpp_dout(dpp, 20) << __func__ << ": del_op.delete_obj returned " <<
         ret << dendl;
@@ -1228,7 +1228,7 @@ namespace rgw::sal {
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
   {
     /* XXX: same as AtomicWriter..consolidate code */
     parent_op.meta.mtime = mtime;
@@ -1383,7 +1383,7 @@ namespace rgw::sal {
                          const std::string *user_data,
                          rgw_zone_set *zones_trace, bool *canceled,
                          const req_context& rctx,
-                         bool log_op)
+                         uint32_t flags)
   {
     parent_op.meta.mtime = mtime;
     parent_op.meta.delete_at = delete_at;

diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h
index d39fb3f62550bf661f01aaa7bd1f09c9173c21e4..3c0c7c765198bdcaf31b944068c4f3c341060b9d 100644 (file)
--- a/src/rgw/rgw_sal_dbstore.h
+++ b/src/rgw/rgw_sal_dbstore.h
@@ -462,7 +462,7 @@ protected:
                         int num_parts, int marker,
                         int* next_marker, bool* truncated, optional_yield y,
                         bool assume_unsorted = false) override;
-    virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) override;
+    virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
     virtual int complete(const DoutPrefixProvider* dpp,
                       optional_yield y, CephContext* cct,
                       std::map<int, std::string>& part_etags,
@@ -524,7 +524,7 @@ protected:
         public:
           DBDeleteOp(DBObject* _source);
 
-          virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) override;
+          virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) override;
       };
 
       DBObject() = default;
@@ -543,7 +543,7 @@ protected:
 
       virtual int delete_object(const DoutPrefixProvider* dpp,
           optional_yield y,
-          bool prevent_versioning = false) override;
+          uint32_t flags) override;
       virtual int copy_object(User* user,
           req_info* info, const rgw_zone_id& source_zone,
           rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
@@ -580,7 +580,7 @@ protected:
           uint64_t olh_epoch,
           const DoutPrefixProvider* dpp,
           optional_yield y,
-          bool log_op) override;
+          uint32_t flags) override;
       virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
       virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
 
@@ -657,7 +657,7 @@ protected:
                          const std::string *user_data,
                          rgw_zone_set *zones_trace, bool *canceled,
                          const req_context& rctx,
-                         bool log_op) override;
+                         uint32_t flags) override;
   };
 
   class DBMultipartWriter : public StoreWriter {
@@ -706,7 +706,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
   };
 
   class DBStore : public StoreDriver {

diff --git a/src/rgw/rgw_sal_filter.cc b/src/rgw/rgw_sal_filter.cc
index 953cf54e040886cc467f14b84d75bc26e0d1db25..6e0ca8ccd82108d123f2116f013976629f16d60f 100644 (file)
--- a/src/rgw/rgw_sal_filter.cc
+++ b/src/rgw/rgw_sal_filter.cc
@@ -755,9 +755,9 @@ int FilterBucket::abort_multiparts(const DoutPrefixProvider* dpp, CephContext* c
 
 int FilterObject::delete_object(const DoutPrefixProvider* dpp,
                                optional_yield y,
-                               bool prevent_versioning)
+                               uint32_t flags)
 {
-  return next->delete_object(dpp, y, prevent_versioning);
+  return next->delete_object(dpp, y, flags);
 }
 
 int FilterObject::copy_object(User* user,
@@ -857,10 +857,10 @@ int FilterObject::transition(Bucket* bucket,
                             uint64_t olh_epoch,
                             const DoutPrefixProvider* dpp,
                             optional_yield y,
-                             bool log_op)
+                             uint32_t flags)
 {
   return next->transition(nextBucket(bucket), placement_rule, mtime, olh_epoch,
-                         dpp, y, log_op);
+                         dpp, y, flags);
 }
 
 int FilterObject::transition_to_cloud(Bucket* bucket,
@@ -980,11 +980,11 @@ int FilterObject::FilterReadOp::iterate(const DoutPrefixProvider* dpp, int64_t o
 }
 
 int FilterObject::FilterDeleteOp::delete_obj(const DoutPrefixProvider* dpp,
-                                          optional_yield y, bool log_op)
+                                          optional_yield y, uint32_t flags)
 {
   /* Copy params into next */
   next->params = params;
-  int ret = next->delete_obj(dpp, y, log_op);
+  int ret = next->delete_obj(dpp, y, flags);
   /* Copy result back */
   result = next->result;
   return ret;
@@ -1025,9 +1025,9 @@ int FilterMultipartUpload::list_parts(const DoutPrefixProvider *dpp, CephContext
   return 0;
 }
 
-int FilterMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y, bool log_op)
+int FilterMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct, optional_yield y)
 {
-  return next->abort(dpp, cct, y, log_op);
+  return next->abort(dpp, cct, y);
 }
 
 int FilterMultipartUpload::complete(const DoutPrefixProvider *dpp,
@@ -1203,11 +1203,11 @@ int FilterWriter::complete(size_t accounted_size, const std::string& etag,
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op)
+                       uint32_t flags)
 {
   return next->complete(accounted_size, etag, mtime, set_mtime, attrs,
                        delete_at, if_match, if_nomatch, user_data, zones_trace,
-                       canceled, rctx, log_op);
+                       canceled, rctx, flags);
 }
 
 int FilterLuaManager::get_script(const DoutPrefixProvider* dpp, optional_yield y,

diff --git a/src/rgw/rgw_sal_filter.h b/src/rgw/rgw_sal_filter.h
index d258cda4a654fcdf8b8aa8b078beead16b51c368..80e236a25d94ca94b026139b10479a0d068da7dc 100644 (file)
--- a/src/rgw/rgw_sal_filter.h
+++ b/src/rgw/rgw_sal_filter.h
@@ -521,7 +521,7 @@ public:
     FilterDeleteOp(std::unique_ptr<DeleteOp> _next) : next(std::move(_next)) {}
     virtual ~FilterDeleteOp() = default;
 
-    virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, bool log_op) override;
+    virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y, uint32_t flags) override;
   };
 
   FilterObject(std::unique_ptr<Object> _next) : next(std::move(_next)) {}
@@ -535,7 +535,7 @@ public:
 
   virtual int delete_object(const DoutPrefixProvider* dpp,
                            optional_yield y,
-                           bool prevent_versioning = false) override;
+                           uint32_t flags) override;
   virtual int copy_object(User* user,
                req_info* info, const rgw_zone_id& source_zone,
               rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
@@ -584,7 +584,7 @@ public:
                         uint64_t olh_epoch,
                         const DoutPrefixProvider* dpp,
                         optional_yield y,
-                         bool log_op) override;
+                         uint32_t flags) override;
   virtual int transition_to_cloud(Bucket* bucket,
                                  rgw::sal::PlacementTier* tier,
                                  rgw_bucket_dir_entry& o,
@@ -697,7 +697,7 @@ public:
                         int num_parts, int marker,
                         int* next_marker, bool* truncated, optional_yield y,
                         bool assume_unsorted = false) override;
-  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y, bool log_op) override;
+  virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct, optional_yield y) override;
   virtual int complete(const DoutPrefixProvider* dpp,
                       optional_yield y, CephContext* cct,
                       std::map<int, std::string>& part_etags,
@@ -842,7 +842,7 @@ public:
                        const std::string *user_data,
                        rgw_zone_set *zones_trace, bool *canceled,
                        const req_context& rctx,
-                       bool log_op) override;
+                       uint32_t flags) override;
 };
 
 class FilterLuaManager : public LuaManager {