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_ignorelist.h"
  27 #include "utils_complain.h"
  28
  29 #include <libvirt/libvirt.h>
  30 #include <libvirt/virterror.h>
  31 #include <libxml/parser.h>
  32 #include <libxml/tree.h>
  33 #include <libxml/xpath.h>
  34 #include <libgen.h>
  35
  36 /* Plugin name */
  37 #define PLUGIN_NAME "virt"
  38
  39 static const char *config_keys[] = {
  40     "Connection",
  41
  42     "RefreshInterval",
  43
  44     "Domain",
  45     "BlockDevice",
  46     "BlockDeviceFormat",
  47     "BlockDeviceFormatBasename",
  48     "InterfaceDevice",
  49     "IgnoreSelected",
  50
  51     "HostnameFormat",
  52     "InterfaceFormat",
  53
  54     "PluginInstanceFormat",
  55
  56     NULL
  57 };
  58 #define NR_CONFIG_KEYS ((sizeof config_keys / sizeof config_keys[0]) - 1)
  59
  60 /* Connection. */
  61 static virConnectPtr conn = 0;
  62 static char *conn_string = NULL;
  63 static c_complain_t conn_complain = C_COMPLAIN_INIT_STATIC;
  64
  65 /* Seconds between list refreshes, 0 disables completely. */
  66 static int interval = 60;
  67
  68 /* List of domains, if specified. */
  69 static ignorelist_t *il_domains = NULL;
  70 /* List of block devices, if specified. */
  71 static ignorelist_t *il_block_devices = NULL;
  72 /* List of network interface devices, if specified. */
  73 static ignorelist_t *il_interface_devices = NULL;
  74
  75 static int ignore_device_match (ignorelist_t *,
  76                                 const char *domname, const char *devpath);
  77
  78 /* Actual list of domains found on last refresh. */
  79 static virDomainPtr *domains = NULL;
  80 static int nr_domains = 0;
  81
  82 static void free_domains (void);
  83 static int add_domain (virDomainPtr dom);
  84
  85 /* Actual list of block devices found on last refresh. */
  86 struct block_device {
  87     virDomainPtr dom;           /* domain */
  88     char *path;                 /* name of block device */
  89 };
  90
  91 static struct block_device *block_devices = NULL;
  92 static int nr_block_devices = 0;
  93
  94 static void free_block_devices (void);
  95 static int add_block_device (virDomainPtr dom, const char *path);
  96
  97 /* Actual list of network interfaces found on last refresh. */
  98 struct interface_device {
  99     virDomainPtr dom;           /* domain */
 100     char *path;                 /* name of interface device */
 101     char *address;              /* mac address of interface device */
 102     char *number;               /* interface device number */
 103 };
 104
 105 static struct interface_device *interface_devices = NULL;
 106 static int nr_interface_devices = 0;
 107
 108 static void free_interface_devices (void);
 109 static int add_interface_device (virDomainPtr dom, const char *path, const char *address, unsigned int number);
 110
 111 /* HostnameFormat. */
 112 #define HF_MAX_FIELDS 3
 113
 114 enum hf_field {
 115     hf_none = 0,
 116     hf_hostname,
 117     hf_name,
 118     hf_uuid
 119 };
 120
 121 static enum hf_field hostname_format[HF_MAX_FIELDS] =
 122     { hf_name };
 123
 124 /* PluginInstanceFormat */
 125 #define PLGINST_MAX_FIELDS 2
 126
 127 enum plginst_field {
 128     plginst_none = 0,
 129     plginst_name,
 130     plginst_uuid
 131 };
 132
 133 static enum plginst_field plugin_instance_format[PLGINST_MAX_FIELDS] =
 134     { plginst_none };
 135
 136 /* BlockDeviceFormat */
 137 enum bd_field {
 138         dev,
 139         source
 140 };
 141
 142 /* InterfaceFormat. */
 143 enum if_field {
 144     if_address,
 145     if_name,
 146     if_number
 147 };
 148
 149 /* BlockDeviceFormatBasename */
 150 char *blockdevice_format_basename="false";
 151 static enum bd_field blockdevice_format = dev;
 152 static enum if_field interface_format = if_name;
 153
 154 /* Time that we last refreshed. */
 155 static time_t last_refresh = (time_t) 0;
 156
 157 static int refresh_lists (void);
 158
 159 /* ERROR(...) macro for virterrors. */
 160 #define VIRT_ERROR(conn,s) do {                 \
 161         virErrorPtr err;                        \
 162         err = (conn) ? virConnGetLastError ((conn)) : virGetLastError (); \
 163         if (err) ERROR ("%s: %s", (s), err->message);                   \
 164     } while(0)
 165
 166 static void
 167 init_value_list (value_list_t *vl, virDomainPtr dom)
 168 {
 169     int n;
 170     const char *name;
 171     char uuid[VIR_UUID_STRING_BUFLEN];
 172
 173     sstrncpy (vl->plugin, PLUGIN_NAME, sizeof (vl->plugin));
 174
 175     vl->host[0] = '\0';
 176
 177     /* Construct the hostname field according to HostnameFormat. */
 178     for (int i = 0; i < HF_MAX_FIELDS; ++i) {
 179         if (hostname_format[i] == hf_none)
 180             continue;
 181
 182         n = DATA_MAX_NAME_LEN - strlen (vl->host) - 2;
 183
 184         if (i > 0 && n >= 1) {
 185             strncat (vl->host, ":", 1);
 186             n--;
 187         }
 188
 189         switch (hostname_format[i]) {
 190         case hf_none: break;
 191         case hf_hostname:
 192             strncat (vl->host, hostname_g, n);
 193             break;
 194         case hf_name:
 195             name = virDomainGetName (dom);
 196             if (name)
 197                 strncat (vl->host, name, n);
 198             break;
 199         case hf_uuid:
 200             if (virDomainGetUUIDString (dom, uuid) == 0)
 201                 strncat (vl->host, uuid, n);
 202             break;
 203         }
 204     }
 205
 206     vl->host[sizeof (vl->host) - 1] = '\0';
 207
 208     /* Construct the plugin instance field according to PluginInstanceFormat. */
 209     for (int i = 0; i < PLGINST_MAX_FIELDS; ++i) {
 210         if (plugin_instance_format[i] == plginst_none)
 211             continue;
 212
 213         n = sizeof(vl->plugin_instance) - strlen (vl->plugin_instance) - 2;
 214
 215         if (i > 0 && n >= 1) {
 216             strncat (vl->plugin_instance, ":", 1);
 217             n--;
 218         }
 219
 220         switch (plugin_instance_format[i]) {
 221         case plginst_none: break;
 222         case plginst_name:
 223             name = virDomainGetName (dom);
 224             if (name)
 225                 strncat (vl->plugin_instance, name, n);
 226             break;
 227         case plginst_uuid:
 228             if (virDomainGetUUIDString (dom, uuid) == 0)
 229                 strncat (vl->plugin_instance, uuid, n);
 230             break;
 231         }
 232     }
 233
 234     vl->plugin_instance[sizeof (vl->plugin_instance) - 1] = '\0';
 235
 236 } /* void init_value_list */
 237
 238 static void submit (virDomainPtr dom,
 239                     char const *type, char const *type_instance,
 240                     value_t *values, size_t values_len)
 241 {
 242     value_list_t vl = VALUE_LIST_INIT;
 243     init_value_list (&vl, dom);
 244
 245     vl.values = values;
 246     vl.values_len = values_len;
 247
 248     sstrncpy (vl.type, type, sizeof (vl.type));
 249     if (type_instance != NULL)
 250         sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 251
 252     plugin_dispatch_values (&vl);
 253 }
 254
 255 static void
 256 memory_submit (gauge_t value, virDomainPtr dom)
 257 {
 258     submit (dom, "memory", "total", &(value_t) { .gauge = value }, 1);
 259 }
 260
 261 static void
 262 memory_stats_submit (gauge_t value, virDomainPtr dom, int tag_index)
 263 {
 264     static const char *tags[] = { "swap_in", "swap_out", "major_fault", "minor_fault",
 265                                     "unused", "available", "actual_balloon", "rss"};
 266
 267     if ((tag_index < 0) || (tag_index >= STATIC_ARRAY_SIZE (tags))) {
 268         ERROR ("virt plugin: Array index out of bounds: tag_index = %d", tag_index);
 269         return;
 270     }
 271
 272     submit (dom, "memory", tags[tag_index], &(value_t) { .gauge = value }, 1);
 273 }
 274
 275 static void
 276 cpu_submit (unsigned long long value,
 277             virDomainPtr dom, const char *type)
 278 {
 279     submit (dom, type, NULL, &(value_t) { .derive = (derive_t) value }, 1);
 280 }
 281
 282 static void
 283 vcpu_submit (derive_t value,
 284              virDomainPtr dom, int vcpu_nr, const char *type)
 285 {
 286     char type_instance[DATA_MAX_NAME_LEN];
 287
 288     ssnprintf (type_instance, sizeof (type_instance), "%d", vcpu_nr);
 289
 290     submit (dom, type, type_instance, &(value_t) { .derive = value }, 1);
 291 }
 292
 293 static void
 294 submit_derive2 (const char *type, derive_t v0, derive_t v1,
 295              virDomainPtr dom, const char *devname)
 296 {
 297     value_t values[] = {
 298         { .derive = v0 },
 299         { .derive = v1 },
 300     };
 301
 302     submit (dom, type, devname, values, STATIC_ARRAY_SIZE (values));
 303 } /* void submit_derive2 */
 304
 305 static int
 306 lv_init (void)
 307 {
 308     if (virInitialize () != 0)
 309         return -1;
 310     else
 311         return 0;
 312 }
 313
 314 static int
 315 lv_config (const char *key, const char *value)
 316 {
 317     if (virInitialize () != 0)
 318         return 1;
 319
 320     if (il_domains == NULL)
 321         il_domains = ignorelist_create (1);
 322     if (il_block_devices == NULL)
 323         il_block_devices = ignorelist_create (1);
 324     if (il_interface_devices == NULL)
 325         il_interface_devices = ignorelist_create (1);
 326
 327     if (strcasecmp (key, "Connection") == 0) {
 328         char *tmp = strdup (value);
 329         if (tmp == NULL) {
 330             ERROR (PLUGIN_NAME " plugin: Connection strdup failed.");
 331             return 1;
 332         }
 333         sfree (conn_string);
 334         conn_string = tmp;
 335         return 0;
 336     }
 337
 338     if (strcasecmp (key, "RefreshInterval") == 0) {
 339         char *eptr = NULL;
 340         interval = strtol (value, &eptr, 10);
 341         if (eptr == NULL || *eptr != '\0') return 1;
 342         return 0;
 343     }
 344
 345     if (strcasecmp (key, "Domain") == 0) {
 346         if (ignorelist_add (il_domains, value)) return 1;
 347         return 0;
 348     }
 349     if (strcasecmp (key, "BlockDevice") == 0) {
 350         if (ignorelist_add (il_block_devices, value)) return 1;
 351         return 0;
 352     }
 353
 354     if (strcasecmp (key, "BlockDeviceFormat") == 0) {
 355         if (strcasecmp (value, "dev") == 0)
 356             blockdevice_format = dev;
 357         else if (strcasecmp (value, "source") == 0)
 358             blockdevice_format = source;
 359         else {
 360             ERROR (PLUGIN_NAME " plugin: unknown BlockDeviceFormat: %s", value);
 361             return -1;
 362         }
 363         return 0;
 364     }
 365     if (strcasecmp (key, "BlockDeviceFormatBasename") == 0) {
 366         if (strcasecmp (value, "true") == 0)
 367             blockdevice_format_basename = "true";
 368         else if (strcasecmp (value, "false") == 0)
 369             blockdevice_format_basename = "false";
 370         else {
 371             ERROR (PLUGIN_NAME " plugin: unknown BlockDeviceFormatBasename: %s", value);
 372             return -1;
 373         }
 374         return 0;
 375     }
 376     if (strcasecmp (key, "InterfaceDevice") == 0) {
 377         if (ignorelist_add (il_interface_devices, value)) return 1;
 378         return 0;
 379     }
 380
 381     if (strcasecmp (key, "IgnoreSelected") == 0) {
 382         if (IS_TRUE (value))
 383         {
 384             ignorelist_set_invert (il_domains, 0);
 385             ignorelist_set_invert (il_block_devices, 0);
 386             ignorelist_set_invert (il_interface_devices, 0);
 387         }
 388         else
 389         {
 390             ignorelist_set_invert (il_domains, 1);
 391             ignorelist_set_invert (il_block_devices, 1);
 392             ignorelist_set_invert (il_interface_devices, 1);
 393         }
 394         return 0;
 395     }
 396
 397     if (strcasecmp (key, "HostnameFormat") == 0) {
 398         char *value_copy;
 399         char *fields[HF_MAX_FIELDS];
 400         int n;
 401
 402         value_copy = strdup (value);
 403         if (value_copy == NULL) {
 404             ERROR (PLUGIN_NAME " plugin: strdup failed.");
 405             return -1;
 406         }
 407
 408         n = strsplit (value_copy, fields, HF_MAX_FIELDS);
 409         if (n < 1) {
 410             sfree (value_copy);
 411             ERROR (PLUGIN_NAME " plugin: HostnameFormat: no fields");
 412             return -1;
 413         }
 414
 415         for (int i = 0; i < n; ++i) {
 416             if (strcasecmp (fields[i], "hostname") == 0)
 417                 hostname_format[i] = hf_hostname;
 418             else if (strcasecmp (fields[i], "name") == 0)
 419                 hostname_format[i] = hf_name;
 420             else if (strcasecmp (fields[i], "uuid") == 0)
 421                 hostname_format[i] = hf_uuid;
 422             else {
 423                 ERROR (PLUGIN_NAME " plugin: unknown HostnameFormat field: %s", fields[i]);
 424                 sfree (value_copy);
 425                 return -1;
 426             }
 427         }
 428         sfree (value_copy);
 429
 430         for (int i = n; i < HF_MAX_FIELDS; ++i)
 431             hostname_format[i] = hf_none;
 432
 433         return 0;
 434     }
 435
 436     if (strcasecmp (key, "PluginInstanceFormat") == 0) {
 437         char *value_copy;
 438         char *fields[PLGINST_MAX_FIELDS];
 439         int n;
 440
 441         value_copy = strdup (value);
 442         if (value_copy == NULL) {
 443             ERROR (PLUGIN_NAME " plugin: strdup failed.");
 444             return -1;
 445         }
 446
 447         n = strsplit (value_copy, fields, PLGINST_MAX_FIELDS);
 448         if (n < 1) {
 449             sfree (value_copy);
 450             ERROR (PLUGIN_NAME " plugin: PluginInstanceFormat: no fields");
 451             return -1;
 452         }
 453
 454         for (int i = 0; i < n; ++i) {
 455             if (strcasecmp (fields[i], "none") == 0) {
 456                 plugin_instance_format[i] = plginst_none;
 457                 break;
 458             } else if (strcasecmp (fields[i], "name") == 0)
 459                 plugin_instance_format[i] = plginst_name;
 460             else if (strcasecmp (fields[i], "uuid") == 0)
 461                 plugin_instance_format[i] = plginst_uuid;
 462             else {
 463                 ERROR (PLUGIN_NAME " plugin: unknown PluginInstanceFormat field: %s", fields[i]);
 464                 sfree (value_copy);
 465                 return -1;
 466             }
 467         }
 468         sfree (value_copy);
 469
 470         for (int i = n; i < PLGINST_MAX_FIELDS; ++i)
 471             plugin_instance_format[i] = plginst_none;
 472
 473         return 0;
 474     }
 475
 476     if (strcasecmp (key, "InterfaceFormat") == 0) {
 477         if (strcasecmp (value, "name") == 0)
 478             interface_format = if_name;
 479         else if (strcasecmp (value, "address") == 0)
 480             interface_format = if_address;
 481         else if (strcasecmp (value, "number") == 0)
 482             interface_format = if_number;
 483         else {
 484             ERROR (PLUGIN_NAME " plugin: unknown InterfaceFormat: %s", value);
 485             return -1;
 486         }
 487         return 0;
 488     }
 489
 490     /* Unrecognised option. */
 491     return -1;
 492 }
 493
 494 static int
 495 lv_read (void)
 496 {
 497     time_t t;
 498
 499     if (conn == NULL) {
 500         /* `conn_string == NULL' is acceptable. */
 501         conn = virConnectOpenReadOnly (conn_string);
 502         if (conn == NULL) {
 503             c_complain (LOG_ERR, &conn_complain,
 504                     PLUGIN_NAME " plugin: Unable to connect: "
 505                     "virConnectOpenReadOnly failed.");
 506             return -1;
 507         }
 508     }
 509     c_release (LOG_NOTICE, &conn_complain,
 510             PLUGIN_NAME " plugin: Connection established.");
 511
 512     time (&t);
 513
 514     /* Need to refresh domain or device lists? */
 515     if ((last_refresh == (time_t) 0) ||
 516             ((interval > 0) && ((last_refresh + interval) <= t))) {
 517         if (refresh_lists () != 0) {
 518             if (conn != NULL)
 519                 virConnectClose (conn);
 520             conn = NULL;
 521             return -1;
 522         }
 523         last_refresh = t;
 524     }
 525
 526 #if 0
 527     for (int i = 0; i < nr_domains; ++i)
 528         fprintf (stderr, "domain %s\n", virDomainGetName (domains[i]));
 529     for (int i = 0; i < nr_block_devices; ++i)
 530         fprintf  (stderr, "block device %d %s:%s\n",
 531                   i, virDomainGetName (block_devices[i].dom),
 532                   block_devices[i].path);
 533     for (int i = 0; i < nr_interface_devices; ++i)
 534         fprintf (stderr, "interface device %d %s:%s\n",
 535                  i, virDomainGetName (interface_devices[i].dom),
 536                  interface_devices[i].path);
 537 #endif
 538
 539     /* Get CPU usage, memory, VCPU usage for each domain. */
 540     for (int i = 0; i < nr_domains; ++i) {
 541         virDomainInfo info;
 542         virVcpuInfoPtr vinfo = NULL;
 543         virDomainMemoryStatPtr minfo = NULL;
 544         int status;
 545
 546         status = virDomainGetInfo (domains[i], &info);
 547         if (status != 0)
 548         {
 549             ERROR (PLUGIN_NAME " plugin: virDomainGetInfo failed with status %i.",
 550                     status);
 551             continue;
 552         }
 553
 554         if (info.state != VIR_DOMAIN_RUNNING)
 555         {
 556             /* only gather stats for running domains */
 557             continue;
 558         }
 559
 560         cpu_submit (info.cpuTime, domains[i], "virt_cpu_total");
 561         memory_submit ((gauge_t) info.memory * 1024, domains[i]);
 562
 563         vinfo = malloc (info.nrVirtCpu * sizeof (vinfo[0]));
 564         if (vinfo == NULL) {
 565             ERROR (PLUGIN_NAME " plugin: malloc failed.");
 566             continue;
 567         }
 568
 569         status = virDomainGetVcpus (domains[i], vinfo, info.nrVirtCpu,
 570                 /* cpu map = */ NULL, /* cpu map length = */ 0);
 571         if (status < 0)
 572         {
 573             ERROR (PLUGIN_NAME " plugin: virDomainGetVcpus failed with status %i.",
 574                     status);
 575             sfree (vinfo);
 576             continue;
 577         }
 578
 579         for (int j = 0; j < info.nrVirtCpu; ++j)
 580             vcpu_submit (vinfo[j].cpuTime,
 581                     domains[i], vinfo[j].number, "virt_vcpu");
 582
 583         sfree (vinfo);
 584
 585         minfo = malloc (VIR_DOMAIN_MEMORY_STAT_NR * sizeof (virDomainMemoryStatStruct));
 586         if (minfo == NULL) {
 587             ERROR ("virt plugin: malloc failed.");
 588             continue;
 589         }
 590
 591         status = virDomainMemoryStats (domains[i], minfo, VIR_DOMAIN_MEMORY_STAT_NR, 0);
 592
 593         if (status < 0) {
 594             ERROR ("virt plugin: virDomainMemoryStats failed with status %i.",
 595                     status);
 596             sfree (minfo);
 597             continue;
 598         }
 599
 600         for (int j = 0; j < status; j++) {
 601             memory_stats_submit ((gauge_t) minfo[j].val * 1024, domains[i], minfo[j].tag);
 602         }
 603
 604         sfree (minfo);
 605     }
 606
 607
 608     /* Get block device stats for each domain. */
 609     for (int i = 0; i < nr_block_devices; ++i) {
 610         struct _virDomainBlockStats stats;
 611
 612         if (virDomainBlockStats (block_devices[i].dom, block_devices[i].path,
 613                     &stats, sizeof stats) != 0)
 614             continue;
 615
 616         char *new_path=NULL;
 617         if( 0==strcasecmp("true", blockdevice_format_basename) && source==blockdevice_format){ //valid only if we use source (full path to the device)
 618                 new_path=strdup(basename(block_devices[i].path));
 619         }else{
 620                 new_path=strdup(block_devices[i].path);
 621         }
 622         if ((stats.rd_req != -1) && (stats.wr_req != -1))
 623             submit_derive2 ("disk_ops",
 624                     (derive_t) stats.rd_req, (derive_t) stats.wr_req,
 625                     block_devices[i].dom, new_path);
 626
 627         if ((stats.rd_bytes != -1) && (stats.wr_bytes != -1))
 628             submit_derive2 ("disk_octets",
 629                     (derive_t) stats.rd_bytes, (derive_t) stats.wr_bytes,
 630                     block_devices[i].dom, new_path);
 631
 632         free(new_path);
 633     } /* for (nr_block_devices) */
 634
 635     /* Get interface stats for each domain. */
 636     for (int i = 0; i < nr_interface_devices; ++i) {
 637         struct _virDomainInterfaceStats stats;
 638         char *display_name = NULL;
 639
 640
 641         switch (interface_format) {
 642             case if_address:
 643                 display_name = interface_devices[i].address;
 644                 break;
 645             case if_number:
 646                 display_name = interface_devices[i].number;
 647                 break;
 648             case if_name:
 649             default:
 650                 display_name = interface_devices[i].path;
 651         }
 652
 653         if (virDomainInterfaceStats (interface_devices[i].dom,
 654                     interface_devices[i].path,
 655                     &stats, sizeof stats) != 0)
 656             continue;
 657
 658         if ((stats.rx_bytes != -1) && (stats.tx_bytes != -1))
 659             submit_derive2 ("if_octets",
 660                     (derive_t) stats.rx_bytes, (derive_t) stats.tx_bytes,
 661                     interface_devices[i].dom, display_name);
 662
 663         if ((stats.rx_packets != -1) && (stats.tx_packets != -1))
 664             submit_derive2 ("if_packets",
 665                     (derive_t) stats.rx_packets, (derive_t) stats.tx_packets,
 666                     interface_devices[i].dom, display_name);
 667
 668         if ((stats.rx_errs != -1) && (stats.tx_errs != -1))
 669             submit_derive2 ("if_errors",
 670                     (derive_t) stats.rx_errs, (derive_t) stats.tx_errs,
 671                     interface_devices[i].dom, display_name);
 672
 673         if ((stats.rx_drop != -1) && (stats.tx_drop != -1))
 674             submit_derive2 ("if_dropped",
 675                     (derive_t) stats.rx_drop, (derive_t) stats.tx_drop,
 676                     interface_devices[i].dom, display_name);
 677     } /* for (nr_interface_devices) */
 678
 679     return 0;
 680 }
 681
 682 static int
 683 refresh_lists (void)
 684 {
 685     int n;
 686
 687     n = virConnectNumOfDomains (conn);
 688     if (n < 0) {
 689         VIRT_ERROR (conn, "reading number of domains");
 690         return -1;
 691     }
 692
 693     if (n > 0) {
 694         int *domids;
 695
 696         /* Get list of domains. */
 697         domids = malloc (sizeof (*domids) * n);
 698         if (domids == NULL) {
 699             ERROR (PLUGIN_NAME " plugin: malloc failed.");
 700             return -1;
 701         }
 702
 703         n = virConnectListDomains (conn, domids, n);
 704         if (n < 0) {
 705             VIRT_ERROR (conn, "reading list of domains");
 706             sfree (domids);
 707             return -1;
 708         }
 709
 710         free_block_devices ();
 711         free_interface_devices ();
 712         free_domains ();
 713
 714         /* Fetch each domain and add it to the list, unless ignore. */
 715         for (int i = 0; i < n; ++i) {
 716             virDomainPtr dom = NULL;
 717             const char *name;
 718             char *xml = NULL;
 719             xmlDocPtr xml_doc = NULL;
 720             xmlXPathContextPtr xpath_ctx = NULL;
 721             xmlXPathObjectPtr xpath_obj = NULL;
 722
 723             dom = virDomainLookupByID (conn, domids[i]);
 724             if (dom == NULL) {
 725                 VIRT_ERROR (conn, "virDomainLookupByID");
 726                 /* Could be that the domain went away -- ignore it anyway. */
 727                 continue;
 728             }
 729
 730             name = virDomainGetName (dom);
 731             if (name == NULL) {
 732                 VIRT_ERROR (conn, "virDomainGetName");
 733                 goto cont;
 734             }
 735
 736             if (il_domains && ignorelist_match (il_domains, name) != 0)
 737                 goto cont;
 738
 739             if (add_domain (dom) < 0) {
 740                 ERROR (PLUGIN_NAME " plugin: malloc failed.");
 741                 goto cont;
 742             }
 743
 744             /* Get a list of devices for this domain. */
 745             xml = virDomainGetXMLDesc (dom, 0);
 746             if (!xml) {
 747                 VIRT_ERROR (conn, "virDomainGetXMLDesc");
 748                 goto cont;
 749             }
 750
 751             /* Yuck, XML.  Parse out the devices. */
 752             xml_doc = xmlReadDoc ((xmlChar *) xml, NULL, NULL, XML_PARSE_NONET);
 753             if (xml_doc == NULL) {
 754                 VIRT_ERROR (conn, "xmlReadDoc");
 755                 goto cont;
 756             }
 757
 758             xpath_ctx = xmlXPathNewContext (xml_doc);
 759
 760             /* Block devices. */
 761             char * bd_xmlpath=NULL;
 762             if( source == blockdevice_format ){
 763                     bd_xmlpath="/domain/devices/disk/source[@dev]";
 764             }else{
 765                         if( dev == blockdevice_format ){
 766                                 bd_xmlpath="/domain/devices/disk/target[@dev]";
 767                         }
 768             }
 769             xpath_obj = xmlXPathEval
 770                   ((xmlChar *) bd_xmlpath,
 771                    xpath_ctx);
 772
 773             if (xpath_obj == NULL || xpath_obj->type != XPATH_NODESET ||
 774                 xpath_obj->nodesetval == NULL)
 775                 goto cont;
 776
 777             for (int j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
 778                 xmlNodePtr node;
 779                 char *path = NULL;
 780
 781                 node = xpath_obj->nodesetval->nodeTab[j];
 782                 if (!node) continue;
 783                 path = (char *) xmlGetProp (node, (xmlChar *) "dev");
 784                 if (!path) continue;
 785
 786                 if (il_block_devices &&
 787                     ignore_device_match (il_block_devices, name, path) != 0)
 788                     goto cont2;
 789
 790                 add_block_device (dom, path);
 791             cont2:
 792                 if (path) xmlFree (path);
 793             }
 794             xmlXPathFreeObject (xpath_obj);
 795
 796             /* Network interfaces. */
 797             xpath_obj = xmlXPathEval
 798                 ((xmlChar *) "/domain/devices/interface[target[@dev]]",
 799                  xpath_ctx);
 800             if (xpath_obj == NULL || xpath_obj->type != XPATH_NODESET ||
 801                 xpath_obj->nodesetval == NULL)
 802                 goto cont;
 803
 804             xmlNodeSetPtr xml_interfaces = xpath_obj->nodesetval;
 805
 806             for (int j = 0; j < xml_interfaces->nodeNr; ++j) {
 807                 char *path = NULL;
 808                 char *address = NULL;
 809                 xmlNodePtr xml_interface;
 810
 811                 xml_interface = xml_interfaces->nodeTab[j];
 812                 if (!xml_interface) continue;
 813
 814                 for (xmlNodePtr child = xml_interface->children; child; child = child->next) {
 815                     if (child->type != XML_ELEMENT_NODE) continue;
 816
 817                     if (xmlStrEqual(child->name, (const xmlChar *) "target")) {
 818                         path = (char *) xmlGetProp (child, (const xmlChar *) "dev");
 819                         if (!path) continue;
 820                     } else if (xmlStrEqual(child->name, (const xmlChar *) "mac")) {
 821                         address = (char *) xmlGetProp (child, (const xmlChar *) "address");
 822                         if (!address) continue;
 823                     }
 824                 }
 825
 826                 if (il_interface_devices &&
 827                     (ignore_device_match (il_interface_devices, name, path) != 0 ||
 828                      ignore_device_match (il_interface_devices, name, address) != 0))
 829                     goto cont3;
 830
 831                 add_interface_device (dom, path, address, j+1);
 832                 cont3:
 833                     if (path) xmlFree (path);
 834                     if (address) xmlFree (address);
 835             }
 836
 837         cont:
 838             if (xpath_obj) xmlXPathFreeObject (xpath_obj);
 839             if (xpath_ctx) xmlXPathFreeContext (xpath_ctx);
 840             if (xml_doc) xmlFreeDoc (xml_doc);
 841             sfree (xml);
 842         }
 843
 844         sfree (domids);
 845     }
 846
 847     return 0;
 848 }
 849
 850 static void
 851 free_domains (void)
 852 {
 853     if (domains) {
 854         for (int i = 0; i < nr_domains; ++i)
 855             virDomainFree (domains[i]);
 856         sfree (domains);
 857     }
 858     domains = NULL;
 859     nr_domains = 0;
 860 }
 861
 862 static int
 863 add_domain (virDomainPtr dom)
 864 {
 865     virDomainPtr *new_ptr;
 866     int new_size = sizeof (domains[0]) * (nr_domains+1);
 867
 868     if (domains)
 869         new_ptr = realloc (domains, new_size);
 870     else
 871         new_ptr = malloc (new_size);
 872
 873     if (new_ptr == NULL)
 874         return -1;
 875
 876     domains = new_ptr;
 877     domains[nr_domains] = dom;
 878     return nr_domains++;
 879 }
 880
 881 static void
 882 free_block_devices (void)
 883 {
 884     if (block_devices) {
 885         for (int i = 0; i < nr_block_devices; ++i)
 886             sfree (block_devices[i].path);
 887         sfree (block_devices);
 888     }
 889     block_devices = NULL;
 890     nr_block_devices = 0;
 891 }
 892
 893 static int
 894 add_block_device (virDomainPtr dom, const char *path)
 895 {
 896     struct block_device *new_ptr;
 897     int new_size = sizeof (block_devices[0]) * (nr_block_devices+1);
 898     char *path_copy;
 899
 900     path_copy = strdup (path);
 901     if (!path_copy)
 902         return -1;
 903
 904     if (block_devices)
 905         new_ptr = realloc (block_devices, new_size);
 906     else
 907         new_ptr = malloc (new_size);
 908
 909     if (new_ptr == NULL) {
 910         sfree (path_copy);
 911         return -1;
 912     }
 913     block_devices = new_ptr;
 914     block_devices[nr_block_devices].dom = dom;
 915     block_devices[nr_block_devices].path = path_copy;
 916     return nr_block_devices++;
 917 }
 918
 919 static void
 920 free_interface_devices (void)
 921 {
 922     if (interface_devices) {
 923         for (int i = 0; i < nr_interface_devices; ++i) {
 924             sfree (interface_devices[i].path);
 925             sfree (interface_devices[i].address);
 926             sfree (interface_devices[i].number);
 927         }
 928         sfree (interface_devices);
 929     }
 930     interface_devices = NULL;
 931     nr_interface_devices = 0;
 932 }
 933
 934 static int
 935 add_interface_device (virDomainPtr dom, const char *path, const char *address, unsigned int number)
 936 {
 937     struct interface_device *new_ptr;
 938     int new_size = sizeof (interface_devices[0]) * (nr_interface_devices+1);
 939     char *path_copy, *address_copy, number_string[15];
 940
 941     if ((path == NULL) || (address == NULL))
 942         return EINVAL;
 943
 944     path_copy = strdup (path);
 945     if (!path_copy) return -1;
 946
 947     address_copy = strdup (address);
 948     if (!address_copy) {
 949         sfree(path_copy);
 950         return -1;
 951     }
 952
 953     snprintf(number_string, sizeof (number_string), "interface-%u", number);
 954
 955     if (interface_devices)
 956         new_ptr = realloc (interface_devices, new_size);
 957     else
 958         new_ptr = malloc (new_size);
 959
 960     if (new_ptr == NULL) {
 961         sfree (path_copy);
 962         sfree (address_copy);
 963         return -1;
 964     }
 965     interface_devices = new_ptr;
 966     interface_devices[nr_interface_devices].dom = dom;
 967     interface_devices[nr_interface_devices].path = path_copy;
 968     interface_devices[nr_interface_devices].address = address_copy;
 969     interface_devices[nr_interface_devices].number = strdup(number_string);
 970     return nr_interface_devices++;
 971 }
 972
 973 static int
 974 ignore_device_match (ignorelist_t *il, const char *domname, const char *devpath)
 975 {
 976     char *name;
 977     int n, r;
 978
 979     if ((domname == NULL) || (devpath == NULL))
 980         return 0;
 981
 982     n = sizeof (char) * (strlen (domname) + strlen (devpath) + 2);
 983     name = malloc (n);
 984     if (name == NULL) {
 985         ERROR (PLUGIN_NAME " plugin: malloc failed.");
 986         return 0;
 987     }
 988     ssnprintf (name, n, "%s:%s", domname, devpath);
 989     r = ignorelist_match (il, name);
 990     sfree (name);
 991     return r;
 992 }
 993
 994 static int
 995 lv_shutdown (void)
 996 {
 997     free_block_devices ();
 998     free_interface_devices ();
 999     free_domains ();
1000
1001     if (conn != NULL)
1002         virConnectClose (conn);
1003     conn = NULL;
1004
1005     ignorelist_free (il_domains);
1006     il_domains = NULL;
1007     ignorelist_free (il_block_devices);
1008     il_block_devices = NULL;
1009     ignorelist_free (il_interface_devices);
1010     il_interface_devices = NULL;
1011
1012     return 0;
1013 }
1014
1015 void
1016 module_register (void)
1017 {
1018     plugin_register_config (PLUGIN_NAME,
1019     lv_config,
1020     config_keys, NR_CONFIG_KEYS);
1021     plugin_register_init (PLUGIN_NAME, lv_init);
1022     plugin_register_read (PLUGIN_NAME, lv_read);
1023     plugin_register_shutdown (PLUGIN_NAME, lv_shutdown);
1024 }
1025
1026 /*
1027  * vim: shiftwidth=4 tabstop=8 softtabstop=4 expandtab fdm=marker
1028  */