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:%s vif:%d ns:%s",
 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;
 782   const vnet_sw_interface_t *sw;
 783   const vnet_hw_interface_t *hw;
 784   const lcp_itf_pair_t *lip;
 785
 786   if (!vnet_sw_if_index_is_api_valid (phy_sw_if_index))
 787     {
 788       LCP_ITF_PAIR_ERR ("pair_create: invalid phy index %u", phy_sw_if_index);
 789       return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 790     }
 791
 792   if (!lcp_validate_if_name (host_if_name))
 793     {
 794       LCP_ITF_PAIR_ERR ("pair_create: invalid host-if-name '%s'",
 795                         host_if_name);
 796       return VNET_API_ERROR_INVALID_ARGUMENT;
 797     }
 798
 799   vnm = vnet_get_main ();
 800   sw = vnet_get_sw_interface (vnm, phy_sw_if_index);
 801   hw = vnet_get_sup_hw_interface (vnm, phy_sw_if_index);
 802   if (!sw || !hw)
 803     {
 804       LCP_ITF_PAIR_ERR ("pair_create: invalid interface");
 805       return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 806     }
 807
 808   /*
 809    * Use interface-specific netns if supplied.
 810    * Otherwise, use netns if defined, otherwise use the OS default.
 811    */
 812   if (ns == 0 || ns[0] == 0)
 813     ns = lcp_get_default_ns ();
 814
 815   /* sub interfaces do not need a tap created */
 816   if (vnet_sw_interface_is_sub (vnm, phy_sw_if_index))
 817     {
 818       index_t parent_if_index;
 819       int orig_ns_fd, ns_fd;
 820       clib_error_t *err;
 821       u16 outer_vlan, inner_vlan;
 822       u16 outer_proto, inner_proto;
 823       u16 vlan, proto;
 824       u32 parent_vif_index;
 825
 826       err = vnet_sw_interface_supports_addressing (vnm, phy_sw_if_index);
 827       if (err)
 828         {
 829           LCP_ITF_PAIR_ERR ("pair_create: can't create LCP for a "
 830                             "sub-interface without exact-match set");
 831           return VNET_API_ERROR_INVALID_ARGUMENT;
 832         }
 833
 834       outer_vlan = sw->sub.eth.outer_vlan_id;
 835       inner_vlan = sw->sub.eth.inner_vlan_id;
 836       outer_proto = inner_proto = ETH_P_8021Q;
 837       if (1 == sw->sub.eth.flags.dot1ad)
 838         outer_proto = ETH_P_8021AD;
 839
 840       LCP_ITF_PAIR_INFO ("pair_create: subif: dot1%s outer %d inner %d on %U",
 841                          sw->sub.eth.flags.dot1ad ? "ad" : "q", outer_vlan,
 842                          inner_vlan, format_vnet_sw_if_index_name, vnm,
 843                          hw->sw_if_index);
 844
 845       parent_if_index = lcp_itf_pair_find_by_phy (sw->sup_sw_if_index);
 846       if (INDEX_INVALID == parent_if_index)
 847         {
 848           LCP_ITF_PAIR_ERR ("pair_create: can't find LCP for %U",
 849                             format_vnet_sw_if_index_name, vnet_get_main (),
 850                             sw->sup_sw_if_index);
 851           return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 852         }
 853       lip = lcp_itf_pair_get (parent_if_index);
 854       if (!lip)
 855         {
 856           LCP_ITF_PAIR_ERR ("pair_create: can't create LCP for a "
 857                             "sub-interface without an LCP on the parent");
 858           return VNET_API_ERROR_INVALID_ARGUMENT;
 859         }
 860       LCP_ITF_PAIR_DBG ("pair_create: parent %U", format_lcp_itf_pair, lip);
 861       parent_vif_index = lip->lip_vif_index;
 862
 863       /*
 864        * see if the requested host interface has already been created
 865        */
 866       orig_ns_fd = ns_fd = -1;
 867       err = NULL;
 868
 869       if (ns && ns[0] != 0)
 870         {
 871           orig_ns_fd = clib_netns_open (NULL /* self */);
 872           ns_fd = clib_netns_open (ns);
 873           if (orig_ns_fd == -1 || ns_fd == -1)
 874             goto socket_close;
 875
 876           clib_setns (ns_fd);
 877         }
 878
 879       vif_index = if_nametoindex ((const char *) host_if_name);
 880
 881       if (!vif_index)
 882         {
 883           /*
 884            * no existing host interface, create it now
 885            */
 886
 887           /*
 888            * Find the parent tap:
 889            * - if this is an outer VLAN, use the pair from the parent phy
 890            * - if this is an inner VLAN, find the pair from the outer sub-int,
 891            * which must exist.
 892            */
 893           if (inner_vlan)
 894             {
 895               index_t linux_parent_if_index;
 896               const lcp_itf_pair_t *llip;
 897
 898               vlan = inner_vlan;
 899               proto = inner_proto;
 900               linux_parent_if_index = lcp_itf_pair_find_by_outer_vlan (
 901                 hw->sw_if_index, sw->sub.eth.outer_vlan_id,
 902                 sw->sub.eth.flags.dot1ad);
 903               if (INDEX_INVALID == linux_parent_if_index ||
 904                   !(llip = lcp_itf_pair_get (linux_parent_if_index)))
 905                 {
 906                   LCP_ITF_PAIR_ERR (
 907                     "pair_create: can't find LCP for outer vlan %d "
 908                     "proto %s on %U",
 909                     outer_vlan,
 910                     outer_proto == ETH_P_8021AD ? "dot1ad" : "dot1q",
 911                     format_vnet_sw_if_index_name, vnm, hw->sw_if_index);
 912                   err = clib_error_return (0, "parent pair not found");
 913                   goto socket_close;
 914                 }
 915
 916               LCP_ITF_PAIR_DBG ("pair_create: linux parent %U",
 917                                 format_lcp_itf_pair, llip);
 918               parent_vif_index = llip->lip_vif_index;
 919             }
 920           else
 921             {
 922               vlan = outer_vlan;
 923               proto = outer_proto;
 924             }
 925
 926           err = lcp_netlink_add_link_vlan (parent_vif_index, vlan, proto,
 927                                            (const char *) host_if_name);
 928           if (err != 0)
 929             {
 930               LCP_ITF_PAIR_ERR ("pair_create: cannot create link "
 931                                 "outer(proto:0x%04x,vlan:%u).inner(proto:0x%"
 932                                 "04x,vlan:%u) name:'%s'",
 933                                 outer_proto, outer_vlan, inner_proto,
 934                                 inner_vlan, host_if_name);
 935             }
 936
 937           if (!err)
 938             vif_index = if_nametoindex ((char *) host_if_name);
 939         }
 940
 941       /*
 942        * create a sub-interface on the tap
 943        */
 944       if (!err &&
 945           vnet_create_sub_interface (lip->lip_host_sw_if_index, sw->sub.id,
 946                                      sw->sub.eth.raw_flags, inner_vlan,
 947                                      outer_vlan, &host_sw_if_index))
 948         {
 949           LCP_ITF_PAIR_ERR (
 950             "pair_create: failed to create tap subint: %d.%d on %U",
 951             outer_vlan, inner_vlan, format_vnet_sw_if_index_name, vnm,
 952             lip->lip_host_sw_if_index);
 953           err = clib_error_return (
 954             0, "failed to create tap subint: %d.%d. on %U", outer_vlan,
 955             inner_vlan, format_vnet_sw_if_index_name, vnm,
 956             lip->lip_host_sw_if_index);
 957         }
 958
 959     socket_close:
 960       if (orig_ns_fd != -1)
 961         {
 962           clib_setns (orig_ns_fd);
 963           close (orig_ns_fd);
 964         }
 965       if (ns_fd != -1)
 966         close (ns_fd);
 967
 968       if (err)
 969         return VNET_API_ERROR_INVALID_ARGUMENT;
 970     }
 971   else
 972     {
 973       tap_create_if_args_t args = {
 974         .num_rx_queues = clib_max (1, vlib_num_workers ()),
 975         .num_tx_queues = 1,
 976         .id = hw->hw_if_index,
 977         .sw_if_index = ~0,
 978         .rx_ring_sz = 256,
 979         .tx_ring_sz = 256,
 980         .host_if_name = host_if_name,
 981         .host_namespace = 0,
 982       };
 983       ethernet_interface_t *ei;
 984
 985       if (host_if_type == LCP_ITF_HOST_TUN)
 986         args.tap_flags |= TAP_FLAG_TUN;
 987       else
 988         {
 989           ei = pool_elt_at_index (ethernet_main.interfaces, hw->hw_instance);
 990           mac_address_copy (&args.host_mac_addr, &ei->address.mac);
 991         }
 992
 993       if (sw->mtu[VNET_MTU_L3])
 994         {
 995           args.host_mtu_set = 1;
 996           args.host_mtu_size = sw->mtu[VNET_MTU_L3];
 997         }
 998
 999       if (ns && ns[0] != 0)
1000         args.host_namespace = ns;
1001
1002       vm = vlib_get_main ();
1003       tap_create_if (vm, &args);
1004
1005       if (args.rv < 0)
1006         {
1007           LCP_ITF_PAIR_ERR ("pair_create: could not create tap, retval:%d",
1008                             args.rv);
1009           return args.rv;
1010         }
1011
1012       /*
1013        * The TAP interface does copy forward the host MTU based on the VPP
1014        * interface's L3 MTU, but it should also ensure that the VPP tap
1015        * interface has an MTU that is greater-or-equal to those. Considering
1016        * users can set the interfaces at runtime (set interface mtu packet ...)
1017        * ensure that the tap MTU is large enough, taking the VPP interface L3
1018        * if it's set, and otherwise a sensible default.
1019        */
1020       if (sw->mtu[VNET_MTU_L3])
1021         vnet_sw_interface_set_mtu (vnm, args.sw_if_index,
1022                                    sw->mtu[VNET_MTU_L3]);
1023       else
1024         vnet_sw_interface_set_mtu (vnm, args.sw_if_index,
1025                                    ETHERNET_MAX_PACKET_BYTES);
1026
1027       /*
1028        * get the hw and ethernet of the tap
1029        */
1030       hw = vnet_get_sup_hw_interface (vnm, args.sw_if_index);
1031       virtio_main_t *mm = &virtio_main;
1032       virtio_if_t *vif = pool_elt_at_index (mm->interfaces, hw->dev_instance);
1033
1034       /*
1035        * Leave the TAP permanently up on the VPP side.
1036        * This TAP will be shared by many sub-interface.
1037        * Therefore we can't use it to manage admin state.
1038        * force the tap in promiscuous mode.
1039        */
1040       if (host_if_type == LCP_ITF_HOST_TAP)
1041         {
1042           ei = pool_elt_at_index (ethernet_main.interfaces, hw->hw_instance);
1043           ei->flags |= ETHERNET_INTERFACE_FLAG_STATUS_L3;
1044         }
1045
1046       vif_index = vif->ifindex;
1047       host_sw_if_index = args.sw_if_index;
1048     }
1049
1050   if (!vif_index)
1051     {
1052       LCP_ITF_PAIR_INFO ("failed pair add (no vif index): {%U, %U, %s}",
1053                          format_vnet_sw_if_index_name, vnet_get_main (),
1054                          phy_sw_if_index, format_vnet_sw_if_index_name,
1055                          vnet_get_main (), host_sw_if_index, host_if_name);
1056       return -1;
1057     }
1058
1059   LCP_ITF_PAIR_INFO ("pair create: {%U, %U, %s}", format_vnet_sw_if_index_name,
1060                      vnet_get_main (), phy_sw_if_index,
1061                      format_vnet_sw_if_index_name, vnet_get_main (),
1062                      host_sw_if_index, host_if_name);
1063   lcp_itf_pair_add (host_sw_if_index, phy_sw_if_index, host_if_name, vif_index,
1064                     host_if_type, ns);
1065
1066   /*
1067    * Copy the link state from VPP into the host side.
1068    * The TAP is shared by many interfaces, always keep it up.
1069    * This controls whether the host can RX/TX.
1070    */
1071
1072   lip = lcp_itf_pair_get (lcp_itf_pair_find_by_vif (vif_index));
1073   LCP_ITF_PAIR_INFO ("pair create: %U sw-flags %u hw-flags %u",
1074                      format_lcp_itf_pair, lip, sw->flags, hw->flags);
1075   vnet_sw_interface_admin_up (vnm, host_sw_if_index);
1076   lcp_itf_set_link_state (lip, sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP);
1077
1078   /*
1079    * Reflect current link state and link speed of the hardware interface on the
1080    * TAP interface.
1081    */
1082   if (host_if_type == LCP_ITF_HOST_TAP &&
1083       !vnet_sw_interface_is_sub (vnm, phy_sw_if_index))
1084     {
1085       hw = vnet_get_sup_hw_interface (vnm, phy_sw_if_index);
1086       lcp_itf_pair_link_up_down (vnm, hw->hw_if_index, hw->flags);
1087     }
1088
1089   if (host_sw_if_indexp)
1090     *host_sw_if_indexp = host_sw_if_index;
1091
1092   return 0;
1093 }
1094
1095 static walk_rc_t
1096 lcp_itf_pair_walk_mark (index_t lipi, void *ctx)
1097 {
1098   lcp_itf_pair_t *lip;
1099
1100   lip = lcp_itf_pair_get (lipi);
1101
1102   lip->lip_flags |= LIP_FLAG_STALE;
1103
1104   return (WALK_CONTINUE);
1105 }
1106
1107 int
1108 lcp_itf_pair_replace_begin (void)
1109 {
1110   lcp_itf_pair_walk (lcp_itf_pair_walk_mark, NULL);
1111
1112   return (0);
1113 }
1114
1115 typedef struct lcp_itf_pair_sweep_ctx_t_
1116 {
1117   index_t *indicies;
1118 } lcp_itf_pair_sweep_ctx_t;
1119
1120 static walk_rc_t
1121 lcp_itf_pair_walk_sweep (index_t lipi, void *arg)
1122 {
1123   lcp_itf_pair_sweep_ctx_t *ctx = arg;
1124   lcp_itf_pair_t *lip;
1125
1126   lip = lcp_itf_pair_get (lipi);
1127
1128   if (lip->lip_flags & LIP_FLAG_STALE)
1129     vec_add1 (ctx->indicies, lipi);
1130
1131   return (WALK_CONTINUE);
1132 }
1133
1134 int
1135 lcp_itf_pair_replace_end (void)
1136 {
1137   lcp_itf_pair_sweep_ctx_t ctx = {
1138     .indicies = NULL,
1139   };
1140   index_t *lipi;
1141
1142   lcp_itf_pair_walk (lcp_itf_pair_walk_sweep, &ctx);
1143
1144   vec_foreach (lipi, ctx.indicies)
1145     lcp_itf_pair_delete_by_index (*lipi);
1146
1147   vec_free (ctx.indicies);
1148   return (0);
1149 }
1150
1151 static clib_error_t *
1152 lcp_itf_pair_link_up_down (vnet_main_t *vnm, u32 hw_if_index, u32 flags)
1153 {
1154   vnet_hw_interface_t *hi;
1155   vnet_sw_interface_t *si;
1156   index_t lipi;
1157   lcp_itf_pair_t *lip;
1158
1159   hi = vnet_get_hw_interface_or_null (vnm, hw_if_index);
1160   if (!hi)
1161     return 0;
1162
1163   lipi = lcp_itf_pair_find_by_phy (hi->sw_if_index);
1164   if (lipi == INDEX_INVALID)
1165     return 0;
1166
1167   lip = lcp_itf_pair_get (lipi);
1168   si = vnet_get_sw_interface_or_null (vnm, lip->lip_host_sw_if_index);
1169   if (!si)
1170     return 0;
1171
1172   if (!lcp_main.test_mode)
1173     {
1174       tap_set_carrier (si->hw_if_index,
1175                        (flags & VNET_HW_INTERFACE_FLAG_LINK_UP));
1176
1177       if (flags & VNET_HW_INTERFACE_FLAG_LINK_UP)
1178         {
1179           tap_set_speed (si->hw_if_index, hi->link_speed / 1000);
1180         }
1181     }
1182
1183   return 0;
1184 }
1185
1186 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION (lcp_itf_pair_link_up_down);
1187
1188 static clib_error_t *
1189 lcp_interface_init (vlib_main_t *vm)
1190 {
1191   vlib_punt_hdl_t punt_hdl = vlib_punt_client_register ("linux-cp");
1192
1193   /* punt IKE */
1194   vlib_punt_register (punt_hdl, ipsec_punt_reason[IPSEC_PUNT_IP4_SPI_UDP_0],
1195                       "linux-cp-punt");
1196
1197   /* punt all unknown ports */
1198   udp_punt_unknown (vm, 0, 1);
1199   udp_punt_unknown (vm, 1, 1);
1200   tcp_punt_unknown (vm, 0, 1);
1201   tcp_punt_unknown (vm, 1, 1);
1202
1203   lcp_itf_pair_logger = vlib_log_register_class ("linux-cp", "itf");
1204
1205   return NULL;
1206 }
1207
1208 VLIB_INIT_FUNCTION (lcp_interface_init) = {
1209   .runs_after = VLIB_INITS ("vnet_interface_init", "tcp_init", "udp_init"),
1210 };
1211
1212 /*
1213  * fd.io coding-style-patch-verification: ON
1214  *
1215  * Local Variables:
1216  * eval: (c-set-style "gnu")
1217  * End:
1218  */