src/vlib/node.h

   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  * node.h: VLIB processing nodes
  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 #ifndef included_vlib_node_h
  41 #define included_vlib_node_h
  42
  43 #include <vppinfra/cpu.h>
  44 #include <vppinfra/longjmp.h>
  45 #include <vppinfra/lock.h>
  46 #include <vlib/trace.h>         /* for vlib_trace_filter_t */
  47
  48 /* Forward declaration. */
  49 struct vlib_node_runtime_t;
  50 struct vlib_frame_t;
  51
  52 /* Internal nodes (including output nodes) move data from node to
  53    node (or out of the graph for output nodes). */
  54 typedef uword (vlib_node_function_t) (struct vlib_main_t * vm,
  55                                       struct vlib_node_runtime_t * node,
  56                                       struct vlib_frame_t * frame);
  57
  58 typedef enum
  59 {
  60   /* An internal node on the call graph (could be output). */
  61   VLIB_NODE_TYPE_INTERNAL,
  62
  63   /* Nodes which input data into the processing graph.
  64      Input nodes are called for each iteration of main loop. */
  65   VLIB_NODE_TYPE_INPUT,
  66
  67   /* Nodes to be called before all input nodes.
  68      Used, for example, to clean out driver TX rings before
  69      processing input. */
  70   VLIB_NODE_TYPE_PRE_INPUT,
  71
  72   /* "Process" nodes which can be suspended and later resumed. */
  73   VLIB_NODE_TYPE_PROCESS,
  74
  75   VLIB_N_NODE_TYPE,
  76 } vlib_node_type_t;
  77
  78 typedef struct _vlib_node_fn_registration
  79 {
  80   vlib_node_function_t *function;
  81   int priority;
  82   struct _vlib_node_fn_registration *next_registration;
  83 } vlib_node_fn_registration_t;
  84
  85 typedef struct _vlib_node_registration
  86 {
  87   /* Vector processing function for this node. */
  88   vlib_node_function_t *function;
  89
  90   /* Node function candidate registration with priority */
  91   vlib_node_fn_registration_t *node_fn_registrations;
  92
  93   /* Node name. */
  94   char *name;
  95
  96   /* Name of sibling (if applicable). */
  97   char *sibling_of;
  98
  99   /* Node index filled in by registration. */
 100   u32 index;
 101
 102   /* Type of this node. */
 103   vlib_node_type_t type;
 104
 105   /* Error strings indexed by error code for this node. */
 106   char **error_strings;
 107
 108   /* Buffer format/unformat for this node. */
 109   format_function_t *format_buffer;
 110   unformat_function_t *unformat_buffer;
 111
 112   /* Trace format/unformat for this node. */
 113   format_function_t *format_trace;
 114   unformat_function_t *unformat_trace;
 115
 116   /* Function to validate incoming frames. */
 117   u8 *(*validate_frame) (struct vlib_main_t * vm,
 118                          struct vlib_node_runtime_t *,
 119                          struct vlib_frame_t * f);
 120
 121   /* Per-node runtime data. */
 122   void *runtime_data;
 123
 124   /* Process stack size. */
 125   u16 process_log2_n_stack_bytes;
 126
 127   /* Number of bytes of per-node run time data. */
 128   u8 runtime_data_bytes;
 129
 130   /* State for input nodes. */
 131   u8 state;
 132
 133   /* Node flags. */
 134   u16 flags;
 135
 136   /* Size of scalar and vector arguments in bytes. */
 137   u16 scalar_size, vector_size;
 138
 139   /* Number of error codes used by this node. */
 140   u16 n_errors;
 141
 142   /* Number of next node names that follow. */
 143   u16 n_next_nodes;
 144
 145   /* Constructor link-list, don't ask... */
 146   struct _vlib_node_registration *next_registration;
 147
 148   /* Names of next nodes which this node feeds into. */
 149   char *next_nodes[];
 150
 151 } vlib_node_registration_t;
 152
 153 #define VLIB_REGISTER_NODE(x,...)                                       \
 154     __VA_ARGS__ vlib_node_registration_t x;                             \
 155 static void __vlib_add_node_registration_##x (void)                     \
 156     __attribute__((__constructor__)) ;                                  \
 157 static void __vlib_add_node_registration_##x (void)                     \
 158 {                                                                       \
 159     vlib_main_t * vm = vlib_get_main();                                 \
 160     x.next_registration = vm->node_main.node_registrations;             \
 161     vm->node_main.node_registrations = &x;                              \
 162 }                                                                       \
 163 static void __vlib_rm_node_registration_##x (void)                      \
 164     __attribute__((__destructor__)) ;                                   \
 165 static void __vlib_rm_node_registration_##x (void)                      \
 166 {                                                                       \
 167     vlib_main_t * vm = vlib_get_main();                                 \
 168     VLIB_REMOVE_FROM_LINKED_LIST (vm->node_main.node_registrations,     \
 169                                   &x, next_registration);               \
 170 }                                                                       \
 171 __VA_ARGS__ vlib_node_registration_t x
 172
 173 #define VLIB_NODE_FN(node)                                              \
 174 uword CLIB_MARCH_SFX (node##_fn)();                                     \
 175 static vlib_node_fn_registration_t                                      \
 176   CLIB_MARCH_SFX(node##_fn_registration) =                              \
 177   { .function = &CLIB_MARCH_SFX (node##_fn), };                         \
 178                                                                         \
 179 static void __clib_constructor                                          \
 180 CLIB_MARCH_SFX (node##_multiarch_register) (void)                       \
 181 {                                                                       \
 182   extern vlib_node_registration_t node;                                 \
 183   vlib_node_fn_registration_t *r;                                       \
 184   r = & CLIB_MARCH_SFX (node##_fn_registration);                        \
 185   r->priority = CLIB_MARCH_FN_PRIORITY();                               \
 186   r->next_registration = node.node_fn_registrations;                    \
 187   node.node_fn_registrations = r;                                       \
 188 }                                                                       \
 189 uword CLIB_CPU_OPTIMIZED CLIB_MARCH_SFX (node##_fn)
 190
 191 #if CLIB_DEBUG > 0
 192 #define VLIB_NODE_FUNCTION_CLONE_TEMPLATE(arch, fn)
 193 #define VLIB_NODE_FUNCTION_MULTIARCH_CLONE(fn)
 194 #define VLIB_NODE_FUNCTION_MULTIARCH(node, fn)
 195 #else
 196 #define VLIB_NODE_FUNCTION_CLONE_TEMPLATE(arch, fn, tgt)                \
 197   uword                                                                 \
 198   __attribute__ ((flatten))                                             \
 199   __attribute__ ((target (tgt)))                                        \
 200   CLIB_CPU_OPTIMIZED                                                    \
 201   fn ## _ ## arch ( struct vlib_main_t * vm,                            \
 202                    struct vlib_node_runtime_t * node,                   \
 203                    struct vlib_frame_t * frame)                         \
 204   { return fn (vm, node, frame); }
 205
 206 #define VLIB_NODE_FUNCTION_MULTIARCH_CLONE(fn)                          \
 207   foreach_march_variant(VLIB_NODE_FUNCTION_CLONE_TEMPLATE, fn)
 208
 209 #define VLIB_NODE_FUNCTION_MULTIARCH(node, fn)                          \
 210   VLIB_NODE_FUNCTION_MULTIARCH_CLONE(fn)                                \
 211   CLIB_MULTIARCH_SELECT_FN(fn, static inline)                           \
 212   static void __attribute__((__constructor__))                          \
 213   __vlib_node_function_multiarch_select_##node (void)                   \
 214   { node.function = fn ## _multiarch_select(); }
 215 #endif
 216
 217 always_inline vlib_node_registration_t *
 218 vlib_node_next_registered (vlib_node_registration_t * c)
 219 {
 220   c =
 221     clib_elf_section_data_next (c,
 222                                 c->n_next_nodes * sizeof (c->next_nodes[0]));
 223   return c;
 224 }
 225
 226 typedef struct
 227 {
 228   /* Total calls, clock ticks and vector elements processed for this node. */
 229   u64 calls, vectors, clocks, suspends;
 230   u64 max_clock;
 231   u64 max_clock_n;
 232 } vlib_node_stats_t;
 233
 234 #define foreach_vlib_node_state                                 \
 235   /* Input node is called each iteration of main loop.          \
 236      This is the default (zero). */                             \
 237   _ (POLLING)                                                   \
 238   /* Input node is called when device signals an interrupt. */  \
 239   _ (INTERRUPT)                                                 \
 240   /* Input node is never called. */                             \
 241   _ (DISABLED)
 242
 243 typedef enum
 244 {
 245 #define _(f) VLIB_NODE_STATE_##f,
 246   foreach_vlib_node_state
 247 #undef _
 248     VLIB_N_NODE_STATE,
 249 } vlib_node_state_t;
 250
 251 typedef struct vlib_node_t
 252 {
 253   /* Vector processing function for this node. */
 254   vlib_node_function_t *function;
 255
 256   /* Node name. */
 257   u8 *name;
 258
 259   /* Node name index in elog string table. */
 260   u32 name_elog_string;
 261
 262   /* Total statistics for this node. */
 263   vlib_node_stats_t stats_total;
 264
 265   /* Saved values as of last clear (or zero if never cleared).
 266      Current values are always stats_total - stats_last_clear. */
 267   vlib_node_stats_t stats_last_clear;
 268
 269   /* Type of this node. */
 270   vlib_node_type_t type;
 271
 272   /* Node index. */
 273   u32 index;
 274
 275   /* Index of corresponding node runtime. */
 276   u32 runtime_index;
 277
 278   /* Runtime data for this node. */
 279   void *runtime_data;
 280
 281   /* Node flags. */
 282   u16 flags;
 283
 284   /* Processing function keeps frame.  Tells node dispatching code not
 285      to free frame after dispatch is done.  */
 286 #define VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH (1 << 0)
 287
 288   /* Node counts as output/drop/punt node for stats purposes. */
 289 #define VLIB_NODE_FLAG_IS_OUTPUT (1 << 1)
 290 #define VLIB_NODE_FLAG_IS_DROP (1 << 2)
 291 #define VLIB_NODE_FLAG_IS_PUNT (1 << 3)
 292 #define VLIB_NODE_FLAG_IS_HANDOFF (1 << 4)
 293
 294   /* Set if current node runtime has traced vectors. */
 295 #define VLIB_NODE_FLAG_TRACE (1 << 5)
 296
 297 #define VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE (1 << 6)
 298 #define VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE (1 << 7)
 299
 300   /* State for input nodes. */
 301   u8 state;
 302
 303   /* Number of bytes of run time data. */
 304   u8 runtime_data_bytes;
 305
 306   /* Number of error codes used by this node. */
 307   u16 n_errors;
 308
 309   /* Size of scalar and vector arguments in bytes. */
 310   u16 scalar_size, vector_size;
 311
 312   /* Handle/index in error heap for this node. */
 313   u32 error_heap_handle;
 314   u32 error_heap_index;
 315
 316   /* Error strings indexed by error code for this node. */
 317   char **error_strings;
 318
 319   /* Vector of next node names.
 320      Only used before next_nodes array is initialized. */
 321   char **next_node_names;
 322
 323   /* Next node indices for this node. */
 324   u32 *next_nodes;
 325
 326   /* Name of node that we are sibling of. */
 327   char *sibling_of;
 328
 329   /* Bitmap of all of this node's siblings. */
 330   uword *sibling_bitmap;
 331
 332   /* Total number of vectors sent to each next node. */
 333   u64 *n_vectors_by_next_node;
 334
 335   /* Hash table mapping next node index into slot in
 336      next_nodes vector.  Quickly determines whether this node
 337      is connected to given next node and, if so, with which slot. */
 338   uword *next_slot_by_node;
 339
 340   /* Bitmap of node indices which feed this node. */
 341   uword *prev_node_bitmap;
 342
 343   /* Node/next-index which own enqueue rights with to this node. */
 344   u32 owner_node_index, owner_next_index;
 345
 346   /* Buffer format/unformat for this node. */
 347   format_function_t *format_buffer;
 348   unformat_function_t *unformat_buffer;
 349
 350   /* Trace buffer format/unformat for this node. */
 351   format_function_t *format_trace;
 352
 353   /* Function to validate incoming frames. */
 354   u8 *(*validate_frame) (struct vlib_main_t * vm,
 355                          struct vlib_node_runtime_t *,
 356                          struct vlib_frame_t * f);
 357   /* for pretty-printing, not typically valid */
 358   u8 *state_string;
 359 } vlib_node_t;
 360
 361 #define VLIB_INVALID_NODE_INDEX ((u32) ~0)
 362
 363 /* Max number of vector elements to process at once per node. */
 364 #define VLIB_FRAME_SIZE 256
 365 #define VLIB_FRAME_ALIGN CLIB_CACHE_LINE_BYTES
 366
 367 /* Calling frame (think stack frame) for a node. */
 368 typedef struct vlib_frame_t
 369 {
 370   /* Frame flags. */
 371   u16 flags;
 372
 373   /* Number of scalar bytes in arguments. */
 374   u8 scalar_size;
 375
 376   /* Number of bytes per vector argument. */
 377   u8 vector_size;
 378
 379   /* Number of vector elements currently in frame. */
 380   u16 n_vectors;
 381
 382   /* Scalar and vector arguments to next node. */
 383   u8 arguments[0];
 384 } vlib_frame_t;
 385
 386 typedef struct
 387 {
 388   /* Frame index. */
 389   u32 frame_index;
 390
 391   /* Node runtime for this next. */
 392   u32 node_runtime_index;
 393
 394   /* Next frame flags. */
 395   u32 flags;
 396
 397   /* Reflects node frame-used flag for this next. */
 398 #define VLIB_FRAME_NO_FREE_AFTER_DISPATCH \
 399   VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
 400
 401   /* This next frame owns enqueue to node
 402      corresponding to node_runtime_index. */
 403 #define VLIB_FRAME_OWNER (1 << 15)
 404
 405   /* Set when frame has been allocated for this next. */
 406 #define VLIB_FRAME_IS_ALLOCATED VLIB_NODE_FLAG_IS_OUTPUT
 407
 408   /* Set when frame has been added to pending vector. */
 409 #define VLIB_FRAME_PENDING VLIB_NODE_FLAG_IS_DROP
 410
 411   /* Set when frame is to be freed after dispatch. */
 412 #define VLIB_FRAME_FREE_AFTER_DISPATCH VLIB_NODE_FLAG_IS_PUNT
 413
 414   /* Set when frame has traced packets. */
 415 #define VLIB_FRAME_TRACE VLIB_NODE_FLAG_TRACE
 416
 417   /* Number of vectors enqueue to this next since last overflow. */
 418   u32 vectors_since_last_overflow;
 419 } vlib_next_frame_t;
 420
 421 always_inline void
 422 vlib_next_frame_init (vlib_next_frame_t * nf)
 423 {
 424   memset (nf, 0, sizeof (nf[0]));
 425   nf->frame_index = ~0;
 426   nf->node_runtime_index = ~0;
 427 }
 428
 429 /* A frame pending dispatch by main loop. */
 430 typedef struct
 431 {
 432   /* Node and runtime for this frame. */
 433   u32 node_runtime_index;
 434
 435   /* Frame index (in the heap). */
 436   u32 frame_index;
 437
 438   /* Start of next frames for this node. */
 439   u32 next_frame_index;
 440
 441   /* Special value for next_frame_index when there is no next frame. */
 442 #define VLIB_PENDING_FRAME_NO_NEXT_FRAME ((u32) ~0)
 443 } vlib_pending_frame_t;
 444
 445 typedef struct vlib_node_runtime_t
 446 {
 447   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);      /**< cacheline mark */
 448
 449   vlib_node_function_t *function;       /**< Node function to call. */
 450
 451   vlib_error_t *errors;                 /**< Vector of errors for this node. */
 452
 453 #if __SIZEOF_POINTER__ == 4
 454   u8 pad[8];
 455 #endif
 456
 457   u32 clocks_since_last_overflow;       /**< Number of clock cycles. */
 458
 459   u32 max_clock;                        /**< Maximum clock cycle for an
 460                                           invocation. */
 461
 462   u32 max_clock_n;                      /**< Number of vectors in the recorded
 463                                           max_clock. */
 464
 465   u32 calls_since_last_overflow;        /**< Number of calls. */
 466
 467   u32 vectors_since_last_overflow;      /**< Number of vector elements
 468                                           processed by this node. */
 469
 470   u32 next_frame_index;                 /**< Start of next frames for this
 471                                           node. */
 472
 473   u32 node_index;                       /**< Node index. */
 474
 475   u32 input_main_loops_per_call;        /**< For input nodes: decremented
 476                                           on each main loop interation until
 477                                           it reaches zero and function is
 478                                           called.  Allows some input nodes to
 479                                           be called more than others. */
 480
 481   u32 main_loop_count_last_dispatch;    /**< Saved main loop counter of last
 482                                           dispatch of this node. */
 483
 484   u32 main_loop_vector_stats[2];
 485
 486   u16 flags;                            /**< Copy of main node flags. */
 487
 488   u16 state;                            /**< Input node state. */
 489
 490   u16 n_next_nodes;
 491
 492   u16 cached_next_index;                /**< Next frame index that vector
 493                                           arguments were last enqueued to
 494                                           last time this node ran. Set to
 495                                           zero before first run of this
 496                                           node. */
 497
 498   u16 thread_index;                     /**< thread this node runs on */
 499
 500   u8 runtime_data[0];                   /**< Function dependent
 501                                           node-runtime data. This data is
 502                                           thread local, and it is not
 503                                           cloned from main thread. It needs
 504                                           to be initialized for each thread
 505                                           before it is used unless
 506                                           runtime_data template exists in
 507                                           vlib_node_t. */
 508 }
 509 vlib_node_runtime_t;
 510
 511 #define VLIB_NODE_RUNTIME_DATA_SIZE     (sizeof (vlib_node_runtime_t) - STRUCT_OFFSET_OF (vlib_node_runtime_t, runtime_data))
 512
 513 typedef struct
 514 {
 515   /* Number of allocated frames for this scalar/vector size. */
 516   u32 n_alloc_frames;
 517
 518   /* Vector of free frame indices for this scalar/vector size. */
 519   u32 *free_frame_indices;
 520 } vlib_frame_size_t;
 521
 522 typedef struct
 523 {
 524   /* Users opaque value for event type. */
 525   uword opaque;
 526 } vlib_process_event_type_t;
 527
 528 typedef struct
 529 {
 530   /* Node runtime for this process. */
 531   vlib_node_runtime_t node_runtime;
 532
 533   /* Where to longjmp when process is done. */
 534   clib_longjmp_t return_longjmp;
 535
 536 #define VLIB_PROCESS_RETURN_LONGJMP_RETURN ((uword) ~0 - 0)
 537 #define VLIB_PROCESS_RETURN_LONGJMP_SUSPEND ((uword) ~0 - 1)
 538
 539   /* Where to longjmp to resume node after suspend. */
 540   clib_longjmp_t resume_longjmp;
 541 #define VLIB_PROCESS_RESUME_LONGJMP_SUSPEND 0
 542 #define VLIB_PROCESS_RESUME_LONGJMP_RESUME  1
 543
 544   u16 flags;
 545 #define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK (1 << 0)
 546 #define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT (1 << 1)
 547   /* Set to indicate that this process has been added to resume vector. */
 548 #define VLIB_PROCESS_RESUME_PENDING (1 << 2)
 549
 550   /* Process function is currently running. */
 551 #define VLIB_PROCESS_IS_RUNNING (1 << 3)
 552
 553   /* Size of process stack. */
 554   u16 log2_n_stack_bytes;
 555
 556   u32 suspended_process_frame_index;
 557
 558   /* Number of times this process was suspended. */
 559   u32 n_suspends;
 560
 561   /* Vectors of pending event data indexed by event type index. */
 562   void **pending_event_data_by_type_index;
 563
 564   /* Bitmap of event type-indices with non-empty vectors. */
 565   uword *non_empty_event_type_bitmap;
 566
 567   /* Bitmap of event type-indices which are one time events. */
 568   uword *one_time_event_type_bitmap;
 569
 570   /* Type is opaque pointer -- typically a pointer to an event handler
 571      function.  Hash table to map opaque to a type index. */
 572   uword *event_type_index_by_type_opaque;
 573
 574   /* Pool of currently valid event types. */
 575   vlib_process_event_type_t *event_type_pool;
 576
 577   /*
 578    * When suspending saves clock time (10us ticks) when process
 579    * is to be resumed.
 580    */
 581   u64 resume_clock_interval;
 582
 583   /* Handle from timer code, to cancel an unexpired timer */
 584   u32 stop_timer_handle;
 585
 586   /* Default output function and its argument for any CLI outputs
 587      within the process. */
 588   vlib_cli_output_function_t *output_function;
 589   uword output_function_arg;
 590
 591 #ifdef CLIB_UNIX
 592   /* Pad to a multiple of the page size so we can mprotect process stacks */
 593 #define PAGE_SIZE_MULTIPLE 0x1000
 594 #define ALIGN_ON_MULTIPLE_PAGE_BOUNDARY_FOR_MPROTECT  __attribute__ ((aligned (PAGE_SIZE_MULTIPLE)))
 595 #else
 596 #define ALIGN_ON_MULTIPLE_PAGE_BOUNDARY_FOR_MPROTECT
 597 #endif
 598
 599   /* Process stack.  Starts here and extends 2^log2_n_stack_bytes
 600      bytes. */
 601
 602 #define VLIB_PROCESS_STACK_MAGIC (0xdead7ead)
 603   u32 stack[0] ALIGN_ON_MULTIPLE_PAGE_BOUNDARY_FOR_MPROTECT;
 604 } vlib_process_t __attribute__ ((aligned (CLIB_CACHE_LINE_BYTES)));
 605
 606 #ifdef CLIB_UNIX
 607   /* Ensure that the stack is aligned on the multiple of the page size */
 608 typedef char
 609   assert_process_stack_must_be_aligned_exactly_to_page_size_multiple[(sizeof
 610                                                                       (vlib_process_t)
 611                                                                       -
 612                                                                       PAGE_SIZE_MULTIPLE)
 613                                                                      ==
 614                                                                      0 ? 0 :
 615                                                                      -1];
 616 #endif
 617
 618 typedef struct
 619 {
 620   u32 node_index;
 621
 622   u32 one_time_event;
 623 } vlib_one_time_waiting_process_t;
 624
 625 typedef struct
 626 {
 627   u16 n_data_elts;
 628
 629   u16 n_data_elt_bytes;
 630
 631   /* n_data_elts * n_data_elt_bytes */
 632   u32 n_data_bytes;
 633
 634   /* Process node & event type to be used to signal event. */
 635   u32 process_node_index;
 636
 637   u32 event_type_index;
 638
 639   union
 640   {
 641     u8 inline_event_data[64 - 3 * sizeof (u32) - 2 * sizeof (u16)];
 642
 643     /* Vector of event data used only when data does not fit inline. */
 644     u8 *event_data_as_vector;
 645   };
 646 }
 647 vlib_signal_timed_event_data_t;
 648
 649 always_inline uword
 650 vlib_timing_wheel_data_is_timed_event (u32 d)
 651 {
 652   return d & 1;
 653 }
 654
 655 always_inline u32
 656 vlib_timing_wheel_data_set_suspended_process (u32 i)
 657 {
 658   return 0 + 2 * i;
 659 }
 660
 661 always_inline u32
 662 vlib_timing_wheel_data_set_timed_event (u32 i)
 663 {
 664   return 1 + 2 * i;
 665 }
 666
 667 always_inline uword
 668 vlib_timing_wheel_data_get_index (u32 d)
 669 {
 670   return d / 2;
 671 }
 672
 673 typedef struct
 674 {
 675   /* Public nodes. */
 676   vlib_node_t **nodes;
 677
 678   /* Node index hashed by node name. */
 679   uword *node_by_name;
 680
 681   u32 flags;
 682 #define VLIB_NODE_MAIN_RUNTIME_STARTED (1 << 0)
 683
 684   /* Nodes segregated by type for cache locality.
 685      Does not apply to nodes of type VLIB_NODE_TYPE_INTERNAL. */
 686   vlib_node_runtime_t *nodes_by_type[VLIB_N_NODE_TYPE];
 687
 688   /* Node runtime indices for input nodes with pending interrupts. */
 689   u32 *pending_interrupt_node_runtime_indices;
 690   clib_spinlock_t pending_interrupt_lock;
 691
 692   /* Input nodes are switched from/to interrupt to/from polling mode
 693      when average vector length goes above/below polling/interrupt
 694      thresholds. */
 695   u32 polling_threshold_vector_length;
 696   u32 interrupt_threshold_vector_length;
 697
 698   /* Vector of next frames. */
 699   vlib_next_frame_t *next_frames;
 700
 701   /* Vector of internal node's frames waiting to be called. */
 702   vlib_pending_frame_t *pending_frames;
 703
 704   /* Timing wheel for scheduling time-based node dispatch. */
 705   void *timing_wheel;
 706
 707   vlib_signal_timed_event_data_t *signal_timed_event_data_pool;
 708
 709   /* Opaque data vector added via timing_wheel_advance. */
 710   u32 *data_from_advancing_timing_wheel;
 711
 712   /* CPU time of next process to be ready on timing wheel. */
 713   f64 time_next_process_ready;
 714
 715   /* Vector of process nodes.
 716      One for each node of type VLIB_NODE_TYPE_PROCESS. */
 717   vlib_process_t **processes;
 718
 719   /* Current running process or ~0 if no process running. */
 720   u32 current_process_index;
 721
 722   /* Pool of pending process frames. */
 723   vlib_pending_frame_t *suspended_process_frames;
 724
 725   /* Vector of event data vectors pending recycle. */
 726   void **recycled_event_data_vectors;
 727
 728   /* Current counts of nodes in each state. */
 729   u32 input_node_counts_by_state[VLIB_N_NODE_STATE];
 730
 731   /* Hash of (scalar_size,vector_size) to frame_sizes index. */
 732   uword *frame_size_hash;
 733
 734   /* Per-size frame allocation information. */
 735   vlib_frame_size_t *frame_sizes;
 736
 737   /* Time of last node runtime stats clear. */
 738   f64 time_last_runtime_stats_clear;
 739
 740   /* Node registrations added by constructors */
 741   vlib_node_registration_t *node_registrations;
 742 } vlib_node_main_t;
 743
 744
 745 #define FRAME_QUEUE_MAX_NELTS 32
 746 typedef struct
 747 {
 748   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 749   u64 head;
 750   u64 head_hint;
 751   u64 tail;
 752   u32 n_in_use;
 753   u32 nelts;
 754   u32 written;
 755   u32 threshold;
 756   i32 n_vectors[FRAME_QUEUE_MAX_NELTS];
 757 } frame_queue_trace_t;
 758
 759 typedef struct
 760 {
 761   u64 count[FRAME_QUEUE_MAX_NELTS];
 762 } frame_queue_nelt_counter_t;
 763
 764 #endif /* included_vlib_node_h */
 765
 766 /*
 767  * fd.io coding-style-patch-verification: ON
 768  *
 769  * Local Variables:
 770  * eval: (c-set-style "gnu")
 771  * End:
 772  */