From: John Spray Date: Thu, 7 Aug 2014 14:56:40 +0000 (+0100) Subject: mds: convert IO contexts X-Git-Tag: v0.86~213^2~33 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=c2728559cb4ccb6e313ece56c91fceee38ac6251;p=ceph.git 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 --- diff --git a/src/mds/CDir.cc b/src/mds/CDir.cc index 5e4c13ec71f6..d30d2f7da84e 100644 --- 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 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 cd5253a8324b..182d830359c0 100644 --- 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 258216a2ba1f..391a3797b603 100644 --- 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 f2a87ab81db0..473b7ce32b63 100644 --- 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 0d307058c716..9da667403e3d 100644 --- 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 ad4858a0435d..323740fbb0d2 100644 --- 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 f5fbe2852f2b..45c05822975a 100644 --- 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& 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 &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 2a3e90e4817e..be73d4fd27db 100644 --- 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); }