FD.io VPP  v17.01-9-ge7dcee4
Vector Packet Processing
interface.c
Go to the documentation of this file.
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  * interface.c: VNET interfaces/sub-interfaces
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 <vnet/vnet.h>
41 #include <vnet/plugin/plugin.h>
42 #include <vnet/fib/ip6_fib.h>
43 #include <vnet/adj/adj.h>
44 #include <vnet/l2/l2_output.h>
45 
46 #define VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE (1 << 0)
47 #define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE (1 << 1)
48 
50  u32 hw_if_index,
51  u32 flags,
52  u32 helper_flags);
53 
55  u32 sw_if_index,
56  u32 flags,
57  u32 helper_flags);
58 
60  u32 hw_if_index,
61  u32 hw_class_index,
62  u32 redistribute);
63 
64 typedef struct
65 {
66  /* Either sw or hw interface index. */
68 
69  /* Flags. */
72 
73 static void
75 {
77  va_arg (*va, vnet_sw_hw_interface_state_t *);
78  u32 n = va_arg (*va, u32);
79  u32 i;
80  for (i = 0; i < n; i++)
81  {
82  serialize_integer (m, s[i].sw_hw_if_index,
83  sizeof (s[i].sw_hw_if_index));
84  serialize_integer (m, s[i].flags, sizeof (s[i].flags));
85  }
86 }
87 
88 static void
90  va_list * va)
91 {
93  va_arg (*va, vnet_sw_hw_interface_state_t *);
94  u32 n = va_arg (*va, u32);
95  u32 i;
96  for (i = 0; i < n; i++)
97  {
98  unserialize_integer (m, &s[i].sw_hw_if_index,
99  sizeof (s[i].sw_hw_if_index));
100  unserialize_integer (m, &s[i].flags, sizeof (s[i].flags));
101  }
102 }
103 
104 static void
106 {
108  va_arg (*va, vnet_sw_hw_interface_state_t *);
110 }
111 
112 static void
114 {
115  CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *);
117 
119 
122  /* helper_flags no redistribution */ 0);
123 }
124 
125 static void
127 {
128  CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *);
130 
132 
135  /* helper_flags no redistribution */ 0);
136 }
137 
138 MC_SERIALIZE_MSG (vnet_sw_interface_set_flags_msg, static) =
139 {
140 .name = "vnet_sw_interface_set_flags",.serialize =
143 
144 MC_SERIALIZE_MSG (vnet_hw_interface_set_flags_msg, static) =
145 {
146 .name = "vnet_hw_interface_set_flags",.serialize =
149 
150 void
152 {
153  vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
154  vnet_sw_hw_interface_state_t *sts = 0, *st;
155  vnet_sw_interface_t *sif;
156  vnet_hw_interface_t *hif;
158 
159  /* Serialize hardware interface classes since they may have changed.
160  Must do this before sending up/down flags. */
161  /* *INDENT-OFF* */
162  pool_foreach (hif, im->hw_interfaces, ({
163  vnet_hw_interface_class_t * hw_class = vnet_get_hw_interface_class (vnm, hif->hw_class_index);
164  serialize_cstring (m, hw_class->name);
165  }));
166  /* *INDENT-ON* */
167 
168  /* Send sw/hw interface state when non-zero. */
169  /* *INDENT-OFF* */
170  pool_foreach (sif, im->sw_interfaces, ({
171  if (sif->flags != 0)
172  {
173  vec_add2 (sts, st, 1);
174  st->sw_hw_if_index = sif->sw_if_index;
175  st->flags = sif->flags;
176  }
177  }));
178  /* *INDENT-ON* */
179 
181 
182  if (sts)
183  _vec_len (sts) = 0;
184 
185  /* *INDENT-OFF* */
186  pool_foreach (hif, im->hw_interfaces, ({
187  if (hif->flags != 0)
188  {
189  vec_add2 (sts, st, 1);
190  st->sw_hw_if_index = hif->hw_if_index;
191  st->flags = hif->flags;
192  }
193  }));
194  /* *INDENT-ON* */
195 
197 
198  vec_free (sts);
199 }
200 
201 void
203 {
204  vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
205  vnet_sw_hw_interface_state_t *sts = 0, *st;
206 
207  /* First set interface hardware class. */
208  {
210  vnet_hw_interface_t *hif;
211  char *class_name;
212  uword *p;
213  clib_error_t *error;
214 
215  /* *INDENT-OFF* */
216  pool_foreach (hif, im->hw_interfaces, ({
217  unserialize_cstring (m, &class_name);
218  p = hash_get_mem (im->hw_interface_class_by_name, class_name);
219  ASSERT (p != 0);
220  error = vnet_hw_interface_set_class_helper (vnm, hif->hw_if_index, p[0], /* redistribute */ 0);
221  if (error)
222  clib_error_report (error);
223  vec_free (class_name);
224  }));
225  /* *INDENT-ON* */
226  }
227 
229  vec_foreach (st, sts)
230  vnet_sw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags,
231  /* no distribute */ 0);
232  vec_free (sts);
233 
235  vec_foreach (st, sts)
236  vnet_hw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags,
237  /* no distribute */ 0);
238  vec_free (sts);
239 }
240 
241 static clib_error_t *
243  u32 flags,
244  _vnet_interface_function_list_elt_t **
245  elts)
246 {
247  _vnet_interface_function_list_elt_t *elt;
249  clib_error_t *error = 0;
250 
251  for (prio = VNET_ITF_FUNC_PRIORITY_LOW;
252  prio <= VNET_ITF_FUNC_PRIORITY_HIGH; prio++)
253  {
254  elt = elts[prio];
255 
256  while (elt)
257  {
258  error = elt->fp (vnm, if_index, flags);
259  if (error)
260  return error;
261  elt = elt->next_interface_function;
262  }
263  }
264  return error;
265 }
266 
267 static clib_error_t *
269  u32 is_create)
270 {
271  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
272  vnet_hw_interface_class_t *hw_class =
274  vnet_device_class_t *dev_class =
276  clib_error_t *error = 0;
277 
278  if (hw_class->interface_add_del_function
279  && (error =
280  hw_class->interface_add_del_function (vnm, hw_if_index, is_create)))
281  return error;
282 
283  if (dev_class->interface_add_del_function
284  && (error =
285  dev_class->interface_add_del_function (vnm, hw_if_index,
286  is_create)))
287  return error;
288 
290  (vnm, hw_if_index, is_create, vnm->hw_interface_add_del_functions);
291 
292  return error;
293 }
294 
295 static clib_error_t *
297  u32 is_create)
298 {
300  (vnm, sw_if_index, is_create, vnm->sw_interface_add_del_functions);
301 }
302 
303 #define VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE (1 << 0)
304 #define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE (1 << 1)
305 
306 static clib_error_t *
308  u32 flags, u32 helper_flags)
309 {
310  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
311  vnet_hw_interface_class_t *hw_class =
313  vnet_device_class_t *dev_class =
315  vlib_main_t *vm = vnm->vlib_main;
316  u32 mask;
317  clib_error_t *error = 0;
318  u32 is_create =
319  (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
320 
321  mask =
324  flags &= mask;
325 
326  /* Call hardware interface add/del callbacks. */
327  if (is_create)
328  call_hw_interface_add_del_callbacks (vnm, hw_if_index, is_create);
329 
330  /* Already in the desired state? */
331  if (!is_create && (hi->flags & mask) == flags)
332  goto done;
333 
334  /* Some interface classes do not redistribute (e.g. are local). */
335  if (!dev_class->redistribute)
337 
338  if (vm->mc_main
340  {
342  s.sw_hw_if_index = hw_if_index;
343  s.flags = flags;
344  mc_serialize (vm->mc_main, &vnet_hw_interface_set_flags_msg, &s);
345  }
346 
349  {
350  /* Do hardware class (e.g. ethernet). */
351  if (hw_class->link_up_down_function
352  && (error = hw_class->link_up_down_function (vnm, hw_if_index,
353  flags)))
354  goto done;
355 
357  (vnm, hw_if_index, flags, vnm->hw_interface_link_up_down_functions);
358 
359  if (error)
360  goto done;
361  }
362 
363  hi->flags &= ~mask;
364  hi->flags |= flags;
365 
366 done:
367  return error;
368 }
369 
370 static clib_error_t *
372  u32 flags, u32 helper_flags)
373 {
374  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
375  vlib_main_t *vm = vnm->vlib_main;
376  u32 mask;
377  clib_error_t *error = 0;
378  u32 is_create =
379  (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
380  u32 old_flags;
381 
383  flags &= mask;
384 
385  if (is_create)
386  {
387  error =
388  call_sw_interface_add_del_callbacks (vnm, sw_if_index, is_create);
389  if (error)
390  goto done;
391 
393  {
394  /* Notify everyone when the interface is created as admin up */
395  error = call_elf_section_interface_callbacks (vnm, sw_if_index,
396  flags,
397  vnm->
398  sw_interface_admin_up_down_functions);
399  if (error)
400  goto done;
401  }
402  }
403  else
404  {
405  vnet_sw_interface_t *si_sup = si;
406 
407  /* Check that super interface is in correct state. */
408  if (si->type == VNET_SW_INTERFACE_TYPE_SUB)
409  {
410  si_sup = vnet_get_sw_interface (vnm, si->sup_sw_if_index);
411 
412  /* Check to see if we're bringing down the soft interface and if it's parent is up */
413  if ((flags != (si_sup->flags & mask)) &&
414  (!((flags == 0)
415  && ((si_sup->flags & mask) ==
417  {
418  error = clib_error_return (0, "super-interface %U must be %U",
420  si_sup,
422  flags);
423  goto done;
424  }
425  }
426 
427  /* Donot change state for slave link of bonded interfaces */
429  {
430  error = clib_error_return
431  (0, "not allowed as %U belong to a BondEthernet interface",
433  goto done;
434  }
435 
436  /* Already in the desired state? */
437  if ((si->flags & mask) == flags)
438  goto done;
439 
440  /* Sub-interfaces of hardware interfaces that do no redistribute,
441  do not redistribute themselves. */
442  if (si_sup->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
443  {
445  vnet_get_hw_interface (vnm, si_sup->hw_if_index);
446  vnet_device_class_t *dev_class =
448  if (!dev_class->redistribute)
449  helper_flags &=
451  }
452 
453  if (vm->mc_main
454  && (helper_flags &
456  {
458  s.sw_hw_if_index = sw_if_index;
459  s.flags = flags;
460  mc_serialize (vm->mc_main, &vnet_sw_interface_set_flags_msg, &s);
461  }
462 
463  /* set the flags now before invoking the registered clients
464  * so that the state they query is consistent with the state here notified */
465  old_flags = si->flags;
466  si->flags &= ~mask;
467  si->flags |= flags;
468  if ((flags | old_flags) & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
470  (vnm, sw_if_index, flags,
472  si->flags = old_flags;
473 
474  if (error)
475  goto done;
476 
478  {
481  vnet_hw_interface_class_t *hw_class =
483  vnet_device_class_t *dev_class =
485 
486  /* save the si admin up flag */
487  old_flags = si->flags;
488 
489  /* update si admin up flag in advance if we are going admin down */
490  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
491  si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP;
492 
493  if (dev_class->admin_up_down_function
494  && (error = dev_class->admin_up_down_function (vnm,
495  si->hw_if_index,
496  flags)))
497  {
498  /* restore si admin up flag to it's original state on errors */
499  si->flags = old_flags;
500  goto done;
501  }
502 
503  if (hw_class->admin_up_down_function
504  && (error = hw_class->admin_up_down_function (vnm,
505  si->hw_if_index,
506  flags)))
507  {
508  /* restore si admin up flag to it's original state on errors */
509  si->flags = old_flags;
510  goto done;
511  }
512 
513  /* Admin down implies link down. */
514  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
517  hi->flags &
519  helper_flags);
520  }
521  }
522 
523  si->flags &= ~mask;
524  si->flags |= flags;
525 
526 done:
527  return error;
528 }
529 
530 clib_error_t *
532 {
534  (vnm, hw_if_index, flags,
536 }
537 
538 clib_error_t *
540 {
542  (vnm, sw_if_index, flags,
544 }
545 
546 static u32
548  vnet_sw_interface_t * template)
549 {
552  u32 sw_if_index;
553 
554  pool_get (im->sw_interfaces, sw);
555  sw_if_index = sw - im->sw_interfaces;
556 
557  sw[0] = template[0];
558 
559  sw->flags = 0;
560  sw->sw_if_index = sw_if_index;
562  sw->sup_sw_if_index = sw->sw_if_index;
563 
564  /* Allocate counters for this interface. */
565  {
566  u32 i;
567 
569 
570  for (i = 0; i < vec_len (im->sw_if_counters); i++)
571  {
572  vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index);
573  vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index);
574  }
575 
576  for (i = 0; i < vec_len (im->combined_sw_if_counters); i++)
577  {
579  sw_if_index);
581  sw_if_index);
582  }
583 
585  }
586  /* Wipe any stale l2 input config data. */
587  if (sw_if_index < vec_len (l2input_main.configs))
588  memset (vec_elt_at_index (l2input_main.configs, sw_if_index),
589  0, sizeof (l2_input_config_t));
590 
591  /* Wipe any stale l2 output config data. */
592  if (sw_if_index < vec_len (l2output_main.configs))
593  memset (vec_elt_at_index (l2output_main.configs, sw_if_index),
594  0, sizeof (l2_output_config_t));
595 
596  return sw_if_index;
597 }
598 
599 clib_error_t *
601  u32 * sw_if_index)
602 {
603  clib_error_t *error;
605  vnet_device_class_t *dev_class;
606 
607  hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index);
608  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
609 
610  if (template->type == VNET_SW_INTERFACE_TYPE_SUB &&
611  dev_class->subif_add_del_function)
612  {
613  error = dev_class->subif_add_del_function (vnm, hi->hw_if_index,
614  (struct vnet_sw_interface_t
615  *) template, 1);
616  if (error)
617  return error;
618  }
619 
620  *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template);
622  (vnm, *sw_if_index, template->flags,
624 
625  if (error)
626  {
627  /* undo the work done by vnet_create_sw_interface_no_callbacks() */
629  vnet_sw_interface_t *sw =
630  pool_elt_at_index (im->sw_interfaces, *sw_if_index);
631  pool_put (im->sw_interfaces, sw);
632  }
633 
634  return error;
635 }
636 
637 void
639 {
641  vnet_sw_interface_t *sw =
642  pool_elt_at_index (im->sw_interfaces, sw_if_index);
643 
644  /* Make sure the interface is in L3 mode (removed from L2 BD or XConnect) */
645  vlib_main_t *vm = vlib_get_main ();
646  l2_input_config_t *config;
647  config = vec_elt_at_index (l2input_main.configs, sw_if_index);
648  if (config->xconnect)
649  set_int_l2_mode (vm, vnm, MODE_L3, config->output_sw_if_index, 0, 0, 0,
650  0);
651  if (config->xconnect || config->bridge)
652  set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0);
653 
654  /* Bring down interface in case it is up. */
655  if (sw->flags != 0)
656  vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0);
657 
658  call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0);
659 
660  pool_put (im->sw_interfaces, sw);
661 }
662 
663 static void
665  u32 node_index, vnet_device_class_t * dev_class)
666 {
667  vlib_node_t *n = vlib_get_node (vm, node_index);
668 
669  n->function = dev_class->tx_function;
670  n->format_trace = dev_class->format_tx_trace;
671 
672  vlib_register_errors (vm, node_index,
673  dev_class->tx_function_n_errors,
674  dev_class->tx_function_error_strings);
675 }
676 
677 static void
679  u32 node_index, vnet_hw_interface_class_t * hw_class)
680 {
681  vlib_node_t *n = vlib_get_node (vm, node_index);
682  n->format_buffer = hw_class->format_header;
683  n->unformat_buffer = hw_class->unformat_header;
684 }
685 
686 /* Register an interface instance. */
687 u32
689  u32 dev_class_index,
690  u32 dev_instance,
691  u32 hw_class_index, u32 hw_instance)
692 {
695  vnet_device_class_t *dev_class =
696  vnet_get_device_class (vnm, dev_class_index);
697  vnet_hw_interface_class_t *hw_class =
698  vnet_get_hw_interface_class (vnm, hw_class_index);
699  vlib_main_t *vm = vnm->vlib_main;
701  vnet_config_main_t *cm;
702  u32 hw_index, i;
703  char *tx_node_name, *output_node_name;
704 
705  pool_get (im->hw_interfaces, hw);
706 
707  hw_index = hw - im->hw_interfaces;
708  hw->hw_if_index = hw_index;
709 
710  if (dev_class->format_device_name)
711  hw->name = format (0, "%U", dev_class->format_device_name, dev_instance);
712  else if (hw_class->format_interface_name)
713  hw->name = format (0, "%U", hw_class->format_interface_name,
714  dev_instance);
715  else
716  hw->name = format (0, "%s%x", hw_class->name, dev_instance);
717 
718  if (!im->hw_interface_by_name)
719  im->hw_interface_by_name = hash_create_vec ( /* size */ 0,
720  sizeof (hw->name[0]),
721  sizeof (uword));
722 
723  hash_set_mem (im->hw_interface_by_name, hw->name, hw_index);
724 
725  /* Make hardware interface point to software interface. */
726  {
727  vnet_sw_interface_t sw = {
729  .flood_class = VNET_FLOOD_CLASS_NORMAL,
730  .hw_if_index = hw_index
731  };
733  }
734 
735  hw->dev_class_index = dev_class_index;
736  hw->dev_instance = dev_instance;
737  hw->hw_class_index = hw_class_index;
738  hw->hw_instance = hw_instance;
739 
740  hw->max_rate_bits_per_sec = 0;
741  hw->min_packet_bytes = 0;
743  hw->max_l3_packet_bytes[VLIB_RX] = ~0;
744  hw->max_l3_packet_bytes[VLIB_TX] = ~0;
745 
746  tx_node_name = (char *) format (0, "%v-tx", hw->name);
747  output_node_name = (char *) format (0, "%v-output", hw->name);
748 
749  /* If we have previously deleted interface nodes, re-use them. */
750  if (vec_len (im->deleted_hw_interface_nodes) > 0)
751  {
754  vlib_node_t *node;
755  vlib_node_runtime_t *nrt;
756 
757  hn = vec_end (im->deleted_hw_interface_nodes) - 1;
758 
759  hw->tx_node_index = hn->tx_node_index;
761 
762  vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name);
763  vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name);
764 
766  ASSERT (rt->is_deleted == 1);
767  rt->is_deleted = 0;
768  rt->hw_if_index = hw_index;
769  rt->sw_if_index = hw->sw_if_index;
770  rt->dev_instance = hw->dev_instance;
771 
773  rt->hw_if_index = hw_index;
774  rt->sw_if_index = hw->sw_if_index;
775  rt->dev_instance = hw->dev_instance;
776 
777  /* The new class may differ from the old one.
778  * Functions have to be updated. */
779  node = vlib_get_node (vm, hw->output_node_index);
780  node->function = dev_class->flatten_output_chains ?
785  nrt->function = node->function;
786 
787  node = vlib_get_node (vm, hw->tx_node_index);
788  node->function = dev_class->tx_function;
789  node->format_trace = dev_class->format_tx_trace;
790  nrt = vlib_node_get_runtime (vm, hw->tx_node_index);
791  nrt->function = node->function;
792 
794  _vec_len (im->deleted_hw_interface_nodes) -= 1;
795  }
796  else
797  {
800  .hw_if_index = hw_index,
801  .sw_if_index = hw->sw_if_index,
802  .dev_instance = hw->dev_instance,
803  .is_deleted = 0,
804  };
805 
806  memset (&r, 0, sizeof (r));
807  r.type = VLIB_NODE_TYPE_INTERNAL;
808  r.runtime_data = &rt;
809  r.runtime_data_bytes = sizeof (rt);
810  r.scalar_size = 0;
811  r.vector_size = sizeof (u32);
812 
813  r.flags = VLIB_NODE_FLAG_IS_OUTPUT;
814  r.name = tx_node_name;
815  r.function = dev_class->tx_function;
816 
817  hw->tx_node_index = vlib_register_node (vm, &r);
818 
820  "error-drop",
822 
823  r.flags = 0;
824  r.name = output_node_name;
825  r.function = dev_class->flatten_output_chains ?
828  r.format_trace = format_vnet_interface_output_trace;
829 
830  {
831  static char *e[] = {
832  "interface is down",
833  "interface is deleted",
834  };
835 
836  r.n_errors = ARRAY_LEN (e);
837  r.error_strings = e;
838  }
839  hw->output_node_index = vlib_register_node (vm, &r);
840 
842  "error-drop",
845  hw->tx_node_index,
847 
848  /* add interface to the list of "output-interface" feature arc start nodes
849  and clone nexts from 1st interface if it exists */
851  cm = &fcm->config_main;
852  i = vec_len (cm->start_node_indices);
855  if (hw_index)
856  {
857  /* copy nexts from 1st interface */
858  vnet_hw_interface_t *first_hw;
859  vlib_node_t *first_node;
860 
861  first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0);
862  first_node = vlib_get_node (vm, first_hw->output_node_index);
863 
864  /* 1st 2 nexts are already added above */
865  for (i = 2; i < vec_len (first_node->next_nodes); i++)
867  first_node->next_nodes[i], i);
868  }
869  }
870 
871  setup_output_node (vm, hw->output_node_index, hw_class);
872  setup_tx_node (vm, hw->tx_node_index, dev_class);
873 
874  /* Call all up/down callbacks with zero flags when interface is created. */
875  vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0,
877  vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0,
879 
880  return hw_index;
881 }
882 
883 void
885 {
887  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
888  vlib_main_t *vm = vnm->vlib_main;
889 
890  /* If it is up, mark it down. */
891  if (hw->flags != 0)
892  vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0);
893 
894  /* Call delete callbacks. */
895  call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0);
896 
897  /* Delete software interface corresponding to hardware interface. */
899 
900  /* Delete any sub-interfaces. */
901  {
902  u32 id, sw_if_index;
903  /* *INDENT-OFF* */
904  hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id, ({
905  vnet_delete_sw_interface (vnm, sw_if_index);
906  }));
907  /* *INDENT-ON* */
908  }
909 
910  {
914 
915  /* Mark node runtime as deleted so output node (if called) will drop packets. */
916  rt->is_deleted = 1;
917 
919  "interface-%d-output-deleted", hw_if_index);
920  vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted",
921  hw_if_index);
923  dn->tx_node_index = hw->tx_node_index;
925  }
926 
928  vec_free (hw->name);
929 
930  pool_put (im->hw_interfaces, hw);
931 }
932 
933 void
935  u32 hw_if_index,
936  vnet_hw_sw_interface_walk_t fn, void *ctx)
937 {
939  u32 id, sw_if_index;
940 
941  hi = vnet_get_hw_interface (vnm, hw_if_index);
942  /* the super first, then the and sub interfaces */
943  fn (vnm, hi->sw_if_index, ctx);
944 
945  /* *INDENT-OFF* */
946  hash_foreach (id, sw_if_index,
948  ({
949  fn (vnm, sw_if_index, ctx);
950  }));
951  /* *INDENT-ON* */
952 }
953 
954 static void
956 {
957  u32 hw_if_index = va_arg (*va, u32);
958  char *hw_class_name = va_arg (*va, char *);
959  serialize_integer (m, hw_if_index, sizeof (hw_if_index));
960  serialize_cstring (m, hw_class_name);
961 }
962 
963 static void
965 {
966  CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *);
967  vnet_main_t *vnm = vnet_get_main ();
968  u32 hw_if_index;
969  char *hw_class_name;
970  uword *p;
971  clib_error_t *error;
972 
973  unserialize_integer (m, &hw_if_index, sizeof (hw_if_index));
974  unserialize_cstring (m, &hw_class_name);
975  p =
976  hash_get (vnm->interface_main.hw_interface_class_by_name, hw_class_name);
977  ASSERT (p != 0);
978  error = vnet_hw_interface_set_class_helper (vnm, hw_if_index, p[0],
979  /* redistribute */ 0);
980  if (error)
981  clib_error_report (error);
982 }
983 
984 MC_SERIALIZE_MSG (vnet_hw_interface_set_class_msg, static) =
985 {
986 .name = "vnet_hw_interface_set_class",.serialize =
989 
990 void
992  u32 hw_class_index, u32 hw_instance)
993 {
994  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
996  vnet_get_hw_interface_class (vnm, hw_class_index);
997 
998  hi->hw_class_index = hw_class_index;
999  hi->hw_instance = hw_instance;
1001 }
1002 
1003 static clib_error_t *
1005  u32 hw_class_index, u32 redistribute)
1006 {
1007  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1009  vnet_hw_interface_class_t *old_class =
1011  vnet_hw_interface_class_t *new_class =
1012  vnet_get_hw_interface_class (vnm, hw_class_index);
1013  vnet_device_class_t *dev_class =
1015  clib_error_t *error = 0;
1016 
1017  /* New class equals old class? Nothing to do. */
1018  if (hi->hw_class_index == hw_class_index)
1019  return 0;
1020 
1021  /* No need (and incorrect since admin up flag may be set) to do error checking when
1022  receiving unserialize message. */
1023  if (redistribute)
1024  {
1026  return clib_error_return (0,
1027  "%v must be admin down to change class from %s to %s",
1028  hi->name, old_class->name, new_class->name);
1029 
1030  /* Make sure interface supports given class. */
1031  if ((new_class->is_valid_class_for_interface
1032  && !new_class->is_valid_class_for_interface (vnm, hw_if_index,
1033  hw_class_index))
1034  || (dev_class->is_valid_class_for_interface
1035  && !dev_class->is_valid_class_for_interface (vnm, hw_if_index,
1036  hw_class_index)))
1037  return clib_error_return (0,
1038  "%v class cannot be changed from %s to %s",
1039  hi->name, old_class->name, new_class->name);
1040 
1041  if (vnm->vlib_main->mc_main)
1042  {
1044  &vnet_hw_interface_set_class_msg, hw_if_index,
1045  new_class->name);
1046  return 0;
1047  }
1048  }
1049 
1050  if (old_class->hw_class_change)
1051  old_class->hw_class_change (vnm, hw_if_index, old_class->index,
1052  new_class->index);
1053 
1054  vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index,
1055  /* instance */ ~0);
1056 
1057  if (new_class->hw_class_change)
1058  new_class->hw_class_change (vnm, hw_if_index, old_class->index,
1059  new_class->index);
1060 
1061  if (dev_class->hw_class_change)
1062  dev_class->hw_class_change (vnm, hw_if_index, new_class->index);
1063 
1064  return error;
1065 }
1066 
1067 clib_error_t *
1069  u32 hw_class_index)
1070 {
1071  return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index,
1072  /* redistribute */ 1);
1073 }
1074 
1075 static int
1077  u32 hw_if_index,
1078  u32 node_index,
1079  u32 redistribute)
1080 {
1081  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1083  (vnm, hi->dev_class_index);
1084 
1085  if (redistribute)
1086  {
1087  /* $$$$ fixme someday maybe */
1088  ASSERT (vnm->vlib_main->mc_main == 0);
1089  }
1090  if (dev_class->rx_redirect_to_node)
1091  {
1092  dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index);
1093  return 0;
1094  }
1095 
1096  return VNET_API_ERROR_UNIMPLEMENTED;
1097 }
1098 
1099 int
1101  u32 node_index)
1102 {
1103  return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index,
1104  node_index,
1105  1 /* redistribute */ );
1106 }
1107 
1108 word
1110  uword sw_if_index0, uword sw_if_index1)
1111 {
1112  vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1113  vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1);
1116 
1117  if (h0 != h1)
1118  return vec_cmp (h0->name, h1->name);
1119  return (word) h0->hw_instance - (word) h1->hw_instance;
1120 }
1121 
1122 word
1124  uword hw_if_index0, uword hw_if_index1)
1125 {
1126  vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0);
1127  vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_if_index1);
1128 
1129  if (h0 != h1)
1130  return vec_cmp (h0->name, h1->name);
1131  return (word) h0->hw_instance - (word) h1->hw_instance;
1132 }
1133 
1134 int
1136 {
1137  vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1140 
1141  return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P);
1142 }
1143 
1144 clib_error_t *
1146 {
1147  vnet_main_t *vnm = vnet_get_main ();
1149  vlib_buffer_t *b = 0;
1150  vnet_buffer_opaque_t *o = 0;
1151 
1152  /*
1153  * Keep people from shooting themselves in the foot.
1154  */
1155  if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t))
1156  {
1157 #define _(a) if (sizeof(o->a) > sizeof (o->unused)) \
1158  clib_warning \
1159  ("FATAL: size of opaque union subtype %s is %d (max %d)", \
1160  #a, sizeof(o->a), sizeof (o->unused));
1162 #undef _
1163 
1164  return clib_error_return
1165  (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d",
1166  sizeof (b->opaque), sizeof (vnet_buffer_opaque_t));
1167  }
1168 
1171  im->sw_if_counter_lock[0] = 1; /* should be no need */
1172 
1182 
1187 
1188  im->sw_if_counter_lock[0] = 0;
1189 
1190  im->device_class_by_name = hash_create_string ( /* size */ 0,
1191  sizeof (uword));
1192  {
1194 
1195  c = vnm->device_class_registrations;
1196 
1197  while (c)
1198  {
1199  c->index = vec_len (im->device_classes);
1200  hash_set_mem (im->device_class_by_name, c->name, c->index);
1201  vec_add1 (im->device_classes, c[0]);
1202  c = c->next_class_registration;
1203  }
1204  }
1205 
1206  im->hw_interface_class_by_name = hash_create_string ( /* size */ 0,
1207  sizeof (uword));
1208 
1209  im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64),
1210  sizeof (uword));
1211  {
1213 
1215 
1216  while (c)
1217  {
1218  c->index = vec_len (im->hw_interface_classes);
1219  hash_set_mem (im->hw_interface_class_by_name, c->name, c->index);
1220 
1221  if (NULL == c->build_rewrite)
1222  c->build_rewrite = default_build_rewrite;
1223  if (NULL == c->update_adjacency)
1224  c->update_adjacency = default_update_adjacency;
1225 
1226  vec_add1 (im->hw_interface_classes, c[0]);
1227  c = c->next_class_registration;
1228  }
1229  }
1230 
1231  {
1232  clib_error_t *error;
1233 
1235  return error;
1236 
1237  return error;
1238  }
1239  vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword));
1240 }
1241 
1243 
1244 /* Kludge to renumber interface names [only!] */
1245 int
1246 vnet_interface_name_renumber (u32 sw_if_index, u32 new_show_dev_instance)
1247 {
1248  int rv;
1249  vnet_main_t *vnm = vnet_get_main ();
1251  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1252 
1254  (vnm, hi->dev_class_index);
1255 
1256  if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0)
1257  return VNET_API_ERROR_UNIMPLEMENTED;
1258 
1259  rv = dev_class->name_renumber (hi, new_show_dev_instance);
1260 
1261  if (rv)
1262  return rv;
1263 
1265  vec_free (hi->name);
1266  /* Use the mapping we set up to call it Ishmael */
1267  hi->name = format (0, "%U", dev_class->format_device_name,
1268  hi->dev_instance);
1269 
1271  return rv;
1272 }
1273 
1274 clib_error_t *
1275 vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name)
1276 {
1278  vlib_main_t *vm = vnm->vlib_main;
1279  vnet_hw_interface_t *hw;
1280  u8 *old_name;
1281  clib_error_t *error = 0;
1282 
1283  hw = vnet_get_hw_interface (vnm, hw_if_index);
1284  if (!hw)
1285  {
1286  return clib_error_return (0,
1287  "unable to find hw interface for index %u",
1288  hw_if_index);
1289  }
1290 
1291  old_name = hw->name;
1292 
1293  /* set new hw->name */
1294  hw->name = format (0, "%s", new_name);
1295 
1296  /* remove the old name to hw_if_index mapping and install the new one */
1297  hash_unset_mem (im->hw_interface_by_name, old_name);
1298  hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index);
1299 
1300  /* rename tx/output nodes */
1301  vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
1302  vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
1303 
1304  /* free the old name vector */
1305  vec_free (old_name);
1306 
1307  return error;
1308 }
1309 
1310 static clib_error_t *
1312  u32 hw_if_index, u64 mac_address)
1313 {
1314  clib_error_t *error = 0;
1315  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1316 
1317  if (hi->hw_address)
1318  {
1319  vnet_device_class_t *dev_class =
1321  if (dev_class->mac_addr_change_function)
1322  {
1323  error =
1324  dev_class->mac_addr_change_function (hi, (char *) &mac_address);
1325  }
1326  if (!error)
1327  {
1328  vnet_hw_interface_class_t *hw_class;
1329 
1330  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1331 
1332  if (NULL != hw_class->mac_addr_change_function)
1333  hw_class->mac_addr_change_function (hi, (char *) &mac_address);
1334  }
1335  else
1336  {
1337  error =
1338  clib_error_return (0,
1339  "MAC Address Change is not supported on this interface");
1340  }
1341  }
1342  else
1343  {
1344  error =
1345  clib_error_return (0,
1346  "mac address change is not supported for interface index %u",
1347  hw_if_index);
1348  }
1349  return error;
1350 }
1351 
1352 clib_error_t *
1354  u64 mac_address)
1355 {
1357  (vnm, hw_if_index, mac_address);
1358 }
1359 
1362 {
1363  switch (link)
1364  {
1365  case VNET_LINK_IP4:
1366  return (VNET_L3_PACKET_TYPE_IP4);
1367  case VNET_LINK_IP6:
1368  return (VNET_L3_PACKET_TYPE_IP6);
1369  case VNET_LINK_MPLS:
1370  return (VNET_L3_PACKET_TYPE_MPLS_UNICAST);
1371  case VNET_LINK_ARP:
1372  return (VNET_L3_PACKET_TYPE_ARP);
1373  case VNET_LINK_ETHERNET:
1374  ASSERT (0);
1375  break;
1376  }
1377  ASSERT (0);
1378  return (0);
1379 }
1380 
1381 u8 *
1383  u32 sw_if_index,
1384  vnet_link_t link_type, const void *dst_address)
1385 {
1386  return (NULL);
1387 }
1388 
1389 void
1391 {
1392  u8 *rewrite;
1393 
1394  rewrite = vnet_build_rewrite_for_sw_interface (vnm, sw_if_index,
1395  adj_get_link_type (ai),
1396  NULL);
1397 
1399 }
1400 
1401 
1402 /*
1403  * fd.io coding-style-patch-verification: ON
1404  *
1405  * Local Variables:
1406  * eval: (c-set-style "gnu")
1407  * End:
1408  */
u32 * next_nodes
Definition: node.h:288
vnet_config_main_t config_main
Definition: feature.h:66
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
void serialize_vnet_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:151
vmrglw vmrglh hi
void(* vnet_hw_sw_interface_walk_t)(vnet_main_t *vnm, u32 sw_if_index, void *ctx)
Call back walk type for walking SW indices on a HW interface.
l2_input_config_t * configs
Definition: l2_input.h:66
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
#define CLIB_UNUSED(x)
Definition: clib.h:79
static clib_error_t * vnet_hw_interface_set_class_helper(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index, u32 redistribute)
Definition: interface.c:1004
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:531
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:110
volatile u32 * sw_if_counter_lock
Definition: interface.h:613
vnet_hw_interface_nodes_t * deleted_hw_interface_nodes
Definition: interface.h:617
_vnet_interface_function_list_elt_t * hw_interface_link_up_down_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:65
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
#define vec_serialize(m, v, f)
Definition: serialize.h:371
An indication that the rewrite is complete, i.e.
Definition: adj_nbr.h:98
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
vnet_interface_main_t interface_main
Definition: vnet.h:57
void * vnet_interface_output_node_multiarch_select(void)
uword vlib_node_add_next_with_slot(vlib_main_t *vm, uword node_index, uword next_node_index, uword slot)
Definition: node.c:156
clib_error_t * vnet_hw_interface_change_mac_address(vnet_main_t *vnm, u32 hw_if_index, u64 mac_address)
Definition: interface.c:1353
int vnet_hw_interface_rx_redirect_to_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
Definition: interface.c:1100
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[])
Definition: error.c:145
void vnet_hw_interface_walk_sw(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_sw_interface_walk_t fn, void *ctx)
Walk the SW interfaces on a HW interface - this is the super interface and any sub-interfaces.
Definition: interface.c:934
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:262
#define NULL
Definition: clib.h:55
static clib_error_t * call_elf_section_interface_callbacks(vnet_main_t *vnm, u32 if_index, u32 flags, _vnet_interface_function_list_elt_t **elts)
Definition: interface.c:242
#define vec_unserialize(m, v, f)
Definition: serialize.h:374
format_function_t * format_trace
Definition: node.h:315
vnet_device_class_t * device_class_registrations
Definition: vnet.h:60
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
Definition: interface.c:1109
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
Definition: interface.c:1246
struct _vlib_node_registration vlib_node_registration_t
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:521
#define hash_set_mem(h, key, value)
Definition: hash.h:274
MC_SERIALIZE_MSG(vnet_sw_interface_set_flags_msg, static)
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
uword * sub_interface_sw_if_index_by_id
Definition: interface.h:452
static void unserialize_vnet_hw_interface_set_flags(serialize_main_t *m, va_list *va)
Definition: interface.c:126
uword * interface_tag_by_sw_if_index
Definition: vnet.h:71
#define clib_error_report(e)
Definition: error.h:125
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:377
_vnet_interface_function_list_elt_t * hw_interface_add_del_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:63
struct _vnet_device_class vnet_device_class_t
#define mc_serialize(mc, msg, args...)
Definition: mc.h:651
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:200
static clib_error_t * vnet_hw_interface_set_flags_helper(vnet_main_t *vnm, u32 hw_if_index, u32 flags, u32 helper_flags)
Definition: interface.c:307
#define VNET_HW_INTERFACE_FLAG_DUPLEX_MASK
Definition: interface.h:382
mc_main_t * mc_main
Definition: main.h:133
vlib_node_function_t * function
Definition: node.h:218
u32 vlib_register_node(vlib_main_t *vm, vlib_node_registration_t *r)
Definition: node.c:451
static void unserialize_vec_vnet_sw_hw_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:89
#define VNET_HW_INTERFACE_FLAG_SPEED_MASK
Definition: interface.h:394
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
void default_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Default adjacency update function.
Definition: interface.c:1390
vnet_l3_packet_type_t
Definition: l3_types.h:44
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:348
void vlib_worker_thread_node_runtime_update(void)
Definition: threads.c:807
vlib_node_function_t * function
Definition: node.h:416
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static u32 vnet_create_sw_interface_no_callbacks(vnet_main_t *vnm, vnet_sw_interface_t *template)
Definition: interface.c:547
u32 output_sw_if_index
Definition: l2_input.h:35
static vnet_device_class_t * vnet_get_device_class(vnet_main_t *vnm, u32 dev_class_index)
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:615
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:418
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
static vnet_sw_interface_t * vnet_get_sup_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static clib_error_t * call_hw_interface_add_del_callbacks(vnet_main_t *vnm, u32 hw_if_index, u32 is_create)
Definition: interface.c:268
unsigned long u64
Definition: types.h:89
#define vec_end(v)
End (last data address) of vector.
#define vlib_call_init_function(vm, x)
Definition: init.h:161
u32 vnet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u32 hw_class_index, u32 hw_instance)
Definition: interface.c:688
#define hash_create_string(elts, value_bytes)
Definition: hash.h:652
u32 set_int_l2_mode(vlib_main_t *vm, vnet_main_t *vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, u32 bvi, u32 shg, u32 xc_sw_if_index)
Set the subinterface to run in l2 or l3 mode.
Definition: l2_input.c:509
char * name
The counter collection&#39;s name.
Definition: counter.h:68
uword * hw_interface_by_name
Definition: interface.h:595
void vlib_node_rename(vlib_main_t *vm, u32 node_index, char *fmt,...)
Definition: node.c:76
vnet_hw_interface_t * hw_interfaces
Definition: interface.h:592
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:637
#define hash_get(h, key)
Definition: hash.h:248
format_function_t format_vnet_sw_interface_name
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread u16 counters, and the shared vlib_counter_t...
Definition: counter.h:321
u8 * format_vnet_interface_output_trace(u8 *s, va_list *va)
#define hash_unset_mem(h, key)
Definition: hash.h:280
u32 * start_node_indices
Definition: config.h:98
vlib_main_t * vlib_main
Definition: vnet.h:79
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1135
#define VNET_SW_INTERFACE_FLAG_BOND_SLAVE
Definition: interface.h:537
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:214
static void serialize_vec_vnet_sw_hw_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:74
uword * sw_if_index_by_sup_and_sub
Definition: interface.h:609
void * vnet_interface_output_node_flatten_multiarch_select(void)
static void * vlib_node_get_runtime_data(vlib_main_t *vm, u32 node_index)
Get node runtime private data by node index.
Definition: node_funcs.h:109
u8 * vnet_build_rewrite_for_sw_interface(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
Definition: rewrite.c:297
static void unserialize_vnet_hw_interface_set_class(serialize_main_t *m, va_list *va)
Definition: interface.c:964
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:614
word vnet_hw_interface_compare(vnet_main_t *vnm, uword hw_if_index0, uword hw_if_index1)
Definition: interface.c:1123
format_function_t * format_buffer
Definition: node.h:311
l2output_main_t l2output_main
Definition: l2_output.c:43
uword * hw_interface_class_by_name
Definition: interface.h:602
void unserialize_cstring(serialize_main_t *m, char **s)
Definition: serialize.c:178
static clib_error_t * vnet_hw_interface_change_mac_address_helper(vnet_main_t *vnm, u32 hw_if_index, u64 mac_address)
Definition: interface.c:1311
void unserialize_vnet_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:202
clib_error_t * vnet_rename_interface(vnet_main_t *vnm, u32 hw_if_index, char *new_name)
Definition: interface.c:1275
clib_error_t * serialize(serialize_main_t *m,...)
Definition: serialize.c:671
svmdb_client_t * c
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
Definition: node_funcs.h:88
unformat_function_t * unformat_buffer
Definition: node.h:312
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:640
static void unserialize_integer(serialize_main_t *m, void *x, u32 n_bytes)
Definition: serialize.h:201
static void serialize_integer(serialize_main_t *m, u64 x, u32 n_bytes)
Definition: serialize.h:185
static clib_error_t * call_sw_interface_add_del_callbacks(vnet_main_t *vnm, u32 sw_if_index, u32 is_create)
Definition: interface.c:296
void vnet_hw_interface_init_for_class(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index, u32 hw_instance)
Definition: interface.c:991
#define ARRAY_LEN(x)
Definition: clib.h:59
static void setup_output_node(vlib_main_t *vm, u32 node_index, vnet_hw_interface_class_t *hw_class)
Definition: interface.c:678
u8 * default_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
Return a complete, zero-length (aka dummy) rewrite.
Definition: interface.c:1382
format_function_t format_vnet_sw_interface_flags
static void unserialize_vnet_sw_interface_set_flags(serialize_main_t *m, va_list *va)
Definition: interface.c:113
#define VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE
Definition: interface.c:303
static clib_error_t * vnet_sw_interface_set_flags_helper(vnet_main_t *vnm, u32 sw_if_index, u32 flags, u32 helper_flags)
Definition: interface.c:371
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:632
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
Definition: counter.c:98
#define hash_create(elts, value_bytes)
Definition: hash.h:658
Definition: mc.h:522
enum vnet_interface_function_priority_t_ vnet_interface_function_priority_t
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:528
u32 max_l3_packet_bytes[VLIB_N_RX_TX]
Definition: interface.h:449
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
static void serialize_vnet_sw_hw_interface_set_flags(serialize_main_t *m, va_list *va)
Definition: interface.c:105
#define VNET_SW_INTERFACE_FLAG_PUNT
Definition: interface.h:531
static void setup_tx_node(vlib_main_t *vm, u32 node_index, vnet_device_class_t *dev_class)
Definition: interface.c:664
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
static vnet_hw_interface_class_t * vnet_get_hw_interface_class(vnet_main_t *vnm, u32 hw_class_index)
clib_error_t * unserialize(serialize_main_t *m,...)
Definition: serialize.c:683
static void vlib_zero_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Clear a simple counter Clears the set of per-thread u16 counters, and the u64 counter.
Definition: counter.h:143
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:880
uword * device_class_by_name
Definition: interface.h:603
void vnet_delete_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface.c:884
u64 uword
Definition: types.h:112
void serialize_cstring(serialize_main_t *m, char *s)
Definition: serialize.c:164
#define VLIB_NODE_FLAG_IS_OUTPUT
Definition: node.h:253
Definition: defs.h:47
l2input_main_t l2input_main
Definition: l2_input.c:87
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:644
i64 word
Definition: types.h:111
struct _vnet_hw_interface_class vnet_hw_interface_class_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
clib_error_t * vnet_interface_init(vlib_main_t *vm)
Definition: interface.c:1145
vnet_l3_packet_type_t vnet_link_to_l3_proto(vnet_link_t link)
Convert a link to to an Ethertype.
Definition: interface.c:1361
static clib_error_t * vnet_interface_cli_init(vlib_main_t *vm)
static int vnet_hw_interface_rx_redirect_to_node_helper(vnet_main_t *vnm, u32 hw_if_index, u32 node_index, u32 redistribute)
Definition: interface.c:1076
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:606
vnet_hw_interface_class_t * hw_interface_class_registrations
Definition: vnet.h:61
char * name
The counter collection&#39;s name.
Definition: counter.h:219
a point 2 point interface
Definition: interface.h:272
l2_output_config_t * configs
Definition: l2_output.h:84
vnet_hw_interface_class_t * hw_interface_classes
Definition: interface.h:598
u32 opaque[8]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:137
_vnet_interface_function_list_elt_t * sw_interface_add_del_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:67
static void * clib_mem_alloc_aligned(uword size, uword align)
Definition: mem.h:117
static void serialize_vnet_hw_interface_set_class(serialize_main_t *m, va_list *va)
Definition: interface.c:955
vnet_sw_interface_type_t type
Definition: interface.h:523
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:58
#define vec_foreach(var, vec)
Vector iterator.
void vnet_delete_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:638
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:539
vnet_device_class_t * device_classes
Definition: interface.h:599
u32 per_packet_overhead_bytes
Definition: interface.h:446
#define clib_error_return(e, args...)
Definition: error.h:111
_vnet_interface_function_list_elt_t * sw_interface_admin_up_down_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:69
clib_error_t * vnet_create_sw_interface(vnet_main_t *vnm, vnet_sw_interface_t *template, u32 *sw_if_index)
Definition: interface.c:600
#define foreach_buffer_opaque_union_subtype
Definition: buffer.h:76
uword vlib_node_add_named_next_with_slot(vlib_main_t *vm, uword node, char *name, uword slot)
Definition: node.c:213
u32 flags
Definition: vhost-user.h:75
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
static_always_inline vnet_feature_config_main_t * vnet_feature_get_config_main(u16 arc)
Definition: feature.h:162
void adj_nbr_update_rewrite(adj_index_t adj_index, adj_nbr_rewrite_flag_t flags, u8 *rewrite)
adj_nbr_update_rewrite
Definition: adj_nbr.c:252
#define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE
Definition: interface.c:304
Definition: defs.h:46
#define MODE_L3
Definition: l2_input.h:178
clib_error_t * vnet_hw_interface_set_class(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index)
Definition: interface.c:1068