From 89cc2cda4aa4dd7a53ba3eb8c7b5aa2cb89796fa Mon Sep 17 00:00:00 2001 From: Xiubo Li Date: Tue, 3 Nov 2020 23:21:58 -0500 Subject: [PATCH] mds: add opened files/inodes and pinned i_caps metric payload support Fixes: https://tracker.ceph.com/issues/46865 Signed-off-by: Xiubo Li --- src/client/Client.cc | 33 ++++++ src/client/Client.h | 34 +++++++ src/client/Inode.cc | 8 +- src/include/cephfs/metrics/Types.h | 138 ++++++++++++++++++++++++++ src/mds/MDSPerfMetricTypes.h | 94 +++++++++++++++++- src/mds/MetricAggregator.cc | 18 ++++ src/mds/MetricsHandler.cc | 54 ++++++++++ src/mds/MetricsHandler.h | 3 + src/mds/cephfs_features.h | 3 + src/mgr/BaseMgrModule.cc | 3 + src/mgr/MDSPerfMetricTypes.cc | 15 +++ src/mgr/MDSPerfMetricTypes.h | 6 ++ src/pybind/mgr/stats/fs/perf_stats.py | 7 +- 13 files changed, 412 insertions(+), 4 deletions(-) diff --git a/src/client/Client.cc b/src/client/Client.cc index aaf9db20c35..74ab0906cc4 100644 --- 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(std::move(message))); } diff --git a/src/client/Client.h b/src/client/Client.h index 01f469ea1ba..8c89deb67f4 100644 --- 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 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 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 get_opened_inodes_rates() { + return std::make_pair(opened_inodes, inode_map.size()); + } + xlist &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 delay_i_release; }; diff --git a/src/client/Inode.cc b/src/client/Inode.cc index b4fe5d84252..a1e9a3ad981 100644 --- 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 160bfa1d174..3f2b642fdb3 100644 --- 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(-1); @@ -255,6 +381,9 @@ typedef boost::variant 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 ff1ad65d7f4..de69a4277b4 100644 --- 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 c5e6fe3bbaf..8d98db5fd49 100644 --- 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 781a41581db..f003c545957 100644 --- 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(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(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(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 e03c2c43104..65bcf488b5f 100644 --- 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 c959e281f83..5309d7e89bd 100644 --- 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 49b5f5627c1..dec75452b5f 100644 --- 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 08279928405..bbba88a76bb 100644 --- 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 9a5feb5e839..41b183b05e2 100644 --- 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 a84c9ad7ac8..352e0124955 100644 --- 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) -- 2.39.5