FD.io VPP  v18.01.2-1-g9b554f3
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/adj/adj_mcast.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  if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
488  {
489  error = clib_error_return (0, "Interface in the error state");
490  goto done;
491  }
492 
493  /* save the si admin up flag */
494  old_flags = si->flags;
495 
496  /* update si admin up flag in advance if we are going admin down */
497  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
498  si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP;
499 
500  if (dev_class->admin_up_down_function
501  && (error = dev_class->admin_up_down_function (vnm,
502  si->hw_if_index,
503  flags)))
504  {
505  /* restore si admin up flag to it's original state on errors */
506  si->flags = old_flags;
507  goto done;
508  }
509 
510  if (hw_class->admin_up_down_function
511  && (error = hw_class->admin_up_down_function (vnm,
512  si->hw_if_index,
513  flags)))
514  {
515  /* restore si admin up flag to it's original state on errors */
516  si->flags = old_flags;
517  goto done;
518  }
519 
520  /* Admin down implies link down. */
521  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
524  hi->flags &
526  helper_flags);
527  }
528  }
529 
530  si->flags &= ~mask;
531  si->flags |= flags;
532 
533 done:
534  return error;
535 }
536 
537 clib_error_t *
539 {
541  (vnm, hw_if_index, flags,
543 }
544 
545 clib_error_t *
547 {
549  (vnm, sw_if_index, flags,
551 }
552 
553 static u32
555  vnet_sw_interface_t * template)
556 {
559  u32 sw_if_index;
560 
561  pool_get (im->sw_interfaces, sw);
562  sw_if_index = sw - im->sw_interfaces;
563 
564  sw[0] = template[0];
565 
566  sw->flags = 0;
567  sw->sw_if_index = sw_if_index;
569  sw->sup_sw_if_index = sw->sw_if_index;
570 
571  /* Allocate counters for this interface. */
572  {
573  u32 i;
574 
576 
577  for (i = 0; i < vec_len (im->sw_if_counters); i++)
578  {
579  vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index);
580  vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index);
581  }
582 
583  for (i = 0; i < vec_len (im->combined_sw_if_counters); i++)
584  {
586  sw_if_index);
588  sw_if_index);
589  }
590 
592  }
593 
594  return sw_if_index;
595 }
596 
597 clib_error_t *
599  u32 * sw_if_index)
600 {
601  clib_error_t *error;
603  vnet_device_class_t *dev_class;
604 
605  hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index);
606  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
607 
608  if (template->type == VNET_SW_INTERFACE_TYPE_SUB &&
609  dev_class->subif_add_del_function)
610  {
611  error = dev_class->subif_add_del_function (vnm, hi->hw_if_index,
612  (struct vnet_sw_interface_t
613  *) template, 1);
614  if (error)
615  return error;
616  }
617 
618  *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template);
620  (vnm, *sw_if_index, template->flags,
622 
623  if (error)
624  {
625  /* undo the work done by vnet_create_sw_interface_no_callbacks() */
627  vnet_sw_interface_t *sw =
628  pool_elt_at_index (im->sw_interfaces, *sw_if_index);
629  pool_put (im->sw_interfaces, sw);
630  }
631 
632  return error;
633 }
634 
635 void
637 {
639  vnet_sw_interface_t *sw =
640  pool_elt_at_index (im->sw_interfaces, sw_if_index);
641 
642  /* Check if the interface has config and is removed from L2 BD or XConnect */
644  l2_input_config_t *config;
645  if (sw_if_index < vec_len (l2input_main.configs))
646  {
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,
650  0, 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 
655  /* Bring down interface in case it is up. */
656  if (sw->flags != 0)
657  vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0);
658 
659  call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0);
660 
661  pool_put (im->sw_interfaces, sw);
662 }
663 
664 static void
666  u32 node_index, vnet_device_class_t * dev_class)
667 {
668  vlib_node_t *n = vlib_get_node (vm, node_index);
669 
670  n->function = dev_class->tx_function;
671  n->format_trace = dev_class->format_tx_trace;
672 
673  vlib_register_errors (vm, node_index,
674  dev_class->tx_function_n_errors,
675  dev_class->tx_function_error_strings);
676 }
677 
678 static void
680  u32 node_index, vnet_hw_interface_class_t * hw_class)
681 {
682  vlib_node_t *n = vlib_get_node (vm, node_index);
683  n->format_buffer = hw_class->format_header;
684  n->unformat_buffer = hw_class->unformat_header;
685 }
686 
687 /* Register an interface instance. */
688 u32
690  u32 dev_class_index,
691  u32 dev_instance,
692  u32 hw_class_index, u32 hw_instance)
693 {
696  vnet_device_class_t *dev_class =
697  vnet_get_device_class (vnm, dev_class_index);
698  vnet_hw_interface_class_t *hw_class =
699  vnet_get_hw_interface_class (vnm, hw_class_index);
700  vlib_main_t *vm = vnm->vlib_main;
702  vnet_config_main_t *cm;
703  u32 hw_index, i;
704  char *tx_node_name, *output_node_name;
705 
706  pool_get (im->hw_interfaces, hw);
707  memset (hw, 0, sizeof (*hw));
708 
709  hw_index = hw - im->hw_interfaces;
710  hw->hw_if_index = hw_index;
712 
713  if (dev_class->format_device_name)
714  hw->name = format (0, "%U", dev_class->format_device_name, dev_instance);
715  else if (hw_class->format_interface_name)
716  hw->name = format (0, "%U", hw_class->format_interface_name,
717  dev_instance);
718  else
719  hw->name = format (0, "%s%x", hw_class->name, dev_instance);
720 
721  if (!im->hw_interface_by_name)
722  im->hw_interface_by_name = hash_create_vec ( /* size */ 0,
723  sizeof (hw->name[0]),
724  sizeof (uword));
725 
726  hash_set_mem (im->hw_interface_by_name, hw->name, hw_index);
727 
728  /* Make hardware interface point to software interface. */
729  {
730  vnet_sw_interface_t sw = {
732  .flood_class = VNET_FLOOD_CLASS_NORMAL,
733  .hw_if_index = hw_index
734  };
736  }
737 
738  hw->dev_class_index = dev_class_index;
739  hw->dev_instance = dev_instance;
740  hw->hw_class_index = hw_class_index;
741  hw->hw_instance = hw_instance;
742 
743  hw->max_rate_bits_per_sec = 0;
744  hw->min_packet_bytes = 0;
746  hw->max_l3_packet_bytes[VLIB_RX] = ~0;
747  hw->max_l3_packet_bytes[VLIB_TX] = ~0;
748 
749  if (dev_class->tx_function == 0)
750  goto no_output_nodes; /* No output/tx nodes to create */
751 
752  tx_node_name = (char *) format (0, "%v-tx", hw->name);
753  output_node_name = (char *) format (0, "%v-output", hw->name);
754 
755  /* If we have previously deleted interface nodes, re-use them. */
756  if (vec_len (im->deleted_hw_interface_nodes) > 0)
757  {
759  vlib_node_t *node;
760  vlib_node_runtime_t *nrt;
761 
762  hn = vec_end (im->deleted_hw_interface_nodes) - 1;
763 
764  hw->tx_node_index = hn->tx_node_index;
766 
767  vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name);
768  vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name);
769 
770  /* *INDENT-OFF* */
773 
774  rt = vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
775  ASSERT (rt->is_deleted == 1);
776  rt->is_deleted = 0;
777  rt->hw_if_index = hw_index;
778  rt->sw_if_index = hw->sw_if_index;
779  rt->dev_instance = hw->dev_instance;
780 
781  rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index);
782  rt->hw_if_index = hw_index;
783  rt->sw_if_index = hw->sw_if_index;
784  rt->dev_instance = hw->dev_instance;
785  });
786  /* *INDENT-ON* */
787 
788  /* The new class may differ from the old one.
789  * Functions have to be updated. */
790  node = vlib_get_node (vm, hw->output_node_index);
792  node->format_trace = format_vnet_interface_output_trace;
793  /* *INDENT-OFF* */
795  nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index);
796  nrt->function = node->function;
797  });
798  /* *INDENT-ON* */
799 
800  node = vlib_get_node (vm, hw->tx_node_index);
801  node->function = dev_class->tx_function;
802  node->format_trace = dev_class->format_tx_trace;
803  /* *INDENT-OFF* */
805  nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index);
806  nrt->function = node->function;
807  });
808  /* *INDENT-ON* */
809 
810  _vec_len (im->deleted_hw_interface_nodes) -= 1;
811  }
812  else
813  {
816  .hw_if_index = hw_index,
817  .sw_if_index = hw->sw_if_index,
818  .dev_instance = hw->dev_instance,
819  .is_deleted = 0,
820  };
821 
822  memset (&r, 0, sizeof (r));
823  r.type = VLIB_NODE_TYPE_INTERNAL;
824  r.runtime_data = &rt;
825  r.runtime_data_bytes = sizeof (rt);
826  r.scalar_size = 0;
827  r.vector_size = sizeof (u32);
828 
829  r.flags = VLIB_NODE_FLAG_IS_OUTPUT;
830  r.name = tx_node_name;
831  r.function = dev_class->tx_function;
832 
833  hw->tx_node_index = vlib_register_node (vm, &r);
834 
836  "error-drop",
838 
839  r.flags = 0;
840  r.name = output_node_name;
842  r.format_trace = format_vnet_interface_output_trace;
843 
844  {
845  static char *e[] = {
846  "interface is down",
847  "interface is deleted",
848  };
849 
850  r.n_errors = ARRAY_LEN (e);
851  r.error_strings = e;
852  }
853  hw->output_node_index = vlib_register_node (vm, &r);
854 
856  "error-drop",
859  hw->tx_node_index,
861 
862  /* add interface to the list of "output-interface" feature arc start nodes
863  and clone nexts from 1st interface if it exists */
865  cm = &fcm->config_main;
866  i = vec_len (cm->start_node_indices);
869  if (hw_index)
870  {
871  /* copy nexts from 1st interface */
872  vnet_hw_interface_t *first_hw;
873  vlib_node_t *first_node;
874 
875  first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0);
876  first_node = vlib_get_node (vm, first_hw->output_node_index);
877 
878  /* 1st 2 nexts are already added above */
879  for (i = 2; i < vec_len (first_node->next_nodes); i++)
881  first_node->next_nodes[i], i);
882  }
883  }
884 
885  setup_output_node (vm, hw->output_node_index, hw_class);
886  setup_tx_node (vm, hw->tx_node_index, dev_class);
887 
888 no_output_nodes:
889  /* Call all up/down callbacks with zero flags when interface is created. */
890  vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0,
892  vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0,
894 
895  return hw_index;
896 }
897 
898 void
900 {
902  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
903  vlib_main_t *vm = vnm->vlib_main;
904  vnet_device_class_t *dev_class = vnet_get_device_class (vnm,
905  hw->dev_class_index);
906  /* If it is up, mark it down. */
907  if (hw->flags != 0)
908  vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0);
909 
910  /* Call delete callbacks. */
911  call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0);
912 
913  /* Delete any sub-interfaces. */
914  {
915  u32 id, sw_if_index;
916  /* *INDENT-OFF* */
917  hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id,
918  ({
919  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
920  u64 sup_and_sub_key =
921  ((u64) (si->sup_sw_if_index) << 32) | (u64) si->sub.id;
922  hash_unset_mem_free (&im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
923  vnet_delete_sw_interface (vnm, sw_if_index);
924  }));
926  /* *INDENT-ON* */
927  }
928 
929  /* Delete software interface corresponding to hardware interface. */
931 
932  if (dev_class->tx_function)
933  {
934  /* Put output/tx nodes into recycle pool */
936 
937  /* *INDENT-OFF* */
939  ({
941  vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
942 
943  /* Mark node runtime as deleted so output node (if called)
944  * will drop packets. */
945  rt->is_deleted = 1;
946  });
947  /* *INDENT-ON* */
948 
950  "interface-%d-output-deleted", hw_if_index);
951  vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted",
952  hw_if_index);
954  dn->tx_node_index = hw->tx_node_index;
956  }
957 
959  vec_free (hw->name);
962 
963  pool_put (im->hw_interfaces, hw);
964 }
965 
966 void
968  u32 hw_if_index,
970 {
972  u32 id, sw_if_index;
973 
974  hi = vnet_get_hw_interface (vnm, hw_if_index);
975  /* the super first, then the and sub interfaces */
976  fn (vnm, hi->sw_if_index, ctx);
977 
978  /* *INDENT-OFF* */
979  hash_foreach (id, sw_if_index,
981  ({
982  fn (vnm, sw_if_index, ctx);
983  }));
984  /* *INDENT-ON* */
985 }
986 
987 static void
989 {
990  u32 hw_if_index = va_arg (*va, u32);
991  char *hw_class_name = va_arg (*va, char *);
992  serialize_integer (m, hw_if_index, sizeof (hw_if_index));
993  serialize_cstring (m, hw_class_name);
994 }
995 
996 static void
998 {
999  CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *);
1000  vnet_main_t *vnm = vnet_get_main ();
1001  u32 hw_if_index;
1002  char *hw_class_name;
1003  uword *p;
1004  clib_error_t *error;
1005 
1006  unserialize_integer (m, &hw_if_index, sizeof (hw_if_index));
1007  unserialize_cstring (m, &hw_class_name);
1008  p =
1009  hash_get (vnm->interface_main.hw_interface_class_by_name, hw_class_name);
1010  ASSERT (p != 0);
1011  error = vnet_hw_interface_set_class_helper (vnm, hw_if_index, p[0],
1012  /* redistribute */ 0);
1013  if (error)
1014  clib_error_report (error);
1015 }
1016 
1017 MC_SERIALIZE_MSG (vnet_hw_interface_set_class_msg, static) =
1018 {
1019 .name = "vnet_hw_interface_set_class",.serialize =
1022 
1023 void
1025  u32 hw_class_index, u32 hw_instance)
1026 {
1027  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1029  vnet_get_hw_interface_class (vnm, hw_class_index);
1030 
1031  hi->hw_class_index = hw_class_index;
1032  hi->hw_instance = hw_instance;
1034 }
1035 
1036 static clib_error_t *
1038  u32 hw_class_index, u32 redistribute)
1039 {
1040  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1042  vnet_hw_interface_class_t *old_class =
1044  vnet_hw_interface_class_t *new_class =
1045  vnet_get_hw_interface_class (vnm, hw_class_index);
1046  vnet_device_class_t *dev_class =
1048  clib_error_t *error = 0;
1049 
1050  /* New class equals old class? Nothing to do. */
1051  if (hi->hw_class_index == hw_class_index)
1052  return 0;
1053 
1054  /* No need (and incorrect since admin up flag may be set) to do error checking when
1055  receiving unserialize message. */
1056  if (redistribute)
1057  {
1059  return clib_error_return (0,
1060  "%v must be admin down to change class from %s to %s",
1061  hi->name, old_class->name, new_class->name);
1062 
1063  /* Make sure interface supports given class. */
1064  if ((new_class->is_valid_class_for_interface
1065  && !new_class->is_valid_class_for_interface (vnm, hw_if_index,
1066  hw_class_index))
1067  || (dev_class->is_valid_class_for_interface
1068  && !dev_class->is_valid_class_for_interface (vnm, hw_if_index,
1069  hw_class_index)))
1070  return clib_error_return (0,
1071  "%v class cannot be changed from %s to %s",
1072  hi->name, old_class->name, new_class->name);
1073 
1074  if (vnm->vlib_main->mc_main)
1075  {
1077  &vnet_hw_interface_set_class_msg, hw_if_index,
1078  new_class->name);
1079  return 0;
1080  }
1081  }
1082 
1083  if (old_class->hw_class_change)
1084  old_class->hw_class_change (vnm, hw_if_index, old_class->index,
1085  new_class->index);
1086 
1087  vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index,
1088  /* instance */ ~0);
1089 
1090  if (new_class->hw_class_change)
1091  new_class->hw_class_change (vnm, hw_if_index, old_class->index,
1092  new_class->index);
1093 
1094  if (dev_class->hw_class_change)
1095  dev_class->hw_class_change (vnm, hw_if_index, new_class->index);
1096 
1097  return error;
1098 }
1099 
1100 clib_error_t *
1102  u32 hw_class_index)
1103 {
1104  return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index,
1105  /* redistribute */ 1);
1106 }
1107 
1108 static int
1110  u32 hw_if_index,
1111  u32 node_index,
1112  u32 redistribute)
1113 {
1114  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1116  (vnm, hi->dev_class_index);
1117 
1118  if (redistribute)
1119  {
1120  /* $$$$ fixme someday maybe */
1121  ASSERT (vnm->vlib_main->mc_main == 0);
1122  }
1123  if (dev_class->rx_redirect_to_node)
1124  {
1125  dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index);
1126  return 0;
1127  }
1128 
1129  return VNET_API_ERROR_UNIMPLEMENTED;
1130 }
1131 
1132 int
1134  u32 node_index)
1135 {
1136  return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index,
1137  node_index,
1138  1 /* redistribute */ );
1139 }
1140 
1141 word
1143  uword sw_if_index0, uword sw_if_index1)
1144 {
1145  vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1146  vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1);
1149 
1150  if (h0 != h1)
1151  return vec_cmp (h0->name, h1->name);
1152  return (word) h0->hw_instance - (word) h1->hw_instance;
1153 }
1154 
1155 word
1157  uword hw_if_index0, uword hw_if_index1)
1158 {
1159  vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0);
1160  vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_if_index1);
1161 
1162  if (h0 != h1)
1163  return vec_cmp (h0->name, h1->name);
1164  return (word) h0->hw_instance - (word) h1->hw_instance;
1165 }
1166 
1167 int
1169 {
1170  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
1171  if (si->type == VNET_SW_INTERFACE_TYPE_P2P)
1172  return 1;
1173 
1174  vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1177 
1178  return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P);
1179 }
1180 
1181 clib_error_t *
1183 {
1184  vnet_main_t *vnm = vnet_get_main ();
1186  vlib_buffer_t *b = 0;
1187  vnet_buffer_opaque_t *o = 0;
1188  clib_error_t *error;
1189 
1190  /*
1191  * Keep people from shooting themselves in the foot.
1192  */
1193  if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t))
1194  {
1195 #define _(a) if (sizeof(o->a) > sizeof (o->unused)) \
1196  clib_warning \
1197  ("FATAL: size of opaque union subtype %s is %d (max %d)", \
1198  #a, sizeof(o->a), sizeof (o->unused));
1200 #undef _
1201 
1202  return clib_error_return
1203  (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d",
1204  sizeof (b->opaque), sizeof (vnet_buffer_opaque_t));
1205  }
1206 
1209  im->sw_if_counter_lock[0] = 1; /* should be no need */
1210 
1220 
1225 
1226  im->sw_if_counter_lock[0] = 0;
1227 
1228  im->device_class_by_name = hash_create_string ( /* size */ 0,
1229  sizeof (uword));
1230  {
1232 
1233  c = vnm->device_class_registrations;
1234 
1235  while (c)
1236  {
1237  c->index = vec_len (im->device_classes);
1238  hash_set_mem (im->device_class_by_name, c->name, c->index);
1239  vec_add1 (im->device_classes, c[0]);
1240  c = c->next_class_registration;
1241  }
1242  }
1243 
1244  im->hw_interface_class_by_name = hash_create_string ( /* size */ 0,
1245  sizeof (uword));
1246 
1247  im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64),
1248  sizeof (uword));
1249  {
1251 
1253 
1254  while (c)
1255  {
1256  c->index = vec_len (im->hw_interface_classes);
1257  hash_set_mem (im->hw_interface_class_by_name, c->name, c->index);
1258 
1259  if (NULL == c->build_rewrite)
1260  c->build_rewrite = default_build_rewrite;
1261  if (NULL == c->update_adjacency)
1262  c->update_adjacency = default_update_adjacency;
1263 
1264  vec_add1 (im->hw_interface_classes, c[0]);
1265  c = c->next_class_registration;
1266  }
1267  }
1268 
1270  return error;
1271 
1272  vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword));
1273 
1274 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
1275  if ((error = vlib_call_init_function (vm, trajectory_trace_init)))
1276  return error;
1277 #endif
1278 
1279  return 0;
1280 }
1281 
1283 
1284 /* Kludge to renumber interface names [only!] */
1285 int
1286 vnet_interface_name_renumber (u32 sw_if_index, u32 new_show_dev_instance)
1287 {
1288  int rv;
1289  vnet_main_t *vnm = vnet_get_main ();
1291  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1292 
1294  (vnm, hi->dev_class_index);
1295 
1296  if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0)
1297  return VNET_API_ERROR_UNIMPLEMENTED;
1298 
1299  rv = dev_class->name_renumber (hi, new_show_dev_instance);
1300 
1301  if (rv)
1302  return rv;
1303 
1305  vec_free (hi->name);
1306  /* Use the mapping we set up to call it Ishmael */
1307  hi->name = format (0, "%U", dev_class->format_device_name,
1308  hi->dev_instance);
1309 
1311  return rv;
1312 }
1313 
1314 clib_error_t *
1315 vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name)
1316 {
1318  vlib_main_t *vm = vnm->vlib_main;
1319  vnet_hw_interface_t *hw;
1320  u8 *old_name;
1321  clib_error_t *error = 0;
1322 
1323  hw = vnet_get_hw_interface (vnm, hw_if_index);
1324  if (!hw)
1325  {
1326  return clib_error_return (0,
1327  "unable to find hw interface for index %u",
1328  hw_if_index);
1329  }
1330 
1331  old_name = hw->name;
1332 
1333  /* set new hw->name */
1334  hw->name = format (0, "%s", new_name);
1335 
1336  /* remove the old name to hw_if_index mapping and install the new one */
1337  hash_unset_mem (im->hw_interface_by_name, old_name);
1338  hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index);
1339 
1340  /* rename tx/output nodes */
1341  vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
1342  vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
1343 
1344  /* free the old name vector */
1345  vec_free (old_name);
1346 
1347  return error;
1348 }
1349 
1350 static clib_error_t *
1352  u32 hw_if_index,
1353  u8 * mac_address)
1354 {
1355  clib_error_t *error = 0;
1356  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1357 
1358  if (hi->hw_address)
1359  {
1360  vnet_device_class_t *dev_class =
1362  if (dev_class->mac_addr_change_function)
1363  {
1364  error =
1365  dev_class->mac_addr_change_function (hi, (char *) mac_address);
1366  }
1367  if (!error)
1368  {
1369  vnet_hw_interface_class_t *hw_class;
1370 
1371  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1372 
1373  if (NULL != hw_class->mac_addr_change_function)
1374  hw_class->mac_addr_change_function (hi, (char *) mac_address);
1375  }
1376  else
1377  {
1378  error =
1379  clib_error_return (0,
1380  "MAC Address Change is not supported on this interface");
1381  }
1382  }
1383  else
1384  {
1385  error =
1386  clib_error_return (0,
1387  "mac address change is not supported for interface index %u",
1388  hw_if_index);
1389  }
1390  return error;
1391 }
1392 
1393 clib_error_t *
1395  u8 * mac_address)
1396 {
1398  (vnm, hw_if_index, mac_address);
1399 }
1400 
1403 {
1404  switch (link)
1405  {
1406  case VNET_LINK_IP4:
1407  return (VNET_L3_PACKET_TYPE_IP4);
1408  case VNET_LINK_IP6:
1409  return (VNET_L3_PACKET_TYPE_IP6);
1410  case VNET_LINK_MPLS:
1411  return (VNET_L3_PACKET_TYPE_MPLS);
1412  case VNET_LINK_ARP:
1413  return (VNET_L3_PACKET_TYPE_ARP);
1414  case VNET_LINK_ETHERNET:
1415  case VNET_LINK_NSH:
1416  ASSERT (0);
1417  break;
1418  }
1419  ASSERT (0);
1420  return (0);
1421 }
1422 
1423 u8 *
1425  u32 sw_if_index,
1426  vnet_link_t link_type, const void *dst_address)
1427 {
1428  return (NULL);
1429 }
1430 
1431 void
1433 {
1434  ip_adjacency_t *adj;
1435 
1436  adj = adj_get (ai);
1437 
1438  switch (adj->lookup_next_index)
1439  {
1440  case IP_LOOKUP_NEXT_ARP:
1441  case IP_LOOKUP_NEXT_GLEAN:
1442  /*
1443  * default rewirte in neighbour adj
1444  */
1446  (ai,
1449  sw_if_index,
1450  adj_get_link_type (ai), NULL));
1451  break;
1452  case IP_LOOKUP_NEXT_MCAST:
1453  /*
1454  * mcast traffic also uses default rewrite string with no mcast
1455  * switch time updates.
1456  */
1458  (ai,
1460  sw_if_index,
1461  adj_get_link_type (ai),
1462  NULL), 0, 0);
1463  break;
1464  case IP_LOOKUP_NEXT_DROP:
1465  case IP_LOOKUP_NEXT_PUNT:
1466  case IP_LOOKUP_NEXT_LOCAL:
1471  case IP_LOOKUP_N_NEXT:
1472  ASSERT (0);
1473  break;
1474  }
1475 }
1476 
1477 /*
1478  * fd.io coding-style-patch-verification: ON
1479  *
1480  * Local Variables:
1481  * eval: (c-set-style "gnu")
1482  * End:
1483  */
u32 * next_nodes
Definition: node.h:288
vnet_config_main_t config_main
Definition: feature.h:65
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:432
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:337
#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:1037
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:538
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:89
volatile u32 * sw_if_counter_lock
Definition: interface.h:670
vnet_hw_interface_nodes_t * deleted_hw_interface_nodes
Definition: interface.h:674
_vnet_interface_function_list_elt_t * hw_interface_link_up_down_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:64
#define vec_serialize(m, v, f)
Definition: serialize.h:371
An indication that the rewrite is complete, i.e.
Definition: adj_nbr.h:98
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
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:56
void * vnet_interface_output_node_multiarch_select(void)
uword vlib_node_add_named_next_with_slot(vlib_main_t *vm, uword node, char *name, uword slot)
Definition: node.c:262
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:132
int vnet_hw_interface_rx_redirect_to_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
Definition: interface.c:1133
Multicast Adjacency.
Definition: adj.h:82
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:967
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:365
#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
IP unicast adjacency.
Definition: adj.h:174
format_function_t * format_trace
Definition: node.h:315
vnet_device_class_t * device_class_registrations
Definition: vnet.h:59
u32 * input_node_thread_index_by_queue
Definition: interface.h:492
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
This packet is to be rewritten and forwarded to the next processing node.
Definition: adj.h:73
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
Definition: interface.c:1142
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
Definition: interface.c:1286
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:557
#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:475
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
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:70
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:394
_vnet_interface_function_list_elt_t * hw_interface_add_del_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:62
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:225
uword * dq_runtime_index_by_queue
Definition: interface.h:499
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:399
mc_main_t * mc_main
Definition: main.h:147
vlib_node_function_t * function
Definition: node.h:218
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[])
Definition: error.c:145
static void unserialize_vec_vnet_sw_hw_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:89
Adjacency to punt this packet.
Definition: adj.h:55
#define VNET_HW_INTERFACE_FLAG_SPEED_MASK
Definition: interface.h:411
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:365
void default_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Default adjacency update function.
Definition: interface.c:1432
vnet_l3_packet_type_t
Definition: l3_types.h:44
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:438
vlib_node_function_t * function
Node function to call.
Definition: node.h:413
#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:554
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:672
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:441
uword vlib_node_add_next_with_slot(vlib_main_t *vm, uword node_index, uword next_node_index, uword slot)
Definition: node.c:205
#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
#define clib_error_return(e, args...)
Definition: error.h:99
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:162
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:689
#define hash_create_string(elts, value_bytes)
Definition: hash.h:675
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:565
char * name
The counter collection&#39;s name.
Definition: counter.h:65
uword * hw_interface_by_name
Definition: interface.h:652
vnet_hw_interface_t * hw_interfaces
Definition: interface.h:649
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:660
#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:459
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread counters.
Definition: counter.h:276
u8 * format_vnet_interface_output_trace(u8 *s, va_list *va)
#define hash_unset_mem(h, key)
Definition: hash.h:290
u32 * start_node_indices
Definition: config.h:98
vlib_main_t * vlib_main
Definition: vnet.h:78
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1168
#define VNET_SW_INTERFACE_FLAG_BOND_SLAVE
Definition: interface.h:585
#define hash_free(h)
Definition: hash.h:309
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:271
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:666
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:110
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
Definition: adj.h:68
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:202
static void unserialize_vnet_hw_interface_set_class(serialize_main_t *m, va_list *va)
Definition: interface.c:997
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:671
word vnet_hw_interface_compare(vnet_main_t *vnm, uword hw_if_index0, uword hw_if_index1)
Definition: interface.c:1156
format_function_t * format_buffer
Definition: node.h:311
#define foreach_vlib_main(body)
Definition: threads.h:244
uword * hw_interface_class_by_name
Definition: interface.h:659
void unserialize_cstring(serialize_main_t *m, char **s)
Definition: serialize.c:178
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:1315
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
Definition: adj.h:63
Adjacency to drop this packet.
Definition: adj.h:53
clib_error_t * serialize(serialize_main_t *m,...)
Definition: serialize.c:671
svmdb_client_t * c
vlib_main_t * vm
Definition: buffer.c:283
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
Multicast Midchain Adjacency.
Definition: adj.h:86
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:89
clib_error_t * vnet_hw_interface_change_mac_address(vnet_main_t *vnm, u32 hw_if_index, u8 *mac_address)
Definition: interface.c:1394
unformat_function_t * unformat_buffer
Definition: node.h:312
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:697
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:1024
#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:679
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:1424
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
This packets follow a mid-chain adjacency.
Definition: adj.h:76
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:689
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
Definition: counter.c:78
#define hash_create(elts, value_bytes)
Definition: hash.h:681
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:576
u32 max_l3_packet_bytes[VLIB_N_RX_TX]
Definition: interface.h:472
#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
void vlib_node_rename(vlib_main_t *vm, u32 node_index, char *fmt,...)
Definition: node.c:102
#define VNET_SW_INTERFACE_FLAG_PUNT
Definition: interface.h:579
long ctx[MAX_CONNS]
Definition: main.c:122
static void setup_tx_node(vlib_main_t *vm, u32 node_index, vnet_device_class_t *dev_class)
Definition: interface.c:665
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
u32 vlib_register_node(vlib_main_t *vm, vlib_node_registration_t *r)
Definition: node.c:498
static vnet_hw_interface_class_t * vnet_get_hw_interface_class(vnet_main_t *vnm, u32 hw_class_index)
#define clib_error_report(e)
Definition: error.h:113
clib_error_t * unserialize(serialize_main_t *m,...)
Definition: serialize.c:683
void adj_mcast_update_rewrite(adj_index_t adj_index, u8 *rewrite, u8 offset, u32 mask)
adj_mcast_update_rewrite
Definition: adj_mcast.c:102
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:123
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:916
uword * device_class_by_name
Definition: interface.h:660
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
void vnet_delete_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface.c:899
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
This packets needs to go to ICMP error.
Definition: adj.h:79
This packet is for one of our own IP addresses.
Definition: adj.h:58
Definition: defs.h:47
l2input_main_t l2input_main
Definition: l2_input.c:113
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:667
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)
#define VNET_SW_INTERFACE_FLAG_ERROR
Definition: interface.h:591
unsigned char u8
Definition: types.h:56
clib_error_t * vnet_interface_init(vlib_main_t *vm)
Definition: interface.c:1182
static clib_error_t * vnet_hw_interface_change_mac_address_helper(vnet_main_t *vnm, u32 hw_if_index, u8 *mac_address)
Definition: interface.c:1351
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:189
vnet_l3_packet_type_t vnet_link_to_l3_proto(vnet_link_t link)
Convert a link to to an Ethertype.
Definition: interface.c:1402
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:1109
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:663
vnet_hw_interface_class_t * hw_interface_class_registrations
Definition: vnet.h:60
char * name
The counter collection&#39;s name.
Definition: counter.h:185
a point 2 point interface
Definition: interface.h:289
vnet_hw_interface_class_t * hw_interface_classes
Definition: interface.h:655
_vnet_interface_function_list_elt_t * sw_interface_add_del_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:66
static void * clib_mem_alloc_aligned(uword size, uword align)
Definition: mem.h:120
static void serialize_vnet_hw_interface_set_class(serialize_main_t *m, va_list *va)
Definition: interface.c:988
vnet_sw_interface_type_t type
Definition: interface.h:571
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:59
#define vec_foreach(var, vec)
Vector iterator.
vnet_hw_interface_rx_mode default_rx_mode
Definition: interface.h:496
void vnet_delete_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:636
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:546
vnet_device_class_t * device_classes
Definition: interface.h:656
#define foreach_buffer_opaque_union_subtype
Definition: buffer.h:81
u32 per_packet_overhead_bytes
Definition: interface.h:469
_vnet_interface_function_list_elt_t * sw_interface_admin_up_down_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:68
clib_error_t * vnet_create_sw_interface(vnet_main_t *vnm, vnet_sw_interface_t *template, u32 *sw_if_index)
Definition: interface.c:598
u32 flags
Definition: vhost-user.h:77
#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:160
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:291
#define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE
Definition: interface.c:304
Definition: defs.h:46
#define MODE_L3
Definition: l2_input.h:202
clib_error_t * vnet_hw_interface_set_class(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index)
Definition: interface.c:1101