2 * collectd - src/ping.c
3 * Copyright (C) 2005-2009 Florian octo Forster
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.
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.
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
19 * Florian octo Forster <octo at verplant.org>
25 #include "configfile.h"
28 #include <netinet/in.h>
30 # include <netdb.h> /* NI_MAXHOST */
36 # define NI_MAXHOST 1025
39 #if defined(OPING_VERSION) && (OPING_VERSION >= 1003000)
40 # define HAVE_OPING_1_3
55 double latency_squared;
57 struct hostlist_s *next;
59 typedef struct hostlist_s hostlist_t;
64 static hostlist_t *hostlist_head = NULL;
66 static char *ping_source = NULL;
68 static char *ping_device = NULL;
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;
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;
81 static const char *config_keys[] =
93 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
98 /* Assure that `ts->tv_nsec' is in the range 0 .. 999999999 */
99 static void time_normalize (struct timespec *ts) /* {{{ */
101 while (ts->tv_nsec < 0)
110 ts->tv_nsec += 1000000000;
113 while (ts->tv_nsec >= 1000000000)
116 ts->tv_nsec -= 1000000000;
118 } /* }}} void time_normalize */
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)
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);
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)))
138 ts_dest->tv_sec = tv_end->tv_sec;
139 ts_dest->tv_nsec = 1000 * tv_end->tv_usec;
142 time_normalize (ts_dest);
143 } /* }}} void time_calc */
145 static void *ping_thread (void *arg) /* {{{ */
147 static pingobj_t *pingobj = NULL;
149 struct timeval tv_begin;
150 struct timeval tv_end;
151 struct timespec ts_wait;
152 struct timespec ts_int;
157 pthread_mutex_lock (&ping_lock);
159 pingobj = ping_construct ();
162 ERROR ("ping plugin: ping_construct failed.");
163 ping_thread_error = 1;
164 pthread_mutex_unlock (&ping_lock);
165 return ((void *) -1);
168 if (ping_source != NULL)
169 if (ping_setopt (pingobj, PING_OPT_SOURCE, (void *) ping_source) != 0)
170 ERROR ("ping plugin: Failed to set source address: %s",
171 ping_get_error (pingobj));
173 #ifdef HAVE_OPING_1_3
174 if (ping_device != NULL)
175 if (ping_setopt (pingobj, PING_OPT_DEVICE, (void *) ping_device) != 0)
176 ERROR ("ping plugin: Failed to set device: %s",
177 ping_get_error (pingobj));
180 ping_setopt (pingobj, PING_OPT_TIMEOUT, (void *) &ping_timeout);
181 ping_setopt (pingobj, PING_OPT_TTL, (void *) &ping_ttl);
183 /* Add all the hosts to the ping object. */
185 for (hl = hostlist_head; hl != NULL; hl = hl->next)
188 tmp_status = ping_host_add (pingobj, hl->host);
190 WARNING ("ping plugin: ping_host_add (%s) failed: %s",
191 hl->host, ping_get_error (pingobj));
198 ERROR ("ping plugin: No host could be added to ping object. Giving up.");
199 ping_thread_error = 1;
200 pthread_mutex_unlock (&ping_lock);
201 return ((void *) -1);
204 /* Set up `ts_int' */
209 temp_nsec = modf (ping_interval, &temp_sec);
210 ts_int.tv_sec = (time_t) temp_sec;
211 ts_int.tv_nsec = (long) (temp_nsec * 1000000000L);
214 while (ping_thread_loop > 0)
216 pingobj_iter_t *iter;
219 if (gettimeofday (&tv_begin, NULL) < 0)
222 ERROR ("ping plugin: gettimeofday failed: %s",
223 sstrerror (errno, errbuf, sizeof (errbuf)));
224 ping_thread_error = 1;
228 pthread_mutex_unlock (&ping_lock);
230 status = ping_send (pingobj);
233 ERROR ("ping plugin: ping_send failed: %s", ping_get_error (pingobj));
234 pthread_mutex_lock (&ping_lock);
235 ping_thread_error = 1;
239 pthread_mutex_lock (&ping_lock);
241 if (ping_thread_loop <= 0)
244 for (iter = ping_iterator_get (pingobj);
246 iter = ping_iterator_next (iter))
248 char userhost[NI_MAXHOST];
252 param_size = sizeof (userhost);
253 status = ping_iterator_get_info (iter,
254 #ifdef PING_INFO_USERNAME
259 userhost, ¶m_size);
262 WARNING ("ping plugin: ping_iterator_get_info failed: %s",
263 ping_get_error (pingobj));
267 for (hl = hostlist_head; hl != NULL; hl = hl->next)
268 if (strcmp (userhost, hl->host) == 0)
273 WARNING ("ping plugin: Cannot find host %s.", userhost);
277 param_size = sizeof (latency);
278 status = ping_iterator_get_info (iter, PING_INFO_LATENCY,
279 (void *) &latency, ¶m_size);
282 WARNING ("ping plugin: ping_iterator_get_info failed: %s",
283 ping_get_error (pingobj));
291 hl->latency_total += latency;
292 hl->latency_squared += (latency * latency);
294 /* reset missed packages counter */
299 /* if the host did not answer our last N packages, trigger a resolv. */
300 if (ping_max_missed >= 0 && hl->pkg_missed >= ping_max_missed)
302 /* we reset the missed package counter here, since we only want to
303 * trigger a resolv every N packages and not every package _AFTER_ N
307 WARNING ("ping plugin: host %s has not answered %d PING requests,"
308 " triggering resolve", hl->host, ping_max_missed);
310 /* we trigger the resolv simply be removeing and adding the host to our
312 status = ping_host_remove (pingobj, hl->host);
315 WARNING ("ping plugin: ping_host_remove (%s) failed.", hl->host);
319 status = ping_host_add (pingobj, hl->host);
321 WARNING ("ping plugin: ping_host_add (%s) failed.", hl->host);
323 } /* }}} ping_max_missed */
324 } /* }}} for (iter) */
326 if (gettimeofday (&tv_end, NULL) < 0)
329 ERROR ("ping plugin: gettimeofday failed: %s",
330 sstrerror (errno, errbuf, sizeof (errbuf)));
331 ping_thread_error = 1;
335 /* Calculate the absolute time until which to wait and store it in
337 time_calc (&ts_wait, &ts_int, &tv_begin, &tv_end);
339 status = pthread_cond_timedwait (&ping_cond, &ping_lock, &ts_wait);
340 if (ping_thread_loop <= 0)
342 } /* while (ping_thread_loop > 0) */
344 pthread_mutex_unlock (&ping_lock);
345 ping_destroy (pingobj);
348 } /* }}} void *ping_thread */
350 static int start_thread (void) /* {{{ */
354 pthread_mutex_lock (&ping_lock);
356 if (ping_thread_loop != 0)
358 pthread_mutex_unlock (&ping_lock);
362 ping_thread_loop = 1;
363 ping_thread_error = 0;
364 status = pthread_create (&ping_thread_id, /* attr = */ NULL,
365 ping_thread, /* arg = */ (void *) 0);
368 ping_thread_loop = 0;
369 ERROR ("ping plugin: Starting thread failed.");
370 pthread_mutex_unlock (&ping_lock);
374 pthread_mutex_unlock (&ping_lock);
376 } /* }}} int start_thread */
378 static int stop_thread (void) /* {{{ */
382 pthread_mutex_lock (&ping_lock);
384 if (ping_thread_loop == 0)
386 pthread_mutex_unlock (&ping_lock);
390 ping_thread_loop = 0;
391 pthread_cond_broadcast (&ping_cond);
392 pthread_mutex_unlock (&ping_lock);
394 status = pthread_join (ping_thread_id, /* return = */ NULL);
397 ERROR ("ping plugin: Stopping thread failed.");
401 memset (&ping_thread_id, 0, sizeof (ping_thread_id));
402 ping_thread_error = 0;
405 } /* }}} int stop_thread */
407 static int ping_init (void) /* {{{ */
409 if (hostlist_head == NULL)
411 NOTICE ("ping plugin: No hosts have been configured.");
415 if (ping_timeout > ping_interval)
417 ping_timeout = 0.9 * ping_interval;
418 WARNING ("ping plugin: Timeout is greater than interval. "
419 "Will use a timeout of %gs.", ping_timeout);
422 if (start_thread () != 0)
426 } /* }}} int ping_init */
428 static int config_set_string (const char *name, /* {{{ */
429 char **var, const char *value)
433 tmp = strdup (value);
437 ERROR ("ping plugin: Setting `%s' to `%s' failed: strdup failed: %s",
438 name, value, sstrerror (errno, errbuf, sizeof (errbuf)));
446 } /* }}} int config_set_string */
448 static int ping_config (const char *key, const char *value) /* {{{ */
450 if (strcasecmp (key, "Host") == 0)
455 hl = (hostlist_t *) malloc (sizeof (hostlist_t));
459 ERROR ("ping plugin: malloc failed: %s",
460 sstrerror (errno, errbuf, sizeof (errbuf)));
464 host = strdup (value);
469 ERROR ("ping plugin: strdup failed: %s",
470 sstrerror (errno, errbuf, sizeof (errbuf)));
478 hl->latency_total = 0.0;
479 hl->latency_squared = 0.0;
480 hl->next = hostlist_head;
483 else if (strcasecmp (key, "SourceAddress") == 0)
485 int status = config_set_string (key, &ping_source, value);
489 #ifdef HAVE_OPING_1_3
490 else if (strcasecmp (key, "Device") == 0)
492 int status = config_set_string (key, &ping_device, value);
497 else if (strcasecmp (key, "TTL") == 0)
499 int ttl = atoi (value);
500 if ((ttl > 0) && (ttl <= 255))
503 WARNING ("ping plugin: Ignoring invalid TTL %i.", ttl);
505 else if (strcasecmp (key, "Interval") == 0)
513 WARNING ("ping plugin: Ignoring invalid interval %g (%s)",
516 else if (strcasecmp (key, "Timeout") == 0)
524 WARNING ("ping plugin: Ignoring invalid timeout %g (%s)",
527 else if (strcasecmp (key, "MaxMissed") == 0)
529 ping_max_missed = atoi (value);
530 if (ping_max_missed < 0)
531 INFO ("ping plugin: MaxMissed < 0, disabled re-resolving of hosts");
539 } /* }}} int ping_config */
541 static void submit (const char *host, const char *type, /* {{{ */
545 value_list_t vl = VALUE_LIST_INIT;
547 values[0].gauge = value;
551 sstrncpy (vl.host, hostname_g, sizeof (vl.host));
552 sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
553 sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
554 sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
555 sstrncpy (vl.type, type, sizeof (vl.type));
557 plugin_dispatch_values (&vl);
558 } /* }}} void ping_submit */
560 static int ping_read (void) /* {{{ */
564 if (ping_thread_error != 0)
566 ERROR ("ping plugin: The ping thread had a problem. Restarting it.");
570 for (hl = hostlist_head; hl != NULL; hl = hl->next)
574 hl->latency_total = 0.0;
575 hl->latency_squared = 0.0;
581 } /* if (ping_thread_error != 0) */
583 for (hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
587 double latency_total;
588 double latency_squared;
590 double latency_average;
591 double latency_stddev;
595 /* Locking here works, because the structure of the linked list is only
596 * changed during configure and shutdown. */
597 pthread_mutex_lock (&ping_lock);
599 pkg_sent = hl->pkg_sent;
600 pkg_recv = hl->pkg_recv;
601 latency_total = hl->latency_total;
602 latency_squared = hl->latency_squared;
606 hl->latency_total = 0.0;
607 hl->latency_squared = 0.0;
609 pthread_mutex_unlock (&ping_lock);
611 /* This e. g. happens when starting up. */
614 DEBUG ("ping plugin: No packages for host %s have been sent.",
619 /* Calculate average. Beware of division by zero. */
621 latency_average = NAN;
623 latency_average = latency_total / ((double) pkg_recv);
625 /* Calculate standard deviation. Beware even more of division by zero. */
627 latency_stddev = NAN;
628 else if (pkg_recv == 1)
629 latency_stddev = 0.0;
631 latency_stddev = sqrt (((((double) pkg_recv) * latency_squared)
632 - (latency_total * latency_total))
633 / ((double) (pkg_recv * (pkg_recv - 1))));
635 /* Calculate drop rate. */
636 droprate = ((double) (pkg_sent - pkg_recv)) / ((double) pkg_sent);
638 submit (hl->host, "ping", latency_average);
639 submit (hl->host, "ping_stddev", latency_stddev);
640 submit (hl->host, "ping_droprate", droprate);
641 } /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
644 } /* }}} int ping_read */
646 static int ping_shutdown (void) /* {{{ */
650 INFO ("ping plugin: Shutting down thread.");
651 if (stop_thread () < 0)
668 } /* }}} int ping_shutdown */
670 void module_register (void)
672 plugin_register_config ("ping", ping_config,
673 config_keys, config_keys_num);
674 plugin_register_init ("ping", ping_init);
675 plugin_register_read ("ping", ping_read);
676 plugin_register_shutdown ("ping", ping_shutdown);
677 } /* void module_register */
679 /* vim: set sw=2 sts=2 et fdm=marker : */