{
bufferlist bl;
- struct rgw_bi_log_entry entry;
+ rgw_bi_log_entry entry;
entry.object = obj_key.name;
entry.instance = obj_key.instance;
* we'll use the second index. Note that regular objects only map to the first index anyway
*/
-static void get_list_index_key(struct rgw_bucket_dir_entry& entry, string *index_key)
+static void get_list_index_key(rgw_bucket_dir_entry& entry, string *index_key)
{
*index_key = entry.key.name;
return 0;
}
-static int read_bucket_header(cls_method_context_t hctx, struct rgw_bucket_dir_header *header)
+static int read_bucket_header(cls_method_context_t hctx,
+ rgw_bucket_dir_header *header)
{
bufferlist bl;
int rc = cls_cxx_map_read_header(hctx, &bl);
{
auto iter = in->cbegin();
- struct rgw_cls_list_op op;
+ rgw_cls_list_op op;
try {
decode(op, iter);
} catch (buffer::error& err) {
return -EINVAL;
}
- struct rgw_cls_list_ret ret;
- struct rgw_bucket_dir& new_dir = ret.dir;
+ rgw_cls_list_ret ret;
+ rgw_bucket_dir& new_dir = ret.dir;
int rc = read_bucket_header(hctx, &new_dir.header);
if (rc < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_list(): failed to read header\n");
if (rc < 0)
return rc;
- std::map<string, struct rgw_bucket_dir_entry>& m = new_dir.m;
+ std::map<string, rgw_bucket_dir_entry>& m = new_dir.m;
done = keys.empty();
for (kiter = keys.begin(); kiter != keys.end(); ++kiter) {
- struct rgw_bucket_dir_entry entry;
+ rgw_bucket_dir_entry entry;
if (!bi_is_objs_index(kiter->first)) {
done = true;
int rgw_bucket_check_index(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- struct rgw_cls_check_index_ret ret;
+ rgw_cls_check_index_ret ret;
int rc = check_index(hctx, &ret.existing_header, &ret.calculated_header);
if (rc < 0)
return 0;
}
-static int write_bucket_header(cls_method_context_t hctx, struct rgw_bucket_dir_header *header)
+static int write_bucket_header(cls_method_context_t hctx, rgw_bucket_dir_header *header)
{
header->ver++;
int rgw_bucket_rebuild_index(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- struct rgw_bucket_dir_header existing_header;
- struct rgw_bucket_dir_header calc_header;
+ rgw_bucket_dir_header existing_header;
+ rgw_bucket_dir_header calc_header;
int rc = check_index(hctx, &existing_header, &calc_header);
if (rc < 0)
return rc;
return -EINVAL;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: %s(): failed to read header\n", __func__);
return -EINVAL;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_set_tag_timeout(): failed to read header\n");
return write_bucket_header(hctx, &header);
}
-static int read_key_entry(cls_method_context_t hctx, cls_rgw_obj_key& key, string *idx, struct rgw_bucket_dir_entry *entry,
+static int read_key_entry(cls_method_context_t hctx, cls_rgw_obj_key& key,
+ string *idx, rgw_bucket_dir_entry *entry,
bool special_delete_marker_name = false);
int rgw_bucket_prepare_op(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
// get on-disk state
string idx;
- struct rgw_bucket_dir_entry entry;
+ rgw_bucket_dir_entry entry;
int rc = read_key_entry(hctx, op.key, &idx, &entry);
if (rc < 0 && rc != -ENOENT)
return rc;
}
// fill in proper state
- struct rgw_bucket_pending_info info;
+ rgw_bucket_pending_info info;
info.timestamp = real_clock::now();
info.state = CLS_RGW_STATE_PENDING_MODIFY;
info.op = op.op;
entry.pending_map.insert(pair<string, rgw_bucket_pending_info>(op.tag, info));
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_prepare_op(): failed to read header\n");
return 0;
}
-static void unaccount_entry(struct rgw_bucket_dir_header& header, struct rgw_bucket_dir_entry& entry)
+static void unaccount_entry(rgw_bucket_dir_header& header,
+ rgw_bucket_dir_entry& entry)
{
- struct rgw_bucket_category_stats& stats = header.stats[entry.meta.category];
+ rgw_bucket_category_stats& stats = header.stats[entry.meta.category];
stats.num_entries--;
stats.total_size -= entry.meta.accounted_size;
stats.total_size_rounded -= cls_rgw_get_rounded_size(entry.meta.accounted_size);
stats.actual_size -= entry.meta.size;
}
-static void log_entry(const char *func, const char *str, struct rgw_bucket_dir_entry *entry)
+static void log_entry(const char *func, const char *str, rgw_bucket_dir_entry *entry)
{
CLS_LOG(1, "%s(): %s: ver=%ld:%llu name=%s instance=%s locator=%s\n", func, str,
(long)entry->ver.pool, (unsigned long long)entry->ver.epoch,
entry->key.name.c_str(), entry->key.instance.c_str(), entry->locator.c_str());
}
-static void log_entry(const char *func, const char *str, struct rgw_bucket_olh_entry *entry)
+static void log_entry(const char *func, const char *str, rgw_bucket_olh_entry *entry)
{
CLS_LOG(1, "%s(): %s: epoch=%llu name=%s instance=%s tag=%s\n", func, str,
(unsigned long long)entry->epoch, entry->key.name.c_str(), entry->key.instance.c_str(),
return 0;
}
-static int read_key_entry(cls_method_context_t hctx, cls_rgw_obj_key& key, string *idx, struct rgw_bucket_dir_entry *entry,
+static int read_key_entry(cls_method_context_t hctx, cls_rgw_obj_key& key,
+ string *idx, rgw_bucket_dir_entry *entry,
bool special_delete_marker_name)
{
encode_obj_index_key(key, idx);
(unsigned long)op.ver.pool, (unsigned long long)op.ver.epoch,
op.tag.c_str());
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_complete_op(): failed to read header\n");
return -EINVAL;
}
- struct rgw_bucket_dir_entry entry;
+ rgw_bucket_dir_entry entry;
bool ondisk = true;
string idx;
entry.flags = (entry.key.instance.empty() ? 0 : RGW_BUCKET_DIRENT_FLAG_VER); /* resetting entry flags, entry might have been previously a delete marker */
if (op.tag.size()) {
- map<string, struct rgw_bucket_pending_info>::iterator pinter = entry.pending_map.find(op.tag);
+ map<string, rgw_bucket_pending_info>::iterator pinter = entry.pending_map.find(op.tag);
if (pinter == entry.pending_map.end()) {
CLS_LOG(1, "ERROR: couldn't find tag for pending operation\n");
return -EINVAL;
break;
case CLS_RGW_OP_ADD:
{
- struct rgw_bucket_dir_entry_meta& meta = op.meta;
- struct rgw_bucket_category_stats& stats = header.stats[meta.category];
+ rgw_bucket_dir_entry_meta& meta = op.meta;
+ rgw_bucket_category_stats& stats = header.stats[meta.category];
entry.meta = meta;
entry.key = op.key;
entry.exists = true;
cls_rgw_obj_key& remove_key = *remove_iter;
CLS_LOG(1, "rgw_bucket_complete_op(): removing entries, read_index_entry name=%s instance=%s\n",
remove_key.name.c_str(), remove_key.instance.c_str());
- struct rgw_bucket_dir_entry remove_entry;
+ rgw_bucket_dir_entry remove_entry;
string k;
int ret = read_key_entry(hctx, remove_key, &k, &remove_entry);
if (ret < 0) {
return cls_cxx_map_set_val(hctx, key, &bl);
}
-static int read_olh(cls_method_context_t hctx,cls_rgw_obj_key& obj_key, struct rgw_bucket_olh_entry *olh_data_entry, string *index_key, bool *found)
+static int read_olh(cls_method_context_t hctx,cls_rgw_obj_key& obj_key, rgw_bucket_olh_entry *olh_data_entry, string *index_key, bool *found)
{
cls_rgw_obj_key olh_key;
olh_key.name = obj_key.name;
return 0;
}
-static void update_olh_log(struct rgw_bucket_olh_entry& olh_data_entry, OLHLogOp op, const string& op_tag,
+static void update_olh_log(rgw_bucket_olh_entry& olh_data_entry, OLHLogOp op, const string& op_tag,
cls_rgw_obj_key& key, bool delete_marker, uint64_t epoch)
{
vector<rgw_bucket_olh_log_entry>& log = olh_data_entry.pending_log[olh_data_entry.epoch];
log.push_back(log_entry);
}
-static int write_obj_instance_entry(cls_method_context_t hctx, struct rgw_bucket_dir_entry& instance_entry, const string& instance_idx)
+static int write_obj_instance_entry(cls_method_context_t hctx, rgw_bucket_dir_entry& instance_entry, const string& instance_idx)
{
CLS_LOG(20, "write_entry() instance=%s idx=%s flags=%d", escape_str(instance_entry.key.instance).c_str(), instance_idx.c_str(), instance_entry.flags);
/* write the instance entry */
/*
* write object instance entry, and if needed also the list entry
*/
-static int write_obj_entries(cls_method_context_t hctx, struct rgw_bucket_dir_entry& instance_entry, const string& instance_idx)
+static int write_obj_entries(cls_method_context_t hctx, rgw_bucket_dir_entry& instance_entry, const string& instance_idx)
{
int ret = write_obj_instance_entry(hctx, instance_entry, instance_idx);
if (ret < 0) {
cls_rgw_obj_key key;
string instance_idx;
- struct rgw_bucket_dir_entry instance_entry;
+ rgw_bucket_dir_entry instance_entry;
bool initialized;
cls_rgw_obj_key key;
string olh_data_idx;
- struct rgw_bucket_olh_entry olh_data_entry;
+ rgw_bucket_olh_entry olh_data_entry;
bool initialized;
public:
static int write_version_marker(cls_method_context_t hctx, cls_rgw_obj_key& key)
{
- struct rgw_bucket_dir_entry entry;
+ rgw_bucket_dir_entry entry;
entry.key = key;
entry.flags = RGW_BUCKET_DIRENT_FLAG_VER_MARKER;
int ret = write_entry(hctx, entry, key.name);
return -EINVAL;
}
- struct rgw_bucket_dir_entry entry;
+ rgw_bucket_dir_entry entry;
string orig_idx;
int ret = read_key_entry(hctx, key, &orig_idx, &entry);
}
if (existed && !real_clock::is_zero(op.unmod_since)) {
- struct timespec mtime = ceph::real_clock::to_timespec(obj.mtime());
- struct timespec unmod = ceph::real_clock::to_timespec(op.unmod_since);
+ timespec mtime = ceph::real_clock::to_timespec(obj.mtime());
+ timespec unmod = ceph::real_clock::to_timespec(op.unmod_since);
if (!op.high_precision_time) {
mtime.tv_nsec = 0;
unmod.tv_nsec = 0;
return ret;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
ret = read_bucket_header(hctx, &header);
if (ret < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_link_olh(): failed to read header\n");
return ret;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
ret = read_bucket_header(hctx, &header);
if (ret < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_unlink_instance(): failed to read header\n");
return -EINVAL;
}
- struct rgw_bucket_olh_entry olh_data_entry;
+ rgw_bucket_olh_entry olh_data_entry;
string olh_data_key;
encode_olh_data_key(op.olh, &olh_data_key);
int ret = read_index_entry(hctx, olh_data_key, &olh_data_entry);
}
/* read olh entry */
- struct rgw_bucket_olh_entry olh_data_entry;
+ rgw_bucket_olh_entry olh_data_entry;
string olh_data_key;
encode_olh_data_key(op.olh, &olh_data_key);
int ret = read_index_entry(hctx, olh_data_key, &olh_data_entry);
}
/* read olh entry */
- struct rgw_bucket_olh_entry olh_data_entry;
+ rgw_bucket_olh_entry olh_data_entry;
string olh_data_key;
encode_olh_data_key(op.key, &olh_data_key);
int ret = read_index_entry(hctx, olh_data_key, &olh_data_entry);
CLS_LOG(1, "rgw_dir_suggest_changes()");
bufferlist header_bl;
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
bool header_changed = false;
int rc = read_bucket_header(hctx, &header);
}
real_time cur_time = real_clock::now();
- map<string, struct rgw_bucket_pending_info>::iterator iter =
+ map<string, rgw_bucket_pending_info>::iterator iter =
cur_disk.pending_map.begin();
while(iter != cur_disk.pending_map.end()) {
- map<string, struct rgw_bucket_pending_info>::iterator cur_iter=iter++;
+ map<string, rgw_bucket_pending_info>::iterator cur_iter=iter++;
if (cur_time > (cur_iter->second.timestamp + timespan(tag_timeout))) {
cur_disk.pending_map.erase(cur_iter);
}
if (cur_disk.pending_map.empty()) {
if (cur_disk.exists) {
- struct rgw_bucket_category_stats& old_stats = header.stats[cur_disk.meta.category];
+ rgw_bucket_category_stats& old_stats = header.stats[cur_disk.meta.category];
CLS_LOG(10, "total_entries: %" PRId64 " -> %" PRId64 "\n", old_stats.num_entries, old_stats.num_entries - 1);
old_stats.num_entries--;
old_stats.total_size -= cur_disk.meta.accounted_size;
old_stats.actual_size -= cur_disk.meta.size;
header_changed = true;
}
- struct rgw_bucket_category_stats& stats =
- header.stats[cur_change.meta.category];
+ rgw_bucket_category_stats& stats = header.stats[cur_change.meta.category];
bool log_op = (op & CEPH_RGW_DIR_SUGGEST_LOG_OP) != 0;
op &= CEPH_RGW_DIR_SUGGEST_OP_MASK;
switch(op) {
static int rgw_bi_log_resync(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_complete_op(): failed to read header\n");
bufferlist bl;
- struct rgw_bi_log_entry entry;
+ rgw_bi_log_entry entry;
entry.timestamp = real_clock::now();
entry.op = RGWModifyOp::CLS_RGW_OP_RESYNC;
static int rgw_bi_log_stop(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: rgw_bucket_complete_op(): failed to read header\n");
bufferlist bl;
- struct rgw_bi_log_entry entry;
+ rgw_bi_log_entry entry;
entry.timestamp = real_clock::now();
entry.op = RGWModifyOp::CLS_RGW_OP_SYNCSTOP;
return -EINVAL;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: %s(): failed to read header\n", __func__);
return -EINVAL;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: %s(): failed to read header\n", __func__);
return -EINVAL;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: %s(): failed to read header\n", __func__);
return 0;
}
-static int rgw_get_bucket_resharding(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
+static int rgw_get_bucket_resharding(cls_method_context_t hctx,
+ bufferlist *in, bufferlist *out)
{
cls_rgw_get_bucket_resharding_op op;
return -EINVAL;
}
- struct rgw_bucket_dir_header header;
+ rgw_bucket_dir_header header;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
CLS_LOG(1, "ERROR: %s(): failed to read header\n", __func__);
static bool issue_bucket_set_tag_timeout_op(librados::IoCtx& io_ctx,
const string& oid, uint64_t timeout, BucketIndexAioManager *manager) {
bufferlist in;
- struct rgw_cls_tag_timeout_op call;
+ rgw_cls_tag_timeout_op call;
call.tag_timeout = timeout;
encode(call, in);
ObjectWriteOperation op;
bool absolute,
const map<RGWObjCategory, rgw_bucket_category_stats>& stats)
{
- struct rgw_cls_bucket_update_stats_op call;
+ rgw_cls_bucket_update_stats_op call;
call.absolute = absolute;
call.stats = stats;
bufferlist in;
const cls_rgw_obj_key& key, const string& locator, bool log_op,
uint16_t bilog_flags, rgw_zone_set& zones_trace)
{
- struct rgw_cls_obj_prepare_op call;
+ rgw_cls_obj_prepare_op call;
call.op = op;
call.tag = tag;
call.key = key;
{
bufferlist in;
- struct rgw_cls_obj_complete_op call;
+ rgw_cls_obj_complete_op call;
call.op = op;
call.tag = tag;
call.key = key;
o.exec(RGW_CLASS, RGW_BUCKET_COMPLETE_OP, in);
}
-static bool issue_bucket_list_op(librados::IoCtx& io_ctx,
- const string& oid, const cls_rgw_obj_key& start_obj, const string& filter_prefix,
- uint32_t num_entries, bool list_versions, BucketIndexAioManager *manager,
- struct rgw_cls_list_ret *pdata) {
+static bool issue_bucket_list_op(librados::IoCtx& io_ctx, const string& oid,
+ const cls_rgw_obj_key& start_obj,
+ const string& filter_prefix,
+ uint32_t num_entries, bool list_versions,
+ BucketIndexAioManager *manager,
+ rgw_cls_list_ret *pdata) {
bufferlist in;
- struct rgw_cls_list_op call;
+ rgw_cls_list_op call;
call.start_obj = start_obj;
call.filter_prefix = filter_prefix;
call.num_entries = num_entries;
encode(call, in);
librados::ObjectReadOperation op;
- op.exec(RGW_CLASS, RGW_BUCKET_LIST, in, new ClsBucketIndexOpCtx<struct rgw_cls_list_ret>(pdata, NULL));
+ op.exec(RGW_CLASS, RGW_BUCKET_LIST, in, new ClsBucketIndexOpCtx<rgw_cls_list_ret>(pdata, NULL));
return manager->aio_operate(io_ctx, oid, &op);
}
void cls_rgw_remove_obj(librados::ObjectWriteOperation& o, list<string>& keep_attr_prefixes)
{
bufferlist in;
- struct rgw_cls_obj_remove_op call;
+ rgw_cls_obj_remove_op call;
call.keep_attr_prefixes = keep_attr_prefixes;
encode(call, in);
o.exec(RGW_CLASS, RGW_OBJ_REMOVE, in);
void cls_rgw_obj_store_pg_ver(librados::ObjectWriteOperation& o, const string& attr)
{
bufferlist in;
- struct rgw_cls_obj_store_pg_ver_op call;
+ rgw_cls_obj_store_pg_ver_op call;
call.attr = attr;
encode(call, in);
o.exec(RGW_CLASS, RGW_OBJ_STORE_PG_VER, in);
void cls_rgw_obj_check_attrs_prefix(librados::ObjectOperation& o, const string& prefix, bool fail_if_exist)
{
bufferlist in;
- struct rgw_cls_obj_check_attrs_prefix call;
+ rgw_cls_obj_check_attrs_prefix call;
call.check_prefix = prefix;
call.fail_if_exist = fail_if_exist;
encode(call, in);
void cls_rgw_obj_check_mtime(librados::ObjectOperation& o, const real_time& mtime, bool high_precision_time, RGWCheckMTimeType type)
{
bufferlist in;
- struct rgw_cls_obj_check_mtime call;
+ rgw_cls_obj_check_mtime call;
call.mtime = mtime;
call.high_precision_time = high_precision_time;
call.type = type;
rgw_cls_bi_entry *entry)
{
bufferlist in, out;
- struct rgw_cls_bi_get_op call;
+ rgw_cls_bi_get_op call;
call.key = key;
call.type = index_type;
encode(call, in);
if (r < 0)
return r;
- struct rgw_cls_bi_get_ret op_ret;
+ rgw_cls_bi_get_ret op_ret;
auto iter = out.cbegin();
try {
decode(op_ret, iter);
int cls_rgw_bi_put(librados::IoCtx& io_ctx, const string oid, rgw_cls_bi_entry& entry)
{
bufferlist in, out;
- struct rgw_cls_bi_put_op call;
+ rgw_cls_bi_put_op call;
call.entry = entry;
encode(call, in);
int r = io_ctx.exec(oid, RGW_CLASS, RGW_BI_PUT, in, out);
void cls_rgw_bi_put(ObjectWriteOperation& op, const string oid, rgw_cls_bi_entry& entry)
{
bufferlist in, out;
- struct rgw_cls_bi_put_op call;
+ rgw_cls_bi_put_op call;
call.entry = entry;
encode(call, in);
op.exec(RGW_CLASS, RGW_BI_PUT, in);
list<rgw_cls_bi_entry> *entries, bool *is_truncated)
{
bufferlist in, out;
- struct rgw_cls_bi_list_op call;
+ rgw_cls_bi_list_op call;
call.name = name;
call.marker = marker;
call.max = max;
if (r < 0)
return r;
- struct rgw_cls_bi_list_ret op_ret;
+ rgw_cls_bi_list_ret op_ret;
auto iter = out.cbegin();
try {
decode(op_ret, iter);
int cls_rgw_bucket_link_olh(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op,
const string& oid, const cls_rgw_obj_key& key, bufferlist& olh_tag,
- bool delete_marker, const string& op_tag, struct rgw_bucket_dir_entry_meta *meta,
+ bool delete_marker, const string& op_tag, rgw_bucket_dir_entry_meta *meta,
uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time, bool log_op, rgw_zone_set& zones_trace)
{
bufferlist in, out;
- struct rgw_cls_link_olh_op call;
+ rgw_cls_link_olh_op call;
call.key = key;
call.olh_tag = string(olh_tag.c_str(), olh_tag.length());
call.op_tag = op_tag;
const string& olh_tag, uint64_t olh_epoch, bool log_op, rgw_zone_set& zones_trace)
{
bufferlist in, out;
- struct rgw_cls_unlink_instance_op call;
+ rgw_cls_unlink_instance_op call;
call.key = key;
call.op_tag = op_tag;
call.olh_epoch = olh_epoch;
int cls_rgw_get_olh_log(IoCtx& io_ctx, string& oid, librados::ObjectReadOperation& op, const cls_rgw_obj_key& olh, uint64_t ver_marker,
const string& olh_tag,
- map<uint64_t, vector<struct rgw_bucket_olh_log_entry> > *log, bool *is_truncated)
+ map<uint64_t, vector<rgw_bucket_olh_log_entry> > *log, bool *is_truncated)
{
bufferlist in, out;
- struct rgw_cls_read_olh_log_op call;
+ rgw_cls_read_olh_log_op call;
call.olh = olh;
call.ver_marker = ver_marker;
call.olh_tag = olh_tag;
return op_ret;
}
- struct rgw_cls_read_olh_log_ret ret;
+ rgw_cls_read_olh_log_ret ret;
try {
auto iter = out.cbegin();
decode(ret, iter);
void cls_rgw_trim_olh_log(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& olh, uint64_t ver, const string& olh_tag)
{
bufferlist in;
- struct rgw_cls_trim_olh_log_op call;
+ rgw_cls_trim_olh_log_op call;
call.olh = olh;
call.ver = ver;
call.olh_tag = olh_tag;
int cls_rgw_clear_olh(IoCtx& io_ctx, librados::ObjectWriteOperation& op, string& oid, const cls_rgw_obj_key& olh, const string& olh_tag)
{
bufferlist in, out;
- struct rgw_cls_bucket_clear_olh_op call;
+ rgw_cls_bucket_clear_olh_op call;
call.key = olh;
call.olh_tag = olh_tag;
encode(call, in);
static bool issue_bi_log_list_op(librados::IoCtx& io_ctx, const string& oid, int shard_id,
BucketIndexShardsManager& marker_mgr, uint32_t max, BucketIndexAioManager *manager,
- struct cls_rgw_bi_log_list_ret *pdata) {
+ cls_rgw_bi_log_list_ret *pdata) {
bufferlist in;
cls_rgw_bi_log_list_op call;
call.marker = marker_mgr.get(shard_id, "");
encode(call, in);
librados::ObjectReadOperation op;
- op.exec(RGW_CLASS, RGW_BI_LOG_LIST, in, new ClsBucketIndexOpCtx<struct cls_rgw_bi_log_list_ret>(pdata, NULL));
+ op.exec(RGW_CLASS, RGW_BI_LOG_LIST, in, new ClsBucketIndexOpCtx<cls_rgw_bi_log_list_ret>(pdata, NULL));
return manager->aio_operate(io_ctx, oid, &op);
}
}
static bool issue_bucket_check_index_op(IoCtx& io_ctx, const string& oid, BucketIndexAioManager *manager,
- struct rgw_cls_check_index_ret *pdata) {
+ rgw_cls_check_index_ret *pdata) {
bufferlist in;
librados::ObjectReadOperation op;
- op.exec(RGW_CLASS, RGW_BUCKET_CHECK_INDEX, in, new ClsBucketIndexOpCtx<struct rgw_cls_check_index_ret>(
+ op.exec(RGW_CLASS, RGW_BUCKET_CHECK_INDEX, in, new ClsBucketIndexOpCtx<rgw_cls_check_index_ret>(
pdata, NULL));
return manager->aio_operate(io_ctx, oid, &op);
}
ret_ctx->put();
}
void handle_completion(int r, bufferlist& outbl) override {
- struct rgw_cls_list_ret ret;
+ rgw_cls_list_ret ret;
try {
auto iter = outbl.cbegin();
decode(ret, iter);
int cls_rgw_get_dir_header_async(IoCtx& io_ctx, string& oid, RGWGetDirHeader_CB *ctx)
{
bufferlist in, out;
- struct rgw_cls_list_op call;
+ rgw_cls_list_op call;
call.num_entries = 0;
encode(call, in);
ObjectReadOperation op;
void cls_rgw_reshard_add(librados::ObjectWriteOperation& op, const cls_rgw_reshard_entry& entry)
{
bufferlist in;
- struct cls_rgw_reshard_add_op call;
+ cls_rgw_reshard_add_op call;
call.entry = entry;
encode(call, in);
op.exec("rgw", "reshard_add", in);
list<cls_rgw_reshard_entry>& entries, bool* is_truncated)
{
bufferlist in, out;
- struct cls_rgw_reshard_list_op call;
+ cls_rgw_reshard_list_op call;
call.marker = marker;
call.max = max;
encode(call, in);
if (r < 0)
return r;
- struct cls_rgw_reshard_list_ret op_ret;
+ cls_rgw_reshard_list_ret op_ret;
auto iter = out.cbegin();
try {
decode(op_ret, iter);
int cls_rgw_reshard_get(librados::IoCtx& io_ctx, const string& oid, cls_rgw_reshard_entry& entry)
{
bufferlist in, out;
- struct cls_rgw_reshard_get_op call;
+ cls_rgw_reshard_get_op call;
call.entry = entry;
encode(call, in);
int r = io_ctx.exec(oid, "rgw", "reshard_get", in, out);
if (r < 0)
return r;
- struct cls_rgw_reshard_get_ret op_ret;
+ cls_rgw_reshard_get_ret op_ret;
auto iter = out.cbegin();
try {
decode(op_ret, iter);
void cls_rgw_reshard_remove(librados::ObjectWriteOperation& op, const cls_rgw_reshard_entry& entry)
{
bufferlist in;
- struct cls_rgw_reshard_remove_op call;
+ cls_rgw_reshard_remove_op call;
call.tenant = entry.tenant;
call.bucket_name = entry.bucket_name;
call.bucket_id = entry.bucket_id;
const cls_rgw_bucket_instance_entry& entry)
{
bufferlist in, out;
- struct cls_rgw_set_bucket_resharding_op call;
+ cls_rgw_set_bucket_resharding_op call;
call.entry = entry;
encode(call, in);
return io_ctx.exec(oid, "rgw", "set_bucket_resharding", in, out);
int cls_rgw_clear_bucket_resharding(librados::IoCtx& io_ctx, const string& oid)
{
bufferlist in, out;
- struct cls_rgw_clear_bucket_resharding_op call;
+ cls_rgw_clear_bucket_resharding_op call;
encode(call, in);
return io_ctx.exec(oid, "rgw", "clear_bucket_resharding", in, out);
}
cls_rgw_bucket_instance_entry *entry)
{
bufferlist in, out;
- struct cls_rgw_get_bucket_resharding_op call;
+ cls_rgw_get_bucket_resharding_op call;
encode(call, in);
int r= io_ctx.exec(oid, "rgw", "get_bucket_resharding", in, out);
if (r < 0)
return r;
- struct cls_rgw_get_bucket_resharding_ret op_ret;
+ cls_rgw_get_bucket_resharding_ret op_ret;
auto iter = out.cbegin();
try {
decode(op_ret, iter);
void cls_rgw_guard_bucket_resharding(librados::ObjectOperation& op, int ret_err)
{
bufferlist in, out;
- struct cls_rgw_guard_bucket_resharding_op call;
+ cls_rgw_guard_bucket_resharding_op call;
call.ret_err = ret_err;
encode(call, in);
op.exec("rgw", "guard_bucket_resharding", in);
const cls_rgw_bucket_instance_entry& entry,
BucketIndexAioManager *manager) {
bufferlist in;
- struct cls_rgw_set_bucket_resharding_op call;
+ cls_rgw_set_bucket_resharding_op call;
call.entry = entry;
encode(call, in);
librados::ObjectWriteOperation op;
int cls_rgw_bucket_link_olh(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op,
const string& oid, const cls_rgw_obj_key& key, bufferlist& olh_tag,
- bool delete_marker, const string& op_tag, struct rgw_bucket_dir_entry_meta *meta,
+ bool delete_marker, const string& op_tag, rgw_bucket_dir_entry_meta *meta,
uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time, bool log_op, rgw_zone_set& zones_trace);
int cls_rgw_bucket_unlink_instance(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op,
const string& oid, const cls_rgw_obj_key& key, const string& op_tag,
const string& olh_tag, uint64_t olh_epoch, bool log_op, rgw_zone_set& zones_trace);
int cls_rgw_get_olh_log(librados::IoCtx& io_ctx, string& oid, librados::ObjectReadOperation& op, const cls_rgw_obj_key& olh, uint64_t ver_marker,
const string& olh_tag,
- map<uint64_t, vector<struct rgw_bucket_olh_log_entry> > *log, bool *is_truncated);
+ map<uint64_t, vector<rgw_bucket_olh_log_entry> > *log, bool *is_truncated);
void cls_rgw_trim_olh_log(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& olh, uint64_t ver, const string& olh_tag);
int cls_rgw_clear_olh(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op, string& oid, const cls_rgw_obj_key& olh, const string& olh_tag);
const string& _filter_prefix, uint32_t _num_entries,
bool _list_versions,
map<int, string>& oids,
- map<int, struct rgw_cls_list_ret>& list_results,
+ map<int, rgw_cls_list_ret>& list_results,
uint32_t max_aio) :
CLSRGWConcurrentIO(io_ctx, oids, max_aio),
start_obj(_start_obj), filter_prefix(_filter_prefix), num_entries(_num_entries), list_versions(_list_versions), result(list_results) {}
};
class CLSRGWIssueBILogList : public CLSRGWConcurrentIO {
- map<int, struct cls_rgw_bi_log_list_ret>& result;
+ map<int, cls_rgw_bi_log_list_ret>& result;
BucketIndexShardsManager& marker_mgr;
uint32_t max;
protected:
public:
CLSRGWIssueBILogList(librados::IoCtx& io_ctx, BucketIndexShardsManager& _marker_mgr, uint32_t _max,
map<int, string>& oids,
- map<int, struct cls_rgw_bi_log_list_ret>& bi_log_lists, uint32_t max_aio) :
+ map<int, cls_rgw_bi_log_list_ret>& bi_log_lists, uint32_t max_aio) :
CLSRGWConcurrentIO(io_ctx, oids, max_aio), result(bi_log_lists),
marker_mgr(_marker_mgr), max(_max) {}
};
*
* Return 0 on success, a failure code otherwise.
*/
-class CLSRGWIssueBucketCheck : public CLSRGWConcurrentIO /*<map<string, struct rgw_cls_check_index_ret> >*/ {
- map<int, struct rgw_cls_check_index_ret>& result;
+class CLSRGWIssueBucketCheck : public CLSRGWConcurrentIO /*<map<string, rgw_cls_check_index_ret> >*/ {
+ map<int, rgw_cls_check_index_ret>& result;
protected:
int issue_op(int shard_id, const string& oid) override;
public:
- CLSRGWIssueBucketCheck(librados::IoCtx& ioc, map<int, string>& oids, map<int, struct rgw_cls_check_index_ret>& bucket_objs_ret,
- uint32_t _max_aio) :
+ CLSRGWIssueBucketCheck(librados::IoCtx& ioc, map<int, string>& oids,
+ map<int, rgw_cls_check_index_ret>& bucket_objs_ret,
+ uint32_t _max_aio) :
CLSRGWConcurrentIO(ioc, oids, _max_aio), result(bucket_objs_ret) {}
};
cls_rgw_obj_key key;
string locator;
rgw_bucket_entry_ver ver;
- struct rgw_bucket_dir_entry_meta meta;
+ rgw_bucket_dir_entry_meta meta;
string tag;
bool log_op;
uint16_t bilog_flags;
string olh_tag;
bool delete_marker;
string op_tag;
- struct rgw_bucket_dir_entry_meta meta;
+ rgw_bucket_dir_entry_meta meta;
uint64_t olh_epoch;
bool log_op;
uint16_t bilog_flags;
struct rgw_cls_read_olh_log_ret
{
- map<uint64_t, vector<struct rgw_bucket_olh_log_entry> > log;
+ map<uint64_t, vector<rgw_bucket_olh_log_entry> > log;
bool is_truncated;
rgw_cls_read_olh_log_ret() : is_truncated(false) {}
f->open_object_section("header");
header.dump(f);
f->close_section();
- map<string, struct rgw_bucket_dir_entry>::const_iterator iter = m.begin();
+ map<string, rgw_bucket_dir_entry>::const_iterator iter = m.begin();
f->open_array_section("map");
for (; iter != m.end(); ++iter) {
f->dump_string("key", iter->first);
rgw_bucket_entry_ver ver;
std::string locator;
bool exists;
- struct rgw_bucket_dir_entry_meta meta;
- multimap<string, struct rgw_bucket_pending_info> pending_map;
+ rgw_bucket_dir_entry_meta meta;
+ multimap<string, rgw_bucket_pending_info> pending_map;
uint64_t index_ver;
string tag;
uint16_t flags;
WRITE_CLASS_ENCODER(rgw_bucket_dir_header)
struct rgw_bucket_dir {
- struct rgw_bucket_dir_header header;
- std::map<string, struct rgw_bucket_dir_entry> m;
+ rgw_bucket_dir_header header;
+ std::map<string, rgw_bucket_dir_entry> m;
void encode(bufferlist &bl) const {
ENCODE_START(2, 2, bl);
projects / ceph.git / commitdiff