37 #include <sys/types.h>
45 #include <qb/qbloop.h>
46 #include <qb/qbipc_common.h>
61 #define MAX_REQ_EXEC_CMAP_MCAST_ITEMS 32
62 #define ICMAP_VALUETYPE_NOT_EXIST 0
90 static int cmap_exec_exit_fn(
void);
92 static int cmap_lib_init_fn (
void *conn);
93 static int cmap_lib_exit_fn (
void *conn);
95 static void message_handler_req_lib_cmap_set(
void *conn,
const void *message);
96 static void message_handler_req_lib_cmap_delete(
void *conn,
const void *message);
97 static void message_handler_req_lib_cmap_get(
void *conn,
const void *message);
98 static void message_handler_req_lib_cmap_adjust_int(
void *conn,
const void *message);
99 static void message_handler_req_lib_cmap_iter_init(
void *conn,
const void *message);
100 static void message_handler_req_lib_cmap_iter_next(
void *conn,
const void *message);
101 static void message_handler_req_lib_cmap_iter_finalize(
void *conn,
const void *message);
102 static void message_handler_req_lib_cmap_track_add(
void *conn,
const void *message);
103 static void message_handler_req_lib_cmap_track_delete(
void *conn,
const void *message);
105 static void cmap_notify_fn(int32_t event,
106 const char *key_name,
111 static void message_handler_req_exec_cmap_mcast(
115 static void exec_cmap_mcast_endian_convert(
void *message);
126 static void cmap_sync_init (
127 const unsigned int *trans_list,
128 size_t trans_list_entries,
129 const unsigned int *member_list,
130 size_t member_list_entries,
133 static int cmap_sync_process (
void);
134 static void cmap_sync_activate (
void);
135 static void cmap_sync_abort (
void);
137 static void cmap_config_version_track_cb(
139 const char *key_name,
154 .lib_handler_fn = message_handler_req_lib_cmap_delete,
158 .lib_handler_fn = message_handler_req_lib_cmap_get,
162 .lib_handler_fn = message_handler_req_lib_cmap_adjust_int,
166 .lib_handler_fn = message_handler_req_lib_cmap_iter_init,
170 .lib_handler_fn = message_handler_req_lib_cmap_iter_next,
174 .lib_handler_fn = message_handler_req_lib_cmap_iter_finalize,
178 .lib_handler_fn = message_handler_req_lib_cmap_track_add,
182 .lib_handler_fn = message_handler_req_lib_cmap_track_delete,
191 .exec_endian_convert_fn = exec_cmap_mcast_endian_convert
196 .
name =
"corosync configuration map access",
202 .lib_init_fn = cmap_lib_init_fn,
203 .lib_exit_fn = cmap_lib_exit_fn,
204 .lib_engine = cmap_lib_engine,
206 .exec_init_fn = cmap_exec_init_fn,
207 .exec_exit_fn = cmap_exec_exit_fn,
208 .exec_engine = cmap_exec_engine,
210 .sync_init = cmap_sync_init,
211 .sync_process = cmap_sync_process,
212 .sync_activate = cmap_sync_activate,
213 .sync_abort = cmap_sync_abort
218 return (&cmap_service_engine);
229 struct qb_ipc_request_header header __attribute__((aligned(8)));
239 static size_t cmap_sync_trans_list_entries = 0;
240 static size_t cmap_sync_member_list_entries = 0;
241 static uint64_t cmap_highest_config_version_received = 0;
242 static uint64_t cmap_my_config_version = 0;
243 static int cmap_first_sync = 1;
246 static void cmap_config_version_track_cb(
248 const char *key_name,
253 const char *key =
"totem.config_version";
259 cmap_my_config_version = 0;
271 static int cmap_exec_exit_fn(
void)
281 static char *cmap_exec_init_fn (
290 cmap_config_version_track_cb,
292 &cmap_config_version_track);
295 return ((
char *)
"Can't add config_version icmap tracker");
301 static int cmap_lib_init_fn (
void *conn)
309 memset(conn_info, 0,
sizeof(*conn_info));
310 hdb_create(&conn_info->
iter_db);
316 static int cmap_lib_exit_fn (
void *conn)
326 hdb_iterator_reset(&conn_info->
iter_db);
327 while (hdb_iterator_next(&conn_info->
iter_db,
328 (
void*)&iter, &iter_handle) == 0) {
332 (void)hdb_handle_put (&conn_info->
iter_db, iter_handle);
335 hdb_destroy(&conn_info->
iter_db);
337 hdb_iterator_reset(&conn_info->
track_db);
338 while (hdb_iterator_next(&conn_info->
track_db,
339 (
void*)&track, &track_handle) == 0) {
345 (void)hdb_handle_put (&conn_info->
track_db, track_handle);
354 static void cmap_sync_init (
355 const unsigned int *trans_list,
356 size_t trans_list_entries,
357 const unsigned int *member_list,
358 size_t member_list_entries,
362 cmap_sync_trans_list_entries = trans_list_entries;
363 cmap_sync_member_list_entries = member_list_entries;
366 cmap_my_config_version = 0;
369 cmap_highest_config_version_received = cmap_my_config_version;
372 static int cmap_sync_process (
void)
374 const char *key =
"totem.config_version";
379 return (ret ==
CS_OK ? 0 : -1);
382 static void cmap_sync_activate (
void)
385 if (cmap_sync_trans_list_entries == 0) {
391 if (cmap_first_sync == 1) {
399 if (cmap_my_config_version == 0) {
405 if (cmap_highest_config_version_received != cmap_my_config_version) {
407 "Received config version (%"PRIu64
") is different than my config version (%"PRIu64
")! Exiting",
408 cmap_highest_config_version_received, cmap_my_config_version);
414 static void cmap_sync_abort (
void)
420 static void message_handler_req_lib_cmap_set(
void *conn,
const void *message)
429 ret =
icmap_set((
char *)req_lib_cmap_set->key_name.value, &req_lib_cmap_set->value,
430 req_lib_cmap_set->value_len, req_lib_cmap_set->type);
441 static void message_handler_req_lib_cmap_delete(
void *conn,
const void *message)
443 const struct req_lib_cmap_set *req_lib_cmap_set = message;
450 ret =
icmap_delete((
char *)req_lib_cmap_set->key_name.value);
461 static void message_handler_req_lib_cmap_get(
void *conn,
const void *message)
465 struct res_lib_cmap_get error_res_lib_cmap_get;
468 size_t res_lib_cmap_get_size;
472 value_len = req_lib_cmap_get->value_len;
474 res_lib_cmap_get_size =
sizeof(*res_lib_cmap_get) + value_len;
475 res_lib_cmap_get = malloc(res_lib_cmap_get_size);
476 if (res_lib_cmap_get == NULL) {
481 memset(res_lib_cmap_get, 0, res_lib_cmap_get_size);
484 value = res_lib_cmap_get->value;
489 ret =
icmap_get((
char *)req_lib_cmap_get->key_name.value,
495 free(res_lib_cmap_get);
499 res_lib_cmap_get->header.size = res_lib_cmap_get_size;
501 res_lib_cmap_get->header.error = ret;
502 res_lib_cmap_get->type =
type;
503 res_lib_cmap_get->value_len = value_len;
506 free(res_lib_cmap_get);
511 memset(&error_res_lib_cmap_get, 0,
sizeof(error_res_lib_cmap_get));
512 error_res_lib_cmap_get.header.size =
sizeof(error_res_lib_cmap_get);
514 error_res_lib_cmap_get.header.error = ret;
516 api->
ipc_response_send(conn, &error_res_lib_cmap_get,
sizeof(error_res_lib_cmap_get));
519 static void message_handler_req_lib_cmap_adjust_int(
void *conn,
const void *message)
525 if (
icmap_is_key_ro((
char *)req_lib_cmap_adjust_int->key_name.value)) {
529 req_lib_cmap_adjust_int->step);
540 static void message_handler_req_lib_cmap_iter_init(
void *conn,
const void *message)
551 if (req_lib_cmap_iter_init->prefix.length > 0) {
552 prefix = (
char *)req_lib_cmap_iter_init->prefix.value;
575 (void)hdb_handle_put (&conn_info->
iter_db, handle);
587 static void message_handler_req_lib_cmap_iter_next(
void *conn,
const void *message)
593 size_t value_len = 0;
595 const char *res = NULL;
599 req_lib_cmap_iter_next->iter_handle, (
void *)&iter));
609 (void)hdb_handle_put (&conn_info->
iter_db, req_lib_cmap_iter_next->iter_handle);
628 static void message_handler_req_lib_cmap_iter_finalize(
void *conn,
const void *message)
637 req_lib_cmap_iter_finalize->iter_handle, (
void *)&iter));
644 (void)hdb_handle_destroy(&conn_info->
iter_db, req_lib_cmap_iter_finalize->iter_handle);
646 (void)hdb_handle_put (&conn_info->
iter_db, req_lib_cmap_iter_finalize->iter_handle);
657 static void cmap_notify_fn(int32_t event,
658 const char *key_name,
685 iov[1].iov_base = (
char *)new_val.
data;
686 iov[1].iov_len = new_val.
len;
687 iov[2].iov_base = (
char *)old_val.
data;
688 iov[2].iov_len = old_val.
len;
693 static void message_handler_req_lib_cmap_track_add(
void *conn,
const void *message)
701 struct cmap_track_user_data *cmap_track_user_data;
702 const char *key_name;
706 cmap_track_user_data = malloc(
sizeof(*cmap_track_user_data));
707 if (cmap_track_user_data == NULL) {
712 memset(cmap_track_user_data, 0,
sizeof(*cmap_track_user_data));
714 if (req_lib_cmap_track_add->key_name.length > 0) {
715 key_name = (
char *)req_lib_cmap_track_add->key_name.value;
721 req_lib_cmap_track_add->track_type,
723 cmap_track_user_data,
726 free(cmap_track_user_data);
733 free(cmap_track_user_data);
740 free(cmap_track_user_data);
746 cmap_track_user_data->
conn = conn;
748 cmap_track_user_data->
track_inst_handle = req_lib_cmap_track_add->track_inst_handle;
750 (void)hdb_handle_put (&conn_info->
track_db, handle);
762 static void message_handler_req_lib_cmap_track_delete(
void *conn,
const void *message)
769 uint64_t track_inst_handle = 0;
772 req_lib_cmap_track_delete->track_handle, (
void *)&track));
783 (void)hdb_handle_put (&conn_info->
track_db, req_lib_cmap_track_delete->track_handle);
784 (void)hdb_handle_destroy(&conn_info->
track_db, req_lib_cmap_track_delete->track_handle);
814 memset(req_exec_cmap_iovec, 0,
sizeof(req_exec_cmap_iovec));
816 for (i = 0; i < argc; i++) {
817 err =
icmap_get(argv[i], NULL, &value_len, &value_type);
828 item = malloc(item_len);
832 memset(item, 0, item_len);
834 item->value_type = value_type;
835 item->value_len = value_len;
836 item->key_name.length = strlen(argv[i]);
837 strcpy((
char *)item->key_name.value, argv[i]);
840 err =
icmap_get(argv[i], item->value, &value_len, &value_type);
846 req_exec_cmap_iovec[i + 1].iov_base = item;
847 req_exec_cmap_iovec[i + 1].iov_len = item_len;
850 qb_log(LOG_TRACE,
"Item %u - type %u, len %zu", i, item->value_type, item->value_len);
862 qb_log(LOG_TRACE,
"Sending %u items (%u iovec) for reason %u", argc, argc + 1, reason);
866 for (i = 0; i < argc; i++) {
867 free(req_exec_cmap_iovec[i + 1].iov_base);
886 p = (
const char *)message +
sizeof(*req_exec_cmap_mcast);
888 for (i = 0; i < req_exec_cmap_mcast->no_items; i++) {
891 key_name_len = item->key_name.length;
892 if (strlen(key) == key_name_len && strcmp((
char *)item->key_name.value, key) == 0) {
902 static void message_handler_req_exec_cmap_mcast_reason_sync_nv(
908 uint64_t config_version = 0;
914 item = cmap_mcast_item_find(message, (
char *)
"totem.config_version");
916 value_len = item->value_len;
923 memcpy(&config_version, item->value, value_len);
927 qb_log(LOG_TRACE,
"Received config version %"PRIu64
" from node %x", config_version, nodeid);
930 config_version > cmap_highest_config_version_received) {
931 cmap_highest_config_version_received = config_version;
935 "runtime.totem.pg.mrp.srp.members.%u.config_version", nodeid);
941 static void message_handler_req_exec_cmap_mcast(
945 const struct req_exec_cmap_mcast *req_exec_cmap_mcast = message;
949 switch (req_exec_cmap_mcast->reason) {
951 message_handler_req_exec_cmap_mcast_reason_sync_nv(req_exec_cmap_mcast->reason,
956 message_handler_req_exec_cmap_mcast_reason_sync_nv(req_exec_cmap_mcast->reason,
961 qb_log(LOG_TRACE,
"Received mcast with unknown reason %u", req_exec_cmap_mcast->reason);
967 static void exec_cmap_mcast_endian_convert(
void *message)
969 struct req_exec_cmap_mcast *req_exec_cmap_mcast = message;
979 swab_coroipc_request_header_t(&req_exec_cmap_mcast->header);
981 p = (
const char *)message +
sizeof(*req_exec_cmap_mcast);
983 for (i = 0; i < req_exec_cmap_mcast->no_items; i++) {
986 swab_mar_uint16_t(&item->key_name.length);
987 swab_mar_size_t(&item->value_len);
989 switch (item->value_type) {
992 memcpy(&u16, item->value,
sizeof(u16));
994 memcpy(item->value, &u16,
sizeof(u16));
998 memcpy(&u32, item->value,
sizeof(u32));
1000 memcpy(item->value, &u32,
sizeof(u32));
1004 memcpy(&u64, item->value,
sizeof(u64));
1006 memcpy(item->value, &u64,
sizeof(u64));
1009 memcpy(&flt, item->value,
sizeof(flt));
1011 memcpy(item->value, &flt,
sizeof(flt));
1014 memcpy(&dbl, item->value,
sizeof(dbl));
1016 memcpy(item->value, &dbl,
sizeof(dbl));