From 8865355f8323bfe1e5e709903a2ea55709acea8e Mon Sep 17 00:00:00 2001 From: Kefu Chai Date: Sun, 14 Apr 2019 12:33:57 +0800 Subject: [PATCH] src/: use cref_t instead of Message::const_ref Signed-off-by: Kefu Chai --- src/client/MetaRequest.h | 2 +- src/mds/Beacon.cc | 4 +- src/mds/Beacon.h | 4 +- src/mds/Locker.cc | 24 +++++------ src/mds/Locker.h | 26 ++++++------ src/mds/MDBalancer.cc | 4 +- src/mds/MDBalancer.h | 4 +- src/mds/MDCache.cc | 58 +++++++++++++------------- src/mds/MDCache.h | 52 +++++++++++------------ src/mds/MDSDaemon.cc | 10 ++--- src/mds/MDSDaemon.h | 10 ++--- src/mds/MDSRank.cc | 50 +++++++++++----------- src/mds/MDSRank.h | 42 +++++++++---------- src/mds/MDSTableClient.cc | 2 +- src/mds/MDSTableClient.h | 6 +-- src/mds/MDSTableServer.cc | 28 ++++++------- src/mds/MDSTableServer.h | 20 ++++----- src/mds/Migrator.cc | 44 ++++++++++---------- src/mds/Migrator.h | 28 ++++++------- src/mds/Mutation.cc | 8 ++-- src/mds/Mutation.h | 12 +++--- src/mds/Server.cc | 88 +++++++++++++++++++-------------------- src/mds/Server.h | 28 ++++++------- src/mds/SnapClient.cc | 4 +- src/mds/SnapClient.h | 4 +- src/mds/SnapServer.cc | 4 +- src/mds/SnapServer.h | 4 +- src/msg/DispatchQueue.cc | 2 +- src/msg/DispatchQueue.h | 36 ++++++++-------- src/msg/Messenger.h | 2 +- src/msg/QueueStrategy.cc | 4 +- 31 files changed, 307 insertions(+), 307 deletions(-) diff --git a/src/client/MetaRequest.h b/src/client/MetaRequest.h index f9dfe982426..202be43baee 100644 --- a/src/client/MetaRequest.h +++ b/src/client/MetaRequest.h @@ -49,7 +49,7 @@ public: int retry_attempt; std::atomic ref = { 1 }; - MClientReply::const_ref reply; // the reply + ceph::cref_t reply; // the reply bool kick; bool success; diff --git a/src/mds/Beacon.cc b/src/mds/Beacon.cc index d6f0eee6356..285ca5b3b60 100644 --- a/src/mds/Beacon.cc +++ b/src/mds/Beacon.cc @@ -87,7 +87,7 @@ void Beacon::init(const MDSMap &mdsmap) }); } -bool Beacon::ms_can_fast_dispatch2(const Message::const_ref& m) const +bool Beacon::ms_can_fast_dispatch2(const cref_t& m) const { return m->get_type() == MSG_MDS_BEACON; } @@ -116,7 +116,7 @@ bool Beacon::ms_dispatch2(const Message::ref& m) * * This function puts the passed message before returning */ -void Beacon::handle_mds_beacon(const MMDSBeacon::const_ref &m) +void Beacon::handle_mds_beacon(const cref_t &m) { std::unique_lock lock(mutex); diff --git a/src/mds/Beacon.h b/src/mds/Beacon.h index 0116335b6dd..18353c6c693 100644 --- a/src/mds/Beacon.h +++ b/src/mds/Beacon.h @@ -52,7 +52,7 @@ public: void shutdown(); bool ms_can_fast_dispatch_any() const override { return true; } - bool ms_can_fast_dispatch2(const Message::const_ref& m) const override; + bool ms_can_fast_dispatch2(const cref_t& m) const override; void ms_fast_dispatch2(const Message::ref& m) override; bool ms_dispatch2(const Message::ref &m) override; void ms_handle_connect(Connection *c) override {} @@ -63,7 +63,7 @@ public: void notify_mdsmap(const MDSMap &mdsmap); void notify_health(const MDSRank *mds); - void handle_mds_beacon(const MMDSBeacon::const_ref &m); + void handle_mds_beacon(const cref_t &m); void send(); void set_want_state(const MDSMap &mdsmap, MDSMap::DaemonState const newstate); diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc index 81bcf14c7a8..db86ee0d2e9 100644 --- a/src/mds/Locker.cc +++ b/src/mds/Locker.cc @@ -89,7 +89,7 @@ Locker::Locker(MDSRank *m, MDCache *c) : mds(m), mdcache(c), need_snapflush_inodes(member_offset(CInode, item_caps)) {} -void Locker::dispatch(const Message::const_ref &m) +void Locker::dispatch(const cref_t &m) { switch (m->get_type()) { @@ -2256,7 +2256,7 @@ void Locker::request_inode_file_caps(CInode *in) } } -void Locker::handle_inode_file_caps(const MInodeFileCaps::const_ref &m) +void Locker::handle_inode_file_caps(const cref_t &m) { // nobody should be talking to us during recovery. if (mds->get_state() < MDSMap::STATE_CLIENTREPLAY) { @@ -2659,7 +2659,7 @@ bool Locker::should_defer_client_cap_frozen(CInode *in) return (in->is_freezing() && in->get_num_auth_pins() == 0) || in->is_frozen(); } -void Locker::handle_client_caps(const MClientCaps::const_ref &m) +void Locker::handle_client_caps(const cref_t &m) { client_t client = m->get_source().num(); snapid_t follows = m->get_snap_follows(); @@ -3110,7 +3110,7 @@ void Locker::kick_cap_releases(MDRequestRef& mdr) /** * m and ack might be NULL, so don't dereference them unless dirty != 0 */ -void Locker::_do_snap_update(CInode *in, snapid_t snap, int dirty, snapid_t follows, client_t client, const MClientCaps::const_ref &m, const MClientCaps::ref &ack) +void Locker::_do_snap_update(CInode *in, snapid_t snap, int dirty, snapid_t follows, client_t client, const cref_t &m, const MClientCaps::ref &ack) { dout(10) << "_do_snap_update dirty " << ccap_string(dirty) << " follows " << follows << " snap " << snap @@ -3198,7 +3198,7 @@ void Locker::_do_snap_update(CInode *in, snapid_t snap, int dirty, snapid_t foll ack, client)); } -void Locker::_update_cap_fields(CInode *in, int dirty, const MClientCaps::const_ref &m, CInode::mempool_inode *pi) +void Locker::_update_cap_fields(CInode *in, int dirty, const cref_t &m, CInode::mempool_inode *pi) { if (dirty == 0) return; @@ -3301,7 +3301,7 @@ void Locker::_update_cap_fields(CInode *in, int dirty, const MClientCaps::const_ */ bool Locker::_do_cap_update(CInode *in, Capability *cap, int dirty, snapid_t follows, - const MClientCaps::const_ref &m, const MClientCaps::ref &ack, + const cref_t &m, const MClientCaps::ref &ack, bool *need_flush) { dout(10) << "_do_cap_update dirty " << ccap_string(dirty) @@ -3481,7 +3481,7 @@ bool Locker::_do_cap_update(CInode *in, Capability *cap, return true; } -void Locker::handle_client_cap_release(const MClientCapRelease::const_ref &m) +void Locker::handle_client_cap_release(const cref_t &m) { client_t client = m->get_source().num(); dout(10) << "handle_client_cap_release " << *m << dendl; @@ -3693,7 +3693,7 @@ void Locker::caps_tick() } -void Locker::handle_client_lease(const MClientLease::const_ref &m) +void Locker::handle_client_lease(const cref_t &m) { dout(10) << "handle_client_lease " << *m << dendl; @@ -3896,7 +3896,7 @@ SimpleLock *Locker::get_lock(int lock_type, const MDSCacheObjectInfo &info) return 0; } -void Locker::handle_lock(const MLock::const_ref &m) +void Locker::handle_lock(const cref_t &m) { // nobody should be talking to us during recovery. ceph_assert(mds->is_rejoin() || mds->is_clientreplay() || mds->is_active() || mds->is_stopping()); @@ -3943,7 +3943,7 @@ void Locker::handle_lock(const MLock::const_ref &m) /** This function may take a reference to m if it needs one, but does * not put references. */ -void Locker::handle_reqrdlock(SimpleLock *lock, const MLock::const_ref &m) +void Locker::handle_reqrdlock(SimpleLock *lock, const cref_t &m) { MDSCacheObject *parent = lock->get_parent(); if (parent->is_auth() && @@ -3966,7 +3966,7 @@ void Locker::handle_reqrdlock(SimpleLock *lock, const MLock::const_ref &m) } } -void Locker::handle_simple_lock(SimpleLock *lock, const MLock::const_ref &m) +void Locker::handle_simple_lock(SimpleLock *lock, const cref_t &m) { int from = m->get_asker(); @@ -5192,7 +5192,7 @@ void Locker::file_recover(ScatterLock *lock) // messenger -void Locker::handle_file_lock(ScatterLock *lock, const MLock::const_ref &m) +void Locker::handle_file_lock(ScatterLock *lock, const cref_t &m) { CInode *in = static_cast(lock->get_parent()); int from = m->get_asker(); diff --git a/src/mds/Locker.h b/src/mds/Locker.h index 05b4f63a543..4252f4d1b57 100644 --- a/src/mds/Locker.h +++ b/src/mds/Locker.h @@ -54,8 +54,8 @@ private: SimpleLock *get_lock(int lock_type, const MDSCacheObjectInfo &info); - void dispatch(const Message::const_ref &m); - void handle_lock(const MLock::const_ref &m); + void dispatch(const cref_t &m); + void handle_lock(const cref_t &m); void tick(); @@ -130,7 +130,7 @@ public: bool simple_rdlock_try(SimpleLock *lock, MDSContext *con); protected: void simple_eval(SimpleLock *lock, bool *need_issue); - void handle_simple_lock(SimpleLock *lock, const MLock::const_ref &m); + void handle_simple_lock(SimpleLock *lock, const cref_t &m); public: bool simple_sync(SimpleLock *lock, bool *need_issue=0); @@ -148,7 +148,7 @@ public: void scatter_nudge(ScatterLock *lock, MDSContext *c, bool forcelockchange=false); protected: - void handle_scatter_lock(ScatterLock *lock, const MLock::const_ref &m); + void handle_scatter_lock(ScatterLock *lock, const cref_t &m); bool scatter_scatter_fastpath(ScatterLock *lock); void scatter_scatter(ScatterLock *lock, bool nowait=false); void scatter_tempsync(ScatterLock *lock, bool *need_issue=0); @@ -162,7 +162,7 @@ public: void mark_updated_scatterlock(ScatterLock *lock); - void handle_reqrdlock(SimpleLock *lock, const MLock::const_ref &m); + void handle_reqrdlock(SimpleLock *lock, const cref_t &m); @@ -189,13 +189,13 @@ private: protected: bool _need_flush_mdlog(CInode *in, int wanted_caps); void adjust_cap_wanted(Capability *cap, int wanted, int issue_seq); - void handle_client_caps(const MClientCaps::const_ref &m); - void _update_cap_fields(CInode *in, int dirty, const MClientCaps::const_ref &m, CInode::mempool_inode *pi); - void _do_snap_update(CInode *in, snapid_t snap, int dirty, snapid_t follows, client_t client, const MClientCaps::const_ref &m, const MClientCaps::ref &ack); + void handle_client_caps(const cref_t &m); + void _update_cap_fields(CInode *in, int dirty, const cref_t &m, CInode::mempool_inode *pi); + void _do_snap_update(CInode *in, snapid_t snap, int dirty, snapid_t follows, client_t client, const cref_t &m, const MClientCaps::ref &ack); void _do_null_snapflush(CInode *head_in, client_t client, snapid_t last=CEPH_NOSNAP); - bool _do_cap_update(CInode *in, Capability *cap, int dirty, snapid_t follows, const MClientCaps::const_ref &m, + bool _do_cap_update(CInode *in, Capability *cap, int dirty, snapid_t follows, const cref_t &m, const MClientCaps::ref &ack, bool *need_flush=NULL); - void handle_client_cap_release(const MClientCapRelease::const_ref &m); + void handle_client_cap_release(const cref_t &m); void _do_cap_release(client_t client, inodeno_t ino, uint64_t cap_id, ceph_seq_t mseq, ceph_seq_t seq); void caps_tick(); @@ -223,7 +223,7 @@ protected: public: void file_eval(ScatterLock *lock, bool *need_issue); protected: - void handle_file_lock(ScatterLock *lock, const MLock::const_ref &m); + void handle_file_lock(ScatterLock *lock, const cref_t &m); void scatter_mix(ScatterLock *lock, bool *need_issue=0); void file_excl(ScatterLock *lock, bool *need_issue=0); void file_xsyn(SimpleLock *lock, bool *need_issue=0); @@ -250,7 +250,7 @@ public: public: void request_inode_file_caps(CInode *in); protected: - void handle_inode_file_caps(const MInodeFileCaps::const_ref &m); + void handle_inode_file_caps(const cref_t &m); void file_update_finish(CInode *in, MutationRef& mut, unsigned flags, client_t client, const MClientCaps::ref &ack); @@ -278,7 +278,7 @@ private: // -- client leases -- public: - void handle_client_lease(const MClientLease::const_ref &m); + void handle_client_lease(const cref_t &m); void issue_client_lease(CDentry *dn, client_t client, bufferlist &bl, utime_t now, Session *session); void revoke_client_leases(SimpleLock *lock); diff --git a/src/mds/MDBalancer.cc b/src/mds/MDBalancer.cc index 0975d112499..ec4a03f2c9e 100644 --- a/src/mds/MDBalancer.cc +++ b/src/mds/MDBalancer.cc @@ -59,7 +59,7 @@ using std::chrono::duration_cast; #define MIN_OFFLOAD 10 // point at which i stop trying, close enough -int MDBalancer::proc_message(const Message::const_ref &m) +int MDBalancer::proc_message(const cref_t &m) { switch (m->get_type()) { @@ -406,7 +406,7 @@ void MDBalancer::send_heartbeat() } } -void MDBalancer::handle_heartbeat(const MHeartbeat::const_ref &m) +void MDBalancer::handle_heartbeat(const cref_t &m) { mds_rank_t who = mds_rank_t(m->get_source().num()); dout(25) << "=== got heartbeat " << m->get_beat() << " from " << m->get_source().num() << " " << m->get_load() << dendl; diff --git a/src/mds/MDBalancer.h b/src/mds/MDBalancer.h index 206db596c53..ce48c6febaa 100644 --- a/src/mds/MDBalancer.h +++ b/src/mds/MDBalancer.h @@ -48,7 +48,7 @@ public: const std::set &changed, const MDSMap &mds_map); - int proc_message(const Message::const_ref &m); + int proc_message(const cref_t &m); /** * Regularly called upkeep function. @@ -100,7 +100,7 @@ private: mds_load_t get_load(); int localize_balancer(); void send_heartbeat(); - void handle_heartbeat(const MHeartbeat::const_ref &m); + void handle_heartbeat(const cref_t &m); void find_exports(CDir *dir, double amount, std::vector* exports, diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc index 0ac218ae30b..70fcf64fb6f 100644 --- a/src/mds/MDCache.cc +++ b/src/mds/MDCache.cc @@ -2906,7 +2906,7 @@ void MDCache::handle_mds_failure(mds_rank_t who) add_ambiguous_slave_update(p->first, mdr->slave_to_mds); } } else if (mdr->slave_request) { - const MMDSSlaveRequest::const_ref &slave_req = mdr->slave_request; + const cref_t &slave_req = mdr->slave_request; // FIXME: Slave rename request can arrive after we notice mds failure. // This can cause mds to crash (does not affect integrity of FS). if (slave_req->get_op() == MMDSSlaveRequest::OP_RENAMEPREP && @@ -3085,7 +3085,7 @@ void MDCache::set_recovery_set(set& s) * * This functions puts the passed message before returning */ -void MDCache::handle_resolve(const MMDSResolve::const_ref &m) +void MDCache::handle_resolve(const cref_t &m) { dout(7) << "handle_resolve from " << m->get_source() << dendl; mds_rank_t from = mds_rank_t(m->get_source().num()); @@ -3270,7 +3270,7 @@ void MDCache::handle_resolve(const MMDSResolve::const_ref &m) void MDCache::process_delayed_resolve() { dout(10) << "process_delayed_resolve" << dendl; - map tmp; + map> tmp; tmp.swap(delayed_resolve); for (auto &p : tmp) { handle_resolve(p.second); @@ -3308,7 +3308,7 @@ void MDCache::maybe_resolve_finish() } } -void MDCache::handle_resolve_ack(const MMDSResolveAck::const_ref &ack) +void MDCache::handle_resolve_ack(const cref_t &ack) { dout(10) << "handle_resolve_ack " << *ack << " from " << ack->get_source() << dendl; mds_rank_t from = mds_rank_t(ack->get_source().num()); @@ -4242,7 +4242,7 @@ void MDCache::rejoin_walk(CDir *dir, const MMDSCacheRejoin::ref &rejoin) * if i am active|stopping, * - remove source from replica list for everything not referenced here. */ -void MDCache::handle_cache_rejoin(const MMDSCacheRejoin::const_ref &m) +void MDCache::handle_cache_rejoin(const cref_t &m) { dout(7) << "handle_cache_rejoin " << *m << " from " << m->get_source() << " (" << m->get_payload().length() << " bytes)" @@ -4278,7 +4278,7 @@ void MDCache::handle_cache_rejoin(const MMDSCacheRejoin::const_ref &m) * - may have deleted/purged inodes * and i may have to go to disk to get accurate inode contents. yuck. */ -void MDCache::handle_cache_rejoin_weak(const MMDSCacheRejoin::const_ref &weak) +void MDCache::handle_cache_rejoin_weak(const cref_t &weak) { mds_rank_t from = mds_rank_t(weak->get_source().num()); @@ -4503,7 +4503,7 @@ void MDCache::handle_cache_rejoin_weak(const MMDSCacheRejoin::const_ref &weak) * all validated replicas are acked with a strong nonce, etc. if that isn't in the * ack, the replica dne, and we can remove it from our replica maps. */ -void MDCache::rejoin_scour_survivor_replicas(mds_rank_t from, const MMDSCacheRejoin::const_ref &ack, +void MDCache::rejoin_scour_survivor_replicas(mds_rank_t from, const cref_t &ack, set& acked_inodes, set& gather_locks) { @@ -4585,7 +4585,7 @@ CDir *MDCache::rejoin_invent_dirfrag(dirfrag_t df) return dir; } -void MDCache::handle_cache_rejoin_strong(const MMDSCacheRejoin::const_ref &strong) +void MDCache::handle_cache_rejoin_strong(const cref_t &strong) { mds_rank_t from = mds_rank_t(strong->get_source().num()); @@ -4854,7 +4854,7 @@ void MDCache::handle_cache_rejoin_strong(const MMDSCacheRejoin::const_ref &stron } } -void MDCache::handle_cache_rejoin_ack(const MMDSCacheRejoin::const_ref &ack) +void MDCache::handle_cache_rejoin_ack(const cref_t &ack) { dout(7) << "handle_cache_rejoin_ack from " << ack->get_source() << dendl; mds_rank_t from = mds_rank_t(ack->get_source().num()); @@ -7193,7 +7193,7 @@ void MDCache::standby_trim_segment(LogSegment *ls) } } -void MDCache::handle_cache_expire(const MCacheExpire::const_ref &m) +void MDCache::handle_cache_expire(const cref_t &m) { mds_rank_t from = mds_rank_t(m->get_from()); @@ -7877,7 +7877,7 @@ done: // ========= messaging ============== -void MDCache::dispatch(const Message::const_ref &m) +void MDCache::dispatch(const cref_t &m) { switch (m->get_type()) { @@ -8451,10 +8451,10 @@ class C_IO_MDC_OpenInoBacktraceFetched : public MDCacheIOContext { struct C_MDC_OpenInoTraverseDir : public MDCacheContext { inodeno_t ino; - MMDSOpenIno::const_ref msg; + cref_t msg; bool parent; public: - C_MDC_OpenInoTraverseDir(MDCache *c, inodeno_t i, const MMDSOpenIno::const_ref &m, bool p) : + C_MDC_OpenInoTraverseDir(MDCache *c, inodeno_t i, const cref_t &m, bool p) : MDCacheContext(c), ino(i), msg(m), parent(p) {} void finish(int r) override { if (r < 0 && !parent) @@ -8604,7 +8604,7 @@ void MDCache::_open_ino_traverse_dir(inodeno_t ino, open_ino_info_t& info, int r do_open_ino(ino, info, ret); } -void MDCache::_open_ino_fetch_dir(inodeno_t ino, const MMDSOpenIno::const_ref &m, CDir *dir, bool parent) +void MDCache::_open_ino_fetch_dir(inodeno_t ino, const cref_t &m, CDir *dir, bool parent) { if (dir->state_test(CDir::STATE_REJOINUNDEF)) ceph_assert(dir->get_inode()->dirfragtree.is_leaf(dir->get_frag())); @@ -8613,7 +8613,7 @@ void MDCache::_open_ino_fetch_dir(inodeno_t ino, const MMDSOpenIno::const_ref &m mds->logger->inc(l_mds_openino_dir_fetch); } -int MDCache::open_ino_traverse_dir(inodeno_t ino, const MMDSOpenIno::const_ref &m, +int MDCache::open_ino_traverse_dir(inodeno_t ino, const cref_t &m, const vector& ancestors, bool discover, bool want_xlocked, mds_rank_t *hint) { @@ -8807,7 +8807,7 @@ void MDCache::do_open_ino_peer(inodeno_t ino, open_ino_info_t& info) } } -void MDCache::handle_open_ino(const MMDSOpenIno::const_ref &m, int err) +void MDCache::handle_open_ino(const cref_t &m, int err) { if (mds->get_state() < MDSMap::STATE_REJOIN && mds->get_want_state() != CEPH_MDS_STATE_REJOIN) { @@ -8849,7 +8849,7 @@ void MDCache::handle_open_ino(const MMDSOpenIno::const_ref &m, int err) mds->send_message_mds(reply, from); } -void MDCache::handle_open_ino_reply(const MMDSOpenInoReply::const_ref &m) +void MDCache::handle_open_ino_reply(const cref_t &m) { dout(10) << "handle_open_ino_reply " << *m << dendl; @@ -9022,7 +9022,7 @@ void MDCache::_do_find_ino_peer(find_ino_peer_info_t& fip) } } -void MDCache::handle_find_ino(const MMDSFindIno::const_ref &m) +void MDCache::handle_find_ino(const cref_t &m) { if (mds->get_state() < MDSMap::STATE_REJOIN) { return; @@ -9039,7 +9039,7 @@ void MDCache::handle_find_ino(const MMDSFindIno::const_ref &m) } -void MDCache::handle_find_ino_reply(const MMDSFindInoReply::const_ref &m) +void MDCache::handle_find_ino_reply(const cref_t &m) { map::iterator p = find_ino_peer.find(m->tid); if (p != find_ino_peer.end()) { @@ -9113,7 +9113,7 @@ int MDCache::get_num_client_requests() return count; } -MDRequestRef MDCache::request_start(const MClientRequest::const_ref& req) +MDRequestRef MDCache::request_start(const cref_t& req) { // did we win a forward race against a slave? if (active_requests.count(req->get_reqid())) { @@ -9146,7 +9146,7 @@ MDRequestRef MDCache::request_start(const MClientRequest::const_ref& req) return mdr; } -MDRequestRef MDCache::request_start_slave(metareqid_t ri, __u32 attempt, const Message::const_ref &m) +MDRequestRef MDCache::request_start_slave(metareqid_t ri, __u32 attempt, const cref_t &m) { int by = m->get_source().num(); MDRequestImpl::Params params; @@ -9577,7 +9577,7 @@ void MDCache::send_snap_update(CInode *in, version_t stid, int snap_op) notify_global_snaprealm_update(snap_op); } -void MDCache::handle_snap_update(const MMDSSnapUpdate::const_ref &m) +void MDCache::handle_snap_update(const cref_t &m) { mds_rank_t from = mds_rank_t(m->get_source().num()); dout(10) << __func__ << " " << *m << " from mds." << from << dendl; @@ -9868,7 +9868,7 @@ void MDCache::kick_discovers(mds_rank_t who) } -void MDCache::handle_discover(const MDiscover::const_ref &dis) +void MDCache::handle_discover(const cref_t &dis) { mds_rank_t whoami = mds->get_nodeid(); mds_rank_t from = mds_rank_t(dis->get_source().num()); @@ -10164,7 +10164,7 @@ void MDCache::handle_discover(const MDiscover::const_ref &dis) mds->send_message(reply, dis->get_connection()); } -void MDCache::handle_discover_reply(const MDiscoverReply::const_ref &m) +void MDCache::handle_discover_reply(const cref_t &m) { /* if (mds->get_state() < MDSMap::STATE_ACTIVE) { @@ -10507,7 +10507,7 @@ int MDCache::send_dir_updates(CDir *dir, bool bcast) return 0; } -void MDCache::handle_dir_update(const MDirUpdate::const_ref &m) +void MDCache::handle_dir_update(const cref_t &m) { dirfrag_t df = m->get_dirfrag(); CDir *dir = get_dirfrag(df); @@ -10587,7 +10587,7 @@ void MDCache::send_dentry_link(CDentry *dn, MDRequestRef& mdr) } } -void MDCache::handle_dentry_link(const MDentryLink::const_ref &m) +void MDCache::handle_dentry_link(const cref_t &m) { CDentry *dn = NULL; CDir *dir = get_dirfrag(m->get_dirfrag()); @@ -10666,7 +10666,7 @@ void MDCache::send_dentry_unlink(CDentry *dn, CDentry *straydn, MDRequestRef& md } } -void MDCache::handle_dentry_unlink(const MDentryUnlink::const_ref &m) +void MDCache::handle_dentry_unlink(const cref_t &m) { // straydn CDentry *straydn = NULL; @@ -11666,7 +11666,7 @@ void MDCache::fragment_maybe_finish(const fragment_info_iterator& it) } -void MDCache::handle_fragment_notify_ack(const MMDSFragmentNotifyAck::const_ref &ack) +void MDCache::handle_fragment_notify_ack(const cref_t &ack) { dout(10) << "handle_fragment_notify_ack " << *ack << " from " << ack->get_source() << dendl; mds_rank_t from = mds_rank_t(ack->get_source().num()); @@ -11689,7 +11689,7 @@ void MDCache::handle_fragment_notify_ack(const MMDSFragmentNotifyAck::const_ref } } -void MDCache::handle_fragment_notify(const MMDSFragmentNotify::const_ref ¬ify) +void MDCache::handle_fragment_notify(const cref_t ¬ify) { dout(10) << "handle_fragment_notify " << *notify << " from " << notify->get_source() << dendl; mds_rank_t from = mds_rank_t(notify->get_source().num()); diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h index e910766def9..88a985f42e2 100644 --- a/src/mds/MDCache.h +++ b/src/mds/MDCache.h @@ -417,8 +417,8 @@ protected: public: int get_num_client_requests(); - MDRequestRef request_start(const MClientRequest::const_ref& req); - MDRequestRef request_start_slave(metareqid_t rid, __u32 attempt, const Message::const_ref &m); + MDRequestRef request_start(const cref_t& req); + MDRequestRef request_start_slave(metareqid_t rid, __u32 attempt, const cref_t &m); MDRequestRef request_start_internal(int op); bool have_request(metareqid_t rid) { return active_requests.count(rid); @@ -522,10 +522,10 @@ protected: set resolve_ack_gather; // nodes i need a resolve_ack from set resolve_snapclient_commits; map resolve_need_rollback; // rollbacks i'm writing to the journal - map delayed_resolve; + map> delayed_resolve; - void handle_resolve(const MMDSResolve::const_ref &m); - void handle_resolve_ack(const MMDSResolveAck::const_ref &m); + void handle_resolve(const cref_t &m); + void handle_resolve_ack(const cref_t &m); void process_delayed_resolve(); void discard_delayed_resolve(mds_rank_t who); void maybe_resolve_finish(); @@ -623,15 +623,15 @@ protected: MDSContext::vec rejoin_waiters; void rejoin_walk(CDir *dir, const MMDSCacheRejoin::ref &rejoin); - void handle_cache_rejoin(const MMDSCacheRejoin::const_ref &m); - void handle_cache_rejoin_weak(const MMDSCacheRejoin::const_ref &m); + void handle_cache_rejoin(const cref_t &m); + void handle_cache_rejoin_weak(const cref_t &m); CInode* rejoin_invent_inode(inodeno_t ino, snapid_t last); CDir* rejoin_invent_dirfrag(dirfrag_t df); - void handle_cache_rejoin_strong(const MMDSCacheRejoin::const_ref &m); - void rejoin_scour_survivor_replicas(mds_rank_t from, const MMDSCacheRejoin::const_ref &ack, + void handle_cache_rejoin_strong(const cref_t &m); + void rejoin_scour_survivor_replicas(mds_rank_t from, const cref_t &ack, set& acked_inodes, set& gather_locks); - void handle_cache_rejoin_ack(const MMDSCacheRejoin::const_ref &m); + void handle_cache_rejoin_ack(const cref_t &m); void rejoin_send_acks(); void rejoin_trim_undef_inodes(); void maybe_send_pending_rejoins() { @@ -1065,15 +1065,15 @@ protected: void _open_ino_backtrace_fetched(inodeno_t ino, bufferlist& bl, int err); void _open_ino_parent_opened(inodeno_t ino, int ret); void _open_ino_traverse_dir(inodeno_t ino, open_ino_info_t& info, int err); - void _open_ino_fetch_dir(inodeno_t ino, const MMDSOpenIno::const_ref &m, CDir *dir, bool parent); - int open_ino_traverse_dir(inodeno_t ino, const MMDSOpenIno::const_ref &m, + void _open_ino_fetch_dir(inodeno_t ino, const cref_t &m, CDir *dir, bool parent); + int open_ino_traverse_dir(inodeno_t ino, const cref_t &m, const vector& ancestors, bool discover, bool want_xlocked, mds_rank_t *hint); void open_ino_finish(inodeno_t ino, open_ino_info_t& info, int err); void do_open_ino(inodeno_t ino, open_ino_info_t& info, int err); void do_open_ino_peer(inodeno_t ino, open_ino_info_t& info); - void handle_open_ino(const MMDSOpenIno::const_ref &m, int err=0); - void handle_open_ino_reply(const MMDSOpenInoReply::const_ref &m); + void handle_open_ino(const cref_t &m, int err=0); + void handle_open_ino_reply(const cref_t &m); friend class C_IO_MDC_OpenInoBacktraceFetched; friend struct C_MDC_OpenInoTraverseDir; friend struct C_MDC_OpenInoParentOpened; @@ -1100,8 +1100,8 @@ public: void find_ino_peers(inodeno_t ino, MDSContext *c, mds_rank_t hint=MDS_RANK_NONE); void _do_find_ino_peer(find_ino_peer_info_t& fip); - void handle_find_ino(const MMDSFindIno::const_ref &m); - void handle_find_ino_reply(const MMDSFindInoReply::const_ref &m); + void handle_find_ino(const cref_t &m); + void handle_find_ino_reply(const cref_t &m); void kick_find_ino_peers(mds_rank_t who); // -- snaprealms -- @@ -1112,7 +1112,7 @@ public: void create_global_snaprealm(); void do_realm_invalidate_and_update_notify(CInode *in, int snapop, bool notify_clients=true); void send_snap_update(CInode *in, version_t stid, int snap_op); - void handle_snap_update(const MMDSSnapUpdate::const_ref &m); + void handle_snap_update(const cref_t &m); void notify_global_snaprealm_update(int snap_op); // -- stray -- @@ -1127,12 +1127,12 @@ protected: // == messages == public: - void dispatch(const Message::const_ref &m); + void dispatch(const cref_t &m); protected: // -- replicas -- - void handle_discover(const MDiscover::const_ref &dis); - void handle_discover_reply(const MDiscoverReply::const_ref &m); + void handle_discover(const cref_t &dis); + void handle_discover_reply(const cref_t &m); friend class C_MDC_Join; public: @@ -1153,8 +1153,8 @@ public: void send_dentry_link(CDentry *dn, MDRequestRef& mdr); void send_dentry_unlink(CDentry *dn, CDentry *straydn, MDRequestRef& mdr); protected: - void handle_dentry_link(const MDentryLink::const_ref &m); - void handle_dentry_unlink(const MDentryUnlink::const_ref &m); + void handle_dentry_link(const cref_t &m); + void handle_dentry_unlink(const cref_t &m); // -- fragmenting -- @@ -1222,8 +1222,8 @@ private: friend class C_MDC_FragmentCommit; friend class C_IO_MDC_FragmentPurgeOld; - void handle_fragment_notify(const MMDSFragmentNotify::const_ref &m); - void handle_fragment_notify_ack(const MMDSFragmentNotifyAck::const_ref &m); + void handle_fragment_notify(const cref_t &m); + void handle_fragment_notify_ack(const cref_t &m); void add_uncommitted_fragment(dirfrag_t basedirfrag, int bits, const frag_vec_t& old_frag, LogSegment *ls, bufferlist *rollback=NULL); @@ -1252,10 +1252,10 @@ public: //void handle_inode_update(MInodeUpdate *m); int send_dir_updates(CDir *in, bool bcast=false); - void handle_dir_update(const MDirUpdate::const_ref &m); + void handle_dir_update(const cref_t &m); // -- cache expiration -- - void handle_cache_expire(const MCacheExpire::const_ref &m); + void handle_cache_expire(const cref_t &m); // delayed cache expire map delayed_expire; // subtree root -> expire msg void process_delayed_expire(CDir *dir); diff --git a/src/mds/MDSDaemon.cc b/src/mds/MDSDaemon.cc index e7edfd38e75..7b530e0cb1b 100644 --- a/src/mds/MDSDaemon.cc +++ b/src/mds/MDSDaemon.cc @@ -578,7 +578,7 @@ void MDSDaemon::tick() } } -void MDSDaemon::send_command_reply(const MCommand::const_ref &m, MDSRank *mds_rank, +void MDSDaemon::send_command_reply(const cref_t &m, MDSRank *mds_rank, int r, bufferlist outbl, std::string_view outs) { @@ -607,7 +607,7 @@ void MDSDaemon::send_command_reply(const MCommand::const_ref &m, MDSRank *mds_ra m->get_connection()->send_message2(reply); } -void MDSDaemon::handle_command(const MCommand::const_ref &m) +void MDSDaemon::handle_command(const cref_t &m) { auto priv = m->get_connection()->get_priv(); auto session = static_cast(priv.get()); @@ -687,7 +687,7 @@ const std::vector& MDSDaemon::get_commands() int MDSDaemon::_handle_command( const cmdmap_t &cmdmap, - const MCommand::const_ref &m, + const cref_t &m, bufferlist *outbl, std::string *outs, Context **run_later, @@ -869,7 +869,7 @@ out: return r; } -void MDSDaemon::handle_mds_map(const MMDSMap::const_ref &m) +void MDSDaemon::handle_mds_map(const cref_t &m) { version_t epoch = m->get_epoch(); @@ -1180,7 +1180,7 @@ bool MDSDaemon::ms_get_authorizer(int dest_type, AuthAuthorizer **authorizer) /* * high priority messages we always process */ -bool MDSDaemon::handle_core_message(const Message::const_ref &m) +bool MDSDaemon::handle_core_message(const cref_t &m) { switch (m->get_type()) { case CEPH_MSG_MON_MAP: diff --git a/src/mds/MDSDaemon.h b/src/mds/MDSDaemon.h index 916062fd060..c21c89cf03d 100644 --- a/src/mds/MDSDaemon.h +++ b/src/mds/MDSDaemon.h @@ -144,21 +144,21 @@ class MDSDaemon : public Dispatcher, public md_config_obs_t { void tick(); protected: - bool handle_core_message(const Message::const_ref &m); + bool handle_core_message(const cref_t &m); // special message types friend class C_MDS_Send_Command_Reply; - static void send_command_reply(const MCommand::const_ref &m, MDSRank* mds_rank, int r, + static void send_command_reply(const cref_t &m, MDSRank* mds_rank, int r, bufferlist outbl, std::string_view outs); int _handle_command( const cmdmap_t &cmdmap, - const MCommand::const_ref &m, + const cref_t &m, bufferlist *outbl, std::string *outs, Context **run_later, bool *need_reply); - void handle_command(const MCommand::const_ref &m); - void handle_mds_map(const MMDSMap::const_ref &m); + void handle_command(const cref_t &m); + void handle_mds_map(const cref_t &m); void _handle_mds_map(const MDSMap &oldmap); private: diff --git a/src/mds/MDSRank.cc b/src/mds/MDSRank.cc index dfa6ce8d19f..78d7a40a900 100644 --- a/src/mds/MDSRank.cc +++ b/src/mds/MDSRank.cc @@ -1009,7 +1009,7 @@ void MDSRank::ProgressThread::shutdown() } } -bool MDSRankDispatcher::ms_dispatch(const Message::const_ref &m) +bool MDSRankDispatcher::ms_dispatch(const cref_t &m) { if (m->get_source().is_client()) { Session *session = static_cast(m->get_connection()->get_priv().get()); @@ -1023,7 +1023,7 @@ bool MDSRankDispatcher::ms_dispatch(const Message::const_ref &m) return ret; } -bool MDSRank::_dispatch(const Message::const_ref &m, bool new_msg) +bool MDSRank::_dispatch(const cref_t &m, bool new_msg) { if (is_stale_message(m)) { return true; @@ -1154,7 +1154,7 @@ void MDSRank::update_mlogger() /* * lower priority messages we defer if we seem laggy */ -bool MDSRank::handle_deferrable_message(const Message::const_ref &m) +bool MDSRank::handle_deferrable_message(const cref_t &m) { int port = m->get_type() & 0xff00; @@ -1193,7 +1193,7 @@ bool MDSRank::handle_deferrable_message(const Message::const_ref &m) case MSG_MDS_TABLE_REQUEST: ALLOW_MESSAGES_FROM(CEPH_ENTITY_TYPE_MDS); { - const MMDSTableRequest::const_ref &req = MMDSTableRequest::msgref_cast(m); + const cref_t &req = MMDSTableRequest::msgref_cast(m); if (req->op < 0) { MDSTableClient *client = get_table_client(req->table); client->handle_request(req); @@ -1253,7 +1253,7 @@ void MDSRank::_advance_queues() if (beacon.is_laggy()) break; - Message::const_ref old = waiting_for_nolaggy.front(); + cref_t old = waiting_for_nolaggy.front(); waiting_for_nolaggy.pop_front(); if (!is_stale_message(old)) { @@ -1288,7 +1288,7 @@ void MDSRank::heartbeat_reset() g_ceph_context->get_heartbeat_map()->reset_timeout(hb, grace, 0); } -bool MDSRank::is_stale_message(const Message::const_ref &m) const +bool MDSRank::is_stale_message(const cref_t &m) const { // from bad mds? if (m->get_source().is_mds()) { @@ -1328,7 +1328,7 @@ bool MDSRank::is_stale_message(const Message::const_ref &m) const return false; } -Session *MDSRank::get_session(const Message::const_ref &m) +Session *MDSRank::get_session(const cref_t &m) { // do not carry ref auto session = static_cast(m->get_connection()->get_priv().get()); @@ -1364,14 +1364,14 @@ Session *MDSRank::get_session(const Message::const_ref &m) return session; } -void MDSRank::send_message(const Message::ref& m, const ConnectionRef& c) +void MDSRank::send_message(const ref_t& m, const ConnectionRef& c) { ceph_assert(c); c->send_message2(m); } -void MDSRank::send_message_mds(const Message::ref& m, mds_rank_t mds) +void MDSRank::send_message_mds(const ref_t& m, mds_rank_t mds) { if (!mdsmap->is_up(mds)) { dout(10) << "send_message_mds mds." << mds << " not up, dropping " << *m << dendl; @@ -1386,10 +1386,10 @@ void MDSRank::send_message_mds(const Message::ref& m, mds_rank_t mds) } // send message - messenger->send_to_mds(Message::ref(m).detach(), mdsmap->get_addrs(mds)); + messenger->send_to_mds(ref_t(m).detach(), mdsmap->get_addrs(mds)); } -void MDSRank::forward_message_mds(const MClientRequest::const_ref& m, mds_rank_t mds) +void MDSRank::forward_message_mds(const cref_t& m, mds_rank_t mds) { ceph_assert(mds != whoami); @@ -1408,7 +1408,7 @@ void MDSRank::forward_message_mds(const MClientRequest::const_ref& m, mds_rank_t send_message_client(f, session); } -void MDSRank::send_message_client_counted(const Message::ref& m, client_t client) +void MDSRank::send_message_client_counted(const ref_t& m, client_t client) { Session *session = sessionmap.get_session(entity_name_t::CLIENT(client.v)); if (session) { @@ -1418,7 +1418,7 @@ void MDSRank::send_message_client_counted(const Message::ref& m, client_t client } } -void MDSRank::send_message_client_counted(const Message::ref& m, const ConnectionRef& connection) +void MDSRank::send_message_client_counted(const ref_t& m, const ConnectionRef& connection) { // do not carry ref auto session = static_cast(connection->get_priv().get()); @@ -1430,7 +1430,7 @@ void MDSRank::send_message_client_counted(const Message::ref& m, const Connectio } } -void MDSRank::send_message_client_counted(const Message::ref& m, Session* session) +void MDSRank::send_message_client_counted(const ref_t& m, Session* session) { version_t seq = session->inc_push_seq(); dout(10) << "send_message_client_counted " << session->info.inst.name << " seq " @@ -1442,7 +1442,7 @@ void MDSRank::send_message_client_counted(const Message::ref& m, Session* sessio } } -void MDSRank::send_message_client(const Message::ref& m, Session* session) +void MDSRank::send_message_client(const ref_t& m, Session* session) { dout(10) << "send_message_client " << session->info.inst << " " << *m << dendl; if (session->get_connection()) { @@ -1465,7 +1465,7 @@ void MDSRank::set_osd_epoch_barrier(epoch_t e) osd_epoch_barrier = e; } -void MDSRank::retry_dispatch(const Message::const_ref &m) +void MDSRank::retry_dispatch(const cref_t &m) { inc_dispatch_depth(); _dispatch(m, false); @@ -2120,7 +2120,7 @@ void MDSRank::stopping_done() } void MDSRankDispatcher::handle_mds_map( - const MMDSMap::const_ref &m, + const cref_t &m, const MDSMap &oldmap) { // I am only to be passed MDSMaps in which I hold a rank @@ -2594,9 +2594,9 @@ bool MDSRankDispatcher::handle_asok_command(std::string_view command, class C_MDS_Send_Command_Reply : public MDSInternalContext { protected: - MCommand::const_ref m; + cref_t m; public: - C_MDS_Send_Command_Reply(MDSRank *_mds, const MCommand::const_ref &_m) : + C_MDS_Send_Command_Reply(MDSRank *_mds, const cref_t &_m) : MDSInternalContext(_mds), m(_m) {} void send(int r, std::string_view ss) { @@ -2617,7 +2617,7 @@ public: class C_ExecAndReply : public C_MDS_Send_Command_Reply { public: - C_ExecAndReply(MDSRank *mds, const MCommand::const_ref &m) + C_ExecAndReply(MDSRank *mds, const cref_t &m) : C_MDS_Send_Command_Reply(mds, m), f(true) { } @@ -2641,7 +2641,7 @@ protected: class C_CacheDropExecAndReply : public C_ExecAndReply { public: - C_CacheDropExecAndReply(MDSRank *mds, const MCommand::const_ref &m, + C_CacheDropExecAndReply(MDSRank *mds, const cref_t &m, uint64_t timeout) : C_ExecAndReply(mds, m), timeout(timeout) { } @@ -2656,7 +2656,7 @@ private: class C_ScrubExecAndReply : public C_ExecAndReply { public: - C_ScrubExecAndReply(MDSRank *mds, const MCommand::const_ref &m, + C_ScrubExecAndReply(MDSRank *mds, const cref_t &m, const std::string &path, const std::string &tag, const std::vector &scrubop) : C_ExecAndReply(mds, m), path(path), tag(tag), scrubop(scrubop) { @@ -2674,7 +2674,7 @@ private: class C_ScrubControlExecAndReply : public C_ExecAndReply { public: - C_ScrubControlExecAndReply(MDSRank *mds, const MCommand::const_ref &m, + C_ScrubControlExecAndReply(MDSRank *mds, const cref_t &m, const std::string &command) : C_ExecAndReply(mds, m), command(command) { } @@ -2705,7 +2705,7 @@ private: * MDSRank after calling it (we could have gone into shutdown): just * send your result back to the calling client and finish. */ -void MDSRankDispatcher::evict_clients(const SessionFilter &filter, const MCommand::const_ref &m) +void MDSRankDispatcher::evict_clients(const SessionFilter &filter, const cref_t &m) { C_MDS_Send_Command_Reply *reply = new C_MDS_Send_Command_Reply(this, m); @@ -3474,7 +3474,7 @@ MDSRankDispatcher::MDSRankDispatcher( bool MDSRankDispatcher::handle_command( const cmdmap_t &cmdmap, - const MCommand::const_ref &m, + const cref_t &m, int *r, std::stringstream *ds, std::stringstream *ss, diff --git a/src/mds/MDSRank.h b/src/mds/MDSRank.h index f53b764808c..f052d74ad63 100644 --- a/src/mds/MDSRank.h +++ b/src/mds/MDSRank.h @@ -198,7 +198,7 @@ class MDSRank { Session *get_session(client_t client) { return sessionmap.get_session(entity_name_t::CLIENT(client.v)); } - Session *get_session(const Message::const_ref &m); + Session *get_session(const cref_t &m); PerfCounters *logger, *mlogger; OpTracker op_tracker; @@ -260,20 +260,20 @@ class MDSRank { void signal() {cond.Signal();} } progress_thread; - list waiting_for_nolaggy; + list> waiting_for_nolaggy; MDSContext::que finished_queue; // Dispatch, retry, queues int dispatch_depth; void inc_dispatch_depth() { ++dispatch_depth; } void dec_dispatch_depth() { --dispatch_depth; } - void retry_dispatch(const Message::const_ref &m); - bool handle_deferrable_message(const Message::const_ref &m); + void retry_dispatch(const cref_t &m); + bool handle_deferrable_message(const cref_t &m); void _advance_queues(); - bool _dispatch(const Message::const_ref &m, bool new_msg); + bool _dispatch(const cref_t &m, bool new_msg); ceph::heartbeat_handle_d *hb; // Heartbeat for threads using mds_lock - bool is_stale_message(const Message::const_ref &m) const; + bool is_stale_message(const cref_t &m) const; map peer_mdsmap_epoch; @@ -387,13 +387,13 @@ class MDSRank { double get_dispatch_queue_max_age(utime_t now) const; - void send_message_mds(const Message::ref& m, mds_rank_t mds); - void forward_message_mds(const MClientRequest::const_ref& req, mds_rank_t mds); - void send_message_client_counted(const Message::ref& m, client_t client); - void send_message_client_counted(const Message::ref& m, Session* session); - void send_message_client_counted(const Message::ref& m, const ConnectionRef& connection); - void send_message_client(const Message::ref& m, Session* session); - void send_message(const Message::ref& m, const ConnectionRef& c); + void send_message_mds(const ref_t& m, mds_rank_t mds); + void forward_message_mds(const cref_t& req, mds_rank_t mds); + void send_message_client_counted(const ref_t& m, client_t client); + void send_message_client_counted(const ref_t& m, Session* session); + void send_message_client_counted(const ref_t& m, const ConnectionRef& connection); + void send_message_client(const ref_t& m, Session* session); + void send_message(const ref_t& m, const ConnectionRef& c); void wait_for_active_peer(mds_rank_t who, MDSContext *c) { waiting_for_active_peer[who].push_back(c); @@ -582,18 +582,18 @@ protected: * will put the Message exactly once.*/ class C_MDS_RetryMessage : public MDSInternalContext { public: - C_MDS_RetryMessage(MDSRank *mds, const Message::const_ref &m) + C_MDS_RetryMessage(MDSRank *mds, const cref_t &m) : MDSInternalContext(mds), m(m) {} void finish(int r) override { get_mds()->retry_dispatch(m); } protected: - Message::const_ref m; + cref_t m; }; class CF_MDS_RetryMessageFactory : public MDSContextFactory { public: - CF_MDS_RetryMessageFactory(MDSRank *mds, const Message::const_ref &m) + CF_MDS_RetryMessageFactory(MDSRank *mds, const cref_t &m) : mds(mds), m(m) {} MDSContext *build() { @@ -602,7 +602,7 @@ public: private: MDSRank *mds; - Message::const_ref m; + cref_t m; }; /** @@ -618,13 +618,13 @@ public: void shutdown(); bool handle_asok_command(std::string_view command, const cmdmap_t& cmdmap, Formatter *f, std::ostream& ss); - void handle_mds_map(const MMDSMap::const_ref &m, const MDSMap &oldmap); + void handle_mds_map(const cref_t &m, const MDSMap &oldmap); void handle_osd_map(); void update_log_config(); bool handle_command( const cmdmap_t &cmdmap, - const MCommand::const_ref &m, + const cref_t &m, int *r, std::stringstream *ds, std::stringstream *ss, @@ -632,10 +632,10 @@ public: bool *need_reply); void dump_sessions(const SessionFilter &filter, Formatter *f) const; - void evict_clients(const SessionFilter &filter, const MCommand::const_ref &m); + void evict_clients(const SessionFilter &filter, const cref_t &m); // Call into me from MDS::ms_dispatch - bool ms_dispatch(const Message::const_ref &m); + bool ms_dispatch(const cref_t &m); MDSRankDispatcher( mds_rank_t whoami_, diff --git a/src/mds/MDSTableClient.cc b/src/mds/MDSTableClient.cc index 6418b1306d3..7e53db476d3 100644 --- a/src/mds/MDSTableClient.cc +++ b/src/mds/MDSTableClient.cc @@ -46,7 +46,7 @@ public: }; -void MDSTableClient::handle_request(const MMDSTableRequest::const_ref &m) +void MDSTableClient::handle_request(const cref_t &m) { dout(10) << "handle_request " << *m << dendl; ceph_assert(m->table == table); diff --git a/src/mds/MDSTableClient.h b/src/mds/MDSTableClient.h index f2bf461ad94..75326c2f121 100644 --- a/src/mds/MDSTableClient.h +++ b/src/mds/MDSTableClient.h @@ -62,7 +62,7 @@ public: mds(m), table(tab), last_reqid(~0ULL), server_ready(false) {} virtual ~MDSTableClient() {} - void handle_request(const MMDSTableRequest::const_ref &m); + void handle_request(const cref_t &m); void _prepare(bufferlist& mutation, version_t *ptid, bufferlist *pbl, MDSContext *onfinish); void commit(version_t tid, LogSegment *ls); @@ -92,8 +92,8 @@ public: // child must implement virtual void resend_queries() = 0; - virtual void handle_query_result(const MMDSTableRequest::const_ref &m) = 0; - virtual void handle_notify_prep(const MMDSTableRequest::const_ref &m) = 0; + virtual void handle_query_result(const cref_t &m) = 0; + virtual void handle_notify_prep(const cref_t &m) = 0; virtual void notify_commit(version_t tid) = 0; // and friendly front-end for _prepare. diff --git a/src/mds/MDSTableServer.cc b/src/mds/MDSTableServer.cc index cd7724f5e03..493b82127ba 100644 --- a/src/mds/MDSTableServer.cc +++ b/src/mds/MDSTableServer.cc @@ -24,7 +24,7 @@ #undef dout_prefix #define dout_prefix *_dout << "mds." << rank << ".tableserver(" << get_mdstable_name(table) << ") " -void MDSTableServer::handle_request(const MMDSTableRequest::const_ref &req) +void MDSTableServer::handle_request(const cref_t &req) { ceph_assert(req->op >= 0); switch (req->op) { @@ -39,19 +39,19 @@ void MDSTableServer::handle_request(const MMDSTableRequest::const_ref &req) class C_Prepare : public MDSLogContextBase { MDSTableServer *server; - MMDSTableRequest::const_ref req; + cref_t req; version_t tid; MDSRank *get_mds() override { return server->mds; } public: - C_Prepare(MDSTableServer *s, const MMDSTableRequest::const_ref r, version_t v) : server(s), req(r), tid(v) {} + C_Prepare(MDSTableServer *s, const cref_t r, version_t v) : server(s), req(r), tid(v) {} void finish(int r) override { server->_prepare_logged(req, tid); } }; // prepare -void MDSTableServer::handle_prepare(const MMDSTableRequest::const_ref &req) +void MDSTableServer::handle_prepare(const cref_t &req) { dout(7) << "handle_prepare " << *req << dendl; mds_rank_t from = mds_rank_t(req->get_source().num()); @@ -68,7 +68,7 @@ void MDSTableServer::handle_prepare(const MMDSTableRequest::const_ref &req) mds->mdlog->flush(); } -void MDSTableServer::_prepare_logged(const MMDSTableRequest::const_ref &req, version_t tid) +void MDSTableServer::_prepare_logged(const cref_t &req, version_t tid) { dout(7) << "_create_logged " << *req << " tid " << tid << dendl; mds_rank_t from = mds_rank_t(req->get_source().num()); @@ -93,7 +93,7 @@ void MDSTableServer::_prepare_logged(const MMDSTableRequest::const_ref &req, ver } } -void MDSTableServer::handle_notify_ack(const MMDSTableRequest::const_ref &m) +void MDSTableServer::handle_notify_ack(const cref_t &m) { dout(7) << __func__ << " " << *m << dendl; mds_rank_t from = mds_rank_t(m->get_source().num()); @@ -118,17 +118,17 @@ void MDSTableServer::handle_notify_ack(const MMDSTableRequest::const_ref &m) class C_Commit : public MDSLogContextBase { MDSTableServer *server; - MMDSTableRequest::const_ref req; + cref_t req; MDSRank *get_mds() override { return server->mds; } public: - C_Commit(MDSTableServer *s, const MMDSTableRequest::const_ref &r) : server(s), req(r) {} + C_Commit(MDSTableServer *s, const cref_t &r) : server(s), req(r) {} void finish(int r) override { server->_commit_logged(req); } }; // commit -void MDSTableServer::handle_commit(const MMDSTableRequest::const_ref &req) +void MDSTableServer::handle_commit(const cref_t &req) { dout(7) << "handle_commit " << *req << dendl; @@ -163,7 +163,7 @@ void MDSTableServer::handle_commit(const MMDSTableRequest::const_ref &req) } } -void MDSTableServer::_commit_logged(const MMDSTableRequest::const_ref &req) +void MDSTableServer::_commit_logged(const cref_t &req) { dout(7) << "_commit_logged, sending ACK" << dendl; @@ -182,17 +182,17 @@ void MDSTableServer::_commit_logged(const MMDSTableRequest::const_ref &req) class C_Rollback : public MDSLogContextBase { MDSTableServer *server; - MMDSTableRequest::const_ref req; + cref_t req; MDSRank *get_mds() override { return server->mds; } public: - C_Rollback(MDSTableServer *s, const MMDSTableRequest::const_ref &r) : server(s), req(r) {} + C_Rollback(MDSTableServer *s, const cref_t &r) : server(s), req(r) {} void finish(int r) override { server->_rollback_logged(req); } }; // ROLLBACK -void MDSTableServer::handle_rollback(const MMDSTableRequest::const_ref &req) +void MDSTableServer::handle_rollback(const cref_t &req) { dout(7) << "handle_rollback " << *req << dendl; @@ -209,7 +209,7 @@ void MDSTableServer::handle_rollback(const MMDSTableRequest::const_ref &req) new C_Rollback(this, req)); } -void MDSTableServer::_rollback_logged(const MMDSTableRequest::const_ref &req) +void MDSTableServer::_rollback_logged(const cref_t &req) { dout(7) << "_rollback_logged " << *req << dendl; diff --git a/src/mds/MDSTableServer.h b/src/mds/MDSTableServer.h index 83f1031551e..5851326f5dd 100644 --- a/src/mds/MDSTableServer.h +++ b/src/mds/MDSTableServer.h @@ -38,28 +38,28 @@ private: }; map pending_notifies; - void handle_prepare(const MMDSTableRequest::const_ref &m); - void _prepare_logged(const MMDSTableRequest::const_ref &m, version_t tid); + void handle_prepare(const cref_t &m); + void _prepare_logged(const cref_t &m, version_t tid); friend class C_Prepare; - void handle_commit(const MMDSTableRequest::const_ref &m); - void _commit_logged(const MMDSTableRequest::const_ref &m); + void handle_commit(const cref_t &m); + void _commit_logged(const cref_t &m); friend class C_Commit; - void handle_rollback(const MMDSTableRequest::const_ref &m); - void _rollback_logged(const MMDSTableRequest::const_ref &m); + void handle_rollback(const cref_t &m); + void _rollback_logged(const cref_t &m); friend class C_Rollback; void _server_update_logged(bufferlist& bl); friend class C_ServerUpdate; - void handle_notify_ack(const MMDSTableRequest::const_ref &m); + void handle_notify_ack(const cref_t &m); public: - virtual void handle_query(const MMDSTableRequest::const_ref &m) = 0; + virtual void handle_query(const cref_t &m) = 0; virtual void _prepare(const bufferlist &bl, uint64_t reqid, mds_rank_t bymds, bufferlist& out) = 0; virtual void _get_reply_buffer(version_t tid, bufferlist *pbl) const = 0; - virtual void _commit(version_t tid, MMDSTableRequest::const_ref req) = 0; + virtual void _commit(version_t tid, cref_t req) = 0; virtual void _rollback(version_t tid) = 0; virtual void _server_update(bufferlist& bl) { ceph_abort(); } virtual bool _notify_prep(version_t tid) { return false; }; @@ -99,7 +99,7 @@ public: ++version; } - void handle_request(const MMDSTableRequest::const_ref &m); + void handle_request(const cref_t &m); void do_server_update(bufferlist& bl); virtual void encode_server_state(bufferlist& bl) const = 0; diff --git a/src/mds/Migrator.cc b/src/mds/Migrator.cc index 80465b0da18..b35500aabda 100644 --- a/src/mds/Migrator.cc +++ b/src/mds/Migrator.cc @@ -91,7 +91,7 @@ public: } }; -void Migrator::dispatch(const Message::const_ref &m) +void Migrator::dispatch(const cref_t &m) { switch (m->get_type()) { // import @@ -1174,7 +1174,7 @@ void Migrator::child_export_finish(std::shared_ptr& parent, bool * called on receipt of MExportDirDiscoverAck * the importer now has the directory's _inode_ in memory, and pinned. */ -void Migrator::handle_export_discover_ack(const MExportDirDiscoverAck::const_ref &m) +void Migrator::handle_export_discover_ack(const cref_t &m) { CDir *dir = cache->get_dirfrag(m->get_dirfrag()); mds_rank_t dest(m->get_source().num()); @@ -1432,7 +1432,7 @@ void Migrator::get_export_client_set(CInode *in, set& client_set) } } -void Migrator::handle_export_prep_ack(const MExportDirPrepAck::const_ref &m) +void Migrator::handle_export_prep_ack(const cref_t &m) { CDir *dir = cache->get_dirfrag(m->get_dirfrag()); mds_rank_t dest(m->get_source().num()); @@ -1853,7 +1853,7 @@ public: /* * i should get an export_ack from the export target. */ -void Migrator::handle_export_ack(const MExportDirAck::const_ref &m) +void Migrator::handle_export_ack(const cref_t &m) { CDir *dir = cache->get_dirfrag(m->get_dirfrag()); mds_rank_t dest(m->get_source().num()); @@ -2061,7 +2061,7 @@ void Migrator::export_logged_finish(CDir *dir) * i'll get an ack from each bystander. * when i get them all, unfreeze and send the finish. */ -void Migrator::handle_export_notify_ack(const MExportDirNotifyAck::const_ref &m) +void Migrator::handle_export_notify_ack(const cref_t &m) { CDir *dir = cache->get_dirfrag(m->get_dirfrag()); mds_rank_t dest(m->get_source().num()); @@ -2211,29 +2211,29 @@ void Migrator::export_finish(CDir *dir) class C_MDS_ExportDiscover : public MigratorContext { public: - C_MDS_ExportDiscover(Migrator *mig, const MExportDirDiscover::const_ref& m) : MigratorContext(mig), m(m) {} + C_MDS_ExportDiscover(Migrator *mig, const cref_t& m) : MigratorContext(mig), m(m) {} void finish(int r) override { mig->handle_export_discover(m, true); } private: - MExportDirDiscover::const_ref m; + cref_t m; }; class C_MDS_ExportDiscoverFactory : public MDSContextFactory { public: - C_MDS_ExportDiscoverFactory(Migrator *mig, MExportDirDiscover::const_ref m) : mig(mig), m(m) {} + C_MDS_ExportDiscoverFactory(Migrator *mig, cref_t m) : mig(mig), m(m) {} MDSContext *build() { return new C_MDS_ExportDiscover(mig, m); } private: Migrator *mig; - MExportDirDiscover::const_ref m; + cref_t m; }; // ========================================================== // IMPORT -void Migrator::handle_export_discover(const MExportDirDiscover::const_ref &m, bool started) +void Migrator::handle_export_discover(const cref_t &m, bool started) { mds_rank_t from = m->get_source_mds(); ceph_assert(from != mds->get_nodeid()); @@ -2331,7 +2331,7 @@ void Migrator::import_reverse_prepping(CDir *dir, import_state_t& stat) import_reverse_final(dir); } -void Migrator::handle_export_cancel(const MExportDirCancel::const_ref &m) +void Migrator::handle_export_cancel(const cref_t &m) { dout(7) << "handle_export_cancel on " << m->get_dirfrag() << dendl; dirfrag_t df = m->get_dirfrag(); @@ -2364,26 +2364,26 @@ void Migrator::handle_export_cancel(const MExportDirCancel::const_ref &m) class C_MDS_ExportPrep : public MigratorContext { public: - C_MDS_ExportPrep(Migrator *mig, const MExportDirPrep::const_ref& m) : MigratorContext(mig), m(m) {} + C_MDS_ExportPrep(Migrator *mig, const cref_t& m) : MigratorContext(mig), m(m) {} void finish(int r) override { mig->handle_export_prep(m, true); } private: - MExportDirPrep::const_ref m; + cref_t m; }; class C_MDS_ExportPrepFactory : public MDSContextFactory { public: - C_MDS_ExportPrepFactory(Migrator *mig, MExportDirPrep::const_ref m) : mig(mig), m(m) {} + C_MDS_ExportPrepFactory(Migrator *mig, cref_t m) : mig(mig), m(m) {} MDSContext *build() { return new C_MDS_ExportPrep(mig, m); } private: Migrator *mig; - MExportDirPrep::const_ref m; + cref_t m; }; -void Migrator::handle_export_prep(const MExportDirPrep::const_ref &m, bool did_assim) +void Migrator::handle_export_prep(const cref_t &m, bool did_assim) { mds_rank_t oldauth = mds_rank_t(m->get_source().num()); ceph_assert(oldauth != mds->get_nodeid()); @@ -2605,7 +2605,7 @@ public: } }; -void Migrator::handle_export_dir(const MExportDir::const_ref &m) +void Migrator::handle_export_dir(const cref_t &m) { assert (g_conf()->mds_kill_import_at != 5); CDir *dir = cache->get_dirfrag(m->dirfrag); @@ -3005,7 +3005,7 @@ void Migrator::import_logged_start(dirfrag_t df, CDir *dir, mds_rank_t from, cache->show_subtrees(); } -void Migrator::handle_export_finish(const MExportDirFinish::const_ref &m) +void Migrator::handle_export_finish(const cref_t &m) { CDir *dir = cache->get_dirfrag(m->get_dirfrag()); ceph_assert(dir); @@ -3393,7 +3393,7 @@ int Migrator::decode_import_dir(bufferlist::const_iterator& blp, // authority bystander -void Migrator::handle_export_notify(const MExportDirNotify::const_ref &m) +void Migrator::handle_export_notify(const cref_t &m) { if (!(mds->is_clientreplay() || mds->is_active() || mds->is_stopping())) { return; @@ -3452,7 +3452,7 @@ void Migrator::export_caps(CInode *in) mds->send_message_mds(ex, dest); } -void Migrator::handle_export_caps_ack(const MExportCapsAck::const_ref &ack) +void Migrator::handle_export_caps_ack(const cref_t &ack) { mds_rank_t from = ack->get_source().num(); CInode *in = cache->get_inode(ack->ino); @@ -3489,7 +3489,7 @@ void Migrator::handle_export_caps_ack(const MExportCapsAck::const_ref &ack) } } -void Migrator::handle_gather_caps(const MGatherCaps::const_ref &m) +void Migrator::handle_gather_caps(const cref_t &m) { CInode *in = cache->get_inode(m->ino); if (!in) @@ -3518,7 +3518,7 @@ public: } }; -void Migrator::handle_export_caps(const MExportCaps::const_ref &ex) +void Migrator::handle_export_caps(const cref_t &ex) { dout(10) << "handle_export_caps " << *ex << " from " << ex->get_source() << dendl; CInode *in = cache->get_inode(ex->ino); diff --git a/src/mds/Migrator.h b/src/mds/Migrator.h index e237463abcc..b4d8bc13180 100644 --- a/src/mds/Migrator.h +++ b/src/mds/Migrator.h @@ -160,9 +160,9 @@ protected: std::map import_state; - void handle_export_discover_ack(const MExportDirDiscoverAck::const_ref &m); + void handle_export_discover_ack(const cref_t &m); void export_frozen(CDir *dir, uint64_t tid); - void handle_export_prep_ack(const MExportDirPrepAck::const_ref &m); + void handle_export_prep_ack(const cref_t &m); void export_sessions_flushed(CDir *dir, uint64_t tid); void export_go(CDir *dir); void export_go_synced(CDir *dir, uint64_t tid); @@ -170,12 +170,12 @@ protected: 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, std::set& bounds); - void handle_export_ack(const MExportDirAck::const_ref &m); + void handle_export_ack(const cref_t &m); void export_logged_finish(CDir *dir); - void handle_export_notify_ack(const MExportDirNotifyAck::const_ref &m); + void handle_export_notify_ack(const cref_t &m); void export_finish(CDir *dir); - void handle_gather_caps(const MGatherCaps::const_ref &m); + void handle_gather_caps(const cref_t &m); friend class C_MDC_ExportFreeze; friend class C_MDS_ExportFinishLogged; @@ -187,10 +187,10 @@ protected: friend class MigratorLogContext; // importer - void handle_export_discover(const MExportDirDiscover::const_ref &m, bool started=false); - void handle_export_cancel(const MExportDirCancel::const_ref &m); - void handle_export_prep(const MExportDirPrep::const_ref &m, bool did_assim=false); - void handle_export_dir(const MExportDir::const_ref &m); + void handle_export_discover(const cref_t &m, bool started=false); + void handle_export_cancel(const cref_t &m); + void handle_export_prep(const cref_t &m, bool did_assim=false); + void handle_export_dir(const cref_t &m); void import_reverse_discovering(dirfrag_t df); void import_reverse_discovered(dirfrag_t df, CInode *diri); @@ -202,10 +202,10 @@ protected: void import_notify_finish(CDir *dir, std::set& bounds); void import_logged_start(dirfrag_t df, CDir *dir, mds_rank_t from, std::map >& imported_session_map); - void handle_export_finish(const MExportDirFinish::const_ref &m); + void handle_export_finish(const cref_t &m); - void handle_export_caps(const MExportCaps::const_ref &m); - void handle_export_caps_ack(const MExportCapsAck::const_ref &m); + void handle_export_caps(const cref_t &m); + void handle_export_caps_ack(const cref_t &m); void logged_import_caps(CInode *in, mds_rank_t from, std::map >& imported_session_map, @@ -217,12 +217,12 @@ protected: friend class C_M_LoggedImportCaps; // bystander - void handle_export_notify(const MExportDirNotify::const_ref &m); + void handle_export_notify(const cref_t &m); public: - void dispatch(const Message::const_ref &); + void dispatch(const cref_t &); void show_importing(); void show_exporting(); diff --git a/src/mds/Mutation.cc b/src/mds/Mutation.cc index bad865f683c..1cfaeadab6a 100644 --- a/src/mds/Mutation.cc +++ b/src/mds/Mutation.cc @@ -357,19 +357,19 @@ bool MDRequestImpl::is_queued_for_replay() const return client_request ? client_request->is_queued_for_replay() : false; } -MClientRequest::const_ref MDRequestImpl::release_client_request() +cref_t MDRequestImpl::release_client_request() { msg_lock.lock(); - MClientRequest::const_ref req; + cref_t req; req.swap(client_request); msg_lock.unlock(); return req; } -void MDRequestImpl::reset_slave_request(const MMDSSlaveRequest::const_ref& req) +void MDRequestImpl::reset_slave_request(const cref_t& req) { msg_lock.lock(); - MMDSSlaveRequest::const_ref old; + cref_t old; old.swap(slave_request); slave_request = req; msg_lock.unlock(); diff --git a/src/mds/Mutation.h b/src/mds/Mutation.h index d628a4a2d15..076be8b0b5f 100644 --- a/src/mds/Mutation.h +++ b/src/mds/Mutation.h @@ -244,7 +244,7 @@ struct MDRequestImpl : public MutationImpl { elist::item item_session_request; // if not on list, op is aborted. // -- i am a client (master) request - MClientRequest::const_ref client_request; // client request (if any) + cref_t client_request; // client request (if any) // store up to two sets of dn vectors, inode pointers, for request path1 and path2. vector dn[2]; @@ -271,7 +271,7 @@ struct MDRequestImpl : public MutationImpl { map cap_releases; // -- i am a slave request - MMDSSlaveRequest::const_ref slave_request; // slave request (if one is pending; implies slave == true) + cref_t slave_request; // slave request (if one is pending; implies slave == true) // -- i am an internal op int internal_op; @@ -345,8 +345,8 @@ struct MDRequestImpl : public MutationImpl { struct Params { metareqid_t reqid; __u32 attempt; - MClientRequest::const_ref client_req; - Message::const_ref triggering_slave_req; + cref_t client_req; + cref_t triggering_slave_req; mds_rank_t slave_to; utime_t initiated; utime_t throttled, all_read, dispatched; @@ -402,8 +402,8 @@ struct MDRequestImpl : public MutationImpl { void print(ostream &out) const override; void dump(Formatter *f) const override; - MClientRequest::const_ref release_client_request(); - void reset_slave_request(const MMDSSlaveRequest::const_ref& req=nullptr); + cref_t release_client_request(); + void reset_slave_request(const cref_t& req=nullptr); // TrackedOp stuff typedef boost::intrusive_ptr Ref; diff --git a/src/mds/Server.cc b/src/mds/Server.cc index 18b46e1fdf4..9c99076a862 100644 --- a/src/mds/Server.cc +++ b/src/mds/Server.cc @@ -197,7 +197,7 @@ Server::Server(MDSRank *m) : supported_features = feature_bitset_t(CEPHFS_FEATURES_MDS_SUPPORTED); } -void Server::dispatch(const Message::const_ref &m) +void Server::dispatch(const cref_t &m) { switch (m->get_type()) { case CEPH_MSG_CLIENT_RECONNECT: @@ -325,7 +325,7 @@ Session* Server::find_session_by_uuid(std::string_view uuid) return session; } -void Server::reclaim_session(Session *session, const MClientReclaim::const_ref &m) +void Server::reclaim_session(Session *session, const cref_t &m) { if (!session->is_open() && !session->is_stale()) { dout(10) << "session not open, dropping this req" << dendl; @@ -409,7 +409,7 @@ void Server::finish_reclaim_session(Session *session, const MClientReclaimReply: } } -void Server::handle_client_reclaim(const MClientReclaim::const_ref &m) +void Server::handle_client_reclaim(const cref_t &m) { Session *session = mds->get_session(m); dout(3) << __func__ << " " << *m << " from " << m->get_source() << dendl; @@ -432,7 +432,7 @@ void Server::handle_client_reclaim(const MClientReclaim::const_ref &m) } } -void Server::handle_client_session(const MClientSession::const_ref &m) +void Server::handle_client_session(const cref_t &m) { version_t pv; Session *session = mds->get_session(m); @@ -1193,7 +1193,7 @@ void Server::reconnect_clients(MDSContext *reconnect_done_) mds->sessionmap.dump(); } -void Server::handle_client_reconnect(const MClientReconnect::const_ref &m) +void Server::handle_client_reconnect(const cref_t &m) { dout(7) << "handle_client_reconnect " << m->get_source() << (m->has_more() ? " (more)" : "") << dendl; @@ -1730,7 +1730,7 @@ void Server::respond_to_request(MDRequestRef& mdr, int r) } // statistics mds req op number and latency -void Server::perf_gather_op_latency(const MClientRequest::const_ref &req, utime_t lat) +void Server::perf_gather_op_latency(const cref_t &req, utime_t lat) { int code = l_mdss_first; switch(req->get_op()) { @@ -1843,7 +1843,7 @@ void Server::early_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn) return; } - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; entity_inst_t client_inst = req->get_source_inst(); if (client_inst.name.is_mds()) return; @@ -1903,7 +1903,7 @@ void Server::early_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn) void Server::reply_client_request(MDRequestRef& mdr, const MClientReply::ref &reply) { ceph_assert(mdr.get()); - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; dout(7) << "reply_client_request " << reply->get_result() << " (" << cpp_strerror(reply->get_result()) @@ -2092,7 +2092,7 @@ void Server::set_trace_dist(Session *session, const MClientReply::ref &reply, reply->set_trace(bl); } -void Server::handle_client_request(const MClientRequest::const_ref &req) +void Server::handle_client_request(const cref_t &req) { dout(4) << "handle_client_request " << *req << dendl; @@ -2250,7 +2250,7 @@ void Server::dispatch_client_request(MDRequestRef& mdr) return; } - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; if (logger) logger->inc(l_mdss_dispatch_client_request); @@ -2401,7 +2401,7 @@ void Server::dispatch_client_request(MDRequestRef& mdr) // --------------------------------------- // SLAVE REQUESTS -void Server::handle_slave_request(const MMDSSlaveRequest::const_ref &m) +void Server::handle_slave_request(const cref_t &m) { dout(4) << "handle_slave_request " << m->get_reqid() << " from " << m->get_source() << dendl; mds_rank_t from = mds_rank_t(m->get_source().num()); @@ -2496,7 +2496,7 @@ void Server::handle_slave_request(const MMDSSlaveRequest::const_ref &m) dispatch_slave_request(mdr); } -void Server::handle_slave_request_reply(const MMDSSlaveRequest::const_ref &m) +void Server::handle_slave_request_reply(const cref_t &m) { mds_rank_t from = mds_rank_t(m->get_source().num()); @@ -2831,7 +2831,7 @@ void Server::handle_slave_auth_pin(MDRequestRef& mdr) return; } -void Server::handle_slave_auth_pin_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &ack) +void Server::handle_slave_auth_pin_ack(MDRequestRef& mdr, const cref_t &ack) { dout(10) << "handle_slave_auth_pin_ack on " << *mdr << " " << *ack << dendl; mds_rank_t from = mds_rank_t(ack->get_source().num()); @@ -3134,7 +3134,7 @@ CInode* Server::prepare_new_inode(MDRequestRef& mdr, CDir *dir, inodeno_t useino in->inode.change_attr = 0; - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; if (req->get_data().length()) { auto p = req->get_data().cbegin(); @@ -3495,7 +3495,7 @@ CDir* Server::try_open_auth_dirfrag(CInode *diri, frag_t fg, MDRequestRef& mdr) void Server::handle_client_getattr(MDRequestRef& mdr, bool is_lookup) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; if (req->get_filepath().depth() == 0 && is_lookup) { // refpath can't be empty for lookup but it can for @@ -3588,7 +3588,7 @@ struct C_MDS_LookupIno2 : public ServerContext { void Server::handle_client_lookup_ino(MDRequestRef& mdr, bool want_parent, bool want_dentry) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; if ((uint64_t)req->head.args.lookupino.snapid > 0) return _lookup_snap_ino(mdr); @@ -3681,7 +3681,7 @@ void Server::handle_client_lookup_ino(MDRequestRef& mdr, void Server::_lookup_snap_ino(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; vinodeno_t vino; vino.ino = req->get_filepath().get_ino(); @@ -3779,7 +3779,7 @@ void Server::_lookup_ino_2(MDRequestRef& mdr, int r) /* This function takes responsibility for the passed mdr*/ void Server::handle_client_open(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; dout(7) << "open on " << req->get_filepath() << dendl; int flags = req->head.args.open.flags; @@ -4001,7 +4001,7 @@ public: /* This function takes responsibility for the passed mdr*/ void Server::handle_client_openc(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; client_t client = mdr->get_client(); dout(7) << "open w/ O_CREAT on " << req->get_filepath() << dendl; @@ -4184,7 +4184,7 @@ void Server::handle_client_openc(MDRequestRef& mdr) void Server::handle_client_readdir(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; client_t client = req->get_source().num(); MutationImpl::LockOpVec lov; CInode *diri = rdlock_path_pin_ref(mdr, 0, lov, false, true); @@ -4476,7 +4476,7 @@ public: void Server::handle_client_file_setlock(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; MutationImpl::LockOpVec lov; // get the inode to operate on, and set up any locks needed for that @@ -4579,7 +4579,7 @@ void Server::handle_client_file_setlock(MDRequestRef& mdr) void Server::handle_client_file_readlock(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; MutationImpl::LockOpVec lov; // get the inode to operate on, and set up any locks needed for that @@ -4632,7 +4632,7 @@ void Server::handle_client_file_readlock(MDRequestRef& mdr) void Server::handle_client_setattr(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; MutationImpl::LockOpVec lov; CInode *cur = rdlock_path_pin_ref(mdr, 0, lov, true); if (!cur) return; @@ -4832,7 +4832,7 @@ void Server::do_open_truncate(MDRequestRef& mdr, int cmode) /* This function cleans up the passed mdr */ void Server::handle_client_setlayout(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; MutationImpl::LockOpVec lov; CInode *cur = rdlock_path_pin_ref(mdr, 0, lov, true); if (!cur) return; @@ -4921,7 +4921,7 @@ void Server::handle_client_setlayout(MDRequestRef& mdr) void Server::handle_client_setdirlayout(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; MutationImpl::LockOpVec lov; file_layout_t *dir_layout = nullptr; CInode *cur = rdlock_path_pin_ref(mdr, 0, lov, true, false, &dir_layout); @@ -5146,7 +5146,7 @@ int Server::check_layout_vxattr(MDRequestRef& mdr, string value, file_layout_t *layout) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; epoch_t epoch; int r; @@ -5208,7 +5208,7 @@ void Server::handle_set_vxattr(MDRequestRef& mdr, CInode *cur, file_layout_t *dir_layout, MutationImpl::LockOpVec& lov) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; string name(req->get_path2()); bufferlist bl = req->get_data(); string value (bl.c_str(), bl.length()); @@ -5368,7 +5368,7 @@ void Server::handle_remove_vxattr(MDRequestRef& mdr, CInode *cur, file_layout_t *dir_layout, MutationImpl::LockOpVec& lov) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; string name(req->get_path2()); dout(10) << __func__ << " " << name << " on " << *cur << dendl; @@ -5443,7 +5443,7 @@ public: void Server::handle_client_setxattr(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; string name(req->get_path2()); MutationImpl::LockOpVec lov; CInode *cur; @@ -5542,7 +5542,7 @@ void Server::handle_client_setxattr(MDRequestRef& mdr) void Server::handle_client_removexattr(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; std::string name(req->get_path2()); MutationImpl::LockOpVec lov; @@ -5656,7 +5656,7 @@ public: void Server::handle_client_mknod(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; client_t client = mdr->get_client(); MutationImpl::LockOpVec lov; file_layout_t *dir_layout = nullptr; @@ -5752,7 +5752,7 @@ void Server::handle_client_mknod(MDRequestRef& mdr) /* This function takes responsibility for the passed mdr*/ void Server::handle_client_mkdir(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; if (req->get_filepath().is_last_dot_or_dotdot()) { respond_to_request(mdr, -EEXIST); return; @@ -5839,7 +5839,7 @@ void Server::handle_client_mkdir(MDRequestRef& mdr) void Server::handle_client_symlink(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; MutationImpl::LockOpVec lov; CDentry *dn = rdlock_path_xlock_dentry(mdr, 0, lov, false, false, false); if (!dn) return; @@ -5895,7 +5895,7 @@ void Server::handle_client_symlink(MDRequestRef& mdr) void Server::handle_client_link(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; dout(7) << "handle_client_link " << req->get_filepath() << " to " << req->get_filepath2() @@ -6503,7 +6503,7 @@ void Server::_link_rollback_finish(MutationRef& mut, MDRequestRef& mdr, } -void Server::handle_slave_link_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &m) +void Server::handle_slave_link_prep_ack(MDRequestRef& mdr, const cref_t &m) { dout(10) << "handle_slave_link_prep_ack " << *mdr << " " << *m << dendl; @@ -6537,7 +6537,7 @@ void Server::handle_slave_link_prep_ack(MDRequestRef& mdr, const MMDSSlaveReques void Server::handle_client_unlink(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; client_t client = mdr->get_client(); // rmdir or unlink? @@ -7058,7 +7058,7 @@ void Server::_logged_slave_rmdir(MDRequestRef& mdr, CDentry *dn, CDentry *strayd } } -void Server::handle_slave_rmdir_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &ack) +void Server::handle_slave_rmdir_prep_ack(MDRequestRef& mdr, const cref_t &ack) { dout(10) << "handle_slave_rmdir_prep_ack " << *mdr << " " << *ack << dendl; @@ -7309,7 +7309,7 @@ public: */ void Server::handle_client_rename(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; dout(7) << "handle_client_rename " << *req << dendl; filepath destpath = req->get_filepath(); @@ -9336,7 +9336,7 @@ void Server::_rename_rollback_finish(MutationRef& mut, MDRequestRef& mdr, CDentr mut->cleanup(); } -void Server::handle_slave_rename_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &ack) +void Server::handle_slave_rename_prep_ack(MDRequestRef& mdr, const cref_t &ack) { dout(10) << "handle_slave_rename_prep_ack " << *mdr << " witnessed by " << ack->get_source() @@ -9382,7 +9382,7 @@ void Server::handle_slave_rename_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequ dout(10) << "still waiting on slaves " << mdr->more()->waiting_on_slave << dendl; } -void Server::handle_slave_rename_notify_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &ack) +void Server::handle_slave_rename_notify_ack(MDRequestRef& mdr, const cref_t &ack) { dout(10) << "handle_slave_rename_notify_ack " << *mdr << " from mds." << ack->get_source() << dendl; @@ -9421,7 +9421,7 @@ void Server::_slave_rename_sessions_flushed(MDRequestRef& mdr) /* This function takes responsibility for the passed mdr*/ void Server::handle_client_lssnap(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; // traverse to path CInode *diri = mdcache->get_inode(req->get_filepath().get_ino()); @@ -9536,7 +9536,7 @@ struct C_MDS_mksnap_finish : public ServerLogContext { /* This function takes responsibility for the passed mdr*/ void Server::handle_client_mksnap(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; // make sure we have as new a map as the client if (req->get_mdsmap_epoch() > mds->mdsmap->get_epoch()) { mds->wait_for_mdsmap(req->get_mdsmap_epoch(), new C_MDS_RetryRequest(mdcache, mdr)); @@ -9704,7 +9704,7 @@ struct C_MDS_rmsnap_finish : public ServerLogContext { /* This function takes responsibility for the passed mdr*/ void Server::handle_client_rmsnap(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; CInode *diri = mdcache->get_inode(req->get_filepath().get_ino()); if (!diri || diri->state_test(CInode::STATE_PURGING)) { @@ -9838,7 +9838,7 @@ struct C_MDS_renamesnap_finish : public ServerLogContext { /* This function takes responsibility for the passed mdr*/ void Server::handle_client_renamesnap(MDRequestRef& mdr) { - const MClientRequest::const_ref &req = mdr->client_request; + const cref_t &req = mdr->client_request; if (req->get_filepath().get_ino() != req->get_filepath2().get_ino()) { respond_to_request(mdr, -EINVAL); return; diff --git a/src/mds/Server.h b/src/mds/Server.h index e46cf2cad4e..b95676f1f76 100644 --- a/src/mds/Server.h +++ b/src/mds/Server.h @@ -124,7 +124,7 @@ public: void create_logger(); // message handler - void dispatch(const Message::const_ref &m); + void dispatch(const cref_t &m); void handle_osd_map(); @@ -136,7 +136,7 @@ public: return last_recall_state; } - void handle_client_session(const MClientSession::const_ref &m); + void handle_client_session(const cref_t &m); void _session_logged(Session *session, uint64_t state_seq, bool open, version_t pv, interval_set& inos,version_t piv); version_t prepare_force_open_sessions(map &cm, @@ -155,12 +155,12 @@ public: set client_reclaim_gather; size_t get_num_pending_reclaim() const { return client_reclaim_gather.size(); } Session *find_session_by_uuid(std::string_view uuid); - void reclaim_session(Session *session, const MClientReclaim::const_ref &m); + void reclaim_session(Session *session, const cref_t &m); void finish_reclaim_session(Session *session, const MClientReclaimReply::ref &reply=nullptr); - void handle_client_reclaim(const MClientReclaim::const_ref &m); + void handle_client_reclaim(const cref_t &m); void reconnect_clients(MDSContext *reconnect_done_); - void handle_client_reconnect(const MClientReconnect::const_ref &m); + void handle_client_reconnect(const cref_t &m); void infer_supported_features(Session *session, client_metadata_t& client_metadata); void update_required_client_features(); @@ -178,14 +178,14 @@ public: void force_clients_readonly(); // -- requests -- - void handle_client_request(const MClientRequest::const_ref &m); + void handle_client_request(const cref_t &m); void journal_and_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn, LogEvent *le, MDSLogContextBase *fin); void submit_mdlog_entry(LogEvent *le, MDSLogContextBase *fin, MDRequestRef& mdr, std::string_view event); void dispatch_client_request(MDRequestRef& mdr); - void perf_gather_op_latency(const MClientRequest::const_ref &req, utime_t lat); + void perf_gather_op_latency(const cref_t &req, utime_t lat); void early_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn); void respond_to_request(MDRequestRef& mdr, int r = 0); void set_trace_dist(Session *session, const MClientReply::ref &reply, CInode *in, CDentry *dn, @@ -194,11 +194,11 @@ public: MDRequestRef& mdr); - void handle_slave_request(const MMDSSlaveRequest::const_ref &m); - void handle_slave_request_reply(const MMDSSlaveRequest::const_ref &m); + void handle_slave_request(const cref_t &m); + void handle_slave_request_reply(const cref_t &m); void dispatch_slave_request(MDRequestRef& mdr); void handle_slave_auth_pin(MDRequestRef& mdr); - void handle_slave_auth_pin_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &ack); + void handle_slave_auth_pin_ack(MDRequestRef& mdr, const cref_t &ack); // some helpers bool check_fragment_space(MDRequestRef& mdr, CDir *in); @@ -282,7 +282,7 @@ public: void _logged_slave_link(MDRequestRef& mdr, CInode *targeti, bool adjust_realm); void _commit_slave_link(MDRequestRef& mdr, int r, CInode *targeti); void _committed_slave(MDRequestRef& mdr); // use for rename, too - void handle_slave_link_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &m); + void handle_slave_link_prep_ack(MDRequestRef& mdr, const cref_t &m); void do_link_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr); void _link_rollback_finish(MutationRef& mut, MDRequestRef& mdr, map& split); @@ -299,7 +299,7 @@ public: void handle_slave_rmdir_prep(MDRequestRef& mdr); void _logged_slave_rmdir(MDRequestRef& mdr, CDentry *srcdn, CDentry *straydn); void _commit_slave_rmdir(MDRequestRef& mdr, int r, CDentry *straydn); - void handle_slave_rmdir_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &ack); + void handle_slave_rmdir_prep_ack(MDRequestRef& mdr, const cref_t &ack); void do_rmdir_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr); void _rmdir_rollback_finish(MDRequestRef& mdr, metareqid_t reqid, CDentry *dn, CDentry *straydn); @@ -332,8 +332,8 @@ public: // slaving void handle_slave_rename_prep(MDRequestRef& mdr); - void handle_slave_rename_prep_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &m); - void handle_slave_rename_notify_ack(MDRequestRef& mdr, const MMDSSlaveRequest::const_ref &m); + void handle_slave_rename_prep_ack(MDRequestRef& mdr, const cref_t &m); + void handle_slave_rename_notify_ack(MDRequestRef& mdr, const cref_t &m); void _slave_rename_sessions_flushed(MDRequestRef& mdr); void _logged_slave_rename(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn); void _commit_slave_rename(MDRequestRef& mdr, int r, CDentry *srcdn, CDentry *destdn, CDentry *straydn); diff --git a/src/mds/SnapClient.cc b/src/mds/SnapClient.cc index fa1f56b4c35..99784d5f111 100644 --- a/src/mds/SnapClient.cc +++ b/src/mds/SnapClient.cc @@ -40,7 +40,7 @@ void SnapClient::resend_queries() } } -void SnapClient::handle_query_result(const MMDSTableRequest::const_ref &m) +void SnapClient::handle_query_result(const cref_t &m) { dout(10) << __func__ << " " << *m << dendl; @@ -111,7 +111,7 @@ void SnapClient::handle_query_result(const MMDSTableRequest::const_ref &m) } } -void SnapClient::handle_notify_prep(const MMDSTableRequest::const_ref &m) +void SnapClient::handle_notify_prep(const cref_t &m) { dout(10) << __func__ << " " << *m << dendl; handle_query_result(m); diff --git a/src/mds/SnapClient.h b/src/mds/SnapClient.h index c0d595ba9a2..ebbe4ef6304 100644 --- a/src/mds/SnapClient.h +++ b/src/mds/SnapClient.h @@ -45,8 +45,8 @@ public: sync_reqid(0), synced(false) {} void resend_queries() override; - void handle_query_result(const MMDSTableRequest::const_ref &m) override; - void handle_notify_prep(const MMDSTableRequest::const_ref &m) override; + void handle_query_result(const cref_t &m) override; + void handle_notify_prep(const cref_t &m) override; void notify_commit(version_t tid) override; void prepare_create(inodeno_t dirino, std::string_view name, utime_t stamp, diff --git a/src/mds/SnapServer.cc b/src/mds/SnapServer.cc index 4cd9dea8991..51e0cbaf2f4 100644 --- a/src/mds/SnapServer.cc +++ b/src/mds/SnapServer.cc @@ -159,7 +159,7 @@ void SnapServer::_get_reply_buffer(version_t tid, bufferlist *pbl) const assert (0 == "tid not found"); } -void SnapServer::_commit(version_t tid, MMDSTableRequest::const_ref req) +void SnapServer::_commit(version_t tid, cref_t req) { if (pending_update.count(tid)) { SnapInfo &info = pending_update[tid]; @@ -273,7 +273,7 @@ bool SnapServer::_notify_prep(version_t tid) return true; } -void SnapServer::handle_query(const MMDSTableRequest::const_ref &req) +void SnapServer::handle_query(const cref_t &req) { using ceph::encode; using ceph::decode; diff --git a/src/mds/SnapServer.h b/src/mds/SnapServer.h index a3f9f7db590..a0bc6adc6b1 100644 --- a/src/mds/SnapServer.h +++ b/src/mds/SnapServer.h @@ -85,11 +85,11 @@ protected: // server bits void _prepare(const bufferlist &bl, uint64_t reqid, mds_rank_t bymds, bufferlist &out) override; void _get_reply_buffer(version_t tid, bufferlist *pbl) const override; - void _commit(version_t tid, MMDSTableRequest::const_ref req) override; + void _commit(version_t tid, cref_t req) override; void _rollback(version_t tid) override; void _server_update(bufferlist& bl) override; bool _notify_prep(version_t tid) override; - void handle_query(const MMDSTableRequest::const_ref &m) override; + void handle_query(const cref_t &m) override; public: SnapServer(MDSRank *m, MonClient *monc) diff --git a/src/msg/DispatchQueue.cc b/src/msg/DispatchQueue.cc index 587a2dbee39..f3d4936a529 100644 --- a/src/msg/DispatchQueue.cc +++ b/src/msg/DispatchQueue.cc @@ -61,7 +61,7 @@ void DispatchQueue::post_dispatch(const Message::ref& m, uint64_t msize) ldout(cct,20) << "done calling dispatch on " << m << dendl; } -bool DispatchQueue::can_fast_dispatch(const Message::const_ref &m) const +bool DispatchQueue::can_fast_dispatch(const cref_t &m) const { return msgr->ms_can_fast_dispatch(m); } diff --git a/src/msg/DispatchQueue.h b/src/msg/DispatchQueue.h index 2d90d82c433..8244538219f 100644 --- a/src/msg/DispatchQueue.h +++ b/src/msg/DispatchQueue.h @@ -42,9 +42,9 @@ class DispatchQueue { class QueueItem { int type; ConnectionRef con; - Message::ref m; + ref_t m; public: - explicit QueueItem(const Message::ref& m) : type(-1), con(0), m(m) {} + explicit QueueItem(const ref_t& m) : type(-1), con(0), m(m) {} QueueItem(int type, Connection *con) : type(type), con(con), m(0) {} bool is_code() const { return type != -1; @@ -53,7 +53,7 @@ class DispatchQueue { ceph_assert(is_code()); return type; } - const Message::ref& get_message() { + const ref_t& get_message() { ceph_assert(!is_code()); return m; } @@ -70,9 +70,9 @@ class DispatchQueue { PrioritizedQueue mqueue; - std::set> marrival; - map marrival_map; - void add_arrival(const Message::ref& m) { + std::set>> marrival; + map, decltype(marrival)::iterator> marrival_map; + void add_arrival(const ref_t& m) { marrival_map.insert( make_pair( m, @@ -80,7 +80,7 @@ class DispatchQueue { ) ); } - void remove_arrival(const Message::ref& m) { + void remove_arrival(const ref_t& m) { auto it = marrival_map.find(m); ceph_assert(it != marrival_map.end()); marrival.erase(it->second); @@ -107,7 +107,7 @@ class DispatchQueue { Mutex local_delivery_lock; Cond local_delivery_cond; bool stop_local_delivery; - std::queue> local_messages; + std::queue, int>> local_messages; class LocalDeliveryThread : public Thread { DispatchQueue *dq; public: @@ -118,8 +118,8 @@ class DispatchQueue { } } local_delivery_thread; - uint64_t pre_dispatch(const Message::ref& m); - void post_dispatch(const Message::ref& m, uint64_t msize); + uint64_t pre_dispatch(const ref_t& m); + void post_dispatch(const ref_t& m, uint64_t msize); public: @@ -127,9 +127,9 @@ class DispatchQueue { Throttle dispatch_throttler; bool stop; - void local_delivery(const Message::ref& m, int priority); + void local_delivery(const ref_t& m, int priority); void local_delivery(Message* m, int priority) { - return local_delivery(Message::ref(m, false), priority); /* consume ref */ + return local_delivery(ref_t(m, false), priority); /* consume ref */ } void run_local_delivery(); @@ -198,15 +198,15 @@ class DispatchQueue { cond.Signal(); } - bool can_fast_dispatch(const Message::const_ref &m) const; - void fast_dispatch(const Message::ref& m); + bool can_fast_dispatch(const cref_t &m) const; + void fast_dispatch(const ref_t& m); void fast_dispatch(Message* m) { - return fast_dispatch(Message::ref(m, false)); /* consume ref */ + return fast_dispatch(ref_t(m, false)); /* consume ref */ } - void fast_preprocess(const Message::ref& m); - void enqueue(const Message::ref& m, int priority, uint64_t id); + void fast_preprocess(const ref_t& m); + void enqueue(const ref_t& m, int priority, uint64_t id); void enqueue(Message* m, int priority, uint64_t id) { - return enqueue(Message::ref(m, false), priority, id); /* consume ref */ + return enqueue(ref_t(m, false), priority, id); /* consume ref */ } void discard_queue(uint64_t id); void discard_local(); diff --git a/src/msg/Messenger.h b/src/msg/Messenger.h index 1eae5213526..6763716c945 100644 --- a/src/msg/Messenger.h +++ b/src/msg/Messenger.h @@ -642,7 +642,7 @@ public: * * @param m The Message we are testing. */ - bool ms_can_fast_dispatch(const Message::const_ref& m) { + bool ms_can_fast_dispatch(const cref_t& m) { for (const auto &dispatcher : fast_dispatchers) { if (dispatcher->ms_can_fast_dispatch2(m)) return true; diff --git a/src/msg/QueueStrategy.cc b/src/msg/QueueStrategy.cc index ee0bfdbd845..a6db0b96de6 100644 --- a/src/msg/QueueStrategy.cc +++ b/src/msg/QueueStrategy.cc @@ -46,11 +46,11 @@ void QueueStrategy::ds_dispatch(Message *m) { void QueueStrategy::entry(QSThread *thrd) { for (;;) { - Message::ref m; + ref_t m; lock.Lock(); for (;;) { if (! mqueue.empty()) { - m = Message::ref(&mqueue.front(), false); + m = ref_t(&mqueue.front(), false); mqueue.pop_front(); break; } -- 2.39.5