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