drivers/net/enic/enic_flow.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2008-2017 Cisco Systems, Inc.  All rights reserved.
   3  */
   4
   5 #include <errno.h>
   6 #include <stdint.h>
   7 #include <rte_log.h>
   8 #include <rte_ethdev_driver.h>
   9 #include <rte_flow_driver.h>
  10 #include <rte_ether.h>
  11 #include <rte_ip.h>
  12 #include <rte_udp.h>
  13
  14 #include "enic_compat.h"
  15 #include "enic.h"
  16 #include "vnic_dev.h"
  17 #include "vnic_nic.h"
  18
  19 #define FLOW_TRACE() \
  20         rte_log(RTE_LOG_DEBUG, enicpmd_logtype_flow, \
  21                 "%s()\n", __func__)
  22 #define FLOW_LOG(level, fmt, args...) \
  23         rte_log(RTE_LOG_ ## level, enicpmd_logtype_flow, \
  24                 fmt "\n", ##args)
  25
  26 /** Info about how to copy items into enic filters. */
  27 struct enic_items {
  28         /** Function for copying and validating an item. */
  29         int (*copy_item)(const struct rte_flow_item *item,
  30                          struct filter_v2 *enic_filter, u8 *inner_ofst);
  31         /** List of valid previous items. */
  32         const enum rte_flow_item_type * const prev_items;
  33         /** True if it's OK for this item to be the first item. For some NIC
  34          * versions, it's invalid to start the stack above layer 3.
  35          */
  36         const u8 valid_start_item;
  37 };
  38
  39 /** Filtering capabilities for various NIC and firmware versions. */
  40 struct enic_filter_cap {
  41         /** list of valid items and their handlers and attributes. */
  42         const struct enic_items *item_info;
  43 };
  44
  45 /* functions for copying flow actions into enic actions */
  46 typedef int (copy_action_fn)(const struct rte_flow_action actions[],
  47                              struct filter_action_v2 *enic_action);
  48
  49 /* functions for copying items into enic filters */
  50 typedef int(enic_copy_item_fn)(const struct rte_flow_item *item,
  51                           struct filter_v2 *enic_filter, u8 *inner_ofst);
  52
  53 /** Action capabilities for various NICs. */
  54 struct enic_action_cap {
  55         /** list of valid actions */
  56         const enum rte_flow_action_type *actions;
  57         /** copy function for a particular NIC */
  58         int (*copy_fn)(const struct rte_flow_action actions[],
  59                        struct filter_action_v2 *enic_action);
  60 };
  61
  62 /* Forward declarations */
  63 static enic_copy_item_fn enic_copy_item_ipv4_v1;
  64 static enic_copy_item_fn enic_copy_item_udp_v1;
  65 static enic_copy_item_fn enic_copy_item_tcp_v1;
  66 static enic_copy_item_fn enic_copy_item_eth_v2;
  67 static enic_copy_item_fn enic_copy_item_vlan_v2;
  68 static enic_copy_item_fn enic_copy_item_ipv4_v2;
  69 static enic_copy_item_fn enic_copy_item_ipv6_v2;
  70 static enic_copy_item_fn enic_copy_item_udp_v2;
  71 static enic_copy_item_fn enic_copy_item_tcp_v2;
  72 static enic_copy_item_fn enic_copy_item_sctp_v2;
  73 static enic_copy_item_fn enic_copy_item_sctp_v2;
  74 static enic_copy_item_fn enic_copy_item_vxlan_v2;
  75 static copy_action_fn enic_copy_action_v1;
  76 static copy_action_fn enic_copy_action_v2;
  77
  78 /**
  79  * Legacy NICs or NICs with outdated firmware. Only 5-tuple perfect match
  80  * is supported.
  81  */
  82 static const struct enic_items enic_items_v1[] = {
  83         [RTE_FLOW_ITEM_TYPE_IPV4] = {
  84                 .copy_item = enic_copy_item_ipv4_v1,
  85                 .valid_start_item = 1,
  86                 .prev_items = (const enum rte_flow_item_type[]) {
  87                                RTE_FLOW_ITEM_TYPE_END,
  88                 },
  89         },
  90         [RTE_FLOW_ITEM_TYPE_UDP] = {
  91                 .copy_item = enic_copy_item_udp_v1,
  92                 .valid_start_item = 0,
  93                 .prev_items = (const enum rte_flow_item_type[]) {
  94                                RTE_FLOW_ITEM_TYPE_IPV4,
  95                                RTE_FLOW_ITEM_TYPE_END,
  96                 },
  97         },
  98         [RTE_FLOW_ITEM_TYPE_TCP] = {
  99                 .copy_item = enic_copy_item_tcp_v1,
 100                 .valid_start_item = 0,
 101                 .prev_items = (const enum rte_flow_item_type[]) {
 102                                RTE_FLOW_ITEM_TYPE_IPV4,
 103                                RTE_FLOW_ITEM_TYPE_END,
 104                 },
 105         },
 106 };
 107
 108 /**
 109  * NICs have Advanced Filters capability but they are disabled. This means
 110  * that layer 3 must be specified.
 111  */
 112 static const struct enic_items enic_items_v2[] = {
 113         [RTE_FLOW_ITEM_TYPE_ETH] = {
 114                 .copy_item = enic_copy_item_eth_v2,
 115                 .valid_start_item = 1,
 116                 .prev_items = (const enum rte_flow_item_type[]) {
 117                                RTE_FLOW_ITEM_TYPE_VXLAN,
 118                                RTE_FLOW_ITEM_TYPE_END,
 119                 },
 120         },
 121         [RTE_FLOW_ITEM_TYPE_VLAN] = {
 122                 .copy_item = enic_copy_item_vlan_v2,
 123                 .valid_start_item = 1,
 124                 .prev_items = (const enum rte_flow_item_type[]) {
 125                                RTE_FLOW_ITEM_TYPE_ETH,
 126                                RTE_FLOW_ITEM_TYPE_END,
 127                 },
 128         },
 129         [RTE_FLOW_ITEM_TYPE_IPV4] = {
 130                 .copy_item = enic_copy_item_ipv4_v2,
 131                 .valid_start_item = 1,
 132                 .prev_items = (const enum rte_flow_item_type[]) {
 133                                RTE_FLOW_ITEM_TYPE_ETH,
 134                                RTE_FLOW_ITEM_TYPE_VLAN,
 135                                RTE_FLOW_ITEM_TYPE_END,
 136                 },
 137         },
 138         [RTE_FLOW_ITEM_TYPE_IPV6] = {
 139                 .copy_item = enic_copy_item_ipv6_v2,
 140                 .valid_start_item = 1,
 141                 .prev_items = (const enum rte_flow_item_type[]) {
 142                                RTE_FLOW_ITEM_TYPE_ETH,
 143                                RTE_FLOW_ITEM_TYPE_VLAN,
 144                                RTE_FLOW_ITEM_TYPE_END,
 145                 },
 146         },
 147         [RTE_FLOW_ITEM_TYPE_UDP] = {
 148                 .copy_item = enic_copy_item_udp_v2,
 149                 .valid_start_item = 0,
 150                 .prev_items = (const enum rte_flow_item_type[]) {
 151                                RTE_FLOW_ITEM_TYPE_IPV4,
 152                                RTE_FLOW_ITEM_TYPE_IPV6,
 153                                RTE_FLOW_ITEM_TYPE_END,
 154                 },
 155         },
 156         [RTE_FLOW_ITEM_TYPE_TCP] = {
 157                 .copy_item = enic_copy_item_tcp_v2,
 158                 .valid_start_item = 0,
 159                 .prev_items = (const enum rte_flow_item_type[]) {
 160                                RTE_FLOW_ITEM_TYPE_IPV4,
 161                                RTE_FLOW_ITEM_TYPE_IPV6,
 162                                RTE_FLOW_ITEM_TYPE_END,
 163                 },
 164         },
 165         [RTE_FLOW_ITEM_TYPE_SCTP] = {
 166                 .copy_item = enic_copy_item_sctp_v2,
 167                 .valid_start_item = 0,
 168                 .prev_items = (const enum rte_flow_item_type[]) {
 169                                RTE_FLOW_ITEM_TYPE_IPV4,
 170                                RTE_FLOW_ITEM_TYPE_IPV6,
 171                                RTE_FLOW_ITEM_TYPE_END,
 172                 },
 173         },
 174         [RTE_FLOW_ITEM_TYPE_VXLAN] = {
 175                 .copy_item = enic_copy_item_vxlan_v2,
 176                 .valid_start_item = 0,
 177                 .prev_items = (const enum rte_flow_item_type[]) {
 178                                RTE_FLOW_ITEM_TYPE_UDP,
 179                                RTE_FLOW_ITEM_TYPE_END,
 180                 },
 181         },
 182 };
 183
 184 /** NICs with Advanced filters enabled */
 185 static const struct enic_items enic_items_v3[] = {
 186         [RTE_FLOW_ITEM_TYPE_ETH] = {
 187                 .copy_item = enic_copy_item_eth_v2,
 188                 .valid_start_item = 1,
 189                 .prev_items = (const enum rte_flow_item_type[]) {
 190                                RTE_FLOW_ITEM_TYPE_VXLAN,
 191                                RTE_FLOW_ITEM_TYPE_END,
 192                 },
 193         },
 194         [RTE_FLOW_ITEM_TYPE_VLAN] = {
 195                 .copy_item = enic_copy_item_vlan_v2,
 196                 .valid_start_item = 1,
 197                 .prev_items = (const enum rte_flow_item_type[]) {
 198                                RTE_FLOW_ITEM_TYPE_ETH,
 199                                RTE_FLOW_ITEM_TYPE_END,
 200                 },
 201         },
 202         [RTE_FLOW_ITEM_TYPE_IPV4] = {
 203                 .copy_item = enic_copy_item_ipv4_v2,
 204                 .valid_start_item = 1,
 205                 .prev_items = (const enum rte_flow_item_type[]) {
 206                                RTE_FLOW_ITEM_TYPE_ETH,
 207                                RTE_FLOW_ITEM_TYPE_VLAN,
 208                                RTE_FLOW_ITEM_TYPE_END,
 209                 },
 210         },
 211         [RTE_FLOW_ITEM_TYPE_IPV6] = {
 212                 .copy_item = enic_copy_item_ipv6_v2,
 213                 .valid_start_item = 1,
 214                 .prev_items = (const enum rte_flow_item_type[]) {
 215                                RTE_FLOW_ITEM_TYPE_ETH,
 216                                RTE_FLOW_ITEM_TYPE_VLAN,
 217                                RTE_FLOW_ITEM_TYPE_END,
 218                 },
 219         },
 220         [RTE_FLOW_ITEM_TYPE_UDP] = {
 221                 .copy_item = enic_copy_item_udp_v2,
 222                 .valid_start_item = 1,
 223                 .prev_items = (const enum rte_flow_item_type[]) {
 224                                RTE_FLOW_ITEM_TYPE_IPV4,
 225                                RTE_FLOW_ITEM_TYPE_IPV6,
 226                                RTE_FLOW_ITEM_TYPE_END,
 227                 },
 228         },
 229         [RTE_FLOW_ITEM_TYPE_TCP] = {
 230                 .copy_item = enic_copy_item_tcp_v2,
 231                 .valid_start_item = 1,
 232                 .prev_items = (const enum rte_flow_item_type[]) {
 233                                RTE_FLOW_ITEM_TYPE_IPV4,
 234                                RTE_FLOW_ITEM_TYPE_IPV6,
 235                                RTE_FLOW_ITEM_TYPE_END,
 236                 },
 237         },
 238         [RTE_FLOW_ITEM_TYPE_SCTP] = {
 239                 .copy_item = enic_copy_item_sctp_v2,
 240                 .valid_start_item = 1,
 241                 .prev_items = (const enum rte_flow_item_type[]) {
 242                                RTE_FLOW_ITEM_TYPE_IPV4,
 243                                RTE_FLOW_ITEM_TYPE_IPV6,
 244                                RTE_FLOW_ITEM_TYPE_END,
 245                 },
 246         },
 247         [RTE_FLOW_ITEM_TYPE_VXLAN] = {
 248                 .copy_item = enic_copy_item_vxlan_v2,
 249                 .valid_start_item = 1,
 250                 .prev_items = (const enum rte_flow_item_type[]) {
 251                                RTE_FLOW_ITEM_TYPE_UDP,
 252                                RTE_FLOW_ITEM_TYPE_END,
 253                 },
 254         },
 255 };
 256
 257 /** Filtering capabilities indexed this NICs supported filter type. */
 258 static const struct enic_filter_cap enic_filter_cap[] = {
 259         [FILTER_IPV4_5TUPLE] = {
 260                 .item_info = enic_items_v1,
 261         },
 262         [FILTER_USNIC_IP] = {
 263                 .item_info = enic_items_v2,
 264         },
 265         [FILTER_DPDK_1] = {
 266                 .item_info = enic_items_v3,
 267         },
 268 };
 269
 270 /** Supported actions for older NICs */
 271 static const enum rte_flow_action_type enic_supported_actions_v1[] = {
 272         RTE_FLOW_ACTION_TYPE_QUEUE,
 273         RTE_FLOW_ACTION_TYPE_END,
 274 };
 275
 276 /** Supported actions for newer NICs */
 277 static const enum rte_flow_action_type enic_supported_actions_v2_id[] = {
 278         RTE_FLOW_ACTION_TYPE_QUEUE,
 279         RTE_FLOW_ACTION_TYPE_MARK,
 280         RTE_FLOW_ACTION_TYPE_FLAG,
 281         RTE_FLOW_ACTION_TYPE_END,
 282 };
 283
 284 static const enum rte_flow_action_type enic_supported_actions_v2_drop[] = {
 285         RTE_FLOW_ACTION_TYPE_QUEUE,
 286         RTE_FLOW_ACTION_TYPE_MARK,
 287         RTE_FLOW_ACTION_TYPE_FLAG,
 288         RTE_FLOW_ACTION_TYPE_DROP,
 289         RTE_FLOW_ACTION_TYPE_END,
 290 };
 291
 292 /** Action capabilities indexed by NIC version information */
 293 static const struct enic_action_cap enic_action_cap[] = {
 294         [FILTER_ACTION_RQ_STEERING_FLAG] = {
 295                 .actions = enic_supported_actions_v1,
 296                 .copy_fn = enic_copy_action_v1,
 297         },
 298         [FILTER_ACTION_FILTER_ID_FLAG] = {
 299                 .actions = enic_supported_actions_v2_id,
 300                 .copy_fn = enic_copy_action_v2,
 301         },
 302         [FILTER_ACTION_DROP_FLAG] = {
 303                 .actions = enic_supported_actions_v2_drop,
 304                 .copy_fn = enic_copy_action_v2,
 305         },
 306 };
 307
 308 static int
 309 mask_exact_match(const u8 *supported, const u8 *supplied,
 310                  unsigned int size)
 311 {
 312         unsigned int i;
 313         for (i = 0; i < size; i++) {
 314                 if (supported[i] != supplied[i])
 315                         return 0;
 316         }
 317         return 1;
 318 }
 319
 320 /**
 321  * Copy IPv4 item into version 1 NIC filter.
 322  *
 323  * @param item[in]
 324  *   Item specification.
 325  * @param enic_filter[out]
 326  *   Partially filled in NIC filter structure.
 327  * @param inner_ofst[in]
 328  *   Should always be 0 for version 1.
 329  */
 330 static int
 331 enic_copy_item_ipv4_v1(const struct rte_flow_item *item,
 332                        struct filter_v2 *enic_filter, u8 *inner_ofst)
 333 {
 334         const struct rte_flow_item_ipv4 *spec = item->spec;
 335         const struct rte_flow_item_ipv4 *mask = item->mask;
 336         struct filter_ipv4_5tuple *enic_5tup = &enic_filter->u.ipv4;
 337         struct ipv4_hdr supported_mask = {
 338                 .src_addr = 0xffffffff,
 339                 .dst_addr = 0xffffffff,
 340         };
 341
 342         FLOW_TRACE();
 343
 344         if (*inner_ofst)
 345                 return ENOTSUP;
 346
 347         if (!mask)
 348                 mask = &rte_flow_item_ipv4_mask;
 349
 350         /* This is an exact match filter, both fields must be set */
 351         if (!spec || !spec->hdr.src_addr || !spec->hdr.dst_addr) {
 352                 FLOW_LOG(ERR, "IPv4 exact match src/dst addr");
 353                 return ENOTSUP;
 354         }
 355
 356         /* check that the suppied mask exactly matches capabilty */
 357         if (!mask_exact_match((const u8 *)&supported_mask,
 358                               (const u8 *)item->mask, sizeof(*mask))) {
 359                 FLOW_LOG(ERR, "IPv4 exact match mask");
 360                 return ENOTSUP;
 361         }
 362
 363         enic_filter->u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;
 364         enic_5tup->src_addr = spec->hdr.src_addr;
 365         enic_5tup->dst_addr = spec->hdr.dst_addr;
 366
 367         return 0;
 368 }
 369
 370 /**
 371  * Copy UDP item into version 1 NIC filter.
 372  *
 373  * @param item[in]
 374  *   Item specification.
 375  * @param enic_filter[out]
 376  *   Partially filled in NIC filter structure.
 377  * @param inner_ofst[in]
 378  *   Should always be 0 for version 1.
 379  */
 380 static int
 381 enic_copy_item_udp_v1(const struct rte_flow_item *item,
 382                       struct filter_v2 *enic_filter, u8 *inner_ofst)
 383 {
 384         const struct rte_flow_item_udp *spec = item->spec;
 385         const struct rte_flow_item_udp *mask = item->mask;
 386         struct filter_ipv4_5tuple *enic_5tup = &enic_filter->u.ipv4;
 387         struct udp_hdr supported_mask = {
 388                 .src_port = 0xffff,
 389                 .dst_port = 0xffff,
 390         };
 391
 392         FLOW_TRACE();
 393
 394         if (*inner_ofst)
 395                 return ENOTSUP;
 396
 397         if (!mask)
 398                 mask = &rte_flow_item_udp_mask;
 399
 400         /* This is an exact match filter, both ports must be set */
 401         if (!spec || !spec->hdr.src_port || !spec->hdr.dst_port) {
 402                 FLOW_LOG(ERR, "UDP exact match src/dst addr");
 403                 return ENOTSUP;
 404         }
 405
 406         /* check that the suppied mask exactly matches capabilty */
 407         if (!mask_exact_match((const u8 *)&supported_mask,
 408                               (const u8 *)item->mask, sizeof(*mask))) {
 409                 FLOW_LOG(ERR, "UDP exact match mask");
 410                 return ENOTSUP;
 411         }
 412
 413         enic_filter->u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;
 414         enic_5tup->src_port = spec->hdr.src_port;
 415         enic_5tup->dst_port = spec->hdr.dst_port;
 416         enic_5tup->protocol = PROTO_UDP;
 417
 418         return 0;
 419 }
 420
 421 /**
 422  * Copy TCP item into version 1 NIC filter.
 423  *
 424  * @param item[in]
 425  *   Item specification.
 426  * @param enic_filter[out]
 427  *   Partially filled in NIC filter structure.
 428  * @param inner_ofst[in]
 429  *   Should always be 0 for version 1.
 430  */
 431 static int
 432 enic_copy_item_tcp_v1(const struct rte_flow_item *item,
 433                       struct filter_v2 *enic_filter, u8 *inner_ofst)
 434 {
 435         const struct rte_flow_item_tcp *spec = item->spec;
 436         const struct rte_flow_item_tcp *mask = item->mask;
 437         struct filter_ipv4_5tuple *enic_5tup = &enic_filter->u.ipv4;
 438         struct tcp_hdr supported_mask = {
 439                 .src_port = 0xffff,
 440                 .dst_port = 0xffff,
 441         };
 442
 443         FLOW_TRACE();
 444
 445         if (*inner_ofst)
 446                 return ENOTSUP;
 447
 448         if (!mask)
 449                 mask = &rte_flow_item_tcp_mask;
 450
 451         /* This is an exact match filter, both ports must be set */
 452         if (!spec || !spec->hdr.src_port || !spec->hdr.dst_port) {
 453                 FLOW_LOG(ERR, "TCPIPv4 exact match src/dst addr");
 454                 return ENOTSUP;
 455         }
 456
 457         /* check that the suppied mask exactly matches capabilty */
 458         if (!mask_exact_match((const u8 *)&supported_mask,
 459                              (const u8 *)item->mask, sizeof(*mask))) {
 460                 FLOW_LOG(ERR, "TCP exact match mask");
 461                 return ENOTSUP;
 462         }
 463
 464         enic_filter->u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;
 465         enic_5tup->src_port = spec->hdr.src_port;
 466         enic_5tup->dst_port = spec->hdr.dst_port;
 467         enic_5tup->protocol = PROTO_TCP;
 468
 469         return 0;
 470 }
 471
 472 /**
 473  * Copy ETH item into version 2 NIC filter.
 474  *
 475  * @param item[in]
 476  *   Item specification.
 477  * @param enic_filter[out]
 478  *   Partially filled in NIC filter structure.
 479  * @param inner_ofst[in]
 480  *   If zero, this is an outer header. If non-zero, this is the offset into L5
 481  *   where the header begins.
 482  */
 483 static int
 484 enic_copy_item_eth_v2(const struct rte_flow_item *item,
 485                       struct filter_v2 *enic_filter, u8 *inner_ofst)
 486 {
 487         struct ether_hdr enic_spec;
 488         struct ether_hdr enic_mask;
 489         const struct rte_flow_item_eth *spec = item->spec;
 490         const struct rte_flow_item_eth *mask = item->mask;
 491         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 492
 493         FLOW_TRACE();
 494
 495         /* Match all if no spec */
 496         if (!spec)
 497                 return 0;
 498
 499         if (!mask)
 500                 mask = &rte_flow_item_eth_mask;
 501
 502         memcpy(enic_spec.d_addr.addr_bytes, spec->dst.addr_bytes,
 503                ETHER_ADDR_LEN);
 504         memcpy(enic_spec.s_addr.addr_bytes, spec->src.addr_bytes,
 505                ETHER_ADDR_LEN);
 506
 507         memcpy(enic_mask.d_addr.addr_bytes, mask->dst.addr_bytes,
 508                ETHER_ADDR_LEN);
 509         memcpy(enic_mask.s_addr.addr_bytes, mask->src.addr_bytes,
 510                ETHER_ADDR_LEN);
 511         enic_spec.ether_type = spec->type;
 512         enic_mask.ether_type = mask->type;
 513
 514         if (*inner_ofst == 0) {
 515                 /* outer header */
 516                 memcpy(gp->layer[FILTER_GENERIC_1_L2].mask, &enic_mask,
 517                        sizeof(struct ether_hdr));
 518                 memcpy(gp->layer[FILTER_GENERIC_1_L2].val, &enic_spec,
 519                        sizeof(struct ether_hdr));
 520         } else {
 521                 /* inner header */
 522                 if ((*inner_ofst + sizeof(struct ether_hdr)) >
 523                      FILTER_GENERIC_1_KEY_LEN)
 524                         return ENOTSUP;
 525                 /* Offset into L5 where inner Ethernet header goes */
 526                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
 527                        &enic_mask, sizeof(struct ether_hdr));
 528                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
 529                        &enic_spec, sizeof(struct ether_hdr));
 530                 *inner_ofst += sizeof(struct ether_hdr);
 531         }
 532         return 0;
 533 }
 534
 535 /**
 536  * Copy VLAN item into version 2 NIC filter.
 537  *
 538  * @param item[in]
 539  *   Item specification.
 540  * @param enic_filter[out]
 541  *   Partially filled in NIC filter structure.
 542  * @param inner_ofst[in]
 543  *   If zero, this is an outer header. If non-zero, this is the offset into L5
 544  *   where the header begins.
 545  */
 546 static int
 547 enic_copy_item_vlan_v2(const struct rte_flow_item *item,
 548                        struct filter_v2 *enic_filter, u8 *inner_ofst)
 549 {
 550         const struct rte_flow_item_vlan *spec = item->spec;
 551         const struct rte_flow_item_vlan *mask = item->mask;
 552         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 553
 554         FLOW_TRACE();
 555
 556         /* Match all if no spec */
 557         if (!spec)
 558                 return 0;
 559
 560         if (!mask)
 561                 mask = &rte_flow_item_vlan_mask;
 562
 563         if (*inner_ofst == 0) {
 564                 struct ether_hdr *eth_mask =
 565                         (void *)gp->layer[FILTER_GENERIC_1_L2].mask;
 566                 struct ether_hdr *eth_val =
 567                         (void *)gp->layer[FILTER_GENERIC_1_L2].val;
 568
 569                 /* Outer TPID cannot be matched */
 570                 if (eth_mask->ether_type)
 571                         return ENOTSUP;
 572                 eth_mask->ether_type = mask->inner_type;
 573                 eth_val->ether_type = spec->inner_type;
 574
 575                 /* Outer header. Use the vlan mask/val fields */
 576                 gp->mask_vlan = mask->tci;
 577                 gp->val_vlan = spec->tci;
 578         } else {
 579                 /* Inner header. Mask/Val start at *inner_ofst into L5 */
 580                 if ((*inner_ofst + sizeof(struct vlan_hdr)) >
 581                      FILTER_GENERIC_1_KEY_LEN)
 582                         return ENOTSUP;
 583                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
 584                        mask, sizeof(struct vlan_hdr));
 585                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
 586                        spec, sizeof(struct vlan_hdr));
 587                 *inner_ofst += sizeof(struct vlan_hdr);
 588         }
 589         return 0;
 590 }
 591
 592 /**
 593  * Copy IPv4 item into version 2 NIC filter.
 594  *
 595  * @param item[in]
 596  *   Item specification.
 597  * @param enic_filter[out]
 598  *   Partially filled in NIC filter structure.
 599  * @param inner_ofst[in]
 600  *   Must be 0. Don't support inner IPv4 filtering.
 601  */
 602 static int
 603 enic_copy_item_ipv4_v2(const struct rte_flow_item *item,
 604                        struct filter_v2 *enic_filter, u8 *inner_ofst)
 605 {
 606         const struct rte_flow_item_ipv4 *spec = item->spec;
 607         const struct rte_flow_item_ipv4 *mask = item->mask;
 608         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 609
 610         FLOW_TRACE();
 611
 612         if (*inner_ofst == 0) {
 613                 /* Match IPv4 */
 614                 gp->mask_flags |= FILTER_GENERIC_1_IPV4;
 615                 gp->val_flags |= FILTER_GENERIC_1_IPV4;
 616
 617                 /* Match all if no spec */
 618                 if (!spec)
 619                         return 0;
 620
 621                 if (!mask)
 622                         mask = &rte_flow_item_ipv4_mask;
 623
 624                 memcpy(gp->layer[FILTER_GENERIC_1_L3].mask, &mask->hdr,
 625                        sizeof(struct ipv4_hdr));
 626                 memcpy(gp->layer[FILTER_GENERIC_1_L3].val, &spec->hdr,
 627                        sizeof(struct ipv4_hdr));
 628         } else {
 629                 /* Inner IPv4 header. Mask/Val start at *inner_ofst into L5 */
 630                 if ((*inner_ofst + sizeof(struct ipv4_hdr)) >
 631                      FILTER_GENERIC_1_KEY_LEN)
 632                         return ENOTSUP;
 633                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
 634                        mask, sizeof(struct ipv4_hdr));
 635                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
 636                        spec, sizeof(struct ipv4_hdr));
 637                 *inner_ofst += sizeof(struct ipv4_hdr);
 638         }
 639         return 0;
 640 }
 641
 642 /**
 643  * Copy IPv6 item into version 2 NIC filter.
 644  *
 645  * @param item[in]
 646  *   Item specification.
 647  * @param enic_filter[out]
 648  *   Partially filled in NIC filter structure.
 649  * @param inner_ofst[in]
 650  *   Must be 0. Don't support inner IPv6 filtering.
 651  */
 652 static int
 653 enic_copy_item_ipv6_v2(const struct rte_flow_item *item,
 654                        struct filter_v2 *enic_filter, u8 *inner_ofst)
 655 {
 656         const struct rte_flow_item_ipv6 *spec = item->spec;
 657         const struct rte_flow_item_ipv6 *mask = item->mask;
 658         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 659
 660         FLOW_TRACE();
 661
 662         /* Match IPv6 */
 663         gp->mask_flags |= FILTER_GENERIC_1_IPV6;
 664         gp->val_flags |= FILTER_GENERIC_1_IPV6;
 665
 666         /* Match all if no spec */
 667         if (!spec)
 668                 return 0;
 669
 670         if (!mask)
 671                 mask = &rte_flow_item_ipv6_mask;
 672
 673         if (*inner_ofst == 0) {
 674                 memcpy(gp->layer[FILTER_GENERIC_1_L3].mask, &mask->hdr,
 675                        sizeof(struct ipv6_hdr));
 676                 memcpy(gp->layer[FILTER_GENERIC_1_L3].val, &spec->hdr,
 677                        sizeof(struct ipv6_hdr));
 678         } else {
 679                 /* Inner IPv6 header. Mask/Val start at *inner_ofst into L5 */
 680                 if ((*inner_ofst + sizeof(struct ipv6_hdr)) >
 681                      FILTER_GENERIC_1_KEY_LEN)
 682                         return ENOTSUP;
 683                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
 684                        mask, sizeof(struct ipv6_hdr));
 685                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
 686                        spec, sizeof(struct ipv6_hdr));
 687                 *inner_ofst += sizeof(struct ipv6_hdr);
 688         }
 689         return 0;
 690 }
 691
 692 /**
 693  * Copy UDP item into version 2 NIC filter.
 694  *
 695  * @param item[in]
 696  *   Item specification.
 697  * @param enic_filter[out]
 698  *   Partially filled in NIC filter structure.
 699  * @param inner_ofst[in]
 700  *   Must be 0. Don't support inner UDP filtering.
 701  */
 702 static int
 703 enic_copy_item_udp_v2(const struct rte_flow_item *item,
 704                       struct filter_v2 *enic_filter, u8 *inner_ofst)
 705 {
 706         const struct rte_flow_item_udp *spec = item->spec;
 707         const struct rte_flow_item_udp *mask = item->mask;
 708         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 709
 710         FLOW_TRACE();
 711
 712         /* Match UDP */
 713         gp->mask_flags |= FILTER_GENERIC_1_UDP;
 714         gp->val_flags |= FILTER_GENERIC_1_UDP;
 715
 716         /* Match all if no spec */
 717         if (!spec)
 718                 return 0;
 719
 720         if (!mask)
 721                 mask = &rte_flow_item_udp_mask;
 722
 723         if (*inner_ofst == 0) {
 724                 memcpy(gp->layer[FILTER_GENERIC_1_L4].mask, &mask->hdr,
 725                        sizeof(struct udp_hdr));
 726                 memcpy(gp->layer[FILTER_GENERIC_1_L4].val, &spec->hdr,
 727                        sizeof(struct udp_hdr));
 728         } else {
 729                 /* Inner IPv6 header. Mask/Val start at *inner_ofst into L5 */
 730                 if ((*inner_ofst + sizeof(struct udp_hdr)) >
 731                      FILTER_GENERIC_1_KEY_LEN)
 732                         return ENOTSUP;
 733                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
 734                        mask, sizeof(struct udp_hdr));
 735                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
 736                        spec, sizeof(struct udp_hdr));
 737                 *inner_ofst += sizeof(struct udp_hdr);
 738         }
 739         return 0;
 740 }
 741
 742 /**
 743  * Copy TCP item into version 2 NIC filter.
 744  *
 745  * @param item[in]
 746  *   Item specification.
 747  * @param enic_filter[out]
 748  *   Partially filled in NIC filter structure.
 749  * @param inner_ofst[in]
 750  *   Must be 0. Don't support inner TCP filtering.
 751  */
 752 static int
 753 enic_copy_item_tcp_v2(const struct rte_flow_item *item,
 754                       struct filter_v2 *enic_filter, u8 *inner_ofst)
 755 {
 756         const struct rte_flow_item_tcp *spec = item->spec;
 757         const struct rte_flow_item_tcp *mask = item->mask;
 758         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 759
 760         FLOW_TRACE();
 761
 762         /* Match TCP */
 763         gp->mask_flags |= FILTER_GENERIC_1_TCP;
 764         gp->val_flags |= FILTER_GENERIC_1_TCP;
 765
 766         /* Match all if no spec */
 767         if (!spec)
 768                 return 0;
 769
 770         if (!mask)
 771                 return ENOTSUP;
 772
 773         if (*inner_ofst == 0) {
 774                 memcpy(gp->layer[FILTER_GENERIC_1_L4].mask, &mask->hdr,
 775                        sizeof(struct tcp_hdr));
 776                 memcpy(gp->layer[FILTER_GENERIC_1_L4].val, &spec->hdr,
 777                        sizeof(struct tcp_hdr));
 778         } else {
 779                 /* Inner IPv6 header. Mask/Val start at *inner_ofst into L5 */
 780                 if ((*inner_ofst + sizeof(struct tcp_hdr)) >
 781                      FILTER_GENERIC_1_KEY_LEN)
 782                         return ENOTSUP;
 783                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].mask[*inner_ofst],
 784                        mask, sizeof(struct tcp_hdr));
 785                 memcpy(&gp->layer[FILTER_GENERIC_1_L5].val[*inner_ofst],
 786                        spec, sizeof(struct tcp_hdr));
 787                 *inner_ofst += sizeof(struct tcp_hdr);
 788         }
 789         return 0;
 790 }
 791
 792 /**
 793  * Copy SCTP item into version 2 NIC filter.
 794  *
 795  * @param item[in]
 796  *   Item specification.
 797  * @param enic_filter[out]
 798  *   Partially filled in NIC filter structure.
 799  * @param inner_ofst[in]
 800  *   Must be 0. Don't support inner SCTP filtering.
 801  */
 802 static int
 803 enic_copy_item_sctp_v2(const struct rte_flow_item *item,
 804                        struct filter_v2 *enic_filter, u8 *inner_ofst)
 805 {
 806         const struct rte_flow_item_sctp *spec = item->spec;
 807         const struct rte_flow_item_sctp *mask = item->mask;
 808         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 809
 810         FLOW_TRACE();
 811
 812         if (*inner_ofst)
 813                 return ENOTSUP;
 814
 815         /* Match all if no spec */
 816         if (!spec)
 817                 return 0;
 818
 819         if (!mask)
 820                 mask = &rte_flow_item_sctp_mask;
 821
 822         memcpy(gp->layer[FILTER_GENERIC_1_L4].mask, &mask->hdr,
 823                sizeof(struct sctp_hdr));
 824         memcpy(gp->layer[FILTER_GENERIC_1_L4].val, &spec->hdr,
 825                sizeof(struct sctp_hdr));
 826         return 0;
 827 }
 828
 829 /**
 830  * Copy UDP item into version 2 NIC filter.
 831  *
 832  * @param item[in]
 833  *   Item specification.
 834  * @param enic_filter[out]
 835  *   Partially filled in NIC filter structure.
 836  * @param inner_ofst[in]
 837  *   Must be 0. VxLAN headers always start at the beginning of L5.
 838  */
 839 static int
 840 enic_copy_item_vxlan_v2(const struct rte_flow_item *item,
 841                         struct filter_v2 *enic_filter, u8 *inner_ofst)
 842 {
 843         const struct rte_flow_item_vxlan *spec = item->spec;
 844         const struct rte_flow_item_vxlan *mask = item->mask;
 845         struct filter_generic_1 *gp = &enic_filter->u.generic_1;
 846
 847         FLOW_TRACE();
 848
 849         if (*inner_ofst)
 850                 return EINVAL;
 851
 852         /* Match all if no spec */
 853         if (!spec)
 854                 return 0;
 855
 856         if (!mask)
 857                 mask = &rte_flow_item_vxlan_mask;
 858
 859         memcpy(gp->layer[FILTER_GENERIC_1_L5].mask, mask,
 860                sizeof(struct vxlan_hdr));
 861         memcpy(gp->layer[FILTER_GENERIC_1_L5].val, spec,
 862                sizeof(struct vxlan_hdr));
 863
 864         *inner_ofst = sizeof(struct vxlan_hdr);
 865         return 0;
 866 }
 867
 868 /**
 869  * Return 1 if current item is valid on top of the previous one.
 870  *
 871  * @param prev_item[in]
 872  *   The item before this one in the pattern or RTE_FLOW_ITEM_TYPE_END if this
 873  *   is the first item.
 874  * @param item_info[in]
 875  *   Info about this item, like valid previous items.
 876  * @param is_first[in]
 877  *   True if this the first item in the pattern.
 878  */
 879 static int
 880 item_stacking_valid(enum rte_flow_item_type prev_item,
 881                     const struct enic_items *item_info, u8 is_first_item)
 882 {
 883         enum rte_flow_item_type const *allowed_items = item_info->prev_items;
 884
 885         FLOW_TRACE();
 886
 887         for (; *allowed_items != RTE_FLOW_ITEM_TYPE_END; allowed_items++) {
 888                 if (prev_item == *allowed_items)
 889                         return 1;
 890         }
 891
 892         /* This is the first item in the stack. Check if that's cool */
 893         if (is_first_item && item_info->valid_start_item)
 894                 return 1;
 895
 896         return 0;
 897 }
 898
 899 /**
 900  * Build the intenal enic filter structure from the provided pattern. The
 901  * pattern is validated as the items are copied.
 902  *
 903  * @param pattern[in]
 904  * @param items_info[in]
 905  *   Info about this NICs item support, like valid previous items.
 906  * @param enic_filter[out]
 907  *   NIC specfilc filters derived from the pattern.
 908  * @param error[out]
 909  */
 910 static int
 911 enic_copy_filter(const struct rte_flow_item pattern[],
 912                  const struct enic_items *items_info,
 913                  struct filter_v2 *enic_filter,
 914                  struct rte_flow_error *error)
 915 {
 916         int ret;
 917         const struct rte_flow_item *item = pattern;
 918         u8 inner_ofst = 0; /* If encapsulated, ofst into L5 */
 919         enum rte_flow_item_type prev_item;
 920         const struct enic_items *item_info;
 921
 922         u8 is_first_item = 1;
 923
 924         FLOW_TRACE();
 925
 926         prev_item = 0;
 927
 928         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
 929                 /* Get info about how to validate and copy the item. If NULL
 930                  * is returned the nic does not support the item.
 931                  */
 932                 if (item->type == RTE_FLOW_ITEM_TYPE_VOID)
 933                         continue;
 934
 935                 item_info = &items_info[item->type];
 936
 937                 /* check to see if item stacking is valid */
 938                 if (!item_stacking_valid(prev_item, item_info, is_first_item))
 939                         goto stacking_error;
 940
 941                 ret = item_info->copy_item(item, enic_filter, &inner_ofst);
 942                 if (ret)
 943                         goto item_not_supported;
 944                 prev_item = item->type;
 945                 is_first_item = 0;
 946         }
 947         return 0;
 948
 949 item_not_supported:
 950         rte_flow_error_set(error, ret, RTE_FLOW_ERROR_TYPE_ITEM,
 951                            NULL, "enic type error");
 952         return -rte_errno;
 953
 954 stacking_error:
 955         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
 956                            item, "stacking error");
 957         return -rte_errno;
 958 }
 959
 960 /**
 961  * Build the intenal version 1 NIC action structure from the provided pattern.
 962  * The pattern is validated as the items are copied.
 963  *
 964  * @param actions[in]
 965  * @param enic_action[out]
 966  *   NIC specfilc actions derived from the actions.
 967  * @param error[out]
 968  */
 969 static int
 970 enic_copy_action_v1(const struct rte_flow_action actions[],
 971                     struct filter_action_v2 *enic_action)
 972 {
 973         enum { FATE = 1, };
 974         uint32_t overlap = 0;
 975
 976         FLOW_TRACE();
 977
 978         for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
 979                 if (actions->type == RTE_FLOW_ACTION_TYPE_VOID)
 980                         continue;
 981
 982                 switch (actions->type) {
 983                 case RTE_FLOW_ACTION_TYPE_QUEUE: {
 984                         const struct rte_flow_action_queue *queue =
 985                                 (const struct rte_flow_action_queue *)
 986                                 actions->conf;
 987
 988                         if (overlap & FATE)
 989                                 return ENOTSUP;
 990                         overlap |= FATE;
 991                         enic_action->rq_idx =
 992                                 enic_rte_rq_idx_to_sop_idx(queue->index);
 993                         break;
 994                 }
 995                 default:
 996                         RTE_ASSERT(0);
 997                         break;
 998                 }
 999         }
1000         if (!(overlap & FATE))
1001                 return ENOTSUP;
1002         enic_action->type = FILTER_ACTION_RQ_STEERING;
1003         return 0;
1004 }
1005
1006 /**
1007  * Build the intenal version 2 NIC action structure from the provided pattern.
1008  * The pattern is validated as the items are copied.
1009  *
1010  * @param actions[in]
1011  * @param enic_action[out]
1012  *   NIC specfilc actions derived from the actions.
1013  * @param error[out]
1014  */
1015 static int
1016 enic_copy_action_v2(const struct rte_flow_action actions[],
1017                     struct filter_action_v2 *enic_action)
1018 {
1019         enum { FATE = 1, MARK = 2, };
1020         uint32_t overlap = 0;
1021
1022         FLOW_TRACE();
1023
1024         for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
1025                 switch (actions->type) {
1026                 case RTE_FLOW_ACTION_TYPE_QUEUE: {
1027                         const struct rte_flow_action_queue *queue =
1028                                 (const struct rte_flow_action_queue *)
1029                                 actions->conf;
1030
1031                         if (overlap & FATE)
1032                                 return ENOTSUP;
1033                         overlap |= FATE;
1034                         enic_action->rq_idx =
1035                                 enic_rte_rq_idx_to_sop_idx(queue->index);
1036                         enic_action->flags |= FILTER_ACTION_RQ_STEERING_FLAG;
1037                         break;
1038                 }
1039                 case RTE_FLOW_ACTION_TYPE_MARK: {
1040                         const struct rte_flow_action_mark *mark =
1041                                 (const struct rte_flow_action_mark *)
1042                                 actions->conf;
1043
1044                         if (overlap & MARK)
1045                                 return ENOTSUP;
1046                         overlap |= MARK;
1047                         /* ENIC_MAGIC_FILTER_ID is reserved and is the highest
1048                          * in the range of allows mark ids.
1049                          */
1050                         if (mark->id >= ENIC_MAGIC_FILTER_ID)
1051                                 return EINVAL;
1052                         enic_action->filter_id = mark->id;
1053                         enic_action->flags |= FILTER_ACTION_FILTER_ID_FLAG;
1054                         break;
1055                 }
1056                 case RTE_FLOW_ACTION_TYPE_FLAG: {
1057                         if (overlap & MARK)
1058                                 return ENOTSUP;
1059                         overlap |= MARK;
1060                         enic_action->filter_id = ENIC_MAGIC_FILTER_ID;
1061                         enic_action->flags |= FILTER_ACTION_FILTER_ID_FLAG;
1062                         break;
1063                 }
1064                 case RTE_FLOW_ACTION_TYPE_DROP: {
1065                         enic_action->flags |= FILTER_ACTION_DROP_FLAG;
1066                         break;
1067                 }
1068                 case RTE_FLOW_ACTION_TYPE_VOID:
1069                         continue;
1070                 default:
1071                         RTE_ASSERT(0);
1072                         break;
1073                 }
1074         }
1075         if (!(overlap & FATE))
1076                 return ENOTSUP;
1077         enic_action->type = FILTER_ACTION_V2;
1078         return 0;
1079 }
1080
1081 /** Check if the action is supported */
1082 static int
1083 enic_match_action(const struct rte_flow_action *action,
1084                   const enum rte_flow_action_type *supported_actions)
1085 {
1086         for (; *supported_actions != RTE_FLOW_ACTION_TYPE_END;
1087              supported_actions++) {
1088                 if (action->type == *supported_actions)
1089                         return 1;
1090         }
1091         return 0;
1092 }
1093
1094 /** Get the NIC filter capabilties structure */
1095 static const struct enic_filter_cap *
1096 enic_get_filter_cap(struct enic *enic)
1097 {
1098         if (enic->flow_filter_mode)
1099                 return &enic_filter_cap[enic->flow_filter_mode];
1100
1101         return NULL;
1102 }
1103
1104 /** Get the actions for this NIC version. */
1105 static const struct enic_action_cap *
1106 enic_get_action_cap(struct enic *enic)
1107 {
1108         const struct enic_action_cap *ea;
1109         uint8_t actions;
1110
1111         actions = enic->filter_actions;
1112         if (actions & FILTER_ACTION_DROP_FLAG)
1113                 ea = &enic_action_cap[FILTER_ACTION_DROP_FLAG];
1114         else if (actions & FILTER_ACTION_FILTER_ID_FLAG)
1115                 ea = &enic_action_cap[FILTER_ACTION_FILTER_ID_FLAG];
1116         else
1117                 ea = &enic_action_cap[FILTER_ACTION_RQ_STEERING_FLAG];
1118         return ea;
1119 }
1120
1121 /* Debug function to dump internal NIC action structure. */
1122 static void
1123 enic_dump_actions(const struct filter_action_v2 *ea)
1124 {
1125         if (ea->type == FILTER_ACTION_RQ_STEERING) {
1126                 FLOW_LOG(INFO, "Action(V1), queue: %u\n", ea->rq_idx);
1127         } else if (ea->type == FILTER_ACTION_V2) {
1128                 FLOW_LOG(INFO, "Actions(V2)\n");
1129                 if (ea->flags & FILTER_ACTION_RQ_STEERING_FLAG)
1130                         FLOW_LOG(INFO, "\tqueue: %u\n",
1131                                enic_sop_rq_idx_to_rte_idx(ea->rq_idx));
1132                 if (ea->flags & FILTER_ACTION_FILTER_ID_FLAG)
1133                         FLOW_LOG(INFO, "\tfilter_id: %u\n", ea->filter_id);
1134         }
1135 }
1136
1137 /* Debug function to dump internal NIC filter structure. */
1138 static void
1139 enic_dump_filter(const struct filter_v2 *filt)
1140 {
1141         const struct filter_generic_1 *gp;
1142         int i, j, mbyte;
1143         char buf[128], *bp;
1144         char ip4[16], ip6[16], udp[16], tcp[16], tcpudp[16], ip4csum[16];
1145         char l4csum[16], ipfrag[16];
1146
1147         switch (filt->type) {
1148         case FILTER_IPV4_5TUPLE:
1149                 FLOW_LOG(INFO, "FILTER_IPV4_5TUPLE\n");
1150                 break;
1151         case FILTER_USNIC_IP:
1152         case FILTER_DPDK_1:
1153                 /* FIXME: this should be a loop */
1154                 gp = &filt->u.generic_1;
1155                 FLOW_LOG(INFO, "Filter: vlan: 0x%04x, mask: 0x%04x\n",
1156                        gp->val_vlan, gp->mask_vlan);
1157
1158                 if (gp->mask_flags & FILTER_GENERIC_1_IPV4)
1159                         sprintf(ip4, "%s ",
1160                                 (gp->val_flags & FILTER_GENERIC_1_IPV4)
1161                                  ? "ip4(y)" : "ip4(n)");
1162                 else
1163                         sprintf(ip4, "%s ", "ip4(x)");
1164
1165                 if (gp->mask_flags & FILTER_GENERIC_1_IPV6)
1166                         sprintf(ip6, "%s ",
1167                                 (gp->val_flags & FILTER_GENERIC_1_IPV4)
1168                                  ? "ip6(y)" : "ip6(n)");
1169                 else
1170                         sprintf(ip6, "%s ", "ip6(x)");
1171
1172                 if (gp->mask_flags & FILTER_GENERIC_1_UDP)
1173                         sprintf(udp, "%s ",
1174                                 (gp->val_flags & FILTER_GENERIC_1_UDP)
1175                                  ? "udp(y)" : "udp(n)");
1176                 else
1177                         sprintf(udp, "%s ", "udp(x)");
1178
1179                 if (gp->mask_flags & FILTER_GENERIC_1_TCP)
1180                         sprintf(tcp, "%s ",
1181                                 (gp->val_flags & FILTER_GENERIC_1_TCP)
1182                                  ? "tcp(y)" : "tcp(n)");
1183                 else
1184                         sprintf(tcp, "%s ", "tcp(x)");
1185
1186                 if (gp->mask_flags & FILTER_GENERIC_1_TCP_OR_UDP)
1187                         sprintf(tcpudp, "%s ",
1188                                 (gp->val_flags & FILTER_GENERIC_1_TCP_OR_UDP)
1189                                  ? "tcpudp(y)" : "tcpudp(n)");
1190                 else
1191                         sprintf(tcpudp, "%s ", "tcpudp(x)");
1192
1193                 if (gp->mask_flags & FILTER_GENERIC_1_IP4SUM_OK)
1194                         sprintf(ip4csum, "%s ",
1195                                 (gp->val_flags & FILTER_GENERIC_1_IP4SUM_OK)
1196                                  ? "ip4csum(y)" : "ip4csum(n)");
1197                 else
1198                         sprintf(ip4csum, "%s ", "ip4csum(x)");
1199
1200                 if (gp->mask_flags & FILTER_GENERIC_1_L4SUM_OK)
1201                         sprintf(l4csum, "%s ",
1202                                 (gp->val_flags & FILTER_GENERIC_1_L4SUM_OK)
1203                                  ? "l4csum(y)" : "l4csum(n)");
1204                 else
1205                         sprintf(l4csum, "%s ", "l4csum(x)");
1206
1207                 if (gp->mask_flags & FILTER_GENERIC_1_IPFRAG)
1208                         sprintf(ipfrag, "%s ",
1209                                 (gp->val_flags & FILTER_GENERIC_1_IPFRAG)
1210                                  ? "ipfrag(y)" : "ipfrag(n)");
1211                 else
1212                         sprintf(ipfrag, "%s ", "ipfrag(x)");
1213                 FLOW_LOG(INFO, "\tFlags: %s%s%s%s%s%s%s%s\n", ip4, ip6, udp,
1214                          tcp, tcpudp, ip4csum, l4csum, ipfrag);
1215
1216                 for (i = 0; i < FILTER_GENERIC_1_NUM_LAYERS; i++) {
1217                         mbyte = FILTER_GENERIC_1_KEY_LEN - 1;
1218                         while (mbyte && !gp->layer[i].mask[mbyte])
1219                                 mbyte--;
1220                         if (mbyte == 0)
1221                                 continue;
1222
1223                         bp = buf;
1224                         for (j = 0; j <= mbyte; j++) {
1225                                 sprintf(bp, "%02x",
1226                                         gp->layer[i].mask[j]);
1227                                 bp += 2;
1228                         }
1229                         *bp = '\0';
1230                         FLOW_LOG(INFO, "\tL%u mask: %s\n", i + 2, buf);
1231                         bp = buf;
1232                         for (j = 0; j <= mbyte; j++) {
1233                                 sprintf(bp, "%02x",
1234                                         gp->layer[i].val[j]);
1235                                 bp += 2;
1236                         }
1237                         *bp = '\0';
1238                         FLOW_LOG(INFO, "\tL%u  val: %s\n", i + 2, buf);
1239                 }
1240                 break;
1241         default:
1242                 FLOW_LOG(INFO, "FILTER UNKNOWN\n");
1243                 break;
1244         }
1245 }
1246
1247 /* Debug function to dump internal NIC flow structures. */
1248 static void
1249 enic_dump_flow(const struct filter_action_v2 *ea, const struct filter_v2 *filt)
1250 {
1251         enic_dump_filter(filt);
1252         enic_dump_actions(ea);
1253 }
1254
1255
1256 /**
1257  * Internal flow parse/validate function.
1258  *
1259  * @param dev[in]
1260  *   This device pointer.
1261  * @param pattern[in]
1262  * @param actions[in]
1263  * @param error[out]
1264  * @param enic_filter[out]
1265  *   Internal NIC filter structure pointer.
1266  * @param enic_action[out]
1267  *   Internal NIC action structure pointer.
1268  */
1269 static int
1270 enic_flow_parse(struct rte_eth_dev *dev,
1271                 const struct rte_flow_attr *attrs,
1272                 const struct rte_flow_item pattern[],
1273                 const struct rte_flow_action actions[],
1274                 struct rte_flow_error *error,
1275                 struct filter_v2 *enic_filter,
1276                 struct filter_action_v2 *enic_action)
1277 {
1278         unsigned int ret = 0;
1279         struct enic *enic = pmd_priv(dev);
1280         const struct enic_filter_cap *enic_filter_cap;
1281         const struct enic_action_cap *enic_action_cap;
1282         const struct rte_flow_action *action;
1283
1284         FLOW_TRACE();
1285
1286         memset(enic_filter, 0, sizeof(*enic_filter));
1287         memset(enic_action, 0, sizeof(*enic_action));
1288
1289         if (!pattern) {
1290                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1291                                    NULL, "No pattern specified");
1292                 return -rte_errno;
1293         }
1294
1295         if (!actions) {
1296                 rte_flow_error_set(error, EINVAL,
1297                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1298                                    NULL, "No action specified");
1299                 return -rte_errno;
1300         }
1301
1302         if (attrs) {
1303                 if (attrs->group) {
1304                         rte_flow_error_set(error, ENOTSUP,
1305                                            RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
1306                                            NULL,
1307                                            "priority groups are not supported");
1308                         return -rte_errno;
1309                 } else if (attrs->priority) {
1310                         rte_flow_error_set(error, ENOTSUP,
1311                                            RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
1312                                            NULL,
1313                                            "priorities are not supported");
1314                         return -rte_errno;
1315                 } else if (attrs->egress) {
1316                         rte_flow_error_set(error, ENOTSUP,
1317                                            RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
1318                                            NULL,
1319                                            "egress is not supported");
1320                         return -rte_errno;
1321                 } else if (!attrs->ingress) {
1322                         rte_flow_error_set(error, ENOTSUP,
1323                                            RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
1324                                            NULL,
1325                                            "only ingress is supported");
1326                         return -rte_errno;
1327                 }
1328
1329         } else {
1330                 rte_flow_error_set(error, EINVAL,
1331                                    RTE_FLOW_ERROR_TYPE_ATTR,
1332                                    NULL, "No attribute specified");
1333                 return -rte_errno;
1334         }
1335
1336         /* Verify Actions. */
1337         enic_action_cap =  enic_get_action_cap(enic);
1338         for (action = &actions[0]; action->type != RTE_FLOW_ACTION_TYPE_END;
1339              action++) {
1340                 if (action->type == RTE_FLOW_ACTION_TYPE_VOID)
1341                         continue;
1342                 else if (!enic_match_action(action, enic_action_cap->actions))
1343                         break;
1344         }
1345         if (action->type != RTE_FLOW_ACTION_TYPE_END) {
1346                 rte_flow_error_set(error, EPERM, RTE_FLOW_ERROR_TYPE_ACTION,
1347                                    action, "Invalid action.");
1348                 return -rte_errno;
1349         }
1350         ret = enic_action_cap->copy_fn(actions, enic_action);
1351         if (ret) {
1352                 rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
1353                            NULL, "Unsupported action.");
1354                 return -rte_errno;
1355         }
1356
1357         /* Verify Flow items. If copying the filter from flow format to enic
1358          * format fails, the flow is not supported
1359          */
1360         enic_filter_cap =  enic_get_filter_cap(enic);
1361         if (enic_filter_cap == NULL) {
1362                 rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_HANDLE,
1363                            NULL, "Flow API not available");
1364                 return -rte_errno;
1365         }
1366         enic_filter->type = enic->flow_filter_mode;
1367         ret = enic_copy_filter(pattern, enic_filter_cap->item_info,
1368                                        enic_filter, error);
1369         return ret;
1370 }
1371
1372 /**
1373  * Push filter/action to the NIC.
1374  *
1375  * @param enic[in]
1376  *   Device structure pointer.
1377  * @param enic_filter[in]
1378  *   Internal NIC filter structure pointer.
1379  * @param enic_action[in]
1380  *   Internal NIC action structure pointer.
1381  * @param error[out]
1382  */
1383 static struct rte_flow *
1384 enic_flow_add_filter(struct enic *enic, struct filter_v2 *enic_filter,
1385                    struct filter_action_v2 *enic_action,
1386                    struct rte_flow_error *error)
1387 {
1388         struct rte_flow *flow;
1389         int ret;
1390         u16 entry;
1391
1392         FLOW_TRACE();
1393
1394         flow = rte_calloc(__func__, 1, sizeof(*flow), 0);
1395         if (!flow) {
1396                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
1397                                    NULL, "cannot allocate flow memory");
1398                 return NULL;
1399         }
1400
1401         /* entry[in] is the queue id, entry[out] is the filter Id for delete */
1402         entry = enic_action->rq_idx;
1403         ret = vnic_dev_classifier(enic->vdev, CLSF_ADD, &entry, enic_filter,
1404                                   enic_action);
1405         if (!ret) {
1406                 flow->enic_filter_id = entry;
1407                 flow->enic_filter = *enic_filter;
1408         } else {
1409                 rte_flow_error_set(error, ret, RTE_FLOW_ERROR_TYPE_HANDLE,
1410                                    NULL, "vnic_dev_classifier error");
1411                 rte_free(flow);
1412                 return NULL;
1413         }
1414         return flow;
1415 }
1416
1417 /**
1418  * Remove filter/action from the NIC.
1419  *
1420  * @param enic[in]
1421  *   Device structure pointer.
1422  * @param filter_id[in]
1423  *   Id of NIC filter.
1424  * @param enic_action[in]
1425  *   Internal NIC action structure pointer.
1426  * @param error[out]
1427  */
1428 static int
1429 enic_flow_del_filter(struct enic *enic, u16 filter_id,
1430                    struct rte_flow_error *error)
1431 {
1432         int ret;
1433
1434         FLOW_TRACE();
1435
1436         ret = vnic_dev_classifier(enic->vdev, CLSF_DEL, &filter_id, NULL, NULL);
1437         if (!ret)
1438                 rte_flow_error_set(error, ret, RTE_FLOW_ERROR_TYPE_HANDLE,
1439                                    NULL, "vnic_dev_classifier failed");
1440         return ret;
1441 }
1442
1443 /*
1444  * The following functions are callbacks for Generic flow API.
1445  */
1446
1447 /**
1448  * Validate a flow supported by the NIC.
1449  *
1450  * @see rte_flow_validate()
1451  * @see rte_flow_ops
1452  */
1453 static int
1454 enic_flow_validate(struct rte_eth_dev *dev, const struct rte_flow_attr *attrs,
1455                    const struct rte_flow_item pattern[],
1456                    const struct rte_flow_action actions[],
1457                    struct rte_flow_error *error)
1458 {
1459         struct filter_v2 enic_filter;
1460         struct filter_action_v2 enic_action;
1461         int ret;
1462
1463         FLOW_TRACE();
1464
1465         ret = enic_flow_parse(dev, attrs, pattern, actions, error,
1466                                &enic_filter, &enic_action);
1467         if (!ret)
1468                 enic_dump_flow(&enic_action, &enic_filter);
1469         return ret;
1470 }
1471
1472 /**
1473  * Create a flow supported by the NIC.
1474  *
1475  * @see rte_flow_create()
1476  * @see rte_flow_ops
1477  */
1478 static struct rte_flow *
1479 enic_flow_create(struct rte_eth_dev *dev,
1480                  const struct rte_flow_attr *attrs,
1481                  const struct rte_flow_item pattern[],
1482                  const struct rte_flow_action actions[],
1483                  struct rte_flow_error *error)
1484 {
1485         int ret;
1486         struct filter_v2 enic_filter;
1487         struct filter_action_v2 enic_action;
1488         struct rte_flow *flow;
1489         struct enic *enic = pmd_priv(dev);
1490
1491         FLOW_TRACE();
1492
1493         ret = enic_flow_parse(dev, attrs, pattern, actions, error, &enic_filter,
1494                               &enic_action);
1495         if (ret < 0)
1496                 return NULL;
1497
1498         rte_spinlock_lock(&enic->flows_lock);
1499         flow = enic_flow_add_filter(enic, &enic_filter, &enic_action,
1500                                     error);
1501         if (flow)
1502                 LIST_INSERT_HEAD(&enic->flows, flow, next);
1503         rte_spinlock_unlock(&enic->flows_lock);
1504
1505         return flow;
1506 }
1507
1508 /**
1509  * Destroy a flow supported by the NIC.
1510  *
1511  * @see rte_flow_destroy()
1512  * @see rte_flow_ops
1513  */
1514 static int
1515 enic_flow_destroy(struct rte_eth_dev *dev, struct rte_flow *flow,
1516                   __rte_unused struct rte_flow_error *error)
1517 {
1518         struct enic *enic = pmd_priv(dev);
1519
1520         FLOW_TRACE();
1521
1522         rte_spinlock_lock(&enic->flows_lock);
1523         enic_flow_del_filter(enic, flow->enic_filter_id, error);
1524         LIST_REMOVE(flow, next);
1525         rte_spinlock_unlock(&enic->flows_lock);
1526         return 0;
1527 }
1528
1529 /**
1530  * Flush all flows on the device.
1531  *
1532  * @see rte_flow_flush()
1533  * @see rte_flow_ops
1534  */
1535 static int
1536 enic_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
1537 {
1538         struct rte_flow *flow;
1539         struct enic *enic = pmd_priv(dev);
1540
1541         FLOW_TRACE();
1542
1543         rte_spinlock_lock(&enic->flows_lock);
1544
1545         while (!LIST_EMPTY(&enic->flows)) {
1546                 flow = LIST_FIRST(&enic->flows);
1547                 enic_flow_del_filter(enic, flow->enic_filter_id, error);
1548                 LIST_REMOVE(flow, next);
1549         }
1550         rte_spinlock_unlock(&enic->flows_lock);
1551         return 0;
1552 }
1553
1554 /**
1555  * Flow callback registration.
1556  *
1557  * @see rte_flow_ops
1558  */
1559 const struct rte_flow_ops enic_flow_ops = {
1560         .validate = enic_flow_validate,
1561         .create = enic_flow_create,
1562         .destroy = enic_flow_destroy,
1563         .flush = enic_flow_flush,
1564 };