vlib_node_main_t *nm = &vm->node_main;
uword *p;
u8 *key = name;
- if (!clib_mem_is_heap_object (vec_header (key, 0)))
- key = format (0, "%s", key);
+ key = format (0, "%s", key);
p = hash_get (nm->node_by_name, key);
if (key != name)
vec_free (key);
pf->next_frame_index += n_insert;
}
/* *INDENT-OFF* */
- pool_foreach (pf, nm->suspended_process_frames, ({
+ pool_foreach (pf, nm->suspended_process_frames) {
if (pf->next_frame_index != ~0 && pf->next_frame_index >= i)
pf->next_frame_index += n_insert;
- }));
+ }
/* *INDENT-ON* */
r->n_next_nodes = vec_len (node->next_nodes);
uword sib_node_index, sib_slot;
vlib_node_t *sib_node;
/* *INDENT-OFF* */
- clib_bitmap_foreach (sib_node_index, node->sibling_bitmap, ({
+ clib_bitmap_foreach (sib_node_index, node->sibling_bitmap) {
sib_node = vec_elt (nm->nodes, sib_node_index);
if (sib_node != node)
{
sib_slot = vlib_node_add_next_with_slot (vm, sib_node_index, next_node_index, slot);
ASSERT (sib_slot == slot);
}
- }));
+ }
/* *INDENT-ON* */
}
#define STACK_ALIGN CLIB_CACHE_LINE_BYTES
#endif
+vlib_node_function_t *
+vlib_node_get_preferred_node_fn_variant (vlib_main_t *vm,
+ vlib_node_fn_registration_t *regs)
+{
+ vlib_node_main_t *nm = &vm->node_main;
+ vlib_node_fn_registration_t *r;
+ vlib_node_fn_variant_t *v;
+ vlib_node_function_t *fn = 0;
+ int priority = -1;
+
+ if (nm->node_fn_default_march_variant != ~0)
+ {
+ r = regs;
+ while (r)
+ {
+ if (r->march_variant == nm->node_fn_default_march_variant)
+ return r->function;
+ r = r->next_registration;
+ }
+ }
+
+ r = regs;
+ while (r)
+ {
+ v = vec_elt_at_index (nm->variants, r->march_variant);
+ if (v->priority > priority)
+ {
+ priority = v->priority;
+ fn = r->function;
+ }
+ r = r->next_registration;
+ }
+
+ ASSERT (fn);
+ return fn;
+}
+
static void
register_node (vlib_main_t * vm, vlib_node_registration_t * r)
{
vlib_node_main_t *nm = &vm->node_main;
vlib_node_t *n;
- u32 page_size = clib_mem_get_page_size ();
int i;
if (CLIB_DEBUG > 0)
if (r->node_fn_registrations)
{
- vlib_node_fn_registration_t *fnr = r->node_fn_registrations;
- int priority = -1;
-
/* to avoid confusion, please remove ".function " statiement from
CLIB_NODE_REGISTRATION() if using function function candidates */
ASSERT (r->function == 0);
- while (fnr)
- {
- if (fnr->priority > priority)
- {
- priority = fnr->priority;
- r->function = fnr->function;
- }
- fnr = fnr->next_registration;
- }
+ r->function =
+ vlib_node_get_preferred_node_fn_variant (vm, r->node_fn_registrations);
}
ASSERT (r->function != 0);
/* Node names must be unique. */
{
- vlib_node_t *o = vlib_get_node_by_name (vm, n->name);
+ /* vlib_get_node_by_name() expects NULL-terminated strings */
+ u8 *name = format (0, "%v%c", n->name, 0);
+ vlib_node_t *o = vlib_get_node_by_name (vm, name);
+ vec_free (name);
if (o)
clib_error ("more than one node named `%v'", n->name);
}
_(validate_frame);
/* Register error counters. */
- vlib_register_errors (vm, n->index, r->n_errors, r->error_strings);
+ vlib_register_errors (vm, n->index, r->n_errors, r->error_strings,
+ r->error_counters);
node_elog_init (vm, n->index);
_(runtime_data_bytes);
if (n->type == VLIB_NODE_TYPE_PROCESS)
{
vlib_process_t *p;
- void *map;
- uword log2_n_stack_bytes, stack_bytes;
- int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
+ uword log2_n_stack_bytes;
log2_n_stack_bytes = clib_max (r->process_log2_n_stack_bytes,
VLIB_PROCESS_LOG2_STACK_SIZE);
log2_n_stack_bytes = clib_max (log2_n_stack_bytes,
- min_log2 (page_size));
+ clib_mem_get_log2_page_size ());
p = clib_mem_alloc_aligned (sizeof (p[0]), CLIB_CACHE_LINE_BYTES);
clib_memset (p, 0, sizeof (p[0]));
p->log2_n_stack_bytes = log2_n_stack_bytes;
- stack_bytes = 1ULL << log2_n_stack_bytes;
- /* map stack size + 2 extra guard pages */
- map = mmap (0, stack_bytes + page_size, PROT_READ | PROT_WRITE,
- mmap_flags, -1, 0);
+ p->stack = clib_mem_vm_map_stack (1ULL << log2_n_stack_bytes,
+ CLIB_MEM_PAGE_SZ_DEFAULT,
+ "process stack: %U",
+ format_vlib_node_name, vm,
+ n->index);
- if (map == MAP_FAILED)
+ if (p->stack == CLIB_MEM_VM_MAP_FAILED)
clib_panic ("failed to allocate process stack (%d bytes)",
- stack_bytes);
-
- /* skip the guard page */
- p->stack = map + page_size;
-
- mmap_flags |= MAP_FIXED;
- map = mmap (map, page_size, PROT_NONE, mmap_flags, -1, 0);
-
- if (map == MAP_FAILED)
- clib_unix_warning ("failed to create stack guard page");
+ 1ULL << log2_n_stack_bytes);
/* Process node's runtime index is really index into process
pointer vector. */
{
vec_add2_aligned (nm->nodes_by_type[n->type], rt, 1,
/* align */ CLIB_CACHE_LINE_BYTES);
+ if (n->type == VLIB_NODE_TYPE_INPUT)
+ clib_interrupt_resize (&nm->interrupts,
+ vec_len (nm->nodes_by_type[n->type]));
n->runtime_index = rt - nm->nodes_by_type[n->type];
}
if (vec_len (n->runtime_data) > 0)
clib_memcpy (rt->runtime_data, n->runtime_data,
vec_len (n->runtime_data));
+ else
+ clib_memset (rt->runtime_data, 0, VLIB_NODE_RUNTIME_DATA_SIZE);
vec_free (n->runtime_data);
}
+#undef _
}
/* Register new packet processing node. */
return n_vectors;
}
+void
+vlib_register_all_node_march_variants (vlib_main_t *vm)
+{
+ vlib_node_main_t *nm = &vm->node_main;
+ vlib_node_fn_variant_t *v;
+ int prio = -1;
+
+ nm->node_fn_default_march_variant = ~0;
+ ASSERT (nm->variants == 0);
+ vec_add2 (nm->variants, v, 1);
+ v->desc = v->suffix = "default";
+ v->index = CLIB_MARCH_VARIANT_TYPE;
+
+#define _(s, n) \
+ vec_add2 (nm->variants, v, 1); \
+ v->suffix = #s; \
+ v->index = CLIB_MARCH_VARIANT_TYPE_##s; \
+ v->priority = clib_cpu_march_priority_##s (); \
+ v->desc = n;
+
+ foreach_march_variant;
+#undef _
+
+ nm->node_fn_march_variant_by_suffix = hash_create_string (0, sizeof (u32));
+
+ vec_foreach (v, nm->variants)
+ {
+ ASSERT (v->index == v - nm->variants);
+ hash_set (nm->node_fn_march_variant_by_suffix, v->suffix, v->index);
+ if (v->priority > prio)
+ prio = v->priority;
+ }
+}
+
void
vlib_register_all_static_nodes (vlib_main_t * vm)
{
}
/* *INDENT-OFF* */
- clib_bitmap_foreach (si, sib->sibling_bitmap, ({
+ clib_bitmap_foreach (si, sib->sibling_bitmap) {
vlib_node_t * m = vec_elt (nm->nodes, si);
/* Connect all of sibling's siblings to us. */
/* Connect us to all of sibling's siblings. */
n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
- }));
+ }
/* *INDENT-ON* */
/* Connect sibling to us. */
return (r.index);
}
+int
+vlib_node_set_march_variant (vlib_main_t *vm, u32 node_index,
+ clib_march_variant_type_t march_variant)
+{
+ vlib_node_fn_registration_t *fnr;
+ vlib_node_fn_variant_t *v;
+ vlib_node_t *n = vlib_get_node (vm, node_index);
+
+ if (n->node_fn_registrations == 0)
+ return -1;
+
+ fnr = n->node_fn_registrations;
+ v = vec_elt_at_index (vm->node_main.variants, march_variant);
+
+ while (fnr)
+ {
+ if (fnr->march_variant == v->index)
+ {
+ n->function = fnr->function;
+
+ for (int i = 0; i < vec_len (vlib_mains); i++)
+ {
+ vlib_node_runtime_t *nrt;
+ nrt = vlib_node_get_runtime (vlib_mains[i], n->index);
+ nrt->function = fnr->function;
+ }
+ return 0;
+ }
+ fnr = fnr->next_registration;
+ }
+ return -1;
+}
/*
* fd.io coding-style-patch-verification: ON
*