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