mds/*: forward-declare MDSContext

Signed-off-by: Max Kellermann <[email protected]>

Author: MaxKellermann

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 @@ class CDir : public MDSCacheObject, public Counter<CDir> {
   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 @@ class CDir : public MDSCacheObject, public Counter<CDir> {
     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 @@ class CDir : public MDSCacheObject, public Counter<CDir> {
   /* 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 @@ class CDir : public MDSCacheObject, public Counter<CDir> {
   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;
 

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 @@ class CInode : public MDSCacheObject, public InodeStoreBase, public Counter<CIno
   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 --

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 @@ class Locker {
   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())

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) {

src/mds/MDCache.h

@@ -1049,9 +1049,9 @@ class MDCache {
   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 @@ class MDCache {
   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 @@ class MDCache {
     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 @@ class MDCache {
     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 @@ class MDCache {
     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 @@ class MDCache {
 
   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 @@ class MDCache {
 
   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 @@ class MDCache {
     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 @@ class MDCache {
   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 @@ class MDCache {
   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;

src/mds/MDLog.h

@@ -272,7 +272,7 @@ class MDLog {
 
   bool already_replayed = false;
 
-  MDSContext::vec waitfor_replay;
+  std::vector<MDSContext*> waitfor_replay;
 
   // -- segments --
   std::map<uint64_t,LogSegment*> segments;

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);
   }

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)