src/vpp/stats/stat_segment.c

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vppinfra/mem.h>
  17 #include <vlib/vlib.h>
  18 #include <vlib/unix/unix.h>
  19 #include "stat_segment.h"
  20 #include <vnet/vnet.h>
  21 #include <vnet/devices/devices.h>       /* vnet_get_aggregate_rx_packets */
  22 #undef HAVE_MEMFD_CREATE
  23 #include <vppinfra/linux/syscall.h>
  24 #include <vpp-api/client/stat_client.h>
  25 #include <vppinfra/mheap.h>
  26
  27 stat_segment_main_t stat_segment_main;
  28
  29 /*
  30  *  Used only by VPP writers
  31  */
  32 void
  33 vlib_stat_segment_lock (void)
  34 {
  35   stat_segment_main_t *sm = &stat_segment_main;
  36   clib_spinlock_lock (sm->stat_segment_lockp);
  37   sm->shared_header->in_progress = 1;
  38 }
  39
  40 void
  41 vlib_stat_segment_unlock (void)
  42 {
  43   stat_segment_main_t *sm = &stat_segment_main;
  44   sm->shared_header->epoch++;
  45   sm->shared_header->in_progress = 0;
  46   clib_spinlock_unlock (sm->stat_segment_lockp);
  47 }
  48
  49 /*
  50  * Change heap to the stats shared memory segment
  51  */
  52 void *
  53 vlib_stats_push_heap (void *old)
  54 {
  55   stat_segment_main_t *sm = &stat_segment_main;
  56
  57   sm->last = old;
  58   ASSERT (sm && sm->shared_header);
  59   return clib_mem_set_heap (sm->heap);
  60 }
  61
  62 static u32
  63 lookup_hash_index (u8 * name)
  64 {
  65   stat_segment_main_t *sm = &stat_segment_main;
  66   u32 index = STAT_SEGMENT_INDEX_INVALID;
  67   hash_pair_t *hp;
  68
  69   /* Must be called in the context of the main heap */
  70   ASSERT (clib_mem_get_heap () != sm->heap);
  71
  72   hp = hash_get_pair (sm->directory_vector_by_name, name);
  73   if (hp)
  74     {
  75       index = hp->value[0];
  76     }
  77
  78   return index;
  79 }
  80
  81 static void
  82 create_hash_index (u8 * name, u32 index)
  83 {
  84   stat_segment_main_t *sm = &stat_segment_main;
  85
  86   /* Must be called in the context of the main heap */
  87   ASSERT (clib_mem_get_heap () != sm->heap);
  88
  89   hash_set (sm->directory_vector_by_name, format (0, "%s%c", name, 0), index);
  90 }
  91
  92 static u32
  93 vlib_stats_get_next_vector_index ()
  94 {
  95   stat_segment_main_t *sm = &stat_segment_main;
  96   u32 next_vector_index = vec_len (sm->directory_vector);
  97
  98   ssize_t i;
  99   vec_foreach_index_backwards (i, sm->directory_vector)
 100   {
 101     if (sm->directory_vector[i].type == STAT_DIR_TYPE_EMPTY)
 102       {
 103         next_vector_index = i;
 104         break;
 105       }
 106   }
 107
 108   return next_vector_index;
 109 }
 110
 111 static u32
 112 vlib_stats_create_counter (stat_segment_directory_entry_t * e, void *oldheap)
 113 {
 114   stat_segment_main_t *sm = &stat_segment_main;
 115
 116   ASSERT (clib_mem_get_heap () == sm->heap);
 117
 118   u32 index = vlib_stats_get_next_vector_index ();
 119
 120   clib_mem_set_heap (oldheap);
 121   create_hash_index ((u8 *) e->name, index);
 122   clib_mem_set_heap (sm->heap);
 123
 124   vec_validate (sm->directory_vector, index);
 125   sm->directory_vector[index] = *e;
 126
 127   return index;
 128 }
 129
 130 static void
 131 vlib_stats_delete_counter (u32 index, void *oldheap)
 132 {
 133   stat_segment_main_t *sm = &stat_segment_main;
 134   stat_segment_directory_entry_t *e;
 135
 136   ASSERT (clib_mem_get_heap () == sm->heap);
 137
 138   if (index > vec_len (sm->directory_vector))
 139     return;
 140
 141   e = &sm->directory_vector[index];
 142
 143   clib_mem_set_heap (oldheap);
 144   hash_unset (sm->directory_vector_by_name, &e->name);
 145   clib_mem_set_heap (sm->heap);
 146
 147   memset (e, 0, sizeof (*e));
 148   e->type = STAT_DIR_TYPE_EMPTY;
 149 }
 150
 151 /*
 152  * Called from main heap
 153  */
 154 void
 155 vlib_stats_delete_cm (void *cm_arg)
 156 {
 157   vlib_simple_counter_main_t *cm = (vlib_simple_counter_main_t *) cm_arg;
 158   stat_segment_main_t *sm = &stat_segment_main;
 159   stat_segment_directory_entry_t *e;
 160
 161   /* Not all counters have names / hash-table entries */
 162   if (!cm->name && !cm->stat_segment_name)
 163     {
 164       return;
 165     }
 166   vlib_stat_segment_lock ();
 167
 168   /* Lookup hash-table is on the main heap */
 169   char *stat_segment_name =
 170     cm->stat_segment_name ? cm->stat_segment_name : cm->name;
 171   u32 index = lookup_hash_index ((u8 *) stat_segment_name);
 172
 173   e = &sm->directory_vector[index];
 174   hash_unset (sm->directory_vector_by_name, &e->name);
 175
 176   void *oldheap = clib_mem_set_heap (sm->heap); /* Enter stats segment */
 177   clib_mem_set_heap (oldheap);  /* Exit stats segment */
 178
 179   memset (e, 0, sizeof (*e));
 180   e->type = STAT_DIR_TYPE_EMPTY;
 181
 182   vlib_stat_segment_unlock ();
 183 }
 184
 185 void
 186 vlib_stats_pop_heap (void *cm_arg, void *oldheap, u32 cindex,
 187                      stat_directory_type_t type)
 188 {
 189   vlib_simple_counter_main_t *cm = (vlib_simple_counter_main_t *) cm_arg;
 190   stat_segment_main_t *sm = &stat_segment_main;
 191   stat_segment_shared_header_t *shared_header = sm->shared_header;
 192   char *stat_segment_name;
 193   stat_segment_directory_entry_t e = { 0 };
 194
 195   /* Not all counters have names / hash-table entries */
 196   if (!cm->name && !cm->stat_segment_name)
 197     {
 198       clib_mem_set_heap (oldheap);
 199       return;
 200     }
 201
 202   ASSERT (shared_header);
 203
 204   vlib_stat_segment_lock ();
 205
 206   /* Lookup hash-table is on the main heap */
 207   stat_segment_name =
 208     cm->stat_segment_name ? cm->stat_segment_name : cm->name;
 209
 210   clib_mem_set_heap (oldheap);  /* Exit stats segment */
 211   u32 vector_index = lookup_hash_index ((u8 *) stat_segment_name);
 212   /* Back to stats segment */
 213   clib_mem_set_heap (sm->heap); /* Re-enter stat segment */
 214
 215
 216   /* Update the vector */
 217   if (vector_index == STAT_SEGMENT_INDEX_INVALID)
 218     {                           /* New */
 219       strncpy (e.name, stat_segment_name, 128 - 1);
 220       e.type = type;
 221       vector_index = vlib_stats_create_counter (&e, oldheap);
 222     }
 223
 224   stat_segment_directory_entry_t *ep = &sm->directory_vector[vector_index];
 225   ep->data = cm->counters;
 226
 227   /* Reset the client hash table pointer, since it WILL change! */
 228   shared_header->directory_vector = sm->directory_vector;
 229
 230   vlib_stat_segment_unlock ();
 231   clib_mem_set_heap (oldheap);
 232 }
 233
 234 void
 235 vlib_stats_register_error_index (void *oldheap, u8 * name, u64 * em_vec,
 236                                  u64 index)
 237 {
 238   stat_segment_main_t *sm = &stat_segment_main;
 239   stat_segment_shared_header_t *shared_header = sm->shared_header;
 240   stat_segment_directory_entry_t e;
 241
 242   ASSERT (shared_header);
 243
 244   vlib_stat_segment_lock ();
 245   clib_mem_set_heap (oldheap);  /* Exit stats segment */
 246   u32 vector_index = lookup_hash_index (name);
 247   /* Back to stats segment */
 248   clib_mem_set_heap (sm->heap); /* Re-enter stat segment */
 249
 250   if (vector_index == STAT_SEGMENT_INDEX_INVALID)
 251     {
 252       memcpy (e.name, name, vec_len (name));
 253       e.name[vec_len (name)] = '\0';
 254       e.type = STAT_DIR_TYPE_ERROR_INDEX;
 255       e.index = index;
 256       vector_index = vlib_stats_create_counter (&e, oldheap);
 257
 258       /* Warn clients to refresh any pointers they might be holding */
 259       shared_header->directory_vector = sm->directory_vector;
 260     }
 261
 262   vlib_stat_segment_unlock ();
 263 }
 264
 265 static void
 266 stat_validate_counter_vector (stat_segment_directory_entry_t * ep, u32 max)
 267 {
 268   counter_t **counters = ep->data;
 269   vlib_thread_main_t *tm = vlib_get_thread_main ();
 270   int i;
 271
 272   vec_validate_aligned (counters, tm->n_vlib_mains - 1,
 273                         CLIB_CACHE_LINE_BYTES);
 274   for (i = 0; i < tm->n_vlib_mains; i++)
 275     vec_validate_aligned (counters[i], max, CLIB_CACHE_LINE_BYTES);
 276
 277   ep->data = counters;
 278 }
 279
 280 always_inline void
 281 stat_set_simple_counter (stat_segment_directory_entry_t * ep,
 282                          u32 thread_index, u32 index, u64 value)
 283 {
 284   ASSERT (ep->data);
 285   counter_t *cb = ep->data;
 286   cb[index] = value;
 287 }
 288
 289 void
 290 vlib_stats_pop_heap2 (u64 * error_vector, u32 thread_index, void *oldheap,
 291                       int lock)
 292 {
 293   stat_segment_main_t *sm = &stat_segment_main;
 294   stat_segment_shared_header_t *shared_header = sm->shared_header;
 295
 296   ASSERT (shared_header);
 297
 298   if (lock)
 299     vlib_stat_segment_lock ();
 300
 301   /* Reset the client hash table pointer, since it WILL change! */
 302   vec_validate (sm->error_vector, thread_index);
 303   sm->error_vector[thread_index] = error_vector;
 304
 305   shared_header->error_vector = sm->error_vector;
 306   shared_header->directory_vector = sm->directory_vector;
 307
 308   if (lock)
 309     vlib_stat_segment_unlock ();
 310   clib_mem_set_heap (oldheap);
 311 }
 312
 313 clib_error_t *
 314 vlib_map_stat_segment_init (void)
 315 {
 316   stat_segment_main_t *sm = &stat_segment_main;
 317   stat_segment_shared_header_t *shared_header;
 318   void *oldheap;
 319   ssize_t memory_size;
 320   int mfd;
 321   char *mem_name = "stat_segment_test";
 322   void *memaddr;
 323
 324   memory_size = sm->memory_size;
 325   if (memory_size == 0)
 326     memory_size = STAT_SEGMENT_DEFAULT_SIZE;
 327
 328   /* Create shared memory segment */
 329   if ((mfd = memfd_create (mem_name, 0)) < 0)
 330     return clib_error_return (0, "stat segment memfd_create failure");
 331
 332   /* Set size */
 333   if ((ftruncate (mfd, memory_size)) == -1)
 334     return clib_error_return (0, "stat segment ftruncate failure");
 335
 336   if ((memaddr =
 337        mmap (NULL, memory_size, PROT_READ | PROT_WRITE, MAP_SHARED, mfd,
 338              0)) == MAP_FAILED)
 339     return clib_error_return (0, "stat segment mmap failure");
 340
 341   void *heap;
 342   heap =
 343     create_mspace_with_base (((u8 *) memaddr) + getpagesize (),
 344                              memory_size - getpagesize (), 1 /* locked */ );
 345   mspace_disable_expand (heap);
 346   sm->heap = heap;
 347   sm->memfd = mfd;
 348
 349   sm->directory_vector_by_name = hash_create_string (0, sizeof (uword));
 350   sm->shared_header = shared_header = memaddr;
 351
 352   shared_header->version = STAT_SEGMENT_VERSION;
 353   shared_header->base = memaddr;
 354
 355   sm->stat_segment_lockp = clib_mem_alloc (sizeof (clib_spinlock_t));
 356   clib_spinlock_init (sm->stat_segment_lockp);
 357
 358   oldheap = clib_mem_set_heap (sm->heap);
 359
 360   /* Set up the name to counter-vector hash table */
 361   sm->directory_vector = 0;
 362
 363   shared_header->epoch = 1;
 364
 365   /* Scalar stats and node counters */
 366   vec_validate (sm->directory_vector, STAT_COUNTERS - 1);
 367 #define _(E,t,n,p)                                                      \
 368   strcpy(sm->directory_vector[STAT_COUNTER_##E].name,  #p "/" #n); \
 369   sm->directory_vector[STAT_COUNTER_##E].type = STAT_DIR_TYPE_##t;
 370   foreach_stat_segment_counter_name
 371 #undef _
 372     /* Save the vector in the shared segment, for clients */
 373     shared_header->directory_vector = sm->directory_vector;
 374
 375   clib_mem_set_heap (oldheap);
 376
 377   /* Total shared memory size */
 378   clib_mem_usage_t usage;
 379   mheap_usage (sm->heap, &usage);
 380   sm->directory_vector[STAT_COUNTER_MEM_STATSEG_TOTAL].value =
 381     usage.bytes_total;
 382
 383   return 0;
 384 }
 385
 386 static int
 387 name_sort_cmp (void *a1, void *a2)
 388 {
 389   stat_segment_directory_entry_t *n1 = a1;
 390   stat_segment_directory_entry_t *n2 = a2;
 391
 392   return strcmp ((char *) n1->name, (char *) n2->name);
 393 }
 394
 395 static u8 *
 396 format_stat_dir_entry (u8 * s, va_list * args)
 397 {
 398   stat_segment_directory_entry_t *ep =
 399     va_arg (*args, stat_segment_directory_entry_t *);
 400   char *type_name;
 401   char *format_string;
 402
 403   format_string = "%-74s %-10s %10lld";
 404
 405   switch (ep->type)
 406     {
 407     case STAT_DIR_TYPE_SCALAR_INDEX:
 408       type_name = "ScalarPtr";
 409       break;
 410
 411     case STAT_DIR_TYPE_COUNTER_VECTOR_SIMPLE:
 412     case STAT_DIR_TYPE_COUNTER_VECTOR_COMBINED:
 413       type_name = "CMainPtr";
 414       break;
 415
 416     case STAT_DIR_TYPE_ERROR_INDEX:
 417       type_name = "ErrIndex";
 418       break;
 419
 420     case STAT_DIR_TYPE_NAME_VECTOR:
 421       type_name = "NameVector";
 422       break;
 423
 424     case STAT_DIR_TYPE_EMPTY:
 425       type_name = "empty";
 426       break;
 427
 428     default:
 429       type_name = "illegal!";
 430       break;
 431     }
 432
 433   return format (s, format_string, ep->name, type_name, 0);
 434 }
 435
 436 static clib_error_t *
 437 show_stat_segment_command_fn (vlib_main_t * vm,
 438                               unformat_input_t * input,
 439                               vlib_cli_command_t * cmd)
 440 {
 441   stat_segment_main_t *sm = &stat_segment_main;
 442   stat_segment_directory_entry_t *show_data;
 443   int i;
 444
 445   int verbose = 0;
 446
 447   if (unformat (input, "verbose"))
 448     verbose = 1;
 449
 450   /* Lock even as reader, as this command doesn't handle epoch changes */
 451   vlib_stat_segment_lock ();
 452   show_data = vec_dup (sm->directory_vector);
 453   vlib_stat_segment_unlock ();
 454
 455   vec_sort_with_function (show_data, name_sort_cmp);
 456
 457   vlib_cli_output (vm, "%-74s %10s %10s", "Name", "Type", "Value");
 458
 459   for (i = 0; i < vec_len (show_data); i++)
 460     {
 461       stat_segment_directory_entry_t *ep = vec_elt_at_index (show_data, i);
 462
 463       if (ep->type == STAT_DIR_TYPE_EMPTY)
 464         continue;
 465
 466       vlib_cli_output (vm, "%-100U", format_stat_dir_entry,
 467                        vec_elt_at_index (show_data, i));
 468     }
 469
 470   if (verbose)
 471     {
 472       ASSERT (sm->heap);
 473       vlib_cli_output (vm, "%U", format_mheap, sm->heap, 0 /* verbose */ );
 474     }
 475
 476   return 0;
 477 }
 478
 479 /* *INDENT-OFF* */
 480 VLIB_CLI_COMMAND (show_stat_segment_command, static) =
 481 {
 482   .path = "show statistics segment",
 483   .short_help = "show statistics segment [verbose]",
 484   .function = show_stat_segment_command_fn,
 485 };
 486 /* *INDENT-ON* */
 487
 488 /*
 489  * Node performance counters:
 490  * total_calls [threads][node-index]
 491  * total_vectors
 492  * total_calls
 493  * total suspends
 494  */
 495
 496 static inline void
 497 update_node_counters (stat_segment_main_t * sm)
 498 {
 499   vlib_main_t **stat_vms = 0;
 500   vlib_node_t ***node_dups = 0;
 501   int i, j;
 502   static u32 no_max_nodes = 0;
 503
 504   vlib_node_get_nodes (0 /* vm, for barrier sync */ ,
 505                        (u32) ~ 0 /* all threads */ ,
 506                        1 /* include stats */ ,
 507                        0 /* barrier sync */ ,
 508                        &node_dups, &stat_vms);
 509
 510   u32 l = vec_len (node_dups[0]);
 511
 512   /*
 513    * Extend performance nodes if necessary
 514    */
 515   if (l > no_max_nodes)
 516     {
 517       void *oldheap = clib_mem_set_heap (sm->heap);
 518       vlib_stat_segment_lock ();
 519
 520       stat_validate_counter_vector (&sm->directory_vector
 521                                     [STAT_COUNTER_NODE_CLOCKS], l - 1);
 522       stat_validate_counter_vector (&sm->directory_vector
 523                                     [STAT_COUNTER_NODE_VECTORS], l - 1);
 524       stat_validate_counter_vector (&sm->directory_vector
 525                                     [STAT_COUNTER_NODE_CALLS], l - 1);
 526       stat_validate_counter_vector (&sm->directory_vector
 527                                     [STAT_COUNTER_NODE_SUSPENDS], l - 1);
 528
 529       vec_validate (sm->nodes, l - 1);
 530       stat_segment_directory_entry_t *ep;
 531       ep = &sm->directory_vector[STAT_COUNTER_NODE_NAMES];
 532       ep->data = sm->nodes;
 533
 534       /* Update names dictionary */
 535       vlib_node_t **nodes = node_dups[0];
 536       int i;
 537       for (i = 0; i < vec_len (nodes); i++)
 538         {
 539           vlib_node_t *n = nodes[i];
 540           u8 *s = 0;
 541           s = format (s, "%v%c", n->name, 0);
 542           if (sm->nodes[n->index])
 543             vec_free (sm->nodes[n->index]);
 544           sm->nodes[n->index] = s;
 545         }
 546       vlib_stat_segment_unlock ();
 547       clib_mem_set_heap (oldheap);
 548       no_max_nodes = l;
 549     }
 550
 551   for (j = 0; j < vec_len (node_dups); j++)
 552     {
 553       vlib_node_t **nodes = node_dups[j];
 554
 555       for (i = 0; i < vec_len (nodes); i++)
 556         {
 557           counter_t **counters;
 558           counter_t *c;
 559           vlib_node_t *n = nodes[i];
 560
 561           counters = sm->directory_vector[STAT_COUNTER_NODE_CLOCKS].data;
 562           c = counters[j];
 563           c[n->index] = n->stats_total.clocks - n->stats_last_clear.clocks;
 564
 565           counters = sm->directory_vector[STAT_COUNTER_NODE_VECTORS].data;
 566           c = counters[j];
 567           c[n->index] = n->stats_total.vectors - n->stats_last_clear.vectors;
 568
 569           counters = sm->directory_vector[STAT_COUNTER_NODE_CALLS].data;
 570           c = counters[j];
 571           c[n->index] = n->stats_total.calls - n->stats_last_clear.calls;
 572
 573           counters = sm->directory_vector[STAT_COUNTER_NODE_SUSPENDS].data;
 574           c = counters[j];
 575           c[n->index] =
 576             n->stats_total.suspends - n->stats_last_clear.suspends;
 577         }
 578       vec_free (node_dups[j]);
 579     }
 580   vec_free (node_dups);
 581   vec_free (stat_vms);
 582 }
 583
 584 static void
 585 do_stat_segment_updates (stat_segment_main_t * sm)
 586 {
 587   vlib_main_t *vm = vlib_mains[0];
 588   f64 vector_rate;
 589   u64 input_packets;
 590   f64 dt, now;
 591   vlib_main_t *this_vlib_main;
 592   int i;
 593   static int num_worker_threads_set;
 594
 595   /*
 596    * Set once at the beginning of time.
 597    * Can't do this from the init routine, which happens before
 598    * start_workers sets up vlib_mains...
 599    */
 600   if (PREDICT_FALSE (num_worker_threads_set == 0))
 601     {
 602       void *oldheap = clib_mem_set_heap (sm->heap);
 603       vlib_stat_segment_lock ();
 604
 605       stat_validate_counter_vector (&sm->directory_vector
 606                                     [STAT_COUNTER_VECTOR_RATE_PER_WORKER], 0);
 607       num_worker_threads_set = 1;
 608       vlib_stat_segment_unlock ();
 609       clib_mem_set_heap (oldheap);
 610     }
 611
 612   /*
 613    * Compute per-worker vector rates, and the average vector rate
 614    * across all workers
 615    */
 616   vector_rate = 0.0;
 617
 618   for (i = 0; i < vec_len (vlib_mains); i++)
 619     {
 620
 621       f64 this_vector_rate;
 622
 623       this_vlib_main = vlib_mains[i];
 624
 625       this_vector_rate = vlib_internal_node_vector_rate (this_vlib_main);
 626       vlib_clear_internal_node_vector_rate (this_vlib_main);
 627
 628       vector_rate += this_vector_rate;
 629
 630       /* Set the per-worker rate */
 631       stat_set_simple_counter (&sm->directory_vector
 632                                [STAT_COUNTER_VECTOR_RATE_PER_WORKER], i, 0,
 633                                this_vector_rate);
 634     }
 635
 636   /* And set the system average rate */
 637   vector_rate /= (f64) (i > 1 ? i - 1 : 1);
 638
 639   sm->directory_vector[STAT_COUNTER_VECTOR_RATE].value = vector_rate;
 640
 641   /*
 642    * Compute the aggregate input rate
 643    */
 644   now = vlib_time_now (vm);
 645   dt = now - sm->directory_vector[STAT_COUNTER_LAST_UPDATE].value;
 646   input_packets = vnet_get_aggregate_rx_packets ();
 647   sm->directory_vector[STAT_COUNTER_INPUT_RATE].value =
 648     (f64) (input_packets - sm->last_input_packets) / dt;
 649   sm->directory_vector[STAT_COUNTER_LAST_UPDATE].value = now;
 650   sm->last_input_packets = input_packets;
 651   sm->directory_vector[STAT_COUNTER_LAST_STATS_CLEAR].value =
 652     vm->node_main.time_last_runtime_stats_clear;
 653
 654   /* Stats segment memory heap counter */
 655   clib_mem_usage_t usage;
 656   mheap_usage (sm->heap, &usage);
 657   sm->directory_vector[STAT_COUNTER_MEM_STATSEG_USED].value =
 658     usage.bytes_used;
 659
 660   if (sm->node_counters_enabled)
 661     update_node_counters (sm);
 662
 663   /* *INDENT-OFF* */
 664   stat_segment_gauges_pool_t *g;
 665   pool_foreach(g, sm->gauges,
 666   ({
 667     g->fn(&sm->directory_vector[g->directory_index], g->caller_index);
 668   }));
 669   /* *INDENT-ON* */
 670
 671   /* Heartbeat, so clients detect we're still here */
 672   sm->directory_vector[STAT_COUNTER_HEARTBEAT].value++;
 673 }
 674
 675 /*
 676  * Accept connection on the socket and exchange the fd for the shared
 677  * memory segment.
 678  */
 679 static clib_error_t *
 680 stats_socket_accept_ready (clib_file_t * uf)
 681 {
 682   stat_segment_main_t *sm = &stat_segment_main;
 683   clib_error_t *err;
 684   clib_socket_t client = { 0 };
 685
 686   err = clib_socket_accept (sm->socket, &client);
 687   if (err)
 688     {
 689       clib_error_report (err);
 690       return err;
 691     }
 692
 693   /* Send the fd across and close */
 694   err = clib_socket_sendmsg (&client, 0, 0, &sm->memfd, 1);
 695   if (err)
 696     clib_error_report (err);
 697   clib_socket_close (&client);
 698
 699   return 0;
 700 }
 701
 702 static clib_error_t *
 703 stats_segment_socket_init (void)
 704 {
 705   stat_segment_main_t *sm = &stat_segment_main;
 706   clib_error_t *error;
 707   clib_socket_t *s = clib_mem_alloc (sizeof (clib_socket_t));
 708
 709   memset (s, 0, sizeof (clib_socket_t));
 710   s->config = (char *) sm->socket_name;
 711   s->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_SEQPACKET |
 712     CLIB_SOCKET_F_ALLOW_GROUP_WRITE | CLIB_SOCKET_F_PASSCRED;
 713
 714   if ((error = clib_socket_init (s)))
 715     return error;
 716
 717   clib_file_t template = { 0 };
 718   template.read_function = stats_socket_accept_ready;
 719   template.file_descriptor = s->fd;
 720   template.description = format (0, "stats segment listener %s", s->config);
 721   clib_file_add (&file_main, &template);
 722
 723   sm->socket = s;
 724
 725   return 0;
 726 }
 727
 728 static clib_error_t *
 729 stats_segment_socket_exit (vlib_main_t * vm)
 730 {
 731   /*
 732    * cleanup the listener socket on exit.
 733    */
 734   stat_segment_main_t *sm = &stat_segment_main;
 735   unlink ((char *) sm->socket_name);
 736   return 0;
 737 }
 738
 739 VLIB_MAIN_LOOP_EXIT_FUNCTION (stats_segment_socket_exit);
 740
 741 /* Overrides weak reference in vlib:node_cli.c */
 742 f64
 743 vlib_get_stat_segment_update_rate (void)
 744 {
 745   return stat_segment_main.update_interval;
 746 }
 747
 748 static uword
 749 stat_segment_collector_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
 750                                 vlib_frame_t * f)
 751 {
 752   stat_segment_main_t *sm = &stat_segment_main;
 753
 754   while (1)
 755     {
 756       do_stat_segment_updates (sm);
 757       vlib_process_suspend (vm, sm->update_interval);
 758     }
 759   return 0;                     /* or not */
 760 }
 761
 762 static clib_error_t *
 763 statseg_init (vlib_main_t * vm)
 764 {
 765   stat_segment_main_t *sm = &stat_segment_main;
 766
 767   /* set default socket file name when statseg config stanza is empty. */
 768   if (!vec_len (sm->socket_name))
 769     sm->socket_name = format (0, "%s/%s%c", vlib_unix_get_runtime_dir (),
 770                               STAT_SEGMENT_SOCKET_FILENAME, 0);
 771   return stats_segment_socket_init ();
 772 }
 773
 774 /* *INDENT-OFF* */
 775 VLIB_INIT_FUNCTION (statseg_init) =
 776 {
 777   .runs_after = VLIB_INITS("unix_input_init"),
 778 };
 779 /* *INDENT-ON* */
 780
 781 clib_error_t *
 782 stat_segment_register_gauge (u8 * name, stat_segment_update_fn update_fn,
 783                              u32 caller_index)
 784 {
 785   stat_segment_main_t *sm = &stat_segment_main;
 786   stat_segment_shared_header_t *shared_header = sm->shared_header;
 787   void *oldheap;
 788   stat_segment_directory_entry_t e;
 789   stat_segment_gauges_pool_t *gauge;
 790
 791   ASSERT (shared_header);
 792
 793   u32 vector_index = lookup_hash_index (name);
 794
 795   if (vector_index != STAT_SEGMENT_INDEX_INVALID)       /* Already registered */
 796     return clib_error_return (0, "%v is already registered", name);
 797
 798   memset (&e, 0, sizeof (e));
 799   e.type = STAT_DIR_TYPE_SCALAR_INDEX;
 800   memcpy (e.name, name, vec_len (name));
 801
 802   oldheap = vlib_stats_push_heap (NULL);
 803   vlib_stat_segment_lock ();
 804   vector_index = vlib_stats_create_counter (&e, oldheap);
 805
 806   shared_header->directory_vector = sm->directory_vector;
 807
 808   vlib_stat_segment_unlock ();
 809   clib_mem_set_heap (oldheap);
 810
 811   /* Back on our own heap */
 812   pool_get (sm->gauges, gauge);
 813   gauge->fn = update_fn;
 814   gauge->caller_index = caller_index;
 815   gauge->directory_index = vector_index;
 816
 817   return NULL;
 818 }
 819
 820 clib_error_t *
 821 stat_segment_register_state_counter (u8 * name, u32 * index)
 822 {
 823   stat_segment_main_t *sm = &stat_segment_main;
 824   stat_segment_shared_header_t *shared_header = sm->shared_header;
 825   void *oldheap;
 826   stat_segment_directory_entry_t e;
 827
 828   ASSERT (shared_header);
 829   ASSERT (vlib_get_thread_index () == 0);
 830
 831   u32 vector_index = lookup_hash_index (name);
 832
 833   if (vector_index != STAT_SEGMENT_INDEX_INVALID)       /* Already registered */
 834     return clib_error_return (0, "%v is already registered", name);
 835
 836   memset (&e, 0, sizeof (e));
 837   e.type = STAT_DIR_TYPE_SCALAR_INDEX;
 838   memcpy (e.name, name, vec_len (name));
 839
 840   oldheap = vlib_stats_push_heap (NULL);
 841   vlib_stat_segment_lock ();
 842
 843   vector_index = vlib_stats_create_counter (&e, oldheap);
 844
 845   shared_header->directory_vector = sm->directory_vector;
 846
 847   vlib_stat_segment_unlock ();
 848   clib_mem_set_heap (oldheap);
 849
 850   *index = vector_index;
 851   return 0;
 852 }
 853
 854 clib_error_t *
 855 stat_segment_deregister_state_counter (u32 index)
 856 {
 857   stat_segment_main_t *sm = &stat_segment_main;
 858   stat_segment_shared_header_t *shared_header = sm->shared_header;
 859   stat_segment_directory_entry_t *e;
 860   void *oldheap;
 861
 862   ASSERT (shared_header);
 863
 864   if (index > vec_len (sm->directory_vector))
 865     return clib_error_return (0, "%u index does not exist", index);
 866
 867   e = &sm->directory_vector[index];
 868   if (e->type != STAT_DIR_TYPE_SCALAR_INDEX)
 869     return clib_error_return (0, "%u index cannot be deleted", index);
 870
 871   oldheap = vlib_stats_push_heap (NULL);
 872   vlib_stat_segment_lock ();
 873
 874   vlib_stats_delete_counter (index, oldheap);
 875
 876   vlib_stat_segment_unlock ();
 877   clib_mem_set_heap (oldheap);
 878
 879   return 0;
 880 }
 881
 882 void
 883 stat_segment_set_state_counter (u32 index, u64 value)
 884 {
 885   stat_segment_main_t *sm = &stat_segment_main;
 886
 887   ASSERT (index < vec_len (sm->directory_vector));
 888   sm->directory_vector[index].index = value;
 889 }
 890
 891 static clib_error_t *
 892 statseg_config (vlib_main_t * vm, unformat_input_t * input)
 893 {
 894   stat_segment_main_t *sm = &stat_segment_main;
 895   sm->update_interval = 10.0;
 896
 897   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 898     {
 899       if (unformat (input, "socket-name %s", &sm->socket_name))
 900         ;
 901       /* DEPRECATE: default (does nothing) */
 902       else if (unformat (input, "default"))
 903         ;
 904       else if (unformat (input, "size %U",
 905                          unformat_memory_size, &sm->memory_size))
 906         ;
 907       else if (unformat (input, "per-node-counters on"))
 908         sm->node_counters_enabled = 1;
 909       else if (unformat (input, "per-node-counters off"))
 910         sm->node_counters_enabled = 0;
 911       else if (unformat (input, "update-interval %f", &sm->update_interval))
 912         ;
 913       else
 914         return clib_error_return (0, "unknown input `%U'",
 915                                   format_unformat_error, input);
 916     }
 917
 918   /*
 919    * NULL-terminate socket name string
 920    * clib_socket_init()->socket_config() use C str*
 921    */
 922   if (vec_len (sm->socket_name))
 923     vec_terminate_c_string (sm->socket_name);
 924
 925   return 0;
 926 }
 927
 928 VLIB_EARLY_CONFIG_FUNCTION (statseg_config, "statseg");
 929
 930 static clib_error_t *
 931 statseg_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
 932 {
 933   stat_segment_main_t *sm = &stat_segment_main;
 934
 935   void *oldheap = vlib_stats_push_heap (sm->interfaces);
 936   vlib_stat_segment_lock ();
 937
 938   vec_validate (sm->interfaces, sw_if_index);
 939   if (is_add)
 940     {
 941       vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
 942       vnet_sw_interface_t *si_sup =
 943         vnet_get_sup_sw_interface (vnm, si->sw_if_index);
 944       vnet_hw_interface_t *hi_sup;
 945
 946       ASSERT (si_sup->type == VNET_SW_INTERFACE_TYPE_HARDWARE);
 947       hi_sup = vnet_get_hw_interface (vnm, si_sup->hw_if_index);
 948
 949       u8 *s = 0;
 950       s = format (s, "%v", hi_sup->name);
 951       if (si->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
 952         s = format (s, ".%d", si->sub.id);
 953       s = format (s, "%c", 0);
 954       sm->interfaces[sw_if_index] = s;
 955     }
 956   else
 957     {
 958       vec_free (sm->interfaces[sw_if_index]);
 959       sm->interfaces[sw_if_index] = 0;
 960     }
 961
 962   stat_segment_directory_entry_t *ep;
 963   ep = &sm->directory_vector[STAT_COUNTER_INTERFACE_NAMES];
 964   ep->data = sm->interfaces;
 965
 966   vlib_stat_segment_unlock ();
 967   clib_mem_set_heap (oldheap);
 968
 969   return 0;
 970 }
 971
 972 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (statseg_sw_interface_add_del);
 973
 974 /* *INDENT-OFF* */
 975 VLIB_REGISTER_NODE (stat_segment_collector, static) =
 976 {
 977 .function = stat_segment_collector_process,
 978 .name = "statseg-collector-process",
 979 .type = VLIB_NODE_TYPE_PROCESS,
 980 };
 981
 982 /* *INDENT-ON* */
 983
 984 /*
 985  * fd.io coding-style-patch-verification: ON
 986  *
 987  * Local Variables:
 988  * eval: (c-set-style "gnu")
 989  * End:
 990  */