src/ping.c

   1 /**
   2  * collectd - src/ping.c
   3  * Copyright (C) 2005-2012  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 collectd.org>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "common.h"
  24 #include "plugin.h"
  25 #include "configfile.h"
  26
  27 #include <pthread.h>
  28 #include <netinet/in.h>
  29 #if HAVE_NETDB_H
  30 # include <netdb.h> /* NI_MAXHOST */
  31 #endif
  32
  33 #include <oping.h>
  34
  35 #ifndef NI_MAXHOST
  36 # define NI_MAXHOST 1025
  37 #endif
  38
  39 #if defined(OPING_VERSION) && (OPING_VERSION >= 1003000)
  40 # define HAVE_OPING_1_3
  41 #endif
  42
  43 /*
  44  * Private data types
  45  */
  46 struct hostlist_s
  47 {
  48   char *host;
  49
  50   uint32_t pkg_sent;
  51   uint32_t pkg_recv;
  52   uint32_t pkg_missed;
  53
  54   double latency_total;
  55   double latency_squared;
  56
  57   struct hostlist_s *next;
  58 };
  59 typedef struct hostlist_s hostlist_t;
  60
  61 /*
  62  * Private variables
  63  */
  64 static hostlist_t *hostlist_head = NULL;
  65
  66 static char  *ping_source = NULL;
  67 #ifdef HAVE_OPING_1_3
  68 static char  *ping_device = NULL;
  69 #endif
  70 static int    ping_ttl = PING_DEF_TTL;
  71 static double ping_interval = 1.0;
  72 static double ping_timeout = 0.9;
  73 static int    ping_max_missed = -1;
  74
  75 static int             ping_thread_loop = 0;
  76 static int             ping_thread_error = 0;
  77 static pthread_t       ping_thread_id;
  78 static pthread_mutex_t ping_lock = PTHREAD_MUTEX_INITIALIZER;
  79 static pthread_cond_t  ping_cond = PTHREAD_COND_INITIALIZER;
  80
  81 static const char *config_keys[] =
  82 {
  83   "Host",
  84   "SourceAddress",
  85 #ifdef HAVE_OPING_1_3
  86   "Device",
  87 #endif
  88   "TTL",
  89   "Interval",
  90   "Timeout",
  91   "MaxMissed"
  92 };
  93 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  94
  95 /*
  96  * Private functions
  97  */
  98 /* Assure that `ts->tv_nsec' is in the range 0 .. 999999999 */
  99 static void time_normalize (struct timespec *ts) /* {{{ */
 100 {
 101   while (ts->tv_nsec < 0)
 102   {
 103     if (ts->tv_sec == 0)
 104     {
 105       ts->tv_nsec = 0;
 106       return;
 107     }
 108
 109     ts->tv_sec  -= 1;
 110     ts->tv_nsec += 1000000000;
 111   }
 112
 113   while (ts->tv_nsec >= 1000000000)
 114   {
 115     ts->tv_sec  += 1;
 116     ts->tv_nsec -= 1000000000;
 117   }
 118 } /* }}} void time_normalize */
 119
 120 /* Add `ts_int' to `tv_begin' and store the result in `ts_dest'. If the result
 121  * is larger than `tv_end', copy `tv_end' to `ts_dest' instead. */
 122 static void time_calc (struct timespec *ts_dest, /* {{{ */
 123     const struct timespec *ts_int,
 124     const struct timeval  *tv_begin,
 125     const struct timeval  *tv_end)
 126 {
 127   ts_dest->tv_sec = tv_begin->tv_sec + ts_int->tv_sec;
 128   ts_dest->tv_nsec = (tv_begin->tv_usec * 1000) + ts_int->tv_nsec;
 129   time_normalize (ts_dest);
 130
 131   /* Assure that `(begin + interval) > end'.
 132    * This may seem overly complicated, but `tv_sec' is of type `time_t'
 133    * which may be `unsigned. *sigh* */
 134   if ((tv_end->tv_sec > ts_dest->tv_sec)
 135       || ((tv_end->tv_sec == ts_dest->tv_sec)
 136         && ((tv_end->tv_usec * 1000) > ts_dest->tv_nsec)))
 137   {
 138     ts_dest->tv_sec = tv_end->tv_sec;
 139     ts_dest->tv_nsec = 1000 * tv_end->tv_usec;
 140   }
 141
 142   time_normalize (ts_dest);
 143 } /* }}} void time_calc */
 144
 145 static int ping_dispatch_all (pingobj_t *pingobj) /* {{{ */
 146 {
 147   pingobj_iter_t *iter;
 148   hostlist_t *hl;
 149   int status;
 150
 151   for (iter = ping_iterator_get (pingobj);
 152       iter != NULL;
 153       iter = ping_iterator_next (iter))
 154   { /* {{{ */
 155     char userhost[NI_MAXHOST];
 156     double latency;
 157     size_t param_size;
 158
 159     param_size = sizeof (userhost);
 160     status = ping_iterator_get_info (iter,
 161 #ifdef PING_INFO_USERNAME
 162         PING_INFO_USERNAME,
 163 #else
 164         PING_INFO_HOSTNAME,
 165 #endif
 166         userhost, &param_size);
 167     if (status != 0)
 168     {
 169       WARNING ("ping plugin: ping_iterator_get_info failed: %s",
 170           ping_get_error (pingobj));
 171       continue;
 172     }
 173
 174     for (hl = hostlist_head; hl != NULL; hl = hl->next)
 175       if (strcmp (userhost, hl->host) == 0)
 176         break;
 177
 178     if (hl == NULL)
 179     {
 180       WARNING ("ping plugin: Cannot find host %s.", userhost);
 181       continue;
 182     }
 183
 184     param_size = sizeof (latency);
 185     status = ping_iterator_get_info (iter, PING_INFO_LATENCY,
 186         (void *) &latency, &param_size);
 187     if (status != 0)
 188     {
 189       WARNING ("ping plugin: ping_iterator_get_info failed: %s",
 190           ping_get_error (pingobj));
 191       continue;
 192     }
 193
 194     hl->pkg_sent++;
 195     if (latency >= 0.0)
 196     {
 197       hl->pkg_recv++;
 198       hl->latency_total += latency;
 199       hl->latency_squared += (latency * latency);
 200
 201       /* reset missed packages counter */
 202       hl->pkg_missed = 0;
 203     } else
 204       hl->pkg_missed++;
 205
 206     /* if the host did not answer our last N packages, trigger a resolv. */
 207     if (ping_max_missed >= 0 && hl->pkg_missed >= ping_max_missed)
 208     { /* {{{ */
 209       /* we reset the missed package counter here, since we only want to
 210        * trigger a resolv every N packages and not every package _AFTER_ N
 211        * missed packages */
 212       hl->pkg_missed = 0;
 213
 214       WARNING ("ping plugin: host %s has not answered %d PING requests,"
 215           " triggering resolve", hl->host, ping_max_missed);
 216
 217       /* we trigger the resolv simply be removeing and adding the host to our
 218        * ping object */
 219       status = ping_host_remove (pingobj, hl->host);
 220       if (status != 0)
 221       {
 222         WARNING ("ping plugin: ping_host_remove (%s) failed.", hl->host);
 223       }
 224       else
 225       {
 226         status = ping_host_add (pingobj, hl->host);
 227         if (status != 0)
 228           ERROR ("ping plugin: ping_host_add (%s) failed.", hl->host);
 229       }
 230     } /* }}} ping_max_missed */
 231   } /* }}} for (iter) */
 232
 233   return (0);
 234 } /* }}} int ping_dispatch_all */
 235
 236 static void *ping_thread (void *arg) /* {{{ */
 237 {
 238   static pingobj_t *pingobj = NULL;
 239
 240   struct timeval  tv_begin;
 241   struct timeval  tv_end;
 242   struct timespec ts_wait;
 243   struct timespec ts_int;
 244
 245   hostlist_t *hl;
 246   int count;
 247
 248   pthread_mutex_lock (&ping_lock);
 249
 250   pingobj = ping_construct ();
 251   if (pingobj == NULL)
 252   {
 253     ERROR ("ping plugin: ping_construct failed.");
 254     ping_thread_error = 1;
 255     pthread_mutex_unlock (&ping_lock);
 256     return ((void *) -1);
 257   }
 258
 259   if (ping_source != NULL)
 260     if (ping_setopt (pingobj, PING_OPT_SOURCE, (void *) ping_source) != 0)
 261       ERROR ("ping plugin: Failed to set source address: %s",
 262           ping_get_error (pingobj));
 263
 264 #ifdef HAVE_OPING_1_3
 265   if (ping_device != NULL)
 266     if (ping_setopt (pingobj, PING_OPT_DEVICE, (void *) ping_device) != 0)
 267       ERROR ("ping plugin: Failed to set device: %s",
 268           ping_get_error (pingobj));
 269 #endif
 270
 271   ping_setopt (pingobj, PING_OPT_TIMEOUT, (void *) &ping_timeout);
 272   ping_setopt (pingobj, PING_OPT_TTL, (void *) &ping_ttl);
 273
 274   /* Add all the hosts to the ping object. */
 275   count = 0;
 276   for (hl = hostlist_head; hl != NULL; hl = hl->next)
 277   {
 278     int tmp_status;
 279     tmp_status = ping_host_add (pingobj, hl->host);
 280     if (tmp_status != 0)
 281       WARNING ("ping plugin: ping_host_add (%s) failed: %s",
 282           hl->host, ping_get_error (pingobj));
 283     else
 284       count++;
 285   }
 286
 287   if (count == 0)
 288   {
 289     ERROR ("ping plugin: No host could be added to ping object. Giving up.");
 290     ping_thread_error = 1;
 291     pthread_mutex_unlock (&ping_lock);
 292     return ((void *) -1);
 293   }
 294
 295   /* Set up `ts_int' */
 296   {
 297     double temp_sec;
 298     double temp_nsec;
 299
 300     temp_nsec = modf (ping_interval, &temp_sec);
 301     ts_int.tv_sec  = (time_t) temp_sec;
 302     ts_int.tv_nsec = (long) (temp_nsec * 1000000000L);
 303   }
 304
 305   while (ping_thread_loop > 0)
 306   {
 307     int status;
 308
 309     if (gettimeofday (&tv_begin, NULL) < 0)
 310     {
 311       char errbuf[1024];
 312       ERROR ("ping plugin: gettimeofday failed: %s",
 313           sstrerror (errno, errbuf, sizeof (errbuf)));
 314       ping_thread_error = 1;
 315       break;
 316     }
 317
 318     pthread_mutex_unlock (&ping_lock);
 319
 320     status = ping_send (pingobj);
 321     if (status < 0)
 322     {
 323       ERROR ("ping plugin: ping_send failed: %s", ping_get_error (pingobj));
 324       pthread_mutex_lock (&ping_lock);
 325       ping_thread_error = 1;
 326       break;
 327     }
 328
 329     pthread_mutex_lock (&ping_lock);
 330
 331     if (ping_thread_loop <= 0)
 332       break;
 333
 334     (void) ping_dispatch_all (pingobj);
 335
 336     if (gettimeofday (&tv_end, NULL) < 0)
 337     {
 338       char errbuf[1024];
 339       ERROR ("ping plugin: gettimeofday failed: %s",
 340           sstrerror (errno, errbuf, sizeof (errbuf)));
 341       ping_thread_error = 1;
 342       break;
 343     }
 344
 345     /* Calculate the absolute time until which to wait and store it in
 346      * `ts_wait'. */
 347     time_calc (&ts_wait, &ts_int, &tv_begin, &tv_end);
 348
 349     status = pthread_cond_timedwait (&ping_cond, &ping_lock, &ts_wait);
 350     if (ping_thread_loop <= 0)
 351       break;
 352   } /* while (ping_thread_loop > 0) */
 353
 354   pthread_mutex_unlock (&ping_lock);
 355   ping_destroy (pingobj);
 356
 357   return ((void *) 0);
 358 } /* }}} void *ping_thread */
 359
 360 static int start_thread (void) /* {{{ */
 361 {
 362   int status;
 363
 364   pthread_mutex_lock (&ping_lock);
 365
 366   if (ping_thread_loop != 0)
 367   {
 368     pthread_mutex_unlock (&ping_lock);
 369     return (-1);
 370   }
 371
 372   ping_thread_loop = 1;
 373   ping_thread_error = 0;
 374   status = pthread_create (&ping_thread_id, /* attr = */ NULL,
 375       ping_thread, /* arg = */ (void *) 0);
 376   if (status != 0)
 377   {
 378     ping_thread_loop = 0;
 379     ERROR ("ping plugin: Starting thread failed.");
 380     pthread_mutex_unlock (&ping_lock);
 381     return (-1);
 382   }
 383
 384   pthread_mutex_unlock (&ping_lock);
 385   return (0);
 386 } /* }}} int start_thread */
 387
 388 static int stop_thread (void) /* {{{ */
 389 {
 390   int status;
 391
 392   pthread_mutex_lock (&ping_lock);
 393
 394   if (ping_thread_loop == 0)
 395   {
 396     pthread_mutex_unlock (&ping_lock);
 397     return (-1);
 398   }
 399
 400   ping_thread_loop = 0;
 401   pthread_cond_broadcast (&ping_cond);
 402   pthread_mutex_unlock (&ping_lock);
 403
 404   status = pthread_join (ping_thread_id, /* return = */ NULL);
 405   if (status != 0)
 406   {
 407     ERROR ("ping plugin: Stopping thread failed.");
 408     status = -1;
 409   }
 410
 411   memset (&ping_thread_id, 0, sizeof (ping_thread_id));
 412   ping_thread_error = 0;
 413
 414   return (status);
 415 } /* }}} int stop_thread */
 416
 417 static int ping_init (void) /* {{{ */
 418 {
 419   if (hostlist_head == NULL)
 420   {
 421     NOTICE ("ping plugin: No hosts have been configured.");
 422     return (-1);
 423   }
 424
 425   if (ping_timeout > ping_interval)
 426   {
 427     ping_timeout = 0.9 * ping_interval;
 428     WARNING ("ping plugin: Timeout is greater than interval. "
 429         "Will use a timeout of %gs.", ping_timeout);
 430   }
 431
 432   if (start_thread () != 0)
 433     return (-1);
 434
 435   return (0);
 436 } /* }}} int ping_init */
 437
 438 static int config_set_string (const char *name, /* {{{ */
 439     char **var, const char *value)
 440 {
 441   char *tmp;
 442
 443   tmp = strdup (value);
 444   if (tmp == NULL)
 445   {
 446     char errbuf[1024];
 447     ERROR ("ping plugin: Setting `%s' to `%s' failed: strdup failed: %s",
 448         name, value, sstrerror (errno, errbuf, sizeof (errbuf)));
 449     return (1);
 450   }
 451
 452   if (*var != NULL)
 453     free (*var);
 454   *var = tmp;
 455   return (0);
 456 } /* }}} int config_set_string */
 457
 458 static int ping_config (const char *key, const char *value) /* {{{ */
 459 {
 460   if (strcasecmp (key, "Host") == 0)
 461   {
 462     hostlist_t *hl;
 463     char *host;
 464
 465     hl = (hostlist_t *) malloc (sizeof (hostlist_t));
 466     if (hl == NULL)
 467     {
 468       char errbuf[1024];
 469       ERROR ("ping plugin: malloc failed: %s",
 470           sstrerror (errno, errbuf, sizeof (errbuf)));
 471       return (1);
 472     }
 473
 474     host = strdup (value);
 475     if (host == NULL)
 476     {
 477       char errbuf[1024];
 478       sfree (hl);
 479       ERROR ("ping plugin: strdup failed: %s",
 480           sstrerror (errno, errbuf, sizeof (errbuf)));
 481       return (1);
 482     }
 483
 484     hl->host = host;
 485     hl->pkg_sent = 0;
 486     hl->pkg_recv = 0;
 487     hl->pkg_missed = 0;
 488     hl->latency_total = 0.0;
 489     hl->latency_squared = 0.0;
 490     hl->next = hostlist_head;
 491     hostlist_head = hl;
 492   }
 493   else if (strcasecmp (key, "SourceAddress") == 0)
 494   {
 495     int status = config_set_string (key, &ping_source, value);
 496     if (status != 0)
 497       return (status);
 498   }
 499 #ifdef HAVE_OPING_1_3
 500   else if (strcasecmp (key, "Device") == 0)
 501   {
 502     int status = config_set_string (key, &ping_device, value);
 503     if (status != 0)
 504       return (status);
 505   }
 506 #endif
 507   else if (strcasecmp (key, "TTL") == 0)
 508   {
 509     int ttl = atoi (value);
 510     if ((ttl > 0) && (ttl <= 255))
 511       ping_ttl = ttl;
 512     else
 513       WARNING ("ping plugin: Ignoring invalid TTL %i.", ttl);
 514   }
 515   else if (strcasecmp (key, "Interval") == 0)
 516   {
 517     double tmp;
 518
 519     tmp = atof (value);
 520     if (tmp > 0.0)
 521       ping_interval = tmp;
 522     else
 523       WARNING ("ping plugin: Ignoring invalid interval %g (%s)",
 524           tmp, value);
 525   }
 526   else if (strcasecmp (key, "Timeout") == 0)
 527   {
 528     double tmp;
 529
 530     tmp = atof (value);
 531     if (tmp > 0.0)
 532       ping_timeout = tmp;
 533     else
 534       WARNING ("ping plugin: Ignoring invalid timeout %g (%s)",
 535           tmp, value);
 536   }
 537   else if (strcasecmp (key, "MaxMissed") == 0)
 538   {
 539     ping_max_missed = atoi (value);
 540     if (ping_max_missed < 0)
 541       INFO ("ping plugin: MaxMissed < 0, disabled re-resolving of hosts");
 542   }
 543   else
 544   {
 545     return (-1);
 546   }
 547
 548   return (0);
 549 } /* }}} int ping_config */
 550
 551 static void submit (const char *host, const char *type, /* {{{ */
 552     gauge_t value)
 553 {
 554   value_t values[1];
 555   value_list_t vl = VALUE_LIST_INIT;
 556
 557   values[0].gauge = value;
 558
 559   vl.values = values;
 560   vl.values_len = 1;
 561   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 562   sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
 563   sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
 564   sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
 565   sstrncpy (vl.type, type, sizeof (vl.type));
 566
 567   plugin_dispatch_values (&vl);
 568 } /* }}} void ping_submit */
 569
 570 static int ping_read (void) /* {{{ */
 571 {
 572   hostlist_t *hl;
 573
 574   if (ping_thread_error != 0)
 575   {
 576     ERROR ("ping plugin: The ping thread had a problem. Restarting it.");
 577
 578     stop_thread ();
 579
 580     for (hl = hostlist_head; hl != NULL; hl = hl->next)
 581     {
 582       hl->pkg_sent = 0;
 583       hl->pkg_recv = 0;
 584       hl->latency_total = 0.0;
 585       hl->latency_squared = 0.0;
 586     }
 587
 588     start_thread ();
 589
 590     return (-1);
 591   } /* if (ping_thread_error != 0) */
 592
 593   for (hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
 594   {
 595     uint32_t pkg_sent;
 596     uint32_t pkg_recv;
 597     double latency_total;
 598     double latency_squared;
 599
 600     double latency_average;
 601     double latency_stddev;
 602
 603     double droprate;
 604
 605     /* Locking here works, because the structure of the linked list is only
 606      * changed during configure and shutdown. */
 607     pthread_mutex_lock (&ping_lock);
 608
 609     pkg_sent = hl->pkg_sent;
 610     pkg_recv = hl->pkg_recv;
 611     latency_total = hl->latency_total;
 612     latency_squared = hl->latency_squared;
 613
 614     hl->pkg_sent = 0;
 615     hl->pkg_recv = 0;
 616     hl->latency_total = 0.0;
 617     hl->latency_squared = 0.0;
 618
 619     pthread_mutex_unlock (&ping_lock);
 620
 621     /* This e. g. happens when starting up. */
 622     if (pkg_sent == 0)
 623     {
 624       DEBUG ("ping plugin: No packages for host %s have been sent.",
 625           hl->host);
 626       continue;
 627     }
 628
 629     /* Calculate average. Beware of division by zero. */
 630     if (pkg_recv == 0)
 631       latency_average = NAN;
 632     else
 633       latency_average = latency_total / ((double) pkg_recv);
 634
 635     /* Calculate standard deviation. Beware even more of division by zero. */
 636     if (pkg_recv == 0)
 637       latency_stddev = NAN;
 638     else if (pkg_recv == 1)
 639       latency_stddev = 0.0;
 640     else
 641       latency_stddev = sqrt (((((double) pkg_recv) * latency_squared)
 642           - (latency_total * latency_total))
 643           / ((double) (pkg_recv * (pkg_recv - 1))));
 644
 645     /* Calculate drop rate. */
 646     droprate = ((double) (pkg_sent - pkg_recv)) / ((double) pkg_sent);
 647
 648     submit (hl->host, "ping", latency_average);
 649     submit (hl->host, "ping_stddev", latency_stddev);
 650     submit (hl->host, "ping_droprate", droprate);
 651   } /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
 652
 653   return (0);
 654 } /* }}} int ping_read */
 655
 656 static int ping_shutdown (void) /* {{{ */
 657 {
 658   hostlist_t *hl;
 659
 660   INFO ("ping plugin: Shutting down thread.");
 661   if (stop_thread () < 0)
 662     return (-1);
 663
 664   hl = hostlist_head;
 665   while (hl != NULL)
 666   {
 667     hostlist_t *hl_next;
 668
 669     hl_next = hl->next;
 670
 671     sfree (hl->host);
 672     sfree (hl);
 673
 674     hl = hl_next;
 675   }
 676
 677   return (0);
 678 } /* }}} int ping_shutdown */
 679
 680 void module_register (void)
 681 {
 682   plugin_register_config ("ping", ping_config,
 683       config_keys, config_keys_num);
 684   plugin_register_init ("ping", ping_init);
 685   plugin_register_read ("ping", ping_read);
 686   plugin_register_shutdown ("ping", ping_shutdown);
 687 } /* void module_register */
 688
 689 /* vim: set sw=2 sts=2 et fdm=marker : */