mds: add opened files/inodes and pinned i_caps metric payload support

Fixes: https://tracker.ceph.com/issues/46865
Signed-off-by: Xiubo Li <xiubli@redhat.com>

diff --git a/src/client/Client.cc b/src/client/Client.cc
index aaf9db20c35423a2a1496616a5a3f845c18541ab..74ab0906cc4c5e8387d2dc908f8c76c80dc4f13d 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -4185,6 +4185,8 @@ void Client::add_update_cap(Inode *in, MetaSession *mds_session, uint64_t cap_id
       issued |= cap.issued;
       flags |= CEPH_CAP_FLAG_AUTH;
     }
+  } else {
+    inc_pinned_icaps();
   }
 
   check_cap_issue(in, issued);
@@ -4250,8 +4252,11 @@ void Client::remove_cap(Cap *cap, bool queue_release)
       cap->issue_seq,
       cap->mseq,
       cap_epoch_barrier);
+  } else {
+    dec_pinned_icaps();
   }
 
+
   if (in.auth_cap == cap) {
     if (in.flushing_cap_item.is_on_list()) {
       ldout(cct, 10) << " removing myself from flushing_cap list" << dendl;
@@ -6423,11 +6428,14 @@ void Client::abort_conn()
 
 void Client::flush_cap_releases()
 {
+  uint64_t nr_caps = 0;
+
   // send any cap releases
   for (auto &p : mds_sessions) {
     auto &session = p.second;
     if (session.release && mdsmap->is_clientreplay_or_active_or_stopping(
           p.first)) {
+      nr_caps += session.release->caps.size();
       if (cct->_conf->client_inject_release_failure) {
         ldout(cct, 20) << __func__ << " injecting failure to send cap release message" << dendl;
       } else {
@@ -6436,6 +6444,10 @@ void Client::flush_cap_releases()
       session.release.reset();
     }
   }
+
+  if (nr_caps > 0) {
+    dec_pinned_icaps(nr_caps);
+  }
 }
 
 void Client::renew_and_flush_cap_releases()
@@ -6596,6 +6608,27 @@ void Client::collect_and_send_global_metrics() {
   metric = ClientMetricMessage(DentryLeasePayload(dlease_hits, dlease_misses, nr));
   message.push_back(metric);
 
+  // opened files
+  {
+    auto [opened_files, total_inodes] = get_opened_files_rates();
+    metric = ClientMetricMessage(OpenedFilesPayload(opened_files, total_inodes));
+  }
+  message.push_back(metric);
+
+  // pinned i_caps
+  {
+    auto [pinned_icaps, total_inodes] = get_pinned_icaps_rates();
+    metric = ClientMetricMessage(PinnedIcapsPayload(pinned_icaps, total_inodes));
+  }
+  message.push_back(metric);
+
+  // opened inodes
+  {
+    auto [opened_inodes, total_inodes] = get_opened_inodes_rates();
+    metric = ClientMetricMessage(OpenedInodesPayload(opened_inodes, total_inodes));
+  }
+  message.push_back(metric);
+
   session->con->send_message2(make_message<MClientMetrics>(std::move(message)));
 }
 

diff --git a/src/client/Client.h b/src/client/Client.h
index 01f469ea1baa1eb5ef0401c4ebb0c05484f139c7..8c89deb67f451104e4c4e4fbaad65fdfa727c096 100644 (file)
--- a/src/client/Client.h
+++ b/src/client/Client.h
@@ -769,6 +769,36 @@ public:
     return std::make_pair(cap_hits, cap_misses);
   }
 
+  void inc_opened_files() {
+    ++opened_files;
+  }
+  void dec_opened_files() {
+    --opened_files;
+  }
+  std::pair<uint64_t, uint64_t> get_opened_files_rates() {
+    return std::make_pair(opened_files, inode_map.size());
+  }
+
+  void inc_pinned_icaps() {
+    ++pinned_icaps;
+  }
+  void dec_pinned_icaps(uint64_t nr=1) {
+    pinned_icaps -= nr;
+  }
+  std::pair<uint64_t, uint64_t> get_pinned_icaps_rates() {
+    return std::make_pair(pinned_icaps, inode_map.size());
+  }
+
+  void inc_opened_inodes() {
+    ++opened_inodes;
+  }
+  void dec_opened_inodes() {
+    --opened_inodes;
+  }
+  std::pair<uint64_t, uint64_t> get_opened_inodes_rates() {
+    return std::make_pair(opened_inodes, inode_map.size());
+  }
+
   xlist<Inode*> &get_dirty_list() { return dirty_list; }
 
   /* timer_lock for 'timer' */
@@ -1456,6 +1486,10 @@ private:
   uint64_t cap_hits = 0;
   uint64_t cap_misses = 0;
 
+  uint64_t opened_files = 0;
+  uint64_t pinned_icaps = 0;
+  uint64_t opened_inodes = 0;
+
   ceph::spinlock delay_i_lock;
   std::map<Inode*,int> delay_i_release;
 };

diff --git a/src/client/Inode.cc b/src/client/Inode.cc
index b4fe5d84252c46ef54cd95637265927a4044a5b4..a1e9a3ad981dccb15664aa005de957548469c6b4 100644 (file)
--- a/src/client/Inode.cc
+++ b/src/client/Inode.cc
@@ -137,6 +137,9 @@ void Inode::make_nosnap_relative_path(filepath& p)
 
 void Inode::get_open_ref(int mode)
 {
+  client->inc_opened_files();
+  if (open_by_mode.count(mode) == 0)
+    client->inc_opened_inodes();
   open_by_mode[mode]++;
   break_deleg(!(mode & CEPH_FILE_MODE_WR));
 }
@@ -146,8 +149,11 @@ bool Inode::put_open_ref(int mode)
   //cout << "open_by_mode[" << mode << "] " << open_by_mode[mode] << " -> " << (open_by_mode[mode]-1) << std::endl;
   auto& ref = open_by_mode.at(mode);
   ceph_assert(ref > 0);
-  if (--ref == 0)
+  client->dec_opened_files();
+  if (--ref == 0) {
+    client->dec_opened_inodes();
     return true;
+  }
   return false;
 }
 

diff --git a/src/include/cephfs/metrics/Types.h b/src/include/cephfs/metrics/Types.h
index 160bfa1d174e1dd12449ba2e897a6512227dd4e5..3f2b642fdb3d54e9c16d736339796a20355b9958 100644 (file)
--- a/src/include/cephfs/metrics/Types.h
+++ b/src/include/cephfs/metrics/Types.h
@@ -22,6 +22,9 @@ enum ClientMetricType {
   CLIENT_METRIC_TYPE_WRITE_LATENCY,
   CLIENT_METRIC_TYPE_METADATA_LATENCY,
   CLIENT_METRIC_TYPE_DENTRY_LEASE,
+  CLIENT_METRIC_TYPE_OPENED_FILES,
+  CLIENT_METRIC_TYPE_PINNED_ICAPS,
+  CLIENT_METRIC_TYPE_OPENED_INODES,
 };
 inline std::ostream &operator<<(std::ostream &os, const ClientMetricType &type) {
   switch(type) {
@@ -40,6 +43,15 @@ inline std::ostream &operator<<(std::ostream &os, const ClientMetricType &type)
   case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE:
     os << "DENTRY_LEASE";
     break;
+  case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES:
+    os << "OPENED_FILES";
+    break;
+  case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS:
+    os << "PINNED_ICAPS";
+    break;
+  case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES:
+    os << "OPENED_INODES";
+    break;
   default:
     ceph_abort();
   }
@@ -232,6 +244,120 @@ struct DentryLeasePayload {
   }
 };
 
+struct OpenedFilesPayload {
+  static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES;
+
+  uint64_t opened_files = 0;
+  uint64_t total_inodes = 0;
+
+  OpenedFilesPayload() { }
+  OpenedFilesPayload(uint64_t opened_files, uint64_t total_inodes)
+    : opened_files(opened_files), total_inodes(total_inodes) {
+  }
+
+  void encode(bufferlist &bl) const {
+    using ceph::encode;
+    ENCODE_START(1, 1, bl);
+    encode(opened_files, bl);
+    encode(total_inodes, bl);
+    ENCODE_FINISH(bl);
+  }
+
+  void decode(bufferlist::const_iterator &iter) {
+    using ceph::decode;
+    DECODE_START(1, iter);
+    decode(opened_files, iter);
+    decode(total_inodes, iter);
+    DECODE_FINISH(iter);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_int("opened_files", opened_files);
+    f->dump_int("total_inodes", total_inodes);
+  }
+
+  void print(ostream *out) const {
+    *out << "opened_files: " << opened_files << " "
+        << "total_inodes: " << total_inodes;
+  }
+};
+
+struct PinnedIcapsPayload {
+  static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS;
+
+  uint64_t pinned_icaps = 0;
+  uint64_t total_inodes = 0;
+
+  PinnedIcapsPayload() { }
+  PinnedIcapsPayload(uint64_t pinned_icaps, uint64_t total_inodes)
+    : pinned_icaps(pinned_icaps), total_inodes(total_inodes) {
+  }
+
+  void encode(bufferlist &bl) const {
+    using ceph::encode;
+    ENCODE_START(1, 1, bl);
+    encode(pinned_icaps, bl);
+    encode(total_inodes, bl);
+    ENCODE_FINISH(bl);
+  }
+
+  void decode(bufferlist::const_iterator &iter) {
+    using ceph::decode;
+    DECODE_START(1, iter);
+    decode(pinned_icaps, iter);
+    decode(total_inodes, iter);
+    DECODE_FINISH(iter);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_int("pinned_icaps", pinned_icaps);
+    f->dump_int("total_inodes", total_inodes);
+  }
+
+  void print(ostream *out) const {
+    *out << "pinned_icaps: " << pinned_icaps << " "
+        << "total_inodes: " << total_inodes;
+  }
+};
+
+struct OpenedInodesPayload {
+  static const ClientMetricType METRIC_TYPE = ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES;
+
+  uint64_t opened_inodes = 0;
+  uint64_t total_inodes = 0;
+
+  OpenedInodesPayload() { }
+  OpenedInodesPayload(uint64_t opened_inodes, uint64_t total_inodes)
+    : opened_inodes(opened_inodes), total_inodes(total_inodes) {
+  }
+
+  void encode(bufferlist &bl) const {
+    using ceph::encode;
+    ENCODE_START(1, 1, bl);
+    encode(opened_inodes, bl);
+    encode(total_inodes, bl);
+    ENCODE_FINISH(bl);
+  }
+
+  void decode(bufferlist::const_iterator &iter) {
+    using ceph::decode;
+    DECODE_START(1, iter);
+    decode(opened_inodes, iter);
+    decode(total_inodes, iter);
+    DECODE_FINISH(iter);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_int("opened_inodes", opened_inodes);
+    f->dump_int("total_inodes", total_inodes);
+  }
+
+  void print(ostream *out) const {
+    *out << "opened_inodes: " << opened_inodes << " "
+        << "total_inodes: " << total_inodes;
+  }
+};
+
 struct UnknownPayload {
   static const ClientMetricType METRIC_TYPE = static_cast<ClientMetricType>(-1);
 
@@ -255,6 +381,9 @@ typedef boost::variant<CapInfoPayload,
                        WriteLatencyPayload,
                        MetadataLatencyPayload,
                       DentryLeasePayload,
+                      OpenedFilesPayload,
+                      PinnedIcapsPayload,
+                      OpenedInodesPayload,
                        UnknownPayload> ClientMetricPayload;
 
 // metric update message sent by clients
@@ -354,6 +483,15 @@ public:
     case ClientMetricType::CLIENT_METRIC_TYPE_DENTRY_LEASE:
       payload = DentryLeasePayload();
       break;
+    case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_FILES:
+      payload = OpenedFilesPayload();
+      break;
+    case ClientMetricType::CLIENT_METRIC_TYPE_PINNED_ICAPS:
+      payload = PinnedIcapsPayload();
+      break;
+    case ClientMetricType::CLIENT_METRIC_TYPE_OPENED_INODES:
+      payload = OpenedInodesPayload();
+      break;
     default:
       payload = UnknownPayload();
       break;

diff --git a/src/mds/MDSPerfMetricTypes.h b/src/mds/MDSPerfMetricTypes.h
index ff1ad65d7f45c96abe9a1b919a35b0013694a689..de69a4277b4aa958f40239df893f6444f1f12c24 100644 (file)
--- a/src/mds/MDSPerfMetricTypes.h
+++ b/src/mds/MDSPerfMetricTypes.h
@@ -127,11 +127,89 @@ struct DentryLeaseHitMetric {
   }
 };
 
+struct OpenedFilesMetric {
+  uint64_t opened_files = 0;
+  uint64_t total_inodes = 0;
+  bool updated = false;
+
+  DENC(OpenedFilesMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.opened_files, p);
+    denc(v.total_inodes, p);
+    denc(v.updated, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_unsigned("opened_files", opened_files);
+    f->dump_unsigned("total_inodes", total_inodes);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const OpenedFilesMetric &metric) {
+    os << "{opened_files=" << metric.opened_files  << ", total_inodes="
+       << metric.total_inodes << "}";
+    return os;
+  }
+};
+
+struct PinnedIcapsMetric {
+  uint64_t pinned_icaps = 0;
+  uint64_t total_inodes = 0;
+  bool updated = false;
+
+  DENC(PinnedIcapsMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.pinned_icaps, p);
+    denc(v.total_inodes, p);
+    denc(v.updated, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_unsigned("pinned_icaps", pinned_icaps);
+    f->dump_unsigned("total_inodes", total_inodes);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const PinnedIcapsMetric &metric) {
+    os << "{pinned_icaps=" << metric.pinned_icaps << ", total_inodes="
+       << metric.total_inodes << "}";
+    return os;
+  }
+};
+
+struct OpenedInodesMetric {
+  uint64_t opened_inodes = 0;
+  uint64_t total_inodes = 0;
+  bool updated = false;
+
+  DENC(OpenedInodesMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.opened_inodes, p);
+    denc(v.total_inodes, p);
+    denc(v.updated, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_unsigned("opened_inodes", opened_inodes);
+    f->dump_unsigned("total_inodes", total_inodes);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const OpenedInodesMetric &metric) {
+    os << "{opened_inodes=" << metric.opened_inodes << ", total_inodes="
+       << metric.total_inodes << "}";
+    return os;
+  }
+};
+
 WRITE_CLASS_DENC(CapHitMetric)
 WRITE_CLASS_DENC(ReadLatencyMetric)
 WRITE_CLASS_DENC(WriteLatencyMetric)
 WRITE_CLASS_DENC(MetadataLatencyMetric)
 WRITE_CLASS_DENC(DentryLeaseHitMetric)
+WRITE_CLASS_DENC(OpenedFilesMetric)
+WRITE_CLASS_DENC(PinnedIcapsMetric)
+WRITE_CLASS_DENC(OpenedInodesMetric)
 
 // metrics that are forwarded to the MDS by client(s).
 struct Metrics {
@@ -141,12 +219,15 @@ struct Metrics {
   WriteLatencyMetric write_latency_metric;
   MetadataLatencyMetric metadata_latency_metric;
   DentryLeaseHitMetric dentry_lease_metric;
+  OpenedFilesMetric opened_files_metric;
+  PinnedIcapsMetric pinned_icaps_metric;
+  OpenedInodesMetric opened_inodes_metric;
 
   // metric update type
   uint32_t update_type = UpdateType::UPDATE_TYPE_REFRESH;
 
   DENC(Metrics, v, p) {
-    DENC_START(2, 1, p);
+    DENC_START(3, 1, p);
     denc(v.update_type, p);
     denc(v.cap_hit_metric, p);
     denc(v.read_latency_metric, p);
@@ -155,6 +236,11 @@ struct Metrics {
     if (struct_v >= 2) {
       denc(v.dentry_lease_metric, p);
     }
+    if (struct_v >= 3) {
+      denc(v.opened_files_metric, p);
+      denc(v.pinned_icaps_metric, p);
+      denc(v.opened_inodes_metric, p);
+    }
     DENC_FINISH(p);
   }
 
@@ -165,6 +251,9 @@ struct Metrics {
     f->dump_object("write_latency_metric", write_latency_metric);
     f->dump_object("metadata_latency_metric", metadata_latency_metric);
     f->dump_object("dentry_lease_metric", dentry_lease_metric);
+    f->dump_object("opened_files_metric", opened_files_metric);
+    f->dump_object("pinned_icaps_metric", pinned_icaps_metric);
+    f->dump_object("opened_inodes_metric", opened_inodes_metric);
   }
 
   friend std::ostream& operator<<(std::ostream& os, const Metrics& metrics) {
@@ -174,6 +263,9 @@ struct Metrics {
        << ", write_latency=" << metrics.write_latency_metric
        << ", metadata_latency=" << metrics.metadata_latency_metric
        << ", dentry_lease =" << metrics.dentry_lease_metric
+       << ", opened_files_metric =" << metrics.opened_files_metric
+       << ", pinned_icaps_metric =" << metrics.pinned_icaps_metric
+       << ", opened_inodes_metric =" << metrics.opened_inodes_metric
        << "}]";
     return os;
   }

diff --git a/src/mds/MetricAggregator.cc b/src/mds/MetricAggregator.cc
index c5e6fe3bbaf087eae3c445a076ac48f34adf8d52..8d98db5fd49d09586ff06d1bf730c851bdc14e96 100644 (file)
--- a/src/mds/MetricAggregator.cc
+++ b/src/mds/MetricAggregator.cc
@@ -138,6 +138,24 @@ void MetricAggregator::refresh_metrics_for_rank(const entity_inst_t &client,
         c->second = metrics.dentry_lease_metric.misses;
       }
       break;
+    case MDSPerformanceCounterType::OPENED_FILES_METRIC:
+      if (metrics.opened_files_metric.updated) {
+        c->first = metrics.opened_files_metric.opened_files;
+        c->second = metrics.opened_files_metric.total_inodes;
+      }
+      break;
+    case MDSPerformanceCounterType::PINNED_ICAPS_METRIC:
+      if (metrics.pinned_icaps_metric.updated) {
+        c->first = metrics.pinned_icaps_metric.pinned_icaps;
+        c->second = metrics.pinned_icaps_metric.total_inodes;
+      }
+      break;
+    case MDSPerformanceCounterType::OPENED_INODES_METRIC:
+      if (metrics.opened_inodes_metric.updated) {
+        c->first = metrics.opened_inodes_metric.opened_inodes;
+        c->second = metrics.opened_inodes_metric.total_inodes;
+      }
+      break;
     default:
       ceph_abort_msg("unknown counter type");
     }

diff --git a/src/mds/MetricsHandler.cc b/src/mds/MetricsHandler.cc
index 781a41581db47d3d7a076067fd025955855e5236..f003c5459576b01cefb87af3d99b0cec2cc8db57 100644 (file)
--- a/src/mds/MetricsHandler.cc
+++ b/src/mds/MetricsHandler.cc
@@ -124,6 +124,9 @@ void MetricsHandler::remove_session(Session *session) {
   metrics.write_latency_metric = { };
   metrics.metadata_latency_metric = { };
   metrics.dentry_lease_metric = { };
+  metrics.opened_files_metric = { };
+  metrics.pinned_icaps_metric = { };
+  metrics.opened_inodes_metric = { };
   metrics.update_type = UPDATE_TYPE_REMOVE;
 }
 
@@ -221,6 +224,57 @@ void MetricsHandler::handle_payload(Session *session, const DentryLeasePayload &
   metrics.dentry_lease_metric.updated = true;
 }
 
+void MetricsHandler::handle_payload(Session *session, const OpenedFilesPayload &payload) {
+  dout(20) << ": type=" << static_cast<ClientMetricType>(OpenedFilesPayload::METRIC_TYPE)
+           << ", session=" << session << ", opened_files=" << payload.opened_files
+           << ", total_inodes=" << payload.total_inodes << dendl;
+
+  auto it = client_metrics_map.find(session->info.inst);
+  if (it == client_metrics_map.end()) {
+    return;
+  }
+
+  auto &metrics = it->second.second;
+  metrics.update_type = UPDATE_TYPE_REFRESH;
+  metrics.opened_files_metric.opened_files = payload.opened_files;
+  metrics.opened_files_metric.total_inodes = payload.total_inodes;
+  metrics.opened_files_metric.updated = true;
+}
+
+void MetricsHandler::handle_payload(Session *session, const PinnedIcapsPayload &payload) {
+  dout(20) << ": type=" << static_cast<ClientMetricType>(PinnedIcapsPayload::METRIC_TYPE)
+           << ", session=" << session << ", pinned_icaps=" << payload.pinned_icaps
+           << ", total_inodes=" << payload.total_inodes << dendl;
+
+  auto it = client_metrics_map.find(session->info.inst);
+  if (it == client_metrics_map.end()) {
+    return;
+  }
+
+  auto &metrics = it->second.second;
+  metrics.update_type = UPDATE_TYPE_REFRESH;
+  metrics.pinned_icaps_metric.pinned_icaps = payload.pinned_icaps;
+  metrics.pinned_icaps_metric.total_inodes = payload.total_inodes;
+  metrics.pinned_icaps_metric.updated = true;
+}
+
+void MetricsHandler::handle_payload(Session *session, const OpenedInodesPayload &payload) {
+  dout(20) << ": type=" << static_cast<ClientMetricType>(OpenedInodesPayload::METRIC_TYPE)
+           << ", session=" << session << ", opened_inodes=" << payload.opened_inodes
+           << ", total_inodes=" << payload.total_inodes << dendl;
+
+  auto it = client_metrics_map.find(session->info.inst);
+  if (it == client_metrics_map.end()) {
+    return;
+  }
+
+  auto &metrics = it->second.second;
+  metrics.update_type = UPDATE_TYPE_REFRESH;
+  metrics.opened_inodes_metric.opened_inodes = payload.opened_inodes;
+  metrics.opened_inodes_metric.total_inodes = payload.total_inodes;
+  metrics.opened_inodes_metric.updated = true;
+}
+
 void MetricsHandler::handle_payload(Session *session, const UnknownPayload &payload) {
   dout(5) << ": type=Unknown, session=" << session << ", ignoring unknown payload" << dendl;
 }

diff --git a/src/mds/MetricsHandler.h b/src/mds/MetricsHandler.h
index e03c2c43104ade18a9d5fdf932c26faf34c1e922..65bcf488b5f064fb7c958155e43fef28700c0538 100644 (file)
--- a/src/mds/MetricsHandler.h
+++ b/src/mds/MetricsHandler.h
@@ -95,6 +95,9 @@ private:
   void handle_payload(Session *session, const WriteLatencyPayload &payload);
   void handle_payload(Session *session, const MetadataLatencyPayload &payload);
   void handle_payload(Session *session, const DentryLeasePayload &payload);
+  void handle_payload(Session *session, const OpenedFilesPayload &payload);
+  void handle_payload(Session *session, const PinnedIcapsPayload &payload);
+  void handle_payload(Session *session, const OpenedInodesPayload &payload);
   void handle_payload(Session *session, const UnknownPayload &payload);
 
   void set_next_seq(version_t seq);

diff --git a/src/mds/cephfs_features.h b/src/mds/cephfs_features.h
index c959e281f83379a6ab0e73b64989c1c7cc417776..5309d7e89bd8f240a44b61fa3e7cca6cdbdb9f95 100644 (file)
--- a/src/mds/cephfs_features.h
+++ b/src/mds/cephfs_features.h
@@ -66,6 +66,9 @@ namespace ceph {
     CLIENT_METRIC_TYPE_WRITE_LATENCY,          \
     CLIENT_METRIC_TYPE_METADATA_LATENCY,       \
     CLIENT_METRIC_TYPE_DENTRY_LEASE,           \
+    CLIENT_METRIC_TYPE_OPENED_FILES,           \
+    CLIENT_METRIC_TYPE_PINNED_ICAPS,           \
+    CLIENT_METRIC_TYPE_OPENED_INODES,          \
 }
 
 #define CEPHFS_FEATURES_MDS_SUPPORTED CEPHFS_FEATURES_ALL

diff --git a/src/mgr/BaseMgrModule.cc b/src/mgr/BaseMgrModule.cc
index 49b5f5627c1a0f3e209965cc736bc8165803b54b..dec75452b5fa5a7676d02c080454f63b4a94e9f5 100644 (file)
--- a/src/mgr/BaseMgrModule.cc
+++ b/src/mgr/BaseMgrModule.cc
@@ -1048,6 +1048,9 @@ ceph_add_mds_perf_query(BaseMgrModule *self, PyObject *args)
     {"write_latency", MDSPerformanceCounterType::WRITE_LATENCY_METRIC},
     {"metadata_latency", MDSPerformanceCounterType::METADATA_LATENCY_METRIC},
     {"dentry_lease", MDSPerformanceCounterType::DENTRY_LEASE_METRIC},
+    {"opened_files", MDSPerformanceCounterType::OPENED_FILES_METRIC},
+    {"pinned_icaps", MDSPerformanceCounterType::PINNED_ICAPS_METRIC},
+    {"opened_inodes", MDSPerformanceCounterType::OPENED_INODES_METRIC},
   };
 
   PyObject *py_query = nullptr;

diff --git a/src/mgr/MDSPerfMetricTypes.cc b/src/mgr/MDSPerfMetricTypes.cc
index 0827992840550d0020950197b9293613d6a4dbc4..bbba88a76bb509d3f101d5bc3b04a889c8edf33a 100644 (file)
--- a/src/mgr/MDSPerfMetricTypes.cc
+++ b/src/mgr/MDSPerfMetricTypes.cc
@@ -30,6 +30,9 @@ void MDSPerformanceCounterDescriptor::pack_counter(
   case MDSPerformanceCounterType::WRITE_LATENCY_METRIC:
   case MDSPerformanceCounterType::METADATA_LATENCY_METRIC:
   case MDSPerformanceCounterType::DENTRY_LEASE_METRIC:
+  case MDSPerformanceCounterType::OPENED_FILES_METRIC:
+  case MDSPerformanceCounterType::PINNED_ICAPS_METRIC:
+  case MDSPerformanceCounterType::OPENED_INODES_METRIC:
     break;
   default:
     ceph_abort_msg("unknown counter type");
@@ -47,6 +50,9 @@ void MDSPerformanceCounterDescriptor::unpack_counter(
   case MDSPerformanceCounterType::WRITE_LATENCY_METRIC:
   case MDSPerformanceCounterType::METADATA_LATENCY_METRIC:
   case MDSPerformanceCounterType::DENTRY_LEASE_METRIC:
+  case MDSPerformanceCounterType::OPENED_FILES_METRIC:
+  case MDSPerformanceCounterType::PINNED_ICAPS_METRIC:
+  case MDSPerformanceCounterType::OPENED_INODES_METRIC:
     break;
   default:
     ceph_abort_msg("unknown counter type");
@@ -70,6 +76,15 @@ std::ostream& operator<<(std::ostream &os, const MDSPerformanceCounterDescriptor
    case MDSPerformanceCounterType::DENTRY_LEASE_METRIC:
      os << "dentry_lease_metric";
      break;
+   case MDSPerformanceCounterType::OPENED_FILES_METRIC:
+     os << "opened_files_metric";
+     break;
+   case MDSPerformanceCounterType::PINNED_ICAPS_METRIC:
+     os << "pinned_icaps_metric";
+     break;
+   case MDSPerformanceCounterType::OPENED_INODES_METRIC:
+     os << "opened_inodes_metric";
+     break;
    }
 
    return os;

diff --git a/src/mgr/MDSPerfMetricTypes.h b/src/mgr/MDSPerfMetricTypes.h
index 9a5feb5e8393a2a417c3f8bb499439ff94be390a..41b183b05e297e9c4a1f468a320cb03dc2d2b9d2 100644 (file)
--- a/src/mgr/MDSPerfMetricTypes.h
+++ b/src/mgr/MDSPerfMetricTypes.h
@@ -121,6 +121,9 @@ enum class MDSPerformanceCounterType : uint8_t {
   WRITE_LATENCY_METRIC = 2,
   METADATA_LATENCY_METRIC = 3,
   DENTRY_LEASE_METRIC = 4,
+  OPENED_FILES_METRIC = 5,
+  PINNED_ICAPS_METRIC = 6,
+  OPENED_INODES_METRIC = 7,
 };
 
 struct MDSPerformanceCounterDescriptor {
@@ -133,6 +136,9 @@ struct MDSPerformanceCounterDescriptor {
     case MDSPerformanceCounterType::WRITE_LATENCY_METRIC:
     case MDSPerformanceCounterType::METADATA_LATENCY_METRIC:
     case MDSPerformanceCounterType::DENTRY_LEASE_METRIC:
+    case MDSPerformanceCounterType::OPENED_FILES_METRIC:
+    case MDSPerformanceCounterType::PINNED_ICAPS_METRIC:
+    case MDSPerformanceCounterType::OPENED_INODES_METRIC:
       return true;
     default:
       return false;

diff --git a/src/pybind/mgr/stats/fs/perf_stats.py b/src/pybind/mgr/stats/fs/perf_stats.py
index a84c9ad7ac89291052595aff5672ab383c9a2b13..352e012495506245a4d5905bde74f05f7a12cb5c 100644 (file)
--- a/src/pybind/mgr/stats/fs/perf_stats.py
+++ b/src/pybind/mgr/stats/fs/perf_stats.py
@@ -28,9 +28,12 @@ MDS_PERF_QUERY_COUNTERS_MAP = OrderedDict({'cap_hit': 0,
                                            'read_latency': 1,
                                            'write_latency': 2,
                                            'metadata_latency': 3,
-                                           'dentry_lease': 4})
+                                           'dentry_lease': 4,
+                                           'opened_files': 5,
+                                           'pinned_icaps': 6,
+                                           'opened_inodes': 7})
 MDS_PERF_QUERY_COUNTERS = [] # type: List[str]
-MDS_GLOBAL_PERF_QUERY_COUNTERS = ['cap_hit', 'read_latency', 'write_latency', 'metadata_latency', 'dentry_lease'] # type: List[str]
+MDS_GLOBAL_PERF_QUERY_COUNTERS = ['cap_hit', 'read_latency', 'write_latency', 'metadata_latency', 'dentry_lease', 'opened_files', 'pinned_icaps', 'opened_inodes'] # type: List[str]
 
 QUERY_EXPIRE_INTERVAL = timedelta(minutes=1)