// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
+// vim: ts=8 sw=2 smarttab ft=cpp
#include <errno.h>
#include "include/types.h"
#include "include/stringify.h"
+#include "librados/AioCompletionImpl.h"
+
#include "rgw_common.h"
-#include "rgw_rados.h"
#include "rgw_tools.h"
#include "rgw_acl_s3.h"
#include "rgw_op.h"
#include "rgw_aio_throttle.h"
#include "rgw_compression.h"
#include "rgw_zone.h"
+#include "rgw_sal_rados.h"
#include "osd/osd_types.h"
#include "services/svc_sys_obj.h"
+#include "services/svc_zone.h"
#include "services/svc_zone_utils.h"
#define dout_subsys ceph_subsys_rgw
#define READ_CHUNK_LEN (512 * 1024)
+using namespace std;
+
static std::map<std::string, std::string>* ext_mime_map;
-int rgw_init_ioctx(librados::Rados *rados, const rgw_pool& pool,
+int rgw_init_ioctx(const DoutPrefixProvider *dpp,
+ librados::Rados *rados, const rgw_pool& pool,
librados::IoCtx& ioctx, bool create,
bool mostly_omap)
{
if (r == -ENOENT && create) {
r = rados->pool_create(pool.name.c_str());
if (r == -ERANGE) {
- dout(0)
+ ldpp_dout(dpp, 0)
<< __func__
<< " ERROR: librados::Rados::pool_create returned " << cpp_strerror(-r)
<< " (this can be due to a pool or placement group misconfiguration, e.g."
float bias = g_conf().get_val<double>("rgw_rados_pool_autoscale_bias");
int r = rados->mon_command(
"{\"prefix\": \"osd pool set\", \"pool\": \"" +
- pool.name + "\", \"var\": \"pg_autoscale_bias\": \"" +
+ pool.name + "\", \"var\": \"pg_autoscale_bias\", \"val\": \"" +
stringify(bias) + "\"}",
inbl, NULL, NULL);
if (r < 0) {
- dout(10) << __func__ << " warning: failed to set pg_autoscale_bias on "
+ ldpp_dout(dpp, 10) << __func__ << " warning: failed to set pg_autoscale_bias on "
<< pool.name << dendl;
}
- // set pg_num_min
- int min = g_conf().get_val<uint64_t>("rgw_rados_pool_pg_num_min");
+ // set recovery_priority
+ int p = g_conf().get_val<uint64_t>("rgw_rados_pool_recovery_priority");
r = rados->mon_command(
"{\"prefix\": \"osd pool set\", \"pool\": \"" +
- pool.name + "\", \"var\": \"pg_num_min\": \"" +
- stringify(min) + "\"}",
+ pool.name + "\", \"var\": \"recovery_priority\": \"" +
+ stringify(p) + "\"}",
inbl, NULL, NULL);
- if (r < 0) {
- dout(10) << __func__ << " warning: failed to set pg_num_min on "
- << pool.name << dendl;
+ if (r < 0) {
+ ldpp_dout(dpp, 10) << __func__ << " warning: failed to set recovery_priority on "
+ << pool.name << dendl;
}
}
} else if (r < 0) {
return 0;
}
-int rgw_put_system_obj(RGWRados *rgwstore, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
- RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs)
+void rgw_shard_name(const string& prefix, unsigned max_shards, const string& key, string& name, int *shard_id)
+{
+ uint32_t val = ceph_str_hash_linux(key.c_str(), key.size());
+ char buf[16];
+ if (shard_id) {
+ *shard_id = val % max_shards;
+ }
+ snprintf(buf, sizeof(buf), "%u", (unsigned)(val % max_shards));
+ name = prefix + buf;
+}
+
+void rgw_shard_name(const string& prefix, unsigned max_shards, const string& section, const string& key, string& name)
+{
+ uint32_t val = ceph_str_hash_linux(key.c_str(), key.size());
+ val ^= ceph_str_hash_linux(section.c_str(), section.size());
+ char buf[16];
+ snprintf(buf, sizeof(buf), "%u", (unsigned)(val % max_shards));
+ name = prefix + buf;
+}
+
+void rgw_shard_name(const string& prefix, unsigned shard_id, string& name)
+{
+ char buf[16];
+ snprintf(buf, sizeof(buf), "%u", shard_id);
+ name = prefix + buf;
+}
+
+int rgw_parse_list_of_flags(struct rgw_name_to_flag *mapping,
+ const string& str, uint32_t *perm)
+{
+ list<string> strs;
+ get_str_list(str, strs);
+ list<string>::iterator iter;
+ uint32_t v = 0;
+ for (iter = strs.begin(); iter != strs.end(); ++iter) {
+ string& s = *iter;
+ for (int i = 0; mapping[i].type_name; i++) {
+ if (s.compare(mapping[i].type_name) == 0)
+ v |= mapping[i].flag;
+ }
+ }
+
+ *perm = v;
+ return 0;
+}
+
+int rgw_put_system_obj(const DoutPrefixProvider *dpp,
+ RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, real_time set_mtime, optional_yield y, map<string, bufferlist> *pattrs)
{
map<string,bufferlist> no_attrs;
if (!pattrs) {
rgw_raw_obj obj(pool, oid);
- auto obj_ctx = rgwstore->svc.sysobj->init_obj_ctx();
auto sysobj = obj_ctx.get_obj(obj);
int ret = sysobj.wop()
.set_objv_tracker(objv_tracker)
.set_exclusive(exclusive)
.set_mtime(set_mtime)
.set_attrs(*pattrs)
- .write(data);
-
- if (ret == -ENOENT) {
- ret = rgwstore->create_pool(pool);
- if (ret >= 0) {
- ret = sysobj.wop()
- .set_objv_tracker(objv_tracker)
- .set_exclusive(exclusive)
- .set_mtime(set_mtime)
- .set_attrs(*pattrs)
- .write(data);
- }
- }
+ .write(dpp, data, y);
return ret;
}
-int rgw_get_system_obj(RGWRados *rgwstore, RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& key, bufferlist& bl,
- RGWObjVersionTracker *objv_tracker, real_time *pmtime, map<string, bufferlist> *pattrs,
- rgw_cache_entry_info *cache_info, boost::optional<obj_version> refresh_version)
+int rgw_get_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& key, bufferlist& bl,
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime, optional_yield y, const DoutPrefixProvider *dpp, map<string, bufferlist> *pattrs,
+ rgw_cache_entry_info *cache_info,
+ boost::optional<obj_version> refresh_version, bool raw_attrs)
{
bufferlist::iterator iter;
int request_len = READ_CHUNK_LEN;
int ret = rop.set_attrs(pattrs)
.set_last_mod(pmtime)
.set_objv_tracker(objv_tracker)
- .stat();
+ .set_raw_attrs(raw_attrs)
+ .stat(y, dpp);
if (ret < 0)
return ret;
ret = rop.set_cache_info(cache_info)
.set_refresh_version(refresh_version)
- .read(&bl);
+ .read(dpp, &bl, y);
if (ret == -ECANCELED) {
/* raced, restart */
if (!original_readv.empty()) {
return 0;
}
-int rgw_delete_system_obj(RGWRados *rgwstore, const rgw_pool& pool, const string& oid,
- RGWObjVersionTracker *objv_tracker)
+int rgw_delete_system_obj(const DoutPrefixProvider *dpp,
+ RGWSI_SysObj *sysobj_svc, const rgw_pool& pool, const string& oid,
+ RGWObjVersionTracker *objv_tracker, optional_yield y)
{
- auto obj_ctx = rgwstore->svc.sysobj->init_obj_ctx();
+ auto obj_ctx = sysobj_svc->init_obj_ctx();
auto sysobj = obj_ctx.get_obj(rgw_raw_obj{pool, oid});
rgw_raw_obj obj(pool, oid);
return sysobj.wop()
.set_objv_tracker(objv_tracker)
- .remove();
+ .remove(dpp, y);
}
thread_local bool is_asio_thread = false;
-int rgw_rados_operate(librados::IoCtx& ioctx, const std::string& oid,
+int rgw_rados_operate(const DoutPrefixProvider *dpp, librados::IoCtx& ioctx, const std::string& oid,
librados::ObjectReadOperation *op, bufferlist* pbl,
- optional_yield y)
+ optional_yield y, int flags)
{
-#ifdef HAVE_BOOST_CONTEXT
// given a yield_context, call async_operate() to yield the coroutine instead
// of blocking
if (y) {
auto& context = y.get_io_context();
auto& yield = y.get_yield_context();
boost::system::error_code ec;
- auto bl = librados::async_operate(context, ioctx, oid, op, 0, yield[ec]);
+ auto bl = librados::async_operate(
+ context, ioctx, oid, op, flags, yield[ec]);
if (pbl) {
*pbl = std::move(bl);
}
}
// work on asio threads should be asynchronous, so warn when they block
if (is_asio_thread) {
- dout(20) << "WARNING: blocking librados call" << dendl;
+ ldpp_dout(dpp, 20) << "WARNING: blocking librados call" << dendl;
+ }
+ return ioctx.operate(oid, op, nullptr, flags);
+}
+
+int rgw_rados_operate(const DoutPrefixProvider *dpp, librados::IoCtx& ioctx, const std::string& oid,
+ librados::ObjectWriteOperation *op, optional_yield y,
+ int flags)
+{
+ if (y) {
+ auto& context = y.get_io_context();
+ auto& yield = y.get_yield_context();
+ boost::system::error_code ec;
+ librados::async_operate(context, ioctx, oid, op, flags, yield[ec]);
+ return -ec.value();
+ }
+ if (is_asio_thread) {
+ ldpp_dout(dpp, 20) << "WARNING: blocking librados call" << dendl;
}
-#endif
- return ioctx.operate(oid, op, nullptr);
+ return ioctx.operate(oid, op, flags);
}
-int rgw_rados_operate(librados::IoCtx& ioctx, const std::string& oid,
- librados::ObjectWriteOperation *op, optional_yield y)
+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)
{
-#ifdef HAVE_BOOST_CONTEXT
if (y) {
auto& context = y.get_io_context();
auto& yield = y.get_yield_context();
boost::system::error_code ec;
- librados::async_operate(context, ioctx, oid, op, 0, yield[ec]);
+ auto reply = librados::async_notify(context, ioctx, oid,
+ bl, timeout_ms, yield[ec]);
+ if (pbl) {
+ *pbl = std::move(reply);
+ }
return -ec.value();
}
if (is_asio_thread) {
- dout(20) << "WARNING: blocking librados call" << dendl;
+ ldpp_dout(dpp, 20) << "WARNING: blocking librados call" << dendl;
}
-#endif
- return ioctx.operate(oid, op);
+ return ioctx.notify2(oid, bl, timeout_ms, pbl);
}
void parse_mime_map_line(const char *start, const char *end)
}
}
-static int ext_mime_map_init(CephContext *cct, const char *ext_map)
+static int ext_mime_map_init(const DoutPrefixProvider *dpp, CephContext *cct, const char *ext_map)
{
int fd = open(ext_map, O_RDONLY);
char *buf = NULL;
int ret;
if (fd < 0) {
ret = -errno;
- ldout(cct, 0) << __func__ << " failed to open file=" << ext_map
+ ldpp_dout(dpp, 0) << __func__ << " failed to open file=" << ext_map
<< " : " << cpp_strerror(-ret) << dendl;
return ret;
}
ret = fstat(fd, &st);
if (ret < 0) {
ret = -errno;
- ldout(cct, 0) << __func__ << " failed to stat file=" << ext_map
+ ldpp_dout(dpp, 0) << __func__ << " failed to stat file=" << ext_map
<< " : " << cpp_strerror(-ret) << dendl;
goto done;
}
buf = (char *)malloc(st.st_size + 1);
if (!buf) {
ret = -ENOMEM;
- ldout(cct, 0) << __func__ << " failed to allocate buf" << dendl;
+ ldpp_dout(dpp, 0) << __func__ << " failed to allocate buf" << dendl;
goto done;
}
ret = safe_read(fd, buf, st.st_size + 1);
if (ret != st.st_size) {
// huh? file size has changed?
- ldout(cct, 0) << __func__ << " raced! will retry.." << dendl;
+ ldpp_dout(dpp, 0) << __func__ << " raced! will retry.." << dendl;
free(buf);
close(fd);
- return ext_mime_map_init(cct, ext_map);
+ return ext_mime_map_init(dpp, cct, ext_map);
}
buf[st.st_size] = '\0';
}
}
-RGWDataAccess::RGWDataAccess(RGWRados *_store) : store(_store)
+RGWDataAccess::RGWDataAccess(rgw::sal::Store* _store) : store(_store)
{
- sysobj_ctx = std::make_unique<RGWSysObjectCtx>(store->svc.sysobj->init_obj_ctx());
}
return 0;
}
-int RGWDataAccess::Bucket::init()
+int RGWDataAccess::Bucket::init(const DoutPrefixProvider *dpp, optional_yield y)
{
- int ret = sd->store->get_bucket_info(*sd->sysobj_ctx,
- tenant, name,
- bucket_info,
- &mtime,
- &attrs);
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ int ret = sd->store->get_bucket(dpp, nullptr, tenant, name, &bucket, y);
if (ret < 0) {
return ret;
}
+ bucket_info = bucket->get_info();
+ mtime = bucket->get_modification_time();
+ attrs = bucket->get_attrs();
+
return finish_init();
}
}
int RGWDataAccess::Object::put(bufferlist& data,
- map<string, bufferlist>& attrs)
+ map<string, bufferlist>& attrs,
+ const DoutPrefixProvider *dpp,
+ optional_yield y)
{
- RGWRados *store = sd->store;
+ rgw::sal::Store* store = sd->store;
CephContext *cct = store->ctx();
string tag;
RGWBucketInfo& bucket_info = bucket->bucket_info;
- using namespace rgw::putobj;
- rgw::AioThrottle aio(store->ctx()->_conf->rgw_put_obj_min_window_size);
+ rgw::BlockingAioThrottle aio(store->ctx()->_conf->rgw_put_obj_min_window_size);
RGWObjectCtx obj_ctx(store);
- rgw_obj obj(bucket_info.bucket, key);
+ std::unique_ptr<rgw::sal::Bucket> b;
+ store->get_bucket(NULL, bucket_info, &b);
+ std::unique_ptr<rgw::sal::Object> obj = b->get_object(key);
auto& owner = bucket->policy.get_owner();
- string req_id = store->svc.zone_utils->unique_id(store->get_new_req_id());
+ string req_id = store->zone_unique_id(store->get_new_req_id());
- AtomicObjectProcessor processor(&aio, store, bucket_info,
- nullptr,
- owner.get_id(),
- obj_ctx, obj, olh_epoch, req_id);
+ std::unique_ptr<rgw::sal::Writer> processor;
+ processor = store->get_atomic_writer(dpp, y, std::move(obj),
+ owner.get_id(), obj_ctx,
+ nullptr, olh_epoch, req_id);
- int ret = processor.prepare();
+ int ret = processor->prepare(y);
if (ret < 0)
return ret;
- using namespace rgw::putobj;
-
- DataProcessor *filter = &processor;
+ rgw::sal::DataProcessor *filter = processor.get();
CompressorRef plugin;
boost::optional<RGWPutObj_Compress> compressor;
- const auto& compression_type = store->svc.zone->get_zone_params().get_compression_type(bucket_info.placement_rule);
+ const auto& compression_type = store->get_zone()->get_params().get_compression_type(bucket_info.placement_rule);
if (compression_type != "none") {
plugin = Compressor::create(store->ctx(), compression_type);
if (!plugin) {
- ldout(store->ctx(), 1) << "Cannot load plugin for compression type "
+ ldpp_dout(dpp, 1) << "Cannot load plugin for compression type "
<< compression_type << dendl;
} else {
compressor.emplace(store->ctx(), plugin, filter);
puser_data = &(*user_data);
}
- return processor.complete(obj_size, etag,
+ return processor->complete(obj_size, etag,
&mtime, mtime,
attrs, delete_at,
nullptr, nullptr,
puser_data,
- nullptr, nullptr);
+ nullptr, nullptr, y);
}
void RGWDataAccess::Object::set_policy(const RGWAccessControlPolicy& policy)
policy.encode(aclbl.emplace());
}
-int rgw_tools_init(CephContext *cct)
+int rgw_tools_init(const DoutPrefixProvider *dpp, CephContext *cct)
{
ext_mime_map = new std::map<std::string, std::string>;
- ext_mime_map_init(cct, cct->_conf->rgw_mime_types_file.c_str());
+ ext_mime_map_init(dpp, cct, cct->_conf->rgw_mime_types_file.c_str());
// ignore errors; missing mime.types is not fatal
return 0;
}
delete ext_mime_map;
ext_mime_map = nullptr;
}
+
+void rgw_complete_aio_completion(librados::AioCompletion* c, int r) {
+ auto pc = c->pc;
+ librados::CB_AioCompleteAndSafe cb(pc);
+ cb(r);
+}
projects / ceph.git / blobdiff