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