mds: support export pinning on directories

src/mds/MDBalancer.cc

@@ -337,14 +337,10 @@ void MDBalancer::export_empties()
 {
   dout(5) << "export_empties checking for empty imports" << dendl;
 
-  for (map<CDir*,set<CDir*> >::iterator it = mds->mdcache->subtrees.begin();
-       it != mds->mdcache->subtrees.end();
-       ++it) {
-    CDir *dir = it->first;
-    if (!dir->is_auth() ||
-	dir->is_ambiguous_auth() ||
-	dir->is_freezing() ||
-	dir->is_frozen())
+  std::set<CDir *> subtrees;
+  mds->mdcache->get_fullauth_subtrees(subtrees);
+  for (auto &dir : subtrees) {
+    if (dir->is_freezing() || dir->is_frozen())
       continue;
 
     if (!dir->inode->is_base() &&

src/mds/MDBalancer.h

@@ -25,8 +25,6 @@ using std::map;
 #include "include/types.h"
 #include "common/Clock.h"
 #include "common/Cond.h"
-#include "CInode.h"
-
 
 class MDSRank;
 class Message;
@@ -37,49 +35,7 @@ class Messenger;
 class MonClient;
 
 class MDBalancer {
- protected:
-  MDSRank *mds;
-  Messenger *messenger;
-  MonClient *mon_client;
-  int beat_epoch;
-
-  int last_epoch_under;  
-  int last_epoch_over; 
-  string bal_code;
-  string bal_version;
-
-  utime_t last_heartbeat;
-  utime_t last_sample;    
-  utime_t rebalance_time; //ensure a consistent view of load for rebalance
-
-  // Dirfrags which are marked to be passed on to MDCache::[split|merge]_dir
-  // just as soon as a delayed context comes back and triggers it.
-  // These sets just prevent us from spawning extra timer contexts for
-  // dirfrags that already have one in flight.
-  set<dirfrag_t>   split_pending, merge_pending;
-
-  // per-epoch scatter/gathered info
-  map<mds_rank_t, mds_load_t>  mds_load;
-  map<mds_rank_t, double>       mds_meta_load;
-  map<mds_rank_t, map<mds_rank_t, float> > mds_import_map;
-
-  // per-epoch state
-  double          my_load, target_load;
-  map<mds_rank_t,double> my_targets;
-  map<mds_rank_t,double> imported;
-  map<mds_rank_t,double> exported;
-
-  map<mds_rank_t, int> old_prev_targets;  // # iterations they _haven't_ been targets
-  bool check_targets();
-
-  double try_match(mds_rank_t ex, double& maxex,
-                   mds_rank_t im, double& maxim);
-  double get_maxim(mds_rank_t im) {
-    return target_load - mds_meta_load[im] - imported[im];
-  }
-  double get_maxex(mds_rank_t ex) {
-    return mds_meta_load[ex] - target_load - exported[ex];    
-  }
+  friend class C_Bal_SendHeartbeat;
 
 public:
   MDBalancer(MDSRank *m, Messenger *msgr, MonClient *monc) : 
@@ -88,39 +44,32 @@ class MDBalancer {
     mon_client(monc),
     beat_epoch(0),
     last_epoch_under(0), last_epoch_over(0), my_load(0.0), target_load(0.0) { }
-  
+
   mds_load_t get_load(utime_t);
 
   int proc_message(Message *m);
-
-  int localize_balancer();
-  void send_heartbeat();
-  void handle_heartbeat(MHeartbeat *m);
 
+  /**
+   * Regularly called upkeep function.
+   *
+   * Sends MHeartbeat messages to the mons.
+   */
   void tick();
 
-  void export_empties();
-  //set up the rebalancing targets for export and do one if the
-  //MDSMap is up to date
-  void prep_rebalance(int beat);
-  int mantle_prep_rebalance();
-  /*check if the monitor has recorded the current export targets;
-    if it has then do the actual export. Otherwise send off our
-    export targets message again*/
+  /**
+   * Try to rebalance after receiving monitor mdsmap update.
+   *
+   * Check if the monitor has recorded the current export targets;
+   * if it has then do the actual export. Otherwise send off our
+   * export targets message again.
+   */
   void try_rebalance();
-  void find_exports(CDir *dir, 
-                    double amount, 
-                    list<CDir*>& exports, 
-                    double& have,
-                    set<CDir*>& already_exporting);
 
+  void subtract_export(CDir *ex, utime_t now);
+  void add_import(CDir *im, utime_t now);
 
-  void subtract_export(class CDir *ex, utime_t now);
-  void add_import(class CDir *im, utime_t now);
-
-  void hit_inode(utime_t now, class CInode *in, int type, int who=-1);
-  void hit_dir(utime_t now, class CDir *dir, int type, int who=-1, double amount=1.0);
-  void hit_recursive(utime_t now, class CDir *dir, int type, double amount, double rd_adj);
+  void hit_inode(utime_t now, CInode *in, int type, int who=-1);
+  void hit_dir(utime_t now, CDir *dir, int type, int who=-1, double amount=1.0);
 
   void queue_split(const CDir *dir, bool fast);
   void queue_merge(CDir *dir);
@@ -132,8 +81,65 @@ class MDBalancer {
    * \param hot whether the directory's temperature is enough to split it
    */
   void maybe_fragment(CDir *dir, bool hot);
-};
 
+private:
+  //set up the rebalancing targets for export and do one if the
+  //MDSMap is up to date
+  void prep_rebalance(int beat);
+  int mantle_prep_rebalance();
+
+  void export_empties();
+  int localize_balancer();
+  bool check_targets();
+  void send_heartbeat();
+  void handle_heartbeat(MHeartbeat *m);
+  void find_exports(CDir *dir,
+                    double amount,
+                    list<CDir*>& exports,
+                    double& have,
+                    set<CDir*>& already_exporting);
+
+  double try_match(mds_rank_t ex, double& maxex,
+                   mds_rank_t im, double& maxim);
+  double get_maxim(mds_rank_t im) {
+    return target_load - mds_meta_load[im] - imported[im];
+  }
+  double get_maxex(mds_rank_t ex) {
+    return mds_meta_load[ex] - target_load - exported[ex];
+  }
+
+  MDSRank *mds;
+  Messenger *messenger;
+  MonClient *mon_client;
+  int beat_epoch;
+
+  int last_epoch_under;
+  int last_epoch_over;
+  string bal_code;
+  string bal_version;
+
+  utime_t last_heartbeat;
+  utime_t last_sample;
+  utime_t rebalance_time; //ensure a consistent view of load for rebalance
+
+  // Dirfrags which are marked to be passed on to MDCache::[split|merge]_dir
+  // just as soon as a delayed context comes back and triggers it.
+  // These sets just prevent us from spawning extra timer contexts for
+  // dirfrags that already have one in flight.
+  set<dirfrag_t>   split_pending, merge_pending;
 
+  // per-epoch scatter/gathered info
+  map<mds_rank_t, mds_load_t>  mds_load;
+  map<mds_rank_t, double>       mds_meta_load;
+  map<mds_rank_t, map<mds_rank_t, float> > mds_import_map;
+
+  // per-epoch state
+  double          my_load, target_load;
+  map<mds_rank_t,double> my_targets;
+  map<mds_rank_t,double> imported;
+  map<mds_rank_t,double> exported;
+
+  map<mds_rank_t, int> old_prev_targets;  // # iterations they _haven't_ been targets
+};
 
 #endif

src/mds/MDCache.cc

@@ -1257,19 +1257,15 @@ void MDCache::verify_subtree_bounds(CDir *dir, const set<CDir*>& bounds)
   if (bounds != subtrees[dir]) {
     dout(0) << "verify_subtree_bounds failed" << dendl;
     set<CDir*> b = bounds;
-    for (set<CDir*>::iterator p = subtrees[dir].begin();
-	 p != subtrees[dir].end();
-	 ++p) {
-      if (bounds.count(*p)) {
-	b.erase(*p);
+    for (auto &cd : subtrees[dir]) {
+      if (bounds.count(cd)) {
+	b.erase(cd);
 	continue;
       }
-      dout(0) << "  missing bound " << **p << dendl;
+      dout(0) << "  missing bound " << *cd << dendl;
     }
-    for (set<CDir*>::iterator p = b.begin();
-	 p != b.end();
-	 ++p) 
-      dout(0) << "    extra bound " << **p << dendl;
+    for (const auto &cd : b)
+      dout(0) << "    extra bound " << *cd << dendl;
   }
   assert(bounds == subtrees[dir]);
 }
@@ -1281,10 +1277,8 @@ void MDCache::verify_subtree_bounds(CDir *dir, const list<dirfrag_t>& bounds)
 
   // make sure that any bounds i do have are properly noted as such.
   int failed = 0;
-  for (list<dirfrag_t>::const_iterator p = bounds.begin();
-       p != bounds.end();
-       ++p) {
-    CDir *bd = get_dirfrag(*p);
+  for (const auto &fg : bounds) {
+    CDir *bd = get_dirfrag(fg);
     if (!bd) continue;
     if (subtrees[dir].count(bd) == 0) {
       dout(0) << "verify_subtree_bounds failed: extra bound " << *bd << dendl;

src/mds/MDCache.h

@@ -252,7 +252,8 @@ class MDCache {
 
   // -- subtrees --
 protected:
-  map<CDir*,set<CDir*> > subtrees;   // nested bounds on subtrees.
+  /* subtree keys and each tree's non-recursive nested subtrees (the "bounds") */
+  map<CDir*,set<CDir*> > subtrees;
   map<CInode*,list<pair<CDir*,CDir*> > > projected_subtree_renames;  // renamed ino -> target dir
 
   // adjust subtree auth specification

src/mds/MDSRank.cc

@@ -17,6 +17,7 @@
 
 #include "messages/MClientRequestForward.h"
 #include "messages/MMDSMap.h"
+#include "messages/MMDSTableRequest.h"
 #include "messages/MCommand.h"
 #include "messages/MCommandReply.h"
 
@@ -25,7 +26,6 @@
 #include "SnapClient.h"
 #include "SnapServer.h"
 #include "MDBalancer.h"
-#include "messages/MMDSTableRequest.h"
 #include "Locker.h"
 #include "Server.h"
 #include "InoTable.h"

src/mds/Migrator.cc

@@ -1269,7 +1269,7 @@ void Migrator::export_go_synced(CDir *dir, uint64_t tid)
   // fill export message with cache data
   MExportDir *req = new MExportDir(dir->dirfrag(), it->second.tid);
   map<client_t,entity_inst_t> exported_client_map;
-  int num_exported_inodes = encode_export_dir(req->export_data,
+  uint64_t num_exported_inodes = encode_export_dir(req->export_data,
 					      dir,   // recur start point
 					      exported_client_map,
 					      now);
@@ -1430,12 +1430,12 @@ void Migrator::finish_export_inode(CInode *in, utime_t now, mds_rank_t peer,
 
 }
 
-int Migrator::encode_export_dir(bufferlist& exportbl,
+uint64_t Migrator::encode_export_dir(bufferlist& exportbl,
 				CDir *dir,
 				map<client_t,entity_inst_t>& exported_client_map,
 				utime_t now)
 {
-  int num_exported = 0;
+  uint64_t num_exported = 0;
 
   dout(7) << "encode_export_dir " << *dir << " " << dir->get_num_head_items() << " head items" << dendl;
 
@@ -1700,10 +1700,7 @@ void Migrator::export_reverse(CDir *dir)
   }
 
   // unpin bounds
-  for (set<CDir*>::iterator p = bounds.begin();
-       p != bounds.end();
-       ++p) {
-    CDir *bd = *p;
+  for (const auto &bd : bounds) {
     bd->put(CDir::PIN_EXPORTBOUND);
     bd->state_clear(CDir::STATE_EXPORTBOUND);
   }