ceph-dencoder: MDS - Add missing types

Currently, ceph-dencoder lacks certain mds types, preventing us from accurately checking the ceph corpus for encode-decode mismatches.
This pull request aims to address this issue by adding the missing types to ceph-dencoder.

To successfully incorporate these types into ceph-dencoder, we need to introduce the necessary `dump` and `generate_test_instances`
functions that was missing in some types. These functions are essential for proper encode and decode of the added types.

This PR will enhance the functionality of ceph-dencoder by including the missing types, enabling a comprehensive analysis of encode-decode consistency.
With the addition of these types, we can ensure the robustness and correctness of the ceph corpus.

This update will significantly contribute to improving the overall reliability and accuracy of ceph-dencoder.
It allows for a more comprehensive assessment of the encode-decode behavior, leading to enhanced data integrity and stability within the ceph ecosystem.

Fixes: https://tracker.ceph.com/issues/61788
Signed-off-by: Nitzan Mordechai <nmordech@redhat.com>

diff --git a/src/include/cephfs/metrics/Types.h b/src/include/cephfs/metrics/Types.h
index d7cf5613861119da016162b2019fae3840fc9c95..af377db606e2b54545d6ba8220c28006a92af310 100644 (file)
--- a/src/include/cephfs/metrics/Types.h
+++ b/src/include/cephfs/metrics/Types.h
@@ -688,6 +688,10 @@ public:
     apply_visitor(DumpPayloadVisitor(f), payload);
   }
 
+  static void generate_test_instances(std::list<ClientMetricMessage*>& ls) {
+    ls.push_back(new ClientMetricMessage(CapInfoPayload(1, 2, 3)));
+  }
+
   void print(std::ostream *out) const {
     apply_visitor(PrintPayloadVisitor(out), payload);
   }

diff --git a/src/include/cephfs/types.h b/src/include/cephfs/types.h
index 108878794f755074ceb73f9ec678ce21fa90e06c..f098ab22673075cbad2dc2e13b363f3823b0aa43 100644 (file)
--- a/src/include/cephfs/types.h
+++ b/src/include/cephfs/types.h
@@ -226,7 +226,6 @@ struct vinodeno_t {
     ls.push_back(new vinodeno_t);
     ls.push_back(new vinodeno_t(1, 2));
   }
-
   inodeno_t ino;
   snapid_t snapid;
 };
@@ -371,7 +370,6 @@ public:
   void decode(ceph::buffer::list::const_iterator& bl);
   void dump(ceph::Formatter *f) const;
   static void generate_test_instances(std::list<inline_data_t*>& ls);
-
   version_t version = 1;
 
 private:

diff --git a/src/mds/Capability.cc b/src/mds/Capability.cc
index de2a16e1ab19870bdcb7dc9d4a94dcfae6cb4168..c05a11511af9b62d5bf1e9c9ce16480a8932d250 100644 (file)
--- a/src/mds/Capability.cc
+++ b/src/mds/Capability.cc
@@ -73,14 +73,8 @@ void Capability::Export::dump(ceph::Formatter *f) const
 
 void Capability::Export::generate_test_instances(std::list<Capability::Export*>& ls)
 {
-  ls.push_back(new Export);
-  ls.push_back(new Export);
-  ls.back()->wanted = 1;
-  ls.back()->issued = 2;
-  ls.back()->pending = 3;
-  ls.back()->client_follows = 4;
-  ls.back()->mseq = 5;
-  ls.back()->last_issue_stamp = utime_t(6, 7);
+  ls.push_back(new Export());
+  ls.push_back(new Export(1, 2, 3, 4, 5, 6, 7, utime_t(8, 9), 10));
 }
 
 void Capability::Import::encode(ceph::buffer::list &bl) const
@@ -108,6 +102,11 @@ void Capability::Import::dump(ceph::Formatter *f) const
   f->dump_unsigned("migrate_seq", mseq);
 }
 
+void Capability::Import::generate_test_instances(std::list<Capability::Import*>& ls)
+{
+  ls.push_back(new Import());
+  ls.push_back(new Import(1, 2, 3));
+}
 /*
  * Capability::revoke_info
  */

diff --git a/src/mds/Capability.h b/src/mds/Capability.h
index ebc626a22949ae07d31cfb101f789d26f1ee2274..324c03569cd7fe9cd98e690ed3516f1b1157d70c 100644 (file)
--- a/src/mds/Capability.h
+++ b/src/mds/Capability.h
@@ -100,6 +100,7 @@ public:
     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<Import*>& ls);
 
     int64_t cap_id = 0;
     ceph_seq_t issue_seq = 0;

diff --git a/src/mds/FSMap.cc b/src/mds/FSMap.cc
index 73e4151a9ae6d8264d44b14f6c430b33d02d6e42..6c00d537c8e4949656524c97f06f9d6664241848 100644 (file)
--- a/src/mds/FSMap.cc
+++ b/src/mds/FSMap.cc
@@ -115,6 +115,14 @@ void MirrorInfo::dump(ceph::Formatter *f) const {
   f->close_section(); // peers
 }
 
+void MirrorInfo::generate_test_instances(std::list<MirrorInfo*>& ls) {
+  ls.push_back(new MirrorInfo());
+  ls.push_back(new MirrorInfo());
+  ls.back()->mirrored = true;
+  ls.back()->peers.insert(Peer());
+  ls.back()->peers.insert(Peer());
+}
+
 void MirrorInfo::print(std::ostream& out) const {
   out << "[peers=" << peers << "]" << std::endl;
 }

diff --git a/src/mds/FSMap.h b/src/mds/FSMap.h
index 9d452bb98d954540db314465da24e2171f850923..5b193e76d184804648226787edb48c046def06b7 100644 (file)
--- a/src/mds/FSMap.h
+++ b/src/mds/FSMap.h
@@ -168,6 +168,7 @@ struct MirrorInfo {
   Peers peers;
 
   void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<MirrorInfo*>& ls);
   void print(std::ostream& out) const;
 
   void encode(ceph::buffer::list &bl) const;

diff --git a/src/mds/PurgeQueue.cc b/src/mds/PurgeQueue.cc
index 639c7e85277a60b9d81fd67b4754d459a5e76118..49d15a2cf0ef456882339899a176e494d416bfb2 100644 (file)
--- a/src/mds/PurgeQueue.cc
+++ b/src/mds/PurgeQueue.cc
@@ -99,6 +99,17 @@ void PurgeItem::decode(bufferlist::const_iterator &p)
   DECODE_FINISH(p);
 }
 
+void PurgeItem::generate_test_instances(std::list<PurgeItem*>& ls) {
+  ls.push_back(new PurgeItem());
+  ls.push_back(new PurgeItem());
+  ls.back()->action = PurgeItem::PURGE_FILE;
+  ls.back()->ino = 1;
+  ls.back()->size = 2;
+  ls.back()->layout = file_layout_t();
+  ls.back()->old_pools = {1, 2};
+  ls.back()->snapc = SnapContext();
+  ls.back()->stamp = utime_t(3, 4);
+}
 // if Objecter has any slow requests, take that as a hint and
 // slow down our rate of purging
 PurgeQueue::PurgeQueue(

diff --git a/src/mds/PurgeQueue.h b/src/mds/PurgeQueue.h
index 7bc101e31c4fb955efff77070f5397e8bab05647..bbf260ae70d74ae28650b1c8bc1ec4935baa2119 100644 (file)
--- a/src/mds/PurgeQueue.h
+++ b/src/mds/PurgeQueue.h
@@ -61,6 +61,7 @@ public:
     fragtree.dump(f);
     f->close_section();
   }
+  static void generate_test_instances(std::list<PurgeItem*>& ls);
 
   std::string_view get_type_str() const;
 

diff --git a/src/mds/SessionMap.h b/src/mds/SessionMap.h
index 360dd66a27bb5c24dc3696822d01381450cbf1c8..e2f6692ec546314b07863cde6d721ccf97fe02b8 100644 (file)
--- a/src/mds/SessionMap.h
+++ b/src/mds/SessionMap.h
@@ -574,7 +574,6 @@ public:
   }
 
   static void generate_test_instances(std::list<SessionMapStore*>& ls);
-
   void reset_state()
   {
     session_map.clear();

diff --git a/src/mds/SimpleLock.cc b/src/mds/SimpleLock.cc
index da266e30dab74c642b71695415cc95d4b55422e9..df61384a3ca672bc95652fa2bac1cf8d66947e4b 100644 (file)
--- a/src/mds/SimpleLock.cc
+++ b/src/mds/SimpleLock.cc
@@ -43,6 +43,13 @@ void SimpleLock::dump(ceph::Formatter *f) const {
   f->close_section();
 }
 
+void SimpleLock::generate_test_instances(std::list<SimpleLock*>& ls) {
+  ls.push_back(new SimpleLock);
+  ls.push_back(new SimpleLock);
+  ls.back()->set_state(LOCK_SYNC);
+}
+
+
 int SimpleLock::get_wait_shift() const {
   switch (get_type()) {
     case CEPH_LOCK_DN:       return 0;

diff --git a/src/mds/SimpleLock.h b/src/mds/SimpleLock.h
index 6f1d049ea0aa01ba87b079339d81fe12e780a454..55621549a8ff7488330ff8dc21dec8b9741eae7e 100644 (file)
--- a/src/mds/SimpleLock.h
+++ b/src/mds/SimpleLock.h
@@ -175,6 +175,12 @@ public:
     }
   }
 
+  //for dencoder only
+  SimpleLock() :
+    type(nullptr),
+    parent(nullptr)
+  {}
+
   SimpleLock(MDSCacheObject *o, const LockType *lt) :
     type(lt),
     parent(o)
@@ -199,8 +205,8 @@ public:
 
   // parent
   MDSCacheObject *get_parent() { return parent; }
-  int get_type() const { return type->type; }
-  const sm_t* get_sm() const { return type->sm; }
+  int get_type() const { return (type != nullptr) ? type->type : 0; }
+  const sm_t* get_sm() const { return (type != nullptr) ? type->sm : nullptr; }
 
   int get_cap_shift() const;
   int get_cap_mask() const;
@@ -493,6 +499,7 @@ public:
       encode(empty_gather_set, bl);
     ENCODE_FINISH(bl);
   }
+  
   void decode(ceph::buffer::list::const_iterator& p) {
     DECODE_START(2, p);
     decode(state, p);
@@ -588,6 +595,7 @@ public:
    * to formatter, or nothing if is_sync_and_unlocked.
    */
   void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<SimpleLock*>& ls);
 
   virtual void print(std::ostream& out) const {
     out << "(";

diff --git a/src/mds/flock.cc b/src/mds/flock.cc
index 69d579d30342b274938378f0e55b0a36cf241d93..c126b0f0898cbd733fa637173388626976a4f2ae 100644 (file)
--- a/src/mds/flock.cc
+++ b/src/mds/flock.cc
@@ -37,6 +37,50 @@ ceph_lock_state_t::~ceph_lock_state_t()
   }
 }
 
+void ceph_lock_state_t::dump(ceph::Formatter *f) const {
+  f->dump_int("type", type);
+  f->dump_int("held_locks", held_locks.size());
+  for (auto &p : held_locks) {
+    f->open_object_section("lock");
+    f->dump_int("start", p.second.start);
+    f->dump_int("length", p.second.length);
+    f->dump_int("client", p.second.client);
+    f->dump_int("owner", p.second.owner);
+    f->dump_int("pid", p.second.pid);
+    f->dump_int("type", p.second.type);
+    f->close_section();
+  }
+  f->dump_int("waiting_locks", waiting_locks.size());
+  for (auto &p : waiting_locks) {
+    f->open_object_section("lock");
+    f->dump_int("start", p.second.start);
+    f->dump_int("length", p.second.length);
+    f->dump_int("client", p.second.client);
+    f->dump_int("owner", p.second.owner);
+    f->dump_int("pid", p.second.pid);
+    f->dump_int("type", p.second.type);
+    f->close_section();
+  }
+  f->dump_int("client_held_lock_counts", client_held_lock_counts.size());
+  for (auto &p : client_held_lock_counts) {
+    f->open_object_section("client");
+    f->dump_int("client_id", p.first.v);
+    f->dump_int("count", p.second);
+    f->close_section();
+  }
+  f->dump_int("client_waiting_lock_counts", client_waiting_lock_counts.size());
+}
+
+
+void ceph_lock_state_t::generate_test_instances(std::list<ceph_lock_state_t*>& ls) {
+  ls.push_back(new ceph_lock_state_t(NULL, 0));
+  ls.push_back(new ceph_lock_state_t(NULL, 1));
+  ls.back()->held_locks.insert(std::make_pair(1, ceph_filelock()));
+  ls.back()->waiting_locks.insert(std::make_pair(1, ceph_filelock()));
+  ls.back()->client_held_lock_counts.insert(std::make_pair(1, 1));
+  ls.back()->client_waiting_lock_counts.insert(std::make_pair(1, 1));
+}
+
 bool ceph_lock_state_t::is_waiting(const ceph_filelock &fl) const
 {
   auto p = waiting_locks.find(fl.start);

diff --git a/src/mds/flock.h b/src/mds/flock.h
index 915d912e1ee0022d65e61c0022d95432be6d1378..6871f2decc5c84e9e9cd46fabe137407dcb9239a 100644 (file)
--- a/src/mds/flock.h
+++ b/src/mds/flock.h
@@ -71,6 +71,7 @@ inline bool operator!=(const ceph_filelock& l, const ceph_filelock& r) {
 class ceph_lock_state_t {
 public:
   explicit ceph_lock_state_t(CephContext *cct_, int type_) : cct(cct_), type(type_) {}
+  ceph_lock_state_t() : cct(NULL), type(0) {}
   ~ceph_lock_state_t();
   /**
    * Check if a lock is on the waiting_locks list.
@@ -132,6 +133,8 @@ public:
     decode(held_locks, bl);
     decode(client_held_lock_counts, bl);
   }
+  void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<ceph_lock_state_t*>& ls);
   bool empty() const {
     return held_locks.empty() && waiting_locks.empty() &&
           client_held_lock_counts.empty() &&

diff --git a/src/mds/mdstypes.cc b/src/mds/mdstypes.cc
index 21e17ca0e5bcd718d2f2871660aa1176dbc4d6ca..0769efca9327410c667ef93ee4c68ee08832f842 100644 (file)
--- a/src/mds/mdstypes.cc
+++ b/src/mds/mdstypes.cc
@@ -504,6 +504,15 @@ void feature_bitset_t::dump(Formatter *f) const {
   f->dump_string("feature_bits", css->strv());
 }
 
+void feature_bitset_t::generate_test_instances(std::list<feature_bitset_t*>& ls)
+{
+  ls.push_back(new feature_bitset_t());
+  ls.push_back(new feature_bitset_t());
+  ls.back()->_vec.push_back(1);
+  ls.back()->_vec.push_back(2);
+  ls.back()->_vec.push_back(3);
+}
+
 void feature_bitset_t::print(ostream& out) const
 {
   std::ios_base::fmtflags f(out.flags());
@@ -540,6 +549,13 @@ void metric_spec_t::dump(Formatter *f) const {
   f->dump_object("metric_flags", metric_flags);
 }
 
+void metric_spec_t::generate_test_instances(std::list<metric_spec_t*>& ls)
+{
+  ls.push_back(new metric_spec_t());
+  ls.push_back(new metric_spec_t());
+  ls.back()->metric_flags = 1;
+}
+
 void metric_spec_t::print(ostream& out) const
 {
   out << "{metric_flags: '" << metric_flags << "'}";
@@ -577,6 +593,16 @@ void client_metadata_t::dump(Formatter *f) const
     f->dump_string(name.c_str(), val);
 }
 
+void client_metadata_t::generate_test_instances(std::list<client_metadata_t*>& ls)
+{
+  ls.push_back(new client_metadata_t());
+  ls.push_back(new client_metadata_t());
+  ls.back()->kv_map["key1"] = "val1";
+  ls.back()->kv_map["key2"] = "val2";
+  ls.back()->features = 0x12345678;
+  ls.back()->metric_spec.metric_flags = 0x12345678;
+}
+
 /*
  * session_info_t
  */

diff --git a/src/mds/mdstypes.h b/src/mds/mdstypes.h
index 272ae76cac18d236bc18e38e7c8324ef6cbffb53..347b697ea56b640d1daa0f9178d849356245b869 100644 (file)
--- a/src/mds/mdstypes.h
+++ b/src/mds/mdstypes.h
@@ -348,6 +348,7 @@ public:
   void decode(ceph::buffer::list::const_iterator &p);
   void dump(ceph::Formatter *f) const;
   void print(std::ostream& out) const;
+  static void generate_test_instances(std::list<feature_bitset_t*>& ls);
 private:
   std::vector<block_type> _vec;
 };
@@ -384,6 +385,7 @@ struct metric_spec_t {
   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<metric_spec_t*>& ls);
   void print(std::ostream& out) const;
 
   // set of metrics that a client is capable of forwarding
@@ -430,6 +432,7 @@ struct client_metadata_t {
   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<client_metadata_t*>& ls);
 
   kv_map_t kv_map;
   feature_bitset_t features;
@@ -631,7 +634,10 @@ struct metareqid_t {
   void print(std::ostream& out) const {
     out << name << ":" << tid;
   }
-
+  static void generate_test_instances(std::list<metareqid_t*>& ls) {
+    ls.push_back(new metareqid_t);
+    ls.push_back(new metareqid_t(entity_name_t::CLIENT(123), 456));
+  }
   entity_name_t name;
   uint64_t tid = 0;
 };
@@ -783,6 +789,15 @@ struct dirfrag_t {
     decode(ino, bl);
     decode(frag, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("ino", ino);
+    f->dump_unsigned("frag", frag);
+  }
+  static void generate_test_instances(std::list<dirfrag_t*>& ls) {
+    ls.push_back(new dirfrag_t);
+    ls.push_back(new dirfrag_t(1, frag_t()));
+    ls.push_back(new dirfrag_t(2, frag_t(3)));
+  }
 
   inodeno_t ino = 0;
   frag_t frag;

diff --git a/src/messages/MMDSBeacon.h b/src/messages/MMDSBeacon.h
index ba2d52d11ee3f98a5ff259c649c4ee4ce0b51daa..ccd61144876914d0f41963873f795db81581103e 100644 (file)
--- a/src/messages/MMDSBeacon.h
+++ b/src/messages/MMDSBeacon.h
@@ -151,6 +151,25 @@ struct MDSHealthMetric
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("type", mds_metric_name(type));
+    f->dump_stream("sev") << sev;
+    f->dump_string("message", message);
+    f->open_object_section("metadata");
+    for (auto& i : metadata) {
+      f->dump_string(i.first.c_str(), i.second);
+    }
+    f->close_section();
+  }
+
+  static void generate_test_instances(std::list<MDSHealthMetric*>& ls) {
+    ls.push_back(new MDSHealthMetric());
+    ls.back()->type = MDS_HEALTH_CACHE_OVERSIZED;
+    ls.push_back(new MDSHealthMetric(MDS_HEALTH_TRIM, HEALTH_WARN, "MDS is behind on trimming"));
+    ls.back()->metadata["mds"] = "a";
+    ls.back()->metadata["num"] = "1";
+  }
+
   bool operator==(MDSHealthMetric const &other) const
   {
     return (type == other.type && sev == other.sev && message == other.message);
@@ -183,6 +202,23 @@ struct MDSHealth
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->open_array_section("metrics");
+    for (auto& i : metrics) {
+      f->open_object_section("metric");
+      i.dump(f);
+      f->close_section();
+    }
+    f->close_section();
+  }
+
+  static void generate_test_instances(std::list<MDSHealth*>& ls) {
+    ls.push_back(new MDSHealth);
+    ls.push_back(new MDSHealth);
+    ls.back()->metrics.push_back(MDSHealthMetric(MDS_HEALTH_TRIM, HEALTH_WARN,
+             "MDS is behind on trimming"));
+  }
+
   bool operator==(MDSHealth const &other) const
   {
     return metrics == other.metrics;

diff --git a/src/mgr/DaemonHealthMetric.h b/src/mgr/DaemonHealthMetric.h
index a6fbce29910b7c573f836f29c96344a657a37641..2bc382dde4094926f7bcc9838076fade0d26ec22 100644 (file)
--- a/src/mgr/DaemonHealthMetric.h
+++ b/src/mgr/DaemonHealthMetric.h
@@ -7,6 +7,7 @@
 #include <ostream>
 #include "common/Formatter.h"
 #include "include/denc.h"
+#include "common/Formatter.h"
 
 enum class daemon_metric : uint8_t {
   SLOW_OPS,

diff --git a/src/mgr/MDSPerfMetricTypes.h b/src/mgr/MDSPerfMetricTypes.h
index aa35b8cab0fc2037390df6e3f4de9cb312ceca80..2323afcdd1bbd901ec382d03bccd87c1acfbea90 100644 (file)
--- a/src/mgr/MDSPerfMetricTypes.h
+++ b/src/mgr/MDSPerfMetricTypes.h
@@ -10,6 +10,7 @@
 
 #include "include/denc.h"
 #include "include/stringify.h"
+#include "common/Formatter.h"
 
 #include "mds/mdstypes.h"
 #include "mgr/Types.h"
@@ -40,7 +41,7 @@ struct MDSPerfMetricSubKeyDescriptor {
   MDSPerfMetricSubKeyDescriptor() {
   }
   MDSPerfMetricSubKeyDescriptor(MDSPerfMetricSubKeyType type, const std::string &regex_str)
-    : type(type), regex_str(regex_str) {
+      : type(type), regex_str(regex_str) {
   }
 
   bool operator<(const MDSPerfMetricSubKeyDescriptor &other) const {
@@ -59,6 +60,10 @@ struct MDSPerfMetricSubKeyDescriptor {
     denc(v.regex_str, p);
     DENC_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("type", static_cast<uint8_t>(type));
+    f->dump_string("regex_str", regex_str);
+  }
 };
 WRITE_CLASS_DENC(MDSPerfMetricSubKeyDescriptor)
 
@@ -77,7 +82,7 @@ struct denc_traits<MDSPerfMetricKeyDescriptor> {
     if (size) {
       size_t per = 0;
       denc(v.front(), per);
-      p +=  per * size;
+      p += per * size;
     }
   }
   static void encode(const MDSPerfMetricKeyDescriptor& v,
@@ -183,6 +188,9 @@ struct MDSPerformanceCounterDescriptor {
     denc(v.type, p);
     DENC_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("type", static_cast<uint8_t>(type));
+  }
 
   void pack_counter(const PerformanceCounter &c, ceph::buffer::list *bl) const;
   void unpack_counter(ceph::buffer::list::const_iterator& bl, PerformanceCounter *c) const;
@@ -204,7 +212,7 @@ struct denc_traits<MDSPerformanceCounterDescriptors> {
     if (size) {
       size_t per = 0;
       denc(v.front(), per);
-      p +=  per * size;
+      p += per * size;
     }
   }
   static void encode(const MDSPerformanceCounterDescriptors& v,
@@ -237,7 +245,7 @@ struct MDSPerfMetricLimit {
   MDSPerfMetricLimit() {
   }
   MDSPerfMetricLimit(const MDSPerformanceCounterDescriptor &order_by, uint64_t max_count)
-    : order_by(order_by), max_count(max_count) {
+      : order_by(order_by), max_count(max_count) {
   }
 
   bool operator<(const MDSPerfMetricLimit &other) const {
@@ -254,6 +262,10 @@ struct MDSPerfMetricLimit {
     denc(v.max_count, p);
     DENC_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("order_by", order_by);
+    f->dump_unsigned("max_count", max_count);
+  }
 };
 WRITE_CLASS_DENC(MDSPerfMetricLimit)
 
@@ -268,7 +280,7 @@ struct MDSPerfMetricQuery {
   }
   MDSPerfMetricQuery(const MDSPerfMetricKeyDescriptor &key_descriptor,
                      const MDSPerformanceCounterDescriptors &performance_counter_descriptors)
-    : key_descriptor(key_descriptor),
+      : key_descriptor(key_descriptor),
       performance_counter_descriptors(performance_counter_descriptors)
   {
   }
@@ -320,6 +332,11 @@ struct MDSPerfMetricQuery {
     DENC_FINISH(p);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_stream("key_descriptor") << key_descriptor;
+    f->dump_stream("performance_counter_descriptors") << performance_counter_descriptors;
+  }
+
   void pack_counters(const PerformanceCounters &counters, ceph::buffer::list *bl) const;
 };
 WRITE_CLASS_DENC(MDSPerfMetricQuery)
@@ -332,7 +349,7 @@ struct MDSPerfCollector : PerfCollector {
   utime_t last_updated_mono;
 
   MDSPerfCollector(MetricQueryID query_id)
-    : PerfCollector(query_id) {
+      : PerfCollector(query_id) {
   }
 };
 
@@ -346,6 +363,15 @@ struct MDSPerfMetrics {
     denc(v.group_packed_performance_counters, p);
     DENC_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_stream("performance_counter_descriptors") << performance_counter_descriptors;
+    f->open_array_section("group_packed_performance_counters");
+    for (auto &i : group_packed_performance_counters) {
+      f->dump_stream("key") << i.first;
+      f->dump_stream("value") << i.second;
+    }
+    f->close_section();
+  }
 };
 
 struct MDSPerfMetricReport {
@@ -359,6 +385,24 @@ struct MDSPerfMetricReport {
     denc(v.rank_metrics_delayed, p);
     DENC_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->open_array_section("reports");
+    for (auto &i : reports) {
+      f->open_object_section("query");
+      f->dump_object("query",i.first);
+      f->close_section();
+      f->open_object_section("metrics");
+      f->dump_object("metrics",i.second);
+      f->close_section();
+    }
+    f->close_section();
+  }
+  static void generate_test_instances(std::list<MDSPerfMetricReport *> &o) {
+    o.push_back(new MDSPerfMetricReport);
+    o.push_back(new MDSPerfMetricReport);
+    o.back()->reports.emplace(MDSPerfMetricQuery(), MDSPerfMetrics());
+    o.back()->rank_metrics_delayed.insert(1);
+  }
 };
 
 WRITE_CLASS_DENC(MDSPerfMetrics)

diff --git a/src/mgr/MetricTypes.h b/src/mgr/MetricTypes.h
index 762564f37ee198c0616c1d124963afbc5ed9994e..9bfd3fa0e254c952064d4dda40e0a2b1682a296b 100644 (file)
--- a/src/mgr/MetricTypes.h
+++ b/src/mgr/MetricTypes.h
@@ -32,11 +32,19 @@ struct OSDMetricPayload {
   }
 
   void dump(ceph::Formatter *f) const {
-    encode_json("report", report, f);
+    f->open_array_section("report");
+    for (auto& i : report) {
+      f->open_object_section("query");
+      i.first.dump(f);
+      f->close_section();
+      f->open_object_section("report");
+      i.second.dump(f);
+      f->close_section();
+    }
+    f->close_section();
   }
-
   static void generate_test_instances(std::list<OSDMetricPayload*>& ls) {
-    ls.push_back(new OSDMetricPayload);
+    ls.push_back(new OSDMetricPayload());
   }
 };
 
@@ -55,6 +63,12 @@ struct MDSMetricPayload {
     denc(v.metric_report, p);
     DENC_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    metric_report.dump(f);
+  }
+  static void generate_test_instances(std::list<MDSMetricPayload*>& ls) {
+    ls.push_back(new MDSMetricPayload());
+  }
 };
 
 struct UnknownMetricPayload {
@@ -65,6 +79,10 @@ struct UnknownMetricPayload {
   DENC(UnknownMetricPayload, v, p) {
     ceph_abort();
   }
+
+  void dump(ceph::Formatter *f) const {
+    ceph_abort();
+  }
 };
 
 WRITE_CLASS_DENC(OSDMetricPayload)
@@ -145,6 +163,23 @@ struct MetricReportMessage {
 
   boost::apply_visitor(DecodeMetricPayloadVisitor(iter), payload);
   }
+  void dump(ceph::Formatter *f) const {
+    f->open_object_section("payload");
+    if (const OSDMetricPayload* osdPayload = boost::get<OSDMetricPayload>(&payload)) {
+      osdPayload->dump(f);
+    } else if (const MDSMetricPayload* mdsPayload = boost::get<MDSMetricPayload>(&payload)) {
+      mdsPayload->dump(f);
+    } else if (const UnknownMetricPayload* unknownPayload = boost::get<UnknownMetricPayload>(&payload)) {
+      unknownPayload->dump(f);
+    } else {
+      ceph_abort();
+    }
+    f->close_section();
+  }
+  static void generate_test_instances(std::list<MetricReportMessage*>& ls) {
+    ls.push_back(new MetricReportMessage(OSDMetricPayload()));
+    ls.push_back(new MetricReportMessage(MDSMetricPayload()));
+  }
 };
 
 WRITE_CLASS_ENCODER(MetricReportMessage);
@@ -188,6 +223,22 @@ struct MDSConfigPayload {
     denc(v.config, p);
     DENC_FINISH(p);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->open_object_section("config");
+    for (auto& i : config) {
+      f->dump_object("query", i.first);
+      f->open_object_section("limits");
+      for (auto& j : i.second) {
+        f->dump_object("limit", j);
+      }
+      f->close_section();
+    }
+    f->close_section();
+  }
+  static void generate_test_instances(std::list<MDSConfigPayload*>& ls) {
+    ls.push_back(new MDSConfigPayload);
+  }
 };
 
 struct UnknownConfigPayload {

diff --git a/src/mgr/OSDPerfMetricTypes.h b/src/mgr/OSDPerfMetricTypes.h
index 8dd0afd8cb4550593bd04bc5075fc7aeb55050e0..aba27f284a42d7c1549656141a7f6ecf1781afd1 100644 (file)
--- a/src/mgr/OSDPerfMetricTypes.h
+++ b/src/mgr/OSDPerfMetricTypes.h
@@ -7,6 +7,8 @@
 #include "common/ceph_json.h"
 #include "include/denc.h"
 #include "include/stringify.h"
+#include "common/Formatter.h"
+
 #include "mgr/Types.h"
 
 #include <regex>
@@ -70,7 +72,6 @@ struct OSDPerfMetricSubKeyDescriptor {
     denc(v.regex_str, p);
     DENC_FINISH(p);
   }
-
   void dump(ceph::Formatter *f) const {
     f->dump_unsigned("type", static_cast<uint8_t>(type));
     f->dump_string("regex", regex_str);

diff --git a/src/tools/ceph-dencoder/mds_types.h b/src/tools/ceph-dencoder/mds_types.h
index 91ba86be0d1ec30857e169ba2d3d46f3851f0320..1272017c438ebfea680bcd2aabc7714acb21485d 100644 (file)
--- a/src/tools/ceph-dencoder/mds_types.h
+++ b/src/tools/ceph-dencoder/mds_types.h
@@ -10,13 +10,22 @@ TYPE(SnapInfo)
 TYPE(snaplink_t)
 TYPE(sr_t)
 
-#include "mds/mdstypes.h"
+#include "mds/SimpleLock.h"
+TYPE_NOCOPY(SimpleLock)
+
+#include "mds/PurgeQueue.h"
+TYPE(PurgeItem)
+
+#include "mds/Anchor.h"
+TYPE(Anchor)
+
 #include "include/cephfs/types.h"
 TYPE(frag_info_t)
 TYPE(nest_info_t)
 TYPE(quota_info_t)
 TYPE(client_writeable_range_t)
 TYPE_FEATUREFUL(inode_t<std::allocator>)
+//TYPE(inode_t<std::allocator>)
 TYPE_FEATUREFUL(old_inode_t<std::allocator>)
 TYPE(fnode_t)
 TYPE(old_rstat_t)
@@ -31,6 +40,10 @@ TYPE(mds_load_t)
 TYPE(MDSCacheObjectInfo)
 TYPE(inode_backtrace_t)
 TYPE(inode_backpointer_t)
+TYPE(vinodeno_t)
+
+#include "include/cephfs/metrics/Types.h"
+TYPE(ClientMetricMessage)
 
 #include "mds/CInode.h"
 TYPE_FEATUREFUL(InodeStore)
@@ -40,12 +53,18 @@ TYPE_FEATUREFUL(InodeStoreBare)
 TYPE_FEATUREFUL(MDSMap)
 TYPE_FEATUREFUL(MDSMap::mds_info_t)
 
+#include "mds/flock.h"
+TYPE(ceph_lock_state_t)
+
 #include "mds/FSMap.h"
 //TYPE_FEATUREFUL(Filesystem)
 TYPE_FEATUREFUL(FSMap)
+TYPE(MirrorInfo)
 
 #include "mds/Capability.h"
 TYPE_NOCOPY(Capability)
+TYPE(Capability::Export)
+TYPE(Capability::Import)
 
 #include "mds/inode_backtrace.h"
 TYPE(inode_backpointer_t)
@@ -54,8 +73,11 @@ TYPE(inode_backtrace_t)
 #include "mds/InoTable.h"
 TYPE(InoTable)
 
+#include "mds/SessionMap.h"
+//TYPE_FEATUREFUL(SessionMapStore)
+
 #include "mds/SnapServer.h"
-TYPE_STRAYDATA(SnapServer)
+TYPE_FEATUREFUL(SnapServer)
 
 #include "mds/events/ECommitted.h"
 TYPE_FEATUREFUL_NOCOPY(ECommitted)
@@ -109,4 +131,22 @@ TYPE_FEATUREFUL_NOCOPY(ETableServer)
 
 #include "mds/events/EUpdate.h"
 TYPE_FEATUREFUL_NOCOPY(EUpdate)
+
+#include "mgr/MetricTypes.h"
+TYPE(MDSMetricPayload)
+TYPE(MetricReportMessage)
+TYPE(MDSConfigPayload)
+
+#include "mds/mdstypes.h"
+TYPE(metareqid_t)
+TYPE(feature_bitset_t)
+TYPE(dirfrag_t)
+TYPE(client_metadata_t)
+TYPE(MDSPerfMetricReport)
+TYPE(metric_spec_t)
+
+#include "messages/MMDSBeacon.h"
+TYPE(MDSHealthMetric)
+TYPE(MDSHealth)
+
 #endif // WITH_CEPHFS