--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+#ifndef CEPH_MDSTYPES_H
+#define CEPH_MDSTYPES_H
+
+#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/entity_name.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 "inode_backtrace.h"
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/pool/pool.hpp>
+#include "include/assert.h"
+#include <boost/serialization/strong_typedef.hpp>
+
+#define CEPH_FS_ONDISK_MAGIC "ceph fs volume v011"
+
+#define MDS_PORT_CACHE 0x200
+#define MDS_PORT_LOCKER 0x300
+#define MDS_PORT_MIGRATOR 0x400
+
+#define MAX_MDS 0x100
+#define NUM_STRAY 10
+
+#define MDS_INO_ROOT 1
+
+// No longer created but recognised in existing filesystems
+// so that we don't try to fragment it.
+#define MDS_INO_CEPH 2
+
+#define MDS_INO_MDSDIR_OFFSET (1*MAX_MDS)
+#define MDS_INO_STRAY_OFFSET (6*MAX_MDS)
+
+// Locations for journal data
+#define MDS_INO_LOG_OFFSET (2*MAX_MDS)
+#define MDS_INO_LOG_BACKUP_OFFSET (3*MAX_MDS)
+#define MDS_INO_LOG_POINTER_OFFSET (4*MAX_MDS)
+#define MDS_INO_PURGE_QUEUE (5*MAX_MDS)
+
+#define MDS_INO_SYSTEM_BASE ((6*MAX_MDS) + (MAX_MDS * NUM_STRAY))
+
+#define MDS_INO_STRAY(x,i) (MDS_INO_STRAY_OFFSET+((((unsigned)(x))*NUM_STRAY)+((unsigned)(i))))
+#define MDS_INO_MDSDIR(x) (MDS_INO_MDSDIR_OFFSET+((unsigned)x))
+
+#define MDS_INO_IS_STRAY(i) ((i) >= MDS_INO_STRAY_OFFSET && (i) < (MDS_INO_STRAY_OFFSET+(MAX_MDS*NUM_STRAY)))
+#define MDS_INO_IS_MDSDIR(i) ((i) >= MDS_INO_MDSDIR_OFFSET && (i) < (MDS_INO_MDSDIR_OFFSET+MAX_MDS))
+#define MDS_INO_MDSDIR_OWNER(i) (signed ((unsigned (i)) - MDS_INO_MDSDIR_OFFSET))
+#define MDS_INO_IS_BASE(i) (MDS_INO_ROOT == (i) || MDS_INO_IS_MDSDIR(i))
+#define MDS_INO_STRAY_OWNER(i) (signed (((unsigned (i)) - MDS_INO_STRAY_OFFSET) / NUM_STRAY))
+#define MDS_INO_STRAY_INDEX(i) (((unsigned (i)) - MDS_INO_STRAY_OFFSET) % NUM_STRAY)
+
+#define MDS_TRAVERSE_FORWARD 1
+#define MDS_TRAVERSE_DISCOVER 2 // skips permissions checks etc.
+#define MDS_TRAVERSE_DISCOVERXLOCK 3 // succeeds on (foreign?) null, xlocked dentries.
+
+
+typedef int32_t mds_rank_t;
+typedef int32_t fs_cluster_id_t;
+
+BOOST_STRONG_TYPEDEF(uint64_t, mds_gid_t)
+extern const mds_gid_t MDS_GID_NONE;
+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};
+extern const mds_rank_t MDS_RANK_NONE;
+
+class mds_role_t
+{
+ public:
+ fs_cluster_id_t fscid;
+ mds_rank_t rank;
+
+ mds_role_t(fs_cluster_id_t fscid_, mds_rank_t rank_)
+ : fscid(fscid_), rank(rank_)
+ {}
+ mds_role_t()
+ : fscid(FS_CLUSTER_ID_NONE), rank(MDS_RANK_NONE)
+ {}
+ bool operator<(mds_role_t const &rhs) const
+ {
+ if (fscid < rhs.fscid) {
+ return true;
+ } else if (fscid == rhs.fscid) {
+ return rank < rhs.rank;
+ } else {
+ return false;
+ }
+ }
+
+ bool is_none() const
+ {
+ return (rank == MDS_RANK_NONE);
+ }
+};
+std::ostream& operator<<(std::ostream &out, const mds_role_t &role);
+
+
+// CAPS
+
+inline string gcap_string(int cap)
+{
+ 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_GRD) s += "r";
+ if (cap & CEPH_CAP_GWR) s += "w";
+ if (cap & CEPH_CAP_GBUFFER) s += "b";
+ if (cap & CEPH_CAP_GWREXTEND) s += "a";
+ if (cap & CEPH_CAP_GLAZYIO) s += "l";
+ return s;
+}
+inline string ccap_string(int cap)
+{
+ string s;
+ if (cap & CEPH_CAP_PIN) s += "p";
+
+ int a = (cap >> CEPH_CAP_SAUTH) & 3;
+ if (a) s += 'A' + gcap_string(a);
+
+ a = (cap >> CEPH_CAP_SLINK) & 3;
+ if (a) s += 'L' + gcap_string(a);
+
+ a = (cap >> CEPH_CAP_SXATTR) & 3;
+ if (a) s += 'X' + gcap_string(a);
+
+ a = cap >> CEPH_CAP_SFILE;
+ if (a) s += 'F' + gcap_string(a);
+
+ if (s.length() == 0)
+ s = "-";
+ return s;
+}
+
+
+struct scatter_info_t {
+ version_t version;
+
+ scatter_info_t() : version(0) {}
+};
+
+struct frag_info_t : public scatter_info_t {
+ // this frag
+ utime_t mtime;
+ uint64_t change_attr;
+ int64_t nfiles; // files
+ int64_t nsubdirs; // subdirs
+
+ frag_info_t() : change_attr(0), nfiles(0), nsubdirs(0) {}
+
+ int64_t size() const { return nfiles + nsubdirs; }
+
+ void zero() {
+ *this = frag_info_t();
+ }
+
+ // *this += cur - acc;
+ void add_delta(const frag_info_t &cur, const frag_info_t &acc, bool *touched_mtime=0, bool *touched_chattr=0) {
+ if (cur.mtime > mtime) {
+ mtime = cur.mtime;
+ if (touched_mtime)
+ *touched_mtime = true;
+ }
+ if (cur.change_attr > change_attr) {
+ change_attr = cur.change_attr;
+ if (touched_chattr)
+ *touched_chattr = true;
+ }
+ nfiles += cur.nfiles - acc.nfiles;
+ nsubdirs += cur.nsubdirs - acc.nsubdirs;
+ }
+
+ void add(const frag_info_t& other) {
+ if (other.mtime > mtime)
+ mtime = other.mtime;
+ if (other.change_attr > change_attr)
+ change_attr = other.change_attr;
+ nfiles += other.nfiles;
+ nsubdirs += other.nsubdirs;
+ }
+
+ bool same_sums(const frag_info_t &o) const {
+ return mtime <= o.mtime &&
+ nfiles == o.nfiles &&
+ nsubdirs == o.nsubdirs;
+ }
+
+ void encode(bufferlist &bl) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<frag_info_t*>& ls);
+};
+WRITE_CLASS_ENCODER(frag_info_t)
+
+inline bool operator==(const frag_info_t &l, const frag_info_t &r) {
+ return memcmp(&l, &r, sizeof(l)) == 0;
+}
+inline bool operator!=(const frag_info_t &l, const frag_info_t &r) {
+ return !(l == r);
+}
+
+std::ostream& operator<<(std::ostream &out, const frag_info_t &f);
+
+
+struct nest_info_t : public scatter_info_t {
+ // this frag + children
+ utime_t rctime;
+ int64_t rbytes;
+ int64_t rfiles;
+ int64_t rsubdirs;
+ int64_t rsize() const { return rfiles + rsubdirs; }
+
+ int64_t rsnaprealms;
+
+ nest_info_t() : rbytes(0), rfiles(0), rsubdirs(0), rsnaprealms(0) {}
+
+ void zero() {
+ *this = nest_info_t();
+ }
+
+ void sub(const nest_info_t &other) {
+ add(other, -1);
+ }
+ void add(const nest_info_t &other, int fac=1) {
+ if (other.rctime > rctime)
+ rctime = other.rctime;
+ rbytes += fac*other.rbytes;
+ rfiles += fac*other.rfiles;
+ rsubdirs += fac*other.rsubdirs;
+ rsnaprealms += fac*other.rsnaprealms;
+ }
+
+ // *this += cur - acc;
+ void add_delta(const nest_info_t &cur, const nest_info_t &acc) {
+ if (cur.rctime > rctime)
+ rctime = cur.rctime;
+ rbytes += cur.rbytes - acc.rbytes;
+ rfiles += cur.rfiles - acc.rfiles;
+ rsubdirs += cur.rsubdirs - acc.rsubdirs;
+ rsnaprealms += cur.rsnaprealms - acc.rsnaprealms;
+ }
+
+ bool same_sums(const nest_info_t &o) const {
+ return rctime <= o.rctime &&
+ rbytes == o.rbytes &&
+ rfiles == o.rfiles &&
+ rsubdirs == o.rsubdirs &&
+ rsnaprealms == o.rsnaprealms;
+ }
+
+ void encode(bufferlist &bl) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<nest_info_t*>& ls);
+};
+WRITE_CLASS_ENCODER(nest_info_t)
+
+inline bool operator==(const nest_info_t &l, const nest_info_t &r) {
+ return memcmp(&l, &r, sizeof(l)) == 0;
+}
+inline bool operator!=(const nest_info_t &l, const nest_info_t &r) {
+ return !(l == r);
+}
+
+std::ostream& operator<<(std::ostream &out, const nest_info_t &n);
+
+
+struct vinodeno_t {
+ inodeno_t ino;
+ snapid_t snapid;
+ vinodeno_t() {}
+ vinodeno_t(inodeno_t i, snapid_t s) : ino(i), snapid(s) {}
+
+ void encode(bufferlist& bl) const {
+ ::encode(ino, bl);
+ ::encode(snapid, bl);
+ }
+ void decode(bufferlist::iterator& p) {
+ ::decode(ino, p);
+ ::decode(snapid, p);
+ }
+};
+WRITE_CLASS_ENCODER(vinodeno_t)
+
+inline bool operator==(const vinodeno_t &l, const vinodeno_t &r) {
+ return l.ino == r.ino && l.snapid == r.snapid;
+}
+inline bool operator!=(const vinodeno_t &l, const vinodeno_t &r) {
+ return !(l == r);
+}
+inline bool operator<(const vinodeno_t &l, const vinodeno_t &r) {
+ return
+ l.ino < r.ino ||
+ (l.ino == r.ino && l.snapid < r.snapid);
+}
+
+struct quota_info_t
+{
+ int64_t max_bytes;
+ int64_t max_files;
+
+ quota_info_t() : max_bytes(0), max_files(0) {}
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ ::encode(max_bytes, bl);
+ ::encode(max_files, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::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;
+ static void generate_test_instances(list<quota_info_t *>& ls);
+
+ bool is_valid() const {
+ return max_bytes >=0 && max_files >=0;
+ }
+ bool is_enable() const {
+ return max_bytes || max_files;
+ }
+};
+WRITE_CLASS_ENCODER(quota_info_t)
+
+inline bool operator==(const quota_info_t &l, const quota_info_t &r) {
+ return memcmp(&l, &r, sizeof(l)) == 0;
+}
+
+ostream& operator<<(ostream &out, const quota_info_t &n);
+
+namespace std {
+ template<> struct hash<vinodeno_t> {
+ size_t operator()(const vinodeno_t &vino) const {
+ hash<inodeno_t> H;
+ hash<uint64_t> I;
+ return H(vino.ino) ^ I(vino.snapid);
+ }
+ };
+} // namespace std
+
+
+
+
+inline std::ostream& operator<<(std::ostream &out, const vinodeno_t &vino) {
+ out << vino.ino;
+ if (vino.snapid == CEPH_NOSNAP)
+ out << ".head";
+ else if (vino.snapid)
+ out << '.' << vino.snapid;
+ return out;
+}
+
+
+/*
+ * client_writeable_range_t
+ */
+struct client_writeable_range_t {
+ struct byte_range_t {
+ uint64_t first, last; // interval client can write to
+ byte_range_t() : first(0), last(0) {}
+ };
+
+ byte_range_t range;
+ snapid_t follows; // aka "data+metadata flushed thru"
+
+ client_writeable_range_t() : follows(0) {}
+
+ void encode(bufferlist &bl) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<client_writeable_range_t*>& ls);
+};
+
+inline void decode(client_writeable_range_t::byte_range_t& range, bufferlist::iterator& bl) {
+ ::decode(range.first, bl);
+ ::decode(range.last, bl);
+}
+
+WRITE_CLASS_ENCODER(client_writeable_range_t)
+
+std::ostream& operator<<(std::ostream& out, const client_writeable_range_t& r);
+
+inline bool operator==(const client_writeable_range_t& l,
+ const client_writeable_range_t& r) {
+ return l.range.first == r.range.first && l.range.last == r.range.last &&
+ l.follows == r.follows;
+}
+
+struct inline_data_t {
+private:
+ std::unique_ptr<bufferlist> blp;
+public:
+ version_t version;
+
+ void free_data() {
+ blp.reset();
+ }
+ bufferlist& get_data() {
+ if (!blp)
+ blp.reset(new bufferlist);
+ return *blp;
+ }
+ size_t length() const { return blp ? blp->length() : 0; }
+
+ inline_data_t() : version(1) {}
+ inline_data_t(const inline_data_t& o) : version(o.version) {
+ if (o.blp)
+ get_data() = *o.blp;
+ }
+ inline_data_t& operator=(const inline_data_t& o) {
+ version = o.version;
+ if (o.blp)
+ get_data() = *o.blp;
+ else
+ free_data();
+ return *this;
+ }
+ 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())));
+ }
+ bool operator!=(const inline_data_t& o) const {
+ return !(*this == o);
+ }
+ void encode(bufferlist &bl) const;
+ void decode(bufferlist::iterator& bl);
+};
+WRITE_CLASS_ENCODER(inline_data_t)
+
+enum {
+ DAMAGE_STATS, // statistics (dirstat, size, etc)
+ DAMAGE_RSTATS, // recursive statistics (rstat, accounted_rstat)
+ DAMAGE_FRAGTREE // fragtree -- repair by searching
+};
+typedef uint32_t damage_flags_t;
+
+/*
+ * inode_t
+ */
+struct inode_t {
+ /**
+ * ***************
+ * Do not forget to add any new fields to the compare() function.
+ * ***************
+ */
+ // base (immutable)
+ inodeno_t ino;
+ uint32_t rdev; // if special file
+
+ // affected by any inode change...
+ utime_t ctime; // inode change time
+ utime_t btime; // birth time
+
+ // perm (namespace permissions)
+ uint32_t mode;
+ uid_t uid;
+ gid_t gid;
+
+ // nlink
+ int32_t nlink;
+
+ // file (data access)
+ ceph_dir_layout dir_layout; // [dir only]
+ file_layout_t layout;
+ compact_set <int64_t> old_pools;
+ uint64_t size; // on directory, # dentries
+ uint64_t max_size_ever; // max size the file has ever been
+ uint32_t truncate_seq;
+ uint64_t truncate_size, truncate_from;
+ uint32_t truncate_pending;
+ utime_t mtime; // file data modify time.
+ utime_t atime; // file data access time.
+ uint32_t time_warp_seq; // count of (potential) mtime/atime timewarps (i.e., utimes())
+ inline_data_t inline_data;
+
+ // change attribute
+ uint64_t change_attr;
+
+ std::map<client_t,client_writeable_range_t> client_ranges; // client(s) can write to these ranges
+
+ // dirfrag, recursive accountin
+ frag_info_t dirstat; // protected by my filelock
+ nest_info_t rstat; // protected by my nestlock
+ nest_info_t accounted_rstat; // protected by parent's nestlock
+
+ quota_info_t quota;
+
+ mds_rank_t export_pin;
+
+ // special stuff
+ version_t version; // auth only
+ version_t file_data_version; // auth only
+ version_t xattr_version;
+
+ utime_t last_scrub_stamp; // start time of last complete scrub
+ version_t last_scrub_version;// (parent) start version of last complete scrub
+
+ version_t backtrace_version;
+
+ snapid_t oldest_snap;
+
+ string stray_prior_path; //stores path before unlink
+
+ inode_t() : ino(0), rdev(0),
+ mode(0), uid(0), gid(0), nlink(0),
+ size(0), max_size_ever(0),
+ truncate_seq(0), truncate_size(0), truncate_from(0),
+ truncate_pending(0),
+ time_warp_seq(0), change_attr(0),
+ export_pin(MDS_RANK_NONE),
+ version(0), file_data_version(0), xattr_version(0),
+ last_scrub_version(0), backtrace_version(0) {
+ clear_layout();
+ memset(&dir_layout, 0, sizeof(dir_layout));
+ memset("a, 0, sizeof(quota));
+ }
+
+ // file type
+ bool is_symlink() const { return (mode & S_IFMT) == S_IFLNK; }
+ bool is_dir() const { return (mode & S_IFMT) == S_IFDIR; }
+ bool is_file() const { return (mode & S_IFMT) == S_IFREG; }
+
+ bool is_truncating() const { return (truncate_pending > 0); }
+ void truncate(uint64_t old_size, uint64_t new_size) {
+ assert(new_size < old_size);
+ if (old_size > max_size_ever)
+ max_size_ever = old_size;
+ truncate_from = old_size;
+ size = new_size;
+ rstat.rbytes = new_size;
+ truncate_size = size;
+ truncate_seq++;
+ truncate_pending++;
+ }
+
+ bool has_layout() const {
+ return layout != file_layout_t();
+ }
+
+ void clear_layout() {
+ layout = file_layout_t();
+ }
+
+ uint64_t get_layout_size_increment() const {
+ return layout.get_period();
+ }
+
+ bool is_dirty_rstat() const { return !(rstat == accounted_rstat); }
+
+ uint64_t get_max_size() const {
+ uint64_t max = 0;
+ for (std::map<client_t,client_writeable_range_t>::const_iterator p = client_ranges.begin();
+ p != client_ranges.end();
+ ++p)
+ if (p->second.range.last > max)
+ max = p->second.range.last;
+ return max;
+ }
+ void set_max_size(uint64_t new_max) {
+ if (new_max == 0) {
+ client_ranges.clear();
+ } else {
+ for (std::map<client_t,client_writeable_range_t>::iterator p = client_ranges.begin();
+ p != client_ranges.end();
+ ++p)
+ p->second.range.last = new_max;
+ }
+ }
+
+ void trim_client_ranges(snapid_t last) {
+ std::map<client_t, client_writeable_range_t>::iterator p = client_ranges.begin();
+ while (p != client_ranges.end()) {
+ if (p->second.follows >= last)
+ client_ranges.erase(p++);
+ else
+ ++p;
+ }
+ }
+
+ bool is_backtrace_updated() const {
+ return backtrace_version == version;
+ }
+ void update_backtrace(version_t pv=0) {
+ backtrace_version = pv ? pv : version;
+ }
+
+ void add_old_pool(int64_t l) {
+ backtrace_version = version;
+ old_pools.insert(l);
+ }
+
+ void encode(bufferlist &bl, uint64_t features) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<inode_t*>& ls);
+ /**
+ * Compare this inode_t with another that represent *the same inode*
+ * at different points in time.
+ * @pre The inodes are the same ino
+ *
+ * @param other The inode_t to compare ourselves with
+ * @param divergent A bool pointer which will be set to true
+ * if the values are different in a way that can't be explained
+ * by one being a newer version than the other.
+ *
+ * @returns 1 if we are newer than the other, 0 if equal, -1 if older.
+ */
+ int compare(const inode_t &other, bool *divergent) const;
+private:
+ bool older_is_consistent(const inode_t &other) const;
+};
+WRITE_CLASS_ENCODER_FEATURES(inode_t)
+
+
+/*
+ * old_inode_t
+ */
+struct old_inode_t {
+ snapid_t first;
+ inode_t inode;
+ std::map<string,bufferptr> xattrs;
+
+ void encode(bufferlist &bl, uint64_t features) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<old_inode_t*>& ls);
+};
+WRITE_CLASS_ENCODER_FEATURES(old_inode_t)
+
+
+/*
+ * like an inode, but for a dir frag
+ */
+struct fnode_t {
+ version_t version;
+ snapid_t snap_purged_thru; // the max_last_destroy snapid we've been purged thru
+ frag_info_t fragstat, accounted_fragstat;
+ nest_info_t rstat, accounted_rstat;
+ damage_flags_t damage_flags;
+
+ // we know we and all our descendants have been scrubbed since this version
+ version_t recursive_scrub_version;
+ utime_t recursive_scrub_stamp;
+ // version at which we last scrubbed our personal data structures
+ version_t localized_scrub_version;
+ utime_t localized_scrub_stamp;
+
+ void encode(bufferlist &bl) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<fnode_t*>& ls);
+ fnode_t() : version(0), damage_flags(0),
+ recursive_scrub_version(0), localized_scrub_version(0) {}
+};
+WRITE_CLASS_ENCODER(fnode_t)
+
+
+struct old_rstat_t {
+ snapid_t first;
+ nest_info_t rstat, accounted_rstat;
+
+ void encode(bufferlist& bl) const;
+ void decode(bufferlist::iterator& p);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<old_rstat_t*>& ls);
+};
+WRITE_CLASS_ENCODER(old_rstat_t)
+
+inline std::ostream& operator<<(std::ostream& out, const old_rstat_t& o) {
+ return out << "old_rstat(first " << o.first << " " << o.rstat << " " << o.accounted_rstat << ")";
+}
+
+
+/*
+ * session_info_t
+ */
+
+struct session_info_t {
+ 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
+ std::map<std::string, std::string> client_metadata;
+ std::set<ceph_tid_t> completed_flushes;
+ EntityName auth_name;
+
+ client_t get_client() const { return client_t(inst.name.num()); }
+ const entity_name_t& get_source() const { return inst.name; }
+
+ void clear_meta() {
+ prealloc_inos.clear();
+ used_inos.clear();
+ completed_requests.clear();
+ completed_flushes.clear();
+ }
+
+ void encode(bufferlist& bl, uint64_t features) const;
+ void decode(bufferlist::iterator& p);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<session_info_t*>& ls);
+};
+WRITE_CLASS_ENCODER_FEATURES(session_info_t)
+
+
+// =======
+// dentries
+
+struct dentry_key_t {
+ snapid_t snapid;
+ const char *name;
+ __u32 hash;
+ dentry_key_t() : snapid(0), name(0), hash(0) {}
+ dentry_key_t(snapid_t s, const char *n, __u32 h=0) :
+ snapid(s), name(n), hash(h) {}
+
+ bool is_valid() { return name || snapid; }
+
+ // encode into something that can be decoded as a string.
+ // name_ (head) or name_%x (!head)
+ void encode(bufferlist& bl) const {
+ string key;
+ encode(key);
+ ::encode(key, bl);
+ }
+ void encode(string& key) const {
+ char b[20];
+ if (snapid != CEPH_NOSNAP) {
+ uint64_t val(snapid);
+ snprintf(b, sizeof(b), "%" PRIx64, val);
+ } else {
+ snprintf(b, sizeof(b), "%s", "head");
+ }
+ ostringstream oss;
+ oss << name << "_" << b;
+ key = oss.str();
+ }
+ static void decode_helper(bufferlist::iterator& bl, string& nm, snapid_t& sn) {
+ string key;
+ ::decode(key, bl);
+ decode_helper(key, nm, sn);
+ }
+ static void decode_helper(const string& key, string& nm, snapid_t& sn) {
+ size_t i = key.find_last_of('_');
+ assert(i != string::npos);
+ if (key.compare(i+1, string::npos, "head") == 0) {
+ // name_head
+ sn = CEPH_NOSNAP;
+ } else {
+ // name_%x
+ long long unsigned x = 0;
+ sscanf(key.c_str() + i + 1, "%llx", &x);
+ sn = x;
+ }
+ nm = string(key.c_str(), i);
+ }
+};
+
+inline std::ostream& operator<<(std::ostream& out, const dentry_key_t &k)
+{
+ return out << "(" << k.name << "," << k.snapid << ")";
+}
+
+inline bool operator<(const dentry_key_t& k1, const dentry_key_t& k2)
+{
+ /*
+ * order by hash, name, snap
+ */
+ int c = ceph_frag_value(k1.hash) - ceph_frag_value(k2.hash);
+ if (c)
+ return c < 0;
+ c = strcmp(k1.name, k2.name);
+ if (c)
+ return c < 0;
+ return k1.snapid < k2.snapid;
+}
+
+
+/*
+ * string_snap_t is a simple (string, snapid_t) pair
+ */
+struct string_snap_t {
+ string name;
+ snapid_t snapid;
+ string_snap_t() {}
+ string_snap_t(const string& n, snapid_t s) : name(n), snapid(s) {}
+ string_snap_t(const char *n, snapid_t s) : name(n), snapid(s) {}
+
+ void encode(bufferlist& bl) const;
+ void decode(bufferlist::iterator& p);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<string_snap_t*>& ls);
+};
+WRITE_CLASS_ENCODER(string_snap_t)
+
+inline bool operator<(const string_snap_t& l, const string_snap_t& r) {
+ int c = strcmp(l.name.c_str(), r.name.c_str());
+ return c < 0 || (c == 0 && l.snapid < r.snapid);
+}
+
+inline std::ostream& operator<<(std::ostream& out, const string_snap_t &k)
+{
+ return out << "(" << k.name << "," << k.snapid << ")";
+}
+
+/*
+ * mds_table_pending_t
+ *
+ * mds's requesting any pending ops. child needs to encode the corresponding
+ * pending mutation state in the table.
+ */
+struct mds_table_pending_t {
+ uint64_t reqid;
+ __s32 mds;
+ version_t tid;
+ mds_table_pending_t() : reqid(0), mds(0), tid(0) {}
+ void encode(bufferlist& bl) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<mds_table_pending_t*>& ls);
+};
+WRITE_CLASS_ENCODER(mds_table_pending_t)
+
+
+// =========
+// requests
+
+struct metareqid_t {
+ entity_name_t name;
+ uint64_t tid;
+ metareqid_t() : tid(0) {}
+ metareqid_t(entity_name_t n, ceph_tid_t t) : name(n), tid(t) {}
+ void encode(bufferlist& bl) const {
+ ::encode(name, bl);
+ ::encode(tid, bl);
+ }
+ void decode(bufferlist::iterator &p) {
+ ::decode(name, p);
+ ::decode(tid, p);
+ }
+};
+WRITE_CLASS_ENCODER(metareqid_t)
+
+inline std::ostream& operator<<(std::ostream& out, const metareqid_t& r) {
+ return out << r.name << ":" << r.tid;
+}
+
+inline bool operator==(const metareqid_t& l, const metareqid_t& r) {
+ return (l.name == r.name) && (l.tid == r.tid);
+}
+inline bool operator!=(const metareqid_t& l, const metareqid_t& r) {
+ return (l.name != r.name) || (l.tid != r.tid);
+}
+inline bool operator<(const metareqid_t& l, const metareqid_t& r) {
+ return (l.name < r.name) ||
+ (l.name == r.name && l.tid < r.tid);
+}
+inline bool operator<=(const metareqid_t& l, const metareqid_t& r) {
+ return (l.name < r.name) ||
+ (l.name == r.name && l.tid <= r.tid);
+}
+inline bool operator>(const metareqid_t& l, const metareqid_t& r) { return !(l <= r); }
+inline bool operator>=(const metareqid_t& l, const metareqid_t& r) { return !(l < r); }
+
+namespace std {
+ template<> struct hash<metareqid_t> {
+ size_t operator()(const metareqid_t &r) const {
+ hash<uint64_t> H;
+ return H(r.name.num()) ^ H(r.name.type()) ^ H(r.tid);
+ }
+ };
+} // namespace std
+
+
+// cap info for client reconnect
+struct cap_reconnect_t {
+ string path;
+ mutable ceph_mds_cap_reconnect capinfo;
+ snapid_t snap_follows;
+ bufferlist flockbl;
+
+ cap_reconnect_t() {
+ memset(&capinfo, 0, sizeof(capinfo));
+ snap_follows = 0;
+ }
+ cap_reconnect_t(uint64_t cap_id, inodeno_t pino, const string& p, int w, int i,
+ inodeno_t sr, snapid_t sf, bufferlist& lb) :
+ path(p) {
+ capinfo.cap_id = cap_id;
+ capinfo.wanted = w;
+ capinfo.issued = i;
+ capinfo.snaprealm = sr;
+ capinfo.pathbase = pino;
+ capinfo.flock_len = 0;
+ snap_follows = sf;
+ flockbl.claim(lb);
+ }
+ void encode(bufferlist& bl) const;
+ void decode(bufferlist::iterator& bl);
+ void encode_old(bufferlist& bl) const;
+ void decode_old(bufferlist::iterator& bl);
+
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<cap_reconnect_t*>& ls);
+};
+WRITE_CLASS_ENCODER(cap_reconnect_t)
+
+
+// compat for pre-FLOCK feature
+struct old_ceph_mds_cap_reconnect {
+ __le64 cap_id;
+ __le32 wanted;
+ __le32 issued;
+ __le64 old_size;
+ struct ceph_timespec old_mtime, old_atime;
+ __le64 snaprealm;
+ __le64 pathbase; /* base ino for our path to this ino */
+} __attribute__ ((packed));
+WRITE_RAW_ENCODER(old_ceph_mds_cap_reconnect)
+
+struct old_cap_reconnect_t {
+ string path;
+ old_ceph_mds_cap_reconnect capinfo;
+
+ const old_cap_reconnect_t& operator=(const cap_reconnect_t& n) {
+ path = n.path;
+ capinfo.cap_id = n.capinfo.cap_id;
+ capinfo.wanted = n.capinfo.wanted;
+ capinfo.issued = n.capinfo.issued;
+ capinfo.snaprealm = n.capinfo.snaprealm;
+ capinfo.pathbase = n.capinfo.pathbase;
+ return *this;
+ }
+ operator cap_reconnect_t() {
+ cap_reconnect_t n;
+ n.path = path;
+ n.capinfo.cap_id = capinfo.cap_id;
+ n.capinfo.wanted = capinfo.wanted;
+ n.capinfo.issued = capinfo.issued;
+ n.capinfo.snaprealm = capinfo.snaprealm;
+ n.capinfo.pathbase = capinfo.pathbase;
+ return n;
+ }
+
+ void encode(bufferlist& bl) const {
+ ::encode(path, bl);
+ ::encode(capinfo, bl);
+ }
+ void decode(bufferlist::iterator& bl) {
+ ::decode(path, bl);
+ ::decode(capinfo, bl);
+ }
+};
+WRITE_CLASS_ENCODER(old_cap_reconnect_t)
+
+
+// ================================================================
+// dir frag
+
+struct dirfrag_t {
+ inodeno_t ino;
+ frag_t frag;
+
+ dirfrag_t() : ino(0) { }
+ dirfrag_t(inodeno_t i, frag_t f) : ino(i), frag(f) { }
+
+ void encode(bufferlist& bl) const {
+ ::encode(ino, bl);
+ ::encode(frag, bl);
+ }
+ void decode(bufferlist::iterator& bl) {
+ ::decode(ino, bl);
+ ::decode(frag, bl);
+ }
+};
+WRITE_CLASS_ENCODER(dirfrag_t)
+
+
+inline std::ostream& operator<<(std::ostream& out, const dirfrag_t &df) {
+ out << df.ino;
+ if (!df.frag.is_root()) out << "." << df.frag;
+ return out;
+}
+inline bool operator<(dirfrag_t l, dirfrag_t r) {
+ if (l.ino < r.ino) return true;
+ if (l.ino == r.ino && l.frag < r.frag) return true;
+ return false;
+}
+inline bool operator==(dirfrag_t l, dirfrag_t r) {
+ return l.ino == r.ino && l.frag == r.frag;
+}
+
+namespace std {
+ template<> struct hash<dirfrag_t> {
+ size_t operator()(const dirfrag_t &df) const {
+ static rjhash<uint64_t> H;
+ static rjhash<uint32_t> I;
+ return H(df.ino) ^ I(df.frag);
+ }
+ };
+} // namespace std
+
+
+
+// ================================================================
+
+#define META_POP_IRD 0
+#define META_POP_IWR 1
+#define META_POP_READDIR 2
+#define META_POP_FETCH 3
+#define META_POP_STORE 4
+#define META_NPOP 5
+
+class inode_load_vec_t {
+ static const int NUM = 2;
+ std::vector < DecayCounter > vec;
+public:
+ explicit inode_load_vec_t(const utime_t &now)
+ : vec(NUM, DecayCounter(now))
+ {}
+ // for dencoder infrastructure
+ inode_load_vec_t() :
+ vec(NUM, DecayCounter())
+ {}
+ DecayCounter &get(int t) {
+ assert(t < NUM);
+ return vec[t];
+ }
+ void zero(utime_t now) {
+ for (int i=0; i<NUM; i++)
+ vec[i].reset(now);
+ }
+ void encode(bufferlist &bl) const;
+ void decode(const utime_t &t, bufferlist::iterator &p);
+ // for dencoder
+ void decode(bufferlist::iterator& p) { utime_t sample; decode(sample, p); }
+ void dump(Formatter *f);
+ static void generate_test_instances(list<inode_load_vec_t*>& ls);
+};
+inline void encode(const inode_load_vec_t &c, bufferlist &bl) { c.encode(bl); }
+inline void decode(inode_load_vec_t & c, const utime_t &t, bufferlist::iterator &p) {
+ c.decode(t, p);
+}
+// for dencoder
+inline void decode(inode_load_vec_t & c, bufferlist::iterator &p) {
+ utime_t sample;
+ c.decode(sample, p);
+}
+
+class dirfrag_load_vec_t {
+public:
+ static const int NUM = 5;
+ std::vector < DecayCounter > vec;
+ explicit dirfrag_load_vec_t(const utime_t &now)
+ : vec(NUM, DecayCounter(now))
+ { }
+ // for dencoder infrastructure
+ dirfrag_load_vec_t()
+ : vec(NUM, DecayCounter())
+ {}
+ void encode(bufferlist &bl) const {
+ ENCODE_START(2, 2, bl);
+ for (int i=0; i<NUM; i++)
+ ::encode(vec[i], bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(const utime_t &t, bufferlist::iterator &p) {
+ DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
+ for (int i=0; i<NUM; i++)
+ ::decode(vec[i], t, p);
+ DECODE_FINISH(p);
+ }
+ // for dencoder infrastructure
+ void decode(bufferlist::iterator& p) {
+ utime_t sample;
+ decode(sample, p);
+ }
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<dirfrag_load_vec_t*>& ls);
+
+ DecayCounter &get(int t) {
+ assert(t < NUM);
+ return vec[t];
+ }
+ void adjust(utime_t now, const DecayRate& rate, double d) {
+ for (int i=0; i<NUM; i++)
+ vec[i].adjust(now, rate, d);
+ }
+ void zero(utime_t now) {
+ for (int i=0; i<NUM; i++)
+ vec[i].reset(now);
+ }
+ double meta_load(utime_t now, const DecayRate& rate) {
+ return
+ 1*vec[META_POP_IRD].get(now, rate) +
+ 2*vec[META_POP_IWR].get(now, rate) +
+ 1*vec[META_POP_READDIR].get(now, rate) +
+ 2*vec[META_POP_FETCH].get(now, rate) +
+ 4*vec[META_POP_STORE].get(now, rate);
+ }
+ double meta_load() {
+ return
+ 1*vec[META_POP_IRD].get_last() +
+ 2*vec[META_POP_IWR].get_last() +
+ 1*vec[META_POP_READDIR].get_last() +
+ 2*vec[META_POP_FETCH].get_last() +
+ 4*vec[META_POP_STORE].get_last();
+ }
+
+ void add(utime_t now, DecayRate& rate, dirfrag_load_vec_t& r) {
+ for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
+ vec[i].adjust(r.vec[i].get(now, rate));
+ }
+ void sub(utime_t now, DecayRate& rate, dirfrag_load_vec_t& r) {
+ for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
+ vec[i].adjust(-r.vec[i].get(now, rate));
+ }
+ void scale(double f) {
+ for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
+ vec[i].scale(f);
+ }
+};
+
+inline void encode(const dirfrag_load_vec_t &c, bufferlist &bl) { c.encode(bl); }
+inline void decode(dirfrag_load_vec_t& c, const utime_t &t, bufferlist::iterator &p) {
+ c.decode(t, p);
+}
+// this for dencoder
+inline void decode(dirfrag_load_vec_t& c, bufferlist::iterator &p) {
+ utime_t sample;
+ c.decode(sample, p);
+}
+
+inline std::ostream& operator<<(std::ostream& out, dirfrag_load_vec_t& dl)
+{
+ // ugliness!
+ utime_t now = ceph_clock_now();
+ DecayRate rate(g_conf->mds_decay_halflife);
+ return out << "[" << dl.vec[0].get(now, rate) << "," << dl.vec[1].get(now, rate)
+ << " " << dl.meta_load(now, rate)
+ << "]";
+}
+
+
+
+
+
+
+/* mds_load_t
+ * mds load
+ */
+
+struct mds_load_t {
+ dirfrag_load_vec_t auth;
+ dirfrag_load_vec_t all;
+
+ double req_rate;
+ double cache_hit_rate;
+ double queue_len;
+
+ double cpu_load_avg;
+
+ explicit mds_load_t(const utime_t &t) :
+ auth(t), all(t), req_rate(0), cache_hit_rate(0),
+ queue_len(0), cpu_load_avg(0)
+ {}
+ // mostly for the dencoder infrastructure
+ mds_load_t() :
+ auth(), all(),
+ req_rate(0), cache_hit_rate(0), queue_len(0), cpu_load_avg(0)
+ {}
+
+ double mds_load(); // defiend in MDBalancer.cc
+ void encode(bufferlist& bl) const;
+ void decode(const utime_t& now, bufferlist::iterator& bl);
+ //this one is for dencoder infrastructure
+ void decode(bufferlist::iterator& bl) { utime_t sample; decode(sample, bl); }
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<mds_load_t*>& ls);
+};
+inline void encode(const mds_load_t &c, bufferlist &bl) { c.encode(bl); }
+inline void decode(mds_load_t &c, const utime_t &t, bufferlist::iterator &p) {
+ c.decode(t, p);
+}
+// this one is for dencoder
+inline void decode(mds_load_t &c, bufferlist::iterator &p) {
+ utime_t sample;
+ c.decode(sample, p);
+}
+
+inline std::ostream& operator<<( std::ostream& out, mds_load_t& load )
+{
+ return out << "mdsload<" << load.auth << "/" << load.all
+ << ", req " << load.req_rate
+ << ", hr " << load.cache_hit_rate
+ << ", qlen " << load.queue_len
+ << ", cpu " << load.cpu_load_avg
+ << ">";
+}
+
+class load_spread_t {
+public:
+ static const int MAX = 4;
+ int last[MAX];
+ int p, n;
+ DecayCounter count;
+
+public:
+ load_spread_t() : p(0), n(0), count(ceph_clock_now())
+ {
+ for (int i=0; i<MAX; i++)
+ last[i] = -1;
+ }
+
+ double hit(utime_t now, const DecayRate& rate, int who) {
+ for (int i=0; i<n; i++)
+ if (last[i] == who)
+ return count.get_last();
+
+ // we're new(ish)
+ last[p++] = who;
+ if (n < MAX) n++;
+ if (n == 1) return 0.0;
+
+ if (p == MAX) p = 0;
+
+ return count.hit(now, rate);
+ }
+ double get(utime_t now, const DecayRate& rate) {
+ return count.get(now, rate);
+ }
+};
+
+
+
+// ================================================================
+typedef std::pair<mds_rank_t, mds_rank_t> mds_authority_t;
+
+// -- authority delegation --
+// directory authority types
+// >= 0 is the auth mds
+#define CDIR_AUTH_PARENT mds_rank_t(-1) // default
+#define CDIR_AUTH_UNKNOWN mds_rank_t(-2)
+#define CDIR_AUTH_DEFAULT mds_authority_t(CDIR_AUTH_PARENT, CDIR_AUTH_UNKNOWN)
+#define CDIR_AUTH_UNDEF mds_authority_t(CDIR_AUTH_UNKNOWN, CDIR_AUTH_UNKNOWN)
+//#define CDIR_AUTH_ROOTINODE pair<int,int>( 0, -2)
+
+class MDSCacheObjectInfo {
+public:
+ inodeno_t ino;
+ dirfrag_t dirfrag;
+ string dname;
+ snapid_t snapid;
+
+ MDSCacheObjectInfo() : ino(0) {}
+
+ void encode(bufferlist& bl) const;
+ void decode(bufferlist::iterator& bl);
+ void dump(Formatter *f) const;
+ static void generate_test_instances(list<MDSCacheObjectInfo*>& ls);
+};
+
+inline std::ostream& operator<<(std::ostream& out, const MDSCacheObjectInfo &info) {
+ if (info.ino) return out << info.ino << "." << info.snapid;
+ if (info.dname.length()) return out << info.dirfrag << "/" << info.dname
+ << " snap " << info.snapid;
+ return out << info.dirfrag;
+}
+
+inline bool operator==(const MDSCacheObjectInfo& l, const MDSCacheObjectInfo& r) {
+ if (l.ino || r.ino)
+ return l.ino == r.ino && l.snapid == r.snapid;
+ else
+ return l.dirfrag == r.dirfrag && l.dname == r.dname;
+}
+WRITE_CLASS_ENCODER(MDSCacheObjectInfo)
+
+
+// parse a map of keys/values.
+namespace qi = boost::spirit::qi;
+
+template <typename Iterator>
+struct keys_and_values
+ : qi::grammar<Iterator, std::map<string, string>()>
+{
+ keys_and_values()
+ : keys_and_values::base_type(query)
+ {
+ query = pair >> *(qi::lit(' ') >> pair);
+ pair = key >> '=' >> value;
+ key = qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");
+ value = +qi::char_("a-zA-Z_0-9");
+ }
+ qi::rule<Iterator, std::map<string, string>()> query;
+ qi::rule<Iterator, std::pair<string, string>()> pair;
+ qi::rule<Iterator, string()> key, value;
+};
+
+#endif
Code Review / stor4nfv.git / blobdiff