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