src/plugins/linux-cp/lcp_interface.c

   1 /*
   2  * Copyright (c) 2020 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 #define _GNU_SOURCE
  17 #include <fcntl.h>
  18 #include <ctype.h>
  19 #include <sys/socket.h>
  20 #include <net/if.h>
  21
  22 #include <linux-cp/lcp_interface.h>
  23 #include <netlink/route/link/vlan.h>
  24 #include <linux/if_ether.h>
  25
  26 #include <vnet/plugin/plugin.h>
  27 #include <vnet/plugin/plugin.h>
  28
  29 #include <vppinfra/linux/netns.h>
  30
  31 #include <vnet/ip/ip_punt_drop.h>
  32 #include <vnet/fib/fib_table.h>
  33 #include <vnet/adj/adj_mcast.h>
  34 #include <vnet/udp/udp.h>
  35 #include <vnet/tcp/tcp.h>
  36 #include <vnet/devices/tap/tap.h>
  37 #include <vnet/devices/virtio/virtio.h>
  38 #include <vnet/devices/netlink.h>
  39 #include <vlibapi/api_helper_macros.h>
  40 #include <vnet/ipsec/ipsec_punt.h>
  41
  42 vlib_log_class_t lcp_itf_pair_logger;
  43
  44 /**
  45  * Pool of LIP objects
  46  */
  47 lcp_itf_pair_t *lcp_itf_pair_pool = NULL;
  48
  49 u32
  50 lcp_itf_num_pairs (void)
  51 {
  52   return pool_elts (lcp_itf_pair_pool);
  53 }
  54
  55 /**
  56  * DBs of interface-pair objects:
  57  *  - key'd by VIF (linux ID)
  58  *  - key'd by VPP's physical interface
  59  *  - number of shared uses of VPP's tap/host interface
  60  */
  61 static uword *lip_db_by_vif;
  62 index_t *lip_db_by_phy;
  63 u32 *lip_db_by_host;
  64
  65 /**
  66  * vector of virtual function table
  67  */
  68 static lcp_itf_pair_vft_t *lcp_itf_vfts = NULL;
  69
  70 void
  71 lcp_itf_pair_register_vft (lcp_itf_pair_vft_t *lcp_itf_vft)
  72 {
  73   vec_add1 (lcp_itf_vfts, *lcp_itf_vft);
  74 }
  75
  76 u8 *
  77 format_lcp_itf_pair (u8 *s, va_list *args)
  78 {
  79   vnet_main_t *vnm = vnet_get_main ();
  80   lcp_itf_pair_t *lip = va_arg (*args, lcp_itf_pair_t *);
  81   vnet_sw_interface_t *swif_phy;
  82   vnet_sw_interface_t *swif_host;
  83
  84   s = format (s, "itf-pair: [%d]", lip - lcp_itf_pair_pool);
  85
  86   swif_phy = vnet_get_sw_interface_or_null (vnm, lip->lip_phy_sw_if_index);
  87   if (!swif_phy)
  88     s = format (s, " <no-phy-if>");
  89   else
  90     s = format (s, " %U", format_vnet_sw_interface_name, vnm, swif_phy);
  91
  92   swif_host = vnet_get_sw_interface_or_null (vnm, lip->lip_host_sw_if_index);
  93   if (!swif_host)
  94     s = format (s, " <no-host-if>");
  95   else
  96     s = format (s, " %U", format_vnet_sw_interface_name, vnm, swif_host);
  97
  98   s = format (s, " %v %d type %s", lip->lip_host_name, lip->lip_vif_index,
  99               (lip->lip_host_type == LCP_ITF_HOST_TAP) ? "tap" : "tun");
 100
 101   if (lip->lip_namespace)
 102     s = format (s, " netns %s", lip->lip_namespace);
 103
 104   return s;
 105 }
 106
 107 static walk_rc_t
 108 lcp_itf_pair_walk_show_cb (index_t api, void *ctx)
 109 {
 110   vlib_main_t *vm;
 111   lcp_itf_pair_t *lip;
 112
 113   lip = lcp_itf_pair_get (api);
 114   if (!lip)
 115     return WALK_STOP;
 116
 117   vm = vlib_get_main ();
 118   vlib_cli_output (vm, "%U\n", format_lcp_itf_pair, lip);
 119
 120   return WALK_CONTINUE;
 121 }
 122
 123 void
 124 lcp_itf_pair_show (u32 phy_sw_if_index)
 125 {
 126   vlib_main_t *vm;
 127   u8 *ns;
 128   index_t api;
 129
 130   vm = vlib_get_main ();
 131   ns = lcp_get_default_ns ();
 132   vlib_cli_output (vm, "lcp default netns '%s'\n",
 133                    ns ? (char *) ns : "<unset>");
 134   vlib_cli_output (vm, "lcp lcp-auto-subint %s\n",
 135                    lcp_auto_subint () ? "on" : "off");
 136   vlib_cli_output (vm, "lcp lcp-sync %s\n", lcp_sync () ? "on" : "off");
 137   vlib_cli_output (vm, "lcp del-static-on-link-down %s\n",
 138                    lcp_get_del_static_on_link_down () ? "on" : "off");
 139   vlib_cli_output (vm, "lcp del-dynamic-on-link-down %s\n",
 140                    lcp_get_del_dynamic_on_link_down () ? "on" : "off");
 141
 142   if (phy_sw_if_index == ~0)
 143     {
 144       lcp_itf_pair_walk (lcp_itf_pair_walk_show_cb, 0);
 145     }
 146   else
 147     {
 148       api = lcp_itf_pair_find_by_phy (phy_sw_if_index);
 149       if (api != INDEX_INVALID)
 150         lcp_itf_pair_walk_show_cb (api, 0);
 151     }
 152 }
 153
 154 lcp_itf_pair_t *
 155 lcp_itf_pair_get (u32 index)
 156 {
 157   if (!lcp_itf_pair_pool)
 158     return NULL;
 159   if (index == INDEX_INVALID)
 160     return NULL;
 161
 162   return pool_elt_at_index (lcp_itf_pair_pool, index);
 163 }
 164
 165 index_t
 166 lcp_itf_pair_find_by_vif (u32 vif_index)
 167 {
 168   uword *p;
 169
 170   p = hash_get (lip_db_by_vif, vif_index);
 171
 172   if (p)
 173     return p[0];
 174
 175   return INDEX_INVALID;
 176 }
 177
 178 const char *lcp_itf_l3_feat_names[N_LCP_ITF_HOST][N_AF] = {
 179   [LCP_ITF_HOST_TAP] = {
 180     [AF_IP4] = "linux-cp-xc-ip4",
 181     [AF_IP6] = "linux-cp-xc-ip6",
 182   },
 183   [LCP_ITF_HOST_TUN] = {
 184     [AF_IP4] = "linux-cp-xc-l3-ip4",
 185     [AF_IP6] = "linux-cp-xc-l3-ip6",
 186   },
 187 };
 188
 189 const fib_route_path_flags_t lcp_itf_route_path_flags[N_LCP_ITF_HOST] = {
 190   [LCP_ITF_HOST_TAP] = FIB_ROUTE_PATH_DVR,
 191   [LCP_ITF_HOST_TUN] = FIB_ROUTE_PATH_FLAG_NONE,
 192 };
 193
 194 static void
 195 lcp_itf_unset_adjs (lcp_itf_pair_t *lip)
 196 {
 197   adj_unlock (lip->lip_phy_adjs.adj_index[AF_IP4]);
 198   adj_unlock (lip->lip_phy_adjs.adj_index[AF_IP6]);
 199 }
 200
 201 static void
 202 lcp_itf_set_adjs (lcp_itf_pair_t *lip)
 203 {
 204   if (lip->lip_host_type == LCP_ITF_HOST_TUN)
 205     {
 206       lip->lip_phy_adjs.adj_index[AF_IP4] = adj_nbr_add_or_lock (
 207         FIB_PROTOCOL_IP4, VNET_LINK_IP4, &zero_addr, lip->lip_phy_sw_if_index);
 208       lip->lip_phy_adjs.adj_index[AF_IP6] = adj_nbr_add_or_lock (
 209         FIB_PROTOCOL_IP6, VNET_LINK_IP6, &zero_addr, lip->lip_phy_sw_if_index);
 210     }
 211   else
 212     {
 213       lip->lip_phy_adjs.adj_index[AF_IP4] = adj_mcast_add_or_lock (
 214         FIB_PROTOCOL_IP4, VNET_LINK_IP4, lip->lip_phy_sw_if_index);
 215       lip->lip_phy_adjs.adj_index[AF_IP6] = adj_mcast_add_or_lock (
 216         FIB_PROTOCOL_IP6, VNET_LINK_IP6, lip->lip_phy_sw_if_index);
 217     }
 218
 219   ip_adjacency_t *adj;
 220
 221   adj = adj_get (lip->lip_phy_adjs.adj_index[AF_IP4]);
 222
 223   lip->lip_rewrite_len = adj->rewrite_header.data_bytes;
 224 }
 225
 226 int
 227 lcp_itf_pair_add (u32 host_sw_if_index, u32 phy_sw_if_index, u8 *host_name,
 228                   u32 host_index, lip_host_type_t host_type, u8 *ns)
 229 {
 230   index_t lipi;
 231   lcp_itf_pair_t *lip;
 232
 233   if (host_sw_if_index == ~0)
 234     {
 235       LCP_ITF_PAIR_ERR ("pair_add: Cannot add LIP - invalid host");
 236       return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 237     }
 238
 239   lipi = lcp_itf_pair_find_by_phy (phy_sw_if_index);
 240
 241   if (lipi != INDEX_INVALID)
 242     return VNET_API_ERROR_VALUE_EXIST;
 243
 244   LCP_ITF_PAIR_INFO ("add: host:%U phy:%U, host_if:%v vif:%d ns:%s",
 245                      format_vnet_sw_if_index_name, vnet_get_main (),
 246                      host_sw_if_index, format_vnet_sw_if_index_name,
 247                      vnet_get_main (), phy_sw_if_index, host_name, host_index,
 248                      ns);
 249
 250   /*
 251    * Create a new pair.
 252    */
 253   pool_get (lcp_itf_pair_pool, lip);
 254
 255   lipi = lip - lcp_itf_pair_pool;
 256
 257   vec_validate_init_empty (lip_db_by_phy, phy_sw_if_index, INDEX_INVALID);
 258   vec_validate_init_empty (lip_db_by_host, host_sw_if_index, INDEX_INVALID);
 259   lip_db_by_phy[phy_sw_if_index] = lipi;
 260   lip_db_by_host[host_sw_if_index] = lipi;
 261   hash_set (lip_db_by_vif, host_index, lipi);
 262
 263   lip->lip_host_sw_if_index = host_sw_if_index;
 264   lip->lip_phy_sw_if_index = phy_sw_if_index;
 265   lip->lip_host_name = vec_dup (host_name);
 266   lip->lip_host_type = host_type;
 267   lip->lip_vif_index = host_index;
 268   lip->lip_namespace = vec_dup (ns);
 269
 270   /*
 271    * First use of this host interface.
 272    * Enable the x-connect feature on the host to send
 273    * all packets to the phy.
 274    */
 275   ip_address_family_t af;
 276
 277   FOR_EACH_IP_ADDRESS_FAMILY (af)
 278   ip_feature_enable_disable (af, N_SAFI, IP_FEATURE_INPUT,
 279                              lcp_itf_l3_feat_names[lip->lip_host_type][af],
 280                              lip->lip_host_sw_if_index, 1, NULL, 0);
 281
 282   /*
 283    * Configure passive punt to the host interface.
 284    */
 285   fib_route_path_t *rpaths = NULL, rpath = {
 286     .frp_flags = lcp_itf_route_path_flags[lip->lip_host_type],
 287     .frp_proto = DPO_PROTO_IP4,
 288     .frp_sw_if_index = lip->lip_host_sw_if_index,
 289     .frp_weight = 1,
 290     .frp_fib_index = ~0,
 291   };
 292
 293   vec_add1 (rpaths, rpath);
 294
 295   ip4_punt_redirect_add_paths (lip->lip_phy_sw_if_index, rpaths);
 296
 297   rpaths[0].frp_proto = DPO_PROTO_IP6;
 298
 299   ip6_punt_redirect_add_paths (lip->lip_phy_sw_if_index, rpaths);
 300
 301   vec_free (rpaths);
 302
 303   lcp_itf_set_adjs (lip);
 304
 305   /* enable ARP feature node for broadcast interfaces */
 306   if (lip->lip_host_type != LCP_ITF_HOST_TUN)
 307     {
 308       vnet_feature_enable_disable ("arp", "linux-cp-arp-phy",
 309                                    lip->lip_phy_sw_if_index, 1, NULL, 0);
 310       vnet_feature_enable_disable ("arp", "linux-cp-arp-host",
 311                                    lip->lip_host_sw_if_index, 1, NULL, 0);
 312     }
 313   else
 314     {
 315       if (hash_elts (lip_db_by_vif) == 1)
 316         {
 317           vnet_feature_enable_disable ("ip4-punt", "linux-cp-punt-l3", 0, 1,
 318                                        NULL, 0);
 319           vnet_feature_enable_disable ("ip6-punt", "linux-cp-punt-l3", 0, 1,
 320                                        NULL, 0);
 321         }
 322     }
 323
 324   /* invoke registered callbacks for pair addition */
 325   lcp_itf_pair_vft_t *vft;
 326
 327   vec_foreach (vft, lcp_itf_vfts)
 328     {
 329       if (vft->pair_add_fn)
 330         vft->pair_add_fn (lip);
 331     }
 332
 333   /* set timestamp when pair entered service */
 334   lip->lip_create_ts = vlib_time_now (vlib_get_main ());
 335
 336   return 0;
 337 }
 338
 339 static clib_error_t *
 340 lcp_netlink_add_link_vlan (int parent, u32 vlan, u16 proto, const char *name)
 341 {
 342   struct rtnl_link *link;
 343   struct nl_sock *sk;
 344   int err;
 345
 346   sk = nl_socket_alloc ();
 347   if ((err = nl_connect (sk, NETLINK_ROUTE)) < 0)
 348     {
 349       LCP_ITF_PAIR_ERR ("netlink_add_link_vlan: connect error: %s",
 350                         nl_geterror (err));
 351       return clib_error_return (NULL, "Unable to connect socket: %d", err);
 352     }
 353
 354   link = rtnl_link_vlan_alloc ();
 355
 356   rtnl_link_set_link (link, parent);
 357   rtnl_link_set_name (link, name);
 358   rtnl_link_vlan_set_id (link, vlan);
 359   rtnl_link_vlan_set_protocol (link, htons (proto));
 360
 361   if ((err = rtnl_link_add (sk, link, NLM_F_CREATE)) < 0)
 362     {
 363       LCP_ITF_PAIR_ERR ("netlink_add_link_vlan: link add error: %s",
 364                         nl_geterror (err));
 365       return clib_error_return (NULL, "Unable to add link %s: %d", name, err);
 366     }
 367
 368   rtnl_link_put (link);
 369   nl_close (sk);
 370
 371   return NULL;
 372 }
 373
 374 static clib_error_t *
 375 lcp_netlink_del_link (const char *name)
 376 {
 377   struct rtnl_link *link;
 378   struct nl_sock *sk;
 379   int err;
 380
 381   sk = nl_socket_alloc ();
 382   if ((err = nl_connect (sk, NETLINK_ROUTE)) < 0)
 383     return clib_error_return (NULL, "Unable to connect socket: %d", err);
 384
 385   link = rtnl_link_alloc ();
 386   rtnl_link_set_name (link, name);
 387
 388   if ((err = rtnl_link_delete (sk, link)) < 0)
 389     return clib_error_return (NULL, "Unable to del link %s: %d", name, err);
 390
 391   rtnl_link_put (link);
 392   nl_close (sk);
 393
 394   return NULL;
 395 }
 396
 397 int
 398 lcp_itf_pair_del (u32 phy_sw_if_index)
 399 {
 400   ip_address_family_t af;
 401   lcp_itf_pair_t *lip;
 402   u32 lipi;
 403   lcp_itf_pair_vft_t *vft;
 404
 405   lipi = lcp_itf_pair_find_by_phy (phy_sw_if_index);
 406
 407   if (lipi == INDEX_INVALID)
 408     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 409
 410   lip = lcp_itf_pair_get (lipi);
 411
 412   LCP_ITF_PAIR_NOTICE (
 413     "pair_del: host:%U phy:%U host_if:%v vif:%d ns:%v",
 414     format_vnet_sw_if_index_name, vnet_get_main (), lip->lip_host_sw_if_index,
 415     format_vnet_sw_if_index_name, vnet_get_main (), lip->lip_phy_sw_if_index,
 416     lip->lip_host_name, lip->lip_vif_index, lip->lip_namespace);
 417
 418   /* invoke registered callbacks for pair deletion */
 419   vec_foreach (vft, lcp_itf_vfts)
 420     {
 421       if (vft->pair_del_fn)
 422         vft->pair_del_fn (lip);
 423     }
 424
 425   FOR_EACH_IP_ADDRESS_FAMILY (af)
 426   ip_feature_enable_disable (af, N_SAFI, IP_FEATURE_INPUT,
 427                              lcp_itf_l3_feat_names[lip->lip_host_type][af],
 428                              lip->lip_host_sw_if_index, 0, NULL, 0);
 429
 430   lcp_itf_unset_adjs (lip);
 431
 432   ip4_punt_redirect_del (lip->lip_phy_sw_if_index);
 433   ip6_punt_redirect_del (lip->lip_phy_sw_if_index);
 434
 435   /* disable ARP feature node for broadcast interfaces */
 436   if (lip->lip_host_type != LCP_ITF_HOST_TUN)
 437     {
 438       vnet_feature_enable_disable ("arp", "linux-cp-arp-phy",
 439                                    lip->lip_phy_sw_if_index, 0, NULL, 0);
 440       vnet_feature_enable_disable ("arp", "linux-cp-arp-host",
 441                                    lip->lip_host_sw_if_index, 0, NULL, 0);
 442     }
 443   else
 444     {
 445       if (hash_elts (lip_db_by_vif) == 1)
 446         {
 447           vnet_feature_enable_disable ("ip4-punt", "linux-cp-punt-l3", 0, 0,
 448                                        NULL, 0);
 449           vnet_feature_enable_disable ("ip6-punt", "linux-cp-punt-l3", 0, 0,
 450                                        NULL, 0);
 451         }
 452     }
 453   lip_db_by_phy[phy_sw_if_index] = INDEX_INVALID;
 454   lip_db_by_host[lip->lip_host_sw_if_index] = INDEX_INVALID;
 455   hash_unset (lip_db_by_vif, lip->lip_vif_index);
 456
 457   vec_free (lip->lip_host_name);
 458   vec_free (lip->lip_namespace);
 459   pool_put (lcp_itf_pair_pool, lip);
 460
 461   return 0;
 462 }
 463
 464 static void
 465 lcp_itf_pair_delete_by_index (index_t lipi)
 466 {
 467   u32 host_sw_if_index;
 468   lcp_itf_pair_t *lip;
 469   u8 *host_name, *ns;
 470
 471   lip = lcp_itf_pair_get (lipi);
 472
 473   host_name = vec_dup (lip->lip_host_name);
 474   host_sw_if_index = lip->lip_host_sw_if_index;
 475   ns = vec_dup (lip->lip_namespace);
 476
 477   lcp_itf_pair_del (lip->lip_phy_sw_if_index);
 478
 479   if (vnet_sw_interface_is_sub (vnet_get_main (), host_sw_if_index))
 480     {
 481       int curr_ns_fd = -1;
 482       int vif_ns_fd = -1;
 483       if (ns)
 484         {
 485           curr_ns_fd = clib_netns_open (NULL /* self */);
 486           vif_ns_fd = clib_netns_open ((u8 *) ns);
 487           if (vif_ns_fd != -1)
 488             clib_setns (vif_ns_fd);
 489         }
 490
 491       lcp_netlink_del_link ((const char *) host_name);
 492       if (vif_ns_fd != -1)
 493         close (vif_ns_fd);
 494
 495       if (curr_ns_fd != -1)
 496         {
 497           clib_setns (curr_ns_fd);
 498           close (curr_ns_fd);
 499         }
 500
 501       vnet_delete_sub_interface (host_sw_if_index);
 502     }
 503   else
 504     tap_delete_if (vlib_get_main (), host_sw_if_index);
 505
 506   vec_free (host_name);
 507   vec_free (ns);
 508 }
 509
 510 int
 511 lcp_itf_pair_delete (u32 phy_sw_if_index)
 512 {
 513   index_t lipi;
 514
 515   lipi = lcp_itf_pair_find_by_phy (phy_sw_if_index);
 516
 517   if (lipi == INDEX_INVALID)
 518     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 519
 520   lcp_itf_pair_delete_by_index (lipi);
 521
 522   return 0;
 523 }
 524
 525 /**
 526  * lcp_itf_interface_add_del
 527  *
 528  * Registered to receive interface Add and delete notifications
 529  */
 530 static clib_error_t *
 531 lcp_itf_interface_add_del (vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
 532 {
 533   if (!is_add)
 534     /* remove any interface pair we have for this interface */
 535     lcp_itf_pair_delete (sw_if_index);
 536
 537   return (NULL);
 538 }
 539
 540 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (lcp_itf_interface_add_del);
 541
 542 void
 543 lcp_itf_pair_walk (lcp_itf_pair_walk_cb_t cb, void *ctx)
 544 {
 545   u32 api;
 546
 547   pool_foreach_index (api, lcp_itf_pair_pool)
 548     {
 549       if (!cb (api, ctx))
 550         break;
 551     };
 552 }
 553
 554 static clib_error_t *
 555 lcp_itf_pair_config (vlib_main_t *vm, unformat_input_t *input)
 556 {
 557   u8 *default_ns;
 558
 559   default_ns = NULL;
 560
 561   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 562     {
 563       if (unformat (input, "default netns %v", &default_ns))
 564         {
 565           vec_add1 (default_ns, 0);
 566           if (lcp_set_default_ns (default_ns) < 0)
 567             {
 568               return clib_error_return (0,
 569                                         "linux-cp default namespace must"
 570                                         " be less than %d characters",
 571                                         LCP_NS_LEN);
 572             }
 573         }
 574       else if (unformat (input, "lcp-auto-subint"))
 575         lcp_set_auto_subint (1 /* is_auto */);
 576       else if (unformat (input, "lcp-sync"))
 577         lcp_set_sync (1 /* is_auto */);
 578       else if (unformat (input, "del-static-on-link-down"))
 579         lcp_set_del_static_on_link_down (1 /* is_del */);
 580       else if (unformat (input, "del-dynamic-on-link-down"))
 581         lcp_set_del_dynamic_on_link_down (1 /* is_del */);
 582       else
 583         return clib_error_return (0, "interfaces not found");
 584     }
 585
 586   vec_free (default_ns);
 587
 588   return NULL;
 589 }
 590
 591 VLIB_EARLY_CONFIG_FUNCTION (lcp_itf_pair_config, "linux-cp");
 592
 593 /*
 594  * Returns 1 if the tap name is valid.
 595  * Returns 0 if the tap name is invalid.
 596  */
 597 static int
 598 lcp_validate_if_name (u8 *name)
 599 {
 600   int len;
 601   char *p;
 602
 603   p = (char *) name;
 604   len = clib_strnlen (p, IFNAMSIZ);
 605   if (len >= IFNAMSIZ)
 606     return 0;
 607
 608   for (; *p; ++p)
 609     {
 610       if (isalnum (*p))
 611         continue;
 612
 613       switch (*p)
 614         {
 615         case '-':
 616         case '_':
 617         case '%':
 618         case '@':
 619         case ':':
 620         case '.':
 621           continue;
 622         }
 623
 624       return 0;
 625     }
 626
 627   return 1;
 628 }
 629
 630 void
 631 lcp_itf_set_link_state (const lcp_itf_pair_t *lip, u8 state)
 632 {
 633   int curr_ns_fd, vif_ns_fd;
 634
 635   if (!lip)
 636     return;
 637
 638   curr_ns_fd = vif_ns_fd = -1;
 639
 640   if (lip->lip_namespace)
 641     {
 642       curr_ns_fd = clib_netns_open (NULL /* self */);
 643       vif_ns_fd = clib_netns_open (lip->lip_namespace);
 644       if (vif_ns_fd != -1)
 645         clib_setns (vif_ns_fd);
 646     }
 647
 648   /* Set the same link state on the netlink interface
 649    */
 650   vnet_netlink_set_link_state (lip->lip_vif_index, state);
 651
 652   if (vif_ns_fd != -1)
 653     close (vif_ns_fd);
 654
 655   if (curr_ns_fd != -1)
 656     {
 657       clib_setns (curr_ns_fd);
 658       close (curr_ns_fd);
 659     }
 660
 661   return;
 662 }
 663
 664 void
 665 lcp_itf_set_interface_addr (const lcp_itf_pair_t *lip)
 666 {
 667   ip4_main_t *im4 = &ip4_main;
 668   ip6_main_t *im6 = &ip6_main;
 669   ip_lookup_main_t *lm4 = &im4->lookup_main;
 670   ip_lookup_main_t *lm6 = &im6->lookup_main;
 671   ip_interface_address_t *ia = 0;
 672   int vif_ns_fd = -1;
 673   int curr_ns_fd = -1;
 674
 675   if (!lip)
 676     return;
 677
 678   if (lip->lip_namespace)
 679     {
 680       curr_ns_fd = clib_netns_open (NULL /* self */);
 681       vif_ns_fd = clib_netns_open (lip->lip_namespace);
 682       if (vif_ns_fd != -1)
 683         clib_setns (vif_ns_fd);
 684     }
 685
 686   /* Sync any IP4 addressing info into LCP */
 687   foreach_ip_interface_address (
 688     lm4, ia, lip->lip_phy_sw_if_index, 1 /* honor unnumbered */, ({
 689       ip4_address_t *r4 = ip_interface_address_get_address (lm4, ia);
 690       LCP_ITF_PAIR_NOTICE ("set_interface_addr: %U add ip4 %U/%d",
 691                            format_lcp_itf_pair, lip, format_ip4_address, r4,
 692                            ia->address_length);
 693       vnet_netlink_add_ip4_addr (lip->lip_vif_index, r4, ia->address_length);
 694     }));
 695
 696   /* Sync any IP6 addressing info into LCP */
 697   foreach_ip_interface_address (
 698     lm6, ia, lip->lip_phy_sw_if_index, 1 /* honor unnumbered */, ({
 699       ip6_address_t *r6 = ip_interface_address_get_address (lm6, ia);
 700       LCP_ITF_PAIR_NOTICE ("set_interface_addr: %U add ip6 %U/%d",
 701                            format_lcp_itf_pair, lip, format_ip6_address, r6,
 702                            ia->address_length);
 703       vnet_netlink_add_ip6_addr (lip->lip_vif_index, r6, ia->address_length);
 704     }));
 705
 706   if (vif_ns_fd != -1)
 707     close (vif_ns_fd);
 708
 709   if (curr_ns_fd != -1)
 710     {
 711       clib_setns (curr_ns_fd);
 712       close (curr_ns_fd);
 713     }
 714 }
 715
 716 typedef struct
 717 {
 718   u32 vlan;
 719   bool dot1ad;
 720
 721   u32 matched_sw_if_index;
 722 } lcp_itf_match_t;
 723
 724 static walk_rc_t
 725 lcp_itf_pair_find_walk (vnet_main_t *vnm, u32 sw_if_index, void *arg)
 726 {
 727   lcp_itf_match_t *match = arg;
 728   const vnet_sw_interface_t *sw;
 729
 730   sw = vnet_get_sw_interface (vnm, sw_if_index);
 731   if (sw && (sw->sub.eth.inner_vlan_id == 0) &&
 732       (sw->sub.eth.outer_vlan_id == match->vlan) &&
 733       (sw->sub.eth.flags.dot1ad == match->dot1ad))
 734     {
 735       LCP_ITF_PAIR_DBG ("find_walk: found match outer %d dot1ad %d "
 736                         "inner-dot1q %d: interface %U",
 737                         sw->sub.eth.outer_vlan_id, sw->sub.eth.flags.dot1ad,
 738                         sw->sub.eth.inner_vlan_id,
 739                         format_vnet_sw_if_index_name, vnet_get_main (),
 740                         sw->sw_if_index);
 741       match->matched_sw_if_index = sw->sw_if_index;
 742       return WALK_STOP;
 743     }
 744
 745   return WALK_CONTINUE;
 746 }
 747
 748 /* Return the index of the sub-int on the phy that has the given vlan and
 749  * proto,
 750  */
 751 static index_t
 752 lcp_itf_pair_find_by_outer_vlan (u32 sup_if_index, u16 vlan, bool dot1ad)
 753 {
 754   lcp_itf_match_t match;
 755   const vnet_hw_interface_t *hw;
 756
 757   match.vlan = vlan;
 758   match.dot1ad = dot1ad;
 759   match.matched_sw_if_index = INDEX_INVALID;
 760   hw = vnet_get_sup_hw_interface (vnet_get_main (), sup_if_index);
 761
 762   vnet_hw_interface_walk_sw (vnet_get_main (), hw->hw_if_index,
 763                              lcp_itf_pair_find_walk, &match);
 764
 765   if (match.matched_sw_if_index >= vec_len (lip_db_by_phy))
 766     return INDEX_INVALID;
 767
 768   return lip_db_by_phy[match.matched_sw_if_index];
 769 }
 770
 771 static clib_error_t *lcp_itf_pair_link_up_down (vnet_main_t *vnm,
 772                                                 u32 hw_if_index, u32 flags);
 773
 774 int
 775 lcp_itf_pair_create (u32 phy_sw_if_index, u8 *host_if_name,
 776                      lip_host_type_t host_if_type, u8 *ns,
 777                      u32 *host_sw_if_indexp)
 778 {
 779   vlib_main_t *vm;
 780   vnet_main_t *vnm;
 781   u32 vif_index = 0, host_sw_if_index = ~0;
 782   const vnet_sw_interface_t *sw;
 783   const vnet_hw_interface_t *hw;
 784   const lcp_itf_pair_t *lip;
 785   index_t lipi;
 786
 787   lipi = lcp_itf_pair_find_by_phy (phy_sw_if_index);
 788
 789   if (lipi != INDEX_INVALID)
 790     {
 791       LCP_ITF_PAIR_ERR ("pair_create: already created");
 792       return VNET_API_ERROR_VALUE_EXIST;
 793     }
 794
 795   if (!vnet_sw_if_index_is_api_valid (phy_sw_if_index))
 796     {
 797       LCP_ITF_PAIR_ERR ("pair_create: invalid phy index %u", phy_sw_if_index);
 798       return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 799     }
 800
 801   if (!lcp_validate_if_name (host_if_name))
 802     {
 803       LCP_ITF_PAIR_ERR ("pair_create: invalid host-if-name '%s'",
 804                         host_if_name);
 805       return VNET_API_ERROR_INVALID_ARGUMENT;
 806     }
 807
 808   vnm = vnet_get_main ();
 809   sw = vnet_get_sw_interface (vnm, phy_sw_if_index);
 810   hw = vnet_get_sup_hw_interface (vnm, phy_sw_if_index);
 811   if (!sw || !hw)
 812     {
 813       LCP_ITF_PAIR_ERR ("pair_create: invalid interface");
 814       return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 815     }
 816
 817   if (hw->hw_class_index != ethernet_hw_interface_class.index &&
 818       host_if_type == LCP_ITF_HOST_TAP)
 819     {
 820       LCP_ITF_PAIR_ERR (
 821         "pair_create: don't create TAP for non-eth interface; use tun");
 822       return VNET_API_ERROR_INVALID_ARGUMENT;
 823     }
 824
 825   /*
 826    * Use interface-specific netns if supplied.
 827    * Otherwise, use netns if defined, otherwise use the OS default.
 828    */
 829   if (ns == 0 || ns[0] == 0)
 830     ns = lcp_get_default_ns ();
 831
 832   /* sub interfaces do not need a tap created */
 833   if (vnet_sw_interface_is_sub (vnm, phy_sw_if_index))
 834     {
 835       index_t parent_if_index;
 836       int orig_ns_fd, ns_fd;
 837       clib_error_t *err;
 838       u16 outer_vlan, inner_vlan;
 839       u16 outer_proto, inner_proto;
 840       u16 vlan, proto;
 841       u32 parent_vif_index;
 842
 843       err = vnet_sw_interface_supports_addressing (vnm, phy_sw_if_index);
 844       if (err)
 845         {
 846           LCP_ITF_PAIR_ERR ("pair_create: can't create LCP for a "
 847                             "sub-interface without exact-match set");
 848           return VNET_API_ERROR_INVALID_ARGUMENT;
 849         }
 850
 851       outer_vlan = sw->sub.eth.outer_vlan_id;
 852       inner_vlan = sw->sub.eth.inner_vlan_id;
 853       outer_proto = inner_proto = ETH_P_8021Q;
 854       if (1 == sw->sub.eth.flags.dot1ad)
 855         outer_proto = ETH_P_8021AD;
 856
 857       LCP_ITF_PAIR_INFO ("pair_create: subif: dot1%s outer %d inner %d on %U",
 858                          sw->sub.eth.flags.dot1ad ? "ad" : "q", outer_vlan,
 859                          inner_vlan, format_vnet_sw_if_index_name, vnm,
 860                          hw->sw_if_index);
 861
 862       parent_if_index = lcp_itf_pair_find_by_phy (sw->sup_sw_if_index);
 863       if (INDEX_INVALID == parent_if_index)
 864         {
 865           LCP_ITF_PAIR_ERR ("pair_create: can't find LCP for %U",
 866                             format_vnet_sw_if_index_name, vnet_get_main (),
 867                             sw->sup_sw_if_index);
 868           return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 869         }
 870       lip = lcp_itf_pair_get (parent_if_index);
 871       if (!lip)
 872         {
 873           LCP_ITF_PAIR_ERR ("pair_create: can't create LCP for a "
 874                             "sub-interface without an LCP on the parent");
 875           return VNET_API_ERROR_INVALID_ARGUMENT;
 876         }
 877       LCP_ITF_PAIR_DBG ("pair_create: parent %U", format_lcp_itf_pair, lip);
 878       parent_vif_index = lip->lip_vif_index;
 879
 880       /*
 881        * see if the requested host interface has already been created
 882        */
 883       orig_ns_fd = ns_fd = -1;
 884       err = NULL;
 885
 886       if (ns && ns[0] != 0)
 887         {
 888           orig_ns_fd = clib_netns_open (NULL /* self */);
 889           ns_fd = clib_netns_open (ns);
 890           if (orig_ns_fd == -1 || ns_fd == -1)
 891             goto socket_close;
 892
 893           clib_setns (ns_fd);
 894         }
 895
 896       vif_index = if_nametoindex ((const char *) host_if_name);
 897
 898       if (!vif_index)
 899         {
 900           /*
 901            * no existing host interface, create it now
 902            */
 903
 904           /*
 905            * Find the parent tap:
 906            * - if this is an outer VLAN, use the pair from the parent phy
 907            * - if this is an inner VLAN, find the pair from the outer sub-int,
 908            * which must exist.
 909            */
 910           if (inner_vlan)
 911             {
 912               index_t linux_parent_if_index;
 913               const lcp_itf_pair_t *llip;
 914
 915               vlan = inner_vlan;
 916               proto = inner_proto;
 917               linux_parent_if_index = lcp_itf_pair_find_by_outer_vlan (
 918                 hw->sw_if_index, sw->sub.eth.outer_vlan_id,
 919                 sw->sub.eth.flags.dot1ad);
 920               if (INDEX_INVALID == linux_parent_if_index ||
 921                   !(llip = lcp_itf_pair_get (linux_parent_if_index)))
 922                 {
 923                   LCP_ITF_PAIR_ERR (
 924                     "pair_create: can't find LCP for outer vlan %d "
 925                     "proto %s on %U",
 926                     outer_vlan,
 927                     outer_proto == ETH_P_8021AD ? "dot1ad" : "dot1q",
 928                     format_vnet_sw_if_index_name, vnm, hw->sw_if_index);
 929                   err = clib_error_return (0, "parent pair not found");
 930                   goto socket_close;
 931                 }
 932
 933               LCP_ITF_PAIR_DBG ("pair_create: linux parent %U",
 934                                 format_lcp_itf_pair, llip);
 935               parent_vif_index = llip->lip_vif_index;
 936             }
 937           else
 938             {
 939               vlan = outer_vlan;
 940               proto = outer_proto;
 941             }
 942
 943           err = lcp_netlink_add_link_vlan (parent_vif_index, vlan, proto,
 944                                            (const char *) host_if_name);
 945           if (err != 0)
 946             {
 947               LCP_ITF_PAIR_ERR ("pair_create: cannot create link "
 948                                 "outer(proto:0x%04x,vlan:%u).inner(proto:0x%"
 949                                 "04x,vlan:%u) name:'%s'",
 950                                 outer_proto, outer_vlan, inner_proto,
 951                                 inner_vlan, host_if_name);
 952             }
 953
 954           if (!err)
 955             vif_index = if_nametoindex ((char *) host_if_name);
 956         }
 957
 958       /*
 959        * create a sub-interface on the tap
 960        */
 961       if (!err &&
 962           vnet_create_sub_interface (lip->lip_host_sw_if_index, sw->sub.id,
 963                                      sw->sub.eth.raw_flags, inner_vlan,
 964                                      outer_vlan, &host_sw_if_index))
 965         {
 966           LCP_ITF_PAIR_ERR (
 967             "pair_create: failed to create tap subint: %d.%d on %U",
 968             outer_vlan, inner_vlan, format_vnet_sw_if_index_name, vnm,
 969             lip->lip_host_sw_if_index);
 970           err = clib_error_return (
 971             0, "failed to create tap subint: %d.%d. on %U", outer_vlan,
 972             inner_vlan, format_vnet_sw_if_index_name, vnm,
 973             lip->lip_host_sw_if_index);
 974         }
 975
 976     socket_close:
 977       if (orig_ns_fd != -1)
 978         {
 979           clib_setns (orig_ns_fd);
 980           close (orig_ns_fd);
 981         }
 982       if (ns_fd != -1)
 983         close (ns_fd);
 984
 985       if (err)
 986         return VNET_API_ERROR_INVALID_ARGUMENT;
 987     }
 988   else
 989     {
 990       tap_create_if_args_t args = {
 991         .num_rx_queues = clib_max (1, vlib_num_workers ()),
 992         .num_tx_queues = 1,
 993         .id = hw->hw_if_index,
 994         .sw_if_index = ~0,
 995         .rx_ring_sz = 256,
 996         .tx_ring_sz = 256,
 997         .host_if_name = host_if_name,
 998         .host_namespace = 0,
 999         .rv = 0,
1000         .error = NULL,
1001       };
1002       ethernet_interface_t *ei;
1003       u32 host_sw_mtu_size;
1004
1005       if (host_if_type == LCP_ITF_HOST_TUN)
1006         args.tap_flags |= TAP_FLAG_TUN;
1007       else
1008         {
1009           ei = pool_elt_at_index (ethernet_main.interfaces, hw->hw_instance);
1010           mac_address_copy (&args.host_mac_addr, &ei->address.mac);
1011         }
1012
1013       /*
1014        * The TAP interface does copy forward the host MTU based on the VPP
1015        * interface's L3 MTU, but it should also ensure that the VPP tap
1016        * interface has an MTU that is greater-or-equal to those. Considering
1017        * users can set the interfaces at runtime (set interface mtu packet ...)
1018        * ensure that the tap MTU is large enough, taking the VPP interface L3
1019        * if it's set, and otherwise a sensible default.
1020        */
1021       host_sw_mtu_size = sw->mtu[VNET_MTU_L3];
1022       if (host_sw_mtu_size)
1023         {
1024           args.host_mtu_set = 1;
1025           args.host_mtu_size = host_sw_mtu_size;
1026         }
1027       else
1028         host_sw_mtu_size = ETHERNET_MAX_PACKET_BYTES;
1029
1030       if (ns && ns[0] != 0)
1031         args.host_namespace = ns;
1032
1033       vm = vlib_get_main ();
1034       tap_create_if (vm, &args);
1035       if (args.rv < 0)
1036         {
1037           LCP_ITF_PAIR_ERR ("pair_create: could not create tap, retval:%d",
1038                             args.rv);
1039           clib_error_free (args.error);
1040           return args.rv;
1041         }
1042
1043       vnet_sw_interface_set_mtu (vnm, args.sw_if_index, host_sw_mtu_size);
1044
1045       /*
1046        * get the hw and ethernet of the tap
1047        */
1048       hw = vnet_get_sup_hw_interface (vnm, args.sw_if_index);
1049       virtio_main_t *mm = &virtio_main;
1050       virtio_if_t *vif = pool_elt_at_index (mm->interfaces, hw->dev_instance);
1051
1052       /*
1053        * Leave the TAP permanently up on the VPP side.
1054        * This TAP will be shared by many sub-interface.
1055        * Therefore we can't use it to manage admin state.
1056        * force the tap in promiscuous mode.
1057        */
1058       if (host_if_type == LCP_ITF_HOST_TAP)
1059         {
1060           ei = pool_elt_at_index (ethernet_main.interfaces, hw->hw_instance);
1061           ei->flags |= ETHERNET_INTERFACE_FLAG_STATUS_L3;
1062         }
1063
1064       vif_index = vif->ifindex;
1065       host_sw_if_index = args.sw_if_index;
1066     }
1067
1068   if (!vif_index)
1069     {
1070       LCP_ITF_PAIR_INFO ("failed pair add (no vif index): {%U, %U, %s}",
1071                          format_vnet_sw_if_index_name, vnet_get_main (),
1072                          phy_sw_if_index, format_vnet_sw_if_index_name,
1073                          vnet_get_main (), host_sw_if_index, host_if_name);
1074       return -1;
1075     }
1076
1077   LCP_ITF_PAIR_INFO ("pair create: {%U, %U, %s}", format_vnet_sw_if_index_name,
1078                      vnet_get_main (), phy_sw_if_index,
1079                      format_vnet_sw_if_index_name, vnet_get_main (),
1080                      host_sw_if_index, host_if_name);
1081   lcp_itf_pair_add (host_sw_if_index, phy_sw_if_index, host_if_name, vif_index,
1082                     host_if_type, ns);
1083
1084   /*
1085    * Copy the link state from VPP into the host side.
1086    * The TAP is shared by many interfaces, always keep it up.
1087    * This controls whether the host can RX/TX.
1088    */
1089   sw = vnet_get_sw_interface (vnm, phy_sw_if_index);
1090   lip = lcp_itf_pair_get (lcp_itf_pair_find_by_vif (vif_index));
1091   LCP_ITF_PAIR_INFO ("pair create: %U sw-flags %u hw-flags %u",
1092                      format_lcp_itf_pair, lip, sw->flags, hw->flags);
1093   vnet_sw_interface_admin_up (vnm, host_sw_if_index);
1094   lcp_itf_set_link_state (lip, sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP);
1095
1096   /*
1097    * Reflect current link state and link speed of the hardware interface on the
1098    * TAP interface.
1099    */
1100   if (host_if_type == LCP_ITF_HOST_TAP &&
1101       !vnet_sw_interface_is_sub (vnm, phy_sw_if_index))
1102     {
1103       hw = vnet_get_sup_hw_interface (vnm, phy_sw_if_index);
1104       lcp_itf_pair_link_up_down (vnm, hw->hw_if_index, hw->flags);
1105     }
1106
1107   if (host_sw_if_indexp)
1108     *host_sw_if_indexp = host_sw_if_index;
1109
1110   return 0;
1111 }
1112
1113 static walk_rc_t
1114 lcp_itf_pair_walk_mark (index_t lipi, void *ctx)
1115 {
1116   lcp_itf_pair_t *lip;
1117
1118   lip = lcp_itf_pair_get (lipi);
1119
1120   lip->lip_flags |= LIP_FLAG_STALE;
1121
1122   return (WALK_CONTINUE);
1123 }
1124
1125 int
1126 lcp_itf_pair_replace_begin (void)
1127 {
1128   lcp_itf_pair_walk (lcp_itf_pair_walk_mark, NULL);
1129
1130   return (0);
1131 }
1132
1133 typedef struct lcp_itf_pair_sweep_ctx_t_
1134 {
1135   index_t *indicies;
1136 } lcp_itf_pair_sweep_ctx_t;
1137
1138 static walk_rc_t
1139 lcp_itf_pair_walk_sweep (index_t lipi, void *arg)
1140 {
1141   lcp_itf_pair_sweep_ctx_t *ctx = arg;
1142   lcp_itf_pair_t *lip;
1143
1144   lip = lcp_itf_pair_get (lipi);
1145
1146   if (lip->lip_flags & LIP_FLAG_STALE)
1147     vec_add1 (ctx->indicies, lipi);
1148
1149   return (WALK_CONTINUE);
1150 }
1151
1152 int
1153 lcp_itf_pair_replace_end (void)
1154 {
1155   lcp_itf_pair_sweep_ctx_t ctx = {
1156     .indicies = NULL,
1157   };
1158   index_t *lipi;
1159
1160   lcp_itf_pair_walk (lcp_itf_pair_walk_sweep, &ctx);
1161
1162   vec_foreach (lipi, ctx.indicies)
1163     lcp_itf_pair_delete_by_index (*lipi);
1164
1165   vec_free (ctx.indicies);
1166   return (0);
1167 }
1168
1169 static clib_error_t *
1170 lcp_itf_pair_link_up_down (vnet_main_t *vnm, u32 hw_if_index, u32 flags)
1171 {
1172   vnet_hw_interface_t *hi;
1173   vnet_sw_interface_t *si;
1174   index_t lipi;
1175   lcp_itf_pair_t *lip;
1176
1177   hi = vnet_get_hw_interface_or_null (vnm, hw_if_index);
1178   if (!hi)
1179     return 0;
1180
1181   lipi = lcp_itf_pair_find_by_phy (hi->sw_if_index);
1182   if (lipi == INDEX_INVALID)
1183     return 0;
1184
1185   lip = lcp_itf_pair_get (lipi);
1186   si = vnet_get_sw_interface_or_null (vnm, lip->lip_host_sw_if_index);
1187   if (!si)
1188     return 0;
1189
1190   if (!lcp_main.test_mode)
1191     {
1192       tap_set_carrier (si->hw_if_index,
1193                        (flags & VNET_HW_INTERFACE_FLAG_LINK_UP));
1194
1195       if (flags & VNET_HW_INTERFACE_FLAG_LINK_UP &&
1196           hi->link_speed != UINT32_MAX)
1197         {
1198           tap_set_speed (si->hw_if_index, hi->link_speed / 1000);
1199         }
1200     }
1201
1202   return 0;
1203 }
1204
1205 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (lcp_itf_pair_link_up_down);
1206
1207 static clib_error_t *
1208 lcp_interface_init (vlib_main_t *vm)
1209 {
1210   vlib_punt_hdl_t punt_hdl = vlib_punt_client_register ("linux-cp");
1211
1212   /* punt IKE */
1213   vlib_punt_register (punt_hdl, ipsec_punt_reason[IPSEC_PUNT_IP4_SPI_UDP_0],
1214                       "linux-cp-punt");
1215   vlib_punt_register (punt_hdl, ipsec_punt_reason[IPSEC_PUNT_IP6_SPI_UDP_0],
1216                       "linux-cp-punt");
1217
1218   /* punt all unknown ports */
1219   udp_punt_unknown (vm, 0, 1);
1220   udp_punt_unknown (vm, 1, 1);
1221   tcp_punt_unknown (vm, 0, 1);
1222   tcp_punt_unknown (vm, 1, 1);
1223
1224   lcp_itf_pair_logger = vlib_log_register_class ("linux-cp", "itf");
1225
1226   return NULL;
1227 }
1228
1229 VLIB_INIT_FUNCTION (lcp_interface_init) = {
1230   .runs_after = VLIB_INITS ("vnet_interface_init", "tcp_init", "udp_init"),
1231 };
1232
1233 /*
1234  * fd.io coding-style-patch-verification: ON
1235  *
1236  * Local Variables:
1237  * eval: (c-set-style "gnu")
1238  * End:
1239  */