From 485020f97b08222f696d7aaf95f9ec3b49c5d171 Mon Sep 17 00:00:00 2001 From: Shilpa Jagannath Date: Thu, 18 Jan 2024 13:47:49 -0500 Subject: [PATCH] rgw/multisite: add a flag to bilog_flags and use it to set/unset null version Signed-off-by: Shilpa Jagannath --- src/cls/rgw/cls_rgw.cc | 11 ++++++--- src/cls/rgw/cls_rgw_client.cc | 9 ++++--- src/cls/rgw/cls_rgw_client.h | 5 ++-- src/cls/rgw/cls_rgw_ops.h | 9 +++++-- src/cls/rgw/cls_rgw_types.h | 6 +++++ src/rgw/driver/rados/rgw_bucket.cc | 3 --- src/rgw/driver/rados/rgw_cr_rados.cc | 2 ++ src/rgw/driver/rados/rgw_data_sync.cc | 11 +++++++-- src/rgw/driver/rados/rgw_rados.cc | 35 +++++++++++++++++---------- src/rgw/driver/rados/rgw_rados.h | 15 +++++++++--- src/rgw/driver/rados/rgw_sal_rados.cc | 1 + src/rgw/rgw_op.cc | 9 +++++++ src/rgw/rgw_sal.h | 1 + 13 files changed, 84 insertions(+), 33 deletions(-) diff --git a/src/cls/rgw/cls_rgw.cc b/src/cls/rgw/cls_rgw.cc index 9ad1320e38a..4b9fe1838fc 100644 --- a/src/cls/rgw/cls_rgw.cc +++ b/src/cls/rgw/cls_rgw.cc @@ -1887,9 +1887,6 @@ static int rgw_bucket_unlink_instance(cls_method_context_t hctx, bufferlist *in, } cls_rgw_obj_key dest_key = op.key; - if (dest_key.instance == "null") { - dest_key.instance.clear(); - } BIVerObjEntry obj(hctx, dest_key); BIOLHEntry olh(hctx, dest_key); @@ -2014,12 +2011,18 @@ static int rgw_bucket_unlink_instance(cls_method_context_t hctx, bufferlist *in, rgw_bucket_entry_ver ver; ver.epoch = (op.olh_epoch ? op.olh_epoch : olh.get_epoch()); + if (op.null_verid) { + op.bilog_flags = op.bilog_flags | RGW_BILOG_FLAG_VERSIONED_OP | RGW_BILOG_NULL_VERSION; + } else { + op.bilog_flags = op.bilog_flags | RGW_BILOG_FLAG_VERSIONED_OP; + } + real_time mtime = obj.mtime(); /* mtime has no real meaning in * instance removal context */ ret = log_index_operation(hctx, op.key, CLS_RGW_OP_UNLINK_INSTANCE, op.op_tag, mtime, ver, CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker, - op.bilog_flags | RGW_BILOG_FLAG_VERSIONED_OP, NULL, NULL, &op.zones_trace); + op.bilog_flags, NULL, NULL, &op.zones_trace); if (ret < 0) return ret; diff --git a/src/cls/rgw/cls_rgw_client.cc b/src/cls/rgw/cls_rgw_client.cc index ac87c9a4a40..c36d9c232a0 100644 --- a/src/cls/rgw/cls_rgw_client.cc +++ b/src/cls/rgw/cls_rgw_client.cc @@ -535,10 +535,11 @@ void cls_rgw_bucket_link_olh(librados::ObjectWriteOperation& op, const cls_rgw_o int cls_rgw_bucket_unlink_instance(librados::IoCtx& io_ctx, const string& oid, const cls_rgw_obj_key& key, const string& op_tag, - const string& olh_tag, uint64_t olh_epoch, bool log_op, const rgw_zone_set& zones_trace) + const string& olh_tag, uint64_t olh_epoch, bool log_op, + bool null_verid, const rgw_zone_set& zones_trace) { librados::ObjectWriteOperation op; - cls_rgw_bucket_unlink_instance(op, key, op_tag, olh_tag, olh_epoch, log_op, zones_trace); + cls_rgw_bucket_unlink_instance(op, key, op_tag, olh_tag, olh_epoch, log_op, null_verid, zones_trace); int r = io_ctx.operate(oid, &op); if (r < 0) return r; @@ -548,7 +549,8 @@ int cls_rgw_bucket_unlink_instance(librados::IoCtx& io_ctx, const string& oid, void cls_rgw_bucket_unlink_instance(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& key, const string& op_tag, - const string& olh_tag, uint64_t olh_epoch, bool log_op, const rgw_zone_set& zones_trace) + const string& olh_tag, uint64_t olh_epoch, bool log_op, + bool null_verid, const rgw_zone_set& zones_trace) { bufferlist in, out; rgw_cls_unlink_instance_op call; @@ -558,6 +560,7 @@ void cls_rgw_bucket_unlink_instance(librados::ObjectWriteOperation& op, call.olh_tag = olh_tag; call.log_op = log_op; call.zones_trace = zones_trace; + call.null_verid = null_verid; encode(call, in); op.exec(RGW_CLASS, RGW_BUCKET_UNLINK_INSTANCE, in); } diff --git a/src/cls/rgw/cls_rgw_client.h b/src/cls/rgw/cls_rgw_client.h index ac062b987ae..c3dec6932e0 100644 --- a/src/cls/rgw/cls_rgw_client.h +++ b/src/cls/rgw/cls_rgw_client.h @@ -381,7 +381,7 @@ void cls_rgw_bucket_link_olh(librados::ObjectWriteOperation& op, uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time, bool log_op, const rgw_zone_set& zones_trace); void cls_rgw_bucket_unlink_instance(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& key, const std::string& op_tag, - const std::string& olh_tag, uint64_t olh_epoch, bool log_op, const rgw_zone_set& zones_trace); + const std::string& olh_tag, uint64_t olh_epoch, bool log_op, bool null_verid, const rgw_zone_set& zones_trace); void cls_rgw_get_olh_log(librados::ObjectReadOperation& op, const cls_rgw_obj_key& olh, uint64_t ver_marker, const std::string& olh_tag, rgw_cls_read_olh_log_ret& log_ret, int& op_ret); void cls_rgw_trim_olh_log(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& olh, uint64_t ver, const std::string& olh_tag); void cls_rgw_clear_olh(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& olh, const std::string& olh_tag); @@ -395,7 +395,8 @@ int cls_rgw_bucket_link_olh(librados::IoCtx& io_ctx, const std::string& oid, uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time, bool log_op, const rgw_zone_set& zones_trace); int cls_rgw_bucket_unlink_instance(librados::IoCtx& io_ctx, const std::string& oid, const cls_rgw_obj_key& key, const std::string& op_tag, - const std::string& olh_tag, uint64_t olh_epoch, bool log_op, const rgw_zone_set& zones_trace); + const std::string& olh_tag, uint64_t olh_epoch, bool log_op, + bool null_verid, const rgw_zone_set& zones_trace); int cls_rgw_get_olh_log(librados::IoCtx& io_ctx, std::string& oid, const cls_rgw_obj_key& olh, uint64_t ver_marker, const std::string& olh_tag, rgw_cls_read_olh_log_ret& log_ret); int cls_rgw_clear_olh(librados::IoCtx& io_ctx, std::string& oid, const cls_rgw_obj_key& olh, const std::string& olh_tag); diff --git a/src/cls/rgw/cls_rgw_ops.h b/src/cls/rgw/cls_rgw_ops.h index b824c73d3d0..f6ae362f5da 100644 --- a/src/cls/rgw/cls_rgw_ops.h +++ b/src/cls/rgw/cls_rgw_ops.h @@ -239,11 +239,12 @@ struct rgw_cls_unlink_instance_op { uint16_t bilog_flags; std::string olh_tag; rgw_zone_set zones_trace; + bool null_verid; rgw_cls_unlink_instance_op() : olh_epoch(0), log_op(false), bilog_flags(0) {} void encode(ceph::buffer::list& bl) const { - ENCODE_START(3, 1, bl); + ENCODE_START(4, 1, bl); encode(key, bl); encode(op_tag, bl); encode(olh_epoch, bl); @@ -251,11 +252,12 @@ struct rgw_cls_unlink_instance_op { encode(bilog_flags, bl); encode(olh_tag, bl); encode(zones_trace, bl); + encode(null_verid, bl); ENCODE_FINISH(bl); } void decode(ceph::buffer::list::const_iterator& bl) { - DECODE_START(3, bl); + DECODE_START(4, bl); decode(key, bl); decode(op_tag, bl); decode(olh_epoch, bl); @@ -267,6 +269,9 @@ struct rgw_cls_unlink_instance_op { if (struct_v >= 3) { decode(zones_trace, bl); } + if (struct_v >= 4) { + decode(null_verid, bl); + } DECODE_FINISH(bl); } diff --git a/src/cls/rgw/cls_rgw_types.h b/src/cls/rgw/cls_rgw_types.h index 07f05bc5be4..4f4dd9c1014 100644 --- a/src/cls/rgw/cls_rgw_types.h +++ b/src/cls/rgw/cls_rgw_types.h @@ -111,6 +111,7 @@ inline std::ostream& operator<<(std::ostream& out, RGWModifyOp op) { enum RGWBILogFlags { RGW_BILOG_FLAG_VERSIONED_OP = 0x1, + RGW_BILOG_NULL_VERSION = 0X2, }; enum RGWCheckMTimeType { @@ -660,6 +661,11 @@ struct rgw_bi_log_entry { bool is_versioned() { return ((bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0); } + + bool is_null_verid() { + return ((bilog_flags & RGW_BILOG_NULL_VERSION) != 0); + } + }; WRITE_CLASS_ENCODER(rgw_bi_log_entry) diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc index 08de61b172b..14219dad4a8 100644 --- a/src/rgw/driver/rados/rgw_bucket.cc +++ b/src/rgw/driver/rados/rgw_bucket.cc @@ -146,9 +146,6 @@ bool rgw_bucket_object_check_filter(const std::string& oid) 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"; - } std::unique_ptr object = bucket->get_object(key); diff --git a/src/rgw/driver/rados/rgw_cr_rados.cc b/src/rgw/driver/rados/rgw_cr_rados.cc index 3e367984ecf..5b69c5725ff 100644 --- a/src/rgw/driver/rados/rgw_cr_rados.cc +++ b/src/rgw/driver/rados/rgw_cr_rados.cc @@ -936,6 +936,7 @@ int RGWAsyncRemoveObj::_send_request(const DoutPrefixProvider *dpp) if (versioned) { del_op->params.versioning_status = BUCKET_VERSIONED; } + del_op->params.olh_epoch = versioned_epoch; del_op->params.marker_version_id = marker_version_id; del_op->params.obj_owner.id = rgw_user(owner); @@ -943,6 +944,7 @@ int RGWAsyncRemoveObj::_send_request(const DoutPrefixProvider *dpp) del_op->params.mtime = timestamp; del_op->params.high_precision_time = true; del_op->params.zones_trace = &zones_trace; + del_op->params.null_verid = false; ret = del_op->delete_obj(dpp, null_yield, true); if (ret < 0) { diff --git a/src/rgw/driver/rados/rgw_data_sync.cc b/src/rgw/driver/rados/rgw_data_sync.cc index dbea56d4de7..edf97d27975 100644 --- a/src/rgw/driver/rados/rgw_data_sync.cc +++ b/src/rgw/driver/rados/rgw_data_sync.cc @@ -4391,6 +4391,7 @@ class RGWBucketSyncSingleEntryCR : public RGWCoroutine { rgw_obj_key key; bool versioned; + bool null_verid; std::optional versioned_epoch; rgw_bucket_entry_owner owner; real_time timestamp; @@ -4418,6 +4419,7 @@ public: RGWBucketSyncSingleEntryCR(RGWDataSyncCtx *_sc, rgw_bucket_sync_pipe& _sync_pipe, const rgw_obj_key& _key, bool _versioned, + bool _null_verid, std::optional _versioned_epoch, real_time& _timestamp, const rgw_bucket_entry_owner& _owner, @@ -4426,7 +4428,8 @@ public: RGWSyncTraceNodeRef& _tn_parent) : RGWCoroutine(_sc->cct), sc(_sc), sync_env(_sc->env), sync_pipe(_sync_pipe), bs(_sync_pipe.info.source_bs), - key(_key), versioned(_versioned), versioned_epoch(_versioned_epoch), + key(_key), versioned(_versioned), + null_verid(_null_verid),versioned_epoch(_versioned_epoch), owner(_owner), timestamp(_timestamp), op(_op), op_state(_op_state), @@ -4504,6 +4507,9 @@ public: if (op == CLS_RGW_OP_UNLINK_INSTANCE) { versioned = true; } + if (null_verid) { + key.instance = "null"; + } tn->log(10, SSTR("removing obj: " << sc->source_zone << "/" << bs.bucket << "/" << key << "[" << versioned_epoch.value_or(0) << "]")); call(data_sync_module->remove_object(dpp, sc, sync_pipe, key, timestamp, versioned, versioned_epoch.value_or(0), &zones_trace)); // our copy of the object is more recent, continue as if it succeeded @@ -4714,6 +4720,7 @@ int RGWBucketFullSyncCR::operate(const DoutPrefixProvider *dpp) using SyncCR = RGWBucketSyncSingleEntryCR; yield spawn(new SyncCR(sc, sync_pipe, entry->key, false, /* versioned, only matters for object removal */ + false, entry->versioned_epoch, entry->mtime, entry->owner, entry->get_modify_op(), CLS_RGW_STATE_COMPLETE, entry->key, &marker_tracker, zones_trace, tn), @@ -5122,7 +5129,7 @@ int RGWBucketShardIncrementalSyncCR::operate(const DoutPrefixProvider *dpp) tn->log(20, SSTR("entry->timestamp=" << entry->timestamp)); using SyncCR = RGWBucketSyncSingleEntryCR; spawn(new SyncCR(sc, sync_pipe, key, - entry->is_versioned(), versioned_epoch, + entry->is_versioned(), entry->is_null_verid(), versioned_epoch, entry->timestamp, owner, entry->op, entry->state, cur_id, &marker_tracker, entry->zones_trace, tn), false); diff --git a/src/rgw/driver/rados/rgw_rados.cc b/src/rgw/driver/rados/rgw_rados.cc index ec1bd23f59c..793e1729049 100644 --- a/src/rgw/driver/rados/rgw_rados.cc +++ b/src/rgw/driver/rados/rgw_rados.cc @@ -3055,7 +3055,7 @@ int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx, /* Need to remove the archived copy. */ ret = delete_obj(dpp, obj_ctx, archive_binfo, archive_obj, - archive_binfo.versioning_status(), y); + archive_binfo.versioning_status(), y, false); return ret; }; @@ -5738,7 +5738,7 @@ int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvi } result.delete_marker = dirent.is_delete_marker(); r = store->unlink_obj_instance(dpp, target->get_ctx(), target->get_bucket_info(), obj, params.olh_epoch, - y, params.zones_trace, add_log); + y, params.null_verid, params.zones_trace, add_log); if (r < 0) { return r; } @@ -5834,6 +5834,11 @@ int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvi index_op.set_zones_trace(params.zones_trace); index_op.set_bilog_flags(params.bilog_flags); + if (params.null_verid) { + index_op.set_bilog_flags(params.bilog_flags | RGW_BILOG_NULL_VERSION); + } + + r = index_op.prepare(dpp, CLS_RGW_OP_DEL, &state->write_tag, y, log_op); if (r < 0) return r; @@ -5885,6 +5890,7 @@ int RGWRados::delete_obj(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw_obj& obj, int versioning_status, optional_yield y,// versioning flags defined in enum RGWBucketFlags + bool null_verid, uint16_t bilog_flags, const real_time& expiration_time, rgw_zone_set *zones_trace, @@ -5898,6 +5904,7 @@ int RGWRados::delete_obj(const DoutPrefixProvider *dpp, del_op.params.bilog_flags = bilog_flags; del_op.params.expiration_time = expiration_time; del_op.params.zones_trace = zones_trace; + del_op.params.null_verid = null_verid; return del_op.delete_obj(y, dpp, log_op ? rgw::sal::FLAG_LOG_OP : 0); } @@ -7840,7 +7847,7 @@ int RGWRados::bucket_index_unlink_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const rgw_obj& obj_instance, const string& op_tag, const string& olh_tag, - uint64_t olh_epoch, optional_yield y, + uint64_t olh_epoch, optional_yield y, bool null_verid, rgw_zone_set *_zones_trace, bool log_op) { rgw_rados_ref ref; @@ -7865,7 +7872,7 @@ int RGWRados::bucket_index_unlink_instance(const DoutPrefixProvider *dpp, op.assert_exists(); // bucket index shard must exist cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING); cls_rgw_bucket_unlink_instance(op, key, op_tag, - olh_tag, olh_epoch, log_op, zones_trace); + olh_tag, olh_epoch, log_op, null_verid, zones_trace); return rgw_rados_operate(dpp, ref.ioctx, ref.obj.oid, &op, y); }, y); if (r < 0) { @@ -8068,8 +8075,10 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, bufferlist& olh_tag, std::map >& log, uint64_t *plast_ver, - optional_yield y, rgw_zone_set* zones_trace, - bool log_op) + optional_yield y, + bool null_verid, + rgw_zone_set* zones_trace, + bool log_op) { if (log.empty()) { return 0; @@ -8182,7 +8191,7 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, liter != remove_instances.end(); ++liter) { cls_rgw_obj_key& key = *liter; rgw_obj obj_instance(bucket, key); - int ret = delete_obj(dpp, obj_ctx, bucket_info, obj_instance, 0, y, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace, log_op); + int ret = delete_obj(dpp, obj_ctx, bucket_info, obj_instance, 0, y, null_verid, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace, log_op); if (ret < 0 && ret != -ENOENT) { ldpp_dout(dpp, 0) << "ERROR: delete_obj() returned " << ret << " obj_instance=" << obj_instance << dendl; return ret; @@ -8286,7 +8295,7 @@ int RGWRados::clear_olh(const DoutPrefixProvider *dpp, /* * read olh log and apply it */ -int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y, rgw_zone_set *zones_trace, bool log_op) +int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y, rgw_zone_set *zones_trace, bool null_verid, bool log_op) { map > log; bool is_truncated; @@ -8297,7 +8306,7 @@ int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, R if (ret < 0) { return ret; } - ret = apply_olh_log(dpp, obj_ctx, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, y, zones_trace, log_op); + ret = apply_olh_log(dpp, obj_ctx, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, y, null_verid, zones_trace, log_op); if (ret < 0) { return ret; } @@ -8399,7 +8408,7 @@ int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, } int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj, - uint64_t olh_epoch, optional_yield y, rgw_zone_set *zones_trace, bool log_op) + uint64_t olh_epoch, optional_yield y, bool null_verid, rgw_zone_set *zones_trace, bool log_op) { string op_tag; @@ -8438,7 +8447,7 @@ int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& o std::this_thread::sleep_for(cct->_conf->rgw_debug_inject_latency_bi_unlink * std::chrono::seconds{1}); } - ret = bucket_index_unlink_instance(dpp, bucket_info, target_obj, op_tag, olh_tag, olh_epoch, y, zones_trace, log_op); + ret = bucket_index_unlink_instance(dpp, bucket_info, target_obj, op_tag, olh_tag, olh_epoch, y, null_verid, zones_trace, log_op); if (ret < 0) { olh_cancel_modification(dpp, bucket_info, *state, olh_obj, op_tag, y); ldpp_dout(dpp, 20) << "bucket_index_unlink_instance() target_obj=" << target_obj << " returned " << ret << dendl; @@ -8448,7 +8457,7 @@ int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& o // it's possible that the pending xattr from this op prevented the olh // object from being cleaned by another thread that was deleting the last // existing version. We invoke a best-effort update_olh here to handle this case. - int r = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj, y, zones_trace, log_op); + int r = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj, y, zones_trace, null_verid, log_op); if (r < 0 && r != -ECANCELED) { ldpp_dout(dpp, 20) << "update_olh() target_obj=" << olh_obj << " returned " << r << dendl; } @@ -8462,7 +8471,7 @@ int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& o return -EIO; } - ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj, y, zones_trace, log_op); + ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj, y, zones_trace, null_verid, log_op); if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */ return 0; } diff --git a/src/rgw/driver/rados/rgw_rados.h b/src/rgw/driver/rados/rgw_rados.h index 2a2b4d85edc..e405afbf3a2 100644 --- a/src/rgw/driver/rados/rgw_rados.h +++ b/src/rgw/driver/rados/rgw_rados.h @@ -841,6 +841,7 @@ public: struct DeleteParams { rgw_owner bucket_owner; // for quota stats update int versioning_status; // versioning flags defined in enum RGWBucketFlags + bool null_verid; ACLOwner obj_owner; // needed for creation of deletion marker uint64_t olh_epoch; std::string marker_version_id; @@ -854,7 +855,7 @@ public: bool abortmp; uint64_t parts_accounted_size; - DeleteParams() : versioning_status(0), olh_epoch(0), bilog_flags(0), remove_objs(NULL), high_precision_time(false), zones_trace(nullptr), abortmp(false), parts_accounted_size(0) {} + DeleteParams() : versioning_status(0), null_verid(false), olh_epoch(0), bilog_flags(0), remove_objs(NULL), high_precision_time(false), zones_trace(nullptr), abortmp(false), parts_accounted_size(0) {} } params; struct DeleteResult { @@ -968,6 +969,10 @@ public: bilog_flags = flags; } + int get_bilog_flags() { + return bilog_flags; + } + void set_zones_trace(rgw_zone_set *_zones_trace) { zones_trace = _zones_trace; } @@ -1259,6 +1264,7 @@ public: const RGWBucketInfo& bucket_info, const rgw_obj& obj, int versioning_status, optional_yield y, // versioning flags defined in enum RGWBucketFlags + bool null_verid, uint16_t bilog_flags = 0, const ceph::real_time& expiration_time = ceph::real_time(), rgw_zone_set *zones_trace = nullptr, @@ -1353,6 +1359,7 @@ public: const rgw_obj& obj_instance, const std::string& op_tag, const std::string& olh_tag, uint64_t olh_epoch, optional_yield y, + bool null_verid, rgw_zone_set *zones_trace = nullptr, bool log_op = true); int bucket_index_read_olh_log(const DoutPrefixProvider *dpp, @@ -1363,9 +1370,9 @@ public: int bucket_index_clear_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const std::string& olh_tag, const rgw_obj& obj_instance, optional_yield y); int apply_olh_log(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState& obj_state, RGWBucketInfo& bucket_info, const rgw_obj& obj, bufferlist& obj_tag, std::map >& log, - uint64_t *plast_ver, optional_yield y, rgw_zone_set *zones_trace = nullptr, bool log_op = true); + uint64_t *plast_ver, optional_yield y, bool null_verid, rgw_zone_set *zones_trace = nullptr, bool log_op = true); int update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y, - rgw_zone_set *zones_trace = nullptr, bool log_op = true); + rgw_zone_set *zones_trace = nullptr, bool null_verid = false, bool log_op = true); int clear_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, const rgw_obj& obj, @@ -1389,7 +1396,7 @@ public: int repair_olh(const DoutPrefixProvider *dpp, RGWObjState* state, const RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y); int unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj, - uint64_t olh_epoch, optional_yield y, rgw_zone_set *zones_trace = nullptr, bool log_op = true); + uint64_t olh_epoch, optional_yield y, bool null_verid, rgw_zone_set *zones_trace = nullptr, bool log_op = true); void check_pending_olh_entries(const DoutPrefixProvider *dpp, std::map& pending_entries, std::map *rm_pending_entries); int remove_olh_pending_entries(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, std::map& pending_attrs, optional_yield y); diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc index 9057bc7af44..b478d4bde7a 100644 --- a/src/rgw/driver/rados/rgw_sal_rados.cc +++ b/src/rgw/driver/rados/rgw_sal_rados.cc @@ -2810,6 +2810,7 @@ int RadosObject::RadosDeleteOp::delete_obj(const DoutPrefixProvider* dpp, option parent_op.params.zones_trace = params.zones_trace; parent_op.params.abortmp = params.abortmp; parent_op.params.parts_accounted_size = params.parts_accounted_size; + parent_op.params.null_verid = params.null_verid; int ret = parent_op.delete_obj(y, dpp, flags & FLAG_LOG_OP); if (ret < 0) diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc index c2a8d05bb06..39633a899ea 100644 --- a/src/rgw/rgw_op.cc +++ b/src/rgw/rgw_op.cc @@ -5119,9 +5119,16 @@ void RGWDeleteObj::execute(optional_yield y) if (!rgw::sal::Object::empty(s->object.get())) { uint64_t obj_size = 0; std::string etag; + bool null_verid; { int state_loaded = -1; bool check_obj_lock = s->object->have_instance() && s->bucket->get_info().obj_lock_enabled(); + if (s->object->get_instance() == "null") { + null_verid = 1; + } else { + null_verid = 0; + } + op_ret = state_loaded = s->object->load_obj_state(this, s->yield, true); if (op_ret < 0) { if (need_object_expiration() || multipart_delete) { @@ -5218,7 +5225,9 @@ void RGWDeleteObj::execute(optional_yield y) del_op->params.high_precision_time = s->system_request; del_op->params.olh_epoch = epoch; del_op->params.marker_version_id = version_id; + del_op->params.null_verid = null_verid; + ldpp_dout(this, 1) << "del_op->params.null_verid " << del_op->params.null_verid << dendl; op_ret = del_op->delete_obj(this, y, rgw::sal::FLAG_LOG_OP); if (op_ret >= 0) { delete_marker = del_op->result.delete_marker; diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h index 5fd20fda692..f90b08aa6a7 100644 --- a/src/rgw/rgw_sal.h +++ b/src/rgw/rgw_sal.h @@ -1081,6 +1081,7 @@ class Object { rgw_owner bucket_owner; //< bucket owner for usage/quota accounting ACLOwner obj_owner; //< acl owner for delete marker if necessary int versioning_status{0}; + bool null_verid{false}; uint64_t olh_epoch{0}; std::string marker_version_id; uint32_t bilog_flags{0}; -- 2.39.5