The ref should be const even if its contents are not.
Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>
}
}
-bool Locker::try_rdlock_snap_layout(CInode *in, MDRequestRef& mdr,
+bool Locker::try_rdlock_snap_layout(CInode *in, const MDRequestRef& mdr,
int n, bool want_layout)
{
dout(10) << __func__ << " " << *mdr << " " << *in << dendl;
}
struct MarkEventOnDestruct {
- MDRequestRef& mdr;
+ MDRequestRef mdr;
std::string_view message;
bool mark_event;
- MarkEventOnDestruct(MDRequestRef& _mdr, std::string_view _message) :
+ MarkEventOnDestruct(const MDRequestRef& _mdr, std::string_view _message) :
mdr(_mdr),
message(_message),
mark_event(true) {}
/* If this function returns false, the mdr has been placed
* on the appropriate wait list */
-bool Locker::acquire_locks(MDRequestRef& mdr,
+bool Locker::acquire_locks(const MDRequestRef& mdr,
MutationImpl::LockOpVec& lov,
CInode *auth_pin_freeze,
bool auth_pin_nonblocking)
}
}
-void Locker::create_lock_cache(MDRequestRef& mdr, CInode *diri, file_layout_t *dir_layout)
+void Locker::create_lock_cache(const MDRequestRef& mdr, CInode *diri, file_layout_t *dir_layout)
{
if (mdr->lock_cache)
return;
mdr->lock_cache = lock_cache;
}
-bool Locker::find_and_attach_lock_cache(MDRequestRef& mdr, CInode *diri)
+bool Locker::find_and_attach_lock_cache(const MDRequestRef& mdr, CInode *diri)
{
if (mdr->lock_cache)
return true;
return false;
}
-bool Locker::rdlock_start(SimpleLock *lock, MDRequestRef& mut, bool as_anon)
+bool Locker::rdlock_start(SimpleLock *lock, const MDRequestRef& mut, bool as_anon)
{
dout(7) << "rdlock_start on " << *lock << " on " << *lock->get_parent() << dendl;
}
}
-bool Locker::rdlock_try_set(MutationImpl::LockOpVec& lov, MDRequestRef& mdr)
+bool Locker::rdlock_try_set(MutationImpl::LockOpVec& lov, const MDRequestRef& mdr)
{
dout(10) << __func__ << dendl;
for (const auto& p : lov) {
return false;
}
-bool Locker::wrlock_start(const MutationImpl::LockOp &op, MDRequestRef& mut)
+bool Locker::wrlock_start(const MutationImpl::LockOp &op, const MDRequestRef& mut)
{
SimpleLock *lock = op.lock;
if (lock->get_type() == CEPH_LOCK_IVERSION ||
// remote wrlock
-void Locker::remote_wrlock_start(SimpleLock *lock, mds_rank_t target, MDRequestRef& mut)
+void Locker::remote_wrlock_start(SimpleLock *lock, mds_rank_t target, const MDRequestRef& mut)
{
dout(7) << "remote_wrlock_start mds." << target << " on " << *lock << " on " << *lock->get_parent() << dendl;
// ------------------
// xlock
-bool Locker::xlock_start(SimpleLock *lock, MDRequestRef& mut)
+bool Locker::xlock_start(SimpleLock *lock, const MDRequestRef& mut)
{
if (lock->get_type() == CEPH_LOCK_IVERSION ||
lock->get_type() == CEPH_LOCK_DVERSION)
Capability* Locker::issue_new_caps(CInode *in,
int mode,
- MDRequestRef& mdr,
+ const MDRequestRef& mdr,
SnapRealm *realm)
{
dout(7) << "issue_new_caps for mode " << mode << " on " << *in << dendl;
}
};
-void Locker::process_request_cap_release(MDRequestRef& mdr, client_t client, const ceph_mds_request_release& item,
+void Locker::process_request_cap_release(const MDRequestRef& mdr, client_t client, const ceph_mds_request_release& item,
std::string_view dname)
{
inodeno_t ino = (uint64_t)item.ino;
issue_caps(in, cap);
}
-void Locker::kick_cap_releases(MDRequestRef& mdr)
+void Locker::kick_cap_releases(const MDRequestRef& mdr)
{
client_t client = mdr->get_client();
for (map<vinodeno_t,ceph_seq_t>::iterator p = mdr->cap_releases.begin();
}
-void Locker::issue_client_lease(CDentry *dn, CInode *in, MDRequestRef &mdr, utime_t now,
+void Locker::issue_client_lease(CDentry *dn, CInode *in, const MDRequestRef& mdr, utime_t now,
bufferlist &bl)
{
client_t client = mdr->get_client();
ceph_assert(it->is_wrlock());
}
-bool Locker::local_wrlock_start(LocalLockC *lock, MDRequestRef& mut)
+bool Locker::local_wrlock_start(LocalLockC *lock, const MDRequestRef& mut)
{
dout(7) << "local_wrlock_start on " << *lock
<< " on " << *lock->get_parent() << dendl;
}
}
-bool Locker::local_xlock_start(LocalLockC *lock, MDRequestRef& mut)
+bool Locker::local_xlock_start(LocalLockC *lock, const MDRequestRef& mut)
{
dout(7) << "local_xlock_start on " << *lock
<< " on " << *lock->get_parent() << dendl;
void nudge_log(SimpleLock *lock);
- bool acquire_locks(MDRequestRef& mdr,
+ bool acquire_locks(const MDRequestRef& mdr,
MutationImpl::LockOpVec& lov,
CInode *auth_pin_freeze=NULL,
bool auth_pin_nonblocking=false);
- bool try_rdlock_snap_layout(CInode *in, MDRequestRef& mdr,
+ bool try_rdlock_snap_layout(CInode *in, const MDRequestRef& mdr,
int n=0, bool want_layout=false);
void notify_freeze_waiter(MDSCacheObject *o);
void drop_locks_for_fragment_unfreeze(MutationImpl *mut);
int get_cap_bit_for_lock_cache(int op);
- void create_lock_cache(MDRequestRef& mdr, CInode *diri, file_layout_t *dir_layout=nullptr);
- bool find_and_attach_lock_cache(MDRequestRef& mdr, CInode *diri);
+ void create_lock_cache(const MDRequestRef& mdr, CInode *diri, file_layout_t *dir_layout=nullptr);
+ bool find_and_attach_lock_cache(const MDRequestRef& mdr, CInode *diri);
void invalidate_lock_caches(CDir *dir);
void invalidate_lock_caches(SimpleLock *lock);
void invalidate_lock_cache(MDLockCache *lock_cache);
bool _rdlock_kick(SimpleLock *lock, bool as_anon);
bool rdlock_try(SimpleLock *lock, client_t client);
- bool rdlock_start(SimpleLock *lock, MDRequestRef& mut, bool as_anon=false);
+ bool rdlock_start(SimpleLock *lock, const MDRequestRef& mut, bool as_anon=false);
void rdlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut, bool *pneed_issue);
- bool rdlock_try_set(MutationImpl::LockOpVec& lov, MDRequestRef& mdr);
+ bool rdlock_try_set(MutationImpl::LockOpVec& lov, const MDRequestRef& mdr);
bool rdlock_try_set(MutationImpl::LockOpVec& lov, MutationRef& mut);
void wrlock_force(SimpleLock *lock, MutationRef& mut);
bool wrlock_try(SimpleLock *lock, const MutationRef& mut, client_t client=-1);
- bool wrlock_start(const MutationImpl::LockOp &op, MDRequestRef& mut);
+ bool wrlock_start(const MutationImpl::LockOp &op, const MDRequestRef& mut);
void wrlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut, bool *pneed_issue);
- void remote_wrlock_start(SimpleLock *lock, mds_rank_t target, MDRequestRef& mut);
+ void remote_wrlock_start(SimpleLock *lock, mds_rank_t target, const MDRequestRef& mut);
void remote_wrlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut);
- bool xlock_start(SimpleLock *lock, MDRequestRef& mut);
+ bool xlock_start(SimpleLock *lock, const MDRequestRef& mut);
void _finish_xlock(SimpleLock *lock, client_t xlocker, bool *pneed_issue);
void xlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut, bool *pneed_issue);
// process_request_cap_release to preserve ordering.
bool should_defer_client_cap_frozen(CInode *in);
- void process_request_cap_release(MDRequestRef& mdr, client_t client, const ceph_mds_request_release& r,
+ void process_request_cap_release(const MDRequestRef& mdr, client_t client, const ceph_mds_request_release& r,
std::string_view dname);
- void kick_cap_releases(MDRequestRef& mdr);
+ void kick_cap_releases(const MDRequestRef& mdr);
void kick_issue_caps(CInode *in, client_t client, ceph_seq_t seq);
void remove_client_cap(CInode *in, Capability *cap, bool kill=false);
// -- file i/o --
version_t issue_file_data_version(CInode *in);
- Capability* issue_new_caps(CInode *in, int mode, MDRequestRef& mdr, SnapRealm *conrealm);
+ Capability* issue_new_caps(CInode *in, int mode, const MDRequestRef& mdr, SnapRealm *conrealm);
int get_allowed_caps(CInode *in, Capability *cap, int &all_allowed,
int &loner_allowed, int &xlocker_allowed);
int issue_caps(CInode *in, Capability *only_cap=0);
// -- client leases --
void handle_client_lease(const cref_t<MClientLease> &m);
- void issue_client_lease(CDentry *dn, CInode *in, MDRequestRef &mdr, utime_t now, bufferlist &bl);
+ void issue_client_lease(CDentry *dn, CInode *in, const MDRequestRef &mdr, utime_t now, bufferlist &bl);
void revoke_client_leases(SimpleLock *lock);
static void encode_lease(bufferlist& bl, const session_info_t& info, const LeaseStat& ls);
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();
- bool local_wrlock_start(LocalLockC *lock, MDRequestRef& mut);
+ bool local_wrlock_start(LocalLockC *lock, const MDRequestRef& mut);
void local_wrlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut);
- bool local_xlock_start(LocalLockC *lock, MDRequestRef& mut);
+ bool local_xlock_start(LocalLockC *lock, const MDRequestRef& mut);
void local_xlock_finish(const MutationImpl::lock_iterator& it, MutationImpl *mut);
void handle_file_lock(ScatterLock *lock, const cref_t<MLock> &m);
return su;
}
-void MDCache::finish_rollback(metareqid_t reqid, MDRequestRef& mdr) {
+void MDCache::finish_rollback(metareqid_t reqid, const MDRequestRef& mdr) {
auto p = resolve_need_rollback.find(reqid);
ceph_assert(p != resolve_need_rollback.end());
if (mds->is_resolve()) {
}
}
-int MDCache::path_traverse(MDRequestRef& mdr, MDSContextFactory& cf,
+int MDCache::path_traverse(const MDRequestRef& mdr, MDSContextFactory& cf,
const filepath& path, int flags,
vector<CDentry*> *pdnvec, CInode **pin)
{
return 0;
}
-int MDCache::maybe_request_forward_to_auth(MDRequestRef& mdr, MDSContextFactory& cf,
+int MDCache::maybe_request_forward_to_auth(const MDRequestRef& mdr, MDSContextFactory& cf,
MDSCacheObject *p)
{
if (p->is_ambiguous_auth()) {
* will return inode for primary, or link up/open up remote link's inode as necessary.
* If it's not available right now, puts mdr on wait list and returns null.
*/
-CInode *MDCache::get_dentry_inode(CDentry *dn, MDRequestRef& mdr, bool projected)
+CInode *MDCache::get_dentry_inode(CDentry *dn, const MDRequestRef& mdr, bool projected)
{
CDentry::linkage_t *dnl;
if (projected)
return p->second;
}
-void MDCache::request_finish(MDRequestRef& mdr)
+void MDCache::request_finish(const MDRequestRef& mdr)
{
dout(7) << "request_finish " << *mdr << dendl;
mdr->mark_event("finishing request");
}
-void MDCache::request_forward(MDRequestRef& mdr, mds_rank_t who, int port)
+void MDCache::request_forward(const MDRequestRef& mdr, mds_rank_t who, int port)
{
CachedStackStringStream css;
*css << "forwarding request to mds." << who;
}
-void MDCache::dispatch_request(MDRequestRef& mdr)
+void MDCache::dispatch_request(const MDRequestRef& mdr)
{
if (mdr->client_request) {
mds->server->dispatch_client_request(mdr);
}
-void MDCache::request_drop_foreign_locks(MDRequestRef& mdr)
+void MDCache::request_drop_foreign_locks(const MDRequestRef& mdr)
{
if (!mdr->has_more())
return;
* this function can get called more than once */
}
-void MDCache::request_drop_non_rdlocks(MDRequestRef& mdr)
+void MDCache::request_drop_non_rdlocks(const MDRequestRef& mdr)
{
request_drop_foreign_locks(mdr);
mds->locker->drop_non_rdlocks(mdr.get());
}
-void MDCache::request_drop_locks(MDRequestRef& mdr)
+void MDCache::request_drop_locks(const MDRequestRef& mdr)
{
request_drop_foreign_locks(mdr);
mds->locker->drop_locks(mdr.get());
}
-void MDCache::request_cleanup(MDRequestRef& mdr)
+void MDCache::request_cleanup(const MDRequestRef& mdr)
{
dout(15) << "request_cleanup " << *mdr << dendl;
mdr->mark_event("cleaned up request");
}
-void MDCache::request_kill(MDRequestRef& mdr)
+void MDCache::request_kill(const MDRequestRef& mdr)
{
// rollback peer requests is tricky. just let the request proceed.
if (mdr->has_more() &&
DECODE_FINISH(p);
}
-void MDCache::send_dentry_link(CDentry *dn, MDRequestRef& mdr)
+void MDCache::send_dentry_link(CDentry *dn, const MDRequestRef& mdr)
{
dout(7) << __func__ << " " << *dn << dendl;
// UNLINK
-void MDCache::send_dentry_unlink(CDentry *dn, CDentry *straydn, MDRequestRef& mdr)
+void MDCache::send_dentry_unlink(CDentry *dn, CDentry *straydn, const MDRequestRef& mdr)
{
dout(10) << __func__ << " " << *dn << dendl;
// share unlink news with replicas
MDCache *mdcache;
MDRequestRef mdr;
public:
- C_MDC_FragmentFrozen(MDCache *m, MDRequestRef& r) :
+ C_MDC_FragmentFrozen(MDCache *m, const MDRequestRef& r) :
MDSInternalContext(m->mds), mdcache(m), mdr(r) {}
void finish(int r) override {
mdcache->fragment_frozen(mdr, r);
class C_MDC_FragmentMarking : public MDCacheContext {
MDRequestRef mdr;
public:
- C_MDC_FragmentMarking(MDCache *m, MDRequestRef& r) : MDCacheContext(m), mdr(r) {}
+ C_MDC_FragmentMarking(MDCache *m, const MDRequestRef& r) : MDCacheContext(m), mdr(r) {}
void finish(int r) override {
mdcache->fragment_mark_and_complete(mdr);
}
};
-void MDCache::fragment_mark_and_complete(MDRequestRef& mdr)
+void MDCache::fragment_mark_and_complete(const MDRequestRef& mdr)
{
dirfrag_t basedirfrag = mdr->more()->fragment_base;
map<dirfrag_t,fragment_info_t>::iterator it = fragments.find(basedirfrag);
class C_MDC_FragmentPrep : public MDCacheLogContext {
MDRequestRef mdr;
public:
- C_MDC_FragmentPrep(MDCache *m, MDRequestRef& r) : MDCacheLogContext(m), mdr(r) {}
+ C_MDC_FragmentPrep(MDCache *m, const MDRequestRef& r) : MDCacheLogContext(m), mdr(r) {}
void finish(int r) override {
mdcache->_fragment_logged(mdr);
}
class C_MDC_FragmentStore : public MDCacheContext {
MDRequestRef mdr;
public:
- C_MDC_FragmentStore(MDCache *m, MDRequestRef& r) : MDCacheContext(m), mdr(r) {}
+ C_MDC_FragmentStore(MDCache *m, const MDRequestRef& r) : MDCacheContext(m), mdr(r) {}
void finish(int r) override {
mdcache->_fragment_stored(mdr);
}
}
};
-void MDCache::fragment_frozen(MDRequestRef& mdr, int r)
+void MDCache::fragment_frozen(const MDRequestRef& mdr, int r)
{
dirfrag_t basedirfrag = mdr->more()->fragment_base;
map<dirfrag_t,fragment_info_t>::iterator it = fragments.find(basedirfrag);
dispatch_fragment_dir(mdr);
}
-void MDCache::dispatch_fragment_dir(MDRequestRef& mdr)
+void MDCache::dispatch_fragment_dir(const MDRequestRef& mdr)
{
dirfrag_t basedirfrag = mdr->more()->fragment_base;
map<dirfrag_t,fragment_info_t>::iterator it = fragments.find(basedirfrag);
mds->mdlog->flush();
}
-void MDCache::_fragment_logged(MDRequestRef& mdr)
+void MDCache::_fragment_logged(const MDRequestRef& mdr)
{
dirfrag_t basedirfrag = mdr->more()->fragment_base;
auto& info = fragments.at(basedirfrag);
gather.activate();
}
-void MDCache::_fragment_stored(MDRequestRef& mdr)
+void MDCache::_fragment_stored(const MDRequestRef& mdr)
{
dirfrag_t basedirfrag = mdr->more()->fragment_base;
fragment_info_t &info = fragments.at(basedirfrag);
enqueue_scrub_work(mdr);
}
-void MDCache::enqueue_scrub_work(MDRequestRef& mdr)
+void MDCache::enqueue_scrub_work(const MDRequestRef& mdr)
{
CInode *in;
CF_MDS_RetryRequestFactory cf(this, mdr, true);
struct C_MDC_RespondInternalRequest : public MDCacheLogContext {
MDRequestRef mdr;
- C_MDC_RespondInternalRequest(MDCache *c, MDRequestRef& m) :
+ C_MDC_RespondInternalRequest(MDCache *c, const MDRequestRef& m) :
MDCacheLogContext(c), mdr(m) {}
void finish(int r) override {
mdr->apply();
repair_dirfrag_stats_work(mdr);
}
-void MDCache::repair_dirfrag_stats_work(MDRequestRef& mdr)
+void MDCache::repair_dirfrag_stats_work(const MDRequestRef& mdr)
{
CDir *dir = static_cast<CDir*>(mdr->internal_op_private);
dout(10) << __func__ << " " << *dir << dendl;
repair_inode_stats_work(mdr);
}
-void MDCache::repair_inode_stats_work(MDRequestRef& mdr)
+void MDCache::repair_inode_stats_work(const MDRequestRef& mdr)
{
CInode *diri = static_cast<CInode*>(mdr->internal_op_private);
dout(10) << __func__ << " " << *diri << dendl;
return rdlock_dirfrags_stats_work(mdr);
}
-void MDCache::rdlock_dirfrags_stats_work(MDRequestRef& mdr)
+void MDCache::rdlock_dirfrags_stats_work(const MDRequestRef& mdr)
{
CInode *diri = static_cast<CInode*>(mdr->internal_op_private);
dout(10) << __func__ << " " << *diri << dendl;
MDRequestRef mdr;
MDSRank *get_mds() override { return mds; }
public:
- C_FinishIOMDR(MDSRank *mds_, MDRequestRef& mdr_) : mds(mds_), mdr(mdr_) {}
+ C_FinishIOMDR(MDSRank *mds_, const MDRequestRef& mdr_) : mds(mds_), mdr(mdr_) {}
void finish(int r) override { mds->server->respond_to_request(mdr, r); }
};
-void MDCache::flush_dentry_work(MDRequestRef& mdr)
+void MDCache::flush_dentry_work(const MDRequestRef& mdr)
{
MutationImpl::LockOpVec lov;
CInode *in = mds->server->rdlock_path_pin_ref(mdr, true);
return active_requests.count(rid);
}
MDRequestRef request_get(metareqid_t rid);
- void request_pin_ref(MDRequestRef& r, CInode *ref, std::vector<CDentry*>& trace);
- void request_finish(MDRequestRef& mdr);
- void request_forward(MDRequestRef& mdr, mds_rank_t mds, int port=0);
- void dispatch_request(MDRequestRef& mdr);
- void request_drop_foreign_locks(MDRequestRef& mdr);
- void request_drop_non_rdlocks(MDRequestRef& r);
- void request_drop_locks(MDRequestRef& r);
- void request_cleanup(MDRequestRef& r);
+ void request_pin_ref(const MDRequestRef& r, CInode *ref, std::vector<CDentry*>& trace);
+ void request_finish(const MDRequestRef& mdr);
+ void request_forward(const MDRequestRef& mdr, mds_rank_t mds, int port=0);
+ void dispatch_request(const MDRequestRef& mdr);
+ void request_drop_foreign_locks(const MDRequestRef& mdr);
+ void request_drop_non_rdlocks(const MDRequestRef& r);
+ void request_drop_locks(const MDRequestRef& r);
+ void request_cleanup(const MDRequestRef& r);
- void request_kill(MDRequestRef& r); // called when session closes
+ void request_kill(const MDRequestRef& r); // called when session closes
// journal/snap helpers
CInode *pick_inode_snap(CInode *in, snapid_t follows);
void add_rollback(metareqid_t reqid, mds_rank_t leader) {
resolve_need_rollback[reqid] = leader;
}
- void finish_rollback(metareqid_t reqid, MDRequestRef& mdr);
+ void finish_rollback(metareqid_t reqid, const MDRequestRef& mdr);
// ambiguous imports
void add_ambiguous_import(dirfrag_t base, const std::vector<dirfrag_t>& bounds);
* If it returns 2 the request has been forwarded, and again the requester
* should unwind itself and back out.
*/
- int path_traverse(MDRequestRef& mdr, MDSContextFactory& cf,
+ int path_traverse(const MDRequestRef& mdr, MDSContextFactory& cf,
const filepath& path, int flags,
std::vector<CDentry*> *pdnvec, CInode **pin=nullptr);
- int maybe_request_forward_to_auth(MDRequestRef& mdr, MDSContextFactory& cf,
+ int maybe_request_forward_to_auth(const MDRequestRef& mdr, MDSContextFactory& cf,
MDSCacheObject *p);
CInode *cache_traverse(const filepath& path);
void open_remote_dirfrag(CInode *diri, frag_t fg, MDSContext *fin);
- CInode *get_dentry_inode(CDentry *dn, MDRequestRef& mdr, bool projected=false);
+ CInode *get_dentry_inode(CDentry *dn, const MDRequestRef& mdr, bool projected=false);
bool parallel_fetch(std::map<inodeno_t,filepath>& pathmap, std::set<inodeno_t>& missing);
bool parallel_fetch_traverse_dir(inodeno_t ino, filepath& path,
// -- namespace --
void encode_remote_dentry_link(CDentry::linkage_t *dnl, bufferlist& bl);
void decode_remote_dentry_link(CDir *dir, CDentry *dn, bufferlist::const_iterator& p);
- void send_dentry_link(CDentry *dn, MDRequestRef& mdr);
- void send_dentry_unlink(CDentry *dn, CDentry *straydn, MDRequestRef& mdr);
+ void send_dentry_link(CDentry *dn, const MDRequestRef& mdr);
+ void send_dentry_unlink(CDentry *dn, CDentry *straydn, const MDRequestRef& mdr);
void wait_for_uncommitted_fragment(dirfrag_t dirfrag, MDSContext *c) {
uncommitted_fragments.at(dirfrag).waiters.push_back(c);
int dump_cache(std::string_view fn, Formatter *f, double timeout);
- void flush_dentry_work(MDRequestRef& mdr);
+ void flush_dentry_work(const MDRequestRef& mdr);
/**
* Resolve path to a dentry and pass it onto the ScrubStack.
*
* this scrub (we won't block them on a whole scrub as it can take a very
* long time)
*/
- void enqueue_scrub_work(MDRequestRef& mdr);
- void repair_inode_stats_work(MDRequestRef& mdr);
- void repair_dirfrag_stats_work(MDRequestRef& mdr);
- void rdlock_dirfrags_stats_work(MDRequestRef& mdr);
+ void enqueue_scrub_work(const MDRequestRef& mdr);
+ void repair_inode_stats_work(const MDRequestRef& mdr);
+ void repair_dirfrag_stats_work(const MDRequestRef& mdr);
+ void rdlock_dirfrags_stats_work(const MDRequestRef& mdr);
ceph::unordered_map<inodeno_t,CInode*> inode_map; // map of head inodes by ino
std::map<vinodeno_t, CInode*> snap_inode_map; // map of snap inodes by ino
bool can_fragment(CInode *diri, const std::vector<CDir*>& dirs);
void fragment_freeze_dirs(const std::vector<CDir*>& dirs);
- void fragment_mark_and_complete(MDRequestRef& mdr);
- void fragment_frozen(MDRequestRef& mdr, int r);
+ void fragment_mark_and_complete(const MDRequestRef& mdr);
+ void fragment_frozen(const MDRequestRef& mdr, int r);
void fragment_unmark_unfreeze_dirs(const std::vector<CDir*>& dirs);
void fragment_drop_locks(fragment_info_t &info);
void fragment_maybe_finish(const fragment_info_iterator& it);
- void dispatch_fragment_dir(MDRequestRef& mdr);
- void _fragment_logged(MDRequestRef& mdr);
- void _fragment_stored(MDRequestRef& mdr);
+ void dispatch_fragment_dir(const MDRequestRef& mdr);
+ void _fragment_logged(const MDRequestRef& mdr);
+ void _fragment_stored(const MDRequestRef& mdr);
void _fragment_committed(dirfrag_t f, const MDRequestRef& mdr);
void _fragment_old_purged(dirfrag_t f, int bits, const MDRequestRef& mdr);
MDCache *cache;
MDRequestRef mdr;
public:
- C_MDS_RetryRequest(MDCache *c, MDRequestRef& r) :
+ C_MDS_RetryRequest(MDCache *c, const MDRequestRef& r) :
MDSInternalContext(c->mds), cache(c), mdr(r) {}
void finish(int r) override;
};
class CF_MDS_RetryRequestFactory : public MDSContextFactory {
public:
- CF_MDS_RetryRequestFactory(MDCache *cache, MDRequestRef &mdr, bool dl) :
+ CF_MDS_RetryRequestFactory(MDCache *cache, const MDRequestRef& mdr, bool dl) :
mdcache(cache), mdr(mdr), drop_locks(dl) {}
MDSContext *build() override;
private:
messenger->send_to_mds(ref_t<Message>(m).detach(), addr);
}
-void MDSRank::forward_message_mds(MDRequestRef& mdr, mds_rank_t mds)
+void MDSRank::forward_message_mds(const MDRequestRef& mdr, mds_rank_t mds)
{
ceph_assert(mds != whoami);
void send_message_mds(const ref_t<Message>& m, mds_rank_t mds);
void send_message_mds(const ref_t<Message>& m, const entity_addrvec_t &addr);
- void forward_message_mds(MDRequestRef& mdr, mds_rank_t mds);
+ void forward_message_mds(const MDRequestRef& mdr, 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 Migrator::dispatch_export_dir(MDRequestRef& mdr, int count)
+void Migrator::dispatch_export_dir(const MDRequestRef& mdr, int count)
{
CDir *dir = mdr->more()->export_dir;
dout(7) << *mdr << " " << *dir << dendl;
// -- import/export --
// exporter
- void dispatch_export_dir(MDRequestRef& mdr, int count);
+ void dispatch_export_dir(const MDRequestRef& mdr, int count);
void export_dir(CDir *dir, mds_rank_t dest);
void export_empty_import(CDir *dir);
explicit ServerLogContext(Server *s) : server(s) {
ceph_assert(server != NULL);
}
- explicit ServerLogContext(Server *s, MDRequestRef& r) : server(s), mdr(r) {
+ explicit ServerLogContext(Server *s, const MDRequestRef& r) : server(s), mdr(r) {
ceph_assert(server != NULL);
}
};
/*******
* some generic stuff for finishing off requests
*/
-void Server::journal_and_reply(MDRequestRef& mdr, CInode *in, CDentry *dn, LogEvent *le, MDSLogContextBase *fin)
+void Server::journal_and_reply(const MDRequestRef& mdr, CInode *in, CDentry *dn, LogEvent *le, MDSLogContextBase *fin)
{
dout(10) << "journal_and_reply tracei " << in << " tracedn " << dn << dendl;
ceph_assert(!mdr->has_completed);
mdlog->flush();
}
-void Server::submit_mdlog_entry(LogEvent *le, MDSLogContextBase *fin, MDRequestRef& mdr,
+void Server::submit_mdlog_entry(LogEvent *le, MDSLogContextBase *fin, const MDRequestRef& mdr,
std::string_view event)
{
if (mdr) {
/*
* send response built from mdr contents and error code; clean up mdr
*/
-void Server::respond_to_request(MDRequestRef& mdr, int r)
+void Server::respond_to_request(const MDRequestRef& mdr, int r)
{
if (mdr->client_request) {
if (mdr->is_batch_head()) {
logger->tinc(code, lat);
}
-void Server::early_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn)
+void Server::early_reply(const MDRequestRef& mdr, CInode *tracei, CDentry *tracedn)
{
if (!g_conf()->mds_early_reply)
return;
* include a trace to tracei
* Clean up mdr
*/
-void Server::reply_client_request(MDRequestRef& mdr, const ref_t<MClientReply> &reply)
+void Server::reply_client_request(const MDRequestRef& mdr, const ref_t<MClientReply> &reply)
{
ceph_assert(mdr.get());
const cref_t<MClientRequest> &req = mdr->client_request;
*/
void Server::set_trace_dist(const ref_t<MClientReply> &reply,
CInode *in, CDentry *dn,
- MDRequestRef& mdr)
+ const MDRequestRef& mdr)
{
// skip doing this for debugging purposes?
if (g_conf()->mds_inject_traceless_reply_probability &&
});
}
-void Server::dispatch_client_request(MDRequestRef& mdr)
+void Server::dispatch_client_request(const MDRequestRef& mdr)
{
// we shouldn't be waiting on anyone.
ceph_assert(!mdr->has_more() || mdr->more()->waiting_on_peer.empty());
mdr->batch_op_map->erase(it);
return;
}
- mdr = std::move(new_batch_head);
+ mds->finisher->queue(new C_MDS_RetryRequest(mdcache, new_batch_head));
+ return;
} else {
return;
}
}
}
-void Server::dispatch_peer_request(MDRequestRef& mdr)
+void Server::dispatch_peer_request(const MDRequestRef& mdr)
{
dout(7) << "dispatch_peer_request " << *mdr << " " << *mdr->peer_request << dendl;
}
}
-void Server::handle_peer_auth_pin(MDRequestRef& mdr)
+void Server::handle_peer_auth_pin(const MDRequestRef& mdr)
{
dout(10) << "handle_peer_auth_pin " << *mdr << dendl;
return;
}
-void Server::handle_peer_auth_pin_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
+void Server::handle_peer_auth_pin_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
{
dout(10) << "handle_peer_auth_pin_ack on " << *mdr << " " << *ack << dendl;
mds_rank_t from = mds_rank_t(ack->get_source().num());
* by mask on the given inode, based on the capability in the mdr's
* session.
*/
-bool Server::check_access(MDRequestRef& mdr, CInode *in, unsigned mask)
+bool Server::check_access(const MDRequestRef& mdr, CInode *in, unsigned mask)
{
if (mdr->session) {
int r = mdr->session->check_access(
* check whether fragment has reached maximum size
*
*/
-bool Server::check_fragment_space(MDRequestRef &mdr, CDir *dir)
+bool Server::check_fragment_space(const MDRequestRef& mdr, CDir *dir)
{
const auto size = dir->get_frag_size();
const auto max = bal_fragment_size_max;
* check whether entries in a dir reached maximum size
*
*/
-bool Server::check_dir_max_entries(MDRequestRef &mdr, CDir *in)
+bool Server::check_dir_max_entries(const MDRequestRef& mdr, CDir *in)
{
const uint64_t size = in->inode->get_projected_inode()->dirstat.nfiles +
in->inode->get_projected_inode()->dirstat.nsubdirs;
}
-CDentry* Server::prepare_stray_dentry(MDRequestRef& mdr, CInode *in)
+CDentry* Server::prepare_stray_dentry(const MDRequestRef& mdr, CInode *in)
{
string straydname;
in->name_stray_dentry(straydname);
*
* create a new inode. set c/m/atime. hit dir pop.
*/
-CInode* Server::prepare_new_inode(MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
+CInode* Server::prepare_new_inode(const MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
const file_layout_t *layout)
{
CInode *in = new CInode(mdcache);
return in;
}
-void Server::journal_allocated_inos(MDRequestRef& mdr, EMetaBlob *blob)
+void Server::journal_allocated_inos(const MDRequestRef& mdr, EMetaBlob *blob)
{
dout(20) << "journal_allocated_inos sessionmapv " << mds->sessionmap.get_projected()
<< " inotablev " << mds->inotable->get_projected_version()
mds->inotable->get_projected_version());
}
-void Server::apply_allocated_inos(MDRequestRef& mdr, Session *session)
+void Server::apply_allocated_inos(const MDRequestRef& mdr, Session *session)
{
dout(10) << "apply_allocated_inos " << mdr->alloc_ino
<< " / " << mdr->prealloc_inos
struct C_MDS_TryOpenInode : public ServerContext {
MDRequestRef mdr;
inodeno_t ino;
- C_MDS_TryOpenInode(Server *s, MDRequestRef& r, inodeno_t i) :
+ C_MDS_TryOpenInode(Server *s, const MDRequestRef& r, inodeno_t i) :
ServerContext(s), mdr(r), ino(i) {}
void finish(int r) override {
server->_try_open_ino(mdr, r, ino);
}
};
-void Server::_try_open_ino(MDRequestRef& mdr, int r, inodeno_t ino)
+void Server::_try_open_ino(const MDRequestRef& mdr, int r, inodeno_t ino)
{
dout(10) << "_try_open_ino " << mdr.get() << " ino " << ino << " r=" << r << dendl;
MDCache *mdcache;
inodeno_t ino;
public:
- C_MDS_TryFindInode(Server *s, MDRequestRef& r, MDCache *m, inodeno_t i) :
+ C_MDS_TryFindInode(Server *s, const MDRequestRef& r, MDCache *m, inodeno_t i) :
ServerContext(s), mdr(r), mdcache(m), ino(i) {}
void finish(int r) override {
if (r == -CEPHFS_ESTALE) { // :( find_ino_peers failed
/* If this returns null, the request has been handled
* as appropriate: forwarded on, or the client's been replied to */
-CInode* Server::rdlock_path_pin_ref(MDRequestRef& mdr,
+CInode* Server::rdlock_path_pin_ref(const MDRequestRef& mdr,
bool want_auth,
bool no_want_auth)
{
* to ensure tail dentry and target inode are both auth in one mds. the tail dentry
* will not be xlocked too if authexist and the target inode exists.
*/
-CDentry* Server::rdlock_path_xlock_dentry(MDRequestRef& mdr,
+CDentry* Server::rdlock_path_xlock_dentry(const MDRequestRef& mdr,
bool create, bool okexist, bool authexist,
bool want_layout)
{
* order.
*/
std::pair<CDentry*, CDentry*>
-Server::rdlock_two_paths_xlock_destdn(MDRequestRef& mdr, bool xlock_srcdn)
+Server::rdlock_two_paths_xlock_destdn(const MDRequestRef& mdr, bool xlock_srcdn)
{
const filepath& refpath = mdr->get_filepath();
* @param mdr request
* @returns the pointer, or NULL if it had to be delayed (but mdr is taken care of)
*/
-CDir* Server::try_open_auth_dirfrag(CInode *diri, frag_t fg, MDRequestRef& mdr)
+CDir* Server::try_open_auth_dirfrag(CInode *diri, frag_t fg, const MDRequestRef& mdr)
{
CDir *dir = diri->get_dirfrag(fg);
// ===============================================================================
// STAT
-void Server::handle_client_getattr(MDRequestRef& mdr, bool is_lookup)
+void Server::handle_client_getattr(const MDRequestRef& mdr, bool is_lookup)
{
const cref_t<MClientRequest> &req = mdr->client_request;
struct C_MDS_LookupIno2 : public ServerContext {
MDRequestRef mdr;
- C_MDS_LookupIno2(Server *s, MDRequestRef& r) : ServerContext(s), mdr(r) {}
+ C_MDS_LookupIno2(Server *s, const MDRequestRef& r) : ServerContext(s), mdr(r) {}
void finish(int r) override {
server->_lookup_ino_2(mdr, r);
}
/*
* filepath: ino
*/
-void Server::handle_client_lookup_ino(MDRequestRef& mdr,
+void Server::handle_client_lookup_ino(const MDRequestRef& mdr,
bool want_parent, bool want_dentry)
{
const cref_t<MClientRequest> &req = mdr->client_request;
}
}
-void Server::_lookup_snap_ino(MDRequestRef& mdr)
+void Server::_lookup_snap_ino(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
}
}
-void Server::_lookup_ino_2(MDRequestRef& mdr, int r)
+void Server::_lookup_ino_2(const MDRequestRef& mdr, int r)
{
inodeno_t ino = mdr->client_request->get_filepath().get_ino();
dout(10) << "_lookup_ino_2 " << mdr.get() << " ino " << ino << " r=" << r << dendl;
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_open(MDRequestRef& mdr)
+void Server::handle_client_open(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
dout(7) << "open on " << req->get_filepath() << dendl;
CDentry *dn;
CInode *newi;
public:
- C_MDS_openc_finish(Server *s, MDRequestRef& r, CDentry *d, CInode *ni) :
+ C_MDS_openc_finish(Server *s, const MDRequestRef& r, CDentry *d, CInode *ni) :
ServerLogContext(s, r), dn(d), newi(ni) {}
void finish(int r) override {
ceph_assert(r == 0);
};
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_openc(MDRequestRef& mdr)
+void Server::handle_client_openc(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
client_t client = mdr->get_client();
}
-void Server::_finalize_readdir(MDRequestRef& mdr,
+void Server::_finalize_readdir(const MDRequestRef& mdr,
CInode *diri,
CDir* dir,
bool start,
respond_to_request(mdr, 0);
}
-void Server::handle_client_readdir(MDRequestRef& mdr)
+void Server::handle_client_readdir(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
Session *session = mds->get_session(req);
CInode *in;
bool truncating_smaller, changed_ranges, adjust_realm;
public:
- C_MDS_inode_update_finish(Server *s, MDRequestRef& r, CInode *i,
+ C_MDS_inode_update_finish(Server *s, const MDRequestRef& r, CInode *i,
bool sm=false, bool cr=false, bool ar=false) :
ServerLogContext(s, r), in(i),
truncating_smaller(sm), changed_ranges(cr), adjust_realm(ar) { }
}
};
-void Server::handle_client_file_setlock(MDRequestRef& mdr)
+void Server::handle_client_file_setlock(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
dout(10) << " state after lock change: " << *lock_state << dendl;
}
-void Server::handle_client_file_readlock(MDRequestRef& mdr)
+void Server::handle_client_file_readlock(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
respond_to_request(mdr, 0);
}
-void Server::handle_client_setattr(MDRequestRef& mdr)
+void Server::handle_client_setattr(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
}
/* Takes responsibility for mdr */
-void Server::do_open_truncate(MDRequestRef& mdr, int cmode)
+void Server::do_open_truncate(const MDRequestRef& mdr, int cmode)
{
CInode *in = mdr->in[0];
client_t client = mdr->get_client();
/* This function cleans up the passed mdr */
-void Server::handle_client_setlayout(MDRequestRef& mdr)
+void Server::handle_client_setlayout(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
CInode *cur = rdlock_path_pin_ref(mdr, true);
journal_and_reply(mdr, cur, 0, le, new C_MDS_inode_update_finish(this, mdr, cur));
}
-bool Server::xlock_policylock(MDRequestRef& mdr, CInode *in, bool want_layout, bool xlock_snaplock)
+bool Server::xlock_policylock(const MDRequestRef& mdr, CInode *in, bool want_layout, bool xlock_snaplock)
{
if (mdr->locking_state & MutationImpl::ALL_LOCKED)
return true;
return true;
}
-CInode* Server::try_get_auth_inode(MDRequestRef& mdr, inodeno_t ino)
+CInode* Server::try_get_auth_inode(const MDRequestRef& mdr, inodeno_t ino)
{
CInode *in = mdcache->get_inode(ino);
if (!in || in->state_test(CInode::STATE_PURGING)) {
return in;
}
-void Server::handle_client_setdirlayout(MDRequestRef& mdr)
+void Server::handle_client_setdirlayout(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
* Return 0 on success, otherwise this function takes
* responsibility for the passed mdr.
*/
-int Server::check_layout_vxattr(MDRequestRef& mdr,
+int Server::check_layout_vxattr(const MDRequestRef& mdr,
string name,
string value,
file_layout_t *layout)
return 0;
}
-void Server::handle_set_vxattr(MDRequestRef& mdr, CInode *cur)
+void Server::handle_set_vxattr(const MDRequestRef& mdr, CInode *cur)
{
const cref_t<MClientRequest> &req = mdr->client_request;
MutationImpl::LockOpVec lov;
return;
}
-void Server::handle_remove_vxattr(MDRequestRef& mdr, CInode *cur)
+void Server::handle_remove_vxattr(const MDRequestRef& mdr, CInode *cur)
{
const cref_t<MClientRequest> &req = mdr->client_request;
string name(req->get_path2());
xattr_rm(xattrs, Server::MirrorXattrInfo::FS_ID);
}
-void Server::handle_client_setxattr(MDRequestRef& mdr)
+void Server::handle_client_setxattr(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
string name(req->get_path2());
journal_and_reply(mdr, cur, 0, le, new C_MDS_inode_update_finish(this, mdr, cur));
}
-void Server::handle_client_removexattr(MDRequestRef& mdr)
+void Server::handle_client_removexattr(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
std::string name(req->get_path2());
journal_and_reply(mdr, cur, 0, le, new C_MDS_inode_update_finish(this, mdr, cur));
}
-void Server::handle_client_getvxattr(MDRequestRef& mdr)
+void Server::handle_client_getvxattr(const MDRequestRef& mdr)
{
const auto& req = mdr->client_request;
string xattr_name{req->get_path2()};
CDentry *dn;
CInode *newi;
public:
- C_MDS_mknod_finish(Server *s, MDRequestRef& r, CDentry *d, CInode *ni) :
+ C_MDS_mknod_finish(Server *s, const MDRequestRef& r, CDentry *d, CInode *ni) :
ServerLogContext(s, r), dn(d), newi(ni) {}
void finish(int r) override {
ceph_assert(r == 0);
};
-void Server::handle_client_mknod(MDRequestRef& mdr)
+void Server::handle_client_mknod(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
client_t client = mdr->get_client();
// MKDIR
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_mkdir(MDRequestRef& mdr)
+void Server::handle_client_mkdir(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
// SYMLINK
-void Server::handle_client_symlink(MDRequestRef& mdr)
+void Server::handle_client_symlink(const MDRequestRef& mdr)
{
const auto& req = mdr->client_request;
// LINK
-void Server::handle_client_link(MDRequestRef& mdr)
+void Server::handle_client_link(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
version_t tipv;
bool adjust_realm;
public:
- C_MDS_link_local_finish(Server *s, MDRequestRef& r, CDentry *d, CInode *ti,
+ C_MDS_link_local_finish(Server *s, const MDRequestRef& r, CDentry *d, CInode *ti,
version_t dnpv_, version_t tipv_, bool ar) :
ServerLogContext(s, r), dn(d), targeti(ti),
dnpv(dnpv_), tipv(tipv_), adjust_realm(ar) { }
};
-void Server::_link_local(MDRequestRef& mdr, CDentry *dn, CInode *targeti, SnapRealm *target_realm)
+void Server::_link_local(const MDRequestRef& mdr, CDentry *dn, CInode *targeti, SnapRealm *target_realm)
{
dout(10) << "_link_local " << *dn << " to " << *targeti << dendl;
new C_MDS_link_local_finish(this, mdr, dn, targeti, dnpv, tipv, adjust_realm));
}
-void Server::_link_local_finish(MDRequestRef& mdr, CDentry *dn, CInode *targeti,
+void Server::_link_local_finish(const MDRequestRef& mdr, CDentry *dn, CInode *targeti,
version_t dnpv, version_t tipv, bool adjust_realm)
{
dout(10) << "_link_local_finish " << *dn << " to " << *targeti << dendl;
CInode *targeti;
version_t dpv;
public:
- C_MDS_link_remote_finish(Server *s, MDRequestRef& r, bool i, CDentry *d, CInode *ti) :
+ C_MDS_link_remote_finish(Server *s, const MDRequestRef& r, bool i, CDentry *d, CInode *ti) :
ServerLogContext(s, r), inc(i), dn(d), targeti(ti),
dpv(d->get_projected_version()) {}
void finish(int r) override {
}
};
-void Server::_link_remote(MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti)
+void Server::_link_remote(const MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti)
{
dout(10) << "_link_remote "
<< (inc ? "link ":"unlink ")
new C_MDS_link_remote_finish(this, mdr, inc, dn, targeti));
}
-void Server::_link_remote_finish(MDRequestRef& mdr, bool inc,
+void Server::_link_remote_finish(const MDRequestRef& mdr, bool inc,
CDentry *dn, CInode *targeti,
version_t dpv)
{
CInode *targeti;
bool adjust_realm;
public:
- C_MDS_PeerLinkPrep(Server *s, MDRequestRef& r, CInode *t, bool ar) :
+ C_MDS_PeerLinkPrep(Server *s, const MDRequestRef& r, CInode *t, bool ar) :
ServerLogContext(s, r), targeti(t), adjust_realm(ar) { }
void finish(int r) override {
ceph_assert(r == 0);
MDRequestRef mdr;
CInode *targeti;
public:
- C_MDS_PeerLinkCommit(Server *s, MDRequestRef& r, CInode *t) :
+ C_MDS_PeerLinkCommit(Server *s, const MDRequestRef& r, CInode *t) :
ServerContext(s), mdr(r), targeti(t) { }
void finish(int r) override {
server->_commit_peer_link(mdr, r, targeti);
}
};
-void Server::handle_peer_link_prep(MDRequestRef& mdr)
+void Server::handle_peer_link_prep(const MDRequestRef& mdr)
{
dout(10) << "handle_peer_link_prep " << *mdr
<< " on " << mdr->peer_request->get_object_info()
mdlog->flush();
}
-void Server::_logged_peer_link(MDRequestRef& mdr, CInode *targeti, bool adjust_realm)
+void Server::_logged_peer_link(const MDRequestRef& mdr, CInode *targeti, bool adjust_realm)
{
dout(10) << "_logged_peer_link " << *mdr
<< " " << *targeti << dendl;
struct C_MDS_CommittedPeer : public ServerLogContext {
- C_MDS_CommittedPeer(Server *s, MDRequestRef& m) : ServerLogContext(s, m) {}
+ C_MDS_CommittedPeer(Server *s, const MDRequestRef& m) : ServerLogContext(s, m) {}
void finish(int r) override {
server->_committed_peer(mdr);
}
};
-void Server::_commit_peer_link(MDRequestRef& mdr, int r, CInode *targeti)
+void Server::_commit_peer_link(const MDRequestRef& mdr, int r, CInode *targeti)
{
dout(10) << "_commit_peer_link " << *mdr
<< " r=" << r
}
}
-void Server::_committed_peer(MDRequestRef& mdr)
+void Server::_committed_peer(const MDRequestRef& mdr)
{
dout(10) << "_committed_peer " << *mdr << dendl;
struct C_MDS_LoggedLinkRollback : public ServerLogContext {
MutationRef mut;
map<client_t,ref_t<MClientSnap>> splits;
- C_MDS_LoggedLinkRollback(Server *s, MutationRef& m, MDRequestRef& r,
+ C_MDS_LoggedLinkRollback(Server *s, MutationRef& m, const MDRequestRef& r,
map<client_t,ref_t<MClientSnap>>&& _splits) :
ServerLogContext(s, r), mut(m), splits(std::move(_splits)) {
}
}
};
-void Server::do_link_rollback(bufferlist &rbl, mds_rank_t leader, MDRequestRef& mdr)
+void Server::do_link_rollback(bufferlist &rbl, mds_rank_t leader, const MDRequestRef& mdr)
{
link_rollback rollback;
auto p = rbl.cbegin();
mdlog->flush();
}
-void Server::_link_rollback_finish(MutationRef& mut, MDRequestRef& mdr,
+void Server::_link_rollback_finish(MutationRef& mut, const MDRequestRef& mdr,
map<client_t,ref_t<MClientSnap>>& splits)
{
dout(10) << "_link_rollback_finish" << dendl;
}
-void Server::handle_peer_link_prep_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m)
+void Server::handle_peer_link_prep_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m)
{
dout(10) << "handle_peer_link_prep_ack " << *mdr
<< " " << *m << dendl;
// UNLINK
-void Server::handle_client_unlink(MDRequestRef& mdr)
+void Server::handle_client_unlink(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
client_t client = mdr->get_client();
CDentry *straydn;
version_t dnpv; // deleted dentry
public:
- C_MDS_unlink_local_finish(Server *s, MDRequestRef& r, CDentry *d, CDentry *sd) :
+ C_MDS_unlink_local_finish(Server *s, const MDRequestRef& r, CDentry *d, CDentry *sd) :
ServerLogContext(s, r), dn(d), straydn(sd),
dnpv(d->get_projected_version()) {}
void finish(int r) override {
}
};
-void Server::_unlink_local(MDRequestRef& mdr, CDentry *dn, CDentry *straydn)
+void Server::_unlink_local(const MDRequestRef& mdr, CDentry *dn, CDentry *straydn)
{
dout(10) << "_unlink_local " << *dn << dendl;
journal_and_reply(mdr, 0, dn, le, new C_MDS_unlink_local_finish(this, mdr, dn, straydn));
}
-void Server::_unlink_local_finish(MDRequestRef& mdr,
+void Server::_unlink_local_finish(const MDRequestRef& mdr,
CDentry *dn, CDentry *straydn,
version_t dnpv)
{
}
}
-bool Server::_rmdir_prepare_witness(MDRequestRef& mdr, mds_rank_t who, vector<CDentry*>& trace, CDentry *straydn)
+bool Server::_rmdir_prepare_witness(const MDRequestRef& mdr, mds_rank_t who, vector<CDentry*>& trace, CDentry *straydn)
{
if (mds->is_cluster_degraded() &&
!mds->mdsmap->is_clientreplay_or_active_or_stopping(who)) {
struct C_MDS_PeerRmdirPrep : public ServerLogContext {
CDentry *dn, *straydn;
- C_MDS_PeerRmdirPrep(Server *s, MDRequestRef& r, CDentry *d, CDentry *st)
+ C_MDS_PeerRmdirPrep(Server *s, const MDRequestRef& r, CDentry *d, CDentry *st)
: ServerLogContext(s, r), dn(d), straydn(st) {}
void finish(int r) override {
server->_logged_peer_rmdir(mdr, dn, straydn);
struct C_MDS_PeerRmdirCommit : public ServerContext {
MDRequestRef mdr;
CDentry *straydn;
- C_MDS_PeerRmdirCommit(Server *s, MDRequestRef& r, CDentry *sd)
+ C_MDS_PeerRmdirCommit(Server *s, const MDRequestRef& r, CDentry *sd)
: ServerContext(s), mdr(r), straydn(sd) { }
void finish(int r) override {
server->_commit_peer_rmdir(mdr, r, straydn);
}
};
-void Server::handle_peer_rmdir_prep(MDRequestRef& mdr)
+void Server::handle_peer_rmdir_prep(const MDRequestRef& mdr)
{
dout(10) << "handle_peer_rmdir_prep " << *mdr
<< " " << mdr->peer_request->srcdnpath
mdlog->flush();
}
-void Server::_logged_peer_rmdir(MDRequestRef& mdr, CDentry *dn, CDentry *straydn)
+void Server::_logged_peer_rmdir(const MDRequestRef& mdr, CDentry *dn, CDentry *straydn)
{
dout(10) << "_logged_peer_rmdir " << *mdr << " on " << *dn << dendl;
CInode *in = dn->get_linkage()->get_inode();
}
}
-void Server::handle_peer_rmdir_prep_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
+void Server::handle_peer_rmdir_prep_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
{
dout(10) << "handle_peer_rmdir_prep_ack " << *mdr
<< " " << *ack << dendl;
dout(10) << "still waiting on peers " << mdr->more()->waiting_on_peer << dendl;
}
-void Server::_commit_peer_rmdir(MDRequestRef& mdr, int r, CDentry *straydn)
+void Server::_commit_peer_rmdir(const MDRequestRef& mdr, int r, CDentry *straydn)
{
dout(10) << "_commit_peer_rmdir " << *mdr << " r=" << r << dendl;
metareqid_t reqid;
CDentry *dn;
CDentry *straydn;
- C_MDS_LoggedRmdirRollback(Server *s, MDRequestRef& m, metareqid_t mr, CDentry *d, CDentry *st)
+ C_MDS_LoggedRmdirRollback(Server *s, const MDRequestRef& m, metareqid_t mr, CDentry *d, CDentry *st)
: ServerLogContext(s, m), reqid(mr), dn(d), straydn(st) {}
void finish(int r) override {
server->_rmdir_rollback_finish(mdr, reqid, dn, straydn);
}
};
-void Server::do_rmdir_rollback(bufferlist &rbl, mds_rank_t leader, MDRequestRef& mdr)
+void Server::do_rmdir_rollback(bufferlist &rbl, mds_rank_t leader, const MDRequestRef& mdr)
{
// unlink the other rollback methods, the rmdir rollback is only
// needed to record the subtree changes in the journal for inode
mdlog->flush();
}
-void Server::_rmdir_rollback_finish(MDRequestRef& mdr, metareqid_t reqid, CDentry *dn, CDentry *straydn)
+void Server::_rmdir_rollback_finish(const MDRequestRef& mdr, metareqid_t reqid, CDentry *dn, CDentry *straydn)
{
dout(10) << "_rmdir_rollback_finish " << reqid << dendl;
* the unlocked varient this is a fastpath check. we can't really be
* sure until we rdlock the filelock.
*/
-bool Server::_dir_is_nonempty_unlocked(MDRequestRef& mdr, CInode *in)
+bool Server::_dir_is_nonempty_unlocked(const MDRequestRef& mdr, CInode *in)
{
dout(10) << "dir_is_nonempty_unlocked " << *in << dendl;
ceph_assert(in->is_auth());
return false;
}
-bool Server::_dir_is_nonempty(MDRequestRef& mdr, CInode *in)
+bool Server::_dir_is_nonempty(const MDRequestRef& mdr, CInode *in)
{
dout(10) << "dir_is_nonempty " << *in << dendl;
ceph_assert(in->is_auth());
CDentry *destdn;
CDentry *straydn;
public:
- C_MDS_rename_finish(Server *s, MDRequestRef& r,
+ C_MDS_rename_finish(Server *s, const MDRequestRef& r,
CDentry *sdn, CDentry *ddn, CDentry *stdn) :
ServerLogContext(s, r),
srcdn(sdn), destdn(ddn), straydn(stdn) { }
*
* This function takes responsibility for the passed mdr.
*/
-void Server::handle_client_rename(MDRequestRef& mdr)
+void Server::handle_client_rename(const MDRequestRef& mdr)
{
const auto& req = mdr->client_request;
dout(7) << "handle_client_rename " << *req << dendl;
}
-void Server::_rename_finish(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn)
+void Server::_rename_finish(const MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn)
{
dout(10) << "_rename_finish " << *mdr << dendl;
// helpers
-bool Server::_rename_prepare_witness(MDRequestRef& mdr, mds_rank_t who, set<mds_rank_t> &witnesse,
+bool Server::_rename_prepare_witness(const MDRequestRef& mdr, mds_rank_t who, set<mds_rank_t> &witnesse,
vector<CDentry*>& srctrace, vector<CDentry*>& dsttrace, CDentry *straydn)
{
const auto& client_req = mdr->client_request;
return true;
}
-version_t Server::_rename_prepare_import(MDRequestRef& mdr, CDentry *srcdn, bufferlist *client_map_bl)
+version_t Server::_rename_prepare_import(const MDRequestRef& mdr, CDentry *srcdn, bufferlist *client_map_bl)
{
version_t oldpv = mdr->more()->inode_import_v;
return force_journal;
}
-void Server::_rename_prepare(MDRequestRef& mdr,
+void Server::_rename_prepare(const MDRequestRef& mdr,
EMetaBlob *metablob, bufferlist *client_map_bl,
CDentry *srcdn, CDentry *destdn, std::string_view alternate_name,
CDentry *straydn)
}
-void Server::_rename_apply(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn)
+void Server::_rename_apply(const MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn)
{
dout(10) << "_rename_apply " << *mdr << " " << *srcdn << " " << *destdn << dendl;
dout(10) << " pvs " << mdr->more()->pvmap << dendl;
class C_MDS_PeerRenamePrep : public ServerLogContext {
CDentry *srcdn, *destdn, *straydn;
public:
- C_MDS_PeerRenamePrep(Server *s, MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
+ C_MDS_PeerRenamePrep(Server *s, const MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
ServerLogContext(s, m), srcdn(sr), destdn(de), straydn(st) {}
void finish(int r) override {
server->_logged_peer_rename(mdr, srcdn, destdn, straydn);
MDRequestRef mdr;
CDentry *srcdn, *destdn, *straydn;
public:
- C_MDS_PeerRenameCommit(Server *s, MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
+ C_MDS_PeerRenameCommit(Server *s, const MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
ServerContext(s), mdr(m), srcdn(sr), destdn(de), straydn(st) {}
void finish(int r) override {
server->_commit_peer_rename(mdr, r, srcdn, destdn, straydn);
class C_MDS_PeerRenameSessionsFlushed : public ServerContext {
MDRequestRef mdr;
public:
- C_MDS_PeerRenameSessionsFlushed(Server *s, MDRequestRef& r) :
+ C_MDS_PeerRenameSessionsFlushed(Server *s, const MDRequestRef& r) :
ServerContext(s), mdr(r) {}
void finish(int r) override {
server->_peer_rename_sessions_flushed(mdr);
}
};
-void Server::handle_peer_rename_prep(MDRequestRef& mdr)
+void Server::handle_peer_rename_prep(const MDRequestRef& mdr)
{
dout(10) << "handle_peer_rename_prep " << *mdr
<< " " << mdr->peer_request->srcdnpath
}
}
-void Server::_logged_peer_rename(MDRequestRef& mdr,
+void Server::_logged_peer_rename(const MDRequestRef& mdr,
CDentry *srcdn, CDentry *destdn, CDentry *straydn)
{
dout(10) << "_logged_peer_rename " << *mdr << dendl;
}
}
-void Server::_commit_peer_rename(MDRequestRef& mdr, int r,
+void Server::_commit_peer_rename(const MDRequestRef& mdr, int r,
CDentry *srcdn, CDentry *destdn, CDentry *straydn)
{
dout(10) << "_commit_peer_rename " << *mdr << " r=" << r << dendl;
CDentry *straydn;
map<client_t,ref_t<MClientSnap>> splits[2];
bool finish_mdr;
- C_MDS_LoggedRenameRollback(Server *s, MutationRef& m, MDRequestRef& r,
+ C_MDS_LoggedRenameRollback(Server *s, MutationRef& m, const MDRequestRef& r,
CDentry *sd, version_t pv, CDentry *dd, CDentry *st,
map<client_t,ref_t<MClientSnap>> _splits[2], bool f) :
ServerLogContext(s, r), mut(m), srcdn(sd), srcdnpv(pv), destdn(dd),
}
};
-void Server::do_rename_rollback(bufferlist &rbl, mds_rank_t leader, MDRequestRef& mdr,
+void Server::do_rename_rollback(bufferlist &rbl, mds_rank_t leader, const MDRequestRef& mdr,
bool finish_mdr)
{
rename_rollback rollback;
}
}
-void Server::_rename_rollback_finish(MutationRef& mut, MDRequestRef& mdr, CDentry *srcdn,
+void Server::_rename_rollback_finish(MutationRef& mut, const MDRequestRef& mdr, CDentry *srcdn,
version_t srcdnpv, CDentry *destdn, CDentry *straydn,
map<client_t,ref_t<MClientSnap>> splits[2], bool finish_mdr)
{
mut->cleanup();
}
-void Server::handle_peer_rename_prep_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
+void Server::handle_peer_rename_prep_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
{
dout(10) << "handle_peer_rename_prep_ack " << *mdr
<< " witnessed by " << ack->get_source()
dout(10) << "still waiting on peers " << mdr->more()->waiting_on_peer << dendl;
}
-void Server::handle_peer_rename_notify_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
+void Server::handle_peer_rename_notify_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack)
{
dout(10) << "handle_peer_rename_notify_ack " << *mdr << " from mds."
<< ack->get_source() << dendl;
}
}
-void Server::_peer_rename_sessions_flushed(MDRequestRef& mdr)
+void Server::_peer_rename_sessions_flushed(const MDRequestRef& mdr)
{
dout(10) << "_peer_rename_sessions_flushed " << *mdr << dendl;
// snaps
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_lssnap(MDRequestRef& mdr)
+void Server::handle_client_lssnap(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
struct C_MDS_mksnap_finish : public ServerLogContext {
CInode *diri;
SnapInfo info;
- C_MDS_mksnap_finish(Server *s, MDRequestRef& r, CInode *di, SnapInfo &i) :
+ C_MDS_mksnap_finish(Server *s, const MDRequestRef& r, CInode *di, SnapInfo &i) :
ServerLogContext(s, r), diri(di), info(i) {}
void finish(int r) override {
server->_mksnap_finish(mdr, diri, info);
};
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_mksnap(MDRequestRef& mdr)
+void Server::handle_client_mksnap(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
// make sure we have as new a map as the client
mdlog->flush();
}
-void Server::_mksnap_finish(MDRequestRef& mdr, CInode *diri, SnapInfo &info)
+void Server::_mksnap_finish(const MDRequestRef& mdr, CInode *diri, SnapInfo &info)
{
dout(10) << "_mksnap_finish " << *mdr << " " << info << dendl;
struct C_MDS_rmsnap_finish : public ServerLogContext {
CInode *diri;
snapid_t snapid;
- C_MDS_rmsnap_finish(Server *s, MDRequestRef& r, CInode *di, snapid_t sn) :
+ C_MDS_rmsnap_finish(Server *s, const MDRequestRef& r, CInode *di, snapid_t sn) :
ServerLogContext(s, r), diri(di), snapid(sn) {}
void finish(int r) override {
server->_rmsnap_finish(mdr, diri, snapid);
};
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_rmsnap(MDRequestRef& mdr)
+void Server::handle_client_rmsnap(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
mdlog->flush();
}
-void Server::_rmsnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid)
+void Server::_rmsnap_finish(const MDRequestRef& mdr, CInode *diri, snapid_t snapid)
{
dout(10) << "_rmsnap_finish " << *mdr << " " << snapid << dendl;
snapid_t stid = mdr->more()->stid;
struct C_MDS_renamesnap_finish : public ServerLogContext {
CInode *diri;
snapid_t snapid;
- C_MDS_renamesnap_finish(Server *s, MDRequestRef& r, CInode *di, snapid_t sn) :
+ C_MDS_renamesnap_finish(Server *s, const MDRequestRef& r, CInode *di, snapid_t sn) :
ServerLogContext(s, r), diri(di), snapid(sn) {}
void finish(int r) override {
server->_renamesnap_finish(mdr, diri, snapid);
};
/* This function takes responsibility for the passed mdr*/
-void Server::handle_client_renamesnap(MDRequestRef& mdr)
+void Server::handle_client_renamesnap(const MDRequestRef& mdr)
{
const cref_t<MClientRequest> &req = mdr->client_request;
if (req->get_filepath().get_ino() != req->get_filepath2().get_ino()) {
mdlog->flush();
}
-void Server::_renamesnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid)
+void Server::_renamesnap_finish(const MDRequestRef& mdr, CInode *diri, snapid_t snapid)
{
dout(10) << "_renamesnap_finish " << *mdr << " " << snapid << dendl;
respond_to_request(mdr, 0);
}
-void Server::handle_client_readdir_snapdiff(MDRequestRef& mdr)
+void Server::handle_client_readdir_snapdiff(const MDRequestRef& mdr)
{
const cref_t<MClientRequest>& req = mdr->client_request;
Session* session = mds->get_session(req);
void Server::_readdir_diff(
utime_t now,
- MDRequestRef& mdr,
+ const MDRequestRef& mdr,
CInode* diri,
CDir* dir,
SnapRealm* realm,
}
bool Server::build_snap_diff(
- MDRequestRef& mdr,
+ const MDRequestRef& mdr,
CDir* dir,
int bytes_left,
dentry_key_t* skip_key,
void handle_client_request(const cref_t<MClientRequest> &m);
void handle_client_reply(const cref_t<MClientReply> &m);
- void journal_and_reply(MDRequestRef& mdr, CInode *tracei, CDentry *tracedn,
+ void journal_and_reply(const 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);
+ const MDRequestRef& mdr, std::string_view event);
+ void dispatch_client_request(const MDRequestRef& mdr);
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 early_reply(const MDRequestRef& mdr, CInode *tracei, CDentry *tracedn);
+ void respond_to_request(const MDRequestRef& mdr, int r = 0);
void set_trace_dist(const ref_t<MClientReply> &reply, CInode *in, CDentry *dn,
- MDRequestRef& mdr);
+ const MDRequestRef& mdr);
void handle_peer_request(const cref_t<MMDSPeerRequest> &m);
void handle_peer_request_reply(const cref_t<MMDSPeerRequest> &m);
- void dispatch_peer_request(MDRequestRef& mdr);
- void handle_peer_auth_pin(MDRequestRef& mdr);
- void handle_peer_auth_pin_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack);
+ void dispatch_peer_request(const MDRequestRef& mdr);
+ void handle_peer_auth_pin(const MDRequestRef& mdr);
+ void handle_peer_auth_pin_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack);
// some helpers
- bool check_fragment_space(MDRequestRef& mdr, CDir *in);
- bool check_dir_max_entries(MDRequestRef& mdr, CDir *in);
- bool check_access(MDRequestRef& mdr, CInode *in, unsigned mask);
+ bool check_fragment_space(const MDRequestRef& mdr, CDir *in);
+ bool check_dir_max_entries(const MDRequestRef& mdr, CDir *in);
+ bool check_access(const MDRequestRef& mdr, CInode *in, unsigned mask);
bool _check_access(Session *session, CInode *in, unsigned mask, int caller_uid, int caller_gid, int setattr_uid, int setattr_gid);
- CDentry *prepare_stray_dentry(MDRequestRef& mdr, CInode *in);
- CInode* prepare_new_inode(MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
+ CDentry *prepare_stray_dentry(const MDRequestRef& mdr, CInode *in);
+ CInode* prepare_new_inode(const MDRequestRef& mdr, CDir *dir, inodeno_t useino, unsigned mode,
const file_layout_t *layout=nullptr);
- void journal_allocated_inos(MDRequestRef& mdr, EMetaBlob *blob);
- void apply_allocated_inos(MDRequestRef& mdr, Session *session);
+ void journal_allocated_inos(const MDRequestRef& mdr, EMetaBlob *blob);
+ void apply_allocated_inos(const MDRequestRef& mdr, Session *session);
- void _try_open_ino(MDRequestRef& mdr, int r, inodeno_t ino);
- CInode* rdlock_path_pin_ref(MDRequestRef& mdr, bool want_auth,
+ void _try_open_ino(const MDRequestRef& mdr, int r, inodeno_t ino);
+ CInode* rdlock_path_pin_ref(const MDRequestRef& mdr, bool want_auth,
bool no_want_auth=false);
- CDentry* rdlock_path_xlock_dentry(MDRequestRef& mdr, bool create,
+ CDentry* rdlock_path_xlock_dentry(const MDRequestRef& mdr, bool create,
bool okexist=false, bool authexist=false,
bool want_layout=false);
std::pair<CDentry*, CDentry*>
- rdlock_two_paths_xlock_destdn(MDRequestRef& mdr, bool xlock_srcdn);
+ rdlock_two_paths_xlock_destdn(const MDRequestRef& mdr, bool xlock_srcdn);
- CDir* try_open_auth_dirfrag(CInode *diri, frag_t fg, MDRequestRef& mdr);
+ CDir* try_open_auth_dirfrag(CInode *diri, frag_t fg, const MDRequestRef& mdr);
// requests on existing inodes.
- void handle_client_getattr(MDRequestRef& mdr, bool is_lookup);
- void handle_client_lookup_ino(MDRequestRef& mdr,
+ void handle_client_getattr(const MDRequestRef& mdr, bool is_lookup);
+ void handle_client_lookup_ino(const MDRequestRef& mdr,
bool want_parent, bool want_dentry);
- void _lookup_snap_ino(MDRequestRef& mdr);
- void _lookup_ino_2(MDRequestRef& mdr, int r);
- void handle_client_readdir(MDRequestRef& mdr);
- void handle_client_file_setlock(MDRequestRef& mdr);
- void handle_client_file_readlock(MDRequestRef& mdr);
+ void _lookup_snap_ino(const MDRequestRef& mdr);
+ void _lookup_ino_2(const MDRequestRef& mdr, int r);
+ void handle_client_readdir(const MDRequestRef& mdr);
+ void handle_client_file_setlock(const MDRequestRef& mdr);
+ void handle_client_file_readlock(const MDRequestRef& mdr);
- bool xlock_policylock(MDRequestRef& mdr, CInode *in,
+ bool xlock_policylock(const MDRequestRef& mdr, CInode *in,
bool want_layout=false, bool xlock_snaplock=false);
- CInode* try_get_auth_inode(MDRequestRef& mdr, inodeno_t ino);
- void handle_client_setattr(MDRequestRef& mdr);
- void handle_client_setlayout(MDRequestRef& mdr);
- void handle_client_setdirlayout(MDRequestRef& mdr);
+ CInode* try_get_auth_inode(const MDRequestRef& mdr, inodeno_t ino);
+ void handle_client_setattr(const MDRequestRef& mdr);
+ void handle_client_setlayout(const MDRequestRef& mdr);
+ void handle_client_setdirlayout(const MDRequestRef& mdr);
int parse_quota_vxattr(std::string name, std::string value, quota_info_t *quota);
void create_quota_realm(CInode *in);
file_layout_t *layout);
int parse_layout_vxattr(std::string name, std::string value, const OSDMap& osdmap,
file_layout_t *layout, bool validate=true);
- int check_layout_vxattr(MDRequestRef& mdr,
+ int check_layout_vxattr(const MDRequestRef& mdr,
std::string name,
std::string value,
file_layout_t *layout);
- void handle_set_vxattr(MDRequestRef& mdr, CInode *cur);
- void handle_remove_vxattr(MDRequestRef& mdr, CInode *cur);
- void handle_client_getvxattr(MDRequestRef& mdr);
- void handle_client_setxattr(MDRequestRef& mdr);
- void handle_client_removexattr(MDRequestRef& mdr);
+ void handle_set_vxattr(const MDRequestRef& mdr, CInode *cur);
+ void handle_remove_vxattr(const MDRequestRef& mdr, CInode *cur);
+ void handle_client_getvxattr(const MDRequestRef& mdr);
+ void handle_client_setxattr(const MDRequestRef& mdr);
+ void handle_client_removexattr(const MDRequestRef& mdr);
- void handle_client_fsync(MDRequestRef& mdr);
+ void handle_client_fsync(const MDRequestRef& mdr);
// open
- void handle_client_open(MDRequestRef& mdr);
- void handle_client_openc(MDRequestRef& mdr); // O_CREAT variant.
- void do_open_truncate(MDRequestRef& mdr, int cmode); // O_TRUNC variant.
+ void handle_client_open(const MDRequestRef& mdr);
+ void handle_client_openc(const MDRequestRef& mdr); // O_CREAT variant.
+ void do_open_truncate(const MDRequestRef& mdr, int cmode); // O_TRUNC variant.
// namespace changes
- void handle_client_mknod(MDRequestRef& mdr);
- void handle_client_mkdir(MDRequestRef& mdr);
- void handle_client_symlink(MDRequestRef& mdr);
+ void handle_client_mknod(const MDRequestRef& mdr);
+ void handle_client_mkdir(const MDRequestRef& mdr);
+ void handle_client_symlink(const MDRequestRef& mdr);
// link
- void handle_client_link(MDRequestRef& mdr);
- void _link_local(MDRequestRef& mdr, CDentry *dn, CInode *targeti, SnapRealm *target_realm);
- void _link_local_finish(MDRequestRef& mdr, CDentry *dn, CInode *targeti,
+ void handle_client_link(const MDRequestRef& mdr);
+ void _link_local(const MDRequestRef& mdr, CDentry *dn, CInode *targeti, SnapRealm *target_realm);
+ void _link_local_finish(const MDRequestRef& mdr, CDentry *dn, CInode *targeti,
version_t, version_t, bool);
- void _link_remote(MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti);
- void _link_remote_finish(MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti,
+ void _link_remote(const MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti);
+ void _link_remote_finish(const MDRequestRef& mdr, bool inc, CDentry *dn, CInode *targeti,
version_t);
- void handle_peer_link_prep(MDRequestRef& mdr);
- void _logged_peer_link(MDRequestRef& mdr, CInode *targeti, bool adjust_realm);
- void _commit_peer_link(MDRequestRef& mdr, int r, CInode *targeti);
- void _committed_peer(MDRequestRef& mdr); // use for rename, too
- void handle_peer_link_prep_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m);
- void do_link_rollback(bufferlist &rbl, mds_rank_t leader, MDRequestRef& mdr);
- void _link_rollback_finish(MutationRef& mut, MDRequestRef& mdr,
+ void handle_peer_link_prep(const MDRequestRef& mdr);
+ void _logged_peer_link(const MDRequestRef& mdr, CInode *targeti, bool adjust_realm);
+ void _commit_peer_link(const MDRequestRef& mdr, int r, CInode *targeti);
+ void _committed_peer(const MDRequestRef& mdr); // use for rename, too
+ void handle_peer_link_prep_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m);
+ void do_link_rollback(bufferlist &rbl, mds_rank_t leader, const MDRequestRef& mdr);
+ void _link_rollback_finish(MutationRef& mut, const MDRequestRef& mdr,
std::map<client_t,ref_t<MClientSnap>>& split);
// unlink
- void handle_client_unlink(MDRequestRef& mdr);
- bool _dir_is_nonempty_unlocked(MDRequestRef& mdr, CInode *rmdiri);
- bool _dir_is_nonempty(MDRequestRef& mdr, CInode *rmdiri);
- void _unlink_local(MDRequestRef& mdr, CDentry *dn, CDentry *straydn);
- void _unlink_local_finish(MDRequestRef& mdr,
+ void handle_client_unlink(const MDRequestRef& mdr);
+ bool _dir_is_nonempty_unlocked(const MDRequestRef& mdr, CInode *rmdiri);
+ bool _dir_is_nonempty(const MDRequestRef& mdr, CInode *rmdiri);
+ void _unlink_local(const MDRequestRef& mdr, CDentry *dn, CDentry *straydn);
+ void _unlink_local_finish(const MDRequestRef& mdr,
CDentry *dn, CDentry *straydn,
version_t);
- bool _rmdir_prepare_witness(MDRequestRef& mdr, mds_rank_t who, std::vector<CDentry*>& trace, CDentry *straydn);
- void handle_peer_rmdir_prep(MDRequestRef& mdr);
- void _logged_peer_rmdir(MDRequestRef& mdr, CDentry *srcdn, CDentry *straydn);
- void _commit_peer_rmdir(MDRequestRef& mdr, int r, CDentry *straydn);
- void handle_peer_rmdir_prep_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack);
- void do_rmdir_rollback(bufferlist &rbl, mds_rank_t leader, MDRequestRef& mdr);
- void _rmdir_rollback_finish(MDRequestRef& mdr, metareqid_t reqid, CDentry *dn, CDentry *straydn);
+ bool _rmdir_prepare_witness(const MDRequestRef& mdr, mds_rank_t who, std::vector<CDentry*>& trace, CDentry *straydn);
+ void handle_peer_rmdir_prep(const MDRequestRef& mdr);
+ void _logged_peer_rmdir(const MDRequestRef& mdr, CDentry *srcdn, CDentry *straydn);
+ void _commit_peer_rmdir(const MDRequestRef& mdr, int r, CDentry *straydn);
+ void handle_peer_rmdir_prep_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &ack);
+ void do_rmdir_rollback(bufferlist &rbl, mds_rank_t leader, const MDRequestRef& mdr);
+ void _rmdir_rollback_finish(const MDRequestRef& mdr, metareqid_t reqid, CDentry *dn, CDentry *straydn);
// rename
- void handle_client_rename(MDRequestRef& mdr);
- void _rename_finish(MDRequestRef& mdr,
+ void handle_client_rename(const MDRequestRef& mdr);
+ void _rename_finish(const MDRequestRef& mdr,
CDentry *srcdn, CDentry *destdn, CDentry *straydn);
- void handle_client_lssnap(MDRequestRef& mdr);
- void handle_client_mksnap(MDRequestRef& mdr);
- void _mksnap_finish(MDRequestRef& mdr, CInode *diri, SnapInfo &info);
- void handle_client_rmsnap(MDRequestRef& mdr);
- void _rmsnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid);
- void handle_client_renamesnap(MDRequestRef& mdr);
- void _renamesnap_finish(MDRequestRef& mdr, CInode *diri, snapid_t snapid);
- void handle_client_readdir_snapdiff(MDRequestRef& mdr);
+ void handle_client_lssnap(const MDRequestRef& mdr);
+ void handle_client_mksnap(const MDRequestRef& mdr);
+ void _mksnap_finish(const MDRequestRef& mdr, CInode *diri, SnapInfo &info);
+ void handle_client_rmsnap(const MDRequestRef& mdr);
+ void _rmsnap_finish(const MDRequestRef& mdr, CInode *diri, snapid_t snapid);
+ void handle_client_renamesnap(const MDRequestRef& mdr);
+ void _renamesnap_finish(const MDRequestRef& mdr, CInode *diri, snapid_t snapid);
+ void handle_client_readdir_snapdiff(const MDRequestRef& mdr);
// helpers
- bool _rename_prepare_witness(MDRequestRef& mdr, mds_rank_t who, std::set<mds_rank_t> &witnesse,
+ bool _rename_prepare_witness(const MDRequestRef& mdr, mds_rank_t who, std::set<mds_rank_t> &witnesse,
std::vector<CDentry*>& srctrace, std::vector<CDentry*>& dsttrace, CDentry *straydn);
- version_t _rename_prepare_import(MDRequestRef& mdr, CDentry *srcdn, bufferlist *client_map_bl);
+ version_t _rename_prepare_import(const MDRequestRef& mdr, CDentry *srcdn, bufferlist *client_map_bl);
bool _need_force_journal(CInode *diri, bool empty);
- void _rename_prepare(MDRequestRef& mdr,
+ void _rename_prepare(const MDRequestRef& mdr,
EMetaBlob *metablob, bufferlist *client_map_bl,
CDentry *srcdn, CDentry *destdn, std::string_view alternate_name,
CDentry *straydn);
/* set not_journaling=true if you're going to discard the results --
* this bypasses the asserts to make sure we're journaling the right
* things on the right nodes */
- void _rename_apply(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
+ void _rename_apply(const MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
// slaving
- void handle_peer_rename_prep(MDRequestRef& mdr);
- void handle_peer_rename_prep_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m);
- void handle_peer_rename_notify_ack(MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m);
- void _peer_rename_sessions_flushed(MDRequestRef& mdr);
- void _logged_peer_rename(MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
- void _commit_peer_rename(MDRequestRef& mdr, int r, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
- void do_rename_rollback(bufferlist &rbl, mds_rank_t leader, MDRequestRef& mdr, bool finish_mdr=false);
- void _rename_rollback_finish(MutationRef& mut, MDRequestRef& mdr, CDentry *srcdn, version_t srcdnpv,
+ void handle_peer_rename_prep(const MDRequestRef& mdr);
+ void handle_peer_rename_prep_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m);
+ void handle_peer_rename_notify_ack(const MDRequestRef& mdr, const cref_t<MMDSPeerRequest> &m);
+ void _peer_rename_sessions_flushed(const MDRequestRef& mdr);
+ void _logged_peer_rename(const MDRequestRef& mdr, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
+ void _commit_peer_rename(const MDRequestRef& mdr, int r, CDentry *srcdn, CDentry *destdn, CDentry *straydn);
+ void do_rename_rollback(bufferlist &rbl, mds_rank_t leader, const MDRequestRef& mdr, bool finish_mdr=false);
+ void _rename_rollback_finish(MutationRef& mut, const MDRequestRef& mdr, CDentry *srcdn, version_t srcdnpv,
CDentry *destdn, CDentry *staydn, std::map<client_t,ref_t<MClientSnap>> splits[2],
bool finish_mdr);
xattr_name == "ceph.mirror.dirty_snap_id";
}
- void reply_client_request(MDRequestRef& mdr, const ref_t<MClientReply> &reply);
+ void reply_client_request(const MDRequestRef& mdr, const ref_t<MClientReply> &reply);
void flush_session(Session *session, MDSGatherBuilder& gather);
- void _finalize_readdir(MDRequestRef& mdr,
+ void _finalize_readdir(const MDRequestRef& mdr,
CInode *diri,
CDir* dir,
bool start,
bufferlist& dnbl);
void _readdir_diff(
utime_t now,
- MDRequestRef& mdr,
+ const MDRequestRef& mdr,
CInode* diri,
CDir* dir,
SnapRealm* realm,
unsigned req_flags,
bufferlist& dirbl);
bool build_snap_diff(
- MDRequestRef& mdr,
+ const MDRequestRef& mdr,
CDir* dir,
int bytes_left,
dentry_key_t* skip_key,
projects / ceph-ci.git / commitdiff