src/netlink.c

   1 /**
   2  * collectd - src/netlink.c
   3  * Copyright (C) 2007  Florian octo Forster
   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  *   Florian octo Forster <octo at verplant.org>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "plugin.h"
  24 #include "common.h"
  25
  26 #include <asm/types.h>
  27 #include <sys/socket.h>
  28 #include <iproute/libnetlink.h>
  29 #include <linux/netlink.h>
  30 #include <linux/rtnetlink.h>
  31 #include <linux/gen_stats.h>
  32
  33 #include <iproute/ll_map.h>
  34
  35 typedef struct ir_ignorelist_s
  36 {
  37   char *device;
  38   char *type;
  39   char *inst;
  40   struct ir_ignorelist_s *next;
  41 } ir_ignorelist_t;
  42
  43 static int ir_ignorelist_invert = 1;
  44 static ir_ignorelist_t *ir_ignorelist_head = NULL;
  45
  46 static struct rtnl_handle rth;
  47
  48 static const char *config_keys[] =
  49 {
  50         "Interface",
  51         "VerboseInterface",
  52         "QDisc",
  53         "Class",
  54         "Filter",
  55         "IgnoreSelected"
  56 };
  57 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  58
  59 static int add_ignorelist (const char *dev, const char *type,
  60     const char *inst)
  61 {
  62   ir_ignorelist_t *entry;
  63
  64   entry = (ir_ignorelist_t *) malloc (sizeof (ir_ignorelist_t));
  65   if (entry == NULL)
  66     return (-1);
  67
  68   memset (entry, '\0', sizeof (ir_ignorelist_t));
  69
  70   if (strcasecmp (dev, "All") != 0)
  71   {
  72     entry->device = strdup (dev);
  73     if (entry->device == NULL)
  74     {
  75       sfree (entry);
  76       return (-1);
  77     }
  78   }
  79
  80   entry->type = strdup (type);
  81   if (entry->type == NULL)
  82   {
  83     sfree (entry->device);
  84     sfree (entry);
  85     return (-1);
  86   }
  87
  88   if (inst != NULL)
  89   {
  90     entry->inst = strdup (inst);
  91     if (entry->inst == NULL)
  92     {
  93       sfree (entry->type);
  94       sfree (entry->device);
  95       sfree (entry);
  96       return (-1);
  97     }
  98   }
  99
 100   entry->next = ir_ignorelist_head;
 101   ir_ignorelist_head = entry;
 102
 103   return (0);
 104 } /* int add_ignorelist */
 105
 106 /*
 107  * Checks wether a data set should be ignored. Returns `true' is the value
 108  * should be ignored, `false' otherwise.
 109  */
 110 static int check_ignorelist (const char *dev,
 111     const char *type, const char *type_instance)
 112 {
 113   ir_ignorelist_t *i;
 114
 115   if (ir_ignorelist_head == NULL)
 116     return (ir_ignorelist_invert ? 0 : 1);
 117
 118   for (i = ir_ignorelist_head; i != NULL; i = i->next)
 119   {
 120     if ((strcasecmp (i->device, dev) != 0)
 121         || (strcasecmp (i->type, type) != 0))
 122       continue;
 123
 124     if ((i->inst != NULL)
 125         && ((type_instance == NULL)
 126           || (strcasecmp (i->inst, type_instance) != 0)))
 127       continue;
 128
 129     return (ir_ignorelist_invert ? 0 : 1);
 130   } /* for i */
 131
 132   return (ir_ignorelist_invert);
 133 } /* int check_ignorelist */
 134
 135 static void submit_one (const char *dev, const char *type,
 136     const char *type_instance, counter_t value)
 137 {
 138   value_t values[1];
 139   value_list_t vl = VALUE_LIST_INIT;
 140
 141   values[0].counter = value;
 142
 143   vl.values = values;
 144   vl.values_len = 1;
 145   vl.time = time (NULL);
 146   strcpy (vl.host, hostname_g);
 147   strcpy (vl.plugin, "netlink");
 148   strncpy (vl.plugin_instance, dev, sizeof (vl.plugin_instance));
 149
 150   if (type_instance != NULL)
 151     strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 152
 153   plugin_dispatch_values (type, &vl);
 154 } /* void submit_one */
 155
 156 static void submit_two (const char *dev, const char *type,
 157     const char *type_instance,
 158     counter_t rx, counter_t tx)
 159 {
 160   value_t values[2];
 161   value_list_t vl = VALUE_LIST_INIT;
 162
 163   values[0].counter = rx;
 164   values[1].counter = tx;
 165
 166   vl.values = values;
 167   vl.values_len = 2;
 168   vl.time = time (NULL);
 169   strcpy (vl.host, hostname_g);
 170   strcpy (vl.plugin, "netlink");
 171   strncpy (vl.plugin_instance, dev, sizeof (vl.plugin_instance));
 172
 173   if (type_instance != NULL)
 174     strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 175
 176   plugin_dispatch_values (type, &vl);
 177 } /* void submit_two */
 178
 179 static int link_filter (const struct sockaddr_nl *sa, struct nlmsghdr *nmh,
 180     void *args)
 181 {
 182   struct ifinfomsg *msg;
 183   int msg_len;
 184   struct rtattr *attrs[IFLA_MAX + 1];
 185   struct rtnl_link_stats *stats;
 186
 187   const char *dev;
 188
 189   if (nmh->nlmsg_type != RTM_NEWLINK)
 190   {
 191     ERROR ("netlink plugin: link_filter: Don't know how to handle type %i.\n",
 192         nmh->nlmsg_type);
 193     return (-1);
 194   }
 195
 196   msg = NLMSG_DATA (nmh);
 197
 198   msg_len = nmh->nlmsg_len - sizeof (struct ifinfomsg);
 199   if (msg_len < 0)
 200   {
 201     ERROR ("netlink plugin: link_filter: msg_len = %i < 0;\n", msg_len);
 202     return (-1);
 203   }
 204
 205   memset (attrs, '\0', sizeof (attrs));
 206   if (parse_rtattr (attrs, IFLA_MAX, IFLA_RTA (msg), msg_len) != 0)
 207   {
 208     ERROR ("netlink plugin: link_filter: parse_rtattr failed.\n");
 209     return (-1);
 210   }
 211
 212   if (attrs[IFLA_STATS] == NULL)
 213     return (-1);
 214   stats = RTA_DATA (attrs[IFLA_STATS]);
 215
 216   if (attrs[IFLA_IFNAME] == NULL)
 217   {
 218     ERROR ("netlink plugin: link_filter: attrs[IFLA_IFNAME] == NULL\n");
 219     return (-1);
 220   }
 221   dev = RTA_DATA (attrs[IFLA_IFNAME]);
 222
 223   if (check_ignorelist (dev, "interface", NULL) == 0)
 224   {
 225     submit_two (dev, "if_octets", NULL, stats->rx_bytes, stats->tx_bytes);
 226     submit_two (dev, "if_packets", NULL, stats->rx_bytes, stats->tx_bytes);
 227     submit_two (dev, "if_errors", NULL, stats->rx_bytes, stats->tx_bytes);
 228   }
 229   else
 230   {
 231     DEBUG ("netlink plugin: Ignoring %s/interface.", dev);
 232   }
 233
 234   if (check_ignorelist (dev, "if_detail", NULL) == 0)
 235   {
 236     submit_two (dev, "if_dropped", NULL, stats->rx_bytes, stats->tx_bytes);
 237     submit_one (dev, "if_multicast", NULL, stats->multicast);
 238     submit_one (dev, "if_collisions", NULL, stats->collisions);
 239     /* FIXME: Add the rest */
 240   }
 241   else
 242   {
 243     DEBUG ("netlink plugin: Ignoring %s/if_detail.", dev);
 244   }
 245
 246   return (0);
 247 } /* int link_filter */
 248
 249 static int qos_filter (const struct sockaddr_nl *sa, struct nlmsghdr *nmh,
 250     void *args)
 251 {
 252   struct tcmsg *msg;
 253   int msg_len;
 254   struct rtattr *attrs[TCA_MAX + 1];
 255
 256   const char *dev;
 257
 258   /* char *type_instance; */
 259   char *tc_type;
 260   char tc_inst[DATA_MAX_NAME_LEN];
 261
 262   printf ("=== qos_filter ===\n");
 263
 264   if (nmh->nlmsg_type == RTM_NEWQDISC)
 265     tc_type = "qdisc";
 266   else if (nmh->nlmsg_type == RTM_NEWTCLASS)
 267     tc_type = "class";
 268   else if (nmh->nlmsg_type == RTM_NEWTFILTER)
 269     tc_type = "filter";
 270   else
 271   {
 272     ERROR ("netlink plugin: qos_filter: Don't know how to handle type %i.\n",
 273         nmh->nlmsg_type);
 274     return (-1);
 275   }
 276
 277   msg = NLMSG_DATA (nmh);
 278
 279   msg_len = nmh->nlmsg_len - sizeof (struct tcmsg);
 280   if (msg_len < 0)
 281   {
 282     ERROR ("netlink plugin: qos_filter: msg_len = %i < 0;\n", msg_len);
 283     return (-1);
 284   }
 285
 286   dev = ll_index_to_name (msg->tcm_ifindex);
 287   if (dev == NULL)
 288   {
 289     ERROR ("netlink plugin: qos_filter: ll_index_to_name (%i) failed.\n",
 290         msg->tcm_ifindex);
 291     return (-1);
 292   }
 293
 294   memset (attrs, '\0', sizeof (attrs));
 295   if (parse_rtattr (attrs, TCA_MAX, TCA_RTA (msg), msg_len) != 0)
 296   {
 297     ERROR ("netlink plugin: qos_filter: parse_rtattr failed.\n");
 298     return (-1);
 299   }
 300
 301   if (attrs[TCA_KIND] == NULL)
 302   {
 303     ERROR ("netlink plugin: qos_filter: attrs[TCA_KIND] == NULL\n");
 304     return (-1);
 305   }
 306   snprintf (tc_inst, sizeof (tc_inst), "%s-%x",
 307       (const char *) RTA_DATA (attrs[TCA_KIND]), (msg->tcm_handle >> 16));
 308   tc_inst[sizeof (tc_inst) - 1] = '\0';
 309
 310   if (check_ignorelist (dev, tc_type, tc_inst))
 311     return (0);
 312
 313   if (attrs[TCA_STATS2])
 314   {
 315     struct rtattr *attrs_stats[TCA_STATS_MAX + 1];
 316
 317     memset (attrs_stats, '\0', sizeof (attrs_stats));
 318     parse_rtattr_nested (attrs_stats, TCA_STATS_MAX, attrs[TCA_STATS2]);
 319
 320     if (attrs_stats[TCA_STATS_BASIC])
 321     {
 322       struct gnet_stats_basic bs;
 323       char type_instance[DATA_MAX_NAME_LEN];
 324
 325       snprintf (type_instance, sizeof (type_instance), "%s-%s",
 326           tc_type, tc_inst);
 327       type_instance[sizeof (type_instance) - 1] = '\0';
 328
 329       memset (&bs, '\0', sizeof (bs));
 330       memcpy (&bs, RTA_DATA (attrs_stats[TCA_STATS_BASIC]),
 331           MIN (RTA_PAYLOAD (attrs_stats[TCA_STATS_BASIC]), sizeof(bs)));
 332
 333       submit_one (dev, "ipt_octets", type_instance, bs.bytes);
 334       submit_one (dev, "ipt_packets", type_instance, bs.packets);
 335     }
 336   }
 337
 338   return (0);
 339 } /* int qos_filter */
 340
 341 static int ir_config (const char *key, const char *value)
 342 {
 343   char *new_val;
 344   char *fields[8];
 345   int fields_num;
 346   int status = 1;
 347
 348   new_val = strdup (value);
 349   if (new_val == NULL)
 350     return (-1);
 351
 352   fields_num = strsplit (new_val, fields, STATIC_ARRAY_SIZE (fields));
 353   if ((fields_num < 1) || (fields_num > 8))
 354   {
 355     sfree (new_val);
 356     return (-1);
 357   }
 358
 359   if ((strcasecmp (key, "Interface") == 0)
 360       || (strcasecmp (key, "VerboseInterface") == 0))
 361   {
 362     if (fields_num != 1)
 363     {
 364       ERROR ("netlink plugin: Invalid number of fields for option "
 365           "`%s'. Got %i, expected 1.", key, fields_num);
 366       status = -1;
 367     }
 368     else
 369     {
 370       add_ignorelist (fields[0], "interface", NULL);
 371       if (strcasecmp (key, "VerboseInterface") == 0)
 372         add_ignorelist (fields[0], "if_detail", NULL);
 373       status = 0;
 374     }
 375   }
 376   else if ((strcasecmp (key, "QDisc") == 0)
 377       || (strcasecmp (key, "Class") == 0)
 378       || (strcasecmp (key, "Filter") == 0))
 379   {
 380     if ((fields_num < 1) || (fields_num > 2))
 381     {
 382       ERROR ("netlink plugin: Invalid number of fields for option "
 383           "`%s'. Got %i, expected 1 or 2.", key, fields_num);
 384       return (-1);
 385     }
 386     else
 387     {
 388       add_ignorelist (fields[0], key,
 389           (fields_num == 2) ? fields[1] : NULL);
 390       status = 0;
 391     }
 392   }
 393   else if (strcasecmp (key, "IgnoreSelected"))
 394   {
 395     if (fields_num != 1)
 396     {
 397       ERROR ("netlink plugin: Invalid number of fields for option "
 398           "`IgnoreSelected'. Got %i, expected 1.", fields_num);
 399       status = -1;
 400     }
 401     else
 402     {
 403       if ((strcasecmp (fields[0], "yes") == 0)
 404           || (strcasecmp (fields[0], "true") == 0)
 405           || (strcasecmp (fields[0], "on") == 0))
 406         ir_ignorelist_invert = 0;
 407       else
 408         ir_ignorelist_invert = 1;
 409       status = 0;
 410     }
 411   }
 412
 413   sfree (new_val);
 414
 415   return (status);
 416 } /* int ir_config */
 417
 418 static int ir_init (void)
 419 {
 420   memset (&rth, '\0', sizeof (rth));
 421
 422   if (rtnl_open (&rth, 0) != 0)
 423   {
 424     ERROR ("netlink plugin: print_stats: rtnl_open failed.\n");
 425     return (-1);
 426   }
 427
 428   if (ll_init_map (&rth) != 0)
 429   {
 430     ERROR ("netlink plugin: print_stats: ll_init_map failed.\n");
 431     return (-1);
 432   }
 433
 434   return (0);
 435 } /* int ir_init */
 436
 437 static int ir_read (void)
 438 {
 439   struct ifinfomsg im;
 440   struct tcmsg tm;
 441
 442   memset (&im, '\0', sizeof (im));
 443   im.ifi_type = AF_UNSPEC;
 444
 445   memset (&tm, '\0', sizeof (tm));
 446   tm.tcm_family = AF_UNSPEC;
 447
 448   if (rtnl_dump_request (&rth, RTM_GETLINK, &im, sizeof (im)) < 0)
 449   {
 450     ERROR ("netlink plugin: print_stats: rtnl_dump_request failed.\n");
 451     return (-1);
 452   }
 453
 454   if (rtnl_dump_filter (&rth, link_filter, /* arg1 = */ NULL,
 455         NULL, NULL) != 0)
 456   {
 457     ERROR ("netlink plugin: print_stats: rtnl_dump_filter failed.\n");
 458     return (-1);
 459   }
 460
 461   /* Get QDisc stats */
 462   if (rtnl_dump_request (&rth, RTM_GETQDISC, &tm, sizeof (tm)) < 0)
 463   {
 464     ERROR ("netlink plugin: print_stats: rtnl_dump_request failed.\n");
 465     return (-1);
 466   }
 467
 468   if (rtnl_dump_filter (&rth, qos_filter, /* arg1 = */ NULL,
 469         NULL, NULL) != 0)
 470   {
 471     ERROR ("netlink plugin: print_stats: rtnl_dump_filter failed.\n");
 472     return (-1);
 473   }
 474
 475   /* Get Class stats */
 476   if (rtnl_dump_request (&rth, RTM_GETTCLASS, &tm, sizeof (tm)) < 0)
 477   {
 478     ERROR ("netlink plugin: print_stats: rtnl_dump_request failed.\n");
 479     return (-1);
 480   }
 481
 482   if (rtnl_dump_filter (&rth, qos_filter, /* arg1 = */ NULL,
 483         NULL, NULL) != 0)
 484   {
 485     ERROR ("netlink plugin: print_stats: rtnl_dump_filter failed.\n");
 486     return (-1);
 487   }
 488
 489   /* Get Filter stats */
 490   if (rtnl_dump_request (&rth, RTM_GETTFILTER, &tm, sizeof (tm)) < 0)
 491   {
 492     ERROR ("netlink plugin: print_stats: rtnl_dump_request failed.\n");
 493     return (-1);
 494   }
 495
 496   if (rtnl_dump_filter (&rth, qos_filter, /* arg1 = */ NULL,
 497         NULL, NULL) != 0)
 498   {
 499     ERROR ("netlink plugin: print_stats: rtnl_dump_filter failed.\n");
 500     return (-1);
 501   }
 502
 503
 504   return (0);
 505 } /* int print_stats */
 506
 507 static int ir_shutdown (void)
 508 {
 509   if ((rth.fd != 0) || (rth.seq != 0) || (rth.dump != 0))
 510   {
 511     rtnl_close(&rth);
 512     memset (&rth, '\0', sizeof (rth));
 513   }
 514
 515   return (0);
 516 } /* int ir_shutdown */
 517
 518 void module_register (void)
 519 {
 520   plugin_register_config ("netlink", ir_config, config_keys, config_keys_num);
 521   plugin_register_init ("netlink", ir_init);
 522   plugin_register_read ("netlink", ir_read);
 523   plugin_register_shutdown ("netlink", ir_shutdown);
 524 } /* void module_register */
 525
 526 /*
 527  * vim: set shiftwidth=2 softtabstop=2 tabstop=8 :
 528  */