X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fclient%2Fstat_client.c;h=5bb6e9f1e5633dec32a35a0fc0c4cca091b54140;hb=3f885f97f0bb812296cb549acd3c4b8fc17de0c9;hp=1c099edc78979a9135fc29f953aaf7cab1bb4caa;hpb=5bdd55831e65ffd7bb0122bf31a6c07ef8f5138a;p=vpp.git

diff --git a/src/vpp-api/client/stat_client.c b/src/vpp-api/client/stat_client.c
index 1c099edc789..5bb6e9f1e56 100644
--- a/src/vpp-api/client/stat_client.c
+++ b/src/vpp-api/client/stat_client.c
@@ -28,18 +28,27 @@
 #include <assert.h>
 #include <vppinfra/vec.h>
 #include <vppinfra/lock.h>
-#include "stat_client.h"
 #include <stdatomic.h>
+#include <vlib/vlib.h>
+#include <vlib/stats/stats.h>
+#include <vpp-api/client/stat_client.h>
 
-typedef struct
+stat_client_main_t stat_client_main;
+
+stat_client_main_t *
+stat_client_get (void)
 {
-  uint64_t current_epoch;
-  stat_segment_shared_header_t *shared_header;
-  stat_segment_directory_entry_t *directory_vector;
-  ssize_t memory_size;
-} stat_client_main_t;
+  stat_client_main_t *sm;
+  sm = (stat_client_main_t *) malloc (sizeof (stat_client_main_t));
+  clib_memset (sm, 0, sizeof (stat_client_main_t));
+  return sm;
+}
 
-stat_client_main_t stat_client_main;
+void
+stat_client_free (stat_client_main_t * sm)
+{
+  free (sm);
+}
 
 static int
 recv_fd (int sock)
@@ -73,26 +82,24 @@ recv_fd (int sock)
   return fd;
 }
 
-static stat_segment_directory_entry_t *
-get_stat_vector (void)
+static vlib_stats_entry_t *
+get_stat_vector_r (stat_client_main_t *sm)
 {
-  stat_client_main_t *sm = &stat_client_main;
   ASSERT (sm->shared_header);
-  return stat_segment_pointer (sm->shared_header,
-			       sm->shared_header->directory_offset);
+  return stat_segment_adjust (sm,
+			      (void *) sm->shared_header->directory_vector);
 }
 
 int
-stat_segment_connect (char *socket_name)
+stat_segment_connect_r (const char *socket_name, stat_client_main_t * sm)
 {
-  stat_client_main_t *sm = &stat_client_main;
   int mfd = -1;
   int sock;
 
-  memset (sm, 0, sizeof (*sm));
+  clib_memset (sm, 0, sizeof (*sm));
   if ((sock = socket (AF_UNIX, SOCK_SEQPACKET, 0)) < 0)
     {
-      perror ("Couldn't open socket");
+      perror ("Stat client couldn't open socket");
       return -1;
     }
 
@@ -103,15 +110,14 @@ stat_segment_connect (char *socket_name)
       0)
     {
       close (sock);
-      perror ("connect");
-      return -1;
+      return -2;
     }
 
   if ((mfd = recv_fd (sock)) < 0)
     {
       close (sock);
       fprintf (stderr, "Receiving file descriptor failed\n");
-      return -1;
+      return -3;
     }
   close (sock);
 
@@ -121,57 +127,116 @@ stat_segment_connect (char *socket_name)
 
   if (fstat (mfd, &st) == -1)
     {
-      perror ("mmap");
-      return -1;
+      close (mfd);
+      perror ("mmap fstat failed");
+      return -4;
     }
   if ((memaddr =
        mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, mfd, 0)) == MAP_FAILED)
     {
-      perror ("mmap");
-      return -1;
+      close (mfd);
+      perror ("mmap map failed");
+      return -5;
     }
 
+  close (mfd);
   sm->memory_size = st.st_size;
   sm->shared_header = memaddr;
   sm->directory_vector =
-    stat_segment_pointer (memaddr, sm->shared_header->directory_offset);
+    stat_segment_adjust (sm, (void *) sm->shared_header->directory_vector);
 
   return 0;
 }
 
+int
+stat_segment_connect (const char *socket_name)
+{
+  stat_client_main_t *sm = &stat_client_main;
+  return stat_segment_connect_r (socket_name, sm);
+}
+
+void
+stat_segment_disconnect_r (stat_client_main_t * sm)
+{
+  munmap (sm->shared_header, sm->memory_size);
+  return;
+}
+
 void
 stat_segment_disconnect (void)
 {
   stat_client_main_t *sm = &stat_client_main;
-  munmap (sm->shared_header, sm->memory_size);
+  return stat_segment_disconnect_r (sm);
+}
 
-  return;
+double
+stat_segment_heartbeat_r (stat_client_main_t * sm)
+{
+  stat_segment_access_t sa;
+  vlib_stats_entry_t *ep;
+
+  /* Has directory been updated? */
+  if (sm->shared_header->epoch != sm->current_epoch)
+    return 0;
+  if (stat_segment_access_start (&sa, sm))
+    return 0;
+  ep = vec_elt_at_index (sm->directory_vector, STAT_COUNTER_HEARTBEAT);
+  if (!stat_segment_access_end (&sa, sm))
+    return 0.0;
+  return ep->value;
 }
 
 double
 stat_segment_heartbeat (void)
 {
   stat_client_main_t *sm = &stat_client_main;
-  stat_segment_directory_entry_t *vec = get_stat_vector ();
-  double *hb = stat_segment_pointer (sm->shared_header, vec[4].offset);
-  return *hb;
+  return stat_segment_heartbeat_r (sm);
 }
 
-stat_segment_data_t
-copy_data (stat_segment_directory_entry_t * ep)
+#define stat_vec_dup(S,V)                             \
+  ({                                                  \
+  __typeof__ ((V)[0]) * _v(v) = 0;                    \
+  if (V && ((void *)V > (void *)S->shared_header) &&  \
+      (((void*)V + vec_bytes(V)) <                    \
+       ((void *)S->shared_header + S->memory_size)))  \
+    _v(v) = vec_dup(V);                               \
+   _v(v);                                             \
+})
+
+static counter_t *
+stat_vec_simple_init (counter_t c)
+{
+  counter_t *v = 0;
+  vec_add1 (v, c);
+  return v;
+}
+
+static vlib_counter_t *
+stat_vec_combined_init (vlib_counter_t c)
+{
+  vlib_counter_t *v = 0;
+  vec_add1 (v, c);
+  return v;
+}
+
+/*
+ * If index2 is specified copy out the column (the indexed value across all
+ * threads), otherwise copy out all values.
+ */
+static stat_segment_data_t
+copy_data (vlib_stats_entry_t *ep, u32 index2, char *name,
+	   stat_client_main_t *sm)
 {
-  stat_client_main_t *sm = &stat_client_main;
   stat_segment_data_t result = { 0 };
   int i;
   vlib_counter_t **combined_c;	/* Combined counter */
   counter_t **simple_c;		/* Simple counter */
-  counter_t *error_base;
-  uint64_t *offset_vector;
 
   assert (sm->shared_header);
 
   result.type = ep->type;
-  result.name = strdup (ep->name);
+  result.name = strdup (name ? name : ep->name);
+
   switch (ep->type)
     {
     case STAT_DIR_TYPE_SCALAR_INDEX:
@@ -179,44 +244,59 @@ copy_data (stat_segment_directory_entry_t * ep)
       break;
 
     case STAT_DIR_TYPE_COUNTER_VECTOR_SIMPLE:
-      if (ep->offset == 0)
-	return result;
-      simple_c = stat_segment_pointer (sm->shared_header, ep->offset);
-      result.simple_counter_vec = vec_dup (simple_c);
-      offset_vector =
-	stat_segment_pointer (sm->shared_header, ep->offset_vector);
+      simple_c = stat_segment_adjust (sm, ep->data);
+      result.simple_counter_vec = stat_vec_dup (sm, simple_c);
       for (i = 0; i < vec_len (simple_c); i++)
 	{
-	  counter_t *cb =
-	    stat_segment_pointer (sm->shared_header, offset_vector[i]);
-	  result.simple_counter_vec[i] = vec_dup (cb);
+	  counter_t *cb = stat_segment_adjust (sm, simple_c[i]);
+	  if (index2 != ~0)
+	    result.simple_counter_vec[i] = stat_vec_simple_init (cb[index2]);
+	  else
+	    result.simple_counter_vec[i] = stat_vec_dup (sm, cb);
 	}
       break;
 
     case STAT_DIR_TYPE_COUNTER_VECTOR_COMBINED:
-      if (ep->offset == 0)
-	return result;
-      combined_c = stat_segment_pointer (sm->shared_header, ep->offset);
-      result.combined_counter_vec = vec_dup (combined_c);
-      offset_vector =
-	stat_segment_pointer (sm->shared_header, ep->offset_vector);
+      combined_c = stat_segment_adjust (sm, ep->data);
+      result.combined_counter_vec = stat_vec_dup (sm, combined_c);
       for (i = 0; i < vec_len (combined_c); i++)
 	{
-	  vlib_counter_t *cb =
-	    stat_segment_pointer (sm->shared_header, offset_vector[i]);
-	  result.combined_counter_vec[i] = vec_dup (cb);
+	  vlib_counter_t *cb = stat_segment_adjust (sm, combined_c[i]);
+	  if (index2 != ~0)
+	    result.combined_counter_vec[i] =
+	      stat_vec_combined_init (cb[index2]);
+	  else
+	    result.combined_counter_vec[i] = stat_vec_dup (sm, cb);
 	}
       break;
 
-    case STAT_DIR_TYPE_ERROR_INDEX:
-      error_base =
-	stat_segment_pointer (sm->shared_header,
-			      sm->shared_header->error_offset);
-      result.error_value = error_base[ep->index];
+    case STAT_DIR_TYPE_NAME_VECTOR:
+      {
+	uint8_t **name_vector = stat_segment_adjust (sm, ep->data);
+	result.name_vector = stat_vec_dup (sm, name_vector);
+	for (i = 0; i < vec_len (name_vector); i++)
+	  {
+	    u8 *name = stat_segment_adjust (sm, name_vector[i]);
+	    result.name_vector[i] = stat_vec_dup (sm, name);
+	  }
+      }
+      break;
+
+    case STAT_DIR_TYPE_SYMLINK:
+      /* Gather info from all threads into a vector */
+      {
+	vlib_stats_entry_t *ep2;
+	ep2 = vec_elt_at_index (sm->directory_vector, ep->index1);
+	/* We do not intend to return the "result", avoid a leak */
+	free (result.name);
+	return copy_data (ep2, ep->index2, ep->name, sm);
+      }
+
+    case STAT_DIR_TYPE_EMPTY:
       break;
 
     default:
-      fprintf (stderr, "Unknown type: %d", ep->type);
+      fprintf (stderr, "Unknown type: %d\n", ep->type);
     }
   return result;
 }
@@ -239,45 +319,25 @@ stat_segment_data_free (stat_segment_data_t * res)
 	    vec_free (res[i].combined_counter_vec[j]);
 	  vec_free (res[i].combined_counter_vec);
 	  break;
+	case STAT_DIR_TYPE_NAME_VECTOR:
+	  for (j = 0; j < vec_len (res[i].name_vector); j++)
+	    vec_free (res[i].name_vector[j]);
+	  vec_free (res[i].name_vector);
+	  break;
+	case STAT_DIR_TYPE_SCALAR_INDEX:
+	case STAT_DIR_TYPE_EMPTY:
+	  break;
 	default:
-	  ;
+	  assert (0);
 	}
       free (res[i].name);
     }
   vec_free (res);
 }
 
-
-typedef struct
-{
-  uint64_t epoch;
-} stat_segment_access_t;
-
-static void
-stat_segment_access_start (stat_segment_access_t * sa)
-{
-  stat_client_main_t *sm = &stat_client_main;
-  stat_segment_shared_header_t *shared_header = sm->shared_header;
-  sa->epoch = shared_header->epoch;
-  while (shared_header->in_progress != 0)
-    ;
-}
-
-static bool
-stat_segment_access_end (stat_segment_access_t * sa)
-{
-  stat_client_main_t *sm = &stat_client_main;
-  stat_segment_shared_header_t *shared_header = sm->shared_header;
-
-  if (shared_header->epoch != sa->epoch || shared_header->in_progress)
-    return false;
-  return true;
-}
-
 uint32_t *
-stat_segment_ls (uint8_t ** patterns)
+stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm)
 {
-  stat_client_main_t *sm = &stat_client_main;
   stat_segment_access_t sa;
 
   uint32_t *dir = 0;
@@ -286,7 +346,7 @@ stat_segment_ls (uint8_t ** patterns)
   int i, j;
   for (i = 0; i < vec_len (patterns); i++)
     {
-      int rv = regcomp (&regex[i], (char *) patterns[i], 0);
+      int rv = regcomp (&regex[i], (const char *) patterns[i], 0);
       if (rv)
 	{
 	  fprintf (stderr, "Could not compile regex %s\n", patterns[i]);
@@ -294,9 +354,10 @@ stat_segment_ls (uint8_t ** patterns)
 	}
     }
 
-  stat_segment_access_start (&sa);
+  if (stat_segment_access_start (&sa, sm))
+    return 0;
 
-  stat_segment_directory_entry_t *counter_vec = get_stat_vector ();
+  vlib_stats_entry_t *counter_vec = get_stat_vector_r (sm);
   for (j = 0; j < vec_len (counter_vec); j++)
     {
       for (i = 0; i < vec_len (patterns); i++)
@@ -315,7 +376,7 @@ stat_segment_ls (uint8_t ** patterns)
   for (i = 0; i < vec_len (patterns); i++)
     regfree (&regex[i]);
 
-  if (!stat_segment_access_end (&sa))
+  if (!stat_segment_access_end (&sa, sm))
     {
       /* Failed, clean up */
       vec_free (dir);
@@ -328,12 +389,18 @@ stat_segment_ls (uint8_t ** patterns)
   return dir;
 }
 
+uint32_t *
+stat_segment_ls (uint8_t ** patterns)
+{
+  stat_client_main_t *sm = &stat_client_main;
+  return stat_segment_ls_r ((uint8_t **) patterns, sm);
+}
+
 stat_segment_data_t *
-stat_segment_dump (uint32_t * stats)
+stat_segment_dump_r (uint32_t * stats, stat_client_main_t * sm)
 {
   int i;
-  stat_client_main_t *sm = &stat_client_main;
-  stat_segment_directory_entry_t *ep;
+  vlib_stats_entry_t *ep;
   stat_segment_data_t *res = 0;
   stat_segment_access_t sa;
 
@@ -341,15 +408,17 @@ stat_segment_dump (uint32_t * stats)
   if (sm->shared_header->epoch != sm->current_epoch)
     return 0;
 
-  stat_segment_access_start (&sa);
+  if (stat_segment_access_start (&sa, sm))
+    return 0;
+
   for (i = 0; i < vec_len (stats); i++)
     {
       /* Collect counter */
       ep = vec_elt_at_index (sm->directory_vector, stats[i]);
-      vec_add1 (res, copy_data (ep));
+      vec_add1 (res, copy_data (ep, ~0, 0, sm));
     }
 
-  if (stat_segment_access_end (&sa))
+  if (stat_segment_access_end (&sa, sm))
     return res;
 
   fprintf (stderr, "Epoch changed while reading, invalid results\n");
@@ -357,6 +426,13 @@ stat_segment_dump (uint32_t * stats)
   return 0;
 }
 
+stat_segment_data_t *
+stat_segment_dump (uint32_t * stats)
+{
+  stat_client_main_t *sm = &stat_client_main;
+  return stat_segment_dump_r (stats, sm);
+}
+
 /* Wrapper for accessing vectors from other languages */
 int
 stat_segment_vec_len (void *vec)
@@ -364,44 +440,92 @@ stat_segment_vec_len (void *vec)
   return vec_len (vec);
 }
 
+void
+stat_segment_vec_free (void *vec)
+{
+  vec_free (vec);
+}
+
 /* Create a vector from a string (or add to existing) */
-u8 **
-stat_segment_string_vector (u8 ** string_vector, char *string)
+uint8_t **
+stat_segment_string_vector (uint8_t ** string_vector, const char *string)
 {
-  u8 *name = 0;
-  name = vec_dup ((u8 *) string);
-  vec_add1 (string_vector, (u8 *) name);
+  uint8_t *name = 0;
+  size_t len = strlen (string);
+
+  vec_validate_init_c_string (name, string, len);
+  vec_add1 (string_vector, name);
   return string_vector;
 }
 
 stat_segment_data_t *
-stat_segment_dump_entry (uint32_t index)
+stat_segment_dump_entry_r (uint32_t index, stat_client_main_t * sm)
 {
-  stat_client_main_t *sm = &stat_client_main;
-  stat_segment_directory_entry_t *ep;
+  vlib_stats_entry_t *ep;
   stat_segment_data_t *res = 0;
   stat_segment_access_t sa;
 
-  stat_segment_access_start (&sa);
+  /* Has directory been update? */
+  if (sm->shared_header->epoch != sm->current_epoch)
+    return 0;
+
+  if (stat_segment_access_start (&sa, sm))
+    return 0;
 
   /* Collect counter */
   ep = vec_elt_at_index (sm->directory_vector, index);
-  vec_add1 (res, copy_data (ep));
+  vec_add1 (res, copy_data (ep, ~0, 0, sm));
 
-  if (stat_segment_access_end (&sa))
+  if (stat_segment_access_end (&sa, sm))
     return res;
   return 0;
 }
 
+stat_segment_data_t *
+stat_segment_dump_entry (uint32_t index)
+{
+  stat_client_main_t *sm = &stat_client_main;
+  return stat_segment_dump_entry_r (index, sm);
+}
+
+char *
+stat_segment_index_to_name_r (uint32_t index, stat_client_main_t * sm)
+{
+  vlib_stats_entry_t *ep;
+  stat_segment_access_t sa;
+  vlib_stats_entry_t *vec;
+
+  /* Has directory been update? */
+  if (sm->shared_header->epoch != sm->current_epoch)
+    return 0;
+  if (stat_segment_access_start (&sa, sm))
+    return 0;
+  vec = get_stat_vector_r (sm);
+  ep = vec_elt_at_index (vec, index);
+  if (!stat_segment_access_end (&sa, sm))
+    return 0;
+  return strdup (ep->name);
+}
+
 char *
 stat_segment_index_to_name (uint32_t index)
 {
-  char *name;
-  stat_segment_directory_entry_t *counter_vec = get_stat_vector ();
-  stat_segment_directory_entry_t *ep;
-  ep = vec_elt_at_index (counter_vec, index);
-  name = strdup (ep->name);
-  return name;
+  stat_client_main_t *sm = &stat_client_main;
+  return stat_segment_index_to_name_r (index, sm);
+}
+
+uint64_t
+stat_segment_version_r (stat_client_main_t * sm)
+{
+  ASSERT (sm->shared_header);
+  return sm->shared_header->version;
+}
+
+uint64_t
+stat_segment_version (void)
+{
+  stat_client_main_t *sm = &stat_client_main;
+  return stat_segment_version_r (sm);
 }
 
 /*