src/plugins/gbp/gbp_classify_node.c

   1 /*
   2  * gbp.h : Group Based Policy
   3  *
   4  * Copyright (c) 2018 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <plugins/gbp/gbp.h>
  19 #include <plugins/gbp/gbp_classify.h>
  20 #include <plugins/gbp/gbp_policy_dpo.h>
  21 #include <plugins/gbp/gbp_ext_itf.h>
  22 #include <vnet/fib/ip4_fib.h>
  23 #include <vnet/fib/ip6_fib.h>
  24 #include <vnet/dpo/load_balance.h>
  25 #include <vnet/l2/l2_input.h>
  26 #include <vnet/l2/feat_bitmap.h>
  27 #include <vnet/fib/fib_table.h>
  28 #include <vnet/vxlan-gbp/vxlan_gbp_packet.h>
  29 #include <vnet/ethernet/arp_packet.h>
  30
  31 /**
  32  * per-packet trace data
  33  */
  34 typedef struct gbp_classify_trace_t_
  35 {
  36   /* per-pkt trace data */
  37   sclass_t sclass;
  38 } gbp_classify_trace_t;
  39
  40 /*
  41  * determine the SRC EPG form the input port
  42  */
  43 always_inline uword
  44 gbp_classify_inline (vlib_main_t * vm,
  45                      vlib_node_runtime_t * node,
  46                      vlib_frame_t * frame,
  47                      gbp_src_classify_type_t type, dpo_proto_t dproto)
  48 {
  49   gbp_src_classify_main_t *gscm = &gbp_src_classify_main;
  50   u32 n_left_from, *from, *to_next;
  51   u32 next_index;
  52
  53   next_index = 0;
  54   n_left_from = frame->n_vectors;
  55   from = vlib_frame_vector_args (frame);
  56
  57   while (n_left_from > 0)
  58     {
  59       u32 n_left_to_next;
  60
  61       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
  62
  63       while (n_left_from > 0 && n_left_to_next > 0)
  64         {
  65           u32 next0, bi0, sw_if_index0;
  66           const gbp_endpoint_t *ge0;
  67           vlib_buffer_t *b0;
  68           sclass_t sclass0;
  69
  70           bi0 = from[0];
  71           to_next[0] = bi0;
  72           from += 1;
  73           to_next += 1;
  74           n_left_from -= 1;
  75           n_left_to_next -= 1;
  76
  77           b0 = vlib_get_buffer (vm, bi0);
  78
  79           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
  80           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_NONE;
  81
  82           if (GBP_SRC_CLASSIFY_NULL == type)
  83             {
  84               sclass0 = SCLASS_INVALID;
  85               next0 =
  86                 vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
  87                                       L2INPUT_FEAT_GBP_NULL_CLASSIFY);
  88             }
  89           else
  90             {
  91               if (DPO_PROTO_ETHERNET == dproto)
  92                 {
  93                   const ethernet_header_t *h0;
  94
  95                   h0 = vlib_buffer_get_current (b0);
  96                   next0 =
  97                     vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
  98                                           L2INPUT_FEAT_GBP_SRC_CLASSIFY);
  99                   ge0 = gbp_endpoint_find_mac (h0->src_address,
 100                                                vnet_buffer (b0)->l2.bd_index);
 101                 }
 102               else if (DPO_PROTO_IP4 == dproto)
 103                 {
 104                   const ip4_header_t *h0;
 105
 106                   h0 = vlib_buffer_get_current (b0);
 107
 108                   ge0 = gbp_endpoint_find_ip4
 109                     (&h0->src_address,
 110                      fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
 111                                                           sw_if_index0));
 112
 113
 114                   /*
 115                    * Go straight to looukp, do not pass go, do not collect $200
 116                    */
 117                   next0 = 0;
 118                 }
 119               else if (DPO_PROTO_IP6 == dproto)
 120                 {
 121                   const ip6_header_t *h0;
 122
 123                   h0 = vlib_buffer_get_current (b0);
 124
 125                   ge0 = gbp_endpoint_find_ip6
 126                     (&h0->src_address,
 127                      fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP6,
 128                                                           sw_if_index0));
 129
 130
 131                   /*
 132                    * Go straight to lookup, do not pass go, do not collect $200
 133                    */
 134                   next0 = 0;
 135                 }
 136               else
 137                 {
 138                   ge0 = NULL;
 139                   next0 = 0;
 140                   ASSERT (0);
 141                 }
 142
 143               if (PREDICT_TRUE (NULL != ge0))
 144                 sclass0 = ge0->ge_fwd.gef_sclass;
 145               else
 146                 sclass0 = SCLASS_INVALID;
 147             }
 148
 149           vnet_buffer2 (b0)->gbp.sclass = sclass0;
 150
 151           if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
 152             {
 153               gbp_classify_trace_t *t =
 154                 vlib_add_trace (vm, node, b0, sizeof (*t));
 155               t->sclass = sclass0;
 156             }
 157
 158           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 159                                            to_next, n_left_to_next,
 160                                            bi0, next0);
 161         }
 162
 163       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 164     }
 165
 166   return frame->n_vectors;
 167 }
 168
 169 VLIB_NODE_FN (gbp_src_classify_node) (vlib_main_t * vm,
 170                                       vlib_node_runtime_t * node,
 171                                       vlib_frame_t * frame)
 172 {
 173   return (gbp_classify_inline (vm, node, frame,
 174                                GBP_SRC_CLASSIFY_PORT, DPO_PROTO_ETHERNET));
 175 }
 176
 177 VLIB_NODE_FN (gbp_null_classify_node) (vlib_main_t * vm,
 178                                        vlib_node_runtime_t * node,
 179                                        vlib_frame_t * frame)
 180 {
 181   return (gbp_classify_inline (vm, node, frame,
 182                                GBP_SRC_CLASSIFY_NULL, DPO_PROTO_ETHERNET));
 183 }
 184
 185 VLIB_NODE_FN (gbp_ip4_src_classify_node) (vlib_main_t * vm,
 186                                           vlib_node_runtime_t * node,
 187                                           vlib_frame_t * frame)
 188 {
 189   return (gbp_classify_inline (vm, node, frame,
 190                                GBP_SRC_CLASSIFY_PORT, DPO_PROTO_IP4));
 191 }
 192
 193 VLIB_NODE_FN (gbp_ip6_src_classify_node) (vlib_main_t * vm,
 194                                           vlib_node_runtime_t * node,
 195                                           vlib_frame_t * frame)
 196 {
 197   return (gbp_classify_inline (vm, node, frame,
 198                                GBP_SRC_CLASSIFY_PORT, DPO_PROTO_IP6));
 199 }
 200
 201
 202 /* packet trace format function */
 203 static u8 *
 204 format_gbp_classify_trace (u8 * s, va_list * args)
 205 {
 206   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 207   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 208   gbp_classify_trace_t *t = va_arg (*args, gbp_classify_trace_t *);
 209
 210   s = format (s, "sclass:%d", t->sclass);
 211
 212   return s;
 213 }
 214
 215 /* *INDENT-OFF* */
 216 VLIB_REGISTER_NODE (gbp_null_classify_node) = {
 217   .name = "gbp-null-classify",
 218   .vector_size = sizeof (u32),
 219   .format_trace = format_gbp_classify_trace,
 220   .type = VLIB_NODE_TYPE_INTERNAL,
 221
 222   .n_errors = 0,
 223   .n_next_nodes = 0,
 224 };
 225
 226 VLIB_REGISTER_NODE (gbp_src_classify_node) = {
 227   .name = "gbp-src-classify",
 228   .vector_size = sizeof (u32),
 229   .format_trace = format_gbp_classify_trace,
 230   .type = VLIB_NODE_TYPE_INTERNAL,
 231
 232   .n_errors = 0,
 233   .n_next_nodes = 0,
 234 };
 235
 236 VLIB_REGISTER_NODE (gbp_ip4_src_classify_node) = {
 237   .name = "ip4-gbp-src-classify",
 238   .vector_size = sizeof (u32),
 239   .format_trace = format_gbp_classify_trace,
 240   .type = VLIB_NODE_TYPE_INTERNAL,
 241
 242   .n_errors = 0,
 243   .n_next_nodes = 1,
 244   .next_nodes = {
 245     [0] = "ip4-lookup"
 246   },
 247 };
 248
 249 VLIB_REGISTER_NODE (gbp_ip6_src_classify_node) = {
 250   .name = "ip6-gbp-src-classify",
 251   .vector_size = sizeof (u32),
 252   .format_trace = format_gbp_classify_trace,
 253   .type = VLIB_NODE_TYPE_INTERNAL,
 254
 255   .n_errors = 0,
 256   .n_next_nodes = 1,
 257   .next_nodes = {
 258     [0] = "ip6-lookup"
 259   },
 260 };
 261
 262 VNET_FEATURE_INIT (gbp_ip4_src_classify_feat_node, static) =
 263 {
 264   .arc_name = "ip4-unicast",
 265   .node_name = "ip4-gbp-src-classify",
 266   .runs_before = VNET_FEATURES ("nat44-out2in"),
 267 };
 268 VNET_FEATURE_INIT (gbp_ip6_src_classify_feat_node, static) =
 269 {
 270   .arc_name = "ip6-unicast",
 271   .node_name = "ip6-gbp-src-classify",
 272   .runs_before = VNET_FEATURES ("nat66-out2in"),
 273 };
 274
 275 /* *INDENT-ON* */
 276
 277 typedef enum gbp_lpm_classify_next_t_
 278 {
 279   GPB_LPM_CLASSIFY_DROP,
 280 } gbp_lpm_classify_next_t;
 281
 282 always_inline void
 283 gbp_classify_get_src_ip4_address (const ethernet_header_t * eh0,
 284                                   const ip4_address_t ** ip4)
 285 {
 286   const ip4_header_t *iph4;
 287
 288   iph4 = (ip4_header_t *) (eh0 + 1);
 289   *ip4 = &iph4->src_address;
 290 }
 291
 292 always_inline void
 293 gbp_classify_get_src_ip6_address (const ethernet_header_t * eh0,
 294                                   const ip6_address_t ** ip6)
 295 {
 296   const ip6_header_t *iph6;
 297
 298   iph6 = (ip6_header_t *) (eh0 + 1);
 299   *ip6 = &iph6->src_address;
 300 }
 301
 302 always_inline void
 303 gbp_classify_get_src_ip_address (const ethernet_header_t * eh0,
 304                                  const ip4_address_t ** ip4,
 305                                  const ip6_address_t ** ip6)
 306 {
 307   u16 etype = clib_net_to_host_u16 (eh0->type);
 308
 309   switch (etype)
 310     {
 311     case ETHERNET_TYPE_IP4:
 312       gbp_classify_get_src_ip4_address (eh0, ip4);
 313       break;
 314     case ETHERNET_TYPE_IP6:
 315       gbp_classify_get_src_ip6_address (eh0, ip6);
 316       break;
 317     case ETHERNET_TYPE_VLAN:
 318       {
 319         ethernet_vlan_header_t *vh0;
 320
 321         vh0 = (ethernet_vlan_header_t *) (eh0 + 1);
 322
 323         switch (clib_net_to_host_u16 (vh0->type))
 324           {
 325           case ETHERNET_TYPE_IP4:
 326             {
 327               gbp_classify_get_src_ip4_address (eh0, ip4);
 328               break;
 329           case ETHERNET_TYPE_IP6:
 330               gbp_classify_get_src_ip6_address (eh0, ip6);
 331               break;
 332             }
 333           }
 334       }
 335     case ETHERNET_TYPE_ARP:
 336       {
 337         const ethernet_arp_header_t *ea0;
 338
 339         ea0 = (ethernet_arp_header_t *) (eh0 + 1);
 340
 341         *ip4 = &ea0->ip4_over_ethernet[0].ip4;
 342         break;
 343       }
 344     default:
 345       break;
 346     }
 347 }
 348
 349 /**
 350  * per-packet trace data
 351  */
 352 typedef struct gbp_lpm_classify_trace_t_
 353 {
 354   sclass_t sclass;
 355   index_t lbi;
 356   ip46_address_t src;
 357 } gbp_lpm_classify_trace_t;
 358
 359 /* packet trace format function */
 360 static u8 *
 361 format_gbp_lpm_classify_trace (u8 * s, va_list * args)
 362 {
 363   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 364   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 365   gbp_lpm_classify_trace_t *t = va_arg (*args, gbp_lpm_classify_trace_t *);
 366
 367   s = format (s, "sclass:%d lb:%d src:%U",
 368               t->sclass, t->lbi, format_ip46_address, &t->src, IP46_TYPE_ANY);
 369
 370   return s;
 371 }
 372
 373 /*
 374  * Determine the SRC EPG from a LPM
 375  */
 376 always_inline uword
 377 gbp_lpm_classify_inline (vlib_main_t * vm,
 378                          vlib_node_runtime_t * node,
 379                          vlib_frame_t * frame,
 380                          dpo_proto_t dproto, u8 is_recirc)
 381 {
 382   gbp_src_classify_main_t *gscm = &gbp_src_classify_main;
 383   u32 n_left_from, *from, *to_next;
 384   u32 next_index;
 385
 386   next_index = 0;
 387   n_left_from = frame->n_vectors;
 388   from = vlib_frame_vector_args (frame);
 389
 390   while (n_left_from > 0)
 391     {
 392       u32 n_left_to_next;
 393
 394       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 395
 396       while (n_left_from > 0 && n_left_to_next > 0)
 397         {
 398           u32 bi0, sw_if_index0, fib_index0, lbi0;
 399           gbp_lpm_classify_next_t next0;
 400           const ethernet_header_t *eh0;
 401           const gbp_policy_dpo_t *gpd0;
 402           const ip4_address_t *ip4_0;
 403           const ip6_address_t *ip6_0;
 404           const gbp_endpoint_t *ge0;
 405           const gbp_recirc_t *gr0;
 406           const dpo_id_t *dpo0;
 407           load_balance_t *lb0;
 408           vlib_buffer_t *b0;
 409           sclass_t sclass0;
 410
 411           bi0 = from[0];
 412           to_next[0] = bi0;
 413           from += 1;
 414           to_next += 1;
 415           n_left_from -= 1;
 416           n_left_to_next -= 1;
 417           ip4_0 = NULL;
 418           ip6_0 = NULL;
 419           next0 = GPB_LPM_CLASSIFY_DROP;
 420
 421           lbi0 = ~0;
 422           eh0 = NULL;
 423           b0 = vlib_get_buffer (vm, bi0);
 424
 425           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
 426           vnet_buffer2 (b0)->gbp.flags = VXLAN_GBP_GPFLAGS_NONE;
 427
 428           if (DPO_PROTO_IP4 == dproto)
 429             ip4_0 =
 430               &((ip4_header_t *) vlib_buffer_get_current (b0))->src_address;
 431           else if (DPO_PROTO_IP6 == dproto)
 432             ip6_0 =
 433               &((ip6_header_t *) vlib_buffer_get_current (b0))->src_address;
 434           else if (DPO_PROTO_ETHERNET == dproto)
 435             {
 436               eh0 = vlib_buffer_get_current (b0);
 437               gbp_classify_get_src_ip_address (eh0, &ip4_0, &ip6_0);
 438             }
 439
 440           if (is_recirc)
 441             {
 442               gr0 = gbp_recirc_get (sw_if_index0);
 443               fib_index0 = gr0->gr_fib_index[dproto];
 444               ge0 = NULL;
 445
 446               vnet_feature_next (&next0, b0);
 447             }
 448           else
 449             {
 450               if (NULL == eh0)
 451                 {
 452                   /* packet should be l2 */
 453                   sclass0 = SCLASS_INVALID;
 454                   goto trace;
 455                 }
 456
 457               ge0 = gbp_endpoint_find_mac (eh0->src_address,
 458                                            vnet_buffer (b0)->l2.bd_index);
 459
 460               if (NULL == ge0)
 461                 {
 462                   /* packet must have come from an EP's mac */
 463                   sclass0 = SCLASS_INVALID;
 464                   goto trace;
 465                 }
 466
 467               fib_index0 = ge0->ge_fwd.gef_fib_index;
 468
 469               if (~0 == fib_index0)
 470                 {
 471                   sclass0 = SCLASS_INVALID;
 472                   goto trace;
 473                 }
 474
 475               if (ip4_0)
 476                 {
 477                   ge0 = gbp_endpoint_find_ip4 (ip4_0, fib_index0);
 478                 }
 479               else if (ip6_0)
 480                 {
 481                   ge0 = gbp_endpoint_find_ip6 (ip6_0, fib_index0);
 482                 }
 483
 484               next0 = vnet_l2_feature_next
 485                 (b0, gscm->l2_input_feat_next[GBP_SRC_CLASSIFY_LPM],
 486                  L2INPUT_FEAT_GBP_LPM_CLASSIFY);
 487
 488               /*
 489                * if we found the EP by IP lookup, it must be from the EP
 490                * not a network behind it
 491                */
 492               if (NULL != ge0)
 493                 {
 494                   sclass0 = ge0->ge_fwd.gef_sclass;
 495                   goto trace;
 496                 }
 497             }
 498
 499           if (ip4_0)
 500             {
 501               lbi0 = ip4_fib_forwarding_lookup (fib_index0, ip4_0);
 502             }
 503           else if (ip6_0)
 504             {
 505               lbi0 =
 506                 ip6_fib_table_fwding_lookup (&ip6_main, fib_index0, ip6_0);
 507             }
 508           else
 509             {
 510               /* not IP so no LPM classify possible */
 511               sclass0 = SCLASS_INVALID;
 512               next0 = GPB_LPM_CLASSIFY_DROP;
 513               goto trace;
 514             }
 515           lb0 = load_balance_get (lbi0);
 516           dpo0 = load_balance_get_bucket_i (lb0, 0);
 517
 518           if (gbp_policy_dpo_type == dpo0->dpoi_type)
 519             {
 520               gpd0 = gbp_policy_dpo_get (dpo0->dpoi_index);
 521               sclass0 = gpd0->gpd_sclass;
 522             }
 523           else
 524             {
 525               /* could not classify => drop */
 526               sclass0 = SCLASS_INVALID;
 527               goto trace;
 528             }
 529
 530         trace:
 531           vnet_buffer2 (b0)->gbp.sclass = sclass0;
 532
 533           if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
 534             {
 535               gbp_lpm_classify_trace_t *t =
 536                 vlib_add_trace (vm, node, b0, sizeof (*t));
 537               t->sclass = sclass0;
 538               t->lbi = lbi0;
 539               if (ip4_0)
 540                 t->src.ip4 = *ip4_0;
 541               if (ip6_0)
 542                 t->src.ip6 = *ip6_0;
 543             }
 544
 545           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 546                                            to_next, n_left_to_next,
 547                                            bi0, next0);
 548         }
 549
 550       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 551     }
 552
 553   return frame->n_vectors;
 554 }
 555
 556 VLIB_NODE_FN (gbp_ip4_lpm_classify_node) (vlib_main_t * vm,
 557                                           vlib_node_runtime_t * node,
 558                                           vlib_frame_t * frame)
 559 {
 560   return (gbp_lpm_classify_inline (vm, node, frame, DPO_PROTO_IP4, 1));
 561 }
 562
 563 VLIB_NODE_FN (gbp_ip6_lpm_classify_node) (vlib_main_t * vm,
 564                                           vlib_node_runtime_t * node,
 565                                           vlib_frame_t * frame)
 566 {
 567   return (gbp_lpm_classify_inline (vm, node, frame, DPO_PROTO_IP6, 1));
 568 }
 569
 570 VLIB_NODE_FN (gbp_l2_lpm_classify_node) (vlib_main_t * vm,
 571                                          vlib_node_runtime_t * node,
 572                                          vlib_frame_t * frame)
 573 {
 574   return (gbp_lpm_classify_inline (vm, node, frame, DPO_PROTO_ETHERNET, 0));
 575 }
 576
 577 /* *INDENT-OFF* */
 578 VLIB_REGISTER_NODE (gbp_ip4_lpm_classify_node) = {
 579   .name = "ip4-gbp-lpm-classify",
 580   .vector_size = sizeof (u32),
 581   .format_trace = format_gbp_lpm_classify_trace,
 582   .type = VLIB_NODE_TYPE_INTERNAL,
 583
 584   .n_errors = 0,
 585   .n_next_nodes = 1,
 586   .next_nodes = {
 587     [GPB_LPM_CLASSIFY_DROP] = "ip4-drop"
 588   },
 589 };
 590
 591 VLIB_REGISTER_NODE (gbp_ip6_lpm_classify_node) = {
 592   .name = "ip6-gbp-lpm-classify",
 593   .vector_size = sizeof (u32),
 594   .format_trace = format_gbp_lpm_classify_trace,
 595   .type = VLIB_NODE_TYPE_INTERNAL,
 596
 597   .n_errors = 0,
 598   .n_next_nodes = 1,
 599   .next_nodes = {
 600     [GPB_LPM_CLASSIFY_DROP] = "ip6-drop"
 601   },
 602 };
 603
 604 VLIB_REGISTER_NODE (gbp_l2_lpm_classify_node) = {
 605   .name = "l2-gbp-lpm-classify",
 606   .vector_size = sizeof (u32),
 607   .format_trace = format_gbp_lpm_classify_trace,
 608   .type = VLIB_NODE_TYPE_INTERNAL,
 609
 610   .n_errors = 0,
 611   .n_next_nodes = 1,
 612   .next_nodes = {
 613     [GPB_LPM_CLASSIFY_DROP] = "error-drop"
 614   },
 615 };
 616
 617 VNET_FEATURE_INIT (gbp_ip4_lpm_classify_feat_node, static) =
 618 {
 619   .arc_name = "ip4-unicast",
 620   .node_name = "ip4-gbp-lpm-classify",
 621   .runs_before = VNET_FEATURES ("nat44-out2in"),
 622 };
 623 VNET_FEATURE_INIT (gbp_ip6_lpm_classify_feat_node, static) =
 624 {
 625   .arc_name = "ip6-unicast",
 626   .node_name = "ip6-gbp-lpm-classify",
 627   .runs_before = VNET_FEATURES ("nat66-out2in"),
 628 };
 629
 630 /* *INDENT-ON* */
 631
 632 /*
 633  * fd.io coding-style-patch-verification: ON
 634  *
 635  * Local Variables:
 636  * eval: (c-set-style "gnu")
 637  * End:
 638  */