#include <vppinfra/vec.h>
#include <vppinfra/lock.h>
#include <stdatomic.h>
-#include <vpp/stats/stat_segment.h>
+#include <vlib/vlib.h>
+#include <vlib/stats/stats.h>
#include <vpp-api/client/stat_client.h>
stat_client_main_t stat_client_main;
return fd;
}
-static stat_segment_directory_entry_t *
-get_stat_vector_r (stat_client_main_t * sm)
+static vlib_stats_entry_t *
+get_stat_vector_r (stat_client_main_t *sm)
{
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
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;
}
stat_segment_heartbeat_r (stat_client_main_t * sm)
{
stat_segment_access_t sa;
- stat_segment_directory_entry_t *ep;
+ vlib_stats_entry_t *ep;
- /* Has directory been update? */
+ /* Has directory been updated? */
if (sm->shared_header->epoch != sm->current_epoch)
return 0;
- stat_segment_access_start (&sa, sm);
+ 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 stat_segment_heartbeat_r (sm);
}
+#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 (stat_segment_directory_entry_t * ep, stat_client_main_t * sm)
+copy_data (vlib_stats_entry_t *ep, u32 index2, char *name,
+ stat_client_main_t *sm, bool via_symlink)
{
stat_segment_data_t result = { 0 };
int i;
vlib_counter_t **combined_c; /* Combined counter */
counter_t **simple_c; /* Simple counter */
- uint64_t *offset_vector;
assert (sm->shared_header);
result.type = ep->type;
- result.name = strdup (ep->name);
+ result.via_symlink = via_symlink;
+ 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);
- }
- break;
-
- case STAT_DIR_TYPE_ERROR_INDEX:
- /* Gather errors from all threads into a vector */
- offset_vector = stat_segment_pointer (sm->shared_header,
- sm->shared_header->error_offset);
- vec_validate (result.error_vector, vec_len (offset_vector) - 1);
- for (i = 0; i < vec_len (offset_vector); i++)
- {
- counter_t *cb =
- stat_segment_pointer (sm->shared_header, offset_vector[i]);
- result.error_vector[i] = cb[ep->index];
+ 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_NAME_VECTOR:
- if (ep->offset == 0)
- return result;
- uint8_t **name_vector =
- stat_segment_pointer (sm->shared_header, ep->offset);
- result.name_vector = vec_dup (name_vector);
- offset_vector =
- stat_segment_pointer (sm->shared_header, ep->offset_vector);
- for (i = 0; i < vec_len (name_vector); i++)
- {
- if (offset_vector[i])
- {
- u8 *name =
- stat_segment_pointer (sm->shared_header, offset_vector[i]);
- result.name_vector[i] = vec_dup (name);
- }
- else
- result.name_vector[i] = 0;
- }
+ {
+ 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, true);
+ }
+
case STAT_DIR_TYPE_EMPTY:
break;
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);
}
}
}
- stat_segment_access_start (&sa, sm);
+ if (stat_segment_access_start (&sa, sm))
+ return 0;
- stat_segment_directory_entry_t *counter_vec = get_stat_vector_r (sm);
+ 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++)
stat_segment_dump_r (uint32_t * stats, stat_client_main_t * sm)
{
int i;
- 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, sm);
+ 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, sm));
+ vec_add1 (res, copy_data (ep, ~0, 0, sm, false));
}
if (stat_segment_access_end (&sa, sm))
fprintf (stderr, "Epoch changed while reading, invalid results\n");
// TODO increase counter
+ if (res)
+ stat_segment_data_free (res);
return 0;
}
stat_segment_data_t *
stat_segment_dump_entry_r (uint32_t index, stat_client_main_t * sm)
{
- 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, sm);
+ /* 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, sm));
+ vec_add1 (res, copy_data (ep, ~0, 0, sm, false));
if (stat_segment_access_end (&sa, sm))
return res;
char *
stat_segment_index_to_name_r (uint32_t index, stat_client_main_t * sm)
{
- stat_segment_directory_entry_t *ep;
+ vlib_stats_entry_t *ep;
stat_segment_access_t sa;
- stat_segment_directory_entry_t *vec;
+ vlib_stats_entry_t *vec;
/* Has directory been update? */
if (sm->shared_header->epoch != sm->current_epoch)
return 0;
- stat_segment_access_start (&sa, sm);
+ if (stat_segment_access_start (&sa, sm))
+ return 0;
vec = get_stat_vector_r (sm);
ep = vec_elt_at_index (vec, index);
+ if (ep->type == STAT_DIR_TYPE_EMPTY)
+ {
+ stat_segment_access_end (&sa, sm);
+ return 0;
+ }
if (!stat_segment_access_end (&sa, sm))
return 0;
return strdup (ep->name);
Code Review / vpp.git / blobdiff