FD.io VPP  v18.11-rc0-18-g2a3fb1a
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 
473  if (error)
474  {
475  /* restore flags on error */
476  si->flags = old_flags;
477  goto done;
478  }
479 
481  {
484  vnet_hw_interface_class_t *hw_class =
486  vnet_device_class_t *dev_class =
488 
489  if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
491  {
492  error = clib_error_return (0, "Interface in the error state");
493  goto done;
494  }
495 
496  /* save the si admin up flag */
497  old_flags = si->flags;
498 
499  /* update si admin up flag in advance if we are going admin down */
500  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
501  si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP;
502 
503  if (dev_class->admin_up_down_function
504  && (error = dev_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  if (hw_class->admin_up_down_function
514  && (error = hw_class->admin_up_down_function (vnm,
515  si->hw_if_index,
516  flags)))
517  {
518  /* restore si admin up flag to it's original state on errors */
519  si->flags = old_flags;
520  goto done;
521  }
522 
523  /* Admin down implies link down. */
524  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
527  hi->flags &
529  helper_flags);
530  }
531  }
532 
533  si->flags &= ~mask;
534  si->flags |= flags;
535 
536 done:
537  return error;
538 }
539 
540 clib_error_t *
542 {
544  (vnm, hw_if_index, flags,
546 }
547 
548 clib_error_t *
550 {
552  (vnm, sw_if_index, flags,
554 }
555 
556 static u32
558  vnet_sw_interface_t * template)
559 {
562  u32 sw_if_index;
563 
564  pool_get (im->sw_interfaces, sw);
565  sw_if_index = sw - im->sw_interfaces;
566 
567  sw[0] = template[0];
568 
569  sw->flags = 0;
570  sw->sw_if_index = sw_if_index;
572  sw->sup_sw_if_index = sw->sw_if_index;
573 
574  /* Allocate counters for this interface. */
575  {
576  u32 i;
577 
579 
580  for (i = 0; i < vec_len (im->sw_if_counters); i++)
581  {
582  vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index);
583  vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index);
584  }
585 
586  for (i = 0; i < vec_len (im->combined_sw_if_counters); i++)
587  {
589  sw_if_index);
591  sw_if_index);
592  }
593 
595  }
596 
597  return sw_if_index;
598 }
599 
600 clib_error_t *
602  u32 * sw_if_index)
603 {
604  clib_error_t *error;
606  vnet_device_class_t *dev_class;
607 
608  hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index);
609  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
610 
611  if (template->type == VNET_SW_INTERFACE_TYPE_SUB &&
612  dev_class->subif_add_del_function)
613  {
614  error = dev_class->subif_add_del_function (vnm, hi->hw_if_index,
615  (struct vnet_sw_interface_t
616  *) template, 1);
617  if (error)
618  return error;
619  }
620 
621  *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template);
623  (vnm, *sw_if_index, template->flags,
625 
626  if (error)
627  {
628  /* undo the work done by vnet_create_sw_interface_no_callbacks() */
630  vnet_sw_interface_t *sw =
631  pool_elt_at_index (im->sw_interfaces, *sw_if_index);
632  pool_put (im->sw_interfaces, sw);
633  }
634 
635  return error;
636 }
637 
638 void
640 {
642  vnet_sw_interface_t *sw =
643  pool_elt_at_index (im->sw_interfaces, sw_if_index);
644 
645  /* Check if the interface has config and is removed from L2 BD or XConnect */
647  l2_input_config_t *config;
648  if (sw_if_index < vec_len (l2input_main.configs))
649  {
650  config = vec_elt_at_index (l2input_main.configs, sw_if_index);
651  if (config->xconnect)
652  set_int_l2_mode (vm, vnm, MODE_L3, config->output_sw_if_index, 0, 0,
653  0, 0);
654  if (config->xconnect || config->bridge)
655  set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0);
656  }
657  vnet_clear_sw_interface_tag (vnm, sw_if_index);
658 
659  /* Bring down interface in case it is up. */
660  if (sw->flags != 0)
661  vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0);
662 
663  call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0);
664 
665  pool_put (im->sw_interfaces, sw);
666 }
667 
668 static clib_error_t *
670 {
672  (vnm, sw_if_index, 0, vnm->sw_interface_mtu_change_functions);
673 }
674 
675 void
676 vnet_sw_interface_set_mtu (vnet_main_t * vnm, u32 sw_if_index, u32 mtu)
677 {
678  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
679 
680  if (si->mtu[VNET_MTU_L3] != mtu)
681  {
682  si->mtu[VNET_MTU_L3] = mtu;
683  call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
684  }
685 }
686 
687 void
689  u32 mtu[])
690 {
691  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
692  bool changed = false;
693  int i;
694 
695  for (i = 0; i < VNET_N_MTU; i++)
696  {
697  if (si->mtu[i] != mtu[i])
698  {
699  si->mtu[i] = mtu[i];
700  changed = true;
701  }
702  }
703  /* Notify interested parties */
704  if (changed)
705  call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
706 }
707 
708 /*
709  * Reflect a change in hardware MTU on protocol MTUs
710  */
711 static walk_rc_t
712 sw_interface_walk_callback (vnet_main_t * vnm, u32 sw_if_index, void *ctx)
713 {
714  u32 *link_mtu = ctx;
715  vnet_sw_interface_set_mtu (vnm, sw_if_index, *link_mtu);
716  return WALK_CONTINUE;
717 }
718 
719 void
720 vnet_hw_interface_set_mtu (vnet_main_t * vnm, u32 hw_if_index, u32 mtu)
721 {
722  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
723 
724  if (hi->max_packet_bytes != mtu)
725  {
726  hi->max_packet_bytes = mtu;
729  &mtu);
730  }
731 }
732 
733 static void
735  u32 node_index, vnet_device_class_t * dev_class)
736 {
737  vlib_node_t *n = vlib_get_node (vm, node_index);
738 
739  n->function = dev_class->tx_function;
740  n->format_trace = dev_class->format_tx_trace;
741 
742  vlib_register_errors (vm, node_index,
743  dev_class->tx_function_n_errors,
744  dev_class->tx_function_error_strings);
745 }
746 
747 static void
749  u32 node_index, vnet_hw_interface_class_t * hw_class)
750 {
751  vlib_node_t *n = vlib_get_node (vm, node_index);
752  n->format_buffer = hw_class->format_header;
753  n->unformat_buffer = hw_class->unformat_header;
754 }
755 
756 /* Register an interface instance. */
757 u32
759  u32 dev_class_index,
760  u32 dev_instance,
761  u32 hw_class_index, u32 hw_instance)
762 {
765  vnet_device_class_t *dev_class =
766  vnet_get_device_class (vnm, dev_class_index);
767  vnet_hw_interface_class_t *hw_class =
768  vnet_get_hw_interface_class (vnm, hw_class_index);
769  vlib_main_t *vm = vnm->vlib_main;
771  vnet_config_main_t *cm;
772  u32 hw_index, i;
773  char *tx_node_name = NULL, *output_node_name = NULL;
774 
775  pool_get (im->hw_interfaces, hw);
776  memset (hw, 0, sizeof (*hw));
777 
778  hw_index = hw - im->hw_interfaces;
779  hw->hw_if_index = hw_index;
781 
782  if (dev_class->format_device_name)
783  hw->name = format (0, "%U", dev_class->format_device_name, dev_instance);
784  else if (hw_class->format_interface_name)
785  hw->name = format (0, "%U", hw_class->format_interface_name,
786  dev_instance);
787  else
788  hw->name = format (0, "%s%x", hw_class->name, dev_instance);
789 
790  if (!im->hw_interface_by_name)
791  im->hw_interface_by_name = hash_create_vec ( /* size */ 0,
792  sizeof (hw->name[0]),
793  sizeof (uword));
794 
795  hash_set_mem (im->hw_interface_by_name, hw->name, hw_index);
796 
797  /* Make hardware interface point to software interface. */
798  {
799  vnet_sw_interface_t sw = {
801  .flood_class = VNET_FLOOD_CLASS_NORMAL,
802  .hw_if_index = hw_index
803  };
805  }
806 
807  hw->dev_class_index = dev_class_index;
808  hw->dev_instance = dev_instance;
809  hw->hw_class_index = hw_class_index;
810  hw->hw_instance = hw_instance;
811 
812  hw->max_rate_bits_per_sec = 0;
813  hw->min_packet_bytes = 0;
815 
816  if (dev_class->tx_function == 0)
817  goto no_output_nodes; /* No output/tx nodes to create */
818 
819  tx_node_name = (char *) format (0, "%v-tx", hw->name);
820  output_node_name = (char *) format (0, "%v-output", hw->name);
821 
822  /* If we have previously deleted interface nodes, re-use them. */
823  if (vec_len (im->deleted_hw_interface_nodes) > 0)
824  {
826  vlib_node_t *node;
827  vlib_node_runtime_t *nrt;
828 
829  hn = vec_end (im->deleted_hw_interface_nodes) - 1;
830 
831  hw->tx_node_index = hn->tx_node_index;
833 
834  vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name);
835  vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name);
836 
837  /* *INDENT-OFF* */
840 
841  rt = vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
842  ASSERT (rt->is_deleted == 1);
843  rt->is_deleted = 0;
844  rt->hw_if_index = hw_index;
845  rt->sw_if_index = hw->sw_if_index;
846  rt->dev_instance = hw->dev_instance;
847 
848  rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index);
849  rt->hw_if_index = hw_index;
850  rt->sw_if_index = hw->sw_if_index;
851  rt->dev_instance = hw->dev_instance;
852  });
853  /* *INDENT-ON* */
854 
855  /* The new class may differ from the old one.
856  * Functions have to be updated. */
857  node = vlib_get_node (vm, hw->output_node_index);
859  node->format_trace = format_vnet_interface_output_trace;
860  /* *INDENT-OFF* */
862  nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index);
863  nrt->function = node->function;
864  });
865  /* *INDENT-ON* */
866 
867  node = vlib_get_node (vm, hw->tx_node_index);
868  node->function = dev_class->tx_function;
869  node->format_trace = dev_class->format_tx_trace;
870  /* *INDENT-OFF* */
872  nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index);
873  nrt->function = node->function;
874  });
875  /* *INDENT-ON* */
876 
877  _vec_len (im->deleted_hw_interface_nodes) -= 1;
878  }
879  else
880  {
883  .hw_if_index = hw_index,
884  .sw_if_index = hw->sw_if_index,
885  .dev_instance = hw->dev_instance,
886  .is_deleted = 0,
887  };
888 
889  memset (&r, 0, sizeof (r));
890  r.type = VLIB_NODE_TYPE_INTERNAL;
891  r.runtime_data = &rt;
892  r.runtime_data_bytes = sizeof (rt);
893  r.scalar_size = 0;
894  r.vector_size = sizeof (u32);
895 
896  r.flags = VLIB_NODE_FLAG_IS_OUTPUT;
897  r.name = tx_node_name;
898  r.function = dev_class->tx_function;
899 
900  hw->tx_node_index = vlib_register_node (vm, &r);
901 
903  "error-drop",
905 
906  r.flags = 0;
907  r.name = output_node_name;
909  r.format_trace = format_vnet_interface_output_trace;
910 
911  {
912  static char *e[] = {
913  "interface is down",
914  "interface is deleted",
915  };
916 
917  r.n_errors = ARRAY_LEN (e);
918  r.error_strings = e;
919  }
920  hw->output_node_index = vlib_register_node (vm, &r);
921 
923  "error-drop",
926  hw->tx_node_index,
928 
929  /* add interface to the list of "output-interface" feature arc start nodes
930  and clone nexts from 1st interface if it exists */
932  cm = &fcm->config_main;
933  i = vec_len (cm->start_node_indices);
936  if (hw_index)
937  {
938  /* copy nexts from 1st interface */
939  vnet_hw_interface_t *first_hw;
940  vlib_node_t *first_node;
941 
942  first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0);
943  first_node = vlib_get_node (vm, first_hw->output_node_index);
944 
945  /* 1st 2 nexts are already added above */
946  for (i = 2; i < vec_len (first_node->next_nodes); i++)
948  first_node->next_nodes[i], i);
949  }
950  }
951 
952  setup_output_node (vm, hw->output_node_index, hw_class);
953  setup_tx_node (vm, hw->tx_node_index, dev_class);
954 
955 no_output_nodes:
956  /* Call all up/down callbacks with zero flags when interface is created. */
957  vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0,
959  vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0,
961  vec_free (tx_node_name);
962  vec_free (output_node_name);
963 
964  return hw_index;
965 }
966 
967 void
969 {
971  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
972  vlib_main_t *vm = vnm->vlib_main;
973  vnet_device_class_t *dev_class = vnet_get_device_class (vnm,
974  hw->dev_class_index);
975  /* If it is up, mark it down. */
976  if (hw->flags != 0)
977  vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0);
978 
979  /* Call delete callbacks. */
980  call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0);
981 
982  /* Delete any sub-interfaces. */
983  {
984  u32 id, sw_if_index;
985  /* *INDENT-OFF* */
986  hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id,
987  ({
988  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
989  u64 sup_and_sub_key =
990  ((u64) (si->sup_sw_if_index) << 32) | (u64) si->sub.id;
991  hash_unset_mem_free (&im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
992  vnet_delete_sw_interface (vnm, sw_if_index);
993  }));
995  /* *INDENT-ON* */
996  }
997 
998  /* Delete software interface corresponding to hardware interface. */
1000 
1001  if (dev_class->tx_function)
1002  {
1003  /* Put output/tx nodes into recycle pool */
1005 
1006  /* *INDENT-OFF* */
1008  ({
1010  vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
1011 
1012  /* Mark node runtime as deleted so output node (if called)
1013  * will drop packets. */
1014  rt->is_deleted = 1;
1015  });
1016  /* *INDENT-ON* */
1017 
1019  "interface-%d-output-deleted", hw_if_index);
1020  vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted",
1021  hw_if_index);
1022  vec_add2 (im->deleted_hw_interface_nodes, dn, 1);
1023  dn->tx_node_index = hw->tx_node_index;
1025  }
1026 
1028  vec_free (hw->name);
1029  vec_free (hw->hw_address);
1032 
1033  pool_put (im->hw_interfaces, hw);
1034 }
1035 
1036 void
1038  u32 hw_if_index,
1039  vnet_hw_sw_interface_walk_t fn, void *ctx)
1040 {
1042  u32 id, sw_if_index;
1043 
1044  hi = vnet_get_hw_interface (vnm, hw_if_index);
1045  /* the super first, then the sub interfaces */
1046  if (WALK_STOP == fn (vnm, hi->sw_if_index, ctx))
1047  return;
1048 
1049  /* *INDENT-OFF* */
1050  hash_foreach (id, sw_if_index,
1052  ({
1053  if (WALK_STOP == fn (vnm, sw_if_index, ctx))
1054  break;
1055  }));
1056  /* *INDENT-ON* */
1057 }
1058 
1059 void
1061  vnet_hw_interface_walk_t fn, void *ctx)
1062 {
1065 
1066  im = &vnm->interface_main;
1067 
1068  /* *INDENT-OFF* */
1069  pool_foreach (hi, im->hw_interfaces,
1070  ({
1071  if (WALK_STOP == fn(vnm, hi->hw_if_index, ctx))
1072  break;
1073  }));
1074  /* *INDENT-ON* */
1075 }
1076 
1077 void
1079  vnet_sw_interface_walk_t fn, void *ctx)
1080 {
1082  vnet_sw_interface_t *si;
1083 
1084  im = &vnm->interface_main;
1085 
1086  /* *INDENT-OFF* */
1087  pool_foreach (si, im->sw_interfaces,
1088  {
1089  if (WALK_STOP == fn (vnm, si, ctx))
1090  break;
1091  });
1092  /* *INDENT-ON* */
1093 }
1094 
1095 static void
1097 {
1098  u32 hw_if_index = va_arg (*va, u32);
1099  char *hw_class_name = va_arg (*va, char *);
1100  serialize_integer (m, hw_if_index, sizeof (hw_if_index));
1101  serialize_cstring (m, hw_class_name);
1102 }
1103 
1104 static void
1106 {
1107  CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *);
1108  vnet_main_t *vnm = vnet_get_main ();
1109  u32 hw_if_index;
1110  char *hw_class_name;
1111  uword *p;
1112  clib_error_t *error;
1113 
1114  unserialize_integer (m, &hw_if_index, sizeof (hw_if_index));
1115  unserialize_cstring (m, &hw_class_name);
1116  p =
1117  hash_get (vnm->interface_main.hw_interface_class_by_name, hw_class_name);
1118  ASSERT (p != 0);
1119  error = vnet_hw_interface_set_class_helper (vnm, hw_if_index, p[0],
1120  /* redistribute */ 0);
1121  if (error)
1122  clib_error_report (error);
1123 }
1124 
1125 MC_SERIALIZE_MSG (vnet_hw_interface_set_class_msg, static) =
1126 {
1127 .name = "vnet_hw_interface_set_class",.serialize =
1130 
1131 void
1133  u32 hw_class_index, u32 hw_instance)
1134 {
1135  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1137  vnet_get_hw_interface_class (vnm, hw_class_index);
1138 
1139  hi->hw_class_index = hw_class_index;
1140  hi->hw_instance = hw_instance;
1142 }
1143 
1144 static clib_error_t *
1146  u32 hw_class_index, u32 redistribute)
1147 {
1148  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1150  vnet_hw_interface_class_t *old_class =
1152  vnet_hw_interface_class_t *new_class =
1153  vnet_get_hw_interface_class (vnm, hw_class_index);
1154  vnet_device_class_t *dev_class =
1156  clib_error_t *error = 0;
1157 
1158  /* New class equals old class? Nothing to do. */
1159  if (hi->hw_class_index == hw_class_index)
1160  return 0;
1161 
1162  /* No need (and incorrect since admin up flag may be set) to do error checking when
1163  receiving unserialize message. */
1164  if (redistribute)
1165  {
1167  return clib_error_return (0,
1168  "%v must be admin down to change class from %s to %s",
1169  hi->name, old_class->name, new_class->name);
1170 
1171  /* Make sure interface supports given class. */
1172  if ((new_class->is_valid_class_for_interface
1173  && !new_class->is_valid_class_for_interface (vnm, hw_if_index,
1174  hw_class_index))
1175  || (dev_class->is_valid_class_for_interface
1176  && !dev_class->is_valid_class_for_interface (vnm, hw_if_index,
1177  hw_class_index)))
1178  return clib_error_return (0,
1179  "%v class cannot be changed from %s to %s",
1180  hi->name, old_class->name, new_class->name);
1181 
1182  if (vnm->vlib_main->mc_main)
1183  {
1185  &vnet_hw_interface_set_class_msg, hw_if_index,
1186  new_class->name);
1187  return 0;
1188  }
1189  }
1190 
1191  if (old_class->hw_class_change)
1192  old_class->hw_class_change (vnm, hw_if_index, old_class->index,
1193  new_class->index);
1194 
1195  vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index,
1196  /* instance */ ~0);
1197 
1198  if (new_class->hw_class_change)
1199  new_class->hw_class_change (vnm, hw_if_index, old_class->index,
1200  new_class->index);
1201 
1202  if (dev_class->hw_class_change)
1203  dev_class->hw_class_change (vnm, hw_if_index, new_class->index);
1204 
1205  return error;
1206 }
1207 
1208 clib_error_t *
1210  u32 hw_class_index)
1211 {
1212  return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index,
1213  /* redistribute */ 1);
1214 }
1215 
1216 static int
1218  u32 hw_if_index,
1219  u32 node_index,
1220  u32 redistribute)
1221 {
1222  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1224  (vnm, hi->dev_class_index);
1225 
1226  if (redistribute)
1227  {
1228  /* $$$$ fixme someday maybe */
1229  ASSERT (vnm->vlib_main->mc_main == 0);
1230  }
1231  if (dev_class->rx_redirect_to_node)
1232  {
1233  dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index);
1234  return 0;
1235  }
1236 
1237  return VNET_API_ERROR_UNIMPLEMENTED;
1238 }
1239 
1240 int
1242  u32 node_index)
1243 {
1244  return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index,
1245  node_index,
1246  1 /* redistribute */ );
1247 }
1248 
1249 word
1251  uword sw_if_index0, uword sw_if_index1)
1252 {
1253  vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1254  vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1);
1257 
1258  if (h0 != h1)
1259  return vec_cmp (h0->name, h1->name);
1260  return (word) h0->hw_instance - (word) h1->hw_instance;
1261 }
1262 
1263 word
1265  uword hw_if_index0, uword hw_if_index1)
1266 {
1267  vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0);
1268  vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_if_index1);
1269 
1270  if (h0 != h1)
1271  return vec_cmp (h0->name, h1->name);
1272  return (word) h0->hw_instance - (word) h1->hw_instance;
1273 }
1274 
1275 int
1277 {
1278  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
1279  if ((si->type == VNET_SW_INTERFACE_TYPE_P2P) ||
1281  return 1;
1282 
1283  vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1286 
1287  return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P);
1288 }
1289 
1290 clib_error_t *
1292 {
1293  vnet_main_t *vnm = vnet_get_main ();
1295  vlib_buffer_t *b = 0;
1296  vnet_buffer_opaque_t *o = 0;
1297  clib_error_t *error;
1298 
1299  /*
1300  * Keep people from shooting themselves in the foot.
1301  */
1302  if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t))
1303  {
1304 #define _(a) if (sizeof(o->a) > sizeof (o->unused)) \
1305  clib_warning \
1306  ("FATAL: size of opaque union subtype %s is %d (max %d)", \
1307  #a, sizeof(o->a), sizeof (o->unused));
1309 #undef _
1310 
1311  return clib_error_return
1312  (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d",
1313  sizeof (b->opaque), sizeof (vnet_buffer_opaque_t));
1314  }
1315 
1318  im->sw_if_counter_lock[0] = 1; /* should be no need */
1319 
1321 #define _(E,n,p) \
1322  im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \
1323  im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1325 #undef _
1328 #define _(E,n,p) \
1329  im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \
1330  im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1332 #undef _
1333  im->sw_if_counter_lock[0] = 0;
1334 
1335  im->device_class_by_name = hash_create_string ( /* size */ 0,
1336  sizeof (uword));
1337  {
1339 
1340  c = vnm->device_class_registrations;
1341 
1342  while (c)
1343  {
1344  c->index = vec_len (im->device_classes);
1345  hash_set_mem (im->device_class_by_name, c->name, c->index);
1346  vec_add1 (im->device_classes, c[0]);
1347  c = c->next_class_registration;
1348  }
1349  }
1350 
1351  im->hw_interface_class_by_name = hash_create_string ( /* size */ 0,
1352  sizeof (uword));
1353 
1354  im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64),
1355  sizeof (uword));
1356  {
1358 
1360 
1361  while (c)
1362  {
1363  c->index = vec_len (im->hw_interface_classes);
1364  hash_set_mem (im->hw_interface_class_by_name, c->name, c->index);
1365 
1366  if (NULL == c->build_rewrite)
1367  c->build_rewrite = default_build_rewrite;
1368  if (NULL == c->update_adjacency)
1369  c->update_adjacency = default_update_adjacency;
1370 
1371  vec_add1 (im->hw_interface_classes, c[0]);
1372  c = c->next_class_registration;
1373  }
1374  }
1375 
1377  return error;
1378 
1379  vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword));
1380 
1381 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
1382  if ((error = vlib_call_init_function (vm, trajectory_trace_init)))
1383  return error;
1384 #endif
1385 
1386  return 0;
1387 }
1388 
1390 
1391 /* Kludge to renumber interface names [only!] */
1392 int
1393 vnet_interface_name_renumber (u32 sw_if_index, u32 new_show_dev_instance)
1394 {
1395  int rv;
1396  vnet_main_t *vnm = vnet_get_main ();
1398  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1399 
1401  (vnm, hi->dev_class_index);
1402 
1403  if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0)
1404  return VNET_API_ERROR_UNIMPLEMENTED;
1405 
1406  rv = dev_class->name_renumber (hi, new_show_dev_instance);
1407 
1408  if (rv)
1409  return rv;
1410 
1412  vec_free (hi->name);
1413  /* Use the mapping we set up to call it Ishmael */
1414  hi->name = format (0, "%U", dev_class->format_device_name,
1415  hi->dev_instance);
1416 
1418  return rv;
1419 }
1420 
1421 clib_error_t *
1422 vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name)
1423 {
1425  vlib_main_t *vm = vnm->vlib_main;
1426  vnet_hw_interface_t *hw;
1427  u8 *old_name;
1428  clib_error_t *error = 0;
1429 
1430  hw = vnet_get_hw_interface (vnm, hw_if_index);
1431  if (!hw)
1432  {
1433  return clib_error_return (0,
1434  "unable to find hw interface for index %u",
1435  hw_if_index);
1436  }
1437 
1438  old_name = hw->name;
1439 
1440  /* set new hw->name */
1441  hw->name = format (0, "%s", new_name);
1442 
1443  /* remove the old name to hw_if_index mapping and install the new one */
1444  hash_unset_mem (im->hw_interface_by_name, old_name);
1445  hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index);
1446 
1447  /* rename tx/output nodes */
1448  vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
1449  vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
1450 
1451  /* free the old name vector */
1452  vec_free (old_name);
1453 
1454  return error;
1455 }
1456 
1457 static clib_error_t *
1459  u32 hw_if_index,
1460  u8 * mac_address)
1461 {
1462  clib_error_t *error = 0;
1463  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1464 
1465  if (hi->hw_address)
1466  {
1467  vnet_device_class_t *dev_class =
1469  if (dev_class->mac_addr_change_function)
1470  {
1471  error =
1472  dev_class->mac_addr_change_function (hi, (char *) mac_address);
1473  }
1474  if (!error)
1475  {
1476  vnet_hw_interface_class_t *hw_class;
1477 
1478  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1479 
1480  if (NULL != hw_class->mac_addr_change_function)
1481  hw_class->mac_addr_change_function (hi, (char *) mac_address);
1482  }
1483  else
1484  {
1485  error =
1486  clib_error_return (0,
1487  "MAC Address Change is not supported on this interface");
1488  }
1489  }
1490  else
1491  {
1492  error =
1493  clib_error_return (0,
1494  "mac address change is not supported for interface index %u",
1495  hw_if_index);
1496  }
1497  return error;
1498 }
1499 
1500 clib_error_t *
1502  u8 * mac_address)
1503 {
1505  (vnm, hw_if_index, mac_address);
1506 }
1507 
1508 /* update the unnumbered state of an interface*/
1509 void
1511  u32 ip_sw_if_index, u8 enable)
1512 {
1513  vnet_main_t *vnm = vnet_get_main ();
1514  vnet_sw_interface_t *si;
1515  u32 was_unnum;
1516 
1517  si = vnet_get_sw_interface (vnm, unnumbered_sw_if_index);
1518  was_unnum = (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED);
1519 
1520  if (enable)
1521  {
1523  si->unnumbered_sw_if_index = ip_sw_if_index;
1524 
1526  [unnumbered_sw_if_index] =
1527  ip4_main.
1528  lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1529  ip6_main.
1530  lookup_main.if_address_pool_index_by_sw_if_index
1531  [unnumbered_sw_if_index] =
1532  ip6_main.
1533  lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1534  }
1535  else
1536  {
1538  si->unnumbered_sw_if_index = (u32) ~ 0;
1539 
1541  [unnumbered_sw_if_index] = ~0;
1543  [unnumbered_sw_if_index] = ~0;
1544  }
1545 
1546  if (was_unnum != (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
1547  {
1548  ip4_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1549  ip6_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1550  }
1551 }
1552 
1555 {
1556  switch (link)
1557  {
1558  case VNET_LINK_IP4:
1559  return (VNET_L3_PACKET_TYPE_IP4);
1560  case VNET_LINK_IP6:
1561  return (VNET_L3_PACKET_TYPE_IP6);
1562  case VNET_LINK_MPLS:
1563  return (VNET_L3_PACKET_TYPE_MPLS);
1564  case VNET_LINK_ARP:
1565  return (VNET_L3_PACKET_TYPE_ARP);
1566  case VNET_LINK_ETHERNET:
1567  case VNET_LINK_NSH:
1568  ASSERT (0);
1569  break;
1570  }
1571  ASSERT (0);
1572  return (0);
1573 }
1574 
1575 vnet_mtu_t
1577 {
1578  switch (link)
1579  {
1580  case VNET_LINK_IP4:
1581  return (VNET_MTU_IP4);
1582  case VNET_LINK_IP6:
1583  return (VNET_MTU_IP6);
1584  case VNET_LINK_MPLS:
1585  return (VNET_MTU_MPLS);
1586  default:
1587  return (VNET_MTU_L3);
1588  }
1589 }
1590 
1591 u8 *
1593  u32 sw_if_index,
1594  vnet_link_t link_type, const void *dst_address)
1595 {
1596  return (NULL);
1597 }
1598 
1599 void
1601 {
1602  ip_adjacency_t *adj;
1603 
1604  adj = adj_get (ai);
1605 
1606  switch (adj->lookup_next_index)
1607  {
1608  case IP_LOOKUP_NEXT_GLEAN:
1610  break;
1611  case IP_LOOKUP_NEXT_ARP:
1612  /*
1613  * default rewirte in neighbour adj
1614  */
1616  (ai,
1619  sw_if_index,
1620  adj_get_link_type (ai), NULL));
1621  break;
1622  case IP_LOOKUP_NEXT_MCAST:
1623  /*
1624  * mcast traffic also uses default rewrite string with no mcast
1625  * switch time updates.
1626  */
1628  (ai,
1630  sw_if_index,
1631  adj_get_link_type (ai),
1632  NULL), 0);
1633  break;
1634  case IP_LOOKUP_NEXT_DROP:
1635  case IP_LOOKUP_NEXT_PUNT:
1636  case IP_LOOKUP_NEXT_LOCAL:
1641  case IP_LOOKUP_N_NEXT:
1642  ASSERT (0);
1643  break;
1644  }
1645 }
1646 
1648 
1649 void
1651 {
1653 }
1654 
1655 void
1657 {
1659 }
1660 
1661 static clib_error_t *
1663  unformat_input_t * input,
1664  vlib_cli_command_t * cmd)
1665 {
1666  unformat_input_t _line_input, *line_input = &_line_input;
1667  clib_error_t *error = NULL;
1668 
1669  /* Get a line of input. */
1670  if (!unformat_user (input, unformat_line_input, line_input))
1671  return clib_error_return (0, "expected enable | disable");
1672 
1673  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1674  {
1675  if (unformat (line_input, "enable") || unformat (line_input, "on"))
1677  else if (unformat (line_input, "disable")
1678  || unformat (line_input, "off"))
1680  else
1681  {
1682  error = clib_error_return (0, "unknown input `%U'",
1683  format_unformat_error, line_input);
1684  goto done;
1685  }
1686  }
1687 
1688 done:
1689  unformat_free (line_input);
1690  return error;
1691 }
1692 
1693 /* *INDENT-OFF* */
1694 VLIB_CLI_COMMAND (collect_detailed_interface_stats_command, static) = {
1695  .path = "interface collect detailed-stats",
1696  .short_help = "interface collect detailed-stats <enable|disable>",
1698 };
1699 /* *INDENT-ON* */
1700 
1701 /*
1702  * fd.io coding-style-patch-verification: ON
1703  *
1704  * Local Variables:
1705  * eval: (c-set-style "gnu")
1706  * End:
1707  */
u32 * next_nodes
Definition: node.h:324
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:437
void serialize_vnet_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:151
#define VNET_SW_INTERFACE_FLAG_UNNUMBERED
Definition: interface.h:668
vmrglw vmrglh hi
l2_input_config_t * configs
Definition: l2_input.h:66
#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:1145
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:541
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:106
volatile u32 * sw_if_counter_lock
Definition: interface.h:809
vnet_hw_interface_nodes_t * deleted_hw_interface_nodes
Definition: interface.h:813
_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:142
unsigned long u64
Definition: types.h:89
int vnet_hw_interface_rx_redirect_to_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
Definition: interface.c:1241
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:1037
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:388
#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
walk_rc_t(* vnet_hw_interface_walk_t)(vnet_main_t *vnm, u32 hw_if_index, void *ctx)
Call back walk type for walking all HW indices.
#define vec_unserialize(m, v, f)
Definition: serialize.h:374
IP unicast adjacency.
Definition: adj.h:175
format_function_t * format_trace
Definition: node.h:351
vnet_device_class_t * device_class_registrations
Definition: vnet.h:59
u32 * input_node_thread_index_by_queue
Definition: interface.h:560
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:523
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
Definition: interface.c:1250
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
Definition: interface.c:1393
static void vnet_clear_sw_interface_tag(vnet_main_t *vnm, u32 sw_if_index)
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:562
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
#define hash_set_mem(h, key, value)
Definition: hash.h:275
MC_SERIALIZE_MSG(vnet_sw_interface_set_flags_msg, static)
ip_lookup_main_t lookup_main
Definition: ip4.h:97
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:543
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:72
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:458
_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:659
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
uword * dq_runtime_index_by_queue
Definition: interface.h:567
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
unsigned char u8
Definition: types.h:56
#define VNET_HW_INTERFACE_FLAG_DUPLEX_MASK
Definition: interface.h:463
mc_main_t * mc_main
Definition: main.h:150
static clib_error_t * collect_detailed_interface_stats_cli(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: interface.c:1662
vlib_node_function_t * function
Definition: node.h:254
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[])
Definition: error.c:158
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
enum walk_rc_t_ walk_rc_t
Walk return code.
#define VNET_HW_INTERFACE_FLAG_SPEED_MASK
Definition: interface.h:481
void adj_glean_update_rewrite(adj_index_t adj_index)
adj_glean_update_rewrite
Definition: adj_glean.c:101
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:370
void default_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Default adjacency update function.
Definition: interface.c:1600
vnet_l3_packet_type_t
Definition: l3_types.h:44
i64 word
Definition: types.h:111
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:443
vlib_node_function_t * function
Node function to call.
Definition: node.h:449
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
static u32 vnet_create_sw_interface_no_callbacks(vnet_main_t *vnm, vnet_sw_interface_t *template)
Definition: interface.c:557
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:811
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
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
static walk_rc_t sw_interface_walk_callback(vnet_main_t *vnm, u32 sw_if_index, void *ctx)
Definition: interface.c:712
u32 mtu[VNET_N_MTU]
Definition: interface.h:695
unsigned int u32
Definition: types.h:88
#define vec_end(v)
End (last data address) of vector.
#define vlib_call_init_function(vm, x)
Definition: init.h:227
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:758
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
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:551
void vnet_sw_interface_set_protocol_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu[])
Definition: interface.c:688
unformat_function_t unformat_line_input
Definition: format.h:282
uword * hw_interface_by_name
Definition: interface.h:791
vnet_hw_interface_t * hw_interfaces
Definition: interface.h:788
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:661
#define hash_get(h, key)
Definition: hash.h:249
format_function_t format_vnet_sw_interface_name
void adj_mcast_update_rewrite(adj_index_t adj_index, u8 *rewrite, u8 offset)
adj_mcast_update_rewrite
Definition: adj_mcast.c:102
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
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:278
u8 * format_vnet_interface_output_trace(u8 *s, va_list *va)
#define hash_unset_mem(h, key)
Definition: hash.h:291
void ip4_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip4_forward.c:496
u32 * start_node_indices
Definition: config.h:98
vlib_main_t * vlib_main
Definition: vnet.h:80
void vnet_sw_interface_walk(vnet_main_t *vnm, vnet_sw_interface_walk_t fn, void *ctx)
Walk all the SW interfaces in the system.
Definition: interface.c:1078
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1276
#define VNET_SW_INTERFACE_FLAG_BOND_SLAVE
Definition: interface.h:670
struct _unformat_input_t unformat_input_t
vnet_mtu_t
Definition: interface.h:640
#define hash_free(h)
Definition: hash.h:310
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
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:805
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:213
static void unserialize_vnet_hw_interface_set_class(serialize_main_t *m, va_list *va)
Definition: interface.c:1105
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:810
word vnet_hw_interface_compare(vnet_main_t *vnm, uword hw_if_index0, uword hw_if_index1)
Definition: interface.c:1264
format_function_t * format_buffer
Definition: node.h:347
void vnet_sw_interface_update_unnumbered(u32 unnumbered_sw_if_index, u32 ip_sw_if_index, u8 enable)
Definition: interface.c:1510
#define foreach_vlib_main(body)
Definition: threads.h:244
uword * hw_interface_class_by_name
Definition: interface.h:798
void unserialize_cstring(serialize_main_t *m, char **s)
Definition: serialize.c:178
u32 flags
Definition: vhost_user.h:110
#define foreach_simple_interface_counter_name
Definition: interface.h:741
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:1422
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:672
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
#define foreach_combined_interface_counter_name
Definition: interface.h:751
svmdb_client_t * c
vlib_main_t * vm
Definition: buffer.c:294
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
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:1501
unformat_function_t * unformat_buffer
Definition: node.h:348
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:836
#define ETHERNET_INTERFACE_FLAG_MTU
Definition: ethernet.h:152
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:1132
#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:748
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:1592
format_function_t format_vnet_sw_interface_flags
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
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
u32 * if_address_pool_index_by_sw_if_index
Head of doubly linked list of interface addresses for each software interface.
Definition: lookup.h:129
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:828
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
Definition: counter.c:92
#define hash_create(elts, value_bytes)
Definition: hash.h:696
Definition: mc.h:530
enum vnet_interface_function_priority_t_ vnet_interface_function_priority_t
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:661
#define ASSERT(truth)
_vnet_interface_function_list_elt_t * sw_interface_mtu_change_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:70
void collect_detailed_interface_stats_flag_clear(void)
Definition: interface.c:1656
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
ip6_main_t ip6_main
Definition: ip6_forward.c:2574
#define VNET_SW_INTERFACE_FLAG_PUNT
Definition: interface.h:664
ip_lookup_main_t lookup_main
Definition: ip6.h:161
long ctx[MAX_CONNS]
Definition: main.c:126
static void setup_tx_node(vlib_main_t *vm, u32 node_index, vnet_device_class_t *dev_class)
Definition: interface.c:734
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:518
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:684
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:124
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:921
walk_rc_t(* 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.
uword * device_class_by_name
Definition: interface.h:799
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:968
void serialize_cstring(serialize_main_t *m, char *s)
Definition: serialize.c:164
int collect_detailed_interface_stats_flag
Definition: interface.c:1647
struct _vlib_node_registration vlib_node_registration_t
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
void vnet_hw_interface_set_mtu(vnet_main_t *vnm, u32 hw_if_index, u32 mtu)
Definition: interface.c:720
l2input_main_t l2input_main
Definition: l2_input.c:113
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:668
void vnet_hw_interface_walk(vnet_main_t *vnm, vnet_hw_interface_walk_t fn, void *ctx)
Walk all the HW interface.
Definition: interface.c:1060
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:676
clib_error_t * vnet_interface_init(vlib_main_t *vm)
Definition: interface.c:1291
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:1458
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:190
vnet_l3_packet_type_t vnet_link_to_l3_proto(vnet_link_t link)
Convert a link to to an Ethertype.
Definition: interface.c:1554
static clib_error_t * vnet_interface_cli_init(vlib_main_t *vm)
vnet_mtu_t vnet_link_to_mtu(vnet_link_t link)
Definition: interface.c:1576
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
void collect_detailed_interface_stats_flag_set(void)
Definition: interface.c:1650
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:1217
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:802
vnet_hw_interface_class_t * hw_interface_class_registrations
Definition: vnet.h:60
a point 2 point interface
Definition: interface.h:345
u32 ethernet_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:367
vnet_hw_interface_class_t * hw_interface_classes
Definition: interface.h:794
void vnet_sw_interface_set_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu)
Definition: interface.c:676
walk_rc_t(* vnet_sw_interface_walk_t)(vnet_main_t *vnm, vnet_sw_interface_t *si, void *ctx)
Call back walk type for walking SW indices on a HW interface.
_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:1096
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
vnet_sw_interface_type_t type
Definition: interface.h:656
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:832
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:59
#define VLIB_NODE_FLAG_IS_OUTPUT
Definition: node.h:289
#define vec_foreach(var, vec)
Vector iterator.
vnet_hw_interface_rx_mode default_rx_mode
Definition: interface.h:564
void vnet_delete_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:639
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:549
vnet_device_class_t * device_classes
Definition: interface.h:795
#define foreach_buffer_opaque_union_subtype
Definition: buffer.h:86
_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:601
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:62
static_always_inline vnet_feature_config_main_t * vnet_feature_get_config_main(u16 arc)
Definition: feature.h:176
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
static clib_error_t * call_sw_interface_mtu_change_callbacks(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:669
#define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE
Definition: interface.c:304
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:142
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
#define MODE_L3
Definition: l2_input.h:206
clib_error_t * vnet_hw_interface_set_class(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index)
Definition: interface.c:1209