FD.io VPP  v19.08-27-gf4dcae4
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  ASSERT (p != 0);
204  error = vnet_hw_interface_set_class_helper (vnm, hif->hw_if_index, p[0], /* redistribute */ 0);
205  if (error)
206  clib_error_report (error);
207  vec_free (class_name);
208  }));
209  /* *INDENT-ON* */
210  }
211 
213  vec_foreach (st, sts)
214  vnet_sw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags,
215  /* no distribute */ 0);
216  vec_free (sts);
217 
219  vec_foreach (st, sts)
220  {
222  (vnm, st->sw_hw_if_index, vnet_sw_interface_flags_to_hw (st->flags),
223  /* no distribute */ 0);
224  }
225  vec_free (sts);
226 }
227 
228 static clib_error_t *
230  u32 flags,
231  _vnet_interface_function_list_elt_t **
232  elts)
233 {
234  _vnet_interface_function_list_elt_t *elt;
236  clib_error_t *error = 0;
237 
238  for (prio = VNET_ITF_FUNC_PRIORITY_LOW;
239  prio <= VNET_ITF_FUNC_PRIORITY_HIGH; prio++)
240  {
241  elt = elts[prio];
242 
243  while (elt)
244  {
245  error = elt->fp (vnm, if_index, flags);
246  if (error)
247  return error;
248  elt = elt->next_interface_function;
249  }
250  }
251  return error;
252 }
253 
254 static clib_error_t *
256  u32 is_create)
257 {
258  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
259  vnet_hw_interface_class_t *hw_class =
261  vnet_device_class_t *dev_class =
263  clib_error_t *error = 0;
264 
265  if (hw_class->interface_add_del_function
266  && (error =
267  hw_class->interface_add_del_function (vnm, hw_if_index, is_create)))
268  return error;
269 
270  if (dev_class->interface_add_del_function
271  && (error =
272  dev_class->interface_add_del_function (vnm, hw_if_index,
273  is_create)))
274  return error;
275 
277  (vnm, hw_if_index, is_create, vnm->hw_interface_add_del_functions);
278 
279  return error;
280 }
281 
282 static clib_error_t *
284  u32 is_create)
285 {
287  (vnm, sw_if_index, is_create, vnm->sw_interface_add_del_functions);
288 }
289 
290 static clib_error_t *
294  helper_flags)
295 {
296  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
297  vnet_hw_interface_class_t *hw_class =
299  u32 mask;
300  clib_error_t *error = 0;
301  u32 is_create =
302  (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
303 
304  mask =
306  flags &= mask;
307 
308  /* Call hardware interface add/del callbacks. */
309  if (is_create)
310  call_hw_interface_add_del_callbacks (vnm, hw_if_index, is_create);
311 
312  /* Already in the desired state? */
313  if (!is_create && (hi->flags & mask) == flags)
314  goto done;
315 
318  {
319  /* Do hardware class (e.g. ethernet). */
320  if (hw_class->link_up_down_function
321  && (error = hw_class->link_up_down_function (vnm, hw_if_index,
322  flags)))
323  goto done;
324 
326  (vnm, hw_if_index, flags, vnm->hw_interface_link_up_down_functions);
327 
328  if (error)
329  goto done;
330  }
331 
332  hi->flags &= ~mask;
333  hi->flags |= flags;
334 
335 done:
336  return error;
337 }
338 
339 static clib_error_t *
343  helper_flags)
344 {
345  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
346  u32 mask;
347  clib_error_t *error = 0;
348  u32 is_create =
349  (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0;
350  u32 old_flags;
351 
353  flags &= mask;
354 
355  if (is_create)
356  {
357  error =
358  call_sw_interface_add_del_callbacks (vnm, sw_if_index, is_create);
359  if (error)
360  goto done;
361 
363  {
364  /* Notify everyone when the interface is created as admin up */
365  error = call_elf_section_interface_callbacks (vnm, sw_if_index,
366  flags,
367  vnm->
368  sw_interface_admin_up_down_functions);
369  if (error)
370  goto done;
371  }
372  }
373  else
374  {
375  vnet_sw_interface_t *si_sup = si;
376 
377  /* Check that super interface is in correct state. */
378  if (si->type == VNET_SW_INTERFACE_TYPE_SUB)
379  {
380  si_sup = vnet_get_sw_interface (vnm, si->sup_sw_if_index);
381 
382  /* Check to see if we're bringing down the soft interface and if it's parent is up */
383  if ((flags != (si_sup->flags & mask)) &&
384  (!((flags == 0)
385  && ((si_sup->flags & mask) ==
387  {
388  error = clib_error_return (0, "super-interface %U must be %U",
390  si_sup,
392  flags);
393  goto done;
394  }
395  }
396 
397  /* Do not change state for slave link of bonded interfaces */
399  {
400  error = clib_error_return
401  (0, "not allowed as %U belong to a BondEthernet interface",
403  goto done;
404  }
405 
406  /* Already in the desired state? */
407  if ((si->flags & mask) == flags)
408  goto done;
409 
410  /* Sub-interfaces of hardware interfaces that do no redistribute,
411  do not redistribute themselves. */
412  if (si_sup->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
413  {
415  vnet_get_hw_interface (vnm, si_sup->hw_if_index);
416  vnet_device_class_t *dev_class =
418  if (!dev_class->redistribute)
419  helper_flags &=
421  }
422 
423  /* set the flags now before invoking the registered clients
424  * so that the state they query is consistent with the state here notified */
425  old_flags = si->flags;
426  si->flags &= ~mask;
427  si->flags |= flags;
428  if ((flags | old_flags) & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
430  (vnm, sw_if_index, flags,
432 
433  if (error)
434  {
435  /* restore flags on error */
436  si->flags = old_flags;
437  goto done;
438  }
439 
441  {
444  vnet_hw_interface_class_t *hw_class =
446  vnet_device_class_t *dev_class =
448 
449  if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) &&
451  {
452  error = clib_error_return (0, "Interface in the error state");
453  goto done;
454  }
455 
456  /* save the si admin up flag */
457  old_flags = si->flags;
458 
459  /* update si admin up flag in advance if we are going admin down */
460  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
461  si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP;
462 
463  if (dev_class->admin_up_down_function
464  && (error = dev_class->admin_up_down_function (vnm,
465  si->hw_if_index,
466  flags)))
467  {
468  /* restore si admin up flag to it's original state on errors */
469  si->flags = old_flags;
470  goto done;
471  }
472 
473  if (hw_class->admin_up_down_function
474  && (error = hw_class->admin_up_down_function (vnm,
475  si->hw_if_index,
476  flags)))
477  {
478  /* restore si admin up flag to it's original state on errors */
479  si->flags = old_flags;
480  goto done;
481  }
482 
483  /* Admin down implies link down. */
484  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
487  hi->flags &
489  helper_flags);
490  }
491  }
492 
493  si->flags &= ~mask;
494  si->flags |= flags;
495 
496 done:
497  return error;
498 }
499 
500 clib_error_t *
503 {
505  (vnm, hw_if_index, flags,
507 }
508 
509 clib_error_t *
512 {
514  (vnm, sw_if_index, flags,
516 }
517 
518 void
520 {
521  u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
522 
523  if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
524  {
526  vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
527  }
528 }
529 
530 void
532 {
533  u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
534 
536  {
538  vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
539  }
540 }
541 
542 static u32
544  vnet_sw_interface_t * template)
545 {
549 
550  pool_get (im->sw_interfaces, sw);
551  sw_if_index = sw - im->sw_interfaces;
552 
553  sw[0] = template[0];
554 
555  sw->flags = 0;
556  sw->sw_if_index = sw_if_index;
558  sw->sup_sw_if_index = sw->sw_if_index;
559 
560  /* Allocate counters for this interface. */
561  {
562  u32 i;
563 
565 
566  for (i = 0; i < vec_len (im->sw_if_counters); i++)
567  {
568  vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index);
569  vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index);
570  }
571 
572  for (i = 0; i < vec_len (im->combined_sw_if_counters); i++)
573  {
575  sw_if_index);
577  sw_if_index);
578  }
579 
581  }
582 
583  return sw_if_index;
584 }
585 
586 clib_error_t *
588  u32 * sw_if_index)
589 {
590  clib_error_t *error;
592  vnet_device_class_t *dev_class;
593 
594  hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index);
595  dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
596 
597  if (template->type == VNET_SW_INTERFACE_TYPE_SUB &&
598  dev_class->subif_add_del_function)
599  {
600  error = dev_class->subif_add_del_function (vnm, hi->hw_if_index,
601  (struct vnet_sw_interface_t
602  *) template, 1);
603  if (error)
604  return error;
605  }
606 
607  *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template);
609  (vnm, *sw_if_index, template->flags,
611 
612  if (error)
613  {
614  /* undo the work done by vnet_create_sw_interface_no_callbacks() */
616  vnet_sw_interface_t *sw =
617  pool_elt_at_index (im->sw_interfaces, *sw_if_index);
618  pool_put (im->sw_interfaces, sw);
619  }
620 
621  return error;
622 }
623 
624 void
626 {
628  vnet_sw_interface_t *sw =
629  pool_elt_at_index (im->sw_interfaces, sw_if_index);
630 
631  /* Check if the interface has config and is removed from L2 BD or XConnect */
633  l2_input_config_t *config;
634  if (sw_if_index < vec_len (l2input_main.configs))
635  {
636  config = vec_elt_at_index (l2input_main.configs, sw_if_index);
637  if (config->xconnect)
638  set_int_l2_mode (vm, vnm, MODE_L3, config->output_sw_if_index, 0,
639  L2_BD_PORT_TYPE_NORMAL, 0, 0);
640  if (config->xconnect || config->bridge)
641  set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0,
642  L2_BD_PORT_TYPE_NORMAL, 0, 0);
643  }
644  vnet_clear_sw_interface_tag (vnm, sw_if_index);
645 
646  /* Bring down interface in case it is up. */
647  if (sw->flags != 0)
648  vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0);
649 
650  call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0);
651 
652  pool_put (im->sw_interfaces, sw);
653 }
654 
655 static clib_error_t *
657 {
659  (vnm, sw_if_index, 0, vnm->sw_interface_mtu_change_functions);
660 }
661 
662 void
664 {
665  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
666 
667  if (si->mtu[VNET_MTU_L3] != mtu)
668  {
669  si->mtu[VNET_MTU_L3] = mtu;
670  call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
671  }
672 }
673 
674 void
676  u32 mtu[])
677 {
678  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
679  bool changed = false;
680  int i;
681 
682  for (i = 0; i < VNET_N_MTU; i++)
683  {
684  if (si->mtu[i] != mtu[i])
685  {
686  si->mtu[i] = mtu[i];
687  changed = true;
688  }
689  }
690  /* Notify interested parties */
691  if (changed)
692  call_sw_interface_mtu_change_callbacks (vnm, sw_if_index);
693 }
694 
695 void
697  u32 sw_if_index, u8 enable)
698 {
700 
701  si = vnet_get_sw_interface (vnm, sw_if_index);
702 
703  if (enable)
705  else
707 
708  ip4_directed_broadcast (sw_if_index, enable);
709 }
710 
711 /*
712  * Reflect a change in hardware MTU on protocol MTUs
713  */
714 static walk_rc_t
716 {
717  u32 *link_mtu = ctx;
718  vnet_sw_interface_set_mtu (vnm, sw_if_index, *link_mtu);
719  return WALK_CONTINUE;
720 }
721 
722 void
723 vnet_hw_interface_set_mtu (vnet_main_t * vnm, u32 hw_if_index, u32 mtu)
724 {
725  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
726 
727  if (hi->max_packet_bytes != mtu)
728  {
729  hi->max_packet_bytes = mtu;
732  &mtu);
733  }
734 }
735 
736 static void
738  u32 node_index, vnet_device_class_t * dev_class)
739 {
740  vlib_node_t *n = vlib_get_node (vm, node_index);
741 
742  n->function = dev_class->tx_function;
743  n->format_trace = dev_class->format_tx_trace;
744 
745  vlib_register_errors (vm, node_index,
746  dev_class->tx_function_n_errors,
747  dev_class->tx_function_error_strings);
748 }
749 
750 static void
752  u32 node_index, vnet_hw_interface_class_t * hw_class)
753 {
754  vlib_node_t *n = vlib_get_node (vm, node_index);
755  n->format_buffer = hw_class->format_header;
756  n->unformat_buffer = hw_class->unformat_header;
757 }
758 
759 /* Register an interface instance. */
760 u32
762  u32 dev_class_index,
763  u32 dev_instance,
764  u32 hw_class_index, u32 hw_instance)
765 {
768  vnet_device_class_t *dev_class =
769  vnet_get_device_class (vnm, dev_class_index);
770  vnet_hw_interface_class_t *hw_class =
771  vnet_get_hw_interface_class (vnm, hw_class_index);
772  vlib_main_t *vm = vnm->vlib_main;
775  u32 hw_index, i;
776  char *tx_node_name = NULL, *output_node_name = NULL;
777 
778  pool_get (im->hw_interfaces, hw);
779  clib_memset (hw, 0, sizeof (*hw));
780 
781  hw_index = hw - im->hw_interfaces;
782  hw->hw_if_index = hw_index;
784 
785  if (dev_class->format_device_name)
786  hw->name = format (0, "%U", dev_class->format_device_name, dev_instance);
787  else if (hw_class->format_interface_name)
788  hw->name = format (0, "%U", hw_class->format_interface_name,
789  dev_instance);
790  else
791  hw->name = format (0, "%s%x", hw_class->name, dev_instance);
792 
793  if (!im->hw_interface_by_name)
794  im->hw_interface_by_name = hash_create_vec ( /* size */ 0,
795  sizeof (hw->name[0]),
796  sizeof (uword));
797 
798  hash_set_mem (im->hw_interface_by_name, hw->name, hw_index);
799 
800  /* Make hardware interface point to software interface. */
801  {
802  vnet_sw_interface_t sw = {
804  .flood_class = VNET_FLOOD_CLASS_NORMAL,
805  .hw_if_index = hw_index
806  };
808  }
809 
810  hw->dev_class_index = dev_class_index;
811  hw->dev_instance = dev_instance;
812  hw->hw_class_index = hw_class_index;
813  hw->hw_instance = hw_instance;
814 
815  hw->max_rate_bits_per_sec = 0;
816  hw->min_packet_bytes = 0;
818 
819  if (dev_class->tx_function == 0)
820  goto no_output_nodes; /* No output/tx nodes to create */
821 
822  tx_node_name = (char *) format (0, "%v-tx", hw->name);
823  output_node_name = (char *) format (0, "%v-output", hw->name);
824 
825  /* If we have previously deleted interface nodes, re-use them. */
826  if (vec_len (im->deleted_hw_interface_nodes) > 0)
827  {
829  vlib_node_t *node;
830  vlib_node_runtime_t *nrt;
831 
832  hn = vec_end (im->deleted_hw_interface_nodes) - 1;
833 
834  hw->tx_node_index = hn->tx_node_index;
836 
837  vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name);
838  vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name);
839 
840  /* *INDENT-OFF* */
843 
844  rt = vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
845  ASSERT (rt->is_deleted == 1);
846  rt->is_deleted = 0;
847  rt->hw_if_index = hw_index;
848  rt->sw_if_index = hw->sw_if_index;
849  rt->dev_instance = hw->dev_instance;
850 
851  rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index);
852  rt->hw_if_index = hw_index;
853  rt->sw_if_index = hw->sw_if_index;
854  rt->dev_instance = hw->dev_instance;
855  });
856  /* *INDENT-ON* */
857 
858  /* The new class may differ from the old one.
859  * Functions have to be updated. */
860  node = vlib_get_node (vm, hw->output_node_index);
861  node->function = vnet_interface_output_node;
862  node->format_trace = format_vnet_interface_output_trace;
863  /* *INDENT-OFF* */
865  nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index);
866  nrt->function = node->function;
867  });
868  /* *INDENT-ON* */
869 
870  node = vlib_get_node (vm, hw->tx_node_index);
871  node->function = dev_class->tx_function;
872  node->format_trace = dev_class->format_tx_trace;
873  /* *INDENT-OFF* */
875  nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index);
876  nrt->function = node->function;
877  });
878  /* *INDENT-ON* */
879 
880  _vec_len (im->deleted_hw_interface_nodes) -= 1;
881  }
882  else
883  {
886  .hw_if_index = hw_index,
887  .sw_if_index = hw->sw_if_index,
888  .dev_instance = hw->dev_instance,
889  .is_deleted = 0,
890  };
891 
892  clib_memset (&r, 0, sizeof (r));
893  r.type = VLIB_NODE_TYPE_INTERNAL;
894  r.runtime_data = &rt;
895  r.runtime_data_bytes = sizeof (rt);
896  r.scalar_size = 0;
897  r.vector_size = sizeof (u32);
898 
899  r.flags = VLIB_NODE_FLAG_IS_OUTPUT;
900  r.name = tx_node_name;
901  r.function = dev_class->tx_function;
902 
903  hw->tx_node_index = vlib_register_node (vm, &r);
904 
906  "error-drop",
908 
909  r.flags = 0;
910  r.name = output_node_name;
911  r.function = vnet_interface_output_node;
912  r.format_trace = format_vnet_interface_output_trace;
913 
914  {
915  static char *e[] = {
916  "interface is down",
917  "interface is deleted",
918  "no buffers to segment GSO",
919  };
920 
921  r.n_errors = ARRAY_LEN (e);
922  r.error_strings = e;
923  }
924  hw->output_node_index = vlib_register_node (vm, &r);
925 
927  "error-drop",
930  hw->tx_node_index,
932 
933  /* add interface to the list of "output-interface" feature arc start nodes
934  and clone nexts from 1st interface if it exists */
936  cm = &fcm->config_main;
937  i = vec_len (cm->start_node_indices);
940  if (hw_index)
941  {
942  /* copy nexts from 1st interface */
943  vnet_hw_interface_t *first_hw;
944  vlib_node_t *first_node;
945 
946  first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0);
947  first_node = vlib_get_node (vm, first_hw->output_node_index);
948 
949  /* 1st 2 nexts are already added above */
950  for (i = 2; i < vec_len (first_node->next_nodes); i++)
952  first_node->next_nodes[i], i);
953  }
954  }
955 
956  setup_output_node (vm, hw->output_node_index, hw_class);
957  setup_tx_node (vm, hw->tx_node_index, dev_class);
958 
959 no_output_nodes:
960  /* Call all up/down callbacks with zero flags when interface is created. */
961  vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0,
963  vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0,
965  vec_free (tx_node_name);
966  vec_free (output_node_name);
967 
968  return hw_index;
969 }
970 
971 void
973 {
975  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
976  vlib_main_t *vm = vnm->vlib_main;
977  vnet_device_class_t *dev_class = vnet_get_device_class (vnm,
978  hw->dev_class_index);
979  /* If it is up, mark it down. */
980  if (hw->flags != 0)
981  vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0);
982 
983  /* Call delete callbacks. */
984  call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0);
985 
986  /* Delete any sub-interfaces. */
987  {
988  u32 id, sw_if_index;
989  /* *INDENT-OFF* */
990  hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id,
991  ({
992  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
993  u64 sup_and_sub_key =
994  ((u64) (si->sup_sw_if_index) << 32) | (u64) si->sub.id;
995  hash_unset_mem_free (&im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
996  vnet_delete_sw_interface (vnm, sw_if_index);
997  }));
999  /* *INDENT-ON* */
1000  }
1001 
1002  /* Delete software interface corresponding to hardware interface. */
1004 
1005  if (dev_class->tx_function)
1006  {
1007  /* Put output/tx nodes into recycle pool */
1009 
1010  /* *INDENT-OFF* */
1012  ({
1014  vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index);
1015 
1016  /* Mark node runtime as deleted so output node (if called)
1017  * will drop packets. */
1018  rt->is_deleted = 1;
1019  });
1020  /* *INDENT-ON* */
1021 
1023  "interface-%d-output-deleted", hw_if_index);
1024  vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted",
1025  hw_if_index);
1026  vec_add2 (im->deleted_hw_interface_nodes, dn, 1);
1027  dn->tx_node_index = hw->tx_node_index;
1029  }
1030 
1032  vec_free (hw->name);
1033  vec_free (hw->hw_address);
1036 
1037  pool_put (im->hw_interfaces, hw);
1038 }
1039 
1040 void
1042  u32 hw_if_index,
1043  vnet_hw_sw_interface_walk_t fn, void *ctx)
1044 {
1046  u32 id, sw_if_index;
1047 
1048  hi = vnet_get_hw_interface (vnm, hw_if_index);
1049  /* the super first, then the sub interfaces */
1050  if (WALK_STOP == fn (vnm, hi->sw_if_index, ctx))
1051  return;
1052 
1053  /* *INDENT-OFF* */
1054  hash_foreach (id, sw_if_index,
1056  ({
1057  if (WALK_STOP == fn (vnm, sw_if_index, ctx))
1058  break;
1059  }));
1060  /* *INDENT-ON* */
1061 }
1062 
1063 void
1065  vnet_hw_interface_walk_t fn, void *ctx)
1066 {
1069 
1070  im = &vnm->interface_main;
1071 
1072  /* *INDENT-OFF* */
1073  pool_foreach (hi, im->hw_interfaces,
1074  ({
1075  if (WALK_STOP == fn(vnm, hi->hw_if_index, ctx))
1076  break;
1077  }));
1078  /* *INDENT-ON* */
1079 }
1080 
1081 void
1083  vnet_sw_interface_walk_t fn, void *ctx)
1084 {
1086  vnet_sw_interface_t *si;
1087 
1088  im = &vnm->interface_main;
1089 
1090  /* *INDENT-OFF* */
1091  pool_foreach (si, im->sw_interfaces,
1092  {
1093  if (WALK_STOP == fn (vnm, si, ctx))
1094  break;
1095  });
1096  /* *INDENT-ON* */
1097 }
1098 
1099 void
1101  u32 hw_class_index, u32 hw_instance)
1102 {
1103  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1105  vnet_get_hw_interface_class (vnm, hw_class_index);
1106 
1107  hi->hw_class_index = hw_class_index;
1108  hi->hw_instance = hw_instance;
1110 }
1111 
1112 static clib_error_t *
1114  u32 hw_class_index, u32 redistribute)
1115 {
1116  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1118  vnet_hw_interface_class_t *old_class =
1120  vnet_hw_interface_class_t *new_class =
1121  vnet_get_hw_interface_class (vnm, hw_class_index);
1122  vnet_device_class_t *dev_class =
1124  clib_error_t *error = 0;
1125 
1126  /* New class equals old class? Nothing to do. */
1127  if (hi->hw_class_index == hw_class_index)
1128  return 0;
1129 
1130  /* No need (and incorrect since admin up flag may be set) to do error checking when
1131  receiving unserialize message. */
1132  if (redistribute)
1133  {
1135  return clib_error_return (0,
1136  "%v must be admin down to change class from %s to %s",
1137  hi->name, old_class->name, new_class->name);
1138 
1139  /* Make sure interface supports given class. */
1140  if ((new_class->is_valid_class_for_interface
1141  && !new_class->is_valid_class_for_interface (vnm, hw_if_index,
1142  hw_class_index))
1143  || (dev_class->is_valid_class_for_interface
1144  && !dev_class->is_valid_class_for_interface (vnm, hw_if_index,
1145  hw_class_index)))
1146  return clib_error_return (0,
1147  "%v class cannot be changed from %s to %s",
1148  hi->name, old_class->name, new_class->name);
1149 
1150  }
1151 
1152  if (old_class->hw_class_change)
1153  old_class->hw_class_change (vnm, hw_if_index, old_class->index,
1154  new_class->index);
1155 
1156  vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index,
1157  /* instance */ ~0);
1158 
1159  if (new_class->hw_class_change)
1160  new_class->hw_class_change (vnm, hw_if_index, old_class->index,
1161  new_class->index);
1162 
1163  if (dev_class->hw_class_change)
1164  dev_class->hw_class_change (vnm, hw_if_index, new_class->index);
1165 
1166  return error;
1167 }
1168 
1169 clib_error_t *
1171  u32 hw_class_index)
1172 {
1173  return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index,
1174  /* redistribute */ 1);
1175 }
1176 
1177 static int
1179  u32 hw_if_index,
1180  u32 node_index,
1181  u32 redistribute)
1182 {
1183  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1185  (vnm, hi->dev_class_index);
1186 
1187  if (dev_class->rx_redirect_to_node)
1188  {
1189  dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index);
1190  return 0;
1191  }
1192 
1193  return VNET_API_ERROR_UNIMPLEMENTED;
1194 }
1195 
1196 int
1198  u32 node_index)
1199 {
1200  return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index,
1201  node_index,
1202  1 /* redistribute */ );
1203 }
1204 
1205 word
1207  uword sw_if_index0, uword sw_if_index1)
1208 {
1209  vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1210  vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1);
1213 
1214  if (h0 != h1)
1215  return vec_cmp (h0->name, h1->name);
1216  return (word) h0->hw_instance - (word) h1->hw_instance;
1217 }
1218 
1219 word
1221  uword hw_if_index0, uword hw_if_index1)
1222 {
1223  vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0);
1224  vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_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 int
1233 {
1234  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
1235  if ((si->type == VNET_SW_INTERFACE_TYPE_P2P) ||
1237  return 1;
1238 
1239  vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
1242 
1243  return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P);
1244 }
1245 
1246 clib_error_t *
1248 {
1249  vnet_main_t *vnm = vnet_get_main ();
1251  vlib_buffer_t *b = 0;
1252  vnet_buffer_opaque_t *o = 0;
1253  clib_error_t *error;
1254 
1255  /*
1256  * Keep people from shooting themselves in the foot.
1257  */
1258  if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t))
1259  {
1260 #define _(a) if (sizeof(o->a) > sizeof (o->unused)) \
1261  clib_warning \
1262  ("FATAL: size of opaque union subtype %s is %d (max %d)", \
1263  #a, sizeof(o->a), sizeof (o->unused));
1265 #undef _
1266 
1267  return clib_error_return
1268  (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d",
1269  sizeof (b->opaque), sizeof (vnet_buffer_opaque_t));
1270  }
1271 
1273  clib_spinlock_lock (&im->sw_if_counter_lock); /* should be no need */
1274 
1276 #define _(E,n,p) \
1277  im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \
1278  im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1280 #undef _
1283 #define _(E,n,p) \
1284  im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \
1285  im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n;
1287 #undef _
1289 
1290  im->device_class_by_name = hash_create_string ( /* size */ 0,
1291  sizeof (uword));
1292  {
1294 
1295  c = vnm->device_class_registrations;
1296 
1297  while (c)
1298  {
1299  c->index = vec_len (im->device_classes);
1300  hash_set_mem (im->device_class_by_name, c->name, c->index);
1301 
1302  if (c->tx_fn_registrations)
1303  {
1304  vlib_node_fn_registration_t *fnr = c->tx_fn_registrations;
1305  int priority = -1;
1306 
1307  /* to avoid confusion, please remove ".tx_function" statement
1308  from VNET_DEVICE_CLASS() if using function candidates */
1309  ASSERT (c->tx_function == 0);
1310 
1311  while (fnr)
1312  {
1313  if (fnr->priority > priority)
1314  {
1315  priority = fnr->priority;
1316  c->tx_function = fnr->function;
1317  }
1318  fnr = fnr->next_registration;
1319  }
1320  }
1321 
1322  vec_add1 (im->device_classes, c[0]);
1323  c = c->next_class_registration;
1324  }
1325  }
1326 
1327  im->hw_interface_class_by_name = hash_create_string ( /* size */ 0,
1328  sizeof (uword));
1329 
1330  im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64),
1331  sizeof (uword));
1332  {
1334 
1336 
1337  while (c)
1338  {
1339  c->index = vec_len (im->hw_interface_classes);
1340  hash_set_mem (im->hw_interface_class_by_name, c->name, c->index);
1341 
1342  if (NULL == c->build_rewrite)
1343  c->build_rewrite = default_build_rewrite;
1344  if (NULL == c->update_adjacency)
1345  c->update_adjacency = default_update_adjacency;
1346 
1347  vec_add1 (im->hw_interface_classes, c[0]);
1348  c = c->next_class_registration;
1349  }
1350  }
1351 
1352  im->gso_interface_count = 0;
1353  /* init per-thread data */
1356 
1358  return error;
1359 
1360  vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword));
1361 
1362 #if VLIB_BUFFER_TRACE_TRAJECTORY > 0
1363  if ((error = vlib_call_init_function (vm, trajectory_trace_init)))
1364  return error;
1365 #endif
1366 
1367  return 0;
1368 }
1369 
1371 
1372 /* Kludge to renumber interface names [only!] */
1373 int
1375 {
1376  int rv;
1377  vnet_main_t *vnm = vnet_get_main ();
1379  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
1380 
1382  (vnm, hi->dev_class_index);
1383 
1384  if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0)
1385  return VNET_API_ERROR_UNIMPLEMENTED;
1386 
1387  rv = dev_class->name_renumber (hi, new_show_dev_instance);
1388 
1389  if (rv)
1390  return rv;
1391 
1393  vec_free (hi->name);
1394  /* Use the mapping we set up to call it Ishmael */
1395  hi->name = format (0, "%U", dev_class->format_device_name,
1396  hi->dev_instance);
1397 
1399  return rv;
1400 }
1401 
1402 clib_error_t *
1403 vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name)
1404 {
1406  vlib_main_t *vm = vnm->vlib_main;
1407  vnet_hw_interface_t *hw;
1408  u8 *old_name;
1409  clib_error_t *error = 0;
1410 
1411  hw = vnet_get_hw_interface (vnm, hw_if_index);
1412  if (!hw)
1413  {
1414  return clib_error_return (0,
1415  "unable to find hw interface for index %u",
1416  hw_if_index);
1417  }
1418 
1419  old_name = hw->name;
1420 
1421  /* set new hw->name */
1422  hw->name = format (0, "%s", new_name);
1423 
1424  /* remove the old name to hw_if_index mapping and install the new one */
1425  hash_unset_mem (im->hw_interface_by_name, old_name);
1426  hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index);
1427 
1428  /* rename tx/output nodes */
1429  vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name);
1430  vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name);
1431 
1432  /* free the old name vector */
1433  vec_free (old_name);
1434 
1435  return error;
1436 }
1437 
1438 static clib_error_t *
1440  u32 hw_if_index,
1441  const u8 * mac_address)
1442 {
1443  clib_error_t *error = 0;
1444  vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
1445 
1446  if (hi->hw_address)
1447  {
1448  u8 *old_address = vec_dup (hi->hw_address);
1449  vnet_device_class_t *dev_class =
1451  if (dev_class->mac_addr_change_function)
1452  {
1453  error =
1454  dev_class->mac_addr_change_function (hi, old_address,
1455  mac_address);
1456  }
1457  if (!error)
1458  {
1459  vnet_hw_interface_class_t *hw_class;
1460 
1461  hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index);
1462 
1463  if (NULL != hw_class->mac_addr_change_function)
1464  hw_class->mac_addr_change_function (hi, old_address, mac_address);
1465  }
1466  else
1467  {
1468  error =
1469  clib_error_return (0,
1470  "MAC Address Change is not supported on this interface");
1471  }
1472  vec_free (old_address);
1473  }
1474  else
1475  {
1476  error =
1477  clib_error_return (0,
1478  "mac address change is not supported for interface index %u",
1479  hw_if_index);
1480  }
1481  return error;
1482 }
1483 
1484 clib_error_t *
1486  const u8 * mac_address)
1487 {
1489  (vnm, hw_if_index, mac_address);
1490 }
1491 
1492 /* update the unnumbered state of an interface*/
1493 void
1495  u32 ip_sw_if_index, u8 enable)
1496 {
1497  vnet_main_t *vnm = vnet_get_main ();
1498  vnet_sw_interface_t *si;
1499  u32 was_unnum;
1500 
1501  si = vnet_get_sw_interface (vnm, unnumbered_sw_if_index);
1502  was_unnum = (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED);
1503 
1504  if (enable)
1505  {
1507  si->unnumbered_sw_if_index = ip_sw_if_index;
1508 
1510  [unnumbered_sw_if_index] =
1511  ip4_main.
1512  lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1513  ip6_main.
1514  lookup_main.if_address_pool_index_by_sw_if_index
1515  [unnumbered_sw_if_index] =
1516  ip6_main.
1517  lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index];
1518  }
1519  else
1520  {
1522  si->unnumbered_sw_if_index = (u32) ~ 0;
1523 
1525  [unnumbered_sw_if_index] = ~0;
1527  [unnumbered_sw_if_index] = ~0;
1528  }
1529 
1530  if (was_unnum != (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
1531  {
1532  ip4_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1533  ip6_sw_interface_enable_disable (unnumbered_sw_if_index, enable);
1534  }
1535 }
1536 
1539 {
1540  switch (link)
1541  {
1542  case VNET_LINK_IP4:
1543  return (VNET_L3_PACKET_TYPE_IP4);
1544  case VNET_LINK_IP6:
1545  return (VNET_L3_PACKET_TYPE_IP6);
1546  case VNET_LINK_MPLS:
1547  return (VNET_L3_PACKET_TYPE_MPLS);
1548  case VNET_LINK_ARP:
1549  return (VNET_L3_PACKET_TYPE_ARP);
1550  case VNET_LINK_ETHERNET:
1551  case VNET_LINK_NSH:
1552  ASSERT (0);
1553  break;
1554  }
1555  ASSERT (0);
1556  return (0);
1557 }
1558 
1559 vnet_mtu_t
1561 {
1562  switch (link)
1563  {
1564  case VNET_LINK_IP4:
1565  return (VNET_MTU_IP4);
1566  case VNET_LINK_IP6:
1567  return (VNET_MTU_IP6);
1568  case VNET_LINK_MPLS:
1569  return (VNET_MTU_MPLS);
1570  default:
1571  return (VNET_MTU_L3);
1572  }
1573 }
1574 
1575 u8 *
1577  u32 sw_if_index,
1578  vnet_link_t link_type, const void *dst_address)
1579 {
1580  return (NULL);
1581 }
1582 
1583 void
1585 {
1586  ip_adjacency_t *adj;
1587 
1588  adj = adj_get (ai);
1589 
1590  switch (adj->lookup_next_index)
1591  {
1592  case IP_LOOKUP_NEXT_GLEAN:
1594  break;
1595  case IP_LOOKUP_NEXT_ARP:
1596  case IP_LOOKUP_NEXT_BCAST:
1597  /*
1598  * default rewrite in neighbour adj
1599  */
1601  (ai,
1604  sw_if_index,
1605  adj_get_link_type (ai), NULL));
1606  break;
1607  case IP_LOOKUP_NEXT_MCAST:
1608  /*
1609  * mcast traffic also uses default rewrite string with no mcast
1610  * switch time updates.
1611  */
1613  (ai,
1615  sw_if_index,
1616  adj_get_link_type (ai),
1617  NULL), 0);
1618  break;
1619  case IP_LOOKUP_NEXT_DROP:
1620  case IP_LOOKUP_NEXT_PUNT:
1621  case IP_LOOKUP_NEXT_LOCAL:
1626  case IP_LOOKUP_N_NEXT:
1627  ASSERT (0);
1628  break;
1629  }
1630 }
1631 
1633 
1634 void
1636 {
1638 }
1639 
1640 void
1642 {
1644 }
1645 
1646 static clib_error_t *
1648  unformat_input_t * input,
1649  vlib_cli_command_t * cmd)
1650 {
1651  unformat_input_t _line_input, *line_input = &_line_input;
1652  clib_error_t *error = NULL;
1653 
1654  /* Get a line of input. */
1655  if (!unformat_user (input, unformat_line_input, line_input))
1656  return clib_error_return (0, "expected enable | disable");
1657 
1658  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1659  {
1660  if (unformat (line_input, "enable") || unformat (line_input, "on"))
1662  else if (unformat (line_input, "disable")
1663  || unformat (line_input, "off"))
1665  else
1666  {
1667  error = clib_error_return (0, "unknown input `%U'",
1668  format_unformat_error, line_input);
1669  goto done;
1670  }
1671  }
1672 
1673 done:
1674  unformat_free (line_input);
1675  return error;
1676 }
1677 
1678 /* *INDENT-OFF* */
1679 VLIB_CLI_COMMAND (collect_detailed_interface_stats_command, static) = {
1680  .path = "interface collect detailed-stats",
1681  .short_help = "interface collect detailed-stats <enable|disable>",
1683 };
1684 /* *INDENT-ON* */
1685 
1686 /*
1687  * fd.io coding-style-patch-verification: ON
1688  *
1689  * Local Variables:
1690  * eval: (c-set-style "gnu")
1691  * End:
1692  */
u32 * next_nodes
Definition: node.h:333
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:439
void serialize_vnet_interface_state(serialize_main_t *m, va_list *va)
Definition: interface.c:124
vmrglw vmrglh hi
l2_input_config_t * configs
Definition: l2_input.h:61
u32 flags
Definition: vhost_user.h:141
static_always_inline void clib_spinlock_unlock(clib_spinlock_t *p)
Definition: lock.h:100
static_always_inline void clib_spinlock_lock(clib_spinlock_t *p)
Definition: lock.h:78
vnet_interface_per_thread_data_t * per_thread_data
Definition: interface.h:859
clib_spinlock_t sw_if_counter_lock
Definition: interface.h:840
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:1113
void vnet_sw_interface_ip_directed_broadcast(vnet_main_t *vnm, u32 sw_if_index, u8 enable)
Definition: interface.c:696
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:94
vnet_hw_interface_nodes_t * deleted_hw_interface_nodes
Definition: interface.h:844
_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: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:56
uword vlib_node_add_named_next_with_slot(vlib_main_t *vm, uword node, char *name, uword slot)
Definition: node.c:262
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:1197
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:1041
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:468
#define NULL
Definition: clib.h:58
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:229
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
Broadcasr Adjacency.
Definition: adj.h:85
IP unicast adjacency.
Definition: adj.h:221
void vnet_sw_interface_admin_up(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:519
format_function_t * format_trace
Definition: node.h:360
vnet_device_class_t * device_class_registrations
Definition: vnet.h:59
u32 * input_node_thread_index_by_queue
Definition: interface.h:570
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:522
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
Definition: interface.c:1206
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
Definition: interface.c:1374
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:560
int i
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
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
ip_lookup_main_t lookup_main
Definition: ip4.h:107
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:553
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
uword * interface_tag_by_sw_if_index
Definition: vnet.h:72
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:450
_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 pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:236
uword * dq_runtime_index_by_queue
Definition: interface.h:577
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:493
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:1647
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
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: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:433
void default_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Default adjacency update function.
Definition: interface.c:1584
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:493
vlib_node_function_t * function
Node function to call.
Definition: node.h:466
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
#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:543
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:291
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)
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:1439
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:842
enum vnet_hw_interface_flags_t_ vnet_hw_interface_flags_t
vnet_hw_interface_flags_t flags
Definition: interface.h:505
#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:255
#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:715
struct _vlib_node_fn_registration vlib_node_fn_registration_t
u32 mtu[VNET_N_MTU]
Definition: interface.h:716
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:761
void ip4_directed_broadcast(u32 sw_if_index, u8 enable)
Definition: ip4_forward.c:647
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
void vnet_sw_interface_set_protocol_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu[])
Definition: interface.c:675
unformat_function_t unformat_line_input
Definition: format.h:283
static void clib_spinlock_init(clib_spinlock_t *p)
Definition: lock.h:61
uword * hw_interface_by_name
Definition: interface.h:822
vnet_crypto_main_t * cm
Definition: quic_crypto.c:41
vnet_hw_interface_t * hw_interfaces
Definition: interface.h:819
#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:102
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
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:491
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:1082
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1232
long ctx[MAX_CONNS]
Definition: main.c:144
struct _unformat_input_t unformat_input_t
vnet_mtu_t
Definition: interface.h:654
#define hash_free(h)
Definition: hash.h:310
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:375
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:836
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
vnet_sw_interface_flags_t flags
Definition: interface.h:699
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:841
word vnet_hw_interface_compare(vnet_main_t *vnm, uword hw_if_index0, uword hw_if_index1)
Definition: interface.c:1220
format_function_t * format_buffer
Definition: node.h:356
void vnet_sw_interface_update_unnumbered(u32 unnumbered_sw_if_index, u32 ip_sw_if_index, u8 enable)
Definition: interface.c:1494
#define foreach_vlib_main(body)
Definition: threads.h:236
uword * hw_interface_class_by_name
Definition: interface.h:829
i32 priority
Definition: ipsec.api:92
#define foreach_simple_interface_counter_name
Definition: interface.h:762
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:1403
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
#define foreach_combined_interface_counter_name
Definition: interface.h:773
svmdb_client_t * c
vlib_main_t * vm
Definition: buffer.c:312
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
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:89
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:357
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:876
#define ETHERNET_INTERFACE_FLAG_MTU
Definition: ethernet.h:146
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:283
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:1100
#define ARRAY_LEN(x)
Definition: clib.h:62
static void setup_output_node(vlib_main_t *vm, u32 node_index, vnet_hw_interface_class_t *hw_class)
Definition: interface.c:751
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:1576
format_function_t format_vnet_sw_interface_flags
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
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:132
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:869
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
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:70
void collect_detailed_interface_stats_flag_clear(void)
Definition: interface.c:1641
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:2671
ip_lookup_main_t lookup_main
Definition: ip6.h:179
static void setup_tx_node(vlib_main_t *vm, u32 node_index, vnet_device_class_t *dev_class)
Definition: interface.c:737
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:520
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:591
static vnet_hw_interface_class_t * vnet_get_hw_interface_class(vnet_main_t *vnm, u32 hw_class_index)
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:919
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.
u8 mac_address[6]
uword * device_class_by_name
Definition: interface.h:830
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:972
int collect_detailed_interface_stats_flag
Definition: interface.c:1632
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:723
void vnet_sw_interface_admin_down(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:531
l2input_main_t l2input_main
Definition: l2_input.c:128
#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:1064
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:1247
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:236
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:340
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:501
vnet_l3_packet_type_t vnet_link_to_l3_proto(vnet_link_t link)
Convert a link to to an Ethertype.
Definition: interface.c:1538
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:1560
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:1635
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:1178
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:833
vnet_hw_interface_class_t * hw_interface_class_registrations
Definition: vnet.h:60
a point 2 point interface
Definition: interface.h:368
u32 ethernet_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:372
vnet_hw_interface_class_t * hw_interface_classes
Definition: interface.h:825
void vnet_sw_interface_set_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu)
Definition: interface.c:663
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
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:697
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:921
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:510
vnet_interface_helper_flags_t_
Definition: interface.c:47
static u32 vlib_num_workers()
Definition: threads.h:367
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:295
#define vec_foreach(var, vec)
Vector iterator.
vnet_hw_interface_rx_mode default_rx_mode
Definition: interface.h:574
void vnet_delete_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:625
vnet_device_class_t * device_classes
Definition: interface.h:826
#define foreach_buffer_opaque_union_subtype
Definition: buffer.h:110
u32 id
Definition: udp.api:45
clib_error_t * vnet_hw_interface_change_mac_address(vnet_main_t *vnm, u32 hw_if_index, const u8 *mac_address)
Definition: interface.c:1485
_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:587
#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:234
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:298
static clib_error_t * call_sw_interface_mtu_change_callbacks(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:656
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:146
u32 opaque[10]
Opaque data used by sub-graphs for their own purposes.
Definition: buffer.h:153
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:219
clib_error_t * vnet_hw_interface_set_class(vnet_main_t *vnm, u32 hw_if_index, u32 hw_class_index)
Definition: interface.c:1170