37 #include <sys/types.h> 45 #include <qb/qbloop.h> 46 #include <qb/qblist.h> 47 #include <qb/qbipcs.h> 48 #include <qb/qbipc_common.h> 64 #define MAX_REQ_EXEC_CMAP_MCAST_ITEMS 32 65 #define ICMAP_VALUETYPE_NOT_EXIST 0 153 static int cmap_exec_exit_fn(
void);
155 static int cmap_lib_init_fn (
void *conn);
156 static int cmap_lib_exit_fn (
void *conn);
158 static void message_handler_req_lib_cmap_set(
void *conn,
const void *message);
159 static void message_handler_req_lib_cmap_delete(
void *conn,
const void *message);
160 static void message_handler_req_lib_cmap_get(
void *conn,
const void *message);
161 static void message_handler_req_lib_cmap_adjust_int(
void *conn,
const void *message);
162 static void message_handler_req_lib_cmap_iter_init(
void *conn,
const void *message);
163 static void message_handler_req_lib_cmap_iter_next(
void *conn,
const void *message);
164 static void message_handler_req_lib_cmap_iter_finalize(
void *conn,
const void *message);
165 static void message_handler_req_lib_cmap_track_add(
void *conn,
const void *message);
166 static void message_handler_req_lib_cmap_track_delete(
void *conn,
const void *message);
167 static void message_handler_req_lib_cmap_set_current_map(
void *conn,
const void *message);
169 static void cmap_notify_fn(int32_t event,
170 const char *key_name,
175 static void message_handler_req_exec_cmap_mcast(
179 static void exec_cmap_mcast_endian_convert(
void *message);
190 static void cmap_sync_init (
191 const unsigned int *trans_list,
192 size_t trans_list_entries,
193 const unsigned int *member_list,
194 size_t member_list_entries,
197 static int cmap_sync_process (
void);
198 static void cmap_sync_activate (
void);
199 static void cmap_sync_abort (
void);
201 static void cmap_config_version_track_cb(
203 const char *key_name,
218 .lib_handler_fn = message_handler_req_lib_cmap_delete,
222 .lib_handler_fn = message_handler_req_lib_cmap_get,
226 .lib_handler_fn = message_handler_req_lib_cmap_adjust_int,
230 .lib_handler_fn = message_handler_req_lib_cmap_iter_init,
234 .lib_handler_fn = message_handler_req_lib_cmap_iter_next,
238 .lib_handler_fn = message_handler_req_lib_cmap_iter_finalize,
242 .lib_handler_fn = message_handler_req_lib_cmap_track_add,
246 .lib_handler_fn = message_handler_req_lib_cmap_track_delete,
250 .lib_handler_fn = message_handler_req_lib_cmap_set_current_map,
259 .exec_endian_convert_fn = exec_cmap_mcast_endian_convert
264 .
name =
"corosync configuration map access",
270 .lib_init_fn = cmap_lib_init_fn,
271 .lib_exit_fn = cmap_lib_exit_fn,
272 .lib_engine = cmap_lib_engine,
274 .exec_init_fn = cmap_exec_init_fn,
275 .exec_exit_fn = cmap_exec_exit_fn,
276 .exec_engine = cmap_exec_engine,
278 .sync_init = cmap_sync_init,
279 .sync_process = cmap_sync_process,
280 .sync_activate = cmap_sync_activate,
281 .sync_abort = cmap_sync_abort
286 return (&cmap_service_engine);
297 struct qb_ipc_request_header header __attribute__((aligned(8)));
307 static size_t cmap_sync_trans_list_entries = 0;
308 static size_t cmap_sync_member_list_entries = 0;
309 static uint64_t cmap_highest_config_version_received = 0;
310 static uint64_t cmap_my_config_version = 0;
311 static int cmap_first_sync = 1;
314 static void cmap_config_version_track_cb(
316 const char *key_name,
321 const char *key =
"totem.config_version";
327 cmap_my_config_version = 0;
339 static int cmap_exec_exit_fn(
void)
349 static char *cmap_exec_init_fn (
358 cmap_config_version_track_cb,
360 &cmap_config_version_track);
363 return ((
char *)
"Can't add config_version icmap tracker");
369 static int cmap_lib_init_fn (
void *conn)
377 memset(conn_info, 0,
sizeof(*conn_info));
379 hdb_create(&conn_info->
iter_db);
385 static int cmap_lib_exit_fn (
void *conn)
395 hdb_iterator_reset(&conn_info->
iter_db);
396 while (hdb_iterator_next(&conn_info->
iter_db,
397 (
void*)&iter, &iter_handle) == 0) {
401 (void)hdb_handle_put (&conn_info->
iter_db, iter_handle);
404 hdb_destroy(&conn_info->
iter_db);
406 hdb_iterator_reset(&conn_info->
track_db);
407 while (hdb_iterator_next(&conn_info->
track_db,
408 (
void*)&track, &track_handle) == 0) {
414 (void)hdb_handle_put (&conn_info->
track_db, track_handle);
423 static void cmap_sync_init (
424 const unsigned int *trans_list,
425 size_t trans_list_entries,
426 const unsigned int *member_list,
427 size_t member_list_entries,
431 cmap_sync_trans_list_entries = trans_list_entries;
432 cmap_sync_member_list_entries = member_list_entries;
435 cmap_my_config_version = 0;
438 cmap_highest_config_version_received = cmap_my_config_version;
441 static int cmap_sync_process (
void)
443 const char *key =
"totem.config_version";
448 return (ret ==
CS_OK ? 0 : -1);
451 static void cmap_sync_activate (
void)
454 if (cmap_sync_trans_list_entries == 0) {
460 if (cmap_first_sync == 1) {
468 if (cmap_my_config_version == 0) {
474 if (cmap_highest_config_version_received != cmap_my_config_version) {
476 "Received config version (%"PRIu64
") is different than my config version (%"PRIu64
")! Exiting",
477 cmap_highest_config_version_received, cmap_my_config_version);
483 static void cmap_sync_abort (
void)
489 static void message_handler_req_lib_cmap_set(
void *conn,
const void *message)
499 ret = conn_info->
map_fns.
map_set((
char *)req_lib_cmap_set->key_name.value, &req_lib_cmap_set->value,
500 req_lib_cmap_set->value_len, req_lib_cmap_set->type);
503 memset(&res_lib_cmap_set, 0,
sizeof(res_lib_cmap_set));
504 res_lib_cmap_set.header.size =
sizeof(res_lib_cmap_set);
506 res_lib_cmap_set.header.error = ret;
511 static void message_handler_req_lib_cmap_delete(
void *conn,
const void *message)
524 memset(&res_lib_cmap_delete, 0,
sizeof(res_lib_cmap_delete));
525 res_lib_cmap_delete.header.size =
sizeof(res_lib_cmap_delete);
527 res_lib_cmap_delete.header.error = ret;
532 static void message_handler_req_lib_cmap_get(
void *conn,
const void *message)
537 struct res_lib_cmap_get error_res_lib_cmap_get;
540 size_t res_lib_cmap_get_size;
544 value_len = req_lib_cmap_get->value_len;
546 res_lib_cmap_get_size =
sizeof(*res_lib_cmap_get) + value_len;
547 res_lib_cmap_get = malloc(res_lib_cmap_get_size);
548 if (res_lib_cmap_get == NULL) {
553 memset(res_lib_cmap_get, 0, res_lib_cmap_get_size);
556 value = res_lib_cmap_get->value;
561 ret = conn_info->
map_fns.
map_get((
char *)req_lib_cmap_get->key_name.value,
567 free(res_lib_cmap_get);
571 res_lib_cmap_get->header.size = res_lib_cmap_get_size;
573 res_lib_cmap_get->header.error = ret;
574 res_lib_cmap_get->type =
type;
575 res_lib_cmap_get->value_len = value_len;
578 free(res_lib_cmap_get);
583 memset(&error_res_lib_cmap_get, 0,
sizeof(error_res_lib_cmap_get));
584 error_res_lib_cmap_get.header.size =
sizeof(error_res_lib_cmap_get);
586 error_res_lib_cmap_get.header.error = ret;
588 api->
ipc_response_send(conn, &error_res_lib_cmap_get,
sizeof(error_res_lib_cmap_get));
591 static void message_handler_req_lib_cmap_adjust_int(
void *conn,
const void *message)
602 req_lib_cmap_adjust_int->step);
606 memset(&res_lib_cmap_adjust_int, 0,
sizeof(res_lib_cmap_adjust_int));
607 res_lib_cmap_adjust_int.header.size =
sizeof(res_lib_cmap_adjust_int);
609 res_lib_cmap_adjust_int.header.error = ret;
611 api->
ipc_response_send(conn, &res_lib_cmap_adjust_int,
sizeof(res_lib_cmap_adjust_int));
614 static void message_handler_req_lib_cmap_iter_init(
void *conn,
const void *message)
625 if (req_lib_cmap_iter_init->prefix.length > 0) {
626 prefix = (
char *)req_lib_cmap_iter_init->prefix.value;
649 (void)hdb_handle_put (&conn_info->
iter_db, handle);
652 memset(&res_lib_cmap_iter_init, 0,
sizeof(res_lib_cmap_iter_init));
653 res_lib_cmap_iter_init.header.size =
sizeof(res_lib_cmap_iter_init);
655 res_lib_cmap_iter_init.header.error = ret;
656 res_lib_cmap_iter_init.iter_handle = handle;
658 api->
ipc_response_send(conn, &res_lib_cmap_iter_init,
sizeof(res_lib_cmap_iter_init));
661 static void message_handler_req_lib_cmap_iter_next(
void *conn,
const void *message)
667 size_t value_len = 0;
669 const char *res = NULL;
673 req_lib_cmap_iter_next->iter_handle, (
void *)&iter));
683 (void)hdb_handle_put (&conn_info->
iter_db, req_lib_cmap_iter_next->iter_handle);
686 memset(&res_lib_cmap_iter_next, 0,
sizeof(res_lib_cmap_iter_next));
687 res_lib_cmap_iter_next.header.size =
sizeof(res_lib_cmap_iter_next);
689 res_lib_cmap_iter_next.header.error = ret;
692 res_lib_cmap_iter_next.value_len = value_len;
693 res_lib_cmap_iter_next.type =
type;
695 assert(strlen(res) <=
sizeof(res_lib_cmap_iter_next.key_name.value));
697 memcpy(res_lib_cmap_iter_next.key_name.value, res, strlen(res));
698 res_lib_cmap_iter_next.key_name.length = strlen(res);
701 api->
ipc_response_send(conn, &res_lib_cmap_iter_next,
sizeof(res_lib_cmap_iter_next));
704 static void message_handler_req_lib_cmap_iter_finalize(
void *conn,
const void *message)
713 req_lib_cmap_iter_finalize->iter_handle, (
void *)&iter));
720 (void)hdb_handle_destroy(&conn_info->
iter_db, req_lib_cmap_iter_finalize->iter_handle);
722 (void)hdb_handle_put (&conn_info->
iter_db, req_lib_cmap_iter_finalize->iter_handle);
725 memset(&res_lib_cmap_iter_finalize, 0,
sizeof(res_lib_cmap_iter_finalize));
726 res_lib_cmap_iter_finalize.header.size =
sizeof(res_lib_cmap_iter_finalize);
728 res_lib_cmap_iter_finalize.header.error = ret;
730 api->
ipc_response_send(conn, &res_lib_cmap_iter_finalize,
sizeof(res_lib_cmap_iter_finalize));
733 static void cmap_notify_fn(int32_t event,
734 const char *key_name,
743 memset(&res_lib_cmap_notify_callback, 0,
sizeof(res_lib_cmap_notify_callback));
745 res_lib_cmap_notify_callback.header.size =
sizeof(res_lib_cmap_notify_callback) + new_val.
len + old_val.
len;
747 res_lib_cmap_notify_callback.header.error =
CS_OK;
749 res_lib_cmap_notify_callback.new_value_type = new_val.
type;
750 res_lib_cmap_notify_callback.old_value_type = old_val.
type;
751 res_lib_cmap_notify_callback.new_value_len = new_val.
len;
752 res_lib_cmap_notify_callback.old_value_len = old_val.
len;
753 res_lib_cmap_notify_callback.event = event;
754 res_lib_cmap_notify_callback.key_name.length = strlen(key_name);
755 res_lib_cmap_notify_callback.track_inst_handle = cmap_track_user_data->
track_inst_handle;
757 assert(strlen(key_name) <=
sizeof(res_lib_cmap_notify_callback.key_name.value));
759 memcpy(res_lib_cmap_notify_callback.key_name.value, key_name, strlen(key_name));
761 iov[0].iov_base = (
char *)&res_lib_cmap_notify_callback;
762 iov[0].iov_len =
sizeof(res_lib_cmap_notify_callback);
763 iov[1].iov_base = (
char *)new_val.
data;
764 iov[1].iov_len = new_val.
len;
765 iov[2].iov_base = (
char *)old_val.
data;
766 iov[2].iov_len = old_val.
len;
771 static void message_handler_req_lib_cmap_track_add(
void *conn,
const void *message)
780 const char *key_name;
784 cmap_track_user_data = malloc(
sizeof(*cmap_track_user_data));
785 if (cmap_track_user_data == NULL) {
790 memset(cmap_track_user_data, 0,
sizeof(*cmap_track_user_data));
792 if (req_lib_cmap_track_add->key_name.length > 0) {
793 key_name = (
char *)req_lib_cmap_track_add->key_name.value;
799 req_lib_cmap_track_add->track_type,
801 cmap_track_user_data,
804 free(cmap_track_user_data);
811 free(cmap_track_user_data);
818 free(cmap_track_user_data);
824 cmap_track_user_data->
conn = conn;
826 cmap_track_user_data->
track_inst_handle = req_lib_cmap_track_add->track_inst_handle;
828 (void)hdb_handle_put (&conn_info->
track_db, handle);
831 memset(&res_lib_cmap_track_add, 0,
sizeof(res_lib_cmap_track_add));
832 res_lib_cmap_track_add.header.size =
sizeof(res_lib_cmap_track_add);
834 res_lib_cmap_track_add.header.error = ret;
835 res_lib_cmap_track_add.track_handle = handle;
837 api->
ipc_response_send(conn, &res_lib_cmap_track_add,
sizeof(res_lib_cmap_track_add));
840 static void message_handler_req_lib_cmap_track_delete(
void *conn,
const void *message)
847 uint64_t track_inst_handle = 0;
850 req_lib_cmap_track_delete->track_handle, (
void *)&track));
862 (void)hdb_handle_put (&conn_info->
track_db, req_lib_cmap_track_delete->track_handle);
863 (void)hdb_handle_destroy(&conn_info->
track_db, req_lib_cmap_track_delete->track_handle);
866 memset(&res_lib_cmap_track_delete, 0,
sizeof(res_lib_cmap_track_delete));
867 res_lib_cmap_track_delete.header.size =
sizeof(res_lib_cmap_track_delete);
869 res_lib_cmap_track_delete.header.error = ret;
876 static void message_handler_req_lib_cmap_set_current_map(
void *
conn,
const void *message)
879 struct qb_ipc_response_header res;
882 int handles_open = 0;
889 hdb_iterator_reset(&conn_info->
iter_db);
890 while (hdb_iterator_next(&conn_info->
iter_db,
891 (
void*)&iter, &iter_handle) == 0) {
895 hdb_iterator_reset(&conn_info->
track_db);
896 while (hdb_iterator_next(&conn_info->
track_db,
897 (
void*)&track, &track_handle) == 0) {
906 switch (req_lib_cmap_set_current_map->map) {
919 res.size =
sizeof(res);
936 struct iovec req_exec_cmap_iovec[MAX_REQ_EXEC_CMAP_MCAST_ITEMS + 1];
940 if (argc > MAX_REQ_EXEC_CMAP_MCAST_ITEMS) {
944 memset(req_exec_cmap_iovec, 0,
sizeof(req_exec_cmap_iovec));
946 for (i = 0; i < argc; i++) {
947 err =
icmap_get(argv[i], NULL, &value_len, &value_type);
958 item = malloc(item_len);
962 memset(item, 0, item_len);
964 item->value_type = value_type;
965 item->value_len = value_len;
966 item->key_name.length = strlen(argv[i]);
968 assert(strlen(argv[i]) <
sizeof(item->key_name.value));
970 strcpy((
char *)item->key_name.value, argv[i]);
973 err =
icmap_get(argv[i], item->value, &value_len, &value_type);
979 req_exec_cmap_iovec[i + 1].iov_base = item;
980 req_exec_cmap_iovec[i + 1].iov_len = item_len;
983 qb_log(LOG_TRACE,
"Item %u - type %u, len %zu", i, item->value_type, item->value_len);
988 memset(&req_exec_cmap_mcast, 0,
sizeof(req_exec_cmap_mcast));
989 req_exec_cmap_mcast.header.size =
sizeof(req_exec_cmap_mcast) + msg_len;
990 req_exec_cmap_mcast.reason = reason;
991 req_exec_cmap_mcast.no_items = argc;
992 req_exec_cmap_iovec[0].iov_base = &req_exec_cmap_mcast;
993 req_exec_cmap_iovec[0].iov_len =
sizeof(req_exec_cmap_mcast);
995 qb_log(LOG_TRACE,
"Sending %u items (%u iovec) for reason %u", argc, argc + 1, reason);
999 for (i = 0; i < argc; i++) {
1000 free(req_exec_cmap_iovec[i + 1].iov_base);
1010 const void *message,
1019 p = (
const char *)message +
sizeof(*req_exec_cmap_mcast);
1021 for (i = 0; i < req_exec_cmap_mcast->no_items; i++) {
1024 key_name_len = item->key_name.length;
1025 if (strlen(key) == key_name_len && strcmp((
char *)item->key_name.value, key) == 0) {
1035 static void message_handler_req_exec_cmap_mcast_reason_sync_nv(
1037 const void *message,
1041 uint64_t config_version = 0;
1047 item = cmap_mcast_item_find(message, (
char *)
"totem.config_version");
1049 value_len = item->value_len;
1056 memcpy(&config_version, item->value, value_len);
1060 qb_log(LOG_TRACE,
"Received config version %"PRIu64
" from node " CS_PRI_NODE_ID, config_version, nodeid);
1063 config_version > cmap_highest_config_version_received) {
1064 cmap_highest_config_version_received = config_version;
1068 "runtime.members.%u.config_version", nodeid);
1074 static void message_handler_req_exec_cmap_mcast(
1075 const void *message,
1082 switch (req_exec_cmap_mcast->reason) {
1084 message_handler_req_exec_cmap_mcast_reason_sync_nv(req_exec_cmap_mcast->reason,
1089 message_handler_req_exec_cmap_mcast_reason_sync_nv(req_exec_cmap_mcast->reason,
1094 qb_log(LOG_TRACE,
"Received mcast with unknown reason %u", req_exec_cmap_mcast->reason);
1100 static void exec_cmap_mcast_endian_convert(
void *message)
1112 swab_coroipc_request_header_t(&req_exec_cmap_mcast->header);
1114 p = (
const char *)message +
sizeof(*req_exec_cmap_mcast);
1116 for (i = 0; i < req_exec_cmap_mcast->no_items; i++) {
1119 swab_mar_uint16_t(&item->key_name.length);
1120 swab_mar_size_t(&item->value_len);
1122 switch (item->value_type) {
1125 memcpy(&u16, item->value,
sizeof(u16));
1127 memcpy(item->value, &u16,
sizeof(u16));
1131 memcpy(&u32, item->value,
sizeof(u32));
1133 memcpy(item->value, &u32,
sizeof(u32));
1137 memcpy(&u64, item->value,
sizeof(u64));
1139 memcpy(item->value, &u64,
sizeof(u64));
1142 memcpy(&flt, item->value,
sizeof(flt));
1144 memcpy(item->value, &flt,
sizeof(flt));
1147 memcpy(&dbl, item->value,
sizeof(dbl));
1149 memcpy(item->value, &dbl,
sizeof(dbl));
void *(* ipc_private_data_get)(void *conn)
The res_lib_cmap_track_add struct.
uint64_t track_inst_handle
The res_lib_cmap_iter_finalize struct.
void * icmap_track_get_user_data(icmap_track_t icmap_track)
Return user data associated with given track.
#define ICMAP_VALUETYPE_NOT_EXIST
cs_error_t hdb_error_to_cs(int res)
const char * icmap_iter_next(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type)
Return next item in iterator iter.
cs_error_t icmap_adjust_int(const char *key_name, int32_t step)
icmap_adjust_int
const char *(* map_iter_next)(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type)
cs_error_t stats_map_track_add(const char *key_name, int32_t track_type, icmap_notify_fn_t notify_fn, void *user_data, icmap_track_t *icmap_track)
The corosync_service_engine struct.
void icmap_iter_finalize(icmap_iter_t iter)
Finalize iterator.
struct corosync_service_engine cmap_service_engine
cs_error_t(* map_get)(const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type)
uint64_t cmap_iter_handle_t
cs_error_t icmap_set(const char *key_name, const void *value, size_t value_len, icmap_value_types_t type)
Store value with value_len length and type as key_name name in global icmap.
void(* shutdown_request)(void)
The res_lib_cmap_iter_next struct.
int(* ipc_dispatch_iov_send)(void *conn, const struct iovec *iov, unsigned int iov_len)
int(* ipc_response_send)(void *conn, const void *msg, size_t mlen)
cs_error_t stats_map_track_delete(icmap_track_t icmap_track)
#define MAR_ALIGN_UP(addr, size)
The res_lib_cmap_adjust_int struct.
The req_lib_cmap_iter_finalize struct.
The corosync_lib_handler struct.
cmap_track_handle_t track_handle
The req_lib_cmap_set_current_map struct used by cmap_initialize_map()
The corosync_exec_handler struct.
The req_lib_cmap_iter_next struct.
int(* totem_mcast)(const struct iovec *iovec, unsigned int iov_len, unsigned int guarantee)
#define log_printf(level, format, args...)
void(* exec_handler_fn)(const void *msg, unsigned int nodeid)
#define swab64(x)
The swab64 macro.
void(* map_iter_finalize)(icmap_iter_t iter)
#define ICMAP_TRACK_DELETE
#define ICMAP_KEYNAME_MAXLEN
Maximum length of key in icmap.
The res_lib_cmap_iter_init struct.
cs_error_t(* map_track_add)(const char *key_name, int32_t track_type, icmap_notify_fn_t notify_fn, void *user_data, icmap_track_t *icmap_track)
#define ICMAP_TRACK_MODIFY
cs_error_t(* map_track_delete)(icmap_track_t icmap_track)
The req_lib_cmap_track_add struct.
uint64_t cmap_track_handle_t
The res_lib_cmap_notify_callback struct.
unsigned int(* totem_nodeid_get)(void)
void(* icmap_notify_fn_t)(int32_t event, const char *key_name, struct icmap_notify_value new_value, struct icmap_notify_value old_value, void *user_data)
Prototype for notify callback function.
mar_uint64_t mar_size_t
mar_size_t
void(* ipc_refcnt_dec)(void *conn)
LOGSYS_DECLARE_SUBSYS("CMAP")
int(* map_is_key_ro)(const char *key_name)
#define LOGSYS_LEVEL_ERROR
cs_error_t icmap_delete(const char *key_name)
Delete key from map.
cs_error_t icmap_get(const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type)
Retrieve value of key key_name and store it in user preallocated value pointer.
cs_error_t
The cs_error_t enum.
cs_error_t icmap_track_delete(icmap_track_t icmap_track)
Remove previously added track.
#define LOGSYS_LEVEL_DEBUG
cs_error_t(* map_adjust_int)(const char *key_name, int32_t step)
uint64_t cmap_track_handle_t
struct hdb_handle_database iter_db
void * stats_map_track_get_user_data(icmap_track_t icmap_track)
The corosync_api_v1 struct.
The res_lib_cmap_track_delete struct.
cs_error_t stats_map_set(const char *key_name, const void *value, size_t value_len, icmap_value_types_t type)
cs_error_t stats_map_adjust_int(const char *key_name, int32_t step)
#define swab32(x)
The swab32 macro.
const char * stats_map_iter_next(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type)
cs_error_t icmap_set_uint64(const char *key_name, uint64_t value)
int icmap_is_key_ro(const char *key_name)
Check in given key is read only.
struct corosync_service_engine * cmap_get_service_engine_ver0(void)
void *(* map_track_get_user_data)(icmap_track_t icmap_track)
struct cmap_map icmap_map
icmap_iter_t stats_map_iter_init(const char *prefix)
cs_error_t(* map_delete)(const char *key_name)
The res_lib_cmap_delete struct.
The req_lib_cmap_iter_init struct.
The req_lib_cmap_track_delete struct.
cs_error_t stats_map_delete(const char *key_name)
cs_error_t icmap_get_uint64(const char *key_name, uint64_t *u64)
#define swab16(x)
The swab16 macro.
cs_error_t stats_map_get(const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type)
void stats_map_iter_finalize(icmap_iter_t iter)
uint64_t cmap_iter_handle_t
The res_lib_cmap_set struct.
cs_error_t(* map_set)(const char *key_name, const void *value, size_t value_len, icmap_value_types_t type)
The req_lib_cmap_adjust_int struct.
void(* lib_handler_fn)(void *conn, const void *msg)
icmap_iter_t(* map_iter_init)(const char *prefix)
The res_lib_cmap_get struct.
The req_lib_cmap_set struct.
struct cmap_map stats_map
icmap_iter_t icmap_iter_init(const char *prefix)
Initialize iterator with given prefix.
struct memb_ring_id ring_id
icmap_value_types_t
Possible types of value.
#define hdb_handle_database
qb_map_iter_t * icmap_iter_t
Itterator type.
The req_lib_cmap_get struct.
Structure passed as new_value and old_value in change callback.
cs_error_t icmap_track_add(const char *key_name, int32_t track_type, icmap_notify_fn_t notify_fn, void *user_data, icmap_track_t *icmap_track)
Add tracking function for given key_name.
int stats_map_is_key_ro(const char *key_name)
struct hdb_handle_database track_db
void(* ipc_refcnt_inc)(void *conn)