it's not used.
Signed-off-by: Kefu Chai <kchai@redhat.com>
}
string prefix;
try {
- cmd_getval(m_cct, cmdmap, "format", format);
- cmd_getval(m_cct, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "format", format);
+ cmd_getval(cmdmap, "prefix", prefix);
} catch (const bad_cmd_get& e) {
return on_finish(-EINVAL, "invalid json, missing format and/or prefix",
empty);
command == "perf dump") {
std::string logger;
std::string counter;
- cmd_getval(this, cmdmap, "logger", logger);
- cmd_getval(this, cmdmap, "counter", counter);
+ cmd_getval(cmdmap, "logger", logger);
+ cmd_getval(cmdmap, "counter", counter);
_perf_counters_collection->dump_formatted(f, false, logger, counter);
}
else if (command == "perfcounters_schema" || command == "2" ||
else if (command == "perf histogram dump") {
std::string logger;
std::string counter;
- cmd_getval(this, cmdmap, "logger", logger);
- cmd_getval(this, cmdmap, "counter", counter);
+ cmd_getval(cmdmap, "logger", logger);
+ cmd_getval(cmdmap, "counter", counter);
_perf_counters_collection->dump_formatted_histograms(f, false, logger,
counter);
}
std::string var;
std::string section(command);
f->open_object_section(section.c_str());
- if (!cmd_getval(this, cmdmap, "var", var)) {
+ if (!cmd_getval(cmdmap, "var", var)) {
f->dump_string("error", "syntax error: 'perf reset <var>'");
} else {
if(!_perf_counters_collection->reset(var))
}
else if (command == "config unset") {
std::string var;
- if (!(cmd_getval(this, cmdmap, "var", var))) {
+ if (!(cmd_getval(cmdmap, "var", var))) {
r = -EINVAL;
} else {
r = _conf.rm_val(var.c_str());
std::string var;
std::vector<std::string> val;
- if (!(cmd_getval(this, cmdmap, "var", var)) ||
- !(cmd_getval(this, cmdmap, "val", val))) {
+ if (!(cmd_getval(cmdmap, "var", var)) ||
+ !(cmd_getval(cmdmap, "val", val))) {
r = -EINVAL;
} else {
// val may be multiple words
}
} else if (command == "config get") {
std::string var;
- if (!cmd_getval(this, cmdmap, "var", var)) {
+ if (!cmd_getval(cmdmap, "var", var)) {
r = -EINVAL;
} else {
char buf[4096];
}
} else if (command == "config help") {
std::string var;
- if (cmd_getval(this, cmdmap, "var", var)) {
+ if (cmd_getval(cmdmap, "var", var)) {
// Output a single one
std::string key = ConfFile::normalize_key_name(var);
auto schema = _conf.get_schema(key);
}
else if (command == "injectargs") {
vector<string> argsvec;
- cmd_getval(this, cmdmap, "injected_args", argsvec);
+ cmd_getval(cmdmap, "injected_args", argsvec);
if (!argsvec.empty()) {
string args = joinify<std::string>(argsvec.begin(),
argsvec.end(),
{
Value v;
try {
- if (!cmd_getval(cct, cmdmap, string(name), v)) {
+ if (!cmd_getval(cmdmap, string(name), v)) {
if constexpr (is_vector) {
// an empty list is acceptable.
return true;
});
}
-bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
+bool cmd_getval(const cmdmap_t& cmdmap,
const std::string& k, bool& val)
{
/*
}
};
-bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
+bool cmd_getval(const cmdmap_t& cmdmap,
const std::string& k, bool& val);
template <typename T>
-bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
+bool cmd_getval(const cmdmap_t& cmdmap,
const std::string& k, T& val)
{
if (cmdmap.count(k)) {
template <typename T>
bool cmd_getval(
- CephContext *cct, const cmdmap_t& cmdmap, const std::string& k,
+ const cmdmap_t& cmdmap, const std::string& k,
T& val, const T& defval)
{
if (cmdmap.count(k)) {
r = -EOPNOTSUPP;
} else {
string heapcmd;
- cmd_getval(cct, cmdmap, "heapcmd", heapcmd);
+ cmd_getval(cmdmap, "heapcmd", heapcmd);
vector<string> heapcmd_vec;
get_str_vec(heapcmd, heapcmd_vec);
string value;
- if (cmd_getval(cct, cmdmap, "value", value)) {
+ if (cmd_getval(cmdmap, "value", value)) {
heapcmd_vec.push_back(value);
}
ceph_heap_profiler_handle_command(heapcmd_vec, ss);
}
} else if (command == "cpu_profiler") {
string arg;
- cmd_getval(cct, cmdmap, "arg", arg);
+ cmd_getval(cmdmap, "arg", arg);
vector<string> argvec;
get_str_vec(arg, argvec);
cpu_profiler_handle_command(argvec, ss);
}
} else if (command == "osdmap barrier") {
int64_t target_epoch = 0;
- bool got_val = cmd_getval(g_ceph_context, cmdmap, "target_epoch", target_epoch);
+ bool got_val = cmd_getval(cmdmap, "target_epoch", target_epoch);
if (!got_val) {
ss << "no target epoch given";
command == "client ls") {
std::lock_guard l(mds_lock);
std::vector<std::string> filter_args;
- cmd_getval(g_ceph_context, cmdmap, "filters", filter_args);
+ cmd_getval(cmdmap, "filters", filter_args);
SessionFilter filter;
r = filter.parse(filter_args, &ss);
if (r != 0) {
command == "client evict") {
std::lock_guard l(mds_lock);
std::vector<std::string> filter_args;
- cmd_getval(g_ceph_context, cmdmap, "filters", filter_args);
+ cmd_getval(cmdmap, "filters", filter_args);
SessionFilter filter;
r = filter.parse(filter_args, &ss);
return;
} else if (command == "session kill") {
std::string client_id;
- if (!cmd_getval(g_ceph_context, cmdmap, "client_id", client_id)) {
+ if (!cmd_getval(cmdmap, "client_id", client_id)) {
ss << "Invalid client_id specified";
r = -ENOENT;
goto out;
std::string option;
std::string value;
- cmd_getval(g_ceph_context, cmdmap, "client_id", client_id);
- cmd_getval(g_ceph_context, cmdmap, "option", option);
- bool got_value = cmd_getval(g_ceph_context, cmdmap, "value", value);
+ cmd_getval(cmdmap, "client_id", client_id);
+ cmd_getval(cmdmap, "option", option);
+ bool got_value = cmd_getval(cmdmap, "value", value);
std::lock_guard l(mds_lock);
r = config_client(client_id, !got_value, option, value, ss);
string path;
string tag;
vector<string> scrubop_vec;
- cmd_getval(g_ceph_context, cmdmap, "scrubops", scrubop_vec);
- cmd_getval(g_ceph_context, cmdmap, "path", path);
- cmd_getval(g_ceph_context, cmdmap, "tag", tag);
+ cmd_getval(cmdmap, "scrubops", scrubop_vec);
+ cmd_getval(cmdmap, "path", path);
+ cmd_getval(cmdmap, "tag", tag);
/* Multiple MDS scrub is not currently supported. See also: https://tracker.ceph.com/issues/12274 */
if (mdsmap->get_max_mds() > 1) {
command_scrub_status(f);
} else if (command == "tag path") {
string path;
- cmd_getval(g_ceph_context, cmdmap, "path", path);
+ cmd_getval(cmdmap, "path", path);
string tag;
- cmd_getval(g_ceph_context, cmdmap, "tag", tag);
+ cmd_getval(cmdmap, "tag", tag);
command_tag_path(f, path, tag);
} else if (command == "flush_path") {
string path;
- cmd_getval(g_ceph_context, cmdmap, "path", path);
+ cmd_getval(cmdmap, "path", path);
command_flush_path(f, path);
} else if (command == "flush journal") {
command_flush_journal(f);
command_get_subtrees(f);
} else if (command == "export dir") {
string path;
- if(!cmd_getval(g_ceph_context, cmdmap, "path", path)) {
+ if(!cmd_getval(cmdmap, "path", path)) {
ss << "malformed path";
r = -EINVAL;
goto out;
}
int64_t rank;
- if(!cmd_getval(g_ceph_context, cmdmap, "rank", rank)) {
+ if(!cmd_getval(cmdmap, "rank", rank)) {
ss << "malformed rank";
r = -EINVAL;
goto out;
} else if (command == "dump cache") {
std::lock_guard l(mds_lock);
string path;
- if (!cmd_getval(g_ceph_context, cmdmap, "path", path)) {
+ if (!cmd_getval(cmdmap, "path", path)) {
r = mdcache->dump_cache(f);
} else {
r = mdcache->dump_cache(path);
}
} else if (command == "cache drop") {
int64_t timeout = 0;
- cmd_getval(g_ceph_context, cmdmap, "timeout", timeout);
+ cmd_getval(cmdmap, "timeout", timeout);
finisher->queue(
new LambdaContext(
[this, on_finish, f, timeout](int r) {
} else if (command == "dump snaps") {
std::lock_guard l(mds_lock);
string server;
- cmd_getval(g_ceph_context, cmdmap, "server", server);
+ cmd_getval(cmdmap, "server", server);
if (server == "--server") {
if (mdsmap->get_tableserver() == whoami) {
snapserver->dump(f);
} else if (command == "damage rm") {
std::lock_guard l(mds_lock);
damage_entry_id_t id = 0;
- if (!cmd_getval(g_ceph_context, cmdmap, "damage_id", (int64_t&)id)) {
+ if (!cmd_getval(cmdmap, "damage_id", (int64_t&)id)) {
r = -EINVAL;
goto out;
}
{
std::string root;
int64_t depth;
- cmd_getval(g_ceph_context, cmdmap, "root", root);
- if (!cmd_getval(g_ceph_context, cmdmap, "depth", depth))
+ cmd_getval(cmdmap, "root", root);
+ if (!cmd_getval(cmdmap, "depth", depth))
depth = -1;
std::lock_guard l(mds_lock);
CInode *in = mdcache->cache_traverse(filepath(root.c_str()));
std::ostream &ss)
{
std::string path;
- bool got = cmd_getval(g_ceph_context, cmdmap, "path", path);
+ bool got = cmd_getval(cmdmap, "path", path);
if (!got) {
ss << "missing path argument";
return NULL;
}
std::string frag_str;
- if (!cmd_getval(g_ceph_context, cmdmap, "frag", frag_str)) {
+ if (!cmd_getval(cmdmap, "frag", frag_str)) {
ss << "missing frag argument";
return NULL;
}
{
std::lock_guard l(mds_lock);
int64_t by = 0;
- if (!cmd_getval(g_ceph_context, cmdmap, "bits", by)) {
+ if (!cmd_getval(cmdmap, "bits", by)) {
ss << "missing bits argument";
return false;
}
{
std::lock_guard l(mds_lock);
std::string path;
- bool got = cmd_getval(g_ceph_context, cmdmap, "path", path);
+ bool got = cmd_getval(cmdmap, "path", path);
if (!got) {
ss << "missing path argument";
return false;
}
std::string frag_str;
- if (!cmd_getval(g_ceph_context, cmdmap, "frag", frag_str)) {
+ if (!cmd_getval(cmdmap, "frag", frag_str)) {
ss << "missing frag argument";
return false;
}
{
std::lock_guard l(mds_lock);
std::string path;
- bool got = cmd_getval(g_ceph_context, cmdmap, "path", path);
+ bool got = cmd_getval(cmdmap, "path", path);
if (!got) {
ss << "missing path argument";
return false;
{
std::lock_guard l(mds_lock);
int64_t number;
- bool got = cmd_getval(g_ceph_context, cmdmap, "number", number);
+ bool got = cmd_getval(cmdmap, "number", number);
if (!got) {
ss << "missing inode number";
return;
if (admin_command == "dump_osd_network") {
int64_t value = 0;
// Default to health warning level if nothing specified
- if (!(cmd_getval(g_ceph_context, cmdmap, "value", value))) {
+ if (!(cmd_getval(cmdmap, "value", value))) {
// Convert milliseconds to microseconds
value = static_cast<int64_t>(g_ceph_context->_conf.get_val<double>("mon_warn_on_slow_ping_time")) * 1000;
if (value == 0) {
continue;
if (p->first == "caps") {
vector<string> cv;
- if (cmd_getval(g_ceph_context, cmdmap, "caps", cv) &&
+ if (cmd_getval(cmdmap, "caps", cv) &&
cv.size() % 2 == 0) {
for (unsigned i = 0; i < cv.size(); i += 2) {
string k = string("caps_") + cv[i];
}
{
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdctx->cmdmap, "format", format, string("plain"));
f.reset(Formatter::create(format));
}
string prefix;
- cmd_getval(cct, cmdctx->cmdmap, "prefix", prefix);
+ cmd_getval(cmdctx->cmdmap, "prefix", prefix);
dout(10) << "decoded-size=" << cmdctx->cmdmap.size() << " prefix=" << prefix << dendl;
if (prefix == "config set") {
std::string key;
std::string val;
- cmd_getval(cct, cmdctx->cmdmap, "key", key);
- cmd_getval(cct, cmdctx->cmdmap, "value", val);
+ cmd_getval(cmdctx->cmdmap, "key", key);
+ cmd_getval(cmdctx->cmdmap, "value", val);
r = cct->_conf.set_val(key, val, &ss);
if (r == 0) {
cct->_conf.apply_changes(nullptr);
pg_t pgid;
spg_t spgid;
string pgidstr;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "pgid", pgidstr);
+ cmd_getval(cmdctx->cmdmap, "pgid", pgidstr);
if (!pgid.parse(pgidstr.c_str())) {
ss << "invalid pgid '" << pgidstr << "'";
cmdctx->reply(-EINVAL, ss);
prefix == "osd deep-scrub" ||
prefix == "osd repair") {
string whostr;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "who", whostr);
+ cmd_getval(cmdctx->cmdmap, "who", whostr);
vector<string> pvec;
get_str_vec(prefix, pvec);
prefix == "osd pool deep-scrub" ||
prefix == "osd pool repair") {
vector<string> pool_names;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "who", pool_names);
+ cmd_getval(cmdctx->cmdmap, "who", pool_names);
if (pool_names.empty()) {
ss << "must specify one or more pool names";
cmdctx->reply(-EINVAL, ss);
prefix == "osd test-reweight-by-pg" ||
prefix == "osd test-reweight-by-utilization";
int64_t oload;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "oload", oload, int64_t(120));
+ cmd_getval(cmdctx->cmdmap, "oload", oload, int64_t(120));
set<int64_t> pools;
vector<string> poolnames;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "pools", poolnames);
+ cmd_getval(cmdctx->cmdmap, "pools", poolnames);
cluster_state.with_osdmap([&](const OSDMap& osdmap) {
for (const auto& poolname : poolnames) {
int64_t pool = osdmap.lookup_pg_pool_name(poolname);
}
double max_change = g_conf().get_val<double>("mon_reweight_max_change");
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "max_change", max_change);
+ cmd_getval(cmdctx->cmdmap, "max_change", max_change);
if (max_change <= 0.0) {
ss << "max_change " << max_change << " must be positive";
cmdctx->reply(-EINVAL, ss);
return true;
}
int64_t max_osds = g_conf().get_val<int64_t>("mon_reweight_max_osds");
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "max_osds", max_osds);
+ cmd_getval(cmdctx->cmdmap, "max_osds", max_osds);
if (max_osds <= 0) {
ss << "max_osds " << max_osds << " must be positive";
cmdctx->reply(-EINVAL, ss);
return true;
}
bool no_increasing = false;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "no_increasing", no_increasing);
+ cmd_getval(cmdctx->cmdmap, "no_increasing", no_increasing);
string out_str;
mempool::osdmap::map<int32_t, uint32_t> new_weights;
r = cluster_state.with_osdmap_and_pgmap([&](const OSDMap &osdmap, const PGMap& pgmap) {
}
} else if (prefix == "osd df") {
string method, filter;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "output_method", method);
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "filter", filter);
+ cmd_getval(cmdctx->cmdmap, "output_method", method);
+ cmd_getval(cmdctx->cmdmap, "filter", filter);
stringstream rs;
r = cluster_state.with_osdmap_and_pgmap([&](const OSDMap& osdmap, const PGMap& pgmap) {
// sanity check filter(s)
return true;
} else if (prefix == "osd pool stats") {
string pool_name;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "pool_name", pool_name);
+ cmd_getval(cmdctx->cmdmap, "pool_name", pool_name);
int64_t poolid = -ENOENT;
bool one_pool = false;
r = cluster_state.with_osdmap_and_pgmap([&](const OSDMap& osdmap, const PGMap& pg_map) {
int r = 0;
if (prefix == "osd safe-to-destroy") {
vector<string> ids;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "ids", ids);
+ cmd_getval(cmdctx->cmdmap, "ids", ids);
cluster_state.with_osdmap([&](const OSDMap& osdmap) {
r = osdmap.parse_osd_id_list(ids, &osds, &ss);
});
}
} else {
int64_t id;
- if (!cmd_getval(g_ceph_context, cmdctx->cmdmap, "id", id)) {
+ if (!cmd_getval(cmdctx->cmdmap, "id", id)) {
r = -EINVAL;
ss << "must specify OSD id";
} else {
if (r) {
bool force = false;
- cmd_getval(cct, cmdctx->cmdmap, "force", force);
+ cmd_getval(cmdctx->cmdmap, "force", force);
if (!force) {
// Backward compat
- cmd_getval(cct, cmdctx->cmdmap, "yes_i_really_mean_it", force);
+ cmd_getval(cmdctx->cmdmap, "yes_i_really_mean_it", force);
}
if (!force) {
ss << "\nYou can proceed by passing --force, but be warned that"
return true;
} else if (prefix == "osd ok-to-stop") {
vector<string> ids;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "ids", ids);
+ cmd_getval(cmdctx->cmdmap, "ids", ids);
set<int> osds;
int r;
cluster_state.with_osdmap([&](const OSDMap& osdmap) {
if (granularity == "pg") {
// covnert pg names to pgs, discard any invalid ones while at it
vector<string> pgids;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "pgid", pgids);
+ cmd_getval(cmdctx->cmdmap, "pgid", pgids);
for (auto& i : pgids) {
pg_t pgid;
if (!pgid.parse(i.c_str())) {
} else {
// per pool
vector<string> pool_names;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "who", pool_names);
+ cmd_getval(cmdctx->cmdmap, "who", pool_names);
if (pool_names.empty()) {
ss << "must specify one or more pool names";
cmdctx->reply(-EINVAL, ss);
} else if (prefix == "config show" ||
prefix == "config show-with-defaults") {
string who;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "who", who);
+ cmd_getval(cmdctx->cmdmap, "who", who);
auto [key, valid] = DaemonKey::parse(who);
if (!valid) {
ss << "invalid daemon name: use <type>.<id>";
int r = 0;
string name;
- if (cmd_getval(g_ceph_context, cmdctx->cmdmap, "key", name)) {
+ if (cmd_getval(cmdctx->cmdmap, "key", name)) {
auto p = daemon->config.find(name);
if (p != daemon->config.end() &&
!p->second.empty()) {
return true;
} else if (prefix == "device ls-by-daemon") {
string who;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "who", who);
+ cmd_getval(cmdctx->cmdmap, "who", who);
if (auto [k, valid] = DaemonKey::parse(who); !valid) {
ss << who << " is not a valid daemon name";
r = -EINVAL;
}
} else if (prefix == "device ls-by-host") {
string host;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "host", host);
+ cmd_getval(cmdctx->cmdmap, "host", host);
set<string> devids;
daemon_state.list_devids_by_server(host, &devids);
if (f) {
return true;
} else if (prefix == "device info") {
string devid;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "devid", devid);
+ cmd_getval(cmdctx->cmdmap, "devid", devid);
int r = 0;
ostringstream rs;
if (!daemon_state.with_device(devid,
return true;
} else if (prefix == "device set-life-expectancy") {
string devid;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "devid", devid);
+ cmd_getval(cmdctx->cmdmap, "devid", devid);
string from_str, to_str;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "from", from_str);
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "to", to_str);
+ cmd_getval(cmdctx->cmdmap, "from", from_str);
+ cmd_getval(cmdctx->cmdmap, "to", to_str);
utime_t from, to;
if (!from.parse(from_str)) {
ss << "unable to parse datetime '" << from_str << "'";
return true;
} else if (prefix == "device rm-life-expectancy") {
string devid;
- cmd_getval(g_ceph_context, cmdctx->cmdmap, "devid", devid);
+ cmd_getval(cmdctx->cmdmap, "devid", devid);
map<string,string> meta;
if (daemon_state.with_device_write(devid, [&meta] (DeviceState& dev) {
dev.rm_life_expectancy();
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
if (prefix == "auth add" ||
prefix == "auth del" ||
prefix == "auth rm" ||
// entity might not be supplied, but if it is, it should be valid
string entity_name;
- cmd_getval(g_ceph_context, cmdmap, "entity", entity_name);
+ cmd_getval(cmdmap, "entity", entity_name);
EntityName entity;
if (!entity_name.empty() && !entity.from_str(entity_name)) {
ss << "invalid entity_auth " << entity_name;
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
if (prefix == "auth export") {
string entity_name;
EntityName entity;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
MonSession *session = op->get_session();
return true;
}
- cmd_getval(g_ceph_context, cmdmap, "caps", caps_vec);
+ cmd_getval(cmdmap, "caps", caps_vec);
if ((caps_vec.size() % 2) != 0) {
ss << "bad capabilities request; odd number of arguments";
err = -EINVAL;
goto done;
}
- cmd_getval(g_ceph_context, cmdmap, "entity", entity_name);
+ cmd_getval(cmdmap, "entity", entity_name);
if (!entity_name.empty() && !entity.from_str(entity_name)) {
ss << "bad entity name";
err = -EINVAL;
return true;
} else if (prefix == "fs authorize") {
string filesystem;
- cmd_getval(g_ceph_context, cmdmap, "filesystem", filesystem);
+ cmd_getval(cmdmap, "filesystem", filesystem);
string mds_cap_string, osd_cap_string;
string osd_cap_wanted = "r";
return false;
}
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
string key;
- cmd_getval(g_ceph_context, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
if (prefix == "config-key get") {
ret = store_get(key, rdata);
bufferlist data;
string val;
- if (cmd_getval(g_ceph_context, cmdmap, "val", val)) {
+ if (cmd_getval(cmdmap, "val", val)) {
// they specified a value in the command instead of a file
data.append(val);
} else if (cmd->get_data_len() > 0) {
} else if (prefix == "config-key dump") {
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "key", prefix);
+ cmd_getval(cmdmap, "key", prefix);
stringstream tmp_ss;
store_dump(tmp_ss, prefix);
rdata.append(tmp_ss);
return true;
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
bufferlist odata;
if (prefix == "config help") {
stringstream ss;
string name;
- cmd_getval(g_ceph_context, cmdmap, "key", name);
+ cmd_getval(cmdmap, "key", name);
const Option *opt = g_conf().find_option(name);
if (!opt) {
opt = mon->mgrmon()->find_module_option(name);
}
} else if (prefix == "config get") {
string who, name;
- cmd_getval(g_ceph_context, cmdmap, "who", who);
+ cmd_getval(cmdmap, "who", who);
EntityName entity;
if (!entity.from_str(who) &&
device_class,
&src);
- if (cmd_getval(g_ceph_context, cmdmap, "key", name)) {
+ if (cmd_getval(cmdmap, "key", name)) {
const Option *opt = g_conf().find_option(name);
if (!opt) {
opt = mon->mgrmon()->find_module_option(name);
}
} else if (prefix == "config log") {
int64_t num = 10;
- cmd_getval(g_ceph_context, cmdmap, "num", num);
+ cmd_getval(cmdmap, "num", num);
ostringstream ds;
if (f) {
f->open_array_section("changesets");
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
bufferlist odata;
if (prefix == "config set" ||
string who;
string name, value;
bool force = false;
- cmd_getval(g_ceph_context, cmdmap, "who", who);
- cmd_getval(g_ceph_context, cmdmap, "name", name);
- cmd_getval(g_ceph_context, cmdmap, "value", value);
- cmd_getval(g_ceph_context, cmdmap, "force", force);
+ cmd_getval(cmdmap, "who", who);
+ cmd_getval(cmdmap, "name", name);
+ cmd_getval(cmdmap, "value", value);
+ cmd_getval(cmdmap, "force", force);
if (prefix == "config set" && !force) {
const Option *opt = g_conf().find_option(name);
goto update;
} else if (prefix == "config reset") {
int64_t revert_to = -1;
- cmd_getval(g_ceph_context, cmdmap, "num", revert_to);
+ cmd_getval(cmdmap, "num", revert_to);
if (revert_to < 0 ||
revert_to > (int64_t)version) {
err = -EINVAL;
std::stringstream &ss) override
{
string flag_name;
- cmd_getval(g_ceph_context, cmdmap, "flag_name", flag_name);
+ cmd_getval(cmdmap, "flag_name", flag_name);
string flag_val;
- cmd_getval(g_ceph_context, cmdmap, "val", flag_val);
+ cmd_getval(cmdmap, "val", flag_val);
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (flag_name == "enable_multiple") {
bool flag_bool = false;
}
std::string fs_name;
- if (!cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name) || fs_name.empty()) {
+ if (!cmd_getval(cmdmap, "fs_name", fs_name) || fs_name.empty()) {
ss << "Missing filesystem name";
return -EINVAL;
}
ceph_assert(m_paxos->is_plugged());
string metadata_name;
- cmd_getval(g_ceph_context, cmdmap, "metadata", metadata_name);
+ cmd_getval(cmdmap, "metadata", metadata_name);
int64_t metadata = mon->osdmon()->osdmap.lookup_pg_pool_name(metadata_name);
if (metadata < 0) {
ss << "pool '" << metadata_name << "' does not exist";
}
string data_name;
- cmd_getval(g_ceph_context, cmdmap, "data", data_name);
+ cmd_getval(cmdmap, "data", data_name);
int64_t data = mon->osdmon()->osdmap.lookup_pg_pool_name(data_name);
if (data < 0) {
ss << "pool '" << data_name << "' does not exist";
}
string fs_name;
- cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name);
+ cmd_getval(cmdmap, "fs_name", fs_name);
if (fs_name.empty()) {
// Ensure fs name is not empty so that we can implement
// commmands that refer to FS by name in future.
}
bool force = false;
- cmd_getval(g_ceph_context,cmdmap, "force", force);
+ cmd_getval(cmdmap, "force", force);
const pool_stat_t *stat = mon->mgrstatmon()->get_pool_stat(metadata);
if (stat) {
const std::vector<int64_t> &data_pools = fs->mds_map.get_data_pools();
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap,
+ cmd_getval(cmdmap,
"allow_dangerous_metadata_overlay", sure);
if ((std::find(data_pools.begin(), data_pools.end(), data) != data_pools.end()
std::stringstream &ss) override
{
std::string fs_name;
- if (!cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name) || fs_name.empty()) {
+ if (!cmd_getval(cmdmap, "fs_name", fs_name) || fs_name.empty()) {
ss << "Missing filesystem name";
return -EINVAL;
}
}
string var;
- if (!cmd_getval(g_ceph_context, cmdmap, "var", var) || var.empty()) {
+ if (!cmd_getval(cmdmap, "var", var) || var.empty()) {
ss << "Invalid variable";
return -EINVAL;
}
string val;
string interr;
int64_t n = 0;
- if (!cmd_getval(g_ceph_context, cmdmap, "val", val)) {
+ if (!cmd_getval(cmdmap, "val", val)) {
return -EINVAL;
}
// we got a string. see if it contains an int.
if (enable_inline) {
bool confirm = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_really_mean_it", confirm);
+ cmd_getval(cmdmap, "yes_i_really_really_mean_it", confirm);
if (!confirm) {
ss << "Inline data support is deprecated and will be removed in a future release. "
<< "Add --yes-i-really-really-mean-it if you are certain you want this enabled.";
}
string confirm;
- if (!cmd_getval(g_ceph_context, cmdmap, "confirm", confirm) ||
+ if (!cmd_getval(cmdmap, "confirm", confirm) ||
confirm != "--yes-i-am-really-a-mds") {
ss << "Warning! This command is for MDS only. Do not run it manually";
return -EPERM;
ceph_assert(m_paxos->is_plugged());
string poolname;
- cmd_getval(g_ceph_context, cmdmap, "pool", poolname);
+ cmd_getval(cmdmap, "pool", poolname);
std::string fs_name;
- if (!cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name)
+ if (!cmd_getval(cmdmap, "fs_name", fs_name)
|| fs_name.empty()) {
ss << "Missing filesystem name";
return -EINVAL;
std::stringstream &ss) override
{
std::string fs_name;
- cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name);
+ cmd_getval(cmdmap, "fs_name", fs_name);
auto fs = fsmap.get_filesystem(fs_name);
if (fs == nullptr) {
ss << "filesystem '" << fs_name << "' does not exist";
// (redundant while there is only one FS, but command
// syntax should apply to multi-FS future)
string fs_name;
- cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name);
+ cmd_getval(cmdmap, "fs_name", fs_name);
auto fs = fsmap.get_filesystem(fs_name);
if (fs == nullptr) {
// Consider absence success to make deletes idempotent
// Check for confirmation flag
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
ss << "this is a DESTRUCTIVE operation and will make data in your filesystem permanently" \
" inaccessible. Add --yes-i-really-mean-it if you are sure you wish to continue.";
std::stringstream &ss) override
{
string fs_name;
- cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name);
+ cmd_getval(cmdmap, "fs_name", fs_name);
auto fs = fsmap.get_filesystem(fs_name);
if (fs == nullptr) {
ss << "filesystem '" << fs_name << "' does not exist";
// Check for confirmation flag
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
ss << "this is a potentially destructive operation, only for use by experts in disaster recovery. "
"Add --yes-i-really-mean-it if you are sure you wish to continue.";
std::stringstream &ss) override
{
string poolname;
- cmd_getval(g_ceph_context, cmdmap, "pool", poolname);
+ cmd_getval(cmdmap, "pool", poolname);
std::string fs_name;
- if (!cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name)
+ if (!cmd_getval(cmdmap, "fs_name", fs_name)
|| fs_name.empty()) {
ss << "Missing filesystem name";
return -EINVAL;
// more sanity checks
try {
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
} catch (const bad_cmd_get& e) {
mon->reply_command(op, -EINVAL, e.what(), rdata, get_last_committed());
return true;
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
int r = 0;
if (prefix == "health mute") {
string code;
bool sticky = false;
- if (!cmd_getval(g_ceph_context, cmdmap, "code", code) ||
+ if (!cmd_getval(cmdmap, "code", code) ||
code == "") {
r = -EINVAL;
ss << "must specify an alert code to mute";
goto out;
}
- cmd_getval(g_ceph_context, cmdmap, "sticky", sticky);
+ cmd_getval(cmdmap, "sticky", sticky);
string ttl_str;
utime_t ttl;
- if (cmd_getval(g_ceph_context, cmdmap, "ttl", ttl_str)) {
+ if (cmd_getval(cmdmap, "ttl", ttl_str)) {
auto secs = parse_timespan(ttl_str);
if (secs == 0s) {
r = -EINVAL;
m.count = count;
} else if (prefix == "health unmute") {
string code;
- if (cmd_getval(g_ceph_context, cmdmap, "code", code)) {
+ if (cmd_getval(cmdmap, "code", code)) {
pending_mutes.erase(code);
} else {
pending_mutes.clear();
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
if (prefix == "log last") {
int64_t num = 20;
- cmd_getval(g_ceph_context, cmdmap, "num", num);
+ cmd_getval(cmdmap, "num", num);
if (f) {
f->open_array_section("tail");
}
std::string level_str;
clog_type level;
- if (cmd_getval(g_ceph_context, cmdmap, "level", level_str)) {
+ if (cmd_getval(cmdmap, "level", level_str)) {
level = LogEntry::str_to_level(level_str);
if (level == CLOG_UNKNOWN) {
ss << "Invalid severity '" << level_str << "'";
}
std::string channel;
- if (!cmd_getval(g_ceph_context, cmdmap, "channel", channel)) {
+ if (!cmd_getval(cmdmap, "channel", channel)) {
channel = CLOG_CHANNEL_DEFAULT;
}
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
MonSession *session = op->get_session();
if (!session) {
if (prefix == "log") {
vector<string> logtext;
- cmd_getval(g_ceph_context, cmdmap, "logtext", logtext);
+ cmd_getval(cmdmap, "logtext", logtext);
LogEntry le;
le.rank = m->get_orig_source();
le.addrs.v.push_back(m->get_orig_source_addr());
* Specialized implementation of cmd_getval to allow us to parse
* out strongly-typedef'd types
*/
-template<> bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
+template<> bool cmd_getval(const cmdmap_t& cmdmap,
const std::string& k, mds_gid_t &val)
{
- return cmd_getval(cct, cmdmap, k, (int64_t&)val);
+ return cmd_getval(cmdmap, k, (int64_t&)val);
}
-template<> bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
+template<> bool cmd_getval(const cmdmap_t& cmdmap,
const std::string& k, mds_rank_t &val)
{
- return cmd_getval(cct, cmdmap, k, (int64_t&)val);
+ return cmd_getval(cmdmap, k, (int64_t&)val);
}
-template<> bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
+template<> bool cmd_getval(const cmdmap_t& cmdmap,
const std::string& k, MDSMap::DaemonState &val)
{
- return cmd_getval(cct, cmdmap, k, (int64_t&)val);
+ return cmd_getval(cmdmap, k, (int64_t&)val);
}
// my methods
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
std::unique_ptr<Formatter> f(Formatter::create(format));
MonSession *session = op->get_session();
r = 0;
} else if (prefix == "mds ok-to-stop") {
vector<string> ids;
- if (!cmd_getval(g_ceph_context, cmdmap, "ids", ids)) {
+ if (!cmd_getval(cmdmap, "ids", ids)) {
r = -EINVAL;
ss << "must specify mds id";
goto out;
const FSMap *fsmapp = &fsmap;
FSMap dummy;
- if (cmd_getval(g_ceph_context, cmdmap, "epoch", epocharg)) {
+ if (cmd_getval(cmdmap, "epoch", epocharg)) {
epoch = epocharg;
bufferlist b;
int err = get_version(epoch, b);
f.reset(Formatter::create("json-pretty"));
string who;
- bool all = !cmd_getval(g_ceph_context, cmdmap, "who", who);
+ bool all = !cmd_getval(cmdmap, "who", who);
dout(1) << "all = " << all << dendl;
if (all) {
r = 0;
if (!f)
f.reset(Formatter::create("json-pretty"));
string field;
- cmd_getval(g_ceph_context, cmdmap, "property", field);
+ cmd_getval(cmdmap, "property", field);
count_metadata(field, f.get());
f->flush(ds);
r = 0;
r = 0;
} else if (prefix == "fs get") {
string fs_name;
- cmd_getval(g_ceph_context, cmdmap, "fs_name", fs_name);
+ cmd_getval(cmdmap, "fs_name", fs_name);
const auto &fs = fsmap.get_filesystem(fs_name);
if (fs == nullptr) {
ss << "filesystem '" << fs_name << "' not found";
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
/* Refuse access if message not associated with a valid session */
MonSession *session = op->get_session();
op->mark_mdsmon_event(__func__);
int r = 0;
string whostr;
- cmd_getval(g_ceph_context, cmdmap, "role", whostr);
+ cmd_getval(cmdmap, "role", whostr);
if (prefix == "mds set_state") {
mds_gid_t gid;
- if (!cmd_getval(g_ceph_context, cmdmap, "gid", gid)) {
+ if (!cmd_getval(cmdmap, "gid", gid)) {
ss << "error parsing 'gid' value '"
<< cmd_vartype_stringify(cmdmap.at("gid")) << "'";
return -EINVAL;
}
MDSMap::DaemonState state;
- if (!cmd_getval(g_ceph_context, cmdmap, "state", state)) {
+ if (!cmd_getval(cmdmap, "state", state)) {
ss << "error parsing 'state' string value '"
<< cmd_vartype_stringify(cmdmap.at("state")) << "'";
return -EINVAL;
}
} else if (prefix == "mds fail") {
string who;
- cmd_getval(g_ceph_context, cmdmap, "role_or_gid", who);
+ cmd_getval(cmdmap, "role_or_gid", who);
MDSMap::mds_info_t failed_info;
r = fail_mds(fsmap, ss, who, &failed_info);
}
} else if (prefix == "mds rm") {
mds_gid_t gid;
- if (!cmd_getval(g_ceph_context, cmdmap, "gid", gid)) {
+ if (!cmd_getval(cmdmap, "gid", gid)) {
ss << "error parsing 'gid' value '"
<< cmd_vartype_stringify(cmdmap.at("gid")) << "'";
return -EINVAL;
}
} else if (prefix == "mds rmfailed") {
bool confirm = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", confirm);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", confirm);
if (!confirm) {
ss << "WARNING: this can make your filesystem inaccessible! "
"Add --yes-i-really-mean-it if you are sure you wish to continue.";
}
std::string role_str;
- cmd_getval(g_ceph_context, cmdmap, "role", role_str);
+ cmd_getval(cmdmap, "role", role_str);
mds_role_t role;
int r = fsmap.parse_role(role_str, &role, ss);
if (r < 0) {
return 0;
} else if (prefix == "mds compat rm_compat") {
int64_t f;
- if (!cmd_getval(g_ceph_context, cmdmap, "feature", f)) {
+ if (!cmd_getval(cmdmap, "feature", f)) {
ss << "error parsing feature value '"
<< cmd_vartype_stringify(cmdmap.at("feature")) << "'";
return -EINVAL;
r = 0;
} else if (prefix == "mds compat rm_incompat") {
int64_t f;
- if (!cmd_getval(g_ceph_context, cmdmap, "feature", f)) {
+ if (!cmd_getval(cmdmap, "feature", f)) {
ss << "error parsing feature value '"
<< cmd_vartype_stringify(cmdmap.at("feature")) << "'";
return -EINVAL;
r = 0;
} else if (prefix == "mds repaired") {
std::string role_str;
- cmd_getval(g_ceph_context, cmdmap, "role", role_str);
+ cmd_getval(cmdmap, "role", role_str);
mds_role_t role;
r = fsmap.parse_role(role_str, &role, ss);
if (r < 0) {
r = 0;
} else if (prefix == "mds freeze") {
std::string who;
- cmd_getval(g_ceph_context, cmdmap, "role_or_gid", who);
+ cmd_getval(cmdmap, "role_or_gid", who);
mds_gid_t gid = gid_from_arg(fsmap, who, ss);
if (gid == MDS_GID_NONE) {
return -EINVAL;
bool freeze = false;
{
std::string str;
- cmd_getval(g_ceph_context, cmdmap, "val", str);
+ cmd_getval(cmdmap, "val", str);
if ((r = parse_bool(str, &freeze, ss)) != 0) {
return r;
}
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty",
"json-pretty"));
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
int r = 0;
if (prefix == "mgr dump") {
int64_t epoch = 0;
- cmd_getval(g_ceph_context, cmdmap, "epoch", epoch, (int64_t)map.get_epoch());
+ cmd_getval(cmdmap, "epoch", epoch, (int64_t)map.get_epoch());
if (epoch == (int64_t)map.get_epoch()) {
f->dump_object("mgrmap", map);
} else {
f->flush(rdata);
} else if (prefix == "mgr metadata") {
string name;
- cmd_getval(g_ceph_context, cmdmap, "who", name);
+ cmd_getval(cmdmap, "who", name);
if (name.size() > 0 && !map.have_name(name)) {
ss << "mgr." << name << " does not exist";
r = -ENOENT;
goto reply;
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty", "json-pretty"));
if (name.size()) {
f->open_object_section("mgr_metadata");
r = 0;
} else if (prefix == "mgr count-metadata") {
string field;
- cmd_getval(g_ceph_context, cmdmap, "property", field);
+ cmd_getval(cmdmap, "property", field);
count_metadata(field, f.get());
f->flush(rdata);
r = 0;
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
int r = 0;
if (prefix == "mgr fail") {
string who;
- cmd_getval(g_ceph_context, cmdmap, "who", who);
+ cmd_getval(cmdmap, "who", who);
std::string err;
uint64_t gid = strict_strtol(who.c_str(), 10, &err);
}
} else if (prefix == "mgr module enable") {
string module;
- cmd_getval(g_ceph_context, cmdmap, "module", module);
+ cmd_getval(cmdmap, "module", module);
if (module.empty()) {
r = -EINVAL;
goto out;
goto out;
}
string force;
- cmd_getval(g_ceph_context, cmdmap, "force", force);
+ cmd_getval(cmdmap, "force", force);
if (!pending_map.all_support_module(module) &&
force != "--force") {
ss << "all mgr daemons do not support module '" << module << "', pass "
pending_map.modules.insert(module);
} else if (prefix == "mgr module disable") {
string module;
- cmd_getval(g_ceph_context, cmdmap, "module", module);
+ cmd_getval(cmdmap, "module", module);
if (module.empty()) {
r = -EINVAL;
goto out;
_quorum_status(f, out);
} else if (command == "sync_force") {
string validate;
- if ((!cmd_getval(g_ceph_context, cmdmap, "validate", validate)) ||
+ if ((!cmd_getval(cmdmap, "validate", validate)) ||
(validate != "--yes-i-really-mean-it")) {
err << "are you SURE? this will mean the monitor store will be erased "
"the next time the monitor is restarted. pass "
}
} else if (command == "quorum") {
string quorumcmd;
- cmd_getval(g_ceph_context, cmdmap, "quorumcmd", quorumcmd);
+ cmd_getval(cmdmap, "quorumcmd", quorumcmd);
if (quorumcmd == "exit") {
start_election();
elector.stop_participating();
}
} else if (command == "smart") {
string want_devid;
- cmd_getval(cct, cmdmap, "devid", want_devid);
+ cmd_getval(cmdmap, "devid", want_devid);
string devname = store->get_devname();
set<string> devnames;
goto abort;
}
string cmd;
- if (!cmd_getval(cct, cmdmap, "heapcmd", cmd)) {
+ if (!cmd_getval(cmdmap, "heapcmd", cmd)) {
err << "unable to get value for command \"" << cmd << "\"";
r = -EINVAL;
goto abort;
std::vector<std::string> cmd_vec;
get_str_vec(cmd, cmd_vec);
string val;
- if (cmd_getval(cct, cmdmap, "value", val)) {
+ if (cmd_getval(cmdmap, "value", val)) {
cmd_vec.push_back(val);
}
ceph_heap_profiler_handle_command(cmd_vec, out);
entity_addrvec_t addrs;
string addrstr;
- if (cmd_getval(g_ceph_context, cmdmap, "addr", addrstr)) {
+ if (cmd_getval(cmdmap, "addr", addrstr)) {
dout(10) << "_add_bootstrap_peer_hint '" << cmd << "' addr '"
<< addrstr << "'" << dendl;
addrs.v[0].set_type(entity_addr_t::TYPE_MSGR2);
}
}
- } else if (cmd_getval(g_ceph_context, cmdmap, "addrv", addrstr)) {
+ } else if (cmd_getval(cmdmap, "addrv", addrstr)) {
dout(10) << "_add_bootstrap_peer_hintv '" << cmd << "' addrv '"
<< addrstr << "'" << dendl;
const char *end = 0;
continue;
if (p->first == "caps") {
vector<string> cv;
- if (cmd_getval(g_ceph_context, cmdmap, "caps", cv) &&
+ if (cmd_getval(cmdmap, "caps", cv) &&
cv.size() % 2 == 0) {
for (unsigned i = 0; i < cv.size(); i += 2) {
string k = string("caps_") + cv[i];
map<string,string> param_str_map;
_generate_command_map(cmdmap, param_str_map);
string prefix;
- if (!cmd_getval(g_ceph_context, cmdmap, "prefix", prefix)) {
+ if (!cmd_getval(cmdmap, "prefix", prefix)) {
return reply_tell_command(op, -EINVAL, "no prefix");
}
if (auto cmd = _get_moncommand(prefix,
// check return value. If no prefix parameter provided,
// return value will be false, then return error info.
- if (!cmd_getval(g_ceph_context, cmdmap, "prefix", prefix)) {
+ if (!cmd_getval(cmdmap, "prefix", prefix)) {
reply_command(op, -EINVAL, "command prefix not found", 0);
return;
}
dout(0) << "handle_command " << *m << dendl;
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
get_str_vec(prefix, fullcmd);
prefix == "health" ||
prefix == "df") {
string detail;
- cmd_getval(g_ceph_context, cmdmap, "detail", detail);
+ cmd_getval(cmdmap, "detail", detail);
if (prefix == "status") {
// get_cluster_status handles f == NULL
f->dump_stream("timestamp") << ceph_clock_now();
vector<string> tagsvec;
- cmd_getval(g_ceph_context, cmdmap, "tags", tagsvec);
+ cmd_getval(cmdmap, "tags", tagsvec);
string tagstr = str_join(tagsvec, " ");
if (!tagstr.empty())
tagstr = tagstr.substr(0, tagstr.find_last_of(' '));
r = 0;
} else if (prefix == "osd last-stat-seq") {
int64_t osd;
- cmd_getval(g_ceph_context, cmdmap, "id", osd);
+ cmd_getval(cmdmap, "id", osd);
uint64_t seq = mgrstatmon()->get_last_osd_stat_seq(osd);
if (f) {
f->dump_unsigned("seq", seq);
r = 0;
} else if (prefix == "node ls") {
string node_type("all");
- cmd_getval(g_ceph_context, cmdmap, "type", node_type);
+ cmd_getval(cmdmap, "type", node_type);
if (!f)
f.reset(Formatter::create("json-pretty"));
if (node_type == "all") {
f.reset(Formatter::create("json-pretty"));
string name;
- bool all = !cmd_getval(g_ceph_context, cmdmap, "id", name);
+ bool all = !cmd_getval(cmdmap, "id", name);
if (!all) {
// Dump a single mon's metadata
int mon = monmap->get_rank(name);
if (!f)
f.reset(Formatter::create("json-pretty"));
string field;
- cmd_getval(g_ceph_context, cmdmap, "property", field);
+ cmd_getval(cmdmap, "property", field);
count_metadata(field, f.get());
f->flush(ds);
rdata.append(ds);
r = 0;
} else if (prefix == "mon ok-to-stop") {
vector<string> ids;
- if (!cmd_getval(g_ceph_context, cmdmap, "ids", ids)) {
+ if (!cmd_getval(cmdmap, "ids", ids)) {
r = -EINVAL;
goto out;
}
r = 0;
} else if (prefix == "mon ok-to-rm") {
string id;
- if (!cmd_getval(g_ceph_context, cmdmap, "id", id)) {
+ if (!cmd_getval(cmdmap, "id", id)) {
r = -EINVAL;
rs = "must specify a monitor id";
goto out;
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
MonSession *session = op->get_session();
if (!session) {
}
string format;
- cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
if (prefix == "mon stat") {
epoch_t epoch;
int64_t epochnum;
- cmd_getval(g_ceph_context, cmdmap, "epoch", epochnum, (int64_t)0);
+ cmd_getval(cmdmap, "epoch", epochnum, (int64_t)0);
epoch = epochnum;
MonMap *p = mon->monmap;
bool list_with_value = false;
string with_value;
- if (cmd_getval(g_ceph_context, cmdmap, "with_value", with_value) &&
+ if (cmd_getval(cmdmap, "with_value", with_value) &&
with_value == "--with-value") {
list_with_value = true;
}
}
string prefix;
- cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
MonSession *session = op->get_session();
if (!session) {
bool propose = false;
if (prefix == "mon add") {
string name;
- cmd_getval(g_ceph_context, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
string addrstr;
- cmd_getval(g_ceph_context, cmdmap, "addr", addrstr);
+ cmd_getval(cmdmap, "addr", addrstr);
entity_addr_t addr;
bufferlist rdata;
} else if (prefix == "mon remove" ||
prefix == "mon rm") {
string name;
- cmd_getval(g_ceph_context, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (!monmap.contains(name)) {
err = 0;
ss << "mon." << name << " does not exist or has already been removed";
* 'mon flag set/unset'.
*/
string feature_name;
- if (!cmd_getval(g_ceph_context, cmdmap, "feature_name", feature_name)) {
+ if (!cmd_getval(cmdmap, "feature_name", feature_name)) {
ss << "missing required feature name";
err = -EINVAL;
goto reply;
}
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
ss << "please specify '--yes-i-really-mean-it' if you "
<< "really, **really** want to set feature '"
} else if (prefix == "mon set-rank") {
string name;
int64_t rank;
- if (!cmd_getval(g_ceph_context, cmdmap, "name", name) ||
- !cmd_getval(g_ceph_context, cmdmap, "rank", rank)) {
+ if (!cmd_getval(cmdmap, "name", name) ||
+ !cmd_getval(cmdmap, "rank", rank)) {
err = -EINVAL;
goto reply;
}
} else if (prefix == "mon set-addrs") {
string name;
string addrs;
- if (!cmd_getval(g_ceph_context, cmdmap, "name", name) ||
- !cmd_getval(g_ceph_context, cmdmap, "addrs", addrs)) {
+ if (!cmd_getval(cmdmap, "name", name) ||
+ !cmd_getval(cmdmap, "addrs", addrs)) {
err = -EINVAL;
goto reply;
}
} else if (prefix == "mon set-weight") {
string name;
int64_t weight;
- if (!cmd_getval(g_ceph_context, cmdmap, "name", name) ||
- !cmd_getval(g_ceph_context, cmdmap, "weight", weight)) {
+ if (!cmd_getval(cmdmap, "name", name) ||
+ !cmd_getval(cmdmap, "weight", weight)) {
err = -EINVAL;
goto reply;
}
}
string prefix;
- cmd_getval(cct, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
string format;
- cmd_getval(cct, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
if (prefix == "osd stat") {
epoch_t epoch = 0;
int64_t epochnum;
- cmd_getval(cct, cmdmap, "epoch", epochnum, (int64_t)osdmap.get_epoch());
+ cmd_getval(cmdmap, "epoch", epochnum, (int64_t)osdmap.get_epoch());
epoch = epochnum;
bufferlist osdmap_bl;
} else if (prefix == "osd info") {
int64_t osd_id;
bool do_single_osd = true;
- if (!cmd_getval(cct, cmdmap, "id", osd_id)) {
+ if (!cmd_getval(cmdmap, "id", osd_id)) {
do_single_osd = false;
}
} else if (prefix == "osd tree" || prefix == "osd tree-from") {
string bucket;
if (prefix == "osd tree-from") {
- cmd_getval(cct, cmdmap, "bucket", bucket);
+ cmd_getval(cmdmap, "bucket", bucket);
if (!osdmap.crush->name_exists(bucket)) {
ss << "bucket '" << bucket << "' does not exist";
r = -ENOENT;
}
vector<string> states;
- cmd_getval(cct, cmdmap, "states", states);
+ cmd_getval(cmdmap, "states", states);
unsigned filter = 0;
for (auto& s : states) {
if (s == "up") {
ss << p->get_crush_version();
} else if (prefix == "osd ls-tree") {
string bucket_name;
- cmd_getval(cct, cmdmap, "name", bucket_name);
+ cmd_getval(cmdmap, "name", bucket_name);
set<int> osds;
r = p->get_osds_by_bucket_name(bucket_name, &osds);
if (r == -ENOENT) {
goto reply;
} else if (prefix == "osd find") {
int64_t osd;
- if (!cmd_getval(cct, cmdmap, "id", osd)) {
+ if (!cmd_getval(cmdmap, "id", osd)) {
ss << "unable to parse osd id value '"
<< cmd_vartype_stringify(cmdmap["id"]) << "'";
r = -EINVAL;
goto reply;
}
string format;
- cmd_getval(cct, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty", "json-pretty"));
f->open_object_section("osd_location");
f->dump_int("osd", osd);
} else if (prefix == "osd metadata") {
int64_t osd = -1;
if (cmd_vartype_stringify(cmdmap["id"]).size() &&
- !cmd_getval(cct, cmdmap, "id", osd)) {
+ !cmd_getval(cmdmap, "id", osd)) {
ss << "unable to parse osd id value '"
<< cmd_vartype_stringify(cmdmap["id"]) << "'";
r = -EINVAL;
goto reply;
}
string format;
- cmd_getval(cct, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty", "json-pretty"));
if (osd >= 0) {
f->open_object_section("osd_metadata");
if (!f)
f.reset(Formatter::create("json-pretty"));
string field;
- cmd_getval(cct, cmdmap, "property", field);
+ cmd_getval(cmdmap, "property", field);
count_metadata(field, f.get());
f->flush(rdata);
r = 0;
}
} else if (prefix == "osd map") {
string poolstr, objstr, namespacestr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
- cmd_getval(cct, cmdmap, "object", objstr);
- cmd_getval(cct, cmdmap, "nspace", namespacestr);
+ cmd_getval(cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "object", objstr);
+ cmd_getval(cmdmap, "nspace", namespacestr);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
} else if (prefix == "pg map") {
pg_t pgid;
string pgidstr;
- cmd_getval(cct, cmdmap, "pgid", pgidstr);
+ cmd_getval(cmdmap, "pgid", pgidstr);
if (!pgid.parse(pgidstr.c_str())) {
ss << "invalid pgid '" << pgidstr << "'";
r = -EINVAL;
} else if (prefix == "osd pool ls") {
string detail;
- cmd_getval(cct, cmdmap, "detail", detail);
+ cmd_getval(cmdmap, "detail", detail);
if (!f && detail == "detail") {
ostringstream ss;
osdmap.print_pools(ss);
} else if (prefix == "osd crush get-tunable") {
string tunable;
- cmd_getval(cct, cmdmap, "tunable", tunable);
+ cmd_getval(cmdmap, "tunable", tunable);
ostringstream rss;
if (f)
f->open_object_section("tunable");
} else if (prefix == "osd pool get") {
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
ss << "unrecognized pool '" << poolstr << "'";
const pg_pool_t *p = osdmap.get_pg_pool(pool);
string var;
- cmd_getval(cct, cmdmap, "var", var);
+ cmd_getval(cmdmap, "var", var);
typedef std::map<std::string, osd_pool_get_choices> choices_map_t;
const choices_map_t ALL_CHOICES = {
r = 0;
} else if (prefix == "osd pool get-quota") {
string pool_name;
- cmd_getval(cct, cmdmap, "pool", pool_name);
+ cmd_getval(cmdmap, "pool", pool_name);
int64_t poolid = osdmap.lookup_pg_pool_name(pool_name);
if (poolid < 0) {
}
} else if (prefix == "osd crush rule ls-by-class") {
string class_name;
- cmd_getval(cct, cmdmap, "class", class_name);
+ cmd_getval(cmdmap, "class", class_name);
if (class_name.empty()) {
ss << "no class specified";
r = -EINVAL;
}
} else if (prefix == "osd crush rule dump") {
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
string format;
- cmd_getval(cct, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty", "json-pretty"));
if (name == "") {
f->open_array_section("rules");
rdata.append(rs.str());
} else if (prefix == "osd crush dump") {
string format;
- cmd_getval(cct, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty", "json-pretty"));
f->open_object_section("crush_map");
osdmap.crush->dump(f.get());
rdata.append(rs.str());
} else if (prefix == "osd crush show-tunables") {
string format;
- cmd_getval(cct, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty", "json-pretty"));
f->open_object_section("crush_map_tunables");
osdmap.crush->dump_tunables(f.get());
rdata.append(rs.str());
} else if (prefix == "osd crush tree") {
string shadow;
- cmd_getval(cct, cmdmap, "shadow", shadow);
+ cmd_getval(cmdmap, "shadow", shadow);
bool show_shadow = shadow == "--show-shadow";
boost::scoped_ptr<Formatter> f(Formatter::create(format));
if (f) {
}
} else if (prefix == "osd crush ls") {
string name;
- if (!cmd_getval(cct, cmdmap, "node", name)) {
+ if (!cmd_getval(cmdmap, "node", name)) {
ss << "no node specified";
r = -EINVAL;
goto reply;
f->flush(rdata);
} else if (prefix == "osd crush class ls-osd") {
string name;
- cmd_getval(cct, cmdmap, "class", name);
+ cmd_getval(cmdmap, "class", name);
set<int> osds;
osdmap.crush->get_devices_by_class(name, &osds);
if (f) {
}
} else if (prefix == "osd crush get-device-class") {
vector<string> idvec;
- cmd_getval(cct, cmdmap, "ids", idvec);
+ cmd_getval(cmdmap, "ids", idvec);
map<int, string> class_by_osd;
for (auto& id : idvec) {
ostringstream ts;
f->flush(rdata);
} else if (prefix == "osd erasure-code-profile get") {
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (!osdmap.has_erasure_code_profile(name)) {
ss << "unknown erasure code profile '" << name << "'";
r = -ENOENT;
boost::scoped_ptr<Formatter> f(Formatter::create(format, "json-pretty",
"json-pretty"));
string pool_name;
- cmd_getval(cct, cmdmap, "pool", pool_name);
+ cmd_getval(cmdmap, "pool", pool_name);
string app;
- cmd_getval(cct, cmdmap, "app", app);
+ cmd_getval(cmdmap, "app", app);
string key;
- cmd_getval(cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
if (pool_name.empty()) {
// all
stringstream& ss)
{
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
ss << "unrecognized pool '" << poolstr << "'";
return -ENOENT;
}
string var;
- cmd_getval(cct, cmdmap, "var", var);
+ cmd_getval(cmdmap, "var", var);
pg_pool_t p = *osdmap.get_pg_pool(pool);
if (pending_inc.new_pools.count(pool))
int64_t n = 0;
double f = 0;
int64_t uf = 0; // micro-f
- cmd_getval(cct, cmdmap, "val", val);
+ cmd_getval(cmdmap, "val", val);
auto si_options = {
"target_max_objects"
return r;
}
bool force = false;
- cmd_getval(cct,cmdmap, "yes_i_really_mean_it", force);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", force);
if (p.cache_mode != pg_pool_t::CACHEMODE_NONE && !force) {
ss << "splits in cache pools must be followed by scrubs and leave sufficient free space to avoid overfilling. use --yes-i-really-mean-it to force.";
return -EPERM;
} else if (var == "hashpspool") {
uint64_t flag = pg_pool_t::get_flag_by_name(var);
bool force = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", force);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", force);
if (!force) {
ss << "are you SURE? this will remap all placement groups in this pool,"
bool preparing)
{
string pool_name;
- cmd_getval(cct, cmdmap, "pool", pool_name);
+ cmd_getval(cmdmap, "pool", pool_name);
int64_t pool = osdmap.lookup_pg_pool_name(pool_name.c_str());
if (pool < 0) {
ss << "unrecognized pool '" << pool_name << "'";
}
string app;
- cmd_getval(cct, cmdmap, "app", app);
+ cmd_getval(cmdmap, "app", app);
bool app_exists = (p.application_metadata.count(app) > 0);
string key;
- cmd_getval(cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
if (key == "all") {
ss << "key cannot be 'all'";
return -EINVAL;
}
string value;
- cmd_getval(cct, cmdmap, "value", value);
+ cmd_getval(cmdmap, "value", value);
if (value == "all") {
ss << "value cannot be 'all'";
return -EINVAL;
}
bool force = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", force);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", force);
if (!app_exists && !p.application_metadata.empty() && !force) {
ss << "Are you SURE? Pool '" << pool_name << "' already has an enabled "
} else if (boost::algorithm::ends_with(prefix, "disable")) {
bool force = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", force);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", force);
if (!force) {
ss << "Are you SURE? Disabling an application within a pool might result "
}
string key;
- cmd_getval(cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
if (key.empty()) {
ss << "key must be provided";
}
string value;
- cmd_getval(cct, cmdmap, "value", value);
+ cmd_getval(cmdmap, "value", value);
if (value.length() > MAX_POOL_APPLICATION_LENGTH) {
ss << "value '" << value << "' too long; max length "
<< MAX_POOL_APPLICATION_LENGTH;
}
string key;
- cmd_getval(cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
auto it = p.application_metadata[app].find(key);
if (it == p.application_metadata[app].end()) {
ss << "application '" << app << "' on pool '" << pool_name
* If `id` is specified, and the osd has been previously marked
* as destroyed, then the `id` will be reused.
*/
- if (!cmd_getval(cct, cmdmap, "uuid", uuidstr)) {
+ if (!cmd_getval(cmdmap, "uuid", uuidstr)) {
ss << "requires the OSD's UUID to be specified.";
return -EINVAL;
} else if (!uuid.parse(uuidstr.c_str())) {
return -EINVAL;
}
- if (cmd_getval(cct, cmdmap, "id", id) &&
+ if (cmd_getval(cmdmap, "id", id) &&
(id < 0)) {
ss << "invalid OSD id; must be greater or equal than zero.";
return -EINVAL;
map<int32_t, uint32_t>* weights)
{
string weights_str;
- if (!cmd_getval(cct, cmdmap, "weights", weights_str)) {
+ if (!cmd_getval(cmdmap, "weights", weights_str)) {
return -EINVAL;
}
std::replace(begin(weights_str), end(weights_str), '\'', '"');
int err = 0;
string format;
- cmd_getval(cct, cmdmap, "format", format, string("plain"));
+ cmd_getval(cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(Formatter::create(format));
string prefix;
- cmd_getval(cct, cmdmap, "prefix", prefix);
+ cmd_getval(cmdmap, "prefix", prefix);
int64_t osdid;
string osd_name;
if (prefix != "osd pg-temp" &&
prefix != "osd pg-upmap" &&
prefix != "osd pg-upmap-items") { // avoid commands with non-int id arg
- osdid_present = cmd_getval(cct, cmdmap, "id", osdid);
+ osdid_present = cmd_getval(cmdmap, "id", osdid);
}
if (osdid_present) {
ostringstream oss;
}
int64_t prior_version = 0;
- if (cmd_getval(cct, cmdmap, "prior_version", prior_version)) {
+ if (cmd_getval(cmdmap, "prior_version", prior_version)) {
if (prior_version == osdmap.get_crush_version() - 1) {
// see if we are a resend of the last update. this is imperfect
// (multiple racing updaters may not both get reliable success)
return true;
} else if (prefix == "osd crush set-device-class") {
string device_class;
- if (!cmd_getval(cct, cmdmap, "class", device_class)) {
+ if (!cmd_getval(cmdmap, "class", device_class)) {
err = -EINVAL; // no value!
goto reply;
}
bool stop = false;
vector<string> idvec;
- cmd_getval(cct, cmdmap, "ids", idvec);
+ cmd_getval(cmdmap, "ids", idvec);
CrushWrapper newcrush;
_get_pending_crush(newcrush);
set<int> updated;
} else if (prefix == "osd crush rm-device-class") {
bool stop = false;
vector<string> idvec;
- cmd_getval(cct, cmdmap, "ids", idvec);
+ cmd_getval(cmdmap, "ids", idvec);
CrushWrapper newcrush;
_get_pending_crush(newcrush);
set<int> updated;
}
} else if (prefix == "osd crush class create") {
string device_class;
- if (!cmd_getval(g_ceph_context, cmdmap, "class", device_class)) {
+ if (!cmd_getval(cmdmap, "class", device_class)) {
err = -EINVAL; // no value!
goto reply;
}
goto update;
} else if (prefix == "osd crush class rm") {
string device_class;
- if (!cmd_getval(g_ceph_context, cmdmap, "class", device_class)) {
+ if (!cmd_getval(cmdmap, "class", device_class)) {
err = -EINVAL; // no value!
goto reply;
}
goto update;
} else if (prefix == "osd crush class rename") {
string srcname, dstname;
- if (!cmd_getval(cct, cmdmap, "srcname", srcname)) {
+ if (!cmd_getval(cmdmap, "srcname", srcname)) {
err = -EINVAL;
goto reply;
}
- if (!cmd_getval(cct, cmdmap, "dstname", dstname)) {
+ if (!cmd_getval(cmdmap, "dstname", dstname)) {
err = -EINVAL;
goto reply;
}
// os crush add-bucket <name> <type>
string name, typestr;
vector<string> argvec;
- cmd_getval(cct, cmdmap, "name", name);
- cmd_getval(cct, cmdmap, "type", typestr);
- cmd_getval(cct, cmdmap, "args", argvec);
+ cmd_getval(cmdmap, "name", name);
+ cmd_getval(cmdmap, "type", typestr);
+ cmd_getval(cmdmap, "args", argvec);
map<string,string> loc;
if (!argvec.empty()) {
CrushWrapper::parse_loc_map(argvec, &loc);
goto update;
} else if (prefix == "osd crush rename-bucket") {
string srcname, dstname;
- cmd_getval(cct, cmdmap, "srcname", srcname);
- cmd_getval(cct, cmdmap, "dstname", dstname);
+ cmd_getval(cmdmap, "srcname", srcname);
+ cmd_getval(cmdmap, "dstname", dstname);
err = crush_rename_bucket(srcname, dstname, &ss);
if (err == -EALREADY) // equivalent to success for idempotency
goto reply;
}
string poolname, mode;
- cmd_getval(cct, cmdmap, "pool", poolname);
+ cmd_getval(cmdmap, "pool", poolname);
pool = osdmap.lookup_pg_pool_name(poolname.c_str());
if (pool < 0) {
ss << "pool '" << poolname << "' not found";
err = -ENOENT;
goto reply;
}
- cmd_getval(cct, cmdmap, "mode", mode);
+ cmd_getval(cmdmap, "mode", mode);
if (mode != "flat" && mode != "positional") {
ss << "unrecognized weight-set mode '" << mode << "'";
err = -EINVAL;
int64_t pool;
if (prefix == "osd crush weight-set rm") {
string poolname;
- cmd_getval(cct, cmdmap, "pool", poolname);
+ cmd_getval(cmdmap, "pool", poolname);
pool = osdmap.lookup_pg_pool_name(poolname.c_str());
if (pool < 0) {
ss << "pool '" << poolname << "' not found";
prefix == "osd crush weight-set reweight-compat") {
string poolname, item;
vector<double> weight;
- cmd_getval(cct, cmdmap, "pool", poolname);
- cmd_getval(cct, cmdmap, "item", item);
- cmd_getval(cct, cmdmap, "weight", weight);
+ cmd_getval(cmdmap, "pool", poolname);
+ cmd_getval(cmdmap, "item", item);
+ cmd_getval(cmdmap, "weight", weight);
CrushWrapper newcrush;
_get_pending_crush(newcrush);
int64_t pool;
}
double weight;
- if (!cmd_getval(cct, cmdmap, "weight", weight)) {
+ if (!cmd_getval(cmdmap, "weight", weight)) {
ss << "unable to parse weight value '"
<< cmd_vartype_stringify(cmdmap.at("weight")) << "'";
err = -EINVAL;
string args;
vector<string> argvec;
- cmd_getval(cct, cmdmap, "args", argvec);
+ cmd_getval(cmdmap, "args", argvec);
map<string,string> loc;
CrushWrapper::parse_loc_map(argvec, &loc);
}
double weight;
- if (!cmd_getval(cct, cmdmap, "weight", weight)) {
+ if (!cmd_getval(cmdmap, "weight", weight)) {
ss << "unable to parse weight value '"
<< cmd_vartype_stringify(cmdmap.at("weight")) << "'";
err = -EINVAL;
string args;
vector<string> argvec;
- cmd_getval(cct, cmdmap, "args", argvec);
+ cmd_getval(cmdmap, "args", argvec);
map<string,string> loc;
CrushWrapper::parse_loc_map(argvec, &loc);
// osd crush move <name> <loc1> [<loc2> ...]
string name;
vector<string> argvec;
- cmd_getval(cct, cmdmap, "name", name);
- cmd_getval(cct, cmdmap, "args", argvec);
+ cmd_getval(cmdmap, "name", name);
+ cmd_getval(cmdmap, "args", argvec);
map<string,string> loc;
CrushWrapper::parse_loc_map(argvec, &loc);
} while (false);
} else if (prefix == "osd crush swap-bucket") {
string source, dest;
- cmd_getval(cct, cmdmap, "source", source);
- cmd_getval(cct, cmdmap, "dest", dest);
+ cmd_getval(cmdmap, "source", source);
+ cmd_getval(cmdmap, "dest", dest);
bool force = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", force);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", force);
CrushWrapper newcrush;
_get_pending_crush(newcrush);
} else if (prefix == "osd crush link") {
// osd crush link <name> <loc1> [<loc2> ...]
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
vector<string> argvec;
- cmd_getval(cct, cmdmap, "args", argvec);
+ cmd_getval(cmdmap, "args", argvec);
map<string,string> loc;
CrushWrapper::parse_loc_map(argvec, &loc);
_get_pending_crush(newcrush);
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (!osdmap.crush->name_exists(name)) {
err = 0;
bool unlink_only = prefix == "osd crush unlink";
string ancestor_str;
- if (cmd_getval(cct, cmdmap, "ancestor", ancestor_str)) {
+ if (cmd_getval(cmdmap, "ancestor", ancestor_str)) {
if (!newcrush.name_exists(ancestor_str)) {
err = -ENOENT;
ss << "ancestor item '" << ancestor_str
_get_pending_crush(newcrush);
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (!newcrush.name_exists(name)) {
err = -ENOENT;
ss << "device '" << name << "' does not appear in the crush map";
goto reply;
}
double w;
- if (!cmd_getval(cct, cmdmap, "weight", w)) {
+ if (!cmd_getval(cmdmap, "weight", w)) {
ss << "unable to parse weight value '"
<< cmd_vartype_stringify(cmdmap.at("weight")) << "'";
err = -EINVAL;
_get_pending_crush(newcrush);
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (!newcrush.name_exists(name)) {
err = -ENOENT;
ss << "device '" << name << "' does not appear in the crush map";
goto reply;
}
double w;
- if (!cmd_getval(cct, cmdmap, "weight", w)) {
+ if (!cmd_getval(cmdmap, "weight", w)) {
ss << "unable to parse weight value '"
<< cmd_vartype_stringify(cmdmap.at("weight")) << "'";
err = -EINVAL;
err = 0;
string profile;
- cmd_getval(cct, cmdmap, "profile", profile);
+ cmd_getval(cmdmap, "profile", profile);
if (profile == "legacy" || profile == "argonaut") {
newcrush.set_tunables_legacy();
} else if (profile == "bobtail") {
err = 0;
string tunable;
- cmd_getval(cct, cmdmap, "tunable", tunable);
+ cmd_getval(cmdmap, "tunable", tunable);
int64_t value = -1;
- if (!cmd_getval(cct, cmdmap, "value", value)) {
+ if (!cmd_getval(cmdmap, "value", value)) {
err = -EINVAL;
ss << "failed to parse integer value "
<< cmd_vartype_stringify(cmdmap.at("value"));
} else if (prefix == "osd crush rule create-simple") {
string name, root, type, mode;
- cmd_getval(cct, cmdmap, "name", name);
- cmd_getval(cct, cmdmap, "root", root);
- cmd_getval(cct, cmdmap, "type", type);
- cmd_getval(cct, cmdmap, "mode", mode);
+ cmd_getval(cmdmap, "name", name);
+ cmd_getval(cmdmap, "root", root);
+ cmd_getval(cmdmap, "type", type);
+ cmd_getval(cmdmap, "mode", mode);
if (mode == "")
mode = "firstn";
} else if (prefix == "osd crush rule create-replicated") {
string name, root, type, device_class;
- cmd_getval(cct, cmdmap, "name", name);
- cmd_getval(cct, cmdmap, "root", root);
- cmd_getval(cct, cmdmap, "type", type);
- cmd_getval(cct, cmdmap, "class", device_class);
+ cmd_getval(cmdmap, "name", name);
+ cmd_getval(cmdmap, "root", root);
+ cmd_getval(cmdmap, "type", type);
+ cmd_getval(cmdmap, "class", device_class);
if (osdmap.crush->rule_exists(name)) {
// The name is uniquely associated to a ruleid and the rule it contains
} else if (prefix == "osd erasure-code-profile rm") {
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (erasure_code_profile_in_use(pending_inc.new_pools, name, &ss))
goto wait;
} else if (prefix == "osd erasure-code-profile set") {
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
vector<string> profile;
- cmd_getval(cct, cmdmap, "profile", profile);
+ cmd_getval(cmdmap, "profile", profile);
bool force = false;
- cmd_getval(cct, cmdmap, "force", force);
+ cmd_getval(cmdmap, "force", force);
map<string,string> profile_map;
err = parse_erasure_code_profile(profile, &profile_map, &ss);
if (err)
goto reply;
string name, poolstr;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
string profile;
- cmd_getval(cct, cmdmap, "profile", profile);
+ cmd_getval(cmdmap, "profile", profile);
if (profile == "")
profile = "default";
if (profile == "default") {
} else if (prefix == "osd crush rule rm") {
string name;
- cmd_getval(cct, cmdmap, "name", name);
+ cmd_getval(cmdmap, "name", name);
if (!osdmap.crush->rule_exists(name)) {
ss << "rule " << name << " does not exist";
} else if (prefix == "osd crush rule rename") {
string srcname;
string dstname;
- cmd_getval(cct, cmdmap, "srcname", srcname);
- cmd_getval(cct, cmdmap, "dstname", dstname);
+ cmd_getval(cmdmap, "srcname", srcname);
+ cmd_getval(cmdmap, "dstname", dstname);
if (srcname.empty() || dstname.empty()) {
ss << "must specify both source rule name and destination rule name";
err = -EINVAL;
} else if (prefix == "osd setmaxosd") {
int64_t newmax;
- if (!cmd_getval(cct, cmdmap, "newmax", newmax)) {
+ if (!cmd_getval(cmdmap, "newmax", newmax)) {
ss << "unable to parse 'newmax' value '"
<< cmd_vartype_stringify(cmdmap.at("newmax")) << "'";
err = -EINVAL;
prefix == "osd set-backfillfull-ratio" ||
prefix == "osd set-nearfull-ratio") {
double n;
- if (!cmd_getval(cct, cmdmap, "ratio", n)) {
+ if (!cmd_getval(cmdmap, "ratio", n)) {
ss << "unable to parse 'ratio' value '"
<< cmd_vartype_stringify(cmdmap.at("ratio")) << "'";
err = -EINVAL;
return true;
} else if (prefix == "osd set-require-min-compat-client") {
string v;
- cmd_getval(cct, cmdmap, "version", v);
+ cmd_getval(cmdmap, "version", v);
ceph_release_t vno = ceph_release_from_name(v);
if (!vno) {
ss << "version " << v << " is not recognized";
goto reply;
}
bool sure = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
FeatureMap m;
mon->get_combined_feature_map(&m);
} else if (prefix == "osd set") {
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
string key;
- cmd_getval(cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
if (key == "pause")
return prepare_set_flag(op, CEPH_OSDMAP_PAUSERD | CEPH_OSDMAP_PAUSEWR);
else if (key == "noup")
} else if (prefix == "osd unset") {
string key;
- cmd_getval(cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
if (key == "pause")
return prepare_unset_flag(op, CEPH_OSDMAP_PAUSERD | CEPH_OSDMAP_PAUSEWR);
else if (key == "noup")
} else if (prefix == "osd require-osd-release") {
string release;
- cmd_getval(cct, cmdmap, "release", release);
+ cmd_getval(cmdmap, "release", release);
bool sure = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
ceph_release_t rel = ceph_release_from_name(release.c_str());
if (!rel) {
ss << "unrecognized release " << release;
bool definitely_dead = false;
vector<string> idvec;
- cmd_getval(cct, cmdmap, "ids", idvec);
- cmd_getval(cct, cmdmap, "definitely_dead", definitely_dead);
+ cmd_getval(cmdmap, "ids", idvec);
+ cmd_getval(cmdmap, "definitely_dead", definitely_dead);
derr << "definitely_dead " << (int)definitely_dead << dendl;
for (unsigned j = 0; j < idvec.size() && !stop; j++) {
set<int> osds;
unsigned flags = 0;
vector<string> who;
if (prefix == "osd set-group" || prefix == "osd unset-group") {
- cmd_getval(cct, cmdmap, "flags", flag_str);
- cmd_getval(cct, cmdmap, "who", who);
+ cmd_getval(cmdmap, "flags", flag_str);
+ cmd_getval(cmdmap, "who", who);
vector<string> raw_flags;
boost::split(raw_flags, flag_str, boost::is_any_of(","));
for (auto& f : raw_flags) {
}
}
} else {
- cmd_getval(cct, cmdmap, "ids", who);
+ cmd_getval(cmdmap, "ids", who);
if (prefix.find("noup") != string::npos)
flags = CEPH_OSD_NOUP;
else if (prefix.find("nodown") != string::npos)
}
} else if (prefix == "osd pg-temp") {
string pgidstr;
- if (!cmd_getval(cct, cmdmap, "pgid", pgidstr)) {
+ if (!cmd_getval(cmdmap, "pgid", pgidstr)) {
ss << "unable to parse 'pgid' value '"
<< cmd_vartype_stringify(cmdmap.at("pgid")) << "'";
err = -EINVAL;
vector<int64_t> id_vec;
vector<int32_t> new_pg_temp;
- cmd_getval(cct, cmdmap, "id", id_vec);
+ cmd_getval(cmdmap, "id", id_vec);
if (id_vec.empty()) {
pending_inc.new_pg_temp[pgid] = mempool::osdmap::vector<int>();
ss << "done cleaning up pg_temp of " << pgid;
goto update;
} else if (prefix == "osd primary-temp") {
string pgidstr;
- if (!cmd_getval(cct, cmdmap, "pgid", pgidstr)) {
+ if (!cmd_getval(cmdmap, "pgid", pgidstr)) {
ss << "unable to parse 'pgid' value '"
<< cmd_vartype_stringify(cmdmap.at("pgid")) << "'";
err = -EINVAL;
}
int64_t osd;
- if (!cmd_getval(cct, cmdmap, "id", osd)) {
+ if (!cmd_getval(cmdmap, "id", osd)) {
ss << "unable to parse 'id' value '"
<< cmd_vartype_stringify(cmdmap.at("id")) << "'";
err = -EINVAL;
} else if (prefix == "pg repeer") {
pg_t pgid;
string pgidstr;
- cmd_getval(cct, cmdmap, "pgid", pgidstr);
+ cmd_getval(cmdmap, "pgid", pgidstr);
if (!pgid.parse(pgidstr.c_str())) {
ss << "invalid pgid '" << pgidstr << "'";
err = -EINVAL;
if (err < 0)
goto reply;
string pgidstr;
- if (!cmd_getval(cct, cmdmap, "pgid", pgidstr)) {
+ if (!cmd_getval(cmdmap, "pgid", pgidstr)) {
ss << "unable to parse 'pgid' value '"
<< cmd_vartype_stringify(cmdmap.at("pgid")) << "'";
err = -EINVAL;
case OP_PG_UPMAP:
{
vector<int64_t> id_vec;
- if (!cmd_getval(cct, cmdmap, "id", id_vec)) {
+ if (!cmd_getval(cmdmap, "id", id_vec)) {
ss << "unable to parse 'id' value(s) '"
<< cmd_vartype_stringify(cmdmap.at("id")) << "'";
err = -EINVAL;
case OP_PG_UPMAP_ITEMS:
{
vector<int64_t> id_vec;
- if (!cmd_getval(cct, cmdmap, "id", id_vec)) {
+ if (!cmd_getval(cmdmap, "id", id_vec)) {
ss << "unable to parse 'id' value(s) '"
<< cmd_vartype_stringify(cmdmap.at("id")) << "'";
err = -EINVAL;
goto update;
} else if (prefix == "osd primary-affinity") {
int64_t id;
- if (!cmd_getval(cct, cmdmap, "id", id)) {
+ if (!cmd_getval(cmdmap, "id", id)) {
ss << "invalid osd id value '"
<< cmd_vartype_stringify(cmdmap.at("id")) << "'";
err = -EINVAL;
goto reply;
}
double w;
- if (!cmd_getval(cct, cmdmap, "weight", w)) {
+ if (!cmd_getval(cmdmap, "weight", w)) {
ss << "unable to parse 'weight' value '"
<< cmd_vartype_stringify(cmdmap.at("weight")) << "'";
err = -EINVAL;
}
} else if (prefix == "osd reweight") {
int64_t id;
- if (!cmd_getval(cct, cmdmap, "id", id)) {
+ if (!cmd_getval(cmdmap, "id", id)) {
ss << "unable to parse osd id value '"
<< cmd_vartype_stringify(cmdmap.at("id")) << "'";
err = -EINVAL;
goto reply;
}
double w;
- if (!cmd_getval(cct, cmdmap, "weight", w)) {
+ if (!cmd_getval(cmdmap, "weight", w)) {
ss << "unable to parse weight value '"
<< cmd_vartype_stringify(cmdmap.at("weight")) << "'";
err = -EINVAL;
return true;
} else if (prefix == "osd lost") {
int64_t id;
- if (!cmd_getval(cct, cmdmap, "id", id)) {
+ if (!cmd_getval(cmdmap, "id", id)) {
ss << "unable to parse osd id value '"
<< cmd_vartype_stringify(cmdmap.at("id")) << "'";
err = -EINVAL;
goto reply;
}
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
ss << "are you SURE? this might mean real, permanent data loss. pass "
"--yes-i-really-mean-it if you really do.";
}
int64_t id;
- if (!cmd_getval(cct, cmdmap, "id", id)) {
+ if (!cmd_getval(cmdmap, "id", id)) {
auto p = cmdmap.find("id");
if (p == cmdmap.end()) {
ss << "no osd id specified";
}
bool sure = false;
- cmd_getval(g_ceph_context, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
ss << "Are you SURE? Did you verify with 'ceph osd safe-to-destroy'? "
<< "This will mean real, permanent data loss, as well "
// optional id provided?
int64_t id = -1, cmd_id = -1;
- if (cmd_getval(cct, cmdmap, "id", cmd_id)) {
+ if (cmd_getval(cmdmap, "id", cmd_id)) {
if (cmd_id < 0) {
ss << "invalid osd id value '" << cmd_id << "'";
err = -EINVAL;
uuid_d uuid;
string uuidstr;
- if (cmd_getval(cct, cmdmap, "uuid", uuidstr)) {
+ if (cmd_getval(cmdmap, "uuid", uuidstr)) {
if (!uuid.parse(uuidstr.c_str())) {
ss << "invalid uuid value '" << uuidstr << "'";
err = -EINVAL;
return true;
} else if (prefix == "osd blacklist") {
string addrstr;
- cmd_getval(cct, cmdmap, "addr", addrstr);
+ cmd_getval(cmdmap, "addr", addrstr);
entity_addr_t addr;
if (!addr.parse(addrstr.c_str(), 0)) {
ss << "unable to parse address " << addrstr;
}
string blacklistop;
- cmd_getval(cct, cmdmap, "blacklistop", blacklistop);
+ cmd_getval(cmdmap, "blacklistop", blacklistop);
if (blacklistop == "add") {
utime_t expires = ceph_clock_now();
double d;
// default one hour
- cmd_getval(cct, cmdmap, "expire", d,
+ cmd_getval(cmdmap, "expire", d,
g_conf()->mon_osd_blacklist_default_expire);
expires += d;
}
} else if (prefix == "osd pool mksnap") {
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string snapname;
- cmd_getval(cct, cmdmap, "snap", snapname);
+ cmd_getval(cmdmap, "snap", snapname);
const pg_pool_t *p = osdmap.get_pg_pool(pool);
if (p->is_unmanaged_snaps_mode()) {
ss << "pool " << poolstr << " is in unmanaged snaps mode";
return true;
} else if (prefix == "osd pool rmsnap") {
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string snapname;
- cmd_getval(cct, cmdmap, "snap", snapname);
+ cmd_getval(cmdmap, "snap", snapname);
const pg_pool_t *p = osdmap.get_pg_pool(pool);
if (p->is_unmanaged_snaps_mode()) {
ss << "pool " << poolstr << " is in unmanaged snaps mode";
} else if (prefix == "osd pool create") {
int64_t pg_num, pg_num_min;
int64_t pgp_num;
- cmd_getval(cct, cmdmap, "pg_num", pg_num, int64_t(0));
- cmd_getval(cct, cmdmap, "pgp_num", pgp_num, pg_num);
- cmd_getval(cct, cmdmap, "pg_num_min", pg_num_min, int64_t(0));
+ cmd_getval(cmdmap, "pg_num", pg_num, int64_t(0));
+ cmd_getval(cmdmap, "pgp_num", pgp_num, pg_num);
+ cmd_getval(cmdmap, "pg_num_min", pg_num_min, int64_t(0));
string pool_type_str;
- cmd_getval(cct, cmdmap, "pool_type", pool_type_str);
+ cmd_getval(cmdmap, "pool_type", pool_type_str);
if (pool_type_str.empty())
pool_type_str = g_conf().get_val<string>("osd_pool_default_type");
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id >= 0) {
const pg_pool_t *p = osdmap.get_pg_pool(pool_id);
bool implicit_rule_creation = false;
int64_t expected_num_objects = 0;
string rule_name;
- cmd_getval(cct, cmdmap, "rule", rule_name);
+ cmd_getval(cmdmap, "rule", rule_name);
string erasure_code_profile;
- cmd_getval(cct, cmdmap, "erasure_code_profile", erasure_code_profile);
+ cmd_getval(cmdmap, "erasure_code_profile", erasure_code_profile);
if (pool_type == pg_pool_t::TYPE_ERASURE) {
if (erasure_code_profile == "")
rule_name = poolstr;
}
}
- cmd_getval(g_ceph_context, cmdmap, "expected_num_objects",
+ cmd_getval(cmdmap, "expected_num_objects",
expected_num_objects, int64_t(0));
} else {
//NOTE:for replicated pool,cmd_map will put rule_name to erasure_code_profile field
}
rule_name = erasure_code_profile;
} else { // cmd is well-formed
- cmd_getval(g_ceph_context, cmdmap, "expected_num_objects",
+ cmd_getval(cmdmap, "expected_num_objects",
expected_num_objects, int64_t(0));
}
}
}
int64_t fast_read_param;
- cmd_getval(cct, cmdmap, "fast_read", fast_read_param, int64_t(-1));
+ cmd_getval(cmdmap, "fast_read", fast_read_param, int64_t(-1));
FastReadType fast_read = FAST_READ_DEFAULT;
if (fast_read_param == 0)
fast_read = FAST_READ_OFF;
fast_read = FAST_READ_ON;
int64_t repl_size = 0;
- cmd_getval(cct, cmdmap, "size", repl_size);
+ cmd_getval(cmdmap, "size", repl_size);
int64_t target_size_bytes = 0;
double target_size_ratio = 0.0;
- cmd_getval(cct, cmdmap, "target_size_bytes", target_size_bytes);
- cmd_getval(cct, cmdmap, "target_size_ratio", target_size_ratio);
+ cmd_getval(cmdmap, "target_size_bytes", target_size_bytes);
+ cmd_getval(cmdmap, "target_size_ratio", target_size_ratio);
err = prepare_new_pool(poolstr,
-1, // default crush rule
prefix == "osd pool rm") {
// osd pool delete/rm <poolname> <poolname again> --yes-i-really-really-mean-it
string poolstr, poolstr2, sure;
- cmd_getval(cct, cmdmap, "pool", poolstr);
- cmd_getval(cct, cmdmap, "pool2", poolstr2);
+ cmd_getval(cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool2", poolstr2);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
ss << "pool '" << poolstr << "' does not exist";
}
bool force_no_fake = false;
- cmd_getval(cct, cmdmap, "yes_i_really_really_mean_it", force_no_fake);
+ cmd_getval(cmdmap, "yes_i_really_really_mean_it", force_no_fake);
bool force = false;
- cmd_getval(cct, cmdmap, "yes_i_really_really_mean_it_not_faking", force);
+ cmd_getval(cmdmap, "yes_i_really_really_mean_it_not_faking", force);
if (poolstr2 != poolstr ||
(!force && !force_no_fake)) {
ss << "WARNING: this will *PERMANENTLY DESTROY* all data stored in pool " << poolstr
goto update;
} else if (prefix == "osd pool rename") {
string srcpoolstr, destpoolstr;
- cmd_getval(cct, cmdmap, "srcpool", srcpoolstr);
- cmd_getval(cct, cmdmap, "destpool", destpoolstr);
+ cmd_getval(cmdmap, "srcpool", srcpoolstr);
+ cmd_getval(cmdmap, "destpool", destpoolstr);
int64_t pool_src = osdmap.lookup_pg_pool_name(srcpoolstr.c_str());
int64_t pool_dst = osdmap.lookup_pg_pool_name(destpoolstr.c_str());
if (err)
goto reply;
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string tierpoolstr;
- cmd_getval(cct, cmdmap, "tierpool", tierpoolstr);
+ cmd_getval(cmdmap, "tierpool", tierpoolstr);
int64_t tierpool_id = osdmap.lookup_pg_pool_name(tierpoolstr);
if (tierpool_id < 0) {
ss << "unrecognized pool '" << tierpoolstr << "'";
// make sure new tier is empty
string force_nonempty;
- cmd_getval(cct, cmdmap, "force_nonempty", force_nonempty);
+ cmd_getval(cmdmap, "force_nonempty", force_nonempty);
const pool_stat_t *pstats = mon->mgrstatmon()->get_pool_stat(tierpool_id);
if (pstats && pstats->stats.sum.num_objects != 0 &&
force_nonempty != "--force-nonempty") {
} else if (prefix == "osd tier remove" ||
prefix == "osd tier rm") {
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string tierpoolstr;
- cmd_getval(cct, cmdmap, "tierpool", tierpoolstr);
+ cmd_getval(cmdmap, "tierpool", tierpoolstr);
int64_t tierpool_id = osdmap.lookup_pg_pool_name(tierpoolstr);
if (tierpool_id < 0) {
ss << "unrecognized pool '" << tierpoolstr << "'";
if (err)
goto reply;
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string overlaypoolstr;
- cmd_getval(cct, cmdmap, "overlaypool", overlaypoolstr);
+ cmd_getval(cmdmap, "overlaypool", overlaypoolstr);
int64_t overlaypool_id = osdmap.lookup_pg_pool_name(overlaypoolstr);
if (overlaypool_id < 0) {
ss << "unrecognized pool '" << overlaypoolstr << "'";
} else if (prefix == "osd tier remove-overlay" ||
prefix == "osd tier rm-overlay") {
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
if (err)
goto reply;
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string modestr;
- cmd_getval(cct, cmdmap, "mode", modestr);
+ cmd_getval(cmdmap, "mode", modestr);
pg_pool_t::cache_mode_t mode = pg_pool_t::get_cache_mode_from_str(modestr);
if (int(mode) < 0) {
ss << "'" << modestr << "' is not a valid cache mode";
}
bool sure = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (mode == pg_pool_t::CACHEMODE_FORWARD ||
mode == pg_pool_t::CACHEMODE_READFORWARD) {
if (err)
goto reply;
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
goto reply;
}
string tierpoolstr;
- cmd_getval(cct, cmdmap, "tierpool", tierpoolstr);
+ cmd_getval(cmdmap, "tierpool", tierpoolstr);
int64_t tierpool_id = osdmap.lookup_pg_pool_name(tierpoolstr);
if (tierpool_id < 0) {
ss << "unrecognized pool '" << tierpoolstr << "'";
}
int64_t size = 0;
- if (!cmd_getval(cct, cmdmap, "size", size)) {
+ if (!cmd_getval(cmdmap, "size", size)) {
ss << "unable to parse 'size' value '"
<< cmd_vartype_stringify(cmdmap.at("size")) << "'";
err = -EINVAL;
return true;
} else if (prefix == "osd pool set-quota") {
string poolstr;
- cmd_getval(cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
int64_t pool_id = osdmap.lookup_pg_pool_name(poolstr);
if (pool_id < 0) {
ss << "unrecognized pool '" << poolstr << "'";
}
string field;
- cmd_getval(cct, cmdmap, "field", field);
+ cmd_getval(cmdmap, "field", field);
if (field != "max_objects" && field != "max_bytes") {
ss << "unrecognized field '" << field << "'; should be 'max_bytes' or 'max_objects'";
err = -EINVAL;
// val could contain unit designations, so we treat as a string
string val;
- cmd_getval(cct, cmdmap, "val", val);
+ cmd_getval(cmdmap, "val", val);
string tss;
int64_t value;
if (field == "max_objects") {
} else if (prefix == "osd force-create-pg") {
pg_t pgid;
string pgidstr;
- cmd_getval(cct, cmdmap, "pgid", pgidstr);
+ cmd_getval(cmdmap, "pgid", pgidstr);
if (!pgid.parse(pgidstr.c_str())) {
ss << "invalid pgid '" << pgidstr << "'";
err = -EINVAL;
goto reply;
}
bool sure = false;
- cmd_getval(cct, cmdmap, "yes_i_really_mean_it", sure);
+ cmd_getval(cmdmap, "yes_i_really_mean_it", sure);
if (!sure) {
ss << "This command will recreate a lost (as in data lost) PG with data in it, such "
<< "that the cluster will give up ever trying to recover the lost data. Do this "
} else if (prefix == "pg ls-by-pool") {
prefix = "pg ls";
string poolstr;
- cmd_getval(g_ceph_context, cmdmap, "poolstr", poolstr);
+ cmd_getval(cmdmap, "poolstr", poolstr);
int64_t pool = osdmap.lookup_pg_pool_name(poolstr.c_str());
if (pool < 0) {
*ss << "pool " << poolstr << " does not exist";
string val;
vector<string> dumpcontents;
set<string> what;
- if (cmd_getval(g_ceph_context, cmdmap, "dumpcontents", dumpcontents)) {
+ if (cmd_getval(cmdmap, "dumpcontents", dumpcontents)) {
copy(dumpcontents.begin(), dumpcontents.end(),
inserter(what, what.end()));
}
int64_t pool = -1;
vector<string>states;
set<pg_t> pgs;
- cmd_getval(g_ceph_context, cmdmap, "pool", pool);
- cmd_getval(g_ceph_context, cmdmap, "osd", osd);
- cmd_getval(g_ceph_context, cmdmap, "states", states);
+ cmd_getval(cmdmap, "pool", pool);
+ cmd_getval(cmdmap, "osd", osd);
+ cmd_getval(cmdmap, "states", states);
if (pool >= 0 && !osdmap.have_pg_pool(pool)) {
*ss << "pool " << pool << " does not exist";
return -ENOENT;
if (prefix == "pg dump_stuck") {
vector<string> stuckop_vec;
- cmd_getval(g_ceph_context, cmdmap, "stuckops", stuckop_vec);
+ cmd_getval(cmdmap, "stuckops", stuckop_vec);
if (stuckop_vec.empty())
stuckop_vec.push_back("unclean");
int64_t threshold;
- cmd_getval(g_ceph_context, cmdmap, "threshold", threshold,
+ cmd_getval(cmdmap, "threshold", threshold,
g_conf().get_val<int64_t>("mon_pg_stuck_threshold"));
if (pg_map.dump_stuck_pg_stats(ds, f, (int)threshold, stuckop_vec) < 0) {
if (prefix == "pg debug") {
string debugop;
- cmd_getval(g_ceph_context, cmdmap, "debugop", debugop,
+ cmd_getval(cmdmap, "debugop", debugop,
string("unfound_objects_exist"));
if (debugop == "unfound_objects_exist") {
bool unfound_objects_exist = false;
bufferlist& out) override {
if (command == "bluestore bluefs available") {
int64_t alloc_size = 0;
- cmd_getval(bluefs->cct, cmdmap, "alloc_size", alloc_size);
+ cmd_getval(cmdmap, "alloc_size", alloc_size);
if ((alloc_size & (alloc_size - 1)) != 0) {
ss << "Invalid allocation size:'" << alloc_size << std::endl;
return -EINVAL;
) {
string pgidstr;
pg_t pgid;
- if (!cmd_getval(cct, cmdmap, "pgid", pgidstr)) {
+ if (!cmd_getval(cmdmap, "pgid", pgidstr)) {
ss << "no pgid specified";
ret = -EINVAL;
goto out;
set<string> filters;
vector<string> filter_str;
- if (cmd_getval(cct, cmdmap, "filterstr", filter_str)) {
+ if (cmd_getval(cmdmap, "filterstr", filter_str)) {
copy(filter_str.begin(), filter_str.end(),
inserter(filters, filters.end()));
}
int64_t value = 0;
string error;
bool success = false;
- if (!cmd_getval(cct, cmdmap, "property", property)) {
+ if (!cmd_getval(cmdmap, "property", property)) {
error = "unable to get property";
success = false;
- } else if (!cmd_getval(cct, cmdmap, "value", value)) {
+ } else if (!cmd_getval(cmdmap, "value", value)) {
error = "unable to get value";
success = false;
} else if (value < 0) {
size_t value = 0;
string error;
bool success = false;
- if (!cmd_getval(cct, cmdmap, "property", property)) {
+ if (!cmd_getval(cmdmap, "property", property)) {
error = "unable to get property";
success = false;
} else if (!ceph_heap_get_numeric_property(property.c_str(), &value)) {
f->close_section();
} else if (prefix == "smart") {
string devid;
- cmd_getval(cct, cmdmap, "devid", devid);
+ cmd_getval(cmdmap, "devid", devid);
ostringstream out;
probe_smart(devid, out);
outbl.append(out.str());
else if (prefix == "cluster_log") {
vector<string> msg;
- cmd_getval(cct, cmdmap, "message", msg);
+ cmd_getval(cmdmap, "message", msg);
if (msg.empty()) {
ret = -EINVAL;
ss << "ignoring empty log message";
for (vector<string>::iterator a = ++msg.begin(); a != msg.end(); ++a)
message += " " + *a;
string lvl;
- cmd_getval(cct, cmdmap, "level", lvl);
+ cmd_getval(cmdmap, "level", lvl);
clog_type level = string_to_clog_type(lvl);
if (level < 0) {
ret = -EINVAL;
int64_t bsize;
int64_t osize, onum;
// default count 1G, size 4MB
- cmd_getval(cct, cmdmap, "count", count, (int64_t)1 << 30);
- cmd_getval(cct, cmdmap, "size", bsize, (int64_t)4 << 20);
- cmd_getval(cct, cmdmap, "object_size", osize, (int64_t)0);
- cmd_getval(cct, cmdmap, "object_num", onum, (int64_t)0);
+ cmd_getval(cmdmap, "count", count, (int64_t)1 << 30);
+ cmd_getval(cmdmap, "size", bsize, (int64_t)4 << 20);
+ cmd_getval(cmdmap, "object_size", osize, (int64_t)0);
+ cmd_getval(cmdmap, "object_num", onum, (int64_t)0);
uint32_t duration = cct->_conf->osd_bench_duration;
else if (prefix == "debug kick_recovery_wq") {
int64_t delay;
- cmd_getval(cct, cmdmap, "delay", delay);
+ cmd_getval(cmdmap, "delay", delay);
ostringstream oss;
oss << delay;
ret = cct->_conf.set_val("osd_recovery_delay_start", oss.str().c_str());
else if (prefix == "cpu_profiler") {
ostringstream ds;
string arg;
- cmd_getval(cct, cmdmap, "arg", arg);
+ cmd_getval(cmdmap, "arg", arg);
vector<string> argvec;
get_str_vec(arg, argvec);
cpu_profiler_handle_command(argvec, ds);
else if (prefix == "perf histogram dump") {
std::string logger;
std::string counter;
- cmd_getval(cct, cmdmap, "logger", logger);
- cmd_getval(cct, cmdmap, "counter", counter);
+ cmd_getval(cmdmap, "logger", logger);
+ cmd_getval(cmdmap, "counter", counter);
cct->get_perfcounters_collection()->dump_formatted_histograms(
f, false, logger, counter);
}
else if (prefix == "dump_osd_network") {
lock_guard l(osd_lock);
int64_t value = 0;
- if (!(cmd_getval(cct, cmdmap, "value", value))) {
+ if (!(cmd_getval(cmdmap, "value", value))) {
// Convert milliseconds to microseconds
value = static_cast<double>(g_conf().get_val<double>(
"mon_warn_on_slow_ping_time")) * 1000;
string poolstr;
- cmd_getval(service->cct, cmdmap, "pool", poolstr);
+ cmd_getval(cmdmap, "pool", poolstr);
pool = curmap->lookup_pg_pool_name(poolstr);
//If we can't find it by name then maybe id specified
if (pool < 0 && isdigit(poolstr[0]))
}
string objname, nspace;
- cmd_getval(service->cct, cmdmap, "objname", objname);
+ cmd_getval(cmdmap, "objname", objname);
std::size_t found = objname.find_first_of('/');
if (found != string::npos) {
nspace = objname.substr(0, found);
}
int64_t shardid;
- cmd_getval(service->cct, cmdmap, "shardid", shardid, int64_t(shard_id_t::NO_SHARD));
+ cmd_getval(cmdmap, "shardid", shardid, int64_t(shard_id_t::NO_SHARD));
hobject_t obj(object_t(objname), string(""), CEPH_NOSNAP, rawpg.ps(), pool, nspace);
ghobject_t gobj(obj, ghobject_t::NO_GEN, shard_id_t(uint8_t(shardid)));
spg_t pgid(curmap->raw_pg_to_pg(rawpg), shard_id_t(shardid));
map<string, bufferlist> newattrs;
bufferlist val;
string key, valstr;
- cmd_getval(service->cct, cmdmap, "key", key);
- cmd_getval(service->cct, cmdmap, "val", valstr);
+ cmd_getval(cmdmap, "key", key);
+ cmd_getval(cmdmap, "val", valstr);
val.append(valstr);
newattrs[key] = val;
ss << "ok";
} else if (command == "rmomapkey") {
string key;
- cmd_getval(service->cct, cmdmap, "key", key);
+ cmd_getval(cmdmap, "key", key);
t.omap_rmkey(coll_t(pgid), ghobject_t(obj), key);
r = store->queue_transaction(service->meta_ch, std::move(t));
bufferlist newheader;
string headerstr;
- cmd_getval(service->cct, cmdmap, "header", headerstr);
+ cmd_getval(cmdmap, "header", headerstr);
newheader.append(headerstr);
t.omap_setheader(coll_t(pgid), ghobject_t(obj), newheader);
r = store->queue_transaction(service->meta_ch, std::move(t));
}
} else if (command == "truncobj") {
int64_t trunclen;
- cmd_getval(service->cct, cmdmap, "len", trunclen);
+ cmd_getval(cmdmap, "len", trunclen);
t.truncate(coll_t(pgid), ghobject_t(obj), trunclen);
r = store->queue_transaction(service->meta_ch, std::move(t));
if (r < 0)
}
if (command == "set_recovery_delay") {
int64_t delay;
- cmd_getval(service->cct, cmdmap, "utime", delay, (int64_t)0);
+ cmd_getval(cmdmap, "utime", delay, (int64_t)0);
ostringstream oss;
oss << delay;
int r = service->cct->_conf.set_val("osd_recovery_delay_start",
int64_t count;
string type;
OSDService::s_names state;
- cmd_getval(service->cct, cmdmap, "type", type, string("full"));
- cmd_getval(service->cct, cmdmap, "count", count, (int64_t)-1);
+ cmd_getval(cmdmap, "type", type, string("full"));
+ cmd_getval(cmdmap, "count", count, (int64_t)-1);
if (type == "none" || count == 0) {
type = "none";
count = 0;
}
string cmd;
- if (!cmd_getval(&cct, cmdmap, "heapcmd", cmd)) {
+ if (!cmd_getval(cmdmap, "heapcmd", cmd)) {
os << "unable to get value for command \"" << cmd << "\"";
return -EINVAL;
}
get_str_vec(cmd, cmd_vec);
string val;
- if (cmd_getval(&cct, cmdmap, "value", val)) {
+ if (cmd_getval(cmdmap, "value", val)) {
cmd_vec.push_back(val);
}
std::function<void(int,const std::string&,bufferlist&)> on_finish)
{
string format;
- cmd_getval(cct, cmdmap, "format", format);
+ cmd_getval(cmdmap, "format", format);
std::unique_ptr<Formatter> f(Formatter::create(
format, "json-pretty", "json-pretty"));
int ret = 0;
// - ceph tell <pgid> foo -> prefix=foo
string prefix(orig_prefix);
string command;
- cmd_getval(cct, cmdmap, "cmd", command);
+ cmd_getval(cmdmap, "cmd", command);
if (command.size()) {
prefix = command;
}
else if (prefix == "mark_unfound_lost") {
string mulcmd;
- cmd_getval(cct, cmdmap, "mulcmd", mulcmd);
+ cmd_getval(cmdmap, "mulcmd", mulcmd);
int mode = -1;
if (mulcmd == "revert") {
if (pool.info.is_erasure()) {
hobject_t offset;
string offset_json;
bool show_offset = false;
- if (cmd_getval(cct, cmdmap, "offset", offset_json)) {
+ if (cmd_getval(cmdmap, "offset", offset_json)) {
json_spirit::Value v;
try {
if (!json_spirit::read(offset_json, v))
prefix == "deep_scrub") {
bool deep = (prefix == "deep_scrub");
int64_t time;
- cmd_getval(cct, cmdmap, "time", time, (int64_t)0);
+ cmd_getval(cmdmap, "time", time, (int64_t)0);
if (is_primary()) {
const pg_pool_t *p = &pool.info;
std::ostream& ss,
bufferlist& result) override {
std::vector<std::string> args;
- cmd_getval(g_ceph_context, cmdmap, "args", args);
+ cmd_getval(cmdmap, "args", args);
result.append(command);
result.append("|");
string resultstr;
std::ostream& ss,
bufferlist& result) override {
std::vector<std::string> args;
- cmd_getval(g_ceph_context, cmdmap, "args", args);
+ cmd_getval(cmdmap, "args", args);
result.append(command);
result.append("|");
string resultstr;
projects / ceph.git / commitdiff