src/vlib/node.c

   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.c: 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 #include <vlib/vlib.h>
  41 #include <vlib/threads.h>
  42
  43 /* Query node given name. */
  44 vlib_node_t *
  45 vlib_get_node_by_name (vlib_main_t * vm, u8 * name)
  46 {
  47   vlib_node_main_t *nm = &vm->node_main;
  48   uword *p;
  49   u8 *key = name;
  50   key = format (0, "%s", key);
  51   p = hash_get (nm->node_by_name, key);
  52   if (key != name)
  53     vec_free (key);
  54   return p ? vec_elt (nm->nodes, p[0]) : 0;
  55 }
  56
  57 static void
  58 node_set_elog_name (vlib_main_t * vm, uword node_index)
  59 {
  60   vlib_node_t *n = vlib_get_node (vm, node_index);
  61   elog_event_type_t *t;
  62
  63   t = vec_elt_at_index (vm->node_call_elog_event_types, node_index);
  64   vec_free (t->format);
  65   t->format = (char *) format (0, "%v-call: %%d%c", n->name, 0);
  66
  67   t = vec_elt_at_index (vm->node_return_elog_event_types, node_index);
  68   vec_free (t->format);
  69   t->format = (char *) format (0, "%v-return: %%d%c", n->name, 0);
  70
  71   n->name_elog_string =
  72     elog_string (&vlib_global_main.elog_main, "%v%c", n->name, 0);
  73 }
  74
  75 void
  76 vlib_node_rename (vlib_main_t * vm, u32 node_index, char *fmt, ...)
  77 {
  78   va_list va;
  79   vlib_node_main_t *nm = &vm->node_main;
  80   vlib_node_t *n = vlib_get_node (vm, node_index);
  81
  82   va_start (va, fmt);
  83   hash_unset (nm->node_by_name, n->name);
  84   vec_free (n->name);
  85   n->name = va_format (0, fmt, &va);
  86   va_end (va);
  87   hash_set (nm->node_by_name, n->name, n->index);
  88
  89   node_set_elog_name (vm, node_index);
  90
  91   /* Propagate the change to all worker threads */
  92   vlib_worker_thread_node_runtime_update ();
  93 }
  94
  95 static void
  96 vlib_node_runtime_update (vlib_main_t * vm, u32 node_index, u32 next_index)
  97 {
  98   vlib_node_main_t *nm = &vm->node_main;
  99   vlib_node_runtime_t *r, *s;
 100   vlib_node_t *node, *next_node;
 101   vlib_next_frame_t *nf;
 102   vlib_pending_frame_t *pf;
 103   i32 i, j, n_insert;
 104
 105   node = vec_elt (nm->nodes, node_index);
 106   r = vlib_node_get_runtime (vm, node_index);
 107
 108   n_insert = vec_len (node->next_nodes) - r->n_next_nodes;
 109   if (n_insert > 0)
 110     {
 111       i = r->next_frame_index + r->n_next_nodes;
 112       vec_insert (nm->next_frames, n_insert, i);
 113
 114       /* Initialize newly inserted next frames. */
 115       for (j = 0; j < n_insert; j++)
 116         vlib_next_frame_init (nm->next_frames + i + j);
 117
 118       /* Relocate other next frames at higher indices. */
 119       for (j = 0; j < vec_len (nm->nodes); j++)
 120         {
 121           s = vlib_node_get_runtime (vm, j);
 122           if (j != node_index && s->next_frame_index >= i)
 123             s->next_frame_index += n_insert;
 124         }
 125
 126       /* Pending frames may need to be relocated also. */
 127       vec_foreach (pf, nm->pending_frames)
 128       {
 129         if (pf->next_frame_index != VLIB_PENDING_FRAME_NO_NEXT_FRAME
 130             && pf->next_frame_index >= i)
 131           pf->next_frame_index += n_insert;
 132       }
 133       pool_foreach (pf, nm->suspended_process_frames)  {
 134           if (pf->next_frame_index != ~0 && pf->next_frame_index >= i)
 135             pf->next_frame_index += n_insert;
 136       }
 137
 138       r->n_next_nodes = vec_len (node->next_nodes);
 139     }
 140
 141   /* Set frame's node runtime index. */
 142   next_node = vlib_get_node (vm, node->next_nodes[next_index]);
 143   nf = nm->next_frames + r->next_frame_index + next_index;
 144   nf->node_runtime_index = next_node->runtime_index;
 145
 146   vlib_worker_thread_node_runtime_update ();
 147 }
 148
 149 uword
 150 vlib_node_get_next (vlib_main_t * vm, uword node_index, uword next_node_index)
 151 {
 152   vlib_node_main_t *nm = &vm->node_main;
 153   vlib_node_t *node;
 154   uword *p;
 155
 156   node = vec_elt (nm->nodes, node_index);
 157
 158   /* Runtime has to be initialized. */
 159   ASSERT (nm->flags & VLIB_NODE_MAIN_RUNTIME_STARTED);
 160
 161   if ((p = hash_get (node->next_slot_by_node, next_node_index)))
 162     {
 163       return p[0];
 164     }
 165
 166   return (~0);
 167 }
 168
 169 /* Add next node to given node in given slot. */
 170 uword
 171 vlib_node_add_next_with_slot (vlib_main_t * vm,
 172                               uword node_index,
 173                               uword next_node_index, uword slot)
 174 {
 175   vlib_node_main_t *nm = &vm->node_main;
 176   vlib_node_t *node, *next, *old_next;
 177   u32 old_next_index;
 178   uword *p;
 179
 180   ASSERT (vlib_get_thread_index () == 0);
 181
 182   node = vec_elt (nm->nodes, node_index);
 183   next = vec_elt (nm->nodes, next_node_index);
 184
 185   /* Runtime has to be initialized. */
 186   ASSERT (nm->flags & VLIB_NODE_MAIN_RUNTIME_STARTED);
 187
 188   if ((p = hash_get (node->next_slot_by_node, next_node_index)))
 189     {
 190       /* Next already exists: slot must match. */
 191       if (slot != ~0)
 192         ASSERT (slot == p[0]);
 193       return p[0];
 194     }
 195
 196   vlib_worker_thread_barrier_sync (vm);
 197
 198   if (slot == ~0)
 199     slot = vec_len (node->next_nodes);
 200
 201   vec_validate_init_empty (node->next_nodes, slot, ~0);
 202   vec_validate (node->n_vectors_by_next_node, slot);
 203
 204   if ((old_next_index = node->next_nodes[slot]) != ~0u)
 205     {
 206       hash_unset (node->next_slot_by_node, old_next_index);
 207       old_next = vlib_get_node (vm, old_next_index);
 208       old_next->prev_node_bitmap =
 209         clib_bitmap_andnoti (old_next->prev_node_bitmap, node_index);
 210     }
 211
 212   node->next_nodes[slot] = next_node_index;
 213   hash_set (node->next_slot_by_node, next_node_index, slot);
 214
 215   vlib_node_runtime_update (vm, node_index, slot);
 216
 217   next->prev_node_bitmap = clib_bitmap_ori (next->prev_node_bitmap,
 218                                             node_index);
 219
 220   /* Siblings all get same node structure. */
 221   {
 222     uword sib_node_index, sib_slot;
 223     vlib_node_t *sib_node;
 224     clib_bitmap_foreach (sib_node_index, node->sibling_bitmap)  {
 225       sib_node = vec_elt (nm->nodes, sib_node_index);
 226       if (sib_node != node)
 227         {
 228           sib_slot = vlib_node_add_next_with_slot (vm, sib_node_index, next_node_index, slot);
 229           ASSERT (sib_slot == slot);
 230         }
 231     }
 232   }
 233
 234   vlib_worker_thread_barrier_release (vm);
 235   return slot;
 236 }
 237
 238 /* Add named next node to given node in given slot. */
 239 uword
 240 vlib_node_add_named_next_with_slot (vlib_main_t * vm,
 241                                     uword node, char *name, uword slot)
 242 {
 243   vlib_node_main_t *nm;
 244   vlib_node_t *n, *n_next;
 245
 246   nm = &vm->node_main;
 247   n = vlib_get_node (vm, node);
 248
 249   n_next = vlib_get_node_by_name (vm, (u8 *) name);
 250   if (!n_next)
 251     {
 252       if (nm->flags & VLIB_NODE_MAIN_RUNTIME_STARTED)
 253         return ~0;
 254
 255       if (slot == ~0)
 256         slot = clib_max (vec_len (n->next_node_names),
 257                          vec_len (n->next_nodes));
 258       vec_validate (n->next_node_names, slot);
 259       n->next_node_names[slot] = name;
 260       return slot;
 261     }
 262
 263   return vlib_node_add_next_with_slot (vm, node, n_next->index, slot);
 264 }
 265
 266 static void
 267 node_elog_init (vlib_main_t * vm, uword ni)
 268 {
 269   elog_event_type_t t;
 270
 271   clib_memset (&t, 0, sizeof (t));
 272
 273   /* 2 event types for this node: one when node function is called.
 274      One when it returns. */
 275   vec_validate (vm->node_call_elog_event_types, ni);
 276   vm->node_call_elog_event_types[ni] = t;
 277
 278   vec_validate (vm->node_return_elog_event_types, ni);
 279   vm->node_return_elog_event_types[ni] = t;
 280
 281   node_set_elog_name (vm, ni);
 282 }
 283
 284 #ifdef CLIB_UNIX
 285 #define STACK_ALIGN (clib_mem_get_page_size())
 286 #else
 287 #define STACK_ALIGN CLIB_CACHE_LINE_BYTES
 288 #endif
 289
 290 vlib_node_function_t *
 291 vlib_node_get_preferred_node_fn_variant (vlib_main_t *vm,
 292                                          vlib_node_fn_registration_t *regs)
 293 {
 294   vlib_node_main_t *nm = &vm->node_main;
 295   vlib_node_fn_registration_t *r;
 296   vlib_node_fn_variant_t *v;
 297   vlib_node_function_t *fn = 0;
 298   int priority = -1;
 299
 300   if (nm->node_fn_default_march_variant != ~0)
 301     {
 302       r = regs;
 303       while (r)
 304         {
 305           if (r->march_variant == nm->node_fn_default_march_variant)
 306             return r->function;
 307           r = r->next_registration;
 308         }
 309     }
 310
 311   r = regs;
 312   while (r)
 313     {
 314       v = vec_elt_at_index (nm->variants, r->march_variant);
 315       if (v->priority > priority)
 316         {
 317           priority = v->priority;
 318           fn = r->function;
 319         }
 320       r = r->next_registration;
 321     }
 322
 323   ASSERT (fn);
 324   return fn;
 325 }
 326
 327 static void
 328 vlib_node_add_to_sibling_bitmap (vlib_main_t *vm, vlib_node_t *n,
 329                                  vlib_node_t *sib)
 330 {
 331   vlib_node_main_t *nm = &vm->node_main;
 332   u32 si;
 333
 334   clib_bitmap_foreach (si, sib->sibling_bitmap)
 335     {
 336       vlib_node_t *m = vec_elt (nm->nodes, si);
 337
 338       /* Connect all of sibling's siblings to us. */
 339       m->sibling_bitmap = clib_bitmap_ori (m->sibling_bitmap, n->index);
 340
 341       /* Connect us to all of sibling's siblings. */
 342       n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
 343     }
 344
 345   /* Connect sibling to us. */
 346   sib->sibling_bitmap = clib_bitmap_ori (sib->sibling_bitmap, n->index);
 347
 348   /* Connect us to sibling. */
 349   n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, sib->index);
 350 }
 351
 352 u32
 353 vlib_register_node (vlib_main_t *vm, vlib_node_registration_t *r, char *fmt,
 354                     ...)
 355 {
 356   vlib_node_main_t *nm = &vm->node_main;
 357   vlib_node_t *n, *sib = 0;
 358   va_list va;
 359   u32 size;
 360   int i;
 361
 362   if (r->sibling_of)
 363     {
 364       if (r->n_next_nodes > 0)
 365         clib_error ("sibling node should not have any next nodes `%v'",
 366                     r->name);
 367       if (nm->flags & VLIB_NODE_MAIN_RUNTIME_STARTED)
 368         {
 369           sib = vlib_get_node_by_name (vm, (u8 *) r->sibling_of);
 370
 371           if (sib == 0)
 372             clib_error ("unknown sibling node '%s'", r->sibling_of);
 373         }
 374     }
 375
 376   if (CLIB_DEBUG > 0)
 377     {
 378       /* Default (0) type should match INTERNAL. */
 379       vlib_node_t zero = { 0 };
 380       ASSERT (VLIB_NODE_TYPE_INTERNAL == zero.type);
 381     }
 382
 383   if (r->node_fn_registrations)
 384     {
 385       /* to avoid confusion, please remove ".function " statiement from
 386          CLIB_NODE_REGISTRATION() if using function function candidates */
 387       ASSERT (r->function == 0);
 388
 389       r->function =
 390         vlib_node_get_preferred_node_fn_variant (vm, r->node_fn_registrations);
 391     }
 392
 393   ASSERT (r->function != 0);
 394
 395   n = clib_mem_alloc_no_fail (sizeof (n[0]));
 396   clib_memset (n, 0, sizeof (n[0]));
 397   n->index = vec_len (nm->nodes);
 398   n->node_fn_registrations = r->node_fn_registrations;
 399   n->protocol_hint = r->protocol_hint;
 400
 401   vec_add1 (nm->nodes, n);
 402
 403   va_start (va, fmt);
 404   n->name = va_format (0, fmt, &va);
 405   va_end (va);
 406
 407   if (!nm->node_by_name)
 408     nm->node_by_name = hash_create_vec ( /* size */ 32,
 409                                         sizeof (n->name[0]), sizeof (uword));
 410
 411   /* Node names must be unique. */
 412   {
 413     /* vlib_get_node_by_name() expects NULL-terminated strings */
 414     u8 *name = format (0, "%v%c", n->name, 0);
 415     vlib_node_t *o = vlib_get_node_by_name (vm, name);
 416     vec_free (name);
 417     if (o)
 418       clib_error ("more than one node named `%v'", n->name);
 419   }
 420
 421   hash_set (nm->node_by_name, n->name, n->index);
 422
 423   r->index = n->index;          /* save index in registration */
 424   n->function = r->function;
 425
 426   if (r->type == VLIB_NODE_TYPE_INTERNAL)
 427     ASSERT (r->vector_size > 0);
 428
 429 #define _(f) n->f = r->f
 430
 431   _(type);
 432   _(flags);
 433   _(state);
 434   _(format_buffer);
 435   _(unformat_buffer);
 436   _(format_trace);
 437   _(validate_frame);
 438
 439   size = round_pow2 (sizeof (vlib_frame_t), VLIB_FRAME_DATA_ALIGN);
 440
 441   /* scalar data size */
 442   if (r->scalar_size)
 443     {
 444       n->scalar_offset = size;
 445       size += round_pow2 (r->scalar_size, VLIB_FRAME_DATA_ALIGN);
 446     }
 447   else
 448     n->scalar_offset = 0;
 449
 450   /* Vecor data size */
 451   n->vector_offset = size;
 452   size += r->vector_size * VLIB_FRAME_SIZE;
 453
 454   /* Allocate a few extra slots of vector data to support
 455      speculative vector enqueues which overflow vector data in next frame. */
 456   size += r->vector_size * VLIB_FRAME_SIZE_EXTRA;
 457
 458   /* space for VLIB_FRAME_MAGIC */
 459   n->magic_offset = size;
 460   size += sizeof (u32);
 461
 462   /* round size to VLIB_FRAME_DATA_ALIGN */
 463   size = round_pow2 (size, VLIB_FRAME_DATA_ALIGN);
 464
 465   if (r->aux_size)
 466     {
 467       n->aux_offset = size;
 468       size += r->aux_size * VLIB_FRAME_SIZE;
 469     }
 470   else
 471     n->aux_offset = 0;
 472
 473   /* final size */
 474   n->frame_size = size = round_pow2 (size, CLIB_CACHE_LINE_BYTES);
 475   ASSERT (size <= __UINT16_MAX__);
 476
 477   vlib_frame_size_t *fs = 0;
 478
 479   n->frame_size_index = (u16) ~0;
 480   vec_foreach (fs, nm->frame_sizes)
 481     if (fs->frame_size == size)
 482       {
 483         n->frame_size_index = fs - nm->frame_sizes;
 484         break;
 485       }
 486
 487   if (n->frame_size_index == (u16) ~0)
 488     {
 489       vec_add2 (nm->frame_sizes, fs, 1);
 490       fs->frame_size = size;
 491       n->frame_size_index = fs - nm->frame_sizes;
 492     }
 493
 494   /* Register error counters. */
 495   vlib_register_errors (vm, n->index, r->n_errors, r->error_strings,
 496                         r->error_counters);
 497   node_elog_init (vm, n->index);
 498
 499   _(runtime_data_bytes);
 500   if (r->runtime_data_bytes > 0)
 501     {
 502       vec_resize (n->runtime_data, r->runtime_data_bytes);
 503       if (r->runtime_data)
 504         clib_memcpy (n->runtime_data, r->runtime_data, r->runtime_data_bytes);
 505     }
 506
 507   vec_resize (n->next_node_names, r->n_next_nodes);
 508   for (i = 0; i < r->n_next_nodes; i++)
 509     n->next_node_names[i] = r->next_nodes[i];
 510
 511   vec_validate_init_empty (n->next_nodes, r->n_next_nodes - 1, ~0);
 512   vec_validate (n->n_vectors_by_next_node, r->n_next_nodes - 1);
 513
 514   n->owner_node_index = n->owner_next_index = ~0;
 515
 516   /* Initialize node runtime. */
 517   {
 518     vlib_node_runtime_t *rt;
 519     u32 i;
 520
 521     if (n->type == VLIB_NODE_TYPE_PROCESS)
 522       {
 523         vlib_process_t *p;
 524         uword log2_n_stack_bytes;
 525
 526         log2_n_stack_bytes = clib_max (r->process_log2_n_stack_bytes,
 527                                        VLIB_PROCESS_LOG2_STACK_SIZE);
 528         log2_n_stack_bytes = clib_max (log2_n_stack_bytes,
 529                                        clib_mem_get_log2_page_size ());
 530
 531         p = clib_mem_alloc_aligned (sizeof (p[0]), CLIB_CACHE_LINE_BYTES);
 532         clib_memset (p, 0, sizeof (p[0]));
 533         p->log2_n_stack_bytes = log2_n_stack_bytes;
 534
 535         p->stack = clib_mem_vm_map_stack (1ULL << log2_n_stack_bytes,
 536                                           CLIB_MEM_PAGE_SZ_DEFAULT,
 537                                           "process stack: %U",
 538                                           format_vlib_node_name, vm,
 539                                           n->index);
 540
 541         if (p->stack == CLIB_MEM_VM_MAP_FAILED)
 542           clib_panic ("failed to allocate process stack (%d bytes)",
 543                       1ULL << log2_n_stack_bytes);
 544
 545         /* Process node's runtime index is really index into process
 546            pointer vector. */
 547         n->runtime_index = vec_len (nm->processes);
 548
 549         vec_add1 (nm->processes, p);
 550
 551         /* Paint first stack word with magic number so we can at least
 552            detect process stack overruns. */
 553         p->stack[0] = VLIB_PROCESS_STACK_MAGIC;
 554
 555         /* Node runtime is stored inside of process. */
 556         rt = &p->node_runtime;
 557       }
 558     else
 559       {
 560         vec_add2_aligned (nm->nodes_by_type[n->type], rt, 1,
 561                           /* align */ CLIB_CACHE_LINE_BYTES);
 562         if (n->type == VLIB_NODE_TYPE_INPUT)
 563           clib_interrupt_resize (&nm->input_node_interrupts,
 564                                  vec_len (nm->nodes_by_type[n->type]));
 565         else if (n->type == VLIB_NODE_TYPE_PRE_INPUT)
 566           clib_interrupt_resize (&nm->pre_input_node_interrupts,
 567                                  vec_len (nm->nodes_by_type[n->type]));
 568         n->runtime_index = rt - nm->nodes_by_type[n->type];
 569       }
 570
 571     if (n->type == VLIB_NODE_TYPE_INPUT)
 572       nm->input_node_counts_by_state[n->state] += 1;
 573
 574     rt->function = n->function;
 575     rt->flags = n->flags;
 576     rt->state = n->state;
 577     rt->node_index = n->index;
 578
 579     rt->n_next_nodes = r->n_next_nodes;
 580     rt->next_frame_index = vec_len (nm->next_frames);
 581
 582     vec_resize (nm->next_frames, rt->n_next_nodes);
 583     for (i = 0; i < rt->n_next_nodes; i++)
 584       vlib_next_frame_init (nm->next_frames + rt->next_frame_index + i);
 585
 586     vec_resize (rt->errors, r->n_errors);
 587     for (i = 0; i < vec_len (rt->errors); i++)
 588       rt->errors[i] = n->error_heap_index + i;
 589
 590     STATIC_ASSERT_SIZEOF (vlib_node_runtime_t, 128);
 591     ASSERT (vec_len (n->runtime_data) <= VLIB_NODE_RUNTIME_DATA_SIZE);
 592
 593     if (vec_len (n->runtime_data) > 0)
 594       clib_memcpy (rt->runtime_data, n->runtime_data,
 595                    vec_len (n->runtime_data));
 596     else
 597       clib_memset (rt->runtime_data, 0, VLIB_NODE_RUNTIME_DATA_SIZE);
 598
 599     vec_free (n->runtime_data);
 600   }
 601 #undef _
 602
 603   if (sib)
 604     {
 605       u32 slot, i;
 606
 607       vec_foreach_index (i, sib->next_nodes)
 608         {
 609           slot =
 610             vlib_node_add_next_with_slot (vm, n->index, sib->next_nodes[i], i);
 611           ASSERT (slot == i);
 612         }
 613
 614       vlib_node_add_to_sibling_bitmap (vm, n, sib);
 615
 616       r->n_next_nodes = vec_len (n->next_nodes);
 617     }
 618   n->sibling_of = r->sibling_of;
 619
 620   return r->index;
 621 }
 622
 623 static uword
 624 null_node_fn (vlib_main_t * vm,
 625               vlib_node_runtime_t * node, vlib_frame_t * frame)
 626 {
 627   u16 n_vectors = frame->n_vectors;
 628
 629   vlib_node_increment_counter (vm, node->node_index, 0, n_vectors);
 630   vlib_buffer_free (vm, vlib_frame_vector_args (frame), n_vectors);
 631   vlib_frame_free (vm, frame);
 632
 633   return n_vectors;
 634 }
 635
 636 void
 637 vlib_register_all_node_march_variants (vlib_main_t *vm)
 638 {
 639   vlib_node_main_t *nm = &vm->node_main;
 640   vlib_node_fn_variant_t *v;
 641   int prio = -1;
 642
 643   nm->node_fn_default_march_variant = ~0;
 644   ASSERT (nm->variants == 0);
 645   vec_add2 (nm->variants, v, 1);
 646   v->desc = v->suffix = "default";
 647   v->index = CLIB_MARCH_VARIANT_TYPE;
 648
 649 #define _(s, n)                                                               \
 650   vec_add2 (nm->variants, v, 1);                                              \
 651   v->suffix = #s;                                                             \
 652   v->index = CLIB_MARCH_VARIANT_TYPE_##s;                                     \
 653   v->priority = clib_cpu_march_priority_##s ();                               \
 654   v->desc = n;
 655
 656   foreach_march_variant;
 657 #undef _
 658
 659   nm->node_fn_march_variant_by_suffix = hash_create_string (0, sizeof (u32));
 660
 661   vec_foreach (v, nm->variants)
 662     {
 663       ASSERT (v->index == v - nm->variants);
 664       hash_set (nm->node_fn_march_variant_by_suffix, v->suffix, v->index);
 665       if (v->priority > prio)
 666         prio = v->priority;
 667     }
 668 }
 669
 670 void
 671 vlib_register_all_static_nodes (vlib_main_t * vm)
 672 {
 673   vlib_global_main_t *vgm = vlib_get_global_main ();
 674   vlib_node_registration_t *r;
 675
 676   static char *null_node_error_strings[] = {
 677     "blackholed packets",
 678   };
 679
 680   static vlib_node_registration_t null_node_reg = {
 681     .function = null_node_fn,
 682     .vector_size = sizeof (u32),
 683     .n_errors = 1,
 684     .error_strings = null_node_error_strings,
 685   };
 686
 687   /* make sure that node index 0 is not used by
 688      real node */
 689   vlib_register_node (vm, &null_node_reg, "null-node");
 690
 691   r = vgm->node_registrations;
 692   while (r)
 693     {
 694       vlib_register_node (vm, r, "%s", r->name);
 695       r = r->next_registration;
 696     }
 697 }
 698
 699 void
 700 vlib_node_get_nodes (vlib_main_t * vm, u32 max_threads, int include_stats,
 701                      int barrier_sync, vlib_node_t **** node_dupsp,
 702                      vlib_main_t *** stat_vmsp)
 703 {
 704   vlib_node_main_t *nm = &vm->node_main;
 705   vlib_node_t *n;
 706   vlib_node_t ***node_dups = *node_dupsp;
 707   vlib_node_t **nodes;
 708   vlib_main_t **stat_vms = *stat_vmsp;
 709   vlib_main_t *stat_vm;
 710   uword i, j;
 711   u32 threads_to_serialize;
 712
 713   if (vec_len (stat_vms) == 0)
 714     {
 715       for (i = 0; i < vlib_get_n_threads (); i++)
 716         {
 717           stat_vm = vlib_get_main_by_index (i);
 718           if (stat_vm)
 719             vec_add1 (stat_vms, stat_vm);
 720         }
 721     }
 722
 723   threads_to_serialize = clib_min (max_threads, vec_len (stat_vms));
 724
 725   vec_validate (node_dups, threads_to_serialize - 1);
 726
 727   /*
 728    * Barrier sync across stats scraping.
 729    * Otherwise, the counts will be grossly inaccurate.
 730    */
 731   if (barrier_sync)
 732     vlib_worker_thread_barrier_sync (vm);
 733
 734   for (j = 0; j < threads_to_serialize; j++)
 735     {
 736       stat_vm = stat_vms[j];
 737       nm = &stat_vm->node_main;
 738
 739       if (include_stats)
 740         {
 741           for (i = 0; i < vec_len (nm->nodes); i++)
 742             {
 743               n = nm->nodes[i];
 744               vlib_node_sync_stats (stat_vm, n);
 745             }
 746         }
 747
 748       nodes = node_dups[j];
 749       vec_validate (nodes, vec_len (nm->nodes) - 1);
 750       clib_memcpy (nodes, nm->nodes, vec_len (nm->nodes) * sizeof (nodes[0]));
 751       node_dups[j] = nodes;
 752     }
 753
 754   if (barrier_sync)
 755     vlib_worker_thread_barrier_release (vm);
 756
 757   *node_dupsp = node_dups;
 758   *stat_vmsp = stat_vms;
 759 }
 760
 761 clib_error_t *
 762 vlib_node_main_init (vlib_main_t * vm)
 763 {
 764   vlib_node_main_t *nm = &vm->node_main;
 765   clib_error_t *error = 0;
 766   vlib_node_t *n;
 767   uword ni;
 768
 769   nm->flags |= VLIB_NODE_MAIN_RUNTIME_STARTED;
 770
 771   /* Generate sibling relationships */
 772   {
 773     vlib_node_t *n, *sib;
 774
 775     for (ni = 0; ni < vec_len (nm->nodes); ni++)
 776       {
 777         n = vec_elt (nm->nodes, ni);
 778
 779         if (!n->sibling_of)
 780           continue;
 781
 782         sib = vlib_get_node_by_name (vm, (u8 *) n->sibling_of);
 783         if (!sib)
 784           {
 785             error = clib_error_create ("sibling `%s' not found for node `%v'",
 786                                        n->sibling_of, n->name);
 787             goto done;
 788           }
 789
 790         vlib_node_add_to_sibling_bitmap (vm, n, sib);
 791       }
 792   }
 793
 794   /* Resolve next names into next indices. */
 795   for (ni = 0; ni < vec_len (nm->nodes); ni++)
 796     {
 797       uword i;
 798
 799       n = vec_elt (nm->nodes, ni);
 800
 801       for (i = 0; i < vec_len (n->next_node_names); i++)
 802         {
 803           char *a = n->next_node_names[i];
 804
 805           if (!a)
 806             continue;
 807
 808           if (~0 == vlib_node_add_named_next_with_slot (vm, n->index, a, i))
 809             {
 810               error = clib_error_create
 811                 ("node `%v' refers to unknown node `%s'", n->name, a);
 812               goto done;
 813             }
 814         }
 815
 816       vec_free (n->next_node_names);
 817     }
 818
 819   /* Set previous node pointers. */
 820   for (ni = 0; ni < vec_len (nm->nodes); ni++)
 821     {
 822       vlib_node_t *n_next;
 823       uword i;
 824
 825       n = vec_elt (nm->nodes, ni);
 826
 827       for (i = 0; i < vec_len (n->next_nodes); i++)
 828         {
 829           if (n->next_nodes[i] >= vec_len (nm->nodes))
 830             continue;
 831
 832           n_next = vec_elt (nm->nodes, n->next_nodes[i]);
 833           n_next->prev_node_bitmap =
 834             clib_bitmap_ori (n_next->prev_node_bitmap, n->index);
 835         }
 836     }
 837
 838   {
 839     vlib_next_frame_t *nf;
 840     vlib_node_runtime_t *r;
 841     vlib_node_t *next;
 842     uword i;
 843
 844     vec_foreach (r, nm->nodes_by_type[VLIB_NODE_TYPE_INTERNAL])
 845     {
 846       if (r->n_next_nodes == 0)
 847         continue;
 848
 849       n = vlib_get_node (vm, r->node_index);
 850       nf = vec_elt_at_index (nm->next_frames, r->next_frame_index);
 851
 852       for (i = 0; i < vec_len (n->next_nodes); i++)
 853         {
 854           next = vlib_get_node (vm, n->next_nodes[i]);
 855
 856           /* Validate node runtime indices are correctly initialized. */
 857           ASSERT (nf[i].node_runtime_index == next->runtime_index);
 858
 859           nf[i].flags = 0;
 860           if (next->flags & VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH)
 861             nf[i].flags |= VLIB_FRAME_NO_FREE_AFTER_DISPATCH;
 862         }
 863     }
 864   }
 865
 866 done:
 867   return error;
 868 }
 869
 870 u32
 871 vlib_process_create (vlib_main_t * vm, char *name,
 872                      vlib_node_function_t * f, u32 log2_n_stack_bytes)
 873 {
 874   vlib_node_registration_t r;
 875   vlib_node_t *n;
 876
 877   memset (&r, 0, sizeof (r));
 878
 879   r.function = f;
 880   r.process_log2_n_stack_bytes = log2_n_stack_bytes;
 881   r.type = VLIB_NODE_TYPE_PROCESS;
 882
 883   vlib_worker_thread_barrier_sync (vm);
 884
 885   vlib_register_node (vm, &r, "%s", name);
 886   vec_free (r.name);
 887
 888   vlib_worker_thread_node_runtime_update ();
 889   vlib_worker_thread_barrier_release (vm);
 890
 891   n = vlib_get_node (vm, r.index);
 892   vlib_start_process (vm, n->runtime_index);
 893
 894   return (r.index);
 895 }
 896
 897 int
 898 vlib_node_set_march_variant (vlib_main_t *vm, u32 node_index,
 899                              clib_march_variant_type_t march_variant)
 900 {
 901   vlib_node_fn_registration_t *fnr;
 902   vlib_node_fn_variant_t *v;
 903   vlib_node_t *n = vlib_get_node (vm, node_index);
 904
 905   if (n->node_fn_registrations == 0)
 906     return -1;
 907
 908   fnr = n->node_fn_registrations;
 909   v = vec_elt_at_index (vm->node_main.variants, march_variant);
 910
 911   while (fnr)
 912     {
 913       if (fnr->march_variant == v->index)
 914         {
 915           n->function = fnr->function;
 916
 917           for (int i = 0; i < vlib_get_n_threads (); i++)
 918             {
 919               vlib_node_runtime_t *nrt;
 920               nrt =
 921                 vlib_node_get_runtime (vlib_get_main_by_index (i), n->index);
 922               nrt->function = fnr->function;
 923             }
 924           return 0;
 925         }
 926       fnr = fnr->next_registration;
 927     }
 928   return -1;
 929 }
 930 /*
 931  * fd.io coding-style-patch-verification: ON
 932  *
 933  * Local Variables:
 934  * eval: (c-set-style "gnu")
 935  * End:
 936  */