#include "common/Clock.h"
#include "mon/PGMap.h"
+using std::list;
+using std::make_pair;
+using std::map;
+using std::multimap;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::unordered_map;
+using std::vector;
+
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+
#define dout_subsys ceph_subsys_osd
MEMPOOL_DEFINE_OBJECT_FACTORY(OSDMap, osdmap, osdmap);
f->dump_int("lost_at", lost_at);
}
-void osd_info_t::encode(bufferlist& bl) const
+void osd_info_t::encode(ceph::buffer::list& bl) const
{
using ceph::encode;
__u8 struct_v = 1;
encode(lost_at, bl);
}
-void osd_info_t::decode(bufferlist::const_iterator& bl)
+void osd_info_t::decode(ceph::buffer::list::const_iterator& bl)
{
using ceph::decode;
__u8 struct_v;
f->dump_unsigned("old_weight", old_weight);
}
-void osd_xinfo_t::encode(bufferlist& bl) const
+void osd_xinfo_t::encode(ceph::buffer::list& bl) const
{
ENCODE_START(3, 1, bl);
encode(down_stamp, bl);
ENCODE_FINISH(bl);
}
-void osd_xinfo_t::decode(bufferlist::const_iterator& bl)
+void osd_xinfo_t::decode(ceph::buffer::list::const_iterator& bl)
{
DECODE_START(3, bl);
decode(down_stamp, bl);
return true;
}
-void OSDMap::Incremental::encode_client_old(bufferlist& bl) const
+void OSDMap::Incremental::encode_client_old(ceph::buffer::list& bl) const
{
using ceph::encode;
__u16 v = 5;
}
}
-void OSDMap::Incremental::encode_classic(bufferlist& bl, uint64_t features) const
+void OSDMap::Incremental::encode_classic(ceph::buffer::list& bl, uint64_t features) const
{
using ceph::encode;
if ((features & CEPH_FEATURE_PGID64) == 0) {
}
template<class T>
-static void encode_addrvec_map_as_addr(const T& m, bufferlist& bl, uint64_t f)
+static void encode_addrvec_map_as_addr(const T& m, ceph::buffer::list& bl, uint64_t f)
{
uint32_t n = m.size();
encode(n, bl);
}
template<class T>
-static void encode_addrvec_pvec_as_addr(const T& m, bufferlist& bl, uint64_t f)
+static void encode_addrvec_pvec_as_addr(const T& m, ceph::buffer::list& bl, uint64_t f)
{
uint32_t n = m.size();
encode(n, bl);
* introduced, please refer to
* doc/dev/osd_internals/osdmap_versions.txt
*/
-void OSDMap::Incremental::encode(bufferlist& bl, uint64_t features) const
+void OSDMap::Incremental::encode(ceph::buffer::list& bl, uint64_t features) const
{
using ceph::encode;
if ((features & CEPH_FEATURE_OSDMAP_ENC) == 0) {
size_t start_offset = bl.length();
size_t tail_offset;
size_t crc_offset;
- std::optional<buffer::list::contiguous_filler> crc_filler;
+ std::optional<ceph::buffer::list::contiguous_filler> crc_filler;
// meta-encoding: how we include client-used and osd-specific data
ENCODE_START(8, 7, bl);
ENCODE_FINISH(bl); // meta-encoding wrapper
// fill in crc
- bufferlist front;
+ ceph::buffer::list front;
front.substr_of(bl, start_offset, crc_offset - start_offset);
inc_crc = front.crc32c(-1);
- bufferlist tail;
+ ceph::buffer::list tail;
tail.substr_of(bl, tail_offset, bl.length() - tail_offset);
inc_crc = tail.crc32c(inc_crc);
ceph_le32 crc_le;
have_crc = true;
}
-void OSDMap::Incremental::decode_classic(bufferlist::const_iterator &p)
+void OSDMap::Incremental::decode_classic(ceph::buffer::list::const_iterator &p)
{
using ceph::decode;
__u32 n, t;
decode(n, p);
while (n--) {
old_pg_t opg;
- ::decode_raw(opg, p);
+ ceph::decode_raw(opg, p);
decode(new_pg_temp[pg_t(opg)], p);
}
} else {
* introduced, please refer to
* doc/dev/osd_internals/osdmap_versions.txt
*/
-void OSDMap::Incremental::decode(bufferlist::const_iterator& bl)
+void OSDMap::Incremental::decode(ceph::buffer::list::const_iterator& bl)
{
using ceph::decode;
/**
*/
size_t start_offset = bl.get_off();
size_t tail_offset = 0;
- bufferlist crc_front, crc_tail;
+ ceph::buffer::list crc_front, crc_tail;
DECODE_START_LEGACY_COMPAT_LEN(8, 7, 7, bl); // wrapper
if (struct_v < 7) {
// verify crc
uint32_t actual = crc_front.crc32c(-1);
if (tail_offset < bl.get_off()) {
- bufferlist tail;
+ ceph::buffer::list tail;
tail.substr_of(bl.get_bl(), tail_offset, bl.get_off() - tail_offset);
actual = tail.crc32c(actual);
}
ostringstream ss;
ss << "bad crc, actual " << actual << " != expected " << inc_crc;
string s = ss.str();
- throw buffer::malformed_input(s.c_str());
+ throw ceph::buffer::malformed_input(s.c_str());
}
}
}
if (fullmap.length()) {
f->open_object_section("full_map");
OSDMap full;
- bufferlist fbl = fullmap; // kludge around constness.
+ ceph::buffer::list fbl = fullmap; // kludge around constness.
auto p = fbl.cbegin();
full.decode(p);
full.dump(f);
if (crush.length()) {
f->open_object_section("crush");
CrushWrapper c;
- bufferlist tbl = crush; // kludge around constness.
+ ceph::buffer::list tbl = crush; // kludge around constness.
auto p = tbl.cbegin();
c.decode(p);
c.dump(f);
}
// does crush match?
- bufferlist oc, nc;
+ ceph::buffer::list oc, nc;
encode(*o->crush, oc, CEPH_FEATURES_SUPPORTED_DEFAULT);
encode(*n->crush, nc, CEPH_FEATURES_SUPPORTED_DEFAULT);
if (oc.contents_equal(nc)) {
// full map?
if (inc.fullmap.length()) {
- bufferlist bl(inc.fullmap);
+ ceph::buffer::list bl(inc.fullmap);
decode(bl);
return 0;
}
}
// do new crush map last (after up/down stuff)
if (inc.crush.length()) {
- bufferlist bl(inc.crush);
+ ceph::buffer::list bl(inc.crush);
auto blp = bl.cbegin();
crush.reset(new CrushWrapper);
crush->decode(blp);
}
// serialize, unserialize
-void OSDMap::encode_client_old(bufferlist& bl) const
+void OSDMap::encode_client_old(ceph::buffer::list& bl) const
{
using ceph::encode;
__u16 v = 5;
}
// crush
- bufferlist cbl;
+ ceph::buffer::list cbl;
crush->encode(cbl, 0 /* legacy (no) features */);
encode(cbl, bl);
}
-void OSDMap::encode_classic(bufferlist& bl, uint64_t features) const
+void OSDMap::encode_classic(ceph::buffer::list& bl, uint64_t features) const
{
using ceph::encode;
if ((features & CEPH_FEATURE_PGID64) == 0) {
encode(*pg_temp, bl);
// crush
- bufferlist cbl;
+ ceph::buffer::list cbl;
crush->encode(cbl, 0 /* legacy (no) features */);
encode(cbl, bl);
* refer to
* doc/dev/osd_internals/osdmap_versions.txt
*/
-void OSDMap::encode(bufferlist& bl, uint64_t features) const
+void OSDMap::encode(ceph::buffer::list& bl, uint64_t features) const
{
using ceph::encode;
if ((features & CEPH_FEATURE_OSDMAP_ENC) == 0) {
size_t start_offset = bl.length();
size_t tail_offset;
size_t crc_offset;
- std::optional<buffer::list::contiguous_filler> crc_filler;
+ std::optional<ceph::buffer::list::contiguous_filler> crc_filler;
// meta-encoding: how we include client-used and osd-specific data
ENCODE_START(8, 7, bl);
}
// crush
- bufferlist cbl;
+ ceph::buffer::list cbl;
crush->encode(cbl, features);
encode(cbl, bl);
encode(erasure_code_profiles, bl);
ENCODE_FINISH(bl); // meta-encoding wrapper
// fill in crc
- bufferlist front;
+ ceph::buffer::list front;
front.substr_of(bl, start_offset, crc_offset - start_offset);
crc = front.crc32c(-1);
if (tail_offset < bl.length()) {
- bufferlist tail;
+ ceph::buffer::list tail;
tail.substr_of(bl, tail_offset, bl.length() - tail_offset);
crc = tail.crc32c(crc);
}
* refer to
* doc/dev/osd_internals/osdmap_versions.txt
*/
-void OSDMap::decode(bufferlist& bl)
+void OSDMap::decode(ceph::buffer::list& bl)
{
auto p = bl.cbegin();
decode(p);
}
-void OSDMap::decode_classic(bufferlist::const_iterator& p)
+void OSDMap::decode_classic(ceph::buffer::list::const_iterator& p)
{
using ceph::decode;
__u32 n, t;
decode(n, p);
while (n--) {
old_pg_t opg;
- ::decode_raw(opg, p);
+ ceph::decode_raw(opg, p);
mempool::osdmap::vector<int32_t> v;
decode(v, p);
pg_temp->set(pg_t(opg), v);
}
// crush
- bufferlist cbl;
+ ceph::buffer::list cbl;
decode(cbl, p);
auto cblp = cbl.cbegin();
crush->decode(cblp);
post_decode();
}
-void OSDMap::decode(bufferlist::const_iterator& bl)
+void OSDMap::decode(ceph::buffer::list::const_iterator& bl)
{
using ceph::decode;
/**
*/
size_t start_offset = bl.get_off();
size_t tail_offset = 0;
- bufferlist crc_front, crc_tail;
+ ceph::buffer::list crc_front, crc_tail;
DECODE_START_LEGACY_COMPAT_LEN(8, 7, 7, bl); // wrapper
if (struct_v < 7) {
}
// crush
- bufferlist cbl;
+ ceph::buffer::list cbl;
decode(cbl, bl);
auto cblp = cbl.cbegin();
crush->decode(cblp);
// verify crc
uint32_t actual = crc_front.crc32c(-1);
if (tail_offset < bl.get_off()) {
- bufferlist tail;
+ ceph::buffer::list tail;
tail.substr_of(bl.get_bl(), tail_offset, bl.get_off() - tail_offset);
actual = tail.crc32c(actual);
}
ostringstream ss;
ss << "bad crc, actual " << actual << " != expected " << crc;
string s = ss.str();
- throw buffer::malformed_input(s.c_str());
+ throw ceph::buffer::malformed_input(s.c_str());
}
}
// CACHE_POOL_NO_HIT_SET
if (g_conf()->mon_warn_on_cache_pools_without_hit_sets) {
list<string> detail;
- for (map<int64_t, pg_pool_t>::const_iterator p = pools.begin();
- p != pools.end();
- ++p) {
+ for (auto p = pools.cbegin(); p != pools.cend(); ++p) {
const pg_pool_t& info = p->second;
if (info.cache_mode_requires_hit_set() &&
info.hit_set_params.get_type() == HitSet::TYPE_NONE) {
osd_info_t() : last_clean_begin(0), last_clean_end(0),
up_from(0), up_thru(0), down_at(0), lost_at(0) {}
- void dump(Formatter *f) const;
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- static void generate_test_instances(list<osd_info_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ static void generate_test_instances(std::list<osd_info_t*>& o);
};
WRITE_CLASS_ENCODER(osd_info_t)
-ostream& operator<<(ostream& out, const osd_info_t& info);
+std::ostream& operator<<(std::ostream& out, const osd_info_t& info);
struct osd_xinfo_t {
utime_t down_stamp; ///< timestamp when we were last marked down
osd_xinfo_t() : laggy_probability(0), laggy_interval(0),
features(0), old_weight(0) {}
- void dump(Formatter *f) const;
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- static void generate_test_instances(list<osd_xinfo_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ static void generate_test_instances(std::list<osd_xinfo_t*>& o);
};
WRITE_CLASS_ENCODER(osd_xinfo_t)
-ostream& operator<<(ostream& out, const osd_xinfo_t& xi);
+std::ostream& operator<<(std::ostream& out, const osd_xinfo_t& xi);
struct PGTempMap {
#if 1
- bufferlist data;
+ ceph::buffer::list data;
typedef btree::btree_map<pg_t,int32_t*> map_t;
map_t map;
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
uint32_t n = map.size();
encode(n, bl);
bl.append((char*)p.second, (*p.second + 1) * sizeof(int32_t));
}
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
using ceph::decode;
data.clear();
map.clear();
return;
auto pstart = p;
size_t start_off = pstart.get_off();
-
vector<pair<pg_t,size_t>> offsets;
+
std::vector<std::pair<pg_t,size_t>> offsets;
offsets.resize(n);
for (unsigned i=0; i<n; ++i) {
pg_t pgid;
//map.reserve(n);
char *start = data.c_str();
for (auto i : offsets) {
- map.insert(map.end(), make_pair(i.first, (int32_t*)(start + i.second)));
+ map.insert(map.end(), std::make_pair(i.first, (int32_t*)(start + i.second)));
}
}
void rebuild() {
- bufferlist bl;
+ ceph::buffer::list bl;
encode(bl);
auto p = std::cbegin(bl);
decode(p);
class iterator {
map_t::const_iterator it;
map_t::const_iterator end;
- pair<pg_t,vector<int32_t>> current;
+ std::pair<pg_t,std::vector<int32_t>> current;
void init_current() {
if (it != end) {
current.first = it->first;
init_current();
}
- const pair<pg_t,vector<int32_t>>& operator*() const {
+ const std::pair<pg_t,std::vector<int32_t>>& operator*() const {
return current;
}
- const pair<pg_t,vector<int32_t>>* operator->() const {
+ const std::pair<pg_t,std::vector<int32_t>>* operator->() const {
return ¤t;
}
friend bool operator==(const iterator& l, const iterator& r) {
using ceph::encode;
size_t need = sizeof(int32_t) * (1 + v.size());
if (need < data.get_append_buffer_unused_tail_length()) {
- bufferptr z(data.get_append_buffer_unused_tail_length());
+ ceph::buffer::ptr z(data.get_append_buffer_unused_tail_length());
z.zero();
data.append(z.c_str(), z.length());
}
// trivial implementation
mempool::osdmap::map<pg_t,mempool::osdmap::vector<int32_t> > pg_temp;
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
encode(pg_temp, bl);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
decode(pg_temp, p);
}
friend bool operator==(const PGTempMap& l, const PGTempMap& r) {
mempool::osdmap::vector<int32_t> >::const_iterator p)
: it(p) {}
- pair<pg_t,const mempool::osdmap::vector<int32_t>&> operator*() const {
+
std::pair<pg_t,const mempool::osdmap::vector<int32_t>&> operator*() const {
return *it;
}
- const pair<const pg_t,mempool::osdmap::vector<int32_t>>* operator->() const {
+ const std::pair<const pg_t,mempool::osdmap::vector<int32_t>>* operator->() const {
return &*it;
}
friend bool operator==(const iterator& l, const iterator& r) {
return pg_temp.at(pgid);
}
#endif
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
for (const auto &pg : *this) {
f->open_object_section("osds");
f->dump_stream("pgid") << pg.first;
int8_t new_require_osd_release = -1;
// full (rare)
- bufferlist fullmap; // in lieu of below.
- bufferlist crush;
+ ceph::buffer::list fullmap; // in lieu of below.
+ ceph::buffer::list crush;
// incremental
int32_t new_max_osd;
mempool::osdmap::map<int64_t,pg_pool_t> new_pools;
- mempool::osdmap::map<int64_t,string> new_pool_names;
+ mempool::osdmap::map<int64_t,std::string> new_pool_names;
mempool::osdmap::set<int64_t> old_pools;
- mempool::osdmap::map<string,map<string,string> > new_erasure_code_profiles;
- mempool::osdmap::vector<string> old_erasure_code_profiles;
+ mempool::osdmap::map<std::string,std::map<std::string,std::string> > new_erasure_code_profiles;
+ mempool::osdmap::vector<std::string> old_erasure_code_profiles;
mempool::osdmap::map<int32_t,entity_addrvec_t> new_up_client;
mempool::osdmap::map<int32_t,entity_addrvec_t> new_up_cluster;
mempool::osdmap::map<int32_t,uint32_t> new_state; // XORed onto previous state.
mempool::osdmap::map<pg_t, int32_t> new_primary_temp; // [-1] to remove
mempool::osdmap::map<int32_t,uint32_t> new_primary_affinity;
mempool::osdmap::map<int32_t,epoch_t> new_up_thru;
- mempool::osdmap::map<int32_t,pair<epoch_t,epoch_t> > new_last_clean_interval;
+ mempool::osdmap::map<int32_t,std::pair<epoch_t,epoch_t> > new_last_clean_interval;
mempool::osdmap::map<int32_t,epoch_t> new_lost;
mempool::osdmap::map<int32_t,uuid_d> new_uuid;
mempool::osdmap::map<int32_t,osd_xinfo_t> new_xinfo;
mempool::osdmap::map<int32_t, entity_addrvec_t> new_hb_front_up;
mempool::osdmap::map<pg_t,mempool::osdmap::vector<int32_t>> new_pg_upmap;
- mempool::osdmap::map<pg_t,mempool::osdmap::vector<pair<int32_t,int32_t>>> new_pg_upmap_items;
+ mempool::osdmap::map<pg_t,mempool::osdmap::vector<std::pair<int32_t,int32_t>>> new_pg_upmap_items;
mempool::osdmap::set<pg_t> old_pg_upmap, old_pg_upmap_items;
mempool::osdmap::map<int64_t, snap_interval_set_t> new_removed_snaps;
mempool::osdmap::map<int64_t, snap_interval_set_t> new_purged_snaps;
- string cluster_snapshot;
+ std::string cluster_snapshot;
float new_nearfull_ratio = -1;
float new_backfillfull_ratio = -1;
int get_net_marked_down(const OSDMap *previous) const;
int identify_osd(uuid_d u) const;
- void encode_client_old(bufferlist& bl) const;
- void encode_classic(bufferlist& bl, uint64_t features) const;
- void encode(bufferlist& bl, uint64_t features=CEPH_FEATURES_ALL) const;
- void decode_classic(bufferlist::const_iterator &p);
- void decode(bufferlist::const_iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<Incremental*>& o);
+ void encode_client_old(ceph::buffer::list& bl) const;
+ void encode_classic(ceph::buffer::list& bl, uint64_t features) const;
+ void encode(ceph::buffer::list& bl, uint64_t features=CEPH_FEATURES_ALL) const;
+ void decode_classic(ceph::buffer::list::const_iterator &p);
+ void decode(ceph::buffer::list::const_iterator &bl);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<Incremental*>& o);
explicit Incremental(epoch_t e=0) :
encode_features(0),
epoch(e), new_pool_max(-1), new_flags(-1), new_max_osd(-1),
have_crc(false), full_crc(0), inc_crc(0) {
}
- explicit Incremental(bufferlist &bl) {
+ explicit Incremental(ceph::buffer::list &bl) {
auto p = std::cbegin(bl);
decode(p);
}
- explicit Incremental(bufferlist::const_iterator &p) {
+ explicit Incremental(ceph::buffer::list::const_iterator &p) {
decode(p);
}
new_pools[pool] = *orig;
return &new_pools[pool];
}
- bool has_erasure_code_profile(const string &name) const {
+ bool has_erasure_code_profile(const std::string &name) const {
auto i = new_erasure_code_profiles.find(name);
return i != new_erasure_code_profiles.end();
}
- void set_erasure_code_profile(const string &name,
- const map<string,string>& profile) {
+ void set_erasure_code_profile(const std::string &name,
+ const std::map<std::string,std::string>& profile) {
new_erasure_code_profiles[name] = profile;
}
- mempool::osdmap::map<string,map<string,string>> get_erasure_code_profiles() const {
+ mempool::osdmap::map<std::string,std::map<std::string,std::string>> get_erasure_code_profiles() const {
return new_erasure_code_profiles;
}
int propagate_snaps_to_tiers(CephContext *cct, const OSDMap &base);
/// filter out osds with any pending state changing
- size_t get_pending_state_osds(vector<int> *osds) {
+ size_t get_pending_state_osds(std::vector<int> *osds) {
ceph_assert(osds);
osds->clear();
int num_in_osd; // not saved; see calc_num_osds
int32_t max_osd;
- vector<uint32_t> osd_state;
+ std::vector<uint32_t> osd_state;
utime_t last_up_change, last_in_change;
// remap (post-CRUSH, pre-up)
mempool::osdmap::map<pg_t,mempool::osdmap::vector<int32_t>> pg_upmap; ///< remap pg
- mempool::osdmap::map<pg_t,mempool::osdmap::vector<pair<int32_t,int32_t>>> pg_upmap_items; ///< remap osds in up set
+ mempool::osdmap::map<pg_t,mempool::osdmap::vector<std::pair<int32_t,int32_t>>> pg_upmap_items; ///< remap osds in up set
mempool::osdmap::map<int64_t,pg_pool_t> pools;
- mempool::osdmap::map<int64_t,string> pool_name;
- mempool::osdmap::map<string,map<string,string> > erasure_code_profiles;
- mempool::osdmap::map<string,int64_t> name_pool;
+ mempool::osdmap::map<int64_t,std::string> pool_name;
+ mempool::osdmap::map<std::string, std::map<std::string,std::string>> erasure_code_profiles;
+ mempool::osdmap::map<std::string,int64_t> name_pool;
std::shared_ptr< mempool::osdmap::vector<uuid_d> > osd_uuid;
mempool::osdmap::vector<osd_xinfo_t> osd_xinfo;
mempool::osdmap::map<int64_t, snap_interval_set_t> new_purged_snaps;
epoch_t cluster_snapshot_epoch;
- string cluster_snapshot;
+ std::string cluster_snapshot;
bool new_blacklist_entries;
float full_ratio = 0, backfillfull_ratio = 0, nearfull_ratio = 0;
bool is_blacklisted(const entity_addr_t& a) const;
bool is_blacklisted(const entity_addrvec_t& a) const;
- void get_blacklist(list<pair<entity_addr_t,utime_t > > *bl) const;
+ void get_blacklist(std::list<std::pair<entity_addr_t,utime_t > > *bl) const;
void get_blacklist(std::set<entity_addr_t> *bl) const;
- string get_cluster_snapshot() const {
+ std::string get_cluster_snapshot() const {
if (cluster_snapshot_epoch == epoch)
return cluster_snapshot;
- return string();
+ return std::string();
}
float get_full_ratio() const {
return nearfull_ratio;
}
void get_full_pools(CephContext *cct,
- set<int64_t> *full,
- set<int64_t> *backfillfull,
- set<int64_t> *nearfull) const;
- void get_full_osd_counts(set<int> *full, set<int> *backfill,
- set<int> *nearfull) const;
+ std::set<int64_t> *full,
+ std::set<int64_t> *backfillfull,
+ std::set<int64_t> *nearfull) const;
+ void get_full_osd_counts(std::set<int> *full, std::set<int> *backfill,
+ std::set<int> *nearfull) const;
/***** cluster state *****/
/// recalculate cached values for get_num{,_up,_in}_osds
int calc_num_osds();
- void get_all_osds(set<int32_t>& ls) const;
- void get_up_osds(set<int32_t>& ls) const;
- void get_out_osds(set<int32_t>& ls) const;
+ void get_all_osds(std::set<int32_t>& ls) const;
+ void get_up_osds(std::set<int32_t>& ls) const;
+ void get_out_osds(std::set<int32_t>& ls) const;
unsigned get_num_pg_temp() const {
return pg_temp->size();
}
void set_flag(int f) { flags |= f; }
void clear_flag(int f) { flags &= ~f; }
- void get_flag_set(set<string> *flagset) const;
+ void get_flag_set(std::set<std::string> *flagset) const;
- static void calc_state_set(int state, set<string>& st);
+ static void calc_state_set(int state, std::set<std::string>& st);
int get_state(int o) const {
ceph_assert(o < max_osd);
return osd_state[o];
}
- int get_state(int o, set<string>& st) const {
+ int get_state(int o, std::set<std::string>& st) const {
ceph_assert(o < max_osd);
unsigned t = osd_state[o];
calc_state_set(t, st);
float get_weightf(int o) const {
return (float)get_weight(o) / (float)CEPH_OSD_IN;
}
- void adjust_osd_weights(const map<int,double>& weights, Incremental& inc) const;
+ void adjust_osd_weights(const std::map<int,double>& weights, Incremental& inc) const;
void set_primary_affinity(int o, int w) {
ceph_assert(o < max_osd);
return (float)get_primary_affinity(o) / (float)CEPH_OSD_MAX_PRIMARY_AFFINITY;
}
- bool has_erasure_code_profile(const string &name) const {
+ bool has_erasure_code_profile(const std::string &name) const {
auto i = erasure_code_profiles.find(name);
return i != erasure_code_profiles.end();
}
int get_erasure_code_profile_default(CephContext *cct,
- map<string,string> &profile_map,
- ostream *ss);
- void set_erasure_code_profile(const string &name,
- const map<string,string>& profile) {
+ std::map<std::string,std::string> &profile_map,
+ std::ostream *ss);
+ void set_erasure_code_profile(const std::string &name,
+ const std::map<std::string,std::string>& profile) {
erasure_code_profiles[name] = profile;
}
- const map<string,string> &get_erasure_code_profile(
- const string &name) const {
- static map<string,string> empty;
+ const std::map<std::string,std::string> &get_erasure_code_profile(
+ const std::string &name) const {
+ static std::map<std::string,std::string> empty;
auto i = erasure_code_profiles.find(name);
if (i == erasure_code_profiles.end())
return empty;
else
return i->second;
}
- const mempool::osdmap::map<string,map<string,string> > &get_erasure_code_profiles() const {
+ const mempool::osdmap::map<std::string,std::map<std::string,std::string>> &get_erasure_code_profiles() const {
return erasure_code_profiles;
}
return exists(osd) && (osd_state[osd] & CEPH_OSD_NOOUT);
}
- void get_noup_osds(vector<int> *osds) const {
+ void get_noup_osds(std::vector<int> *osds) const {
ceph_assert(osds);
osds->clear();
}
}
- void get_nodown_osds(vector<int> *osds) const {
+ void get_nodown_osds(std::vector<int> *osds) const {
ceph_assert(osds);
osds->clear();
}
}
- void get_noin_osds(vector<int> *osds) const {
+ void get_noin_osds(std::vector<int> *osds) const {
ceph_assert(osds);
osds->clear();
}
}
- void get_noout_osds(vector<int> *osds) const {
+ void get_noout_osds(std::vector<int> *osds) const {
ceph_assert(osds);
osds->clear();
/**
* check if an entire crush subtree is down
*/
- bool subtree_is_down(int id, set<int> *down_cache) const;
- bool containing_subtree_is_down(CephContext *cct, int osd, int subtree_type, set<int> *down_cache) const;
-
- bool subtree_type_is_down(CephContext *cct, int id, int subtree_type, set<int> *down_in_osds, set<int> *up_in_osds,
- set<int> *subtree_up, unordered_map<int, set<int> > *subtree_type_down) const;
+ bool subtree_is_down(int id, std::set<int> *down_cache) const;
+ bool containing_subtree_is_down(CephContext *cct, int osd, int subtree_type, std::set<int> *down_cache) const;
+
+ bool subtree_type_is_down(CephContext *cct, int id, int subtree_type, std::set<int> *down_in_osds, std::set<int> *up_in_osds,
+ std::set<int> *subtree_up, std::unordered_map<int, std::set<int> > *subtree_type_down) const;
int identify_osd(const entity_addr_t& addr) const;
int identify_osd(const uuid_d& u) const;
void get_random_up_osds_by_subtree(int n, // whoami
- string &subtree,
+ std::string &subtree,
int limit, // how many
- set<int> skip,
- set<int> *want) const;
+ std::set<int> skip,
+ std::set<int> *want) const;
/**
* get feature bits required by the current structure
*
* @param entity_type [in] what entity type we are asking about
- * @param mask [out] set of all possible map-related features we could set
+ * @param mask [out] std::set of all possible map-related features we could std::set
* @return feature bits used by this map
*/
uint64_t get_features(int entity_type, uint64_t *mask) const;
// serialize, unserialize
private:
- void encode_client_old(bufferlist& bl) const;
- void encode_classic(bufferlist& bl, uint64_t features) const;
- void decode_classic(bufferlist::const_iterator& p);
+ void encode_client_old(ceph::buffer::list& bl) const;
+ void encode_classic(ceph::buffer::list& bl, uint64_t features) const;
+ void decode_classic(ceph::buffer::list::const_iterator& p);
void post_decode();
public:
- void encode(bufferlist& bl, uint64_t features=CEPH_FEATURES_ALL) const;
- void decode(bufferlist& bl);
- void decode(bufferlist::const_iterator& bl);
+ void encode(ceph::buffer::list& bl, uint64_t features=CEPH_FEATURES_ALL) const;
+ void decode(ceph::buffer::list& bl);
+ void decode(ceph::buffer::list::const_iterator& bl);
/**** mapping facilities ****/
int map_to_pg(
int64_t pool,
- const string& name,
- const string& key,
- const string& nspace,
+ const std::string& name,
+ const std::string& key,
+ const std::string& nspace,
pg_t *pg) const;
int object_locator_to_pg(const object_t& oid, const object_locator_t& loc,
pg_t &pg) const;
}
ceph_object_layout make_object_layout(object_t oid, int pg_pool,
- string nspace) const;
+ std::string nspace) const;
int get_pg_num(int pg_pool) const
{
}
private:
- /// pg -> (raw osd list)
+ /// pg -> (raw osd std::list)
void _pg_to_raw_osds(
const pg_pool_t& pool, pg_t pg,
- vector<int> *osds,
+ std::vector<int> *osds,
ps_t *ppps) const;
- int _pick_primary(const vector<int>& osds) const;
- void _remove_nonexistent_osds(const pg_pool_t& pool, vector<int>& osds) const;
+ int _pick_primary(const std::vector<int>& osds) const;
+ void _remove_nonexistent_osds(const pg_pool_t& pool, std::vector<int>& osds) const;
void _apply_primary_affinity(ps_t seed, const pg_pool_t& pool,
- vector<int> *osds, int *primary) const;
+ std::vector<int> *osds, int *primary) const;
/// apply pg_upmap[_items] mappings
- void _apply_upmap(const pg_pool_t& pi, pg_t pg, vector<int> *raw) const;
+ void _apply_upmap(const pg_pool_t& pi, pg_t pg, std::vector<int> *raw) const;
- /// pg -> (up osd list)
- void _raw_to_up_osds(const pg_pool_t& pool, const vector<int>& raw,
- vector<int> *up) const;
+ /// pg -> (up osd std::list)
+ void _raw_to_up_osds(const pg_pool_t& pool, const std::vector<int>& raw,
+ std::vector<int> *up) const;
/**
* from the pg_temp (if specified), or -1 if you should use the calculated (up_)primary.
*/
void _get_temp_osds(const pg_pool_t& pool, pg_t pg,
- vector<int> *temp_pg, int *temp_primary) const;
+ std::vector<int> *temp_pg, int *temp_primary) const;
/**
* map to up and acting. Fills in whatever fields are non-NULL.
*/
- void _pg_to_up_acting_osds(const pg_t& pg, vector<int> *up, int *up_primary,
- vector<int> *acting, int *acting_primary,
+ void _pg_to_up_acting_osds(const pg_t& pg, std::vector<int> *up, int *up_primary,
+ std::vector<int> *acting, int *acting_primary,
bool raw_pg_to_pg = true) const;
public:
* by anybody for data mapping purposes.
* raw and primary must be non-NULL
*/
- void pg_to_raw_osds(pg_t pg, vector<int> *raw, int *primary) const;
- void pg_to_raw_upmap(pg_t pg, vector<int> *raw_upmap) const;
+ void pg_to_raw_osds(pg_t pg, std::vector<int> *raw, int *primary) const;
+ void pg_to_raw_upmap(pg_t pg, std::vector<int> *raw_upmap) const;
/// map a pg to its acting set. @return acting set size
- void pg_to_acting_osds(const pg_t& pg, vector<int> *acting,
+ void pg_to_acting_osds(const pg_t& pg, std::vector<int> *acting,
int *acting_primary) const {
_pg_to_up_acting_osds(pg, NULL, NULL, acting, acting_primary);
}
- void pg_to_acting_osds(pg_t pg, vector<int>& acting) const {
+ void pg_to_acting_osds(pg_t pg, std::vector<int>& acting) const {
return pg_to_acting_osds(pg, &acting, NULL);
}
/**
* This does not apply temp overrides and should not be used
* by anybody for data mapping purposes. Specify both pointers.
*/
- void pg_to_raw_up(pg_t pg, vector<int> *up, int *primary) const;
+ void pg_to_raw_up(pg_t pg, std::vector<int> *up, int *primary) const;
/**
* map a pg to its acting set as well as its up set. You must use
* the acting set for data mapping purposes, but some users will
* set as pg_temp.
* Each of these pointers must be non-NULL.
*/
- void pg_to_up_acting_osds(pg_t pg, vector<int> *up, int *up_primary,
- vector<int> *acting, int *acting_primary) const {
+ void pg_to_up_acting_osds(pg_t pg, std::vector<int> *up, int *up_primary,
+ std::vector<int> *acting, int *acting_primary) const {
_pg_to_up_acting_osds(pg, up, up_primary, acting, acting_primary);
}
- void pg_to_up_acting_osds(pg_t pg, vector<int>& up, vector<int>& acting) const {
+ void pg_to_up_acting_osds(pg_t pg, std::vector<int>& up, std::vector<int>& acting) const {
int up_primary, acting_primary;
pg_to_up_acting_osds(pg, &up, &up_primary, &acting, &acting_primary);
}
return true;
}
int primary;
- vector<int> acting;
+ std::vector<int> acting;
pg_to_acting_osds(pgid, &acting, &primary);
for (uint8_t i = 0; i < acting.size(); ++i) {
if (acting[i] == primary) {
if (i == get_pools().end()) {
return false;
}
- vector<int> acting;
+ std::vector<int> acting;
pg_to_acting_osds(pgid, &acting, primary);
if (i->second.is_erasure()) {
for (uint8_t i = 0; i < acting.size(); ++i) {
return new_purged_snaps;
}
- int64_t lookup_pg_pool_name(const string& name) const {
+ int64_t lookup_pg_pool_name(const std::string& name) const {
auto p = name_pool.find(name);
if (p == name_pool.end())
return -ENOENT;
mempool::osdmap::map<int64_t,pg_pool_t>& get_pools() {
return pools;
}
- void get_pool_ids_by_rule(int rule_id, set<int64_t> *pool_ids) const {
+ void get_pool_ids_by_rule(int rule_id, std::set<int64_t> *pool_ids) const {
ceph_assert(pool_ids);
for (auto &p: pools) {
if (p.second.get_crush_rule() == rule_id) {
}
void get_pool_ids_by_osd(CephContext *cct,
int osd,
- set<int64_t> *pool_ids) const;
- const string& get_pool_name(int64_t p) const {
+ std::set<int64_t> *pool_ids) const;
+ const std::string& get_pool_name(int64_t p) const {
auto i = pool_name.find(p);
ceph_assert(i != pool_name.end());
return i->second;
}
- const mempool::osdmap::map<int64_t,string>& get_pool_names() const {
+ const mempool::osdmap::map<int64_t,std::string>& get_pool_names() const {
return pool_name;
}
bool have_pg_pool(int64_t p) const {
* check whether an spg_t maps to a particular osd
*/
bool is_up_acting_osd_shard(spg_t pg, int osd) const {
- vector<int> up, acting;
+ std::vector<int> up, acting;
_pg_to_up_acting_osds(pg.pgid, &up, NULL, &acting, NULL, false);
if (pg.shard == shard_id_t::NO_SHARD) {
if (calc_pg_role(osd, acting, acting.size()) >= 0 ||
/* what replica # is a given osd? 0 primary, -1 for none. */
- static int calc_pg_rank(int osd, const vector<int>& acting, int nrep=0);
- static int calc_pg_role(int osd, const vector<int>& acting, int nrep=0);
+ static int calc_pg_rank(int osd, const std::vector<int>& acting, int nrep=0);
+ static int calc_pg_role(int osd, const std::vector<int>& acting, int nrep=0);
static bool primary_changed(
int oldprimary,
- const vector<int> &oldacting,
+ const std::vector<int> &oldacting,
int newprimary,
- const vector<int> &newacting);
+ const std::vector<int> &newacting);
/* rank is -1 (stray), 0 (primary), 1,2,3,... (replica) */
int get_pg_acting_rank(pg_t pg, int osd) const {
- vector<int> group;
+ std::vector<int> group;
pg_to_acting_osds(pg, group);
return calc_pg_rank(osd, group, group.size());
}
/* role is -1 (stray), 0 (primary), 1 (replica) */
int get_pg_acting_role(const pg_t& pg, int osd) const {
- vector<int> group;
+ std::vector<int> group;
pg_to_acting_osds(pg, group);
return calc_pg_role(osd, group, group.size());
}
bool osd_is_valid_op_target(pg_t pg, int osd) const {
int primary;
- vector<int> group;
+ std::vector<int> group;
pg_to_acting_osds(pg, &group, &primary);
if (osd == primary)
return true;
bool try_pg_upmap(
CephContext *cct,
pg_t pg, ///< pg to potentially remap
- const set<int>& overfull, ///< osds we'd want to evacuate
- const vector<int>& underfull, ///< osds to move to, in order of preference
- vector<int> *orig,
- vector<int> *out); ///< resulting alternative mapping
+ const std::set<int>& overfull, ///< osds we'd want to evacuate
+ const std::vector<int>& underfull, ///< osds to move to, in order of preference
+ std::vector<int> *orig,
+ std::vector<int> *out); ///< resulting alternative mapping
int calc_pg_upmaps(
CephContext *cct,
float max_deviation, ///< max deviation from target (value < 1.0)
int max_iterations, ///< max iterations to run
- const set<int64_t>& pools, ///< [optional] restrict to pool
+ const std::set<int64_t>& pools, ///< [optional] restrict to pool
Incremental *pending_inc
);
- int get_osds_by_bucket_name(const string &name, set<int> *osds) const;
+ int get_osds_by_bucket_name(const std::string &name, std::set<int> *osds) const;
bool have_pg_upmaps(pg_t pg) const {
return pg_upmap.count(pg) ||
}
static int _build_crush_types(CrushWrapper& crush);
static int build_simple_crush_map(CephContext *cct, CrushWrapper& crush,
- int num_osd, ostream *ss);
+ int num_osd, std::ostream *ss);
static int build_simple_crush_map_from_conf(CephContext *cct,
CrushWrapper& crush,
- ostream *ss);
+ std::ostream *ss);
static int build_simple_crush_rules(
CephContext *cct, CrushWrapper& crush,
- const string& root,
- ostream *ss);
+ const std::string& root,
+ std::ostream *ss);
bool crush_rule_in_use(int rule_id) const;
- int validate_crush_rules(CrushWrapper *crush, ostream *ss) const;
+ int validate_crush_rules(CrushWrapper *crush, std::ostream *ss) const;
void clear_temp() {
pg_temp->clear();
}
private:
- void print_osd_line(int cur, ostream *out, Formatter *f) const;
+ void print_osd_line(int cur, std::ostream *out, ceph::Formatter *f) const;
public:
- void print(ostream& out) const;
- void print_pools(ostream& out) const;
- void print_summary(Formatter *f, ostream& out, const string& prefix, bool extra=false) const;
- void print_oneline_summary(ostream& out) const;
+ void print(std::ostream& out) const;
+ void print_pools(std::ostream& out) const;
+ void print_summary(ceph::Formatter *f, std::ostream& out, const std::string& prefix, bool extra=false) const;
+ void print_oneline_summary(std::ostream& out) const;
enum {
DUMP_IN = 1, // only 'in' osds
DUMP_DOWN = 8, // only 'down' osds
DUMP_DESTROYED = 16, // only 'destroyed' osds
};
- void print_tree(Formatter *f, ostream *out, unsigned dump_flags=0, string bucket="") const;
+ void print_tree(ceph::Formatter *f, std::ostream *out, unsigned dump_flags=0, std::string bucket="") const;
int summarize_mapping_stats(
OSDMap *newmap,
- const set<int64_t> *pools,
+ const std::set<int64_t> *pools,
std::string *out,
- Formatter *f) const;
+ ceph::Formatter *f) const;
- string get_flag_string() const;
- static string get_flag_string(unsigned flags);
+ std::string get_flag_string() const;
+ static std::string get_flag_string(unsigned flags);
static void dump_erasure_code_profiles(
- const mempool::osdmap::map<string,map<string,string> > &profiles,
- Formatter *f);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<OSDMap*>& o);
+ const mempool::osdmap::map<std::string,std::map<std::string,std::string> > &profiles,
+ ceph::Formatter *f);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<OSDMap*>& o);
bool check_new_blacklist_entries() const { return new_blacklist_entries; }
void check_health(health_check_map_t *checks) const;
- int parse_osd_id_list(const vector<string>& ls,
- set<int> *out,
- ostream *ss) const;
+ int parse_osd_id_list(const std::vector<std::string>& ls,
+ std::set<int> *out,
+ std::ostream *ss) const;
float pool_raw_used_rate(int64_t poolid) const;
typedef std::shared_ptr<const OSDMap> OSDMapRef;
-inline ostream& operator<<(ostream& out, const OSDMap& m) {
+inline std::ostream& operator<<(std::ostream& out, const OSDMap& m) {
m.print_oneline_summary(out);
return out;
}
void print_osd_utilization(const OSDMap& osdmap,
const PGMap& pgmap,
- ostream& out,
- Formatter *f,
+ std::ostream& out,
+ ceph::Formatter *f,
bool tree,
- const string& class_name,
- const string& item_name);
+ const std::string& class_name,
+ const std::string& item_name);
#endif
projects / ceph-ci.git / commitdiff