X-Git-Url: https://git.octo.it/?p=collectd.git;a=blobdiff_plain;f=src%2Fgps.c;h=b22c3a2e5ecd505620709654b2bdaf1808b38262;hp=d5b7176b44560073260bef643ea88d811ecb80f3;hb=7111bb6df7628edce3a8e538b386fbe27633a191;hpb=e1bfa71aca1f37c2f293dc9adb44065c6e7a9ad9

diff --git a/src/gps.c b/src/gps.c
index d5b7176b..b22c3a2e 100644
--- a/src/gps.c
+++ b/src/gps.c
@@ -31,14 +31,14 @@
 #include "plugin.h"
 #include "utils_time.h"
 
-#define CGPS_TRUE                  1
-#define CGPS_FALSE                 0
-#define CGPS_DEFAULT_HOST          "localhost"
-#define CGPS_DEFAULT_PORT          "2947" /* DEFAULT_GPSD_PORT */
-#define CGPS_DEFAULT_TIMEOUT       MS_TO_CDTIME_T (15)
-#define CGPS_DEFAULT_PAUSE_CONNECT TIME_T_TO_CDTIME_T (5)
-#define CGPS_MAX_ERROR             100
-#define CGPS_CONFIG                "?WATCH={\"enable\":true,\"json\":true,\"nmea\":false}\r\n"
+#define CGPS_TRUE 1
+#define CGPS_FALSE 0
+#define CGPS_DEFAULT_HOST "localhost"
+#define CGPS_DEFAULT_PORT "2947" /* DEFAULT_GPSD_PORT */
+#define CGPS_DEFAULT_TIMEOUT MS_TO_CDTIME_T(15)
+#define CGPS_DEFAULT_PAUSE_CONNECT TIME_T_TO_CDTIME_T(5)
+#define CGPS_MAX_ERROR 100
+#define CGPS_CONFIG "?WATCH={\"enable\":true,\"json\":true,\"nmea\":false}\r\n"
 
 #include <gps.h>
 #include <pthread.h>
@@ -62,118 +62,103 @@ static cgps_config_t cgps_config_data;
 static cgps_data_t cgps_data = {NAN, NAN, NAN, NAN};
 
 static pthread_t cgps_thread_id;
-static pthread_mutex_t  cgps_data_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t  cgps_thread_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t cgps_data_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t cgps_thread_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cgps_thread_cond = PTHREAD_COND_INITIALIZER;
 static int cgps_thread_shutdown = CGPS_FALSE;
 static int cgps_thread_running = CGPS_FALSE;
 
 /**
  * Non blocking pause for the thread.
  */
-static int cgps_thread_pause(cdtime_t pTime)
-{
-  cdtime_t now;
-  now = cdtime ();
-  struct timespec pause_th;
-  CDTIME_T_TO_TIMESPEC (MS_TO_CDTIME_T(10), &pause_th);
-  while (CGPS_TRUE)
-  {
-    if ( (cdtime () - now) > pTime )
-    {
-      break;
-    }
+static int cgps_thread_pause(cdtime_t pTime) {
+  cdtime_t until = cdtime() + pTime;
 
-    pthread_mutex_lock (&cgps_thread_lock);
-    if (cgps_thread_shutdown == CGPS_TRUE)
-    {
-      return CGPS_FALSE;
-    }
-    pthread_mutex_unlock (&cgps_thread_lock);
-    nanosleep (&pause_th, NULL);
- }
+  pthread_mutex_lock(&cgps_thread_lock);
+  pthread_cond_timedwait(&cgps_thread_cond, &cgps_thread_lock,
+                         &CDTIME_T_TO_TIMESPEC(until));
 
- return CGPS_TRUE;
+  int ret = !cgps_thread_shutdown;
+
+  pthread_mutex_unlock(&cgps_thread_lock);
+  return ret;
 }
 
 /**
  * Thread reading from gpsd.
  */
-static void * cgps_thread (void * pData)
-{
+static void *cgps_thread(void *pData) {
   struct gps_data_t gpsd_conn;
   unsigned int err_count;
   cgps_thread_running = CGPS_TRUE;
 
-  while (CGPS_TRUE)
-  {
-    pthread_mutex_lock (&cgps_thread_lock);
-    if (cgps_thread_shutdown == CGPS_TRUE)
-    {
+  while (CGPS_TRUE) {
+    pthread_mutex_lock(&cgps_thread_lock);
+    if (cgps_thread_shutdown == CGPS_TRUE) {
       goto quit;
     }
-    pthread_mutex_unlock (&cgps_thread_lock);
+    pthread_mutex_unlock(&cgps_thread_lock);
 
     err_count = 0;
 
 #if GPSD_API_MAJOR_VERSION > 4
-    int status = gps_open (cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
+    int status =
+        gps_open(cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
 #else
-    int status = gps_open_r (cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
+    int status =
+        gps_open_r(cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
 #endif
-    if (status < 0)
-    {
-      WARNING ("gps plugin: connecting to %s:%s failed: %s",
-               cgps_config_data.host, cgps_config_data.port, gps_errstr (status));
+    if (status < 0) {
+      WARNING("gps plugin: connecting to %s:%s failed: %s",
+              cgps_config_data.host, cgps_config_data.port, gps_errstr(status));
 
       // Here we make a pause until a new tentative to connect, we check also if
       // the thread does not need to stop.
-      if (cgps_thread_pause(cgps_config_data.pause_connect) == CGPS_FALSE)
-      {
+      if (cgps_thread_pause(cgps_config_data.pause_connect) == CGPS_FALSE) {
         goto quit;
       }
 
       continue;
     }
 
-    gps_stream (&gpsd_conn, WATCH_ENABLE | WATCH_JSON | WATCH_NEWSTYLE, NULL);
-    gps_send (&gpsd_conn, CGPS_CONFIG);
+    gps_stream(&gpsd_conn, WATCH_ENABLE | WATCH_JSON | WATCH_NEWSTYLE, NULL);
+    gps_send(&gpsd_conn, CGPS_CONFIG);
 
-    while (CGPS_TRUE)
-    {
-      pthread_mutex_lock (&cgps_thread_lock);
-      if (cgps_thread_shutdown == CGPS_TRUE)
-      {
+    while (CGPS_TRUE) {
+      pthread_mutex_lock(&cgps_thread_lock);
+      if (cgps_thread_shutdown == CGPS_TRUE) {
         goto stop;
       }
-      pthread_mutex_unlock (&cgps_thread_lock);
+      pthread_mutex_unlock(&cgps_thread_lock);
 
 #if GPSD_API_MAJOR_VERSION > 4
-      long timeout_us = CDTIME_T_TO_US (cgps_config_data.timeout);
-      if (!gps_waiting (&gpsd_conn, (int) timeout_us ))
+      long timeout_us = CDTIME_T_TO_US(cgps_config_data.timeout);
+      if (!gps_waiting(&gpsd_conn, (int)timeout_us))
 #else
-      if (!gps_waiting (&gpsd_conn))
+      if (!gps_waiting(&gpsd_conn))
 #endif
       {
         continue;
       }
 
-      if (gps_read (&gpsd_conn) == -1)
+#if GPSD_API_MAJOR_VERSION > 6
+      if (gps_read(&gpsd_conn, NULL, 0) == -1)
+#else
+      if (gps_read(&gpsd_conn) == -1)
+#endif
       {
-        WARNING ("gps plugin: incorrect data! (err_count: %d)", err_count);
+        WARNING("gps plugin: incorrect data! (err_count: %d)", err_count);
         err_count++;
 
-        if (err_count > CGPS_MAX_ERROR)
-        {
+        if (err_count > CGPS_MAX_ERROR) {
           // Server is not responding ...
-          if (gps_send (&gpsd_conn, CGPS_CONFIG) == -1)
-          {
-            WARNING ("gps plugin: gpsd seems to be down, reconnecting");
-            gps_close (&gpsd_conn);
+          if (gps_send(&gpsd_conn, CGPS_CONFIG) == -1) {
+            WARNING("gps plugin: gpsd seems to be down, reconnecting");
+            gps_close(&gpsd_conn);
             break;
           }
           // Server is responding ...
-          else
-          {
+          else {
             err_count = 0;
           }
         }
@@ -181,184 +166,173 @@ static void * cgps_thread (void * pData)
         continue;
       }
 
-      pthread_mutex_lock (&cgps_data_lock);
+      pthread_mutex_lock(&cgps_data_lock);
 
       // Number of sats in view:
-      cgps_data.sats_used = (gauge_t) gpsd_conn.satellites_used;
-      cgps_data.sats_visible = (gauge_t) gpsd_conn.satellites_visible;
+      cgps_data.sats_used = (gauge_t)gpsd_conn.satellites_used;
+      cgps_data.sats_visible = (gauge_t)gpsd_conn.satellites_visible;
 
       // dilution of precision:
       cgps_data.vdop = NAN;
       cgps_data.hdop = NAN;
-      if (cgps_data.sats_used > 0)
-      {
+      if (cgps_data.sats_used > 0) {
         cgps_data.hdop = gpsd_conn.dop.hdop;
         cgps_data.vdop = gpsd_conn.dop.vdop;
       }
 
-      DEBUG ("gps plugin: %.0f sats used (of %.0f visible), hdop = %.3f, vdop = %.3f",
-             cgps_data.sats_used, cgps_data.sats_visible, cgps_data.hdop, cgps_data.vdop);
+      DEBUG("gps plugin: %.0f sats used (of %.0f visible), hdop = %.3f, vdop = "
+            "%.3f",
+            cgps_data.sats_used, cgps_data.sats_visible, cgps_data.hdop,
+            cgps_data.vdop);
 
-      pthread_mutex_unlock (&cgps_data_lock);
+      pthread_mutex_unlock(&cgps_data_lock);
     }
   }
 
 stop:
-  DEBUG ("gps plugin: thread closing gpsd connection ... ");
-  gps_stream (&gpsd_conn, WATCH_DISABLE, NULL);
-  gps_close (&gpsd_conn);
+  DEBUG("gps plugin: thread closing gpsd connection ... ");
+  gps_stream(&gpsd_conn, WATCH_DISABLE, NULL);
+  gps_close(&gpsd_conn);
 quit:
-  DEBUG ("gps plugin: thread shutting down ... ");
+  DEBUG("gps plugin: thread shutting down ... ");
   cgps_thread_running = CGPS_FALSE;
-  pthread_mutex_unlock (&cgps_thread_lock);
-  pthread_exit (NULL);
+  pthread_mutex_unlock(&cgps_thread_lock);
+  pthread_exit(NULL);
 }
 
-
 /**
  * Submit a piece of the data.
  */
-static void cgps_submit (const char *type, gauge_t value, const char *type_instance)
-{
+static void cgps_submit(const char *type, gauge_t value,
+                        const char *type_instance) {
   value_list_t vl = VALUE_LIST_INIT;
 
-  vl.values = &(value_t) { .gauge = value };
+  vl.values = &(value_t){.gauge = value};
   vl.values_len = 1;
-  sstrncpy (vl.host, hostname_g, sizeof (vl.host));
-  sstrncpy (vl.plugin, "gps", sizeof (vl.plugin));
-  sstrncpy (vl.type, type, sizeof (vl.type));
-  sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
+  sstrncpy(vl.plugin, "gps", sizeof(vl.plugin));
+  sstrncpy(vl.type, type, sizeof(vl.type));
+  sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 
-  plugin_dispatch_values (&vl);
+  plugin_dispatch_values(&vl);
 }
 
 /**
  * Read the data and submit by piece.
  */
-static int cgps_read (void)
-{
+static int cgps_read(void) {
   cgps_data_t data_copy;
 
-  pthread_mutex_lock (&cgps_data_lock);
+  pthread_mutex_lock(&cgps_data_lock);
   data_copy = cgps_data;
-  pthread_mutex_unlock (&cgps_data_lock);
+  pthread_mutex_unlock(&cgps_data_lock);
 
-  cgps_submit ("dilution_of_precision", data_copy.hdop, "horizontal");
-  cgps_submit ("dilution_of_precision", data_copy.vdop, "vertical");
-  cgps_submit ("satellites", data_copy.sats_used, "used");
-  cgps_submit ("satellites", data_copy.sats_visible, "visible");
+  cgps_submit("dilution_of_precision", data_copy.hdop, "horizontal");
+  cgps_submit("dilution_of_precision", data_copy.vdop, "vertical");
+  cgps_submit("satellites", data_copy.sats_used, "used");
+  cgps_submit("satellites", data_copy.sats_visible, "visible");
 
-  return (0);
+  return 0;
 }
 
 /**
  * Read configuration.
  */
-static int cgps_config (oconfig_item_t *ci)
-{
+static int cgps_config(oconfig_item_t *ci) {
   int i;
 
-  for (i = 0; i < ci->children_num; i++)
-  {
+  for (i = 0; i < ci->children_num; i++) {
     oconfig_item_t *child = ci->children + i;
 
-    if (strcasecmp ("Host", child->key) == 0)
-      cf_util_get_string (child, &cgps_config_data.host);
-    else if (strcasecmp ("Port", child->key) == 0)
-      cf_util_get_service (child, &cgps_config_data.port);
-    else if (strcasecmp ("Timeout", child->key) == 0)
-      cf_util_get_cdtime (child, &cgps_config_data.timeout);
-    else if (strcasecmp ("PauseConnect", child->key) == 0)
-      cf_util_get_cdtime (child, &cgps_config_data.pause_connect);
+    if (strcasecmp("Host", child->key) == 0)
+      cf_util_get_string(child, &cgps_config_data.host);
+    else if (strcasecmp("Port", child->key) == 0)
+      cf_util_get_service(child, &cgps_config_data.port);
+    else if (strcasecmp("Timeout", child->key) == 0)
+      cf_util_get_cdtime(child, &cgps_config_data.timeout);
+    else if (strcasecmp("PauseConnect", child->key) == 0)
+      cf_util_get_cdtime(child, &cgps_config_data.pause_connect);
     else
-      WARNING ("gps plugin: Ignoring unknown config option \"%s\".", child->key);
+      WARNING("gps plugin: Ignoring unknown config option \"%s\".", child->key);
   }
 
   // Controlling the value for timeout:
-  // If set too high it blocks the reading (> 5 s), too low it gets not reading (< 500 us).
+  // If set too high it blocks the reading (> 5 s), too low it gets not reading
+  // (< 500 us).
   // To avoid any issues we replace "out of range" value by the default value.
-  if (
-    cgps_config_data.timeout > TIME_T_TO_CDTIME_T(5)
-    ||
-    cgps_config_data.timeout < US_TO_CDTIME_T(500)
-  )
-  {
-    WARNING ("gps plugin: timeout set to %.6f sec. setting to default (%.6f).",
-      CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
-      CDTIME_T_TO_DOUBLE(CGPS_DEFAULT_TIMEOUT)
-    );
+  if (cgps_config_data.timeout > TIME_T_TO_CDTIME_T(5) ||
+      cgps_config_data.timeout < US_TO_CDTIME_T(500)) {
+    WARNING("gps plugin: timeout set to %.6f sec. setting to default (%.6f).",
+            CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
+            CDTIME_T_TO_DOUBLE(CGPS_DEFAULT_TIMEOUT));
     cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
   }
 
-  return (0);
+  return 0;
 }
 
 /**
  * Init.
  */
-static int cgps_init (void)
-{
+static int cgps_init(void) {
   int status;
 
-  if (cgps_thread_running == CGPS_TRUE)
-  {
-    DEBUG ("gps plugin: error gps thread already running ... ");
+  if (cgps_thread_running == CGPS_TRUE) {
+    DEBUG("gps plugin: error gps thread already running ... ");
     return 0;
   }
 
-  DEBUG ("gps plugin: config{host: \"%s\", port: \"%s\", timeout: %.6f sec., pause connect: %.3f sec.}",
-         cgps_config_data.host, cgps_config_data.port,
-         CDTIME_T_TO_DOUBLE (cgps_config_data.timeout),
-         CDTIME_T_TO_DOUBLE (cgps_config_data.pause_connect));
-
-  status = plugin_thread_create (&cgps_thread_id, NULL, cgps_thread, NULL);
-  if (status != 0)
-  {
-    ERROR ("gps plugin: pthread_create() failed.");
-    return (-1);
+  DEBUG("gps plugin: config{host: \"%s\", port: \"%s\", timeout: %.6f sec., "
+        "pause connect: %.3f sec.}",
+        cgps_config_data.host, cgps_config_data.port,
+        CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
+        CDTIME_T_TO_DOUBLE(cgps_config_data.pause_connect));
+
+  status =
+      plugin_thread_create(&cgps_thread_id, NULL, cgps_thread, NULL, "gps");
+  if (status != 0) {
+    ERROR("gps plugin: pthread_create() failed.");
+    return -1;
   }
 
-  return (0);
+  return 0;
 }
 
 /**
  * Shutdown.
  */
-static int cgps_shutdown (void)
-{
-  void * res;
+static int cgps_shutdown(void) {
+  void *res;
 
-  pthread_mutex_lock (&cgps_thread_lock);
+  pthread_mutex_lock(&cgps_thread_lock);
   cgps_thread_shutdown = CGPS_TRUE;
-  pthread_mutex_unlock (&cgps_thread_lock);
+  pthread_cond_broadcast(&cgps_thread_cond);
+  pthread_mutex_unlock(&cgps_thread_lock);
 
   pthread_join(cgps_thread_id, &res);
   free(res);
 
   // Clean mutex:
-  pthread_mutex_unlock(&cgps_thread_lock);
   pthread_mutex_destroy(&cgps_thread_lock);
   pthread_mutex_unlock(&cgps_data_lock);
   pthread_mutex_destroy(&cgps_data_lock);
 
-  sfree (cgps_config_data.port);
-  sfree (cgps_config_data.host);
+  sfree(cgps_config_data.port);
+  sfree(cgps_config_data.host);
 
-  return (0);
+  return 0;
 }
 
 /**
  * Register the module.
  */
-void module_register (void)
-{
-  cgps_config_data.host = sstrdup (CGPS_DEFAULT_HOST);
-  cgps_config_data.port = sstrdup (CGPS_DEFAULT_PORT);
+void module_register(void) {
+  cgps_config_data.host = sstrdup(CGPS_DEFAULT_HOST);
+  cgps_config_data.port = sstrdup(CGPS_DEFAULT_PORT);
   cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
   cgps_config_data.pause_connect = CGPS_DEFAULT_PAUSE_CONNECT;
 
-  plugin_register_complex_config ("gps", cgps_config);
-  plugin_register_init ("gps", cgps_init);
-  plugin_register_read ("gps", cgps_read);
-  plugin_register_shutdown ("gps", cgps_shutdown);
+  plugin_register_complex_config("gps", cgps_config);
+  plugin_register_init("gps", cgps_init);
+  plugin_register_read("gps", cgps_read);
+  plugin_register_shutdown("gps", cgps_shutdown);
 }