213 lines
7.1 KiB
C++
213 lines
7.1 KiB
C++
// Copyright (c) Vitaliy Filippov, 2019+
|
|
// License: VNPL-1.1 (see README.md for details)
|
|
|
|
#include "cli_fix.h"
|
|
#include "cluster_client.h"
|
|
#include "pg_states.h"
|
|
#include "str_util.h"
|
|
#include "json_util.h"
|
|
|
|
std::vector<uint64_t> parse_uint64_list(json11::Json val);
|
|
|
|
// Find object(s) in the cluster using raw secondary listing operations.
|
|
// Only for troubleshooting.
|
|
struct cli_raw_ls_t
|
|
{
|
|
json11::Json cfg;
|
|
pool_id_t pool_id = 0;
|
|
pg_num_t pg_num = 0;
|
|
pg_num_t pg_count = 0;
|
|
uint32_t pg_stripe_size = 0;
|
|
std::set<uint64_t> osds;
|
|
std::vector<osd_num_t> osd_list;
|
|
uint64_t min_inode = 0, max_inode = 0, min_offset = 0, max_offset = 0;
|
|
bool offset_set = false;
|
|
|
|
cli_tool_t *parent = NULL;
|
|
int state = 0;
|
|
cli_result_t result;
|
|
bool first = true;
|
|
size_t osd_pos = 0;
|
|
|
|
bool is_done()
|
|
{
|
|
return state == 100;
|
|
}
|
|
|
|
void loop()
|
|
{
|
|
if (state == 1)
|
|
goto resume_1;
|
|
if (state == 100)
|
|
return;
|
|
pool_id = cfg["pool_id"].uint64_value();
|
|
pg_num = (pg_num_t)cfg["pg_num"].uint64_value();
|
|
pg_count = (pg_num_t)cfg["pg_count"].uint64_value();
|
|
pg_stripe_size = cfg["pg_stripe_size"].uint64_value();
|
|
if (!pool_id)
|
|
{
|
|
result = (cli_result_t){ .err = EINVAL, .text = "Pool ID is required" };
|
|
state = 100;
|
|
return;
|
|
}
|
|
if (cfg["min_inode"].is_null() && cfg["max_inode"].is_null())
|
|
{
|
|
min_inode = INODE_WITH_POOL(cfg["pool_id"].uint64_value(), 0);
|
|
max_inode = INODE_WITH_POOL(cfg["pool_id"].uint64_value(), UINT64_MAX);
|
|
}
|
|
else
|
|
{
|
|
min_inode = INODE_WITH_POOL(cfg["pool_id"].uint64_value(), stoull_full(cfg["min_inode"].as_string()));
|
|
max_inode = INODE_WITH_POOL(cfg["pool_id"].uint64_value(), stoull_full(cfg["max_inode"].as_string()));
|
|
}
|
|
if (cfg["offset"].is_null())
|
|
{
|
|
if (!pg_num)
|
|
{
|
|
result = (cli_result_t){ .err = EINVAL, .text = "PG number is required if offset is not specified" };
|
|
state = 100;
|
|
return;
|
|
}
|
|
min_offset = 0;
|
|
max_offset = UINT64_MAX;
|
|
}
|
|
else
|
|
{
|
|
min_offset = max_offset = stoull_full(cfg["offset"].as_string());
|
|
offset_set = true;
|
|
}
|
|
for (auto osd_num: parse_uint64_list(cfg["osds"]))
|
|
{
|
|
osds.insert(osd_num);
|
|
}
|
|
if (!pg_count || !pg_stripe_size || !osds.size())
|
|
{
|
|
auto pool_it = parent->cli->st_cli.pool_config.find(pool_id);
|
|
if (pool_it == parent->cli->st_cli.pool_config.end())
|
|
{
|
|
result = (cli_result_t){ .err = EINVAL, .text = "pg_count, pg_stripe_size and osds are required if the pool does not exist" };
|
|
state = 100;
|
|
return;
|
|
}
|
|
if (!pg_count)
|
|
{
|
|
pg_count = pool_it->second.real_pg_count;
|
|
}
|
|
if (!pg_stripe_size)
|
|
{
|
|
pg_stripe_size = pool_it->second.pg_stripe_size;
|
|
}
|
|
if (!osds.size())
|
|
{
|
|
for (auto & pgp: pool_it->second.pg_config)
|
|
{
|
|
for (osd_num_t pg_osd: pgp.second.target_set)
|
|
osds.insert(pg_osd);
|
|
for (osd_num_t pg_osd: pgp.second.all_peers)
|
|
osds.insert(pg_osd);
|
|
for (auto & hist_item: pgp.second.target_history)
|
|
for (auto pg_osd: hist_item)
|
|
osds.insert(pg_osd);
|
|
}
|
|
osds.erase(0);
|
|
}
|
|
}
|
|
if (offset_set)
|
|
{
|
|
min_offset = (min_offset / pg_stripe_size) * pg_stripe_size;
|
|
max_offset = ((max_offset / pg_stripe_size) * pg_stripe_size) | STRIPE_MASK;
|
|
pg_num = (min_offset/pg_stripe_size) % pg_count + 1; // like map_to_pg()
|
|
fprintf(stderr, "Selected PG %u\n", pg_num);
|
|
}
|
|
parent->cli->init_msgr();
|
|
osd_list = std::vector<osd_num_t>(osds.begin(), osds.end());
|
|
osd_pos = 0;
|
|
state = 1;
|
|
resume_1:
|
|
for (; osd_pos < osd_list.size() && parent->waiting < parent->parallel_osds; osd_pos++)
|
|
{
|
|
uint64_t osd_num = osd_list[osd_pos];
|
|
if (parent->cli->st_cli.peer_states[osd_num].is_null())
|
|
{
|
|
fprintf(stderr, "OSD %ju is unavailable, skipping\n", osd_num);
|
|
continue;
|
|
}
|
|
osd_op_t *op = new osd_op_t;
|
|
op->req = (osd_any_op_t){
|
|
.sec_list = {
|
|
.header = {
|
|
.magic = SECONDARY_OSD_OP_MAGIC,
|
|
.opcode = OSD_OP_SEC_LIST,
|
|
},
|
|
.list_pg = pg_num,
|
|
.pg_count = pg_count,
|
|
.pg_stripe_size = pg_stripe_size,
|
|
.min_inode = min_inode,
|
|
.max_inode = max_inode,
|
|
.min_stripe = min_offset,
|
|
.max_stripe = max_offset,
|
|
},
|
|
};
|
|
op->callback = [this, osd_num](osd_op_t *op)
|
|
{
|
|
if (op->reply.hdr.retval < 0)
|
|
{
|
|
fprintf(stderr, "OSD %ju listing failed: retval=%jd\n", osd_num, op->reply.hdr.retval);
|
|
}
|
|
else
|
|
{
|
|
for (uint64_t i = 0; i < op->reply.hdr.retval; i++)
|
|
{
|
|
auto & ov = ((obj_ver_id*)op->buf)[i];
|
|
if (parent->json_output)
|
|
{
|
|
printf("%s{\"osd\":%ju,\"inode\":\"0x%jx\",\"stripe\":\"0x%jx\",\"version\":%ju,\"stable\":%s}",
|
|
first ? "" : ",\n", osd_num, ov.oid.inode, ov.oid.stripe, ov.version,
|
|
i < op->reply.sec_list.stable_count ? "true" : "false");
|
|
first = false;
|
|
}
|
|
else
|
|
{
|
|
printf("OSD %ju - %jx:%jx v%ju%s\n",
|
|
osd_num, ov.oid.inode, ov.oid.stripe, ov.version,
|
|
i < op->reply.sec_list.stable_count ? " stable" : "");
|
|
}
|
|
}
|
|
}
|
|
parent->waiting--;
|
|
loop();
|
|
delete op;
|
|
};
|
|
parent->waiting++;
|
|
parent->cli->execute_raw(osd_num, op);
|
|
}
|
|
if (parent->waiting > 0)
|
|
{
|
|
return;
|
|
}
|
|
if (!first)
|
|
{
|
|
printf("\n");
|
|
}
|
|
state = 100;
|
|
}
|
|
};
|
|
|
|
std::function<bool(cli_result_t &)> cli_tool_t::start_raw_ls(json11::Json cfg)
|
|
{
|
|
auto raw_ls = new cli_raw_ls_t();
|
|
raw_ls->parent = this;
|
|
raw_ls->cfg = cfg;
|
|
return [raw_ls](cli_result_t & result)
|
|
{
|
|
raw_ls->loop();
|
|
if (raw_ls->is_done())
|
|
{
|
|
result = raw_ls->result;
|
|
delete raw_ls;
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
}
|