static int _init_cluster(void) { SaAisErrorT err; SaVersionT ver = { 'B', 1, 1 }; int select_fd; node_hash = dm_hash_create(100); lock_hash = dm_hash_create(10); err = cpg_initialize(&cpg_handle, &openais_cpg_callbacks); if (err != SA_AIS_OK) { syslog(LOG_ERR, "Cannot initialise OpenAIS CPG service: %d", err); DEBUGLOG("Cannot initialise OpenAIS CPG service: %d", err); return ais_to_errno(err); } err = saLckInitialize(&lck_handle, NULL, &ver); if (err != SA_AIS_OK) { cpg_initialize(&cpg_handle, &openais_cpg_callbacks); syslog(LOG_ERR, "Cannot initialise OpenAIS lock service: %d", err); DEBUGLOG("Cannot initialise OpenAIS lock service: %d\n\n", err); return ais_to_errno(err); } /* Connect to the clvmd group */ strcpy((char *)cpg_group_name.value, "clvmd"); cpg_group_name.length = strlen((char *)cpg_group_name.value); err = cpg_join(cpg_handle, &cpg_group_name); if (err != SA_AIS_OK) { cpg_finalize(cpg_handle); saLckFinalize(lck_handle); syslog(LOG_ERR, "Cannot join clvmd process group"); DEBUGLOG("Cannot join clvmd process group: %d\n", err); return ais_to_errno(err); } err = cpg_local_get(cpg_handle, &our_nodeid); if (err != SA_AIS_OK) { cpg_finalize(cpg_handle); saLckFinalize(lck_handle); syslog(LOG_ERR, "Cannot get local node id\n"); return ais_to_errno(err); } DEBUGLOG("Our local node id is %d\n", our_nodeid); saLckSelectionObjectGet(lck_handle, (SaSelectionObjectT *)&select_fd); add_internal_client(select_fd, lck_dispatch); DEBUGLOG("Connected to OpenAIS\n"); return 0; }
void init_lvhash() { /* Create hash table for keeping LV locks & status */ lv_hash = dm_hash_create(100); pthread_mutex_init(&lv_hash_lock, NULL); pthread_mutex_init(&lvm_lock, NULL); }
static int _hash_create(void) { if (!(_vgname_hash = dm_hash_create(128))) return 0; if (!(_pvname_hash = dm_hash_create(128))) { _hash_destroy_single(&_vgname_hash); return 0; } if (!(_lvname_hash = dm_hash_create(128))) { _hash_destroy_single(&_vgname_hash); _hash_destroy_single(&_pvname_hash); return 0; } if (!(_vgid_hash = dm_hash_create(128))) { _hash_destroy_single(&_vgname_hash); _hash_destroy_single(&_pvname_hash); _hash_destroy_single(&_lvname_hash); return 0; } return 1; }
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 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; }
/* Called by init_cluster() to open up the listening socket */ int init_comms(unsigned short port) { struct sockaddr_in6 addr; sock_hash = dm_hash_create(100); tcp_port = port ? : DEFAULT_TCP_PORT; listen_fd = socket(AF_INET6, SOCK_STREAM, 0); if (listen_fd < 0) { return -1; } else { int one = 1; setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int)); setsockopt(listen_fd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(int)); } memset(&addr, 0, sizeof(addr)); // Bind to INADDR_ANY addr.sin6_family = AF_INET6; addr.sin6_port = htons(tcp_port); if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { DEBUGLOG("Can't bind to port: %s\n", strerror(errno)); syslog(LOG_ERR, "Can't bind to port %d, is clvmd already running ?", tcp_port); close(listen_fd); return -1; } listen(listen_fd, 5); /* Set Close-on-exec */ fcntl(listen_fd, F_SETFD, 1); return 0; }
static int _init_cluster(void) { cs_error_t err; #ifdef QUORUM_SET /* corosync/quorum.h */ uint32_t quorum_type; #endif node_hash = dm_hash_create(100); err = cpg_initialize(&cpg_handle, &corosync_cpg_callbacks); if (err != CS_OK) { syslog(LOG_ERR, "Cannot initialise Corosync CPG service: %d", err); DEBUGLOG("Cannot initialise Corosync CPG service: %d", err); return cs_to_errno(err); } #ifdef QUORUM_SET err = quorum_initialize(&quorum_handle, &quorum_callbacks, &quorum_type); if (quorum_type != QUORUM_SET) { syslog(LOG_ERR, "Corosync quorum service is not configured"); DEBUGLOG("Corosync quorum service is not configured"); return EINVAL; } #else err = quorum_initialize(&quorum_handle, &quorum_callbacks); #endif if (err != CS_OK) { syslog(LOG_ERR, "Cannot initialise Corosync quorum service: %d", err); DEBUGLOG("Cannot initialise Corosync quorum service: %d", err); return cs_to_errno(err); } /* Create a lockspace for LV & VG locks to live in */ lockspace = dlm_open_lockspace(LOCKSPACE_NAME); if (!lockspace) { lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600); if (!lockspace) { syslog(LOG_ERR, "Unable to create DLM lockspace for CLVM: %m"); return -1; } DEBUGLOG("Created DLM lockspace for CLVMD.\n"); } else DEBUGLOG("Opened existing DLM lockspace for CLVMD.\n"); dlm_ls_pthread_init(lockspace); DEBUGLOG("DLM initialisation complete\n"); /* Connect to the clvmd group */ strcpy((char *)cpg_group_name.value, "clvmd"); cpg_group_name.length = strlen((char *)cpg_group_name.value); err = cpg_join(cpg_handle, &cpg_group_name); if (err != CS_OK) { cpg_finalize(cpg_handle); quorum_finalize(quorum_handle); dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1); syslog(LOG_ERR, "Cannot join clvmd process group"); DEBUGLOG("Cannot join clvmd process group: %d\n", err); return cs_to_errno(err); } err = cpg_local_get(cpg_handle, &our_nodeid); if (err != CS_OK) { cpg_finalize(cpg_handle); quorum_finalize(quorum_handle); dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1); syslog(LOG_ERR, "Cannot get local node id\n"); return cs_to_errno(err); } DEBUGLOG("Our local node id is %d\n", our_nodeid); DEBUGLOG("Connected to Corosync\n"); return 0; }
void print_log(int level, const char *file, int line, int dm_errno_or_class, const char *format, ...) { va_list ap; char buf[1024], message[4096]; int bufused, n; const char *trformat; /* Translated format string */ char *newbuf; int use_stderr = level & _LOG_STDERR; int log_once = level & _LOG_ONCE; int fatal_internal_error = 0; size_t msglen; const char *indent_spaces = ""; FILE *stream; static int _abort_on_internal_errors_env_present = -1; static int _abort_on_internal_errors_env = 0; char *env_str; level &= ~(_LOG_STDERR|_LOG_ONCE); if (_abort_on_internal_errors_env_present < 0) { if ((env_str = getenv("DM_ABORT_ON_INTERNAL_ERRORS"))) { _abort_on_internal_errors_env_present = 1; /* Set when env DM_ABORT_ON_INTERNAL_ERRORS is not "0" */ _abort_on_internal_errors_env = strcmp(env_str, "0"); } else _abort_on_internal_errors_env_present = 0; } /* Use value from environment if present, otherwise use value from config. */ if (((_abort_on_internal_errors_env_present && _abort_on_internal_errors_env) || (!_abort_on_internal_errors_env_present && _abort_on_internal_errors_config)) && !strncmp(format, INTERNAL_ERROR, sizeof(INTERNAL_ERROR) - 1)) { fatal_internal_error = 1; /* Internal errors triggering abort cannot be suppressed. */ _log_suppress = 0; level = _LOG_FATAL; } if (level <= _LOG_ERR) init_error_message_produced(1); trformat = _(format); if (level < _LOG_DEBUG && dm_errno_or_class && !_lvm_errno) _lvm_errno = dm_errno_or_class; if (_lvm2_log_fn || (_store_errmsg && (level <= _LOG_ERR)) || log_once) { va_start(ap, format); n = vsnprintf(message, sizeof(message), trformat, ap); va_end(ap); /* When newer glibc returns >= sizeof(locn), we will just log what * has fit into buffer, it's '\0' terminated string */ if (n < 0) { fprintf(stderr, _("vsnprintf failed: skipping external " "logging function")); goto log_it; } } /* FIXME Avoid pointless use of message buffer when it'll never be read! */ if (_store_errmsg && (level <= _LOG_ERR) && _lvm_errmsg_len < MAX_ERRMSG_LEN) { msglen = strlen(message); if ((_lvm_errmsg_len + msglen + 1) >= _lvm_errmsg_size) { _lvm_errmsg_size = 2 * (_lvm_errmsg_len + msglen + 1); if ((newbuf = dm_realloc(_lvm_errmsg, _lvm_errmsg_size))) _lvm_errmsg = newbuf; else _lvm_errmsg_size = _lvm_errmsg_len; } if (_lvm_errmsg && (_lvm_errmsg_len + msglen + 2) < _lvm_errmsg_size) { /* prepend '\n' and copy with '\0' but do not count in */ if (_lvm_errmsg_len) _lvm_errmsg[_lvm_errmsg_len++] = '\n'; memcpy(_lvm_errmsg + _lvm_errmsg_len, message, msglen + 1); _lvm_errmsg_len += msglen; } } if (log_once) { if (!_duplicated) _duplicated = dm_hash_create(128); if (_duplicated) { if (dm_hash_lookup(_duplicated, message)) level = _LOG_NOTICE; else (void) dm_hash_insert(_duplicated, message, (void*)1); } } if (_lvm2_log_fn) { _lvm2_log_fn(level, file, line, 0, message); if (fatal_internal_error) abort(); return; } log_it: if ((verbose_level() >= level) && !_log_suppress) { if (verbose_level() > _LOG_DEBUG) { (void) dm_snprintf(buf, sizeof(buf), "#%s:%d ", file, line); } else buf[0] = '\0'; if (_indent) switch (level) { case _LOG_NOTICE: indent_spaces = " "; break; case _LOG_INFO: indent_spaces = " "; break; case _LOG_DEBUG: indent_spaces = " "; break; default: /* nothing to do */; } va_start(ap, format); switch (level) { case _LOG_DEBUG: if (verbose_level() < _LOG_DEBUG) break; if (!debug_class_is_logged(dm_errno_or_class)) break; if ((verbose_level() == level) && (strcmp("<backtrace>", format) == 0)) break; /* fall through */ default: /* Typically only log_warn goes to stdout */ stream = (use_stderr || (level != _LOG_WARN)) ? stderr : stdout; if (stream == stderr) fflush(stdout); fprintf(stream, "%s%s%s%s", buf, log_command_name(), _msg_prefix, indent_spaces); vfprintf(stream, trformat, ap); fputc('\n', stream); } va_end(ap); } if ((level > debug_level()) || (level >= _LOG_DEBUG && !debug_class_is_logged(dm_errno_or_class))) { if (fatal_internal_error) abort(); return; } if (_log_to_file && (_log_while_suspended || !critical_section())) { fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(), _msg_prefix); va_start(ap, format); vfprintf(_log_file, trformat, ap); va_end(ap); fputc('\n', _log_file); fflush(_log_file); } if (_syslog && (_log_while_suspended || !critical_section())) { va_start(ap, format); vsyslog(level, trformat, ap); va_end(ap); } if (fatal_internal_error) abort(); /* FIXME This code is unfinished - pre-extend & condense. */ if (!_already_logging && _log_direct && critical_section()) { _already_logging = 1; memset(&buf, ' ', sizeof(buf)); bufused = 0; if ((n = dm_snprintf(buf, sizeof(buf), "%s:%d %s%s", file, line, log_command_name(), _msg_prefix)) == -1) goto done; bufused += n; /* n does not include '\0' */ va_start(ap, format); n = vsnprintf(buf + bufused, sizeof(buf) - bufused, trformat, ap); va_end(ap); if (n < 0) goto done; bufused += n; if (n >= sizeof(buf)) bufused = sizeof(buf) - 1; done: buf[bufused] = '\n'; buf[sizeof(buf) - 1] = '\n'; /* FIXME real size bufused */ dev_append(&_log_dev, sizeof(buf), buf); _already_logging = 0; } }
void print_log(int level, const char *file, int line, int dm_errno, const char *format, ...) { va_list ap; char buf[1024], locn[4096]; int bufused, n; const char *message; const char *trformat; /* Translated format string */ char *newbuf; int use_stderr = level & _LOG_STDERR; int log_once = level & _LOG_ONCE; int fatal_internal_error = 0; size_t msglen; level &= ~(_LOG_STDERR|_LOG_ONCE); if (_abort_on_internal_errors && !strncmp(format, INTERNAL_ERROR, strlen(INTERNAL_ERROR))) { fatal_internal_error = 1; /* Internal errors triggering abort cannot be suppressed. */ _log_suppress = 0; level = _LOG_FATAL; } if (_log_suppress == 2) return; if (level <= _LOG_ERR) init_error_message_produced(1); trformat = _(format); if (dm_errno && !_lvm_errno) _lvm_errno = dm_errno; if (_lvm2_log_fn || (_store_errmsg && (level <= _LOG_ERR)) || log_once) { va_start(ap, format); n = vsnprintf(locn, sizeof(locn) - 1, trformat, ap); va_end(ap); if (n < 0) { fprintf(stderr, _("vsnprintf failed: skipping external " "logging function")); goto log_it; } locn[sizeof(locn) - 1] = '\0'; message = locn; } /* FIXME Avoid pointless use of message buffer when it'll never be read! */ if (_store_errmsg && (level <= _LOG_ERR) && _lvm_errmsg_len < MAX_ERRMSG_LEN) { msglen = strlen(message); if ((_lvm_errmsg_len + msglen + 1) >= _lvm_errmsg_size) { _lvm_errmsg_size = 2 * (_lvm_errmsg_len + msglen + 1); if ((newbuf = dm_realloc(_lvm_errmsg, _lvm_errmsg_size))) _lvm_errmsg = newbuf; else _lvm_errmsg_size = _lvm_errmsg_len; } if (_lvm_errmsg && (_lvm_errmsg_len + msglen + 2) < _lvm_errmsg_size) { /* prepend '\n' and copy with '\0' but do not count in */ if (_lvm_errmsg_len) _lvm_errmsg[_lvm_errmsg_len++] = '\n'; memcpy(_lvm_errmsg + _lvm_errmsg_len, message, msglen + 1); _lvm_errmsg_len += msglen; } } if (log_once) { if (!_duplicated) _duplicated = dm_hash_create(128); if (_duplicated) { if (dm_hash_lookup(_duplicated, message)) level = _LOG_NOTICE; (void) dm_hash_insert(_duplicated, message, (void*)1); } } if (_lvm2_log_fn) { _lvm2_log_fn(level, file, line, 0, message); if (fatal_internal_error) abort(); return; } log_it: if (!_log_suppress) { if (verbose_level() > _LOG_DEBUG) (void) dm_snprintf(locn, sizeof(locn), "#%s:%d ", file, line); else locn[0] = '\0'; va_start(ap, format); switch (level) { case _LOG_DEBUG: if (!strcmp("<backtrace>", format) && verbose_level() <= _LOG_DEBUG) break; if (verbose_level() >= _LOG_DEBUG) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); if (_indent) fprintf(stderr, " "); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_INFO: if (verbose_level() >= _LOG_INFO) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); if (_indent) fprintf(stderr, " "); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_NOTICE: if (verbose_level() >= _LOG_NOTICE) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); if (_indent) fprintf(stderr, " "); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_WARN: if (verbose_level() >= _LOG_WARN) { fprintf(use_stderr ? stderr : stdout, "%s%s", log_command_name(), _msg_prefix); vfprintf(use_stderr ? stderr : stdout, trformat, ap); fputc('\n', use_stderr ? stderr : stdout); } break; case _LOG_ERR: if (verbose_level() >= _LOG_ERR) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; case _LOG_FATAL: default: if (verbose_level() >= _LOG_FATAL) { fprintf(stderr, "%s%s%s", locn, log_command_name(), _msg_prefix); vfprintf(stderr, trformat, ap); fputc('\n', stderr); } break; } va_end(ap); } if (level > debug_level()) return; if (_log_to_file && (_log_while_suspended || !critical_section())) { fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(), _msg_prefix); va_start(ap, format); vfprintf(_log_file, trformat, ap); va_end(ap); fprintf(_log_file, "\n"); fflush(_log_file); } if (_syslog && (_log_while_suspended || !critical_section())) { va_start(ap, format); vsyslog(level, trformat, ap); va_end(ap); } if (fatal_internal_error) abort(); /* FIXME This code is unfinished - pre-extend & condense. */ if (!_already_logging && _log_direct && critical_section()) { _already_logging = 1; memset(&buf, ' ', sizeof(buf)); bufused = 0; if ((n = dm_snprintf(buf, sizeof(buf) - 1, "%s:%d %s%s", file, line, log_command_name(), _msg_prefix)) == -1) goto done; bufused += n; va_start(ap, format); n = vsnprintf(buf + bufused - 1, sizeof(buf) - bufused - 1, trformat, ap); va_end(ap); bufused += n; buf[bufused - 1] = '\n'; done: buf[bufused] = '\n'; buf[sizeof(buf) - 1] = '\n'; /* FIXME real size bufused */ dev_append(&_log_dev, sizeof(buf), buf); _already_logging = 0; } }
static int _init_cluster(void) { cs_error_t err; node_hash = dm_hash_create(100); err = cpg_initialize(&cpg_handle, &corosync_cpg_callbacks); if (err != CS_OK) { syslog(LOG_ERR, "Cannot initialise Corosync CPG service: %d", err); DEBUGLOG("Cannot initialise Corosync CPG service: %d", err); return cs_to_errno(err); } err = quorum_initialize(&quorum_handle, &quorum_callbacks); if (err != CS_OK) { syslog(LOG_ERR, "Cannot initialise Corosync quorum service: %d", err); DEBUGLOG("Cannot initialise Corosync quorum service: %d", err); return cs_to_errno(err); } /* Create a lockspace for LV & VG locks to live in */ lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600); if (!lockspace) { if (errno == EEXIST) { lockspace = dlm_open_lockspace(LOCKSPACE_NAME); } if (!lockspace) { syslog(LOG_ERR, "Unable to create lockspace for CLVM: %m"); quorum_finalize(quorum_handle); return -1; } } dlm_ls_pthread_init(lockspace); DEBUGLOG("DLM initialisation complete\n"); /* Connect to the clvmd group */ strcpy((char *)cpg_group_name.value, "clvmd"); cpg_group_name.length = strlen((char *)cpg_group_name.value); err = cpg_join(cpg_handle, &cpg_group_name); if (err != CS_OK) { cpg_finalize(cpg_handle); quorum_finalize(quorum_handle); dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1); syslog(LOG_ERR, "Cannot join clvmd process group"); DEBUGLOG("Cannot join clvmd process group: %d\n", err); return cs_to_errno(err); } err = cpg_local_get(cpg_handle, &our_nodeid); if (err != CS_OK) { cpg_finalize(cpg_handle); quorum_finalize(quorum_handle); dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1); syslog(LOG_ERR, "Cannot get local node id\n"); return cs_to_errno(err); } DEBUGLOG("Our local node id is %d\n", our_nodeid); DEBUGLOG("Connected to Corosync\n"); return 0; }
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; }