#include "include/types.h"
+#include "MDSContext.h"
+
#include <map>
#include <list>
#include <set>
-using std::map;
-using std::list;
-using std::set;
-
+#include <string_view>
class MDSRank;
class CDir;
class CDentry;
class Session;
-class MExportDirDiscover;
-class MExportDirDiscoverAck;
-class MExportDirCancel;
-class MExportDirPrep;
-class MExportDirPrepAck;
-class MExportDir;
-class MExportDirAck;
-class MExportDirNotify;
-class MExportDirNotifyAck;
-class MExportDirFinish;
-
-class MExportCaps;
-class MExportCapsAck;
-class MGatherCaps;
+#include "messages/MExportCaps.h"
+#include "messages/MExportCapsAck.h"
+#include "messages/MExportDir.h"
+#include "messages/MExportDirAck.h"
+#include "messages/MExportDirCancel.h"
+#include "messages/MExportDirDiscover.h"
+#include "messages/MExportDirDiscoverAck.h"
+#include "messages/MExportDirFinish.h"
+#include "messages/MExportDirNotify.h"
+#include "messages/MExportDirNotifyAck.h"
+#include "messages/MExportDirPrep.h"
+#include "messages/MExportDirPrepAck.h"
+#include "messages/MGatherCaps.h"
class EImportStart;
const static int EXPORT_EXPORTING = 7; // sent actual export, waiting for ack
const static int EXPORT_LOGGINGFINISH = 8; // logging EExportFinish
const static int EXPORT_NOTIFYING = 9; // waiting for notifyacks
- static const char *get_export_statename(int s) {
+ static std::string_view get_export_statename(int s) {
switch (s) {
case EXPORT_CANCELLING: return "cancelling";
case EXPORT_LOCKING: return "locking";
case EXPORT_EXPORTING: return "exporting";
case EXPORT_LOGGINGFINISH: return "loggingfinish";
case EXPORT_NOTIFYING: return "notifying";
- default: ceph_abort(); return 0;
+ default: ceph_abort(); return std::string_view();
}
}
const static int IMPORT_ACKING = 6; // logged EImportStart, sent ack, waiting for finish
const static int IMPORT_FINISHING = 7; // sent cap imports, waiting for finish
const static int IMPORT_ABORTING = 8; // notifying bystanders of an abort before unfreezing
- static const char *get_import_statename(int s) {
+ static std::string_view get_import_statename(int s) {
switch (s) {
case IMPORT_DISCOVERING: return "discovering";
case IMPORT_DISCOVERED: return "discovered";
case IMPORT_ACKING: return "acking";
case IMPORT_FINISHING: return "finishing";
case IMPORT_ABORTING: return "aborting";
- default: ceph_abort(); return 0;
+ default: ceph_abort(); return std::string_view();
}
}
// -- cons --
Migrator(MDSRank *m, MDCache *c);
- void handle_conf_change(const struct md_config_t *conf,
+ void handle_conf_change(const ConfigProxy& conf,
const std::set <std::string> &changed,
const MDSMap &mds_map);
int state = 0;
mds_rank_t peer = MDS_RANK_NONE;
uint64_t tid = 0;
- set<mds_rank_t> warning_ack_waiting;
- set<mds_rank_t> notify_ack_waiting;
- map<inodeno_t,map<client_t,Capability::Import> > peer_imported;
+ std::set<mds_rank_t> warning_ack_waiting;
+ std::set<mds_rank_t> notify_ack_waiting;
+ std::map<inodeno_t,std::map<client_t,Capability::Import> > peer_imported;
MutationRef mut;
size_t approx_size = 0;
- size_t orig_size = 0;
// for freeze tree deadlock detection
utime_t last_cum_auth_pins_change;
int last_cum_auth_pins = 0;
std::shared_ptr<export_base_t> parent;
};
- map<CDir*, export_state_t> export_state;
+ std::map<CDir*, export_state_t> export_state;
typedef map<CDir*, export_state_t>::iterator export_state_iterator;
uint64_t total_exporting_size = 0;
unsigned num_locking_exports = 0; // exports in locking state (approx_size == 0)
- list<pair<dirfrag_t,mds_rank_t> > export_queue;
+
std::list<pair<dirfrag_t,mds_rank_t> > export_queue;
uint64_t export_queue_gen = 1;
// import fun
int state;
mds_rank_t peer;
uint64_t tid;
- set<mds_rank_t> bystanders;
- list<dirfrag_t> bound_ls;
- list<ScatterLock*> updated_scatterlocks;
- map<client_t,pair<Session*,uint64_t> > session_map;
- map<CInode*, map<client_t,Capability::Export> > peer_exports;
+ std::set<mds_rank_t> bystanders;
+ std::list<dirfrag_t> bound_ls;
+ std::list<ScatterLock*> updated_scatterlocks;
+ std::map<client_t,pair<Session*,uint64_t> > session_map;
+ std::map<CInode*, std::map<client_t,Capability::Export> > peer_exports;
MutationRef mut;
import_state_t() : state(0), peer(0), tid(0), mut() {}
};
- map<dirfrag_t, import_state_t> import_state;
+ std::map<dirfrag_t, import_state_t> import_state;
- void handle_export_discover_ack(MExportDirDiscoverAck *m);
+ void handle_export_discover_ack(const MExportDirDiscoverAck::const_ref &m);
void export_frozen(CDir *dir, uint64_t tid);
- void handle_export_prep_ack(MExportDirPrepAck *m);
+ void handle_export_prep_ack(const MExportDirPrepAck::const_ref &m);
void export_sessions_flushed(CDir *dir, uint64_t tid);
void export_go(CDir *dir);
void export_go_synced(CDir *dir, uint64_t tid);
void export_try_cancel(CDir *dir, bool notify_peer=true);
void export_cancel_finish(export_state_iterator& it);
void export_reverse(CDir *dir, export_state_t& stat);
- void export_notify_abort(CDir *dir, export_state_t& stat, set<CDir*>& bounds);
- void handle_export_ack(MExportDirAck *m);
+ void export_notify_abort(CDir *dir, export_state_t& stat, std::set<CDir*>& bounds);
+ void handle_export_ack(const MExportDirAck::const_ref &m);
void export_logged_finish(CDir *dir);
- void handle_export_notify_ack(MExportDirNotifyAck *m);
+ void handle_export_notify_ack(const MExportDirNotifyAck::const_ref &m);
void export_finish(CDir *dir);
- void handle_gather_caps(MGatherCaps *m);
+ void handle_gather_caps(const MGatherCaps::const_ref &m);
friend class C_MDC_ExportFreeze;
friend class C_MDS_ExportFinishLogged;
friend class C_M_ExportGo;
friend class C_M_ExportSessionsFlushed;
+ friend class C_MDS_ExportDiscover;
+ friend class C_MDS_ExportPrep;
friend class MigratorContext;
friend class MigratorLogContext;
// importer
- void handle_export_discover(MExportDirDiscover *m);
- void handle_export_cancel(MExportDirCancel *m);
- void handle_export_prep(MExportDirPrep *m);
- void handle_export_dir(MExportDir *m);
+ void handle_export_discover(const MExportDirDiscover::const_ref &m, bool started=false);
+ void handle_export_cancel(const MExportDirCancel::const_ref &m);
+ void handle_export_prep(const MExportDirPrep::const_ref &m, bool did_assim=false);
+ void handle_export_dir(const MExportDir::const_ref &m);
void import_reverse_discovering(dirfrag_t df);
void import_reverse_discovered(dirfrag_t df, CInode *diri);
void import_reverse_prepping(CDir *dir, import_state_t& stat);
- void import_remove_pins(CDir *dir, set<CDir*>& bounds);
+ void import_remove_pins(CDir *dir, std::set<CDir*>& bounds);
void import_reverse_unfreeze(CDir *dir);
void import_reverse_final(CDir *dir);
- void import_notify_abort(CDir *dir, set<CDir*>& bounds);
- void import_notify_finish(CDir *dir, set<CDir*>& bounds);
+ void import_notify_abort(CDir *dir, std::set<CDir*>& bounds);
+ void import_notify_finish(CDir *dir, std::set<CDir*>& bounds);
void import_logged_start(dirfrag_t df, CDir *dir, mds_rank_t from,
- map<client_t,pair<Session*,uint64_t> >& imported_session_map);
- void handle_export_finish(MExportDirFinish *m);
+ std::map<client_t,pair<Session*,uint64_t> >& imported_session_map);
+ void handle_export_finish(const MExportDirFinish::const_ref &m);
- void handle_export_caps(MExportCaps *m);
- void handle_export_caps_ack(MExportCapsAck *m);
+ void handle_export_caps(const MExportCaps::const_ref &m);
+ void handle_export_caps_ack(const MExportCapsAck::const_ref &m);
void logged_import_caps(CInode *in,
mds_rank_t from,
- map<client_t,pair<Session*,uint64_t> >& imported_session_map,
- map<CInode*, map<client_t,Capability::Export> >& cap_imports);
+ std::map<client_t,pair<Session*,uint64_t> >& imported_session_map,
+ std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports);
friend class C_MDS_ImportDirLoggedStart;
friend class C_M_LoggedImportCaps;
// bystander
- void handle_export_notify(MExportDirNotify *m);
+ void handle_export_notify(const MExportDirNotify::const_ref &m);
public:
- void dispatch(Message*);
+ void dispatch(const Message::const_ref &);
void show_importing();
void show_exporting();
// -- status --
int is_exporting(CDir *dir) const {
- map<CDir*, export_state_t>::const_iterator it = export_state.find(dir);
+ auto it = export_state.find(dir);
if (it != export_state.end()) return it->second.state;
return 0;
}
bool is_exporting() const { return !export_state.empty(); }
int is_importing(dirfrag_t df) const {
- map<dirfrag_t, import_state_t>::const_iterator it = import_state.find(df);
+ auto it = import_state.find(df);
if (it != import_state.end()) return it->second.state;
return 0;
}
bool is_importing() const { return !import_state.empty(); }
bool is_ambiguous_import(dirfrag_t df) const {
- map<dirfrag_t, import_state_t>::const_iterator p = import_state.find(df);
- if (p == import_state.end())
+ auto it = import_state.find(df);
+ if (it == import_state.end())
return false;
- if (p->second.state >= IMPORT_LOGGINGSTART &&
- p->second.state < IMPORT_ABORTING)
+ if (it->second.state >= IMPORT_LOGGINGSTART &&
+ it->second.state < IMPORT_ABORTING)
return true;
return false;
}
int get_import_state(dirfrag_t df) const {
- map<dirfrag_t, import_state_t>::const_iterator it = import_state.find(df);
- assert(it != import_state.end());
+ auto it = import_state.find(df);
+ ceph_assert(it != import_state.end());
return it->second.state;
}
int get_import_peer(dirfrag_t df) const {
- map<dirfrag_t, import_state_t>::const_iterator it = import_state.find(df);
- assert(it != import_state.end());
+ auto it = import_state.find(df);
+ ceph_assert(it != import_state.end());
return it->second.peer;
}
int get_export_state(CDir *dir) const {
- map<CDir*, export_state_t>::const_iterator it = export_state.find(dir);
- assert(it != export_state.end());
+ auto it = export_state.find(dir);
+ ceph_assert(it != export_state.end());
return it->second.state;
}
// this returns true if we are export @dir,
// be warned of ambiguous auth.
// only returns meaningful results during EXPORT_WARNING state.
bool export_has_warned(CDir *dir, mds_rank_t who) {
- map<CDir*, export_state_t>::iterator it = export_state.find(dir);
- assert(it != export_state.end());
- assert(it->second.state == EXPORT_WARNING);
+ auto it = export_state.find(dir);
+ ceph_assert(it != export_state.end());
+ ceph_assert(it->second.state == EXPORT_WARNING);
return (it->second.warning_ack_waiting.count(who) == 0);
}
bool export_has_notified(CDir *dir, mds_rank_t who) const {
- map<CDir*, export_state_t>::const_iterator it = export_state.find(dir);
- assert(it != export_state.end());
- assert(it->second.state == EXPORT_NOTIFYING);
+ auto it = export_state.find(dir);
+ ceph_assert(it != export_state.end());
+ ceph_assert(it->second.state == EXPORT_NOTIFYING);
return (it->second.notify_ack_waiting.count(who) == 0);
}
void export_freeze_inc_num_waiters(CDir *dir) {
- map<CDir*, export_state_t>::iterator it = export_state.find(dir);
- assert(it != export_state.end());
+ auto it = export_state.find(dir);
+ ceph_assert(it != export_state.end());
it->second.num_remote_waiters++;
}
void find_stale_export_freeze();
void maybe_split_export(CDir* dir, uint64_t max_size, bool null_okay,
vector<pair<CDir*, size_t> >& results);
- void restart_export_dir(CDir *dir, uint64_t tid);
- bool adjust_export_size(export_state_t &stat, CDir *dir);
- void adjust_export_after_rename(CInode* diri, CDir *olddir);
void child_export_finish(std::shared_ptr<export_base_t>& parent, bool success);
- void get_export_lock_set(CDir *dir, set<SimpleLock*>& locks);
- void get_export_client_set(CDir *dir, set<client_t> &client_set);
- void get_export_client_set(CInode *in, set<client_t> &client_set);
+ void get_export_lock_set(CDir *dir, MutationImpl::LockOpVec& lov);
+ void get_export_client_set(CDir *dir, std::set<client_t> &client_set);
+ void get_export_client_set(CInode *in, std::set<client_t> &client_set);
void encode_export_inode(CInode *in, bufferlist& bl,
- map<client_t,entity_inst_t>& exported_client_map);
+ std::map<client_t,entity_inst_t>& exported_client_map,
+ std::map<client_t,client_metadata_t>& exported_client_metadata_map);
void encode_export_inode_caps(CInode *in, bool auth_cap, bufferlist& bl,
- map<client_t,entity_inst_t>& exported_client_map);
- void finish_export_inode(CInode *in, utime_t now, mds_rank_t target,
- map<client_t,Capability::Import>& peer_imported,
- list<MDSInternalContextBase*>& finished);
+ std::map<client_t,entity_inst_t>& exported_client_map,
+ std::map<client_t,client_metadata_t>& exported_client_metadata_map);
+ void finish_export_inode(CInode *in, mds_rank_t target,
+ std::map<client_t,Capability::Import>& peer_imported,
+ MDSContext::vec& finished);
void finish_export_inode_caps(CInode *in, mds_rank_t target,
- map<client_t,Capability::Import>& peer_imported);
+ std::map<client_t,Capability::Import>& peer_imported);
uint64_t encode_export_dir(bufferlist& exportbl,
CDir *dir,
- map<client_t,entity_inst_t>& exported_client_map,
- utime_t now);
- void finish_export_dir(CDir *dir, utime_t now, mds_rank_t target,
- map<inodeno_t,map<client_t,Capability::Import> >& peer_imported,
- list<MDSInternalContextBase*>& finished, int *num_dentries);
+ std::map<client_t,entity_inst_t>& exported_client_map,
+ std::map<client_t,client_metadata_t>& exported_client_metadata_map);
+ void finish_export_dir(CDir *dir, mds_rank_t target,
+ std::map<inodeno_t,std::map<client_t,Capability::Import> >& peer_imported,
+ MDSContext::vec& finished, int *num_dentries);
void clear_export_proxy_pins(CDir *dir);
void export_caps(CInode *in);
- void decode_import_inode(CDentry *dn, bufferlist::iterator& blp,
+ void decode_import_inode(CDentry *dn, bufferlist::const_iterator& blp,
mds_rank_t oldauth, LogSegment *ls,
- map<CInode*, map<client_t,Capability::Export> >& cap_imports,
- list<ScatterLock*>& updated_scatterlocks);
- void decode_import_inode_caps(CInode *in, bool auth_cap, bufferlist::iterator &blp,
- map<CInode*, map<client_t,Capability::Export> >& cap_imports);
+ std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports,
+ std::list<ScatterLock*>& updated_scatterlocks);
+ void decode_import_inode_caps(CInode *in, bool auth_cap, bufferlist::const_iterator &blp,
+ std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports);
void finish_import_inode_caps(CInode *in, mds_rank_t from, bool auth_cap,
- const map<client_t,pair<Session*,uint64_t> >& smap,
- const map<client_t,Capability::Export> &export_map,
- map<client_t,Capability::Import> &import_map);
- int decode_import_dir(bufferlist::iterator& blp,
+ const std::map<client_t,pair<Session*,uint64_t> >& smap,
+ const std::map<client_t,Capability::Export> &export_map,
+ std::map<client_t,Capability::Import> &import_map);
+ int decode_import_dir(bufferlist::const_iterator& blp,
mds_rank_t oldauth,
CDir *import_root,
EImportStart *le,
LogSegment *ls,
- map<CInode*, map<client_t,Capability::Export> >& cap_imports,
- list<ScatterLock*>& updated_scatterlocks, utime_t now);
+ std::map<CInode*, std::map<client_t,Capability::Export> >& cap_imports,
+ std::list<ScatterLock*>& updated_scatterlocks);
void import_reverse(CDir *dir);
MDCache *cache;
uint64_t max_export_size = 0;
bool inject_session_race = false;
- int inject_message_loss = 0;
};
#endif
projects / ceph.git / blobdiff