#undef dout_prefix
#define dout_prefix *_dout << "cephx keyserverdata: "
+using std::ostringstream;
+using std::string;
+using std::stringstream;
+
+using ceph::bufferptr;
+using ceph::bufferlist;
+using ceph::Formatter;
+
bool KeyServerData::get_service_secret(CephContext *cct, uint32_t service_id,
ExpiringCryptoKey& secret, uint64_t& secret_id) const
{
- map<uint32_t, RotatingSecrets>::const_iterator iter =
- rotating_secrets.find(service_id);
+ auto iter = rotating_secrets.find(service_id);
if (iter == rotating_secrets.end()) {
ldout(cct, 10) << "get_service_secret service " << ceph_entity_type_name(service_id) << " not found " << dendl;
return false;
const RotatingSecrets& secrets = iter->second;
// second to oldest, unless it's expired
- map<uint64_t, ExpiringCryptoKey>::const_iterator riter =
- secrets.secrets.begin();
+ auto riter = secrets.secrets.begin();
if (secrets.secrets.size() > 1)
++riter;
bool KeyServerData::get_service_secret(CephContext *cct, uint32_t service_id,
uint64_t secret_id, CryptoKey& secret) const
{
- map<uint32_t, RotatingSecrets>::const_iterator iter =
- rotating_secrets.find(service_id);
+ auto iter = rotating_secrets.find(service_id);
if (iter == rotating_secrets.end())
return false;
const RotatingSecrets& secrets = iter->second;
- map<uint64_t, ExpiringCryptoKey>::const_iterator riter =
- secrets.secrets.find(secret_id);
+ auto riter = secrets.secrets.find(secret_id);
if (riter == secrets.secrets.end()) {
ldout(cct, 10) << "get_service_secret service " << ceph_entity_type_name(service_id)
<< " secret " << secret_id << " not found" << dendl;
ldout(cct, 30) << " I have:" << dendl;
- for (map<uint64_t, ExpiringCryptoKey>::const_iterator iter =
- secrets.secrets.begin();
- iter != secrets.secrets.end();
- ++iter)
+ for (auto iter = secrets.secrets.begin();
+ iter != secrets.secrets.end();
+ ++iter)
ldout(cct, 30) << " id " << iter->first << " " << iter->second << dendl;
return false;
}
return true;
}
bool KeyServerData::get_auth(const EntityName& name, EntityAuth& auth) const {
- map<EntityName, EntityAuth>::const_iterator iter = secrets.find(name);
+ auto iter = secrets.find(name);
if (iter != secrets.end()) {
auth = iter->second;
return true;
}
bool KeyServerData::get_secret(const EntityName& name, CryptoKey& secret) const {
- map<EntityName, EntityAuth>::const_iterator iter = secrets.find(name);
+ auto iter = secrets.find(name);
if (iter != secrets.end()) {
secret = iter->second.key;
return true;
caps_info.allow_all = false;
ldout(cct, 10) << "get_caps: name=" << name.to_str() << dendl;
- map<EntityName, EntityAuth>::const_iterator iter = secrets.find(name);
+ auto iter = secrets.find(name);
if (iter != secrets.end()) {
ldout(cct, 10) << "get_secret: num of caps=" << iter->second.caps.size() << dendl;
- map<string, bufferlist>::const_iterator capsiter = iter->second.caps.find(type);
+ auto capsiter = iter->second.caps.find(type);
if (capsiter != iter->second.caps.end()) {
caps_info.caps = capsiter->second;
}
void KeyServer::_dump_rotating_secrets()
{
ldout(cct, 30) << "_dump_rotating_secrets" << dendl;
- for (map<uint32_t, RotatingSecrets>::iterator iter = data.rotating_secrets.begin();
+ for (auto iter = data.rotating_secrets.begin();
iter != data.rotating_secrets.end();
++iter) {
RotatingSecrets& key = iter->second;
- for (map<uint64_t, ExpiringCryptoKey>::iterator mapiter = key.secrets.begin();
+ for (auto mapiter = key.secrets.begin();
mapiter != key.secrets.end();
++mapiter)
ldout(cct, 30) << "service " << ceph_entity_type_name(iter->first)
int KeyServer::encode_secrets(Formatter *f, stringstream *ds) const
{
std::scoped_lock l{lock};
- map<EntityName, EntityAuth>::const_iterator mapiter = data.secrets_begin();
+ auto mapiter = data.secrets_begin();
if (mapiter == data.secrets_end())
return -ENOENT;
f->open_object_section("caps");
}
- map<string, bufferlist>::const_iterator capsiter =
- mapiter->second.caps.begin();
+ auto capsiter = mapiter->second.caps.begin();
for (; capsiter != mapiter->second.caps.end(); ++capsiter) {
// FIXME: need a const_iterator for bufferlist, but it doesn't exist yet.
bufferlist *bl = const_cast<bufferlist*>(&capsiter->second);
{
std::scoped_lock l{lock};
- map<EntityName, EntityAuth>::const_iterator mapiter = data.find_name(name);
+ auto mapiter = data.find_name(name);
if (mapiter == data.secrets_end())
return false;
const CryptoKey& specific_key = mapiter->second.key;
- map<uint32_t, RotatingSecrets>::const_iterator rotate_iter =
- data.rotating_secrets.find(name.get_type());
+ auto rotate_iter = data.rotating_secrets.find(name.get_type());
if (rotate_iter == data.rotating_secrets.end())
return false;
#include "auth/KeyRing.h"
#include "CephxProtocol.h"
-#include "CephxKeyServer.h"
#include "common/ceph_mutex.h"
#include "include/common_fwd.h"
version_t version;
/* for each entity */
- map<EntityName, EntityAuth> secrets;
+ std::map<EntityName, EntityAuth> secrets;
KeyRing *extra_secrets;
/* for each service type */
version_t rotating_ver;
- map<uint32_t, RotatingSecrets> rotating_secrets;
+ std::map<uint32_t, RotatingSecrets> rotating_secrets;
explicit KeyServerData(KeyRing *extra)
: version(0),
extra_secrets(extra),
rotating_ver(0) {}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
__u8 struct_v = 1;
using ceph::encode;
encode(struct_v, bl);
encode(secrets, bl);
encode(rotating_secrets, bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
decode(rotating_secrets, bl);
}
- void encode_rotating(bufferlist& bl) const {
+ void encode_rotating(ceph::buffer::list& bl) const {
using ceph::encode;
__u8 struct_v = 1;
encode(struct_v, bl);
encode(rotating_ver, bl);
encode(rotating_secrets, bl);
}
- void decode_rotating(bufferlist& rotating_bl) {
+ void decode_rotating(ceph::buffer::list& rotating_bl) {
using ceph::decode;
auto iter = rotating_bl.cbegin();
__u8 struct_v;
}
void remove_secret(const EntityName& name) {
- map<EntityName, EntityAuth>::iterator iter = secrets.find(name);
+ auto iter = secrets.find(name);
if (iter == secrets.end())
return;
secrets.erase(iter);
bool get_caps(CephContext *cct, const EntityName& name,
const std::string& type, AuthCapsInfo& caps) const;
- map<EntityName, EntityAuth>::iterator secrets_begin()
+ std::map<EntityName, EntityAuth>::iterator secrets_begin()
{ return secrets.begin(); }
- map<EntityName, EntityAuth>::const_iterator secrets_begin() const
+ std::map<EntityName, EntityAuth>::const_iterator secrets_begin() const
{ return secrets.begin(); }
- map<EntityName, EntityAuth>::iterator secrets_end()
+ std::map<EntityName, EntityAuth>::iterator secrets_end()
{ return secrets.end(); }
- map<EntityName, EntityAuth>::const_iterator secrets_end() const
+ std::map<EntityName, EntityAuth>::const_iterator secrets_end() const
{ return secrets.end(); }
- map<EntityName, EntityAuth>::iterator find_name(const EntityName& name)
+ std::map<EntityName, EntityAuth>::iterator find_name(const EntityName& name)
{ return secrets.find(name); }
- map<EntityName, EntityAuth>::const_iterator find_name(const EntityName& name) const
+ std::map<EntityName, EntityAuth>::const_iterator find_name(const EntityName& name) const
{ return secrets.find(name); }
struct Incremental {
IncrementalOp op;
- bufferlist rotating_bl; // if SET_ROTATING. otherwise,
+ ceph::buffer::list rotating_bl; // if SET_ROTATING. otherwise,
EntityName name;
EntityAuth auth;
-
- void encode(bufferlist& bl) const {
+
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
__u8 struct_v = 1;
encode(struct_v, bl);
encode(auth, bl);
}
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
bool get_secret(const EntityName& name, CryptoKey& secret) const override;
bool get_auth(const EntityName& name, EntityAuth& auth) const;
- bool get_caps(const EntityName& name, const string& type, AuthCapsInfo& caps) const;
+ bool get_caps(const EntityName& name, const std::string& type, AuthCapsInfo& caps) const;
bool get_active_rotating_secret(const EntityName& name, CryptoKey& secret) const;
int start_server();
void rotate_timeout(double timeout);
bool generate_secret(EntityName& name, CryptoKey& secret);
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
encode(data, bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
std::scoped_lock l{lock};
using ceph::decode;
decode(data, bl);
}
bool contains(const EntityName& name) const;
- int encode_secrets(Formatter *f, stringstream *ds) const;
- void encode_formatted(string label, Formatter *f, bufferlist &bl);
- void encode_plaintext(bufferlist &bl);
- int list_secrets(stringstream& ds) const {
+ int encode_secrets(ceph::Formatter *f, std::stringstream *ds) const;
+ void encode_formatted(std::string label, ceph::Formatter *f, ceph::buffer::list &bl);
+ void encode_plaintext(ceph::buffer::list &bl);
+ int list_secrets(std::stringstream& ds) const {
return encode_secrets(NULL, &ds);
}
version_t get_ver() const {
std::scoped_lock l{lock};
- return data.version;
+ return data.version;
}
void clear_secrets() {
}
bool has_secrets() {
- map<EntityName, EntityAuth>::const_iterator b = data.secrets_begin();
+ auto b = data.secrets_begin();
return (b != data.secrets_end());
}
int get_num_secrets() {
}
void export_keyring(KeyRing& keyring) {
std::scoped_lock l{lock};
- for (map<EntityName, EntityAuth>::iterator p = data.secrets.begin();
- p != data.secrets.end();
- ++p) {
+ for (auto p = data.secrets.begin(); p != data.secrets.end(); ++p) {
keyring.add(p->first, p->second);
}
}
- bool updated_rotating(bufferlist& rotating_bl, version_t& rotating_ver);
+ bool updated_rotating(ceph::buffer::list& rotating_bl, version_t& rotating_ver);
- bool get_rotating_encrypted(const EntityName& name, bufferlist& enc_bl) const;
+ bool get_rotating_encrypted(const EntityName& name, ceph::buffer::list& enc_bl) const;
ceph::mutex& get_lock() const { return lock; }
bool get_service_caps(const EntityName& name, uint32_t service_id,
AuthCapsInfo& caps) const;
- map<EntityName, EntityAuth>::iterator secrets_begin()
+ std::map<EntityName, EntityAuth>::iterator secrets_begin()
{ return data.secrets_begin(); }
- map<EntityName, EntityAuth>::iterator secrets_end()
+ std::map<EntityName, EntityAuth>::iterator secrets_end()
{ return data.secrets_end(); }
};
WRITE_CLASS_ENCODER(KeyServer)
#undef dout_prefix
#define dout_prefix *_dout << "cephx server " << entity_name << ": "
+using std::dec;
+using std::hex;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+
int CephxServiceHandler::start_session(
const EntityName& name,
size_t connection_secret_required_length,
struct CephXRequestHeader cephx_header;
try {
decode(cephx_header, indata);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
ldout(cct, 0) << __func__ << " failed to decode CephXRequestHeader: "
<< e.what() << dendl;
return -EPERM;
CephXAuthenticate req;
try {
decode(req, indata);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
ldout(cct, 0) << __func__ << " failed to decode CephXAuthenticate: "
<< e.what() << dendl;
ret = -EPERM;
CephXServiceTicketRequest ticket_req;
try {
decode(ticket_req, indata);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
ldout(cct, 0) << __func__
<< " failed to decode CephXServiceTicketRequest: "
<< e.what() << dendl;
int start_session(const EntityName& name,
size_t connection_secret_required_length,
- bufferlist *result_bl,
+ ceph::buffer::list *result_bl,
AuthCapsInfo *caps,
CryptoKey *session_key,
std::string *connection_secret) override;
int handle_request(
- bufferlist::const_iterator& indata,
+ ceph::buffer::list::const_iterator& indata,
size_t connection_secret_required_length,
- bufferlist *result_bl,
+ ceph::buffer::list *result_bl,
uint64_t *global_id,
AuthCapsInfo *caps,
CryptoKey *session_key,
std::string *connection_secret) override;
- void build_cephx_response_header(int request_type, int status, bufferlist& bl);
+ void build_cephx_response_header(int request_type, int status, ceph::buffer::list& bl);
};
#endif
int start_session(const EntityName& name,
size_t connection_secret_required_length,
- bufferlist *result_bl,
+ ceph::buffer::list *result_bl,
AuthCapsInfo *caps,
CryptoKey *session_key,
std::string *connection_secret) override {
caps->allow_all = true;
return 1;
}
- int handle_request(bufferlist::const_iterator& indata,
+ int handle_request(ceph::buffer::list::const_iterator& indata,
size_t connection_secret_required_length,
- bufferlist *result_bl,
+ ceph::buffer::list *result_bl,
uint64_t *global_id,
AuthCapsInfo *caps,
CryptoKey *session_key,
return 0;
}
void build_cephx_response_header(int request_type, int status,
- bufferlist& bl) {
+ ceph::buffer::list& bl) {
}
};
#define dout_subsys ceph_subsys_mon
+using std::cerr;
+using std::cout;
+using std::list;
+using std::map;
+using std::ostringstream;
+using std::string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::JSONFormatter;
+
Monitor *mon = NULL;
+
void handle_mon_signal(int signum)
{
if (mon)
// always mark seed/mkfs monmap as epoch 0
monmap.set_epoch(0);
- } catch (const buffer::error& e) {
+ } catch (const ceph::buffer::error& e) {
derr << argv[0] << ": error decoding monmap " << monmap_fn << ": " << e.what() << dendl;
exit(1);
}
if (err >= 0) {
try {
monmap.decode(mapbl);
- } catch (const buffer::error& e) {
+ } catch (const ceph::buffer::error& e) {
derr << "can't decode monmap: " << e.what() << dendl;
}
} else {
#ifndef CEPH_OS_BLUESTORE_CHECKSUMMER
#define CEPH_OS_BLUESTORE_CHECKSUMMER
-#include "xxHash/xxhash.h"
+#include "include/buffer.h"
#include "include/byteorder.h"
+#include "include/ceph_assert.h"
+
+#include "xxHash/xxhash.h"
class Checksummer {
public:
state_t state,
init_value_t init_value,
size_t len,
- bufferlist::const_iterator& p
+ ceph::buffer::list::const_iterator& p
) {
return p.crc32c(len, init_value);
}
state_t state,
init_value_t init_value,
size_t len,
- bufferlist::const_iterator& p
+ ceph::buffer::list::const_iterator& p
) {
return p.crc32c(len, init_value) & 0xffff;
}
state_t state,
init_value_t init_value,
size_t len,
- bufferlist::const_iterator& p
+ ceph::buffer::list::const_iterator& p
) {
return p.crc32c(len, init_value) & 0xff;
}
state_t state,
init_value_t init_value,
size_t len,
- bufferlist::const_iterator& p
+ ceph::buffer::list::const_iterator& p
) {
XXH32_reset(state, init_value);
while (len > 0) {
state_t state,
init_value_t init_value,
size_t len,
- bufferlist::const_iterator& p
+ ceph::buffer::list::const_iterator& p
) {
XXH64_reset(state, init_value);
while (len > 0) {
size_t csum_block_size,
size_t offset,
size_t length,
- const bufferlist &bl,
- bufferptr* csum_data
+ const ceph::buffer::list &bl,
+ ceph::buffer::ptr* csum_data
) {
return calculate<Alg>(-1, csum_block_size, offset, length, bl, csum_data);
}
size_t csum_block_size,
size_t offset,
size_t length,
- const bufferlist &bl,
- bufferptr* csum_data) {
+ const ceph::buffer::list &bl,
+ ceph::buffer::ptr* csum_data) {
ceph_assert(length % csum_block_size == 0);
size_t blocks = length / csum_block_size;
- bufferlist::const_iterator p = bl.begin();
+ ceph::buffer::list::const_iterator p = bl.begin();
ceph_assert(bl.length() >= length);
typename Alg::state_t state;
size_t csum_block_size,
size_t offset,
size_t length,
- const bufferlist &bl,
- const bufferptr& csum_data,
+ const ceph::buffer::list &bl,
+ const ceph::buffer::ptr& csum_data,
uint64_t *bad_csum=0
) {
ceph_assert(length % csum_block_size == 0);
- bufferlist::const_iterator p = bl.begin();
+ ceph::buffer::list::const_iterator p = bl.begin();
ceph_assert(bl.length() >= length);
typename Alg::state_t state;
#include <memory>
#endif
#include "common/ceph_mutex.h"
+#include "common/ceph_context.h"
#include "common/dout.h"
#include "include/unordered_map.h"
-// re-include our assert to clobber the system one; fix dout:
-#include "include/ceph_assert.h"
-
template <class K, class V>
class SharedLRU {
CephContext *cct;
VPtr val; // release any ref we have after we drop the lock
{
std::lock_guard l{lock};
- typename map<K, pair<WeakVPtr, V*>, C>::iterator i = weak_refs.find(key);
+ auto i = weak_refs.find(key);
if (i != weak_refs.end()) {
val = i->second.first.lock();
}
void clear_range(
const K& from,
const K& to) {
- list<VPtr> vals; // release any refs we have after we drop the lock
+ std::list<VPtr> vals; // release any refs we have after we drop the lock
{
std::lock_guard l{lock};
auto from_iter = weak_refs.lower_bound(from);
VPtr val; // release any ref we have after we drop the lock
{
std::lock_guard l{lock};
- typename map<K, pair<WeakVPtr, V*>, C>::iterator i = weak_refs.find(key);
+ auto i = weak_refs.find(key);
if (i != weak_refs.end()) {
val = i->second.first.lock();
weak_refs.erase(i);
}
void set_size(size_t new_size) {
- list<VPtr> to_release;
+ std::list<VPtr> to_release;
{
std::lock_guard l{lock};
max_size = new_size;
VPtr lower_bound(const K& key) {
VPtr val;
- list<VPtr> to_release;
+ std::list<VPtr> to_release;
{
std::unique_lock l{lock};
++waiting;
}
VPtr lookup_or_create(const K &key) {
VPtr val;
- list<VPtr> to_release;
+ std::list<VPtr> to_release;
{
std::unique_lock l{lock};
cond.wait(l, [this, &key, &val] {
*/
VPtr add(const K& key, V *value, bool *existed = NULL) {
VPtr val;
- list<VPtr> to_release;
+ std::list<VPtr> to_release;
{
- typename map<K, pair<WeakVPtr, V*>, C>::iterator actual;
+ typename std::map<K, std::pair<WeakVPtr, V*>, C>::iterator actual;
std::unique_lock l{lock};
cond.wait(l, [this, &key, &actual, &val] {
actual = weak_refs.lower_bound(key);
#ifndef CEPH_SIMPLECACHE_H
#define CEPH_SIMPLECACHE_H
+#include <list>
+#include <map>
+#include <unordered_map>
+#include <utility>
+
#include "common/ceph_mutex.h"
-#include "include/unordered_map.h"
template <class K, class V, class C = std::less<K>, class H = std::hash<K> >
class SimpleLRU {
size_t max_size;
size_t max_bytes = 0;
size_t total_bytes = 0;
- ceph::unordered_map<K, typename list<pair<K, V> >::iterator, H> contents;
- list<pair<K, V> > lru;
- map<K, V, C> pinned;
+ std::unordered_map<K, typename std::list<std::pair<K, V>>::iterator, H> contents;
+ std::list<std::pair<K, V> > lru;
+ std::map<K, V, C> pinned;
void trim_cache() {
while (contents.size() > max_size) {
void clear_pinned(K e) {
std::lock_guard l(lock);
- for (typename map<K, V, C>::iterator i = pinned.begin();
+ for (auto i = pinned.begin();
i != pinned.end() && i->first <= e;
pinned.erase(i++)) {
- typename ceph::unordered_map<K, typename list<pair<K, V> >::iterator, H>::iterator iter =
- contents.find(i->first);
+ auto iter = contents.find(i->first);
if (iter == contents.end())
_add(i->first, std::move(i->second));
else
void clear(K key) {
std::lock_guard l(lock);
- typename ceph::unordered_map<K, typename list<pair<K, V> >::iterator, H>::iterator i =
- contents.find(key);
+ auto i = contents.find(key);
if (i == contents.end())
return;
total_bytes -= i->second->second.length();
bool lookup(K key, V *out) {
std::lock_guard l(lock);
- typename ceph::unordered_map<K, typename list<pair<K, V> >::iterator, H>::iterator i =
- contents.find(key);
+ auto i = contents.find(key);
if (i != contents.end()) {
*out = i->second->second;
lru.splice(lru.begin(), lru, i->second);
return true;
}
- typename map<K, V, C>::iterator i_pinned = pinned.find(key);
+ auto i_pinned = pinned.find(key);
if (i_pinned != pinned.end()) {
*out = i_pinned->second;
return true;
#include "RocksDBStore.h"
#endif
+using std::map;
+using std::string;
+
KeyValueDB *KeyValueDB::create(CephContext *cct, const string& type,
const string& dir,
map<string,string> options,
#include "common/perf_counters.h"
#include "common/PriorityCache.h"
-using std::string;
-using std::vector;
/**
* Defines virtual interface to be implemented by key value store
*
* Prefix will be the name of column family to use.
*/
struct ColumnFamily {
- string name; //< name of this individual column family
- string option; //< configure option string for this CF
- ColumnFamily(const string &name, const string &option)
+ std::string name; //< name of this individual column family
+ std::string option; //< configure option string for this CF
+ ColumnFamily(const std::string &name, const std::string &option)
: name(name), option(option) {}
};
uint32_t num;
decode(num, p);
while (num--) {
- string key;
+ std::string key;
ceph::buffer::list value;
decode(key, p);
decode(value, p);
const char *k,
size_t keylen,
const ceph::buffer::list& bl) {
- set(prefix, string(k, keylen), bl);
+ set(prefix, std::string(k, keylen), bl);
}
/// Removes Keys (via encoded ceph::buffer::list)
uint32_t num;
decode(num, p);
while (num--) {
- string key;
+ std::string key;
decode(key, p);
rmkey(prefix, key);
}
const char *k, ///< [in] Key to remove
size_t keylen
) {
- rmkey(prefix, string(k, keylen));
+ rmkey(prefix, std::string(k, keylen));
}
/// Remove Single Key which exists and was not overwritten.
) = 0;
virtual void rm_range_keys(
- const string &prefix, ///< [in] Prefix by which to remove keys
- const string &start, ///< [in] The start bound of remove keys
- const string &end ///< [in] The start bound of remove keys
+ const std::string &prefix, ///< [in] Prefix by which to remove keys
+ const std::string &start, ///< [in] The start bound of remove keys
+ const std::string &end ///< [in] The start bound of remove keys
) = 0;
/// Merge value into key
/// test whether we can successfully initialize; may have side effects (e.g., create)
static int test_init(const std::string& type, const std::string& dir);
- virtual int init(string option_str="") = 0;
+ virtual int init(std::string option_str="") = 0;
virtual int open(std::ostream &out, const std::vector<ColumnFamily>& cfs = {}) = 0;
// std::vector cfs contains column families to be created when db is created.
virtual int create_and_open(std::ostream &out,
}
return r;
}
- virtual int get(const string &prefix,
+ virtual int get(const std::string &prefix,
const char *key, size_t keylen,
ceph::buffer::list *value) {
- return get(prefix, string(key, keylen), value);
+ return get(prefix, std::string(key, keylen), value);
}
// This superclass is used both by kv iterators *and* by the ObjectMap
virtual ~KeyValueDB() {}
/// estimate space utilization for a prefix (in bytes)
- virtual int64_t estimate_prefix_size(const string& prefix,
- const string& key_prefix) {
+ virtual int64_t estimate_prefix_size(const std::string& prefix,
+ const std::string& key_prefix) {
return 0;
}
#include <string>
#include <cerrno>
-using std::string;
-
#include "common/debug.h"
#include "common/perf_counters.h"
#undef dout_prefix
#define dout_prefix *_dout << "leveldb: "
+using std::list;
+using std::string;
+using std::ostream;
+using std::pair;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+
class CephLevelDBLogger : public leveldb::Logger {
CephContext *cct;
public:
CephContext *cct;
PerfCounters *logger;
CephLevelDBLogger *ceph_logger;
- string path;
+ std::string path;
boost::scoped_ptr<leveldb::Cache> db_cache;
#ifdef HAVE_LEVELDB_FILTER_POLICY
boost::scoped_ptr<const leveldb::FilterPolicy> filterpolicy;
boost::scoped_ptr<leveldb::DB> db;
int load_leveldb_options(bool create_if_missing, leveldb::Options &opts);
- int do_open(ostream &out, bool create_if_missing);
+ int do_open(std::ostream &out, bool create_if_missing);
// manage async compactions
ceph::mutex compact_queue_lock =
ceph::make_mutex("LevelDBStore::compact_thread_lock");
ceph::condition_variable compact_queue_cond;
- list< pair<string,string> > compact_queue;
+ std::list<std::pair<std::string, std::string>> compact_queue;
bool compact_queue_stop;
class CompactThread : public Thread {
LevelDBStore *db;
void compact_thread_entry();
- void compact_range(const string& start, const string& end) {
+ void compact_range(const std::string& start, const std::string& end) {
leveldb::Slice cstart(start);
leveldb::Slice cend(end);
db->CompactRange(&cstart, &cend);
}
- void compact_range_async(const string& start, const string& end);
+ void compact_range_async(const std::string& start, const std::string& end);
public:
/// compact the underlying leveldb store
void compact() override;
void compact_async() override {
- compact_range_async(string(), string());
+ compact_range_async({}, {});
}
/// compact db for all keys with a given prefix
- void compact_prefix(const string& prefix) override {
+ void compact_prefix(const std::string& prefix) override {
compact_range(prefix, past_prefix(prefix));
}
- void compact_prefix_async(const string& prefix) override {
+ void compact_prefix_async(const std::string& prefix) override {
compact_range_async(prefix, past_prefix(prefix));
}
- void compact_range(const string& prefix,
- const string& start, const string& end) override {
+ void compact_range(const std::string& prefix,
+ const std::string& start, const std::string& end) override {
compact_range(combine_strings(prefix, start), combine_strings(prefix, end));
}
- void compact_range_async(const string& prefix,
- const string& start, const string& end) override {
+ void compact_range_async(const std::string& prefix,
+ const std::string& start, const std::string& end) override {
compact_range_async(combine_strings(prefix, start),
combine_strings(prefix, end));
}
bool error_if_exists;
bool paranoid_checks;
- string log_file;
+ std::string log_file;
options_t() :
write_buffer_size(0), //< 0 means default
{}
} options;
- LevelDBStore(CephContext *c, const string &path) :
+ LevelDBStore(CephContext *c, const std::string &path) :
cct(c),
logger(NULL),
ceph_logger(NULL),
~LevelDBStore() override;
- static int _test_init(const string& dir);
- int init(string option_str="") override;
+ static int _test_init(const std::string& dir);
+ int init(std::string option_str="") override;
/// Opens underlying db
- int open(ostream &out, const std::vector<ColumnFamily>& = {}) override;
+ int open(std::ostream &out, const std::vector<ColumnFamily>& = {}) override;
/// Creates underlying db if missing and opens it
- int create_and_open(ostream &out, const std::vector<ColumnFamily>& = {}) override;
+ int create_and_open(std::ostream &out, const std::vector<ColumnFamily>& = {}) override;
void close() override;
LevelDBStore *db;
explicit LevelDBTransactionImpl(LevelDBStore *db) : db(db) {}
void set(
- const string &prefix,
- const string &k,
- const bufferlist &bl) override;
+ const std::string &prefix,
+ const std::string &k,
+ const ceph::buffer::list &bl) override;
using KeyValueDB::TransactionImpl::set;
void rmkey(
- const string &prefix,
- const string &k) override;
+ const std::string &prefix,
+ const std::string &k) override;
void rmkeys_by_prefix(
- const string &prefix
+ const std::string &prefix
) override;
virtual void rm_range_keys(
- const string &prefix,
- const string &start,
- const string &end) override;
+ const std::string &prefix,
+ const std::string &start,
+ const std::string &end) override;
using KeyValueDB::TransactionImpl::rmkey;
};
int submit_transaction(KeyValueDB::Transaction t) override;
int submit_transaction_sync(KeyValueDB::Transaction t) override;
int get(
- const string &prefix,
- const std::set<string> &key,
- std::map<string, bufferlist> *out
+ const std::string &prefix,
+ const std::set<std::string> &key,
+ std::map<std::string, ceph::buffer::list> *out
) override;
- int get(const string &prefix,
- const string &key,
- bufferlist *value) override;
+ int get(const std::string &prefix,
+ const std::string &key,
+ ceph::buffer::list *value) override;
using KeyValueDB::get;
dbiter->SeekToFirst();
return dbiter->status().ok() ? 0 : -1;
}
- int seek_to_first(const string &prefix) override {
+ int seek_to_first(const std::string &prefix) override {
leveldb::Slice slice_prefix(prefix);
dbiter->Seek(slice_prefix);
return dbiter->status().ok() ? 0 : -1;
dbiter->SeekToLast();
return dbiter->status().ok() ? 0 : -1;
}
- int seek_to_last(const string &prefix) override {
- string limit = past_prefix(prefix);
+ int seek_to_last(const std::string &prefix) override {
+ std::string limit = past_prefix(prefix);
leveldb::Slice slice_limit(limit);
dbiter->Seek(slice_limit);
}
return dbiter->status().ok() ? 0 : -1;
}
- int upper_bound(const string &prefix, const string &after) override {
+ int upper_bound(const std::string &prefix, const std::string &after) override {
lower_bound(prefix, after);
if (valid()) {
- pair<string,string> key = raw_key();
+ std::pair<std::string,std::string> key = raw_key();
if (key.first == prefix && key.second == after)
next();
}
return dbiter->status().ok() ? 0 : -1;
}
- int lower_bound(const string &prefix, const string &to) override {
- string bound = combine_strings(prefix, to);
+ int lower_bound(const std::string &prefix, const std::string &to) override {
+ std::string bound = combine_strings(prefix, to);
leveldb::Slice slice_bound(bound);
dbiter->Seek(slice_bound);
return dbiter->status().ok() ? 0 : -1;
dbiter->Prev();
return dbiter->status().ok() ? 0 : -1;
}
- string key() override {
- string out_key;
+ std::string key() override {
+ std::string out_key;
split_key(dbiter->key(), 0, &out_key);
return out_key;
}
- pair<string,string> raw_key() override {
- string prefix, key;
+ std::pair<std::string,std::string> raw_key() override {
+ std::string prefix, key;
split_key(dbiter->key(), &prefix, &key);
- return make_pair(prefix, key);
+ return std::make_pair(prefix, key);
}
- bool raw_key_is_prefixed(const string &prefix) override {
+ bool raw_key_is_prefixed(const std::string &prefix) override {
leveldb::Slice key = dbiter->key();
if ((key.size() > prefix.length()) && (key[prefix.length()] == '\0')) {
return memcmp(key.data(), prefix.c_str(), prefix.length()) == 0;
return false;
}
}
- bufferlist value() override {
+ ceph::buffer::list value() override {
return to_bufferlist(dbiter->value());
}
- bufferptr value_as_ptr() override {
+ ceph::bufferptr value_as_ptr() override {
leveldb::Slice data = dbiter->value();
- return bufferptr(data.data(), data.size());
+ return ceph::bufferptr(data.data(), data.size());
}
int status() override {
};
/// Utility
- static string combine_strings(const string &prefix, const string &value);
- static int split_key(leveldb::Slice in, string *prefix, string *key);
- static bufferlist to_bufferlist(leveldb::Slice in);
- static string past_prefix(const string &prefix) {
- string limit = prefix;
+ static std::string combine_strings(const std::string &prefix, const std::string &value);
+ static int split_key(leveldb::Slice in, std::string *prefix, std::string *key);
+ static ceph::buffer::list to_bufferlist(leveldb::Slice in);
+ static std::string past_prefix(const std::string &prefix) {
+ std::string limit = prefix;
limit.push_back(1);
return limit;
}
- uint64_t get_estimated_size(map<string,uint64_t> &extra) override {
+ uint64_t get_estimated_size(std::map<std::string,std::uint64_t> &extra) override {
DIR *store_dir = opendir(path.c_str());
if (!store_dir) {
lderr(cct) << __func__ << " something happened opening the store: "
struct dirent *entry = NULL;
while ((entry = readdir(store_dir)) != NULL) {
- string n(entry->d_name);
+ std::string n(entry->d_name);
if (n == "." || n == "..")
continue;
- string fpath = path + '/' + n;
+ std::string fpath = path + '/' + n;
struct stat s;
int err = stat(fpath.c_str(), &s);
if (err < 0)
}
size_t pos = n.find_last_of('.');
- if (pos == string::npos) {
+ if (pos == std::string::npos) {
misc_size += s.st_size;
continue;
}
- string ext = n.substr(pos+1);
+ std::string ext = n.substr(pos+1);
if (ext == "sst") {
sst_size += s.st_size;
} else if (ext == "log") {
#define dwarn dout(0)
#define dinfo dout(0)
+using std::cerr;
+using std::ostream;
+using std::string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::decode;
+using ceph::encode;
+
static void split_key(const string& raw_key, string *prefix, string *key)
{
size_t pos = raw_key.find(KEY_DELIM, 0);
string key;
bufferptr datap;
- bytes_done += ::decode_file(fd, key);
- bytes_done += ::decode_file(fd, datap);
+ bytes_done += ceph::decode_file(fd, key);
+ bytes_done += ceph::decode_file(fd, datap);
dout(10) << __func__ << " Key:"<< key << dendl;
m_map[key] = datap;
return key;
}
-pair<string,string> MemDB::MDBWholeSpaceIteratorImpl::raw_key()
+std::pair<string,string> MemDB::MDBWholeSpaceIteratorImpl::raw_key()
{
string prefix, key;
split_key(m_key_value.first, &prefix, &key);
- return make_pair(prefix, key);
+ return { prefix, key };
}
bool MemDB::MDBWholeSpaceIteratorImpl::raw_key_is_prefixed(
#include "KeyValueDB.h"
#include "osd/osd_types.h"
-using std::string;
#define KEY_DELIM '\0'
class MemDB : public KeyValueDB
{
- typedef std::pair<std::pair<std::string, std::string>, bufferlist> ms_op_t;
+ typedef std::pair<std::pair<std::string, std::string>, ceph::bufferlist> ms_op_t;
std::mutex m_lock;
uint64_t m_total_bytes;
uint64_t m_allocated_bytes;
- typedef std::map<std::string, bufferptr> mdb_map_t;
+ typedef std::map<std::string, ceph::bufferptr> mdb_map_t;
typedef mdb_map_t::iterator mdb_iter_t;
bool m_using_btree;
CephContext *m_cct;
PerfCounters *logger;
void* m_priv;
- string m_options;
- string m_db_path;
+ std::string m_options;
+ std::string m_db_path;
int transaction_rollback(KeyValueDB::Transaction t);
- int _open(ostream &out);
+ int _open(std::ostream &out);
void close() override;
- bool _get(const string &prefix, const string &k, bufferlist *out);
- bool _get_locked(const string &prefix, const string &k, bufferlist *out);
+ bool _get(const std::string &prefix, const std::string &k, ceph::bufferlist *out);
+ bool _get_locked(const std::string &prefix, const std::string &k, ceph::bufferlist *out);
std::string _get_data_fn();
- void _encode(mdb_iter_t iter, bufferlist &bl);
+ void _encode(mdb_iter_t iter, ceph::bufferlist &bl);
void _save();
int _load();
uint64_t iterator_seq_no;
public:
- MemDB(CephContext *c, const string &path, void *p) :
+ MemDB(CephContext *c, const std::string &path, void *p) :
m_total_bytes(0), m_allocated_bytes(0), m_using_btree(false),
m_cct(c), logger(NULL), m_priv(p), m_db_path(path), iterator_seq_no(1)
{
std::shared_ptr<MergeOperator> _find_merge_op(const std::string &prefix);
static
- int _test_init(const string& dir) { return 0; };
+ int _test_init(const std::string& dir) { return 0; };
class MDBTransactionImpl : public KeyValueDB::TransactionImpl {
public:
std::vector<std::pair<op_type, ms_op_t>> ops;
MemDB *m_db;
- bool key_is_prefixed(const string &prefix, const string& full_key);
+ bool key_is_prefixed(const std::string &prefix, const std::string& full_key);
public:
const std::vector<std::pair<op_type, ms_op_t>>&
get_ops() { return ops; };
void set(const std::string &prefix, const std::string &key,
- const bufferlist &val) override;
+ const ceph::bufferlist &val) override;
using KeyValueDB::TransactionImpl::set;
void rmkey(const std::string &prefix, const std::string &k) override;
using KeyValueDB::TransactionImpl::rmkey;
void rmkeys_by_prefix(const std::string &prefix) override;
void rm_range_keys(
- const string &prefix,
- const string &start,
- const string &end) override;
+ const std::string &prefix,
+ const std::string &start,
+ const std::string &end) override;
- void merge(const std::string &prefix, const std::string &key, const bufferlist &value) override;
+ void merge(const std::string &prefix, const std::string &key,
+ const ceph::bufferlist &value) override;
void clear() {
ops.clear();
}
/*
* Transaction states.
*/
- int _merge(const std::string &k, bufferptr &bl);
+ int _merge(const std::string &k, ceph::bufferptr &bl);
int _merge(ms_op_t &op);
int _setkey(ms_op_t &op);
int _rmkey(ms_op_t &op);
public:
- int init(string option_str="") override { m_options = option_str; return 0; }
+ int init(std::string option_str="") override { m_options = option_str; return 0; }
int _init(bool format);
- int do_open(ostream &out, bool create);
- int open(ostream &out, const std::vector<ColumnFamily>&) override;
- int create_and_open(ostream &out, const std::vector<ColumnFamily>&) override;
+ int do_open(std::ostream &out, bool create);
+ int open(std::ostream &out, const std::vector<ColumnFamily>&) override;
+ int create_and_open(std::ostream &out, const std::vector<ColumnFamily>&) override;
using KeyValueDB::create_and_open;
KeyValueDB::Transaction get_transaction() override {
int submit_transaction_sync(Transaction) override;
int get(const std::string &prefix, const std::set<std::string> &key,
- std::map<std::string, bufferlist> *out) override;
+ std::map<std::string, ceph::bufferlist> *out) override;
int get(const std::string &prefix, const std::string &key,
- bufferlist *out) override;
+ ceph::bufferlist *out) override;
using KeyValueDB::get;
class MDBWholeSpaceIteratorImpl : public KeyValueDB::WholeSpaceIteratorImpl {
mdb_iter_t m_iter;
- std::pair<string, bufferlist> m_key_value;
+ std::pair<std::string, ceph::bufferlist> m_key_value;
mdb_map_t *m_map_p;
std::mutex *m_map_lock_p;
uint64_t *global_seq_no;
std::string key() override;
std::pair<std::string,std::string> raw_key() override;
bool raw_key_is_prefixed(const std::string &prefix) override;
- bufferlist value() override;
+ ceph::bufferlist value() override;
~MDBWholeSpaceIteratorImpl() override;
};
#include "rocksdb/utilities/convenience.h"
#include "rocksdb/merge_operator.h"
-using std::string;
#include "common/perf_counters.h"
#include "common/PriorityCache.h"
#include "include/common_fwd.h"
#undef dout_prefix
#define dout_prefix *_dout << "rocksdb: "
+using std::function;
+using std::list;
+using std::map;
+using std::ostream;
+using std::pair;
+using std::set;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::Formatter;
+
static bufferlist to_bufferlist(rocksdb::Slice in) {
bufferlist bl;
bl.append(bufferptr(in.data(), in.size()));
dout(10) << __func__ << " enter" << dendl;
while (!compact_queue_stop) {
if (!compact_queue.empty()) {
- pair<string,string> range = compact_queue.front();
+ auto range = compact_queue.front();
compact_queue.pop_front();
logger->set(l_rocksdb_compact_queue_len, compact_queue.size());
l.unlock();
class RocksDBStore : public KeyValueDB {
CephContext *cct;
PerfCounters *logger;
- string path;
- map<string,string> kv_options;
+ std::string path;
+ std::map<std::string,std::string> kv_options;
void *priv;
rocksdb::DB *db;
rocksdb::Env *env;
std::shared_ptr<rocksdb::Statistics> dbstats;
rocksdb::BlockBasedTableOptions bbt_opts;
- string options_str;
+ std::string options_str;
uint64_t cache_size = 0;
bool set_cache_flag = false;
rocksdb::ColumnFamilyHandle *default_cf = nullptr;
int submit_common(rocksdb::WriteOptions& woptions, KeyValueDB::Transaction t);
- int install_cf_mergeop(const string &cf_name, rocksdb::ColumnFamilyOptions *cf_opt);
+ int install_cf_mergeop(const std::string &cf_name, rocksdb::ColumnFamilyOptions *cf_opt);
int create_db_dir();
- int do_open(ostream &out, bool create_if_missing, bool open_readonly,
- const vector<ColumnFamily>* cfs = nullptr);
+ int do_open(std::ostream &out, bool create_if_missing, bool open_readonly,
+ const std::vector<ColumnFamily>* cfs = nullptr);
int load_rocksdb_options(bool create_if_missing, rocksdb::Options& opt);
// manage async compactions
ceph::mutex compact_queue_lock =
ceph::make_mutex("RocksDBStore::compact_thread_lock");
ceph::condition_variable compact_queue_cond;
- list< pair<string,string> > compact_queue;
+ std::list<std::pair<std::string,std::string>> compact_queue;
bool compact_queue_stop;
class CompactThread : public Thread {
RocksDBStore *db;
void compact_thread_entry();
- void compact_range(const string& start, const string& end);
- void compact_range_async(const string& start, const string& end);
- int tryInterpret(const string& key, const string& val, rocksdb::Options& opt);
+ void compact_range(const std::string& start, const std::string& end);
+ void compact_range_async(const std::string& start, const std::string& end);
+ int tryInterpret(const std::string& key, const std::string& val,
+ rocksdb::Options& opt);
public:
/// compact the underlying rocksdb store
void compact() override;
void compact_async() override {
- compact_range_async(string(), string());
+ compact_range_async({}, {});
}
- int ParseOptionsFromString(const string& opt_str, rocksdb::Options& opt);
+ int ParseOptionsFromString(const std::string& opt_str, rocksdb::Options& opt);
static int ParseOptionsFromStringStatic(
CephContext* cct,
- const string& opt_str,
+ const std::string& opt_str,
rocksdb::Options &opt,
- function<int(const string&, const string&, rocksdb::Options&)> interp);
- static int _test_init(const string& dir);
- int init(string options_str) override;
+ std::function<int(const std::string&, const std::string&, rocksdb::Options&)> interp);
+ static int _test_init(const std::string& dir);
+ int init(std::string options_str) override;
/// compact rocksdb for all keys with a given prefix
- void compact_prefix(const string& prefix) override {
+ void compact_prefix(const std::string& prefix) override {
compact_range(prefix, past_prefix(prefix));
}
- void compact_prefix_async(const string& prefix) override {
+ void compact_prefix_async(const std::string& prefix) override {
compact_range_async(prefix, past_prefix(prefix));
}
- void compact_range(const string& prefix, const string& start, const string& end) override {
+ void compact_range(const std::string& prefix, const std::string& start,
+ const std::string& end) override {
compact_range(combine_strings(prefix, start), combine_strings(prefix, end));
}
- void compact_range_async(const string& prefix, const string& start, const string& end) override {
+ void compact_range_async(const std::string& prefix, const std::string& start,
+ const std::string& end) override {
compact_range_async(combine_strings(prefix, start), combine_strings(prefix, end));
}
- RocksDBStore(CephContext *c, const string &path, map<string,string> opt, void *p) :
+ RocksDBStore(CephContext *c, const std::string &path, std::map<std::string,std::string> opt, void *p) :
cct(c),
logger(NULL),
path(path),
~RocksDBStore() override;
- static bool check_omap_dir(string &omap_dir);
+ static bool check_omap_dir(std::string &omap_dir);
/// Opens underlying db
- int open(ostream &out, const vector<ColumnFamily>& cfs = {}) override {
+ int open(std::ostream &out, const std::vector<ColumnFamily>& cfs = {}) override {
return do_open(out, false, false, &cfs);
}
/// Creates underlying db if missing and opens it
- int create_and_open(ostream &out,
- const vector<ColumnFamily>& cfs = {}) override;
+ int create_and_open(std::ostream &out,
+ const std::vector<ColumnFamily>& cfs = {}) override;
- int open_read_only(ostream &out, const vector<ColumnFamily>& cfs = {}) override {
+ int open_read_only(std::ostream &out, const std::vector<ColumnFamily>& cfs = {}) override {
return do_open(out, false, true, &cfs);
}
}
int repair(std::ostream &out) override;
void split_stats(const std::string &s, char delim, std::vector<std::string> &elems);
- void get_statistics(Formatter *f) override;
+ void get_statistics(ceph::Formatter *f) override;
PerfCounters *get_perf_counters() override
{
const std::string &property,
uint64_t *out) final;
- int64_t estimate_prefix_size(const string& prefix,
- const string& key_prefix) override;
+ int64_t estimate_prefix_size(const std::string& prefix,
+ const std::string& key_prefix) override;
struct RocksWBHandler: public rocksdb::WriteBatch::Handler {
std::string seen ;
int num_seen = 0;
- static string pretty_binary_string(const string& in) {
+ static std::string pretty_binary_string(const std::string& in) {
char buf[10];
- string out;
+ std::string out;
out.reserve(in.length() * 3);
enum { NONE, HEX, STRING } mode = NONE;
unsigned from = 0, i;
}
void Put(const rocksdb::Slice& key,
const rocksdb::Slice& value) override {
- string prefix ((key.ToString()).substr(0,1));
- string key_to_decode ((key.ToString()).substr(2,string::npos));
+ std::string prefix ((key.ToString()).substr(0,1));
+ std::string key_to_decode ((key.ToString()).substr(2, std::string::npos));
uint64_t size = (value.ToString()).size();
seen += "\nPut( Prefix = " + prefix + " key = "
+ pretty_binary_string(key_to_decode)
num_seen++;
}
void SingleDelete(const rocksdb::Slice& key) override {
- string prefix ((key.ToString()).substr(0,1));
- string key_to_decode ((key.ToString()).substr(2,string::npos));
+ std::string prefix ((key.ToString()).substr(0,1));
+ std::string key_to_decode ((key.ToString()).substr(2, std::string::npos));
seen += "\nSingleDelete(Prefix = "+ prefix + " Key = "
+ pretty_binary_string(key_to_decode) + ")";
num_seen++;
}
void Delete(const rocksdb::Slice& key) override {
- string prefix ((key.ToString()).substr(0,1));
- string key_to_decode ((key.ToString()).substr(2,string::npos));
+ std::string prefix ((key.ToString()).substr(0,1));
+ std::string key_to_decode ((key.ToString()).substr(2, std::string::npos));
seen += "\nDelete( Prefix = " + prefix + " key = "
+ pretty_binary_string(key_to_decode) + ")";
}
void Merge(const rocksdb::Slice& key,
const rocksdb::Slice& value) override {
- string prefix ((key.ToString()).substr(0,1));
- string key_to_decode ((key.ToString()).substr(2,string::npos));
+ std::string prefix ((key.ToString()).substr(0,1));
+ std::string key_to_decode ((key.ToString()).substr(2, std::string::npos));
uint64_t size = (value.ToString()).size();
seen += "\nMerge( Prefix = " + prefix + " key = "
+ pretty_binary_string(key_to_decode) + " Value size = "
void put_bat(
rocksdb::WriteBatch& bat,
rocksdb::ColumnFamilyHandle *cf,
- const string &k,
- const bufferlist &to_set_bl);
+ const std::string &k,
+ const ceph::bufferlist &to_set_bl);
public:
void set(
- const string &prefix,
- const string &k,
- const bufferlist &bl) override;
+ const std::string &prefix,
+ const std::string &k,
+ const ceph::bufferlist &bl) override;
void set(
- const string &prefix,
+ const std::string &prefix,
const char *k,
size_t keylen,
- const bufferlist &bl) override;
+ const ceph::bufferlist &bl) override;
void rmkey(
- const string &prefix,
- const string &k) override;
+ const std::string &prefix,
+ const std::string &k) override;
void rmkey(
- const string &prefix,
+ const std::string &prefix,
const char *k,
size_t keylen) override;
void rm_single_key(
- const string &prefix,
- const string &k) override;
+ const std::string &prefix,
+ const std::string &k) override;
void rmkeys_by_prefix(
- const string &prefix
+ const std::string &prefix
) override;
void rm_range_keys(
- const string &prefix,
- const string &start,
- const string &end) override;
+ const std::string &prefix,
+ const std::string &start,
+ const std::string &end) override;
void merge(
- const string& prefix,
- const string& k,
- const bufferlist &bl) override;
+ const std::string& prefix,
+ const std::string& k,
+ const ceph::bufferlist &bl) override;
};
KeyValueDB::Transaction get_transaction() override {
int submit_transaction(KeyValueDB::Transaction t) override;
int submit_transaction_sync(KeyValueDB::Transaction t) override;
int get(
- const string &prefix,
- const std::set<string> &key,
- std::map<string, bufferlist> *out
+ const std::string &prefix,
+ const std::set<std::string> &key,
+ std::map<std::string, ceph::bufferlist> *out
) override;
int get(
- const string &prefix,
- const string &key,
- bufferlist *out
+ const std::string &prefix,
+ const std::string &key,
+ ceph::bufferlist *out
) override;
int get(
- const string &prefix,
+ const std::string &prefix,
const char *key,
size_t keylen,
- bufferlist *out) override;
+ ceph::bufferlist *out) override;
class RocksDBWholeSpaceIteratorImpl :
~RocksDBWholeSpaceIteratorImpl() override;
int seek_to_first() override;
- int seek_to_first(const string &prefix) override;
+ int seek_to_first(const std::string &prefix) override;
int seek_to_last() override;
- int seek_to_last(const string &prefix) override;
- int upper_bound(const string &prefix, const string &after) override;
- int lower_bound(const string &prefix, const string &to) override;
+ int seek_to_last(const std::string &prefix) override;
+ int upper_bound(const std::string &prefix, const std::string &after) override;
+ int lower_bound(const std::string &prefix, const std::string &to) override;
bool valid() override;
int next() override;
int prev() override;
- string key() override;
- pair<string,string> raw_key() override;
- bool raw_key_is_prefixed(const string &prefix) override;
- bufferlist value() override;
- bufferptr value_as_ptr() override;
+ std::string key() override;
+ std::pair<std::string,std::string> raw_key() override;
+ bool raw_key_is_prefixed(const std::string &prefix) override;
+ ceph::bufferlist value() override;
+ ceph::bufferptr value_as_ptr() override;
int status() override;
size_t key_size() override;
size_t value_size() override;
Iterator get_iterator(const std::string& prefix) override;
/// Utility
- static string combine_strings(const string &prefix, const string &value) {
- string out = prefix;
+ static std::string combine_strings(const std::string &prefix, const std::string &value) {
+ std::string out = prefix;
out.push_back(0);
out.append(value);
return out;
}
- static void combine_strings(const string &prefix,
+ static void combine_strings(const std::string &prefix,
const char *key, size_t keylen,
- string *out) {
+ std::string *out) {
out->reserve(prefix.size() + 1 + keylen);
*out = prefix;
out->push_back(0);
out->append(key, keylen);
}
- static int split_key(rocksdb::Slice in, string *prefix, string *key);
+ static int split_key(rocksdb::Slice in, std::string *prefix, std::string *key);
- static string past_prefix(const string &prefix);
+ static std::string past_prefix(const std::string &prefix);
class MergeOperatorRouter;
class MergeOperatorLinker;
int set_merge_operator(
const std::string& prefix,
std::shared_ptr<KeyValueDB::MergeOperator> mop) override;
- string assoc_name; ///< Name of associative operator
+ std::string assoc_name; ///< Name of associative operator
- uint64_t get_estimated_size(map<string,uint64_t> &extra) override {
+ uint64_t get_estimated_size(std::map<std::string,uint64_t> &extra) override {
DIR *store_dir = opendir(path.c_str());
if (!store_dir) {
lderr(cct) << __func__ << " something happened opening the store: "
struct dirent *entry = NULL;
while ((entry = readdir(store_dir)) != NULL) {
- string n(entry->d_name);
+ std::string n(entry->d_name);
if (n == "." || n == "..")
continue;
- string fpath = path + '/' + n;
+ std::string fpath = path + '/' + n;
struct stat s;
int err = stat(fpath.c_str(), &s);
if (err < 0)
}
size_t pos = n.find_last_of('.');
- if (pos == string::npos) {
+ if (pos == std::string::npos) {
misc_size += s.st_size;
continue;
}
- string ext = n.substr(pos+1);
+ std::string ext = n.substr(pos+1);
if (ext == "sst") {
sst_size += s.st_size;
} else if (ext == "log") {
virtual std::shared_ptr<PriorityCache::PriCache> get_priority_cache()
const override {
- return dynamic_pointer_cast<PriorityCache::PriCache>(
+ return
std::dynamic_pointer_cast<PriorityCache::PriCache>(
bbt_opts.block_cache);
}
using std::ostream;
using std::string;
+using std::vector;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;
version_t round = 0;
utime_t timestamp;
- map<int, double> skews;
- map<int, double> latencies;
+ std::map<int, double> skews;
+ std::map<int, double> latencies;
MTimeCheck2() : Message{MSG_TIMECHECK2, HEAD_VERSION, COMPAT_VERSION} { }
MTimeCheck2(int op) :
#define dout_subsys ceph_subsys_mgr
-ostream& operator<<(ostream& out, const mgr_rwxa_t& p) {
+std::ostream& operator<<(std::ostream& out, const mgr_rwxa_t& p) {
if (p == MGR_CAP_ANY)
return out << "*";
return out;
}
-ostream& operator<<(ostream& out, const MgrCapGrantConstraint& c) {
+std::ostream& operator<<(std::ostream& out, const MgrCapGrantConstraint& c) {
switch (c.match_type) {
case MgrCapGrantConstraint::MATCH_TYPE_EQUAL:
out << "=";
return out;
}
-ostream& operator<<(ostream& out, const MgrCapGrant& m) {
+std::ostream& operator<<(std::ostream& out, const MgrCapGrant& m) {
if (!m.profile.empty()) {
out << "profile " << maybe_quote_string(m.profile);
} else {
return allow;
}
-ostream& operator<<(ostream&out, const MgrCap& m) {
+std::ostream& operator<<(std::ostream&out, const MgrCap& m) {
bool first = true;
for (auto& grant : m.grants) {
if (!first) {
return false;
}
-void MgrCap::encode(bufferlist& bl) const {
+void MgrCap::encode(ceph::buffer::list& bl) const {
// remain backwards compatible w/ MgrCap
ENCODE_START(4, 4, bl);
encode(text, bl);
ENCODE_FINISH(bl);
}
-void MgrCap::decode(bufferlist::const_iterator& bl) {
+void MgrCap::decode(ceph::buffer::list::const_iterator& bl) {
// remain backwards compatible w/ MgrCap
std::string s;
DECODE_START(4, bl);
parse(s, NULL);
}
-void MgrCap::dump(Formatter *f) const {
+void MgrCap::dump(ceph::Formatter *f) const {
f->dump_string("text", text);
}
-void MgrCap::generate_test_instances(list<MgrCap*>& ls) {
+void MgrCap::generate_test_instances(std::list<MgrCap*>& ls) {
ls.push_back(new MgrCap);
ls.push_back(new MgrCap);
ls.back()->parse("allow *");
>> qi::attr(std::string())
>> qi::attr(std::string())
>> qi::attr(std::string())
- >> qi::attr(map<std::string, MgrCapGrantConstraint>())
+ >> qi::attr(std::map<std::string, MgrCapGrantConstraint>())
>> spaces >> rwxa
>> -(spaces >> lit("network") >> spaces >> network_str);
qi::rule<Iterator, MgrCap()> mgrcap;
};
-bool MgrCap::parse(const std::string& str, ostream *err) {
+bool MgrCap::parse(const std::string& str, std::ostream *err) {
auto iter = str.begin();
auto end = str.end();
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, get_last_committed())
using namespace TOPNSPC::common;
+
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
static ostream& _prefix(std::ostream *_dout, Monitor *mon, version_t v) {
return *_dout << "mon." << mon->name << "@" << mon->rank
<< "(" << mon->get_state_name()
decode(supported, indata);
decode(entity_name, indata);
decode(s->con->peer_global_id, indata);
- } catch (const buffer::error &e) {
+ } catch (const ceph::buffer::error &e) {
dout(10) << "failed to decode initial auth message" << dendl;
ret = -EINVAL;
goto reply;
}
ret = 0;
}
- } catch (const buffer::error &err) {
+ } catch (const ceph::buffer::error &err) {
ret = -EINVAL;
dout(0) << "caught error when trying to handle auth request, probably malformed request" << dendl;
}
return -EINVAL;
try {
auth.key.decode_base64(key);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
return -EINVAL;
}
auth.caps = caps;
KeyRing keyring;
try {
decode(keyring, iter);
- } catch (const buffer::error &ex) {
+ } catch (const ceph::buffer::error &ex) {
ss << "error decoding keyring" << " " << ex.what();
err = -EINVAL;
goto done;
auto iter = bl.cbegin();
try {
decode(new_keyring, iter);
- } catch (const buffer::error &ex) {
+ } catch (const ceph::buffer::error &ex) {
ss << "error decoding keyring";
err = -EINVAL;
goto done;
auto it = p->second.caps["mon"].cbegin();
decode(mon_caps, it);
}
- catch (const buffer::error&) {
+ catch (const ceph::buffer::error&) {
dout(10) << __func__ << " unable to parse mon cap for "
<< p->first << dendl;
continue;
#include "mon/PaxosService.h"
#include "mon/MonitorDBStore.h"
-struct MAuth;
+class MAuth;
class KeyRing;
class Monitor;
IncType inc_type;
uint64_t max_global_id;
uint32_t auth_type;
- bufferlist auth_data;
+ ceph::buffer::list auth_data;
Incremental() : inc_type(GLOBAL_ID), max_global_id(0), auth_type(0) {}
- void encode(bufferlist& bl, uint64_t features=-1) const {
+ void encode(ceph::buffer::list& bl, uint64_t features=-1) const {
using ceph::encode;
ENCODE_START(2, 2, bl);
__u32 _type = (__u32)inc_type;
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
__u32 _type;
decode(_type, bl);
}
DECODE_FINISH(bl);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_int("type", inc_type);
f->dump_int("max_global_id", max_global_id);
f->dump_int("auth_type", auth_type);
f->dump_int("auth_data_len", auth_data.length());
}
- static void generate_test_instances(list<Incremental*>& ls) {
+ static void generate_test_instances(std::list<Incremental*>& ls) {
ls.push_back(new Incremental);
ls.push_back(new Incremental);
ls.back()->inc_type = GLOBAL_ID;
private:
- vector<Incremental> pending_auth;
+ std::vector<Incremental> pending_auth;
version_t last_rotating_ver;
uint64_t max_global_id;
uint64_t last_allocated_id;
}
/* validate mon/osd/mds caps; fail on unrecognized service/type */
- bool valid_caps(const string& type, const string& caps, ostream *out);
- bool valid_caps(const string& type, const bufferlist& bl, ostream *out) {
+ bool valid_caps(const std::string& type, const std::string& caps, std::ostream *out);
+ bool valid_caps(const std::string& type, const ceph::buffer::list& bl, std::ostream *out) {
auto p = bl.begin();
- string v;
+ std::string v;
try {
+ using ceph::decode;
decode(v, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
*out << "corrupt capability encoding";
return false;
}
return valid_caps(type, v, out);
}
- bool valid_caps(const vector<string>& caps, ostream *out);
+ bool valid_caps(const std::vector<std::string>& caps, std::ostream *out);
void on_active() override;
bool should_propose(double& delay) override;
int exists_and_matches_entity(
const auth_entity_t& entity,
bool has_secret,
- stringstream& ss);
+ std::stringstream& ss);
int exists_and_matches_entity(
const EntityName& name,
const EntityAuth& auth,
- const map<string,bufferlist>& caps,
+ const std::map<std::string,ceph::buffer::list>& caps,
bool has_secret,
- stringstream& ss);
+ std::stringstream& ss);
int remove_entity(const EntityName &entity);
int add_entity(
const EntityName& name,
const EntityAuth& auth);
public:
- AuthMonitor(Monitor *mn, Paxos *p, const string& service_name)
+ AuthMonitor(Monitor *mn, Paxos *p, const std::string& service_name)
: PaxosService(mn, p, service_name),
last_rotating_ver(0),
max_global_id(0),
const uuid_d& uuid,
EntityName& cephx_entity,
EntityName& lockbox_entity,
- stringstream& ss);
+ std::stringstream& ss);
int do_osd_destroy(
const EntityName& cephx_entity,
const EntityName& lockbox_entity);
int validate_osd_new(
int32_t id,
const uuid_d& uuid,
- const string& cephx_secret,
- const string& lockbox_secret,
+ const std::string& cephx_secret,
+ const std::string& lockbox_secret,
auth_entity_t& cephx_entity,
auth_entity_t& lockbox_entity,
- stringstream& ss);
+ std::stringstream& ss);
- void dump_info(Formatter *f);
+ void dump_info(ceph::Formatter *f);
- bool is_valid_cephx_key(const string& k) {
+ bool is_valid_cephx_key(const std::string& k) {
if (k.empty())
return false;
try {
ea.key.decode_base64(k);
return true;
- } catch (buffer::error& e) { /* fallthrough */ }
+ } catch (ceph::buffer::error& e) { /* fallthrough */ }
return false;
}
};
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, this)
using namespace TOPNSPC::common;
+
+using namespace std::literals;
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::parse_timespan;
+using ceph::timespan_str;
+
static ostream& _prefix(std::ostream *_dout, const Monitor *mon,
const ConfigKeyService *service) {
return *_dout << "mon." << mon->name << "@" << mon->rank
{
Paxos *paxos;
- int store_get(const string &key, bufferlist &bl);
- void store_put(const string &key, bufferlist &bl, Context *cb = NULL);
- void store_delete(MonitorDBStore::TransactionRef t, const string &key);
- void store_delete(const string &key, Context *cb = NULL);
+ int store_get(const std::string &key, ceph::buffer::list &bl);
+ void store_put(const std::string &key, ceph::buffer::list &bl, Context *cb = NULL);
+ void store_delete(MonitorDBStore::TransactionRef t, const std::string &key);
+ void store_delete(const std::string &key, Context *cb = NULL);
void store_delete_prefix(
MonitorDBStore::TransactionRef t,
- const string &prefix);
- void store_list(stringstream &ss);
- void store_dump(stringstream &ss, const string& prefix);
- bool store_exists(const string &key);
- bool store_has_prefix(const string &prefix);
+ const std::string &prefix);
+ void store_list(std::stringstream &ss);
+ void store_dump(std::stringstream &ss, const std::string& prefix);
+ bool store_exists(const std::string &key);
+ bool store_has_prefix(const std::string &prefix);
- static const string STORE_PREFIX;
+ static const std::string STORE_PREFIX;
protected:
void service_shutdown() override { }
void do_osd_destroy(int32_t id, uuid_d& uuid);
int validate_osd_new(
const uuid_d& uuid,
- const string& dmcrypt_key,
- stringstream& ss);
- void do_osd_new(const uuid_d& uuid, const string& dmcrypt_key);
+ const std::string& dmcrypt_key,
+ std::stringstream& ss);
+ void do_osd_new(const uuid_d& uuid, const std::string& dmcrypt_key);
int get_type() override {
return QuorumService::SERVICE_CONFIG_KEY;
}
- string get_name() const override {
+ std::string get_name() const override {
return "config_key";
}
- void get_store_prefixes(set<string>& s) const;
+ void get_store_prefixes(std::set<std::string>& s) const;
/**
* @} // ConfigKeyService_Inherited_h
*/
#include "crush/CrushWrapper.h"
#include "common/entity_name.h"
+using namespace std::literals;
+
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
+
int MaskedOption::get_precision(const CrushWrapper *crush)
{
// 0 = most precise
}
return r;
}
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
};
struct MaskedOption {
- string raw_value; ///< raw, unparsed, unvalidated value
+ std::string raw_value; ///< raw, unparsed, unvalidated value
const Option *opt; ///< the option
OptionMask mask;
- unique_ptr<const Option> unknown_opt; ///< if fabricated for an unknown option
+ std::unique_ptr<const Option> unknown_opt; ///< if fabricated for an unknown option
MaskedOption(const Option *o, bool fab=false) : opt(o) {
if (fab) {
/// return a precision metric (smaller is more precise)
int get_precision(const CrushWrapper *crush);
- friend ostream& operator<<(ostream& out, const MaskedOption& o);
+ friend std::ostream& operator<<(std::ostream& out, const MaskedOption& o);
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
};
struct Section {
void clear() {
options.clear();
}
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
std::string get_minimal_conf() const;
};
by_type.clear();
by_id.clear();
}
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
std::map<std::string,std::string,std::less<>> generate_entity_map(
const EntityName& name,
- const map<std::string,std::string>& crush_location,
+ const std::map<std::string,std::string>& crush_location,
const CrushWrapper *crush,
const std::string& device_class,
- std::map<std::string,pair<std::string,const MaskedOption*>> *src=0);
+ std::map<std::string,std::pair<std::string,const MaskedOption*>> *src=0);
static bool parse_mask(
const std::string& in,
struct ConfigChangeSet {
version_t version;
utime_t stamp;
- string name;
+ std::string name;
// key -> (old value, new value)
- map<string,pair<boost::optional<string>,boost::optional<string>>> diff;
+ std::map<std::string,std::pair<boost::optional<std::string>,boost::optional<std::string>>> diff;
- void dump(Formatter *f) const;
- void print(ostream& out) const;
+ void dump(ceph::Formatter *f) const;
+ void print(std::ostream& out) const;
};
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, this)
using namespace TOPNSPC::common;
+
+using namespace std::literals;
+
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
static ostream& _prefix(std::ostream *_dout, const Monitor *mon,
const ConfigMonitor *hmon) {
return *_dout << "mon." << mon->name << "@" << mon->rank
decode(ch->stamp, p);
decode(ch->name, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
derr << __func__ << " failure decoding changeset " << v << dendl;
}
} else {
{
version_t version = 0;
ConfigMap config_map;
- map<string,boost::optional<bufferlist>> pending;
- string pending_description;
- map<string,boost::optional<bufferlist>> pending_cleanup;
+ std::map<std::string,boost::optional<ceph::buffer::list>> pending;
+ std::string pending_description;
+ std::map<std::string,boost::optional<ceph::buffer::list>> pending_cleanup;
- map<string,bufferlist> current;
+ std::map<std::string,ceph::buffer::list> current;
public:
- ConfigMonitor(Monitor *m, Paxos *p, const string& service_name);
+ ConfigMonitor(Monitor *m, Paxos *p, const std::string& service_name);
void init() override;
#include <map>
#include <set>
+#include <vector>
#include "include/encoding.h"
#include "include/utime.h"
// NOTE: pre-octopus instances of this class will have a
// zeroed-out history
- vector<int> up;
+ std::vector<int> up;
int up_primary = -1;
- vector<int> acting;
+ std::vector<int> acting;
int acting_primary = -1;
pg_history_t history;
PastIntervals past_intervals;
- void encode(bufferlist& bl, uint64_t features) const {
+ void encode(ceph::buffer::list& bl, uint64_t features) const {
using ceph::encode;
if (!HAVE_FEATURE(features, SERVER_OCTOPUS)) {
// was pair<epoch_t,utime_t> prior to octopus
encode(past_intervals, bl);
ENCODE_FINISH(bl);
}
- void decode_legacy(bufferlist::const_iterator& p) {
+ void decode_legacy(ceph::buffer::list::const_iterator& p) {
using ceph::decode;
decode(create_epoch, p);
decode(create_stamp, p);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
using ceph::decode;
DECODE_START(1, p);
decode(create_epoch, p);
decode(past_intervals, p);
DECODE_FINISH(p);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_unsigned("create_epoch", create_epoch);
f->dump_stream("create_stamp") << create_stamp;
f->open_array_section("up");
bool done() const {
return start >= end;
}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
encode(created, bl);
encode(modified, bl);
encode(start, bl);
encode(end, bl);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
using ceph::decode;
decode(created, p);
decode(modified, p);
};
/// queue of pgs we still need to create (poolid -> <created, set of ps>)
- map<int64_t,pool_create_info> queue;
+ std::map<int64_t,pool_create_info> queue;
/// pools that exist in the osdmap for which at least one pg has been created
std::set<int64_t> created_pools;
queue.erase(removed_pool);
return total - pgs.size();
}
- void encode(bufferlist& bl, uint64_t features) const {
+ void encode(ceph::buffer::list& bl, uint64_t features) const {
unsigned v = 3;
if (!HAVE_FEATURE(features, SERVER_OCTOPUS)) {
v = 2;
encode(queue, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
DECODE_START(3, bl);
decode(last_scan_epoch, bl);
if (struct_v >= 3) {
}
f->close_section();
}
- static void generate_test_instances(list<creating_pgs_t*>& o) {
+ static void generate_test_instances(std::list<creating_pgs_t*>& o) {
auto c = new creating_pgs_t;
c->last_scan_epoch = 17;
c->pgs.emplace(pg_t{42, 2}, pg_create_info(31, utime_t{891, 113}));
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#define dout_prefix _prefix(_dout, epoch, elector)
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
static ostream& _prefix(std::ostream *_dout, epoch_t epoch, ElectionOwner* elector) {
return *_dout << "paxos." << elector->get_my_rank()
<< ").electionLogic(" << epoch << ") ";
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, get_epoch())
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
static ostream& _prefix(std::ostream *_dout, Monitor *mon, epoch_t epoch) {
return *_dout << "mon." << mon->name << "@" << mon->rank
<< "(" << mon->get_state_name()
uint64_t cluster_features = 0;
mon_feature_t mon_features;
ceph_release_t mon_release{0};
- map<string,string> metadata;
+ std::map<std::string,std::string> metadata;
};
/**
* Map containing info of all those that acked our proposal to become the Leader.
* Note each peer's info.
*/
- map<int, elector_info_t> peer_info;
+ std::map<int, elector_info_t> peer_info;
/**
* @}
*/
using TOPNSPC::common::cmd_getval;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::ErasureCodeInterfaceRef;
+using ceph::ErasureCodeProfile;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+
static const string EXPERIMENTAL_WARNING("Warning! This feature is experimental."
"It may cause problems up to and including data loss."
"Consult the documentation at ceph.com, and if unsure, do not proceed."
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, this)
using namespace TOPNSPC::common;
+
+using namespace std::literals;
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::parse_timespan;
+using ceph::timespan_str;
static ostream& _prefix(std::ostream *_dout, const Monitor *mon,
const HealthMonitor *hmon) {
return *_dout << "mon." << mon->name << "@" << mon->rank
class HealthMonitor : public PaxosService
{
version_t version = 0;
- map<int,health_check_map_t> quorum_checks; // for each quorum member
+ std::map<int,health_check_map_t> quorum_checks; // for each quorum member
health_check_map_t leader_checks; // leader only
- map<string,health_mute_t> mutes;
+ std::map<std::string,health_mute_t> mutes;
- map<string,health_mute_t> pending_mutes;
+ std::map<std::string,health_mute_t> pending_mutes;
public:
- HealthMonitor(Monitor *m, Paxos *p, const string& service_name);
+ HealthMonitor(Monitor *m, Paxos *p, const std::string& service_name);
/**
* @defgroup HealthMonitor_Inherited_h Inherited abstract methods
void gather_all_health_checks(health_check_map_t *all);
health_status_t get_health_status(
bool want_detail,
- Formatter *f,
+ ceph::Formatter *f,
std::string *plain,
const char *sep1 = " ",
const char *sep2 = "; ");
using namespace TOPNSPC::common;
+using std::cerr;
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
+
string LogMonitor::log_channel_info::get_log_file(const string &channel)
{
dout(25) << __func__ << " for channel '"
dout(10) << __func__ << " v" << version << dendl;
__u8 v = 1;
encode(v, bl);
- multimap<utime_t,LogEntry>::iterator p;
- for (p = pending_log.begin(); p != pending_log.end(); ++p)
+ for (auto p = pending_log.begin(); p != pending_log.end(); ++p)
p->second.encode(bl, mon->get_quorum_con_features());
put_version(t, version, bl);
goto done;
}
- for (deque<LogEntry>::iterator p = m->entries.begin();
+ for (auto p = m->entries.begin();
p != m->entries.end();
++p) {
if (!pending_summary.contains(p->key()))
return false;
}
- for (deque<LogEntry>::iterator p = m->entries.begin();
+ for (auto p = m->entries.begin();
p != m->entries.end();
++p) {
dout(10) << " logging " << *p << dendl;
class MLog;
-static const string LOG_META_CHANNEL = "$channel";
+static const std::string LOG_META_CHANNEL = "$channel";
namespace ceph {
namespace logging {
class LogMonitor : public PaxosService,
public md_config_obs_t {
private:
- multimap<utime_t,LogEntry> pending_log;
+ std::multimap<utime_t,LogEntry> pending_log;
LogSummary pending_summary, summary;
struct log_channel_info {
- map<string,string> log_to_syslog;
- map<string,string> syslog_level;
- map<string,string> syslog_facility;
- map<string,string> log_file;
- map<string,string> expanded_log_file;
- map<string,string> log_file_level;
- map<string,string> log_to_graylog;
- map<string,string> log_to_graylog_host;
- map<string,string> log_to_graylog_port;
-
- map<string, shared_ptr<ceph::logging::Graylog>> graylogs;
+ std::map<std::string,std::string> log_to_syslog;
+ std::map<std::string,std::string> syslog_level;
+ std::map<std::string,std::string> syslog_facility;
+ std::map<std::string,std::string> log_file;
+ std::map<std::string,std::string> expanded_log_file;
+ std::map<std::string,std::string> log_file_level;
+ std::map<std::string,std::string> log_to_graylog;
+ std::map<std::string,std::string> log_to_graylog_host;
+ std::map<std::string,std::string> log_to_graylog_port;
+
+ std::map<std::string, std::shared_ptr<ceph::logging::Graylog>> graylogs;
uuid_d fsid;
- string host;
+ std::string host;
void clear() {
log_to_syslog.clear();
expand_channel_meta(syslog_facility);
expand_channel_meta(log_file_level);
}
- void expand_channel_meta(map<string,string> &m);
- string expand_channel_meta(const string &input,
- const string &change_to);
+ void expand_channel_meta(std::map<std::string,std::string> &m);
+ std::string expand_channel_meta(const std::string &input,
+ const std::string &change_to);
- bool do_log_to_syslog(const string &channel);
+ bool do_log_to_syslog(const std::string &channel);
- string get_facility(const string &channel) {
+ std::string get_facility(const std::string &channel) {
return get_str_map_key(syslog_facility, channel,
&CLOG_CONFIG_DEFAULT_KEY);
}
- string get_level(const string &channel) {
+ std::string get_level(const std::string &channel) {
return get_str_map_key(syslog_level, channel,
&CLOG_CONFIG_DEFAULT_KEY);
}
- string get_log_file(const string &channel);
+ std::string get_log_file(const std::string &channel);
- string get_log_file_level(const string &channel) {
+ std::string get_log_file_level(const std::string &channel) {
return get_str_map_key(log_file_level, channel,
&CLOG_CONFIG_DEFAULT_KEY);
}
- bool do_log_to_graylog(const string &channel) {
+ bool do_log_to_graylog(const std::string &channel) {
return (get_str_map_key(log_to_graylog, channel,
&CLOG_CONFIG_DEFAULT_KEY) == "true");
}
- shared_ptr<ceph::logging::Graylog> get_graylog(const string &channel);
+ std::shared_ptr<ceph::logging::Graylog> get_graylog(const std::string &channel);
} channels;
void update_log_channels();
void _create_sub_incremental(MLog *mlog, int level, version_t sv);
public:
- LogMonitor(Monitor *mn, Paxos *p, const string& service_name)
+ LogMonitor(Monitor *mn, Paxos *p, const std::string& service_name)
: PaxosService(mn, p, service_name) { }
void init() override {
* @param n name
* @return id, or -1 if unrecognized
*/
- int sub_name_to_id(const string& n);
+ int sub_name_to_id(const std::string& n);
void on_shutdown() override {
g_conf().remove_observer(this);
#include "mds/mdstypes.h"
#include "Session.h"
+using namespace TOPNSPC::common;
+
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::ErasureCodeInterfaceRef;
+using ceph::ErasureCodeProfile;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, get_fsmap())
-using namespace TOPNSPC::common;
-
static ostream& _prefix(std::ostream *_dout, Monitor *mon, const FSMap& fsmap) {
return *_dout << "mon." << mon->name << "@" << mon->rank
<< "(" << mon->get_state_name()
for (const auto& p : last_beacon) {
latest_beacon = std::max(p.second.stamp, latest_beacon);
}
- auto since = chrono::duration<double>(now-latest_beacon);
+ auto since = std::chrono::duration<double>(now-latest_beacon);
const bool may_replace = since.count() <
std::max(g_conf()->mds_beacon_interval, g_conf()->mds_beacon_grace * 0.5);
std::vector<mds_gid_t> to_remove;
for (auto it = last_beacon.begin(); it != last_beacon.end(); ) {
auto& [gid, beacon_info] = *it;
- auto since_last = chrono::duration<double>(now-beacon_info.stamp);
+ auto since_last = std::chrono::duration<double>(now-beacon_info.stamp);
if (!fsmap.gid_exists(gid)) {
// gid no longer exists, remove from tracked beacons
class MDSMonitor : public PaxosService, public PaxosFSMap, protected CommandHandler {
public:
- MDSMonitor(Monitor *mn, Paxos *p, string service_name);
+ MDSMonitor(Monitor *mn, Paxos *p, std::string service_name);
// service methods
void create_initial() override;
- void get_store_prefixes(std::set<string>& s) const override;
+ void get_store_prefixes(std::set<std::string>& s) const override;
void update_from_paxos(bool *need_bootstrap) override;
void init() override;
- void create_pending() override;
+ void create_pending() override;
void encode_pending(MonitorDBStore::TransactionRef t) override;
// we don't require full versions; don't encode any.
void encode_full(MonitorDBStore::TransactionRef t) override { }
void check_subs();
void check_sub(Subscription *sub);
- void dump_info(Formatter *f);
- int print_nodes(Formatter *f);
+ void dump_info(ceph::Formatter *f);
+ int print_nodes(ceph::Formatter *f);
/**
* Return true if a blacklist was done (i.e. OSD propose needed)
// beacons
struct beacon_info_t {
- mono_time stamp = mono_clock::zero();
+ ceph::mono_time stamp = ceph::mono_clock::zero();
uint64_t seq = 0;
beacon_info_t() {}
- beacon_info_t(mono_time stamp, uint64_t seq) : stamp(stamp), seq(seq) {}
+ beacon_info_t(ceph::mono_time stamp, uint64_t seq) : stamp(stamp), seq(seq) {}
};
- map<mds_gid_t, beacon_info_t> last_beacon;
+ std::map<mds_gid_t, beacon_info_t> last_beacon;
std::list<std::shared_ptr<FileSystemCommandHandler> > handlers;
bool check_health(FSMap &fsmap, bool* osd_propose);
void tick() override; // check state, take actions
- int dump_metadata(const FSMap &fsmap, const std::string &who, Formatter *f,
- ostream& err);
+ int dump_metadata(const FSMap &fsmap, const std::string &who, ceph::Formatter *f,
+ std::ostream& err);
void update_metadata(mds_gid_t gid, const Metadata& metadata);
void remove_from_metadata(const FSMap &fsmap, MonitorDBStore::TransactionRef t);
- int load_metadata(map<mds_gid_t, Metadata>& m);
- void count_metadata(const std::string& field, Formatter *f);
+ int load_metadata(std::map<mds_gid_t, Metadata>& m);
+ void count_metadata(const std::string& field, ceph::Formatter *f);
public:
- void count_metadata(const std::string& field, map<string,int> *out);
+ void count_metadata(const std::string& field, std::map<std::string,int> *out);
protected:
// MDS daemon GID to latest health state from that GID
std::map<uint64_t, MDSHealth> pending_daemon_health;
std::set<uint64_t> pending_daemon_health_rm;
- map<mds_gid_t, Metadata> pending_metadata;
+ std::map<mds_gid_t, Metadata> pending_metadata;
mds_gid_t gid_from_arg(const FSMap &fsmap, const std::string &arg, std::ostream& err);
// When did the mon last call into our tick() method? Used for detecting
// when the mon was not updating us for some period (e.g. during slow
// election) to reset last_beacon timeouts
- mono_time last_tick = mono_clock::zero();
+ ceph::mono_time last_tick = ceph::mono_clock::zero();
};
#endif
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, map)
using namespace TOPNSPC::common;
+
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::ErasureCodeInterfaceRef;
+using ceph::ErasureCodeProfile;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+
static ostream& _prefix(std::ostream *_dout, Monitor *mon,
const MgrMap& mgrmap) {
return *_dout << "mon." << mon->name << "@" << mon->rank
auto p = bl.cbegin();
decode(m, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
if (err)
*err << "mgr." << name << " metadata is corrupt";
return -EIO;
MgrMap pending_map;
bool ever_had_active_mgr = false;
- std::map<std::string, bufferlist> pending_metadata;
- std::set<std::string> pending_metadata_rm;
+ std::map<std::string, ceph::buffer::list> pending_metadata;
+ std::set<std::string> pending_metadata_rm;
std::map<std::string,Option> mgr_module_options;
std::list<std::string> misc_option_strings;
std::vector<MonCommand> pending_command_descs;
public:
- MgrMonitor(Monitor *mn, Paxos *p, const string& service_name)
+ MgrMonitor(Monitor *mn, Paxos *p, const std::string& service_name)
: PaxosService(mn, p, service_name)
{}
~MgrMonitor() override {}
const std::map<std::string,Option>& get_mgr_module_options() {
return mgr_module_options;
}
- const Option *find_module_option(const string& name);
+ const Option *find_module_option(const std::string& name);
bool in_use() const { return map.epoch > 0; }
void prime_mgr_client();
void create_initial() override;
- void get_store_prefixes(std::set<string>& s) const override;
+ void get_store_prefixes(std::set<std::string>& s) const override;
void update_from_paxos(bool *need_bootstrap) override;
void post_paxos_update() override;
void create_pending() override;
void tick() override;
- void print_summary(Formatter *f, std::ostream *ss) const;
+ void print_summary(ceph::Formatter *f, std::ostream *ss) const;
const std::vector<MonCommand> &get_command_descs() const;
- int load_metadata(const string& name, std::map<string, string>& m,
- ostream *err) const;
- int dump_metadata(const string& name, Formatter *f, ostream *err);
- void print_nodes(Formatter *f) const;
- void count_metadata(const string& field, Formatter *f);
- void count_metadata(const string& field, std::map<string,int> *out);
+ int load_metadata(const std::string& name, std::map<std::string, std::string>& m,
+ std::ostream *err) const;
+ int dump_metadata(const std::string& name, ceph::Formatter *f, std::ostream *err);
+ void print_nodes(ceph::Formatter *f) const;
+ void count_metadata(const std::string& field, ceph::Formatter *f);
+ void count_metadata(const std::string& field, std::map<std::string,int> *out);
// When did the mon last call into our tick() method? Used for detecting
// when the mon was not updating us for some period (e.g. during slow
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon)
+
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::ErasureCodeInterfaceRef;
+using ceph::ErasureCodeProfile;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+
static ostream& _prefix(std::ostream *_dout, Monitor *mon) {
return *_dout << "mon." << mon->name << "@" << mon->rank
<< "(" << mon->get_state_name()
<< " " << progress_events.size() << " progress events"
<< dendl;
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
derr << "failed to decode mgrstat state; luminous dev version? "
<< e.what() << dendl;
}
PGMapDigest pending_digest;
health_check_map_t pending_health_checks;
std::map<std::string,ProgressEvent> pending_progress_events;
- bufferlist pending_service_map_bl;
+ ceph::buffer::list pending_service_map_bl;
public:
- MgrStatMonitor(Monitor *mn, Paxos *p, const string& service_name);
+ MgrStatMonitor(Monitor *mn, Paxos *p, const std::string& service_name);
~MgrStatMonitor() override;
void init() override {}
return digest.get_statfs(osdmap, data_pool);
}
- void print_summary(Formatter *f, ostream *out) const {
+ void print_summary(ceph::Formatter *f, std::ostream *out) const {
digest.print_summary(f, out);
}
- void dump_info(Formatter *f) const {
+ void dump_info(ceph::Formatter *f) const {
digest.dump(f);
f->dump_object("servicemap", get_service_map());
}
- void dump_cluster_stats(stringstream *ss,
- Formatter *f,
- bool verbose) const {
+ void dump_cluster_stats(std::stringstream *ss,
+ ceph::Formatter *f,
+ bool verbose) const {
digest.dump_cluster_stats(ss, f, verbose);
}
- void dump_pool_stats(const OSDMap& osdm, stringstream *ss, Formatter *f,
+ void dump_pool_stats(const OSDMap& osdm, std::stringstream *ss, ceph::Formatter *f,
bool verbose) const {
digest.dump_pool_stats_full(osdm, ss, f, verbose);
}
forwarded_to_leader = true;
}
- void mark_svc_event(const string &service, const string &event) {
- string s = service;
+ void mark_svc_event(const std::string &service, const std::string &event) {
+ std::string s = service;
s.append(":").append(event);
mark_event(s);
}
- void mark_logmon_event(const string &event) {
+ void mark_logmon_event(const std::string &event) {
mark_svc_event("logm", event);
}
- void mark_osdmon_event(const string &event) {
+ void mark_osdmon_event(const std::string &event) {
mark_svc_event("osdmap", event);
}
- void mark_pgmon_event(const string &event) {
+ void mark_pgmon_event(const std::string &event) {
mark_svc_event("pgmap", event);
}
- void mark_mdsmon_event(const string &event) {
+ void mark_mdsmon_event(const std::string &event) {
mark_svc_event("mdsmap", event);
}
- void mark_authmon_event(const string &event) {
+ void mark_authmon_event(const std::string &event) {
mark_svc_event("auth", event);
}
- void mark_paxos_event(const string &event) {
+ void mark_paxos_event(const std::string &event) {
mark_svc_event("paxos", event);
}
}
}
- void _dump(Formatter *f) const override {
+ void _dump(ceph::Formatter *f) const override {
{
f->open_array_section("events");
std::lock_guard l(lock);
}
protected:
- void _dump_op_descriptor_unlocked(ostream& stream) const override {
+ void _dump_op_descriptor_unlocked(std::ostream& stream) const override {
get_req()->print(stream);
}
_finish(r);
}
- void mark_op_event(const string &event) {
+ void mark_op_event(const std::string &event) {
if (op)
op->mark_event(event);
}
#undef dout_prefix
#define dout_prefix _prefix(_dout, this)
using namespace TOPNSPC::common;
+
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::ErasureCodeInterfaceRef;
+using ceph::ErasureCodeProfile;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
+
+
static ostream& _prefix(std::ostream *_dout, const Monitor *mon) {
return *_dout << "mon." << mon->name << "@" << mon->rank
<< "(" << mon->get_state_name() << ") e" << mon->monmap->get_epoch() << " ";
auto p = bl.cbegin();
decode(fingerprint, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
dout(10) << __func__ << " failed to decode cluster_fingerprint" << dendl;
}
} else {
OSDMap om;
om.decode(osdmapbl);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
derr << "error decoding provided osdmap: " << e.what() << dendl;
return -EINVAL;
}
auto i = bl.cbegin();
keyring.decode_plaintext(i);
}
- catch (const buffer::error& e) {
+ catch (const ceph::buffer::error& e) {
derr << "error decoding keyring " << keyring_plaintext
<< ": " << e.what() << dendl;
return -EINVAL;
assert(mode >= AUTH_MODE_MON && mode <= AUTH_MODE_MON_MAX);
decode(entity_name, p);
decode(con->peer_global_id, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
dout(1) << __func__ << " failed to decode, " << e.what() << dendl;
return -EACCES;
}
string str;
try {
decode(str, p);
- } catch (const buffer::error &err) {
+ } catch (const ceph::buffer::error &err) {
derr << __func__ << " corrupt cap data for " << con->get_peer_entity_name()
<< " in auth db" << dendl;
str.clear();
-// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
- * License version 2.1, as published by the Free Software
+ * License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
- *
+ *
*/
-/*
- * This is the top level monitor. It runs on each machine in the Monitor
- * Cluster. The election of a leader for the paxos algorithm only happens
- * once per machine via the elector. There is a separate paxos instance (state)
- * kept for each of the system components: Object Store Device (OSD) Monitor,
+/*
+ * This is the top level monitor. It runs on each machine in the Monitor
+ * Cluster. The election of a leader for the paxos algorithm only happens
+ * once per machine via the elector. There is a separate paxos instance (state)
+ * kept for each of the system components: Object Store Device (OSD) Monitor,
* Placement Group (PG) Monitor, Metadata Server (MDS) Monitor, and Client Monitor.
*/
const char **orig_argv = nullptr;
// me
- string name;
+ std::string name;
int rank;
Messenger *messenger;
ConnectionRef con_self;
MonMap *monmap;
uuid_d fingerprint;
- set<entity_addrvec_t> extra_probe_peers;
+ std::set<entity_addrvec_t> extra_probe_peers;
LogClient log_client;
LogChannelRef clog;
CompatSet features;
- vector<MonCommand> leader_mon_commands; // quorum leader's commands
- vector<MonCommand> local_mon_commands; // commands i support
- bufferlist local_mon_commands_bl; // encoded version of above
+ std::vector<MonCommand> leader_mon_commands; // quorum leader's commands
+ std::vector<MonCommand> local_mon_commands; // commands i support
+ ceph::buffer::list local_mon_commands_bl; // encoded version of above
- vector<MonCommand> prenautilus_local_mon_commands;
- bufferlist prenautilus_local_mon_commands_bl;
+ std::vector<MonCommand> prenautilus_local_mon_commands;
+ ceph::buffer::list prenautilus_local_mon_commands_bl;
Messenger *mgr_messenger;
MgrClient mgr_client;
// -- local storage --
public:
MonitorDBStore *store;
- static const string MONITOR_NAME;
- static const string MONITOR_STORE_PREFIX;
+ static const std::string MONITOR_NAME;
+ static const std::string MONITOR_STORE_PREFIX;
// -- monitor state --
private:
uint64_t required_features;
int leader; // current leader (to best of knowledge)
- set<int> quorum; // current active set of monitors (if !starting)
- mono_clock::time_point quorum_since; // when quorum formed
+ std::set<int> quorum; // current active set of monitors (if !starting)
+ ceph::mono_clock::time_point quorum_since; // when quorum formed
utime_t leader_since; // when this monitor became the leader, if it is the leader
utime_t exited_quorum; // time detected as not in quorum; 0 if in
// map of counts of connected clients, by type and features, for
// each quorum mon
- map<int,FeatureMap> quorum_feature_map;
+ std::map<int,FeatureMap> quorum_feature_map;
/**
* Intersection of quorum member's connection feature bits.
ceph_release_t quorum_min_mon_release{ceph_release_t::unknown};
- set<string> outside_quorum;
+ std::set<std::string> outside_quorum;
/**
* @defgroup Monitor_h_scrub
* @{
*/
version_t scrub_version; ///< paxos version we are scrubbing
- map<int,ScrubResult> scrub_result; ///< results so far
+ std::map<int,ScrubResult> scrub_result; ///< results so far
/**
* trigger a cross-mon scrub
int scrub();
void handle_scrub(MonOpRequestRef op);
bool _scrub(ScrubResult *r,
- pair<string,string> *start,
+ std::pair<std::string,std::string> *start,
int *num_keys);
void scrub_check_results();
void scrub_timeout();
void scrub_cancel_timeout();
struct ScrubState {
- pair<string,string> last_key; ///< last scrubbed key
+ std::pair<std::string,std::string> last_key; ///< last scrubbed key
bool finished;
ScrubState() : finished(false) { }
uint64_t cookie; ///< unique cookie for this sync attempt
utime_t timeout; ///< when we give up and expire this attempt
version_t last_committed; ///< last paxos version on peer
- pair<string,string> last_key; ///< last key sent to (or on) peer
+ std::pair<std::string,std::string> last_key; ///< last key sent to (or on) peer
bool full; ///< full scan?
MonitorDBStore::Synchronizer synchronizer; ///< iterator
}
};
- map<uint64_t, SyncProvider> sync_providers; ///< cookie -> SyncProvider for those syncing from us
+ std::map<std::uint64_t, SyncProvider> sync_providers; ///< cookie -> SyncProvider for those syncing from us
uint64_t sync_provider_count; ///< counter for issued cookies to keep them unique
/**
*
* @returns a set of strings referring to the prefixes being synchronized
*/
- set<string> get_sync_targets_names();
+ std::set<std::string> get_sync_targets_names();
/**
* Reset the monitor's sync-related data structures for syncing *from* a peer
/**
* Get the latest monmap for backup purposes during sync
*/
- void sync_obtain_latest_monmap(bufferlist &bl);
+ void sync_obtain_latest_monmap(ceph::buffer::list &bl);
/**
* Start sync process
/**
* force a sync on next mon restart
*/
- void sync_force(Formatter *f);
+ void sync_force(ceph::Formatter *f);
private:
/**
* @} // Synchronization
*/
- list<Context*> waitfor_quorum;
- list<Context*> maybe_wait_for_quorum;
+ std::list<Context*> waitfor_quorum;
+ std::list<Context*> maybe_wait_for_quorum;
/**
* @defgroup Monitor_h_TimeCheck Monitor Clock Drift Early Warning System
* - Once all the quorum members have pong'ed, the leader will share the
* clock skew and latency maps with all the monitors in the quorum.
*/
- map<int, utime_t> timecheck_waiting;
- map<int, double> timecheck_skews;
- map<int, double> timecheck_latencies;
+ std::map<int, utime_t> timecheck_waiting;
+ std::map<int, double> timecheck_skews;
+ std::map<int, double> timecheck_latencies;
// odd value means we are mid-round; even value means the round has
// finished.
version_t timecheck_round;
void timecheck_check_skews();
void timecheck_report();
void timecheck();
- health_status_t timecheck_status(ostringstream &ss,
+ health_status_t timecheck_status(std::ostringstream &ss,
const double skew_bound,
const double latency);
void handle_timecheck_leader(MonOpRequestRef op);
public:
epoch_t get_epoch();
int get_leader() const { return leader; }
- string get_leader_name() {
- return quorum.empty() ? string() : monmap->get_name(*quorum.begin());
+ std::string get_leader_name() {
+ return quorum.empty() ? std::string() : monmap->get_name(*quorum.begin());
}
- const set<int>& get_quorum() const { return quorum; }
- list<string> get_quorum_names() {
- list<string> q;
- for (set<int>::iterator p = quorum.begin(); p != quorum.end(); ++p)
+ const std::set<int>& get_quorum() const { return quorum; }
+ std::list<std::string> get_quorum_names() {
+ std::list<std::string> q;
+ for (auto p = quorum.begin(); p != quorum.end(); ++p)
q.push_back(monmap->get_name(*p));
return q;
}
void start_election();
void win_standalone_election();
// end election (called by Elector)
- void win_election(epoch_t epoch, const set<int>& q,
+ void win_election(epoch_t epoch, const std::set<int>& q,
uint64_t features,
const mon_feature_t& mon_features,
ceph_release_t min_mon_release,
- const map<int,Metadata>& metadata);
- void lose_election(epoch_t epoch, set<int>& q, int l,
+ const std::map<int,Metadata>& metadata);
+ void lose_election(epoch_t epoch, std::set<int>& q, int l,
uint64_t features,
const mon_feature_t& mon_features,
ceph_release_t min_mon_release);
/**
* Vector holding the Services serviced by this Monitor.
*/
- vector<std::unique_ptr<PaxosService>> paxos_service;
+
std::vector<std::unique_ptr<PaxosService>> paxos_service;
class MDSMonitor *mdsmon() {
return (class MDSMonitor *)paxos_service[PAXOS_MDSMAP].get();
void handle_mon_get_map(MonOpRequestRef op);
static void _generate_command_map(cmdmap_t& cmdmap,
- map<string,string> ¶m_str_map);
+ std::map<std::string,std::string> ¶m_str_map);
static const MonCommand *_get_moncommand(
- const string &cmd_prefix,
- const vector<MonCommand>& cmds);
- bool _allowed_command(MonSession *s, const string& module,
- const string& prefix,
+ const std::string &cmd_prefix,
+ const std::vector<MonCommand>& cmds);
+ bool _allowed_command(MonSession *s, const std::string& module,
+ const std::string& prefix,
const cmdmap_t& cmdmap,
- const map<string,string>& param_str_map,
+ const std::map<std::string,std::string>& param_str_map,
const MonCommand *this_cmd);
- void get_mon_status(Formatter *f);
- void _quorum_status(Formatter *f, ostream& ss);
+ void get_mon_status(ceph::Formatter *f);
+ void _quorum_status(ceph::Formatter *f, std::ostream& ss);
bool _add_bootstrap_peer_hint(std::string_view cmd, const cmdmap_t& cmdmap,
std::ostream& ss);
void handle_tell_command(MonOpRequestRef op);
void handle_route(MonOpRequestRef op);
void handle_mon_metadata(MonOpRequestRef op);
- int get_mon_metadata(int mon, Formatter *f, ostream& err);
- int print_nodes(Formatter *f, ostream& err);
+ int get_mon_metadata(int mon, ceph::Formatter *f, std::ostream& err);
+ int print_nodes(ceph::Formatter *f, std::ostream& err);
// Accumulate metadata across calls to update_mon_metadata
- map<int, Metadata> mon_metadata;
- map<int, Metadata> pending_metadata;
+ std::map<int, Metadata> mon_metadata;
+ std::map<int, Metadata> pending_metadata;
/**
*
*/
struct health_cache_t {
health_status_t overall;
- string summary;
+ std::string summary;
void reset() {
// health_status_t doesn't really have a NONE value and we're not
public:
- void get_cluster_status(stringstream &ss, Formatter *f);
+ void get_cluster_status(std::stringstream &ss, ceph::Formatter *f);
- void reply_command(MonOpRequestRef op, int rc, const string &rs, version_t version);
- void reply_command(MonOpRequestRef op, int rc, const string &rs, bufferlist& rdata, version_t version);
+ void reply_command(MonOpRequestRef op, int rc, const std::string &rs, version_t version);
+ void reply_command(MonOpRequestRef op, int rc, const std::string &rs, ceph::buffer::list& rdata, version_t version);
- void reply_tell_command(MonOpRequestRef op, int rc, const string &rs);
+ void reply_tell_command(MonOpRequestRef op, int rc, const std::string &rs);
// request routing
struct RoutedRequest {
uint64_t tid;
- bufferlist request_bl;
+ ceph::buffer::list request_bl;
MonSession *session;
ConnectionRef con;
uint64_t con_features;
}
};
uint64_t routed_request_tid;
- map<uint64_t, RoutedRequest*> routed_requests;
-
+ std::map<uint64_t, RoutedRequest*> routed_requests;
+
void forward_request_leader(MonOpRequestRef op);
void handle_forward(MonOpRequestRef op);
void send_reply(MonOpRequestRef op, Message *reply);
struct C_Command : public C_MonOp {
Monitor *mon;
int rc;
- string rs;
- bufferlist rdata;
+ std::string rs;
+ ceph::buffer::list rdata;
version_t version;
- C_Command(Monitor *_mm, MonOpRequestRef _op, int r, string s, version_t v) :
+ C_Command(Monitor *_mm, MonOpRequestRef _op, int r, std::string s, version_t v) :
C_MonOp(_op), mon(_mm), rc(r), rs(s), version(v){}
- C_Command(Monitor *_mm, MonOpRequestRef _op, int r, string s, bufferlist rd, version_t v) :
+ C_Command(Monitor *_mm, MonOpRequestRef _op, int r, std::string s, ceph::buffer::list rd, version_t v) :
C_MonOp(_op), mon(_mm), rc(r), rs(s), rdata(rd), version(v){}
void _finish(int r) override {
auto m = op->get_req<MMonCommand>();
if (r >= 0) {
- ostringstream ss;
+ std::ostringstream ss;
if (!op->get_req()->get_connection()) {
ss << "connection dropped for command ";
} else {
Connection *con,
AuthConnectionMeta *auth_meta,
uint32_t *method,
- vector<uint32_t> *preferred_modes,
- bufferlist *out) override;
+ std::vector<uint32_t> *preferred_modes,
+ ceph::buffer::list *out) override;
int handle_auth_reply_more(
Connection *con,
AuthConnectionMeta *auth_meta,
- const bufferlist& bl,
- bufferlist *reply) override;
+ const ceph::buffer::list& bl,
+ ceph::buffer::list *reply) override;
int handle_auth_done(
Connection *con,
AuthConnectionMeta *auth_meta,
uint64_t global_id,
uint32_t con_mode,
- const bufferlist& bl,
+ const ceph::buffer::list& bl,
CryptoKey *session_key,
std::string *connection_secret) override;
int handle_auth_bad_method(
AuthConnectionMeta *auth_meta,
bool more,
uint32_t auth_method,
- const bufferlist& bl,
- bufferlist *reply) override;
+ const ceph::buffer::list& bl,
+ ceph::buffer::list *reply) override;
// /AuthServer
- int write_default_keyring(bufferlist& bl);
+ int write_default_keyring(ceph::buffer::list& bl);
void extract_save_mon_key(KeyRing& keyring);
void collect_metadata(Metadata *m);
void update_mon_metadata(int from, Metadata&& m);
int load_metadata();
- void count_metadata(const string& field, Formatter *f);
- void count_metadata(const string& field, map<string,int> *out);
+ void count_metadata(const std::string& field, ceph::Formatter *f);
+ void count_metadata(const std::string& field, std::map<std::string,int> *out);
// features
static CompatSet get_initial_supported_features();
OpTracker op_tracker;
public:
- Monitor(CephContext *cct_, string nm, MonitorDBStore *s,
+ Monitor(CephContext *cct_, std::string nm, MonitorDBStore *s,
Messenger *m, Messenger *mgr_m, MonMap *map);
~Monitor() override;
void handle_signal(int sig);
- int mkfs(bufferlist& osdmapbl);
+ int mkfs(ceph::buffer::list& osdmapbl);
/**
* check cluster_fsid file
int write_fsid(MonitorDBStore::TransactionRef t);
int do_admin_command(std::string_view command, const cmdmap_t& cmdmap,
- Formatter *f,
+ ceph::Formatter *f,
std::ostream& err,
std::ostream& out);
public:
static void format_command_descriptions(const std::vector<MonCommand> &commands,
- Formatter *f,
+ ceph::Formatter *f,
uint64_t features,
- bufferlist *rdata);
+ ceph::buffer::list *rdata);
const std::vector<MonCommand> &get_local_commands(mon_feature_t f) {
if (f.contains_all(ceph::features::mon::FEATURE_NAUTILUS)) {
return prenautilus_local_mon_commands;
}
}
- const bufferlist& get_local_commands_bl(mon_feature_t f) {
+ const ceph::buffer::list& get_local_commands_bl(mon_feature_t f) {
if (f.contains_all(ceph::features::mon::FEATURE_NAUTILUS)) {
return local_mon_commands_bl;
} else {
class MonitorDBStore
{
- string path;
+ std::string path;
boost::scoped_ptr<KeyValueDB> db;
bool do_dump;
int dump_fd_binary;
std::ofstream dump_fd_json;
- JSONFormatter dump_fmt;
+ ceph::JSONFormatter dump_fmt;
Finisher io_work;
public:
- string get_devname() {
+ std::string get_devname() {
char devname[4096] = {0}, partition[4096];
get_device_by_path(path.c_str(), partition, devname,
sizeof(devname));
struct Op {
uint8_t type;
- string prefix;
- string key, endkey;
- bufferlist bl;
+ std::string prefix;
+ std::string key, endkey;
+ ceph::buffer::list bl;
Op()
: type(0) { }
- Op(int t, const string& p, const string& k)
+ Op(int t, const std::string& p, const std::string& k)
: type(t), prefix(p), key(k) { }
- Op(int t, const string& p, const string& k, const bufferlist& b)
+ Op(int t, const std::string& p, const std::string& k, const ceph::buffer::list& b)
: type(t), prefix(p), key(k), bl(b) { }
- Op(int t, const string& p, const string& start, const string& end)
+ Op(int t, const std::string& p, const std::string& start, const std::string& end)
: type(t), prefix(p), key(start), endkey(end) { }
- void encode(bufferlist& encode_bl) const {
+ void encode(ceph::buffer::list& encode_bl) const {
ENCODE_START(2, 1, encode_bl);
encode(type, encode_bl);
encode(prefix, encode_bl);
ENCODE_FINISH(encode_bl);
}
- void decode(bufferlist::const_iterator& decode_bl) {
+ void decode(ceph::buffer::list::const_iterator& decode_bl) {
DECODE_START(2, decode_bl);
decode(type, decode_bl);
decode(prefix, decode_bl);
DECODE_FINISH(decode_bl);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_int("type", type);
f->dump_string("prefix", prefix);
f->dump_string("key", key);
4 + bl.length();
}
- static void generate_test_instances(list<Op*>& ls) {
+ static void generate_test_instances(std::list<Op*>& ls) {
ls.push_back(new Op);
// we get coverage here from the Transaction instances
}
struct Transaction;
typedef std::shared_ptr<Transaction> TransactionRef;
struct Transaction {
- list<Op> ops;
+ std::list<Op> ops;
uint64_t bytes, keys;
Transaction() : bytes(6 + 4 + 8*2), keys(0) {}
OP_ERASE_RANGE = 4,
};
- void put(const string& prefix, const string& key, const bufferlist& bl) {
+ void put(const std::string& prefix, const std::string& key, const ceph::buffer::list& bl) {
ops.push_back(Op(OP_PUT, prefix, key, bl));
++keys;
bytes += ops.back().approx_size();
}
- void put(const string& prefix, version_t ver, const bufferlist& bl) {
- ostringstream os;
+ void put(const std::string& prefix, version_t ver, const ceph::buffer::list& bl) {
+ std::ostringstream os;
os << ver;
put(prefix, os.str(), bl);
}
- void put(const string& prefix, const string& key, version_t ver) {
+ void put(const std::string& prefix, const std::string& key, version_t ver) {
using ceph::encode;
- bufferlist bl;
+ ceph::buffer::list bl;
encode(ver, bl);
put(prefix, key, bl);
}
- void erase(const string& prefix, const string& key) {
+ void erase(const std::string& prefix, const std::string& key) {
ops.push_back(Op(OP_ERASE, prefix, key));
++keys;
bytes += ops.back().approx_size();
}
- void erase(const string& prefix, version_t ver) {
- ostringstream os;
+ void erase(const std::string& prefix, version_t ver) {
+ std::ostringstream os;
os << ver;
erase(prefix, os.str());
}
- void erase_range(const string& prefix, const string& begin,
- const string& end) {
+ void erase_range(const std::string& prefix, const std::string& begin,
+ const std::string& end) {
ops.push_back(Op(OP_ERASE_RANGE, prefix, begin, end));
++keys;
bytes += ops.back().approx_size();
}
- void compact_prefix(const string& prefix) {
- ops.push_back(Op(OP_COMPACT, prefix, string()));
+ void compact_prefix(const std::string& prefix) {
+ ops.push_back(Op(OP_COMPACT, prefix, {}));
}
- void compact_range(const string& prefix, const string& start,
- const string& end) {
+ void compact_range(const std::string& prefix, const std::string& start,
+ const std::string& end) {
ops.push_back(Op(OP_COMPACT, prefix, start, end));
}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
ENCODE_START(2, 1, bl);
encode(ops, bl);
encode(bytes, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
DECODE_START(2, bl);
decode(ops, bl);
if (struct_v >= 2) {
DECODE_FINISH(bl);
}
- static void generate_test_instances(list<Transaction*>& ls) {
+ static void generate_test_instances(std::list<Transaction*>& ls) {
ls.push_back(new Transaction);
ls.push_back(new Transaction);
- bufferlist bl;
+ ceph::buffer::list bl;
bl.append("value");
ls.back()->put("prefix", "key", bl);
ls.back()->erase("prefix2", "key2");
bytes += other->bytes;
}
- void append_from_encoded(bufferlist& bl) {
+ void append_from_encoded(ceph::buffer::list& bl) {
auto other(std::make_shared<Transaction>());
auto it = bl.cbegin();
other->decode(it);
void dump(ceph::Formatter *f, bool dump_val=false) const {
f->open_object_section("transaction");
f->open_array_section("ops");
- list<Op>::const_iterator it;
int op_num = 0;
- for (it = ops.begin(); it != ops.end(); ++it) {
+ for (auto it = ops.begin(); it != ops.end(); ++it) {
const Op& op = *it;
f->open_object_section("op");
f->dump_int("op_num", op_num++);
f->dump_string("key", op.key);
f->dump_unsigned("length", op.bl.length());
if (dump_val) {
- ostringstream os;
+ std::ostringstream os;
op.bl.hexdump(os);
f->dump_string("bl", os.str());
}
if (do_dump) {
if (!g_conf()->mon_debug_dump_json) {
- bufferlist bl;
+ ceph::buffer::list bl;
t->encode(bl);
bl.write_fd(dump_fd_binary);
} else {
}
}
- list<pair<string, pair<string,string> > > compact;
- for (list<Op>::const_iterator it = t->ops.begin();
- it != t->ops.end();
- ++it) {
+ std::list<std::pair<std::string, std::pair<std::string,std::string>>> compact;
+ for (auto it = t->ops.begin(); it != t->ops.end(); ++it) {
const Op& op = *it;
switch (op.type) {
case Transaction::OP_PUT:
int r = db->submit_transaction_sync(dbt);
if (r >= 0) {
while (!compact.empty()) {
- if (compact.front().second.first == string() &&
- compact.front().second.second == string())
+ if (compact.front().second.first == std::string() &&
+ compact.front().second.second == std::string())
db->compact_prefix_async(compact.front().first);
else
db->compact_range_async(compact.front().first, compact.front().second.first, compact.front().second.second);
class StoreIteratorImpl {
protected:
bool done;
- pair<string,string> last_key;
- bufferlist crc_bl;
+ std::pair<std::string,std::string> last_key;
+ ceph::buffer::list crc_bl;
StoreIteratorImpl() : done(false) { }
virtual ~StoreIteratorImpl() { }
return crc_bl.crc32c(0);
return 0;
}
- pair<string,string> get_last_key() {
+ std::pair<std::string,std::string> get_last_key() {
return last_key;
}
virtual bool has_next_chunk() {
}
virtual void get_chunk_tx(TransactionRef tx, uint64_t max_bytes,
uint64_t max_keys) = 0;
- virtual pair<string,string> get_next_key() = 0;
+ virtual std::pair<std::string,std::string> get_next_key() = 0;
};
typedef std::shared_ptr<StoreIteratorImpl> Synchronizer;
class WholeStoreIteratorImpl : public StoreIteratorImpl {
KeyValueDB::WholeSpaceIterator iter;
- set<string> sync_prefixes;
+ std::set<std::string> sync_prefixes;
public:
WholeStoreIteratorImpl(KeyValueDB::WholeSpaceIterator iter,
- set<string> &prefixes)
+ std::set<std::string> &prefixes)
: StoreIteratorImpl(),
iter(iter),
sync_prefixes(prefixes)
*/
void get_chunk_tx(TransactionRef tx, uint64_t max_bytes,
uint64_t max_keys) override {
+ using ceph::encode;
ceph_assert(done == false);
ceph_assert(iter->valid() == true);
while (iter->valid()) {
- string prefix(iter->raw_key().first);
- string key(iter->raw_key().second);
+ std::string prefix(iter->raw_key().first);
+ std::string key(iter->raw_key().second);
if (sync_prefixes.count(prefix)) {
- bufferlist value = iter->value();
+ ceph::buffer::list value = iter->value();
if (tx->empty() ||
(tx->get_bytes() + value.length() + key.size() +
prefix.size() < max_bytes &&
done = true;
}
- pair<string,string> get_next_key() override {
+ std::pair<std::string,std::string> get_next_key() override {
ceph_assert(iter->valid());
for (; iter->valid(); iter->next()) {
- pair<string,string> r = iter->raw_key();
+ std::pair<std::string,std::string> r = iter->raw_key();
if (sync_prefixes.count(r.first) > 0) {
iter->next();
return r;
}
}
- return pair<string,string>();
+ return std::pair<std::string,std::string>();
}
bool _is_valid() override {
}
};
- Synchronizer get_synchronizer(pair<string,string> &key,
- set<string> &prefixes) {
+ Synchronizer get_synchronizer(std::pair<std::string,std::string> &key,
+ std::set<std::string> &prefixes) {
KeyValueDB::WholeSpaceIterator iter;
iter = db->get_wholespace_iterator();
);
}
- KeyValueDB::Iterator get_iterator(const string &prefix) {
+ KeyValueDB::Iterator get_iterator(const std::string &prefix) {
ceph_assert(!prefix.empty());
KeyValueDB::Iterator iter = db->get_iterator(prefix);
iter->seek_to_first();
return iter;
}
- int get(const string& prefix, const string& key, bufferlist& bl) {
+ int get(const std::string& prefix, const std::string& key, ceph::buffer::list& bl) {
ceph_assert(bl.length() == 0);
return db->get(prefix, key, &bl);
}
- int get(const string& prefix, const version_t ver, bufferlist& bl) {
- ostringstream os;
+ int get(const std::string& prefix, const version_t ver, ceph::buffer::list& bl) {
+ std::ostringstream os;
os << ver;
return get(prefix, os.str(), bl);
}
- version_t get(const string& prefix, const string& key) {
- bufferlist bl;
+ version_t get(const std::string& prefix, const std::string& key) {
+ using ceph::decode;
+ ceph::buffer::list bl;
int err = get(prefix, key, bl);
if (err < 0) {
if (err == -ENOENT) // if key doesn't exist, assume its value is 0
return ver;
}
- bool exists(const string& prefix, const string& key) {
+ bool exists(const std::string& prefix, const std::string& key) {
KeyValueDB::Iterator it = db->get_iterator(prefix);
int err = it->lower_bound(key);
if (err < 0)
return (it->valid() && it->key() == key);
}
- bool exists(const string& prefix, version_t ver) {
- ostringstream os;
+ bool exists(const std::string& prefix, version_t ver) {
+ std::ostringstream os;
os << ver;
return exists(prefix, os.str());
}
- string combine_strings(const string& prefix, const string& value) {
- string out = prefix;
+ std::string combine_strings(const std::string& prefix, const std::string& value) {
+ std::string out = prefix;
out.push_back('_');
out.append(value);
return out;
}
- string combine_strings(const string& prefix, const version_t ver) {
- ostringstream os;
+ std::string combine_strings(const std::string& prefix, const version_t ver) {
+ std::ostringstream os;
os << ver;
return combine_strings(prefix, os.str());
}
- void clear(set<string>& prefixes) {
- set<string>::iterator iter;
+ void clear(std::set<std::string>& prefixes) {
KeyValueDB::Transaction dbt = db->get_transaction();
- for (iter = prefixes.begin(); iter != prefixes.end(); ++iter) {
+ for (auto iter = prefixes.begin(); iter != prefixes.end(); ++iter) {
dbt->rmkeys_by_prefix((*iter));
}
int r = db->submit_transaction_sync(dbt);
ceph_assert(r >= 0);
}
- void _open(const string& kv_type) {
- string::const_reverse_iterator rit;
+ void _open(const std::string& kv_type) {
int pos = 0;
- for (rit = path.rbegin(); rit != path.rend(); ++rit, ++pos) {
+ for (auto rit = path.rbegin(); rit != path.rend(); ++rit, ++pos) {
if (*rit != '/')
break;
}
- ostringstream os;
+ std::ostringstream os;
os << path.substr(0, path.size() - pos) << "/store.db";
- string full_path = os.str();
+ std::string full_path = os.str();
KeyValueDB *db_ptr = KeyValueDB::create(g_ceph_context,
kv_type,
}
- int open(ostream &out) {
- string kv_type;
+ int open(std::ostream &out) {
+ std::string kv_type;
int r = read_meta("kv_backend", &kv_type);
if (r < 0 || kv_type.empty()) {
// assume old monitors that did not mark the type were leveldb.
return 0;
}
- int create_and_open(ostream &out) {
+ int create_and_open(std::ostream &out) {
// record the type before open
- string kv_type;
+ std::string kv_type;
int r = read_meta("kv_backend", &kv_type);
if (r < 0) {
kv_type = g_conf()->mon_keyvaluedb;
db->compact_async();
}
- void compact_prefix(const string& prefix) {
+ void compact_prefix(const std::string& prefix) {
db->compact_prefix(prefix);
}
- uint64_t get_estimated_size(map<string, uint64_t> &extras) {
+ uint64_t get_estimated_size(std::map<std::string, uint64_t> &extras) {
return db->get_estimated_size(extras);
}
*/
int write_meta(const std::string& key,
const std::string& value) const {
- string v = value;
+ std::string v = value;
v += "\n";
int r = safe_write_file(path.c_str(), key.c_str(),
v.c_str(), v.length(),
while (r && isspace(buf[r-1])) {
--r;
}
- *value = string(buf, r);
+ *value = std::string(buf, r);
return 0;
}
- explicit MonitorDBStore(const string& path)
+ explicit MonitorDBStore(const std::string& path)
: path(path),
db(0),
do_dump(false),
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon)
using namespace TOPNSPC::common;
+
+using std::cout;
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::setfill;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+using std::unique_ptr;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
static ostream& _prefix(std::ostream *_dout, Monitor *mon) {
return *_dout << "mon." << mon->name << "@" << mon->rank
<< "(" << mon->get_state_name()
class MonmapMonitor : public PaxosService {
public:
- MonmapMonitor(Monitor *mn, Paxos *p, const string& service_name)
+ MonmapMonitor(Monitor *mn, Paxos *p, const std::string& service_name)
: PaxosService(mn, p, service_name)
{
}
void apply_mon_features(const mon_feature_t& features,
ceph_release_t min_mon_release);
- void dump_info(Formatter *f);
+ void dump_info(ceph::Formatter *f);
bool preprocess_query(MonOpRequestRef op) override;
bool prepare_update(MonOpRequestRef op) override;
bool preprocess_command(MonOpRequestRef op);
bool prepare_command(MonOpRequestRef op);
- int get_monmap(bufferlist &bl);
+ int get_monmap(ceph::buffer::list &bl);
/*
* Since monitors are pretty
private:
void check_subs();
- bufferlist monmap_bl;
+ ceph::buffer::list monmap_bl;
};
#include <boost/algorithm/string/predicate.hpp>
+using std::dec;
+using std::hex;
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::to_string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::ErasureCodeInterfaceRef;
+using ceph::ErasureCodePluginRegistry;
+using ceph::ErasureCodeProfile;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_message;
+
#define dout_subsys ceph_subsys_mon
static const string OSD_PG_CREATING_PREFIX("osd_pg_creating");
static const string OSD_METADATA_PREFIX("osd_metadata");
auto p = caps_info.caps.cbegin();
try {
decode(caps_str, p);
- } catch (const buffer::error &err) {
+ } catch (const ceph::buffer::error &err) {
derr << "corrupt OSD cap data for " << entity_name << " in auth db"
<< dendl;
return false;
osds.insert(p->first);
}
}
- for (map<int32_t,uint32_t>::iterator p = pending_inc.new_weight.begin();
+ for (auto p = pending_inc.new_weight.begin();
!all && p != pending_inc.new_weight.end();
++p) {
if (p->second < osdmap.get_weight(p->first)) {
auto p = bl.cbegin();
decode(m, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
if (err)
*err << "osd." << osd << " metadata is corrupt";
return -EIO;
auto &v = r[epoch];
try {
ceph::decode(v, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " unable to parse value for key '" << it->key()
<< "': \n";
bl.hexdump(*_dout);
return -EINVAL;
}
check_legacy_ec_plugin(plugin->second, erasure_code_profile);
- ErasureCodePluginRegistry &instance = ErasureCodePluginRegistry::instance();
+ auto& instance = ErasureCodePluginRegistry::instance();
return instance.factory(plugin->second,
g_conf().get_val<std::string>("erasure_code_dir"),
profile, erasure_code, ss);
}
if (osdmap.exists(id)) {
pending_inc.new_primary_affinity[id] = ww;
- ss << "set osd." << id << " primary-affinity to " << w << " (" << ios::hex << ww << ios::dec << ")";
+ ss << "set osd." << id << " primary-affinity to " << w << " (" << std::ios::hex << ww << std::ios::dec << ")";
getline(ss, rs);
wait_for_finished_proposal(op, new Monitor::C_Command(mon, op, 0, rs,
get_last_committed() + 1));
#include "CreatingPGs.h"
#include "PaxosService.h"
+#include "erasure-code/ErasureCodeInterface.h"
+#include "mon/MonOpRequest.h"
+#include <boost/functional/hash.hpp>
+
class Monitor;
class PGMap;
-class MonSession;
+struct MonSession;
class MOSDMap;
-#include "erasure-code/ErasureCodeInterface.h"
-#include "mon/MonOpRequest.h"
-#include <boost/functional/hash.hpp>
-// re-include our assert to clobber the system one; fix dout:
-#include "include/ceph_assert.h"
/// information about a particular peer's failure reports for one osd
struct failure_reporter_t {
/// information about all failure reports for one osd
struct failure_info_t {
- map<int, failure_reporter_t> reporters; ///< reporter -> failed_since etc
+ std::map<int, failure_reporter_t> reporters; ///< reporter -> failed_since etc
utime_t max_failed_since; ///< most recent failed_since
failure_info_t() {}
utime_t get_failed_since() {
if (max_failed_since == utime_t() && !reporters.empty()) {
// the old max must have canceled; recalculate.
- for (map<int, failure_reporter_t>::iterator p = reporters.begin();
- p != reporters.end();
- ++p)
+ for (auto p = reporters.begin(); p != reporters.end(); ++p)
if (p->second.failed_since > max_failed_since)
max_failed_since = p->second.failed_since;
}
// if any, so we can discard it.
MonOpRequestRef add_report(int who, utime_t failed_since,
MonOpRequestRef op) {
- map<int, failure_reporter_t>::iterator p = reporters.find(who);
+ auto p = reporters.find(who);
if (p == reporters.end()) {
if (max_failed_since != utime_t() && max_failed_since < failed_since)
max_failed_since = failed_since;
- p = reporters.insert(map<int, failure_reporter_t>::value_type(who, failure_reporter_t(failed_since))).first;
+ p = reporters.insert(std::map<int, failure_reporter_t>::value_type(who, failure_reporter_t(failed_since))).first;
}
MonOpRequestRef ret = p->second.op;
return ret;
}
- void take_report_messages(list<MonOpRequestRef>& ls) {
- for (map<int, failure_reporter_t>::iterator p = reporters.begin();
- p != reporters.end();
- ++p) {
+ void take_report_messages(std::list<MonOpRequestRef>& ls) {
+ for (auto p = reporters.begin(); p != reporters.end(); ++p) {
if (p->second.op) {
ls.push_back(p->second.op);
p->second.op.reset();
}
MonOpRequestRef cancel_report(int who) {
- map<int, failure_reporter_t>::iterator p = reporters.find(who);
+ auto p = reporters.find(who);
if (p == reporters.end())
return MonOpRequestRef();
MonOpRequestRef ret = p->second.op;
class LastEpochClean {
struct Lec {
- vector<epoch_t> epoch_by_pg;
+ std::vector<epoch_t> epoch_by_pg;
ps_t next_missing = 0;
epoch_t floor = std::numeric_limits<epoch_t>::max();
void report(ps_t pg, epoch_t last_epoch_clean);
struct osdmap_manifest_t {
// all the maps we have pinned -- i.e., won't be removed unless
// they are inside a trim interval.
- set<version_t> pinned;
+ std::set<version_t> pinned;
osdmap_manifest_t() {}
version_t get_last_pinned() const
{
- set<version_t>::const_reverse_iterator it = pinned.crbegin();
+ auto it = pinned.crbegin();
if (it == pinned.crend()) {
return 0;
}
version_t get_first_pinned() const
{
- set<version_t>::const_iterator it = pinned.cbegin();
+ auto it = pinned.cbegin();
if (it == pinned.cend()) {
return 0;
}
}
version_t get_lower_closest_pinned(version_t v) const {
- set<version_t>::const_iterator p = pinned.lower_bound(v);
+ auto p = pinned.lower_bound(v);
if (p == pinned.cend()) {
return 0;
} else if (*p > v) {
return *p;
}
- void encode(bufferlist& bl) const
+ void encode(ceph::buffer::list& bl) const
{
ENCODE_START(1, 1, bl);
encode(pinned, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& bl)
+ void decode(ceph::buffer::list::const_iterator& bl)
{
DECODE_START(1, bl);
decode(pinned, bl);
DECODE_FINISH(bl);
}
- void decode(bufferlist& bl) {
+ void decode(ceph::buffer::list& bl) {
auto p = bl.cbegin();
decode(p);
}
- void dump(Formatter *f) {
+ void dump(ceph::Formatter *f) {
f->dump_unsigned("first_pinned", get_first_pinned());
f->dump_unsigned("last_pinned", get_last_pinned());
f->open_array_section("pinned_maps");
const std::set<std::string> &changed) override;
// [leader]
OSDMap::Incremental pending_inc;
- map<int, bufferlist> pending_metadata;
- set<int> pending_metadata_rm;
- map<int, failure_info_t> failure_info;
- map<int,utime_t> down_pending_out; // osd down -> out
+ std::map<int, ceph::buffer::list> pending_metadata;
+ std::set<int> pending_metadata_rm;
+ std::map<int, failure_info_t> failure_info;
+ std::map<int,utime_t> down_pending_out; // osd down -> out
bool priority_convert = false;
- map<int64_t,set<snapid_t>> pending_pseudo_purged_snaps;
+ std::map<int64_t,std::set<snapid_t>> pending_pseudo_purged_snaps;
std::shared_ptr<PriorityCache::PriCache> rocksdb_binned_kv_cache = nullptr;
std::shared_ptr<PriorityCache::Manager> pcm = nullptr;
ceph::mutex balancer_lock = ceph::make_mutex("OSDMonitor::balancer_lock");
- map<int,double> osd_weight;
+ std::map<int,double> osd_weight;
using osdmap_key_t = std::pair<version_t, uint64_t>;
using osdmap_cache_t = SimpleLRU<osdmap_key_t,
- bufferlist,
+ ceph::buffer::list,
std::less<osdmap_key_t>,
boost::hash<osdmap_key_t>>;
osdmap_cache_t inc_osd_cache;
osdmap(om),
pending_inc(pi) {}
- void process(const vector<pg_t>& to_check) override {
- vector<pg_t> to_cancel;
- map<pg_t, mempool::osdmap::vector<pair<int,int>>> to_remap;
+ void process(const
std::vector<pg_t>& to_check) override {
+
std::vector<pg_t> to_cancel;
+ std::map<pg_t, mempool::osdmap::vector<std::pair<int,int>>> to_remap;
osdmap.check_pg_upmaps(cct, to_check, &to_cancel, &to_remap);
// don't bother taking lock if nothing changes
if (!to_cancel.empty() || !to_remap.empty()) {
// svc
public:
void create_initial() override;
- void get_store_prefixes(std::set<string>& s) const override;
+ void get_store_prefixes(std::set<std::string>& s) const override;
private:
void update_from_paxos(bool *need_bootstrap) override;
void encode_trim_extra(MonitorDBStore::TransactionRef tx, version_t first) override;
void update_msgr_features();
- int check_cluster_features(uint64_t features, stringstream &ss);
+ int check_cluster_features(uint64_t features, std::stringstream &ss);
/**
* check if the cluster supports the features required by the
* given crush map. Outputs the daemons which don't support it
* @returns true if the map is passable, false otherwise
*/
bool validate_crush_against_features(const CrushWrapper *newcrush,
- stringstream &ss);
+ std::stringstream &ss);
void check_osdmap_subs();
void share_map_with_random_osd();
osdmon->prime_pg_temp(*osdmap, pgid);
}
}
- void process(const vector<pg_t>& pgs) override {}
+ void process(const
std::vector<pg_t>& pgs) override {}
void complete() override {}
};
void maybe_prime_pg_temp();
ParallelPGMapper mapper; ///< for background pg work
OSDMapMapping mapping; ///< pg <-> osd mappings
- unique_ptr<ParallelPGMapper::Job> mapping_job; ///< background mapping job
+
std::unique_ptr<ParallelPGMapper::Job> mapping_job; ///< background mapping job
void start_mapping();
void update_logger();
MonOpRequestRef req = MonOpRequestRef());
private:
- void print_utilization(ostream &out, Formatter *f, bool tree) const;
+ void print_utilization(std::ostream &out, ceph::Formatter *f, bool tree) const;
bool check_source(MonOpRequestRef op, uuid_d fsid);
bool prepare_failure(MonOpRequestRef op);
bool prepare_mark_me_down(MonOpRequestRef op);
void process_failures();
- void take_all_failures(list<MonOpRequestRef>& ls);
+ void take_all_failures(std::list<MonOpRequestRef>& ls);
bool preprocess_mark_me_dead(MonOpRequestRef op);
bool prepare_mark_me_dead(MonOpRequestRef op);
bool preprocess_pg_ready_to_merge(MonOpRequestRef op);
bool prepare_pg_ready_to_merge(MonOpRequestRef op);
- int _check_remove_pool(int64_t pool_id, const pg_pool_t &pool, ostream *ss);
+ int _check_remove_pool(int64_t pool_id, const pg_pool_t &pool, std::ostream *ss);
bool _check_become_tier(
int64_t tier_pool_id, const pg_pool_t *tier_pool,
int64_t base_pool_id, const pg_pool_t *base_pool,
- int *err, ostream *ss) const;
+ int *err, std::ostream *ss) const;
bool _check_remove_tier(
int64_t base_pool_id, const pg_pool_t *base_pool, const pg_pool_t *tier_pool,
- int *err, ostream *ss) const;
+ int *err, std::ostream *ss) const;
- int _prepare_remove_pool(int64_t pool, ostream *ss, bool no_fake);
- int _prepare_rename_pool(int64_t pool, string newname);
+ int _prepare_remove_pool(int64_t pool, std::ostream *ss, bool no_fake);
+ int _prepare_rename_pool(int64_t pool, std::string newname);
bool enforce_pool_op_caps(MonOpRequestRef op);
bool preprocess_pool_op (MonOpRequestRef op);
bool prepare_pool_op (MonOpRequestRef op);
bool prepare_pool_op_create (MonOpRequestRef op);
bool prepare_pool_op_delete(MonOpRequestRef op);
- int crush_rename_bucket(const string& srcname,
- const string& dstname,
- ostream *ss);
- void check_legacy_ec_plugin(const string& plugin,
- const string& profile) const;
- int normalize_profile(const string& profilename,
- ErasureCodeProfile &profile,
+ int crush_rename_bucket(const std::string& srcname,
+ const std::string& dstname,
+ std::ostream *ss);
+ void check_legacy_ec_plugin(const std::string& plugin,
+ const std::string& profile) const;
+ int normalize_profile(const std::string& profilename,
+ ceph::ErasureCodeProfile &profile,
bool force,
- ostream *ss);
- int crush_rule_create_erasure(const string &name,
- const string &profile,
+ std::ostream *ss);
+ int crush_rule_create_erasure(const std::string &name,
+ const std::string &profile,
int *rule,
- ostream *ss);
- int get_crush_rule(const string &rule_name,
- int *crush_rule,
- ostream *ss);
- int get_erasure_code(const string &erasure_code_profile,
- ErasureCodeInterfaceRef *erasure_code,
- ostream *ss) const;
+ std::ostream *ss);
+ int get_crush_rule(const std::string &rule_name,
+ int *crush_rule,
+ std::ostream *ss);
+ int get_erasure_code(const std::string &erasure_code_profile,
+ ceph::ErasureCodeInterfaceRef *erasure_code,
+ std::ostream *ss) const;
int prepare_pool_crush_rule(const unsigned pool_type,
- const string &erasure_code_profile,
- const string &rule_name,
- int *crush_rule,
- ostream *ss);
+ const std::string &erasure_code_profile,
+ const std::string &rule_name,
+ int *crush_rule,
+ std::ostream *ss);
bool erasure_code_profile_in_use(
const mempool::osdmap::map<int64_t, pg_pool_t> &pools,
- const string &profile,
- ostream *ss);
- int parse_erasure_code_profile(const vector<string> &erasure_code_profile,
- map<string,string> *erasure_code_profile_map,
- ostream *ss);
+ const std::string &profile,
+ std::ostream *ss);
+ int parse_erasure_code_profile(const std::vector<std::string> &erasure_code_profile,
+ std::map<std::string,std::string> *erasure_code_profile_map,
+ std::ostream *ss);
int prepare_pool_size(const unsigned pool_type,
- const string &erasure_code_profile,
+ const std::string &erasure_code_profile,
uint8_t repl_size,
unsigned *size, unsigned *min_size,
- ostream *ss);
+ std::ostream *ss);
int prepare_pool_stripe_width(const unsigned pool_type,
- const string &erasure_code_profile,
+ const std::string &erasure_code_profile,
unsigned *stripe_width,
- ostream *ss);
- int check_pg_num(int64_t pool, int pg_num, int size, ostream* ss);
- int prepare_new_pool(string& name,
+ std::ostream *ss);
+ int check_pg_num(int64_t pool, int pg_num, int size, std::ostream* ss);
+ int prepare_new_pool(std::string& name,
int crush_rule,
- const string &crush_rule_name,
+ const std::string &crush_rule_name,
unsigned pg_num, unsigned pgp_num,
unsigned pg_num_min,
uint64_t repl_size,
const uint64_t target_size_bytes,
const float target_size_ratio,
- const string &erasure_code_profile,
+ const std::string &erasure_code_profile,
const unsigned pool_type,
const uint64_t expected_num_objects,
FastReadType fast_read,
- const string& pg_autoscale_mode,
- ostream *ss);
+ const std::string& pg_autoscale_mode,
+ std::ostream *ss);
int prepare_new_pool(MonOpRequestRef op);
void set_pool_flags(int64_t pool_id, uint64_t flags);
bool _is_removed_snap(int64_t pool_id, snapid_t snapid);
bool _is_pending_removed_snap(int64_t pool_id, snapid_t snapid);
- string make_purged_snap_epoch_key(epoch_t epoch);
- string make_purged_snap_key(int64_t pool, snapid_t snap);
- string make_purged_snap_key_value(int64_t pool, snapid_t snap, snapid_t num,
- epoch_t epoch, bufferlist *v);
+ std::string make_purged_snap_epoch_key(epoch_t epoch);
+ std::string make_purged_snap_key(int64_t pool, snapid_t snap);
+ std::string make_purged_snap_key_value(int64_t pool, snapid_t snap, snapid_t num,
+ epoch_t epoch, ceph::buffer::list *v);
bool try_prune_purged_snaps();
int lookup_purged_snap(int64_t pool, snapid_t snap,
bool prepare_unset_flag(MonOpRequestRef op, int flag);
void _pool_op_reply(MonOpRequestRef op,
- int ret, epoch_t epoch, bufferlist *blp=NULL);
+ int ret, epoch_t epoch, ceph::buffer::list *blp=NULL);
struct C_Booted : public C_MonOp {
OSDMonitor *cmon;
OSDMonitor *osdmon;
int replyCode;
int epoch;
- bufferlist reply_data;
- C_PoolOp(OSDMonitor * osd, MonOpRequestRef op_, int rc, int e, bufferlist *rd=NULL) :
+ ceph::buffer::list reply_data;
+ C_PoolOp(OSDMonitor * osd, MonOpRequestRef op_, int rc, int e, ceph::buffer::list *rd=NULL) :
C_MonOp(op_), osdmon(osd), replyCode(rc), epoch(e) {
if (rd)
reply_data = *rd;
bool preprocess_get_purged_snaps(MonOpRequestRef op);
- int load_metadata(int osd, map<string, string>& m, ostream *err);
- void count_metadata(const string& field, Formatter *f);
+ int load_metadata(int osd, std::map<std::string, std::string>& m,
+ std::ostream *err);
+ void count_metadata(const std::string& field, ceph::Formatter *f);
- void reencode_incremental_map(bufferlist& bl, uint64_t features);
- void reencode_full_map(bufferlist& bl, uint64_t features);
+ void reencode_incremental_map(ceph::buffer::list& bl, uint64_t features);
+ void reencode_full_map(ceph::buffer::list& bl, uint64_t features);
public:
- void count_metadata(const string& field, map<string,int> *out);
+ void count_metadata(const std::string& field, std::map<std::string,int> *out);
protected:
int get_osd_objectstore_type(int osd, std::string *type);
bool is_pool_currently_all_bluestore(int64_t pool_id, const pg_pool_t &pool,
- ostream *err);
+ std::ostream *err);
// when we last received PG stats from each osd
- map<int,utime_t> last_osd_report;
+ std::map<int,utime_t> last_osd_report;
// TODO: use last_osd_report to store the osd report epochs, once we don't
// need to upgrade from pre-luminous releases.
- map<int,epoch_t> osd_epochs;
+ std::map<int,epoch_t> osd_epochs;
LastEpochClean last_epoch_clean;
bool preprocess_beacon(MonOpRequestRef op);
bool prepare_beacon(MonOpRequestRef op);
const mempool::osdmap::set<int64_t>& removed_pools,
utime_t modified,
creating_pgs_t* creating_pgs) const;
- pair<int32_t, pg_t> get_parent_pg(pg_t pgid) const;
+ std::pair<int32_t, pg_t> get_parent_pg(pg_t pgid) const;
void update_creating_pgs();
void check_pg_creates_subs();
epoch_t send_pg_creates(int osd, Connection *con, epoch_t next) const;
int32_t _allocate_osd_id(int32_t* existing_id);
public:
- OSDMonitor(CephContext *cct, Monitor *mn, Paxos *p, const string& service_name);
+ OSDMonitor(CephContext *cct, Monitor *mn, Paxos *p, const std::string& service_name);
void tick() override; // check state, take actions
const uuid_d& uuid,
const bool check_osd_exists,
int32_t* existing_id,
- stringstream& ss);
+ std::stringstream& ss);
int prepare_command_osd_create(
const int32_t id,
const uuid_d& uuid,
int32_t* existing_id,
- stringstream& ss);
+ std::stringstream& ss);
void do_osd_create(const int32_t id, const uuid_d& uuid,
- const string& device_class,
+ const std::string& device_class,
int32_t* new_id);
- int prepare_command_osd_purge(int32_t id, stringstream& ss);
- int prepare_command_osd_destroy(int32_t id, stringstream& ss);
+ int prepare_command_osd_purge(int32_t id, std::stringstream& ss);
+ int prepare_command_osd_destroy(int32_t id, std::stringstream& ss);
int _prepare_command_osd_crush_remove(
CrushWrapper &newcrush,
int32_t id,
int prepare_command_osd_new(
MonOpRequestRef op,
const cmdmap_t& cmdmap,
- const map<string,string>& secrets,
- stringstream &ss,
- Formatter *f);
+ const std::map<std::string,std::string>& secrets,
+ std::stringstream &ss,
+ ceph::Formatter *f);
int prepare_command_pool_set(const cmdmap_t& cmdmap,
- stringstream& ss);
+ std::stringstream& ss);
- int prepare_command_pool_application(const string &prefix,
+ int prepare_command_pool_application(const std::string &prefix,
const cmdmap_t& cmdmap,
- stringstream& ss);
- int preprocess_command_pool_application(const string &prefix,
+ std::stringstream& ss);
+ int preprocess_command_pool_application(const std::string &prefix,
const cmdmap_t& cmdmap,
- stringstream& ss,
+ std::stringstream& ss,
bool *modified);
- int _command_pool_application(const string &prefix,
- const cmdmap_t& cmdmap,
- stringstream& ss,
- bool *modified,
- bool preparing);
+ int _command_pool_application(const std::string &prefix,
+ const cmdmap_t& cmdmap,
+ std::stringstream& ss,
+ bool *modified,
+ bool preparing);
bool handle_osd_timeouts(const utime_t &now,
std::map<int,utime_t> &last_osd_report);
send_incremental(op, start);
}
- int get_version(version_t ver, bufferlist& bl) override;
- int get_version(version_t ver, uint64_t feature, bufferlist& bl);
+ int get_version(version_t ver, ceph::buffer::list& bl) override;
+ int get_version(version_t ver, uint64_t feature, ceph::buffer::list& bl);
- int get_version_full(version_t ver, uint64_t feature, bufferlist& bl);
- int get_version_full(version_t ver, bufferlist& bl) override;
+ int get_version_full(version_t ver, uint64_t feature, ceph::buffer::list& bl);
+ int get_version_full(version_t ver, ceph::buffer::list& bl) override;
int get_inc(version_t ver, OSDMap::Incremental& inc);
- int get_full_from_pinned_map(version_t ver, bufferlist& bl);
+ int get_full_from_pinned_map(version_t ver, ceph::buffer::list& bl);
epoch_t blacklist(const entity_addrvec_t& av, utime_t until);
epoch_t blacklist(entity_addr_t a, utime_t until);
- void dump_info(Formatter *f);
- int dump_osd_metadata(int osd, Formatter *f, ostream *err);
- void print_nodes(Formatter *f);
+ void dump_info(ceph::Formatter *f);
+ int dump_osd_metadata(int osd, ceph::Formatter *f, std::ostream *err);
+ void print_nodes(ceph::Formatter *f);
void check_osdmap_sub(Subscription *sub);
void check_pg_creates_sub(Subscription *sub);
#include "common/Timer.h"
#include "messages/PaxosServiceMessage.h"
+using std::string;
+using std::unique_lock;
+
+using ceph::bufferlist;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::to_timespan;
+
#define dout_subsys ceph_subsys_paxos
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, mon->name, mon->rank, paxos_name, state, first_committed, last_committed)
-static ostream& _prefix(std::ostream *_dout, Monitor *mon, const string& name,
- int rank, const string& paxos_name, int state,
- version_t first_committed, version_t last_committed)
+static std::ostream& _prefix(std::ostream *_dout, Monitor *mon, const string& name,
+ int rank, const string& paxos_name, int state,
+ version_t first_committed, version_t last_committed)
{
return *_dout << "mon." << name << "@" << rank
<< "(" << mon->get_state_name() << ")"
dout(10) << "collect with pn " << accepted_pn << dendl;
// send collect
- for (set<int>::const_iterator p = mon->get_quorum().begin();
+ for (auto p = mon->get_quorum().begin();
p != mon->get_quorum().end();
++p) {
if (*p == mon->rank) continue;
-
+
MMonPaxos *collect = new MMonPaxos(mon->get_epoch(), MMonPaxos::OP_COLLECT,
ceph_clock_now());
collect->last_committed = last_committed;
bool Paxos::store_state(MMonPaxos *m)
{
auto t(std::make_shared<MonitorDBStore::Transaction>());
- map<version_t,bufferlist>::iterator start = m->values.begin();
+ auto start = m->values.begin();
bool changed = false;
// build map of values to store
// make sure we get the right interval of values to apply by pushing forward
// the 'end' iterator until it matches the message's 'last_committed'.
- map<version_t,bufferlist>::iterator end = start;
+ auto end = start;
while (end != m->values.end() && end->first <= m->last_committed) {
last_committed = end->first;
++end;
// we should apply the state here -- decode every single bufferlist in the
// map and append the transactions to 't'.
- map<version_t,bufferlist>::iterator it;
- for (it = start; it != end; ++it) {
+ for (auto it = start; it != end; ++it) {
// write the bufferlist as the version's value
t->put(get_name(), it->first, it->second);
// decode the bufferlist and append it to the transaction we will shortly
ceph_assert(g_conf()->paxos_kill_at != 2);
// is everyone contiguous and up to date?
- for (map<int,version_t>::iterator p = peer_last_committed.begin();
+ for (auto p = peer_last_committed.begin();
p != peer_last_committed.end();
++p) {
if (p->second + 1 < first_committed && first_committed > 1) {
}
// ask others to accept it too!
- for (set<int>::const_iterator p = mon->get_quorum().begin();
+ for (auto p = mon->get_quorum().begin();
p != mon->get_quorum().end();
++p) {
if (*p == mon->rank) continue;
_sanity_check_store();
// tell everyone
- for (set<int>::const_iterator p = mon->get_quorum().begin();
+ for (auto p = mon->get_quorum().begin();
p != mon->get_quorum().end();
++p) {
if (*p == mon->rank) continue;
<< " (" << lease_expire << ")" << dendl;
// bcast
- for (set<int>::const_iterator p = mon->get_quorum().begin();
+ for (auto p = mon->get_quorum().begin();
p != mon->get_quorum().end(); ++p) {
if (*p == mon->rank) continue;
*
* Each version's value (value_1, value_2, ..., value_n) is a blob of data,
* incomprehensible to the Paxos. These values are proposed to the Paxos on
- * propose_new_value() and each one is a transaction encoded in a bufferlist.
+ * propose_new_value() and each one is a transaction encoded in a ceph::buffer::list.
*
* The Paxos will write the value to disk, associating it with its version,
* but will take a step further: the value shall be decoded, and the operations
* on that transaction shall be applied during the same transaction that will
- * write the value's encoded bufferlist to disk. This behavior ensures that
+ * write the value's encoded ceph::buffer::list to disk. This behavior ensures that
* whatever is being proposed will only be available on the store when it is
* applied by Paxos, which will then be aware of such new values, guaranteeing
* the store state is always consistent without requiring shady workarounds.
*
* So, let's say that FooMonitor proposes the following transaction, neatly
- * encoded on a bufferlist of course:
+ * encoded on a ceph::buffer::list of course:
*
* Tx_Foo
* put(foo, last_committed, 3)
* erase(foo, 1)
* put(foo, first_committed, 3)
*
- * And knowing that the Paxos is proposed Tx_Foo as a bufferlist, once it is
+ * And knowing that the Paxos is proposed Tx_Foo as a ceph::buffer::list, once it is
* ready to commit, and assuming we are now committing version 5 of the Paxos,
* we will do something along the lines of:
*
* Tx proposed_tx;
- * proposed_tx.decode(Tx_foo_bufferlist);
+ * proposed_tx.decode(Tx_foo_ceph::buffer::list);
*
* Tx our_tx;
* our_tx.put(paxos, last_committed, 5);
- * our_tx.put(paxos, 5, Tx_foo_bufferlist);
+ * our_tx.put(paxos, 5, Tx_foo_ceph::buffer::list);
* our_tx.append(proposed_tx);
*
* store_apply(our_tx);
* 2 -> value_2
* 3 -> value_3
* 4 -> value_4
- * 5 -> Tx_foo_bufferlist
+ * 5 -> Tx_foo_ceph::buffer::list
* foo:
* first_committed -> 3
* last_committed -> 3
void init_logger();
// my state machine info
- const string paxos_name;
+ const std::string paxos_name;
friend class Monitor;
friend class PaxosService;
- list<std::string> extra_state_dirs;
+ std::list<std::string> extra_state_dirs;
// LEADER+PEON
* @param s State value.
* @return The state's name.
*/
- static const string get_statename(int s) {
+ static const std::string get_statename(int s) {
switch (s) {
case STATE_RECOVERING:
return "recovering";
* When the Leader starts the collect phase, each Peon will reply with its
* first committed version, which will then be kept in this map.
*/
- map<int,version_t> peer_first_committed;
+ std::map<int,version_t> peer_first_committed;
/**
* Map holding the last committed version by each quorum member.
*
* When the Leader starts the collect phase, each Peon will reply with its
* last committed version, which will then be kept in this map.
*/
- map<int,version_t> peer_last_committed;
+ std::map<int,version_t> peer_last_committed;
/**
* @}
*/
/**
* List of callbacks waiting for our state to change into STATE_ACTIVE.
*/
- list<Context*> waiting_for_active;
+ std::list<Context*> waiting_for_active;
/**
* List of callbacks waiting for the chance to read a version from us.
*
* with the latest proposal, or if we don't really care about the remaining
* uncommitted values --, or if we're on a quorum of one.
*/
- list<Context*> waiting_for_readable;
+ std::list<Context*> waiting_for_readable;
/**
* @}
*/
* on the Leader, or learnt by the Leader from a Peon during the collect
* phase.
*/
- bufferlist uncommitted_value;
+ ceph::buffer::list uncommitted_value;
/**
* Used to specify when an on-going collect phase times out.
*/
* members, guaranteeing that we trigger new elections if some don't ack in
* the expected timeframe.
*/
- set<int> acked_lease;
+ std::set<int> acked_lease;
/**
* Callback responsible for extending the lease periodically.
*/
/**
* New Value being proposed to the Peons.
*
- * This bufferlist holds the value the Leader is proposing to the Peons, and
+ * This ceph::buffer::list holds the value the Leader is proposing to the Peons, and
* that will be committed if the Peons do accept the proposal.
*/
- bufferlist new_value;
+ ceph::buffer::list new_value;
/**
* Set of participants (Leader & Peons) that accepted the new proposed value.
*
* participants has accepted the proposal), and when to extend the lease
* (when all the quorum members have accepted the proposal).
*/
- set<int> accepted;
+ std::set<int> accepted;
/**
* Callback to trigger a new election if the proposal is not accepted by the
* full quorum within a given timeframe.
* @remarks It is not possible to write if we are not the Leader, or we are
* not on the active state, or if the lease has expired.
*/
- list<Context*> waiting_for_writeable;
+ std::list<Context*> waiting_for_writeable;
/**
* Pending proposal transaction
* These are waiting for updates in the pending proposal/transaction
* to be committed.
*/
- list<Context*> pending_finishers;
+ std::list<Context*> pending_finishers;
/**
* Finishers for committing transaction
* When the pending_proposal is submitted, pending_finishers move to
* this list. When it commits, these finishers are notified.
*/
- list<Context*> committing_finishers;
+ std::list<Context*> committing_finishers;
/**
* This function re-triggers pending_ and committing_finishers
* safely, so as to maintain existing system invariants. In particular
class C_Proposal : public Context {
Context *proposer_context;
public:
- bufferlist bl;
+ ceph::buffer::list bl;
// for debug purposes. Will go away. Soon.
bool proposed;
utime_t proposal_time;
- C_Proposal(Context *c, bufferlist& proposal_bl) :
+ C_Proposal(Context *c, ceph::buffer::list& proposal_bl) :
proposer_context(c),
bl(proposal_bl),
proposed(false),
*
* @param value The value being proposed to the quorum
*/
- void begin(bufferlist& value);
+ void begin(ceph::buffer::list& value);
/**
* Accept or decline (by ignoring) a proposal from the Leader.
*
* @param name A name for the paxos service. It serves as the naming space
* of the underlying persistent storage for this service.
*/
- Paxos(Monitor *m, const string &name)
+ Paxos(Monitor *m, const std::string &name)
: mon(m),
logger(NULL),
paxos_name(name),
clock_drift_warned(0),
trimming(false) { }
- const string get_name() const {
+ const std::string get_name() const {
return paxos_name;
}
/**
* dump state info to a formatter
*/
- void dump_info(Formatter *f);
+ void dump_info(ceph::Formatter *f);
/**
* This function runs basic consistency checks. Importantly, if
*
* Basically, we received a set of version. Or just one. It doesn't matter.
* What matters is that we have to stash it in the store. So, we will simply
- * write every single bufferlist into their own versions on our side (i.e.,
- * onto paxos-related keys), and then we will decode those same bufferlists
+ * write every single ceph::buffer::list into their own versions on our side (i.e.,
+ * onto paxos-related keys), and then we will decode those same ceph::buffer::lists
* we just wrote and apply the transactions they hold. We will also update
* our first and last committed values to point to the new values, if need
* be. All this is done tightly wrapped in a transaction to ensure we
void _sanity_check_store();
/**
- * Helper function to decode a bufferlist into a transaction and append it
+ * Helper function to decode a ceph::buffer::list into a transaction and append it
* to another transaction.
*
* This function is used during the Leader's commit and during the
- * Paxos::store_state in order to apply the bufferlist's transaction onto
+ * Paxos::store_state in order to apply the ceph::buffer::list's transaction onto
* the store.
*
* @param t The transaction to which we will append the operations
- * @param bl A bufferlist containing an encoded transaction
+ * @param bl A ceph::buffer::list containing an encoded transaction
*/
static void decode_append_transaction(MonitorDBStore::TransactionRef t,
- bufferlist& bl) {
+ ceph::buffer::list& bl) {
auto vt(std::make_shared<MonitorDBStore::Transaction>());
auto it = bl.cbegin();
vt->decode(it);
* its objective is to allow a third-party to have a "private"
* state dir. -JL
*/
- void add_extra_state_dir(string s) {
+ void add_extra_state_dir(std::string s) {
extra_state_dirs.push_back(s);
}
* @param[out] bl The version's value
* @return 'true' if we successfully read the value; 'false' otherwise
*/
- bool read(version_t v, bufferlist &bl);
+ bool read(version_t v, ceph::buffer::list &bl);
/**
* Read the latest committed version
*
* @return the latest committed version if we successfully read the value;
* or 0 (zero) otherwise.
*/
- version_t read_current(bufferlist &bl);
+ version_t read_current(ceph::buffer::list &bl);
/**
* Add onreadable to the list of callbacks waiting for us to become readable.
*
MonitorDBStore *get_store();
};
-inline ostream& operator<<(ostream& out, Paxos::C_Proposal& p)
+inline std::ostream& operator<<(std::ostream& out, Paxos::C_Proposal& p)
{
- string proposed = (p.proposed ? "proposed" : "unproposed");
+ std::string proposed = (p.proposed ? "proposed" : "unproposed");
out << " " << proposed
<< " queued " << (ceph_clock_now() - p.proposal_time)
<< " tx dump:\n";
auto t(std::make_shared<MonitorDBStore::Transaction>());
auto p_it = p.bl.cbegin();
t->decode(p_it);
- JSONFormatter f(true);
+ ceph::JSONFormatter f(true);
t->dump(&f);
f.flush(out);
return out;
}
#endif
-
return pending_fsmap;
}
- void decode(bufferlist &bl) {
+ void decode(ceph::buffer::list &bl) {
fsmap.decode(bl);
pending_fsmap = FSMap(); /* nuke it to catch invalid access */
}
#include "include/ceph_assert.h"
#include "mon/MonOpRequest.h"
+using std::ostream;
+using std::string;
+
+using ceph::bufferlist;
+
#define dout_subsys ceph_subsys_paxos
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, paxos, service_name, get_first_committed(), get_last_committed())
mon->store->get("health", service_name, bl);
if (bl.length()) {
auto p = bl.cbegin();
+ using ceph::decode;
decode(health_checks, p);
}
}
* Our name. This will be associated with the class implementing us, and will
* be used mainly for store-related operations.
*/
- string service_name;
+ std::string service_name;
/**
* If we are or have queued anything for proposal, this variable will be true
* until our proposal has been finished.
* @param p A Paxos instance
* @param name Our service's name.
*/
- PaxosService(Monitor *mn, Paxos *p, string name)
+ PaxosService(Monitor *mn, Paxos *p, std::string name)
: mon(mn), paxos(p), service_name(name),
proposing(false),
service_version(0), proposal_timer(0), have_pending(false),
*
* @returns The service's name.
*/
- const string& get_service_name() const { return service_name; }
+ const std::string& get_service_name() const { return service_name; }
/**
* Get the store prefixes we utilize
*/
- virtual void get_store_prefixes(set<string>& s) const {
+ virtual void get_store_prefixes(std::set<std::string>& s) const {
s.insert(service_name);
}
virtual void create_pending() = 0;
/**
- * Encode the pending state into a bufferlist for ratification and
+ * Encode the pending state into a ceph::buffer::list for ratification and
* transmission as the next state.
*
* @invariant This function is only called on a Leader.
void encode_health(const health_check_map_t& next,
MonitorDBStore::TransactionRef t) {
- bufferlist bl;
+ using ceph::encode;
+ ceph::buffer::list bl;
encode(next, bl);
t->put("health", service_name, bl);
mon->log_health(next, health_checks, t);
* mistakes.
* @{
*/
- const string last_committed_name;
- const string first_committed_name;
- const string full_prefix_name;
- const string full_latest_name;
+ const std::string last_committed_name;
+ const std::string first_committed_name;
+ const std::string full_prefix_name;
+ const std::string full_latest_name;
/**
* @}
*/
* Paxos. These callbacks will be awaken whenever the said proposal
* finishes.
*/
- list<Context*> waiting_for_finished_proposal;
+ std::list<Context*> waiting_for_finished_proposal;
public:
*
* @param t A transaction to which we will add this put operation
* @param ver The version to which we will add the value
- * @param bl A bufferlist containing the version's value
+ * @param bl A ceph::buffer::list containing the version's value
*/
void put_version(MonitorDBStore::TransactionRef t, version_t ver,
- bufferlist& bl) {
+ ceph::buffer::list& bl) {
t->put(get_service_name(), ver, bl);
}
/**
*
* @param t The transaction to which we will add this put operation
* @param ver A version number
- * @param bl A bufferlist containing the version's value
+ * @param bl A ceph::buffer::list containing the version's value
*/
void put_version_full(MonitorDBStore::TransactionRef t,
- version_t ver, bufferlist& bl) {
- string key = mon->store->combine_strings(full_prefix_name, ver);
+ version_t ver, ceph::buffer::list& bl) {
+ std::string key = mon->store->combine_strings(full_prefix_name, ver);
t->put(get_service_name(), key, bl);
}
/**
* @param ver A version number
*/
void put_version_latest_full(MonitorDBStore::TransactionRef t, version_t ver) {
- string key = mon->store->combine_strings(full_prefix_name, full_latest_name);
+ std::string key = mon->store->combine_strings(full_prefix_name, full_latest_name);
t->put(get_service_name(), key, ver);
}
/**
*
* @param t A transaction to which we will add this put operation
* @param key The key to which we will add the value
- * @param bl A bufferlist containing the value
+ * @param bl A ceph::buffer::list containing the value
*/
void put_value(MonitorDBStore::TransactionRef t,
- const string& key, bufferlist& bl) {
+ const std::string& key, ceph::buffer::list& bl) {
t->put(get_service_name(), key, bl);
}
* @param v An integer
*/
void put_value(MonitorDBStore::TransactionRef t,
- const string& key, version_t v) {
+ const std::string& key, version_t v) {
t->put(get_service_name(), key, v);
}
* Get the contents of a given version @p ver
*
* @param ver The version being obtained
- * @param bl The bufferlist to be populated
+ * @param bl The ceph::buffer::list to be populated
* @return 0 on success; <0 otherwise
*/
- virtual int get_version(version_t ver, bufferlist& bl) {
+ virtual int get_version(version_t ver, ceph::buffer::list& bl) {
return mon->store->get(get_service_name(), ver, bl);
}
/**
* Get the contents of a given full version of this service.
*
* @param ver A version number
- * @param bl The bufferlist to be populated
+ * @param bl The ceph::buffer::list to be populated
* @returns 0 on success; <0 otherwise
*/
- virtual int get_version_full(version_t ver, bufferlist& bl) {
- string key = mon->store->combine_strings(full_prefix_name, ver);
+ virtual int get_version_full(version_t ver, ceph::buffer::list& bl) {
+ std::string key = mon->store->combine_strings(full_prefix_name, ver);
return mon->store->get(get_service_name(), key, bl);
}
/**
* @returns A version number
*/
version_t get_version_latest_full() {
- string key = mon->store->combine_strings(full_prefix_name, full_latest_name);
+ std::string key = mon->store->combine_strings(full_prefix_name, full_latest_name);
return mon->store->get(get_service_name(), key);
}
* Get a value from a given key.
*
* @param[in] key The key
- * @param[out] bl The bufferlist to be populated with the value
+ * @param[out] bl The ceph::buffer::list to be populated with the value
*/
- int get_value(const string& key, bufferlist& bl) {
+ int get_value(const std::string& key, ceph::buffer::list& bl) {
return mon->store->get(get_service_name(), key, bl);
}
/**
*
* @param[in] key The key
*/
- version_t get_value(const string& key) {
+ version_t get_value(const std::string& key) {
return mon->store->get(get_service_name(), key);
}
};
#endif
-
virtual void init() { }
virtual int get_type() = 0;
- virtual string get_name() const = 0;
+ virtual std::string get_name() const = 0;
};
#undef dout_prefix
#define dout_prefix *_dout << "fuse "
+using std::list;
+using std::map;
+using std::set;
+using std::string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+
// some fuse-y bits of state
struct fs_info {
struct fuse_args args;
struct OpenFile {
std::string path;
- bufferlist bl;
+ ceph::buffer::list bl;
bool dirty = false;
int ref = 0;
};
std::map<std::string,OpenFile*> open_files;
int open_file(std::string p, struct fuse_file_info *fi,
- std::function<int(bufferlist *bl)> f);
+ std::function<int(ceph::buffer::list *bl)> f);
class FuseThread : public Thread {
FuseStore *fs;
#include "kstore/KStore.h"
#endif
+using std::string;
+
ObjectStore *ObjectStore::create(CephContext *cct,
const string& type,
const string& data,
virtual int pool_statfs(uint64_t pool_id, struct store_statfs_t *buf,
bool *per_pool_omap) = 0;
- virtual void collect_metadata(std::map<std::string,string> *pm) { }
+ virtual void collect_metadata(std::map<std::string,std::string> *pm) { }
/**
* write_meta - write a simple configuration key out-of-band
virtual int dump_onode(
CollectionHandle &c,
const ghobject_t& oid,
- const string& section_name,
+ const std::string& section_name,
ceph::Formatter *f) {
return -ENOTSUP;
}
#include "os/Transaction.h"
#include "common/Formatter.h"
+using std::list;
+using std::map;
+using std::ostream;
+using std::set;
+using std::string;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+
void decode_str_str_map_to_bl(bufferlist::const_iterator& p,
bufferlist *out)
{
#include "common/admin_socket.h"
#define dout_subsys ceph_subsys_bluestore
+using std::string;
+using std::to_string;
+
+using ceph::bufferlist;
+using ceph::Formatter;
+
class Allocator::SocketHook : public AdminSocketHook {
Allocator *alloc;
virtual double get_fragmentation_score();
virtual void shutdown() = 0;
- static Allocator *create(CephContext* cct, string type, int64_t size,
+ static Allocator *create(CephContext* cct, std::string type, int64_t size,
int64_t block_size, const std::string& name = "");
private:
class SocketHook;
#undef dout_prefix
#define dout_prefix *_dout << "freelist "
+using std::string;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::decode;
+using ceph::encode;
+
void make_offset_key(uint64_t offset, std::string *key)
{
key->reserve(10);
uint64_t block_mask; ///< mask to convert byte offset to block offset
uint64_t key_mask; ///< mask to convert offset to key offset
- bufferlist all_set_bl;
+ ceph::buffer::list all_set_bl;
KeyValueDB::Iterator enumerate_p;
uint64_t enumerate_offset; ///< logical offset; position
- bufferlist enumerate_bl; ///< current key at enumerate_offset
+ ceph::buffer::list enumerate_bl; ///< current key at enumerate_offset
int enumerate_bl_pos; ///< bit position in enumerate_bl
uint64_t _get_offset(uint64_t key_off, int bit) {
KeyValueDB::Transaction txn);
public:
- BitmapFreelistManager(CephContext* cct, string meta_prefix,
- string bitmap_prefix);
+ BitmapFreelistManager(CephContext* cct, std::string meta_prefix,
+ std::string bitmap_prefix);
- static void setup_merge_operator(KeyValueDB *db, string prefix);
+ static void setup_merge_operator(KeyValueDB *db, std::string prefix);
int create(uint64_t size, uint64_t granularity,
KeyValueDB::Transaction txn) override;
#undef dout_prefix
#define dout_prefix *_dout << "bdev "
+using std::string;
+
void IOContext::aio_wait()
{
std::unique_lock l(lock);
virtual int read(
uint64_t off,
uint64_t len,
- bufferlist *pbl,
+ ceph::buffer::list *pbl,
IOContext *ioc,
bool buffered) = 0;
virtual int read_random(
bool buffered) = 0;
virtual int write(
uint64_t off,
- bufferlist& bl,
+ ceph::buffer::list& bl,
bool buffered,
int write_hint = WRITE_LIFE_NOT_SET) = 0;
virtual int aio_read(
uint64_t off,
uint64_t len,
- bufferlist *pbl,
+ ceph::buffer::list *pbl,
IOContext *ioc) = 0;
virtual int aio_write(
uint64_t off,
- bufferlist& bl,
+ ceph::buffer::list& bl,
IOContext *ioc,
bool buffered,
int write_hint = WRITE_LIFE_NOT_SET) = 0;
#undef dout_prefix
#define dout_prefix *_dout << "bluefs "
using TOPNSPC::common::cmd_getval;
+
+using std::byte;
+using std::list;
+using std::make_pair;
+using std::map;
+using std::ostream;
+using std::pair;
+using std::set;
+using std::string;
+using std::to_string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+
+
MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::File, bluefs_file, bluefs);
MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::Dir, bluefs_dir, bluefs);
MEMPOOL_DEFINE_OBJECT_FACTORY(BlueFS::FileWriter, bluefs_file_writer, bluefs);
auto p = bl.cbegin();
decode(t, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
derr << __func__ << " 0x" << std::hex << pos << std::dec
<< ": stop: failed to decode: " << e.what()
<< dendl;
virtual ~BlueFSVolumeSelector() {
}
virtual void* get_hint_by_device(uint8_t dev) const = 0;
- virtual void* get_hint_by_dir(const string& dirname) const = 0;
+ virtual void* get_hint_by_dir(const std::string& dirname) const = 0;
virtual void add_usage(void* file_hint, const bluefs_fnode_t& fnode) = 0;
virtual void sub_usage(void* file_hint, const bluefs_fnode_t& fnode) = 0;
virtual void sub_usage(void* file_hint, uint64_t fsize) = 0;
virtual uint8_t select_prefer_bdev(void* hint) = 0;
virtual void get_paths(const std::string& base, paths& res) const = 0;
- virtual void dump(ostream& sout) = 0;
+ virtual void dump(std::ostream& sout) = 0;
};
class BlueFS;
struct Dir : public RefCountedObject {
MEMPOOL_CLASS_HELPERS();
- mempool::bluefs::map<string,FileRef> file_map;
+ mempool::bluefs::map<std::string,FileRef> file_map;
private:
FRIEND_MAKE_REF(Dir);
FileRef file;
uint64_t pos = 0; ///< start offset for buffer
- bufferlist buffer; ///< new data to write (at end of file)
- bufferlist tail_block; ///< existing partial block at end of file, if any
- bufferlist::page_aligned_appender buffer_appender; //< for const char* only
+ ceph::buffer::list buffer; ///< new data to write (at end of file)
+ ceph::buffer::list tail_block; ///< existing partial block at end of file, if any
+ ceph::buffer::list::page_aligned_appender buffer_appender; //< for const char* only
int writer_type = 0; ///< WRITER_*
int write_hint = WRITE_LIFE_NOT_SET;
}
// note: used internally only, for ino 1 or 0.
- void append(bufferlist& bl) {
+ void append(ceph::buffer::list& bl) {
buffer.claim_append(bl);
}
MEMPOOL_CLASS_HELPERS();
uint64_t bl_off = 0; ///< prefetch buffer logical offset
- bufferlist bl; ///< prefetch buffer
+ ceph::buffer::list bl; ///< prefetch buffer
uint64_t pos = 0; ///< current logical offset
uint64_t max_prefetch; ///< max allowed prefetch
};
// cache
- mempool::bluefs::map<string, DirRef> dir_map; ///< dirname -> Dir
+ mempool::bluefs::map<std::string, DirRef> dir_map; ///< dirname -> Dir
mempool::bluefs::unordered_map<uint64_t,FileRef> file_map; ///< ino -> File
// map of dirty files, files of same dirty_seq are grouped into list.
- map<uint64_t, dirty_file_list_t> dirty_files;
+ std::map<uint64_t, dirty_file_list_t> dirty_files;
bluefs_super_t super; ///< latest superblock (as last written)
uint64_t ino_last = 0; ///< last assigned ino (this one is in use)
* BDEV_WAL db.wal/ - a small, fast device, specifically for the WAL
* BDEV_SLOW db.slow/ - a big, slow device, to spill over to as BDEV_DB fills
*/
- vector<BlockDevice*> bdev; ///< block devices we can use
- vector<IOContext*> ioc; ///< IOContexts for bdevs
- vector<interval_set<uint64_t> > block_all; ///< extents in bdev we own
- vector<Allocator*> alloc; ///< allocators for bdevs
- vector<uint64_t> alloc_size; ///< alloc size for each device
- vector<interval_set<uint64_t>> pending_release; ///< extents to release
- vector<interval_set<uint64_t>> block_unused_too_granular;
+ std::vector<BlockDevice*> bdev; ///< block devices we can use
+ std::vector<IOContext*> ioc; ///< IOContexts for bdevs
+ std::vector<interval_set<uint64_t> > block_all; ///< extents in bdev we own
+
std::vector<Allocator*> alloc; ///< allocators for bdevs
+ std::vector<uint64_t> alloc_size; ///< alloc size for each device
+ std::vector<interval_set<uint64_t>> pending_release; ///< extents to release
+ std::vector<interval_set<uint64_t>> block_unused_too_granular;
BlockDevice::aio_callback_t discard_cb[3]; //discard callbacks for each dev
void _init_alloc();
void _stop_alloc();
- void _pad_bl(bufferlist& bl); ///< pad bufferlist to block size w/ zeros
+ void _pad_bl(ceph::buffer::list& bl); ///< pad ceph::buffer::list to block size w/ zeros
FileRef _get_file(uint64_t ino);
void _drop_link(FileRef f);
int _fsync(FileWriter *h, std::unique_lock<ceph::mutex>& l);
#ifdef HAVE_LIBAIO
- void _claim_completed_aios(FileWriter *h, list<aio_t> *ls);
+ void _claim_completed_aios(FileWriter *h,
std::list<aio_t> *ls);
void wait_for_aio(FileWriter *h); // safe to call without a lock
#endif
FileReaderBuffer *buf, ///< [in] reader state
uint64_t offset, ///< [in] offset
size_t len, ///< [in] this many bytes
- bufferlist *outbl, ///< [out] optional: reference the result here
+ ceph::buffer::list *outbl, ///< [out] optional: reference the result here
char *out); ///< [out] optional: or copy it here
int _read_random(
FileReader *h, ///< [in] read from here
int log_dump();
- void collect_metadata(map<string,string> *pm, unsigned skip_bdev_id);
- void get_devices(set<string> *ls);
+ void collect_metadata(std::map<std::string,std::string> *pm, unsigned skip_bdev_id);
+ void get_devices(std::set<std::string> *ls);
uint64_t get_alloc_size(int id) {
return alloc_size[id];
}
int device_migrate_to_new(
CephContext *cct,
- const set<int>& devs_source,
+ const std::set<int>& devs_source,
int dev_target,
const bluefs_layout_t& layout);
int device_migrate_to_existing(
CephContext *cct,
- const set<int>& devs_source,
+ const std::set<int>& devs_source,
int dev_target,
const bluefs_layout_t& layout);
uint64_t get_used();
uint64_t get_total(unsigned id);
uint64_t get_free(unsigned id);
- void get_usage(vector<pair<uint64_t,uint64_t>> *usage); // [<free,total> ...]
- void dump_perf_counters(Formatter *f);
+ void get_usage(std::vector<std::pair<uint64_t,uint64_t>> *usage); // [<free,total> ...]
+ void dump_perf_counters(ceph::Formatter *f);
- void dump_block_extents(ostream& out);
+ void dump_block_extents(std::ostream& out);
/// get current extents that we own for given block device
int get_block_extents(unsigned id, interval_set<uint64_t> *extents);
int open_for_write(
- const string& dir,
- const string& file,
+ const std::string& dir,
+ const std::string& file,
FileWriter **h,
bool overwrite);
int open_for_read(
- const string& dir,
- const string& file,
+ const std::string& dir,
+ const std::string& file,
FileReader **h,
bool random = false);
_close_writer(h);
}
- int rename(const string& old_dir, const string& old_file,
- const string& new_dir, const string& new_file);
+ int rename(const std::string& old_dir, const std::string& old_file,
+ const std::string& new_dir, const std::string& new_file);
- int readdir(const string& dirname, vector<string> *ls);
+ int readdir(const std::string& dirname, std::vector<std::string> *ls);
- int unlink(const string& dirname, const string& filename);
- int mkdir(const string& dirname);
- int rmdir(const string& dirname);
+ int unlink(const std::string& dirname, const std::string& filename);
+ int mkdir(const std::string& dirname);
+ int rmdir(const std::string& dirname);
bool wal_is_rotational();
- bool dir_exists(const string& dirname);
- int stat(const string& dirname, const string& filename,
+ bool dir_exists(const std::string& dirname);
+ int stat(const std::string& dirname, const std::string& filename,
uint64_t *size, utime_t *mtime);
- int lock_file(const string& dirname, const string& filename, FileLock **p);
+ int lock_file(const std::string& dirname, const std::string& filename, FileLock **p);
int unlock_file(FileLock *l);
void compact_log();
void set_volume_selector(BlueFSVolumeSelector* s) {
vselector.reset(s);
}
- void dump_volume_selector(ostream& sout) {
+ void dump_volume_selector(std::ostream& sout) {
vselector->dump(sout);
}
void get_vselector_paths(const std::string& base,
return vselector->get_paths(base, res);
}
- int add_block_device(unsigned bdev, const string& path, bool trim,
+ int add_block_device(unsigned bdev, const std::string& path, bool trim,
bool shared_with_bluestore=false);
bool bdev_support_label(unsigned id);
uint64_t get_block_device_size(unsigned bdev);
return _fsync(h, l);
}
int read(FileReader *h, FileReaderBuffer *buf, uint64_t offset, size_t len,
- bufferlist *outbl, char *out) {
+ ceph::buffer::list *outbl, char *out) {
// no need to hold the global lock here; we only touch h and
// h->file, and read vs write or delete is already protected (via
// atomics and asserts).
: wal_total(_wal_total), db_total(_db_total), slow_total(_slow_total) {}
void* get_hint_by_device(uint8_t dev) const override;
- void* get_hint_by_dir(const string& dirname) const override;
+ void* get_hint_by_dir(const std::string& dirname) const override;
void add_usage(void* hint, const bluefs_fnode_t& fnode) override {
// do nothing
uint8_t select_prefer_bdev(void* hint) override;
void get_paths(const std::string& base, paths& res) const override;
- void dump(ostream& sout) override;
+ void dump(std::ostream& sout) override;
};
#endif
// bluestore_txc
MEMPOOL_DEFINE_OBJECT_FACTORY(BlueStore::TransContext, bluestore_transcontext,
bluestore_txc);
-
+using std::deque;
+using std::min;
+using std::make_pair;
+using std::numeric_limits;
+using std::pair;
+using std::list;
+using std::map;
+using std::max;
+using std::ostream;
+using std::ostringstream;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::coarse_mono_clock;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+using ceph::make_timespan;
+using ceph::mono_clock;
+using ceph::mono_time;
+using ceph::timespan_str;
// kv store prefixes
const string PREFIX_SUPER = "S"; // field -> value
crc = t.crc32c(-1);
decode(expected_crc, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
dout(2) << __func__ << " unable to decode label at offset " << p.get_off()
<< ": " << e.what()
<< dendl;
auto p = bl.cbegin();
try {
decode(c->cnode, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " failed to decode cnode, key:"
<< pretty_binary_string(it->key()) << dendl;
return -EIO;
dout(30) << __func__ << " pool " << pool_id
<< " statfs " << st << dendl;
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " failed to decode pool stats, key:"
<< pretty_binary_string(it->key()) << dendl;
}
auto blp = bl.cbegin();
try {
vstatfs.decode(blp);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << "fsck error: failed to decode Pool StatFS record"
<< pretty_binary_string(key) << dendl;
if (repairer) {
++errors;
}
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
derr << "fsck error: failed to retrieve bluefs_extents from kv" << dendl;
++errors;
}
auto blp = bl.cbegin();
try {
decode(shared_blob, blp);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
++errors;
// Force update and don't report as missing
sbi.updated = sbi.passed = true;
bluestore_deferred_transaction_t wt;
try {
decode(wt, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << "fsck error: failed to decode deferred txn "
<< pretty_binary_string(it->key()) << dendl;
if (repair) {
uint64_t v;
decode(v, p);
nid_max = v;
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " unable to read nid_max" << dendl;
return -EIO;
}
uint64_t v;
decode(v, p);
blobid_max = v;
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " unable to read blobid_max" << dendl;
return -EIO;
}
auto p = bl.cbegin();
try {
decode(ondisk_format, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " unable to read ondisk_format" << dendl;
return -EIO;
}
auto p = bl.cbegin();
try {
decode(compat_ondisk_format, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " unable to read compat_ondisk_format" << dendl;
return -EIO;
}
min_alloc_size = val;
min_alloc_size_order = ctz(val);
ceph_assert(min_alloc_size == 1u << min_alloc_size_order);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " unable to read min_alloc_size" << dendl;
return -EIO;
}
uint64_t val;
decode(val, p);
min_alloc_size = val;
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " failed to read min_min_alloc_size" << dendl;
return -EIO;
}
auto p = bl.cbegin();
try {
decode(*deferred_txn, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " failed to decode deferred txn "
<< pretty_binary_string(it->key()) << dendl;
delete deferred_txn;
size_t pad_count = 0;
if (front_pad) {
size_t front_copy = std::min<uint64_t>(chunk_size - front_pad, length);
- bufferptr z = buffer::create_small_page_aligned(chunk_size);
+ bufferptr z = ceph::buffer::create_small_page_aligned(chunk_size);
z.zero(0, front_pad, false);
pad_count += front_pad;
bl->begin().copy(front_copy, z.c_str() + front_pad);
#include "include/cpp-btree/btree_set.h"
#include "include/ceph_assert.h"
+#include "include/interval_set.h"
#include "include/unordered_map.h"
#include "include/mempool.h"
#include "include/hash.h"
cct->_conf.get_val<double>("bluestore_max_defer_interval");
}
- class TransContext;
+ struct TransContext;
- typedef map<uint64_t, bufferlist> ready_regions_t;
+ typedef std::map<uint64_t, ceph::buffer::list> ready_regions_t;
struct BufferSpace;
uint32_t flags; ///< FLAG_*
uint64_t seq;
uint32_t offset, length;
- bufferlist data;
+ ceph::buffer::list data;
boost::intrusive::list_member_hook<> lru_item;
boost::intrusive::list_member_hook<> state_item;
Buffer(BufferSpace *space, unsigned s, uint64_t q, uint32_t o, uint32_t l,
unsigned f = 0)
: space(space), state(s), flags(f), seq(q), offset(o), length(l) {}
- Buffer(BufferSpace *space, unsigned s, uint64_t q, uint32_t o, bufferlist& b,
+ Buffer(BufferSpace *space, unsigned s, uint64_t q, uint32_t o, ceph::buffer::list& b,
unsigned f = 0)
: space(space), state(s), flags(f), seq(q), offset(o),
length(b.length()), data(b) {}
void truncate(uint32_t newlen) {
ceph_assert(newlen < length);
if (data.length()) {
- bufferlist t;
+ ceph::buffer::list t;
t.substr_of(data, 0, newlen);
data.claim(t);
}
}
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_string("state", get_state_name(state));
f->dump_unsigned("seq", seq);
f->dump_unsigned("offset", offset);
_rm_buffer(cache, buffer_map.find(b->offset));
}
void _rm_buffer(BufferCacheShard* cache,
- map<uint32_t, std::unique_ptr<Buffer>>::iterator p) {
+ std::map<uint32_t, std::unique_ptr<Buffer>>::iterator p) {
ceph_assert(p != buffer_map.end());
cache->_audit("_rm_buffer start");
if (p->second->is_writing()) {
cache->_audit("_rm_buffer end");
}
- map<uint32_t,std::unique_ptr<Buffer>>::iterator _data_lower_bound(
+ std::map<uint32_t,std::unique_ptr<Buffer>>::iterator _data_lower_bound(
uint32_t offset) {
auto i = buffer_map.lower_bound(offset);
if (i != buffer_map.begin()) {
}
int _discard(BufferCacheShard* cache, uint32_t offset, uint32_t length);
- void write(BufferCacheShard* cache, uint64_t seq, uint32_t offset, bufferlist& bl,
+ void write(BufferCacheShard* cache, uint64_t seq, uint32_t offset, ceph::buffer::list& bl,
unsigned flags) {
std::lock_guard l(cache->lock);
Buffer *b = new Buffer(this, Buffer::STATE_WRITING, seq, offset, bl,
cache->_trim();
}
void _finish_write(BufferCacheShard* cache, uint64_t seq);
- void did_read(BufferCacheShard* cache, uint32_t offset, bufferlist& bl) {
+ void did_read(BufferCacheShard* cache, uint32_t offset, ceph::buffer::list& bl) {
std::lock_guard l(cache->lock);
Buffer *b = new Buffer(this, Buffer::STATE_CLEAN, 0, offset, bl);
b->cache_private = _discard(cache, offset, bl.length());
void split(BufferCacheShard* cache, size_t pos, BufferSpace &r);
- void dump(BufferCacheShard* cache, Formatter *f) const {
+ void dump(BufferCacheShard* cache, ceph::Formatter *f) const {
std::lock_guard l(cache->lock);
f->open_array_section("buffers");
for (auto& i : buffer_map) {
friend void intrusive_ptr_add_ref(SharedBlob *b) { b->get(); }
friend void intrusive_ptr_release(SharedBlob *b) { b->put(); }
- void dump(Formatter* f) const;
- friend ostream& operator<<(ostream& out, const SharedBlob& sb);
+ void dump(ceph::Formatter* f) const;
+ friend std::ostream& operator<<(std::ostream& out, const SharedBlob& sb);
void get() {
++nref;
private:
mutable bluestore_blob_t blob; ///< decoded blob metadata
#ifdef CACHE_BLOB_BL
- mutable bufferlist blob_bl; ///< cached encoded blob, blob is dirty if empty
+ mutable ceph::buffer::list blob_bl; ///< cached encoded blob, blob is dirty if empty
#endif
/// refs from this shard. ephemeral if id<0, persisted if spanning.
bluestore_blob_use_tracker_t used_in_blob;
friend void intrusive_ptr_add_ref(Blob *b) { b->get(); }
friend void intrusive_ptr_release(Blob *b) { b->put(); }
- void dump(Formatter* f) const;
- friend ostream& operator<<(ostream& out, const Blob &b);
+ void dump(ceph::Formatter* f) const;
+ friend std::ostream& operator<<(std::ostream& out, const Blob &b);
const bluestore_blob_use_tracker_t& get_blob_use_tracker() const {
return used_in_blob;
}
}
void encode(
- bufferlist::contiguous_appender& p,
+ ceph::buffer::list::contiguous_appender& p,
bool include_ref_map) const {
_encode();
p.append(blob_bl);
}
void decode(
Collection */*coll*/,
- bufferptr::const_iterator& p,
+ ceph::buffer::ptr::const_iterator& p,
bool include_ref_map) {
const char *start = p.get_pos();
denc(blob, p);
}
}
void encode(
- bufferlist::contiguous_appender& p,
+ ceph::buffer::list::contiguous_appender& p,
uint64_t struct_v,
uint64_t sbid,
bool include_ref_map) const {
}
void decode(
Collection *coll,
- bufferptr::const_iterator& p,
+ ceph::buffer::ptr::const_iterator& p,
uint64_t struct_v,
uint64_t* sbid,
bool include_ref_map);
}
}
- void dump(Formatter* f) const;
+ void dump(ceph::Formatter* f) const;
void assign_blob(const BlobRef& b) {
ceph_assert(!blob);
typedef boost::intrusive::set<Extent> extent_map_t;
- friend ostream& operator<<(ostream& out, const Extent& e);
+ friend std::ostream& operator<<(std::ostream& out, const Extent& e);
struct OldExtent {
boost::intrusive::list_member_hook<> old_extent_item;
};
mempool::bluestore_cache_other::vector<Shard> shards; ///< shards
- bufferlist inline_bl; ///< cached encoded map, if unsharded; empty=>dirty
+ ceph::buffer::list inline_bl; ///< cached encoded map, if unsharded; empty=>dirty
uint32_t needs_reshard_begin = 0;
uint32_t needs_reshard_end = 0;
clear_needs_reshard();
}
- void dump(Formatter* f) const;
+ void dump(ceph::Formatter* f) const;
- bool encode_some(uint32_t offset, uint32_t length, bufferlist& bl,
+ bool encode_some(uint32_t offset, uint32_t length, ceph::buffer::list& bl,
unsigned *pn);
- unsigned decode_some(bufferlist& bl);
+ unsigned decode_some(ceph::buffer::list& bl);
void bound_encode_spanning_blobs(size_t& p);
- void encode_spanning_blobs(bufferlist::contiguous_appender& p);
- void decode_spanning_blobs(bufferptr::const_iterator& p);
+ void encode_spanning_blobs(ceph::buffer::list::contiguous_appender& p);
+ void decode_spanning_blobs(ceph::buffer::ptr::const_iterator& p);
BlobRef get_spanning_blob(int id) {
auto p = spanning_blob_map.find(id);
The root cause for old_extents use is the need to handle blob ref counts
properly. Old extents still hold blob refs and hence we need to traverse
the collection to determine if blob to be released.
- Protrusive extents are extents that fit into the blob set in action
+ Protrusive extents are extents that fit into the blob std::set in action
(ones that are below the logical range from above) but not removed totally
due to the current write.
E.g. for
}
};
CephContext* cct;
- map<Blob*, BlobInfo> affected_blobs; ///< compressed blobs and their ref_map
+ std::map<Blob*, BlobInfo> affected_blobs; ///< compressed blobs and their ref_map
///< copies that are affected by the
///< specific write
///< (except the case where
///< uncompressed extent follows
///< compressed one - see below).
- BlobInfo* blob_info_counted = nullptr; ///< set if previous allocation unit
+ BlobInfo* blob_info_counted = nullptr; ///< std::set if previous allocation unit
///< caused expected_allocations
///< counter increment at this blob.
///< if uncompressed extent follows
extent_map(this) {
}
Onode(Collection* c, const ghobject_t& o,
- const string& k)
+ const std::string& k)
: s(nullptr),
nref(0),
c(c),
static Onode* decode(
CollectionRef c,
const ghobject_t& oid,
- const string& key,
- const bufferlist& v);
+ const std::string& key,
+ const ceph::buffer::list& v);
- void dump(Formatter* f) const;
+ void dump(ceph::Formatter* f) const;
void flush();
void get() {
}
}
- const string& get_omap_prefix();
- void get_omap_header(string *out);
- void get_omap_key(const string& key, string *out);
- void rewrite_omap_key(const string& old, string *out);
- void get_omap_tail(string *out);
- void decode_omap_key(const string& key, string *user_key);
+ const std::string& get_omap_prefix();
+ void get_omap_header(std::string *out);
+ void get_omap_key(const std::string& key, std::string *out);
+ void rewrite_omap_key(const std::string& old, std::string *out);
+ void get_omap_tail(std::string *out);
+ void decode_omap_key(const std::string& key, std::string *user_key);
};
typedef boost::intrusive_ptr<Onode> OnodeRef;
struct OnodeCacheShard : public CacheShard {
std::atomic<uint64_t> num_pinned = {0};
- std::array<std::pair<ghobject_t, mono_clock::time_point>, 64> dumped_onodes;
+ std::array<std::pair<ghobject_t, ceph::mono_clock::time_point>, 64> dumped_onodes;
public:
OnodeCacheShard(CephContext* cct) : CacheShard(cct) {}
- static OnodeCacheShard *create(CephContext* cct, string type,
+ static OnodeCacheShard *create(CephContext* cct, std::string type,
PerfCounters *logger);
virtual void _add(OnodeRef& o, int level) = 0;
virtual void _rm(OnodeRef& o) = 0;
public:
BufferCacheShard(CephContext* cct) : CacheShard(cct) {}
- static BufferCacheShard *create(CephContext* cct, string type,
+ static BufferCacheShard *create(CephContext* cct, std::string type,
PerfCounters *logger);
virtual void _add(Buffer *b, int level, Buffer *near) = 0;
virtual void _rm(Buffer *b) = 0;
/// forward lookups
mempool::bluestore_cache_other::unordered_map<ghobject_t,OnodeRef> onode_map;
- friend class Collection; // for split_cache()
+ friend struct Collection; // for split_cache()
public:
OnodeSpace(OnodeCacheShard *c) : cache(c) {}
//
// i.e.,
// open = SharedBlob is instantiated
- // shared = blob_t shared flag is set; SharedBlob is hashed.
+ // shared = blob_t shared flag is std::set; SharedBlob is hashed.
// loaded = SharedBlob::shared_blob_t is loaded from kv store
void open_shared_blob(uint64_t sbid, BlobRef b);
void load_shared_blob(SharedBlobRef sb);
CollectionRef c;
OnodeRef o;
KeyValueDB::Iterator it;
- string head, tail;
+ std::string head, tail;
- string _stringify() const;
+ std::string _stringify() const;
public:
OmapIteratorImpl(CollectionRef c, OnodeRef o, KeyValueDB::Iterator it);
int seek_to_first() override;
- int upper_bound(const string &after) override;
- int lower_bound(const string &to) override;
+ int upper_bound(const std::string &after) override;
+ int lower_bound(const std::string &to) override;
bool valid() override;
int next() override;
- string key() override;
- bufferlist value() override;
- std::string tail_key() {
+ std::string key() override;
+ ceph::buffer::list value() override;
+ std::string tail_key() override {
return tail;
}
values[STATFS_COMPRESSED_ORIGINAL] == 0 &&
values[STATFS_COMPRESSED_ALLOCATED] == 0;
}
- void decode(bufferlist::const_iterator& it) {
+ void decode(ceph::buffer::list::const_iterator& it) {
using ceph::decode;
for (size_t i = 0; i < STATFS_LAST; i++) {
decode(values[i], it);
}
}
- void encode(bufferlist& bl) {
+ void encode(ceph::buffer::list& bl) {
using ceph::encode;
for (size_t i = 0; i < STATFS_LAST; i++) {
encode(values[i], bl);
uint64_t bytes = 0, ios = 0, cost = 0;
- set<OnodeRef> onodes; ///< these need to be updated/written
- set<OnodeRef> modified_objects; ///< objects we modified (and need a ref)
- set<SharedBlobRef> shared_blobs; ///< these need to be updated/written
- set<SharedBlobRef> shared_blobs_written; ///< update these on io completion
+ std::set<OnodeRef> onodes; ///< these need to be updated/written
+ std::set<OnodeRef> modified_objects; ///< objects we modified (and need a ref)
+ std::set<SharedBlobRef> shared_blobs; ///< these need to be updated/written
+ std::set<SharedBlobRef> shared_blobs_written; ///< update these on io completion
KeyValueDB::Transaction t; ///< then we will commit this
- list<Context*> oncommits; ///< more commit completions
- list<CollectionRef> removed_collections; ///< colls we removed
+ std::list<Context*> oncommits; ///< more commit completions
+ std::list<CollectionRef> removed_collections; ///< colls we removed
boost::intrusive::list_member_hook<> deferred_queue_item;
bluestore_deferred_transaction_t *deferred_txn = nullptr; ///< if any
interval_set<uint64_t> allocated, released;
volatile_statfs statfs_delta; ///< overall store statistics delta
uint64_t osd_pool_id = META_POOL_ID; ///< osd pool id we're operating on
-
+
IOContext ioc;
bool had_ios = false; ///< true if we submitted IOs before our kv txn
uint64_t seq = 0;
- mono_clock::time_point start;
- mono_clock::time_point last_stamp;
+ ceph::mono_clock::time_point start;
+ ceph::mono_clock::time_point last_stamp;
uint64_t last_nid = 0; ///< if non-zero, highest new nid we allocated
uint64_t last_blobid = 0; ///< if non-zero, highest new blobid we allocated
#endif
explicit TransContext(CephContext* cct, Collection *c, OpSequencer *o,
- list<Context*> *on_commits)
+ std::list<Context*> *on_commits)
: ch(c),
osr(o),
ioc(cct, this),
- start(mono_clock::now()) {
+ start(ceph::mono_clock::now()) {
last_stamp = start;
if (on_commits) {
oncommits.swap(*on_commits);
class BlueStoreThrottle {
#if defined(WITH_LTTNG)
- const std::chrono::time_point<mono_clock> time_base = mono_clock::now();
+ const std::chrono::time_point<ceph::mono_clock> time_base = ceph::mono_clock::now();
// Time of last chosen io (microseconds)
std::atomic<uint64_t> previous_emitted_tp_time_mono_mcs = {0};
} else {
ios_started_since_last_traced++;
auto now_mcs = ceph::to_microseconds<uint64_t>(
- mono_clock::now() - time_base);
+ ceph::mono_clock::now() - time_base);
uint64_t previous_mcs = previous_emitted_tp_time_mono_mcs;
uint64_t period_mcs = now_mcs - previous_mcs;
if (period_mcs > min_period_mcs) {
void emit_initial_tracepoint(
KeyValueDB &db,
TransContext &txc,
- mono_clock::time_point);
+ ceph::mono_clock::time_point);
#else
void emit_initial_tracepoint(
KeyValueDB &db,
TransContext &txc,
- mono_clock::time_point) {}
+ ceph::mono_clock::time_point) {}
#endif
Throttle throttle_bytes; ///< submit to commit
void complete(TransContext &txc) {}
#endif
- mono_clock::duration log_state_latency(
+ ceph::mono_clock::duration log_state_latency(
TransContext &txc, PerfCounters *logger, int state);
bool try_start_transaction(
KeyValueDB &db,
TransContext &txc,
- mono_clock::time_point);
+ ceph::mono_clock::time_point);
void finish_start_transaction(
KeyValueDB &db,
TransContext &txc,
- mono_clock::time_point);
+ ceph::mono_clock::time_point);
void release_kv_throttle(uint64_t cost) {
throttle_bytes.put(cost);
}
struct DeferredBatch final : public AioContext {
OpSequencer *osr;
struct deferred_io {
- bufferlist bl; ///< data
+ ceph::buffer::list bl; ///< data
uint64_t seq; ///< deferred transaction seq
};
- map<uint64_t,deferred_io> iomap; ///< map of ios in this batch
+ std::map<uint64_t,deferred_io> iomap; ///< map of ios in this batch
deferred_queue_t txcs; ///< txcs in this batch
IOContext ioc; ///< our aios
/// bytes of pending io for each deferred seq (may be 0)
- map<uint64_t,int> seq_bytes;
+ std::map<uint64_t,int> seq_bytes;
void _discard(CephContext *cct, uint64_t offset, uint64_t length);
void _audit(CephContext *cct);
/// prepare a write
void prepare_write(CephContext *cct,
uint64_t seq, uint64_t offset, uint64_t length,
- bufferlist::const_iterator& p);
+ ceph::buffer::list::const_iterator& p);
void aio_finish(BlueStore *store) override {
store->_deferred_aio_finish(osr);
std::atomic_int kv_submitted_waiters = {0};
- std::atomic_bool zombie = {false}; ///< in zombie_osr set (collection going away)
+ std::atomic_bool zombie = {false}; ///< in zombie_osr std::set (collection going away)
const uint32_t sequencer_id;
void flush() {
std::unique_lock l(qlock);
while (true) {
- // set flag before the check because the condition
+ // std::set flag before the check because the condition
// may become true outside qlock, and we need to make
// sure those threads see waiters and signal qcond.
++kv_submitted_waiters;
std::unique_lock l(qlock);
assert (q.size() >= 1);
while (true) {
- // set flag before the check because the condition
+ // std::set flag before the check because the condition
// may become true outside qlock, and we need to make
// sure those threads see waiters and signal qcond.
++kv_submitted_waiters;
struct key_dist {
uint64_t count;
uint32_t max_len;
- map<int, struct value_dist> val_map; ///< slab id to count, max length of value and key
+ std::map<int, struct value_dist> val_map; ///< slab id to count, max length of value and key
};
- map<string, map<int, struct key_dist> > key_hist;
- map<int, uint64_t> value_hist;
+ std::map<std::string, std::map<int, struct key_dist> > key_hist;
+ std::map<int, uint64_t> value_hist;
int get_key_slab(size_t sz);
- string get_key_slab_to_range(int slab);
+ std::string get_key_slab_to_range(int slab);
int get_value_slab(size_t sz);
- string get_value_slab_to_range(int slab);
- void update_hist_entry(map<string, map<int, struct key_dist> > &key_hist,
- const string &prefix, size_t key_size, size_t value_size);
- void dump(Formatter *f);
+ std::string get_value_slab_to_range(int slab);
+ void update_hist_entry(std::map<std::string, std::map<int, struct key_dist> > &key_hist,
+ const std::string &prefix, size_t key_size, size_t value_size);
+ void dump(ceph::Formatter *f);
};
// --------------------------------------------------------
private:
BlueFS *bluefs = nullptr;
bluefs_layout_t bluefs_layout;
- mono_time bluefs_last_balance;
+ ceph::mono_time bluefs_last_balance;
utime_t next_dump_on_bluefs_alloc_failure;
KeyValueDB *db = nullptr;
ceph::shared_mutex coll_lock = ceph::make_shared_mutex("BlueStore::coll_lock"); ///< rwlock to protect coll_map
mempool::bluestore_cache_other::unordered_map<coll_t, CollectionRef> coll_map;
bool collections_had_errors = false;
- map<coll_t,CollectionRef> new_coll_map;
+ std::map<coll_t,CollectionRef> new_coll_map;
- vector<OnodeCacheShard*> onode_cache_shards;
- vector<BufferCacheShard*> buffer_cache_shards;
+ std::vector<OnodeCacheShard*> onode_cache_shards;
+ std::vector<BufferCacheShard*> buffer_cache_shards;
/// protect zombie_osr_set
ceph::mutex zombie_osr_lock = ceph::make_mutex("BlueStore::zombie_osr_lock");
uint32_t next_sequencer_id = 0;
- std::map<coll_t,OpSequencerRef> zombie_osr_set; ///< set of OpSequencers for deleted collections
+ std::map<coll_t,OpSequencerRef> zombie_osr_set; ///< std::set of OpSequencers for deleted collections
std::atomic<uint64_t> nid_last = {0};
std::atomic<uint64_t> nid_max = {0};
std::atomic<uint64_t> deferred_seq = {0};
deferred_osr_queue_t deferred_queue; ///< osr's with deferred io pending
int deferred_queue_size = 0; ///< num txc's queued across all osrs
- atomic_int deferred_aggressive = {0}; ///< aggressive wakeup of kv thread
+ std::atomic_int deferred_aggressive = {0}; ///< aggressive wakeup of kv thread
Finisher finisher;
utime_t deferred_last_submitted = utime_t();
bool kv_stop = false;
bool kv_finalize_started = false;
bool kv_finalize_stop = false;
- deque<TransContext*> kv_queue; ///< ready, already submitted
- deque<TransContext*> kv_queue_unsubmitted; ///< ready, need submit by kv thread
- deque<TransContext*> kv_committing; ///< currently syncing
- deque<DeferredBatch*> deferred_done_queue; ///< deferred ios done
+ std::deque<TransContext*> kv_queue; ///< ready, already submitted
+ std::deque<TransContext*> kv_queue_unsubmitted; ///< ready, need submit by kv thread
+ std::deque<TransContext*> kv_committing; ///< currently syncing
+ std::deque<DeferredBatch*> deferred_done_queue; ///< deferred ios done
bool kv_sync_in_progress = false;
KVFinalizeThread kv_finalize_thread;
ceph::mutex kv_finalize_lock = ceph::make_mutex("BlueStore::kv_finalize_lock");
ceph::condition_variable kv_finalize_cond;
- deque<TransContext*> kv_committing_to_finalize; ///< pending finalization
- deque<DeferredBatch*> deferred_stable_to_finalize; ///< pending finalization
+ std::deque<TransContext*> kv_committing_to_finalize; ///< pending finalization
+ std::deque<DeferredBatch*> deferred_stable_to_finalize; ///< pending finalization
bool kv_finalize_in_progress = false;
PerfCounters *logger = nullptr;
- list<CollectionRef> removed_collections;
+ std::list<CollectionRef> removed_collections;
ceph::shared_mutex debug_read_error_lock =
ceph::make_shared_mutex("BlueStore::debug_read_error_lock");
- set<ghobject_t> debug_data_error_objects;
- set<ghobject_t> debug_mdata_error_objects;
+ std::set<ghobject_t> debug_data_error_objects;
+ std::set<ghobject_t> debug_mdata_error_objects;
std::atomic<int> csum_type = {Checksummer::CSUM_CRC32C};
double max_defer_interval = 0; ///< Time to wait between last deferred submit
std::atomic<uint32_t> config_changed = {0}; ///< Counter to determine if there is a configuration change.
- typedef map<uint64_t, volatile_statfs> osd_pools_map;
+ typedef std::map<uint64_t, volatile_statfs> osd_pools_map;
ceph::mutex vstatfs_lock = ceph::make_mutex("BlueStore::vstatfs_lock");
volatile_statfs vstatfs;
virtual void set_cache_ratio(double ratio) {
cache_ratio = ratio;
}
- virtual string get_cache_name() const = 0;
+ virtual std::string get_cache_name() const = 0;
};
struct MetaCache : public MempoolCache {
mempool::bluestore_cache_onode::allocated_bytes();
}
- virtual string get_cache_name() const {
+ virtual std::string get_cache_name() const {
return "BlueStore Meta Cache";
}
}
return bytes;
}
- virtual string get_cache_name() const {
+ virtual std::string get_cache_name() const {
return "BlueStore Data Cache";
}
};
void _fsck_collections(int64_t* errors);
void _close_collections();
- int _setup_block_symlink_or_file(string name, string path, uint64_t size,
+ int _setup_block_symlink_or_file(std::string name, std::string path, uint64_t size,
bool create);
public:
}
static int _write_bdev_label(CephContext* cct,
- string path, bluestore_bdev_label_t label);
- static int _read_bdev_label(CephContext* cct, string path,
+ std::string path, bluestore_bdev_label_t label);
+ static int _read_bdev_label(CephContext* cct, std::string path,
bluestore_bdev_label_t *label);
private:
- int _check_or_set_bdev_label(string path, uint64_t size, string desc,
+ int _check_or_set_bdev_label(std::string path, uint64_t size, std::string desc,
bool create);
int _open_super_meta();
friend void _dump_transaction(CephContext *cct, Transaction *t);
TransContext *_txc_create(Collection *c, OpSequencer *osr,
- list<Context*> *on_commits);
+ std::list<Context*> *on_commits);
void _txc_update_store_statfs(TransContext *txc);
void _txc_add_transaction(TransContext *txc, Transaction *t);
void _txc_calc_cost(TransContext *txc);
TransContext *txc,
BlobRef b,
uint64_t offset,
- bufferlist& bl,
+ ceph::buffer::list& bl,
unsigned flags) {
b->shared_blob->bc.write(b->shared_blob->get_cache(), txc->seq, offset, bl,
flags);
int _collection_list(
Collection *c, const ghobject_t& start, const ghobject_t& end,
- int max, vector<ghobject_t> *ls, ghobject_t *next);
+ int max, std::vector<ghobject_t> *ls, ghobject_t *next);
template <typename T, typename F>
T select_option(const std::string& opt_name, T val1, F f) {
void _apply_padding(uint64_t head_pad,
uint64_t tail_pad,
- bufferlist& padded);
+ ceph::buffer::list& padded);
void _record_onode(OnodeRef &o, KeyValueDB::Transaction &txn);
// --- public interface ---
public:
- BlueStore(CephContext *cct, const string& path);
- BlueStore(CephContext *cct, const string& path, uint64_t min_alloc_size); // Ctor for UT only
+ BlueStore(CephContext *cct, const std::string& path);
+ BlueStore(CephContext *cct, const std::string& path, uint64_t min_alloc_size); // Ctor for UT only
~BlueStore() override;
- string get_type() override {
+ std::string get_type() override {
return "bluestore";
}
return min_alloc_size;
}
- int get_devices(set<string> *ls) override;
+ int get_devices(std::set<std::string> *ls) override;
bool is_rotational() override;
bool is_journal_rotational() override;
- string get_default_device_class() override {
- string device_class;
- map<string, string> metadata;
+ std::string get_default_device_class() override {
+ std::string device_class;
+ std::map<std::string, std::string> metadata;
collect_metadata(&metadata);
auto it = metadata.find("bluestore_bdev_type");
if (it != metadata.end()) {
int get_numa_node(
int *numa_node,
- set<int> *nodes,
- set<string> *failed) override;
+ std::set<int> *nodes,
+ std::set<std::string> *failed) override;
- static int get_block_device_fsid(CephContext* cct, const string& path,
+ static int get_block_device_fsid(CephContext* cct, const std::string& path,
uuid_d *fsid);
bool test_mount_in_use() override;
}
void set_cache_shards(unsigned num) override;
- void dump_cache_stats(Formatter *f) override {
+ void dump_cache_stats(ceph::Formatter *f) override {
int onode_count = 0, buffers_bytes = 0;
for (auto i: onode_cache_shards) {
onode_count += i->_get_num();
f->dump_int("bluestore_onode", onode_count);
f->dump_int("bluestore_buffers", buffers_bytes);
}
- void dump_cache_stats(ostream& ss) override {
+ void dump_cache_stats(std::ostream& ss) override {
int onode_count = 0, buffers_bytes = 0;
for (auto i: onode_cache_shards) {
onode_count += i->_get_num();
return 0;
}
- void get_db_statistics(Formatter *f) override;
- void generate_db_histogram(Formatter *f) override;
+ void get_db_statistics(ceph::Formatter *f) override;
+ void generate_db_histogram(ceph::Formatter *f) override;
void _flush_cache();
- int flush_cache(ostream *os = NULL) override;
- void dump_perf_counters(Formatter *f) override {
+ int flush_cache(std::ostream *os = NULL) override;
+ void dump_perf_counters(ceph::Formatter *f) override {
f->open_object_section("perf_counters");
logger->dump_formatted(f, false);
f->close_section();
}
- int add_new_bluefs_device(int id, const string& path);
- int migrate_to_existing_bluefs_device(const set<int>& devs_source,
+ int add_new_bluefs_device(int id, const std::string& path);
+ int migrate_to_existing_bluefs_device(const std::set<int>& devs_source,
int id);
- int migrate_to_new_bluefs_device(const set<int>& devs_source,
+ int migrate_to_new_bluefs_device(const std::set<int>& devs_source,
int id,
- const string& path);
- int expand_devices(ostream& out);
- string get_device_path(unsigned id);
+ const std::string& path);
+ int expand_devices(std::ostream& out);
+ std::string get_device_path(unsigned id);
public:
int statfs(struct store_statfs_t *buf,
int pool_statfs(uint64_t pool_id, struct store_statfs_t *buf,
bool *per_pool_omap) override;
- void collect_metadata(map<string,string> *pm) override;
+ void collect_metadata(std::map<std::string,std::string> *pm) override;
bool exists(CollectionHandle &c, const ghobject_t& oid) override;
int set_collection_opts(
const ghobject_t& oid,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags = 0) override;
private:
length(from.length),
front(from.front){}
- friend ostream& operator<<(ostream& out, const region_t& r) {
+ friend std::ostream& operator<<(std::ostream& out, const region_t& r) {
return out << "0x" << std::hex << r.logical_offset << ":"
<< r.blob_xoffset << "~" << r.length << std::dec;
}
struct read_req_t {
uint64_t r_off = 0;
uint64_t r_len = 0;
- bufferlist bl;
+ ceph::buffer::list bl;
std::list<region_t> regs; // original read regions
read_req_t(uint64_t off, uint64_t len) : r_off(off), r_len(len) {}
- friend ostream& operator<<(ostream& out, const read_req_t& r) {
+ friend std::ostream& operator<<(std::ostream& out, const read_req_t& r) {
out << "{<0x" << std::hex << r.r_off << ", 0x" << r.r_len << "> : [";
for (const auto& reg : r.regs)
out << reg;
}
};
- typedef list<read_req_t> regions2read_t;
- typedef map<BlueStore::BlobRef, regions2read_t> blobs2read_t;
+ typedef std::list<read_req_t> regions2read_t;
+ typedef std::map<BlueStore::BlobRef, regions2read_t> blobs2read_t;
void _read_cache(
OnodeRef o,
int _prepare_read_ioc(
blobs2read_t& blobs2read,
- vector<bufferlist>* compressed_blob_bls,
+ std::vector<ceph::buffer::list>* compressed_blob_bls,
IOContext* ioc);
int _generate_read_result_bl(
uint64_t offset,
size_t length,
ready_regions_t& ready_regions,
- vector<bufferlist>& compressed_blob_bls,
+ std::vector<ceph::buffer::list>& compressed_blob_bls,
blobs2read_t& blobs2read,
bool buffered,
bool* csum_error,
- bufferlist& bl);
+ ceph::buffer::list& bl);
int _do_read(
Collection *c,
OnodeRef o,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags = 0,
uint64_t retry_count = 0);
Collection *c,
OnodeRef o,
const interval_set<uint64_t>& m,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags = 0,
uint64_t retry_count = 0);
int _fiemap(CollectionHandle &c_, const ghobject_t& oid,
- uint64_t offset, size_t len, interval_set<uint64_t>& destset);
+ uint64_t offset, size_t len, interval_set<uint64_t>& destset);
public:
int fiemap(CollectionHandle &c, const ghobject_t& oid,
- uint64_t offset, size_t len, bufferlist& bl) override;
+ uint64_t offset, size_t len, ceph::buffer::list& bl) override;
int fiemap(CollectionHandle &c, const ghobject_t& oid,
- uint64_t offset, size_t len, map<uint64_t, uint64_t>& destmap) override;
+ uint64_t offset, size_t len, std::map<uint64_t, uint64_t>& destmap) override;
int readv(
CollectionHandle &c_,
const ghobject_t& oid,
interval_set<uint64_t>& m,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags) override;
int dump_onode(CollectionHandle &c, const ghobject_t& oid,
- const string& section_name, Formatter *f) override;
+ const std::string& section_name, ceph::Formatter *f) override;
int getattr(CollectionHandle &c, const ghobject_t& oid, const char *name,
- bufferptr& value) override;
+ ceph::buffer::ptr& value) override;
int getattrs(CollectionHandle &c, const ghobject_t& oid,
- map<string,bufferptr>& aset) override;
+ std::map<std::string,ceph::buffer::ptr>& aset) override;
- int list_collections(vector<coll_t>& ls) override;
+ int list_collections(std::vector<coll_t>& ls) override;
CollectionHandle open_collection(const coll_t &c) override;
CollectionHandle create_new_collection(const coll_t& cid) override;
const ghobject_t& start,
const ghobject_t& end,
int max,
- vector<ghobject_t> *ls, ghobject_t *next) override;
+ std::vector<ghobject_t> *ls, ghobject_t *next) override;
int omap_get(
CollectionHandle &c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
- map<string, bufferlist> *out /// < [out] Key to value map
+ ceph::buffer::list *header, ///< [out] omap header
+ std::map<std::string, ceph::buffer::list> *out /// < [out] Key to value map
) override;
int _omap_get(
Collection *c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
- map<string, bufferlist> *out /// < [out] Key to value map
+ ceph::buffer::list *header, ///< [out] omap header
+ std::map<std::string, ceph::buffer::list> *out /// < [out] Key to value map
);
int _onode_omap_get(
const OnodeRef &o, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
- map<string, bufferlist> *out /// < [out] Key to value map
+ ceph::buffer::list *header, ///< [out] omap header
+ std::map<std::string, ceph::buffer::list> *out /// < [out] Key to value map
);
int omap_get_header(
CollectionHandle &c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
+ ceph::buffer::list *header, ///< [out] omap header
bool allow_eio = false ///< [in] don't assert on eio
) override;
int omap_get_keys(
CollectionHandle &c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- set<string> *keys ///< [out] Keys defined on oid
+ std::set<std::string> *keys ///< [out] Keys defined on oid
) override;
/// Get key values
int omap_get_values(
CollectionHandle &c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to get
- map<string, bufferlist> *out ///< [out] Returned keys and values
+ const std::set<std::string> &keys, ///< [in] Keys to get
+ std::map<std::string, ceph::buffer::list> *out ///< [out] Returned keys and values
) override;
#ifdef WITH_SEASTAR
int omap_get_values(
CollectionHandle &c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const std::optional<string> &start_after, ///< [in] Keys to get
- map<string, bufferlist> *out ///< [out] Returned keys and values
+ const std::optional<std::string> &start_after, ///< [in] Keys to get
+ std::map<std::string, ceph::buffer::list> *out ///< [out] Returned keys and values
) override;
#endif
int omap_check_keys(
CollectionHandle &c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to check
- set<string> *out ///< [out] Subset of keys defined on oid
+ const std::set<std::string> &keys, ///< [in] Keys to check
+ std::set<std::string> *out ///< [out] Subset of keys defined on oid
) override;
ObjectMap::ObjectMapIterator get_omap_iterator(
int queue_transactions(
CollectionHandle& ch,
- vector<Transaction>& tls,
+ std::vector<Transaction>& tls,
TrackedOpRef op = TrackedOpRef(),
ThreadPool::TPHandle *handle = NULL) override;
}
/// methods to inject various errors fsck can repair
- void inject_broken_shared_blob_key(const string& key,
- const bufferlist& bl);
+ void inject_broken_shared_blob_key(const std::string& key,
+ const ceph::buffer::list& bl);
void inject_leaked(uint64_t len);
void inject_false_free(coll_t cid, ghobject_t oid);
- void inject_statfs(const string& key, const store_statfs_t& new_statfs);
+ void inject_statfs(const std::string& key, const store_statfs_t& new_statfs);
void inject_global_statfs(const store_statfs_t& new_statfs);
void inject_misreference(coll_t cid1, ghobject_t oid1,
coll_t cid2, ghobject_t oid2,
int idx,
const ceph::timespan& lat,
double lat_threshold,
- std::function<string (const ceph::timespan& lat)> fn) const;
+ std::function<std::string (const ceph::timespan& lat)> fn) const;
private:
bool _debug_data_eio(const ghobject_t& o) {
}
private:
ceph::mutex qlock = ceph::make_mutex("BlueStore::Alerts::qlock");
- string failed_cmode;
- set<string> failed_compressors;
- string spillover_alert;
- string legacy_statfs_alert;
- string no_per_pool_omap_alert;
- string disk_size_mismatch_alert;
+ std::string failed_cmode;
+ std::set<std::string> failed_compressors;
+ std::string spillover_alert;
+ std::string legacy_statfs_alert;
+ std::string no_per_pool_omap_alert;
+ std::string disk_size_mismatch_alert;
void _log_alerts(osd_alert_list_t& alerts);
bool _set_compression_alert(bool cmode, const char* s) {
failed_cmode.clear();
}
- void _set_spillover_alert(const string& s) {
+ void _set_spillover_alert(const std::string& s) {
std::lock_guard l(qlock);
spillover_alert = s;
}
void _check_legacy_statfs_alert();
void _check_no_per_pool_omap_alert();
- void _set_disk_size_mismatch_alert(const string& s) {
+ void _set_disk_size_mismatch_alert(const std::string& s) {
std::lock_guard l(qlock);
disk_size_mismatch_alert = s;
}
OnodeRef& o,
const bluestore_blob_t* blob,
uint64_t blob_xoffset,
- const bufferlist& bl,
+ const ceph::buffer::list& bl,
uint64_t logical_offset) const;
- int _decompress(bufferlist& source, bufferlist* result);
+ int _decompress(ceph::buffer::list& source, ceph::buffer::list* result);
// --------------------------------------------------------
BlobRef b;
uint64_t blob_length;
uint64_t b_off;
- bufferlist bl;
+ ceph::buffer::list bl;
uint64_t b_off0; ///< original offset in a blob prior to padding
uint64_t length0; ///< original data length prior to padding
bool new_blob; ///< whether new blob was created
bool compressed = false;
- bufferlist compressed_bl;
+ ceph::buffer::list compressed_bl;
size_t compressed_len = 0;
write_item(
BlobRef b,
uint64_t blob_len,
uint64_t o,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint64_t o0,
uint64_t l0,
bool _mark_unused,
mark_unused(_mark_unused),
new_blob(_new_blob) {}
};
- vector<write_item> writes; ///< blobs we're writing
+ std::vector<write_item> writes; ///< blobs we're writing
/// partial clone of the context
void fork(const WriteContext& other) {
BlobRef b,
uint64_t blob_len,
uint64_t o,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint64_t o0,
uint64_t len0,
bool _mark_unused,
CollectionRef &c,
OnodeRef o,
uint64_t offset, uint64_t length,
- bufferlist::iterator& blp,
+ ceph::buffer::list::iterator& blp,
WriteContext *wctx);
void _do_write_big(
TransContext *txc,
CollectionRef &c,
OnodeRef o,
uint64_t offset, uint64_t length,
- bufferlist::iterator& blp,
+ ceph::buffer::list::iterator& blp,
WriteContext *wctx);
int _do_alloc_write(
TransContext *txc,
CollectionRef& c,
OnodeRef o,
WriteContext *wctx,
- set<SharedBlob*> *maybe_unshared_blobs=0);
+ std::set<SharedBlob*> *maybe_unshared_blobs=0);
int _write(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
uint64_t offset, size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t fadvise_flags);
- void _pad_zeros(bufferlist *bl, uint64_t *offset,
+ void _pad_zeros(ceph::buffer::list *bl, uint64_t *offset,
uint64_t chunk_size);
void _choose_write_options(CollectionRef& c,
CollectionRef &c,
OnodeRef o,
uint64_t offset, uint64_t length,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t fadvise_flags);
void _do_write_data(TransContext *txc,
CollectionRef& c,
OnodeRef o,
uint64_t offset,
uint64_t length,
- bufferlist& bl,
+ ceph::buffer::list& bl,
WriteContext *wctx);
int _touch(TransContext *txc,
CollectionRef& c,
OnodeRef o,
uint64_t offset,
- set<SharedBlob*> *maybe_unshared_blobs=0);
+ std::set<SharedBlob*> *maybe_unshared_blobs=0);
int _truncate(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
int _setattr(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const string& name,
- bufferptr& val);
+ const std::string& name,
+ ceph::buffer::ptr& val);
int _setattrs(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const map<string,bufferptr>& aset);
+ const std::map<std::string,ceph::buffer::ptr>& aset);
int _rmattr(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const string& name);
+ const std::string& name);
int _rmattrs(TransContext *txc,
CollectionRef& c,
OnodeRef& o);
int _omap_setkeys(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& bl);
+ ceph::buffer::list& bl);
int _omap_setheader(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& header);
+ ceph::buffer::list& header);
int _omap_rmkeys(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& bl);
+ ceph::buffer::list& bl);
int _omap_rmkey_range(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const string& first, const string& last);
+ const std::string& first, const std::string& last);
int _set_alloc_hint(
TransContext *txc,
CollectionRef& c,
struct sb_info_t {
coll_t cid;
int64_t pool_id = INT64_MIN;
- list<ghobject_t> oids;
+ std::list<ghobject_t> oids;
BlueStore::SharedBlobRef sb;
bluestore_extent_ref_map_t ref_map;
bool compressed = false;
int64_t pool_id,
CollectionRef c,
const ghobject_t& oid,
- const string& key,
- const bufferlist& value,
- mempool::bluestore_fsck::list<string>* expecting_shards,
- map<BlobRef, bluestore_blob_t::unused_t>* referenced,
+ const std::string& key,
+ const ceph::buffer::list& value,
+ mempool::bluestore_fsck::list<std::string>* expecting_shards,
+ std::map<BlobRef, bluestore_blob_t::unused_t>* referenced,
const BlueStore::FSCK_ObjectCtx& ctx);
private:
FSCK_ObjectCtx& ctx);
};
-inline ostream& operator<<(ostream& out, const BlueStore::volatile_statfs& s) {
+inline std::ostream& operator<<(std::ostream& out, const BlueStore::volatile_statfs& s) {
return out
<< " allocated:"
<< s.values[BlueStore::volatile_statfs::STATFS_ALLOCATED]
};
public:
void fix_per_pool_omap(KeyValueDB *db);
- bool remove_key(KeyValueDB *db, const string& prefix, const string& key);
+ bool remove_key(KeyValueDB *db, const std::string& prefix, const std::string& key);
bool fix_shared_blob(KeyValueDB *db,
uint64_t sbid,
- const bufferlist* bl);
- bool fix_statfs(KeyValueDB *db, const string& key,
+ const ceph::buffer::list* bl);
+ bool fix_statfs(KeyValueDB *db, const std::string& key,
const store_statfs_t& new_statfs);
bool fix_leaked(KeyValueDB *db,
ceph_assert(dev == BlueFS::BDEV_WAL); // others aren't used atm
return reinterpret_cast<void*>(LEVEL_WAL);
}
- void* get_hint_by_dir(const string& dirname) const override;
+ void* get_hint_by_dir(const std::string& dirname) const override;
void add_usage(void* hint, const bluefs_fnode_t& fnode) override {
if (hint == nullptr)
const std::string& base,
BlueFSVolumeSelector::paths& res) const override;
- void dump(ostream& sout) override;
+ void dump(std::ostream& sout) override;
};
#endif
FreelistManager *FreelistManager::create(
CephContext* cct,
- string type,
- string prefix)
+ std::string type,
+ std::string prefix)
{
// a bit of a hack... we hard-code the prefixes here. we need to
// put the freelistmanagers in different prefixes because the merge
static FreelistManager *create(
CephContext* cct,
- string type,
- string prefix);
+ std::string type,
+ std::string prefix);
static void setup_merge_operators(KeyValueDB *db);
#undef dout_prefix
#define dout_prefix *_dout << "bdev(" << this << " " << path << ") "
+using std::list;
+using std::map;
+using std::string;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::make_timespan;
+using ceph::mono_clock;
+using ceph::operator <<;
+
KernelDevice::KernelDevice(CephContext* cct, aio_callback_t cb, void *cbpriv, aio_callback_t d_cb, void *d_cbpriv)
: BlockDevice(cct, cb, cbpriv),
aio(false), dio(false),
ioc->pending_aios.push_back(aio_t(ioc, choose_fd(false, write_hint)));
++ioc->num_pending;
auto& aio = ioc->pending_aios.back();
- bufferptr p = buffer::create_small_page_aligned(len);
+ bufferptr p = ceph::buffer::create_small_page_aligned(len);
aio.bl.append(std::move(p));
aio.bl.prepare_iov(&aio.iov);
aio.preadv(off, len);
auto start1 = mono_clock::now();
- auto p = buffer::ptr_node::create(buffer::create_small_page_aligned(len));
+ auto p = ceph::buffer::ptr_node::create(ceph::buffer::create_small_page_aligned(len));
int r = ::pread(buffered ? fd_buffereds[WRITE_LIFE_NOT_SET] : fd_directs[WRITE_LIFE_NOT_SET],
p->c_str(), len, off);
auto age = cct->_conf->bdev_debug_aio_log_age;
ioc->pending_aios.push_back(aio_t(ioc, fd_directs[WRITE_LIFE_NOT_SET]));
++ioc->num_pending;
aio_t& aio = ioc->pending_aios.back();
- bufferptr p = buffer::create_small_page_aligned(len);
+ bufferptr p = ceph::buffer::create_small_page_aligned(len);
aio.bl.append(std::move(p));
aio.bl.prepare_iov(&aio.iov);
aio.preadv(off, len);
{
uint64_t aligned_off = p2align(off, block_size);
uint64_t aligned_len = p2roundup(off+len, block_size) - aligned_off;
- bufferptr p = buffer::create_small_page_aligned(aligned_len);
+ bufferptr p = ceph::buffer::create_small_page_aligned(aligned_len);
int r = 0;
auto start1 = mono_clock::now();
if (r < 0) {
r = -errno;
derr << __func__ << " direct_aligned_read" << " 0x" << std::hex
- << off << "~" << left << std::dec << " error: " << cpp_strerror(r)
+ << off << "~" << std::left << std::dec << " error: " << cpp_strerror(r)
<< dendl;
goto out;
}
bool aio, dio;
int vdo_fd = -1; ///< fd for vdo sysfs directory
- string vdo_name;
+ std::string vdo_name;
std::string devname; ///< kernel dev name (/sys/block/$devname), if any
void _aio_log_start(IOContext *ioc, uint64_t offset, uint64_t length);
void _aio_log_finish(IOContext *ioc, uint64_t offset, uint64_t length);
- int _sync_write(uint64_t off, bufferlist& bl, bool buffered, int write_hint);
+ int _sync_write(uint64_t off, ceph::buffer::list& bl, bool buffered, int write_hint);
int _lock();
void aio_submit(IOContext *ioc) override;
void discard_drain() override;
- int collect_metadata(const std::string& prefix, map<std::string,std::string> *pm) const override;
+ int collect_metadata(const std::string& prefix, std::map<std::string,std::string> *pm) const override;
int get_devname(std::string *s) const override {
if (devname.empty()) {
return -ENOENT;
bool get_thin_utilization(uint64_t *total, uint64_t *avail) const override;
- int read(uint64_t off, uint64_t len, bufferlist *pbl,
+ int read(uint64_t off, uint64_t len, ceph::buffer::list *pbl,
IOContext *ioc,
bool buffered) override;
- int aio_read(uint64_t off, uint64_t len, bufferlist *pbl,
+ int aio_read(uint64_t off, uint64_t len, ceph::buffer::list *pbl,
IOContext *ioc) override;
int read_random(uint64_t off, uint64_t len, char *buf, bool buffered) override;
- int write(uint64_t off, bufferlist& bl, bool buffered, int write_hint = WRITE_LIFE_NOT_SET) override;
- int aio_write(uint64_t off, bufferlist& bl,
+ int write(uint64_t off, ceph::buffer::list& bl, bool buffered, int write_hint = WRITE_LIFE_NOT_SET) override;
+ int aio_write(uint64_t off, ceph::buffer::list& bl,
IOContext *ioc,
bool buffered,
int write_hint = WRITE_LIFE_NOT_SET) override;
int64_t block_size;
typedef mempool::bluestore_alloc::pool_allocator<
- pair<const uint64_t,uint64_t>> allocator_t;
+ std::pair<const uint64_t,uint64_t>> allocator_t;
typedef btree::btree_map<uint64_t,uint64_t,std::less<uint64_t>,allocator_t> interval_set_map_t;
typedef interval_set<uint64_t,interval_set_map_t> interval_set_t;
std::vector<interval_set_t> free; ///< leading-edge copy
#include "include/uuid.h"
#include "include/stringify.h"
+using std::list;
+using std::ostream;
+
+using ceph::bufferlist;
+using ceph::Formatter;
+
// bluefs_extent_t
void bluefs_extent_t::dump(Formatter *f) const
{
DECODE_FINISH(p);
uint32_t actual = op_bl.crc32c(-1);
if (actual != crc)
- throw buffer::malformed_input("bad crc " + stringify(actual)
+ throw ceph::buffer::malformed_input("bad crc " + stringify(actual)
+ " expected " + stringify(crc));
}
DENC_FINISH(p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluefs_extent_t*>&);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluefs_extent_t*>&);
};
WRITE_CLASS_DENC(bluefs_extent_t)
-ostream& operator<<(ostream& out, const bluefs_extent_t& e);
+std::ostream& operator<<(std::ostream& out, const bluefs_extent_t& e);
struct bluefs_fnode_t {
uint64_t ino;
void bound_encode(size_t& p) const {
_denc_friend(*this, p);
}
- void encode(bufferlist::contiguous_appender& p) const {
+ void encode(ceph::buffer::list::contiguous_appender& p) const {
DENC_DUMP_PRE(bluefs_fnode_t);
_denc_friend(*this, p);
}
- void decode(buffer::ptr::const_iterator& p) {
+ void decode(ceph::buffer::ptr::const_iterator& p) {
_denc_friend(*this, p);
recalc_allocated();
}
mempool::bluefs::vector<bluefs_extent_t>::iterator seek(
uint64_t off, uint64_t *x_off);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluefs_fnode_t*>& ls);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluefs_fnode_t*>& ls);
};
WRITE_CLASS_DENC(bluefs_fnode_t)
-ostream& operator<<(ostream& out, const bluefs_fnode_t& file);
+std::ostream& operator<<(std::ostream& out, const bluefs_fnode_t& file);
struct bluefs_layout_t {
unsigned shared_bdev = 0; ///< which bluefs bdev we are sharing
dedicated_wal == other.dedicated_wal;
}
- void encode(ceph::bufferlist& bl) const;
- void decode(ceph::bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
};
WRITE_CLASS_ENCODER(bluefs_layout_t)
return ~((uint64_t)block_size - 1);
}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluefs_super_t*>& ls);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluefs_super_t*>& ls);
};
WRITE_CLASS_ENCODER(bluefs_super_t)
-ostream& operator<<(ostream&, const bluefs_super_t& s);
+std::ostream& operator<<(std::ostream&, const bluefs_super_t& s);
struct bluefs_transaction_t {
uuid_d uuid; ///< fs uuid
uint64_t seq; ///< sequence number
- bufferlist op_bl; ///< encoded transaction ops
+ ceph::buffer::list op_bl; ///< encoded transaction ops
bluefs_transaction_t() : seq(0) {}
encode(offset, op_bl);
encode(length, op_bl);
}
- void op_dir_create(const string& dir) {
+ void op_dir_create(const std::string& dir) {
using ceph::encode;
encode((__u8)OP_DIR_CREATE, op_bl);
encode(dir, op_bl);
}
- void op_dir_remove(const string& dir) {
+ void op_dir_remove(const std::string& dir) {
using ceph::encode;
encode((__u8)OP_DIR_REMOVE, op_bl);
encode(dir, op_bl);
}
- void op_dir_link(const string& dir, const string& file, uint64_t ino) {
+ void op_dir_link(const std::string& dir, const std::string& file, uint64_t ino) {
using ceph::encode;
encode((__u8)OP_DIR_LINK, op_bl);
encode(dir, op_bl);
encode(file, op_bl);
encode(ino, op_bl);
}
- void op_dir_unlink(const string& dir, const string& file) {
+ void op_dir_unlink(const std::string& dir, const std::string& file) {
using ceph::encode;
encode((__u8)OP_DIR_UNLINK, op_bl);
encode(dir, op_bl);
op_bl.claim_append(from.op_bl);
}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluefs_transaction_t*>& ls);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluefs_transaction_t*>& ls);
};
WRITE_CLASS_ENCODER(bluefs_transaction_t)
-ostream& operator<<(ostream& out, const bluefs_transaction_t& t);
+std::ostream& operator<<(std::ostream& out, const bluefs_transaction_t& t);
#endif
#include "common/Checksummer.h"
#include "include/stringify.h"
+using std::list;
+using std::map;
+using std::make_pair;
+using std::ostream;
+using std::string;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::Formatter;
+
// bluestore_bdev_label_t
void bluestore_bdev_label_t::encode(bufferlist& bl) const
ls.back()->allocated_test(bluestore_pextent_t(111, 222));
ls.push_back(new bluestore_blob_t);
ls.back()->init_csum(Checksummer::CSUM_XXHASH32, 16, 65536);
- ls.back()->csum_data = buffer::claim_malloc(4, strdup("abcd"));
+ ls.back()->csum_data = ceph::buffer::claim_malloc(4, strdup("abcd"));
ls.back()->add_unused(0, 3);
ls.back()->add_unused(8, 8);
ls.back()->allocated_test(bluestore_pextent_t(0x40100000, 0x10000));
#include <ostream>
#include <bitset>
#include <type_traits>
+#include "include/mempool.h"
#include "include/types.h"
#include "include/interval_set.h"
#include "include/utime.h"
uuid_d osd_uuid; ///< osd uuid
uint64_t size = 0; ///< device size
utime_t btime; ///< birth time
- string description; ///< device description
+ std::string description; ///< device description
- map<string,string> meta; ///< {read,write}_meta() content from ObjectStore
+ std::map<std::string,std::string> meta; ///< {read,write}_meta() content from ObjectStore
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_bdev_label_t*>& o);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_bdev_label_t*>& o);
};
WRITE_CLASS_ENCODER(bluestore_bdev_label_t)
-ostream& operator<<(ostream& out, const bluestore_bdev_label_t& l);
+std::ostream& operator<<(std::ostream& out, const bluestore_bdev_label_t& l);
/// collection metadata
struct bluestore_cnode_t {
denc(v.bits, p);
DENC_FINISH(p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_cnode_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_cnode_t*>& o);
};
WRITE_CLASS_DENC(bluestore_cnode_t)
-ostream& operator<<(ostream& out, const bluestore_cnode_t& l);
+std::ostream& operator<<(std::ostream& out, const bluestore_cnode_t& l);
template <typename OFFS_TYPE, typename LEN_TYPE>
struct bluestore_interval_t
denc_varint_lowz(v.length, p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_pextent_t*>& ls);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_pextent_t*>& ls);
};
WRITE_CLASS_DENC(bluestore_pextent_t)
-ostream& operator<<(ostream& out, const bluestore_pextent_t& o);
+std::ostream& operator<<(std::ostream& out, const bluestore_pextent_t& o);
typedef mempool::bluestore_cache_other::vector<bluestore_pextent_t> PExtentVector;
}
}
static void encode(const PExtentVector& v,
- bufferlist::contiguous_appender& p) {
+ ceph::buffer::list::contiguous_appender& p) {
denc_varint(v.size(), p);
for (auto& i : v) {
denc(i, p);
}
}
- static void decode(PExtentVector& v, bufferptr::const_iterator& p) {
+ static void decode(PExtentVector& v, ceph::buffer::ptr::const_iterator& p) {
unsigned num;
denc_varint(num, p);
v.clear();
}
};
-/// extent_map: a map of reference counted extents
+/// extent_map: a std::map of reference counted extents
struct bluestore_extent_ref_map_t {
struct record_t {
uint32_t length;
p += elem_size * ref_map.size();
}
}
- void encode(bufferlist::contiguous_appender& p) const {
+ void encode(ceph::buffer::list::contiguous_appender& p) const {
const uint32_t n = ref_map.size();
denc_varint(n, p);
if (n) {
}
}
}
- void decode(bufferptr::const_iterator& p) {
+ void decode(ceph::buffer::ptr::const_iterator& p) {
uint32_t n;
denc_varint(n, p);
if (n) {
}
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_extent_ref_map_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_extent_ref_map_t*>& o);
};
WRITE_CLASS_DENC(bluestore_extent_ref_map_t)
-ostream& operator<<(ostream& out, const bluestore_extent_ref_map_t& rm);
+std::ostream& operator<<(std::ostream& out, const bluestore_extent_ref_map_t& rm);
static inline bool operator==(const bluestore_extent_ref_map_t::record_t& l,
const bluestore_extent_ref_map_t::record_t& r) {
return l.length == r.length && l.refs == r.refs;
}
}
}
- void encode(bufferlist::contiguous_appender& p) const {
+ void encode(ceph::buffer::list::contiguous_appender& p) const {
denc_varint(au_size, p);
if (au_size) {
denc_varint(num_au, p);
}
}
}
- void decode(bufferptr::const_iterator& p) {
+ void decode(ceph::buffer::ptr::const_iterator& p) {
clear();
denc_varint(au_size, p);
if (au_size) {
}
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_blob_use_tracker_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_blob_use_tracker_t*>& o);
private:
void allocate();
};
WRITE_CLASS_DENC(bluestore_blob_use_tracker_t)
-ostream& operator<<(ostream& out, const bluestore_blob_use_tracker_t& rm);
+std::ostream& operator<<(std::ostream& out, const bluestore_blob_use_tracker_t& rm);
/// blob: a piece of data on disk
struct bluestore_blob_t {
LEGACY_FLAG_MUTABLE = 1, ///< [legacy] blob can be overwritten or split
FLAG_COMPRESSED = 2, ///< blob is compressed
FLAG_CSUM = 4, ///< blob has checksums
- FLAG_HAS_UNUSED = 8, ///< blob has unused map
+ FLAG_HAS_UNUSED = 8, ///< blob has unused std::map
FLAG_SHARED = 16, ///< blob is shared; see external SharedBlob
};
- static string get_flags_string(unsigned flags);
+ static std::string get_flags_string(unsigned flags);
uint32_t flags = 0; ///< FLAG_*
uint8_t csum_type = Checksummer::CSUM_NONE; ///< CSUM_*
uint8_t csum_chunk_order = 0; ///< csum block size is 1<<block_order bytes
- bufferptr csum_data; ///< opaque vector of csum data
+ ceph::buffer::ptr csum_data; ///< opaque std::vector of csum data
bluestore_blob_t(uint32_t f = 0) : flags(f) {}
p += sizeof(unused_t);
}
- void encode(bufferlist::contiguous_appender& p, uint64_t struct_v) const {
+ void encode(ceph::buffer::list::contiguous_appender& p, uint64_t struct_v) const {
ceph_assert(struct_v == 1 || struct_v == 2);
denc(extents, p);
denc_varint(flags, p);
}
}
- void decode(bufferptr::const_iterator& p, uint64_t struct_v) {
+ void decode(ceph::buffer::ptr::const_iterator& p, uint64_t struct_v) {
ceph_assert(struct_v == 1 || struct_v == 2);
denc(extents, p);
denc_varint(flags, p);
return !has_csum() || blob_offset % get_csum_chunk_size() == 0;
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_blob_t*>& ls);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_blob_t*>& ls);
bool has_flag(unsigned f) const {
return flags & f;
void clear_flag(unsigned f) {
flags &= ~f;
}
- string get_flags_string() const {
+ std::string get_flags_string() const {
return get_flags_string(flags);
}
}
template<class F>
void map_bl(uint64_t x_off,
- bufferlist& bl,
+ ceph::buffer::list& bl,
F&& f) const {
- static_assert(std::is_invocable_v<F, uint64_t, bufferlist&>);
+ static_assert(std::is_invocable_v<F, uint64_t, ceph::buffer::list&>);
auto p = extents.begin();
ceph_assert(p != extents.end());
++p;
ceph_assert(p != extents.end());
}
- bufferlist::iterator it = bl.begin();
+ ceph::buffer::list::iterator it = bl.begin();
uint64_t x_len = bl.length();
while (x_len > 0) {
ceph_assert(p != extents.end());
uint64_t l = std::min(p->length - x_off, x_len);
- bufferlist t;
+ ceph::buffer::list t;
it.copy(l, t);
f(p->offset + x_off, t);
x_off = 0;
flags |= FLAG_CSUM;
csum_type = type;
csum_chunk_order = order;
- csum_data = buffer::create(get_csum_value_size() * len / get_csum_chunk_size());
+ csum_data = ceph::buffer::create(get_csum_value_size() * len / get_csum_chunk_size());
csum_data.zero();
csum_data.reassign_to_mempool(mempool::mempool_bluestore_cache_other);
}
/// calculate csum for the buffer at the given b_off
- void calc_csum(uint64_t b_off, const bufferlist& bl);
+ void calc_csum(uint64_t b_off, const ceph::buffer::list& bl);
/// verify csum: return -EOPNOTSUPP for unsupported checksum type;
/// return -1 and valid(nonnegative) b_bad_off for checksum error;
/// return 0 if all is well.
- int verify_csum(uint64_t b_off, const bufferlist& bl, int* b_bad_off,
+ int verify_csum(uint64_t b_off, const ceph::buffer::list& bl, int* b_bad_off,
uint64_t *bad_csum) const;
bool can_prune_tail() const {
logical_length -= p.length;
extents.pop_back();
if (has_csum()) {
- bufferptr t;
+ ceph::buffer::ptr t;
t.swap(csum_data);
- csum_data = bufferptr(t.c_str(),
+ csum_data = ceph::buffer::ptr(t.c_str(),
get_logical_length() / get_csum_chunk_size() *
get_csum_value_size());
}
new_len - logical_length));
logical_length = new_len;
if (has_csum()) {
- bufferptr t;
+ ceph::buffer::ptr t;
t.swap(csum_data);
- csum_data = buffer::create(
+ csum_data = ceph::buffer::create(
get_csum_value_size() * logical_length / get_csum_chunk_size());
csum_data.copy_in(0, t.length(), t.c_str());
csum_data.zero(t.length(), csum_data.length() - t.length());
};
WRITE_CLASS_DENC_FEATURED(bluestore_blob_t)
-ostream& operator<<(ostream& out, const bluestore_blob_t& o);
+std::ostream& operator<<(std::ostream& out, const bluestore_blob_t& o);
/// shared blob state
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_shared_blob_t*>& ls);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_shared_blob_t*>& ls);
bool empty() const {
return ref_map.empty();
};
WRITE_CLASS_DENC(bluestore_shared_blob_t)
-ostream& operator<<(ostream& out, const bluestore_shared_blob_t& o);
+std::ostream& operator<<(std::ostream& out, const bluestore_shared_blob_t& o);
/// onode: per-object metadata
struct bluestore_onode_t {
uint64_t nid = 0; ///< numeric id (locally unique)
uint64_t size = 0; ///< object size
- map<mempool::bluestore_cache_other::string, bufferptr> attrs; ///< attrs
+ std::map<mempool::bluestore_cache_other::string, ceph::buffer::ptr> attrs; ///< attrs
struct shard_info {
uint32_t offset = 0; ///< logical offset for start of shard
denc_varint(v.offset, p);
denc_varint(v.bytes, p);
}
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
};
- vector<shard_info> extent_map_shards; ///< extent map shards (if any)
+ std::vector<shard_info> extent_map_shards; ///< extent std::map shards (if any)
uint32_t expected_object_size = 0;
uint32_t expected_write_size = 0;
FLAG_PERPOOL_OMAP = 4, ///< omap data is in per-pool prefix; per-pool keys
};
- string get_flags_string() const {
- string s;
+ std::string get_flags_string() const {
+ std::string s;
if (flags & FLAG_OMAP) {
s = "omap";
}
denc_varint(v.alloc_hint_flags, p);
DENC_FINISH(p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_onode_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_onode_t*>& o);
};
WRITE_CLASS_DENC(bluestore_onode_t::shard_info)
WRITE_CLASS_DENC(bluestore_onode_t)
-ostream& operator<<(ostream& out, const bluestore_onode_t::shard_info& si);
+std::ostream& operator<<(std::ostream& out, const bluestore_onode_t::shard_info& si);
/// writeahead-logged op
struct bluestore_deferred_op_t {
__u8 op = 0;
PExtentVector extents;
- bufferlist data;
+ ceph::buffer::list data;
DENC(bluestore_deferred_op_t, v, p) {
DENC_START(1, 1, p);
denc(v.data, p);
DENC_FINISH(p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_deferred_op_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_deferred_op_t*>& o);
};
WRITE_CLASS_DENC(bluestore_deferred_op_t)
/// writeahead-logged transaction
struct bluestore_deferred_transaction_t {
uint64_t seq = 0;
- list<bluestore_deferred_op_t> ops;
+ std::list<bluestore_deferred_op_t> ops;
interval_set<uint64_t> released; ///< allocations to release after tx
bluestore_deferred_transaction_t() : seq(0) {}
denc(v.released, p);
DENC_FINISH(p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_deferred_transaction_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_deferred_transaction_t*>& o);
};
WRITE_CLASS_DENC(bluestore_deferred_transaction_t)
denc(v.length, p);
DENC_FINISH(p);
}
- void dump(Formatter *f) const;
- static void generate_test_instances(list<bluestore_compression_header_t*>& o);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<bluestore_compression_header_t*>& o);
};
WRITE_CLASS_DENC(bluestore_compression_header_t)
boost::container::small_vector<iovec,4> iov;
uint64_t offset, length;
long rval;
- bufferlist bl; ///< write payload (so that it remains stable for duration)
+ ceph::buffer::list bl; ///< write payload (so that it remains stable for duration)
boost::intrusive::list_member_hook<> queue_item;
&aio_t::queue_item> > aio_list_t;
struct io_queue_t {
- typedef list<aio_t>::iterator aio_iter;
+ typedef
std::list<aio_t>::iterator aio_iter;
virtual ~io_queue_t() {};
#undef dout_prefix
#define dout_prefix *_dout << "btrfsfilestorebackend(" << get_basedir_path() << ") "
+using std::cerr;
+using std::list;
+using std::string;
+
#define ALIGN_DOWN(x, by) ((x) - ((x) % (by)))
#define ALIGNED(x, by) (!((x) % (by)))
#define ALIGN_UP(x, by) (ALIGNED((x), (by)) ? (x) : (ALIGN_DOWN((x), (by)) + (by)))
int detect_features() override;
bool can_checkpoint() override;
int create_current() override;
- int list_checkpoints(list<string>& ls) override;
- int create_checkpoint(const string& name, uint64_t *cid) override;
+ int list_checkpoints(std::list<std::string>& ls) override;
+ int create_checkpoint(const std::string& name, uint64_t *cid) override;
int sync_checkpoint(uint64_t cid) override;
- int rollback_to(const string& name) override;
- int destroy_checkpoint(const string& name) override;
+ int rollback_to(const std::string& name) override;
+ int destroy_checkpoint(const std::string& name) override;
int syncfs() override;
int clone_range(int from, int to, uint64_t srcoff, uint64_t len, uint64_t dstoff) override;
};
class Path {
public:
/// Returned path
- string full_path;
+ std::string full_path;
/// Ref to parent Index
CollectionIndex* parent_ref;
/// coll_t for parent Index
/// Normal Constructor
Path(
- string path, ///< [in] Path to return.
+ std::string path, ///< [in] Path to return.
CollectionIndex* ref)
: full_path(path), parent_ref(ref), parent_coll(parent_ref->coll()) {}
/// Debugging Constructor
Path(
- string path, ///< [in] Path to return.
+ std::string path, ///< [in] Path to return.
const coll_t& coll) ///< [in] collection
: full_path(path), parent_coll(coll) {}
/// Type of returned paths
typedef std::shared_ptr<Path> IndexedPath;
- static IndexedPath get_testing_path(string path, coll_t collection) {
+ static IndexedPath get_testing_path(std::string path, coll_t collection) {
return std::make_shared<Path>(path, collection);
}
const ghobject_t &start, ///< [in] object at which to start
const ghobject_t &end, ///< [in] list only objects < end
int max_count, ///< [in] return at most max_count objects
- vector<ghobject_t> *ls, ///< [out] Listed objects
+ std::vector<ghobject_t> *ls, ///< [out] Listed objects
ghobject_t *next ///< [out] Next object to list
) = 0;
#undef dout_prefix
#define dout_prefix *_dout << "filestore "
+using std::map;
+using std::ostream;
+using std::ostringstream;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+using ceph::bufferlist;
+
const string DBObjectMap::USER_PREFIX = "_USER_";
const string DBObjectMap::XATTR_PREFIX = "_AXATTR_";
const string DBObjectMap::SYS_PREFIX = "_SYS_";
* store three mappings: the key mapping, the complete mapping, and the parent.
* The complete mapping (COMPLETE_PREFIX space) is key->key. Each x->y entry in
* this mapping indicates that the key mapping contains all entries on [x,y).
- * Note, max string is represented by "", so ""->"" indicates that the parent
+ * Note, max std::string is represented by "", so ""->"" indicates that the parent
* is unnecessary (@see rm_keys). When looking up a key not contained in the
- * the complete set, we have to check the parent if we don't find it in the
- * key set. During rm_keys, we copy keys from the parent and update the
- * complete set to reflect the change @see rm_keys.
+ * the complete std::set, we have to check the parent if we don't find it in the
+ * key std::set. During rm_keys, we copy keys from the parent and update the
+ * complete std::set to reflect the change @see rm_keys.
*/
class DBObjectMap : public ObjectMap {
public:
KeyValueDB *get_db() override { return db.get(); }
/**
- * Serializes access to next_seq as well as the in_use set
+ * Serializes access to next_seq as well as the in_use std::set
*/
ceph::mutex header_lock = ceph::make_mutex("DBOBjectMap");
ceph::condition_variable header_cond;
ceph::condition_variable map_header_cond;
/**
- * Set of headers currently in use
+ * Std::Set of headers currently in use
*/
- set<uint64_t> in_use;
- set<ghobject_t> map_header_in_use;
+ std::set<uint64_t> in_use;
+ std::set<ghobject_t> map_header_in_use;
/**
* Takes the map_header_in_use entry in constructor, releases in
int set_keys(
const ghobject_t &oid,
- const map<string, bufferlist> &set,
+ const std::map<std::string, ceph::buffer::list> &set,
const SequencerPosition *spos=0
) override;
int set_header(
const ghobject_t &oid,
- const bufferlist &bl,
+ const ceph::buffer::list &bl,
const SequencerPosition *spos=0
) override;
int get_header(
const ghobject_t &oid,
- bufferlist *bl
+ ceph::buffer::list *bl
) override;
int clear(
int rm_keys(
const ghobject_t &oid,
- const set<string> &to_clear,
+ const std::set<std::string> &to_clear,
const SequencerPosition *spos=0
) override;
int get(
const ghobject_t &oid,
- bufferlist *header,
- map<string, bufferlist> *out
+ ceph::buffer::list *header,
+ std::map<std::string, ceph::buffer::list> *out
) override;
int get_keys(
const ghobject_t &oid,
- set<string> *keys
+ std::set<std::string> *keys
) override;
int get_values(
const ghobject_t &oid,
- const set<string> &keys,
- map<string, bufferlist> *out
+ const std::set<std::string> &keys,
+ std::map<std::string, ceph::buffer::list> *out
) override;
int check_keys(
const ghobject_t &oid,
- const set<string> &keys,
- set<string> *out
+ const std::set<std::string> &keys,
+ std::set<std::string> *out
) override;
int get_xattrs(
const ghobject_t &oid,
- const set<string> &to_get,
- map<string, bufferlist> *out
+ const std::set<std::string> &to_get,
+ std::map<std::string, ceph::buffer::list> *out
) override;
int get_all_xattrs(
const ghobject_t &oid,
- set<string> *out
+ std::set<std::string> *out
) override;
int set_xattrs(
const ghobject_t &oid,
- const map<string, bufferlist> &to_set,
+ const std::map<std::string, ceph::buffer::list> &to_set,
const SequencerPosition *spos=0
) override;
int remove_xattrs(
const ghobject_t &oid,
- const set<string> &to_remove,
+ const std::set<std::string> &to_remove,
const SequencerPosition *spos=0
) override;
const ghobject_t &from,
const ghobject_t &to,
const SequencerPosition *spos=0
- );
+ ) override;
int legacy_clone(
const ghobject_t &oid,
const ghobject_t &target,
const SequencerPosition *spos=0
- );
+ ) override;
/// Read initial state from backing store
int get_state();
}
/// Util, get all objects, there must be no other concurrent access
- int list_objects(vector<ghobject_t> *objs ///< [out] objects
+ int list_objects(std::vector<ghobject_t> *objs ///< [out] objects
);
struct _Header;
// Util, get all object headers, there must be no other concurrent access
- int list_object_headers(vector<_Header> *out ///< [out] headers
+ int list_object_headers(std::vector<_Header> *out ///< [out] headers
);
ObjectMapIterator get_iterator(const ghobject_t &oid) override;
- static const string USER_PREFIX;
- static const string XATTR_PREFIX;
- static const string SYS_PREFIX;
- static const string COMPLETE_PREFIX;
- static const string HEADER_KEY;
- static const string USER_HEADER_KEY;
- static const string GLOBAL_STATE_KEY;
- static const string HOBJECT_TO_SEQ;
+ static const std::string USER_PREFIX;
+ static const std::string XATTR_PREFIX;
+ static const std::string SYS_PREFIX;
+ static const std::string COMPLETE_PREFIX;
+ static const std::string HEADER_KEY;
+ static const std::string USER_HEADER_KEY;
+ static const std::string GLOBAL_STATE_KEY;
+ static const std::string HOBJECT_TO_SEQ;
/// Legacy
- static const string LEAF_PREFIX;
- static const string REVERSE_LEAF_PREFIX;
+ static const std::string LEAF_PREFIX;
+ static const std::string REVERSE_LEAF_PREFIX;
/// persistent state for store @see generate_header
struct State {
State() : v(0), seq(1), legacy(false) {}
explicit State(uint64_t seq) : v(0), seq(seq), legacy(false) {}
- void encode(bufferlist &bl) const {
+ void encode(ceph::buffer::list &bl) const {
ENCODE_START(3, 1, bl);
encode(v, bl);
encode(seq, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator &bl) {
+ void decode(ceph::buffer::list::const_iterator &bl) {
DECODE_START(3, bl);
if (struct_v >= 2)
decode(v, bl);
DECODE_FINISH(bl);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_unsigned("v", v);
f->dump_unsigned("seq", seq);
f->dump_bool("legacy", legacy);
}
- static void generate_test_instances(list<State*> &o) {
+ static void generate_test_instances(std::list<State*> &o) {
o.push_back(new State(0));
o.push_back(new State(20));
}
SequencerPosition spos;
- void encode(bufferlist &bl) const {
+ void encode(ceph::buffer::list &bl) const {
coll_t unused;
ENCODE_START(2, 1, bl);
encode(seq, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator &bl) {
+ void decode(ceph::buffer::list::const_iterator &bl) {
coll_t unused;
DECODE_START(2, bl);
decode(seq, bl);
DECODE_FINISH(bl);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_unsigned("seq", seq);
f->dump_unsigned("parent", parent);
f->dump_unsigned("num_children", num_children);
f->dump_stream("oid") << oid;
}
- static void generate_test_instances(list<_Header*> &o) {
+ static void generate_test_instances(std::list<_Header*> &o) {
o.push_back(new _Header);
o.push_back(new _Header);
o.back()->parent = 20;
_Header() : seq(0), parent(0), num_children(1) {}
};
- /// String munging (public for testing)
- static string ghobject_key(const ghobject_t &oid);
- static string ghobject_key_v0(coll_t c, const ghobject_t &oid);
+ /// Std::String munging (public for testing)
+ static std::string ghobject_key(const ghobject_t &oid);
+ static std::string ghobject_key_v0(coll_t c, const ghobject_t &oid);
static int is_buggy_ghobject_key_v1(CephContext* cct,
- const string &in);
+ const std::string &in);
private:
/// Implicit lock on Header->seq
typedef std::shared_ptr<_Header> Header;
ceph::mutex cache_lock = ceph::make_mutex("DBObjectMap::CacheLock");
SimpleLRU<ghobject_t, _Header> caches;
- string map_header_key(const ghobject_t &oid);
- string header_key(uint64_t seq);
- string complete_prefix(Header header);
- string user_prefix(Header header);
- string sys_prefix(Header header);
- string xattr_prefix(Header header);
- string sys_parent_prefix(_Header header);
- string sys_parent_prefix(Header header) {
+ std::string map_header_key(const ghobject_t &oid);
+ std::string header_key(uint64_t seq);
+ std::string complete_prefix(Header header);
+ std::string user_prefix(Header header);
+ std::string sys_prefix(Header header);
+ std::string xattr_prefix(Header header);
+ std::string sys_parent_prefix(_Header header);
+ std::string sys_parent_prefix(Header header) {
return sys_parent_prefix(*header);
}
public:
int seek_to_first() override { return 0; }
int seek_to_last() { return 0; }
- int upper_bound(const string &after) override { return 0; }
- int lower_bound(const string &to) override { return 0; }
+ int upper_bound(const std::string &after) override { return 0; }
+ int lower_bound(const std::string &to) override { return 0; }
bool valid() override { return false; }
int next() override { ceph_abort(); return 0; }
- string key() override { ceph_abort(); return ""; }
- bufferlist value() override { ceph_abort(); return bufferlist(); }
+ std::string key() override { ceph_abort(); return ""; }
+ ceph::buffer::list value() override { ceph_abort(); return ceph::buffer::list(); }
int status() override { return 0; }
};
map(map), hlock(map), header(header), r(0), ready(false), invalid(true) {}
int seek_to_first() override;
int seek_to_last();
- int upper_bound(const string &after) override;
- int lower_bound(const string &to) override;
+ int upper_bound(const std::string &after) override;
+ int lower_bound(const std::string &to) override;
bool valid() override;
int next() override;
- string key() override;
- bufferlist value() override;
+ std::string key() override;
+ ceph::buffer::list value() override;
int status() override;
bool on_parent() {
int next_parent();
/// first parent() >= to
- int lower_bound_parent(const string &to);
+ int lower_bound_parent(const std::string &to);
/**
* Tests whether to_test is in complete region
*
* postcondition: complete_iter will be max s.t. complete_iter->value > to_test
*/
- int in_complete_region(const string &to_test, ///< [in] key to test
- string *begin, ///< [out] beginning of region
- string *end ///< [out] end of region
+ int in_complete_region(const std::string &to_test, ///< [in] key to test
+ std::string *begin, ///< [out] beginning of region
+ std::string *end ///< [out] end of region
); ///< @returns true if to_test is in the complete region, else false
private:
/// Removes node corresponding to header
void clear_header(Header header, KeyValueDB::Transaction t);
- /// Set node containing input to new contents
+ /// Std::Set node containing input to new contents
void set_header(Header input, KeyValueDB::Transaction t);
/// Remove leaf node corresponding to oid in c
Header header,
KeyValueDB::Transaction t);
- /// Set leaf node for c and oid to the value of header
+ /// Std::Set leaf node for c and oid to the value of header
void set_map_header(
const MapHeaderLock &l,
const ghobject_t &oid, _Header header,
KeyValueDB::Transaction t);
- /// Set leaf node for c and oid to the value of header
+ /// Std::Set leaf node for c and oid to the value of header
bool check_spos(const ghobject_t &oid,
Header header,
const SequencerPosition *spos);
/// Helpers
- int _get_header(Header header, bufferlist *bl);
+ int _get_header(Header header, ceph::buffer::list *bl);
/// Scan keys in header into out_keys and out_values (if nonnull)
int scan(Header header,
- const set<string> &in_keys,
- set<string> *out_keys,
- map<string, bufferlist> *out_values);
+ const std::set<std::string> &in_keys,
+ std::set<std::string> *out_keys,
+ std::map<std::string, ceph::buffer::list> *out_values);
/// Remove header and all related prefixes
int _clear(Header header,
/* Scan complete region bumping *begin to the beginning of any
* containing region and adding all complete region keys between
- * the updated begin and end to the complete_keys_to_remove set */
+ * the updated begin and end to the complete_keys_to_remove std::set */
int merge_new_complete(DBObjectMapIterator &iter,
- string *begin,
- const string &end,
- set<string> *complete_keys_to_remove);
+ std::string *begin,
+ const std::string &end,
+ std::set<std::string> *complete_keys_to_remove);
/// Writes out State (mainly next_seq)
int write_state(KeyValueDB::Transaction _t =
KeyValueDB::Transaction t);
/// Sets header @see set_header
- void _set_header(Header header, const bufferlist &bl,
+ void _set_header(Header header, const ceph::buffer::list &bl,
KeyValueDB::Transaction t);
/**
WRITE_CLASS_ENCODER(DBObjectMap::_Header)
WRITE_CLASS_ENCODER(DBObjectMap::State)
-ostream& operator<<(ostream& out, const DBObjectMap::_Header& h);
+std::ostream& operator<<(std::ostream& out, const DBObjectMap::_Header& h);
#endif
#undef dout_prefix
#define dout_prefix *_dout << "journal "
+using std::list;
+using std::map;
+using std::ostream;
+using std::ostringstream;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+
const static int64_t ONE_MEG(1 << 20);
const static int CEPH_DIRECTIO_ALIGNMENT(4096);
void *buf = 0;
int64_t needed_space;
int ret;
- buffer::ptr bp;
+ ceph::buffer::ptr bp;
dout(2) << "create " << fn << " fsid " << fsid << dendl;
ret = _open(true, true);
dout(10) << "read_header" << dendl;
bufferlist bl;
- buffer::ptr bp = buffer::create_small_page_aligned(block_size);
+ ceph::buffer::ptr bp = ceph::buffer::create_small_page_aligned(block_size);
char* bpdata = bp.c_str();
int r = ::pread(fd, bpdata, bp.length(), 0);
auto p = bl.cbegin();
decode(*hdr, p);
}
- catch (buffer::error& e) {
+ catch (ceph::buffer::error& e) {
derr << "read_header error decoding journal header" << dendl;
return -EINVAL;
}
header.committed_up_to = journaled_seq;
}
encode(header, bl);
- bufferptr bp = buffer::create_small_page_aligned(get_top());
+ bufferptr bp = ceph::buffer::create_small_page_aligned(get_top());
// don't use bp.zero() here, because it also invalidates
// crc cache (which is not yet populated anyway)
char* data = bp.c_str();
if (bl.length() == 0 && !must_write_header)
return;
- buffer::ptr hbp;
+ ceph::buffer::ptr hbp;
if (cct->_conf->journal_write_header_frequency &&
(((++journaled_since_start) %
cct->_conf->journal_write_header_frequency) == 0)) {
if (bl.length() == 0 && !must_write_header)
return;
- buffer::ptr hbp;
+ ceph::buffer::ptr hbp;
if (must_write_header) {
must_write_header = false;
hbp = prepare_header();
// header
ebl.append((const char*)&h, sizeof(h));
if (h.pre_pad) {
- ebl.push_back(buffer::create_static(h.pre_pad, zero_buf));
+ ebl.push_back(ceph::buffer::create_static(h.pre_pad, zero_buf));
}
// payload
ebl.claim_append(bl);
if (h.post_pad) {
- ebl.push_back(buffer::create_static(h.post_pad, zero_buf));
+ ebl.push_back(ceph::buffer::create_static(h.post_pad, zero_buf));
}
// footer
ebl.append((const char*)&h, sizeof(h));
int64_t actual = ::lseek64(fd, pos, SEEK_SET);
ceph_assert(actual == pos);
- bufferptr bp = buffer::create(len);
+ bufferptr bp = ceph::buffer::create(len);
int r = safe_read_exact(fd, bp.c_str(), len);
if (r) {
derr << "FileJournal::wrap_read_bl: safe_read_exact " << pos << "~" << len << " returned "
};
struct write_item {
uint64_t seq;
- bufferlist bl;
+ ceph::buffer::list bl;
uint32_t orig_len;
TrackedOpRef tracked_op;
ZTracer::Trace trace;
- write_item(uint64_t s, bufferlist& b, int ol, TrackedOpRef opref) :
+ write_item(uint64_t s, ceph::buffer::list& b, int ol, TrackedOpRef opref) :
seq(s), orig_len(ol), tracked_op(opref) {
bl.claim(b);
}
ceph::mutex writeq_lock = ceph::make_mutex("FileJournal::writeq_lock");
ceph::condition_variable writeq_cond;
- list<write_item> writeq;
+ std::list<write_item> writeq;
bool writeq_empty();
write_item &peek_write();
void pop_write();
- void batch_pop_write(list<write_item> &items);
- void batch_unpop_write(list<write_item> &items);
+ void batch_pop_write(std::list<write_item> &items);
+ void batch_unpop_write(std::list<write_item> &items);
ceph::mutex completions_lock =
ceph::make_mutex("FileJournal::completions_lock");
- list<completion_item> completions;
+ std::list<completion_item> completions;
bool completions_empty() {
std::lock_guard l{completions_lock};
return completions.empty();
}
- void batch_pop_completions(list<completion_item> &items) {
+ void batch_pop_completions(std::list<completion_item> &items) {
std::lock_guard l{completions_lock};
completions.swap(items);
}
- void batch_unpop_completions(list<completion_item> &items) {
+ void batch_unpop_completions(std::list<completion_item> &items) {
std::lock_guard l{completions_lock};
completions.splice(completions.begin(), items);
}
completions.pop_front();
}
- int prepare_entry(vector<ObjectStore::Transaction>& tls, bufferlist* tbl) override;
+ int prepare_entry(std::vector<ObjectStore::Transaction>& tls, ceph::buffer::list* tbl) override;
- void submit_entry(uint64_t seq, bufferlist& bl, uint32_t orig_len,
+ void submit_entry(uint64_t seq, ceph::buffer::list& bl, uint32_t orig_len,
Context *oncommit,
TrackedOpRef osd_op = TrackedOpRef()) override;
/// End protected by finisher_lock
return *(uint64_t*)fsid.bytes();
}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
__u32 v = 4;
encode(v, bl);
- bufferlist em;
+ ceph::buffer::list em;
{
encode(flags, em);
encode(fsid, em);
}
encode(em, bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
using ceph::decode;
__u32 v;
decode(v, bl);
start_seq = 0;
return;
}
- bufferlist em;
+ ceph::buffer::list em;
decode(em, bl);
auto t = em.cbegin();
decode(flags, t);
bool journalq_empty() { return journalq.empty(); }
private:
- string fn;
+ std::string fn;
char *zero_buf;
off64_t max_size;
/// Protected by aio_lock
struct aio_info {
struct iocb iocb {};
- bufferlist bl;
+ ceph::buffer::list bl;
struct iovec *iov;
bool done;
uint64_t off, len; ///< these are for debug only
uint64_t seq; ///< seq number to complete on aio completion, if non-zero
- aio_info(bufferlist& b, uint64_t o, uint64_t s)
+ aio_info(ceph::buffer::list& b, uint64_t o, uint64_t s)
: iov(NULL), done(false), off(o), len(b.length()), seq(s) {
bl.claim(b);
}
ceph::condition_variable aio_cond;
ceph::condition_variable write_finish_cond;
io_context_t aio_ctx = 0;
- list<aio_info> aio_queue;
+
std::list<aio_info> aio_queue;
int aio_num = 0, aio_bytes = 0;
uint64_t aio_write_queue_ops = 0;
uint64_t aio_write_queue_bytes = 0;
uint64_t last_committed_seq;
uint64_t journaled_since_start;
- string devname;
+ std::string devname;
/*
* full states cycle at the beginnging of each commit epoch, when commit_start()
int fd;
// in journal
- deque<pair<uint64_t, off64_t> > journalq; // track seq offsets, so we can trim later.
+ std::deque<std::pair<uint64_t, off64_t> > journalq; // track seq offsets, so we can trim later.
uint64_t writing_seq;
for (const char **i = get_tracked_conf_keys();
*i;
++i) {
- if (changed.count(string(*i))) {
+ if (changed.count(std::string(*i))) {
set_throttle_params();
return;
}
int _open_block_device();
void _close(int fd) const;
int _open_file(int64_t oldsize, blksize_t blksize, bool create);
- int _dump(ostream& out, bool simple);
+ int _dump(std::ostream& out, bool simple);
void print_header(const header_t &hdr) const;
int read_header(header_t *hdr) const;
- bufferptr prepare_header();
+ ceph::bufferptr prepare_header();
void start_writer();
void stop_writer();
void write_thread_entry();
void queue_completions_thru(uint64_t seq);
int check_for_full(uint64_t seq, off64_t pos, off64_t size);
- int prepare_multi_write(bufferlist& bl, uint64_t& orig_ops, uint64_t& orig_bytee);
- int prepare_single_write(write_item &next_write, bufferlist& bl, off64_t& queue_pos,
+ int prepare_multi_write(ceph::buffer::list& bl, uint64_t& orig_ops, uint64_t& orig_bytee);
+ int prepare_single_write(write_item &next_write, ceph::buffer::list& bl, off64_t& queue_pos,
uint64_t& orig_ops, uint64_t& orig_bytes);
- void do_write(bufferlist& bl);
+ void do_write(ceph::buffer::list& bl);
void write_finish_thread_entry();
void check_aio_completion();
- void do_aio_write(bufferlist& bl);
- int write_aio_bl(off64_t& pos, bufferlist& bl, uint64_t seq);
+ void do_aio_write(ceph::buffer::list& bl);
+ int write_aio_bl(off64_t& pos, ceph::buffer::list& bl, uint64_t seq);
- void check_align(off64_t pos, bufferlist& bl);
- int write_bl(off64_t& pos, bufferlist& bl);
+ void check_align(off64_t pos, ceph::buffer::list& bl);
+ int write_bl(off64_t& pos, ceph::buffer::list& bl);
/// read len from journal starting at in_pos and wrapping up to len
void wrap_read_bl(
off64_t in_pos, ///< [in] start position
int64_t len, ///< [in] length to read
- bufferlist* bl, ///< [out] result
+ ceph::buffer::list* bl, ///< [out] result
off64_t *out_pos ///< [out] next position to read, will be wrapped
) const;
void close() override;
int peek_fsid(uuid_d& fsid);
- int dump(ostream& out) override;
- int simple_dump(ostream& out);
- int _fdump(Formatter &f, bool simple);
+ int dump(std::ostream& out) override;
+ int simple_dump(std::ostream& out);
+ int _fdump(ceph::Formatter &f, bool simple);
void flush() override;
- void get_devices(set<string> *ls) override;
- void collect_metadata(map<string,string> *pm) override;
+ void get_devices(std::set<std::string> *ls) override;
+ void collect_metadata(std::map<std::string,std::string> *pm) override;
void reserve_throttle_and_backoff(uint64_t count) override;
void set_wait_on_full(bool b) { wait_on_full = b; }
- off64_t get_journal_size_estimate();
+ off64_t get_journal_size_estimate() override;
// reads
read_entry_result do_read_entry(
off64_t pos, ///< [in] position to read
off64_t *next_pos, ///< [out] next position to read
- bufferlist* bl, ///< [out] payload for successful read
+ ceph::buffer::list* bl, ///< [out] payload for successful read
uint64_t *seq, ///< [out] seq of successful read
- ostream *ss, ///< [out] error output
+ std::ostream *ss, ///< [out] error output
entry_header_t *h = 0 ///< [out] header
) const; ///< @return result code
bool read_entry(
- bufferlist &bl,
+ ceph::buffer::list &bl,
uint64_t &last_seq,
bool *corrupt
);
bool read_entry(
- bufferlist &bl,
+ ceph::buffer::list &bl,
uint64_t &last_seq) override {
return read_entry(bl, last_seq, 0);
}
#include "kv/KeyValueDB.h"
#include "common/ceph_crypto.h"
-using ceph::crypto::SHA1;
#include "include/ceph_assert.h"
#define XATTR_SPILL_OUT "1"
#define __FUNC__ __func__ << "(" << __LINE__ << ")"
+using std::cerr;
+using std::list;
+using std::make_pair;
+using std::map;
+using std::ostream;
+using std::ostringstream;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+using ceph::crypto::SHA1;
+using ceph::BackTrace;
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::decode;
+using ceph::encode;
+using ceph::Formatter;
+using ceph::JSONFormatter;
+
//Initial features in new superblock.
static CompatSet get_fs_initial_compat_set() {
CompatSet::FeatureSet ceph_osd_feature_compat;
FileStore::~FileStore()
{
- for (vector<Finisher*>::iterator it = ondisk_finishers.begin(); it != ondisk_finishers.end(); ++it) {
+ for (auto it = ondisk_finishers.begin(); it != ondisk_finishers.end(); ++it) {
delete *it;
*it = nullptr;
}
- for (vector<Finisher*>::iterator it = apply_finishers.begin(); it != apply_finishers.end(); ++it) {
+ for (auto it = apply_finishers.begin(); it != apply_finishers.end(); ++it) {
delete *it;
*it = nullptr;
}
char val[CHAIN_XATTR_MAX_BLOCK_LEN];
int l = chain_fgetxattr(fd, name, val, sizeof(val));
if (l >= 0) {
- bp = buffer::create(l);
+ bp = ceph::buffer::create(l);
memcpy(bp.c_str(), val, l);
} else if (l == -ERANGE) {
l = chain_fgetxattr(fd, name, 0, 0);
if (l > 0) {
- bp = buffer::create(l);
+ bp = ceph::buffer::create(l);
l = chain_fgetxattr(fd, name, bp.c_str(), l);
}
}
class FSSuperblock {
public:
CompatSet compat_features;
- string omap_backend;
+ std::string omap_backend;
FSSuperblock() { }
- void encode(bufferlist &bl) const;
- void decode(bufferlist::const_iterator &bl);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<FSSuperblock*>& o);
+ void encode(ceph::buffer::list &bl) const;
+ void decode(ceph::buffer::list::const_iterator &bl);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<FSSuperblock*>& o);
};
WRITE_CLASS_ENCODER(FSSuperblock)
-inline ostream& operator<<(ostream& out, const FSSuperblock& sb)
+inline std::ostream& operator<<(std::ostream& out, const FSSuperblock& sb)
{
return out << "sb(" << sb.compat_features << "): "
<< sb.omap_backend;
return target_version;
}
- static int get_block_device_fsid(CephContext* cct, const string& path,
+ static int get_block_device_fsid(CephContext* cct, const std::string& path,
uuid_d *fsid);
struct FSPerfTracker {
PerfCounters::avg_tracker<uint64_t> os_commit_latency_ns;
}
private:
- string internal_name; ///< internal name, used to name the perfcounter instance
- string basedir, journalpath;
+ std::string internal_name; ///< internal name, used to name the perfcounter instance
+ std::string basedir, journalpath;
osflagbits_t generic_flags;
std::string current_fn;
std::string current_op_seq_fn;
void create_backend(unsigned long f_type);
- string devname;
+ std::string devname;
int vdo_fd = -1;
- string vdo_name;
+ std::string vdo_name;
deque<uint64_t> snaps;
ceph::mutex sync_entry_timeo_lock = ceph::make_mutex("FileStore::sync_entry_timeo_lock");
SafeTimer timer;
- list<Context*> sync_waiters;
+ std::list<Context*> sync_waiters;
bool stop;
void sync_entry();
struct SyncThread : public Thread {
struct Op {
utime_t start;
uint64_t op;
- vector<Transaction> tls;
+ std::vector<Transaction> tls;
Context *onreadable, *onreadable_sync;
uint64_t ops, bytes;
TrackedOpRef osd_op;
// to protect q, for benefit of flush (peek/dequeue also protected by lock)
ceph::mutex qlock =
ceph::make_mutex("FileStore::OpSequencer::qlock", false);
- list<Op*> q;
- list<uint64_t> jq;
- list<pair<uint64_t, Context*> > flush_commit_waiters;
+ std::list<Op*> q;
+ std::list<uint64_t> jq;
+ std::list<std::pair<uint64_t, Context*> > flush_commit_waiters;
ceph::condition_variable cond;
- string osr_name_str;
+ std::string osr_name_str;
/// hash of pointers to ghobject_t's for in-flight writes
- unordered_multimap<uint32_t,const ghobject_t*> applying;
+ std::unordered_multimap<uint32_t,const ghobject_t*> applying;
public:
// for apply mutual exclusion
ceph::mutex apply_lock =
return false;
} /// @returns true if both queues are empty
- void _wake_flush_waiters(list<Context*> *to_queue) {
+ void _wake_flush_waiters(std::list<Context*> *to_queue) {
uint64_t seq;
if (_get_min_uncompleted(&seq))
seq = -1;
- for (list<pair<uint64_t, Context*> >::iterator i =
- flush_commit_waiters.begin();
+ for (auto i = flush_commit_waiters.begin();
i != flush_commit_waiters.end() && i->first < seq;
flush_commit_waiters.erase(i++)) {
to_queue->push_back(i->second);
jq.push_back(o->op);
_register_apply(o);
}
- void dequeue_journal(list<Context*> *to_queue) {
+ void dequeue_journal(std::list<Context*> *to_queue) {
std::lock_guard l{qlock};
jq.pop_front();
cond.notify_all();
return q.front();
}
- Op *dequeue(list<Context*> *to_queue) {
+ Op *dequeue(std::list<Context*> *to_queue) {
ceph_assert(to_queue);
ceph_assert(ceph_mutex_is_locked(apply_lock));
std::lock_guard l{qlock};
if (_get_max_uncompleted(&seq)) {
return true;
} else {
- flush_commit_waiters.push_back(make_pair(seq, c));
+ flush_commit_waiters.push_back(std::make_pair(seq, c));
return false;
}
}
typedef boost::intrusive_ptr<OpSequencer> OpSequencerRef;
ceph::mutex coll_lock = ceph::make_mutex("FileStore::coll_lock");
- map<coll_t,OpSequencerRef> coll_map;
+ std::map<coll_t,OpSequencerRef> coll_map;
- friend ostream& operator<<(ostream& out, const OpSequencer& s);
+ friend std::ostream& operator<<(std::ostream& out, const OpSequencer& s);
FDCache fdcache;
WBThrottle wbthrottle;
BackoffThrottle throttle_ops, throttle_bytes;
const int m_ondisk_finisher_num;
const int m_apply_finisher_num;
- vector<Finisher*> ondisk_finishers;
- vector<Finisher*> apply_finishers;
+ std::vector<Finisher*> ondisk_finishers;
+ std::vector<Finisher*> apply_finishers;
ThreadPool op_tp;
struct OpWQ : public ThreadPool::WorkQueue<OpSequencer> {
void _do_op(OpSequencer *o, ThreadPool::TPHandle &handle);
void _finish_op(OpSequencer *o);
- Op *build_op(vector<Transaction>& tls,
+ Op *build_op(std::vector<Transaction>& tls,
Context *onreadable, Context *onreadable_sync,
TrackedOpRef osd_op);
void queue_op(OpSequencer *osr, Op *o);
const char *internal_name = "filestore", bool update_to=false);
~FileStore() override;
- string get_type() override {
+ std::string get_type() override {
return "filestore";
}
bool is_rotational() override;
bool is_journal_rotational() override;
- void dump_perf_counters(Formatter *f) override {
+ void dump_perf_counters(ceph::Formatter *f) override {
f->open_object_section("perf_counters");
logger->dump_formatted(f, false);
f->close_section();
}
- int flush_cache(ostream *os = NULL) override;
+ int flush_cache(std::ostream *os = NULL) override;
int write_version_stamp();
int version_stamp_is_valid(uint32_t *version);
int update_version_stamp();
return true; // i support legacy sort order
}
- void collect_metadata(map<string,string> *pm) override;
- int get_devices(set<string> *ls) override;
+ void collect_metadata(std::map<std::string,std::string> *pm) override;
+ int get_devices(std::set<std::string> *ls) override;
int statfs(struct store_statfs_t *buf,
osd_alert_list_t* alerts = nullptr) override;
bool *per_pool_omap) override;
int _do_transactions(
- vector<Transaction> &tls, uint64_t op_seq,
+ std::vector<Transaction> &tls, uint64_t op_seq,
ThreadPool::TPHandle *handle,
const char *osr_name);
- int do_transactions(vector<Transaction> &tls, uint64_t op_seq) override {
+ int do_transactions(std::vector<Transaction> &tls, uint64_t op_seq) override {
return _do_transactions(tls, op_seq, nullptr, "replay");
}
void _do_transaction(
ContextQueue *commit_queue) override {
}
- int queue_transactions(CollectionHandle& ch, vector<Transaction>& tls,
+ int queue_transactions(CollectionHandle& ch, std::vector<Transaction>& tls,
TrackedOpRef op = TrackedOpRef(),
ThreadPool::TPHandle *handle = nullptr) override;
const ghobject_t& oid,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags = 0) override;
int _do_fiemap(int fd, uint64_t offset, size_t len,
- map<uint64_t, uint64_t> *m);
+ std::map<uint64_t, uint64_t> *m);
int _do_seek_hole_data(int fd, uint64_t offset, size_t len,
- map<uint64_t, uint64_t> *m);
+ std::map<uint64_t, uint64_t> *m);
using ObjectStore::fiemap;
- int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, bufferlist& bl) override;
- int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, map<uint64_t, uint64_t>& destmap) override;
+ int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, ceph::buffer::list& bl) override;
+ int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, std::map<uint64_t, uint64_t>& destmap) override;
int _touch(const coll_t& cid, const ghobject_t& oid);
int _write(const coll_t& cid, const ghobject_t& oid, uint64_t offset, size_t len,
- const bufferlist& bl, uint32_t fadvise_flags = 0);
+ const ceph::buffer::list& bl, uint32_t fadvise_flags = 0);
int _zero(const coll_t& cid, const ghobject_t& oid, uint64_t offset, size_t len);
int _truncate(const coll_t& cid, const ghobject_t& oid, uint64_t size);
int _clone(const coll_t& cid, const ghobject_t& oldoid, const ghobject_t& newoid,
int _do_copy_range(int from, int to, uint64_t srcoff, uint64_t len, uint64_t dstoff, bool skip_sloppycrc=false);
int _remove(const coll_t& cid, const ghobject_t& oid, const SequencerPosition &spos);
- int _fgetattr(int fd, const char *name, bufferptr& bp);
- int _fgetattrs(int fd, map<string,bufferptr>& aset);
- int _fsetattrs(int fd, map<string, bufferptr> &aset);
+ int _fgetattr(int fd, const char *name, ceph::bufferptr& bp);
+ int _fgetattrs(int fd, std::map<std::string, ceph::bufferptr>& aset);
+ int _fsetattrs(int fd, std::map<std::string, ceph::bufferptr> &aset);
void do_force_sync();
void start_sync(Context *onsafe);
void sync_and_flush();
int flush_journal() override;
- int dump_journal(ostream& out) override;
+ int dump_journal(std::ostream& out) override;
void set_fsid(uuid_d u) override {
fsid = u;
// DEBUG read error injection, an object is removed from both on delete()
ceph::mutex read_error_lock = ceph::make_mutex("FileStore::read_error_lock");
- set<ghobject_t> data_error_set; // read() will return -EIO
- set<ghobject_t> mdata_error_set; // getattr(),stat() will return -EIO
+ std::set<ghobject_t> data_error_set; // read() will return -EIO
+ std::set<ghobject_t> mdata_error_set; // getattr(),stat() will return -EIO
void inject_data_error(const ghobject_t &oid) override;
void inject_mdata_error(const ghobject_t &oid) override;
bool debug_data_eio(const ghobject_t &oid);
bool debug_mdata_eio(const ghobject_t &oid);
- int snapshot(const string& name) override;
+ int snapshot(const std::string& name) override;
// attrs
using ObjectStore::getattr;
using ObjectStore::getattrs;
- int getattr(CollectionHandle& c, const ghobject_t& oid, const char *name, bufferptr &bp) override;
- int getattrs(CollectionHandle& c, const ghobject_t& oid, map<string,bufferptr>& aset) override;
+ int getattr(CollectionHandle& c, const ghobject_t& oid, const char *name, ceph::bufferptr &bp) override;
+ int getattrs(CollectionHandle& c, const ghobject_t& oid, std::map<std::string,ceph::bufferptr>& aset) override;
- int _setattrs(const coll_t& cid, const ghobject_t& oid, map<string,bufferptr>& aset,
+ int _setattrs(const coll_t& cid, const ghobject_t& oid, std::map<std::string,ceph::bufferptr>& aset,
const SequencerPosition &spos);
int _rmattr(const coll_t& cid, const ghobject_t& oid, const char *name,
const SequencerPosition &spos);
int collection_bits(CollectionHandle& c) override;
int collection_list(CollectionHandle& c,
const ghobject_t& start, const ghobject_t& end, int max,
- vector<ghobject_t> *ls, ghobject_t *next) override {
+ std::vector<ghobject_t> *ls, ghobject_t *next) override {
c->flush();
return collection_list(c->cid, start, end, max, ls, next);
}
int collection_list(const coll_t& cid,
const ghobject_t& start, const ghobject_t& end, int max,
- vector<ghobject_t> *ls, ghobject_t *next);
- int list_collections(vector<coll_t>& ls) override;
- int list_collections(vector<coll_t>& ls, bool include_temp);
+ std::vector<ghobject_t> *ls, ghobject_t *next);
+ int list_collections(std::vector<coll_t>& ls) override;
+ int list_collections(std::vector<coll_t>& ls, bool include_temp);
int collection_stat(const coll_t& c, struct stat *st);
bool collection_exists(const coll_t& c) override;
int collection_empty(CollectionHandle& c, bool *empty) override {
// omap (see ObjectStore.h for documentation)
using ObjectStore::omap_get;
- int omap_get(CollectionHandle& c, const ghobject_t &oid, bufferlist *header,
- map<string, bufferlist> *out) override;
+ int omap_get(CollectionHandle& c, const ghobject_t &oid, ceph::buffer::list *header,
+ std::map<std::string, ceph::buffer::list> *out) override;
using ObjectStore::omap_get_header;
int omap_get_header(
CollectionHandle& c,
const ghobject_t &oid,
- bufferlist *out,
+ ceph::buffer::list *out,
bool allow_eio = false) override;
using ObjectStore::omap_get_keys;
- int omap_get_keys(CollectionHandle& c, const ghobject_t &oid, set<string> *keys) override;
+ int omap_get_keys(CollectionHandle& c, const ghobject_t &oid, std::set<std::string> *keys) override;
using ObjectStore::omap_get_values;
- int omap_get_values(CollectionHandle& c, const ghobject_t &oid, const set<string> &keys,
- map<string, bufferlist> *out) override;
+ int omap_get_values(CollectionHandle& c, const ghobject_t &oid, const std::set<std::string> &keys,
+ std::map<std::string, ceph::buffer::list> *out) override;
using ObjectStore::omap_check_keys;
- int omap_check_keys(CollectionHandle& c, const ghobject_t &oid, const set<string> &keys,
- set<string> *out) override;
+ int omap_check_keys(CollectionHandle& c, const ghobject_t &oid, const std::set<std::string> &keys,
+ std::set<std::string> *out) override;
using ObjectStore::get_omap_iterator;
ObjectMap::ObjectMapIterator get_omap_iterator(CollectionHandle& c, const ghobject_t &oid) override;
ObjectMap::ObjectMapIterator get_omap_iterator(const coll_t& cid, const ghobject_t &oid);
void dump_start(const std::string& file);
void dump_stop();
- void dump_transactions(vector<Transaction>& ls, uint64_t seq, OpSequencer *osr);
+ void dump_transactions(std::vector<Transaction>& ls, uint64_t seq, OpSequencer *osr);
virtual int apply_layout_settings(const coll_t &cid, int target_level);
- void get_db_statistics(Formatter* f) override;
+ void get_db_statistics(ceph::Formatter* f) override;
private:
void _inject_failure();
int _omap_clear(const coll_t& cid, const ghobject_t &oid,
const SequencerPosition &spos);
int _omap_setkeys(const coll_t& cid, const ghobject_t &oid,
- const map<string, bufferlist> &aset,
+ const std::map<std::string, ceph::buffer::list> &aset,
const SequencerPosition &spos);
- int _omap_rmkeys(const coll_t& cid, const ghobject_t &oid, const set<string> &keys,
+ int _omap_rmkeys(const coll_t& cid, const ghobject_t &oid, const std::set<std::string> &keys,
const SequencerPosition &spos);
int _omap_rmkeyrange(const coll_t& cid, const ghobject_t &oid,
- const string& first, const string& last,
+ const std::string& first, const std::string& last,
const SequencerPosition &spos);
- int _omap_setheader(const coll_t& cid, const ghobject_t &oid, const bufferlist &bl,
+ int _omap_setheader(const coll_t& cid, const ghobject_t &oid, const ceph::buffer::list &bl,
const SequencerPosition &spos);
int _split_collection(const coll_t& cid, uint32_t bits, uint32_t rem, coll_t dest,
const SequencerPosition &spos);
bool m_osd_use_stale_snap;
bool m_filestore_do_dump;
std::ofstream m_filestore_dump;
- JSONFormatter m_filestore_dump_fmt;
+ ceph::JSONFormatter m_filestore_dump_fmt;
std::atomic<int64_t> m_filestore_kill_at = { 0 };
bool m_filestore_sloppy_crc;
int m_filestore_sloppy_crc_block_size;
friend class TestFileStore;
};
-ostream& operator<<(ostream& out, const FileStore::OpSequencer& s);
+std::ostream& operator<<(std::ostream& out, const FileStore::OpSequencer& s);
struct fiemap;
size_t get_blksize() {
return filestore->blk_size;
}
- const string& get_basedir_path() {
+ const std::string& get_basedir_path() {
return filestore->basedir;
}
- const string& get_journal_path() {
+ const std::string& get_journal_path() {
return filestore->journalpath;
}
- const string& get_current_path() {
+ const std::string& get_current_path() {
return filestore->current_fn;
}
int _copy_range(int from, int to, uint64_t srcoff, uint64_t len, uint64_t dstoff) {
virtual int detect_features() = 0;
virtual int create_current() = 0;
virtual bool can_checkpoint() = 0;
- virtual int list_checkpoints(list<string>& ls) = 0;
- virtual int create_checkpoint(const string& name, uint64_t *cid) = 0;
+ virtual int list_checkpoints(std::list<std::string>& ls) = 0;
+ virtual int create_checkpoint(const std::string& name, uint64_t *cid) = 0;
virtual int sync_checkpoint(uint64_t id) = 0;
- virtual int rollback_to(const string& name) = 0;
- virtual int destroy_checkpoint(const string& name) = 0;
+ virtual int rollback_to(const std::string& name) = 0;
+ virtual int destroy_checkpoint(const std::string& name) = 0;
virtual int syncfs() = 0;
virtual bool has_fiemap() = 0;
virtual bool has_seek_data_hole() = 0;
virtual bool has_splice() const = 0;
// hooks for (sloppy) crc tracking
- virtual int _crc_update_write(int fd, loff_t off, size_t len, const bufferlist& bl) = 0;
+ virtual int _crc_update_write(int fd, loff_t off, size_t len, const ceph::buffer::list& bl) = 0;
virtual int _crc_update_truncate(int fd, loff_t off) = 0;
virtual int _crc_update_zero(int fd, loff_t off, size_t len) = 0;
virtual int _crc_update_clone_range(int srcfd, int destfd,
loff_t srcoff, size_t len, loff_t dstoff) = 0;
- virtual int _crc_verify_read(int fd, loff_t off, size_t len, const bufferlist& bl,
- ostream *out) = 0;
+ virtual int _crc_verify_read(int fd, loff_t off, size_t len, const ceph::buffer::list& bl,
+ std::ostream *out) = 0;
};
#endif
#define ALIGNED(x, by) (!((x) % (by)))
#define ALIGN_UP(x, by) (ALIGNED((x), (by)) ? (x) : (ALIGN_DOWN((x), (by)) + (by)))
+using std::ostream;
+using std::ostringstream;
+using std::string;
+
+using ceph::bufferptr;
+using ceph::bufferlist;
+
GenericFileStoreBackend::GenericFileStoreBackend(FileStore *fs):
FileStoreBackend(fs),
ioctl_fiemap(false),
return 0;
}
if (l >= 0) {
- bp = buffer::create(l);
+ bp = ceph::buffer::create(l);
memcpy(bp.c_str(), buf, l);
} else if (l == -ERANGE) {
l = chain_fgetxattr(fd, SLOPPY_CRC_XATTR, 0, 0);
if (l > 0) {
- bp = buffer::create(l);
+ bp = ceph::buffer::create(l);
l = chain_fgetxattr(fd, SLOPPY_CRC_XATTR, bp.c_str(), l);
}
}
try {
decode(*cm, p);
}
- catch (buffer::error &e) {
+ catch (ceph::buffer::error &e) {
r = -EIO;
}
if (r < 0)
bool is_journal_rotational() override {
return m_journal_rotational;
}
- int list_checkpoints(list<string>& ls) override { return 0; }
- int create_checkpoint(const string& name, uint64_t *cid) override { return -EOPNOTSUPP; }
+ int list_checkpoints(std::list<std::string>& ls) override { return 0; }
+ int create_checkpoint(const std::string& name, uint64_t *cid) override { return -EOPNOTSUPP; }
int sync_checkpoint(uint64_t id) override { return -EOPNOTSUPP; }
- int rollback_to(const string& name) override { return -EOPNOTSUPP; }
- int destroy_checkpoint(const string& name) override { return -EOPNOTSUPP; }
+ int rollback_to(const std::string& name) override { return -EOPNOTSUPP; }
+ int destroy_checkpoint(const std::string& name) override { return -EOPNOTSUPP; }
int syncfs() override;
bool has_fiemap() override { return ioctl_fiemap; }
bool has_seek_data_hole() override { return seek_data_hole; }
int _crc_load_or_init(int fd, SloppyCRCMap *cm);
int _crc_save(int fd, SloppyCRCMap *cm);
public:
- int _crc_update_write(int fd, loff_t off, size_t len, const bufferlist& bl) override;
+ int _crc_update_write(int fd, loff_t off, size_t len, const ceph::buffer::list& bl) override;
int _crc_update_truncate(int fd, loff_t off) override;
int _crc_update_zero(int fd, loff_t off, size_t len) override;
int _crc_update_clone_range(int srcfd, int destfd,
loff_t srcoff, size_t len, loff_t dstoff) override;
- int _crc_verify_read(int fd, loff_t off, size_t len, const bufferlist& bl,
- ostream *out) override;
+ int _crc_verify_read(int fd, loff_t off, size_t len, const ceph::buffer::list& bl,
+ std::ostream *out) override;
};
#endif
#define dout_context cct
#define dout_subsys ceph_subsys_filestore
+using std::map;
+using std::pair;
+using std::set;
+using std::string;
+using std::vector;
+
+using ceph::bufferptr;
+using ceph::bufferlist;
+
const string HashIndex::SUBDIR_ATTR = "contents";
const string HashIndex::SETTINGS_ATTR = "settings";
const string HashIndex::IN_PROGRESS_OP_TAG = "in_progress_op";
#include "include/encoding.h"
#include "LFNIndex.h"
-extern string reverse_hexdigit_bits_string(string l);
+extern std::string reverse_hexdigit_bits_string(std::string l);
/**
* Implements collection prehashing.
class HashIndex : public LFNIndex {
private:
/// Attribute name for storing subdir info @see subdir_info_s
- static const string SUBDIR_ATTR;
+ static const std::string SUBDIR_ATTR;
/// Attribute name for storing index-wide settings
- static const string SETTINGS_ATTR;
+ static const std::string SETTINGS_ATTR;
/// Attribute name for storing in progress op tag
- static const string IN_PROGRESS_OP_TAG;
+ static const std::string IN_PROGRESS_OP_TAG;
/// Size (bits) in object hash
static const int PATH_HASH_LEN = 32;
/// Max length of hashed path
subdir_info_s() : objs(0), subdirs(0), hash_level(0) {}
- void encode(bufferlist &bl) const
+ void encode(ceph::buffer::list &bl) const
{
using ceph::encode;
__u8 v = 1;
encode(hash_level, bl);
}
- void decode(bufferlist::const_iterator &bl)
+ void decode(ceph::buffer::list::const_iterator &bl)
{
using ceph::decode;
__u8 v;
struct settings_s {
uint32_t split_rand_factor; ///< random factor added to split threshold (only on root of collection)
settings_s() : split_rand_factor(0) {}
- void encode(bufferlist &bl) const
+ void encode(ceph::buffer::list &bl) const
{
using ceph::encode;
__u8 v = 1;
encode(v, bl);
encode(split_rand_factor, bl);
}
- void decode(bufferlist::const_iterator &bl)
+ void decode(ceph::buffer::list::const_iterator &bl)
{
using ceph::decode;
__u8 v;
static const int MERGE = 1;
static const int COL_SPLIT = 2;
int op;
- vector<string> path;
+ std::vector<std::string> path;
- InProgressOp(int op, const vector<string> &path)
+ InProgressOp(int op, const std::vector<std::string> &path)
: op(op), path(path) {}
- explicit InProgressOp(bufferlist::const_iterator &bl) {
+ explicit InProgressOp(ceph::buffer::list::const_iterator &bl) {
decode(bl);
}
bool is_col_split() const { return op == COL_SPLIT; }
bool is_merge() const { return op == MERGE; }
- void encode(bufferlist &bl) const {
+ void encode(ceph::buffer::list &bl) const {
using ceph::encode;
__u8 v = 1;
encode(v, bl);
encode(path, bl);
}
- void decode(bufferlist::const_iterator &bl) {
+ void decode(ceph::buffer::list::const_iterator &bl) {
using ceph::decode;
__u8 v;
decode(v, bl);
int _merge_dirs(
HashIndex& from,
HashIndex& to,
- const vector<string>& path);
+ const std::vector<std::string>& path);
/// @see CollectionIndex
int apply_layout_settings(int target_level) override;
int _init() override;
int _created(
- const vector<string> &path,
+ const std::vector<std::string> &path,
const ghobject_t &oid,
- const string &mangled_name
+ const std::string &mangled_name
) override;
int _remove(
- const vector<string> &path,
+ const std::vector<std::string> &path,
const ghobject_t &oid,
- const string &mangled_name
+ const std::string &mangled_name
) override;
int _lookup(
const ghobject_t &oid,
- vector<string> *path,
- string *mangled_name,
+ std::vector<std::string> *path,
+ std::string *mangled_name,
int *hardlink
) override;
const ghobject_t &start,
const ghobject_t &end,
int max_count,
- vector<ghobject_t> *ls,
+ std::vector<ghobject_t> *ls,
ghobject_t *next
) override;
private:
/// Internal recursively remove path and its subdirs
int _recursive_remove(
- const vector<string> &path, ///< [in] path to remove
+ const std::vector<std::string> &path, ///< [in] path to remove
bool top ///< [in] internal tracking of first caller
); /// @return Error Code, 0 on success
/// Recursively remove path and its subdirs
int recursive_remove(
- const vector<string> &path ///< [in] path to remove
+ const std::vector<std::string> &path ///< [in] path to remove
); /// @return Error Code, 0 on success
/// Tag root directory at beginning of col_split
int start_col_split(
- const vector<string> &path ///< [in] path to split
+ const std::vector<std::string> &path ///< [in] path to split
); ///< @return Error Code, 0 on success
/// Tag root directory at beginning of split
int start_split(
- const vector<string> &path ///< [in] path to split
+ const std::vector<std::string> &path ///< [in] path to split
); ///< @return Error Code, 0 on success
/// Tag root directory at beginning of split
int start_merge(
- const vector<string> &path ///< [in] path to merge
+ const std::vector<std::string> &path ///< [in] path to merge
); ///< @return Error Code, 0 on success
/// Remove tag at end of split or merge
int end_split_or_merge(
- const vector<string> &path ///< [in] path to split or merged
+ const std::vector<std::string> &path ///< [in] path to split or merged
); ///< @return Error Code, 0 on success
/// Gets info from the xattr on the subdir represented by path
int get_info(
- const vector<string> &path, ///< [in] Path from which to read attribute.
+ const std::vector<std::string> &path, ///< [in] Path from which to read attribute.
subdir_info_s *info ///< [out] Attribute value
); /// @return Error Code, 0 on success
/// Sets info to the xattr on the subdir represented by path
int set_info(
- const vector<string> &path, ///< [in] Path on which to set attribute.
+ const std::vector<std::string> &path, ///< [in] Path on which to set attribute.
const subdir_info_s &info ///< [in] Value to set
); /// @return Error Code, 0 on success
/// Initiates merge
int initiate_merge(
- const vector<string> &path, ///< [in] Subdir to merge
+ const std::vector<std::string> &path, ///< [in] Subdir to merge
subdir_info_s info ///< [in] Info attached to path
); /// @return Error Code, 0 on success
/// Completes merge
int complete_merge(
- const vector<string> &path, ///< [in] Subdir to merge
+ const std::vector<std::string> &path, ///< [in] Subdir to merge
subdir_info_s info ///< [in] Info attached to path
); /// @return Error Code, 0 on success
/// Resets attr to match actual subdir contents
int reset_attr(
- const vector<string> &path ///< [in] path to cleanup
+ const std::vector<std::string> &path ///< [in] path to cleanup
);
/// Initiate Split
int initiate_split(
- const vector<string> &path, ///< [in] Subdir to split
+ const std::vector<std::string> &path, ///< [in] Subdir to split
subdir_info_s info ///< [in] Info attached to path
); /// @return Error Code, 0 on success
/// Completes Split
int complete_split(
- const vector<string> &path, ///< [in] Subdir to split
+ const std::vector<std::string> &path, ///< [in] Subdir to split
subdir_info_s info ///< [in] Info attached to path
); /// @return Error Code, 0 on success
/// Determine path components from hoid hash
void get_path_components(
const ghobject_t &oid, ///< [in] Object for which to get path components
- vector<string> *path ///< [out] Path components for hoid.
+ std::vector<std::string> *path ///< [out] Path components for hoid.
);
/// Pre-hash and split folders to avoid runtime splitting
/// Initialize the folder (dir info) with the given hash
/// level and number of its subdirs.
- int init_split_folder(vector<string> &path, uint32_t hash_level);
+ int init_split_folder(std::vector<std::string> &path, uint32_t hash_level);
/// do collection split for path
static int col_split_level(
HashIndex &from, ///< [in] from index
HashIndex &dest, ///< [in] to index
- const vector<string> &path, ///< [in] path to split
+ const std::vector<std::string> &path, ///< [in] path to split
uint32_t bits, ///< [in] num bits to match
uint32_t match, ///< [in] bits to match
unsigned *mkdirred ///< [in,out] path[:mkdirred] has been mkdirred
/**
- * Get string representation of ghobject_t/hash
+ * Get std::string representation of ghobject_t/hash
*
* e.g: 0x01234567 -> "76543210"
*/
- static string get_path_str(
- const ghobject_t &oid ///< [in] Object to get hash string for
- ); ///< @return Hash string for hoid.
+ static std::string get_path_str(
+ const ghobject_t &oid ///< [in] Object to get hash std::string for
+ ); ///< @return Hash std::string for hoid.
- /// Get string from hash, @see get_path_str
- static string get_hash_str(
+ /// Get std::string from hash, @see get_path_str
+ static std::string get_hash_str(
uint32_t hash ///< [in] Hash to convert to a string.
- ); ///< @return String representation of hash
+ ); ///< @return std::string representation of hash
- /// Get hash from hash prefix string e.g. "FFFFAB" -> 0xFFFFAB00
+ /// Get hash from hash prefix std::string e.g. "FFFFAB" -> 0xFFFFAB00
static uint32_t hash_prefix_to_hash(
- string prefix ///< [in] string to convert
+ std::string prefix ///< [in] std::string to convert
); ///< @return Hash
/// Get hash mod from path
static void path_to_hobject_hash_prefix(
- const vector<string> &path,///< [in] path to convert
+ const std::vector<std::string> &path,///< [in] path to convert
uint32_t *bits, ///< [out] bits
uint32_t *hash ///< [out] hash
) {
- string hash_str;
- for (vector<string>::const_iterator i = path.begin();
- i != path.end();
- ++i) {
+ std::string hash_str;
+ for (auto i = path.begin(); i != path.end(); ++i) {
hash_str.push_back(*i->begin());
}
uint32_t rev_hash = hash_prefix_to_hash(hash_str);
return ret;
}
- /// Convert a number to hex string (upper case).
- static string to_hex(int n) {
+ /// Convert a number to hex std::string (upper case).
+ static std::string to_hex(int n) {
ceph_assert(n >= 0 && n < 16);
char c = (n <= 9 ? ('0' + n) : ('A' + n - 10));
- string str;
+ std::string str;
str.append(1, c);
return str;
}
struct CmpPairBitwise {
- bool operator()(const pair<string, ghobject_t>& l,
- const pair<string, ghobject_t>& r) const
+ bool operator()(const std::pair<std::string, ghobject_t>& l,
+ const std::pair<std::string, ghobject_t>& r) const
{
if (l.first < r.first)
return true;
};
struct CmpHexdigitStringBitwise {
- bool operator()(const string& l, const string& r) const {
+ bool operator()(const std::string& l, const std::string& r) const {
return reverse_hexdigit_bits_string(l) < reverse_hexdigit_bits_string(r);
}
};
/// Get path contents by hash
int get_path_contents_by_hash_bitwise(
- const vector<string> &path, /// [in] Path to list
+ const std::vector<std::string> &path, /// [in] Path to list
const ghobject_t *next_object, /// [in] list > *next_object
- set<string, CmpHexdigitStringBitwise> *hash_prefixes, /// [out] prefixes in dir
- set<pair<string, ghobject_t>, CmpPairBitwise> *objects /// [out] objects
+ std::set<std::string, CmpHexdigitStringBitwise> *hash_prefixes, /// [out] prefixes in dir
+ std::set<std::pair<std::string, ghobject_t>, CmpPairBitwise> *objects /// [out] objects
);
/// List objects in collection in ghobject_t order
int list_by_hash(
- const vector<string> &path, /// [in] Path to list
+ const std::vector<std::string> &path, /// [in] Path to list
const ghobject_t &end, /// [in] List only objects < end
int max_count, /// [in] List at most max_count
ghobject_t *next, /// [in,out] List objects >= *next
- vector<ghobject_t> *out /// [out] Listed objects
+ std::vector<ghobject_t> *out /// [out] Listed objects
); ///< @return Error Code, 0 on success
/// List objects in collection in ghobject_t order
int list_by_hash_bitwise(
- const vector<string> &path, /// [in] Path to list
+ const std::vector<std::string> &path, /// [in] Path to list
const ghobject_t &end, /// [in] List only objects < end
int max_count, /// [in] List at most max_count
ghobject_t *next, /// [in,out] List objects >= *next
- vector<ghobject_t> *out /// [out] Listed objects
+ std::vector<ghobject_t> *out /// [out] Listed objects
); ///< @return Error Code, 0 on success
/// Create the given levels of sub directories from the given root.
/// The contents of *path* is not changed after calling this function.
- int recursive_create_path(vector<string>& path, int level);
+ int recursive_create_path(std::vector<std::string>& path, int level);
/// split each dir below the given path
- int split_dirs(const vector<string> &path, int target_level = 0);
+ int split_dirs(const std::vector<std::string> &path, int target_level = 0);
int write_settings();
};
#include "chain_xattr.h"
+using std::string;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::decode;
+using ceph::encode;
+
static int set_version(const char *path, uint32_t version) {
bufferlist bl;
encode(version, bl);
* @param [out] index Index for c
* @return error code
*/
- int get_index(coll_t c, const string& baseDir, Index *index);
+ int get_index(coll_t c, const std::string& baseDir, Index *index);
/**
* Initialize index for collection c at path
virtual void flush() = 0;
- virtual void get_devices(set<string> *ls) {}
- virtual void collect_metadata(map<string,string> *pm) {}
+ virtual void get_devices(std::set<std::string> *ls) {}
+ virtual void collect_metadata(std::map<std::string,std::string> *pm) {}
/**
* reserve_throttle_and_backoff
*
*/
virtual void reserve_throttle_and_backoff(uint64_t count) = 0;
- virtual int dump(ostream& out) { return -EOPNOTSUPP; }
+ virtual int dump(std::ostream& out) { return -EOPNOTSUPP; }
void set_wait_on_full(bool b) { wait_on_full = b; }
// writes
virtual bool is_writeable() = 0;
virtual int make_writeable() = 0;
- virtual void submit_entry(uint64_t seq, bufferlist& e, uint32_t orig_len,
+ virtual void submit_entry(uint64_t seq, ceph::buffer::list& e, uint32_t orig_len,
Context *oncommit,
TrackedOpRef osd_op = TrackedOpRef()) = 0;
virtual void commit_start(uint64_t seq) = 0;
/// Read next journal entry - asserts on invalid journal
virtual bool read_entry(
- bufferlist &bl, ///< [out] payload on successful read
+ ceph::buffer::list &bl, ///< [out] payload on successful read
uint64_t &seq ///< [in,out] sequence number on last successful read
) = 0; ///< @return true on successful read, false on journal end
virtual bool should_commit_now() = 0;
- virtual int prepare_entry(vector<ObjectStore::Transaction>& tls, bufferlist* tbl) = 0;
+ virtual int prepare_entry(std::vector<ObjectStore::Transaction>& tls, ceph::buffer::list* tbl) = 0;
virtual off64_t get_journal_size_estimate() { return 0; }
}
}
throttle.put(to_put_bytes);
- return make_pair(to_put_ops, to_put_bytes);
+ return std::make_pair(to_put_ops, to_put_bytes);
}
uint64_t JournalThrottle::get_current()
#undef dout_prefix
#define dout_prefix *_dout << "journal "
+using std::map;
+using std::vector;
+using ceph::bufferptr;
+using ceph::bufferlist;
void JournalingObjectStore::journal_start()
{
uint64_t max_applied_seq;
ceph::mutex com_lock = ceph::make_mutex("JOS::ApplyManager::com_lock");
- map<version_t, vector<Context*> > commit_waiters;
+ std::map<version_t, std::vector<Context*> > commit_waiters;
uint64_t committing_seq, committed_seq;
public:
void journal_write_close();
int journal_replay(uint64_t fs_op_seq);
- void _op_journal_transactions(bufferlist& tls, uint32_t orig_len, uint64_t op,
+ void _op_journal_transactions(ceph::buffer::list& tls, uint32_t orig_len, uint64_t op,
Context *onjournal, TrackedOpRef osd_op);
- virtual int do_transactions(vector<ObjectStore::Transaction>& tls, uint64_t op_seq) = 0;
+ virtual int do_transactions(std::vector<ObjectStore::Transaction>& tls, uint64_t op_seq) = 0;
public:
bool is_committing() {
#include "chain_xattr.h"
#include "LFNIndex.h"
-using ceph::crypto::SHA1;
#define dout_context cct
#define dout_subsys ceph_subsys_filestore
#undef dout_prefix
#define dout_prefix *_dout << "LFNIndex(" << get_base_path() << ") "
+using std::map;
+using std::pair;
+using std::set;
+using std::string;
+using std::vector;
+
+using ceph::crypto::SHA1;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
const string LFNIndex::LFN_ATTR = "user.cephos.lfn";
const string LFNIndex::PHASH_ATTR_PREFIX = "user.cephos.phash.";
/// Length of hashed filename cookie.
static const int FILENAME_EXTRA = 4;
/// Lfn cookie value.
- static const string FILENAME_COOKIE;
+ static const std::string FILENAME_COOKIE;
/// Name of LFN attribute for storing full name.
- static const string LFN_ATTR;
+ static const std::string LFN_ATTR;
/// Prefix for subdir index attributes.
- static const string PHASH_ATTR_PREFIX;
+ static const std::string PHASH_ATTR_PREFIX;
/// Prefix for index subdirectories.
- static const string SUBDIR_PREFIX;
+ static const std::string SUBDIR_PREFIX;
/// Path to Index base.
- const string base_path;
+ const std::string base_path;
protected:
const uint32_t index_version;
/// true if retry injection is enabled
- struct RetryException : public exception {};
+ struct RetryException : public std::exception {};
bool error_injection_enabled;
bool error_injection_on;
double error_injection_probability;
}
private:
- string lfn_attribute, lfn_alt_attribute;
+ std::string lfn_attribute, lfn_alt_attribute;
coll_t collection;
public:
} else {
char buf[100];
snprintf(buf, sizeof(buf), "%d", index_version);
- lfn_attribute = LFN_ATTR + string(buf);
- lfn_alt_attribute = LFN_ATTR + string(buf) + "-alt";
+ lfn_attribute = LFN_ATTR + std::string(buf);
+ lfn_alt_attribute = LFN_ATTR + std::string(buf) + "-alt";
}
}
const ghobject_t &start,
const ghobject_t &end,
int max_count,
- vector<ghobject_t> *ls,
+ std::vector<ghobject_t> *ls,
ghobject_t *next
) override;
/// Will be called upon object creation
virtual int _created(
- const vector<string> &path, ///< [in] Path to subdir.
+ const std::vector<std::string> &path, ///< [in] Path to subdir.
const ghobject_t &oid, ///< [in] Object created.
- const string &mangled_name ///< [in] Mangled filename.
+ const std::string &mangled_name ///< [in] Mangled filename.
) = 0;
/// Will be called to remove an object
virtual int _remove(
- const vector<string> &path, ///< [in] Path to subdir.
+ const std::vector<std::string> &path, ///< [in] Path to subdir.
const ghobject_t &oid, ///< [in] Object to remove.
- const string &mangled_name ///< [in] Mangled filename.
+ const std::string &mangled_name ///< [in] Mangled filename.
) = 0;
/// Return the path and mangled_name for oid.
virtual int _lookup(
const ghobject_t &oid,///< [in] Object for lookup.
- vector<string> *path, ///< [out] Path to the object.
- string *mangled_name, ///< [out] Mangled filename.
+ std::vector<std::string> *path, ///< [out] Path to the object.
+ std::string *mangled_name, ///< [out] Mangled filename.
int *exists ///< [out] True if the object exists.
) = 0;
const ghobject_t &start,
const ghobject_t &end,
int max_count,
- vector<ghobject_t> *ls,
+ std::vector<ghobject_t> *ls,
ghobject_t *next
) = 0;
/// Sync a subdirectory
int fsync_dir(
- const vector<string> &path ///< [in] Path to sync
+ const std::vector<std::string> &path ///< [in] Path to sync
); ///< @return Error Code, 0 on success
/// Link an object from from into to
int link_object(
- const vector<string> &from, ///< [in] Source subdirectory.
- const vector<string> &to, ///< [in] Dest subdirectory.
+ const std::vector<std::string> &from, ///< [in] Source subdirectory.
+ const std::vector<std::string> &to, ///< [in] Dest subdirectory.
const ghobject_t &oid, ///< [in] Object to move.
- const string &from_short_name ///< [in] Mangled filename of oid.
+ const std::string &from_short_name ///< [in] Mangled filename of oid.
); ///< @return Error Code, 0 on success
/**
* @return Error Code, 0 on success.
*/
int remove_objects(
- const vector<string> &dir,
- const map<string, ghobject_t> &to_remove,
- map<string, ghobject_t> *remaining
+ const std::vector<std::string> &dir,
+ const std::map<std::string, ghobject_t> &to_remove,
+ std::map<std::string, ghobject_t> *remaining
);
* @return Error Code, 0 on success
*/
int move_objects(
- const vector<string> &from, ///< [in] Source subdirectory.
- const vector<string> &to ///< [in] Dest subdirectory.
+ const std::vector<std::string> &from, ///< [in] Source subdirectory.
+ const std::vector<std::string> &to ///< [in] Dest subdirectory.
);
/**
* @return Error Code, 0 on success
*/
int remove_object(
- const vector<string> &from, ///< [in] Directory from which to remove.
+ const std::vector<std::string> &from, ///< [in] Directory from which to remove.
const ghobject_t &to_remove ///< [in] Object to remove.
);
* @return Error code on failure, 0 on success
*/
int get_mangled_name(
- const vector<string> &from, ///< [in] Subdirectory
+ const std::vector<std::string> &from, ///< [in] Subdirectory
const ghobject_t &oid, ///< [in] Object
- string *mangled_name, ///< [out] Filename
+ std::string *mangled_name, ///< [out] Filename
int *hardlink ///< [out] hardlink for this file, hardlink=0 mean no-exist
);
static int move_subdir(
LFNIndex &from, ///< [in] from index
LFNIndex &dest, ///< [in] to index
- const vector<string> &path, ///< [in] path containing dir
- string dir ///< [in] dir to move
+ const std::vector<std::string> &path, ///< [in] path containing dir
+ std::string dir ///< [in] dir to move
);
/// do move object from from to dest
static int move_object(
LFNIndex &from, ///< [in] from index
LFNIndex &dest, ///< [in] to index
- const vector<string> &path, ///< [in] path to split
- const pair<string, ghobject_t> &obj ///< [in] obj to move
+ const std::vector<std::string> &path, ///< [in] path to split
+ const std::pair<std::string, ghobject_t> &obj ///< [in] obj to move
);
/**
* @return Error code on failure, 0 on success
*/
int list_objects(
- const vector<string> &to_list,
+ const std::vector<std::string> &to_list,
int max_objects,
long *handle,
- map<string, ghobject_t> *out
+ std::map<std::string, ghobject_t> *out
);
/// Lists subdirectories.
int list_subdirs(
- const vector<string> &to_list, ///< [in] Directory to list.
- vector<string> *out ///< [out] Subdirectories listed.
+ const std::vector<std::string> &to_list, ///< [in] Directory to list.
+ std::vector<std::string> *out ///< [out] Subdirectories listed.
);
/// Create subdirectory.
int create_path(
- const vector<string> &to_create ///< [in] Subdirectory to create.
+ const std::vector<std::string> &to_create ///< [in] Subdirectory to create.
);
/// Remove subdirectory.
int remove_path(
- const vector<string> &to_remove ///< [in] Subdirectory to remove.
+ const std::vector<std::string> &to_remove ///< [in] Subdirectory to remove.
);
/// Check whether to_check exists.
int path_exists(
- const vector<string> &to_check, ///< [in] Subdirectory to check.
+ const std::vector<std::string> &to_check, ///< [in] Subdirectory to check.
int *exists ///< [out] 1 if it exists, 0 else
);
/// Save attr_value to attr_name attribute on path.
int add_attr_path(
- const vector<string> &path, ///< [in] Path to modify.
- const string &attr_name, ///< [in] Name of attribute.
- bufferlist &attr_value ///< [in] Value to save.
+ const std::vector<std::string> &path, ///< [in] Path to modify.
+ const std::string &attr_name, ///< [in] Name of attribute.
+ ceph::buffer::list &attr_value ///< [in] Value to save.
);
/// Read into attr_value attribute attr_name on path.
int get_attr_path(
- const vector<string> &path, ///< [in] Path to read.
- const string &attr_name, ///< [in] Attribute to read.
- bufferlist &attr_value ///< [out] Attribute value read.
+ const std::vector<std::string> &path, ///< [in] Path to read.
+ const std::string &attr_name, ///< [in] Attribute to read.
+ ceph::buffer::list &attr_value ///< [out] Attribute value read.
);
/// Remove attr from path
int remove_attr_path(
- const vector<string> &path, ///< [in] path from which to remove attr
- const string &attr_name ///< [in] attr to remove
+ const std::vector<std::string> &path, ///< [in] path from which to remove attr
+ const std::string &attr_name ///< [in] attr to remove
); ///< @return Error code, 0 on success
private:
/**
* Gets the version specific lfn attribute tag
*/
- const string &get_lfn_attr() const {
+ const std::string &get_lfn_attr() const {
return lfn_attribute;
}
- const string &get_alt_lfn_attr() const {
+ const std::string &get_alt_lfn_attr() const {
return lfn_alt_attribute;
}
* @return Error Code, 0 on success.
*/
int lfn_get_name(
- const vector<string> &path,
+ const std::vector<std::string> &path,
const ghobject_t &oid,
- string *mangled_name,
- string *full_path,
+ std::string *mangled_name,
+ std::string *full_path,
int *hardlink
);
/// Adjusts path contents when oid is created at name mangled_name.
int lfn_created(
- const vector<string> &path, ///< [in] Path to adjust.
+ const std::vector<std::string> &path, ///< [in] Path to adjust.
const ghobject_t &oid, ///< [in] Object created.
- const string &mangled_name ///< [in] Filename of created object.
+ const std::string &mangled_name ///< [in] Filename of created object.
);
/// Removes oid from path while adjusting path contents
int lfn_unlink(
- const vector<string> &path, ///< [in] Path containing oid.
+ const std::vector<std::string> &path, ///< [in] Path containing oid.
const ghobject_t &oid, ///< [in] Object to remove.
- const string &mangled_name ///< [in] Filename of object to remove.
+ const std::string &mangled_name ///< [in] Filename of object to remove.
);
///Transate a file into and ghobject_t.
int lfn_translate(
- const vector<string> &path, ///< [in] Path containing the file.
- const string &short_name, ///< [in] Filename to translate.
+ const std::vector<std::string> &path, ///< [in] Path containing the file.
+ const std::string &short_name, ///< [in] Filename to translate.
ghobject_t *out ///< [out] Object found.
); ///< @return Negative error code on error, 0 if not an object, 1 else
/* manglers/demanglers */
/// Filters object filenames
bool lfn_is_object(
- const string &short_name ///< [in] Filename to check
+ const std::string &short_name ///< [in] Filename to check
); ///< True if short_name is an object, false otherwise
/// Filters subdir filenames
bool lfn_is_subdir(
- const string &short_name, ///< [in] Filename to check.
- string *demangled_name ///< [out] Demangled subdir name.
+ const std::string &short_name, ///< [in] Filename to check.
+ std::string *demangled_name ///< [out] Demangled subdir name.
); ///< @return True if short_name is a subdir, false otherwise
/// Generate object name
- string lfn_generate_object_name_keyless(
+ std::string lfn_generate_object_name_keyless(
const ghobject_t &oid ///< [in] Object for which to generate.
); ///< @return Generated object name.
/// Generate object name
- string lfn_generate_object_name_poolless(
+ std::string lfn_generate_object_name_poolless(
const ghobject_t &oid ///< [in] Object for which to generate.
); ///< @return Generated object name.
/// Generate object name
- static string lfn_generate_object_name_current(
+ static std::string lfn_generate_object_name_current(
const ghobject_t &oid ///< [in] Object for which to generate.
); ///< @return Generated object name.
/// Generate object name
- string lfn_generate_object_name(
+ std::string lfn_generate_object_name(
const ghobject_t &oid ///< [in] Object for which to generate.
) {
if (index_version == HASH_INDEX_TAG)
/// Parse object name
int lfn_parse_object_name_keyless(
- const string &long_name, ///< [in] Name to parse
+ const std::string &long_name, ///< [in] Name to parse
ghobject_t *out ///< [out] Resulting Object
); ///< @return True if successful, False otherwise.
/// Parse object name
int lfn_parse_object_name_poolless(
- const string &long_name, ///< [in] Name to parse
+ const std::string &long_name, ///< [in] Name to parse
ghobject_t *out ///< [out] Resulting Object
); ///< @return True if successful, False otherwise.
/// Parse object name
int lfn_parse_object_name(
- const string &long_name, ///< [in] Name to parse
+ const std::string &long_name, ///< [in] Name to parse
ghobject_t *out ///< [out] Resulting Object
); ///< @return True if successful, False otherwise.
/// Checks whether short_name is a hashed filename.
bool lfn_is_hashed_filename(
- const string &short_name ///< [in] Name to check.
+ const std::string &short_name ///< [in] Name to check.
); ///< @return True if short_name is hashed, False otherwise.
/// Checks whether long_name must be hashed.
bool lfn_must_hash(
- const string &long_name ///< [in] Name to check.
+ const std::string &long_name ///< [in] Name to check.
); ///< @return True if long_name must be hashed, False otherwise.
/// Generate hashed name.
- string lfn_get_short_name(
+ std::string lfn_get_short_name(
const ghobject_t &oid, ///< [in] Object for which to generate.
int i ///< [in] Index of hashed name to generate.
); ///< @return Hashed filename.
/* other common methods */
/// Gets the base path
- const string &get_base_path(); ///< @return Index base_path
+ const std::string &get_base_path(); ///< @return Index base_path
/// Get full path the subdir
- string get_full_path_subdir(
- const vector<string> &rel ///< [in] The subdir.
+ std::string get_full_path_subdir(
+ const std::vector<std::string> &rel ///< [in] The subdir.
); ///< @return Full path to rel.
/// Get full path to object
- string get_full_path(
- const vector<string> &rel, ///< [in] Path to object.
- const string &name ///< [in] Filename of object.
+ std::string get_full_path(
+ const std::vector<std::string> &rel, ///< [in] Path to object.
+ const std::string &name ///< [in] Filename of object.
); ///< @return Fullpath to object at name in rel.
/// Get mangled path component
- string mangle_path_component(
- const string &component ///< [in] Component to mangle
+ std::string mangle_path_component(
+ const std::string &component ///< [in] Component to mangle
); /// @return Mangled component
/// Demangle component
- string demangle_path_component(
- const string &component ///< [in] Subdir name to demangle
+ std::string demangle_path_component(
+ const std::string &component ///< [in] Subdir name to demangle
); ///< @return Demangled path component.
/// Decompose full path into object name and filename.
int decompose_full_path(
const char *in, ///< [in] Full path to object.
- vector<string> *out, ///< [out] Path to object at in.
+ std::vector<std::string> *out, ///< [out] Path to object at in.
ghobject_t *oid, ///< [out] Object at in.
- string *shortname ///< [out] Filename of object at in.
+ std::string *shortname ///< [out] Filename of object at in.
); ///< @return Error Code, 0 on success.
/// Mangle attribute name
- string mangle_attr_name(
- const string &attr ///< [in] Attribute to mangle.
+ std::string mangle_attr_name(
+ const std::string &attr ///< [in] Attribute to mangle.
); ///< @return Mangled attribute name.
/// checks whether long_name could hash to short_name
SequencerPosition(uint64_t s=0, int32_t t=0, int32_t o=0) : seq(s), trans(t), op(o) {}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
ENCODE_START(1, 1, bl);
encode(seq, bl);
encode(trans, bl);
encode(op, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
DECODE_START(1, p);
decode(seq, p);
decode(trans, p);
decode(op, p);
DECODE_FINISH(p);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_unsigned("seq", seq);
f->dump_unsigned("trans", trans);
f->dump_unsigned("op", op);
}
- static void generate_test_instances(list<SequencerPosition*>& o) {
+ static void generate_test_instances(std::list<SequencerPosition*>& o) {
o.push_back(new SequencerPosition);
o.push_back(new SequencerPosition(1, 2, 3));
o.push_back(new SequencerPosition(4, 5, 6));
};
WRITE_CLASS_ENCODER(SequencerPosition)
-inline ostream& operator<<(ostream& out, const SequencerPosition& t) {
+inline std::ostream& operator<<(std::ostream& out, const SequencerPosition& t) {
return out << t.seq << "." << t.trans << "." << t.op;
}
#include "common/perf_counters.h"
#include "common/errno.h"
+using std::pair;
+using std::string;
+
WBThrottle::WBThrottle(CephContext *cct) :
cur_ios(0), cur_size(0),
cct(cct),
*/
/// Limits on unflushed bytes
- pair<uint64_t, uint64_t> size_limits;
+ std::pair<uint64_t, uint64_t> size_limits;
/// Limits on unflushed ios
- pair<uint64_t, uint64_t> io_limits;
+ std::pair<uint64_t, uint64_t> io_limits;
/// Limits on unflushed objects
- pair<uint64_t, uint64_t> fd_limits;
+ std::pair<uint64_t, uint64_t> fd_limits;
uint64_t cur_ios; /// Currently unflushed IOs
uint64_t cur_size; /// Currently unflushed bytes
/**
* Flush objects in lru order
*/
- list<ghobject_t> lru;
- ceph::unordered_map<ghobject_t, list<ghobject_t>::iterator> rev_lru;
+ std::list<ghobject_t> lru;
+ ceph::unordered_map<ghobject_t, std::list<ghobject_t>::iterator> rev_lru;
void remove_object(const ghobject_t &oid) {
ceph_assert(ceph_mutex_is_locked(lock));
- ceph::unordered_map<ghobject_t, list<ghobject_t>::iterator>::iterator iter =
+ ceph::unordered_map<ghobject_t, std::list<ghobject_t>::iterator>::iterator iter =
rev_lru.find(oid);
if (iter == rev_lru.end())
return;
rev_lru.insert(make_pair(oid, --lru.end()));
}
- ceph::unordered_map<ghobject_t, pair<PendingWB, FDRef> > pending_wbs;
+ ceph::unordered_map<ghobject_t,
std::pair<PendingWB, FDRef> > pending_wbs;
/// get next flush to perform
bool get_next_should_flush(
#include "include/ceph_assert.h"
+using ceph::bufferptr;
+
/*
* chaining xattrs
*
// wrappers to hide annoying errno handling.
-static inline int sys_fgetxattr(int fd, const char *name, void *val, size_t size)
+inline int sys_fgetxattr(int fd, const char *name, void *val, size_t size)
{
int r = ::ceph_os_fgetxattr(fd, name, val, size);
return (r < 0 ? -errno : r);
}
-static inline int sys_getxattr(const char *fn, const char *name, void *val, size_t size)
+inline int sys_getxattr(const char *fn, const char *name, void *val, size_t size)
{
int r = ::ceph_os_getxattr(fn, name, val, size);
return (r < 0 ? -errno : r);
}
-static inline int sys_setxattr(const char *fn, const char *name, const void *val, size_t size)
+inline int sys_setxattr(const char *fn, const char *name, const void *val, size_t size)
{
int r = ::ceph_os_setxattr(fn, name, val, size);
return (r < 0 ? -errno : r);
}
-static inline int sys_fsetxattr(int fd, const char *name, const void *val, size_t size)
+inline int sys_fsetxattr(int fd, const char *name, const void *val, size_t size)
{
int r = ::ceph_os_fsetxattr(fd, name, val, size);
return (r < 0 ? -errno : r);
}
-static inline int sys_listxattr(const char *fn, char *names, size_t len)
+inline int sys_listxattr(const char *fn, char *names, size_t len)
{
int r = ::ceph_os_listxattr(fn, names, len);
return (r < 0 ? -errno : r);
}
-static inline int sys_flistxattr(int fd, char *names, size_t len)
+inline int sys_flistxattr(int fd, char *names, size_t len)
{
int r = ::ceph_os_flistxattr(fd, names, len);
return (r < 0 ? -errno : r);
}
-static inline int sys_removexattr(const char *fn, const char *name)
+inline int sys_removexattr(const char *fn, const char *name)
{
int r = ::ceph_os_removexattr(fn, name);
return (r < 0 ? -errno : r);
}
-static inline int sys_fremovexattr(int fd, const char *name)
+inline int sys_fremovexattr(int fd, const char *name)
{
int r = ::ceph_os_fremovexattr(fd, name);
return (r < 0 ? -errno : r);
// wrappers to chain large values across multiple xattrs
int chain_getxattr(const char *fn, const char *name, void *val, size_t size);
-int chain_getxattr_buf(const char *fn, const char *name, bufferptr *bp);
+int chain_getxattr_buf(const char *fn, const char *name, ceph::buffer::ptr *bp);
int chain_fgetxattr(int fd, const char *name, void *val, size_t size);
int get_xattr_block_size(size_t size);
{
// fall back to writing zeros
- bufferlist bl;
+ ceph::bufferlist bl;
bl.append_zero(length);
r = ::lseek64(fd, offset, SEEK_SET);
if (r < 0) {
*/
+using std::list;
+using std::make_pair;
+using std::map;
+using std::pair;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
+using ceph::bufferlist;
+using ceph::bufferptr;
+using ceph::decode;
+using ceph::encode;
+using ceph::JSONFormatter;
+
const string PREFIX_SUPER = "S"; // field -> value
const string PREFIX_COLL = "C"; // collection name -> (nothing)
const string PREFIX_OBJ = "O"; // object name -> onode
auto p = bl.cbegin();
try {
decode(c->cnode, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
derr << __func__ << " failed to decode cnode, key:"
<< pretty_binary_string(it->key()) << dendl;
return -EIO;
auto p = bl.cbegin();
try {
decode(nid_max, p);
- } catch (buffer::error& e) {
+ } catch (ceph::buffer::error& e) {
}
dout(10) << __func__ << " old nid_max " << nid_max << dendl;
nid_last = nid_max;
// types
public:
- class TransContext;
+ struct TransContext;
/// an in-memory object
struct Onode {
std::atomic_int nref; ///< reference count
ghobject_t oid;
- string key; ///< key under PREFIX_OBJ where we are stored
+ std::string key; ///< key under PREFIX_OBJ where we are stored
boost::intrusive::list_member_hook<> lru_item;
kstore_onode_t onode; ///< metadata stored as value in kv store
std::mutex flush_lock; ///< protect flush_txns
std::condition_variable flush_cond; ///< wait here for unapplied txns
- set<TransContext*> flush_txns; ///< committing txns
+ std::set<TransContext*> flush_txns; ///< committing txns
uint64_t tail_offset;
- bufferlist tail_bl;
+ ceph::buffer::list tail_bl;
- map<uint64_t,bufferlist> pending_stripes; ///< unwritten stripes
+ std::map<uint64_t,ceph::buffer::list> pending_stripes; ///< unwritten stripes
- Onode(CephContext* cct, const ghobject_t& o, const string& k)
+ Onode(CephContext* cct, const ghobject_t& o, const std::string& k)
: cct(cct),
nref(0),
oid(o),
OnodeRef lookup(const ghobject_t& o);
void rename(const ghobject_t& old_oid, const ghobject_t& new_oid);
void clear();
- bool get_next(const ghobject_t& after, pair<ghobject_t,OnodeRef> *next);
+ bool get_next(const ghobject_t& after, std::pair<ghobject_t,OnodeRef> *next);
int trim(int max=-1);
};
CollectionRef c;
OnodeRef o;
KeyValueDB::Iterator it;
- string head, tail;
+ std::string head, tail;
public:
OmapIteratorImpl(CollectionRef c, OnodeRef o, KeyValueDB::Iterator it);
int seek_to_first() override;
- int upper_bound(const string &after) override;
- int lower_bound(const string &to) override;
+ int upper_bound(const std::string &after) override;
+ int lower_bound(const std::string &to) override;
bool valid() override;
int next() override;
- string key() override;
- bufferlist value() override;
+ std::string key() override;
+ ceph::buffer::list value() override;
int status() override {
return 0;
}
uint64_t ops, bytes;
- set<OnodeRef> onodes; ///< these onodes need to be updated/written
+ std::set<OnodeRef> onodes; ///< these onodes need to be updated/written
KeyValueDB::Transaction t; ///< then we will commit this
Context *oncommit; ///< signal on commit
Context *onreadable; ///< signal on readable
Context *onreadable_sync; ///< signal on readable
- list<Context*> oncommits; ///< more commit completions
- list<CollectionRef> removed_collections; ///< colls we removed
+ std::list<Context*> oncommits; ///< more commit completions
+ std::list<CollectionRef> removed_collections; ///< colls we removed
CollectionRef first_collection; ///< first referenced collection
utime_t start;
private:
KeyValueDB *db;
uuid_d fsid;
- string basedir;
+ std::string basedir;
int path_fd; ///< open handle to $path
int fsid_fd; ///< open handle (locked) to $path/fsid
bool mounted;
/// rwlock to protect coll_map
ceph::shared_mutex coll_lock = ceph::make_shared_mutex("KStore::coll_lock");
ceph::unordered_map<coll_t, CollectionRef> coll_map;
- map<coll_t,CollectionRef> new_coll_map;
+ std::map<coll_t,CollectionRef> new_coll_map;
std::mutex nid_lock;
uint64_t nid_last;
std::mutex kv_lock;
std::condition_variable kv_cond, kv_sync_cond;
bool kv_stop;
- deque<TransContext*> kv_queue, kv_committing;
+ std::deque<TransContext*> kv_queue, kv_committing;
//Logger *logger;
PerfCounters *logger;
std::mutex reap_lock;
- list<CollectionRef> removed_collections;
+ std::list<CollectionRef> removed_collections;
// --------------------------------------------------------
kv_stop = false;
}
- void _do_read_stripe(OnodeRef o, uint64_t offset, bufferlist *pbl, bool do_cache);
+ void _do_read_stripe(OnodeRef o, uint64_t offset, ceph::buffer::list *pbl, bool do_cache);
void _do_write_stripe(TransContext *txc, OnodeRef o,
- uint64_t offset, bufferlist& bl);
+ uint64_t offset, ceph::buffer::list& bl);
void _do_remove_stripe(TransContext *txc, OnodeRef o, uint64_t offset);
int _collection_list(
Collection *c, const ghobject_t& start, const ghobject_t& end,
- int max, vector<ghobject_t> *ls, ghobject_t *next);
+ int max, std::vector<ghobject_t> *ls, ghobject_t *next);
public:
- KStore(CephContext *cct, const string& path);
+ KStore(CephContext *cct, const std::string& path);
~KStore() override;
- string get_type() override {
+ std::string get_type() override {
return "kstore";
}
bool wants_journal() override { return false; };
bool allows_journal() override { return false; };
- static int get_block_device_fsid(const string& path, uuid_d *fsid);
+ static int get_block_device_fsid(const std::string& path, uuid_d *fsid);
bool test_mount_in_use() override;
int mkjournal() override {
return 0;
}
- void dump_perf_counters(Formatter *f) override {
+ void dump_perf_counters(ceph::Formatter *f) override {
f->open_object_section("perf_counters");
logger->dump_formatted(f, false);
f->close_section();
}
- void get_db_statistics(Formatter *f) override {
+ void get_db_statistics(ceph::Formatter *f) override {
db->get_statistics(f);
}
int statfs(struct store_statfs_t *buf,
const ghobject_t& oid,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags = 0) override;
int _do_read(
OnodeRef o,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
bool do_cache,
uint32_t op_flags = 0);
using ObjectStore::fiemap;
- int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, map<uint64_t, uint64_t>& destmap) override;
- int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, bufferlist& outbl) override;
+ int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, std::map<uint64_t, uint64_t>& destmap) override;
+ int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset, size_t len, ceph::buffer::list& outbl) override;
using ObjectStore::getattr;
- int getattr(CollectionHandle& c, const ghobject_t& oid, const char *name, bufferptr& value) override;
+ int getattr(CollectionHandle& c, const ghobject_t& oid, const char *name, ceph::buffer::ptr& value) override;
using ObjectStore::getattrs;
- int getattrs(CollectionHandle& c, const ghobject_t& oid, map<string,bufferptr>& aset) override;
+ int getattrs(CollectionHandle& c, const ghobject_t& oid, std::map<std::string,ceph::buffer::ptr>& aset) override;
- int list_collections(vector<coll_t>& ls) override;
+ int list_collections(std::vector<coll_t>& ls) override;
bool collection_exists(const coll_t& c) override;
int collection_empty(CollectionHandle& c, bool *empty) override;
int collection_bits(CollectionHandle& c) override;
int collection_list(
CollectionHandle &c, const ghobject_t& start, const ghobject_t& end,
int max,
- vector<ghobject_t> *ls, ghobject_t *next) override;
+ std::vector<ghobject_t> *ls, ghobject_t *next) override;
using ObjectStore::omap_get;
int omap_get(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
- map<string, bufferlist> *out /// < [out] Key to value map
+ ceph::buffer::list *header, ///< [out] omap header
+ std::map<std::string, ceph::buffer::list> *out /// < [out] Key to value std::map
) override;
using ObjectStore::omap_get_header;
int omap_get_header(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
+ ceph::buffer::list *header, ///< [out] omap header
bool allow_eio = false ///< [in] don't assert on eio
) override;
int omap_get_keys(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- set<string> *keys ///< [out] Keys defined on oid
+ std::set<std::string> *keys ///< [out] Keys defined on oid
) override;
using ObjectStore::omap_get_values;
int omap_get_values(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to get
- map<string, bufferlist> *out ///< [out] Returned keys and values
+ const std::set<std::string> &keys, ///< [in] Keys to get
+ std::map<std::string, ceph::buffer::list> *out ///< [out] Returned keys and values
) override;
using ObjectStore::omap_check_keys;
int omap_check_keys(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to check
- set<string> *out ///< [out] Subset of keys defined on oid
+ const std::set<std::string> &keys, ///< [in] Keys to check
+ std::set<std::string> *out ///< [out] Subset of keys defined on oid
) override;
using ObjectStore::get_omap_iterator;
int queue_transactions(
CollectionHandle& ch,
- vector<Transaction>& tls,
+ std::vector<Transaction>& tls,
TrackedOpRef op = TrackedOpRef(),
ThreadPool::TPHandle *handle = NULL) override;
CollectionRef& c,
OnodeRef& o,
uint64_t offset, size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t fadvise_flags);
int _do_write(TransContext *txc,
OnodeRef o,
uint64_t offset, uint64_t length,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t fadvise_flags);
int _touch(TransContext *txc,
CollectionRef& c,
int _setattr(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const string& name,
- bufferptr& val);
+ const std::string& name,
+ ceph::buffer::ptr& val);
int _setattrs(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const map<string,bufferptr>& aset);
+ const std::map<std::string,ceph::buffer::ptr>& aset);
int _rmattr(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const string& name);
+ const std::string& name);
int _rmattrs(TransContext *txc,
CollectionRef& c,
OnodeRef& o);
int _omap_setkeys(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& bl);
+ ceph::buffer::list& bl);
int _omap_setheader(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& header);
+ ceph::buffer::list& header);
int _omap_rmkeys(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const bufferlist& bl);
+ const ceph::buffer::list& bl);
int _omap_rmkey_range(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- const string& first, const string& last);
+ const std::string& first, const std::string& last);
int _setallochint(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
#include "common/Formatter.h"
#include "include/stringify.h"
+using std::list;
+
+using ceph::bufferlist;
+using ceph::Formatter;
+
// cnode_t
void kstore_cnode_t::encode(bufferlist& bl) const
f->dump_unsigned("nid", nid);
f->dump_unsigned("size", size);
f->open_object_section("attrs");
- for (map<string,bufferptr>::const_iterator p = attrs.begin();
- p != attrs.end(); ++p) {
+ for (auto p = attrs.begin(); p != attrs.end(); ++p) {
f->open_object_section("attr");
f->dump_string("name", p->first);
f->dump_unsigned("len", p->second.length());
explicit kstore_cnode_t(int b=0) : bits(b) {}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<kstore_cnode_t*>& o);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<kstore_cnode_t*>& o);
};
WRITE_CLASS_ENCODER(kstore_cnode_t)
struct kstore_onode_t {
uint64_t nid; ///< numeric id (locally unique)
uint64_t size; ///< object size
- map<string, bufferptr> attrs; ///< attrs
+ std::map<std::string, ceph::buffer::ptr> attrs; ///< attrs
uint64_t omap_head; ///< id for omap root node
uint32_t stripe_size; ///< stripe size
expected_write_size(0),
alloc_hint_flags(0) {}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
- static void generate_test_instances(list<kstore_onode_t*>& o);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<kstore_onode_t*>& o);
};
WRITE_CLASS_ENCODER(kstore_onode_t)
#undef dout_prefix
#define dout_prefix *_dout << "memstore(" << path << ") "
+using ceph::decode;
+using ceph::encode;
+
// for comparing collections for lock ordering
bool operator>(const MemStore::CollectionRef& l,
const MemStore::CollectionRef& r)
{
dout(10) << __func__ << dendl;
dump_all();
- set<coll_t> collections;
- for (ceph::unordered_map<coll_t,CollectionRef>::iterator p = coll_map.begin();
- p != coll_map.end();
- ++p) {
+ std::set<coll_t> collections;
+ for (auto p = coll_map.begin(); p != coll_map.end(); ++p) {
dout(20) << __func__ << " coll " << p->first << " " << p->second << dendl;
collections.insert(p->first);
- bufferlist bl;
+ ceph::buffer::list bl;
ceph_assert(p->second);
p->second->encode(bl);
- string fn = path + "/" + stringify(p->first);
+ std::string fn = path + "/" + stringify(p->first);
int r = bl.write_file(fn.c_str());
if (r < 0)
return r;
}
- string fn = path + "/collections";
- bufferlist bl;
+ std::string fn = path + "/collections";
+ ceph::buffer::list bl;
encode(collections, bl);
int r = bl.write_file(fn.c_str());
if (r < 0)
void MemStore::dump_all()
{
- Formatter *f = Formatter::create("json-pretty");
+ auto f = ceph::Formatter::create("json-pretty");
f->open_object_section("store");
dump(f);
f->close_section();
delete f;
}
-void MemStore::dump(Formatter *f)
+void MemStore::dump(ceph::Formatter *f)
{
f->open_array_section("collections");
- for (ceph::unordered_map<coll_t,CollectionRef>::iterator p = coll_map.begin();
- p != coll_map.end();
- ++p) {
+ for (auto p = coll_map.begin(); p != coll_map.end(); ++p) {
f->open_object_section("collection");
f->dump_string("name", stringify(p->first));
f->open_array_section("xattrs");
- for (map<string,bufferptr>::iterator q = p->second->xattr.begin();
+ for (auto q = p->second->xattr.begin();
q != p->second->xattr.end();
++q) {
f->open_object_section("xattr");
f->close_section();
f->open_array_section("objects");
- for (map<ghobject_t,ObjectRef>::iterator q = p->second->object_map.begin();
+ for (auto q = p->second->object_map.begin();
q != p->second->object_map.end();
++q) {
f->open_object_section("object");
int MemStore::_load()
{
dout(10) << __func__ << dendl;
- bufferlist bl;
- string fn = path + "/collections";
- string err;
+ ceph::buffer::list bl;
+ std::string fn = path + "/collections";
+ std::string err;
int r = bl.read_file(fn.c_str(), &err);
if (r < 0)
return r;
- set<coll_t> collections;
+ std::set<coll_t> collections;
auto p = bl.cbegin();
decode(collections, p);
- for (set<coll_t>::iterator q = collections.begin();
+ for (auto q = collections.begin();
q != collections.end();
++q) {
- string fn = path + "/" + stringify(*q);
- bufferlist cbl;
+ std::string fn = path + "/" + stringify(*q);
+ ceph::buffer::list cbl;
int r = cbl.read_file(fn.c_str(), &err);
if (r < 0)
return r;
uuid_d MemStore::get_fsid()
{
- string fsid_str;
+ std::string fsid_str;
int r = read_meta("fsid", &fsid_str);
ceph_assert(r >= 0);
uuid_d uuid;
int MemStore::mkfs()
{
- string fsid_str;
+ std::string fsid_str;
int r = read_meta("fsid", &fsid_str);
if (r == -ENOENT) {
uuid_d fsid;
dout(1) << __func__ << " had fsid " << fsid_str << dendl;
}
- string fn = path + "/collections";
+ std::string fn = path + "/collections";
derr << path << dendl;
- bufferlist bl;
- set<coll_t> collections;
+ ceph::buffer::list bl;
+ std::set<coll_t> collections;
encode(collections, bl);
r = bl.write_file(fn.c_str());
if (r < 0)
const ghobject_t& oid,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags)
{
Collection *c = static_cast<Collection*>(c_.get());
}
int MemStore::fiemap(CollectionHandle& ch, const ghobject_t& oid,
- uint64_t offset, size_t len, bufferlist& bl)
+ uint64_t offset, size_t len, ceph::buffer::list& bl)
{
- map<uint64_t, uint64_t> destmap;
+ std::map<uint64_t, uint64_t> destmap;
int r = fiemap(ch, oid, offset, len, destmap);
if (r >= 0)
encode(destmap, bl);
}
int MemStore::fiemap(CollectionHandle& ch, const ghobject_t& oid,
- uint64_t offset, size_t len, map<uint64_t, uint64_t>& destmap)
+ uint64_t offset, size_t len, std::map<uint64_t, uint64_t>& destmap)
{
dout(10) << __func__ << " " << ch->cid << " " << oid << " " << offset << "~"
<< len << dendl;
}
int MemStore::getattr(CollectionHandle &c_, const ghobject_t& oid,
- const char *name, bufferptr& value)
+ const char *name, ceph::buffer::ptr& value)
{
Collection *c = static_cast<Collection*>(c_.get());
dout(10) << __func__ << " " << c->cid << " " << oid << " " << name << dendl;
ObjectRef o = c->get_object(oid);
if (!o)
return -ENOENT;
- string k(name);
+ std::string k(name);
std::lock_guard lock{o->xattr_mutex};
if (!o->xattr.count(k)) {
return -ENODATA;
}
int MemStore::getattrs(CollectionHandle &c_, const ghobject_t& oid,
- map<string,bufferptr>& aset)
+ std::map<std::string,ceph::buffer::ptr>& aset)
{
Collection *c = static_cast<Collection*>(c_.get());
dout(10) << __func__ << " " << c->cid << " " << oid << dendl;
return 0;
}
-int MemStore::list_collections(vector<coll_t>& ls)
+int MemStore::list_collections(std::vector<coll_t>& ls)
{
dout(10) << __func__ << dendl;
std::shared_lock l{coll_lock};
const ghobject_t& start,
const ghobject_t& end,
int max,
- vector<ghobject_t> *ls, ghobject_t *next)
+ std::vector<ghobject_t> *ls, ghobject_t *next)
{
Collection *c = static_cast<Collection*>(ch.get());
std::shared_lock l{c->lock};
dout(10) << __func__ << " cid " << ch->cid << " start " << start
<< " end " << end << dendl;
- map<ghobject_t,ObjectRef>::iterator p = c->object_map.lower_bound(start);
+ auto p = c->object_map.lower_bound(start);
while (p != c->object_map.end() &&
ls->size() < (unsigned)max &&
p->first < end) {
int MemStore::omap_get(
CollectionHandle& ch, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
- map<string, bufferlist> *out /// < [out] Key to value map
+ ceph::buffer::list *header, ///< [out] omap header
+ std::map<std::string, ceph::buffer::list> *out /// < [out] Key to value map
)
{
dout(10) << __func__ << " " << ch->cid << " " << oid << dendl;
int MemStore::omap_get_header(
CollectionHandle& ch, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
+ ceph::buffer::list *header, ///< [out] omap header
bool allow_eio ///< [in] don't assert on eio
)
{
int MemStore::omap_get_keys(
CollectionHandle& ch, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- set<string> *keys ///< [out] Keys defined on oid
+ std::set<std::string> *keys ///< [out] Keys defined on oid
)
{
dout(10) << __func__ << " " << ch->cid << " " << oid << dendl;
if (!o)
return -ENOENT;
std::lock_guard lock{o->omap_mutex};
- for (map<string,bufferlist>::iterator p = o->omap.begin();
- p != o->omap.end();
- ++p)
+ for (auto p = o->omap.begin(); p != o->omap.end(); ++p)
keys->insert(p->first);
return 0;
}
int MemStore::omap_get_values(
CollectionHandle& ch, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to get
- map<string, bufferlist> *out ///< [out] Returned keys and values
+ const std::set<std::string> &keys, ///< [in] Keys to get
+ std::map<std::string, ceph::buffer::list> *out ///< [out] Returned keys and values
)
{
dout(10) << __func__ << " " << ch->cid << " " << oid << dendl;
if (!o)
return -ENOENT;
std::lock_guard lock{o->omap_mutex};
- for (set<string>::const_iterator p = keys.begin();
- p != keys.end();
- ++p) {
- map<string,bufferlist>::iterator q = o->omap.find(*p);
+ for (auto p = keys.begin(); p != keys.end(); ++p) {
+ auto q = o->omap.find(*p);
if (q != o->omap.end())
out->insert(*q);
}
int MemStore::omap_check_keys(
CollectionHandle& ch, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to check
- set<string> *out ///< [out] Subset of keys defined on oid
+ const std::set<std::string> &keys, ///< [in] Keys to check
+ std::set<std::string> *out ///< [out] Subset of keys defined on oid
)
{
dout(10) << __func__ << " " << ch->cid << " " << oid << dendl;
if (!o)
return -ENOENT;
std::lock_guard lock{o->omap_mutex};
- for (set<string>::const_iterator p = keys.begin();
- p != keys.end();
- ++p) {
- map<string,bufferlist>::iterator q = o->omap.find(*p);
+ for (auto p = keys.begin(); p != keys.end(); ++p) {
+ auto q = o->omap.find(*p);
if (q != o->omap.end())
out->insert(*p);
}
class MemStore::OmapIteratorImpl : public ObjectMap::ObjectMapIteratorImpl {
CollectionRef c;
ObjectRef o;
- map<string,bufferlist>::iterator it;
+ std::map<std::string,ceph::buffer::list>::iterator it;
public:
OmapIteratorImpl(CollectionRef c, ObjectRef o)
: c(c), o(o), it(o->omap.begin()) {}
it = o->omap.begin();
return 0;
}
- int upper_bound(const string &after) override {
+ int upper_bound(const std::string &after) override {
std::lock_guard lock{o->omap_mutex};
it = o->omap.upper_bound(after);
return 0;
}
- int lower_bound(const string &to) override {
+ int lower_bound(const std::string &to) override {
std::lock_guard lock{o->omap_mutex};
it = o->omap.lower_bound(to);
return 0;
++it;
return 0;
}
- string key() override {
+ std::string key() override {
std::lock_guard lock{o->omap_mutex};
return it->first;
}
- bufferlist value() override {
+ ceph::buffer::list value() override {
std::lock_guard lock{o->omap_mutex};
return it->second;
}
int MemStore::queue_transactions(
CollectionHandle& ch,
- vector<Transaction>& tls,
+ std::vector<Transaction>& tls,
TrackedOpRef op,
ThreadPool::TPHandle *handle)
{
Collection *c = static_cast<Collection*>(ch.get());
std::unique_lock lock{c->sequencer_mutex};
- for (vector<Transaction>::iterator p = tls.begin(); p != tls.end(); ++p) {
+ for (auto p = tls.begin(); p != tls.end(); ++p) {
// poke the TPHandle heartbeat just to exercise that code path
if (handle)
handle->reset_tp_timeout();
uint64_t off = op->off;
uint64_t len = op->len;
uint32_t fadvise_flags = i.get_fadvise_flags();
- bufferlist bl;
+ ceph::buffer::list bl;
i.decode_bl(bl);
r = _write(cid, oid, off, len, bl, fadvise_flags);
}
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- string name = i.decode_string();
- bufferlist bl;
+ std::string name = i.decode_string();
+ ceph::buffer::list bl;
i.decode_bl(bl);
- map<string, bufferptr> to_set;
- to_set[name] = bufferptr(bl.c_str(), bl.length());
+ std::map<std::string, ceph::buffer::ptr> to_set;
+ to_set[name] = ceph::buffer::ptr(bl.c_str(), bl.length());
r = _setattrs(cid, oid, to_set);
}
break;
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- map<string, bufferptr> aset;
+ std::map<std::string, ceph::buffer::ptr> aset;
i.decode_attrset(aset);
r = _setattrs(cid, oid, aset);
}
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- string name = i.decode_string();
+ std::string name = i.decode_string();
r = _rmattr(cid, oid, name.c_str());
}
break;
{
coll_t cid = i.get_cid(op->cid);
uint32_t type = op->hint_type;
- bufferlist hint;
+ ceph::buffer::list hint;
i.decode_bl(hint);
auto hiter = hint.cbegin();
if (type == Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS) {
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- bufferlist aset_bl;
+ ceph::buffer::list aset_bl;
i.decode_attrset_bl(&aset_bl);
r = _omap_setkeys(cid, oid, aset_bl);
}
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- bufferlist keys_bl;
+ ceph::buffer::list keys_bl;
i.decode_keyset_bl(&keys_bl);
r = _omap_rmkeys(cid, oid, keys_bl);
}
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- string first, last;
+ std::string first, last;
first = i.decode_string();
last = i.decode_string();
r = _omap_rmkeyrange(cid, oid, first, last);
{
coll_t cid = i.get_cid(op->cid);
ghobject_t oid = i.get_oid(op->oid);
- bufferlist bl;
+ ceph::buffer::list bl;
i.decode_bl(bl);
r = _omap_setheader(cid, oid, bl);
}
<< " (op " << pos << ", counting from 0)" << dendl;
dout(0) << msg << dendl;
dout(0) << " transaction dump:\n";
- JSONFormatter f(true);
+ ceph::JSONFormatter f(true);
f.open_object_section("transaction");
t.dump(&f);
f.close_section();
}
int MemStore::_write(const coll_t& cid, const ghobject_t& oid,
- uint64_t offset, size_t len, const bufferlist& bl,
+ uint64_t offset, size_t len, const ceph::buffer::list& bl,
uint32_t fadvise_flags)
{
dout(10) << __func__ << " " << cid << " " << oid << " "
{
dout(10) << __func__ << " " << cid << " " << oid << " " << offset << "~"
<< len << dendl;
- bufferlist bl;
+ ceph::buffer::list bl;
bl.append_zero(len);
return _write(cid, oid, offset, len, bl);
}
}
int MemStore::_setattrs(const coll_t& cid, const ghobject_t& oid,
- map<string,bufferptr>& aset)
+ std::map<std::string,ceph::buffer::ptr>& aset)
{
dout(10) << __func__ << " " << cid << " " << oid << dendl;
CollectionRef c = get_collection(cid);
if (!o)
return -ENOENT;
std::lock_guard lock{o->xattr_mutex};
- for (map<string,bufferptr>::const_iterator p = aset.begin(); p != aset.end(); ++p)
+ for (auto p = aset.begin(); p != aset.end(); ++p)
o->xattr[p->first] = p->second;
return 0;
}
}
int MemStore::_omap_setkeys(const coll_t& cid, const ghobject_t &oid,
- bufferlist& aset_bl)
+ ceph::buffer::list& aset_bl)
{
dout(10) << __func__ << " " << cid << " " << oid << dendl;
CollectionRef c = get_collection(cid);
__u32 num;
decode(num, p);
while (num--) {
- string key;
+ std::string key;
decode(key, p);
decode(o->omap[key], p);
}
}
int MemStore::_omap_rmkeys(const coll_t& cid, const ghobject_t &oid,
- bufferlist& keys_bl)
+ ceph::buffer::list& keys_bl)
{
dout(10) << __func__ << " " << cid << " " << oid << dendl;
CollectionRef c = get_collection(cid);
__u32 num;
decode(num, p);
while (num--) {
- string key;
+ std::string key;
decode(key, p);
o->omap.erase(key);
}
}
int MemStore::_omap_rmkeyrange(const coll_t& cid, const ghobject_t &oid,
- const string& first, const string& last)
+ const std::string& first, const std::string& last)
{
dout(10) << __func__ << " " << cid << " " << oid << " " << first
<< " " << last << dendl;
if (!o)
return -ENOENT;
std::lock_guard lock{o->omap_mutex};
- map<string,bufferlist>::iterator p = o->omap.lower_bound(first);
- map<string,bufferlist>::iterator e = o->omap.lower_bound(last);
+ auto p = o->omap.lower_bound(first);
+ auto e = o->omap.lower_bound(last);
o->omap.erase(p, e);
return 0;
}
int MemStore::_omap_setheader(const coll_t& cid, const ghobject_t &oid,
- const bufferlist &bl)
+ const ceph::buffer::list &bl)
{
dout(10) << __func__ << " " << cid << " " << oid << dendl;
CollectionRef c = get_collection(cid);
std::scoped_lock l{std::min(&(*sc), &(*dc))->lock,
std::max(&(*sc), &(*dc))->lock};
- map<ghobject_t,ObjectRef>::iterator p = sc->object_map.begin();
+ auto p = sc->object_map.begin();
while (p != sc->object_map.end()) {
if (p->first.match(bits, match)) {
dout(20) << " moving " << p->first << dendl;
- dc->object_map.insert(make_pair(p->first, p->second));
- dc->object_hash.insert(make_pair(p->first, p->second));
+ dc->object_map.insert(std::make_pair(p->first, p->second));
+ dc->object_hash.insert(std::make_pair(p->first, p->second));
sc->object_hash.erase(p->first);
sc->object_map.erase(p++);
} else {
std::scoped_lock l{std::min(&(*sc), &(*dc))->lock,
std::max(&(*sc), &(*dc))->lock};
- map<ghobject_t,ObjectRef>::iterator p = sc->object_map.begin();
+ auto p = sc->object_map.begin();
while (p != sc->object_map.end()) {
dout(20) << " moving " << p->first << dendl;
- dc->object_map.insert(make_pair(p->first, p->second));
- dc->object_hash.insert(make_pair(p->first, p->second));
+ dc->object_map.insert(std::make_pair(p->first, p->second));
+ dc->object_hash.insert(std::make_pair(p->first, p->second));
sc->object_hash.erase(p->first);
sc->object_map.erase(p++);
}
namespace {
struct BufferlistObject : public MemStore::Object {
ceph::spinlock mutex;
- bufferlist data;
+ ceph::buffer::list data;
size_t get_size() const override { return data.length(); }
- int read(uint64_t offset, uint64_t len, bufferlist &bl) override;
- int write(uint64_t offset, const bufferlist &bl) override;
+ int read(uint64_t offset, uint64_t len, ceph::buffer::list &bl) override;
+ int write(uint64_t offset, const ceph::buffer::list &bl) override;
int clone(Object *src, uint64_t srcoff, uint64_t len,
uint64_t dstoff) override;
int truncate(uint64_t offset) override;
- void encode(bufferlist& bl) const override {
+ void encode(ceph::buffer::list& bl) const override {
ENCODE_START(1, 1, bl);
encode(data, bl);
encode_base(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& p) override {
+ void decode(ceph::buffer::list::const_iterator& p) override {
DECODE_START(1, p);
decode(data, p);
decode_base(p);
}
// BufferlistObject
int BufferlistObject::read(uint64_t offset, uint64_t len,
- bufferlist &bl)
+ ceph::buffer::list &bl)
{
std::lock_guard<decltype(mutex)> lock(mutex);
bl.substr_of(data, offset, len);
return bl.length();
}
-int BufferlistObject::write(uint64_t offset, const bufferlist &src)
+int BufferlistObject::write(uint64_t offset, const ceph::buffer::list &src)
{
unsigned len = src.length();
std::lock_guard<decltype(mutex)> lock(mutex);
// before
- bufferlist newdata;
+ ceph::buffer::list newdata;
if (get_size() >= offset) {
newdata.substr_of(data, 0, offset);
} else {
// after
if (get_size() > offset + len) {
- bufferlist tail;
+ ceph::buffer::list tail;
tail.substr_of(data, offset + len, get_size() - (offset + len));
newdata.append(tail);
}
if (srcbl == nullptr)
return -ENOTSUP;
- bufferlist bl;
+ ceph::buffer::list bl;
{
std::lock_guard<decltype(srcbl->mutex)> lock(srcbl->mutex);
if (srcoff == dstoff && len == src->get_size()) {
{
std::lock_guard<decltype(mutex)> lock(mutex);
if (get_size() > size) {
- bufferlist bl;
+ ceph::buffer::list bl;
bl.substr_of(data, 0, size);
data.claim(bl);
} else if (get_size() == size) {
size_t get_size() const override { return data_len; }
- int read(uint64_t offset, uint64_t len, bufferlist &bl) override;
- int write(uint64_t offset, const bufferlist &bl) override;
+ int read(uint64_t offset, uint64_t len, ceph::buffer::list &bl) override;
+ int write(uint64_t offset, const ceph::buffer::list &bl) override;
int clone(Object *src, uint64_t srcoff, uint64_t len,
uint64_t dstoff) override;
int truncate(uint64_t offset) override;
- void encode(bufferlist& bl) const override {
+ void encode(ceph::buffer::list& bl) const override {
ENCODE_START(1, 1, bl);
encode(data_len, bl);
data.encode(bl);
encode_base(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& p) override {
+ void decode(ceph::buffer::list::const_iterator& p) override {
DECODE_START(1, p);
decode(data_len, p);
data.decode(p);
#define DEFINE_PAGE_VECTOR(name) PageSet::page_vector name;
#endif
-int MemStore::PageSetObject::read(uint64_t offset, uint64_t len, bufferlist& bl)
+int MemStore::PageSetObject::read(uint64_t offset, uint64_t len, ceph::buffer::list& bl)
{
const auto start = offset;
const auto end = offset + len;
data.get_range(offset, len, tls_pages);
// allocate a buffer for the data
- buffer::ptr buf(len);
+ ceph::buffer::ptr buf(len);
auto p = tls_pages.begin();
while (remaining) {
// read from page
const auto page_offset = offset - page->offset;
- const auto count = min(remaining, data.get_page_size() - page_offset);
+ const auto count = std::min(remaining, data.get_page_size() - page_offset);
buf.copy_in(offset - start, count, page->data + page_offset);
return len;
}
-int MemStore::PageSetObject::write(uint64_t offset, const bufferlist &src)
+int MemStore::PageSetObject::write(uint64_t offset, const ceph::buffer::list &src)
{
unsigned len = src.length();
while (len > 0) {
unsigned page_offset = offset - (*page)->offset;
unsigned pageoff = data.get_page_size() - page_offset;
- unsigned count = min(len, pageoff);
+ unsigned count = std::min(len, pageoff);
p.copy(count, (*page)->data + page_offset);
offset += count;
len -= count;
struct Object : public RefCountedObject {
ceph::mutex xattr_mutex{ceph::make_mutex("MemStore::Object::xattr_mutex")};
ceph::mutex omap_mutex{ceph::make_mutex("MemStore::Object::omap_mutex")};
- map<string,bufferptr> xattr;
- bufferlist omap_header;
- map<string,bufferlist> omap;
+ std::map<std::string,ceph::buffer::ptr> xattr;
+ ceph::buffer::list omap_header;
+ std::map<std::string,ceph::buffer::list> omap;
using Ref = ceph::ref_t<Object>;
// interface for object data
virtual size_t get_size() const = 0;
- virtual int read(uint64_t offset, uint64_t len, bufferlist &bl) = 0;
- virtual int write(uint64_t offset, const bufferlist &bl) = 0;
+ virtual int read(uint64_t offset, uint64_t len, ceph::buffer::list &bl) = 0;
+ virtual int write(uint64_t offset, const ceph::buffer::list &bl) = 0;
virtual int clone(Object *src, uint64_t srcoff, uint64_t len,
uint64_t dstoff) = 0;
virtual int truncate(uint64_t offset) = 0;
- virtual void encode(bufferlist& bl) const = 0;
- virtual void decode(bufferlist::const_iterator& p) = 0;
+ virtual void encode(ceph::buffer::list& bl) const = 0;
+ virtual void decode(ceph::buffer::list::const_iterator& p) = 0;
- void encode_base(bufferlist& bl) const {
+ void encode_base(ceph::buffer::list& bl) const {
using ceph::encode;
encode(xattr, bl);
encode(omap_header, bl);
encode(omap, bl);
}
- void decode_base(bufferlist::const_iterator& p) {
+ void decode_base(ceph::buffer::list::const_iterator& p) {
using ceph::decode;
decode(xattr, p);
decode(omap_header, p);
decode(omap, p);
}
- void dump(Formatter *f) const {
+ void dump(ceph::Formatter *f) const {
f->dump_int("data_len", get_size());
f->dump_int("omap_header_len", omap_header.length());
f->open_array_section("xattrs");
- for (map<string,bufferptr>::const_iterator p = xattr.begin();
- p != xattr.end();
- ++p) {
+ for (auto p = xattr.begin(); p != xattr.end(); ++p) {
f->open_object_section("xattr");
f->dump_string("name", p->first);
f->dump_int("length", p->second.length());
f->close_section();
f->open_array_section("omap");
- for (map<string,bufferlist>::const_iterator p = omap.begin();
- p != omap.end();
- ++p) {
+ for (auto p = omap.begin(); p != omap.end(); ++p) {
f->open_object_section("pair");
f->dump_string("key", p->first);
f->dump_int("length", p->second.length());
CephContext *cct;
bool use_page_set;
ceph::unordered_map<ghobject_t, ObjectRef> object_hash; ///< for lookup
- map<ghobject_t, ObjectRef> object_map; ///< for iteration
- map<string,bufferptr> xattr;
+ std::map<ghobject_t, ObjectRef> object_map; ///< for iteration
+ std::map<std::string,ceph::buffer::ptr> xattr;
/// for object_{map,hash}
ceph::shared_mutex lock{
ceph::make_shared_mutex("MemStore::Collection::lock", true, false)};
return result.first->second;
}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
ENCODE_START(1, 1, bl);
encode(xattr, bl);
encode(use_page_set, bl);
uint32_t s = object_map.size();
encode(s, bl);
- for (map<ghobject_t, ObjectRef>::const_iterator p = object_map.begin();
- p != object_map.end();
- ++p) {
+ for (auto p = object_map.begin(); p != object_map.end(); ++p) {
encode(p->first, bl);
p->second->encode(bl);
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
DECODE_START(1, p);
decode(xattr, p);
decode(use_page_set, p);
decode(k, p);
auto o = create_object();
o->decode(p);
- object_map.insert(make_pair(k, o));
- object_hash.insert(make_pair(k, o));
+ object_map.insert(std::make_pair(k, o));
+ object_hash.insert(std::make_pair(k, o));
}
DECODE_FINISH(p);
}
uint64_t used_bytes() const {
uint64_t result = 0;
- for (map<ghobject_t, ObjectRef>::const_iterator p = object_map.begin();
- p != object_map.end();
- ++p) {
+ for (auto p = object_map.begin(); p != object_map.end(); ++p) {
result += p->second->get_size();
}
/// rwlock to protect coll_map
ceph::shared_mutex coll_lock{
ceph::make_shared_mutex("MemStore::coll_lock")};
- map<coll_t,CollectionRef> new_coll_map;
+ std::map<coll_t,CollectionRef> new_coll_map;
CollectionRef get_collection(const coll_t& cid);
int _touch(const coll_t& cid, const ghobject_t& oid);
int _write(const coll_t& cid, const ghobject_t& oid, uint64_t offset, size_t len,
- const bufferlist& bl, uint32_t fadvise_flags = 0);
+ const ceph::buffer::list& bl, uint32_t fadvise_flags = 0);
int _zero(const coll_t& cid, const ghobject_t& oid, uint64_t offset, size_t len);
int _truncate(const coll_t& cid, const ghobject_t& oid, uint64_t size);
int _remove(const coll_t& cid, const ghobject_t& oid);
- int _setattrs(const coll_t& cid, const ghobject_t& oid, map<string,bufferptr>& aset);
+ int _setattrs(const coll_t& cid, const ghobject_t& oid, std::map<std::string,ceph::buffer::ptr>& aset);
int _rmattr(const coll_t& cid, const ghobject_t& oid, const char *name);
int _rmattrs(const coll_t& cid, const ghobject_t& oid);
int _clone(const coll_t& cid, const ghobject_t& oldoid, const ghobject_t& newoid);
const ghobject_t& newoid,
uint64_t srcoff, uint64_t len, uint64_t dstoff);
int _omap_clear(const coll_t& cid, const ghobject_t &oid);
- int _omap_setkeys(const coll_t& cid, const ghobject_t &oid, bufferlist& aset_bl);
- int _omap_rmkeys(const coll_t& cid, const ghobject_t &oid, bufferlist& keys_bl);
+ int _omap_setkeys(const coll_t& cid, const ghobject_t &oid, ceph::buffer::list& aset_bl);
+ int _omap_rmkeys(const coll_t& cid, const ghobject_t &oid, ceph::buffer::list& keys_bl);
int _omap_rmkeyrange(const coll_t& cid, const ghobject_t &oid,
- const string& first, const string& last);
- int _omap_setheader(const coll_t& cid, const ghobject_t &oid, const bufferlist &bl);
+ const std::string& first, const std::string& last);
+ int _omap_setheader(const coll_t& cid, const ghobject_t &oid, const ceph::buffer::list &bl);
int _collection_hint_expected_num_objs(const coll_t& cid, uint32_t pg_num,
uint64_t num_objs) const { return 0; }
int _save();
int _load();
- void dump(Formatter *f);
+ void dump(ceph::Formatter *f);
void dump_all();
public:
- MemStore(CephContext *cct, const string& path)
+ MemStore(CephContext *cct, const std::string& path)
: ObjectStore(cct, path),
finisher(cct),
used_bytes(0) {}
~MemStore() override { }
- string get_type() override {
+ std::string get_type() override {
return "memstore";
}
return false;
}
- int get_devices(set<string> *ls) override {
+ int get_devices(std::set<std::string> *ls) override {
// no devices for us!
return 0;
}
const ghobject_t& oid,
uint64_t offset,
size_t len,
- bufferlist& bl,
+ ceph::buffer::list& bl,
uint32_t op_flags = 0) override;
using ObjectStore::fiemap;
int fiemap(CollectionHandle& c, const ghobject_t& oid,
- uint64_t offset, size_t len, bufferlist& bl) override;
+ uint64_t offset, size_t len, ceph::buffer::list& bl) override;
int fiemap(CollectionHandle& c, const ghobject_t& oid, uint64_t offset,
- size_t len, map<uint64_t, uint64_t>& destmap) override;
+ size_t len, std::map<uint64_t, uint64_t>& destmap) override;
int getattr(CollectionHandle &c, const ghobject_t& oid, const char *name,
- bufferptr& value) override;
+ ceph::buffer::ptr& value) override;
int getattrs(CollectionHandle &c, const ghobject_t& oid,
- map<string,bufferptr>& aset) override;
+ std::map<std::string,ceph::buffer::ptr>& aset) override;
- int list_collections(vector<coll_t>& ls) override;
+ int list_collections(std::vector<coll_t>& ls) override;
CollectionHandle open_collection(const coll_t& c) override {
return get_collection(c);
int collection_bits(CollectionHandle& c) override;
int collection_list(CollectionHandle& cid,
const ghobject_t& start, const ghobject_t& end, int max,
- vector<ghobject_t> *ls, ghobject_t *next) override;
+ std::vector<ghobject_t> *ls, ghobject_t *next) override;
using ObjectStore::omap_get;
int omap_get(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
- map<string, bufferlist> *out /// < [out] Key to value map
+ ceph::buffer::list *header, ///< [out] omap header
+ std::map<std::string, ceph::buffer::list> *out /// < [out] Key to value map
) override;
using ObjectStore::omap_get_header;
int omap_get_header(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- bufferlist *header, ///< [out] omap header
+ ceph::buffer::list *header, ///< [out] omap header
bool allow_eio = false ///< [in] don't assert on eio
) override;
int omap_get_keys(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- set<string> *keys ///< [out] Keys defined on oid
+ std::set<std::string> *keys ///< [out] Keys defined on oid
) override;
using ObjectStore::omap_get_values;
int omap_get_values(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to get
- map<string, bufferlist> *out ///< [out] Returned keys and values
+ const std::set<std::string> &keys, ///< [in] Keys to get
+ std::map<std::string, ceph::buffer::list> *out ///< [out] Returned keys and values
) override;
using ObjectStore::omap_check_keys;
int omap_check_keys(
CollectionHandle& c, ///< [in] Collection containing oid
const ghobject_t &oid, ///< [in] Object containing omap
- const set<string> &keys, ///< [in] Keys to check
- set<string> *out ///< [out] Subset of keys defined on oid
+ const std::set<std::string> &keys, ///< [in] Keys to check
+ std::set<std::string> *out ///< [out] Subset of keys defined on oid
) override;
using ObjectStore::get_omap_iterator;
int queue_transactions(
CollectionHandle& ch,
- vector<Transaction>& tls,
+ std::vector<Transaction>& tls,
TrackedOpRef op = TrackedOpRef(),
ThreadPool::TPHandle *handle = NULL) override;
};
return lhs.offset < rhs.offset;
}
};
- void encode(bufferlist &bl, size_t page_size) const {
+ void encode(ceph::buffer::list &bl, size_t page_size) const {
using ceph::encode;
- bl.append(buffer::copy(data, page_size));
+ bl.append(ceph::buffer::copy(data, page_size));
encode(offset, bl);
}
- void decode(bufferlist::const_iterator &p, size_t page_size) {
+ void decode(ceph::buffer::list::const_iterator &p, size_t page_size) {
using ceph::decode;
p.copy(page_size, data);
decode(offset, p);
free_pages(cur, pages.end());
}
- void encode(bufferlist &bl) const {
+ void encode(ceph::buffer::list &bl) const {
using ceph::encode;
encode(page_size, bl);
unsigned count = pages.size();
for (auto p = pages.rbegin(); p != pages.rend(); ++p)
p->encode(bl, page_size);
}
- void decode(bufferlist::const_iterator &p) {
+ void decode(ceph::buffer::list::const_iterator &p) {
using ceph::decode;
ceph_assert(empty());
decode(page_size, p);
eversion_t at_version;
eversion_t trim_to;
eversion_t roll_forward_to;
- vector<pg_log_entry_t> log_entries;
+
std::vector<pg_log_entry_t> log_entries;
std::set<hobject_t> temp_added;
std::set<hobject_t> temp_removed;
std::optional<pg_hit_set_history_t> updated_hit_set_history;
eversion_t at_version,
eversion_t trim_to,
eversion_t roll_forward_to,
- vector<pg_log_entry_t> log_entries,
+
std::vector<pg_log_entry_t> log_entries,
std::optional<pg_hit_set_history_t> updated_hit_set_history,
const std::set<hobject_t> &temp_added,
const std::set<hobject_t> &temp_removed,
pg_shard_t from;
ceph_tid_t tid;
std::map<hobject_t, std::list<std::pair<uint64_t, ceph::buffer::list> >> buffers_read;
- std::map<hobject_t, std::map<string, ceph::buffer::list>> attrs_read;
+ std::map<hobject_t, std::map<std::string, ceph::buffer::list>> attrs_read;
std::map<hobject_t, int> errors;
void encode(ceph::buffer::list &bl) const;
void decode(ceph::buffer::list::const_iterator &bl);
#include "include/ipaddr.h"
using std::ostream;
+using std::string;
using std::vector;
ostream& operator<<(ostream& out, const osd_rwxa_t& p)
OSDCapMatch match;
OSDCapSpec spec;
OSDCapProfile profile;
- string network;
+ std::string network;
entity_addr_t network_parsed;
unsigned network_prefix = 0;
bool network_valid = true;
OSDCapGrant() {}
OSDCapGrant(const OSDCapMatch& m, const OSDCapSpec& s,
- boost::optional<string> n = {})
+ boost::optional<std::string> n = {})
: match(m), spec(s) {
if (n) {
set_network(*n);
}
}
explicit OSDCapGrant(const OSDCapProfile& profile,
- boost::optional<string> n = {})
+ boost::optional<std::string> n = {})
: profile(profile) {
if (n) {
set_network(*n);
expand_profile();
}
- void set_network(const string& n);
+ void set_network(const std::string& n);
bool allow_all() const;
- bool is_capable(const string& pool_name, const string& ns,
+ bool is_capable(const std::string& pool_name, const std::string& ns,
const OSDCapPoolTag::app_map_t& application_metadata,
- const string& object, bool op_may_read, bool op_may_write,
+ const std::string& object, bool op_may_read, bool op_may_write,
const std::vector<OpInfo::ClassInfo>& classes,
const entity_addr_t& addr,
std::vector<bool>* class_allowed) const;
* @param classes (class-name, rd, wr, whitelisted-flag) tuples
* @return true if the operation is allowed, false otherwise
*/
- bool is_capable(const string& pool_name, const string& ns,
+ bool is_capable(const std::string& pool_name, const std::string& ns,
const OSDCapPoolTag::app_map_t& application_metadata,
- const string& object, bool op_may_read, bool op_may_write,
+ const std::string& object, bool op_may_read, bool op_may_write,
const std::vector<OpInfo::ClassInfo>& classes,
const entity_addr_t& addr) const;
};
-static inline ostream& operator<<(ostream& out, const OSDCap& cap)
+inline std::ostream& operator<<(std::ostream& out, const OSDCap& cap)
{
return out << "osdcap" << cap.grants;
}
}
void ceph_heap_profiler_handle_command(const std::vector<std::string>& cmd,
- ostream& out) { return; }
+ std::ostream& out) { return; }
bool ceph_heap_set_numeric_property(const char *property, size_t value);
void ceph_heap_profiler_handle_command(const std::vector<std::string> &cmd,
- ostream& out);
+ std::ostream& out);
#endif /* HEAP_PROFILER_H_ */
projects / ceph.git / commitdiff