static void _hash_destroy_single(struct dm_hash_table **htable)
{
if (htable && *htable) {
dm_hash_destroy(*htable);
*htable = NULL;
}
}
static void _cluster_closedown(void)
{
close_comms();
DEBUGLOG("cluster_closedown\n");
destroy_lvhash();
dm_hash_destroy(_locks);
_locks = NULL;
_lockid = 0;
}
static int _init_hash(struct pfilter *pf)
{
if (pf->devices)
dm_hash_destroy(pf->devices);
if (!(pf->devices = dm_hash_create(128))) {
stack;
return 0;
}
return 1;
}
static void _cluster_closedown(void)
{
close_comms();
/* If there is any awaited resource, kill it softly */
pthread_mutex_lock(&_lock_mutex);
dm_hash_destroy(_locks);
_locks = NULL;
_lockid = 0;
pthread_cond_broadcast(&_lock_cond); /* wakeup waiters */
pthread_mutex_unlock(&_lock_mutex);
}
static int _init_cluster(void)
{
int r;
if (!(_locks = dm_hash_create(128))) {
DEBUGLOG("Failed to allocate single-node hash table.\n");
return 1;
}
r = init_comms();
if (r) {
dm_hash_destroy(_locks);
return r;
}
DEBUGLOG("Single-node cluster initialised.\n");
return 0;
}
void reset_log_duplicated(void) {
if (_duplicated) {
dm_hash_destroy(_duplicated);
_duplicated = NULL;
}
}
int config_def_check(struct cmd_context *cmd, struct cft_check_handle *handle)
{
cfg_def_item_t *def;
struct dm_config_node *cn;
char *vp = _cfg_path, rp[CFG_PATH_MAX_LEN];
size_t rplen;
int id, r = 1;
/*
* vp = virtual path, it might contain substitutes for variable parts
* of the path, used while working with the hash
* rp = real path, the real path of the config element as found in the
* configuration, used for message output
*/
/*
* If the check has already been done and 'skip_if_checked' is set,
* skip the actual check and use last result if available.
* If not available, we must do the check. The global status
* is stored in root node.
*/
if (handle->skip_if_checked && (handle->status[root_CFG_SECTION] & CFG_USED))
return handle->status[root_CFG_SECTION] & CFG_VALID;
/* Nothing to do if checks are disabled and also not forced. */
if (!handle->force_check && !find_config_tree_bool(cmd, config_checks_CFG, NULL))
return 1;
/* Clear 'used' and 'valid' status flags. */
for (id = 0; id < CFG_COUNT; id++)
handle->status[id] &= ~(CFG_USED | CFG_VALID);
/*
* Create a hash of all possible configuration
* sections and settings with full path as a key.
* If section name is variable, use '#' as a substitute.
*/
if (!cmd->cft_def_hash) {
if (!(cmd->cft_def_hash = dm_hash_create(64))) {
log_error("Failed to create configuration definition hash.");
r = 0; goto out;
}
for (id = 1; id < CFG_COUNT; id++) {
def = cfg_def_get_item_p(id);
if (!cfg_def_get_path(def)) {
dm_hash_destroy(cmd->cft_def_hash);
cmd->cft_def_hash = NULL;
r = 0; goto out;
}
if (!dm_hash_insert(cmd->cft_def_hash, vp, def)) {
log_error("Failed to insert configuration to hash.");
r = 0;
goto out;
}
}
}
/*
* Mark this handle as used so next time we know that the check
* has already been done and so we can just reuse the previous
* status instead of running this whole check again.
*/
handle->status[root_CFG_SECTION] |= CFG_USED;
/*
* Allow only sections as top-level elements.
* Iterate top-level sections and dive deeper.
* If any of subsequent checks fails, the whole check fails.
*/
for (cn = handle->cft->root; cn; cn = cn->sib) {
if (!cn->v) {
/* top level node: vp=vp, rp=rp */
if (!_config_def_check_node(handle, vp, vp, rp, rp,
CFG_PATH_MAX_LEN,
cn, cmd->cft_def_hash)) {
r = 0; continue;
}
rplen = strlen(rp);
if (!_config_def_check_tree(handle,
vp, vp + strlen(vp),
rp, rp + rplen,
CFG_PATH_MAX_LEN - rplen,
cn, cmd->cft_def_hash))
r = 0;
} else {
log_error_suppress(handle->suppress_messages,
"Configuration setting \"%s\" invalid. "
"It's not part of any section.", cn->key);
r = 0;
}
}
out:
if (r)
handle->status[root_CFG_SECTION] |= CFG_VALID;
else
handle->status[root_CFG_SECTION] &= ~CFG_VALID;
return r;
}