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