FD.io VPP  v20.09-64-g4f7b92f0a
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 #include <vnet/l2/l2_input.h>
46 
48 {
52 
54  u32 hw_if_index,
56  flags,
58  helper_flags);
59 
63  flags,
65  helper_flags);
66 
68  u32 hw_if_index,
69  u32 hw_class_index,
70  u32 redistribute);
71 
72 typedef struct
73 {
74  /* Either sw or hw interface index. */
76 
77  /* Flags. */
80 
81 static void
83 {
85  va_arg (*va, vnet_sw_hw_interface_state_t *);
86  u32 n = va_arg (*va, u32);
87  u32 i;
88  for (i = 0; i < n; i++)
89  {
90  serialize_integer (m, s[i].sw_hw_if_index,
91  sizeof (s[i].sw_hw_if_index));
92  serialize_integer (m, s[i].flags, sizeof (s[i].flags));
93  }
94 }
95 
96 static void
98  va_list * va)
99 {
101  va_arg (*va, vnet_sw_hw_interface_state_t *);
102  u32 n = va_arg (*va, u32);
103  u32 i;
104  for (i = 0; i < n; i++)
105  {
106  unserialize_integer (m, &s[i].sw_hw_if_index,
107  sizeof (s[i].sw_hw_if_index));
108  unserialize_integer (m, &s[i].flags, sizeof (s[i].flags));
109  }
110 }
111 
114 {
116 
119 
120  return (swf);
121 }
122 
123 void
125 {
126  vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
127  vnet_sw_hw_interface_state_t *sts = 0, *st;
128  vnet_sw_interface_t *sif;
129  vnet_hw_interface_t *hif;
131 
132  /* Serialize hardware interface classes since they may have changed.
133  Must do this before sending up/down flags. */
134  /* *INDENT-OFF* */
135  pool_foreach (hif, im->hw_interfaces, ({
136  vnet_hw_interface_class_t * hw_class = vnet_get_hw_interface_class (vnm, hif->hw_class_index);
137  serialize_cstring (m, hw_class->name);
138  }));
139  /* *INDENT-ON* */
140 
141  /* Send sw/hw interface state when non-zero. */
142  /* *INDENT-OFF* */
143  pool_foreach (sif, im->sw_interfaces, ({
144  if (sif->flags != 0)
145  {
146  vec_add2 (sts, st, 1);
147  st->sw_hw_if_index = sif->sw_if_index;
148  st->flags = sif->flags;
149  }
150  }));
151  /* *INDENT-ON* */
152 
154 
155  if (sts)
156  _vec_len (sts) = 0;
157 
158  /* *INDENT-OFF* */
159  pool_foreach (hif, im->hw_interfaces, ({
160  if (hif->flags != 0)
161  {
162  vec_add2 (sts, st, 1);
163  st->sw_hw_if_index = hif->hw_if_index;
164  st->flags = vnet_hw_interface_flags_to_sw(hif->flags);
165  }
166  }));
167  /* *INDENT-ON* */
168 
170 
171  vec_free (sts);
172 }
173 
176 {
178 
181 
182  return (hwf);
183 }
184 
185 void
187 {
188  vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
189  vnet_sw_hw_interface_state_t *sts = 0, *st;
190 
191  /* First set interface hardware class. */
192  {
194  vnet_hw_interface_t *hif;
195  char *class_name;
196  uword *p;
197  clib_error_t *error;
198 
199  /* *INDENT-OFF* */
200  pool_foreach (hif, im->hw_interfaces, ({
201  unserialize_cstring (m, &class_name);
202  p = hash_get_mem (im->hw_interface_class_by_name, class_name);
203  if (p)
204  {
205  error = vnet_hw_interface_set_class_helper
206  (vnm, hif->hw_if_index, p[0], /* redistribute */ 0);
207  }
208  else
209  error = clib_error_return (0, "hw class %s AWOL?", class_name);
210 
211  if (error)
212  clib_error_report (error);
213  vec_free (class_name);
214  }));
215  /* *INDENT-ON* */
216  }
217 
219  vec_foreach (st, sts)
220  vnet_sw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags,
221  /* no distribute */ 0);
222  vec_free (sts);
223 
225  vec_foreach (st, sts)
226  {
228  (vnm, st->sw_hw_if_index, vnet_sw_interface_flags_to_hw (st->flags),
229  /* no distribute */ 0);
230  }
231  vec_free (sts);
232 }
233 
234 static clib_error_t *
236  u32 flags,
237  _vnet_interface_function_list_elt_t **
238  elts)
239 {
240  _vnet_interface_function_list_elt_t *elt;
242  clib_error_t *error = 0;
243 
244  for (prio = VNET_ITF_FUNC_PRIORITY_LOW;
245  prio <= VNET_ITF_FUNC_PRIORITY_HIGH; prio++)
246  {
247  elt = elts[prio];
248 
249  while (elt)
250  {
251  error = elt->fp (vnm, if_index, flags);
252  if (error)
253  return error;
254  elt = elt->next_interface_function;
255  }
256  }
257  return error;
258 }
259 
260 static clib_error_t *
262  u32 is_create)
263 {
264  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
265  vnet_hw_interface_class_t *hw_class =
267  vnet_device_class_t *dev_class =
269  clib_error_t *error = 0;
270 
271  if (hw_class->interface_add_del_function
272  && (error =
273  hw_class->interface_add_del_function (vnm, hw_if_index, is_create)))
274  return error;
275 
276  if (dev_class->interface_add_del_function
277  && (error =
278  dev_class->interface_add_del_function (vnm, hw_if_index,
279  is_create)))
280  return error;
281 
283  (vnm, hw_if_index, is_create, vnm->hw_interface_add_del_functions);
284 
285  return error;
286 }
287 
288 static clib_error_t *
290  u32 is_create)
291 {
293  (vnm, sw_if_index, is_create, vnm->sw_interface_add_del_functions);
294 }
295 
296 static clib_error_t *
300  helper_flags)
301 {
302  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
303  vnet_hw_interface_class_t *hw_class =
305  u32 mask;
306  clib_error_t *error = 0;
307  u32 is_create =
308  (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
309 
310  mask =
312  flags &= mask;
313 
314  /* Call hardware interface add/del callbacks. */
315  if (is_create)
316  call_hw_interface_add_del_callbacks (vnm, hw_if_index, is_create);
317 
318  /* Already in the desired state? */
319  if (!is_create && (hi->flags & mask) == flags)
320  goto done;
321 
324  {
325  /* Do hardware class (e.g. ethernet). */
326  if (hw_class->link_up_down_function
327  && (error = hw_class->link_up_down_function (vnm, hw_if_index,
328  flags)))
329  goto done;
330 
332  (vnm, hw_if_index, flags, vnm->hw_interface_link_up_down_functions);
333 
334  if (error)
335  goto done;
336  }
337 
338  hi->flags &= ~mask;
339  hi->flags |= flags;
340 
341 done:
342  return error;
343 }
344 
345 static clib_error_t *
349  helper_flags)
350 {
351  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
352  u32 mask;
353  clib_error_t *error = 0;
354  u32 is_create =
355  (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
356  u32 old_flags;
357 
359  flags &= mask;
360 
361  if (is_create)
362  {
363  error =
364  call_sw_interface_add_del_callbacks (vnm, sw_if_index, is_create);
365  if (error)
366  goto done;
367 
369  {
370  /* Notify everyone when the interface is created as admin up */
371  error = call_elf_section_interface_callbacks (vnm, sw_if_index,
372  flags,
373  vnm->
374  sw_interface_admin_up_down_functions);
375  if (error)
376  goto done;
377  }
378  }
379  else
380  {
381  vnet_sw_interface_t *si_sup = si;
382 
383  /* Check that super interface is in correct state. */
384  if (si->type == VNET_SW_INTERFACE_TYPE_SUB)
385  {
386  si_sup = vnet_get_sw_interface (vnm, si->sup_sw_if_index);
387 
388  /* Check to see if we're bringing down the soft interface and if it's parent is up */
389  if ((flags != (si_sup->flags & mask)) &&
390  (!((flags == 0)
391  && ((si_sup->flags & mask) ==
393  {
394  error = clib_error_return (0, "super-interface %U must be %U",
396  si_sup,
398  flags);
399  goto done;
400  }
401  }
402 
403  /* Already in the desired state? */
404  if ((si->flags & mask) == flags)
405  goto done;
406 
407  /* Sub-interfaces of hardware interfaces that do no redistribute,
408  do not redistribute themselves. */
409  if (si_sup->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
410  {
412  vnet_get_hw_interface (vnm, si_sup->hw_if_index);
413  vnet_device_class_t *dev_class =
415  if (!dev_class->redistribute)
416  helper_flags &=
418  }
419 
420  /* set the flags now before invoking the registered clients
421  * so that the state they query is consistent with the state here notified */
422  old_flags = si->flags;
423  si->flags &= ~mask;
424  si->flags |= flags;
425  if ((flags | old_flags) & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
427  (vnm, sw_if_index, flags,
429 
430  if (error)
431  {
432  /* restore flags on error */
433  si->flags = old_flags;
434  goto done;
435  }
436 
438  {
441  vnet_hw_interface_class_t *hw_class =
443  vnet_device_class_t *dev_class =
445 
446  if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
448  {
449  error = clib_error_return (0, "Interface in the error state");
450  goto done;
451  }
452 
453  /* save the si admin up flag */
454  old_flags = si->flags;
455 
456  /* update si admin up flag in advance if we are going admin down */
457  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
458  si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP;
459 
460  if (dev_class->admin_up_down_function
461  && (error = dev_class->admin_up_down_function (vnm,
462  si->hw_if_index,
463  flags)))
464  {
465  /* restore si admin up flag to it's original state on errors */
466  si->flags = old_flags;
467  goto done;
468  }
469 
470  if (hw_class->admin_up_down_function
471  && (error = hw_class->admin_up_down_function (vnm,
472  si->hw_if_index,
473  flags)))
474  {
475  /* restore si admin up flag to it's original state on errors */
476  si->flags = old_flags;
477  goto done;
478  }
479 
480  /* Admin down implies link down. */
481  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
484  hi->flags &
486  helper_flags);
487  }
488  }
489 
490  si->flags &= ~mask;
491  si->flags |= flags;
492 
493 done:
494  return error;
495 }
496 
497 clib_error_t *
500 {
502  (vnm, hw_if_index, flags,
504 }
505 
506 clib_error_t *
509 {
511  (vnm, sw_if_index, flags,
513 }
514 
515 void
517 {
518  u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
519 
520  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
521  {
523  vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
524  }
525 }
526 
527 void
529 {
530  u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
531 
533  {
535  vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
536  }
537 }
538 
539 static u32
541  vnet_sw_interface_t * template)
542 {
546 
547  pool_get (im->sw_interfaces, sw);
548  sw_if_index = sw - im->sw_interfaces;
549 
550  sw[0] = template[0];
551 
552  sw->flags = 0;
553  sw->sw_if_index = sw_if_index;
555  sw->sup_sw_if_index = sw->sw_if_index;
556 
557  /* Allocate counters for this interface. */
558  {
559  u32 i;
560 
562 
563  for (i = 0; i < vec_len (im->sw_if_counters); i++)
564  {
565  vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index);
566  vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index);
567  }
568 
569  for (i = 0; i < vec_len (im->combined_sw_if_counters); i++)
570  {
572  sw_if_index);
574  sw_if_index);
575  }
576 
578  }
579 
580  return sw_if_index;
581 }
582 
583 clib_error_t *
585  u32 * sw_if_index)
586 {
587  clib_error_t *error;
589  vnet_device_class_t *dev_class;
590 
591  if (template->sub.eth.flags.two_tags == 1
592  && template->sub.eth.flags.exact_match == 1
593  && (template->sub.eth.flags.inner_vlan_id_any == 1
594  || template->sub.eth.flags.outer_vlan_id_any == 1))
595  {
596  error = clib_error_return (0,
597  "inner-dot1q any exact-match is unsupported");
598  return error;
599  }
600 
601  hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index);
602  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
603 
604  if (template->type == VNET_SW_INTERFACE_TYPE_SUB &&
605  dev_class->subif_add_del_function)
606  {
607  error = dev_class->subif_add_del_function (vnm, hi->hw_if_index,
608  (struct vnet_sw_interface_t
609  *) template, 1);
610  if (error)
611  return error;
612  }
613 
614  *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template);
616  (vnm, *sw_if_index, template->flags,
618 
619  if (error)
620  {
621  /* undo the work done by vnet_create_sw_interface_no_callbacks() */
623  vnet_sw_interface_t *sw =
624  pool_elt_at_index (im->sw_interfaces, *sw_if_index);
625  pool_put (im->sw_interfaces, sw);
626  }
627 
628  return error;
629 }
630 
631 void
633 {
635  vnet_sw_interface_t *sw =
636  pool_elt_at_index (im->sw_interfaces, sw_if_index);
637 
638  /* Check if the interface has config and is removed from L2 BD or XConnect */
640  l2_input_config_t *config;
641  if (sw_if_index < vec_len (l2input_main.configs))
642  {
643  config = vec_elt_at_index (l2input_main.configs, sw_if_index);
644  if (config->xconnect)
645  set_int_l2_mode (vm, vnm, MODE_L3, config->output_sw_if_index, 0,
646  L2_BD_PORT_TYPE_NORMAL, 0, 0);
647  if (config->xconnect || config->bridge)
648  set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0,
649  L2_BD_PORT_TYPE_NORMAL, 0, 0);
650  }
651  vnet_clear_sw_interface_tag (vnm, sw_if_index);
652 
653  /* Bring down interface in case it is up. */
654  if (sw->flags != 0)
655  vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0);
656 
657  call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0);
658 
659  pool_put (im->sw_interfaces, sw);
660 }
661 
662 static clib_error_t *
664 {
666  (vnm, sw_if_index, 0, vnm->sw_interface_mtu_change_functions);
667 }
668 
669 void
671 {
672  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
673 
674  if (si->mtu[VNET_MTU_L3] != mtu)
675  {
676  si->mtu[VNET_MTU_L3] = mtu;
677  call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
678  }
679 }
680 
681 void
683  u32 mtu[])
684 {
685  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
686  bool changed = false;
687  int i;
688 
689  for (i = 0; i < VNET_N_MTU; i++)
690  {
691  if (si->mtu[i] != mtu[i])
692  {
693  si->mtu[i] = mtu[i];
694  changed = true;
695  }
696  }
697  /* Notify interested parties */
698  if (changed)
699  call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
700 }
701 
702 void
704  u32 sw_if_index, u8 enable)
705 {
707 
708  si = vnet_get_sw_interface (vnm, sw_if_index);
709 
710  if (enable)
712  else
714 
715  ip4_directed_broadcast (sw_if_index, enable);
716 }
717 
718 /*
719  * Reflect a change in hardware MTU on protocol MTUs
720  */
721 static walk_rc_t
723 {
724  u32 *link_mtu = ctx;
725  vnet_sw_interface_set_mtu (vnm, sw_if_index, *link_mtu);
726  return WALK_CONTINUE;
727 }
728 
729 void
730 vnet_hw_interface_set_mtu (vnet_main_t * vnm, u32 hw_if_index, u32 mtu)
731 {
732  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
733 
734  if (hi->max_packet_bytes != mtu)
735  {
736  hi->max_packet_bytes = mtu;
739  &mtu);
740  }
741 }
742 
743 static void
745  u32 node_index, vnet_device_class_t * dev_class)
746 {
747  vlib_node_t *n = vlib_get_node (vm, node_index);
748 
749  n->function = dev_class->tx_function;
750  n->format_trace = dev_class->format_tx_trace;
751 
752  vlib_register_errors (vm, node_index,
753  dev_class->tx_function_n_errors,
754  dev_class->tx_function_error_strings);
755 }
756 
757 static void
759  u32 node_index, vnet_hw_interface_class_t * hw_class)
760 {
761  vlib_node_t *n = vlib_get_node (vm, node_index);
762  n->format_buffer = hw_class->format_header;
763  n->unformat_buffer = hw_class->unformat_header;
764 }
765 
766 /* Register an interface instance. */
767 u32
769  u32 dev_class_index,
770  u32 dev_instance,
771  u32 hw_class_index, u32 hw_instance)
772 {
775  vnet_device_class_t *dev_class =
776  vnet_get_device_class (vnm, dev_class_index);
777  vnet_hw_interface_class_t *hw_class =
778  vnet_get_hw_interface_class (vnm, hw_class_index);
779  vlib_main_t *vm = vnm->vlib_main;
782  u32 hw_index, i;
783  char *tx_node_name = NULL, *output_node_name = NULL;
784 
785  pool_get (im->hw_interfaces, hw);
786  clib_memset (hw, 0, sizeof (*hw));
788 
789  hw_index = hw - im->hw_interfaces;
790  hw->hw_if_index = hw_index;
792 
793  if (dev_class->format_device_name)
794  hw->name = format (0, "%U", dev_class->format_device_name, dev_instance);
795  else if (hw_class->format_interface_name)
796  hw->name = format (0, "%U", hw_class->format_interface_name,
797  dev_instance);
798  else
799  hw->name = format (0, "%s%x", hw_class->name, dev_instance);
800 
801  if (!im->hw_interface_by_name)
802  im->hw_interface_by_name = hash_create_vec ( /* size */ 0,
803  sizeof (hw->name[0]),
804  sizeof (uword));
805 
806  hash_set_mem (im->hw_interface_by_name, hw->name, hw_index);
807 
808  /* Make hardware interface point to software interface. */
809  {
810  vnet_sw_interface_t sw = {
812  .flood_class = VNET_FLOOD_CLASS_NORMAL,
813  .hw_if_index = hw_index
814  };
816  }
817 
818  hw->dev_class_index = dev_class_index;
819  hw->dev_instance = dev_instance;
820  hw->hw_class_index = hw_class_index;
821  hw->hw_instance = hw_instance;
822 
823  hw->max_rate_bits_per_sec = 0;
824  hw->min_packet_bytes = 0;
826 
827  if (dev_class->tx_function == 0)
828  goto no_output_nodes; /* No output/tx nodes to create */
829 
830  tx_node_name = (char *) format (0, "%v-tx", hw->name);
831  output_node_name = (char *) format (0, "%v-output", hw->name);
832 
833  /* If we have previously deleted interface nodes, re-use them. */
834  if (vec_len (im->deleted_hw_interface_nodes) > 0)
835  {
837  vlib_node_t *node;
838  vlib_node_runtime_t *nrt;
839 
840  hn = vec_end (im->deleted_hw_interface_nodes) - 1;
841 
842  hw->tx_node_index = hn->tx_node_index;
844 
845  vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name);
846  vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name);
847 
848  /* *INDENT-OFF* */
851 
852  rt = vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
853  ASSERT (rt->is_deleted == 1);
854  rt->is_deleted = 0;
855  rt->hw_if_index = hw_index;
856  rt->sw_if_index = hw->sw_if_index;
857  rt->dev_instance = hw->dev_instance;
858 
859  rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index);
860  rt->hw_if_index = hw_index;
861  rt->sw_if_index = hw->sw_if_index;
862  rt->dev_instance = hw->dev_instance;
863  });
864  /* *INDENT-ON* */
865 
866  /* The new class may differ from the old one.
867  * Functions have to be updated. */
868  node = vlib_get_node (vm, hw->output_node_index);
869  node->function = vnet_interface_output_node;
870  node->format_trace = format_vnet_interface_output_trace;
871  /* *INDENT-OFF* */
873  nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index);
874  nrt->function = node->function;
875  vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0,
877  });
878  /* *INDENT-ON* */
879 
880  node = vlib_get_node (vm, hw->tx_node_index);
881  node->function = dev_class->tx_function;
882  node->format_trace = dev_class->format_tx_trace;
883  /* *INDENT-OFF* */
885  nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index);
886  nrt->function = node->function;
887  vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0,
889  });
890  /* *INDENT-ON* */
891 
892  _vec_len (im->deleted_hw_interface_nodes) -= 1;
893  }
894  else
895  {
898  .hw_if_index = hw_index,
899  .sw_if_index = hw->sw_if_index,
900  .dev_instance = hw->dev_instance,
901  .is_deleted = 0,
902  };
903 
904  clib_memset (&r, 0, sizeof (r));
905  r.type = VLIB_NODE_TYPE_INTERNAL;
906  r.runtime_data = &rt;
907  r.runtime_data_bytes = sizeof (rt);
908  r.scalar_size = 0;
909  r.vector_size = sizeof (u32);
910 
911  r.flags = VLIB_NODE_FLAG_IS_OUTPUT;
912  r.name = tx_node_name;
913  r.function = dev_class->tx_function;
914 
915  hw->tx_node_index = vlib_register_node (vm, &r);
916 
918  "error-drop",
920 
921  r.flags = 0;
922  r.name = output_node_name;
923  r.function = vnet_interface_output_node;
924  r.format_trace = format_vnet_interface_output_trace;
925 
926  {
927  static char *e[] = {
928  "interface is down",
929  "interface is deleted",
930  "no buffers to segment GSO",
931  };
932 
933  r.n_errors = ARRAY_LEN (e);
934  r.error_strings = e;
935  }
936  hw->output_node_index = vlib_register_node (vm, &r);
937 
939  "error-drop",
942  hw->tx_node_index,
944 
945  /* add interface to the list of "output-interface" feature arc start nodes
946  and clone nexts from 1st interface if it exists */
948  cm = &fcm->config_main;
949  i = vec_len (cm->start_node_indices);
952  if (hw_index)
953  {
954  /* copy nexts from 1st interface */
955  vnet_hw_interface_t *first_hw;
956  vlib_node_t *first_node;
957 
958  first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0);
959  first_node = vlib_get_node (vm, first_hw->output_node_index);
960 
961  /* 1st 2 nexts are already added above */
962  for (i = 2; i < vec_len (first_node->next_nodes); i++)
964  first_node->next_nodes[i], i);
965  }
966  }
967 
968  setup_output_node (vm, hw->output_node_index, hw_class);
969  setup_tx_node (vm, hw->tx_node_index, dev_class);
970 
971 no_output_nodes:
972  /* Call all up/down callbacks with zero flags when interface is created. */
973  vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0,
975  vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0,
977  vec_free (tx_node_name);
978  vec_free (output_node_name);
979 
980  return hw_index;
981 }
982 
983 void
985 {
987  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
988  vlib_main_t *vm = vnm->vlib_main;
989  vnet_device_class_t *dev_class = vnet_get_device_class (vnm,
990  hw->dev_class_index);
991  /* If it is up, mark it down. */
992  if (hw->flags != 0)
993  vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0);
994 
995  /* Call delete callbacks. */
996  call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0);
997 
998  /* Delete any sub-interfaces. */
999  {
1000  u32 id, sw_if_index;
1001  /* *INDENT-OFF* */
1002  hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id,
1003  ({
1004  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
1005  u64 sup_and_sub_key =
1006  ((u64) (si->sup_sw_if_index) << 32) | (u64) si->sub.id;
1007  hash_unset_mem_free (&im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
1008  vnet_delete_sw_interface (vnm, sw_if_index);
1009  }));
1011  /* *INDENT-ON* */
1012  }
1013 
1014  /* Delete software interface corresponding to hardware interface. */
1016 
1017  if (dev_class->tx_function)
1018  {
1019  /* Put output/tx nodes into recycle pool */
1021 
1022  /* *INDENT-OFF* */
1024  ({
1026  vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
1027 
1028  /* Mark node runtime as deleted so output node (if called)
1029  * will drop packets. */
1030  rt->is_deleted = 1;
1031  });
1032  /* *INDENT-ON* */
1033 
1035  "interface-%d-output-deleted", hw_if_index);
1036  vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted",
1037  hw_if_index);
1038  vec_add2 (im->deleted_hw_interface_nodes, dn, 1);
1039  dn->tx_node_index = hw->tx_node_index;
1041  }
1042 
1044  vec_free (hw->name);
1045  vec_free (hw->hw_address);
1048 
1049  pool_put (im->hw_interfaces, hw);
1050 }
1051 
1052 void
1054  u32 hw_if_index,
1055  vnet_hw_sw_interface_walk_t fn, void *ctx)
1056 {
1058  u32 id, sw_if_index;
1059 
1060  hi = vnet_get_hw_interface (vnm, hw_if_index);
1061  /* the super first, then the sub interfaces */
1062  if (WALK_STOP == fn (vnm, hi->sw_if_index, ctx))
1063  return;
1064 
1065  /* *INDENT-OFF* */
1066  hash_foreach (id, sw_if_index,
1068  ({
1069  if (WALK_STOP == fn (vnm, sw_if_index, ctx))
1070  break;
1071  }));
1072  /* *INDENT-ON* */
1073 }
1074 
1075 void
1077  vnet_hw_interface_walk_t fn, void *ctx)
1078 {
1081 
1082  im = &vnm->interface_main;
1083 
1084  /* *INDENT-OFF* */
1085  pool_foreach (hi, im->hw_interfaces,
1086  ({
1087  if (WALK_STOP == fn(vnm, hi->hw_if_index, ctx))
1088  break;
1089  }));
1090  /* *INDENT-ON* */
1091 }
1092 
1093 void
1095  vnet_sw_interface_walk_t fn, void *ctx)
1096 {
1099 
1100  im = &vnm->interface_main;
1101 
1102  /* *INDENT-OFF* */
1103  pool_foreach (si, im->sw_interfaces,
1104  {
1105  if (WALK_STOP == fn (vnm, si, ctx))
1106  break;
1107  });
1108  /* *INDENT-ON* */
1109 }
1110 
1111 void
1113  u32 hw_class_index, u32 hw_instance)
1114 {
1115  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1117  vnet_get_hw_interface_class (vnm, hw_class_index);
1118 
1119  hi->hw_class_index = hw_class_index;
1120  hi->hw_instance = hw_instance;
1122 }
1123 
1124 static clib_error_t *
1126  u32 hw_class_index, u32 redistribute)
1127 {
1128  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1130  vnet_hw_interface_class_t *old_class =
1132  vnet_hw_interface_class_t *new_class =
1133  vnet_get_hw_interface_class (vnm, hw_class_index);
1134  vnet_device_class_t *dev_class =
1136  clib_error_t *error = 0;
1137 
1138  /* New class equals old class? Nothing to do. */
1139  if (hi->hw_class_index == hw_class_index)
1140  return 0;
1141 
1142  /* No need (and incorrect since admin up flag may be set) to do error checking when
1143  receiving unserialize message. */
1144  if (redistribute)
1145  {
1147  return clib_error_return (0,
1148  "%v must be admin down to change class from %s to %s",
1149  hi->name, old_class->name, new_class->name);
1150 
1151  /* Make sure interface supports given class. */
1152  if ((new_class->is_valid_class_for_interface
1153  && !new_class->is_valid_class_for_interface (vnm, hw_if_index,
1154  hw_class_index))
1155  || (dev_class->is_valid_class_for_interface
1156  && !dev_class->is_valid_class_for_interface (vnm, hw_if_index,
1157  hw_class_index)))
1158  return clib_error_return (0,
1159  "%v class cannot be changed from %s to %s",
1160  hi->name, old_class->name, new_class->name);
1161 
1162  }
1163 
1164  if (old_class->hw_class_change)
1165  old_class->hw_class_change (vnm, hw_if_index, old_class->index,
1166  new_class->index);
1167 
1168  vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index,
1169  /* instance */ ~0);
1170 
1171  if (new_class->hw_class_change)
1172  new_class->hw_class_change (vnm, hw_if_index, old_class->index,
1173  new_class->index);
1174 
1175  if (dev_class->hw_class_change)
1176  dev_class->hw_class_change (vnm, hw_if_index, new_class->index);
1177 
1178  return error;
1179 }
1180 
1181 clib_error_t *
1183  u32 hw_class_index)
1184 {
1185  return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index,
1186  /* redistribute */ 1);
1187 }
1188 
1189 static int
1191  u32 hw_if_index,
1192  u32 node_index,
1193  u32 redistribute)
1194 {
1195  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1197  (vnm, hi->dev_class_index);
1198 
1199  if (dev_class->rx_redirect_to_node)
1200  {
1201  dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index);
1202  return 0;
1203  }
1204 
1205  return VNET_API_ERROR_UNIMPLEMENTED;
1206 }
1207 
1208 int
1210  u32 node_index)
1211 {
1212  return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index,
1213  node_index,
1214  1 /* redistribute */ );
1215 }
1216 
1217 word
1219  uword sw_if_index0, uword sw_if_index1)
1220 {
1221  vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1222  vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1);
1225 
1226  if (h0 != h1)
1227  return vec_cmp (h0->name, h1->name);
1228  return (word) h0->hw_instance - (word) h1->hw_instance;
1229 }
1230 
1231 word
1233  uword hw_if_index0, uword hw_if_index1)
1234 {
1235  vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0);
1236  vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_if_index1);
1237 
1238  if (h0 != h1)
1239  return vec_cmp (h0->name, h1->name);
1240  return (word) h0->hw_instance - (word) h1->hw_instance;
1241 }
1242 
1243 int
1245 {
1246  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
1247  if ((si->type == VNET_SW_INTERFACE_TYPE_P2P) ||
1249  return 1;
1250 
1251  vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1254 
1255  return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P);
1256 }
1257 
1258 int
1260 {
1261  vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1264 
1265  return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_NBMA);
1266 }
1267 
1268 clib_error_t *
1270 {
1271  vnet_main_t *vnm = vnet_get_main ();
1273  vlib_buffer_t *b = 0;
1274  vnet_buffer_opaque_t *o = 0;
1275  clib_error_t *error;
1276 
1277  /*
1278  * Keep people from shooting themselves in the foot.
1279  */
1280  if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t))
1281  {
1282 #define _(a) if (sizeof(o->a) > sizeof (o->unused)) \
1283  clib_warning \
1284  ("FATAL: size of opaque union subtype %s is %d (max %d)", \
1285  #a, sizeof(o->a), sizeof (o->unused));
1287 #undef _
1288 
1289  return clib_error_return
1290  (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d",
1291  sizeof (b->opaque), sizeof (vnet_buffer_opaque_t));
1292  }
1293 
1295  clib_spinlock_lock (&im->sw_if_counter_lock); /* should be no need */
1296 
1298 #define _(E,n,p) \
1299  im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \
1300  im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1302 #undef _
1305 #define _(E,n,p) \
1306  im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \
1307  im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1309 #undef _
1311 
1312  im->device_class_by_name = hash_create_string ( /* size */ 0,
1313  sizeof (uword));
1314  {
1316 
1317  c = vnm->device_class_registrations;
1318 
1319  while (c)
1320  {
1321  c->index = vec_len (im->device_classes);
1322  hash_set_mem (im->device_class_by_name, c->name, c->index);
1323 
1324  if (c->tx_fn_registrations)
1325  {
1326  vlib_node_fn_registration_t *fnr = c->tx_fn_registrations;
1327  int priority = -1;
1328 
1329  /* to avoid confusion, please remove ".tx_function" statement
1330  from VNET_DEVICE_CLASS() if using function candidates */
1331  ASSERT (c->tx_function == 0);
1332 
1333  while (fnr)
1334  {
1335  if (fnr->priority > priority)
1336  {
1337  priority = fnr->priority;
1338  c->tx_function = fnr->function;
1339  }
1340  fnr = fnr->next_registration;
1341  }
1342  }
1343 
1344  vec_add1 (im->device_classes, c[0]);
1345  c = c->next_class_registration;
1346  }
1347  }
1348 
1349  im->hw_interface_class_by_name = hash_create_string ( /* size */ 0,
1350  sizeof (uword));
1351 
1352  im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64),
1353  sizeof (uword));
1354  {
1356 
1358 
1359  while (c)
1360  {
1361  c->index = vec_len (im->hw_interface_classes);
1362  hash_set_mem (im->hw_interface_class_by_name, c->name, c->index);
1363 
1364  if (NULL == c->build_rewrite)
1365  c->build_rewrite = default_build_rewrite;
1366  if (NULL == c->update_adjacency)
1367  c->update_adjacency = default_update_adjacency;
1368 
1369  vec_add1 (im->hw_interface_classes, c[0]);
1370  c = c->next_class_registration;
1371  }
1372  }
1373 
1374  /* init per-thread data */
1377 
1379  return error;
1380 
1381  vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword));
1382 
1383 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
1384  if ((error = vlib_call_init_function (vm, trajectory_trace_init)))
1385  return error;
1386 #endif
1387 
1388  return 0;
1389 }
1390 
1392 
1393 /* Kludge to renumber interface names [only!] */
1394 int
1396 {
1397  int rv;
1398  vnet_main_t *vnm = vnet_get_main ();
1400  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1401 
1403  (vnm, hi->dev_class_index);
1404 
1405  if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0)
1406  return VNET_API_ERROR_UNIMPLEMENTED;
1407 
1408  rv = dev_class->name_renumber (hi, new_show_dev_instance);
1409 
1410  if (rv)
1411  return rv;
1412 
1414  vec_free (hi->name);
1415  /* Use the mapping we set up to call it Ishmael */
1416  hi->name = format (0, "%U", dev_class->format_device_name,
1417  hi->dev_instance);
1418 
1420  return rv;
1421 }
1422 
1423 clib_error_t *
1424 vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name)
1425 {
1427  vlib_main_t *vm = vnm->vlib_main;
1428  vnet_hw_interface_t *hw;
1429  u8 *old_name;
1430  clib_error_t *error = 0;
1431 
1432  hw = vnet_get_hw_interface (vnm, hw_if_index);
1433  if (!hw)
1434  {
1435  return clib_error_return (0,
1436  "unable to find hw interface for index %u",
1437  hw_if_index);
1438  }
1439 
1440  old_name = hw->name;
1441 
1442  /* set new hw->name */
1443  hw->name = format (0, "%s", new_name);
1444 
1445  /* remove the old name to hw_if_index mapping and install the new one */
1446  hash_unset_mem (im->hw_interface_by_name, old_name);
1447  hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index);
1448 
1449  /* rename tx/output nodes */
1450  vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
1451  vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
1452 
1453  /* free the old name vector */
1454  vec_free (old_name);
1455 
1456  return error;
1457 }
1458 
1459 clib_error_t *
1461  u32 hw_if_index,
1462  const u8 * mac_address, u8 is_add)
1463 {
1464  clib_error_t *error = 0;
1465  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1466 
1467  vnet_device_class_t *dev_class =
1469 
1470  if (!hi->hw_address)
1471  {
1472  error =
1474  (0, "Secondary MAC Addresses not supported for interface index %u",
1475  hw_if_index);
1476  goto done;
1477  }
1478 
1479  if (dev_class->mac_addr_add_del_function)
1480  error = dev_class->mac_addr_add_del_function (hi, mac_address, is_add);
1481 
1482  if (!error)
1483  {
1484  vnet_hw_interface_class_t *hw_class;
1485 
1486  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1487 
1488  if (NULL != hw_class->mac_addr_add_del_function)
1489  error = hw_class->mac_addr_add_del_function (hi, mac_address, is_add);
1490  }
1491 
1492  /* If no errors, add to the list of secondary MACs on the ethernet intf */
1493  if (!error)
1495  mac_address, is_add);
1496 
1497 done:
1498  return error;
1499 }
1500 
1501 static clib_error_t *
1503  u32 hw_if_index,
1504  const u8 * mac_address)
1505 {
1506  clib_error_t *error = 0;
1507  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1508 
1509  if (hi->hw_address)
1510  {
1511  u8 *old_address = vec_dup (hi->hw_address);
1512  vnet_device_class_t *dev_class =
1514  if (dev_class->mac_addr_change_function)
1515  {
1516  error =
1517  dev_class->mac_addr_change_function (hi, old_address,
1518  mac_address);
1519  }
1520  if (!error)
1521  {
1522  vnet_hw_interface_class_t *hw_class;
1523 
1524  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1525 
1526  if (NULL != hw_class->mac_addr_change_function)
1527  hw_class->mac_addr_change_function (hi, old_address, mac_address);
1528  }
1529  else
1530  {
1531  error =
1532  clib_error_return (0,
1533  "MAC Address Change is not supported on this interface");
1534  }
1535  vec_free (old_address);
1536  }
1537  else
1538  {
1539  error =
1540  clib_error_return (0,
1541  "mac address change is not supported for interface index %u",
1542  hw_if_index);
1543  }
1544  return error;
1545 }
1546 
1547 clib_error_t *
1549  const u8 * mac_address)
1550 {
1552  (vnm, hw_if_index, mac_address);
1553 }
1554 
1555 /* update the unnumbered state of an interface*/
1556 void
1558  u32 ip_sw_if_index, u8 enable)
1559 {
1560  vnet_main_t *vnm = vnet_get_main ();
1562  u32 was_unnum;
1563 
1564  si = vnet_get_sw_interface (vnm, unnumbered_sw_if_index);
1565  was_unnum = (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED);
1566 
1567  if (enable)
1568  {
1570  si->unnumbered_sw_if_index = ip_sw_if_index;
1571 
1573  [unnumbered_sw_if_index] =
1574  ip4_main.
1575  lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1576  ip6_main.
1577  lookup_main.if_address_pool_index_by_sw_if_index
1578  [unnumbered_sw_if_index] =
1579  ip6_main.
1580  lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1581  }
1582  else
1583  {
1585  si->unnumbered_sw_if_index = (u32) ~ 0;
1586 
1588  [unnumbered_sw_if_index] = ~0;
1590  [unnumbered_sw_if_index] = ~0;
1591  }
1592 
1593  if (was_unnum != (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
1594  {
1595  ip4_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1596  ip6_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1597  }
1598 }
1599 
1602 {
1603  switch (link)
1604  {
1605  case VNET_LINK_IP4:
1606  return (VNET_L3_PACKET_TYPE_IP4);
1607  case VNET_LINK_IP6:
1608  return (VNET_L3_PACKET_TYPE_IP6);
1609  case VNET_LINK_MPLS:
1610  return (VNET_L3_PACKET_TYPE_MPLS);
1611  case VNET_LINK_ARP:
1612  return (VNET_L3_PACKET_TYPE_ARP);
1613  case VNET_LINK_ETHERNET:
1614  case VNET_LINK_NSH:
1615  ASSERT (0);
1616  break;
1617  }
1618  ASSERT (0);
1619  return (0);
1620 }
1621 
1622 vnet_mtu_t
1624 {
1625  switch (link)
1626  {
1627  case VNET_LINK_IP4:
1628  return (VNET_MTU_IP4);
1629  case VNET_LINK_IP6:
1630  return (VNET_MTU_IP6);
1631  case VNET_LINK_MPLS:
1632  return (VNET_MTU_MPLS);
1633  default:
1634  return (VNET_MTU_L3);
1635  }
1636 }
1637 
1638 u8 *
1640  u32 sw_if_index,
1641  vnet_link_t link_type, const void *dst_address)
1642 {
1643  return (NULL);
1644 }
1645 
1646 void
1648 {
1649  ip_adjacency_t *adj;
1650 
1651  adj = adj_get (ai);
1652 
1653  switch (adj->lookup_next_index)
1654  {
1655  case IP_LOOKUP_NEXT_GLEAN:
1657  break;
1658  case IP_LOOKUP_NEXT_ARP:
1659  case IP_LOOKUP_NEXT_BCAST:
1660  /*
1661  * default rewrite in neighbour adj
1662  */
1664  (ai,
1667  sw_if_index,
1668  adj_get_link_type (ai), NULL));
1669  break;
1670  case IP_LOOKUP_NEXT_MCAST:
1671  /*
1672  * mcast traffic also uses default rewrite string with no mcast
1673  * switch time updates.
1674  */
1676  (ai,
1678  sw_if_index,
1679  adj_get_link_type (ai),
1680  NULL), 0);
1681  break;
1682  case IP_LOOKUP_NEXT_DROP:
1683  case IP_LOOKUP_NEXT_PUNT:
1684  case IP_LOOKUP_NEXT_LOCAL:
1689  case IP_LOOKUP_N_NEXT:
1690  ASSERT (0);
1691  break;
1692  }
1693 }
1694 
1695 clib_error_t *
1698  clib_bitmap_t * bitmap)
1699 {
1700  clib_error_t *error = 0;
1701  vnet_device_class_t *dev_class =
1703 
1704  if (dev_class->set_rss_queues_function)
1705  {
1706  if (clib_bitmap_count_set_bits (bitmap) == 0)
1707  {
1708  error = clib_error_return (0,
1709  "must assign at least one valid rss queue");
1710  goto done;
1711  }
1712 
1713  error = dev_class->set_rss_queues_function (vnm, hi, bitmap);
1714  }
1715  else
1716  {
1717  error = clib_error_return (0,
1718  "setting rss queues is not supported on this interface");
1719  }
1720 
1721  if (!error)
1722  {
1724  hi->rss_queues = clib_bitmap_dup (bitmap);
1725  }
1726 
1727 done:
1728  return error;
1729 }
1730 
1732 
1733 void
1735 {
1737 }
1738 
1739 void
1741 {
1743 }
1744 
1745 static clib_error_t *
1747  unformat_input_t * input,
1748  vlib_cli_command_t * cmd)
1749 {
1750  unformat_input_t _line_input, *line_input = &_line_input;
1751  clib_error_t *error = NULL;
1752 
1753  /* Get a line of input. */
1754  if (!unformat_user (input, unformat_line_input, line_input))
1755  return clib_error_return (0, "expected enable | disable");
1756 
1757  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1758  {
1759  if (unformat (line_input, "enable") || unformat (line_input, "on"))
1761  else if (unformat (line_input, "disable")
1762  || unformat (line_input, "off"))
1764  else
1765  {
1766  error = clib_error_return (0, "unknown input `%U'",
1767  format_unformat_error, line_input);
1768  goto done;
1769  }
1770  }
1771 
1772 done:
1773  unformat_free (line_input);
1774  return error;
1775 }
1776 
1777 /* *INDENT-OFF* */
1778 VLIB_CLI_COMMAND (collect_detailed_interface_stats_command, static) = {
1779  .path = "interface collect detailed-stats",
1780  .short_help = "interface collect detailed-stats <enable|disable>",
1782 };
1783 /* *INDENT-ON* */
1784 
1785 /*
1786  * fd.io coding-style-patch-verification: ON
1787  *
1788  * Local Variables:
1789  * eval: (c-set-style "gnu")
1790  * End:
1791  */
u32 * next_nodes
Definition: node.h:334
vnet_config_main_t config_main
Definition: feature.h:82
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
void serialize_vnet_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:124
l2_input_config_t * configs
Definition: l2_input.h:62
static_always_inline void clib_spinlock_unlock(clib_spinlock_t *p)
Definition: lock.h:119
static_always_inline void clib_spinlock_lock(clib_spinlock_t *p)
Definition: lock.h:80
vnet_interface_per_thread_data_t * per_thread_data
Definition: interface.h:897
clib_spinlock_t sw_if_counter_lock
Definition: interface.h:879
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:1125
void vnet_sw_interface_ip_directed_broadcast(vnet_main_t *vnm, u32 sw_if_index, u8 enable)
Definition: interface.c:703
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:108
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:103
vnet_hw_interface_nodes_t * deleted_hw_interface_nodes
Definition: interface.h:883
_vnet_interface_function_list_elt_t * hw_interface_link_up_down_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:67
#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:46
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:59
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:1209
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:1053
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:507
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:235
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
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
Broadcast Adjacency.
Definition: adj.h:85
IP unicast adjacency.
Definition: adj.h:227
void vnet_sw_interface_admin_up(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:516
format_function_t * format_trace
Definition: node.h:361
vnet_device_class_t * device_class_registrations
Definition: vnet.h:62
u32 * input_node_thread_index_by_queue
Definition: interface.h:603
a non-broadcast multiple access interface
Definition: interface.h:390
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:592
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
Definition: interface.c:1218
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
Definition: interface.c:1395
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:630
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
#define hash_set_mem(h, key, value)
Definition: hash.h:275
ip_lookup_main_t lookup_main
Definition: ip4.h:108
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:585
vlib_main_t * vm
Definition: in2out_ed.c:1582
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
uword * interface_tag_by_sw_if_index
Definition: vnet.h:75
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:520
_vnet_interface_function_list_elt_t * hw_interface_add_del_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:65
u16 mask
Definition: flow_types.api:52
struct _vnet_device_class vnet_device_class_t
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:252
uword * dq_runtime_index_by_queue
Definition: interface.h:610
unsigned char u8
Definition: types.h:56
enum vnet_sw_interface_flags_t_ vnet_sw_interface_flags_t
#define VNET_HW_INTERFACE_FLAG_DUPLEX_MASK
Definition: interface.h:524
u8 id[64]
Definition: dhcp.api:160
#define clib_bitmap_dup(v)
Duplicate a bitmap.
Definition: bitmap.h:87
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:1746
vlib_node_function_t * function
Definition: node.h:260
void vlib_register_errors(vlib_main_t *vm, u32 node_index, u32 n_errors, char *error_strings[])
Definition: error.c:117
int vnet_sw_interface_is_nbma(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1259
static void unserialize_vec_vnet_sw_hw_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:97
Adjacency to punt this packet.
Definition: adj.h:55
enum walk_rc_t_ walk_rc_t
Walk return code.
void adj_glean_update_rewrite(adj_index_t adj_index)
adj_glean_update_rewrite
Definition: adj_glean.c:104
ethernet_main_t ethernet_main
Definition: init.c:45
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:459
void default_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Default adjacency update function.
Definition: interface.c:1647
enum vnet_interface_helper_flags_t_ vnet_interface_helper_flags_t
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:513
vlib_node_function_t * function
Node function to call.
Definition: node.h:467
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
static u32 vnet_create_sw_interface_no_callbacks(vnet_main_t *vnm, vnet_sw_interface_t *template)
Definition: interface.c:540
static clib_error_t * vnet_hw_interface_set_flags_helper(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_interface_flags_t flags, vnet_interface_helper_flags_t helper_flags)
Definition: interface.c:297
u32 output_sw_if_index
Definition: l2_input.h:36
static vnet_device_class_t * vnet_get_device_class(vnet_main_t *vnm, u32 dev_class_index)
static clib_error_t * vnet_hw_interface_change_mac_address_helper(vnet_main_t *vnm, u32 hw_if_index, const u8 *mac_address)
Definition: interface.c:1502
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:881
enum vnet_hw_interface_flags_t_ vnet_hw_interface_flags_t
vnet_hw_interface_flags_t flags
Definition: interface.h:537
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
#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:261
#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:722
uword vlib_node_add_next_with_slot(vlib_main_t *vm, uword node_index, uword next_node_index, uword slot)
Definition: node.c:172
struct _vlib_node_fn_registration vlib_node_fn_registration_t
u32 mtu[VNET_N_MTU]
Definition: interface.h:755
unsigned int u32
Definition: types.h:88
#define vec_end(v)
End (last data address) of vector.
uword vnet_interface_output_node(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
#define vlib_call_init_function(vm, x)
Definition: init.h:270
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:768
void ip4_directed_broadcast(u32 sw_if_index, u8 enable)
Definition: ip4_forward.c:882
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
i32 priority
Definition: ipsec.api:95
void vnet_sw_interface_set_protocol_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu[])
Definition: interface.c:682
unformat_function_t unformat_line_input
Definition: format.h:283
static void clib_spinlock_init(clib_spinlock_t *p)
Definition: lock.h:63
uword * hw_interface_by_name
Definition: interface.h:861
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
vnet_hw_interface_t * hw_interfaces
Definition: interface.h:858
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:661
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:105
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:534
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:285
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:640
u32 * start_node_indices
Definition: config.h:98
vlib_main_t * vlib_main
Definition: vnet.h:86
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:1094
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1244
long ctx[MAX_CONNS]
Definition: main.c:144
struct _unformat_input_t unformat_input_t
vnet_mtu_t
Definition: interface.h:693
#define hash_free(h)
Definition: hash.h:310
u32 vlib_register_node(vlib_main_t *vm, vlib_node_registration_t *r)
Definition: node.c:495
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:429
static void serialize_vec_vnet_sw_hw_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:82
uword * sw_if_index_by_sup_and_sub
Definition: interface.h:875
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:136
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
Definition: adj.h:68
vnet_sw_interface_flags_t flags
Definition: interface.h:738
ip6_main_t ip6_main
Definition: ip6_forward.c:2781
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:164
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:880
word vnet_hw_interface_compare(vnet_main_t *vnm, uword hw_if_index0, uword hw_if_index1)
Definition: interface.c:1232
format_function_t * format_buffer
Definition: node.h:357
void vnet_sw_interface_update_unnumbered(u32 unnumbered_sw_if_index, u32 ip_sw_if_index, u8 enable)
Definition: interface.c:1557
#define foreach_vlib_main(body)
Definition: threads.h:242
uword * hw_interface_class_by_name
Definition: interface.h:868
clib_error_t * vnet_hw_interface_set_rss_queues(vnet_main_t *vnm, vnet_hw_interface_t *hi, clib_bitmap_t *bitmap)
Definition: interface.c:1696
#define foreach_simple_interface_counter_name
Definition: interface.h:801
void unserialize_vnet_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:186
clib_error_t * vnet_rename_interface(vnet_main_t *vnm, u32 hw_if_index, char *new_name)
Definition: interface.c:1424
uword vlib_node_add_named_next_with_slot(vlib_main_t *vm, uword node, char *name, uword slot)
Definition: node.c:243
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
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
mac_address_t * ethernet_interface_add_del_address(ethernet_main_t *em, u32 hw_if_index, const u8 *address, u8 is_add)
Definition: interface.c:977
#define foreach_combined_interface_counter_name
Definition: interface.h:812
svmdb_client_t * c
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
Multicast Midchain Adjacency.
Definition: adj.h:89
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:115
static vnet_hw_interface_flags_t vnet_sw_interface_flags_to_hw(vnet_sw_interface_flags_t swf)
Definition: interface.c:175
unformat_function_t * unformat_buffer
Definition: node.h:358
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:911
#define ETHERNET_INTERFACE_FLAG_MTU
Definition: ethernet.h:155
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:289
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:1112
#define ARRAY_LEN(x)
Definition: clib.h:67
static void setup_output_node(vlib_main_t *vm, u32 node_index, vnet_hw_interface_class_t *hw_class)
Definition: interface.c:758
u32 trace_classify_table_index
Definition: interface.h:621
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 placeholder) rewrite.
Definition: interface.c:1639
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1582
format_function_t format_vnet_sw_interface_flags
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
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:155
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:904
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
Definition: counter.c:79
#define hash_create(elts, value_bytes)
Definition: hash.h:696
static void vlib_node_runtime_perf_counter(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, uword n, u64 t, vlib_node_runtime_perf_call_type_t call_type)
Definition: main.h:441
enum vnet_interface_function_priority_t_ vnet_interface_function_priority_t
#define ASSERT(truth)
_vnet_interface_function_list_elt_t * sw_interface_mtu_change_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:73
void collect_detailed_interface_stats_flag_clear(void)
Definition: interface.c:1740
ip_lookup_main_t lookup_main
Definition: ip6.h:181
static void setup_tx_node(vlib_main_t *vm, u32 node_index, vnet_device_class_t *dev_class)
Definition: interface.c:744
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
u32 set_int_l2_mode(vlib_main_t *vm, vnet_main_t *vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, l2_bd_port_type_t port_type, u32 shg, u32 xc_sw_if_index)
Set the subinterface to run in l2 or l3 mode.
Definition: l2_input.c:580
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
#define clib_bitmap_free(v)
Free a bitmap.
Definition: bitmap.h:92
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:139
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:991
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:869
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
vl_api_ip4_address_t hi
Definition: arp.api:37
void vnet_delete_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface.c:984
int collect_detailed_interface_stats_flag
Definition: interface.c:1731
static uword clib_bitmap_count_set_bits(uword *ai)
Return the number of set bits in a bitmap.
Definition: bitmap.h:462
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:730
clib_bitmap_t * rss_queues
Definition: interface.h:616
void vnet_sw_interface_admin_down(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:528
l2input_main_t l2input_main
Definition: l2_input.c:127
#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:1076
struct _vnet_hw_interface_class vnet_hw_interface_class_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
clib_error_t * vnet_interface_init(vlib_main_t *vm)
Definition: interface.c:1269
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:329
static clib_error_t * vnet_sw_interface_set_flags_helper(vnet_main_t *vnm, u32 sw_if_index, vnet_sw_interface_flags_t flags, vnet_interface_helper_flags_t helper_flags)
Definition: interface.c:346
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_interface_flags_t flags)
Definition: interface.c:498
vnet_l3_packet_type_t vnet_link_to_l3_proto(vnet_link_t link)
Convert a link to to an Ethertype.
Definition: interface.c:1601
static clib_error_t * vnet_interface_cli_init(vlib_main_t *vm)
VLIB buffer representation.
Definition: buffer.h:102
vnet_mtu_t vnet_link_to_mtu(vnet_link_t link)
Definition: interface.c:1623
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:163
void collect_detailed_interface_stats_flag_set(void)
Definition: interface.c:1734
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:1190
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:872
vnet_hw_interface_class_t * hw_interface_class_registrations
Definition: vnet.h:63
a point 2 point interface
Definition: interface.h:386
u32 ethernet_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:426
vnet_hw_interface_class_t * hw_interface_classes
Definition: interface.h:864
void vnet_sw_interface_set_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu)
Definition: interface.c:670
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:69
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static vnet_sw_interface_flags_t vnet_sw_interface_get_flags(vnet_main_t *vnm, u32 sw_if_index)
static vnet_sw_interface_flags_t vnet_hw_interface_flags_to_sw(vnet_hw_interface_flags_t hwf)
Definition: interface.c:113
vnet_sw_interface_type_t type
Definition: interface.h:736
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1144
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, vnet_sw_interface_flags_t flags)
Definition: interface.c:507
vnet_interface_helper_flags_t_
Definition: interface.c:47
static u32 vlib_num_workers()
Definition: threads.h:377
uword clib_bitmap_t
Definition: bitmap.h:50
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:85
#define VLIB_NODE_FLAG_IS_OUTPUT
Definition: node.h:295
#define vec_foreach(var, vec)
Vector iterator.
vnet_hw_interface_rx_mode default_rx_mode
Definition: interface.h:607
void vnet_delete_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:632
vnet_device_class_t * device_classes
Definition: interface.h:865
#define foreach_buffer_opaque_union_subtype
Definition: buffer.h:110
clib_error_t * vnet_hw_interface_add_del_mac_address(vnet_main_t *vnm, u32 hw_if_index, const u8 *mac_address, u8 is_add)
Definition: interface.c:1460
clib_error_t * vnet_hw_interface_change_mac_address(vnet_main_t *vnm, u32 hw_if_index, const u8 *mac_address)
Definition: interface.c:1548
u8 si
Definition: lisp_types.api:47
_vnet_interface_function_list_elt_t * sw_interface_admin_up_down_functions[VNET_ITF_FUNC_N_PRIO]
Definition: vnet.h:71
clib_error_t * vnet_create_sw_interface(vnet_main_t *vnm, vnet_sw_interface_t *template, u32 *sw_if_index)
Definition: interface.c:584
manual_print typedef u8 mac_address[6]
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static_always_inline vnet_feature_config_main_t * vnet_feature_get_config_main(u16 arc)
Definition: feature.h:244
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:319
void vlib_node_rename(vlib_main_t *vm, u32 node_index, char *fmt,...)
Definition: node.c:75
static clib_error_t * call_sw_interface_mtu_change_callbacks(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:663
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:239
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:153
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:33
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
#define MODE_L3
Definition: l2_input.h:220
clib_error_t * vnet_hw_interface_set_class(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index)
Definition: interface.c:1182