FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
interface_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * interface_api.c - vnet interface api
4  *
5  * Copyright (c) 2016 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <vnet/vnet.h>
21 #include <vlibmemory/api.h>
22 
23 #include <vnet/interface.h>
24 #include <vnet/api_errno.h>
25 #include <vnet/ethernet/ethernet.h>
26 #include <vnet/ip/ip.h>
27 #include <vnet/fib/fib_table.h>
28 #include <vnet/mfib/mfib_table.h>
29 #include <vnet/l2/l2_vtr.h>
30 #include <vnet/vnet_msg_enum.h>
31 #include <vnet/fib/fib_api.h>
32 #include <vnet/mfib/mfib_table.h>
33 
34 #include <vlibapi/api_types.h>
35 
36 #include <vnet/ip/ip_types_api.h>
38 
39 #define vl_typedefs /* define message structures */
40 #include <vnet/vnet_all_api_h.h>
41 #undef vl_typedefs
42 
43 #define vl_endianfun /* define message structures */
44 #include <vnet/vnet_all_api_h.h>
45 #undef vl_endianfun
46 
47 /* instantiate all the print functions we know about */
48 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
49 #define vl_printfun
50 #include <vnet/vnet_all_api_h.h>
51 #undef vl_printfun
52 
55 
56 #define foreach_vpe_api_msg \
57 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
58 _(HW_INTERFACE_SET_MTU, hw_interface_set_mtu) \
59 _(SW_INTERFACE_SET_MTU, sw_interface_set_mtu) \
60 _(WANT_INTERFACE_EVENTS, want_interface_events) \
61 _(SW_INTERFACE_DUMP, sw_interface_dump) \
62 _(SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address) \
63 _(SW_INTERFACE_SET_RX_MODE, sw_interface_set_rx_mode) \
64 _(SW_INTERFACE_RX_PLACEMENT_DUMP, sw_interface_rx_placement_dump) \
65 _(SW_INTERFACE_SET_RX_PLACEMENT, sw_interface_set_rx_placement) \
66 _(SW_INTERFACE_SET_TABLE, sw_interface_set_table) \
67 _(SW_INTERFACE_GET_TABLE, sw_interface_get_table) \
68 _(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered) \
69 _(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats) \
70 _(SW_INTERFACE_TAG_ADD_DEL, sw_interface_tag_add_del) \
71 _(SW_INTERFACE_ADD_DEL_MAC_ADDRESS, sw_interface_add_del_mac_address) \
72 _(SW_INTERFACE_SET_MAC_ADDRESS, sw_interface_set_mac_address) \
73 _(SW_INTERFACE_GET_MAC_ADDRESS, sw_interface_get_mac_address) \
74 _(CREATE_VLAN_SUBIF, create_vlan_subif) \
75 _(CREATE_SUBIF, create_subif) \
76 _(DELETE_SUBIF, delete_subif) \
77 _(CREATE_LOOPBACK, create_loopback) \
78 _(CREATE_LOOPBACK_INSTANCE, create_loopback_instance) \
79 _(DELETE_LOOPBACK, delete_loopback) \
80 _(INTERFACE_NAME_RENUMBER, interface_name_renumber) \
81 _(COLLECT_DETAILED_INTERFACE_STATS, collect_detailed_interface_stats) \
82 _(SW_INTERFACE_SET_IP_DIRECTED_BROADCAST, \
83  sw_interface_set_ip_directed_broadcast) \
84 _(SW_INTERFACE_ADDRESS_REPLACE_BEGIN, \
85  sw_interface_address_replace_begin) \
86 _(SW_INTERFACE_ADDRESS_REPLACE_END, \
87  sw_interface_address_replace_end)
88 
89 static void
91 {
92  vl_api_sw_interface_set_flags_reply_t *rmp;
93  vnet_main_t *vnm = vnet_get_main ();
94  int rv = 0;
95  clib_error_t *error;
96  u16 flags;
97 
99 
100  flags =
101  ((ntohl (mp->flags)) & IF_STATUS_API_FLAG_ADMIN_UP) ?
103 
104  error = vnet_sw_interface_set_flags (vnm, ntohl (mp->sw_if_index), flags);
105  if (error)
106  {
107  rv = -1;
108  clib_error_report (error);
109  }
110 
112  REPLY_MACRO (VL_API_SW_INTERFACE_SET_FLAGS_REPLY);
113 }
114 
115 static void
117 {
118  vl_api_hw_interface_set_mtu_reply_t *rmp;
119  vnet_main_t *vnm = vnet_get_main ();
120  u32 sw_if_index = ntohl (mp->sw_if_index);
121  u16 mtu = ntohs (mp->mtu);
123  int rv = 0;
124 
126 
127  vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index);
129  {
130  rv = VNET_API_ERROR_INVALID_VALUE;
131  goto bad_sw_if_index;
132  }
133 
136 
137  if (!eif)
138  {
139  rv = VNET_API_ERROR_FEATURE_DISABLED;
140  goto bad_sw_if_index;
141  }
142 
143  if (mtu < hi->min_supported_packet_bytes)
144  {
145  rv = VNET_API_ERROR_INVALID_VALUE;
146  goto bad_sw_if_index;
147  }
148 
149  if (mtu > hi->max_supported_packet_bytes)
150  {
151  rv = VNET_API_ERROR_INVALID_VALUE;
152  goto bad_sw_if_index;
153  }
154 
155  vnet_hw_interface_set_mtu (vnm, si->hw_if_index, mtu);
156 
158  REPLY_MACRO (VL_API_HW_INTERFACE_SET_MTU_REPLY);
159 }
160 
161 static void
163 {
164  vl_api_sw_interface_set_mtu_reply_t *rmp;
165  vnet_main_t *vnm = vnet_get_main ();
166  u32 sw_if_index = ntohl (mp->sw_if_index);
167  int rv = 0;
168  int i;
169  u32 per_protocol_mtu[VNET_N_MTU];
170 
172 
173  for (i = 0; i < VNET_N_MTU; i++)
174  {
175  per_protocol_mtu[i] = ntohl (mp->mtu[i]);
176  }
177  vnet_sw_interface_set_protocol_mtu (vnm, sw_if_index, per_protocol_mtu);
178 
180  REPLY_MACRO (VL_API_SW_INTERFACE_SET_MTU_REPLY);
181 }
182 
183 static void
186 {
187  vl_api_sw_interface_set_ip_directed_broadcast_reply_t *rmp;
188  u32 sw_if_index = ntohl (mp->sw_if_index);
189  int rv = 0;
190 
192 
194  sw_if_index, mp->enable);
195 
197  REPLY_MACRO (VL_API_SW_INTERFACE_SET_IP_DIRECTED_BROADCAST_REPLY);
198 }
199 
200 static void
203  vnet_sw_interface_t * swif,
204  u8 * interface_name, u32 context)
205 {
208  vnet_device_class_t *dev_class =
210 
211  vl_api_sw_interface_details_t *mp = vl_msg_api_alloc (sizeof (*mp));
212  clib_memset (mp, 0, sizeof (*mp));
213  mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_DETAILS);
214  mp->sw_if_index = ntohl (swif->sw_if_index);
215  mp->sup_sw_if_index = ntohl (swif->sup_sw_if_index);
216 
217  mp->flags |= (swif->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
221  mp->flags = ntohl (mp->flags);
222 
223  switch (swif->type)
224  {
226  mp->type = IF_API_TYPE_SUB;
227  break;
229  mp->type = IF_API_TYPE_P2P;
230  break;
232  mp->type = IF_API_TYPE_PIPE;
233  break;
234  default:
236  }
237  mp->type = ntohl (mp->type);
238 
241  mp->link_speed = ntohl (hi->link_speed);
242  mp->link_mtu = ntohs (hi->max_packet_bytes);
243  mp->mtu[VNET_MTU_L3] = ntohl (swif->mtu[VNET_MTU_L3]);
244  mp->mtu[VNET_MTU_IP4] = ntohl (swif->mtu[VNET_MTU_IP4]);
245  mp->mtu[VNET_MTU_IP6] = ntohl (swif->mtu[VNET_MTU_IP6]);
246  mp->mtu[VNET_MTU_MPLS] = ntohl (swif->mtu[VNET_MTU_MPLS]);
247 
248  mp->context = context;
249 
250  strncpy ((char *) mp->interface_name,
251  (char *) interface_name, ARRAY_LEN (mp->interface_name) - 1);
252 
253  if (dev_class && dev_class->name)
254  strncpy ((char *) mp->interface_dev_type, (char *) dev_class->name,
255  ARRAY_LEN (mp->interface_dev_type) - 1);
256 
257  /* Send the L2 address for ethernet physical intfcs */
258  if (swif->sup_sw_if_index == swif->sw_if_index
260  {
263 
264  ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
265  ASSERT (sizeof (mp->l2_address) >= sizeof (ei->address));
267  }
268  else if (swif->sup_sw_if_index != swif->sw_if_index)
269  {
270  vnet_sub_interface_t *sub = &swif->sub;
271  mp->sub_id = ntohl (sub->id);
272  mp->sub_number_of_tags =
273  sub->eth.flags.one_tag + sub->eth.flags.two_tags * 2;
274  mp->sub_outer_vlan_id = ntohs (sub->eth.outer_vlan_id);
275  mp->sub_inner_vlan_id = ntohs (sub->eth.inner_vlan_id);
276  mp->sub_if_flags =
277  ntohl (sub->eth.raw_flags & SUB_IF_API_FLAG_MASK_VNET);
278  }
279 
280  /* vlan tag rewrite data */
281  u32 vtr_op = L2_VTR_DISABLED;
282  u32 vtr_push_dot1q = 0, vtr_tag1 = 0, vtr_tag2 = 0;
283 
284  if (l2vtr_get (am->vlib_main, am->vnet_main, swif->sw_if_index,
285  &vtr_op, &vtr_push_dot1q, &vtr_tag1, &vtr_tag2) != 0)
286  {
287  // error - default to disabled
288  mp->vtr_op = ntohl (L2_VTR_DISABLED);
289  clib_warning ("cannot get vlan tag rewrite for sw_if_index %d",
290  swif->sw_if_index);
291  }
292  else
293  {
294  mp->vtr_op = ntohl (vtr_op);
295  mp->vtr_push_dot1q = ntohl (vtr_push_dot1q);
296  mp->vtr_tag1 = ntohl (vtr_tag1);
297  mp->vtr_tag2 = ntohl (vtr_tag2);
298  }
299 
300  /* pbb tag rewrite data */
301  ethernet_header_t eth_hdr;
302  u32 pbb_vtr_op = L2_VTR_DISABLED;
303  u16 outer_tag = 0;
304  u16 b_vlanid = 0;
305  u32 i_sid = 0;
306  clib_memset (&eth_hdr, 0, sizeof (eth_hdr));
307 
308  if (!l2pbb_get (am->vlib_main, am->vnet_main, swif->sw_if_index,
309  &pbb_vtr_op, &outer_tag, &eth_hdr, &b_vlanid, &i_sid))
310  {
311  mp->sub_if_flags |= ntohl (SUB_IF_API_FLAG_DOT1AH);
314  mp->b_vlanid = b_vlanid;
315  mp->i_sid = i_sid;
316  }
317 
319  if (tag)
320  strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
321 
322  vl_api_send_msg (rp, (u8 *) mp);
323 }
324 
325 static void
327 {
329  vnet_sw_interface_t *swif;
333 
335 
336  if (rp == 0)
337  {
338  clib_warning ("Client %d AWOL", mp->client_index);
339  return;
340  }
341 
342  u8 *filter = 0, *name = 0;
343  sw_if_index = ntohl (mp->sw_if_index);
344 
345  if (!mp->name_filter_valid && sw_if_index != ~0 && sw_if_index != 0)
346  {
347  /* is it a valid sw_if_index? */
348  if (!vnet_sw_if_index_is_api_valid (sw_if_index))
349  return;
350 
351  swif = vec_elt_at_index (im->sw_interfaces, sw_if_index);
352 
354  name =
356  swif, 0);
357  send_sw_interface_details (am, rp, swif, name, mp->context);
358  vec_free (name);
359  return;
360  }
361 
362  if (mp->name_filter_valid)
363  {
364  filter = vl_api_from_api_to_new_vec (mp, &mp->name_filter);
365  vec_add1 (filter, 0); /* Ensure it's a C string for strcasecmp() */
366  }
367 
368  char *strcasestr (char *, char *); /* lnx hdr file botch */
369  /* *INDENT-OFF* */
370  pool_foreach (swif, im->sw_interfaces,
371  ({
372  if (!vnet_swif_is_api_visible (swif))
373  continue;
374  vec_reset_length(name);
375  name = format (name, "%U%c", format_vnet_sw_interface_name, am->vnet_main,
376  swif, 0);
377 
378  if (filter && !strcasestr((char *) name, (char *) filter))
379  continue;
380 
381  send_sw_interface_details (am, rp, swif, name, mp->context);
382  }));
383  /* *INDENT-ON* */
384 
385  vec_free (name);
386  vec_free (filter);
387 }
388 
389 static void
392 {
393  vlib_main_t *vm = vlib_get_main ();
394  vnet_main_t *vnm = vnet_get_main ();
395  vl_api_sw_interface_add_del_address_reply_t *rmp;
396  int rv = 0;
397  u32 is_del;
398  clib_error_t *error = 0;
399  ip46_address_t address;
400 
402 
403  is_del = mp->is_add == 0;
404  vnm->api_errno = 0;
405 
406  if (mp->del_all)
408  else if (ip_address_decode (&mp->prefix.address, &address) == IP46_TYPE_IP6)
409  error = ip6_add_del_interface_address (vm, ntohl (mp->sw_if_index),
410  (void *) &address.ip6,
411  mp->prefix.len, is_del);
412  else
413  error = ip4_add_del_interface_address (vm, ntohl (mp->sw_if_index),
414  (void *) &address.ip4,
415  mp->prefix.len, is_del);
416 
417  if (error)
418  {
419  rv = vnm->api_errno;
420  clib_error_report (error);
421  goto done;
422  }
423 
425 
426 done:
427  REPLY_MACRO (VL_API_SW_INTERFACE_ADD_DEL_ADDRESS_REPLY);
428 }
429 
430 static void
432 {
433  vl_api_sw_interface_set_table_reply_t *rmp;
434  u32 sw_if_index = ntohl (mp->sw_if_index);
435  u32 table_id = ntohl (mp->vrf_id);
436  int rv = 0;
437 
439 
440  if (mp->is_ipv6)
441  rv = ip_table_bind (FIB_PROTOCOL_IP6, sw_if_index, table_id, 1);
442  else
443  rv = ip_table_bind (FIB_PROTOCOL_IP4, sw_if_index, table_id, 1);
444 
446 
447  REPLY_MACRO (VL_API_SW_INTERFACE_SET_TABLE_REPLY);
448 }
449 
450 int
452  u32 sw_if_index, u32 table_id, u8 is_api)
453 {
455  u32 fib_index, mfib_index;
457  mfib_source_t msrc;
458 
459  if (is_api)
460  {
461  src = FIB_SOURCE_API;
462  msrc = MFIB_SOURCE_API;
463  }
464  else
465  {
466  src = FIB_SOURCE_CLI;
467  msrc = MFIB_SOURCE_CLI;
468  }
469 
470  /*
471  * This if table does not exist = error is what we want in the end.
472  */
473  fib_index = fib_table_find (fproto, table_id);
474  mfib_index = mfib_table_find (fproto, table_id);
475 
476  if (~0 == fib_index || ~0 == mfib_index)
477  {
478  return (VNET_API_ERROR_NO_SUCH_FIB);
479  }
480 
481  if (FIB_PROTOCOL_IP6 == fproto)
482  {
483  /*
484  * If the interface already has in IP address, then a change int
485  * VRF is not allowed. The IP address applied must first be removed.
486  * We do not do that automatically here, since VPP has no knowledge
487  * of whether those subnets are valid in the destination VRF.
488  */
489  /* *INDENT-OFF* */
491  ia, sw_if_index,
492  1 /* honor unnumbered */ ,
493  ({
494  return (VNET_API_ERROR_ADDRESS_FOUND_FOR_INTERFACE);
495  }));
496  /* *INDENT-ON* */
497 
500 
501  /*
502  * tell those that are interested that the binding is changing.
503  */
506  cb->function (&ip6_main, cb->function_opaque,
507  sw_if_index,
508  fib_index,
509  ip6_main.fib_index_by_sw_if_index[sw_if_index]);
510 
511  if (0 == table_id)
512  {
513  /* reset back to default */
514  if (0 != ip6_main.fib_index_by_sw_if_index[sw_if_index])
516  FIB_PROTOCOL_IP6, src);
517  if (0 != ip6_main.mfib_index_by_sw_if_index[sw_if_index])
519  [sw_if_index], FIB_PROTOCOL_IP6, msrc);
520 
521  }
522  else
523  {
524  /* we need to lock the table now it's inuse */
525  fib_table_lock (fib_index, FIB_PROTOCOL_IP6, src);
526  mfib_table_lock (mfib_index, FIB_PROTOCOL_IP6, msrc);
527  }
528 
531  }
532  else
533  {
534  /*
535  * If the interface already has in IP address, then a change int
536  * VRF is not allowed. The IP address applied must first be removed.
537  * We do not do that automatically here, since VPP has no knowledge
538  * of whether those subnets are valid in the destination VRF.
539  */
540  /* *INDENT-OFF* */
542  ia, sw_if_index,
543  1 /* honor unnumbered */ ,
544  ({
545  return (VNET_API_ERROR_ADDRESS_FOUND_FOR_INTERFACE);
546  }));
547  /* *INDENT-ON* */
548 
551 
552  /*
553  * tell those that are interested that the binding is changing.
554  */
557  cb->function (&ip4_main, cb->function_opaque,
558  sw_if_index,
559  fib_index,
560  ip4_main.fib_index_by_sw_if_index[sw_if_index]);
561 
562  if (0 == table_id)
563  {
564  /* reset back to default */
565  if (0 != ip4_main.fib_index_by_sw_if_index[sw_if_index])
567  FIB_PROTOCOL_IP4, src);
568  if (0 != ip4_main.mfib_index_by_sw_if_index[sw_if_index])
570  [sw_if_index], FIB_PROTOCOL_IP4, msrc);
571 
572  }
573  else
574  {
575  /* we need to lock the table now it's inuse */
577  table_id, src);
578 
580  table_id, msrc);
581  }
582 
585  }
586 
587  return (0);
588 }
589 
590 static void
592  u32 context, int retval, u32 vrf_id)
593 {
595 
596  mp = vl_msg_api_alloc (sizeof (*mp));
597  clib_memset (mp, 0, sizeof (*mp));
598  mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_GET_TABLE_REPLY);
599  mp->context = context;
600  mp->retval = htonl (retval);
601  mp->vrf_id = htonl (vrf_id);
602 
603  vl_api_send_msg (reg, (u8 *) mp);
604 }
605 
606 static void
608 {
610  fib_table_t *fib_table = 0;
611  u32 sw_if_index = ~0;
612  u32 fib_index = ~0;
613  u32 table_id = ~0;
614  fib_protocol_t fib_proto = FIB_PROTOCOL_IP4;
615  int rv = 0;
616 
618  if (!reg)
619  return;
620 
622 
623  sw_if_index = ntohl (mp->sw_if_index);
624 
625  if (mp->is_ipv6)
626  fib_proto = FIB_PROTOCOL_IP6;
627 
628  fib_index = fib_table_get_index_for_sw_if_index (fib_proto, sw_if_index);
629  if (fib_index != ~0)
630  {
631  fib_table = fib_table_get (fib_index, fib_proto);
632  table_id = fib_table->ft_table_id;
633  }
634 
636 
637  send_sw_interface_get_table_reply (reg, mp->context, rv, table_id);
638 }
639 
642 {
643  vl_api_sw_interface_set_unnumbered_reply_t *rmp;
644  int rv = 0;
645  vnet_main_t *vnm = vnet_get_main ();
646  u32 sw_if_index = ntohl (mp->sw_if_index);
647  u32 unnumbered_sw_if_index = ntohl (mp->unnumbered_sw_if_index);
648 
649  /*
650  * The API message field names are backwards from
651  * the underlying data structure names.
652  * It's not worth changing them now.
653  */
654  if (!vnet_sw_interface_is_api_valid (vnm, unnumbered_sw_if_index))
655  {
656  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
657  goto done;
658  }
659 
660  /* Only check the "use loop0" field when setting the binding */
661  if (mp->is_add && !vnet_sw_interface_is_api_valid (vnm, sw_if_index))
662  {
663  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
664  goto done;
665  }
666 
667  vnet_sw_interface_update_unnumbered (unnumbered_sw_if_index,
668  sw_if_index, mp->is_add);
669 done:
670  REPLY_MACRO (VL_API_SW_INTERFACE_SET_UNNUMBERED_REPLY);
671 }
672 
673 static void
675  mp)
676 {
677  vl_api_sw_interface_clear_stats_reply_t *rmp;
678 
679  vnet_main_t *vnm = vnet_get_main ();
683  int j, n_counters;
684  int rv = 0;
685 
686  if (mp->sw_if_index != ~0)
688 
689  n_counters = vec_len (im->combined_sw_if_counters);
690 
691  for (j = 0; j < n_counters; j++)
692  {
693  im = &vnm->interface_main;
694  cm = im->combined_sw_if_counters + j;
695  if (mp->sw_if_index == (u32) ~ 0)
697  else
698  vlib_zero_combined_counter (cm, ntohl (mp->sw_if_index));
699  }
700 
701  n_counters = vec_len (im->sw_if_counters);
702 
703  for (j = 0; j < n_counters; j++)
704  {
705  im = &vnm->interface_main;
706  sm = im->sw_if_counters + j;
707  if (mp->sw_if_index == (u32) ~ 0)
709  else
710  vlib_zero_simple_counter (sm, ntohl (mp->sw_if_index));
711  }
712 
714 
715  REPLY_MACRO (VL_API_SW_INTERFACE_CLEAR_STATS_REPLY);
716 }
717 
718 /*
719  * Events used for sw_interface_events
720  */
722 {
729 };
730 
731 static void
734  vl_api_registration_t * vl_reg,
735  u32 sw_if_index, enum api_events events)
736 {
738 
739  mp = vl_msg_api_alloc (sizeof (*mp));
740  clib_memset (mp, 0, sizeof (*mp));
741  mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
742  mp->sw_if_index = ntohl (sw_if_index);
743  mp->client_index = reg->client_index;
744  mp->pid = reg->client_pid;
745  mp->flags = 0;
746  mp->flags |= (events & API_ADMIN_UP_EVENT) ?
748  mp->flags |= (events & API_LINK_STATE_UP_EVENT) ?
750  mp->flags = ntohl (mp->flags);
751  mp->deleted = events & API_SW_INTERFACE_DEL_EVENT ? true : false;
752  vl_api_send_msg (vl_reg, (u8 *) mp);
753 }
754 
755 static uword
758 {
760  uword *event_by_sw_if_index = 0;
762  int i;
763  vl_api_registration_t *vl_reg;
764  uword event_type;
765  uword *event_data = 0;
767 
768  vam->link_state_process_up = 1;
769 
770  while (1)
771  {
773 
774  /* Batch up events */
775  while ((event_type = vlib_process_get_events (vm, &event_data)) != ~0)
776  {
777  for (i = 0; i < vec_len (event_data); i++)
778  {
779  sw_if_index = event_data[i];
780  vec_validate_init_empty (event_by_sw_if_index, sw_if_index, 0);
781  event_by_sw_if_index[sw_if_index] |= event_type;
782  }
783  vec_reset_length (event_data);
784  }
785 
786  for (i = 0; i < vec_len (event_by_sw_if_index); i++)
787  {
788  if (event_by_sw_if_index[i] == 0)
789  continue;
790 
791  /* *INDENT-OFF* */
792  pool_foreach(reg, vam->interface_events_registrations,
793  ({
794  vl_reg = vl_api_client_index_to_registration (reg->client_index);
795  if (vl_reg)
796  send_sw_interface_event (vam, reg, vl_reg, i, event_by_sw_if_index[i]);
797  }));
798  /* *INDENT-ON* */
799  }
800  vec_reset_length (event_by_sw_if_index);
801  }
802 
803  return 0;
804 }
805 
806 static clib_error_t *link_up_down_function (vnet_main_t * vm, u32 hw_if_index,
807  u32 flags);
809  u32 hw_if_index, u32 flags);
811  u32 sw_if_index,
812  u32 flags);
813 
814 /* *INDENT-OFF* */
815 VLIB_REGISTER_NODE (link_state_process_node,static) = {
816  .function = link_state_process,
817  .type = VLIB_NODE_TYPE_PROCESS,
818  .name = "vpe-link-state-process",
819 };
820 /* *INDENT-ON* */
821 
822 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (admin_up_down_function);
823 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (link_up_down_function);
824 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (sw_interface_add_del_function);
825 
826 static clib_error_t *
827 link_up_down_function (vnet_main_t * vm, u32 hw_if_index, u32 flags)
828 {
830  vnet_hw_interface_t *hi = vnet_get_hw_interface (vm, hw_if_index);
831 
832  if (vam->link_state_process_up)
833  {
834  enum api_events event = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
838  link_state_process_node.index, event,
839  hi->sw_if_index);
840  }
841  return 0;
842 }
843 
844 static clib_error_t *
845 admin_up_down_function (vnet_main_t * vm, u32 sw_if_index, u32 flags)
846 {
848 
849  /*
850  * Note: it's perfectly fair to set a subif admin up / admin down.
851  * Note the subtle distinction between this routine and the previous
852  * routine.
853  */
854  if (vam->link_state_process_up)
855  {
856  enum api_events event = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
859  link_state_process_node.index, event,
860  sw_if_index);
861  }
862  return 0;
863 }
864 
865 static clib_error_t *
867 {
869 
870  if (vam->link_state_process_up)
871  {
872  enum api_events event =
875  link_state_process_node.index, event,
876  sw_if_index);
877  }
878  return 0;
879 }
880 
883 {
884  vnet_main_t *vnm = vnet_get_main ();
885  vl_api_sw_interface_tag_add_del_reply_t *rmp;
886  int rv = 0;
887  u8 *tag;
888  u32 sw_if_index = ntohl (mp->sw_if_index);
889 
891 
892  if (mp->is_add)
893  {
894  if (mp->tag[0] == 0)
895  {
896  rv = VNET_API_ERROR_INVALID_VALUE;
897  goto out;
898  }
899 
900  mp->tag[ARRAY_LEN (mp->tag) - 1] = 0;
901  tag = format (0, "%s%c", mp->tag, 0);
902  vnet_set_sw_interface_tag (vnm, tag, sw_if_index);
903  }
904  else
905  vnet_clear_sw_interface_tag (vnm, sw_if_index);
906 
908 out:
909  REPLY_MACRO (VL_API_SW_INTERFACE_TAG_ADD_DEL_REPLY);
910 }
911 
914 {
915  vl_api_sw_interface_add_del_mac_address_reply_t *rmp;
916  vnet_main_t *vnm = vnet_get_main ();
917  u32 sw_if_index = ntohl (mp->sw_if_index);
919  clib_error_t *error;
920  int rv = 0;
921 
923 
924  /* for subifs, the MAC should be changed on the actual hw if */
925  hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
927  mp->addr, mp->is_add);
928  if (error)
929  {
930  rv = VNET_API_ERROR_UNIMPLEMENTED;
931  clib_error_report (error);
932  goto out;
933  }
934 
936 out:
937  REPLY_MACRO (VL_API_SW_INTERFACE_ADD_DEL_MAC_ADDRESS_REPLY);
938 }
939 
942 {
943  vl_api_sw_interface_set_mac_address_reply_t *rmp;
944  vnet_main_t *vnm = vnet_get_main ();
945  u32 sw_if_index = ntohl (mp->sw_if_index);
947  clib_error_t *error;
948  int rv = 0;
950 
952 
953  si = vnet_get_sw_interface (vnm, sw_if_index);
954  mac_address_decode (mp->mac_address, &mac);
955  error =
957  if (error)
958  {
959  rv = VNET_API_ERROR_UNIMPLEMENTED;
960  clib_error_report (error);
961  goto out;
962  }
963 
965 out:
966  REPLY_MACRO (VL_API_SW_INTERFACE_SET_MAC_ADDRESS_REPLY);
967 }
968 
971 {
974  vnet_main_t *vnm = vnet_get_main ();
975  u32 sw_if_index = ntohl (mp->sw_if_index);
977  ethernet_interface_t *eth_if = 0;
978  int rv = 0;
979 
981 
982  si = vnet_get_sup_sw_interface (vnm, sw_if_index);
985 
987 
989  if (!reg)
990  return;
991  rmp = vl_msg_api_alloc (sizeof (*rmp));
992  rmp->_vl_msg_id = htons (VL_API_SW_INTERFACE_GET_MAC_ADDRESS_REPLY);
993  rmp->context = mp->context;
994  rmp->retval = htonl (rv);
995  if (!rv && eth_if)
997  vl_api_send_msg (reg, (u8 *) rmp);
998 }
999 
1002 {
1003  vl_api_sw_interface_set_rx_mode_reply_t *rmp;
1004  vnet_main_t *vnm = vnet_get_main ();
1005  u32 sw_if_index = ntohl (mp->sw_if_index);
1007  clib_error_t *error;
1008  int rv = 0;
1010 
1011  VALIDATE_SW_IF_INDEX (mp);
1012 
1013  si = vnet_get_sw_interface (vnm, sw_if_index);
1015  {
1016  rv = VNET_API_ERROR_INVALID_VALUE;
1017  goto bad_sw_if_index;
1018  }
1019 
1020  rx_mode = (vnet_hw_interface_rx_mode) ntohl (mp->mode);
1021  error = set_hw_interface_change_rx_mode (vnm, si->hw_if_index,
1022  mp->queue_id_valid,
1023  ntohl (mp->queue_id),
1025  rx_mode);
1026 
1027  if (error)
1028  {
1029  rv = VNET_API_ERROR_UNIMPLEMENTED;
1030  clib_error_report (error);
1031  goto out;
1032  }
1033 
1035 out:
1036  REPLY_MACRO (VL_API_SW_INTERFACE_SET_RX_MODE_REPLY);
1037 }
1038 
1039 static void
1041  vl_api_registration_t * rp,
1042  u32 sw_if_index, u32 worker_id,
1043  u32 queue_id, u8 mode, u32 context)
1044 {
1046  mp = vl_msg_api_alloc (sizeof (*mp));
1047  clib_memset (mp, 0, sizeof (*mp));
1048 
1049  mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_RX_PLACEMENT_DETAILS);
1050  mp->sw_if_index = htonl (sw_if_index);
1051  mp->queue_id = htonl (queue_id);
1052  mp->worker_id = htonl (worker_id);
1053  mp->mode = htonl (mode);
1054  mp->context = context;
1055 
1056  vl_api_send_msg (rp, (u8 *) mp);
1057 }
1058 
1061 {
1062  vnet_main_t *vnm = vnet_get_main ();
1064  u32 sw_if_index = ntohl (mp->sw_if_index);
1065  vl_api_registration_t *reg;
1066 
1068  if (!reg)
1069  return;
1070 
1071  if (sw_if_index == ~0)
1072  {
1076  (u8 *) "device-input");
1077  uword si;
1078  int index = 0;
1079 
1080  /* *INDENT-OFF* */
1081  foreach_vlib_main (({
1083  ({
1084  rt = vlib_node_get_runtime_data (this_vlib_main, si);
1085  vec_foreach (dq, rt->devices_and_queues)
1086  {
1087  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm,
1088  dq->hw_if_index);
1089  send_interface_rx_placement_details (am, reg, hw->sw_if_index, index,
1090  dq->queue_id, dq->mode, mp->context);
1091  }
1092  }));
1093  index++;
1094  }));
1095  /* *INDENT-ON* */
1096  }
1097  else
1098  {
1099  int i;
1101 
1102  if (!vnet_sw_if_index_is_api_valid (sw_if_index))
1103  {
1104  clib_warning ("sw_if_index %u does not exist", sw_if_index);
1105  goto bad_sw_if_index;
1106  }
1107 
1108  si = vnet_get_sw_interface (vnm, sw_if_index);
1110  {
1111  clib_warning ("interface type is not HARDWARE! P2P, PIPE and SUB"
1112  " interfaces are not supported");
1113  goto bad_sw_if_index;
1114  }
1115 
1117 
1118  for (i = 0; i < vec_len (hw->dq_runtime_index_by_queue); i++)
1119  {
1122  [i], i,
1123  hw->rx_mode_by_queue[i],
1124  mp->context);
1125  }
1126  }
1127 
1129 }
1130 
1133 {
1134  vl_api_sw_interface_set_rx_placement_reply_t *rmp;
1135  vnet_main_t *vnm = vnet_get_main ();
1136  u32 sw_if_index = ntohl (mp->sw_if_index);
1138  clib_error_t *error = 0;
1139  int rv = 0;
1140 
1141  VALIDATE_SW_IF_INDEX (mp);
1142 
1143  si = vnet_get_sw_interface (vnm, sw_if_index);
1145  {
1146  rv = VNET_API_ERROR_INVALID_VALUE;
1147  goto bad_sw_if_index;
1148  }
1149 
1151  ntohl (mp->queue_id),
1152  ntohl (mp->worker_id), mp->is_main);
1153  if (error)
1154  {
1155  rv = VNET_API_ERROR_UNIMPLEMENTED;
1156  clib_error_report (error);
1157  goto out;
1158  }
1159 
1161 out:
1162  REPLY_MACRO (VL_API_SW_INTERFACE_SET_RX_PLACEMENT_REPLY);
1163 }
1164 
1165 static void
1167 {
1169  vnet_main_t *vnm = vnet_get_main ();
1170  u32 sw_if_index = (u32) ~ 0;
1172  int rv = 0;
1173  u32 id;
1174  vnet_sw_interface_t template;
1175  uword *p;
1177  u64 sup_and_sub_key;
1178  vl_api_registration_t *reg;
1179  clib_error_t *error;
1180 
1181  VALIDATE_SW_IF_INDEX (mp);
1182 
1183  hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index));
1184 
1186  {
1187  rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED;
1188  goto out;
1189  }
1190 
1191  id = ntohl (mp->vlan_id);
1192  if (id == 0 || id > 4095)
1193  {
1194  rv = VNET_API_ERROR_INVALID_VLAN;
1195  goto out;
1196  }
1197 
1198  sup_and_sub_key = ((u64) (hi->sw_if_index) << 32) | (u64) id;
1199 
1200  p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
1201  if (p)
1202  {
1203  rv = VNET_API_ERROR_VLAN_ALREADY_EXISTS;
1204  goto out;
1205  }
1206 
1207  clib_memset (&template, 0, sizeof (template));
1208  template.type = VNET_SW_INTERFACE_TYPE_SUB;
1209  template.flood_class = VNET_FLOOD_CLASS_NORMAL;
1210  template.sup_sw_if_index = hi->sw_if_index;
1211  template.sub.id = id;
1212  template.sub.eth.raw_flags = 0;
1213  template.sub.eth.flags.one_tag = 1;
1214  template.sub.eth.outer_vlan_id = id;
1215  template.sub.eth.flags.exact_match = 1;
1216 
1217  error = vnet_create_sw_interface (vnm, &template, &sw_if_index);
1218  if (error)
1219  {
1220  clib_error_report (error);
1221  rv = VNET_API_ERROR_INVALID_REGISTRATION;
1222  goto out;
1223  }
1224 
1225  u64 *kp = clib_mem_alloc (sizeof (*kp));
1226  *kp = sup_and_sub_key;
1227 
1228  hash_set (hi->sub_interface_sw_if_index_by_id, id, sw_if_index);
1229  hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index);
1230 
1232 
1233 out:
1235  if (!reg)
1236  return;
1237 
1238  rmp = vl_msg_api_alloc (sizeof (*rmp));
1239  rmp->_vl_msg_id = htons (VL_API_CREATE_VLAN_SUBIF_REPLY);
1240  rmp->context = mp->context;
1241  rmp->retval = htonl (rv);
1242  rmp->sw_if_index = htonl (sw_if_index);
1243  vl_api_send_msg (reg, (u8 *) rmp);
1244 }
1245 
1246 static void
1248 {
1250  vnet_main_t *vnm = vnet_get_main ();
1251  u32 sub_sw_if_index = ~0;
1253  int rv = 0;
1254 
1255  VALIDATE_SW_IF_INDEX (mp);
1256 
1257  hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index));
1258 
1260  rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED;
1261  else
1262  rv = vnet_create_sub_interface (ntohl (mp->sw_if_index),
1263  ntohl (mp->sub_id),
1264  ntohl (mp->sub_if_flags),
1265  ntohs (mp->inner_vlan_id),
1266  ntohs (mp->outer_vlan_id),
1267  &sub_sw_if_index);
1268 
1270 
1271  /* *INDENT-OFF* */
1272  REPLY_MACRO2(VL_API_CREATE_SUBIF_REPLY,
1273  ({
1274  rmp->sw_if_index = ntohl(sub_sw_if_index);
1275  }));
1276  /* *INDENT-ON* */
1277 }
1278 
1279 static void
1281 {
1282  vl_api_delete_subif_reply_t *rmp;
1283  int rv;
1284 
1285  rv = vnet_delete_sub_interface (ntohl (mp->sw_if_index));
1286 
1287  REPLY_MACRO (VL_API_DELETE_SUBIF_REPLY);
1288 }
1289 
1290 static void
1292  mp)
1293 {
1294  vl_api_interface_name_renumber_reply_t *rmp;
1295  int rv = 0;
1296 
1297  VALIDATE_SW_IF_INDEX (mp);
1298 
1300  (ntohl (mp->sw_if_index), ntohl (mp->new_show_dev_instance));
1301 
1303 
1304  REPLY_MACRO (VL_API_INTERFACE_NAME_RENUMBER_REPLY);
1305 }
1306 
1307 static void
1309 {
1311  u32 sw_if_index;
1312  int rv;
1314 
1315  mac_address_decode (mp->mac_address, &mac);
1316  rv = vnet_create_loopback_interface (&sw_if_index, (u8 *) & mac, 0, 0);
1317 
1318  /* *INDENT-OFF* */
1319  REPLY_MACRO2(VL_API_CREATE_LOOPBACK_REPLY,
1320  ({
1321  rmp->sw_if_index = ntohl (sw_if_index);
1322  }));
1323  /* *INDENT-ON* */
1324 }
1325 
1328 {
1330  u32 sw_if_index;
1331  u8 is_specified = mp->is_specified;
1332  u32 user_instance = ntohl (mp->user_instance);
1333  int rv;
1335 
1336  mac_address_decode (mp->mac_address, &mac);
1337  rv = vnet_create_loopback_interface (&sw_if_index, (u8 *) & mac,
1338  is_specified, user_instance);
1339 
1340  /* *INDENT-OFF* */
1341  REPLY_MACRO2(VL_API_CREATE_LOOPBACK_INSTANCE_REPLY,
1342  ({
1343  rmp->sw_if_index = ntohl (sw_if_index);
1344  }));
1345  /* *INDENT-ON* */
1346 }
1347 
1348 static void
1350 {
1351  vl_api_delete_loopback_reply_t *rmp;
1352  u32 sw_if_index;
1353  int rv;
1354 
1355  sw_if_index = ntohl (mp->sw_if_index);
1356  rv = vnet_delete_loopback_interface (sw_if_index);
1357 
1358  REPLY_MACRO (VL_API_DELETE_LOOPBACK_REPLY);
1359 }
1360 
1361 static void
1364 {
1365  vl_api_collect_detailed_interface_stats_reply_t *rmp;
1366  int rv = 0;
1367 
1368  rv =
1370  mp->enable_disable);
1371 
1372  REPLY_MACRO (VL_API_COLLECT_DETAILED_INTERFACE_STATS_REPLY);
1373 }
1374 
1375 static void
1378 {
1379  vl_api_sw_interface_address_replace_begin_reply_t *rmp;
1380  int rv = 0;
1381 
1383 
1384  REPLY_MACRO (VL_API_SW_INTERFACE_ADDRESS_REPLACE_BEGIN_REPLY);
1385 }
1386 
1387 static void
1390 {
1391  vl_api_sw_interface_address_replace_end_reply_t *rmp;
1392  int rv = 0;
1393 
1395 
1396  REPLY_MACRO (VL_API_SW_INTERFACE_ADDRESS_REPLACE_END_REPLY);
1397 }
1398 
1399 /*
1400  * vpe_api_hookup
1401  * Add vpe's API message handlers to the table.
1402  * vlib has already mapped shared memory and
1403  * added the client registration handlers.
1404  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1405  */
1406 #define vl_msg_name_crc_list
1407 #include <vnet/interface.api.h>
1408 #undef vl_msg_name_crc_list
1409 
1410 static void
1412 {
1413 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1414  foreach_vl_msg_name_crc_interface;
1415 #undef _
1416 }
1417 
1418 pub_sub_handler (interface_events, INTERFACE_EVENTS);
1419 
1420 static clib_error_t *
1422 {
1423  api_main_t *am = vlibapi_get_main ();
1424 
1425 #define _(N,n) \
1426  vl_msg_api_set_handlers(VL_API_##N, #n, \
1427  vl_api_##n##_t_handler, \
1428  vl_noop_handler, \
1429  vl_api_##n##_t_endian, \
1430  vl_api_##n##_t_print, \
1431  sizeof(vl_api_##n##_t), 1);
1433 #undef _
1434 
1435  /* Mark these APIs as mp safe */
1436  am->is_mp_safe[VL_API_SW_INTERFACE_DUMP] = 1;
1437  am->is_mp_safe[VL_API_SW_INTERFACE_DETAILS] = 1;
1438  am->is_mp_safe[VL_API_SW_INTERFACE_TAG_ADD_DEL] = 1;
1439 
1440  /* Do not replay VL_API_SW_INTERFACE_DUMP messages */
1441  am->api_trace_cfg[VL_API_SW_INTERFACE_DUMP].replay_enable = 0;
1442 
1443  /*
1444  * Set up the (msg_name, crc, message-id) table
1445  */
1447 
1448  return 0;
1449 }
1450 
1452 
1453 /*
1454  * fd.io coding-style-patch-verification: ON
1455  *
1456  * Local Variables:
1457  * eval: (c-set-style "gnu")
1458  * End:
1459  */
static void vl_api_delete_subif_t_handler(vl_api_delete_subif_t *mp)
uword * sibling_bitmap
Definition: node.h:343
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:507
vl_api_interface_index_t sw_if_index
Definition: interface.api:91
enum fib_source_t_ fib_source_t
The different sources that can create a route.
u32 mfib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, mfib_source_t src)
Get the index of the FIB for a Table-ID.
Definition: mfib_table.c:613
#define hash_set(h, key, value)
Definition: hash.h:255
ip4_table_bind_function_t * function
Definition: ip4.h:93
vnet_main_t * vnet_main
#define CLIB_UNUSED(x)
Definition: clib.h:86
Enable or disable detailed interface stats.
Definition: interface.api:621
clib_error_t * set_hw_interface_rx_placement(u32 hw_if_index, u32 queue_id, u32 thread_index, u8 is_main)
void vnet_sw_interface_ip_directed_broadcast(vnet_main_t *vnm, u32 sw_if_index, u8 enable)
Definition: interface.c:703
vl_api_if_status_flags_t flags
Definition: interface.api:149
vl_api_mac_address_t mac
Definition: l2.api:502
Get interface&#39;s MAC address.
Definition: interface.api:387
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:593
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip6.h:199
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static void vl_api_interface_name_renumber_t_handler(vl_api_interface_name_renumber_t *mp)
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
vl_api_interface_index_t unnumbered_sw_if_index
Definition: interface.api:320
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(link_up_down_function)
ethernet_main_t * ethernet_get_main(vlib_main_t *vm)
Definition: init.c:125
void mac_address_encode(const mac_address_t *in, u8 *out)
static clib_error_t * sw_interface_add_del_function(vnet_main_t *vm, u32 sw_if_index, u32 flags)
Set flags on the interface.
Definition: interface.api:35
vnet_interface_main_t interface_main
Definition: vnet.h:56
static void vl_api_sw_interface_add_del_address_t_handler(vl_api_sw_interface_add_del_address_t *mp)
void ip_interface_address_mark(void)
Definition: ip_interface.c:229
vl_api_interface_index_t sw_if_index
Definition: interface.api:391
vl_api_interface_index_t sw_if_index
Definition: interface.api:457
unsigned long u64
Definition: types.h:89
#define REPLY_MACRO2(t, body)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
ethernet_interface_t * interfaces
Definition: ethernet.h:293
u32 fib_table_get_index_for_sw_if_index(fib_protocol_t proto, u32 sw_if_index)
Get the index of the FIB bound to the interface.
Definition: fib_table.c:989
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
u8 src_address[6]
Definition: packet.h:56
Set an interface&#39;s rx-placement Rx-Queue placement on specific thread is operational for only hardwar...
Definition: interface.api:437
u32 * input_node_thread_index_by_queue
Definition: interface.h:592
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
static void vl_api_delete_loopback_t_handler(vl_api_delete_loopback_t *mp)
vl_api_interface_index_t sw_if_index
Definition: interface.api:498
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:590
int vnet_interface_name_renumber(u32 sw_if_index, u32 new_show_dev_instance)
Definition: interface.c:1391
static void vnet_clear_sw_interface_tag(vnet_main_t *vnm, u32 sw_if_index)
static void send_sw_interface_event(vpe_api_main_t *am, vpe_client_registration_t *reg, vl_api_registration_t *vl_reg, u32 sw_if_index, enum api_events events)
vl_api_address_t src
Definition: gre.api:54
VLIB_API_INIT_FUNCTION(interface_api_hookup)
vl_api_mac_address_t mac_address
Definition: interface.api:585
#define hash_set_mem(h, key, value)
Definition: hash.h:275
ip_lookup_main_t lookup_main
Definition: ip4.h:108
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
uword * sub_interface_sw_if_index_by_id
Definition: interface.h:574
vlib_main_t * vlib_main
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:122
Set IP4 directed broadcast The directed broadcast enabled a packet sent to the interface&#39;s subnet add...
Definition: interface.api:72
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
static void vl_api_sw_interface_set_unnumbered_t_handler(vl_api_sw_interface_set_unnumbered_t *mp)
static void vl_api_sw_interface_set_rx_placement_t_handler(vl_api_sw_interface_set_rx_placement_t *mp)
vpe_api_main_t vpe_api_main
Definition: interface_api.c:54
struct _vnet_device_class vnet_device_class_t
uword * dq_runtime_index_by_queue
Definition: interface.h:599
void * vl_msg_api_alloc(int nbytes)
static void vl_api_sw_interface_dump_t_handler(vl_api_sw_interface_dump_t *mp)
unsigned char u8
Definition: types.h:56
trace_cfg_t * api_trace_cfg
Current trace configuration.
Definition: api_common.h:273
static void send_interface_rx_placement_details(vpe_api_main_t *am, vl_api_registration_t *rp, u32 sw_if_index, u32 worker_id, u32 queue_id, u8 mode, u32 context)
#define VNET_HW_INTERFACE_FLAG_DUPLEX_MASK
Definition: interface.h:513
static clib_error_t * interface_api_hookup(vlib_main_t *vm)
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u8 id[64]
Definition: dhcp.api:160
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static uword link_state_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
vl_api_mac_address_t mac_address
Definition: interface.api:559
vl_api_mac_address_t b_dmac
Definition: interface.api:183
int ip_table_bind(fib_protocol_t fproto, u32 sw_if_index, u32 table_id, u8 is_api)
vl_api_interface_index_t sw_if_index
Definition: interface.api:62
enum mfib_source_t_ mfib_source_t
Possible [control plane] sources of MFIB entries.
ethernet_main_t ethernet_main
Definition: init.c:45
vl_api_interface_index_t sw_if_index
Definition: interface.api:547
vnet_hw_interface_rx_mode
Definition: interface.h:53
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:125
Set an interface&#39;s rx-mode.
Definition: interface.api:416
void vlib_clear_combined_counters(vlib_combined_counter_main_t *cm)
Clear a collection of combined counters.
Definition: counter.c:61
Clear interface statistics.
Definition: interface.api:329
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:513
vl_api_interface_index_t sw_if_index
Definition: gre.api:53
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:516
vl_api_address_with_prefix_t prefix
Definition: interface.api:228
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:867
u8 dst_address[6]
Definition: packet.h:55
Reply for the vlan subinterface create request.
Definition: interface.api:532
vnet_hw_interface_flags_t flags
Definition: interface.h:526
vl_api_interface_index_t sw_if_index
Definition: interface.api:611
static void vl_api_sw_interface_rx_placement_dump_t_handler(vl_api_sw_interface_rx_placement_dump_t *mp)
#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 void vl_api_hw_interface_set_mtu_t_handler(vl_api_hw_interface_set_mtu_t *mp)
Get VRF id assigned to interface.
Definition: interface.api:289
int vnet_create_sub_interface(u32 sw_if_index, u32 id, u32 flags, u16 inner_vlan_id, u16 outer_vlan_id, u32 *sub_sw_if_index)
Definition: interface.c:1044
u32 mtu[VNET_N_MTU]
Definition: interface.h:741
unsigned int u32
Definition: types.h:88
u32 fib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1097
A collection of simple counters.
Definition: counter.h:57
ip46_type_t ip_address_decode(const vl_api_address_t *in, ip46_address_t *out)
Decode/Encode for struct/union types.
Definition: ip_types_api.c:160
vl_api_interface_index_t sw_if_index
Definition: interface.api:378
void vnet_sw_interface_set_protocol_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu[])
Definition: interface.c:682
vl_api_if_status_flags_t flags
Definition: interface.api:92
vl_api_mac_address_t b_smac
Definition: interface.api:184
u32 max_supported_packet_bytes
Definition: interface.h:565
clib_error_t * ip4_add_del_interface_address(vlib_main_t *vm, u32 sw_if_index, ip4_address_t *address, u32 address_length, u32 is_del)
Definition: ip4_forward.c:872
vnet_api_error_t api_errno
Definition: vnet.h:78
static clib_error_t * link_up_down_function(vnet_main_t *vm, u32 hw_if_index, u32 flags)
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
format_function_t format_vnet_sw_interface_name
#define VNET_HW_INTERFACE_FLAG_DUPLEX_SHIFT
Definition: interface.h:511
#define clib_bitmap_foreach(i, ai, body)
Macro to iterate across set bits in a bitmap.
Definition: bitmap.h:361
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:534
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread counters.
Definition: counter.h:285
vnet_sub_interface_t sub
Definition: interface.h:744
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
static void vl_api_sw_interface_get_table_t_handler(vl_api_sw_interface_get_table_t *mp)
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:934
void mfib_table_unlock(u32 fib_index, fib_protocol_t proto, mfib_source_t source)
Take a reference counting lock on the table.
Definition: mfib_table.c:777
vl_api_interface_index_t sw_if_index
Definition: interface.api:420
static void send_sw_interface_get_table_reply(vl_api_registration_t *reg, u32 context, int retval, u32 vrf_id)
Set interface L3 MTU.
Definition: interface.api:58
vl_api_interface_index_t sw_if_index
Definition: interface.api:333
int replay_enable
This message can be replayed.
Definition: api_common.h:85
unsigned short u16
Definition: types.h:57
static void vl_api_sw_interface_address_replace_begin_t_handler(vl_api_sw_interface_address_replace_begin_t *mp)
vl_api_interface_index_t sw_if_index
Definition: interface.api:319
uword * sw_if_index_by_sup_and_sub
Definition: interface.h:861
static void vl_api_sw_interface_set_mac_address_t_handler(vl_api_sw_interface_set_mac_address_t *mp)
ip6_table_bind_callback_t * table_bind_callbacks
Functions to call when interface to table biding changes.
Definition: ip6.h:220
Reply to get_sw_interface_vrf.
Definition: interface.api:301
#define REPLY_MACRO(t)
vnet_sw_interface_flags_t flags
Definition: interface.h:724
clib_error_t * set_hw_interface_change_rx_mode(vnet_main_t *vnm, u32 hw_if_index, u8 queue_id_valid, u32 queue_id, vnet_hw_interface_rx_mode mode)
static void vl_api_create_loopback_t_handler(vl_api_create_loopback_t *mp)
ip6_main_t ip6_main
Definition: ip6_forward.c:2784
Create loopback interface instance response.
Definition: interface.api:595
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:866
void mfib_table_lock(u32 fib_index, fib_protocol_t proto, mfib_source_t source)
Release a reference counting lock on the table.
Definition: mfib_table.c:806
void vnet_sw_interface_update_unnumbered(u32 unnumbered_sw_if_index, u32 ip_sw_if_index, u8 enable)
Definition: interface.c:1553
void ip_del_all_interface_addresses(vlib_main_t *vm, u32 sw_if_index)
Definition: ip46_cli.c:82
#define foreach_vlib_main(body)
Definition: threads.h:241
Set or delete one or all ip addresses on a specified interface.
Definition: interface.api:220
void fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
Definition: fib_table.c:1291
vl_api_interface_index_t sw_if_index
Definition: interface.api:279
vl_api_tunnel_mode_t mode
Definition: gre.api:48
vnet_hw_interface_class_t ethernet_hw_interface_class
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:226
static void setup_message_id_table(api_main_t *am)
vl_api_interface_index_t sw_if_index
Definition: interface.api:523
int vnet_create_loopback_interface(u32 *sw_if_indexp, u8 *mac_address, u8 is_specified, u32 user_instance)
Definition: interface.c:816
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
#define VNET_HW_INTERFACE_BOND_INFO_SLAVE
Definition: interface.h:586
#define BAD_SW_IF_INDEX_LABEL
vl_api_mac_address_t l2_address
Definition: interface.api:147
static uword vnet_sw_if_index_is_api_valid(u32 sw_if_index)
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
vl_api_interface_index_t sw_if_index[default=0xFFFFFFFF]
Definition: interface.api:207
u32 flags
Definition: vhost_user.h:248
From the CLI.
Definition: fib_source.h:76
static void vl_api_sw_interface_set_flags_t_handler(vl_api_sw_interface_set_flags_t *mp)
Definition: interface_api.c:90
u32 ft_table_id
Table ID (hash key) for this FIB.
Definition: fib_table.h:92
void ip_interface_address_sweep(void)
Definition: ip_interface.c:289
show the interface&#39;s queue - thread placement This api is used to display the interface and queue wor...
Definition: interface.api:475
int vnet_delete_sub_interface(u32 sw_if_index)
Definition: interface.c:1086
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
int vnet_delete_loopback_interface(u32 sw_if_index)
Definition: interface.c:1024
static clib_error_t * admin_up_down_function(vnet_main_t *vm, u32 hw_if_index, u32 flags)
vl_api_interface_index_t sw_if_index
Definition: interface.api:53
#define clib_warning(format, args...)
Definition: error.h:59
static void vl_api_sw_interface_add_del_mac_address_t_handler(vl_api_sw_interface_add_del_mac_address_t *mp)
Request all or filtered subset of sw_interface_details.
Definition: interface.api:203
static void vl_api_create_loopback_instance_t_handler(vl_api_create_loopback_instance_t *mp)
Delete sub interface request.
Definition: interface.api:544
#define ARRAY_LEN(x)
Definition: clib.h:66
static void send_sw_interface_details(vpe_api_main_t *am, vl_api_registration_t *rp, vnet_sw_interface_t *swif, u8 *interface_name, u32 context)
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:57
vl_api_link_duplex_t link_duplex
Definition: interface.api:154
string name[64]
Definition: ip.api:44
#define foreach_vpe_api_msg
Definition: interface_api.c:56
Delete loopback interface request.
Definition: interface.api:607
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(admin_up_down_function)
void fib_table_lock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Release a reference counting lock on the table.
Definition: fib_table.c:1310
foreach_registration_hash u8 link_state_process_up
vl_api_interface_index_t sw_if_index
Definition: interface.api:571
#define ASSERT(truth)
vl_api_interface_index_t sw_if_index
Definition: interface.api:479
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(sw_interface_add_del_function)
manual_print typedef address
Definition: ip_types.api:85
Reply for get interface&#39;s MAC address request.
Definition: interface.api:399
ip_lookup_main_t lookup_main
Definition: ip6.h:181
static void vnet_set_sw_interface_tag(vnet_main_t *vnm, u8 *tag, u32 sw_if_index)
u32 fib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, fib_source_t src)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1156
From the control plane API.
Definition: fib_source.h:72
static void vl_api_sw_interface_tag_add_del_t_handler(vl_api_sw_interface_tag_add_del_t *mp)
struct vnet_sub_interface_t::@327::@328::@330 flags
#define clib_error_report(e)
Definition: error.h:113
vl_api_interface_index_t sw_if_index
Definition: interface.api:293
vl_api_interface_index_t sw_if_index
Definition: interface.api:441
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
IP interface address replace end.
Definition: interface.api:262
static u8 * vnet_get_sw_interface_tag(vnet_main_t *vnm, u32 sw_if_index)
vl_api_interface_index_t sw_if_index
Definition: interface.api:490
static void vl_api_sw_interface_clear_stats_t_handler(vl_api_sw_interface_clear_stats_t *mp)
static void * clib_mem_alloc(uword size)
Definition: mem.h:157
vl_api_interface_index_t sw_if_index
Definition: interface.api:510
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
vl_api_ip4_address_t hi
Definition: arp.api:37
Interface Event generated by want_interface_events.
Definition: interface.api:87
static void vl_api_sw_interface_set_mtu_t_handler(vl_api_sw_interface_set_mtu_t *mp)
ip4_table_bind_callback_t * table_bind_callbacks
Functions to call when interface to table biding changes.
Definition: ip4.h:147
vl_api_interface_index_t sw_if_index
Definition: interface.api:39
static uword vnet_sw_interface_is_api_valid(vnet_main_t *vnm, u32 sw_if_index)
static void vl_api_sw_interface_set_rx_mode_t_handler(vl_api_sw_interface_set_rx_mode_t *mp)
void vnet_hw_interface_set_mtu(vnet_main_t *vnm, u32 hw_if_index, u32 mtu)
Definition: interface.c:730
vl_api_sub_if_flags_t sub_if_flags
Definition: interface.api:501
static void vl_api_create_subif_t_handler(vl_api_create_subif_t *mp)
Create loopback interface instance request.
Definition: interface.api:581
ethernet_interface_t * ethernet_get_interface(ethernet_main_t *em, u32 hw_if_index)
Definition: interface.c:967
IP interface address replace begin.
Definition: interface.api:249
api_events
vl_api_interface_index_t sw_if_index
Definition: interface.api:625
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vl_api_sub_if_flags_t sub_if_flags
Definition: interface.api:173
Set interface physical MTU.
Definition: interface.api:49
#define foreach_ip_interface_address(lm, a, sw_if_index, loop, body)
Definition: ip_interface.h:57
u32 mfib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: mfib_table.c:555
u64 uword
Definition: types.h:112
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:858
Create loopback interface request.
Definition: interface.api:555
ip6_table_bind_function_t * function
Definition: ip6.h:116
Set unnumbered interface add / del request.
Definition: interface.api:315
fib_table_t * fib_table_get(fib_node_index_t index, fib_protocol_t proto)
Get a pointer to a FIB table.
Definition: fib_table.c:29
vl_api_interface_index_t sw_if_index
Definition: interface.api:224
A collection of combined counters.
Definition: counter.h:188
Create a new subinterface with the given vlan id.
Definition: interface.api:519
int vnet_sw_interface_stats_collect_enable_disable(u32 sw_if_index, u8 enable)
Create loopback interface response.
Definition: interface.api:567
#define hash_get_mem(h, key)
Definition: hash.h:269
static void vl_api_sw_interface_set_ip_directed_broadcast_t_handler(vl_api_sw_interface_set_ip_directed_broadcast_t *mp)
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:379
dump the rx queue placement of interface(s)
Definition: interface.api:453
u32 l2vtr_get(vlib_main_t *vlib_main, vnet_main_t *vnet_main, u32 sw_if_index, u32 *vtr_op, u32 *push_dot1q, u32 *vtr_tag1, u32 *vtr_tag2)
Get vtag tag rewrite on the given interface.
Definition: l2_vtr.c:347
vl_api_interface_index_t sw_if_index
Definition: interface.api:140
Set an interface&#39;s MAC address.
Definition: interface.api:374
u8 * is_mp_safe
Message is mp safe vector.
Definition: api_common.h:249
void vlib_clear_simple_counters(vlib_simple_counter_main_t *cm)
Clear a collection of simple counters.
Definition: counter.c:44
vnet_sw_interface_type_t type
Definition: interface.h:722
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1144
vl_api_if_status_flags_t flags
Definition: interface.api:40
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, vnet_sw_interface_flags_t flags)
Definition: interface.c:507
pub_sub_handler(interface_events, INTERFACE_EVENTS)
#define vec_foreach(var, vec)
Vector iterator.
static void vl_api_create_vlan_subif_t_handler(vl_api_create_vlan_subif_t *mp)
static void vl_api_collect_detailed_interface_stats_t_handler(vl_api_collect_detailed_interface_stats_t *mp)
clib_error_t * ip6_add_del_interface_address(vlib_main_t *vm, u32 sw_if_index, ip6_address_t *address, u32 address_length, u32 is_del)
Definition: ip6_forward.c:297
clib_error_t * vnet_hw_interface_add_del_mac_address(vnet_main_t *vnm, u32 hw_if_index, const u8 *mac_address, u8 is_add)
Definition: interface.c:1456
u32 vrf_id
Definition: nat.api:856
clib_error_t * vnet_hw_interface_change_mac_address(vnet_main_t *vnm, u32 hw_if_index, const u8 *mac_address)
Definition: interface.c:1544
u8 si
Definition: lisp_types.api:47
clib_error_t * vnet_create_sw_interface(vnet_main_t *vnm, vnet_sw_interface_t *template, u32 *sw_if_index)
Definition: interface.c:584
Interface details structure (fix this)
Definition: interface.api:137
static void vl_api_sw_interface_set_table_t_handler(vl_api_sw_interface_set_table_t *mp)
u32 table_id
Definition: fib_types.api:118
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:554
Set / clear software interface tag.
Definition: interface.api:343
Add or delete a secondary MAC address on an interface.
Definition: interface.api:359
Associate the specified interface with a fib table.
Definition: interface.api:275
static void vl_api_sw_interface_get_mac_address_t_handler(vl_api_sw_interface_get_mac_address_t *mp)
u32 * fib_index_by_sw_if_index
Definition: ip6.h:196
void mac_address_decode(const u8 *in, mac_address_t *out)
Conversion functions to/from (decode/encode) API types to VPP internal types.
u8 * vl_api_from_api_to_new_vec(void *mp, vl_api_string_t *astr)
Definition: api_shared.c:1156
vl_api_interface_index_t sw_if_index
Definition: interface.api:536
u32 l2pbb_get(vlib_main_t *vlib_main, vnet_main_t *vnet_main, u32 sw_if_index, u32 *vtr_op, u16 *outer_tag, ethernet_header_t *eth_hdr, u16 *b_vlanid, u32 *i_sid)
Get pbb tag rewrite on the given interface.
Definition: l2_vtr.c:686
struct vnet_sub_interface_t::@327 eth
static void vl_api_sw_interface_address_replace_end_t_handler(vl_api_sw_interface_address_replace_end_t *mp)
vl_api_interface_index_t sw_if_index
Definition: interface.api:599
#define VALIDATE_SW_IF_INDEX(mp)
A protocol Independent FIB table.
Definition: fib_table.h:71
vl_api_interface_index_t sw_if_index
Definition: interface.api:348