src/virt.c

   1 /**
   2  * collectd - src/virt.c
   3  * Copyright (C) 2006-2008  Red Hat Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the license is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Richard W.M. Jones <rjones@redhat.com>
  20  **/
  21
  22 #include "collectd.h"
  23
  24 #include "common.h"
  25 #include "plugin.h"
  26 #include "utils_complain.h"
  27 #include "utils_ignorelist.h"
  28
  29 #include <libgen.h> /* for basename(3) */
  30 #include <libvirt/libvirt.h>
  31 #include <libvirt/virterror.h>
  32 #include <libxml/parser.h>
  33 #include <libxml/tree.h>
  34 #include <libxml/xpath.h>
  35 #include <libxml/xpathInternals.h>
  36
  37 /* Plugin name */
  38 #define PLUGIN_NAME "virt"
  39
  40 #ifdef LIBVIR_CHECK_VERSION
  41 #if LIBVIR_CHECK_VERSION(0, 9, 5)
  42 #define HAVE_BLOCK_STATS_FLAGS 1
  43 #endif
  44 #endif
  45
  46 static const char *config_keys[] = {"Connection",
  47
  48                                     "RefreshInterval",
  49
  50                                     "Domain",
  51                                     "BlockDevice",
  52                                     "BlockDeviceFormat",
  53                                     "BlockDeviceFormatBasename",
  54                                     "InterfaceDevice",
  55                                     "IgnoreSelected",
  56
  57                                     "HostnameFormat",
  58                                     "InterfaceFormat",
  59
  60                                     "PluginInstanceFormat",
  61
  62                                     "Instances",
  63                                     "ExtraStats",
  64
  65                                     NULL};
  66 #define NR_CONFIG_KEYS ((sizeof config_keys / sizeof config_keys[0]) - 1)
  67
  68 /* Connection. */
  69 static virConnectPtr conn = 0;
  70 static char *conn_string = NULL;
  71 static c_complain_t conn_complain = C_COMPLAIN_INIT_STATIC;
  72
  73 /* Seconds between list refreshes, 0 disables completely. */
  74 static int interval = 60;
  75
  76 /* List of domains, if specified. */
  77 static ignorelist_t *il_domains = NULL;
  78 /* List of block devices, if specified. */
  79 static ignorelist_t *il_block_devices = NULL;
  80 /* List of network interface devices, if specified. */
  81 static ignorelist_t *il_interface_devices = NULL;
  82
  83 static int ignore_device_match(ignorelist_t *, const char *domname,
  84                                const char *devpath);
  85
  86 /* Actual list of block devices found on last refresh. */
  87 struct block_device {
  88   virDomainPtr dom; /* domain */
  89   char *path;       /* name of block device */
  90 };
  91
  92 /* Actual list of network interfaces found on last refresh. */
  93 struct interface_device {
  94   virDomainPtr dom; /* domain */
  95   char *path;       /* name of interface device */
  96   char *address;    /* mac address of interface device */
  97   char *number;     /* interface device number */
  98 };
  99
 100 struct lv_read_state {
 101   /* Actual list of domains found on last refresh. */
 102   virDomainPtr *domains;
 103   int nr_domains;
 104
 105   struct block_device *block_devices;
 106   int nr_block_devices;
 107
 108   struct interface_device *interface_devices;
 109   int nr_interface_devices;
 110 };
 111
 112 static void free_domains(struct lv_read_state *state);
 113 static int add_domain(struct lv_read_state *state, virDomainPtr dom);
 114
 115 static void free_block_devices(struct lv_read_state *state);
 116 static int add_block_device(struct lv_read_state *state, virDomainPtr dom,
 117                             const char *path);
 118
 119 static void free_interface_devices(struct lv_read_state *state);
 120 static int add_interface_device(struct lv_read_state *state, virDomainPtr dom,
 121                                 const char *path, const char *address,
 122                                 unsigned int number);
 123
 124 #define METADATA_VM_PARTITION_URI "http://ovirt.org/ovirtmap/tag/1.0"
 125 #define METADATA_VM_PARTITION_ELEMENT "tag"
 126 #define METADATA_VM_PARTITION_PREFIX "ovirtmap"
 127
 128 #define BUFFER_MAX_LEN 256
 129 #define PARTITION_TAG_MAX_LEN 32
 130
 131 struct lv_read_instance {
 132   struct lv_read_state read_state;
 133   char tag[PARTITION_TAG_MAX_LEN];
 134   size_t id;
 135 };
 136
 137 struct lv_user_data {
 138   struct lv_read_instance inst;
 139   user_data_t ud;
 140 };
 141
 142 #define NR_INSTANCES_DEFAULT 1
 143 #define NR_INSTANCES_MAX 128
 144 static int nr_instances = NR_INSTANCES_DEFAULT;
 145 static struct lv_user_data lv_read_user_data[NR_INSTANCES_MAX];
 146
 147 /* HostnameFormat. */
 148 #define HF_MAX_FIELDS 3
 149
 150 enum hf_field { hf_none = 0, hf_hostname, hf_name, hf_uuid };
 151
 152 static enum hf_field hostname_format[HF_MAX_FIELDS] = {hf_name};
 153
 154 /* PluginInstanceFormat */
 155 #define PLGINST_MAX_FIELDS 2
 156
 157 enum plginst_field { plginst_none = 0, plginst_name, plginst_uuid };
 158
 159 static enum plginst_field plugin_instance_format[PLGINST_MAX_FIELDS] = {
 160     plginst_none};
 161
 162 /* BlockDeviceFormat */
 163 enum bd_field { target, source };
 164
 165 /* InterfaceFormat. */
 166 enum if_field { if_address, if_name, if_number };
 167
 168 /* ExtraStats */
 169 #define EX_STATS_MAX_FIELDS 8
 170 #define EX_STATS_DISK "disk"
 171 enum ex_stats { ex_stats_none = 0, ex_stats_disk = 1 };
 172 static enum ex_stats extra_stats = ex_stats_none;
 173
 174 /* BlockDeviceFormatBasename */
 175 _Bool blockdevice_format_basename = 0;
 176 static enum bd_field blockdevice_format = target;
 177 static enum if_field interface_format = if_name;
 178
 179 /* Time that we last refreshed. */
 180 static time_t last_refresh = (time_t)0;
 181
 182 static int refresh_lists(struct lv_read_instance *inst);
 183
 184 struct lv_block_info {
 185   virDomainBlockStatsStruct bi;
 186
 187   long long rd_total_times;
 188   long long wr_total_times;
 189
 190   long long fl_req;
 191   long long fl_total_times;
 192 };
 193
 194 static void init_block_info(struct lv_block_info *binfo) {
 195   if (binfo == NULL)
 196     return;
 197
 198   binfo->bi.rd_req = -1;
 199   binfo->bi.wr_req = -1;
 200   binfo->bi.rd_bytes = -1;
 201   binfo->bi.wr_bytes = -1;
 202
 203   binfo->rd_total_times = -1;
 204   binfo->wr_total_times = -1;
 205   binfo->fl_req = -1;
 206   binfo->fl_total_times = -1;
 207 }
 208
 209 #ifdef HAVE_BLOCK_STATS_FLAGS
 210
 211 #define GET_BLOCK_INFO_VALUE(NAME, FIELD)                                      \
 212   do {                                                                         \
 213     if (!strcmp(param[i].field, NAME)) {                                       \
 214       binfo->FIELD = param[i].value.l;                                         \
 215       continue;                                                                \
 216     }                                                                          \
 217   } while (0)
 218
 219 static int get_block_info(struct lv_block_info *binfo,
 220                           virTypedParameterPtr param, int nparams) {
 221   if (binfo == NULL || param == NULL)
 222     return -1;
 223
 224   for (int i = 0; i < nparams; ++i) {
 225     /* ignore type. Everything must be LLONG anyway. */
 226     GET_BLOCK_INFO_VALUE("rd_operations", bi.rd_req);
 227     GET_BLOCK_INFO_VALUE("wr_operations", bi.wr_req);
 228     GET_BLOCK_INFO_VALUE("rd_bytes", bi.rd_bytes);
 229     GET_BLOCK_INFO_VALUE("wr_bytes", bi.wr_bytes);
 230     GET_BLOCK_INFO_VALUE("rd_total_times", rd_total_times);
 231     GET_BLOCK_INFO_VALUE("wr_total_times", wr_total_times);
 232     GET_BLOCK_INFO_VALUE("flush_operations", fl_req);
 233     GET_BLOCK_INFO_VALUE("flush_total_times", fl_total_times);
 234   }
 235
 236   return 0;
 237 }
 238
 239 #undef GET_BLOCK_INFO_VALUE
 240
 241 #endif /* HAVE_BLOCK_STATS_FLAGS */
 242
 243 /* ERROR(...) macro for virterrors. */
 244 #define VIRT_ERROR(conn, s)                                                    \
 245   do {                                                                         \
 246     virErrorPtr err;                                                           \
 247     err = (conn) ? virConnGetLastError((conn)) : virGetLastError();            \
 248     if (err)                                                                   \
 249       ERROR("%s: %s", (s), err->message);                                      \
 250   } while (0)
 251
 252 static void init_value_list(value_list_t *vl, virDomainPtr dom) {
 253   int n;
 254   const char *name;
 255   char uuid[VIR_UUID_STRING_BUFLEN];
 256
 257   sstrncpy(vl->plugin, PLUGIN_NAME, sizeof(vl->plugin));
 258
 259   vl->host[0] = '\0';
 260
 261   /* Construct the hostname field according to HostnameFormat. */
 262   for (int i = 0; i < HF_MAX_FIELDS; ++i) {
 263     if (hostname_format[i] == hf_none)
 264       continue;
 265
 266     n = DATA_MAX_NAME_LEN - strlen(vl->host) - 2;
 267
 268     if (i > 0 && n >= 1) {
 269       strncat(vl->host, ":", 1);
 270       n--;
 271     }
 272
 273     switch (hostname_format[i]) {
 274     case hf_none:
 275       break;
 276     case hf_hostname:
 277       strncat(vl->host, hostname_g, n);
 278       break;
 279     case hf_name:
 280       name = virDomainGetName(dom);
 281       if (name)
 282         strncat(vl->host, name, n);
 283       break;
 284     case hf_uuid:
 285       if (virDomainGetUUIDString(dom, uuid) == 0)
 286         strncat(vl->host, uuid, n);
 287       break;
 288     }
 289   }
 290
 291   vl->host[sizeof(vl->host) - 1] = '\0';
 292
 293   /* Construct the plugin instance field according to PluginInstanceFormat. */
 294   for (int i = 0; i < PLGINST_MAX_FIELDS; ++i) {
 295     if (plugin_instance_format[i] == plginst_none)
 296       continue;
 297
 298     n = sizeof(vl->plugin_instance) - strlen(vl->plugin_instance) - 2;
 299
 300     if (i > 0 && n >= 1) {
 301       strncat(vl->plugin_instance, ":", 1);
 302       n--;
 303     }
 304
 305     switch (plugin_instance_format[i]) {
 306     case plginst_none:
 307       break;
 308     case plginst_name:
 309       name = virDomainGetName(dom);
 310       if (name)
 311         strncat(vl->plugin_instance, name, n);
 312       break;
 313     case plginst_uuid:
 314       if (virDomainGetUUIDString(dom, uuid) == 0)
 315         strncat(vl->plugin_instance, uuid, n);
 316       break;
 317     }
 318   }
 319
 320   vl->plugin_instance[sizeof(vl->plugin_instance) - 1] = '\0';
 321
 322 } /* void init_value_list */
 323
 324 static void submit(virDomainPtr dom, char const *type,
 325                    char const *type_instance, value_t *values,
 326                    size_t values_len) {
 327   value_list_t vl = VALUE_LIST_INIT;
 328   init_value_list(&vl, dom);
 329
 330   vl.values = values;
 331   vl.values_len = values_len;
 332
 333   sstrncpy(vl.type, type, sizeof(vl.type));
 334   if (type_instance != NULL)
 335     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 336
 337   plugin_dispatch_values(&vl);
 338 }
 339
 340 static void memory_submit(gauge_t value, virDomainPtr dom) {
 341   submit(dom, "memory", "total", &(value_t){.gauge = value}, 1);
 342 }
 343
 344 static void memory_stats_submit(gauge_t value, virDomainPtr dom,
 345                                 int tag_index) {
 346   static const char *tags[] = {"swap_in",        "swap_out", "major_fault",
 347                                "minor_fault",    "unused",   "available",
 348                                "actual_balloon", "rss"};
 349
 350   if ((tag_index < 0) || (tag_index >= STATIC_ARRAY_SIZE(tags))) {
 351     ERROR("virt plugin: Array index out of bounds: tag_index = %d", tag_index);
 352     return;
 353   }
 354
 355   submit(dom, "memory", tags[tag_index], &(value_t){.gauge = value}, 1);
 356 }
 357
 358 static void cpu_submit(unsigned long long value, virDomainPtr dom,
 359                        const char *type) {
 360   submit(dom, type, NULL, &(value_t){.derive = (derive_t)value}, 1);
 361 }
 362
 363 static void vcpu_submit(derive_t value, virDomainPtr dom, int vcpu_nr,
 364                         const char *type) {
 365   char type_instance[DATA_MAX_NAME_LEN];
 366
 367   ssnprintf(type_instance, sizeof(type_instance), "%d", vcpu_nr);
 368
 369   submit(dom, type, type_instance, &(value_t){.derive = value}, 1);
 370 }
 371
 372 static void submit_derive2(const char *type, derive_t v0, derive_t v1,
 373                            virDomainPtr dom, const char *devname) {
 374   value_t values[] = {
 375       {.derive = v0}, {.derive = v1},
 376   };
 377
 378   submit(dom, type, devname, values, STATIC_ARRAY_SIZE(values));
 379 } /* void submit_derive2 */
 380
 381 static void disk_submit(struct lv_block_info *binfo, virDomainPtr dom,
 382                         const char *type_instance) {
 383   char flush_type_instance[DATA_MAX_NAME_LEN];
 384
 385   ssnprintf(flush_type_instance, sizeof(flush_type_instance), "flush-%s",
 386             type_instance);
 387
 388   if ((binfo->bi.rd_req != -1) && (binfo->bi.wr_req != -1))
 389     submit_derive2("disk_ops", (derive_t)binfo->bi.rd_req,
 390                    (derive_t)binfo->bi.wr_req, dom, type_instance);
 391
 392   if ((binfo->bi.rd_bytes != -1) && (binfo->bi.wr_bytes != -1))
 393     submit_derive2("disk_octets", (derive_t)binfo->bi.rd_bytes,
 394                    (derive_t)binfo->bi.wr_bytes, dom, type_instance);
 395
 396   if (extra_stats & ex_stats_disk) {
 397     if ((binfo->rd_total_times != -1) && (binfo->wr_total_times != -1))
 398       submit_derive2("disk_time", (derive_t)binfo->rd_total_times,
 399                      (derive_t)binfo->wr_total_times, dom, type_instance);
 400
 401     if (binfo->fl_req != -1)
 402       submit(dom, "total_requests", flush_type_instance,
 403              &(value_t){.derive = (derive_t)binfo->fl_req}, 1);
 404     if (binfo->fl_total_times != -1) {
 405       derive_t value = binfo->fl_total_times / 1000; // ns -> ms
 406       submit(dom, "total_time_in_ms", flush_type_instance,
 407              &(value_t){.derive = value}, 1);
 408     }
 409   }
 410 }
 411
 412 static int lv_config(const char *key, const char *value) {
 413   if (virInitialize() != 0)
 414     return 1;
 415
 416   if (il_domains == NULL)
 417     il_domains = ignorelist_create(1);
 418   if (il_block_devices == NULL)
 419     il_block_devices = ignorelist_create(1);
 420   if (il_interface_devices == NULL)
 421     il_interface_devices = ignorelist_create(1);
 422
 423   if (strcasecmp(key, "Connection") == 0) {
 424     char *tmp = strdup(value);
 425     if (tmp == NULL) {
 426       ERROR(PLUGIN_NAME " plugin: Connection strdup failed.");
 427       return 1;
 428     }
 429     sfree(conn_string);
 430     conn_string = tmp;
 431     return 0;
 432   }
 433
 434   if (strcasecmp(key, "RefreshInterval") == 0) {
 435     char *eptr = NULL;
 436     interval = strtol(value, &eptr, 10);
 437     if (eptr == NULL || *eptr != '\0')
 438       return 1;
 439     return 0;
 440   }
 441
 442   if (strcasecmp(key, "Domain") == 0) {
 443     if (ignorelist_add(il_domains, value))
 444       return 1;
 445     return 0;
 446   }
 447   if (strcasecmp(key, "BlockDevice") == 0) {
 448     if (ignorelist_add(il_block_devices, value))
 449       return 1;
 450     return 0;
 451   }
 452
 453   if (strcasecmp(key, "BlockDeviceFormat") == 0) {
 454     if (strcasecmp(value, "target") == 0)
 455       blockdevice_format = target;
 456     else if (strcasecmp(value, "source") == 0)
 457       blockdevice_format = source;
 458     else {
 459       ERROR(PLUGIN_NAME " plugin: unknown BlockDeviceFormat: %s", value);
 460       return -1;
 461     }
 462     return 0;
 463   }
 464   if (strcasecmp(key, "BlockDeviceFormatBasename") == 0) {
 465     blockdevice_format_basename = IS_TRUE(value);
 466     return 0;
 467   }
 468   if (strcasecmp(key, "InterfaceDevice") == 0) {
 469     if (ignorelist_add(il_interface_devices, value))
 470       return 1;
 471     return 0;
 472   }
 473
 474   if (strcasecmp(key, "IgnoreSelected") == 0) {
 475     if (IS_TRUE(value)) {
 476       ignorelist_set_invert(il_domains, 0);
 477       ignorelist_set_invert(il_block_devices, 0);
 478       ignorelist_set_invert(il_interface_devices, 0);
 479     } else {
 480       ignorelist_set_invert(il_domains, 1);
 481       ignorelist_set_invert(il_block_devices, 1);
 482       ignorelist_set_invert(il_interface_devices, 1);
 483     }
 484     return 0;
 485   }
 486
 487   if (strcasecmp(key, "HostnameFormat") == 0) {
 488     char *value_copy;
 489     char *fields[HF_MAX_FIELDS];
 490     int n;
 491
 492     value_copy = strdup(value);
 493     if (value_copy == NULL) {
 494       ERROR(PLUGIN_NAME " plugin: strdup failed.");
 495       return -1;
 496     }
 497
 498     n = strsplit(value_copy, fields, HF_MAX_FIELDS);
 499     if (n < 1) {
 500       sfree(value_copy);
 501       ERROR(PLUGIN_NAME " plugin: HostnameFormat: no fields");
 502       return -1;
 503     }
 504
 505     for (int i = 0; i < n; ++i) {
 506       if (strcasecmp(fields[i], "hostname") == 0)
 507         hostname_format[i] = hf_hostname;
 508       else if (strcasecmp(fields[i], "name") == 0)
 509         hostname_format[i] = hf_name;
 510       else if (strcasecmp(fields[i], "uuid") == 0)
 511         hostname_format[i] = hf_uuid;
 512       else {
 513         ERROR(PLUGIN_NAME " plugin: unknown HostnameFormat field: %s",
 514               fields[i]);
 515         sfree(value_copy);
 516         return -1;
 517       }
 518     }
 519     sfree(value_copy);
 520
 521     for (int i = n; i < HF_MAX_FIELDS; ++i)
 522       hostname_format[i] = hf_none;
 523
 524     return 0;
 525   }
 526
 527   if (strcasecmp(key, "PluginInstanceFormat") == 0) {
 528     char *value_copy;
 529     char *fields[PLGINST_MAX_FIELDS];
 530     int n;
 531
 532     value_copy = strdup(value);
 533     if (value_copy == NULL) {
 534       ERROR(PLUGIN_NAME " plugin: strdup failed.");
 535       return -1;
 536     }
 537
 538     n = strsplit(value_copy, fields, PLGINST_MAX_FIELDS);
 539     if (n < 1) {
 540       sfree(value_copy);
 541       ERROR(PLUGIN_NAME " plugin: PluginInstanceFormat: no fields");
 542       return -1;
 543     }
 544
 545     for (int i = 0; i < n; ++i) {
 546       if (strcasecmp(fields[i], "none") == 0) {
 547         plugin_instance_format[i] = plginst_none;
 548         break;
 549       } else if (strcasecmp(fields[i], "name") == 0)
 550         plugin_instance_format[i] = plginst_name;
 551       else if (strcasecmp(fields[i], "uuid") == 0)
 552         plugin_instance_format[i] = plginst_uuid;
 553       else {
 554         ERROR(PLUGIN_NAME " plugin: unknown PluginInstanceFormat field: %s",
 555               fields[i]);
 556         sfree(value_copy);
 557         return -1;
 558       }
 559     }
 560     sfree(value_copy);
 561
 562     for (int i = n; i < PLGINST_MAX_FIELDS; ++i)
 563       plugin_instance_format[i] = plginst_none;
 564
 565     return 0;
 566   }
 567
 568   if (strcasecmp(key, "InterfaceFormat") == 0) {
 569     if (strcasecmp(value, "name") == 0)
 570       interface_format = if_name;
 571     else if (strcasecmp(value, "address") == 0)
 572       interface_format = if_address;
 573     else if (strcasecmp(value, "number") == 0)
 574       interface_format = if_number;
 575     else {
 576       ERROR(PLUGIN_NAME " plugin: unknown InterfaceFormat: %s", value);
 577       return -1;
 578     }
 579     return 0;
 580   }
 581
 582   if (strcasecmp(key, "Instances") == 0) {
 583     char *eptr = NULL;
 584     double val = strtod(value, &eptr);
 585
 586     if (*eptr != '\0') {
 587       ERROR(PLUGIN_NAME " plugin: Invalid value for Instances = '%s'", value);
 588       return 1;
 589     }
 590     if (val <= 0) {
 591       ERROR(PLUGIN_NAME " plugin: Instances <= 0 makes no sense.");
 592       return 1;
 593     }
 594     if (val > NR_INSTANCES_MAX) {
 595       ERROR(PLUGIN_NAME " plugin: Instances=%f > NR_INSTANCES_MAX=%i"
 596                         " use a lower setting or recompile the plugin.",
 597             val, NR_INSTANCES_MAX);
 598       return 1;
 599     }
 600
 601     nr_instances = (int)val;
 602     DEBUG(PLUGIN_NAME " plugin: configured %i instances", nr_instances);
 603     return 0;
 604   }
 605
 606   if (strcasecmp(key, "ExtraStats") == 0) {
 607     char *localvalue = sstrdup(value);
 608     if (localvalue != NULL) {
 609       char *exstats[EX_STATS_MAX_FIELDS];
 610       int numexstats =
 611           strsplit(localvalue, exstats, STATIC_ARRAY_SIZE(exstats));
 612       for (int i = 0; i < numexstats; i++) {
 613         if (strcasecmp(exstats[i], EX_STATS_DISK) == 0) {
 614           DEBUG(PLUGIN_NAME " plugin: enabling extra stats for '%s'",
 615                 EX_STATS_DISK);
 616           extra_stats |= ex_stats_disk;
 617         }
 618       }
 619       sfree(localvalue);
 620     }
 621   }
 622
 623   /* Unrecognised option. */
 624   return -1;
 625 }
 626
 627 static int lv_connect(void) {
 628   if (conn == NULL) {
 629     /* `conn_string == NULL' is acceptable. */
 630     conn = virConnectOpenReadOnly(conn_string);
 631     if (conn == NULL) {
 632       c_complain(LOG_ERR, &conn_complain,
 633                  PLUGIN_NAME " plugin: Unable to connect: "
 634                              "virConnectOpenReadOnly failed.");
 635       return -1;
 636     }
 637   }
 638   c_release(LOG_NOTICE, &conn_complain,
 639             PLUGIN_NAME " plugin: Connection established.");
 640   return 0;
 641 }
 642
 643 static void lv_disconnect(void) {
 644   if (conn != NULL)
 645     virConnectClose(conn);
 646   conn = NULL;
 647   WARNING(PLUGIN_NAME " plugin: closed connection to libvirt");
 648 }
 649
 650 static int lv_domain_block_info(virDomainPtr dom, const char *path,
 651                                 struct lv_block_info *binfo) {
 652 #ifdef HAVE_BLOCK_STATS_FLAGS
 653   virTypedParameterPtr params = NULL;
 654   int nparams = 0;
 655   int rc = -1;
 656   int ret = virDomainBlockStatsFlags(dom, path, NULL, &nparams, 0);
 657   if (ret < 0 || nparams == 0) {
 658     VIRT_ERROR(conn, "getting the disk params count");
 659     return -1;
 660   }
 661
 662   params = calloc(nparams, sizeof(virTypedParameter));
 663   if (params == NULL) {
 664     ERROR("virt plugin: alloc(%i) for block=%s parameters failed.", nparams,
 665           path);
 666     return -1;
 667   }
 668   ret = virDomainBlockStatsFlags(dom, path, params, &nparams, 0);
 669   if (ret < 0) {
 670     VIRT_ERROR(conn, "getting the disk params values");
 671     goto done;
 672   }
 673
 674   rc = get_block_info(binfo, params, nparams);
 675
 676 done:
 677   virTypedParamsFree(params, nparams);
 678   return rc;
 679 #else
 680   return virDomainBlockStats(dom, path, &(binfo->bi), sizeof(binfo->bi));
 681 #endif /* HAVE_BLOCK_STATS_FLAGS */
 682 }
 683
 684 static int lv_read(user_data_t *ud) {
 685   time_t t;
 686   struct lv_read_instance *inst = NULL;
 687   struct lv_read_state *state = NULL;
 688
 689   if (ud->data == NULL) {
 690     ERROR(PLUGIN_NAME " plugin: NULL userdata");
 691     return -1;
 692   }
 693
 694   inst = ud->data;
 695   state = &inst->read_state;
 696
 697   if (inst->id == 0) {
 698     if (lv_connect() < 0)
 699       return -1;
 700   }
 701
 702   time(&t);
 703
 704   /* Need to refresh domain or device lists? */
 705   if ((last_refresh == (time_t)0) ||
 706       ((interval > 0) && ((last_refresh + interval) <= t))) {
 707     if (refresh_lists(inst) != 0) {
 708       if (inst->id == 0)
 709         lv_disconnect();
 710       return -1;
 711     }
 712     last_refresh = t;
 713   }
 714
 715 #if 0
 716     for (int i = 0; i < nr_domains; ++i)
 717         fprintf (stderr, "domain %s\n", virDomainGetName (domains[i]));
 718     for (int i = 0; i < nr_block_devices; ++i)
 719         fprintf  (stderr, "block device %d %s:%s\n",
 720                   i, virDomainGetName (block_devices[i].dom),
 721                   block_devices[i].path);
 722     for (int i = 0; i < nr_interface_devices; ++i)
 723         fprintf (stderr, "interface device %d %s:%s\n",
 724                  i, virDomainGetName (interface_devices[i].dom),
 725                  interface_devices[i].path);
 726 #endif
 727
 728   /* Get CPU usage, memory, VCPU usage for each domain. */
 729   for (int i = 0; i < state->nr_domains; ++i) {
 730     virDomainInfo info;
 731     virVcpuInfoPtr vinfo = NULL;
 732     virDomainMemoryStatPtr minfo = NULL;
 733     int status;
 734
 735     status = virDomainGetInfo(state->domains[i], &info);
 736     if (status != 0) {
 737       ERROR(PLUGIN_NAME " plugin: virDomainGetInfo failed with status %i.",
 738             status);
 739       continue;
 740     }
 741
 742     if (info.state != VIR_DOMAIN_RUNNING) {
 743       /* only gather stats for running domains */
 744       continue;
 745     }
 746
 747     cpu_submit(info.cpuTime, state->domains[i], "virt_cpu_total");
 748     memory_submit((gauge_t)info.memory * 1024, state->domains[i]);
 749
 750     vinfo = malloc(info.nrVirtCpu * sizeof(vinfo[0]));
 751     if (vinfo == NULL) {
 752       ERROR(PLUGIN_NAME " plugin: malloc failed.");
 753       continue;
 754     }
 755
 756     status = virDomainGetVcpus(state->domains[i], vinfo, info.nrVirtCpu,
 757                                /* cpu map = */ NULL, /* cpu map length = */ 0);
 758     if (status < 0) {
 759       ERROR(PLUGIN_NAME " plugin: virDomainGetVcpus failed with status %i.",
 760             status);
 761       sfree(vinfo);
 762       continue;
 763     }
 764
 765     for (int j = 0; j < info.nrVirtCpu; ++j)
 766       vcpu_submit(vinfo[j].cpuTime, state->domains[i], vinfo[j].number,
 767                   "virt_vcpu");
 768
 769     sfree(vinfo);
 770
 771     minfo =
 772         malloc(VIR_DOMAIN_MEMORY_STAT_NR * sizeof(virDomainMemoryStatStruct));
 773     if (minfo == NULL) {
 774       ERROR("virt plugin: malloc failed.");
 775       continue;
 776     }
 777
 778     status = virDomainMemoryStats(state->domains[i], minfo,
 779                                   VIR_DOMAIN_MEMORY_STAT_NR, 0);
 780
 781     if (status < 0) {
 782       ERROR("virt plugin: virDomainMemoryStats failed with status %i.", status);
 783       sfree(minfo);
 784       continue;
 785     }
 786
 787     for (int j = 0; j < status; j++) {
 788       memory_stats_submit((gauge_t)minfo[j].val * 1024, state->domains[i],
 789                           minfo[j].tag);
 790     }
 791
 792     sfree(minfo);
 793   }
 794
 795   /* Get block device stats for each domain. */
 796   for (int i = 0; i < state->nr_block_devices; ++i) {
 797     struct block_device *bdev = &(state->block_devices[i]);
 798     struct lv_block_info binfo;
 799     init_block_info(&binfo);
 800
 801     if (lv_domain_block_info(bdev->dom, bdev->path, &binfo) < 0)
 802       continue;
 803
 804     char *type_instance = bdev->path;
 805     char *path = NULL;
 806     if (blockdevice_format_basename && blockdevice_format == source) {
 807       path = strdup(bdev->path);
 808       if (path == NULL) {
 809         WARNING(PLUGIN_NAME
 810                 " plugin: error extracting the basename for '%s', skipped",
 811                 bdev->path);
 812         continue;
 813       }
 814       type_instance = basename(path);
 815     }
 816
 817     disk_submit(&binfo, bdev->dom, type_instance);
 818
 819     sfree(path);
 820   } /* for (nr_block_devices) */
 821
 822   /* Get interface stats for each domain. */
 823   for (int i = 0; i < state->nr_interface_devices; ++i) {
 824     struct _virDomainInterfaceStats stats;
 825     char *display_name = NULL;
 826
 827     switch (interface_format) {
 828     case if_address:
 829       display_name = state->interface_devices[i].address;
 830       break;
 831     case if_number:
 832       display_name = state->interface_devices[i].number;
 833       break;
 834     case if_name:
 835     default:
 836       display_name = state->interface_devices[i].path;
 837     }
 838
 839     if (virDomainInterfaceStats(state->interface_devices[i].dom,
 840                                 state->interface_devices[i].path, &stats,
 841                                 sizeof stats) != 0)
 842       continue;
 843
 844     if ((stats.rx_bytes != -1) && (stats.tx_bytes != -1))
 845       submit_derive2("if_octets", (derive_t)stats.rx_bytes,
 846                      (derive_t)stats.tx_bytes, state->interface_devices[i].dom,
 847                      display_name);
 848
 849     if ((stats.rx_packets != -1) && (stats.tx_packets != -1))
 850       submit_derive2("if_packets", (derive_t)stats.rx_packets,
 851                      (derive_t)stats.tx_packets,
 852                      state->interface_devices[i].dom, display_name);
 853
 854     if ((stats.rx_errs != -1) && (stats.tx_errs != -1))
 855       submit_derive2("if_errors", (derive_t)stats.rx_errs,
 856                      (derive_t)stats.tx_errs, state->interface_devices[i].dom,
 857                      display_name);
 858
 859     if ((stats.rx_drop != -1) && (stats.tx_drop != -1))
 860       submit_derive2("if_dropped", (derive_t)stats.rx_drop,
 861                      (derive_t)stats.tx_drop, state->interface_devices[i].dom,
 862                      display_name);
 863   } /* for (nr_interface_devices) */
 864
 865   return 0;
 866 }
 867
 868 static int lv_init_instance(size_t i, plugin_read_cb callback) {
 869   struct lv_user_data *lv_ud = &(lv_read_user_data[i]);
 870   struct lv_read_instance *inst = &(lv_ud->inst);
 871
 872   memset(lv_ud, 0, sizeof(*lv_ud));
 873
 874   ssnprintf(inst->tag, sizeof(inst->tag), "%s-%zu", PLUGIN_NAME, i);
 875   inst->id = i;
 876
 877   user_data_t *ud = &(lv_ud->ud);
 878   ud->data = inst;
 879   ud->free_func = NULL;
 880
 881   INFO(PLUGIN_NAME " plugin: reader %s initialized", inst->tag);
 882   return plugin_register_complex_read(NULL, inst->tag, callback, 0, ud);
 883 }
 884
 885 static void lv_clean_read_state(struct lv_read_state *state) {
 886   free_block_devices(state);
 887   free_interface_devices(state);
 888   free_domains(state);
 889 }
 890
 891 static void lv_fini_instance(size_t i) {
 892   struct lv_read_instance *inst = &(lv_read_user_data[i].inst);
 893   struct lv_read_state *state = &(inst->read_state);
 894
 895   lv_clean_read_state(state);
 896   INFO(PLUGIN_NAME " plugin: reader %s finalized", inst->tag);
 897 }
 898
 899 static int lv_init(void) {
 900   if (virInitialize() != 0)
 901     return -1;
 902
 903   if (lv_connect() != 0)
 904     return -1;
 905
 906   DEBUG(PLUGIN_NAME " plugin: starting %i instances", nr_instances);
 907
 908   for (int i = 0; i < nr_instances; ++i)
 909     lv_init_instance(i, lv_read);
 910
 911   return 0;
 912 }
 913
 914 /*
 915  * returns 0 on success and <0 on error
 916  */
 917 static int lv_domain_get_tag(xmlXPathContextPtr xpath_ctx, const char *dom_name,
 918                              char *dom_tag) {
 919   char xpath_str[BUFFER_MAX_LEN] = {'\0'};
 920   xmlXPathObjectPtr xpath_obj = NULL;
 921   xmlNodePtr xml_node = NULL;
 922   int ret = -1;
 923   int err;
 924
 925   err = xmlXPathRegisterNs(xpath_ctx,
 926                            (const xmlChar *)METADATA_VM_PARTITION_PREFIX,
 927                            (const xmlChar *)METADATA_VM_PARTITION_URI);
 928   if (err) {
 929     ERROR(PLUGIN_NAME " plugin: xmlXpathRegisterNs(%s, %s) failed on domain %s",
 930           METADATA_VM_PARTITION_PREFIX, METADATA_VM_PARTITION_URI, dom_name);
 931     goto done;
 932   }
 933
 934   ssnprintf(xpath_str, sizeof(xpath_str), "/domain/metadata/%s:%s/text()",
 935             METADATA_VM_PARTITION_PREFIX, METADATA_VM_PARTITION_ELEMENT);
 936   xpath_obj = xmlXPathEvalExpression((xmlChar *)xpath_str, xpath_ctx);
 937   if (xpath_obj == NULL) {
 938     ERROR(PLUGIN_NAME " plugin: xmlXPathEval(%s) failed on domain %s",
 939           xpath_str, dom_name);
 940     goto done;
 941   }
 942
 943   if (xpath_obj->type != XPATH_NODESET) {
 944     ERROR(PLUGIN_NAME " plugin: xmlXPathEval(%s) unexpected return type %d "
 945                       "(wanted %d) on domain %s",
 946           xpath_str, xpath_obj->type, XPATH_NODESET, dom_name);
 947     goto done;
 948   }
 949
 950   /*
 951    * from now on there is no real error, it's ok if a domain
 952    * doesn't have the metadata partition tag.
 953    */
 954   ret = 0;
 955   if (xpath_obj->nodesetval == NULL || xpath_obj->nodesetval->nodeNr != 1) {
 956     DEBUG(PLUGIN_NAME " plugin: xmlXPathEval(%s) return nodeset size=%i "
 957                       "expected=1 on domain %s",
 958           xpath_str,
 959           (xpath_obj->nodesetval == NULL) ? 0 : xpath_obj->nodesetval->nodeNr,
 960           dom_name);
 961   } else {
 962     xml_node = xpath_obj->nodesetval->nodeTab[0];
 963     sstrncpy(dom_tag, (const char *)xml_node->content, PARTITION_TAG_MAX_LEN);
 964   }
 965
 966 done:
 967   /* deregister to clean up */
 968   err = xmlXPathRegisterNs(xpath_ctx,
 969                            (const xmlChar *)METADATA_VM_PARTITION_PREFIX, NULL);
 970   if (err) {
 971     /* we can't really recover here */
 972     ERROR(PLUGIN_NAME
 973           " plugin: deregistration of namespace %s failed for domain %s",
 974           METADATA_VM_PARTITION_PREFIX, dom_name);
 975   }
 976   if (xpath_obj)
 977     xmlXPathFreeObject(xpath_obj);
 978
 979   return ret;
 980 }
 981
 982 static int is_known_tag(const char *dom_tag) {
 983   for (int i = 0; i < nr_instances; ++i)
 984     if (!strcmp(dom_tag, lv_read_user_data[i].inst.tag))
 985       return 1;
 986   return 0;
 987 }
 988
 989 static int lv_instance_include_domain(struct lv_read_instance *inst,
 990                                       const char *dom_name,
 991                                       const char *dom_tag) {
 992   if ((dom_tag[0] != '\0') && (strcmp(dom_tag, inst->tag) == 0))
 993     return 1;
 994
 995   /* instance#0 will always be there, so it is in charge of extra duties */
 996   if (inst->id == 0) {
 997     if (dom_tag[0] == '\0' || !is_known_tag(dom_tag)) {
 998       DEBUG(PLUGIN_NAME " plugin#%s: refreshing domain %s "
 999                         "with unknown tag '%s'",
1000             inst->tag, dom_name, dom_tag);
1001       return 1;
1002     }
1003   }
1004
1005   return 0;
1006 }
1007
1008 static int refresh_lists(struct lv_read_instance *inst) {
1009   struct lv_read_state *state = &inst->read_state;
1010   int n;
1011
1012   n = virConnectNumOfDomains(conn);
1013   if (n < 0) {
1014     VIRT_ERROR(conn, "reading number of domains");
1015     return -1;
1016   }
1017
1018   lv_clean_read_state(state);
1019
1020   if (n > 0) {
1021     int *domids;
1022
1023     /* Get list of domains. */
1024     domids = malloc(sizeof(*domids) * n);
1025     if (domids == NULL) {
1026       ERROR(PLUGIN_NAME " plugin: malloc failed.");
1027       return -1;
1028     }
1029
1030     n = virConnectListDomains(conn, domids, n);
1031     if (n < 0) {
1032       VIRT_ERROR(conn, "reading list of domains");
1033       sfree(domids);
1034       return -1;
1035     }
1036
1037     /* Fetch each domain and add it to the list, unless ignore. */
1038     for (int i = 0; i < n; ++i) {
1039       virDomainPtr dom = NULL;
1040       const char *name;
1041       char *xml = NULL;
1042       xmlDocPtr xml_doc = NULL;
1043       xmlXPathContextPtr xpath_ctx = NULL;
1044       xmlXPathObjectPtr xpath_obj = NULL;
1045       char tag[PARTITION_TAG_MAX_LEN] = {'\0'};
1046
1047       dom = virDomainLookupByID(conn, domids[i]);
1048       if (dom == NULL) {
1049         VIRT_ERROR(conn, "virDomainLookupByID");
1050         /* Could be that the domain went away -- ignore it anyway. */
1051         continue;
1052       }
1053
1054       name = virDomainGetName(dom);
1055       if (name == NULL) {
1056         VIRT_ERROR(conn, "virDomainGetName");
1057         goto cont;
1058       }
1059
1060       if (il_domains && ignorelist_match(il_domains, name) != 0)
1061         goto cont;
1062
1063       /* Get a list of devices for this domain. */
1064       xml = virDomainGetXMLDesc(dom, 0);
1065       if (!xml) {
1066         VIRT_ERROR(conn, "virDomainGetXMLDesc");
1067         goto cont;
1068       }
1069
1070       /* Yuck, XML.  Parse out the devices. */
1071       xml_doc = xmlReadDoc((xmlChar *)xml, NULL, NULL, XML_PARSE_NONET);
1072       if (xml_doc == NULL) {
1073         VIRT_ERROR(conn, "xmlReadDoc");
1074         goto cont;
1075       }
1076
1077       xpath_ctx = xmlXPathNewContext(xml_doc);
1078
1079       if (lv_domain_get_tag(xpath_ctx, name, tag) < 0) {
1080         ERROR(PLUGIN_NAME " plugin: lv_domain_get_tag failed.");
1081         goto cont;
1082       }
1083
1084       if (!lv_instance_include_domain(inst, name, tag))
1085         goto cont;
1086
1087       if (add_domain(state, dom) < 0) {
1088         ERROR(PLUGIN_NAME " plugin: malloc failed.");
1089         goto cont;
1090       }
1091
1092       /* Block devices. */
1093       const char *bd_xmlpath = "/domain/devices/disk/target[@dev]";
1094       if (blockdevice_format == source)
1095         bd_xmlpath = "/domain/devices/disk/source[@dev]";
1096       xpath_obj = xmlXPathEval((const xmlChar *)bd_xmlpath, xpath_ctx);
1097
1098       if (xpath_obj == NULL || xpath_obj->type != XPATH_NODESET ||
1099           xpath_obj->nodesetval == NULL)
1100         goto cont;
1101
1102       for (int j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
1103         xmlNodePtr node;
1104         char *path = NULL;
1105
1106         node = xpath_obj->nodesetval->nodeTab[j];
1107         if (!node)
1108           continue;
1109         path = (char *)xmlGetProp(node, (xmlChar *)"dev");
1110         if (!path)
1111           continue;
1112
1113         if (il_block_devices &&
1114             ignore_device_match(il_block_devices, name, path) != 0)
1115           goto cont2;
1116
1117         add_block_device(state, dom, path);
1118       cont2:
1119         if (path)
1120           xmlFree(path);
1121       }
1122       xmlXPathFreeObject(xpath_obj);
1123
1124       /* Network interfaces. */
1125       xpath_obj = xmlXPathEval(
1126           (xmlChar *)"/domain/devices/interface[target[@dev]]", xpath_ctx);
1127       if (xpath_obj == NULL || xpath_obj->type != XPATH_NODESET ||
1128           xpath_obj->nodesetval == NULL)
1129         goto cont;
1130
1131       xmlNodeSetPtr xml_interfaces = xpath_obj->nodesetval;
1132
1133       for (int j = 0; j < xml_interfaces->nodeNr; ++j) {
1134         char *path = NULL;
1135         char *address = NULL;
1136         xmlNodePtr xml_interface;
1137
1138         xml_interface = xml_interfaces->nodeTab[j];
1139         if (!xml_interface)
1140           continue;
1141
1142         for (xmlNodePtr child = xml_interface->children; child;
1143              child = child->next) {
1144           if (child->type != XML_ELEMENT_NODE)
1145             continue;
1146
1147           if (xmlStrEqual(child->name, (const xmlChar *)"target")) {
1148             path = (char *)xmlGetProp(child, (const xmlChar *)"dev");
1149             if (!path)
1150               continue;
1151           } else if (xmlStrEqual(child->name, (const xmlChar *)"mac")) {
1152             address = (char *)xmlGetProp(child, (const xmlChar *)"address");
1153             if (!address)
1154               continue;
1155           }
1156         }
1157
1158         if (il_interface_devices &&
1159             (ignore_device_match(il_interface_devices, name, path) != 0 ||
1160              ignore_device_match(il_interface_devices, name, address) != 0))
1161           goto cont3;
1162
1163         add_interface_device(state, dom, path, address, j + 1);
1164       cont3:
1165         if (path)
1166           xmlFree(path);
1167         if (address)
1168           xmlFree(address);
1169       }
1170
1171     cont:
1172       if (xpath_obj)
1173         xmlXPathFreeObject(xpath_obj);
1174       if (xpath_ctx)
1175         xmlXPathFreeContext(xpath_ctx);
1176       if (xml_doc)
1177         xmlFreeDoc(xml_doc);
1178       sfree(xml);
1179     }
1180
1181     sfree(domids);
1182   }
1183
1184   DEBUG(PLUGIN_NAME " plugin#%s: refreshing"
1185                     " domains=%i block_devices=%i iface_devices=%i",
1186         inst->tag, state->nr_domains, state->nr_block_devices,
1187         state->nr_interface_devices);
1188
1189   return 0;
1190 }
1191
1192 static void free_domains(struct lv_read_state *state) {
1193   if (state->domains) {
1194     for (int i = 0; i < state->nr_domains; ++i)
1195       virDomainFree(state->domains[i]);
1196     sfree(state->domains);
1197   }
1198   state->domains = NULL;
1199   state->nr_domains = 0;
1200 }
1201
1202 static int add_domain(struct lv_read_state *state, virDomainPtr dom) {
1203   virDomainPtr *new_ptr;
1204   int new_size = sizeof(state->domains[0]) * (state->nr_domains + 1);
1205
1206   if (state->domains)
1207     new_ptr = realloc(state->domains, new_size);
1208   else
1209     new_ptr = malloc(new_size);
1210
1211   if (new_ptr == NULL)
1212     return -1;
1213
1214   state->domains = new_ptr;
1215   state->domains[state->nr_domains] = dom;
1216   return state->nr_domains++;
1217 }
1218
1219 static void free_block_devices(struct lv_read_state *state) {
1220   if (state->block_devices) {
1221     for (int i = 0; i < state->nr_block_devices; ++i)
1222       sfree(state->block_devices[i].path);
1223     sfree(state->block_devices);
1224   }
1225   state->block_devices = NULL;
1226   state->nr_block_devices = 0;
1227 }
1228
1229 static int add_block_device(struct lv_read_state *state, virDomainPtr dom,
1230                             const char *path) {
1231   struct block_device *new_ptr;
1232   int new_size =
1233       sizeof(state->block_devices[0]) * (state->nr_block_devices + 1);
1234   char *path_copy;
1235
1236   path_copy = strdup(path);
1237   if (!path_copy)
1238     return -1;
1239
1240   if (state->block_devices)
1241     new_ptr = realloc(state->block_devices, new_size);
1242   else
1243     new_ptr = malloc(new_size);
1244
1245   if (new_ptr == NULL) {
1246     sfree(path_copy);
1247     return -1;
1248   }
1249   state->block_devices = new_ptr;
1250   state->block_devices[state->nr_block_devices].dom = dom;
1251   state->block_devices[state->nr_block_devices].path = path_copy;
1252   return state->nr_block_devices++;
1253 }
1254
1255 static void free_interface_devices(struct lv_read_state *state) {
1256   if (state->interface_devices) {
1257     for (int i = 0; i < state->nr_interface_devices; ++i) {
1258       sfree(state->interface_devices[i].path);
1259       sfree(state->interface_devices[i].address);
1260       sfree(state->interface_devices[i].number);
1261     }
1262     sfree(state->interface_devices);
1263   }
1264   state->interface_devices = NULL;
1265   state->nr_interface_devices = 0;
1266 }
1267
1268 static int add_interface_device(struct lv_read_state *state, virDomainPtr dom,
1269                                 const char *path, const char *address,
1270                                 unsigned int number) {
1271   struct interface_device *new_ptr;
1272   int new_size =
1273       sizeof(state->interface_devices[0]) * (state->nr_interface_devices + 1);
1274   char *path_copy, *address_copy, number_string[15];
1275
1276   if ((path == NULL) || (address == NULL))
1277     return EINVAL;
1278
1279   path_copy = strdup(path);
1280   if (!path_copy)
1281     return -1;
1282
1283   address_copy = strdup(address);
1284   if (!address_copy) {
1285     sfree(path_copy);
1286     return -1;
1287   }
1288
1289   snprintf(number_string, sizeof(number_string), "interface-%u", number);
1290
1291   if (state->interface_devices)
1292     new_ptr = realloc(state->interface_devices, new_size);
1293   else
1294     new_ptr = malloc(new_size);
1295
1296   if (new_ptr == NULL) {
1297     sfree(path_copy);
1298     sfree(address_copy);
1299     return -1;
1300   }
1301   state->interface_devices = new_ptr;
1302   state->interface_devices[state->nr_interface_devices].dom = dom;
1303   state->interface_devices[state->nr_interface_devices].path = path_copy;
1304   state->interface_devices[state->nr_interface_devices].address = address_copy;
1305   state->interface_devices[state->nr_interface_devices].number =
1306       strdup(number_string);
1307   return state->nr_interface_devices++;
1308 }
1309
1310 static int ignore_device_match(ignorelist_t *il, const char *domname,
1311                                const char *devpath) {
1312   char *name;
1313   int n, r;
1314
1315   if ((domname == NULL) || (devpath == NULL))
1316     return 0;
1317
1318   n = sizeof(char) * (strlen(domname) + strlen(devpath) + 2);
1319   name = malloc(n);
1320   if (name == NULL) {
1321     ERROR(PLUGIN_NAME " plugin: malloc failed.");
1322     return 0;
1323   }
1324   ssnprintf(name, n, "%s:%s", domname, devpath);
1325   r = ignorelist_match(il, name);
1326   sfree(name);
1327   return r;
1328 }
1329
1330 static int lv_shutdown(void) {
1331   for (int i = 0; i < nr_instances; ++i) {
1332     lv_fini_instance(i);
1333   }
1334
1335   lv_disconnect();
1336
1337   ignorelist_free(il_domains);
1338   il_domains = NULL;
1339   ignorelist_free(il_block_devices);
1340   il_block_devices = NULL;
1341   ignorelist_free(il_interface_devices);
1342   il_interface_devices = NULL;
1343
1344   return 0;
1345 }
1346
1347 void module_register(void) {
1348   plugin_register_config(PLUGIN_NAME, lv_config, config_keys, NR_CONFIG_KEYS);
1349   plugin_register_init(PLUGIN_NAME, lv_init);
1350   plugin_register_shutdown(PLUGIN_NAME, lv_shutdown);
1351 }