mds: convert IO contexts

As of this change, the only thing in the MDS inheriting
directly from Context is MDSContext.

The only files touching mds_lock explicitly are MDS, MDLog and
MDSContext -- everyone else should be getting their locking behaviour
via the contexts.  (one minor exception made for an assertion in
Locker).

Signed-off-by: John Spray <john.spray@redhat.com>

diff --git a/src/mds/CDir.cc b/src/mds/CDir.cc
index 5e4c13ec71f6460181b2a9054f65a856a68bbea1..d30d2f7da84edea3995849f64e86b1883afb6edf 100644 (file)
--- a/src/mds/CDir.cc
+++ b/src/mds/CDir.cc
@@ -42,6 +42,32 @@
 
 
 
+class CDirContext : public MDSInternalContextBase
+{
+protected:
+  CDir *dir;
+  MDS* get_mds() {return dir->cache->mds;}
+
+public:
+  CDirContext(CDir *d) : dir(d) {
+    assert(dir != NULL);
+  }
+};
+
+
+class CDirIOContext : public MDSIOContextBase
+{
+protected:
+  CDir *dir;
+  MDS* get_mds() {return dir->cache->mds;}
+
+public:
+  CDirIOContext(CDir *d) : dir(d) {
+    assert(dir != NULL);
+  }
+};
+
+
 // PINS
 //int cdir_pins[CDIR_NUM_PINS] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
 
@@ -1263,11 +1289,10 @@ void CDir::mark_clean()
 }
 
 
-struct C_Dir_Dirty : public MDSInternalContext {
-  CDir *dir;
+struct C_Dir_Dirty : public CDirContext {
   version_t pv;
   LogSegment *ls;
-  C_Dir_Dirty(CDir *d, version_t p, LogSegment *l) : MDSInternalContext(d->cache->mds), dir(d), pv(p), ls(l) {}
+  C_Dir_Dirty(CDir *d, version_t p, LogSegment *l) : CDirContext(d), pv(p), ls(l) {}
   void finish(int r) {
     dir->mark_dirty(pv, ls);
   }
@@ -1342,16 +1367,14 @@ void CDir::fetch(MDSInternalContextBase *c, const string& want_dn, bool ignore_a
   _omap_fetch(want_dn);
 }
 
-class C_IO_Dir_TMAP_Fetched : public Context {
+class C_IO_Dir_TMAP_Fetched : public CDirIOContext {
  protected:
-  CDir *dir;
   string want_dn;
  public:
   bufferlist bl;
 
-  C_IO_Dir_TMAP_Fetched(CDir *d, const string& w) : dir(d), want_dn(w) { }
+  C_IO_Dir_TMAP_Fetched(CDir *d, const string& w) : CDirIOContext(d), want_dn(w) { }
   void finish(int r) {
-    Mutex::Locker l(dir->cache->mds->mds_lock);
     dir->_tmap_fetched(bl, want_dn, r);
   }
 };
@@ -1398,18 +1421,16 @@ void CDir::_tmap_fetched(bufferlist& bl, const string& want_dn, int r)
   _omap_fetched(header, omap, want_dn, r);
 }
 
-class C_IO_Dir_OMAP_Fetched : public Context {
+class C_IO_Dir_OMAP_Fetched : public CDirIOContext {
  protected:
-  CDir *dir;
   string want_dn;
  public:
   bufferlist hdrbl;
   map<string, bufferlist> omap;
   int ret1, ret2;
 
-  C_IO_Dir_OMAP_Fetched(CDir *d, const string& w) : dir(d), want_dn(w) { }
+  C_IO_Dir_OMAP_Fetched(CDir *d, const string& w) : CDirIOContext(d), want_dn(w) { }
   void finish(int r) {
-    Mutex::Locker l(dir->cache->mds->mds_lock);
     if (r >= 0) r = ret1;
     if (r >= 0) r = ret2;
     dir->_omap_fetched(hdrbl, omap, want_dn, r);
@@ -1751,13 +1772,11 @@ void CDir::commit(version_t want, MDSInternalContextBase *c, bool ignore_authpin
   _commit(want, op_prio);
 }
 
-class C_IO_Dir_Committed : public Context {
-  CDir *dir;
+class C_IO_Dir_Committed : public CDirIOContext {
   version_t version;
 public:
-  C_IO_Dir_Committed(CDir *d, version_t v) : dir(d), version(v) { }
+  C_IO_Dir_Committed(CDir *d, version_t v) : CDirIOContext(d), version(v) { }
   void finish(int r) {
-    Mutex::Locker l(dir->cache->mds->mds_lock);
     assert(r == 0);
     dir->_committed(version);
   }
@@ -2483,11 +2502,9 @@ CDir *CDir::get_frozen_tree_root()
   }
 }
 
-class C_Dir_AuthUnpin : public MDSInternalContext {
-  CDir *dir;
-
+class C_Dir_AuthUnpin : public CDirContext {
   public:
-  C_Dir_AuthUnpin(CDir *d) : MDSInternalContext(dir->cache->mds), dir(d) {}
+  C_Dir_AuthUnpin(CDir *d) : CDirContext(d) {}
   void finish(int r) {
     dir->auth_unpin(dir->get_inode());
   }

diff --git a/src/mds/CInode.cc b/src/mds/CInode.cc
index cd5253a8324b6c711268a36c7473410072ddcf97..182d830359c07492a9c115b708f7ffbdeab93088 100644 (file)
--- a/src/mds/CInode.cc
+++ b/src/mds/CInode.cc
@@ -49,6 +49,18 @@
 #define dout_prefix *_dout << "mds." << mdcache->mds->get_nodeid() << ".cache.ino(" << inode.ino << ") "
 
 
+class CInodeIOContext : public MDSIOContextBase
+{
+protected:
+  CInode *in;
+  MDS *get_mds() {return in->mdcache->mds;}
+public:
+  CInodeIOContext(CInode *in_) : in(in_) {
+    assert(in != NULL);
+  }
+};
+
+
 boost::pool<> CInode::pool(sizeof(CInode));
 boost::pool<> Capability::pool(sizeof(Capability));
 
@@ -885,13 +897,11 @@ void CInode::mark_clean()
 // per-inode storage
 // (currently for root inode only)
 
-struct C_IO_Inode_Stored : public Context {
-  CInode *in;
+struct C_IO_Inode_Stored : public CInodeIOContext {
   version_t version;
   Context *fin;
-  C_IO_Inode_Stored(CInode *i, version_t v, Context *f) : in(i), version(v), fin(f) {}
+  C_IO_Inode_Stored(CInode *i, version_t v, Context *f) : CInodeIOContext(i), version(v), fin(f) {}
   void finish(int r) {
-    Mutex::Locker l(in->mdcache->mds->mds_lock);
     assert(r == 0);
     in->_stored(version, fin);
   }
@@ -940,13 +950,11 @@ void CInode::_stored(version_t v, Context *fin)
   fin->complete(0);
 }
 
-struct C_IO_Inode_Fetched : public Context {
-  CInode *in;
+struct C_IO_Inode_Fetched : public CInodeIOContext {
   bufferlist bl, bl2;
   Context *fin;
-  C_IO_Inode_Fetched(CInode *i, Context *f) : in(i), fin(f) {}
+  C_IO_Inode_Fetched(CInode *i, Context *f) : CInodeIOContext(i), fin(f) {}
   void finish(int r) {
-    Mutex::Locker l(in->mdcache->mds->mds_lock);
     in->_fetched(bl, bl2, fin);
   }
 };
@@ -1021,13 +1029,11 @@ void CInode::build_backtrace(int64_t pool, inode_backtrace_t& bt)
   }
 }
 
-struct C_IO_Inode_StoredBacktrace : public Context {
-  CInode *in;
+struct C_IO_Inode_StoredBacktrace : public CInodeIOContext {
   version_t version;
   Context *fin;
-  C_IO_Inode_StoredBacktrace(CInode *i, version_t v, Context *f) : in(i), version(v), fin(f) {}
+  C_IO_Inode_StoredBacktrace(CInode *i, version_t v, Context *f) : CInodeIOContext(i), version(v), fin(f) {}
   void finish(int r) {
-    Mutex::Locker l(in->mdcache->mds->mds_lock);
     assert(r == 0);
     in->_stored_backtrace(version, fin);
   }
@@ -1693,15 +1699,18 @@ void CInode::start_scatter(ScatterLock *lock)
 }
 
 
-struct C_Inode_FragUpdate : public MDSInternalContext {
+class C_Inode_FragUpdate : public MDSInternalContextBase {
+protected:
   CInode *in;
   CDir *dir;
   MutationRef mut;
-
-  C_Inode_FragUpdate(CInode *i, CDir *d, MutationRef& m) : MDSInternalContext(i->mdcache->mds), in(i), dir(d), mut(m) {}
+  MDS *get_mds() {return in->mdcache->mds;}
   void finish(int r) {
     in->_finish_frag_update(dir, mut);
   }    
+
+public:
+  C_Inode_FragUpdate(CInode *i, CDir *d, MutationRef& m) : in(i), dir(d), mut(m) {}
 };
 
 void CInode::finish_scatter_update(ScatterLock *lock, CDir *dir,

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index 258216a2ba1fca9cd6ee883a40d1d42fff2139fa..391a3797b60372ac2cc5a503b3951fbc6e58ce4b 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -71,12 +71,13 @@ class LockerContext : public MDSInternalContextBase {
   Locker *locker;
   MDS *get_mds()
   {
-    assert(locker != NULL);
     return locker->mds;
   }
 
   public:
-  LockerContext(Locker *locker_) : locker(locker_) {}
+  LockerContext(Locker *locker_) : locker(locker_) {
+    assert(locker != NULL);
+  }
 };
 
 

diff --git a/src/mds/MDLog.cc b/src/mds/MDLog.cc
index f2a87ab81db0447f201f23bae1334b289226e096..473b7ce32b635b7d0eddb3fb0fedf5c36231364a 100644 (file)
--- a/src/mds/MDLog.cc
+++ b/src/mds/MDLog.cc
@@ -130,7 +130,9 @@ void MDLog::create(MDSInternalContextBase *c)
   dout(5) << "create empty log" << dendl;
 
   C_GatherBuilder gather(g_ceph_context);
-  gather.set_finisher(new C_IO_Wrapper(mds, c));
+  // This requires an OnFinisher wrapper because Journaler will call back the completion for write_head inside its own lock
+  // XXX but should maybe that be handled inside Journaler?
+  gather.set_finisher(new C_OnFinisher(new C_IO_Wrapper(mds, c), &(mds->finisher)));
 
   // The inode of the default Journaler we will create
   ino = MDS_INO_LOG_OFFSET + mds->get_nodeid();

diff --git a/src/mds/MDSContext.h b/src/mds/MDSContext.h
index 0d307058c7169604f9375a9c4fa5ba4607573462..9da667403e3db7ddcaba12107ee6a754b84fa61f 100644 (file)
--- a/src/mds/MDSContext.h
+++ b/src/mds/MDSContext.h
@@ -55,7 +55,9 @@ protected:
   virtual MDS* get_mds();
 
 public:
-  MDSInternalContext(MDS *mds_) : mds(mds_) {}
+  MDSInternalContext(MDS *mds_) : mds(mds_) {
+    assert(mds != NULL);
+  }
 };
 
 
@@ -75,17 +77,19 @@ protected:
   virtual MDS* get_mds();
 
 public:
-  MDSIOContext(MDS *mds_) : mds(mds_) {}
+  MDSIOContext(MDS *mds_) : mds(mds_) {
+    assert(mds != NULL);
+  }
 };
 
 
 /**
  * No-op for callers expecting MDSInternalContextBase
  */
-class C_MDSInternalNoop : public MDSInternalContext
+class C_MDSInternalNoop : public MDSInternalContextBase
 {
+  virtual MDS* get_mds() {assert(0);}
 public:
-  C_MDSInternalNoop() : MDSInternalContext(NULL) {}
   void finish(int r) {}
   void complete(int r) {}
 };

diff --git a/src/mds/MDSTable.cc b/src/mds/MDSTable.cc
index ad4858a0435dd4be5f6003e24e3fc8d17442e2e3..323740fbb0d27d613add9d56b2561ba1a74315e2 100644 (file)
--- a/src/mds/MDSTable.cc
+++ b/src/mds/MDSTable.cc
@@ -32,13 +32,23 @@
 #define dout_prefix *_dout << "mds." << (mds ? mds->get_nodeid() : -1) << "." << table_name << ": "
 
 
-class C_IO_MT_Save : public Context {
-  MDSTable *ida;
+class MDSTableIOContext : public MDSIOContextBase
+{
+  protected:
+    MDSTable *ida;
+    MDS *get_mds() {return ida->mds;}
+  public:
+    MDSTableIOContext(MDSTable *ida_) : ida(ida_) {
+      assert(ida != NULL);
+    }
+};
+
+
+class C_IO_MT_Save : public MDSTableIOContext {
   version_t version;
 public:
-  C_IO_MT_Save(MDSTable *i, version_t v) : ida(i), version(v) {}
+  C_IO_MT_Save(MDSTable *i, version_t v) : MDSTableIOContext(i), version(v) {}
   void finish(int r) {
-    Mutex::Locker l(ida->mds->mds_lock);
     ida->save_2(r, version);
   }
 };
@@ -110,14 +120,12 @@ void MDSTable::reset()
 
 // -----------------------
 
-class C_IO_MT_Load : public Context {
+class C_IO_MT_Load : public MDSTableIOContext {
 public:
-  MDSTable *ida;
   Context *onfinish;
   bufferlist bl;
-  C_IO_MT_Load(MDSTable *i, Context *o) : ida(i), onfinish(o) {}
+  C_IO_MT_Load(MDSTable *i, Context *o) : MDSTableIOContext(i), onfinish(o) {}
   void finish(int r) {
-    Mutex::Locker l(ida->mds->mds_lock);
     ida->load_2(r, bl, onfinish);
   }
 };

diff --git a/src/mds/Server.cc b/src/mds/Server.cc
index f5fbe2852f2b2c2a44c9f19d977a7f78961a1fe4..45c05822975a2b6c0020037c1045d5a24e48d7ab 100644 (file)
--- a/src/mds/Server.cc
+++ b/src/mds/Server.cc
@@ -74,7 +74,7 @@ using namespace std;
 #define dout_prefix *_dout << "mds." << mds->get_nodeid() << ".server "
 
 
-class C_ServerContext : public MDSInternalContextBase {
+class ServerContext : public MDSInternalContextBase {
   protected:
   Server *server;
   MDS *get_mds()
@@ -83,7 +83,7 @@ class C_ServerContext : public MDSInternalContextBase {
   }
 
   public:
-  C_ServerContext(Server *s) : server(s) {
+  ServerContext(Server *s) : server(s) {
     assert(server != NULL);
   }
 };
@@ -441,12 +441,12 @@ void Server::finish_force_open_sessions(map<client_t,entity_inst_t>& cm,
   mds->sessionmap.version++;
 }
 
-class C_MDS_TerminatedSessions : public C_ServerContext {
+class C_MDS_TerminatedSessions : public ServerContext {
   void finish(int r) {
     server->terminating_sessions = false;
   }
   public:
-  C_MDS_TerminatedSessions(Server *s) : C_ServerContext(s) {}
+  C_MDS_TerminatedSessions(Server *s) : ServerContext(s) {}
 };
 
 void Server::terminate_sessions()
@@ -2119,10 +2119,10 @@ CDir *Server::traverse_to_auth_dir(MDRequestRef& mdr, vector<CDentry*> &trace, f
   return dir;
 }
 
-class C_MDS_TryFindInode : public C_ServerContext {
+class C_MDS_TryFindInode : public ServerContext {
   MDRequestRef mdr;
 public:
-  C_MDS_TryFindInode(Server *s, MDRequestRef& r) : C_ServerContext(s), mdr(r) {}
+  C_MDS_TryFindInode(Server *s, MDRequestRef& r) : ServerContext(s), mdr(r) {}
   virtual void finish(int r) {
     if (r == -ESTALE) // :( find_ino_peers failed
       server->reply_request(mdr, r);
@@ -2425,9 +2425,9 @@ void Server::handle_client_getattr(MDRequestRef& mdr, bool is_lookup)
                is_lookup ? mdr->dn[0].back() : 0);
 }
 
-struct C_MDS_LookupIno2 : public C_ServerContext {
+struct C_MDS_LookupIno2 : public ServerContext {
   MDRequestRef mdr;
-  C_MDS_LookupIno2(Server *s, MDRequestRef& r) : C_ServerContext(s), mdr(r) {}
+  C_MDS_LookupIno2(Server *s, MDRequestRef& r) : ServerContext(s), mdr(r) {}
   void finish(int r) {
     server->_lookup_ino_2(mdr, r);
   }
@@ -4504,24 +4504,24 @@ void Server::_link_remote_finish(MDRequestRef& mdr, bool inc,
 
 // remote linking/unlinking
 
-class C_MDS_SlaveLinkPrep : public C_ServerContext {
+class C_MDS_SlaveLinkPrep : public ServerContext {
   MDRequestRef mdr;
   CInode *targeti;
 public:
   C_MDS_SlaveLinkPrep(Server *s, MDRequestRef& r, CInode *t) :
-    C_ServerContext(s), mdr(r), targeti(t) { }
+    ServerContext(s), mdr(r), targeti(t) { }
   void finish(int r) {
     assert(r == 0);
     server->_logged_slave_link(mdr, targeti);
   }
 };
 
-class C_MDS_SlaveLinkCommit : public C_ServerContext {
+class C_MDS_SlaveLinkCommit : public ServerContext {
   MDRequestRef mdr;
   CInode *targeti;
 public:
   C_MDS_SlaveLinkCommit(Server *s, MDRequestRef& r, CInode *t) :
-    C_ServerContext(s), mdr(r), targeti(t) { }
+    ServerContext(s), mdr(r), targeti(t) { }
   void finish(int r) {
     server->_commit_slave_link(mdr, r, targeti);
   }
@@ -4627,9 +4627,9 @@ void Server::_logged_slave_link(MDRequestRef& mdr, CInode *targeti)
 }
 
 
-struct C_MDS_CommittedSlave : public C_ServerContext {
+struct C_MDS_CommittedSlave : public ServerContext {
   MDRequestRef mdr;
-  C_MDS_CommittedSlave(Server *s, MDRequestRef& m) : C_ServerContext(s), mdr(m) {}
+  C_MDS_CommittedSlave(Server *s, MDRequestRef& m) : ServerContext(s), mdr(m) {}
   void finish(int r) {
     server->_committed_slave(mdr);
   }
@@ -4669,10 +4669,10 @@ void Server::_committed_slave(MDRequestRef& mdr)
   mds->mdcache->request_finish(mdr);
 }
 
-struct C_MDS_LoggedLinkRollback : public C_ServerContext {
+struct C_MDS_LoggedLinkRollback : public ServerContext {
   MutationRef mut;
   MDRequestRef mdr;
-  C_MDS_LoggedLinkRollback(Server *s, MutationRef& m, MDRequestRef& r) : C_ServerContext(s), mut(m), mdr(r) {}
+  C_MDS_LoggedLinkRollback(Server *s, MutationRef& m, MDRequestRef& r) : ServerContext(s), mut(m), mdr(r) {}
   void finish(int r) {
     server->_link_rollback_finish(mut, mdr);
   }
@@ -5092,21 +5092,20 @@ bool Server::_rmdir_prepare_witness(MDRequestRef& mdr, int who, CDentry *dn, CDe
   return true;
 }
 
-struct C_MDS_SlaveRmdirPrep : public C_ServerContext {
+struct C_MDS_SlaveRmdirPrep : public ServerContext {
   MDRequestRef mdr;
   CDentry *dn, *straydn;
   C_MDS_SlaveRmdirPrep(Server *s, MDRequestRef& r, CDentry *d, CDentry *st)
-    : C_ServerContext(s), mdr(r), dn(d), straydn(st) {}
+    : ServerContext(s), mdr(r), dn(d), straydn(st) {}
   void finish(int r) {
     server->_logged_slave_rmdir(mdr, dn, straydn);
   }
 };
 
-struct C_MDS_SlaveRmdirCommit : public Context {
-  Server *server;
+struct C_MDS_SlaveRmdirCommit : public ServerContext {
   MDRequestRef mdr;
   C_MDS_SlaveRmdirCommit(Server *s, MDRequestRef& r)
-    : server(s), mdr(r) { }
+    : ServerContext(s), mdr(r) { }
   void finish(int r) {
     server->_commit_slave_rmdir(mdr, r);
   }
@@ -5270,13 +5269,13 @@ void Server::_commit_slave_rmdir(MDRequestRef& mdr, int r)
   }
 }
 
-struct C_MDS_LoggedRmdirRollback : public C_ServerContext {
+struct C_MDS_LoggedRmdirRollback : public ServerContext {
   MDRequestRef mdr;
   metareqid_t reqid;
   CDentry *dn;
   CDentry *straydn;
   C_MDS_LoggedRmdirRollback(Server *s, MDRequestRef& m, metareqid_t mr, CDentry *d, CDentry *st)
-    : C_ServerContext(s), mdr(m), reqid(mr), dn(d), straydn(st) {}
+    : ServerContext(s), mdr(m), reqid(mr), dn(d), straydn(st) {}
   void finish(int r) {
     server->_rmdir_rollback_finish(mdr, reqid, dn, straydn);
   }
@@ -6435,33 +6434,33 @@ void Server::_rename_apply(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, C
 // ------------
 // SLAVE
 
-class C_MDS_SlaveRenamePrep : public C_ServerContext {
+class C_MDS_SlaveRenamePrep : public ServerContext {
   MDRequestRef mdr;
   CDentry *srcdn, *destdn, *straydn;
 public:
   C_MDS_SlaveRenamePrep(Server *s, MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
-    C_ServerContext(s), mdr(m), srcdn(sr), destdn(de), straydn(st) {}
+    ServerContext(s), mdr(m), srcdn(sr), destdn(de), straydn(st) {}
   void finish(int r) {
     server->_logged_slave_rename(mdr, srcdn, destdn, straydn);
   }
 };
 
-class C_MDS_SlaveRenameCommit : public C_ServerContext {
+class C_MDS_SlaveRenameCommit : public ServerContext {
   MDRequestRef mdr;
   CDentry *srcdn, *destdn, *straydn;
 public:
   C_MDS_SlaveRenameCommit(Server *s, MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
-    C_ServerContext(s), mdr(m), srcdn(sr), destdn(de), straydn(st) {}
+    ServerContext(s), mdr(m), srcdn(sr), destdn(de), straydn(st) {}
   void finish(int r) {
     server->_commit_slave_rename(mdr, r, srcdn, destdn, straydn);
   }
 };
 
-class C_MDS_SlaveRenameSessionsFlushed : public C_ServerContext {
+class C_MDS_SlaveRenameSessionsFlushed : public ServerContext {
   MDRequestRef mdr;
 public:
   C_MDS_SlaveRenameSessionsFlushed(Server *s, MDRequestRef& r) :
-    C_ServerContext(s), mdr(r) {}
+    ServerContext(s), mdr(r) {}
   void finish(int r) {
     server->_slave_rename_sessions_flushed(mdr);
   }
@@ -6871,7 +6870,7 @@ void _rollback_repair_dir(MutationRef& mut, CDir *dir, rename_rollback::drec &r,
   mut->add_updated_lock(&dir->get_inode()->nestlock);
 }
 
-struct C_MDS_LoggedRenameRollback : public C_ServerContext {
+struct C_MDS_LoggedRenameRollback : public ServerContext {
   MutationRef mut;
   MDRequestRef mdr;
   CDentry *srcdn;
@@ -6882,7 +6881,7 @@ struct C_MDS_LoggedRenameRollback : public C_ServerContext {
   C_MDS_LoggedRenameRollback(Server *s, MutationRef& m, MDRequestRef& r,
                             CDentry *sd, version_t pv, CDentry *dd,
                             CDentry *st, bool f) :
-    C_ServerContext(s), mut(m), mdr(r), srcdn(sd), srcdnpv(pv), destdn(dd),
+    ServerContext(s), mut(m), mdr(r), srcdn(sd), srcdnpv(pv), destdn(dd),
     straydn(st), finish_mdr(f) {}
   void finish(int r) {
     server->_rename_rollback_finish(mut, mdr, srcdn, srcdnpv,

diff --git a/src/mds/SessionMap.cc b/src/mds/SessionMap.cc
index 2a3e90e4817ef54504964a7543148a66a701cb00..be73d4fd27db7c232326d6a153a1c64c51cdf1f3 100644 (file)
--- a/src/mds/SessionMap.cc
+++ b/src/mds/SessionMap.cc
@@ -27,6 +27,19 @@
 #define dout_prefix *_dout << "mds." << mds->get_nodeid() << ".sessionmap "
 
 
+class SessionMapIOContext : public MDSIOContextBase
+{
+  protected:
+    SessionMap *sessionmap;
+    MDS *get_mds() {return sessionmap->mds;}
+  public:
+    SessionMapIOContext(SessionMap *sessionmap_) : sessionmap(sessionmap_) {
+      assert(sessionmap != NULL);
+    }
+};
+
+
+
 void SessionMap::dump()
 {
   dout(10) << "dump" << dendl;
@@ -53,13 +66,11 @@ object_t SessionMap::get_object_name()
   return object_t(s);
 }
 
-class C_IO_SM_Load : public Context {
-  SessionMap *sessionmap;
+class C_IO_SM_Load : public SessionMapIOContext {
 public:
   bufferlist bl;
-  C_IO_SM_Load(SessionMap *cm) : sessionmap(cm) {}
+  C_IO_SM_Load(SessionMap *cm) : SessionMapIOContext(cm) {}
   void finish(int r) {
-    Mutex::Locker l(sessionmap->mds->mds_lock);
     sessionmap->_load_finish(r, bl);
   }
 };
@@ -100,13 +111,11 @@ void SessionMap::_load_finish(int r, bufferlist &bl)
 // ----------------
 // SAVE
 
-class C_IO_SM_Save : public Context {
-  SessionMap *sessionmap;
+class C_IO_SM_Save : public SessionMapIOContext {
   version_t version;
 public:
-  C_IO_SM_Save(SessionMap *cm, version_t v) : sessionmap(cm), version(v) {}
+  C_IO_SM_Save(SessionMap *cm, version_t v) : SessionMapIOContext(cm), version(v) {}
   void finish(int r) {
-    Mutex::Locker l(sessionmap->mds->mds_lock);
     assert(r == 0);
     sessionmap->_save_finish(version);
   }