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