Simply use the RADOS handle and `rgw_rados_ref` directly.
Signed-off-by: Adam C. Emerson <aemerson@redhat.com>
set_description() << "remove dest=" << oid;
}
+RGWRadosRemoveOidCR::RGWRadosRemoveOidCR(rgw::sal::RadosStore* store,
+ rgw_rados_ref&& obj,
+ RGWObjVersionTracker* objv_tracker)
+ : RGWSimpleCoroutine(store->ctx()),
+ ioctx(std::move(obj.ioctx)),
+ oid(std::move(obj.obj.oid)),
+ objv_tracker(objv_tracker)
+{
+ set_description() << "remove dest=" << oid;
+}
+
int RGWRadosRemoveOidCR::send_request(const DoutPrefixProvider *dpp)
{
librados::ObjectWriteOperation op;
RGWSI_RADOS::Obj&& obj,
RGWObjVersionTracker* objv_tracker = nullptr);
+ RGWRadosRemoveOidCR(rgw::sal::RadosStore* store,
+ rgw_rados_ref&& obj,
+ RGWObjVersionTracker* objv_tracker = nullptr);
+
int send_request(const DoutPrefixProvider *dpp) override;
int request_complete() override;
};
int RGWRados::init_svc(bool raw, const DoutPrefixProvider *dpp)
{
if (raw) {
- return svc.init_raw(cct, use_cache, null_yield, dpp);
+ return svc.init_raw(cct, use_cache, get_rados_handle(), null_yield, dpp);
}
- return svc.init(cct, use_cache, run_sync_thread, null_yield, dpp);
+ return svc.init(cct, use_cache, run_sync_thread, get_rados_handle(),
+ null_yield, dpp);
}
int RGWRados::init_ctl(const DoutPrefixProvider *dpp)
*/
int RGWRados::init_begin(const DoutPrefixProvider *dpp)
{
- int ret = init_svc(false, dpp);
+ int ret = init_rados();
+ if (ret < 0) {
+ ldpp_dout(dpp, 0) << "ERROR: failed to init rados (ret=" << cpp_strerror(-ret) << ")" << dendl;
+ return ret;
+ }
+
+ ret = init_svc(false, dpp);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to init services (ret=" << cpp_strerror(-ret) << ")" << dendl;
return ret;
host_id = svc.zone_utils->gen_host_id();
- return init_rados();
+ return 0;
}
/**
ldpp_dout(dpp, 0) << "ERROR: open_bucket_index_shard() returned ret=" << ret << dendl;
return ret;
}
- ldpp_dout(dpp, 20) << " bucket index object: " << bucket_obj.get_raw_obj() << dendl;
+ ldpp_dout(dpp, 20) << " bucket index object: " << bucket_obj << dendl;
return 0;
}
int RGWRados::delete_bucket(RGWBucketInfo& bucket_info, RGWObjVersionTracker& objv_tracker, optional_yield y, const DoutPrefixProvider *dpp, bool check_empty)
{
const rgw_bucket& bucket = bucket_info.bucket;
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, std::nullopt, bucket_info.layout.current_index, &index_pool, &bucket_objs, nullptr);
if (r < 0)
}
/* remove bucket index objects asynchronously by best effort */
- (void) CLSRGWIssueBucketIndexClean(index_pool.ioctx(),
+ (void) CLSRGWIssueBucketIndexClean(index_pool,
bucket_objs,
cct->_conf->rgw_bucket_index_max_aio)();
}
map<RGWObjCategory, RGWStorageStats> *existing_stats,
map<RGWObjCategory, RGWStorageStats> *calculated_stats)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
// key - bucket index object id
// value - bucket index check OP returned result with the given bucket index object (shard)
bucket_objs_ret.emplace(iter.first, rgw_cls_check_index_ret());
}
- ret = CLSRGWIssueBucketCheck(index_pool.ioctx(), oids, bucket_objs_ret, cct->_conf->rgw_bucket_index_max_aio)();
+ ret = CLSRGWIssueBucketCheck(index_pool, oids, bucket_objs_ret, cct->_conf->rgw_bucket_index_max_aio)();
if (ret < 0) {
return ret;
}
int RGWRados::bucket_rebuild_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, std::nullopt, bucket_info.layout.current_index, &index_pool, &bucket_objs, nullptr);
return r;
}
- return CLSRGWIssueBucketRebuild(index_pool.ioctx(), bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
+ return CLSRGWIssueBucketRebuild(index_pool, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
}
static int resync_encrypted_multipart(const DoutPrefixProvider* dpp,
int RGWRados::bucket_set_reshard(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const cls_rgw_bucket_instance_entry& entry)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, std::nullopt, bucket_info.layout.current_index, &index_pool, &bucket_objs, nullptr);
return r;
}
- r = CLSRGWIssueSetBucketResharding(index_pool.ioctx(), bucket_objs, entry, cct->_conf->rgw_bucket_index_max_aio)();
+ r = CLSRGWIssueSetBucketResharding(index_pool, bucket_objs, entry, cct->_conf->rgw_bucket_index_max_aio)();
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: " << __func__ <<
": unable to issue set bucket resharding, r=" << r << " (" <<
constexpr int num_retries = 10;
for (int i = 1; i <= num_retries; i++) { // nb: 1-based for loop
- auto& ref = bs->bucket_obj.get_ref();
- ret = cls_rgw_get_bucket_resharding(ref.pool.ioctx(), ref.obj.oid, &entry);
+ auto& ref = bs->bucket_obj;
+ ret = cls_rgw_get_bucket_resharding(ref.ioctx, ref.obj.oid, &entry);
if (ret == -ENOENT) {
ret = fetch_new_bucket_info("get_bucket_resharding_failed");
if (ret < 0) {
r = guard_reshard(dpp, &bs, obj_instance, bucket_info,
[&](BucketShard *bs) -> int {
cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), obj_instance.key.instance);
- auto& ref = bs->bucket_obj.get_ref();
+ auto& ref = bs->bucket_obj;
librados::ObjectWriteOperation op;
op.assert_exists(); // bucket index shard must exist
cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
delete_marker, op_tag, meta, olh_epoch,
unmod_since, high_precision_time,
svc.zone->need_to_log_data(), zones_trace);
- return rgw_rados_operate(dpp, ref.pool.ioctx(), ref.obj.oid, &op, y);
+ return rgw_rados_operate(dpp, ref.ioctx, ref.obj.oid, &op, y);
}, y);
if (r < 0) {
ldpp_dout(dpp, 20) << "rgw_rados_operate() after cls_rgw_bucket_link_olh() returned r=" << r << dendl;
cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), obj_instance.key.instance);
r = guard_reshard(dpp, &bs, obj_instance, bucket_info,
[&](BucketShard *bs) -> int {
- auto& ref = bs->bucket_obj.get_ref();
+ auto& ref = bs->bucket_obj;
librados::ObjectWriteOperation op;
op.assert_exists(); // bucket index shard must exist
cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
cls_rgw_bucket_unlink_instance(op, key, op_tag,
olh_tag, olh_epoch, svc.zone->need_to_log_data(), zones_trace);
- return rgw_rados_operate(dpp, ref.pool.ioctx(), ref.obj.oid, &op, y);
+ return rgw_rados_operate(dpp, ref.ioctx, ref.obj.oid, &op, y);
}, y);
if (r < 0) {
ldpp_dout(dpp, 20) << "rgw_rados_operate() after cls_rgw_bucket_link_instance() returned r=" << r << dendl;
cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), string());
- auto& shard_ref = bs.bucket_obj.get_ref();
+ auto& shard_ref = bs.bucket_obj;
ObjectReadOperation op;
rgw_cls_read_olh_log_ret log_ret;
int op_ret = 0;
- cls_rgw_get_olh_log(op, key, ver_marker, olh_tag, log_ret, op_ret);
+ cls_rgw_get_olh_log(op, key, ver_marker, olh_tag, log_ret, op_ret);
bufferlist outbl;
- r = rgw_rados_operate(dpp, shard_ref.pool.ioctx(), shard_ref.obj.oid, &op, &outbl, y);
+ r = rgw_rados_operate(dpp, shard_ref.ioctx, shard_ref.obj.oid, &op, &outbl, y);
if (r < 0) {
return r;
}
[&](BucketShard *pbs) -> int {
ObjectWriteOperation op;
op.assert_exists(); // bucket index shard must exist
- auto& ref = pbs->bucket_obj.get_ref();
+ auto& ref = bs.bucket_obj;
cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
cls_rgw_clear_olh(op, key, olh_tag);
- return rgw_rados_operate(dpp, ref.pool.ioctx(), ref.obj.oid, &op, y);
+ return rgw_rados_operate(dpp, ref.ioctx, ref.obj.oid, &op, y);
}, y);
if (ret < 0) {
ldpp_dout(dpp, 5) << "rgw_rados_operate() after cls_rgw_clear_olh() returned ret=" << ret << dendl;
cls_rgw_obj_key key(obj.key.get_index_key_name(), obj.key.instance);
- auto& ref = bs.bucket_obj.get_ref();
-
- return cls_rgw_bi_get(ref.pool.ioctx(), ref.obj.oid, index_type, key, entry);
+ auto& ref = bs.bucket_obj;
+
+ return cls_rgw_bi_get(ref.ioctx, ref.obj.oid, index_type, key, entry);
}
void RGWRados::bi_put(ObjectWriteOperation& op, BucketShard& bs, rgw_cls_bi_entry& entry, optional_yield y)
{
- auto& ref = bs.bucket_obj.get_ref();
+ auto& ref = bs.bucket_obj;
cls_rgw_bi_put(op, ref.obj.oid, entry);
}
int RGWRados::bi_put(BucketShard& bs, rgw_cls_bi_entry& entry, optional_yield y)
{
- auto& ref = bs.bucket_obj.get_ref();
- int ret = cls_rgw_bi_put(ref.pool.ioctx(), ref.obj.oid, entry);
+ auto& ref = bs.bucket_obj;
+ int ret = cls_rgw_bi_put(ref.ioctx, ref.obj.oid, entry);
if (ret < 0)
return ret;
return ret;
}
- auto& ref = bs.bucket_obj.get_ref();
- ret = cls_rgw_bi_list(ref.pool.ioctx(), ref.obj.oid, obj_name_filter, marker, max, entries, is_truncated);
+ auto& ref = bs.bucket_obj;
+ ret = cls_rgw_bi_list(ref.ioctx, ref.obj.oid, obj_name_filter, marker, max, entries, is_truncated);
if (ret == -ENOENT) {
*is_truncated = false;
}
int RGWRados::bi_list(BucketShard& bs, const string& obj_name_filter, const string& marker, uint32_t max,
list<rgw_cls_bi_entry> *entries, bool *is_truncated, optional_yield y)
{
- auto& ref = bs.bucket_obj.get_ref();
- int ret = cls_rgw_bi_list(ref.pool.ioctx(), ref.obj.oid, obj_name_filter, marker, max, entries, is_truncated);
+ auto& ref = bs.bucket_obj;
+ int ret = cls_rgw_bi_list(ref.ioctx, ref.obj.oid, obj_name_filter, marker, max, entries, is_truncated);
if (ret < 0)
return ret;
int RGWRados::bi_remove(const DoutPrefixProvider *dpp, BucketShard& bs)
{
- auto& ref = bs.bucket_obj.get_ref();
- int ret = ref.pool.ioctx().remove(ref.obj.oid);
+ auto& ref = bs.bucket_obj;
+ int ret = ref.ioctx.remove(ref.obj.oid);
if (ret == -ENOENT) {
ret = 0;
}
int RGWRados::cls_obj_set_bucket_tag_timeout(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, uint64_t timeout)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, std::nullopt, bucket_info.layout.current_index, &index_pool, &bucket_objs, nullptr);
if (r < 0)
return r;
- return CLSRGWIssueSetTagTimeout(index_pool.ioctx(), bucket_objs, cct->_conf->rgw_bucket_index_max_aio, timeout)();
+ return CLSRGWIssueSetTagTimeout(index_pool, bucket_objs, cct->_conf->rgw_bucket_index_max_aio, timeout)();
}
m.clear();
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
// key - oid (for different shards if there is any)
// value - list result for the corresponding oid (shard), it is filled by
// the AIO callback
" shard(s) for " << num_entries_per_shard << " entries to get " <<
num_entries << " total entries" << dendl;
- auto& ioctx = index_pool.ioctx();
+ auto& ioctx = index_pool;
std::map<int, rgw_cls_list_ret> shard_list_results;
cls_rgw_obj_key start_after_key(start_after.name, start_after.instance);
r = CLSRGWIssueBucketList(ioctx, start_after_key, prefix, delimiter,
static MultipartMetaFilter multipart_meta_filter;
*is_truncated = false;
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
std::map<int, std::string> oids;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, shard_id, idx_layout, &index_pool, &oids, nullptr);
return r;
}
- auto& ioctx = index_pool.ioctx();
+ auto& ioctx = index_pool;
const uint32_t num_shards = oids.size();
}
const uint32_t num_shards = current_index.layout.normal.num_shards;
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
std::map<int, std::string> index_oids;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, std::nullopt,
bucket_info.layout.current_index,
", shard=" << shard << ", oid=" << oid << ", num_keys=" <<
removals.second.size() << dendl_bitx;
- r = index_pool.ioctx().omap_rm_keys(oid, removals.second);
+ r = index_pool.omap_rm_keys(oid, removals.second);
if (r < 0) {
ldout_bitx(bitx, dpp, 0) << "ERROR: " << __func__ <<
": omap_rm_keys returned ret=" << r <<
int RGWRados::cls_bucket_head(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout, int shard_id, vector<rgw_bucket_dir_header>& headers, map<int, string> *bucket_instance_ids)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> oids;
map<int, struct rgw_cls_list_ret> list_results;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, shard_id, idx_layout, &index_pool, &oids, bucket_instance_ids);
return r;
}
- r = CLSRGWIssueGetDirHeader(index_pool.ioctx(), oids, list_results, cct->_conf->rgw_bucket_index_max_aio)();
+ r = CLSRGWIssueGetDirHeader(index_pool, oids, list_results, cct->_conf->rgw_bucket_index_max_aio)();
if (r < 0) {
ldpp_dout(dpp, 20) << "cls_bucket_head: CLSRGWIssueGetDirHeader() returned "
<< r << dendl;
const rgw::bucket_index_layout_generation& idx_layout, int shard_id,
boost::intrusive_ptr<RGWGetDirHeader_CB> cb, int *num_aio)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
int r = svc.bi_rados->open_bucket_index(dpp, bucket_info, shard_id, idx_layout, &index_pool, &bucket_objs, nullptr);
if (r < 0)
return r;
for (auto& pair : bucket_objs) {
- r = cls_rgw_get_dir_header_async(index_pool.ioctx(), pair.second, cb);
+ r = cls_rgw_get_dir_header_async(index_pool, pair.second, cb);
if (r < 0) {
return r;
}
RGWRados *store;
rgw_bucket bucket;
int shard_id;
- RGWSI_RADOS::Obj bucket_obj;
+ rgw_rados_ref bucket_obj;
explicit BucketShard(RGWRados *_store) : store(_store), shard_id(-1) {}
int init(const rgw_bucket& _bucket, const rgw_obj& obj,
friend std::ostream& operator<<(std::ostream& out, const BucketShard& bs) {
out << "BucketShard:{ bucket=" << bs.bucket <<
", shard_id=" << bs.shard_id <<
- ", bucket_ojb=" << bs.bucket_obj << "}";
+ ", bucket_obj=" << bs.bucket_obj << "}";
return out;
}
};
bool have_cache,
bool raw,
bool run_sync,
+ librados::Rados* radoshandle,
optional_yield y,
const DoutPrefixProvider *dpp)
{
vector<RGWSI_MetaBackend *> meta_bes{meta_be_sobj.get(), meta_be_otp.get()};
finisher->init();
- bi_rados->init(zone.get(), rados.get(), bilog_rados.get(), datalog_rados.get());
+ bi_rados->init(zone.get(), radoshandle, bilog_rados.get(), datalog_rados.get());
bilog_rados->init(bi_rados.get());
bucket_sobj->init(zone.get(), sysobj.get(), sysobj_cache.get(),
bi_rados.get(), meta.get(), meta_be_sobj.get(),
}
-
-int RGWServices::do_init(CephContext *_cct, bool have_cache, bool raw, bool run_sync, optional_yield y, const DoutPrefixProvider *dpp)
+int RGWServices::do_init(CephContext *_cct, bool have_cache, bool raw,
+ bool run_sync, librados::Rados* radoshandle,
+ optional_yield y, const DoutPrefixProvider *dpp)
{
cct = _cct;
- int r = _svc.init(cct, have_cache, raw, run_sync, y, dpp);
+ int r = _svc.init(cct, have_cache, raw, run_sync, radoshandle, y, dpp);
if (r < 0) {
return r;
}
RGWServices_Def();
~RGWServices_Def();
- int init(CephContext *cct, bool have_cache, bool raw_storage, bool run_sync, optional_yield y, const DoutPrefixProvider *dpp);
+ int init(CephContext *cct, bool have_cache, bool raw_storage, bool run_sync,
+ librados::Rados* radoshandle, optional_yield y,
+ const DoutPrefixProvider *dpp);
void shutdown();
};
RGWSI_User *user{nullptr};
RGWSI_Role_RADOS *role{nullptr};
- int do_init(CephContext *cct, bool have_cache, bool raw_storage, bool run_sync, optional_yield y, const DoutPrefixProvider *dpp);
+ int do_init(CephContext *cct, bool have_cache, bool raw_storage,
+ bool run_sync, librados::Rados* radoshandle, optional_yield y,
+ const DoutPrefixProvider *dpp);
- int init(CephContext *cct, bool have_cache, bool run_sync, optional_yield y, const DoutPrefixProvider *dpp) {
- return do_init(cct, have_cache, false, run_sync, y, dpp);
+ int init(CephContext *cct, bool have_cache, bool run_sync,
+ librados::Rados* radoshandle, optional_yield y,
+ const DoutPrefixProvider *dpp) {
+ return do_init(cct, have_cache, false, run_sync, radoshandle, y, dpp);
}
- int init_raw(CephContext *cct, bool have_cache, optional_yield y, const DoutPrefixProvider *dpp) {
- return do_init(cct, have_cache, true, false, y, dpp);
+ int init_raw(CephContext *cct, bool have_cache, librados::Rados* radoshandle,
+ optional_yield y, const DoutPrefixProvider *dpp) {
+ return do_init(cct, have_cache, true, false, radoshandle, y, dpp);
}
void shutdown() {
_svc.shutdown();
struct obj_version;
-struct rgw_rados_ref {
- librados::IoCtx ioctx;
- rgw_raw_obj obj;
-};
-int rgw_get_rados_ref(const DoutPrefixProvider* dpp, librados::Rados* rados,
- rgw_raw_obj obj, rgw_rados_ref* ref);
-
int rgw_init_ioctx(const DoutPrefixProvider *dpp,
librados::Rados *rados, const rgw_pool& pool,
librados::IoCtx& ioctx,
int rgw_rados_operate(const DoutPrefixProvider *dpp, librados::IoCtx& ioctx, const std::string& oid,
librados::ObjectWriteOperation *op, optional_yield y,
int flags = 0);
-inline int rgw_rados_operate(const DoutPrefixProvider *dpp,
- rgw_rados_ref& ref,
- librados::ObjectReadOperation *op, bufferlist *pbl,
- optional_yield y, int flags = 0)
-{
- return rgw_rados_operate(dpp, ref.ioctx, ref.obj.oid, op, pbl, y, flags);
-}
-
-inline int rgw_rados_operate(const DoutPrefixProvider *dpp,
- rgw_rados_ref& ref,
- librados::ObjectWriteOperation *op,
- optional_yield y, int flags = 0)
-{
- return rgw_rados_operate(dpp, ref.ioctx, ref.obj.oid, op, y, flags);
-}
-
int rgw_rados_notify(const DoutPrefixProvider *dpp, librados::IoCtx& ioctx, const std::string& oid,
bufferlist& bl, uint64_t timeout_ms, bufferlist* pbl,
optional_yield y);
-inline int rgw_rados_notify(const DoutPrefixProvider *dpp, rgw_rados_ref& ref,
- bufferlist& bl, uint64_t timeout_ms,
- bufferlist* pbl, optional_yield y)
-{
- return rgw_rados_notify(dpp, ref.ioctx, ref.obj.oid, bl, timeout_ms, pbl, y);
+
+struct rgw_rados_ref {
+ librados::IoCtx ioctx;
+ rgw_raw_obj obj;
+
+
+ int operate(const DoutPrefixProvider *dpp, librados::ObjectReadOperation *op,
+ bufferlist *pbl, optional_yield y, int flags = 0) {
+ return rgw_rados_operate(dpp, ioctx, obj.oid, op, pbl, y, flags);
+ }
+
+ int operate(const DoutPrefixProvider *dpp, librados::ObjectWriteOperation *op,
+ optional_yield y, int flags = 0) {
+ return rgw_rados_operate(dpp, ioctx, obj.oid, op, y, flags);
+ }
+
+ int aio_operate(librados::AioCompletion *c,
+ librados::ObjectWriteOperation *op) {
+ return ioctx.aio_operate(obj.oid, c, op);
+ }
+
+ int aio_operate(librados::AioCompletion *c, librados::ObjectReadOperation *op,
+ bufferlist *pbl) {
+ return ioctx.aio_operate(obj.oid, c, op, pbl);
+ }
+
+ int notify(const DoutPrefixProvider *dpp, bufferlist& bl, uint64_t timeout_ms,
+ bufferlist* pbl, optional_yield y) {
+ return rgw_rados_notify(dpp, ioctx, obj.oid, bl, timeout_ms, pbl, y);
+ }
+};
+inline std::ostream& operator <<(std::ostream& m, const rgw_rados_ref& ref) {
+ return m << ref.obj;
}
+int rgw_get_rados_ref(const DoutPrefixProvider* dpp, librados::Rados* rados,
+ rgw_raw_obj obj, rgw_rados_ref* ref);
+
+
int rgw_tools_init(const DoutPrefixProvider *dpp, CephContext *cct);
void rgw_tools_cleanup();
rados->set_context(cct);
- int ret = rados->init_svc(true, dpp);
- if (ret < 0) {
- ldout(cct, 0) << "ERROR: failed to init services (ret=" << cpp_strerror(-ret) << ")" << dendl;
+ if (rados->init_rados() < 0) {
delete driver;
return nullptr;
}
- if (rados->init_rados() < 0) {
+ int ret = rados->init_svc(true, dpp);
+ if (ret < 0) {
+ ldout(cct, 0) << "ERROR: failed to init services (ret=" << cpp_strerror(-ret) << ")" << dendl;
delete driver;
return nullptr;
}
+
if (driver->initialize(cct, dpp) < 0) {
delete driver;
return nullptr;
}
void RGWSI_BucketIndex_RADOS::init(RGWSI_Zone *zone_svc,
- RGWSI_RADOS *rados_svc,
- RGWSI_BILog_RADOS *bilog_svc,
- RGWDataChangesLog *datalog_rados_svc)
+ librados::Rados* rados_,
+ RGWSI_BILog_RADOS *bilog_svc,
+ RGWDataChangesLog *datalog_rados_svc)
{
svc.zone = zone_svc;
- svc.rados = rados_svc;
+ rados = rados_;
svc.bilog = bilog_svc;
svc.datalog_rados = datalog_rados_svc;
}
int RGWSI_BucketIndex_RADOS::open_pool(const DoutPrefixProvider *dpp,
const rgw_pool& pool,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
bool mostly_omap)
{
- *index_pool = svc.rados->pool(pool);
- return index_pool->open(dpp, RGWSI_RADOS::OpenParams()
- .set_mostly_omap(mostly_omap));
+ return rgw_init_ioctx(dpp, rados, pool, *index_pool, true, mostly_omap);
}
int RGWSI_BucketIndex_RADOS::open_bucket_index_pool(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
- RGWSI_RADOS::Pool *index_pool)
+ librados::IoCtx* index_pool)
{
const rgw_pool& explicit_pool = bucket_info.bucket.explicit_placement.index_pool;
int RGWSI_BucketIndex_RADOS::open_bucket_index_base(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
string *bucket_oid_base)
{
const rgw_bucket& bucket = bucket_info.bucket;
int RGWSI_BucketIndex_RADOS::open_bucket_index(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
string *bucket_oid)
{
const rgw_bucket& bucket = bucket_info.bucket;
const RGWBucketInfo& bucket_info,
std::optional<int> _shard_id,
const rgw::bucket_index_layout_generation& idx_layout,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
map<int, string> *bucket_objs,
map<int, string> *bucket_instance_ids)
{
int RGWSI_BucketIndex_RADOS::open_bucket_index_shard(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
const string& obj_key,
- RGWSI_RADOS::Obj *bucket_obj,
+ rgw_rados_ref* bucket_obj,
int *shard_id)
{
string bucket_oid_base;
- RGWSI_RADOS::Pool pool;
-
- int ret = open_bucket_index_base(dpp, bucket_info, &pool, &bucket_oid_base);
+ int ret = open_bucket_index_base(dpp, bucket_info, &bucket_obj->ioctx, &bucket_oid_base);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << ": open_bucket_index_pool() returned "
<< ret << dendl;
return ret;
}
- string oid;
-
const auto& current_index = bucket_info.layout.current_index;
ret = get_bucket_index_object(bucket_oid_base, current_index.layout.normal,
- current_index.gen, obj_key, &oid, shard_id);
+ current_index.gen, obj_key,
+ &bucket_obj->obj.oid, shard_id);
if (ret < 0) {
ldpp_dout(dpp, 10) << "get_bucket_index_object() returned ret=" << ret << dendl;
return ret;
}
- *bucket_obj = svc.rados->obj(pool, oid);
-
return 0;
}
const RGWBucketInfo& bucket_info,
const rgw::bucket_index_layout_generation& index,
int shard_id,
- RGWSI_RADOS::Obj *bucket_obj)
+ rgw_rados_ref* bucket_obj)
{
- RGWSI_RADOS::Pool index_pool;
string bucket_oid_base;
- int ret = open_bucket_index_base(dpp, bucket_info, &index_pool, &bucket_oid_base);
+ int ret = open_bucket_index_base(dpp, bucket_info, &bucket_obj->ioctx,
+ &bucket_oid_base);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << ": open_bucket_index_pool() returned "
<< ret << dendl;
return ret;
}
- string oid;
-
get_bucket_index_object(bucket_oid_base, index.layout.normal,
- index.gen, shard_id, &oid);
-
- *bucket_obj = svc.rados->obj(index_pool, oid);
+ index.gen, shard_id, &bucket_obj->obj.oid);
return 0;
}
map<int, string> *bucket_instance_ids,
optional_yield y)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> oids;
int r = open_bucket_index(dpp, bucket_info, shard_id, idx_layout, &index_pool, &oids, bucket_instance_ids);
if (r < 0)
list_results.emplace(iter.first, rgw_cls_list_ret());
}
- r = CLSRGWIssueGetDirHeader(index_pool.ioctx(), oids, list_results, cct->_conf->rgw_bucket_index_max_aio)();
+ r = CLSRGWIssueGetDirHeader(index_pool, oids, list_results,
+ cct->_conf->rgw_bucket_index_max_aio)();
if (r < 0)
return r;
return 0;
}
-int RGWSI_BucketIndex_RADOS::init_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout)
+int RGWSI_BucketIndex_RADOS::init_index(const DoutPrefixProvider *dpp,RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
string dir_oid = dir_oid_prefix;
int r = open_bucket_index_pool(dpp, bucket_info, &index_pool);
map<int, string> bucket_objs;
get_bucket_index_objects(dir_oid, idx_layout.layout.normal.num_shards, idx_layout.gen, &bucket_objs);
- return CLSRGWIssueBucketIndexInit(index_pool.ioctx(),
+ return CLSRGWIssueBucketIndexInit(index_pool,
bucket_objs,
cct->_conf->rgw_bucket_index_max_aio)();
}
int RGWSI_BucketIndex_RADOS::clean_index(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, const rgw::bucket_index_layout_generation& idx_layout)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
std::string dir_oid = dir_oid_prefix;
int r = open_bucket_index_pool(dpp, bucket_info, &index_pool);
get_bucket_index_objects(dir_oid, idx_layout.layout.normal.num_shards,
idx_layout.gen, &bucket_objs);
- return CLSRGWIssueBucketIndexClean(index_pool.ioctx(),
+ return CLSRGWIssueBucketIndexClean(index_pool,
bucket_objs,
cct->_conf->rgw_bucket_index_max_aio)();
}
{
map<int, string> bucket_objs;
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
int r = open_bucket_index(dpp, bucket_info,
std::nullopt,
for (auto i : bucket_objs) {
cls_rgw_bucket_instance_entry entry;
- int ret = cls_rgw_get_bucket_resharding(index_pool.ioctx(), i.second, &entry);
+ int ret = cls_rgw_get_bucket_resharding(index_pool, i.second, &entry);
if (ret < 0 && ret != -ENOENT) {
ldpp_dout(dpp, -1) << "ERROR: " << __func__ << ": cls_rgw_get_bucket_resharding() returned ret=" << ret << dendl;
return ret;
int open_pool(const DoutPrefixProvider *dpp,
const rgw_pool& pool,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
bool mostly_omap);
int open_bucket_index_pool(const DoutPrefixProvider *dpp,
- const RGWBucketInfo& bucket_info,
- RGWSI_RADOS::Pool *index_pool);
+ const RGWBucketInfo& bucket_info,
+ librados::IoCtx* index_pool);
int open_bucket_index_base(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
std::string *bucket_oid_base);
// return the index oid for the given shard id
public:
+ librados::Rados* rados{nullptr};
+
struct Svc {
RGWSI_Zone *zone{nullptr};
- RGWSI_RADOS *rados{nullptr};
RGWSI_BILog_RADOS *bilog{nullptr};
RGWDataChangesLog *datalog_rados{nullptr};
} svc;
RGWSI_BucketIndex_RADOS(CephContext *cct);
void init(RGWSI_Zone *zone_svc,
- RGWSI_RADOS *rados_svc,
+ librados::Rados* rados_,
RGWSI_BILog_RADOS *bilog_svc,
RGWDataChangesLog *datalog_rados_svc);
int open_bucket_index_shard(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
const std::string& obj_key,
- RGWSI_RADOS::Obj *bucket_obj,
+ rgw_rados_ref* bucket_obj,
int *shard_id);
int open_bucket_index_shard(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
const rgw::bucket_index_layout_generation& index,
- int shard_id, RGWSI_RADOS::Obj *bucket_obj);
+ int shard_id, rgw_rados_ref* bucket_obj);
int open_bucket_index(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
std::string *bucket_oid);
int open_bucket_index(const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
std::optional<int> shard_id,
const rgw::bucket_index_layout_generation& idx_layout,
- RGWSI_RADOS::Pool *index_pool,
+ librados::IoCtx* index_pool,
std::map<int, std::string> *bucket_objs,
std::map<int, std::string> *bucket_instance_ids);
};
-
-
std::string_view start_marker,
std::string_view end_marker)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
BucketIndexShardsManager start_marker_mgr;
return r;
}
- return CLSRGWIssueBILogTrim(index_pool.ioctx(), start_marker_mgr, end_marker_mgr, bucket_objs,
+ return CLSRGWIssueBILogTrim(index_pool, start_marker_mgr, end_marker_mgr, bucket_objs,
cct->_conf->rgw_bucket_index_max_aio)();
}
int RGWSI_BILog_RADOS::log_start(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_log_layout_generation& log_layout, int shard_id)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
const auto& current_index = rgw::log_to_index_layout(log_layout);
int r = svc.bi->open_bucket_index(dpp, bucket_info, shard_id, current_index, &index_pool, &bucket_objs, nullptr);
if (r < 0)
return r;
- return CLSRGWIssueResyncBucketBILog(index_pool.ioctx(), bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
+ return CLSRGWIssueResyncBucketBILog(index_pool, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
}
int RGWSI_BILog_RADOS::log_stop(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw::bucket_log_layout_generation& log_layout, int shard_id)
{
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> bucket_objs;
const auto& current_index = rgw::log_to_index_layout(log_layout);
int r = svc.bi->open_bucket_index(dpp, bucket_info, shard_id, current_index, &index_pool, &bucket_objs, nullptr);
if (r < 0)
return r;
- return CLSRGWIssueBucketBILogStop(index_pool.ioctx(), bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
+ return CLSRGWIssueBucketBILogStop(index_pool, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
}
static void build_bucket_index_marker(const string& shard_id_str,
ldpp_dout(dpp, 20) << __func__ << ": " << bucket_info.bucket << " marker " << marker << " shard_id=" << shard_id << " max " << max << dendl;
result.clear();
- RGWSI_RADOS::Pool index_pool;
+ librados::IoCtx index_pool;
map<int, string> oids;
map<int, cls_rgw_bi_log_list_ret> bi_log_lists;
const auto& current_index = rgw::log_to_index_layout(log_layout);
r = marker_mgr.from_string(marker, shard_id);
if (r < 0)
return r;
-
- r = CLSRGWIssueBILogList(index_pool.ioctx(), marker_mgr, max, oids, bi_log_lists, cct->_conf->rgw_bucket_index_max_aio)();
+
+ r = CLSRGWIssueBILogList(index_pool, marker_mgr, max, oids, bi_log_lists, cct->_conf->rgw_bucket_index_max_aio)();
if (r < 0)
return r;
projects / ceph.git / commitdiff