From c652f76c97337b39665bcf64b6e655275c3832e7 Mon Sep 17 00:00:00 2001 From: Casey Bodley Date: Sat, 18 Feb 2023 13:11:45 -0500 Subject: [PATCH] rgw/rados: remove sal handles from RGWRados::Object ops Signed-off-by: Casey Bodley (cherry picked from commit f4df0acb01171cff86c8ec1ab455798f2b4bf6dd) Conflicts: src/rgw/driver/rados/rgw_rados.cc need_to_log_data() src/rgw/driver/rados/rgw_rados.h reindex_obj() --- src/rgw/driver/rados/rgw_cr_rados.cc | 16 +- src/rgw/driver/rados/rgw_data_sync.cc | 6 +- src/rgw/driver/rados/rgw_data_sync.h | 4 +- src/rgw/driver/rados/rgw_lc_tier.cc | 65 +-- src/rgw/driver/rados/rgw_obj_manifest.h | 4 +- src/rgw/driver/rados/rgw_putobj_processor.cc | 131 +++--- src/rgw/driver/rados/rgw_putobj_processor.h | 69 +-- src/rgw/driver/rados/rgw_rados.cc | 462 +++++++++---------- src/rgw/driver/rados/rgw_rados.h | 111 +++-- src/rgw/driver/rados/rgw_sal_rados.cc | 108 +++-- src/rgw/driver/rados/rgw_sal_rados.h | 53 ++- src/rgw/driver/rados/rgw_sync_module_aws.cc | 94 ++-- src/rgw/driver/rados/rgw_tools.cc | 2 +- src/rgw/rgw_admin.cc | 6 +- src/rgw/rgw_file.cc | 2 +- src/rgw/rgw_op.cc | 10 +- src/rgw/rgw_orphan.cc | 16 +- src/rgw/rgw_rest_client.cc | 10 +- src/rgw/rgw_rest_client.h | 4 +- src/rgw/rgw_rest_conn.cc | 15 +- src/rgw/rgw_rest_conn.h | 8 +- src/rgw/rgw_sal.h | 6 +- src/rgw/rgw_sal_daos.cc | 14 +- src/rgw/rgw_sal_daos.h | 10 +- src/rgw/rgw_sal_dbstore.cc | 20 +- src/rgw/rgw_sal_dbstore.h | 12 +- src/rgw/rgw_sal_filter.cc | 24 +- src/rgw/rgw_sal_filter.h | 12 +- src/rgw/rgw_sal_motr.cc | 16 +- src/rgw/rgw_sal_motr.h | 14 +- 30 files changed, 628 insertions(+), 696 deletions(-) diff --git a/src/rgw/driver/rados/rgw_cr_rados.cc b/src/rgw/driver/rados/rgw_cr_rados.cc index aac0b76e1e6..a3efedb2713 100644 --- a/src/rgw/driver/rados/rgw_cr_rados.cc +++ b/src/rgw/driver/rados/rgw_cr_rados.cc @@ -736,8 +736,8 @@ int RGWAsyncFetchRemoteObj::_send_request(const DoutPrefixProvider *dpp) snprintf(buf, sizeof(buf), ".%lld", (long long)store->getRados()->instance_id()); rgw::sal::Attrs attrs; - rgw::sal::RadosBucket bucket(store, src_bucket); - rgw::sal::RadosObject src_obj(store, key, &bucket); + rgw_obj src_obj(src_bucket, key); + rgw::sal::RadosBucket dest_bucket(store, dest_bucket_info); rgw::sal::RadosObject dest_obj(store, dest_key.value_or(key), &dest_bucket); @@ -748,9 +748,9 @@ int RGWAsyncFetchRemoteObj::_send_request(const DoutPrefixProvider *dpp) user_id.value_or(rgw_user()), NULL, /* req_info */ source_zone, - &dest_obj, - &src_obj, - &dest_bucket, /* dest */ + dest_obj.get_obj(), + src_obj, + dest_bucket_info, /* dest */ nullptr, /* source */ dest_placement_rule, nullptr, /* real_time* src_mtime, */ @@ -839,15 +839,15 @@ int RGWAsyncStatRemoteObj::_send_request(const DoutPrefixProvider *dpp) char buf[16]; snprintf(buf, sizeof(buf), ".%lld", (long long)store->getRados()->instance_id()); - rgw::sal::RadosBucket bucket(store, src_bucket); - rgw::sal::RadosObject src_obj(store, key, &bucket); + + rgw_obj src_obj(src_bucket, key); int r = store->getRados()->stat_remote_obj(dpp, obj_ctx, rgw_user(user_id), nullptr, /* req_info */ source_zone, - &src_obj, + src_obj, nullptr, /* source */ pmtime, /* real_time* src_mtime, */ psize, /* uint64_t * */ diff --git a/src/rgw/driver/rados/rgw_data_sync.cc b/src/rgw/driver/rados/rgw_data_sync.cc index 4ca79917c42..5981effda64 100644 --- a/src/rgw/driver/rados/rgw_data_sync.cc +++ b/src/rgw/driver/rados/rgw_data_sync.cc @@ -6428,14 +6428,14 @@ string RGWBucketPipeSyncStatusManager::inc_status_oid(const rgw_zone_id& source_ string RGWBucketPipeSyncStatusManager::obj_status_oid(const rgw_bucket_sync_pipe& sync_pipe, const rgw_zone_id& source_zone, - const rgw::sal::Object* obj) + const rgw_obj& obj) { - string prefix = object_status_oid_prefix + "." + source_zone.id + ":" + obj->get_bucket()->get_key().get_key(); + string prefix = object_status_oid_prefix + "." + source_zone.id + ":" + obj.bucket.get_key(); if (sync_pipe.source_bucket_info.bucket != sync_pipe.dest_bucket_info.bucket) { prefix += string("/") + sync_pipe.dest_bucket_info.bucket.get_key(); } - return prefix + ":" + obj->get_name() + ":" + obj->get_instance(); + return prefix + ":" + obj.key.name + ":" + obj.key.instance; } int rgw_read_remote_bilog_info(const DoutPrefixProvider *dpp, diff --git a/src/rgw/driver/rados/rgw_data_sync.h b/src/rgw/driver/rados/rgw_data_sync.h index 9059bd14cce..b9a39343f75 100644 --- a/src/rgw/driver/rados/rgw_data_sync.h +++ b/src/rgw/driver/rados/rgw_data_sync.h @@ -823,8 +823,8 @@ public: uint64_t gen); // specific source obj sync status, can be used by sync modules static std::string obj_status_oid(const rgw_bucket_sync_pipe& sync_pipe, - const rgw_zone_id& source_zone, const rgw::sal::Object* obj); /* specific source obj sync status, - can be used by sync modules */ + const rgw_zone_id& source_zone, + const rgw_obj& obj); // implements DoutPrefixProvider CephContext *get_cct() const override; diff --git a/src/rgw/driver/rados/rgw_lc_tier.cc b/src/rgw/driver/rados/rgw_lc_tier.cc index 59a3106f065..c52acef654f 100644 --- a/src/rgw/driver/rados/rgw_lc_tier.cc +++ b/src/rgw/driver/rados/rgw_lc_tier.cc @@ -237,35 +237,24 @@ static void init_headers(map& attrs, static int cloud_tier_get_object(RGWLCCloudTierCtx& tier_ctx, bool head, std::map& headers) { RGWRESTConn::get_obj_params req_params; - RGWBucketInfo b; std::string target_obj_name; int ret = 0; - std::unique_ptr dest_bucket; - std::unique_ptr dest_obj; rgw_lc_obj_properties obj_properties(tier_ctx.o.meta.mtime, tier_ctx.o.meta.etag, tier_ctx.o.versioned_epoch, tier_ctx.acl_mappings, tier_ctx.target_storage_class); std::string etag; RGWRESTStreamRWRequest *in_req; - b.bucket.name = tier_ctx.target_bucket_name; + rgw_bucket dest_bucket; + dest_bucket.name = tier_ctx.target_bucket_name; target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + tier_ctx.obj->get_name(); if (!tier_ctx.o.is_current()) { target_obj_name += get_key_instance(tier_ctx.obj->get_key()); } - ret = tier_ctx.driver->get_bucket(nullptr, b, &dest_bucket); - if (ret < 0) { - ldpp_dout(tier_ctx.dpp, 0) << "ERROR: failed to initialize dest_bucket - " << tier_ctx.target_bucket_name << " , reterr = " << ret << dendl; - return ret; - } + rgw_obj dest_obj(dest_bucket, rgw_obj_key(target_obj_name)); - dest_obj = dest_bucket->get_object(rgw_obj_key(target_obj_name)); - if (!dest_obj) { - ldpp_dout(tier_ctx.dpp, 0) << "ERROR: failed to initialize dest_object path - " << target_obj_name << dendl; - return -1; - } /* init input connection */ req_params.get_op = !head; req_params.prepend_metadata = true; @@ -273,7 +262,7 @@ static int cloud_tier_get_object(RGWLCCloudTierCtx& tier_ctx, bool head, req_params.sync_manifest = true; req_params.skip_decrypt = true; - ret = tier_ctx.conn.get_obj(tier_ctx.dpp, dest_obj.get(), req_params, true /* send */, &in_req); + ret = tier_ctx.conn.get_obj(tier_ctx.dpp, dest_obj, req_params, true /* send */, &in_req); if (ret < 0) { ldpp_dout(tier_ctx.dpp, 0) << "ERROR: " << __func__ << "(): conn.get_obj() returned ret=" << ret << dendl; return ret; @@ -360,7 +349,7 @@ class RGWLCCloudStreamPut const DoutPrefixProvider *dpp; rgw_lc_obj_properties obj_properties; RGWRESTConn& conn; - rgw::sal::Object *dest_obj; + const rgw_obj& dest_obj; std::string etag; RGWRESTStreamS3PutObj *out_req{nullptr}; @@ -377,7 +366,7 @@ class RGWLCCloudStreamPut RGWLCCloudStreamPut(const DoutPrefixProvider *_dpp, const rgw_lc_obj_properties& _obj_properties, RGWRESTConn& _conn, - rgw::sal::Object *_dest_obj) : + const rgw_obj& _dest_obj) : dpp(_dpp), obj_properties(_obj_properties), conn(_conn), dest_obj(_dest_obj) { } int init(); @@ -763,33 +752,22 @@ static int cloud_tier_transfer_object(const DoutPrefixProvider* dpp, static int cloud_tier_plain_transfer(RGWLCCloudTierCtx& tier_ctx) { int ret; - std::unique_ptr dest_bucket; - std::unique_ptr dest_obj; rgw_lc_obj_properties obj_properties(tier_ctx.o.meta.mtime, tier_ctx.o.meta.etag, tier_ctx.o.versioned_epoch, tier_ctx.acl_mappings, tier_ctx.target_storage_class); - RGWBucketInfo b; std::string target_obj_name; - b.bucket.name = tier_ctx.target_bucket_name; + rgw_bucket dest_bucket; + dest_bucket.name = tier_ctx.target_bucket_name; + target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + tier_ctx.obj->get_name(); if (!tier_ctx.o.is_current()) { target_obj_name += get_key_instance(tier_ctx.obj->get_key()); } - ret = tier_ctx.driver->get_bucket(nullptr, b, &dest_bucket); - if (ret < 0) { - ldpp_dout(tier_ctx.dpp, 0) << "ERROR: failed to initialize dest_bucket - " << tier_ctx.target_bucket_name << " , ret = " << ret << dendl; - return ret; - } - - dest_obj = dest_bucket->get_object(rgw_obj_key(target_obj_name)); - if (!dest_obj) { - ldpp_dout(tier_ctx.dpp, 0) << "ERROR: failed to initialize dest_object path - " << target_obj_name << dendl; - return -1; - } + rgw_obj dest_obj(dest_bucket, rgw_obj_key(target_obj_name)); tier_ctx.obj->set_atomic(); @@ -804,7 +782,7 @@ static int cloud_tier_plain_transfer(RGWLCCloudTierCtx& tier_ctx) { std::shared_ptr writef; writef.reset(new RGWLCCloudStreamPut(tier_ctx.dpp, obj_properties, tier_ctx.conn, - dest_obj.get())); + dest_obj)); /* actual Read & Write */ ret = cloud_tier_transfer_object(tier_ctx.dpp, readf.get(), writef.get()); @@ -817,34 +795,23 @@ static int cloud_tier_send_multipart_part(RGWLCCloudTierCtx& tier_ctx, const rgw_lc_multipart_part_info& part_info, std::string *petag) { int ret; - std::unique_ptr dest_bucket; - std::unique_ptr dest_obj; rgw_lc_obj_properties obj_properties(tier_ctx.o.meta.mtime, tier_ctx.o.meta.etag, tier_ctx.o.versioned_epoch, tier_ctx.acl_mappings, tier_ctx.target_storage_class); - RGWBucketInfo b; std::string target_obj_name; off_t end; - b.bucket.name = tier_ctx.target_bucket_name; + rgw_bucket dest_bucket; + dest_bucket.name = tier_ctx.target_bucket_name; + target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + tier_ctx.obj->get_name(); if (!tier_ctx.o.is_current()) { target_obj_name += get_key_instance(tier_ctx.obj->get_key()); } - ret = tier_ctx.driver->get_bucket(nullptr, b, &dest_bucket); - if (ret < 0) { - ldpp_dout(tier_ctx.dpp, 0) << "ERROR: failed to initialize dest_bucket - " << tier_ctx.target_bucket_name << " , ret = " << ret << dendl; - return ret; - } - - dest_obj = dest_bucket->get_object(rgw_obj_key(target_obj_name)); - if (!dest_obj) { - ldpp_dout(tier_ctx.dpp, 0) << "ERROR: failed to initialize dest_object path - " << target_obj_name << dendl; - return -1; - } + rgw_obj dest_obj(dest_bucket, rgw_obj_key(target_obj_name)); tier_ctx.obj->set_atomic(); @@ -857,7 +824,7 @@ static int cloud_tier_send_multipart_part(RGWLCCloudTierCtx& tier_ctx, std::shared_ptr writef; writef.reset(new RGWLCCloudStreamPut(tier_ctx.dpp, obj_properties, tier_ctx.conn, - dest_obj.get())); + dest_obj)); /* Prepare Read from source */ end = part_info.ofs + part_info.size - 1; diff --git a/src/rgw/driver/rados/rgw_obj_manifest.h b/src/rgw/driver/rados/rgw_obj_manifest.h index 99c5eeee35a..3442cdc8425 100644 --- a/src/rgw/driver/rados/rgw_obj_manifest.h +++ b/src/rgw/driver/rados/rgw_obj_manifest.h @@ -58,7 +58,7 @@ public: } rgw_raw_obj get_raw_obj(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params) const; - rgw_raw_obj get_raw_obj(rgw::sal::RadosStore* store) const; + rgw_raw_obj get_raw_obj(RGWRados* store) const; rgw_obj_select& operator=(const rgw_obj& rhs) { obj = rhs; @@ -607,7 +607,7 @@ public: int create_next(uint64_t ofs); rgw_raw_obj get_cur_obj(RGWZoneGroup& zonegroup, RGWZoneParams& zone_params) { return cur_obj.get_raw_obj(zonegroup, zone_params); } - rgw_raw_obj get_cur_obj(rgw::sal::RadosStore* store) const { return cur_obj.get_raw_obj(store); } + rgw_raw_obj get_cur_obj(RGWRados* store) const { return cur_obj.get_raw_obj(store); } /* total max size of current stripe (including head obj) */ uint64_t cur_stripe_max_size() const { diff --git a/src/rgw/driver/rados/rgw_putobj_processor.cc b/src/rgw/driver/rados/rgw_putobj_processor.cc index 449c3b14db2..e453db5a99f 100644 --- a/src/rgw/driver/rados/rgw_putobj_processor.cc +++ b/src/rgw/driver/rados/rgw_putobj_processor.cc @@ -114,8 +114,7 @@ static int process_completed(const AioResultList& completed, RawObjSet *written) } void RadosWriter::add_write_hint(librados::ObjectWriteOperation& op) { - const rgw_obj obj = head_obj->get_obj(); - const RGWObjStateManifest *sm = obj_ctx.get_state(obj); + const RGWObjStateManifest *sm = obj_ctx.get_state(head_obj); const bool compressed = sm->state.compressed; uint32_t alloc_hint_flags = 0; if (compressed) { @@ -127,7 +126,7 @@ void RadosWriter::add_write_hint(librados::ObjectWriteOperation& op) { int RadosWriter::set_stripe_obj(const rgw_raw_obj& raw_obj) { - stripe_obj = store->svc()->rados->obj(raw_obj); + stripe_obj = store->svc.rados->obj(raw_obj); return stripe_obj.open(dpp); } @@ -178,10 +177,9 @@ RadosWriter::~RadosWriter() bool need_to_remove_head = false; std::optional raw_head; - if (!rgw::sal::Object::empty(head_obj.get())) { + if (!head_obj.empty()) { raw_head.emplace(); - rgw::sal::RadosObject* obj = dynamic_cast(head_obj.get()); - obj->get_raw_obj(&*raw_head); + store->obj_to_raw(bucket_info.placement_rule, head_obj, &*raw_head); } /** @@ -212,7 +210,7 @@ RadosWriter::~RadosWriter() if (need_to_remove_head) { std::string version_id; ldpp_dout(dpp, 5) << "NOTE: we are going to process the head obj (" << *raw_head << ")" << dendl; - int r = head_obj->delete_object(dpp, null_yield); + int r = store->delete_obj(dpp, obj_ctx, bucket_info, head_obj, 0, 0); if (r < 0 && r != -ENOENT) { ldpp_dout(dpp, 0) << "WARNING: failed to remove obj (" << *raw_head << "), leaked" << dendl; } @@ -232,7 +230,7 @@ int ManifestObjectProcessor::next(uint64_t offset, uint64_t *pstripe_size) rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store); uint64_t chunk_size = 0; - r = store->get_raw_chunk_size(dpp, stripe_obj, &chunk_size); + r = store->get_max_chunk_size(stripe_obj.pool, &chunk_size, dpp); if (r < 0) { return r; } @@ -262,29 +260,39 @@ int AtomicObjectProcessor::prepare(optional_yield y) uint64_t head_max_size; uint64_t chunk_size = 0; uint64_t alignment; + rgw_pool head_pool; - int r = dynamic_cast(head_obj.get())->get_max_chunk_size( - dpp, head_obj->get_bucket()->get_placement_rule(), - &max_head_chunk_size, &alignment); + if (!store->get_obj_data_pool(bucket_info.placement_rule, head_obj, &head_pool)) { + return -EIO; + } + + int r = store->get_max_chunk_size(head_pool, &max_head_chunk_size, dpp, &alignment); if (r < 0) { return r; } bool same_pool = true; - if (head_obj->get_bucket()->get_placement_rule() != tail_placement_rule) { - if (!head_obj->placement_rules_match(head_obj->get_bucket()->get_placement_rule(), tail_placement_rule)) { + if (bucket_info.placement_rule != tail_placement_rule) { + rgw_pool tail_pool; + if (!store->get_obj_data_pool(tail_placement_rule, head_obj, &tail_pool)) { + return -EIO; + } + + if (tail_pool != head_pool) { same_pool = false; - r = dynamic_cast(head_obj.get())->get_max_chunk_size(dpp, tail_placement_rule, &chunk_size); + + r = store->get_max_chunk_size(tail_pool, &chunk_size, dpp); if (r < 0) { return r; } + head_max_size = 0; } } if (same_pool) { RGWZonePlacementInfo placement_info; - if (!store->svc()->zone->get_zone_params().get_placement(head_obj->get_bucket()->get_placement_rule().name, &placement_info) || placement_info.inline_data) { + if (!store->svc.zone->get_zone_params().get_placement(bucket_info.placement_rule.name, &placement_info) || placement_info.inline_data) { head_max_size = max_head_chunk_size; } else { head_max_size = 0; @@ -295,17 +303,14 @@ int AtomicObjectProcessor::prepare(optional_yield y) uint64_t stripe_size; const uint64_t default_stripe_size = store->ctx()->_conf->rgw_obj_stripe_size; - dynamic_cast(head_obj.get())->get_max_aligned_size( - default_stripe_size, alignment, &stripe_size); + store->get_max_aligned_size(default_stripe_size, alignment, &stripe_size); manifest.set_trivial_rule(head_max_size, stripe_size); - rgw_obj obj = head_obj->get_obj(); - r = manifest_gen.create_begin(store->ctx(), &manifest, - head_obj->get_bucket()->get_placement_rule(), + bucket_info.placement_rule, &tail_placement_rule, - obj.bucket, obj); + head_obj.bucket, head_obj); if (r < 0) { return r; } @@ -346,15 +351,14 @@ int AtomicObjectProcessor::complete(size_t accounted_size, return r; } - head_obj->set_atomic(); + obj_ctx.set_atomic(head_obj); - RGWRados::Object op_target(store->getRados(), - head_obj->get_bucket(), - obj_ctx, head_obj.get()); - RGWRados::Object::Write obj_op(&op_target); + RGWRados::Object op_target(store, bucket_info, obj_ctx, head_obj); /* some object types shouldn't be versioned, e.g., multipart parts */ - op_target.set_versioning_disabled(!head_obj->get_bucket()->versioning_enabled()); + op_target.set_versioning_disabled(!bucket_info.versioning_enabled()); + + RGWRados::Object::Write obj_op(&op_target); obj_op.meta.data = &first_chunk; obj_op.meta.manifest = &manifest; obj_op.meta.ptag = &unique_tag; /* use req_id as operation tag */ @@ -402,8 +406,8 @@ int MultipartObjectProcessor::process_first_chunk(bufferlist&& data, // randomize the oid prefix and reprepare the head/manifest std::string oid_rand = gen_rand_alphanumeric(store->ctx(), 32); - mp.init(target_obj->get_name(), upload_id, oid_rand); - manifest.set_prefix(target_obj->get_name() + "." + oid_rand); + mp.init(target_obj.key.name, upload_id, oid_rand); + manifest.set_prefix(target_obj.key.name + "." + oid_rand); r = prepare_head(); if (r < 0) { @@ -426,29 +430,26 @@ int MultipartObjectProcessor::prepare_head() uint64_t stripe_size; uint64_t alignment; - int r = dynamic_cast(target_obj.get())->get_max_chunk_size(dpp, - tail_placement_rule, &chunk_size, &alignment); + int r = store->get_max_chunk_size(tail_placement_rule, target_obj, &chunk_size, dpp, &alignment); if (r < 0) { ldpp_dout(dpp, 0) << "ERROR: unexpected: get_max_chunk_size(): placement_rule=" << tail_placement_rule.to_str() << " obj=" << target_obj << " returned r=" << r << dendl; return r; } - dynamic_cast(target_obj.get())->get_max_aligned_size( - default_stripe_size, alignment, &stripe_size); + store->get_max_aligned_size(default_stripe_size, alignment, &stripe_size); manifest.set_multipart_part_rule(stripe_size, part_num); r = manifest_gen.create_begin(store->ctx(), &manifest, - head_obj->get_bucket()->get_placement_rule(), + bucket_info.placement_rule, &tail_placement_rule, - target_obj->get_bucket()->get_key(), - target_obj->get_obj()); + target_obj.bucket, target_obj); if (r < 0) { return r; } rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store); - dynamic_cast(head_obj.get())->raw_obj_to_obj(stripe_obj); - head_obj->set_hash_source(target_obj->get_name()); + RGWSI_Tier_RADOS::raw_obj_to_obj(head_obj.bucket, stripe_obj, &head_obj); + head_obj.index_hash_source = target_obj.key.name; r = writer.set_stripe_obj(stripe_obj); if (r < 0) { @@ -464,7 +465,7 @@ int MultipartObjectProcessor::prepare_head() int MultipartObjectProcessor::prepare(optional_yield y) { - manifest.set_prefix(target_obj->get_name() + "." + upload_id); + manifest.set_prefix(target_obj.key.name + "." + upload_id); return prepare_head(); } @@ -491,13 +492,11 @@ int MultipartObjectProcessor::complete(size_t accounted_size, return r; } - RGWRados::Object op_target(store->getRados(), - head_obj->get_bucket(), - obj_ctx, head_obj.get()); - RGWRados::Object::Write obj_op(&op_target); - + RGWRados::Object op_target(store, bucket_info, obj_ctx, head_obj); op_target.set_versioning_disabled(true); op_target.set_meta_placement_rule(&tail_placement_rule); + + RGWRados::Object::Write obj_op(&op_target); obj_op.meta.set_mtime = set_mtime; obj_op.meta.mtime = mtime; obj_op.meta.owner = owner; @@ -534,16 +533,15 @@ int MultipartObjectProcessor::complete(size_t accounted_size, return r; } - std::unique_ptr meta_obj = - head_obj->get_bucket()->get_object(rgw_obj_key(mp.get_meta(), std::string(), RGW_OBJ_NS_MULTIPART)); - meta_obj->set_in_extra_data(true); + rgw_obj meta_obj; + meta_obj.init_ns(bucket_info.bucket, mp.get_meta(), RGW_OBJ_NS_MULTIPART); + meta_obj.set_in_extra_data(true); rgw_raw_obj meta_raw_obj; - store->getRados()->obj_to_raw(meta_obj->get_bucket()->get_placement_rule(), - meta_obj->get_obj(), - &meta_raw_obj); + store->obj_to_raw(bucket_info.placement_rule, meta_obj, &meta_raw_obj); + rgw_rados_ref meta_obj_ref; - r = store->getRados()->get_raw_obj_ref(dpp, meta_raw_obj, &meta_obj_ref); + r = store->get_raw_obj_ref(dpp, meta_raw_obj, &meta_obj_ref); if (r < 0) { ldpp_dout(dpp, -1) << "ERROR: failed to get obj ref of meta obj with ret=" << r << dendl; return r; @@ -558,7 +556,14 @@ int MultipartObjectProcessor::complete(size_t accounted_size, // New CLS call to update part info is not yet supported. Fall back to the old handling. bufferlist bl; encode(info, bl); - r = meta_obj->omap_set_val_by_key(dpp, p, bl, true, null_yield); + + map m; + m[p] = bl; + + op = librados::ObjectWriteOperation{}; + op.assert_exists(); // detect races with abort + op.omap_set(m); + r = rgw_rados_operate(dpp, meta_obj_ref.pool.ioctx(), meta_obj_ref.obj.oid, &op, y); } if (r < 0) { return r == -ENOENT ? -ERR_NO_SUCH_UPLOAD : r; @@ -587,7 +592,8 @@ int AppendObjectProcessor::process_first_chunk(bufferlist &&data, rgw::sal::Data int AppendObjectProcessor::prepare(optional_yield y) { RGWObjState *astate; - int r = head_obj->get_obj_state(dpp, &astate, y); + int r = store->get_obj_state(dpp, &obj_ctx, bucket_info, head_obj, + &astate, &cur_manifest, y); if (r < 0) { return r; } @@ -602,7 +608,7 @@ int AppendObjectProcessor::prepare(optional_yield y) //set the prefix char buf[33]; gen_rand_alphanumeric(store->ctx(), buf, sizeof(buf) - 1); - string oid_prefix = head_obj->get_name(); + string oid_prefix = head_obj.key.name; oid_prefix.append("."); oid_prefix.append(buf); oid_prefix.append("_"); @@ -641,22 +647,19 @@ int AppendObjectProcessor::prepare(optional_yield y) } else { tail_placement_rule.storage_class = RGW_STORAGE_CLASS_STANDARD; } - cur_manifest = dynamic_cast(head_obj.get())->get_manifest(); manifest.set_prefix(cur_manifest->get_prefix()); astate->keep_tail = true; } manifest.set_multipart_part_rule(store->ctx()->_conf->rgw_obj_stripe_size, cur_part_num); - rgw_obj obj = head_obj->get_obj(); - - r = manifest_gen.create_begin(store->ctx(), &manifest, head_obj->get_bucket()->get_placement_rule(), &tail_placement_rule, obj.bucket, obj); + r = manifest_gen.create_begin(store->ctx(), &manifest, bucket_info.placement_rule, &tail_placement_rule, head_obj.bucket, head_obj); if (r < 0) { return r; } rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store); uint64_t chunk_size = 0; - r = store->get_raw_chunk_size(dpp, stripe_obj, &chunk_size); + r = store->get_max_chunk_size(stripe_obj.pool, &chunk_size, dpp); if (r < 0) { return r; } @@ -691,15 +694,13 @@ int AppendObjectProcessor::complete(size_t accounted_size, const string &etag, c if (r < 0) { return r; } - head_obj->set_atomic(); - RGWRados::Object op_target(store->getRados(), - head_obj->get_bucket(), - obj_ctx, head_obj.get()); - RGWRados::Object::Write obj_op(&op_target); + obj_ctx.set_atomic(head_obj); + RGWRados::Object op_target(store, bucket_info, obj_ctx, head_obj); //For Append obj, disable versioning op_target.set_versioning_disabled(true); + RGWRados::Object::Write obj_op(&op_target); if (cur_manifest) { - cur_manifest->append(dpp, manifest, store->svc()->zone->get_zonegroup(), store->svc()->zone->get_zone_params()); + cur_manifest->append(dpp, manifest, store->svc.zone->get_zonegroup(), store->svc.zone->get_zone_params()); obj_op.meta.manifest = cur_manifest; } else { obj_op.meta.manifest = &manifest; diff --git a/src/rgw/driver/rados/rgw_putobj_processor.h b/src/rgw/driver/rados/rgw_putobj_processor.h index 1beb9a724c0..fa9200f32da 100644 --- a/src/rgw/driver/rados/rgw_putobj_processor.h +++ b/src/rgw/driver/rados/rgw_putobj_processor.h @@ -66,26 +66,23 @@ using RawObjSet = std::set; // a data sink that writes to rados objects and deletes them on cancelation class RadosWriter : public rgw::sal::DataProcessor { Aio *const aio; - rgw::sal::RadosStore *const store; + RGWRados *const store; + const RGWBucketInfo& bucket_info; RGWObjectCtx& obj_ctx; - std::unique_ptr head_obj; + const rgw_obj head_obj; RGWSI_RADOS::Obj stripe_obj; // current stripe object RawObjSet written; // set of written objects for deletion const DoutPrefixProvider *dpp; optional_yield y; public: - RadosWriter(Aio *aio, rgw::sal::RadosStore *store, - RGWObjectCtx& obj_ctx, std::unique_ptr _head_obj, + RadosWriter(Aio *aio, RGWRados *store, + const RGWBucketInfo& bucket_info, + RGWObjectCtx& obj_ctx, const rgw_obj& _head_obj, const DoutPrefixProvider *dpp, optional_yield y) - : aio(aio), store(store), - obj_ctx(obj_ctx), head_obj(std::move(_head_obj)), dpp(dpp), y(y) + : aio(aio), store(store), bucket_info(bucket_info), + obj_ctx(obj_ctx), head_obj(_head_obj), dpp(dpp), y(y) {} - RadosWriter(RadosWriter&& r) - : aio(r.aio), store(r.store), - obj_ctx(r.obj_ctx), head_obj(std::move(r.head_obj)), dpp(r.dpp), y(r.y) - {} - ~RadosWriter(); // add alloc hint to osd @@ -113,11 +110,12 @@ class RadosWriter : public rgw::sal::DataProcessor { class ManifestObjectProcessor : public HeadObjectProcessor, public StripeGenerator { protected: - rgw::sal::RadosStore* const store; + RGWRados* const store; + RGWBucketInfo& bucket_info; rgw_placement_rule tail_placement_rule; rgw_user owner; RGWObjectCtx& obj_ctx; - std::unique_ptr head_obj; + rgw_obj head_obj; RadosWriter writer; RGWObjManifest manifest; @@ -130,16 +128,17 @@ class ManifestObjectProcessor : public HeadObjectProcessor, int next(uint64_t offset, uint64_t *stripe_size) override; public: - ManifestObjectProcessor(Aio *aio, rgw::sal::RadosStore* store, + ManifestObjectProcessor(Aio *aio, RGWRados* store, + RGWBucketInfo& bucket_info, const rgw_placement_rule *ptail_placement_rule, const rgw_user& owner, RGWObjectCtx& _obj_ctx, - std::unique_ptr _head_obj, + const rgw_obj& _head_obj, const DoutPrefixProvider* dpp, optional_yield y) : HeadObjectProcessor(0), - store(store), + store(store), bucket_info(bucket_info), owner(owner), - obj_ctx(_obj_ctx), head_obj(std::move(_head_obj)), - writer(aio, store, obj_ctx, head_obj->clone(), dpp, y), + obj_ctx(_obj_ctx), head_obj(_head_obj), + writer(aio, store, bucket_info, obj_ctx, head_obj, dpp, y), chunk(&writer, 0), stripe(&chunk, this, 0), dpp(dpp) { if (ptail_placement_rule) { tail_placement_rule = *ptail_placement_rule; @@ -169,16 +168,16 @@ class AtomicObjectProcessor : public ManifestObjectProcessor { int process_first_chunk(bufferlist&& data, rgw::sal::DataProcessor **processor) override; public: - AtomicObjectProcessor(Aio *aio, rgw::sal::RadosStore* store, + AtomicObjectProcessor(Aio *aio, RGWRados* store, + RGWBucketInfo& bucket_info, const rgw_placement_rule *ptail_placement_rule, const rgw_user& owner, - RGWObjectCtx& obj_ctx, - std::unique_ptr _head_obj, + RGWObjectCtx& obj_ctx, const rgw_obj& _head_obj, std::optional olh_epoch, const std::string& unique_tag, const DoutPrefixProvider *dpp, optional_yield y) - : ManifestObjectProcessor(aio, store, ptail_placement_rule, - owner, obj_ctx, std::move(_head_obj), dpp, y), + : ManifestObjectProcessor(aio, store, bucket_info, ptail_placement_rule, + owner, obj_ctx, _head_obj, dpp, y), olh_epoch(olh_epoch), unique_tag(unique_tag) {} @@ -201,7 +200,7 @@ class AtomicObjectProcessor : public ManifestObjectProcessor { // part's head is written with an exclusive create to detect racing uploads of // the same part/upload id, which are restarted with a random oid prefix class MultipartObjectProcessor : public ManifestObjectProcessor { - std::unique_ptr target_obj; // target multipart object + const rgw_obj target_obj; // target multipart object const std::string upload_id; const int part_num; const std::string part_num_str; @@ -213,18 +212,19 @@ class MultipartObjectProcessor : public ManifestObjectProcessor { // prepare the head stripe and manifest int prepare_head(); public: - MultipartObjectProcessor(Aio *aio, rgw::sal::RadosStore* store, + MultipartObjectProcessor(Aio *aio, RGWRados* store, + RGWBucketInfo& bucket_info, const rgw_placement_rule *ptail_placement_rule, const rgw_user& owner, RGWObjectCtx& obj_ctx, - std::unique_ptr _head_obj, + const rgw_obj& _head_obj, const std::string& upload_id, uint64_t part_num, const std::string& part_num_str, const DoutPrefixProvider *dpp, optional_yield y) - : ManifestObjectProcessor(aio, store, ptail_placement_rule, - owner, obj_ctx, std::move(_head_obj), dpp, y), - target_obj(head_obj->clone()), upload_id(upload_id), + : ManifestObjectProcessor(aio, store, bucket_info, ptail_placement_rule, + owner, obj_ctx, _head_obj, dpp, y), + target_obj(head_obj), upload_id(upload_id), part_num(part_num), part_num_str(part_num_str), - mp(head_obj->get_name(), upload_id) + mp(head_obj.key.name, upload_id) {} // prepare a multipart manifest @@ -255,15 +255,16 @@ class MultipartObjectProcessor : public ManifestObjectProcessor { int process_first_chunk(bufferlist&& data, rgw::sal::DataProcessor **processor) override; public: - AppendObjectProcessor(Aio *aio, rgw::sal::RadosStore* store, + AppendObjectProcessor(Aio *aio, RGWRados* store, + RGWBucketInfo& bucket_info, const rgw_placement_rule *ptail_placement_rule, const rgw_user& owner, RGWObjectCtx& obj_ctx, - std::unique_ptr _head_obj, + const rgw_obj& _head_obj, const std::string& unique_tag, uint64_t position, uint64_t *cur_accounted_size, const DoutPrefixProvider *dpp, optional_yield y) - : ManifestObjectProcessor(aio, store, ptail_placement_rule, - owner, obj_ctx, std::move(_head_obj), dpp, y), + : ManifestObjectProcessor(aio, store, bucket_info, ptail_placement_rule, + owner, obj_ctx, _head_obj, dpp, y), position(position), cur_size(0), cur_accounted_size(cur_accounted_size), unique_tag(unique_tag), cur_manifest(nullptr) {} diff --git a/src/rgw/driver/rados/rgw_rados.cc b/src/rgw/driver/rados/rgw_rados.cc index e7744a43ebe..00bcc0ba5b0 100644 --- a/src/rgw/driver/rados/rgw_rados.cc +++ b/src/rgw/driver/rados/rgw_rados.cc @@ -116,11 +116,11 @@ static string default_storage_extra_pool_suffix = "rgw.buckets.non-ec"; static RGWObjCategory main_category = RGWObjCategory::Main; #define RGW_USAGE_OBJ_PREFIX "usage." -rgw_raw_obj rgw_obj_select::get_raw_obj(rgw::sal::RadosStore* driver) const +rgw_raw_obj rgw_obj_select::get_raw_obj(RGWRados* store) const { if (!is_raw) { rgw_raw_obj r; - driver->get_raw_obj(placement_rule, obj, &r); + store->obj_to_raw(placement_rule, obj, &r); return r; } return raw_obj; @@ -191,7 +191,7 @@ void RGWObjectCtx::set_compressed(const rgw_obj& obj) { objs_state[obj].state.compressed = true; } -void RGWObjectCtx::set_atomic(rgw_obj& obj) { +void RGWObjectCtx::set_atomic(const rgw_obj& obj) { std::unique_lock wl{lock}; assert (!obj.empty()); objs_state[obj].state.is_atomic = true; @@ -2618,16 +2618,15 @@ int RGWRados::fix_tail_obj_locator(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, rgw_obj_key& key, bool fix, bool *need_fix, optional_yield y) { - std::unique_ptr bucket; - driver->get_bucket(nullptr, bucket_info, &bucket); - std::unique_ptr obj = bucket->get_object(key); + const rgw_bucket& bucket = bucket_info.bucket; + rgw_obj obj(bucket, key); if (need_fix) { *need_fix = false; } rgw_rados_ref ref; - int r = get_obj_head_ref(dpp, bucket_info, obj->get_obj(), &ref); + int r = get_obj_head_ref(dpp, bucket_info, obj, &ref); if (r < 0) { return r; } @@ -2635,14 +2634,14 @@ int RGWRados::fix_tail_obj_locator(const DoutPrefixProvider *dpp, RGWObjState *astate = nullptr; RGWObjManifest* manifest = nullptr; RGWObjectCtx rctx(this->driver); - r = get_obj_state(dpp, &rctx, bucket_info, obj.get(), &astate, &manifest, false, y); + r = get_obj_state(dpp, &rctx, bucket_info, obj, &astate, &manifest, false, y); if (r < 0) return r; if (manifest) { RGWObjManifest::obj_iterator miter; for (miter = manifest->obj_begin(dpp); miter != manifest->obj_end(dpp); ++miter) { - rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(driver); + rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(this); rgw_obj loc; string oid; string locator; @@ -2667,7 +2666,7 @@ int RGWRados::fix_tail_obj_locator(const DoutPrefixProvider *dpp, } string bad_loc; - prepend_bucket_marker(bucket->get_key(), loc.key.name, bad_loc); + prepend_bucket_marker(bucket, loc.key.name, bad_loc); /* create a new ioctx with the bad locator */ librados::IoCtx src_ioctx; @@ -2807,28 +2806,28 @@ int RGWRados::on_last_entry_in_listing(const DoutPrefixProvider *dpp, return 0; } -bool RGWRados::swift_versioning_enabled(rgw::sal::Bucket* bucket) const +bool RGWRados::swift_versioning_enabled(const RGWBucketInfo& bucket_info) const { - return bucket->get_info().has_swift_versioning() && - bucket->get_info().swift_ver_location.size(); + return bucket_info.has_swift_versioning() && + bucket_info.swift_ver_location.size(); } int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx, const rgw_user& user, - rgw::sal::Bucket* bucket, - rgw::sal::Object* obj, + RGWBucketInfo& bucket_info, + const rgw_obj& obj, const DoutPrefixProvider *dpp, optional_yield y) { - if (! swift_versioning_enabled(bucket)) { + if (! swift_versioning_enabled(bucket_info)) { return 0; } - obj->set_atomic(); + obj_ctx.set_atomic(obj); RGWObjState * state = nullptr; RGWObjManifest *manifest = nullptr; - int r = get_obj_state(dpp, &obj_ctx, bucket->get_info(), obj, &state, &manifest, false, y); + int r = get_obj_state(dpp, &obj_ctx, bucket_info, obj, &state, &manifest, false, y); if (r < 0) { return r; } @@ -2837,7 +2836,7 @@ int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx, return 0; } - const string& src_name = obj->get_oid(); + const string& src_name = obj.get_oid(); char buf[src_name.size() + 32]; struct timespec ts = ceph::real_clock::to_timespec(state->mtime); snprintf(buf, sizeof(buf), "%03x%s/%lld.%06ld", (int)src_name.size(), @@ -2845,7 +2844,7 @@ int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx, RGWBucketInfo dest_bucket_info; - r = get_bucket_info(&svc, bucket->get_tenant(), bucket->get_info().swift_ver_location, dest_bucket_info, NULL, null_yield, NULL); + r = get_bucket_info(&svc, bucket_info.bucket.tenant, bucket_info.swift_ver_location, dest_bucket_info, NULL, null_yield, NULL); if (r < 0) { ldpp_dout(dpp, 10) << "failed to read dest bucket info: r=" << r << dendl; if (r == -ENOENT) { @@ -2854,18 +2853,17 @@ int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx, return r; } - if (dest_bucket_info.owner != bucket->get_info().owner) { + if (dest_bucket_info.owner != bucket_info.owner) { return -ERR_PRECONDITION_FAILED; } - rgw::sal::RadosBucket dest_bucket(driver, dest_bucket_info); - rgw::sal::RadosObject dest_obj(driver, rgw_obj_key(buf), &dest_bucket); + rgw_obj dest_obj(dest_bucket_info.bucket, buf); if (dest_bucket_info.versioning_enabled()){ - dest_obj.gen_rand_obj_instance_name(); + gen_rand_obj_instance_name(&dest_obj); } - dest_obj.set_atomic(); + obj_ctx.set_atomic(dest_obj); rgw_zone_id no_zone; @@ -2873,11 +2871,11 @@ int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx, user, NULL, /* req_info *info */ no_zone, - &dest_obj, + dest_obj, obj, - &dest_bucket, - bucket, - bucket->get_placement_rule(), + dest_bucket_info, + bucket_info, + bucket_info.placement_rule, NULL, /* time_t *src_mtime */ NULL, /* time_t *mtime */ NULL, /* const time_t *mod_ptr */ @@ -2909,20 +2907,20 @@ int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx, int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx, const rgw_user& user, - rgw::sal::Bucket* bucket, - rgw::sal::Object* obj, - bool& restored, /* out */ + RGWBucketInfo& bucket_info, + rgw_obj& obj, + bool& restored, const DoutPrefixProvider *dpp) { - if (! swift_versioning_enabled(bucket)) { + if (! swift_versioning_enabled(bucket_info)) { return 0; } /* Bucket info of the bucket that stores previous versions of our object. */ RGWBucketInfo archive_binfo; - int ret = get_bucket_info(&svc, bucket->get_tenant(), - bucket->get_info().swift_ver_location, + int ret = get_bucket_info(&svc, bucket_info.bucket.tenant, + bucket_info.swift_ver_location, archive_binfo, nullptr, null_yield, nullptr); if (ret < 0) { return ret; @@ -2933,7 +2931,7 @@ int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx, * into consideration. For we can live with that. * * TODO: delegate this check to un upper layer and compare with ACLs. */ - if (bucket->get_info().owner != archive_binfo.owner) { + if (bucket_info.owner != archive_binfo.owner) { return -EPERM; } @@ -2954,25 +2952,24 @@ int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx, * irrelevant and may be safely skipped. */ std::map no_attrs; - rgw::sal::RadosBucket archive_bucket(driver, archive_binfo); - rgw::sal::RadosObject archive_obj(driver, entry.key, &archive_bucket); + rgw_obj archive_obj(archive_binfo.bucket, entry.key); - if (bucket->versioning_enabled()){ - obj->gen_rand_obj_instance_name(); + if (bucket_info.versioning_enabled()){ + gen_rand_obj_instance_name(&obj); } - archive_obj.set_atomic(); - obj->set_atomic(); + obj_ctx.set_atomic(archive_obj); + obj_ctx.set_atomic(obj); int ret = copy_obj(obj_ctx, user, nullptr, /* req_info *info */ no_zone, obj, /* dest obj */ - &archive_obj, /* src obj */ - bucket, /* dest bucket info */ - &archive_bucket, /* src bucket info */ - bucket->get_placement_rule(), /* placement_rule */ + archive_obj, /* src obj */ + bucket_info, /* dest bucket info */ + archive_binfo, /* src bucket info */ + bucket_info.placement_rule, /* placement_rule */ nullptr, /* time_t *src_mtime */ nullptr, /* time_t *mtime */ nullptr, /* const time_t *mod_ptr */ @@ -3004,13 +3001,13 @@ int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx, } /* Need to remove the archived copy. */ - ret = delete_obj(dpp, archive_binfo, &archive_obj, + ret = delete_obj(dpp, obj_ctx, archive_binfo, archive_obj, archive_binfo.versioning_status()); return ret; }; - const std::string& obj_name = obj->get_oid(); + const std::string& obj_name = obj.get_oid(); const auto prefix = boost::str(boost::format("%03x%s") % obj_name.size() % obj_name); @@ -3045,7 +3042,7 @@ int RGWRados::Object::Write::_do_write_meta(const DoutPrefixProvider *dpp, if (r < 0) return r; - rgw_obj obj = target->get_obj(); + rgw_obj& obj = target->get_obj(); if (obj.get_oid().empty()) { ldpp_dout(dpp, 0) << "ERROR: " << __func__ << "(): cannot write object with empty name" << dendl; @@ -3236,7 +3233,7 @@ int RGWRados::Object::Write::_do_write_meta(const DoutPrefixProvider *dpp, state = NULL; if (versioned_op && meta.olh_epoch) { - r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), target->get_target(), false, NULL, *meta.olh_epoch, real_time(), false, y, meta.zones_trace); + r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), obj, false, NULL, *meta.olh_epoch, real_time(), false, y, meta.zones_trace); if (r < 0) { return r; } @@ -3568,13 +3565,13 @@ static void set_copy_attrs(map& src_attrs, } } -int RGWRados::rewrite_obj(rgw::sal::Object* obj, const DoutPrefixProvider *dpp, optional_yield y) +int RGWRados::rewrite_obj(RGWBucketInfo& dest_bucket_info, const rgw_obj& obj, const DoutPrefixProvider *dpp, optional_yield y) { RGWObjectCtx rctx(this->driver); rgw::sal::Attrs attrset; uint64_t obj_size; ceph::real_time mtime; - RGWRados::Object op_target(this, obj->get_bucket(), rctx, obj); + RGWRados::Object op_target(this, dest_bucket_info, rctx, obj); RGWRados::Object::Read read_op(&op_target); read_op.params.attrs = &attrset; @@ -3589,10 +3586,9 @@ int RGWRados::rewrite_obj(rgw::sal::Object* obj, const DoutPrefixProvider *dpp, attrset.erase(RGW_ATTR_TAIL_TAG); attrset.erase(RGW_ATTR_STORAGE_CLASS); - return this->copy_obj_data(rctx, obj->get_bucket(), - obj->get_bucket()->get_info().placement_rule, - read_op, obj_size - 1, obj, NULL, mtime, - attrset, 0, real_time(), NULL, dpp, y); + return copy_obj_data(rctx, dest_bucket_info, dest_bucket_info.placement_rule, + read_op, obj_size - 1, obj, NULL, mtime, + attrset, 0, real_time(), NULL, dpp, y); } int RGWRados::reindex_obj(const RGWBucketInfo& bucket_info, @@ -3722,7 +3718,7 @@ int RGWRados::stat_remote_obj(const DoutPrefixProvider *dpp, const rgw_user& user_id, req_info *info, const rgw_zone_id& source_zone, - rgw::sal::Object* src_obj, + const rgw_obj& src_obj, const RGWBucketInfo *src_bucket_info, real_time *src_mtime, uint64_t *psize, @@ -3861,10 +3857,10 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx, const rgw_user& user_id, req_info *info, const rgw_zone_id& source_zone, - rgw::sal::Object* dest_obj, - rgw::sal::Object* src_obj, - rgw::sal::Bucket* dest_bucket, - rgw::sal::Bucket* src_bucket, + const rgw_obj& dest_obj, + const rgw_obj& src_obj, + RGWBucketInfo& dest_bucket_info, + RGWBucketInfo *src_bucket_info, std::optional dest_placement_rule, real_time *src_mtime, real_time *mtime, @@ -3900,18 +3896,18 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx, rgw::BlockingAioThrottle aio(cct->_conf->rgw_put_obj_min_window_size); using namespace rgw::putobj; - AtomicObjectProcessor processor(&aio, this->driver, nullptr, user_id, - obj_ctx, dest_obj->clone(), olh_epoch, + AtomicObjectProcessor processor(&aio, this, dest_bucket_info, nullptr, + user_id, obj_ctx, dest_obj, olh_epoch, tag, dpp, null_yield); RGWRESTConn *conn; auto& zone_conn_map = svc.zone->get_zone_conn_map(); auto& zonegroup_conn_map = svc.zone->get_zonegroup_conn_map(); if (source_zone.empty()) { - if (!src_bucket || src_bucket->get_info().zonegroup.empty()) { + if (!src_bucket_info || src_bucket_info->zonegroup.empty()) { /* source is in the master zonegroup */ conn = svc.zone->get_master_conn(); } else { - map::iterator iter = zonegroup_conn_map.find(src_bucket->get_info().zonegroup); + map::iterator iter = zonegroup_conn_map.find(src_bucket_info->zonegroup); if (iter == zonegroup_conn_map.end()) { ldpp_dout(dpp, 0) << "could not find zonegroup connection to zonegroup: " << source_zone << dendl; return -ENOENT; @@ -3942,8 +3938,8 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx, const rgw_placement_rule *ptail_rule; int ret = filter->filter(cct, - src_obj->get_key(), - dest_bucket->get_info(), + src_obj.key, + dest_bucket_info, dest_placement_rule, obj_attrs, &override_owner, @@ -3984,7 +3980,7 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx, if (copy_if_newer) { /* need to get mtime for destination */ - ret = get_obj_state(dpp, &obj_ctx, dest_bucket->get_info(), dest_obj, &dest_state, &manifest, false, null_yield); + ret = get_obj_state(dpp, &obj_ctx, dest_bucket_info, dest_obj, &dest_state, &manifest, false, null_yield); if (ret < 0) goto set_err_state; @@ -4157,8 +4153,8 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx, if (copy_if_newer && canceled) { ldpp_dout(dpp, 20) << "raced with another write of obj: " << dest_obj << dendl; - obj_ctx.invalidate(dest_obj->get_obj()); /* object was overwritten */ - ret = get_obj_state(dpp, &obj_ctx, dest_bucket->get_info(), dest_obj, &dest_state, &manifest, false, null_yield); + obj_ctx.invalidate(dest_obj); /* object was overwritten */ + ret = get_obj_state(dpp, &obj_ctx, dest_bucket_info, dest_obj, &dest_state, &manifest, false, null_yield); if (ret < 0) { ldpp_dout(dpp, 0) << "ERROR: " << __func__ << ": get_err_state() returned ret=" << ret << dendl; goto set_err_state; @@ -4192,7 +4188,7 @@ set_err_state: // for OP_LINK_OLH to call set_olh() with a real olh_epoch if (olh_epoch && *olh_epoch > 0) { constexpr bool log_data_change = true; - ret = set_olh(dpp, obj_ctx, dest_bucket->get_info(), dest_obj, false, nullptr, + ret = set_olh(dpp, obj_ctx, dest_bucket_info, dest_obj, false, nullptr, *olh_epoch, real_time(), false, null_yield, zones_trace, log_data_change); } else { // we already have the latest copy @@ -4208,7 +4204,7 @@ int RGWRados::copy_obj_to_remote_dest(const DoutPrefixProvider *dpp, map& src_attrs, RGWRados::Object::Read& read_op, const rgw_user& user_id, - rgw::sal::Object* dest_obj, + const rgw_obj& dest_obj, real_time *mtime) { string etag; @@ -4262,10 +4258,10 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, const rgw_user& user_id, req_info *info, const rgw_zone_id& source_zone, - rgw::sal::Object* dest_obj, - rgw::sal::Object* src_obj, - rgw::sal::Bucket* dest_bucket, - rgw::sal::Bucket* src_bucket, + const rgw_obj& dest_obj, + const rgw_obj& src_obj, + RGWBucketInfo& dest_bucket_info, + RGWBucketInfo& src_bucket_info, const rgw_placement_rule& dest_placement, real_time *src_mtime, real_time *mtime, @@ -4290,30 +4286,30 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, { int ret; uint64_t obj_size; - rgw_obj shadow_obj = dest_obj->get_obj(); + rgw_obj shadow_obj = dest_obj; string shadow_oid; bool remote_src; bool remote_dest; - append_rand_alpha(cct, dest_obj->get_oid(), shadow_oid, 32); - shadow_obj.init_ns(dest_obj->get_bucket()->get_key(), shadow_oid, shadow_ns); + append_rand_alpha(cct, dest_obj.get_oid(), shadow_oid, 32); + shadow_obj.init_ns(dest_obj.bucket, shadow_oid, shadow_ns); auto& zonegroup = svc.zone->get_zonegroup(); - remote_dest = !zonegroup.equals(dest_bucket->get_info().zonegroup); - remote_src = !zonegroup.equals(src_bucket->get_info().zonegroup); + remote_dest = !zonegroup.equals(dest_bucket_info.zonegroup); + remote_src = !zonegroup.equals(src_bucket_info.zonegroup); if (remote_src && remote_dest) { ldpp_dout(dpp, 0) << "ERROR: can't copy object when both src and dest buckets are remote" << dendl; return -EINVAL; } - ldpp_dout(dpp, 5) << "Copy object " << src_obj->get_bucket() << ":" << src_obj->get_oid() << " => " << dest_obj->get_bucket() << ":" << dest_obj->get_oid() << dendl; + ldpp_dout(dpp, 5) << "Copy object " << src_obj.bucket << ":" << src_obj.get_oid() << " => " << dest_obj.bucket << ":" << dest_obj.get_oid() << dendl; if (remote_src || !source_zone.empty()) { return fetch_remote_obj(obj_ctx, user_id, info, source_zone, - dest_obj, src_obj, dest_bucket, src_bucket, + dest_obj, src_obj, dest_bucket_info, &src_bucket_info, dest_placement, src_mtime, mtime, mod_ptr, unmod_ptr, high_precision_time, if_match, if_nomatch, attrs_mod, copy_if_newer, attrs, category, @@ -4322,7 +4318,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, } map src_attrs; - RGWRados::Object src_op_target(this, src_bucket, obj_ctx, src_obj); + RGWRados::Object src_op_target(this, src_bucket_info, obj_ctx, src_obj); RGWRados::Object::Read read_op(&src_op_target); read_op.conds.mod_ptr = mod_ptr; @@ -4372,7 +4368,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, RGWObjState *astate = NULL; RGWObjManifest *amanifest = nullptr; - ret = get_obj_state(dpp, &obj_ctx, src_bucket->get_info(), src_obj, &astate, &amanifest, y); + ret = get_obj_state(dpp, &obj_ctx, src_bucket_info, src_obj, &astate, &amanifest, y); if (ret < 0) { return ret; } @@ -4385,9 +4381,9 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, } uint64_t max_chunk_size; - ret = get_max_chunk_size(dest_bucket->get_placement_rule(), dest_obj->get_obj(), &max_chunk_size, dpp); + ret = get_max_chunk_size(dest_bucket_info.placement_rule, dest_obj, &max_chunk_size, dpp); if (ret < 0) { - ldpp_dout(dpp, 0) << "ERROR: failed to get max_chunk_size() for bucket " << dest_obj->get_bucket() << dendl; + ldpp_dout(dpp, 0) << "ERROR: failed to get max_chunk_size() for bucket " << dest_obj.bucket << dendl; return ret; } @@ -4402,15 +4398,15 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, } if (!src_rule || src_rule->empty()) { - src_rule = &src_bucket->get_placement_rule(); + src_rule = &src_bucket_info.placement_rule; } - if (!get_obj_data_pool(*src_rule, src_obj->get_obj(), &src_pool)) { + if (!get_obj_data_pool(*src_rule, src_obj, &src_pool)) { ldpp_dout(dpp, 0) << "ERROR: failed to locate data pool for " << src_obj << dendl; return -EIO; } - if (!get_obj_data_pool(dest_placement, dest_obj->get_obj(), &dest_pool)) { + if (!get_obj_data_pool(dest_placement, dest_obj, &dest_pool)) { ldpp_dout(dpp, 0) << "ERROR: failed to locate data pool for " << dest_obj << dendl; return -EIO; } @@ -4448,7 +4444,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, if (copy_data) { /* refcounting tail wouldn't work here, just copy the data */ attrs.erase(RGW_ATTR_TAIL_TAG); - return copy_obj_data(obj_ctx, dest_bucket, dest_placement, read_op, obj_size - 1, dest_obj, + return copy_obj_data(obj_ctx, dest_bucket_info, dest_placement, read_op, obj_size - 1, dest_obj, mtime, real_time(), attrs, olh_epoch, delete_at, petag, dpp, y); } @@ -4461,11 +4457,11 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, bufferlist first_chunk; - const bool copy_itself = (dest_obj->get_obj() == src_obj->get_obj()); + const bool copy_itself = (dest_obj == src_obj); RGWObjManifest *pmanifest; ldpp_dout(dpp, 20) << "dest_obj=" << dest_obj << " src_obj=" << src_obj << " copy_itself=" << (int)copy_itself << dendl; - RGWRados::Object dest_op_target(this, dest_bucket, obj_ctx, dest_obj); + RGWRados::Object dest_op_target(this, dest_bucket_info, obj_ctx, dest_obj); RGWRados::Object::Write write_op(&dest_op_target); string tag; @@ -4486,7 +4482,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, manifest = *amanifest; const rgw_bucket_placement& tail_placement = manifest.get_tail_placement(); if (tail_placement.bucket.name.empty()) { - manifest.set_tail_placement(tail_placement.placement_rule, src_obj->get_bucket()->get_key()); + manifest.set_tail_placement(tail_placement.placement_rule, src_obj.bucket); } string ref_tag; for (; miter != amanifest->obj_end(dpp); ++miter) { @@ -4494,7 +4490,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, ref_tag = tag + '\0'; cls_refcount_get(op, ref_tag, true); - auto obj = svc.rados->obj(miter.get_location().get_raw_obj(driver)); + auto obj = svc.rados->obj(miter.get_location().get_raw_obj(this)); ret = obj.open(dpp); if (ret < 0) { ldpp_dout(dpp, 0) << "failed to open rados context for " << obj << dendl; @@ -4533,15 +4529,15 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx, goto done_ret; } - pmanifest->set_head(dest_bucket->get_placement_rule(), dest_obj->get_obj(), first_chunk.length()); + pmanifest->set_head(dest_bucket_info.placement_rule, dest_obj, first_chunk.length()); } else { - pmanifest->set_head(dest_bucket->get_placement_rule(), dest_obj->get_obj(), 0); + pmanifest->set_head(dest_bucket_info.placement_rule, dest_obj, 0); } write_op.meta.data = &first_chunk; write_op.meta.manifest = pmanifest; write_op.meta.ptag = &tag; - write_op.meta.owner = dest_bucket->get_info().owner; + write_op.meta.owner = dest_bucket_info.owner; write_op.meta.mtime = mtime; write_op.meta.flags = PUT_OBJ_CREATE; write_op.meta.category = category; @@ -4592,10 +4588,10 @@ done_ret: int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx, - rgw::sal::Bucket* bucket, + RGWBucketInfo& dest_bucket_info, const rgw_placement_rule& dest_placement, RGWRados::Object::Read& read_op, off_t end, - rgw::sal::Object* dest_obj, + const rgw_obj& dest_obj, real_time *mtime, real_time set_mtime, rgw::sal::Attrs& attrs, @@ -4612,9 +4608,9 @@ int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx, using namespace rgw::putobj; // do not change the null_yield in the initialization of this AtomicObjectProcessor // it causes crashes in the ragweed tests - AtomicObjectProcessor processor(&aio, this->driver, &dest_placement, - bucket->get_info().owner, obj_ctx, - dest_obj->clone(), olh_epoch, tag, + AtomicObjectProcessor processor(&aio, this, dest_bucket_info, &dest_placement, + dest_bucket_info.owner, obj_ctx, + dest_obj, olh_epoch, tag, dpp, null_yield); int ret = processor.prepare(y); if (ret < 0) @@ -4673,8 +4669,8 @@ int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx, } int RGWRados::transition_obj(RGWObjectCtx& obj_ctx, - rgw::sal::Bucket* bucket, - rgw::sal::Object& obj, + RGWBucketInfo& bucket_info, + const rgw_obj& obj, const rgw_placement_rule& placement_rule, const real_time& mtime, uint64_t olh_epoch, @@ -4685,8 +4681,8 @@ int RGWRados::transition_obj(RGWObjectCtx& obj_ctx, real_time read_mtime; uint64_t obj_size; - obj.set_atomic(); - RGWRados::Object op_target(this, bucket, obj_ctx, &obj); + obj_ctx.set_atomic(obj); + RGWRados::Object op_target(this, bucket_info, obj_ctx, obj); RGWRados::Object::Read read_op(&op_target); read_op.params.attrs = &attrs; @@ -4707,11 +4703,11 @@ int RGWRados::transition_obj(RGWObjectCtx& obj_ctx, attrs.erase(RGW_ATTR_TAIL_TAG); ret = copy_obj_data(obj_ctx, - bucket, + bucket_info, placement_rule, read_op, obj_size - 1, - &obj, + obj, nullptr /* pmtime */, mtime, attrs, @@ -4923,7 +4919,7 @@ int RGWRados::Object::complete_atomic_modification(const DoutPrefixProvider *dpp return 0; cls_rgw_obj_chain chain; - store->update_gc_chain(dpp, obj->get_obj(), *manifest, &chain); + store->update_gc_chain(dpp, obj, *manifest, &chain); if (chain.empty()) { return 0; @@ -4950,7 +4946,7 @@ void RGWRados::update_gc_chain(const DoutPrefixProvider *dpp, rgw_obj head_obj, rgw_raw_obj raw_head; obj_to_raw(manifest.get_head_placement_rule(), head_obj, &raw_head); for (iter = manifest.obj_begin(dpp); iter != manifest.obj_end(dpp); ++iter) { - const rgw_raw_obj& mobj = iter.get_location().get_raw_obj(driver); + const rgw_raw_obj& mobj = iter.get_location().get_raw_obj(this); if (mobj == raw_head) continue; cls_rgw_obj_key key(mobj.oid); @@ -5085,10 +5081,10 @@ int RGWRados::bucket_set_reshard(const DoutPrefixProvider *dpp, const RGWBucketI return r; } -int RGWRados::defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, optional_yield y) +int RGWRados::defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y) { std::string oid, key; - get_obj_bucket_and_oid_loc(obj->get_obj(), oid, key); + get_obj_bucket_and_oid_loc(obj, oid, key); if (!rctx) return 0; @@ -5159,7 +5155,8 @@ struct tombstone_entry { int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvider *dpp) { RGWRados *store = target->get_store(); - const string& instance = target->get_instance(); + const rgw_obj& src_obj = target->get_obj(); + const string& instance = src_obj.key.instance; rgw_obj obj = target->get_obj(); if (instance == "null") { @@ -5170,18 +5167,18 @@ int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvi if (params.versioning_status & BUCKET_VERSIONED || explicit_marker_version) { if (instance.empty() || explicit_marker_version) { - std::unique_ptr marker = target->get_target()->clone(); - marker->clear_instance(); + rgw_obj marker = obj; + marker.key.instance.clear(); if (!params.marker_version_id.empty()) { if (params.marker_version_id != "null") { - marker->set_instance(params.marker_version_id); + marker.key.set_instance(params.marker_version_id); } } else if ((params.versioning_status & BUCKET_VERSIONS_SUSPENDED) == 0) { - marker->gen_rand_obj_instance_name(); + store->gen_rand_obj_instance_name(&marker); } - result.version_id = marker->get_instance(); + result.version_id = marker.key.instance; if (result.version_id.empty()) result.version_id = "null"; result.delete_marker = true; @@ -5197,7 +5194,7 @@ int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvi meta.mtime = params.mtime; } - int r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), marker.get(), true, &meta, params.olh_epoch, params.unmod_since, params.high_precision_time, y, params.zones_trace); + int r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), marker, true, &meta, params.olh_epoch, params.unmod_since, params.high_precision_time, y, params.zones_trace); if (r < 0) { return r; } @@ -5209,7 +5206,7 @@ int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvi return r; } result.delete_marker = dirent.is_delete_marker(); - r = store->unlink_obj_instance(dpp, target->get_bucket_info(), target->get_target(), params.olh_epoch, y, params.zones_trace); + r = store->unlink_obj_instance(dpp, target->get_ctx(), target->get_bucket_info(), obj, params.olh_epoch, y, params.zones_trace); if (r < 0) { return r; } @@ -5349,40 +5346,25 @@ int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvi return 0; } -int RGWRados::delete_obj(rgw::sal::Driver* store, - const DoutPrefixProvider *dpp, - const RGWBucketInfo& bucket_info, - const rgw_obj& obj, - int versioning_status, // versioning flags defined in enum RGWBucketFlags - uint16_t bilog_flags, - const real_time& expiration_time, - rgw_zone_set *zones_trace) -{ - std::unique_ptr bucket; - store->get_bucket(nullptr, bucket_info, &bucket); - std::unique_ptr object = bucket->get_object(obj.key); - - return delete_obj(dpp, bucket_info, object.get(), versioning_status, - bilog_flags, expiration_time, zones_trace); -} - int RGWRados::delete_obj(const DoutPrefixProvider *dpp, + RGWObjectCtx& obj_ctx, const RGWBucketInfo& bucket_info, - rgw::sal::Object* obj, + const rgw_obj& obj, int versioning_status, // versioning flags defined in enum RGWBucketFlags uint16_t bilog_flags, const real_time& expiration_time, rgw_zone_set *zones_trace) { - std::unique_ptr del_op = obj->get_delete_op(); + RGWRados::Object del_target(this, bucket_info, obj_ctx, obj); + RGWRados::Object::Delete del_op(&del_target); - del_op->params.bucket_owner = bucket_info.owner; - del_op->params.versioning_status = versioning_status; - del_op->params.bilog_flags = bilog_flags; - del_op->params.expiration_time = expiration_time; - del_op->params.zones_trace = zones_trace; + del_op.params.bucket_owner = bucket_info.owner; + del_op.params.versioning_status = versioning_status; + del_op.params.bilog_flags = bilog_flags; + del_op.params.expiration_time = expiration_time; + del_op.params.zones_trace = zones_trace; - return del_op->delete_obj(dpp, null_yield); + return del_op.delete_obj(null_yield, dpp); } int RGWRados::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj) @@ -5422,7 +5404,7 @@ int RGWRados::delete_obj_index(const rgw_obj& obj, ceph::real_time mtime, return index_op.complete_del(dpp, -1 /* pool */, 0, mtime, nullptr, y); } -static void generate_fake_tag(const DoutPrefixProvider *dpp, rgw::sal::Driver* store, map& attrset, RGWObjManifest& manifest, bufferlist& manifest_bl, bufferlist& tag_bl) +static void generate_fake_tag(const DoutPrefixProvider *dpp, RGWRados* store, map& attrset, RGWObjManifest& manifest, bufferlist& manifest_bl, bufferlist& tag_bl) { string tag; @@ -5430,8 +5412,7 @@ static void generate_fake_tag(const DoutPrefixProvider *dpp, rgw::sal::Driver* s if (mi != manifest.obj_end(dpp)) { if (manifest.has_tail()) // first object usually points at the head, let's skip to a more unique part ++mi; - rgw::sal::RadosStore* rstore = dynamic_cast(store); - tag = mi.get_location().get_raw_obj(rstore).oid; + tag = mi.get_location().get_raw_obj(store).oid; tag.append("_"); } @@ -5471,7 +5452,7 @@ static bool has_olh_tag(map& attrs) int RGWRados::get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, - rgw::sal::Object* obj, RGWObjState *olh_state, + const rgw_obj& obj, RGWObjState *olh_state, RGWObjState **target_state, RGWObjManifest **target_manifest, optional_yield y) { @@ -5483,11 +5464,7 @@ int RGWRados::get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& return r; } - std::unique_ptr bucket; - driver->get_bucket(nullptr, bucket_info, &bucket); - std::unique_ptr target_obj = bucket->get_object(target.key); - - r = get_obj_state(dpp, &obj_ctx, bucket_info, target_obj.get(), target_state, + r = get_obj_state(dpp, &obj_ctx, bucket_info, target, target_state, target_manifest, false, y); if (r < 0) { return r; @@ -5497,18 +5474,18 @@ int RGWRados::get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& } int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, - RGWBucketInfo& bucket_info, rgw::sal::Object* obj, + RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state, RGWObjManifest** manifest, bool follow_olh, optional_yield y, bool assume_noent) { - if (obj->empty()) { + if (obj.empty()) { return -EINVAL; } - bool need_follow_olh = follow_olh && obj->get_obj().key.instance.empty(); + bool need_follow_olh = follow_olh && obj.key.instance.empty(); *manifest = nullptr; - RGWObjStateManifest *sm = rctx->get_state(obj->get_obj()); + RGWObjStateManifest *sm = rctx->get_state(obj); RGWObjState *s = &(sm->state); ldpp_dout(dpp, 20) << "get_obj_state: rctx=" << (void *)rctx << " obj=" << obj << " state=" << (void *)s << " s->prefetch_data=" << s->prefetch_data << dendl; *state = s; @@ -5522,10 +5499,10 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc return 0; } - s->obj = obj->get_obj(); + s->obj = obj; rgw_raw_obj raw_obj; - obj_to_raw(bucket_info.placement_rule, obj->get_obj(), &raw_obj); + obj_to_raw(bucket_info.placement_rule, obj, &raw_obj); int r = -ENOENT; @@ -5537,7 +5514,7 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc s->exists = false; s->has_attrs = true; tombstone_entry entry; - if (obj_tombstone_cache && obj_tombstone_cache->find(obj->get_obj(), entry)) { + if (obj_tombstone_cache && obj_tombstone_cache->find(obj, entry)) { s->mtime = entry.mtime; s->zone_short_id = entry.zone_short_id; s->pg_ver = entry.pg_ver; @@ -5600,7 +5577,7 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc try { sm->manifest.emplace(); decode(*sm->manifest, miter); - sm->manifest->set_head(bucket_info.placement_rule, obj->get_obj(), s->size); /* patch manifest to reflect the head we just read, some manifests might be + sm->manifest->set_head(bucket_info.placement_rule, obj, s->size); /* patch manifest to reflect the head we just read, some manifests might be broken due to old bugs */ s->size = sm->manifest->get_obj_size(); if (!compressed) @@ -5615,7 +5592,7 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc sm->manifest->has_explicit_objs()) { RGWObjManifest::obj_iterator mi; for (mi = sm->manifest->obj_begin(dpp); mi != sm->manifest->obj_end(dpp); ++mi) { - ldpp_dout(dpp, 20) << "manifest: ofs=" << mi.get_ofs() << " loc=" << mi.get_location().get_raw_obj(driver) << dendl; + ldpp_dout(dpp, 20) << "manifest: ofs=" << mi.get_ofs() << " loc=" << mi.get_location().get_raw_obj(this) << dendl; } } @@ -5624,7 +5601,7 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc * Uh oh, something's wrong, object with manifest should have tag. Let's * create one out of the manifest, would be unique */ - generate_fake_tag(dpp, driver, s->attrset, *sm->manifest, manifest_bl, s->obj_tag); + generate_fake_tag(dpp, this, s->attrset, *sm->manifest, manifest_bl, s->obj_tag); s->fake_tag = true; } } @@ -5670,7 +5647,7 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc if (need_follow_olh) { return get_olh_target_state(dpp, *rctx, bucket_info, obj, s, state, manifest, y); - } else if (obj->get_obj().key.have_null_instance() && !sm->manifest) { + } else if (obj.key.have_null_instance() && !sm->manifest) { // read null version, and the head object only have olh info s->exists = false; return -ENOENT; @@ -5680,7 +5657,7 @@ int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rc return 0; } -int RGWRados::get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest, +int RGWRados::get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state, RGWObjManifest** manifest, bool follow_olh, optional_yield y, bool assume_noent) { int ret; @@ -5720,17 +5697,18 @@ int RGWRados::Object::Read::get_attr(const DoutPrefixProvider *dpp, const char * int RGWRados::Object::Stat::stat_async(const DoutPrefixProvider *dpp) { - rgw::sal::Object* target = source->get_target(); - rgw_obj obj = target->get_obj(); + RGWObjectCtx& ctx = source->get_ctx(); + rgw_obj& obj = source->get_obj(); RGWRados *store = source->get_store(); + RGWObjStateManifest *sm = ctx.get_state(obj); result.obj = obj; - if (target->has_attrs()) { + if (sm->state.has_attrs) { state.ret = 0; - result.size = target->get_obj_size(); - result.mtime = ceph::real_clock::to_timespec(target->get_mtime()); - result.attrs = target->get_attrs(); - //result.manifest = sm->manifest; + result.size = sm->state.size; + result.mtime = ceph::real_clock::to_timespec(sm->state.mtime); + result.attrs = sm->state.attrset; + result.manifest = sm->manifest; return 0; } @@ -5795,12 +5773,15 @@ int RGWRados::Object::Stat::finish(const DoutPrefixProvider *dpp) return 0; } -int RGWRados::append_atomic_test(const DoutPrefixProvider *dpp, - RGWBucketInfo& bucket_info, rgw::sal::Object* obj, +int RGWRados::append_atomic_test(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, + RGWBucketInfo& bucket_info, const rgw_obj& obj, ObjectOperation& op, RGWObjState **pstate, RGWObjManifest** pmanifest, optional_yield y) { - int r = obj->get_obj_state(dpp, pstate, y, false); + if (!rctx) + return 0; + + int r = get_obj_state(dpp, rctx, bucket_info, obj, pstate, pmanifest, false, y); if (r < 0) return r; @@ -5826,18 +5807,12 @@ int RGWRados::append_atomic_test(const DoutPrefixProvider *dpp, int RGWRados::Object::get_state(const DoutPrefixProvider *dpp, RGWObjState **pstate, RGWObjManifest **pmanifest, bool follow_olh, optional_yield y, bool assume_noent) { - int r = obj->get_obj_state(dpp, pstate, y, follow_olh); - if (r < 0) { - return r; - } - *pmanifest = static_cast(obj)->get_manifest(); - - return r; + return store->get_obj_state(dpp, &ctx, bucket_info, obj, pstate, pmanifest, follow_olh, y, assume_noent); } void RGWRados::Object::invalidate_state() { - obj->invalidate(); + ctx.invalidate(obj); } int RGWRados::Object::prepare_atomic_modification(const DoutPrefixProvider *dpp, @@ -5942,25 +5917,25 @@ int RGWRados::Object::prepare_atomic_modification(const DoutPrefixProvider *dpp, * bl: the contents of the attr * Returns: 0 on success, -ERR# otherwise. */ -int RGWRados::set_attr(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, const char *name, bufferlist& bl) +int RGWRados::set_attr(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, const char *name, bufferlist& bl) { map attrs; attrs[name] = bl; return set_attrs(dpp, rctx, bucket_info, obj, attrs, NULL, null_yield); } -int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, RGWBucketInfo& bucket_info, rgw::sal::Object* src_obj, +int RGWRados::set_attrs(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, RGWBucketInfo& bucket_info, const rgw_obj& src_obj, map& attrs, map* rmattrs, optional_yield y) { - std::unique_ptr obj = src_obj->clone(); - if (obj->get_instance() == "null") { - obj->clear_instance(); + rgw_obj obj = src_obj; + if (obj.key.instance == "null") { + obj.key.instance.clear(); } rgw_rados_ref ref; - int r = get_obj_head_ref(dpp, bucket_info, obj->get_obj(), &ref); + int r = get_obj_head_ref(dpp, bucket_info, obj, &ref); if (r < 0) { return r; } @@ -5969,12 +5944,12 @@ int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, RGWBucketInfo& RGWObjState *state = NULL; RGWObjManifest *manifest = nullptr; - r = append_atomic_test(dpp, bucket_info, obj.get(), op, &state, &manifest, y); + r = append_atomic_test(dpp, rctx, bucket_info, obj, op, &state, &manifest, y); if (r < 0) return r; // ensure null version object exist - if (src_obj->get_instance() == "null" && !manifest) { + if (src_obj.key.instance == "null" && !manifest) { return -ENOENT; } @@ -5986,7 +5961,7 @@ int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, RGWBucketInfo& } } - const rgw_bucket& bucket = obj->get_bucket()->get_key(); + const rgw_bucket& bucket = obj.bucket; for (iter = attrs.begin(); iter != attrs.end(); ++iter) { const string& name = iter->first; @@ -6003,7 +5978,7 @@ int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, RGWBucketInfo& decode(ts, bl); rgw_obj_index_key obj_key; - obj->get_key().get_index_key(&obj_key); + obj.key.get_index_key(&obj_key); obj_expirer->hint_add(dpp, ts, bucket.tenant, bucket.name, bucket.bucket_id, obj_key); } catch (buffer::error& err) { @@ -6017,7 +5992,7 @@ int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, RGWBucketInfo& bufferlist bl; RGWRados::Bucket bop(this, bucket_info); - RGWRados::Bucket::UpdateIndex index_op(&bop, obj->get_obj()); + RGWRados::Bucket::UpdateIndex index_op(&bop, obj); if (state) { string tag; @@ -6442,7 +6417,7 @@ int RGWRados::Object::Read::read(int64_t ofs, int64_t end, RGWObjManifest::obj_iterator iter = manifest->obj_find(dpp, ofs); uint64_t stripe_ofs = iter.get_stripe_ofs(); - read_obj = iter.get_location().get_raw_obj(store->driver); + read_obj = iter.get_location().get_raw_obj(store); len = std::min(len, iter.get_stripe_size() - (ofs - stripe_ofs)); read_ofs = iter.location_ofs() + (ofs - stripe_ofs); reading_from_head = (read_obj == state.head_obj); @@ -6464,8 +6439,7 @@ int RGWRados::Object::Read::read(int64_t ofs, int64_t end, if (reading_from_head) { /* only when reading from the head object do we need to do the atomic test */ - std::unique_ptr obj = source->bucket->get_object(state.obj.key); - r = store->append_atomic_test(dpp, source->get_bucket_info(), obj.get(), op, &astate, &manifest, y); + r = store->append_atomic_test(dpp, &source->get_ctx(), source->get_bucket_info(), state.obj, op, &astate, &manifest, y); if (r < 0) return r; @@ -6630,8 +6604,7 @@ int RGWRados::Object::Read::iterate(const DoutPrefixProvider *dpp, int64_t ofs, auto aio = rgw::make_throttle(window_size, y); get_obj_data data(store, cb, &*aio, ofs, y); - int r = store->iterate_obj(dpp, source->get_ctx(), source->get_bucket_info(), - source->get_target(), + int r = store->iterate_obj(dpp, source->get_ctx(), source->get_bucket_info(), state.obj, ofs, end, chunk_size, _get_obj_iterate_cb, &data, y); if (r < 0) { ldpp_dout(dpp, 0) << "iterate_obj() failed with " << r << dendl; @@ -6643,7 +6616,7 @@ int RGWRados::Object::Read::iterate(const DoutPrefixProvider *dpp, int64_t ofs, } int RGWRados::iterate_obj(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, - RGWBucketInfo& bucket_info, rgw::sal::Object* obj, + RGWBucketInfo& bucket_info, const rgw_obj& obj, off_t ofs, off_t end, uint64_t max_chunk_size, iterate_obj_cb cb, void *arg, optional_yield y) { @@ -6655,7 +6628,7 @@ int RGWRados::iterate_obj(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *astate = NULL; RGWObjManifest *manifest = nullptr; - obj_to_raw(bucket_info.placement_rule, obj->get_obj(), &head_obj); + obj_to_raw(bucket_info.placement_rule, obj, &head_obj); int r = get_obj_state(dpp, &obj_ctx, bucket_info, obj, &astate, &manifest, false, y); if (r < 0) { @@ -6678,7 +6651,7 @@ int RGWRados::iterate_obj(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, off_t next_stripe_ofs = stripe_ofs + iter.get_stripe_size(); while (ofs < next_stripe_ofs && ofs <= end) { - read_obj = iter.get_location().get_raw_obj(driver); + read_obj = iter.get_location().get_raw_obj(this); uint64_t read_len = std::min(len, iter.get_stripe_size() - (ofs - stripe_ofs)); read_ofs = iter.location_ofs() + (ofs - stripe_ofs); @@ -7321,9 +7294,10 @@ static int decode_olh_info(const DoutPrefixProvider *dpp, CephContext* cct, cons } int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, + RGWObjectCtx& obj_ctx, RGWObjState& state, RGWBucketInfo& bucket_info, - const rgw::sal::Object* obj, + const rgw_obj& obj, bufferlist& olh_tag, std::map >& log, uint64_t *plast_ver, @@ -7418,15 +7392,15 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, } rgw_rados_ref ref; - int r = get_obj_head_ref(dpp, bucket_info, obj->get_obj(), &ref); + int r = get_obj_head_ref(dpp, bucket_info, obj, &ref); if (r < 0) { return r; } - rgw::sal::Bucket* bucket = obj->get_bucket(); + const rgw_bucket& bucket = obj.bucket; if (need_to_link) { - rgw_obj target(bucket->get_key(), key); + rgw_obj target(bucket, key); RGWOLHInfo info; info.target = target; info.removed = delete_marker; @@ -7439,8 +7413,8 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, for (list::iterator liter = remove_instances.begin(); liter != remove_instances.end(); ++liter) { cls_rgw_obj_key& key = *liter; - std::unique_ptr obj_instance = bucket->get_object(key); - int ret = delete_obj(dpp, bucket_info, obj_instance.get(), 0, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace); + rgw_obj obj_instance(bucket, key); + int ret = delete_obj(dpp, obj_ctx, bucket_info, obj_instance, 0, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace); if (ret < 0 && ret != -ENOENT) { ldpp_dout(dpp, 0) << "ERROR: delete_obj() returned " << ret << " obj_instance=" << obj_instance << dendl; return ret; @@ -7454,7 +7428,7 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, return r; } - r = bucket_index_trim_olh_log(dpp, bucket_info, state, obj->get_obj(), last_ver); + r = bucket_index_trim_olh_log(dpp, bucket_info, state, obj, last_ver); if (r < 0) { ldpp_dout(dpp, 0) << "ERROR: could not trim olh log, r=" << r << dendl; return r; @@ -7475,7 +7449,7 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, /* * only clear if was successful, otherwise we might clobber pending operations on this object */ - r = bucket_index_clear_olh(dpp, bucket_info, state, obj->get_obj()); + r = bucket_index_clear_olh(dpp, bucket_info, state, obj); if (r < 0) { ldpp_dout(dpp, 0) << "ERROR: could not clear bucket index olh entries r=" << r << dendl; return r; @@ -7489,18 +7463,18 @@ int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp, /* * read olh log and apply it */ -int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw::sal::Object* obj, rgw_zone_set *zones_trace) +int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_zone_set *zones_trace) { map > log; bool is_truncated; uint64_t ver_marker = 0; do { - int ret = bucket_index_read_olh_log(dpp, bucket_info, *state, obj->get_obj(), ver_marker, &log, &is_truncated); + int ret = bucket_index_read_olh_log(dpp, bucket_info, *state, obj, ver_marker, &log, &is_truncated); if (ret < 0) { return ret; } - ret = apply_olh_log(dpp, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, zones_trace); + ret = apply_olh_log(dpp, obj_ctx, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, zones_trace); if (ret < 0) { return ret; } @@ -7511,15 +7485,15 @@ int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjState *state, RGWB int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, - rgw::sal::Object* target_obj, bool delete_marker, + const rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta, uint64_t olh_epoch, real_time unmod_since, bool high_precision_time, optional_yield y, rgw_zone_set *zones_trace, bool log_data_change) { string op_tag; - std::unique_ptr olh_obj = target_obj->clone(); - olh_obj->clear_instance(); + rgw_obj olh_obj = target_obj; + olh_obj.key.instance.clear(); RGWObjState *state = NULL; RGWObjManifest *manifest = nullptr; @@ -7530,15 +7504,15 @@ int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, #define MAX_ECANCELED_RETRY 100 for (i = 0; i < MAX_ECANCELED_RETRY; i++) { if (ret == -ECANCELED) { - olh_obj->invalidate(); + obj_ctx.invalidate(olh_obj); } - ret = get_obj_state(dpp, &obj_ctx, bucket_info, olh_obj.get(), &state, &manifest, false, y); /* don't follow olh */ + ret = get_obj_state(dpp, &obj_ctx, bucket_info, olh_obj, &state, &manifest, false, y); /* don't follow olh */ if (ret < 0) { return ret; } - ret = olh_init_modification(dpp, bucket_info, *state, olh_obj->get_obj(), &op_tag); + ret = olh_init_modification(dpp, bucket_info, *state, olh_obj, &op_tag); if (ret < 0) { ldpp_dout(dpp, 20) << "olh_init_modification() target_obj=" << target_obj << " delete_marker=" << (int)delete_marker << " returned " << ret << dendl; if (ret == -ECANCELED) { @@ -7546,7 +7520,7 @@ int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, } return ret; } - ret = bucket_index_link_olh(dpp, bucket_info, *state, target_obj->get_obj(), + ret = bucket_index_link_olh(dpp, bucket_info, *state, target_obj, delete_marker, op_tag, meta, olh_epoch, unmod_since, high_precision_time, y, zones_trace, log_data_change); if (ret < 0) { @@ -7554,7 +7528,7 @@ int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, if (ret == -ECANCELED) { // the bucket index rejected the link_olh() due to olh tag mismatch; // attempt to reconstruct olh head attributes based on the bucket index - int r2 = repair_olh(dpp, state, bucket_info, olh_obj->get_obj()); + int r2 = repair_olh(dpp, state, bucket_info, olh_obj); if (r2 < 0 && r2 != -ECANCELED) { return r2; } @@ -7570,7 +7544,7 @@ int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, return -EIO; } - ret = update_olh(dpp, state, bucket_info, olh_obj.get()); + ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj); if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */ ret = 0; } @@ -7582,29 +7556,30 @@ int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, return 0; } -int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, rgw::sal::Object* target_obj, +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) { string op_tag; - std::unique_ptr olh_obj = target_obj->clone(); - olh_obj->clear_instance(); + rgw_obj olh_obj = target_obj; + olh_obj.key.instance.clear(); RGWObjState *state = NULL; + RGWObjManifest *manifest = NULL; int ret = 0; int i; for (i = 0; i < MAX_ECANCELED_RETRY; i++) { if (ret == -ECANCELED) { - olh_obj->invalidate(); + obj_ctx.invalidate(olh_obj); } - ret = olh_obj->get_obj_state(dpp, &state, y, false); /* don't follow olh */ + ret = get_obj_state(dpp, &obj_ctx, bucket_info, olh_obj, &state, &manifest, false, y); /* don't follow olh */ if (ret < 0) return ret; - ret = olh_init_modification(dpp, bucket_info, *state, olh_obj->get_obj(), &op_tag); + ret = olh_init_modification(dpp, bucket_info, *state, olh_obj, &op_tag); if (ret < 0) { ldpp_dout(dpp, 20) << "olh_init_modification() target_obj=" << target_obj << " returned " << ret << dendl; if (ret == -ECANCELED) { @@ -7615,7 +7590,7 @@ int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& string olh_tag(state->olh_tag.c_str(), state->olh_tag.length()); - ret = bucket_index_unlink_instance(dpp, bucket_info, target_obj->get_obj(), op_tag, olh_tag, olh_epoch, zones_trace); + ret = bucket_index_unlink_instance(dpp, bucket_info, target_obj, op_tag, olh_tag, olh_epoch, zones_trace); if (ret < 0) { ldpp_dout(dpp, 20) << "bucket_index_unlink_instance() target_obj=" << target_obj << " returned " << ret << dendl; if (ret == -ECANCELED) { @@ -7631,7 +7606,7 @@ int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& return -EIO; } - ret = update_olh(dpp, state, bucket_info, olh_obj.get(), zones_trace); + ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj, zones_trace); if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */ return 0; } @@ -7744,7 +7719,7 @@ int RGWRados::remove_olh_pending_entries(const DoutPrefixProvider *dpp, RGWBucke return 0; } -int RGWRados::follow_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, RGWObjectCtx& obj_ctx, RGWObjState *state, rgw::sal::Object* olh_obj, rgw_obj *target) +int RGWRados::follow_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, RGWObjectCtx& obj_ctx, RGWObjState *state, const rgw_obj& olh_obj, rgw_obj *target) { map pending_entries; rgw_filter_attrset(state->attrset, RGW_ATTR_OLH_PENDING_PREFIX, &pending_entries); @@ -7753,16 +7728,16 @@ int RGWRados::follow_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_in check_pending_olh_entries(dpp, pending_entries, &rm_pending_entries); if (!rm_pending_entries.empty()) { - int ret = remove_olh_pending_entries(dpp, bucket_info, *state, olh_obj->get_obj(), rm_pending_entries); + int ret = remove_olh_pending_entries(dpp, bucket_info, *state, olh_obj, rm_pending_entries); if (ret < 0) { ldpp_dout(dpp, 20) << "ERROR: rm_pending_entries returned ret=" << ret << dendl; return ret; } } if (!pending_entries.empty()) { - ldpp_dout(dpp, 20) << __func__ << "(): found pending entries, need to update_olh() on bucket=" << olh_obj->get_bucket() << dendl; + ldpp_dout(dpp, 20) << __func__ << "(): found pending entries, need to update_olh() on bucket=" << olh_obj.bucket << dendl; - int ret = update_olh(dpp, state, bucket_info, olh_obj); + int ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj); if (ret < 0) { if (ret == -ECANCELED) { // In this context, ECANCELED means that the OLH tag changed in either the bucket index entry or the OLH object. @@ -9334,21 +9309,20 @@ int RGWRados::check_disk_state(const DoutPrefixProvider *dpp, ldout_bitx(bitx, dpp, 10) << "ENTERING " << __func__ << ": bucket=" << bucket_info.bucket << " dir_entry=" << list_state.key << dendl_bitx; - std::unique_ptr bucket; - driver->get_bucket(nullptr, bucket_info, &bucket); uint8_t suggest_flag = (svc.zone->need_to_log_data() ? CEPH_RGW_DIR_SUGGEST_LOG_OP : 0); std::string loc; - std::unique_ptr obj = bucket->get_object(list_state.key); + rgw_obj obj(bucket_info.bucket, list_state.key); + MultipartMetaFilter multipart_meta_filter; string temp_key; if (multipart_meta_filter.filter(list_state.key.name, temp_key)) { - obj->set_in_extra_data(true); + obj.in_extra_data = true; } string oid; - get_obj_bucket_and_oid_loc(obj->get_obj(), oid, loc); + get_obj_bucket_and_oid_loc(obj, oid, loc); if (loc != list_state.locator) { ldpp_dout(dpp, 0) << "WARNING: generated locator (" << loc << ") is different from listed locator (" << list_state.locator << ")" << dendl; @@ -9359,7 +9333,7 @@ int RGWRados::check_disk_state(const DoutPrefixProvider *dpp, RGWObjState *astate = NULL; RGWObjManifest *manifest = nullptr; RGWObjectCtx rctx(this->driver); - int r = get_obj_state(dpp, &rctx, bucket_info, obj.get(), &astate, &manifest, false, y); + int r = get_obj_state(dpp, &rctx, bucket_info, obj, &astate, &manifest, false, y); if (r < 0) return r; @@ -9420,7 +9394,7 @@ int RGWRados::check_disk_state(const DoutPrefixProvider *dpp, if (manifest) { RGWObjManifest::obj_iterator miter; for (miter = manifest->obj_begin(dpp); miter != manifest->obj_end(dpp); ++miter) { - const rgw_raw_obj& raw_loc = miter.get_location().get_raw_obj(driver); + const rgw_raw_obj& raw_loc = miter.get_location().get_raw_obj(this); rgw_obj loc; RGWSI_Tier_RADOS::raw_obj_to_obj(manifest->get_obj().bucket, raw_loc, &loc); @@ -9454,7 +9428,7 @@ int RGWRados::check_disk_state(const DoutPrefixProvider *dpp, list_state.meta.storage_class = storage_class; librados::IoCtx head_obj_ctx; // initialize to data pool so we can get pool id - r = get_obj_head_ioctx(dpp, bucket_info, obj->get_obj(), &head_obj_ctx); + r = get_obj_head_ioctx(dpp, bucket_info, obj, &head_obj_ctx); if (r < 0) { ldpp_dout(dpp, 0) << __func__ << " WARNING: unable to find head object data pool for \"" << diff --git a/src/rgw/driver/rados/rgw_rados.h b/src/rgw/driver/rados/rgw_rados.h index 397fce2134d..886ab16cce9 100644 --- a/src/rgw/driver/rados/rgw_rados.h +++ b/src/rgw/driver/rados/rgw_rados.h @@ -203,7 +203,7 @@ public: RGWObjStateManifest *get_state(const rgw_obj& obj); void set_compressed(const rgw_obj& obj); - void set_atomic(rgw_obj& obj); + void set_atomic(const rgw_obj& obj); void set_prefetch_data(const rgw_obj& obj); void invalidate(const rgw_obj& obj); }; @@ -400,12 +400,12 @@ class RGWRados uint64_t max_bucket_id; int get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& rctx, - RGWBucketInfo& bucket_info, rgw::sal::Object* obj, + RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState *olh_state, RGWObjState **target_state, RGWObjManifest **target_manifest, optional_yield y); - int get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest, + int get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state, RGWObjManifest** manifest, bool follow_olh, optional_yield y, bool assume_noent = false); - int append_atomic_test(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, + int append_atomic_test(const DoutPrefixProvider *dpp, RGWObjectCtx* rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, librados::ObjectOperation& op, RGWObjState **state, RGWObjManifest** pmanifest, optional_yield y); @@ -660,9 +660,9 @@ public: class Object { RGWRados *store; - rgw::sal::Bucket* bucket; + RGWBucketInfo bucket_info; RGWObjectCtx& ctx; - rgw::sal::Object* obj; + rgw_obj obj; BucketShard bs; @@ -684,24 +684,24 @@ public: int complete_atomic_modification(const DoutPrefixProvider *dpp); public: - Object(RGWRados *_store, rgw::sal::Bucket* _bucket, RGWObjectCtx& _ctx, rgw::sal::Object* _obj) : store(_store), bucket(_bucket), + Object(RGWRados *_store, const RGWBucketInfo& _bucket_info, RGWObjectCtx& _ctx, const rgw_obj& _obj) : store(_store), bucket_info(_bucket_info), ctx(_ctx), obj(_obj), bs(store), state(NULL), manifest(nullptr), versioning_disabled(false), bs_initialized(false), pmeta_placement_rule(nullptr) {} RGWRados *get_store() { return store; } - rgw_obj get_obj() { return obj->get_obj(); } + rgw_obj& get_obj() { return obj; } RGWObjectCtx& get_ctx() { return ctx; } - RGWBucketInfo& get_bucket_info() { return bucket->get_info(); } - const std::string& get_instance() { return obj->get_instance(); } - rgw::sal::Object* get_target() { return obj; } + RGWBucketInfo& get_bucket_info() { return bucket_info; } + //const std::string& get_instance() { return obj->get_instance(); } + //rgw::sal::Object* get_target() { return obj; } int get_manifest(const DoutPrefixProvider *dpp, RGWObjManifest **pmanifest, optional_yield y); int get_bucket_shard(BucketShard **pbs, const DoutPrefixProvider *dpp) { if (!bs_initialized) { int r = - bs.init(bucket->get_key(), obj->get_obj(), nullptr /* no RGWBucketInfo */, dpp); + bs.init(bucket_info.bucket, obj, nullptr /* no RGWBucketInfo */, dpp); if (r < 0) { return r; } @@ -716,7 +716,7 @@ public: } bool versioning_enabled() { - return (!versioning_disabled && bucket->versioning_enabled()); + return (!versioning_disabled && bucket_info.versioning_enabled()); } void set_meta_placement_rule(const rgw_placement_rule *p) { @@ -724,7 +724,7 @@ public: } const rgw_placement_rule& get_meta_placement_rule() { - return pmeta_placement_rule ? *pmeta_placement_rule : bucket->get_placement_rule(); + return pmeta_placement_rule ? *pmeta_placement_rule : bucket_info.placement_rule; } struct Read { @@ -1048,26 +1048,26 @@ public: const std::string& obj_delim, std::function handler); - bool swift_versioning_enabled(rgw::sal::Bucket* bucket) const; + bool swift_versioning_enabled(const RGWBucketInfo& bucket_info) const; int swift_versioning_copy(RGWObjectCtx& obj_ctx, /* in/out */ const rgw_user& user, /* in */ - rgw::sal::Bucket* bucket, /* in */ - rgw::sal::Object* obj, /* in */ - const DoutPrefixProvider *dpp, /* in/out */ + RGWBucketInfo& bucket_info, /* in */ + const rgw_obj& obj, /* in */ + const DoutPrefixProvider *dpp, /* in */ optional_yield y); /* in */ int swift_versioning_restore(RGWObjectCtx& obj_ctx, /* in/out */ const rgw_user& user, /* in */ - rgw::sal::Bucket* bucket, /* in */ - rgw::sal::Object* obj, /* in */ - bool& restored, /* out */ - const DoutPrefixProvider *dpp); /* in/out */ + RGWBucketInfo& bucket_info, /* in */ + rgw_obj& obj, /* in/out */ + bool& restored, /* out */ + const DoutPrefixProvider *dpp); /* in */ int copy_obj_to_remote_dest(const DoutPrefixProvider *dpp, RGWObjState *astate, std::map& src_attrs, RGWRados::Object::Read& read_op, const rgw_user& user_id, - rgw::sal::Object* dest_obj, + const rgw_obj& dest_obj, ceph::real_time *mtime); enum AttrsMod { @@ -1078,7 +1078,7 @@ public: D3nDataCache* d3n_data_cache{nullptr}; - int rewrite_obj(rgw::sal::Object* obj, const DoutPrefixProvider *dpp, optional_yield y); + int rewrite_obj(RGWBucketInfo& dest_bucket_info, const rgw_obj& obj, const DoutPrefixProvider *dpp, optional_yield y); int reindex_obj(const RGWBucketInfo& dest_bucket_info, const rgw_obj& obj, const DoutPrefixProvider* dpp, @@ -1089,7 +1089,7 @@ public: const rgw_user& user_id, req_info *info, const rgw_zone_id& source_zone, - rgw::sal::Object* src_obj, + const rgw_obj& src_obj, const RGWBucketInfo *src_bucket_info, real_time *src_mtime, uint64_t *psize, @@ -1108,10 +1108,10 @@ public: const rgw_user& user_id, req_info *info, const rgw_zone_id& source_zone, - rgw::sal::Object* dest_obj, - rgw::sal::Object* src_obj, - rgw::sal::Bucket* dest_bucket, - rgw::sal::Bucket* src_bucket, + const rgw_obj& dest_obj, + const rgw_obj& src_obj, + RGWBucketInfo& dest_bucket_info, + RGWBucketInfo *src_bucket_info, std::optional dest_placement, ceph::real_time *src_mtime, ceph::real_time *mtime, @@ -1152,10 +1152,10 @@ public: const rgw_user& user_id, req_info *info, const rgw_zone_id& source_zone, - rgw::sal::Object* dest_obj, - rgw::sal::Object* src_obj, - rgw::sal::Bucket* dest_bucket, - rgw::sal::Bucket* src_bucket, + const rgw_obj& dest_obj, + const rgw_obj& src_obj, + RGWBucketInfo& dest_bucket_info, + RGWBucketInfo& src_bucket_info, const rgw_placement_rule& dest_placement, ceph::real_time *src_mtime, ceph::real_time *mtime, @@ -1179,10 +1179,10 @@ public: optional_yield y); int copy_obj_data(RGWObjectCtx& obj_ctx, - rgw::sal::Bucket* bucket, + RGWBucketInfo& dest_bucket_info, const rgw_placement_rule& dest_placement, RGWRados::Object::Read& read_op, off_t end, - rgw::sal::Object* dest_obj, + const rgw_obj& dest_obj, ceph::real_time *mtime, ceph::real_time set_mtime, std::map& attrs, @@ -1193,8 +1193,8 @@ public: optional_yield y); int transition_obj(RGWObjectCtx& obj_ctx, - rgw::sal::Bucket* bucket, - rgw::sal::Object& obj, + RGWBucketInfo& bucket_info, + const rgw_obj& obj, const rgw_placement_rule& placement_rule, const real_time& mtime, uint64_t olh_epoch, @@ -1222,17 +1222,10 @@ public: int bucket_suspended(const DoutPrefixProvider *dpp, rgw_bucket& bucket, bool *suspended); /** Delete an object.*/ - int delete_obj(rgw::sal::Driver* driver, - const DoutPrefixProvider *dpp, - const RGWBucketInfo& bucket_owner, - const rgw_obj& src_obj, - int versioning_status, // versioning flags defined in enum RGWBucketFlags - uint16_t bilog_flags = 0, - const ceph::real_time& expiration_time = ceph::real_time(), - rgw_zone_set *zones_trace = nullptr); int delete_obj(const DoutPrefixProvider *dpp, - const RGWBucketInfo& bucket_owner, - rgw::sal::Object* src_obj, + RGWObjectCtx& obj_ctx, + const RGWBucketInfo& bucket_info, + const rgw_obj& obj, int versioning_status, // versioning flags defined in enum RGWBucketFlags uint16_t bilog_flags = 0, const ceph::real_time& expiration_time = ceph::real_time(), @@ -1252,16 +1245,16 @@ public: * bl: the contents of the attr * Returns: 0 on success, -ERR# otherwise. */ - int set_attr(const DoutPrefixProvider *dpp, RGWObjectCtx* ctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, const char *name, bufferlist& bl); + int set_attr(const DoutPrefixProvider *dpp, RGWObjectCtx* ctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, const char *name, bufferlist& bl); - int set_attrs(const DoutPrefixProvider *dpp, void *ctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, + int set_attrs(const DoutPrefixProvider *dpp, RGWObjectCtx* ctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, std::map& attrs, std::map* rmattrs, optional_yield y); - int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest, + int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state, RGWObjManifest** manifest, bool follow_olh, optional_yield y, bool assume_noent = false); - int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest, optional_yield y) { + int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state, RGWObjManifest** manifest, optional_yield y) { return get_obj_state(dpp, rctx, bucket_info, obj, state, manifest, true, y); } @@ -1269,7 +1262,7 @@ public: off_t, bool, RGWObjState*, void*); int iterate_obj(const DoutPrefixProvider *dpp, RGWObjectCtx& ctx, RGWBucketInfo& bucket_info, - rgw::sal::Object* obj, off_t ofs, off_t end, + const rgw_obj& obj, off_t ofs, off_t end, uint64_t max_chunk_size, iterate_obj_cb cb, void *arg, optional_yield y); @@ -1326,21 +1319,21 @@ public: std::map > *log, bool *is_truncated); int bucket_index_trim_olh_log(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, RGWObjState& obj_state, const rgw_obj& obj_instance, uint64_t ver); int bucket_index_clear_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj_instance); - int apply_olh_log(const DoutPrefixProvider *dpp, RGWObjState& obj_state, RGWBucketInfo& bucket_info, const rgw::sal::Object* obj, + 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, rgw_zone_set *zones_trace = nullptr); - int update_olh(const DoutPrefixProvider *dpp, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw::sal::Object* obj, rgw_zone_set *zones_trace = nullptr); - int set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, rgw::sal::Object* target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta, + int update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_zone_set *zones_trace = nullptr); + int set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta, uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time, optional_yield y, rgw_zone_set *zones_trace = nullptr, bool log_data_change = false); int repair_olh(const DoutPrefixProvider *dpp, RGWObjState* state, const RGWBucketInfo& bucket_info, const rgw_obj& obj); - int unlink_obj_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, rgw::sal::Object* target_obj, + 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); 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, RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, std::map& pending_attrs); - int follow_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, RGWObjectCtx& ctx, RGWObjState *state, rgw::sal::Object* olh_obj, rgw_obj *target); + int follow_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, RGWObjectCtx& ctx, RGWObjState *state, const rgw_obj& olh_obj, rgw_obj *target); int get_olh(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWOLHInfo *olh); void gen_rand_obj_instance_name(rgw_obj_key *target_key); @@ -1350,7 +1343,7 @@ public: int append_async(const DoutPrefixProvider *dpp, rgw_raw_obj& obj, size_t size, bufferlist& bl); public: - void set_atomic(void *ctx, rgw_obj& obj) { + void set_atomic(void *ctx, const rgw_obj& obj) { RGWObjectCtx *rctx = static_cast(ctx); rctx->set_atomic(obj); } @@ -1489,7 +1482,7 @@ public: int list_gc_objs(int *index, std::string& marker, uint32_t max, bool expired_only, std::list& result, bool *truncated, bool& processing_queue); int process_gc(bool expired_only); bool process_expire_objects(const DoutPrefixProvider *dpp); - int defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx* ctx, RGWBucketInfo& bucket_info, rgw::sal::Object* obj, optional_yield y); + int defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx* ctx, RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y); int process_lc(const std::unique_ptr& optional_bucket); int list_lc_progress(std::string& marker, uint32_t max_entries, diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc index 67b600b472e..ef9941df94c 100644 --- a/src/rgw/driver/rados/rgw_sal_rados.cc +++ b/src/rgw/driver/rados/rgw_sal_rados.cc @@ -121,7 +121,7 @@ static int rgw_op_get_bucket_policy_from_attr(const DoutPrefixProvider* dpp, return 0; } -int RadosCompletions::drain() +static int drain_aio(std::list& handles) { int ret = 0; while (!handles.empty()) { @@ -137,6 +137,11 @@ int RadosCompletions::drain() return ret; } +int RadosCompletions::drain() +{ + return drain_aio(handles); +} + int RadosUser::list_buckets(const DoutPrefixProvider* dpp, const std::string& marker, const std::string& end_marker, uint64_t max, bool need_stats, BucketList &buckets, optional_yield y) @@ -532,7 +537,7 @@ int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool params.list_versions = true; params.allow_unordered = true; - std::unique_ptr handles = store->get_completions(); + std::list handles; int max_aio = concurrent_max; results.is_truncated = true; @@ -546,10 +551,10 @@ int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool for (; it != results.objs.end(); ++it) { RGWObjState *astate = NULL; RGWObjManifest *amanifest = nullptr; - std::unique_ptr obj = get_object((*it).key); + rgw_obj obj{get_key(), it->key}; - ret = store->getRados()->get_obj_state(dpp, &obj_ctx, obj->get_bucket()->get_info(), - obj.get(), &astate, &amanifest, + ret = store->getRados()->get_obj_state(dpp, &obj_ctx, get_info(), + obj, &astate, &amanifest, false, y); if (ret == -ENOENT) { ldpp_dout(dpp, 1) << "WARNING: cannot find obj state for obj " << obj << dendl; @@ -563,13 +568,13 @@ int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool if (amanifest) { RGWObjManifest& manifest = *amanifest; RGWObjManifest::obj_iterator miter = manifest.obj_begin(dpp); - std::unique_ptr head_obj = get_object(manifest.get_obj().key); + const rgw_obj head_obj = manifest.get_obj(); rgw_raw_obj raw_head_obj; - dynamic_cast(head_obj.get())->get_raw_obj(&raw_head_obj); + store->get_raw_obj(manifest.get_head_placement_rule(), head_obj, &raw_head_obj); for (; miter != manifest.obj_end(dpp) && max_aio--; ++miter) { if (!max_aio) { - ret = handles->drain(); + ret = drain_aio(handles); if (ret < 0) { ldpp_dout(dpp, -1) << "ERROR: could not drain handles as aio completion returned with " << ret << dendl; return ret; @@ -577,20 +582,21 @@ int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool max_aio = concurrent_max; } - rgw_raw_obj last_obj = miter.get_location().get_raw_obj(store); + rgw_raw_obj last_obj = miter.get_location().get_raw_obj(store->getRados()); if (last_obj == raw_head_obj) { // have the head obj deleted at the end continue; } - ret = store->delete_raw_obj_aio(dpp, last_obj, handles.get()); + ret = store->getRados()->delete_raw_obj_aio(dpp, last_obj, handles); if (ret < 0) { ldpp_dout(dpp, -1) << "ERROR: delete obj aio failed with " << ret << dendl; return ret; } } // for all shadow objs - ret = head_obj->delete_obj_aio(dpp, astate, handles.get(), keep_index_consistent, y); + ret = store->getRados()->delete_obj_aio(dpp, head_obj, get_info(), astate, + handles, keep_index_consistent, y); if (ret < 0) { ldpp_dout(dpp, -1) << "ERROR: delete obj aio failed with " << ret << dendl; return ret; @@ -598,18 +604,18 @@ int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool } if (!max_aio) { - ret = handles->drain(); + ret = drain_aio(handles); if (ret < 0) { ldpp_dout(dpp, -1) << "ERROR: could not drain handles as aio completion returned with " << ret << dendl; return ret; } max_aio = concurrent_max; } - obj_ctx.invalidate(obj->get_obj()); + obj_ctx.invalidate(obj); } // for all RGW objects in results } // while is_truncated - ret = handles->drain(); + ret = drain_aio(handles); if (ret < 0) { ldpp_dout(dpp, -1) << "ERROR: could not drain handles as aio completion returned with " << ret << dendl; return ret; @@ -1676,16 +1682,18 @@ int RadosStore::get_oidc_providers(const DoutPrefixProvider *dpp, std::unique_ptr RadosStore::get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, uint64_t position, uint64_t *cur_accounted_size) { + RGWBucketInfo& bucket_info = obj->get_bucket()->get_info(); + RGWObjectCtx& obj_ctx = static_cast(obj)->get_ctx(); auto aio = rgw::make_throttle(ctx()->_conf->rgw_put_obj_min_window_size, y); return std::make_unique(dpp, y, - std::move(_head_obj), + bucket_info, obj_ctx, obj->get_obj(), this, std::move(aio), owner, ptail_placement_rule, unique_tag, position, @@ -1694,15 +1702,17 @@ std::unique_ptr RadosStore::get_append_writer(const DoutPrefixProvider * std::unique_ptr RadosStore::get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, const std::string& unique_tag) { + RGWBucketInfo& bucket_info = obj->get_bucket()->get_info(); + RGWObjectCtx& obj_ctx = static_cast(obj)->get_ctx(); auto aio = rgw::make_throttle(ctx()->_conf->rgw_put_obj_min_window_size, y); return std::make_unique(dpp, y, - std::move(_head_obj), + bucket_info, obj_ctx, obj->get_obj(), this, std::move(aio), owner, ptail_placement_rule, olh_epoch, unique_tag); @@ -1731,7 +1741,7 @@ RadosObject::~RadosObject() int RadosObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **pstate, optional_yield y, bool follow_olh) { - int ret = store->getRados()->get_obj_state(dpp, rados_ctx, bucket->get_info(), this, pstate, &manifest, follow_olh, y); + int ret = store->getRados()->get_obj_state(dpp, rados_ctx, bucket->get_info(), get_obj(), pstate, &manifest, follow_olh, y); if (ret < 0) { return ret; } @@ -1764,7 +1774,7 @@ int RadosObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, A Attrs empty; return store->getRados()->set_attrs(dpp, rados_ctx, bucket->get_info(), - this, + get_obj(), setattrs ? *setattrs : empty, delattrs ? delattrs : nullptr, y); @@ -1772,7 +1782,7 @@ int RadosObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, A int RadosObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj) { - RGWRados::Object op_target(store->getRados(), bucket, *rados_ctx, this); + RGWRados::Object op_target(store->getRados(), bucket->get_info(), *rados_ctx, get_obj()); RGWRados::Object::Read read_op(&op_target); return read_attrs(dpp, read_op, y, target_obj); @@ -1964,7 +1974,7 @@ int RadosObject::transition(Bucket* bucket, const DoutPrefixProvider* dpp, optional_yield y) { - return store->getRados()->transition_obj(*rados_ctx, bucket, *this, placement_rule, mtime, olh_epoch, dpp, y); + return store->getRados()->transition_obj(*rados_ctx, bucket->get_info(), get_obj(), placement_rule, mtime, olh_epoch, dpp, y); } int RadosObject::transition_to_cloud(Bucket* bucket, @@ -2054,7 +2064,7 @@ int RadosObject::write_cloud_tier(const DoutPrefixProvider* dpp, { rgw::sal::RadosPlacementTier* rtier = static_cast(tier); map attrs = get_attrs(); - RGWRados::Object op_target(store->getRados(), bucket, *rados_ctx, this); + RGWRados::Object op_target(store->getRados(), bucket->get_info(), *rados_ctx, get_obj()); RGWRados::Object::Write obj_op(&op_target); obj_op.meta.modify_tail = true; @@ -2136,7 +2146,7 @@ int RadosObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y RGWObjManifest *amanifest{nullptr}; rgw_raw_obj head_obj; - RGWRados::Object op_target(store->getRados(), get_bucket(), *rados_ctx, this); + RGWRados::Object op_target(store->getRados(), bucket->get_info(), *rados_ctx, get_obj()); RGWRados::Object::Read parent_op(&op_target); uint64_t obj_size; @@ -2160,7 +2170,7 @@ int RadosObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y f->open_array_section("data_location"); for (auto miter = amanifest->obj_begin(dpp); miter != amanifest->obj_end(dpp); ++miter) { f->open_object_section("obj"); - rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(store); + rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(store->getRados()); uint64_t ofs = miter.get_ofs(); uint64_t left = amanifest->get_obj_size() - ofs; ::encode_json("ofs", miter.get_ofs(), f); @@ -2187,9 +2197,9 @@ RadosObject::RadosReadOp::RadosReadOp(RadosObject *_source, RGWObjectCtx *_rctx) source(_source), rctx(_rctx), op_target(_source->store->getRados(), - _source->get_bucket(), + _source->get_bucket()->get_info(), *static_cast(rctx), - _source), + _source->get_obj()), parent_op(&op_target) { } @@ -2237,9 +2247,9 @@ std::unique_ptr RadosObject::get_delete_op() RadosObject::RadosDeleteOp::RadosDeleteOp(RadosObject *_source) : source(_source), op_target(_source->store->getRados(), - _source->get_bucket(), + _source->get_bucket()->get_info(), _source->get_ctx(), - _source), + _source->get_obj()), parent_op(&op_target) { } @@ -2274,7 +2284,7 @@ int RadosObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning) { - RGWRados::Object del_target(store->getRados(), bucket, *rados_ctx, this); + 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; @@ -2325,10 +2335,10 @@ int RadosObject::copy_object(User* user, user->get_id(), info, source_zone, - dest_object, - this, - dest_bucket, - src_bucket, + dest_object->get_obj(), + get_obj(), + dest_bucket->get_info(), + src_bucket->get_info(), dest_placement, src_mtime, mtime, @@ -2360,10 +2370,11 @@ int RadosObject::RadosReadOp::iterate(const DoutPrefixProvider* dpp, int64_t ofs int RadosObject::swift_versioning_restore(bool& restored, const DoutPrefixProvider* dpp) { + rgw_obj obj = get_obj(); return store->getRados()->swift_versioning_restore(*rados_ctx, bucket->get_owner()->get_id(), - bucket, - this, + bucket->get_info(), + obj, restored, dpp); } @@ -2372,8 +2383,8 @@ int RadosObject::swift_versioning_copy(const DoutPrefixProvider* dpp, optional_y { return store->getRados()->swift_versioning_copy(*rados_ctx, bucket->get_info().owner, - bucket, - this, + bucket->get_info(), + get_obj(), dpp, y); } @@ -2396,7 +2407,7 @@ int RadosMultipartUpload::cleanup_part_history(const DoutPrefixProvider* dpp, manifest.set_prefix(ppfx); RGWObjManifest::obj_iterator miter = manifest.obj_begin(dpp); for (; miter != manifest.obj_end(dpp); ++miter) { - rgw_raw_obj raw_part_obj = miter.get_location().get_raw_obj(store); + rgw_raw_obj raw_part_obj = miter.get_location().get_raw_obj(store->getRados()); cls_rgw_obj_key part_key(raw_part_obj.oid); chain.push_obj(raw_part_obj.pool.to_str(), part_key, raw_part_obj.loc); } @@ -2457,7 +2468,7 @@ int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct) RGWObjManifest::obj_iterator oiter = obj_part->info.manifest.obj_begin(dpp); if (oiter != obj_part->info.manifest.obj_end(dpp)) { std::unique_ptr head = bucket->get_object(rgw_obj_key()); - rgw_raw_obj raw_head = oiter.get_location().get_raw_obj(store); + rgw_raw_obj raw_head = oiter.get_location().get_raw_obj(store->getRados()); dynamic_cast(head.get())->raw_obj_to_obj(raw_head); rgw_obj_index_key key; @@ -2534,8 +2545,8 @@ int RadosMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y, obj->set_hash_source(oid); RGWRados::Object op_target(store->getRados(), - obj->get_bucket(), - obj_ctx, obj.get()); + obj->get_bucket()->get_info(), + obj_ctx, obj->get_obj()); RGWRados::Object::Write obj_op(&op_target); op_target.set_versioning_disabled(true); /* no versioning for multipart meta */ @@ -2815,9 +2826,9 @@ int RadosMultipartUpload::complete(const DoutPrefixProvider *dpp, target_obj->set_atomic(); RGWRados::Object op_target(store->getRados(), - target_obj->get_bucket(), + target_obj->get_bucket()->get_info(), dynamic_cast(target_obj)->get_ctx(), - target_obj); + target_obj->get_obj()); RGWRados::Object::Write obj_op(&op_target); obj_op.meta.manifest = &manifest; @@ -2916,15 +2927,18 @@ int RadosMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield std::unique_ptr RadosMultipartUpload::get_writer( const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, const std::string& part_num_str) { + RGWBucketInfo& bucket_info = obj->get_bucket()->get_info(); + RGWObjectCtx& obj_ctx = static_cast(obj)->get_ctx(); auto aio = rgw::make_throttle(store->ctx()->_conf->rgw_put_obj_min_window_size, y); - return std::make_unique(dpp, y, this, - std::move(_head_obj), store, std::move(aio), owner, + return std::make_unique(dpp, y, get_upload_id(), + bucket_info, obj_ctx, + obj->get_obj(), store, std::move(aio), owner, ptail_placement_rule, part_num, part_num_str); } diff --git a/src/rgw/driver/rados/rgw_sal_rados.h b/src/rgw/driver/rados/rgw_sal_rados.h index 5835bf01464..7f8a7e7b572 100644 --- a/src/rgw/driver/rados/rgw_sal_rados.h +++ b/src/rgw/driver/rados/rgw_sal_rados.h @@ -227,7 +227,7 @@ class RadosStore : public StoreDriver { std::vector>& providers) override; virtual std::unique_ptr get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, @@ -235,7 +235,7 @@ class RadosStore : public StoreDriver { uint64_t *cur_accounted_size) override; virtual std::unique_ptr get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, @@ -689,7 +689,7 @@ public: virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override; virtual std::unique_ptr get_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, @@ -780,13 +780,15 @@ class RadosAtomicWriter : public StoreWriter { protected: rgw::sal::RadosStore* store; std::unique_ptr aio; - RGWObjectCtx* obj_ctx; + RGWObjectCtx& obj_ctx; rgw::putobj::AtomicObjectProcessor processor; public: RadosAtomicWriter(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + RGWBucketInfo& bucket_info, + RGWObjectCtx& obj_ctx, + const rgw_obj& obj, RadosStore* _store, std::unique_ptr _aio, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, @@ -795,11 +797,10 @@ public: StoreWriter(dpp, y), store(_store), aio(std::move(_aio)), - obj_ctx(&dynamic_cast(_head_obj.get())->get_ctx()), - processor(&*aio, store, - ptail_placement_rule, owner, - *obj_ctx, - std::move(_head_obj), olh_epoch, unique_tag, + obj_ctx(obj_ctx), + processor(&*aio, store->getRados(), bucket_info, + ptail_placement_rule, owner, obj_ctx, + obj, olh_epoch, unique_tag, dpp, y) {} ~RadosAtomicWriter() = default; @@ -825,13 +826,15 @@ class RadosAppendWriter : public StoreWriter { protected: rgw::sal::RadosStore* store; std::unique_ptr aio; - RGWObjectCtx* obj_ctx; + RGWObjectCtx& obj_ctx; rgw::putobj::AppendObjectProcessor processor; public: RadosAppendWriter(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + RGWBucketInfo& bucket_info, + RGWObjectCtx& obj_ctx, + const rgw_obj& obj, RadosStore* _store, std::unique_ptr _aio, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, @@ -841,11 +844,10 @@ public: StoreWriter(dpp, y), store(_store), aio(std::move(_aio)), - obj_ctx(&dynamic_cast(_head_obj.get())->get_ctx()), - processor(&*aio, store, - ptail_placement_rule, owner, - *obj_ctx, - std::move(_head_obj), unique_tag, position, + obj_ctx(obj_ctx), + processor(&*aio, store->getRados(), bucket_info, + ptail_placement_rule, owner, obj_ctx, + obj, unique_tag, position, cur_accounted_size, dpp, y) {} ~RadosAppendWriter() = default; @@ -871,13 +873,15 @@ class RadosMultipartWriter : public StoreWriter { protected: rgw::sal::RadosStore* store; std::unique_ptr aio; - RGWObjectCtx* obj_ctx; + RGWObjectCtx& obj_ctx; rgw::putobj::MultipartObjectProcessor processor; public: RadosMultipartWriter(const DoutPrefixProvider *dpp, - optional_yield y, MultipartUpload* upload, - std::unique_ptr _head_obj, + optional_yield y, const std::string& upload_id, + RGWBucketInfo& bucket_info, + RGWObjectCtx& obj_ctx, + const rgw_obj& obj, RadosStore* _store, std::unique_ptr _aio, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, @@ -885,11 +889,10 @@ public: StoreWriter(dpp, y), store(_store), aio(std::move(_aio)), - obj_ctx(&dynamic_cast(_head_obj.get())->get_ctx()), - processor(&*aio, store, - ptail_placement_rule, owner, - *obj_ctx, - std::move(_head_obj), upload->get_upload_id(), + obj_ctx(obj_ctx), + processor(&*aio, store->getRados(), bucket_info, + ptail_placement_rule, owner, obj_ctx, + obj, upload_id, part_num, part_num_str, dpp, y) {} ~RadosMultipartWriter() = default; diff --git a/src/rgw/driver/rados/rgw_sync_module_aws.cc b/src/rgw/driver/rados/rgw_sync_module_aws.cc index 484df96045b..55340b16cef 100644 --- a/src/rgw/driver/rados/rgw_sync_module_aws.cc +++ b/src/rgw/driver/rados/rgw_sync_module_aws.cc @@ -37,12 +37,9 @@ static string get_key_oid(const rgw_obj_key& key) return oid; } -static string obj_to_aws_path(rgw::sal::Object* obj) +static string obj_to_aws_path(const rgw_obj& obj) { - string path = obj->get_bucket()->get_name() + "/" + get_key_oid(obj->get_key()); - - - return path; + return obj.bucket.name + "/" + get_key_oid(obj.key); } /* @@ -730,7 +727,7 @@ class RGWRESTStreamGetCRF : public RGWStreamReadHTTPResourceCRF { RGWDataSyncCtx *sc; RGWRESTConn *conn; - rgw::sal::Object* src_obj; + const rgw_obj& src_obj; RGWRESTConn::get_obj_params req_params; rgw_sync_aws_src_obj_properties src_properties; @@ -740,9 +737,9 @@ public: RGWCoroutine *_caller, RGWDataSyncCtx *_sc, RGWRESTConn *_conn, - rgw::sal::Object* _src_obj, + const rgw_obj& _src_obj, const rgw_sync_aws_src_obj_properties& _src_properties) : RGWStreamReadHTTPResourceCRF(_cct, _env, _caller, - _sc->env->http_manager, _src_obj->get_key()), + _sc->env->http_manager, _src_obj.key), sc(_sc), conn(_conn), src_obj(_src_obj), src_properties(_src_properties) { } @@ -809,7 +806,7 @@ class RGWAWSStreamPutCRF : public RGWStreamWriteHTTPResourceCRF RGWDataSyncCtx *sc; rgw_sync_aws_src_obj_properties src_properties; std::shared_ptr target; - rgw::sal::Object* dest_obj; + const rgw_obj& dest_obj; string etag; public: RGWAWSStreamPutCRF(CephContext *_cct, @@ -818,7 +815,7 @@ public: RGWDataSyncCtx *_sc, const rgw_sync_aws_src_obj_properties& _src_properties, std::shared_ptr& _target, - rgw::sal::Object* _dest_obj) : RGWStreamWriteHTTPResourceCRF(_cct, _env, _caller, _sc->env->http_manager), + const rgw_obj& _dest_obj) : RGWStreamWriteHTTPResourceCRF(_cct, _env, _caller, _sc->env->http_manager), sc(_sc), src_properties(_src_properties), target(_target), dest_obj(_dest_obj) { } @@ -1007,8 +1004,8 @@ class RGWAWSStreamObjToCloudPlainCR : public RGWCoroutine { RGWDataSyncCtx *sc; RGWRESTConn *source_conn; std::shared_ptr target; - rgw::sal::Object* src_obj; - rgw::sal::Object* dest_obj; + const rgw_obj& src_obj; + const rgw_obj& dest_obj; rgw_sync_aws_src_obj_properties src_properties; @@ -1018,10 +1015,10 @@ class RGWAWSStreamObjToCloudPlainCR : public RGWCoroutine { public: RGWAWSStreamObjToCloudPlainCR(RGWDataSyncCtx *_sc, RGWRESTConn *_source_conn, - rgw::sal::Object* _src_obj, + const rgw_obj& _src_obj, const rgw_sync_aws_src_obj_properties& _src_properties, std::shared_ptr _target, - rgw::sal::Object* _dest_obj) : RGWCoroutine(_sc->cct), + const rgw_obj& _dest_obj) : RGWCoroutine(_sc->cct), sc(_sc), source_conn(_source_conn), target(_target), @@ -1056,8 +1053,8 @@ class RGWAWSStreamObjToCloudMultipartPartCR : public RGWCoroutine { RGWDataSyncCtx *sc; RGWRESTConn *source_conn; std::shared_ptr target; - rgw::sal::Object* src_obj; - rgw::sal::Object* dest_obj; + const rgw_obj& src_obj; + const rgw_obj& dest_obj; rgw_sync_aws_src_obj_properties src_properties; @@ -1073,9 +1070,9 @@ class RGWAWSStreamObjToCloudMultipartPartCR : public RGWCoroutine { public: RGWAWSStreamObjToCloudMultipartPartCR(RGWDataSyncCtx *_sc, RGWRESTConn *_source_conn, - rgw::sal::Object* _src_obj, + const rgw_obj& _src_obj, std::shared_ptr& _target, - rgw::sal::Object* _dest_obj, + const rgw_obj& _dest_obj, const rgw_sync_aws_src_obj_properties& _src_properties, const string& _upload_id, const rgw_sync_aws_multipart_part_info& _part_info, @@ -1125,14 +1122,14 @@ public: class RGWAWSAbortMultipartCR : public RGWCoroutine { RGWDataSyncCtx *sc; RGWRESTConn *dest_conn; - rgw::sal::Object* dest_obj; + const rgw_obj& dest_obj; string upload_id; public: RGWAWSAbortMultipartCR(RGWDataSyncCtx *_sc, RGWRESTConn *_dest_conn, - rgw::sal::Object* _dest_obj, + const rgw_obj& _dest_obj, const string& _upload_id) : RGWCoroutine(_sc->cct), sc(_sc), dest_conn(_dest_conn), @@ -1164,7 +1161,7 @@ public: class RGWAWSInitMultipartCR : public RGWCoroutine { RGWDataSyncCtx *sc; RGWRESTConn *dest_conn; - rgw::sal::Object* dest_obj; + const rgw_obj& dest_obj; uint64_t obj_size; map attrs; @@ -1188,7 +1185,7 @@ class RGWAWSInitMultipartCR : public RGWCoroutine { public: RGWAWSInitMultipartCR(RGWDataSyncCtx *_sc, RGWRESTConn *_dest_conn, - rgw::sal::Object* _dest_obj, + const rgw_obj& _dest_obj, uint64_t _obj_size, const map& _attrs, string *_upload_id) : RGWCoroutine(_sc->cct), @@ -1254,7 +1251,7 @@ public: class RGWAWSCompleteMultipartCR : public RGWCoroutine { RGWDataSyncCtx *sc; RGWRESTConn *dest_conn; - rgw::sal::Object* dest_obj; + const rgw_obj& dest_obj; bufferlist out_bl; @@ -1292,7 +1289,7 @@ class RGWAWSCompleteMultipartCR : public RGWCoroutine { public: RGWAWSCompleteMultipartCR(RGWDataSyncCtx *_sc, RGWRESTConn *_dest_conn, - rgw::sal::Object* _dest_obj, + const rgw_obj& _dest_obj, string _upload_id, const map& _parts) : RGWCoroutine(_sc->cct), sc(_sc), @@ -1364,7 +1361,7 @@ public: class RGWAWSStreamAbortMultipartUploadCR : public RGWCoroutine { RGWDataSyncCtx *sc; RGWRESTConn *dest_conn; - rgw::sal::Object* dest_obj; + const rgw_obj& dest_obj; const rgw_raw_obj status_obj; string upload_id; @@ -1373,7 +1370,7 @@ public: RGWAWSStreamAbortMultipartUploadCR(RGWDataSyncCtx *_sc, RGWRESTConn *_dest_conn, - rgw::sal::Object* _dest_obj, + const rgw_obj& _dest_obj, const rgw_raw_obj& _status_obj, const string& _upload_id) : RGWCoroutine(_sc->cct), sc(_sc), dest_conn(_dest_conn), @@ -1406,8 +1403,8 @@ class RGWAWSStreamObjToCloudMultipartCR : public RGWCoroutine { AWSSyncConfig& conf; RGWRESTConn *source_conn; std::shared_ptr target; - rgw::sal::Object* src_obj; - rgw::sal::Object* dest_obj; + const rgw_obj& src_obj; + const rgw_obj& dest_obj; uint64_t obj_size; string src_etag; @@ -1429,9 +1426,9 @@ public: rgw_bucket_sync_pipe& _sync_pipe, AWSSyncConfig& _conf, RGWRESTConn *_source_conn, - rgw::sal::Object* _src_obj, + const rgw_obj& _src_obj, std::shared_ptr& _target, - rgw::sal::Object* _dest_obj, + const rgw_obj& _dest_obj, uint64_t _obj_size, const rgw_sync_aws_src_obj_properties& _src_properties, const rgw_rest_obj& _rest_obj) : RGWCoroutine(_sc->cct), @@ -1576,8 +1573,6 @@ class RGWAWSHandleRemoteObjCBCR: public RGWStatRemoteObjCBCR { std::shared_ptr target; bufferlist res; unordered_map bucket_created; - string target_bucket_name; - string target_obj_name; rgw_rest_obj rest_obj; int ret{0}; @@ -1594,12 +1589,8 @@ class RGWAWSHandleRemoteObjCBCR: public RGWStatRemoteObjCBCR { } } result; - rgw_bucket target_bucket; - std::unique_ptr bucket; - std::unique_ptr src_obj; - std::unique_ptr dest_bucket; - std::unique_ptr dest_obj; - + rgw_obj src_obj; + rgw_obj dest_obj; public: RGWAWSHandleRemoteObjCBCR(RGWDataSyncCtx *_sc, @@ -1639,15 +1630,15 @@ public: } instance.get_profile(sync_pipe.info.source_bs.bucket, &target); - instance.conf.get_target(target, sync_pipe.dest_bucket_info, key, &target_bucket_name, &target_obj_name); + instance.conf.get_target(target, sync_pipe.dest_bucket_info, key, &dest_obj.bucket.name, &dest_obj.key.name); - if (bucket_created.find(target_bucket_name) == bucket_created.end()){ + if (bucket_created.find(dest_obj.bucket.name) == bucket_created.end()){ yield { - ldpp_dout(dpp, 0) << "AWS: creating bucket " << target_bucket_name << dendl; + ldpp_dout(dpp, 0) << "AWS: creating bucket " << dest_obj.bucket.name << dendl; bufferlist bl; call(new RGWPutRawRESTResourceCR (sc->cct, target->conn.get(), sync_env->http_manager, - target_bucket_name, nullptr, bl, &out_bl)); + dest_obj.bucket.name, nullptr, bl, &out_bl)); } if (retcode < 0 ) { RGWXMLDecoder::XMLParser parser; @@ -1675,19 +1666,14 @@ public: } } - bucket_created[target_bucket_name] = true; + bucket_created[dest_obj.bucket.name] = true; } yield { - bucket.reset(new rgw::sal::RadosBucket(sync_env->driver, src_bucket)); - src_obj.reset(new rgw::sal::RadosObject(sync_env->driver, key, bucket.get())); + src_obj.bucket = src_bucket; + src_obj.key = key; /* init output */ - target_bucket.name = target_bucket_name; /* this is only possible because we only use bucket name for - uri resolution */ - dest_bucket.reset(new rgw::sal::RadosBucket(sync_env->driver, target_bucket)); - dest_obj.reset(new rgw::sal::RadosObject(sync_env->driver, rgw_obj_key(target_obj_name), dest_bucket.get())); - rgw_sync_aws_src_obj_properties src_properties; src_properties.mtime = mtime; src_properties.etag = etag; @@ -1696,10 +1682,10 @@ public: src_properties.versioned_epoch = versioned_epoch; if (size < instance.conf.s3.multipart_sync_threshold) { - call(new RGWAWSStreamObjToCloudPlainCR(sc, source_conn, src_obj.get(), + call(new RGWAWSStreamObjToCloudPlainCR(sc, source_conn, src_obj, src_properties, target, - dest_obj.get())); + dest_obj)); } else { rgw_rest_obj rest_obj; rest_obj.init(key); @@ -1707,8 +1693,8 @@ public: ldpp_dout(dpp, 0) << "ERROR: failed to decode rest obj out of headers=" << headers << ", attrs=" << attrs << dendl; return set_cr_error(-EINVAL); } - call(new RGWAWSStreamObjToCloudMultipartCR(sc, sync_pipe, instance.conf, source_conn, src_obj.get(), - target, dest_obj.get(), size, src_properties, rest_obj)); + call(new RGWAWSStreamObjToCloudMultipartCR(sc, sync_pipe, instance.conf, source_conn, src_obj, + target, dest_obj, size, src_properties, rest_obj)); } } if (retcode < 0) { diff --git a/src/rgw/driver/rados/rgw_tools.cc b/src/rgw/driver/rados/rgw_tools.cc index 22c1b26971c..1c2951c4bcd 100644 --- a/src/rgw/driver/rados/rgw_tools.cc +++ b/src/rgw/driver/rados/rgw_tools.cc @@ -323,7 +323,7 @@ int RGWDataAccess::Object::put(bufferlist& data, string req_id = driver->zone_unique_id(driver->get_new_req_id()); std::unique_ptr processor; - processor = driver->get_atomic_writer(dpp, y, std::move(obj), + processor = driver->get_atomic_writer(dpp, y, obj.get(), owner.get_id(), nullptr, olh_epoch, req_id); diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc index 6aaac0a0951..7ce0beb9622 100644 --- a/src/rgw/rgw_admin.cc +++ b/src/rgw/rgw_admin.cc @@ -7772,7 +7772,8 @@ next: } } if (need_rewrite) { - ret = static_cast(driver)->getRados()->rewrite_obj(obj.get(), dpp(), null_yield); + RGWRados* store = static_cast(driver)->getRados(); + ret = store->rewrite_obj(bucket->get_info(), obj->get_obj(), dpp(), null_yield); if (ret < 0) { cerr << "ERROR: object rewrite returned: " << cpp_strerror(-ret) << std::endl; return -ret; @@ -7976,7 +7977,8 @@ next: if (!need_rewrite) { formatter->dump_string("status", "Skipped"); } else { - r = static_cast(driver)->getRados()->rewrite_obj(obj.get(), dpp(), null_yield); + RGWRados* store = static_cast(driver)->getRados(); + r = store->rewrite_obj(bucket->get_info(), obj->get_obj(), dpp(), null_yield); if (r == 0) { formatter->dump_string("status", "Success"); } else { diff --git a/src/rgw/rgw_file.cc b/src/rgw/rgw_file.cc index 54e913f5a54..ee32170a116 100644 --- a/src/rgw/rgw_file.cc +++ b/src/rgw/rgw_file.cc @@ -1864,7 +1864,7 @@ namespace rgw { version_id = state->object->get_instance(); } } - processor = get_driver()->get_atomic_writer(this, state->yield, state->object->clone(), + processor = get_driver()->get_atomic_writer(this, state->yield, state->object.get(), state->bucket_owner.get_id(), &state->dest_placement, 0, state->req_id); diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc index 10f761d147d..05119a90e33 100644 --- a/src/rgw/rgw_op.cc +++ b/src/rgw/rgw_op.cc @@ -4062,7 +4062,7 @@ void RGWPutObj::execute(optional_yield y) s->dest_placement = *pdest_placement; pdest_placement = &s->dest_placement; ldpp_dout(this, 20) << "dest_placement for part=" << *pdest_placement << dendl; - processor = upload->get_writer(this, s->yield, s->object->clone(), + processor = upload->get_writer(this, s->yield, s->object.get(), s->user->get_id(), pdest_placement, multipart_part_num, multipart_part_str); } else if(append) { @@ -4070,7 +4070,7 @@ void RGWPutObj::execute(optional_yield y) op_ret = -ERR_INVALID_BUCKET_STATE; return; } - processor = driver->get_append_writer(this, s->yield, s->object->clone(), + processor = driver->get_append_writer(this, s->yield, s->object.get(), s->bucket_owner.get_id(), pdest_placement, s->req_id, position, &cur_accounted_size); @@ -4083,7 +4083,7 @@ void RGWPutObj::execute(optional_yield y) version_id = s->object->get_instance(); } } - processor = driver->get_atomic_writer(this, s->yield, s->object->clone(), + processor = driver->get_atomic_writer(this, s->yield, s->object.get(), s->bucket_owner.get_id(), pdest_placement, olh_epoch, s->req_id); } @@ -4490,7 +4490,7 @@ void RGWPostObj::execute(optional_yield y) } std::unique_ptr processor; - processor = driver->get_atomic_writer(this, s->yield, std::move(obj), + processor = driver->get_atomic_writer(this, s->yield, obj.get(), s->bucket_owner.get_id(), &s->dest_placement, 0, s->req_id); op_ret = processor->prepare(s->yield); @@ -7619,7 +7619,7 @@ int RGWBulkUploadOp::handle_file(const std::string_view path, dest_placement.inherit_from(bucket->get_placement_rule()); std::unique_ptr processor; - processor = driver->get_atomic_writer(this, s->yield, std::move(obj), + processor = driver->get_atomic_writer(this, s->yield, obj.get(), bowner.get_id(), &s->dest_placement, 0, s->req_id); op_ret = processor->prepare(s->yield); diff --git a/src/rgw/rgw_orphan.cc b/src/rgw/rgw_orphan.cc index 7322492f1e7..a8b4f5296dd 100644 --- a/src/rgw/rgw_orphan.cc +++ b/src/rgw/rgw_orphan.cc @@ -452,7 +452,7 @@ int RGWOrphanSearch::handle_stat_result(const DoutPrefixProvider *dpp, map(store)); + const rgw_raw_obj& loc = miter.get_location().get_raw_obj(store->getRados()); string s = loc.oid; obj_oids.insert(obj_fingerprint(s)); } @@ -579,9 +579,9 @@ int RGWOrphanSearch::build_linked_oids_for_bucket(const DoutPrefixProvider *dpp, continue; } - std::unique_ptr obj = cur_bucket->get_object(entry.key); + rgw_obj obj(cur_bucket->get_key(), entry.key); - RGWRados::Object op_target(store->getRados(), cur_bucket.get(), obj_ctx, obj.get()); + RGWRados::Object op_target(store->getRados(), cur_bucket->get_info(), obj_ctx, obj); stat_ops.push_back(RGWRados::Object::Stat(&op_target)); RGWRados::Object::Stat& op = stat_ops.back(); @@ -1042,7 +1042,7 @@ int RGWRadosList::handle_stat_result(const DoutPrefixProvider *dpp, RGWObjManifest::obj_iterator miter; for (miter = manifest.obj_begin(dpp); miter != manifest.obj_end(dpp); ++miter) { const rgw_raw_obj& loc = - miter.get_location().get_raw_obj(static_cast(store)); + miter.get_location().get_raw_obj(store->getRados()); string s = loc.oid; obj_oids.insert(s); } @@ -1248,9 +1248,9 @@ int RGWRadosList::process_bucket( [&](const rgw_obj_key& key) -> int { int ret; - std::unique_ptr obj = bucket->get_object(key); - RGWRados::Object op_target(store->getRados(), bucket.get(), - obj_ctx, obj.get()); + rgw_obj obj(bucket_info.bucket, key); + RGWRados::Object op_target(store->getRados(), bucket_info, + obj_ctx, obj); stat_ops.push_back(RGWRados::Object::Stat(&op_target)); RGWRados::Object::Stat& op = stat_ops.back(); @@ -1536,7 +1536,7 @@ int RGWRadosList::do_incomplete_multipart(const DoutPrefixProvider *dpp, obj_it != manifest.obj_end(dpp); ++obj_it) { const rgw_raw_obj& loc = - obj_it.get_location().get_raw_obj(static_cast(store)); + obj_it.get_location().get_raw_obj(store->getRados()); std::cout << loc.oid << std::endl; } // for (auto obj_it } // for (auto& p diff --git a/src/rgw/rgw_rest_client.cc b/src/rgw/rgw_rest_client.cc index 294f3ec4225..b0b8fcc84f3 100644 --- a/src/rgw/rgw_rest_client.cc +++ b/src/rgw/rgw_rest_client.cc @@ -695,22 +695,22 @@ int RGWRESTGenerateHTTPHeaders::sign(const DoutPrefixProvider *dpp, RGWAccessKey return 0; } -void RGWRESTStreamS3PutObj::send_init(rgw::sal::Object* obj) +void RGWRESTStreamS3PutObj::send_init(const rgw_obj& obj) { string resource_str; string resource; string new_url = url; string new_host = host; - const auto& bucket_name = obj->get_bucket()->get_name(); + const auto& bucket_name = obj.bucket.name; if (host_style == VirtualStyle) { - resource_str = obj->get_oid(); + resource_str = obj.get_oid(); new_url = bucket_name + "." + new_url; new_host = bucket_name + "." + new_host; } else { - resource_str = bucket_name + "/" + obj->get_oid(); + resource_str = bucket_name + "/" + obj.get_oid(); } //do not encode slash in object key name @@ -752,7 +752,7 @@ void RGWRESTStreamS3PutObj::send_ready(const DoutPrefixProvider *dpp, RGWAccessK out_cb = new RGWRESTStreamOutCB(this); } -void RGWRESTStreamS3PutObj::put_obj_init(const DoutPrefixProvider *dpp, RGWAccessKey& key, rgw::sal::Object* obj, map& attrs) +void RGWRESTStreamS3PutObj::put_obj_init(const DoutPrefixProvider *dpp, RGWAccessKey& key, const rgw_obj& obj, map& attrs) { send_init(obj); send_ready(dpp, key, attrs); diff --git a/src/rgw/rgw_rest_client.h b/src/rgw/rgw_rest_client.h index c11199fdf27..97cf899fdb5 100644 --- a/src/rgw/rgw_rest_client.h +++ b/src/rgw/rgw_rest_client.h @@ -245,13 +245,13 @@ public: out_cb(NULL), new_info(cct, &new_env), headers_gen(_cct, &new_env, &new_info) {} ~RGWRESTStreamS3PutObj() override; - void send_init(rgw::sal::Object* obj); + void send_init(const rgw_obj& obj); void send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key, std::map& rgw_attrs); void send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key, const std::map& http_attrs, RGWAccessControlPolicy& policy); void send_ready(const DoutPrefixProvider *dpp, RGWAccessKey& key); - void put_obj_init(const DoutPrefixProvider *dpp, RGWAccessKey& key, rgw::sal::Object* obj, std::map& attrs); + void put_obj_init(const DoutPrefixProvider *dpp, RGWAccessKey& key, const rgw_obj& obj, std::map& attrs); RGWGetDataCB *get_out_cb() { return out_cb; } }; diff --git a/src/rgw/rgw_rest_conn.cc b/src/rgw/rgw_rest_conn.cc index 7c3471a3de6..21ddf6b718f 100644 --- a/src/rgw/rgw_rest_conn.cc +++ b/src/rgw/rgw_rest_conn.cc @@ -127,7 +127,7 @@ int RGWRESTConn::forward_iam_request(const DoutPrefixProvider *dpp, const RGWAcc return req.forward_request(dpp, key, info, max_response, inbl, outbl, y, service); } -int RGWRESTConn::put_obj_send_init(rgw::sal::Object* obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req) +int RGWRESTConn::put_obj_send_init(const rgw_obj& obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req) { string url; int ret = get_url(url); @@ -148,7 +148,7 @@ int RGWRESTConn::put_obj_send_init(rgw::sal::Object* obj, const rgw_http_param_p return 0; } -int RGWRESTConn::put_obj_async_init(const DoutPrefixProvider *dpp, const rgw_user& uid, rgw::sal::Object* obj, +int RGWRESTConn::put_obj_async_init(const DoutPrefixProvider *dpp, const rgw_user& uid, const rgw_obj& obj, map& attrs, RGWRESTStreamS3PutObj **req) { @@ -198,7 +198,7 @@ static void set_header(T val, map& headers, const string& header } -int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info *info /* optional */, const rgw::sal::Object* obj, +int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info *info /* optional */, const rgw_obj& obj, const real_time *mod_ptr, const real_time *unmod_ptr, uint32_t mod_zone_id, uint64_t mod_pg_ver, bool prepend_metadata, bool get_op, bool rgwx_stat, @@ -221,7 +221,7 @@ int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req return get_obj(dpp, obj, params, send, req); } -int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw::sal::Object* obj, const get_obj_params& in_params, bool send, RGWRESTStreamRWRequest **req) +int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw_obj& obj, const get_obj_params& in_params, bool send, RGWRESTStreamRWRequest **req) { string url; int ret = get_url(url); @@ -245,9 +245,8 @@ int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw::sal::Object* if (in_params.skip_decrypt) { params.push_back(param_pair_t(RGW_SYS_PARAM_PREFIX "skip-decrypt", "")); } - if (!obj->get_instance().empty()) { - const string& instance = obj->get_instance(); - params.push_back(param_pair_t("versionId", instance)); + if (!obj.key.instance.empty()) { + params.push_back(param_pair_t("versionId", obj.key.instance)); } if (in_params.get_op) { *req = new RGWRESTStreamReadRequest(cct, url, in_params.cb, NULL, ¶ms, api_name, host_style); @@ -287,7 +286,7 @@ int RGWRESTConn::get_obj(const DoutPrefixProvider *dpp, const rgw::sal::Object* set_header(buf, extra_headers, "RANGE"); } - int r = (*req)->send_prepare(dpp, key, extra_headers, obj->get_obj()); + int r = (*req)->send_prepare(dpp, key, extra_headers, obj); if (r < 0) { goto done_err; } diff --git a/src/rgw/rgw_rest_conn.h b/src/rgw/rgw_rest_conn.h index 08ec0cf24ae..bb0d5a8bbf8 100644 --- a/src/rgw/rgw_rest_conn.h +++ b/src/rgw/rgw_rest_conn.h @@ -132,8 +132,8 @@ public: /* async requests */ - int put_obj_send_init(rgw::sal::Object* obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req); - int put_obj_async_init(const DoutPrefixProvider *dpp, const rgw_user& uid, rgw::sal::Object* obj, + int put_obj_send_init(const rgw_obj& obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req); + int put_obj_async_init(const DoutPrefixProvider *dpp, const rgw_user& uid, const rgw_obj& obj, std::map& attrs, RGWRESTStreamS3PutObj **req); int complete_request(RGWRESTStreamS3PutObj *req, std::string& etag, ceph::real_time *mtime, optional_yield y); @@ -164,9 +164,9 @@ public: uint64_t range_end{0}; }; - int get_obj(const DoutPrefixProvider *dpp, const rgw::sal::Object* obj, const get_obj_params& params, bool send, RGWRESTStreamRWRequest **req); + int get_obj(const DoutPrefixProvider *dpp, const rgw_obj& obj, const get_obj_params& params, bool send, RGWRESTStreamRWRequest **req); - int get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info *info /* optional */, const rgw::sal::Object* obj, + int get_obj(const DoutPrefixProvider *dpp, const rgw_user& uid, req_info *info /* optional */, const rgw_obj& obj, const ceph::real_time *mod_ptr, const ceph::real_time *unmod_ptr, uint32_t mod_zone_id, uint64_t mod_pg_ver, bool prepend_metadata, bool get_op, bool rgwx_stat, bool sync_manifest, diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h index 622fd434f70..9d2efccc70a 100644 --- a/src/rgw/rgw_sal.h +++ b/src/rgw/rgw_sal.h @@ -432,7 +432,7 @@ class Driver { /** Get a Writer that appends to an object */ virtual std::unique_ptr get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, @@ -441,7 +441,7 @@ class Driver { /** Get a Writer that atomically writes an entire object */ virtual std::unique_ptr get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, @@ -1225,7 +1225,7 @@ public: /** Get a Writer to write to a part of this upload */ virtual std::unique_ptr get_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, diff --git a/src/rgw/rgw_sal_daos.cc b/src/rgw/rgw_sal_daos.cc index eaa06f5e3d3..88b1173e560 100644 --- a/src/rgw/rgw_sal_daos.cc +++ b/src/rgw/rgw_sal_daos.cc @@ -1502,7 +1502,7 @@ int DaosObject::mark_as_latest(const DoutPrefixProvider* dpp, DaosAtomicWriter::DaosAtomicWriter( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, DaosStore* _store, + rgw::sal::Object* obj, DaosStore* _store, const rgw_user& _owner, const rgw_placement_rule* _ptail_placement_rule, uint64_t _olh_epoch, const std::string& _unique_tag) : StoreWriter(dpp, y), @@ -1511,7 +1511,7 @@ DaosAtomicWriter::DaosAtomicWriter( ptail_placement_rule(_ptail_placement_rule), olh_epoch(_olh_epoch), unique_tag(_unique_tag), - obj(_store, _head_obj->get_key(), _head_obj->get_bucket()) {} + obj(_store, obj->get_key(), obj->get_bucket()) {} int DaosAtomicWriter::prepare(optional_yield y) { ldpp_dout(dpp, 20) << "DEBUG: prepare" << dendl; @@ -2019,13 +2019,13 @@ int DaosMultipartUpload::get_info(const DoutPrefixProvider* dpp, std::unique_ptr DaosMultipartUpload::get_writer( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, const rgw_user& owner, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, uint64_t part_num, const std::string& part_num_str) { ldpp_dout(dpp, 20) << "DaosMultipartUpload::get_writer(): enter part=" << part_num << " head_obj=" << _head_obj << dendl; return std::make_unique( - dpp, y, this, std::move(_head_obj), store, owner, ptail_placement_rule, + dpp, y, this, obj, store, owner, ptail_placement_rule, part_num, part_num_str); } @@ -2163,7 +2163,7 @@ std::unique_ptr DaosBucket::get_multipart_upload( std::unique_ptr DaosStore::get_append_writer( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, const rgw_user& owner, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, const std::string& unique_tag, uint64_t position, uint64_t* cur_accounted_size) { @@ -2173,11 +2173,11 @@ std::unique_ptr DaosStore::get_append_writer( std::unique_ptr DaosStore::get_atomic_writer( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, const rgw_user& owner, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, uint64_t olh_epoch, const std::string& unique_tag) { ldpp_dout(dpp, 20) << "get_atomic_writer" << dendl; - return std::make_unique(dpp, y, std::move(_head_obj), this, + return std::make_unique(dpp, y, obj, this, owner, ptail_placement_rule, olh_epoch, unique_tag); } diff --git a/src/rgw/rgw_sal_daos.h b/src/rgw/rgw_sal_daos.h index edff89b6cfa..3403b30a488 100644 --- a/src/rgw/rgw_sal_daos.h +++ b/src/rgw/rgw_sal_daos.h @@ -741,7 +741,7 @@ class DaosAtomicWriter : public StoreWriter { public: DaosAtomicWriter(const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, DaosStore* _store, const rgw_user& _owner, const rgw_placement_rule* _ptail_placement_rule, uint64_t _olh_epoch, const std::string& _unique_tag); @@ -780,7 +780,7 @@ class DaosMultipartWriter : public StoreWriter { public: DaosMultipartWriter(const DoutPrefixProvider* dpp, optional_yield y, MultipartUpload* _upload, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, DaosStore* _store, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, uint64_t _part_num, const std::string& part_num_str) @@ -874,7 +874,7 @@ class DaosMultipartUpload : public StoreMultipartUpload { rgw::sal::Attrs* attrs = nullptr) override; virtual std::unique_ptr get_writer( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, const rgw_user& owner, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, uint64_t part_num, const std::string& part_num_str) override; const std::string& get_bucket_name() { return bucket->get_name(); } @@ -1027,13 +1027,13 @@ class DaosStore : public StoreDriver { std::vector>& providers) override; virtual std::unique_ptr get_append_writer( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, const rgw_user& owner, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, const std::string& unique_tag, uint64_t position, uint64_t* cur_accounted_size) override; virtual std::unique_ptr get_atomic_writer( const DoutPrefixProvider* dpp, optional_yield y, - std::unique_ptr _head_obj, const rgw_user& owner, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule* ptail_placement_rule, uint64_t olh_epoch, const std::string& unique_tag) override; virtual const std::string& get_compression_type( diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc index ba7da28ca5a..d9f44dbaf71 100644 --- a/src/rgw/rgw_sal_dbstore.cc +++ b/src/rgw/rgw_sal_dbstore.cc @@ -1227,21 +1227,20 @@ namespace rgw::sal { std::unique_ptr DBMultipartUpload::get_writer( const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, const std::string& part_num_str) { - return std::make_unique(dpp, y, this, - std::move(_head_obj), store, owner, + return std::make_unique(dpp, y, this, obj, store, owner, ptail_placement_rule, part_num, part_num_str); } DBMultipartWriter::DBMultipartWriter(const DoutPrefixProvider *dpp, optional_yield y, MultipartUpload* upload, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, DBStore* _driver, const rgw_user& _owner, const rgw_placement_rule *_ptail_placement_rule, @@ -1250,7 +1249,7 @@ namespace rgw::sal { store(_driver), owner(_owner), ptail_placement_rule(_ptail_placement_rule), - head_obj(std::move(_head_obj)), + head_obj(obj), upload_id(upload->get_upload_id()), part_num(_part_num), oid(head_obj->get_name() + "." + upload_id + @@ -1390,7 +1389,7 @@ namespace rgw::sal { DBAtomicWriter::DBAtomicWriter(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* _obj, DBStore* _driver, const rgw_user& _owner, const rgw_placement_rule *_ptail_placement_rule, @@ -1402,7 +1401,7 @@ namespace rgw::sal { ptail_placement_rule(_ptail_placement_rule), olh_epoch(_olh_epoch), unique_tag(_unique_tag), - obj(_driver, _head_obj->get_key(), _head_obj->get_bucket()), + obj(_driver, _obj->get_key(), _obj->get_bucket()), op_target(_driver->getDB(), obj.get_bucket()->get_info(), obj.get_obj()), parent_op(&op_target) {} @@ -1579,7 +1578,7 @@ namespace rgw::sal { std::unique_ptr DBStore::get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, @@ -1590,13 +1589,12 @@ namespace rgw::sal { std::unique_ptr DBStore::get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, const std::string& unique_tag) { - return std::make_unique(dpp, y, - std::move(_head_obj), this, owner, + return std::make_unique(dpp, y, obj, this, owner, ptail_placement_rule, olh_epoch, unique_tag); } diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h index 788932ae50a..b2dd3d71e93 100644 --- a/src/rgw/rgw_sal_dbstore.h +++ b/src/rgw/rgw_sal_dbstore.h @@ -515,7 +515,7 @@ protected: virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override; virtual std::unique_ptr get_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, @@ -680,7 +680,7 @@ protected: public: DBAtomicWriter(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, DBStore* _store, const rgw_user& _owner, const rgw_placement_rule *_ptail_placement_rule, @@ -711,7 +711,7 @@ protected: const rgw_user& owner; const rgw_placement_rule *ptail_placement_rule; uint64_t olh_epoch; - std::unique_ptr head_obj; + rgw::sal::Object* head_obj; std::string upload_id; int part_num; std::string oid; /* object->name() + "." + "upload_id" + "." + part_num */ @@ -729,7 +729,7 @@ protected: public: DBMultipartWriter(const DoutPrefixProvider *dpp, optional_yield y, MultipartUpload* upload, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, DBStore* _store, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, @@ -880,7 +880,7 @@ public: std::vector>& providers) override; virtual std::unique_ptr get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, @@ -888,7 +888,7 @@ public: uint64_t *cur_accounted_size) override; virtual std::unique_ptr get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, diff --git a/src/rgw/rgw_sal_filter.cc b/src/rgw/rgw_sal_filter.cc index c2b3c6d256e..2a48cec9c03 100644 --- a/src/rgw/rgw_sal_filter.cc +++ b/src/rgw/rgw_sal_filter.cc @@ -488,38 +488,34 @@ int FilterDriver::get_oidc_providers(const DoutPrefixProvider *dpp, std::unique_ptr FilterDriver::get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, uint64_t position, uint64_t *cur_accounted_size) { - std::unique_ptr no = nextObject(_head_obj.get())->clone(); - - std::unique_ptr writer = next->get_append_writer(dpp, y, std::move(no), + std::unique_ptr writer = next->get_append_writer(dpp, y, nextObject(obj), owner, ptail_placement_rule, unique_tag, position, cur_accounted_size); - return std::make_unique(std::move(writer), std::move(_head_obj)); + return std::make_unique(std::move(writer), obj); } std::unique_ptr FilterDriver::get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, const std::string& unique_tag) { - std::unique_ptr no = nextObject(_head_obj.get())->clone(); - - std::unique_ptr writer = next->get_atomic_writer(dpp, y, std::move(no), + std::unique_ptr writer = next->get_atomic_writer(dpp, y, nextObject(obj), owner, ptail_placement_rule, olh_epoch, unique_tag); - return std::make_unique(std::move(writer), std::move(_head_obj)); + return std::make_unique(std::move(writer), obj); } const std::string& FilterDriver::get_compression_type(const rgw_placement_rule& rule) @@ -1170,19 +1166,17 @@ int FilterMultipartUpload::get_info(const DoutPrefixProvider *dpp, std::unique_ptr FilterMultipartUpload::get_writer( const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, const std::string& part_num_str) { - std::unique_ptr no = nextObject(_head_obj.get())->clone(); - std::unique_ptr writer; - writer = next->get_writer(dpp, y, std::move(no), owner, + writer = next->get_writer(dpp, y, nextObject(obj), owner, ptail_placement_rule, part_num, part_num_str); - return std::make_unique(std::move(writer), std::move(_head_obj)); + return std::make_unique(std::move(writer), obj); } int FilterMPSerializer::try_lock(const DoutPrefixProvider *dpp, utime_t dur, diff --git a/src/rgw/rgw_sal_filter.h b/src/rgw/rgw_sal_filter.h index 774677a6bbb..b1a4ecbd923 100644 --- a/src/rgw/rgw_sal_filter.h +++ b/src/rgw/rgw_sal_filter.h @@ -297,7 +297,7 @@ public: providers) override; virtual std::unique_ptr get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, @@ -306,7 +306,7 @@ public: uint64_t *cur_accounted_size) override; virtual std::unique_ptr get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, @@ -769,7 +769,7 @@ public: virtual std::unique_ptr get_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, @@ -881,10 +881,10 @@ public: class FilterWriter : public Writer { protected: std::unique_ptr next; - std::unique_ptr head_obj; + Object* obj; public: - FilterWriter(std::unique_ptr _next, std::unique_ptr _head_obj) : - next(std::move(_next)), head_obj(std::move(_head_obj)) {} + FilterWriter(std::unique_ptr _next, Object* _obj) : + next(std::move(_next)), obj(_obj) {} virtual ~FilterWriter() = default; virtual int prepare(optional_yield y) { return next->prepare(y); } diff --git a/src/rgw/rgw_sal_motr.cc b/src/rgw/rgw_sal_motr.cc index 728c6d2b07f..cc7869627a6 100644 --- a/src/rgw/rgw_sal_motr.cc +++ b/src/rgw/rgw_sal_motr.cc @@ -1606,7 +1606,7 @@ int MotrObject::swift_versioning_copy(const DoutPrefixProvider* dpp, MotrAtomicWriter::MotrAtomicWriter(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, MotrStore* _store, const rgw_user& _owner, const rgw_placement_rule *_ptail_placement_rule, @@ -1618,8 +1618,8 @@ MotrAtomicWriter::MotrAtomicWriter(const DoutPrefixProvider *dpp, ptail_placement_rule(_ptail_placement_rule), olh_epoch(_olh_epoch), unique_tag(_unique_tag), - obj(_store, _head_obj->get_key(), _head_obj->get_bucket()), - old_obj(_store, _head_obj->get_key(), _head_obj->get_bucket()) {} + obj(_store, obj->get_key(), obj->get_bucket()), + old_obj(_store, obj->get_key(), obj->get_bucket()) {} static const unsigned MAX_BUFVEC_NR = 256; @@ -2984,14 +2984,14 @@ int MotrMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield std::unique_ptr MotrMultipartUpload::get_writer( const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, const std::string& part_num_str) { return std::make_unique(dpp, y, this, - std::move(_head_obj), store, owner, + obj, store, owner, ptail_placement_rule, part_num, part_num_str); } @@ -3128,7 +3128,7 @@ std::unique_ptr MotrBucket::get_multipart_upload(const std::str std::unique_ptr MotrStore::get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, @@ -3139,13 +3139,13 @@ std::unique_ptr MotrStore::get_append_writer(const DoutPrefixProvider *d std::unique_ptr MotrStore::get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, const std::string& unique_tag) { return std::make_unique(dpp, y, - std::move(_head_obj), this, owner, + obj, this, owner, ptail_placement_rule, olh_epoch, unique_tag); } diff --git a/src/rgw/rgw_sal_motr.h b/src/rgw/rgw_sal_motr.h index bc276b892c3..91f67a20b63 100644 --- a/src/rgw/rgw_sal_motr.h +++ b/src/rgw/rgw_sal_motr.h @@ -792,7 +792,7 @@ class MotrAtomicWriter : public StoreWriter { public: MotrAtomicWriter(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, MotrStore* _store, const rgw_user& _owner, const rgw_placement_rule *_ptail_placement_rule, @@ -827,7 +827,7 @@ protected: rgw::sal::MotrStore* store; // Head object. - std::unique_ptr head_obj; + rgw::sal::Object* head_obj; // Part parameters. const uint64_t part_num; @@ -838,12 +838,12 @@ protected: public: MotrMultipartWriter(const DoutPrefixProvider *dpp, optional_yield y, MultipartUpload* upload, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, MotrStore* _store, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t _part_num, const std::string& part_num_str) : - StoreWriter(dpp, y), store(_store), head_obj(std::move(_head_obj)), + StoreWriter(dpp, y), store(_store), head_obj(obj), part_num(_part_num), part_num_str(part_num_str) { } @@ -951,7 +951,7 @@ public: virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override; virtual std::unique_ptr get_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t part_num, @@ -1072,7 +1072,7 @@ class MotrStore : public StoreDriver { std::vector>& providers) override; virtual std::unique_ptr get_append_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, const std::string& unique_tag, @@ -1080,7 +1080,7 @@ class MotrStore : public StoreDriver { uint64_t *cur_accounted_size) override; virtual std::unique_ptr get_atomic_writer(const DoutPrefixProvider *dpp, optional_yield y, - std::unique_ptr _head_obj, + rgw::sal::Object* obj, const rgw_user& owner, const rgw_placement_rule *ptail_placement_rule, uint64_t olh_epoch, -- 2.39.5