class Beacon::C_MDS_BeaconSender : public Context {
public:
explicit C_MDS_BeaconSender(Beacon *beacon_) : beacon(beacon_) {}
- void finish(int r) {
+ void finish(int r) override {
assert(beacon->lock.is_locked_by_me());
beacon->sender = NULL;
beacon->_send();
{
protected:
CDir *dir;
- MDSRank* get_mds() {return dir->cache->mds;}
+ MDSRank* get_mds() override {return dir->cache->mds;}
public:
explicit CDirContext(CDir *d) : dir(d) {
{
protected:
CDir *dir;
- MDSRank* get_mds() {return dir->cache->mds;}
+ MDSRank* get_mds() override {return dir->cache->mds;}
public:
explicit CDirIOContext(CDir *d) : dir(d) {
C_IO_Dir_OMAP_Fetched(CDir *d, MDSInternalContextBase *f) :
CDirIOContext(d), fin(f), ret1(0), ret2(0), ret3(0) { }
- void finish(int r) {
+ void finish(int r) override {
// check the correctness of backtrace
if (r >= 0 && ret3 != -ECANCELED)
dir->inode->verify_diri_backtrace(btbl, ret3);
version_t version;
public:
C_IO_Dir_Committed(CDir *d, version_t v) : CDirIOContext(d), version(v) { }
- void finish(int r) {
+ void finish(int r) override {
dir->_committed(r, version);
}
};
class C_Dir_AuthUnpin : public CDirContext {
public:
explicit C_Dir_AuthUnpin(CDir *d) : CDirContext(d) {}
- void finish(int r) {
+ void finish(int r) override {
dir->auth_unpin(dir->get_inode());
}
};
{
protected:
CInode *in;
- MDSRank *get_mds() {return in->mdcache->mds;}
+ MDSRank *get_mds() override {return in->mdcache->mds;}
public:
explicit CInodeIOContext(CInode *in_) : in(in_) {
assert(in != NULL);
version_t version;
Context *fin;
C_IO_Inode_Stored(CInode *i, version_t v, Context *f) : CInodeIOContext(i), version(v), fin(f) {}
- void finish(int r) {
+ void finish(int r) override {
in->_stored(r, version, fin);
}
};
bufferlist bl, bl2;
Context *fin;
C_IO_Inode_Fetched(CInode *i, Context *f) : CInodeIOContext(i), fin(f) {}
- void finish(int r) {
+ void finish(int r) override {
// Ignore 'r', because we fetch from two places, so r is usually ENOENT
in->_fetched(bl, bl2, fin);
}
version_t version;
Context *fin;
C_IO_Inode_StoredBacktrace(CInode *i, version_t v, Context *f) : CInodeIOContext(i), version(v), fin(f) {}
- void finish(int r) {
+ void finish(int r) override {
in->_stored_backtrace(r, version, fin);
}
};
CInode *in;
CDir *dir;
MutationRef mut;
- MDSRank *get_mds() {return in->mdcache->mds;}
- void finish(int r) {
+ MDSRank *get_mds() override {return in->mdcache->mds;}
+ void finish(int r) override {
in->_finish_frag_update(dir, mut);
}
return true;
}
- void _done() {
+ void _done() override {
if ((!results->raw_stats.checked || results->raw_stats.passed) &&
(!results->backtrace.checked || results->backtrace.passed) &&
(!results->inode.checked || results->inode.passed))
: ino(ino_), frag(frag_)
{}
- virtual damage_entry_type_t get_type() const
+ damage_entry_type_t get_type() const override
{
return DAMAGE_ENTRY_DIRFRAG;
}
- void dump(Formatter *f) const
+ void dump(Formatter *f) const override
{
f->open_object_section("dir_frag_damage");
f->dump_string("damage_type", "dir_frag");
: ino(ino_), frag(frag_), dname(dname_), snap_id(snap_id_)
{}
- virtual damage_entry_type_t get_type() const
+ damage_entry_type_t get_type() const override
{
return DAMAGE_ENTRY_DENTRY;
}
- void dump(Formatter *f) const
+ void dump(Formatter *f) const override
{
f->open_object_section("dentry_damage");
f->dump_string("damage_type", "dentry");
: ino(ino_)
{}
- virtual damage_entry_type_t get_type() const
+ damage_entry_type_t get_type() const override
{
return DAMAGE_ENTRY_BACKTRACE;
}
- void dump(Formatter *f) const
+ void dump(Formatter *f) const override
{
f->open_object_section("backtrace_damage");
f->dump_string("damage_type", "backtrace");
class LockerContext : public MDSInternalContextBase {
protected:
Locker *locker;
- MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return locker->mds;
}
class LockerLogContext : public MDSLogContextBase {
protected:
Locker *locker;
- MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return locker->mds;
}
assert(locker->mds->mds_lock.is_locked_by_me());
p->get(MDSCacheObject::PIN_PTRWAITER);
}
- void finish(int r) {
+ void finish(int r) override {
p->put(MDSCacheObject::PIN_PTRWAITER);
locker->try_eval(p, mask);
}
ack(ac) {
in->get(CInode::PIN_PTRWAITER);
}
- void finish(int r) {
+ void finish(int r) override {
locker->file_update_finish(in, mut, share, client, cap, ack);
}
};
C_MDL_RequestInodeFileCaps(Locker *l, CInode *i) : LockerContext(l), in(i) {
in->get(CInode::PIN_PTRWAITER);
}
- void finish(int r) {
+ void finish(int r) override {
in->put(CInode::PIN_PTRWAITER);
if (!in->is_auth())
locker->request_inode_file_caps(in);
{
in->get(CInode::PIN_PTRWAITER);
}
- void finish(int r) {
+ void finish(int r) override {
in->put(CInode::PIN_PTRWAITER);
if (in->is_auth())
locker->check_inode_max_size(in, false, new_max_size, newsize, mtime);
public:
C_Locker_RetryRequestCapRelease(Locker *l, client_t c, const ceph_mds_request_release& it) :
LockerContext(l), client(c), item(it) { }
- void finish(int r) {
+ void finish(int r) override {
string dname;
MDRequestRef null_ref;
locker->process_request_cap_release(null_ref, client, item, dname);
LockerContext(l), in(i), client(c), seq(s) {
in->get(CInode::PIN_PTRWAITER);
}
- void finish(int r) {
+ void finish(int r) override {
locker->kick_issue_caps(in, client, seq);
in->put(CInode::PIN_PTRWAITER);
}
C_Locker_RetryCapRelease(Locker *l, client_t c, inodeno_t i, uint64_t id,
ceph_seq_t mseq, ceph_seq_t seq) :
LockerContext(l), client(c), ino(i), cap_id(id), migrate_seq(mseq), issue_seq(seq) {}
- void finish(int r) {
+ void finish(int r) override {
locker->_do_cap_release(client, ino, cap_id, migrate_seq, issue_seq);
}
};
public:
C_Locker_ScatterWB(Locker *l, ScatterLock *sl, MutationRef& m) :
LockerLogContext(l), lock(sl), mut(m) {}
- void finish(int r) {
+ void finish(int r) override {
locker->scatter_writebehind_finish(lock, mut);
}
};
class C_Bal_SendHeartbeat : public MDSInternalContext {
public:
explicit C_Bal_SendHeartbeat(MDSRank *mds_) : MDSInternalContext(mds_) { }
- virtual void finish(int f) {
+ void finish(int f) override {
mds->balancer->send_heartbeat();
}
};
class MDCacheContext : public virtual MDSInternalContextBase {
protected:
MDCache *mdcache;
- virtual MDSRank *get_mds()
+ MDSRank *get_mds() override
{
assert(mdcache != NULL);
return mdcache->mds;
class MDCacheIOContext : public virtual MDSIOContextBase {
protected:
MDCache *mdcache;
- virtual MDSRank *get_mds()
+ MDSRank *get_mds() override
{
assert(mdcache != NULL);
return mdcache->mds;
class MDCacheLogContext : public virtual MDSLogContextBase {
protected:
MDCache *mdcache;
- virtual MDSRank *get_mds()
+ MDSRank *get_mds() override
{
assert(mdcache != NULL);
return mdcache->mds;
MDSInternalContextBase *fin;
C_MDC_CreateSystemFile(MDCache *c, MutationRef& mu, CDentry *d, version_t v, MDSInternalContextBase *f) :
MDCacheLogContext(c), mut(mu), dn(d), dpv(v), fin(f) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_create_system_file_finish(mut, dn, dpv, fin);
}
};
struct C_MDS_RetryOpenRoot : public MDSInternalContext {
MDCache *cache;
explicit C_MDS_RetryOpenRoot(MDCache *c) : MDSInternalContext(c->mds), cache(c) {}
- void finish(int r) {
+ void finish(int r) override {
if (r < 0) {
// If we can't open root, something disastrous has happened: mark
// this rank damaged for operator intervention. Note that
MutationRef mut;
public:
C_MDC_SubtreeMergeWB(MDCache *mdc, CInode *i, MutationRef& m) : MDCacheLogContext(mdc), in(i), mut(m) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->subtree_merge_writebehind_finish(in, mut);
}
};
struct C_MDC_CommittedMaster : public MDCacheLogContext {
metareqid_t reqid;
C_MDC_CommittedMaster(MDCache *s, metareqid_t r) : MDCacheLogContext(s), reqid(r) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_logged_master_commit(reqid);
}
};
mds_rank_t from;
metareqid_t reqid;
C_MDC_SlaveCommit(MDCache *c, int f, metareqid_t r) : MDCacheLogContext(c), from(f), reqid(r) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_logged_slave_commit(from, reqid);
}
};
class C_MDC_RejoinGatherFinish : public MDCacheContext {
public:
explicit C_MDC_RejoinGatherFinish(MDCache *c) : MDCacheContext(c) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->rejoin_gather_finish();
}
};
inodeno_t ino;
public:
C_MDC_RejoinOpenInoFinish(MDCache *c, inodeno_t i) : MDCacheContext(c), ino(i) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->rejoin_open_ino_finish(ino, r);
}
};
C_MDC_RejoinSessionsOpened(MDCache *c, map<client_t,entity_inst_t>& cm) :
MDCacheLogContext(c), client_map(cm) {}
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
mdcache->rejoin_open_sessions_finish(client_map, sseqmap);
}
struct C_MDC_OpenSnapParents : public MDCacheContext {
explicit C_MDC_OpenSnapParents(MDCache *c) : MDCacheContext(c) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->open_snap_parents();
}
};
MutationRef mut;
C_MDC_QueuedCow(MDCache *mdc, CInode *i, MutationRef& m) :
MDCacheContext(mdc), in(i), mut(m) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_queued_file_recover_cow(in, mut);
}
};
public:
C_MDC_RetryTruncate(MDCache *c, CInode *i, LogSegment *l) :
MDCacheContext(c), in(i), ls(l) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_truncate_inode(in, ls);
}
};
LogSegment *ls;
C_IO_MDC_TruncateFinish(MDCache *c, CInode *i, LogSegment *l) :
MDCacheIOContext(c), in(i), ls(l) {}
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0 || r == -ENOENT);
mdcache->truncate_inode_finish(in, ls);
}
MutationRef mut;
C_MDC_TruncateLogged(MDCache *m, CInode *i, MutationRef& mu) :
MDCacheLogContext(m), in(i), mut(mu) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->truncate_inode_logged(in, mut);
}
};
class C_MDC_ShutdownCheck : public MDCacheContext {
public:
explicit C_MDC_ShutdownCheck(MDCache *m) : MDCacheContext(m) {}
- void finish(int) {
+ void finish(int) override {
mdcache->shutdown_check();
}
};
bool want_xlocked;
C_MDC_OpenRemoteDentry(MDCache *m, CDentry *d, inodeno_t i, MDSInternalContextBase *f, bool wx) :
MDCacheContext(m), dn(d), ino(i), onfinish(f), want_xlocked(wx) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_open_remote_dentry_finish(dn, ino, onfinish, want_xlocked, r);
}
};
bufferlist bl;
C_IO_MDC_OpenInoBacktraceFetched(MDCache *c, inodeno_t i) :
MDCacheIOContext(c), ino(i) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_open_ino_backtrace_fetched(ino, bl, r);
}
};
public:
C_MDC_OpenInoTraverseDir(MDCache *c, inodeno_t i, MMDSOpenIno *m, bool p) :
MDCacheContext(c), ino(i), msg(m), parent(p) {}
- void finish(int r) {
+ void finish(int r) override {
if (r < 0 && !parent)
r = -EAGAIN;
if (msg) {
inodeno_t ino;
public:
C_MDC_OpenInoParentOpened(MDCache *c, inodeno_t i) : MDCacheContext(c), ino(i) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_open_ino_parent_opened(ino, r);
}
};
C_MDC_snaprealm_create_finish(MDCache *c, MDRequestRef& m,
MutationRef& mu, CInode *i) :
MDCacheLogContext(c), mdr(m), mut(mu), in(i) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->_snaprealm_create_finish(mdr, mut, in);
}
};
struct C_MDC_RetryScanStray : public MDCacheContext {
dirfrag_t next;
C_MDC_RetryScanStray(MDCache *c, dirfrag_t n) : MDCacheContext(c), next(n) { }
- void finish(int r) {
+ void finish(int r) override {
mdcache->scan_stray_dir(next);
}
};
mds_rank_t from;
C_MDC_RetryDiscoverPath(MDCache *c, CInode *b, snapid_t s, filepath &p, mds_rank_t f) :
MDCacheContext(c), base(b), snapid(s), path(p), from(f) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->discover_path(base, snapid, path, 0, from);
}
};
filepath path;
C_MDC_RetryDiscoverPath2(MDCache *c, CDir *b, snapid_t s, filepath &p) :
MDCacheContext(c), base(b), snapid(s), path(p) {}
- void finish(int r) {
+ void finish(int r) override {
mdcache->discover_path(base, snapid, path, 0);
}
};
public:
C_MDC_FragmentFrozen(MDCache *m, MDRequestRef& r) :
MDSInternalContext(m->mds), mdcache(m), mdr(r) {}
- virtual void finish(int r) {
+ void finish(int r) override {
mdcache->fragment_frozen(mdr, r);
}
};
MDRequestRef mdr;
public:
C_MDC_FragmentMarking(MDCache *m, MDRequestRef& r) : MDCacheContext(m), mdr(r) {}
- virtual void finish(int r) {
+ void finish(int r) override {
mdcache->fragment_mark_and_complete(mdr);
}
};
MDRequestRef mdr;
public:
C_MDC_FragmentPrep(MDCache *m, MDRequestRef& r) : MDCacheLogContext(m), mdr(r) {}
- virtual void finish(int r) {
+ void finish(int r) override {
mdcache->_fragment_logged(mdr);
}
};
MDRequestRef mdr;
public:
C_MDC_FragmentStore(MDCache *m, MDRequestRef& r) : MDCacheContext(m), mdr(r) {}
- virtual void finish(int r) {
+ void finish(int r) override {
mdcache->_fragment_stored(mdr);
}
};
public:
C_MDC_FragmentCommit(MDCache *m, dirfrag_t df, list<CDir*>& l) :
MDCacheLogContext(m), basedirfrag(df), resultfrags(l) {}
- virtual void finish(int r) {
+ void finish(int r) override {
mdcache->_fragment_committed(basedirfrag, resultfrags);
}
};
MDCacheIOContext(m), basedirfrag(f) {
resultfrags.swap(l);
}
- virtual void finish(int r) {
+ void finish(int r) override {
assert(r == 0 || r == -ENOENT);
mdcache->_fragment_finish(basedirfrag, resultfrags);
}
return fin;
}
- void finish(int r) {
+ void finish(int r) override {
if (r < 0) { // we failed the lookup or something; dump ourselves
formatter->open_object_section("results");
formatter->dump_int("return_code", r);
MDRequestRef mdr;
C_MDC_RepairDirfragStats(MDCache *c, MDRequestRef& m) :
MDCacheLogContext(c), mdr(m) {}
- void finish(int r) {
+ void finish(int r) override {
mdr->apply();
get_mds()->server->respond_to_request(mdr, r);
}
protected:
MDSRank *mds;
MDRequestRef mdr;
- MDSRank *get_mds() { return mds; }
+ MDSRank *get_mds() override { return mds; }
public:
C_FinishIOMDR(MDSRank *mds_, MDRequestRef& mdr_) : mds(mds_), mdr(mdr_) {}
- void finish(int r) { mds->server->respond_to_request(mdr, r); }
+ void finish(int r) override { mds->server->respond_to_request(mdr, r); }
};
void MDCache::flush_dentry_work(MDRequestRef& mdr)
class C_MDL_WriteError : public MDSIOContextBase {
protected:
MDLog *mdlog;
- MDSRank *get_mds() {return mdlog->mds;}
+ MDSRank *get_mds() override {return mdlog->mds;}
- void finish(int r) {
+ void finish(int r) override {
MDSRank *mds = get_mds();
// assume journal is reliable, so don't choose action based on
// g_conf->mds_action_on_write_error.
MDSInternalContextBase *on_complete;
public:
C_ReopenComplete(MDLog *mdlog_, MDSInternalContextBase *on_complete_) : MDSInternalContext(mdlog_->mds), mdlog(mdlog_), on_complete(on_complete_) {}
- void finish(int r) {
+ void finish(int r) override {
mdlog->append();
on_complete->complete(r);
}
class C_MDL_Flushed : public MDSLogContextBase {
protected:
MDLog *mdlog;
- MDSRank *get_mds() {return mdlog->mds;}
+ MDSRank *get_mds() override {return mdlog->mds;}
MDSInternalContextBase *wrapped;
- void finish(int r) {
+ void finish(int r) override {
if (wrapped)
wrapped->complete(r);
}
public:
C_MaybeExpiredSegment(MDLog *mdl, LogSegment *s, int p) :
MDSInternalContext(mdl->mds), mdlog(mdl), ls(s), op_prio(p) {}
- void finish(int res) {
+ void finish(int res) override {
if (res < 0)
mdlog->mds->handle_write_error(res);
mdlog->_maybe_expired(ls, op_prio);
assert(fn_);
}
- void finish(int r)
+ void finish(int r) override
{
(mds->*fn)();
}
MDSDaemon *mds_daemon;
public:
explicit C_MDS_Tick(MDSDaemon *m) : mds_daemon(m) {}
- void finish(int r) {
+ void finish(int r) override {
assert(mds_daemon->mds_lock.is_locked_by_me());
mds_daemon->tick_event = 0;
public:
explicit MDSSocketHook(MDSDaemon *m) : mds(m) {}
bool call(std::string command, cmdmap_t& cmdmap, std::string format,
- bufferlist& out) {
+ bufferlist& out) override {
stringstream ss;
bool r = mds->asok_command(command, cmdmap, format, ss);
out.append(ss);
public:
explicit SuicideLater(MDSDaemon *mds_) : mds(mds_) {}
- void finish(int r) {
+ void finish(int r) override {
// Wait a little to improve chances of caller getting
// our response before seeing us disappear from mdsmap
sleep(1);
public:
explicit RespawnLater(MDSDaemon *mds_) : mds(mds_) {}
- void finish(int r) {
+ void finish(int r) override {
// Wait a little to improve chances of caller getting
// our response before seeing us disappear from mdsmap
sleep(1);
assert(fn_);
}
- void finish(int r)
+ void finish(int r) override
{
(mds->*fn)();
}
public:
C_MDS_BootStart(MDSRank *m, MDSRank::BootStep n)
: MDSInternalContext(m), nextstep(n) {}
- void finish(int r) {
+ void finish(int r) override {
mds->boot_start(nextstep, r);
}
};
public:
C_MDS_StandbyReplayRestartFinish(MDSRank *mds_, uint64_t old_read_pos_) :
MDSIOContext(mds_), old_read_pos(old_read_pos_) {}
- void finish(int r) {
+ void finish(int r) override {
mds->_standby_replay_restart_finish(r, old_read_pos);
}
};
class MDSRank::C_MDS_StandbyReplayRestart : public MDSInternalContext {
public:
explicit C_MDS_StandbyReplayRestart(MDSRank *m) : MDSInternalContext(m) {}
- void finish(int r) {
+ void finish(int r) override {
assert(!r);
mds->standby_replay_restart();
}
MDSDaemon::send_command_reply(m, mds, r, bl, out_str);
m->put();
}
- void finish (int r) {
+ void finish (int r) override {
send(r, "");
}
};
{
protected:
MDSTable *ida;
- MDSRank *get_mds() {return ida->mds;}
+ MDSRank *get_mds() override {return ida->mds;}
public:
explicit MDSTableIOContext(MDSTable *ida_) : ida(ida_) {
assert(ida != NULL);
version_t version;
public:
C_IO_MT_Save(MDSTable *i, version_t v) : MDSTableIOContext(i), version(v) {}
- void finish(int r) {
+ void finish(int r) override {
ida->save_2(r, version);
}
};
Context *onfinish;
bufferlist bl;
C_IO_MT_Load(MDSTable *i, Context *o) : MDSTableIOContext(i), onfinish(o) {}
- void finish(int r) {
+ void finish(int r) override {
ida->load_2(r, bl, onfinish);
}
};
class C_LoggedAck : public MDSLogContextBase {
MDSTableClient *tc;
version_t tid;
- MDSRank *get_mds() { return tc->mds; }
+ MDSRank *get_mds() override { return tc->mds; }
public:
C_LoggedAck(MDSTableClient *a, version_t t) : tc(a), tid(t) {}
- void finish(int r) {
+ void finish(int r) override {
tc->_logged_ack(tid);
}
};
MDSTableServer *server;
MMDSTableRequest *req;
version_t tid;
- MDSRank *get_mds() { return server->mds; }
+ MDSRank *get_mds() override { return server->mds; }
public:
C_Prepare(MDSTableServer *s, MMDSTableRequest *r, version_t v) : server(s), req(r), tid(v) {}
- void finish(int r) {
+ void finish(int r) override {
server->_prepare_logged(req, tid);
}
};
class C_Commit : public MDSLogContextBase {
MDSTableServer *server;
MMDSTableRequest *req;
- MDSRank *get_mds() { return server->mds; }
+ MDSRank *get_mds() override { return server->mds; }
public:
C_Commit(MDSTableServer *s, MMDSTableRequest *r) : server(s), req(r) {}
- void finish(int r) {
+ void finish(int r) override {
server->_commit_logged(req);
}
};
class MigratorContext : public MDSInternalContextBase {
protected:
Migrator *mig;
- MDSRank *get_mds() {
+ MDSRank *get_mds() override {
return mig->mds;
}
public:
class MigratorLogContext : public MDSLogContextBase {
protected:
Migrator *mig;
- MDSRank *get_mds() {
+ MDSRank *get_mds() override {
return mig->mds;
}
public:
CDir *dir;
public:
C_MDC_EmptyImport(Migrator *m, CDir *d) : MigratorContext(m), dir(d) {}
- void finish(int r) {
+ void finish(int r) override {
mig->export_empty_import(dir);
}
};
MigratorContext(m), ex(e), tid(t) {
assert(ex != NULL);
}
- virtual void finish(int r) {
+ void finish(int r) override {
if (r >= 0)
mig->export_frozen(ex, tid);
}
: MigratorContext(m), dir(d), tid(t) {
assert(dir != NULL);
}
- void finish(int r) {
+ void finish(int r) override {
mig->export_sessions_flushed(dir, tid);
}
};
MigratorContext(m), dir(d), tid(t) {
assert(dir != NULL);
}
- void finish(int r) {
+ void finish(int r) override {
mig->export_go_synced(dir, tid);
}
};
CDir *dir;
public:
C_MDS_ExportFinishLogged(Migrator *m, CDir *d) : MigratorLogContext(m), dir(d) {}
- void finish(int r) {
+ void finish(int r) override {
mig->export_logged_finish(dir);
}
};
C_MDS_ImportDirLoggedStart(Migrator *m, CDir *d, mds_rank_t f) :
MigratorLogContext(m), df(d->dirfrag()), dir(d), from(f) {
}
- void finish(int r) {
+ void finish(int r) override {
mig->import_logged_start(df, dir, from, imported_client_map, sseqmap);
}
};
map<client_t,uint64_t> sseqmap;
C_M_LoggedImportCaps(Migrator *m, CInode *i, mds_rank_t f) : MigratorLogContext(m), in(i), from(f) {}
- void finish(int r) {
+ void finish(int r) override {
mig->logged_import_caps(in, from, peer_exports, client_map, sseqmap);
}
};
protected:
RecoveryQueue *rq;
CInode *in;
- void finish(int r) {
+ void finish(int r) override {
rq->_recovered(in, r, size, mtime);
}
- MDSRank *get_mds() {
+ MDSRank *get_mds() override {
return rq->mds;
}
: MDSInternalContext(mds), stack(stack_), target(target_)
{}
- void finish(int r)
+ void finish(int r) override
{
stack->_validate_inode_done(target, r, result);
}
class ServerContext : public MDSInternalContextBase {
protected:
Server *server;
- MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return server->mds;
}
class ServerLogContext : public MDSLogContextBase {
protected:
Server *server;
- MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return server->mds;
}
MDRequestRef mdr;
- void pre_finish(int r) {
+ void pre_finish(int r) override {
if (mdr)
mdr->mark_event("journal_committed: ");
}
ServerLogContext(srv), session(se), state_seq(sseq), open(s), cmapv(mv), inotablev(0), fin(fin_) { }
C_MDS_session_finish(Server *srv, Session *se, uint64_t sseq, bool s, version_t mv, interval_set<inodeno_t>& i, version_t iv, Context *fin_ = NULL) :
ServerLogContext(srv), session(se), state_seq(sseq), open(s), cmapv(mv), inos(i), inotablev(iv), fin(fin_) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
server->_session_logged(session, state_seq, open, cmapv, inos, inotablev);
if (fin) {
}
class C_MDS_TerminatedSessions : public ServerContext {
- void finish(int r) {
+ void finish(int r) override {
server->terminating_sessions = false;
}
public:
MDRequestRef mdr;
public:
C_MDS_TryFindInode(Server *s, MDRequestRef& r) : ServerContext(s), mdr(r) {}
- virtual void finish(int r) {
+ void finish(int r) override {
if (r == -ESTALE) // :( find_ino_peers failed
server->respond_to_request(mdr, r);
else
struct C_MDS_LookupIno2 : public ServerContext {
MDRequestRef mdr;
C_MDS_LookupIno2(Server *s, MDRequestRef& r) : ServerContext(s), mdr(r) {}
- void finish(int r) {
+ void finish(int r) override {
server->_lookup_ino_2(mdr, r);
}
};
public:
C_MDS_openc_finish(Server *s, MDRequestRef& r, CDentry *d, CInode *ni, snapid_t f) :
ServerLogContext(s, r), dn(d), newi(ni), follows(f) {}
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
dn->pop_projected_linkage();
C_MDS_inode_update_finish(Server *s, MDRequestRef& r, CInode *i,
bool sm=false, bool cr=false) :
ServerLogContext(s, r), in(i), truncating_smaller(sm), changed_ranges(cr) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
// apply
C_MDS_inode_xattr_update_finish(Server *s, MDRequestRef& r, CInode *i) :
ServerLogContext(s, r), in(i) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
// apply
public:
C_MDS_mknod_finish(Server *s, MDRequestRef& r, CDentry *d, CInode *ni) :
ServerLogContext(s, r), dn(d), newi(ni) {}
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
// link the inode
version_t dnpv_, version_t tipv_) :
ServerLogContext(s, r), dn(d), targeti(ti),
dnpv(dnpv_), tipv(tipv_) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
server->_link_local_finish(mdr, dn, targeti, dnpv, tipv);
}
C_MDS_link_remote_finish(Server *s, 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) {
+ void finish(int r) override {
assert(r == 0);
server->_link_remote_finish(mdr, inc, dn, targeti, dpv);
}
public:
C_MDS_SlaveLinkPrep(Server *s, MDRequestRef& r, CInode *t) :
ServerLogContext(s, r), targeti(t) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
server->_logged_slave_link(mdr, targeti);
}
public:
C_MDS_SlaveLinkCommit(Server *s, MDRequestRef& r, CInode *t) :
ServerContext(s), mdr(r), targeti(t) { }
- void finish(int r) {
+ void finish(int r) override {
server->_commit_slave_link(mdr, r, targeti);
}
};
struct C_MDS_CommittedSlave : public ServerLogContext {
C_MDS_CommittedSlave(Server *s, MDRequestRef& m) : ServerLogContext(s, m) {}
- void finish(int r) {
+ void finish(int r) override {
server->_committed_slave(mdr);
}
};
struct C_MDS_LoggedLinkRollback : public ServerLogContext {
MutationRef mut;
C_MDS_LoggedLinkRollback(Server *s, MutationRef& m, MDRequestRef& r) : ServerLogContext(s, r), mut(m) {}
- void finish(int r) {
+ void finish(int r) override {
server->_link_rollback_finish(mut, mdr);
}
};
C_MDS_unlink_local_finish(Server *s, MDRequestRef& r, CDentry *d, CDentry *sd) :
ServerLogContext(s, r), dn(d), straydn(sd),
dnpv(d->get_projected_version()) {}
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
server->_unlink_local_finish(mdr, dn, straydn, dnpv);
}
CDentry *dn, *straydn;
C_MDS_SlaveRmdirPrep(Server *s, MDRequestRef& r, CDentry *d, CDentry *st)
: ServerLogContext(s, r), dn(d), straydn(st) {}
- void finish(int r) {
+ void finish(int r) override {
server->_logged_slave_rmdir(mdr, dn, straydn);
}
};
MDRequestRef mdr;
C_MDS_SlaveRmdirCommit(Server *s, MDRequestRef& r)
: ServerContext(s), mdr(r) { }
- void finish(int r) {
+ void finish(int r) override {
server->_commit_slave_rmdir(mdr, r);
}
};
CDentry *straydn;
C_MDS_LoggedRmdirRollback(Server *s, MDRequestRef& m, metareqid_t mr, CDentry *d, CDentry *st)
: ServerLogContext(s, m), reqid(mr), dn(d), straydn(st) {}
- void finish(int r) {
+ void finish(int r) override {
server->_rmdir_rollback_finish(mdr, reqid, dn, straydn);
}
};
CDentry *sdn, CDentry *ddn, CDentry *stdn) :
ServerLogContext(s, r),
srcdn(sdn), destdn(ddn), straydn(stdn) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
server->_rename_finish(mdr, srcdn, destdn, straydn);
}
public:
C_MDS_SlaveRenamePrep(Server *s, MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
ServerLogContext(s, m), srcdn(sr), destdn(de), straydn(st) {}
- void finish(int r) {
+ void finish(int r) override {
server->_logged_slave_rename(mdr, srcdn, destdn, straydn);
}
};
public:
C_MDS_SlaveRenameCommit(Server *s, MDRequestRef& m, CDentry *sr, CDentry *de, CDentry *st) :
ServerContext(s), mdr(m), srcdn(sr), destdn(de), straydn(st) {}
- void finish(int r) {
+ void finish(int r) override {
server->_commit_slave_rename(mdr, r, srcdn, destdn, straydn);
}
};
public:
C_MDS_SlaveRenameSessionsFlushed(Server *s, MDRequestRef& r) :
ServerContext(s), mdr(r) {}
- void finish(int r) {
+ void finish(int r) override {
server->_slave_rename_sessions_flushed(mdr);
}
};
CDentry *st, bool f) :
ServerLogContext(s, r), mut(m), srcdn(sd), srcdnpv(pv), destdn(dd),
straydn(st), finish_mdr(f) {}
- void finish(int r) {
+ void finish(int r) override {
server->_rename_rollback_finish(mut, mdr, srcdn, srcdnpv,
destdn, straydn, finish_mdr);
}
SnapInfo info;
C_MDS_mksnap_finish(Server *s, MDRequestRef& r, CInode *di, SnapInfo &i) :
ServerLogContext(s, r), diri(di), info(i) {}
- void finish(int r) {
+ void finish(int r) override {
server->_mksnap_finish(mdr, diri, info);
}
};
snapid_t snapid;
C_MDS_rmsnap_finish(Server *s, MDRequestRef& r, CInode *di, snapid_t sn) :
ServerLogContext(s, r), diri(di), snapid(sn) {}
- void finish(int r) {
+ void finish(int r) override {
server->_rmsnap_finish(mdr, diri, snapid);
}
};
snapid_t snapid;
C_MDS_renamesnap_finish(Server *s, MDRequestRef& r, CInode *di, snapid_t sn) :
ServerLogContext(s, r), diri(di), snapid(sn) {}
- void finish(int r) {
+ void finish(int r) override {
server->_renamesnap_finish(mdr, diri, snapid);
}
};
{
protected:
SessionMap *sessionmap;
- MDSRank *get_mds() {return sessionmap->mds;}
+ MDSRank *get_mds() override {return sessionmap->mds;}
public:
explicit SessionMapIOContext(SessionMap *sessionmap_) : sessionmap(sessionmap_) {
assert(sessionmap != NULL);
C_IO_SM_Load(SessionMap *cm, const bool f)
: SessionMapIOContext(cm), first(f), header_r(0), values_r(0) {}
- void finish(int r) {
+ void finish(int r) override {
sessionmap->_load_finish(r, header_r, values_r, first, header_bl, session_vals);
}
};
public:
bufferlist bl;
explicit C_IO_SM_LoadLegacy(SessionMap *cm) : SessionMapIOContext(cm) {}
- void finish(int r) {
+ void finish(int r) override {
sessionmap->_load_legacy_finish(r, bl);
}
};
version_t version;
public:
C_IO_SM_Save(SessionMap *cm, version_t v) : SessionMapIOContext(cm), version(v) {}
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0);
sessionmap->_save_finish(version);
}
public:
C_IO_SM_Save_One(SessionMap *cm, MDSInternalContextBase *on_safe_)
: SessionMapIOContext(cm), on_safe(on_safe_) {}
- void finish(int r) {
+ void finish(int r) override {
if (r != 0) {
get_mds()->handle_write_error(r);
} else {
sr(s), first(f), last(l), parent_last(pl), parent(p), fin(c) {
sr->inode->get(CInode::PIN_OPENINGSNAPPARENTS);
}
- MDSRank *get_mds() { return sr->mdcache->mds; }
- void finish(int r) {
+ MDSRank *get_mds() override { return sr->mdcache->mds; }
+ void finish(int r) override {
if (r < 0)
sr->_remove_missing_parent(parent_last, parent, r);
if (sr->_open_parents(fin, first, last))
class StrayManagerIOContext : public virtual MDSIOContextBase {
protected:
StrayManager *sm;
- virtual MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return sm->mds;
}
class StrayManagerLogContext : public virtual MDSLogContextBase {
protected:
StrayManager *sm;
- virtual MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return sm->mds;
}
class StrayManagerContext : public virtual MDSInternalContextBase {
protected:
StrayManager *sm;
- virtual MDSRank *get_mds()
+ MDSRank *get_mds() override
{
return sm->mds;
}
public:
C_IO_PurgeStrayPurged(StrayManager *sm_, CDentry *d, bool oh, uint32_t ops) :
StrayManagerIOContext(sm_), dn(d), only_head(oh), ops_allowance(ops) { }
- void finish(int r) {
+ void finish(int r) override {
assert(r == 0 || r == -ENOENT);
sm->_purge_stray_purged(dn, ops_allowance, only_head);
}
public:
C_PurgeStrayLogged(StrayManager *sm_, CDentry *d, version_t v, LogSegment *s) :
StrayManagerLogContext(sm_), dn(d), pdv(v), ls(s) { }
- void finish(int r) {
+ void finish(int r) override {
sm->_purge_stray_logged(dn, pdv, ls);
}
};
public:
C_TruncateStrayLogged(StrayManager *sm, CDentry *d, LogSegment *s) :
StrayManagerLogContext(sm), dn(d), ls(s) { }
- void finish(int r) {
+ void finish(int r) override {
sm->_truncate_stray_logged(dn, ls);
}
};
public:
C_StraysFetched(StrayManager *sm_) :
StrayManagerContext(sm_) { }
- void finish(int r) {
+ void finish(int r) override {
sm->_advance();
}
};
public:
C_OpenSnapParents(StrayManager *sm_, CDentry *dn_, bool t, uint32_t ops) :
StrayManagerContext(sm_), dn(dn_), trunc(t), ops_required(ops) { }
- void finish(int r) {
+ void finish(int r) override {
sm->_process(dn, trunc, ops_required);
}
};
struct C_EvalStray : public StrayManagerContext {
CDentry *dn;
C_EvalStray(StrayManager *sm_, CDentry *d) : StrayManagerContext(sm_), dn(d) {}
- void finish(int r) {
+ void finish(int r) override {
sm->eval_stray(dn);
}
};
struct C_MDC_EvalStray : public StrayManagerContext {
CDentry *dn;
C_MDC_EvalStray(StrayManager *sm_, CDentry *d) : StrayManagerContext(sm_), dn(d) {}
- void finish(int r) {
+ void finish(int r) override {
sm->eval_stray(dn);
}
};
projects / ceph.git / commitdiff