51 key =
format (0,
"%s", key);
145 for (j = 0; j < n_insert; j++)
165 if (pf->next_frame_index != ~0 && pf->next_frame_index >= i)
166 pf->next_frame_index += n_insert;
243 uword sib_node_index, sib_slot;
247 sib_node = vec_elt (nm->nodes, sib_node_index);
248 if (sib_node != node)
250 sib_slot = vlib_node_add_next_with_slot (vm, sib_node_index, next_node_index, slot);
251 ASSERT (sib_slot == slot);
307 #define STACK_ALIGN (clib_mem_get_page_size()) 309 #define STACK_ALIGN CLIB_CACHE_LINE_BYTES 327 if (r->node_fn_registrations)
334 ASSERT (r->function == 0);
338 if (fnr->priority > priority)
340 priority = fnr->priority;
341 r->function = fnr->function;
343 fnr = fnr->next_registration;
347 ASSERT (r->function != 0);
381 if (r->sibling_of && r->n_next_nodes > 0)
382 clib_error (
"sibling node should not have any next nodes `%v'", n->
name);
385 ASSERT (r->vector_size > 0);
387 #define _(f) n->f = r->f 403 _(runtime_data_bytes);
404 if (r->runtime_data_bytes > 0)
412 for (i = 0; i < r->n_next_nodes; i++)
428 uword log2_n_stack_bytes;
430 log2_n_stack_bytes =
clib_max (r->process_log2_n_stack_bytes, 15);
438 if ((page_size > (4 << 10)) && log2_n_stack_bytes < 19)
440 if ((1 << log2_n_stack_bytes) <= page_size)
441 log2_n_stack_bytes =
min_log2 (page_size) + 1;
443 log2_n_stack_bytes++;
448 (
sizeof (p[0]) + (1 << log2_n_stack_bytes),
452 clib_panic (
"failed to allocate process stack (%d bytes)",
453 1 << log2_n_stack_bytes);
476 if (mprotect (p->stack, page_size, PROT_READ) < 0)
544 static char *null_node_error_strings[] = {
545 "blackholed packets",
550 .vector_size =
sizeof (
u32),
553 .error_strings = null_node_error_strings,
564 r = r->next_registration;
580 u32 threads_to_serialize;
603 for (j = 0; j < threads_to_serialize; j++)
605 stat_vm = stat_vms[j];
617 nodes = node_dups[j];
620 node_dups[j] = nodes;
626 *node_dupsp = node_dups;
627 *stat_vmsp = stat_vms;
663 vlib_node_t * m = vec_elt (nm->nodes, si);
666 m->sibling_bitmap = clib_bitmap_ori (m->sibling_bitmap, n->index);
669 n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
698 (
"node `%v' refers to unknown node `%s'", n->
name, a);
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
u32 next_frame_index
Start of next frames for this node.
#define hash_set(h, key, value)
vlib_process_t ** processes
static void * clib_mem_alloc_aligned_at_offset(uword size, uword align, uword align_offset, int os_out_of_memory_on_failure)
#define hash_unset(h, key)
vlib_node_runtime_t node_runtime
#define VLIB_PENDING_FRAME_NO_NEXT_FRAME
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
u8 runtime_data[0]
Function dependent node-runtime data.
static void node_set_elog_name(vlib_main_t *vm, uword node_index)
uword vlib_node_add_named_next_with_slot(vlib_main_t *vm, uword node, char *name, uword slot)
#define clib_error(format, args...)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
#define vec_add2_aligned(V, P, N, A)
Add N elements to end of vector V, return pointer to new elements in P.
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
#define STRUCT_OFFSET_OF(t, f)
char * format
Format string.
vlib_error_t * errors
Vector of errors for this node.
vlib_main_t ** vlib_mains
static uword min_log2(uword x)
vlib_node_function_t * function
#define vlib_worker_thread_barrier_sync(X)
#define clib_memcpy(d, s, n)
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[])
#define VLIB_NODE_RUNTIME_DATA_SIZE
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
void vlib_worker_thread_node_runtime_update(void)
vlib_node_function_t * function
Node function to call.
void vlib_node_get_nodes(vlib_main_t *vm, u32 max_threads, int include_stats, int barrier_sync, vlib_node_t ****node_dupsp, vlib_main_t ***stat_vmsp)
Get list of nodes.
uword vlib_node_add_next_with_slot(vlib_main_t *vm, uword node_index, uword next_node_index, uword slot)
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
struct _vlib_node_fn_registration vlib_node_fn_registration_t
vhost_vring_state_t state
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
#define clib_error_create(args...)
vlib_node_runtime_t * nodes_by_type[VLIB_N_NODE_TYPE]
clib_error_t * vlib_node_main_init(vlib_main_t *vm)
static void vlib_worker_thread_node_rename(u32 node_index)
vlib_worker_thread_t * vlib_worker_threads
#define clib_bitmap_foreach(i, ai, body)
Macro to iterate across set bits in a bitmap.
#define vec_insert(V, N, M)
Insert N vector elements starting at element M, initialize new elements to zero (no header...
u16 state
Input node state.
static void vlib_next_frame_init(vlib_next_frame_t *nf)
#define VLIB_FRAME_NO_FREE_AFTER_DISPATCH
uword clib_mem_get_page_size(void)
vlib_node_registration_t * node_registrations
elog_event_type_t * node_return_elog_event_types
#define vec_dup(V)
Return copy of vector (no header, no alignment)
void vlib_frame_free(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_frame_t *f)
u64 * n_vectors_by_next_node
u32 node_index
Node index.
#define VLIB_PROCESS_STACK_MAGIC
static void node_elog_init(vlib_main_t *vm, uword ni)
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
void vlib_register_all_static_nodes(vlib_main_t *vm)
#define clib_mem_alloc_no_fail(size)
static_always_inline uword vlib_get_thread_index(void)
vlib_pending_frame_t * pending_frames
#define vec_free(V)
Free vector's memory (no header).
#define VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
vlib_node_fn_registration_t * node_fn_registrations
static uword null_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
volatile u32 * wait_at_barrier
#define hash_create(elts, value_bytes)
void vlib_node_rename(vlib_main_t *vm, u32 node_index, char *fmt,...)
u32 vlib_register_node(vlib_main_t *vm, vlib_node_registration_t *r)
uword * next_slot_by_node
static uword clib_mem_is_heap_object(void *p)
uword vlib_node_get_next(vlib_main_t *vm, uword node_index, uword next_node_index)
void vlib_node_sync_stats(vlib_main_t *vm, vlib_node_t *n)
#define vec_elt(v, i)
Get vector value at index i.
struct _vlib_node_registration vlib_node_registration_t
#define hash_create_vec(elts, key_bytes, value_bytes)
u32 elog_string(elog_main_t *em, char *fmt,...)
add a string to the event-log string table
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 input_node_counts_by_state[VLIB_N_NODE_STATE]
vlib_pending_frame_t * suspended_process_frames
vlib_node_main_t node_main
vlib_next_frame_t * next_frames
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
#define clib_unix_warning(format, args...)
static void register_node(vlib_main_t *vm, vlib_node_registration_t *r)
elog_event_type_t * node_call_elog_event_types
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
#define VLIB_NODE_MAIN_RUNTIME_STARTED
static void vlib_node_runtime_update(vlib_main_t *vm, u32 node_index, u32 next_index)
static void * vec_header(void *v, uword header_bytes)
Find a user vector header.
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
#define vec_foreach(var, vec)
Vector iterator.
u16 flags
Copy of main node flags.
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
#define CLIB_CACHE_LINE_BYTES
#define STATIC_ASSERT_SIZEOF(d, s)
#define clib_panic(format, args...)