static int object_find_next (
hdb_handle_t object_find_handle,
hdb_handle_t *object_handle)
{
int res;
struct object_find_instance *object_find_instance;
struct object_instance *object_instance = NULL;
int found = 0;
size_t pos;
res = hdb_handle_get (&object_find_instance_database,
object_find_handle, (void *)&object_find_instance);
if (res != 0) {
goto error_exit;
}
for (pos = object_find_instance->handles_array_pos; !found &&
pos < object_find_instance->handles_array_size; pos++) {
*object_handle = object_find_instance->handles_array[pos];
res = hdb_handle_get (&object_instance_database,
*object_handle, (void *)&object_instance);
if (res != 0) {
continue;
}
if (object_find_instance->object_len == 0 ||
((object_instance->object_name_len ==
object_find_instance->object_len) &&
(memcmp (object_instance->object_name,
object_find_instance->object_name,
object_find_instance->object_len) == 0))) {
found = 1;
}
hdb_handle_put (&object_instance_database, *object_handle);
}
object_find_instance->handles_array_pos = pos;
hdb_handle_put (&object_find_instance_database, object_find_handle);
if (found) {
*object_handle = object_instance->object_handle;
res = 0;
} else {
res = -1;
}
return (res);
error_exit:
return (-1);
}
cs_error_t cmap_track_delete(
cmap_handle_t handle,
cmap_track_handle_t track_handle)
{
cs_error_t error;
struct iovec iov;
struct cmap_inst *cmap_inst;
struct cmap_track_inst *cmap_track_inst;
struct req_lib_cmap_track_delete req_lib_cmap_track_delete;
struct res_lib_cmap_track_delete res_lib_cmap_track_delete;
error = hdb_error_to_cs(hdb_handle_get (&cmap_handle_t_db, handle, (void *)&cmap_inst));
if (error != CS_OK) {
return (error);
}
memset(&req_lib_cmap_track_delete, 0, sizeof(req_lib_cmap_track_delete));
req_lib_cmap_track_delete.header.size = sizeof(req_lib_cmap_track_delete);
req_lib_cmap_track_delete.header.id = MESSAGE_REQ_CMAP_TRACK_DELETE;
req_lib_cmap_track_delete.track_handle = track_handle;
iov.iov_base = (char *)&req_lib_cmap_track_delete;
iov.iov_len = sizeof(req_lib_cmap_track_delete);
error = qb_to_cs_error(qb_ipcc_sendv_recv(
cmap_inst->c,
&iov,
1,
&res_lib_cmap_track_delete,
sizeof (struct res_lib_cmap_track_delete), CS_IPC_TIMEOUT_MS));
if (error == CS_OK) {
error = res_lib_cmap_track_delete.header.error;
}
if (error == CS_OK) {
error = hdb_error_to_cs(hdb_handle_get(&cmap_track_handle_t_db,
res_lib_cmap_track_delete.track_inst_handle,
(void *)&cmap_track_inst));
if (error != CS_OK) {
goto error_put;
}
(void)hdb_handle_put(&cmap_track_handle_t_db, res_lib_cmap_track_delete.track_inst_handle);
(void)hdb_handle_destroy(&cmap_track_handle_t_db, res_lib_cmap_track_delete.track_inst_handle);
}
error_put:
(void)hdb_handle_put (&cmap_handle_t_db, handle);
return (error);
}
/*
* object db reading
*/
static int object_find_create (
hdb_handle_t object_handle,
const void *object_name,
size_t object_len,
hdb_handle_t *object_find_handle)
{
unsigned int res;
struct object_instance *object_instance;
struct object_find_instance *object_find_instance;
objdb_rdlock();
res = hdb_handle_get (&object_instance_database,
object_handle, (void *)&object_instance);
if (res != 0) {
goto error_exit;
}
res = hdb_handle_create (&object_find_instance_database,
sizeof (struct object_find_instance), object_find_handle);
if (res != 0) {
goto error_put;
}
res = hdb_handle_get (&object_find_instance_database,
*object_find_handle, (void *)&object_find_instance);
if (res != 0) {
goto error_destroy;
}
object_find_instance->find_child_list = &object_instance->child_head;
object_find_instance->child_head = &object_instance->child_head;
object_find_instance->object_name = (char *)object_name;
object_find_instance->object_len = object_len;
hdb_handle_put (&object_instance_database, object_handle);
hdb_handle_put (&object_find_instance_database, *object_find_handle);
objdb_rdunlock();
return (0);
error_destroy:
hdb_handle_destroy (&object_instance_database, *object_find_handle);
error_put:
hdb_handle_put (&object_instance_database, object_handle);
error_exit:
objdb_rdunlock();
return (-1);
}
evs_error_t evs_finalize (
evs_handle_t handle)
{
struct evs_inst *evs_inst;
cs_error_t error;
error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
if (error != CS_OK) {
return (error);
}
/*
* Another thread has already started finalizing
*/
if (evs_inst->finalize) {
hdb_handle_put (&evs_handle_t_db, handle);
return (EVS_ERR_BAD_HANDLE);
}
evs_inst->finalize = 1;
coroipcc_service_disconnect (evs_inst->handle);
hdb_handle_destroy (&evs_handle_t_db, handle);
hdb_handle_put (&evs_handle_t_db, handle);
return (EVS_OK);
}
cs_error_t quorum_finalize (
quorum_handle_t handle)
{
struct quorum_inst *quorum_inst;
cs_error_t error;
error = hdb_error_to_cs(hdb_handle_get (&quorum_handle_t_db, handle, (void *)&quorum_inst));
if (error != CS_OK) {
return (error);
}
/*
* Another thread has already started finalizing
*/
if (quorum_inst->finalize) {
(void)hdb_handle_put (&quorum_handle_t_db, handle);
return (CS_ERR_BAD_HANDLE);
}
quorum_inst->finalize = 1;
qb_ipcc_disconnect (quorum_inst->c);
(void)hdb_handle_destroy (&quorum_handle_t_db, handle);
(void)hdb_handle_put (&quorum_handle_t_db, handle);
return (CS_OK);
}
cs_error_t
coroipcc_msg_send_reply_receive (
hdb_handle_t handle,
const struct iovec *iov,
unsigned int iov_len,
void *res_msg,
size_t res_len)
{
cs_error_t res;
struct ipc_instance *ipc_instance;
res = hdb_error_to_cs (hdb_handle_get (&ipc_hdb, handle, (void **)&ipc_instance));
if (res != CS_OK) {
return (res);
}
pthread_mutex_lock (&ipc_instance->mutex);
res = msg_send (ipc_instance, iov, iov_len);
if (res != CS_OK) {
goto error_exit;
}
res = reply_receive (ipc_instance, res_msg, res_len);
error_exit:
pthread_mutex_unlock (&ipc_instance->mutex);
hdb_handle_put (&ipc_hdb, handle);
return (res);
}
cs_error_t cmap_finalize(cmap_handle_t handle)
{
struct cmap_inst *cmap_inst;
cs_error_t error;
hdb_handle_t track_inst_handle = 0;
struct cmap_track_inst *cmap_track_inst;
error = hdb_error_to_cs(hdb_handle_get(&cmap_handle_t_db, handle, (void *)&cmap_inst));
if (error != CS_OK) {
return (error);
}
qb_ipcc_disconnect(cmap_inst->c);
/*
* Destroy all track instances for given connection
*/
hdb_iterator_reset(&cmap_track_handle_t_db);
while (hdb_iterator_next(&cmap_track_handle_t_db,
(void*)&cmap_track_inst, &track_inst_handle) == 0) {
if (cmap_track_inst->c == cmap_inst->c) {
(void)hdb_handle_destroy(&cmap_track_handle_t_db, track_inst_handle);
}
(void)hdb_handle_put (&cmap_track_handle_t_db, track_inst_handle);
}
(void)hdb_handle_destroy(&cmap_handle_t_db, handle);
(void)hdb_handle_put(&cmap_handle_t_db, handle);
return (CS_OK);
}
cs_error_t votequorum_finalize (
votequorum_handle_t handle)
{
struct votequorum_inst *votequorum_inst;
cs_error_t error;
error = hdb_error_to_cs(hdb_handle_get (&votequorum_handle_t_db, handle, (void *)&votequorum_inst));
if (error != CS_OK) {
return (error);
}
/*
* Another thread has already started finalizing
*/
if (votequorum_inst->finalize) {
hdb_handle_put (&votequorum_handle_t_db, handle);
return (CS_ERR_BAD_HANDLE);
}
votequorum_inst->finalize = 1;
hdb_handle_destroy (&votequorum_handle_t_db, handle);
hdb_handle_put (&votequorum_handle_t_db, handle);
return (CS_OK);
}
SaAisErrorT
saAmfFinalize (
SaAmfHandleT amfHandle)
{
struct amfInstance *amfInstance;
SaAisErrorT error;
error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle, (void *)&amfInstance));
if (error != SA_AIS_OK) {
return (error);
}
/*
* Another thread has already started finalizing
*/
if (amfInstance->finalize) {
hdb_handle_put (&amfHandleDatabase, amfHandle);
return (SA_AIS_ERR_BAD_HANDLE);
}
amfInstance->finalize = 1;
coroipcc_service_disconnect (amfInstance->handle);
hdb_handle_destroy (&amfHandleDatabase, amfHandle);
hdb_handle_put (&amfHandleDatabase, amfHandle);
return (error);
}
static int object_key_valid_set (
hdb_handle_t object_handle,
struct object_key_valid *object_key_valid_list,
size_t object_key_valid_list_entries)
{
struct object_instance *instance;
unsigned int res;
objdb_rdlock();
res = hdb_handle_get (&object_instance_database,
object_handle, (void *)&instance);
if (res != 0) {
goto error_exit;
}
instance->object_key_valid_list = object_key_valid_list;
instance->object_key_valid_list_entries = object_key_valid_list_entries;
hdb_handle_put (&object_instance_database, object_handle);
objdb_rdunlock();
return (0);
error_exit:
objdb_rdunlock();
return (-1);
}
SaAisErrorT
saAmfComponentNameGet (
SaAmfHandleT amfHandle,
SaNameT *compName)
{
struct amfInstance *amfInstance;
SaAisErrorT error;
char *env_value;
error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle,
(void *)&amfInstance));
if (error != SA_AIS_OK) {
return (error);
}
error = SA_AIS_OK;
env_value = getenv ("SA_AMF_COMPONENT_NAME");
if (env_value == 0) {
error = SA_AIS_ERR_NOT_EXIST;
goto error_exit;
}
strncpy ((char *)compName->value, env_value, SA_MAX_NAME_LENGTH-1);
compName->value[SA_MAX_NAME_LENGTH-1] = '\0';
compName->length = strlen (env_value);
error_exit:
hdb_handle_put (&amfHandleDatabase, amfHandle);
return (error);
}
SaAisErrorT
saAmfProtectionGroupTrackStop (
SaAmfHandleT amfHandle,
const SaNameT *csiName)
{
struct amfInstance *amfInstance;
struct req_lib_amf_protectiongrouptrackstop req_lib_amf_protectiongrouptrackstop;
struct res_lib_amf_protectiongrouptrackstop res_lib_amf_protectiongrouptrackstop;
struct iovec iov;
SaAisErrorT error;
error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle,
(void *)&amfInstance));
if (error != SA_AIS_OK) {
return (error);
}
req_lib_amf_protectiongrouptrackstop.header.size = sizeof (struct req_lib_amf_protectiongrouptrackstop);
req_lib_amf_protectiongrouptrackstop.header.id = MESSAGE_REQ_AMF_PROTECTIONGROUPTRACKSTOP;
memcpy (&req_lib_amf_protectiongrouptrackstop.csiName, csiName, sizeof (SaNameT));
iov.iov_base = (void *)&req_lib_amf_protectiongrouptrackstop,
iov.iov_len = sizeof (struct req_lib_amf_protectiongrouptrackstop),
error = coroipcc_msg_send_reply_receive (amfInstance->handle,
&iov,
1,
&res_lib_amf_protectiongrouptrackstop,
sizeof (struct res_lib_amf_protectiongrouptrackstop));
hdb_handle_put (&amfHandleDatabase, amfHandle);
return (error == SA_AIS_OK ? res_lib_amf_protectiongrouptrackstop.header.error : error);
}
static int object_find_destroy (
hdb_handle_t object_find_handle)
{
struct object_find_instance *object_find_instance;
unsigned int res;
objdb_lock();
res = hdb_handle_get (&object_find_instance_database,
object_find_handle, (void *)&object_find_instance);
if (res != 0) {
goto error_exit;
}
free(object_find_instance->handles_array);
hdb_handle_put(&object_find_instance_database, object_find_handle);
hdb_handle_destroy(&object_find_instance_database, object_find_handle);
objdb_unlock();
return (0);
error_exit:
objdb_unlock();
return (-1);
}
/**
* test
* @param handle The handle of pload initialize
* @param callbacks The callbacks for pload_initialize
* @returns PLOAD_OK
*/
unsigned int pload_initialize (
pload_handle_t *handle,
pload_callbacks_t *callbacks)
{
cs_error_t error;
struct pload_inst *pload_inst;
error = hdb_error_to_cs(hdb_handle_create (&pload_handle_t_db, sizeof (struct pload_inst), handle));
if (error != CS_OK) {
goto error_no_destroy;
}
error = hdb_error_to_cs(hdb_handle_get (&pload_handle_t_db, *handle, (void *)&pload_inst));
if (error != CS_OK) {
goto error_destroy;
}
pload_inst->c = qb_ipcc_connect ("pload", IPC_REQUEST_SIZE);
if (pload_inst->c == NULL) {
error = qb_to_cs_error(-errno);
goto error_put_destroy;
}
(void)hdb_handle_put (&pload_handle_t_db, *handle);
return (CS_OK);
error_put_destroy:
(void)hdb_handle_put (&pload_handle_t_db, *handle);
error_destroy:
(void)hdb_handle_destroy (&pload_handle_t_db, *handle);
error_no_destroy:
return (error);
}
cs_error_t
corosync_cfg_replyto_shutdown (
corosync_cfg_handle_t cfg_handle,
corosync_cfg_shutdown_reply_flags_t response)
{
struct cfg_inst *cfg_inst;
struct req_lib_cfg_replytoshutdown req_lib_cfg_replytoshutdown;
struct res_lib_cfg_replytoshutdown res_lib_cfg_replytoshutdown;
struct iovec iov;
cs_error_t error;
error = hdb_error_to_cs(hdb_handle_get (&cfg_hdb, cfg_handle,
(void *)&cfg_inst));
if (error != CS_OK) {
return (error);
}
req_lib_cfg_replytoshutdown.header.id = MESSAGE_REQ_CFG_REPLYTOSHUTDOWN;
req_lib_cfg_replytoshutdown.header.size = sizeof (struct req_lib_cfg_replytoshutdown);
req_lib_cfg_replytoshutdown.response = response;
iov.iov_base = (void *)&req_lib_cfg_replytoshutdown;
iov.iov_len = sizeof (struct req_lib_cfg_replytoshutdown);
error = qb_to_cs_error (qb_ipcc_sendv_recv (cfg_inst->c,
&iov,
1,
&res_lib_cfg_replytoshutdown,
sizeof (struct res_lib_cfg_replytoshutdown), CS_IPC_TIMEOUT_MS));
return (error);
}
cs_error_t
corosync_cfg_try_shutdown (
corosync_cfg_handle_t cfg_handle,
corosync_cfg_shutdown_flags_t flags)
{
struct cfg_inst *cfg_inst;
struct req_lib_cfg_tryshutdown req_lib_cfg_tryshutdown;
struct res_lib_cfg_tryshutdown res_lib_cfg_tryshutdown;
cs_error_t error;
struct iovec iov;
error = hdb_error_to_cs(hdb_handle_get (&cfg_hdb, cfg_handle,
(void *)&cfg_inst));
if (error != CS_OK) {
return (error);
}
req_lib_cfg_tryshutdown.header.id = MESSAGE_REQ_CFG_TRYSHUTDOWN;
req_lib_cfg_tryshutdown.header.size = sizeof (struct req_lib_cfg_tryshutdown);
req_lib_cfg_tryshutdown.flags = flags;
iov.iov_base = (void *)&req_lib_cfg_tryshutdown;
iov.iov_len = sizeof (req_lib_cfg_tryshutdown);
error = qb_to_cs_error (qb_ipcc_sendv_recv (cfg_inst->c,
&iov,
1,
&res_lib_cfg_tryshutdown,
sizeof (struct res_lib_cfg_tryshutdown), CS_IPC_TIMEOUT_MS));
(void)hdb_handle_put (&cfg_hdb, cfg_handle);
return (error == CS_OK ? res_lib_cfg_tryshutdown.header.error : error);
}
cs_error_t
corosync_cfg_ring_reenable (
corosync_cfg_handle_t cfg_handle)
{
struct cfg_inst *cfg_inst;
struct req_lib_cfg_ringreenable req_lib_cfg_ringreenable;
struct res_lib_cfg_ringreenable res_lib_cfg_ringreenable;
cs_error_t error;
struct iovec iov;
error = hdb_error_to_cs(hdb_handle_get (&cfg_hdb, cfg_handle, (void *)&cfg_inst));
if (error != CS_OK) {
return (error);
}
req_lib_cfg_ringreenable.header.size = sizeof (struct req_lib_cfg_ringreenable);
req_lib_cfg_ringreenable.header.id = MESSAGE_REQ_CFG_RINGREENABLE;
iov.iov_base = (void *)&req_lib_cfg_ringreenable,
iov.iov_len = sizeof (struct req_lib_cfg_ringreenable);
error = qb_to_cs_error (qb_ipcc_sendv_recv (cfg_inst->c,
&iov,
1,
&res_lib_cfg_ringreenable,
sizeof (struct res_lib_cfg_ringreenable), CS_IPC_TIMEOUT_MS));
(void)hdb_handle_put (&cfg_hdb, cfg_handle);
return (error);
}
cs_error_t
corosync_cfg_finalize (
corosync_cfg_handle_t cfg_handle)
{
struct cfg_inst *cfg_inst;
cs_error_t error;
error = hdb_error_to_cs(hdb_handle_get (&cfg_hdb, cfg_handle, (void *)&cfg_inst));
if (error != CS_OK) {
return (error);
}
/*
* Another thread has already started finalizing
*/
if (cfg_inst->finalize) {
(void)hdb_handle_put (&cfg_hdb, cfg_handle);
return (CS_ERR_BAD_HANDLE);
}
cfg_inst->finalize = 1;
(void)hdb_handle_destroy (&cfg_hdb, cfg_handle);
(void)hdb_handle_put (&cfg_hdb, cfg_handle);
return (error);
}
SaAisErrorT
saAmfComponentErrorClear (
SaAmfHandleT amfHandle,
const SaNameT *compName,
SaNtfIdentifierT ntfIdentifier)
{
struct amfInstance *amfInstance;
struct req_lib_amf_componenterrorclear req_lib_amf_componenterrorclear;
struct res_lib_amf_componenterrorclear res_lib_amf_componenterrorclear;
struct iovec iov;
SaAisErrorT error;
error = hdb_error_to_sa(hdb_handle_get (&amfHandleDatabase, amfHandle,
(void *)&amfInstance));
if (error != SA_AIS_OK) {
return (error);
}
req_lib_amf_componenterrorclear.header.id = MESSAGE_REQ_AMF_COMPONENTERRORCLEAR;
req_lib_amf_componenterrorclear.header.size = sizeof (struct req_lib_amf_componenterrorclear);
memcpy (&req_lib_amf_componenterrorclear.compName, compName, sizeof (SaNameT));
iov.iov_base = (void *)&req_lib_amf_componenterrorclear;
iov.iov_len = sizeof (struct req_lib_amf_componenterrorclear);
error = coroipcc_msg_send_reply_receive (amfInstance->handle,
&iov,
1,
&res_lib_amf_componenterrorclear,
sizeof (struct res_lib_amf_componenterrorclear));
hdb_handle_put (&amfHandleDatabase, amfHandle);
return (error == SA_AIS_OK ? res_lib_amf_componenterrorclear.header.error : error);
}
static int object_destroy (
hdb_handle_t object_handle)
{
struct object_instance *instance;
unsigned int res;
objdb_rdlock();
res = hdb_handle_get (&object_instance_database,
object_handle, (void *)&instance);
if (res != 0) {
objdb_rdunlock();
return (res);
}
object_pre_deletion_notification(object_handle,
instance->parent_handle,
instance->object_name,
instance->object_name_len);
/* Recursively clear sub-objects & keys */
res = _clear_object(instance);
list_del(&instance->child_list);
free(instance->object_name);
hdb_handle_put (&object_instance_database, object_handle);
hdb_handle_destroy (&object_instance_database, object_handle);
objdb_rdunlock();
return (res);
}
unsigned int pload_finalize (
pload_handle_t handle)
{
struct pload_inst *pload_inst;
cs_error_t error;
error = hdb_error_to_cs (hdb_handle_get (&pload_handle_t_db, handle, (void *)&pload_inst));
if (error != CS_OK) {
return (error);
}
/*
* Another thread has already started finalizing
*/
if (pload_inst->finalize) {
(void)hdb_handle_put (&pload_handle_t_db, handle);
return (PLOAD_ERR_BAD_HANDLE);
}
pload_inst->finalize = 1;
qb_ipcc_disconnect(pload_inst->c);
(void)hdb_handle_destroy (&pload_handle_t_db, handle);
(void)hdb_handle_put (&pload_handle_t_db, handle);
return (PLOAD_OK);
}
static void object_created_notification(
hdb_handle_t object_handle,
hdb_handle_t parent_object_handle,
const void *name_pt, size_t name_len)
{
struct list_head * list;
struct object_instance * obj_pt;
struct object_tracker * tracker_pt;
hdb_handle_t obj_handle = object_handle;
unsigned int res;
do {
res = hdb_handle_get (&object_instance_database,
obj_handle, (void *)&obj_pt);
for (list = obj_pt->track_head.next;
list != &obj_pt->track_head; list = list->next) {
tracker_pt = list_entry (list, struct object_tracker, object_list);
if (((obj_handle == parent_object_handle) ||
(tracker_pt->depth == OBJECT_TRACK_DEPTH_RECURSIVE)) &&
(tracker_pt->object_create_notify_fn != NULL)) {
tracker_pt->object_create_notify_fn(object_handle,
parent_object_handle,
name_pt, name_len,
tracker_pt->data_pt);
}
}
hdb_handle_put (&object_instance_database, obj_handle);
obj_handle = obj_pt->parent_handle;
} while (obj_handle != OBJECT_PARENT_HANDLE);
}
static int object_priv_set (
hdb_handle_t object_handle,
void *priv)
{
int res;
struct object_instance *object_instance;
objdb_rdlock();
res = hdb_handle_get (&object_instance_database,
object_handle, (void *)&object_instance);
if (res != 0) {
goto error_exit;
}
object_instance->priv = priv;
hdb_handle_put (&object_instance_database, object_handle);
objdb_rdunlock();
return (0);
error_exit:
objdb_rdunlock();
return (-1);
}
static int object_key_iter_typed (hdb_handle_t parent_object_handle,
char **key_name,
void **value,
size_t *value_len,
objdb_value_types_t *type)
{
unsigned int res;
struct object_instance *instance;
struct object_key *find_key = NULL;
struct list_head *list;
unsigned int found = 0;
objdb_rdlock();
res = hdb_handle_get (&object_instance_database,
parent_object_handle, (void *)&instance);
if (res != 0) {
goto error_exit;
}
res = -ENOENT;
list = instance->iter_key_list->next;
if (list != &instance->key_head) {
find_key = list_entry (list, struct object_key, list);
found = 1;
}
/*
* Function implementations
*/
cs_error_t cmap_initialize (cmap_handle_t *handle)
{
cs_error_t error;
struct cmap_inst *cmap_inst;
error = hdb_error_to_cs(hdb_handle_create(&cmap_handle_t_db, sizeof(*cmap_inst), handle));
if (error != CS_OK) {
goto error_no_destroy;
}
error = hdb_error_to_cs(hdb_handle_get(&cmap_handle_t_db, *handle, (void *)&cmap_inst));
if (error != CS_OK) {
goto error_destroy;
}
error = CS_OK;
cmap_inst->finalize = 0;
cmap_inst->c = qb_ipcc_connect("cmap", IPC_REQUEST_SIZE);
if (cmap_inst->c == NULL) {
error = qb_to_cs_error(-errno);
goto error_put_destroy;
}
(void)hdb_handle_put(&cmap_handle_t_db, *handle);
return (CS_OK);
error_put_destroy:
(void)hdb_handle_put(&cmap_handle_t_db, *handle);
error_destroy:
(void)hdb_handle_destroy(&cmap_handle_t_db, *handle);
error_no_destroy:
return (error);
}
cs_error_t cmap_iter_next(
cmap_handle_t handle,
cmap_iter_handle_t iter_handle,
char key_name[],
size_t *value_len,
cmap_value_types_t *type)
{
cs_error_t error;
struct iovec iov;
struct cmap_inst *cmap_inst;
struct req_lib_cmap_iter_next req_lib_cmap_iter_next;
struct res_lib_cmap_iter_next res_lib_cmap_iter_next;
if (key_name == NULL) {
return (CS_ERR_INVALID_PARAM);
}
error = hdb_error_to_cs(hdb_handle_get (&cmap_handle_t_db, handle, (void *)&cmap_inst));
if (error != CS_OK) {
return (error);
}
memset(&req_lib_cmap_iter_next, 0, sizeof(req_lib_cmap_iter_next));
req_lib_cmap_iter_next.header.size = sizeof(req_lib_cmap_iter_next);
req_lib_cmap_iter_next.header.id = MESSAGE_REQ_CMAP_ITER_NEXT;
req_lib_cmap_iter_next.iter_handle = iter_handle;
iov.iov_base = (char *)&req_lib_cmap_iter_next;
iov.iov_len = sizeof(req_lib_cmap_iter_next);
error = qb_to_cs_error(qb_ipcc_sendv_recv(
cmap_inst->c,
&iov,
1,
&res_lib_cmap_iter_next,
sizeof (struct res_lib_cmap_iter_next), CS_IPC_TIMEOUT_MS));
if (error == CS_OK) {
error = res_lib_cmap_iter_next.header.error;
}
if (error == CS_OK) {
strncpy(key_name, (const char *)res_lib_cmap_iter_next.key_name.value, CMAP_KEYNAME_MAXLEN);
if (value_len != NULL) {
*value_len = res_lib_cmap_iter_next.value_len;
}
if (type != NULL) {
*type = res_lib_cmap_iter_next.type;
}
}
(void)hdb_handle_put (&cmap_handle_t_db, handle);
return (error);
}
cs_error_t cmap_set (
cmap_handle_t handle,
const char *key_name,
const void *value,
size_t value_len,
cmap_value_types_t type)
{
cs_error_t error;
struct iovec iov[2];
struct cmap_inst *cmap_inst;
struct req_lib_cmap_set req_lib_cmap_set;
struct res_lib_cmap_set res_lib_cmap_set;
if (key_name == NULL || value == NULL) {
return (CS_ERR_INVALID_PARAM);
}
if (strlen(key_name) >= CS_MAX_NAME_LENGTH) {
return (CS_ERR_NAME_TOO_LONG);
}
error = hdb_error_to_cs(hdb_handle_get (&cmap_handle_t_db, handle, (void *)&cmap_inst));
if (error != CS_OK) {
return (error);
}
memset(&req_lib_cmap_set, 0, sizeof(req_lib_cmap_set));
req_lib_cmap_set.header.size = sizeof(req_lib_cmap_set) + value_len;
req_lib_cmap_set.header.id = MESSAGE_REQ_CMAP_SET;
memcpy(req_lib_cmap_set.key_name.value, key_name, strlen(key_name));
req_lib_cmap_set.key_name.length = strlen(key_name);
req_lib_cmap_set.value_len = value_len;
req_lib_cmap_set.type = type;
iov[0].iov_base = (char *)&req_lib_cmap_set;
iov[0].iov_len = sizeof(req_lib_cmap_set);
iov[1].iov_base = (void *)value;
iov[1].iov_len = value_len;
error = qb_to_cs_error(qb_ipcc_sendv_recv(
cmap_inst->c,
iov,
2,
&res_lib_cmap_set,
sizeof (struct res_lib_cmap_set), CS_IPC_TIMEOUT_MS));
if (error == CS_OK) {
error = res_lib_cmap_set.header.error;
}
(void)hdb_handle_put (&cmap_handle_t_db, handle);
return (error);
}
cs_error_t cmap_iter_init(
cmap_handle_t handle,
const char *prefix,
cmap_iter_handle_t *cmap_iter_handle)
{
cs_error_t error;
struct iovec iov;
struct cmap_inst *cmap_inst;
struct req_lib_cmap_iter_init req_lib_cmap_iter_init;
struct res_lib_cmap_iter_init res_lib_cmap_iter_init;
if (cmap_iter_handle == NULL) {
return (CS_ERR_INVALID_PARAM);
}
error = hdb_error_to_cs(hdb_handle_get (&cmap_handle_t_db, handle, (void *)&cmap_inst));
if (error != CS_OK) {
return (error);
}
memset(&req_lib_cmap_iter_init, 0, sizeof(req_lib_cmap_iter_init));
req_lib_cmap_iter_init.header.size = sizeof(req_lib_cmap_iter_init);
req_lib_cmap_iter_init.header.id = MESSAGE_REQ_CMAP_ITER_INIT;
if (prefix) {
if (strlen(prefix) >= CS_MAX_NAME_LENGTH) {
return (CS_ERR_NAME_TOO_LONG);
}
memcpy(req_lib_cmap_iter_init.prefix.value, prefix, strlen(prefix));
req_lib_cmap_iter_init.prefix.length = strlen(prefix);
}
iov.iov_base = (char *)&req_lib_cmap_iter_init;
iov.iov_len = sizeof(req_lib_cmap_iter_init);
error = qb_to_cs_error(qb_ipcc_sendv_recv(
cmap_inst->c,
&iov,
1,
&res_lib_cmap_iter_init,
sizeof (struct res_lib_cmap_iter_init), CS_IPC_TIMEOUT_MS));
if (error == CS_OK) {
error = res_lib_cmap_iter_init.header.error;
}
if (error == CS_OK) {
*cmap_iter_handle = res_lib_cmap_iter_init.iter_handle;
}
(void)hdb_handle_put (&cmap_handle_t_db, handle);
return (error);
}
evs_error_t evs_membership_get (
evs_handle_t handle,
unsigned int *local_nodeid,
unsigned int *member_list,
size_t *member_list_entries)
{
evs_error_t error;
struct evs_inst *evs_inst;
struct iovec iov;
struct req_lib_evs_membership_get req_lib_evs_membership_get;
struct res_lib_evs_membership_get res_lib_evs_membership_get;
error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
if (error != CS_OK) {
return (error);
}
req_lib_evs_membership_get.header.size = sizeof (struct req_lib_evs_membership_get);
req_lib_evs_membership_get.header.id = MESSAGE_REQ_EVS_MEMBERSHIP_GET;
iov.iov_base = (void *)&req_lib_evs_membership_get;
iov.iov_len = sizeof (struct req_lib_evs_membership_get);
error = coroipcc_msg_send_reply_receive (evs_inst->handle,
&iov,
1,
&res_lib_evs_membership_get,
sizeof (struct res_lib_evs_membership_get));
if (error != CS_OK) {
goto error_exit;
}
error = res_lib_evs_membership_get.header.error;
/*
* Copy results to caller
*/
if (local_nodeid) {
*local_nodeid = res_lib_evs_membership_get.local_nodeid;
}
*member_list_entries = MIN (*member_list_entries,
res_lib_evs_membership_get.member_list_entries);
if (member_list) {
memcpy (member_list, &res_lib_evs_membership_get.member_list,
*member_list_entries * sizeof (struct in_addr));
}
error_exit:
hdb_handle_put (&evs_handle_t_db, handle);
return (error);
}
cs_error_t votequorum_getinfo (
votequorum_handle_t handle,
unsigned int nodeid,
struct votequorum_info *info)
{
cs_error_t error;
struct votequorum_inst *votequorum_inst;
struct iovec iov;
struct req_lib_votequorum_getinfo req_lib_votequorum_getinfo;
struct res_lib_votequorum_getinfo res_lib_votequorum_getinfo;
error = hdb_error_to_cs(hdb_handle_get (&votequorum_handle_t_db, handle, (void *)&votequorum_inst));
if (error != CS_OK) {
return (error);
}
req_lib_votequorum_getinfo.header.size = sizeof (struct req_lib_votequorum_getinfo);
req_lib_votequorum_getinfo.header.id = MESSAGE_REQ_VOTEQUORUM_GETINFO;
req_lib_votequorum_getinfo.nodeid = nodeid;
iov.iov_base = (char *)&req_lib_votequorum_getinfo;
iov.iov_len = sizeof (struct req_lib_votequorum_getinfo);
error = qb_to_cs_error(qb_ipcc_sendv_recv (
votequorum_inst->c,
&iov,
1,
&res_lib_votequorum_getinfo,
sizeof (struct res_lib_votequorum_getinfo), CS_IPC_TIMEOUT_MS));
if (error != CS_OK) {
goto error_exit;
}
error = res_lib_votequorum_getinfo.header.error;
info->node_id = res_lib_votequorum_getinfo.nodeid;
info->node_state = res_lib_votequorum_getinfo.state;
info->node_votes = res_lib_votequorum_getinfo.votes;
info->node_expected_votes = res_lib_votequorum_getinfo.expected_votes;
info->highest_expected = res_lib_votequorum_getinfo.highest_expected;
info->total_votes = res_lib_votequorum_getinfo.total_votes;
info->quorum = res_lib_votequorum_getinfo.quorum;
info->flags = res_lib_votequorum_getinfo.flags;
info->qdevice_votes = res_lib_votequorum_getinfo.qdevice_votes;
memset(info->qdevice_name, 0, VOTEQUORUM_QDEVICE_MAX_NAME_LEN);
strcpy(info->qdevice_name, res_lib_votequorum_getinfo.qdevice_name);
error_exit:
hdb_handle_put (&votequorum_handle_t_db, handle);
return (error);
}
