Line data Source code
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 : VLIB_NODE_PROTO_HINT_NONE = 0,
61 : VLIB_NODE_PROTO_HINT_ETHERNET,
62 : VLIB_NODE_PROTO_HINT_IP4,
63 : VLIB_NODE_PROTO_HINT_IP6,
64 : VLIB_NODE_PROTO_HINT_TCP,
65 : VLIB_NODE_PROTO_HINT_UDP,
66 : VLIB_NODE_N_PROTO_HINTS,
67 : } vlib_node_proto_hint_t;
68 :
69 : typedef enum
70 : {
71 : /* An internal node on the call graph (could be output). */
72 : VLIB_NODE_TYPE_INTERNAL,
73 :
74 : /* Nodes which input data into the processing graph.
75 : Input nodes are called for each iteration of main loop. */
76 : VLIB_NODE_TYPE_INPUT,
77 :
78 : /* Nodes to be called before all input nodes.
79 : Used, for example, to clean out driver TX rings before
80 : processing input. */
81 : VLIB_NODE_TYPE_PRE_INPUT,
82 :
83 : /* "Process" nodes which can be suspended and later resumed. */
84 : VLIB_NODE_TYPE_PROCESS,
85 :
86 : VLIB_N_NODE_TYPE,
87 : } vlib_node_type_t;
88 :
89 : typedef struct _vlib_node_fn_registration
90 : {
91 : vlib_node_function_t *function;
92 : clib_march_variant_type_t march_variant;
93 : struct _vlib_node_fn_registration *next_registration;
94 : } vlib_node_fn_registration_t;
95 :
96 : typedef struct _vlib_node_registration
97 : {
98 : /* Vector processing function for this node. */
99 : vlib_node_function_t *function;
100 :
101 : /* Node function candidate registration with priority */
102 : vlib_node_fn_registration_t *node_fn_registrations;
103 :
104 : /* Node name. */
105 : char *name;
106 :
107 : /* Name of sibling (if applicable). */
108 : char *sibling_of;
109 :
110 : /* Node index filled in by registration. */
111 : u32 index;
112 :
113 : /* Type of this node. */
114 : vlib_node_type_t type;
115 :
116 : /* Error strings indexed by error code for this node. */
117 : char **error_strings;
118 : vlib_error_desc_t *error_counters;
119 :
120 : /* Buffer format/unformat for this node. */
121 : format_function_t *format_buffer;
122 : unformat_function_t *unformat_buffer;
123 :
124 : /* Trace format/unformat for this node. */
125 : format_function_t *format_trace;
126 : unformat_function_t *unformat_trace;
127 :
128 : /* Function to validate incoming frames. */
129 : u8 *(*validate_frame) (struct vlib_main_t * vm,
130 : struct vlib_node_runtime_t *,
131 : struct vlib_frame_t * f);
132 :
133 : /* Per-node runtime data. */
134 : void *runtime_data;
135 :
136 : /* Process stack size. */
137 : u16 process_log2_n_stack_bytes;
138 :
139 : /* Number of bytes of per-node run time data. */
140 : u8 runtime_data_bytes;
141 :
142 : /* State for input nodes. */
143 : u8 state;
144 :
145 : /* Node flags. */
146 : u16 flags;
147 :
148 : /* protocol at b->data[b->current_data] upon entry to the dispatch fn */
149 : u8 protocol_hint;
150 :
151 : /* Size of scalar and vector arguments in bytes. */
152 : u8 vector_size, aux_size;
153 : u16 scalar_size;
154 :
155 : /* Number of error codes used by this node. */
156 : u16 n_errors;
157 :
158 : /* Number of next node names that follow. */
159 : u16 n_next_nodes;
160 :
161 : /* Constructor link-list, don't ask... */
162 : struct _vlib_node_registration *next_registration;
163 :
164 : /* Names of next nodes which this node feeds into. */
165 : char *next_nodes[];
166 :
167 : } vlib_node_registration_t;
168 :
169 : #ifndef CLIB_MARCH_VARIANT
170 : #define VLIB_REGISTER_NODE(x, ...) \
171 : __VA_ARGS__ vlib_node_registration_t x; \
172 : static void __vlib_add_node_registration_##x (void) \
173 : __attribute__ ((__constructor__)); \
174 : static void __vlib_add_node_registration_##x (void) \
175 : { \
176 : vlib_global_main_t *vgm = vlib_get_global_main (); \
177 : x.next_registration = vgm->node_registrations; \
178 : vgm->node_registrations = &x; \
179 : } \
180 : static void __vlib_rm_node_registration_##x (void) \
181 : __attribute__ ((__destructor__)); \
182 : static void __vlib_rm_node_registration_##x (void) \
183 : { \
184 : vlib_global_main_t *vgm = vlib_get_global_main (); \
185 : VLIB_REMOVE_FROM_LINKED_LIST (vgm->node_registrations, &x, \
186 : next_registration); \
187 : } \
188 : __VA_ARGS__ vlib_node_registration_t x
189 : #else
190 : #define VLIB_REGISTER_NODE(x,...) \
191 : STATIC_ASSERT (sizeof(# __VA_ARGS__) != 7,"node " #x " must not be declared as static"); \
192 : static __clib_unused vlib_node_registration_t __clib_unused_##x
193 : #endif
194 :
195 : #ifndef CLIB_MARCH_VARIANT
196 : #define CLIB_MARCH_VARIANT_STR "default"
197 : #else
198 : #define _CLIB_MARCH_VARIANT_STR(s) __CLIB_MARCH_VARIANT_STR(s)
199 : #define __CLIB_MARCH_VARIANT_STR(s) #s
200 : #define CLIB_MARCH_VARIANT_STR _CLIB_MARCH_VARIANT_STR(CLIB_MARCH_VARIANT)
201 : #endif
202 :
203 : #define VLIB_NODE_FN(node) \
204 : uword CLIB_MARCH_SFX (node##_fn) (vlib_main_t *, vlib_node_runtime_t *, \
205 : vlib_frame_t *); \
206 : static vlib_node_fn_registration_t CLIB_MARCH_SFX ( \
207 : node##_fn_registration) = { \
208 : .function = &CLIB_MARCH_SFX (node##_fn), \
209 : }; \
210 : \
211 : static void __clib_constructor CLIB_MARCH_SFX (node##_multiarch_register) ( \
212 : void) \
213 : { \
214 : extern vlib_node_registration_t node; \
215 : vlib_node_fn_registration_t *r; \
216 : r = &CLIB_MARCH_SFX (node##_fn_registration); \
217 : r->march_variant = CLIB_MARCH_SFX (CLIB_MARCH_VARIANT_TYPE); \
218 : r->next_registration = node.node_fn_registrations; \
219 : node.node_fn_registrations = r; \
220 : } \
221 : uword CLIB_MARCH_SFX (node##_fn)
222 :
223 : unformat_function_t unformat_vlib_node_variant;
224 :
225 : typedef struct
226 : {
227 : /* Total calls, clock ticks and vector elements processed for this node. */
228 : u64 calls, vectors, clocks, suspends;
229 : u64 max_clock;
230 : u64 max_clock_n;
231 : } vlib_node_stats_t;
232 :
233 : #define foreach_vlib_node_state \
234 : /* Input node is called each iteration of main loop. \
235 : This is the default (zero). */ \
236 : _ (POLLING) \
237 : /* Input node is called when device signals an interrupt. */ \
238 : _ (INTERRUPT) \
239 : /* Input node is never called. */ \
240 : _ (DISABLED)
241 :
242 : typedef enum
243 : {
244 : #define _(f) VLIB_NODE_STATE_##f,
245 : foreach_vlib_node_state
246 : #undef _
247 : VLIB_N_NODE_STATE,
248 : } vlib_node_state_t;
249 :
250 : typedef struct vlib_node_t
251 : {
252 : /* Vector processing function for this node. */
253 : vlib_node_function_t *function;
254 :
255 : /* Node name. */
256 : u8 *name;
257 :
258 : /* Node name index in elog string table. */
259 : u32 name_elog_string;
260 :
261 : /* Total statistics for this node. */
262 : vlib_node_stats_t stats_total;
263 :
264 : /* Saved values as of last clear (or zero if never cleared).
265 : Current values are always stats_total - stats_last_clear. */
266 : vlib_node_stats_t stats_last_clear;
267 :
268 : /* Type of this node. */
269 : vlib_node_type_t type;
270 :
271 : /* Node index. */
272 : u32 index;
273 :
274 : /* Index of corresponding node runtime. */
275 : u32 runtime_index;
276 :
277 : /* Runtime data for this node. */
278 : u8 *runtime_data;
279 :
280 : /* Node flags. */
281 : u16 flags;
282 :
283 : /* Processing function keeps frame. Tells node dispatching code not
284 : to free frame after dispatch is done. */
285 : #define VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH (1 << 0)
286 :
287 : /* Node counts as output/drop/punt node for stats purposes. */
288 : #define VLIB_NODE_FLAG_IS_OUTPUT (1 << 1)
289 : #define VLIB_NODE_FLAG_IS_DROP (1 << 2)
290 : #define VLIB_NODE_FLAG_IS_PUNT (1 << 3)
291 : #define VLIB_NODE_FLAG_IS_HANDOFF (1 << 4)
292 :
293 : /* Set if current node runtime has traced vectors. */
294 : #define VLIB_NODE_FLAG_TRACE (1 << 5)
295 :
296 : #define VLIB_NODE_FLAG_SWITCH_FROM_INTERRUPT_TO_POLLING_MODE (1 << 6)
297 : #define VLIB_NODE_FLAG_SWITCH_FROM_POLLING_TO_INTERRUPT_MODE (1 << 7)
298 : #define VLIB_NODE_FLAG_TRACE_SUPPORTED (1 << 8)
299 : #define VLIB_NODE_FLAG_ADAPTIVE_MODE (1 << 9)
300 :
301 : /* State for input nodes. */
302 : u8 state;
303 :
304 : /* Number of bytes of run time data. */
305 : u8 runtime_data_bytes;
306 :
307 : /* protocol at b->data[b->current_data] upon entry to the dispatch fn */
308 : u8 protocol_hint;
309 :
310 : /* Number of error codes used by this node. */
311 : u16 n_errors;
312 :
313 : /* Size of scalar and vector arguments in bytes. */
314 : u16 frame_size, scalar_offset, vector_offset, magic_offset, aux_offset;
315 : u16 frame_size_index;
316 :
317 : /* Handle/index in error heap for this node. */
318 : u32 error_heap_handle;
319 : u32 error_heap_index;
320 :
321 : /* Counter structures indexed by counter code for this node. */
322 : vlib_error_desc_t *error_counters;
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 :
365 : /* Node function candidate registration with priority */
366 : vlib_node_fn_registration_t *node_fn_registrations;
367 : } vlib_node_t;
368 :
369 : #define VLIB_INVALID_NODE_INDEX ((u32) ~0)
370 :
371 : /* Max number of vector elements to process at once per node. */
372 : #define VLIB_FRAME_SIZE 256
373 : /* Number of extra elements allocated at the end of vecttor. */
374 : #define VLIB_FRAME_SIZE_EXTRA 4
375 : /* Frame data alignment */
376 : #define VLIB_FRAME_DATA_ALIGN 16
377 :
378 : /* Calling frame (think stack frame) for a node. */
379 : typedef struct vlib_frame_t
380 : {
381 : /* Frame flags. */
382 : u16 frame_flags;
383 :
384 : /* User flags. Used for sending hints to the next node. */
385 : u16 flags;
386 :
387 : /* Scalar, vector and aux offsets in this frame. */
388 : u16 scalar_offset, vector_offset, aux_offset;
389 :
390 : /* Number of vector elements currently in frame. */
391 : u16 n_vectors;
392 :
393 : /* Index of frame size corresponding to allocated node. */
394 : u16 frame_size_index;
395 :
396 : /* Scalar and vector arguments to next node. */
397 : u8 arguments[0];
398 : } vlib_frame_t;
399 :
400 : typedef struct
401 : {
402 : /* Frame pointer. */
403 : vlib_frame_t *frame;
404 :
405 : /* Node runtime for this next. */
406 : u32 node_runtime_index;
407 :
408 : /* Next frame flags. */
409 : u32 flags;
410 :
411 : /* Reflects node frame-used flag for this next. */
412 : #define VLIB_FRAME_NO_FREE_AFTER_DISPATCH \
413 : VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
414 :
415 : /* Don't append this frame */
416 : #define VLIB_FRAME_NO_APPEND (1 << 14)
417 :
418 : /* This next frame owns enqueue to node
419 : corresponding to node_runtime_index. */
420 : #define VLIB_FRAME_OWNER (1 << 15)
421 :
422 : /* Set when frame has been allocated for this next. */
423 : #define VLIB_FRAME_IS_ALLOCATED VLIB_NODE_FLAG_IS_OUTPUT
424 :
425 : /* Set when frame has been added to pending vector. */
426 : #define VLIB_FRAME_PENDING VLIB_NODE_FLAG_IS_DROP
427 :
428 : /* Set when frame is to be freed after dispatch. */
429 : #define VLIB_FRAME_FREE_AFTER_DISPATCH VLIB_NODE_FLAG_IS_PUNT
430 :
431 : /* Set when frame has traced packets. */
432 : #define VLIB_FRAME_TRACE VLIB_NODE_FLAG_TRACE
433 :
434 : /* Number of vectors enqueue to this next since last overflow. */
435 : u32 vectors_since_last_overflow;
436 : } vlib_next_frame_t;
437 :
438 : always_inline void
439 3203970 : vlib_next_frame_init (vlib_next_frame_t * nf)
440 : {
441 3203970 : clib_memset (nf, 0, sizeof (nf[0]));
442 3203990 : nf->node_runtime_index = ~0;
443 3203990 : }
444 :
445 : /* A frame pending dispatch by main loop. */
446 : typedef struct
447 : {
448 : /* Frame index (in the heap). */
449 : vlib_frame_t *frame;
450 :
451 : /* Node and runtime for this frame. */
452 : u32 node_runtime_index;
453 :
454 : /* Start of next frames for this node. */
455 : u32 next_frame_index;
456 :
457 : /* Special value for next_frame_index when there is no next frame. */
458 : #define VLIB_PENDING_FRAME_NO_NEXT_FRAME ((u32) ~0)
459 : } vlib_pending_frame_t;
460 :
461 : typedef struct vlib_node_runtime_t
462 : {
463 : CLIB_CACHE_LINE_ALIGN_MARK (cacheline0); /**< cacheline mark */
464 :
465 : vlib_node_function_t *function; /**< Node function to call. */
466 :
467 : vlib_error_t *errors; /**< Vector of errors for this node. */
468 :
469 : u32 clocks_since_last_overflow; /**< Number of clock cycles. */
470 :
471 : u32 max_clock; /**< Maximum clock cycle for an
472 : invocation. */
473 :
474 : u32 max_clock_n; /**< Number of vectors in the recorded
475 : max_clock. */
476 :
477 : u32 calls_since_last_overflow; /**< Number of calls. */
478 :
479 : u32 vectors_since_last_overflow; /**< Number of vector elements
480 : processed by this node. */
481 :
482 : u32 next_frame_index; /**< Start of next frames for this
483 : node. */
484 :
485 : u32 node_index; /**< Node index. */
486 :
487 : u32 input_main_loops_per_call; /**< For input nodes: decremented
488 : on each main loop interation until
489 : it reaches zero and function is
490 : called. Allows some input nodes to
491 : be called more than others. */
492 :
493 : u32 main_loop_count_last_dispatch; /**< Saved main loop counter of last
494 : dispatch of this node. */
495 :
496 : u32 main_loop_vector_stats[2];
497 :
498 : u16 flags; /**< Copy of main node flags. */
499 :
500 : u16 state; /**< Input node state. */
501 :
502 : u16 n_next_nodes;
503 :
504 : u16 cached_next_index; /**< Next frame index that vector
505 : arguments were last enqueued to
506 : last time this node ran. Set to
507 : zero before first run of this
508 : node. */
509 :
510 : CLIB_ALIGN_MARK (runtime_data_pad, 8);
511 :
512 : u8 runtime_data[0]; /**< Function dependent
513 : node-runtime data. This data is
514 : thread local, and it is not
515 : cloned from main thread. It needs
516 : to be initialized for each thread
517 : before it is used unless
518 : runtime_data template exists in
519 : vlib_node_t. */
520 : }
521 : vlib_node_runtime_t;
522 :
523 : #define VLIB_NODE_RUNTIME_DATA_SIZE (sizeof (vlib_node_runtime_t) - STRUCT_OFFSET_OF (vlib_node_runtime_t, runtime_data))
524 :
525 : typedef struct
526 : {
527 : /* Number of allocated frames for this scalar/vector size. */
528 : u32 n_alloc_frames;
529 :
530 : /* Frame size */
531 : u16 frame_size;
532 :
533 : /* Vector of free frames for this scalar/vector size. */
534 : vlib_frame_t **free_frames;
535 : } vlib_frame_size_t;
536 :
537 : STATIC_ASSERT_SIZEOF (vlib_frame_size_t, 16);
538 :
539 : typedef struct
540 : {
541 : /* Users opaque value for event type. */
542 : uword opaque;
543 : } vlib_process_event_type_t;
544 :
545 : typedef struct
546 : {
547 : CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
548 : /* Node runtime for this process. */
549 : vlib_node_runtime_t node_runtime;
550 :
551 : /* Where to longjmp when process is done. */
552 : clib_longjmp_t return_longjmp;
553 :
554 : #define VLIB_PROCESS_RETURN_LONGJMP_RETURN ((uword) ~0 - 0)
555 : #define VLIB_PROCESS_RETURN_LONGJMP_SUSPEND ((uword) ~0 - 1)
556 :
557 : /* Where to longjmp to resume node after suspend. */
558 : clib_longjmp_t resume_longjmp;
559 : #define VLIB_PROCESS_RESUME_LONGJMP_SUSPEND 0
560 : #define VLIB_PROCESS_RESUME_LONGJMP_RESUME 1
561 :
562 : u16 flags;
563 : #define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK (1 << 0)
564 : #define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT (1 << 1)
565 : /* Set to indicate that this process has been added to resume vector. */
566 : #define VLIB_PROCESS_RESUME_PENDING (1 << 2)
567 :
568 : /* Process function is currently running. */
569 : #define VLIB_PROCESS_IS_RUNNING (1 << 3)
570 :
571 : /* Size of process stack. */
572 : u16 log2_n_stack_bytes;
573 :
574 : u32 suspended_process_frame_index;
575 :
576 : /* Number of times this process was suspended. */
577 : u32 n_suspends;
578 :
579 : /* Vectors of pending event data indexed by event type index. */
580 : u8 **pending_event_data_by_type_index;
581 :
582 : /* Bitmap of event type-indices with non-empty vectors. */
583 : uword *non_empty_event_type_bitmap;
584 :
585 : /* Bitmap of event type-indices which are one time events. */
586 : uword *one_time_event_type_bitmap;
587 :
588 : /* Type is opaque pointer -- typically a pointer to an event handler
589 : function. Hash table to map opaque to a type index. */
590 : uword *event_type_index_by_type_opaque;
591 :
592 : /* Pool of currently valid event types. */
593 : vlib_process_event_type_t *event_type_pool;
594 :
595 : /*
596 : * When suspending saves clock time (10us ticks) when process
597 : * is to be resumed.
598 : */
599 : u64 resume_clock_interval;
600 :
601 : /* Handle from timer code, to cancel an unexpired timer */
602 : u32 stop_timer_handle;
603 :
604 : /* Default output function and its argument for any CLI outputs
605 : within the process. */
606 : vlib_cli_output_function_t *output_function;
607 : uword output_function_arg;
608 :
609 : /* Process stack */
610 : #define VLIB_PROCESS_STACK_MAGIC (0xdead7ead)
611 : u32 *stack;
612 : } vlib_process_t;
613 :
614 : typedef struct
615 : {
616 : u32 node_index;
617 :
618 : u32 one_time_event;
619 : } vlib_one_time_waiting_process_t;
620 :
621 : typedef struct
622 : {
623 : u16 n_data_elts;
624 :
625 : u16 n_data_elt_bytes;
626 :
627 : /* n_data_elts * n_data_elt_bytes */
628 : u32 n_data_bytes;
629 :
630 : /* Process node & event type to be used to signal event. */
631 : u32 process_node_index;
632 :
633 : u32 event_type_index;
634 :
635 : union
636 : {
637 : u8 inline_event_data[64 - 3 * sizeof (u32) - 2 * sizeof (u16)];
638 :
639 : /* Vector of event data used only when data does not fit inline. */
640 : u8 *event_data_as_vector;
641 : };
642 : }
643 : vlib_signal_timed_event_data_t;
644 :
645 : always_inline uword
646 2259280 : vlib_timing_wheel_data_is_timed_event (u32 d)
647 : {
648 2259280 : return d & 1;
649 : }
650 :
651 : always_inline u32
652 2715905 : vlib_timing_wheel_data_set_suspended_process (u32 i)
653 : {
654 2715905 : return 0 + 2 * i;
655 : }
656 :
657 : always_inline u32
658 : vlib_timing_wheel_data_set_timed_event (u32 i)
659 : {
660 : return 1 + 2 * i;
661 : }
662 :
663 : always_inline uword
664 4053630 : vlib_timing_wheel_data_get_index (u32 d)
665 : {
666 4053630 : return d / 2;
667 : }
668 :
669 : typedef struct
670 : {
671 : clib_march_variant_type_t index;
672 : int priority;
673 : char *suffix;
674 : char *desc;
675 : } vlib_node_fn_variant_t;
676 :
677 : typedef struct
678 : {
679 : /* Public nodes. */
680 : vlib_node_t **nodes;
681 :
682 : /* Node index hashed by node name. */
683 : uword *node_by_name;
684 :
685 : u32 flags;
686 : #define VLIB_NODE_MAIN_RUNTIME_STARTED (1 << 0)
687 :
688 : /* Nodes segregated by type for cache locality.
689 : Does not apply to nodes of type VLIB_NODE_TYPE_INTERNAL. */
690 : vlib_node_runtime_t *nodes_by_type[VLIB_N_NODE_TYPE];
691 :
692 : /* Node runtime indices for input nodes with pending interrupts. */
693 : void *input_node_interrupts;
694 : void *pre_input_node_interrupts;
695 : volatile u8 pending_interrupts;
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 : /* Per-size frame allocation information. */
737 : vlib_frame_size_t *frame_sizes;
738 :
739 : /* Time of last node runtime stats clear. */
740 : f64 time_last_runtime_stats_clear;
741 :
742 : /* Node index from error code */
743 : u32 *node_by_error;
744 :
745 : /* Node Function Variants */
746 : vlib_node_fn_variant_t *variants;
747 :
748 : /* Node Function Default Variant Index */
749 : u32 node_fn_default_march_variant;
750 :
751 : /* Node Function march Variant by Suffix Hash */
752 : uword *node_fn_march_variant_by_suffix;
753 : } vlib_node_main_t;
754 :
755 : typedef u16 vlib_error_t;
756 :
757 : always_inline u32
758 60462 : vlib_error_get_node (vlib_node_main_t * nm, vlib_error_t e)
759 : {
760 60462 : return nm->node_by_error[e];
761 : }
762 :
763 : always_inline u32
764 60462 : vlib_error_get_code (vlib_node_main_t * nm, vlib_error_t e)
765 : {
766 60462 : u32 node_index = nm->node_by_error[e];
767 60462 : vlib_node_t *n = nm->nodes[node_index];
768 60462 : u32 error_code = e - n->error_heap_index;
769 60462 : return error_code;
770 : }
771 :
772 : #define FRAME_QUEUE_MAX_NELTS 64
773 : typedef struct
774 : {
775 : CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
776 : u64 head;
777 : u64 tail;
778 : u32 n_in_use;
779 : u32 nelts;
780 : u32 written;
781 : u32 threshold;
782 : i32 n_vectors[FRAME_QUEUE_MAX_NELTS];
783 : } frame_queue_trace_t;
784 :
785 : typedef struct
786 : {
787 : u64 count[FRAME_QUEUE_MAX_NELTS];
788 : } frame_queue_nelt_counter_t;
789 :
790 : #endif /* included_vlib_node_h */
791 :
792 : /*
793 : * fd.io coding-style-patch-verification: ON
794 : *
795 : * Local Variables:
796 : * eval: (c-set-style "gnu")
797 : * End:
798 : */
|
