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