X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vpp%2Fstats%2Fstats.c;h=c46e2d5a44ec26f84e742a80b52d3fefe671f540;hb=6d963c272cb59cbcb41a2f2c7e01834a80fad683;hp=daaced43dd86a6a093223ec6893014051a5fa120;hpb=4189c17afb7b62977b359929e42cacf942900425;p=vpp.git diff --git a/vpp/stats/stats.c b/vpp/stats/stats.c index daaced43dd8..c46e2d5a44e 100644 --- a/vpp/stats/stats.c +++ b/vpp/stats/stats.c @@ -15,6 +15,9 @@ #include #include #include +#include +#include +#include #define STATS_DEBUG 0 @@ -22,23 +25,23 @@ stats_main_t stats_main; #include -#include +#include #define f64_endian(a) #define f64_print(a,b) -#define vl_typedefs /* define message structures */ -#include +#define vl_typedefs /* define message structures */ +#include #undef vl_typedefs -#define vl_endianfun /* define message structures */ -#include +#define vl_endianfun /* define message structures */ +#include #undef vl_endianfun /* instantiate all the print functions we know about */ #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) #define vl_printfun -#include +#include #undef vl_printfun #define foreach_stats_msg \ @@ -58,383 +61,393 @@ _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) #define STATS_RELEASE_DELAY_NS (1000 * 1000 * 5) /* ns/us us/ms */ -void dslock (stats_main_t *sm, int release_hint, int tag) +void +dslock (stats_main_t * sm, int release_hint, int tag) { - u32 thread_id; - data_structure_lock_t *l = sm->data_structure_lock; + u32 thread_id; + data_structure_lock_t *l = sm->data_structure_lock; - if(PREDICT_FALSE(l == 0)) - return; + if (PREDICT_FALSE (l == 0)) + return; - thread_id = os_get_cpu_number(); - if (l->lock && l->thread_id == thread_id) { - l->count++; - return; + thread_id = os_get_cpu_number (); + if (l->lock && l->thread_id == thread_id) + { + l->count++; + return; } - if (release_hint) - l->release_hint++; + if (release_hint) + l->release_hint++; - while (__sync_lock_test_and_set (&l->lock, 1)) - /* zzzz */ ; - l->tag = tag; - l->thread_id = thread_id; - l->count = 1; + while (__sync_lock_test_and_set (&l->lock, 1)) + /* zzzz */ ; + l->tag = tag; + l->thread_id = thread_id; + l->count = 1; } -void dsunlock (stats_main_t *sm) +void +stats_dslock_with_hint (int hint, int tag) { - u32 thread_id; - data_structure_lock_t *l = sm->data_structure_lock; - - if(PREDICT_FALSE(l == 0)) - return; - - thread_id = os_get_cpu_number(); - ASSERT (l->lock && l->thread_id == thread_id); - l->count--; - if (l->count == 0) { - l->tag = -l->tag; - l->release_hint = 0; - CLIB_MEMORY_BARRIER(); - l->lock = 0; - } + stats_main_t *sm = &stats_main; + dslock (sm, hint, tag); } -static void do_simple_interface_counters (stats_main_t * sm) +void +dsunlock (stats_main_t * sm) { - vl_api_vnet_interface_counters_t * mp = 0; - vnet_interface_main_t * im = sm->interface_main; - api_main_t * am = sm->api_main; - vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; - unix_shared_memory_queue_t * q = shmem_hdr->vl_input_queue; - vlib_simple_counter_main_t * cm; - u32 items_this_message = 0; - u64 v, *vp = 0; - int i; - - /* - * Prevent interface registration from expanding / moving the vectors... - * That tends never to happen, so we can hold this lock for a while. - */ - vnet_interface_counter_lock (im); - - vec_foreach (cm, im->sw_if_counters) { - - for (i = 0; i < vec_len (cm->maxi); i++) { - if (mp == 0) { - items_this_message = clib_min (SIMPLE_COUNTER_BATCH_SIZE, - vec_len (cm->maxi) - i); - - mp = vl_msg_api_alloc_as_if_client - (sizeof (*mp) + items_this_message * sizeof (v)); - mp->_vl_msg_id = ntohs (VL_API_VNET_INTERFACE_COUNTERS); - mp->vnet_counter_type = cm - im->sw_if_counters; - mp->is_combined = 0; - mp->first_sw_if_index = htonl (i); - mp->count = 0; - vp = (u64 *) mp->data; - } - v = vlib_get_simple_counter (cm, i); - clib_mem_unaligned (vp, u64) = clib_host_to_net_u64 (v); - vp++; - mp->count++; - if (mp->count == items_this_message) { - mp->count = htonl (items_this_message); - /* Send to the main thread... */ - vl_msg_api_send_shmem (q, (u8 *)&mp); - mp = 0; - } - } - ASSERT (mp == 0); + u32 thread_id; + data_structure_lock_t *l = sm->data_structure_lock; + + if (PREDICT_FALSE (l == 0)) + return; + + thread_id = os_get_cpu_number (); + ASSERT (l->lock && l->thread_id == thread_id); + l->count--; + if (l->count == 0) + { + l->tag = -l->tag; + l->release_hint = 0; + CLIB_MEMORY_BARRIER (); + l->lock = 0; } - vnet_interface_counter_unlock (im); } -static void do_combined_interface_counters (stats_main_t * sm) +void +stats_dsunlock (int hint, int tag) { - vl_api_vnet_interface_counters_t * mp = 0; - vnet_interface_main_t * im = sm->interface_main; - api_main_t * am = sm->api_main; - vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; - unix_shared_memory_queue_t * q = shmem_hdr->vl_input_queue; - vlib_combined_counter_main_t * cm; - u32 items_this_message = 0; - vlib_counter_t v, *vp = 0; - int i; - - vnet_interface_counter_lock (im); - - vec_foreach (cm, im->combined_sw_if_counters) { - - for (i = 0; i < vec_len (cm->maxi); i++) { - if (mp == 0) { - items_this_message = clib_min (COMBINED_COUNTER_BATCH_SIZE, - vec_len (cm->maxi) - i); - - mp = vl_msg_api_alloc_as_if_client - (sizeof (*mp) + items_this_message * sizeof (v)); - mp->_vl_msg_id = ntohs (VL_API_VNET_INTERFACE_COUNTERS); - mp->vnet_counter_type = cm - im->combined_sw_if_counters; - mp->is_combined = 1; - mp->first_sw_if_index = htonl (i); - mp->count = 0; - vp = (vlib_counter_t *)mp->data; - } - vlib_get_combined_counter (cm, i, &v); - clib_mem_unaligned (&vp->packets, u64) - = clib_host_to_net_u64 (v.packets); - clib_mem_unaligned (&vp->bytes, u64) - = clib_host_to_net_u64 (v.bytes); - vp++; - mp->count++; - if (mp->count == items_this_message) { - mp->count = htonl (items_this_message); - /* Send to the main thread... */ - vl_msg_api_send_shmem (q, (u8 *)&mp); - mp = 0; - } - } - ASSERT (mp == 0); - } - vnet_interface_counter_unlock (im); + stats_main_t *sm = &stats_main; + dsunlock (sm); } -/* from .../vnet/vnet/ip/lookup.c. Yuck */ -typedef CLIB_PACKED (struct { - ip4_address_t address; - - u32 address_length : 6; +static void +do_simple_interface_counters (stats_main_t * sm) +{ + vl_api_vnet_interface_counters_t *mp = 0; + vnet_interface_main_t *im = sm->interface_main; + api_main_t *am = sm->api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + unix_shared_memory_queue_t *q = shmem_hdr->vl_input_queue; + vlib_simple_counter_main_t *cm; + u32 items_this_message = 0; + u64 v, *vp = 0; + int i; + + /* + * Prevent interface registration from expanding / moving the vectors... + * That tends never to happen, so we can hold this lock for a while. + */ + vnet_interface_counter_lock (im); + + vec_foreach (cm, im->sw_if_counters) + { + + for (i = 0; i < vec_len (cm->maxi); i++) + { + if (mp == 0) + { + items_this_message = clib_min (SIMPLE_COUNTER_BATCH_SIZE, + vec_len (cm->maxi) - i); + + mp = vl_msg_api_alloc_as_if_client + (sizeof (*mp) + items_this_message * sizeof (v)); + mp->_vl_msg_id = ntohs (VL_API_VNET_INTERFACE_COUNTERS); + mp->vnet_counter_type = cm - im->sw_if_counters; + mp->is_combined = 0; + mp->first_sw_if_index = htonl (i); + mp->count = 0; + vp = (u64 *) mp->data; + } + v = vlib_get_simple_counter (cm, i); + clib_mem_unaligned (vp, u64) = clib_host_to_net_u64 (v); + vp++; + mp->count++; + if (mp->count == items_this_message) + { + mp->count = htonl (items_this_message); + /* Send to the main thread... */ + vl_msg_api_send_shmem (q, (u8 *) & mp); + mp = 0; + } + } + ASSERT (mp == 0); + } + vnet_interface_counter_unlock (im); +} - u32 index : 26; -}) ip4_route_t; +static void +do_combined_interface_counters (stats_main_t * sm) +{ + vl_api_vnet_interface_counters_t *mp = 0; + vnet_interface_main_t *im = sm->interface_main; + api_main_t *am = sm->api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + unix_shared_memory_queue_t *q = shmem_hdr->vl_input_queue; + vlib_combined_counter_main_t *cm; + u32 items_this_message = 0; + vlib_counter_t v, *vp = 0; + int i; + + vnet_interface_counter_lock (im); + + vec_foreach (cm, im->combined_sw_if_counters) + { + + for (i = 0; i < vec_len (cm->maxi); i++) + { + if (mp == 0) + { + items_this_message = clib_min (COMBINED_COUNTER_BATCH_SIZE, + vec_len (cm->maxi) - i); + + mp = vl_msg_api_alloc_as_if_client + (sizeof (*mp) + items_this_message * sizeof (v)); + mp->_vl_msg_id = ntohs (VL_API_VNET_INTERFACE_COUNTERS); + mp->vnet_counter_type = cm - im->combined_sw_if_counters; + mp->is_combined = 1; + mp->first_sw_if_index = htonl (i); + mp->count = 0; + vp = (vlib_counter_t *) mp->data; + } + vlib_get_combined_counter (cm, i, &v); + clib_mem_unaligned (&vp->packets, u64) + = clib_host_to_net_u64 (v.packets); + clib_mem_unaligned (&vp->bytes, u64) = clib_host_to_net_u64 (v.bytes); + vp++; + mp->count++; + if (mp->count == items_this_message) + { + mp->count = htonl (items_this_message); + /* Send to the main thread... */ + vl_msg_api_send_shmem (q, (u8 *) & mp); + mp = 0; + } + } + ASSERT (mp == 0); + } + vnet_interface_counter_unlock (im); +} -static void ip46_fib_stats_delay (stats_main_t * sm, u32 sec, u32 nsec) +/* from .../vnet/vnet/ip/lookup.c. Yuck */ +typedef CLIB_PACKED (struct + { + ip4_address_t address; +u32 address_length: 6; +u32 index: 26; + }) ip4_route_t; + +static void +ip46_fib_stats_delay (stats_main_t * sm, u32 sec, u32 nsec) { - struct timespec _req, *req = &_req; - struct timespec _rem, *rem = &_rem; - - req->tv_sec = sec; - req->tv_nsec = nsec; - while (1) { - if (nanosleep (req, rem) == 0) - break; - *req = *rem; - if (errno == EINTR) - continue; - clib_unix_warning ("nanosleep"); - break; + struct timespec _req, *req = &_req; + struct timespec _rem, *rem = &_rem; + + req->tv_sec = sec; + req->tv_nsec = nsec; + while (1) + { + if (nanosleep (req, rem) == 0) + break; + *req = *rem; + if (errno == EINTR) + continue; + clib_unix_warning ("nanosleep"); + break; } } -static void do_ip4_fibs (stats_main_t * sm) +static void +do_ip4_fibs (stats_main_t * sm) { - ip4_main_t * im4 = &ip4_main; - api_main_t * am = sm->api_main; - vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; - unix_shared_memory_queue_t * q = shmem_hdr->vl_input_queue; - static ip4_route_t * routes; - ip4_route_t * r; - ip4_fib_t * fib; - ip_lookup_main_t * lm = &im4->lookup_main; - static uword * results; - vl_api_vnet_ip4_fib_counters_t * mp = 0; - u32 items_this_message; - vl_api_ip4_fib_counter_t *ctrp = 0; - u32 start_at_fib_index = 0; - int i; + ip4_main_t *im4 = &ip4_main; + api_main_t *am = sm->api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + unix_shared_memory_queue_t *q = shmem_hdr->vl_input_queue; + static ip4_route_t *routes; + ip4_route_t *r; + fib_table_t *fib; + ip_lookup_main_t *lm = &im4->lookup_main; + static uword *results; + vl_api_vnet_ip4_fib_counters_t *mp = 0; + u32 items_this_message; + vl_api_ip4_fib_counter_t *ctrp = 0; + u32 start_at_fib_index = 0; + int i; again: - vec_foreach (fib, im4->fibs) { - /* We may have bailed out due to control-plane activity */ - while ((fib - im4->fibs) < start_at_fib_index) - continue; - - if (mp == 0) { - items_this_message = IP4_FIB_COUNTER_BATCH_SIZE; - mp = vl_msg_api_alloc_as_if_client - (sizeof(*mp) + - items_this_message*sizeof(vl_api_ip4_fib_counter_t)); - mp->_vl_msg_id = ntohs (VL_API_VNET_IP4_FIB_COUNTERS); - mp->count = 0; - mp->vrf_id = ntohl(fib->table_id); - ctrp = (vl_api_ip4_fib_counter_t *)mp->c; - } else { - /* happens if the last FIB was empty... */ - ASSERT(mp->count == 0); - mp->vrf_id = ntohl(fib->table_id); - } - - dslock (sm, 0 /* release hint */, 1 /* tag */); - - vec_reset_length (routes); - vec_reset_length (results); - - for (i = 0; i < ARRAY_LEN (fib->adj_index_by_dst_address); i++) { - uword * hash = fib->adj_index_by_dst_address[i]; - hash_pair_t * p; - ip4_route_t x; - - x.address_length = i; - - hash_foreach_pair (p, hash, - ({ - x.address.data_u32 = p->key; - if (lm->fib_result_n_words > 1) { - x.index = vec_len (results); - vec_add (results, p->value, lm->fib_result_n_words); - } - else - x.index = p->value[0]; - - vec_add1 (routes, x); - if (sm->data_structure_lock->release_hint) { - start_at_fib_index = fib - im4->fibs; + /* *INDENT-OFF* */ + pool_foreach (fib, im4->fibs, + ({ + /* We may have bailed out due to control-plane activity */ + while ((fib - im4->fibs) < start_at_fib_index) + continue; + + if (mp == 0) + { + items_this_message = IP4_FIB_COUNTER_BATCH_SIZE; + mp = vl_msg_api_alloc_as_if_client + (sizeof (*mp) + + items_this_message * sizeof (vl_api_ip4_fib_counter_t)); + mp->_vl_msg_id = ntohs (VL_API_VNET_IP4_FIB_COUNTERS); + mp->count = 0; + mp->vrf_id = ntohl (fib->ft_table_id); + ctrp = (vl_api_ip4_fib_counter_t *) mp->c; + } + else + { + /* happens if the last FIB was empty... */ + ASSERT (mp->count == 0); + mp->vrf_id = ntohl (fib->ft_table_id); + } + + dslock (sm, 0 /* release hint */ , 1 /* tag */ ); + + vec_reset_length (routes); + vec_reset_length (results); + + for (i = 0; i < ARRAY_LEN (fib->v4.fib_entry_by_dst_address); i++) + { + uword *hash = fib->v4.fib_entry_by_dst_address[i]; + hash_pair_t *p; + ip4_route_t x; + + x.address_length = i; + + hash_foreach_pair (p, hash, + ({ + x.address.data_u32 = p->key; + if (lm->fib_result_n_words > 1) + { + x.index = vec_len (results); + vec_add (results, p->value, lm->fib_result_n_words); + } + else + x.index = p->value[0]; + + vec_add1 (routes, x); + if (sm->data_structure_lock->release_hint) + { + start_at_fib_index = fib - im4->fibs; + dsunlock (sm); + ip46_fib_stats_delay (sm, 0 /* sec */, + STATS_RELEASE_DELAY_NS); + mp->count = 0; + ctrp = (vl_api_ip4_fib_counter_t *)mp->c; + goto again; + } + })); + } + + vec_foreach (r, routes) + { + vlib_counter_t c; + + vlib_get_combined_counter (&load_balance_main.lbm_to_counters, + r->index, &c); + /* + * If it has actually + * seen at least one packet, send it. + */ + if (c.packets > 0) + { + + /* already in net byte order */ + ctrp->address = r->address.as_u32; + ctrp->address_length = r->address_length; + ctrp->packets = clib_host_to_net_u64 (c.packets); + ctrp->bytes = clib_host_to_net_u64 (c.bytes); + mp->count++; + ctrp++; + + if (mp->count == items_this_message) + { + mp->count = htonl (items_this_message); + /* + * If the main thread's input queue is stuffed, + * drop the data structure lock (which the main thread + * may want), and take a pause. + */ + unix_shared_memory_queue_lock (q); + if (unix_shared_memory_queue_is_full (q)) + { dsunlock (sm); - ip46_fib_stats_delay (sm, 0 /* sec */, - STATS_RELEASE_DELAY_NS); - mp->count = 0; - ctrp = (vl_api_ip4_fib_counter_t *)mp->c; + vl_msg_api_send_shmem_nolock (q, (u8 *) & mp); + unix_shared_memory_queue_unlock (q); + mp = 0; + ip46_fib_stats_delay (sm, 0 /* sec */ , + STATS_RELEASE_DELAY_NS); goto again; - } - })); - } - - vec_foreach (r, routes) { - vlib_counter_t c, sum; - uword i, j, n_left, n_nhs, adj_index, * result = 0; - ip_adjacency_t * adj; - ip_multipath_next_hop_t * nhs, tmp_nhs[1]; - - adj_index = r->index; - if (lm->fib_result_n_words > 1) { - result = vec_elt_at_index (results, adj_index); - adj_index = result[0]; - } - - adj = ip_get_adjacency (lm, adj_index); - if (adj->n_adj == 1) { - nhs = &tmp_nhs[0]; - nhs[0].next_hop_adj_index = ~0; /* not used */ - nhs[0].weight = 1; - n_nhs = 1; - } else { - ip_multipath_adjacency_t * madj; - madj = vec_elt_at_index (lm->multipath_adjacencies, - adj->heap_handle); - nhs = heap_elt_at_index - (lm->next_hop_heap, - madj->normalized_next_hops.heap_offset); - n_nhs = madj->normalized_next_hops.count; - } - - n_left = nhs[0].weight; - vlib_counter_zero (&sum); - for (i = j = 0; i < adj->n_adj; i++) { - n_left -= 1; - vlib_get_combined_counter (&lm->adjacency_counters, - adj_index + i, &c); - vlib_counter_add (&sum, &c); - /* - * If we're done with this adj and it has actually - * seen at least one packet, send it. - */ - if (n_left == 0 && sum.packets > 0) { - - /* already in net byte order */ - ctrp->address = r->address.as_u32; - ctrp->address_length = r->address_length; - ctrp->packets = clib_host_to_net_u64 (sum.packets); - ctrp->bytes = clib_host_to_net_u64(sum.bytes); - mp->count++; - ctrp++; - - if (mp->count == items_this_message) { - mp->count = htonl (items_this_message); - /* - * If the main thread's input queue is stuffed, - * drop the data structure lock (which the main thread - * may want), and take a pause. - */ - unix_shared_memory_queue_lock (q); - if (unix_shared_memory_queue_is_full (q)) { - dsunlock (sm); - vl_msg_api_send_shmem_nolock (q, (u8 *)&mp); - unix_shared_memory_queue_unlock (q); - mp = 0; - ip46_fib_stats_delay (sm, 0 /* sec */, - STATS_RELEASE_DELAY_NS); - goto again; - } - vl_msg_api_send_shmem_nolock (q, (u8 *)&mp); - unix_shared_memory_queue_unlock (q); - - items_this_message = IP4_FIB_COUNTER_BATCH_SIZE; - mp = vl_msg_api_alloc_as_if_client - (sizeof(*mp) + - items_this_message* - sizeof(vl_api_ip4_fib_counter_t)); - mp->_vl_msg_id = ntohs (VL_API_VNET_IP4_FIB_COUNTERS); - mp->count = 0; - mp->vrf_id = ntohl(fib->table_id); - ctrp = (vl_api_ip4_fib_counter_t *)mp->c; - } - - j++; - if (j < n_nhs) { - n_left = nhs[j].weight; - vlib_counter_zero (&sum); - } - } - } /* for each (mp or single) adj */ - if (sm->data_structure_lock->release_hint) { - start_at_fib_index = fib - im4->fibs; - dsunlock (sm); - ip46_fib_stats_delay (sm, 0 /* sec */, STATS_RELEASE_DELAY_NS); + } + vl_msg_api_send_shmem_nolock (q, (u8 *) & mp); + unix_shared_memory_queue_unlock (q); + + items_this_message = IP4_FIB_COUNTER_BATCH_SIZE; + mp = vl_msg_api_alloc_as_if_client + (sizeof (*mp) + + items_this_message * sizeof (vl_api_ip4_fib_counter_t)); + mp->_vl_msg_id = ntohs (VL_API_VNET_IP4_FIB_COUNTERS); mp->count = 0; - ctrp = (vl_api_ip4_fib_counter_t *)mp->c; - goto again; - } - } /* vec_foreach (routes) */ - - dsunlock(sm); - - /* Flush any data from this fib */ - if (mp->count) { - mp->count = htonl (mp->count); - vl_msg_api_send_shmem (q, (u8 *)&mp); - mp = 0; - } - } /* vec_foreach (fib) */ - /* If e.g. the last FIB had no reportable routes, free the buffer */ - if (mp) - vl_msg_api_free (mp); + mp->vrf_id = ntohl (fib->ft_table_id); + ctrp = (vl_api_ip4_fib_counter_t *) mp->c; + } + } /* for each (mp or single) adj */ + if (sm->data_structure_lock->release_hint) + { + start_at_fib_index = fib - im4->fibs; + dsunlock (sm); + ip46_fib_stats_delay (sm, 0 /* sec */ , STATS_RELEASE_DELAY_NS); + mp->count = 0; + ctrp = (vl_api_ip4_fib_counter_t *) mp->c; + goto again; + } + } /* vec_foreach (routes) */ + + dsunlock (sm); + + /* Flush any data from this fib */ + if (mp->count) + { + mp->count = htonl (mp->count); + vl_msg_api_send_shmem (q, (u8 *) & mp); + mp = 0; + } + })); + /* *INDENT-ON* */ + + /* If e.g. the last FIB had no reportable routes, free the buffer */ + if (mp) + vl_msg_api_free (mp); } -typedef struct { +typedef struct +{ ip6_address_t address; u32 address_length; u32 index; } ip6_route_t; -typedef struct { +typedef struct +{ u32 fib_index; - ip6_route_t ** routep; - stats_main_t * sm; + ip6_route_t **routep; + stats_main_t *sm; } add_routes_in_fib_arg_t; -static void add_routes_in_fib (BVT(clib_bihash_kv) * kvp, void *arg) +static void +add_routes_in_fib (BVT (clib_bihash_kv) * kvp, void *arg) { - add_routes_in_fib_arg_t * ap = arg; - stats_main_t * sm = ap->sm; + add_routes_in_fib_arg_t *ap = arg; + stats_main_t *sm = ap->sm; if (sm->data_structure_lock->release_hint) clib_longjmp (&sm->jmp_buf, 1); - if (kvp->key[2]>>32 == ap->fib_index) + if (kvp->key[2] >> 32 == ap->fib_index) { ip6_address_t *addr; - ip6_route_t * r; + ip6_route_t *r; addr = (ip6_address_t *) kvp; vec_add2 (*ap->routep, r, 1); r->address = addr[0]; @@ -443,457 +456,473 @@ static void add_routes_in_fib (BVT(clib_bihash_kv) * kvp, void *arg) } } -static void do_ip6_fibs (stats_main_t * sm) +static void +do_ip6_fibs (stats_main_t * sm) { - ip6_main_t * im6 = &ip6_main; - api_main_t * am = sm->api_main; - vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; - unix_shared_memory_queue_t * q = shmem_hdr->vl_input_queue; - static ip6_route_t * routes; - ip6_route_t * r; - ip6_fib_t * fib; - ip_lookup_main_t * lm = &im6->lookup_main; - static uword * results; - vl_api_vnet_ip6_fib_counters_t * mp = 0; - u32 items_this_message; - vl_api_ip6_fib_counter_t *ctrp = 0; - u32 start_at_fib_index = 0; - BVT(clib_bihash) * h = &im6->ip6_lookup_table; - add_routes_in_fib_arg_t _a, *a=&_a; + ip6_main_t *im6 = &ip6_main; + api_main_t *am = sm->api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + unix_shared_memory_queue_t *q = shmem_hdr->vl_input_queue; + static ip6_route_t *routes; + ip6_route_t *r; + fib_table_t *fib; + static uword *results; + vl_api_vnet_ip6_fib_counters_t *mp = 0; + u32 items_this_message; + vl_api_ip6_fib_counter_t *ctrp = 0; + u32 start_at_fib_index = 0; + BVT (clib_bihash) * h = &im6->ip6_table[IP6_FIB_TABLE_FWDING].ip6_hash; + add_routes_in_fib_arg_t _a, *a = &_a; again: - vec_foreach (fib, im6->fibs) { - /* We may have bailed out due to control-plane activity */ - while ((fib - im6->fibs) < start_at_fib_index) - continue; - - if (mp == 0) { - items_this_message = IP6_FIB_COUNTER_BATCH_SIZE; - mp = vl_msg_api_alloc_as_if_client - (sizeof(*mp) + - items_this_message*sizeof(vl_api_ip6_fib_counter_t)); - mp->_vl_msg_id = ntohs (VL_API_VNET_IP6_FIB_COUNTERS); - mp->count = 0; - mp->vrf_id = ntohl(fib->table_id); - ctrp = (vl_api_ip6_fib_counter_t *)mp->c; - } - - dslock (sm, 0 /* release hint */, 1 /* tag */); - - vec_reset_length (routes); - vec_reset_length (results); + /* *INDENT-OFF* */ + pool_foreach (fib, im6->fibs, + ({ + /* We may have bailed out due to control-plane activity */ + while ((fib - im6->fibs) < start_at_fib_index) + continue; + + if (mp == 0) + { + items_this_message = IP6_FIB_COUNTER_BATCH_SIZE; + mp = vl_msg_api_alloc_as_if_client + (sizeof (*mp) + + items_this_message * sizeof (vl_api_ip6_fib_counter_t)); + mp->_vl_msg_id = ntohs (VL_API_VNET_IP6_FIB_COUNTERS); + mp->count = 0; + mp->vrf_id = ntohl (fib->ft_table_id); + ctrp = (vl_api_ip6_fib_counter_t *) mp->c; + } + + dslock (sm, 0 /* release hint */ , 1 /* tag */ ); + + vec_reset_length (routes); + vec_reset_length (results); + + a->fib_index = fib - im6->fibs; + a->routep = &routes; + a->sm = sm; + + if (clib_setjmp (&sm->jmp_buf, 0) == 0) + { + start_at_fib_index = fib - im6->fibs; + BV (clib_bihash_foreach_key_value_pair) (h, add_routes_in_fib, a); + } + else + { + dsunlock (sm); + ip46_fib_stats_delay (sm, 0 /* sec */ , + STATS_RELEASE_DELAY_NS); + mp->count = 0; + ctrp = (vl_api_ip6_fib_counter_t *) mp->c; + goto again; + } + + vec_foreach (r, routes) + { + vlib_counter_t c; + + vlib_get_combined_counter (&load_balance_main.lbm_to_counters, + r->index, &c); + /* + * If it has actually + * seen at least one packet, send it. + */ + if (c.packets > 0) + { + /* already in net byte order */ + ctrp->address[0] = r->address.as_u64[0]; + ctrp->address[1] = r->address.as_u64[1]; + ctrp->address_length = (u8) r->address_length; + ctrp->packets = clib_host_to_net_u64 (c.packets); + ctrp->bytes = clib_host_to_net_u64 (c.bytes); + mp->count++; + ctrp++; - a->fib_index = fib - im6->fibs; - a->routep = &routes; - a->sm = sm; + if (mp->count == items_this_message) + { + mp->count = htonl (items_this_message); + /* + * If the main thread's input queue is stuffed, + * drop the data structure lock (which the main thread + * may want), and take a pause. + */ + unix_shared_memory_queue_lock (q); + if (unix_shared_memory_queue_is_full (q)) + { + dsunlock (sm); + vl_msg_api_send_shmem_nolock (q, (u8 *) & mp); + unix_shared_memory_queue_unlock (q); + mp = 0; + ip46_fib_stats_delay (sm, 0 /* sec */ , + STATS_RELEASE_DELAY_NS); + goto again; + } + vl_msg_api_send_shmem_nolock (q, (u8 *) & mp); + unix_shared_memory_queue_unlock (q); + + items_this_message = IP6_FIB_COUNTER_BATCH_SIZE; + mp = vl_msg_api_alloc_as_if_client + (sizeof (*mp) + + items_this_message * sizeof (vl_api_ip6_fib_counter_t)); + mp->_vl_msg_id = ntohs (VL_API_VNET_IP6_FIB_COUNTERS); + mp->count = 0; + mp->vrf_id = ntohl (fib->ft_table_id); + ctrp = (vl_api_ip6_fib_counter_t *) mp->c; + } + } - if (clib_setjmp(&sm->jmp_buf, 0) == 0) + if (sm->data_structure_lock->release_hint) { start_at_fib_index = fib - im6->fibs; - BV(clib_bihash_foreach_key_value_pair)(h, add_routes_in_fib, a); - } - else - { dsunlock (sm); - ip46_fib_stats_delay (sm, 0 /* sec */, - STATS_RELEASE_DELAY_NS); + ip46_fib_stats_delay (sm, 0 /* sec */ , STATS_RELEASE_DELAY_NS); mp->count = 0; - ctrp = (vl_api_ip6_fib_counter_t *)mp->c; + ctrp = (vl_api_ip6_fib_counter_t *) mp->c; goto again; } - - vec_foreach (r, routes) { - vlib_counter_t c, sum; - uword i, j, n_left, n_nhs, adj_index, * result = 0; - ip_adjacency_t * adj; - ip_multipath_next_hop_t * nhs, tmp_nhs[1]; - - adj_index = r->index; - if (lm->fib_result_n_words > 1) { - result = vec_elt_at_index (results, adj_index); - adj_index = result[0]; - } - - adj = ip_get_adjacency (lm, adj_index); - if (adj->n_adj == 1) { - nhs = &tmp_nhs[0]; - nhs[0].next_hop_adj_index = ~0; /* not used */ - nhs[0].weight = 1; - n_nhs = 1; - } else { - ip_multipath_adjacency_t * madj; - madj = vec_elt_at_index (lm->multipath_adjacencies, - adj->heap_handle); - nhs = heap_elt_at_index - (lm->next_hop_heap, - madj->normalized_next_hops.heap_offset); - n_nhs = madj->normalized_next_hops.count; - } - - n_left = nhs[0].weight; - vlib_counter_zero (&sum); - for (i = j = 0; i < adj->n_adj; i++) { - n_left -= 1; - vlib_get_combined_counter (&lm->adjacency_counters, - adj_index + i, &c); - vlib_counter_add (&sum, &c); - if (n_left == 0 && sum.packets > 0) { - - /* already in net byte order */ - ctrp->address[0] = r->address.as_u64[0]; - ctrp->address[1] = r->address.as_u64[1]; - ctrp->address_length = (u8) r->address_length; - ctrp->packets = clib_host_to_net_u64 (sum.packets); - ctrp->bytes = clib_host_to_net_u64(sum.bytes); - mp->count++; - ctrp++; - - if (mp->count == items_this_message) { - mp->count = htonl (items_this_message); - /* - * If the main thread's input queue is stuffed, - * drop the data structure lock (which the main thread - * may want), and take a pause. - */ - unix_shared_memory_queue_lock (q); - if (unix_shared_memory_queue_is_full (q)) { - dsunlock (sm); - vl_msg_api_send_shmem_nolock (q, (u8 *)&mp); - unix_shared_memory_queue_unlock (q); - mp = 0; - ip46_fib_stats_delay (sm, 0 /* sec */, - STATS_RELEASE_DELAY_NS); - goto again; - } - vl_msg_api_send_shmem_nolock (q, (u8 *)&mp); - unix_shared_memory_queue_unlock (q); - - items_this_message = IP6_FIB_COUNTER_BATCH_SIZE; - mp = vl_msg_api_alloc_as_if_client - (sizeof(*mp) + - items_this_message* - sizeof(vl_api_ip6_fib_counter_t)); - mp->_vl_msg_id = ntohs (VL_API_VNET_IP6_FIB_COUNTERS); - mp->count = 0; - mp->vrf_id = ntohl(fib->table_id); - ctrp = (vl_api_ip6_fib_counter_t *)mp->c; - } - - j++; - if (j < n_nhs) { - n_left = nhs[j].weight; - vlib_counter_zero (&sum); - } - } - } /* for each (mp or single) adj */ - if (sm->data_structure_lock->release_hint) { - start_at_fib_index = fib - im6->fibs; - dsunlock (sm); - ip46_fib_stats_delay (sm, 0 /* sec */, STATS_RELEASE_DELAY_NS); - mp->count = 0; - ctrp = (vl_api_ip6_fib_counter_t *)mp->c; - goto again; - } - } /* vec_foreach (routes) */ - - dsunlock(sm); - - /* Flush any data from this fib */ - if (mp->count) { - mp->count = htonl (mp->count); - vl_msg_api_send_shmem (q, (u8 *)&mp); - mp = 0; - } - } /* vec_foreach (fib) */ - /* If e.g. the last FIB had no reportable routes, free the buffer */ - if (mp) - vl_msg_api_free (mp); + } /* vec_foreach (routes) */ + + dsunlock (sm); + + /* Flush any data from this fib */ + if (mp->count) + { + mp->count = htonl (mp->count); + vl_msg_api_send_shmem (q, (u8 *) & mp); + mp = 0; + } + })); + /* *INDENT-ON* */ + + /* If e.g. the last FIB had no reportable routes, free the buffer */ + if (mp) + vl_msg_api_free (mp); } -static void stats_thread_fn (void *arg) +static void +stats_thread_fn (void *arg) { - stats_main_t *sm = &stats_main; - vlib_worker_thread_t *w = (vlib_worker_thread_t *)arg; - vlib_thread_main_t *tm = vlib_get_thread_main(); - - /* stats thread wants no signals. */ - { - sigset_t s; - sigfillset (&s); - pthread_sigmask (SIG_SETMASK, &s, 0); - } + stats_main_t *sm = &stats_main; + vlib_worker_thread_t *w = (vlib_worker_thread_t *) arg; + vlib_thread_main_t *tm = vlib_get_thread_main (); - if (vec_len(tm->thread_prefix)) - vlib_set_thread_name((char *) - format(0, "%v_stats%c", tm->thread_prefix, '\0')); + /* stats thread wants no signals. */ + { + sigset_t s; + sigfillset (&s); + pthread_sigmask (SIG_SETMASK, &s, 0); + } - clib_mem_set_heap (w->thread_mheap); + if (vec_len (tm->thread_prefix)) + vlib_set_thread_name ((char *) + format (0, "%v_stats%c", tm->thread_prefix, '\0')); - while (1) { - /* 10 second poll interval */ - ip46_fib_stats_delay (sm, 10 /* secs */, 0 /* nsec */); + clib_mem_set_heap (w->thread_mheap); - if (! (sm->enable_poller)) - continue; - do_simple_interface_counters (sm); - do_combined_interface_counters (sm); - do_ip4_fibs (sm); - do_ip6_fibs (sm); + while (1) + { + /* 10 second poll interval */ + ip46_fib_stats_delay (sm, 10 /* secs */ , 0 /* nsec */ ); + + if (!(sm->enable_poller)) + continue; + do_simple_interface_counters (sm); + do_combined_interface_counters (sm); + do_ip4_fibs (sm); + do_ip6_fibs (sm); } } -static void vl_api_vnet_interface_counters_t_handler ( - vl_api_vnet_interface_counters_t *mp) +static void +vl_api_vnet_interface_counters_t_handler (vl_api_vnet_interface_counters_t * + mp) { - vpe_client_registration_t *reg; - stats_main_t * sm = &stats_main; - unix_shared_memory_queue_t *q, *q_prev = NULL; - vl_api_vnet_interface_counters_t *mp_copy = NULL; - u32 mp_size; + vpe_client_registration_t *reg; + stats_main_t *sm = &stats_main; + unix_shared_memory_queue_t *q, *q_prev = NULL; + vl_api_vnet_interface_counters_t *mp_copy = NULL; + u32 mp_size; #if STATS_DEBUG > 0 - char *counter_name; - u32 count, sw_if_index; - int i; + char *counter_name; + u32 count, sw_if_index; + int i; #endif - - mp_size = sizeof (*mp) + (ntohl(mp->count) * - (mp->is_combined ? sizeof (vlib_counter_t) : sizeof (u64))); - - pool_foreach(reg, sm->stats_registrations, - ({ - q = vl_api_client_index_to_input_queue (reg->client_index); - if (q) { - if (q_prev && (q_prev->cursize < q_prev->maxsize)) { - mp_copy = vl_msg_api_alloc_as_if_client(mp_size); - memcpy(mp_copy, mp, mp_size); - vl_msg_api_send_shmem (q_prev, (u8 *)&mp); - mp = mp_copy; - } - q_prev = q; - } - })); + + mp_size = sizeof (*mp) + (ntohl (mp->count) * + (mp->is_combined ? sizeof (vlib_counter_t) : + sizeof (u64))); + + /* *INDENT-OFF* */ + pool_foreach(reg, sm->stats_registrations, + ({ + q = vl_api_client_index_to_input_queue (reg->client_index); + if (q) + { + if (q_prev && (q_prev->cursize < q_prev->maxsize)) + { + mp_copy = vl_msg_api_alloc_as_if_client(mp_size); + clib_memcpy(mp_copy, mp, mp_size); + vl_msg_api_send_shmem (q_prev, (u8 *)&mp); + mp = mp_copy; + } + q_prev = q; + } + })); + /* *INDENT-ON* */ #if STATS_DEBUG > 0 - count = ntohl (mp->count); - sw_if_index = ntohl (mp->first_sw_if_index); - if (mp->is_combined == 0) { - u64 * vp, v; - vp = (u64 *) mp->data; - - switch (mp->vnet_counter_type) { - case VNET_INTERFACE_COUNTER_DROP: - counter_name = "drop"; - break; - case VNET_INTERFACE_COUNTER_PUNT: - counter_name = "punt"; - break; - case VNET_INTERFACE_COUNTER_IP4: - counter_name = "ip4"; - break; - case VNET_INTERFACE_COUNTER_IP6: - counter_name = "ip6"; - break; - case VNET_INTERFACE_COUNTER_RX_NO_BUF: - counter_name = "rx-no-buff"; - break; - case VNET_INTERFACE_COUNTER_RX_MISS:, - counter_name = "rx-miss"; - break; - case VNET_INTERFACE_COUNTER_RX_ERROR:, - counter_name = "rx-error (fifo-full)"; - break; - case VNET_INTERFACE_COUNTER_TX_ERROR:, - counter_name = "tx-error (fifo-full)"; - break; - default: - counter_name = "bogus"; - break; - } - for (i = 0; i < count; i++) { - v = clib_mem_unaligned (vp, u64); - v = clib_net_to_host_u64 (v); - vp++; - fformat (stdout, "%U.%s %lld\n", format_vnet_sw_if_index_name, - sm->vnet_main, sw_if_index, counter_name, v); - sw_if_index++; - } - } else { - vlib_counter_t *vp; - u64 packets, bytes; - vp = (vlib_counter_t *) mp->data; - - switch (mp->vnet_counter_type) { - case VNET_INTERFACE_COUNTER_RX: - counter_name = "rx"; - break; - case VNET_INTERFACE_COUNTER_TX: - counter_name = "tx"; - break; - default: - counter_name = "bogus"; - break; - } - for (i = 0; i < count; i++) { - packets = clib_mem_unaligned (&vp->packets, u64); - packets = clib_net_to_host_u64 (packets); - bytes = clib_mem_unaligned (&vp->bytes, u64); - bytes = clib_net_to_host_u64 (bytes); - vp++; - fformat (stdout, "%U.%s.packets %lld\n", - format_vnet_sw_if_index_name, - sm->vnet_main, sw_if_index, counter_name, packets); - fformat (stdout, "%U.%s.bytes %lld\n", - format_vnet_sw_if_index_name, - sm->vnet_main, sw_if_index, counter_name, bytes); - sw_if_index++; - } + count = ntohl (mp->count); + sw_if_index = ntohl (mp->first_sw_if_index); + if (mp->is_combined == 0) + { + u64 *vp, v; + vp = (u64 *) mp->data; + + switch (mp->vnet_counter_type) + { + case VNET_INTERFACE_COUNTER_DROP: + counter_name = "drop"; + break; + case VNET_INTERFACE_COUNTER_PUNT: + counter_name = "punt"; + break; + case VNET_INTERFACE_COUNTER_IP4: + counter_name = "ip4"; + break; + case VNET_INTERFACE_COUNTER_IP6: + counter_name = "ip6"; + break; + case VNET_INTERFACE_COUNTER_RX_NO_BUF: + counter_name = "rx-no-buff"; + break; + case VNET_INTERFACE_COUNTER_RX_MISS: + , counter_name = "rx-miss"; + break; + case VNET_INTERFACE_COUNTER_RX_ERROR: + , counter_name = "rx-error (fifo-full)"; + break; + case VNET_INTERFACE_COUNTER_TX_ERROR: + , counter_name = "tx-error (fifo-full)"; + break; + default: + counter_name = "bogus"; + break; + } + for (i = 0; i < count; i++) + { + v = clib_mem_unaligned (vp, u64); + v = clib_net_to_host_u64 (v); + vp++; + fformat (stdout, "%U.%s %lld\n", format_vnet_sw_if_index_name, + sm->vnet_main, sw_if_index, counter_name, v); + sw_if_index++; + } + } + else + { + vlib_counter_t *vp; + u64 packets, bytes; + vp = (vlib_counter_t *) mp->data; + + switch (mp->vnet_counter_type) + { + case VNET_INTERFACE_COUNTER_RX: + counter_name = "rx"; + break; + case VNET_INTERFACE_COUNTER_TX: + counter_name = "tx"; + break; + default: + counter_name = "bogus"; + break; + } + for (i = 0; i < count; i++) + { + packets = clib_mem_unaligned (&vp->packets, u64); + packets = clib_net_to_host_u64 (packets); + bytes = clib_mem_unaligned (&vp->bytes, u64); + bytes = clib_net_to_host_u64 (bytes); + vp++; + fformat (stdout, "%U.%s.packets %lld\n", + format_vnet_sw_if_index_name, + sm->vnet_main, sw_if_index, counter_name, packets); + fformat (stdout, "%U.%s.bytes %lld\n", + format_vnet_sw_if_index_name, + sm->vnet_main, sw_if_index, counter_name, bytes); + sw_if_index++; + } } #endif - if (q_prev && - (q_prev->cursize < q_prev->maxsize)) { - vl_msg_api_send_shmem (q_prev, (u8 *)&mp); - } else { - vl_msg_api_free (mp); + if (q_prev && (q_prev->cursize < q_prev->maxsize)) + { + vl_msg_api_send_shmem (q_prev, (u8 *) & mp); + } + else + { + vl_msg_api_free (mp); } } -static void vl_api_vnet_ip4_fib_counters_t_handler ( - vl_api_vnet_ip4_fib_counters_t *mp) +static void +vl_api_vnet_ip4_fib_counters_t_handler (vl_api_vnet_ip4_fib_counters_t * mp) { - vpe_client_registration_t *reg; - stats_main_t * sm = &stats_main; - unix_shared_memory_queue_t *q, *q_prev = NULL; - vl_api_vnet_ip4_fib_counters_t *mp_copy = NULL; - u32 mp_size; - - mp_size = sizeof(*mp_copy) + - ntohl(mp->count) * sizeof(vl_api_ip4_fib_counter_t); - - pool_foreach(reg, sm->stats_registrations, - ({ - q = vl_api_client_index_to_input_queue (reg->client_index); - if (q) { - if (q_prev && (q_prev->cursize < q_prev->maxsize)) { - mp_copy = vl_msg_api_alloc_as_if_client(mp_size); - memcpy(mp_copy, mp, mp_size); - vl_msg_api_send_shmem (q_prev, (u8 *)&mp); - mp = mp_copy; - } - q_prev = q; - } - })); - if (q_prev && - (q_prev->cursize < q_prev->maxsize)) { + vpe_client_registration_t *reg; + stats_main_t *sm = &stats_main; + unix_shared_memory_queue_t *q, *q_prev = NULL; + vl_api_vnet_ip4_fib_counters_t *mp_copy = NULL; + u32 mp_size; + + mp_size = sizeof (*mp_copy) + + ntohl (mp->count) * sizeof (vl_api_ip4_fib_counter_t); + + /* *INDENT-OFF* */ + pool_foreach(reg, sm->stats_registrations, + ({ + q = vl_api_client_index_to_input_queue (reg->client_index); + if (q) + { + if (q_prev && (q_prev->cursize < q_prev->maxsize)) + { + mp_copy = vl_msg_api_alloc_as_if_client(mp_size); + clib_memcpy(mp_copy, mp, mp_size); vl_msg_api_send_shmem (q_prev, (u8 *)&mp); - } else { - vl_msg_api_free (mp); + mp = mp_copy; + } + q_prev = q; + } + })); + /* *INDENT-ON* */ + if (q_prev && (q_prev->cursize < q_prev->maxsize)) + { + vl_msg_api_send_shmem (q_prev, (u8 *) & mp); + } + else + { + vl_msg_api_free (mp); } } -static void vl_api_vnet_ip6_fib_counters_t_handler ( - vl_api_vnet_ip6_fib_counters_t *mp) +static void +vl_api_vnet_ip6_fib_counters_t_handler (vl_api_vnet_ip6_fib_counters_t * mp) { - vpe_client_registration_t *reg; - stats_main_t * sm = &stats_main; - unix_shared_memory_queue_t *q, *q_prev = NULL; - vl_api_vnet_ip6_fib_counters_t *mp_copy = NULL; - u32 mp_size; - - mp_size = sizeof(*mp_copy) + - ntohl(mp->count) * sizeof(vl_api_ip6_fib_counter_t); - - pool_foreach(reg, sm->stats_registrations, - ({ - q = vl_api_client_index_to_input_queue (reg->client_index); - if (q) { - if (q_prev && (q_prev->cursize < q_prev->maxsize)) { - mp_copy = vl_msg_api_alloc_as_if_client(mp_size); - memcpy(mp_copy, mp, mp_size); - vl_msg_api_send_shmem (q_prev, (u8 *)&mp); - mp = mp_copy; - } - q_prev = q; - } - })); - if (q_prev && - (q_prev->cursize < q_prev->maxsize)) { + vpe_client_registration_t *reg; + stats_main_t *sm = &stats_main; + unix_shared_memory_queue_t *q, *q_prev = NULL; + vl_api_vnet_ip6_fib_counters_t *mp_copy = NULL; + u32 mp_size; + + mp_size = sizeof (*mp_copy) + + ntohl (mp->count) * sizeof (vl_api_ip6_fib_counter_t); + + /* *INDENT-OFF* */ + pool_foreach(reg, sm->stats_registrations, + ({ + q = vl_api_client_index_to_input_queue (reg->client_index); + if (q) + { + if (q_prev && (q_prev->cursize < q_prev->maxsize)) + { + mp_copy = vl_msg_api_alloc_as_if_client(mp_size); + clib_memcpy(mp_copy, mp, mp_size); vl_msg_api_send_shmem (q_prev, (u8 *)&mp); - } else { - vl_msg_api_free (mp); + mp = mp_copy; + } + q_prev = q; + } + })); + /* *INDENT-ON* */ + if (q_prev && (q_prev->cursize < q_prev->maxsize)) + { + vl_msg_api_send_shmem (q_prev, (u8 *) & mp); + } + else + { + vl_msg_api_free (mp); } } -static void vl_api_want_stats_reply_t_handler (vl_api_want_stats_reply_t *mp) -{ clib_warning ("BUG"); } +static void +vl_api_want_stats_reply_t_handler (vl_api_want_stats_reply_t * mp) +{ + clib_warning ("BUG"); +} -static void vl_api_want_stats_t_handler ( - vl_api_want_stats_t *mp) +static void +vl_api_want_stats_t_handler (vl_api_want_stats_t * mp) { - stats_main_t *sm = &stats_main; - vpe_client_registration_t *rp; - vl_api_want_stats_reply_t *rmp; - uword *p; - i32 retval = 0; - unix_shared_memory_queue_t *q; - - p = hash_get (sm->stats_registration_hash, mp->client_index); - if (p) { - if (mp->enable_disable) { - clib_warning ("pid %d: already enabled...", mp->pid); - retval = -2; - goto reply; - } else { - rp = pool_elt_at_index (sm->stats_registrations, p[0]); - pool_put (sm->stats_registrations, rp); - hash_unset (sm->stats_registration_hash, mp->client_index); - goto reply; - } + stats_main_t *sm = &stats_main; + vpe_client_registration_t *rp; + vl_api_want_stats_reply_t *rmp; + uword *p; + i32 retval = 0; + unix_shared_memory_queue_t *q; + + p = hash_get (sm->stats_registration_hash, mp->client_index); + if (p) + { + if (mp->enable_disable) + { + clib_warning ("pid %d: already enabled...", mp->pid); + retval = -2; + goto reply; + } + else + { + rp = pool_elt_at_index (sm->stats_registrations, p[0]); + pool_put (sm->stats_registrations, rp); + hash_unset (sm->stats_registration_hash, mp->client_index); + goto reply; + } } - if (mp->enable_disable == 0) { - clib_warning ("pid %d: already disabled...", mp->pid); - retval = -3; - goto reply; + if (mp->enable_disable == 0) + { + clib_warning ("pid %d: already disabled...", mp->pid); + retval = -3; + goto reply; } - pool_get (sm->stats_registrations, rp); - rp->client_index = mp->client_index; - rp->client_pid = mp->pid; - hash_set (sm->stats_registration_hash, rp->client_index, - rp - sm->stats_registrations); + pool_get (sm->stats_registrations, rp); + rp->client_index = mp->client_index; + rp->client_pid = mp->pid; + hash_set (sm->stats_registration_hash, rp->client_index, + rp - sm->stats_registrations); reply: - if (pool_elts(sm->stats_registrations)) - sm->enable_poller = 1; - else - sm->enable_poller = 0; - - q = vl_api_client_index_to_input_queue (mp->client_index); + if (pool_elts (sm->stats_registrations)) + sm->enable_poller = 1; + else + sm->enable_poller = 0; + + q = vl_api_client_index_to_input_queue (mp->client_index); - if (!q) - return; + if (!q) + return; - rmp = vl_msg_api_alloc (sizeof (*rmp)); - rmp->_vl_msg_id = ntohs(VL_API_WANT_STATS_REPLY); - rmp->context = mp->context; - rmp->retval = retval; + rmp = vl_msg_api_alloc (sizeof (*rmp)); + rmp->_vl_msg_id = ntohs (VL_API_WANT_STATS_REPLY); + rmp->context = mp->context; + rmp->retval = retval; - vl_msg_api_send_shmem (q, (u8 *)&rmp); + vl_msg_api_send_shmem (q, (u8 *) & rmp); } -int stats_memclnt_delete_callback (u32 client_index) +int +stats_memclnt_delete_callback (u32 client_index) { - vpe_client_registration_t *rp; - stats_main_t *sm = &stats_main; - uword * p; - - p = hash_get (sm->stats_registration_hash, client_index); - if (p) { - rp = pool_elt_at_index (sm->stats_registrations, p[0]); - pool_put (sm->stats_registrations, rp); - hash_unset (sm->stats_registration_hash, client_index); + vpe_client_registration_t *rp; + stats_main_t *sm = &stats_main; + uword *p; + + p = hash_get (sm->stats_registration_hash, client_index); + if (p) + { + rp = pool_elt_at_index (sm->stats_registrations, p[0]); + pool_put (sm->stats_registrations, rp); + hash_unset (sm->stats_registration_hash, client_index); } - return 0; + return 0; } #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler @@ -901,21 +930,22 @@ int stats_memclnt_delete_callback (u32 client_index) #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler -static clib_error_t * stats_init (vlib_main_t * vm) +static clib_error_t * +stats_init (vlib_main_t * vm) { - stats_main_t * sm = &stats_main; - api_main_t * am = &api_main; - void *vlib_worker_thread_bootstrap_fn (void *arg); - - sm->vlib_main = vm; - sm->vnet_main = vnet_get_main(); - sm->interface_main = &vnet_get_main()->interface_main; - sm->api_main = am; - sm->stats_poll_interval_in_seconds = 10; - sm->data_structure_lock = - clib_mem_alloc_aligned (sizeof(data_structure_lock_t), - CLIB_CACHE_LINE_BYTES); - memset(sm->data_structure_lock, 0, sizeof (*sm->data_structure_lock)); + stats_main_t *sm = &stats_main; + api_main_t *am = &api_main; + void *vlib_worker_thread_bootstrap_fn (void *arg); + + sm->vlib_main = vm; + sm->vnet_main = vnet_get_main (); + sm->interface_main = &vnet_get_main ()->interface_main; + sm->api_main = am; + sm->stats_poll_interval_in_seconds = 10; + sm->data_structure_lock = + clib_mem_alloc_aligned (sizeof (data_structure_lock_t), + CLIB_CACHE_LINE_BYTES); + memset (sm->data_structure_lock, 0, sizeof (*sm->data_structure_lock)); #define _(N,n) \ vl_msg_api_set_handlers(VL_API_##N, #n, \ @@ -923,26 +953,35 @@ static clib_error_t * stats_init (vlib_main_t * vm) vl_noop_handler, \ vl_api_##n##_t_endian, \ vl_api_##n##_t_print, \ - sizeof(vl_api_##n##_t), 0 /* do NOT trace! */); - foreach_stats_msg; + sizeof(vl_api_##n##_t), 0 /* do NOT trace! */); + foreach_stats_msg; #undef _ - /* tell the msg infra not to free these messages... */ - am->message_bounce [VL_API_VNET_INTERFACE_COUNTERS] = 1; - am->message_bounce [VL_API_VNET_IP4_FIB_COUNTERS] = 1; - am->message_bounce [VL_API_VNET_IP6_FIB_COUNTERS] = 1; + /* tell the msg infra not to free these messages... */ + am->message_bounce[VL_API_VNET_INTERFACE_COUNTERS] = 1; + am->message_bounce[VL_API_VNET_IP4_FIB_COUNTERS] = 1; + am->message_bounce[VL_API_VNET_IP6_FIB_COUNTERS] = 1; - return 0; + return 0; } VLIB_INIT_FUNCTION (stats_init); +/* *INDENT-OFF* */ VLIB_REGISTER_THREAD (stats_thread_reg, static) = { - .name = "stats", - .function = stats_thread_fn, - .fixed_count = 1, - .count = 1, - .no_data_structure_clone = 1, - .use_pthreads = 1, - .mheap_size = 2<<20, + .name = "stats", + .function = stats_thread_fn, + .fixed_count = 1, + .count = 1, + .no_data_structure_clone = 1, + .use_pthreads = 1, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */