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