mds: save path on uninline failure

Signed-off-by: Milind Changire <mchangir@redhat.com>

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index c8d0749ee814f22c0db7c4571a2ef4fbd9592b25..72233b886b1314a36c819060f8f7d617fe92b86c 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -13223,7 +13223,9 @@ struct C_IO_DataUninlined : public MDSIOContext {
           << " (" << cpp_strerror(r) << ") for " << *in << dendl;
       in->mdcache->logger->inc(l_mdc_uninline_write_failed);
       ceph_assert(in->get_scrub_header());
-      in->get_scrub_header()->record_uninline_status(in->ino(), r);
+      std::string path;
+      in->make_path_string(path);
+      in->get_scrub_header()->record_uninline_status(in->ino(), r, path);
       in->uninline_finished();
       mds->server->respond_to_request(mdr, r);
       return;

diff --git a/src/mds/ScrubHeader.h b/src/mds/ScrubHeader.h
index d8b90f53f10ad7d06bd03afb4ddc9e209d2a3899..6d255ca99e03d25230f87c7c37a8a76f6f02e6c2 100644 (file)
--- a/src/mds/ScrubHeader.h
+++ b/src/mds/ScrubHeader.h
@@ -65,18 +65,23 @@ public:
   }
   unsigned get_num_pending() const { return num_pending; }
 
-  void record_uninline_status(_inodeno_t ino, int e) {
+  void record_uninline_status(_inodeno_t ino, int e, std::string_view path) {
     if (uninline_failed_info.find(e) == uninline_failed_info.end()) {
       uninline_failed_info[e] = std::vector<_inodeno_t>();
     }
     auto& v = uninline_failed_info.at(e);
     v.push_back(ino);
+    paths[ino] = path;
   }
 
   std::unordered_map<int, std::vector<_inodeno_t>>& get_uninline_failed_info() {
     return uninline_failed_info;
   }
 
+  std::unordered_map<_inodeno_t, std::string>& get_paths() {
+    return paths;
+  }
+
 protected:
   const std::string tag;
   bool is_tag_internal;
@@ -91,6 +96,7 @@ protected:
   unsigned num_pending = 0;
   // errno -> [ino1, ino2, ino3, ...]
   std::unordered_map<int, std::vector<_inodeno_t>> uninline_failed_info;
+  std::unordered_map<_inodeno_t, std::string> paths;
 };
 
 typedef std::shared_ptr<ScrubHeader> ScrubHeaderRef;

diff --git a/src/mds/ScrubStack.cc b/src/mds/ScrubStack.cc
index 35cff12c4b13045460f52fad5b7292dbc915f531..bb586173d9f5b7aca239a9d4e410340f0ff30693 100644 (file)
--- a/src/mds/ScrubStack.cc
+++ b/src/mds/ScrubStack.cc
@@ -1058,6 +1058,7 @@ void ScrubStack::handle_scrub_stats(const cref_t<MMDSScrubStats> &m)
     bool any_repaired = false;
     std::set<std::string> scrubbing_tags;
     std::unordered_map<std::string, unordered_map<int, std::vector<_inodeno_t>>> uninline_failed_meta_info;
+    std::unordered_map<_inodeno_t, std::string> paths;
 
     for (auto it = scrubbing_map.begin(); it != scrubbing_map.end(); ) {
       auto& header = it->second;
@@ -1072,6 +1073,8 @@ void ScrubStack::handle_scrub_stats(const cref_t<MMDSScrubStats> &m)
        auto& ufi = header->get_uninline_failed_info();
        uninline_failed_meta_info[it->first] = ufi;
        ufi.clear();
+       paths.merge(header->get_paths());
+       ceph_assert(header->get_paths().size() == 0);
        scrubbing_map.erase(it++);
       } else {
        ++it;
@@ -1083,6 +1086,7 @@ void ScrubStack::handle_scrub_stats(const cref_t<MMDSScrubStats> &m)
     auto ack = make_message<MMDSScrubStats>(scrub_epoch,
                                            std::move(scrubbing_tags),
                                            std::move(uninline_failed_meta_info),
+                                           std::move(paths),
                                            clear_stack);
     mdcache->mds->send_message_mds(ack, 0);
 
@@ -1100,6 +1104,7 @@ void ScrubStack::handle_scrub_stats(const cref_t<MMDSScrubStats> &m)
       for (auto& [scrub_tag, errno_map] : m->get_uninline_failed_meta_info()) {
        stat.uninline_failed_meta_info[scrub_tag] = errno_map;
       }
+      stat.paths.insert(m->get_paths().begin(), m->get_paths().end());;
     }
   }
 }
@@ -1110,19 +1115,17 @@ void ScrubStack::move_uninline_failures_to_damage_table()
 
   for (mds_rank_t rank = 0; rank < (mds_rank_t)mds_scrub_stats.size(); rank++) {
     auto& ufmi = mds_scrub_stats[rank].uninline_failed_meta_info;
+    auto& paths = mds_scrub_stats[rank].paths;
 
     for (const auto& [scrub_tag, errno_ino_vec_map] : ufmi) {
       for (const auto& [errno_, ino_vec] : errno_ino_vec_map) {
        for (auto ino : ino_vec) {
-         std::string path;
-         auto in = mdcache->get_inode(ino);
-         ceph_assert(in);
-         in->make_path_string(path);
-         mds->damage_table.notify_uninline_failed(ino, rank, errno_, scrub_tag, path);
+         mds->damage_table.notify_uninline_failed(ino, rank, errno_, scrub_tag, paths[ino]);
        }
       }
     }
     ufmi.clear();
+    paths.clear();
   }
 }
 
@@ -1191,6 +1194,7 @@ void ScrubStack::advance_scrub_status()
        any_repaired = true;
       auto& ufmi = mds_scrub_stats[0].uninline_failed_meta_info;
       ufmi[it->first] = header->get_uninline_failed_info();
+      mds_scrub_stats[0].paths.merge(header->get_paths());
       move_uninline_failures_to_damage_table();
       scrubbing_map.erase(it++);
     } else {

diff --git a/src/mds/ScrubStack.h b/src/mds/ScrubStack.h
index 28feee0c2d980d6f765685820e87ec078a1ea6fa..97ec39d152df659120e5c38c85bbd3c3caea4cc7 100644 (file)
--- a/src/mds/ScrubStack.h
+++ b/src/mds/ScrubStack.h
@@ -140,6 +140,7 @@ protected:
     std::set<std::string> scrubbing_tags;
     bool aborting = false;
     std::unordered_map<std::string, std::unordered_map<int, std::vector<_inodeno_t>>> uninline_failed_meta_info;
+    std::unordered_map<_inodeno_t, std::string> paths;
   };
   std::vector<scrub_stat_t> mds_scrub_stats;
 

diff --git a/src/messages/MMDSScrubStats.h b/src/messages/MMDSScrubStats.h
index 200c5cc10c8e60e0e67cce4cd94714dcc6daa8b4..d25ea104d518f53220fa915ac941e6151643d83c 100644 (file)
--- a/src/messages/MMDSScrubStats.h
+++ b/src/messages/MMDSScrubStats.h
@@ -41,6 +41,9 @@ public:
   const std::unordered_map<std::string, std::unordered_map<int, std::vector<_inodeno_t>>>& get_uninline_failed_meta_info() const {
     return uninline_failed_meta_info;
   }
+  const std::unordered_map<_inodeno_t, std::string>& get_paths() const {
+    return paths;
+  }
 
   void encode_payload(uint64_t features) override {
     using ceph::encode;
@@ -75,6 +78,12 @@ public:
        encode(ino_vec, payload);
       }
     }
+    count = (int)paths.size();
+    encode(count, payload);
+    for (auto& [ino, path] : paths) {
+      encode(ino, payload);
+      encode(path, payload);
+    }
   }
   void decode_uninline_failed_info(ceph::bufferlist::const_iterator& p) {
     using ceph::decode;
@@ -95,6 +104,15 @@ public:
       }
       uninline_failed_meta_info[tag] = std::move(uninline_failed_info);
     }
+    int count = 0;
+    decode(count, p);
+    while (count--) {
+      _inodeno_t ino;
+      std::string path;
+      decode(ino, p);
+      decode(path, p);
+      paths[ino] = path;
+    }
   }
 
 protected:
@@ -109,10 +127,10 @@ protected:
     epoch(e), scrubbing_tags(tags), update_scrubbing(true), aborting(abrt) {}
   MMDSScrubStats(unsigned e, const std::set<std::string>& tags,
     std::unordered_map<std::string, std::unordered_map<int, std::vector<_inodeno_t>>>&& ufmi,
-    bool abrt = false) :
+    std::unordered_map<_inodeno_t, std::string>&& paths_, bool abrt = false) :
     MMDSOp(MSG_MDS_SCRUB_STATS, HEAD_VERSION, COMPAT_VERSION),
     epoch(e), scrubbing_tags(tags), update_scrubbing(true), aborting(abrt),
-    uninline_failed_meta_info(std::move(ufmi)) {}
+    uninline_failed_meta_info(std::move(ufmi)), paths(std::move(paths_)) {}
   ~MMDSScrubStats() override {}
 
 private:
@@ -122,6 +140,7 @@ private:
   bool aborting = false;
   // <tag, <error_code, [ino1, ino2, ...]>>
   std::unordered_map<std::string, std::unordered_map<int, std::vector<_inodeno_t>>> uninline_failed_meta_info;
+  std::unordered_map<_inodeno_t, std::string> paths;
 
   template<class T, typename... Args>
   friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);