mds/*: forward-declare MDSContext

Signed-off-by: Max Kellermann <max.kellermann@ionos.com>

diff --git a/src/mds/CDir.h b/src/mds/CDir.h
index fa61b1dc37c0d9e3298db1007badf32353e6ed72..c98b893e0f76678538c0dcdd944b832603cd915e 100644 (file)
--- a/src/mds/CDir.h
+++ b/src/mds/CDir.h
@@ -22,6 +22,7 @@
 #include <set>
 #include <string>
 #include <string_view>
+#include <vector>
 
 #include "common/config.h"
 #include "include/buffer_fwd.h"
@@ -38,6 +39,7 @@ struct session_info_t;
 class bloom_filter;
 class CDentry;
 class MDCache;
+class MDSContext;
 
 std::ostream& operator<<(std::ostream& out, const class CDir& dir);
 
@@ -402,8 +404,8 @@ public:
   void try_remove_dentries_for_stray();
   bool try_trim_snap_dentry(CDentry *dn, const std::set<snapid_t>& snaps);
 
-  void split(int bits, std::vector<CDir*>* subs, MDSContext::vec& waiters, bool replay);
-  void merge(const std::vector<CDir*>& subs, MDSContext::vec& waiters, bool replay);
+  void split(int bits, std::vector<CDir*>* subs, std::vector<MDSContext*>& waiters, bool replay);
+  void merge(const std::vector<CDir*>& subs, std::vector<MDSContext*>& waiters, bool replay);
 
   bool should_split() const;
   bool should_split_fast() const;
@@ -507,10 +509,10 @@ public:
     return waiting_on_dentry.count(string_snap_t(dname, snap));
   }
   void add_dentry_waiter(std::string_view dentry, snapid_t snap, MDSContext *c);
-  void take_dentry_waiting(std::string_view dentry, snapid_t first, snapid_t last, MDSContext::vec& ls);
+  void take_dentry_waiting(std::string_view dentry, snapid_t first, snapid_t last, std::vector<MDSContext*>& ls);
 
   void add_waiter(uint64_t mask, MDSContext *c) override;
-  void take_waiting(uint64_t mask, MDSContext::vec& ls) override;  // may include dentry waiters
+  void take_waiting(uint64_t mask, std::vector<MDSContext*>& ls) override;  // may include dentry waiters
   void finish_waiting(uint64_t mask, int result = 0);    // ditto
 
   // -- import/export --
@@ -754,10 +756,10 @@ protected:
   /* If you set up the bloom filter, you must keep it accurate!
    * It's deleted when you mark_complete() and is deliberately not serialized.*/
 
-  mempool::mds_co::compact_map<version_t, MDSContext::vec_alloc<mempool::mds_co::pool_allocator> > waiting_for_commit;
+  mempool::mds_co::compact_map<version_t, std::vector<MDSContext*, mempool::mds_co::pool_allocator<MDSContext*>>> waiting_for_commit;
 
   // -- waiters --
-  mempool::mds_co::map< string_snap_t, MDSContext::vec_alloc<mempool::mds_co::pool_allocator> > waiting_on_dentry; // FIXME string_snap_t not in mempool
+  mempool::mds_co::map< string_snap_t, std::vector<MDSContext*, mempool::mds_co::pool_allocator<MDSContext*>>> waiting_on_dentry; // FIXME string_snap_t not in mempool
 
 private:
   friend std::ostream& operator<<(std::ostream& out, const class CDir& dir);
@@ -778,9 +780,9 @@ private:
   void remove_null_dentries();
 
   void prepare_new_fragment(bool replay);
-  void prepare_old_fragment(std::map<string_snap_t, MDSContext::vec >& dentry_waiters, bool replay);
+  void prepare_old_fragment(std::map<string_snap_t, std::vector<MDSContext*> >& dentry_waiters, bool replay);
   void steal_dentry(CDentry *dn);  // from another dir.  used by merge/split.
-  void finish_old_fragment(MDSContext::vec& waiters, bool replay);
+  void finish_old_fragment(std::vector<MDSContext*>& waiters, bool replay);
   void init_fragment_pins();
   std::string get_path() const;
 

diff --git a/src/mds/CInode.h b/src/mds/CInode.h
index ae85d90f9484ccd40e7294a49033e7b09ab03dba..bddba4c7f1990596376169cb980139e6d560fa00 100644 (file)
--- a/src/mds/CInode.h
+++ b/src/mds/CInode.h
@@ -33,7 +33,6 @@
 #include "include/compact_set.h"
 
 #include "MDSCacheObject.h"
-#include "MDSContext.h"
 #include "flock.h"
 #include "inode_backtrace.h" // for inode_backtrace_t
 
@@ -52,6 +51,7 @@ class CDentry;
 class CDir;
 class CInode;
 class MDCache;
+class MDSContext;
 class LogSegment;
 struct SnapRealm;
 class Session;
@@ -683,7 +683,7 @@ class CInode : public MDSCacheObject, public InodeStoreBase, public Counter<CIno
   void set_ambiguous_auth() {
     state_set(STATE_AMBIGUOUSAUTH);
   }
-  void clear_ambiguous_auth(MDSContext::vec& finished);
+  void clear_ambiguous_auth(std::vector<MDSContext*>& finished);
   void clear_ambiguous_auth();
 
   const inode_const_ptr& get_inode() const {
@@ -777,12 +777,12 @@ class CInode : public MDSCacheObject, public InodeStoreBase, public Counter<CIno
   void decode_store(ceph::buffer::list::const_iterator& bl);
 
   void add_dir_waiter(frag_t fg, MDSContext *c);
-  void take_dir_waiting(frag_t fg, MDSContext::vec& ls);
+  void take_dir_waiting(frag_t fg, std::vector<MDSContext*>& ls);
   bool is_waiting_for_dir(frag_t fg) {
     return waiting_on_dir.count(fg);
   }
   void add_waiter(uint64_t tag, MDSContext *c) override;
-  void take_waiting(uint64_t tag, MDSContext::vec& ls) override;
+  void take_waiting(uint64_t tag, std::vector<MDSContext*>& ls) override;
 
   // -- encode/decode helpers --
   void _encode_base(ceph::buffer::list& bl, uint64_t features);
@@ -792,7 +792,7 @@ class CInode : public MDSCacheObject, public InodeStoreBase, public Counter<CIno
   void _encode_locks_state_for_replica(ceph::buffer::list& bl, bool need_recover);
   void _encode_locks_state_for_rejoin(ceph::buffer::list& bl, int rep);
   void _decode_locks_state_for_replica(ceph::buffer::list::const_iterator& p, bool is_new);
-  void _decode_locks_rejoin(ceph::buffer::list::const_iterator& p, MDSContext::vec& waiters,
+  void _decode_locks_rejoin(ceph::buffer::list::const_iterator& p, std::vector<MDSContext*>& waiters,
                            std::list<SimpleLock*>& eval_locks, bool survivor);
 
   // -- import/export --
@@ -957,7 +957,7 @@ class CInode : public MDSCacheObject, public InodeStoreBase, public Counter<CIno
   /* Freeze the inode. auth_pin_allowance lets the caller account for any
    * auth_pins it is itself holding/responsible for. */
   bool freeze_inode(int auth_pin_allowance=0);
-  void unfreeze_inode(MDSContext::vec& finished);
+  void unfreeze_inode(std::vector<MDSContext*>& finished);
   void unfreeze_inode();
 
   void freeze_auth_pin();
@@ -1207,7 +1207,7 @@ protected:
   ceph_lock_state_t *flock_locks = nullptr;
 
   // -- waiting --
-  mempool::mds_co::compact_map<frag_t, MDSContext::vec > waiting_on_dir;
+  mempool::mds_co::compact_map<frag_t, std::vector<MDSContext*>> waiting_on_dir;
 
 
   // -- freezing inode --

diff --git a/src/mds/Locker.h b/src/mds/Locker.h
index 643dc3354434b0ae5ab160d7eb577660c544ddf9..9f030b119cb446eb88d040d87e7b7d861d8102ed 100644 (file)
--- a/src/mds/Locker.h
+++ b/src/mds/Locker.h
@@ -19,12 +19,12 @@
 #include <memory>
 #include <set>
 #include <string_view>
+#include <vector>
 
 #include "common/ref.h"
 #include "include/mempool.h"
 #include "include/types.h"
 
-#include "MDSContext.h"
 #include "mdstypes.h" // for xattr_map
 #include "Mutation.h"
 #include "SimpleLock.h"
@@ -39,6 +39,7 @@ class MClientLease;
 class MClientReply;
 class MDCache;
 class MLock;
+class MDSContext;
 class MDSRank;
 class Session;
 class CDentry;
@@ -96,9 +97,9 @@ public:
   void eval_lock_caches(Capability *cap);
   void put_lock_cache(MDLockCache* lock_cache);
 
-  void eval_gather(SimpleLock *lock, bool first=false, bool *need_issue=0, MDSContext::vec *pfinishers=0);
+  void eval_gather(SimpleLock *lock, bool first=false, bool *need_issue=0, std::vector<MDSContext*> *pfinishers=0);
   void eval(SimpleLock *lock, bool *need_issue);
-  void eval_any(SimpleLock *lock, bool *need_issue, MDSContext::vec *pfinishers=0, bool first=false) {
+  void eval_any(SimpleLock *lock, bool *need_issue, std::vector<MDSContext*> *pfinishers=0, bool first=false) {
     if (!lock->is_stable())
       eval_gather(lock, first, need_issue, pfinishers);
     else if (lock->get_parent()->is_auth())

diff --git a/src/mds/LogSegment.h b/src/mds/LogSegment.h
index 19b22949e98d6bc5a165ef8407c45d9358e7823d..88f90f6acabfb17e380770afaa4fe71ff047ed95 100644 (file)
--- a/src/mds/LogSegment.h
+++ b/src/mds/LogSegment.h
@@ -18,7 +18,6 @@
 #include "include/elist.h"
 #include "include/interval_set.h"
 #include "include/Context.h"
-#include "MDSContext.h"
 #include "mdstypes.h"
 #include "CInode.h"
 #include "CDentry.h"
@@ -35,6 +34,10 @@
 class CDir;
 class CInode;
 class CDentry;
+class MDSContext;
+class C_MDSInternalNoop;
+using MDSGather = C_GatherBase<MDSContext, C_MDSInternalNoop>;
+using MDSGatherBuilder = C_GatherBuilderBase<MDSContext, MDSGather>;
 class MDSRank;
 struct MDPeerUpdate;
 
@@ -56,12 +59,7 @@ class LogSegment {
   {}
 
   void try_to_expire(MDSRank *mds, MDSGatherBuilder &gather_bld, int op_prio);
-  void purge_inodes_finish(interval_set<inodeno_t>& inos){
-    purging_inodes.subtract(inos);
-    if (NULL != purged_cb &&
-       purging_inodes.empty())
-      purged_cb->complete(0);
-  }
+  void purge_inodes_finish(interval_set<inodeno_t>& inos);
   void set_purged_cb(MDSContext* c){
     ceph_assert(purged_cb == NULL);
     purged_cb = c;
@@ -107,7 +105,7 @@ class LogSegment {
   version_t sessionmapv = 0;
   std::map<int,version_t> tablev;
 
-  MDSContext::vec expiry_waiters;
+  std::vector<MDSContext*> expiry_waiters;
 };
 
 static inline std::ostream& operator<<(std::ostream& out, const LogSegment& ls) {

diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h
index 00faba916ca12565ba6d18a30cc91dd1aa719c79..b9d4badcb5eea761ff39eacc2ea5cb8a2f8445d8 100644 (file)
--- a/src/mds/MDCache.h
+++ b/src/mds/MDCache.h
@@ -1049,9 +1049,9 @@ private:
   void encode_replica_inode(CInode *in, mds_rank_t to, bufferlist& bl,
                       uint64_t features);
   
-  void decode_replica_dir(CDir *&dir, bufferlist::const_iterator& p, CInode *diri, mds_rank_t from, MDSContext::vec& finished);
-  void decode_replica_dentry(CDentry *&dn, bufferlist::const_iterator& p, CDir *dir, MDSContext::vec& finished);
-  void decode_replica_inode(CInode *&in, bufferlist::const_iterator& p, CDentry *dn, MDSContext::vec& finished);
+  void decode_replica_dir(CDir *&dir, bufferlist::const_iterator& p, CInode *diri, mds_rank_t from, std::vector<MDSContext*>& finished);
+  void decode_replica_dentry(CDentry *&dn, bufferlist::const_iterator& p, CDir *dir, std::vector<MDSContext*>& finished);
+  void decode_replica_inode(CInode *&in, bufferlist::const_iterator& p, CDentry *dn, std::vector<MDSContext*>& finished);
 
   void encode_replica_stray(CDentry *straydn, mds_rank_t who, bufferlist& bl);
   void decode_replica_stray(CDentry *&straydn, CInode **in, const bufferlist &bl, mds_rank_t from);
@@ -1159,7 +1159,7 @@ private:
   ceph_tid_t discover_last_tid = 0;
 
   // waiters
-  std::map<int, std::map<inodeno_t, MDSContext::vec > > waiting_for_base_ino;
+  std::map<int, std::map<inodeno_t, std::vector<MDSContext*> > > waiting_for_base_ino;
 
   std::map<inodeno_t,std::map<client_t, reconnected_cap_info_t> > reconnected_caps;   // inode -> client -> snap_follows,realmino
   std::map<inodeno_t,std::map<client_t, snapid_t> > reconnected_snaprealms;  // realmino -> client -> realmseq
@@ -1206,7 +1206,7 @@ private:
     uleader() {}
     std::set<mds_rank_t> peers;
     LogSegment *ls = nullptr;
-    MDSContext::vec waiters;
+    std::vector<MDSContext*> waiters;
     bool safe = false;
     bool committing = false;
     bool recovering = false;
@@ -1217,7 +1217,7 @@ private:
     mds_rank_t leader;
     LogSegment *ls = nullptr;
     MDPeerUpdate *su = nullptr;
-    MDSContext::vec waiters;
+    std::vector<MDSContext*> waiters;
   };
 
   struct open_ino_info_t {
@@ -1234,14 +1234,14 @@ private:
     version_t tid = 0;
     int64_t pool = -1;
     int last_err = 0;
-    MDSContext::vec waiters;
+    std::vector<MDSContext*> waiters;
   };
 
   ceph_tid_t open_ino_last_tid = 0;
   std::map<inodeno_t,open_ino_info_t> opening_inodes;
 
   bool open_ino_batch = false;
-  std::map<CDir*, std::pair<std::vector<std::string>, MDSContext::vec> > open_ino_batched_fetch;
+  std::map<CDir*, std::pair<std::vector<std::string>, std::vector<MDSContext*>> > open_ino_batched_fetch;
 
   friend struct C_MDC_OpenInoTraverseDir;
   friend struct C_MDC_OpenInoParentOpened;
@@ -1400,7 +1400,7 @@ private:
 
   std::map<inodeno_t,std::map<client_t,std::map<mds_rank_t,cap_reconnect_t> > > cap_imports;  // ino -> client -> frommds -> capex
   std::set<inodeno_t> cap_imports_missing;
-  std::map<inodeno_t, MDSContext::vec > cap_reconnect_waiters;
+  std::map<inodeno_t, std::vector<MDSContext*> > cap_reconnect_waiters;
   int cap_imports_num_opening = 0;
 
   std::set<CInode*> rejoin_undef_inodes;
@@ -1410,7 +1410,7 @@ private:
 
   std::vector<CInode*> rejoin_recover_q, rejoin_check_q;
   std::list<SimpleLock*> rejoin_eval_locks;
-  MDSContext::vec rejoin_waiters;
+  std::vector<MDSContext*> rejoin_waiters;
 
   std::unique_ptr<MDSContext> rejoin_done;
   std::unique_ptr<MDSContext> resolve_done;
@@ -1439,7 +1439,7 @@ private:
     int bits = 0;
     bool committed = false;
     LogSegment *ls = nullptr;
-    MDSContext::vec waiters;
+    std::vector<MDSContext*> waiters;
     frag_vec_t old_frags;
     bufferlist rollback;
   };
@@ -1510,12 +1510,12 @@ private:
   void trim_non_auth();      // trim out trimmable non-auth items
 
   void adjust_dir_fragments(CInode *diri, frag_t basefrag, int bits,
-                           std::vector<CDir*>* frags, MDSContext::vec& waiters, bool replay);
+                           std::vector<CDir*>* frags, std::vector<MDSContext*>& waiters, bool replay);
   void adjust_dir_fragments(CInode *diri,
                            const std::vector<CDir*>& srcfrags,
                            frag_t basefrag, int bits,
                            std::vector<CDir*>* resultfrags,
-                           MDSContext::vec& waiters,
+                           std::vector<MDSContext*>& waiters,
                            bool replay);
   CDir *force_dir_fragment(CInode *diri, frag_t fg, bool replay=true);
   void get_force_dirfrag_bound_set(const std::vector<dirfrag_t>& dfs, std::set<CDir*>& bounds);
@@ -1572,7 +1572,7 @@ private:
   std::pair<dirfrag_t, std::string> shutdown_export_next;
 
   bool opening_root = false, open = false;
-  MDSContext::vec waiting_for_open;
+  std::vector<MDSContext*> waiting_for_open;
 
   // -- snaprealms --
   SnapRealm *global_snaprealm = nullptr;

diff --git a/src/mds/MDLog.h b/src/mds/MDLog.h
index b3b0139cc7bc238a617867fe9a9a2d9b6eeca07f..2dc657bec61f7c26659c6557d9a4a1abd9f1d222 100644 (file)
--- a/src/mds/MDLog.h
+++ b/src/mds/MDLog.h
@@ -272,7 +272,7 @@ protected:
 
   bool already_replayed = false;
 
-  MDSContext::vec waitfor_replay;
+  std::vector<MDSContext*> waitfor_replay;
 
   // -- segments --
   std::map<uint64_t,LogSegment*> segments;

diff --git a/src/mds/MDSCacheObject.h b/src/mds/MDSCacheObject.h
index 003c6fc32d749f8e71e0a3295eff768677ffa483..62f20349ae81b04a72b6e2bd0df2f037fae1e85a 100644 (file)
--- a/src/mds/MDSCacheObject.h
+++ b/src/mds/MDSCacheObject.h
@@ -12,7 +12,6 @@
 #include "include/types.h"
 
 #include "mdstypes.h"
-#include "MDSContext.h"
 #include "include/elist.h"
 
 #define MDS_REF_SET      // define me for improved debug output, sanity checking
@@ -278,10 +277,10 @@ class MDSCacheObject {
     }
     waiting.insert(std::pair<waiter_seq_t, waiter>(seq, waiter{mask, c}));
   }
-  virtual void take_waiting(uint64_t mask, MDSContext::vec& ls) {
+  virtual void take_waiting(uint64_t mask, std::vector<MDSContext*>& ls) {
     take_waiting(waitmask_t(mask), ls);
   }
-  void take_waiting(waitmask_t mask, MDSContext::vec& ls);
+  void take_waiting(waitmask_t mask, std::vector<MDSContext*>& ls);
   void finish_waiting(uint64_t mask, int result = 0) {
     finish_waiting(waitmask_t(mask), result);
   }

diff --git a/src/mds/MDSRank.cc b/src/mds/MDSRank.cc
index 603c23bb39cc78f35cc8d25df0e59f0a905d7deb..6f4adb81be491a289242ce2b6552864a6d18b511 100644 (file)
--- a/src/mds/MDSRank.cc
+++ b/src/mds/MDSRank.cc
@@ -1428,6 +1428,10 @@ void MDSRank::send_message(const ref_t<Message>& m, const ConnectionRef& c)
   c->send_message2(m);
 }
 
+void MDSRank::kick_waiters_for_any_client_connection() {
+  finish_contexts(g_ceph_context, waiting_for_any_client_connection);
+}
+
 class C_MDS_RetrySendMessageMDS : public MDSInternalContext {
 public:
   C_MDS_RetrySendMessageMDS(MDSRank* mds, mds_rank_t who, ref_t<Message> m)

diff --git a/src/mds/MDSRank.h b/src/mds/MDSRank.h
index 0c0cf8fe69f480a8533887f6c03a448f212da62c..bc7f5c9628294378a7db7e87d03ba8ad18d0f3a0 100644 (file)
--- a/src/mds/MDSRank.h
+++ b/src/mds/MDSRank.h
@@ -28,7 +28,6 @@
 #include "DamageTable.h"
 #include "MDSMap.h"
 #include "SessionMap.h"
-#include "MDSContext.h"
 #include "PurgeQueue.h"
 #include "MetricsHandler.h"
 #include "mon/MonClient.h"
@@ -37,6 +36,7 @@
 // benefit of those including this header and using MDSRank::logger
 #include "common/perf_counters.h"
 
+class MDSContext;
 class MDSMetaRequest;
 class MMDSMap;
 
@@ -242,14 +242,14 @@ class MDSRank {
       finished_queue.push_front(c);
       progress_thread.signal();
     }
-    void queue_waiters(MDSContext::vec& ls) {
-      MDSContext::vec v;
+    void queue_waiters(std::vector<MDSContext*>& ls) {
+      std::vector<MDSContext*> v;
       v.swap(ls);
       std::copy(v.begin(), v.end(), std::back_inserter(finished_queue));
       progress_thread.signal();
     }
-    void queue_waiters_front(MDSContext::vec& ls) {
-      MDSContext::vec v;
+    void queue_waiters_front(std::vector<MDSContext*>& ls) {
+      std::vector<MDSContext*> v;
       v.swap(ls);
       std::copy(v.rbegin(), v.rend(), std::front_inserter(finished_queue));
       progress_thread.signal();
@@ -333,9 +333,7 @@ class MDSRank {
     void wait_for_any_client_connection(MDSContext *c) {
       waiting_for_any_client_connection.push_back(c);
     }
-    void kick_waiters_for_any_client_connection(void) {
-      finish_contexts(g_ceph_context, waiting_for_any_client_connection);
-    }
+    void kick_waiters_for_any_client_connection();
     void wait_for_active(MDSContext *c) {
       waiting_for_active.push_back(c);
     }
@@ -604,7 +602,7 @@ class MDSRank {
     std::unique_ptr<MetricAggregator> metric_aggregator;
 
     std::list<cref_t<Message>> waiting_for_nolaggy;
-    MDSContext::que finished_queue;
+    std::deque<MDSContext*> finished_queue;
     // Dispatch, retry, queues
     int dispatch_depth = 0;
 
@@ -616,15 +614,15 @@ class MDSRank {
 
     ceph_tid_t last_tid = 0;    // for mds-initiated requests (e.g. stray rename)
 
-    MDSContext::vec waiting_for_active, waiting_for_replay, waiting_for_rejoin,
+    std::vector<MDSContext*> waiting_for_active, waiting_for_replay, waiting_for_rejoin,
                                waiting_for_reconnect, waiting_for_resolve;
-    MDSContext::vec waiting_for_any_client_connection;
-    MDSContext::que replay_queue;
+    std::vector<MDSContext*> waiting_for_any_client_connection;
+    std::deque<MDSContext*> replay_queue;
     bool replaying_requests_done = false;
 
-    std::map<mds_rank_t, MDSContext::vec> waiting_for_active_peer;
-    std::map<mds_rank_t, MDSContext::vec> waiting_for_bootstrapping_peer;
-    std::map<epoch_t, MDSContext::vec> waiting_for_mdsmap;
+    std::map<mds_rank_t, std::vector<MDSContext*>> waiting_for_active_peer;
+    std::map<mds_rank_t, std::vector<MDSContext*>> waiting_for_bootstrapping_peer;
+    std::map<epoch_t, std::vector<MDSContext*>> waiting_for_mdsmap;
 
     epoch_t osd_epoch_barrier = 0;
 

diff --git a/src/mds/MDSTable.cc b/src/mds/MDSTable.cc
index 842447e58d6eac4b132087a38ff0477799d60136..ccffb5f2c66ffcb4223beb6fd6ae02d54518260e 100644 (file)
--- a/src/mds/MDSTable.cc
+++ b/src/mds/MDSTable.cc
@@ -13,6 +13,7 @@
  */
 
 #include "MDSTable.h"
+#include "MDSContext.h"
 #include "MDSRank.h"
 
 #include "osdc/Objecter.h"

diff --git a/src/mds/MDSTable.h b/src/mds/MDSTable.h
index 164f2e02ab002401e1b8c3ce51de3879911253ca..4c34b74d58ebfb8ffaa8e79a8179c356034ce332 100644 (file)
--- a/src/mds/MDSTable.h
+++ b/src/mds/MDSTable.h
@@ -19,13 +19,13 @@
 #include "include/types.h" // for version_t
 #include "include/cephfs/types.h" // for mds_rank_t
 
-#include "MDSContext.h"
-
 #include <map>
 #include <string>
 #include <string_view>
 #include <vector>
 
+class Context;
+class MDSContext;
 class MDSRank;
 
 class MDSTable {
@@ -91,6 +91,6 @@ protected:
 
   version_t version = 0, committing_version = 0, committed_version = 0, projected_version = 0;
 
-  std::map<version_t, MDSContext::vec > waitfor_save;
+  std::map<version_t, std::vector<MDSContext*> > waitfor_save;
 };
 #endif

diff --git a/src/mds/MDSTableClient.h b/src/mds/MDSTableClient.h
index 86895cec2d38017b0bfbff953c31b17578de8065..7b96b50222d0146a734eeaf6449dc3d0af567115 100644 (file)
--- a/src/mds/MDSTableClient.h
+++ b/src/mds/MDSTableClient.h
@@ -16,7 +16,6 @@
 #define CEPH_MDSTABLECLIENT_H
 
 #include "include/types.h"
-#include "MDSContext.h"
 #include "mds_table_types.h"
 #include "mdstypes.h" // for mds_rank_t
 #include "common/ref.h" // for cref_t
@@ -25,6 +24,7 @@
 #include <map>
 #include <set>
 
+class MDSContext;
 class MMDSTableRequest;
 class MMDSTableQuery;
 class MDSRank;
@@ -104,6 +104,6 @@ protected:
 
   // pending commits
   std::map<version_t, LogSegment*> pending_commit;
-  std::map<version_t, MDSContext::vec > ack_waiters;
+  std::map<version_t, std::vector<MDSContext*> > ack_waiters;
 };
 #endif

diff --git a/src/mds/MDSTableServer.cc b/src/mds/MDSTableServer.cc
index 9983eb5fcb4873e5a43bdb2dc0a0e1d03193416e..505a686db2caf0ff75fd7587924ee7318c802be9 100644 (file)
--- a/src/mds/MDSTableServer.cc
+++ b/src/mds/MDSTableServer.cc
@@ -13,6 +13,7 @@
  */
 
 #include "MDSTableServer.h"
+#include "MDSContext.h"
 #include "MDSRank.h"
 #include "MDLog.h"
 #include "msg/Messenger.h"

diff --git a/src/mds/Migrator.h b/src/mds/Migrator.h
index d8e7c8cb41f797737a51b5bf97d4382bc4f520f0..61adf4c0e76624920d56a3d540c441a9483a5776 100644 (file)
--- a/src/mds/Migrator.h
+++ b/src/mds/Migrator.h
@@ -20,7 +20,6 @@
 #include "include/types.h"
 
 #include "Capability.h"
-#include "MDSContext.h"
 #include "Mutation.h" // for MDRequestRef
 
 #include <map>
@@ -29,6 +28,7 @@
 #include <string_view>
 
 class MDCache;
+class MDSContext;
 class MDSMap;
 class MDSRank;
 class MExportCaps;
@@ -215,7 +215,7 @@ public:
                                std::map<client_t,client_metadata_t>& exported_client_metadata_map);
   void finish_export_inode(CInode *in, mds_rank_t target,
                           std::map<client_t,Capability::Import>& peer_imported,
-                          MDSContext::vec& finished);
+                          std::vector<MDSContext*>& finished);
   void finish_export_inode_caps(CInode *in, mds_rank_t target,
                                std::map<client_t,Capability::Import>& peer_imported);
 
@@ -227,7 +227,7 @@ public:
                         uint64_t &num_exported);
   void finish_export_dir(CDir *dir, mds_rank_t target,
                         std::map<inodeno_t,std::map<client_t,Capability::Import> >& peer_imported,
-                        MDSContext::vec& finished, int *num_dentries);
+                        std::vector<MDSContext*>& finished, int *num_dentries);
 
   void clear_export_proxy_pins(CDir *dir);
 
@@ -360,7 +360,7 @@ protected:
   void child_export_finish(std::shared_ptr<export_base_t>& parent, bool success);
   void encode_export_prep_trace(bufferlist& bl, CDir *bound, CDir *dir, export_state_t &es,
                                std::set<inodeno_t> &inodes_added, std::set<dirfrag_t> &dirfrags_added);
-  void decode_export_prep_trace(bufferlist::const_iterator& blp, mds_rank_t oldauth, MDSContext::vec &finished);
+  void decode_export_prep_trace(bufferlist::const_iterator& blp, mds_rank_t oldauth, std::vector<MDSContext*> &finished);
 
   void handle_gather_caps(const cref_t<MGatherCaps> &m);
 

diff --git a/src/mds/Mutation.h b/src/mds/Mutation.h
index 7a1aece2643637af60135151739d9f950e0b93f6..dd80d1e26f9290e299e655d254ab26510566aed4 100644 (file)
--- a/src/mds/Mutation.h
+++ b/src/mds/Mutation.h
@@ -27,8 +27,6 @@
 #include "include/elist.h"
 #include "include/filepath.h"
 
-#include "MDSContext.h"
-
 #include "Capability.h"
 
 #include "common/StackStringStream.h"
@@ -42,6 +40,7 @@ class CInode;
 class CDir;
 class CDentry;
 class MDSCacheObject;
+class MDSContext;
 class Session;
 class ScatterLock;
 class SimpleLock;
@@ -345,7 +344,7 @@ struct MDRequestImpl : public MutationImpl {
     Context *peer_commit = nullptr;
     ceph::buffer::list rollback_bl;
 
-    MDSContext::vec waiting_for_finish;
+    std::vector<MDSContext*> waiting_for_finish;
 
     std::map<inodeno_t, metareqid_t> quiesce_ops;
 

diff --git a/src/mds/OpenFileTable.h b/src/mds/OpenFileTable.h
index 703934fdbf238b2e2e1206ebac11a432c4ad67b0..ae519df673e6c5f0a94a51fb2be8c5c09a437d08 100644 (file)
--- a/src/mds/OpenFileTable.h
+++ b/src/mds/OpenFileTable.h
@@ -21,14 +21,14 @@
 
 #include "mdstypes.h"
 
-#include "MDSContext.h"
-
 #include "common/config_proxy.h" // for class ConfigProxy
 #include "global/global_context.h" // for g_conf()
 
 struct inode_backpointer_t;
+class Context;
 class CDir;
 class CInode;
+class MDSContext;
 class MDSRank;
 class Anchor;
 class OpenedAnchor;
@@ -139,7 +139,7 @@ protected:
 
   std::vector<std::map<std::string, bufferlist> > loaded_journals;
   std::map<inodeno_t, RecoveredAnchor> loaded_anchor_map;
-  MDSContext::vec waiting_for_load;
+  std::vector<MDSContext*> waiting_for_load;
   bool load_done = false;
 
   enum {
@@ -150,7 +150,7 @@ protected:
   };
   unsigned prefetch_state = 0;
   unsigned num_opening_inodes = 0;
-  MDSContext::vec waiting_for_prefetch;
+  std::vector<MDSContext*> waiting_for_prefetch;
 
   std::map<uint64_t, std::vector<inodeno_t> > logseg_destroyed_inos;
   std::set<inodeno_t> destroyed_inos_set;

diff --git a/src/mds/ScatterLock.h b/src/mds/ScatterLock.h
index c6b314942f322b9d1b7b08512375383eb14ac3ae..4624f612ca449a2c400b34b68f7ebfcea78e184d 100644 (file)
--- a/src/mds/ScatterLock.h
+++ b/src/mds/ScatterLock.h
@@ -18,9 +18,10 @@
 
 #include "SimpleLock.h"
 
-#include "MDSContext.h"
 #include "include/xlist.h"
 
+class MDSContext;
+
 class ScatterLock : public SimpleLock {
 public:
   ScatterLock(MDSCacheObject *o, const LockType *lt) :
@@ -172,7 +173,7 @@ public:
     encode(s, bl);
   }
 
-  void decode_state_rejoin(ceph::buffer::list::const_iterator& p, MDSContext::vec& waiters, bool survivor) {
+  void decode_state_rejoin(ceph::buffer::list::const_iterator& p, std::vector<MDSContext*>& waiters, bool survivor) {
     SimpleLock::decode_state_rejoin(p, waiters, survivor);
     if (is_flushing()) {
       set_dirty();

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index a6d5bcca1cce25d12b96b03473362f75d61a7c8d..434f65f4ef7e1e1f2daeae88a868d30345a56342 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -295,6 +295,12 @@ Server::Server(MDSRank *m, MetricsHandler *metrics_handler) :
   supported_metric_spec = feature_bitset_t(CEPHFS_METRIC_FEATURES_ALL);
 }
 
+Server::~Server() {
+  g_ceph_context->get_perfcounters_collection()->remove(logger);
+  delete logger;
+  delete reconnect_done;
+}
+
 void Server::dispatch(const cref_t<Message> &m)
 {
   switch (m->get_type()) {

diff --git a/src/mds/Server.h b/src/mds/Server.h
index 8e0f69ef624b8c4790ed98b779cc6958f2e69b5f..44e90d0ce7152997273f1770d887f2939760862c 100644 (file)
--- a/src/mds/Server.h
+++ b/src/mds/Server.h
@@ -52,6 +52,10 @@ class LogSegment;
 class MDCache;
 class MDLog;
 class MDSContext;
+class C_MDSInternalNoop;
+using MDSGather = C_GatherBase<MDSContext, C_MDSInternalNoop>;
+using MDSGatherBuilder = C_GatherBuilderBase<MDSContext, MDSGather>;
+class MDSLogContextBase;
 class MDSRank;
 class Session;
 struct SnapInfo;
@@ -133,11 +137,7 @@ public:
   };
 
   explicit Server(MDSRank *m, MetricsHandler *metrics_handler);
-  ~Server() {
-    g_ceph_context->get_perfcounters_collection()->remove(logger);
-    delete logger;
-    delete reconnect_done;
-  }
+  ~Server();
 
   void create_logger();
 

diff --git a/src/mds/SessionMap.h b/src/mds/SessionMap.h
index 7ed36c5876688d1df50c3a97d6ece96b9ee2b0f6..eb61fe7b0b5734f7e7003d3a537eef438b21ee15 100644 (file)
--- a/src/mds/SessionMap.h
+++ b/src/mds/SessionMap.h
@@ -32,11 +32,14 @@
 #include "mds/MDSAuthCaps.h"
 #include "common/DecayCounter.h"
 
-#include "MDSContext.h"
 #include "Mutation.h" // for struct MDRequestImpl
 #include "msg/Message.h"
 
 struct MDRequestImpl;
+class MDSContext;
+class C_MDSInternalNoop;
+using MDSGather = C_GatherBase<MDSContext, C_MDSInternalNoop>;
+using MDSGatherBuilder = C_GatherBuilderBase<MDSContext, MDSGather>;
 
 enum {
   l_mdssm_first = 5500,
@@ -278,7 +281,7 @@ public:
     waitfor_flush[get_push_seq()].push_back(c);
     return get_push_seq();
   }
-  void finish_flush(version_t seq, MDSContext::vec& ls) {
+  void finish_flush(version_t seq, std::vector<MDSContext*>& ls) {
     while (!waitfor_flush.empty()) {
       auto it = waitfor_flush.begin();
       if (it->first > seq)
@@ -486,7 +489,7 @@ private:
   // -- caps --
   uint32_t cap_gen = 0;
   version_t cap_push_seq = 0;        // cap push seq #
-  std::map<version_t, MDSContext::vec > waitfor_flush; // flush session messages
+  std::map<version_t, std::vector<MDSContext*> > waitfor_flush; // flush session messages
 
   // Has completed_requests been modified since the last time we
   // wrote this session out?
@@ -786,11 +789,11 @@ public:
 
   MDSRank *mds;
   std::map<int,xlist<Session*>*> by_state;
-  std::map<version_t, MDSContext::vec> commit_waiters;
+  std::map<version_t, std::vector<MDSContext*>> commit_waiters;
 
   // -- loading, saving --
   inodeno_t ino;
-  MDSContext::vec waiting_for_load;
+  std::vector<MDSContext*> waiting_for_load;
 
 protected:
   void _mark_dirty(Session *session, bool may_save);

diff --git a/src/mds/SimpleLock.h b/src/mds/SimpleLock.h
index 0f68f0674ea7ca7fe76ca539d941544835cd042a..e443fc0748522b52609c577721a87652a0762223 100644 (file)
--- a/src/mds/SimpleLock.h
+++ b/src/mds/SimpleLock.h
@@ -24,7 +24,6 @@
 #include <boost/intrusive_ptr.hpp>
 
 #include "MDSCacheObject.h"
-#include "MDSContext.h"
 
 // -- lock types --
 // see CEPH_LOCK_*
@@ -40,6 +39,7 @@ extern "C" {
 struct MDLockCache;
 struct MDLockCacheItem;
 struct MutationImpl;
+class MDSContext;
 typedef boost::intrusive_ptr<MutationImpl> MutationRef;
 
 struct LockType {
@@ -241,7 +241,7 @@ public:
   void finish_waiters(uint64_t mask, int r=0) {
     parent->finish_waiting(getmask(mask), r);
   }
-  void take_waiting(uint64_t mask, MDSContext::vec& ls) {
+  void take_waiting(uint64_t mask, std::vector<MDSContext*>& ls) {
     parent->take_waiting(getmask(mask), ls);
   }
   void add_waiter(uint64_t mask, MDSContext *c) {
@@ -265,7 +265,7 @@ public:
     //assert(!is_stable() || gather_set.size() == 0);  // gather should be empty in stable states.
     return s;
   }
-  void set_state_rejoin(int s, MDSContext::vec& waiters, bool survivor) {
+  void set_state_rejoin(int s, std::vector<MDSContext*>& waiters, bool survivor) {
     ceph_assert(!get_parent()->is_auth());
 
     // If lock in the replica object was not in SYNC state when auth mds of the object failed.
@@ -502,7 +502,7 @@ public:
     if (is_new)
       state = s;
   }
-  void decode_state_rejoin(ceph::buffer::list::const_iterator& p, MDSContext::vec& waiters, bool survivor) {
+  void decode_state_rejoin(ceph::buffer::list::const_iterator& p, std::vector<MDSContext*>& waiters, bool survivor) {
     __s16 s;
     using ceph::decode;
     decode(s, p);

diff --git a/src/mds/SnapClient.h b/src/mds/SnapClient.h
index 178c81cd16a613e7f6b8f5299ba4d11fd027c691..2baa58e1af0d44eee8a2fcb2b176c9e07d5ac690 100644 (file)
--- a/src/mds/SnapClient.h
+++ b/src/mds/SnapClient.h
@@ -18,6 +18,7 @@
 #include <map>
 #include <set>
 #include <string_view>
+#include <vector>
 
 #include "MDSTableClient.h"
 #include "snap.h"
@@ -107,7 +108,7 @@ private:
 
   std::set<version_t> committing_tids;
 
-  std::map<version_t, MDSContext::vec > waiting_for_version;
+  std::map<version_t, std::vector<MDSContext*> > waiting_for_version;
 
   uint64_t sync_reqid = 0;
   bool synced = false;

diff --git a/src/mds/journal.cc b/src/mds/journal.cc
index 2672e18d208f9862eb1b852f3227b1a13f6c7615..94c215d344a550fe8df462fe32568439afbd07f5 100644 (file)
--- a/src/mds/journal.cc
+++ b/src/mds/journal.cc
@@ -370,6 +370,13 @@ void LogSegment::try_to_expire(MDSRank *mds, MDSGatherBuilder &gather_bld, int o
   }
 }
 
+void LogSegment::purge_inodes_finish(interval_set<inodeno_t>& inos){
+  purging_inodes.subtract(inos);
+  if (NULL != purged_cb &&
+      purging_inodes.empty())
+    purged_cb->complete(0);
+}
+
 // -----------------------
 // EMetaBlob