mds: scope using directives

Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>

diff --git a/src/mds/Locker.h b/src/mds/Locker.h
index 24b9d7820d1adf57b992e4bbd91c967b972ddd8f..38133be2f0945fc041c7e60e607bf1366aaa8358 100644 (file)
--- a/src/mds/Locker.h
+++ b/src/mds/Locker.h
@@ -26,9 +26,6 @@
 #include <list>
 #include <set>
 #include <string_view>
-using std::map;
-using std::list;
-using std::set;
 
 class MDSRank;
 class Session;
@@ -69,7 +66,7 @@ protected:
   void send_lock_message(SimpleLock *lock, int msg, const bufferlist &data);
 
   // -- locks --
-  void _drop_locks(MutationImpl *mut, set<CInode*> *pneed_issue, bool drop_rdlocks);
+  void _drop_locks(MutationImpl *mut, std::set<CInode*> *pneed_issue, bool drop_rdlocks);
 public:
   void include_snap_rdlocks(CInode *in, MutationImpl::LockOpVec& lov);
   void include_snap_rdlocks_wlayout(CInode *in, MutationImpl::LockOpVec& lov,
@@ -81,10 +78,10 @@ public:
                     bool auth_pin_nonblock=false);
 
   void notify_freeze_waiter(MDSCacheObject *o);
-  void cancel_locking(MutationImpl *mut, set<CInode*> *pneed_issue);
-  void drop_locks(MutationImpl *mut, set<CInode*> *pneed_issue=0);
+  void cancel_locking(MutationImpl *mut, std::set<CInode*> *pneed_issue);
+  void drop_locks(MutationImpl *mut, std::set<CInode*> *pneed_issue=0);
   void set_xlocks_done(MutationImpl *mut, bool skip_dentry=false);
-  void drop_non_rdlocks(MutationImpl *mut, set<CInode*> *pneed_issue=0);
+  void drop_non_rdlocks(MutationImpl *mut, std::set<CInode*> *pneed_issue=0);
   void drop_rdlocks_for_early_reply(MutationImpl *mut);
   void drop_locks_for_fragment_unfreeze(MutationImpl *mut);
 
@@ -99,7 +96,7 @@ public:
 
   void eval_scatter_gathers(CInode *in);
 
-  void eval_cap_gather(CInode *in, set<CInode*> *issue_set=0);
+  void eval_cap_gather(CInode *in, std::set<CInode*> *issue_set=0);
 
   bool eval(CInode *in, int mask, bool caps_imported=false);
   void try_eval(MDSCacheObject *p, int mask);
@@ -244,7 +241,7 @@ public:
   version_t issue_file_data_version(CInode *in);
   Capability* issue_new_caps(CInode *in, int mode, Session *session, SnapRealm *conrealm, bool is_replay);
   bool issue_caps(CInode *in, Capability *only_cap=0);
-  void issue_caps_set(set<CInode*>& inset);
+  void issue_caps_set(std::set<CInode*>& inset);
   void issue_truncate(CInode *in);
   void revoke_stale_caps(Session *session);
   void revoke_stale_caps(Capability *cap);

diff --git a/src/mds/MDBalancer.h b/src/mds/MDBalancer.h
index e9cb6838a047a89f69e7e5246a1c7dd254b16762..e89b192d7b2a32afa1d32dee3e5252844ba0b130 100644 (file)
--- a/src/mds/MDBalancer.h
+++ b/src/mds/MDBalancer.h
@@ -19,8 +19,6 @@
 
 #include <list>
 #include <map>
-using std::list;
-using std::map;
 
 #include "include/types.h"
 #include "common/Clock.h"
@@ -104,7 +102,7 @@ private:
   void handle_heartbeat(const MHeartbeat::const_ref &m);
   void find_exports(CDir *dir,
                     double amount,
-                    list<CDir*>& exports,
+                    std::list<CDir*>& exports,
                     double& have,
                     set<CDir*>& already_exporting);
 
@@ -151,10 +149,10 @@ private:
   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;
-  map<mds_rank_t, int> mds_last_epoch_under_map;
+  std::map<mds_rank_t, mds_load_t>  mds_load;
+  std::map<mds_rank_t, double>       mds_meta_load;
+  std::map<mds_rank_t, map<mds_rank_t, float> > mds_import_map;
+  std::map<mds_rank_t, int> mds_last_epoch_under_map;
 
   // per-epoch state
   double my_load = 0;

diff --git a/src/mds/Migrator.h b/src/mds/Migrator.h
index 6a0095a802d01043e6aea9919bd683502946931b..c59a8c77e8d100a13a7f0d285934be6d6ea36253 100644 (file)
--- a/src/mds/Migrator.h
+++ b/src/mds/Migrator.h
@@ -24,10 +24,6 @@
 #include <map>
 #include <list>
 #include <set>
-using std::map;
-using std::list;
-using std::set;
-
 
 class MDSRank;
 class CDir;
@@ -125,9 +121,9 @@ protected:
     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;
+    std::set<mds_rank_t> warning_ack_waiting;
+    std::set<mds_rank_t> notify_ack_waiting;
+    std::map<inodeno_t,std::map<client_t,Capability::Import> > peer_imported;
     MutationRef mut;
     size_t approx_size = 0;
     // for freeze tree deadlock detection
@@ -138,13 +134,13 @@ protected:
 
     std::shared_ptr<export_base_t> parent;
   };
-  map<CDir*, export_state_t>  export_state;
+  std::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;
+  std::list<pair<dirfrag_t,mds_rank_t> >  export_queue;
   uint64_t export_queue_gen = 1;
 
   // import fun
@@ -152,16 +148,16 @@ protected:
     int state;
     mds_rank_t peer;
     uint64_t tid;
-    set<mds_rank_t> bystanders;
-    list<dirfrag_t> bound_ls;
-    list<ScatterLock*> updated_scatterlocks;
-    map<client_t,pair<Session*,uint64_t> > session_map;
-    map<CInode*, map<client_t,Capability::Export> > peer_exports;
+    std::set<mds_rank_t> bystanders;
+    std::list<dirfrag_t> bound_ls;
+    std::list<ScatterLock*> updated_scatterlocks;
+    std::map<client_t,pair<Session*,uint64_t> > session_map;
+    std::map<CInode*, std::map<client_t,Capability::Export> > peer_exports;
     MutationRef mut;
     import_state_t() : state(0), peer(0), tid(0), mut() {}
   };
 
-  map<dirfrag_t, import_state_t>  import_state;
+  std::map<dirfrag_t, import_state_t>  import_state;
 
   void handle_export_discover_ack(const MExportDirDiscoverAck::const_ref &m);
   void export_frozen(CDir *dir, uint64_t tid);
@@ -172,7 +168,7 @@ protected:
   void export_try_cancel(CDir *dir, bool notify_peer=true);
   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 export_notify_abort(CDir *dir, export_state_t& stat, std::set<CDir*>& bounds);
   void handle_export_ack(const MExportDirAck::const_ref &m);
   void export_logged_finish(CDir *dir);
   void handle_export_notify_ack(const MExportDirNotifyAck::const_ref &m);
@@ -198,21 +194,21 @@ protected:
   void import_reverse_discovering(dirfrag_t df);
   void import_reverse_discovered(dirfrag_t df, CInode *diri);
   void import_reverse_prepping(CDir *dir, import_state_t& stat);
-  void import_remove_pins(CDir *dir, set<CDir*>& bounds);
+  void import_remove_pins(CDir *dir, std::set<CDir*>& bounds);
   void import_reverse_unfreeze(CDir *dir);
   void import_reverse_final(CDir *dir);
-  void import_notify_abort(CDir *dir, set<CDir*>& bounds);
-  void import_notify_finish(CDir *dir, set<CDir*>& bounds);
+  void import_notify_abort(CDir *dir, std::set<CDir*>& bounds);
+  void import_notify_finish(CDir *dir, std::set<CDir*>& bounds);
   void import_logged_start(dirfrag_t df, CDir *dir, mds_rank_t from,
-                          map<client_t,pair<Session*,uint64_t> >& imported_session_map);
+                          std::map<client_t,pair<Session*,uint64_t> >& imported_session_map);
   void handle_export_finish(const MExportDirFinish::const_ref &m);
 
   void handle_export_caps(const MExportCaps::const_ref &m);
   void handle_export_caps_ack(const MExportCapsAck::const_ref &m);
   void logged_import_caps(CInode *in,
                          mds_rank_t from,
-                         map<client_t,pair<Session*,uint64_t> >& imported_session_map,
-                         map<CInode*, map<client_t,Capability::Export> >& cap_imports);
+                         std::map<client_t,pair<Session*,uint64_t> >& imported_session_map,
+                         std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports);
 
 
   friend class C_MDS_ImportDirLoggedStart;
@@ -235,41 +231,41 @@ public:
   
   // -- status --
   int is_exporting(CDir *dir) const {
-    map<CDir*, export_state_t>::const_iterator it = export_state.find(dir);
+    auto it = export_state.find(dir);
     if (it != export_state.end()) return it->second.state;
     return 0;
   }
   bool is_exporting() const { return !export_state.empty(); }
   int is_importing(dirfrag_t df) const {
-    map<dirfrag_t, import_state_t>::const_iterator it = import_state.find(df);
+    auto it = import_state.find(df);
     if (it != import_state.end()) return it->second.state;
     return 0;
   }
   bool is_importing() const { return !import_state.empty(); }
 
   bool is_ambiguous_import(dirfrag_t df) const {
-    map<dirfrag_t, import_state_t>::const_iterator p = import_state.find(df);
-    if (p == import_state.end())
+    auto it = import_state.find(df);
+    if (it == import_state.end())
       return false;
-    if (p->second.state >= IMPORT_LOGGINGSTART &&
-       p->second.state < IMPORT_ABORTING)
+    if (it->second.state >= IMPORT_LOGGINGSTART &&
+       it->second.state < IMPORT_ABORTING)
       return true;
     return false;
   }
 
   int get_import_state(dirfrag_t df) const {
-    map<dirfrag_t, import_state_t>::const_iterator it = import_state.find(df);
+    auto it = import_state.find(df);
     ceph_assert(it != import_state.end());
     return it->second.state;
   }
   int get_import_peer(dirfrag_t df) const {
-    map<dirfrag_t, import_state_t>::const_iterator it = import_state.find(df);
+    auto it = import_state.find(df);
     ceph_assert(it != import_state.end());
     return it->second.peer;
   }
 
   int get_export_state(CDir *dir) const {
-    map<CDir*, export_state_t>::const_iterator it = export_state.find(dir);
+    auto it = export_state.find(dir);
     ceph_assert(it != export_state.end());
     return it->second.state;
   }
@@ -278,21 +274,21 @@ public:
   // be warned of ambiguous auth.
   // only returns meaningful results during EXPORT_WARNING state.
   bool export_has_warned(CDir *dir, mds_rank_t who) {
-    map<CDir*, export_state_t>::iterator it = export_state.find(dir);
+    auto it = export_state.find(dir);
     ceph_assert(it != export_state.end());
     ceph_assert(it->second.state == EXPORT_WARNING);
     return (it->second.warning_ack_waiting.count(who) == 0);
   }
 
   bool export_has_notified(CDir *dir, mds_rank_t who) const {
-    map<CDir*, export_state_t>::const_iterator it = export_state.find(dir);
+    auto it = export_state.find(dir);
     ceph_assert(it != export_state.end());
     ceph_assert(it->second.state == EXPORT_NOTIFYING);
     return (it->second.notify_ack_waiting.count(who) == 0);
   }
 
   void export_freeze_inc_num_waiters(CDir *dir) {
-    map<CDir*, export_state_t>::iterator it = export_state.find(dir);
+    auto it = export_state.find(dir);
     ceph_assert(it != export_state.end());
     it->second.num_remote_waiters++;
   }
@@ -321,28 +317,28 @@ public:
   void child_export_finish(std::shared_ptr<export_base_t>& parent, bool success);
 
   void get_export_lock_set(CDir *dir, MutationImpl::LockOpVec& lov);
-  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 get_export_client_set(CDir *dir, std::set<client_t> &client_set);
+  void get_export_client_set(CInode *in, std::set<client_t> &client_set);
 
   void encode_export_inode(CInode *in, bufferlist& bl, 
-                          map<client_t,entity_inst_t>& exported_client_map,
-                          map<client_t,client_metadata_t>& exported_client_metadata_map);
+                          std::map<client_t,entity_inst_t>& exported_client_map,
+                          std::map<client_t,client_metadata_t>& exported_client_metadata_map);
   void encode_export_inode_caps(CInode *in, bool auth_cap, bufferlist& bl,
-                               map<client_t,entity_inst_t>& exported_client_map,
-                               map<client_t,client_metadata_t>& exported_client_metadata_map);
+                               std::map<client_t,entity_inst_t>& exported_client_map,
+                               std::map<client_t,client_metadata_t>& exported_client_metadata_map);
   void finish_export_inode(CInode *in, mds_rank_t target,
-                          map<client_t,Capability::Import>& peer_imported,
+                          std::map<client_t,Capability::Import>& peer_imported,
                           MDSInternalContextBase::vec& finished);
   void finish_export_inode_caps(CInode *in, mds_rank_t target,
-                               map<client_t,Capability::Import>& peer_imported);
+                               std::map<client_t,Capability::Import>& peer_imported);
 
 
   uint64_t encode_export_dir(bufferlist& exportbl,
                        CDir *dir,
-                       map<client_t,entity_inst_t>& exported_client_map,
-                       map<client_t,client_metadata_t>& exported_client_metadata_map);
+                       std::map<client_t,entity_inst_t>& exported_client_map,
+                       std::map<client_t,client_metadata_t>& exported_client_metadata_map);
   void finish_export_dir(CDir *dir, mds_rank_t target,
-                        map<inodeno_t,map<client_t,Capability::Import> >& peer_imported,
+                        std::map<inodeno_t,std::map<client_t,Capability::Import> >& peer_imported,
                         MDSInternalContextBase::vec& finished, int *num_dentries);
 
   void clear_export_proxy_pins(CDir *dir);
@@ -351,21 +347,21 @@ public:
 
   void decode_import_inode(CDentry *dn, bufferlist::const_iterator& blp,
                           mds_rank_t oldauth, LogSegment *ls,
-                          map<CInode*, map<client_t,Capability::Export> >& cap_imports,
-                          list<ScatterLock*>& updated_scatterlocks);
+                          std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports,
+                          std::list<ScatterLock*>& updated_scatterlocks);
   void decode_import_inode_caps(CInode *in, bool auth_cap, bufferlist::const_iterator &blp,
-                               map<CInode*, map<client_t,Capability::Export> >& cap_imports);
+                               std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports);
   void finish_import_inode_caps(CInode *in, mds_rank_t from, bool auth_cap,
-                               const map<client_t,pair<Session*,uint64_t> >& smap,
-                               const map<client_t,Capability::Export> &export_map,
-                               map<client_t,Capability::Import> &import_map);
+                               const std::map<client_t,pair<Session*,uint64_t> >& smap,
+                               const std::map<client_t,Capability::Export> &export_map,
+                               std::map<client_t,Capability::Import> &import_map);
   int decode_import_dir(bufferlist::const_iterator& blp,
                        mds_rank_t oldauth,
                        CDir *import_root,
                        EImportStart *le, 
                        LogSegment *ls,
-                       map<CInode*, map<client_t,Capability::Export> >& cap_imports,
-                       list<ScatterLock*>& updated_scatterlocks);
+                       std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports,
+                       std::list<ScatterLock*>& updated_scatterlocks);
 
   void import_reverse(CDir *dir);