diff --git a/exec/icmap.c b/exec/icmap.c index d51a972d..2743959d 100644 --- a/exec/icmap.c +++ b/exec/icmap.c @@ -1,960 +1,1007 @@ /* * Copyright (c) 2011 Red Hat, Inc. * * All rights reserved. * * Author: Jan Friesse (jfriesse@redhat.com) * * This software licensed under BSD license, the text of which follows: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name of the Red Hat, Inc. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #define ICMAP_MAX_VALUE_LEN (16*1024) struct icmap_item { char *key_name; icmap_value_types_t type; size_t value_len; char value[]; }; static qb_map_t *icmap_map; struct icmap_track { char *key_name; int32_t track_type; icmap_notify_fn_t notify_fn; void *user_data; + struct list_head list; }; struct icmap_ro_access_item { char *key_name; int prefix; struct list_head list; }; DECLARE_LIST_INIT(icmap_ro_access_item_list_head); +DECLARE_LIST_INIT(icmap_track_list_head); /* * Static functions declarations */ /* * Check if key_name is valid icmap key name. Returns 0 on success, and -1 on fail */ static int icmap_check_key_name(const char *key_name); /* * Check that value with given type has correct length value_len. Returns 0 on success, * and -1 on fail */ static int icmap_check_value_len(const void *value, size_t value_len, icmap_value_types_t type); /* * Returns length of value of given type, or 0 for string and binary data type */ static size_t icmap_get_valuetype_len(icmap_value_types_t type); /* * Converts track type of icmap to qb */ static int32_t icmap_tt_to_qbtt(int32_t track_type); /* * Convert track type of qb to icmap */ static int32_t icmap_qbtt_to_tt(int32_t track_type); /* * Checks if item has same value as value with value_len and given type. Returns 0 if not, otherwise !0. */ static int icmap_item_eq(const struct icmap_item *item, const void *value, size_t value_len, icmap_value_types_t type); /* * Checks if given character is valid in key name. Returns 0 if not, otherwise !0. */ static int icmap_is_valid_name_char(char c); /* * Helper for getting integer and float value with given type for key key_name and store it in value. */ static cs_error_t icmap_get_int( const char *key_name, void *value, icmap_value_types_t type); /* * Function implementation */ static int32_t icmap_tt_to_qbtt(int32_t track_type) { int32_t res = 0; if (track_type & ICMAP_TRACK_DELETE) { res |= QB_MAP_NOTIFY_DELETED; } if (track_type & ICMAP_TRACK_MODIFY) { res |= QB_MAP_NOTIFY_REPLACED; } if (track_type & ICMAP_TRACK_ADD) { res |= QB_MAP_NOTIFY_INSERTED; } if (track_type & ICMAP_TRACK_PREFIX) { res |= QB_MAP_NOTIFY_RECURSIVE; } return (track_type); } static int32_t icmap_qbtt_to_tt(int32_t track_type) { int32_t res = 0; if (track_type & QB_MAP_NOTIFY_DELETED) { res |= ICMAP_TRACK_DELETE; } if (track_type & QB_MAP_NOTIFY_REPLACED) { res |= ICMAP_TRACK_MODIFY; } if (track_type & QB_MAP_NOTIFY_INSERTED) { res |= ICMAP_TRACK_ADD; } if (track_type & QB_MAP_NOTIFY_RECURSIVE) { res |= ICMAP_TRACK_PREFIX; } return (track_type); } static void icmap_map_free_cb(uint32_t event, char* key, void* old_value, void* value, void* user_data) { struct icmap_item *item = (struct icmap_item *)old_value; /* * value == old_value -> fast_adjust_int was used, don't free data */ if (item != NULL && value != old_value) { free(item->key_name); free(item); } } cs_error_t icmap_init(void) { int32_t err; icmap_map = qb_trie_create(); if (icmap_map == NULL) return (CS_ERR_INIT); err = qb_map_notify_add(icmap_map, NULL, icmap_map_free_cb, QB_MAP_NOTIFY_FREE, NULL); return (qb_to_cs_error(err)); } +static void icmap_set_ro_access_free(void) +{ + struct list_head *iter = icmap_ro_access_item_list_head.next; + struct icmap_ro_access_item *icmap_ro_ai; + + while (iter != &icmap_ro_access_item_list_head) { + icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list); + list_del(&icmap_ro_ai->list); + free(icmap_ro_ai->key_name); + free(icmap_ro_ai); + iter = icmap_ro_access_item_list_head.next; + } +} + +static void icmap_del_all_track(void) +{ + struct list_head *iter = icmap_track_list_head.next; + struct icmap_track *icmap_track; + + while (iter != &icmap_track_list_head) { + icmap_track = list_entry(iter, struct icmap_track, list); + icmap_track_delete(icmap_track); + iter = icmap_track_list_head.next; + } +} + +void icmap_fini(void) +{ + icmap_del_all_track(); + /* + * catch 22 warning: + * We need to drop this notify but we can't because it calls icmap_map_free_cb + * while destroying the tree to free icmap_item(s). + * -> qb_map_notify_del_2(icmap_map, NULL, icmap_map_free_cb, QB_MAP_NOTIFY_FREE, NULL); + * and we cannot call it after map_destroy. joy! :) + */ + qb_map_destroy(icmap_map); + icmap_set_ro_access_free(); + return; +} + static int icmap_is_valid_name_char(char c) { return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '.' || c == '_' || c == '-' || c == '/' || c == ':'); } void icmap_convert_name_to_valid_name(char *key_name) { int i; for (i = 0; i < strlen(key_name); i++) { if (!icmap_is_valid_name_char(key_name[i])) { key_name[i] = '_'; } } } static int icmap_check_key_name(const char *key_name) { int i; if ((strlen(key_name) < ICMAP_KEYNAME_MINLEN) || strlen(key_name) > ICMAP_KEYNAME_MAXLEN) { return (-1); } for (i = 0; i < strlen(key_name); i++) { if (!icmap_is_valid_name_char(key_name[i])) { return (-1); } } return (0); } static size_t icmap_get_valuetype_len(icmap_value_types_t type) { size_t res = 0; switch (type) { case ICMAP_VALUETYPE_INT8: res = sizeof(int8_t); break; case ICMAP_VALUETYPE_UINT8: res = sizeof(uint8_t); break; case ICMAP_VALUETYPE_INT16: res = sizeof(int16_t); break; case ICMAP_VALUETYPE_UINT16: res = sizeof(uint16_t); break; case ICMAP_VALUETYPE_INT32: res = sizeof(int32_t); break; case ICMAP_VALUETYPE_UINT32: res = sizeof(uint32_t); break; case ICMAP_VALUETYPE_INT64: res = sizeof(int64_t); break; case ICMAP_VALUETYPE_UINT64: res = sizeof(uint64_t); break; case ICMAP_VALUETYPE_FLOAT: res = sizeof(float); break; case ICMAP_VALUETYPE_DOUBLE: res = sizeof(double); break; case ICMAP_VALUETYPE_STRING: case ICMAP_VALUETYPE_BINARY: res = 0; break; } return (res); } static int icmap_check_value_len(const void *value, size_t value_len, icmap_value_types_t type) { if (value_len > ICMAP_MAX_VALUE_LEN) { return (-1); } if (type != ICMAP_VALUETYPE_STRING && type != ICMAP_VALUETYPE_BINARY) { if (icmap_get_valuetype_len(type) == value_len) { return (0); } else { return (-1); } } if (type == ICMAP_VALUETYPE_STRING) { if (value_len > strlen((const char *)value)) { return (-1); } else { return (0); } } return (0); } static int icmap_item_eq(const struct icmap_item *item, const void *value, size_t value_len, icmap_value_types_t type) { size_t ptr_len; if (item->type != type) { return (0); } if (item->type == ICMAP_VALUETYPE_STRING) { ptr_len = strlen((const char *)value); if (ptr_len > value_len) { ptr_len = value_len; } ptr_len++; } else { ptr_len = value_len; } if (item->value_len == ptr_len) { return (memcmp(item->value, value, value_len) == 0); }; return (0); } cs_error_t icmap_set( const char *key_name, const void *value, size_t value_len, icmap_value_types_t type) { struct icmap_item *item; struct icmap_item *new_item; size_t new_value_len; size_t new_item_size; if (value == NULL || key_name == NULL) { return (CS_ERR_INVALID_PARAM); } if (icmap_check_value_len(value, value_len, type) != 0) { return (CS_ERR_INVALID_PARAM); } item = qb_map_get(icmap_map, key_name); if (item != NULL) { /* * Check that key is really changed */ if (icmap_item_eq(item, value, value_len, type)) { return (CS_OK); } } else { if (icmap_check_key_name(key_name) != 0) { return (CS_ERR_NAME_TOO_LONG); } } if (type == ICMAP_VALUETYPE_BINARY || type == ICMAP_VALUETYPE_STRING) { if (type == ICMAP_VALUETYPE_STRING) { new_value_len = strlen((const char *)value); if (new_value_len > value_len) { new_value_len = value_len; } new_value_len++; } else { new_value_len = value_len; } } else { new_value_len = icmap_get_valuetype_len(type); } new_item_size = sizeof(struct icmap_item) + new_value_len; new_item = malloc(new_item_size); if (new_item == NULL) { return (CS_ERR_NO_MEMORY); } memset(new_item, 0, new_item_size); if (item == NULL) { new_item->key_name = strdup(key_name); if (new_item->key_name == NULL) { free(new_item); return (CS_ERR_NO_MEMORY); } } else { new_item->key_name = item->key_name; item->key_name = NULL; } new_item->type = type; new_item->value_len = new_value_len; memcpy(new_item->value, value, new_value_len); if (new_item->type == ICMAP_VALUETYPE_STRING) { ((char *)new_item->value)[new_value_len - 1] = 0; } qb_map_put(icmap_map, new_item->key_name, new_item); return (CS_OK); } cs_error_t icmap_set_int8(const char *key_name, int8_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT8)); } cs_error_t icmap_set_uint8(const char *key_name, uint8_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT8)); } cs_error_t icmap_set_int16(const char *key_name, int16_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT16)); } cs_error_t icmap_set_uint16(const char *key_name, uint16_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT16)); } cs_error_t icmap_set_int32(const char *key_name, int32_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT32)); } cs_error_t icmap_set_uint32(const char *key_name, uint32_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT32)); } cs_error_t icmap_set_int64(const char *key_name, int64_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_INT64)); } cs_error_t icmap_set_uint64(const char *key_name, uint64_t value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_UINT64)); } cs_error_t icmap_set_float(const char *key_name, float value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_FLOAT)); } cs_error_t icmap_set_double(const char *key_name, double value) { return (icmap_set(key_name, &value, sizeof(value), ICMAP_VALUETYPE_DOUBLE)); } cs_error_t icmap_set_string(const char *key_name, const char *value) { if (value == NULL) { return (CS_ERR_INVALID_PARAM); } return (icmap_set(key_name, value, strlen(value), ICMAP_VALUETYPE_STRING)); } cs_error_t icmap_delete(const char *key_name) { struct icmap_item *item; if (key_name == NULL) { return (CS_ERR_INVALID_PARAM); } item = qb_map_get(icmap_map, key_name); if (item == NULL) { return (CS_ERR_NOT_EXIST); } if (qb_map_rm(icmap_map, item->key_name) != QB_TRUE) { return (CS_ERR_NOT_EXIST); } return (CS_OK); } cs_error_t icmap_get( const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type) { struct icmap_item *item; if (key_name == NULL) { return (CS_ERR_INVALID_PARAM); } item = qb_map_get(icmap_map, key_name); if (item == NULL) { return (CS_ERR_NOT_EXIST); } if (type != NULL) { *type = item->type; } if (value == NULL) { if (value_len != NULL) { *value_len = item->value_len; } } else { if (value_len == NULL || *value_len < item->value_len) { return (CS_ERR_INVALID_PARAM); } *value_len = item->value_len; memcpy(value, item->value, item->value_len); } return (CS_OK); } static cs_error_t icmap_get_int( const char *key_name, void *value, icmap_value_types_t type) { char key_value[16]; size_t key_size; cs_error_t err; icmap_value_types_t key_type; key_size = sizeof(key_value); memset(key_value, 0, key_size); err = icmap_get(key_name, key_value, &key_size, &key_type); if (err != CS_OK) return (err); if (key_type != type) { return (CS_ERR_INVALID_PARAM); } memcpy(value, key_value, icmap_get_valuetype_len(key_type)); return (CS_OK); } cs_error_t icmap_get_int8(const char *key_name, int8_t *i8) { return (icmap_get_int(key_name, i8, ICMAP_VALUETYPE_INT8)); } cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8) { return (icmap_get_int(key_name, u8, ICMAP_VALUETYPE_UINT8)); } cs_error_t icmap_get_int16(const char *key_name, int16_t *i16) { return (icmap_get_int(key_name, i16, ICMAP_VALUETYPE_INT16)); } cs_error_t icmap_get_uint16(const char *key_name, uint16_t *u16) { return (icmap_get_int(key_name, u16, ICMAP_VALUETYPE_UINT16)); } cs_error_t icmap_get_int32(const char *key_name, int32_t *i32) { return (icmap_get_int(key_name, i32, ICMAP_VALUETYPE_INT32)); } cs_error_t icmap_get_uint32(const char *key_name, uint32_t *u32) { return (icmap_get_int(key_name, u32, ICMAP_VALUETYPE_UINT32)); } cs_error_t icmap_get_int64(const char *key_name, int64_t *i64) { return(icmap_get_int(key_name, i64, ICMAP_VALUETYPE_INT64)); } cs_error_t icmap_get_uint64(const char *key_name, uint64_t *u64) { return (icmap_get_int(key_name, u64, ICMAP_VALUETYPE_UINT64)); } cs_error_t icmap_get_float(const char *key_name, float *flt) { return (icmap_get_int(key_name, flt, ICMAP_VALUETYPE_FLOAT)); } cs_error_t icmap_get_double(const char *key_name, double *dbl) { return (icmap_get_int(key_name, dbl, ICMAP_VALUETYPE_DOUBLE)); } cs_error_t icmap_get_string(const char *key_name, char **str) { cs_error_t res; size_t str_len; icmap_value_types_t type; res = icmap_get(key_name, NULL, &str_len, &type); if (res != CS_OK || type != ICMAP_VALUETYPE_STRING) { if (res == CS_OK) { res = CS_ERR_INVALID_PARAM; } goto return_error; } *str = malloc(str_len); if (*str == NULL) { res = CS_ERR_NO_MEMORY; goto return_error; } res = icmap_get(key_name, *str, &str_len, &type); if (res != CS_OK) { free(*str); goto return_error; } return (CS_OK); return_error: return (res); } cs_error_t icmap_adjust_int( const char *key_name, int32_t step) { struct icmap_item *item; uint8_t u8; uint16_t u16; uint32_t u32; uint64_t u64; cs_error_t err = CS_OK; if (key_name == NULL) { return (CS_ERR_INVALID_PARAM); } item = qb_map_get(icmap_map, key_name); if (item == NULL) { return (CS_ERR_NOT_EXIST); } switch (item->type) { case ICMAP_VALUETYPE_INT8: case ICMAP_VALUETYPE_UINT8: memcpy(&u8, item->value, sizeof(u8)); u8 += step; err = icmap_set(key_name, &u8, sizeof(u8), item->type); break; case ICMAP_VALUETYPE_INT16: case ICMAP_VALUETYPE_UINT16: memcpy(&u16, item->value, sizeof(u16)); u16 += step; err = icmap_set(key_name, &u16, sizeof(u16), item->type); break; case ICMAP_VALUETYPE_INT32: case ICMAP_VALUETYPE_UINT32: memcpy(&u32, item->value, sizeof(u32)); u32 += step; err = icmap_set(key_name, &u32, sizeof(u32), item->type); break; case ICMAP_VALUETYPE_INT64: case ICMAP_VALUETYPE_UINT64: memcpy(&u64, item->value, sizeof(u64)); u64 += step; err = icmap_set(key_name, &u64, sizeof(u64), item->type); break; case ICMAP_VALUETYPE_FLOAT: case ICMAP_VALUETYPE_DOUBLE: case ICMAP_VALUETYPE_STRING: case ICMAP_VALUETYPE_BINARY: err = CS_ERR_INVALID_PARAM; break; } return (err); } cs_error_t icmap_fast_adjust_int( const char *key_name, int32_t step) { struct icmap_item *item; cs_error_t err = CS_OK; if (key_name == NULL) { return (CS_ERR_INVALID_PARAM); } item = qb_map_get(icmap_map, key_name); if (item == NULL) { return (CS_ERR_NOT_EXIST); } switch (item->type) { case ICMAP_VALUETYPE_INT8: case ICMAP_VALUETYPE_UINT8: *(uint8_t *)item->value += step; break; case ICMAP_VALUETYPE_INT16: case ICMAP_VALUETYPE_UINT16: *(uint16_t *)item->value += step; break; case ICMAP_VALUETYPE_INT32: case ICMAP_VALUETYPE_UINT32: *(uint32_t *)item->value += step; break; case ICMAP_VALUETYPE_INT64: case ICMAP_VALUETYPE_UINT64: *(uint64_t *)item->value += step; break; case ICMAP_VALUETYPE_FLOAT: case ICMAP_VALUETYPE_DOUBLE: case ICMAP_VALUETYPE_STRING: case ICMAP_VALUETYPE_BINARY: err = CS_ERR_INVALID_PARAM; break; } if (err == CS_OK) { qb_map_put(icmap_map, item->key_name, item); } return (err); } cs_error_t icmap_inc(const char *key_name) { return (icmap_adjust_int(key_name, 1)); } cs_error_t icmap_dec(const char *key_name) { return (icmap_adjust_int(key_name, -1)); } cs_error_t icmap_fast_inc(const char *key_name) { return (icmap_fast_adjust_int(key_name, 1)); } cs_error_t icmap_fast_dec(const char *key_name) { return (icmap_fast_adjust_int(key_name, -1)); } icmap_iter_t icmap_iter_init(const char *prefix) { return (qb_map_pref_iter_create(icmap_map, prefix)); } const char *icmap_iter_next(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type) { struct icmap_item *item; const char *res; res = qb_map_iter_next(iter, (void **)&item); if (res == NULL) { return (res); } if (value_len != NULL) { *value_len = item->value_len; } if (type != NULL) { *type = item->type; } return (res); } void icmap_iter_finalize(icmap_iter_t iter) { qb_map_iter_free(iter); } static void icmap_notify_fn(uint32_t event, char *key, void *old_value, void *value, void *user_data) { icmap_track_t icmap_track = (icmap_track_t)user_data; struct icmap_item *new_item = (struct icmap_item *)value; struct icmap_item *old_item = (struct icmap_item *)old_value; struct icmap_notify_value new_val; struct icmap_notify_value old_val; if (value == NULL && old_value == NULL) { return ; } if (new_item != NULL) { new_val.type = new_item->type; new_val.len = new_item->value_len; new_val.data = new_item->value; } else { memset(&new_val, 0, sizeof(new_val)); } /* * old_item == new_item if fast functions are used -> don't fill old value */ if (old_item != NULL && old_item != new_item) { old_val.type = old_item->type; old_val.len = old_item->value_len; old_val.data = old_item->value; } else { memset(&old_val, 0, sizeof(old_val)); } icmap_track->notify_fn(icmap_qbtt_to_tt(event), key, new_val, old_val, icmap_track->user_data); } 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) { int32_t err; if (notify_fn == NULL || icmap_track == NULL) { return (CS_ERR_INVALID_PARAM); } if ((track_type & ~(ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX)) != 0) { return (CS_ERR_INVALID_PARAM); } *icmap_track = malloc(sizeof(**icmap_track)); if (*icmap_track == NULL) { return (CS_ERR_NO_MEMORY); } memset(*icmap_track, 0, sizeof(**icmap_track)); if (key_name != NULL) { (*icmap_track)->key_name = strdup(key_name); }; (*icmap_track)->track_type = track_type; (*icmap_track)->notify_fn = notify_fn; (*icmap_track)->user_data = user_data; if ((err = qb_map_notify_add(icmap_map, (*icmap_track)->key_name, icmap_notify_fn, icmap_tt_to_qbtt(track_type), *icmap_track)) != 0) { free((*icmap_track)->key_name); free(*icmap_track); return (qb_to_cs_error(err)); } + list_init(&(*icmap_track)->list); + list_add (&(*icmap_track)->list, &icmap_track_list_head); + return (CS_OK); } cs_error_t icmap_track_delete(icmap_track_t icmap_track) { int32_t err; if ((err = qb_map_notify_del_2(icmap_map, icmap_track->key_name, icmap_notify_fn, icmap_tt_to_qbtt(icmap_track->track_type), icmap_track)) != 0) { return (qb_to_cs_error(err)); } + list_del(&icmap_track->list); free(icmap_track->key_name); free(icmap_track); return (CS_OK); } void *icmap_track_get_user_data(icmap_track_t icmap_track) { return (icmap_track->user_data); } cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access) { struct list_head *iter; struct icmap_ro_access_item *icmap_ro_ai; for (iter = icmap_ro_access_item_list_head.next; iter != &icmap_ro_access_item_list_head; iter = iter->next) { icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list); if (icmap_ro_ai->prefix == prefix && strcmp(key_name, icmap_ro_ai->key_name) == 0) { /* * We found item */ if (ro_access) { return (CS_ERR_EXIST); } else { list_del(&icmap_ro_ai->list); free(icmap_ro_ai); return (CS_OK); } } } if (!ro_access) { return (CS_ERR_NOT_EXIST); } icmap_ro_ai = malloc(sizeof(*icmap_ro_ai)); if (icmap_ro_ai == NULL) { return (CS_ERR_NO_MEMORY); } memset(icmap_ro_ai, 0, sizeof(*icmap_ro_ai)); icmap_ro_ai->key_name = strdup(key_name); if (icmap_ro_ai->key_name == NULL) { free(icmap_ro_ai); return (CS_ERR_NO_MEMORY); } icmap_ro_ai->prefix = prefix; list_init(&icmap_ro_ai->list); list_add (&icmap_ro_ai->list, &icmap_ro_access_item_list_head); return (CS_OK); } int icmap_is_key_ro(const char *key_name) { struct list_head *iter; struct icmap_ro_access_item *icmap_ro_ai; for (iter = icmap_ro_access_item_list_head.next; iter != &icmap_ro_access_item_list_head; iter = iter->next) { icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list); if (icmap_ro_ai->prefix) { if (strlen(icmap_ro_ai->key_name) > strlen(key_name)) continue; if (strncmp(icmap_ro_ai->key_name, key_name, strlen(icmap_ro_ai->key_name)) == 0) { return (CS_TRUE); } } else { if (strcmp(icmap_ro_ai->key_name, key_name) == 0) { return (CS_TRUE); } } } return (CS_FALSE); } diff --git a/exec/main.c b/exec/main.c index 2f3d242d..a125bbdf 100644 --- a/exec/main.c +++ b/exec/main.c @@ -1,1231 +1,1232 @@ /* * Copyright (c) 2002-2006 MontaVista Software, Inc. * Copyright (c) 2006-2012 Red Hat, Inc. * * All rights reserved. * * Author: Steven Dake (sdake@redhat.com) * * This software licensed under BSD license, the text of which follows: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name of the MontaVista Software, Inc. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ /** * \mainpage Corosync * * This is the doxygen generated developer documentation for the Corosync * project. For more information about Corosync, please see the project * web site, corosync.org. * * \section license License * * This software licensed under BSD license, the text of which follows: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name of the MontaVista Software, Inc. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "quorum.h" #include "totemsrp.h" #include "mainconfig.h" #include "totemconfig.h" #include "main.h" #include "sync.h" #include "timer.h" #include "util.h" #include "apidef.h" #include "service.h" #include "schedwrk.h" #ifdef HAVE_SMALL_MEMORY_FOOTPRINT #define IPC_LOGSYS_SIZE 1024*64 #else #define IPC_LOGSYS_SIZE 8192*128 #endif LOGSYS_DECLARE_SYSTEM ("corosync", LOGSYS_MODE_OUTPUT_STDERR, LOG_DAEMON, LOG_INFO); LOGSYS_DECLARE_SUBSYS ("MAIN"); #define SERVER_BACKLOG 5 static int sched_priority = 0; static unsigned int service_count = 32; static struct totem_logging_configuration totem_logging_configuration; static struct corosync_api_v1 *api = NULL; static int sync_in_process = 1; static qb_loop_t *corosync_poll_handle; struct sched_param global_sched_param; static corosync_timer_handle_t corosync_stats_timer_handle; static const char *corosync_lock_file = LOCALSTATEDIR"/run/corosync.pid"; qb_loop_t *cs_poll_handle_get (void) { return (corosync_poll_handle); } int cs_poll_dispatch_add (qb_loop_t * handle, int fd, int events, void *data, int (*dispatch_fn) (int fd, int revents, void *data)) { return qb_loop_poll_add(handle, QB_LOOP_MED, fd, events, data, dispatch_fn); } int cs_poll_dispatch_delete(qb_loop_t * handle, int fd) { return qb_loop_poll_del(handle, fd); } void corosync_state_dump (void) { int i; for (i = 0; i < SERVICE_HANDLER_MAXIMUM_COUNT; i++) { if (corosync_service[i] && corosync_service[i]->exec_dump_fn) { corosync_service[i]->exec_dump_fn (); } } } static void unlink_all_completed (void) { api->timer_delete (corosync_stats_timer_handle); qb_loop_stop (corosync_poll_handle); + icmap_fini(); } void corosync_shutdown_request (void) { corosync_service_unlink_all (api, unlink_all_completed); } static int32_t sig_diag_handler (int num, void *data) { corosync_state_dump (); qb_log_blackbox_write_to_file(LOCALSTATEDIR "/lib/corosync/fdata"); return 0; } static int32_t sig_exit_handler (int num, void *data) { corosync_service_unlink_all (api, unlink_all_completed); return 0; } static void sigsegv_handler (int num) { (void)signal (SIGSEGV, SIG_DFL); qb_log_blackbox_write_to_file(LOCALSTATEDIR "/lib/corosync/fdata"); qb_log_fini(); raise (SIGSEGV); } static void sigabrt_handler (int num) { (void)signal (SIGABRT, SIG_DFL); qb_log_blackbox_write_to_file(LOCALSTATEDIR "/lib/corosync/fdata"); qb_log_fini(); raise (SIGABRT); } #define LOCALHOST_IP inet_addr("127.0.0.1") static void *corosync_group_handle; static struct totempg_group corosync_group = { .group = "a", .group_len = 1 }; static void serialize_lock (void) { } static void serialize_unlock (void) { } static void corosync_sync_completed (void) { log_printf (LOGSYS_LEVEL_NOTICE, "Completed service synchronization, ready to provide service."); sync_in_process = 0; cs_ipcs_sync_state_changed(sync_in_process); cs_ipc_allow_connections(1); } static int corosync_sync_callbacks_retrieve ( int service_id, struct sync_callbacks *callbacks) { if (corosync_service[service_id] == NULL) { return (-1); } callbacks->name = corosync_service[service_id]->name; callbacks->sync_init = corosync_service[service_id]->sync_init; callbacks->sync_process = corosync_service[service_id]->sync_process; callbacks->sync_activate = corosync_service[service_id]->sync_activate; callbacks->sync_abort = corosync_service[service_id]->sync_abort; return (0); } static struct memb_ring_id corosync_ring_id; static void member_object_joined (unsigned int nodeid) { char member_ip[ICMAP_KEYNAME_MAXLEN]; char member_join_count[ICMAP_KEYNAME_MAXLEN]; char member_status[ICMAP_KEYNAME_MAXLEN]; snprintf(member_ip, ICMAP_KEYNAME_MAXLEN, "runtime.totem.pg.mrp.srp.members.%u.ip", nodeid); snprintf(member_join_count, ICMAP_KEYNAME_MAXLEN, "runtime.totem.pg.mrp.srp.members.%u.join_count", nodeid); snprintf(member_status, ICMAP_KEYNAME_MAXLEN, "runtime.totem.pg.mrp.srp.members.%u.status", nodeid); if (icmap_get(member_ip, NULL, NULL, NULL) == CS_OK) { icmap_inc(member_join_count); icmap_set_string(member_status, "joined"); } else { icmap_set_string(member_ip, (char*)api->totem_ifaces_print (nodeid)); icmap_set_uint32(member_join_count, 1); icmap_set_string(member_status, "joined"); } log_printf (LOGSYS_LEVEL_DEBUG, "Member joined: %s", api->totem_ifaces_print (nodeid)); } static void member_object_left (unsigned int nodeid) { char member_status[ICMAP_KEYNAME_MAXLEN]; snprintf(member_status, ICMAP_KEYNAME_MAXLEN, "runtime.totem.pg.mrp.srp.members.%u.status", nodeid); icmap_set_string(member_status, "left"); log_printf (LOGSYS_LEVEL_DEBUG, "Member left: %s", api->totem_ifaces_print (nodeid)); } static void confchg_fn ( enum totem_configuration_type configuration_type, const unsigned int *member_list, size_t member_list_entries, const unsigned int *left_list, size_t left_list_entries, const unsigned int *joined_list, size_t joined_list_entries, const struct memb_ring_id *ring_id) { int i; int abort_activate = 0; if (sync_in_process == 1) { abort_activate = 1; } sync_in_process = 1; cs_ipcs_sync_state_changed(sync_in_process); memcpy (&corosync_ring_id, ring_id, sizeof (struct memb_ring_id)); for (i = 0; i < left_list_entries; i++) { member_object_left (left_list[i]); } for (i = 0; i < joined_list_entries; i++) { member_object_joined (joined_list[i]); } /* * Call configuration change for all services */ for (i = 0; i < service_count; i++) { if (corosync_service[i] && corosync_service[i]->confchg_fn) { corosync_service[i]->confchg_fn (configuration_type, member_list, member_list_entries, left_list, left_list_entries, joined_list, joined_list_entries, ring_id); } } if (abort_activate) { sync_abort (); } if (configuration_type == TOTEM_CONFIGURATION_TRANSITIONAL) { sync_save_transitional (member_list, member_list_entries, ring_id); } if (configuration_type == TOTEM_CONFIGURATION_REGULAR) { sync_start (member_list, member_list_entries, ring_id); } } static void priv_drop (void) { return; /* TODO: we are still not dropping privs */ } static void corosync_tty_detach (void) { FILE *r; /* * Disconnect from TTY if this is not a debug run */ switch (fork ()) { case -1: corosync_exit_error (COROSYNC_DONE_FORK); break; case 0: /* * child which is disconnected, run this process */ break; default: exit (0); break; } /* Create new session */ (void)setsid(); /* * Map stdin/out/err to /dev/null. */ r = freopen("/dev/null", "r", stdin); if (r == NULL) { corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR); } r = freopen("/dev/null", "a", stderr); if (r == NULL) { corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR); } r = freopen("/dev/null", "a", stdout); if (r == NULL) { corosync_exit_error (COROSYNC_DONE_STD_TO_NULL_REDIR); } } static void corosync_mlockall (void) { #if !defined(COROSYNC_BSD) || defined(COROSYNC_FREEBSD_GE_8) int res; #endif struct rlimit rlimit; rlimit.rlim_cur = RLIM_INFINITY; rlimit.rlim_max = RLIM_INFINITY; #ifndef COROSYNC_SOLARIS setrlimit (RLIMIT_MEMLOCK, &rlimit); #else setrlimit (RLIMIT_VMEM, &rlimit); #endif #if defined(COROSYNC_BSD) && !defined(COROSYNC_FREEBSD_GE_8) /* under FreeBSD < 8 a process with locked page cannot call dlopen * code disabled until FreeBSD bug i386/93396 was solved */ log_printf (LOGSYS_LEVEL_WARNING, "Could not lock memory of service to avoid page faults"); #else res = mlockall (MCL_CURRENT | MCL_FUTURE); if (res == -1) { LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING, "Could not lock memory of service to avoid page faults"); }; #endif } static void corosync_totem_stats_updater (void *data) { totempg_stats_t * stats; uint32_t total_mtt_rx_token; uint32_t total_backlog_calc; uint32_t total_token_holdtime; int t, prev, i; int32_t token_count; char key_name[ICMAP_KEYNAME_MAXLEN]; stats = api->totem_get_stats(); icmap_set_uint32("runtime.totem.pg.msg_reserved", stats->msg_reserved); icmap_set_uint32("runtime.totem.pg.msg_queue_avail", stats->msg_queue_avail); icmap_set_uint64("runtime.totem.pg.mrp.srp.orf_token_tx", stats->mrp->srp->orf_token_tx); icmap_set_uint64("runtime.totem.pg.mrp.srp.orf_token_rx", stats->mrp->srp->orf_token_rx); icmap_set_uint64("runtime.totem.pg.mrp.srp.memb_merge_detect_tx", stats->mrp->srp->memb_merge_detect_tx); icmap_set_uint64("runtime.totem.pg.mrp.srp.memb_merge_detect_rx", stats->mrp->srp->memb_merge_detect_rx); icmap_set_uint64("runtime.totem.pg.mrp.srp.memb_join_tx", stats->mrp->srp->memb_join_tx); icmap_set_uint64("runtime.totem.pg.mrp.srp.memb_join_rx", stats->mrp->srp->memb_join_rx); icmap_set_uint64("runtime.totem.pg.mrp.srp.mcast_tx", stats->mrp->srp->mcast_tx); icmap_set_uint64("runtime.totem.pg.mrp.srp.mcast_retx", stats->mrp->srp->mcast_retx); icmap_set_uint64("runtime.totem.pg.mrp.srp.mcast_rx", stats->mrp->srp->mcast_rx); icmap_set_uint64("runtime.totem.pg.mrp.srp.memb_commit_token_tx", stats->mrp->srp->memb_commit_token_tx); icmap_set_uint64("runtime.totem.pg.mrp.srp.memb_commit_token_rx", stats->mrp->srp->memb_commit_token_rx); icmap_set_uint64("runtime.totem.pg.mrp.srp.token_hold_cancel_tx", stats->mrp->srp->token_hold_cancel_tx); icmap_set_uint64("runtime.totem.pg.mrp.srp.token_hold_cancel_rx", stats->mrp->srp->token_hold_cancel_rx); icmap_set_uint64("runtime.totem.pg.mrp.srp.operational_entered", stats->mrp->srp->operational_entered); icmap_set_uint64("runtime.totem.pg.mrp.srp.operational_token_lost", stats->mrp->srp->operational_token_lost); icmap_set_uint64("runtime.totem.pg.mrp.srp.gather_entered", stats->mrp->srp->gather_entered); icmap_set_uint64("runtime.totem.pg.mrp.srp.gather_token_lost", stats->mrp->srp->gather_token_lost); icmap_set_uint64("runtime.totem.pg.mrp.srp.commit_entered", stats->mrp->srp->commit_entered); icmap_set_uint64("runtime.totem.pg.mrp.srp.commit_token_lost", stats->mrp->srp->commit_token_lost); icmap_set_uint64("runtime.totem.pg.mrp.srp.recovery_entered", stats->mrp->srp->recovery_entered); icmap_set_uint64("runtime.totem.pg.mrp.srp.recovery_token_lost", stats->mrp->srp->recovery_token_lost); icmap_set_uint64("runtime.totem.pg.mrp.srp.consensus_timeouts", stats->mrp->srp->consensus_timeouts); icmap_set_uint64("runtime.totem.pg.mrp.srp.rx_msg_dropped", stats->mrp->srp->rx_msg_dropped); icmap_set_uint32("runtime.totem.pg.mrp.srp.continuous_gather", stats->mrp->srp->continuous_gather); icmap_set_uint8("runtime.totem.pg.mrp.srp.firewall_enabled_or_nic_failure", stats->mrp->srp->continuous_gather > MAX_NO_CONT_GATHER ? 1 : 0); for (i = 0; i < stats->mrp->srp->rrp->interface_count; i++) { snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "runtime.totem.pg.mrp.rrp.%u.faulty", i); icmap_set_uint8(key_name, stats->mrp->srp->rrp->faulty[i]); } total_mtt_rx_token = 0; total_token_holdtime = 0; total_backlog_calc = 0; token_count = 0; t = stats->mrp->srp->latest_token; while (1) { if (t == 0) prev = TOTEM_TOKEN_STATS_MAX - 1; else prev = t - 1; if (prev == stats->mrp->srp->earliest_token) break; /* if tx == 0, then dropped token (not ours) */ if (stats->mrp->srp->token[t].tx != 0 || (stats->mrp->srp->token[t].rx - stats->mrp->srp->token[prev].rx) > 0 ) { total_mtt_rx_token += (stats->mrp->srp->token[t].rx - stats->mrp->srp->token[prev].rx); total_token_holdtime += (stats->mrp->srp->token[t].tx - stats->mrp->srp->token[t].rx); total_backlog_calc += stats->mrp->srp->token[t].backlog_calc; token_count++; } t = prev; } if (token_count) { icmap_set_uint32("runtime.totem.pg.mrp.srp.mtt_rx_token", (total_mtt_rx_token / token_count)); icmap_set_uint32("runtime.totem.pg.mrp.srp.avg_token_workload", (total_token_holdtime / token_count)); icmap_set_uint32("runtime.totem.pg.mrp.srp.avg_backlog_calc", (total_backlog_calc / token_count)); } cs_ipcs_stats_update(); api->timer_add_duration (1500 * MILLI_2_NANO_SECONDS, NULL, corosync_totem_stats_updater, &corosync_stats_timer_handle); } static void totem_dynamic_notify( int32_t event, const char *key_name, struct icmap_notify_value new_val, struct icmap_notify_value old_val, void *user_data) { int res; int ring_no; int member_no; struct totem_ip_address member; int add_new_member = 0; int remove_old_member = 0; char tmp_str[ICMAP_KEYNAME_MAXLEN]; res = sscanf(key_name, "nodelist.node.%u.ring%u%s", &member_no, &ring_no, tmp_str); if (res != 3) return ; if (strcmp(tmp_str, "_addr") != 0) { return; } if (event == ICMAP_TRACK_ADD && new_val.type == ICMAP_VALUETYPE_STRING) { add_new_member = 1; } if (event == ICMAP_TRACK_DELETE && old_val.type == ICMAP_VALUETYPE_STRING) { remove_old_member = 1; } if (event == ICMAP_TRACK_MODIFY && new_val.type == ICMAP_VALUETYPE_STRING && old_val.type == ICMAP_VALUETYPE_STRING) { add_new_member = 1; remove_old_member = 1; } if (remove_old_member) { log_printf(LOGSYS_LEVEL_DEBUG, "removing dynamic member %s for ring %u", (char *)old_val.data, ring_no); if (totemip_parse(&member, (char *)old_val.data, 0) == 0) { totempg_member_remove (&member, ring_no); } } if (add_new_member) { log_printf(LOGSYS_LEVEL_DEBUG, "adding dynamic member %s for ring %u", (char *)new_val.data, ring_no); if (totemip_parse(&member, (char *)new_val.data, 0) == 0) { totempg_member_add (&member, ring_no); } } } static void corosync_totem_dynamic_init (void) { icmap_track_t icmap_track = NULL; icmap_track_add("nodelist.node.", ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY | ICMAP_TRACK_PREFIX, totem_dynamic_notify, NULL, &icmap_track); } static void corosync_totem_stats_init (void) { icmap_set_uint32("runtime.totem.pg.mrp.srp.mtt_rx_token", 0); icmap_set_uint32("runtime.totem.pg.mrp.srp.avg_token_workload", 0); icmap_set_uint32("runtime.totem.pg.mrp.srp.avg_backlog_calc", 0); /* start stats timer */ api->timer_add_duration (1500 * MILLI_2_NANO_SECONDS, NULL, corosync_totem_stats_updater, &corosync_stats_timer_handle); } static void deliver_fn ( unsigned int nodeid, const void *msg, unsigned int msg_len, int endian_conversion_required) { const struct qb_ipc_request_header *header; int32_t service; int32_t fn_id; uint32_t id; header = msg; if (endian_conversion_required) { id = swab32 (header->id); } else { id = header->id; } /* * Call the proper executive handler */ service = id >> 16; fn_id = id & 0xffff; if (!corosync_service[service]) { return; } if (fn_id >= corosync_service[service]->exec_engine_count) { log_printf(LOGSYS_LEVEL_WARNING, "discarded unknown message %d for service %d (max id %d)", fn_id, service, corosync_service[service]->exec_engine_count); return; } icmap_fast_inc(service_stats_rx[service][fn_id]); if (endian_conversion_required) { assert(corosync_service[service]->exec_engine[fn_id].exec_endian_convert_fn != NULL); corosync_service[service]->exec_engine[fn_id].exec_endian_convert_fn ((void *)msg); } corosync_service[service]->exec_engine[fn_id].exec_handler_fn (msg, nodeid); } int main_mcast ( const struct iovec *iovec, unsigned int iov_len, unsigned int guarantee) { const struct qb_ipc_request_header *req = iovec->iov_base; int32_t service; int32_t fn_id; service = req->id >> 16; fn_id = req->id & 0xffff; if (corosync_service[service]) { icmap_fast_inc(service_stats_tx[service][fn_id]); } return (totempg_groups_mcast_joined (corosync_group_handle, iovec, iov_len, guarantee)); } static qb_loop_timer_handle recheck_the_q_level_timer; void corosync_recheck_the_q_level(void *data) { totempg_check_q_level(corosync_group_handle); if (cs_ipcs_q_level_get() == TOTEM_Q_LEVEL_CRITICAL) { qb_loop_timer_add(cs_poll_handle_get(), QB_LOOP_MED, 1*QB_TIME_NS_IN_MSEC, NULL, corosync_recheck_the_q_level, &recheck_the_q_level_timer); } } struct sending_allowed_private_data_struct { int reserved_msgs; }; int corosync_sending_allowed ( unsigned int service, unsigned int id, const void *msg, void *sending_allowed_private_data) { struct sending_allowed_private_data_struct *pd = (struct sending_allowed_private_data_struct *)sending_allowed_private_data; struct iovec reserve_iovec; struct qb_ipc_request_header *header = (struct qb_ipc_request_header *)msg; int sending_allowed; reserve_iovec.iov_base = (char *)header; reserve_iovec.iov_len = header->size; pd->reserved_msgs = totempg_groups_joined_reserve ( corosync_group_handle, &reserve_iovec, 1); if (pd->reserved_msgs == -1) { return -EINVAL; } sending_allowed = QB_FALSE; if (corosync_quorum_is_quorate() == 1 || corosync_service[service]->allow_inquorate == CS_LIB_ALLOW_INQUORATE) { // we are quorate // now check flow control if (corosync_service[service]->lib_engine[id].flow_control == CS_LIB_FLOW_CONTROL_NOT_REQUIRED) { sending_allowed = QB_TRUE; } else if (pd->reserved_msgs && sync_in_process == 0) { sending_allowed = QB_TRUE; } else if (pd->reserved_msgs == 0) { return -ENOBUFS; } else /* (sync_in_process) */ { return -EINPROGRESS; } } else { return -EHOSTUNREACH; } return (sending_allowed); } void corosync_sending_allowed_release (void *sending_allowed_private_data) { struct sending_allowed_private_data_struct *pd = (struct sending_allowed_private_data_struct *)sending_allowed_private_data; if (pd->reserved_msgs == -1) { return; } totempg_groups_joined_release (pd->reserved_msgs); } int message_source_is_local (const mar_message_source_t *source) { int ret = 0; assert (source != NULL); if (source->nodeid == totempg_my_nodeid_get ()) { ret = 1; } return ret; } void message_source_set ( mar_message_source_t *source, void *conn) { assert ((source != NULL) && (conn != NULL)); memset (source, 0, sizeof (mar_message_source_t)); source->nodeid = totempg_my_nodeid_get (); source->conn = conn; } static void corosync_setscheduler (void) { #if defined(HAVE_PTHREAD_SETSCHEDPARAM) && defined(HAVE_SCHED_GET_PRIORITY_MAX) && defined(HAVE_SCHED_SETSCHEDULER) int res; sched_priority = sched_get_priority_max (SCHED_RR); if (sched_priority != -1) { global_sched_param.sched_priority = sched_priority; res = sched_setscheduler (0, SCHED_RR, &global_sched_param); if (res == -1) { LOGSYS_PERROR(errno, LOGSYS_LEVEL_WARNING, "Could not set SCHED_RR at priority %d", global_sched_param.sched_priority); global_sched_param.sched_priority = 0; #ifdef HAVE_QB_LOG_THREAD_PRIORITY_SET qb_log_thread_priority_set (SCHED_OTHER, 0); #endif } else { /* * Turn on SCHED_RR in logsys system */ #ifdef HAVE_QB_LOG_THREAD_PRIORITY_SET res = qb_log_thread_priority_set (SCHED_RR, sched_priority); #else res = -1; #endif if (res == -1) { log_printf (LOGSYS_LEVEL_ERROR, "Could not set logsys thread priority." " Can't continue because of priority inversions."); corosync_exit_error (COROSYNC_DONE_LOGSETUP); } } } else { LOGSYS_PERROR (errno, LOGSYS_LEVEL_WARNING, "Could not get maximum scheduler priority"); sched_priority = 0; } #else log_printf(LOGSYS_LEVEL_WARNING, "The Platform is missing process priority setting features. Leaving at default."); #endif } static void _logsys_log_printf(int level, int subsys, const char *function_name, const char *file_name, int file_line, const char *format, ...) __attribute__((format(printf, 6, 7))); static void _logsys_log_printf(int level, int subsys, const char *function_name, const char *file_name, int file_line, const char *format, ...) { va_list ap; va_start(ap, format); qb_log_from_external_source_va(function_name, file_name, format, level, file_line, subsys, ap); va_end(ap); } static void fplay_key_change_notify_fn ( int32_t event, const char *key_name, struct icmap_notify_value new_val, struct icmap_notify_value old_val, void *user_data) { if (strcmp(key_name, "runtime.blackbox.dump_flight_data") == 0) { fprintf(stderr,"Writetofile\n"); qb_log_blackbox_write_to_file (LOCALSTATEDIR "/lib/corosync/fdata"); } if (strcmp(key_name, "runtime.blackbox.dump_state") == 0) { fprintf(stderr,"statefump\n"); corosync_state_dump (); } } static void corosync_fplay_control_init (void) { icmap_track_t track = NULL; icmap_set_string("runtime.blackbox.dump_flight_data", "no"); icmap_set_string("runtime.blackbox.dump_state", "no"); icmap_track_add("runtime.blackbox.dump_flight_data", ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY, fplay_key_change_notify_fn, NULL, &track); icmap_track_add("runtime.blackbox.dump_state", ICMAP_TRACK_ADD | ICMAP_TRACK_DELETE | ICMAP_TRACK_MODIFY, fplay_key_change_notify_fn, NULL, &track); } /* * Set RO flag for keys, which ether doesn't make sense to change by user (statistic) * or which when changed are not reflected by runtime (totem.crypto_cipher, ...). * * Also some RO keys cannot be determined in this stage, so they are set later in * other functions (like nodelist.local_node_pos, ...) */ static void set_icmap_ro_keys_flag (void) { /* * Set RO flag for all keys of internal configuration and runtime statistics */ icmap_set_ro_access("internal_configuration.", CS_TRUE, CS_TRUE); icmap_set_ro_access("runtime.connections.", CS_TRUE, CS_TRUE); icmap_set_ro_access("runtime.totem.", CS_TRUE, CS_TRUE); icmap_set_ro_access("runtime.services.", CS_TRUE, CS_TRUE); /* * Set RO flag for constrete keys of configuration which can't be changed * during runtime */ icmap_set_ro_access("totem.crypto_cipher", CS_FALSE, CS_TRUE); icmap_set_ro_access("totem.crypto_hash", CS_FALSE, CS_TRUE); icmap_set_ro_access("totem.secauth", CS_FALSE, CS_TRUE); icmap_set_ro_access("totem.rrp_mode", CS_FALSE, CS_TRUE); icmap_set_ro_access("totem.netmtu", CS_FALSE, CS_TRUE); } static void main_service_ready (void) { int res; /* * This must occur after totempg is initialized because "this_ip" must be set */ res = corosync_service_defaults_link_and_init (api); if (res == -1) { log_printf (LOGSYS_LEVEL_ERROR, "Could not initialize default services"); corosync_exit_error (COROSYNC_DONE_INIT_SERVICES); } cs_ipcs_init(); corosync_totem_stats_init (); corosync_fplay_control_init (); corosync_totem_dynamic_init (); sync_init ( corosync_sync_callbacks_retrieve, corosync_sync_completed); } static enum e_corosync_done corosync_flock (const char *lockfile, pid_t pid) { struct flock lock; enum e_corosync_done err; char pid_s[17]; int fd_flag; int lf; err = COROSYNC_DONE_EXIT; lf = open (lockfile, O_WRONLY | O_CREAT, 0640); if (lf == -1) { log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't create lock file."); return (COROSYNC_DONE_AQUIRE_LOCK); } retry_fcntl: lock.l_type = F_WRLCK; lock.l_start = 0; lock.l_whence = SEEK_SET; lock.l_len = 0; if (fcntl (lf, F_SETLK, &lock) == -1) { switch (errno) { case EINTR: goto retry_fcntl; break; case EAGAIN: case EACCES: log_printf (LOGSYS_LEVEL_ERROR, "Another Corosync instance is already running."); err = COROSYNC_DONE_ALREADY_RUNNING; goto error_close; break; default: log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't aquire lock. Error was %s", strerror(errno)); err = COROSYNC_DONE_AQUIRE_LOCK; goto error_close; break; } } if (ftruncate (lf, 0) == -1) { log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't truncate lock file. Error was %s", strerror (errno)); err = COROSYNC_DONE_AQUIRE_LOCK; goto error_close_unlink; } memset (pid_s, 0, sizeof (pid_s)); snprintf (pid_s, sizeof (pid_s) - 1, "%u\n", pid); retry_write: if (write (lf, pid_s, strlen (pid_s)) != strlen (pid_s)) { if (errno == EINTR) { goto retry_write; } else { log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't write pid to lock file. " "Error was %s", strerror (errno)); err = COROSYNC_DONE_AQUIRE_LOCK; goto error_close_unlink; } } if ((fd_flag = fcntl (lf, F_GETFD, 0)) == -1) { log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't get close-on-exec flag from lock file. " "Error was %s", strerror (errno)); err = COROSYNC_DONE_AQUIRE_LOCK; goto error_close_unlink; } fd_flag |= FD_CLOEXEC; if (fcntl (lf, F_SETFD, fd_flag) == -1) { log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't set close-on-exec flag to lock file. " "Error was %s", strerror (errno)); err = COROSYNC_DONE_AQUIRE_LOCK; goto error_close_unlink; } return (err); error_close_unlink: unlink (lockfile); error_close: close (lf); return (err); } int main (int argc, char **argv, char **envp) { const char *error_string; struct totem_config totem_config; int res, ch; int background, setprio; struct stat stat_out; char corosync_lib_dir[PATH_MAX]; enum e_corosync_done flock_err; uint64_t totem_config_warnings; /* default configuration */ background = 1; setprio = 0; while ((ch = getopt (argc, argv, "fprv")) != EOF) { switch (ch) { case 'f': background = 0; logsys_config_mode_set (NULL, LOGSYS_MODE_OUTPUT_STDERR|LOGSYS_MODE_THREADED|LOGSYS_MODE_FORK); break; case 'p': break; case 'r': setprio = 1; break; case 'v': printf ("Corosync Cluster Engine, version '%s'\n", VERSION); printf ("Copyright (c) 2006-2009 Red Hat, Inc.\n"); return EXIT_SUCCESS; break; default: fprintf(stderr, \ "usage:\n"\ " -f : Start application in foreground.\n"\ " -p : Does nothing. \n"\ " -r : Set round robin realtime scheduling \n"\ " -v : Display version and SVN revision of Corosync and exit.\n"); return EXIT_FAILURE; } } /* * Set round robin realtime scheduling with priority 99 * Lock all memory to avoid page faults which may interrupt * application healthchecking */ if (setprio) { corosync_setscheduler (); } corosync_mlockall (); log_printf (LOGSYS_LEVEL_NOTICE, "Corosync Cluster Engine ('%s'): started and ready to provide service.", VERSION); log_printf (LOGSYS_LEVEL_INFO, "Corosync built-in features:" PACKAGE_FEATURES ""); corosync_poll_handle = qb_loop_create (); qb_loop_signal_add(corosync_poll_handle, QB_LOOP_LOW, SIGUSR2, NULL, sig_diag_handler, NULL); qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH, SIGINT, NULL, sig_exit_handler, NULL); qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH, SIGQUIT, NULL, sig_exit_handler, NULL); qb_loop_signal_add(corosync_poll_handle, QB_LOOP_HIGH, SIGTERM, NULL, sig_exit_handler, NULL); (void)signal (SIGSEGV, sigsegv_handler); (void)signal (SIGABRT, sigabrt_handler); #if MSG_NOSIGNAL != 0 (void)signal (SIGPIPE, SIG_IGN); #endif if (icmap_init() != CS_OK) { log_printf (LOGSYS_LEVEL_ERROR, "Corosync Executive couldn't initialize configuration component."); corosync_exit_error (COROSYNC_DONE_ICMAP); } set_icmap_ro_keys_flag(); /* * Initialize the corosync_api_v1 definition */ api = apidef_get (); res = coroparse_configparse(&error_string); if (res == -1) { log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string); corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD); } res = corosync_main_config_read (&error_string); if (res == -1) { /* * if we are here, we _must_ flush the logsys queue * and try to inform that we couldn't read the config. * this is a desperate attempt before certain death * and there is no guarantee that we can print to stderr * nor that logsys is sending the messages where we expect. */ log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string); fprintf(stderr, "%s", error_string); syslog (LOGSYS_LEVEL_ERROR, "%s", error_string); corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD); } /* * Make sure required directory is present */ sprintf (corosync_lib_dir, "%s/lib/corosync", LOCALSTATEDIR); res = stat (corosync_lib_dir, &stat_out); if ((res == -1) || (res == 0 && !S_ISDIR(stat_out.st_mode))) { log_printf (LOGSYS_LEVEL_ERROR, "Required directory not present %s. Please create it.", corosync_lib_dir); corosync_exit_error (COROSYNC_DONE_DIR_NOT_PRESENT); } res = totem_config_read (&totem_config, &error_string, &totem_config_warnings); if (res == -1) { log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string); corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD); } if (totem_config_warnings & TOTEM_CONFIG_WARNING_MEMBERS_IGNORED) { log_printf (LOGSYS_LEVEL_WARNING, "member section is used together with nodelist. Members ignored."); } if (totem_config_warnings & TOTEM_CONFIG_WARNING_MEMBERS_DEPRECATED) { log_printf (LOGSYS_LEVEL_WARNING, "member section is deprecated."); } if (totem_config_warnings & TOTEM_CONFIG_WARNING_TOTEM_NODEID_IGNORED) { log_printf (LOGSYS_LEVEL_WARNING, "nodeid appears both in totem section and nodelist. Nodelist one is used."); } if (totem_config_warnings != 0) { log_printf (LOGSYS_LEVEL_WARNING, "Please migrate config file to nodelist."); } res = totem_config_keyread (&totem_config, &error_string); if (res == -1) { log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string); corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD); } res = totem_config_validate (&totem_config, &error_string); if (res == -1) { log_printf (LOGSYS_LEVEL_ERROR, "%s", error_string); corosync_exit_error (COROSYNC_DONE_MAINCONFIGREAD); } totem_config.totem_logging_configuration = totem_logging_configuration; totem_config.totem_logging_configuration.log_subsys_id = _logsys_subsys_create("TOTEM", "totem"); totem_config.totem_logging_configuration.log_level_security = LOGSYS_LEVEL_WARNING; totem_config.totem_logging_configuration.log_level_error = LOGSYS_LEVEL_ERROR; totem_config.totem_logging_configuration.log_level_warning = LOGSYS_LEVEL_WARNING; totem_config.totem_logging_configuration.log_level_notice = LOGSYS_LEVEL_NOTICE; totem_config.totem_logging_configuration.log_level_debug = LOGSYS_LEVEL_DEBUG; totem_config.totem_logging_configuration.log_printf = _logsys_log_printf; logsys_config_apply(); /* * Now we are fully initialized. */ if (background) { corosync_tty_detach (); } qb_log_thread_start(); if ((flock_err = corosync_flock (corosync_lock_file, getpid ())) != COROSYNC_DONE_EXIT) { corosync_exit_error (flock_err); } /* * if totempg_initialize doesn't have root priveleges, it cannot * bind to a specific interface. This only matters if * there is more then one interface in a system, so * in this case, only a warning is printed */ /* * Join multicast group and setup delivery * and configuration change functions */ totempg_initialize ( corosync_poll_handle, &totem_config); totempg_service_ready_register ( main_service_ready); totempg_groups_initialize ( &corosync_group_handle, deliver_fn, confchg_fn); totempg_groups_join ( corosync_group_handle, &corosync_group, 1); /* * Drop root privleges to user 'corosync' * TODO: Don't really need full root capabilities; * needed capabilities are: * CAP_NET_RAW (bindtodevice) * CAP_SYS_NICE (setscheduler) * CAP_IPC_LOCK (mlockall) */ priv_drop (); schedwrk_init ( serialize_lock, serialize_unlock); /* * Start main processing loop */ qb_loop_run (corosync_poll_handle); /* * Exit was requested */ totempg_finalize (); /* * free the loop resources */ qb_loop_destroy (corosync_poll_handle); /* * free up the icmap */ /* * Remove pid lock file */ unlink (corosync_lock_file); corosync_exit_error (COROSYNC_DONE_EXIT); return EXIT_SUCCESS; } diff --git a/include/corosync/icmap.h b/include/corosync/icmap.h index 80aac256..40637719 100644 --- a/include/corosync/icmap.h +++ b/include/corosync/icmap.h @@ -1,282 +1,283 @@ /* * Copyright (c) 2011-2012 Red Hat, Inc. * * Author: Jan Friesse (jfriesse@redhat.com) * * All rights reserved. * * This software licensed under BSD license, the text of which follows: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name of the Red Hat, Inc. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef ICMAP_H_DEFINED #define ICMAP_H_DEFINED #include #include #include #ifdef __cplusplus extern "C" { #endif /* * Maximum length of key in icmap */ #define ICMAP_KEYNAME_MAXLEN 255 /* * Minimum lenght of key in icmap */ #define ICMAP_KEYNAME_MINLEN 3 /* * Possible types of value. Binary is raw data without trailing zero with given length */ typedef enum { ICMAP_VALUETYPE_INT8 = 1, ICMAP_VALUETYPE_UINT8 = 2, ICMAP_VALUETYPE_INT16 = 3, ICMAP_VALUETYPE_UINT16 = 4, ICMAP_VALUETYPE_INT32 = 5, ICMAP_VALUETYPE_UINT32 = 6, ICMAP_VALUETYPE_INT64 = 7, ICMAP_VALUETYPE_UINT64 = 8, ICMAP_VALUETYPE_FLOAT = 9, ICMAP_VALUETYPE_DOUBLE = 10, ICMAP_VALUETYPE_STRING = 11, ICMAP_VALUETYPE_BINARY = 12, } icmap_value_types_t; /* * Tracking values. */ #define ICMAP_TRACK_ADD 4 #define ICMAP_TRACK_DELETE 1 #define ICMAP_TRACK_MODIFY 2 /* * Whole prefix is tracked, instead of key only (so "totem." tracking means that * "totem.nodeid", "totem.version", ... applies). This value is also never returned * inside of callback and is used only in adding track */ #define ICMAP_TRACK_PREFIX 8 /* * Structure passed as new_value and old_value in change callback. It contains type of * key, length of key and pointer to value of key */ struct icmap_notify_value { icmap_value_types_t type; size_t len; const void *data; }; /* * Prototype for notify callback function. Even is one of ICMAP_TRACK_* event, key_name is * changed key, new and old_value contains values or are zeroed (in other words, type is non * existing 0 type) if there were no old (creating of key) or new (deleting of key) value. * user_data are passed when adding tracking. */ typedef 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); /* * Itterator type */ typedef qb_map_iter_t *icmap_iter_t; /* * Track type */ typedef struct icmap_track *icmap_track_t; /* * Initialize icmap */ extern cs_error_t icmap_init(void); +extern void icmap_fini(void); /* * Store value with value_len length and type as key_name name in icmap. */ extern cs_error_t icmap_set( const char *key_name, const void *value, size_t value_len, icmap_value_types_t type); /* * Shortcuts for setting values */ extern cs_error_t icmap_set_int8(const char *key_name, int8_t value); extern cs_error_t icmap_set_uint8(const char *key_name, uint8_t value); extern cs_error_t icmap_set_int16(const char *key_name, int16_t value); extern cs_error_t icmap_set_uint16(const char *key_name, uint16_t value); extern cs_error_t icmap_set_int32(const char *key_name, int32_t value); extern cs_error_t icmap_set_uint32(const char *key_name, uint32_t value); extern cs_error_t icmap_set_int64(const char *key_name, int64_t value); extern cs_error_t icmap_set_uint64(const char *key_name, uint64_t value); extern cs_error_t icmap_set_float(const char *key_name, float value); extern cs_error_t icmap_set_double(const char *key_name, double value); extern cs_error_t icmap_set_string(const char *key_name, const char *value); /* * Delete key from map */ extern cs_error_t icmap_delete(const char *key_name); /* * Retrieve value of key key_name and store it in user preallocated value pointer. * value can be NULL, and then only value_len and/or type is returned (both of them * can also be NULL). If value is not NULL, actual length of value in map is checked * against value_len. If *value_len is shorter then length of value in map, error * CS_ERR_INVALID_PARAM is returned. After successful copy of value, value_len is * set to actual length of value in map. */ extern cs_error_t icmap_get( const char *key_name, void *value, size_t *value_len, icmap_value_types_t *type); /* * Shortcuts for icmap_get */ extern cs_error_t icmap_get_int8(const char *key_name, int8_t *i8); extern cs_error_t icmap_get_uint8(const char *key_name, uint8_t *u8); extern cs_error_t icmap_get_int16(const char *key_name, int16_t *i16); extern cs_error_t icmap_get_uint16(const char *key_name, uint16_t *u16); extern cs_error_t icmap_get_int32(const char *key_name, int32_t *i32); extern cs_error_t icmap_get_uint32(const char *key_name, uint32_t *u32); extern cs_error_t icmap_get_int64(const char *key_name, int64_t *i64); extern cs_error_t icmap_get_uint64(const char *key_name, uint64_t *u64); extern cs_error_t icmap_get_float(const char *key_name, float *flt); extern cs_error_t icmap_get_double(const char *key_name, double *dbl); /* * Shortcut for icmap_get for string type. Returned string is newly allocated and * caller is responsible for freeing memory */ extern cs_error_t icmap_get_string(const char *key_name, char **str); /* * Defined only for [u]int* values. It adds step to current value. */ extern cs_error_t icmap_adjust_int(const char *key_name, int32_t step); /* * Defined only for [u]int* values. It adds step to current value. Difference * between this function and icmap_adjust_int is given in fact, that in * tracking callback, old value is undefined, but whole process is done * without malloc/memcpy. */ extern cs_error_t icmap_fast_adjust_int(const char *key_name, int32_t step); /* * Increase stored value by one */ extern cs_error_t icmap_inc(const char *key_name); /* * Decrease stored value by one */ extern cs_error_t icmap_dec(const char *key_name); /* * Increase stored value by one. Difference between this function and icmap_inc * is same as between icmap_adjust_int and icmap_fast_adjust_int. */ extern cs_error_t icmap_fast_inc(const char *key_name); /* * Decrease stored value by one. Difference between this function and icmap_dec * is same as between icmap_adjust_int and icmap_fast_adjust_int. */ extern cs_error_t icmap_fast_dec(const char *key_name); /* * Initialize iterator with given prefix */ extern icmap_iter_t icmap_iter_init(const char *prefix); /* * Return next item in iterator iter. value_len and type are optional (= can be NULL), but if set, * length of returned value and/or type is returned. Function returns following key_name or NULL if * iteration is over. */ extern const char *icmap_iter_next(icmap_iter_t iter, size_t *value_len, icmap_value_types_t *type); /* * Finalize iterator */ extern void icmap_iter_finalize(icmap_iter_t iter); /* * Add tracking function for given key_name. Tracked changes (add|modify|delete) depend on track_type, * which is bitwise or of ICMAP_TRACK_* values. notify_fn is called on change, where user_data pointer * is passed (unchanged). Value which can be used to delete tracking is passed as icmap_track. */ extern 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); /* * Return user data associated with given track */ extern void *icmap_track_get_user_data(icmap_track_t icmap_track); /* * Remove previously added track */ extern cs_error_t icmap_track_delete(icmap_track_t icmap_track); /* * Set read-only access for given key (key_name) or prefix, if prefix is set. ro_access * can be !0, which means, that old information about ro of this key is deleted. * Read-only access is used only in CMAP service! (in other word it prevents users * from deleting/changing key, but doesn't guarantee anything for internal icmap users. */ extern cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access); /* * Check in given key is read only. Returns !0 if so, otherwise (key is rw) 0. */ extern int icmap_is_key_ro(const char *key_name); /* * Converts given key_name to valid key name (replacing all prohibited characters by _) */ extern void icmap_convert_name_to_valid_name(char *key_name); #ifdef __cplusplus } #endif #endif /* ICMAP_H_DEFINED */