At Mon, 8 Jun 2015 22:34:44 +0900,
Hitoshi Mitake wrote:
>
> 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 <[email protected]>
> ---
> 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(-)
Applied this series with trivial style fix.
Thanks,
Hitoshi
>
> 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
[email protected]
https://lists.wpkg.org/mailman/listinfo/sheepdog
