src/vlib/main.c

   1 /*
   2  * Copyright (c) 2015 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  * main.c: main vector processing loop
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <math.h>
  41 #include <vppinfra/format.h>
  42 #include <vlib/vlib.h>
  43 #include <vlib/threads.h>
  44 #include <vlib/stats/stats.h>
  45 #include <vppinfra/tw_timer_1t_3w_1024sl_ov.h>
  46
  47 #include <vlib/unix/unix.h>
  48
  49 #define VLIB_FRAME_MAGIC (0xabadc0ed)
  50
  51 always_inline u32 *
  52 vlib_frame_find_magic (vlib_frame_t * f, vlib_node_t * node)
  53 {
  54   return (void *) f + node->magic_offset;
  55 }
  56
  57 static vlib_frame_t *
  58 vlib_frame_alloc_to_node (vlib_main_t * vm, u32 to_node_index,
  59                           u32 frame_flags)
  60 {
  61   vlib_node_main_t *nm = &vm->node_main;
  62   vlib_frame_size_t *fs;
  63   vlib_node_t *to_node;
  64   vlib_frame_t *f;
  65   u32 l, n;
  66
  67   ASSERT (vm == vlib_get_main ());
  68
  69   to_node = vlib_get_node (vm, to_node_index);
  70
  71   vec_validate (nm->frame_sizes, to_node->frame_size_index);
  72   fs = vec_elt_at_index (nm->frame_sizes, to_node->frame_size_index);
  73
  74   if (fs->frame_size == 0)
  75     fs->frame_size = to_node->frame_size;
  76   else
  77     ASSERT (fs->frame_size == to_node->frame_size);
  78
  79   n = fs->frame_size;
  80   if ((l = vec_len (fs->free_frames)) > 0)
  81     {
  82       /* Allocate from end of free list. */
  83       f = fs->free_frames[l - 1];
  84       vec_set_len (fs->free_frames, l - 1);
  85     }
  86   else
  87     {
  88       f = clib_mem_alloc_aligned_no_fail (n, CLIB_CACHE_LINE_BYTES);
  89     }
  90
  91   /* Poison frame when debugging. */
  92   if (CLIB_DEBUG > 0)
  93     clib_memset_u8 (f, 0xfe, n);
  94
  95   /* Insert magic number. */
  96   {
  97     u32 *magic;
  98
  99     magic = vlib_frame_find_magic (f, to_node);
 100     *magic = VLIB_FRAME_MAGIC;
 101   }
 102
 103   f->frame_flags = VLIB_FRAME_IS_ALLOCATED | frame_flags;
 104   f->n_vectors = 0;
 105   f->scalar_offset = to_node->scalar_offset;
 106   f->vector_offset = to_node->vector_offset;
 107   f->aux_offset = to_node->aux_offset;
 108   f->flags = 0;
 109   f->frame_size_index = to_node->frame_size_index;
 110
 111   fs->n_alloc_frames += 1;
 112
 113   return f;
 114 }
 115
 116 /* Allocate a frame for from FROM_NODE to TO_NODE via TO_NEXT_INDEX.
 117    Returns frame index. */
 118 static vlib_frame_t *
 119 vlib_frame_alloc (vlib_main_t * vm, vlib_node_runtime_t * from_node_runtime,
 120                   u32 to_next_index)
 121 {
 122   vlib_node_t *from_node;
 123
 124   from_node = vlib_get_node (vm, from_node_runtime->node_index);
 125   ASSERT (to_next_index < vec_len (from_node->next_nodes));
 126
 127   return vlib_frame_alloc_to_node (vm, from_node->next_nodes[to_next_index],
 128                                    /* frame_flags */ 0);
 129 }
 130
 131 vlib_frame_t *
 132 vlib_get_frame_to_node (vlib_main_t * vm, u32 to_node_index)
 133 {
 134   vlib_frame_t *f = vlib_frame_alloc_to_node (vm, to_node_index,
 135                                               /* frame_flags */
 136                                               VLIB_FRAME_FREE_AFTER_DISPATCH);
 137   return vlib_get_frame (vm, f);
 138 }
 139
 140 static inline void
 141 vlib_validate_frame_indices (vlib_frame_t * f)
 142 {
 143   if (CLIB_DEBUG > 0)
 144     {
 145       int i;
 146       u32 *from = vlib_frame_vector_args (f);
 147
 148       /* Check for bad buffer index values */
 149       for (i = 0; i < f->n_vectors; i++)
 150         {
 151           if (from[i] == 0)
 152             {
 153               clib_warning ("BUG: buffer index 0 at index %d", i);
 154               ASSERT (0);
 155             }
 156           else if (from[i] == 0xfefefefe)
 157             {
 158               clib_warning ("BUG: frame poison pattern at index %d", i);
 159               ASSERT (0);
 160             }
 161         }
 162     }
 163 }
 164
 165 void
 166 vlib_put_frame_to_node (vlib_main_t * vm, u32 to_node_index, vlib_frame_t * f)
 167 {
 168   vlib_pending_frame_t *p;
 169   vlib_node_t *to_node;
 170
 171   if (f->n_vectors == 0)
 172     return;
 173
 174   ASSERT (vm == vlib_get_main ());
 175
 176   vlib_validate_frame_indices (f);
 177
 178   to_node = vlib_get_node (vm, to_node_index);
 179
 180   vec_add2 (vm->node_main.pending_frames, p, 1);
 181
 182   f->frame_flags |= VLIB_FRAME_PENDING;
 183   p->frame = vlib_get_frame (vm, f);
 184   p->node_runtime_index = to_node->runtime_index;
 185   p->next_frame_index = VLIB_PENDING_FRAME_NO_NEXT_FRAME;
 186 }
 187
 188 /* Free given frame. */
 189 void
 190 vlib_frame_free (vlib_main_t *vm, vlib_frame_t *f)
 191 {
 192   vlib_node_main_t *nm = &vm->node_main;
 193   vlib_frame_size_t *fs;
 194
 195   ASSERT (vm == vlib_get_main ());
 196   ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
 197
 198   fs = vec_elt_at_index (nm->frame_sizes, f->frame_size_index);
 199
 200   ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
 201
 202   /* No next frames may point to freed frame. */
 203   if (CLIB_DEBUG > 0)
 204     {
 205       vlib_next_frame_t *nf;
 206       vec_foreach (nf, vm->node_main.next_frames) ASSERT (nf->frame != f);
 207     }
 208
 209   f->frame_flags &= ~(VLIB_FRAME_IS_ALLOCATED | VLIB_FRAME_NO_APPEND);
 210   f->flags = 0;
 211
 212   vec_add1 (fs->free_frames, f);
 213   ASSERT (fs->n_alloc_frames > 0);
 214   fs->n_alloc_frames -= 1;
 215 }
 216
 217 static clib_error_t *
 218 show_frame_stats (vlib_main_t * vm,
 219                   unformat_input_t * input, vlib_cli_command_t * cmd)
 220 {
 221   vlib_frame_size_t *fs;
 222
 223   vlib_cli_output (vm, "%=8s%=6s%=12s%=12s", "Thread", "Size", "# Alloc",
 224                    "# Free");
 225   foreach_vlib_main ()
 226     {
 227       vlib_node_main_t *nm = &this_vlib_main->node_main;
 228       vec_foreach (fs, nm->frame_sizes)
 229         {
 230           u32 n_alloc = fs->n_alloc_frames;
 231           u32 n_free = vec_len (fs->free_frames);
 232
 233           if (n_alloc + n_free > 0)
 234             vlib_cli_output (vm, "%=8d%=6d%=12d%=12d",
 235                              this_vlib_main->thread_index, fs->frame_size,
 236                              n_alloc, n_free);
 237         }
 238     }
 239
 240   return 0;
 241 }
 242
 243 /* *INDENT-OFF* */
 244 VLIB_CLI_COMMAND (show_frame_stats_cli, static) = {
 245   .path = "show vlib frame-allocation",
 246   .short_help = "Show node dispatch frame statistics",
 247   .function = show_frame_stats,
 248 };
 249 /* *INDENT-ON* */
 250
 251 /* Change ownership of enqueue rights to given next node. */
 252 static void
 253 vlib_next_frame_change_ownership (vlib_main_t * vm,
 254                                   vlib_node_runtime_t * node_runtime,
 255                                   u32 next_index)
 256 {
 257   vlib_node_main_t *nm = &vm->node_main;
 258   vlib_next_frame_t *next_frame;
 259   vlib_node_t *node, *next_node;
 260
 261   node = vec_elt (nm->nodes, node_runtime->node_index);
 262
 263   /* Only internal & input nodes are allowed to call other nodes. */
 264   ASSERT (node->type == VLIB_NODE_TYPE_INTERNAL
 265           || node->type == VLIB_NODE_TYPE_INPUT
 266           || node->type == VLIB_NODE_TYPE_PROCESS);
 267
 268   ASSERT (vec_len (node->next_nodes) == node_runtime->n_next_nodes);
 269
 270   next_frame =
 271     vlib_node_runtime_get_next_frame (vm, node_runtime, next_index);
 272   next_node = vec_elt (nm->nodes, node->next_nodes[next_index]);
 273
 274   if (next_node->owner_node_index != VLIB_INVALID_NODE_INDEX)
 275     {
 276       /* Get frame from previous owner. */
 277       vlib_next_frame_t *owner_next_frame;
 278       vlib_next_frame_t tmp;
 279
 280       owner_next_frame =
 281         vlib_node_get_next_frame (vm,
 282                                   next_node->owner_node_index,
 283                                   next_node->owner_next_index);
 284
 285       /* Swap target next frame with owner's. */
 286       tmp = owner_next_frame[0];
 287       owner_next_frame[0] = next_frame[0];
 288       next_frame[0] = tmp;
 289
 290       /*
 291        * If next_frame is already pending, we have to track down
 292        * all pending frames and fix their next_frame_index fields.
 293        */
 294       if (next_frame->flags & VLIB_FRAME_PENDING)
 295         {
 296           vlib_pending_frame_t *p;
 297           if (next_frame->frame != NULL)
 298             {
 299               vec_foreach (p, nm->pending_frames)
 300               {
 301                 if (p->frame == next_frame->frame)
 302                   {
 303                     p->next_frame_index =
 304                       next_frame - vm->node_main.next_frames;
 305                   }
 306               }
 307             }
 308         }
 309     }
 310   else
 311     {
 312       /* No previous owner. Take ownership. */
 313       next_frame->flags |= VLIB_FRAME_OWNER;
 314     }
 315
 316   /* Record new owner. */
 317   next_node->owner_node_index = node->index;
 318   next_node->owner_next_index = next_index;
 319
 320   /* Now we should be owner. */
 321   ASSERT (next_frame->flags & VLIB_FRAME_OWNER);
 322 }
 323
 324 /* Make sure that magic number is still there.
 325    Otherwise, it is likely that caller has overrun frame arguments. */
 326 always_inline void
 327 validate_frame_magic (vlib_main_t * vm,
 328                       vlib_frame_t * f, vlib_node_t * n, uword next_index)
 329 {
 330   vlib_node_t *next_node = vlib_get_node (vm, n->next_nodes[next_index]);
 331   u32 *magic = vlib_frame_find_magic (f, next_node);
 332   ASSERT (VLIB_FRAME_MAGIC == magic[0]);
 333 }
 334
 335 vlib_frame_t *
 336 vlib_get_next_frame_internal (vlib_main_t * vm,
 337                               vlib_node_runtime_t * node,
 338                               u32 next_index, u32 allocate_new_next_frame)
 339 {
 340   vlib_frame_t *f;
 341   vlib_next_frame_t *nf;
 342   u32 n_used;
 343
 344   nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
 345
 346   /* Make sure this next frame owns right to enqueue to destination frame. */
 347   if (PREDICT_FALSE (!(nf->flags & VLIB_FRAME_OWNER)))
 348     vlib_next_frame_change_ownership (vm, node, next_index);
 349
 350   /* ??? Don't need valid flag: can use frame_index == ~0 */
 351   if (PREDICT_FALSE (!(nf->flags & VLIB_FRAME_IS_ALLOCATED)))
 352     {
 353       nf->frame = vlib_frame_alloc (vm, node, next_index);
 354       nf->flags |= VLIB_FRAME_IS_ALLOCATED;
 355     }
 356
 357   f = nf->frame;
 358
 359   /* Has frame been removed from pending vector (e.g. finished dispatching)?
 360      If so we can reuse frame. */
 361   if ((nf->flags & VLIB_FRAME_PENDING)
 362       && !(f->frame_flags & VLIB_FRAME_PENDING))
 363     {
 364       nf->flags &= ~VLIB_FRAME_PENDING;
 365       f->n_vectors = 0;
 366       f->flags = 0;
 367     }
 368
 369   /* Allocate new frame if current one is marked as no-append or
 370      it is already full. */
 371   n_used = f->n_vectors;
 372   if (n_used >= VLIB_FRAME_SIZE || (allocate_new_next_frame && n_used > 0) ||
 373       (f->frame_flags & VLIB_FRAME_NO_APPEND))
 374     {
 375       /* Old frame may need to be freed after dispatch, since we'll have
 376          two redundant frames from node -> next node. */
 377       if (!(nf->flags & VLIB_FRAME_NO_FREE_AFTER_DISPATCH))
 378         {
 379           vlib_frame_t *f_old = vlib_get_frame (vm, nf->frame);
 380           f_old->frame_flags |= VLIB_FRAME_FREE_AFTER_DISPATCH;
 381         }
 382
 383       /* Allocate new frame to replace full one. */
 384       f = nf->frame = vlib_frame_alloc (vm, node, next_index);
 385       n_used = f->n_vectors;
 386     }
 387
 388   /* Should have free vectors in frame now. */
 389   ASSERT (n_used < VLIB_FRAME_SIZE);
 390
 391   if (CLIB_DEBUG > 0)
 392     {
 393       validate_frame_magic (vm, f,
 394                             vlib_get_node (vm, node->node_index), next_index);
 395     }
 396
 397   return f;
 398 }
 399
 400 static void
 401 vlib_put_next_frame_validate (vlib_main_t * vm,
 402                               vlib_node_runtime_t * rt,
 403                               u32 next_index, u32 n_vectors_left)
 404 {
 405   vlib_node_main_t *nm = &vm->node_main;
 406   vlib_next_frame_t *nf;
 407   vlib_frame_t *f;
 408   vlib_node_runtime_t *next_rt;
 409   vlib_node_t *next_node;
 410   u32 n_before, n_after;
 411
 412   nf = vlib_node_runtime_get_next_frame (vm, rt, next_index);
 413   f = vlib_get_frame (vm, nf->frame);
 414
 415   ASSERT (n_vectors_left <= VLIB_FRAME_SIZE);
 416
 417   vlib_validate_frame_indices (f);
 418
 419   n_after = VLIB_FRAME_SIZE - n_vectors_left;
 420   n_before = f->n_vectors;
 421
 422   ASSERT (n_after >= n_before);
 423
 424   next_rt = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INTERNAL],
 425                               nf->node_runtime_index);
 426   next_node = vlib_get_node (vm, next_rt->node_index);
 427   if (n_after > 0 && next_node->validate_frame)
 428     {
 429       u8 *msg = next_node->validate_frame (vm, rt, f);
 430       if (msg)
 431         {
 432           clib_warning ("%v", msg);
 433           ASSERT (0);
 434         }
 435       vec_free (msg);
 436     }
 437 }
 438
 439 void
 440 vlib_put_next_frame (vlib_main_t * vm,
 441                      vlib_node_runtime_t * r,
 442                      u32 next_index, u32 n_vectors_left)
 443 {
 444   vlib_node_main_t *nm = &vm->node_main;
 445   vlib_next_frame_t *nf;
 446   vlib_frame_t *f;
 447   u32 n_vectors_in_frame;
 448
 449   if (CLIB_DEBUG > 0)
 450     vlib_put_next_frame_validate (vm, r, next_index, n_vectors_left);
 451
 452   nf = vlib_node_runtime_get_next_frame (vm, r, next_index);
 453   f = vlib_get_frame (vm, nf->frame);
 454
 455   /* Make sure that magic number is still there.  Otherwise, caller
 456      has overrun frame meta data. */
 457   if (CLIB_DEBUG > 0)
 458     {
 459       vlib_node_t *node = vlib_get_node (vm, r->node_index);
 460       validate_frame_magic (vm, f, node, next_index);
 461     }
 462
 463   /* Convert # of vectors left -> number of vectors there. */
 464   ASSERT (n_vectors_left <= VLIB_FRAME_SIZE);
 465   n_vectors_in_frame = VLIB_FRAME_SIZE - n_vectors_left;
 466
 467   f->n_vectors = n_vectors_in_frame;
 468
 469   /* If vectors were added to frame, add to pending vector. */
 470   if (PREDICT_TRUE (n_vectors_in_frame > 0))
 471     {
 472       vlib_pending_frame_t *p;
 473       u32 v0, v1;
 474
 475       r->cached_next_index = next_index;
 476
 477       if (!(f->frame_flags & VLIB_FRAME_PENDING))
 478         {
 479           __attribute__ ((unused)) vlib_node_t *node;
 480
 481           node = vlib_get_node (vm, r->node_index);
 482
 483           vec_add2 (nm->pending_frames, p, 1);
 484
 485           p->frame = nf->frame;
 486           p->node_runtime_index = nf->node_runtime_index;
 487           p->next_frame_index = nf - nm->next_frames;
 488           nf->flags |= VLIB_FRAME_PENDING;
 489           f->frame_flags |= VLIB_FRAME_PENDING;
 490         }
 491
 492       /* Copy trace flag from next_frame and from runtime. */
 493       nf->flags |=
 494         (nf->flags & VLIB_NODE_FLAG_TRACE) | (r->
 495                                               flags & VLIB_NODE_FLAG_TRACE);
 496
 497       v0 = nf->vectors_since_last_overflow;
 498       v1 = v0 + n_vectors_in_frame;
 499       nf->vectors_since_last_overflow = v1;
 500       if (PREDICT_FALSE (v1 < v0))
 501         {
 502           vlib_node_t *node = vlib_get_node (vm, r->node_index);
 503           vec_elt (node->n_vectors_by_next_node, next_index) += v0;
 504         }
 505     }
 506 }
 507
 508 /* Sync up runtime (32 bit counters) and main node stats (64 bit counters). */
 509 void
 510 vlib_node_runtime_sync_stats_node (vlib_node_t *n, vlib_node_runtime_t *r,
 511                                    uword n_calls, uword n_vectors,
 512                                    uword n_clocks)
 513 {
 514   n->stats_total.calls += n_calls + r->calls_since_last_overflow;
 515   n->stats_total.vectors += n_vectors + r->vectors_since_last_overflow;
 516   n->stats_total.clocks += n_clocks + r->clocks_since_last_overflow;
 517   n->stats_total.max_clock = r->max_clock;
 518   n->stats_total.max_clock_n = r->max_clock_n;
 519
 520   r->calls_since_last_overflow = 0;
 521   r->vectors_since_last_overflow = 0;
 522   r->clocks_since_last_overflow = 0;
 523 }
 524
 525 void
 526 vlib_node_runtime_sync_stats (vlib_main_t *vm, vlib_node_runtime_t *r,
 527                               uword n_calls, uword n_vectors, uword n_clocks)
 528 {
 529   vlib_node_t *n = vlib_get_node (vm, r->node_index);
 530   vlib_node_runtime_sync_stats_node (n, r, n_calls, n_vectors, n_clocks);
 531 }
 532
 533 always_inline void __attribute__ ((unused))
 534 vlib_process_sync_stats (vlib_main_t * vm,
 535                          vlib_process_t * p,
 536                          uword n_calls, uword n_vectors, uword n_clocks)
 537 {
 538   vlib_node_runtime_t *rt = &p->node_runtime;
 539   vlib_node_t *n = vlib_get_node (vm, rt->node_index);
 540   vlib_node_runtime_sync_stats (vm, rt, n_calls, n_vectors, n_clocks);
 541   n->stats_total.suspends += p->n_suspends;
 542   p->n_suspends = 0;
 543 }
 544
 545 void
 546 vlib_node_sync_stats (vlib_main_t * vm, vlib_node_t * n)
 547 {
 548   vlib_node_runtime_t *rt;
 549
 550   if (n->type == VLIB_NODE_TYPE_PROCESS)
 551     {
 552       /* Nothing to do for PROCESS nodes except in main thread */
 553       if (vm != vlib_get_first_main ())
 554         return;
 555
 556       vlib_process_t *p = vlib_get_process_from_node (vm, n);
 557       n->stats_total.suspends += p->n_suspends;
 558       p->n_suspends = 0;
 559       rt = &p->node_runtime;
 560     }
 561   else
 562     rt =
 563       vec_elt_at_index (vm->node_main.nodes_by_type[n->type],
 564                         n->runtime_index);
 565
 566   vlib_node_runtime_sync_stats (vm, rt, 0, 0, 0);
 567
 568   /* Sync up runtime next frame vector counters with main node structure. */
 569   {
 570     vlib_next_frame_t *nf;
 571     uword i;
 572     for (i = 0; i < rt->n_next_nodes; i++)
 573       {
 574         nf = vlib_node_runtime_get_next_frame (vm, rt, i);
 575         vec_elt (n->n_vectors_by_next_node, i) +=
 576           nf->vectors_since_last_overflow;
 577         nf->vectors_since_last_overflow = 0;
 578       }
 579   }
 580 }
 581
 582 always_inline u32
 583 vlib_node_runtime_update_stats (vlib_main_t * vm,
 584                                 vlib_node_runtime_t * node,
 585                                 uword n_calls,
 586                                 uword n_vectors, uword n_clocks)
 587 {
 588   u32 ca0, ca1, v0, v1, cl0, cl1, r;
 589
 590   cl0 = cl1 = node->clocks_since_last_overflow;
 591   ca0 = ca1 = node->calls_since_last_overflow;
 592   v0 = v1 = node->vectors_since_last_overflow;
 593
 594   ca1 = ca0 + n_calls;
 595   v1 = v0 + n_vectors;
 596   cl1 = cl0 + n_clocks;
 597
 598   node->calls_since_last_overflow = ca1;
 599   node->clocks_since_last_overflow = cl1;
 600   node->vectors_since_last_overflow = v1;
 601
 602   node->max_clock_n = node->max_clock > n_clocks ?
 603     node->max_clock_n : n_vectors;
 604   node->max_clock = node->max_clock > n_clocks ? node->max_clock : n_clocks;
 605
 606   r = vlib_node_runtime_update_main_loop_vector_stats (vm, node, n_vectors);
 607
 608   if (PREDICT_FALSE (ca1 < ca0 || v1 < v0 || cl1 < cl0))
 609     {
 610       node->calls_since_last_overflow = ca0;
 611       node->clocks_since_last_overflow = cl0;
 612       node->vectors_since_last_overflow = v0;
 613
 614       vlib_node_runtime_sync_stats (vm, node, n_calls, n_vectors, n_clocks);
 615     }
 616
 617   return r;
 618 }
 619
 620 always_inline void
 621 vlib_process_update_stats (vlib_main_t * vm,
 622                            vlib_process_t * p,
 623                            uword n_calls, uword n_vectors, uword n_clocks)
 624 {
 625   vlib_node_runtime_update_stats (vm, &p->node_runtime,
 626                                   n_calls, n_vectors, n_clocks);
 627 }
 628
 629 static clib_error_t *
 630 vlib_cli_elog_clear (vlib_main_t * vm,
 631                      unformat_input_t * input, vlib_cli_command_t * cmd)
 632 {
 633   elog_reset_buffer (&vlib_global_main.elog_main);
 634   return 0;
 635 }
 636
 637 /* *INDENT-OFF* */
 638 VLIB_CLI_COMMAND (elog_clear_cli, static) = {
 639   .path = "event-logger clear",
 640   .short_help = "Clear the event log",
 641   .function = vlib_cli_elog_clear,
 642 };
 643 /* *INDENT-ON* */
 644
 645 #ifdef CLIB_UNIX
 646 static clib_error_t *
 647 elog_save_buffer (vlib_main_t * vm,
 648                   unformat_input_t * input, vlib_cli_command_t * cmd)
 649 {
 650   elog_main_t *em = &vlib_global_main.elog_main;
 651   char *file, *chroot_file;
 652   clib_error_t *error = 0;
 653
 654   if (!unformat (input, "%s", &file))
 655     {
 656       vlib_cli_output (vm, "expected file name, got `%U'",
 657                        format_unformat_error, input);
 658       return 0;
 659     }
 660
 661   /* It's fairly hard to get "../oopsie" through unformat; just in case */
 662   if (strstr (file, "..") || index (file, '/'))
 663     {
 664       vlib_cli_output (vm, "illegal characters in filename '%s'", file);
 665       return 0;
 666     }
 667
 668   chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
 669
 670   vec_free (file);
 671
 672   vlib_cli_output (vm, "Saving %wd of %wd events to %s",
 673                    elog_n_events_in_buffer (em),
 674                    elog_buffer_capacity (em), chroot_file);
 675
 676   vlib_worker_thread_barrier_sync (vm);
 677   error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
 678   vlib_worker_thread_barrier_release (vm);
 679   vec_free (chroot_file);
 680   return error;
 681 }
 682
 683 void
 684 vlib_post_mortem_dump (void)
 685 {
 686   vlib_global_main_t *vgm = vlib_get_global_main ();
 687
 688   for (int i = 0; i < vec_len (vgm->post_mortem_callbacks); i++)
 689     (vgm->post_mortem_callbacks[i]) ();
 690 }
 691
 692 /* *INDENT-OFF* */
 693 VLIB_CLI_COMMAND (elog_save_cli, static) = {
 694   .path = "event-logger save",
 695   .short_help = "event-logger save <filename> (saves log in /tmp/<filename>)",
 696   .function = elog_save_buffer,
 697 };
 698 /* *INDENT-ON* */
 699
 700 static clib_error_t *
 701 elog_stop (vlib_main_t * vm,
 702            unformat_input_t * input, vlib_cli_command_t * cmd)
 703 {
 704   elog_main_t *em = &vlib_global_main.elog_main;
 705
 706   em->n_total_events_disable_limit = em->n_total_events;
 707
 708   vlib_cli_output (vm, "Stopped the event logger...");
 709   return 0;
 710 }
 711
 712 /* *INDENT-OFF* */
 713 VLIB_CLI_COMMAND (elog_stop_cli, static) = {
 714   .path = "event-logger stop",
 715   .short_help = "Stop the event-logger",
 716   .function = elog_stop,
 717 };
 718 /* *INDENT-ON* */
 719
 720 static clib_error_t *
 721 elog_restart (vlib_main_t * vm,
 722               unformat_input_t * input, vlib_cli_command_t * cmd)
 723 {
 724   elog_main_t *em = &vlib_global_main.elog_main;
 725
 726   em->n_total_events_disable_limit = ~0;
 727
 728   vlib_cli_output (vm, "Restarted the event logger...");
 729   return 0;
 730 }
 731
 732 /* *INDENT-OFF* */
 733 VLIB_CLI_COMMAND (elog_restart_cli, static) = {
 734   .path = "event-logger restart",
 735   .short_help = "Restart the event-logger",
 736   .function = elog_restart,
 737 };
 738 /* *INDENT-ON* */
 739
 740 static clib_error_t *
 741 elog_resize_command_fn (vlib_main_t * vm,
 742                         unformat_input_t * input, vlib_cli_command_t * cmd)
 743 {
 744   elog_main_t *em = &vlib_global_main.elog_main;
 745   u32 tmp;
 746
 747   /* Stop the parade */
 748   elog_reset_buffer (em);
 749
 750   if (unformat (input, "%d", &tmp))
 751     {
 752       elog_alloc (em, tmp);
 753       em->n_total_events_disable_limit = ~0;
 754     }
 755   else
 756     return clib_error_return (0, "Must specify how many events in the ring");
 757
 758   vlib_cli_output (vm, "Resized ring and restarted the event logger...");
 759   return 0;
 760 }
 761
 762 /* *INDENT-OFF* */
 763 VLIB_CLI_COMMAND (elog_resize_cli, static) = {
 764   .path = "event-logger resize",
 765   .short_help = "event-logger resize <nnn>",
 766   .function = elog_resize_command_fn,
 767 };
 768 /* *INDENT-ON* */
 769
 770 #endif /* CLIB_UNIX */
 771
 772 static void
 773 elog_show_buffer_internal (vlib_main_t * vm, u32 n_events_to_show)
 774 {
 775   elog_main_t *em = &vlib_global_main.elog_main;
 776   elog_event_t *e, *es;
 777   f64 dt;
 778
 779   /* Show events in VLIB time since log clock starts after VLIB clock. */
 780   dt = (em->init_time.cpu - vm->clib_time.init_cpu_time)
 781     * vm->clib_time.seconds_per_clock;
 782
 783   es = elog_peek_events (em);
 784   vlib_cli_output (vm, "%d of %d events in buffer, logger %s", vec_len (es),
 785                    em->event_ring_size,
 786                    em->n_total_events < em->n_total_events_disable_limit ?
 787                    "running" : "stopped");
 788   vec_foreach (e, es)
 789   {
 790     vlib_cli_output (vm, "%18.9f: %U",
 791                      e->time + dt, format_elog_event, em, e);
 792     n_events_to_show--;
 793     if (n_events_to_show == 0)
 794       break;
 795   }
 796   vec_free (es);
 797
 798 }
 799
 800 static clib_error_t *
 801 elog_show_buffer (vlib_main_t * vm,
 802                   unformat_input_t * input, vlib_cli_command_t * cmd)
 803 {
 804   u32 n_events_to_show;
 805   clib_error_t *error = 0;
 806
 807   n_events_to_show = 250;
 808   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 809     {
 810       if (unformat (input, "%d", &n_events_to_show))
 811         ;
 812       else if (unformat (input, "all"))
 813         n_events_to_show = ~0;
 814       else
 815         return unformat_parse_error (input);
 816     }
 817   elog_show_buffer_internal (vm, n_events_to_show);
 818   return error;
 819 }
 820
 821 /* *INDENT-OFF* */
 822 VLIB_CLI_COMMAND (elog_show_cli, static) = {
 823   .path = "show event-logger",
 824   .short_help = "Show event logger info",
 825   .function = elog_show_buffer,
 826 };
 827 /* *INDENT-ON* */
 828
 829 void
 830 vlib_gdb_show_event_log (void)
 831 {
 832   elog_show_buffer_internal (vlib_get_main (), (u32) ~ 0);
 833 }
 834
 835 static inline void
 836 vlib_elog_main_loop_event (vlib_main_t * vm,
 837                            u32 node_index,
 838                            u64 time, u32 n_vectors, u32 is_return)
 839 {
 840   vlib_main_t *evm = vlib_get_first_main ();
 841   elog_main_t *em = vlib_get_elog_main ();
 842   int enabled = evm->elog_trace_graph_dispatch |
 843     evm->elog_trace_graph_circuit;
 844
 845   if (PREDICT_FALSE (enabled && n_vectors))
 846     {
 847       if (PREDICT_FALSE (!elog_is_enabled (em)))
 848         {
 849           evm->elog_trace_graph_dispatch = 0;
 850           evm->elog_trace_graph_circuit = 0;
 851           return;
 852         }
 853       if (PREDICT_TRUE
 854           (evm->elog_trace_graph_dispatch ||
 855            (evm->elog_trace_graph_circuit &&
 856             node_index == evm->elog_trace_graph_circuit_node_index)))
 857         {
 858           elog_track (em,
 859                       /* event type */
 860                       vec_elt_at_index (is_return
 861                                         ? evm->node_return_elog_event_types
 862                                         : evm->node_call_elog_event_types,
 863                                         node_index),
 864                       /* track */
 865                       (vm->thread_index ?
 866                        &vlib_worker_threads[vm->thread_index].elog_track
 867                        : &em->default_track),
 868                       /* data to log */ n_vectors);
 869         }
 870     }
 871 }
 872
 873 static inline void
 874 add_trajectory_trace (vlib_buffer_t * b, u32 node_index)
 875 {
 876 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
 877   if (PREDICT_FALSE (b->trajectory_nb >= VLIB_BUFFER_TRACE_TRAJECTORY_MAX))
 878     return;
 879   b->trajectory_trace[b->trajectory_nb] = node_index;
 880   b->trajectory_nb++;
 881 #endif
 882 }
 883
 884 static_always_inline u64
 885 dispatch_node (vlib_main_t * vm,
 886                vlib_node_runtime_t * node,
 887                vlib_node_type_t type,
 888                vlib_node_state_t dispatch_state,
 889                vlib_frame_t * frame, u64 last_time_stamp)
 890 {
 891   uword n, v;
 892   u64 t;
 893   vlib_node_main_t *nm = &vm->node_main;
 894   vlib_next_frame_t *nf;
 895
 896   if (CLIB_DEBUG > 0)
 897     {
 898       vlib_node_t *n = vlib_get_node (vm, node->node_index);
 899       ASSERT (n->type == type);
 900     }
 901
 902   /* Only non-internal nodes may be disabled. */
 903   if (type != VLIB_NODE_TYPE_INTERNAL && node->state != dispatch_state)
 904     {
 905       ASSERT (type != VLIB_NODE_TYPE_INTERNAL);
 906       return last_time_stamp;
 907     }
 908
 909   if ((type == VLIB_NODE_TYPE_PRE_INPUT || type == VLIB_NODE_TYPE_INPUT)
 910       && dispatch_state != VLIB_NODE_STATE_INTERRUPT)
 911     {
 912       u32 c = node->input_main_loops_per_call;
 913       /* Only call node when count reaches zero. */
 914       if (c)
 915         {
 916           node->input_main_loops_per_call = c - 1;
 917           return last_time_stamp;
 918         }
 919     }
 920
 921   /* Speculatively prefetch next frames. */
 922   if (node->n_next_nodes > 0)
 923     {
 924       nf = vec_elt_at_index (nm->next_frames, node->next_frame_index);
 925       CLIB_PREFETCH (nf, 4 * sizeof (nf[0]), WRITE);
 926     }
 927
 928   vm->cpu_time_last_node_dispatch = last_time_stamp;
 929
 930   vlib_elog_main_loop_event (vm, node->node_index,
 931                              last_time_stamp, frame ? frame->n_vectors : 0,
 932                              /* is_after */ 0);
 933
 934   vlib_node_runtime_perf_counter (vm, node, frame, 0, last_time_stamp,
 935                                   VLIB_NODE_RUNTIME_PERF_BEFORE);
 936
 937   /*
 938    * Turn this on if you run into
 939    * "bad monkey" contexts, and you want to know exactly
 940    * which nodes they've visited... See ixge.c...
 941    */
 942   if (VLIB_BUFFER_TRACE_TRAJECTORY && frame)
 943     {
 944       int i;
 945       u32 *from;
 946       from = vlib_frame_vector_args (frame);
 947       for (i = 0; i < frame->n_vectors; i++)
 948         {
 949           vlib_buffer_t *b = vlib_get_buffer (vm, from[i]);
 950           add_trajectory_trace (b, node->node_index);
 951         }
 952       if (PREDICT_TRUE (vm->dispatch_wrapper_fn == 0))
 953         n = node->function (vm, node, frame);
 954       else
 955         n = vm->dispatch_wrapper_fn (vm, node, frame);
 956     }
 957   else
 958     {
 959       if (PREDICT_TRUE (vm->dispatch_wrapper_fn == 0))
 960         n = node->function (vm, node, frame);
 961       else
 962         n = vm->dispatch_wrapper_fn (vm, node, frame);
 963     }
 964
 965   t = clib_cpu_time_now ();
 966
 967   vlib_node_runtime_perf_counter (vm, node, frame, n, t,
 968                                   VLIB_NODE_RUNTIME_PERF_AFTER);
 969
 970   vlib_elog_main_loop_event (vm, node->node_index, t, n, 1 /* is_after */ );
 971
 972   vm->main_loop_vectors_processed += n;
 973   vm->main_loop_nodes_processed += n > 0;
 974
 975   v = vlib_node_runtime_update_stats (vm, node,
 976                                       /* n_calls */ 1,
 977                                       /* n_vectors */ n,
 978                                       /* n_clocks */ t - last_time_stamp);
 979
 980   /* When in adaptive mode and vector rate crosses threshold switch to
 981      polling mode and vice versa. */
 982   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_ADAPTIVE_MODE))
 983     {
 984       /* *INDENT-OFF* */
 985       ELOG_TYPE_DECLARE (e) =
 986         {
 987           .function = (char *) __FUNCTION__,
 988           .format = "%s vector length %d, switching to %s",
 989           .format_args = "T4i4t4",
 990           .n_enum_strings = 2,
 991           .enum_strings = {
 992             "interrupt", "polling",
 993           },
 994         };
 995       /* *INDENT-ON* */
 996       struct
 997       {
 998         u32 node_name, vector_length, is_polling;
 999       } *ed;
1000
1001       if ((dispatch_state == VLIB_NODE_STATE_INTERRUPT
1002            && v >= nm->polling_threshold_vector_length) &&
1003           !(node->flags &
1004             VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE))
1005         {
1006           vlib_node_t *n = vlib_get_node (vm, node->node_index);
1007           n->state = VLIB_NODE_STATE_POLLING;
1008           node->state = VLIB_NODE_STATE_POLLING;
1009           node->flags &=
1010             ~VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE;
1011           node->flags |= VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE;
1012           nm->input_node_counts_by_state[VLIB_NODE_STATE_INTERRUPT] -= 1;
1013           nm->input_node_counts_by_state[VLIB_NODE_STATE_POLLING] += 1;
1014
1015           if (PREDICT_FALSE (
1016                 vlib_get_first_main ()->elog_trace_graph_dispatch))
1017             {
1018               vlib_worker_thread_t *w = vlib_worker_threads
1019                 + vm->thread_index;
1020
1021               ed = ELOG_TRACK_DATA (&vlib_global_main.elog_main, e,
1022                                     w->elog_track);
1023               ed->node_name = n->name_elog_string;
1024               ed->vector_length = v;
1025               ed->is_polling = 1;
1026             }
1027         }
1028       else if (dispatch_state == VLIB_NODE_STATE_POLLING
1029                && v <= nm->interrupt_threshold_vector_length)
1030         {
1031           vlib_node_t *n = vlib_get_node (vm, node->node_index);
1032           if (node->flags &
1033               VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE)
1034             {
1035               /* Switch to interrupt mode after dispatch in polling one more time.
1036                  This allows driver to re-enable interrupts. */
1037               n->state = VLIB_NODE_STATE_INTERRUPT;
1038               node->state = VLIB_NODE_STATE_INTERRUPT;
1039               node->flags &=
1040                 ~VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE;
1041               nm->input_node_counts_by_state[VLIB_NODE_STATE_POLLING] -= 1;
1042               nm->input_node_counts_by_state[VLIB_NODE_STATE_INTERRUPT] += 1;
1043
1044             }
1045           else
1046             {
1047               vlib_worker_thread_t *w = vlib_worker_threads
1048                 + vm->thread_index;
1049               node->flags |=
1050                 VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE;
1051               if (PREDICT_FALSE (
1052                     vlib_get_first_main ()->elog_trace_graph_dispatch))
1053                 {
1054                   ed = ELOG_TRACK_DATA (&vlib_global_main.elog_main, e,
1055                                         w->elog_track);
1056                   ed->node_name = n->name_elog_string;
1057                   ed->vector_length = v;
1058                   ed->is_polling = 0;
1059                 }
1060             }
1061         }
1062     }
1063
1064   return t;
1065 }
1066
1067 static u64
1068 dispatch_pending_node (vlib_main_t * vm, uword pending_frame_index,
1069                        u64 last_time_stamp)
1070 {
1071   vlib_node_main_t *nm = &vm->node_main;
1072   vlib_frame_t *f;
1073   vlib_next_frame_t *nf, nf_placeholder;
1074   vlib_node_runtime_t *n;
1075   vlib_frame_t *restore_frame;
1076   vlib_pending_frame_t *p;
1077
1078   /* See comment below about dangling references to nm->pending_frames */
1079   p = nm->pending_frames + pending_frame_index;
1080
1081   n = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INTERNAL],
1082                         p->node_runtime_index);
1083
1084   f = vlib_get_frame (vm, p->frame);
1085   if (p->next_frame_index == VLIB_PENDING_FRAME_NO_NEXT_FRAME)
1086     {
1087       /* No next frame: so use placeholder on stack. */
1088       nf = &nf_placeholder;
1089       nf->flags = f->frame_flags & VLIB_NODE_FLAG_TRACE;
1090       nf->frame = NULL;
1091     }
1092   else
1093     nf = vec_elt_at_index (nm->next_frames, p->next_frame_index);
1094
1095   ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
1096
1097   /* Force allocation of new frame while current frame is being
1098      dispatched. */
1099   restore_frame = NULL;
1100   if (nf->frame == p->frame)
1101     {
1102       nf->frame = NULL;
1103       nf->flags &= ~VLIB_FRAME_IS_ALLOCATED;
1104       if (!(n->flags & VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH))
1105         restore_frame = p->frame;
1106     }
1107
1108   /* Frame must be pending. */
1109   ASSERT (f->frame_flags & VLIB_FRAME_PENDING);
1110   ASSERT (f->n_vectors > 0);
1111
1112   /* Copy trace flag from next frame to node.
1113      Trace flag indicates that at least one vector in the dispatched
1114      frame is traced. */
1115   n->flags &= ~VLIB_NODE_FLAG_TRACE;
1116   n->flags |= (nf->flags & VLIB_FRAME_TRACE) ? VLIB_NODE_FLAG_TRACE : 0;
1117   nf->flags &= ~VLIB_FRAME_TRACE;
1118
1119   last_time_stamp = dispatch_node (vm, n,
1120                                    VLIB_NODE_TYPE_INTERNAL,
1121                                    VLIB_NODE_STATE_POLLING,
1122                                    f, last_time_stamp);
1123   /* Internal node vector-rate accounting, for summary stats */
1124   vm->internal_node_vectors += f->n_vectors;
1125   vm->internal_node_calls++;
1126   vm->internal_node_last_vectors_per_main_loop =
1127     (f->n_vectors > vm->internal_node_last_vectors_per_main_loop) ?
1128     f->n_vectors : vm->internal_node_last_vectors_per_main_loop;
1129
1130   f->frame_flags &= ~(VLIB_FRAME_PENDING | VLIB_FRAME_NO_APPEND);
1131
1132   /* Frame is ready to be used again, so restore it. */
1133   if (restore_frame != NULL)
1134     {
1135       /*
1136        * We musn't restore a frame that is flagged to be freed. This
1137        * shouldn't happen since frames to be freed post dispatch are
1138        * those used when the to-node frame becomes full i.e. they form a
1139        * sort of queue of frames to a single node. If we get here then
1140        * the to-node frame and the pending frame *were* the same, and so
1141        * we removed the to-node frame.  Therefore this frame is no
1142        * longer part of the queue for that node and hence it cannot be
1143        * it's overspill.
1144        */
1145       ASSERT (!(f->frame_flags & VLIB_FRAME_FREE_AFTER_DISPATCH));
1146
1147       /*
1148        * NB: dispatching node n can result in the creation and scheduling
1149        * of new frames, and hence in the reallocation of nm->pending_frames.
1150        * Recompute p, or no supper. This was broken for more than 10 years.
1151        */
1152       p = nm->pending_frames + pending_frame_index;
1153
1154       /*
1155        * p->next_frame_index can change during node dispatch if node
1156        * function decides to change graph hook up.
1157        */
1158       nf = vec_elt_at_index (nm->next_frames, p->next_frame_index);
1159       nf->flags |= VLIB_FRAME_IS_ALLOCATED;
1160
1161       if (NULL == nf->frame)
1162         {
1163           /* no new frame has been assigned to this node, use the saved one */
1164           nf->frame = restore_frame;
1165           f->n_vectors = 0;
1166           f->flags = 0;
1167         }
1168       else
1169         {
1170           /* The node has gained a frame, implying packets from the current frame
1171              were re-queued to this same node. we don't need the saved one
1172              anymore */
1173           vlib_frame_free (vm, f);
1174         }
1175     }
1176   else
1177     {
1178       if (f->frame_flags & VLIB_FRAME_FREE_AFTER_DISPATCH)
1179         {
1180           ASSERT (!(n->flags & VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH));
1181           vlib_frame_free (vm, f);
1182         }
1183     }
1184
1185   return last_time_stamp;
1186 }
1187
1188 always_inline uword
1189 vlib_process_stack_is_valid (vlib_process_t * p)
1190 {
1191   return p->stack[0] == VLIB_PROCESS_STACK_MAGIC;
1192 }
1193
1194 typedef struct
1195 {
1196   vlib_main_t *vm;
1197   vlib_process_t *process;
1198   vlib_frame_t *frame;
1199 } vlib_process_bootstrap_args_t;
1200
1201 /* Called in process stack. */
1202 static uword
1203 vlib_process_bootstrap (uword _a)
1204 {
1205   vlib_process_bootstrap_args_t *a;
1206   vlib_main_t *vm;
1207   vlib_node_runtime_t *node;
1208   vlib_frame_t *f;
1209   vlib_process_t *p;
1210   uword n;
1211
1212   a = uword_to_pointer (_a, vlib_process_bootstrap_args_t *);
1213
1214   vm = a->vm;
1215   p = a->process;
1216   vlib_process_finish_switch_stack (vm);
1217
1218   f = a->frame;
1219   node = &p->node_runtime;
1220
1221   n = node->function (vm, node, f);
1222
1223   ASSERT (vlib_process_stack_is_valid (p));
1224
1225   vlib_process_start_switch_stack (vm, 0);
1226   clib_longjmp (&p->return_longjmp, n);
1227
1228   return n;
1229 }
1230
1231 /* Called in main stack. */
1232 static_always_inline uword
1233 vlib_process_startup (vlib_main_t * vm, vlib_process_t * p, vlib_frame_t * f)
1234 {
1235   vlib_process_bootstrap_args_t a;
1236   uword r;
1237
1238   a.vm = vm;
1239   a.process = p;
1240   a.frame = f;
1241
1242   r = clib_setjmp (&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_RETURN);
1243   if (r == VLIB_PROCESS_RETURN_LONGJMP_RETURN)
1244     {
1245       vlib_process_start_switch_stack (vm, p);
1246       r = clib_calljmp (vlib_process_bootstrap, pointer_to_uword (&a),
1247                         (void *) p->stack + (1 << p->log2_n_stack_bytes));
1248     }
1249   else
1250     vlib_process_finish_switch_stack (vm);
1251
1252   return r;
1253 }
1254
1255 static_always_inline uword
1256 vlib_process_resume (vlib_main_t * vm, vlib_process_t * p)
1257 {
1258   uword r;
1259   p->flags &= ~(VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
1260                 | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
1261                 | VLIB_PROCESS_RESUME_PENDING);
1262   r = clib_setjmp (&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_RETURN);
1263   if (r == VLIB_PROCESS_RETURN_LONGJMP_RETURN)
1264     {
1265       vlib_process_start_switch_stack (vm, p);
1266       clib_longjmp (&p->resume_longjmp, VLIB_PROCESS_RESUME_LONGJMP_RESUME);
1267     }
1268   else
1269     vlib_process_finish_switch_stack (vm);
1270   return r;
1271 }
1272
1273 static u64
1274 dispatch_process (vlib_main_t * vm,
1275                   vlib_process_t * p, vlib_frame_t * f, u64 last_time_stamp)
1276 {
1277   vlib_node_main_t *nm = &vm->node_main;
1278   vlib_node_runtime_t *node_runtime = &p->node_runtime;
1279   vlib_node_t *node = vlib_get_node (vm, node_runtime->node_index);
1280   u32 old_process_index;
1281   u64 t;
1282   uword n_vectors, is_suspend;
1283
1284   if (node->state != VLIB_NODE_STATE_POLLING
1285       || (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
1286                       | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT)))
1287     return last_time_stamp;
1288
1289   p->flags |= VLIB_PROCESS_IS_RUNNING;
1290
1291   t = last_time_stamp;
1292   vlib_elog_main_loop_event (vm, node_runtime->node_index, t,
1293                              f ? f->n_vectors : 0, /* is_after */ 0);
1294
1295   /* Save away current process for suspend. */
1296   old_process_index = nm->current_process_index;
1297   nm->current_process_index = node->runtime_index;
1298
1299   vlib_node_runtime_perf_counter (vm, node_runtime, f, 0, last_time_stamp,
1300                                   VLIB_NODE_RUNTIME_PERF_BEFORE);
1301
1302   n_vectors = vlib_process_startup (vm, p, f);
1303
1304   nm->current_process_index = old_process_index;
1305
1306   ASSERT (n_vectors != VLIB_PROCESS_RETURN_LONGJMP_RETURN);
1307   is_suspend = n_vectors == VLIB_PROCESS_RETURN_LONGJMP_SUSPEND;
1308   if (is_suspend)
1309     {
1310       vlib_pending_frame_t *pf;
1311
1312       n_vectors = 0;
1313       pool_get (nm->suspended_process_frames, pf);
1314       pf->node_runtime_index = node->runtime_index;
1315       pf->frame = f;
1316       pf->next_frame_index = ~0;
1317
1318       p->n_suspends += 1;
1319       p->suspended_process_frame_index = pf - nm->suspended_process_frames;
1320
1321       if (p->flags & VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK)
1322         {
1323           TWT (tw_timer_wheel) * tw =
1324             (TWT (tw_timer_wheel) *) nm->timing_wheel;
1325           p->stop_timer_handle =
1326             TW (tw_timer_start) (tw,
1327                                  vlib_timing_wheel_data_set_suspended_process
1328                                  (node->runtime_index) /* [sic] pool idex */ ,
1329                                  0 /* timer_id */ ,
1330                                  p->resume_clock_interval);
1331         }
1332     }
1333   else
1334     p->flags &= ~VLIB_PROCESS_IS_RUNNING;
1335
1336   t = clib_cpu_time_now ();
1337
1338   vlib_elog_main_loop_event (vm, node_runtime->node_index, t, is_suspend,
1339                              /* is_after */ 1);
1340
1341   vlib_node_runtime_perf_counter (vm, node_runtime, f, n_vectors, t,
1342                                   VLIB_NODE_RUNTIME_PERF_AFTER);
1343
1344   vlib_process_update_stats (vm, p,
1345                              /* n_calls */ !is_suspend,
1346                              /* n_vectors */ n_vectors,
1347                              /* n_clocks */ t - last_time_stamp);
1348
1349   return t;
1350 }
1351
1352 void
1353 vlib_start_process (vlib_main_t * vm, uword process_index)
1354 {
1355   vlib_node_main_t *nm = &vm->node_main;
1356   vlib_process_t *p = vec_elt (nm->processes, process_index);
1357   dispatch_process (vm, p, /* frame */ 0, /* cpu_time_now */ 0);
1358 }
1359
1360 static u64
1361 dispatch_suspended_process (vlib_main_t * vm,
1362                             uword process_index, u64 last_time_stamp)
1363 {
1364   vlib_node_main_t *nm = &vm->node_main;
1365   vlib_node_runtime_t *node_runtime;
1366   vlib_node_t *node;
1367   vlib_frame_t *f;
1368   vlib_process_t *p;
1369   vlib_pending_frame_t *pf;
1370   u64 t, n_vectors, is_suspend;
1371
1372   t = last_time_stamp;
1373
1374   p = vec_elt (nm->processes, process_index);
1375   if (PREDICT_FALSE (!(p->flags & VLIB_PROCESS_IS_RUNNING)))
1376     return last_time_stamp;
1377
1378   ASSERT (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
1379                       | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT));
1380
1381   pf = pool_elt_at_index (nm->suspended_process_frames,
1382                           p->suspended_process_frame_index);
1383
1384   node_runtime = &p->node_runtime;
1385   node = vlib_get_node (vm, node_runtime->node_index);
1386   f = pf->frame;
1387
1388   vlib_elog_main_loop_event (vm, node_runtime->node_index, t,
1389                              f ? f->n_vectors : 0, /* is_after */ 0);
1390
1391   /* Save away current process for suspend. */
1392   nm->current_process_index = node->runtime_index;
1393
1394   vlib_node_runtime_perf_counter (vm, node_runtime, f, 0, last_time_stamp,
1395                                   VLIB_NODE_RUNTIME_PERF_BEFORE);
1396
1397   n_vectors = vlib_process_resume (vm, p);
1398   t = clib_cpu_time_now ();
1399
1400   nm->current_process_index = ~0;
1401
1402   is_suspend = n_vectors == VLIB_PROCESS_RETURN_LONGJMP_SUSPEND;
1403   if (is_suspend)
1404     {
1405       /* Suspend it again. */
1406       n_vectors = 0;
1407       p->n_suspends += 1;
1408       if (p->flags & VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK)
1409         {
1410           p->stop_timer_handle =
1411             TW (tw_timer_start) ((TWT (tw_timer_wheel) *) nm->timing_wheel,
1412                                  vlib_timing_wheel_data_set_suspended_process
1413                                  (node->runtime_index) /* [sic] pool idex */ ,
1414                                  0 /* timer_id */ ,
1415                                  p->resume_clock_interval);
1416         }
1417     }
1418   else
1419     {
1420       p->flags &= ~VLIB_PROCESS_IS_RUNNING;
1421       pool_put_index (nm->suspended_process_frames,
1422                       p->suspended_process_frame_index);
1423       p->suspended_process_frame_index = ~0;
1424     }
1425
1426   t = clib_cpu_time_now ();
1427   vlib_elog_main_loop_event (vm, node_runtime->node_index, t, !is_suspend,
1428                              /* is_after */ 1);
1429
1430   vlib_node_runtime_perf_counter (vm, node_runtime, f, n_vectors, t,
1431                                   VLIB_NODE_RUNTIME_PERF_AFTER);
1432
1433   vlib_process_update_stats (vm, p,
1434                              /* n_calls */ !is_suspend,
1435                              /* n_vectors */ n_vectors,
1436                              /* n_clocks */ t - last_time_stamp);
1437
1438   return t;
1439 }
1440
1441 void vl_api_send_pending_rpc_requests (vlib_main_t *) __attribute__ ((weak));
1442 void
1443 vl_api_send_pending_rpc_requests (vlib_main_t * vm)
1444 {
1445 }
1446
1447 static_always_inline void
1448 vlib_main_or_worker_loop (vlib_main_t * vm, int is_main)
1449 {
1450   vlib_node_main_t *nm = &vm->node_main;
1451   vlib_thread_main_t *tm = vlib_get_thread_main ();
1452   uword i;
1453   u64 cpu_time_now;
1454   f64 now;
1455   vlib_frame_queue_main_t *fqm;
1456   u32 frame_queue_check_counter = 0;
1457
1458   /* Initialize pending node vector. */
1459   if (is_main)
1460     {
1461       vec_resize (nm->pending_frames, 32);
1462       vec_set_len (nm->pending_frames, 0);
1463     }
1464
1465   /* Mark time of main loop start. */
1466   if (is_main)
1467     {
1468       cpu_time_now = vm->clib_time.last_cpu_time;
1469       vm->cpu_time_main_loop_start = cpu_time_now;
1470     }
1471   else
1472     cpu_time_now = clib_cpu_time_now ();
1473
1474   /* Pre-allocate interupt runtime indices and lock. */
1475   vec_alloc_aligned (nm->pending_interrupts, 1, CLIB_CACHE_LINE_BYTES);
1476
1477   /* Pre-allocate expired nodes. */
1478   if (!nm->polling_threshold_vector_length)
1479     nm->polling_threshold_vector_length = 10;
1480   if (!nm->interrupt_threshold_vector_length)
1481     nm->interrupt_threshold_vector_length = 5;
1482
1483   vm->cpu_id = clib_get_current_cpu_id ();
1484   vm->numa_node = clib_get_current_numa_node ();
1485   os_set_numa_index (vm->numa_node);
1486
1487   /* Start all processes. */
1488   if (is_main)
1489     {
1490       uword i;
1491
1492       /*
1493        * Perform an initial barrier sync. Pays no attention to
1494        * the barrier sync hold-down timer scheme, which won't work
1495        * at this point in time.
1496        */
1497       vlib_worker_thread_initial_barrier_sync_and_release (vm);
1498
1499       nm->current_process_index = ~0;
1500       for (i = 0; i < vec_len (nm->processes); i++)
1501         cpu_time_now = dispatch_process (vm, nm->processes[i], /* frame */ 0,
1502                                          cpu_time_now);
1503     }
1504
1505   while (1)
1506     {
1507       vlib_node_runtime_t *n;
1508
1509       if (PREDICT_FALSE (_vec_len (vm->pending_rpc_requests) > 0))
1510         {
1511           if (!is_main)
1512             vl_api_send_pending_rpc_requests (vm);
1513         }
1514
1515       if (!is_main)
1516         vlib_worker_thread_barrier_check ();
1517
1518       if (PREDICT_FALSE (vm->check_frame_queues + frame_queue_check_counter))
1519         {
1520           u32 processed = 0;
1521           vlib_frame_queue_dequeue_fn_t *fn;
1522
1523           if (vm->check_frame_queues)
1524             {
1525               frame_queue_check_counter = 100;
1526               vm->check_frame_queues = 0;
1527             }
1528
1529           vec_foreach (fqm, tm->frame_queue_mains)
1530             {
1531               fn = fqm->frame_queue_dequeue_fn;
1532               processed += (fn) (vm, fqm);
1533             }
1534
1535           /* No handoff queue work found? */
1536           if (processed)
1537             frame_queue_check_counter = 100;
1538           else
1539             frame_queue_check_counter--;
1540         }
1541
1542       if (PREDICT_FALSE (vec_len (vm->worker_thread_main_loop_callbacks)))
1543         clib_call_callbacks (vm->worker_thread_main_loop_callbacks, vm,
1544                              cpu_time_now);
1545
1546       /* Process pre-input nodes. */
1547       cpu_time_now = clib_cpu_time_now ();
1548       vec_foreach (n, nm->nodes_by_type[VLIB_NODE_TYPE_PRE_INPUT])
1549         cpu_time_now = dispatch_node (vm, n,
1550                                       VLIB_NODE_TYPE_PRE_INPUT,
1551                                       VLIB_NODE_STATE_POLLING,
1552                                       /* frame */ 0,
1553                                       cpu_time_now);
1554
1555       /* Next process input nodes. */
1556       vec_foreach (n, nm->nodes_by_type[VLIB_NODE_TYPE_INPUT])
1557         cpu_time_now = dispatch_node (vm, n,
1558                                       VLIB_NODE_TYPE_INPUT,
1559                                       VLIB_NODE_STATE_POLLING,
1560                                       /* frame */ 0,
1561                                       cpu_time_now);
1562
1563       if (PREDICT_TRUE (is_main && vm->queue_signal_pending == 0))
1564         vm->queue_signal_callback (vm);
1565
1566       if (__atomic_load_n (nm->pending_interrupts, __ATOMIC_ACQUIRE))
1567         {
1568           int int_num = -1;
1569           *nm->pending_interrupts = 0;
1570
1571           while ((int_num =
1572                     clib_interrupt_get_next (nm->interrupts, int_num)) != -1)
1573             {
1574               vlib_node_runtime_t *n;
1575               clib_interrupt_clear (nm->interrupts, int_num);
1576               n = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INPUT],
1577                                     int_num);
1578               cpu_time_now = dispatch_node (vm, n, VLIB_NODE_TYPE_INPUT,
1579                                             VLIB_NODE_STATE_INTERRUPT,
1580                                             /* frame */ 0, cpu_time_now);
1581             }
1582         }
1583
1584       /* Input nodes may have added work to the pending vector.
1585          Process pending vector until there is nothing left.
1586          All pending vectors will be processed from input -> output. */
1587       for (i = 0; i < _vec_len (nm->pending_frames); i++)
1588         cpu_time_now = dispatch_pending_node (vm, i, cpu_time_now);
1589       /* Reset pending vector for next iteration. */
1590       vec_set_len (nm->pending_frames, 0);
1591
1592       if (is_main)
1593         {
1594           /* *INDENT-OFF* */
1595           ELOG_TYPE_DECLARE (es) =
1596             {
1597               .format = "process tw start",
1598               .format_args = "",
1599             };
1600           ELOG_TYPE_DECLARE (ee) =
1601             {
1602               .format = "process tw end: %d",
1603               .format_args = "i4",
1604             };
1605           /* *INDENT-ON* */
1606
1607           struct
1608           {
1609             int nready_procs;
1610           } *ed;
1611
1612           /* Check if process nodes have expired from timing wheel. */
1613           ASSERT (nm->data_from_advancing_timing_wheel != 0);
1614
1615           if (PREDICT_FALSE (vm->elog_trace_graph_dispatch))
1616             ed = ELOG_DATA (&vlib_global_main.elog_main, es);
1617
1618           nm->data_from_advancing_timing_wheel =
1619             TW (tw_timer_expire_timers_vec)
1620             ((TWT (tw_timer_wheel) *) nm->timing_wheel, vlib_time_now (vm),
1621              nm->data_from_advancing_timing_wheel);
1622
1623           ASSERT (nm->data_from_advancing_timing_wheel != 0);
1624
1625           if (PREDICT_FALSE (vm->elog_trace_graph_dispatch))
1626             {
1627               ed = ELOG_DATA (&vlib_global_main.elog_main, ee);
1628               ed->nready_procs =
1629                 _vec_len (nm->data_from_advancing_timing_wheel);
1630             }
1631
1632           if (PREDICT_FALSE
1633               (_vec_len (nm->data_from_advancing_timing_wheel) > 0))
1634             {
1635               uword i;
1636
1637               for (i = 0; i < _vec_len (nm->data_from_advancing_timing_wheel);
1638                    i++)
1639                 {
1640                   u32 d = nm->data_from_advancing_timing_wheel[i];
1641                   u32 di = vlib_timing_wheel_data_get_index (d);
1642
1643                   if (vlib_timing_wheel_data_is_timed_event (d))
1644                     {
1645                       vlib_signal_timed_event_data_t *te =
1646                         pool_elt_at_index (nm->signal_timed_event_data_pool,
1647                                            di);
1648                       vlib_node_t *n =
1649                         vlib_get_node (vm, te->process_node_index);
1650                       vlib_process_t *p =
1651                         vec_elt (nm->processes, n->runtime_index);
1652                       void *data;
1653                       data =
1654                         vlib_process_signal_event_helper (nm, n, p,
1655                                                           te->event_type_index,
1656                                                           te->n_data_elts,
1657                                                           te->n_data_elt_bytes);
1658                       if (te->n_data_bytes < sizeof (te->inline_event_data))
1659                         clib_memcpy_fast (data, te->inline_event_data,
1660                                           te->n_data_bytes);
1661                       else
1662                         {
1663                           clib_memcpy_fast (data, te->event_data_as_vector,
1664                                             te->n_data_bytes);
1665                           vec_free (te->event_data_as_vector);
1666                         }
1667                       pool_put (nm->signal_timed_event_data_pool, te);
1668                     }
1669                   else
1670                     {
1671                       cpu_time_now = clib_cpu_time_now ();
1672                       cpu_time_now =
1673                         dispatch_suspended_process (vm, di, cpu_time_now);
1674                     }
1675                 }
1676               vec_set_len (nm->data_from_advancing_timing_wheel, 0);
1677             }
1678         }
1679       vlib_increment_main_loop_counter (vm);
1680       /* Record time stamp in case there are no enabled nodes and above
1681          calls do not update time stamp. */
1682       cpu_time_now = clib_cpu_time_now ();
1683       vm->loops_this_reporting_interval++;
1684       now = clib_time_now_internal (&vm->clib_time, cpu_time_now);
1685       /* Time to update loops_per_second? */
1686       if (PREDICT_FALSE (now >= vm->loop_interval_end))
1687         {
1688           /* Next sample ends in 20ms */
1689           if (vm->loop_interval_start)
1690             {
1691               f64 this_loops_per_second;
1692
1693               this_loops_per_second =
1694                 ((f64) vm->loops_this_reporting_interval) / (now -
1695                                                              vm->loop_interval_start);
1696
1697               vm->loops_per_second =
1698                 vm->loops_per_second * vm->damping_constant +
1699                 (1.0 - vm->damping_constant) * this_loops_per_second;
1700               if (vm->loops_per_second != 0.0)
1701                 vm->seconds_per_loop = 1.0 / vm->loops_per_second;
1702               else
1703                 vm->seconds_per_loop = 0.0;
1704             }
1705           /* New interval starts now, and ends in 20ms */
1706           vm->loop_interval_start = now;
1707           vm->loop_interval_end = now + 2e-4;
1708           vm->loops_this_reporting_interval = 0;
1709         }
1710     }
1711 }
1712
1713 static void
1714 vlib_main_loop (vlib_main_t * vm)
1715 {
1716   vlib_main_or_worker_loop (vm, /* is_main */ 1);
1717 }
1718
1719 void
1720 vlib_worker_loop (vlib_main_t * vm)
1721 {
1722   vlib_main_or_worker_loop (vm, /* is_main */ 0);
1723 }
1724
1725 vlib_global_main_t vlib_global_main;
1726
1727 void
1728 vlib_add_del_post_mortem_callback (void *cb, int is_add)
1729 {
1730   vlib_global_main_t *vgm = vlib_get_global_main ();
1731   int i;
1732
1733   if (is_add == 0)
1734     {
1735       for (i = vec_len (vgm->post_mortem_callbacks) - 1; i >= 0; i--)
1736         if (vgm->post_mortem_callbacks[i] == cb)
1737           vec_del1 (vgm->post_mortem_callbacks, i);
1738       return;
1739     }
1740
1741   for (i = 0; i < vec_len (vgm->post_mortem_callbacks); i++)
1742     if (vgm->post_mortem_callbacks[i] == cb)
1743       return;
1744   vec_add1 (vgm->post_mortem_callbacks, cb);
1745 }
1746
1747 static void
1748 elog_post_mortem_dump (void)
1749 {
1750   elog_main_t *em = vlib_get_elog_main ();
1751
1752   u8 *filename;
1753   clib_error_t *error;
1754
1755   filename = format (0, "/tmp/elog_post_mortem.%d%c", getpid (), 0);
1756   error = elog_write_file (em, (char *) filename, 1 /* flush ring */);
1757   if (error)
1758     clib_error_report (error);
1759   /*
1760    * We're in the middle of crashing. Don't try to free the filename.
1761    */
1762 }
1763
1764 static clib_error_t *
1765 vlib_main_configure (vlib_main_t * vm, unformat_input_t * input)
1766 {
1767   vlib_global_main_t *vgm = vlib_get_global_main ();
1768   int turn_on_mem_trace = 0;
1769
1770   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1771     {
1772       if (unformat (input, "memory-trace"))
1773         turn_on_mem_trace = 1;
1774
1775       else if (unformat (input, "elog-events %d",
1776                          &vgm->configured_elog_ring_size))
1777         vgm->configured_elog_ring_size =
1778           1 << max_log2 (vgm->configured_elog_ring_size);
1779       else if (unformat (input, "elog-post-mortem-dump"))
1780         vlib_add_del_post_mortem_callback (elog_post_mortem_dump,
1781                                            /* is_add */ 1);
1782       else if (unformat (input, "buffer-alloc-success-rate %f",
1783                          &vm->buffer_alloc_success_rate))
1784         {
1785           if (VLIB_BUFFER_ALLOC_FAULT_INJECTOR == 0)
1786             return clib_error_return
1787               (0, "Buffer fault injection not configured");
1788         }
1789       else if (unformat (input, "buffer-alloc-success-seed %u",
1790                          &vm->buffer_alloc_success_seed))
1791         {
1792           if (VLIB_BUFFER_ALLOC_FAULT_INJECTOR == 0)
1793             return clib_error_return
1794               (0, "Buffer fault injection not configured");
1795         }
1796       else
1797         return unformat_parse_error (input);
1798     }
1799
1800   unformat_free (input);
1801
1802   /* Enable memory trace as early as possible. */
1803   if (turn_on_mem_trace)
1804     clib_mem_trace (1);
1805
1806   return 0;
1807 }
1808
1809 VLIB_EARLY_CONFIG_FUNCTION (vlib_main_configure, "vlib");
1810
1811 static void
1812 placeholder_queue_signal_callback (vlib_main_t * vm)
1813 {
1814 }
1815
1816 #define foreach_weak_reference_stub             \
1817 _(vpe_api_init)                                 \
1818 _(vlibmemory_init)                              \
1819 _(map_api_segment_init)
1820
1821 #define _(name)                                                 \
1822 clib_error_t *name (vlib_main_t *vm) __attribute__((weak));     \
1823 clib_error_t *name (vlib_main_t *vm) { return 0; }
1824 foreach_weak_reference_stub;
1825 #undef _
1826
1827 void vl_api_set_elog_main (elog_main_t * m) __attribute__ ((weak));
1828 void
1829 vl_api_set_elog_main (elog_main_t * m)
1830 {
1831   clib_warning ("STUB");
1832 }
1833
1834 int vl_api_set_elog_trace_api_messages (int enable) __attribute__ ((weak));
1835 int
1836 vl_api_set_elog_trace_api_messages (int enable)
1837 {
1838   clib_warning ("STUB");
1839   return 0;
1840 }
1841
1842 int vl_api_get_elog_trace_api_messages (void) __attribute__ ((weak));
1843 int
1844 vl_api_get_elog_trace_api_messages (void)
1845 {
1846   clib_warning ("STUB");
1847   return 0;
1848 }
1849
1850 /* Main function. */
1851 int
1852 vlib_main (vlib_main_t * volatile vm, unformat_input_t * input)
1853 {
1854   vlib_global_main_t *vgm = vlib_get_global_main ();
1855   clib_error_t *volatile error;
1856   vlib_node_main_t *nm = &vm->node_main;
1857
1858   vm->queue_signal_callback = placeholder_queue_signal_callback;
1859
1860   /* Reconfigure event log which is enabled very early */
1861   if (vgm->configured_elog_ring_size &&
1862       vgm->configured_elog_ring_size != vgm->elog_main.event_ring_size)
1863     elog_resize (&vgm->elog_main, vgm->configured_elog_ring_size);
1864   vl_api_set_elog_main (vlib_get_elog_main ());
1865   (void) vl_api_set_elog_trace_api_messages (1);
1866
1867   /* Default name. */
1868   if (!vgm->name)
1869     vgm->name = "VLIB";
1870
1871   if ((error = vlib_physmem_init (vm)))
1872     {
1873       clib_error_report (error);
1874       goto done;
1875     }
1876
1877   if ((error = vlib_log_init (vm)))
1878     {
1879       clib_error_report (error);
1880       goto done;
1881     }
1882
1883   if ((error = vlib_stats_init (vm)))
1884     {
1885       clib_error_report (error);
1886       goto done;
1887     }
1888
1889   if ((error = vlib_buffer_main_init (vm)))
1890     {
1891       clib_error_report (error);
1892       goto done;
1893     }
1894
1895   if ((error = vlib_thread_init (vm)))
1896     {
1897       clib_error_report (error);
1898       goto done;
1899     }
1900
1901   /* Register node ifunction variants */
1902   vlib_register_all_node_march_variants (vm);
1903
1904   /* Register static nodes so that init functions may use them. */
1905   vlib_register_all_static_nodes (vm);
1906
1907   /* Set seed for random number generator.
1908      Allow user to specify seed to make random sequence deterministic. */
1909   if (!unformat (input, "seed %wd", &vm->random_seed))
1910     vm->random_seed = clib_cpu_time_now ();
1911   clib_random_buffer_init (&vm->random_buffer, vm->random_seed);
1912
1913   /* Initialize node graph. */
1914   if ((error = vlib_node_main_init (vm)))
1915     {
1916       /* Arrange for graph hook up error to not be fatal when debugging. */
1917       if (CLIB_DEBUG > 0)
1918         clib_error_report (error);
1919       else
1920         goto done;
1921     }
1922
1923   /* Direct call / weak reference, for vlib standalone use-cases */
1924   if ((error = vpe_api_init (vm)))
1925     {
1926       clib_error_report (error);
1927       goto done;
1928     }
1929
1930   if ((error = vlibmemory_init (vm)))
1931     {
1932       clib_error_report (error);
1933       goto done;
1934     }
1935
1936   if ((error = map_api_segment_init (vm)))
1937     {
1938       clib_error_report (error);
1939       goto done;
1940     }
1941
1942   /* See unix/main.c; most likely already set up */
1943   if (vgm->init_functions_called == 0)
1944     vgm->init_functions_called = hash_create (0, /* value bytes */ 0);
1945   if ((error = vlib_call_all_init_functions (vm)))
1946     goto done;
1947
1948   nm->timing_wheel = clib_mem_alloc_aligned (sizeof (TWT (tw_timer_wheel)),
1949                                              CLIB_CACHE_LINE_BYTES);
1950
1951   vec_validate (nm->data_from_advancing_timing_wheel, 10);
1952   vec_set_len (nm->data_from_advancing_timing_wheel, 0);
1953
1954   /* Create the process timing wheel */
1955   TW (tw_timer_wheel_init) ((TWT (tw_timer_wheel) *) nm->timing_wheel,
1956                             0 /* no callback */ ,
1957                             10e-6 /* timer period 10us */ ,
1958                             ~0 /* max expirations per call */ );
1959
1960   vec_validate (vm->pending_rpc_requests, 0);
1961   vec_set_len (vm->pending_rpc_requests, 0);
1962   vec_validate (vm->processing_rpc_requests, 0);
1963   vec_set_len (vm->processing_rpc_requests, 0);
1964
1965   /* Default params for the buffer allocator fault injector, if configured */
1966   if (VLIB_BUFFER_ALLOC_FAULT_INJECTOR > 0)
1967     {
1968       vm->buffer_alloc_success_seed = 0xdeaddabe;
1969       vm->buffer_alloc_success_rate = 0.80;
1970     }
1971
1972   if ((error = vlib_call_all_config_functions (vm, input, 0 /* is_early */ )))
1973     goto done;
1974
1975   /*
1976    * Use exponential smoothing, with a half-life of 1 second
1977    * reported_rate(t) = reported_rate(t-1) * K + rate(t)*(1-K)
1978    *
1979    * Sample every 20ms, aka 50 samples per second
1980    * K = exp (-1.0/20.0);
1981    * K = 0.95
1982    */
1983   vm->damping_constant = exp (-1.0 / 20.0);
1984
1985   /* Sort per-thread init functions before we start threads */
1986   vlib_sort_init_exit_functions (&vgm->worker_init_function_registrations);
1987
1988   /* Call all main loop enter functions. */
1989   {
1990     clib_error_t *sub_error;
1991     sub_error = vlib_call_all_main_loop_enter_functions (vm);
1992     if (sub_error)
1993       clib_error_report (sub_error);
1994   }
1995
1996   switch (clib_setjmp (&vm->main_loop_exit, VLIB_MAIN_LOOP_EXIT_NONE))
1997     {
1998     case VLIB_MAIN_LOOP_EXIT_NONE:
1999       vm->main_loop_exit_set = 1;
2000       break;
2001
2002     case VLIB_MAIN_LOOP_EXIT_CLI:
2003       goto done;
2004
2005     default:
2006       error = vm->main_loop_error;
2007       goto done;
2008     }
2009
2010   vlib_main_loop (vm);
2011
2012 done:
2013   vlib_worker_thread_barrier_sync (vm);
2014   /* Call all exit functions. */
2015   {
2016     clib_error_t *sub_error;
2017     sub_error = vlib_call_all_main_loop_exit_functions (vm);
2018     if (sub_error)
2019       clib_error_report (sub_error);
2020   }
2021   vlib_worker_thread_barrier_release (vm);
2022
2023   if (error)
2024     clib_error_report (error);
2025
2026   return vm->main_loop_exit_status;
2027 }
2028
2029 vlib_main_t *
2030 vlib_get_main_not_inline (void)
2031 {
2032   return vlib_get_main ();
2033 }
2034
2035 elog_main_t *
2036 vlib_get_elog_main_not_inline ()
2037 {
2038   return &vlib_global_main.elog_main;
2039 }
2040
2041 void
2042 vlib_exit_with_status (vlib_main_t *vm, int status)
2043 {
2044   vm->main_loop_exit_status = status;
2045   __atomic_store_n (&vm->main_loop_exit_now, 1, __ATOMIC_RELEASE);
2046 }
2047
2048 /*
2049  * fd.io coding-style-patch-verification: ON
2050  *
2051  * Local Variables:
2052  * eval: (c-set-style "gnu")
2053  * End:
2054  */