static int do_plug_unplug(char *disks, bool plug)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int ret;
if (!strlen(disks)) {
sd_err("Empty path isn't allowed");
return EXIT_FAILURE;
}
if (plug)
sd_init_req(&hdr, SD_OP_MD_PLUG);
else
sd_init_req(&hdr, SD_OP_MD_UNPLUG);
hdr.flags = SD_FLAG_CMD_WRITE;
hdr.data_length = strlen(disks) + 1;
ret = dog_exec_req(sdhost, sdport, &hdr, disks);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Failed to execute request, look for sheep.log"
" for more information");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/*
* Make sure we don't overwrite the existing data for misaligned write
*
* If either offset or length of request isn't aligned to
* SD_EC_DATA_STRIPE_SIZE, we have to read the unaligned blocks before write.
* This kind of write amplification indeed slow down the write operation with
* extra read overhead.
*/
static void *init_erasure_buffer(struct request *req, int buf_len)
{
char *buf;
uint32_t len = req->rq.data_length;
uint64_t off = req->rq.obj.offset;
uint64_t oid = req->rq.obj.oid;
int opcode = req->rq.opcode;
struct sd_req hdr;
uint64_t head = round_down(off, SD_EC_DATA_STRIPE_SIZE);
uint64_t tail = round_down(off + len, SD_EC_DATA_STRIPE_SIZE);
int ret;
buf = valloc(buf_len);
if(unlikely(!buf))
return NULL;
memset(buf, 0, buf_len);
if (opcode != SD_OP_WRITE_OBJ)
goto out;
if (off % SD_EC_DATA_STRIPE_SIZE) {
/* Read head */
sd_init_req(&hdr, SD_OP_READ_OBJ);
hdr.obj.oid = oid;
hdr.data_length = SD_EC_DATA_STRIPE_SIZE;
hdr.obj.offset = head;
ret = exec_local_req(&hdr, buf);
if (ret != SD_RES_SUCCESS) {
free(buf);
return NULL;
}
}
if ((len + off) % SD_EC_DATA_STRIPE_SIZE && tail - head > 0) {
/* Read tail */
sd_init_req(&hdr, SD_OP_READ_OBJ);
hdr.obj.oid = oid;
hdr.data_length = SD_EC_DATA_STRIPE_SIZE;
hdr.obj.offset = tail;
ret = exec_local_req(&hdr, buf + tail - head);
if (ret != SD_RES_SUCCESS) {
free(buf);
return NULL;
}
}
out:
memcpy(buf + off % SD_EC_DATA_STRIPE_SIZE, req->data, len);
return buf;
}
int do_loglevel_set(const struct node_id *nid, const char *loglevel_str)
{
int32_t loglevel = -1;
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
for (int i = 0; i < ARRAY_SIZE(loglevel_table); i++) {
if (!strcmp(loglevel_table[i], loglevel_str)) {
loglevel = i;
break;
}
}
if (loglevel == -1)
return EXIT_USAGE;
sd_init_req(&hdr, SD_OP_SET_LOGLEVEL);
hdr.flags = SD_FLAG_CMD_WRITE;
hdr.data_length = sizeof(loglevel);
ret = dog_exec_req(nid, &hdr, &loglevel);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
static int node_kill(int argc, char **argv)
{
char host[128];
int node_id, ret;
struct sd_node_req req;
const char *p = argv[optind++];
if (!is_numeric(p)) {
fprintf(stderr, "Invalid node id '%s', "
"please specify a numeric value\n", p);
exit(EXIT_USAGE);
}
node_id = strtol(p, NULL, 10);
if (node_id < 0 || node_id >= sd_nodes_nr) {
fprintf(stderr, "Invalid node id '%d'\n", node_id);
exit(EXIT_USAGE);
}
addr_to_str(host, sizeof(host), sd_nodes[node_id].nid.addr, 0);
sd_init_req((struct sd_req *)&req, SD_OP_KILL_NODE);
ret = send_light_req((struct sd_req *)&req, host,
sd_nodes[node_id].nid.port);
if (ret) {
fprintf(stderr, "Failed to execute request\n");
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
static int node_md_info(struct node_id *nid)
{
struct sd_md_info info = {};
char size_str[UINT64_DECIMAL_SIZE], used_str[UINT64_DECIMAL_SIZE],
avail_str[UINT64_DECIMAL_SIZE];
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int ret, i;
sd_init_req(&hdr, SD_OP_MD_INFO);
hdr.data_length = sizeof(info);
ret = dog_exec_req(nid->addr, nid->port, &hdr, &info);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("failed to get multi-disk infomation: %s",
sd_strerror(rsp->result));
return EXIT_FAILURE;
}
for (i = 0; i < info.nr; i++) {
uint64_t size = info.disk[i].free + info.disk[i].used;
int ratio = (int)(((double)info.disk[i].used / size) * 100);
size_to_str(size, size_str, sizeof(size_str));
size_to_str(info.disk[i].used, used_str, sizeof(used_str));
size_to_str(info.disk[i].free, avail_str, sizeof(avail_str));
fprintf(stdout, "%2d\t%s\t%s\t%s\t%3d%%\t%s\n",
info.disk[i].idx, size_str, used_str, avail_str, ratio,
info.disk[i].path);
}
return EXIT_SUCCESS;
}
static int get_vdis_from(struct sd_node *node)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
struct vdi_copy *vc = NULL;
int i, ret = SD_RES_SUCCESS;
unsigned int rlen;
int count;
if (node_is_local(node))
goto out;
rlen = SD_DATA_OBJ_SIZE; /* FIXME */
vc = zalloc(rlen);
if (!vc) {
sd_printf(SDOG_ERR, "unable to allocate memory\n");
ret = SD_RES_NO_MEM;
goto out;
}
sd_init_req(&hdr, SD_OP_GET_VDI_COPIES);
hdr.data_length = rlen;
ret = sheep_exec_req(&node->nid, &hdr, (char *)vc);
if (ret != SD_RES_SUCCESS)
goto out;
count = rsp->data_length / sizeof(*vc);
for (i = 0; i < count; i++) {
set_bit(vc[i].vid, sys->vdi_inuse);
add_vdi_copy_number(vc[i].vid, vc[i].nr_copies);
}
out:
free(vc);
return ret;
}
static int trace_disable(int argc, char **argv)
{
const char *tracer = argv[optind];
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
sd_init_req(&hdr, SD_OP_TRACE_DISABLE);
hdr.flags = SD_FLAG_CMD_WRITE;
hdr.data_length = strlen(tracer) + 1;
ret = dog_exec_req(&sd_nid, &hdr, (void *)tracer);
if (ret < 0)
return EXIT_SYSFAIL;
switch (rsp->result) {
case SD_RES_SUCCESS:
break;
case SD_RES_NO_SUPPORT:
sd_err("no such tracer %s", tracer);
return EXIT_FAILURE;
case SD_RES_INVALID_PARMS:
sd_err("tracer %s is not enabled", tracer);
return EXIT_FAILURE;
default:
sd_err("unknown error (%s)", sd_strerror(rsp->result));
return EXIT_SYSFAIL;
}
return trace_read_buffer();
}
static int node_kill(int argc, char **argv)
{
int node_id, ret;
struct sd_req req;
const char *p = argv[optind++];
if (!is_numeric(p)) {
sd_err("Invalid node id '%s', please specify a numeric value",
p);
exit(EXIT_USAGE);
}
node_id = strtol(p, NULL, 10);
if (node_id < 0 || node_id >= sd_nodes_nr) {
sd_err("Invalid node id '%d'", node_id);
exit(EXIT_USAGE);
}
sd_init_req(&req, SD_OP_KILL_NODE);
ret = send_light_req(&req, sd_nodes[node_id].nid.addr,
sd_nodes[node_id].nid.port);
if (ret) {
sd_err("Failed to execute request");
exit(EXIT_FAILURE);
}
return EXIT_SUCCESS;
}
static int node_recovery(int argc, char **argv)
{
int i, ret;
if (!raw_output) {
printf("Nodes In Recovery:\n");
printf(" Id Host:Port V-Nodes Zone\n");
}
for (i = 0; i < sd_nodes_nr; i++) {
char host[128];
struct sd_node_req req;
addr_to_str(host, sizeof(host), sd_nodes[i].nid.addr, 0);
sd_init_req((struct sd_req *)&req, SD_OP_STAT_RECOVERY);
ret = send_light_req_get_response((struct sd_req *)&req, host,
sd_nodes[i].nid.port);
if (ret == SD_RES_NODE_IN_RECOVERY) {
addr_to_str(host, sizeof(host),
sd_nodes[i].nid.addr, sd_nodes[i].nid.port);
printf(raw_output ? "%d %s %d %d\n" : "%4d %-20s%5d%11d\n",
i, host, sd_nodes[i].nr_vnodes,
sd_nodes[i].zone);
}
}
return EXIT_SUCCESS;
}
int sd_read_object(uint64_t oid, void *data, unsigned int datalen,
uint64_t offset, bool direct)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int ret;
sd_init_req(&hdr, SD_OP_READ_OBJ);
hdr.data_length = datalen;
hdr.obj.oid = oid;
hdr.obj.offset = offset;
if (direct)
hdr.flags |= SD_FLAG_CMD_DIRECT;
ret = collie_exec_req(sdhost, sdport, &hdr, data);
if (ret < 0) {
fprintf(stderr, "Failed to read object %" PRIx64 "\n", oid);
return SD_RES_EIO;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Failed to read object %" PRIx64 " %s\n", oid,
sd_strerror(rsp->result));
return rsp->result;
}
untrim_zero_sectors(data, rsp->obj.offset, rsp->data_length, datalen);
return SD_RES_SUCCESS;
}
int sd_read_object(uint64_t oid, void *data, unsigned int datalen,
uint64_t offset, bool direct)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int ret;
sd_init_req(&hdr, SD_OP_READ_OBJ);
hdr.data_length = datalen;
hdr.obj.oid = oid;
hdr.obj.offset = offset;
if (direct)
hdr.flags |= SD_FLAG_CMD_DIRECT;
ret = dog_exec_req(&sd_nid, &hdr, data);
if (ret < 0) {
sd_err("Failed to read object %" PRIx64, oid);
return SD_RES_EIO;
}
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Failed to read object %" PRIx64 " %s", oid,
sd_strerror(rsp->result));
return rsp->result;
}
return SD_RES_SUCCESS;
}
static int list_store(void)
{
int fd, ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
char buf[512] = { 0 };
fd = connect_to(sdhost, sdport);
if (fd < 0)
return EXIT_SYSFAIL;
sd_init_req(&hdr, SD_OP_GET_STORE_LIST);
hdr.data_length = 512;
ret = exec_req(fd, &hdr, buf);
close(fd);
if (ret) {
fprintf(stderr, "Failed to connect\n");
return EXIT_SYSFAIL;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Restore failed: %s\n",
sd_strerror(rsp->result));
return EXIT_FAILURE;
}
printf("Available stores:\n");
printf("---------------------------------------\n");
printf("%s\n", buf);
return EXIT_SYSFAIL;
}
int sd_write_object(uint64_t oid, uint64_t cow_oid, void *data,
unsigned int datalen, uint64_t offset, uint32_t flags,
int copies, bool create, bool direct)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int fd, ret;
fd = connect_to(sdhost, sdport);
if (fd < 0) {
fprintf(stderr, "Failed to connect\n");
return SD_RES_EIO;
}
if (create)
sd_init_req(&hdr, SD_OP_CREATE_AND_WRITE_OBJ);
else
sd_init_req(&hdr, SD_OP_WRITE_OBJ);
hdr.data_length = datalen;
hdr.flags = flags | SD_FLAG_CMD_WRITE;
if (cow_oid)
hdr.flags |= SD_FLAG_CMD_COW;
if (direct)
hdr.flags |= SD_FLAG_CMD_DIRECT;
hdr.obj.copies = copies;
hdr.obj.oid = oid;
hdr.obj.cow_oid = cow_oid;
hdr.obj.offset = offset;
ret = collie_exec_req(fd, &hdr, data);
close(fd);
if (ret) {
fprintf(stderr, "Failed to write object %" PRIx64 "\n", oid);
return SD_RES_EIO;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Failed to write object %" PRIx64 ": %s\n", oid,
sd_strerror(rsp->result));
return rsp->result;
}
return SD_RES_SUCCESS;
}
int update_node_list(int max_nodes, uint32_t epoch)
{
int fd, ret;
unsigned int size;
char *buf = NULL;
struct sd_node *ent;
struct sd_node_req hdr;
struct sd_node_rsp *rsp = (struct sd_node_rsp *)&hdr;
fd = connect_to(sdhost, sdport);
if (fd < 0)
return -1;
size = sizeof(*ent) * max_nodes;
buf = xzalloc(size);
sd_init_req((struct sd_req *)&hdr, SD_OP_GET_NODE_LIST);
hdr.request_ver = epoch;
hdr.data_length = size;
ret = collie_exec_req(fd, (struct sd_req *)&hdr, buf);
if (ret) {
ret = -1;
goto out;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Failed to update node list: %s\n",
sd_strerror(rsp->result));
ret = -1;
goto out;
}
size = rsp->data_length;
sd_nodes_nr = size / sizeof(*ent);
if (sd_nodes_nr == 0) {
fprintf(stderr, "There are no active sheep daemons\n");
exit(EXIT_FAILURE);
}
/* FIXME */
if (sd_nodes_nr > max_nodes) {
ret = -1;
goto out;
}
memcpy(sd_nodes, buf, size);
sd_vnodes_nr = nodes_to_vnodes(sd_nodes, sd_nodes_nr, sd_vnodes);
sd_epoch = hdr.epoch;
master_idx = rsp->master_idx;
out:
if (buf)
free(buf);
if (fd >= 0)
close(fd);
return ret;
}
static int node_info(int argc, char **argv)
{
int i, ret, success = 0;
uint64_t total_size = 0, total_avail = 0, total_vdi_size = 0;
char total_str[UINT64_DECIMAL_SIZE], avail_str[UINT64_DECIMAL_SIZE], vdi_size_str[UINT64_DECIMAL_SIZE];
if (!raw_output)
printf("Id\tSize\tUsed\tUse%%\n");
for (i = 0; i < sd_nodes_nr; i++) {
char host[128];
struct sd_node_req req;
struct sd_node_rsp *rsp = (struct sd_node_rsp *)&req;
char store_str[UINT64_DECIMAL_SIZE], free_str[UINT64_DECIMAL_SIZE];
addr_to_str(host, sizeof(host), sd_nodes[i].nid.addr, 0);
sd_init_req((struct sd_req *)&req, SD_OP_STAT_SHEEP);
req.epoch = sd_epoch;
ret = send_light_req((struct sd_req *)&req, host,
sd_nodes[i].nid.port);
size_to_str(rsp->store_size, store_str, sizeof(store_str));
size_to_str(rsp->store_size - rsp->store_free, free_str,
sizeof(free_str));
if (!ret) {
printf(raw_output ? "%d %s %s %d%%\n" : "%2d\t%s\t%s\t%3d%%\n",
i, store_str, free_str,
rsp->store_size == 0 ? 0 :
(int)(((double)(rsp->store_size - rsp->store_free) / rsp->store_size) * 100));
success++;
}
total_size += rsp->store_size;
total_avail += rsp->store_free;
}
if (success == 0) {
fprintf(stderr, "Cannot get information from any nodes\n");
return EXIT_SYSFAIL;
}
if (parse_vdi(cal_total_vdi_size, SD_INODE_HEADER_SIZE,
&total_vdi_size) < 0)
return EXIT_SYSFAIL;
size_to_str(total_size, total_str, sizeof(total_str));
size_to_str(total_size - total_avail, avail_str, sizeof(avail_str));
size_to_str(total_vdi_size, vdi_size_str, sizeof(vdi_size_str));
printf(raw_output ? "Total %s %s %d%% %s\n"
: "Total\t%s\t%s\t%3d%%\n\nTotal virtual image size\t%s\n",
total_str, avail_str,
(int)(((double)(total_size - total_avail) / total_size) * 100),
vdi_size_str);
return EXIT_SUCCESS;
}
static int find_vdi_name(char *vdiname, uint32_t snapid, const char *tag,
uint32_t *vid, int for_snapshot)
{
int ret, fd;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
unsigned int wlen, rlen = 0;
char buf[SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN];
fd = connect_to(sdhost, sdport);
if (fd < 0)
return -1;
memset(buf, 0, sizeof(buf));
strncpy(buf, vdiname, SD_MAX_VDI_LEN);
strncpy(buf + SD_MAX_VDI_LEN, tag, SD_MAX_VDI_TAG_LEN);
if (for_snapshot)
sd_init_req(&hdr, SD_OP_GET_VDI_INFO);
else
sd_init_req(&hdr, SD_OP_LOCK_VDI);
wlen = SD_MAX_VDI_LEN + SD_MAX_VDI_TAG_LEN;
hdr.data_length = wlen;
hdr.flags = SD_FLAG_CMD_WRITE;
hdr.vdi.snapid = snapid;
ret = exec_req(fd, &hdr, buf, &wlen, &rlen);
if (ret) {
ret = -1;
goto out;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Cannot get VDI info for %s %d %s: %s\n",
vdiname, snapid, tag, sd_strerror(rsp->result));
ret = -1;
goto out;
}
*vid = rsp->vdi.vdi_id;
ret = 0;
out:
close(fd);
return ret;
}
static int cluster_info(int argc, char **argv)
{
int i, ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
struct epoch_log *logs;
int nr_logs, log_length;
time_t ti, ct;
struct tm tm;
char time_str[128];
log_length = sd_epoch * sizeof(struct epoch_log);
logs = xmalloc(log_length);
sd_init_req(&hdr, SD_OP_STAT_CLUSTER);
hdr.data_length = log_length;
ret = dog_exec_req(&sd_nid, &hdr, logs);
if (ret < 0)
goto error;
/* show cluster status */
if (!raw_output)
printf("Cluster status: ");
if (rsp->result == SD_RES_SUCCESS)
printf("running, auto-recovery %s\n", logs->disable_recovery ?
"disabled" : "enabled");
else
printf("%s\n", sd_strerror(rsp->result));
/* show cluster backend store */
if (cluster_cmd_data.show_store) {
if (!raw_output)
printf("Cluster store: ");
if (rsp->result == SD_RES_SUCCESS) {
char copy[10];
int data, parity;
if (!logs->copy_policy)
snprintf(copy, sizeof(copy), "%d",
logs->nr_copies);
else {
ec_policy_to_dp(logs->copy_policy,
&data, &parity);
snprintf(copy, sizeof(copy), "%d:%d",
data, parity);
}
printf("%s with %s redundancy policy\n",
logs->drv_name, copy);
} else
printf("%s\n", sd_strerror(rsp->result));
}
if (!raw_output && rsp->data_length > 0) {
ct = logs[0].ctime >> 32;
printf("\nCluster created at %s\n", ctime(&ct));
printf("Epoch Time Version\n");
}
static int vdi_read_write(uint32_t vid, char *data, size_t length,
off_t offset, bool is_read)
{
struct sd_req hdr;
uint32_t idx = offset / SD_DATA_OBJ_SIZE;
uint64_t done = 0;
struct request_iocb *iocb;
int ret;
iocb = local_req_init();
if (!iocb)
return SD_RES_SYSTEM_ERROR;
offset %= SD_DATA_OBJ_SIZE;
while (done < length) {
size_t len = min(length - done, SD_DATA_OBJ_SIZE - offset);
if (is_read) {
sd_init_req(&hdr, SD_OP_READ_OBJ);
} else {
sd_init_req(&hdr, SD_OP_CREATE_AND_WRITE_OBJ);
hdr.flags = SD_FLAG_CMD_WRITE;
}
hdr.data_length = len;
hdr.obj.oid = vid_to_data_oid(vid, idx);
hdr.obj.offset = offset;
ret = exec_local_req_async(&hdr, data, iocb);
if (ret != SD_RES_SUCCESS)
sd_err("failed to write object %" PRIx64 ", %s",
hdr.obj.oid, sd_strerror(ret));
offset += len;
if (offset == SD_DATA_OBJ_SIZE) {
offset = 0;
idx++;
}
done += len;
data += len;
}
return local_req_wait(iocb);
}
int parse_vdi(vdi_parser_func_t func, size_t size, void *data)
{
int ret;
unsigned long nr;
static struct sd_inode i;
struct sd_req req;
struct sd_rsp *rsp = (struct sd_rsp *)&req;
static DECLARE_BITMAP(vdi_inuse, SD_NR_VDIS);
unsigned int rlen = sizeof(vdi_inuse);
sd_init_req(&req, SD_OP_READ_VDIS);
req.data_length = sizeof(vdi_inuse);
ret = dog_exec_req(sdhost, sdport, &req, &vdi_inuse);
if (ret < 0)
goto out;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("%s", sd_strerror(rsp->result));
goto out;
}
FOR_EACH_VDI(nr, vdi_inuse) {
uint64_t oid;
uint32_t snapid;
oid = vid_to_vdi_oid(nr);
memset(&i, 0, sizeof(i));
ret = sd_read_object(oid, &i, SD_INODE_HEADER_SIZE, 0, true);
if (ret != SD_RES_SUCCESS) {
sd_err("Failed to read inode header");
continue;
}
if (i.name[0] == '\0') /* this VDI has been deleted */
continue;
if (size > SD_INODE_HEADER_SIZE) {
rlen = DIV_ROUND_UP(i.vdi_size, SD_DATA_OBJ_SIZE) *
sizeof(i.data_vdi_id[0]);
if (rlen > size - SD_INODE_HEADER_SIZE)
rlen = size - SD_INODE_HEADER_SIZE;
ret = sd_read_object(oid, ((char *)&i) + SD_INODE_HEADER_SIZE,
rlen, SD_INODE_HEADER_SIZE, true);
if (ret != SD_RES_SUCCESS) {
sd_err("Failed to read inode");
continue;
}
}
snapid = vdi_is_snapshot(&i) ? i.snap_id : 0;
func(i.vdi_id, i.name, i.tag, snapid, 0, &i, data);
}
static int trace_read_buffer(void)
{
int fd, ret, tfd;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
unsigned rlen, wlen;
#define TRACE_BUF_LEN (1024 * 1024 * 20)
char *buf = xzalloc(TRACE_BUF_LEN);
tfd = open(tracefile, O_CREAT | O_RDWR | O_APPEND | O_TRUNC, 0644);
if (tfd < 0) {
fprintf(stderr, "can't create tracefile\n");
return EXIT_SYSFAIL;
}
fd = connect_to(sdhost, sdport);
if (fd < 0)
return EXIT_SYSFAIL;
read_buffer:
sd_init_req(&hdr, SD_OP_TRACE_READ_BUF);
hdr.data_length = rlen = TRACE_BUF_LEN;
hdr.epoch = sd_epoch;
wlen = 0;
ret = exec_req(fd, &hdr, buf, &wlen, &rlen);
if (ret) {
fprintf(stderr, "Failed to connect\n");
close(fd);
return EXIT_SYSFAIL;
}
if (rsp->result == SD_RES_AGAIN)
goto read_buffer;
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Trace failed: %s\n",
sd_strerror(rsp->result));
close(fd);
return EXIT_FAILURE;
}
xwrite(tfd, buf, rlen);
if (rlen == TRACE_BUF_LEN) {
memset(buf, 0, TRACE_BUF_LEN);
goto read_buffer;
}
close(fd);
free(buf);
return EXIT_SUCCESS;
}
int parse_vdi(vdi_parser_func_t func, size_t size, void *data)
{
int ret;
unsigned long nr;
struct sd_inode *i = xmalloc(sizeof(*i));
struct sd_req req;
struct sd_rsp *rsp = (struct sd_rsp *)&req;
static DECLARE_BITMAP(vdi_inuse, SD_NR_VDIS);
uint32_t rlen;
sd_init_req(&req, SD_OP_READ_VDIS);
req.data_length = sizeof(vdi_inuse);
ret = dog_exec_req(&sd_nid, &req, vdi_inuse);
if (ret < 0)
goto out;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("%s", sd_strerror(rsp->result));
goto out;
}
FOR_EACH_VDI(nr, vdi_inuse) {
uint64_t oid;
uint32_t snapid;
oid = vid_to_vdi_oid(nr);
/* for B-tree inode, we also need sd_index_header */
ret = dog_read_object(oid, i, SD_INODE_HEADER_SIZE +
sizeof(struct sd_index_header), 0, true);
if (ret != SD_RES_SUCCESS) {
sd_err("Failed to read inode header");
continue;
}
if (i->name[0] == '\0') /* this VDI has been deleted */
continue;
if (size > SD_INODE_HEADER_SIZE) {
rlen = sd_inode_get_meta_size(i, size);
ret = dog_read_object(oid,
((char *)i) + SD_INODE_HEADER_SIZE,
rlen, SD_INODE_HEADER_SIZE, true);
if (ret != SD_RES_SUCCESS) {
sd_err("Failed to read inode");
continue;
}
}
snapid = vdi_is_snapshot(i) ? i->snap_id : 0;
func(i->vdi_id, i->name, i->tag, snapid, 0, i, data);
}
int sd_write_object(uint64_t oid, uint64_t cow_oid, void *data,
unsigned int datalen, uint64_t offset, uint32_t flags,
uint8_t copies, uint8_t copy_policy, bool create,
bool direct)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int ret;
if (create)
sd_init_req(&hdr, SD_OP_CREATE_AND_WRITE_OBJ);
else
sd_init_req(&hdr, SD_OP_WRITE_OBJ);
hdr.data_length = datalen;
hdr.flags = flags | SD_FLAG_CMD_WRITE;
if (cow_oid)
hdr.flags |= SD_FLAG_CMD_COW;
if (direct)
hdr.flags |= SD_FLAG_CMD_DIRECT;
hdr.obj.copies = copies;
hdr.obj.copy_policy = copy_policy;
hdr.obj.oid = oid;
hdr.obj.cow_oid = cow_oid;
hdr.obj.offset = offset;
ret = dog_exec_req(&sd_nid, &hdr, data);
if (ret < 0) {
sd_err("Failed to write object %" PRIx64, oid);
return SD_RES_EIO;
}
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Failed to write object %" PRIx64 ": %s", oid,
sd_strerror(rsp->result));
return rsp->result;
}
return SD_RES_SUCCESS;
}
/* Write data to both local object cache (if enabled) and backends */
int write_object(uint64_t oid, char *data, unsigned int datalen,
uint64_t offset, bool create)
{
struct sd_req hdr;
int ret;
if (sys->enable_object_cache && object_is_cached(oid)) {
ret = object_cache_write(oid, data, datalen, offset,
create);
if (ret == SD_RES_NO_CACHE)
goto forward_write;
if (ret != 0) {
sd_eprintf("write cache failed %"PRIx64" %"PRIx32, oid,
ret);
return ret;
}
}
forward_write:
if (create)
sd_init_req(&hdr, SD_OP_CREATE_AND_WRITE_OBJ);
else
sd_init_req(&hdr, SD_OP_WRITE_OBJ);
hdr.flags = SD_FLAG_CMD_WRITE;
hdr.data_length = datalen;
hdr.obj.oid = oid;
hdr.obj.offset = offset;
hdr.obj.copies = get_vdi_copy_number(oid_to_vid(oid));
ret = exec_local_req(&hdr, data);
if (ret != SD_RES_SUCCESS)
sd_eprintf("failed to write object %" PRIx64 ", %s", oid,
sd_strerror(ret));
return ret;
}
static int node_recovery(int argc, char **argv)
{
int i, ret;
if (node_cmd_data.recovery_progress)
return node_recovery_progress();
if (!raw_output) {
printf("Nodes In Recovery:\n");
printf(" Id Host:Port V-Nodes Zone"
" Progress\n");
}
for (i = 0; i < sd_nodes_nr; i++) {
struct sd_req req;
struct sd_rsp *rsp = (struct sd_rsp *)&req;
struct recovery_state state;
memset(&state, 0, sizeof(state));
sd_init_req(&req, SD_OP_STAT_RECOVERY);
req.data_length = sizeof(state);
ret = dog_exec_req(sd_nodes[i].nid.addr,
sd_nodes[i].nid.port, &req, &state);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("%s", sd_strerror(rsp->result));
return EXIT_FAILURE;
}
if (state.in_recovery) {
const char *host = addr_to_str(sd_nodes[i].nid.addr,
sd_nodes[i].nid.port);
if (raw_output)
printf("%d %s %d %d %"PRIu64" %"PRIu64"\n", i,
host, sd_nodes[i].nr_vnodes,
sd_nodes[i].zone, state.nr_finished,
state.nr_total);
else
printf("%4d %-20s%5d%11d%11.1f%%\n", i, host,
sd_nodes[i].nr_vnodes, sd_nodes[i].zone,
100 * (float)state.nr_finished
/ state.nr_total);
}
}
return EXIT_SUCCESS;
}
static int do_vdi_create(char *vdiname, int64_t vdi_size, uint32_t base_vid,
uint32_t *vdi_id, int snapshot, int nr_copies)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
int fd, ret;
unsigned int wlen, rlen = 0;
char buf[SD_MAX_VDI_LEN];
fd = connect_to(sdhost, sdport);
if (fd < 0) {
fprintf(stderr, "Failed to connect\n");
return EXIT_SYSFAIL;
}
memset(buf, 0, sizeof(buf));
strncpy(buf, vdiname, SD_MAX_VDI_LEN);
wlen = SD_MAX_VDI_LEN;
sd_init_req(&hdr, SD_OP_NEW_VDI);
hdr.flags = SD_FLAG_CMD_WRITE;
hdr.data_length = wlen;
hdr.vdi.base_vdi_id = base_vid;
hdr.vdi.snapid = snapshot;
hdr.vdi.vdi_size = roundup(vdi_size, 512);
hdr.vdi.copies = nr_copies;
ret = exec_req(fd, &hdr, buf, &wlen, &rlen);
close(fd);
if (ret) {
fprintf(stderr, "Failed to send a request\n");
return EXIT_SYSFAIL;
}
if (rsp->result != SD_RES_SUCCESS) {
fprintf(stderr, "Failed to create VDI %s: %s\n", vdiname,
sd_strerror(rsp->result));
return EXIT_FAILURE;
}
if (vdi_id)
*vdi_id = rsp->vdi.vdi_id;
return EXIT_SUCCESS;
}
int sd_discard_object(uint64_t oid)
{
int ret;
struct sd_req hdr;
sd_init_req(&hdr, SD_OP_DISCARD_OBJ);
hdr.obj.oid = oid;
ret = exec_local_req(&hdr, NULL);
if (ret != SD_RES_SUCCESS)
sd_err("Failed to discard data obj %"PRIu64" %s", oid,
sd_strerror(ret));
return ret;
}
int update_node_list(int max_nodes)
{
int ret;
unsigned int size;
char *buf = NULL;
struct sd_node *ent;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
size = sizeof(*ent) * max_nodes;
buf = xzalloc(size);
sd_init_req(&hdr, SD_OP_GET_NODE_LIST);
hdr.data_length = size;
ret = dog_exec_req(sdhost, sdport, &hdr, buf);
if (ret < 0)
goto out;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Failed to update node list: %s",
sd_strerror(rsp->result));
ret = -1;
goto out;
}
size = rsp->data_length;
sd_nodes_nr = size / sizeof(*ent);
if (sd_nodes_nr == 0) {
sd_err("There are no active sheep daemons");
exit(EXIT_FAILURE);
}
/* FIXME */
if (sd_nodes_nr > max_nodes) {
ret = -1;
goto out;
}
memcpy(sd_nodes, buf, size);
sd_vnodes_nr = nodes_to_vnodes(sd_nodes, sd_nodes_nr, sd_vnodes);
sd_epoch = hdr.epoch;
out:
if (buf)
free(buf);
return ret;
}
static int cluster_info(int argc, char **argv)
{
int i, fd, ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
struct epoch_log *logs;
int nr_logs, log_length;
time_t ti, ct;
struct tm tm;
char time_str[128];
log_length = sd_epoch * sizeof(struct epoch_log);
again:
logs = malloc(log_length);
if (!logs) {
if (log_length < 10) {
fprintf(stderr, "No memory to allocate.\n");
return EXIT_SYSFAIL;
}
log_length /= 2;
goto again;
}
fd = connect_to(sdhost, sdport);
if (fd < 0)
goto error;
sd_init_req(&hdr, SD_OP_STAT_CLUSTER);
hdr.data_length = log_length;
ret = exec_req(fd, &hdr, logs);
close(fd);
if (ret != 0)
goto error;
if (!raw_output)
printf("Cluster status: ");
if (rsp->result == SD_RES_SUCCESS)
printf("running\n");
else
printf("%s\n", sd_strerror(rsp->result));
if (!raw_output && rsp->data_length > 0) {
ct = logs[0].ctime >> 32;
printf("\nCluster created at %s\n", ctime(&ct));
printf("Epoch Time Version\n");
}
int remove_object(uint64_t oid)
{
struct sd_req hdr;
int ret;
sd_init_req(&hdr, SD_OP_REMOVE_OBJ);
hdr.obj.oid = oid;
hdr.obj.copies = get_vdi_copy_number(oid_to_vid(oid));
ret = exec_local_req(&hdr, NULL);
if (ret != SD_RES_SUCCESS)
sd_eprintf("failed to remove object %" PRIx64 ", %s", oid,
sd_strerror(ret));
return ret;
}
static int recover_object_from_replica(uint64_t oid,
const struct sd_vnode *vnode,
uint32_t epoch, uint32_t tgt_epoch)
{
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
unsigned rlen;
int ret = SD_RES_NO_MEM;
void *buf = NULL;
struct siocb iocb = { 0 };
if (vnode_is_local(vnode)) {
ret = sd_store->link(oid, tgt_epoch);
goto out;
}
rlen = get_objsize(oid);
buf = valloc(rlen);
if (!buf) {
sd_eprintf("%m");
goto out;
}
sd_init_req(&hdr, SD_OP_READ_PEER);
hdr.epoch = epoch;
hdr.flags = SD_FLAG_CMD_RECOVERY;
hdr.data_length = rlen;
hdr.obj.oid = oid;
hdr.obj.tgt_epoch = tgt_epoch;
ret = sheep_exec_req(&vnode->nid, &hdr, buf);
if (ret != SD_RES_SUCCESS)
goto out;
iocb.epoch = epoch;
iocb.length = rsp->data_length;
iocb.offset = rsp->obj.offset;
iocb.buf = buf;
ret = sd_store->create_and_write(oid, &iocb);
out:
if (ret == SD_RES_SUCCESS) {
sd_dprintf("recovered oid %"PRIx64" from %d to epoch %d", oid,
tgt_epoch, epoch);
objlist_cache_insert(oid);
}
free(buf);
return ret;
}
