X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fclient%2Fstat_client.c;h=5bee21a2cfc5c27018026e147e291385dc65de73;hb=9067f3332ed0ddc143105b003e614f3f90719916;hp=538820ad338130bcb3cbe9b0c2efec2203f582c3;hpb=2152e1cf8b3420d94ba31fe25853977ad945f35a;p=vpp.git diff --git a/src/vpp-api/client/stat_client.c b/src/vpp-api/client/stat_client.c index 538820ad338..5bee21a2cfc 100644 --- a/src/vpp-api/client/stat_client.c +++ b/src/vpp-api/client/stat_client.c @@ -28,17 +28,10 @@ #include #include #include -#include "stat_client.h" #include -#include - -struct stat_client_main_t -{ - uint64_t current_epoch; - stat_segment_shared_header_t *shared_header; - stat_segment_directory_entry_t *directory_vector; - ssize_t memory_size; -}; +#include +#include +#include stat_client_main_t stat_client_main; @@ -89,23 +82,16 @@ recv_fd (int sock) 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); -} - -static stat_segment_directory_entry_t * -get_stat_vector (void) -{ - stat_client_main_t *sm = &stat_client_main; - return get_stat_vector_r (sm); + return stat_segment_adjust (sm, + (void *) sm->shared_header->directory_vector); } int -stat_segment_connect_r (char *socket_name, stat_client_main_t * sm) +stat_segment_connect_r (const char *socket_name, stat_client_main_t * sm) { int mfd = -1; int sock; @@ -124,14 +110,14 @@ stat_segment_connect_r (char *socket_name, stat_client_main_t * sm) 0) { close (sock); - 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); @@ -141,26 +127,29 @@ stat_segment_connect_r (char *socket_name, stat_client_main_t * sm) if (fstat (mfd, &st) == -1) { + close (mfd); perror ("mmap fstat failed"); - return -1; + return -4; } if ((memaddr = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, mfd, 0)) == MAP_FAILED) { + close (mfd); perror ("mmap map failed"); - return -1; + 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 (char *socket_name) +stat_segment_connect (const char *socket_name) { stat_client_main_t *sm = &stat_client_main; return stat_segment_connect_r (socket_name, sm); @@ -183,9 +172,18 @@ stat_segment_disconnect (void) double stat_segment_heartbeat_r (stat_client_main_t * sm) { - stat_segment_directory_entry_t *vec = get_stat_vector_r (sm); - double *hb = stat_segment_pointer (sm->shared_header, vec[4].offset); - return *hb; + 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 @@ -195,20 +193,50 @@ stat_segment_heartbeat (void) return stat_segment_heartbeat_r (sm); } -stat_segment_data_t -copy_data (stat_segment_directory_entry_t * ep, stat_client_main_t * 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 (vlib_stats_entry_t *ep, u32 index2, char *name, + stat_client_main_t *sm) { 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: @@ -216,44 +244,59 @@ copy_data (stat_segment_directory_entry_t * ep, stat_client_main_t * sm) 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; } @@ -276,40 +319,22 @@ 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_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_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_r (uint8_t ** patterns, stat_client_main_t * sm) { @@ -321,7 +346,7 @@ stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm) 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]); @@ -329,9 +354,10 @@ stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm) } } - 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++) @@ -374,7 +400,7 @@ stat_segment_data_t * 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; @@ -382,12 +408,23 @@ stat_segment_dump_r (uint32_t * stats, stat_client_main_t * sm) 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)); } if (stat_segment_access_end (&sa, sm)) @@ -419,27 +456,34 @@ stat_segment_vec_free (void *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_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)); if (stat_segment_access_end (&sa, sm)) return res; @@ -453,15 +497,44 @@ stat_segment_dump_entry (uint32_t index) 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); } /*