src/plugins/stn/stn.c

   1 /*
   2  * Copyright (c) 2017 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 #include <stn/stn.h>
  17
  18 #include <vnet/plugin/plugin.h>
  19 #include <vpp/app/version.h>
  20 #include <vnet/ip/format.h>
  21 #include <vnet/ethernet/packet.h>
  22 #include <vnet/udp/udp.h>
  23 #include <vnet/tcp/tcp.h>
  24
  25 stn_main_t stn_main;
  26 static vlib_node_registration_t stn_ip4_punt;
  27 static vlib_node_registration_t stn_ip6_punt;
  28
  29 static u8 stn_hw_addr_local[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
  30 static u8 stn_hw_addr_dst[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
  31
  32 static ethernet_header_t stn_ip4_ethernet_header = {};
  33 static ethernet_header_t stn_ip6_ethernet_header = {};
  34
  35 typedef struct {
  36   clib_bihash_kv_16_8_t kv;
  37 } stn_ip46_punt_trace_t;
  38
  39 static u8 *
  40 format_stn_rule (u8 * s, va_list * args)
  41 {
  42   stn_rule_t *r = va_arg (*args, stn_rule_t *);
  43   stn_main_t *stn = &stn_main;
  44   u32 indent = format_get_indent (s);
  45   u32 node_index = ip46_address_is_ip4(&r->address)?stn_ip4_punt.index:stn_ip6_punt.index;
  46   vlib_node_t *next_node = vlib_get_next_node(vlib_get_main(), node_index, r->next_node_index);
  47   s = format (s, "rule_index: %d\n", r - stn->rules);
  48   s = format (s, "%Uaddress: %U\n", format_white_space, indent,
  49               format_ip46_address, &r->address, IP46_TYPE_ANY);
  50   s = format (s, "%Uiface: %U (%d)\n", format_white_space, indent,
  51               format_vnet_sw_if_index_name, vnet_get_main(), r->sw_if_index,
  52               r->sw_if_index);
  53   s = format (s, "%Unext_node: %s (%d)", format_white_space, indent,
  54               next_node->name, next_node->index);
  55   return s;
  56 }
  57
  58 static_always_inline u8 *
  59 format_stn_ip46_punt_trace (u8 * s, va_list * args, u8 is_ipv4)
  60 {
  61   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  62   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  63   stn_ip46_punt_trace_t *t = va_arg (*args, stn_ip46_punt_trace_t *);
  64   u32 indent = format_get_indent (s);
  65
  66   format (s, "dst_address: %U\n", format_ip46_address,
  67           (ip46_address_t *)&t->kv.key, IP46_TYPE_ANY);
  68
  69   if (t->kv.value == ~(0L))
  70     {
  71       s = format (s, "%Urule: none", format_white_space, indent);
  72     }
  73   else
  74     {
  75       s = format (s, "%Urule:\n%U%U", format_white_space, indent,
  76                      format_white_space, indent + 2,
  77                      format_stn_rule, &stn_main.rules[t->kv.value]);
  78     }
  79   return s;
  80 }
  81
  82 static void
  83 stn_punt_fn (vlib_main_t * vm,
  84                    vlib_node_runtime_t * node, vlib_frame_t * frame)
  85 {
  86   u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
  87   stn_main_t *stn = &stn_main;
  88
  89   from = vlib_frame_vector_args (frame);
  90   n_left_from = frame->n_vectors;
  91   next_index = node->cached_next_index;
  92
  93   while (n_left_from > 0)
  94     {
  95       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
  96
  97       /* Single loop */
  98       while (n_left_from > 0 && n_left_to_next > 0)
  99         {
 100           u32 pi0;
 101           vlib_buffer_t *p0;
 102           u32 next0;
 103
 104           pi0 = to_next[0] = from[0];
 105           from += 1;
 106           n_left_from -= 1;
 107           to_next += 1;
 108           n_left_to_next -= 1;
 109
 110           p0 = vlib_get_buffer (vm, pi0);
 111
 112 /*
 113  * We are not guaranteed any particular layer here.
 114  * So we need to reparse from the beginning of the packet.
 115  * which may not start from zero with some DPDK drivers.
 116
 117           ip4_header_t *ip = vlib_buffer_get_current(p0);
 118           if ((ip->ip_version_and_header_length & 0xf0) == 0x40)
 119 *
 120 */
 121          int ethernet_header_offset = 0; /* to be filled by DPDK */
 122          ethernet_header_t *eth = (ethernet_header_t *)(p0->data + ethernet_header_offset);
 123          /* ensure the block current data starts at L3 boundary now for the subsequent nodes */
 124          vlib_buffer_advance(p0, ethernet_header_offset + sizeof(ethernet_header_t) - p0->current_data);
 125           if (clib_net_to_host_u16(eth->type) == ETHERNET_TYPE_IP4)
 126             next0 = stn->punt_to_stn_ip4_next_index;
 127           else
 128             next0 = stn->punt_to_stn_ip6_next_index;
 129
 130           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 131                                            n_left_to_next, pi0, next0);
 132         }
 133       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 134     }
 135 }
 136
 137 typedef enum
 138 {
 139   STN_IP_PUNT_DROP,
 140   STN_IP_PUNT_N_NEXT,
 141 } stn_ip_punt_next_t;
 142
 143 static_always_inline uword
 144 stn_ip46_punt_fn (vlib_main_t * vm,
 145                    vlib_node_runtime_t * node, vlib_frame_t * frame,
 146                    u8 is_ipv4)
 147 {
 148   u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
 149   stn_main_t *stn = &stn_main;
 150
 151   from = vlib_frame_vector_args (frame);
 152   n_left_from = frame->n_vectors;
 153   next_index = node->cached_next_index;
 154
 155   while (n_left_from > 0)
 156     {
 157       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 158
 159       /* Single loop */
 160       while (n_left_from > 0 && n_left_to_next > 0)
 161         {
 162           u32 pi0;
 163           vlib_buffer_t *p0;
 164           clib_bihash_kv_16_8_t kv;
 165           u32 next0 = STN_IP_PUNT_DROP;
 166
 167           pi0 = to_next[0] = from[0];
 168           from += 1;
 169           n_left_from -= 1;
 170           to_next += 1;
 171           n_left_to_next -= 1;
 172
 173           p0 = vlib_get_buffer (vm, pi0);
 174
 175           if (is_ipv4)
 176             {
 177               ip4_header_t *hdr = (ip4_header_t *) vlib_buffer_get_current(p0);
 178               ip46_address_set_ip4((ip46_address_t *)kv.key, &hdr->dst_address);
 179             }
 180           else
 181             {
 182               ip6_header_t *hdr = (ip6_header_t *) vlib_buffer_get_current(p0);
 183               kv.key[0] = hdr->dst_address.as_u64[0];
 184               kv.key[1] = hdr->dst_address.as_u64[1];
 185             }
 186
 187           kv.value = ~(0L);
 188           clib_bihash_search_inline_16_8 (&stn->rule_by_address_table, &kv);
 189           if (kv.value != ~(0L))
 190             {
 191               ethernet_header_t *eth;
 192               stn_rule_t *r = &stn->rules[kv.value];
 193               vnet_buffer(p0)->sw_if_index[VLIB_TX] = r->sw_if_index;
 194               next0 = r->next_node_index;
 195               vlib_buffer_advance(p0, -sizeof(*eth));
 196               eth = (ethernet_header_t *) vlib_buffer_get_current(p0);
 197               if (is_ipv4)
 198                 clib_memcpy(eth, &stn_ip4_ethernet_header, sizeof(*eth));
 199               else
 200                 clib_memcpy(eth, &stn_ip6_ethernet_header, sizeof(*eth));
 201             }
 202
 203           if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
 204             {
 205               stn_ip46_punt_trace_t *tr =
 206                   vlib_add_trace (vm, node, p0, sizeof (*tr));
 207               tr->kv = kv;
 208             }
 209
 210           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 211                                            n_left_to_next, pi0, next0);
 212         }
 213       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 214     }
 215
 216   return frame->n_vectors;
 217 }
 218
 219
 220 #define foreach_stn_ip_punt_error \
 221  _(NONE, "no error")
 222
 223 typedef enum {
 224 #define _(sym,str) STN_IP_punt_ERROR_##sym,
 225   foreach_stn_ip_punt_error
 226 #undef _
 227   STN_IP_PUNT_N_ERROR,
 228 } ila_error_t;
 229
 230 static char *stn_ip_punt_error_strings[] = {
 231 #define _(sym,string) string,
 232     foreach_stn_ip_punt_error
 233 #undef _
 234 };
 235
 236 u8 *
 237 format_stn_ip6_punt_trace (u8 * s, va_list * args)
 238 {
 239   return format_stn_ip46_punt_trace (s, args, 0);
 240 }
 241
 242 static uword
 243 stn_ip6_punt_fn (vlib_main_t * vm,
 244                    vlib_node_runtime_t * node, vlib_frame_t * frame)
 245 {
 246   return stn_ip46_punt_fn(vm, node, frame, 0);
 247 }
 248
 249 /** *INDENT-OFF* */
 250 VLIB_REGISTER_NODE (stn_ip6_punt, static) =
 251 {
 252   .function = stn_ip6_punt_fn,
 253   .name = "stn-ip6-punt",
 254   .vector_size = sizeof (u32),
 255   .format_trace = format_stn_ip6_punt_trace,
 256   .n_errors = STN_IP_PUNT_N_ERROR,
 257   .error_strings = stn_ip_punt_error_strings,
 258   .n_next_nodes = STN_IP_PUNT_N_NEXT,
 259   .next_nodes =
 260   {
 261       [STN_IP_PUNT_DROP] = "error-drop"
 262   },
 263 };
 264 /** *INDENT-ON* */
 265
 266 u8 *
 267 format_stn_ip4_punt_trace (u8 * s, va_list * args)
 268 {
 269   return format_stn_ip46_punt_trace (s, args, 1);
 270 }
 271
 272 static uword
 273 stn_ip4_punt_fn (vlib_main_t * vm,
 274                    vlib_node_runtime_t * node, vlib_frame_t * frame)
 275 {
 276   return stn_ip46_punt_fn(vm, node, frame, 1);
 277 }
 278
 279 /** *INDENT-OFF* */
 280 VLIB_REGISTER_NODE (stn_ip4_punt, static) =
 281 {
 282   .function = stn_ip4_punt_fn,
 283   .name = "stn-ip4-punt",
 284   .vector_size = sizeof (u32),
 285   .format_trace = format_stn_ip4_punt_trace,
 286   .n_errors = STN_IP_PUNT_N_ERROR,
 287   .error_strings = stn_ip_punt_error_strings,
 288   .n_next_nodes = STN_IP_PUNT_N_NEXT,
 289   .next_nodes =
 290   {
 291       [STN_IP_PUNT_DROP] = "error-drop",
 292   },
 293 };
 294 /** *INDENT-ON* */
 295
 296 clib_error_t *
 297 stn_init (vlib_main_t * vm)
 298 {
 299   stn_main_t *stn = &stn_main;
 300   stn->rules = 0;
 301   clib_bihash_init_16_8(&stn->rule_by_address_table, "stn addresses",
 302                         1024, 1<<20);
 303
 304   clib_memcpy(stn_ip4_ethernet_header.dst_address, stn_hw_addr_dst, 6);
 305   clib_memcpy(stn_ip4_ethernet_header.src_address, stn_hw_addr_local, 6);
 306   stn_ip4_ethernet_header.type = clib_host_to_net_u16(ETHERNET_TYPE_IP4);
 307
 308   clib_memcpy(stn_ip6_ethernet_header.dst_address, stn_hw_addr_dst, 6);
 309   clib_memcpy(stn_ip6_ethernet_header.src_address, stn_hw_addr_local, 6);
 310   stn_ip6_ethernet_header.type = clib_host_to_net_u16(ETHERNET_TYPE_IP6);
 311
 312   u32 punt_node_index = vlib_get_node_by_name(vm, (u8 *)"error-punt")->index;
 313   stn->punt_to_stn_ip4_next_index =
 314       vlib_node_add_next(vm, punt_node_index, stn_ip4_punt.index);
 315   stn->punt_to_stn_ip6_next_index =
 316         vlib_node_add_next(vm, punt_node_index, stn_ip6_punt.index);
 317
 318   return stn_api_init (vm, stn);
 319
 320   return NULL;
 321 }
 322
 323 VLIB_INIT_FUNCTION (stn_init);
 324
 325 /* *INDENT-OFF* */
 326 VLIB_PLUGIN_REGISTER () = {
 327     .version = VPP_BUILD_VER,
 328     .description = "VPP Steals the NIC for Container integration",
 329 };
 330 /* *INDENT-ON* */
 331
 332 int stn_rule_add_del (stn_rule_add_del_args_t *args)
 333 {
 334   vnet_main_t *vnm = vnet_get_main();
 335   vlib_main_t *vm = vlib_get_main();
 336   stn_main_t *stn = &stn_main;
 337
 338   stn_rule_t *r = NULL;
 339   clib_bihash_kv_16_8_t kv;
 340   kv.key[0] = args->address.as_u64[0];
 341   kv.key[1] = args->address.as_u64[1];
 342
 343   if (clib_bihash_search_inline_16_8 (&stn->rule_by_address_table, &kv) == 0)
 344     {
 345       r = &stn->rules[kv.value];
 346     }
 347   else if (!args->del)
 348     {
 349       pool_get(stn->rules, r);
 350       kv.value = r - stn->rules;
 351       clib_bihash_add_del_16_8(&stn->rule_by_address_table, &kv, 1);
 352       r->address = args->address;
 353
 354       stn->n_rules++;
 355       if (stn->n_rules == 1)
 356         {
 357           foreach_vlib_main({
 358             this_vlib_main->os_punt_frame = stn_punt_fn;
 359           });
 360           udp_punt_unknown(vm, 0, 1);
 361           udp_punt_unknown(vm, 1, 1);
 362           tcp_punt_unknown(vm, 0, 1);
 363           tcp_punt_unknown(vm, 1, 1);
 364         }
 365     }
 366
 367   if (!args->del)
 368     {
 369       /* Getting output node and adding it as next */
 370       u32 output_node_index =
 371           vnet_tx_node_index_for_sw_interface(vnm, args->sw_if_index);
 372       u32 node_index = ip46_address_is_ip4(&args->address)?
 373           stn_ip4_punt.index : stn_ip6_punt.index;
 374
 375       r->sw_if_index = args->sw_if_index;
 376       r->next_node_index =
 377           vlib_node_add_next(vm, node_index, output_node_index);
 378
 379       /* enabling forwarding on the output node (might not be done since
 380        * it is unnumbered) */
 381       vnet_feature_enable_disable("ip4-unicast", "ip4-lookup", args->sw_if_index,
 382                                   1, 0, 0);
 383       vnet_feature_enable_disable("ip6-unicast", "ip6-lookup", args->sw_if_index,
 384                                   1, 0, 0);
 385       vnet_feature_enable_disable("ip4-unicast", "ip4-not-enabled",
 386                                   args->sw_if_index,
 387                                   0, 0, 0);
 388       vnet_feature_enable_disable("ip6-unicast", "ip6-not-enabled",
 389                                   args->sw_if_index,
 390                                   0, 0, 0);
 391     }
 392   else if (r)
 393     {
 394       clib_bihash_add_del_16_8(&stn->rule_by_address_table, &kv, 0);
 395       pool_put(stn->rules, r);
 396
 397       stn->n_rules--;
 398       if (stn->n_rules == 0)
 399         {
 400           foreach_vlib_main({
 401             this_vlib_main->os_punt_frame = NULL;
 402           });
 403         }
 404     }
 405   else
 406     {
 407       return VNET_API_ERROR_NO_SUCH_ENTRY;
 408     }
 409
 410   return 0;
 411 }
 412
 413 static clib_error_t *
 414 show_stn_rules_fn (vlib_main_t * vm,
 415                       unformat_input_t * input, vlib_cli_command_t * cmd)
 416 {
 417   stn_main_t *stn = &stn_main;
 418   u8 *s = 0;
 419   stn_rule_t *rule;
 420   pool_foreach(rule, stn->rules, {
 421       s = format (s, "- %U\n", format_stn_rule, rule);
 422   });
 423
 424   vlib_cli_output(vm, "%v", s);
 425
 426   vec_free(s);
 427   return NULL;
 428 }
 429
 430 VLIB_CLI_COMMAND (show_stn_rules_command, static) =
 431 {
 432   .path = "show stn rules",
 433   .short_help = "",
 434   .function = show_stn_rules_fn,
 435 };
 436
 437 static clib_error_t *
 438 stn_rule_fn (vlib_main_t * vm,
 439                       unformat_input_t * input, vlib_cli_command_t * cmd)
 440 {
 441   unformat_input_t _line_input, *line_input = &_line_input;
 442   clib_error_t *error = 0;
 443   stn_rule_add_del_args_t args = {};
 444   u8 got_addr = 0;
 445   u8 got_iface = 0;
 446   int ret;
 447
 448   if (!unformat_user (input, unformat_line_input, line_input))
 449     return 0;
 450
 451   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 452     {
 453       if (unformat (line_input, "address %U", unformat_ip46_address,
 454                     &args.address, IP46_TYPE_ANY))
 455         got_addr = 1;
 456       else if (unformat
 457                (line_input, "interface %U", unformat_vnet_sw_interface,
 458                 vnet_get_main(), &args.sw_if_index))
 459         got_iface = 1;
 460       else if (unformat (line_input, "del"))
 461         args.del = 1;
 462       else
 463         {
 464           error = clib_error_return (0, "parse error: '%U'",
 465                                      format_unformat_error, line_input);
 466           goto done;
 467         }
 468     }
 469
 470   if (!got_addr)
 471     {
 472       error = clib_error_return (0, "Missing address");
 473       goto done;
 474     }
 475
 476   if (!got_iface)
 477     {
 478       error = clib_error_return (0, "Missing interface");
 479       goto done;
 480     }
 481
 482   if ((ret = stn_rule_add_del (&args)))
 483     {
 484       error = clib_error_return (0, "stn_rule_add_del returned error %d", ret);
 485       goto done;
 486     }
 487
 488 done:
 489   unformat_free (line_input);
 490   return error;
 491 }
 492
 493 VLIB_CLI_COMMAND (stn_rule_command, static) =
 494 {
 495   .path = "stn rule",
 496   .short_help = "address <addr> interface <iface> [del]",
 497   .function = stn_rule_fn,
 498 };