vlib: introduce vlib_get_main_by_index(), vlib_get_n_threads()
[vpp.git] / src / vlib / node.c
index 3838d95..3c96d9d 100644 (file)
@@ -47,8 +47,7 @@ vlib_get_node_by_name (vlib_main_t * vm, u8 * name)
   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);
@@ -72,32 +71,6 @@ node_set_elog_name (vlib_main_t * vm, uword node_index)
   n->name_elog_string = elog_string (&vm->elog_main, "%v%c", n->name, 0);
 }
 
-static void
-vlib_worker_thread_node_rename (u32 node_index)
-{
-  int i;
-  vlib_main_t *vm;
-  vlib_node_t *n;
-
-  if (vec_len (vlib_mains) == 1)
-    return;
-
-  vm = vlib_mains[0];
-  n = vlib_get_node (vm, node_index);
-
-  ASSERT (vlib_get_thread_index () == 0);
-  ASSERT (*vlib_worker_threads->wait_at_barrier == 1);
-
-  for (i = 1; i < vec_len (vlib_mains); i++)
-    {
-      vlib_main_t *vm_worker = vlib_mains[i];
-      vlib_node_t *n_worker = vlib_get_node (vm_worker, node_index);
-
-      n_worker->name = n->name;
-      n_worker->name_elog_string = n->name_elog_string;
-    }
-}
-
 void
 vlib_node_rename (vlib_main_t * vm, u32 node_index, char *fmt, ...)
 {
@@ -115,7 +88,7 @@ vlib_node_rename (vlib_main_t * vm, u32 node_index, char *fmt, ...)
   node_set_elog_name (vm, node_index);
 
   /* Propagate the change to all worker threads */
-  vlib_worker_thread_node_rename (node_index);
+  vlib_worker_thread_node_runtime_update ();
 }
 
 static void
@@ -157,10 +130,10 @@ vlib_node_runtime_update (vlib_main_t * vm, u32 node_index, u32 next_index)
          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);
@@ -250,14 +223,14 @@ vlib_node_add_next_with_slot (vlib_main_t * vm,
     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* */
   }
 
@@ -317,12 +290,48 @@ node_elog_init (vlib_main_t * vm, uword ni)
 #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)
@@ -334,22 +343,12 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
   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);
@@ -374,7 +373,10 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
   /* 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);
   }
@@ -405,7 +407,8 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
   _(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);
@@ -433,36 +436,26 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
     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. */
@@ -481,6 +474,9 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
       {
        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];
       }
 
@@ -509,9 +505,12 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
     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. */
@@ -535,6 +534,40 @@ null_node_fn (vlib_main_t * vm,
   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)
 {
@@ -580,9 +613,9 @@ vlib_node_get_nodes (vlib_main_t * vm, u32 max_threads, int include_stats,
 
   if (vec_len (stat_vms) == 0)
     {
-      for (i = 0; i < vec_len (vlib_mains); i++)
+      for (i = 0; i < vlib_get_n_threads (); i++)
        {
-         stat_vm = vlib_mains[i];
+         stat_vm = vlib_get_main_by_index (i);
          if (stat_vm)
            vec_add1 (stat_vms, stat_vm);
        }
@@ -661,7 +694,7 @@ vlib_node_main_init (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. */
@@ -669,7 +702,7 @@ vlib_node_main_init (vlib_main_t * vm)
 
              /* Connect us to all of sibling's siblings. */
              n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
-           }));
+           }
         /* *INDENT-ON* */
 
        /* Connect sibling to us. */
@@ -784,6 +817,39 @@ vlib_process_create (vlib_main_t * vm, char *name,
   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 < vlib_get_n_threads (); i++)
+           {
+             vlib_node_runtime_t *nrt;
+             nrt =
+               vlib_node_get_runtime (vlib_get_main_by_index (i), n->index);
+             nrt->function = fnr->function;
+           }
+         return 0;
+       }
+      fnr = fnr->next_registration;
+    }
+  return -1;
+}
 /*
  * fd.io coding-style-patch-verification: ON
  *