#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)
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;
}
if (connect (sock, (struct sockaddr *) &un, sizeof (struct sockaddr_un)) <
0)
{
- perror ("connect");
- return -1;
+ close (sock);
+ return -2;
}
if ((mfd = recv_fd (sock)) < 0)
{
+ close (sock);
fprintf (stderr, "Receiving file descriptor failed\n");
- return -1;
+ return -3;
}
close (sock);
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:
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;
}
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;
int i, j;
for (i = 0; i < vec_len (patterns); i++)
{
- int rv = regcomp (®ex[i], (char *) patterns[i], 0);
+ int rv = regcomp (®ex[i], (const char *) patterns[i], 0);
if (rv)
{
fprintf (stderr, "Could not compile regex %s\n", patterns[i]);
}
}
- 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++)
for (i = 0; i < vec_len (patterns); i++)
regfree (®ex[i]);
- if (!stat_segment_access_end (&sa))
+ if (!stat_segment_access_end (&sa, sm))
{
/* Failed, clean up */
vec_free (dir);
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;
if (sm->shared_header->epoch != sm->current_epoch)
return 0;
- stat_segment_access_start (&sa);
+ if (stat_segment_access_start (&sa, sm))
+ return 0;
+
+ /* preallocate the elements.
+ * This takes care of a special case where
+ * the vec_len(stats) == 0,
+ * such that we return a vector of
+ * length 0, rather than a null pointer
+ * (since null pointer is an error)
+ */
+ vec_alloc (res, vec_len (stats));
+
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");
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)
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);
}
/*
Code Review / vpp.git / blobdiff