// Did I previously not hold a rank? Initialize!
if (mds_rank == NULL) {
- mds_rank = new MDSRankDispatcher(
- whoami, mds_lock, clog,
- timer, beacon, mdsmap, messenger, monc, &mgrc,
- new LambdaContext([this](int r){respawn();}),
- new LambdaContext([this](int r){suicide();}),
- ioctx);
+ mds_rank = new MDSRankDispatcher(whoami, m->map_fs_name, mds_lock, clog,
+ timer, beacon, mdsmap, messenger, monc, &mgrc,
+ new LambdaContext([this](int r){respawn();}),
+ new LambdaContext([this](int r){suicide();}),
+ ioctx);
dout(10) << __func__ << ": initializing MDS rank "
<< mds_rank->get_nodeid() << dendl;
mds_rank->init();
MDSRank::MDSRank(
mds_rank_t whoami_,
+ std::string fs_name_,
ceph::mutex &mds_lock_,
LogChannelRef &clog_,
SafeTimer &timer_,
Context *respawn_hook_,
Context *suicide_hook_,
boost::asio::io_context& ioc) :
- cct(msgr->cct), mds_lock(mds_lock_), clog(clog_),
+ cct(msgr->cct), fs_name(fs_name_), mds_lock(mds_lock_), clog(clog_),
timer(timer_), mdsmap(mdsmap_),
objecter(new Objecter(g_ceph_context, msgr, monc_, ioc, 0, 0)),
damage_table(whoami_), sessionmap(this),
// send mdsmap first?
auto addrs = mdsmap->get_addrs(mds);
if (mds != whoami && peer_mdsmap_epoch[mds] < mdsmap->get_epoch()) {
- auto _m = make_message<MMDSMap>(monc->get_fsid(), *mdsmap);
+ auto _m = make_message<MMDSMap>(monc->get_fsid(), *mdsmap,
+ std::string(mdsmap->get_fs_name()));
send_message_mds(_m, addrs);
peer_mdsmap_epoch[mds] = mdsmap->get_epoch();
}
void MDSRank::dump_status(Formatter *f) const
{
+ f->dump_string("fs_name", fs_name);
if (state == MDSMap::STATE_REPLAY ||
state == MDSMap::STATE_STANDBY_REPLAY) {
mdlog->dump_replay_status(f);
set<Session*> clients;
sessionmap.get_client_session_set(clients);
for (const auto &session : clients) {
- auto m = make_message<MMDSMap>(monc->get_fsid(), *mdsmap);
+ auto m = make_message<MMDSMap>(monc->get_fsid(), *mdsmap,
+ std::string(mdsmap->get_fs_name()));
session->get_connection()->send_message2(std::move(m));
}
last_client_mdsmap_bcast = mdsmap->get_epoch();
MDSRankDispatcher::MDSRankDispatcher(
mds_rank_t whoami_,
+ std::string fs_name_,
ceph::mutex &mds_lock_,
LogChannelRef &clog_,
SafeTimer &timer_,
Context *respawn_hook_,
Context *suicide_hook_,
boost::asio::io_context& ioc)
- : MDSRank(whoami_, mds_lock_, clog_, timer_, beacon_, mdsmap_,
+ : MDSRank(whoami_, fs_name_, mds_lock_, clog_, timer_, beacon_, mdsmap_,
msgr, monc_, mgrc, respawn_hook_, suicide_hook_, ioc)
{
g_conf().add_observer(this);
MDSRank(
mds_rank_t whoami_,
+ std::string fs_name_,
ceph::mutex &mds_lock_,
LogChannelRef &clog_,
SafeTimer &timer_,
boost::asio::io_context& ioc);
mds_rank_t get_nodeid() const { return whoami; }
+ std::string_view get_fs_name() const { return fs_name; }
int64_t get_metadata_pool();
mono_time get_starttime() const {
friend class C_MDS_MonCommand;
const mds_rank_t whoami;
+ std::string fs_name;
~MDSRank();
public:
MDSRankDispatcher(
mds_rank_t whoami_,
+ std::string fs_name,
ceph::mutex &mds_lock_,
LogChannelRef &clog_,
SafeTimer &timer_,
class MMDSMap : public SafeMessage {
private:
- static constexpr int HEAD_VERSION = 1;
+ static constexpr int HEAD_VERSION = 2;
static constexpr int COMPAT_VERSION = 1;
public:
uuid_d fsid;
epoch_t epoch = 0;
ceph::buffer::list encoded;
+ std::string map_fs_name;
version_t get_epoch() const { return epoch; }
const ceph::buffer::list& get_encoded() const { return encoded; }
protected:
MMDSMap() :
SafeMessage{CEPH_MSG_MDS_MAP, HEAD_VERSION, COMPAT_VERSION} {}
- MMDSMap(const uuid_d &f, const MDSMap &mm) :
+
+ MMDSMap(const uuid_d &f, const MDSMap &mm,
+ const std::string mf = std::string()) :
SafeMessage{CEPH_MSG_MDS_MAP, HEAD_VERSION, COMPAT_VERSION},
- fsid(f) {
+ fsid(f), map_fs_name(mf) {
epoch = mm.get_epoch();
mm.encode(encoded, -1); // we will reencode with fewer features as necessary
}
+
~MMDSMap() override {}
public:
decode(fsid, p);
decode(epoch, p);
decode(encoded, p);
+ if (header.version >= 2) {
+ decode(map_fs_name, p);
+ }
}
void encode_payload(uint64_t features) override {
using ceph::encode;
m.encode(encoded, features);
}
encode(encoded, payload);
+ encode(map_fs_name, payload);
}
private:
template<class T, typename... Args>
if (sub->next > mds_map->epoch) {
return;
}
- auto msg = make_message<MMDSMap>(mon->monmap->fsid, *mds_map);
+ auto msg = make_message<MMDSMap>(mon->monmap->fsid, *mds_map,
+ mds_map->fs_name);
sub->session->con->send_message(msg.detach());
if (sub->onetime) {