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