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 always_inline u32
  56 vlib_frame_bytes (u32 n_scalar_bytes, u32 n_vector_bytes)
  57 {
  58   u32 n_bytes;
  59
  60   /* Make room for vlib_frame_t plus scalar arguments. */
  61   n_bytes = vlib_frame_vector_byte_offset (n_scalar_bytes);
  62
  63   /* Make room for vector arguments.
  64      Allocate a few extra slots of vector data to support
  65      speculative vector enqueues which overflow vector data in next frame. */
  66 #define VLIB_FRAME_SIZE_EXTRA 4
  67   n_bytes += (VLIB_FRAME_SIZE + VLIB_FRAME_SIZE_EXTRA) * n_vector_bytes;
  68
  69   /* Magic number is first 32bit number after vector data.
  70      Used to make sure that vector data is never overrun. */
  71 #define VLIB_FRAME_MAGIC (0xabadc0ed)
  72   n_bytes += sizeof (u32);
  73
  74   /* Pad to cache line. */
  75   n_bytes = round_pow2 (n_bytes, CLIB_CACHE_LINE_BYTES);
  76
  77   return n_bytes;
  78 }
  79
  80 always_inline u32 *
  81 vlib_frame_find_magic (vlib_frame_t * f, vlib_node_t * node)
  82 {
  83   void *p = f;
  84
  85   p += vlib_frame_vector_byte_offset (node->scalar_size);
  86
  87   p += (VLIB_FRAME_SIZE + VLIB_FRAME_SIZE_EXTRA) * node->vector_size;
  88
  89   return p;
  90 }
  91
  92 static inline vlib_frame_size_t *
  93 get_frame_size_info (vlib_node_main_t * nm,
  94                      u32 n_scalar_bytes, u32 n_vector_bytes)
  95 {
  96 #ifdef VLIB_SUPPORTS_ARBITRARY_SCALAR_SIZES
  97   uword key = (n_scalar_bytes << 16) | n_vector_bytes;
  98   uword *p, i;
  99
 100   p = hash_get (nm->frame_size_hash, key);
 101   if (p)
 102     i = p[0];
 103   else
 104     {
 105       i = vec_len (nm->frame_sizes);
 106       vec_validate (nm->frame_sizes, i);
 107       hash_set (nm->frame_size_hash, key, i);
 108     }
 109
 110   return vec_elt_at_index (nm->frame_sizes, i);
 111 #else
 112   ASSERT (vlib_frame_bytes (n_scalar_bytes, n_vector_bytes)
 113           == (vlib_frame_bytes (0, 4)));
 114   return vec_elt_at_index (nm->frame_sizes, 0);
 115 #endif
 116 }
 117
 118 static vlib_frame_t *
 119 vlib_frame_alloc_to_node (vlib_main_t * vm, u32 to_node_index,
 120                           u32 frame_flags)
 121 {
 122   vlib_node_main_t *nm = &vm->node_main;
 123   vlib_frame_size_t *fs;
 124   vlib_node_t *to_node;
 125   vlib_frame_t *f;
 126   u32 l, n, scalar_size, vector_size;
 127
 128   to_node = vlib_get_node (vm, to_node_index);
 129
 130   scalar_size = to_node->scalar_size;
 131   vector_size = to_node->vector_size;
 132
 133   fs = get_frame_size_info (nm, scalar_size, vector_size);
 134   n = vlib_frame_bytes (scalar_size, vector_size);
 135   if ((l = vec_len (fs->free_frames)) > 0)
 136     {
 137       /* Allocate from end of free list. */
 138       f = fs->free_frames[l - 1];
 139       _vec_len (fs->free_frames) = l - 1;
 140     }
 141   else
 142     {
 143       f = clib_mem_alloc_aligned_no_fail (n, VLIB_FRAME_ALIGN);
 144     }
 145
 146   /* Poison frame when debugging. */
 147   if (CLIB_DEBUG > 0)
 148     clib_memset (f, 0xfe, n);
 149
 150   /* Insert magic number. */
 151   {
 152     u32 *magic;
 153
 154     magic = vlib_frame_find_magic (f, to_node);
 155     *magic = VLIB_FRAME_MAGIC;
 156   }
 157
 158   f->frame_flags = VLIB_FRAME_IS_ALLOCATED | frame_flags;
 159   f->n_vectors = 0;
 160   f->scalar_size = scalar_size;
 161   f->vector_size = vector_size;
 162   f->flags = 0;
 163
 164   fs->n_alloc_frames += 1;
 165
 166   return f;
 167 }
 168
 169 /* Allocate a frame for from FROM_NODE to TO_NODE via TO_NEXT_INDEX.
 170    Returns frame index. */
 171 static vlib_frame_t *
 172 vlib_frame_alloc (vlib_main_t * vm, vlib_node_runtime_t * from_node_runtime,
 173                   u32 to_next_index)
 174 {
 175   vlib_node_t *from_node;
 176
 177   from_node = vlib_get_node (vm, from_node_runtime->node_index);
 178   ASSERT (to_next_index < vec_len (from_node->next_nodes));
 179
 180   return vlib_frame_alloc_to_node (vm, from_node->next_nodes[to_next_index],
 181                                    /* frame_flags */ 0);
 182 }
 183
 184 vlib_frame_t *
 185 vlib_get_frame_to_node (vlib_main_t * vm, u32 to_node_index)
 186 {
 187   vlib_frame_t *f = vlib_frame_alloc_to_node (vm, to_node_index,
 188                                               /* frame_flags */
 189                                               VLIB_FRAME_FREE_AFTER_DISPATCH);
 190   return vlib_get_frame (vm, f);
 191 }
 192
 193 void
 194 vlib_put_frame_to_node (vlib_main_t * vm, u32 to_node_index, vlib_frame_t * f)
 195 {
 196   vlib_pending_frame_t *p;
 197   vlib_node_t *to_node;
 198
 199   if (f->n_vectors == 0)
 200     return;
 201
 202   to_node = vlib_get_node (vm, to_node_index);
 203
 204   vec_add2 (vm->node_main.pending_frames, p, 1);
 205
 206   f->frame_flags |= VLIB_FRAME_PENDING;
 207   p->frame = vlib_get_frame (vm, f);
 208   p->node_runtime_index = to_node->runtime_index;
 209   p->next_frame_index = VLIB_PENDING_FRAME_NO_NEXT_FRAME;
 210 }
 211
 212 /* Free given frame. */
 213 void
 214 vlib_frame_free (vlib_main_t * vm, vlib_node_runtime_t * r, vlib_frame_t * f)
 215 {
 216   vlib_node_main_t *nm = &vm->node_main;
 217   vlib_node_t *node;
 218   vlib_frame_size_t *fs;
 219
 220   ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
 221
 222   node = vlib_get_node (vm, r->node_index);
 223   fs = get_frame_size_info (nm, node->scalar_size, node->vector_size);
 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) ASSERT (nf->frame != f);
 232     }
 233
 234   f->frame_flags &= ~(VLIB_FRAME_IS_ALLOCATED | VLIB_FRAME_NO_APPEND);
 235
 236   vec_add1 (fs->free_frames, f);
 237   ASSERT (fs->n_alloc_frames > 0);
 238   fs->n_alloc_frames -= 1;
 239 }
 240
 241 static clib_error_t *
 242 show_frame_stats (vlib_main_t * vm,
 243                   unformat_input_t * input, vlib_cli_command_t * cmd)
 244 {
 245   vlib_node_main_t *nm = &vm->node_main;
 246   vlib_frame_size_t *fs;
 247
 248   vlib_cli_output (vm, "%=6s%=12s%=12s", "Size", "# Alloc", "# Free");
 249   vec_foreach (fs, nm->frame_sizes)
 250   {
 251     u32 n_alloc = fs->n_alloc_frames;
 252     u32 n_free = vec_len (fs->free_frames);
 253
 254     if (n_alloc + n_free > 0)
 255       vlib_cli_output (vm, "%=6d%=12d%=12d",
 256                        fs - nm->frame_sizes, n_alloc, n_free);
 257   }
 258
 259   return 0;
 260 }
 261
 262 /* *INDENT-OFF* */
 263 VLIB_CLI_COMMAND (show_frame_stats_cli, static) = {
 264   .path = "show vlib frame-allocation",
 265   .short_help = "Show node dispatch frame statistics",
 266   .function = show_frame_stats,
 267 };
 268 /* *INDENT-ON* */
 269
 270 /* Change ownership of enqueue rights to given next node. */
 271 static void
 272 vlib_next_frame_change_ownership (vlib_main_t * vm,
 273                                   vlib_node_runtime_t * node_runtime,
 274                                   u32 next_index)
 275 {
 276   vlib_node_main_t *nm = &vm->node_main;
 277   vlib_next_frame_t *next_frame;
 278   vlib_node_t *node, *next_node;
 279
 280   node = vec_elt (nm->nodes, node_runtime->node_index);
 281
 282   /* Only internal & input nodes are allowed to call other nodes. */
 283   ASSERT (node->type == VLIB_NODE_TYPE_INTERNAL
 284           || node->type == VLIB_NODE_TYPE_INPUT
 285           || node->type == VLIB_NODE_TYPE_PROCESS);
 286
 287   ASSERT (vec_len (node->next_nodes) == node_runtime->n_next_nodes);
 288
 289   next_frame =
 290     vlib_node_runtime_get_next_frame (vm, node_runtime, next_index);
 291   next_node = vec_elt (nm->nodes, node->next_nodes[next_index]);
 292
 293   if (next_node->owner_node_index != VLIB_INVALID_NODE_INDEX)
 294     {
 295       /* Get frame from previous owner. */
 296       vlib_next_frame_t *owner_next_frame;
 297       vlib_next_frame_t tmp;
 298
 299       owner_next_frame =
 300         vlib_node_get_next_frame (vm,
 301                                   next_node->owner_node_index,
 302                                   next_node->owner_next_index);
 303
 304       /* Swap target next frame with owner's. */
 305       tmp = owner_next_frame[0];
 306       owner_next_frame[0] = next_frame[0];
 307       next_frame[0] = tmp;
 308
 309       /*
 310        * If next_frame is already pending, we have to track down
 311        * all pending frames and fix their next_frame_index fields.
 312        */
 313       if (next_frame->flags & VLIB_FRAME_PENDING)
 314         {
 315           vlib_pending_frame_t *p;
 316           if (next_frame->frame != NULL)
 317             {
 318               vec_foreach (p, nm->pending_frames)
 319               {
 320                 if (p->frame == next_frame->frame)
 321                   {
 322                     p->next_frame_index =
 323                       next_frame - vm->node_main.next_frames;
 324                   }
 325               }
 326             }
 327         }
 328     }
 329   else
 330     {
 331       /* No previous owner. Take ownership. */
 332       next_frame->flags |= VLIB_FRAME_OWNER;
 333     }
 334
 335   /* Record new owner. */
 336   next_node->owner_node_index = node->index;
 337   next_node->owner_next_index = next_index;
 338
 339   /* Now we should be owner. */
 340   ASSERT (next_frame->flags & VLIB_FRAME_OWNER);
 341 }
 342
 343 /* Make sure that magic number is still there.
 344    Otherwise, it is likely that caller has overrun frame arguments. */
 345 always_inline void
 346 validate_frame_magic (vlib_main_t * vm,
 347                       vlib_frame_t * f, vlib_node_t * n, uword next_index)
 348 {
 349   vlib_node_t *next_node = vlib_get_node (vm, n->next_nodes[next_index]);
 350   u32 *magic = vlib_frame_find_magic (f, next_node);
 351   ASSERT (VLIB_FRAME_MAGIC == magic[0]);
 352 }
 353
 354 vlib_frame_t *
 355 vlib_get_next_frame_internal (vlib_main_t * vm,
 356                               vlib_node_runtime_t * node,
 357                               u32 next_index, u32 allocate_new_next_frame)
 358 {
 359   vlib_frame_t *f;
 360   vlib_next_frame_t *nf;
 361   u32 n_used;
 362
 363   nf = vlib_node_runtime_get_next_frame (vm, node, next_index);
 364
 365   /* Make sure this next frame owns right to enqueue to destination frame. */
 366   if (PREDICT_FALSE (!(nf->flags & VLIB_FRAME_OWNER)))
 367     vlib_next_frame_change_ownership (vm, node, next_index);
 368
 369   /* ??? Don't need valid flag: can use frame_index == ~0 */
 370   if (PREDICT_FALSE (!(nf->flags & VLIB_FRAME_IS_ALLOCATED)))
 371     {
 372       nf->frame = vlib_frame_alloc (vm, node, next_index);
 373       nf->flags |= VLIB_FRAME_IS_ALLOCATED;
 374     }
 375
 376   f = nf->frame;
 377
 378   /* Has frame been removed from pending vector (e.g. finished dispatching)?
 379      If so we can reuse frame. */
 380   if ((nf->flags & VLIB_FRAME_PENDING)
 381       && !(f->frame_flags & VLIB_FRAME_PENDING))
 382     {
 383       nf->flags &= ~VLIB_FRAME_PENDING;
 384       f->n_vectors = 0;
 385       f->flags = 0;
 386     }
 387
 388   /* Allocate new frame if current one is marked as no-append or
 389      it is already full. */
 390   n_used = f->n_vectors;
 391   if (n_used >= VLIB_FRAME_SIZE || (allocate_new_next_frame && n_used > 0) ||
 392       (f->frame_flags & VLIB_FRAME_NO_APPEND))
 393     {
 394       /* Old frame may need to be freed after dispatch, since we'll have
 395          two redundant frames from node -> next node. */
 396       if (!(nf->flags & VLIB_FRAME_NO_FREE_AFTER_DISPATCH))
 397         {
 398           vlib_frame_t *f_old = vlib_get_frame (vm, nf->frame);
 399           f_old->frame_flags |= VLIB_FRAME_FREE_AFTER_DISPATCH;
 400         }
 401
 402       /* Allocate new frame to replace full one. */
 403       f = nf->frame = vlib_frame_alloc (vm, node, next_index);
 404       n_used = f->n_vectors;
 405     }
 406
 407   /* Should have free vectors in frame now. */
 408   ASSERT (n_used < VLIB_FRAME_SIZE);
 409
 410   if (CLIB_DEBUG > 0)
 411     {
 412       validate_frame_magic (vm, f,
 413                             vlib_get_node (vm, node->node_index), next_index);
 414     }
 415
 416   return f;
 417 }
 418
 419 static void
 420 vlib_put_next_frame_validate (vlib_main_t * vm,
 421                               vlib_node_runtime_t * rt,
 422                               u32 next_index, u32 n_vectors_left)
 423 {
 424   vlib_node_main_t *nm = &vm->node_main;
 425   vlib_next_frame_t *nf;
 426   vlib_frame_t *f;
 427   vlib_node_runtime_t *next_rt;
 428   vlib_node_t *next_node;
 429   u32 n_before, n_after;
 430
 431   nf = vlib_node_runtime_get_next_frame (vm, rt, next_index);
 432   f = vlib_get_frame (vm, nf->frame);
 433
 434   ASSERT (n_vectors_left <= VLIB_FRAME_SIZE);
 435   n_after = VLIB_FRAME_SIZE - n_vectors_left;
 436   n_before = f->n_vectors;
 437
 438   ASSERT (n_after >= n_before);
 439
 440   next_rt = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INTERNAL],
 441                               nf->node_runtime_index);
 442   next_node = vlib_get_node (vm, next_rt->node_index);
 443   if (n_after > 0 && next_node->validate_frame)
 444     {
 445       u8 *msg = next_node->validate_frame (vm, rt, f);
 446       if (msg)
 447         {
 448           clib_warning ("%v", msg);
 449           ASSERT (0);
 450         }
 451       vec_free (msg);
 452     }
 453 }
 454
 455 void
 456 vlib_put_next_frame (vlib_main_t * vm,
 457                      vlib_node_runtime_t * r,
 458                      u32 next_index, u32 n_vectors_left)
 459 {
 460   vlib_node_main_t *nm = &vm->node_main;
 461   vlib_next_frame_t *nf;
 462   vlib_frame_t *f;
 463   u32 n_vectors_in_frame;
 464
 465   if (CLIB_DEBUG > 0)
 466     vlib_put_next_frame_validate (vm, r, next_index, n_vectors_left);
 467
 468   nf = vlib_node_runtime_get_next_frame (vm, r, next_index);
 469   f = vlib_get_frame (vm, nf->frame);
 470
 471   /* Make sure that magic number is still there.  Otherwise, caller
 472      has overrun frame meta data. */
 473   if (CLIB_DEBUG > 0)
 474     {
 475       vlib_node_t *node = vlib_get_node (vm, r->node_index);
 476       validate_frame_magic (vm, f, node, next_index);
 477     }
 478
 479   /* Convert # of vectors left -> number of vectors there. */
 480   ASSERT (n_vectors_left <= VLIB_FRAME_SIZE);
 481   n_vectors_in_frame = VLIB_FRAME_SIZE - n_vectors_left;
 482
 483   f->n_vectors = n_vectors_in_frame;
 484
 485   /* If vectors were added to frame, add to pending vector. */
 486   if (PREDICT_TRUE (n_vectors_in_frame > 0))
 487     {
 488       vlib_pending_frame_t *p;
 489       u32 v0, v1;
 490
 491       r->cached_next_index = next_index;
 492
 493       if (!(f->frame_flags & VLIB_FRAME_PENDING))
 494         {
 495           __attribute__ ((unused)) vlib_node_t *node;
 496           vlib_node_t *next_node;
 497           vlib_node_runtime_t *next_runtime;
 498
 499           node = vlib_get_node (vm, r->node_index);
 500           next_node = vlib_get_next_node (vm, r->node_index, next_index);
 501           next_runtime = vlib_node_get_runtime (vm, next_node->index);
 502
 503           vec_add2 (nm->pending_frames, p, 1);
 504
 505           p->frame = nf->frame;
 506           p->node_runtime_index = nf->node_runtime_index;
 507           p->next_frame_index = nf - nm->next_frames;
 508           nf->flags |= VLIB_FRAME_PENDING;
 509           f->frame_flags |= VLIB_FRAME_PENDING;
 510
 511           /*
 512            * If we're going to dispatch this frame on another thread,
 513            * force allocation of a new frame. Otherwise, we create
 514            * a dangling frame reference. Each thread has its own copy of
 515            * the next_frames vector.
 516            */
 517           if (0 && r->thread_index != next_runtime->thread_index)
 518             {
 519               nf->frame = NULL;
 520               nf->flags &= ~(VLIB_FRAME_PENDING | VLIB_FRAME_IS_ALLOCATED);
 521             }
 522         }
 523
 524       /* Copy trace flag from next_frame and from runtime. */
 525       nf->flags |=
 526         (nf->flags & VLIB_NODE_FLAG_TRACE) | (r->
 527                                               flags & VLIB_NODE_FLAG_TRACE);
 528
 529       v0 = nf->vectors_since_last_overflow;
 530       v1 = v0 + n_vectors_in_frame;
 531       nf->vectors_since_last_overflow = v1;
 532       if (PREDICT_FALSE (v1 < v0))
 533         {
 534           vlib_node_t *node = vlib_get_node (vm, r->node_index);
 535           vec_elt (node->n_vectors_by_next_node, next_index) += v0;
 536         }
 537     }
 538 }
 539
 540 /* Sync up runtime (32 bit counters) and main node stats (64 bit counters). */
 541 never_inline void
 542 vlib_node_runtime_sync_stats (vlib_main_t * vm,
 543                               vlib_node_runtime_t * r,
 544                               uword n_calls, uword n_vectors, uword n_clocks,
 545                               uword n_ticks0, uword n_ticks1)
 546 {
 547   vlib_node_t *n = vlib_get_node (vm, r->node_index);
 548
 549   n->stats_total.calls += n_calls + r->calls_since_last_overflow;
 550   n->stats_total.vectors += n_vectors + r->vectors_since_last_overflow;
 551   n->stats_total.clocks += n_clocks + r->clocks_since_last_overflow;
 552   n->stats_total.perf_counter0_ticks += n_ticks0 +
 553     r->perf_counter0_ticks_since_last_overflow;
 554   n->stats_total.perf_counter1_ticks += n_ticks1 +
 555     r->perf_counter1_ticks_since_last_overflow;
 556   n->stats_total.perf_counter_vectors += n_vectors +
 557     r->perf_counter_vectors_since_last_overflow;
 558   n->stats_total.max_clock = r->max_clock;
 559   n->stats_total.max_clock_n = r->max_clock_n;
 560
 561   r->calls_since_last_overflow = 0;
 562   r->vectors_since_last_overflow = 0;
 563   r->clocks_since_last_overflow = 0;
 564   r->perf_counter0_ticks_since_last_overflow = 0ULL;
 565   r->perf_counter1_ticks_since_last_overflow = 0ULL;
 566   r->perf_counter_vectors_since_last_overflow = 0ULL;
 567 }
 568
 569 always_inline void __attribute__ ((unused))
 570 vlib_process_sync_stats (vlib_main_t * vm,
 571                          vlib_process_t * p,
 572                          uword n_calls, uword n_vectors, uword n_clocks,
 573                          uword n_ticks0, uword n_ticks1)
 574 {
 575   vlib_node_runtime_t *rt = &p->node_runtime;
 576   vlib_node_t *n = vlib_get_node (vm, rt->node_index);
 577   vlib_node_runtime_sync_stats (vm, rt, n_calls, n_vectors, n_clocks,
 578                                 n_ticks0, n_ticks1);
 579   n->stats_total.suspends += p->n_suspends;
 580   p->n_suspends = 0;
 581 }
 582
 583 void
 584 vlib_node_sync_stats (vlib_main_t * vm, vlib_node_t * n)
 585 {
 586   vlib_node_runtime_t *rt;
 587
 588   if (n->type == VLIB_NODE_TYPE_PROCESS)
 589     {
 590       /* Nothing to do for PROCESS nodes except in main thread */
 591       if (vm != &vlib_global_main)
 592         return;
 593
 594       vlib_process_t *p = vlib_get_process_from_node (vm, n);
 595       n->stats_total.suspends += p->n_suspends;
 596       p->n_suspends = 0;
 597       rt = &p->node_runtime;
 598     }
 599   else
 600     rt =
 601       vec_elt_at_index (vm->node_main.nodes_by_type[n->type],
 602                         n->runtime_index);
 603
 604   vlib_node_runtime_sync_stats (vm, rt, 0, 0, 0, 0, 0);
 605
 606   /* Sync up runtime next frame vector counters with main node structure. */
 607   {
 608     vlib_next_frame_t *nf;
 609     uword i;
 610     for (i = 0; i < rt->n_next_nodes; i++)
 611       {
 612         nf = vlib_node_runtime_get_next_frame (vm, rt, i);
 613         vec_elt (n->n_vectors_by_next_node, i) +=
 614           nf->vectors_since_last_overflow;
 615         nf->vectors_since_last_overflow = 0;
 616       }
 617   }
 618 }
 619
 620 always_inline u32
 621 vlib_node_runtime_update_stats (vlib_main_t * vm,
 622                                 vlib_node_runtime_t * node,
 623                                 uword n_calls,
 624                                 uword n_vectors, uword n_clocks,
 625                                 uword n_ticks0, uword n_ticks1)
 626 {
 627   u32 ca0, ca1, v0, v1, cl0, cl1, r;
 628   u32 ptick00, ptick01, ptick10, ptick11, pvec0, pvec1;
 629
 630   cl0 = cl1 = node->clocks_since_last_overflow;
 631   ca0 = ca1 = node->calls_since_last_overflow;
 632   v0 = v1 = node->vectors_since_last_overflow;
 633   ptick00 = ptick01 = node->perf_counter0_ticks_since_last_overflow;
 634   ptick10 = ptick11 = node->perf_counter1_ticks_since_last_overflow;
 635   pvec0 = pvec1 = node->perf_counter_vectors_since_last_overflow;
 636
 637   ca1 = ca0 + n_calls;
 638   v1 = v0 + n_vectors;
 639   cl1 = cl0 + n_clocks;
 640   ptick01 = ptick00 + n_ticks0;
 641   ptick11 = ptick10 + n_ticks1;
 642   pvec1 = pvec0 + n_vectors;
 643
 644   node->calls_since_last_overflow = ca1;
 645   node->clocks_since_last_overflow = cl1;
 646   node->vectors_since_last_overflow = v1;
 647   node->perf_counter0_ticks_since_last_overflow = ptick01;
 648   node->perf_counter1_ticks_since_last_overflow = ptick11;
 649   node->perf_counter_vectors_since_last_overflow = pvec1;
 650
 651   node->max_clock_n = node->max_clock > n_clocks ?
 652     node->max_clock_n : n_vectors;
 653   node->max_clock = node->max_clock > n_clocks ? node->max_clock : n_clocks;
 654
 655   r = vlib_node_runtime_update_main_loop_vector_stats (vm, node, n_vectors);
 656
 657   if (PREDICT_FALSE (ca1 < ca0 || v1 < v0 || cl1 < cl0) || (ptick01 < ptick00)
 658       || (ptick11 < ptick10) || (pvec1 < pvec0))
 659     {
 660       node->calls_since_last_overflow = ca0;
 661       node->clocks_since_last_overflow = cl0;
 662       node->vectors_since_last_overflow = v0;
 663       node->perf_counter0_ticks_since_last_overflow = ptick00;
 664       node->perf_counter1_ticks_since_last_overflow = ptick10;
 665       node->perf_counter_vectors_since_last_overflow = pvec0;
 666
 667       vlib_node_runtime_sync_stats (vm, node, n_calls, n_vectors, n_clocks,
 668                                     n_ticks0, n_ticks1);
 669     }
 670
 671   return r;
 672 }
 673
 674 always_inline void
 675 vlib_node_runtime_perf_counter (vlib_main_t * vm, u64 * pmc0, u64 * pmc1,
 676                                 vlib_node_runtime_t * node,
 677                                 vlib_frame_t * frame, int before_or_after)
 678 {
 679   *pmc0 = 0;
 680   *pmc1 = 0;
 681   if (PREDICT_FALSE (vec_len (vm->vlib_node_runtime_perf_counter_cbs) != 0))
 682     clib_call_callbacks (vm->vlib_node_runtime_perf_counter_cbs, vm, pmc0,
 683                          pmc1, node, frame, before_or_after);
 684 }
 685
 686 always_inline void
 687 vlib_process_update_stats (vlib_main_t * vm,
 688                            vlib_process_t * p,
 689                            uword n_calls, uword n_vectors, uword n_clocks)
 690 {
 691   vlib_node_runtime_update_stats (vm, &p->node_runtime,
 692                                   n_calls, n_vectors, n_clocks, 0ULL, 0ULL);
 693 }
 694
 695 static clib_error_t *
 696 vlib_cli_elog_clear (vlib_main_t * vm,
 697                      unformat_input_t * input, vlib_cli_command_t * cmd)
 698 {
 699   elog_reset_buffer (&vm->elog_main);
 700   return 0;
 701 }
 702
 703 /* *INDENT-OFF* */
 704 VLIB_CLI_COMMAND (elog_clear_cli, static) = {
 705   .path = "event-logger clear",
 706   .short_help = "Clear the event log",
 707   .function = vlib_cli_elog_clear,
 708 };
 709 /* *INDENT-ON* */
 710
 711 #ifdef CLIB_UNIX
 712 static clib_error_t *
 713 elog_save_buffer (vlib_main_t * vm,
 714                   unformat_input_t * input, vlib_cli_command_t * cmd)
 715 {
 716   elog_main_t *em = &vm->elog_main;
 717   char *file, *chroot_file;
 718   clib_error_t *error = 0;
 719
 720   if (!unformat (input, "%s", &file))
 721     {
 722       vlib_cli_output (vm, "expected file name, got `%U'",
 723                        format_unformat_error, input);
 724       return 0;
 725     }
 726
 727   /* It's fairly hard to get "../oopsie" through unformat; just in case */
 728   if (strstr (file, "..") || index (file, '/'))
 729     {
 730       vlib_cli_output (vm, "illegal characters in filename '%s'", file);
 731       return 0;
 732     }
 733
 734   chroot_file = (char *) format (0, "/tmp/%s%c", file, 0);
 735
 736   vec_free (file);
 737
 738   vlib_cli_output (vm, "Saving %wd of %wd events to %s",
 739                    elog_n_events_in_buffer (em),
 740                    elog_buffer_capacity (em), chroot_file);
 741
 742   vlib_worker_thread_barrier_sync (vm);
 743   error = elog_write_file (em, chroot_file, 1 /* flush ring */ );
 744   vlib_worker_thread_barrier_release (vm);
 745   vec_free (chroot_file);
 746   return error;
 747 }
 748
 749 void
 750 elog_post_mortem_dump (void)
 751 {
 752   vlib_main_t *vm = &vlib_global_main;
 753   elog_main_t *em = &vm->elog_main;
 754   u8 *filename;
 755   clib_error_t *error;
 756
 757   if (!vm->elog_post_mortem_dump)
 758     return;
 759
 760   filename = format (0, "/tmp/elog_post_mortem.%d%c", getpid (), 0);
 761   error = elog_write_file (em, (char *) filename, 1 /* flush ring */ );
 762   if (error)
 763     clib_error_report (error);
 764   vec_free (filename);
 765 }
 766
 767 /* *INDENT-OFF* */
 768 VLIB_CLI_COMMAND (elog_save_cli, static) = {
 769   .path = "event-logger save",
 770   .short_help = "event-logger save <filename> (saves log in /tmp/<filename>)",
 771   .function = elog_save_buffer,
 772 };
 773 /* *INDENT-ON* */
 774
 775 static clib_error_t *
 776 elog_stop (vlib_main_t * vm,
 777            unformat_input_t * input, vlib_cli_command_t * cmd)
 778 {
 779   elog_main_t *em = &vm->elog_main;
 780
 781   em->n_total_events_disable_limit = em->n_total_events;
 782
 783   vlib_cli_output (vm, "Stopped the event logger...");
 784   return 0;
 785 }
 786
 787 /* *INDENT-OFF* */
 788 VLIB_CLI_COMMAND (elog_stop_cli, static) = {
 789   .path = "event-logger stop",
 790   .short_help = "Stop the event-logger",
 791   .function = elog_stop,
 792 };
 793 /* *INDENT-ON* */
 794
 795 static clib_error_t *
 796 elog_restart (vlib_main_t * vm,
 797               unformat_input_t * input, vlib_cli_command_t * cmd)
 798 {
 799   elog_main_t *em = &vm->elog_main;
 800
 801   em->n_total_events_disable_limit = ~0;
 802
 803   vlib_cli_output (vm, "Restarted the event logger...");
 804   return 0;
 805 }
 806
 807 /* *INDENT-OFF* */
 808 VLIB_CLI_COMMAND (elog_restart_cli, static) = {
 809   .path = "event-logger restart",
 810   .short_help = "Restart the event-logger",
 811   .function = elog_restart,
 812 };
 813 /* *INDENT-ON* */
 814
 815 static clib_error_t *
 816 elog_resize (vlib_main_t * vm,
 817              unformat_input_t * input, vlib_cli_command_t * cmd)
 818 {
 819   elog_main_t *em = &vm->elog_main;
 820   u32 tmp;
 821
 822   /* Stop the parade */
 823   elog_reset_buffer (&vm->elog_main);
 824
 825   if (unformat (input, "%d", &tmp))
 826     {
 827       elog_alloc (em, tmp);
 828       em->n_total_events_disable_limit = ~0;
 829     }
 830   else
 831     return clib_error_return (0, "Must specify how many events in the ring");
 832
 833   vlib_cli_output (vm, "Resized ring and restarted the event logger...");
 834   return 0;
 835 }
 836
 837 /* *INDENT-OFF* */
 838 VLIB_CLI_COMMAND (elog_resize_cli, static) = {
 839   .path = "event-logger resize",
 840   .short_help = "event-logger resize <nnn>",
 841   .function = elog_resize,
 842 };
 843 /* *INDENT-ON* */
 844
 845 #endif /* CLIB_UNIX */
 846
 847 static void
 848 elog_show_buffer_internal (vlib_main_t * vm, u32 n_events_to_show)
 849 {
 850   elog_main_t *em = &vm->elog_main;
 851   elog_event_t *e, *es;
 852   f64 dt;
 853
 854   /* Show events in VLIB time since log clock starts after VLIB clock. */
 855   dt = (em->init_time.cpu - vm->clib_time.init_cpu_time)
 856     * vm->clib_time.seconds_per_clock;
 857
 858   es = elog_peek_events (em);
 859   vlib_cli_output (vm, "%d of %d events in buffer, logger %s", vec_len (es),
 860                    em->event_ring_size,
 861                    em->n_total_events < em->n_total_events_disable_limit ?
 862                    "running" : "stopped");
 863   vec_foreach (e, es)
 864   {
 865     vlib_cli_output (vm, "%18.9f: %U",
 866                      e->time + dt, format_elog_event, em, e);
 867     n_events_to_show--;
 868     if (n_events_to_show == 0)
 869       break;
 870   }
 871   vec_free (es);
 872
 873 }
 874
 875 static clib_error_t *
 876 elog_show_buffer (vlib_main_t * vm,
 877                   unformat_input_t * input, vlib_cli_command_t * cmd)
 878 {
 879   u32 n_events_to_show;
 880   clib_error_t *error = 0;
 881
 882   n_events_to_show = 250;
 883   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 884     {
 885       if (unformat (input, "%d", &n_events_to_show))
 886         ;
 887       else if (unformat (input, "all"))
 888         n_events_to_show = ~0;
 889       else
 890         return unformat_parse_error (input);
 891     }
 892   elog_show_buffer_internal (vm, n_events_to_show);
 893   return error;
 894 }
 895
 896 /* *INDENT-OFF* */
 897 VLIB_CLI_COMMAND (elog_show_cli, static) = {
 898   .path = "show event-logger",
 899   .short_help = "Show event logger info",
 900   .function = elog_show_buffer,
 901 };
 902 /* *INDENT-ON* */
 903
 904 void
 905 vlib_gdb_show_event_log (void)
 906 {
 907   elog_show_buffer_internal (vlib_get_main (), (u32) ~ 0);
 908 }
 909
 910 static inline void
 911 vlib_elog_main_loop_event (vlib_main_t * vm,
 912                            u32 node_index,
 913                            u64 time, u32 n_vectors, u32 is_return)
 914 {
 915   vlib_main_t *evm = &vlib_global_main;
 916   elog_main_t *em = &evm->elog_main;
 917   int enabled = evm->elog_trace_graph_dispatch |
 918     evm->elog_trace_graph_circuit;
 919
 920   if (PREDICT_FALSE (enabled && n_vectors))
 921     {
 922       if (PREDICT_FALSE (!elog_is_enabled (em)))
 923         {
 924           evm->elog_trace_graph_dispatch = 0;
 925           evm->elog_trace_graph_circuit = 0;
 926           return;
 927         }
 928       if (PREDICT_TRUE
 929           (evm->elog_trace_graph_dispatch ||
 930            (evm->elog_trace_graph_circuit &&
 931             node_index == evm->elog_trace_graph_circuit_node_index)))
 932         {
 933           elog_track (em,
 934                       /* event type */
 935                       vec_elt_at_index (is_return
 936                                         ? evm->node_return_elog_event_types
 937                                         : evm->node_call_elog_event_types,
 938                                         node_index),
 939                       /* track */
 940                       (vm->thread_index ?
 941                        &vlib_worker_threads[vm->thread_index].elog_track
 942                        : &em->default_track),
 943                       /* data to log */ n_vectors);
 944         }
 945     }
 946 }
 947
 948 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
 949 void (*vlib_buffer_trace_trajectory_cb) (vlib_buffer_t * b, u32 node_index);
 950 void (*vlib_buffer_trace_trajectory_init_cb) (vlib_buffer_t * b);
 951
 952 void
 953 vlib_buffer_trace_trajectory_init (vlib_buffer_t * b)
 954 {
 955   if (PREDICT_TRUE (vlib_buffer_trace_trajectory_init_cb != 0))
 956     {
 957       (*vlib_buffer_trace_trajectory_init_cb) (b);
 958     }
 959 }
 960
 961 #endif
 962
 963 static inline void
 964 add_trajectory_trace (vlib_buffer_t * b, u32 node_index)
 965 {
 966 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
 967   if (PREDICT_TRUE (vlib_buffer_trace_trajectory_cb != 0))
 968     {
 969       (*vlib_buffer_trace_trajectory_cb) (b, node_index);
 970     }
 971 #endif
 972 }
 973
 974 u8 *format_vnet_buffer_flags (u8 * s, va_list * args) __attribute__ ((weak));
 975 u8 *
 976 format_vnet_buffer_flags (u8 * s, va_list * args)
 977 {
 978   s = format (s, "BUG STUB %s", __FUNCTION__);
 979   return s;
 980 }
 981
 982 u8 *format_vnet_buffer_opaque (u8 * s, va_list * args) __attribute__ ((weak));
 983 u8 *
 984 format_vnet_buffer_opaque (u8 * s, va_list * args)
 985 {
 986   s = format (s, "BUG STUB %s", __FUNCTION__);
 987   return s;
 988 }
 989
 990 u8 *format_vnet_buffer_opaque2 (u8 * s, va_list * args)
 991   __attribute__ ((weak));
 992 u8 *
 993 format_vnet_buffer_opaque2 (u8 * s, va_list * args)
 994 {
 995   s = format (s, "BUG STUB %s", __FUNCTION__);
 996   return s;
 997 }
 998
 999 static u8 *
1000 format_buffer_metadata (u8 * s, va_list * args)
1001 {
1002   vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
1003
1004   s = format (s, "flags: %U\n", format_vnet_buffer_flags, b);
1005   s = format (s, "current_data: %d, current_length: %d\n",
1006               (i32) (b->current_data), (i32) (b->current_length));
1007   s = format (s, "current_config_index: %d, flow_id: %x, next_buffer: %x\n",
1008               b->current_config_index, b->flow_id, b->next_buffer);
1009   s = format (s, "error: %d, ref_count: %d, buffer_pool_index: %d\n",
1010               (u32) (b->error), (u32) (b->ref_count),
1011               (u32) (b->buffer_pool_index));
1012   s = format (s,
1013               "trace_handle: 0x%x, len_not_first_buf: %d\n",
1014               b->trace_handle, b->total_length_not_including_first_buffer);
1015   return s;
1016 }
1017
1018 #define A(x) vec_add1(vm->pcap_buffer, (x))
1019
1020 static void
1021 dispatch_pcap_trace (vlib_main_t * vm,
1022                      vlib_node_runtime_t * node, vlib_frame_t * frame)
1023 {
1024   int i;
1025   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **bufp, *b;
1026   pcap_main_t *pm = &vlib_global_main.dispatch_pcap_main;
1027   vlib_trace_main_t *tm = &vm->trace_main;
1028   u32 capture_size;
1029   vlib_node_t *n;
1030   i32 n_left;
1031   f64 time_now = vlib_time_now (vm);
1032   u32 *from;
1033   u8 *d;
1034   u8 string_count;
1035
1036   /* Input nodes don't have frames yet */
1037   if (frame == 0 || frame->n_vectors == 0)
1038     return;
1039
1040   from = vlib_frame_vector_args (frame);
1041   vlib_get_buffers (vm, from, bufs, frame->n_vectors);
1042   bufp = bufs;
1043
1044   n = vlib_get_node (vm, node->node_index);
1045
1046   for (i = 0; i < frame->n_vectors; i++)
1047     {
1048       if (PREDICT_TRUE (pm->n_packets_captured < pm->n_packets_to_capture))
1049         {
1050           b = bufp[i];
1051
1052           vec_reset_length (vm->pcap_buffer);
1053           string_count = 0;
1054
1055           /* Version, flags */
1056           A ((u8) VLIB_PCAP_MAJOR_VERSION);
1057           A ((u8) VLIB_PCAP_MINOR_VERSION);
1058           A (0 /* string_count */ );
1059           A (n->protocol_hint);
1060
1061           /* Buffer index (big endian) */
1062           A ((from[i] >> 24) & 0xff);
1063           A ((from[i] >> 16) & 0xff);
1064           A ((from[i] >> 8) & 0xff);
1065           A ((from[i] >> 0) & 0xff);
1066
1067           /* Node name, NULL-terminated ASCII */
1068           vm->pcap_buffer = format (vm->pcap_buffer, "%v%c", n->name, 0);
1069           string_count++;
1070
1071           vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
1072                                     format_buffer_metadata, b, 0);
1073           string_count++;
1074           vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
1075                                     format_vnet_buffer_opaque, b, 0);
1076           string_count++;
1077           vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
1078                                     format_vnet_buffer_opaque2, b, 0);
1079           string_count++;
1080
1081           /* Is this packet traced? */
1082           if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
1083             {
1084               vlib_trace_header_t **h
1085                 = pool_elt_at_index (tm->trace_buffer_pool,
1086                                      vlib_buffer_get_trace_index (b));
1087
1088               vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
1089                                         format_vlib_trace, vm, h[0], 0);
1090               string_count++;
1091             }
1092
1093           /* Save the string count */
1094           vm->pcap_buffer[2] = string_count;
1095
1096           /* Figure out how many bytes in the pcap trace */
1097           capture_size = vec_len (vm->pcap_buffer) +
1098             +vlib_buffer_length_in_chain (vm, b);
1099
1100           clib_spinlock_lock_if_init (&pm->lock);
1101           n_left = clib_min (capture_size, 16384);
1102           d = pcap_add_packet (pm, time_now, n_left, capture_size);
1103
1104           /* Copy the header */
1105           clib_memcpy_fast (d, vm->pcap_buffer, vec_len (vm->pcap_buffer));
1106           d += vec_len (vm->pcap_buffer);
1107
1108           n_left = clib_min
1109             (vlib_buffer_length_in_chain (vm, b),
1110              (16384 - vec_len (vm->pcap_buffer)));
1111           /* Copy the packet data */
1112           while (1)
1113             {
1114               u32 copy_length = clib_min ((u32) n_left, b->current_length);
1115               clib_memcpy_fast (d, b->data + b->current_data, copy_length);
1116               n_left -= b->current_length;
1117               if (n_left <= 0)
1118                 break;
1119               d += b->current_length;
1120               ASSERT (b->flags & VLIB_BUFFER_NEXT_PRESENT);
1121               b = vlib_get_buffer (vm, b->next_buffer);
1122             }
1123           clib_spinlock_unlock_if_init (&pm->lock);
1124         }
1125     }
1126 }
1127
1128 static_always_inline u64
1129 dispatch_node (vlib_main_t * vm,
1130                vlib_node_runtime_t * node,
1131                vlib_node_type_t type,
1132                vlib_node_state_t dispatch_state,
1133                vlib_frame_t * frame, u64 last_time_stamp)
1134 {
1135   uword n, v;
1136   u64 t;
1137   vlib_node_main_t *nm = &vm->node_main;
1138   vlib_next_frame_t *nf;
1139   u64 pmc_before[2], pmc_after[2], pmc_delta[2];
1140
1141   if (CLIB_DEBUG > 0)
1142     {
1143       vlib_node_t *n = vlib_get_node (vm, node->node_index);
1144       ASSERT (n->type == type);
1145     }
1146
1147   /* Only non-internal nodes may be disabled. */
1148   if (type != VLIB_NODE_TYPE_INTERNAL && node->state != dispatch_state)
1149     {
1150       ASSERT (type != VLIB_NODE_TYPE_INTERNAL);
1151       return last_time_stamp;
1152     }
1153
1154   if ((type == VLIB_NODE_TYPE_PRE_INPUT || type == VLIB_NODE_TYPE_INPUT)
1155       && dispatch_state != VLIB_NODE_STATE_INTERRUPT)
1156     {
1157       u32 c = node->input_main_loops_per_call;
1158       /* Only call node when count reaches zero. */
1159       if (c)
1160         {
1161           node->input_main_loops_per_call = c - 1;
1162           return last_time_stamp;
1163         }
1164     }
1165
1166   /* Speculatively prefetch next frames. */
1167   if (node->n_next_nodes > 0)
1168     {
1169       nf = vec_elt_at_index (nm->next_frames, node->next_frame_index);
1170       CLIB_PREFETCH (nf, 4 * sizeof (nf[0]), WRITE);
1171     }
1172
1173   vm->cpu_time_last_node_dispatch = last_time_stamp;
1174
1175   vlib_elog_main_loop_event (vm, node->node_index,
1176                              last_time_stamp, frame ? frame->n_vectors : 0,
1177                              /* is_after */ 0);
1178
1179   vlib_node_runtime_perf_counter (vm, &pmc_before[0], &pmc_before[1],
1180                                   node, frame, 0 /* before */ );
1181
1182   /*
1183    * Turn this on if you run into
1184    * "bad monkey" contexts, and you want to know exactly
1185    * which nodes they've visited... See ixge.c...
1186    */
1187   if (VLIB_BUFFER_TRACE_TRAJECTORY && frame)
1188     {
1189       int i;
1190       u32 *from;
1191       from = vlib_frame_vector_args (frame);
1192       for (i = 0; i < frame->n_vectors; i++)
1193         {
1194           vlib_buffer_t *b = vlib_get_buffer (vm, from[i]);
1195           add_trajectory_trace (b, node->node_index);
1196         }
1197       if (PREDICT_FALSE (vm->dispatch_pcap_enable))
1198         dispatch_pcap_trace (vm, node, frame);
1199       n = node->function (vm, node, frame);
1200     }
1201   else
1202     {
1203       if (PREDICT_FALSE (vm->dispatch_pcap_enable))
1204         dispatch_pcap_trace (vm, node, frame);
1205       n = node->function (vm, node, frame);
1206     }
1207
1208   t = clib_cpu_time_now ();
1209
1210   /*
1211    * To validate accounting: pmc_delta = t - pmc_before;
1212    * perf ticks should equal clocks/pkt...
1213    */
1214   vlib_node_runtime_perf_counter (vm, &pmc_after[0], &pmc_after[1], node,
1215                                   frame, 1 /* after */ );
1216
1217   pmc_delta[0] = pmc_after[0] - pmc_before[0];
1218   pmc_delta[1] = pmc_after[1] - pmc_before[1];
1219
1220   vlib_elog_main_loop_event (vm, node->node_index, t, n, 1 /* is_after */ );
1221
1222   vm->main_loop_vectors_processed += n;
1223   vm->main_loop_nodes_processed += n > 0;
1224
1225   v = vlib_node_runtime_update_stats (vm, node,
1226                                       /* n_calls */ 1,
1227                                       /* n_vectors */ n,
1228                                       /* n_clocks */ t - last_time_stamp,
1229                                       pmc_delta[0] /* PMC0 */ ,
1230                                       pmc_delta[1] /* PMC1 */ );
1231
1232   /* When in interrupt mode and vector rate crosses threshold switch to
1233      polling mode. */
1234   if (PREDICT_FALSE ((dispatch_state == VLIB_NODE_STATE_INTERRUPT)
1235                      || (dispatch_state == VLIB_NODE_STATE_POLLING
1236                          && (node->flags
1237                              &
1238                              VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE))))
1239     {
1240       /* *INDENT-OFF* */
1241       ELOG_TYPE_DECLARE (e) =
1242         {
1243           .function = (char *) __FUNCTION__,
1244           .format = "%s vector length %d, switching to %s",
1245           .format_args = "T4i4t4",
1246           .n_enum_strings = 2,
1247           .enum_strings = {
1248             "interrupt", "polling",
1249           },
1250         };
1251       /* *INDENT-ON* */
1252       struct
1253       {
1254         u32 node_name, vector_length, is_polling;
1255       } *ed;
1256
1257       if ((dispatch_state == VLIB_NODE_STATE_INTERRUPT
1258            && v >= nm->polling_threshold_vector_length) &&
1259           !(node->flags &
1260             VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE))
1261         {
1262           vlib_node_t *n = vlib_get_node (vm, node->node_index);
1263           n->state = VLIB_NODE_STATE_POLLING;
1264           node->state = VLIB_NODE_STATE_POLLING;
1265           node->flags &=
1266             ~VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE;
1267           node->flags |= VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE;
1268           nm->input_node_counts_by_state[VLIB_NODE_STATE_INTERRUPT] -= 1;
1269           nm->input_node_counts_by_state[VLIB_NODE_STATE_POLLING] += 1;
1270
1271           if (PREDICT_FALSE (vlib_global_main.elog_trace_graph_dispatch))
1272             {
1273               vlib_worker_thread_t *w = vlib_worker_threads
1274                 + vm->thread_index;
1275
1276               ed = ELOG_TRACK_DATA (&vlib_global_main.elog_main, e,
1277                                     w->elog_track);
1278               ed->node_name = n->name_elog_string;
1279               ed->vector_length = v;
1280               ed->is_polling = 1;
1281             }
1282         }
1283       else if (dispatch_state == VLIB_NODE_STATE_POLLING
1284                && v <= nm->interrupt_threshold_vector_length)
1285         {
1286           vlib_node_t *n = vlib_get_node (vm, node->node_index);
1287           if (node->flags &
1288               VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE)
1289             {
1290               /* Switch to interrupt mode after dispatch in polling one more time.
1291                  This allows driver to re-enable interrupts. */
1292               n->state = VLIB_NODE_STATE_INTERRUPT;
1293               node->state = VLIB_NODE_STATE_INTERRUPT;
1294               node->flags &=
1295                 ~VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE;
1296               nm->input_node_counts_by_state[VLIB_NODE_STATE_POLLING] -= 1;
1297               nm->input_node_counts_by_state[VLIB_NODE_STATE_INTERRUPT] += 1;
1298
1299             }
1300           else
1301             {
1302               vlib_worker_thread_t *w = vlib_worker_threads
1303                 + vm->thread_index;
1304               node->flags |=
1305                 VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE;
1306               if (PREDICT_FALSE (vlib_global_main.elog_trace_graph_dispatch))
1307                 {
1308                   ed = ELOG_TRACK_DATA (&vlib_global_main.elog_main, e,
1309                                         w->elog_track);
1310                   ed->node_name = n->name_elog_string;
1311                   ed->vector_length = v;
1312                   ed->is_polling = 0;
1313                 }
1314             }
1315         }
1316     }
1317
1318   return t;
1319 }
1320
1321 static u64
1322 dispatch_pending_node (vlib_main_t * vm, uword pending_frame_index,
1323                        u64 last_time_stamp)
1324 {
1325   vlib_node_main_t *nm = &vm->node_main;
1326   vlib_frame_t *f;
1327   vlib_next_frame_t *nf, nf_dummy;
1328   vlib_node_runtime_t *n;
1329   vlib_frame_t *restore_frame;
1330   vlib_pending_frame_t *p;
1331
1332   /* See comment below about dangling references to nm->pending_frames */
1333   p = nm->pending_frames + pending_frame_index;
1334
1335   n = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INTERNAL],
1336                         p->node_runtime_index);
1337
1338   f = vlib_get_frame (vm, p->frame);
1339   if (p->next_frame_index == VLIB_PENDING_FRAME_NO_NEXT_FRAME)
1340     {
1341       /* No next frame: so use dummy on stack. */
1342       nf = &nf_dummy;
1343       nf->flags = f->frame_flags & VLIB_NODE_FLAG_TRACE;
1344       nf->frame = NULL;
1345     }
1346   else
1347     nf = vec_elt_at_index (nm->next_frames, p->next_frame_index);
1348
1349   ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
1350
1351   /* Force allocation of new frame while current frame is being
1352      dispatched. */
1353   restore_frame = NULL;
1354   if (nf->frame == p->frame)
1355     {
1356       nf->frame = NULL;
1357       nf->flags &= ~VLIB_FRAME_IS_ALLOCATED;
1358       if (!(n->flags & VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH))
1359         restore_frame = p->frame;
1360     }
1361
1362   /* Frame must be pending. */
1363   ASSERT (f->frame_flags & VLIB_FRAME_PENDING);
1364   ASSERT (f->n_vectors > 0);
1365
1366   /* Copy trace flag from next frame to node.
1367      Trace flag indicates that at least one vector in the dispatched
1368      frame is traced. */
1369   n->flags &= ~VLIB_NODE_FLAG_TRACE;
1370   n->flags |= (nf->flags & VLIB_FRAME_TRACE) ? VLIB_NODE_FLAG_TRACE : 0;
1371   nf->flags &= ~VLIB_FRAME_TRACE;
1372
1373   last_time_stamp = dispatch_node (vm, n,
1374                                    VLIB_NODE_TYPE_INTERNAL,
1375                                    VLIB_NODE_STATE_POLLING,
1376                                    f, last_time_stamp);
1377   /* Internal node vector-rate accounting, for summary stats */
1378   vm->internal_node_vectors += f->n_vectors;
1379   vm->internal_node_calls++;
1380   vm->internal_node_last_vectors_per_main_loop =
1381     (f->n_vectors > vm->internal_node_last_vectors_per_main_loop) ?
1382     f->n_vectors : vm->internal_node_last_vectors_per_main_loop;
1383
1384   f->frame_flags &= ~(VLIB_FRAME_PENDING | VLIB_FRAME_NO_APPEND);
1385
1386   /* Frame is ready to be used again, so restore it. */
1387   if (restore_frame != NULL)
1388     {
1389       /*
1390        * We musn't restore a frame that is flagged to be freed. This
1391        * shouldn't happen since frames to be freed post dispatch are
1392        * those used when the to-node frame becomes full i.e. they form a
1393        * sort of queue of frames to a single node. If we get here then
1394        * the to-node frame and the pending frame *were* the same, and so
1395        * we removed the to-node frame.  Therefore this frame is no
1396        * longer part of the queue for that node and hence it cannot be
1397        * it's overspill.
1398        */
1399       ASSERT (!(f->frame_flags & VLIB_FRAME_FREE_AFTER_DISPATCH));
1400
1401       /*
1402        * NB: dispatching node n can result in the creation and scheduling
1403        * of new frames, and hence in the reallocation of nm->pending_frames.
1404        * Recompute p, or no supper. This was broken for more than 10 years.
1405        */
1406       p = nm->pending_frames + pending_frame_index;
1407
1408       /*
1409        * p->next_frame_index can change during node dispatch if node
1410        * function decides to change graph hook up.
1411        */
1412       nf = vec_elt_at_index (nm->next_frames, p->next_frame_index);
1413       nf->flags |= VLIB_FRAME_IS_ALLOCATED;
1414
1415       if (NULL == nf->frame)
1416         {
1417           /* no new frame has been assigned to this node, use the saved one */
1418           nf->frame = restore_frame;
1419           f->n_vectors = 0;
1420         }
1421       else
1422         {
1423           /* The node has gained a frame, implying packets from the current frame
1424              were re-queued to this same node. we don't need the saved one
1425              anymore */
1426           vlib_frame_free (vm, n, f);
1427         }
1428     }
1429   else
1430     {
1431       if (f->frame_flags & VLIB_FRAME_FREE_AFTER_DISPATCH)
1432         {
1433           ASSERT (!(n->flags & VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH));
1434           vlib_frame_free (vm, n, f);
1435         }
1436     }
1437
1438   return last_time_stamp;
1439 }
1440
1441 always_inline uword
1442 vlib_process_stack_is_valid (vlib_process_t * p)
1443 {
1444   return p->stack[0] == VLIB_PROCESS_STACK_MAGIC;
1445 }
1446
1447 typedef struct
1448 {
1449   vlib_main_t *vm;
1450   vlib_process_t *process;
1451   vlib_frame_t *frame;
1452 } vlib_process_bootstrap_args_t;
1453
1454 /* Called in process stack. */
1455 static uword
1456 vlib_process_bootstrap (uword _a)
1457 {
1458   vlib_process_bootstrap_args_t *a;
1459   vlib_main_t *vm;
1460   vlib_node_runtime_t *node;
1461   vlib_frame_t *f;
1462   vlib_process_t *p;
1463   uword n;
1464
1465   a = uword_to_pointer (_a, vlib_process_bootstrap_args_t *);
1466
1467   vm = a->vm;
1468   p = a->process;
1469   f = a->frame;
1470   node = &p->node_runtime;
1471
1472   n = node->function (vm, node, f);
1473
1474   ASSERT (vlib_process_stack_is_valid (p));
1475
1476   clib_longjmp (&p->return_longjmp, n);
1477
1478   return n;
1479 }
1480
1481 /* Called in main stack. */
1482 static_always_inline uword
1483 vlib_process_startup (vlib_main_t * vm, vlib_process_t * p, vlib_frame_t * f)
1484 {
1485   vlib_process_bootstrap_args_t a;
1486   uword r;
1487
1488   a.vm = vm;
1489   a.process = p;
1490   a.frame = f;
1491
1492   r = clib_setjmp (&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_RETURN);
1493   if (r == VLIB_PROCESS_RETURN_LONGJMP_RETURN)
1494     r = clib_calljmp (vlib_process_bootstrap, pointer_to_uword (&a),
1495                       (void *) p->stack + (1 << p->log2_n_stack_bytes));
1496
1497   return r;
1498 }
1499
1500 static_always_inline uword
1501 vlib_process_resume (vlib_process_t * p)
1502 {
1503   uword r;
1504   p->flags &= ~(VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
1505                 | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
1506                 | VLIB_PROCESS_RESUME_PENDING);
1507   r = clib_setjmp (&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_RETURN);
1508   if (r == VLIB_PROCESS_RETURN_LONGJMP_RETURN)
1509     clib_longjmp (&p->resume_longjmp, VLIB_PROCESS_RESUME_LONGJMP_RESUME);
1510   return r;
1511 }
1512
1513 static u64
1514 dispatch_process (vlib_main_t * vm,
1515                   vlib_process_t * p, vlib_frame_t * f, u64 last_time_stamp)
1516 {
1517   vlib_node_main_t *nm = &vm->node_main;
1518   vlib_node_runtime_t *node_runtime = &p->node_runtime;
1519   vlib_node_t *node = vlib_get_node (vm, node_runtime->node_index);
1520   u32 old_process_index;
1521   u64 t;
1522   uword n_vectors, is_suspend;
1523
1524   if (node->state != VLIB_NODE_STATE_POLLING
1525       || (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
1526                       | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT)))
1527     return last_time_stamp;
1528
1529   p->flags |= VLIB_PROCESS_IS_RUNNING;
1530
1531   t = last_time_stamp;
1532   vlib_elog_main_loop_event (vm, node_runtime->node_index, t,
1533                              f ? f->n_vectors : 0, /* is_after */ 0);
1534
1535   /* Save away current process for suspend. */
1536   old_process_index = nm->current_process_index;
1537   nm->current_process_index = node->runtime_index;
1538
1539   n_vectors = vlib_process_startup (vm, p, f);
1540
1541   nm->current_process_index = old_process_index;
1542
1543   ASSERT (n_vectors != VLIB_PROCESS_RETURN_LONGJMP_RETURN);
1544   is_suspend = n_vectors == VLIB_PROCESS_RETURN_LONGJMP_SUSPEND;
1545   if (is_suspend)
1546     {
1547       vlib_pending_frame_t *pf;
1548
1549       n_vectors = 0;
1550       pool_get (nm->suspended_process_frames, pf);
1551       pf->node_runtime_index = node->runtime_index;
1552       pf->frame = f;
1553       pf->next_frame_index = ~0;
1554
1555       p->n_suspends += 1;
1556       p->suspended_process_frame_index = pf - nm->suspended_process_frames;
1557
1558       if (p->flags & VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK)
1559         {
1560           TWT (tw_timer_wheel) * tw =
1561             (TWT (tw_timer_wheel) *) nm->timing_wheel;
1562           p->stop_timer_handle =
1563             TW (tw_timer_start) (tw,
1564                                  vlib_timing_wheel_data_set_suspended_process
1565                                  (node->runtime_index) /* [sic] pool idex */ ,
1566                                  0 /* timer_id */ ,
1567                                  p->resume_clock_interval);
1568         }
1569     }
1570   else
1571     p->flags &= ~VLIB_PROCESS_IS_RUNNING;
1572
1573   t = clib_cpu_time_now ();
1574
1575   vlib_elog_main_loop_event (vm, node_runtime->node_index, t, is_suspend,
1576                              /* is_after */ 1);
1577
1578   vlib_process_update_stats (vm, p,
1579                              /* n_calls */ !is_suspend,
1580                              /* n_vectors */ n_vectors,
1581                              /* n_clocks */ t - last_time_stamp);
1582
1583   return t;
1584 }
1585
1586 void
1587 vlib_start_process (vlib_main_t * vm, uword process_index)
1588 {
1589   vlib_node_main_t *nm = &vm->node_main;
1590   vlib_process_t *p = vec_elt (nm->processes, process_index);
1591   dispatch_process (vm, p, /* frame */ 0, /* cpu_time_now */ 0);
1592 }
1593
1594 static u64
1595 dispatch_suspended_process (vlib_main_t * vm,
1596                             uword process_index, u64 last_time_stamp)
1597 {
1598   vlib_node_main_t *nm = &vm->node_main;
1599   vlib_node_runtime_t *node_runtime;
1600   vlib_node_t *node;
1601   vlib_frame_t *f;
1602   vlib_process_t *p;
1603   vlib_pending_frame_t *pf;
1604   u64 t, n_vectors, is_suspend;
1605
1606   t = last_time_stamp;
1607
1608   p = vec_elt (nm->processes, process_index);
1609   if (PREDICT_FALSE (!(p->flags & VLIB_PROCESS_IS_RUNNING)))
1610     return last_time_stamp;
1611
1612   ASSERT (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
1613                       | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT));
1614
1615   pf = pool_elt_at_index (nm->suspended_process_frames,
1616                           p->suspended_process_frame_index);
1617
1618   node_runtime = &p->node_runtime;
1619   node = vlib_get_node (vm, node_runtime->node_index);
1620   f = pf->frame;
1621
1622   vlib_elog_main_loop_event (vm, node_runtime->node_index, t,
1623                              f ? f->n_vectors : 0, /* is_after */ 0);
1624
1625   /* Save away current process for suspend. */
1626   nm->current_process_index = node->runtime_index;
1627
1628   n_vectors = vlib_process_resume (p);
1629   t = clib_cpu_time_now ();
1630
1631   nm->current_process_index = ~0;
1632
1633   is_suspend = n_vectors == VLIB_PROCESS_RETURN_LONGJMP_SUSPEND;
1634   if (is_suspend)
1635     {
1636       /* Suspend it again. */
1637       n_vectors = 0;
1638       p->n_suspends += 1;
1639       if (p->flags & VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK)
1640         {
1641           p->stop_timer_handle =
1642             TW (tw_timer_start) ((TWT (tw_timer_wheel) *) nm->timing_wheel,
1643                                  vlib_timing_wheel_data_set_suspended_process
1644                                  (node->runtime_index) /* [sic] pool idex */ ,
1645                                  0 /* timer_id */ ,
1646                                  p->resume_clock_interval);
1647         }
1648     }
1649   else
1650     {
1651       p->flags &= ~VLIB_PROCESS_IS_RUNNING;
1652       pool_put_index (nm->suspended_process_frames,
1653                       p->suspended_process_frame_index);
1654       p->suspended_process_frame_index = ~0;
1655     }
1656
1657   t = clib_cpu_time_now ();
1658   vlib_elog_main_loop_event (vm, node_runtime->node_index, t, !is_suspend,
1659                              /* is_after */ 1);
1660
1661   vlib_process_update_stats (vm, p,
1662                              /* n_calls */ !is_suspend,
1663                              /* n_vectors */ n_vectors,
1664                              /* n_clocks */ t - last_time_stamp);
1665
1666   return t;
1667 }
1668
1669 void vl_api_send_pending_rpc_requests (vlib_main_t *) __attribute__ ((weak));
1670 void
1671 vl_api_send_pending_rpc_requests (vlib_main_t * vm)
1672 {
1673 }
1674
1675
1676 static_always_inline void
1677 vlib_main_or_worker_loop (vlib_main_t * vm, int is_main)
1678 {
1679   vlib_node_main_t *nm = &vm->node_main;
1680   vlib_thread_main_t *tm = vlib_get_thread_main ();
1681   uword i;
1682   u64 cpu_time_now;
1683   vlib_frame_queue_main_t *fqm;
1684   u32 *last_node_runtime_indices = 0;
1685   u32 frame_queue_check_counter = 0;
1686
1687   /* Initialize pending node vector. */
1688   if (is_main)
1689     {
1690       vec_resize (nm->pending_frames, 32);
1691       _vec_len (nm->pending_frames) = 0;
1692     }
1693
1694   /* Mark time of main loop start. */
1695   if (is_main)
1696     {
1697       cpu_time_now = vm->clib_time.last_cpu_time;
1698       vm->cpu_time_main_loop_start = cpu_time_now;
1699     }
1700   else
1701     cpu_time_now = clib_cpu_time_now ();
1702
1703   /* Pre-allocate interupt runtime indices and lock. */
1704   vec_alloc (nm->pending_interrupt_node_runtime_indices, 32);
1705   vec_alloc (last_node_runtime_indices, 32);
1706   if (!is_main)
1707     clib_spinlock_init (&nm->pending_interrupt_lock);
1708
1709   /* Pre-allocate expired nodes. */
1710   if (!nm->polling_threshold_vector_length)
1711     nm->polling_threshold_vector_length = 10;
1712   if (!nm->interrupt_threshold_vector_length)
1713     nm->interrupt_threshold_vector_length = 5;
1714
1715   vm->cpu_id = clib_get_current_cpu_id ();
1716   vm->numa_node = clib_get_current_numa_node ();
1717
1718   /* Start all processes. */
1719   if (is_main)
1720     {
1721       uword i;
1722
1723       /*
1724        * Perform an initial barrier sync. Pays no attention to
1725        * the barrier sync hold-down timer scheme, which won't work
1726        * at this point in time.
1727        */
1728       vlib_worker_thread_initial_barrier_sync_and_release (vm);
1729
1730       nm->current_process_index = ~0;
1731       for (i = 0; i < vec_len (nm->processes); i++)
1732         cpu_time_now = dispatch_process (vm, nm->processes[i], /* frame */ 0,
1733                                          cpu_time_now);
1734     }
1735
1736   while (1)
1737     {
1738       vlib_node_runtime_t *n;
1739
1740       if (PREDICT_FALSE (_vec_len (vm->pending_rpc_requests) > 0))
1741         {
1742           if (!is_main)
1743             vl_api_send_pending_rpc_requests (vm);
1744         }
1745
1746       if (!is_main)
1747         {
1748           vlib_worker_thread_barrier_check ();
1749           if (PREDICT_FALSE (vm->check_frame_queues +
1750                              frame_queue_check_counter))
1751             {
1752               u32 processed = 0;
1753
1754               if (vm->check_frame_queues)
1755                 {
1756                   frame_queue_check_counter = 100;
1757                   vm->check_frame_queues = 0;
1758                 }
1759
1760               vec_foreach (fqm, tm->frame_queue_mains)
1761                 processed += vlib_frame_queue_dequeue (vm, fqm);
1762
1763               /* No handoff queue work found? */
1764               if (processed)
1765                 frame_queue_check_counter = 100;
1766               else
1767                 frame_queue_check_counter--;
1768             }
1769           if (PREDICT_FALSE (vec_len (vm->worker_thread_main_loop_callbacks)))
1770             clib_call_callbacks (vm->worker_thread_main_loop_callbacks, vm);
1771         }
1772
1773       /* Process pre-input nodes. */
1774       vec_foreach (n, nm->nodes_by_type[VLIB_NODE_TYPE_PRE_INPUT])
1775         cpu_time_now = dispatch_node (vm, n,
1776                                       VLIB_NODE_TYPE_PRE_INPUT,
1777                                       VLIB_NODE_STATE_POLLING,
1778                                       /* frame */ 0,
1779                                       cpu_time_now);
1780
1781       /* Next process input nodes. */
1782       vec_foreach (n, nm->nodes_by_type[VLIB_NODE_TYPE_INPUT])
1783         cpu_time_now = dispatch_node (vm, n,
1784                                       VLIB_NODE_TYPE_INPUT,
1785                                       VLIB_NODE_STATE_POLLING,
1786                                       /* frame */ 0,
1787                                       cpu_time_now);
1788
1789       if (PREDICT_TRUE (is_main && vm->queue_signal_pending == 0))
1790         vm->queue_signal_callback (vm);
1791
1792       /* Next handle interrupts. */
1793       {
1794         /* unlocked read, for performance */
1795         uword l = _vec_len (nm->pending_interrupt_node_runtime_indices);
1796         uword i;
1797         if (PREDICT_FALSE (l > 0))
1798           {
1799             u32 *tmp;
1800             if (!is_main)
1801               {
1802                 clib_spinlock_lock (&nm->pending_interrupt_lock);
1803                 /* Re-read w/ lock held, in case another thread added an item */
1804                 l = _vec_len (nm->pending_interrupt_node_runtime_indices);
1805               }
1806
1807             tmp = nm->pending_interrupt_node_runtime_indices;
1808             nm->pending_interrupt_node_runtime_indices =
1809               last_node_runtime_indices;
1810             last_node_runtime_indices = tmp;
1811             _vec_len (last_node_runtime_indices) = 0;
1812             if (!is_main)
1813               clib_spinlock_unlock (&nm->pending_interrupt_lock);
1814             for (i = 0; i < l; i++)
1815               {
1816                 n = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INPUT],
1817                                       last_node_runtime_indices[i]);
1818                 cpu_time_now =
1819                   dispatch_node (vm, n, VLIB_NODE_TYPE_INPUT,
1820                                  VLIB_NODE_STATE_INTERRUPT,
1821                                  /* frame */ 0,
1822                                  cpu_time_now);
1823               }
1824           }
1825       }
1826       /* Input nodes may have added work to the pending vector.
1827          Process pending vector until there is nothing left.
1828          All pending vectors will be processed from input -> output. */
1829       for (i = 0; i < _vec_len (nm->pending_frames); i++)
1830         cpu_time_now = dispatch_pending_node (vm, i, cpu_time_now);
1831       /* Reset pending vector for next iteration. */
1832       _vec_len (nm->pending_frames) = 0;
1833
1834       if (is_main)
1835         {
1836           /* *INDENT-OFF* */
1837           ELOG_TYPE_DECLARE (es) =
1838             {
1839               .format = "process tw start",
1840               .format_args = "",
1841             };
1842           ELOG_TYPE_DECLARE (ee) =
1843             {
1844               .format = "process tw end: %d",
1845               .format_args = "i4",
1846             };
1847           /* *INDENT-ON* */
1848
1849           struct
1850           {
1851             int nready_procs;
1852           } *ed;
1853
1854           /* Check if process nodes have expired from timing wheel. */
1855           ASSERT (nm->data_from_advancing_timing_wheel != 0);
1856
1857           if (PREDICT_FALSE (vm->elog_trace_graph_dispatch))
1858             ed = ELOG_DATA (&vlib_global_main.elog_main, es);
1859
1860           nm->data_from_advancing_timing_wheel =
1861             TW (tw_timer_expire_timers_vec)
1862             ((TWT (tw_timer_wheel) *) nm->timing_wheel, vlib_time_now (vm),
1863              nm->data_from_advancing_timing_wheel);
1864
1865           ASSERT (nm->data_from_advancing_timing_wheel != 0);
1866
1867           if (PREDICT_FALSE (vm->elog_trace_graph_dispatch))
1868             {
1869               ed = ELOG_DATA (&vlib_global_main.elog_main, ee);
1870               ed->nready_procs =
1871                 _vec_len (nm->data_from_advancing_timing_wheel);
1872             }
1873
1874           if (PREDICT_FALSE
1875               (_vec_len (nm->data_from_advancing_timing_wheel) > 0))
1876             {
1877               uword i;
1878
1879               for (i = 0; i < _vec_len (nm->data_from_advancing_timing_wheel);
1880                    i++)
1881                 {
1882                   u32 d = nm->data_from_advancing_timing_wheel[i];
1883                   u32 di = vlib_timing_wheel_data_get_index (d);
1884
1885                   if (vlib_timing_wheel_data_is_timed_event (d))
1886                     {
1887                       vlib_signal_timed_event_data_t *te =
1888                         pool_elt_at_index (nm->signal_timed_event_data_pool,
1889                                            di);
1890                       vlib_node_t *n =
1891                         vlib_get_node (vm, te->process_node_index);
1892                       vlib_process_t *p =
1893                         vec_elt (nm->processes, n->runtime_index);
1894                       void *data;
1895                       data =
1896                         vlib_process_signal_event_helper (nm, n, p,
1897                                                           te->event_type_index,
1898                                                           te->n_data_elts,
1899                                                           te->n_data_elt_bytes);
1900                       if (te->n_data_bytes < sizeof (te->inline_event_data))
1901                         clib_memcpy_fast (data, te->inline_event_data,
1902                                           te->n_data_bytes);
1903                       else
1904                         {
1905                           clib_memcpy_fast (data, te->event_data_as_vector,
1906                                             te->n_data_bytes);
1907                           vec_free (te->event_data_as_vector);
1908                         }
1909                       pool_put (nm->signal_timed_event_data_pool, te);
1910                     }
1911                   else
1912                     {
1913                       cpu_time_now = clib_cpu_time_now ();
1914                       cpu_time_now =
1915                         dispatch_suspended_process (vm, di, cpu_time_now);
1916                     }
1917                 }
1918               _vec_len (nm->data_from_advancing_timing_wheel) = 0;
1919             }
1920         }
1921       vlib_increment_main_loop_counter (vm);
1922       /* Record time stamp in case there are no enabled nodes and above
1923          calls do not update time stamp. */
1924       cpu_time_now = clib_cpu_time_now ();
1925     }
1926 }
1927
1928 static void
1929 vlib_main_loop (vlib_main_t * vm)
1930 {
1931   vlib_main_or_worker_loop (vm, /* is_main */ 1);
1932 }
1933
1934 void
1935 vlib_worker_loop (vlib_main_t * vm)
1936 {
1937   vlib_main_or_worker_loop (vm, /* is_main */ 0);
1938 }
1939
1940 vlib_main_t vlib_global_main;
1941
1942 static clib_error_t *
1943 vlib_main_configure (vlib_main_t * vm, unformat_input_t * input)
1944 {
1945   int turn_on_mem_trace = 0;
1946
1947   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1948     {
1949       if (unformat (input, "memory-trace"))
1950         turn_on_mem_trace = 1;
1951
1952       else if (unformat (input, "elog-events %d",
1953                          &vm->elog_main.event_ring_size))
1954         ;
1955       else if (unformat (input, "elog-post-mortem-dump"))
1956         vm->elog_post_mortem_dump = 1;
1957       else
1958         return unformat_parse_error (input);
1959     }
1960
1961   unformat_free (input);
1962
1963   /* Enable memory trace as early as possible. */
1964   if (turn_on_mem_trace)
1965     clib_mem_trace (1);
1966
1967   return 0;
1968 }
1969
1970 VLIB_EARLY_CONFIG_FUNCTION (vlib_main_configure, "vlib");
1971
1972 static void
1973 dummy_queue_signal_callback (vlib_main_t * vm)
1974 {
1975 }
1976
1977 #define foreach_weak_reference_stub             \
1978 _(vlib_map_stat_segment_init)                   \
1979 _(vpe_api_init)                                 \
1980 _(vlibmemory_init)                              \
1981 _(map_api_segment_init)
1982
1983 #define _(name)                                                 \
1984 clib_error_t *name (vlib_main_t *vm) __attribute__((weak));     \
1985 clib_error_t *name (vlib_main_t *vm) { return 0; }
1986 foreach_weak_reference_stub;
1987 #undef _
1988
1989 void vl_api_set_elog_main (elog_main_t * m) __attribute__ ((weak));
1990 void
1991 vl_api_set_elog_main (elog_main_t * m)
1992 {
1993   clib_warning ("STUB");
1994 }
1995
1996 int vl_api_set_elog_trace_api_messages (int enable) __attribute__ ((weak));
1997 int
1998 vl_api_set_elog_trace_api_messages (int enable)
1999 {
2000   clib_warning ("STUB");
2001   return 0;
2002 }
2003
2004 int vl_api_get_elog_trace_api_messages (void) __attribute__ ((weak));
2005 int
2006 vl_api_get_elog_trace_api_messages (void)
2007 {
2008   clib_warning ("STUB");
2009   return 0;
2010 }
2011
2012 /* Main function. */
2013 int
2014 vlib_main (vlib_main_t * volatile vm, unformat_input_t * input)
2015 {
2016   clib_error_t *volatile error;
2017   vlib_node_main_t *nm = &vm->node_main;
2018
2019   vm->queue_signal_callback = dummy_queue_signal_callback;
2020
2021   clib_time_init (&vm->clib_time);
2022
2023   /* Turn on event log. */
2024   if (!vm->elog_main.event_ring_size)
2025     vm->elog_main.event_ring_size = 128 << 10;
2026   elog_init (&vm->elog_main, vm->elog_main.event_ring_size);
2027   elog_enable_disable (&vm->elog_main, 1);
2028   vl_api_set_elog_main (&vm->elog_main);
2029   (void) vl_api_set_elog_trace_api_messages (1);
2030
2031   /* Default name. */
2032   if (!vm->name)
2033     vm->name = "VLIB";
2034
2035   if ((error = vlib_physmem_init (vm)))
2036     {
2037       clib_error_report (error);
2038       goto done;
2039     }
2040
2041   if ((error = vlib_map_stat_segment_init (vm)))
2042     {
2043       clib_error_report (error);
2044       goto done;
2045     }
2046
2047   if ((error = vlib_buffer_main_init (vm)))
2048     {
2049       clib_error_report (error);
2050       goto done;
2051     }
2052
2053   if ((error = vlib_thread_init (vm)))
2054     {
2055       clib_error_report (error);
2056       goto done;
2057     }
2058
2059   /* Register static nodes so that init functions may use them. */
2060   vlib_register_all_static_nodes (vm);
2061
2062   /* Set seed for random number generator.
2063      Allow user to specify seed to make random sequence deterministic. */
2064   if (!unformat (input, "seed %wd", &vm->random_seed))
2065     vm->random_seed = clib_cpu_time_now ();
2066   clib_random_buffer_init (&vm->random_buffer, vm->random_seed);
2067
2068   /* Initialize node graph. */
2069   if ((error = vlib_node_main_init (vm)))
2070     {
2071       /* Arrange for graph hook up error to not be fatal when debugging. */
2072       if (CLIB_DEBUG > 0)
2073         clib_error_report (error);
2074       else
2075         goto done;
2076     }
2077
2078   /* Direct call / weak reference, for vlib standalone use-cases */
2079   if ((error = vpe_api_init (vm)))
2080     {
2081       clib_error_report (error);
2082       goto done;
2083     }
2084
2085   if ((error = vlibmemory_init (vm)))
2086     {
2087       clib_error_report (error);
2088       goto done;
2089     }
2090
2091   if ((error = map_api_segment_init (vm)))
2092     {
2093       clib_error_report (error);
2094       goto done;
2095     }
2096
2097   /* See unix/main.c; most likely already set up */
2098   if (vm->init_functions_called == 0)
2099     vm->init_functions_called = hash_create (0, /* value bytes */ 0);
2100   if ((error = vlib_call_all_init_functions (vm)))
2101     goto done;
2102
2103   nm->timing_wheel = clib_mem_alloc_aligned (sizeof (TWT (tw_timer_wheel)),
2104                                              CLIB_CACHE_LINE_BYTES);
2105
2106   vec_validate (nm->data_from_advancing_timing_wheel, 10);
2107   _vec_len (nm->data_from_advancing_timing_wheel) = 0;
2108
2109   /* Create the process timing wheel */
2110   TW (tw_timer_wheel_init) ((TWT (tw_timer_wheel) *) nm->timing_wheel,
2111                             0 /* no callback */ ,
2112                             10e-6 /* timer period 10us */ ,
2113                             ~0 /* max expirations per call */ );
2114
2115   vec_validate (vm->pending_rpc_requests, 0);
2116   _vec_len (vm->pending_rpc_requests) = 0;
2117   vec_validate (vm->processing_rpc_requests, 0);
2118   _vec_len (vm->processing_rpc_requests) = 0;
2119
2120   if ((error = vlib_call_all_config_functions (vm, input, 0 /* is_early */ )))
2121     goto done;
2122
2123   /* Sort per-thread init functions before we start threads */
2124   vlib_sort_init_exit_functions (&vm->worker_init_function_registrations);
2125
2126   /* Call all main loop enter functions. */
2127   {
2128     clib_error_t *sub_error;
2129     sub_error = vlib_call_all_main_loop_enter_functions (vm);
2130     if (sub_error)
2131       clib_error_report (sub_error);
2132   }
2133
2134   switch (clib_setjmp (&vm->main_loop_exit, VLIB_MAIN_LOOP_EXIT_NONE))
2135     {
2136     case VLIB_MAIN_LOOP_EXIT_NONE:
2137       vm->main_loop_exit_set = 1;
2138       break;
2139
2140     case VLIB_MAIN_LOOP_EXIT_CLI:
2141       goto done;
2142
2143     default:
2144       error = vm->main_loop_error;
2145       goto done;
2146     }
2147
2148   vlib_main_loop (vm);
2149
2150 done:
2151   /* Call all exit functions. */
2152   {
2153     clib_error_t *sub_error;
2154     sub_error = vlib_call_all_main_loop_exit_functions (vm);
2155     if (sub_error)
2156       clib_error_report (sub_error);
2157   }
2158
2159   if (error)
2160     clib_error_report (error);
2161
2162   return 0;
2163 }
2164
2165 int
2166 vlib_pcap_dispatch_trace_configure (vlib_pcap_dispatch_trace_args_t * a)
2167 {
2168   vlib_main_t *vm = vlib_get_main ();
2169   pcap_main_t *pm = &vm->dispatch_pcap_main;
2170   vlib_trace_main_t *tm;
2171   vlib_trace_node_t *tn;
2172
2173   if (a->status)
2174     {
2175       if (vm->dispatch_pcap_enable)
2176         {
2177           int i;
2178           vlib_cli_output
2179             (vm, "pcap dispatch capture enabled: %d of %d pkts...",
2180              pm->n_packets_captured, pm->n_packets_to_capture);
2181           vlib_cli_output (vm, "capture to file %s", pm->file_name);
2182
2183           for (i = 0; i < vec_len (vm->dispatch_buffer_trace_nodes); i++)
2184             {
2185               vlib_cli_output (vm,
2186                                "Buffer trace of %d pkts from %U enabled...",
2187                                a->buffer_traces_to_capture,
2188                                format_vlib_node_name, vm,
2189                                vm->dispatch_buffer_trace_nodes[i]);
2190             }
2191         }
2192       else
2193         vlib_cli_output (vm, "pcap dispatch capture disabled");
2194       return 0;
2195     }
2196
2197   /* Consistency checks */
2198
2199   /* Enable w/ capture already enabled not allowed */
2200   if (vm->dispatch_pcap_enable && a->enable)
2201     return -7;                  /* VNET_API_ERROR_INVALID_VALUE */
2202
2203   /* Disable capture with capture already disabled, not interesting */
2204   if (vm->dispatch_pcap_enable == 0 && a->enable == 0)
2205     return -81;                 /* VNET_API_ERROR_VALUE_EXIST */
2206
2207   /* Change number of packets to capture while capturing */
2208   if (vm->dispatch_pcap_enable && a->enable
2209       && (pm->n_packets_to_capture != a->packets_to_capture))
2210     return -8;                  /* VNET_API_ERROR_INVALID_VALUE_2 */
2211
2212   /* Independent of enable/disable, to allow buffer trace multi nodes */
2213   if (a->buffer_trace_node_index != ~0)
2214     {
2215       /* *INDENT-OFF* */
2216       foreach_vlib_main ((
2217         {
2218           tm = &this_vlib_main->trace_main;
2219           tm->verbose = 0;  /* not sure this ever did anything... */
2220           vec_validate (tm->nodes, a->buffer_trace_node_index);
2221           tn = tm->nodes + a->buffer_trace_node_index;
2222           tn->limit += a->buffer_traces_to_capture;
2223           tm->trace_enable = 1;
2224         }));
2225       /* *INDENT-ON* */
2226       vec_add1 (vm->dispatch_buffer_trace_nodes, a->buffer_trace_node_index);
2227     }
2228
2229   if (a->enable)
2230     {
2231       /* Clean up from previous run, if any */
2232       vec_free (pm->file_name);
2233       vec_free (pm->pcap_data);
2234       memset (pm, 0, sizeof (*pm));
2235
2236       vec_validate_aligned (vnet_trace_dummy, 2048, CLIB_CACHE_LINE_BYTES);
2237       if (pm->lock == 0)
2238         clib_spinlock_init (&(pm->lock));
2239
2240       if (a->filename == 0)
2241         a->filename = format (0, "/tmp/dispatch.pcap%c", 0);
2242
2243       pm->file_name = (char *) a->filename;
2244       pm->n_packets_captured = 0;
2245       pm->packet_type = PCAP_PACKET_TYPE_vpp;
2246       pm->n_packets_to_capture = a->packets_to_capture;
2247       /* *INDENT-OFF* */
2248       foreach_vlib_main (({this_vlib_main->dispatch_pcap_enable = 1;}));
2249       /* *INDENT-ON* */
2250     }
2251   else
2252     {
2253       /* *INDENT-OFF* */
2254       foreach_vlib_main (({this_vlib_main->dispatch_pcap_enable = 0;}));
2255       /* *INDENT-ON* */
2256       vec_reset_length (vm->dispatch_buffer_trace_nodes);
2257       if (pm->n_packets_captured)
2258         {
2259           clib_error_t *error;
2260           pm->n_packets_to_capture = pm->n_packets_captured;
2261           vlib_cli_output (vm, "Write %d packets to %s, and stop capture...",
2262                            pm->n_packets_captured, pm->file_name);
2263           error = pcap_write (pm);
2264           if (pm->flags & PCAP_MAIN_INIT_DONE)
2265             pcap_close (pm);
2266           /* Report I/O errors... */
2267           if (error)
2268             {
2269               clib_error_report (error);
2270               return -11;       /* VNET_API_ERROR_SYSCALL_ERROR_1 */
2271             }
2272           return 0;
2273         }
2274       else
2275         return -6;              /* VNET_API_ERROR_NO_SUCH_ENTRY */
2276     }
2277
2278   return 0;
2279 }
2280
2281 static clib_error_t *
2282 dispatch_trace_command_fn (vlib_main_t * vm,
2283                            unformat_input_t * input, vlib_cli_command_t * cmd)
2284 {
2285   unformat_input_t _line_input, *line_input = &_line_input;
2286   vlib_pcap_dispatch_trace_args_t _a, *a = &_a;
2287   u8 *filename = 0;
2288   u32 max = 1000;
2289   int rv;
2290   int enable = 0;
2291   int status = 0;
2292   u32 node_index = ~0, buffer_traces_to_capture = 100;
2293
2294   /* Get a line of input. */
2295   if (!unformat_user (input, unformat_line_input, line_input))
2296     return 0;
2297
2298   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
2299     {
2300       if (unformat (line_input, "on %=", &enable, 1))
2301         ;
2302       else if (unformat (line_input, "enable %=", &enable, 1))
2303         ;
2304       else if (unformat (line_input, "off %=", &enable, 0))
2305         ;
2306       else if (unformat (line_input, "disable %=", &enable, 0))
2307         ;
2308       else if (unformat (line_input, "max %d", &max))
2309         ;
2310       else if (unformat (line_input, "packets-to-capture %d", &max))
2311         ;
2312       else if (unformat (line_input, "file %U", unformat_vlib_tmpfile,
2313                          &filename))
2314         ;
2315       else if (unformat (line_input, "status %=", &status, 1))
2316         ;
2317       else if (unformat (line_input, "buffer-trace %U %d",
2318                          unformat_vlib_node, vm, &node_index,
2319                          &buffer_traces_to_capture))
2320         ;
2321       else
2322         {
2323           return clib_error_return (0, "unknown input `%U'",
2324                                     format_unformat_error, line_input);
2325         }
2326     }
2327
2328   unformat_free (line_input);
2329
2330   /* no need for memset (a, 0, sizeof (*a)), set all fields here. */
2331   a->filename = filename;
2332   a->enable = enable;
2333   a->status = status;
2334   a->packets_to_capture = max;
2335   a->buffer_trace_node_index = node_index;
2336   a->buffer_traces_to_capture = buffer_traces_to_capture;
2337
2338   rv = vlib_pcap_dispatch_trace_configure (a);
2339
2340   switch (rv)
2341     {
2342     case 0:
2343       break;
2344
2345     case -7:
2346       return clib_error_return (0, "dispatch trace already enabled...");
2347
2348     case -81:
2349       return clib_error_return (0, "dispatch trace already disabled...");
2350
2351     case -8:
2352       return clib_error_return
2353         (0, "can't change number of records to capture while tracing...");
2354
2355     case -11:
2356       return clib_error_return (0, "I/O writing trace capture...");
2357
2358     case -6:
2359       return clib_error_return (0, "No packets captured...");
2360
2361     default:
2362       vlib_cli_output (vm, "WARNING: trace configure returned %d", rv);
2363       break;
2364     }
2365   return 0;
2366 }
2367
2368 /*?
2369  * This command is used to start or stop pcap dispatch trace capture, or show
2370  * the capture status.
2371  *
2372  * This command has the following optional parameters:
2373  *
2374  * - <b>on|off</b> - Used to start or stop capture.
2375  *
2376  * - <b>max <nn></b> - Depth of local buffer. Once '<em>nn</em>' number
2377  *   of packets have been received, buffer is flushed to file. Once another
2378  *   '<em>nn</em>' number of packets have been received, buffer is flushed
2379  *   to file, overwriting previous write. If not entered, value defaults
2380  *   to 100. Can only be updated if packet capture is off.
2381  *
2382  * - <b>file <name></b> - Used to specify the output filename. The file will
2383  *   be placed in the '<em>/tmp</em>' directory, so only the filename is
2384  *   supported. Directory should not be entered. If file already exists, file
2385  *   will be overwritten. If no filename is provided, '<em>/tmp/vpe.pcap</em>'
2386  *   will be used. Can only be updated if packet capture is off.
2387  *
2388  * - <b>status</b> - Displays the current status and configured attributes
2389  *   associated with a packet capture. If packet capture is in progress,
2390  *   '<em>status</em>' also will return the number of packets currently in
2391  *   the local buffer. All additional attributes entered on command line
2392  *   with '<em>status</em>' will be ignored and not applied.
2393  *
2394  * @cliexpar
2395  * Example of how to display the status of capture when off:
2396  * @cliexstart{pcap dispatch trace status}
2397  * max is 100, for any interface to file /tmp/vpe.pcap
2398  * pcap dispatch capture is off...
2399  * @cliexend
2400  * Example of how to start a dispatch trace capture:
2401  * @cliexstart{pcap dispatch trace on max 35 file dispatchTrace.pcap}
2402  * pcap dispatch capture on...
2403  * @cliexend
2404  * Example of how to start a dispatch trace capture with buffer tracing
2405  * @cliexstart{pcap dispatch trace on max 10000 file dispatchTrace.pcap buffer-trace dpdk-input 1000}
2406  * pcap dispatch capture on...
2407  * @cliexend
2408  * Example of how to display the status of a tx packet capture in progress:
2409  * @cliexstart{pcap tx trace status}
2410  * max is 35, dispatch trace to file /tmp/vppTest.pcap
2411  * pcap tx capture is on: 20 of 35 pkts...
2412  * @cliexend
2413  * Example of how to stop a tx packet capture:
2414  * @cliexstart{vppctl pcap dispatch trace off}
2415  * captured 21 pkts...
2416  * saved to /tmp/dispatchTrace.pcap...
2417  * @cliexend
2418 ?*/
2419 /* *INDENT-OFF* */
2420 VLIB_CLI_COMMAND (pcap_dispatch_trace_command, static) = {
2421     .path = "pcap dispatch trace",
2422     .short_help =
2423     "pcap dispatch trace [on|off] [max <nn>] [file <name>] [status]\n"
2424     "              [buffer-trace <input-node-name> <nn>]",
2425     .function = dispatch_trace_command_fn,
2426 };
2427 /* *INDENT-ON* */
2428
2429 /*
2430  * fd.io coding-style-patch-verification: ON
2431  *
2432  * Local Variables:
2433  * eval: (c-set-style "gnu")
2434  * End:
2435  */