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