2 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
3 // vim: ts=8 sw=2 smarttab
5 #include "include/compat.h"
9 #include <boost/algorithm/string.hpp>
11 #include <boost/format.hpp>
12 #include <boost/optional.hpp>
13 #include <boost/utility/in_place_factory.hpp>
15 #include "common/ceph_json.h"
16 #include "common/utf8.h"
18 #include "common/errno.h"
19 #include "common/Formatter.h"
20 #include "common/Throttle.h"
21 #include "common/Finisher.h"
23 #include "rgw_rados.h"
24 #include "rgw_cache.h"
26 #include "rgw_acl_s3.h" /* for dumping s3policy in debug log */
27 #include "rgw_metadata.h"
28 #include "rgw_bucket.h"
29 #include "rgw_rest_conn.h"
30 #include "rgw_cr_rados.h"
31 #include "rgw_cr_rest.h"
33 #include "cls/rgw/cls_rgw_ops.h"
34 #include "cls/rgw/cls_rgw_types.h"
35 #include "cls/rgw/cls_rgw_client.h"
36 #include "cls/rgw/cls_rgw_const.h"
37 #include "cls/refcount/cls_refcount_client.h"
38 #include "cls/version/cls_version_client.h"
39 #include "cls/log/cls_log_client.h"
40 #include "cls/statelog/cls_statelog_client.h"
41 #include "cls/timeindex/cls_timeindex_client.h"
42 #include "cls/lock/cls_lock_client.h"
43 #include "cls/user/cls_user_client.h"
44 #include "osd/osd_types.h"
46 #include "rgw_tools.h"
47 #include "rgw_coroutine.h"
48 #include "rgw_compression.h"
50 #undef fork // fails to compile RGWPeriod::fork() below
52 #include "common/Clock.h"
54 #include "include/rados/librados.hpp"
55 using namespace librados;
63 #include "auth/Crypto.h" // get_random_bytes()
70 #include "rgw_object_expirer_core.h"
72 #include "rgw_data_sync.h"
73 #include "rgw_realm_watcher.h"
74 #include "rgw_reshard.h"
76 #include "compressor/Compressor.h"
78 #define dout_context g_ceph_context
79 #define dout_subsys ceph_subsys_rgw
83 static string notify_oid_prefix = "notify";
84 static string *notify_oids = NULL;
85 static string shadow_ns = "shadow";
86 static string dir_oid_prefix = ".dir.";
87 static string default_storage_pool_suffix = "rgw.buckets.data";
88 static string default_bucket_index_pool_suffix = "rgw.buckets.index";
89 static string default_storage_extra_pool_suffix = "rgw.buckets.non-ec";
90 static string avail_pools = ".pools.avail";
92 static string zone_info_oid_prefix = "zone_info.";
93 static string zone_names_oid_prefix = "zone_names.";
94 static string region_info_oid_prefix = "region_info.";
95 static string zone_group_info_oid_prefix = "zonegroup_info.";
96 static string realm_names_oid_prefix = "realms_names.";
97 static string realm_info_oid_prefix = "realms.";
98 static string default_region_info_oid = "default.region";
99 static string default_zone_group_info_oid = "default.zonegroup";
100 static string period_info_oid_prefix = "periods.";
101 static string period_latest_epoch_info_oid = ".latest_epoch";
102 static string region_map_oid = "region_map";
103 static string zonegroup_map_oid = "zonegroup_map";
104 static string log_lock_name = "rgw_log_lock";
105 static string default_realm_info_oid = "default.realm";
106 const string default_zonegroup_name = "default";
107 const string default_zone_name = "default";
108 static string zonegroup_names_oid_prefix = "zonegroups_names.";
109 static RGWObjCategory main_category = RGW_OBJ_CATEGORY_MAIN;
110 #define RGW_USAGE_OBJ_PREFIX "usage."
111 #define FIRST_EPOCH 1
112 static string RGW_DEFAULT_ZONE_ROOT_POOL = "rgw.root";
113 static string RGW_DEFAULT_ZONEGROUP_ROOT_POOL = "rgw.root";
114 static string RGW_DEFAULT_REALM_ROOT_POOL = "rgw.root";
115 static string RGW_DEFAULT_PERIOD_ROOT_POOL = "rgw.root";
117 #define RGW_STATELOG_OBJ_PREFIX "statelog."
119 #define dout_subsys ceph_subsys_rgw
122 static bool rgw_get_obj_data_pool(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params,
123 const string& placement_id, const rgw_obj& obj, rgw_pool *pool)
125 if (!zone_params.get_head_data_pool(placement_id, obj, pool)) {
126 RGWZonePlacementInfo placement;
127 if (!zone_params.get_placement(zonegroup.default_placement, &placement)) {
131 if (!obj.in_extra_data) {
132 *pool = placement.data_pool;
134 *pool = placement.get_data_extra_pool();
141 static bool rgw_obj_to_raw(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params,
142 const string& placement_id, const rgw_obj& obj, rgw_raw_obj *raw_obj)
144 get_obj_bucket_and_oid_loc(obj, raw_obj->oid, raw_obj->loc);
146 return rgw_get_obj_data_pool(zonegroup, zone_params, placement_id, obj, &raw_obj->pool);
149 rgw_raw_obj rgw_obj_select::get_raw_obj(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params) const
153 rgw_obj_to_raw(zonegroup, zone_params, placement_rule, obj, &r);
159 rgw_raw_obj rgw_obj_select::get_raw_obj(RGWRados *store) const
163 store->obj_to_raw(placement_rule, obj, &r);
169 int rgw_init_ioctx(librados::Rados *rados, const rgw_pool& pool, IoCtx& ioctx, bool create)
171 int r = rados->ioctx_create(pool.name.c_str(), ioctx);
172 if (r == -ENOENT && create) {
173 r = rados->pool_create(pool.name.c_str());
174 if (r < 0 && r != -EEXIST) {
178 r = rados->ioctx_create(pool.name.c_str(), ioctx);
183 r = ioctx.application_enable(pg_pool_t::APPLICATION_NAME_RGW, false);
184 if (r < 0 && r != -EOPNOTSUPP) {
190 if (!pool.ns.empty()) {
191 ioctx.set_namespace(pool.ns);
197 void RGWObjectCtxImpl<rgw_obj, RGWObjState>::invalidate(rgw_obj& obj) {
198 RWLock::WLocker wl(lock);
199 auto iter = objs_state.find(obj);
200 if (iter == objs_state.end()) {
203 bool is_atomic = iter->second.is_atomic;
204 bool prefetch_data = iter->second.prefetch_data;
206 objs_state.erase(iter);
208 if (is_atomic || prefetch_data) {
209 auto& s = objs_state[obj];
210 s.is_atomic = is_atomic;
211 s.prefetch_data = prefetch_data;
216 void RGWObjectCtxImpl<rgw_raw_obj, RGWRawObjState>::invalidate(rgw_raw_obj& obj) {
217 RWLock::WLocker wl(lock);
218 auto iter = objs_state.find(obj);
219 if (iter == objs_state.end()) {
223 objs_state.erase(iter);
226 void RGWDefaultZoneGroupInfo::dump(Formatter *f) const {
227 encode_json("default_zonegroup", default_zonegroup, f);
230 void RGWDefaultZoneGroupInfo::decode_json(JSONObj *obj) {
232 JSONDecoder::decode_json("default_zonegroup", default_zonegroup, obj);
233 /* backward compatability with region */
234 if (default_zonegroup.empty()) {
235 JSONDecoder::decode_json("default_region", default_zonegroup, obj);
239 rgw_pool RGWZoneGroup::get_pool(CephContext *cct_)
241 if (cct_->_conf->rgw_zonegroup_root_pool.empty()) {
242 return rgw_pool(RGW_DEFAULT_ZONEGROUP_ROOT_POOL);
245 return rgw_pool(cct_->_conf->rgw_zonegroup_root_pool);
248 int RGWZoneGroup::create_default(bool old_format)
250 name = default_zonegroup_name;
253 RGWZoneGroupPlacementTarget placement_target;
254 placement_target.name = "default-placement";
255 placement_targets[placement_target.name] = placement_target;
256 default_placement = "default-placement";
258 RGWZoneParams zone_params(default_zone_name);
260 int r = zone_params.init(cct, store, false);
262 ldout(cct, 0) << "create_default: error initializing zone params: " << cpp_strerror(-r) << dendl;
266 r = zone_params.create_default();
267 if (r < 0 && r != -EEXIST) {
268 ldout(cct, 0) << "create_default: error in create_default zone params: " << cpp_strerror(-r) << dendl;
270 } else if (r == -EEXIST) {
271 ldout(cct, 10) << "zone_params::create_default() returned -EEXIST, we raced with another default zone_params creation" << dendl;
272 zone_params.clear_id();
273 r = zone_params.init(cct, store);
275 ldout(cct, 0) << "create_default: error in init existing zone params: " << cpp_strerror(-r) << dendl;
278 ldout(cct, 20) << "zone_params::create_default() " << zone_params.get_name() << " id " << zone_params.get_id()
282 RGWZone& default_zone = zones[zone_params.get_id()];
283 default_zone.name = zone_params.get_name();
284 default_zone.id = zone_params.get_id();
285 master_zone = default_zone.id;
288 if (r < 0 && r != -EEXIST) {
289 ldout(cct, 0) << "error storing zone group info: " << cpp_strerror(-r) << dendl;
294 ldout(cct, 10) << "create_default() returned -EEXIST, we raced with another zonegroup creation" << dendl;
296 r = init(cct, store);
306 post_process_params();
311 const string RGWZoneGroup::get_default_oid(bool old_region_format)
313 if (old_region_format) {
314 if (cct->_conf->rgw_default_region_info_oid.empty()) {
315 return default_region_info_oid;
317 return cct->_conf->rgw_default_region_info_oid;
320 string default_oid = cct->_conf->rgw_default_zonegroup_info_oid;
322 if (cct->_conf->rgw_default_zonegroup_info_oid.empty()) {
323 default_oid = default_zone_group_info_oid;
326 default_oid += "." + realm_id;
331 const string& RGWZoneGroup::get_info_oid_prefix(bool old_region_format)
333 if (old_region_format) {
334 return region_info_oid_prefix;
336 return zone_group_info_oid_prefix;
339 const string& RGWZoneGroup::get_names_oid_prefix()
341 return zonegroup_names_oid_prefix;
344 const string& RGWZoneGroup::get_predefined_name(CephContext *cct) {
345 return cct->_conf->rgw_zonegroup;
348 int RGWZoneGroup::equals(const string& other_zonegroup) const
350 if (is_master && other_zonegroup.empty())
353 return (id == other_zonegroup);
356 int RGWZoneGroup::add_zone(const RGWZoneParams& zone_params, bool *is_master, bool *read_only,
357 const list<string>& endpoints, const string *ptier_type,
358 bool *psync_from_all, list<string>& sync_from, list<string>& sync_from_rm)
360 auto& zone_id = zone_params.get_id();
361 auto& zone_name = zone_params.get_name();
363 // check for duplicate zone name on insert
364 if (!zones.count(zone_id)) {
365 for (const auto& zone : zones) {
366 if (zone.second.name == zone_name) {
367 ldout(cct, 0) << "ERROR: found existing zone name " << zone_name
368 << " (" << zone.first << ") in zonegroup " << get_name() << dendl;
376 if (!master_zone.empty() && master_zone != zone_params.get_id()) {
377 ldout(cct, 0) << "NOTICE: overriding master zone: " << master_zone << dendl;
379 master_zone = zone_params.get_id();
380 } else if (master_zone == zone_params.get_id()) {
385 RGWZone& zone = zones[zone_params.get_id()];
386 zone.name = zone_params.get_name();
387 zone.id = zone_params.get_id();
388 if (!endpoints.empty()) {
389 zone.endpoints = endpoints;
392 zone.read_only = *read_only;
395 zone.tier_type = *ptier_type;
398 if (psync_from_all) {
399 zone.sync_from_all = *psync_from_all;
402 for (auto add : sync_from) {
403 zone.sync_from.insert(add);
406 for (auto rm : sync_from_rm) {
407 zone.sync_from.erase(rm);
410 post_process_params();
416 int RGWZoneGroup::rename_zone(const RGWZoneParams& zone_params)
418 RGWZone& zone = zones[zone_params.get_id()];
419 zone.name = zone_params.get_name();
424 void RGWZoneGroup::post_process_params()
426 bool log_data = zones.size() > 1;
428 if (master_zone.empty()) {
429 map<string, RGWZone>::iterator iter = zones.begin();
430 if (iter != zones.end()) {
431 master_zone = iter->first;
435 for (map<string, RGWZone>::iterator iter = zones.begin(); iter != zones.end(); ++iter) {
436 RGWZone& zone = iter->second;
437 zone.log_data = log_data;
439 RGWZoneParams zone_params(zone.id, zone.name);
440 int ret = zone_params.init(cct, store);
442 ldout(cct, 0) << "WARNING: could not read zone params for zone id=" << zone.id << " name=" << zone.name << dendl;
446 for (map<string, RGWZonePlacementInfo>::iterator iter = zone_params.placement_pools.begin();
447 iter != zone_params.placement_pools.end(); ++iter) {
448 const string& placement_name = iter->first;
449 if (placement_targets.find(placement_name) == placement_targets.end()) {
450 RGWZoneGroupPlacementTarget placement_target;
451 placement_target.name = placement_name;
452 placement_targets[placement_name] = placement_target;
457 if (default_placement.empty() && !placement_targets.empty()) {
458 default_placement = placement_targets.begin()->first;
462 int RGWZoneGroup::remove_zone(const std::string& zone_id)
464 map<string, RGWZone>::iterator iter = zones.find(zone_id);
465 if (iter == zones.end()) {
466 ldout(cct, 0) << "zone id " << zone_id << " is not a part of zonegroup "
473 post_process_params();
478 int RGWZoneGroup::read_default_id(string& default_id, bool old_format)
480 if (realm_id.empty()) {
481 /* try using default realm */
483 int ret = realm.init(cct, store);
485 ldout(cct, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
488 realm_id = realm.get_id();
491 return RGWSystemMetaObj::read_default_id(default_id, old_format);
494 int RGWZoneGroup::set_as_default(bool exclusive)
496 if (realm_id.empty()) {
497 /* try using default realm */
499 int ret = realm.init(cct, store);
501 ldout(cct, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
504 realm_id = realm.get_id();
507 return RGWSystemMetaObj::set_as_default(exclusive);
510 int RGWSystemMetaObj::init(CephContext *_cct, RGWRados *_store, bool setup_obj, bool old_format)
518 if (old_format && id.empty()) {
525 name = get_predefined_name(cct);
528 r = use_default(old_format);
532 } else if (!old_format) {
533 r = read_id(name, id);
536 ldout(cct, 0) << "error in read_id for object name: " << name << " : " << cpp_strerror(-r) << dendl;
543 return read_info(id, old_format);
546 int RGWSystemMetaObj::read_default(RGWDefaultSystemMetaObjInfo& default_info, const string& oid)
548 auto pool = get_pool(cct);
550 RGWObjectCtx obj_ctx(store);
551 int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
556 bufferlist::iterator iter = bl.begin();
557 ::decode(default_info, iter);
558 } catch (buffer::error& err) {
559 ldout(cct, 0) << "error decoding data from " << pool << ":" << oid << dendl;
566 int RGWSystemMetaObj::read_default_id(string& default_id, bool old_format)
568 RGWDefaultSystemMetaObjInfo default_info;
570 int ret = read_default(default_info, get_default_oid(old_format));
575 default_id = default_info.default_id;
580 int RGWSystemMetaObj::use_default(bool old_format)
582 return read_default_id(id, old_format);
585 int RGWSystemMetaObj::set_as_default(bool exclusive)
587 string oid = get_default_oid();
589 rgw_pool pool(get_pool(cct));
592 RGWDefaultSystemMetaObjInfo default_info;
593 default_info.default_id = id;
595 ::encode(default_info, bl);
597 int ret = rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
598 exclusive, NULL, real_time(), NULL);
605 int RGWSystemMetaObj::read_id(const string& obj_name, string& object_id)
607 rgw_pool pool(get_pool(cct));
610 string oid = get_names_oid_prefix() + obj_name;
612 RGWObjectCtx obj_ctx(store);
613 int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
618 RGWNameToId nameToId;
620 bufferlist::iterator iter = bl.begin();
621 ::decode(nameToId, iter);
622 } catch (buffer::error& err) {
623 ldout(cct, 0) << "ERROR: failed to decode obj from " << pool << ":" << oid << dendl;
626 object_id = nameToId.obj_id;
630 int RGWSystemMetaObj::delete_obj(bool old_format)
632 rgw_pool pool(get_pool(cct));
634 /* check to see if obj is the default */
635 RGWDefaultSystemMetaObjInfo default_info;
636 int ret = read_default(default_info, get_default_oid(old_format));
637 if (ret < 0 && ret != -ENOENT)
639 if (default_info.default_id == id || (old_format && default_info.default_id == name)) {
640 string oid = get_default_oid(old_format);
641 rgw_raw_obj default_named_obj(pool, oid);
642 ret = store->delete_system_obj(default_named_obj);
644 ldout(cct, 0) << "Error delete default obj name " << name << ": " << cpp_strerror(-ret) << dendl;
649 string oid = get_names_oid_prefix() + name;
650 rgw_raw_obj object_name(pool, oid);
651 ret = store->delete_system_obj(object_name);
653 ldout(cct, 0) << "Error delete obj name " << name << ": " << cpp_strerror(-ret) << dendl;
658 string oid = get_info_oid_prefix(old_format);
665 rgw_raw_obj object_id(pool, oid);
666 ret = store->delete_system_obj(object_id);
668 ldout(cct, 0) << "Error delete object id " << id << ": " << cpp_strerror(-ret) << dendl;
674 int RGWSystemMetaObj::store_name(bool exclusive)
676 rgw_pool pool(get_pool(cct));
677 string oid = get_names_oid_prefix() + name;
679 RGWNameToId nameToId;
680 nameToId.obj_id = id;
683 ::encode(nameToId, bl);
684 return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
687 int RGWSystemMetaObj::rename(const string& new_name)
690 int ret = read_id(new_name, new_id);
694 if (ret < 0 && ret != -ENOENT) {
695 ldout(cct, 0) << "Error read_id " << new_name << ": " << cpp_strerror(-ret) << dendl;
698 string old_name = name;
702 ldout(cct, 0) << "Error storing new obj info " << new_name << ": " << cpp_strerror(-ret) << dendl;
705 ret = store_name(true);
707 ldout(cct, 0) << "Error storing new name " << new_name << ": " << cpp_strerror(-ret) << dendl;
710 /* delete old name */
711 rgw_pool pool(get_pool(cct));
712 string oid = get_names_oid_prefix() + old_name;
713 rgw_raw_obj old_name_obj(pool, oid);
714 ret = store->delete_system_obj(old_name_obj);
716 ldout(cct, 0) << "Error delete old obj name " << old_name << ": " << cpp_strerror(-ret) << dendl;
723 int RGWSystemMetaObj::read_info(const string& obj_id, bool old_format)
725 rgw_pool pool(get_pool(cct));
729 string oid = get_info_oid_prefix(old_format) + obj_id;
731 RGWObjectCtx obj_ctx(store);
732 int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
734 ldout(cct, 0) << "failed reading obj info from " << pool << ":" << oid << ": " << cpp_strerror(-ret) << dendl;
739 bufferlist::iterator iter = bl.begin();
740 ::decode(*this, iter);
741 } catch (buffer::error& err) {
742 ldout(cct, 0) << "ERROR: failed to decode obj from " << pool << ":" << oid << dendl;
749 int RGWSystemMetaObj::read()
751 int ret = read_id(name, id);
756 return read_info(id);
759 int RGWSystemMetaObj::create(bool exclusive)
763 /* check to see the name is not used */
764 ret = read_id(name, id);
765 if (exclusive && ret == 0) {
766 ldout(cct, 10) << "ERROR: name " << name << " already in use for obj id " << id << dendl;
768 } else if ( ret < 0 && ret != -ENOENT) {
769 ldout(cct, 0) << "failed reading obj id " << id << ": " << cpp_strerror(-ret) << dendl;
774 /* create unique id */
777 new_uuid.generate_random();
778 new_uuid.print(uuid_str);
782 ret = store_info(exclusive);
784 ldout(cct, 0) << "ERROR: storing info for " << id << ": " << cpp_strerror(-ret) << dendl;
788 return store_name(exclusive);
791 int RGWSystemMetaObj::store_info(bool exclusive)
793 rgw_pool pool(get_pool(cct));
795 string oid = get_info_oid_prefix() + id;
799 return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
802 int RGWSystemMetaObj::write(bool exclusive)
804 int ret = store_info(exclusive);
806 ldout(cct, 20) << __func__ << "(): store_info() returned ret=" << ret << dendl;
809 ret = store_name(exclusive);
811 ldout(cct, 20) << __func__ << "(): store_name() returned ret=" << ret << dendl;
818 const string& RGWRealm::get_predefined_name(CephContext *cct) {
819 return cct->_conf->rgw_realm;
822 int RGWRealm::create(bool exclusive)
824 int ret = RGWSystemMetaObj::create(exclusive);
826 ldout(cct, 0) << "ERROR creating new realm object " << name << ": " << cpp_strerror(-ret) << dendl;
829 // create the control object for watch/notify
830 ret = create_control(exclusive);
832 ldout(cct, 0) << "ERROR creating control for new realm " << name << ": " << cpp_strerror(-ret) << dendl;
836 if (current_period.empty()) {
837 /* create new period for the realm */
838 ret = period.init(cct, store, id, name, false);
842 ret = period.create(true);
844 ldout(cct, 0) << "ERROR: creating new period for realm " << name << ": " << cpp_strerror(-ret) << dendl;
848 period = RGWPeriod(current_period, 0);
849 int ret = period.init(cct, store, id, name);
851 ldout(cct, 0) << "ERROR: failed to init period " << current_period << dendl;
855 ret = set_current_period(period);
857 ldout(cct, 0) << "ERROR: failed set current period " << current_period << dendl;
860 // try to set as default. may race with another create, so pass exclusive=true
861 // so we don't override an existing default
862 ret = set_as_default(true);
863 if (ret < 0 && ret != -EEXIST) {
864 ldout(cct, 0) << "WARNING: failed to set realm as default realm, ret=" << ret << dendl;
870 int RGWRealm::delete_obj()
872 int ret = RGWSystemMetaObj::delete_obj();
876 return delete_control();
879 int RGWRealm::create_control(bool exclusive)
881 auto pool = rgw_pool{get_pool(cct)};
882 auto oid = get_control_oid();
883 return rgw_put_system_obj(store, pool, oid, nullptr, 0, exclusive,
884 nullptr, real_time(), nullptr);
887 int RGWRealm::delete_control()
889 auto pool = rgw_pool{get_pool(cct)};
890 auto obj = rgw_raw_obj{pool, get_control_oid()};
891 return store->delete_system_obj(obj);
894 rgw_pool RGWRealm::get_pool(CephContext *cct)
896 if (cct->_conf->rgw_realm_root_pool.empty()) {
897 return rgw_pool(RGW_DEFAULT_REALM_ROOT_POOL);
899 return rgw_pool(cct->_conf->rgw_realm_root_pool);
902 const string RGWRealm::get_default_oid(bool old_format)
904 if (cct->_conf->rgw_default_realm_info_oid.empty()) {
905 return default_realm_info_oid;
907 return cct->_conf->rgw_default_realm_info_oid;
910 const string& RGWRealm::get_names_oid_prefix()
912 return realm_names_oid_prefix;
915 const string& RGWRealm::get_info_oid_prefix(bool old_format)
917 return realm_info_oid_prefix;
920 int RGWRealm::set_current_period(RGWPeriod& period)
922 // update realm epoch to match the period's
923 if (epoch > period.get_realm_epoch()) {
924 ldout(cct, 0) << "ERROR: set_current_period with old realm epoch "
925 << period.get_realm_epoch() << ", current epoch=" << epoch << dendl;
928 if (epoch == period.get_realm_epoch() && current_period != period.get_id()) {
929 ldout(cct, 0) << "ERROR: set_current_period with same realm epoch "
930 << period.get_realm_epoch() << ", but different period id "
931 << period.get_id() << " != " << current_period << dendl;
935 epoch = period.get_realm_epoch();
936 current_period = period.get_id();
940 ldout(cct, 0) << "ERROR: period update: " << cpp_strerror(-ret) << dendl;
944 ret = period.reflect();
946 ldout(cct, 0) << "ERROR: period.reflect(): " << cpp_strerror(-ret) << dendl;
953 string RGWRealm::get_control_oid()
955 return get_info_oid_prefix() + id + ".control";
958 int RGWRealm::notify_zone(bufferlist& bl)
960 // open a context on the realm's pool
961 rgw_pool pool{get_pool(cct)};
963 int r = rgw_init_ioctx(store->get_rados_handle(), pool, ctx);
965 ldout(cct, 0) << "Failed to open pool " << pool << dendl;
968 // send a notify on the realm object
969 r = ctx.notify2(get_control_oid(), bl, 0, nullptr);
971 ldout(cct, 0) << "Realm notify failed with " << r << dendl;
977 int RGWRealm::notify_new_period(const RGWPeriod& period)
980 // push the period to dependent zonegroups/zones
981 ::encode(RGWRealmNotify::ZonesNeedPeriod, bl);
982 ::encode(period, bl);
983 // reload the gateway with the new period
984 ::encode(RGWRealmNotify::Reload, bl);
986 return notify_zone(bl);
989 std::string RGWPeriodConfig::get_oid(const std::string& realm_id)
991 if (realm_id.empty()) {
992 return "period_config.default";
994 return "period_config." + realm_id;
997 rgw_pool RGWPeriodConfig::get_pool(CephContext *cct)
999 const auto& pool_name = cct->_conf->rgw_period_root_pool;
1000 if (pool_name.empty()) {
1001 return {RGW_DEFAULT_PERIOD_ROOT_POOL};
1006 int RGWPeriodConfig::read(RGWRados *store, const std::string& realm_id)
1008 RGWObjectCtx obj_ctx(store);
1009 const auto& pool = get_pool(store->ctx());
1010 const auto& oid = get_oid(realm_id);
1013 int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, nullptr, nullptr);
1018 bufferlist::iterator iter = bl.begin();
1019 ::decode(*this, iter);
1020 } catch (buffer::error& err) {
1026 int RGWPeriodConfig::write(RGWRados *store, const std::string& realm_id)
1028 const auto& pool = get_pool(store->ctx());
1029 const auto& oid = get_oid(realm_id);
1031 ::encode(*this, bl);
1032 return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
1033 false, nullptr, real_time(), nullptr);
1036 int RGWPeriod::init(CephContext *_cct, RGWRados *_store, const string& period_realm_id,
1037 const string& period_realm_name, bool setup_obj)
1041 realm_id = period_realm_id;
1042 realm_name = period_realm_name;
1047 return init(_cct, _store, setup_obj);
1051 int RGWPeriod::init(CephContext *_cct, RGWRados *_store, bool setup_obj)
1060 RGWRealm realm(realm_id, realm_name);
1061 int ret = realm.init(cct, store);
1063 ldout(cct, 0) << "RGWPeriod::init failed to init realm " << realm_name << " id " << realm_id << " : " <<
1064 cpp_strerror(-ret) << dendl;
1067 id = realm.get_current_period();
1068 realm_id = realm.get_id();
1072 int ret = use_latest_epoch();
1074 ldout(cct, 0) << "failed to use_latest_epoch period id " << id << " realm " << realm_name << " id " << realm_id
1075 << " : " << cpp_strerror(-ret) << dendl;
1084 int RGWPeriod::get_zonegroup(RGWZoneGroup& zonegroup, const string& zonegroup_id) {
1085 map<string, RGWZoneGroup>::const_iterator iter;
1086 if (!zonegroup_id.empty()) {
1087 iter = period_map.zonegroups.find(zonegroup_id);
1089 iter = period_map.zonegroups.find("default");
1091 if (iter != period_map.zonegroups.end()) {
1092 zonegroup = iter->second;
1099 const string& RGWPeriod::get_latest_epoch_oid()
1101 if (cct->_conf->rgw_period_latest_epoch_info_oid.empty()) {
1102 return period_latest_epoch_info_oid;
1104 return cct->_conf->rgw_period_latest_epoch_info_oid;
1107 const string& RGWPeriod::get_info_oid_prefix()
1109 return period_info_oid_prefix;
1112 const string RGWPeriod::get_period_oid_prefix()
1114 return get_info_oid_prefix() + id;
1117 const string RGWPeriod::get_period_oid()
1119 std::ostringstream oss;
1120 oss << get_period_oid_prefix();
1121 // skip the epoch for the staging period
1122 if (id != get_staging_id(realm_id))
1123 oss << "." << epoch;
1127 int RGWPeriod::read_latest_epoch(RGWPeriodLatestEpochInfo& info,
1128 RGWObjVersionTracker *objv)
1130 string oid = get_period_oid_prefix() + get_latest_epoch_oid();
1132 rgw_pool pool(get_pool(cct));
1134 RGWObjectCtx obj_ctx(store);
1135 int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, objv, nullptr);
1137 ldout(cct, 1) << "error read_lastest_epoch " << pool << ":" << oid << dendl;
1141 bufferlist::iterator iter = bl.begin();
1142 ::decode(info, iter);
1143 } catch (buffer::error& err) {
1144 ldout(cct, 0) << "error decoding data from " << pool << ":" << oid << dendl;
1151 int RGWPeriod::get_latest_epoch(epoch_t& latest_epoch)
1153 RGWPeriodLatestEpochInfo info;
1155 int ret = read_latest_epoch(info);
1160 latest_epoch = info.epoch;
1165 int RGWPeriod::use_latest_epoch()
1167 RGWPeriodLatestEpochInfo info;
1168 int ret = read_latest_epoch(info);
1178 int RGWPeriod::set_latest_epoch(epoch_t epoch, bool exclusive,
1179 RGWObjVersionTracker *objv)
1181 string oid = get_period_oid_prefix() + get_latest_epoch_oid();
1183 rgw_pool pool(get_pool(cct));
1186 RGWPeriodLatestEpochInfo info;
1191 return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
1192 exclusive, objv, real_time(), nullptr);
1195 int RGWPeriod::update_latest_epoch(epoch_t epoch)
1197 static constexpr int MAX_RETRIES = 20;
1199 for (int i = 0; i < MAX_RETRIES; i++) {
1200 RGWPeriodLatestEpochInfo info;
1201 RGWObjVersionTracker objv;
1202 bool exclusive = false;
1204 // read existing epoch
1205 int r = read_latest_epoch(info, &objv);
1207 // use an exclusive create to set the epoch atomically
1209 ldout(cct, 20) << "creating initial latest_epoch=" << epoch
1210 << " for period=" << id << dendl;
1212 ldout(cct, 0) << "ERROR: failed to read latest_epoch" << dendl;
1214 } else if (epoch <= info.epoch) {
1215 r = -EEXIST; // fail with EEXIST if epoch is not newer
1216 ldout(cct, 1) << "found existing latest_epoch " << info.epoch
1217 << " >= given epoch " << epoch << ", returning r=" << r << dendl;
1220 ldout(cct, 20) << "updating latest_epoch from " << info.epoch
1221 << " -> " << epoch << " on period=" << id << dendl;
1224 r = set_latest_epoch(epoch, exclusive, &objv);
1226 continue; // exclusive create raced with another update, retry
1227 } else if (r == -ECANCELED) {
1228 continue; // write raced with a conflicting version, retry
1231 ldout(cct, 0) << "ERROR: failed to write latest_epoch" << dendl;
1234 return 0; // return success
1237 return -ECANCELED; // fail after max retries
1240 int RGWPeriod::delete_obj()
1242 rgw_pool pool(get_pool(cct));
1244 // delete the object for each period epoch
1245 for (epoch_t e = 1; e <= epoch; e++) {
1246 RGWPeriod p{get_id(), e};
1247 rgw_raw_obj oid{pool, p.get_period_oid()};
1248 int ret = store->delete_system_obj(oid);
1250 ldout(cct, 0) << "WARNING: failed to delete period object " << oid
1251 << ": " << cpp_strerror(-ret) << dendl;
1255 // delete the .latest_epoch object
1256 rgw_raw_obj oid{pool, get_period_oid_prefix() + get_latest_epoch_oid()};
1257 int ret = store->delete_system_obj(oid);
1259 ldout(cct, 0) << "WARNING: failed to delete period object " << oid
1260 << ": " << cpp_strerror(-ret) << dendl;
1265 int RGWPeriod::read_info()
1267 rgw_pool pool(get_pool(cct));
1271 RGWObjectCtx obj_ctx(store);
1272 int ret = rgw_get_system_obj(store, obj_ctx, pool, get_period_oid(), bl, NULL, NULL);
1274 ldout(cct, 0) << "failed reading obj info from " << pool << ":" << get_period_oid() << ": " << cpp_strerror(-ret) << dendl;
1279 bufferlist::iterator iter = bl.begin();
1280 ::decode(*this, iter);
1281 } catch (buffer::error& err) {
1282 ldout(cct, 0) << "ERROR: failed to decode obj from " << pool << ":" << get_period_oid() << dendl;
1289 int RGWPeriod::create(bool exclusive)
1293 /* create unique id */
1296 new_uuid.generate_random();
1297 new_uuid.print(uuid_str);
1300 epoch = FIRST_EPOCH;
1304 ret = store_info(exclusive);
1306 ldout(cct, 0) << "ERROR: storing info for " << id << ": " << cpp_strerror(-ret) << dendl;
1310 ret = set_latest_epoch(epoch);
1312 ldout(cct, 0) << "ERROR: setting latest epoch " << id << ": " << cpp_strerror(-ret) << dendl;
1318 int RGWPeriod::store_info(bool exclusive)
1320 rgw_pool pool(get_pool(cct));
1322 string oid = get_period_oid();
1324 ::encode(*this, bl);
1326 return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
1327 exclusive, NULL, real_time(), NULL);
1330 rgw_pool RGWPeriod::get_pool(CephContext *cct)
1332 if (cct->_conf->rgw_period_root_pool.empty()) {
1333 return rgw_pool(RGW_DEFAULT_PERIOD_ROOT_POOL);
1335 return rgw_pool(cct->_conf->rgw_period_root_pool);
1338 int RGWPeriod::add_zonegroup(const RGWZoneGroup& zonegroup)
1340 if (zonegroup.realm_id != realm_id) {
1343 int ret = period_map.update(zonegroup, cct);
1345 ldout(cct, 0) << "ERROR: updating period map: " << cpp_strerror(-ret) << dendl;
1349 return store_info(false);
1352 int RGWPeriod::update()
1354 ldout(cct, 20) << __func__ << " realm " << realm_id << " period " << get_id() << dendl;
1355 list<string> zonegroups;
1356 int ret = store->list_zonegroups(zonegroups);
1358 ldout(cct, 0) << "ERROR: failed to list zonegroups: " << cpp_strerror(-ret) << dendl;
1362 // clear zone short ids of removed zones. period_map.update() will add the
1363 // remaining zones back
1364 period_map.short_zone_ids.clear();
1366 for (auto& iter : zonegroups) {
1367 RGWZoneGroup zg(string(), iter);
1368 ret = zg.init(cct, store);
1370 ldout(cct, 0) << "WARNING: zg.init() failed: " << cpp_strerror(-ret) << dendl;
1374 if (zg.realm_id != realm_id) {
1375 ldout(cct, 20) << "skipping zonegroup " << zg.get_name() << " zone realm id " << zg.realm_id << ", not on our realm " << realm_id << dendl;
1379 if (zg.master_zone.empty()) {
1380 ldout(cct, 0) << "ERROR: zonegroup " << zg.get_name() << " should have a master zone " << dendl;
1384 if (zg.is_master_zonegroup()) {
1385 master_zonegroup = zg.get_id();
1386 master_zone = zg.master_zone;
1389 int ret = period_map.update(zg, cct);
1395 ret = period_config.read(store, realm_id);
1396 if (ret < 0 && ret != -ENOENT) {
1397 ldout(cct, 0) << "ERROR: failed to read period config: "
1398 << cpp_strerror(ret) << dendl;
1404 int RGWPeriod::reflect()
1406 for (auto& iter : period_map.zonegroups) {
1407 RGWZoneGroup& zg = iter.second;
1408 zg.reinit_instance(cct, store);
1409 int r = zg.write(false);
1411 ldout(cct, 0) << "ERROR: failed to store zonegroup info for zonegroup=" << iter.first << ": " << cpp_strerror(-r) << dendl;
1414 if (zg.is_master_zonegroup()) {
1415 // set master as default if no default exists
1416 r = zg.set_as_default(true);
1418 ldout(cct, 1) << "Set the period's master zonegroup " << zg.get_id()
1419 << " as the default" << dendl;
1424 int r = period_config.write(store, realm_id);
1426 ldout(cct, 0) << "ERROR: failed to store period config: "
1427 << cpp_strerror(-r) << dendl;
1433 void RGWPeriod::fork()
1435 ldout(cct, 20) << __func__ << " realm " << realm_id << " period " << id << dendl;
1436 predecessor_uuid = id;
1437 id = get_staging_id(realm_id);
1442 static int read_sync_status(RGWRados *store, rgw_meta_sync_status *sync_status)
1444 // initialize a sync status manager to read the status
1445 RGWMetaSyncStatusManager mgr(store, store->get_async_rados());
1450 r = mgr.read_sync_status(sync_status);
1455 int RGWPeriod::update_sync_status(const RGWPeriod ¤t_period,
1456 std::ostream& error_stream,
1457 bool force_if_stale)
1459 rgw_meta_sync_status status;
1460 int r = read_sync_status(store, &status);
1462 ldout(cct, 0) << "period failed to read sync status: "
1463 << cpp_strerror(-r) << dendl;
1467 std::vector<std::string> markers;
1469 const auto current_epoch = current_period.get_realm_epoch();
1470 if (current_epoch != status.sync_info.realm_epoch) {
1471 // no sync status markers for the current period
1472 assert(current_epoch > status.sync_info.realm_epoch);
1473 const int behind = current_epoch - status.sync_info.realm_epoch;
1474 if (!force_if_stale && current_epoch > 1) {
1475 error_stream << "ERROR: This zone is " << behind << " period(s) behind "
1476 "the current master zone in metadata sync. If this zone is promoted "
1477 "to master, any metadata changes during that time are likely to "
1479 "Waiting for this zone to catch up on metadata sync (see "
1480 "'radosgw-admin sync status') is recommended.\n"
1481 "To promote this zone to master anyway, add the flag "
1482 "--yes-i-really-mean-it." << std::endl;
1485 // empty sync status markers - other zones will skip this period during
1486 // incremental metadata sync
1487 markers.resize(status.sync_info.num_shards);
1489 markers.reserve(status.sync_info.num_shards);
1490 for (auto& i : status.sync_markers) {
1491 auto& marker = i.second;
1492 // filter out markers from other periods
1493 if (marker.realm_epoch != current_epoch) {
1494 marker.marker.clear();
1496 markers.emplace_back(std::move(marker.marker));
1500 std::swap(sync_status, markers);
1504 int RGWPeriod::commit(RGWRealm& realm, const RGWPeriod& current_period,
1505 std::ostream& error_stream, bool force_if_stale)
1507 ldout(cct, 20) << __func__ << " realm " << realm.get_id() << " period " << current_period.get_id() << dendl;
1508 // gateway must be in the master zone to commit
1509 if (master_zone != store->get_zone_params().get_id()) {
1510 error_stream << "Cannot commit period on zone "
1511 << store->get_zone_params().get_id() << ", it must be sent to "
1512 "the period's master zone " << master_zone << '.' << std::endl;
1515 // period predecessor must match current period
1516 if (predecessor_uuid != current_period.get_id()) {
1517 error_stream << "Period predecessor " << predecessor_uuid
1518 << " does not match current period " << current_period.get_id()
1519 << ". Use 'period pull' to get the latest period from the master, "
1520 "reapply your changes, and try again." << std::endl;
1523 // realm epoch must be 1 greater than current period
1524 if (realm_epoch != current_period.get_realm_epoch() + 1) {
1525 error_stream << "Period's realm epoch " << realm_epoch
1526 << " does not come directly after current realm epoch "
1527 << current_period.get_realm_epoch() << ". Use 'realm pull' to get the "
1528 "latest realm and period from the master zone, reapply your changes, "
1529 "and try again." << std::endl;
1532 // did the master zone change?
1533 if (master_zone != current_period.get_master_zone()) {
1534 // store the current metadata sync status in the period
1535 int r = update_sync_status(current_period, error_stream, force_if_stale);
1537 ldout(cct, 0) << "failed to update metadata sync status: "
1538 << cpp_strerror(-r) << dendl;
1541 // create an object with a new period id
1544 ldout(cct, 0) << "failed to create new period: " << cpp_strerror(-r) << dendl;
1547 // set as current period
1548 r = realm.set_current_period(*this);
1550 ldout(cct, 0) << "failed to update realm's current period: "
1551 << cpp_strerror(-r) << dendl;
1554 ldout(cct, 4) << "Promoted to master zone and committed new period "
1556 realm.notify_new_period(*this);
1559 // period must be based on current epoch
1560 if (epoch != current_period.get_epoch()) {
1561 error_stream << "Period epoch " << epoch << " does not match "
1562 "predecessor epoch " << current_period.get_epoch()
1563 << ". Use 'period pull' to get the latest epoch from the master zone, "
1564 "reapply your changes, and try again." << std::endl;
1567 // set period as next epoch
1568 set_id(current_period.get_id());
1569 set_epoch(current_period.get_epoch() + 1);
1570 set_predecessor(current_period.get_predecessor());
1571 realm_epoch = current_period.get_realm_epoch();
1572 // write the period to rados
1573 int r = store_info(false);
1575 ldout(cct, 0) << "failed to store period: " << cpp_strerror(-r) << dendl;
1578 // set as latest epoch
1579 r = update_latest_epoch(epoch);
1581 // already have this epoch (or a more recent one)
1585 ldout(cct, 0) << "failed to set latest epoch: " << cpp_strerror(-r) << dendl;
1590 ldout(cct, 0) << "failed to update local objects: " << cpp_strerror(-r) << dendl;
1593 ldout(cct, 4) << "Committed new epoch " << epoch
1594 << " for period " << id << dendl;
1595 realm.notify_new_period(*this);
1599 int RGWZoneParams::create_default(bool old_format)
1601 name = default_zone_name;
1616 int get_zones_pool_set(CephContext* cct,
1618 const list<string>& zones,
1619 const string& my_zone_id,
1620 set<rgw_pool>& pool_names)
1622 for(auto const& iter : zones) {
1623 RGWZoneParams zone(iter);
1624 int r = zone.init(cct, store);
1626 ldout(cct, 0) << "Error: init zone " << iter << ":" << cpp_strerror(-r) << dendl;
1629 if (zone.get_id() != my_zone_id) {
1630 pool_names.insert(zone.domain_root);
1631 pool_names.insert(zone.metadata_heap);
1632 pool_names.insert(zone.control_pool);
1633 pool_names.insert(zone.gc_pool);
1634 pool_names.insert(zone.log_pool);
1635 pool_names.insert(zone.intent_log_pool);
1636 pool_names.insert(zone.usage_log_pool);
1637 pool_names.insert(zone.user_keys_pool);
1638 pool_names.insert(zone.user_email_pool);
1639 pool_names.insert(zone.user_swift_pool);
1640 pool_names.insert(zone.user_uid_pool);
1641 pool_names.insert(zone.roles_pool);
1642 pool_names.insert(zone.reshard_pool);
1643 for(auto& iter : zone.placement_pools) {
1644 pool_names.insert(iter.second.index_pool);
1645 pool_names.insert(iter.second.data_pool);
1646 pool_names.insert(iter.second.data_extra_pool);
1653 rgw_pool fix_zone_pool_dup(set<rgw_pool> pools,
1654 const string& default_prefix,
1655 const string& default_suffix,
1656 const rgw_pool& suggested_pool)
1658 string suggested_name = suggested_pool.to_str();
1660 string prefix = default_prefix;
1661 string suffix = default_suffix;
1663 if (!suggested_pool.empty()) {
1664 prefix = suggested_name.substr(0, suggested_name.find("."));
1665 suffix = suggested_name.substr(prefix.length());
1668 rgw_pool pool(prefix + suffix);
1670 if (pools.find(pool) == pools.end()) {
1674 pool = prefix + "_" + std::to_string(std::rand()) + suffix;
1675 if (pools.find(pool) == pools.end()) {
1682 int RGWZoneParams::fix_pool_names()
1686 int r = store->list_zones(zones);
1688 ldout(cct, 10) << "WARNING: store->list_zones() returned r=" << r << dendl;
1691 set<rgw_pool> pools;
1692 r = get_zones_pool_set(cct, store, zones, id, pools);
1694 ldout(cct, 0) << "Error: get_zones_pool_names" << r << dendl;
1698 domain_root = fix_zone_pool_dup(pools, name, ".rgw.meta:root", domain_root);
1699 if (!metadata_heap.name.empty()) {
1700 metadata_heap = fix_zone_pool_dup(pools, name, ".rgw.meta:heap", metadata_heap);
1702 control_pool = fix_zone_pool_dup(pools, name, ".rgw.control", control_pool);
1703 gc_pool = fix_zone_pool_dup(pools, name ,".rgw.log:gc", gc_pool);
1704 lc_pool = fix_zone_pool_dup(pools, name ,".rgw.log:lc", lc_pool);
1705 log_pool = fix_zone_pool_dup(pools, name, ".rgw.log", log_pool);
1706 intent_log_pool = fix_zone_pool_dup(pools, name, ".rgw.log:intent", intent_log_pool);
1707 usage_log_pool = fix_zone_pool_dup(pools, name, ".rgw.log:usage", usage_log_pool);
1708 user_keys_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.keys", user_keys_pool);
1709 user_email_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.email", user_email_pool);
1710 user_swift_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.swift", user_swift_pool);
1711 user_uid_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:users.uid", user_uid_pool);
1712 roles_pool = fix_zone_pool_dup(pools, name, ".rgw.meta:roles", roles_pool);
1713 reshard_pool = fix_zone_pool_dup(pools, name, ".rgw.log:reshard", reshard_pool);
1715 for(auto& iter : placement_pools) {
1716 iter.second.index_pool = fix_zone_pool_dup(pools, name, "." + default_bucket_index_pool_suffix,
1717 iter.second.index_pool);
1718 iter.second.data_pool = fix_zone_pool_dup(pools, name, "." + default_storage_pool_suffix,
1719 iter.second.data_pool);
1720 iter.second.data_extra_pool= fix_zone_pool_dup(pools, name, "." + default_storage_extra_pool_suffix,
1721 iter.second.data_extra_pool);
1727 int RGWZoneParams::create(bool exclusive)
1729 /* check for old pools config */
1730 rgw_raw_obj obj(domain_root, avail_pools);
1731 int r = store->raw_obj_stat(obj, NULL, NULL, NULL, NULL, NULL, NULL);
1733 ldout(store->ctx(), 10) << "couldn't find old data placement pools config, setting up new ones for the zone" << dendl;
1734 /* a new system, let's set new placement info */
1735 RGWZonePlacementInfo default_placement;
1736 default_placement.index_pool = name + "." + default_bucket_index_pool_suffix;
1737 default_placement.data_pool = name + "." + default_storage_pool_suffix;
1738 default_placement.data_extra_pool = name + "." + default_storage_extra_pool_suffix;
1739 placement_pools["default-placement"] = default_placement;
1742 r = fix_pool_names();
1744 ldout(cct, 0) << "ERROR: fix_pool_names returned r=" << r << dendl;
1748 r = RGWSystemMetaObj::create(exclusive);
1753 // try to set as default. may race with another create, so pass exclusive=true
1754 // so we don't override an existing default
1755 r = set_as_default(true);
1756 if (r < 0 && r != -EEXIST) {
1757 ldout(cct, 10) << "WARNING: failed to set zone as default, r=" << r << dendl;
1763 rgw_pool RGWZoneParams::get_pool(CephContext *cct)
1765 if (cct->_conf->rgw_zone_root_pool.empty()) {
1766 return rgw_pool(RGW_DEFAULT_ZONE_ROOT_POOL);
1769 return rgw_pool(cct->_conf->rgw_zone_root_pool);
1772 const string RGWZoneParams::get_default_oid(bool old_format)
1775 return cct->_conf->rgw_default_zone_info_oid;
1778 return cct->_conf->rgw_default_zone_info_oid + "." + realm_id;
1781 const string& RGWZoneParams::get_names_oid_prefix()
1783 return zone_names_oid_prefix;
1786 const string& RGWZoneParams::get_info_oid_prefix(bool old_format)
1788 return zone_info_oid_prefix;
1791 const string& RGWZoneParams::get_predefined_name(CephContext *cct) {
1792 return cct->_conf->rgw_zone;
1795 int RGWZoneParams::init(CephContext *cct, RGWRados *store, bool setup_obj, bool old_format)
1798 name = cct->_conf->rgw_zone;
1801 return RGWSystemMetaObj::init(cct, store, setup_obj, old_format);
1804 int RGWZoneParams::read_default_id(string& default_id, bool old_format)
1806 if (realm_id.empty()) {
1807 /* try using default realm */
1809 int ret = realm.init(cct, store);
1811 ldout(cct, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
1814 realm_id = realm.get_id();
1817 return RGWSystemMetaObj::read_default_id(default_id, old_format);
1821 int RGWZoneParams::set_as_default(bool exclusive)
1823 if (realm_id.empty()) {
1824 /* try using default realm */
1826 int ret = realm.init(cct, store);
1828 ldout(cct, 10) << "could not read realm id: " << cpp_strerror(-ret) << dendl;
1831 realm_id = realm.get_id();
1834 return RGWSystemMetaObj::set_as_default(exclusive);
1837 const string& RGWZoneParams::get_compression_type(const string& placement_rule) const
1839 static const std::string NONE{"none"};
1840 auto p = placement_pools.find(placement_rule);
1841 if (p == placement_pools.end()) {
1844 const auto& type = p->second.compression_type;
1845 return !type.empty() ? type : NONE;
1848 void RGWPeriodMap::encode(bufferlist& bl) const {
1849 ENCODE_START(2, 1, bl);
1851 ::encode(zonegroups, bl);
1852 ::encode(master_zonegroup, bl);
1853 ::encode(short_zone_ids, bl);
1857 void RGWPeriodMap::decode(bufferlist::iterator& bl) {
1858 DECODE_START(2, bl);
1860 ::decode(zonegroups, bl);
1861 ::decode(master_zonegroup, bl);
1862 if (struct_v >= 2) {
1863 ::decode(short_zone_ids, bl);
1867 zonegroups_by_api.clear();
1868 for (map<string, RGWZoneGroup>::iterator iter = zonegroups.begin();
1869 iter != zonegroups.end(); ++iter) {
1870 RGWZoneGroup& zonegroup = iter->second;
1871 zonegroups_by_api[zonegroup.api_name] = zonegroup;
1872 if (zonegroup.is_master_zonegroup()) {
1873 master_zonegroup = zonegroup.get_id();
1878 // run an MD5 hash on the zone_id and return the first 32 bits
1879 static uint32_t gen_short_zone_id(const std::string zone_id)
1881 unsigned char md5[CEPH_CRYPTO_MD5_DIGESTSIZE];
1883 hash.Update((const byte *)zone_id.c_str(), zone_id.size());
1887 memcpy((char *)&short_id, md5, sizeof(short_id));
1888 return std::max(short_id, 1u);
1891 int RGWPeriodMap::update(const RGWZoneGroup& zonegroup, CephContext *cct)
1893 if (zonegroup.is_master_zonegroup() && (!master_zonegroup.empty() && zonegroup.get_id() != master_zonegroup)) {
1894 ldout(cct,0) << "Error updating periodmap, multiple master zonegroups configured "<< dendl;
1895 ldout(cct,0) << "master zonegroup: " << master_zonegroup << " and " << zonegroup.get_id() <<dendl;
1898 map<string, RGWZoneGroup>::iterator iter = zonegroups.find(zonegroup.get_id());
1899 if (iter != zonegroups.end()) {
1900 RGWZoneGroup& old_zonegroup = iter->second;
1901 if (!old_zonegroup.api_name.empty()) {
1902 zonegroups_by_api.erase(old_zonegroup.api_name);
1905 zonegroups[zonegroup.get_id()] = zonegroup;
1907 if (!zonegroup.api_name.empty()) {
1908 zonegroups_by_api[zonegroup.api_name] = zonegroup;
1911 if (zonegroup.is_master_zonegroup()) {
1912 master_zonegroup = zonegroup.get_id();
1913 } else if (master_zonegroup == zonegroup.get_id()) {
1914 master_zonegroup = "";
1917 for (auto& i : zonegroup.zones) {
1918 auto& zone = i.second;
1919 if (short_zone_ids.find(zone.id) != short_zone_ids.end()) {
1922 // calculate the zone's short id
1923 uint32_t short_id = gen_short_zone_id(zone.id);
1925 // search for an existing zone with the same short id
1926 for (auto& s : short_zone_ids) {
1927 if (s.second == short_id) {
1928 ldout(cct, 0) << "New zone '" << zone.name << "' (" << zone.id
1929 << ") generates the same short_zone_id " << short_id
1930 << " as existing zone id " << s.first << dendl;
1935 short_zone_ids[zone.id] = short_id;
1941 uint32_t RGWPeriodMap::get_zone_short_id(const string& zone_id) const
1943 auto i = short_zone_ids.find(zone_id);
1944 if (i == short_zone_ids.end()) {
1950 int RGWZoneGroupMap::read(CephContext *cct, RGWRados *store)
1954 int ret = period.init(cct, store);
1956 cerr << "failed to read current period info: " << cpp_strerror(ret);
1960 bucket_quota = period.get_config().bucket_quota;
1961 user_quota = period.get_config().user_quota;
1962 zonegroups = period.get_map().zonegroups;
1963 zonegroups_by_api = period.get_map().zonegroups_by_api;
1964 master_zonegroup = period.get_map().master_zonegroup;
1969 void RGWRegionMap::encode(bufferlist& bl) const {
1970 ENCODE_START( 3, 1, bl);
1971 ::encode(regions, bl);
1972 ::encode(master_region, bl);
1973 ::encode(bucket_quota, bl);
1974 ::encode(user_quota, bl);
1978 void RGWRegionMap::decode(bufferlist::iterator& bl) {
1979 DECODE_START(3, bl);
1980 ::decode(regions, bl);
1981 ::decode(master_region, bl);
1983 ::decode(bucket_quota, bl);
1985 ::decode(user_quota, bl);
1989 void RGWZoneGroupMap::encode(bufferlist& bl) const {
1990 ENCODE_START( 3, 1, bl);
1991 ::encode(zonegroups, bl);
1992 ::encode(master_zonegroup, bl);
1993 ::encode(bucket_quota, bl);
1994 ::encode(user_quota, bl);
1998 void RGWZoneGroupMap::decode(bufferlist::iterator& bl) {
1999 DECODE_START(3, bl);
2000 ::decode(zonegroups, bl);
2001 ::decode(master_zonegroup, bl);
2003 ::decode(bucket_quota, bl);
2005 ::decode(user_quota, bl);
2008 zonegroups_by_api.clear();
2009 for (map<string, RGWZoneGroup>::iterator iter = zonegroups.begin();
2010 iter != zonegroups.end(); ++iter) {
2011 RGWZoneGroup& zonegroup = iter->second;
2012 zonegroups_by_api[zonegroup.api_name] = zonegroup;
2013 if (zonegroup.is_master_zonegroup()) {
2014 master_zonegroup = zonegroup.get_name();
2019 void RGWObjVersionTracker::prepare_op_for_read(ObjectReadOperation *op)
2021 obj_version *check_objv = version_for_check();
2024 cls_version_check(*op, *check_objv, VER_COND_EQ);
2027 cls_version_read(*op, &read_version);
2030 void RGWObjVersionTracker::prepare_op_for_write(ObjectWriteOperation *op)
2032 obj_version *check_objv = version_for_check();
2033 obj_version *modify_version = version_for_write();
2036 cls_version_check(*op, *check_objv, VER_COND_EQ);
2039 if (modify_version) {
2040 cls_version_set(*op, *modify_version);
2042 cls_version_inc(*op);
2046 void RGWObjManifest::obj_iterator::operator++()
2048 if (manifest->explicit_objs) {
2051 if (explicit_iter == manifest->objs.end()) {
2052 ofs = manifest->obj_size;
2056 update_explicit_pos();
2062 uint64_t obj_size = manifest->get_obj_size();
2063 uint64_t head_size = manifest->get_head_size();
2065 if (ofs == obj_size) {
2069 if (manifest->rules.empty()) {
2073 /* are we still pointing at the head? */
2074 if (ofs < head_size) {
2075 rule_iter = manifest->rules.begin();
2076 RGWObjManifestRule *rule = &rule_iter->second;
2077 ofs = MIN(head_size, obj_size);
2080 stripe_size = MIN(obj_size - ofs, rule->stripe_max_size);
2081 if (rule->part_size > 0) {
2082 stripe_size = MIN(stripe_size, rule->part_size);
2088 RGWObjManifestRule *rule = &rule_iter->second;
2090 stripe_ofs += rule->stripe_max_size;
2092 dout(20) << "RGWObjManifest::operator++(): rule->part_size=" << rule->part_size << " rules.size()=" << manifest->rules.size() << dendl;
2094 if (rule->part_size > 0) {
2095 /* multi part, multi stripes object */
2097 dout(20) << "RGWObjManifest::operator++(): stripe_ofs=" << stripe_ofs << " part_ofs=" << part_ofs << " rule->part_size=" << rule->part_size << dendl;
2099 if (stripe_ofs >= part_ofs + rule->part_size) {
2100 /* moved to the next part */
2102 part_ofs += rule->part_size;
2103 stripe_ofs = part_ofs;
2105 bool last_rule = (next_rule_iter == manifest->rules.end());
2106 /* move to the next rule? */
2107 if (!last_rule && stripe_ofs >= next_rule_iter->second.start_ofs) {
2108 rule_iter = next_rule_iter;
2109 last_rule = (next_rule_iter == manifest->rules.end());
2113 cur_part_id = rule_iter->second.start_part_num;
2118 rule = &rule_iter->second;
2121 stripe_size = MIN(rule->part_size - (stripe_ofs - part_ofs), rule->stripe_max_size);
2124 cur_override_prefix = rule->override_prefix;
2127 if (ofs > obj_size) {
2133 dout(20) << "RGWObjManifest::operator++(): result: ofs=" << ofs << " stripe_ofs=" << stripe_ofs << " part_ofs=" << part_ofs << " rule->part_size=" << rule->part_size << dendl;
2137 int RGWObjManifest::generator::create_begin(CephContext *cct, RGWObjManifest *_m, const string& placement_rule, rgw_bucket& _b, rgw_obj& _obj)
2141 manifest->set_tail_placement(placement_rule, _b);
2142 manifest->set_head(placement_rule, _obj, 0);
2145 if (manifest->get_prefix().empty()) {
2147 gen_rand_alphanumeric(cct, buf, sizeof(buf) - 1);
2149 string oid_prefix = ".";
2150 oid_prefix.append(buf);
2151 oid_prefix.append("_");
2153 manifest->set_prefix(oid_prefix);
2156 bool found = manifest->get_rule(0, &rule);
2158 derr << "ERROR: manifest->get_rule() could not find rule" << dendl;
2162 uint64_t head_size = manifest->get_head_size();
2164 if (head_size > 0) {
2165 cur_stripe_size = head_size;
2167 cur_stripe_size = rule.stripe_max_size;
2170 cur_part_id = rule.start_part_num;
2172 manifest->get_implicit_location(cur_part_id, cur_stripe, 0, NULL, &cur_obj);
2174 // Normal object which not generated through copy operation
2175 manifest->set_tail_instance(_obj.key.instance);
2177 manifest->update_iterators();
2182 int RGWObjManifest::generator::create_next(uint64_t ofs)
2184 if (ofs < last_ofs) /* only going forward */
2187 uint64_t max_head_size = manifest->get_max_head_size();
2189 if (ofs < max_head_size) {
2190 manifest->set_head_size(ofs);
2193 if (ofs >= max_head_size) {
2194 manifest->set_head_size(max_head_size);
2195 cur_stripe = (ofs - max_head_size) / rule.stripe_max_size;
2196 cur_stripe_size = rule.stripe_max_size;
2198 if (cur_part_id == 0 && max_head_size > 0) {
2204 manifest->set_obj_size(ofs);
2206 manifest->get_implicit_location(cur_part_id, cur_stripe, ofs, NULL, &cur_obj);
2208 manifest->update_iterators();
2213 const RGWObjManifest::obj_iterator& RGWObjManifest::obj_begin()
2218 const RGWObjManifest::obj_iterator& RGWObjManifest::obj_end()
2223 RGWObjManifest::obj_iterator RGWObjManifest::obj_find(uint64_t ofs)
2225 if (ofs > obj_size) {
2228 RGWObjManifest::obj_iterator iter(this);
2233 int RGWObjManifest::append(RGWObjManifest& m, RGWZoneGroup& zonegroup, RGWZoneParams& zone_params)
2235 if (explicit_objs || m.explicit_objs) {
2236 return append_explicit(m, zonegroup, zone_params);
2239 if (rules.empty()) {
2244 string override_prefix;
2246 if (prefix.empty()) {
2250 if (prefix != m.prefix) {
2251 override_prefix = m.prefix;
2254 map<uint64_t, RGWObjManifestRule>::iterator miter = m.rules.begin();
2255 if (miter == m.rules.end()) {
2256 return append_explicit(m, zonegroup, zone_params);
2259 for (; miter != m.rules.end(); ++miter) {
2260 map<uint64_t, RGWObjManifestRule>::reverse_iterator last_rule = rules.rbegin();
2262 RGWObjManifestRule& rule = last_rule->second;
2264 if (rule.part_size == 0) {
2265 rule.part_size = obj_size - rule.start_ofs;
2268 RGWObjManifestRule& next_rule = miter->second;
2269 if (!next_rule.part_size) {
2270 next_rule.part_size = m.obj_size - next_rule.start_ofs;
2273 string rule_prefix = prefix;
2274 if (!rule.override_prefix.empty()) {
2275 rule_prefix = rule.override_prefix;
2278 string next_rule_prefix = m.prefix;
2279 if (!next_rule.override_prefix.empty()) {
2280 next_rule_prefix = next_rule.override_prefix;
2283 if (rule.part_size != next_rule.part_size ||
2284 rule.stripe_max_size != next_rule.stripe_max_size ||
2285 rule_prefix != next_rule_prefix) {
2286 if (next_rule_prefix != prefix) {
2287 append_rules(m, miter, &next_rule_prefix);
2289 append_rules(m, miter, NULL);
2294 uint64_t expected_part_num = rule.start_part_num + 1;
2295 if (rule.part_size > 0) {
2296 expected_part_num = rule.start_part_num + (obj_size + next_rule.start_ofs - rule.start_ofs) / rule.part_size;
2299 if (expected_part_num != next_rule.start_part_num) {
2300 append_rules(m, miter, NULL);
2305 set_obj_size(obj_size + m.obj_size);
2310 int RGWObjManifest::append(RGWObjManifest& m, RGWRados *store)
2312 return append(m, store->get_zonegroup(), store->get_zone_params());
2315 void RGWObjManifest::append_rules(RGWObjManifest& m, map<uint64_t, RGWObjManifestRule>::iterator& miter,
2316 string *override_prefix)
2318 for (; miter != m.rules.end(); ++miter) {
2319 RGWObjManifestRule rule = miter->second;
2320 rule.start_ofs += obj_size;
2321 if (override_prefix)
2322 rule.override_prefix = *override_prefix;
2323 rules[rule.start_ofs] = rule;
2327 void RGWObjManifest::convert_to_explicit(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params)
2329 if (explicit_objs) {
2332 obj_iterator iter = obj_begin();
2334 while (iter != obj_end()) {
2335 RGWObjManifestPart& part = objs[iter.get_stripe_ofs()];
2336 const rgw_obj_select& os = iter.get_location();
2337 const rgw_raw_obj& raw_loc = os.get_raw_obj(zonegroup, zone_params);
2340 uint64_t ofs = iter.get_stripe_ofs();
2345 rgw_raw_obj_to_obj(tail_placement.bucket, raw_loc, &part.loc);
2348 uint64_t next_ofs = iter.get_stripe_ofs();
2350 part.size = next_ofs - ofs;
2353 explicit_objs = true;
2358 int RGWObjManifest::append_explicit(RGWObjManifest& m, const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params)
2360 if (!explicit_objs) {
2361 convert_to_explicit(zonegroup, zone_params);
2363 if (!m.explicit_objs) {
2364 m.convert_to_explicit(zonegroup, zone_params);
2366 map<uint64_t, RGWObjManifestPart>::iterator iter;
2367 uint64_t base = obj_size;
2368 for (iter = m.objs.begin(); iter != m.objs.end(); ++iter) {
2369 RGWObjManifestPart& part = iter->second;
2370 objs[base + iter->first] = part;
2372 obj_size += m.obj_size;
2377 bool RGWObjManifest::get_rule(uint64_t ofs, RGWObjManifestRule *rule)
2379 if (rules.empty()) {
2383 map<uint64_t, RGWObjManifestRule>::iterator iter = rules.upper_bound(ofs);
2384 if (iter != rules.begin()) {
2388 *rule = iter->second;
2393 void RGWObjVersionTracker::generate_new_write_ver(CephContext *cct)
2395 write_version.ver = 1;
2398 write_version.tag.clear();
2399 append_rand_alpha(cct, write_version.tag, write_version.tag, TAG_LEN);
2402 int RGWPutObjProcessor::complete(size_t accounted_size, const string& etag,
2403 real_time *mtime, real_time set_mtime,
2404 map<string, bufferlist>& attrs, real_time delete_at,
2405 const char *if_match, const char *if_nomatch, const string *user_data,
2406 rgw_zone_set *zones_trace)
2408 int r = do_complete(accounted_size, etag, mtime, set_mtime, attrs, delete_at, if_match, if_nomatch, user_data, zones_trace);
2412 is_complete = !canceled;
2416 CephContext *RGWPutObjProcessor::ctx()
2418 return store->ctx();
2421 RGWPutObjProcessor_Aio::~RGWPutObjProcessor_Aio()
2428 set<rgw_raw_obj>::iterator iter;
2429 bool need_to_remove_head = false;
2430 rgw_raw_obj raw_head;
2432 if (!head_obj.empty()) {
2433 store->obj_to_raw(bucket_info.placement_rule, head_obj, &raw_head);
2437 * We should delete the object in the "multipart" namespace to avoid race condition.
2438 * Such race condition is caused by the fact that the multipart object is the gatekeeper of a multipart
2439 * upload, when it is deleted, a second upload would start with the same suffix("2/"), therefore, objects
2440 * written by the second upload may be deleted by the first upload.
2441 * details is describled on #11749
2443 * The above comment still stands, but instead of searching for a specific object in the multipart
2444 * namespace, we just make sure that we remove the object that is marked as the head object after
2445 * we remove all the other raw objects. Note that we use different call to remove the head object,
2446 * as this one needs to go via the bucket index prepare/complete 2-phase commit scheme.
2448 for (iter = written_objs.begin(); iter != written_objs.end(); ++iter) {
2449 const rgw_raw_obj& obj = *iter;
2450 if (!head_obj.empty() && obj == raw_head) {
2451 ldout(store->ctx(), 5) << "NOTE: we should not process the head object (" << obj << ") here" << dendl;
2452 need_to_remove_head = true;
2456 int r = store->delete_raw_obj(obj);
2457 if (r < 0 && r != -ENOENT) {
2458 ldout(store->ctx(), 5) << "WARNING: failed to remove obj (" << obj << "), leaked" << dendl;
2462 if (need_to_remove_head) {
2463 ldout(store->ctx(), 5) << "NOTE: we are going to process the head obj (" << raw_head << ")" << dendl;
2464 int r = store->delete_obj(obj_ctx, bucket_info, head_obj, 0, 0);
2465 if (r < 0 && r != -ENOENT) {
2466 ldout(store->ctx(), 0) << "WARNING: failed to remove obj (" << raw_head << "), leaked" << dendl;
2471 int RGWPutObjProcessor_Aio::handle_obj_data(rgw_raw_obj& obj, bufferlist& bl, off_t ofs, off_t abs_ofs, void **phandle, bool exclusive)
2473 if ((uint64_t)abs_ofs + bl.length() > obj_len)
2474 obj_len = abs_ofs + bl.length();
2476 if (!(obj == last_written_obj)) {
2477 last_written_obj = obj;
2480 // For the first call pass -1 as the offset to
2482 return store->aio_put_obj_data(NULL, obj, bl, ((ofs != 0) ? ofs : -1), exclusive, phandle);
2485 struct put_obj_aio_info RGWPutObjProcessor_Aio::pop_pending()
2487 struct put_obj_aio_info info;
2488 info = pending.front();
2489 pending.pop_front();
2490 pending_size -= info.size;
2494 int RGWPutObjProcessor_Aio::wait_pending_front()
2496 if (pending.empty()) {
2499 struct put_obj_aio_info info = pop_pending();
2500 int ret = store->aio_wait(info.handle);
2503 add_written_obj(info.obj);
2509 bool RGWPutObjProcessor_Aio::pending_has_completed()
2511 if (pending.empty())
2514 struct put_obj_aio_info& info = pending.front();
2515 return store->aio_completed(info.handle);
2518 int RGWPutObjProcessor_Aio::drain_pending()
2521 while (!pending.empty()) {
2522 int r = wait_pending_front();
2529 int RGWPutObjProcessor_Aio::throttle_data(void *handle, const rgw_raw_obj& obj, uint64_t size, bool need_to_wait)
2531 bool _wait = need_to_wait;
2534 struct put_obj_aio_info info;
2535 info.handle = handle;
2538 pending_size += size;
2539 pending.push_back(info);
2541 size_t orig_size = pending_size;
2543 /* first drain complete IOs */
2544 while (pending_has_completed()) {
2545 int r = wait_pending_front();
2552 /* resize window in case messages are draining too fast */
2553 if (orig_size - pending_size >= window_size) {
2554 window_size += store->ctx()->_conf->rgw_max_chunk_size;
2555 uint64_t max_window_size = store->ctx()->_conf->rgw_put_obj_max_window_size;
2556 if (window_size > max_window_size) {
2557 window_size = max_window_size;
2561 /* now throttle. Note that need_to_wait should only affect the first IO operation */
2562 if (pending_size > window_size || _wait) {
2563 int r = wait_pending_front();
2570 int RGWPutObjProcessor_Atomic::write_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool exclusive)
2572 if (ofs >= next_part_ofs) {
2573 int r = prepare_next_part(ofs);
2586 return RGWPutObjProcessor_Aio::handle_obj_data(cur_obj, bl, ofs - cur_part_ofs, ofs, phandle, exclusive);
2589 int RGWPutObjProcessor_Aio::prepare(RGWRados *store, string *oid_rand)
2591 RGWPutObjProcessor::prepare(store, oid_rand);
2593 window_size = store->ctx()->_conf->rgw_put_obj_min_window_size;
2598 int RGWPutObjProcessor_Atomic::handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again)
2601 uint64_t max_write_size = MIN(max_chunk_size, (uint64_t)next_part_ofs - data_ofs);
2603 pending_data_bl.claim_append(bl);
2604 if (pending_data_bl.length() < max_write_size) {
2609 pending_data_bl.splice(0, max_write_size, &bl);
2611 /* do we have enough data pending accumulated that needs to be written? */
2612 *again = (pending_data_bl.length() >= max_chunk_size);
2614 if (!data_ofs && !immutable_head()) {
2615 first_chunk.claim(bl);
2616 obj_len = (uint64_t)first_chunk.length();
2617 int r = prepare_next_part(obj_len);
2624 off_t write_ofs = data_ofs;
2625 data_ofs = write_ofs + bl.length();
2626 bool exclusive = (!write_ofs && immutable_head()); /* immutable head object, need to verify nothing exists there
2627 we could be racing with another upload, to the same
2628 object and cleanup can be messy */
2629 int ret = write_data(bl, write_ofs, phandle, pobj, exclusive);
2630 if (ret >= 0) { /* we might return, need to clear bl as it was already sent */
2637 int RGWPutObjProcessor_Atomic::prepare_init(RGWRados *store, string *oid_rand)
2639 RGWPutObjProcessor_Aio::prepare(store, oid_rand);
2641 int r = store->get_max_chunk_size(bucket_info.placement_rule, head_obj, &max_chunk_size);
2649 int RGWPutObjProcessor_Atomic::prepare(RGWRados *store, string *oid_rand)
2651 head_obj.init(bucket, obj_str);
2653 int r = prepare_init(store, oid_rand);
2658 if (!version_id.empty()) {
2659 head_obj.key.set_instance(version_id);
2660 } else if (versioned_object) {
2661 store->gen_rand_obj_instance_name(&head_obj);
2664 manifest.set_trivial_rule(max_chunk_size, store->ctx()->_conf->rgw_obj_stripe_size);
2666 r = manifest_gen.create_begin(store->ctx(), &manifest, bucket_info.placement_rule, head_obj.bucket, head_obj);
2674 int RGWPutObjProcessor_Atomic::prepare_next_part(off_t ofs) {
2676 int ret = manifest_gen.create_next(ofs);
2678 lderr(store->ctx()) << "ERROR: manifest_gen.create_next() returned ret=" << ret << dendl;
2682 next_part_ofs = ofs + manifest_gen.cur_stripe_max_size();
2683 cur_obj = manifest_gen.get_cur_obj(store);
2688 int RGWPutObjProcessor_Atomic::complete_parts()
2690 if (obj_len > (uint64_t)cur_part_ofs) {
2691 return prepare_next_part(obj_len);
2696 int RGWPutObjProcessor_Atomic::complete_writing_data()
2698 if (!data_ofs && !immutable_head()) {
2699 /* only claim if pending_data_bl() is not empty. This is needed because we might be called twice
2700 * (e.g., when a retry due to race happens). So a second call to first_chunk.claim() would
2701 * clobber first_chunk
2703 if (pending_data_bl.length() > 0) {
2704 first_chunk.claim(pending_data_bl);
2706 obj_len = (uint64_t)first_chunk.length();
2708 while (pending_data_bl.length()) {
2709 void *handle = nullptr;
2711 uint64_t max_write_size = MIN(max_chunk_size, (uint64_t)next_part_ofs - data_ofs);
2712 if (max_write_size > pending_data_bl.length()) {
2713 max_write_size = pending_data_bl.length();
2716 pending_data_bl.splice(0, max_write_size, &bl);
2717 uint64_t write_len = bl.length();
2718 int r = write_data(bl, data_ofs, &handle, &obj, false);
2720 ldout(store->ctx(), 0) << "ERROR: write_data() returned " << r << dendl;
2723 data_ofs += write_len;
2724 r = throttle_data(handle, obj, write_len, false);
2726 ldout(store->ctx(), 0) << "ERROR: throttle_data() returned " << r << dendl;
2730 if (data_ofs >= next_part_ofs) {
2731 r = prepare_next_part(data_ofs);
2733 ldout(store->ctx(), 0) << "ERROR: prepare_next_part() returned " << r << dendl;
2738 int r = complete_parts();
2743 r = drain_pending();
2750 int RGWPutObjProcessor_Atomic::do_complete(size_t accounted_size, const string& etag,
2751 real_time *mtime, real_time set_mtime,
2752 map<string, bufferlist>& attrs,
2753 real_time delete_at,
2754 const char *if_match,
2755 const char *if_nomatch, const string *user_data,
2756 rgw_zone_set *zones_trace) {
2757 int r = complete_writing_data();
2761 obj_ctx.obj.set_atomic(head_obj);
2763 RGWRados::Object op_target(store, bucket_info, obj_ctx, head_obj);
2765 /* some object types shouldn't be versioned, e.g., multipart parts */
2766 op_target.set_versioning_disabled(!versioned_object);
2768 RGWRados::Object::Write obj_op(&op_target);
2770 obj_op.meta.data = &first_chunk;
2771 obj_op.meta.manifest = &manifest;
2772 obj_op.meta.ptag = &unique_tag; /* use req_id as operation tag */
2773 obj_op.meta.if_match = if_match;
2774 obj_op.meta.if_nomatch = if_nomatch;
2775 obj_op.meta.mtime = mtime;
2776 obj_op.meta.set_mtime = set_mtime;
2777 obj_op.meta.owner = bucket_info.owner;
2778 obj_op.meta.flags = PUT_OBJ_CREATE;
2779 obj_op.meta.olh_epoch = olh_epoch;
2780 obj_op.meta.delete_at = delete_at;
2781 obj_op.meta.user_data = user_data;
2782 obj_op.meta.zones_trace = zones_trace;
2783 obj_op.meta.modify_tail = true;
2785 r = obj_op.write_meta(obj_len, accounted_size, attrs);
2790 canceled = obj_op.meta.canceled;
2795 int RGWRados::watch(const string& oid, uint64_t *watch_handle, librados::WatchCtx2 *ctx) {
2796 int r = control_pool_ctx.watch2(oid, watch_handle, ctx);
2802 int RGWRados::unwatch(uint64_t watch_handle)
2804 int r = control_pool_ctx.unwatch2(watch_handle);
2806 ldout(cct, 0) << "ERROR: rados->unwatch2() returned r=" << r << dendl;
2809 r = rados[0].watch_flush();
2811 ldout(cct, 0) << "ERROR: rados->watch_flush() returned r=" << r << dendl;
2817 void RGWRados::add_watcher(int i)
2819 ldout(cct, 20) << "add_watcher() i=" << i << dendl;
2820 Mutex::Locker l(watchers_lock);
2821 watchers_set.insert(i);
2822 if (watchers_set.size() == (size_t)num_watchers) {
2823 ldout(cct, 2) << "all " << num_watchers << " watchers are set, enabling cache" << dendl;
2824 set_cache_enabled(true);
2828 void RGWRados::remove_watcher(int i)
2830 ldout(cct, 20) << "remove_watcher() i=" << i << dendl;
2831 Mutex::Locker l(watchers_lock);
2832 size_t orig_size = watchers_set.size();
2833 watchers_set.erase(i);
2834 if (orig_size == (size_t)num_watchers &&
2835 watchers_set.size() < orig_size) { /* actually removed */
2836 ldout(cct, 2) << "removed watcher, disabling cache" << dendl;
2837 set_cache_enabled(false);
2841 class RGWWatcher : public librados::WatchCtx2 {
2845 uint64_t watch_handle;
2847 class C_ReinitWatch : public Context {
2848 RGWWatcher *watcher;
2850 explicit C_ReinitWatch(RGWWatcher *_watcher) : watcher(_watcher) {}
2851 void finish(int r) override {
2856 RGWWatcher(RGWRados *r, int i, const string& o) : rados(r), index(i), oid(o), watch_handle(0) {}
2857 void handle_notify(uint64_t notify_id,
2859 uint64_t notifier_id,
2860 bufferlist& bl) override {
2861 ldout(rados->ctx(), 10) << "RGWWatcher::handle_notify() "
2862 << " notify_id " << notify_id
2863 << " cookie " << cookie
2864 << " notifier " << notifier_id
2865 << " bl.length()=" << bl.length() << dendl;
2866 rados->watch_cb(notify_id, cookie, notifier_id, bl);
2868 bufferlist reply_bl; // empty reply payload
2869 rados->control_pool_ctx.notify_ack(oid, notify_id, cookie, reply_bl);
2871 void handle_error(uint64_t cookie, int err) override {
2872 lderr(rados->ctx()) << "RGWWatcher::handle_error cookie " << cookie
2873 << " err " << cpp_strerror(err) << dendl;
2874 rados->remove_watcher(index);
2875 rados->schedule_context(new C_ReinitWatch(this));
2879 int ret = unregister_watch();
2881 ldout(rados->ctx(), 0) << "ERROR: unregister_watch() returned ret=" << ret << dendl;
2884 ret = register_watch();
2886 ldout(rados->ctx(), 0) << "ERROR: register_watch() returned ret=" << ret << dendl;
2891 int unregister_watch() {
2892 int r = rados->unwatch(watch_handle);
2896 rados->remove_watcher(index);
2900 int register_watch() {
2901 int r = rados->watch(oid, &watch_handle, this);
2905 rados->add_watcher(index);
2910 class RGWMetaNotifierManager : public RGWCoroutinesManager {
2912 RGWHTTPManager http_manager;
2915 RGWMetaNotifierManager(RGWRados *_store) : RGWCoroutinesManager(_store->ctx(), _store->get_cr_registry()), store(_store),
2916 http_manager(store->ctx(), completion_mgr) {
2917 http_manager.set_threaded();
2920 int notify_all(map<string, RGWRESTConn *>& conn_map, set<int>& shards) {
2921 rgw_http_param_pair pairs[] = { { "type", "metadata" },
2925 list<RGWCoroutinesStack *> stacks;
2926 for (map<string, RGWRESTConn *>::iterator iter = conn_map.begin(); iter != conn_map.end(); ++iter) {
2927 RGWRESTConn *conn = iter->second;
2928 RGWCoroutinesStack *stack = new RGWCoroutinesStack(store->ctx(), this);
2929 stack->call(new RGWPostRESTResourceCR<set<int>, int>(store->ctx(), conn, &http_manager, "/admin/log", pairs, shards, NULL));
2931 stacks.push_back(stack);
2937 class RGWDataNotifierManager : public RGWCoroutinesManager {
2939 RGWHTTPManager http_manager;
2942 RGWDataNotifierManager(RGWRados *_store) : RGWCoroutinesManager(_store->ctx(), _store->get_cr_registry()), store(_store),
2943 http_manager(store->ctx(), completion_mgr) {
2944 http_manager.set_threaded();
2947 int notify_all(map<string, RGWRESTConn *>& conn_map, map<int, set<string> >& shards) {
2948 rgw_http_param_pair pairs[] = { { "type", "data" },
2950 { "source-zone", store->get_zone_params().get_id().c_str() },
2953 list<RGWCoroutinesStack *> stacks;
2954 for (map<string, RGWRESTConn *>::iterator iter = conn_map.begin(); iter != conn_map.end(); ++iter) {
2955 RGWRESTConn *conn = iter->second;
2956 RGWCoroutinesStack *stack = new RGWCoroutinesStack(store->ctx(), this);
2957 stack->call(new RGWPostRESTResourceCR<map<int, set<string> >, int>(store->ctx(), conn, &http_manager, "/admin/log", pairs, shards, NULL));
2959 stacks.push_back(stack);
2965 class RGWRadosThread {
2966 class Worker : public Thread {
2968 RGWRadosThread *processor;
2973 Mutex::Locker l(lock);
2977 void wait_interval(const utime_t& wait_time) {
2978 Mutex::Locker l(lock);
2979 cond.WaitInterval(lock, wait_time);
2983 Worker(CephContext *_cct, RGWRadosThread *_p) : cct(_cct), processor(_p), lock("RGWRadosThread::Worker") {}
2984 void *entry() override;
2986 Mutex::Locker l(lock);
2997 std::atomic<bool> down_flag = { false };
3001 virtual uint64_t interval_msec() = 0;
3002 virtual void stop_process() {}
3004 RGWRadosThread(RGWRados *_store, const string& thread_name = "radosgw")
3005 : worker(NULL), cct(_store->ctx()), store(_store), thread_name(thread_name) {}
3006 virtual ~RGWRadosThread() {
3010 virtual int init() { return 0; }
3011 virtual int process() = 0;
3013 bool going_down() { return down_flag; }
3025 void RGWRadosThread::start()
3027 worker = new Worker(cct, this);
3028 worker->create(thread_name.c_str());
3031 void RGWRadosThread::stop()
3043 void *RGWRadosThread::Worker::entry() {
3044 uint64_t msec = processor->interval_msec();
3045 utime_t interval = utime_t(msec / 1000, (msec % 1000) * 1000000);
3048 utime_t start = ceph_clock_now();
3049 int r = processor->process();
3051 dout(0) << "ERROR: processor->process() returned error r=" << r << dendl;
3054 if (processor->going_down())
3057 utime_t end = ceph_clock_now();
3060 uint64_t cur_msec = processor->interval_msec();
3061 if (cur_msec != msec) { /* was it reconfigured? */
3063 interval = utime_t(msec / 1000, (msec % 1000) * 1000000);
3067 if (interval <= end)
3068 continue; // next round
3070 utime_t wait_time = interval;
3073 wait_interval(wait_time);
3077 } while (!processor->going_down());
3082 class RGWMetaNotifier : public RGWRadosThread {
3083 RGWMetaNotifierManager notify_mgr;
3084 RGWMetadataLog *const log;
3086 uint64_t interval_msec() override {
3087 return cct->_conf->rgw_md_notify_interval_msec;
3090 RGWMetaNotifier(RGWRados *_store, RGWMetadataLog* log)
3091 : RGWRadosThread(_store, "meta-notifier"), notify_mgr(_store), log(log) {}
3093 int process() override;
3096 int RGWMetaNotifier::process()
3100 log->read_clear_modified(shards);
3102 if (shards.empty()) {
3106 for (set<int>::iterator iter = shards.begin(); iter != shards.end(); ++iter) {
3107 ldout(cct, 20) << __func__ << "(): notifying mdlog change, shard_id=" << *iter << dendl;
3110 notify_mgr.notify_all(store->zone_conn_map, shards);
3115 class RGWDataNotifier : public RGWRadosThread {
3116 RGWDataNotifierManager notify_mgr;
3118 uint64_t interval_msec() override {
3119 return cct->_conf->get_val<int64_t>("rgw_data_notify_interval_msec");
3122 RGWDataNotifier(RGWRados *_store) : RGWRadosThread(_store, "data-notifier"), notify_mgr(_store) {}
3124 int process() override;
3127 int RGWDataNotifier::process()
3129 if (!store->data_log) {
3133 map<int, set<string> > shards;
3135 store->data_log->read_clear_modified(shards);
3137 if (shards.empty()) {
3141 for (map<int, set<string> >::iterator iter = shards.begin(); iter != shards.end(); ++iter) {
3142 ldout(cct, 20) << __func__ << "(): notifying datalog change, shard_id=" << iter->first << ": " << iter->second << dendl;
3145 notify_mgr.notify_all(store->zone_data_notify_to_map, shards);
3150 class RGWSyncProcessorThread : public RGWRadosThread {
3152 RGWSyncProcessorThread(RGWRados *_store, const string& thread_name = "radosgw") : RGWRadosThread(_store, thread_name) {}
3153 RGWSyncProcessorThread(RGWRados *_store) : RGWRadosThread(_store) {}
3154 ~RGWSyncProcessorThread() override {}
3155 int init() override = 0 ;
3156 int process() override = 0;
3159 class RGWMetaSyncProcessorThread : public RGWSyncProcessorThread
3161 RGWMetaSyncStatusManager sync;
3163 uint64_t interval_msec() override {
3164 return 0; /* no interval associated, it'll run once until stopped */
3166 void stop_process() override {
3170 RGWMetaSyncProcessorThread(RGWRados *_store, RGWAsyncRadosProcessor *async_rados)
3171 : RGWSyncProcessorThread(_store, "meta-sync"), sync(_store, async_rados) {}
3173 void wakeup_sync_shards(set<int>& shard_ids) {
3174 for (set<int>::iterator iter = shard_ids.begin(); iter != shard_ids.end(); ++iter) {
3178 RGWMetaSyncStatusManager* get_manager() { return &sync; }
3180 int init() override {
3181 int ret = sync.init();
3183 ldout(store->ctx(), 0) << "ERROR: sync.init() returned " << ret << dendl;
3189 int process() override {
3195 class RGWDataSyncProcessorThread : public RGWSyncProcessorThread
3197 RGWDataSyncStatusManager sync;
3200 uint64_t interval_msec() override {
3202 return 0; /* no interval associated, it'll run once until stopped */
3204 #define DATA_SYNC_INIT_WAIT_SEC 20
3205 return DATA_SYNC_INIT_WAIT_SEC * 1000;
3208 void stop_process() override {
3212 RGWDataSyncProcessorThread(RGWRados *_store, RGWAsyncRadosProcessor *async_rados,
3213 const string& _source_zone)
3214 : RGWSyncProcessorThread(_store, "data-sync"), sync(_store, async_rados, _source_zone),
3215 initialized(false) {}
3217 void wakeup_sync_shards(map<int, set<string> >& shard_ids) {
3218 for (map<int, set<string> >::iterator iter = shard_ids.begin(); iter != shard_ids.end(); ++iter) {
3219 sync.wakeup(iter->first, iter->second);
3222 RGWDataSyncStatusManager* get_manager() { return &sync; }
3224 int init() override {
3228 int process() override {
3229 while (!initialized) {
3233 int ret = sync.init();
3238 /* we'll be back! */
3246 class RGWSyncLogTrimThread : public RGWSyncProcessorThread
3248 RGWCoroutinesManager crs;
3250 RGWHTTPManager http;
3251 const utime_t trim_interval;
3253 uint64_t interval_msec() override { return 0; }
3254 void stop_process() override { crs.stop(); }
3256 RGWSyncLogTrimThread(RGWRados *store, int interval)
3257 : RGWSyncProcessorThread(store, "sync-log-trim"),
3258 crs(store->ctx(), store->get_cr_registry()), store(store),
3259 http(store->ctx(), crs.get_completion_mgr()),
3260 trim_interval(interval, 0)
3263 int init() override {
3264 return http.set_threaded();
3266 int process() override {
3267 list<RGWCoroutinesStack*> stacks;
3268 auto meta = new RGWCoroutinesStack(store->ctx(), &crs);
3269 meta->call(create_meta_log_trim_cr(store, &http,
3270 cct->_conf->rgw_md_log_max_shards,
3272 stacks.push_back(meta);
3274 auto data = new RGWCoroutinesStack(store->ctx(), &crs);
3275 data->call(create_data_log_trim_cr(store, &http,
3276 cct->_conf->rgw_data_log_num_shards,
3278 stacks.push_back(data);
3285 void RGWRados::wakeup_meta_sync_shards(set<int>& shard_ids)
3287 Mutex::Locker l(meta_sync_thread_lock);
3288 if (meta_sync_processor_thread) {
3289 meta_sync_processor_thread->wakeup_sync_shards(shard_ids);
3293 void RGWRados::wakeup_data_sync_shards(const string& source_zone, map<int, set<string> >& shard_ids)
3295 ldout(ctx(), 20) << __func__ << ": source_zone=" << source_zone << ", shard_ids=" << shard_ids << dendl;
3296 Mutex::Locker l(data_sync_thread_lock);
3297 map<string, RGWDataSyncProcessorThread *>::iterator iter = data_sync_processor_threads.find(source_zone);
3298 if (iter == data_sync_processor_threads.end()) {
3299 ldout(ctx(), 10) << __func__ << ": couldn't find sync thread for zone " << source_zone << ", skipping async data sync processing" << dendl;
3303 RGWDataSyncProcessorThread *thread = iter->second;
3305 thread->wakeup_sync_shards(shard_ids);
3308 RGWMetaSyncStatusManager* RGWRados::get_meta_sync_manager()
3310 Mutex::Locker l(meta_sync_thread_lock);
3311 if (meta_sync_processor_thread) {
3312 return meta_sync_processor_thread->get_manager();
3317 RGWDataSyncStatusManager* RGWRados::get_data_sync_manager(const std::string& source_zone)
3319 Mutex::Locker l(data_sync_thread_lock);
3320 auto thread = data_sync_processor_threads.find(source_zone);
3321 if (thread == data_sync_processor_threads.end()) {
3324 return thread->second->get_manager();
3327 int RGWRados::get_required_alignment(const rgw_pool& pool, uint64_t *alignment)
3330 int r = open_pool_ctx(pool, ioctx);
3332 ldout(cct, 0) << "ERROR: open_pool_ctx() returned " << r << dendl;
3337 r = ioctx.pool_requires_alignment2(&requires);
3339 ldout(cct, 0) << "ERROR: ioctx.pool_requires_alignment2() returned "
3350 r = ioctx.pool_required_alignment2(&align);
3352 ldout(cct, 0) << "ERROR: ioctx.pool_required_alignment2() returned "
3357 ldout(cct, 20) << "required alignment=" << align << dendl;
3363 int RGWRados::get_max_chunk_size(const rgw_pool& pool, uint64_t *max_chunk_size)
3365 uint64_t alignment = 0;
3366 int r = get_required_alignment(pool, &alignment);
3371 uint64_t config_chunk_size = cct->_conf->rgw_max_chunk_size;
3373 if (alignment == 0) {
3374 *max_chunk_size = config_chunk_size;
3378 if (config_chunk_size <= alignment) {
3379 *max_chunk_size = alignment;
3383 *max_chunk_size = config_chunk_size - (config_chunk_size % alignment);
3385 ldout(cct, 20) << "max_chunk_size=" << *max_chunk_size << dendl;
3390 int RGWRados::get_max_chunk_size(const string& placement_rule, const rgw_obj& obj, uint64_t *max_chunk_size)
3393 if (!get_obj_data_pool(placement_rule, obj, &pool)) {
3394 ldout(cct, 0) << "ERROR: failed to get data pool for object " << obj << dendl;
3397 return get_max_chunk_size(pool, max_chunk_size);
3400 class RGWIndexCompletionManager;
3402 struct complete_op_data {
3403 Mutex lock{"complete_op_data"};
3404 AioCompletion *rados_completion{nullptr};
3405 int manager_shard_id{-1};
3406 RGWIndexCompletionManager *manager{nullptr};
3410 rgw_bucket_entry_ver ver;
3411 cls_rgw_obj_key key;
3412 rgw_bucket_dir_entry_meta dir_meta;
3413 list<cls_rgw_obj_key> remove_objs;
3416 rgw_zone_set zones_trace;
3418 bool stopped{false};
3421 Mutex::Locker l(lock);
3426 class RGWIndexCompletionThread : public RGWRadosThread {
3429 uint64_t interval_msec() override {
3433 list<complete_op_data *> completions;
3435 Mutex completions_lock;
3437 RGWIndexCompletionThread(RGWRados *_store)
3438 : RGWRadosThread(_store, "index-complete"), store(_store), completions_lock("RGWIndexCompletionThread::completions_lock") {}
3440 int process() override;
3442 void add_completion(complete_op_data *completion) {
3444 Mutex::Locker l(completions_lock);
3445 completions.push_back(completion);
3452 int RGWIndexCompletionThread::process()
3454 list<complete_op_data *> comps;
3457 Mutex::Locker l(completions_lock);
3458 completions.swap(comps);
3461 for (auto c : comps) {
3462 std::unique_ptr<complete_op_data> up{c};
3467 ldout(store->ctx(), 20) << __func__ << "(): handling completion for key=" << c->key << dendl;
3469 RGWRados::BucketShard bs(store);
3471 int r = bs.init(c->obj.bucket, c->obj);
3473 ldout(cct, 0) << "ERROR: " << __func__ << "(): failed to initialize BucketShard, obj=" << c->obj << " r=" << r << dendl;
3474 /* not much to do */
3478 r = store->guard_reshard(&bs, c->obj, [&](RGWRados::BucketShard *bs) -> int {
3479 librados::ObjectWriteOperation o;
3480 cls_rgw_guard_bucket_resharding(o, -ERR_BUSY_RESHARDING);
3481 cls_rgw_bucket_complete_op(o, c->op, c->tag, c->ver, c->key, c->dir_meta, &c->remove_objs,
3482 c->log_op, c->bilog_op, &c->zones_trace);
3484 return bs->index_ctx.operate(bs->bucket_obj, &o);
3487 ldout(cct, 0) << "ERROR: " << __func__ << "(): bucket index completion failed, obj=" << c->obj << " r=" << r << dendl;
3488 /* ignoring error, can't do anything about it */
3491 r = store->data_log->add_entry(bs.bucket, bs.shard_id);
3493 lderr(store->ctx()) << "ERROR: failed writing data log" << dendl;
3500 class RGWIndexCompletionManager {
3501 RGWRados *store{nullptr};
3502 vector<Mutex *> locks;
3503 vector<set<complete_op_data *> > completions;
3505 RGWIndexCompletionThread *completion_thread{nullptr};
3509 std::atomic<int> cur_shard {0};
3513 RGWIndexCompletionManager(RGWRados *_store) : store(_store) {
3514 num_shards = store->ctx()->_conf->rgw_thread_pool_size;
3516 for (int i = 0; i < num_shards; i++) {
3518 snprintf(buf, sizeof(buf), "RGWIndexCompletionManager::lock::%d", i);
3519 locks.push_back(new Mutex(buf));
3522 completions.resize(num_shards);
3524 ~RGWIndexCompletionManager() {
3527 for (auto l : locks) {
3533 int result = cur_shard % num_shards;
3538 void create_completion(const rgw_obj& obj,
3539 RGWModifyOp op, string& tag,
3540 rgw_bucket_entry_ver& ver,
3541 const cls_rgw_obj_key& key,
3542 rgw_bucket_dir_entry_meta& dir_meta,
3543 list<cls_rgw_obj_key> *remove_objs, bool log_op,
3545 rgw_zone_set *zones_trace,
3546 complete_op_data **result);
3547 bool handle_completion(completion_t cb, complete_op_data *arg);
3550 completion_thread = new RGWIndexCompletionThread(store);
3551 int ret = completion_thread->init();
3555 completion_thread->start();
3559 if (completion_thread) {
3560 completion_thread->stop();
3561 delete completion_thread;
3564 for (int i = 0; i < num_shards; ++i) {
3565 Mutex::Locker l(*locks[i]);
3566 for (auto c : completions[i]) {
3567 Mutex::Locker cl(c->lock);
3571 completions.clear();
3575 static void obj_complete_cb(completion_t cb, void *arg)
3577 complete_op_data *completion = (complete_op_data *)arg;
3578 completion->lock.Lock();
3579 if (completion->stopped) {
3580 completion->lock.Unlock(); /* can drop lock, no one else is referencing us */
3584 bool need_delete = completion->manager->handle_completion(cb, completion);
3585 completion->lock.Unlock();
3592 void RGWIndexCompletionManager::create_completion(const rgw_obj& obj,
3593 RGWModifyOp op, string& tag,
3594 rgw_bucket_entry_ver& ver,
3595 const cls_rgw_obj_key& key,
3596 rgw_bucket_dir_entry_meta& dir_meta,
3597 list<cls_rgw_obj_key> *remove_objs, bool log_op,
3599 rgw_zone_set *zones_trace,
3600 complete_op_data **result)
3602 complete_op_data *entry = new complete_op_data;
3604 int shard_id = next_shard();
3606 entry->manager_shard_id = shard_id;
3607 entry->manager = this;
3613 entry->dir_meta = dir_meta;
3614 entry->log_op = log_op;
3615 entry->bilog_op = bilog_op;
3618 for (auto iter = remove_objs->begin(); iter != remove_objs->end(); ++iter) {
3619 entry->remove_objs.push_back(*iter);
3624 entry->zones_trace = *zones_trace;
3626 entry->zones_trace.insert(store->get_zone().id);
3631 entry->rados_completion = librados::Rados::aio_create_completion(entry, NULL, obj_complete_cb);
3633 Mutex::Locker l(*locks[shard_id]);
3634 completions[shard_id].insert(entry);
3637 bool RGWIndexCompletionManager::handle_completion(completion_t cb, complete_op_data *arg)
3639 int shard_id = arg->manager_shard_id;
3641 Mutex::Locker l(*locks[shard_id]);
3643 auto& comps = completions[shard_id];
3645 auto iter = comps.find(arg);
3646 if (iter == comps.end()) {
3653 int r = rados_aio_get_return_value(cb);
3654 if (r != -ERR_BUSY_RESHARDING) {
3657 completion_thread->add_completion(arg);
3661 void RGWRados::finalize()
3663 if (run_sync_thread) {
3664 Mutex::Locker l(meta_sync_thread_lock);
3665 meta_sync_processor_thread->stop();
3667 Mutex::Locker dl(data_sync_thread_lock);
3668 for (auto iter : data_sync_processor_threads) {
3669 RGWDataSyncProcessorThread *thread = iter.second;
3672 if (sync_log_trimmer) {
3673 sync_log_trimmer->stop();
3677 async_rados->stop();
3679 if (run_sync_thread) {
3680 delete meta_sync_processor_thread;
3681 meta_sync_processor_thread = NULL;
3682 Mutex::Locker dl(data_sync_thread_lock);
3683 for (auto iter : data_sync_processor_threads) {
3684 RGWDataSyncProcessorThread *thread = iter.second;
3687 data_sync_processor_threads.clear();
3688 delete sync_log_trimmer;
3689 sync_log_trimmer = nullptr;
3694 if (need_watch_notify()) {
3698 /* delete finisher only after cleaning up watches, as watch error path might call
3699 * into finisher. We stop finisher before finalizing watch to make sure we don't
3700 * actually handle any racing work
3704 if (meta_notifier) {
3705 meta_notifier->stop();
3706 delete meta_notifier;
3708 if (data_notifier) {
3709 data_notifier->stop();
3710 delete data_notifier;
3726 delete rest_master_conn;
3728 map<string, RGWRESTConn *>::iterator iter;
3729 for (iter = zone_conn_map.begin(); iter != zone_conn_map.end(); ++iter) {
3730 RGWRESTConn *conn = iter->second;
3734 for (iter = zonegroup_conn_map.begin(); iter != zonegroup_conn_map.end(); ++iter) {
3735 RGWRESTConn *conn = iter->second;
3738 RGWQuotaHandler::free_handler(quota_handler);
3744 delete obj_tombstone_cache;
3745 delete sync_modules_manager;
3747 if (reshard_wait.get()) {
3748 reshard_wait->stop();
3749 reshard_wait.reset();
3752 if (run_reshard_thread) {
3753 reshard->stop_processor();
3756 delete index_completion_manager;
3760 * Initialize the RADOS instance and prepare to do other ops
3761 * Returns 0 on success, -ERR# on failure.
3763 int RGWRados::init_rados()
3766 auto handles = std::vector<librados::Rados>{cct->_conf->rgw_num_rados_handles};
3768 for (auto& r : handles) {
3769 ret = r.init_with_context(cct);
3779 sync_modules_manager = new RGWSyncModulesManager();
3781 rgw_register_sync_modules(sync_modules_manager);
3783 auto crs = std::unique_ptr<RGWCoroutinesManagerRegistry>{
3784 new RGWCoroutinesManagerRegistry(cct)};
3785 ret = crs->hook_to_admin_command("cr dump");
3790 meta_mgr = new RGWMetadataManager(cct, this);
3791 data_log = new RGWDataChangesLog(cct, this);
3792 cr_registry = crs.release();
3794 std::swap(handles, rados);
3799 int RGWRados::register_to_service_map(const string& daemon_type, const map<string, string>& meta)
3801 map<string,string> metadata = meta;
3802 metadata["num_handles"] = stringify(rados.size());
3803 metadata["zonegroup_id"] = zonegroup.get_id();
3804 metadata["zonegroup_name"] = zonegroup.get_name();
3805 metadata["zone_name"] = zone_name();
3806 metadata["zone_id"] = zone_id();;
3807 string name = cct->_conf->name.get_id();
3808 if (name.find("rgw.") == 0) {
3809 name = name.substr(4);
3811 int ret = rados[0].service_daemon_register(daemon_type, name, metadata);
3813 ldout(cct, 0) << "ERROR: service_daemon_register() returned ret=" << ret << ": " << cpp_strerror(-ret) << dendl;
3821 * Add new connection to connections map
3822 * @param zonegroup_conn_map map which new connection will be added to
3823 * @param zonegroup zonegroup which new connection will connect to
3824 * @param new_connection pointer to new connection instance
3826 static void add_new_connection_to_map(map<string, RGWRESTConn *> &zonegroup_conn_map,
3827 const RGWZoneGroup &zonegroup, RGWRESTConn *new_connection)
3829 // Delete if connection is already exists
3830 map<string, RGWRESTConn *>::iterator iterZoneGroup = zonegroup_conn_map.find(zonegroup.get_id());
3831 if (iterZoneGroup != zonegroup_conn_map.end()) {
3832 delete iterZoneGroup->second;
3835 // Add new connection to connections map
3836 zonegroup_conn_map[zonegroup.get_id()] = new_connection;
3839 int RGWRados::convert_regionmap()
3841 RGWZoneGroupMap zonegroupmap;
3843 string pool_name = cct->_conf->rgw_zone_root_pool;
3844 if (pool_name.empty()) {
3845 pool_name = RGW_DEFAULT_ZONE_ROOT_POOL;
3847 string oid = region_map_oid;
3849 rgw_pool pool(pool_name);
3851 RGWObjectCtx obj_ctx(this);
3852 int ret = rgw_get_system_obj(this, obj_ctx, pool, oid, bl, NULL, NULL);
3853 if (ret < 0 && ret != -ENOENT) {
3855 } else if (ret == -ENOENT) {
3860 bufferlist::iterator iter = bl.begin();
3861 ::decode(zonegroupmap, iter);
3862 } catch (buffer::error& err) {
3863 ldout(cct, 0) << "error decoding regionmap from " << pool << ":" << oid << dendl;
3867 for (map<string, RGWZoneGroup>::iterator iter = zonegroupmap.zonegroups.begin();
3868 iter != zonegroupmap.zonegroups.end(); ++iter) {
3869 RGWZoneGroup& zonegroup = iter->second;
3870 ret = zonegroup.init(cct, this, false);
3871 ret = zonegroup.update();
3872 if (ret < 0 && ret != -ENOENT) {
3873 ldout(cct, 0) << "Error could not update zonegroup " << zonegroup.get_name() << ": " <<
3874 cpp_strerror(-ret) << dendl;
3876 } else if (ret == -ENOENT) {
3877 ret = zonegroup.create();
3879 ldout(cct, 0) << "Error could not create " << zonegroup.get_name() << ": " <<
3880 cpp_strerror(-ret) << dendl;
3886 current_period.set_user_quota(zonegroupmap.user_quota);
3887 current_period.set_bucket_quota(zonegroupmap.bucket_quota);
3889 // remove the region_map so we don't try to convert again
3890 rgw_raw_obj obj(pool, oid);
3891 ret = delete_system_obj(obj);
3893 ldout(cct, 0) << "Error could not remove " << obj
3894 << " after upgrading to zonegroup map: " << cpp_strerror(ret) << dendl;
3902 * Replace all region configuration with zonegroup for
3903 * backward compatability
3904 * Returns 0 on success, -ERR# on failure.
3906 int RGWRados::replace_region_with_zonegroup()
3908 /* copy default region */
3909 /* convert default region to default zonegroup */
3910 string default_oid = cct->_conf->rgw_default_region_info_oid;
3911 if (default_oid.empty()) {
3912 default_oid = default_region_info_oid;
3916 RGWZoneGroup default_zonegroup;
3917 rgw_pool pool{default_zonegroup.get_pool(cct)};
3918 string oid = "converted";
3920 RGWObjectCtx obj_ctx(this);
3922 int ret = rgw_get_system_obj(this, obj_ctx, pool ,oid, bl, NULL, NULL);
3923 if (ret < 0 && ret != -ENOENT) {
3924 ldout(cct, 0) << __func__ << " failed to read converted: ret "<< ret << " " << cpp_strerror(-ret)
3927 } else if (ret != -ENOENT) {
3928 ldout(cct, 20) << "System already converted " << dendl;
3932 string default_region;
3933 ret = default_zonegroup.init(cct, this, false, true);
3935 ldout(cct, 0) << __func__ << " failed init default region: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
3938 ret = default_zonegroup.read_default_id(default_region, true);
3939 if (ret < 0 && ret != -ENOENT) {
3940 ldout(cct, 0) << __func__ << " failed reading old default region: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
3944 /* convert regions to zonegroups */
3945 list<string> regions;
3946 ret = list_regions(regions);
3947 if (ret < 0 && ret != -ENOENT) {
3948 ldout(cct, 0) << __func__ << " failed to list regions: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
3950 } else if (ret == -ENOENT || regions.empty()) {
3951 RGWZoneParams zoneparams(default_zone_name);
3952 int ret = zoneparams.init(cct, this);
3953 if (ret < 0 && ret != -ENOENT) {
3954 ldout(cct, 0) << __func__ << ": error initializing default zone params: " << cpp_strerror(-ret) << dendl;
3957 /* update master zone */
3958 RGWZoneGroup default_zg(default_zonegroup_name);
3959 ret = default_zg.init(cct, this);
3960 if (ret < 0 && ret != -ENOENT) {
3961 ldout(cct, 0) << __func__ << ": error in initializing default zonegroup: " << cpp_strerror(-ret) << dendl;
3964 if (ret != -ENOENT && default_zg.master_zone.empty()) {
3965 default_zg.master_zone = zoneparams.get_id();
3966 return default_zg.update();
3971 string master_region, master_zone;
3972 for (list<string>::iterator iter = regions.begin(); iter != regions.end(); ++iter) {
3973 if (*iter != default_zonegroup_name){
3974 RGWZoneGroup region(*iter);
3975 int ret = region.init(cct, this, true, true);
3977 ldout(cct, 0) << __func__ << " failed init region "<< *iter << ": " << cpp_strerror(-ret) << dendl;
3980 if (region.is_master_zonegroup()) {
3981 master_region = region.get_id();
3982 master_zone = region.master_zone;
3987 /* create realm if there is none.
3988 The realm name will be the region and zone concatenated
3989 realm id will be mds of its name */
3990 if (realm.get_id().empty() && !master_region.empty() && !master_zone.empty()) {
3991 string new_realm_name = master_region + "." + master_zone;
3992 unsigned char md5[CEPH_CRYPTO_MD5_DIGESTSIZE];
3993 char md5_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 1];
3995 hash.Update((const byte *)new_realm_name.c_str(), new_realm_name.length());
3997 buf_to_hex(md5, CEPH_CRYPTO_MD5_DIGESTSIZE, md5_str);
3998 string new_realm_id(md5_str);
3999 RGWRealm new_realm(new_realm_id,new_realm_name);
4000 ret = new_realm.init(cct, this, false);
4002 ldout(cct, 0) << __func__ << " Error initing new realm: " << cpp_strerror(-ret) << dendl;
4005 ret = new_realm.create();
4006 if (ret < 0 && ret != -EEXIST) {
4007 ldout(cct, 0) << __func__ << " Error creating new realm: " << cpp_strerror(-ret) << dendl;
4010 ret = new_realm.set_as_default();
4012 ldout(cct, 0) << __func__ << " Error setting realm as default: " << cpp_strerror(-ret) << dendl;
4015 ret = realm.init(cct, this);
4017 ldout(cct, 0) << __func__ << " Error initing realm: " << cpp_strerror(-ret) << dendl;
4020 ret = current_period.init(cct, this, realm.get_id(), realm.get_name());
4022 ldout(cct, 0) << __func__ << " Error initing current period: " << cpp_strerror(-ret) << dendl;
4027 list<string>::iterator iter;
4028 /* create zonegroups */
4029 for (iter = regions.begin(); iter != regions.end(); ++iter)
4031 ldout(cct, 0) << __func__ << "Converting " << *iter << dendl;
4032 /* check to see if we don't have already a zonegroup with this name */
4033 RGWZoneGroup new_zonegroup(*iter);
4034 ret = new_zonegroup.init(cct , this);
4035 if (ret == 0 && new_zonegroup.get_id() != *iter) {
4036 ldout(cct, 0) << __func__ << " zonegroup "<< *iter << " already exists id " << new_zonegroup.get_id () <<
4037 " skipping conversion " << dendl;
4040 RGWZoneGroup zonegroup(*iter);
4041 zonegroup.set_id(*iter);
4042 int ret = zonegroup.init(cct, this, true, true);
4044 ldout(cct, 0) << __func__ << " failed init zonegroup: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
4047 zonegroup.realm_id = realm.get_id();
4048 /* fix default region master zone */
4049 if (*iter == default_zonegroup_name && zonegroup.master_zone.empty()) {
4050 ldout(cct, 0) << __func__ << " Setting default zone as master for default region" << dendl;
4051 zonegroup.master_zone = default_zone_name;
4053 ret = zonegroup.update();
4054 if (ret < 0 && ret != -EEXIST) {
4055 ldout(cct, 0) << __func__ << " failed to update zonegroup " << *iter << ": ret "<< ret << " " << cpp_strerror(-ret)
4059 ret = zonegroup.update_name();
4060 if (ret < 0 && ret != -EEXIST) {
4061 ldout(cct, 0) << __func__ << " failed to update_name for zonegroup " << *iter << ": ret "<< ret << " " << cpp_strerror(-ret)
4065 if (zonegroup.get_name() == default_region) {
4066 ret = zonegroup.set_as_default();
4068 ldout(cct, 0) << __func__ << " failed to set_as_default " << *iter << ": ret "<< ret << " " << cpp_strerror(-ret)
4073 for (map<string, RGWZone>::const_iterator iter = zonegroup.zones.begin(); iter != zonegroup.zones.end();
4075 ldout(cct, 0) << __func__ << " Converting zone" << iter->first << dendl;
4076 RGWZoneParams zoneparams(iter->first, iter->first);
4077 zoneparams.set_id(iter->first);
4078 zoneparams.realm_id = realm.get_id();
4079 ret = zoneparams.init(cct, this);
4080 if (ret < 0 && ret != -ENOENT) {
4081 ldout(cct, 0) << __func__ << " failed to init zoneparams " << iter->first << ": " << cpp_strerror(-ret) << dendl;
4083 } else if (ret == -ENOENT) {
4084 ldout(cct, 0) << __func__ << " zone is part of another cluster " << iter->first << " skipping " << dendl;
4087 zonegroup.realm_id = realm.get_id();
4088 ret = zoneparams.update();
4089 if (ret < 0 && ret != -EEXIST) {
4090 ldout(cct, 0) << __func__ << " failed to update zoneparams " << iter->first << ": " << cpp_strerror(-ret) << dendl;
4093 ret = zoneparams.update_name();
4094 if (ret < 0 && ret != -EEXIST) {
4095 ldout(cct, 0) << __func__ << " failed to init zoneparams " << iter->first << ": " << cpp_strerror(-ret) << dendl;
4100 if (!current_period.get_id().empty()) {
4101 ret = current_period.add_zonegroup(zonegroup);
4103 ldout(cct, 0) << __func__ << " failed to add zonegroup to current_period: " << cpp_strerror(-ret) << dendl;
4109 if (!current_period.get_id().empty()) {
4110 ret = current_period.update();
4112 ldout(cct, 0) << __func__ << " failed to update new period: " << cpp_strerror(-ret) << dendl;
4115 ret = current_period.store_info(false);
4117 ldout(cct, 0) << __func__ << " failed to store new period: " << cpp_strerror(-ret) << dendl;
4120 ret = current_period.reflect();
4122 ldout(cct, 0) << __func__ << " failed to update local objects: " << cpp_strerror(-ret) << dendl;
4127 for (auto const& iter : regions) {
4128 RGWZoneGroup zonegroup(iter);
4129 int ret = zonegroup.init(cct, this, true, true);
4131 ldout(cct, 0) << __func__ << " failed init zonegroup" << iter << ": ret "<< ret << " " << cpp_strerror(-ret) << dendl;
4134 ret = zonegroup.delete_obj(true);
4135 if (ret < 0 && ret != -ENOENT) {
4136 ldout(cct, 0) << __func__ << " failed to delete region " << iter << ": ret "<< ret << " " << cpp_strerror(-ret)
4142 /* mark as converted */
4143 ret = rgw_put_system_obj(this, pool, oid, bl.c_str(), bl.length(),
4144 true, NULL, real_time(), NULL);
4146 ldout(cct, 0) << __func__ << " failed to mark cluster as converted: ret "<< ret << " " << cpp_strerror(-ret)
4154 int RGWRados::init_zg_from_period(bool *initialized)
4156 *initialized = false;
4158 if (current_period.get_id().empty()) {
4162 int ret = zonegroup.init(cct, this);
4163 ldout(cct, 20) << "period zonegroup init ret " << ret << dendl;
4164 if (ret == -ENOENT) {
4168 ldout(cct, 0) << "failed reading zonegroup info: " << cpp_strerror(-ret) << dendl;
4171 ldout(cct, 20) << "period zonegroup name " << zonegroup.get_name() << dendl;
4173 map<string, RGWZoneGroup>::const_iterator iter =
4174 current_period.get_map().zonegroups.find(zonegroup.get_id());
4176 if (iter != current_period.get_map().zonegroups.end()) {
4177 ldout(cct, 20) << "using current period zonegroup " << zonegroup.get_name() << dendl;
4178 zonegroup = iter->second;
4179 ret = zonegroup.init(cct, this, false);
4181 ldout(cct, 0) << "failed init zonegroup: " << " " << cpp_strerror(-ret) << dendl;
4184 ret = zone_params.init(cct, this);
4185 if (ret < 0 && ret != -ENOENT) {
4186 ldout(cct, 0) << "failed reading zone params info: " << " " << cpp_strerror(-ret) << dendl;
4188 } if (ret ==-ENOENT && zonegroup.get_name() == default_zonegroup_name) {
4189 ldout(cct, 10) << " Using default name "<< default_zone_name << dendl;
4190 zone_params.set_name(default_zone_name);
4191 ret = zone_params.init(cct, this);
4192 if (ret < 0 && ret != -ENOENT) {
4193 ldout(cct, 0) << "failed reading zone params info: " << " " << cpp_strerror(-ret) << dendl;
4198 for (iter = current_period.get_map().zonegroups.begin();
4199 iter != current_period.get_map().zonegroups.end(); ++iter){
4200 const RGWZoneGroup& zg = iter->second;
4201 // use endpoints from the zonegroup's master zone
4202 auto master = zg.zones.find(zg.master_zone);
4203 if (master == zg.zones.end()) {
4204 // fix missing master zone for a single zone zonegroup
4205 if (zg.master_zone.empty() && zg.zones.size() == 1) {
4206 master = zg.zones.begin();
4207 ldout(cct, 0) << "zonegroup " << zg.get_name() << " missing master_zone, setting zone " <<
4208 master->second.name << " id:" << master->second.id << " as master" << dendl;
4209 if (zonegroup.get_id() == zg.get_id()) {
4210 zonegroup.master_zone = master->second.id;
4211 ret = zonegroup.update();
4213 ldout(cct, 0) << "error updating zonegroup : " << cpp_strerror(-ret) << dendl;
4217 RGWZoneGroup fixed_zg(zg.get_id(),zg.get_name());
4218 ret = fixed_zg.init(cct, this);
4220 ldout(cct, 0) << "error initializing zonegroup : " << cpp_strerror(-ret) << dendl;
4223 fixed_zg.master_zone = master->second.id;
4224 ret = fixed_zg.update();
4226 ldout(cct, 0) << "error initializing zonegroup : " << cpp_strerror(-ret) << dendl;
4231 ldout(cct, 0) << "zonegroup " << zg.get_name() << " missing zone for master_zone=" <<
4232 zg.master_zone << dendl;
4236 const auto& endpoints = master->second.endpoints;
4237 add_new_connection_to_map(zonegroup_conn_map, zg, new RGWRESTConn(cct, this, zg.get_id(), endpoints));
4238 if (!current_period.get_master_zonegroup().empty() &&
4239 zg.get_id() == current_period.get_master_zonegroup()) {
4240 rest_master_conn = new RGWRESTConn(cct, this, zg.get_id(), endpoints);
4244 *initialized = true;
4249 int RGWRados::init_zg_from_local(bool *creating_defaults)
4251 int ret = zonegroup.init(cct, this);
4252 if ( (ret < 0 && ret != -ENOENT) || (ret == -ENOENT && !cct->_conf->rgw_zonegroup.empty())) {
4253 ldout(cct, 0) << "failed reading zonegroup info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
4255 } else if (ret == -ENOENT) {
4256 *creating_defaults = true;
4257 ldout(cct, 10) << "Creating default zonegroup " << dendl;
4258 ret = zonegroup.create_default();
4260 ldout(cct, 0) << "failure in zonegroup create_default: ret "<< ret << " " << cpp_strerror(-ret)
4264 ret = zonegroup.init(cct, this);
4266 ldout(cct, 0) << "failure in zonegroup create_default: ret "<< ret << " " << cpp_strerror(-ret)
4271 ldout(cct, 20) << "zonegroup " << zonegroup.get_name() << dendl;
4272 if (zonegroup.is_master_zonegroup()) {
4273 // use endpoints from the zonegroup's master zone
4274 auto master = zonegroup.zones.find(zonegroup.master_zone);
4275 if (master == zonegroup.zones.end()) {
4276 // fix missing master zone for a single zone zonegroup
4277 if (zonegroup.master_zone.empty() && zonegroup.zones.size() == 1) {
4278 master = zonegroup.zones.begin();
4279 ldout(cct, 0) << "zonegroup " << zonegroup.get_name() << " missing master_zone, setting zone " <<
4280 master->second.name << " id:" << master->second.id << " as master" << dendl;
4281 zonegroup.master_zone = master->second.id;
4282 ret = zonegroup.update();
4284 ldout(cct, 0) << "error initializing zonegroup : " << cpp_strerror(-ret) << dendl;
4288 ldout(cct, 0) << "zonegroup " << zonegroup.get_name() << " missing zone for "
4289 "master_zone=" << zonegroup.master_zone << dendl;
4293 const auto& endpoints = master->second.endpoints;
4294 rest_master_conn = new RGWRESTConn(cct, this, zonegroup.get_id(), endpoints);
4301 bool RGWRados::zone_syncs_from(RGWZone& target_zone, RGWZone& source_zone)
4303 return target_zone.syncs_from(source_zone.name) &&
4304 sync_modules_manager->supports_data_export(source_zone.tier_type);
4308 * Initialize the RADOS instance and prepare to do other ops
4309 * Returns 0 on success, -ERR# on failure.
4311 int RGWRados::init_complete()
4313 int ret = realm.init(cct, this);
4314 if (ret < 0 && ret != -ENOENT) {
4315 ldout(cct, 0) << "failed reading realm info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
4317 } else if (ret != -ENOENT) {
4318 ldout(cct, 20) << "realm " << realm.get_name() << " " << realm.get_id() << dendl;
4319 ret = current_period.init(cct, this, realm.get_id(), realm.get_name());
4320 if (ret < 0 && ret != -ENOENT) {
4321 ldout(cct, 0) << "failed reading current period info: " << " " << cpp_strerror(-ret) << dendl;
4324 ldout(cct, 20) << "current period " << current_period.get_id() << dendl;
4327 ret = replace_region_with_zonegroup();
4329 lderr(cct) << "failed converting region to zonegroup : ret "<< ret << " " << cpp_strerror(-ret) << dendl;
4333 ret = convert_regionmap();
4335 lderr(cct) << "failed converting regionmap: " << cpp_strerror(-ret) << dendl;
4339 bool zg_initialized = false;
4341 if (!current_period.get_id().empty()) {
4342 ret = init_zg_from_period(&zg_initialized);
4348 bool creating_defaults = false;
4349 bool using_local = (!zg_initialized);
4351 ldout(cct, 10) << " cannot find current period zonegroup using local zonegroup" << dendl;
4352 ret = init_zg_from_local(&creating_defaults);
4356 // read period_config into current_period
4357 auto& period_config = current_period.get_config();
4358 ret = period_config.read(this, zonegroup.realm_id);
4359 if (ret < 0 && ret != -ENOENT) {
4360 ldout(cct, 0) << "ERROR: failed to read period config: "
4361 << cpp_strerror(ret) << dendl;
4366 ldout(cct, 10) << "Cannot find current period zone using local zone" << dendl;
4367 if (creating_defaults && cct->_conf->rgw_zone.empty()) {
4368 ldout(cct, 10) << " Using default name "<< default_zone_name << dendl;
4369 zone_params.set_name(default_zone_name);
4372 ret = zone_params.init(cct, this);
4373 if (ret < 0 && ret != -ENOENT) {
4374 lderr(cct) << "failed reading zone info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
4377 map<string, RGWZone>::iterator zone_iter = get_zonegroup().zones.find(zone_params.get_id());
4378 if (zone_iter == get_zonegroup().zones.end()) {
4380 lderr(cct) << "Cannot find zone id=" << zone_params.get_id() << " (name=" << zone_params.get_name() << ")" << dendl;
4383 ldout(cct, 1) << "Cannot find zone id=" << zone_params.get_id() << " (name=" << zone_params.get_name() << "), switching to local zonegroup configuration" << dendl;
4384 ret = init_zg_from_local(&creating_defaults);
4388 zone_iter = get_zonegroup().zones.find(zone_params.get_id());
4390 if (zone_iter != get_zonegroup().zones.end()) {
4391 zone_public_config = zone_iter->second;
4392 ldout(cct, 20) << "zone " << zone_params.get_name() << dendl;
4394 lderr(cct) << "Cannot find zone id=" << zone_params.get_id() << " (name=" << zone_params.get_name() << ")" << dendl;
4398 zone_short_id = current_period.get_map().get_zone_short_id(zone_params.get_id());
4400 if (run_sync_thread) {
4401 ret = sync_modules_manager->create_instance(cct, zone_public_config.tier_type, zone_params.tier_config, &sync_module);
4403 lderr(cct) << "ERROR: failed to init sync module instance, ret=" << ret << dendl;
4408 writeable_zone = (zone_public_config.tier_type.empty() || zone_public_config.tier_type == "rgw");
4410 init_unique_trans_id_deps();
4412 finisher = new Finisher(cct);
4415 period_puller.reset(new RGWPeriodPuller(this));
4416 period_history.reset(new RGWPeriodHistory(cct, period_puller.get(),
4419 if (need_watch_notify()) {
4422 lderr(cct) << "ERROR: failed to initialize watch: " << cpp_strerror(-ret) << dendl;
4427 /* first build all zones index */
4428 for (auto ziter : get_zonegroup().zones) {
4429 const string& id = ziter.first;
4430 RGWZone& z = ziter.second;
4431 zone_id_by_name[z.name] = id;
4435 if (zone_by_id.find(zone_id()) == zone_by_id.end()) {
4436 ldout(cct, 0) << "WARNING: could not find zone config in zonegroup for local zone (" << zone_id() << "), will use defaults" << dendl;
4438 zone_public_config = zone_by_id[zone_id()];
4439 for (auto ziter : get_zonegroup().zones) {
4440 const string& id = ziter.first;
4441 RGWZone& z = ziter.second;
4442 if (id == zone_id()) {
4445 if (z.endpoints.empty()) {
4446 ldout(cct, 0) << "WARNING: can't generate connection for zone " << z.id << " id " << z.name << ": no endpoints defined" << dendl;
4449 ldout(cct, 20) << "generating connection object for zone " << z.name << " id " << z.id << dendl;
4450 RGWRESTConn *conn = new RGWRESTConn(cct, this, z.id, z.endpoints);
4451 zone_conn_map[id] = conn;
4452 if (zone_syncs_from(zone_public_config, z) ||
4453 zone_syncs_from(z, zone_public_config)) {
4454 if (zone_syncs_from(zone_public_config, z)) {
4455 zone_data_sync_from_map[id] = conn;
4457 if (zone_syncs_from(z, zone_public_config)) {
4458 zone_data_notify_to_map[id] = conn;
4461 ldout(cct, 20) << "NOTICE: not syncing to/from zone " << z.name << " id " << z.id << dendl;
4465 ret = open_root_pool_ctx();
4469 ret = open_gc_pool_ctx();
4473 ret = open_lc_pool_ctx();
4477 ret = open_objexp_pool_ctx();
4481 ret = open_reshard_pool_ctx();
4485 pools_initialized = true;
4488 gc->initialize(cct, this);
4490 obj_expirer = new RGWObjectExpirer(this);
4492 if (use_gc_thread) {
4493 gc->start_processor();
4494 obj_expirer->start_processor();
4497 if (run_sync_thread) {
4498 // initialize the log period history. we want to do this any time we're not
4499 // running under radosgw-admin, so we check run_sync_thread here before
4500 // disabling it based on the zone/zonegroup setup
4501 meta_mgr->init_oldest_log_period();
4504 /* no point of running sync thread if we don't have a master zone configured
4505 or there is no rest_master_conn */
4506 if (get_zonegroup().master_zone.empty() || !rest_master_conn
4507 || current_period.get_id().empty()) {
4508 run_sync_thread = false;
4511 async_rados = new RGWAsyncRadosProcessor(this, cct->_conf->rgw_num_async_rados_threads);
4512 async_rados->start();
4514 ret = meta_mgr->init(current_period.get_id());
4516 lderr(cct) << "ERROR: failed to initialize metadata log: "
4517 << cpp_strerror(-ret) << dendl;
4521 if (is_meta_master()) {
4522 auto md_log = meta_mgr->get_log(current_period.get_id());
4523 meta_notifier = new RGWMetaNotifier(this, md_log);
4524 meta_notifier->start();
4527 if (run_sync_thread) {
4528 Mutex::Locker l(meta_sync_thread_lock);
4529 meta_sync_processor_thread = new RGWMetaSyncProcessorThread(this, async_rados);
4530 ret = meta_sync_processor_thread->init();
4532 ldout(cct, 0) << "ERROR: failed to initialize meta sync thread" << dendl;
4535 meta_sync_processor_thread->start();
4537 Mutex::Locker dl(data_sync_thread_lock);
4538 for (auto iter : zone_data_sync_from_map) {
4539 ldout(cct, 5) << "starting data sync thread for zone " << iter.first << dendl;
4540 RGWDataSyncProcessorThread *thread = new RGWDataSyncProcessorThread(this, async_rados, iter.first);
4541 ret = thread->init();
4543 ldout(cct, 0) << "ERROR: failed to initialize data sync thread" << dendl;
4547 data_sync_processor_threads[iter.first] = thread;
4549 auto interval = cct->_conf->rgw_sync_log_trim_interval;
4551 sync_log_trimmer = new RGWSyncLogTrimThread(this, interval);
4552 ret = sync_log_trimmer->init();
4554 ldout(cct, 0) << "ERROR: failed to initialize sync log trim thread" << dendl;
4557 sync_log_trimmer->start();
4560 data_notifier = new RGWDataNotifier(this);
4561 data_notifier->start();
4564 lc->initialize(cct, this);
4567 lc->start_processor();
4569 quota_handler = RGWQuotaHandler::generate_handler(this, quota_threads);
4571 bucket_index_max_shards = (cct->_conf->rgw_override_bucket_index_max_shards ? cct->_conf->rgw_override_bucket_index_max_shards :
4572 get_zone().bucket_index_max_shards);
4573 if (bucket_index_max_shards > get_max_bucket_shards()) {
4574 bucket_index_max_shards = get_max_bucket_shards();
4575 ldout(cct, 1) << __func__ << " bucket index max shards is too large, reset to value: "
4576 << get_max_bucket_shards() << dendl;
4578 ldout(cct, 20) << __func__ << " bucket index max shards: " << bucket_index_max_shards << dendl;
4580 binfo_cache = new RGWChainedCacheImpl<bucket_info_entry>;
4581 binfo_cache->init(this);
4583 bool need_tombstone_cache = !zone_data_notify_to_map.empty(); /* have zones syncing from us */
4585 if (need_tombstone_cache) {
4586 obj_tombstone_cache = new tombstone_cache_t(cct->_conf->rgw_obj_tombstone_cache_size);
4589 reshard_wait = std::make_shared<RGWReshardWait>(this);
4591 reshard = new RGWReshard(this);
4593 /* only the master zone in the zonegroup reshards buckets */
4594 run_reshard_thread = run_reshard_thread && (get_zonegroup().master_zone == zone_public_config.id);
4595 if (run_reshard_thread) {
4596 reshard->start_processor();
4599 index_completion_manager = new RGWIndexCompletionManager(this);
4600 ret = index_completion_manager->start();
4606 * Initialize the RADOS instance and prepare to do other ops
4607 * Returns 0 on success, -ERR# on failure.
4609 int RGWRados::initialize()
4617 return init_complete();
4620 void RGWRados::finalize_watch()
4622 for (int i = 0; i < num_watchers; i++) {
4623 RGWWatcher *watcher = watchers[i];
4624 watcher->unregister_watch();
4628 delete[] notify_oids;
4632 void RGWRados::schedule_context(Context *c) {
4636 int RGWRados::list_raw_prefixed_objs(const rgw_pool& pool, const string& prefix, list<string>& result)
4639 RGWListRawObjsCtx ctx;
4642 int r = list_raw_objects(pool, prefix, 1000,
4643 ctx, oids, &is_truncated);
4647 list<string>::iterator iter;
4648 for (iter = oids.begin(); iter != oids.end(); ++iter) {
4649 string& val = *iter;
4650 if (val.size() > prefix.size())
4651 result.push_back(val.substr(prefix.size()));
4653 } while (is_truncated);
4658 int RGWRados::list_regions(list<string>& regions)
4660 RGWZoneGroup zonegroup;
4662 return list_raw_prefixed_objs(zonegroup.get_pool(cct), region_info_oid_prefix, regions);
4665 int RGWRados::list_zonegroups(list<string>& zonegroups)
4667 RGWZoneGroup zonegroup;
4669 return list_raw_prefixed_objs(zonegroup.get_pool(cct), zonegroup_names_oid_prefix, zonegroups);
4672 int RGWRados::list_zones(list<string>& zones)
4674 RGWZoneParams zoneparams;
4676 return list_raw_prefixed_objs(zoneparams.get_pool(cct), zone_names_oid_prefix, zones);
4679 int RGWRados::list_realms(list<string>& realms)
4681 RGWRealm realm(cct, this);
4682 return list_raw_prefixed_objs(realm.get_pool(cct), realm_names_oid_prefix, realms);
4685 int RGWRados::list_periods(list<string>& periods)
4688 list<string> raw_periods;
4689 int ret = list_raw_prefixed_objs(period.get_pool(cct), period.get_info_oid_prefix(), raw_periods);
4693 for (const auto& oid : raw_periods) {
4694 size_t pos = oid.find(".");
4695 if (pos != std::string::npos) {
4696 periods.push_back(oid.substr(0, pos));
4698 periods.push_back(oid);
4701 periods.sort(); // unique() only detects duplicates if they're adjacent
4707 int RGWRados::list_periods(const string& current_period, list<string>& periods)
4710 string period_id = current_period;
4711 while(!period_id.empty()) {
4712 RGWPeriod period(period_id);
4713 ret = period.init(cct, this);
4717 periods.push_back(period.get_id());
4718 period_id = period.get_predecessor();
4725 * Open the pool used as root for this gateway
4726 * Returns: 0 on success, -ERR# otherwise.
4728 int RGWRados::open_root_pool_ctx()
4730 return rgw_init_ioctx(get_rados_handle(), get_zone_params().domain_root, root_pool_ctx, true);
4733 int RGWRados::open_gc_pool_ctx()
4735 return rgw_init_ioctx(get_rados_handle(), get_zone_params().gc_pool, gc_pool_ctx, true);
4738 int RGWRados::open_lc_pool_ctx()
4740 return rgw_init_ioctx(get_rados_handle(), get_zone_params().lc_pool, lc_pool_ctx, true);
4743 int RGWRados::open_objexp_pool_ctx()
4745 return rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, objexp_pool_ctx, true);
4748 int RGWRados::open_reshard_pool_ctx()
4750 return rgw_init_ioctx(get_rados_handle(), get_zone_params().reshard_pool, reshard_pool_ctx, true);
4753 int RGWRados::init_watch()
4755 int r = rgw_init_ioctx(&rados[0], get_zone_params().control_pool, control_pool_ctx, true);
4760 num_watchers = cct->_conf->rgw_num_control_oids;
4762 bool compat_oid = (num_watchers == 0);
4764 if (num_watchers <= 0)
4767 notify_oids = new string[num_watchers];
4768 watchers = new RGWWatcher *[num_watchers];
4770 for (int i=0; i < num_watchers; i++) {
4771 string& notify_oid = notify_oids[i];
4772 notify_oid = notify_oid_prefix;
4775 snprintf(buf, sizeof(buf), ".%d", i);
4776 notify_oid.append(buf);
4778 r = control_pool_ctx.create(notify_oid, false);
4779 if (r < 0 && r != -EEXIST)
4782 RGWWatcher *watcher = new RGWWatcher(this, i, notify_oid);
4783 watchers[i] = watcher;
4785 r = watcher->register_watch();
4790 watch_initialized = true;
4792 set_cache_enabled(true);
4797 void RGWRados::pick_control_oid(const string& key, string& notify_oid)
4799 uint32_t r = ceph_str_hash_linux(key.c_str(), key.size());
4801 int i = r % num_watchers;
4803 snprintf(buf, sizeof(buf), ".%d", i);
4805 notify_oid = notify_oid_prefix;
4806 notify_oid.append(buf);
4809 int RGWRados::open_pool_ctx(const rgw_pool& pool, librados::IoCtx& io_ctx)
4811 librados::Rados *rad = get_rados_handle();
4812 int r = rgw_init_ioctx(rad, pool, io_ctx);
4816 if (!pools_initialized)
4819 r = rad->pool_create(pool.name.c_str());
4820 if (r < 0 && r != -EEXIST)
4823 r = rgw_init_ioctx(rad, pool, io_ctx);
4827 r = io_ctx.application_enable(pg_pool_t::APPLICATION_NAME_RGW, false);
4828 if (r < 0 && r != -EOPNOTSUPP)
4833 void RGWRados::build_bucket_index_marker(const string& shard_id_str, const string& shard_marker,
4836 *marker = shard_id_str;
4837 marker->append(BucketIndexShardsManager::KEY_VALUE_SEPARATOR);
4838 marker->append(shard_marker);
4842 int RGWRados::open_bucket_index_ctx(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx)
4844 const string *rule = &bucket_info.placement_rule;
4845 if (rule->empty()) {
4846 rule = &zonegroup.default_placement;
4848 auto iter = zone_params.placement_pools.find(*rule);
4849 if (iter == zone_params.placement_pools.end()) {
4850 ldout(cct, 0) << "could not find placement rule " << *rule << " within zonegroup " << dendl;
4854 int r = open_pool_ctx(iter->second.index_pool, index_ctx);
4862 * set up a bucket listing.
4863 * handle is filled in.
4864 * Returns 0 on success, -ERR# otherwise.
4866 int RGWRados::list_buckets_init(RGWAccessHandle *handle)
4868 librados::NObjectIterator *state = new librados::NObjectIterator(root_pool_ctx.nobjects_begin());
4869 *handle = (RGWAccessHandle)state;
4874 * get the next bucket in the listing.
4876 * handle is updated.
4877 * returns 0 on success, -ERR# otherwise.
4879 int RGWRados::list_buckets_next(rgw_bucket_dir_entry& obj, RGWAccessHandle *handle)
4881 librados::NObjectIterator *state = (librados::NObjectIterator *)*handle;
4884 if (*state == root_pool_ctx.nobjects_end()) {
4889 obj.key.name = (*state)->get_oid();
4890 if (obj.key.name[0] == '_') {
4891 obj.key.name = obj.key.name.substr(1);
4895 } while (obj.key.name[0] == '.'); /* skip all entries starting with '.' */
4903 struct log_list_state {
4905 librados::IoCtx io_ctx;
4906 librados::NObjectIterator obit;
4909 int RGWRados::log_list_init(const string& prefix, RGWAccessHandle *handle)
4911 log_list_state *state = new log_list_state;
4912 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, state->io_ctx);
4917 state->prefix = prefix;
4918 state->obit = state->io_ctx.nobjects_begin();
4919 *handle = (RGWAccessHandle)state;
4923 int RGWRados::log_list_next(RGWAccessHandle handle, string *name)
4925 log_list_state *state = static_cast<log_list_state *>(handle);
4927 if (state->obit == state->io_ctx.nobjects_end()) {
4931 if (state->prefix.length() &&
4932 state->obit->get_oid().find(state->prefix) != 0) {
4936 *name = state->obit->get_oid();
4943 int RGWRados::log_remove(const string& name)
4945 librados::IoCtx io_ctx;
4946 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, io_ctx);
4949 return io_ctx.remove(name);
4952 struct log_show_state {
4953 librados::IoCtx io_ctx;
4955 bufferlist::iterator p;
4959 log_show_state() : pos(0), eof(false) {}
4962 int RGWRados::log_show_init(const string& name, RGWAccessHandle *handle)
4964 log_show_state *state = new log_show_state;
4965 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, state->io_ctx);
4971 *handle = (RGWAccessHandle)state;
4975 int RGWRados::log_show_next(RGWAccessHandle handle, rgw_log_entry *entry)
4977 log_show_state *state = static_cast<log_show_state *>(handle);
4978 off_t off = state->p.get_off();
4980 ldout(cct, 10) << "log_show_next pos " << state->pos << " bl " << state->bl.length()
4982 << " eof " << (int)state->eof
4985 unsigned chunk = 1024*1024;
4986 if ((state->bl.length() - off) < chunk/2 && !state->eof) {
4988 int r = state->io_ctx.read(state->name, more, chunk, state->pos);
4994 old.substr_of(state->bl, off, state->bl.length() - off);
4995 } catch (buffer::error& err) {
4999 state->bl.claim(old);
5000 state->bl.claim_append(more);
5001 state->p = state->bl.begin();
5002 if ((unsigned)r < chunk)
5004 ldout(cct, 10) << " read " << r << dendl;
5008 return 0; // end of file
5010 ::decode(*entry, state->p);
5012 catch (const buffer::error &e) {
5019 * usage_log_hash: get usage log key hash, based on name and index
5021 * Get the usage object name. Since a user may have more than 1
5022 * object holding that info (multiple shards), we use index to
5023 * specify that shard number. Once index exceeds max shards it
5025 * If name is not being set, results for all users will be returned
5026 * and index will wrap only after total shards number.
5028 * @param cct [in] ceph context
5029 * @param name [in] user name
5030 * @param hash [out] hash value
5031 * @param index [in] shard index number
5033 static void usage_log_hash(CephContext *cct, const string& name, string& hash, uint32_t index)
5035 uint32_t val = index;
5037 if (!name.empty()) {
5038 int max_user_shards = cct->_conf->rgw_usage_max_user_shards;
5039 val %= max_user_shards;
5040 val += ceph_str_hash_linux(name.c_str(), name.size());
5043 int max_shards = cct->_conf->rgw_usage_max_shards;
5044 snprintf(buf, sizeof(buf), RGW_USAGE_OBJ_PREFIX "%u", (unsigned)(val % max_shards));
5048 int RGWRados::log_usage(map<rgw_user_bucket, RGWUsageBatch>& usage_info)
5052 map<string, rgw_usage_log_info> log_objs;
5057 /* restructure usage map, zone by object hash */
5058 map<rgw_user_bucket, RGWUsageBatch>::iterator iter;
5059 for (iter = usage_info.begin(); iter != usage_info.end(); ++iter) {
5060 const rgw_user_bucket& ub = iter->first;
5061 RGWUsageBatch& info = iter->second;
5063 if (ub.user.empty()) {
5064 ldout(cct, 0) << "WARNING: RGWRados::log_usage(): user name empty (bucket=" << ub.bucket << "), skipping" << dendl;
5068 if (ub.user != last_user) {
5069 /* index *should* be random, but why waste extra cycles
5070 in most cases max user shards is not going to exceed 1,
5071 so just incrementing it */
5072 usage_log_hash(cct, ub.user, hash, index++);
5074 last_user = ub.user;
5075 vector<rgw_usage_log_entry>& v = log_objs[hash].entries;
5077 for (auto miter = info.m.begin(); miter != info.m.end(); ++miter) {
5078 v.push_back(miter->second);
5082 map<string, rgw_usage_log_info>::iterator liter;
5084 for (liter = log_objs.begin(); liter != log_objs.end(); ++liter) {
5085 int r = cls_obj_usage_log_add(liter->first, liter->second);
5092 int RGWRados::read_usage(const rgw_user& user, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
5093 bool *is_truncated, RGWUsageIter& usage_iter, map<rgw_user_bucket, rgw_usage_log_entry>& usage)
5095 uint32_t num = max_entries;
5096 string hash, first_hash;
5097 string user_str = user.to_str();
5098 usage_log_hash(cct, user_str, first_hash, 0);
5100 if (usage_iter.index) {
5101 usage_log_hash(cct, user_str, hash, usage_iter.index);
5109 map<rgw_user_bucket, rgw_usage_log_entry> ret_usage;
5110 map<rgw_user_bucket, rgw_usage_log_entry>::iterator iter;
5112 int ret = cls_obj_usage_log_read(hash, user_str, start_epoch, end_epoch, num,
5113 usage_iter.read_iter, ret_usage, is_truncated);
5120 num -= ret_usage.size();
5122 for (iter = ret_usage.begin(); iter != ret_usage.end(); ++iter) {
5123 usage[iter->first].aggregate(iter->second);
5127 if (!*is_truncated) {
5128 usage_iter.read_iter.clear();
5129 usage_log_hash(cct, user_str, hash, ++usage_iter.index);
5131 } while (num && !*is_truncated && hash != first_hash);
5135 int RGWRados::trim_usage(rgw_user& user, uint64_t start_epoch, uint64_t end_epoch)
5138 string hash, first_hash;
5139 string user_str = user.to_str();
5140 usage_log_hash(cct, user_str, first_hash, index);
5145 int ret = cls_obj_usage_log_trim(hash, user_str, start_epoch, end_epoch);
5153 usage_log_hash(cct, user_str, hash, ++index);
5154 } while (hash != first_hash);
5159 int RGWRados::key_to_shard_id(const string& key, int max_shards)
5161 return rgw_shards_hash(key, max_shards);
5164 void RGWRados::shard_name(const string& prefix, unsigned max_shards, const string& key, string& name, int *shard_id)
5166 uint32_t val = ceph_str_hash_linux(key.c_str(), key.size());
5169 *shard_id = val % max_shards;
5171 snprintf(buf, sizeof(buf), "%u", (unsigned)(val % max_shards));
5172 name = prefix + buf;
5175 void RGWRados::shard_name(const string& prefix, unsigned max_shards, const string& section, const string& key, string& name)
5177 uint32_t val = ceph_str_hash_linux(key.c_str(), key.size());
5178 val ^= ceph_str_hash_linux(section.c_str(), section.size());
5180 snprintf(buf, sizeof(buf), "%u", (unsigned)(val % max_shards));
5181 name = prefix + buf;
5184 void RGWRados::shard_name(const string& prefix, unsigned shard_id, string& name)
5187 snprintf(buf, sizeof(buf), "%u", shard_id);
5188 name = prefix + buf;
5192 void RGWRados::time_log_prepare_entry(cls_log_entry& entry, const real_time& ut, const string& section, const string& key, bufferlist& bl)
5194 cls_log_add_prepare_entry(entry, utime_t(ut), section, key, bl);
5197 int RGWRados::time_log_add_init(librados::IoCtx& io_ctx)
5199 return rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, io_ctx, true);
5203 int RGWRados::time_log_add(const string& oid, const real_time& ut, const string& section, const string& key, bufferlist& bl)
5205 librados::IoCtx io_ctx;
5207 int r = time_log_add_init(io_ctx);
5212 ObjectWriteOperation op;
5214 cls_log_add(op, t, section, key, bl);
5216 return io_ctx.operate(oid, &op);
5219 int RGWRados::time_log_add(const string& oid, list<cls_log_entry>& entries,
5220 librados::AioCompletion *completion, bool monotonic_inc)
5222 librados::IoCtx io_ctx;
5224 int r = time_log_add_init(io_ctx);
5229 ObjectWriteOperation op;
5230 cls_log_add(op, entries, monotonic_inc);
5233 r = io_ctx.operate(oid, &op);
5235 r = io_ctx.aio_operate(oid, completion, &op);
5240 int RGWRados::time_log_list(const string& oid, const real_time& start_time, const real_time& end_time,
5241 int max_entries, list<cls_log_entry>& entries,
5242 const string& marker,
5246 librados::IoCtx io_ctx;
5248 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, io_ctx);
5251 librados::ObjectReadOperation op;
5253 utime_t st(start_time);
5254 utime_t et(end_time);
5256 cls_log_list(op, st, et, marker, max_entries, entries,
5257 out_marker, truncated);
5261 int ret = io_ctx.operate(oid, &op, &obl);
5268 int RGWRados::time_log_info(const string& oid, cls_log_header *header)
5270 librados::IoCtx io_ctx;
5272 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, io_ctx);
5275 librados::ObjectReadOperation op;
5277 cls_log_info(op, header);
5281 int ret = io_ctx.operate(oid, &op, &obl);
5288 int RGWRados::time_log_info_async(librados::IoCtx& io_ctx, const string& oid, cls_log_header *header, librados::AioCompletion *completion)
5290 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, io_ctx);
5294 librados::ObjectReadOperation op;
5296 cls_log_info(op, header);
5298 int ret = io_ctx.aio_operate(oid, completion, &op, NULL);
5305 int RGWRados::time_log_trim(const string& oid, const real_time& start_time, const real_time& end_time,
5306 const string& from_marker, const string& to_marker,
5307 librados::AioCompletion *completion)
5309 librados::IoCtx io_ctx;
5311 int r = rgw_init_ioctx(get_rados_handle(), get_zone_params().log_pool, io_ctx);
5315 utime_t st(start_time);
5316 utime_t et(end_time);
5318 ObjectWriteOperation op;
5319 cls_log_trim(op, st, et, from_marker, to_marker);
5322 r = io_ctx.operate(oid, &op);
5324 r = io_ctx.aio_operate(oid, completion, &op);
5329 string RGWRados::objexp_hint_get_shardname(int shard_num)
5332 snprintf(buf, sizeof(buf), "%010u", (unsigned)shard_num);
5334 string objname("obj_delete_at_hint.");
5335 return objname + buf;
5338 int RGWRados::objexp_key_shard(const rgw_obj_index_key& key)
5340 string obj_key = key.name + key.instance;
5341 int num_shards = cct->_conf->rgw_objexp_hints_num_shards;
5342 uint32_t sid = ceph_str_hash_linux(obj_key.c_str(), obj_key.size());
5343 uint32_t sid2 = sid ^ ((sid & 0xFF) << 24);
5344 sid = rgw_shards_mod(sid2, num_shards);
5348 static string objexp_hint_get_keyext(const string& tenant_name,
5349 const string& bucket_name,
5350 const string& bucket_id,
5351 const rgw_obj_key& obj_key)
5353 return tenant_name + (tenant_name.empty() ? "" : ":") + bucket_name + ":" + bucket_id +
5354 ":" + obj_key.name + ":" + obj_key.instance;
5357 int RGWRados::objexp_hint_add(const ceph::real_time& delete_at,
5358 const string& tenant_name,
5359 const string& bucket_name,
5360 const string& bucket_id,
5361 const rgw_obj_index_key& obj_key)
5363 const string keyext = objexp_hint_get_keyext(tenant_name, bucket_name,
5364 bucket_id, obj_key);
5365 objexp_hint_entry he = {
5366 .tenant = tenant_name,
5367 .bucket_name = bucket_name,
5368 .bucket_id = bucket_id,
5370 .exp_time = delete_at };
5373 ObjectWriteOperation op;
5374 cls_timeindex_add(op, utime_t(delete_at), keyext, hebl);
5376 string shard_name = objexp_hint_get_shardname(objexp_key_shard(obj_key));
5377 return objexp_pool_ctx.operate(shard_name, &op);
5380 void RGWRados::objexp_get_shard(int shard_num,
5381 string& shard) /* out */
5383 shard = objexp_hint_get_shardname(shard_num);
5386 int RGWRados::objexp_hint_list(const string& oid,
5387 const ceph::real_time& start_time,
5388 const ceph::real_time& end_time,
5389 const int max_entries,
5390 const string& marker,
5391 list<cls_timeindex_entry>& entries, /* out */
5392 string *out_marker, /* out */
5393 bool *truncated) /* out */
5395 librados::ObjectReadOperation op;
5396 cls_timeindex_list(op, utime_t(start_time), utime_t(end_time), marker, max_entries, entries,
5397 out_marker, truncated);
5400 int ret = objexp_pool_ctx.operate(oid, &op, &obl);
5402 if ((ret < 0 ) && (ret != -ENOENT)) {
5406 if ((ret == -ENOENT) && truncated) {
5413 int RGWRados::objexp_hint_parse(cls_timeindex_entry &ti_entry, /* in */
5414 objexp_hint_entry& hint_entry) /* out */
5417 bufferlist::iterator iter = ti_entry.value.begin();
5418 ::decode(hint_entry, iter);
5419 } catch (buffer::error& err) {
5420 ldout(cct, 0) << "ERROR: couldn't decode avail_pools" << dendl;
5426 int RGWRados::objexp_hint_trim(const string& oid,
5427 const ceph::real_time& start_time,
5428 const ceph::real_time& end_time,
5429 const string& from_marker,
5430 const string& to_marker)
5432 int ret = cls_timeindex_trim(objexp_pool_ctx, oid, utime_t(start_time), utime_t(end_time),
5433 from_marker, to_marker);
5434 if ((ret < 0 ) && (ret != -ENOENT)) {
5441 int RGWRados::lock_exclusive(rgw_pool& pool, const string& oid, timespan& duration,
5442 string& zone_id, string& owner_id) {
5443 librados::IoCtx io_ctx;
5445 int r = rgw_init_ioctx(get_rados_handle(), pool, io_ctx);
5449 uint64_t msec = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
5450 utime_t ut(msec / 1000, msec % 1000);
5452 rados::cls::lock::Lock l(log_lock_name);
5454 l.set_cookie(owner_id);
5458 return l.lock_exclusive(&io_ctx, oid);
5461 int RGWRados::unlock(rgw_pool& pool, const string& oid, string& zone_id, string& owner_id) {
5462 librados::IoCtx io_ctx;
5464 int r = rgw_init_ioctx(get_rados_handle(), pool, io_ctx);
5469 rados::cls::lock::Lock l(log_lock_name);
5471 l.set_cookie(owner_id);
5473 return l.unlock(&io_ctx, oid);
5476 int RGWRados::decode_policy(bufferlist& bl, ACLOwner *owner)
5478 bufferlist::iterator i = bl.begin();
5479 RGWAccessControlPolicy policy(cct);
5481 policy.decode_owner(i);
5482 } catch (buffer::error& err) {
5483 ldout(cct, 0) << "ERROR: could not decode policy, caught buffer::error" << dendl;
5486 *owner = policy.get_owner();
5490 int rgw_policy_from_attrset(CephContext *cct, map<string, bufferlist>& attrset, RGWAccessControlPolicy *policy)
5492 map<string, bufferlist>::iterator aiter = attrset.find(RGW_ATTR_ACL);
5493 if (aiter == attrset.end())
5496 bufferlist& bl = aiter->second;
5497 bufferlist::iterator iter = bl.begin();
5499 policy->decode(iter);
5500 } catch (buffer::error& err) {
5501 ldout(cct, 0) << "ERROR: could not decode policy, caught buffer::error" << dendl;
5504 if (cct->_conf->subsys.should_gather(ceph_subsys_rgw, 15)) {
5505 RGWAccessControlPolicy_S3 *s3policy = static_cast<RGWAccessControlPolicy_S3 *>(policy);
5506 ldout(cct, 15) << __func__ << " Read AccessControlPolicy";
5507 s3policy->to_xml(*_dout);
5514 int RGWRados::Bucket::update_bucket_id(const string& new_bucket_id)
5516 rgw_bucket bucket = bucket_info.bucket;
5517 bucket.update_bucket_id(new_bucket_id);
5519 RGWObjectCtx obj_ctx(store);
5521 int ret = store->get_bucket_instance_info(obj_ctx, bucket, bucket_info, nullptr, nullptr);
5530 * get listing of the objects in a bucket.
5532 * max: maximum number of results to return
5533 * bucket: bucket to list contents of
5534 * prefix: only return results that match this prefix
5535 * delim: do not include results that match this string.
5536 * Any skipped results will have the matching portion of their name
5537 * inserted in common_prefixes with a "true" mark.
5538 * marker: if filled in, begin the listing with this object.
5539 * end_marker: if filled in, end the listing with this object.
5540 * result: the objects are put in here.
5541 * common_prefixes: if delim is filled in, any matching prefixes are placed here.
5542 * is_truncated: if number of objects in the bucket is bigger than max, then truncated.
5544 int RGWRados::Bucket::List::list_objects(int64_t max,
5545 vector<rgw_bucket_dir_entry> *result,
5546 map<string, bool> *common_prefixes,
5549 RGWRados *store = target->get_store();
5550 CephContext *cct = store->ctx();
5551 int shard_id = target->get_shard_id();
5554 bool truncated = true;
5555 int read_ahead = std::max(cct->_conf->rgw_list_bucket_min_readahead,max);
5559 rgw_obj_key marker_obj(params.marker.name, params.marker.instance, params.ns);
5560 rgw_obj_index_key cur_marker;
5561 marker_obj.get_index_key(&cur_marker);
5563 rgw_obj_key end_marker_obj(params.end_marker.name, params.end_marker.instance,
5565 rgw_obj_index_key cur_end_marker;
5566 end_marker_obj.get_index_key(&cur_end_marker);
5567 const bool cur_end_marker_valid = !params.end_marker.empty();
5569 rgw_obj_key prefix_obj(params.prefix);
5570 prefix_obj.ns = params.ns;
5571 string cur_prefix = prefix_obj.get_index_key_name();
5573 string bigger_than_delim;
5575 if (!params.delim.empty()) {
5576 unsigned long val = decode_utf8((unsigned char *)params.delim.c_str(), params.delim.size());
5577 char buf[params.delim.size() + 16];
5578 int r = encode_utf8(val + 1, (unsigned char *)buf);
5580 ldout(cct,0) << "ERROR: encode_utf8() failed" << dendl;
5585 bigger_than_delim = buf;
5587 /* if marker points at a common prefix, fast forward it into its upperbound string */
5588 int delim_pos = cur_marker.name.find(params.delim, cur_prefix.size());
5589 if (delim_pos >= 0) {
5590 string s = cur_marker.name.substr(0, delim_pos);
5591 s.append(bigger_than_delim);
5596 string skip_after_delim;
5597 while (truncated && count <= max) {
5598 if (skip_after_delim > cur_marker.name) {
5599 cur_marker = skip_after_delim;
5600 ldout(cct, 20) << "setting cur_marker=" << cur_marker.name << "[" << cur_marker.instance << "]" << dendl;
5602 std::map<string, rgw_bucket_dir_entry> ent_map;
5603 int r = store->cls_bucket_list(target->get_bucket_info(), shard_id, cur_marker, cur_prefix,
5604 read_ahead + 1 - count, params.list_versions, ent_map,
5605 &truncated, &cur_marker);
5609 std::map<string, rgw_bucket_dir_entry>::iterator eiter;
5610 for (eiter = ent_map.begin(); eiter != ent_map.end(); ++eiter) {
5611 rgw_bucket_dir_entry& entry = eiter->second;
5612 rgw_obj_index_key index_key = entry.key;
5614 rgw_obj_key obj(index_key);
5616 /* note that parse_raw_oid() here will not set the correct object's instance, as
5617 * rgw_obj_index_key encodes that separately. We don't need to set the instance because it's
5618 * not needed for the checks here and we end up using the raw entry for the return vector
5620 bool valid = rgw_obj_key::parse_raw_oid(index_key.name, &obj);
5622 ldout(cct, 0) << "ERROR: could not parse object name: " << obj.name << dendl;
5625 bool check_ns = (obj.ns == params.ns);
5626 if (!params.list_versions && !entry.is_visible()) {
5630 if (params.enforce_ns && !check_ns) {
5631 if (!params.ns.empty()) {
5632 /* we've iterated past the namespace we're searching -- done now */
5637 /* we're not looking at the namespace this object is in, next! */
5641 if (cur_end_marker_valid && cur_end_marker <= index_key) {
5647 params.marker = index_key;
5648 next_marker = index_key;
5651 if (params.filter && !params.filter->filter(obj.name, index_key.name))
5654 if (params.prefix.size() && (obj.name.compare(0, params.prefix.size(), params.prefix) != 0))
5657 if (!params.delim.empty()) {
5658 int delim_pos = obj.name.find(params.delim, params.prefix.size());
5660 if (delim_pos >= 0) {
5661 string prefix_key = obj.name.substr(0, delim_pos + 1);
5663 if (common_prefixes &&
5664 common_prefixes->find(prefix_key) == common_prefixes->end()) {
5669 next_marker = prefix_key;
5670 (*common_prefixes)[prefix_key] = true;
5672 int marker_delim_pos = cur_marker.name.find(params.delim, cur_prefix.size());
5674 skip_after_delim = cur_marker.name.substr(0, marker_delim_pos);
5675 skip_after_delim.append(bigger_than_delim);
5677 ldout(cct, 20) << "skip_after_delim=" << skip_after_delim << dendl;
5691 result->emplace_back(std::move(entry));
5695 // Either the back-end telling us truncated, or we don't consume all
5696 // items returned per the amount caller request
5697 truncated = (truncated || eiter != ent_map.end());
5702 *is_truncated = truncated;
5708 * create a rados pool, associated meta info
5709 * returns 0 on success, -ERR# otherwise.
5711 int RGWRados::create_pool(const rgw_pool& pool)
5715 librados::Rados *rad = get_rados_handle();
5716 ret = rad->pool_create(pool.name.c_str(), 0);
5719 else if (ret == -ERANGE) {
5722 << " ERROR: librados::Rados::pool_create returned " << cpp_strerror(-ret)
5723 << " (this can be due to a pool or placement group misconfiguration, e.g., pg_num < pgp_num)"
5729 librados::IoCtx io_ctx;
5730 ret = rad->ioctx_create(pool.name.c_str(), io_ctx);
5734 ret = io_ctx.application_enable(pg_pool_t::APPLICATION_NAME_RGW, false);
5735 if (ret < 0 && ret != -EOPNOTSUPP)
5740 int RGWRados::init_bucket_index(RGWBucketInfo& bucket_info, int num_shards)
5742 librados::IoCtx index_ctx; // context for new bucket
5744 string dir_oid = dir_oid_prefix;
5745 int r = open_bucket_index_ctx(bucket_info, index_ctx);
5750 dir_oid.append(bucket_info.bucket.bucket_id);
5752 map<int, string> bucket_objs;
5753 get_bucket_index_objects(dir_oid, num_shards, bucket_objs);
5755 return CLSRGWIssueBucketIndexInit(index_ctx, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
5758 void RGWRados::create_bucket_id(string *bucket_id)
5760 uint64_t iid = instance_id();
5761 uint64_t bid = next_bucket_id();
5762 char buf[get_zone_params().get_id().size() + 48];
5763 snprintf(buf, sizeof(buf), "%s.%llu.%llu", get_zone_params().get_id().c_str(), (long long)iid, (long long)bid);
5767 int RGWRados::create_bucket(RGWUserInfo& owner, rgw_bucket& bucket,
5768 const string& zonegroup_id,
5769 const string& placement_rule,
5770 const string& swift_ver_location,
5771 const RGWQuotaInfo * pquota_info,
5772 map<std::string, bufferlist>& attrs,
5773 RGWBucketInfo& info,
5775 obj_version *pep_objv,
5776 real_time creation_time,
5777 rgw_bucket *pmaster_bucket,
5778 uint32_t *pmaster_num_shards,
5781 #define MAX_CREATE_RETRIES 20 /* need to bound retries */
5782 string selected_placement_rule_name;
5783 RGWZonePlacementInfo rule_info;
5785 for (int i = 0; i < MAX_CREATE_RETRIES; i++) {
5787 ret = select_bucket_placement(owner, zonegroup_id, placement_rule,
5788 &selected_placement_rule_name, &rule_info);
5792 if (!pmaster_bucket) {
5793 create_bucket_id(&bucket.marker);
5794 bucket.bucket_id = bucket.marker;
5796 bucket.marker = pmaster_bucket->marker;
5797 bucket.bucket_id = pmaster_bucket->bucket_id;
5800 RGWObjVersionTracker& objv_tracker = info.objv_tracker;
5803 objv_tracker.write_version = *pobjv;
5805 objv_tracker.generate_new_write_ver(cct);
5808 info.bucket = bucket;
5809 info.owner = owner.user_id;
5810 info.zonegroup = zonegroup_id;
5811 info.placement_rule = selected_placement_rule_name;
5812 info.index_type = rule_info.index_type;
5813 info.swift_ver_location = swift_ver_location;
5814 info.swift_versioning = (!swift_ver_location.empty());
5815 if (pmaster_num_shards) {
5816 info.num_shards = *pmaster_num_shards;
5818 info.num_shards = bucket_index_max_shards;
5820 info.bucket_index_shard_hash_type = RGWBucketInfo::MOD;
5821 info.requester_pays = false;
5822 if (real_clock::is_zero(creation_time)) {
5823 info.creation_time = ceph::real_clock::now();
5825 info.creation_time = creation_time;
5828 info.quota = *pquota_info;
5831 int r = init_bucket_index(info, info.num_shards);
5836 ret = put_linked_bucket_info(info, exclusive, ceph::real_time(), pep_objv, &attrs, true);
5837 if (ret == -EEXIST) {
5838 librados::IoCtx index_ctx;
5839 map<int, string> bucket_objs;
5840 int r = open_bucket_index(info, index_ctx, bucket_objs);
5844 /* we need to reread the info and return it, caller will have a use for it */
5845 RGWObjVersionTracker instance_ver = info.objv_tracker;
5846 info.objv_tracker.clear();
5847 RGWObjectCtx obj_ctx(this);
5848 r = get_bucket_info(obj_ctx, bucket.tenant, bucket.name, info, NULL, NULL);
5853 ldout(cct, 0) << "get_bucket_info returned " << r << dendl;
5857 /* only remove it if it's a different bucket instance */
5858 if (info.bucket.bucket_id != bucket.bucket_id) {
5859 /* remove bucket meta instance */
5860 string entry = bucket.get_key();
5861 r = rgw_bucket_instance_remove_entry(this, entry, &instance_ver);
5865 map<int, string>::const_iterator biter;
5866 for (biter = bucket_objs.begin(); biter != bucket_objs.end(); ++biter) {
5867 // Do best effort removal
5868 index_ctx.remove(biter->second);
5871 /* ret == -ENOENT here */
5876 /* this is highly unlikely */
5877 ldout(cct, 0) << "ERROR: could not create bucket, continuously raced with bucket creation and removal" << dendl;
5881 int RGWRados::select_new_bucket_location(RGWUserInfo& user_info, const string& zonegroup_id, const string& request_rule,
5882 string *pselected_rule_name, RGWZonePlacementInfo *rule_info)
5885 /* first check that zonegroup exists within current period. */
5886 RGWZoneGroup zonegroup;
5887 int ret = get_zonegroup(zonegroup_id, zonegroup);
5889 ldout(cct, 0) << "could not find zonegroup " << zonegroup_id << " in current period" << dendl;
5893 /* find placement rule. Hierarchy: request rule > user default rule > zonegroup default rule */
5894 std::map<std::string, RGWZoneGroupPlacementTarget>::const_iterator titer;
5896 if (!request_rule.empty()) {
5897 titer = zonegroup.placement_targets.find(request_rule);
5898 if (titer == zonegroup.placement_targets.end()) {
5899 ldout(cct, 0) << "could not find requested placement id " << request_rule
5900 << " within zonegroup " << dendl;
5901 return -ERR_INVALID_LOCATION_CONSTRAINT;
5903 } else if (!user_info.default_placement.empty()) {
5904 titer = zonegroup.placement_targets.find(user_info.default_placement);
5905 if (titer == zonegroup.placement_targets.end()) {
5906 ldout(cct, 0) << "could not find user default placement id " << user_info.default_placement
5907 << " within zonegroup " << dendl;
5908 return -ERR_INVALID_LOCATION_CONSTRAINT;
5911 if (zonegroup.default_placement.empty()) { // zonegroup default rule as fallback, it should not be empty.
5912 ldout(cct, 0) << "misconfiguration, zonegroup default placement id should not be empty." << dendl;
5913 return -ERR_ZONEGROUP_DEFAULT_PLACEMENT_MISCONFIGURATION;
5915 titer = zonegroup.placement_targets.find(zonegroup.default_placement);
5916 if (titer == zonegroup.placement_targets.end()) {
5917 ldout(cct, 0) << "could not find zonegroup default placement id " << zonegroup.default_placement
5918 << " within zonegroup " << dendl;
5919 return -ERR_INVALID_LOCATION_CONSTRAINT;
5924 /* now check tag for the rule, whether user is permitted to use rule */
5925 const auto& target_rule = titer->second;
5926 if (!target_rule.user_permitted(user_info.placement_tags)) {
5927 ldout(cct, 0) << "user not permitted to use placement rule " << titer->first << dendl;
5931 if (pselected_rule_name)
5932 *pselected_rule_name = titer->first;
5934 return select_bucket_location_by_rule(titer->first, rule_info);
5937 int RGWRados::select_bucket_location_by_rule(const string& location_rule, RGWZonePlacementInfo *rule_info)
5939 if (location_rule.empty()) {
5940 /* we can only reach here if we're trying to set a bucket location from a bucket
5941 * created on a different zone, using a legacy / default pool configuration
5943 return select_legacy_bucket_placement(rule_info);
5947 * make sure that zone has this rule configured. We're
5948 * checking it for the local zone, because that's where this bucket object is going to
5951 map<string, RGWZonePlacementInfo>::iterator piter = get_zone_params().placement_pools.find(location_rule);
5952 if (piter == get_zone_params().placement_pools.end()) {
5953 /* couldn't find, means we cannot really place data for this bucket in this zone */
5954 if (get_zonegroup().equals(zonegroup.get_id())) {
5955 /* that's a configuration error, zone should have that rule, as we're within the requested
5959 /* oh, well, data is not going to be placed here, bucket object is just a placeholder */
5964 RGWZonePlacementInfo& placement_info = piter->second;
5967 *rule_info = placement_info;
5973 int RGWRados::select_bucket_placement(RGWUserInfo& user_info, const string& zonegroup_id, const string& placement_rule,
5974 string *pselected_rule_name, RGWZonePlacementInfo *rule_info)
5976 if (!get_zone_params().placement_pools.empty()) {
5977 return select_new_bucket_location(user_info, zonegroup_id, placement_rule,
5978 pselected_rule_name, rule_info);
5981 if (pselected_rule_name) {
5982 pselected_rule_name->clear();
5985 return select_legacy_bucket_placement(rule_info);
5988 int RGWRados::select_legacy_bucket_placement(RGWZonePlacementInfo *rule_info)
5991 map<string, bufferlist> m;
5993 bool write_map = false;
5995 rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
5997 RGWObjectCtx obj_ctx(this);
5998 int ret = rgw_get_system_obj(this, obj_ctx, get_zone_params().domain_root, avail_pools, map_bl, NULL, NULL);
6004 bufferlist::iterator iter = map_bl.begin();
6006 } catch (buffer::error& err) {
6007 ldout(cct, 0) << "ERROR: couldn't decode avail_pools" << dendl;
6013 ret = omap_get_all(obj, header, m);
6018 if (ret < 0 || m.empty()) {
6019 vector<rgw_pool> pools;
6020 string s = string("default.") + default_storage_pool_suffix;
6021 pools.push_back(rgw_pool(s));
6022 vector<int> retcodes;
6024 ret = create_pools(pools, retcodes);
6027 ret = omap_set(obj, s, bl);
6035 ::encode(m, new_bl);
6036 ret = put_system_obj_data(NULL, obj, new_bl, -1, false);
6038 ldout(cct, 0) << "WARNING: could not save avail pools map info ret=" << ret << dendl;
6042 map<string, bufferlist>::iterator miter;
6045 for (miter = m.begin(); miter != m.end(); ++miter) {
6046 v.push_back(miter->first);
6050 ret = get_random_bytes((char *)&r, sizeof(r));
6054 int i = r % v.size();
6058 pool_name = miter->first;
6061 rule_info->data_pool = pool_name;
6062 rule_info->data_extra_pool = pool_name;
6063 rule_info->index_pool = pool_name;
6064 rule_info->index_type = RGWBIType_Normal;
6069 bool RGWRados::get_obj_data_pool(const string& placement_rule, const rgw_obj& obj, rgw_pool *pool)
6071 return rgw_get_obj_data_pool(zonegroup, zone_params, placement_rule, obj, pool);
6074 bool RGWRados::obj_to_raw(const string& placement_rule, const rgw_obj& obj, rgw_raw_obj *raw_obj)
6076 get_obj_bucket_and_oid_loc(obj, raw_obj->oid, raw_obj->loc);
6078 return get_obj_data_pool(placement_rule, obj, &raw_obj->pool);
6081 int RGWRados::update_placement_map()
6084 map<string, bufferlist> m;
6085 rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
6086 int ret = omap_get_all(obj, header, m);
6091 ::encode(m, new_bl);
6092 ret = put_system_obj_data(NULL, obj, new_bl, -1, false);
6094 ldout(cct, 0) << "WARNING: could not save avail pools map info ret=" << ret << dendl;
6100 int RGWRados::add_bucket_placement(const rgw_pool& new_pool)
6102 librados::Rados *rad = get_rados_handle();
6103 int ret = rad->pool_lookup(new_pool.name.c_str());
6104 if (ret < 0) // DNE, or something
6107 rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
6108 bufferlist empty_bl;
6109 ret = omap_set(obj, new_pool.to_str(), empty_bl);
6111 // don't care about return value
6112 update_placement_map();
6117 int RGWRados::remove_bucket_placement(const rgw_pool& old_pool)
6119 rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
6120 int ret = omap_del(obj, old_pool.to_str());
6122 // don't care about return value
6123 update_placement_map();
6128 int RGWRados::list_placement_set(set<rgw_pool>& names)
6131 map<string, bufferlist> m;
6133 rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
6134 int ret = omap_get_all(obj, header, m);
6139 map<string, bufferlist>::iterator miter;
6140 for (miter = m.begin(); miter != m.end(); ++miter) {
6141 names.insert(rgw_pool(miter->first));
6144 return names.size();
6147 int RGWRados::create_pools(vector<rgw_pool>& pools, vector<int>& retcodes)
6149 vector<librados::PoolAsyncCompletion *> completions;
6152 librados::Rados *rad = get_rados_handle();
6153 for (auto iter = pools.begin(); iter != pools.end(); ++iter) {
6154 librados::PoolAsyncCompletion *c = librados::Rados::pool_async_create_completion();
6155 completions.push_back(c);
6156 rgw_pool& pool = *iter;
6157 int ret = rad->pool_create_async(pool.name.c_str(), c);
6158 rets.push_back(ret);
6161 vector<int>::iterator riter;
6162 vector<librados::PoolAsyncCompletion *>::iterator citer;
6165 assert(rets.size() == completions.size());
6166 for (riter = rets.begin(), citer = completions.begin(); riter != rets.end(); ++riter, ++citer) {
6168 PoolAsyncCompletion *c = *citer;
6171 r = c->get_return_value();
6173 ldout(cct, 0) << "WARNING: async pool_create returned " << r << dendl;
6178 retcodes.push_back(r);
6184 std::vector<librados::IoCtx> io_ctxs;
6186 for (auto pool : pools) {
6187 io_ctxs.emplace_back();
6188 int ret = rad->ioctx_create(pool.name.c_str(), io_ctxs.back());
6190 ldout(cct, 0) << "WARNING: ioctx_create returned " << ret << dendl;
6193 retcodes.push_back(ret);
6199 completions.clear();
6200 for (auto &io_ctx : io_ctxs) {
6201 librados::PoolAsyncCompletion *c =
6202 librados::Rados::pool_async_create_completion();
6203 completions.push_back(c);
6204 int ret = io_ctx.application_enable_async(pg_pool_t::APPLICATION_NAME_RGW,
6210 for (auto c : completions) {
6212 int ret = c->get_return_value();
6213 if (ret == -EOPNOTSUPP) {
6215 } else if (ret < 0) {
6216 ldout(cct, 0) << "WARNING: async application_enable returned " << ret
6221 retcodes.push_back(ret);
6226 int RGWRados::get_obj_head_ioctx(const RGWBucketInfo& bucket_info, const rgw_obj& obj, librados::IoCtx *ioctx)
6229 get_obj_bucket_and_oid_loc(obj, oid, key);
6232 if (!get_obj_data_pool(bucket_info.placement_rule, obj, &pool)) {
6233 ldout(cct, 0) << "ERROR: cannot get data pool for obj=" << obj << ", probably misconfiguration" << dendl;
6237 int r = open_pool_ctx(pool, *ioctx);
6242 ioctx->locator_set_key(key);
6247 int RGWRados::get_obj_head_ref(const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_rados_ref *ref)
6249 get_obj_bucket_and_oid_loc(obj, ref->oid, ref->key);
6252 if (!get_obj_data_pool(bucket_info.placement_rule, obj, &pool)) {
6253 ldout(cct, 0) << "ERROR: cannot get data pool for obj=" << obj << ", probably misconfiguration" << dendl;
6257 int r = open_pool_ctx(pool, ref->ioctx);
6262 ref->ioctx.locator_set_key(ref->key);
6267 int RGWRados::get_raw_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref)
6274 if (ref->oid.empty()) {
6275 ref->oid = obj.pool.to_str();
6276 ref->pool = get_zone_params().domain_root;
6278 ref->pool = obj.pool;
6280 r = open_pool_ctx(ref->pool, ref->ioctx);
6284 ref->ioctx.locator_set_key(ref->key);
6289 int RGWRados::get_system_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref)
6291 return get_raw_obj_ref(obj, ref);
6295 * fixes an issue where head objects were supposed to have a locator created, but ended
6298 int RGWRados::fix_head_obj_locator(const RGWBucketInfo& bucket_info, bool copy_obj, bool remove_bad, rgw_obj_key& key)
6300 const rgw_bucket& bucket = bucket_info.bucket;
6304 rgw_obj obj(bucket, key);
6306 get_obj_bucket_and_oid_loc(obj, oid, locator);
6308 if (locator.empty()) {
6309 ldout(cct, 20) << "object does not have a locator, nothing to fix" << dendl;
6313 librados::IoCtx ioctx;
6315 int ret = get_obj_head_ioctx(bucket_info, obj, &ioctx);
6317 cerr << "ERROR: get_obj_head_ioctx() returned ret=" << ret << std::endl;
6320 ioctx.locator_set_key(string()); /* override locator for this object, use empty locator */
6325 struct timespec mtime_ts;
6326 map<string, bufferlist> attrs;
6327 librados::ObjectReadOperation op;
6328 op.getxattrs(&attrs, NULL);
6329 op.stat2(&size, &mtime_ts, NULL);
6330 #define HEAD_SIZE 512 * 1024
6331 op.read(0, HEAD_SIZE, &data, NULL);
6333 ret = ioctx.operate(oid, &op, NULL);
6335 lderr(cct) << "ERROR: ioctx.operate(oid=" << oid << ") returned ret=" << ret << dendl;
6339 if (size > HEAD_SIZE) {
6340 lderr(cct) << "ERROR: returned object size (" << size << ") > HEAD_SIZE (" << HEAD_SIZE << ")" << dendl;
6344 if (size != data.length()) {
6345 lderr(cct) << "ERROR: returned object size (" << size << ") != data.length() (" << data.length() << ")" << dendl;
6350 librados::ObjectWriteOperation wop;
6352 wop.mtime2(&mtime_ts);
6354 map<string, bufferlist>::iterator iter;
6355 for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
6356 wop.setxattr(iter->first.c_str(), iter->second);
6361 ioctx.locator_set_key(locator);
6362 ioctx.operate(oid, &wop);
6366 ioctx.locator_set_key(string());
6368 ret = ioctx.remove(oid);
6370 lderr(cct) << "ERROR: failed to remove original bad object" << dendl;
6378 int RGWRados::move_rados_obj(librados::IoCtx& src_ioctx,
6379 const string& src_oid, const string& src_locator,
6380 librados::IoCtx& dst_ioctx,
6381 const string& dst_oid, const string& dst_locator)
6384 #define COPY_BUF_SIZE (4 * 1024 * 1024)
6386 uint64_t chunk_size = COPY_BUF_SIZE;
6390 struct timespec mtime_ts;
6393 if (src_oid == dst_oid && src_locator == dst_locator) {
6397 src_ioctx.locator_set_key(src_locator);
6398 dst_ioctx.locator_set_key(dst_locator);
6402 ObjectReadOperation rop;
6403 ObjectWriteOperation wop;
6406 rop.stat2(&size, &mtime_ts, NULL);
6407 mtime = real_clock::from_timespec(mtime_ts);
6409 rop.read(ofs, chunk_size, &data, NULL);
6410 ret = src_ioctx.operate(src_oid, &rop, NULL);
6415 if (data.length() == 0) {
6420 wop.create(true); /* make it exclusive */
6421 wop.mtime2(&mtime_ts);
6422 mtime = real_clock::from_timespec(mtime_ts);
6424 wop.write(ofs, data);
6425 ret = dst_ioctx.operate(dst_oid, &wop);
6426 ofs += data.length();
6427 done = data.length() != chunk_size;
6431 lderr(cct) << "ERROR: " << __func__ << ": copying " << src_oid << " -> " << dst_oid
6432 << ": expected " << size << " bytes to copy, ended up with " << ofs << dendl;
6437 src_ioctx.remove(src_oid);
6442 lderr(cct) << "ERROR: failed to copy " << src_oid << " -> " << dst_oid << dendl;
6447 * fixes an issue where head objects were supposed to have a locator created, but ended
6450 int RGWRados::fix_tail_obj_locator(const RGWBucketInfo& bucket_info, rgw_obj_key& key, bool fix, bool *need_fix)
6452 const rgw_bucket& bucket = bucket_info.bucket;
6453 rgw_obj obj(bucket, key);
6460 int r = get_obj_head_ref(bucket_info, obj, &ref);
6465 RGWObjState *astate = NULL;
6466 RGWObjectCtx rctx(this);
6467 r = get_obj_state(&rctx, bucket_info, obj, &astate, false);
6471 if (astate->has_manifest) {
6472 RGWObjManifest::obj_iterator miter;
6473 RGWObjManifest& manifest = astate->manifest;
6474 for (miter = manifest.obj_begin(); miter != manifest.obj_end(); ++miter) {
6475 rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(this);
6480 rgw_raw_obj_to_obj(manifest.get_tail_placement().bucket, raw_loc, &loc);
6482 if (loc.key.ns.empty()) {
6483 /* continue, we're only interested in tail objects */
6487 get_obj_bucket_and_oid_loc(loc, oid, locator);
6488 ref.ioctx.locator_set_key(locator);
6490 ldout(cct, 20) << __func__ << ": key=" << key << " oid=" << oid << " locator=" << locator << dendl;
6492 r = ref.ioctx.stat(oid, NULL, NULL);
6498 prepend_bucket_marker(bucket, loc.key.name, bad_loc);
6500 /* create a new ioctx with the bad locator */
6501 librados::IoCtx src_ioctx;
6502 src_ioctx.dup(ref.ioctx);
6503 src_ioctx.locator_set_key(bad_loc);
6505 r = src_ioctx.stat(oid, NULL, NULL);
6507 /* cannot find a broken part */
6510 ldout(cct, 20) << __func__ << ": found bad object part: " << loc << dendl;
6515 r = move_rados_obj(src_ioctx, oid, bad_loc, ref.ioctx, oid, locator);
6517 lderr(cct) << "ERROR: copy_rados_obj() on oid=" << oid << " returned r=" << r << dendl;
6526 int RGWRados::BucketShard::init(const rgw_bucket& _bucket, const rgw_obj& obj)
6530 RGWObjectCtx obj_ctx(store);
6532 RGWBucketInfo bucket_info;
6533 int ret = store->get_bucket_instance_info(obj_ctx, bucket, bucket_info, NULL, NULL);
6538 ret = store->open_bucket_index_shard(bucket_info, index_ctx, obj.get_hash_object(), &bucket_obj, &shard_id);
6540 ldout(store->ctx(), 0) << "ERROR: open_bucket_index_shard() returned ret=" << ret << dendl;
6543 ldout(store->ctx(), 20) << " bucket index object: " << bucket_obj << dendl;
6548 int RGWRados::BucketShard::init(const rgw_bucket& _bucket, int sid)
6553 RGWObjectCtx obj_ctx(store);
6555 RGWBucketInfo bucket_info;
6556 int ret = store->get_bucket_instance_info(obj_ctx, bucket, bucket_info, NULL, NULL);
6561 ret = store->open_bucket_index_shard(bucket_info, index_ctx, shard_id, &bucket_obj);
6563 ldout(store->ctx(), 0) << "ERROR: open_bucket_index_shard() returned ret=" << ret << dendl;
6566 ldout(store->ctx(), 20) << " bucket index object: " << bucket_obj << dendl;
6572 /* Execute @handler on last item in bucket listing for bucket specified
6573 * in @bucket_info. @obj_prefix and @obj_delim narrow down the listing
6574 * to objects matching these criterias. */
6575 int RGWRados::on_last_entry_in_listing(RGWBucketInfo& bucket_info,
6576 const std::string& obj_prefix,
6577 const std::string& obj_delim,
6578 std::function<int(const rgw_bucket_dir_entry&)> handler)
6580 RGWRados::Bucket target(this, bucket_info);
6581 RGWRados::Bucket::List list_op(&target);
6583 list_op.params.prefix = obj_prefix;
6584 list_op.params.delim = obj_delim;
6586 ldout(cct, 20) << "iterating listing for bucket=" << bucket_info.bucket.name
6587 << ", obj_prefix=" << obj_prefix
6588 << ", obj_delim=" << obj_delim
6591 bool is_truncated = false;
6593 boost::optional<rgw_bucket_dir_entry> last_entry;
6594 /* We need to rewind to the last object in a listing. */
6596 /* List bucket entries in chunks. */
6597 static constexpr int MAX_LIST_OBJS = 100;
6598 std::vector<rgw_bucket_dir_entry> entries(MAX_LIST_OBJS);
6600 int ret = list_op.list_objects(MAX_LIST_OBJS, &entries, nullptr,
6604 } else if (!entries.empty()) {
6605 last_entry = entries.back();
6607 } while (is_truncated);
6610 return handler(*last_entry);
6613 /* Empty listing - no items we can run handler on. */
6618 int RGWRados::swift_versioning_copy(RGWObjectCtx& obj_ctx,
6619 const rgw_user& user,
6620 RGWBucketInfo& bucket_info,
6623 if (! swift_versioning_enabled(bucket_info)) {
6627 obj_ctx.obj.set_atomic(obj);
6629 RGWObjState * state = nullptr;
6630 int r = get_obj_state(&obj_ctx, bucket_info, obj, &state, false);
6635 if (!state->exists) {
6642 const string& src_name = obj.get_oid();
6643 char buf[src_name.size() + 32];
6644 struct timespec ts = ceph::real_clock::to_timespec(state->mtime);
6645 snprintf(buf, sizeof(buf), "%03x%s/%lld.%06ld", (int)src_name.size(),
6646 src_name.c_str(), (long long)ts.tv_sec, ts.tv_nsec / 1000);
6648 RGWBucketInfo dest_bucket_info;
6650 r = get_bucket_info(obj_ctx, bucket_info.bucket.tenant, bucket_info.swift_ver_location, dest_bucket_info, NULL, NULL);
6652 ldout(cct, 10) << "failed to read dest bucket info: r=" << r << dendl;
6654 return -ERR_PRECONDITION_FAILED;
6659 if (dest_bucket_info.owner != bucket_info.owner) {
6660 return -ERR_PRECONDITION_FAILED;
6663 rgw_obj dest_obj(dest_bucket_info.bucket, buf);
6664 obj_ctx.obj.set_atomic(dest_obj);
6668 r = copy_obj(obj_ctx,
6672 NULL, /* req_info *info */
6678 NULL, /* time_t *src_mtime */
6679 NULL, /* time_t *mtime */
6680 NULL, /* const time_t *mod_ptr */
6681 NULL, /* const time_t *unmod_ptr */
6682 false, /* bool high_precision_time */
6683 NULL, /* const char *if_match */
6684 NULL, /* const char *if_nomatch */
6685 RGWRados::ATTRSMOD_NONE,
6686 true, /* bool copy_if_newer */
6688 RGW_OBJ_CATEGORY_MAIN,
6689 0, /* uint64_t olh_epoch */
6690 real_time(), /* time_t delete_at */
6691 NULL, /* string *version_id */
6692 NULL, /* string *ptag */
6693 NULL, /* string *petag */
6694 NULL, /* void (*progress_cb)(off_t, void *) */
6695 NULL); /* void *progress_data */
6696 if (r == -ECANCELED || r == -ENOENT) {
6697 /* Has already been overwritten, meaning another rgw process already
6705 int RGWRados::swift_versioning_restore(RGWObjectCtx& obj_ctx,
6706 const rgw_user& user,
6707 RGWBucketInfo& bucket_info,
6709 bool& restored) /* out */
6711 if (! swift_versioning_enabled(bucket_info)) {
6715 /* Bucket info of the bucket that stores previous versions of our object. */
6716 RGWBucketInfo archive_binfo;
6718 int ret = get_bucket_info(obj_ctx, bucket_info.bucket.tenant,
6719 bucket_info.swift_ver_location, archive_binfo,
6725 /* Abort the operation if the bucket storing our archive belongs to someone
6726 * else. This is a limitation in comparison to Swift as we aren't taking ACLs
6727 * into consideration. For we can live with that.
6729 * TODO: delegate this check to un upper layer and compare with ACLs. */
6730 if (bucket_info.owner != archive_binfo.owner) {
6734 /* This code will be executed on latest version of the object. */
6735 const auto handler = [&](const rgw_bucket_dir_entry& entry) -> int {
6736 std::string no_client_id;
6737 std::string no_op_id;
6738 std::string no_zone;
6740 /* We don't support object versioning of Swift API on those buckets that
6741 * are already versioned using the S3 mechanism. This affects also bucket
6742 * storing archived objects. Otherwise the delete operation would create
6743 * a deletion marker. */
6744 if (archive_binfo.versioned()) {
6746 return -ERR_PRECONDITION_FAILED;
6749 /* We are requesting ATTRSMOD_NONE so the attr attribute is perfectly
6750 * irrelevant and may be safely skipped. */
6751 std::map<std::string, ceph::bufferlist> no_attrs;
6753 rgw_obj archive_obj(archive_binfo.bucket, entry.key);
6754 obj_ctx.obj.set_atomic(archive_obj);
6755 obj_ctx.obj.set_atomic(obj);
6757 int ret = copy_obj(obj_ctx,
6761 nullptr, /* req_info *info */
6764 archive_obj, /* src obj */
6765 bucket_info, /* dest bucket info */
6766 archive_binfo, /* src bucket info */
6767 nullptr, /* time_t *src_mtime */
6768 nullptr, /* time_t *mtime */
6769 nullptr, /* const time_t *mod_ptr */
6770 nullptr, /* const time_t *unmod_ptr */
6771 false, /* bool high_precision_time */
6772 nullptr, /* const char *if_match */
6773 nullptr, /* const char *if_nomatch */
6774 RGWRados::ATTRSMOD_NONE,
6775 true, /* bool copy_if_newer */
6777 RGW_OBJ_CATEGORY_MAIN,
6778 0, /* uint64_t olh_epoch */
6779 real_time(), /* time_t delete_at */
6780 nullptr, /* string *version_id */
6781 nullptr, /* string *ptag */
6782 nullptr, /* string *petag */
6783 nullptr, /* void (*progress_cb)(off_t, void *) */
6784 nullptr); /* void *progress_data */
6785 if (ret == -ECANCELED || ret == -ENOENT) {
6786 /* Has already been overwritten, meaning another rgw process already
6789 } else if (ret < 0) {
6795 /* Need to remove the archived copy. */
6796 ret = delete_obj(obj_ctx, archive_binfo, archive_obj,
6797 archive_binfo.versioning_status());
6802 const std::string& obj_name = obj.get_oid();
6803 const auto prefix = boost::str(boost::format("%03x%s") % obj_name.size()
6806 return on_last_entry_in_listing(archive_binfo, prefix, std::string(),
6811 * Write/overwrite an object to the bucket storage.
6812 * bucket: the bucket to store the object in
6813 * obj: the object name/key
6814 * data: the object contents/value
6815 * size: the amount of data to write (data must be this long)
6816 * accounted_size: original size of data before compression, encryption
6817 * mtime: if non-NULL, writes the given mtime to the bucket storage
6818 * attrs: all the given attrs are written to bucket storage for the given object
6819 * exclusive: create object exclusively
6820 * Returns: 0 on success, -ERR# otherwise.
6822 int RGWRados::Object::Write::_do_write_meta(uint64_t size, uint64_t accounted_size,
6823 map<string, bufferlist>& attrs,
6824 bool assume_noent, bool modify_tail,
6827 RGWRados::Bucket::UpdateIndex *index_op = static_cast<RGWRados::Bucket::UpdateIndex *>(_index_op);
6828 RGWRados *store = target->get_store();
6830 ObjectWriteOperation op;
6833 int r = target->get_state(&state, false, assume_noent);
6837 rgw_obj& obj = target->get_obj();
6839 if (obj.get_oid().empty()) {
6840 ldout(store->ctx(), 0) << "ERROR: " << __func__ << "(): cannot write object with empty name" << dendl;
6845 r = store->get_obj_head_ref(target->get_bucket_info(), obj, &ref);
6849 bool is_olh = state->is_olh;
6851 bool reset_obj = (meta.flags & PUT_OBJ_CREATE) != 0;
6853 const string *ptag = meta.ptag;
6854 if (!ptag && !index_op->get_optag()->empty()) {
6855 ptag = index_op->get_optag();
6857 r = target->prepare_atomic_modification(op, reset_obj, ptag, meta.if_match, meta.if_nomatch, false, modify_tail);
6861 if (real_clock::is_zero(meta.set_mtime)) {
6862 meta.set_mtime = real_clock::now();
6865 if (state->is_olh) {
6866 op.setxattr(RGW_ATTR_OLH_ID_TAG, state->olh_tag);
6869 struct timespec mtime_ts = real_clock::to_timespec(meta.set_mtime);
6870 op.mtime2(&mtime_ts);
6873 /* if we want to overwrite the data, we also want to overwrite the
6874 xattrs, so just remove the object */
6875 op.write_full(*meta.data);
6879 string content_type;
6882 map<string, bufferlist>::iterator iter;
6884 for (iter = meta.rmattrs->begin(); iter != meta.rmattrs->end(); ++iter) {
6885 const string& name = iter->first;
6886 op.rmxattr(name.c_str());
6890 if (meta.manifest) {
6891 /* remove existing manifest attr */
6892 iter = attrs.find(RGW_ATTR_MANIFEST);
6893 if (iter != attrs.end())
6897 ::encode(*meta.manifest, bl);
6898 op.setxattr(RGW_ATTR_MANIFEST, bl);
6901 for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
6902 const string& name = iter->first;
6903 bufferlist& bl = iter->second;
6908 op.setxattr(name.c_str(), bl);
6910 if (name.compare(RGW_ATTR_ETAG) == 0) {
6912 } else if (name.compare(RGW_ATTR_CONTENT_TYPE) == 0) {
6913 content_type = bl.c_str();
6914 } else if (name.compare(RGW_ATTR_ACL) == 0) {
6918 if (attrs.find(RGW_ATTR_PG_VER) == attrs.end()) {
6919 cls_rgw_obj_store_pg_ver(op, RGW_ATTR_PG_VER);
6922 if (attrs.find(RGW_ATTR_SOURCE_ZONE) == attrs.end()) {
6924 ::encode(store->get_zone_short_id(), bl);
6925 op.setxattr(RGW_ATTR_SOURCE_ZONE, bl);
6936 if (!reset_obj) { //Multipart upload, it has immutable head.
6937 orig_exists = false;
6940 orig_exists = state->exists;
6941 orig_size = state->accounted_size;
6944 bool versioned_target = (meta.olh_epoch > 0 || !obj.key.instance.empty());
6946 bool versioned_op = (target->versioning_enabled() || is_olh || versioned_target);
6949 index_op->set_bilog_flags(RGW_BILOG_FLAG_VERSIONED_OP);
6952 if (!index_op->is_prepared()) {
6953 r = index_op->prepare(CLS_RGW_OP_ADD, &state->write_tag);
6958 r = ref.ioctx.operate(ref.oid, &op);
6959 if (r < 0) { /* we can expect to get -ECANCELED if object was replaced under,
6960 or -ENOENT if was removed, or -EEXIST if it did not exist
6961 before and now it does */
6962 if (r == -EEXIST && assume_noent) {
6963 target->invalidate_state();
6969 epoch = ref.ioctx.get_last_version();
6970 poolid = ref.ioctx.get_id();
6972 r = target->complete_atomic_modification();
6974 ldout(store->ctx(), 0) << "ERROR: complete_atomic_modification returned r=" << r << dendl;
6977 r = index_op->complete(poolid, epoch, size, accounted_size,
6978 meta.set_mtime, etag, content_type, &acl_bl,
6979 meta.category, meta.remove_objs, meta.user_data);
6984 *meta.mtime = meta.set_mtime;
6987 /* note that index_op was using state so we couldn't invalidate it earlier */
6988 target->invalidate_state();
6992 r = store->set_olh(target->get_ctx(), target->get_bucket_info(), obj, false, NULL, meta.olh_epoch, real_time(), false, meta.zones_trace);
6998 if (!real_clock::is_zero(meta.delete_at)) {
6999 rgw_obj_index_key obj_key;
7000 obj.key.get_index_key(&obj_key);
7002 r = store->objexp_hint_add(meta.delete_at,
7003 obj.bucket.tenant, obj.bucket.name, obj.bucket.bucket_id, obj_key);
7005 ldout(store->ctx(), 0) << "ERROR: objexp_hint_add() returned r=" << r << ", object will not get removed" << dendl;
7006 /* ignoring error, nothing we can do at this point */
7009 meta.canceled = false;
7011 /* update quota cache */
7012 if (meta.completeMultipart){
7013 store->quota_handler->update_stats(meta.owner, obj.bucket, (orig_exists ? 0 : 1),
7017 store->quota_handler->update_stats(meta.owner, obj.bucket, (orig_exists ? 0 : 1),
7018 accounted_size, orig_size);
7023 int ret = index_op->cancel();
7025 ldout(store->ctx(), 0) << "ERROR: index_op.cancel()() returned ret=" << ret << dendl;
7028 meta.canceled = true;
7030 /* we lost in a race. There are a few options:
7031 * - existing object was rewritten (ECANCELED)
7032 * - non existing object was created (EEXIST)
7033 * - object was removed (ENOENT)
7034 * should treat it as a success
7036 if (meta.if_match == NULL && meta.if_nomatch == NULL) {
7037 if (r == -ECANCELED || r == -ENOENT || r == -EEXIST) {
7041 if (meta.if_match != NULL) {
7042 // only overwrite existing object
7043 if (strcmp(meta.if_match, "*") == 0) {
7045 r = -ERR_PRECONDITION_FAILED;
7046 } else if (r == -ECANCELED) {
7052 if (meta.if_nomatch != NULL) {
7053 // only create a new object
7054 if (strcmp(meta.if_nomatch, "*") == 0) {
7056 r = -ERR_PRECONDITION_FAILED;
7057 } else if (r == -ENOENT) {
7067 int RGWRados::Object::Write::write_meta(uint64_t size, uint64_t accounted_size,
7068 map<string, bufferlist>& attrs)
7070 RGWBucketInfo& bucket_info = target->get_bucket_info();
7072 RGWRados::Bucket bop(target->get_store(), bucket_info);
7073 RGWRados::Bucket::UpdateIndex index_op(&bop, target->get_obj());
7074 index_op.set_zones_trace(meta.zones_trace);
7076 bool assume_noent = (meta.if_match == NULL && meta.if_nomatch == NULL);
7079 r = _do_write_meta(size, accounted_size, attrs, assume_noent, meta.modify_tail, (void *)&index_op);
7081 assume_noent = false;
7084 if (!assume_noent) {
7085 r = _do_write_meta(size, accounted_size, attrs, assume_noent, meta.modify_tail, (void *)&index_op);
7090 /** Write/overwrite a system object. */
7091 int RGWRados::put_system_obj_impl(rgw_raw_obj& obj, uint64_t size, real_time *mtime,
7092 map<std::string, bufferlist>& attrs, int flags,
7094 RGWObjVersionTracker *objv_tracker,
7095 real_time set_mtime /* 0 for don't set */)
7098 int r = get_system_obj_ref(obj, &ref);
7102 ObjectWriteOperation op;
7104 if (flags & PUT_OBJ_EXCL) {
7105 if (!(flags & PUT_OBJ_CREATE))
7107 op.create(true); // exclusive create
7110 op.set_op_flags2(LIBRADOS_OP_FLAG_FAILOK);
7115 objv_tracker->prepare_op_for_write(&op);
7118 if (real_clock::is_zero(set_mtime)) {
7119 set_mtime = real_clock::now();
7122 struct timespec mtime_ts = real_clock::to_timespec(set_mtime);
7123 op.mtime2(&mtime_ts);
7124 op.write_full(data);
7128 for (map<string, bufferlist>::iterator iter = attrs.begin(); iter != attrs.end(); ++iter) {
7129 const string& name = iter->first;
7130 bufferlist& bl = iter->second;
7135 op.setxattr(name.c_str(), bl);
7138 r = ref.ioctx.operate(ref.oid, &op);
7144 objv_tracker->apply_write();
7154 int RGWRados::put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl,
7155 off_t ofs, bool exclusive,
7156 RGWObjVersionTracker *objv_tracker)
7159 int r = get_system_obj_ref(obj, &ref);
7164 ObjectWriteOperation op;
7170 objv_tracker->prepare_op_for_write(&op);
7177 r = ref.ioctx.operate(ref.oid, &op);
7182 objv_tracker->apply_write();
7188 * Write/overwrite an object to the bucket storage.
7189 * bucket: the bucket to store the object in
7190 * obj: the object name/key
7191 * data: the object contents/value
7192 * offset: the offet to write to in the object
7193 * If this is -1, we will overwrite the whole object.
7194 * size: the amount of data to write (data must be this long)
7195 * attrs: all the given attrs are written to bucket storage for the given object
7196 * Returns: 0 on success, -ERR# otherwise.
7199 int RGWRados::aio_put_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl,
7200 off_t ofs, bool exclusive,
7204 int r = get_raw_obj_ref(obj, &ref);
7209 AioCompletion *c = librados::Rados::aio_create_completion(NULL, NULL, NULL);
7212 ObjectWriteOperation op;
7222 r = ref.ioctx.aio_operate(ref.oid, c, &op);
7229 int RGWRados::aio_wait(void *handle)
7231 AioCompletion *c = (AioCompletion *)handle;
7233 int ret = c->get_return_value();
7238 bool RGWRados::aio_completed(void *handle)
7240 AioCompletion *c = (AioCompletion *)handle;
7241 return c->is_safe();
7244 class RGWRadosPutObj : public RGWGetDataCB
7248 RGWPutObjDataProcessor *filter;
7249 boost::optional<RGWPutObj_Compress>& compressor;
7250 CompressorRef& plugin;
7251 RGWPutObjProcessor_Atomic *processor;
7252 RGWOpStateSingleOp *opstate;
7253 void (*progress_cb)(off_t, void *);
7254 void *progress_data;
7255 bufferlist extra_data_bl;
7256 uint64_t extra_data_len;
7258 map<string, bufferlist> src_attrs;
7260 RGWRadosPutObj(CephContext* cct,
7261 CompressorRef& plugin,
7262 boost::optional<RGWPutObj_Compress>& compressor,
7263 RGWPutObjProcessor_Atomic *p,
7264 RGWOpStateSingleOp *_ops,
7265 void (*_progress_cb)(off_t, void *),
7266 void *_progress_data) :
7269 compressor(compressor),
7273 progress_cb(_progress_cb),
7274 progress_data(_progress_data),
7278 int process_attrs(void) {
7279 if (extra_data_bl.length()) {
7281 if (!jp.parse(extra_data_bl.c_str(), extra_data_bl.length())) {
7282 ldout(cct, 0) << "failed to parse response extra data. len=" << extra_data_bl.length() << " data=" << extra_data_bl.c_str() << dendl;
7286 JSONDecoder::decode_json("attrs", src_attrs, &jp);
7288 src_attrs.erase(RGW_ATTR_COMPRESSION);
7289 src_attrs.erase(RGW_ATTR_MANIFEST); // not interested in original object layout
7292 if (plugin && src_attrs.find(RGW_ATTR_CRYPT_MODE) == src_attrs.end()) {
7293 //do not compress if object is encrypted
7294 compressor = boost::in_place(cct, plugin, filter);
7295 filter = &*compressor;
7300 int handle_data(bufferlist& bl, off_t ofs, off_t len) override {
7302 progress_cb(ofs, progress_data);
7304 if (extra_data_len) {
7305 size_t extra_len = bl.length();
7306 if (extra_len > extra_data_len)
7307 extra_len = extra_data_len;
7310 bl.splice(0, extra_len, &extra);
7311 extra_data_bl.append(extra);
7313 extra_data_len -= extra_len;
7314 if (extra_data_len == 0) {
7315 int res = process_attrs();
7319 if (bl.length() == 0) {
7323 data_len += bl.length();
7326 bool need_opstate = true;
7329 void *handle = NULL;
7331 uint64_t size = bl.length();
7332 int ret = filter->handle_data(bl, ofs, &handle, &obj, &again);
7336 if (need_opstate && opstate) {
7337 /* need to update opstate repository with new state. This is ratelimited, so we're not
7338 * really doing it every time
7340 ret = opstate->renew_state();
7342 ldout(cct, 0) << "ERROR: RGWRadosPutObj::handle_data(): failed to renew op state ret=" << ret << dendl;
7343 int r = filter->throttle_data(handle, obj, size, false);
7345 ldout(cct, 0) << "ERROR: RGWRadosPutObj::handle_data(): processor->throttle_data() returned " << r << dendl;
7347 /* could not renew state! might have been marked as cancelled */
7350 need_opstate = false;
7353 ret = filter->throttle_data(handle, obj, size, false);
7361 bufferlist& get_extra_data() { return extra_data_bl; }
7363 map<string, bufferlist>& get_attrs() { return src_attrs; }
7365 void set_extra_data_len(uint64_t len) override {
7366 extra_data_len = len;
7369 uint64_t get_data_len() {
7373 int complete(const string& etag, real_time *mtime, real_time set_mtime,
7374 map<string, bufferlist>& attrs, real_time delete_at, rgw_zone_set *zones_trace) {
7375 return processor->complete(data_len, etag, mtime, set_mtime, attrs, delete_at, NULL, NULL, NULL, zones_trace);
7378 bool is_canceled() {
7379 return processor->is_canceled();
7384 * prepare attrset depending on attrs_mod.
7386 static void set_copy_attrs(map<string, bufferlist>& src_attrs,
7387 map<string, bufferlist>& attrs,
7388 RGWRados::AttrsMod attrs_mod)
7390 switch (attrs_mod) {
7391 case RGWRados::ATTRSMOD_NONE:
7394 case RGWRados::ATTRSMOD_REPLACE:
7395 if (!attrs[RGW_ATTR_ETAG].length()) {
7396 attrs[RGW_ATTR_ETAG] = src_attrs[RGW_ATTR_ETAG];
7398 if (!attrs[RGW_ATTR_TAIL_TAG].length()) {
7399 auto ttiter = src_attrs.find(RGW_ATTR_TAIL_TAG);
7400 if (ttiter != src_attrs.end()) {
7401 attrs[RGW_ATTR_TAIL_TAG] = src_attrs[RGW_ATTR_TAIL_TAG];
7405 case RGWRados::ATTRSMOD_MERGE:
7406 for (map<string, bufferlist>::iterator it = src_attrs.begin(); it != src_attrs.end(); ++it) {
7407 if (attrs.find(it->first) == attrs.end()) {
7408 attrs[it->first] = it->second;
7415 int RGWRados::rewrite_obj(RGWBucketInfo& dest_bucket_info, rgw_obj& obj)
7417 map<string, bufferlist> attrset;
7421 RGWObjectCtx rctx(this);
7423 RGWRados::Object op_target(this, dest_bucket_info, rctx, obj);
7424 RGWRados::Object::Read read_op(&op_target);
7426 read_op.params.attrs = &attrset;
7427 read_op.params.lastmod = &mtime;
7428 read_op.params.obj_size = &obj_size;
7430 int ret = read_op.prepare();
7434 attrset.erase(RGW_ATTR_ID_TAG);
7435 attrset.erase(RGW_ATTR_TAIL_TAG);
7437 uint64_t max_chunk_size;
7439 ret = get_max_chunk_size(dest_bucket_info.placement_rule, obj, &max_chunk_size);
7441 ldout(cct, 0) << "ERROR: failed to get max_chunk_size() for bucket " << obj.bucket << dendl;
7445 return copy_obj_data(rctx, dest_bucket_info, read_op, obj_size - 1, obj, obj, max_chunk_size, NULL, mtime, attrset,
7446 RGW_OBJ_CATEGORY_MAIN, 0, real_time(), NULL, NULL, NULL);
7449 struct obj_time_weight {
7451 uint32_t zone_short_id;
7453 bool high_precision;
7455 obj_time_weight() : zone_short_id(0), pg_ver(0), high_precision(false) {}
7457 bool compare_low_precision(const obj_time_weight& rhs) {
7458 struct timespec l = ceph::real_clock::to_timespec(mtime);
7459 struct timespec r = ceph::real_clock::to_timespec(rhs.mtime);
7468 if (zone_short_id != rhs.zone_short_id) {
7469 return (zone_short_id < rhs.zone_short_id);
7471 return (pg_ver < rhs.pg_ver);
7475 bool operator<(const obj_time_weight& rhs) {
7476 if (!high_precision || !rhs.high_precision) {
7477 return compare_low_precision(rhs);
7479 if (mtime > rhs.mtime) {
7482 if (mtime < rhs.mtime) {
7485 if (zone_short_id != rhs.zone_short_id) {
7486 return (zone_short_id < rhs.zone_short_id);
7488 return (pg_ver < rhs.pg_ver);
7491 void init(const real_time& _mtime, uint32_t _short_id, uint64_t _pg_ver) {
7493 zone_short_id = _short_id;
7497 void init(RGWObjState *state) {
7498 mtime = state->mtime;
7499 zone_short_id = state->zone_short_id;
7500 pg_ver = state->pg_ver;
7504 inline ostream& operator<<(ostream& out, const obj_time_weight &o) {
7507 if (o.zone_short_id != 0 || o.pg_ver != 0) {
7508 out << "[zid=" << o.zone_short_id << ", pgv=" << o.pg_ver << "]";
7514 class RGWGetExtraDataCB : public RGWGetDataCB {
7515 bufferlist extra_data;
7517 RGWGetExtraDataCB() {}
7518 int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
7519 if (extra_data.length() < extra_data_len) {
7520 off_t max = extra_data_len - extra_data.length();
7524 bl.splice(0, max, &extra_data);
7529 bufferlist& get_extra_data() {
7534 int RGWRados::stat_remote_obj(RGWObjectCtx& obj_ctx,
7535 const rgw_user& user_id,
7536 const string& client_id,
7538 const string& source_zone,
7540 RGWBucketInfo& src_bucket_info,
7541 real_time *src_mtime,
7543 const real_time *mod_ptr,
7544 const real_time *unmod_ptr,
7545 bool high_precision_time,
7546 const char *if_match,
7547 const char *if_nomatch,
7548 map<string, bufferlist> *pattrs,
7553 /* source is in a different zonegroup, copy from there */
7555 RGWRESTStreamRWRequest *in_stream_req;
7557 map<string, bufferlist> src_attrs;
7558 append_rand_alpha(cct, tag, tag, 32);
7559 obj_time_weight set_mtime_weight;
7560 set_mtime_weight.high_precision = high_precision_time;
7563 if (source_zone.empty()) {
7564 if (src_bucket_info.zonegroup.empty()) {
7565 /* source is in the master zonegroup */
7566 conn = rest_master_conn;
7568 map<string, RGWRESTConn *>::iterator iter = zonegroup_conn_map.find(src_bucket_info.zonegroup);
7569 if (iter == zonegroup_conn_map.end()) {
7570 ldout(cct, 0) << "could not find zonegroup connection to zonegroup: " << source_zone << dendl;
7573 conn = iter->second;
7576 map<string, RGWRESTConn *>::iterator iter = zone_conn_map.find(source_zone);
7577 if (iter == zone_conn_map.end()) {
7578 ldout(cct, 0) << "could not find zone connection to zone: " << source_zone << dendl;
7581 conn = iter->second;
7584 RGWGetExtraDataCB cb;
7586 map<string, string> req_headers;
7587 real_time set_mtime;
7589 const real_time *pmod = mod_ptr;
7591 obj_time_weight dest_mtime_weight;
7593 constexpr bool prepend_meta = true;
7594 constexpr bool get_op = true;
7595 constexpr bool rgwx_stat = true;
7596 constexpr bool sync_manifest = true;
7597 constexpr bool skip_decrypt = true;
7598 int ret = conn->get_obj(user_id, info, src_obj, pmod, unmod_ptr,
7599 dest_mtime_weight.zone_short_id, dest_mtime_weight.pg_ver,
7600 prepend_meta, get_op, rgwx_stat,
7601 sync_manifest, skip_decrypt, &cb, &in_stream_req);
7606 ret = conn->complete_request(in_stream_req, etag, &set_mtime, psize, req_headers);
7611 bufferlist& extra_data_bl = cb.get_extra_data();
7612 if (extra_data_bl.length()) {
7614 if (!jp.parse(extra_data_bl.c_str(), extra_data_bl.length())) {
7615 ldout(cct, 0) << "failed to parse response extra data. len=" << extra_data_bl.length() << " data=" << extra_data_bl.c_str() << dendl;
7619 JSONDecoder::decode_json("attrs", src_attrs, &jp);
7621 src_attrs.erase(RGW_ATTR_MANIFEST); // not interested in original object layout
7625 *src_mtime = set_mtime;
7629 map<string, bufferlist>::iterator iter = src_attrs.find(RGW_ATTR_ETAG);
7630 if (iter != src_attrs.end()) {
7631 bufferlist& etagbl = iter->second;
7632 *petag = etagbl.to_str();
7637 *pattrs = src_attrs;
7643 int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
7644 const rgw_user& user_id,
7645 const string& client_id,
7646 const string& op_id,
7647 bool record_op_state,
7649 const string& source_zone,
7652 RGWBucketInfo& dest_bucket_info,
7653 RGWBucketInfo& src_bucket_info,
7654 real_time *src_mtime,
7656 const real_time *mod_ptr,
7657 const real_time *unmod_ptr,
7658 bool high_precision_time,
7659 const char *if_match,
7660 const char *if_nomatch,
7663 map<string, bufferlist>& attrs,
7664 RGWObjCategory category,
7666 real_time delete_at,
7669 ceph::buffer::list *petag,
7670 void (*progress_cb)(off_t, void *),
7671 void *progress_data,
7672 rgw_zone_set *zones_trace)
7674 /* source is in a different zonegroup, copy from there */
7676 RGWRESTStreamRWRequest *in_stream_req;
7679 append_rand_alpha(cct, tag, tag, 32);
7680 obj_time_weight set_mtime_weight;
7681 set_mtime_weight.high_precision = high_precision_time;
7683 RGWPutObjProcessor_Atomic processor(obj_ctx,
7684 dest_bucket_info, dest_obj.bucket, dest_obj.key.name,
7685 cct->_conf->rgw_obj_stripe_size, tag, dest_bucket_info.versioning_enabled());
7686 if (version_id && *version_id != "null") {
7687 processor.set_version_id(*version_id);
7689 processor.set_olh_epoch(olh_epoch);
7690 int ret = processor.prepare(this, NULL);
7696 if (source_zone.empty()) {
7697 if (dest_bucket_info.zonegroup.empty()) {
7698 /* source is in the master zonegroup */
7699 conn = rest_master_conn;
7701 map<string, RGWRESTConn *>::iterator iter = zonegroup_conn_map.find(src_bucket_info.zonegroup);
7702 if (iter == zonegroup_conn_map.end()) {
7703 ldout(cct, 0) << "could not find zonegroup connection to zonegroup: " << source_zone << dendl;
7706 conn = iter->second;
7709 map<string, RGWRESTConn *>::iterator iter = zone_conn_map.find(source_zone);
7710 if (iter == zone_conn_map.end()) {
7711 ldout(cct, 0) << "could not find zone connection to zone: " << source_zone << dendl;
7714 conn = iter->second;
7717 string obj_name = dest_obj.bucket.name + "/" + dest_obj.get_oid();
7719 RGWOpStateSingleOp *opstate = NULL;
7721 if (record_op_state) {
7722 opstate = new RGWOpStateSingleOp(this, client_id, op_id, obj_name);
7724 ret = opstate->set_state(RGWOpState::OPSTATE_IN_PROGRESS);
7726 ldout(cct, 0) << "ERROR: failed to set opstate ret=" << ret << dendl;
7732 boost::optional<RGWPutObj_Compress> compressor;
7733 CompressorRef plugin;
7735 const auto& compression_type = zone_params.get_compression_type(
7736 dest_bucket_info.placement_rule);
7737 if (compression_type != "none") {
7738 plugin = Compressor::create(cct, compression_type);
7740 ldout(cct, 1) << "Cannot load plugin for compression type "
7741 << compression_type << dendl;
7745 RGWRadosPutObj cb(cct, plugin, compressor, &processor, opstate, progress_cb, progress_data);
7748 map<string, string> req_headers;
7749 real_time set_mtime;
7751 RGWObjState *dest_state = NULL;
7753 const real_time *pmod = mod_ptr;
7755 obj_time_weight dest_mtime_weight;
7757 if (copy_if_newer) {
7758 /* need to get mtime for destination */
7759 ret = get_obj_state(&obj_ctx, dest_bucket_info, dest_obj, &dest_state, false);
7763 if (!real_clock::is_zero(dest_state->mtime)) {
7764 dest_mtime_weight.init(dest_state);
7765 pmod = &dest_mtime_weight.mtime;
7769 static constexpr bool prepend_meta = true;
7770 static constexpr bool get_op = true;
7771 static constexpr bool rgwx_stat = false;
7772 static constexpr bool sync_manifest = true;
7773 static constexpr bool skip_decrypt = true;
7774 ret = conn->get_obj(user_id, info, src_obj, pmod, unmod_ptr,
7775 dest_mtime_weight.zone_short_id, dest_mtime_weight.pg_ver,
7776 prepend_meta, get_op, rgwx_stat,
7777 sync_manifest, skip_decrypt, &cb, &in_stream_req);
7782 ret = conn->complete_request(in_stream_req, etag, &set_mtime, nullptr, req_headers);
7786 if (compressor && compressor->is_compressed()) {
7788 RGWCompressionInfo cs_info;
7789 cs_info.compression_type = plugin->get_type_name();
7790 cs_info.orig_size = cb.get_data_len();
7791 cs_info.blocks = move(compressor->get_compression_blocks());
7792 ::encode(cs_info, tmp);
7793 cb.get_attrs()[RGW_ATTR_COMPRESSION] = tmp;
7796 if (source_zone.empty()) { /* need to preserve expiration if copy in the same zonegroup */
7797 cb.get_attrs().erase(RGW_ATTR_DELETE_AT);
7799 map<string, bufferlist>::iterator iter = cb.get_attrs().find(RGW_ATTR_DELETE_AT);
7800 if (iter != cb.get_attrs().end()) {
7802 ::decode(delete_at, iter->second);
7803 } catch (buffer::error& err) {
7804 ldout(cct, 0) << "ERROR: failed to decode delete_at field in intra zone copy" << dendl;
7810 *src_mtime = set_mtime;
7814 const auto iter = cb.get_attrs().find(RGW_ATTR_ETAG);
7815 if (iter != cb.get_attrs().end()) {
7816 *petag = iter->second;
7820 if (source_zone.empty()) {
7821 set_copy_attrs(cb.get_attrs(), attrs, attrs_mod);
7823 attrs = cb.get_attrs();
7826 if (copy_if_newer) {
7827 uint64_t pg_ver = 0;
7828 auto i = attrs.find(RGW_ATTR_PG_VER);
7829 if (i != attrs.end() && i->second.length() > 0) {
7830 bufferlist::iterator iter = i->second.begin();
7832 ::decode(pg_ver, iter);
7833 } catch (buffer::error& err) {
7834 ldout(ctx(), 0) << "ERROR: failed to decode pg ver attribute, ignoring" << dendl;
7835 /* non critical error */
7838 set_mtime_weight.init(set_mtime, get_zone_short_id(), pg_ver);
7841 #define MAX_COMPLETE_RETRY 100
7842 for (i = 0; i < MAX_COMPLETE_RETRY; i++) {
7843 ret = cb.complete(etag, mtime, set_mtime, attrs, delete_at, zones_trace);
7847 if (copy_if_newer && cb.is_canceled()) {
7848 ldout(cct, 20) << "raced with another write of obj: " << dest_obj << dendl;
7849 obj_ctx.obj.invalidate(dest_obj); /* object was overwritten */
7850 ret = get_obj_state(&obj_ctx, dest_bucket_info, dest_obj, &dest_state, false);
7852 ldout(cct, 0) << "ERROR: " << __func__ << ": get_err_state() returned ret=" << ret << dendl;
7855 dest_mtime_weight.init(dest_state);
7856 dest_mtime_weight.high_precision = high_precision_time;
7857 if (!dest_state->exists ||
7858 dest_mtime_weight < set_mtime_weight) {
7859 ldout(cct, 20) << "retrying writing object mtime=" << set_mtime << " dest_state->mtime=" << dest_state->mtime << " dest_state->exists=" << dest_state->exists << dendl;
7862 ldout(cct, 20) << "not retrying writing object mtime=" << set_mtime << " dest_state->mtime=" << dest_state->mtime << " dest_state->exists=" << dest_state->exists << dendl;
7868 if (i == MAX_COMPLETE_RETRY) {
7869 ldout(cct, 0) << "ERROR: retried object completion too many times, something is wrong!" << dendl;
7875 ret = opstate->set_state(RGWOpState::OPSTATE_COMPLETE);
7877 ldout(cct, 0) << "ERROR: failed to set opstate ret=" << ret << dendl;
7884 if (copy_if_newer && ret == -ERR_NOT_MODIFIED) {
7888 RGWOpState::OpState state;
7890 state = RGWOpState::OPSTATE_ERROR;
7892 state = RGWOpState::OPSTATE_COMPLETE;
7894 int r = opstate->set_state(state);
7896 ldout(cct, 0) << "ERROR: failed to set opstate r=" << ret << dendl;
7904 int RGWRados::copy_obj_to_remote_dest(RGWObjState *astate,
7905 map<string, bufferlist>& src_attrs,
7906 RGWRados::Object::Read& read_op,
7907 const rgw_user& user_id,
7913 RGWRESTStreamWriteRequest *out_stream_req;
7915 int ret = rest_master_conn->put_obj_init(user_id, dest_obj, astate->size, src_attrs, &out_stream_req);
7920 ret = read_op.iterate(0, astate->size - 1, out_stream_req->get_out_cb());
7922 delete out_stream_req;
7926 ret = rest_master_conn->complete_request(out_stream_req, etag, mtime);
7935 * dest_obj: the object to copy into
7936 * src_obj: the object to copy from
7937 * attrs: usage depends on attrs_mod parameter
7938 * attrs_mod: the modification mode of the attrs, may have the following values:
7939 * ATTRSMOD_NONE - the attributes of the source object will be
7940 * copied without modifications, attrs parameter is ignored;
7941 * ATTRSMOD_REPLACE - new object will have the attributes provided by attrs
7942 * parameter, source object attributes are not copied;
7943 * ATTRSMOD_MERGE - any conflicting meta keys on the source object's attributes
7944 * are overwritten by values contained in attrs parameter.
7945 * err: stores any errors resulting from the get of the original object
7946 * Returns: 0 on success, -ERR# otherwise.
7948 int RGWRados::copy_obj(RGWObjectCtx& obj_ctx,
7949 const rgw_user& user_id,
7950 const string& client_id,
7951 const string& op_id,
7953 const string& source_zone,
7956 RGWBucketInfo& dest_bucket_info,
7957 RGWBucketInfo& src_bucket_info,
7958 real_time *src_mtime,
7960 const real_time *mod_ptr,
7961 const real_time *unmod_ptr,
7962 bool high_precision_time,
7963 const char *if_match,
7964 const char *if_nomatch,
7967 map<string, bufferlist>& attrs,
7968 RGWObjCategory category,
7970 real_time delete_at,
7973 ceph::buffer::list *petag,
7974 void (*progress_cb)(off_t, void *),
7975 void *progress_data)
7979 rgw_obj shadow_obj = dest_obj;
7985 append_rand_alpha(cct, dest_obj.get_oid(), shadow_oid, 32);
7986 shadow_obj.init_ns(dest_obj.bucket, shadow_oid, shadow_ns);
7988 remote_dest = !get_zonegroup().equals(dest_bucket_info.zonegroup);
7989 remote_src = !get_zonegroup().equals(src_bucket_info.zonegroup);
7991 if (remote_src && remote_dest) {
7992 ldout(cct, 0) << "ERROR: can't copy object when both src and dest buckets are remote" << dendl;
7996 ldout(cct, 5) << "Copy object " << src_obj.bucket << ":" << src_obj.get_oid() << " => " << dest_obj.bucket << ":" << dest_obj.get_oid() << dendl;
7998 if (remote_src || !source_zone.empty()) {
7999 return fetch_remote_obj(obj_ctx, user_id, client_id, op_id, true, info, source_zone,
8000 dest_obj, src_obj, dest_bucket_info, src_bucket_info, src_mtime, mtime, mod_ptr,
8001 unmod_ptr, high_precision_time,
8002 if_match, if_nomatch, attrs_mod, copy_if_newer, attrs, category,
8003 olh_epoch, delete_at, version_id, ptag, petag, progress_cb, progress_data);
8006 map<string, bufferlist> src_attrs;
8007 RGWRados::Object src_op_target(this, src_bucket_info, obj_ctx, src_obj);
8008 RGWRados::Object::Read read_op(&src_op_target);
8010 read_op.conds.mod_ptr = mod_ptr;
8011 read_op.conds.unmod_ptr = unmod_ptr;
8012 read_op.conds.high_precision_time = high_precision_time;
8013 read_op.conds.if_match = if_match;
8014 read_op.conds.if_nomatch = if_nomatch;
8015 read_op.params.attrs = &src_attrs;
8016 read_op.params.lastmod = src_mtime;
8017 read_op.params.obj_size = &obj_size;
8019 ret = read_op.prepare();
8024 src_attrs[RGW_ATTR_ACL] = attrs[RGW_ATTR_ACL];
8025 src_attrs.erase(RGW_ATTR_DELETE_AT);
8027 set_copy_attrs(src_attrs, attrs, attrs_mod);
8028 attrs.erase(RGW_ATTR_ID_TAG);
8029 attrs.erase(RGW_ATTR_PG_VER);
8030 attrs.erase(RGW_ATTR_SOURCE_ZONE);
8031 map<string, bufferlist>::iterator cmp = src_attrs.find(RGW_ATTR_COMPRESSION);
8032 if (cmp != src_attrs.end())
8033 attrs[RGW_ATTR_COMPRESSION] = cmp->second;
8035 RGWObjManifest manifest;
8036 RGWObjState *astate = NULL;
8038 ret = get_obj_state(&obj_ctx, src_bucket_info, src_obj, &astate);
8043 vector<rgw_raw_obj> ref_objs;
8046 /* dest is in a different zonegroup, copy it there */
8047 return copy_obj_to_remote_dest(astate, attrs, read_op, user_id, dest_obj, mtime);
8049 uint64_t max_chunk_size;
8051 ret = get_max_chunk_size(dest_bucket_info.placement_rule, dest_obj, &max_chunk_size);
8053 ldout(cct, 0) << "ERROR: failed to get max_chunk_size() for bucket " << dest_obj.bucket << dendl;
8059 if (!get_obj_data_pool(src_bucket_info.placement_rule, src_obj, &src_pool)) {
8060 ldout(cct, 0) << "ERROR: failed to locate data pool for " << src_obj << dendl;
8063 if (!get_obj_data_pool(dest_bucket_info.placement_rule, dest_obj, &dest_pool)) {
8064 ldout(cct, 0) << "ERROR: failed to locate data pool for " << dest_obj << dendl;
8069 bool copy_data = !astate->has_manifest || (src_pool != dest_pool);
8070 bool copy_first = false;
8071 if (astate->has_manifest) {
8072 if (!astate->manifest.has_tail()) {
8075 uint64_t head_size = astate->manifest.get_head_size();
8077 if (head_size > 0) {
8078 if (head_size > max_chunk_size) {
8088 const auto iter = attrs.find(RGW_ATTR_ETAG);
8089 if (iter != attrs.end()) {
8090 *petag = iter->second;
8094 if (copy_data) { /* refcounting tail wouldn't work here, just copy the data */
8095 return copy_obj_data(obj_ctx, dest_bucket_info, read_op, obj_size - 1, dest_obj, src_obj,
8096 max_chunk_size, mtime, real_time(), attrs, category, olh_epoch, delete_at,
8097 version_id, ptag, petag);
8100 RGWObjManifest::obj_iterator miter = astate->manifest.obj_begin();
8102 if (copy_first) { // we need to copy first chunk, not increase refcount
8107 ret = get_raw_obj_ref(miter.get_location().get_raw_obj(this), &ref);
8112 bool versioned_dest = dest_bucket_info.versioning_enabled();
8114 if (version_id && !version_id->empty()) {
8115 versioned_dest = true;
8116 dest_obj.key.set_instance(*version_id);
8117 } else if (versioned_dest) {
8118 gen_rand_obj_instance_name(&dest_obj);
8121 bufferlist first_chunk;
8123 bool copy_itself = (dest_obj == src_obj);
8124 RGWObjManifest *pmanifest;
8125 ldout(cct, 20) << "dest_obj=" << dest_obj << " src_obj=" << src_obj << " copy_itself=" << (int)copy_itself << dendl;
8127 RGWRados::Object dest_op_target(this, dest_bucket_info, obj_ctx, dest_obj);
8128 RGWRados::Object::Write write_op(&dest_op_target);
8137 append_rand_alpha(cct, tag, tag, 32);
8141 attrs.erase(RGW_ATTR_TAIL_TAG);
8142 manifest = astate->manifest;
8143 const rgw_bucket_placement& tail_placement = manifest.get_tail_placement();
8144 if (tail_placement.bucket.name.empty()) {
8145 manifest.set_tail_placement(tail_placement.placement_rule, src_obj.bucket);
8148 for (; miter != astate->manifest.obj_end(); ++miter) {
8149 ObjectWriteOperation op;
8150 ref_tag = tag + '\0';
8151 cls_refcount_get(op, ref_tag, true);
8152 const rgw_raw_obj& loc = miter.get_location().get_raw_obj(this);
8153 ref.ioctx.locator_set_key(loc.loc);
8155 ret = ref.ioctx.operate(loc.oid, &op);
8160 ref_objs.push_back(loc);
8163 pmanifest = &manifest;
8165 pmanifest = &astate->manifest;
8166 /* don't send the object's tail for garbage collection */
8167 astate->keep_tail = true;
8171 ret = read_op.read(0, max_chunk_size, first_chunk);
8176 pmanifest->set_head(dest_bucket_info.placement_rule, dest_obj, first_chunk.length());
8178 pmanifest->set_head(dest_bucket_info.placement_rule, dest_obj, 0);
8181 write_op.meta.data = &first_chunk;
8182 write_op.meta.manifest = pmanifest;
8183 write_op.meta.ptag = &tag;
8184 write_op.meta.owner = dest_bucket_info.owner;
8185 write_op.meta.mtime = mtime;
8186 write_op.meta.flags = PUT_OBJ_CREATE;
8187 write_op.meta.category = category;
8188 write_op.meta.olh_epoch = olh_epoch;
8189 write_op.meta.delete_at = delete_at;
8190 write_op.meta.modify_tail = !copy_itself;
8192 ret = write_op.write_meta(obj_size, astate->accounted_size, attrs);
8201 vector<rgw_raw_obj>::iterator riter;
8203 /* rollback reference */
8204 for (riter = ref_objs.begin(); riter != ref_objs.end(); ++riter) {
8205 ObjectWriteOperation op;
8206 cls_refcount_put(op, tag, true);
8208 ref.ioctx.locator_set_key(riter->loc);
8210 int r = ref.ioctx.operate(riter->oid, &op);
8212 ldout(cct, 0) << "ERROR: cleanup after error failed to drop reference on obj=" << *riter << dendl;
8220 int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx,
8221 RGWBucketInfo& dest_bucket_info,
8222 RGWRados::Object::Read& read_op, off_t end,
8225 uint64_t max_chunk_size,
8227 real_time set_mtime,
8228 map<string, bufferlist>& attrs,
8229 RGWObjCategory category,
8231 real_time delete_at,
8234 ceph::buffer::list *petag)
8236 bufferlist first_chunk;
8237 RGWObjManifest manifest;
8240 append_rand_alpha(cct, tag, tag, 32);
8242 RGWPutObjProcessor_Atomic processor(obj_ctx,
8243 dest_bucket_info, dest_obj.bucket, dest_obj.get_oid(),
8244 cct->_conf->rgw_obj_stripe_size, tag, dest_bucket_info.versioning_enabled());
8246 processor.set_version_id(*version_id);
8248 processor.set_olh_epoch(olh_epoch);
8249 int ret = processor.prepare(this, NULL);
8257 ret = read_op.read(ofs, end, bl);
8259 uint64_t read_len = ret;
8266 ret = processor.handle_data(bl, ofs, &handle, &obj, &again);
8270 ret = processor.throttle_data(handle, obj, read_len, false);
8276 } while (ofs <= end);
8279 auto iter = attrs.find(RGW_ATTR_ETAG);
8280 if (iter != attrs.end()) {
8281 bufferlist& bl = iter->second;
8282 etag = string(bl.c_str(), bl.length());
8288 uint64_t accounted_size;
8290 bool compressed{false};
8291 RGWCompressionInfo cs_info;
8292 ret = rgw_compression_info_from_attrset(attrs, compressed, cs_info);
8294 ldout(cct, 0) << "ERROR: failed to read compression info" << dendl;
8297 // pass original size if compressed
8298 accounted_size = compressed ? cs_info.orig_size : ofs;
8301 return processor.complete(accounted_size, etag, mtime, set_mtime, attrs, delete_at);
8304 bool RGWRados::is_meta_master()
8306 if (!get_zonegroup().is_master_zonegroup()) {
8310 return (get_zonegroup().master_zone == zone_public_config.id);
8314 * Check to see if the bucket metadata could be synced
8315 * bucket: the bucket to check
8316 * Returns false is the bucket is not synced
8318 bool RGWRados::is_syncing_bucket_meta(const rgw_bucket& bucket)
8321 /* no current period */
8322 if (current_period.get_id().empty()) {
8326 /* zonegroup is not master zonegroup */
8327 if (!get_zonegroup().is_master_zonegroup()) {
8331 /* single zonegroup and a single zone */
8332 if (current_period.is_single_zonegroup() && get_zonegroup().zones.size() == 1) {
8336 /* zone is not master */
8337 if (get_zonegroup().master_zone.compare(zone_public_config.id) != 0) {
8344 int RGWRados::check_bucket_empty(RGWBucketInfo& bucket_info)
8346 std::map<string, rgw_bucket_dir_entry> ent_map;
8347 rgw_obj_index_key marker;
8352 #define NUM_ENTRIES 1000
8353 int r = cls_bucket_list(bucket_info, RGW_NO_SHARD, marker, prefix, NUM_ENTRIES, true, ent_map,
8354 &is_truncated, &marker);
8359 std::map<string, rgw_bucket_dir_entry>::iterator eiter;
8360 for (eiter = ent_map.begin(); eiter != ent_map.end(); ++eiter) {
8363 if (rgw_obj_key::oid_to_key_in_ns(eiter->second.key.name, &obj, ns))
8366 } while (is_truncated);
8372 * bucket: the name of the bucket to delete
8373 * Returns 0 on success, -ERR# otherwise.
8375 int RGWRados::delete_bucket(RGWBucketInfo& bucket_info, RGWObjVersionTracker& objv_tracker, bool check_empty)
8377 const rgw_bucket& bucket = bucket_info.bucket;
8378 librados::IoCtx index_ctx;
8379 map<int, string> bucket_objs;
8380 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs);
8385 r = check_bucket_empty(bucket_info);
8391 r = rgw_bucket_delete_bucket_obj(this, bucket.tenant, bucket.name, objv_tracker);
8395 /* if the bucket is not synced we can remove the meta file */
8396 if (!is_syncing_bucket_meta(bucket)) {
8397 RGWObjVersionTracker objv_tracker;
8398 string entry = bucket.get_key();
8399 r= rgw_bucket_instance_remove_entry(this, entry, &objv_tracker);
8403 /* remove bucket index objects*/
8404 map<int, string>::const_iterator biter;
8405 for (biter = bucket_objs.begin(); biter != bucket_objs.end(); ++biter) {
8406 index_ctx.remove(biter->second);
8412 int RGWRados::set_bucket_owner(rgw_bucket& bucket, ACLOwner& owner)
8415 map<string, bufferlist> attrs;
8416 RGWObjectCtx obj_ctx(this);
8418 if (bucket.bucket_id.empty()) {
8419 r = get_bucket_info(obj_ctx, bucket.tenant, bucket.name, info, NULL, &attrs);
8421 r = get_bucket_instance_info(obj_ctx, bucket, info, nullptr, &attrs);
8424 ldout(cct, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << dendl;
8428 info.owner = owner.get_id();
8430 r = put_bucket_instance_info(info, false, real_time(), &attrs);
8432 ldout(cct, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << dendl;
8440 int RGWRados::set_buckets_enabled(vector<rgw_bucket>& buckets, bool enabled)
8444 vector<rgw_bucket>::iterator iter;
8446 for (iter = buckets.begin(); iter != buckets.end(); ++iter) {
8447 rgw_bucket& bucket = *iter;
8449 ldout(cct, 20) << "enabling bucket name=" << bucket.name << dendl;
8451 ldout(cct, 20) << "disabling bucket name=" << bucket.name << dendl;
8454 map<string, bufferlist> attrs;
8455 RGWObjectCtx obj_ctx(this);
8456 int r = get_bucket_info(obj_ctx, bucket.tenant, bucket.name, info, NULL, &attrs);
8458 ldout(cct, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
8463 info.flags &= ~BUCKET_SUSPENDED;
8465 info.flags |= BUCKET_SUSPENDED;
8468 r = put_bucket_instance_info(info, false, real_time(), &attrs);
8470 ldout(cct, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
8478 int RGWRados::bucket_suspended(rgw_bucket& bucket, bool *suspended)
8480 RGWBucketInfo bucket_info;
8481 RGWObjectCtx obj_ctx(this);
8482 int ret = get_bucket_info(obj_ctx, bucket.tenant, bucket.name, bucket_info, NULL);
8487 *suspended = ((bucket_info.flags & BUCKET_SUSPENDED) != 0);
8491 int RGWRados::Object::complete_atomic_modification()
8493 if (!state->has_manifest || state->keep_tail)
8496 cls_rgw_obj_chain chain;
8497 store->update_gc_chain(obj, state->manifest, &chain);
8499 if (chain.empty()) {
8503 string tag = (state->tail_tag.length() > 0 ? state->tail_tag.to_str() : state->obj_tag.to_str());
8504 return store->gc->send_chain(chain, tag, false); // do it async
8507 void RGWRados::update_gc_chain(rgw_obj& head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain)
8509 RGWObjManifest::obj_iterator iter;
8510 rgw_raw_obj raw_head;
8511 obj_to_raw(manifest.get_head_placement_rule(), head_obj, &raw_head);
8512 for (iter = manifest.obj_begin(); iter != manifest.obj_end(); ++iter) {
8513 const rgw_raw_obj& mobj = iter.get_location().get_raw_obj(this);
8514 if (mobj == raw_head)
8516 cls_rgw_obj_key key(mobj.oid);
8517 chain->push_obj(mobj.pool.to_str(), key, mobj.loc);
8521 int RGWRados::send_chain_to_gc(cls_rgw_obj_chain& chain, const string& tag, bool sync)
8523 return gc->send_chain(chain, tag, sync);
8526 int RGWRados::open_bucket_index(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx, string& bucket_oid)
8528 const rgw_bucket& bucket = bucket_info.bucket;
8529 int r = open_bucket_index_ctx(bucket_info, index_ctx);
8533 if (bucket.bucket_id.empty()) {
8534 ldout(cct, 0) << "ERROR: empty bucket id for bucket operation" << dendl;
8538 bucket_oid = dir_oid_prefix;
8539 bucket_oid.append(bucket.bucket_id);
8544 int RGWRados::open_bucket_index_base(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
8545 string& bucket_oid_base) {
8546 const rgw_bucket& bucket = bucket_info.bucket;
8547 int r = open_bucket_index_ctx(bucket_info, index_ctx);
8551 if (bucket.bucket_id.empty()) {
8552 ldout(cct, 0) << "ERROR: empty bucket_id for bucket operation" << dendl;
8556 bucket_oid_base = dir_oid_prefix;
8557 bucket_oid_base.append(bucket.bucket_id);
8563 int RGWRados::open_bucket_index(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
8564 map<int, string>& bucket_objs, int shard_id, map<int, string> *bucket_instance_ids) {
8565 string bucket_oid_base;
8566 int ret = open_bucket_index_base(bucket_info, index_ctx, bucket_oid_base);
8571 get_bucket_index_objects(bucket_oid_base, bucket_info.num_shards, bucket_objs, shard_id);
8572 if (bucket_instance_ids) {
8573 get_bucket_instance_ids(bucket_info, shard_id, bucket_instance_ids);
8578 template<typename T>
8579 int RGWRados::open_bucket_index(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
8580 map<int, string>& oids, map<int, T>& bucket_objs,
8581 int shard_id, map<int, string> *bucket_instance_ids)
8583 int ret = open_bucket_index(bucket_info, index_ctx, oids, shard_id, bucket_instance_ids);
8587 map<int, string>::const_iterator iter = oids.begin();
8588 for (; iter != oids.end(); ++iter) {
8589 bucket_objs[iter->first] = T();
8594 int RGWRados::open_bucket_index_shard(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
8595 const string& obj_key, string *bucket_obj, int *shard_id)
8597 string bucket_oid_base;
8598 int ret = open_bucket_index_base(bucket_info, index_ctx, bucket_oid_base);
8602 RGWObjectCtx obj_ctx(this);
8604 ret = get_bucket_index_object(bucket_oid_base, obj_key, bucket_info.num_shards,
8605 (RGWBucketInfo::BIShardsHashType)bucket_info.bucket_index_shard_hash_type, bucket_obj, shard_id);
8607 ldout(cct, 10) << "get_bucket_index_object() returned ret=" << ret << dendl;
8613 int RGWRados::open_bucket_index_shard(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
8614 int shard_id, string *bucket_obj)
8616 string bucket_oid_base;
8617 int ret = open_bucket_index_base(bucket_info, index_ctx, bucket_oid_base);
8621 RGWObjectCtx obj_ctx(this);
8623 get_bucket_index_object(bucket_oid_base, bucket_info.num_shards,
8624 shard_id, bucket_obj);
8628 static void accumulate_raw_stats(const rgw_bucket_dir_header& header,
8629 map<RGWObjCategory, RGWStorageStats>& stats)
8631 for (const auto& pair : header.stats) {
8632 const RGWObjCategory category = static_cast<RGWObjCategory>(pair.first);
8633 const rgw_bucket_category_stats& header_stats = pair.second;
8635 RGWStorageStats& s = stats[category];
8637 s.category = category;
8638 s.size += header_stats.total_size;
8639 s.size_rounded += header_stats.total_size_rounded;
8640 s.size_utilized += header_stats.actual_size;
8641 s.num_objects += header_stats.num_entries;
8645 int RGWRados::bucket_check_index(RGWBucketInfo& bucket_info,
8646 map<RGWObjCategory, RGWStorageStats> *existing_stats,
8647 map<RGWObjCategory, RGWStorageStats> *calculated_stats)
8649 librados::IoCtx index_ctx;
8650 // key - bucket index object id
8651 // value - bucket index check OP returned result with the given bucket index object (shard)
8652 map<int, string> oids;
8653 map<int, struct rgw_cls_check_index_ret> bucket_objs_ret;
8655 int ret = open_bucket_index(bucket_info, index_ctx, oids, bucket_objs_ret);
8660 ret = CLSRGWIssueBucketCheck(index_ctx, oids, bucket_objs_ret, cct->_conf->rgw_bucket_index_max_aio)();
8665 // Aggregate results (from different shards if there is any)
8666 map<int, struct rgw_cls_check_index_ret>::iterator iter;
8667 for (iter = bucket_objs_ret.begin(); iter != bucket_objs_ret.end(); ++iter) {
8668 accumulate_raw_stats(iter->second.existing_header, *existing_stats);
8669 accumulate_raw_stats(iter->second.calculated_header, *calculated_stats);
8675 int RGWRados::bucket_rebuild_index(RGWBucketInfo& bucket_info)
8677 librados::IoCtx index_ctx;
8678 map<int, string> bucket_objs;
8680 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs);
8685 return CLSRGWIssueBucketRebuild(index_ctx, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
8688 int RGWRados::bucket_set_reshard(RGWBucketInfo& bucket_info, const cls_rgw_bucket_instance_entry& entry)
8690 librados::IoCtx index_ctx;
8691 map<int, string> bucket_objs;
8693 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs);
8698 return CLSRGWIssueSetBucketResharding(index_ctx, bucket_objs, entry, cct->_conf->rgw_bucket_index_max_aio)();
8701 int RGWRados::defer_gc(void *ctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj)
8703 RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
8704 std::string oid, key;
8705 get_obj_bucket_and_oid_loc(obj, oid, key);
8709 RGWObjState *state = NULL;
8711 int r = get_obj_state(rctx, bucket_info, obj, &state, false);
8715 if (!state->is_atomic) {
8716 ldout(cct, 20) << "state for obj=" << obj << " is not atomic, not deferring gc operation" << dendl;
8722 if (state->tail_tag.length() > 0) {
8723 tag = state->tail_tag.c_str();
8724 } else if (state->obj_tag.length() > 0) {
8725 tag = state->obj_tag.c_str();
8727 ldout(cct, 20) << "state->obj_tag is empty, not deferring gc operation" << dendl;
8731 ldout(cct, 0) << "defer chain tag=" << tag << dendl;
8733 return gc->defer_chain(tag, false);
8736 void RGWRados::remove_rgw_head_obj(ObjectWriteOperation& op)
8738 list<string> prefixes;
8739 prefixes.push_back(RGW_ATTR_OLH_PREFIX);
8740 cls_rgw_remove_obj(op, prefixes);
8743 void RGWRados::cls_obj_check_prefix_exist(ObjectOperation& op, const string& prefix, bool fail_if_exist)
8745 cls_rgw_obj_check_attrs_prefix(op, prefix, fail_if_exist);
8748 void RGWRados::cls_obj_check_mtime(ObjectOperation& op, const real_time& mtime, bool high_precision_time, RGWCheckMTimeType type)
8750 cls_rgw_obj_check_mtime(op, mtime, high_precision_time, type);
8756 * bucket: name of the bucket storing the object
8757 * obj: name of the object to delete
8758 * Returns: 0 on success, -ERR# otherwise.
8760 int RGWRados::Object::Delete::delete_obj()
8762 RGWRados *store = target->get_store();
8763 rgw_obj& src_obj = target->get_obj();
8764 const string& instance = src_obj.key.instance;
8765 rgw_obj obj = src_obj;
8767 if (instance == "null") {
8768 obj.key.instance.clear();
8771 bool explicit_marker_version = (!params.marker_version_id.empty());
8773 if (params.versioning_status & BUCKET_VERSIONED || explicit_marker_version) {
8774 if (instance.empty() || explicit_marker_version) {
8775 rgw_obj marker = obj;
8777 if (!params.marker_version_id.empty()) {
8778 if (params.marker_version_id != "null") {
8779 marker.key.set_instance(params.marker_version_id);
8781 } else if ((params.versioning_status & BUCKET_VERSIONS_SUSPENDED) == 0) {
8782 store->gen_rand_obj_instance_name(&marker);
8785 result.version_id = marker.key.instance;
8786 result.delete_marker = true;
8788 struct rgw_bucket_dir_entry_meta meta;
8790 meta.owner = params.obj_owner.get_id().to_str();
8791 meta.owner_display_name = params.obj_owner.get_display_name();
8793 if (real_clock::is_zero(params.mtime)) {
8794 meta.mtime = real_clock::now();
8796 meta.mtime = params.mtime;
8799 int r = store->set_olh(target->get_ctx(), target->get_bucket_info(), marker, true, &meta, params.olh_epoch, params.unmod_since, params.high_precision_time, params.zones_trace);
8804 rgw_bucket_dir_entry dirent;
8806 int r = store->bi_get_instance(target->get_bucket_info(), obj, &dirent);
8810 result.delete_marker = dirent.is_delete_marker();
8811 r = store->unlink_obj_instance(target->get_ctx(), target->get_bucket_info(), obj, params.olh_epoch, params.zones_trace);
8815 result.version_id = instance;
8819 int r = target->get_bucket_shard(&bs);
8821 ldout(store->ctx(), 5) << "failed to get BucketShard object: r=" << r << dendl;
8825 if (target->bucket_info.datasync_flag_enabled()) {
8826 r = store->data_log->add_entry(bs->bucket, bs->shard_id);
8828 lderr(store->ctx()) << "ERROR: failed writing data log" << dendl;
8837 int r = store->get_obj_head_ref(target->get_bucket_info(), obj, &ref);
8843 r = target->get_state(&state, false);
8847 ObjectWriteOperation op;
8849 if (!real_clock::is_zero(params.unmod_since)) {
8850 struct timespec ctime = ceph::real_clock::to_timespec(state->mtime);
8851 struct timespec unmod = ceph::real_clock::to_timespec(params.unmod_since);
8852 if (!params.high_precision_time) {
8857 ldout(store->ctx(), 10) << "If-UnModified-Since: " << params.unmod_since << " Last-Modified: " << ctime << dendl;
8858 if (ctime > unmod) {
8859 return -ERR_PRECONDITION_FAILED;
8862 /* only delete object if mtime is less than or equal to params.unmod_since */
8863 store->cls_obj_check_mtime(op, params.unmod_since, params.high_precision_time, CLS_RGW_CHECK_TIME_MTIME_LE);
8865 uint64_t obj_size = state->size;
8867 if (!real_clock::is_zero(params.expiration_time)) {
8869 real_time delete_at;
8871 if (state->get_attr(RGW_ATTR_DELETE_AT, bl)) {
8873 bufferlist::iterator iter = bl.begin();
8874 ::decode(delete_at, iter);
8875 } catch (buffer::error& err) {
8876 ldout(store->ctx(), 0) << "ERROR: couldn't decode RGW_ATTR_DELETE_AT" << dendl;
8880 if (params.expiration_time != delete_at) {
8881 return -ERR_PRECONDITION_FAILED;
8884 return -ERR_PRECONDITION_FAILED;
8888 if (!state->exists) {
8889 target->invalidate_state();
8893 r = target->prepare_atomic_modification(op, false, NULL, NULL, NULL, true, false);
8897 RGWBucketInfo& bucket_info = target->get_bucket_info();
8899 RGWRados::Bucket bop(store, bucket_info);
8900 RGWRados::Bucket::UpdateIndex index_op(&bop, obj);
8902 index_op.set_zones_trace(params.zones_trace);
8903 index_op.set_bilog_flags(params.bilog_flags);
8905 r = index_op.prepare(CLS_RGW_OP_DEL, &state->write_tag);
8909 store->remove_rgw_head_obj(op);
8910 r = ref.ioctx.operate(ref.oid, &op);
8911 bool need_invalidate = false;
8912 if (r == -ECANCELED) {
8913 /* raced with another operation, we can regard it as removed */
8914 need_invalidate = true;
8918 int64_t poolid = ref.ioctx.get_id();
8920 tombstone_cache_t *obj_tombstone_cache = store->get_tombstone_cache();
8921 if (obj_tombstone_cache) {
8922 tombstone_entry entry{*state};
8923 obj_tombstone_cache->add(obj, entry);
8925 r = index_op.complete_del(poolid, ref.ioctx.get_last_version(), state->mtime, params.remove_objs);
8927 int ret = target->complete_atomic_modification();
8929 ldout(store->ctx(), 0) << "ERROR: complete_atomic_modification returned ret=" << ret << dendl;
8931 /* other than that, no need to propagate error */
8933 int ret = index_op.cancel();
8935 ldout(store->ctx(), 0) << "ERROR: index_op.cancel() returned ret=" << ret << dendl;
8939 if (need_invalidate) {
8940 target->invalidate_state();
8946 /* update quota cache */
8947 store->quota_handler->update_stats(params.bucket_owner, obj.bucket, -1, 0, obj_size);
8952 int RGWRados::delete_obj(RGWObjectCtx& obj_ctx,
8953 const RGWBucketInfo& bucket_info,
8955 int versioning_status,
8956 uint16_t bilog_flags,
8957 const real_time& expiration_time,
8958 rgw_zone_set *zones_trace)
8960 RGWRados::Object del_target(this, bucket_info, obj_ctx, obj);
8961 RGWRados::Object::Delete del_op(&del_target);
8963 del_op.params.bucket_owner = bucket_info.owner;
8964 del_op.params.versioning_status = versioning_status;
8965 del_op.params.bilog_flags = bilog_flags;
8966 del_op.params.expiration_time = expiration_time;
8967 del_op.params.zones_trace = zones_trace;
8969 return del_op.delete_obj();
8972 int RGWRados::delete_raw_obj(const rgw_raw_obj& obj)
8975 int r = get_raw_obj_ref(obj, &ref);
8980 ObjectWriteOperation op;
8983 r = ref.ioctx.operate(ref.oid, &op);
8990 int RGWRados::delete_system_obj(rgw_raw_obj& obj, RGWObjVersionTracker *objv_tracker)
8993 ldout(cct, 1) << "delete_system_obj got empty object name "
8994 << obj << ", returning EINVAL" << dendl;
8998 int r = get_raw_obj_ref(obj, &ref);
9003 ObjectWriteOperation op;
9006 objv_tracker->prepare_op_for_write(&op);
9010 r = ref.ioctx.operate(ref.oid, &op);
9017 int RGWRados::delete_obj_index(const rgw_obj& obj)
9019 std::string oid, key;
9020 get_obj_bucket_and_oid_loc(obj, oid, key);
9022 RGWObjectCtx obj_ctx(this);
9024 RGWBucketInfo bucket_info;
9025 int ret = get_bucket_instance_info(obj_ctx, obj.bucket, bucket_info, NULL, NULL);
9027 ldout(cct, 0) << "ERROR: " << __func__ << "() get_bucket_instance_info(bucket=" << obj.bucket << ") returned ret=" << ret << dendl;
9031 RGWRados::Bucket bop(this, bucket_info);
9032 RGWRados::Bucket::UpdateIndex index_op(&bop, obj);
9034 real_time removed_mtime;
9035 int r = index_op.complete_del(-1 /* pool */, 0, removed_mtime, NULL);
9040 static void generate_fake_tag(RGWRados *store, map<string, bufferlist>& attrset, RGWObjManifest& manifest, bufferlist& manifest_bl, bufferlist& tag_bl)
9044 RGWObjManifest::obj_iterator mi = manifest.obj_begin();
9045 if (mi != manifest.obj_end()) {
9046 if (manifest.has_tail()) // first object usually points at the head, let's skip to a more unique part
9048 tag = mi.get_location().get_raw_obj(store).oid;
9052 unsigned char md5[CEPH_CRYPTO_MD5_DIGESTSIZE];
9053 char md5_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 1];
9055 hash.Update((const byte *)manifest_bl.c_str(), manifest_bl.length());
9057 map<string, bufferlist>::iterator iter = attrset.find(RGW_ATTR_ETAG);
9058 if (iter != attrset.end()) {
9059 bufferlist& bl = iter->second;
9060 hash.Update((const byte *)bl.c_str(), bl.length());
9064 buf_to_hex(md5, CEPH_CRYPTO_MD5_DIGESTSIZE, md5_str);
9065 tag.append(md5_str);
9067 ldout(store->ctx(), 10) << "generate_fake_tag new tag=" << tag << dendl;
9069 tag_bl.append(tag.c_str(), tag.size() + 1);
9072 static bool is_olh(map<string, bufferlist>& attrs)
9074 map<string, bufferlist>::iterator iter = attrs.find(RGW_ATTR_OLH_INFO);
9075 return (iter != attrs.end());
9078 static bool has_olh_tag(map<string, bufferlist>& attrs)
9080 map<string, bufferlist>::iterator iter = attrs.find(RGW_ATTR_OLH_ID_TAG);
9081 return (iter != attrs.end());
9084 int RGWRados::get_olh_target_state(RGWObjectCtx& obj_ctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
9085 RGWObjState *olh_state, RGWObjState **target_state)
9087 assert(olh_state->is_olh);
9090 int r = RGWRados::follow_olh(bucket_info, obj_ctx, olh_state, obj, &target); /* might return -EAGAIN */
9094 r = get_obj_state(&obj_ctx, bucket_info, target, target_state, false);
9102 int RGWRados::get_system_obj_state_impl(RGWObjectCtx *rctx, rgw_raw_obj& obj, RGWRawObjState **state, RGWObjVersionTracker *objv_tracker)
9108 RGWRawObjState *s = rctx->raw.get_state(obj);
9109 ldout(cct, 20) << "get_system_obj_state: rctx=" << (void *)rctx << " obj=" << obj << " state=" << (void *)s << " s->prefetch_data=" << s->prefetch_data << dendl;
9117 int r = raw_obj_stat(obj, &s->size, &s->mtime, &s->epoch, &s->attrset, (s->prefetch_data ? &s->data : NULL), objv_tracker);
9120 s->has_attrs = true;
9121 s->mtime = real_time();
9128 s->has_attrs = true;
9129 s->obj_tag = s->attrset[RGW_ATTR_ID_TAG];
9131 if (s->obj_tag.length())
9132 ldout(cct, 20) << "get_system_obj_state: setting s->obj_tag to "
9133 << s->obj_tag.c_str() << dendl;
9135 ldout(cct, 20) << "get_system_obj_state: s->obj_tag was set empty" << dendl;
9140 int RGWRados::get_system_obj_state(RGWObjectCtx *rctx, rgw_raw_obj& obj, RGWRawObjState **state, RGWObjVersionTracker *objv_tracker)
9145 ret = get_system_obj_state_impl(rctx, obj, state, objv_tracker);
9146 } while (ret == -EAGAIN);
9151 int RGWRados::get_obj_state_impl(RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
9152 RGWObjState **state, bool follow_olh, bool assume_noent)
9158 bool need_follow_olh = follow_olh && obj.key.instance.empty();
9160 RGWObjState *s = rctx->obj.get_state(obj);
9161 ldout(cct, 20) << "get_obj_state: rctx=" << (void *)rctx << " obj=" << obj << " state=" << (void *)s << " s->prefetch_data=" << s->prefetch_data << dendl;
9164 if (s->is_olh && need_follow_olh) {
9165 return get_olh_target_state(*rctx, bucket_info, obj, s, state);
9172 rgw_raw_obj raw_obj;
9173 obj_to_raw(bucket_info.placement_rule, obj, &raw_obj);
9177 if (!assume_noent) {
9178 r = RGWRados::raw_obj_stat(raw_obj, &s->size, &s->mtime, &s->epoch, &s->attrset, (s->prefetch_data ? &s->data : NULL), NULL);
9183 s->has_attrs = true;
9184 tombstone_entry entry;
9185 if (obj_tombstone_cache && obj_tombstone_cache->find(obj, entry)) {
9186 s->mtime = entry.mtime;
9187 s->zone_short_id = entry.zone_short_id;
9188 s->pg_ver = entry.pg_ver;
9189 ldout(cct, 20) << __func__ << "(): found obj in tombstone cache: obj=" << obj
9190 << " mtime=" << s->mtime << " pgv=" << s->pg_ver << dendl;
9192 s->mtime = real_time();
9200 s->has_attrs = true;
9201 s->accounted_size = s->size;
9203 auto iter = s->attrset.find(RGW_ATTR_COMPRESSION);
9204 const bool compressed = (iter != s->attrset.end());
9206 // use uncompressed size for accounted_size
9208 RGWCompressionInfo info;
9209 auto p = iter->second.begin();
9211 s->accounted_size = info.orig_size;
9212 } catch (buffer::error&) {
9213 dout(0) << "ERROR: could not decode compression info for object: " << obj << dendl;
9218 iter = s->attrset.find(RGW_ATTR_SHADOW_OBJ);
9219 if (iter != s->attrset.end()) {
9220 bufferlist bl = iter->second;
9221 bufferlist::iterator it = bl.begin();
9222 it.copy(bl.length(), s->shadow_obj);
9223 s->shadow_obj[bl.length()] = '\0';
9225 s->obj_tag = s->attrset[RGW_ATTR_ID_TAG];
9226 auto ttiter = s->attrset.find(RGW_ATTR_TAIL_TAG);
9227 if (ttiter != s->attrset.end()) {
9228 s->tail_tag = s->attrset[RGW_ATTR_TAIL_TAG];
9231 bufferlist manifest_bl = s->attrset[RGW_ATTR_MANIFEST];
9232 if (manifest_bl.length()) {
9233 bufferlist::iterator miter = manifest_bl.begin();
9235 ::decode(s->manifest, miter);
9236 s->has_manifest = true;
9237 s->manifest.set_head(bucket_info.placement_rule, obj, s->size); /* patch manifest to reflect the head we just read, some manifests might be
9238 broken due to old bugs */
9239 s->size = s->manifest.get_obj_size();
9241 s->accounted_size = s->size;
9242 } catch (buffer::error& err) {
9243 ldout(cct, 0) << "ERROR: couldn't decode manifest" << dendl;
9246 ldout(cct, 10) << "manifest: total_size = " << s->manifest.get_obj_size() << dendl;
9247 if (cct->_conf->subsys.should_gather(ceph_subsys_rgw, 20) && s->manifest.has_explicit_objs()) {
9248 RGWObjManifest::obj_iterator mi;
9249 for (mi = s->manifest.obj_begin(); mi != s->manifest.obj_end(); ++mi) {
9250 ldout(cct, 20) << "manifest: ofs=" << mi.get_ofs() << " loc=" << mi.get_location().get_raw_obj(this) << dendl;
9254 if (!s->obj_tag.length()) {
9256 * Uh oh, something's wrong, object with manifest should have tag. Let's
9257 * create one out of the manifest, would be unique
9259 generate_fake_tag(this, s->attrset, s->manifest, manifest_bl, s->obj_tag);
9263 map<string, bufferlist>::iterator aiter = s->attrset.find(RGW_ATTR_PG_VER);
9264 if (aiter != s->attrset.end()) {
9265 bufferlist& pg_ver_bl = aiter->second;
9266 if (pg_ver_bl.length()) {
9267 bufferlist::iterator pgbl = pg_ver_bl.begin();
9269 ::decode(s->pg_ver, pgbl);
9270 } catch (buffer::error& err) {
9271 ldout(cct, 0) << "ERROR: couldn't decode pg ver attr for object " << s->obj << ", non-critical error, ignoring" << dendl;
9275 aiter = s->attrset.find(RGW_ATTR_SOURCE_ZONE);
9276 if (aiter != s->attrset.end()) {
9277 bufferlist& zone_short_id_bl = aiter->second;
9278 if (zone_short_id_bl.length()) {
9279 bufferlist::iterator zbl = zone_short_id_bl.begin();
9281 ::decode(s->zone_short_id, zbl);
9282 } catch (buffer::error& err) {
9283 ldout(cct, 0) << "ERROR: couldn't decode zone short id attr for object " << s->obj << ", non-critical error, ignoring" << dendl;
9287 if (s->obj_tag.length())
9288 ldout(cct, 20) << "get_obj_state: setting s->obj_tag to " << s->obj_tag.c_str() << dendl;
9290 ldout(cct, 20) << "get_obj_state: s->obj_tag was set empty" << dendl;
9292 /* an object might not be olh yet, but could have olh id tag, so we should set it anyway if
9293 * it exist, and not only if is_olh() returns true
9295 iter = s->attrset.find(RGW_ATTR_OLH_ID_TAG);
9296 if (iter != s->attrset.end()) {
9297 s->olh_tag = iter->second;
9300 if (is_olh(s->attrset)) {
9303 ldout(cct, 20) << __func__ << ": setting s->olh_tag to " << string(s->olh_tag.c_str(), s->olh_tag.length()) << dendl;
9305 if (need_follow_olh) {
9306 return get_olh_target_state(*rctx, bucket_info, obj, s, state);
9313 int RGWRados::get_obj_state(RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state,
9314 bool follow_olh, bool assume_noent)
9319 ret = get_obj_state_impl(rctx, bucket_info, obj, state, follow_olh, assume_noent);
9320 } while (ret == -EAGAIN);
9325 int RGWRados::Object::get_manifest(RGWObjManifest **pmanifest)
9327 RGWObjState *astate;
9328 int r = get_state(&astate, true);
9333 *pmanifest = &astate->manifest;
9338 int RGWRados::Object::Read::get_attr(const char *name, bufferlist& dest)
9341 int r = source->get_state(&state, true);
9346 if (!state->get_attr(name, dest))
9353 int RGWRados::Object::Stat::stat_async()
9355 RGWObjectCtx& ctx = source->get_ctx();
9356 rgw_obj& obj = source->get_obj();
9357 RGWRados *store = source->get_store();
9359 RGWObjState *s = ctx.obj.get_state(obj); /* calling this one directly because otherwise a sync request will be sent */
9363 result.size = s->size;
9364 result.mtime = ceph::real_clock::to_timespec(s->mtime);
9365 result.attrs = s->attrset;
9366 result.has_manifest = s->has_manifest;
9367 result.manifest = s->manifest;
9373 get_obj_bucket_and_oid_loc(obj, oid, loc);
9375 int r = store->get_obj_head_ioctx(source->get_bucket_info(), obj, &state.io_ctx);
9380 librados::ObjectReadOperation op;
9381 op.stat2(&result.size, &result.mtime, NULL);
9382 op.getxattrs(&result.attrs, NULL);
9383 state.completion = librados::Rados::aio_create_completion(NULL, NULL, NULL);
9384 state.io_ctx.locator_set_key(loc);
9385 r = state.io_ctx.aio_operate(oid, state.completion, &op, NULL);
9387 ldout(store->ctx(), 5) << __func__
9388 << ": ERROR: aio_operate() returned ret=" << r
9397 int RGWRados::Object::Stat::wait()
9399 if (!state.completion) {
9403 state.completion->wait_for_safe();
9404 state.ret = state.completion->get_return_value();
9405 state.completion->release();
9407 if (state.ret != 0) {
9414 int RGWRados::Object::Stat::finish()
9416 map<string, bufferlist>::iterator iter = result.attrs.find(RGW_ATTR_MANIFEST);
9417 if (iter != result.attrs.end()) {
9418 bufferlist& bl = iter->second;
9419 bufferlist::iterator biter = bl.begin();
9421 ::decode(result.manifest, biter);
9422 } catch (buffer::error& err) {
9423 RGWRados *store = source->get_store();
9424 ldout(store->ctx(), 0) << "ERROR: " << __func__ << ": failed to decode manifest" << dendl;
9427 result.has_manifest = true;
9434 * Get an attribute for a system object.
9435 * obj: the object to get attr
9436 * name: name of the attr to retrieve
9437 * dest: bufferlist to store the result in
9438 * Returns: 0 on success, -ERR# otherwise.
9440 int RGWRados::system_obj_get_attr(rgw_raw_obj& obj, const char *name, bufferlist& dest)
9443 int r = get_system_obj_ref(obj, &ref);
9448 ObjectReadOperation op;
9451 op.getxattr(name, &dest, &rval);
9453 r = ref.ioctx.operate(ref.oid, &op, NULL);
9460 int RGWRados::append_atomic_test(RGWObjectCtx *rctx,
9461 const RGWBucketInfo& bucket_info, const rgw_obj& obj,
9462 ObjectOperation& op, RGWObjState **pstate)
9467 int r = get_obj_state(rctx, bucket_info, obj, pstate, false);
9471 RGWObjState *state = *pstate;
9473 if (!state->is_atomic) {
9474 ldout(cct, 20) << "state for obj=" << obj << " is not atomic, not appending atomic test" << dendl;
9478 if (state->obj_tag.length() > 0 && !state->fake_tag) {// check for backward compatibility
9479 op.cmpxattr(RGW_ATTR_ID_TAG, LIBRADOS_CMPXATTR_OP_EQ, state->obj_tag);
9481 ldout(cct, 20) << "state->obj_tag is empty, not appending atomic test" << dendl;
9486 int RGWRados::Object::get_state(RGWObjState **pstate, bool follow_olh, bool assume_noent)
9488 return store->get_obj_state(&ctx, bucket_info, obj, pstate, follow_olh, assume_noent);
9491 void RGWRados::Object::invalidate_state()
9493 ctx.obj.invalidate(obj);
9496 void RGWRados::SystemObject::invalidate_state()
9498 ctx.raw.invalidate(obj);
9501 int RGWRados::Object::prepare_atomic_modification(ObjectWriteOperation& op, bool reset_obj, const string *ptag,
9502 const char *if_match, const char *if_nomatch, bool removal_op,
9505 int r = get_state(&state, false);
9509 bool need_guard = (state->has_manifest || (state->obj_tag.length() != 0) ||
9510 if_match != NULL || if_nomatch != NULL) &&
9513 if (!state->is_atomic) {
9514 ldout(store->ctx(), 20) << "prepare_atomic_modification: state is not atomic. state=" << (void *)state << dendl;
9518 store->remove_rgw_head_obj(op); // we're not dropping reference here, actually removing object
9525 /* first verify that the object wasn't replaced under */
9526 if (if_nomatch == NULL || strcmp(if_nomatch, "*") != 0) {
9527 op.cmpxattr(RGW_ATTR_ID_TAG, LIBRADOS_CMPXATTR_OP_EQ, state->obj_tag);
9528 // FIXME: need to add FAIL_NOTEXIST_OK for racing deletion
9532 if (strcmp(if_match, "*") == 0) {
9533 // test the object is existing
9534 if (!state->exists) {
9535 return -ERR_PRECONDITION_FAILED;
9539 if (!state->get_attr(RGW_ATTR_ETAG, bl) ||
9540 strncmp(if_match, bl.c_str(), bl.length()) != 0) {
9541 return -ERR_PRECONDITION_FAILED;
9547 if (strcmp(if_nomatch, "*") == 0) {
9548 // test the object is NOT existing
9549 if (state->exists) {
9550 return -ERR_PRECONDITION_FAILED;
9554 if (!state->get_attr(RGW_ATTR_ETAG, bl) ||
9555 strncmp(if_nomatch, bl.c_str(), bl.length()) == 0) {
9556 return -ERR_PRECONDITION_FAILED;
9563 if (state->exists) {
9565 store->remove_rgw_head_obj(op);
9572 /* the object is being removed, no need to update its tag */
9577 state->write_tag = *ptag;
9579 append_rand_alpha(store->ctx(), state->write_tag, state->write_tag, 32);
9582 bl.append(state->write_tag.c_str(), state->write_tag.size() + 1);
9584 ldout(store->ctx(), 10) << "setting object write_tag=" << state->write_tag << dendl;
9586 op.setxattr(RGW_ATTR_ID_TAG, bl);
9588 op.setxattr(RGW_ATTR_TAIL_TAG, bl);
9594 int RGWRados::system_obj_set_attr(void *ctx, rgw_raw_obj& obj, const char *name, bufferlist& bl,
9595 RGWObjVersionTracker *objv_tracker)
9597 map<string, bufferlist> attrs;
9599 return system_obj_set_attrs(ctx, obj, attrs, NULL, objv_tracker);
9602 int RGWRados::system_obj_set_attrs(void *ctx, rgw_raw_obj& obj,
9603 map<string, bufferlist>& attrs,
9604 map<string, bufferlist>* rmattrs,
9605 RGWObjVersionTracker *objv_tracker)
9608 int r = get_system_obj_ref(obj, &ref);
9612 ObjectWriteOperation op;
9615 objv_tracker->prepare_op_for_write(&op);
9618 map<string, bufferlist>::iterator iter;
9620 for (iter = rmattrs->begin(); iter != rmattrs->end(); ++iter) {
9621 const string& name = iter->first;
9622 op.rmxattr(name.c_str());
9626 for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
9627 const string& name = iter->first;
9628 bufferlist& bl = iter->second;
9633 op.setxattr(name.c_str(), bl);
9641 r = ref.ioctx.operate(ref.oid, &op);
9649 * Set an attr on an object.
9650 * bucket: name of the bucket holding the object
9651 * obj: name of the object to set the attr on
9652 * name: the attr to set
9653 * bl: the contents of the attr
9654 * Returns: 0 on success, -ERR# otherwise.
9656 int RGWRados::set_attr(void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj, const char *name, bufferlist& bl)
9658 map<string, bufferlist> attrs;
9660 return set_attrs(ctx, bucket_info, obj, attrs, NULL);
9663 int RGWRados::set_attrs(void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj,
9664 map<string, bufferlist>& attrs,
9665 map<string, bufferlist>* rmattrs)
9668 int r = get_obj_head_ref(bucket_info, obj, &ref);
9672 RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
9674 ObjectWriteOperation op;
9675 RGWObjState *state = NULL;
9677 r = append_atomic_test(rctx, bucket_info, obj, op, &state);
9681 map<string, bufferlist>::iterator iter;
9683 for (iter = rmattrs->begin(); iter != rmattrs->end(); ++iter) {
9684 const string& name = iter->first;
9685 op.rmxattr(name.c_str());
9689 const rgw_bucket& bucket = obj.bucket;
9691 for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
9692 const string& name = iter->first;
9693 bufferlist& bl = iter->second;
9698 op.setxattr(name.c_str(), bl);
9700 if (name.compare(RGW_ATTR_DELETE_AT) == 0) {
9705 rgw_obj_index_key obj_key;
9706 obj.key.get_index_key(&obj_key);
9708 objexp_hint_add(ts, bucket.tenant, bucket.name, bucket.bucket_id, obj_key);
9709 } catch (buffer::error& err) {
9710 ldout(cct, 0) << "ERROR: failed to decode " RGW_ATTR_DELETE_AT << " attr" << dendl;
9718 RGWObjectCtx obj_ctx(this);
9721 RGWRados::Bucket bop(this, bucket_info);
9722 RGWRados::Bucket::UpdateIndex index_op(&bop, obj);
9726 append_rand_alpha(cct, tag, tag, 32);
9727 state->write_tag = tag;
9728 r = index_op.prepare(CLS_RGW_OP_ADD, &state->write_tag);
9733 bl.append(tag.c_str(), tag.size() + 1);
9734 op.setxattr(RGW_ATTR_ID_TAG, bl);
9738 real_time mtime = real_clock::now();
9739 struct timespec mtime_ts = real_clock::to_timespec(mtime);
9740 op.mtime2(&mtime_ts);
9741 r = ref.ioctx.operate(ref.oid, &op);
9744 bufferlist acl_bl = attrs[RGW_ATTR_ACL];
9745 bufferlist etag_bl = attrs[RGW_ATTR_ETAG];
9746 bufferlist content_type_bl = attrs[RGW_ATTR_CONTENT_TYPE];
9747 string etag(etag_bl.c_str(), etag_bl.length());
9748 string content_type(content_type_bl.c_str(), content_type_bl.length());
9749 uint64_t epoch = ref.ioctx.get_last_version();
9750 int64_t poolid = ref.ioctx.get_id();
9751 r = index_op.complete(poolid, epoch, state->size, state->accounted_size,
9752 mtime, etag, content_type, &acl_bl,
9753 RGW_OBJ_CATEGORY_MAIN, NULL);
9755 int ret = index_op.cancel();
9757 ldout(cct, 0) << "ERROR: complete_update_index_cancel() returned ret=" << ret << dendl;
9765 state->obj_tag.swap(bl);
9767 for (iter = rmattrs->begin(); iter != rmattrs->end(); ++iter) {
9768 state->attrset.erase(iter->first);
9771 for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
9772 state->attrset[iter->first] = iter->second;
9779 int RGWRados::Object::Read::prepare()
9781 RGWRados *store = source->get_store();
9782 CephContext *cct = store->ctx();
9786 map<string, bufferlist>::iterator iter;
9788 RGWObjState *astate;
9789 int r = source->get_state(&astate, true);
9793 if (!astate->exists) {
9797 const RGWBucketInfo& bucket_info = source->get_bucket_info();
9799 state.obj = astate->obj;
9800 store->obj_to_raw(bucket_info.placement_rule, state.obj, &state.head_obj);
9802 r = store->get_obj_head_ioctx(bucket_info, state.obj, &state.io_ctx);
9807 *params.attrs = astate->attrset;
9808 if (cct->_conf->subsys.should_gather(ceph_subsys_rgw, 20)) {
9809 for (iter = params.attrs->begin(); iter != params.attrs->end(); ++iter) {
9810 ldout(cct, 20) << "Read xattr: " << iter->first << dendl;
9815 /* Convert all times go GMT to make them compatible */
9816 if (conds.mod_ptr || conds.unmod_ptr) {
9817 obj_time_weight src_weight;
9818 src_weight.init(astate);
9819 src_weight.high_precision = conds.high_precision_time;
9821 obj_time_weight dest_weight;
9822 dest_weight.high_precision = conds.high_precision_time;
9824 if (conds.mod_ptr) {
9825 dest_weight.init(*conds.mod_ptr, conds.mod_zone_id, conds.mod_pg_ver);
9826 ldout(cct, 10) << "If-Modified-Since: " << dest_weight << " Last-Modified: " << src_weight << dendl;
9827 if (!(dest_weight < src_weight)) {
9828 return -ERR_NOT_MODIFIED;
9832 if (conds.unmod_ptr) {
9833 dest_weight.init(*conds.unmod_ptr, conds.mod_zone_id, conds.mod_pg_ver);
9834 ldout(cct, 10) << "If-UnModified-Since: " << dest_weight << " Last-Modified: " << src_weight << dendl;
9835 if (dest_weight < src_weight) {
9836 return -ERR_PRECONDITION_FAILED;
9840 if (conds.if_match || conds.if_nomatch) {
9841 r = get_attr(RGW_ATTR_ETAG, etag);
9845 if (conds.if_match) {
9846 string if_match_str = rgw_string_unquote(conds.if_match);
9847 ldout(cct, 10) << "ETag: " << etag.c_str() << " " << " If-Match: " << if_match_str << dendl;
9848 if (if_match_str.compare(etag.c_str()) != 0) {
9849 return -ERR_PRECONDITION_FAILED;
9853 if (conds.if_nomatch) {
9854 string if_nomatch_str = rgw_string_unquote(conds.if_nomatch);
9855 ldout(cct, 10) << "ETag: " << etag.c_str() << " " << " If-NoMatch: " << if_nomatch_str << dendl;
9856 if (if_nomatch_str.compare(etag.c_str()) == 0) {
9857 return -ERR_NOT_MODIFIED;
9862 if (params.obj_size)
9863 *params.obj_size = astate->size;
9865 *params.lastmod = astate->mtime;
9870 int RGWRados::Object::Read::range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end)
9877 } else if (end < 0) {
9882 if (ofs >= (off_t)obj_size) {
9885 if (end >= (off_t)obj_size) {
9892 int RGWRados::SystemObject::get_state(RGWRawObjState **pstate, RGWObjVersionTracker *objv_tracker)
9894 return store->get_system_obj_state(&ctx, obj, pstate, objv_tracker);
9897 int RGWRados::stat_system_obj(RGWObjectCtx& obj_ctx,
9898 RGWRados::SystemObject::Read::GetObjState& state,
9900 map<string, bufferlist> *attrs,
9903 RGWObjVersionTracker *objv_tracker)
9905 RGWRawObjState *astate = NULL;
9907 int r = get_system_obj_state(&obj_ctx, obj, &astate, objv_tracker);
9911 if (!astate->exists) {
9916 *attrs = astate->attrset;
9917 if (cct->_conf->subsys.should_gather(ceph_subsys_rgw, 20)) {
9918 map<string, bufferlist>::iterator iter;
9919 for (iter = attrs->begin(); iter != attrs->end(); ++iter) {
9920 ldout(cct, 20) << "Read xattr: " << iter->first << dendl;
9926 *obj_size = astate->size;
9928 *lastmod = astate->mtime;
9934 int RGWRados::Bucket::UpdateIndex::guard_reshard(BucketShard **pbs, std::function<int(BucketShard *)> call)
9936 RGWRados *store = target->get_store();
9940 #define NUM_RESHARD_RETRIES 10
9941 for (int i = 0; i < NUM_RESHARD_RETRIES; ++i) {
9942 int ret = get_bucket_shard(&bs);
9944 ldout(store->ctx(), 5) << "failed to get BucketShard object: ret=" << ret << dendl;
9948 if (r != -ERR_BUSY_RESHARDING) {
9951 ldout(store->ctx(), 0) << "NOTICE: resharding operation on bucket index detected, blocking" << dendl;
9952 string new_bucket_id;
9953 r = store->block_while_resharding(bs, &new_bucket_id);
9954 if (r == -ERR_BUSY_RESHARDING) {
9960 ldout(store->ctx(), 20) << "reshard completion identified, new_bucket_id=" << new_bucket_id << dendl;
9961 i = 0; /* resharding is finished, make sure we can retry */
9962 r = target->update_bucket_id(new_bucket_id);
9964 ldout(store->ctx(), 0) << "ERROR: update_bucket_id() new_bucket_id=" << new_bucket_id << " returned r=" << r << dendl;
9981 int RGWRados::SystemObject::Read::stat(RGWObjVersionTracker *objv_tracker)
9983 RGWRados *store = source->get_store();
9984 rgw_raw_obj& obj = source->get_obj();
9986 return store->stat_system_obj(source->get_ctx(), state, obj, stat_params.attrs,
9987 stat_params.lastmod, stat_params.obj_size, objv_tracker);
9990 int RGWRados::Bucket::UpdateIndex::prepare(RGWModifyOp op, const string *write_tag)
9995 RGWRados *store = target->get_store();
9997 if (write_tag && write_tag->length()) {
9998 optag = string(write_tag->c_str(), write_tag->length());
10000 if (optag.empty()) {
10001 append_rand_alpha(store->ctx(), optag, optag, 32);
10005 int r = guard_reshard(nullptr, [&](BucketShard *bs) -> int {
10006 return store->cls_obj_prepare_op(*bs, op, optag, obj, bilog_flags, zones_trace);
10017 int RGWRados::Bucket::UpdateIndex::complete(int64_t poolid, uint64_t epoch,
10018 uint64_t size, uint64_t accounted_size,
10019 ceph::real_time& ut, const string& etag,
10020 const string& content_type,
10021 bufferlist *acl_bl,
10022 RGWObjCategory category,
10023 list<rgw_obj_index_key> *remove_objs, const string *user_data)
10028 RGWRados *store = target->get_store();
10031 int ret = get_bucket_shard(&bs);
10033 ldout(store->ctx(), 5) << "failed to get BucketShard object: ret=" << ret << dendl;
10037 rgw_bucket_dir_entry ent;
10038 obj.key.get_index_key(&ent.key);
10039 ent.meta.size = size;
10040 ent.meta.accounted_size = accounted_size;
10041 ent.meta.mtime = ut;
10042 ent.meta.etag = etag;
10044 ent.meta.user_data = *user_data;
10047 if (acl_bl && acl_bl->length()) {
10048 int ret = store->decode_policy(*acl_bl, &owner);
10050 ldout(store->ctx(), 0) << "WARNING: could not decode policy ret=" << ret << dendl;
10053 ent.meta.owner = owner.get_id().to_str();
10054 ent.meta.owner_display_name = owner.get_display_name();
10055 ent.meta.content_type = content_type;
10057 ret = store->cls_obj_complete_add(*bs, obj, optag, poolid, epoch, ent, category, remove_objs, bilog_flags, zones_trace);
10059 if (target->bucket_info.datasync_flag_enabled()) {
10060 int r = store->data_log->add_entry(bs->bucket, bs->shard_id);
10062 lderr(store->ctx()) << "ERROR: failed writing data log" << dendl;
10069 int RGWRados::Bucket::UpdateIndex::complete_del(int64_t poolid, uint64_t epoch,
10070 real_time& removed_mtime,
10071 list<rgw_obj_index_key> *remove_objs)
10076 RGWRados *store = target->get_store();
10079 int ret = get_bucket_shard(&bs);
10081 ldout(store->ctx(), 5) << "failed to get BucketShard object: ret=" << ret << dendl;
10085 ret = store->cls_obj_complete_del(*bs, optag, poolid, epoch, obj, removed_mtime, remove_objs, bilog_flags, zones_trace);
10087 if (target->bucket_info.datasync_flag_enabled()) {
10088 int r = store->data_log->add_entry(bs->bucket, bs->shard_id);
10090 lderr(store->ctx()) << "ERROR: failed writing data log" << dendl;
10098 int RGWRados::Bucket::UpdateIndex::cancel()
10103 RGWRados *store = target->get_store();
10106 int ret = guard_reshard(&bs, [&](BucketShard *bs) -> int {
10107 return store->cls_obj_complete_cancel(*bs, optag, obj, bilog_flags, zones_trace);
10111 * need to update data log anyhow, so that whoever follows needs to update its internal markers
10112 * for following the specific bucket shard log. Otherwise they end up staying behind, and users
10113 * have no way to tell that they're all caught up
10115 if (target->bucket_info.datasync_flag_enabled()) {
10116 int r = store->data_log->add_entry(bs->bucket, bs->shard_id);
10118 lderr(store->ctx()) << "ERROR: failed writing data log" << dendl;
10125 int RGWRados::Object::Read::read(int64_t ofs, int64_t end, bufferlist& bl)
10127 RGWRados *store = source->get_store();
10128 CephContext *cct = store->ctx();
10130 rgw_raw_obj read_obj;
10131 uint64_t read_ofs = ofs;
10132 uint64_t len, read_len;
10133 bool reading_from_head = true;
10134 ObjectReadOperation op;
10136 bool merge_bl = false;
10137 bufferlist *pbl = &bl;
10138 bufferlist read_bl;
10139 uint64_t max_chunk_size;
10141 RGWObjState *astate;
10142 int r = source->get_state(&astate, true);
10149 len = end - ofs + 1;
10151 if (astate->has_manifest && astate->manifest.has_tail()) {
10152 /* now get the relevant object part */
10153 RGWObjManifest::obj_iterator iter = astate->manifest.obj_find(ofs);
10155 uint64_t stripe_ofs = iter.get_stripe_ofs();
10156 read_obj = iter.get_location().get_raw_obj(store);
10157 len = min(len, iter.get_stripe_size() - (ofs - stripe_ofs));
10158 read_ofs = iter.location_ofs() + (ofs - stripe_ofs);
10159 reading_from_head = (read_obj == state.head_obj);
10161 read_obj = state.head_obj;
10164 r = store->get_max_chunk_size(read_obj.pool, &max_chunk_size);
10166 ldout(cct, 0) << "ERROR: failed to get max_chunk_size() for pool " << read_obj.pool << dendl;
10170 if (len > max_chunk_size)
10171 len = max_chunk_size;
10174 state.io_ctx.locator_set_key(read_obj.loc);
10178 if (reading_from_head) {
10179 /* only when reading from the head object do we need to do the atomic test */
10180 r = store->append_atomic_test(&source->get_ctx(), source->get_bucket_info(), state.obj, op, &astate);
10184 if (astate && astate->prefetch_data) {
10185 if (!ofs && astate->data.length() >= len) {
10187 return bl.length();
10190 if (ofs < astate->data.length()) {
10191 unsigned copy_len = min((uint64_t)astate->data.length() - ofs, len);
10192 astate->data.copy(ofs, copy_len, bl);
10193 read_len -= copy_len;
10194 read_ofs += copy_len;
10196 return bl.length();
10204 ldout(cct, 20) << "rados->read obj-ofs=" << ofs << " read_ofs=" << read_ofs << " read_len=" << read_len << dendl;
10205 op.read(read_ofs, read_len, pbl, NULL);
10207 r = state.io_ctx.operate(read_obj.oid, &op, NULL);
10208 ldout(cct, 20) << "rados->read r=" << r << " bl.length=" << bl.length() << dendl;
10215 bl.append(read_bl);
10218 return bl.length();
10221 int RGWRados::SystemObject::Read::GetObjState::get_ref(RGWRados *store, rgw_raw_obj& obj, rgw_rados_ref **pref)
10224 int r = store->get_raw_obj_ref(obj, &ref);
10235 int RGWRados::get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
10236 RGWObjVersionTracker *objv_tracker, rgw_raw_obj& obj,
10237 bufferlist& bl, off_t ofs, off_t end,
10238 map<string, bufferlist> *attrs,
10239 rgw_cache_entry_info *cache_info)
10242 ObjectReadOperation op;
10247 len = end - ofs + 1;
10249 if (objv_tracker) {
10250 objv_tracker->prepare_op_for_read(&op);
10253 ldout(cct, 20) << "rados->read ofs=" << ofs << " len=" << len << dendl;
10254 op.read(ofs, len, &bl, NULL);
10257 op.getxattrs(attrs, NULL);
10260 rgw_rados_ref *ref;
10261 int r = read_state.get_ref(this, obj, &ref);
10263 ldout(cct, 20) << "read_state.get_ref() on obj=" << obj << " returned " << r << dendl;
10266 r = ref->ioctx.operate(ref->oid, &op, NULL);
10268 ldout(cct, 20) << "rados->read r=" << r << " bl.length=" << bl.length() << dendl;
10271 ldout(cct, 20) << "rados->read r=" << r << " bl.length=" << bl.length() << dendl;
10273 uint64_t op_ver = ref->ioctx.get_last_version();
10275 if (read_state.last_ver > 0 &&
10276 read_state.last_ver != op_ver) {
10277 ldout(cct, 5) << "raced with an object write, abort" << dendl;
10281 read_state.last_ver = op_ver;
10283 return bl.length();
10286 int RGWRados::SystemObject::Read::read(int64_t ofs, int64_t end, bufferlist& bl, RGWObjVersionTracker *objv_tracker)
10288 RGWRados *store = source->get_store();
10289 rgw_raw_obj& obj = source->get_obj();
10291 return store->get_system_obj(source->get_ctx(), state, objv_tracker, obj, bl, ofs, end, read_params.attrs, read_params.cache_info);
10294 int RGWRados::SystemObject::Read::get_attr(const char *name, bufferlist& dest)
10296 RGWRados *store = source->get_store();
10297 rgw_raw_obj& obj = source->get_obj();
10299 return store->system_obj_get_attr(obj, name, dest);
10302 struct get_obj_data;
10304 struct get_obj_aio_data {
10305 struct get_obj_data *op_data;
10310 struct get_obj_io {
10315 static void _get_obj_aio_completion_cb(completion_t cb, void *arg);
10317 struct get_obj_data : public RefCountedObject {
10322 map<off_t, get_obj_io> io_map;
10323 map<off_t, librados::AioCompletion *> completion_map;
10324 uint64_t total_read;
10327 list<get_obj_aio_data> aio_data;
10328 RGWGetDataCB *client_cb;
10329 std::atomic<bool> cancelled = { false };
10330 std::atomic<int64_t> err_code = { 0 };
10332 list<bufferlist> read_list;
10334 explicit get_obj_data(CephContext *_cct)
10336 rados(NULL), ctx(NULL),
10337 total_read(0), lock("get_obj_data"), data_lock("get_obj_data::data_lock"),
10339 throttle(cct, "get_obj_data", cct->_conf->rgw_get_obj_window_size, false) {}
10340 ~get_obj_data() override { }
10341 void set_cancelled(int r) {
10346 bool is_cancelled() {
10350 int get_err_code() {
10354 int wait_next_io(bool *done) {
10356 map<off_t, librados::AioCompletion *>::iterator iter = completion_map.begin();
10357 if (iter == completion_map.end()) {
10362 off_t cur_ofs = iter->first;
10363 librados::AioCompletion *c = iter->second;
10366 c->wait_for_safe_and_cb();
10367 int r = c->get_return_value();
10370 completion_map.erase(cur_ofs);
10372 if (completion_map.empty()) {
10382 void add_io(off_t ofs, off_t len, bufferlist **pbl, AioCompletion **pc) {
10383 Mutex::Locker l(lock);
10385 const auto& io_iter = io_map.insert(
10386 map<off_t, get_obj_io>::value_type(ofs, get_obj_io()));
10388 assert(io_iter.second); // assert new insertion
10390 get_obj_io& io = (io_iter.first)->second;
10393 struct get_obj_aio_data aio;
10396 aio.op_data = this;
10398 aio_data.push_back(aio);
10400 struct get_obj_aio_data *paio_data = &aio_data.back(); /* last element */
10402 librados::AioCompletion *c = librados::Rados::aio_create_completion((void *)paio_data, NULL, _get_obj_aio_completion_cb);
10403 completion_map[ofs] = c;
10407 /* we have a reference per IO, plus one reference for the calling function.
10408 * reference is dropped for each callback, plus when we're done iterating
10409 * over the parts */
10413 void cancel_io(off_t ofs) {
10414 ldout(cct, 20) << "get_obj_data::cancel_io() ofs=" << ofs << dendl;
10416 map<off_t, AioCompletion *>::iterator iter = completion_map.find(ofs);
10417 if (iter != completion_map.end()) {
10418 AioCompletion *c = iter->second;
10420 completion_map.erase(ofs);
10425 /* we don't drop a reference here -- e.g., not calling d->put(), because we still
10426 * need IoCtx to live, as io callback may still be called
10430 void cancel_all_io() {
10431 ldout(cct, 20) << "get_obj_data::cancel_all_io()" << dendl;
10432 Mutex::Locker l(lock);
10433 for (map<off_t, librados::AioCompletion *>::iterator iter = completion_map.begin();
10434 iter != completion_map.end(); ++iter) {
10435 librados::AioCompletion *c = iter->second;
10440 int get_complete_ios(off_t ofs, list<bufferlist>& bl_list) {
10441 Mutex::Locker l(lock);
10443 map<off_t, get_obj_io>::iterator liter = io_map.begin();
10445 if (liter == io_map.end() ||
10446 liter->first != ofs) {
10450 map<off_t, librados::AioCompletion *>::iterator aiter;
10451 aiter = completion_map.find(ofs);
10452 if (aiter == completion_map.end()) {
10453 /* completion map does not hold this io, it was cancelled */
10457 AioCompletion *completion = aiter->second;
10458 int r = completion->get_return_value();
10462 for (; aiter != completion_map.end(); ++aiter) {
10463 completion = aiter->second;
10464 if (!completion->is_safe()) {
10465 /* reached a request that is not yet complete, stop */
10469 r = completion->get_return_value();
10471 set_cancelled(r); /* mark it as cancelled, so that we don't continue processing next operations */
10477 map<off_t, get_obj_io>::iterator old_liter = liter++;
10478 bl_list.push_back(old_liter->second.bl);
10479 io_map.erase(old_liter);
10486 static int _get_obj_iterate_cb(const RGWBucketInfo& bucket_info, const rgw_obj& obj, const rgw_raw_obj& read_obj, off_t obj_ofs, off_t read_ofs, off_t len, bool is_head_obj, RGWObjState *astate, void *arg)
10488 struct get_obj_data *d = (struct get_obj_data *)arg;
10490 return d->rados->get_obj_iterate_cb(d->ctx, astate, bucket_info, obj, read_obj, obj_ofs, read_ofs, len, is_head_obj, arg);
10493 static void _get_obj_aio_completion_cb(completion_t cb, void *arg)
10495 struct get_obj_aio_data *aio_data = (struct get_obj_aio_data *)arg;
10496 struct get_obj_data *d = aio_data->op_data;
10498 d->rados->get_obj_aio_completion_cb(cb, arg);
10502 void RGWRados::get_obj_aio_completion_cb(completion_t c, void *arg)
10504 struct get_obj_aio_data *aio_data = (struct get_obj_aio_data *)arg;
10505 struct get_obj_data *d = aio_data->op_data;
10506 off_t ofs = aio_data->ofs;
10507 off_t len = aio_data->len;
10509 list<bufferlist> bl_list;
10510 list<bufferlist>::iterator iter;
10513 ldout(cct, 20) << "get_obj_aio_completion_cb: io completion ofs=" << ofs << " len=" << len << dendl;
10514 d->throttle.put(len);
10516 r = rados_aio_get_return_value(c);
10518 ldout(cct, 0) << "ERROR: got unexpected error when trying to read object: " << r << dendl;
10519 d->set_cancelled(r);
10523 if (d->is_cancelled()) {
10527 d->data_lock.Lock();
10529 r = d->get_complete_ios(ofs, bl_list);
10534 d->read_list.splice(d->read_list.end(), bl_list);
10537 d->data_lock.Unlock();
10543 int RGWRados::flush_read_list(struct get_obj_data *d)
10545 d->data_lock.Lock();
10546 list<bufferlist> l;
10547 l.swap(d->read_list);
10549 d->read_list.clear();
10551 d->data_lock.Unlock();
10555 list<bufferlist>::iterator iter;
10556 for (iter = l.begin(); iter != l.end(); ++iter) {
10557 bufferlist& bl = *iter;
10558 r = d->client_cb->handle_data(bl, 0, bl.length());
10560 dout(0) << "ERROR: flush_read_list(): d->client_cb->handle_data() returned " << r << dendl;
10565 d->data_lock.Lock();
10568 d->set_cancelled(r);
10570 d->data_lock.Unlock();
10574 int RGWRados::get_obj_iterate_cb(RGWObjectCtx *ctx, RGWObjState *astate,
10575 const RGWBucketInfo& bucket_info,
10576 const rgw_obj& obj,
10577 const rgw_raw_obj& read_obj,
10579 off_t read_ofs, off_t len,
10580 bool is_head_obj, void *arg)
10582 RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
10583 ObjectReadOperation op;
10584 struct get_obj_data *d = (struct get_obj_data *)arg;
10592 /* only when reading from the head object do we need to do the atomic test */
10593 r = append_atomic_test(rctx, bucket_info, obj, op, &astate);
10598 obj_ofs < astate->data.length()) {
10599 unsigned chunk_len = min((uint64_t)astate->data.length() - obj_ofs, (uint64_t)len);
10601 d->data_lock.Lock();
10602 r = d->client_cb->handle_data(astate->data, obj_ofs, chunk_len);
10603 d->data_lock.Unlock();
10608 d->total_read += chunk_len;
10612 read_ofs += chunk_len;
10613 obj_ofs += chunk_len;
10619 d->throttle.get(len);
10620 if (d->is_cancelled()) {
10621 return d->get_err_code();
10624 /* add io after we check that we're not cancelled, otherwise we're going to have trouble
10627 d->add_io(obj_ofs, len, &pbl, &c);
10629 ldout(cct, 20) << "rados->get_obj_iterate_cb oid=" << read_obj.oid << " obj-ofs=" << obj_ofs << " read_ofs=" << read_ofs << " len=" << len << dendl;
10630 op.read(read_ofs, len, pbl, NULL);
10632 librados::IoCtx io_ctx(d->io_ctx);
10633 io_ctx.locator_set_key(read_obj.loc);
10635 r = io_ctx.aio_operate(read_obj.oid, c, &op, NULL);
10637 ldout(cct, 0) << "rados->aio_operate r=" << r << dendl;
10641 // Flush data to client if there is any
10642 r = flush_read_list(d);
10649 ldout(cct, 20) << "cancelling io r=" << r << " obj_ofs=" << obj_ofs << dendl;
10650 d->set_cancelled(r);
10651 d->cancel_io(obj_ofs);
10656 int RGWRados::Object::Read::iterate(int64_t ofs, int64_t end, RGWGetDataCB *cb)
10658 RGWRados *store = source->get_store();
10659 CephContext *cct = store->ctx();
10661 struct get_obj_data *data = new get_obj_data(cct);
10664 RGWObjectCtx& obj_ctx = source->get_ctx();
10666 data->rados = store;
10667 data->io_ctx.dup(state.io_ctx);
10668 data->client_cb = cb;
10670 int r = store->iterate_obj(obj_ctx, source->get_bucket_info(), state.obj, ofs, end, cct->_conf->rgw_get_obj_max_req_size, _get_obj_iterate_cb, (void *)data);
10672 data->cancel_all_io();
10677 r = data->wait_next_io(&done);
10679 dout(10) << "get_obj_iterate() r=" << r << ", canceling all io" << dendl;
10680 data->cancel_all_io();
10683 r = store->flush_read_list(data);
10685 dout(10) << "get_obj_iterate() r=" << r << ", canceling all io" << dendl;
10686 data->cancel_all_io();
10696 int RGWRados::iterate_obj(RGWObjectCtx& obj_ctx,
10697 const RGWBucketInfo& bucket_info, const rgw_obj& obj,
10698 off_t ofs, off_t end,
10699 uint64_t max_chunk_size,
10700 int (*iterate_obj_cb)(const RGWBucketInfo&, const rgw_obj& obj,
10701 const rgw_raw_obj&, off_t, off_t, off_t, bool,
10702 RGWObjState *, void *),
10705 rgw_raw_obj head_obj;
10706 rgw_raw_obj read_obj;
10707 uint64_t read_ofs = ofs;
10709 bool reading_from_head = true;
10710 RGWObjState *astate = NULL;
10712 obj_to_raw(bucket_info.placement_rule, obj, &head_obj);
10714 int r = get_obj_state(&obj_ctx, bucket_info, obj, &astate, false);
10722 len = end - ofs + 1;
10724 if (astate->has_manifest) {
10725 /* now get the relevant object stripe */
10726 RGWObjManifest::obj_iterator iter = astate->manifest.obj_find(ofs);
10728 RGWObjManifest::obj_iterator obj_end = astate->manifest.obj_end();
10730 for (; iter != obj_end && ofs <= end; ++iter) {
10731 off_t stripe_ofs = iter.get_stripe_ofs();
10732 off_t next_stripe_ofs = stripe_ofs + iter.get_stripe_size();
10734 while (ofs < next_stripe_ofs && ofs <= end) {
10735 read_obj = iter.get_location().get_raw_obj(this);
10736 uint64_t read_len = min(len, iter.get_stripe_size() - (ofs - stripe_ofs));
10737 read_ofs = iter.location_ofs() + (ofs - stripe_ofs);
10739 if (read_len > max_chunk_size) {
10740 read_len = max_chunk_size;
10743 reading_from_head = (read_obj == head_obj);
10744 r = iterate_obj_cb(bucket_info, obj, read_obj, ofs, read_ofs, read_len, reading_from_head, astate, arg);
10754 while (ofs <= end) {
10755 read_obj = head_obj;
10756 uint64_t read_len = min(len, max_chunk_size);
10758 r = iterate_obj_cb(bucket_info, obj, read_obj, ofs, ofs, read_len, reading_from_head, astate, arg);
10771 int RGWRados::obj_operate(const RGWBucketInfo& bucket_info, const rgw_obj& obj, ObjectWriteOperation *op)
10774 int r = get_obj_head_ref(bucket_info, obj, &ref);
10779 return ref.ioctx.operate(ref.oid, op);
10782 int RGWRados::obj_operate(const RGWBucketInfo& bucket_info, const rgw_obj& obj, ObjectReadOperation *op)
10785 int r = get_obj_head_ref(bucket_info, obj, &ref);
10792 return ref.ioctx.operate(ref.oid, op, &outbl);
10795 int RGWRados::olh_init_modification_impl(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, string *op_tag)
10797 ObjectWriteOperation op;
10799 assert(olh_obj.key.instance.empty());
10801 bool has_tag = (state.exists && has_olh_tag(state.attrset));
10803 if (!state.exists) {
10806 op.assert_exists();
10810 * 3 possible cases: olh object doesn't exist, it exists as an olh, it exists as a regular object.
10811 * If it exists as a regular object we'll need to transform it into an olh. We'll do it in two
10812 * steps, first change its tag and set the olh pending attrs. Once write is done we'll need to
10813 * truncate it, remove extra attrs, and send it to the garbage collection. The bucket index olh
10814 * log will reflect that.
10816 * Need to generate separate olh and obj tags, as olh can be colocated with object data. obj_tag
10817 * is used for object data instance, olh_tag for olh instance.
10820 /* guard against racing writes */
10821 bucket_index_guard_olh_op(state, op);
10827 int ret = gen_rand_alphanumeric_lower(cct, &obj_tag, 32);
10829 ldout(cct, 0) << "ERROR: gen_rand_alphanumeric_lower() returned ret=" << ret << dendl;
10833 bl.append(obj_tag.c_str(), obj_tag.size());
10834 op.setxattr(RGW_ATTR_ID_TAG, bl);
10836 state.attrset[RGW_ATTR_ID_TAG] = bl;
10837 state.obj_tag = bl;
10841 ret = gen_rand_alphanumeric_lower(cct, &olh_tag, 32);
10843 ldout(cct, 0) << "ERROR: gen_rand_alphanumeric_lower() returned ret=" << ret << dendl;
10847 olh_bl.append(olh_tag.c_str(), olh_tag.size());
10848 op.setxattr(RGW_ATTR_OLH_ID_TAG, olh_bl);
10850 state.attrset[RGW_ATTR_OLH_ID_TAG] = olh_bl;
10851 state.olh_tag = olh_bl;
10852 state.is_olh = true;
10855 op.setxattr(RGW_ATTR_OLH_VER, verbl);
10859 RGWOLHPendingInfo pending_info;
10860 pending_info.time = real_clock::now();
10861 ::encode(pending_info, bl);
10863 #define OLH_PENDING_TAG_LEN 32
10864 /* tag will start with current time epoch, this so that entries are sorted by time */
10866 utime_t ut(pending_info.time);
10867 snprintf(buf, sizeof(buf), "%016llx", (unsigned long long)ut.sec());
10871 int ret = gen_rand_alphanumeric_lower(cct, &s, OLH_PENDING_TAG_LEN - op_tag->size());
10873 ldout(cct, 0) << "ERROR: gen_rand_alphanumeric_lower() returned ret=" << ret << dendl;
10878 string attr_name = RGW_ATTR_OLH_PENDING_PREFIX;
10879 attr_name.append(*op_tag);
10881 op.setxattr(attr_name.c_str(), bl);
10883 ret = obj_operate(bucket_info, olh_obj, &op);
10888 state.exists = true;
10889 state.attrset[attr_name] = bl;
10894 int RGWRados::olh_init_modification(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj, string *op_tag)
10898 ret = olh_init_modification_impl(bucket_info, state, obj, op_tag);
10899 if (ret == -EEXIST) {
10906 int RGWRados::guard_reshard(BucketShard *bs, const rgw_obj& obj_instance, std::function<int(BucketShard *)> call)
10909 const rgw_obj *pobj = &obj_instance;
10912 for (int i = 0; i < NUM_RESHARD_RETRIES; ++i) {
10913 r = bs->init(pobj->bucket, *pobj);
10915 ldout(cct, 5) << "bs.init() returned ret=" << r << dendl;
10919 if (r != -ERR_BUSY_RESHARDING) {
10922 ldout(cct, 0) << "NOTICE: resharding operation on bucket index detected, blocking" << dendl;
10923 string new_bucket_id;
10924 r = block_while_resharding(bs, &new_bucket_id);
10925 if (r == -ERR_BUSY_RESHARDING) {
10931 ldout(cct, 20) << "reshard completion identified, new_bucket_id=" << new_bucket_id << dendl;
10932 i = 0; /* resharding is finished, make sure we can retry */
10935 obj.bucket.update_bucket_id(new_bucket_id);
10946 int RGWRados::block_while_resharding(RGWRados::BucketShard *bs, string *new_bucket_id)
10948 std::shared_ptr<RGWReshardWait> waiter = reshard_wait;
10950 return waiter->block_while_resharding(bs, new_bucket_id);
10953 int RGWRados::bucket_index_link_olh(const RGWBucketInfo& bucket_info, RGWObjState& olh_state, const rgw_obj& obj_instance,
10954 bool delete_marker,
10955 const string& op_tag,
10956 struct rgw_bucket_dir_entry_meta *meta,
10957 uint64_t olh_epoch,
10958 real_time unmod_since, bool high_precision_time, rgw_zone_set *_zones_trace)
10961 int r = get_obj_head_ref(bucket_info, obj_instance, &ref);
10966 rgw_zone_set zones_trace;
10967 if (_zones_trace) {
10968 zones_trace = *_zones_trace;
10970 zones_trace.insert(get_zone().id);
10973 BucketShard bs(this);
10975 cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), obj_instance.key.instance);
10976 r = guard_reshard(&bs, obj_instance, [&](BucketShard *bs) -> int {
10977 librados::ObjectWriteOperation op;
10978 cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
10979 return cls_rgw_bucket_link_olh(bs->index_ctx, op,
10980 bs->bucket_obj, key, olh_state.olh_tag, delete_marker, op_tag, meta, olh_epoch,
10981 unmod_since, high_precision_time,
10982 get_zone().log_data, zones_trace);
10985 ldout(cct, 20) << "cls_rgw_bucket_link_olh() returned r=" << r << dendl;
10992 void RGWRados::bucket_index_guard_olh_op(RGWObjState& olh_state, ObjectOperation& op)
10994 ldout(cct, 20) << __func__ << "(): olh_state.olh_tag=" << string(olh_state.olh_tag.c_str(), olh_state.olh_tag.length()) << dendl;
10995 op.cmpxattr(RGW_ATTR_OLH_ID_TAG, CEPH_OSD_CMPXATTR_OP_EQ, olh_state.olh_tag);
10998 int RGWRados::bucket_index_unlink_instance(const RGWBucketInfo& bucket_info, const rgw_obj& obj_instance,
10999 const string& op_tag, const string& olh_tag, uint64_t olh_epoch, rgw_zone_set *_zones_trace)
11002 int r = get_obj_head_ref(bucket_info, obj_instance, &ref);
11007 rgw_zone_set zones_trace;
11008 if (_zones_trace) {
11009 zones_trace = *_zones_trace;
11011 zones_trace.insert(get_zone().id);
11013 BucketShard bs(this);
11015 cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), obj_instance.key.instance);
11016 r = guard_reshard(&bs, obj_instance, [&](BucketShard *bs) -> int {
11017 librados::ObjectWriteOperation op;
11018 cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
11019 return cls_rgw_bucket_unlink_instance(bs->index_ctx, op, bs->bucket_obj, key, op_tag,
11020 olh_tag, olh_epoch, get_zone().log_data, zones_trace);
11023 ldout(cct, 20) << "cls_rgw_bucket_link_olh() returned r=" << r << dendl;
11030 int RGWRados::bucket_index_read_olh_log(const RGWBucketInfo& bucket_info, RGWObjState& state,
11031 const rgw_obj& obj_instance, uint64_t ver_marker,
11032 map<uint64_t, vector<rgw_bucket_olh_log_entry> > *log,
11033 bool *is_truncated)
11036 int r = get_obj_head_ref(bucket_info, obj_instance, &ref);
11041 BucketShard bs(this);
11042 int ret = bs.init(obj_instance.bucket, obj_instance);
11044 ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
11048 string olh_tag(state.olh_tag.c_str(), state.olh_tag.length());
11050 cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), string());
11052 ret = guard_reshard(&bs, obj_instance, [&](BucketShard *bs) -> int {
11053 ObjectReadOperation op;
11054 cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
11055 return cls_rgw_get_olh_log(bs->index_ctx, bs->bucket_obj, op,
11056 key, ver_marker, olh_tag, log, is_truncated);
11059 ldout(cct, 20) << "cls_rgw_get_olh_log() returned r=" << r << dendl;
11066 int RGWRados::bucket_index_trim_olh_log(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj_instance, uint64_t ver)
11069 int r = get_obj_head_ref(bucket_info, obj_instance, &ref);
11074 BucketShard bs(this);
11075 int ret = bs.init(obj_instance.bucket, obj_instance);
11077 ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
11081 string olh_tag(state.olh_tag.c_str(), state.olh_tag.length());
11083 cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), string());
11085 ret = guard_reshard(&bs, obj_instance, [&](BucketShard *pbs) -> int {
11086 ObjectWriteOperation op;
11087 cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
11088 cls_rgw_trim_olh_log(op, key, ver, olh_tag);
11089 return pbs->index_ctx.operate(pbs->bucket_obj, &op);
11092 ldout(cct, 20) << "cls_rgw_trim_olh_log() returned r=" << ret << dendl;
11099 int RGWRados::bucket_index_clear_olh(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj_instance)
11102 int r = get_obj_head_ref(bucket_info, obj_instance, &ref);
11107 BucketShard bs(this);
11109 string olh_tag(state.olh_tag.c_str(), state.olh_tag.length());
11111 cls_rgw_obj_key key(obj_instance.key.get_index_key_name(), string());
11113 int ret = guard_reshard(&bs, obj_instance, [&](BucketShard *pbs) -> int {
11114 ObjectWriteOperation op;
11115 cls_rgw_guard_bucket_resharding(op, -ERR_BUSY_RESHARDING);
11116 return cls_rgw_clear_olh(pbs->index_ctx, op, pbs->bucket_obj, key, olh_tag);
11119 ldout(cct, 5) << "cls_rgw_clear_olh() returned ret=" << ret << dendl;
11126 int RGWRados::apply_olh_log(RGWObjectCtx& obj_ctx, RGWObjState& state, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
11127 bufferlist& olh_tag, map<uint64_t, vector<rgw_bucket_olh_log_entry> >& log,
11128 uint64_t *plast_ver, rgw_zone_set* zones_trace)
11134 librados::ObjectWriteOperation op;
11136 uint64_t last_ver = log.rbegin()->first;
11137 *plast_ver = last_ver;
11139 map<uint64_t, vector<rgw_bucket_olh_log_entry> >::iterator iter = log.begin();
11141 op.cmpxattr(RGW_ATTR_OLH_ID_TAG, CEPH_OSD_CMPXATTR_OP_EQ, olh_tag);
11142 op.cmpxattr(RGW_ATTR_OLH_VER, CEPH_OSD_CMPXATTR_OP_GT, last_ver);
11144 bool need_to_link = false;
11145 cls_rgw_obj_key key;
11146 bool delete_marker = false;
11147 list<cls_rgw_obj_key> remove_instances;
11148 bool need_to_remove = false;
11150 for (iter = log.begin(); iter != log.end(); ++iter) {
11151 vector<rgw_bucket_olh_log_entry>::iterator viter = iter->second.begin();
11152 for (; viter != iter->second.end(); ++viter) {
11153 rgw_bucket_olh_log_entry& entry = *viter;
11155 ldout(cct, 20) << "olh_log_entry: op=" << (int)entry.op
11156 << " key=" << entry.key.name << "[" << entry.key.instance << "] "
11157 << (entry.delete_marker ? "(delete)" : "") << dendl;
11158 switch (entry.op) {
11159 case CLS_RGW_OLH_OP_REMOVE_INSTANCE:
11160 remove_instances.push_back(entry.key);
11162 case CLS_RGW_OLH_OP_LINK_OLH:
11163 need_to_link = true;
11164 need_to_remove = false;
11166 delete_marker = entry.delete_marker;
11168 case CLS_RGW_OLH_OP_UNLINK_OLH:
11169 need_to_remove = true;
11170 need_to_link = false;
11173 ldout(cct, 0) << "ERROR: apply_olh_log: invalid op: " << (int)entry.op << dendl;
11176 string attr_name = RGW_ATTR_OLH_PENDING_PREFIX;
11177 attr_name.append(entry.op_tag);
11178 op.rmxattr(attr_name.c_str());
11183 int r = get_obj_head_ref(bucket_info, obj, &ref);
11188 const rgw_bucket& bucket = obj.bucket;
11190 if (need_to_link) {
11191 rgw_obj target(bucket, key);
11193 info.target = target;
11194 info.removed = delete_marker;
11196 ::encode(info, bl);
11197 op.setxattr(RGW_ATTR_OLH_INFO, bl);
11200 /* first remove object instances */
11201 for (list<cls_rgw_obj_key>::iterator liter = remove_instances.begin();
11202 liter != remove_instances.end(); ++liter) {
11203 cls_rgw_obj_key& key = *liter;
11204 rgw_obj obj_instance(bucket, key);
11205 int ret = delete_obj(obj_ctx, bucket_info, obj_instance, 0, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace);
11206 if (ret < 0 && ret != -ENOENT) {
11207 ldout(cct, 0) << "ERROR: delete_obj() returned " << ret << " obj_instance=" << obj_instance << dendl;
11212 /* update olh object */
11213 r = ref.ioctx.operate(ref.oid, &op);
11214 if (r == -ECANCELED) {
11218 ldout(cct, 0) << "ERROR: could not apply olh update, r=" << r << dendl;
11222 r = bucket_index_trim_olh_log(bucket_info, state, obj, last_ver);
11224 ldout(cct, 0) << "ERROR: could not trim olh log, r=" << r << dendl;
11228 if (need_to_remove) {
11229 ObjectWriteOperation rm_op;
11231 rm_op.cmpxattr(RGW_ATTR_OLH_ID_TAG, CEPH_OSD_CMPXATTR_OP_EQ, olh_tag);
11232 rm_op.cmpxattr(RGW_ATTR_OLH_VER, CEPH_OSD_CMPXATTR_OP_GT, last_ver);
11233 cls_obj_check_prefix_exist(rm_op, RGW_ATTR_OLH_PENDING_PREFIX, true); /* fail if found one of these, pending modification */
11236 r = ref.ioctx.operate(ref.oid, &rm_op);
11237 if (r == -ECANCELED) {
11238 return 0; /* someone else won this race */
11241 * only clear if was successful, otherwise we might clobber pending operations on this object
11243 r = bucket_index_clear_olh(bucket_info, state, obj);
11245 ldout(cct, 0) << "ERROR: could not clear bucket index olh entries r=" << r << dendl;
11255 * read olh log and apply it
11257 int RGWRados::update_olh(RGWObjectCtx& obj_ctx, RGWObjState *state, const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_zone_set *zones_trace)
11259 map<uint64_t, vector<rgw_bucket_olh_log_entry> > log;
11261 uint64_t ver_marker = 0;
11264 int ret = bucket_index_read_olh_log(bucket_info, *state, obj, ver_marker, &log, &is_truncated);
11268 ret = apply_olh_log(obj_ctx, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, zones_trace);
11272 } while (is_truncated);
11277 int RGWRados::set_olh(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
11278 uint64_t olh_epoch, real_time unmod_since, bool high_precision_time, rgw_zone_set *zones_trace)
11282 rgw_obj olh_obj = target_obj;
11283 olh_obj.key.instance.clear();
11285 RGWObjState *state = NULL;
11290 #define MAX_ECANCELED_RETRY 100
11291 for (i = 0; i < MAX_ECANCELED_RETRY; i++) {
11292 if (ret == -ECANCELED) {
11293 obj_ctx.obj.invalidate(olh_obj);
11296 ret = get_obj_state(&obj_ctx, bucket_info, olh_obj, &state, false); /* don't follow olh */
11301 ret = olh_init_modification(bucket_info, *state, olh_obj, &op_tag);
11303 ldout(cct, 20) << "olh_init_modification() target_obj=" << target_obj << " delete_marker=" << (int)delete_marker << " returned " << ret << dendl;
11304 if (ret == -ECANCELED) {
11309 ret = bucket_index_link_olh(bucket_info, *state, target_obj, delete_marker, op_tag, meta, olh_epoch, unmod_since, high_precision_time, zones_trace);
11311 ldout(cct, 20) << "bucket_index_link_olh() target_obj=" << target_obj << " delete_marker=" << (int)delete_marker << " returned " << ret << dendl;
11312 if (ret == -ECANCELED) {
11320 if (i == MAX_ECANCELED_RETRY) {
11321 ldout(cct, 0) << "ERROR: exceeded max ECANCELED retries, aborting (EIO)" << dendl;
11325 ret = update_olh(obj_ctx, state, bucket_info, olh_obj);
11326 if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */
11330 ldout(cct, 20) << "update_olh() target_obj=" << target_obj << " returned " << ret << dendl;
11337 int RGWRados::unlink_obj_instance(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj,
11338 uint64_t olh_epoch, rgw_zone_set *zones_trace)
11342 rgw_obj olh_obj = target_obj;
11343 olh_obj.key.instance.clear();
11345 RGWObjState *state = NULL;
11350 for (i = 0; i < MAX_ECANCELED_RETRY; i++) {
11351 if (ret == -ECANCELED) {
11352 obj_ctx.obj.invalidate(olh_obj);
11355 ret = get_obj_state(&obj_ctx, bucket_info, olh_obj, &state, false); /* don't follow olh */
11359 ret = olh_init_modification(bucket_info, *state, olh_obj, &op_tag);
11361 ldout(cct, 20) << "olh_init_modification() target_obj=" << target_obj << " returned " << ret << dendl;
11362 if (ret == -ECANCELED) {
11368 string olh_tag(state->olh_tag.c_str(), state->olh_tag.length());
11370 ret = bucket_index_unlink_instance(bucket_info, target_obj, op_tag, olh_tag, olh_epoch, zones_trace);
11372 ldout(cct, 20) << "bucket_index_unlink_instance() target_obj=" << target_obj << " returned " << ret << dendl;
11373 if (ret == -ECANCELED) {
11381 if (i == MAX_ECANCELED_RETRY) {
11382 ldout(cct, 0) << "ERROR: exceeded max ECANCELED retries, aborting (EIO)" << dendl;
11386 ret = update_olh(obj_ctx, state, bucket_info, olh_obj, zones_trace);
11387 if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */
11391 ldout(cct, 20) << "update_olh() target_obj=" << target_obj << " returned " << ret << dendl;
11398 void RGWRados::gen_rand_obj_instance_name(rgw_obj *target_obj)
11400 #define OBJ_INSTANCE_LEN 32
11401 char buf[OBJ_INSTANCE_LEN + 1];
11403 gen_rand_alphanumeric_no_underscore(cct, buf, OBJ_INSTANCE_LEN); /* don't want it to get url escaped,
11404 no underscore for instance name due to the way we encode the raw keys */
11406 target_obj->key.set_instance(buf);
11409 static void filter_attrset(map<string, bufferlist>& unfiltered_attrset, const string& check_prefix,
11410 map<string, bufferlist> *attrset)
11413 map<string, bufferlist>::iterator iter;
11414 for (iter = unfiltered_attrset.lower_bound(check_prefix);
11415 iter != unfiltered_attrset.end(); ++iter) {
11416 if (!boost::algorithm::starts_with(iter->first, check_prefix))
11418 (*attrset)[iter->first] = iter->second;
11422 int RGWRados::get_olh(const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWOLHInfo *olh)
11424 map<string, bufferlist> unfiltered_attrset;
11426 ObjectReadOperation op;
11427 op.getxattrs(&unfiltered_attrset, NULL);
11430 int r = obj_operate(bucket_info, obj, &op);
11435 map<string, bufferlist> attrset;
11437 filter_attrset(unfiltered_attrset, RGW_ATTR_OLH_PREFIX, &attrset);
11439 map<string, bufferlist>::iterator iter = attrset.find(RGW_ATTR_OLH_INFO);
11440 if (iter == attrset.end()) { /* not an olh */
11445 bufferlist::iterator biter = iter->second.begin();
11446 ::decode(*olh, biter);
11447 } catch (buffer::error& err) {
11448 ldout(cct, 0) << "ERROR: failed to decode olh info" << dendl;
11455 void RGWRados::check_pending_olh_entries(map<string, bufferlist>& pending_entries,
11456 map<string, bufferlist> *rm_pending_entries)
11458 map<string, bufferlist>::iterator iter = pending_entries.begin();
11460 real_time now = real_clock::now();
11462 while (iter != pending_entries.end()) {
11463 bufferlist::iterator biter = iter->second.begin();
11464 RGWOLHPendingInfo pending_info;
11466 ::decode(pending_info, biter);
11467 } catch (buffer::error& err) {
11468 /* skipping bad entry, we could remove it but it might hide a bug */
11469 ldout(cct, 0) << "ERROR: failed to decode pending entry " << iter->first << dendl;
11474 map<string, bufferlist>::iterator cur_iter = iter;
11476 if (now - pending_info.time >= make_timespan(cct->_conf->rgw_olh_pending_timeout_sec)) {
11477 (*rm_pending_entries)[cur_iter->first] = cur_iter->second;
11478 pending_entries.erase(cur_iter);
11480 /* entries names are sorted by time (rounded to a second) */
11486 int RGWRados::remove_olh_pending_entries(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, map<string, bufferlist>& pending_attrs)
11488 ObjectWriteOperation op;
11490 bucket_index_guard_olh_op(state, op);
11492 for (map<string, bufferlist>::iterator iter = pending_attrs.begin(); iter != pending_attrs.end(); ++iter) {
11493 op.rmxattr(iter->first.c_str());
11497 int r = get_obj_head_ref(bucket_info, olh_obj, &ref);
11502 /* update olh object */
11503 r = ref.ioctx.operate(ref.oid, &op);
11504 if (r == -ENOENT || r == -ECANCELED) {
11505 /* raced with some other change, shouldn't sweat about it */
11509 ldout(cct, 0) << "ERROR: could not apply olh update, r=" << r << dendl;
11516 int RGWRados::follow_olh(const RGWBucketInfo& bucket_info, RGWObjectCtx& obj_ctx, RGWObjState *state, const rgw_obj& olh_obj, rgw_obj *target)
11518 map<string, bufferlist> pending_entries;
11519 filter_attrset(state->attrset, RGW_ATTR_OLH_PENDING_PREFIX, &pending_entries);
11521 map<string, bufferlist> rm_pending_entries;
11522 check_pending_olh_entries(pending_entries, &rm_pending_entries);
11524 if (!rm_pending_entries.empty()) {
11525 int ret = remove_olh_pending_entries(bucket_info, *state, olh_obj, rm_pending_entries);
11527 ldout(cct, 20) << "ERROR: rm_pending_entries returned ret=" << ret << dendl;
11531 if (!pending_entries.empty()) {
11532 ldout(cct, 20) << __func__ << "(): found pending entries, need to update_olh() on bucket=" << olh_obj.bucket << dendl;
11534 int ret = update_olh(obj_ctx, state, bucket_info, olh_obj);
11540 map<string, bufferlist>::iterator iter = state->attrset.find(RGW_ATTR_OLH_INFO);
11541 assert(iter != state->attrset.end());
11544 bufferlist::iterator biter = iter->second.begin();
11545 ::decode(olh, biter);
11546 } catch (buffer::error& err) {
11547 ldout(cct, 0) << "ERROR: failed to decode olh info" << dendl;
11555 *target = olh.target;
11560 int RGWRados::raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch,
11561 map<string, bufferlist> *attrs, bufferlist *first_chunk,
11562 RGWObjVersionTracker *objv_tracker)
11565 int r = get_raw_obj_ref(obj, &ref);
11570 map<string, bufferlist> unfiltered_attrset;
11572 struct timespec mtime_ts;
11574 ObjectReadOperation op;
11575 if (objv_tracker) {
11576 objv_tracker->prepare_op_for_read(&op);
11579 op.getxattrs(&unfiltered_attrset, NULL);
11581 if (psize || pmtime) {
11582 op.stat2(&size, &mtime_ts, NULL);
11585 op.read(0, cct->_conf->rgw_max_chunk_size, first_chunk, NULL);
11588 r = ref.ioctx.operate(ref.oid, &op, &outbl);
11591 *epoch = ref.ioctx.get_last_version();
11600 *pmtime = ceph::real_clock::from_timespec(mtime_ts);
11602 filter_attrset(unfiltered_attrset, RGW_ATTR_PREFIX, attrs);
11608 int RGWRados::get_bucket_stats(RGWBucketInfo& bucket_info, int shard_id, string *bucket_ver, string *master_ver,
11609 map<RGWObjCategory, RGWStorageStats>& stats, string *max_marker, bool *syncstopped)
11611 map<string, rgw_bucket_dir_header> headers;
11612 map<int, string> bucket_instance_ids;
11613 int r = cls_bucket_head(bucket_info, shard_id, headers, &bucket_instance_ids);
11618 assert(headers.size() == bucket_instance_ids.size());
11620 map<string, rgw_bucket_dir_header>::iterator iter = headers.begin();
11621 map<int, string>::iterator viter = bucket_instance_ids.begin();
11622 BucketIndexShardsManager ver_mgr;
11623 BucketIndexShardsManager master_ver_mgr;
11624 BucketIndexShardsManager marker_mgr;
11626 for(; iter != headers.end(); ++iter, ++viter) {
11627 accumulate_raw_stats(iter->second, stats);
11628 snprintf(buf, sizeof(buf), "%lu", (unsigned long)iter->second.ver);
11629 ver_mgr.add(viter->first, string(buf));
11630 snprintf(buf, sizeof(buf), "%lu", (unsigned long)iter->second.master_ver);
11631 master_ver_mgr.add(viter->first, string(buf));
11632 if (shard_id >= 0) {
11633 *max_marker = iter->second.max_marker;
11635 marker_mgr.add(viter->first, iter->second.max_marker);
11637 if (syncstopped != NULL)
11638 *syncstopped = iter->second.syncstopped;
11640 ver_mgr.to_string(bucket_ver);
11641 master_ver_mgr.to_string(master_ver);
11642 if (shard_id < 0) {
11643 marker_mgr.to_string(max_marker);
11648 int RGWRados::get_bi_log_status(RGWBucketInfo& bucket_info, int shard_id,
11649 map<int, string>& markers)
11651 map<string, rgw_bucket_dir_header> headers;
11652 map<int, string> bucket_instance_ids;
11653 int r = cls_bucket_head(bucket_info, shard_id, headers, &bucket_instance_ids);
11657 assert(headers.size() == bucket_instance_ids.size());
11659 map<string, rgw_bucket_dir_header>::iterator iter = headers.begin();
11660 map<int, string>::iterator viter = bucket_instance_ids.begin();
11662 for(; iter != headers.end(); ++iter, ++viter) {
11663 if (shard_id >= 0) {
11664 markers[shard_id] = iter->second.max_marker;
11666 markers[viter->first] = iter->second.max_marker;
11672 class RGWGetBucketStatsContext : public RGWGetDirHeader_CB {
11673 RGWGetBucketStats_CB *cb;
11675 map<RGWObjCategory, RGWStorageStats> stats;
11681 RGWGetBucketStatsContext(RGWGetBucketStats_CB *_cb, uint32_t _pendings)
11682 : cb(_cb), pendings(_pendings), stats(), ret_code(0), should_cb(true),
11683 lock("RGWGetBucketStatsContext") {}
11685 void handle_response(int r, rgw_bucket_dir_header& header) override {
11686 Mutex::Locker l(lock);
11689 accumulate_raw_stats(header, stats);
11694 // Are we all done?
11695 if (--pendings == 0) {
11697 cb->set_response(&stats);
11699 cb->handle_response(ret_code);
11706 Mutex::Locker l(lock);
11711 int RGWRados::get_bucket_stats_async(RGWBucketInfo& bucket_info, int shard_id, RGWGetBucketStats_CB *ctx)
11714 RGWGetBucketStatsContext *get_ctx = new RGWGetBucketStatsContext(ctx, bucket_info.num_shards ? : 1);
11716 int r = cls_bucket_head_async(bucket_info, shard_id, get_ctx, &num_aio);
11720 get_ctx->unset_cb();
11727 class RGWGetUserStatsContext : public RGWGetUserHeader_CB {
11728 RGWGetUserStats_CB *cb;
11731 explicit RGWGetUserStatsContext(RGWGetUserStats_CB * const cb)
11734 void handle_response(int r, cls_user_header& header) override {
11735 const cls_user_stats& hs = header.stats;
11737 RGWStorageStats stats;
11739 stats.size = hs.total_bytes;
11740 stats.size_rounded = hs.total_bytes_rounded;
11741 stats.num_objects = hs.total_entries;
11743 cb->set_response(stats);
11746 cb->handle_response(r);
11752 int RGWRados::get_user_stats(const rgw_user& user, RGWStorageStats& stats)
11754 string user_str = user.to_str();
11756 cls_user_header header;
11757 int r = cls_user_get_header(user_str, &header);
11761 const cls_user_stats& hs = header.stats;
11763 stats.size = hs.total_bytes;
11764 stats.size_rounded = hs.total_bytes_rounded;
11765 stats.num_objects = hs.total_entries;
11770 int RGWRados::get_user_stats_async(const rgw_user& user, RGWGetUserStats_CB *ctx)
11772 string user_str = user.to_str();
11774 RGWGetUserStatsContext *get_ctx = new RGWGetUserStatsContext(ctx);
11775 int r = cls_user_get_header_async(user_str, get_ctx);
11785 void RGWRados::get_bucket_meta_oid(const rgw_bucket& bucket, string& oid)
11787 oid = RGW_BUCKET_INSTANCE_MD_PREFIX + bucket.get_key(':');
11790 void RGWRados::get_bucket_instance_obj(const rgw_bucket& bucket, rgw_raw_obj& obj)
11792 if (!bucket.oid.empty()) {
11793 obj.init(get_zone_params().domain_root, bucket.oid);
11796 get_bucket_meta_oid(bucket, oid);
11797 obj.init(get_zone_params().domain_root, oid);
11801 int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, const string& meta_key, RGWBucketInfo& info,
11802 real_time *pmtime, map<string, bufferlist> *pattrs)
11804 size_t pos = meta_key.find(':');
11805 if (pos == string::npos) {
11808 string oid = RGW_BUCKET_INSTANCE_MD_PREFIX + meta_key;
11809 rgw_bucket_instance_key_to_oid(oid);
11811 return get_bucket_instance_from_oid(obj_ctx, oid, info, pmtime, pattrs);
11814 int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, const rgw_bucket& bucket, RGWBucketInfo& info,
11815 real_time *pmtime, map<string, bufferlist> *pattrs)
11818 if (bucket.oid.empty()) {
11819 get_bucket_meta_oid(bucket, oid);
11824 return get_bucket_instance_from_oid(obj_ctx, oid, info, pmtime, pattrs);
11827 int RGWRados::get_bucket_instance_from_oid(RGWObjectCtx& obj_ctx, const string& oid, RGWBucketInfo& info,
11828 real_time *pmtime, map<string, bufferlist> *pattrs,
11829 rgw_cache_entry_info *cache_info)
11831 ldout(cct, 20) << "reading from " << get_zone_params().domain_root << ":" << oid << dendl;
11835 int ret = rgw_get_system_obj(this, obj_ctx, get_zone_params().domain_root, oid, epbl, &info.objv_tracker, pmtime, pattrs, cache_info);
11840 bufferlist::iterator iter = epbl.begin();
11842 ::decode(info, iter);
11843 } catch (buffer::error& err) {
11844 ldout(cct, 0) << "ERROR: could not decode buffer info, caught buffer::error" << dendl;
11847 info.bucket.oid = oid;
11851 int RGWRados::get_bucket_entrypoint_info(RGWObjectCtx& obj_ctx,
11852 const string& tenant_name,
11853 const string& bucket_name,
11854 RGWBucketEntryPoint& entry_point,
11855 RGWObjVersionTracker *objv_tracker,
11857 map<string, bufferlist> *pattrs,
11858 rgw_cache_entry_info *cache_info)
11861 string bucket_entry;
11863 rgw_make_bucket_entry_name(tenant_name, bucket_name, bucket_entry);
11864 int ret = rgw_get_system_obj(this, obj_ctx, get_zone_params().domain_root, bucket_entry, bl, objv_tracker, pmtime, pattrs, cache_info);
11869 bufferlist::iterator iter = bl.begin();
11871 ::decode(entry_point, iter);
11872 } catch (buffer::error& err) {
11873 ldout(cct, 0) << "ERROR: could not decode buffer info, caught buffer::error" << dendl;
11879 int RGWRados::convert_old_bucket_info(RGWObjectCtx& obj_ctx,
11880 const string& tenant_name,
11881 const string& bucket_name)
11883 RGWBucketEntryPoint entry_point;
11884 real_time ep_mtime;
11885 RGWObjVersionTracker ot;
11886 map<string, bufferlist> attrs;
11887 RGWBucketInfo info;
11889 ldout(cct, 10) << "RGWRados::convert_old_bucket_info(): bucket=" << bucket_name << dendl;
11891 int ret = get_bucket_entrypoint_info(obj_ctx, tenant_name, bucket_name, entry_point, &ot, &ep_mtime, &attrs);
11893 ldout(cct, 0) << "ERROR: get_bucket_entrypoint_info() returned " << ret << " bucket=" << bucket_name << dendl;
11897 if (!entry_point.has_bucket_info) {
11898 /* already converted! */
11902 info = entry_point.old_bucket_info;
11903 info.bucket.oid = bucket_name;
11904 info.ep_objv = ot.read_version;
11906 ot.generate_new_write_ver(cct);
11908 ret = put_linked_bucket_info(info, false, ep_mtime, &ot.write_version, &attrs, true);
11910 ldout(cct, 0) << "ERROR: failed to put_linked_bucket_info(): " << ret << dendl;
11917 int RGWRados::get_bucket_info(RGWObjectCtx& obj_ctx,
11918 const string& tenant, const string& bucket_name, RGWBucketInfo& info,
11919 real_time *pmtime, map<string, bufferlist> *pattrs)
11921 bucket_info_entry e;
11922 string bucket_entry;
11923 rgw_make_bucket_entry_name(tenant, bucket_name, bucket_entry);
11925 if (binfo_cache->find(bucket_entry, &e)) {
11934 RGWBucketEntryPoint entry_point;
11935 real_time ep_mtime;
11936 RGWObjVersionTracker ot;
11937 rgw_cache_entry_info entry_cache_info;
11938 int ret = get_bucket_entrypoint_info(obj_ctx, tenant, bucket_name, entry_point, &ot, &ep_mtime, pattrs, &entry_cache_info);
11940 /* only init these fields */
11941 info.bucket.tenant = tenant;
11942 info.bucket.name = bucket_name;
11946 if (entry_point.has_bucket_info) {
11947 info = entry_point.old_bucket_info;
11948 info.bucket.oid = bucket_name;
11949 info.bucket.tenant = tenant;
11950 info.ep_objv = ot.read_version;
11951 ldout(cct, 20) << "rgw_get_bucket_info: old bucket info, bucket=" << info.bucket << " owner " << info.owner << dendl;
11955 /* data is in the bucket instance object, we need to get attributes from there, clear everything
11962 ldout(cct, 20) << "rgw_get_bucket_info: bucket instance: " << entry_point.bucket << dendl;
11965 /* read bucket instance info */
11968 get_bucket_meta_oid(entry_point.bucket, oid);
11970 rgw_cache_entry_info cache_info;
11972 ret = get_bucket_instance_from_oid(obj_ctx, oid, e.info, &e.mtime, &e.attrs, &cache_info);
11973 e.info.ep_objv = ot.read_version;
11976 info.bucket.tenant = tenant;
11977 info.bucket.name = bucket_name;
11978 // XXX and why return anything in case of an error anyway?
11987 list<rgw_cache_entry_info *> cache_info_entries;
11988 cache_info_entries.push_back(&entry_cache_info);
11989 cache_info_entries.push_back(&cache_info);
11992 /* chain to both bucket entry point and bucket instance */
11993 if (!binfo_cache->put(this, bucket_entry, &e, cache_info_entries)) {
11994 ldout(cct, 20) << "couldn't put binfo cache entry, might have raced with data changes" << dendl;
12000 int RGWRados::put_bucket_entrypoint_info(const string& tenant_name, const string& bucket_name, RGWBucketEntryPoint& entry_point,
12001 bool exclusive, RGWObjVersionTracker& objv_tracker, real_time mtime,
12002 map<string, bufferlist> *pattrs)
12005 ::encode(entry_point, epbl);
12006 string bucket_entry;
12007 rgw_make_bucket_entry_name(tenant_name, bucket_name, bucket_entry);
12008 return rgw_bucket_store_info(this, bucket_entry, epbl, exclusive, pattrs, &objv_tracker, mtime);
12011 int RGWRados::put_bucket_instance_info(RGWBucketInfo& info, bool exclusive,
12012 real_time mtime, map<string, bufferlist> *pattrs)
12014 info.has_instance_obj = true;
12017 ::encode(info, bl);
12019 string key = info.bucket.get_key(); /* when we go through meta api, we don't use oid directly */
12020 int ret = rgw_bucket_instance_store_info(this, key, bl, exclusive, pattrs, &info.objv_tracker, mtime);
12021 if (ret == -EEXIST) {
12022 /* well, if it's exclusive we shouldn't overwrite it, because we might race with another
12023 * bucket operation on this specific bucket (e.g., being synced from the master), but
12024 * since bucket instace meta object is unique for this specific bucket instace, we don't
12025 * need to return an error.
12026 * A scenario where we'd get -EEXIST here, is in a multi-zone config, we're not on the
12027 * master, creating a bucket, sending bucket creation to the master, we create the bucket
12028 * locally, while in the sync thread we sync the new bucket.
12035 int RGWRados::put_linked_bucket_info(RGWBucketInfo& info, bool exclusive, real_time mtime, obj_version *pep_objv,
12036 map<string, bufferlist> *pattrs, bool create_entry_point)
12038 bool create_head = !info.has_instance_obj || create_entry_point;
12040 int ret = put_bucket_instance_info(info, exclusive, mtime, pattrs);
12046 return 0; /* done! */
12048 RGWBucketEntryPoint entry_point;
12049 entry_point.bucket = info.bucket;
12050 entry_point.owner = info.owner;
12051 entry_point.creation_time = info.creation_time;
12052 entry_point.linked = true;
12053 RGWObjVersionTracker ot;
12054 if (pep_objv && !pep_objv->tag.empty()) {
12055 ot.write_version = *pep_objv;
12057 ot.generate_new_write_ver(cct);
12059 *pep_objv = ot.write_version;
12062 ret = put_bucket_entrypoint_info(info.bucket.tenant, info.bucket.name, entry_point, exclusive, ot, mtime, NULL);
12069 int RGWRados::omap_get_vals(rgw_raw_obj& obj, bufferlist& header, const string& marker, uint64_t count, std::map<string, bufferlist>& m)
12072 int r = get_raw_obj_ref(obj, &ref);
12077 r = ref.ioctx.omap_get_vals(ref.oid, marker, count, &m);
12085 int RGWRados::omap_get_all(rgw_raw_obj& obj, bufferlist& header,
12086 std::map<string, bufferlist>& m)
12089 int r = get_raw_obj_ref(obj, &ref);
12094 #define MAX_OMAP_GET_ENTRIES 1024
12095 const int count = MAX_OMAP_GET_ENTRIES;
12096 string start_after;
12099 std::map<string, bufferlist> t;
12100 r = ref.ioctx.omap_get_vals(ref.oid, start_after, count, &t);
12107 start_after = t.rbegin()->first;
12108 m.insert(t.begin(), t.end());
12113 int RGWRados::omap_set(rgw_raw_obj& obj, const std::string& key, bufferlist& bl)
12116 int r = get_raw_obj_ref(obj, &ref);
12120 ldout(cct, 15) << "omap_set obj=" << obj << " key=" << key << dendl;
12122 map<string, bufferlist> m;
12125 r = ref.ioctx.omap_set(ref.oid, m);
12130 int RGWRados::omap_set(rgw_raw_obj& obj, std::map<std::string, bufferlist>& m)
12133 int r = get_raw_obj_ref(obj, &ref);
12138 r = ref.ioctx.omap_set(ref.oid, m);
12143 int RGWRados::omap_del(rgw_raw_obj& obj, const std::string& key)
12146 int r = get_raw_obj_ref(obj, &ref);
12154 r = ref.ioctx.omap_rm_keys(ref.oid, k);
12158 int RGWRados::update_containers_stats(map<string, RGWBucketEnt>& m)
12160 RGWObjectCtx obj_ctx(this);
12162 map<string, RGWBucketEnt>::iterator iter;
12163 for (iter = m.begin(); iter != m.end(); ++iter) {
12164 RGWBucketEnt& ent = iter->second;
12165 rgw_bucket& bucket = ent.bucket;
12168 ent.size_rounded = 0;
12170 map<string, rgw_bucket_dir_header> headers;
12172 RGWBucketInfo bucket_info;
12173 int ret = get_bucket_instance_info(obj_ctx, bucket, bucket_info, NULL, NULL);
12178 int r = cls_bucket_head(bucket_info, RGW_NO_SHARD, headers);
12182 map<string, rgw_bucket_dir_header>::iterator hiter = headers.begin();
12183 for (; hiter != headers.end(); ++hiter) {
12184 RGWObjCategory category = main_category;
12185 map<uint8_t, struct rgw_bucket_category_stats>::iterator iter = (hiter->second.stats).find((uint8_t)category);
12186 if (iter != hiter->second.stats.end()) {
12187 struct rgw_bucket_category_stats& stats = iter->second;
12188 ent.count += stats.num_entries;
12189 ent.size += stats.total_size;
12190 ent.size_rounded += stats.total_size_rounded;
12194 // fill in placement_rule from the bucket instance for use in swift's
12195 // per-storage policy statistics
12196 ent.placement_rule = std::move(bucket_info.placement_rule);
12202 int RGWRados::append_async(rgw_raw_obj& obj, size_t size, bufferlist& bl)
12205 int r = get_raw_obj_ref(obj, &ref);
12209 librados::Rados *rad = get_rados_handle();
12210 librados::AioCompletion *completion = rad->aio_create_completion(NULL, NULL, NULL);
12212 r = ref.ioctx.aio_append(ref.oid, completion, bl, size);
12213 completion->release();
12217 int RGWRados::distribute(const string& key, bufferlist& bl)
12220 * we were called before watch was initialized. This can only happen if we're updating some system
12221 * config object (e.g., zone info) during init. Don't try to distribute the cache info for these
12222 * objects, they're currently only read on startup anyway.
12224 if (!watch_initialized)
12228 pick_control_oid(key, notify_oid);
12230 ldout(cct, 10) << "distributing notification oid=" << notify_oid << " bl.length()=" << bl.length() << dendl;
12231 return control_pool_ctx.notify2(notify_oid, bl, 0, NULL);
12234 int RGWRados::pool_iterate_begin(const rgw_pool& pool, RGWPoolIterCtx& ctx)
12236 librados::IoCtx& io_ctx = ctx.io_ctx;
12237 librados::NObjectIterator& iter = ctx.iter;
12239 int r = open_pool_ctx(pool, io_ctx);
12243 iter = io_ctx.nobjects_begin();
12248 int RGWRados::pool_iterate_begin(const rgw_pool& pool, const string& cursor, RGWPoolIterCtx& ctx)
12250 librados::IoCtx& io_ctx = ctx.io_ctx;
12251 librados::NObjectIterator& iter = ctx.iter;
12253 int r = open_pool_ctx(pool, io_ctx);
12257 librados::ObjectCursor oc;
12258 if (!oc.from_str(cursor)) {
12259 ldout(cct, 10) << "failed to parse cursor: " << cursor << dendl;
12263 iter = io_ctx.nobjects_begin(oc);
12268 string RGWRados::pool_iterate_get_cursor(RGWPoolIterCtx& ctx)
12270 return ctx.iter.get_cursor().to_str();
12273 int RGWRados::pool_iterate(RGWPoolIterCtx& ctx, uint32_t num, vector<rgw_bucket_dir_entry>& objs,
12274 bool *is_truncated, RGWAccessListFilter *filter)
12276 librados::IoCtx& io_ctx = ctx.io_ctx;
12277 librados::NObjectIterator& iter = ctx.iter;
12279 if (iter == io_ctx.nobjects_end())
12284 for (i = 0; i < num && iter != io_ctx.nobjects_end(); ++i, ++iter) {
12285 rgw_bucket_dir_entry e;
12287 string oid = iter->get_oid();
12288 ldout(cct, 20) << "RGWRados::pool_iterate: got " << oid << dendl;
12290 // fill it in with initial values; we may correct later
12291 if (filter && !filter->filter(oid, oid))
12299 *is_truncated = (iter != io_ctx.nobjects_end());
12301 return objs.size();
12303 struct RGWAccessListFilterPrefix : public RGWAccessListFilter {
12306 explicit RGWAccessListFilterPrefix(const string& _prefix) : prefix(_prefix) {}
12307 bool filter(string& name, string& key) override {
12308 return (prefix.compare(key.substr(0, prefix.size())) == 0);
12312 int RGWRados::list_raw_objects_init(const rgw_pool& pool, const string& marker, RGWListRawObjsCtx *ctx)
12314 if (!ctx->initialized) {
12315 int r = pool_iterate_begin(pool, marker, ctx->iter_ctx);
12317 ldout(cct, 10) << "failed to list objects pool_iterate_begin() returned r=" << r << dendl;
12320 ctx->initialized = true;
12325 int RGWRados::list_raw_objects_next(const string& prefix_filter, int max,
12326 RGWListRawObjsCtx& ctx, list<string>& oids,
12327 bool *is_truncated)
12329 if (!ctx.initialized) {
12332 RGWAccessListFilterPrefix filter(prefix_filter);
12333 vector<rgw_bucket_dir_entry> objs;
12334 int r = pool_iterate(ctx.iter_ctx, max, objs, is_truncated, &filter);
12337 ldout(cct, 10) << "failed to list objects pool_iterate returned r=" << r << dendl;
12341 vector<rgw_bucket_dir_entry>::iterator iter;
12342 for (iter = objs.begin(); iter != objs.end(); ++iter) {
12343 oids.push_back(iter->key.name);
12346 return oids.size();
12349 int RGWRados::list_raw_objects(const rgw_pool& pool, const string& prefix_filter,
12350 int max, RGWListRawObjsCtx& ctx, list<string>& oids,
12351 bool *is_truncated)
12353 if (!ctx.initialized) {
12354 int r = list_raw_objects_init(pool, string(), &ctx);
12360 return list_raw_objects_next(prefix_filter, max, ctx, oids, is_truncated);
12363 string RGWRados::list_raw_objs_get_cursor(RGWListRawObjsCtx& ctx)
12365 return pool_iterate_get_cursor(ctx.iter_ctx);
12368 int RGWRados::list_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id, string& marker, uint32_t max,
12369 std::list<rgw_bi_log_entry>& result, bool *truncated)
12371 ldout(cct, 20) << __func__ << ": " << bucket_info.bucket << " marker " << marker << " shard_id=" << shard_id << " max " << max << dendl;
12374 librados::IoCtx index_ctx;
12375 map<int, string> oids;
12376 map<int, cls_rgw_bi_log_list_ret> bi_log_lists;
12377 map<int, string> bucket_instance_ids;
12378 int r = open_bucket_index(bucket_info, index_ctx, oids, shard_id, &bucket_instance_ids);
12382 BucketIndexShardsManager marker_mgr;
12383 bool has_shards = (oids.size() > 1 || shard_id >= 0);
12384 // If there are multiple shards for the bucket index object, the marker
12385 // should have the pattern '{shard_id_1}#{shard_marker_1},{shard_id_2}#
12386 // {shard_marker_2}...', if there is no sharding, the bi_log_list should
12387 // only contain one record, and the key is the bucket instance id.
12388 r = marker_mgr.from_string(marker, shard_id);
12392 r = CLSRGWIssueBILogList(index_ctx, marker_mgr, max, oids, bi_log_lists, cct->_conf->rgw_bucket_index_max_aio)();
12396 map<int, list<rgw_bi_log_entry>::iterator> vcurrents;
12397 map<int, list<rgw_bi_log_entry>::iterator> vends;
12399 *truncated = false;
12401 map<int, cls_rgw_bi_log_list_ret>::iterator miter = bi_log_lists.begin();
12402 for (; miter != bi_log_lists.end(); ++miter) {
12403 int shard_id = miter->first;
12404 vcurrents[shard_id] = miter->second.entries.begin();
12405 vends[shard_id] = miter->second.entries.end();
12407 *truncated = (*truncated || miter->second.truncated);
12412 bool has_more = true;
12413 map<int, list<rgw_bi_log_entry>::iterator>::iterator viter;
12414 map<int, list<rgw_bi_log_entry>::iterator>::iterator eiter;
12415 while (total < max && has_more) {
12418 viter = vcurrents.begin();
12419 eiter = vends.begin();
12421 for (; total < max && viter != vcurrents.end(); ++viter, ++eiter) {
12422 assert (eiter != vends.end());
12424 int shard_id = viter->first;
12425 list<rgw_bi_log_entry>::iterator& liter = viter->second;
12427 if (liter == eiter->second){
12430 rgw_bi_log_entry& entry = *(liter);
12433 snprintf(buf, sizeof(buf), "%d", shard_id);
12435 build_bucket_index_marker(buf, entry.id, &tmp_id);
12436 entry.id.swap(tmp_id);
12438 marker_mgr.add(shard_id, entry.id);
12439 result.push_back(entry);
12447 for (viter = vcurrents.begin(), eiter = vends.begin(); viter != vcurrents.end(); ++viter, ++eiter) {
12448 assert (eiter != vends.end());
12449 *truncated = (*truncated || (viter->second != eiter->second));
12453 // Refresh marker, if there are multiple shards, the output will look like
12454 // '{shard_oid_1}#{shard_marker_1},{shard_oid_2}#{shard_marker_2}...',
12455 // if there is no sharding, the simply marker (without oid) is returned
12457 marker_mgr.to_string(&marker);
12459 if (!result.empty()) {
12460 marker = result.rbegin()->id;
12467 int RGWRados::trim_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id, string& start_marker, string& end_marker)
12469 librados::IoCtx index_ctx;
12470 map<int, string> bucket_objs;
12472 BucketIndexShardsManager start_marker_mgr;
12473 BucketIndexShardsManager end_marker_mgr;
12475 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs, shard_id);
12480 r = start_marker_mgr.from_string(start_marker, shard_id);
12485 r = end_marker_mgr.from_string(end_marker, shard_id);
12490 return CLSRGWIssueBILogTrim(index_ctx, start_marker_mgr, end_marker_mgr, bucket_objs,
12491 cct->_conf->rgw_bucket_index_max_aio)();
12496 int RGWRados::resync_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id)
12498 librados::IoCtx index_ctx;
12499 map<int, string> bucket_objs;
12500 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs, shard_id);
12504 return CLSRGWIssueResyncBucketBILog(index_ctx, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
12507 int RGWRados::stop_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id)
12509 librados::IoCtx index_ctx;
12510 map<int, string> bucket_objs;
12511 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs, shard_id);
12515 return CLSRGWIssueBucketBILogStop(index_ctx, bucket_objs, cct->_conf->rgw_bucket_index_max_aio)();
12518 int RGWRados::bi_get_instance(const RGWBucketInfo& bucket_info, rgw_obj& obj, rgw_bucket_dir_entry *dirent)
12521 int r = get_obj_head_ref(bucket_info, obj, &ref);
12526 rgw_cls_bi_entry bi_entry;
12527 r = bi_get(obj.bucket, obj, InstanceIdx, &bi_entry);
12528 if (r < 0 && r != -ENOENT) {
12529 ldout(cct, 0) << "ERROR: bi_get() returned r=" << r << dendl;
12534 bufferlist::iterator iter = bi_entry.data.begin();
12536 ::decode(*dirent, iter);
12537 } catch (buffer::error& err) {
12538 ldout(cct, 0) << "ERROR: failed to decode bi_entry()" << dendl;
12545 int RGWRados::bi_get(rgw_bucket& bucket, rgw_obj& obj, BIIndexType index_type, rgw_cls_bi_entry *entry)
12547 BucketShard bs(this);
12548 int ret = bs.init(bucket, obj);
12550 ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
12554 cls_rgw_obj_key key(obj.key.get_index_key_name(), obj.key.instance);
12556 ret = cls_rgw_bi_get(bs.index_ctx, bs.bucket_obj, index_type, key, entry);
12563 void RGWRados::bi_put(ObjectWriteOperation& op, BucketShard& bs, rgw_cls_bi_entry& entry)
12565 cls_rgw_bi_put(op, bs.bucket_obj, entry);
12568 int RGWRados::bi_put(BucketShard& bs, rgw_cls_bi_entry& entry)
12570 int ret = cls_rgw_bi_put(bs.index_ctx, bs.bucket_obj, entry);
12577 int RGWRados::bi_put(rgw_bucket& bucket, rgw_obj& obj, rgw_cls_bi_entry& entry)
12579 BucketShard bs(this);
12580 int ret = bs.init(bucket, obj);
12582 ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
12586 return bi_put(bs, entry);
12589 int RGWRados::bi_list(rgw_bucket& bucket, const string& obj_name, const string& marker, uint32_t max, list<rgw_cls_bi_entry> *entries, bool *is_truncated)
12591 rgw_obj obj(bucket, obj_name);
12592 BucketShard bs(this);
12593 int ret = bs.init(bucket, obj);
12595 ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
12599 ret = cls_rgw_bi_list(bs.index_ctx, bs.bucket_obj, obj_name, marker, max, entries, is_truncated);
12600 if (ret == -ENOENT) {
12601 *is_truncated = false;
12609 int RGWRados::bi_list(BucketShard& bs, const string& filter_obj, const string& marker, uint32_t max, list<rgw_cls_bi_entry> *entries, bool *is_truncated)
12611 int ret = cls_rgw_bi_list(bs.index_ctx, bs.bucket_obj, filter_obj, marker, max, entries, is_truncated);
12618 int RGWRados::bi_remove(BucketShard& bs)
12620 int ret = bs.index_ctx.remove(bs.bucket_obj);
12621 if (ret == -ENOENT) {
12625 ldout(cct, 5) << "bs.index_ctx.remove(" << bs.bucket_obj << ") returned ret=" << ret << dendl;
12632 int RGWRados::bi_list(rgw_bucket& bucket, int shard_id, const string& filter_obj, const string& marker, uint32_t max, list<rgw_cls_bi_entry> *entries, bool *is_truncated)
12634 BucketShard bs(this);
12635 int ret = bs.init(bucket, shard_id);
12637 ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
12641 return bi_list(bs, filter_obj, marker, max, entries, is_truncated);
12644 int RGWRados::gc_operate(string& oid, librados::ObjectWriteOperation *op)
12646 return gc_pool_ctx.operate(oid, op);
12649 int RGWRados::gc_aio_operate(string& oid, librados::ObjectWriteOperation *op)
12651 AioCompletion *c = librados::Rados::aio_create_completion(NULL, NULL, NULL);
12652 int r = gc_pool_ctx.aio_operate(oid, c, op);
12657 int RGWRados::gc_operate(string& oid, librados::ObjectReadOperation *op, bufferlist *pbl)
12659 return gc_pool_ctx.operate(oid, op, pbl);
12662 int RGWRados::list_gc_objs(int *index, string& marker, uint32_t max, bool expired_only, std::list<cls_rgw_gc_obj_info>& result, bool *truncated)
12664 return gc->list(index, marker, max, expired_only, result, truncated);
12667 int RGWRados::process_gc()
12669 return gc->process();
12672 int RGWRados::list_lc_progress(const string& marker, uint32_t max_entries, map<string, int> *progress_map)
12674 return lc->list_lc_progress(marker, max_entries, progress_map);
12677 int RGWRados::process_lc()
12679 return lc->process();
12682 int RGWRados::process_expire_objects()
12684 obj_expirer->inspect_all_shards(utime_t(), ceph_clock_now());
12688 int RGWRados::cls_rgw_init_index(librados::IoCtx& index_ctx, librados::ObjectWriteOperation& op, string& oid)
12691 cls_rgw_bucket_init(op);
12692 return index_ctx.operate(oid, &op);
12695 int RGWRados::cls_obj_prepare_op(BucketShard& bs, RGWModifyOp op, string& tag,
12696 rgw_obj& obj, uint16_t bilog_flags, rgw_zone_set *_zones_trace)
12698 rgw_zone_set zones_trace;
12699 if (_zones_trace) {
12700 zones_trace = *_zones_trace;
12703 zones_trace.insert(get_zone().id);
12706 ObjectWriteOperation o;
12707 cls_rgw_obj_key key(obj.key.get_index_key_name(), obj.key.instance);
12708 cls_rgw_guard_bucket_resharding(o, -ERR_BUSY_RESHARDING);
12709 cls_rgw_bucket_prepare_op(o, op, tag, key, obj.key.get_loc(), get_zone().log_data, bilog_flags, zones_trace);
12710 return bs.index_ctx.operate(bs.bucket_obj, &o);
12713 int RGWRados::cls_obj_complete_op(BucketShard& bs, const rgw_obj& obj, RGWModifyOp op, string& tag,
12714 int64_t pool, uint64_t epoch,
12715 rgw_bucket_dir_entry& ent, RGWObjCategory category,
12716 list<rgw_obj_index_key> *remove_objs, uint16_t bilog_flags, rgw_zone_set *_zones_trace)
12718 ObjectWriteOperation o;
12719 rgw_bucket_dir_entry_meta dir_meta;
12720 dir_meta = ent.meta;
12721 dir_meta.category = category;
12723 rgw_bucket_entry_ver ver;
12726 cls_rgw_obj_key key(ent.key.name, ent.key.instance);
12727 cls_rgw_guard_bucket_resharding(o, -ERR_BUSY_RESHARDING);
12728 cls_rgw_bucket_complete_op(o, op, tag, ver, key, dir_meta, remove_objs,
12729 get_zone().log_data, bilog_flags, _zones_trace);
12730 complete_op_data *arg;
12731 index_completion_manager->create_completion(obj, op, tag, ver, key, dir_meta, remove_objs,
12732 get_zone().log_data, bilog_flags, _zones_trace, &arg);
12733 librados::AioCompletion *completion = arg->rados_completion;
12734 int ret = bs.index_ctx.aio_operate(bs.bucket_obj, arg->rados_completion, &o);
12735 completion->release(); /* can't reference arg here, as it might have already been released */
12739 int RGWRados::cls_obj_complete_add(BucketShard& bs, const rgw_obj& obj, string& tag,
12740 int64_t pool, uint64_t epoch,
12741 rgw_bucket_dir_entry& ent, RGWObjCategory category,
12742 list<rgw_obj_index_key> *remove_objs, uint16_t bilog_flags, rgw_zone_set *zones_trace)
12744 return cls_obj_complete_op(bs, obj, CLS_RGW_OP_ADD, tag, pool, epoch, ent, category, remove_objs, bilog_flags, zones_trace);
12747 int RGWRados::cls_obj_complete_del(BucketShard& bs, string& tag,
12748 int64_t pool, uint64_t epoch,
12750 real_time& removed_mtime,
12751 list<rgw_obj_index_key> *remove_objs,
12752 uint16_t bilog_flags,
12753 rgw_zone_set *zones_trace)
12755 rgw_bucket_dir_entry ent;
12756 ent.meta.mtime = removed_mtime;
12757 obj.key.get_index_key(&ent.key);
12758 return cls_obj_complete_op(bs, obj, CLS_RGW_OP_DEL, tag, pool, epoch, ent, RGW_OBJ_CATEGORY_NONE, remove_objs, bilog_flags, zones_trace);
12761 int RGWRados::cls_obj_complete_cancel(BucketShard& bs, string& tag, rgw_obj& obj, uint16_t bilog_flags, rgw_zone_set *zones_trace)
12763 rgw_bucket_dir_entry ent;
12764 obj.key.get_index_key(&ent.key);
12765 return cls_obj_complete_op(bs, obj, CLS_RGW_OP_CANCEL, tag, -1 /* pool id */, 0, ent, RGW_OBJ_CATEGORY_NONE, NULL, bilog_flags, zones_trace);
12768 int RGWRados::cls_obj_set_bucket_tag_timeout(RGWBucketInfo& bucket_info, uint64_t timeout)
12770 librados::IoCtx index_ctx;
12771 map<int, string> bucket_objs;
12772 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs);
12776 return CLSRGWIssueSetTagTimeout(index_ctx, bucket_objs, cct->_conf->rgw_bucket_index_max_aio, timeout)();
12779 int RGWRados::cls_bucket_list(RGWBucketInfo& bucket_info, int shard_id, rgw_obj_index_key& start, const string& prefix,
12780 uint32_t num_entries, bool list_versions, map<string, rgw_bucket_dir_entry>& m,
12781 bool *is_truncated, rgw_obj_index_key *last_entry,
12782 bool (*force_check_filter)(const string& name))
12784 ldout(cct, 10) << "cls_bucket_list " << bucket_info.bucket << " start " << start.name << "[" << start.instance << "] num_entries " << num_entries << dendl;
12786 librados::IoCtx index_ctx;
12787 // key - oid (for different shards if there is any)
12788 // value - list result for the corresponding oid (shard), it is filled by the AIO callback
12789 map<int, string> oids;
12790 map<int, struct rgw_cls_list_ret> list_results;
12791 int r = open_bucket_index(bucket_info, index_ctx, oids, shard_id);
12795 cls_rgw_obj_key start_key(start.name, start.instance);
12796 r = CLSRGWIssueBucketList(index_ctx, start_key, prefix, num_entries, list_versions,
12797 oids, list_results, cct->_conf->rgw_bucket_index_max_aio)();
12801 // Create a list of iterators that are used to iterate each shard
12802 vector<map<string, struct rgw_bucket_dir_entry>::iterator> vcurrents(list_results.size());
12803 vector<map<string, struct rgw_bucket_dir_entry>::iterator> vends(list_results.size());
12804 vector<string> vnames(list_results.size());
12805 map<int, struct rgw_cls_list_ret>::iterator iter = list_results.begin();
12806 *is_truncated = false;
12807 for (; iter != list_results.end(); ++iter) {
12808 vcurrents.push_back(iter->second.dir.m.begin());
12809 vends.push_back(iter->second.dir.m.end());
12810 vnames.push_back(oids[iter->first]);
12811 *is_truncated = (*is_truncated || iter->second.is_truncated);
12814 // Create a map to track the next candidate entry from each shard, if the entry
12815 // from a specified shard is selected/erased, the next entry from that shard will
12816 // be inserted for next round selection
12817 map<string, size_t> candidates;
12818 for (size_t i = 0; i < vcurrents.size(); ++i) {
12819 if (vcurrents[i] != vends[i]) {
12820 candidates[vcurrents[i]->first] = i;
12824 map<string, bufferlist> updates;
12825 uint32_t count = 0;
12826 while (count < num_entries && !candidates.empty()) {
12828 // Select the next one
12829 int pos = candidates.begin()->second;
12830 const string& name = vcurrents[pos]->first;
12831 struct rgw_bucket_dir_entry& dirent = vcurrents[pos]->second;
12833 bool force_check = force_check_filter &&
12834 force_check_filter(dirent.key.name);
12835 if ((!dirent.exists && !dirent.is_delete_marker()) ||
12836 !dirent.pending_map.empty() ||
12838 /* there are uncommitted ops. We need to check the current state,
12839 * and if the tags are old we need to do cleanup as well. */
12840 librados::IoCtx sub_ctx;
12841 sub_ctx.dup(index_ctx);
12842 r = check_disk_state(sub_ctx, bucket_info, dirent, dirent, updates[vnames[pos]]);
12843 if (r < 0 && r != -ENOENT) {
12848 ldout(cct, 10) << "RGWRados::cls_bucket_list: got " << dirent.key.name << "[" << dirent.key.instance << "]" << dendl;
12849 m[name] = std::move(dirent);
12853 // Refresh the candidates map
12854 candidates.erase(candidates.begin());
12856 if (vcurrents[pos] != vends[pos]) {
12857 candidates[vcurrents[pos]->first] = pos;
12861 // Suggest updates if there is any
12862 map<string, bufferlist>::iterator miter = updates.begin();
12863 for (; miter != updates.end(); ++miter) {
12864 if (miter->second.length()) {
12865 ObjectWriteOperation o;
12866 cls_rgw_suggest_changes(o, miter->second);
12867 // we don't care if we lose suggested updates, send them off blindly
12868 AioCompletion *c = librados::Rados::aio_create_completion(NULL, NULL, NULL);
12869 index_ctx.aio_operate(miter->first, c, &o);
12874 // Check if all the returned entries are consumed or not
12875 for (size_t i = 0; i < vcurrents.size(); ++i) {
12876 if (vcurrents[i] != vends[i])
12877 *is_truncated = true;
12880 *last_entry = m.rbegin()->first;
12885 int RGWRados::cls_obj_usage_log_add(const string& oid, rgw_usage_log_info& info)
12887 rgw_raw_obj obj(get_zone_params().usage_log_pool, oid);
12890 int r = get_raw_obj_ref(obj, &ref);
12895 ObjectWriteOperation op;
12896 cls_rgw_usage_log_add(op, info);
12898 r = ref.ioctx.operate(ref.oid, &op);
12902 int RGWRados::cls_obj_usage_log_read(string& oid, string& user, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
12903 string& read_iter, map<rgw_user_bucket, rgw_usage_log_entry>& usage, bool *is_truncated)
12905 rgw_raw_obj obj(get_zone_params().usage_log_pool, oid);
12908 int r = get_raw_obj_ref(obj, &ref);
12913 *is_truncated = false;
12915 r = cls_rgw_usage_log_read(ref.ioctx, ref.oid, user, start_epoch, end_epoch,
12916 max_entries, read_iter, usage, is_truncated);
12921 int RGWRados::cls_obj_usage_log_trim(string& oid, string& user, uint64_t start_epoch, uint64_t end_epoch)
12923 rgw_raw_obj obj(get_zone_params().usage_log_pool, oid);
12926 int r = get_raw_obj_ref(obj, &ref);
12931 ObjectWriteOperation op;
12932 cls_rgw_usage_log_trim(op, user, start_epoch, end_epoch);
12934 r = ref.ioctx.operate(ref.oid, &op);
12938 int RGWRados::remove_objs_from_index(RGWBucketInfo& bucket_info, list<rgw_obj_index_key>& oid_list)
12940 librados::IoCtx index_ctx;
12943 uint8_t suggest_flag = (get_zone().log_data ? CEPH_RGW_DIR_SUGGEST_LOG_OP : 0);
12945 int r = open_bucket_index(bucket_info, index_ctx, dir_oid);
12949 bufferlist updates;
12951 for (auto iter = oid_list.begin(); iter != oid_list.end(); ++iter) {
12952 rgw_bucket_dir_entry entry;
12954 dout(2) << "RGWRados::remove_objs_from_index bucket=" << bucket_info.bucket << " obj=" << entry.key.name << ":" << entry.key.instance << dendl;
12955 entry.ver.epoch = (uint64_t)-1; // ULLONG_MAX, needed to that objclass doesn't skip out request
12956 updates.append(CEPH_RGW_REMOVE | suggest_flag);
12957 ::encode(entry, updates);
12962 r = index_ctx.exec(dir_oid, RGW_CLASS, RGW_DIR_SUGGEST_CHANGES, updates, out);
12967 int RGWRados::check_disk_state(librados::IoCtx io_ctx,
12968 const RGWBucketInfo& bucket_info,
12969 rgw_bucket_dir_entry& list_state,
12970 rgw_bucket_dir_entry& object,
12971 bufferlist& suggested_updates)
12973 const rgw_bucket& bucket = bucket_info.bucket;
12974 uint8_t suggest_flag = (get_zone().log_data ? CEPH_RGW_DIR_SUGGEST_LOG_OP : 0);
12978 rgw_obj obj(bucket, list_state.key);
12981 get_obj_bucket_and_oid_loc(obj, oid, loc);
12983 if (loc != list_state.locator) {
12984 ldout(cct, 0) << "WARNING: generated locator (" << loc << ") is different from listed locator (" << list_state.locator << ")" << dendl;
12987 io_ctx.locator_set_key(list_state.locator);
12989 RGWObjState *astate = NULL;
12990 RGWObjectCtx rctx(this);
12991 int r = get_obj_state(&rctx, bucket_info, obj, &astate, false);
12995 list_state.pending_map.clear(); // we don't need this and it inflates size
12996 if (!astate->exists) {
12997 /* object doesn't exist right now -- hopefully because it's
12998 * marked as !exists and got deleted */
12999 if (list_state.exists) {
13000 /* FIXME: what should happen now? Work out if there are any
13001 * non-bad ways this could happen (there probably are, but annoying
13004 // encode a suggested removal of that key
13005 list_state.ver.epoch = io_ctx.get_last_version();
13006 list_state.ver.pool = io_ctx.get_id();
13007 cls_rgw_encode_suggestion(CEPH_RGW_REMOVE, list_state, suggested_updates);
13012 string content_type;
13015 object.meta.size = astate->size;
13016 object.meta.accounted_size = astate->accounted_size;
13017 object.meta.mtime = astate->mtime;
13019 map<string, bufferlist>::iterator iter = astate->attrset.find(RGW_ATTR_ETAG);
13020 if (iter != astate->attrset.end()) {
13021 etag = iter->second.c_str();
13023 iter = astate->attrset.find(RGW_ATTR_CONTENT_TYPE);
13024 if (iter != astate->attrset.end()) {
13025 content_type = iter->second.c_str();
13027 iter = astate->attrset.find(RGW_ATTR_ACL);
13028 if (iter != astate->attrset.end()) {
13029 r = decode_policy(iter->second, &owner);
13031 dout(0) << "WARNING: could not decode policy for object: " << obj << dendl;
13035 if (astate->has_manifest) {
13036 RGWObjManifest::obj_iterator miter;
13037 RGWObjManifest& manifest = astate->manifest;
13038 for (miter = manifest.obj_begin(); miter != manifest.obj_end(); ++miter) {
13039 const rgw_raw_obj& raw_loc = miter.get_location().get_raw_obj(this);
13041 rgw_raw_obj_to_obj(manifest.get_obj().bucket, raw_loc, &loc);
13043 if (loc.key.ns == RGW_OBJ_NS_MULTIPART) {
13044 dout(10) << "check_disk_state(): removing manifest part from index: " << loc << dendl;
13045 r = delete_obj_index(loc);
13047 dout(0) << "WARNING: delete_obj_index() returned r=" << r << dendl;
13053 object.meta.etag = etag;
13054 object.meta.content_type = content_type;
13055 object.meta.owner = owner.get_id().to_str();
13056 object.meta.owner_display_name = owner.get_display_name();
13058 // encode suggested updates
13059 list_state.ver.pool = io_ctx.get_id();
13060 list_state.ver.epoch = astate->epoch;
13061 list_state.meta.size = object.meta.size;
13062 list_state.meta.accounted_size = object.meta.accounted_size;
13063 list_state.meta.mtime = object.meta.mtime;
13064 list_state.meta.category = main_category;
13065 list_state.meta.etag = etag;
13066 list_state.meta.content_type = content_type;
13067 if (astate->obj_tag.length() > 0)
13068 list_state.tag = astate->obj_tag.c_str();
13069 list_state.meta.owner = owner.get_id().to_str();
13070 list_state.meta.owner_display_name = owner.get_display_name();
13072 list_state.exists = true;
13073 cls_rgw_encode_suggestion(CEPH_RGW_UPDATE | suggest_flag, list_state, suggested_updates);
13077 int RGWRados::cls_bucket_head(const RGWBucketInfo& bucket_info, int shard_id, map<string, struct rgw_bucket_dir_header>& headers, map<int, string> *bucket_instance_ids)
13079 librados::IoCtx index_ctx;
13080 map<int, string> oids;
13081 map<int, struct rgw_cls_list_ret> list_results;
13082 int r = open_bucket_index(bucket_info, index_ctx, oids, list_results, shard_id, bucket_instance_ids);
13086 r = CLSRGWIssueGetDirHeader(index_ctx, oids, list_results, cct->_conf->rgw_bucket_index_max_aio)();
13090 map<int, struct rgw_cls_list_ret>::iterator iter = list_results.begin();
13091 for(; iter != list_results.end(); ++iter) {
13092 headers[oids[iter->first]] = iter->second.dir.header;
13097 int RGWRados::cls_bucket_head_async(const RGWBucketInfo& bucket_info, int shard_id, RGWGetDirHeader_CB *ctx, int *num_aio)
13099 librados::IoCtx index_ctx;
13100 map<int, string> bucket_objs;
13101 int r = open_bucket_index(bucket_info, index_ctx, bucket_objs, shard_id);
13105 map<int, string>::iterator iter = bucket_objs.begin();
13106 for (; iter != bucket_objs.end(); ++iter) {
13107 r = cls_rgw_get_dir_header_async(index_ctx, iter->second, static_cast<RGWGetDirHeader_CB*>(ctx->get()));
13118 int RGWRados::cls_user_get_header(const string& user_id, cls_user_header *header)
13120 string buckets_obj_id;
13121 rgw_get_buckets_obj(user_id, buckets_obj_id);
13122 rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
13125 int r = get_raw_obj_ref(obj, &ref);
13130 librados::ObjectReadOperation op;
13132 ::cls_user_get_header(op, header, &rc);
13134 r = ref.ioctx.operate(ref.oid, &op, &ibl);
13143 int RGWRados::cls_user_get_header_async(const string& user_id, RGWGetUserHeader_CB *ctx)
13145 string buckets_obj_id;
13146 rgw_get_buckets_obj(user_id, buckets_obj_id);
13147 rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
13150 int r = get_raw_obj_ref(obj, &ref);
13155 r = ::cls_user_get_header_async(ref.ioctx, ref.oid, ctx);
13162 int RGWRados::cls_user_sync_bucket_stats(rgw_raw_obj& user_obj, const RGWBucketInfo& bucket_info)
13164 map<string, struct rgw_bucket_dir_header> headers;
13165 int r = cls_bucket_head(bucket_info, RGW_NO_SHARD, headers);
13167 ldout(cct, 20) << "cls_bucket_header() returned " << r << dendl;
13171 cls_user_bucket_entry entry;
13173 bucket_info.bucket.convert(&entry.bucket);
13175 for (const auto& hiter : headers) {
13176 for (const auto& iter : hiter.second.stats) {
13177 const struct rgw_bucket_category_stats& header_stats = iter.second;
13178 entry.size += header_stats.total_size;
13179 entry.size_rounded += header_stats.total_size_rounded;
13180 entry.count += header_stats.num_entries;
13184 list<cls_user_bucket_entry> entries;
13185 entries.push_back(entry);
13187 r = cls_user_update_buckets(user_obj, entries, false);
13189 ldout(cct, 20) << "cls_user_update_buckets() returned " << r << dendl;
13196 int RGWRados::cls_user_get_bucket_stats(const rgw_bucket& bucket, cls_user_bucket_entry& entry)
13198 map<string, struct rgw_bucket_dir_header> headers;
13199 RGWBucketInfo bucket_info;
13200 RGWObjectCtx obj_ctx(this);
13201 int ret = get_bucket_instance_info(obj_ctx, bucket, bucket_info, NULL, NULL);
13206 ret = cls_bucket_head(bucket_info, RGW_NO_SHARD, headers);
13208 ldout(cct, 20) << "cls_bucket_header() returned " << ret << dendl;
13212 bucket.convert(&entry.bucket);
13214 for (const auto& hiter : headers) {
13215 for (const auto& iter : hiter.second.stats) {
13216 const struct rgw_bucket_category_stats& header_stats = iter.second;
13217 entry.size += header_stats.total_size;
13218 entry.size_rounded += header_stats.total_size_rounded;
13219 entry.count += header_stats.num_entries;
13226 int RGWRados::cls_user_list_buckets(rgw_raw_obj& obj,
13227 const string& in_marker,
13228 const string& end_marker,
13229 const int max_entries,
13230 list<cls_user_bucket_entry>& entries,
13231 string * const out_marker,
13232 bool * const truncated)
13235 int r = get_raw_obj_ref(obj, &ref);
13240 librados::ObjectReadOperation op;
13243 cls_user_bucket_list(op, in_marker, end_marker, max_entries, entries, out_marker, truncated, &rc);
13245 r = ref.ioctx.operate(ref.oid, &op, &ibl);
13254 int RGWRados::cls_user_update_buckets(rgw_raw_obj& obj, list<cls_user_bucket_entry>& entries, bool add)
13257 int r = get_raw_obj_ref(obj, &ref);
13262 librados::ObjectWriteOperation op;
13263 cls_user_set_buckets(op, entries, add);
13264 r = ref.ioctx.operate(ref.oid, &op);
13271 int RGWRados::complete_sync_user_stats(const rgw_user& user_id)
13273 string buckets_obj_id;
13274 rgw_get_buckets_obj(user_id, buckets_obj_id);
13275 rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
13276 return cls_user_complete_stats_sync(obj);
13279 int RGWRados::cls_user_complete_stats_sync(rgw_raw_obj& obj)
13282 int r = get_raw_obj_ref(obj, &ref);
13287 librados::ObjectWriteOperation op;
13288 ::cls_user_complete_stats_sync(op);
13289 r = ref.ioctx.operate(ref.oid, &op);
13296 int RGWRados::cls_user_add_bucket(rgw_raw_obj& obj, const cls_user_bucket_entry& entry)
13298 list<cls_user_bucket_entry> l;
13299 l.push_back(entry);
13301 return cls_user_update_buckets(obj, l, true);
13304 int RGWRados::cls_user_remove_bucket(rgw_raw_obj& obj, const cls_user_bucket& bucket)
13307 int r = get_system_obj_ref(obj, &ref);
13312 librados::ObjectWriteOperation op;
13313 ::cls_user_remove_bucket(op, bucket);
13314 r = ref.ioctx.operate(ref.oid, &op);
13321 int RGWRados::check_bucket_shards(const RGWBucketInfo& bucket_info, const rgw_bucket& bucket,
13322 RGWQuotaInfo& bucket_quota)
13324 if (!cct->_conf->rgw_dynamic_resharding) {
13328 bool need_resharding = false;
13329 int num_source_shards = (bucket_info.num_shards > 0 ? bucket_info.num_shards : 1);
13330 uint32_t suggested_num_shards;
13332 int ret = quota_handler->check_bucket_shards((uint64_t)cct->_conf->rgw_max_objs_per_shard,
13333 num_source_shards, bucket_info.owner, bucket, bucket_quota,
13334 1, need_resharding, &suggested_num_shards);
13339 if (need_resharding) {
13340 ldout(cct, 20) << __func__ << " bucket " << bucket.name << " need resharding " <<
13341 " old num shards " << bucket_info.num_shards << " new num shards " << suggested_num_shards <<
13343 return add_bucket_to_reshard(bucket_info, suggested_num_shards);
13349 int RGWRados::add_bucket_to_reshard(const RGWBucketInfo& bucket_info, uint32_t new_num_shards)
13351 RGWReshard reshard(this);
13353 uint32_t num_source_shards = (bucket_info.num_shards > 0 ? bucket_info.num_shards : 1);
13355 new_num_shards = min(new_num_shards, get_max_bucket_shards());
13356 if (new_num_shards <= num_source_shards) {
13357 ldout(cct, 20) << "not resharding bucket name=" << bucket_info.bucket.name << ", orig_num=" << num_source_shards << ", new_num_shards=" << new_num_shards << dendl;
13361 cls_rgw_reshard_entry entry;
13362 entry.time = real_clock::now();
13363 entry.tenant = bucket_info.owner.tenant;
13364 entry.bucket_name = bucket_info.bucket.name;
13365 entry.bucket_id = bucket_info.bucket.bucket_id;
13366 entry.old_num_shards = num_source_shards;
13367 entry.new_num_shards = new_num_shards;
13369 return reshard.add(entry);
13372 int RGWRados::check_quota(const rgw_user& bucket_owner, rgw_bucket& bucket,
13373 RGWQuotaInfo& user_quota, RGWQuotaInfo& bucket_quota, uint64_t obj_size)
13375 return quota_handler->check_quota(bucket_owner, bucket, user_quota, bucket_quota, 1, obj_size);
13378 void RGWRados::get_bucket_index_objects(const string& bucket_oid_base,
13379 uint32_t num_shards, map<int, string>& bucket_objects, int shard_id)
13382 bucket_objects[0] = bucket_oid_base;
13384 char buf[bucket_oid_base.size() + 32];
13385 if (shard_id < 0) {
13386 for (uint32_t i = 0; i < num_shards; ++i) {
13387 snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), i);
13388 bucket_objects[i] = buf;
13391 if ((uint32_t)shard_id > num_shards) {
13394 snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), shard_id);
13395 bucket_objects[shard_id] = buf;
13400 void RGWRados::get_bucket_instance_ids(const RGWBucketInfo& bucket_info, int shard_id, map<int, string> *result)
13402 const rgw_bucket& bucket = bucket_info.bucket;
13403 string plain_id = bucket.name + ":" + bucket.bucket_id;
13404 if (!bucket_info.num_shards) {
13405 (*result)[0] = plain_id;
13408 if (shard_id < 0) {
13409 for (uint32_t i = 0; i < bucket_info.num_shards; ++i) {
13410 snprintf(buf, sizeof(buf), ":%d", i);
13411 (*result)[i] = plain_id + buf;
13414 if ((uint32_t)shard_id > bucket_info.num_shards) {
13417 snprintf(buf, sizeof(buf), ":%d", shard_id);
13418 (*result)[shard_id] = plain_id + buf;
13423 int RGWRados::get_target_shard_id(const RGWBucketInfo& bucket_info, const string& obj_key,
13427 switch (bucket_info.bucket_index_shard_hash_type) {
13428 case RGWBucketInfo::MOD:
13429 if (!bucket_info.num_shards) {
13434 uint32_t sid = ceph_str_hash_linux(obj_key.c_str(), obj_key.size());
13435 uint32_t sid2 = sid ^ ((sid & 0xFF) << 24);
13436 sid = rgw_shards_mod(sid2, bucket_info.num_shards);
13438 *shard_id = (int)sid;
13448 void RGWRados::get_bucket_index_object(const string& bucket_oid_base, uint32_t num_shards,
13449 int shard_id, string *bucket_obj)
13452 // By default with no sharding, we use the bucket oid as itself
13453 (*bucket_obj) = bucket_oid_base;
13455 char buf[bucket_oid_base.size() + 32];
13456 snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), shard_id);
13457 (*bucket_obj) = buf;
13461 int RGWRados::get_bucket_index_object(const string& bucket_oid_base, const string& obj_key,
13462 uint32_t num_shards, RGWBucketInfo::BIShardsHashType hash_type, string *bucket_obj, int *shard_id)
13465 switch (hash_type) {
13466 case RGWBucketInfo::MOD:
13468 // By default with no sharding, we use the bucket oid as itself
13469 (*bucket_obj) = bucket_oid_base;
13474 uint32_t sid = ceph_str_hash_linux(obj_key.c_str(), obj_key.size());
13475 uint32_t sid2 = sid ^ ((sid & 0xFF) << 24);
13476 sid = rgw_shards_mod(sid2, num_shards);
13477 char buf[bucket_oid_base.size() + 32];
13478 snprintf(buf, sizeof(buf), "%s.%d", bucket_oid_base.c_str(), sid);
13479 (*bucket_obj) = buf;
13481 *shard_id = (int)sid;
13491 void RGWStateLog::oid_str(int shard, string& oid) {
13492 oid = RGW_STATELOG_OBJ_PREFIX + module_name + ".";
13494 snprintf(buf, sizeof(buf), "%d", shard);
13498 int RGWStateLog::get_shard_num(const string& object) {
13499 uint32_t val = ceph_str_hash_linux(object.c_str(), object.length());
13500 return val % num_shards;
13503 string RGWStateLog::get_oid(const string& object) {
13504 int shard = get_shard_num(object);
13506 oid_str(shard, oid);
13510 int RGWStateLog::open_ioctx(librados::IoCtx& ioctx) {
13512 store->get_log_pool(pool);
13513 int r = rgw_init_ioctx(store->get_rados_handle(), pool, ioctx);
13515 lderr(store->ctx()) << "ERROR: could not open rados pool" << dendl;
13521 int RGWStateLog::store_entry(const string& client_id, const string& op_id, const string& object,
13522 uint32_t state, bufferlist *bl, uint32_t *check_state)
13524 if (client_id.empty() ||
13527 ldout(store->ctx(), 0) << "client_id / op_id / object is empty" << dendl;
13530 librados::IoCtx ioctx;
13531 int r = open_ioctx(ioctx);
13535 string oid = get_oid(object);
13537 librados::ObjectWriteOperation op;
13539 cls_statelog_check_state(op, client_id, op_id, object, *check_state);
13541 utime_t ts = ceph_clock_now();
13543 cls_statelog_add(op, client_id, op_id, object, ts, state, (bl ? *bl : nobl));
13544 r = ioctx.operate(oid, &op);
13552 int RGWStateLog::remove_entry(const string& client_id, const string& op_id, const string& object)
13554 if (client_id.empty() ||
13557 ldout(store->ctx(), 0) << "client_id / op_id / object is empty" << dendl;
13560 librados::IoCtx ioctx;
13561 int r = open_ioctx(ioctx);
13565 string oid = get_oid(object);
13567 librados::ObjectWriteOperation op;
13568 cls_statelog_remove_by_object(op, object, op_id);
13569 r = ioctx.operate(oid, &op);
13577 void RGWStateLog::init_list_entries(const string& client_id, const string& op_id, const string& object,
13580 list_state *state = new list_state;
13581 state->client_id = client_id;
13582 state->op_id = op_id;
13583 state->object = object;
13584 if (object.empty()) {
13585 state->cur_shard = 0;
13586 state->max_shard = num_shards - 1;
13588 state->cur_shard = state->max_shard = get_shard_num(object);
13590 *handle = (void *)state;
13593 int RGWStateLog::list_entries(void *handle, int max_entries,
13594 list<cls_statelog_entry>& entries,
13597 list_state *state = static_cast<list_state *>(handle);
13599 librados::IoCtx ioctx;
13600 int r = open_ioctx(ioctx);
13606 for (; state->cur_shard <= state->max_shard && max_entries > 0; ++state->cur_shard) {
13608 oid_str(state->cur_shard, oid);
13610 librados::ObjectReadOperation op;
13611 list<cls_statelog_entry> ents;
13613 cls_statelog_list(op, state->client_id, state->op_id, state->object, state->marker,
13614 max_entries, ents, &state->marker, &truncated);
13616 r = ioctx.operate(oid, &op, &ibl);
13617 if (r == -ENOENT) {
13622 ldout(store->ctx(), 0) << "cls_statelog_list returned " << r << dendl;
13627 state->marker.clear();
13630 max_entries -= ents.size();
13632 entries.splice(entries.end(), ents);
13638 *done = (state->cur_shard > state->max_shard);
13643 void RGWStateLog::finish_list_entries(void *handle)
13645 list_state *state = static_cast<list_state *>(handle);
13649 void RGWStateLog::dump_entry(const cls_statelog_entry& entry, Formatter *f)
13651 f->open_object_section("statelog_entry");
13652 f->dump_string("client_id", entry.client_id);
13653 f->dump_string("op_id", entry.op_id);
13654 f->dump_string("object", entry.object);
13655 entry.timestamp.gmtime_nsec(f->dump_stream("timestamp"));
13656 if (!dump_entry_internal(entry, f)) {
13657 f->dump_int("state", entry.state);
13659 f->close_section();
13662 RGWOpState::RGWOpState(RGWRados *_store) : RGWStateLog(_store, _store->ctx()->_conf->rgw_num_zone_opstate_shards, string("obj_opstate"))
13666 bool RGWOpState::dump_entry_internal(const cls_statelog_entry& entry, Formatter *f)
13669 switch ((OpState)entry.state) {
13670 case OPSTATE_UNKNOWN:
13673 case OPSTATE_IN_PROGRESS:
13676 case OPSTATE_COMPLETE:
13679 case OPSTATE_ERROR:
13682 case OPSTATE_ABORT:
13685 case OPSTATE_CANCELLED:
13691 f->dump_string("state", s);
13695 int RGWOpState::state_from_str(const string& s, OpState *state)
13697 if (s == "unknown") {
13698 *state = OPSTATE_UNKNOWN;
13699 } else if (s == "in-progress") {
13700 *state = OPSTATE_IN_PROGRESS;
13701 } else if (s == "complete") {
13702 *state = OPSTATE_COMPLETE;
13703 } else if (s == "error") {
13704 *state = OPSTATE_ERROR;
13705 } else if (s == "abort") {
13706 *state = OPSTATE_ABORT;
13707 } else if (s == "cancelled") {
13708 *state = OPSTATE_CANCELLED;
13716 int RGWOpState::set_state(const string& client_id, const string& op_id, const string& object, OpState state)
13718 uint32_t s = (uint32_t)state;
13719 return store_entry(client_id, op_id, object, s, NULL, NULL);
13722 int RGWOpState::renew_state(const string& client_id, const string& op_id, const string& object, OpState state)
13724 uint32_t s = (uint32_t)state;
13725 return store_entry(client_id, op_id, object, s, NULL, &s);
13728 RGWOpStateSingleOp::RGWOpStateSingleOp(RGWRados *store, const string& cid, const string& oid,
13729 const string& obj) : os(store), client_id(cid), op_id(oid), object(obj)
13731 cct = store->ctx();
13732 cur_state = RGWOpState::OPSTATE_UNKNOWN;
13735 int RGWOpStateSingleOp::set_state(RGWOpState::OpState state) {
13736 last_update = real_clock::now();
13738 return os.set_state(client_id, op_id, object, state);
13741 int RGWOpStateSingleOp::renew_state() {
13742 real_time now = real_clock::now();
13744 int rate_limit_sec = cct->_conf->rgw_opstate_ratelimit_sec;
13746 if (rate_limit_sec && now - last_update < make_timespan(rate_limit_sec)) {
13751 return os.renew_state(client_id, op_id, object, cur_state);
13755 uint64_t RGWRados::instance_id()
13757 return get_rados_handle()->get_instance_id();
13760 uint64_t RGWRados::next_bucket_id()
13762 Mutex::Locker l(bucket_id_lock);
13763 return ++max_bucket_id;
13766 RGWRados *RGWStoreManager::init_storage_provider(CephContext *cct, bool use_gc_thread, bool use_lc_thread, bool quota_threads, bool run_sync_thread, bool run_reshard_thread)
13768 int use_cache = cct->_conf->rgw_cache_enabled;
13769 RGWRados *store = NULL;
13771 store = new RGWRados;
13773 store = new RGWCache<RGWRados>;
13776 if (store->initialize(cct, use_gc_thread, use_lc_thread, quota_threads, run_sync_thread, run_reshard_thread) < 0) {
13784 RGWRados *RGWStoreManager::init_raw_storage_provider(CephContext *cct)
13786 RGWRados *store = NULL;
13787 store = new RGWRados;
13789 store->set_context(cct);
13791 if (store->init_rados() < 0) {
13799 void RGWStoreManager::close_storage(RGWRados *store)
13809 librados::Rados* RGWRados::get_rados_handle()
13811 if (rados.size() == 1) {
13814 handle_lock.get_read();
13815 pthread_t id = pthread_self();
13816 std::map<pthread_t, int>:: iterator it = rados_map.find(id);
13818 if (it != rados_map.end()) {
13819 handle_lock.put_read();
13820 return &rados[it->second];
13822 handle_lock.put_read();
13823 handle_lock.get_write();
13824 const uint32_t handle = next_rados_handle;
13825 rados_map[id] = handle;
13826 if (++next_rados_handle == rados.size()) {
13827 next_rados_handle = 0;
13829 handle_lock.put_write();
13830 return &rados[handle];
13835 int RGWRados::delete_raw_obj_aio(const rgw_raw_obj& obj, list<librados::AioCompletion *>& handles)
13838 int ret = get_raw_obj_ref(obj, &ref);
13840 lderr(cct) << "ERROR: failed to get obj ref with ret=" << ret << dendl;
13844 ObjectWriteOperation op;
13845 list<string> prefixes;
13846 cls_rgw_remove_obj(op, prefixes);
13848 AioCompletion *c = librados::Rados::aio_create_completion(NULL, NULL, NULL);
13849 ret = ref.ioctx.aio_operate(ref.oid, c, &op);
13851 lderr(cct) << "ERROR: AioOperate failed with ret=" << ret << dendl;
13856 handles.push_back(c);
13861 int RGWRados::delete_obj_aio(const rgw_obj& obj,
13862 RGWBucketInfo& bucket_info, RGWObjState *astate,
13863 list<librados::AioCompletion *>& handles, bool keep_index_consistent)
13866 int ret = get_obj_head_ref(bucket_info, obj, &ref);
13868 lderr(cct) << "ERROR: failed to get obj ref with ret=" << ret << dendl;
13872 if (keep_index_consistent) {
13873 RGWRados::Bucket bop(this, bucket_info);
13874 RGWRados::Bucket::UpdateIndex index_op(&bop, obj);
13876 ret = index_op.prepare(CLS_RGW_OP_DEL, &astate->write_tag);
13878 lderr(cct) << "ERROR: failed to prepare index op with ret=" << ret << dendl;
13883 ObjectWriteOperation op;
13884 list<string> prefixes;
13885 cls_rgw_remove_obj(op, prefixes);
13887 AioCompletion *c = librados::Rados::aio_create_completion(NULL, NULL, NULL);
13888 ret = ref.ioctx.aio_operate(ref.oid, c, &op);
13890 lderr(cct) << "ERROR: AioOperate failed with ret=" << ret << dendl;
13895 handles.push_back(c);
13897 if (keep_index_consistent) {
13898 ret = delete_obj_index(obj);
13900 lderr(cct) << "ERROR: failed to delete obj index with ret=" << ret << dendl;
13907 int rgw_compression_info_from_attrset(map<string, bufferlist>& attrs, bool& need_decompress, RGWCompressionInfo& cs_info) {
13908 map<string, bufferlist>::iterator value = attrs.find(RGW_ATTR_COMPRESSION);
13909 if (value != attrs.end()) {
13910 bufferlist::iterator bliter = value->second.begin();
13912 ::decode(cs_info, bliter);
13913 } catch (buffer::error& err) {
13916 if (cs_info.blocks.size() == 0) {
13919 if (cs_info.compression_type != "none")
13920 need_decompress = true;
13922 need_decompress = false;
13925 need_decompress = false;