src/vnet/dpo/dpo.c

   1 /*
   2  * Copyright (c) 2016 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  * @brief
  17  * A Data-Path Object is an object that represents actions that are
  18  * applied to packets are they are switched through VPP.
  19  *
  20  * The DPO is a base class that is specialised by other objects to provide
  21  * concrete actions
  22  *
  23  * The VLIB graph nodes are graph of types, the DPO graph is a graph of instances.
  24  */
  25
  26 #include <vnet/dpo/dpo.h>
  27 #include <vnet/ip/lookup.h>
  28 #include <vnet/ip/format.h>
  29 #include <vnet/adj/adj.h>
  30
  31 #include <vnet/dpo/load_balance.h>
  32 #include <vnet/dpo/mpls_label_dpo.h>
  33 #include <vnet/dpo/lookup_dpo.h>
  34 #include <vnet/dpo/drop_dpo.h>
  35 #include <vnet/dpo/receive_dpo.h>
  36 #include <vnet/dpo/punt_dpo.h>
  37 #include <vnet/dpo/classify_dpo.h>
  38 #include <vnet/dpo/ip_null_dpo.h>
  39 #include <vnet/dpo/replicate_dpo.h>
  40 #include <vnet/dpo/interface_rx_dpo.h>
  41 #include <vnet/dpo/interface_tx_dpo.h>
  42 #include <vnet/dpo/mpls_disposition.h>
  43 #include <vnet/dpo/dvr_dpo.h>
  44 #include <vnet/dpo/l3_proxy_dpo.h>
  45 #include <vnet/dpo/ip6_ll_dpo.h>
  46
  47 /**
  48  * Array of char* names for the DPO types and protos
  49  */
  50 static const char* dpo_type_names[] = DPO_TYPES;
  51 static const char* dpo_proto_names[] = DPO_PROTOS;
  52
  53 /**
  54  * @brief Vector of virtual function tables for the DPO types
  55  *
  56  * This is a vector so we can dynamically register new DPO types in plugins.
  57  */
  58 static dpo_vft_t *dpo_vfts;
  59
  60 /**
  61  * @brief vector of graph node names associated with each DPO type and protocol.
  62  *
  63  *   dpo_nodes[child_type][child_proto][node_X] = node_name;
  64  * i.e.
  65  *   dpo_node[DPO_LOAD_BALANCE][DPO_PROTO_IP4][0] = "ip4-lookup"
  66  *   dpo_node[DPO_LOAD_BALANCE][DPO_PROTO_IP4][1] = "ip4-load-balance"
  67  *
  68  * This is a vector so we can dynamically register new DPO types in plugins.
  69  */
  70 static const char* const * const ** dpo_nodes;
  71
  72 /**
  73  * @brief Vector of edge indicies from parent DPO nodes to child
  74  *
  75  * dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge_index
  76  *
  77  * This array is derived at init time from the dpo_nodes above. Note that
  78  * the third dimension in dpo_nodes is lost, hence, the edge index from each
  79  * node MUST be the same.
  80  * Including both the child and parent protocol is required to support the
  81  * case where it changes as the graph is traversed, most notably when an
  82  * MPLS label is popped.
  83  *
  84  * Note that this array is child type specific, not child instance specific.
  85  */
  86 static u32 ****dpo_edges;
  87
  88 /**
  89  * @brief The DPO type value that can be assigned to the next dynamic
  90  *        type registration.
  91  */
  92 static dpo_type_t dpo_dynamic = DPO_LAST;
  93
  94 dpo_proto_t
  95 vnet_link_to_dpo_proto (vnet_link_t linkt)
  96 {
  97     switch (linkt)
  98     {
  99     case VNET_LINK_IP6:
 100         return (DPO_PROTO_IP6);
 101     case VNET_LINK_IP4:
 102         return (DPO_PROTO_IP4);
 103     case VNET_LINK_MPLS:
 104         return (DPO_PROTO_MPLS);
 105     case VNET_LINK_ETHERNET:
 106         return (DPO_PROTO_ETHERNET);
 107     case VNET_LINK_NSH:
 108         return (DPO_PROTO_NSH);
 109     case VNET_LINK_ARP:
 110         break;
 111     }
 112     ASSERT(0);
 113     return (0);
 114 }
 115
 116 vnet_link_t
 117 dpo_proto_to_link (dpo_proto_t dp)
 118 {
 119     switch (dp)
 120     {
 121     case DPO_PROTO_IP6:
 122         return (VNET_LINK_IP6);
 123     case DPO_PROTO_IP4:
 124         return (VNET_LINK_IP4);
 125     case DPO_PROTO_MPLS:
 126     case DPO_PROTO_BIER:
 127         return (VNET_LINK_MPLS);
 128     case DPO_PROTO_ETHERNET:
 129         return (VNET_LINK_ETHERNET);
 130     case DPO_PROTO_NSH:
 131         return (VNET_LINK_NSH);
 132     }
 133     return (~0);
 134 }
 135
 136 u8 *
 137 format_dpo_type (u8 * s, va_list * args)
 138 {
 139     dpo_type_t type = va_arg (*args, int);
 140
 141     s = format(s, "%s", dpo_type_names[type]);
 142
 143     return (s);
 144 }
 145
 146 u8 *
 147 format_dpo_id (u8 * s, va_list * args)
 148 {
 149     dpo_id_t *dpo = va_arg (*args, dpo_id_t*);
 150     u32 indent = va_arg (*args, u32);
 151
 152     s = format(s, "[@%d]: ", dpo->dpoi_next_node);
 153
 154     if (NULL != dpo_vfts[dpo->dpoi_type].dv_format)
 155     {
 156         s = format(s, "%U",
 157                    dpo_vfts[dpo->dpoi_type].dv_format,
 158                    dpo->dpoi_index,
 159                    indent);
 160     }
 161     else
 162     {
 163         switch (dpo->dpoi_type)
 164         {
 165         case DPO_FIRST:
 166             s = format(s, "unset");
 167             break;
 168         default:
 169             s = format(s, "unknown");
 170             break;
 171         }
 172     }
 173     return (s);
 174 }
 175
 176 u8 *
 177 format_dpo_proto (u8 * s, va_list * args)
 178 {
 179     dpo_proto_t proto = va_arg (*args, int);
 180
 181     return (format(s, "%s", dpo_proto_names[proto]));
 182 }
 183
 184 void
 185 dpo_set (dpo_id_t *dpo,
 186          dpo_type_t type,
 187          dpo_proto_t proto,
 188          index_t index)
 189 {
 190     dpo_id_t tmp = *dpo;
 191
 192     dpo->dpoi_type = type;
 193     dpo->dpoi_proto = proto,
 194     dpo->dpoi_index = index;
 195
 196     if (DPO_ADJACENCY == type)
 197     {
 198         /*
 199          * set the adj subtype
 200          */
 201         ip_adjacency_t *adj;
 202
 203         adj = adj_get(index);
 204
 205         switch (adj->lookup_next_index)
 206         {
 207         case IP_LOOKUP_NEXT_ARP:
 208             dpo->dpoi_type = DPO_ADJACENCY_INCOMPLETE;
 209             break;
 210         case IP_LOOKUP_NEXT_MIDCHAIN:
 211             dpo->dpoi_type = DPO_ADJACENCY_MIDCHAIN;
 212             break;
 213         case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 214             dpo->dpoi_type = DPO_ADJACENCY_MCAST_MIDCHAIN;
 215             break;
 216         case IP_LOOKUP_NEXT_MCAST:
 217             dpo->dpoi_type = DPO_ADJACENCY_MCAST;
 218             break;
 219         case IP_LOOKUP_NEXT_GLEAN:
 220             dpo->dpoi_type = DPO_ADJACENCY_GLEAN;
 221             break;
 222         default:
 223             break;
 224         }
 225     }
 226     dpo_lock(dpo);
 227     dpo_unlock(&tmp);
 228 }
 229
 230 void
 231 dpo_reset (dpo_id_t *dpo)
 232 {
 233     dpo_id_t tmp = DPO_INVALID;
 234
 235     /*
 236      * use the atomic copy operation.
 237      */
 238     dpo_copy(dpo, &tmp);
 239 }
 240
 241 /**
 242  * \brief
 243  * Compare two Data-path objects
 244  *
 245  * like memcmp, return 0 is matching, !0 otherwise.
 246  */
 247 int
 248 dpo_cmp (const dpo_id_t *dpo1,
 249          const dpo_id_t *dpo2)
 250 {
 251     int res;
 252
 253     res = dpo1->dpoi_type - dpo2->dpoi_type;
 254
 255     if (0 != res) return (res);
 256
 257     return (dpo1->dpoi_index - dpo2->dpoi_index);
 258 }
 259
 260 void
 261 dpo_copy (dpo_id_t *dst,
 262           const dpo_id_t *src)
 263 {
 264     dpo_id_t tmp = *dst;
 265
 266     /*
 267      * the destination is written in a single u64 write - hence atomically w.r.t
 268      * any packets inflight.
 269      */
 270     *((u64*)dst) = *(u64*)src;
 271
 272     dpo_lock(dst);
 273     dpo_unlock(&tmp);
 274 }
 275
 276 int
 277 dpo_is_adj (const dpo_id_t *dpo)
 278 {
 279     return ((dpo->dpoi_type == DPO_ADJACENCY) ||
 280             (dpo->dpoi_type == DPO_ADJACENCY_INCOMPLETE) ||
 281             (dpo->dpoi_type == DPO_ADJACENCY_MIDCHAIN) ||
 282             (dpo->dpoi_type == DPO_ADJACENCY_GLEAN));
 283 }
 284
 285 static u32 *
 286 dpo_default_get_next_node (const dpo_id_t *dpo)
 287 {
 288     u32 *node_indices = NULL;
 289     const char *node_name;
 290     u32 ii = 0;
 291
 292     node_name = dpo_nodes[dpo->dpoi_type][dpo->dpoi_proto][ii];
 293     while (NULL != node_name)
 294     {
 295         vlib_node_t *node;
 296
 297         node = vlib_get_node_by_name(vlib_get_main(), (u8*) node_name);
 298         ASSERT(NULL != node);
 299         vec_add1(node_indices, node->index);
 300
 301         ++ii;
 302         node_name = dpo_nodes[dpo->dpoi_type][dpo->dpoi_proto][ii];
 303     }
 304
 305     return (node_indices);
 306 }
 307
 308 /**
 309  * A default variant of the make interpose function that just returns
 310  * the original
 311  */
 312 static void
 313 dpo_default_mk_interpose (const dpo_id_t *original,
 314                           const dpo_id_t *parent,
 315                           dpo_id_t *clone)
 316 {
 317     dpo_copy(clone, original);
 318 }
 319
 320 void
 321 dpo_register (dpo_type_t type,
 322               const dpo_vft_t *vft,
 323               const char * const * const * nodes)
 324 {
 325     vec_validate(dpo_vfts, type);
 326     dpo_vfts[type] = *vft;
 327     if (NULL == dpo_vfts[type].dv_get_next_node)
 328     {
 329         dpo_vfts[type].dv_get_next_node = dpo_default_get_next_node;
 330     }
 331     if (NULL == dpo_vfts[type].dv_mk_interpose)
 332     {
 333         dpo_vfts[type].dv_mk_interpose = dpo_default_mk_interpose;
 334     }
 335
 336     vec_validate(dpo_nodes, type);
 337     dpo_nodes[type] = nodes;
 338 }
 339
 340 dpo_type_t
 341 dpo_register_new_type (const dpo_vft_t *vft,
 342                        const char * const * const * nodes)
 343 {
 344     dpo_type_t type = dpo_dynamic++;
 345
 346     dpo_register(type, vft, nodes);
 347
 348     return (type);
 349 }
 350
 351 void
 352 dpo_mk_interpose (const dpo_id_t *original,
 353                   const dpo_id_t *parent,
 354                   dpo_id_t *clone)
 355 {
 356     if (!dpo_id_is_valid(original))
 357         return;
 358
 359     dpo_vfts[original->dpoi_type].dv_mk_interpose(original, parent, clone);
 360 }
 361
 362 void
 363 dpo_lock (dpo_id_t *dpo)
 364 {
 365     if (!dpo_id_is_valid(dpo))
 366         return;
 367
 368     dpo_vfts[dpo->dpoi_type].dv_lock(dpo);
 369 }
 370
 371 void
 372 dpo_unlock (dpo_id_t *dpo)
 373 {
 374     if (!dpo_id_is_valid(dpo))
 375         return;
 376
 377     dpo_vfts[dpo->dpoi_type].dv_unlock(dpo);
 378 }
 379
 380 u32
 381 dpo_get_urpf(const dpo_id_t *dpo)
 382 {
 383     if (dpo_id_is_valid(dpo) &&
 384         (NULL != dpo_vfts[dpo->dpoi_type].dv_get_urpf))
 385     {
 386         return (dpo_vfts[dpo->dpoi_type].dv_get_urpf(dpo));
 387     }
 388
 389     return (~0);
 390 }
 391
 392 static u32
 393 dpo_get_next_node (dpo_type_t child_type,
 394                    dpo_proto_t child_proto,
 395                    const dpo_id_t *parent_dpo)
 396 {
 397     dpo_proto_t parent_proto;
 398     dpo_type_t parent_type;
 399
 400     parent_type = parent_dpo->dpoi_type;
 401     parent_proto = parent_dpo->dpoi_proto;
 402
 403     vec_validate(dpo_edges, child_type);
 404     vec_validate(dpo_edges[child_type], child_proto);
 405     vec_validate(dpo_edges[child_type][child_proto], parent_type);
 406     vec_validate_init_empty(
 407         dpo_edges[child_type][child_proto][parent_type],
 408         parent_proto, ~0);
 409
 410     /*
 411      * if the edge index has not yet been created for this node to node transition
 412      */
 413     if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
 414     {
 415         vlib_node_t *child_node;
 416         u32 *parent_indices;
 417         vlib_main_t *vm;
 418         u32 edge, *pi, cc;
 419
 420         vm = vlib_get_main();
 421
 422         ASSERT(NULL != dpo_vfts[parent_type].dv_get_next_node);
 423         ASSERT(NULL != dpo_nodes[child_type]);
 424         ASSERT(NULL != dpo_nodes[child_type][child_proto]);
 425
 426         cc = 0;
 427         parent_indices = dpo_vfts[parent_type].dv_get_next_node(parent_dpo);
 428
 429         vlib_worker_thread_barrier_sync(vm);
 430
 431         /*
 432          * create a graph arc from each of the child's registered node types,
 433          * to each of the parent's.
 434          */
 435         while (NULL != dpo_nodes[child_type][child_proto][cc])
 436         {
 437             child_node =
 438                 vlib_get_node_by_name(vm,
 439                                       (u8*) dpo_nodes[child_type][child_proto][cc]);
 440
 441             vec_foreach(pi, parent_indices)
 442             {
 443                 edge = vlib_node_add_next(vm, child_node->index, *pi);
 444
 445                 if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
 446                 {
 447                     dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge;
 448                 }
 449                 else
 450                 {
 451                     ASSERT(dpo_edges[child_type][child_proto][parent_type][parent_proto] == edge);
 452                 }
 453             }
 454             cc++;
 455         }
 456
 457         vlib_worker_thread_barrier_release(vm);
 458         vec_free(parent_indices);
 459     }
 460
 461     return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
 462 }
 463
 464 /**
 465  * @brief return already stacked up next node index for a given
 466  * child_type/child_proto and parent_type/patent_proto.
 467  * The VLIB graph arc used is taken from the parent and child types
 468  * passed.
 469  */
 470 u32
 471 dpo_get_next_node_by_type_and_proto (dpo_type_t   child_type,
 472                                      dpo_proto_t  child_proto,
 473                                      dpo_type_t   parent_type,
 474                                      dpo_proto_t  parent_proto)
 475 {
 476    return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
 477 }
 478
 479 /**
 480  * @brief Stack one DPO object on another, and thus establish a child parent
 481  * relationship. The VLIB graph arc used is taken from the parent and child types
 482  * passed.
 483  */
 484 static void
 485 dpo_stack_i (u32 edge,
 486              dpo_id_t *dpo,
 487              const dpo_id_t *parent)
 488 {
 489     /*
 490      * in order to get an atomic update of the parent we create a temporary,
 491      * from a copy of the child, and add the next_node. then we copy to the parent
 492      */
 493     dpo_id_t tmp = DPO_INVALID;
 494     dpo_copy(&tmp, parent);
 495
 496     /*
 497      * get the edge index for the parent to child VLIB graph transition
 498      */
 499     tmp.dpoi_next_node = edge;
 500
 501     /*
 502      * this update is atomic.
 503      */
 504     dpo_copy(dpo, &tmp);
 505
 506     dpo_reset(&tmp);
 507 }
 508
 509 /**
 510  * @brief Stack one DPO object on another, and thus establish a child-parent
 511  * relationship. The VLIB graph arc used is taken from the parent and child types
 512  * passed.
 513  */
 514 void
 515 dpo_stack (dpo_type_t child_type,
 516            dpo_proto_t child_proto,
 517            dpo_id_t *dpo,
 518            const dpo_id_t *parent)
 519 {
 520     dpo_stack_i(dpo_get_next_node(child_type, child_proto, parent), dpo, parent);
 521 }
 522
 523 /**
 524  * @brief Stack one DPO object on another, and thus establish a child parent
 525  * relationship. A new VLIB graph arc is created from the child node passed
 526  * to the nodes registered by the parent. The VLIB infra will ensure this arc
 527  * is added only once.
 528  */
 529 void
 530 dpo_stack_from_node (u32 child_node_index,
 531                      dpo_id_t *dpo,
 532                      const dpo_id_t *parent)
 533 {
 534     dpo_type_t parent_type;
 535     u32 *parent_indices;
 536     vlib_main_t *vm;
 537     u32 edge, *pi;
 538
 539     edge = 0;
 540     parent_type = parent->dpoi_type;
 541     vm = vlib_get_main();
 542
 543     ASSERT(NULL != dpo_vfts[parent_type].dv_get_next_node);
 544     parent_indices = dpo_vfts[parent_type].dv_get_next_node(parent);
 545     ASSERT(parent_indices);
 546
 547     /*
 548      * This loop is purposefully written with the worker thread lock in the
 549      * inner loop because;
 550      *  1) the likelihood that the edge does not exist is smaller
 551      *  2) the likelihood there is more than one node is even smaller
 552      * so we are optimising for not need to take the lock
 553      */
 554     vec_foreach(pi, parent_indices)
 555     {
 556         edge = vlib_node_get_next(vm, child_node_index, *pi);
 557
 558         if (~0 == edge)
 559         {
 560             vlib_worker_thread_barrier_sync(vm);
 561
 562             edge = vlib_node_add_next(vm, child_node_index, *pi);
 563
 564             vlib_worker_thread_barrier_release(vm);
 565         }
 566     }
 567     dpo_stack_i(edge, dpo, parent);
 568
 569     /* should free this local vector to avoid memory leak */
 570     vec_free(parent_indices);
 571 }
 572
 573 static clib_error_t *
 574 dpo_module_init (vlib_main_t * vm)
 575 {
 576     drop_dpo_module_init();
 577     punt_dpo_module_init();
 578     receive_dpo_module_init();
 579     load_balance_module_init();
 580     mpls_label_dpo_module_init();
 581     classify_dpo_module_init();
 582     lookup_dpo_module_init();
 583     ip_null_dpo_module_init();
 584     ip6_ll_dpo_module_init();
 585     replicate_module_init();
 586     interface_rx_dpo_module_init();
 587     interface_tx_dpo_module_init();
 588     mpls_disp_dpo_module_init();
 589     dvr_dpo_module_init();
 590     l3_proxy_dpo_module_init();
 591
 592     return (NULL);
 593 }
 594
 595 VLIB_INIT_FUNCTION(dpo_module_init);
 596
 597 static clib_error_t *
 598 dpo_memory_show (vlib_main_t * vm,
 599                  unformat_input_t * input,
 600                  vlib_cli_command_t * cmd)
 601 {
 602     dpo_vft_t *vft;
 603
 604     vlib_cli_output (vm, "DPO memory");
 605     vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s   totals",
 606                      "Name","Size", "in-use", "allocated");
 607
 608     vec_foreach(vft, dpo_vfts)
 609     {
 610         if (NULL != vft->dv_mem_show)
 611             vft->dv_mem_show();
 612     }
 613
 614     return (NULL);
 615 }
 616
 617 /* *INDENT-OFF* */
 618 /*?
 619  * The '<em>sh dpo memory </em>' command displays the memory usage for each
 620  * data-plane object type.
 621  *
 622  * @cliexpar
 623  * @cliexstart{show dpo memory}
 624  * DPO memory
 625  *             Name               Size  in-use /allocated   totals
 626  *         load-balance            64     12   /    12      768/768
 627  *           Adjacency            256      1   /    1       256/256
 628  *            Receive              24      5   /    5       120/120
 629  *            Lookup               12      0   /    0       0/0
 630  *           Classify              12      0   /    0       0/0
 631  *          MPLS label             24      0   /    0       0/0
 632  * @cliexend
 633 ?*/
 634 VLIB_CLI_COMMAND (show_fib_memory, static) = {
 635     .path = "show dpo memory",
 636     .function = dpo_memory_show,
 637     .short_help = "show dpo memory",
 638 };
 639 /* *INDENT-ON* */