[Sheepdog] [PATCH v3 2/4] change process_work and process_main to process_top and process_main
Li Wenpeng
levin108 at gmail.com
Wed May 2 09:03:13 CEST 2012
From: levin li <xingke.lwp at taobao.com>
The old semantics 'work' and 'main' indicate us that process_work should
work in worker thread, and process_main should work in main thread,
but in fact, sometimes such as for the cluster request, we'd like to
make process_main run in worker thread, because process_work only run
in local node, so we should change the semantics to 'top' and 'bottom',
at the same time, for cluster request, process_work run before process_main,
so the semantics 'top' and 'bottom' is better.
Signed-off-by: levin li <xingke.lwp at taobao.com>
---
sheep/group.c | 16 ++++-----
sheep/ops.c | 94 ++++++++++++++++++++++++++--------------------------
sheep/sdnet.c | 8 ++---
sheep/sheep_priv.h | 8 ++---
sheep/store.c | 2 +-
5 files changed, 64 insertions(+), 64 deletions(-)
diff --git a/sheep/group.c b/sheep/group.c
index f9a5437..d55ec7c 100644
--- a/sheep/group.c
+++ b/sheep/group.c
@@ -215,11 +215,11 @@ static void do_cluster_op(void *arg)
req = list_first_entry(&sys->pending_list, struct request, pending_list);
- if (has_process_main(req->op))
+ if (has_process_bottom(req->op))
data = msg->data;
else
data = req->data;
- ret = do_process_work(req->op, (const struct sd_req *)&msg->req,
+ ret = do_process_top(req->op, (const struct sd_req *)&msg->req,
(struct sd_rsp *)&msg->rsp, data);
msg->rsp.result = ret;
@@ -234,7 +234,7 @@ void do_cluster_request(struct work *work)
eprintf("%p %x\n", req, hdr->opcode);
- if (has_process_main(req->op))
+ if (has_process_bottom(req->op))
size = sizeof(*msg) + hdr->data_length;
else
size = sizeof(*msg);
@@ -247,12 +247,12 @@ void do_cluster_request(struct work *work)
msg->req = *((struct sd_vdi_req *)&req->rq);
msg->rsp = *((struct sd_vdi_rsp *)&req->rp);
- if (has_process_main(req->op))
+ if (has_process_bottom(req->op))
memcpy(msg->data, req->data, hdr->data_length);
list_add_tail(&req->pending_list, &sys->pending_list);
- if (has_process_work(req->op))
+ if (has_process_top(req->op))
sys->cdrv->notify(msg, size, do_cluster_op);
else {
msg->rsp.result = SD_RES_SUCCESS;
@@ -623,15 +623,15 @@ static void __sd_notify_done(struct event_struct *cevent)
int ret = msg->rsp.result;
struct sd_op_template *op = get_sd_op(msg->req.opcode);
- if (ret == SD_RES_SUCCESS && has_process_main(op))
- ret = do_process_main(op, (const struct sd_req *)&msg->req,
+ if (ret == SD_RES_SUCCESS && has_process_bottom(op))
+ ret = do_process_bottom(op, (const struct sd_req *)&msg->req,
(struct sd_rsp *)&msg->rsp, msg->data);
if (!req)
return;
msg->rsp.result = ret;
- if (has_process_main(req->op))
+ if (has_process_bottom(req->op))
memcpy(req->data, msg->data, msg->rsp.data_length);
memcpy(&req->rp, &msg->rsp, sizeof(req->rp));
req->done(req);
diff --git a/sheep/ops.c b/sheep/ops.c
index 8d1ac03..ea35d43 100644
--- a/sheep/ops.c
+++ b/sheep/ops.c
@@ -39,25 +39,25 @@ struct sd_op_template {
int force;
/*
- * process_work() will be called in the worker thread, and
- * process_main() will be called in the main thread.
+ * process_top() will be called in the worker thread, and
+ * process_bottom() will be called in the main thread.
*
* If type is SD_OP_TYPE_CLUSTER, it is guaranteed that only
* one node processes a cluster operation at the same time.
* We can use this for something like distributed locking.
- * process_work() will be called on the local node, and
- * process_main() will be called on every nodes.
+ * process_top() will be called on the local node, and
+ * process_bottom() will be called on every nodes.
*
- * If type is SD_OP_TYPE_LOCAL, both process_work() and
- * process_main() will be called on the local node.
+ * If type is SD_OP_TYPE_LOCAL, both process_bottom() and
+ * process_bottom() will be called on the local node.
*
- * If type is SD_OP_TYPE_IO, neither process_work() nor
- * process_main() is used because this type of operation is
+ * If type is SD_OP_TYPE_IO, neither process_top() nor
+ * process_bottom() is used because this type of operation is
* heavily intertwined with Sheepdog core codes. We will be
* unlikely to add new operations of this type.
*/
- int (*process_work)(const struct sd_req *req, struct sd_rsp *rsp, void *data);
- int (*process_main)(const struct sd_req *req, struct sd_rsp *rsp, void *data);
+ int (*process_top)(const struct sd_req *req, struct sd_rsp *rsp, void *data);
+ int (*process_bottom)(const struct sd_req *req, struct sd_rsp *rsp, void *data);
};
struct flush_work {
@@ -881,39 +881,39 @@ static struct sd_op_template sd_ops[] = {
/* cluster operations */
[SD_OP_NEW_VDI] = {
.type = SD_OP_TYPE_CLUSTER,
- .process_work = cluster_new_vdi,
- .process_main = post_cluster_new_vdi,
+ .process_top = cluster_new_vdi,
+ .process_bottom = post_cluster_new_vdi,
},
[SD_OP_DEL_VDI] = {
.type = SD_OP_TYPE_CLUSTER,
- .process_work = cluster_del_vdi,
+ .process_top = cluster_del_vdi,
},
[SD_OP_GET_VDI_INFO] = {
.type = SD_OP_TYPE_CLUSTER,
- .process_work = cluster_get_vdi_info,
+ .process_top = cluster_get_vdi_info,
},
[SD_OP_LOCK_VDI] = {
.type = SD_OP_TYPE_CLUSTER,
- .process_work = cluster_get_vdi_info,
+ .process_top = cluster_get_vdi_info,
},
[SD_OP_MAKE_FS] = {
.type = SD_OP_TYPE_CLUSTER,
.force = 1,
- .process_main = cluster_make_fs,
+ .process_bottom = cluster_make_fs,
},
[SD_OP_SHUTDOWN] = {
.type = SD_OP_TYPE_CLUSTER,
- .process_main = cluster_shutdown,
+ .process_bottom = cluster_shutdown,
},
[SD_OP_GET_VDI_ATTR] = {
.type = SD_OP_TYPE_CLUSTER,
- .process_work = cluster_get_vdi_attr,
+ .process_top = cluster_get_vdi_attr,
},
[SD_OP_RELEASE_VDI] = {
@@ -923,120 +923,120 @@ static struct sd_op_template sd_ops[] = {
[SD_OP_RECOVER] = {
.type = SD_OP_TYPE_CLUSTER,
.force = 1,
- .process_main = cluster_manual_recover,
+ .process_bottom = cluster_manual_recover,
},
[SD_OP_SNAPSHOT] = {
.type = SD_OP_TYPE_CLUSTER,
.force = 1,
- .process_main = cluster_snapshot,
+ .process_bottom = cluster_snapshot,
},
[SD_OP_RESTORE] = {
.type = SD_OP_TYPE_CLUSTER,
.force = 1,
- .process_main = cluster_restore,
+ .process_bottom = cluster_restore,
},
[SD_OP_CLEANUP] = {
.type = SD_OP_TYPE_CLUSTER,
.force = 1,
- .process_main = cluster_cleanup,
+ .process_bottom = cluster_cleanup,
},
/* local operations */
[SD_OP_GET_STORE_LIST] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_work = local_get_store_list,
+ .process_top = local_get_store_list,
},
[SD_OP_READ_VDIS] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_main = local_read_vdis,
+ .process_bottom = local_read_vdis,
},
[SD_OP_GET_NODE_LIST] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_main = local_get_node_list,
+ .process_bottom = local_get_node_list,
},
[SD_OP_STAT_SHEEP] = {
.type = SD_OP_TYPE_LOCAL,
- .process_work = local_stat_sheep,
+ .process_top = local_stat_sheep,
},
[SD_OP_STAT_RECOVERY] = {
.type = SD_OP_TYPE_LOCAL,
- .process_main = local_stat_recovery,
+ .process_bottom = local_stat_recovery,
},
[SD_OP_STAT_CLUSTER] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_work = local_stat_cluster,
+ .process_top = local_stat_cluster,
},
[SD_OP_KILL_NODE] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_work = local_kill_node,
+ .process_top = local_kill_node,
},
[SD_OP_GET_OBJ_LIST] = {
.type = SD_OP_TYPE_LOCAL,
- .process_work = local_get_obj_list,
+ .process_top = local_get_obj_list,
},
[SD_OP_GET_EPOCH] = {
.type = SD_OP_TYPE_LOCAL,
- .process_work = local_get_epoch,
+ .process_top = local_get_epoch,
},
[SD_OP_GET_SNAP_FILE] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_work = local_get_snap_file,
+ .process_top = local_get_snap_file,
},
[SD_OP_FLUSH_VDI] = {
.type = SD_OP_TYPE_LOCAL,
- .process_work = local_flush_vdi,
+ .process_top = local_flush_vdi,
},
[SD_OP_TRACE] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_main = local_trace_ops,
+ .process_bottom = local_trace_ops,
},
[SD_OP_TRACE_CAT] = {
.type = SD_OP_TYPE_LOCAL,
.force = 1,
- .process_main = local_trace_cat_ops,
+ .process_bottom = local_trace_cat_ops,
},
/* I/O operations */
[SD_OP_CREATE_AND_WRITE_OBJ] = {
.type = SD_OP_TYPE_IO,
- .process_work = store_create_and_write_obj,
+ .process_top = store_create_and_write_obj,
},
[SD_OP_READ_OBJ] = {
.type = SD_OP_TYPE_IO,
- .process_work = store_read_obj,
+ .process_top = store_read_obj,
},
[SD_OP_WRITE_OBJ] = {
.type = SD_OP_TYPE_IO,
- .process_work = store_write_obj,
+ .process_top = store_write_obj,
},
[SD_OP_REMOVE_OBJ] = {
.type = SD_OP_TYPE_IO,
- .process_work = store_remove_obj,
+ .process_top = store_remove_obj,
},
};
@@ -1068,24 +1068,24 @@ int is_force_op(struct sd_op_template *op)
return !!op->force;
}
-int has_process_work(struct sd_op_template *op)
+int has_process_top(struct sd_op_template *op)
{
- return !!op->process_work;
+ return !!op->process_top;
}
-int has_process_main(struct sd_op_template *op)
+int has_process_bottom(struct sd_op_template *op)
{
- return !!op->process_main;
+ return !!op->process_bottom;
}
-int do_process_work(struct sd_op_template *op, const struct sd_req *req,
+int do_process_top(struct sd_op_template *op, const struct sd_req *req,
struct sd_rsp *rsp, void *data)
{
- return op->process_work(req, rsp, data);
+ return op->process_top(req, rsp, data);
}
-int do_process_main(struct sd_op_template *op, const struct sd_req *req,
+int do_process_bottom(struct sd_op_template *op, const struct sd_req *req,
struct sd_rsp *rsp, void *data)
{
- return op->process_main(req, rsp, data);
+ return op->process_bottom(req, rsp, data);
}
diff --git a/sheep/sdnet.c b/sheep/sdnet.c
index b281e2c..6d0c1d5 100644
--- a/sheep/sdnet.c
+++ b/sheep/sdnet.c
@@ -163,8 +163,8 @@ static void local_op_done(struct work *work)
{
struct request *req = container_of(work, struct request, work);
- if (has_process_main(req->op)) {
- req->rp.result = do_process_main(req->op, &req->rq,
+ if (has_process_bottom(req->op)) {
+ req->rp.result = do_process_bottom(req->op, &req->rq,
&req->rp, req->data);
}
@@ -182,8 +182,8 @@ static void do_local_request(struct work *work)
struct sd_obj_rsp *rsp = (struct sd_obj_rsp *)&req->rp;
int ret = SD_RES_SUCCESS;
- if (has_process_work(req->op))
- ret = do_process_work(req->op, &req->rq, &req->rp, req->data);
+ if (has_process_top(req->op))
+ ret = do_process_top(req->op, &req->rq, &req->rp, req->data);
rsp->result = ret;
}
diff --git a/sheep/sheep_priv.h b/sheep/sheep_priv.h
index fd36ea4..db241c8 100644
--- a/sheep/sheep_priv.h
+++ b/sheep/sheep_priv.h
@@ -321,11 +321,11 @@ int is_cluster_op(struct sd_op_template *op);
int is_local_op(struct sd_op_template *op);
int is_io_op(struct sd_op_template *op);
int is_force_op(struct sd_op_template *op);
-int has_process_work(struct sd_op_template *op);
-int has_process_main(struct sd_op_template *op);
-int do_process_work(struct sd_op_template *op, const struct sd_req *req,
+int has_process_top(struct sd_op_template *op);
+int has_process_bottom(struct sd_op_template *op);
+int do_process_top(struct sd_op_template *op, const struct sd_req *req,
struct sd_rsp *rsp, void *data);
-int do_process_main(struct sd_op_template *op, const struct sd_req *req,
+int do_process_bottom(struct sd_op_template *op, const struct sd_req *req,
struct sd_rsp *rsp, void *data);
/* Journal */
diff --git a/sheep/store.c b/sheep/store.c
index 6412556..bc27ee7 100644
--- a/sheep/store.c
+++ b/sheep/store.c
@@ -53,7 +53,7 @@ static int do_local_io(struct request *req, uint32_t epoch)
hdr->epoch = epoch;
dprintf("%x, %" PRIx64" , %u\n", hdr->opcode, hdr->oid, epoch);
- return do_process_work(req->op, &req->rq, &req->rp, req);
+ return do_process_top(req->op, &req->rq, &req->rp, req);
}
static int forward_read_obj_req(struct request *req)
--
1.7.10
More information about the sheepdog
mailing list