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 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 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;
}
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 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 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");
}
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);
}
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);
}
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;
}
/* Light request only contains header, without body content. */
int send_light_req(struct sd_req *hdr, const uint8_t *addr, int port)
{
int ret = dog_exec_req(addr, port, hdr, NULL);
struct sd_rsp *rsp = (struct sd_rsp *)hdr;
if (ret == -1)
return -1;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Response's result: %s", sd_strerror(rsp->result));
return -1;
}
return 0;
}
/* Light request only contains header, without body content. */
int send_light_req(const struct node_id *nid, struct sd_req *hdr)
{
int ret = dog_exec_req(nid, hdr, NULL);
struct sd_rsp *rsp = (struct sd_rsp *)hdr;
if (ret == -1)
return -1;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Response's result: %s", sd_strerror(rsp->result));
return -1;
}
return 0;
}
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 trace_read_buffer(void)
{
int ret, tfd;
int rval = EXIT_SUCCESS;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
#define TRACE_BUF_LEN (1024 * 1024 * 20)
char *buf = xmalloc(TRACE_BUF_LEN);
tfd = open(tracefile, O_CREAT | O_RDWR | O_APPEND | O_TRUNC, 0644);
if (tfd < 0) {
sd_err("can't create tracefile");
rval = EXIT_SYSFAIL;
goto out;
}
read_buffer:
sd_init_req(&hdr, SD_OP_TRACE_READ_BUF);
hdr.data_length = TRACE_BUF_LEN;
ret = dog_exec_req(&sd_nid, &hdr, buf);
if (ret < 0) {
rval = EXIT_SYSFAIL;
goto out;
}
if (rsp->result == SD_RES_AGAIN)
goto read_buffer;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Trace failed: %s", sd_strerror(rsp->result));
rval = EXIT_FAILURE;
goto out;
}
xwrite(tfd, buf, rsp->data_length);
if (rsp->data_length == TRACE_BUF_LEN)
goto read_buffer;
out:
free(buf);
return rval;
}
static int get_recovery_state(struct recovery_state *state)
{
int ret;
struct sd_req req;
struct sd_rsp *rsp = (struct sd_rsp *)&req;
sd_init_req(&req, SD_OP_STAT_RECOVERY);
req.data_length = sizeof(*state);
ret = dog_exec_req(sdhost, sdport, &req, state);
if (ret < 0) {
sd_err("Failed to execute request");
return -1;
}
if (rsp->result != SD_RES_SUCCESS) {
sd_err("%s", sd_strerror(rsp->result));
return -1;
}
return 0;
}
int do_loglevel_get(const struct node_id *nid, int32_t *ret_loglevel)
{
int32_t loglevel = -1;
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
sd_init_req(&hdr, SD_OP_GET_LOGLEVEL);
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;
*ret_loglevel = loglevel;
return EXIT_SUCCESS;
}
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;
}
static int trace_status(int argc, char **argv)
{
char buf[4096]; /* must have enough space to store tracer list */
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
sd_init_req(&hdr, SD_OP_TRACE_STATUS);
hdr.data_length = sizeof(buf);
ret = dog_exec_req(&sd_nid, &hdr, buf);
if (ret < 0)
return EXIT_SYSFAIL;
switch (rsp->result) {
sd_err("%s", sd_strerror(rsp->result));
return EXIT_FAILURE;
}
printf("%s", buf);
return EXIT_SUCCESS;
}
int do_loglevel_set(const struct node_id *nid, const char *loglevel_str)
{
int32_t loglevel = loglevel_str2num(loglevel_str);
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
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 list_store(void)
{
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
char buf[512] = { 0 };
sd_init_req(&hdr, SD_OP_GET_STORE_LIST);
hdr.data_length = 512;
ret = dog_exec_req(&sd_nid, &hdr, buf);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Restore failed: %s", sd_strerror(rsp->result));
return EXIT_FAILURE;
}
printf("Available stores:\n");
printf("---------------------------------------\n");
printf("%s\n", buf);
return EXIT_SYSFAIL;
}
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, *log;
char *next_log;
int nr_logs, log_length;
time_t ti, ct;
struct tm tm;
char time_str[128];
uint32_t nodes_nr;
nodes_nr = sd_nodes_nr;
log_length = sd_epoch * (sizeof(struct epoch_log)
+ nodes_nr * sizeof(struct sd_node));
logs = xmalloc(log_length);
retry:
sd_init_req(&hdr, SD_OP_STAT_CLUSTER);
hdr.data_length = log_length;
hdr.cluster.nodes_nr = nodes_nr;
ret = dog_exec_req(&sd_nid, &hdr, logs);
if (ret < 0)
goto error;
if (rsp->result == SD_RES_BUFFER_SMALL) {
nodes_nr *= 2;
log_length = sd_epoch * (sizeof(struct epoch_log)
+ nodes_nr * sizeof(struct sd_node));
logs = xrealloc(logs, log_length);
goto retry;
}
/* show cluster status */
if (!raw_output)
printf("Cluster status: ");
if (rsp->result == SD_RES_SUCCESS)
printf("running, auto-recovery enabled\n");
else
printf("%s\n", sd_strerror(rsp->result));
if (verbose) {
/* show cluster backend 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));
/* show vnode mode (node or disk) for cluster */
if (!raw_output)
printf("Cluster vnode mode: ");
if (logs->flags & SD_CLUSTER_FLAG_DISKMODE)
printf("disk");
else
printf("node");
}
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 update_node_list(int max_nodes)
{
int ret;
unsigned int size;
struct sd_node *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(&sd_nid, &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;
}
for (int i = 0; i < sd_nodes_nr; i++) {
struct sd_node *n = xmalloc(sizeof(*n));
int j;
*n = buf[i];
rb_insert(&sd_nroot, n, rb, node_cmp);
for (j = 0; j < sd_zones_nr; j++) {
if (sd_zones[j] == n->zone)
break;
}
if (j == sd_zones_nr)
sd_zones[sd_zones_nr++] = n->zone;
}
nodes_to_vnodes(&sd_nroot, &sd_vroot);
sd_epoch = hdr.epoch;
out:
if (buf)
free(buf);
return ret;
}
static int cluster_format(int argc, char **argv)
{
int ret;
struct sd_req hdr;
struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
struct timeval tv;
char store_name[STORE_LEN];
static DECLARE_BITMAP(vdi_inuse, SD_NR_VDIS);
if (cluster_cmd_data.copies > sd_nodes_nr) {
char info[1024];
snprintf(info, sizeof(info), "Number of copies (%d) is larger "
"than number of nodes (%d).\n"
"Are you sure you want to continue? [yes/no]: ",
cluster_cmd_data.copies, sd_nodes_nr);
confirm(info);
}
sd_init_req(&hdr, SD_OP_READ_VDIS);
hdr.data_length = sizeof(vdi_inuse);
ret = dog_exec_req(&sd_nid, &hdr, &vdi_inuse);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("%s", sd_strerror(rsp->result));
return EXIT_FAILURE;
}
if (!no_vdi(vdi_inuse))
confirm(FORMAT_PRINT);
gettimeofday(&tv, NULL);
sd_init_req(&hdr, SD_OP_MAKE_FS);
hdr.cluster.copies = cluster_cmd_data.copies;
hdr.cluster.copy_policy = cluster_cmd_data.copy_policy;
hdr.cluster.ctime = (uint64_t) tv.tv_sec << 32 | tv.tv_usec * 1000;
if (strlen(cluster_cmd_data.name))
pstrcpy(store_name, STORE_LEN, cluster_cmd_data.name);
else
pstrcpy(store_name, STORE_LEN, DEFAULT_STORE);
hdr.data_length = strlen(store_name) + 1;
hdr.flags |= SD_FLAG_CMD_WRITE;
if (cluster_cmd_data.strict)
hdr.cluster.flags |= SD_CLUSTER_FLAG_STRICT;
printf("using backend %s store\n", store_name);
ret = dog_exec_req(&sd_nid, &hdr, store_name);
if (ret < 0)
return EXIT_SYSFAIL;
if (rsp->result != SD_RES_SUCCESS) {
sd_err("Format failed: %s", sd_strerror(rsp->result));
if (rsp->result == SD_RES_NO_STORE)
return list_store();
else
return EXIT_SYSFAIL;
}
return EXIT_SUCCESS;
}
