#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
+#include <stdbool.h>
/* Plugin name */
#define PLUGIN_NAME "virt"
pthread_t event_loop_tid;
int domain_event_cb_id;
pthread_mutex_t active_mutex; /* protects 'is_active' member access*/
- _Bool is_active;
+ bool is_active;
} virt_notif_thread_t;
static const char *config_keys[] = {"Connection",
NULL};
/* PersistentNotification is false by default */
-static _Bool persistent_notification = 0;
+static bool persistent_notification = false;
/* Thread used for handling libvirt notifications events */
static virt_notif_thread_t notif_thread;
} while (0)
/* Connection. */
-static virConnectPtr conn = 0;
-static char *conn_string = NULL;
+static virConnectPtr conn;
+static char *conn_string;
static c_complain_t conn_complain = C_COMPLAIN_INIT_STATIC;
/* Node information required for %CPU */
static int interval = 60;
/* List of domains, if specified. */
-static ignorelist_t *il_domains = NULL;
+static ignorelist_t *il_domains;
/* List of block devices, if specified. */
-static ignorelist_t *il_block_devices = NULL;
+static ignorelist_t *il_block_devices;
/* List of network interface devices, if specified. */
-static ignorelist_t *il_interface_devices = NULL;
+static ignorelist_t *il_interface_devices;
static int ignore_device_match(ignorelist_t *, const char *domname,
const char *devpath);
typedef struct domain_s {
virDomainPtr ptr;
virDomainInfo info;
- _Bool active;
+ bool active;
} domain_t;
struct lv_read_state {
static void free_domains(struct lv_read_state *state);
static int add_domain(struct lv_read_state *state, virDomainPtr dom,
- _Bool active);
+ bool active);
static void free_block_devices(struct lv_read_state *state);
static int add_block_device(struct lv_read_state *state, virDomainPtr dom,
};
/* BlockDeviceFormatBasename */
-_Bool blockdevice_format_basename = 0;
+static bool blockdevice_format_basename;
static enum bd_field blockdevice_format = target;
static enum if_field interface_format = if_name;
}
static void domain_state_submit_notif(virDomainPtr dom, int state, int reason) {
- if ((state < 0) || (state >= STATIC_ARRAY_SIZE(domain_states))) {
+ if ((state < 0) || ((size_t)state >= STATIC_ARRAY_SIZE(domain_states))) {
ERROR(PLUGIN_NAME ": Array index out of bounds: state=%d", state);
return;
}
char msg[DATA_MAX_NAME_LEN];
const char *state_str = domain_states[state];
#ifdef HAVE_DOM_REASON
- if ((reason < 0) || (reason >= STATIC_ARRAY_SIZE(domain_reasons[0]))) {
+ if ((reason < 0) ||
+ ((size_t)reason >= STATIC_ARRAY_SIZE(domain_reasons[0]))) {
ERROR(PLUGIN_NAME ": Array index out of bounds: reason=%d", reason);
return;
}
return 0;
}
if (strcasecmp(key, "BlockDeviceFormatBasename") == 0) {
- blockdevice_format_basename = IS_TRUE(value);
+ blockdevice_format_basename = IS_TRUE(value) ? true : false;
return 0;
}
if (strcasecmp(key, "InterfaceDevice") == 0) {
unsigned char *cpu_maps, int cpu_map_len) {
for (int cpu = 0; cpu < max_cpus; ++cpu) {
char type_instance[DATA_MAX_NAME_LEN];
- _Bool is_set = VIR_CPU_USABLE(cpu_maps, cpu_map_len, vcpu, cpu) ? 1 : 0;
+ bool is_set = VIR_CPU_USABLE(cpu_maps, cpu_map_len, vcpu, cpu);
snprintf(type_instance, sizeof(type_instance), "vcpu_%d-cpu_%d", vcpu, cpu);
submit(dom, "cpu_affinity", type_instance, &(value_t){.gauge = is_set}, 1);
#define NM_ADD_STR_ITEMS(_items, _size) \
do { \
- for (int _i = 0; _i < _size; ++_i) { \
+ for (size_t _i = 0; _i < _size; ++_i) { \
DEBUG(PLUGIN_NAME \
" plugin: Adding notification metadata name=%s value=%s", \
_items[_i].name, _items[_i].value); \
{.name = "name", .value = fs_info->name},
{.name = "fstype", .value = fs_info->fstype}};
- for (int i = 0; i < fs_info->ndevAlias; ++i) {
+ for (size_t i = 0; i < fs_info->ndevAlias; ++i) {
fs_dev_alias[i].name = "devAlias";
fs_dev_alias[i].value = fs_info->devAlias[i];
}
return 0;
}
-static int domain_lifecycle_event_cb(__attribute__((unused)) virConnectPtr conn,
+static int domain_lifecycle_event_cb(__attribute__((unused)) virConnectPtr con_,
virDomainPtr dom, int event, int detail,
__attribute__((unused)) void *opaque) {
int domain_state = map_domain_event_to_state(event);
}
static void virt_notif_thread_set_active(virt_notif_thread_t *thread_data,
- const _Bool active) {
+ const bool active) {
assert(thread_data != NULL);
pthread_mutex_lock(&thread_data->active_mutex);
thread_data->is_active = active;
pthread_mutex_unlock(&thread_data->active_mutex);
}
-static _Bool virt_notif_thread_is_active(virt_notif_thread_t *thread_data) {
- _Bool state = 0;
+static bool virt_notif_thread_is_active(virt_notif_thread_t *thread_data) {
+ bool active = false;
assert(thread_data != NULL);
pthread_mutex_lock(&thread_data->active_mutex);
- state = thread_data->is_active;
+ active = thread_data->is_active;
pthread_mutex_unlock(&thread_data->active_mutex);
- return state;
+ return active;
}
/* worker function running default event implementation */
* domain_event_cb_id to '-1'
*/
thread_data->domain_event_cb_id = -1;
- thread_data->is_active = 0;
+ pthread_mutex_lock(&thread_data->active_mutex);
+ thread_data->is_active = false;
+ pthread_mutex_unlock(&thread_data->active_mutex);
return 0;
}
virConnectDomainEventDeregisterAny(conn, thread_data->domain_event_cb_id);
if (pthread_join(notif_thread.event_loop_tid, NULL) != 0)
- ERROR(PLUGIN_NAME " plugin: stopping thread %lu failed",
- notif_thread.event_loop_tid);
+ ERROR(PLUGIN_NAME " plugin: stopping notification thread failed");
}
static int persistent_domains_state_notification(void) {
inst = ud->data;
state = &inst->read_state;
- _Bool reconnect = conn == NULL ? 1 : 0;
+ bool reconnect = conn == NULL ? true : false;
/* event implementation must be registered before connection is opened */
if (inst->id == 0) {
if (!persistent_notification && reconnect)
ERROR(PLUGIN_NAME
" failed to get stats for block device (%s) in domain %s",
state->block_devices[i].path,
- virDomainGetName(state->domains[i].ptr));
+ virDomainGetName(state->block_devices[i].dom));
}
/* Get interface stats for each domain. */
}
static int add_domain(struct lv_read_state *state, virDomainPtr dom,
- _Bool active) {
+ bool active) {
domain_t *new_ptr;
int new_size = sizeof(state->domains[0]) * (state->nr_domains + 1);
struct interface_device *new_ptr;
int new_size =
sizeof(state->interface_devices[0]) * (state->nr_interface_devices + 1);
- char *path_copy, *address_copy, number_string[15];
+ char *path_copy, *address_copy, number_string[21];
if ((path == NULL) || (address == NULL))
return EINVAL;
static int ignore_device_match(ignorelist_t *il, const char *domname,
const char *devpath) {
char *name;
- int n, r;
+ int r;
if ((domname == NULL) || (devpath == NULL))
return 0;
- n = strlen(domname) + strlen(devpath) + 2;
+ size_t n = strlen(domname) + strlen(devpath) + 2;
name = malloc(n);
if (name == NULL) {
ERROR(PLUGIN_NAME " plugin: malloc failed.");
projects / collectd.git / blobdiff