update sources to 12.2.10

[ceph.git] / ceph / src / mds / Migrator.h

diff --git a/ceph/src/mds/Migrator.h b/ceph/src/mds/Migrator.h
index 59d3a55b9a43727d3177d6766cfbdaac4af85199..d718a7ac48fac450e60f201d61341c50b000e591 100644 (file)
--- a/ceph/src/mds/Migrator.h
+++ b/ceph/src/mds/Migrator.h
@@ -102,38 +102,50 @@ public:
   }
 
   // -- cons --
-  Migrator(MDSRank *m, MDCache *c) : mds(m), cache(c) {
-    inject_session_race = g_conf->get_val<bool>("mds_inject_migrator_session_race");
-    inject_message_loss = g_conf->get_val<int64_t>("mds_inject_migrator_message_loss");
-  }
+  Migrator(MDSRank *m, MDCache *c);
 
   void handle_conf_change(const struct md_config_t *conf,
                           const std::set <std::string> &changed,
                           const MDSMap &mds_map);
 
 protected:
+  struct export_base_t {
+    dirfrag_t dirfrag;
+    mds_rank_t dest;
+    unsigned pending_children;
+    uint64_t export_queue_gen;
+    bool restart = false;
+    export_base_t(dirfrag_t df, mds_rank_t d, unsigned c, uint64_t g) :
+      dirfrag(df), dest(d), pending_children(c), export_queue_gen(g) {}
+  };
+
   // export fun
   struct export_state_t {
-    int state;
-    mds_rank_t peer;
-    uint64_t tid;
+    int state = 0;
+    mds_rank_t peer = MDS_RANK_NONE;
+    uint64_t tid = 0;
     set<mds_rank_t> warning_ack_waiting;
     set<mds_rank_t> notify_ack_waiting;
     map<inodeno_t,map<client_t,Capability::Import> > peer_imported;
-    set<CDir*> residual_dirs;
-
     MutationRef mut;
+    size_t approx_size = 0;
+    size_t orig_size = 0;
     // for freeze tree deadlock detection
     utime_t last_cum_auth_pins_change;
-    int last_cum_auth_pins;
-    int num_remote_waiters; // number of remote authpin waiters
-    export_state_t() : state(0), peer(0), tid(0), mut(),
-                      last_cum_auth_pins(0), num_remote_waiters(0) {}
-  };
+    int last_cum_auth_pins = 0;
+    int num_remote_waiters = 0; // number of remote authpin waiters
+    export_state_t() {}
 
+    std::shared_ptr<export_base_t> parent;
+  };
   map<CDir*, export_state_t>  export_state;
+  typedef map<CDir*, export_state_t>::iterator export_state_iterator;
+
+  uint64_t total_exporting_size = 0;
+  unsigned num_locking_exports = 0; // exports in locking state (approx_size == 0)
 
   list<pair<dirfrag_t,mds_rank_t> >  export_queue;
+  uint64_t export_queue_gen = 1;
 
   // import fun
   struct import_state_t {
@@ -153,13 +165,12 @@ protected:
 
   void handle_export_discover_ack(MExportDirDiscoverAck *m);
   void export_frozen(CDir *dir, uint64_t tid);
-  void check_export_size(CDir *dir, export_state_t& stat, set<client_t> &client_set);
   void handle_export_prep_ack(MExportDirPrepAck *m);
   void export_sessions_flushed(CDir *dir, uint64_t tid);
   void export_go(CDir *dir);
   void export_go_synced(CDir *dir, uint64_t tid);
   void export_try_cancel(CDir *dir, bool notify_peer=true);
-  void export_cancel_finish(CDir *dir);
+  void export_cancel_finish(export_state_iterator& it);
   void export_reverse(CDir *dir, export_state_t& stat);
   void export_notify_abort(CDir *dir, export_state_t& stat, set<CDir*>& bounds);
   void handle_export_ack(MExportDirAck *m);
@@ -300,9 +311,18 @@ public:
   void maybe_do_queued_export();
   void clear_export_queue() {
     export_queue.clear();
+    export_queue_gen++;
   }
   
+  void maybe_split_export(CDir* dir, uint64_t max_size, bool null_okay,
+                         vector<pair<CDir*, size_t> >& results);
+  void restart_export_dir(CDir *dir, uint64_t tid);
+  bool adjust_export_size(export_state_t &stat, CDir *dir);
+  void adjust_export_after_rename(CInode* diri, CDir *olddir);
+  void child_export_finish(std::shared_ptr<export_base_t>& parent, bool success);
+
   void get_export_lock_set(CDir *dir, set<SimpleLock*>& locks);
+  void get_export_client_set(CDir *dir, set<client_t> &client_set);
   void get_export_client_set(CInode *in, set<client_t> &client_set);
 
   void encode_export_inode(CInode *in, bufferlist& bl, 
@@ -353,6 +373,7 @@ public:
 private:
   MDSRank *mds;
   MDCache *cache;
+  uint64_t max_export_size = 0;
   bool inject_session_race = false;
   int inject_message_loss = 0;
 };