This change the API and ABI for cpg. Before this change can go anywhere, it needs proper Makefile.am love or even easier queue it after libtool changes that makes slightly easier to have per library API and ABI versioning.
Let's try, as a general rule, to avoid the same nightmare we had between whitetank and current status with hidden API/ABI changes. Fabio On Wed, 2009-08-19 at 13:16 -0700, Steven Dake wrote: > comments inline. Looks pretty good though. > > Regards > -steve > > On Wed, 2009-08-19 at 16:31 +0200, Jan Friesse wrote: > > Implementation of DRAFT API. Look like there are no leaks, valgrind > > problems, ... > > > > Regards, > > Honza > > plain text document attachment > > (0001-Implementation-of-cpg_iteration-functions.patch) > > From 02a9fbad2db3ee019c735422dc064fed0179e103 Mon Sep 17 00:00:00 2001 > > From: Jan Friesse <[email protected]> > > Date: Wed, 19 Aug 2009 15:17:27 +0200 > > Subject: [PATCH] Implementation of cpg_iteration functions > > > > --- > > trunk/include/corosync/cpg.h | 31 ++++ > > trunk/include/corosync/ipc_cpg.h | 53 +++++++- > > trunk/lib/cpg.c | 236 ++++++++++++++++++++++++++++- > > trunk/services/cpg.c | 313 > > +++++++++++++++++++++++++++++++++++++- > > 4 files changed, 627 insertions(+), 6 deletions(-) > > > > diff --git a/trunk/include/corosync/cpg.h b/trunk/include/corosync/cpg.h > > index 242cbbe..b5609df 100644 > > --- a/trunk/include/corosync/cpg.h > > +++ b/trunk/include/corosync/cpg.h > > @@ -4,6 +4,7 @@ > > * All rights reserved. > > * > > * Author: Christine Caulfield ([email protected]) > > + * Author: Jan Friesse ([email protected]) > > * > > * This software licensed under BSD license, the text of which follows: > > * > > @@ -48,6 +49,8 @@ extern "C" { > > */ > > typedef uint64_t cpg_handle_t; > > > > +typedef uint64_t cpg_iteration_handle_t; > > + > > typedef enum { > > CPG_TYPE_UNORDERED, /* not implemented */ > > CPG_TYPE_FIFO, /* same as agreed */ > > @@ -69,6 +72,12 @@ typedef enum { > > CPG_REASON_PROCDOWN = 5 > > } cpg_reason_t; > > > > +typedef enum { > > + CPG_ITERATION_NAME_ONLY = 1, > > + CPG_ITERATION_ONE_GROUP = 2, > > + CPG_ITERATION_ALL = 3, > > +} cpg_iteration_type_t; > > + > > struct cpg_address { > > uint32_t nodeid; > > uint32_t pid; > > @@ -83,6 +92,12 @@ struct cpg_name { > > > > #define CPG_MEMBERS_MAX 128 > > > > +struct cpg_iteration_description_t { > > + struct cpg_name group; > > + uint32_t nodeid; > > + uint32_t pid; > > +}; > > + > > typedef void (*cpg_deliver_fn_t) ( > > cpg_handle_t handle, > > const struct cpg_name *group_name, > > @@ -209,6 +224,22 @@ cs_error_t cpg_zcb_mcast_joined ( > > void *msg, > > size_t msg_len); > > > > +/* > > + * Iteration > > + */ > > +cs_error_t cpg_iteration_initialize( > > + cpg_handle_t handle, > > + cpg_iteration_type_t iteration_type, > > + const struct cpg_name *group, > > + cpg_iteration_handle_t *cpg_iteration_handle); > > + > > +cs_error_t cpg_iteration_next( > > + cpg_iteration_handle_t handle, > > + struct cpg_iteration_description_t *description); > > + > > +cs_error_t cpg_iteration_finalize ( > > + cpg_iteration_handle_t handle); > > + > > #ifdef __cplusplus > > } > > #endif > > diff --git a/trunk/include/corosync/ipc_cpg.h > > b/trunk/include/corosync/ipc_cpg.h > > index 1d240d4..7df1891 100644 > > --- a/trunk/include/corosync/ipc_cpg.h > > +++ b/trunk/include/corosync/ipc_cpg.h > > @@ -45,6 +45,9 @@ enum req_cpg_types { > > MESSAGE_REQ_CPG_MCAST = 2, > > MESSAGE_REQ_CPG_MEMBERSHIP = 3, > > MESSAGE_REQ_CPG_LOCAL_GET = 4, > > + MESSAGE_REQ_CPG_ITERATIONINITIALIZE = 5, > > + MESSAGE_REQ_CPG_ITERATIONNEXT = 6, > > + MESSAGE_REQ_CPG_ITERATIONFINALIZE = 7 > > }; > > > > enum res_cpg_types { > > @@ -56,7 +59,10 @@ enum res_cpg_types { > > MESSAGE_RES_CPG_DELIVER_CALLBACK = 5, > > MESSAGE_RES_CPG_FLOW_CONTROL_STATE_SET = 6, > > MESSAGE_RES_CPG_LOCAL_GET = 7, > > - MESSAGE_RES_CPG_FLOWCONTROL_CALLBACK = 8 > > + MESSAGE_RES_CPG_FLOWCONTROL_CALLBACK = 8, > > + MESSAGE_RES_CPG_ITERATIONINITIALIZE = 9, > > + MESSAGE_RES_CPG_ITERATIONNEXT = 10, > > + MESSAGE_RES_CPG_ITERATIONFINALIZE = 11, > > }; > > > > enum lib_cpg_confchg_reason { > > @@ -126,6 +132,21 @@ static inline int mar_name_compare ( > > g1->length - g2->length); > > } > > > > +typedef struct { > > + mar_cpg_name_t group; > > + mar_uint32_t nodeid; > > + mar_uint32_t pid; > > +} mar_cpg_iteration_description_t; > > + > > +static inline void marshall_from_mar_cpg_iteration_description_t( > > + struct cpg_iteration_description_t *dest, > > + const mar_cpg_iteration_description_t *src) > > +{ > > + dest->nodeid = src->nodeid; > > + dest->pid = src->pid; > > + marshall_from_mar_cpg_name_t (&dest->group, &src->group); > > +}; > > + > > struct req_lib_cpg_join { > > coroipc_request_header_t header __attribute__((aligned(8))); > > mar_cpg_name_t group_name __attribute__((aligned(8))); > > @@ -217,4 +238,34 @@ struct res_lib_cpg_leave { > > coroipc_response_header_t header __attribute__((aligned(8))); > > }; > > > > +struct req_lib_cpg_iterationinitialize { > > + coroipc_request_header_t header __attribute__((aligned(8))); > > + mar_cpg_name_t group_name __attribute__((aligned(8))); > > + mar_uint32_t iteration_type __attribute__((aligned(8))); > > +}; > > + > > +struct res_lib_cpg_iterationinitialize { > > + coroipc_response_header_t header __attribute__((aligned(8))); > > + hdb_handle_t iteration_handle __attribute__((aligned(8))); > > +}; > > + > > +struct req_lib_cpg_iterationnext { > > + coroipc_request_header_t header __attribute__((aligned(8))); > > + hdb_handle_t iteration_handle __attribute__((aligned(8))); > > +}; > > + > > +struct res_lib_cpg_iterationnext { > > + coroipc_response_header_t header __attribute__((aligned(8))); > > + mar_cpg_iteration_description_t description __attribute__((aligned(8))); > > +}; > > + > > +struct req_lib_cpg_iterationfinalize { > > + coroipc_request_header_t header __attribute__((aligned(8))); > > + hdb_handle_t iteration_handle __attribute__((aligned(8))); > > +}; > > + > > +struct res_lib_cpg_iterationfinalize { > > + coroipc_response_header_t header __attribute__((aligned(8))); > > +}; > > + > > #endif /* IPC_CPG_H_DEFINED */ > > diff --git a/trunk/lib/cpg.c b/trunk/lib/cpg.c > > index 3f8df6c..e3ab8e6 100644 > > --- a/trunk/lib/cpg.c > > +++ b/trunk/lib/cpg.c > > @@ -5,7 +5,8 @@ > > * > > * All rights reserved. > > * > > - * Author: Patrick Caulfield ([email protected]) > > + * Author: Christine Caulfield ([email protected]) > > + * Author: Jan Friesse ([email protected]) > > * > > * This software licensed under BSD license, the text of which follows: > > * > > @@ -51,6 +52,7 @@ > > #include <corosync/coroipcc.h> > > #include <corosync/corodefs.h> > > #include <corosync/hdb.h> > > +#include <corosync/list.h> > > > > #include <corosync/cpg.h> > > #include <corosync/ipc_cpg.h> > > @@ -62,10 +64,49 @@ struct cpg_inst { > > int finalize; > > cpg_callbacks_t callbacks; > > void *context; > > + struct list_head iteration_list_head; > > }; > > > > DECLARE_HDB_DATABASE(cpg_handle_t_db,NULL); > > > > +struct cpg_iteration_instance_t { > > + cpg_iteration_handle_t cpg_iteration_handle; > > + hdb_handle_t conn_handle; > > + hdb_handle_t executive_iteration_handle; > > + struct list_head list; > > +}; > > + > > +DECLARE_HDB_DATABASE(cpg_iteration_handle_t_db,NULL); > > + > > + > > +/* > > + * Internal (not visible by API) functions > > + */ > > + > > +static void cpg_iteration_instance_finalize (struct > > cpg_iteration_instance_t *cpg_iteration_instance) > > +{ > > + list_del (&cpg_iteration_instance->list); > > + hdb_handle_destroy (&cpg_iteration_handle_t_db, > > cpg_iteration_instance->cpg_iteration_handle); > > +} > > + > > +static void cpg_inst_finalize (struct cpg_inst *cpg_inst, hdb_handle_t > > handle) > > +{ > > + struct list_head *iter, *iter_next; > > + struct cpg_iteration_instance_t *cpg_iteration_instance; > > + > > + /* > > + * Traverse thru iteration instances and delete them > > + */ > > + for (iter = cpg_inst->iteration_list_head.next; iter != > > &cpg_inst->iteration_list_head;iter = iter_next) { > > + iter_next = iter->next; > > + > > + cpg_iteration_instance = list_entry (iter, struct > > cpg_iteration_instance_t, list); > > + > > + cpg_iteration_instance_finalize (cpg_iteration_instance); > > + } > > + hdb_handle_destroy (&cpg_handle_t_db, handle); > > +} > > + > > this handle destroy doesn't make any sense since cpg_finalize should be > doing the hdb_handle_destroy. This will result in wrong ref counting. > > > /** > > * @defgroup cpg_coroipcc The closed process group API > > * @ingroup coroipcc > > @@ -103,6 +144,8 @@ cs_error_t cpg_initialize ( > > > > memcpy (&cpg_inst->callbacks, callbacks, sizeof (cpg_callbacks_t)); > > > > + list_init(&cpg_inst->iteration_list_head); > > + > > hdb_handle_put (&cpg_handle_t_db, *handle); > > > > return (CS_OK); > > @@ -138,8 +181,7 @@ cs_error_t cpg_finalize ( > > > > coroipcc_service_disconnect (cpg_inst->handle); > > > > - hdb_handle_destroy (&cpg_handle_t_db, handle); > > - > > + cpg_inst_finalize (cpg_inst, handle); > > hdb_handle_put (&cpg_handle_t_db, handle); > > > > return (CPG_OK); > > @@ -675,4 +717,192 @@ error_exit: > > > > return (error); > > } > > + > > +cs_error_t cpg_iteration_initialize( > > + cpg_handle_t handle, > > + cpg_iteration_type_t iteration_type, > > + const struct cpg_name *group, > > + cpg_iteration_handle_t *cpg_iteration_handle) > > +{ > > + cs_error_t error; > > + struct iovec iov; > > + struct cpg_inst *cpg_inst; > > + struct cpg_iteration_instance_t *cpg_iteration_instance; > > + struct req_lib_cpg_iterationinitialize req_lib_cpg_iterationinitialize; > > + struct res_lib_cpg_iterationinitialize res_lib_cpg_iterationinitialize; > > + > > + if (cpg_iteration_handle == NULL) { > > + return (CS_ERR_INVALID_PARAM); > > + } > > + > > + if ((iteration_type == CPG_ITERATION_ONE_GROUP && group == NULL) || > > + (iteration_type != CPG_ITERATION_ONE_GROUP && group != NULL)) { > > + return (CS_ERR_INVALID_PARAM); > > + } > > + > > + if (iteration_type != CPG_ITERATION_NAME_ONLY && iteration_type != > > CPG_ITERATION_ONE_GROUP && > > + iteration_type != CPG_ITERATION_ALL) { > > + > > + return (CS_ERR_INVALID_PARAM); > > + } > > + > > + error = hdb_error_to_cs (hdb_handle_get (&cpg_handle_t_db, handle, > > (void *)&cpg_inst)); > > + > > why the void cast? > > > > if (error != CS_OK) { > > + return (error); > > + } > > + > > + error = hdb_error_to_cs (hdb_handle_create (&cpg_iteration_handle_t_db, > > + sizeof (struct cpg_iteration_instance_t), > > cpg_iteration_handle)); > > + if (error != CS_OK) { > > + goto error_put_cpg_db; > > + } > > + > > + error = hdb_error_to_cs (hdb_handle_get (&cpg_iteration_handle_t_db, > > *cpg_iteration_handle, > > + (void *)&cpg_iteration_instance)); > > + if (error != CS_OK) { > > + goto error_destroy; > > + } > > + > > + cpg_iteration_instance->conn_handle = cpg_inst->handle; > > + > > + list_init (&cpg_iteration_instance->list); > > + > > + req_lib_cpg_iterationinitialize.header.size = sizeof (struct > > req_lib_cpg_iterationinitialize); > > + req_lib_cpg_iterationinitialize.header.id = > > MESSAGE_REQ_CPG_ITERATIONINITIALIZE; > > + req_lib_cpg_iterationinitialize.iteration_type = iteration_type; > > + if (group) { > > + marshall_to_mar_cpg_name_t > > (&req_lib_cpg_iterationinitialize.group_name, group); > > + } > > + > > + iov.iov_base = (void *)&req_lib_cpg_iterationinitialize; > > + iov.iov_len = sizeof (struct req_lib_cpg_iterationinitialize); > > + > > + error = coroipcc_msg_send_reply_receive (cpg_inst->handle, > > + &iov, > > + 1, > > + &res_lib_cpg_iterationinitialize, > > + sizeof (struct req_lib_cpg_iterationinitialize)); > > + > > + if (error != CS_OK) { > > + goto error_put_destroy; > > + } > > + > > + cpg_iteration_instance->executive_iteration_handle = > > + res_lib_cpg_iterationinitialize.iteration_handle; > > + cpg_iteration_instance->cpg_iteration_handle = *cpg_iteration_handle; > > + > > + list_add (&cpg_iteration_instance->list, > > &cpg_inst->iteration_list_head); > > + > > + hdb_handle_put (&cpg_iteration_handle_t_db, *cpg_iteration_handle); > > + hdb_handle_put (&cpg_handle_t_db, handle); > > + > > + return (res_lib_cpg_iterationinitialize.header.error); > > + > > +error_put_destroy: > > + hdb_handle_put (&cpg_iteration_handle_t_db, *cpg_iteration_handle); > > +error_destroy: > > + hdb_handle_destroy (&cpg_iteration_handle_t_db, *cpg_iteration_handle); > > +error_put_cpg_db: > > + hdb_handle_put (&cpg_handle_t_db, handle); > > + > > + return (error); > > +} > > + > > +cs_error_t cpg_iteration_next( > > + cpg_iteration_handle_t handle, > > + struct cpg_iteration_description_t *description) > > +{ > > + cs_error_t error; > > + struct cpg_iteration_instance_t *cpg_iteration_instance; > > + struct req_lib_cpg_iterationnext req_lib_cpg_iterationnext; > > + struct res_lib_cpg_iterationnext *res_lib_cpg_iterationnext; > > + struct iovec iov; > > + void *return_address; > > + > > + if (description == NULL) { > > + return CS_ERR_INVALID_PARAM; > > + } > > + > > + error = hdb_error_to_cs (hdb_handle_get (&cpg_iteration_handle_t_db, > > handle, > > + (void *)&cpg_iteration_instance)); > > + if (error != CS_OK) { > > + goto error_exit; > > + } > > + > > + req_lib_cpg_iterationnext.header.size = sizeof (struct > > req_lib_cpg_iterationnext); > > + req_lib_cpg_iterationnext.header.id = MESSAGE_REQ_CPG_ITERATIONNEXT; > > + req_lib_cpg_iterationnext.iteration_handle = > > cpg_iteration_instance->executive_iteration_handle; > > + > > + iov.iov_base = (void *)&req_lib_cpg_iterationnext; > > + iov.iov_len = sizeof (struct req_lib_cpg_iterationnext); > > + > > + error = coroipcc_msg_send_reply_receive_in_buf_get > > (cpg_iteration_instance->conn_handle, > > + &iov, > > + 1, > > + &return_address); > > + res_lib_cpg_iterationnext = return_address; > > + > > + if (error != CS_OK) { > > + goto error_put; > > + } > > + > > + marshall_from_mar_cpg_iteration_description_t( > > + description, > > + &res_lib_cpg_iterationnext->description); > > + > > + error = (error == CS_OK ? res_lib_cpg_iterationnext->header.error : > > error); > > + > > + coroipcc_msg_send_reply_receive_in_buf_put( > > + cpg_iteration_instance->conn_handle); > > + > > +error_put: > > + hdb_handle_put (&cpg_iteration_handle_t_db, handle); > > + > > +error_exit: > > + return (error); > > +} > > + > > +cs_error_t cpg_iteration_finalize ( > > + cpg_iteration_handle_t handle) > > +{ > > + cs_error_t error; > > + struct iovec iov; > > + struct cpg_iteration_instance_t *cpg_iteration_instance; > > + struct req_lib_cpg_iterationfinalize req_lib_cpg_iterationfinalize; > > + struct res_lib_cpg_iterationfinalize res_lib_cpg_iterationfinalize; > > + > > + error = hdb_error_to_cs (hdb_handle_get (&cpg_iteration_handle_t_db, > > handle, > > + (void *)&cpg_iteration_instance)); > > + if (error != CS_OK) { > > + goto error_exit; > > + } > > + > > + req_lib_cpg_iterationfinalize.header.size = sizeof (struct > > req_lib_cpg_iterationfinalize); > > + req_lib_cpg_iterationfinalize.header.id = > > MESSAGE_REQ_CPG_ITERATIONFINALIZE; > > + req_lib_cpg_iterationfinalize.iteration_handle = > > cpg_iteration_instance->executive_iteration_handle; > > + > > + iov.iov_base = (void *)&req_lib_cpg_iterationfinalize; > > + iov.iov_len = sizeof (struct req_lib_cpg_iterationfinalize); > > + > > + error = coroipcc_msg_send_reply_receive > > (cpg_iteration_instance->conn_handle, > > + &iov, > > + 1, > > + &res_lib_cpg_iterationfinalize, > > + sizeof (struct req_lib_cpg_iterationfinalize)); > > + > > + if (error != CS_OK) { > > + goto error_put; > > + } > > + > > + cpg_iteration_instance_finalize (cpg_iteration_instance); > > + hdb_handle_put (&cpg_iteration_handle_t_db, > > cpg_iteration_instance->cpg_iteration_handle); > > + > > + return (res_lib_cpg_iterationfinalize.header.error); > > + > > +error_put: > > + hdb_handle_put (&cpg_iteration_handle_t_db, handle); > > +error_exit: > > + return (error); > > +} > > + > > /** @} */ > > diff --git a/trunk/services/cpg.c b/trunk/services/cpg.c > > index cac623d..507af7c 100644 > > --- a/trunk/services/cpg.c > > +++ b/trunk/services/cpg.c > > @@ -134,8 +134,18 @@ struct cpg_pd { > > uint32_t pid; > > enum cpd_state cpd_state; > > struct list_head list; > > + struct list_head iteration_instance_list_head; > > }; > > > > +struct cpg_iteration_instance { > > + hdb_handle_t handle; > > + struct list_head list; > > + struct list_head items_list_head; /* List of process_info */ > > + struct list_head *current_pointer; > > +}; > > + > > +DECLARE_HDB_DATABASE(cpg_iteration_handle_t_db,NULL); > > + > > DECLARE_LIST_INIT(cpg_pd_list_head); > > > > static unsigned int my_member_list[PROCESSOR_COUNT_MAX]; > > @@ -212,6 +222,15 @@ static void message_handler_req_lib_cpg_membership > > (void *conn, > > static void message_handler_req_lib_cpg_local_get (void *conn, > > const void *message); > > > > +static void message_handler_req_lib_cpg_iteration_initialize (void *conn, > > + const void > > *message); > > + > > +static void message_handler_req_lib_cpg_iteration_next (void *conn, > > + const void *message); > > + > > +static void message_handler_req_lib_cpg_iteration_finalize (void *conn, > > + const void > > *message); > > + > > static int cpg_node_joinleave_send (unsigned int pid, const mar_cpg_name_t > > *group_name, int fn, int reason); > > > > static int cpg_exec_send_downlist(void); > > @@ -253,7 +272,19 @@ static struct corosync_lib_handler cpg_lib_engine[] = > > { /* 4 */ > > .lib_handler_fn = > > message_handler_req_lib_cpg_local_get, > > .flow_control = > > CS_LIB_FLOW_CONTROL_NOT_REQUIRED > > - } > > + }, > > + { /* 5 */ > > + .lib_handler_fn = > > message_handler_req_lib_cpg_iteration_initialize, > > + .flow_control = > > CS_LIB_FLOW_CONTROL_NOT_REQUIRED > > + }, > > + { /* 6 */ > > + .lib_handler_fn = > > message_handler_req_lib_cpg_iteration_next, > > + .flow_control = > > CS_LIB_FLOW_CONTROL_NOT_REQUIRED > > + }, > > + { /* 7 */ > > + .lib_handler_fn = > > message_handler_req_lib_cpg_iteration_finalize, > > + .flow_control = > > CS_LIB_FLOW_CONTROL_NOT_REQUIRED > > + }, > > }; > > > > static struct corosync_exec_handler cpg_exec_engine[] = > > @@ -572,6 +603,45 @@ static int cpg_exec_init_fn (struct corosync_api_v1 > > *corosync_api) > > return (0); > > } > > > > +static void cpg_iteration_instance_finalize (struct cpg_iteration_instance > > *cpg_iteration_instance) > > +{ > > + struct list_head *iter, *iter_next; > > + struct process_info *pi; > > + > > + for (iter = cpg_iteration_instance->items_list_head.next; > > + iter != &cpg_iteration_instance->items_list_head; > > + iter = iter_next) { > > + > > + iter_next = iter->next; > > + > > + pi = list_entry (iter, struct process_info, list); > > + list_del (&pi->list); > > + free (pi); > > + } > > + > > + list_del (&cpg_iteration_instance->list); > > + hdb_handle_destroy (&cpg_iteration_handle_t_db, > > cpg_iteration_instance->handle); > > +} > > + > > +static void cpg_pd_finalize (struct cpg_pd *cpd) > > +{ > > + struct list_head *iter, *iter_next; > > + struct cpg_iteration_instance *cpii; > > + > > + for (iter = cpd->iteration_instance_list_head.next; > > + iter != &cpd->iteration_instance_list_head; > > + iter = iter_next) { > > + > > + iter_next = iter->next; > > + > > + cpii = list_entry (iter, struct cpg_iteration_instance, list); > > + > > + cpg_iteration_instance_finalize (cpii); > > + } > > + > > + list_del (&cpd->list); > > +} > > + > > static int cpg_lib_exit_fn (void *conn) > > { > > struct cpg_pd *cpd = (struct cpg_pd *)api->ipc_private_data_get (conn); > > @@ -582,7 +652,9 @@ static int cpg_lib_exit_fn (void *conn) > > cpg_node_joinleave_send (cpd->pid, &cpd->group_name, > > MESSAGE_REQ_EXEC_CPG_PROCLEAVE, > > CONFCHG_CPG_REASON_LEAVE); > > } > > - list_del (&cpd->list); > > + > > + cpg_pd_finalize (cpd); > > + > > api->ipc_refcnt_dec (conn); > > return (0); > > } > > @@ -958,6 +1030,8 @@ static int cpg_lib_init_fn (void *conn) > > cpd->conn = conn; > > list_add (&cpd->list, &cpg_pd_list_head); > > > > + list_init (&cpd->iteration_instance_list_head); > > + > > api->ipc_refcnt_inc (conn); > > log_printf(LOGSYS_LEVEL_DEBUG, "lib_init_fn: conn=%p, cpd=%p\n", conn, > > cpd); > > return (0); > > @@ -1157,3 +1231,238 @@ static void message_handler_req_lib_cpg_local_get > > (void *conn, > > api->ipc_response_send (conn, &res_lib_cpg_local_get, > > sizeof (res_lib_cpg_local_get)); > > } > > + > > +static void message_handler_req_lib_cpg_iteration_initialize (void *conn, > > + const void > > *message) > > +{ > > + const struct req_lib_cpg_iterationinitialize > > *req_lib_cpg_iterationinitialize = message; > > + struct cpg_pd *cpd = (struct cpg_pd *)api->ipc_private_data_get (conn); > > + hdb_handle_t cpg_iteration_handle; > > + > > + struct res_lib_cpg_iterationinitialize res_lib_cpg_iterationinitialize; > > + struct list_head *iter, *iter2; > > + struct cpg_iteration_instance *cpg_iteration_instance; > > + cs_error_t error = CS_OK; > > + int res; > > + > > + log_printf (LOGSYS_LEVEL_DEBUG, "cpg iteration initialize\n"); > > + > > + /* Because between calling this function and *next can be some > > operations which will > > + * change list, we must do full copy. > > + */ > > + > > + /* > > + * Create new iteration instance > > + */ > > + res = hdb_handle_create (&cpg_iteration_handle_t_db, sizeof (struct > > cpg_iteration_instance), > > + &cpg_iteration_handle); > > + > > + if (res != 0) { > > + error = CS_ERR_NO_MEMORY; > > + goto response_send; > > + } > > + > > + res = hdb_handle_get (&cpg_iteration_handle_t_db, cpg_iteration_handle, > > (void *)&cpg_iteration_instance); > > + > > + if (res != 0) { > > + error = CS_ERR_BAD_HANDLE; > > + goto error_destroy; > > + } > > + > > + list_init (&cpg_iteration_instance->items_list_head); > > + cpg_iteration_instance->handle = cpg_iteration_handle; > > + > > + /* > > + * Create copy of process_info list "grouped by" group name > > + */ > > + for (iter = process_info_list_head.next; iter != > > &process_info_list_head; iter = iter->next) { > > + struct process_info *pi = list_entry (iter, struct > > process_info, list); > > + struct process_info *new_pi; > > + > > + if (req_lib_cpg_iterationinitialize->iteration_type == > > CPG_ITERATION_NAME_ONLY) { > > + /* > > + * Try to find processed group name in our list new list > > + */ > > + int found = 0; > > + > > + for (iter2 = > > cpg_iteration_instance->items_list_head.next; > > + iter2 != &cpg_iteration_instance->items_list_head; > > + iter2 = iter2->next) { > > + struct process_info *pi2 = list_entry (iter2, > > struct process_info, list); > > + > > + if (mar_name_compare (&pi2->group, &pi->group) > > == 0) { > > + found = 1; > > + break; > > + } > > + } > > + > > + if (found) { > > + /* > > + * We have this name in list -> don't add > > + */ > > + continue ; > > + } > > + } else if (req_lib_cpg_iterationinitialize->iteration_type == > > CPG_ITERATION_ONE_GROUP) { > > + /* > > + * Test pi group name with request > > + */ > > + if (mar_name_compare (&pi->group, > > &req_lib_cpg_iterationinitialize->group_name) != 0) > > + /* > > + * Not same -> don't add > > + */ > > + continue ; > > + } else { > > why an else with no code? Maybe should remove this stanza entirely. > > > + /* > > + * We will add new item for sure > > + */ > > + } > > + > > + new_pi = malloc (sizeof (struct process_info)); > > + if (!new_pi) { > > + log_printf(LOGSYS_LEVEL_WARNING, "Unable to allocate > > process_info struct"); > > + > > + error = CS_ERR_NO_MEMORY; > > + > > + goto error_put_destroy; > > + } > > + > > + memcpy (new_pi, pi, sizeof (struct process_info)); > > + list_init (&new_pi->list); > > + > > + if (req_lib_cpg_iterationinitialize->iteration_type == > > CPG_ITERATION_NAME_ONLY) { > > + /* > > + * pid and nodeid -> undefined > > + */ > > + new_pi->pid = new_pi->nodeid = 0; > > + } > > + > > + /* > > + * We will return list "grouped" by "group name", so try to > > find right place to add > > + */ > > + for (iter2 = cpg_iteration_instance->items_list_head.next; > > + iter2 != &cpg_iteration_instance->items_list_head; > > + iter2 = iter2->next) { > > + struct process_info *pi2 = list_entry (iter2, struct > > process_info, list); > > + > > + if (mar_name_compare (&pi2->group, &pi->group) == 0) { > > + break; > > + } > > + } > > + > > + list_add (&new_pi->list, iter2); > > + } > > + > > + /* > > + * Now we have a full "grouped by" copy of process_info list > > + */ > > + > > + /* > > + * Add instance to current cpd list > > + */ > > + list_init (&cpg_iteration_instance->list); > > + list_add (&cpg_iteration_instance->list, > > &cpd->iteration_instance_list_head); > > + > > + cpg_iteration_instance->current_pointer = > > &cpg_iteration_instance->items_list_head; > > + > > +error_put_destroy: > > + hdb_handle_put (&cpg_iteration_handle_t_db, cpg_iteration_handle); > > +error_destroy: > > + if (error != CS_OK) { > > + hdb_handle_destroy (&cpg_iteration_handle_t_db, > > cpg_iteration_handle); > > + } > > + > > +response_send: > > + res_lib_cpg_iterationinitialize.header.size = sizeof > > (res_lib_cpg_iterationinitialize); > > + res_lib_cpg_iterationinitialize.header.id = > > MESSAGE_RES_CPG_ITERATIONINITIALIZE; > > + res_lib_cpg_iterationinitialize.header.error = error; > > + res_lib_cpg_iterationinitialize.iteration_handle = cpg_iteration_handle; > > + > > + api->ipc_response_send (conn, &res_lib_cpg_iterationinitialize, > > + sizeof (res_lib_cpg_iterationinitialize)); > > +} > > + > > +static void message_handler_req_lib_cpg_iteration_next (void *conn, > > + const void *message) > > +{ > > + const struct req_lib_cpg_iterationnext *req_lib_cpg_iterationnext = > > message; > > + struct res_lib_cpg_iterationnext res_lib_cpg_iterationnext; > > + struct cpg_iteration_instance *cpg_iteration_instance; > > + cs_error_t error = CS_OK; > > + int res; > > + struct process_info *pi; > > + > > + log_printf (LOGSYS_LEVEL_DEBUG, "cpg iteration next\n"); > > + > > + res = hdb_handle_get (&cpg_iteration_handle_t_db, > > + req_lib_cpg_iterationnext->iteration_handle, > > + (void *)&cpg_iteration_instance); > > + > > + if (res != 0) { > > + error = CS_ERR_LIBRARY; > > + goto error_exit; > > + } > > + > > + assert (cpg_iteration_instance); > > + > > + cpg_iteration_instance->current_pointer = > > cpg_iteration_instance->current_pointer->next; > > + > > + if (cpg_iteration_instance->current_pointer == > > &cpg_iteration_instance->items_list_head) { > > + error = CS_ERR_NO_SECTIONS; > > + goto error_put; > > + } > > + > > + pi = list_entry (cpg_iteration_instance->current_pointer, struct > > process_info, list); > > + > > + /* > > + * Copy iteration data > > + */ > > + res_lib_cpg_iterationnext.description.nodeid = pi->nodeid; > > + res_lib_cpg_iterationnext.description.pid = pi->pid; > > + memcpy (&res_lib_cpg_iterationnext.description.group, > > + &pi->group, > > + sizeof (mar_cpg_name_t)); > > + > > +error_put: > > + hdb_handle_put (&cpg_iteration_handle_t_db, > > req_lib_cpg_iterationnext->iteration_handle); > > +error_exit: > > + res_lib_cpg_iterationnext.header.size = sizeof > > (res_lib_cpg_iterationnext); > > + res_lib_cpg_iterationnext.header.id = MESSAGE_RES_CPG_ITERATIONNEXT; > > + res_lib_cpg_iterationnext.header.error = error; > > + > > + api->ipc_response_send (conn, &res_lib_cpg_iterationnext, > > + sizeof (res_lib_cpg_iterationnext)); > > +} > > + > > +static void message_handler_req_lib_cpg_iteration_finalize (void *conn, > > + const void *message) > > + > > const void *message should be at 1 tabtop not tabbed to align. > > > { > > + const struct req_lib_cpg_iterationfinalize > > *req_lib_cpg_iterationfinalize = message; > > + struct res_lib_cpg_iterationfinalize res_lib_cpg_iterationfinalize; > > + struct cpg_iteration_instance *cpg_iteration_instance; > > + cs_error_t error = CS_OK; > > + int res; > > + > > + log_printf (LOGSYS_LEVEL_DEBUG, "cpg iteration finalize\n"); > > + > > + res = hdb_handle_get (&cpg_iteration_handle_t_db, > > + req_lib_cpg_iterationfinalize->iteration_handle, > > + (void *)&cpg_iteration_instance); > > + > > + if (res != 0) { > > + error = CS_ERR_LIBRARY; > > + goto error_exit; > > + } > > + > > + assert (cpg_iteration_instance); > > + > > + cpg_iteration_instance_finalize (cpg_iteration_instance); > > + hdb_handle_put (&cpg_iteration_handle_t_db, > > cpg_iteration_instance->handle); > > + > > +error_exit: > > + res_lib_cpg_iterationfinalize.header.size = sizeof > > (res_lib_cpg_iterationfinalize); > > + res_lib_cpg_iterationfinalize.header.id = > > MESSAGE_RES_CPG_ITERATIONFINALIZE; > > + res_lib_cpg_iterationfinalize.header.error = error; > > + > > + api->ipc_response_send (conn, &res_lib_cpg_iterationfinalize, > > + sizeof (res_lib_cpg_iterationfinalize)); > > +} > > _______________________________________________ > > Openais mailing list > > [email protected] > > https://lists.linux-foundation.org/mailman/listinfo/openais > > _______________________________________________ > Openais mailing list > [email protected] > https://lists.linux-foundation.org/mailman/listinfo/openais _______________________________________________ Openais mailing list [email protected] https://lists.linux-foundation.org/mailman/listinfo/openais
