Currently, sheepdog is using a word "snapshot" as a terminology for vdi state synchronization during node joining (e.g. SD_OP_VDI_STATE_SNAPSHOT_CTL). It is confusing because the word snapshot resembles snapshot of VDIs.
This patch changes the terminology to checkpoint based on the famous textbook: http://www.cs.cornell.edu/projects/quicksilver/public_pdfs/History.pdf Signed-off-by: Hitoshi Mitake <mitake.hito...@lab.ntt.co.jp> --- include/internal_proto.h | 2 +- include/sheepdog_proto.h | 2 +- sheep/group.c | 24 +++++++++--------- sheep/ops.c | 22 ++++++++--------- sheep/sheep_priv.h | 8 +++--- sheep/vdi.c | 63 ++++++++++++++++++++++++------------------------ 6 files changed, 61 insertions(+), 60 deletions(-) diff --git a/include/internal_proto.h b/include/internal_proto.h index a1a073d..b3cbbc5 100644 --- a/include/internal_proto.h +++ b/include/internal_proto.h @@ -108,7 +108,7 @@ #define SD_OP_ALLOW_INODE_UPDATE 0xC4 #define SD_OP_REPAIR_REPLICA 0xC5 #define SD_OP_OIDS_EXIST 0xC6 -#define SD_OP_VDI_STATE_SNAPSHOT_CTL 0xC7 +#define SD_OP_VDI_STATE_CHECKPOINT_CTL 0xC7 #define SD_OP_INODE_COHERENCE 0xC8 #define SD_OP_READ_DEL_VDIS 0xC9 #define SD_OP_GET_RECOVERY 0xCA diff --git a/include/sheepdog_proto.h b/include/sheepdog_proto.h index 4a6edbe..4b9dacc 100644 --- a/include/sheepdog_proto.h +++ b/include/sheepdog_proto.h @@ -198,7 +198,7 @@ struct sd_req { struct { uint32_t get; /* 0 means free, 1 means get */ uint32_t tgt_epoch; - } vdi_state_snapshot; + } vdi_state_checkpoint; struct { /* 1 means validate, 0 means invalidate */ uint32_t vid; diff --git a/sheep/group.c b/sheep/group.c index 7c7cb6d..e342453 100644 --- a/sheep/group.c +++ b/sheep/group.c @@ -710,18 +710,18 @@ static struct vdi_state *do_cinfo_collection_work(uint32_t epoch, vs = xcalloc(rlen, sizeof(*vs)); retry: - sd_init_req(&hdr, SD_OP_VDI_STATE_SNAPSHOT_CTL); - hdr.vdi_state_snapshot.get = 1; - hdr.vdi_state_snapshot.tgt_epoch = epoch; + sd_init_req(&hdr, SD_OP_VDI_STATE_CHECKPOINT_CTL); + hdr.vdi_state_checkpoint.get = 1; + hdr.vdi_state_checkpoint.tgt_epoch = epoch; hdr.data_length = rlen; ret = sheep_exec_req(&n->nid, &hdr, (char *)vs); if (ret == SD_RES_SUCCESS) { - sd_debug("succeed to obtain snapshot of vdi states"); + sd_debug("succeed to obtain checkpoint of vdi states"); *nr_vdi_states = rsp->data_length / sizeof(*vs); return vs; } else if (ret == SD_RES_BUFFER_SMALL) { - sd_debug("buffer is small for obtaining snapshot of vdi states," + sd_debug("buffer is small for obtaining checkpoint of vdi states," " doubling it (%lu -> %lu)", rlen * sizeof(*vs), rlen * 2 * sizeof(*vs)); rlen *= 2; @@ -729,7 +729,7 @@ retry: goto retry; } - sd_err("failed to obtain snapshot of vdi states from node %s", + sd_err("failed to obtain checkpoint of vdi states from node %s", node_to_str(n)); return NULL; } @@ -756,7 +756,7 @@ static void cinfo_collection_work(struct work *work) goto get_succeed; } - panic("getting a snapshot of vdi state at epoch %d failed", w->epoch); + panic("getting a checkpoint of vdi state at epoch %d failed", w->epoch); get_succeed: w->nr_vdi_states = nr_vdi_states; @@ -768,13 +768,13 @@ get_succeed: if (node_is_local(n)) continue; - sd_init_req(&hdr, SD_OP_VDI_STATE_SNAPSHOT_CTL); - hdr.vdi_state_snapshot.get = 0; - hdr.vdi_state_snapshot.tgt_epoch = w->epoch; + sd_init_req(&hdr, SD_OP_VDI_STATE_CHECKPOINT_CTL); + hdr.vdi_state_checkpoint.get = 0; + hdr.vdi_state_checkpoint.tgt_epoch = w->epoch; ret = sheep_exec_req(&n->nid, &hdr, (char *)vs); if (ret != SD_RES_SUCCESS) - sd_err("error at freeing a snapshot of vdi state" + sd_err("error at freeing a checkpoint of vdi state" " at epoch %d", w->epoch); } @@ -906,7 +906,7 @@ static void update_cluster_info(const struct cluster_info *cinfo, } } else { if (0 < cinfo->epoch && cinfo->status == SD_STATUS_OK) - take_vdi_state_snapshot(cinfo->epoch - 1); + create_vdi_state_checkpoint(cinfo->epoch - 1); } sockfd_cache_add(&joined->nid); diff --git a/sheep/ops.c b/sheep/ops.c index 7b92f8c..223994c 100644 --- a/sheep/ops.c +++ b/sheep/ops.c @@ -1454,30 +1454,30 @@ static int cluster_release_vdi_main(const struct sd_req *req, return SD_RES_SUCCESS; } -static int local_vdi_state_snapshot_ctl(const struct sd_req *req, +static int local_vdi_state_checkpoint_ctl(const struct sd_req *req, struct sd_rsp *rsp, void *data, const struct sd_node *sender) { - bool get = !!req->vdi_state_snapshot.get; - int epoch = req->vdi_state_snapshot.tgt_epoch; + bool get = !!req->vdi_state_checkpoint.get; + int epoch = req->vdi_state_checkpoint.tgt_epoch; int ret, length = 0; - sd_info("%s vdi state snapshot at epoch %d", + sd_info("%s vdi state checkpoint at epoch %d", get ? "getting" : "freeing", epoch); if (get) { - ret = get_vdi_state_snapshot(epoch, data, req->data_length, - &length); + ret = get_vdi_state_checkpoint(epoch, data, req->data_length, + &length); if (ret == SD_RES_SUCCESS) rsp->data_length = length; else { - sd_info("failed to get vdi state snapshot: %s", + sd_info("failed to get vdi state checkpoint: %s", sd_strerror(ret)); return ret; } } else - free_vdi_state_snapshot(epoch); + free_vdi_state_checkpoint(epoch); return SD_RES_SUCCESS; } @@ -1948,10 +1948,10 @@ static struct sd_op_template sd_ops[] = { .process_work = local_repair_replica, }, - [SD_OP_VDI_STATE_SNAPSHOT_CTL] = { - .name = "VDI_STATE_SNAPSHOT_CTL", + [SD_OP_VDI_STATE_CHECKPOINT_CTL] = { + .name = "VDI_STATE_CHECKPOINT_CTL", .type = SD_OP_TYPE_LOCAL, - .process_main = local_vdi_state_snapshot_ctl, + .process_main = local_vdi_state_checkpoint_ctl, }, [SD_OP_GET_CLUSTER_DEFAULT] = { diff --git a/sheep/sheep_priv.h b/sheep/sheep_priv.h index 7becf6e..8c173a9 100644 --- a/sheep/sheep_priv.h +++ b/sheep/sheep_priv.h @@ -371,10 +371,10 @@ int sd_create_hyper_volume(const char *name, uint32_t *vdi_id); bool vdi_lock(uint32_t vid, const struct node_id *owner, int type); bool vdi_unlock(uint32_t vid, const struct node_id *owner, int type); void apply_vdi_lock_state(struct vdi_state *vs); -void take_vdi_state_snapshot(int epoch); -int get_vdi_state_snapshot(int epoch, void *data, int data_len_max, - int *data_len_result); -void free_vdi_state_snapshot(int epoch); +void create_vdi_state_checkpoint(int epoch); +int get_vdi_state_checkpoint(int epoch, void *data, int data_len_max, + int *data_len_result); +void free_vdi_state_checkpoint(int epoch); void log_vdi_op_lock(uint32_t vid, const struct node_id *owner, int type); void log_vdi_op_unlock(uint32_t vid, const struct node_id *owner, int type); void play_logged_vdi_ops(void); diff --git a/sheep/vdi.c b/sheep/vdi.c index 7f6cf67..aeb6e68 100644 --- a/sheep/vdi.c +++ b/sheep/vdi.c @@ -2118,83 +2118,84 @@ out: return ret; } -struct vdi_state_snapshot { +struct vdi_state_checkpoint { int epoch, nr_vs; struct vdi_state *vs; struct list_node list; }; -static LIST_HEAD(vdi_state_snapshot_list); +static LIST_HEAD(vdi_state_checkpoint_list); -main_fn void take_vdi_state_snapshot(int epoch) +main_fn void create_vdi_state_checkpoint(int epoch) { /* - * take a snapshot of current vdi state and associate it with + * take a checkpoint of current vdi state and associate it with * the given epoch */ - struct vdi_state_snapshot *snapshot; + struct vdi_state_checkpoint *checkpoint; - list_for_each_entry(snapshot, &vdi_state_snapshot_list, list) { - if (snapshot->epoch == epoch) { - sd_debug("duplicate snapshot of epoch %d", epoch); + list_for_each_entry(checkpoint, &vdi_state_checkpoint_list, list) { + if (checkpoint->epoch == epoch) { + sd_debug("duplicate checkpoint of epoch %d", epoch); return; } } - snapshot = xzalloc(sizeof(*snapshot)); - snapshot->epoch = epoch; - snapshot->vs = fill_vdi_state_list_with_alloc(&snapshot->nr_vs); - INIT_LIST_NODE(&snapshot->list); - list_add_tail(&snapshot->list, &vdi_state_snapshot_list); + checkpoint = xzalloc(sizeof(*checkpoint)); + checkpoint->epoch = epoch; + checkpoint->vs = fill_vdi_state_list_with_alloc(&checkpoint->nr_vs); + INIT_LIST_NODE(&checkpoint->list); + list_add_tail(&checkpoint->list, &vdi_state_checkpoint_list); - sd_debug("taking a snapshot of vdi state at epoch %d succeed", epoch); - sd_debug("a number of vdi state: %d", snapshot->nr_vs); + sd_debug("creating a checkpoint of vdi state at epoch %d succeed", + epoch); + sd_debug("a number of vdi state: %d", checkpoint->nr_vs); } -main_fn int get_vdi_state_snapshot(int epoch, void *data, int data_len_max, - int *data_len_result) +main_fn int get_vdi_state_checkpoint(int epoch, void *data, int data_len_max, + int *data_len_result) { - struct vdi_state_snapshot *snapshot; + struct vdi_state_checkpoint *checkpoint; int len; - list_for_each_entry(snapshot, &vdi_state_snapshot_list, list) { - if (snapshot->epoch == epoch) + list_for_each_entry(checkpoint, &vdi_state_checkpoint_list, list) { + if (checkpoint->epoch == epoch) goto found; } - sd_info("get request for not prepared vdi state snapshot, epoch: %d", + sd_info("get request for not prepared vdi state checkpoint, epoch: %d", epoch); return SD_RES_AGAIN; found: - len = sizeof(*snapshot->vs) * snapshot->nr_vs; + len = sizeof(*checkpoint->vs) * checkpoint->nr_vs; if (data_len_max < len) { sd_info("maximum allowed length: %d, required length: %d", data_len_max, len); return SD_RES_BUFFER_SMALL; } - memcpy(data, snapshot->vs, len); + memcpy(data, checkpoint->vs, len); return SD_RES_SUCCESS; } -main_fn void free_vdi_state_snapshot(int epoch) +main_fn void free_vdi_state_checkpoint(int epoch) { - struct vdi_state_snapshot *snapshot; + struct vdi_state_checkpoint *checkpoint; - list_for_each_entry(snapshot, &vdi_state_snapshot_list, list) { - if (snapshot->epoch == epoch) { - list_del(&snapshot->list); - free(snapshot->vs); - free(snapshot); + list_for_each_entry(checkpoint, &vdi_state_checkpoint_list, list) { + if (checkpoint->epoch == epoch) { + list_del(&checkpoint->list); + free(checkpoint->vs); + free(checkpoint); return; } } - panic("invalid free request for vdi state snapshot, epoch: %d", epoch); + panic("invalid free request for vdi state checkpoint, epoch: %d", epoch); } static int clean_matched_obj(uint64_t oid, const char *path, -- 1.9.1 -- sheepdog mailing list sheepdog@lists.wpkg.org https://lists.wpkg.org/mailman/listinfo/sheepdog
