int retry_attempt;
std::atomic<uint64_t> ref = { 1 };
- MClientReply::const_ref reply; // the reply
+ ceph::cref_t<MClientReply> reply; // the reply
bool kick;
bool success;
});
}
-bool Beacon::ms_can_fast_dispatch2(const Message::const_ref& m) const
+bool Beacon::ms_can_fast_dispatch2(const cref_t<Message>& m) const
{
return m->get_type() == MSG_MDS_BEACON;
}
*
* 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<MMDSBeacon> &m)
{
std::unique_lock lock(mutex);
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<Message>& 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 {}
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<MMDSBeacon> &m);
void send();
void set_want_state(const MDSMap &mdsmap, MDSMap::DaemonState const newstate);
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<Message> &m)
{
switch (m->get_type()) {
}
}
-void Locker::handle_inode_file_caps(const MInodeFileCaps::const_ref &m)
+void Locker::handle_inode_file_caps(const cref_t<MInodeFileCaps> &m)
{
// nobody should be talking to us during recovery.
if (mds->get_state() < MDSMap::STATE_CLIENTREPLAY) {
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<MClientCaps> &m)
{
client_t client = m->get_source().num();
snapid_t follows = m->get_snap_follows();
/**
* 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<MClientCaps> &m, const MClientCaps::ref &ack)
{
dout(10) << "_do_snap_update dirty " << ccap_string(dirty)
<< " follows " << follows << " snap " << snap
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<MClientCaps> &m, CInode::mempool_inode *pi)
{
if (dirty == 0)
return;
*/
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<MClientCaps> &m, const MClientCaps::ref &ack,
bool *need_flush)
{
dout(10) << "_do_cap_update dirty " << ccap_string(dirty)
return true;
}
-void Locker::handle_client_cap_release(const MClientCapRelease::const_ref &m)
+void Locker::handle_client_cap_release(const cref_t<MClientCapRelease> &m)
{
client_t client = m->get_source().num();
dout(10) << "handle_client_cap_release " << *m << dendl;
}
-void Locker::handle_client_lease(const MClientLease::const_ref &m)
+void Locker::handle_client_lease(const cref_t<MClientLease> &m)
{
dout(10) << "handle_client_lease " << *m << dendl;
return 0;
}
-void Locker::handle_lock(const MLock::const_ref &m)
+void Locker::handle_lock(const cref_t<MLock> &m)
{
// nobody should be talking to us during recovery.
ceph_assert(mds->is_rejoin() || mds->is_clientreplay() || mds->is_active() || mds->is_stopping());
/** 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<MLock> &m)
{
MDSCacheObject *parent = lock->get_parent();
if (parent->is_auth() &&
}
}
-void Locker::handle_simple_lock(SimpleLock *lock, const MLock::const_ref &m)
+void Locker::handle_simple_lock(SimpleLock *lock, const cref_t<MLock> &m)
{
int from = m->get_asker();
// messenger
-void Locker::handle_file_lock(ScatterLock *lock, const MLock::const_ref &m)
+void Locker::handle_file_lock(ScatterLock *lock, const cref_t<MLock> &m)
{
CInode *in = static_cast<CInode*>(lock->get_parent());
int from = m->get_asker();
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<Message> &m);
+ void handle_lock(const cref_t<MLock> &m);
void tick();
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<MLock> &m);
public:
bool simple_sync(SimpleLock *lock, bool *need_issue=0);
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<MLock> &m);
bool scatter_scatter_fastpath(ScatterLock *lock);
void scatter_scatter(ScatterLock *lock, bool nowait=false);
void scatter_tempsync(ScatterLock *lock, bool *need_issue=0);
void mark_updated_scatterlock(ScatterLock *lock);
- void handle_reqrdlock(SimpleLock *lock, const MLock::const_ref &m);
+ void handle_reqrdlock(SimpleLock *lock, const cref_t<MLock> &m);
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<MClientCaps> &m);
+ void _update_cap_fields(CInode *in, int dirty, const cref_t<MClientCaps> &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<MClientCaps> &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<MClientCaps> &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<MClientCapRelease> &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();
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<MLock> &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);
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<MInodeFileCaps> &m);
void file_update_finish(CInode *in, MutationRef& mut, unsigned flags,
client_t client, const MClientCaps::ref &ack);
// -- client leases --
public:
- void handle_client_lease(const MClientLease::const_ref &m);
+ void handle_client_lease(const cref_t<MClientLease> &m);
void issue_client_lease(CDentry *dn, client_t client, bufferlist &bl, utime_t now, Session *session);
void revoke_client_leases(SimpleLock *lock);
#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<Message> &m)
{
switch (m->get_type()) {
}
}
-void MDBalancer::handle_heartbeat(const MHeartbeat::const_ref &m)
+void MDBalancer::handle_heartbeat(const cref_t<MHeartbeat> &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;
const std::set <std::string> &changed,
const MDSMap &mds_map);
- int proc_message(const Message::const_ref &m);
+ int proc_message(const cref_t<Message> &m);
/**
* Regularly called upkeep function.
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<MHeartbeat> &m);
void find_exports(CDir *dir,
double amount,
std::vector<CDir*>* exports,
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<MMDSSlaveRequest> &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 &&
*
* This functions puts the passed message before returning
*/
-void MDCache::handle_resolve(const MMDSResolve::const_ref &m)
+void MDCache::handle_resolve(const cref_t<MMDSResolve> &m)
{
dout(7) << "handle_resolve from " << m->get_source() << dendl;
mds_rank_t from = mds_rank_t(m->get_source().num());
void MDCache::process_delayed_resolve()
{
dout(10) << "process_delayed_resolve" << dendl;
- map<mds_rank_t, MMDSResolve::const_ref> tmp;
+ map<mds_rank_t, cref_t<MMDSResolve>> tmp;
tmp.swap(delayed_resolve);
for (auto &p : tmp) {
handle_resolve(p.second);
}
}
-void MDCache::handle_resolve_ack(const MMDSResolveAck::const_ref &ack)
+void MDCache::handle_resolve_ack(const cref_t<MMDSResolveAck> &ack)
{
dout(10) << "handle_resolve_ack " << *ack << " from " << ack->get_source() << dendl;
mds_rank_t from = mds_rank_t(ack->get_source().num());
* 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<MMDSCacheRejoin> &m)
{
dout(7) << "handle_cache_rejoin " << *m << " from " << m->get_source()
<< " (" << m->get_payload().length() << " bytes)"
* - 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<MMDSCacheRejoin> &weak)
{
mds_rank_t from = mds_rank_t(weak->get_source().num());
* 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<MMDSCacheRejoin> &ack,
set<vinodeno_t>& acked_inodes,
set<SimpleLock *>& gather_locks)
{
return dir;
}
-void MDCache::handle_cache_rejoin_strong(const MMDSCacheRejoin::const_ref &strong)
+void MDCache::handle_cache_rejoin_strong(const cref_t<MMDSCacheRejoin> &strong)
{
mds_rank_t from = mds_rank_t(strong->get_source().num());
}
}
-void MDCache::handle_cache_rejoin_ack(const MMDSCacheRejoin::const_ref &ack)
+void MDCache::handle_cache_rejoin_ack(const cref_t<MMDSCacheRejoin> &ack)
{
dout(7) << "handle_cache_rejoin_ack from " << ack->get_source() << dendl;
mds_rank_t from = mds_rank_t(ack->get_source().num());
}
}
-void MDCache::handle_cache_expire(const MCacheExpire::const_ref &m)
+void MDCache::handle_cache_expire(const cref_t<MCacheExpire> &m)
{
mds_rank_t from = mds_rank_t(m->get_from());
// ========= messaging ==============
-void MDCache::dispatch(const Message::const_ref &m)
+void MDCache::dispatch(const cref_t<Message> &m)
{
switch (m->get_type()) {
struct C_MDC_OpenInoTraverseDir : public MDCacheContext {
inodeno_t ino;
- MMDSOpenIno::const_ref msg;
+ cref_t<MMDSOpenIno> 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<MMDSOpenIno> &m, bool p) :
MDCacheContext(c), ino(i), msg(m), parent(p) {}
void finish(int r) override {
if (r < 0 && !parent)
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<MMDSOpenIno> &m, CDir *dir, bool parent)
{
if (dir->state_test(CDir::STATE_REJOINUNDEF))
ceph_assert(dir->get_inode()->dirfragtree.is_leaf(dir->get_frag()));
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<MMDSOpenIno> &m,
const vector<inode_backpointer_t>& ancestors,
bool discover, bool want_xlocked, mds_rank_t *hint)
{
}
}
-void MDCache::handle_open_ino(const MMDSOpenIno::const_ref &m, int err)
+void MDCache::handle_open_ino(const cref_t<MMDSOpenIno> &m, int err)
{
if (mds->get_state() < MDSMap::STATE_REJOIN &&
mds->get_want_state() != CEPH_MDS_STATE_REJOIN) {
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<MMDSOpenInoReply> &m)
{
dout(10) << "handle_open_ino_reply " << *m << dendl;
}
}
-void MDCache::handle_find_ino(const MMDSFindIno::const_ref &m)
+void MDCache::handle_find_ino(const cref_t<MMDSFindIno> &m)
{
if (mds->get_state() < MDSMap::STATE_REJOIN) {
return;
}
-void MDCache::handle_find_ino_reply(const MMDSFindInoReply::const_ref &m)
+void MDCache::handle_find_ino_reply(const cref_t<MMDSFindInoReply> &m)
{
map<ceph_tid_t, find_ino_peer_info_t>::iterator p = find_ino_peer.find(m->tid);
if (p != find_ino_peer.end()) {
return count;
}
-MDRequestRef MDCache::request_start(const MClientRequest::const_ref& req)
+MDRequestRef MDCache::request_start(const cref_t<MClientRequest>& req)
{
// did we win a forward race against a slave?
if (active_requests.count(req->get_reqid())) {
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<Message> &m)
{
int by = m->get_source().num();
MDRequestImpl::Params params;
notify_global_snaprealm_update(snap_op);
}
-void MDCache::handle_snap_update(const MMDSSnapUpdate::const_ref &m)
+void MDCache::handle_snap_update(const cref_t<MMDSSnapUpdate> &m)
{
mds_rank_t from = mds_rank_t(m->get_source().num());
dout(10) << __func__ << " " << *m << " from mds." << from << dendl;
}
-void MDCache::handle_discover(const MDiscover::const_ref &dis)
+void MDCache::handle_discover(const cref_t<MDiscover> &dis)
{
mds_rank_t whoami = mds->get_nodeid();
mds_rank_t from = mds_rank_t(dis->get_source().num());
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<MDiscoverReply> &m)
{
/*
if (mds->get_state() < MDSMap::STATE_ACTIVE) {
return 0;
}
-void MDCache::handle_dir_update(const MDirUpdate::const_ref &m)
+void MDCache::handle_dir_update(const cref_t<MDirUpdate> &m)
{
dirfrag_t df = m->get_dirfrag();
CDir *dir = get_dirfrag(df);
}
}
-void MDCache::handle_dentry_link(const MDentryLink::const_ref &m)
+void MDCache::handle_dentry_link(const cref_t<MDentryLink> &m)
{
CDentry *dn = NULL;
CDir *dir = get_dirfrag(m->get_dirfrag());
}
}
-void MDCache::handle_dentry_unlink(const MDentryUnlink::const_ref &m)
+void MDCache::handle_dentry_unlink(const cref_t<MDentryUnlink> &m)
{
// straydn
CDentry *straydn = NULL;
}
-void MDCache::handle_fragment_notify_ack(const MMDSFragmentNotifyAck::const_ref &ack)
+void MDCache::handle_fragment_notify_ack(const cref_t<MMDSFragmentNotifyAck> &ack)
{
dout(10) << "handle_fragment_notify_ack " << *ack << " from " << ack->get_source() << dendl;
mds_rank_t from = mds_rank_t(ack->get_source().num());
}
}
-void MDCache::handle_fragment_notify(const MMDSFragmentNotify::const_ref ¬ify)
+void MDCache::handle_fragment_notify(const cref_t<MMDSFragmentNotify> ¬ify)
{
dout(10) << "handle_fragment_notify " << *notify << " from " << notify->get_source() << dendl;
mds_rank_t from = mds_rank_t(notify->get_source().num());
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<MClientRequest>& req);
+ MDRequestRef request_start_slave(metareqid_t rid, __u32 attempt, const cref_t<Message> &m);
MDRequestRef request_start_internal(int op);
bool have_request(metareqid_t rid) {
return active_requests.count(rid);
set<mds_rank_t> resolve_ack_gather; // nodes i need a resolve_ack from
set<version_t> resolve_snapclient_commits;
map<metareqid_t, mds_rank_t> resolve_need_rollback; // rollbacks i'm writing to the journal
- map<mds_rank_t, MMDSResolve::const_ref> delayed_resolve;
+ map<mds_rank_t, cref_t<MMDSResolve>> 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<MMDSResolve> &m);
+ void handle_resolve_ack(const cref_t<MMDSResolveAck> &m);
void process_delayed_resolve();
void discard_delayed_resolve(mds_rank_t who);
void maybe_resolve_finish();
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<MMDSCacheRejoin> &m);
+ void handle_cache_rejoin_weak(const cref_t<MMDSCacheRejoin> &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<MMDSCacheRejoin> &m);
+ void rejoin_scour_survivor_replicas(mds_rank_t from, const cref_t<MMDSCacheRejoin> &ack,
set<vinodeno_t>& acked_inodes,
set<SimpleLock *>& gather_locks);
- void handle_cache_rejoin_ack(const MMDSCacheRejoin::const_ref &m);
+ void handle_cache_rejoin_ack(const cref_t<MMDSCacheRejoin> &m);
void rejoin_send_acks();
void rejoin_trim_undef_inodes();
void maybe_send_pending_rejoins() {
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<MMDSOpenIno> &m, CDir *dir, bool parent);
+ int open_ino_traverse_dir(inodeno_t ino, const cref_t<MMDSOpenIno> &m,
const vector<inode_backpointer_t>& 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<MMDSOpenIno> &m, int err=0);
+ void handle_open_ino_reply(const cref_t<MMDSOpenInoReply> &m);
friend class C_IO_MDC_OpenInoBacktraceFetched;
friend struct C_MDC_OpenInoTraverseDir;
friend struct C_MDC_OpenInoParentOpened;
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<MMDSFindIno> &m);
+ void handle_find_ino_reply(const cref_t<MMDSFindInoReply> &m);
void kick_find_ino_peers(mds_rank_t who);
// -- snaprealms --
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<MMDSSnapUpdate> &m);
void notify_global_snaprealm_update(int snap_op);
// -- stray --
// == messages ==
public:
- void dispatch(const Message::const_ref &m);
+ void dispatch(const cref_t<Message> &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<MDiscover> &dis);
+ void handle_discover_reply(const cref_t<MDiscoverReply> &m);
friend class C_MDC_Join;
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<MDentryLink> &m);
+ void handle_dentry_unlink(const cref_t<MDentryUnlink> &m);
// -- fragmenting --
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<MMDSFragmentNotify> &m);
+ void handle_fragment_notify_ack(const cref_t<MMDSFragmentNotifyAck> &m);
void add_uncommitted_fragment(dirfrag_t basedirfrag, int bits, const frag_vec_t& old_frag,
LogSegment *ls, bufferlist *rollback=NULL);
//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<MDirUpdate> &m);
// -- cache expiration --
- void handle_cache_expire(const MCacheExpire::const_ref &m);
+ void handle_cache_expire(const cref_t<MCacheExpire> &m);
// delayed cache expire
map<CDir*, expiremap> delayed_expire; // subtree root -> expire msg
void process_delayed_expire(CDir *dir);
}
}
-void MDSDaemon::send_command_reply(const MCommand::const_ref &m, MDSRank *mds_rank,
+void MDSDaemon::send_command_reply(const cref_t<MCommand> &m, MDSRank *mds_rank,
int r, bufferlist outbl,
std::string_view outs)
{
m->get_connection()->send_message2(reply);
}
-void MDSDaemon::handle_command(const MCommand::const_ref &m)
+void MDSDaemon::handle_command(const cref_t<MCommand> &m)
{
auto priv = m->get_connection()->get_priv();
auto session = static_cast<Session *>(priv.get());
int MDSDaemon::_handle_command(
const cmdmap_t &cmdmap,
- const MCommand::const_ref &m,
+ const cref_t<MCommand> &m,
bufferlist *outbl,
std::string *outs,
Context **run_later,
return r;
}
-void MDSDaemon::handle_mds_map(const MMDSMap::const_ref &m)
+void MDSDaemon::handle_mds_map(const cref_t<MMDSMap> &m)
{
version_t epoch = m->get_epoch();
/*
* high priority messages we always process
*/
-bool MDSDaemon::handle_core_message(const Message::const_ref &m)
+bool MDSDaemon::handle_core_message(const cref_t<Message> &m)
{
switch (m->get_type()) {
case CEPH_MSG_MON_MAP:
void tick();
protected:
- bool handle_core_message(const Message::const_ref &m);
+ bool handle_core_message(const cref_t<Message> &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<MCommand> &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<MCommand> &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<MCommand> &m);
+ void handle_mds_map(const cref_t<MMDSMap> &m);
void _handle_mds_map(const MDSMap &oldmap);
private:
}
}
-bool MDSRankDispatcher::ms_dispatch(const Message::const_ref &m)
+bool MDSRankDispatcher::ms_dispatch(const cref_t<Message> &m)
{
if (m->get_source().is_client()) {
Session *session = static_cast<Session*>(m->get_connection()->get_priv().get());
return ret;
}
-bool MDSRank::_dispatch(const Message::const_ref &m, bool new_msg)
+bool MDSRank::_dispatch(const cref_t<Message> &m, bool new_msg)
{
if (is_stale_message(m)) {
return true;
/*
* 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<Message> &m)
{
int port = m->get_type() & 0xff00;
case MSG_MDS_TABLE_REQUEST:
ALLOW_MESSAGES_FROM(CEPH_ENTITY_TYPE_MDS);
{
- const MMDSTableRequest::const_ref &req = MMDSTableRequest::msgref_cast(m);
+ const cref_t<MMDSTableRequest> &req = MMDSTableRequest::msgref_cast(m);
if (req->op < 0) {
MDSTableClient *client = get_table_client(req->table);
client->handle_request(req);
if (beacon.is_laggy())
break;
- Message::const_ref old = waiting_for_nolaggy.front();
+ cref_t<Message> old = waiting_for_nolaggy.front();
waiting_for_nolaggy.pop_front();
if (!is_stale_message(old)) {
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<Message> &m) const
{
// from bad mds?
if (m->get_source().is_mds()) {
return false;
}
-Session *MDSRank::get_session(const Message::const_ref &m)
+Session *MDSRank::get_session(const cref_t<Message> &m)
{
// do not carry ref
auto session = static_cast<Session *>(m->get_connection()->get_priv().get());
return session;
}
-void MDSRank::send_message(const Message::ref& m, const ConnectionRef& c)
+void MDSRank::send_message(const ref_t<Message>& 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<Message>& m, mds_rank_t mds)
{
if (!mdsmap->is_up(mds)) {
dout(10) << "send_message_mds mds." << mds << " not up, dropping " << *m << dendl;
}
// send message
- messenger->send_to_mds(Message::ref(m).detach(), mdsmap->get_addrs(mds));
+ messenger->send_to_mds(ref_t<Message>(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<MClientRequest>& m, mds_rank_t mds)
{
ceph_assert(mds != whoami);
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<Message>& m, client_t client)
{
Session *session = sessionmap.get_session(entity_name_t::CLIENT(client.v));
if (session) {
}
}
-void MDSRank::send_message_client_counted(const Message::ref& m, const ConnectionRef& connection)
+void MDSRank::send_message_client_counted(const ref_t<Message>& m, const ConnectionRef& connection)
{
// do not carry ref
auto session = static_cast<Session *>(connection->get_priv().get());
}
}
-void MDSRank::send_message_client_counted(const Message::ref& m, Session* session)
+void MDSRank::send_message_client_counted(const ref_t<Message>& m, Session* session)
{
version_t seq = session->inc_push_seq();
dout(10) << "send_message_client_counted " << session->info.inst.name << " seq "
}
}
-void MDSRank::send_message_client(const Message::ref& m, Session* session)
+void MDSRank::send_message_client(const ref_t<Message>& m, Session* session)
{
dout(10) << "send_message_client " << session->info.inst << " " << *m << dendl;
if (session->get_connection()) {
osd_epoch_barrier = e;
}
-void MDSRank::retry_dispatch(const Message::const_ref &m)
+void MDSRank::retry_dispatch(const cref_t<Message> &m)
{
inc_dispatch_depth();
_dispatch(m, false);
}
void MDSRankDispatcher::handle_mds_map(
- const MMDSMap::const_ref &m,
+ const cref_t<MMDSMap> &m,
const MDSMap &oldmap)
{
// I am only to be passed MDSMaps in which I hold a rank
class C_MDS_Send_Command_Reply : public MDSInternalContext {
protected:
- MCommand::const_ref m;
+ cref_t<MCommand> m;
public:
- C_MDS_Send_Command_Reply(MDSRank *_mds, const MCommand::const_ref &_m) :
+ C_MDS_Send_Command_Reply(MDSRank *_mds, const cref_t<MCommand> &_m) :
MDSInternalContext(_mds), m(_m) {}
void send(int r, std::string_view ss) {
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<MCommand> &m)
: C_MDS_Send_Command_Reply(mds, m), f(true) {
}
class C_CacheDropExecAndReply : public C_ExecAndReply {
public:
- C_CacheDropExecAndReply(MDSRank *mds, const MCommand::const_ref &m,
+ C_CacheDropExecAndReply(MDSRank *mds, const cref_t<MCommand> &m,
uint64_t timeout)
: C_ExecAndReply(mds, m), timeout(timeout) {
}
class C_ScrubExecAndReply : public C_ExecAndReply {
public:
- C_ScrubExecAndReply(MDSRank *mds, const MCommand::const_ref &m,
+ C_ScrubExecAndReply(MDSRank *mds, const cref_t<MCommand> &m,
const std::string &path, const std::string &tag,
const std::vector<std::string> &scrubop)
: C_ExecAndReply(mds, m), path(path), tag(tag), scrubop(scrubop) {
class C_ScrubControlExecAndReply : public C_ExecAndReply {
public:
- C_ScrubControlExecAndReply(MDSRank *mds, const MCommand::const_ref &m,
+ C_ScrubControlExecAndReply(MDSRank *mds, const cref_t<MCommand> &m,
const std::string &command)
: C_ExecAndReply(mds, m), command(command) {
}
* 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<MCommand> &m)
{
C_MDS_Send_Command_Reply *reply = new C_MDS_Send_Command_Reply(this, m);
bool MDSRankDispatcher::handle_command(
const cmdmap_t &cmdmap,
- const MCommand::const_ref &m,
+ const cref_t<MCommand> &m,
int *r,
std::stringstream *ds,
std::stringstream *ss,
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<Message> &m);
PerfCounters *logger, *mlogger;
OpTracker op_tracker;
void signal() {cond.Signal();}
} progress_thread;
- list<Message::const_ref> waiting_for_nolaggy;
+ list<cref_t<Message>> 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<Message> &m);
+ bool handle_deferrable_message(const cref_t<Message> &m);
void _advance_queues();
- bool _dispatch(const Message::const_ref &m, bool new_msg);
+ bool _dispatch(const cref_t<Message> &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<Message> &m) const;
map<mds_rank_t, version_t> peer_mdsmap_epoch;
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<Message>& m, mds_rank_t mds);
+ void forward_message_mds(const cref_t<MClientRequest>& req, mds_rank_t mds);
+ void send_message_client_counted(const ref_t<Message>& m, client_t client);
+ void send_message_client_counted(const ref_t<Message>& m, Session* session);
+ void send_message_client_counted(const ref_t<Message>& m, const ConnectionRef& connection);
+ void send_message_client(const ref_t<Message>& m, Session* session);
+ void send_message(const ref_t<Message>& m, const ConnectionRef& c);
void wait_for_active_peer(mds_rank_t who, MDSContext *c) {
waiting_for_active_peer[who].push_back(c);
* 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<Message> &m)
: MDSInternalContext(mds), m(m) {}
void finish(int r) override {
get_mds()->retry_dispatch(m);
}
protected:
- Message::const_ref m;
+ cref_t<Message> 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<Message> &m)
: mds(mds), m(m) {}
MDSContext *build() {
private:
MDSRank *mds;
- Message::const_ref m;
+ cref_t<Message> m;
};
/**
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<MMDSMap> &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<MCommand> &m,
int *r,
std::stringstream *ds,
std::stringstream *ss,
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<MCommand> &m);
// Call into me from MDS::ms_dispatch
- bool ms_dispatch(const Message::const_ref &m);
+ bool ms_dispatch(const cref_t<Message> &m);
MDSRankDispatcher(
mds_rank_t whoami_,
};
-void MDSTableClient::handle_request(const MMDSTableRequest::const_ref &m)
+void MDSTableClient::handle_request(const cref_t<MMDSTableRequest> &m)
{
dout(10) << "handle_request " << *m << dendl;
ceph_assert(m->table == table);
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<MMDSTableRequest> &m);
void _prepare(bufferlist& mutation, version_t *ptid, bufferlist *pbl, MDSContext *onfinish);
void commit(version_t tid, LogSegment *ls);
// 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<MMDSTableRequest> &m) = 0;
+ virtual void handle_notify_prep(const cref_t<MMDSTableRequest> &m) = 0;
virtual void notify_commit(version_t tid) = 0;
// and friendly front-end for _prepare.
#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<MMDSTableRequest> &req)
{
ceph_assert(req->op >= 0);
switch (req->op) {
class C_Prepare : public MDSLogContextBase {
MDSTableServer *server;
- MMDSTableRequest::const_ref req;
+ cref_t<MMDSTableRequest> 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<MMDSTableRequest> 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<MMDSTableRequest> &req)
{
dout(7) << "handle_prepare " << *req << dendl;
mds_rank_t from = mds_rank_t(req->get_source().num());
mds->mdlog->flush();
}
-void MDSTableServer::_prepare_logged(const MMDSTableRequest::const_ref &req, version_t tid)
+void MDSTableServer::_prepare_logged(const cref_t<MMDSTableRequest> &req, version_t tid)
{
dout(7) << "_create_logged " << *req << " tid " << tid << dendl;
mds_rank_t from = mds_rank_t(req->get_source().num());
}
}
-void MDSTableServer::handle_notify_ack(const MMDSTableRequest::const_ref &m)
+void MDSTableServer::handle_notify_ack(const cref_t<MMDSTableRequest> &m)
{
dout(7) << __func__ << " " << *m << dendl;
mds_rank_t from = mds_rank_t(m->get_source().num());
class C_Commit : public MDSLogContextBase {
MDSTableServer *server;
- MMDSTableRequest::const_ref req;
+ cref_t<MMDSTableRequest> 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<MMDSTableRequest> &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<MMDSTableRequest> &req)
{
dout(7) << "handle_commit " << *req << dendl;
}
}
-void MDSTableServer::_commit_logged(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::_commit_logged(const cref_t<MMDSTableRequest> &req)
{
dout(7) << "_commit_logged, sending ACK" << dendl;
class C_Rollback : public MDSLogContextBase {
MDSTableServer *server;
- MMDSTableRequest::const_ref req;
+ cref_t<MMDSTableRequest> 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<MMDSTableRequest> &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<MMDSTableRequest> &req)
{
dout(7) << "handle_rollback " << *req << dendl;
new C_Rollback(this, req));
}
-void MDSTableServer::_rollback_logged(const MMDSTableRequest::const_ref &req)
+void MDSTableServer::_rollback_logged(const cref_t<MMDSTableRequest> &req)
{
dout(7) << "_rollback_logged " << *req << dendl;
};
map<version_t, notify_info_t> 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<MMDSTableRequest> &m);
+ void _prepare_logged(const cref_t<MMDSTableRequest> &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<MMDSTableRequest> &m);
+ void _commit_logged(const cref_t<MMDSTableRequest> &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<MMDSTableRequest> &m);
+ void _rollback_logged(const cref_t<MMDSTableRequest> &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<MMDSTableRequest> &m);
public:
- virtual void handle_query(const MMDSTableRequest::const_ref &m) = 0;
+ virtual void handle_query(const cref_t<MMDSTableRequest> &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<MMDSTableRequest> 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; };
++version;
}
- void handle_request(const MMDSTableRequest::const_ref &m);
+ void handle_request(const cref_t<MMDSTableRequest> &m);
void do_server_update(bufferlist& bl);
virtual void encode_server_state(bufferlist& bl) const = 0;
}
};
-void Migrator::dispatch(const Message::const_ref &m)
+void Migrator::dispatch(const cref_t<Message> &m)
{
switch (m->get_type()) {
// import
* 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<MExportDirDiscoverAck> &m)
{
CDir *dir = cache->get_dirfrag(m->get_dirfrag());
mds_rank_t dest(m->get_source().num());
}
}
-void Migrator::handle_export_prep_ack(const MExportDirPrepAck::const_ref &m)
+void Migrator::handle_export_prep_ack(const cref_t<MExportDirPrepAck> &m)
{
CDir *dir = cache->get_dirfrag(m->get_dirfrag());
mds_rank_t dest(m->get_source().num());
/*
* 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<MExportDirAck> &m)
{
CDir *dir = cache->get_dirfrag(m->get_dirfrag());
mds_rank_t dest(m->get_source().num());
* 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<MExportDirNotifyAck> &m)
{
CDir *dir = cache->get_dirfrag(m->get_dirfrag());
mds_rank_t dest(m->get_source().num());
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<MExportDirDiscover>& m) : MigratorContext(mig), m(m) {}
void finish(int r) override {
mig->handle_export_discover(m, true);
}
private:
- MExportDirDiscover::const_ref m;
+ cref_t<MExportDirDiscover> 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<MExportDirDiscover> m) : mig(mig), m(m) {}
MDSContext *build() {
return new C_MDS_ExportDiscover(mig, m);
}
private:
Migrator *mig;
- MExportDirDiscover::const_ref m;
+ cref_t<MExportDirDiscover> m;
};
// ==========================================================
// IMPORT
-void Migrator::handle_export_discover(const MExportDirDiscover::const_ref &m, bool started)
+void Migrator::handle_export_discover(const cref_t<MExportDirDiscover> &m, bool started)
{
mds_rank_t from = m->get_source_mds();
ceph_assert(from != mds->get_nodeid());
import_reverse_final(dir);
}
-void Migrator::handle_export_cancel(const MExportDirCancel::const_ref &m)
+void Migrator::handle_export_cancel(const cref_t<MExportDirCancel> &m)
{
dout(7) << "handle_export_cancel on " << m->get_dirfrag() << dendl;
dirfrag_t df = m->get_dirfrag();
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<MExportDirPrep>& m) : MigratorContext(mig), m(m) {}
void finish(int r) override {
mig->handle_export_prep(m, true);
}
private:
- MExportDirPrep::const_ref m;
+ cref_t<MExportDirPrep> 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<MExportDirPrep> m) : mig(mig), m(m) {}
MDSContext *build() {
return new C_MDS_ExportPrep(mig, m);
}
private:
Migrator *mig;
- MExportDirPrep::const_ref m;
+ cref_t<MExportDirPrep> m;
};
-void Migrator::handle_export_prep(const MExportDirPrep::const_ref &m, bool did_assim)
+void Migrator::handle_export_prep(const cref_t<MExportDirPrep> &m, bool did_assim)
{
mds_rank_t oldauth = mds_rank_t(m->get_source().num());
ceph_assert(oldauth != mds->get_nodeid());
}
};
-void Migrator::handle_export_dir(const MExportDir::const_ref &m)
+void Migrator::handle_export_dir(const cref_t<MExportDir> &m)
{
assert (g_conf()->mds_kill_import_at != 5);
CDir *dir = cache->get_dirfrag(m->dirfrag);
cache->show_subtrees();
}
-void Migrator::handle_export_finish(const MExportDirFinish::const_ref &m)
+void Migrator::handle_export_finish(const cref_t<MExportDirFinish> &m)
{
CDir *dir = cache->get_dirfrag(m->get_dirfrag());
ceph_assert(dir);
// authority bystander
-void Migrator::handle_export_notify(const MExportDirNotify::const_ref &m)
+void Migrator::handle_export_notify(const cref_t<MExportDirNotify> &m)
{
if (!(mds->is_clientreplay() || mds->is_active() || mds->is_stopping())) {
return;
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<MExportCapsAck> &ack)
{
mds_rank_t from = ack->get_source().num();
CInode *in = cache->get_inode(ack->ino);
}
}
-void Migrator::handle_gather_caps(const MGatherCaps::const_ref &m)
+void Migrator::handle_gather_caps(const cref_t<MGatherCaps> &m)
{
CInode *in = cache->get_inode(m->ino);
if (!in)
}
};
-void Migrator::handle_export_caps(const MExportCaps::const_ref &ex)
+void Migrator::handle_export_caps(const cref_t<MExportCaps> &ex)
{
dout(10) << "handle_export_caps " << *ex << " from " << ex->get_source() << dendl;
CInode *in = cache->get_inode(ex->ino);
std::map<dirfrag_t, import_state_t> import_state;
- void handle_export_discover_ack(const MExportDirDiscoverAck::const_ref &m);
+ void handle_export_discover_ack(const cref_t<MExportDirDiscoverAck> &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<MExportDirPrepAck> &m);
void export_sessions_flushed(CDir *dir, uint64_t tid);
void export_go(CDir *dir);
void export_go_synced(CDir *dir, uint64_t tid);
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<CDir*>& bounds);
- void handle_export_ack(const MExportDirAck::const_ref &m);
+ void handle_export_ack(const cref_t<MExportDirAck> &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<MExportDirNotifyAck> &m);
void export_finish(CDir *dir);
- void handle_gather_caps(const MGatherCaps::const_ref &m);
+ void handle_gather_caps(const cref_t<MGatherCaps> &m);
friend class C_MDC_ExportFreeze;
friend class C_MDS_ExportFinishLogged;
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<MExportDirDiscover> &m, bool started=false);
+ void handle_export_cancel(const cref_t<MExportDirCancel> &m);
+ void handle_export_prep(const cref_t<MExportDirPrep> &m, bool did_assim=false);
+ void handle_export_dir(const cref_t<MExportDir> &m);
void import_reverse_discovering(dirfrag_t df);
void import_reverse_discovered(dirfrag_t df, CInode *diri);
void import_notify_finish(CDir *dir, std::set<CDir*>& bounds);
void import_logged_start(dirfrag_t df, CDir *dir, mds_rank_t from,
std::map<client_t,pair<Session*,uint64_t> >& imported_session_map);
- void handle_export_finish(const MExportDirFinish::const_ref &m);
+ void handle_export_finish(const cref_t<MExportDirFinish> &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<MExportCaps> &m);
+ void handle_export_caps_ack(const cref_t<MExportCapsAck> &m);
void logged_import_caps(CInode *in,
mds_rank_t from,
std::map<client_t,pair<Session*,uint64_t> >& imported_session_map,
friend class C_M_LoggedImportCaps;
// bystander
- void handle_export_notify(const MExportDirNotify::const_ref &m);
+ void handle_export_notify(const cref_t<MExportDirNotify> &m);
public:
- void dispatch(const Message::const_ref &);
+ void dispatch(const cref_t<Message> &);
void show_importing();
void show_exporting();
return client_request ? client_request->is_queued_for_replay() : false;
}
-MClientRequest::const_ref MDRequestImpl::release_client_request()
+cref_t<MClientRequest> MDRequestImpl::release_client_request()
{
msg_lock.lock();
- MClientRequest::const_ref req;
+ cref_t<MClientRequest> 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<MMDSSlaveRequest>& req)
{
msg_lock.lock();
- MMDSSlaveRequest::const_ref old;
+ cref_t<MMDSSlaveRequest> old;
old.swap(slave_request);
slave_request = req;
msg_lock.unlock();
elist<MDRequestImpl*>::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<MClientRequest> client_request; // client request (if any)
// store up to two sets of dn vectors, inode pointers, for request path1 and path2.
vector<CDentry*> dn[2];
map<vinodeno_t, ceph_seq_t> cap_releases;
// -- i am a slave request
- MMDSSlaveRequest::const_ref slave_request; // slave request (if one is pending; implies slave == true)
+ cref_t<MMDSSlaveRequest> slave_request; // slave request (if one is pending; implies slave == true)
// -- i am an internal op
int internal_op;
struct Params {
metareqid_t reqid;
__u32 attempt;
- MClientRequest::const_ref client_req;
- Message::const_ref triggering_slave_req;
+ cref_t<MClientRequest> client_req;
+ cref_t<Message> triggering_slave_req;
mds_rank_t slave_to;
utime_t initiated;
utime_t throttled, all_read, dispatched;
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<MClientRequest> release_client_request();
+ void reset_slave_request(const cref_t<MMDSSlaveRequest>& req=nullptr);
// TrackedOp stuff
typedef boost::intrusive_ptr<MDRequestImpl> Ref;
supported_features = feature_bitset_t(CEPHFS_FEATURES_MDS_SUPPORTED);
}
-void Server::dispatch(const Message::const_ref &m)
+void Server::dispatch(const cref_t<Message> &m)
{
switch (m->get_type()) {
case CEPH_MSG_CLIENT_RECONNECT:
return session;
}
-void Server::reclaim_session(Session *session, const MClientReclaim::const_ref &m)
+void Server::reclaim_session(Session *session, const cref_t<MClientReclaim> &m)
{
if (!session->is_open() && !session->is_stale()) {
dout(10) << "session not open, dropping this req" << dendl;
}
}
-void Server::handle_client_reclaim(const MClientReclaim::const_ref &m)
+void Server::handle_client_reclaim(const cref_t<MClientReclaim> &m)
{
Session *session = mds->get_session(m);
dout(3) << __func__ << " " << *m << " from " << m->get_source() << dendl;
}
}
-void Server::handle_client_session(const MClientSession::const_ref &m)
+void Server::handle_client_session(const cref_t<MClientSession> &m)
{
version_t pv;
Session *session = mds->get_session(m);
mds->sessionmap.dump();
}
-void Server::handle_client_reconnect(const MClientReconnect::const_ref &m)
+void Server::handle_client_reconnect(const cref_t<MClientReconnect> &m)
{
dout(7) << "handle_client_reconnect " << m->get_source()
<< (m->has_more() ? " (more)" : "") << dendl;
}
// 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<MClientRequest> &req, utime_t lat)
{
int code = l_mdss_first;
switch(req->get_op()) {
return;
}
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
entity_inst_t client_inst = req->get_source_inst();
if (client_inst.name.is_mds())
return;
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<MClientRequest> &req = mdr->client_request;
dout(7) << "reply_client_request " << reply->get_result()
<< " (" << cpp_strerror(reply->get_result())
reply->set_trace(bl);
}
-void Server::handle_client_request(const MClientRequest::const_ref &req)
+void Server::handle_client_request(const cref_t<MClientRequest> &req)
{
dout(4) << "handle_client_request " << *req << dendl;
return;
}
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
if (logger) logger->inc(l_mdss_dispatch_client_request);
// ---------------------------------------
// SLAVE REQUESTS
-void Server::handle_slave_request(const MMDSSlaveRequest::const_ref &m)
+void Server::handle_slave_request(const cref_t<MMDSSlaveRequest> &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());
dispatch_slave_request(mdr);
}
-void Server::handle_slave_request_reply(const MMDSSlaveRequest::const_ref &m)
+void Server::handle_slave_request_reply(const cref_t<MMDSSlaveRequest> &m)
{
mds_rank_t from = mds_rank_t(m->get_source().num());
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<MMDSSlaveRequest> &ack)
{
dout(10) << "handle_slave_auth_pin_ack on " << *mdr << " " << *ack << dendl;
mds_rank_t from = mds_rank_t(ack->get_source().num());
in->inode.change_attr = 0;
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
if (req->get_data().length()) {
auto p = req->get_data().cbegin();
void Server::handle_client_getattr(MDRequestRef& mdr, bool is_lookup)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
if (req->get_filepath().depth() == 0 && is_lookup) {
// refpath can't be empty for lookup but it can for
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<MClientRequest> &req = mdr->client_request;
if ((uint64_t)req->head.args.lookupino.snapid > 0)
return _lookup_snap_ino(mdr);
void Server::_lookup_snap_ino(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
vinodeno_t vino;
vino.ino = req->get_filepath().get_ino();
/* 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<MClientRequest> &req = mdr->client_request;
dout(7) << "open on " << req->get_filepath() << dendl;
int flags = req->head.args.open.flags;
/* 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<MClientRequest> &req = mdr->client_request;
client_t client = mdr->get_client();
dout(7) << "open w/ O_CREAT on " << req->get_filepath() << dendl;
void Server::handle_client_readdir(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &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);
void Server::handle_client_file_setlock(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
// get the inode to operate on, and set up any locks needed for that
void Server::handle_client_file_readlock(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
// get the inode to operate on, and set up any locks needed for that
void Server::handle_client_setattr(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
CInode *cur = rdlock_path_pin_ref(mdr, 0, lov, true);
if (!cur) return;
/* 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<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
CInode *cur = rdlock_path_pin_ref(mdr, 0, lov, true);
if (!cur) return;
void Server::handle_client_setdirlayout(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &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);
string value,
file_layout_t *layout)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
epoch_t epoch;
int r;
file_layout_t *dir_layout,
MutationImpl::LockOpVec& lov)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
string name(req->get_path2());
bufferlist bl = req->get_data();
string value (bl.c_str(), bl.length());
file_layout_t *dir_layout,
MutationImpl::LockOpVec& lov)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
string name(req->get_path2());
dout(10) << __func__ << " " << name << " on " << *cur << dendl;
void Server::handle_client_setxattr(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
string name(req->get_path2());
MutationImpl::LockOpVec lov;
CInode *cur;
void Server::handle_client_removexattr(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
std::string name(req->get_path2());
MutationImpl::LockOpVec lov;
void Server::handle_client_mknod(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
client_t client = mdr->get_client();
MutationImpl::LockOpVec lov;
file_layout_t *dir_layout = nullptr;
/* 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<MClientRequest> &req = mdr->client_request;
if (req->get_filepath().is_last_dot_or_dotdot()) {
respond_to_request(mdr, -EEXIST);
return;
void Server::handle_client_symlink(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
CDentry *dn = rdlock_path_xlock_dentry(mdr, 0, lov, false, false, false);
if (!dn) return;
void Server::handle_client_link(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
dout(7) << "handle_client_link " << req->get_filepath()
<< " to " << req->get_filepath2()
}
-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<MMDSSlaveRequest> &m)
{
dout(10) << "handle_slave_link_prep_ack " << *mdr
<< " " << *m << dendl;
void Server::handle_client_unlink(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
client_t client = mdr->get_client();
// rmdir or unlink?
}
}
-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<MMDSSlaveRequest> &ack)
{
dout(10) << "handle_slave_rmdir_prep_ack " << *mdr
<< " " << *ack << dendl;
*/
void Server::handle_client_rename(MDRequestRef& mdr)
{
- const MClientRequest::const_ref &req = mdr->client_request;
+ const cref_t<MClientRequest> &req = mdr->client_request;
dout(7) << "handle_client_rename " << *req << dendl;
filepath destpath = req->get_filepath();
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<MMDSSlaveRequest> &ack)
{
dout(10) << "handle_slave_rename_prep_ack " << *mdr
<< " witnessed by " << ack->get_source()
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<MMDSSlaveRequest> &ack)
{
dout(10) << "handle_slave_rename_notify_ack " << *mdr << " from mds."
<< ack->get_source() << dendl;
/* 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<MClientRequest> &req = mdr->client_request;
// traverse to path
CInode *diri = mdcache->get_inode(req->get_filepath().get_ino());
/* 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<MClientRequest> &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));
/* 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<MClientRequest> &req = mdr->client_request;
CInode *diri = mdcache->get_inode(req->get_filepath().get_ino());
if (!diri || diri->state_test(CInode::STATE_PURGING)) {
/* 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<MClientRequest> &req = mdr->client_request;
if (req->get_filepath().get_ino() != req->get_filepath2().get_ino()) {
respond_to_request(mdr, -EINVAL);
return;
void create_logger();
// message handler
- void dispatch(const Message::const_ref &m);
+ void dispatch(const cref_t<Message> &m);
void handle_osd_map();
return last_recall_state;
}
- void handle_client_session(const MClientSession::const_ref &m);
+ void handle_client_session(const cref_t<MClientSession> &m);
void _session_logged(Session *session, uint64_t state_seq,
bool open, version_t pv, interval_set<inodeno_t>& inos,version_t piv);
version_t prepare_force_open_sessions(map<client_t,entity_inst_t> &cm,
set<client_t> 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<MClientReclaim> &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<MClientReclaim> &m);
void reconnect_clients(MDSContext *reconnect_done_);
- void handle_client_reconnect(const MClientReconnect::const_ref &m);
+ void handle_client_reconnect(const cref_t<MClientReconnect> &m);
void infer_supported_features(Session *session, client_metadata_t& client_metadata);
void update_required_client_features();
void force_clients_readonly();
// -- requests --
- void handle_client_request(const MClientRequest::const_ref &m);
+ void handle_client_request(const cref_t<MClientRequest> &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<MClientRequest> &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,
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<MMDSSlaveRequest> &m);
+ void handle_slave_request_reply(const cref_t<MMDSSlaveRequest> &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<MMDSSlaveRequest> &ack);
// some helpers
bool check_fragment_space(MDRequestRef& mdr, CDir *in);
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<MMDSSlaveRequest> &m);
void do_link_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr);
void _link_rollback_finish(MutationRef& mut, MDRequestRef& mdr,
map<client_t,MClientSnap::ref>& split);
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<MMDSSlaveRequest> &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);
// 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<MMDSSlaveRequest> &m);
+ void handle_slave_rename_notify_ack(MDRequestRef& mdr, const cref_t<MMDSSlaveRequest> &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);
}
}
-void SnapClient::handle_query_result(const MMDSTableRequest::const_ref &m)
+void SnapClient::handle_query_result(const cref_t<MMDSTableRequest> &m)
{
dout(10) << __func__ << " " << *m << dendl;
}
}
-void SnapClient::handle_notify_prep(const MMDSTableRequest::const_ref &m)
+void SnapClient::handle_notify_prep(const cref_t<MMDSTableRequest> &m)
{
dout(10) << __func__ << " " << *m << dendl;
handle_query_result(m);
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<MMDSTableRequest> &m) override;
+ void handle_notify_prep(const cref_t<MMDSTableRequest> &m) override;
void notify_commit(version_t tid) override;
void prepare_create(inodeno_t dirino, std::string_view name, utime_t stamp,
assert (0 == "tid not found");
}
-void SnapServer::_commit(version_t tid, MMDSTableRequest::const_ref req)
+void SnapServer::_commit(version_t tid, cref_t<MMDSTableRequest> req)
{
if (pending_update.count(tid)) {
SnapInfo &info = pending_update[tid];
return true;
}
-void SnapServer::handle_query(const MMDSTableRequest::const_ref &req)
+void SnapServer::handle_query(const cref_t<MMDSTableRequest> &req)
{
using ceph::encode;
using ceph::decode;
// 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<MMDSTableRequest> 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<MMDSTableRequest> &m) override;
public:
SnapServer(MDSRank *m, MonClient *monc)
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<Message> &m) const
{
return msgr->ms_can_fast_dispatch(m);
}
class QueueItem {
int type;
ConnectionRef con;
- Message::ref m;
+ ref_t<Message> m;
public:
- explicit QueueItem(const Message::ref& m) : type(-1), con(0), m(m) {}
+ explicit QueueItem(const ref_t<Message>& 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;
ceph_assert(is_code());
return type;
}
- const Message::ref& get_message() {
+ const ref_t<Message>& get_message() {
ceph_assert(!is_code());
return m;
}
PrioritizedQueue<QueueItem, uint64_t> mqueue;
- std::set<pair<double, Message::ref>> marrival;
- map<Message::ref, decltype(marrival)::iterator> marrival_map;
- void add_arrival(const Message::ref& m) {
+ std::set<pair<double, ref_t<Message>>> marrival;
+ map<ref_t<Message>, decltype(marrival)::iterator> marrival_map;
+ void add_arrival(const ref_t<Message>& m) {
marrival_map.insert(
make_pair(
m,
)
);
}
- void remove_arrival(const Message::ref& m) {
+ void remove_arrival(const ref_t<Message>& m) {
auto it = marrival_map.find(m);
ceph_assert(it != marrival_map.end());
marrival.erase(it->second);
Mutex local_delivery_lock;
Cond local_delivery_cond;
bool stop_local_delivery;
- std::queue<pair<Message::ref, int>> local_messages;
+ std::queue<pair<ref_t<Message>, int>> local_messages;
class LocalDeliveryThread : public Thread {
DispatchQueue *dq;
public:
}
} 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<Message>& m);
+ void post_dispatch(const ref_t<Message>& m, uint64_t msize);
public:
Throttle dispatch_throttler;
bool stop;
- void local_delivery(const Message::ref& m, int priority);
+ void local_delivery(const ref_t<Message>& 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<Message>(m, false), priority); /* consume ref */
}
void run_local_delivery();
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<Message> &m) const;
+ void fast_dispatch(const ref_t<Message>& m);
void fast_dispatch(Message* m) {
- return fast_dispatch(Message::ref(m, false)); /* consume ref */
+ return fast_dispatch(ref_t<Message>(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<Message>& m);
+ void enqueue(const ref_t<Message>& 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<Message>(m, false), priority, id); /* consume ref */
}
void discard_queue(uint64_t id);
void discard_local();
*
* @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<Message>& m) {
for (const auto &dispatcher : fast_dispatchers) {
if (dispatcher->ms_can_fast_dispatch2(m))
return true;
void QueueStrategy::entry(QSThread *thrd)
{
for (;;) {
- Message::ref m;
+ ref_t<Message> m;
lock.Lock();
for (;;) {
if (! mqueue.empty()) {
- m = Message::ref(&mqueue.front(), false);
+ m = ref_t<Message>(&mqueue.front(), false);
mqueue.pop_front();
break;
}
projects / ceph-ci.git / commitdiff