tools/cephfs/EventOutput.cc
tools/cephfs/Dumper.cc
tools/cephfs/Resetter.cc
+ tools/cephfs/RoleSelector.cc
tools/cephfs/MDSUtility.cc)
add_executable(cephfs-journal-tool ${cephfs_journal_tool_srcs})
target_link_libraries(cephfs-journal-tool librados mds osdc global
set(cephfs_table_tool_srcs
tools/cephfs/cephfs-table-tool.cc
tools/cephfs/TableTool.cc
+ tools/cephfs/RoleSelector.cc
tools/cephfs/MDSUtility.cc)
add_executable(cephfs-table-tool ${cephfs_table_tool_srcs})
target_link_libraries(cephfs-table-tool librados mds osdc global
set(cephfs_data_scan_srcs
tools/cephfs/cephfs-data-scan.cc
tools/cephfs/DataScan.cc
+ tools/cephfs/RoleSelector.cc
tools/cephfs/MDSUtility.cc)
add_executable(cephfs-data-scan ${cephfs_data_scan_srcs})
target_link_libraries(cephfs-data-scan librados mds osdc global
cephfs_journal_tool_SOURCES = \
tools/cephfs/cephfs-journal-tool.cc \
tools/cephfs/JournalTool.cc \
+ tools/cephfs/RoleSelector.cc \
tools/cephfs/JournalFilter.cc \
tools/cephfs/JournalScanner.cc \
tools/cephfs/EventOutput.cc \
cephfs_table_tool_SOURCES = \
tools/cephfs/cephfs-table-tool.cc \
tools/cephfs/TableTool.cc \
+ tools/cephfs/RoleSelector.cc \
tools/cephfs/MDSUtility.cc
cephfs_table_tool_LDADD = $(LIBMDS) $(LIBRADOS) $(CEPH_GLOBAL)
bin_PROGRAMS += cephfs-table-tool
cephfs_data_scan_SOURCES = \
tools/cephfs/cephfs-data-scan.cc \
tools/cephfs/DataScan.cc \
+ tools/cephfs/RoleSelector.cc \
tools/cephfs/MDSUtility.cc
cephfs_data_scan_LDADD = $(LIBMDS) libcls_cephfs_client.la $(LIBRADOS) $(CEPH_GLOBAL)
bin_PROGRAMS += cephfs-data-scan
tools/rados/RadosImport.h \
tools/ceph_objectstore_tool.h \
tools/rados/PoolDump.h \
- tools/cephfs/DataScan.h
+ tools/cephfs/DataScan.h \
+ tools/cephfs/RoleSelector.h
EXTRA_DIST += \
tools/setup-virtualenv.sh
<< "\n"
<< " --force-corrupt: overrite apparently corrupt structures\n"
<< " --force-init: write root inodes even if they exist\n"
- << " --force-pool: use data pool even if it is not in MDSMap\n"
+ << " --force-pool: use data pool even if it is not in FSMap\n"
<< "\n"
<< " cephfs-data-scan scan_frags [--force-corrupt]\n"
<< "\n"
filter_tag = val;
dout(10) << "Applying tag filter: '" << filter_tag << "'" << dendl;
return true;
+ } else if (arg == std::string("--filesystem")) {
+ std::shared_ptr<Filesystem> fs;
+ *r = fsmap->parse_filesystem(val, &fs);
+ if (*r != 0) {
+ std::cerr << "Invalid filesystem '" << val << "'" << std::endl;
+ return false;
+ }
+ fscid = fs->fscid;
+ return true;
} else {
return false;
}
return -EINVAL;
}
+ // If caller didn't specify a namespace, try to pick
+ // one if only one exists
+ if (fscid == FS_CLUSTER_ID_NONE) {
+ if (fsmap->get_filesystems().size() == 1) {
+ fscid = fsmap->get_filesystems().begin()->first;
+ } else {
+ std::cerr << "Specify a filesystem with --filesystem" << std::endl;
+ return -EINVAL;
+ }
+ }
+ auto fs = fsmap->get_filesystem(fscid);
+ assert(fs != nullptr);
+
// Default to output to metadata pool
if (driver == NULL) {
driver = new MetadataDriver();
dout(4) << "connecting to RADOS..." << dendl;
rados.connect();
- r = driver->init(rados, mdsmap);
+ r = driver->init(rados, fsmap, fscid);
if (r < 0) {
return r;
}
<< "' has ID " << data_pool_id << dendl;
}
- if (!mdsmap->is_data_pool(data_pool_id)) {
+ if (!fs->mds_map.is_data_pool(data_pool_id)) {
std::cerr << "Warning: pool '" << data_pool_name << "' is not a "
"CephFS data pool!" << std::endl;
if (!force_pool) {
// Initialize metadata_io from MDSMap for scan_frags
if (command == "scan_frags") {
- int const metadata_pool_id = mdsmap->get_metadata_pool();
+ const auto fs = fsmap->get_filesystem(fscid);
+ if (fs == nullptr) {
+ std::cerr << "Filesystem id " << fscid << " does not exist" << std::endl;
+ return -ENOENT;
+ }
+ int const metadata_pool_id = fs->mds_map.get_metadata_pool();
+
dout(4) << "resolving metadata pool " << metadata_pool_id << dendl;
std::string metadata_pool_name;
int r = rados.pool_reverse_lookup(metadata_pool_id, &metadata_pool_name);
} else if (command == "tmap_upgrade") {
return tmap_upgrade();
} else if (command == "init") {
- return driver->init_roots(mdsmap->get_first_data_pool());
+ return driver->init_roots(fs->mds_map.get_first_data_pool());
} else {
std::cerr << "Unknown command '" << command << "'" << std::endl;
return -EINVAL;
}
-int MetadataDriver::init(librados::Rados &rados, const MDSMap *mdsmap)
+int MetadataDriver::init(
+ librados::Rados &rados, const FSMap *fsmap, fs_cluster_id_t fscid)
{
- int const metadata_pool_id = mdsmap->get_metadata_pool();
+ auto fs = fsmap->get_filesystem(fscid);
+ assert(fs != nullptr);
+ int const metadata_pool_id = fs->mds_map.get_metadata_pool();
dout(4) << "resolving metadata pool " << metadata_pool_id << dendl;
std::string metadata_pool_name;
return rados.ioctx_create(metadata_pool_name.c_str(), metadata_io);
}
-int LocalFileDriver::init(librados::Rados &rados, const MDSMap *mdsmap)
+int LocalFileDriver::init(
+ librados::Rados &rados, const FSMap *fsmap, fs_cluster_id_t fscid)
{
return 0;
}
bool force_init;
public:
- virtual int init(librados::Rados &rados, const MDSMap *mdsmap) = 0;
+ virtual int init(
+ librados::Rados &rados,
+ const FSMap *fsmap,
+ fs_cluster_id_t fscid) = 0;
void set_force_corrupt(const bool val)
{
{}
// Implement RecoveryDriver interface
- int init(librados::Rados &rados, const MDSMap *mdsmap);
+ int init(
+ librados::Rados &rados,
+ const FSMap *fsmap,
+ fs_cluster_id_t fscid);
int inject_with_backtrace(
const inode_backtrace_t &bt,
public:
// Implement RecoveryDriver interface
- int init(librados::Rados &rados, const MDSMap *mdsmap);
+ int init(
+ librados::Rados &rados,
+ const FSMap *fsmap,
+ fs_cluster_id_t fscid);
int inject_with_backtrace(
const inode_backtrace_t &bt,
{
protected:
RecoveryDriver *driver;
+ fs_cluster_id_t fscid;
// IoCtx for data pool (where we scrape file backtraces from)
librados::IoCtx data_io;
*/
int tmap_upgrade();
- // Accept pools which are not in the MDSMap
+ // Accept pools which are not in the FSMap
bool force_pool;
// Respond to decode errors by overwriting
bool force_corrupt;
int main(const std::vector<const char *> &args);
DataScan()
- : driver(NULL), data_pool_id(-1), n(0), m(1),
+ : driver(NULL), fscid(FS_CLUSTER_ID_NONE), data_pool_id(-1), n(0), m(1),
force_pool(false), force_corrupt(false),
force_init(false)
{
#define HEADER_LEN 4096
-int Dumper::init(int rank_)
+int Dumper::init(mds_role_t role_)
{
- rank = rank_;
+ role = role_;
int r = MDSUtility::init();
if (r < 0) {
return r;
}
- JournalPointer jp(rank, mdsmap->get_metadata_pool());
+ auto fs = fsmap->get_filesystem(role.fscid);
+ assert(fs != nullptr);
+
+ JournalPointer jp(role.rank, fs->mds_map.get_metadata_pool());
int jp_load_result = jp.load(objecter);
if (jp_load_result != 0) {
std::cerr << "Error loading journal: " << cpp_strerror(jp_load_result) << std::endl;
{
int r = 0;
- Journaler journaler(ino, mdsmap->get_metadata_pool(), CEPH_FS_ONDISK_MAGIC,
- objecter, 0, 0, &timer, &finisher);
+ auto fs = fsmap->get_filesystem(role.fscid);
+ assert(fs != nullptr);
+
+ Journaler journaler(ino, fs->mds_map.get_metadata_pool(),
+ CEPH_FS_ONDISK_MAGIC, objecter, 0, 0,
+ &timer, &finisher);
r = recover_journal(&journaler);
if (r) {
return r;
char buf[HEADER_LEN];
memset(buf, 0, sizeof(buf));
snprintf(buf, HEADER_LEN, "Ceph mds%d journal dump\n start offset %llu (0x%llx)\n length %llu (0x%llx)\n write_pos %llu (0x%llx)\n format %llu\n trimmed_pos %llu (0x%llx)\n%c",
- rank,
+ role.rank,
(unsigned long long)start, (unsigned long long)start,
(unsigned long long)len, (unsigned long long)len,
(unsigned long long)journaler.last_committed.write_pos, (unsigned long long)journaler.last_committed.write_pos,
{
cout << "undump " << dump_file << std::endl;
+ auto fs = fsmap->get_filesystem(role.fscid);
+ assert(fs != nullptr);
+
int r = 0;
int fd = ::open(dump_file, O_RDONLY);
if (fd < 0) {
h.magic = CEPH_FS_ONDISK_MAGIC;
h.layout = file_layout_t::get_default();
- h.layout.pool_id = mdsmap->get_metadata_pool();
+ h.layout.pool_id = fs->mds_map.get_metadata_pool();
bufferlist hbl;
::encode(h, hbl);
object_t oid = file_object_t(ino, 0);
- object_locator_t oloc(mdsmap->get_metadata_pool());
+ object_locator_t oloc(fs->mds_map.get_metadata_pool());
SnapContext snapc;
cout << "writing header " << oid << std::endl;
class Dumper : public MDSUtility {
private:
- int rank;
+ mds_role_t role;
inodeno_t ino;
public:
- Dumper() : rank(-1), ino(-1)
+ Dumper() : ino(-1)
{}
- void handle_mds_map(MMDSMap* m);
+ void handle_mds_map(MFSMap* m);
- int init(int rank);
+ int init(mds_role_t role_);
int recover_journal(Journaler *journaler);
int dump(const char *dumpfile);
int undump(const char *dumpfile);
<< " <output>: [summary|binary|json] [--path <path>]\n"
<< "\n"
<< "Options:\n"
- << " --rank=<int> Journal rank (default 0)\n";
+ << " --rank=<str> Journal rank (default 0)\n";
generic_client_usage();
}
}
std::vector<const char*>::iterator arg = argv.begin();
+
std::string rank_str;
- if(ceph_argparse_witharg(argv, arg, &rank_str, "--rank", (char*)NULL)) {
- std::string rank_err;
- rank = strict_strtol(rank_str.c_str(), 10, &rank_err);
- if (!rank_err.empty()) {
- derr << "Bad rank '" << rank_str << "'" << dendl;
- usage();
- }
+ if(!ceph_argparse_witharg(argv, arg, &rank_str, "--rank", (char*)NULL)) {
+ // Default: act on rank 0. Will give the user an error if they
+ // try invoking this way when they have more than one filesystem.
+ rank_str = "0";
+ }
+
+ r = role_selector.parse(*fsmap, rank_str);
+ if (r != 0) {
+ return r;
}
std::string mode;
dout(4) << "JournalTool: connecting to RADOS..." << dendl;
rados.connect();
- int const pool_id = mdsmap->get_metadata_pool();
+ auto fs = fsmap->get_filesystem(role_selector.get_ns());
+ assert(fs != nullptr);
+ int const pool_id = fs->mds_map.get_metadata_pool();
dout(4) << "JournalTool: resolving pool " << pool_id << dendl;
std::string pool_name;
r = rados.pool_reverse_lookup(pool_id, &pool_name);
// Execution
// =========
- dout(4) << "Executing for rank " << rank << dendl;
- if (mode == std::string("journal")) {
- return main_journal(argv);
- } else if (mode == std::string("header")) {
- return main_header(argv);
- } else if (mode == std::string("event")) {
- return main_event(argv);
- } else {
- derr << "Bad command '" << mode << "'" << dendl;
- usage();
- return -EINVAL;
+ for (auto role : role_selector.get_roles()) {
+ rank = role.rank;
+ dout(4) << "Executing for rank " << rank << dendl;
+ if (mode == std::string("journal")) {
+ r = main_journal(argv);
+ } else if (mode == std::string("header")) {
+ r = main_header(argv);
+ } else if (mode == std::string("event")) {
+ r = main_event(argv);
+ } else {
+ derr << "Bad command '" << mode << "'" << dendl;
+ usage();
+ return -EINVAL;
+ }
+
+ if (r != 0) {
+ return r;
+ }
}
+
+ return r;
}
*/
{
Dumper dumper;
- r = dumper.init(rank);
+ r = dumper.init(mds_role_t(role_selector.get_ns(), rank));
if (r < 0) {
derr << "dumper::init failed: " << cpp_strerror(r) << dendl;
return r;
return r;
}
- if (mdsmap->is_dne(mds_rank_t(rank))) {
- std::cerr << "MDS rank " << rank << " does not exist" << std::endl;
- return -ENOENT;
- }
-
if (hard) {
- r = resetter.reset_hard(rank);
+ r = resetter.reset_hard(mds_role_t(role_selector.get_ns(), rank));
} else {
- r = resetter.reset(rank);
+ r = resetter.reset(mds_role_t(role_selector.get_ns(), rank));
}
resetter.shutdown();
int r = 0;
// InoTable is a per-MDS structure, so iterate over assigned ranks
+ auto fs = fsmap->get_filesystem(role_selector.get_ns());
std::set<mds_rank_t> in_ranks;
- mdsmap->get_mds_set(in_ranks);
+ fs->mds_map.get_mds_set(in_ranks);
for (std::set<mds_rank_t>::iterator rank_i = in_ranks.begin();
rank_i != in_ranks.end(); ++rank_i)
*/
#include "MDSUtility.h"
+#include "RoleSelector.h"
#include <vector>
#include "mds/mdstypes.h"
class JournalTool : public MDSUtility
{
private:
- int rank;
+ MDSRoleSelector role_selector;
+ // Bit hacky, use this `rank` member to control behaviour of the
+ // various main_ functions.
+ mds_rank_t rank;
// Entry points
int main_journal(std::vector<const char*> &argv);
{
monc = new MonClient(g_ceph_context);
messenger = Messenger::create_client_messenger(g_ceph_context, "mds");
- mdsmap = new MDSMap();
+ fsmap = new FSMap();
objecter = new Objecter(g_ceph_context, messenger, monc, NULL, 0, 0);
}
delete objecter;
delete monc;
delete messenger;
- delete mdsmap;
+ delete fsmap;
assert(waiting_for_mds_map == NULL);
}
Mutex init_lock("MDSUtility:init");
Cond cond;
bool done = false;
- assert(!mdsmap->get_epoch());
+ assert(!fsmap->get_epoch());
lock.Lock();
waiting_for_mds_map = new C_SafeCond(&init_lock, &cond, &done, NULL);
lock.Unlock();
- monc->sub_want("mdsmap", 0, CEPH_SUBSCRIBE_ONETIME);
+ monc->sub_want("fsmap", 0, CEPH_SUBSCRIBE_ONETIME);
monc->renew_subs();
// Wait for MDS map
while (!done)
cond.Wait(init_lock);
init_lock.Unlock();
- dout(4) << "Got MDS map " << mdsmap->get_epoch() << dendl;
+ dout(4) << "Got MDS map " << fsmap->get_epoch() << dendl;
finisher.start();
{
Mutex::Locker locker(lock);
switch (m->get_type()) {
- case CEPH_MSG_MDS_MAP:
- handle_mds_map((MMDSMap*)m);
+ case CEPH_MSG_FS_MAP:
+ handle_mds_map((MFSMap*)m);
break;
case CEPH_MSG_OSD_MAP:
break;
}
-void MDSUtility::handle_mds_map(MMDSMap* m)
+void MDSUtility::handle_mds_map(MFSMap* m)
{
- mdsmap->decode(m->get_encoded());
+ fsmap->decode(m->get_encoded());
if (waiting_for_mds_map) {
waiting_for_mds_map->complete(0);
waiting_for_mds_map = NULL;
#define MDS_UTILITY_H_
#include "osdc/Objecter.h"
-#include "mds/MDSMap.h"
-#include "messages/MMDSMap.h"
+#include "mds/FSMap.h"
+#include "messages/MFSMap.h"
#include "msg/Dispatcher.h"
#include "msg/Messenger.h"
#include "auth/Auth.h"
class MDSUtility : public Dispatcher {
protected:
Objecter *objecter;
- MDSMap *mdsmap;
+ FSMap *fsmap;
Messenger *messenger;
MonClient *monc;
MDSUtility();
~MDSUtility();
- void handle_mds_map(MMDSMap* m);
+ void handle_mds_map(MFSMap* m);
bool ms_dispatch(Message *m);
bool ms_handle_reset(Connection *con) { return false; }
void ms_handle_remote_reset(Connection *con) {}
#define dout_subsys ceph_subsys_mds
-int Resetter::reset(int rank)
+int Resetter::reset(mds_role_t role)
{
Mutex mylock("Resetter::reset::lock");
Cond cond;
bool done;
int r;
- JournalPointer jp(rank, mdsmap->get_metadata_pool());
+ auto fs = fsmap->get_filesystem(role.fscid);
+ assert(fs != nullptr);
+ int const pool_id = fs->mds_map.get_metadata_pool();
+
+ JournalPointer jp(role.rank, pool_id);
int jp_load_result = jp.load(objecter);
if (jp_load_result != 0) {
std::cerr << "Error loading journal: " << cpp_strerror(jp_load_result) <<
}
Journaler journaler(jp.front,
- mdsmap->get_metadata_pool(),
+ pool_id,
CEPH_FS_ONDISK_MAGIC,
objecter, 0, 0, &timer, &finisher);
return 0;
}
-int Resetter::reset_hard(int rank)
+int Resetter::reset_hard(mds_role_t role)
{
- JournalPointer jp(rank, mdsmap->get_metadata_pool());
- jp.front = rank + MDS_INO_LOG_OFFSET;
+ auto fs = fsmap->get_filesystem(role.fscid);
+ assert(fs != nullptr);
+ int const pool_id = fs->mds_map.get_metadata_pool();
+
+ JournalPointer jp(role.rank, pool_id);
+ jp.front = role.rank + MDS_INO_LOG_OFFSET;
jp.back = 0;
int r = jp.save(objecter);
if (r != 0) {
}
Journaler journaler(jp.front,
- mdsmap->get_metadata_pool(),
+ pool_id,
CEPH_FS_ONDISK_MAGIC,
objecter, 0, 0, &timer, &finisher);
journaler.set_writeable();
- file_layout_t default_log_layout = MDCache::gen_default_log_layout(*mdsmap);
+ file_layout_t default_log_layout = MDCache::gen_default_log_layout(
+ fsmap->get_filesystem(role.fscid)->mds_map);
journaler.create(&default_log_layout, g_conf->mds_journal_format);
C_SaferCond cond;
}
dout(4) << "Successfully wrote new journal pointer and header for rank "
- << rank << dendl;
+ << role << dendl;
return 0;
}
* For use when no journal header/pointer was present: write one
* out from scratch.
*/
- int reset_hard(int rank);
- int reset(int rank);
+ int reset_hard(mds_role_t role);
+ int reset(mds_role_t role);
};
#endif /* JOURNAL_RESETTER_H_ */
--- /dev/null
+
+#include "RoleSelector.h"
+
+int MDSRoleSelector::parse_rank(
+ const FSMap &fsmap,
+ std::string const &str)
+{
+ if (str == "all" || str == "*") {
+ std::set<mds_rank_t> in;
+ const MDSMap &mds_map = fsmap.get_filesystem(fscid)->mds_map;
+ mds_map.get_mds_set(in);
+
+ for (auto rank : in) {
+ roles.push_back(mds_role_t(fscid, rank));
+ }
+
+ return 0;
+ } else {
+ std::string rank_err;
+ mds_rank_t rank = strict_strtol(str.c_str(), 10, &rank_err);
+ if (!rank_err.empty()) {
+ return -EINVAL;
+ }
+ if (fsmap.get_filesystem(fscid)->mds_map.is_dne(rank)) {
+ return -ENOENT;
+ }
+ roles.push_back(mds_role_t(fscid, rank));
+ return 0;
+ }
+}
+
+int MDSRoleSelector::parse(const FSMap &fsmap, std::string const &str)
+{
+ auto colon_pos = str.find(":");
+ if (colon_pos == std::string::npos) {
+ // An unqualified rank. Only valid if there is only one
+ // namespace.
+ if (fsmap.get_filesystems().size() == 1) {
+ fscid = fsmap.get_filesystems().begin()->first;
+ return parse_rank(fsmap, str);
+ } else {
+ return -EINVAL;
+ }
+ } else if (colon_pos == 0 || colon_pos == str.size() - 1) {
+ return -EINVAL;
+ } else {
+ const std::string ns_str = str.substr(0, colon_pos);
+ const std::string rank_str = str.substr(colon_pos + 1);
+ std::shared_ptr<Filesystem> fs_ptr;
+ int r = fsmap.parse_filesystem(ns_str, &fs_ptr);
+ if (r != 0) {
+ return r;
+ }
+ fscid = fs_ptr->fscid;
+ return parse_rank(fsmap, rank_str);
+ }
+}
+
--- /dev/null
+
+#ifndef ROLE_SELECTOR_H_
+#define ROLE_SELECTOR_H_
+
+#include <string>
+#include <vector>
+#include "mds/mdstypes.h"
+#include "mds/FSMap.h"
+
+/**
+ * When you want to let the user act on a single rank in a namespace,
+ * or all of them.
+ */
+class MDSRoleSelector
+{
+ public:
+ const std::vector<mds_role_t> &get_roles() const {return roles;}
+ int parse(const FSMap &fsmap, std::string const &str);
+ MDSRoleSelector()
+ : fscid(FS_CLUSTER_ID_NONE)
+ {}
+ fs_cluster_id_t get_ns() const
+ {
+ return fscid;
+ }
+ protected:
+ int parse_rank(
+ const FSMap &fsmap,
+ std::string const &str);
+ std::vector<mds_role_t> roles;
+ fs_cluster_id_t fscid;
+};
+
+#endif // ROLE_SELECTOR_H_
+
/**
- * For a function that takes an MDS rank as an argument and
- * returns an error code, execute it either on all ranks (if
- * this->rank is MDS_RANK_NONE), or on the rank specified
- * by this->rank.
+ * For a function that takes an MDS role as an argument and
+ * returns an error code, execute it on the roles specified
+ * by `role_selector`.
*/
-int TableTool::apply_rank_fn(std::function<int(mds_rank_t, Formatter *)> fptr, Formatter *f)
+int TableTool::apply_role_fn(std::function<int(mds_role_t, Formatter *)> fptr, Formatter *f)
{
assert(f != NULL);
int r = 0;
- std::set<mds_rank_t> apply_to_ranks;
- if (rank == MDS_RANK_NONE) {
- mdsmap->get_mds_set(apply_to_ranks);
- } else {
- apply_to_ranks.insert(rank);
- }
f->open_object_section("ranks");
- for (std::set<mds_rank_t>::iterator rank_i = apply_to_ranks.begin();
- rank_i != apply_to_ranks.end(); ++rank_i) {
+ for (auto role : role_selector.get_roles()) {
std::ostringstream rank_str;
- rank_str << *rank_i;
+ rank_str << role.rank;
f->open_object_section(rank_str.str().c_str());
f->open_object_section("data");
- int rank_r = fptr(*rank_i, f);
+ int rank_r = fptr(role, f);
f->close_section();
r = r ? r : rank_r;
f->dump_int("result", rank_r);
f->close_section();
+
+
}
f->close_section();
// The RADOS object ID for the table
std::string object_name;
- // The rank in question (may be NONE)
- mds_rank_t rank;
+ // The role in question (may be NONE)
+ mds_role_t role;
// Whether this is an MDSTable subclass (i.e. has leading version field to decode)
bool mds_table;
public:
- TableHandler(mds_rank_t r, std::string const &name, bool mds_table_)
- : rank(r), mds_table(mds_table_)
+ TableHandler(mds_role_t r, std::string const &name, bool mds_table_)
+ : role(r), mds_table(mds_table_)
{
// Compose object name of the table we will dump
std::ostringstream oss;
oss << "mds";
- if (rank != MDS_RANK_NONE) {
- oss << rank;
+ if (!role.is_none()) {
+ oss << role.rank;
}
oss << "_" << name;
object_name = oss.str();
f->dump_int("version", version);
}
A table_inst;
- table_inst.set_rank(rank);
+ table_inst.set_rank(role.rank);
table_inst.decode(q);
table_inst.dump(f);
{
A table_inst;
// Compose new (blank) table
- table_inst.set_rank(rank);
+ table_inst.set_rank(role.rank);
table_inst.reset_state();
// Write the table out
return write(table_inst, io);
// The RADOS object ID for the table
std::string object_name;
- // The rank in question (may be NONE)
- mds_rank_t rank;
+ // The role (rank may be NONE)
+ mds_role_t role;
// Whether this is an MDSTable subclass (i.e. has leading version field to decode)
bool mds_table;
public:
- TableHandlerOmap(mds_rank_t r, std::string const &name, bool mds_table_)
- : rank(r), mds_table(mds_table_)
+ TableHandlerOmap(mds_role_t r, std::string const &name, bool mds_table_)
+ : role(r), mds_table(mds_table_)
{
// Compose object name of the table we will dump
std::ostringstream oss;
oss << "mds";
- if (rank != MDS_RANK_NONE) {
- oss << rank;
+ if (!role.is_none()) {
+ oss << role.rank;
}
oss << "_" << name;
object_name = oss.str();
bufferlist header_bl;
int r = io->omap_get_header(object_name, &header_bl);
if (r != 0) {
- derr << "error reading header: " << cpp_strerror(r) << dendl;
+ derr << "error reading header on '" << object_name << "': "
+ << cpp_strerror(r) << dendl;
return r;
}
// Decode the header
A table_inst;
- table_inst.set_rank(rank);
+ table_inst.set_rank(role.rank);
try {
table_inst.decode_header(header_bl);
} catch (buffer::error &e) {
int reset(librados::IoCtx *io)
{
A table_inst;
- table_inst.set_rank(rank);
+ table_inst.set_rank(role.rank);
table_inst.reset_state();
bufferlist header_bl;
table_inst.encode_header(&header_bl);
class InoTableHandler : public TableHandler<InoTable>
{
public:
- explicit InoTableHandler(mds_rank_t r)
+ explicit InoTableHandler(mds_role_t r)
: TableHandler(r, "inotable", true)
{}
int take_inos(librados::IoCtx *io, inodeno_t max, Formatter *f)
{
InoTable inst;
- inst.set_rank(rank);
+ inst.set_rank(role.rank);
inst.reset_state();
int r = 0;
dout(4) << "connecting to RADOS..." << dendl;
rados.connect();
- int const pool_id = mdsmap->get_metadata_pool();
- dout(4) << "resolving pool " << pool_id << dendl;
- std::string pool_name;
- r = rados.pool_reverse_lookup(pool_id, &pool_name);
- if (r < 0) {
- derr << "Pool " << pool_id << " identified in MDS map not found in RADOS!" << dendl;
- return r;
- }
- dout(4) << "creating IoCtx.." << dendl;
- r = rados.ioctx_create(pool_name.c_str(), io);
- assert(r == 0);
// Require at least 3 args <rank> <mode> <arg> [args...]
if (argv.size() < 3) {
return -EINVAL;
}
- const std::string rank_str = std::string(argv[0]);
+ const std::string role_str = std::string(argv[0]);
const std::string mode = std::string(argv[1]);
+ const std::string table = std::string(argv[2]);
- if (rank_str == "all") {
- rank = MDS_RANK_NONE;
- } else {
- std::string rank_err;
- rank = strict_strtol(rank_str.c_str(), 10, &rank_err);
- if (!rank_err.empty()) {
- derr << "Bad rank '" << rank_str << "'" << dendl;
- usage();
- }
+ r = role_selector.parse(*fsmap, role_str);
+ if (r < 0) {
+ derr << "Bad rank selection: " << role_str << "'" << dendl;
+ return r;
+ }
+
+ auto fs = fsmap->get_filesystem(role_selector.get_ns());
+ assert(fs != nullptr);
+ int const pool_id = fs->mds_map.get_metadata_pool();
+ dout(4) << "resolving pool " << pool_id << dendl;
+ std::string pool_name;
+ r = rados.pool_reverse_lookup(pool_id, &pool_name);
+ if (r < 0) {
+ derr << "Pool " << pool_id << " identified in MDS map not found in RADOS!"
+ << dendl;
+ return r;
+ }
+
+ dout(4) << "creating IoCtx.." << dendl;
+ r = rados.ioctx_create(pool_name.c_str(), io);
+ if (r != 0) {
+ return r;
}
JSONFormatter jf(true);
if (mode == "reset") {
const std::string table = std::string(argv[2]);
if (table == "session") {
- r = apply_rank_fn([this](mds_rank_t rank, Formatter *f) -> int {
+ r = apply_role_fn([this](mds_role_t rank, Formatter *f) -> int {
return TableHandlerOmap<SessionMapStore>(rank, "sessionmap", false).reset(&io);
}, &jf);
} else if (table == "inode") {
- r = apply_rank_fn([this](mds_rank_t rank, Formatter *f) -> int {
+ r = apply_role_fn([this](mds_role_t rank, Formatter *f) -> int {
return TableHandler<InoTable>(rank, "inotable", true).reset(&io);
}, &jf);
} else if (table == "snap") {
- r = TableHandler<SnapServer>(MDS_RANK_NONE, "snaptable", true).reset(&io);
+ r = TableHandler<SnapServer>(mds_role_t(), "snaptable", true).reset(&io);
jf.open_object_section("reset_snap_status");
jf.dump_int("result", r);
jf.close_section();
} else if (mode == "show") {
const std::string table = std::string(argv[2]);
if (table == "session") {
- r = apply_rank_fn([this](mds_rank_t rank, Formatter *f) -> int {
+ r = apply_role_fn([this](mds_role_t rank, Formatter *f) -> int {
return TableHandlerOmap<SessionMapStore>(rank, "sessionmap", false).load_and_dump(&io, f);
}, &jf);
} else if (table == "inode") {
- r = apply_rank_fn([this](mds_rank_t rank, Formatter *f) -> int {
+ r = apply_role_fn([this](mds_role_t rank, Formatter *f) -> int {
return TableHandler<InoTable>(rank, "inotable", true).load_and_dump(&io, f);;
}, &jf);
} else if (table == "snap") {
jf.open_object_section("show_snap_table");
{
r = TableHandler<SnapServer>(
- MDS_RANK_NONE, "snaptable", true).load_and_dump(&io, &jf);
+ mds_role_t(), "snaptable", true).load_and_dump(&io, &jf);
jf.dump_int("result", r);
}
jf.close_section();
derr << "Bad ino '" << ino_str << "'" << dendl;
return -EINVAL;
}
- r = apply_rank_fn([this, ino](mds_rank_t rank, Formatter *f) -> int {
+ r = apply_role_fn([this, ino](mds_role_t rank, Formatter *f) -> int {
return InoTableHandler(rank).take_inos(&io, ino, f);
}, &jf);
} else {
#include "MDSUtility.h"
+#include "RoleSelector.h"
#include "include/rados/librados.hpp"
-
/**
* Command line tool for debugging the backing store of
* MDSTable instances.
class TableTool : public MDSUtility
{
private:
- mds_rank_t rank;
+ MDSRoleSelector role_selector;
// I/O handles
librados::Rados rados;
librados::IoCtx io;
- int apply_rank_fn(std::function<int(mds_rank_t, Formatter *)> fptr, Formatter *f);
+ int apply_role_fn(std::function<int(mds_role_t, Formatter *)> fptr, Formatter *f);
public:
void usage();
- TableTool() :
- rank(MDS_RANK_NONE) {}
int main(std::vector<const char*> &argv);
};
+
projects / ceph.git / commitdiff