#include "include/int_types.h"
-#include <math.h>
#include <ostream>
#include <set>
#include <map>
#include "common/config.h"
#include "common/Clock.h"
#include "common/DecayCounter.h"
+#include "common/StackStringStream.h"
#include "common/entity_name.h"
+#include "include/compat.h"
#include "include/Context.h"
#include "include/frag.h"
#include "include/xlist.h"
#include "include/interval_set.h"
-#include "include/compact_map.h"
#include "include/compact_set.h"
#include "include/fs_types.h"
#include <boost/pool/pool.hpp>
#include "include/ceph_assert.h"
#include <boost/serialization/strong_typedef.hpp>
+#include "common/ceph_json.h"
#define CEPH_FS_ONDISK_MAGIC "ceph fs volume v011"
#define MDS_INO_STRAY_INDEX(i) (((unsigned (i)) - MDS_INO_STRAY_OFFSET) % NUM_STRAY)
typedef int32_t mds_rank_t;
-constexpr mds_rank_t MDS_RANK_NONE = -1;
+constexpr mds_rank_t MDS_RANK_NONE = -1;
+constexpr mds_rank_t MDS_RANK_EPHEMERAL_DIST = -2;
+constexpr mds_rank_t MDS_RANK_EPHEMERAL_RAND = -3;
BOOST_STRONG_TYPEDEF(uint64_t, mds_gid_t)
extern const mds_gid_t MDS_GID_NONE;
typedef int32_t fs_cluster_id_t;
constexpr fs_cluster_id_t FS_CLUSTER_ID_NONE = -1;
+
// The namespace ID of the anonymous default filesystem from legacy systems
constexpr fs_cluster_id_t FS_CLUSTER_ID_ANONYMOUS = 0;
}
// CAPS
-inline string gcap_string(int cap)
+inline std::string gcap_string(int cap)
{
- string s;
+ std::string s;
if (cap & CEPH_CAP_GSHARED) s += "s";
if (cap & CEPH_CAP_GEXCL) s += "x";
if (cap & CEPH_CAP_GCACHE) s += "c";
if (cap & CEPH_CAP_GLAZYIO) s += "l";
return s;
}
-inline string ccap_string(int cap)
+inline std::string ccap_string(int cap)
{
- string s;
+ std::string s;
if (cap & CEPH_CAP_PIN) s += "p";
int a = (cap >> CEPH_CAP_SAUTH) & 3;
nsubdirs == o.nsubdirs;
}
- void encode(bufferlist &bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list &bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void dump(ceph::Formatter *f) const;
+ void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<frag_info_t*>& ls);
// this frag
rsnaps == o.rsnaps;
}
- void encode(bufferlist &bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list &bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void dump(ceph::Formatter *f) const;
+ void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<nest_info_t*>& ls);
// this frag + children
vinodeno_t() {}
vinodeno_t(inodeno_t i, snapid_t s) : ino(i), snapid(s) {}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
encode(ino, bl);
encode(snapid, bl);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
using ceph::decode;
decode(ino, p);
decode(snapid, p);
struct quota_info_t
{
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
ENCODE_START(1, 1, bl);
encode(max_bytes, bl);
encode(max_files, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator& p) {
+ void decode(ceph::buffer::list::const_iterator& p) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, p);
decode(max_bytes, p);
decode(max_files, p);
DECODE_FINISH(p);
}
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<quota_info_t *>& ls);
bool is_valid() const {
bool is_enable() const {
return max_bytes || max_files;
}
+ void decode_json(JSONObj *obj);
int64_t max_bytes = 0;
int64_t max_files = 0;
return memcmp(&l, &r, sizeof(l)) == 0;
}
-ostream& operator<<(ostream &out, const quota_info_t &n);
+std::ostream& operator<<(std::ostream &out, const quota_info_t &n);
namespace std {
template<> struct hash<vinodeno_t> {
struct client_writeable_range_t {
struct byte_range_t {
uint64_t first = 0, last = 0; // interval client can write to
+ byte_range_t() {}
+ void decode_json(JSONObj *obj);
};
- void encode(bufferlist &bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ 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<client_writeable_range_t*>& ls);
byte_range_t range;
snapid_t follows = 0; // aka "data+metadata flushed thru"
};
-inline void decode(client_writeable_range_t::byte_range_t& range, bufferlist::const_iterator& bl) {
+inline void decode(client_writeable_range_t::byte_range_t& range, ceph::buffer::list::const_iterator& bl) {
+ using ceph::decode;
decode(range.first, bl);
decode(range.last, bl);
}
inline_data_t() {}
inline_data_t(const inline_data_t& o) : version(o.version) {
if (o.blp)
- get_data() = *o.blp;
+ set_data(*o.blp);
}
inline_data_t& operator=(const inline_data_t& o) {
version = o.version;
if (o.blp)
- get_data() = *o.blp;
+ set_data(*o.blp);
else
free_data();
return *this;
void free_data() {
blp.reset();
}
- bufferlist& get_data() {
+ void get_data(ceph::buffer::list& ret) const {
+ if (blp)
+ ret = *blp;
+ else
+ ret.clear();
+ }
+ void set_data(const ceph::buffer::list& bl) {
if (!blp)
- blp.reset(new bufferlist);
- return *blp;
+ blp.reset(new ceph::buffer::list);
+ *blp = bl;
}
size_t length() const { return blp ? blp->length() : 0; }
bool operator==(const inline_data_t& o) const {
return length() == o.length() &&
(length() == 0 ||
- (*const_cast<bufferlist*>(blp.get()) == *const_cast<bufferlist*>(o.blp.get())));
+ (*const_cast<ceph::buffer::list*>(blp.get()) == *const_cast<ceph::buffer::list*>(o.blp.get())));
}
bool operator!=(const inline_data_t& o) const {
return !(*this == o);
}
- void encode(bufferlist &bl) const;
- void decode(bufferlist::const_iterator& bl);
+ void encode(ceph::buffer::list &bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
version_t version = 1;
private:
- std::unique_ptr<bufferlist> blp;
+ std::unique_ptr<ceph::buffer::list> blp;
};
WRITE_CLASS_ENCODER(inline_data_t)
old_pools.insert(l);
}
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list &bl, uint64_t features) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void dump(ceph::Formatter *f) const;
+ static void client_ranges_cb(client_range_map& c, JSONObj *obj);
+ static void old_pools_cb(compact_set<int64_t, std::less<int64_t>, Allocator<int64_t> >& c, JSONObj *obj);
+ void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<inode_t*>& ls);
/**
* Compare this inode_t with another that represent *the same inode*
std::basic_string<char,std::char_traits<char>,Allocator<char>> stray_prior_path; //stores path before unlink
+ bool fscrypt = false; // fscrypt enabled ?
+
private:
bool older_is_consistent(const inode_t &other) const;
};
// These methods may be moved back to mdstypes.cc when we have pmr
template<template<typename> class Allocator>
-void inode_t<Allocator>::encode(bufferlist &bl, uint64_t features) const
+void inode_t<Allocator>::encode(ceph::buffer::list &bl, uint64_t features) const
{
- ENCODE_START(16, 6, bl);
+ ENCODE_START(17, 6, bl);
encode(ino, bl);
encode(rdev, bl);
encode(export_ephemeral_random_pin, bl);
encode(export_ephemeral_distributed_pin, bl);
+ encode(fscrypt, bl);
+
ENCODE_FINISH(bl);
}
template<template<typename> class Allocator>
-void inode_t<Allocator>::decode(bufferlist::const_iterator &p)
+void inode_t<Allocator>::decode(ceph::buffer::list::const_iterator &p)
{
- DECODE_START_LEGACY_COMPAT_LEN(16, 6, 6, p);
+ DECODE_START_LEGACY_COMPAT_LEN(17, 6, 6, p);
decode(ino, p);
decode(rdev, p);
if (struct_v >= 3) {
decode(client_ranges, p);
} else {
- map<client_t, client_writeable_range_t::byte_range_t> m;
+ std::map<client_t, client_writeable_range_t::byte_range_t> m;
decode(m, p);
- for (map<client_t, client_writeable_range_t::byte_range_t>::iterator
- q = m.begin(); q != m.end(); ++q)
+ for (auto q = m.begin(); q != m.end(); ++q)
client_ranges[q->first].range = q->second;
}
export_ephemeral_distributed_pin = false;
}
+ if (struct_v >= 17) {
+ decode(fscrypt, p);
+ } else {
+ fscrypt = 0;
+ }
+
DECODE_FINISH(p);
}
template<template<typename> class Allocator>
-void inode_t<Allocator>::dump(Formatter *f) const
+void inode_t<Allocator>::dump(ceph::Formatter *f) const
{
f->dump_unsigned("ino", ino);
f->dump_unsigned("rdev", rdev);
f->dump_unsigned("last_scrub_version", last_scrub_version);
}
+template<template<typename> class Allocator>
+void inode_t<Allocator>::client_ranges_cb(typename inode_t<Allocator>::client_range_map& c, JSONObj *obj){
+
+ int64_t client;
+ JSONDecoder::decode_json("client", client, obj, true);
+ client_writeable_range_t client_range_tmp;
+ JSONDecoder::decode_json("byte range", client_range_tmp.range, obj, true);
+ JSONDecoder::decode_json("follows", client_range_tmp.follows.val, obj, true);
+ c[client] = client_range_tmp;
+}
+
+template<template<typename> class Allocator>
+void inode_t<Allocator>::old_pools_cb(compact_set<int64_t, std::less<int64_t>, Allocator<int64_t> >& c, JSONObj *obj){
+
+ int64_t tmp;
+ decode_json_obj(tmp, obj);
+ c.insert(tmp);
+}
+
+template<template<typename> class Allocator>
+void inode_t<Allocator>::decode_json(JSONObj *obj)
+{
+
+ JSONDecoder::decode_json("ino", ino.val, obj, true);
+ JSONDecoder::decode_json("rdev", rdev, obj, true);
+ //JSONDecoder::decode_json("ctime", ctime, obj, true);
+ //JSONDecoder::decode_json("btime", btime, obj, true);
+ JSONDecoder::decode_json("mode", mode, obj, true);
+ JSONDecoder::decode_json("uid", uid, obj, true);
+ JSONDecoder::decode_json("gid", gid, obj, true);
+ JSONDecoder::decode_json("nlink", nlink, obj, true);
+ JSONDecoder::decode_json("dir_layout", dir_layout, obj, true);
+ JSONDecoder::decode_json("layout", layout, obj, true);
+ JSONDecoder::decode_json("old_pools", old_pools, inode_t<Allocator>::old_pools_cb, obj, true);
+ JSONDecoder::decode_json("size", size, obj, true);
+ JSONDecoder::decode_json("truncate_seq", truncate_seq, obj, true);
+ JSONDecoder::decode_json("truncate_size", truncate_size, obj, true);
+ JSONDecoder::decode_json("truncate_from", truncate_from, obj, true);
+ JSONDecoder::decode_json("truncate_pending", truncate_pending, obj, true);
+ //JSONDecoder::decode_json("mtime", mtime, obj, true);
+ //JSONDecoder::decode_json("atime", atime, obj, true);
+ JSONDecoder::decode_json("time_warp_seq", time_warp_seq, obj, true);
+ JSONDecoder::decode_json("change_attr", change_attr, obj, true);
+ JSONDecoder::decode_json("export_pin", export_pin, obj, true);
+ JSONDecoder::decode_json("client_ranges", client_ranges, inode_t<Allocator>::client_ranges_cb, obj, true);
+ JSONDecoder::decode_json("dirstat", dirstat, obj, true);
+ JSONDecoder::decode_json("rstat", rstat, obj, true);
+ JSONDecoder::decode_json("accounted_rstat", accounted_rstat, obj, true);
+ JSONDecoder::decode_json("version", version, obj, true);
+ JSONDecoder::decode_json("file_data_version", file_data_version, obj, true);
+ JSONDecoder::decode_json("xattr_version", xattr_version, obj, true);
+ JSONDecoder::decode_json("backtrace_version", backtrace_version, obj, true);
+ JSONDecoder::decode_json("stray_prior_path", stray_prior_path, obj, true);
+ JSONDecoder::decode_json("max_size_ever", max_size_ever, obj, true);
+ JSONDecoder::decode_json("quota", quota, obj, true);
+ JSONDecoder::decode_json("last_scrub_stamp", last_scrub_stamp, obj, true);
+ JSONDecoder::decode_json("last_scrub_version", last_scrub_version, obj, true);
+}
+
template<template<typename> class Allocator>
void inode_t<Allocator>::generate_test_instances(std::list<inode_t*>& ls)
{
}
template<template<typename> class Allocator>
-inline void encode(const inode_t<Allocator> &c, ::ceph::bufferlist &bl, uint64_t features)
+inline void encode(const inode_t<Allocator> &c, ::ceph::buffer::list &bl, uint64_t features)
{
ENCODE_DUMP_PRE();
c.encode(bl, features);
ENCODE_DUMP_POST(cl);
}
template<template<typename> class Allocator>
-inline void decode(inode_t<Allocator> &c, ::ceph::bufferlist::const_iterator &p)
+inline void decode(inode_t<Allocator> &c, ::ceph::buffer::list::const_iterator &p)
{
c.decode(p);
}
using alloc_string = std::basic_string<char,std::char_traits<char>,Allocator<char>>;
template<template<typename> class Allocator>
-using xattr_map = compact_map<alloc_string<Allocator>, bufferptr, std::less<alloc_string<Allocator>>, Allocator<std::pair<const alloc_string<Allocator>, bufferptr>>>; // FIXME bufferptr not in mempool
+using xattr_map = std::map<alloc_string<Allocator>,
+ ceph::bufferptr,
+ std::less<alloc_string<Allocator>>,
+ Allocator<std::pair<const alloc_string<Allocator>,
+ ceph::bufferptr>>>; // FIXME bufferptr not in mempool
template<template<typename> class Allocator>
inline void decode_noshare(xattr_map<Allocator>& xattrs, ceph::buffer::list::const_iterator &p)
inode_t<Allocator> inode;
xattr_map<Allocator> xattrs;
- void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list &bl, uint64_t features) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<old_inode_t*>& ls);
};
// These methods may be moved back to mdstypes.cc when we have pmr
template<template<typename> class Allocator>
-void old_inode_t<Allocator>::encode(bufferlist& bl, uint64_t features) const
+void old_inode_t<Allocator>::encode(ceph::buffer::list& bl, uint64_t features) const
{
ENCODE_START(2, 2, bl);
encode(first, bl);
}
template<template<typename> class Allocator>
-void old_inode_t<Allocator>::decode(bufferlist::const_iterator& bl)
+void old_inode_t<Allocator>::decode(ceph::buffer::list::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(first, bl);
}
template<template<typename> class Allocator>
-void old_inode_t<Allocator>::dump(Formatter *f) const
+void old_inode_t<Allocator>::dump(ceph::Formatter *f) const
{
f->dump_unsigned("first", first);
inode.dump(f);
std::list<inode_t<Allocator>*> ils;
inode_t<Allocator>::generate_test_instances(ils);
ls.back()->inode = *ils.back();
- ls.back()->xattrs["user.foo"] = buffer::copy("asdf", 4);
- ls.back()->xattrs["user.unprintable"] = buffer::copy("\000\001\002", 3);
+ ls.back()->xattrs["user.foo"] = ceph::buffer::copy("asdf", 4);
+ ls.back()->xattrs["user.unprintable"] = ceph::buffer::copy("\000\001\002", 3);
}
template<template<typename> class Allocator>
-inline void encode(const old_inode_t<Allocator> &c, ::ceph::bufferlist &bl, uint64_t features)
+inline void encode(const old_inode_t<Allocator> &c, ::ceph::buffer::list &bl, uint64_t features)
{
ENCODE_DUMP_PRE();
c.encode(bl, features);
ENCODE_DUMP_POST(cl);
}
template<template<typename> class Allocator>
-inline void decode(old_inode_t<Allocator> &c, ::ceph::bufferlist::const_iterator &p)
+inline void decode(old_inode_t<Allocator> &c, ::ceph::buffer::list::const_iterator &p)
{
c.decode(p);
}
* like an inode, but for a dir frag
*/
struct fnode_t {
- void encode(bufferlist &bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list &bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void dump(ceph::Formatter *f) const;
+ void decode_json(JSONObj *obj);
static void generate_test_instances(std::list<fnode_t*>& ls);
version_t version = 0;
struct old_rstat_t {
- void encode(bufferlist& bl) const;
- void decode(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;
static void generate_test_instances(std::list<old_rstat_t*>& ls);
snapid_t first;
feature_bitset_t(const feature_bitset_t& other) : _vec(other._vec) {}
feature_bitset_t(feature_bitset_t&& other) : _vec(std::move(other._vec)) {}
feature_bitset_t(unsigned long value = 0);
- feature_bitset_t(const vector<size_t>& array);
+ feature_bitset_t(const std::vector<size_t>& array);
feature_bitset_t& operator=(const feature_bitset_t& other) {
_vec = other._vec;
return *this;
return false;
return _vec[bit / bits_per_block] & ((block_type)1 << (bit % bits_per_block));
}
+ void insert(size_t bit) {
+ size_t n = bit / bits_per_block;
+ if (n >= _vec.size())
+ _vec.resize(n + 1);
+ _vec[n] |= ((block_type)1 << (bit % bits_per_block));
+ }
+ void erase(size_t bit) {
+ size_t n = bit / bits_per_block;
+ if (n >= _vec.size())
+ return;
+ _vec[n] &= ~((block_type)1 << (bit % bits_per_block));
+ if (n + 1 == _vec.size()) {
+ while (!_vec.empty() && _vec.back() == 0)
+ _vec.pop_back();
+ }
+ }
void clear() {
_vec.clear();
}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator &p);
- void dump(Formatter *f) const;
- void print(ostream& out) const;
+ bool operator==(const feature_bitset_t& other) const {
+ return _vec == other._vec;
+ }
+ bool operator!=(const feature_bitset_t& other) const {
+ return _vec != other._vec;
+ }
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator &p);
+ void dump(ceph::Formatter *f) const;
+ void print(std::ostream& out) const;
private:
- vector<block_type> _vec;
+ std::vector<block_type> _vec;
};
WRITE_CLASS_ENCODER(feature_bitset_t)
metric_flags.clear();
}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
- void print(ostream& out) const;
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
+ void print(std::ostream& out) const;
// set of metrics that a client is capable of forwarding
feature_bitset_t metric_flags;
metric_spec.clear();
}
- void encode(bufferlist& bl) const;
- void decode(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;
kv_map_t kv_map;
feature_bitset_t features;
void clear_meta() {
prealloc_inos.clear();
- used_inos.clear();
completed_requests.clear();
completed_flushes.clear();
client_metadata.clear();
}
- void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::const_iterator& p);
- void dump(Formatter *f) const;
+ void encode(ceph::buffer::list& bl, uint64_t features) const;
+ void decode(ceph::buffer::list::const_iterator& p);
+ void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<session_info_t*>& ls);
entity_inst_t inst;
std::map<ceph_tid_t,inodeno_t> completed_requests;
interval_set<inodeno_t> prealloc_inos; // preallocated, ready to use.
- interval_set<inodeno_t> used_inos; // journaling use
client_metadata_t client_metadata;
std::set<ceph_tid_t> completed_flushes;
EntityName auth_name;
// encode into something that can be decoded as a string.
// name_ (head) or name_%x (!head)
- void encode(bufferlist& bl) const {
- string key;
+ void encode(ceph::buffer::list& bl) const {
+ std::string key;
encode(key);
using ceph::encode;
encode(key, bl);
}
- void encode(string& key) const {
+ void encode(std::string& key) const {
char b[20];
if (snapid != CEPH_NOSNAP) {
uint64_t val(snapid);
} else {
snprintf(b, sizeof(b), "%s", "head");
}
- ostringstream oss;
- oss << name << "_" << b;
- key = oss.str();
+ CachedStackStringStream css;
+ *css << name << "_" << b;
+ key = css->strv();
}
- static void decode_helper(bufferlist::const_iterator& bl, string& nm, snapid_t& sn) {
- string key;
+ static void decode_helper(ceph::buffer::list::const_iterator& bl, std::string& nm,
+ snapid_t& sn) {
+ std::string key;
+ using ceph::decode;
decode(key, bl);
decode_helper(key, nm, sn);
}
- static void decode_helper(std::string_view key, string& nm, snapid_t& sn) {
+ static void decode_helper(std::string_view key, std::string& nm, snapid_t& sn) {
size_t i = key.find_last_of('_');
- ceph_assert(i != string::npos);
+ ceph_assert(i != std::string::npos);
if (key.compare(i+1, std::string_view::npos, "head") == 0) {
// name_head
sn = CEPH_NOSNAP;
string_snap_t() {}
string_snap_t(std::string_view n, snapid_t s) : name(n), snapid(s) {}
- void encode(bufferlist& bl) const;
- void decode(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;
static void generate_test_instances(std::list<string_snap_t*>& ls);
- string name;
+ std::string name;
snapid_t snapid;
};
WRITE_CLASS_ENCODER(string_snap_t)
* pending mutation state in the table.
*/
struct mds_table_pending_t {
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ 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<mds_table_pending_t*>& ls);
uint64_t reqid = 0;
struct metareqid_t {
metareqid_t() {}
metareqid_t(entity_name_t n, ceph_tid_t t) : name(n), tid(t) {}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
encode(name, bl);
encode(tid, bl);
}
- void decode(bufferlist::const_iterator &p) {
+ void decode(ceph::buffer::list::const_iterator &p) {
using ceph::decode;
decode(name, p);
decode(tid, p);
struct cap_reconnect_t {
cap_reconnect_t() {}
cap_reconnect_t(uint64_t cap_id, inodeno_t pino, std::string_view p, int w, int i,
- inodeno_t sr, snapid_t sf, bufferlist& lb) :
+ inodeno_t sr, snapid_t sf, ceph::buffer::list& lb) :
path(p) {
capinfo.cap_id = cap_id;
capinfo.wanted = w;
capinfo.pathbase = pino;
capinfo.flock_len = 0;
snap_follows = sf;
- flockbl.claim(lb);
+ flockbl = std::move(lb);
}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- void encode_old(bufferlist& bl) const;
- void decode_old(bufferlist::const_iterator& bl);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void encode_old(ceph::buffer::list& bl) const;
+ void decode_old(ceph::buffer::list::const_iterator& bl);
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<cap_reconnect_t*>& ls);
- string path;
+ std::string path;
mutable ceph_mds_cap_reconnect capinfo = {};
snapid_t snap_follows = 0;
- bufferlist flockbl;
+ ceph::buffer::list flockbl;
};
WRITE_CLASS_ENCODER(cap_reconnect_t)
realm.seq = seq;
realm.parent = parent;
}
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- void encode_old(bufferlist& bl) const;
- void decode_old(bufferlist::const_iterator& bl);
+ void encode(ceph::buffer::list& bl) const;
+ void decode(ceph::buffer::list::const_iterator& bl);
+ void encode_old(ceph::buffer::list& bl) const;
+ void decode_old(ceph::buffer::list::const_iterator& bl);
- void dump(Formatter *f) const;
+ void dump(ceph::Formatter *f) const;
static void generate_test_instances(std::list<snaprealm_reconnect_t*>& ls);
mutable ceph_mds_snaprealm_reconnect realm = {};
return n;
}
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
encode(path, bl);
encode(capinfo, bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
using ceph::decode;
decode(path, bl);
decode(capinfo, bl);
}
- string path;
+ std::string path;
old_ceph_mds_cap_reconnect capinfo;
};
WRITE_CLASS_ENCODER(old_cap_reconnect_t)
dirfrag_t() {}
dirfrag_t(inodeno_t i, frag_t f) : ino(i), frag(f) { }
- void encode(bufferlist& bl) const {
+ void encode(ceph::buffer::list& bl) const {
using ceph::encode;
encode(ino, bl);
encode(frag, bl);
}
- void decode(bufferlist::const_iterator& bl) {
+ void decode(ceph::buffer::list::const_iterator& bl) {
using ceph::decode;
decode(ino, bl);
decode(frag, bl);
inode_load_vec_t() : vec{DecayCounter(DecayRate()), DecayCounter(DecayRate())} {}
inode_load_vec_t(const DecayRate &rate) : vec{DecayCounter(rate), DecayCounter(rate)} {}
- DecayCounter &get(int t) {
- return vec[t];
+ DecayCounter &get(int t) {
+ return vec[t];
}
void zero() {
for (auto &d : vec) {
d.reset();
}
}
- void encode(bufferlist &bl) const;
- void decode(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;
static void generate_test_instances(std::list<inode_load_vec_t*>& ls);
private:
std::array<DecayCounter, NUM> vec;
};
-inline void encode(const inode_load_vec_t &c, bufferlist &bl) {
+inline void encode(const inode_load_vec_t &c, ceph::buffer::list &bl) {
c.encode(bl);
}
-inline void decode(inode_load_vec_t & c, bufferlist::const_iterator &p) {
+inline void decode(inode_load_vec_t & c, ceph::buffer::list::const_iterator &p) {
c.decode(p);
}
vec{DecayCounter(rate), DecayCounter(rate), DecayCounter(rate), DecayCounter(rate), DecayCounter(rate)}
{}
- void encode(bufferlist &bl) const {
+ void encode(ceph::buffer::list &bl) const {
ENCODE_START(2, 2, bl);
for (const auto &i : vec) {
encode(i, bl);
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::const_iterator &p) {
+ void decode(ceph::buffer::list::const_iterator &p) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
for (auto &i : vec) {
decode(i, p);
}
DECODE_FINISH(p);
}
- void dump(Formatter *f) const;
- void dump(Formatter *f, const DecayRate& rate) const;
+ void dump(ceph::Formatter *f) const;
+ void dump(ceph::Formatter *f, const DecayRate& rate) const;
static void generate_test_instances(std::list<dirfrag_load_vec_t*>& ls);
const DecayCounter &get(int t) const {
std::array<DecayCounter, NUM> vec;
};
-inline void encode(const dirfrag_load_vec_t &c, bufferlist &bl) {
+inline void encode(const dirfrag_load_vec_t &c, ceph::buffer::list &bl) {
c.encode(bl);
}
-inline void decode(dirfrag_load_vec_t& c, bufferlist::const_iterator &p) {
+inline void decode(dirfrag_load_vec_t& c, ceph::buffer::list::const_iterator &p) {
c.decode(p);
}
inline std::ostream& operator<<(std::ostream& out, const dirfrag_load_vec_t& dl)
{
- std::ostringstream ss;
- ss << std::setprecision(1) << std::fixed
+ CachedStackStringStream css;
+ *css << std::setprecision(1) << std::fixed
<< "[pop"
" IRD:" << dl.vec[0]
<< " IWR:" << dl.vec[1]
<< " FET:" << dl.vec[3]
<< " STR:" << dl.vec[4]
<< " *LOAD:" << dl.meta_load() << "]";
- return out << ss.str() << std::endl;
+ return out << css->strv() << std::endl;
}
struct mds_load_t {
double cpu_load_avg = 0.0;
double mds_load() const; // defiend in MDBalancer.cc
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ 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<mds_load_t*>& ls);
};
-inline void encode(const mds_load_t &c, bufferlist &bl) {
+inline void encode(const mds_load_t &c, ceph::buffer::list &bl) {
c.encode(bl);
}
-inline void decode(mds_load_t &c, bufferlist::const_iterator &p) {
+inline void decode(mds_load_t &c, ceph::buffer::list::const_iterator &p) {
c.decode(p);
}
class MDSCacheObjectInfo {
public:
- void encode(bufferlist& bl) const;
- void decode(bufferlist::const_iterator& bl);
- void dump(Formatter *f) const;
+ 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<MDSCacheObjectInfo*>& ls);
inodeno_t ino = 0;
dirfrag_t dirfrag;
- string dname;
+ std::string dname;
snapid_t snapid;
};
template <typename Iterator>
struct keys_and_values
- : qi::grammar<Iterator, std::map<string, string>()>
+ : qi::grammar<Iterator, std::map<std::string, std::string>()>
{
keys_and_values()
: keys_and_values::base_type(query)
key = qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");
value = +qi::char_("a-zA-Z0-9-_.");
}
- qi::rule<Iterator, std::map<string, string>()> query;
- qi::rule<Iterator, std::pair<string, string>()> pair;
- qi::rule<Iterator, string()> key, value;
+ qi::rule<Iterator, std::map<std::string, std::string>()> query;
+ qi::rule<Iterator, std::pair<std::string, std::string>()> pair;
+ qi::rule<Iterator, std::string()> key, value;
};
#endif
projects / ceph.git / blobdiff